#include "reentr.h"
+#ifdef I_WCHAR
+# include <wchar.h>
+#endif
+
/* If the environment says to, we can output debugging information during
* initialization. This is done before option parsing, and before any thread
* creation, so can be a file-level static */
-#ifdef DEBUGGING
-# ifdef PERL_GLOBAL_STRUCT
- /* no global syms allowed */
-# define debug_initialization 0
-# define DEBUG_INITIALIZATION_set(v)
-# else
+#if ! defined(DEBUGGING) || defined(PERL_GLOBAL_STRUCT)
+# define debug_initialization 0
+# define DEBUG_INITIALIZATION_set(v)
+#else
static bool debug_initialization = FALSE;
-# define DEBUG_INITIALIZATION_set(v) (debug_initialization = v)
-# endif
+# define DEBUG_INITIALIZATION_set(v) (debug_initialization = v)
#endif
-/* strlen() of a literal string constant. XXX We might want this more general,
- * but using it in just this file for now */
+/* strlen() of a literal string constant. We might want this more general,
+ * but using it in just this file for now. A problem with more generality is
+ * the compiler warnings about comparing unlike signs */
#define STRLENs(s) (sizeof("" s "") - 1)
+/* Is the C string input 'name' "C" or "POSIX"? If so, and 'name' is the
+ * return of setlocale(), then this is extremely likely to be the C or POSIX
+ * locale. However, the output of setlocale() is documented to be opaque, but
+ * the odds are extremely small that it would return these two strings for some
+ * other locale. Note that VMS in these two locales includes many non-ASCII
+ * characters as controls and punctuation (below are hex bytes):
+ * cntrl: 84-97 9B-9F
+ * punct: A1-A3 A5 A7-AB B0-B3 B5-B7 B9-BD BF-CF D1-DD DF-EF F1-FD
+ * Oddly, none there are listed as alphas, though some represent alphabetics
+ * http://www.nntp.perl.org/group/perl.perl5.porters/2013/02/msg198753.html */
+#define isNAME_C_OR_POSIX(name) \
+ ( (name) != NULL \
+ && (( *(name) == 'C' && (*(name + 1)) == '\0') \
+ || strEQ((name), "POSIX")))
+
#ifdef USE_LOCALE
-/*
- * Standardize the locale name from a string returned by 'setlocale', possibly
- * modifying that string.
- *
- * The typical return value of setlocale() is either
- * (1) "xx_YY" if the first argument of setlocale() is not LC_ALL
- * (2) "xa_YY xb_YY ..." if the first argument of setlocale() is LC_ALL
- * (the space-separated values represent the various sublocales,
- * in some unspecified order). This is not handled by this function.
+/* This code keeps a LRU cache of the UTF-8ness of the locales it has so-far
+ * looked up. This is in the form of a C string: */
+
+#define UTF8NESS_SEP "\v"
+#define UTF8NESS_PREFIX "\f"
+
+/* So, the string looks like:
*
- * In some platforms it has a form like "LC_SOMETHING=Lang_Country.866\n",
- * which is harmful for further use of the string in setlocale(). This
- * function removes the trailing new line and everything up through the '='
+ * \vC\a0\vPOSIX\a0\vam_ET\a0\vaf_ZA.utf8\a1\ven_US.UTF-8\a1\0
*
- */
+ * where the digit 0 after the \a indicates that the locale starting just
+ * after the preceding \v is not UTF-8, and the digit 1 mean it is. */
+
+STATIC_ASSERT_DECL(STRLENs(UTF8NESS_SEP) == 1);
+STATIC_ASSERT_DECL(STRLENs(UTF8NESS_PREFIX) == 1);
+
+#define C_and_POSIX_utf8ness UTF8NESS_SEP "C" UTF8NESS_PREFIX "0" \
+ UTF8NESS_SEP "POSIX" UTF8NESS_PREFIX "0"
+
+/* The cache is initialized to C_and_POSIX_utf8ness at start up. These are
+ * kept there always. The remining portion of the cache is LRU, with the
+ * oldest looked-up locale at the tail end */
+
STATIC char *
S_stdize_locale(pTHX_ char *locs)
{
+ /* Standardize the locale name from a string returned by 'setlocale',
+ * possibly modifying that string.
+ *
+ * The typical return value of setlocale() is either
+ * (1) "xx_YY" if the first argument of setlocale() is not LC_ALL
+ * (2) "xa_YY xb_YY ..." if the first argument of setlocale() is LC_ALL
+ * (the space-separated values represent the various sublocales,
+ * in some unspecified order). This is not handled by this function.
+ *
+ * In some platforms it has a form like "LC_SOMETHING=Lang_Country.866\n",
+ * which is harmful for further use of the string in setlocale(). This
+ * function removes the trailing new line and everything up through the '='
+ * */
+
const char * const s = strchr(locs, '=');
bool okay = TRUE;
# ifdef USE_LOCALE_MONETARY
LC_MONETARY,
# endif
+# ifdef USE_LOCALE_ADDRESS
+ LC_ADDRESS,
+# endif
+# ifdef USE_LOCALE_IDENTIFICATION
+ LC_IDENTIFICATION,
+# endif
+# ifdef USE_LOCALE_MEASUREMENT
+ LC_MEASUREMENT,
+# endif
+# ifdef USE_LOCALE_PAPER
+ LC_PAPER,
+# endif
+# ifdef USE_LOCALE_TELEPHONE
+ LC_TELEPHONE,
+# endif
# ifdef LC_ALL
LC_ALL,
# endif
# ifdef USE_LOCALE_MONETARY
"LC_MONETARY",
# endif
+# ifdef USE_LOCALE_ADDRESS
+ "LC_ADDRESS",
+# endif
+# ifdef USE_LOCALE_IDENTIFICATION
+ "LC_IDENTIFICATION",
+# endif
+# ifdef USE_LOCALE_MEASUREMENT
+ "LC_MEASUREMENT",
+# endif
+# ifdef USE_LOCALE_PAPER
+ "LC_PAPER",
+# endif
+# ifdef USE_LOCALE_TELEPHONE
+ "LC_TELEPHONE",
+# endif
# ifdef LC_ALL
"LC_ALL",
# endif
* special cases. Most loops through these arrays in the code below are
* written like 'for (i = 0; i < NOMINAL_LC_ALL_INDEX; i++)'. They will work
* on either type of system. But the code must be written to not access the
- * element at 'NOMINAL_LC_ALL_INDEX' except on platforms that have it. */
+ * element at 'LC_ALL_INDEX' except on platforms that have it. This can be
+ * checked for at compile time by using the #define LC_ALL_INDEX which is only
+ * defined if we do have LC_ALL. */
+
+STATIC const char *
+S_category_name(const int category)
+{
+ unsigned int i;
+
+#ifdef LC_ALL
+
+ if (category == LC_ALL) {
+ return "LC_ALL";
+ }
#endif
+ for (i = 0; i < NOMINAL_LC_ALL_INDEX; i++) {
+ if (category == categories[i]) {
+ return category_names[i];
+ }
+ }
+
+ {
+ const char suffix[] = " (unknown)";
+ int temp = category;
+ Size_t length = sizeof(suffix) + 1;
+ char * unknown;
+ dTHX;
+
+ if (temp < 0) {
+ length++;
+ temp = - temp;
+ }
+
+ /* Calculate the number of digits */
+ while (temp >= 10) {
+ temp /= 10;
+ length++;
+ }
+
+ Newx(unknown, length, char);
+ my_snprintf(unknown, length, "%d%s", category, suffix);
+ SAVEFREEPV(unknown);
+ return unknown;
+ }
+}
+
+/* Now create LC_foo_INDEX #defines for just those categories on this system */
+# ifdef USE_LOCALE_NUMERIC
+# define LC_NUMERIC_INDEX 0
+# define _DUMMY_NUMERIC LC_NUMERIC_INDEX
+# else
+# define _DUMMY_NUMERIC -1
+# endif
+# ifdef USE_LOCALE_CTYPE
+# define LC_CTYPE_INDEX _DUMMY_NUMERIC + 1
+# define _DUMMY_CTYPE LC_CTYPE_INDEX
+# else
+# define _DUMMY_CTYPE _DUMMY_NUMERIC
+# endif
+# ifdef USE_LOCALE_COLLATE
+# define LC_COLLATE_INDEX _DUMMY_CTYPE + 1
+# define _DUMMY_COLLATE LC_COLLATE_INDEX
+# else
+# define _DUMMY_COLLATE _DUMMY_COLLATE
+# endif
+# ifdef USE_LOCALE_TIME
+# define LC_TIME_INDEX _DUMMY_COLLATE + 1
+# define _DUMMY_TIME LC_TIME_INDEX
+# else
+# define _DUMMY_TIME _DUMMY_COLLATE
+# endif
+# ifdef USE_LOCALE_MESSAGES
+# define LC_MESSAGES_INDEX _DUMMY_TIME + 1
+# define _DUMMY_MESSAGES LC_MESSAGES_INDEX
+# else
+# define _DUMMY_MESSAGES _DUMMY_TIME
+# endif
+# ifdef USE_LOCALE_MONETARY
+# define LC_MONETARY_INDEX _DUMMY_MESSAGES + 1
+# define _DUMMY_MONETARY LC_MONETARY_INDEX
+# else
+# define _DUMMY_MONETARY _DUMMY_MESSAGES
+# endif
+# ifdef USE_LOCALE_ADDRESS
+# define LC_ADDRESS_INDEX _DUMMY_MONETARY + 1
+# define _DUMMY_ADDRESS LC_ADDRESS_INDEX
+# else
+# define _DUMMY_ADDRESS _DUMMY_MONETARY
+# endif
+# ifdef USE_LOCALE_IDENTIFICATION
+# define LC_IDENTIFICATION_INDEX _DUMMY_ADDRESS + 1
+# define _DUMMY_IDENTIFICATION LC_IDENTIFICATION_INDEX
+# else
+# define _DUMMY_IDENTIFICATION _DUMMY_ADDRESS
+# endif
+# ifdef USE_LOCALE_MEASUREMENT
+# define LC_MEASUREMENT_INDEX _DUMMY_IDENTIFICATION + 1
+# define _DUMMY_MEASUREMENT LC_MEASUREMENT_INDEX
+# else
+# define _DUMMY_MEASUREMENT _DUMMY_IDENTIFICATION
+# endif
+# ifdef USE_LOCALE_PAPER
+# define LC_PAPER_INDEX _DUMMY_MEASUREMENT + 1
+# define _DUMMY_PAPER LC_PAPER_INDEX
+# else
+# define _DUMMY_PAPER _DUMMY_MEASUREMENT
+# endif
+# ifdef USE_LOCALE_TELEPHONE
+# define LC_TELEPHONE_INDEX _DUMMY_PAPER + 1
+# define _DUMMY_TELEPHONE LC_TELEPHONE_INDEX
+# else
+# define _DUMMY_TELEPHONE _DUMMY_PAPER
+# endif
+# ifdef LC_ALL
+# define LC_ALL_INDEX _DUMMY_TELEPHONE + 1
+# endif
+#endif /* ifdef USE_LOCALE */
+
/* Windows requres a customized base-level setlocale() */
# ifdef WIN32
# define my_setlocale(cat, locale) win32_setlocale(cat, locale)
#if defined(USE_LOCALE_NUMERIC) && ( defined(HAS_LOCALECONV) \
|| defined(HAS_NL_LANGINFO))
- /* We only set up the radix SV if we are to use a locale radix ... */
- if (use_locale) {
- const char * radix = my_nl_langinfo(PERL_RADIXCHAR, FALSE);
- /* FALSE => already in dest locale */
+ const char * radix = (use_locale)
+ ? my_nl_langinfo(PERL_RADIXCHAR, FALSE)
+ /* FALSE => already in dest locale */
+ : ".";
- /* ... and the character being used isn't a dot */
- if (strNE(radix, ".")) {
- if (PL_numeric_radix_sv) {
- sv_setpv(PL_numeric_radix_sv, radix);
- }
- else {
- PL_numeric_radix_sv = newSVpv(radix, 0);
- }
+ sv_setpv(PL_numeric_radix_sv, radix);
- if ( ! is_utf8_invariant_string(
- (U8 *) SvPVX(PL_numeric_radix_sv), SvCUR(PL_numeric_radix_sv))
- && is_utf8_string(
- (U8 *) SvPVX(PL_numeric_radix_sv), SvCUR(PL_numeric_radix_sv))
- && _is_cur_LC_category_utf8(LC_NUMERIC))
- {
- SvUTF8_on(PL_numeric_radix_sv);
- }
- goto done;
- }
+ /* If this is valid UTF-8 that isn't totally ASCII, and we are in
+ * a UTF-8 locale, then mark the radix as being in UTF-8 */
+ if (is_utf8_non_invariant_string((U8 *) SvPVX(PL_numeric_radix_sv),
+ SvCUR(PL_numeric_radix_sv))
+ && _is_cur_LC_category_utf8(LC_NUMERIC))
+ {
+ SvUTF8_on(PL_numeric_radix_sv);
}
- SvREFCNT_dec(PL_numeric_radix_sv);
- PL_numeric_radix_sv = NULL;
-
- done: ;
-
# ifdef DEBUGGING
if (DEBUG_L_TEST || debug_initialization) {
PerlIO_printf(Perl_debug_log, "Locale radix is '%s', ?UTF-8=%d\n",
- (PL_numeric_radix_sv)
- ? SvPVX(PL_numeric_radix_sv)
- : "NULL",
- (PL_numeric_radix_sv)
- ? cBOOL(SvUTF8(PL_numeric_radix_sv))
- : 0);
+ SvPVX(PL_numeric_radix_sv),
+ cBOOL(SvUTF8(PL_numeric_radix_sv)));
}
# endif
}
-/* Is the C string input 'name' "C" or "POSIX"? If so, and 'name' is the
- * return of setlocale(), then this is extremely likely to be the C or POSIX
- * locale. However, the output of setlocale() is documented to be opaque, but
- * the odds are extremely small that it would return these two strings for some
- * other locale. Note that VMS in these two locales includes many non-ASCII
- * characters as controls and punctuation (below are hex bytes):
- * cntrl: 84-97 9B-9F
- * punct: A1-A3 A5 A7-AB B0-B3 B5-B7 B9-BD BF-CF D1-DD DF-EF F1-FD
- * Oddly, none there are listed as alphas, though some represent alphabetics
- * http://www.nntp.perl.org/group/perl.perl5.porters/2013/02/msg198753.html */
-#define isNAME_C_OR_POSIX(name) \
- ( (name) != NULL \
- && (( *(name) == 'C' && (*(name + 1)) == '\0') \
- || strEQ((name), "POSIX")))
void
Perl_new_numeric(pTHX_ const char *newnum)
#else
- /* Called after all libc setlocale() calls affecting LC_NUMERIC, to tell
+ /* Called after each libc setlocale() call affecting LC_NUMERIC, to tell
* core Perl this and that 'newnum' is the name of the new locale.
* It installs this locale as the current underlying default.
*
* that the current locale is the program's underlying
* locale
* PL_numeric_standard An int indicating if the toggled state is such
- * that the current locale is the C locale. If non-zero,
- * it is in C; if > 1, it means it may not be toggled away
+ * that the current locale is the C locale or
+ * indistinguishable from the C locale. If non-zero, it
+ * is in C; if > 1, it means it may not be toggled away
* from C.
- * Note that both of the last two variables can be true at the same time,
- * if the underlying locale is C. (Toggling is a no-op under these
- * circumstances.)
- *
+ * PL_numeric_underlying_is_standard A bool kept by this function
+ * indicating that the underlying locale and the standard
+ * C locale are indistinguishable for the purposes of
+ * LC_NUMERIC. This happens when both of the above two
+ * variables are true at the same time. (Toggling is a
+ * no-op under these circumstances.) This variable is
+ * used to avoid having to recalculate.
* Any code changing the locale (outside this file) should use
* POSIX::setlocale, which calls this function. Therefore this function
* should be called directly only from this file and from
PL_numeric_name = NULL;
PL_numeric_standard = TRUE;
PL_numeric_underlying = TRUE;
+ PL_numeric_underlying_is_standard = TRUE;
return;
}
save_newnum = stdize_locale(savepv(newnum));
-
- PL_numeric_standard = isNAME_C_OR_POSIX(save_newnum);
PL_numeric_underlying = TRUE;
+ PL_numeric_standard = isNAME_C_OR_POSIX(save_newnum);
+
+ /* If its name isn't C nor POSIX, it could still be indistinguishable from
+ * them */
+ if (! PL_numeric_standard) {
+ PL_numeric_standard = cBOOL(strEQ(".", my_nl_langinfo(PERL_RADIXCHAR,
+ FALSE /* Don't toggle locale */ ))
+ && strEQ("", my_nl_langinfo(PERL_THOUSEP,
+ FALSE)));
+ }
+ /* Save the new name if it isn't the same as the previous one, if any */
if (! PL_numeric_name || strNE(PL_numeric_name, save_newnum)) {
Safefree(PL_numeric_name);
PL_numeric_name = save_newnum;
Safefree(save_newnum);
}
+ PL_numeric_underlying_is_standard = PL_numeric_standard;
+
+# if defined(HAS_NEWLOCALE) && ! defined(NO_POSIX_2008_LOCALE)
+
+ PL_underlying_numeric_obj = newlocale(LC_NUMERIC_MASK,
+ PL_numeric_name,
+ PL_underlying_numeric_obj);
+
+#endif
+
+ if (DEBUG_L_TEST || debug_initialization) {
+ PerlIO_printf(Perl_debug_log, "Called new_numeric with %s, PL_numeric_name=%s\n", newnum, PL_numeric_name);
+ }
+
/* Keep LC_NUMERIC in the C locale. This is for XS modules, so they don't
* have to worry about the radix being a non-dot. (Core operations that
* need the underlying locale change to it temporarily). */
do_setlocale_c(LC_NUMERIC, "C");
PL_numeric_standard = TRUE;
- PL_numeric_underlying = isNAME_C_OR_POSIX(PL_numeric_name);
+ PL_numeric_underlying = PL_numeric_underlying_is_standard;
set_numeric_radix(0);
# ifdef DEBUGGING
* wrong if some XS code has changed the locale behind our back) */
do_setlocale_c(LC_NUMERIC, PL_numeric_name);
- PL_numeric_standard = isNAME_C_OR_POSIX(PL_numeric_name);
+ PL_numeric_standard = PL_numeric_underlying_is_standard;
PL_numeric_underlying = TRUE;
- set_numeric_radix(1);
+ set_numeric_radix(! PL_numeric_standard);
# ifdef DEBUGGING
#else
- /* Called after all libc setlocale() calls affecting LC_CTYPE, to tell
+ /* Called after each libc setlocale() call affecting LC_CTYPE, to tell
* core Perl this and that 'newctype' is the name of the new locale.
*
* This function sets up the folding arrays for all 256 bytes, assuming
unsigned int bad_count = 0; /* Count of bad characters */
for (i = 0; i < 256; i++) {
- if (isUPPER_LC((U8) i))
- PL_fold_locale[i] = (U8) toLOWER_LC((U8) i);
- else if (isLOWER_LC((U8) i))
- PL_fold_locale[i] = (U8) toUPPER_LC((U8) i);
+ if (isupper(i))
+ PL_fold_locale[i] = (U8) tolower(i);
+ else if (islower(i))
+ PL_fold_locale[i] = (U8) toupper(i);
else
PL_fold_locale[i] = (U8) i;
if ( check_for_problems
&& (isGRAPH_A(i) || isBLANK_A(i) || i == '\n'))
{
- if (( isALPHANUMERIC_A(i) && ! isALPHANUMERIC_LC(i))
- || (isPUNCT_A(i) && ! isPUNCT_LC(i))
- || (isBLANK_A(i) && ! isBLANK_LC(i))
- || (i == '\n' && ! isCNTRL_LC(i)))
+ if ( cBOOL(isalnum(i)) != cBOOL(isALPHANUMERIC(i))
+ || cBOOL(isalpha(i)) != cBOOL(isALPHA_A(i))
+ || cBOOL(isdigit(i)) != cBOOL(isDIGIT_A(i))
+ || cBOOL(isgraph(i)) != cBOOL(isGRAPH_A(i))
+ || cBOOL(islower(i)) != cBOOL(isLOWER_A(i))
+ || cBOOL(isprint(i)) != cBOOL(isPRINT_A(i))
+ || cBOOL(ispunct(i)) != cBOOL(isPUNCT_A(i))
+ || cBOOL(isspace(i)) != cBOOL(isSPACE_A(i))
+ || cBOOL(isupper(i)) != cBOOL(isUPPER_A(i))
+ || cBOOL(isxdigit(i))!= cBOOL(isXDIGIT_A(i))
+ || tolower(i) != (int) toLOWER_A(i)
+ || toupper(i) != (int) toUPPER_A(i)
+ || (i == '\n' && ! isCNTRL_LC(i)))
{
if (bad_count) { /* Separate multiple entries with a
blank */
* _CHECK_AND_WARN_PROBLEMATIC_LOCALE */
if (PL_warn_locale) {
- /*GCC_DIAG_IGNORE(-Wformat-security); Didn't work */
Perl_ck_warner(aTHX_ packWARN(WARN_LOCALE),
SvPVX(PL_warn_locale),
0 /* dummy to avoid compiler warning */ );
- /* GCC_DIAG_RESTORE; */
SvREFCNT_dec_NN(PL_warn_locale);
PL_warn_locale = NULL;
}
#else
- /* Called after all libc setlocale() calls affecting LC_COLLATE, to tell
+ /* Called after each libc setlocale() call affecting LC_COLLATE, to tell
* core Perl this and that 'newcoll' is the name of the new locale.
*
* The design of locale collation is that every locale change is given an
* one that is set. (If they are set to "", it means to use the same thing
* we just set LC_ALL to, so can skip) */
- for (i = 0; i < NOMINAL_LC_ALL_INDEX; i++) {
+ for (i = 0; i < LC_ALL_INDEX; i++) {
result = PerlEnv_getenv(category_names[i]);
if (result && strNE(result, "")) {
setlocale(categories[i], result);
#ifdef USE_LOCALE_NUMERIC
- /* A NULL locale means only query what the current one is. We
- * have the LC_NUMERIC name saved, because we are normally switched
- * into the C locale for it. Switch back so an LC_ALL query will yield
- * the correct results; all other categories don't require special
- * handling */
+ /* A NULL locale means only query what the current one is. We have the
+ * LC_NUMERIC name saved, because we are normally switched into the C
+ * locale for it. For an LC_ALL query, switch back to get the correct
+ * results. All other categories don't require special handling */
if (locale == NULL) {
if (category == LC_NUMERIC) {
return savepv(PL_numeric_name);
# ifdef LC_ALL
- else if (category == LC_ALL) {
+ else if (category == LC_ALL && ! PL_numeric_underlying) {
+
SET_NUMERIC_UNDERLYING();
}
=item C<YESEXPR>
+=item C<YESSTR>
+
=item C<NOEXPR>
-Only the values for English are returned. Earlier POSIX standards also
-specified C<YESSTR> and C<NOSTR>, but these have been removed from POSIX 2008,
-and aren't supported by C<Perl_langinfo>.
+=item C<NOSTR>
+
+Only the values for English are returned. C<YESSTR> and C<NOSTR> have been
+removed from POSIX 2008, and are retained for backwards compatibility. Your
+platform's C<nl_langinfo> may not support them.
=item C<D_FMT>
{
dTHX;
+ /* We only need to toggle into the underlying LC_NUMERIC locale for these
+ * two items, and only if not already there */
+ if (toggle && (( item != PERL_RADIXCHAR && item != PERL_THOUSEP)
+ || PL_numeric_underlying))
+ {
+ toggle = FALSE;
+ }
+
#if defined(HAS_NL_LANGINFO) /* nl_langinfo() is available. */
#if ! defined(HAS_POSIX_2008_LOCALE)
* switching back, as some systems destroy the buffer when setlocale() is
* called */
- LOCALE_LOCK;
+ {
+ DECLARATION_FOR_LC_NUMERIC_MANIPULATION;
- if (toggle) {
- if (item == PERL_RADIXCHAR || item == PERL_THOUSEP) {
- do_setlocale_c(LC_NUMERIC, PL_numeric_name);
- }
- else {
- toggle = FALSE;
+ if (toggle) {
+ STORE_LC_NUMERIC_FORCE_TO_UNDERLYING();
}
- }
- save_to_buffer(nl_langinfo(item), &PL_langinfo_buf, &PL_langinfo_bufsize, 0);
+ LOCALE_LOCK; /* Prevent interference from another thread executing
+ this code section (the only call to nl_langinfo in
+ the core) */
- if (toggle) {
- do_setlocale_c(LC_NUMERIC, "C");
- }
+ save_to_buffer(nl_langinfo(item), &PL_langinfo_buf,
+ &PL_langinfo_bufsize, 0);
- LOCALE_UNLOCK;
+ LOCALE_UNLOCK;
- return PL_langinfo_buf;
+ if (toggle) {
+ RESTORE_LC_NUMERIC();
+ }
+ }
# else /* Use nl_langinfo_l(), avoiding both a mutex and changing the locale */
- bool do_free = FALSE;
- locale_t cur = uselocale((locale_t) 0);
+ {
+ bool do_free = FALSE;
+ locale_t cur = uselocale((locale_t) 0);
- if (cur == LC_GLOBAL_LOCALE) {
- cur = duplocale(LC_GLOBAL_LOCALE);
- do_free = TRUE;
- }
+ if (cur == LC_GLOBAL_LOCALE) {
+ cur = duplocale(LC_GLOBAL_LOCALE);
+ do_free = TRUE;
+ }
- if ( toggle
- && (item == PERL_RADIXCHAR || item == PERL_THOUSEP))
- {
- cur = newlocale(LC_NUMERIC_MASK, PL_numeric_name, cur);
- do_free = TRUE;
+ if (toggle) {
+ if (PL_underlying_numeric_obj) {
+ cur = PL_underlying_numeric_obj;
+ }
+ else {
+ cur = newlocale(LC_NUMERIC_MASK, PL_numeric_name, cur);
+ do_free = TRUE;
+ }
+ }
+
+ save_to_buffer(nl_langinfo_l(item, cur),
+ &PL_langinfo_buf, &PL_langinfo_bufsize, 0);
+ if (do_free) {
+ freelocale(cur);
+ }
}
- save_to_buffer(nl_langinfo_l(item, cur),
- &PL_langinfo_buf, &PL_langinfo_bufsize, 0);
- if (do_free) {
- freelocale(cur);
+# endif
+
+ if (strEQ(PL_langinfo_buf, "")) {
+ if (item == PERL_YESSTR) {
+ return "yes";
+ }
+ if (item == PERL_NOSTR) {
+ return "no";
+ }
}
return PL_langinfo_buf;
-# endif
#else /* Below, emulate nl_langinfo as best we can */
+
+ {
+
# ifdef HAS_LOCALECONV
- const struct lconv* lc;
+ const struct lconv* lc;
+ DECLARATION_FOR_LC_NUMERIC_MANIPULATION;
# endif
# ifdef HAS_STRFTIME
- struct tm tm;
- bool return_format = FALSE; /* Return the %format, not the value */
- const char * format;
+ struct tm tm;
+ bool return_format = FALSE; /* Return the %format, not the value */
+ const char * format;
# endif
- /* We copy the results to a per-thread buffer, even if not multi-threaded.
- * This is in part to simplify this code, and partly because we need a
- * buffer anyway for strftime(), and partly because a call of localeconv()
- * could otherwise wipe out the buffer, and the programmer would not be
- * expecting this, as this is a nl_langinfo() substitute after all, so s/he
- * might be thinking their localeconv() is safe until another localeconv()
- * call. */
+ /* We copy the results to a per-thread buffer, even if not
+ * multi-threaded. This is in part to simplify this code, and partly
+ * because we need a buffer anyway for strftime(), and partly because a
+ * call of localeconv() could otherwise wipe out the buffer, and the
+ * programmer would not be expecting this, as this is a nl_langinfo()
+ * substitute after all, so s/he might be thinking their localeconv()
+ * is safe until another localeconv() call. */
- switch (item) {
- Size_t len;
- const char * retval;
+ switch (item) {
+ Size_t len;
+ const char * retval;
- /* These 2 are unimplemented */
- case PERL_CODESET:
- case PERL_ERA: /* For use with strftime() %E modifier */
+ /* These 2 are unimplemented */
+ case PERL_CODESET:
+ case PERL_ERA: /* For use with strftime() %E modifier */
- default:
- return "";
+ default:
+ return "";
- /* We use only an English set, since we don't know any more */
- case PERL_YESEXPR: return "^[+1yY]";
- case PERL_NOEXPR: return "^[-0nN]";
+ /* We use only an English set, since we don't know any more */
+ case PERL_YESEXPR: return "^[+1yY]";
+ case PERL_YESSTR: return "yes";
+ case PERL_NOEXPR: return "^[-0nN]";
+ case PERL_NOSTR: return "no";
# ifdef HAS_LOCALECONV
- case PERL_CRNCYSTR:
+ case PERL_CRNCYSTR:
- LOCALE_LOCK;
+ /* We don't bother with localeconv_l() because any system that
+ * has it is likely to also have nl_langinfo() */
- lc = localeconv();
- if (! lc || ! lc->currency_symbol || strEQ("", lc->currency_symbol))
- {
- LOCALE_UNLOCK;
- return "";
- }
+ LOCALE_LOCK; /* Prevent interference with other threads
+ using localeconv() */
- /* Leave the first spot empty to be filled in below */
- save_to_buffer(lc->currency_symbol, &PL_langinfo_buf,
- &PL_langinfo_bufsize, 1);
- if (lc->mon_decimal_point && strEQ(lc->mon_decimal_point, ""))
- { /* khw couldn't figure out how the localedef specifications
- would show that the $ should replace the radix; this is
- just a guess as to how it might work.*/
- *PL_langinfo_buf = '.';
- }
- else if (lc->p_cs_precedes) {
- *PL_langinfo_buf = '-';
- }
- else {
- *PL_langinfo_buf = '+';
- }
+ lc = localeconv();
+ if ( ! lc
+ || ! lc->currency_symbol
+ || strEQ("", lc->currency_symbol))
+ {
+ LOCALE_UNLOCK;
+ return "";
+ }
- LOCALE_UNLOCK;
- break;
+ /* Leave the first spot empty to be filled in below */
+ save_to_buffer(lc->currency_symbol, &PL_langinfo_buf,
+ &PL_langinfo_bufsize, 1);
+ if (lc->mon_decimal_point && strEQ(lc->mon_decimal_point, ""))
+ { /* khw couldn't figure out how the localedef specifications
+ would show that the $ should replace the radix; this is
+ just a guess as to how it might work.*/
+ *PL_langinfo_buf = '.';
+ }
+ else if (lc->p_cs_precedes) {
+ *PL_langinfo_buf = '-';
+ }
+ else {
+ *PL_langinfo_buf = '+';
+ }
- case PERL_RADIXCHAR:
- case PERL_THOUSEP:
+ LOCALE_UNLOCK;
+ break;
- LOCALE_LOCK;
+ case PERL_RADIXCHAR:
+ case PERL_THOUSEP:
- if (toggle) {
- do_setlocale_c(LC_NUMERIC, PL_numeric_name);
- }
+ if (toggle) {
+ STORE_LC_NUMERIC_FORCE_TO_UNDERLYING();
+ }
- lc = localeconv();
- if (! lc) {
- retval = "";
- }
- else switch (item) {
- case PERL_RADIXCHAR:
- if (! lc->decimal_point) {
- retval = "";
- }
- else {
- retval = lc->decimal_point;
- }
- break;
+ LOCALE_LOCK; /* Prevent interference with other threads
+ using localeconv() */
- case PERL_THOUSEP:
- if (! lc->thousands_sep || strEQ("", lc->thousands_sep)) {
+ lc = localeconv();
+ if (! lc) {
+ retval = "";
+ }
+ else {
+ retval = (item == PERL_RADIXCHAR)
+ ? lc->decimal_point
+ : lc->thousands_sep;
+ if (! retval) {
retval = "";
}
- else {
- retval = lc->thousands_sep;
- }
- break;
-
- default:
- LOCALE_UNLOCK;
- Perl_croak(aTHX_ "panic: %s: %d: switch case: %d problem",
- __FILE__, __LINE__, item);
- }
+ }
- save_to_buffer(retval, &PL_langinfo_buf, &PL_langinfo_bufsize, 0);
+ save_to_buffer(retval, &PL_langinfo_buf,
+ &PL_langinfo_bufsize, 0);
- if (toggle) {
- do_setlocale_c(LC_NUMERIC, "C");
- }
+ LOCALE_UNLOCK;
- LOCALE_UNLOCK;
+ if (toggle) {
+ RESTORE_LC_NUMERIC();
+ }
- break;
+ break;
# endif
# ifdef HAS_STRFTIME
- /* These are defined by C89, so we assume that strftime supports them,
- * and so are returned unconditionally; they may not be what the locale
- * actually says, but should give good enough results for someone using
- * them as formats (as opposed to trying to parse them to figure out
- * what the locale says). The other format items are actually tested to
- * verify they work on the platform */
- case PERL_D_FMT: return "%x";
- case PERL_T_FMT: return "%X";
- case PERL_D_T_FMT: return "%c";
-
- /* These formats are only available in later strfmtime's */
- case PERL_ERA_D_FMT: case PERL_ERA_T_FMT: case PERL_ERA_D_T_FMT:
- case PERL_T_FMT_AMPM:
-
- /* The rest can be gotten from most versions of strftime(). */
- case PERL_ABDAY_1: case PERL_ABDAY_2: case PERL_ABDAY_3:
- case PERL_ABDAY_4: case PERL_ABDAY_5: case PERL_ABDAY_6:
- case PERL_ABDAY_7:
- case PERL_ALT_DIGITS:
- case PERL_AM_STR: case PERL_PM_STR:
- case PERL_ABMON_1: case PERL_ABMON_2: case PERL_ABMON_3:
- case PERL_ABMON_4: case PERL_ABMON_5: case PERL_ABMON_6:
- case PERL_ABMON_7: case PERL_ABMON_8: case PERL_ABMON_9:
- case PERL_ABMON_10: case PERL_ABMON_11: case PERL_ABMON_12:
- case PERL_DAY_1: case PERL_DAY_2: case PERL_DAY_3: case PERL_DAY_4:
- case PERL_DAY_5: case PERL_DAY_6: case PERL_DAY_7:
- case PERL_MON_1: case PERL_MON_2: case PERL_MON_3: case PERL_MON_4:
- case PERL_MON_5: case PERL_MON_6: case PERL_MON_7: case PERL_MON_8:
- case PERL_MON_9: case PERL_MON_10: case PERL_MON_11: case PERL_MON_12:
-
- LOCALE_LOCK;
-
- init_tm(&tm); /* Precaution against core dumps */
- tm.tm_sec = 30;
- tm.tm_min = 30;
- tm.tm_hour = 6;
- tm.tm_year = 2017 - 1900;
- tm.tm_wday = 0;
- tm.tm_mon = 0;
- switch (item) {
- default:
- LOCALE_UNLOCK;
- Perl_croak(aTHX_ "panic: %s: %d: switch case: %d problem",
- __FILE__, __LINE__, item);
- NOT_REACHED; /* NOTREACHED */
-
- case PERL_PM_STR: tm.tm_hour = 18;
- case PERL_AM_STR:
- format = "%p";
- break;
-
- case PERL_ABDAY_7: tm.tm_wday++;
- case PERL_ABDAY_6: tm.tm_wday++;
- case PERL_ABDAY_5: tm.tm_wday++;
- case PERL_ABDAY_4: tm.tm_wday++;
- case PERL_ABDAY_3: tm.tm_wday++;
- case PERL_ABDAY_2: tm.tm_wday++;
- case PERL_ABDAY_1:
- format = "%a";
- break;
-
- case PERL_DAY_7: tm.tm_wday++;
- case PERL_DAY_6: tm.tm_wday++;
- case PERL_DAY_5: tm.tm_wday++;
- case PERL_DAY_4: tm.tm_wday++;
- case PERL_DAY_3: tm.tm_wday++;
- case PERL_DAY_2: tm.tm_wday++;
- case PERL_DAY_1:
- format = "%A";
- break;
-
- case PERL_ABMON_12: tm.tm_mon++;
- case PERL_ABMON_11: tm.tm_mon++;
- case PERL_ABMON_10: tm.tm_mon++;
- case PERL_ABMON_9: tm.tm_mon++;
- case PERL_ABMON_8: tm.tm_mon++;
- case PERL_ABMON_7: tm.tm_mon++;
- case PERL_ABMON_6: tm.tm_mon++;
- case PERL_ABMON_5: tm.tm_mon++;
- case PERL_ABMON_4: tm.tm_mon++;
- case PERL_ABMON_3: tm.tm_mon++;
- case PERL_ABMON_2: tm.tm_mon++;
- case PERL_ABMON_1:
- format = "%b";
- break;
-
- case PERL_MON_12: tm.tm_mon++;
- case PERL_MON_11: tm.tm_mon++;
- case PERL_MON_10: tm.tm_mon++;
- case PERL_MON_9: tm.tm_mon++;
- case PERL_MON_8: tm.tm_mon++;
- case PERL_MON_7: tm.tm_mon++;
- case PERL_MON_6: tm.tm_mon++;
- case PERL_MON_5: tm.tm_mon++;
- case PERL_MON_4: tm.tm_mon++;
- case PERL_MON_3: tm.tm_mon++;
- case PERL_MON_2: tm.tm_mon++;
- case PERL_MON_1:
- format = "%B";
- break;
+ /* These are defined by C89, so we assume that strftime supports
+ * them, and so are returned unconditionally; they may not be what
+ * the locale actually says, but should give good enough results
+ * for someone using them as formats (as opposed to trying to parse
+ * them to figure out what the locale says). The other format
+ * items are actually tested to verify they work on the platform */
+ case PERL_D_FMT: return "%x";
+ case PERL_T_FMT: return "%X";
+ case PERL_D_T_FMT: return "%c";
+
+ /* These formats are only available in later strfmtime's */
+ case PERL_ERA_D_FMT: case PERL_ERA_T_FMT: case PERL_ERA_D_T_FMT:
+ case PERL_T_FMT_AMPM:
+
+ /* The rest can be gotten from most versions of strftime(). */
+ case PERL_ABDAY_1: case PERL_ABDAY_2: case PERL_ABDAY_3:
+ case PERL_ABDAY_4: case PERL_ABDAY_5: case PERL_ABDAY_6:
+ case PERL_ABDAY_7:
+ case PERL_ALT_DIGITS:
+ case PERL_AM_STR: case PERL_PM_STR:
+ case PERL_ABMON_1: case PERL_ABMON_2: case PERL_ABMON_3:
+ case PERL_ABMON_4: case PERL_ABMON_5: case PERL_ABMON_6:
+ case PERL_ABMON_7: case PERL_ABMON_8: case PERL_ABMON_9:
+ case PERL_ABMON_10: case PERL_ABMON_11: case PERL_ABMON_12:
+ case PERL_DAY_1: case PERL_DAY_2: case PERL_DAY_3: case PERL_DAY_4:
+ case PERL_DAY_5: case PERL_DAY_6: case PERL_DAY_7:
+ case PERL_MON_1: case PERL_MON_2: case PERL_MON_3: case PERL_MON_4:
+ case PERL_MON_5: case PERL_MON_6: case PERL_MON_7: case PERL_MON_8:
+ case PERL_MON_9: case PERL_MON_10: case PERL_MON_11:
+ case PERL_MON_12:
+
+ LOCALE_LOCK;
+
+ init_tm(&tm); /* Precaution against core dumps */
+ tm.tm_sec = 30;
+ tm.tm_min = 30;
+ tm.tm_hour = 6;
+ tm.tm_year = 2017 - 1900;
+ tm.tm_wday = 0;
+ tm.tm_mon = 0;
+ switch (item) {
+ default:
+ LOCALE_UNLOCK;
+ Perl_croak(aTHX_
+ "panic: %s: %d: switch case: %d problem",
+ __FILE__, __LINE__, item);
+ NOT_REACHED; /* NOTREACHED */
+
+ case PERL_PM_STR: tm.tm_hour = 18;
+ case PERL_AM_STR:
+ format = "%p";
+ break;
+
+ case PERL_ABDAY_7: tm.tm_wday++;
+ case PERL_ABDAY_6: tm.tm_wday++;
+ case PERL_ABDAY_5: tm.tm_wday++;
+ case PERL_ABDAY_4: tm.tm_wday++;
+ case PERL_ABDAY_3: tm.tm_wday++;
+ case PERL_ABDAY_2: tm.tm_wday++;
+ case PERL_ABDAY_1:
+ format = "%a";
+ break;
+
+ case PERL_DAY_7: tm.tm_wday++;
+ case PERL_DAY_6: tm.tm_wday++;
+ case PERL_DAY_5: tm.tm_wday++;
+ case PERL_DAY_4: tm.tm_wday++;
+ case PERL_DAY_3: tm.tm_wday++;
+ case PERL_DAY_2: tm.tm_wday++;
+ case PERL_DAY_1:
+ format = "%A";
+ break;
+
+ case PERL_ABMON_12: tm.tm_mon++;
+ case PERL_ABMON_11: tm.tm_mon++;
+ case PERL_ABMON_10: tm.tm_mon++;
+ case PERL_ABMON_9: tm.tm_mon++;
+ case PERL_ABMON_8: tm.tm_mon++;
+ case PERL_ABMON_7: tm.tm_mon++;
+ case PERL_ABMON_6: tm.tm_mon++;
+ case PERL_ABMON_5: tm.tm_mon++;
+ case PERL_ABMON_4: tm.tm_mon++;
+ case PERL_ABMON_3: tm.tm_mon++;
+ case PERL_ABMON_2: tm.tm_mon++;
+ case PERL_ABMON_1:
+ format = "%b";
+ break;
+
+ case PERL_MON_12: tm.tm_mon++;
+ case PERL_MON_11: tm.tm_mon++;
+ case PERL_MON_10: tm.tm_mon++;
+ case PERL_MON_9: tm.tm_mon++;
+ case PERL_MON_8: tm.tm_mon++;
+ case PERL_MON_7: tm.tm_mon++;
+ case PERL_MON_6: tm.tm_mon++;
+ case PERL_MON_5: tm.tm_mon++;
+ case PERL_MON_4: tm.tm_mon++;
+ case PERL_MON_3: tm.tm_mon++;
+ case PERL_MON_2: tm.tm_mon++;
+ case PERL_MON_1:
+ format = "%B";
+ break;
+
+ case PERL_T_FMT_AMPM:
+ format = "%r";
+ return_format = TRUE;
+ break;
+
+ case PERL_ERA_D_FMT:
+ format = "%Ex";
+ return_format = TRUE;
+ break;
+
+ case PERL_ERA_T_FMT:
+ format = "%EX";
+ return_format = TRUE;
+ break;
+
+ case PERL_ERA_D_T_FMT:
+ format = "%Ec";
+ return_format = TRUE;
+ break;
+
+ case PERL_ALT_DIGITS:
+ tm.tm_wday = 0;
+ format = "%Ow"; /* Find the alternate digit for 0 */
+ break;
+ }
- case PERL_T_FMT_AMPM:
- format = "%r";
- return_format = TRUE;
- break;
+ /* We can't use my_strftime() because it doesn't look at
+ * tm_wday */
+ while (0 == strftime(PL_langinfo_buf, PL_langinfo_bufsize,
+ format, &tm))
+ {
+ /* A zero return means one of:
+ * a) there wasn't enough space in PL_langinfo_buf
+ * b) the format, like a plain %p, returns empty
+ * c) it was an illegal format, though some
+ * implementations of strftime will just return the
+ * illegal format as a plain character sequence.
+ *
+ * To quickly test for case 'b)', try again but precede
+ * the format with a plain character. If that result is
+ * still empty, the problem is either 'a)' or 'c)' */
+
+ Size_t format_size = strlen(format) + 1;
+ Size_t mod_size = format_size + 1;
+ char * mod_format;
+ char * temp_result;
+
+ Newx(mod_format, mod_size, char);
+ Newx(temp_result, PL_langinfo_bufsize, char);
+ *mod_format = ' ';
+ my_strlcpy(mod_format + 1, format, mod_size);
+ len = strftime(temp_result,
+ PL_langinfo_bufsize,
+ mod_format, &tm);
+ Safefree(mod_format);
+ Safefree(temp_result);
+
+ /* If 'len' is non-zero, it means that we had a case like
+ * %p which means the current locale doesn't use a.m. or
+ * p.m., and that is valid */
+ if (len == 0) {
+
+ /* Here, still didn't work. If we get well beyond a
+ * reasonable size, bail out to prevent an infinite
+ * loop. */
+
+ if (PL_langinfo_bufsize > 100 * format_size) {
+ *PL_langinfo_buf = '\0';
+ }
+ else {
+ /* Double the buffer size to retry; Add 1 in case
+ * original was 0, so we aren't stuck at 0. */
+ PL_langinfo_bufsize *= 2;
+ PL_langinfo_bufsize++;
+ Renew(PL_langinfo_buf, PL_langinfo_bufsize, char);
+ continue;
+ }
+ }
- case PERL_ERA_D_FMT:
- format = "%Ex";
- return_format = TRUE;
break;
+ }
- case PERL_ERA_T_FMT:
- format = "%EX";
- return_format = TRUE;
- break;
+ /* Here, we got a result.
+ *
+ * If the item is 'ALT_DIGITS', PL_langinfo_buf contains the
+ * alternate format for wday 0. If the value is the same as
+ * the normal 0, there isn't an alternate, so clear the buffer.
+ * */
+ if ( item == PERL_ALT_DIGITS
+ && strEQ(PL_langinfo_buf, "0"))
+ {
+ *PL_langinfo_buf = '\0';
+ }
- case PERL_ERA_D_T_FMT:
- format = "%Ec";
- return_format = TRUE;
- break;
+ /* ALT_DIGITS is problematic. Experiments on it showed that
+ * strftime() did not always work properly when going from
+ * alt-9 to alt-10. Only a few locales have this item defined,
+ * and in all of them on Linux that khw was able to find,
+ * nl_langinfo() merely returned the alt-0 character, possibly
+ * doubled. Most Unicode digits are in blocks of 10
+ * consecutive code points, so that is sufficient information
+ * for those scripts, as we can infer alt-1, alt-2, .... But
+ * for a Japanese locale, a CJK ideographic 0 is returned, and
+ * the CJK digits are not in code point order, so you can't
+ * really infer anything. The localedef for this locale did
+ * specify the succeeding digits, so that strftime() works
+ * properly on them, without needing to infer anything. But
+ * the nl_langinfo() return did not give sufficient information
+ * for the caller to understand what's going on. So until
+ * there is evidence that it should work differently, this
+ * returns the alt-0 string for ALT_DIGITS.
+ *
+ * wday was chosen because its range is all a single digit.
+ * Things like tm_sec have two digits as the minimum: '00' */
- case PERL_ALT_DIGITS:
- tm.tm_wday = 0;
- format = "%Ow"; /* Find the alternate digit for 0 */
- break;
- }
+ LOCALE_UNLOCK;
- /* We can't use my_strftime() because it doesn't look at tm_wday */
- while (0 == strftime(PL_langinfo_buf, PL_langinfo_bufsize,
- format, &tm))
- {
- /* A zero return means one of:
- * a) there wasn't enough space in PL_langinfo_buf
- * b) the format, like a plain %p, returns empty
- * c) it was an illegal format, though some implementations of
- * strftime will just return the illegal format as a plain
- * character sequence.
- *
- * To quickly test for case 'b)', try again but precede the
- * format with a plain character. If that result is still
- * empty, the problem is either 'a)' or 'c)' */
-
- Size_t format_size = strlen(format) + 1;
- Size_t mod_size = format_size + 1;
- char * mod_format;
- char * temp_result;
-
- Newx(mod_format, mod_size, char);
- Newx(temp_result, PL_langinfo_bufsize, char);
- *mod_format = '\a';
- my_strlcpy(mod_format + 1, format, mod_size);
- len = strftime(temp_result,
- PL_langinfo_bufsize,
- mod_format, &tm);
- Safefree(mod_format);
- Safefree(temp_result);
-
- /* If 'len' is non-zero, it means that we had a case like %p
- * which means the current locale doesn't use a.m. or p.m., and
- * that is valid */
- if (len == 0) {
-
- /* Here, still didn't work. If we get well beyond a
- * reasonable size, bail out to prevent an infinite loop. */
-
- if (PL_langinfo_bufsize > 100 * format_size) {
+ /* If to return the format, not the value, overwrite the buffer
+ * with it. But some strftime()s will keep the original format
+ * if illegal, so change those to "" */
+ if (return_format) {
+ if (strEQ(PL_langinfo_buf, format)) {
*PL_langinfo_buf = '\0';
}
- else { /* Double the buffer size to retry; Add 1 in case
- original was 0, so we aren't stuck at 0. */
- PL_langinfo_bufsize *= 2;
- PL_langinfo_bufsize++;
- Renew(PL_langinfo_buf, PL_langinfo_bufsize, char);
- continue;
+ else {
+ save_to_buffer(format, &PL_langinfo_buf,
+ &PL_langinfo_bufsize, 0);
}
}
break;
- }
-
- /* Here, we got a result.
- *
- * If the item is 'ALT_DIGITS', PL_langinfo_buf contains the
- * alternate format for wday 0. If the value is the same as the
- * normal 0, there isn't an alternate, so clear the buffer. */
- if ( item == PERL_ALT_DIGITS
- && strEQ(PL_langinfo_buf, "0"))
- {
- *PL_langinfo_buf = '\0';
- }
-
- /* ALT_DIGITS is problematic. Experiments on it showed that
- * strftime() did not always work properly when going from alt-9 to
- * alt-10. Only a few locales have this item defined, and in all
- * of them on Linux that khw was able to find, nl_langinfo() merely
- * returned the alt-0 character, possibly doubled. Most Unicode
- * digits are in blocks of 10 consecutive code points, so that is
- * sufficient information for those scripts, as we can infer alt-1,
- * alt-2, .... But for a Japanese locale, a CJK ideographic 0 is
- * returned, and the CJK digits are not in code point order, so you
- * can't really infer anything. The localedef for this locale did
- * specify the succeeding digits, so that strftime() works properly
- * on them, without needing to infer anything. But the
- * nl_langinfo() return did not give sufficient information for the
- * caller to understand what's going on. So until there is
- * evidence that it should work differently, this returns the alt-0
- * string for ALT_DIGITS.
- *
- * wday was chosen because its range is all a single digit. Things
- * like tm_sec have two digits as the minimum: '00' */
-
- LOCALE_UNLOCK;
-
- /* If to return the format, not the value, overwrite the buffer
- * with it. But some strftime()s will keep the original format if
- * illegal, so change those to "" */
- if (return_format) {
- if (strEQ(PL_langinfo_buf, format)) {
- *PL_langinfo_buf = '\0';
- }
- else {
- save_to_buffer(format, &PL_langinfo_buf,
- &PL_langinfo_bufsize, 0);
- }
- }
-
- break;
# endif
+ }
}
return PL_langinfo_buf;
/* disallow with "" or "0" */
*bad_lang_use_once
&& strNE("0", bad_lang_use_once)))));
- bool done = FALSE;
- char * sl_result[NOMINAL_LC_ALL_INDEX + 1]; /* setlocale() return vals;
- not copied so must be
- looked at immediately */
- char * curlocales[NOMINAL_LC_ALL_INDEX + 1]; /* current locale for given
- category; should have been
- copied so aren't volatile
- */
- char * locale_param;
+
+ /* setlocale() return vals; not copied so must be looked at immediately */
+ const char * sl_result[NOMINAL_LC_ALL_INDEX + 1];
+
+ /* current locale for given category; should have been copied so aren't
+ * volatile */
+ const char * curlocales[NOMINAL_LC_ALL_INDEX + 1];
# ifdef WIN32
const char *system_default_locale = NULL;
# endif
-# ifdef DEBUGGING
+
+# ifndef DEBUGGING
+# define DEBUG_LOCALE_INIT(a,b,c)
+# else
DEBUG_INITIALIZATION_set(cBOOL(PerlEnv_getenv("PERL_DEBUG_LOCALE_INIT")));
} \
} STMT_END
-# else
-# define DEBUG_LOCALE_INIT(a,b,c)
-# endif
+/* Make sure the parallel arrays are properly set up */
+# ifdef USE_LOCALE_NUMERIC
+ assert(categories[LC_NUMERIC_INDEX] == LC_NUMERIC);
+ assert(strEQ(category_names[LC_NUMERIC_INDEX], "LC_NUMERIC"));
+# endif
+# ifdef USE_LOCALE_CTYPE
+ assert(categories[LC_CTYPE_INDEX] == LC_CTYPE);
+ assert(strEQ(category_names[LC_CTYPE_INDEX], "LC_CTYPE"));
+# endif
+# ifdef USE_LOCALE_COLLATE
+ assert(categories[LC_COLLATE_INDEX] == LC_COLLATE);
+ assert(strEQ(category_names[LC_COLLATE_INDEX], "LC_COLLATE"));
+# endif
+# ifdef USE_LOCALE_TIME
+ assert(categories[LC_TIME_INDEX] == LC_TIME);
+ assert(strEQ(category_names[LC_TIME_INDEX], "LC_TIME"));
+# endif
+# ifdef USE_LOCALE_MESSAGES
+ assert(categories[LC_MESSAGES_INDEX] == LC_MESSAGES);
+ assert(strEQ(category_names[LC_MESSAGES_INDEX], "LC_MESSAGES"));
+# endif
+# ifdef USE_LOCALE_MONETARY
+ assert(categories[LC_MONETARY_INDEX] == LC_MONETARY);
+ assert(strEQ(category_names[LC_MONETARY_INDEX], "LC_MONETARY"));
+# endif
+# ifdef USE_LOCALE_ADDRESS
+ assert(categories[LC_ADDRESS_INDEX] == LC_ADDRESS);
+ assert(strEQ(category_names[LC_ADDRESS_INDEX], "LC_ADDRESS"));
+# endif
+# ifdef USE_LOCALE_IDENTIFICATION
+ assert(categories[LC_IDENTIFICATION_INDEX] == LC_IDENTIFICATION);
+ assert(strEQ(category_names[LC_IDENTIFICATION_INDEX], "LC_IDENTIFICATION"));
+# endif
+# ifdef USE_LOCALE_MEASUREMENT
+ assert(categories[LC_MEASUREMENT_INDEX] == LC_MEASUREMENT);
+ assert(strEQ(category_names[LC_MEASUREMENT_INDEX], "LC_MEASUREMENT"));
+# endif
+# ifdef USE_LOCALE_PAPER
+ assert(categories[LC_PAPER_INDEX] == LC_PAPER);
+ assert(strEQ(category_names[LC_PAPER_INDEX], "LC_PAPER"));
+# endif
+# ifdef USE_LOCALE_TELEPHONE
+ assert(categories[LC_TELEPHONE_INDEX] == LC_TELEPHONE);
+ assert(strEQ(category_names[LC_TELEPHONE_INDEX], "LC_TELEPHONE"));
+# endif
+# ifdef LC_ALL
+ assert(categories[LC_ALL_INDEX] == LC_ALL);
+ assert(strEQ(category_names[LC_ALL_INDEX], "LC_ALL"));
+ assert(NOMINAL_LC_ALL_INDEX == LC_ALL_INDEX);
+# endif
+# endif /* DEBUGGING */
-# ifndef LOCALE_ENVIRON_REQUIRED
+ /* Initialize the cache of the program's UTF-8ness for the always known
+ * locales C and POSIX */
+ my_strlcpy(PL_locale_utf8ness, C_and_POSIX_utf8ness,
+ sizeof(PL_locale_utf8ness));
- PERL_UNUSED_VAR(done);
- PERL_UNUSED_VAR(locale_param);
+ PL_numeric_radix_sv = newSVpvs(".");
-# else
+# ifdef LOCALE_ENVIRON_REQUIRED
/*
* Ultrix setlocale(..., "") fails if there are no environment
* variables from which to get a locale name.
*/
-# ifdef LC_ALL
+# ifndef LC_ALL
+# error Ultrix without LC_ALL not implemented
+# else
- if (lang) {
- sl_result[NOMINAL_LC_ALL_INDEX] = do_setlocale_c(LC_ALL, setlocale_init);
- DEBUG_LOCALE_INIT(LC_ALL, setlocale_init, sl_result[NOMINAL_LC_ALL_INDEX]);
- if (sl_result[NOMINAL_LC_ALL_INDEX])
- done = TRUE;
- else
- setlocale_failure = TRUE;
- }
- if (! setlocale_failure) {
- for (i = 0; i < NOMINAL_LC_ALL_INDEX; i++) {
- locale_param = (! done && (lang || PerlEnv_getenv(category_names[i])))
- ? setlocale_init
- : NULL;
- sl_result[i] = do_setlocale_r(categories[i], locale_param);
- if (! sl_result[i]) {
+ {
+ bool done = FALSE;
+ if (lang) {
+ sl_result[LC_ALL_INDEX] = do_setlocale_c(LC_ALL, setlocale_init);
+ DEBUG_LOCALE_INIT(LC_ALL, setlocale_init, sl_result[LC_ALL_INDEX]);
+ if (sl_result[LC_ALL_INDEX])
+ done = TRUE;
+ else
setlocale_failure = TRUE;
+ }
+ if (! setlocale_failure) {
+ const char * locale_param;
+ for (i = 0; i < LC_ALL_INDEX; i++) {
+ locale_param = (! done && (lang || PerlEnv_getenv(category_names[i])))
+ ? setlocale_init
+ : NULL;
+ sl_result[i] = do_setlocale_r(categories[i], locale_param);
+ if (! sl_result[i]) {
+ setlocale_failure = TRUE;
+ }
+ DEBUG_LOCALE_INIT(categories[i], locale_param, sl_result[i]);
}
- DEBUG_LOCALE_INIT(categories[i], locale_param, sl_result[i]);
}
}
setlocale_failure = FALSE;
# ifdef SYSTEM_DEFAULT_LOCALE
-# ifdef WIN32
+# ifdef WIN32 /* Note that assumes Win32 has LC_ALL */
/* On Windows machines, an entry of "" after the 0th means to use
* the system default locale, which we now proceed to get. */
trial_locale = system_default_locale;
}
-# endif /* WIN32 */
+# else
+# error SYSTEM_DEFAULT_LOCALE only implemented for Win32
+# endif
# endif /* SYSTEM_DEFAULT_LOCALE */
- }
+
+ } /* For i > 0 */
# ifdef LC_ALL
- sl_result[NOMINAL_LC_ALL_INDEX] = do_setlocale_c(LC_ALL, trial_locale);
- DEBUG_LOCALE_INIT(LC_ALL, trial_locale, sl_result[NOMINAL_LC_ALL_INDEX]);
- if (! sl_result[NOMINAL_LC_ALL_INDEX]) {
+ sl_result[LC_ALL_INDEX] = do_setlocale_c(LC_ALL, trial_locale);
+ DEBUG_LOCALE_INIT(LC_ALL, trial_locale, sl_result[LC_ALL_INDEX]);
+ if (! sl_result[LC_ALL_INDEX]) {
setlocale_failure = TRUE;
}
else {
}
}
- PerlIO_printf(Perl_error_log, "and possibly others\n");
-
# endif /* LC_ALL */
PerlIO_printf(Perl_error_log,
/* Done with finding the locales; update our records */
- for (i = 0; i < NOMINAL_LC_ALL_INDEX; i++) {
- switch (categories[i]) {
-
# ifdef USE_LOCALE_CTYPE
- case LC_CTYPE:
- new_ctype(curlocales[i]);
- break;
+ new_ctype(curlocales[LC_CTYPE_INDEX]);
# endif
# ifdef USE_LOCALE_COLLATE
- case LC_COLLATE:
- new_collate(curlocales[i]);
- break;
+ new_collate(curlocales[LC_COLLATE_INDEX]);
# endif
# ifdef USE_LOCALE_NUMERIC
- case LC_NUMERIC:
- new_numeric(curlocales[i]);
- break;
+ new_numeric(curlocales[LC_NUMERIC_INDEX]);
# endif
- default: ;
- }
+ for (i = 0; i < NOMINAL_LC_ALL_INDEX; i++) {
+
+# if defined(USE_ITHREADS)
+
+ /* This caches whether each category's locale is UTF-8 or not. This
+ * may involve changing the locale. It is ok to do this at
+ * initialization time before any threads have started, but not later.
+ * Caching means that if the program heeds our dictate not to change
+ * locales in threaded applications, this data will remain valid, and
+ * it may get queried without changing locales. If the environment is
+ * such that all categories have the same locale, this isn't needed, as
+ * the code will not change the locale; but this handles the uncommon
+ * case where the environment has disparate locales for the categories
+ * */
+ (void) _is_cur_LC_category_utf8(categories[i]);
+
+# endif
Safefree(curlocales[i]);
}
# if defined(USE_PERLIO) && defined(USE_LOCALE_CTYPE)
/* Set PL_utf8locale to TRUE if using PerlIO _and_ the current LC_CTYPE
- * locale is UTF-8. If PL_utf8locale and PL_unicode (set by -C or by
- * $ENV{PERL_UNICODE}) are true, perl.c:S_parse_body() will turn on the
- * PerlIO :utf8 layer on STDIN, STDOUT, STDERR, _and_ the default open
- * discipline. */
- PL_utf8locale = _is_cur_LC_category_utf8(LC_CTYPE);
+ * locale is UTF-8. The call to new_ctype() just above has already
+ * calculated the latter value and saved it in PL_in_utf8_CTYPE_locale. If
+ * both PL_utf8locale and PL_unicode (set by -C or by $ENV{PERL_UNICODE})
+ * are true, perl.c:S_parse_body() will turn on the PerlIO :utf8 layer on
+ * STDIN, STDOUT, STDERR, _and_ the default open discipline. */
+ PL_utf8locale = PL_in_utf8_CTYPE_locale;
/* Set PL_unicode to $ENV{PERL_UNICODE} if using PerlIO.
This is an alternative to using the -C command line switch
} /* End of determining the character that is to replace NULs */
/* If the replacement is variant under UTF-8, it must match the
- * UTF8-ness as the original */
+ * UTF8-ness of the original */
if ( ! UVCHR_IS_INVARIANT(PL_strxfrm_NUL_replacement) && utf8) {
this_replacement_char[0] =
UTF8_EIGHT_BIT_HI(PL_strxfrm_NUL_replacement);
#ifdef USE_LOCALE
+STATIC const char *
+S_switch_category_locale_to_template(pTHX_ const int switch_category, const int template_category, const char * template_locale)
+{
+ /* Changes the locale for LC_'switch_category" to that of
+ * LC_'template_category', if they aren't already the same. If not NULL,
+ * 'template_locale' is the locale that 'template_category' is in.
+ *
+ * Returns the original locale for 'switch_category' so can be switched
+ * back to with the companion function restore_switched_locale(), (NULL if
+ * no restoral is necessary.) */
+
+ char * restore_to_locale = NULL;
+
+ if (switch_category == template_category) { /* No changes needed */
+ return NULL;
+ }
+
+ /* Find the original locale of the category we may need to change, so that
+ * it can be restored to later */
+ restore_to_locale = do_setlocale_r(switch_category, NULL);
+ if (! restore_to_locale) {
+ Perl_croak(aTHX_
+ "panic: %s: %d: Could not find current %s locale, errno=%d\n",
+ __FILE__, __LINE__, category_name(switch_category), errno);
+ }
+ restore_to_locale = stdize_locale(savepv(restore_to_locale));
+
+ /* If the locale of the template category wasn't passed in, find it now */
+ if (template_locale == NULL) {
+ template_locale = do_setlocale_r(template_category, NULL);
+ if (! template_locale) {
+ Perl_croak(aTHX_
+ "panic: %s: %d: Could not find current %s locale, errno=%d\n",
+ __FILE__, __LINE__, category_name(template_category), errno);
+ }
+ }
+
+ /* It the locales are the same, there's nothing to do */
+ if (strEQ(restore_to_locale, template_locale)) {
+ Safefree(restore_to_locale);
+
+ DEBUG_Lv(PerlIO_printf(Perl_debug_log, "%s locale unchanged as %s\n",
+ category_name(switch_category), restore_to_locale));
+
+ return NULL;
+ }
+
+ /* Finally, change the locale to the template one */
+ if (! do_setlocale_r(switch_category, template_locale)) {
+ Perl_croak(aTHX_
+ "panic: %s: %d: Could not change %s locale to %s, errno=%d\n",
+ __FILE__, __LINE__, category_name(switch_category),
+ template_locale, errno);
+ }
+
+ DEBUG_Lv(PerlIO_printf(Perl_debug_log, "%s locale switched to %s\n",
+ category_name(switch_category), template_locale));
+
+ return restore_to_locale;
+}
+
+STATIC void
+S_restore_switched_locale(pTHX_ const int category, const char * const original_locale)
+{
+ /* Restores the locale for LC_'category' to 'original_locale', or do
+ * nothing if the latter parameter is NULL */
+
+ if (original_locale == NULL) {
+ return;
+ }
+
+ if (! do_setlocale_r(category, original_locale)) {
+ Perl_croak(aTHX_
+ "panic: %s: %d: setlocale %s restore to %s failed, errno=%d\n",
+ __FILE__, __LINE__,
+ category_name(category), original_locale, errno);
+ }
+
+ Safefree(original_locale);
+}
+
bool
Perl__is_cur_LC_category_utf8(pTHX_ int category)
{
* English, it comes down to if the locale's name ends in something like
* "UTF-8". It errs on the side of not being a UTF-8 locale. */
- char *save_input_locale = NULL;
- STRLEN final_pos;
+ /* Name of current locale corresponding to the input category */
+ const char *save_input_locale = NULL;
+
+ bool is_utf8 = FALSE; /* The return value */
+
+ /* The variables below are for the cache of previous lookups using this
+ * function. The cache is a C string, described at the definition for
+ * 'C_and_POSIX_utf8ness'.
+ *
+ * The first part of the cache is fixed, for the C and POSIX locales. The
+ * varying part starts just after them. */
+ char * utf8ness_cache = PL_locale_utf8ness + STRLENs(C_and_POSIX_utf8ness);
+
+ Size_t utf8ness_cache_size; /* Size of the varying portion */
+ Size_t input_name_len; /* Length in bytes of save_input_locale */
+ Size_t input_name_len_with_overhead; /* plus extra chars used to store
+ the name in the cache */
+ char * delimited; /* The name plus the delimiters used to store
+ it in the cache */
+ char * name_pos; /* position of 'delimited' in the cache, or 0
+ if not there */
+
# ifdef LC_ALL
# endif
- /* First dispose of the trivial cases */
+ /* Get the desired category's locale */
save_input_locale = do_setlocale_r(category, NULL);
if (! save_input_locale) {
- DEBUG_L(PerlIO_printf(Perl_debug_log,
- "Could not find current locale for category %d\n",
- category));
- return FALSE; /* XXX maybe should croak */
+ Perl_croak(aTHX_
+ "panic: %s: %d: Could not find current %s locale, errno=%d\n",
+ __FILE__, __LINE__, category_name(category), errno);
}
+
save_input_locale = stdize_locale(savepv(save_input_locale));
- if (isNAME_C_OR_POSIX(save_input_locale)) {
- DEBUG_L(PerlIO_printf(Perl_debug_log,
- "Current locale for category %d is %s\n",
- category, save_input_locale));
- Safefree(save_input_locale);
- return FALSE;
- }
+ DEBUG_L(PerlIO_printf(Perl_debug_log,
+ "Current locale for %s is %s\n",
+ category_name(category), save_input_locale));
-# if defined(USE_LOCALE_CTYPE) \
- && (defined(MB_CUR_MAX) || (defined(HAS_NL_LANGINFO) && defined(CODESET)))
+ input_name_len = strlen(save_input_locale);
- { /* Next try nl_langinfo or MB_CUR_MAX if available */
+ /* In our cache, each name is accompanied by two delimiters and a single
+ * utf8ness digit */
+ input_name_len_with_overhead = input_name_len + 3;
- char *save_ctype_locale = NULL;
- bool is_utf8;
+ /* Allocate and populate space for a copy of the name surrounded by the
+ * delimiters */
+ Newx(delimited, input_name_len_with_overhead, char);
+ delimited[0] = UTF8NESS_SEP[0];
+ Copy(save_input_locale, delimited + 1, input_name_len, char);
+ delimited[input_name_len+1] = UTF8NESS_PREFIX[0];
+ delimited[input_name_len+2] = '\0';
- if (category != LC_CTYPE) { /* These work only on LC_CTYPE */
+ /* And see if that is in the cache */
+ name_pos = instr(PL_locale_utf8ness, delimited);
+ if (name_pos) {
+ is_utf8 = *(name_pos + input_name_len_with_overhead - 1) - '0';
- /* Get the current LC_CTYPE locale */
- save_ctype_locale = do_setlocale_c(LC_CTYPE, NULL);
- if (! save_ctype_locale) {
- DEBUG_L(PerlIO_printf(Perl_debug_log,
- "Could not find current locale for LC_CTYPE\n"));
- goto cant_use_nllanginfo;
- }
- save_ctype_locale = stdize_locale(savepv(save_ctype_locale));
-
- /* If LC_CTYPE and the desired category use the same locale, this
- * means that finding the value for LC_CTYPE is the same as finding
- * the value for the desired category. Otherwise, switch LC_CTYPE
- * to the desired category's locale */
- if (strEQ(save_ctype_locale, save_input_locale)) {
- Safefree(save_ctype_locale);
- save_ctype_locale = NULL;
- }
- else if (! do_setlocale_c(LC_CTYPE, save_input_locale)) {
- DEBUG_L(PerlIO_printf(Perl_debug_log,
- "Could not change LC_CTYPE locale to %s\n",
- save_input_locale));
- Safefree(save_ctype_locale);
- goto cant_use_nllanginfo;
- }
+# ifdef DEBUGGING
+
+ if (DEBUG_Lv_TEST || debug_initialization) {
+ PerlIO_printf(Perl_debug_log, "UTF8ness for locale %s=%d, \n",
+ save_input_locale, is_utf8);
+ }
+
+# endif
+
+ /* And, if not already in that position, move it to the beginning of
+ * the non-constant portion of the list, since it is the most recently
+ * used. (We don't have to worry about overflow, since just moving
+ * existing names around) */
+ if (name_pos > utf8ness_cache) {
+ Move(utf8ness_cache,
+ utf8ness_cache + input_name_len_with_overhead,
+ name_pos - utf8ness_cache, char);
+ Copy(delimited,
+ utf8ness_cache,
+ input_name_len_with_overhead - 1, char);
+ utf8ness_cache[input_name_len_with_overhead - 1] = is_utf8 + '0';
}
- DEBUG_L(PerlIO_printf(Perl_debug_log, "Current LC_CTYPE locale=%s\n",
- save_input_locale));
+ Safefree(delimited);
+ Safefree(save_input_locale);
+ return is_utf8;
+ }
+
+ /* Here we don't have stored the utf8ness for the input locale. We have to
+ * calculate it */
+
+# if defined(USE_LOCALE_CTYPE) \
+ && ( (defined(HAS_NL_LANGINFO) && defined(CODESET)) \
+ || (defined(HAS_MBTOWC) || defined(HAS_MBRTOWC)))
+
+ {
+ const char *original_ctype_locale
+ = switch_category_locale_to_template(LC_CTYPE,
+ category,
+ save_input_locale);
/* Here the current LC_CTYPE is set to the locale of the category whose
- * information is desired. This means that nl_langinfo() and MB_CUR_MAX
+ * information is desired. This means that nl_langinfo() and mbtowc()
* should give the correct results */
+# ifdef MB_CUR_MAX /* But we can potentially rule out UTF-8ness, avoiding
+ calling the functions if we have this */
+
+ /* Standard UTF-8 needs at least 4 bytes to represent the maximum
+ * Unicode code point. */
+
+ DEBUG_L(PerlIO_printf(Perl_debug_log, "\tMB_CUR_MAX=%d\n",
+ (int) MB_CUR_MAX));
+ if ((unsigned) MB_CUR_MAX < STRLENs(MAX_UNICODE_UTF8)) {
+ is_utf8 = FALSE;
+ restore_switched_locale(LC_CTYPE, original_ctype_locale);
+ goto finish_and_return;
+ }
+
+# endif
# if defined(HAS_NL_LANGINFO) && defined(CODESET)
- /* The task is easiest if has this POSIX 2001 function */
- {
+ { /* The task is easiest if the platform has this POSIX 2001 function.
+ Except on some platforms it can wrongly return "", so have to have
+ a fallback. And it can return that it's UTF-8, even if there are
+ variances from that. For example, Turkish locales may use the
+ alternate dotted I rules, and sometimes it appears to be a
+ defective locale definition. XXX We should probably check for
+ these in the Latin1 range and warn */
const char *codeset = my_nl_langinfo(PERL_CODESET, FALSE);
/* FALSE => already in dest locale */
"\tnllanginfo returned CODESET '%s'\n", codeset));
if (codeset && strNE(codeset, "")) {
- /* If we switched LC_CTYPE, switch back */
- if (save_ctype_locale) {
- do_setlocale_c(LC_CTYPE, save_ctype_locale);
- Safefree(save_ctype_locale);
- }
- is_utf8 = ( ( strlen(codeset) == STRLENs("UTF-8")
- && foldEQ(codeset, STR_WITH_LEN("UTF-8")))
- || ( strlen(codeset) == STRLENs("UTF8")
- && foldEQ(codeset, STR_WITH_LEN("UTF8"))));
+ /* If the implementation of foldEQ() somehow were
+ * to change to not go byte-by-byte, this could
+ * read past end of string, as only one length is
+ * checked. But currently, a premature NUL will
+ * compare false, and it will stop there */
+ is_utf8 = cBOOL( foldEQ(codeset, STR_WITH_LEN("UTF-8"))
+ || foldEQ(codeset, STR_WITH_LEN("UTF8")));
DEBUG_L(PerlIO_printf(Perl_debug_log,
"\tnllanginfo returned CODESET '%s'; ?UTF8 locale=%d\n",
codeset, is_utf8));
- Safefree(save_input_locale);
- return is_utf8;
+ restore_switched_locale(LC_CTYPE, original_ctype_locale);
+ goto finish_and_return;
}
}
# endif
-# ifdef MB_CUR_MAX
+# if defined(HAS_MBTOWC) || defined(HAS_MBRTOWC)
+ /* We can see if this is a UTF-8-like locale if have mbtowc(). It was a
+ * late adder to C89, so very likely to have it. However, testing has
+ * shown that, like nl_langinfo() above, there are locales that are not
+ * strictly UTF-8 that this will return that they are */
- /* Here, either we don't have nl_langinfo, or it didn't return a
- * codeset. Try MB_CUR_MAX */
+ {
+ wchar_t wc;
+ int len;
- /* Standard UTF-8 needs at least 4 bytes to represent the maximum
- * Unicode code point. Since UTF-8 is the only non-single byte
- * encoding we handle, we just say any such encoding is UTF-8, and if
- * turns out to be wrong, other things will fail */
- is_utf8 = MB_CUR_MAX >= 4;
+# if defined(HAS_MBRTOWC) && defined(USE_ITHREADS)
- DEBUG_L(PerlIO_printf(Perl_debug_log,
- "\tMB_CUR_MAX=%d; ?UTF8 locale=%d\n",
- (int) MB_CUR_MAX, is_utf8));
+ mbstate_t ps;
- Safefree(save_input_locale);
+# endif
-# ifdef HAS_MBTOWC
+ /* mbrtowc() and mbtowc() convert a byte string to a wide
+ * character. Feed a byte string to one of them and check that the
+ * result is the expected Unicode code point */
- /* ... But, most system that have MB_CUR_MAX will also have mbtowc(),
- * since they are both in the C99 standard. We can feed a known byte
- * string to the latter function, and check that it gives the expected
- * result */
- if (is_utf8) {
- wchar_t wc;
- int len;
+# if defined(HAS_MBRTOWC) && defined(USE_ITHREADS)
+ /* Prefer this function if available, as it's reentrant */
- PERL_UNUSED_RESULT(mbtowc(&wc, NULL, 0));/* Reset any shift state */
+ memset(&ps, 0, sizeof(ps));;
+ PERL_UNUSED_RESULT(mbrtowc(&wc, NULL, 0, &ps)); /* Reset any shift
+ state */
errno = 0;
- len = mbtowc(&wc, STR_WITH_LEN(REPLACEMENT_CHARACTER_UTF8));
+ len = mbrtowc(&wc, STR_WITH_LEN(REPLACEMENT_CHARACTER_UTF8), &ps);
+# else
- if ( len != STRLENs(REPLACEMENT_CHARACTER_UTF8)
- || wc != (wchar_t) 0xFFFD)
- {
- is_utf8 = FALSE;
- DEBUG_L(PerlIO_printf(Perl_debug_log, "\replacement=U+%x\n",
- (unsigned int)wc));
- DEBUG_L(PerlIO_printf(Perl_debug_log,
- "\treturn from mbtowc=%d; errno=%d; ?UTF8 locale=0\n",
- len, errno));
- }
- }
+ PERL_UNUSED_RESULT(mbtowc(&wc, NULL, 0));/* Reset any shift state */
+ errno = 0;
+ len = mbtowc(&wc, STR_WITH_LEN(REPLACEMENT_CHARACTER_UTF8));
# endif
- /* If we switched LC_CTYPE, switch back */
- if (save_ctype_locale) {
- do_setlocale_c(LC_CTYPE, save_ctype_locale);
- Safefree(save_ctype_locale);
- }
-
- return is_utf8;
+ DEBUG_L(PerlIO_printf(Perl_debug_log,
+ "\treturn from mbtowc; len=%d; code_point=%x; errno=%d\n",
+ len, (unsigned int) wc, errno));
-# endif
+ is_utf8 = cBOOL( len == STRLENs(REPLACEMENT_CHARACTER_UTF8)
+ && wc == (wchar_t) UNICODE_REPLACEMENT);
+ }
+ restore_switched_locale(LC_CTYPE, original_ctype_locale);
+ goto finish_and_return;
}
- cant_use_nllanginfo:
-
-# else /* nl_langinfo should work if available, so don't bother compiling this
- fallback code. The final fallback of looking at the name is
- compiled, and will be executed if nl_langinfo fails */
+# endif
+# else
- /* nl_langinfo not available or failed somehow. Next try looking at the
- * currency symbol to see if it disambiguates things. Often that will be
- * in the native script, and if the symbol isn't in UTF-8, we know that the
- * locale isn't. If it is non-ASCII UTF-8, we infer that the locale is
- * too, as the odds of a non-UTF8 string being valid UTF-8 are quite small
- * */
+ /* Here, we must have a C89 compiler that doesn't have mbtowc(). Next
+ * try looking at the currency symbol to see if it disambiguates
+ * things. Often that will be in the native script, and if the symbol
+ * isn't in UTF-8, we know that the locale isn't. If it is non-ASCII
+ * UTF-8, we infer that the locale is too, as the odds of a non-UTF8
+ * string being valid UTF-8 are quite small */
# ifdef HAS_LOCALECONV
# ifdef USE_LOCALE_MONETARY
- {
- char *save_monetary_locale = NULL;
- bool only_ascii = FALSE;
- bool is_utf8 = FALSE;
- struct lconv* lc;
+ {
+ const char *original_monetary_locale
+ = switch_category_locale_to_template(LC_MONETARY,
+ category,
+ save_input_locale);
+ bool only_ascii = FALSE;
+ struct lconv* lc;
- /* Like above for LC_CTYPE, we first set LC_MONETARY to the locale of
- * the desired category, if it isn't that locale already */
+ /* Like above for LC_CTYPE, we first set LC_MONETARY to the locale of
+ * the desired category, if it isn't that locale already */
- if (category != LC_MONETARY) {
- save_monetary_locale = do_setlocale_c(LC_MONETARY, NULL);
- if (! save_monetary_locale) {
- DEBUG_L(PerlIO_printf(Perl_debug_log,
- "Could not find current locale for LC_MONETARY\n"));
- goto cant_use_monetary;
- }
- save_monetary_locale = stdize_locale(savepv(save_monetary_locale));
+ /* Here the current LC_MONETARY is set to the locale of the category
+ * whose information is desired. */
- if (strEQ(save_monetary_locale, save_input_locale)) {
- Safefree(save_monetary_locale);
- save_monetary_locale = NULL;
+ lc = localeconv();
+ if (! lc
+ || ! lc->currency_symbol
+ || is_utf8_invariant_string((U8 *) lc->currency_symbol, 0))
+ {
+ DEBUG_L(PerlIO_printf(Perl_debug_log, "Couldn't get currency symbol for %s, or contains only ASCII; can't use for determining if UTF-8 locale\n", save_input_locale));
+ only_ascii = TRUE;
}
- else if (! do_setlocale_c(LC_MONETARY, save_input_locale)) {
- DEBUG_L(PerlIO_printf(Perl_debug_log,
- "Could not change LC_MONETARY locale to %s\n",
- save_input_locale));
- Safefree(save_monetary_locale);
- goto cant_use_monetary;
+ else {
+ is_utf8 = is_utf8_string((U8 *) lc->currency_symbol, 0);
}
- }
-
- /* Here the current LC_MONETARY is set to the locale of the category
- * whose information is desired. */
- lc = localeconv();
- if (! lc
- || ! lc->currency_symbol
- || is_utf8_invariant_string((U8 *) lc->currency_symbol, 0))
- {
- DEBUG_L(PerlIO_printf(Perl_debug_log, "Couldn't get currency symbol for %s, or contains only ASCII; can't use for determining if UTF-8 locale\n", save_input_locale));
- only_ascii = TRUE;
- }
- else {
- is_utf8 = is_utf8_string((U8 *) lc->currency_symbol, 0);
- }
+ restore_switched_locale(LC_MONETARY, original_monetary_locale);
- /* If we changed it, restore LC_MONETARY to its original locale */
- if (save_monetary_locale) {
- do_setlocale_c(LC_MONETARY, save_monetary_locale);
- Safefree(save_monetary_locale);
- }
-
- if (! only_ascii) {
+ if (! only_ascii) {
- /* It isn't a UTF-8 locale if the symbol is not legal UTF-8;
- * otherwise assume the locale is UTF-8 if and only if the symbol
- * is non-ascii UTF-8. */
- DEBUG_L(PerlIO_printf(Perl_debug_log, "\t?Currency symbol for %s is UTF-8=%d\n",
- save_input_locale, is_utf8));
- Safefree(save_input_locale);
- return is_utf8;
+ /* It isn't a UTF-8 locale if the symbol is not legal UTF-8;
+ * otherwise assume the locale is UTF-8 if and only if the symbol
+ * is non-ascii UTF-8. */
+ DEBUG_L(PerlIO_printf(Perl_debug_log, "\t?Currency symbol for %s is UTF-8=%d\n",
+ save_input_locale, is_utf8));
+ goto finish_and_return;
+ }
}
- }
- cant_use_monetary:
# endif /* USE_LOCALE_MONETARY */
# endif /* HAS_LOCALECONV */
# if defined(HAS_STRFTIME) && defined(USE_LOCALE_TIME)
-/* Still haven't found a non-ASCII string to disambiguate UTF-8 or not. Try
- * the names of the months and weekdays, timezone, and am/pm indicator */
- {
- char *save_time_locale = NULL;
- int hour = 10;
- bool is_dst = FALSE;
- int dom = 1;
- int month = 0;
- int i;
- char * formatted_time;
-
-
- /* Like above for LC_MONETARY, we set LC_TIME to the locale of the
- * desired category, if it isn't that locale already */
-
- if (category != LC_TIME) {
-
- save_time_locale = do_setlocale_c(LC_TIME, NULL);
- if (! save_time_locale) {
- DEBUG_L(PerlIO_printf(Perl_debug_log,
- "Could not find current locale for LC_TIME\n"));
- goto cant_use_time;
- }
- save_time_locale = stdize_locale(savepv(save_time_locale));
-
- if (strEQ(save_time_locale, save_input_locale)) {
- Safefree(save_time_locale);
- save_time_locale = NULL;
- }
- else if (! do_setlocale_c(LC_TIME, save_input_locale)) {
- DEBUG_L(PerlIO_printf(Perl_debug_log,
- "Could not change LC_TIME locale to %s\n",
- save_input_locale));
- Safefree(save_time_locale);
- goto cant_use_time;
- }
- }
-
- /* Here the current LC_TIME is set to the locale of the category
- * whose information is desired. Look at all the days of the week and
- * month names, and the timezone and am/pm indicator for UTF-8 variant
- * characters. The first such a one found will tell us if the locale
- * is UTF-8 or not */
-
- for (i = 0; i < 7 + 12; i++) { /* 7 days; 12 months */
- formatted_time = my_strftime("%A %B %Z %p",
- 0, 0, hour, dom, month, 2012 - 1900, 0, 0, is_dst);
- if ( ! formatted_time
- || is_utf8_invariant_string((U8 *) formatted_time, 0))
- {
+ /* Still haven't found a non-ASCII string to disambiguate UTF-8 or not. Try
+ * the names of the months and weekdays, timezone, and am/pm indicator */
+ {
+ const char *original_time_locale
+ = switch_category_locale_to_template(LC_TIME,
+ category,
+ save_input_locale);
+ int hour = 10;
+ bool is_dst = FALSE;
+ int dom = 1;
+ int month = 0;
+ int i;
+ char * formatted_time;
+
+ /* Here the current LC_TIME is set to the locale of the category
+ * whose information is desired. Look at all the days of the week and
+ * month names, and the timezone and am/pm indicator for UTF-8 variant
+ * characters. The first such a one found will tell us if the locale
+ * is UTF-8 or not */
+
+ for (i = 0; i < 7 + 12; i++) { /* 7 days; 12 months */
+ formatted_time = my_strftime("%A %B %Z %p",
+ 0, 0, hour, dom, month, 2012 - 1900, 0, 0, is_dst);
+ if ( ! formatted_time
+ || is_utf8_invariant_string((U8 *) formatted_time, 0))
+ {
- /* Here, we didn't find a non-ASCII. Try the next time through
- * with the complemented dst and am/pm, and try with the next
- * weekday. After we have gotten all weekdays, try the next
- * month */
- is_dst = ! is_dst;
- hour = (hour + 12) % 24;
- dom++;
- if (i > 6) {
- month++;
+ /* Here, we didn't find a non-ASCII. Try the next time through
+ * with the complemented dst and am/pm, and try with the next
+ * weekday. After we have gotten all weekdays, try the next
+ * month */
+ is_dst = ! is_dst;
+ hour = (hour + 12) % 24;
+ dom++;
+ if (i > 6) {
+ month++;
+ }
+ continue;
}
- continue;
- }
- /* Here, we have a non-ASCII. Return TRUE is it is valid UTF8;
- * false otherwise. But first, restore LC_TIME to its original
- * locale if we changed it */
- if (save_time_locale) {
- do_setlocale_c(LC_TIME, save_time_locale);
- Safefree(save_time_locale);
- }
+ /* Here, we have a non-ASCII. Return TRUE is it is valid UTF8;
+ * false otherwise. But first, restore LC_TIME to its original
+ * locale if we changed it */
+ restore_switched_locale(LC_TIME, original_time_locale);
- DEBUG_L(PerlIO_printf(Perl_debug_log, "\t?time-related strings for %s are UTF-8=%d\n",
- save_input_locale,
- is_utf8_string((U8 *) formatted_time, 0)));
- Safefree(save_input_locale);
- return is_utf8_string((U8 *) formatted_time, 0);
- }
+ DEBUG_L(PerlIO_printf(Perl_debug_log, "\t?time-related strings for %s are UTF-8=%d\n",
+ save_input_locale,
+ is_utf8_string((U8 *) formatted_time, 0)));
+ is_utf8 = is_utf8_string((U8 *) formatted_time, 0);
+ goto finish_and_return;
+ }
- /* Falling off the end of the loop indicates all the names were just
- * ASCII. Go on to the next test. If we changed it, restore LC_TIME
- * to its original locale */
- if (save_time_locale) {
- do_setlocale_c(LC_TIME, save_time_locale);
- Safefree(save_time_locale);
+ /* Falling off the end of the loop indicates all the names were just
+ * ASCII. Go on to the next test. If we changed it, restore LC_TIME
+ * to its original locale */
+ restore_switched_locale(LC_TIME, original_time_locale);
+ DEBUG_L(PerlIO_printf(Perl_debug_log, "All time-related words for %s contain only ASCII; can't use for determining if UTF-8 locale\n", save_input_locale));
}
- DEBUG_L(PerlIO_printf(Perl_debug_log, "All time-related words for %s contain only ASCII; can't use for determining if UTF-8 locale\n", save_input_locale));
- }
- cant_use_time:
# endif
# if 0 && defined(USE_LOCALE_MESSAGES) && defined(HAS_SYS_ERRLIST)
-/* This code is ifdefd out because it was found to not be necessary in testing
- * on our dromedary test machine, which has over 700 locales. There, this
- * added no value to looking at the currency symbol and the time strings. I
- * left it in so as to avoid rewriting it if real-world experience indicates
- * that dromedary is an outlier. Essentially, instead of returning abpve if we
- * haven't found illegal utf8, we continue on and examine all the strerror()
- * messages on the platform for utf8ness. If all are ASCII, we still don't
- * know the answer; but otherwise we have a pretty good indication of the
- * utf8ness. The reason this doesn't help much is that the messages may not
- * have been translated into the locale. The currency symbol and time strings
- * are much more likely to have been translated. */
- {
- int e;
- bool is_utf8 = FALSE;
- bool non_ascii = FALSE;
- char *save_messages_locale = NULL;
- const char * errmsg = NULL;
-
- /* Like above, we set LC_MESSAGES to the locale of the desired
- * category, if it isn't that locale already */
-
- if (category != LC_MESSAGES) {
-
- save_messages_locale = do_setlocale_c(LC_MESSAGES, NULL);
- if (! save_messages_locale) {
- DEBUG_L(PerlIO_printf(Perl_debug_log,
- "Could not find current locale for LC_MESSAGES\n"));
- goto cant_use_messages;
+ /* This code is ifdefd out because it was found to not be necessary in testing
+ * on our dromedary test machine, which has over 700 locales. There, this
+ * added no value to looking at the currency symbol and the time strings. I
+ * left it in so as to avoid rewriting it if real-world experience indicates
+ * that dromedary is an outlier. Essentially, instead of returning abpve if we
+ * haven't found illegal utf8, we continue on and examine all the strerror()
+ * messages on the platform for utf8ness. If all are ASCII, we still don't
+ * know the answer; but otherwise we have a pretty good indication of the
+ * utf8ness. The reason this doesn't help much is that the messages may not
+ * have been translated into the locale. The currency symbol and time strings
+ * are much more likely to have been translated. */
+ {
+ int e;
+ bool non_ascii = FALSE;
+ const char *original_messages_locale
+ = switch_category_locale_to_template(LC_MESSAGES,
+ category,
+ save_input_locale);
+ const char * errmsg = NULL;
+
+ /* Here the current LC_MESSAGES is set to the locale of the category
+ * whose information is desired. Look through all the messages. We
+ * can't use Strerror() here because it may expand to code that
+ * segfaults in miniperl */
+
+ for (e = 0; e <= sys_nerr; e++) {
+ errno = 0;
+ errmsg = sys_errlist[e];
+ if (errno || !errmsg) {
+ break;
+ }
+ errmsg = savepv(errmsg);
+ if (! is_utf8_invariant_string((U8 *) errmsg, 0)) {
+ non_ascii = TRUE;
+ is_utf8 = is_utf8_string((U8 *) errmsg, 0);
+ break;
+ }
}
- save_messages_locale = stdize_locale(savepv(save_messages_locale));
+ Safefree(errmsg);
- if (strEQ(save_messages_locale, save_input_locale)) {
- Safefree(save_messages_locale);
- save_messages_locale = NULL;
- }
- else if (! do_setlocale_c(LC_MESSAGES, save_input_locale)) {
- DEBUG_L(PerlIO_printf(Perl_debug_log,
- "Could not change LC_MESSAGES locale to %s\n",
- save_input_locale));
- Safefree(save_messages_locale);
- goto cant_use_messages;
- }
- }
+ restore_switched_locale(LC_MESSAGES, original_messages_locale);
- /* Here the current LC_MESSAGES is set to the locale of the category
- * whose information is desired. Look through all the messages. We
- * can't use Strerror() here because it may expand to code that
- * segfaults in miniperl */
+ if (non_ascii) {
- for (e = 0; e <= sys_nerr; e++) {
- errno = 0;
- errmsg = sys_errlist[e];
- if (errno || !errmsg) {
- break;
- }
- errmsg = savepv(errmsg);
- if (! is_utf8_invariant_string((U8 *) errmsg, 0)) {
- non_ascii = TRUE;
- is_utf8 = is_utf8_string((U8 *) errmsg, 0);
- break;
+ /* Any non-UTF-8 message means not a UTF-8 locale; if all are valid,
+ * any non-ascii means it is one; otherwise we assume it isn't */
+ DEBUG_L(PerlIO_printf(Perl_debug_log, "\t?error messages for %s are UTF-8=%d\n",
+ save_input_locale,
+ is_utf8));
+ goto finish_and_return;
}
- }
- Safefree(errmsg);
-
- /* And, if we changed it, restore LC_MESSAGES to its original locale */
- if (save_messages_locale) {
- do_setlocale_c(LC_MESSAGES, save_messages_locale);
- Safefree(save_messages_locale);
- }
-
- if (non_ascii) {
- /* Any non-UTF-8 message means not a UTF-8 locale; if all are valid,
- * any non-ascii means it is one; otherwise we assume it isn't */
- DEBUG_L(PerlIO_printf(Perl_debug_log, "\t?error messages for %s are UTF-8=%d\n",
- save_input_locale,
- is_utf8));
- Safefree(save_input_locale);
- return is_utf8;
+ DEBUG_L(PerlIO_printf(Perl_debug_log, "All error messages for %s contain only ASCII; can't use for determining if UTF-8 locale\n", save_input_locale));
}
- DEBUG_L(PerlIO_printf(Perl_debug_log, "All error messages for %s contain only ASCII; can't use for determining if UTF-8 locale\n", save_input_locale));
- }
- cant_use_messages:
-
# endif
-# endif /* the code that is compiled when no nl_langinfo */
-
-# ifndef EBCDIC /* On os390, even if the name ends with "UTF-8', it isn't a
+# ifndef EBCDIC /* On os390, even if the name ends with "UTF-8', it isn't a
UTF-8 locale */
/* As a last resort, look at the locale name to see if it matches
* its UTF-8ness, but if it has UTF8 in the name, it is extremely likely to
* be a UTF-8 locale. Similarly for the other common names */
- final_pos = strlen(save_input_locale) - 1;
- if (final_pos >= 3) {
- char *name = save_input_locale;
+ {
+ const Size_t final_pos = strlen(save_input_locale) - 1;
+
+ if (final_pos >= 3) {
+ const char *name = save_input_locale;
- /* Find next 'U' or 'u' and look from there */
- while ((name += strcspn(name, "Uu") + 1)
- <= save_input_locale + final_pos - 2)
- {
- if ( isALPHA_FOLD_NE(*name, 't')
- || isALPHA_FOLD_NE(*(name + 1), 'f'))
+ /* Find next 'U' or 'u' and look from there */
+ while ((name += strcspn(name, "Uu") + 1)
+ <= save_input_locale + final_pos - 2)
{
- continue;
- }
- name += 2;
- if (*(name) == '-') {
- if ((name > save_input_locale + final_pos - 1)) {
- break;
+ if ( isALPHA_FOLD_NE(*name, 't')
+ || isALPHA_FOLD_NE(*(name + 1), 'f'))
+ {
+ continue;
+ }
+ name += 2;
+ if (*(name) == '-') {
+ if ((name > save_input_locale + final_pos - 1)) {
+ break;
+ }
+ name++;
+ }
+ if (*(name) == '8') {
+ DEBUG_L(PerlIO_printf(Perl_debug_log,
+ "Locale %s ends with UTF-8 in name\n",
+ save_input_locale));
+ is_utf8 = TRUE;
+ goto finish_and_return;
}
- name++;
- }
- if (*(name) == '8') {
- DEBUG_L(PerlIO_printf(Perl_debug_log,
- "Locale %s ends with UTF-8 in name\n",
- save_input_locale));
- Safefree(save_input_locale);
- return TRUE;
}
+ DEBUG_L(PerlIO_printf(Perl_debug_log,
+ "Locale %s doesn't end with UTF-8 in name\n",
+ save_input_locale));
}
- DEBUG_L(PerlIO_printf(Perl_debug_log,
- "Locale %s doesn't end with UTF-8 in name\n",
- save_input_locale));
- }
-# endif
-# ifdef WIN32
+# ifdef WIN32
- /* http://msdn.microsoft.com/en-us/library/windows/desktop/dd317756.aspx */
- if (memENDs(save_input_locale, final_pos, "65001")) {
- DEBUG_L(PerlIO_printf(Perl_debug_log,
+ /* http://msdn.microsoft.com/en-us/library/windows/desktop/dd317756.aspx */
+ if (memENDs(save_input_locale, final_pos, "65001")) {
+ DEBUG_L(PerlIO_printf(Perl_debug_log,
"Locale %s ends with 65001 in name, is UTF-8 locale\n",
save_input_locale));
- Safefree(save_input_locale);
- return TRUE;
+ is_utf8 = TRUE;
+ goto finish_and_return;
+ }
}
-# endif
+# endif
+# endif
/* Other common encodings are the ISO 8859 series, which aren't UTF-8. But
* since we are about to return FALSE anyway, there is no point in doing
* this extra work */
-# if 0
+# if 0
if (instr(save_input_locale, "8859")) {
DEBUG_L(PerlIO_printf(Perl_debug_log,
"Locale %s has 8859 in name, not UTF-8 locale\n",
save_input_locale));
- Safefree(save_input_locale);
- return FALSE;
+ is_utf8 = FALSE;
+ goto finish_and_return;
}
-# endif
+# endif
DEBUG_L(PerlIO_printf(Perl_debug_log,
"Assuming locale %s is not a UTF-8 locale\n",
save_input_locale));
+ is_utf8 = FALSE;
+
+# endif /* the code that is compiled when no modern LC_CTYPE */
+
+ finish_and_return:
+
+ /* Cache this result so we don't have to go through all this next time. */
+ utf8ness_cache_size = sizeof(PL_locale_utf8ness)
+ - (utf8ness_cache - PL_locale_utf8ness);
+
+ /* But we can't save it if it is too large for the total space available */
+ if (LIKELY(input_name_len_with_overhead < utf8ness_cache_size)) {
+ Size_t utf8ness_cache_len = strlen(utf8ness_cache);
+
+ /* Here it can fit, but we may need to clear out the oldest cached
+ * result(s) to do so. Check */
+ if (utf8ness_cache_len + input_name_len_with_overhead
+ >= utf8ness_cache_size)
+ {
+ /* Here we have to clear something out to make room for this.
+ * Start looking at the rightmost place where it could fit and find
+ * the beginning of the entry that extends past that. */
+ char * cutoff = (char *) my_memrchr(utf8ness_cache,
+ UTF8NESS_SEP[0],
+ utf8ness_cache_size
+ - input_name_len_with_overhead);
+
+ assert(cutoff);
+ assert(cutoff >= utf8ness_cache);
+
+ /* This and all subsequent entries must be removed */
+ *cutoff = '\0';
+ utf8ness_cache_len = strlen(utf8ness_cache);
+ }
+
+ /* Make space for the new entry */
+ Move(utf8ness_cache,
+ utf8ness_cache + input_name_len_with_overhead,
+ utf8ness_cache_len + 1 /* Incl. trailing NUL */, char);
+
+ /* And insert it */
+ Copy(delimited, utf8ness_cache, input_name_len_with_overhead - 1, char);
+ utf8ness_cache[input_name_len_with_overhead - 1] = is_utf8 + '0';
+
+ if ((PL_locale_utf8ness[strlen(PL_locale_utf8ness)-1]
+ & (PERL_UINTMAX_T) ~1) != '0')
+ {
+ Perl_croak(aTHX_
+ "panic: %s: %d: Corrupt utf8ness_cache=%s\nlen=%u,"
+ " inserted_name=%s, its_len=%u\n",
+ __FILE__, __LINE__,
+ PL_locale_utf8ness, strlen(PL_locale_utf8ness),
+ delimited, input_name_len_with_overhead);
+ }
+ }
+
+# ifdef DEBUGGING
+
+ if (DEBUG_Lv_TEST || debug_initialization) {
+ PerlIO_printf(Perl_debug_log,
+ "PL_locale_utf8ness is now %s; returning %d\n",
+ PL_locale_utf8ness, is_utf8);
+ }
+
+# endif
+
+ Safefree(delimited);
Safefree(save_input_locale);
- return FALSE;
+ return is_utf8;
}
#endif
-
bool
Perl__is_in_locale_category(pTHX_ const bool compiling, const int category)
{
# if defined(HAS_POSIX_2008_LOCALE) && defined(HAS_STRERROR_L)
- /* This function is trivial if we have strerror_l() */
+ /* This function is trivial if we don't have to worry about thread safety
+ * and have strerror_l(), as it handles the switch of locales so we don't
+ * have to deal with that. We don't have to worry about thread safety if
+ * this is an unthreaded build, or if strerror_r() is also available. Both
+ * it and strerror_l() are thread-safe. Plain strerror() isn't thread
+ * safe. But on threaded builds when strerror_r() is available, the
+ * apparent call to strerror() below is actually a macro that
+ * behind-the-scenes calls strerror_r().
+ */
+
+# if ! defined(USE_ITHREADS) || defined(HAS_STRERROR_R)
if (within_locale_scope) {
errstr = savepv(strerror(errnum));
errstr = savepv(strerror_l(errnum, PL_C_locale_obj));
}
-# else /* Doesn't have strerror_l(). */
+# else
+
+ /* Here we have strerror_l(), but not strerror_r() and we are on a
+ * threaded-build. We use strerror_l() for everything, constructing a
+ * locale to pass to it if necessary */
+
+ bool do_free = FALSE;
+ locale_t locale_to_use;
+
+ if (within_locale_scope) {
+ locale_to_use = uselocale((locale_t) 0);
+ if (locale_to_use == LC_GLOBAL_LOCALE) {
+ locale_to_use = duplocale(LC_GLOBAL_LOCALE);
+ do_free = TRUE;
+ }
+ }
+ else { /* Use C locale if not within 'use locale' scope */
+ locale_to_use = PL_C_locale_obj;
+ }
+
+ errstr = savepv(strerror_l(errnum, locale_to_use));
+
+ if (do_free) {
+ freelocale(locale_to_use);
+ }
+
+# endif
+# else /* Doesn't have strerror_l() */
# ifdef USE_POSIX_2008_LOCALE
# else
- char * save_locale = NULL;
+ const char * save_locale = NULL;
bool locale_is_C = FALSE;
/* We have a critical section to prevent another thread from changing the
save_locale = do_setlocale_c(LC_MESSAGES, NULL);
if (! save_locale) {
- DEBUG_L(PerlIO_printf(Perl_debug_log,
- "setlocale failed, errno=%d\n", errno));
+ Perl_croak(aTHX_
+ "panic: %s: %d: Could not find current LC_MESSAGES locale,"
+ " errno=%d\n", __FILE__, __LINE__, errno);
}
else {
locale_is_C = isNAME_C_OR_POSIX(save_locale);
if (save_locale && ! locale_is_C) {
if (! do_setlocale_c(LC_MESSAGES, save_locale)) {
- DEBUG_L(PerlIO_printf(Perl_debug_log,
- "setlocale restore failed, errno=%d\n", errno));
+ Perl_croak(aTHX_
+ "panic: %s: %d: setlocale restore failed, errno=%d\n",
+ __FILE__, __LINE__, errno);
}
Safefree(save_locale);
}
static char ret[128] = "If you can read this, thank your buggy C"
" library strlcpy(), and change your hints file"
" to undef it";
- unsigned int i;
-
- const unsigned int highest_index = NOMINAL_LC_ALL_INDEX;
my_strlcpy(ret, "setlocale(", sizeof(ret));
-
- /* Look for category in our list, and if found, add its name */
- for (i = 0; i <= highest_index; i++) {
- if (category == categories[i]) {
- my_strlcat(ret, category_names[i], sizeof(ret));
- goto found_category;
- }
- }
-
- /* Unknown category to us */
- my_snprintf(ret, sizeof(ret), "%s? %d", ret, category);
-
- found_category:
-
+ my_strlcat(ret, category_name(category), sizeof(ret));
my_strlcat(ret, ", ", sizeof(ret));
if (locale) {
https://perl5.git.perl.org / perl5.git / blobdiff