diff --git a/lib/libc/locale/lmonetary.c b/lib/libc/locale/lmonetary.c index b8b4e78c060b..99800ae69922 100644 --- a/lib/libc/locale/lmonetary.c +++ b/lib/libc/locale/lmonetary.c @@ -1,227 +1,227 @@ /*- * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * * Copyright (c) 2000, 2001 Alexey Zelkin * All rights reserved. * * Copyright (c) 2011 The FreeBSD Foundation * All rights reserved. * Portions of this software were developed by David Chisnall * under sponsorship from the FreeBSD Foundation. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include __FBSDID("$FreeBSD$"); #include #include #include #include "ldpart.h" #include "lmonetary.h" extern const char * __fix_locale_grouping_str(const char *); #define LCMONETARY_SIZE_FULL (sizeof(struct lc_monetary_T) / sizeof(char *)) #define LCMONETARY_SIZE_MIN \ (offsetof(struct lc_monetary_T, int_p_cs_precedes) / \ sizeof(char *)) static char empty[] = ""; static char numempty[] = { CHAR_MAX, '\0'}; static const struct lc_monetary_T _C_monetary_locale = { empty, /* int_curr_symbol */ empty, /* currency_symbol */ empty, /* mon_decimal_point */ empty, /* mon_thousands_sep */ numempty, /* mon_grouping */ empty, /* positive_sign */ empty, /* negative_sign */ numempty, /* int_frac_digits */ numempty, /* frac_digits */ numempty, /* p_cs_precedes */ numempty, /* p_sep_by_space */ numempty, /* n_cs_precedes */ numempty, /* n_sep_by_space */ numempty, /* p_sign_posn */ numempty, /* n_sign_posn */ numempty, /* int_p_cs_precedes */ numempty, /* int_n_cs_precedes */ numempty, /* int_p_sep_by_space */ numempty, /* int_n_sep_by_space */ numempty, /* int_p_sign_posn */ numempty /* int_n_sign_posn */ }; struct xlocale_monetary __xlocale_global_monetary; static char cnv(const char *str) { int i = strtol(str, NULL, 10); if (i == -1) i = CHAR_MAX; return ((char)i); } static void destruct_monetary(void *v) { struct xlocale_monetary *l = v; if (l->buffer) free(l->buffer); free(l); } static int monetary_load_locale_l(struct xlocale_monetary *loc, int *using_locale, int *changed, const char *name) { int ret; struct lc_monetary_T *l = &loc->locale; ret = __part_load_locale(name, using_locale, &loc->buffer, "LC_MONETARY", LCMONETARY_SIZE_FULL, LCMONETARY_SIZE_MIN, (const char **)l); + if (ret != _LDP_ERROR) + *changed = 1; if (ret == _LDP_LOADED) { l->mon_grouping = __fix_locale_grouping_str(l->mon_grouping); #define M_ASSIGN_CHAR(NAME) (((char *)l->NAME)[0] = \ cnv(l->NAME)) M_ASSIGN_CHAR(int_frac_digits); M_ASSIGN_CHAR(frac_digits); M_ASSIGN_CHAR(p_cs_precedes); M_ASSIGN_CHAR(p_sep_by_space); M_ASSIGN_CHAR(n_cs_precedes); M_ASSIGN_CHAR(n_sep_by_space); M_ASSIGN_CHAR(p_sign_posn); M_ASSIGN_CHAR(n_sign_posn); /* * The six additional C99 international monetary formatting * parameters default to the national parameters when * reading FreeBSD LC_MONETARY data files. */ #define M_ASSIGN_ICHAR(NAME) \ do { \ if (l->int_##NAME == NULL) \ l->int_##NAME = \ l->NAME; \ else \ M_ASSIGN_CHAR(int_##NAME); \ } while (0) M_ASSIGN_ICHAR(p_cs_precedes); M_ASSIGN_ICHAR(n_cs_precedes); M_ASSIGN_ICHAR(p_sep_by_space); M_ASSIGN_ICHAR(n_sep_by_space); M_ASSIGN_ICHAR(p_sign_posn); M_ASSIGN_ICHAR(n_sign_posn); } - if (ret != _LDP_ERROR) - atomic_store_rel_int(changed, 1); return (ret); } int __monetary_load_locale(const char *name) { return monetary_load_locale_l(&__xlocale_global_monetary, &__xlocale_global_locale.using_monetary_locale, &__xlocale_global_locale.monetary_locale_changed, name); } void* __monetary_load(const char *name, locale_t l) { struct xlocale_monetary *new = calloc(sizeof(struct xlocale_monetary), 1); new->header.header.destructor = destruct_monetary; if (monetary_load_locale_l(new, &l->using_monetary_locale, &l->monetary_locale_changed, name) == _LDP_ERROR) { xlocale_release(new); return NULL; } return new; } struct lc_monetary_T * __get_current_monetary_locale(locale_t loc) { return (loc->using_monetary_locale ? &((struct xlocale_monetary*)loc->components[XLC_MONETARY])->locale : (struct lc_monetary_T *)&_C_monetary_locale); } #ifdef LOCALE_DEBUG void monetdebug() { printf( "int_curr_symbol = %s\n" "currency_symbol = %s\n" "mon_decimal_point = %s\n" "mon_thousands_sep = %s\n" "mon_grouping = %s\n" "positive_sign = %s\n" "negative_sign = %s\n" "int_frac_digits = %d\n" "frac_digits = %d\n" "p_cs_precedes = %d\n" "p_sep_by_space = %d\n" "n_cs_precedes = %d\n" "n_sep_by_space = %d\n" "p_sign_posn = %d\n" "n_sign_posn = %d\n" "int_p_cs_precedes = %d\n" "int_p_sep_by_space = %d\n" "int_n_cs_precedes = %d\n" "int_n_sep_by_space = %d\n" "int_p_sign_posn = %d\n" "int_n_sign_posn = %d\n", _monetary_locale.int_curr_symbol, _monetary_locale.currency_symbol, _monetary_locale.mon_decimal_point, _monetary_locale.mon_thousands_sep, _monetary_locale.mon_grouping, _monetary_locale.positive_sign, _monetary_locale.negative_sign, _monetary_locale.int_frac_digits[0], _monetary_locale.frac_digits[0], _monetary_locale.p_cs_precedes[0], _monetary_locale.p_sep_by_space[0], _monetary_locale.n_cs_precedes[0], _monetary_locale.n_sep_by_space[0], _monetary_locale.p_sign_posn[0], _monetary_locale.n_sign_posn[0], _monetary_locale.int_p_cs_precedes[0], _monetary_locale.int_p_sep_by_space[0], _monetary_locale.int_n_cs_precedes[0], _monetary_locale.int_n_sep_by_space[0], _monetary_locale.int_p_sign_posn[0], _monetary_locale.int_n_sign_posn[0] ); } #endif /* LOCALE_DEBUG */ diff --git a/lib/libc/locale/lnumeric.c b/lib/libc/locale/lnumeric.c index cc1daa3863e3..046d1f1817dc 100644 --- a/lib/libc/locale/lnumeric.c +++ b/lib/libc/locale/lnumeric.c @@ -1,129 +1,129 @@ /*- * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * * Copyright (c) 2000, 2001 Alexey Zelkin * All rights reserved. * * Copyright (c) 2011 The FreeBSD Foundation * All rights reserved. * Portions of this software were developed by David Chisnall * under sponsorship from the FreeBSD Foundation. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include __FBSDID("$FreeBSD$"); #include #include "ldpart.h" #include "lnumeric.h" extern const char *__fix_locale_grouping_str(const char *); #define LCNUMERIC_SIZE (sizeof(struct lc_numeric_T) / sizeof(char *)) static char numempty[] = { CHAR_MAX, '\0' }; static const struct lc_numeric_T _C_numeric_locale = { ".", /* decimal_point */ "", /* thousands_sep */ numempty /* grouping */ }; static void destruct_numeric(void *v) { struct xlocale_numeric *l = v; if (l->buffer) free(l->buffer); free(l); } struct xlocale_numeric __xlocale_global_numeric; static int numeric_load_locale(struct xlocale_numeric *loc, int *using_locale, int *changed, const char *name) { int ret; struct lc_numeric_T *l = &loc->locale; ret = __part_load_locale(name, using_locale, &loc->buffer, "LC_NUMERIC", LCNUMERIC_SIZE, LCNUMERIC_SIZE, (const char**)l); + if (ret != _LDP_ERROR) + *changed= 1; if (ret == _LDP_LOADED) { /* Can't be empty according to C99 */ if (*l->decimal_point == '\0') l->decimal_point = _C_numeric_locale.decimal_point; l->grouping = __fix_locale_grouping_str(l->grouping); } - if (ret != _LDP_ERROR) - atomic_store_rel_int(changed, 1); return (ret); } int __numeric_load_locale(const char *name) { return numeric_load_locale(&__xlocale_global_numeric, &__xlocale_global_locale.using_numeric_locale, &__xlocale_global_locale.numeric_locale_changed, name); } void * __numeric_load(const char *name, locale_t l) { struct xlocale_numeric *new = calloc(sizeof(struct xlocale_numeric), 1); new->header.header.destructor = destruct_numeric; if (numeric_load_locale(new, &l->using_numeric_locale, &l->numeric_locale_changed, name) == _LDP_ERROR) { xlocale_release(new); return NULL; } return new; } struct lc_numeric_T * __get_current_numeric_locale(locale_t loc) { return (loc->using_numeric_locale ? &((struct xlocale_numeric *)loc->components[XLC_NUMERIC])->locale : (struct lc_numeric_T *)&_C_numeric_locale); } #ifdef LOCALE_DEBUG void numericdebug(void) { printf( "decimal_point = %s\n" "thousands_sep = %s\n" "grouping = %s\n", _numeric_locale.decimal_point, _numeric_locale.thousands_sep, _numeric_locale.grouping ); } #endif /* LOCALE_DEBUG */ diff --git a/lib/libc/locale/localeconv.c b/lib/libc/locale/localeconv.c index 130f93c178f4..641773944e32 100644 --- a/lib/libc/locale/localeconv.c +++ b/lib/libc/locale/localeconv.c @@ -1,119 +1,119 @@ /*- * SPDX-License-Identifier: BSD-3-Clause * * Copyright (c) 2001 Alexey Zelkin * Copyright (c) 1991, 1993 * The Regents of the University of California. All rights reserved. * * Copyright (c) 2011 The FreeBSD Foundation * All rights reserved. * Portions of this software were developed by David Chisnall * under sponsorship from the FreeBSD Foundation. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #if defined(LIBC_SCCS) && !defined(lint) static char sccsid[] = "@(#)localeconv.c 8.1 (Berkeley) 6/4/93"; #endif /* LIBC_SCCS and not lint */ #include __FBSDID("$FreeBSD$"); #include #include "lmonetary.h" #include "lnumeric.h" /* * The localeconv() function constructs a struct lconv from the current * monetary and numeric locales. * * Because localeconv() may be called many times (especially by library * routines like printf() & strtod()), the approprate members of the * lconv structure are computed only when the monetary or numeric * locale has been changed. */ /* * Return the current locale conversion. */ struct lconv * localeconv_l(locale_t loc) { FIX_LOCALE(loc); struct lconv *ret = &loc->lconv; - if (atomic_load_acq_int(&loc->monetary_locale_changed) != 0) { + if (loc->monetary_locale_changed) { /* LC_MONETARY part */ struct lc_monetary_T * mptr; #define M_ASSIGN_STR(NAME) (ret->NAME = (char*)mptr->NAME) #define M_ASSIGN_CHAR(NAME) (ret->NAME = mptr->NAME[0]) mptr = __get_current_monetary_locale(loc); M_ASSIGN_STR(int_curr_symbol); M_ASSIGN_STR(currency_symbol); M_ASSIGN_STR(mon_decimal_point); M_ASSIGN_STR(mon_thousands_sep); M_ASSIGN_STR(mon_grouping); M_ASSIGN_STR(positive_sign); M_ASSIGN_STR(negative_sign); M_ASSIGN_CHAR(int_frac_digits); M_ASSIGN_CHAR(frac_digits); M_ASSIGN_CHAR(p_cs_precedes); M_ASSIGN_CHAR(p_sep_by_space); M_ASSIGN_CHAR(n_cs_precedes); M_ASSIGN_CHAR(n_sep_by_space); M_ASSIGN_CHAR(p_sign_posn); M_ASSIGN_CHAR(n_sign_posn); M_ASSIGN_CHAR(int_p_cs_precedes); M_ASSIGN_CHAR(int_n_cs_precedes); M_ASSIGN_CHAR(int_p_sep_by_space); M_ASSIGN_CHAR(int_n_sep_by_space); M_ASSIGN_CHAR(int_p_sign_posn); M_ASSIGN_CHAR(int_n_sign_posn); - atomic_store_int(&loc->monetary_locale_changed, 0); + loc->monetary_locale_changed = 0; } - if (atomic_load_acq_int(&loc->numeric_locale_changed) != 0) { + if (loc->numeric_locale_changed) { /* LC_NUMERIC part */ struct lc_numeric_T * nptr; #define N_ASSIGN_STR(NAME) (ret->NAME = (char*)nptr->NAME) nptr = __get_current_numeric_locale(loc); N_ASSIGN_STR(decimal_point); N_ASSIGN_STR(thousands_sep); N_ASSIGN_STR(grouping); - atomic_store_int(&loc->numeric_locale_changed, 0); + loc->numeric_locale_changed = 0; } return ret; } struct lconv * localeconv(void) { return localeconv_l(__get_locale()); }