static int internal_function FCT (const CHAR *pattern, const CHAR *string, const CHAR *string_end, bool no_leading_period, int flags) { register const CHAR *p = pattern, *n = string; register UCHAR c; #ifdef _LIBC # if WIDE_CHAR_VERSION const char *collseq = (const char *) _NL_CURRENT(LC_COLLATE, _NL_COLLATE_COLLSEQWC); # else const UCHAR *collseq = (const UCHAR *) _NL_CURRENT(LC_COLLATE, _NL_COLLATE_COLLSEQMB); # endif #endif while ((c = *p++) != L('\0')) { bool new_no_leading_period = false; c = FOLD (c); switch (c) { case L('?'): if (__builtin_expect (flags & FNM_EXTMATCH, 0) && *p == '(') { int res; res = EXT (c, p, n, string_end, no_leading_period, flags); if (res != -1) return res; } if (n == string_end) return FNM_NOMATCH; else if (*n == L('/') && (flags & FNM_FILE_NAME)) return FNM_NOMATCH; else if (*n == L('.') && no_leading_period) return FNM_NOMATCH; break; case L('\\'): if (!(flags & FNM_NOESCAPE)) { c = *p++; if (c == L('\0')) /* Trailing \ loses. */ return FNM_NOMATCH; c = FOLD (c); } if (n == string_end || FOLD ((UCHAR) *n) != c) return FNM_NOMATCH; break; case L('*'): if (__builtin_expect (flags & FNM_EXTMATCH, 0) && *p == '(') { int res; res = EXT (c, p, n, string_end, no_leading_period, flags); if (res != -1) return res; } if (n != string_end && *n == L('.') && no_leading_period) return FNM_NOMATCH; for (c = *p++; c == L('?') || c == L('*'); c = *p++) { if (*p == L('(') && (flags & FNM_EXTMATCH) != 0) { const CHAR *endp = END (p); if (endp != p) { /* This is a pattern. Skip over it. */ p = endp; continue; } } if (c == L('?')) { /* A ? needs to match one character. */ if (n == string_end) /* There isn't another character; no match. */ return FNM_NOMATCH; else if (*n == L('/') && __builtin_expect (flags & FNM_FILE_NAME, 0)) /* A slash does not match a wildcard under FNM_FILE_NAME. */ return FNM_NOMATCH; else /* One character of the string is consumed in matching this ? wildcard, so *??? won't match if there are less than three characters. */ ++n; } } if (c == L('\0')) /* The wildcard(s) is/are the last element of the pattern. If the name is a file name and contains another slash this means it cannot match, unless the FNM_LEADING_DIR flag is set. */ { int result = (flags & FNM_FILE_NAME) == 0 ? 0 : FNM_NOMATCH; if (flags & FNM_FILE_NAME) { if (flags & FNM_LEADING_DIR) result = 0; else { if (MEMCHR (n, L('/'), string_end - n) == NULL) result = 0; } } return result; } else { const CHAR *endp; endp = MEMCHR (n, (flags & FNM_FILE_NAME) ? L('/') : L('\0'), string_end - n); if (endp == NULL) endp = string_end; if (c == L('[') || (__builtin_expect (flags & FNM_EXTMATCH, 0) != 0 && (c == L('@') || c == L('+') || c == L('!')) && *p == L('('))) { int flags2 = ((flags & FNM_FILE_NAME) ? flags : (flags & ~FNM_PERIOD)); bool no_leading_period2 = no_leading_period; for (--p; n < endp; ++n, no_leading_period2 = false) if (FCT (p, n, string_end, no_leading_period2, flags2) == 0) return 0; } else if (c == L('/') && (flags & FNM_FILE_NAME)) { while (n < string_end && *n != L('/')) ++n; if (n < string_end && *n == L('/') && (FCT (p, n + 1, string_end, flags & FNM_PERIOD, flags) == 0)) return 0; } else { int flags2 = ((flags & FNM_FILE_NAME) ? flags : (flags & ~FNM_PERIOD)); int no_leading_period2 = no_leading_period; if (c == L('\\') && !(flags & FNM_NOESCAPE)) c = *p; c = FOLD (c); for (--p; n < endp; ++n, no_leading_period2 = false) if (FOLD ((UCHAR) *n) == c && (FCT (p, n, string_end, no_leading_period2, flags2) == 0)) return 0; } } /* If we come here no match is possible with the wildcard. */ return FNM_NOMATCH; case L('['): { /* Nonzero if the sense of the character class is inverted. */ register bool not; CHAR cold; UCHAR fn; if (posixly_correct == 0) posixly_correct = getenv ("POSIXLY_CORRECT") != NULL ? 1 : -1; if (n == string_end) return FNM_NOMATCH; if (*n == L('.') && no_leading_period) return FNM_NOMATCH; if (*n == L('/') && (flags & FNM_FILE_NAME)) /* `/' cannot be matched. */ return FNM_NOMATCH; not = (*p == L('!') || (posixly_correct < 0 && *p == L('^'))); if (not) ++p; fn = FOLD ((UCHAR) *n); c = *p++; for (;;) { if (!(flags & FNM_NOESCAPE) && c == L('\\')) { if (*p == L('\0')) return FNM_NOMATCH; c = FOLD ((UCHAR) *p); ++p; if (c == fn) goto matched; } else if (c == L('[') && *p == L(':')) { /* Leave room for the null. */ CHAR str[CHAR_CLASS_MAX_LENGTH + 1]; size_t c1 = 0; #if defined _LIBC || WIDE_CHAR_SUPPORT wctype_t wt; #endif const CHAR *startp = p; for (;;) { if (c1 == CHAR_CLASS_MAX_LENGTH) /* The name is too long and therefore the pattern is ill-formed. */ return FNM_NOMATCH; c = *++p; if (c == L(':') && p[1] == L(']')) { p += 2; break; } if (c < L('a') || c >= L('z')) { /* This cannot possibly be a character class name. Match it as a normal range. */ p = startp; c = L('['); goto normal_bracket; } str[c1++] = c; } str[c1] = L('\0'); #if defined _LIBC || WIDE_CHAR_SUPPORT wt = IS_CHAR_CLASS (str); if (wt == 0) /* Invalid character class name. */ return FNM_NOMATCH; # if defined _LIBC && ! WIDE_CHAR_VERSION /* The following code is glibc specific but does there a good job in speeding up the code since we can avoid the btowc() call. */ if (_ISCTYPE ((UCHAR) *n, wt)) goto matched; # else if (ISWCTYPE (BTOWC ((UCHAR) *n), wt)) goto matched; # endif #else if ((STREQ (str, L("alnum")) && ISALNUM ((UCHAR) *n)) || (STREQ (str, L("alpha")) && ISALPHA ((UCHAR) *n)) || (STREQ (str, L("blank")) && ISBLANK ((UCHAR) *n)) || (STREQ (str, L("cntrl")) && ISCNTRL ((UCHAR) *n)) || (STREQ (str, L("digit")) && ISDIGIT ((UCHAR) *n)) || (STREQ (str, L("graph")) && ISGRAPH ((UCHAR) *n)) || (STREQ (str, L("lower")) && ISLOWER ((UCHAR) *n)) || (STREQ (str, L("print")) && ISPRINT ((UCHAR) *n)) || (STREQ (str, L("punct")) && ISPUNCT ((UCHAR) *n)) || (STREQ (str, L("space")) && ISSPACE ((UCHAR) *n)) || (STREQ (str, L("upper")) && ISUPPER ((UCHAR) *n)) || (STREQ (str, L("xdigit")) && ISXDIGIT ((UCHAR) *n))) goto matched; #endif c = *p++; } #ifdef _LIBC else if (c == L('[') && *p == L('=')) { UCHAR str[1]; uint32_t nrules = _NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES); const CHAR *startp = p; c = *++p; if (c == L('\0')) { p = startp; c = L('['); goto normal_bracket; } str[0] = c; c = *++p; if (c != L('=') || p[1] != L(']')) { p = startp; c = L('['); goto normal_bracket; } p += 2; if (nrules == 0) { if ((UCHAR) *n == str[0]) goto matched; } else { const int32_t *table; # if WIDE_CHAR_VERSION const int32_t *weights; const int32_t *extra; # else const unsigned char *weights; const unsigned char *extra; # endif const int32_t *indirect; int32_t idx; const UCHAR *cp = (const UCHAR *) str; /* This #include defines a local function! */ # if WIDE_CHAR_VERSION # include <locale/weightwc.h> # else # include <locale/weight.h> # endif # if WIDE_CHAR_VERSION table = (const int32_t *) _NL_CURRENT (LC_COLLATE, _NL_COLLATE_TABLEWC); weights = (const int32_t *) _NL_CURRENT (LC_COLLATE, _NL_COLLATE_WEIGHTWC); extra = (const int32_t *) _NL_CURRENT (LC_COLLATE, _NL_COLLATE_EXTRAWC); indirect = (const int32_t *) _NL_CURRENT (LC_COLLATE, _NL_COLLATE_INDIRECTWC); # else table = (const int32_t *) _NL_CURRENT (LC_COLLATE, _NL_COLLATE_TABLEMB); weights = (const unsigned char *) _NL_CURRENT (LC_COLLATE, _NL_COLLATE_WEIGHTMB); extra = (const unsigned char *) _NL_CURRENT (LC_COLLATE, _NL_COLLATE_EXTRAMB); indirect = (const int32_t *) _NL_CURRENT (LC_COLLATE, _NL_COLLATE_INDIRECTMB); # endif idx = findidx (&cp); if (idx != 0) { /* We found a table entry. Now see whether the character we are currently at has the same equivalance class value. */ int len = weights[idx]; int32_t idx2; const UCHAR *np = (const UCHAR *) n; idx2 = findidx (&np); if (idx2 != 0 && len == weights[idx2]) { int cnt = 0; while (cnt < len && (weights[idx + 1 + cnt] == weights[idx2 + 1 + cnt])) ++cnt; if (cnt == len) goto matched; } } } c = *p++; } #endif else if (c == L('\0')) /* [ (unterminated) loses. */ return FNM_NOMATCH; else { bool is_range = false; #ifdef _LIBC bool is_seqval = false; if (c == L('[') && *p == L('.')) { uint32_t nrules = _NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES); const CHAR *startp = p; size_t c1 = 0; while (1) { c = *++p; if (c == L('.') && p[1] == L(']')) { p += 2; break; } if (c == '\0') return FNM_NOMATCH; ++c1; } /* We have to handling the symbols differently in ranges since then the collation sequence is important. */ is_range = *p == L('-') && p[1] != L('\0'); if (nrules == 0) { /* There are no names defined in the collation data. Therefore we only accept the trivial names consisting of the character itself. */ if (c1 != 1) return FNM_NOMATCH; if (!is_range && *n == startp[1]) goto matched; cold = startp[1]; c = *p++; } else { int32_t table_size; const int32_t *symb_table; # ifdef WIDE_CHAR_VERSION char str[c1]; size_t strcnt; # else # define str (startp + 1) # endif const unsigned char *extra; int32_t idx; int32_t elem; int32_t second; int32_t hash; # ifdef WIDE_CHAR_VERSION /* We have to convert the name to a single-byte string. This is possible since the names consist of ASCII characters and the internal representation is UCS4. */ for (strcnt = 0; strcnt < c1; ++strcnt) str[strcnt] = startp[1 + strcnt]; # endif table_size = _NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_SYMB_HASH_SIZEMB); symb_table = (const int32_t *) _NL_CURRENT (LC_COLLATE, _NL_COLLATE_SYMB_TABLEMB); extra = (const unsigned char *) _NL_CURRENT (LC_COLLATE, _NL_COLLATE_SYMB_EXTRAMB); /* Locate the character in the hashing table. */ hash = elem_hash (str, c1); idx = 0; elem = hash % table_size; second = hash % (table_size - 2); while (symb_table[2 * elem] != 0) { /* First compare the hashing value. */ if (symb_table[2 * elem] == hash && c1 == extra[symb_table[2 * elem + 1]] && memcmp (str, &extra[symb_table[2 * elem + 1] + 1], c1) == 0) { /* Yep, this is the entry. */ idx = symb_table[2 * elem + 1]; idx += 1 + extra[idx]; break; } /* Next entry. */ elem += second; } if (symb_table[2 * elem] != 0) { /* Compare the byte sequence but only if this is not part of a range. */ # ifdef WIDE_CHAR_VERSION int32_t *wextra; idx += 1 + extra[idx]; /* Adjust for the alignment. */ idx = (idx + 3) & ~3; wextra = (int32_t *) &extra[idx + 4]; # endif if (! is_range) { # ifdef WIDE_CHAR_VERSION for (c1 = 0; (int32_t) c1 < wextra[idx]; ++c1) if (n[c1] != wextra[1 + c1]) break; if ((int32_t) c1 == wextra[idx]) goto matched; # else for (c1 = 0; c1 < extra[idx]; ++c1) if (n[c1] != extra[1 + c1]) break; if (c1 == extra[idx]) goto matched; # endif } /* Get the collation sequence value. */ is_seqval = true; # ifdef WIDE_CHAR_VERSION cold = wextra[1 + wextra[idx]]; # else /* Adjust for the alignment. */ idx += 1 + extra[idx]; idx = (idx + 3) & ~4; cold = *((int32_t *) &extra[idx]); # endif c = *p++; } else if (c1 == 1) { /* No valid character. Match it as a single byte. */ if (!is_range && *n == str[0]) goto matched; cold = str[0]; c = *p++; } else return FNM_NOMATCH; } } else # undef str #endif { c = FOLD (c); normal_bracket: /* We have to handling the symbols differently in ranges since then the collation sequence is important. */ is_range = (*p == L('-') && p[1] != L('\0') && p[1] != L(']')); if (!is_range && c == fn) goto matched; cold = c; c = *p++; } if (c == L('-') && *p != L(']')) { #if _LIBC /* We have to find the collation sequence value for C. Collation sequence is nothing we can regularly access. The sequence value is defined by the order in which the definitions of the collation values for the various characters appear in the source file. A strange concept, nowhere documented. */ uint32_t fcollseq; uint32_t lcollseq; UCHAR cend = *p++; # ifdef WIDE_CHAR_VERSION /* Search in the `names' array for the characters. */ fcollseq = __collseq_table_lookup (collseq, fn); if (fcollseq == ~((uint32_t) 0)) /* XXX We don't know anything about the character we are supposed to match. This means we are failing. */ goto range_not_matched; if (is_seqval) lcollseq = cold; else lcollseq = __collseq_table_lookup (collseq, cold); # else fcollseq = collseq[fn]; lcollseq = is_seqval ? cold : collseq[(UCHAR) cold]; # endif is_seqval = false; if (cend == L('[') && *p == L('.')) { uint32_t nrules = _NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES); const CHAR *startp = p; size_t c1 = 0; while (1) { c = *++p; if (c == L('.') && p[1] == L(']')) { p += 2; break; } if (c == '\0') return FNM_NOMATCH; ++c1; } if (nrules == 0) { /* There are no names defined in the collation data. Therefore we only accept the trivial names consisting of the character itself. */ if (c1 != 1) return FNM_NOMATCH; cend = startp[1]; } else { int32_t table_size; const int32_t *symb_table; # ifdef WIDE_CHAR_VERSION char str[c1]; size_t strcnt; # else # define str (startp + 1) # endif const unsigned char *extra; int32_t idx; int32_t elem; int32_t second; int32_t hash; # ifdef WIDE_CHAR_VERSION /* We have to convert the name to a single-byte string. This is possible since the names consist of ASCII characters and the internal representation is UCS4. */ for (strcnt = 0; strcnt < c1; ++strcnt) str[strcnt] = startp[1 + strcnt]; # endif table_size = _NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_SYMB_HASH_SIZEMB); symb_table = (const int32_t *) _NL_CURRENT (LC_COLLATE, _NL_COLLATE_SYMB_TABLEMB); extra = (const unsigned char *) _NL_CURRENT (LC_COLLATE, _NL_COLLATE_SYMB_EXTRAMB); /* Locate the character in the hashing table. */ hash = elem_hash (str, c1); idx = 0; elem = hash % table_size; second = hash % (table_size - 2); while (symb_table[2 * elem] != 0) { /* First compare the hashing value. */ if (symb_table[2 * elem] == hash && (c1 == extra[symb_table[2 * elem + 1]]) && memcmp (str, &extra[symb_table[2 * elem + 1] + 1], c1) == 0) { /* Yep, this is the entry. */ idx = symb_table[2 * elem + 1]; idx += 1 + extra[idx]; break; } /* Next entry. */ elem += second; } if (symb_table[2 * elem] != 0) { /* Compare the byte sequence but only if this is not part of a range. */ # ifdef WIDE_CHAR_VERSION int32_t *wextra; idx += 1 + extra[idx]; /* Adjust for the alignment. */ idx = (idx + 3) & ~4; wextra = (int32_t *) &extra[idx + 4]; # endif /* Get the collation sequence value. */ is_seqval = true; # ifdef WIDE_CHAR_VERSION cend = wextra[1 + wextra[idx]]; # else /* Adjust for the alignment. */ idx += 1 + extra[idx]; idx = (idx + 3) & ~4; cend = *((int32_t *) &extra[idx]); # endif } else if (symb_table[2 * elem] != 0 && c1 == 1) { cend = str[0]; c = *p++; } else return FNM_NOMATCH; } # undef str } else { if (!(flags & FNM_NOESCAPE) && cend == L('\\')) cend = *p++; if (cend == L('\0')) return FNM_NOMATCH; cend = FOLD (cend); } /* XXX It is not entirely clear to me how to handle characters which are not mentioned in the collation specification. */ if ( # ifdef WIDE_CHAR_VERSION lcollseq == 0xffffffff || # endif lcollseq <= fcollseq) { /* We have to look at the upper bound. */ uint32_t hcollseq; if (is_seqval) hcollseq = cend; else { # ifdef WIDE_CHAR_VERSION hcollseq = __collseq_table_lookup (collseq, cend); if (hcollseq == ~((uint32_t) 0)) { /* Hum, no information about the upper bound. The matching succeeds if the lower bound is matched exactly. */ if (lcollseq != fcollseq) goto range_not_matched; goto matched; } # else hcollseq = collseq[cend]; # endif } if (lcollseq <= hcollseq && fcollseq <= hcollseq) goto matched; } # ifdef WIDE_CHAR_VERSION range_not_matched: # endif #else /* We use a boring value comparison of the character values. This is better than comparing using `strcoll' since the latter would have surprising and sometimes fatal consequences. */ UCHAR cend = *p++; if (!(flags & FNM_NOESCAPE) && cend == L('\\')) cend = *p++; if (cend == L('\0')) return FNM_NOMATCH; /* It is a range. */ if (cold <= fn && fn <= cend) goto matched; #endif c = *p++; } } if (c == L(']')) break; } if (!not) return FNM_NOMATCH; break; matched: /* Skip the rest of the [...] that already matched. */ do { ignore_next: c = *p++; if (c == L('\0')) /* [... (unterminated) loses. */ return FNM_NOMATCH; if (!(flags & FNM_NOESCAPE) && c == L('\\')) { if (*p == L('\0')) return FNM_NOMATCH; /* XXX 1003.2d11 is unclear if this is right. */ ++p; } else if (c == L('[') && *p == L(':')) { int c1 = 0; const CHAR *startp = p; while (1) { c = *++p; if (++c1 == CHAR_CLASS_MAX_LENGTH) return FNM_NOMATCH; if (*p == L(':') && p[1] == L(']')) break; if (c < L('a') || c >= L('z')) { p = startp; goto ignore_next; } } p += 2; c = *p++; } else if (c == L('[') && *p == L('=')) { c = *++p; if (c == L('\0')) return FNM_NOMATCH; c = *++p; if (c != L('=') || p[1] != L(']')) return FNM_NOMATCH; p += 2; c = *p++; } else if (c == L('[') && *p == L('.')) { ++p; while (1) { c = *++p; if (c == '\0') return FNM_NOMATCH; if (*p == L('.') && p[1] == L(']')) break; } p += 2; c = *p++; } } while (c != L(']')); if (not) return FNM_NOMATCH; } break; case L('+'): case L('@'): case L('!'): if (__builtin_expect (flags & FNM_EXTMATCH, 0) && *p == '(') { int res; res = EXT (c, p, n, string_end, no_leading_period, flags); if (res != -1) return res; } goto normal_match; case L('/'): if (NO_LEADING_PERIOD (flags)) { if (n == string_end || c != (UCHAR) *n) return FNM_NOMATCH; new_no_leading_period = true; break; } /* FALLTHROUGH */ default: normal_match: if (n == string_end || c != FOLD ((UCHAR) *n)) return FNM_NOMATCH; } no_leading_period = new_no_leading_period; ++n; } if (n == string_end) return 0; if ((flags & FNM_LEADING_DIR) && n != string_end && *n == L('/')) /* The FNM_LEADING_DIR flag says that "foo*" matches "foobar/frobozz". */ return 0; return FNM_NOMATCH; }
static void _nl_init_era_entries (void) { size_t cnt; __libc_lock_lock (__libc_setlocale_lock); if (era_initialized == 0) { size_t new_num_eras = _NL_CURRENT_WORD (LC_TIME, _NL_TIME_ERA_NUM_ENTRIES); if (new_num_eras == 0) { free (eras); eras = NULL; } else { if (num_eras != new_num_eras) eras = (struct era_entry *) realloc (eras, new_num_eras * sizeof (struct era_entry)); if (eras == NULL) { num_eras = 0; eras = NULL; } else { const char *ptr = _NL_CURRENT (LC_TIME, _NL_TIME_ERA_ENTRIES); num_eras = new_num_eras; for (cnt = 0; cnt < num_eras; ++cnt) { const char *base_ptr = ptr; memcpy ((void *) (eras + cnt), (const void *) ptr, sizeof (uint32_t) * 8); if (ERA_DATE_CMP(eras[cnt].start_date, eras[cnt].stop_date)) if (eras[cnt].direction == (uint32_t) '+') eras[cnt].absolute_direction = 1; else eras[cnt].absolute_direction = -1; else if (eras[cnt].direction == (uint32_t) '+') eras[cnt].absolute_direction = -1; else eras[cnt].absolute_direction = 1; /* Skip numeric values. */ ptr += sizeof (uint32_t) * 8; /* Set and skip era name. */ eras[cnt].era_name = ptr; ptr = strchr (ptr, '\0') + 1; /* Set and skip era format. */ eras[cnt].era_format = ptr; ptr = strchr (ptr, '\0') + 1; ptr += 3 - (((ptr - (const char *) base_ptr) + 3) & 3); /* Set and skip wide era name. */ eras[cnt].era_wname = (wchar_t *) ptr; ptr = (char *) (wcschr ((wchar_t *) ptr, L'\0') + 1); /* Set and skip wide era format. */ eras[cnt].era_wformat = (wchar_t *) ptr; ptr = (char *) (wcschr ((wchar_t *) ptr, L'\0') + 1); } } } era_initialized = 1; } __libc_lock_unlock (__libc_setlocale_lock); }
int __printf_fphex (FILE *fp, const struct printf_info *info, const void *const *args) { /* The floating-point value to output. */ union { union ieee754_double dbl; long double ldbl; } fpnum; /* Locale-dependent representation of decimal point. */ const char *decimal; wchar_t decimalwc; /* "NaN" or "Inf" for the special cases. */ const char *special = NULL; const wchar_t *wspecial = NULL; /* Buffer for the generated number string for the mantissa. The maximal size for the mantissa is 128 bits. */ char numbuf[32]; char *numstr; char *numend; wchar_t wnumbuf[32]; wchar_t *wnumstr; wchar_t *wnumend; int negative; /* The maximal exponent of two in decimal notation has 5 digits. */ char expbuf[5]; char *expstr; wchar_t wexpbuf[5]; wchar_t *wexpstr; int expnegative; int exponent; /* Non-zero is mantissa is zero. */ int zero_mantissa; /* The leading digit before the decimal point. */ char leading; /* Precision. */ int precision = info->prec; /* Width. */ int width = info->width; /* Number of characters written. */ int done = 0; /* Nonzero if this is output on a wide character stream. */ int wide = info->wide; /* Figure out the decimal point character. */ if (info->extra == 0) { decimal = _NL_CURRENT (LC_NUMERIC, DECIMAL_POINT); decimalwc = _NL_CURRENT_WORD (LC_NUMERIC, _NL_NUMERIC_DECIMAL_POINT_WC); } else { decimal = _NL_CURRENT (LC_MONETARY, MON_DECIMAL_POINT); decimalwc = _NL_CURRENT_WORD (LC_MONETARY, _NL_MONETARY_DECIMAL_POINT_WC); } /* The decimal point character must never be zero. */ assert (*decimal != '\0' && decimalwc != L'\0'); /* Fetch the argument value. */ #ifndef __NO_LONG_DOUBLE_MATH if (info->is_long_double && sizeof (long double) > sizeof (double)) { fpnum.ldbl = *(const long double *) args[0]; /* Check for special values: not a number or infinity. */ if (isnan (fpnum.ldbl)) { if (isupper (info->spec)) { special = "NAN"; wspecial = L"NAN"; } else { special = "nan"; wspecial = L"nan"; } } else { if (isinf (fpnum.ldbl)) { if (isupper (info->spec)) { special = "INF"; wspecial = L"INF"; } else { special = "inf"; wspecial = L"inf"; } } } negative = signbit (fpnum.ldbl); } else #endif /* no long double */ { fpnum.dbl.d = *(const double *) args[0]; /* Check for special values: not a number or infinity. */ if (isnan (fpnum.dbl.d)) { if (isupper (info->spec)) { special = "NAN"; wspecial = L"NAN"; } else { special = "nan"; wspecial = L"nan"; } } else { if (isinf (fpnum.dbl.d)) { if (isupper (info->spec)) { special = "INF"; wspecial = L"INF"; } else { special = "inf"; wspecial = L"inf"; } } } negative = signbit (fpnum.dbl.d); } if (special) { int width = info->width; if (negative || info->showsign || info->space) --width; width -= 3; if (!info->left && width > 0) PADN (' ', width); if (negative) outchar ('-'); else if (info->showsign) outchar ('+'); else if (info->space) outchar (' '); PRINT (special, wspecial, 3); if (info->left && width > 0) PADN (' ', width); return done; } if (info->is_long_double == 0 || sizeof (double) == sizeof (long double)) { /* We have 52 bits of mantissa plus one implicit digit. Since 52 bits are representable without rest using hexadecimal digits we use only the implicit digits for the number before the decimal point. */ unsigned long long int num; num = (((unsigned long long int) fpnum.dbl.ieee.mantissa0) << 32 | fpnum.dbl.ieee.mantissa1); zero_mantissa = num == 0; if (sizeof (unsigned long int) > 6) { wnumstr = _itowa_word (num, wnumbuf + (sizeof wnumbuf) / sizeof (wchar_t), 16, info->spec == 'A'); numstr = _itoa_word (num, numbuf + sizeof numbuf, 16, info->spec == 'A'); } else { wnumstr = _itowa (num, wnumbuf + sizeof wnumbuf / sizeof (wchar_t), 16, info->spec == 'A'); numstr = _itoa (num, numbuf + sizeof numbuf, 16, info->spec == 'A'); } /* Fill with zeroes. */ while (wnumstr > wnumbuf + (sizeof wnumbuf - 52) / sizeof (wchar_t)) { *--wnumstr = L'0'; *--numstr = '0'; } leading = fpnum.dbl.ieee.exponent == 0 ? '0' : '1'; exponent = fpnum.dbl.ieee.exponent; if (exponent == 0) { if (zero_mantissa) expnegative = 0; else { /* This is a denormalized number. */ expnegative = 1; exponent = IEEE754_DOUBLE_BIAS - 1; } } else if (exponent >= IEEE754_DOUBLE_BIAS) { expnegative = 0; exponent -= IEEE754_DOUBLE_BIAS; } else { expnegative = 1; exponent = -(exponent - IEEE754_DOUBLE_BIAS); } } #ifdef PRINT_FPHEX_LONG_DOUBLE else PRINT_FPHEX_LONG_DOUBLE; #endif /* Look for trailing zeroes. */ if (! zero_mantissa) { wnumend = &wnumbuf[sizeof wnumbuf / sizeof wnumbuf[0]]; numend = &numbuf[sizeof numbuf / sizeof numbuf[0]]; while (wnumend[-1] == L'0') { --wnumend; --numend; } bool do_round_away = false; if (precision != -1 && precision < numend - numstr) { char last_digit = precision > 0 ? numstr[precision - 1] : leading; char next_digit = numstr[precision]; int last_digit_value = (last_digit >= 'A' && last_digit <= 'F' ? last_digit - 'A' + 10 : (last_digit >= 'a' && last_digit <= 'f' ? last_digit - 'a' + 10 : last_digit - '0')); int next_digit_value = (next_digit >= 'A' && next_digit <= 'F' ? next_digit - 'A' + 10 : (next_digit >= 'a' && next_digit <= 'f' ? next_digit - 'a' + 10 : next_digit - '0')); bool more_bits = ((next_digit_value & 7) != 0 || precision + 1 < numend - numstr); int rounding_mode = get_rounding_mode (); do_round_away = round_away (negative, last_digit_value & 1, next_digit_value >= 8, more_bits, rounding_mode); } if (precision == -1) precision = numend - numstr; else if (do_round_away) { /* Round up. */ int cnt = precision; while (--cnt >= 0) { char ch = numstr[cnt]; /* We assume that the digits and the letters are ordered like in ASCII. This is true for the rest of GNU, too. */ if (ch == '9') { wnumstr[cnt] = (wchar_t) info->spec; numstr[cnt] = info->spec; /* This is tricky, think about it! */ break; } else if (tolower (ch) < 'f') { ++numstr[cnt]; ++wnumstr[cnt]; break; } else { numstr[cnt] = '0'; wnumstr[cnt] = L'0'; } } if (cnt < 0) { /* The mantissa so far was fff...f Now increment the leading digit. Here it is again possible that we get an overflow. */ if (leading == '9') leading = info->spec; else if (tolower (leading) < 'f') ++leading; else { leading = '1'; if (expnegative) { exponent -= 4; if (exponent <= 0) { exponent = -exponent; expnegative = 0; } } else exponent += 4; } } } } else { if (precision == -1) precision = 0; numend = numstr; wnumend = wnumstr; } /* Now we can compute the exponent string. */ expstr = _itoa_word (exponent, expbuf + sizeof expbuf, 10, 0); wexpstr = _itowa_word (exponent, wexpbuf + sizeof wexpbuf / sizeof (wchar_t), 10, 0); /* Now we have all information to compute the size. */ width -= ((negative || info->showsign || info->space) /* Sign. */ + 2 + 1 + 0 + precision + 1 + 1 /* 0x h . hhh P ExpoSign. */ + ((expbuf + sizeof expbuf) - expstr)); /* Exponent. */ /* Count the decimal point. A special case when the mantissa or the precision is zero and the `#' is not given. In this case we must not print the decimal point. */ if (precision > 0 || info->alt) width -= wide ? 1 : strlen (decimal); if (!info->left && info->pad != '0' && width > 0) PADN (' ', width); if (negative) outchar ('-'); else if (info->showsign) outchar ('+'); else if (info->space) outchar (' '); outchar ('0'); if ('X' - 'A' == 'x' - 'a') outchar (info->spec + ('x' - 'a')); else outchar (info->spec == 'A' ? 'X' : 'x'); if (!info->left && info->pad == '0' && width > 0) PADN ('0', width); outchar (leading); if (precision > 0 || info->alt) { const wchar_t *wtmp = &decimalwc; PRINT (decimal, wtmp, wide ? 1 : strlen (decimal)); } if (precision > 0) { ssize_t tofill = precision - (numend - numstr); PRINT (numstr, wnumstr, MIN (numend - numstr, precision)); if (tofill > 0) PADN ('0', tofill); } if ('P' - 'A' == 'p' - 'a') outchar (info->spec + ('p' - 'a')); else outchar (info->spec == 'A' ? 'P' : 'p'); outchar (expnegative ? '-' : '+'); PRINT (expstr, wexpstr, (expbuf + sizeof expbuf) - expstr); if (info->left && info->pad != '0' && width > 0) PADN (info->pad, width); return done; }
/* We provide support for some special names. This helps debugging and may be useful for advanced usage of the provided information outside C. */ void locale_special (const char *name, int show_category_name, int show_keyword_name) { #if 0 /* "collate-elements": print collation elements of locale. */ if (strcmp (name, "collate-elements") == 0) { size_t nelem = _NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_ELEM_HASH_SIZE); if (show_category_name) puts ("LC_COLLATE"); if (show_keyword_name) fputs ("collate-elements=", stdout); if (nelem != 0) { int first = 1; size_t cnt; for (cnt = 0; cnt < nelem; ++cnt) if (__collate_element_hash[2 * cnt] != (~((u_int32_t) 0))) { size_t idx = __collate_element_hash[2 * cnt]; printf ("%s<%s>", first ? "" : ";", &__collate_element_strings[idx]); /* We don't print the string. This is only confusing because only the programs have to know the encoding. The code is left in place because it shows how to get the information. */ { const wchar_t *wp; idx = __collate_element_hash[2 * cnt + 1]; wp = &__collate_element_values[idx]; while (*wp != L'\0') { /********************************************\ |* XXX The element values are really wide *| |* chars. But we are currently not able to *| |* print these so fake here. *| \********************************************/ int ch = wctob (*wp++); if (ch != EOF) putchar (ch); else fputs ("<??\?>", stdout); } putchar ('"'); } first = 0; } } putchar ('\n'); return; } if (strcmp (name, "collate-classes") == 0) { size_t nelem = _NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_SYMB_HASH_SIZE); size_t cnt; int first = 1; if (show_category_name) puts ("LC_COLLATE"); if (show_keyword_name) fputs ("collate-classes=", stdout); for (cnt = 0; cnt < nelem; ++cnt) if (__collate_symbol_hash[2 * cnt] != 0xffffffff) { printf ("%s<%s>", first ? "" : ",", &__collate_symbol_strings[__collate_symbol_hash[2 * cnt]]); #if 0 { size_t idx = __collate_symbol_hash[2 * cnt + 1]; size_t cls; putchar ('='); for (cls = 0; cls < __collate_symbol_classes[idx]; ++cls) printf ("%s%d", cls == 0 ? "" : ":", __collate_symbol_classes[idx + 1 + cls]); } #endif first = 0; } putchar ('\n'); return; } #endif }