+2004-03-14 Ulrich Drepper <drepper@redhat.com>
+
+ Make the non-_l functions wrappers around the _l functions.
+ * include/monetary.h: Declare __vstrmon_l.
+ * include/string.h: Add libc_hidden_proto for __strcoll_l and
+ __strxfrm_l.
+ * include/time.h: Define ptime_locale_status. Declare
+ __strptime_internal.
+ * include/wchar.h: Add libc_hidden_proto for __wcscoll_l and
+ __wcsxfrm_l.
+ * stdlib/strfmon.c: Move the code to strfmon_l.c. Add little
+ wrapper around __vstrfmon_l.
+ * stdlib/strfmon_l.c: Add real implementation. Split into new
+ function __vstrfmon_l to allow calling it from strfmon.
+ * stdlib/strtod.c: Move real code to strtod_l.c and add wrapper.
+ * stdlib/strtod_l.c: Add real implementation.
+ * stdlib/strtof.c: Adjust to changed strtod.c.
+ * stdlib/strtof_l.c: Include strtod_l.c now.
+ * stdlib/strtold.c: New file.
+ * stdlib/strtold_l.c: Removed.
+ * string/strcoll.c: Move real code to strcoll_l.c: Add wrapper.
+ * string/strcoll_l.c: Add real implementation.
+ * string/strxfrm.c: Move real code to strxfrm_l.c: Add wrapper.
+ * string/strxfrm_l.c: Add real implementation.
+ * sysdeps/generic/strtol.c: Move real implementation to strtol_l.c.
+ Add wrappers.
+ * sysdeps/generic/strtol_l.c: Add real implementation.
+ * sysdeps/generic/strtold.c: Removed.
+ * sysdeps/generic/strtold_l.c: New file.
+ * sysdeps/generic/strtoll_l.c: Include strtol_l.c now. Adjust
+ #defines.
+ * sysdeps/generic/strtoul_l.c: Likewise.
+ * sysdeps/generic/strtoull_l.c: Likewise.
+ * sysdeps/generic/wcstol_l.c: Likewise.
+ * sysdeps/generic/wcstoll_l.c: Likewise.
+ * sysdeps/generic/wcstoul_l.c: Likewise.
+ * sysdeps/generic/wcstoull_l.c: Likewise.
+ * sysdeps/ieee754/ldbl-128/strtold.c: Removed.
+ * sysdeps/ieee754/ldbl-128/strtold_l.c: New file.
+ * sysdeps/ieee754/ldbl-96/strtold.c: Removed.
+ * sysdeps/ieee754/ldbl-96/strtold_l.c: New file.
+ * sysdeps/m68k/strtold.c: Removed.
+ * sysdeps/m68k/strtold_l.c: New file.
+ * time/strftime.c: Move real code to strftime_l.c. Add wrapper.
+ * time/strftime_l.c: Add real implementation.
+ * time/strptime.c: Move real code to strptime_l.c. Add wrapper.
+ * time/strptime_l.c: Add real implementation.
+ * time/wcsftime.c: Simplify since only wrappers are defined in
+ strftime.c.
+ * time/wcsftime_l.c: Include strftime_l.c.
+ * wcsmbs/wcscoll.c: Simplify since the file is not used by wcscoll_l.c
+ anymore.
+ * wcsmbs/wcscoll_l.c: Include strcoll_l.c.
+ * wcsmbs/wcsxfrm.c: Simplify since the file is not used by wcsxfrm_l.c
+ anymore.
+ * wcsmbs/wcsxfrm_l.c: Include strxfrm_l.c.
+ * wcsmbs/wcstod.c: Prepare to include new strtod.c.
+ * wcsmbs/wcstod_l.c: Include strtod_l.c.
+ * wcsmbs/wcstof.c: Prepare to include new strtof.c.
+ * wcsmbs/wcstof_l.c: Include strtof_l.c.
+ * wcsmbs/wcstold.c: Prepare to include new strtold.c.
+ * wcsmbs/wcstold_l.c: Include strtold_l.c.
+
+ * locale/uselocale.c: Use _NL_CURRENT_LOCALE instead of __libc_tsd_get.
+
+ * sysdeps/generic/strcasecmp.c: Optimize a bit. It's better to get
+ a reference to the current locale and then use the _l functions.
+ * sysdeps/generic/strncase.c: Likewise.
+
2004-03-11 Jeroen Dekkers <jeroen@dekkers.cx>
* cppflags-iterator.mk: Change libof-$(cpp-src) to
#include <stdlib/monetary.h>
+#include <stdarg.h>
+
+extern ssize_t __vstrfmon_l (char *s, size_t maxsize, __locale_t loc,
+ const char *format, va_list ap);
libc_hidden_proto (__strverscmp)
libc_hidden_proto (basename)
libc_hidden_proto (strcoll)
+libc_hidden_proto (__strcoll_l)
+libc_hidden_proto (__strxfrm_l)
libc_hidden_builtin_proto (memchr)
libc_hidden_builtin_proto (memcpy)
# include <time/time.h>
#else
# include <time/time.h>
+# include <xlocale.h>
extern __typeof (strftime_l) __strftime_l;
libc_hidden_proto (__strftime_l)
extern int __getclktck (void);
+/* strptime support. */
+/* Status of lookup: do we use the locale data or the raw data? */
+enum ptime_locale_status { not, loc, raw };
+
+extern char * __strptime_internal (const char *rp, const char *fmt,
+ struct tm *tm,
+ enum ptime_locale_status *decided,
+ int era_cnt, __locale_t loc)
+ internal_function;
+
+
+
/* Use in the clock_* functions. Size of the field representing the
actual clock ID. */
#ifndef _ISOMAC
libc_hidden_proto (__wcscasecmp_l)
libc_hidden_proto (__wcsncasecmp_l)
+libc_hidden_proto (__wcscoll_l)
+libc_hidden_proto (__wcsxfrm_l)
+
libc_hidden_proto (fputws_unlocked)
libc_hidden_proto (putwc_unlocked)
libc_hidden_proto (putwc)
/* uselocale -- fetch and set the current per-thread locale
- Copyright (C) 2002 Free Software Foundation, Inc.
+ Copyright (C) 2002, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
locale_t
__uselocale (locale_t newloc)
{
- locale_t oldloc = __libc_tsd_get (LOCALE);
+ locale_t oldloc = _NL_CURRENT_LOCALE;
if (newloc != NULL)
{
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
-#include <ctype.h>
-#include <errno.h>
-#include <langinfo.h>
-#include <locale.h>
#include <monetary.h>
-#ifdef USE_IN_LIBIO
-# include "../libio/libioP.h"
-# include "../libio/strfile.h"
-#endif
-#include <printf.h>
#include <stdarg.h>
-#include <stdio.h>
-#include <string.h>
-#include "../locale/localeinfo.h"
+#include <locale/localeinfo.h>
-#define out_char(Ch) \
- do { \
- if (dest >= s + maxsize - 1) \
- { \
- __set_errno (E2BIG); \
- va_end (ap); \
- return -1; \
- } \
- *dest++ = (Ch); \
- } while (0)
-
-#define out_string(String) \
- do { \
- const char *_s = (String); \
- while (*_s) \
- out_char (*_s++); \
- } while (0)
-
-#define out_nstring(String, N) \
- do { \
- int _n = (N); \
- const char *_s = (String); \
- while (_n-- > 0) \
- out_char (*_s++); \
- } while (0)
-
-#define to_digit(Ch) ((Ch) - '0')
-
-
-/* We use this code also for the extended locale handling where the
- function gets as an additional argument the locale which has to be
- used. To access the values we have to redefine the _NL_CURRENT
- macro. */
-#ifdef USE_IN_EXTENDED_LOCALE_MODEL
-# undef _NL_CURRENT
-# define _NL_CURRENT(category, item) \
- (current->values[_NL_ITEM_INDEX (item)].string)
-#endif
-
-extern int __printf_fp (FILE *, const struct printf_info *,
- const void *const *);
-libc_hidden_proto (__printf_fp)
-/* This function determines the number of digit groups in the output.
- The definition is in printf_fp.c. */
-extern unsigned int __guess_grouping (unsigned int intdig_max,
- const char *grouping, wchar_t sepchar);
-
-
-/* We have to overcome some problems with this implementation. On the
- one hand the strfmon() function is specified in XPG4 and of course
- it has to follow this. But on the other hand POSIX.2 specifies
- some information in the LC_MONETARY category which should be used,
- too. Some of the information contradicts the information which can
- be specified in format string. */
-#ifndef USE_IN_EXTENDED_LOCALE_MODEL
ssize_t
strfmon (char *s, size_t maxsize, const char *format, ...)
-#else
-ssize_t
-__strfmon_l (char *s, size_t maxsize, __locale_t loc, const char *format, ...)
-#endif
{
-#ifdef USE_IN_EXTENDED_LOCALE_MODEL
- struct locale_data *current = loc->__locales[LC_MONETARY];
-#endif
-#ifdef USE_IN_LIBIO
- _IO_strfile f;
-# ifdef _IO_MTSAFE_IO
- _IO_lock_t lock;
-# endif
-#else
- FILE f;
-#endif
- struct printf_info info;
- va_list ap; /* Scan through the varargs. */
- char *dest; /* Pointer so copy the output. */
- const char *fmt; /* Pointer that walks through format. */
+ va_list ap;
va_start (ap, format);
- dest = s;
- fmt = format;
-
- /* Loop through the format-string. */
- while (*fmt != '\0')
- {
- /* The floating-point value to output. */
- union
- {
- double dbl;
- __long_double_t ldbl;
- }
- fpnum;
- int int_format;
- int print_curr_symbol;
- int left_prec;
- int left_pad;
- int right_prec;
- int group;
- char pad;
- int is_long_double;
- int p_sign_posn;
- int n_sign_posn;
- int sign_posn;
- int other_sign_posn;
- int left;
- int is_negative;
- int sep_by_space;
- int other_sep_by_space;
- int cs_precedes;
- int other_cs_precedes;
- const char *sign_string;
- const char *other_sign_string;
- int done;
- const char *currency_symbol;
- size_t currency_symbol_len;
- int width;
- char *startp;
- const void *ptr;
- char space_char;
-
- /* Process all character which do not introduce a format
- specification. */
- if (*fmt != '%')
- {
- out_char (*fmt++);
- continue;
- }
-
- /* "%%" means a single '%' character. */
- if (fmt[1] == '%')
- {
- out_char (*++fmt);
- ++fmt;
- continue;
- }
-
- /* Defaults for formatting. */
- int_format = 0; /* Use international curr. symbol */
- print_curr_symbol = 1; /* Print the currency symbol. */
- left_prec = -1; /* No left precision specified. */
- right_prec = -1; /* No right precision specified. */
- group = 1; /* Print digits grouped. */
- pad = ' '; /* Fill character is <SP>. */
- is_long_double = 0; /* Double argument by default. */
- p_sign_posn = -1; /* This indicates whether the */
- n_sign_posn = -1; /* '(' flag is given. */
- width = -1; /* No width specified so far. */
- left = 0; /* Right justified by default. */
-
- /* Parse group characters. */
- while (1)
- {
- switch (*++fmt)
- {
- case '=': /* Set fill character. */
- pad = *++fmt;
- if (pad == '\0')
- {
- /* Premature EOS. */
- __set_errno (EINVAL);
- va_end (ap);
- return -1;
- }
- continue;
- case '^': /* Don't group digits. */
- group = 0;
- continue;
- case '+': /* Use +/- for sign of number. */
- if (n_sign_posn != -1)
- {
- __set_errno (EINVAL);
- va_end (ap);
- return -1;
- }
- p_sign_posn = *_NL_CURRENT (LC_MONETARY, P_SIGN_POSN);
- n_sign_posn = *_NL_CURRENT (LC_MONETARY, N_SIGN_POSN);
- continue;
- case '(': /* Use ( ) for negative sign. */
- if (n_sign_posn != -1)
- {
- __set_errno (EINVAL);
- va_end (ap);
- return -1;
- }
- p_sign_posn = 0;
- n_sign_posn = 0;
- continue;
- case '!': /* Don't print the currency symbol. */
- print_curr_symbol = 0;
- continue;
- case '-': /* Print left justified. */
- left = 1;
- continue;
- default:
- /* Will stop the loop. */;
- }
- break;
- }
-
- if (isdigit (*fmt))
- {
- /* Parse field width. */
- width = to_digit (*fmt);
-
- while (isdigit (*++fmt))
- {
- width *= 10;
- width += to_digit (*fmt);
- }
-
- /* If we don't have enough room for the demanded width we
- can stop now and return an error. */
- if (dest + width >= s + maxsize)
- {
- __set_errno (E2BIG);
- va_end (ap);
- return -1;
- }
- }
-
- /* Recognize left precision. */
- if (*fmt == '#')
- {
- if (!isdigit (*++fmt))
- {
- __set_errno (EINVAL);
- va_end (ap);
- return -1;
- }
- left_prec = to_digit (*fmt);
-
- while (isdigit (*++fmt))
- {
- left_prec *= 10;
- left_prec += to_digit (*fmt);
- }
- }
-
- /* Recognize right precision. */
- if (*fmt == '.')
- {
- if (!isdigit (*++fmt))
- {
- __set_errno (EINVAL);
- va_end (ap);
- return -1;
- }
- right_prec = to_digit (*fmt);
-
- while (isdigit (*++fmt))
- {
- right_prec *= 10;
- right_prec += to_digit (*fmt);
- }
- }
-
- /* Handle modifier. This is an extension. */
- if (*fmt == 'L')
- {
- ++fmt;
- is_long_double = 1;
- }
-
- /* Handle format specifier. */
- char int_symbol[4];
- switch (*fmt++)
- {
- case 'i': { /* Use international currency symbol. */
- const char *int_curr_symbol;
-
- int_curr_symbol = _NL_CURRENT (LC_MONETARY, INT_CURR_SYMBOL);
- strncpy(int_symbol, int_curr_symbol, 3);
- int_symbol[3] = '\0';
-
- currency_symbol_len = 3;
- currency_symbol = &int_symbol[0];
- space_char = int_curr_symbol[3];
- int_format = 1;
- break;
- }
- case 'n': /* Use national currency symbol. */
- currency_symbol = _NL_CURRENT (LC_MONETARY, CURRENCY_SYMBOL);
- currency_symbol_len = strlen (currency_symbol);
- space_char = ' ';
- int_format = 0;
- break;
- default: /* Any unrecognized format is an error. */
- __set_errno (EINVAL);
- va_end (ap);
- return -1;
- }
-
- /* If not specified by the format string now find the values for
- the format specification. */
- if (p_sign_posn == -1)
- p_sign_posn = *_NL_CURRENT (LC_MONETARY, int_format ? INT_P_SIGN_POSN : P_SIGN_POSN);
- if (n_sign_posn == -1)
- n_sign_posn = *_NL_CURRENT (LC_MONETARY, int_format ? INT_N_SIGN_POSN : N_SIGN_POSN);
-
- if (right_prec == -1)
- {
- right_prec = *_NL_CURRENT (LC_MONETARY, int_format ? INT_FRAC_DIGITS : FRAC_DIGITS);
-
- if (right_prec == CHAR_MAX)
- right_prec = 2;
- }
-
- /* If we have to print the digits grouped determine how many
- extra characters this means. */
- if (group && left_prec != -1)
- left_prec += __guess_grouping (left_prec,
- _NL_CURRENT (LC_MONETARY, MON_GROUPING),
- *_NL_CURRENT (LC_MONETARY,
- MON_THOUSANDS_SEP));
-
- /* Now it's time to get the value. */
- if (is_long_double == 1)
- {
- fpnum.ldbl = va_arg (ap, long double);
- is_negative = fpnum.ldbl < 0;
- if (is_negative)
- fpnum.ldbl = -fpnum.ldbl;
- }
- else
- {
- fpnum.dbl = va_arg (ap, double);
- is_negative = fpnum.dbl < 0;
- if (is_negative)
- fpnum.dbl = -fpnum.dbl;
- }
-
- /* We now know the sign of the value and can determine the format. */
- if (is_negative)
- {
- sign_string = _NL_CURRENT (LC_MONETARY, NEGATIVE_SIGN);
- /* If the locale does not specify a character for the
- negative sign we use a '-'. */
- if (*sign_string == '\0')
- sign_string = (const char *) "-";
- cs_precedes = *_NL_CURRENT (LC_MONETARY, int_format ? INT_N_CS_PRECEDES : N_CS_PRECEDES);
- sep_by_space = *_NL_CURRENT (LC_MONETARY, int_format ? INT_N_SEP_BY_SPACE : N_SEP_BY_SPACE);
- sign_posn = n_sign_posn;
-
- other_sign_string = _NL_CURRENT (LC_MONETARY, POSITIVE_SIGN);
- other_cs_precedes = *_NL_CURRENT (LC_MONETARY, int_format ? INT_P_CS_PRECEDES : P_CS_PRECEDES);
- other_sep_by_space = *_NL_CURRENT (LC_MONETARY, int_format ? INT_P_SEP_BY_SPACE : P_SEP_BY_SPACE);
- other_sign_posn = p_sign_posn;
- }
- else
- {
- sign_string = _NL_CURRENT (LC_MONETARY, POSITIVE_SIGN);
- cs_precedes = *_NL_CURRENT (LC_MONETARY, int_format ? INT_P_CS_PRECEDES : P_CS_PRECEDES);
- sep_by_space = *_NL_CURRENT (LC_MONETARY, int_format ? INT_P_SEP_BY_SPACE : P_SEP_BY_SPACE);
- sign_posn = p_sign_posn;
-
- other_sign_string = _NL_CURRENT (LC_MONETARY, NEGATIVE_SIGN);
- if (*other_sign_string == '\0')
- other_sign_string = (const char *) "-";
- other_cs_precedes = *_NL_CURRENT (LC_MONETARY, int_format ? INT_N_CS_PRECEDES : N_CS_PRECEDES);
- other_sep_by_space = *_NL_CURRENT (LC_MONETARY, int_format ? INT_N_SEP_BY_SPACE : N_SEP_BY_SPACE);
- other_sign_posn = n_sign_posn;
- }
-
- /* Set default values for unspecified information. */
- if (cs_precedes != 0)
- cs_precedes = 1;
- if (other_cs_precedes != 0)
- other_cs_precedes = 1;
- if (sep_by_space == CHAR_MAX)
- sep_by_space = 0;
- if (other_sep_by_space == CHAR_MAX)
- other_sep_by_space = 0;
- if (sign_posn == CHAR_MAX)
- sign_posn = 1;
- if (other_sign_posn == CHAR_MAX)
- other_sign_posn = 1;
-
- /* Check for degenerate cases */
- if (sep_by_space == 2)
- {
- if (sign_posn == 0 ||
- (sign_posn == 1 && !cs_precedes) ||
- (sign_posn == 2 && cs_precedes))
- /* sign and symbol are not adjacent, so no separator */
- sep_by_space = 0;
- }
- if (other_sep_by_space == 2)
- {
- if (other_sign_posn == 0 ||
- (other_sign_posn == 1 && !other_cs_precedes) ||
- (other_sign_posn == 2 && other_cs_precedes))
- /* sign and symbol are not adjacent, so no separator */
- other_sep_by_space = 0;
- }
-
- /* Set the left precision and padding needed for alignment */
- if (left_prec == -1)
- {
- left_prec = 0;
- left_pad = 0;
- }
- else
- {
- /* Set left_pad to number of spaces needed to align positive
- and negative formats */
-
- int left_bytes = 0;
- int other_left_bytes = 0;
-
- /* Work out number of bytes for currency string and separator
- preceding the value */
- if (cs_precedes)
- {
- left_bytes += currency_symbol_len;
- if (sep_by_space != 0)
- ++left_bytes;
- }
-
- if (other_cs_precedes)
- {
- other_left_bytes += currency_symbol_len;
- if (other_sep_by_space != 0)
- ++other_left_bytes;
- }
-
- /* Work out number of bytes for the sign (or left parenthesis)
- preceding the value */
- if (sign_posn == 0 && is_negative)
- ++left_bytes;
- else if (sign_posn == 1)
- left_bytes += strlen (sign_string);
- else if (cs_precedes && (sign_posn == 3 || sign_posn == 4))
- left_bytes += strlen (sign_string);
-
- if (other_sign_posn == 0 && !is_negative)
- ++other_left_bytes;
- else if (other_sign_posn == 1)
- other_left_bytes += strlen (other_sign_string);
- else if (other_cs_precedes &&
- (other_sign_posn == 3 || other_sign_posn == 4))
- other_left_bytes += strlen (other_sign_string);
-
- /* Compare the number of bytes preceding the value for
- each format, and set the padding accordingly */
- if (other_left_bytes > left_bytes)
- left_pad = other_left_bytes - left_bytes;
- else
- left_pad = 0;
- }
-
- /* Perhaps we'll someday make these things configurable so
- better start using symbolic names now. */
-#define left_paren '('
-#define right_paren ')'
-
- startp = dest; /* Remember start so we can compute length. */
-
- while (left_pad-- > 0)
- out_char (' ');
-
- if (sign_posn == 0 && is_negative)
- out_char (left_paren);
-
- if (cs_precedes)
- {
- if (sign_posn != 0 && sign_posn != 2 && sign_posn != 4
- && sign_posn != 5)
- {
- out_string (sign_string);
- if (sep_by_space == 2)
- out_char (' ');
- }
-
- if (print_curr_symbol)
- {
- out_string (currency_symbol);
-
- if (sign_posn == 4)
- {
- if (sep_by_space == 2)
- out_char (space_char);
- out_string (sign_string);
- if (sep_by_space == 1)
- /* POSIX.2 and SUS are not clear on this case, but C99
- says a space follows the adjacent-symbol-and-sign */
- out_char (' ');
- }
- else
- if (sep_by_space == 1)
- out_char (space_char);
- }
- }
- else
- if (sign_posn != 0 && sign_posn != 2 && sign_posn != 3
- && sign_posn != 4 && sign_posn != 5)
- out_string (sign_string);
-
- /* Print the number. */
-#ifdef USE_IN_LIBIO
-# ifdef _IO_MTSAFE_IO
- f._sbf._f._lock = &lock;
-# endif
- INTUSE(_IO_init) ((_IO_FILE *) &f, 0);
- _IO_JUMPS ((struct _IO_FILE_plus *) &f) = &_IO_str_jumps;
- INTUSE(_IO_str_init_static) ((_IO_strfile *) &f, dest,
- (s + maxsize) - dest, dest);
-#else
- memset ((void *) &f, 0, sizeof (f));
- f.__magic = _IOMAGIC;
- f.__mode.__write = 1;
- /* The buffer size is one less than MAXLEN
- so we have space for the null terminator. */
- f.__bufp = f.__buffer = (char *) dest;
- f.__bufsize = (s + maxsize) - dest;
- f.__put_limit = f.__buffer + f.__bufsize;
- f.__get_limit = f.__buffer;
- /* After the buffer is full (MAXLEN characters have been written),
- any more characters written will go to the bit bucket. */
- f.__room_funcs = __default_room_functions;
- f.__io_funcs.__write = NULL;
- f.__seen = 1;
-#endif
- /* We clear the last available byte so we can find out whether
- the numeric representation is too long. */
- s[maxsize - 1] = '\0';
-
- info.prec = right_prec;
- info.width = left_prec + (right_prec ? (right_prec + 1) : 0);
- info.spec = 'f';
- info.is_long_double = is_long_double;
- info.is_short = 0;
- info.is_long = 0;
- info.alt = 0;
- info.space = 0;
- info.left = 0;
- info.showsign = 0;
- info.group = group;
- info.pad = pad;
- info.extra = 1; /* This means use values from LC_MONETARY. */
- info.wide = 0;
-
- ptr = &fpnum;
- done = __printf_fp ((FILE *) &f, &info, &ptr);
- if (done < 0)
- {
- va_end (ap);
- return -1;
- }
-
- if (s[maxsize - 1] != '\0')
- {
- __set_errno (E2BIG);
- return -1;
- }
-
- dest += done;
-
- if (!cs_precedes)
- {
- if (sign_posn == 3)
- {
- if (sep_by_space == 1)
- out_char (' ');
- out_string (sign_string);
- }
-
- if (print_curr_symbol)
- {
- if ((sign_posn == 3 && sep_by_space == 2)
- || (sign_posn == 4 && sep_by_space == 1)
- || (sign_posn == 2 && sep_by_space == 1)
- || (sign_posn == 1 && sep_by_space == 1)
- || (sign_posn == 0 && sep_by_space == 1))
- out_char (space_char);
- out_nstring (currency_symbol, currency_symbol_len);
- if (sign_posn == 4)
- {
- if (sep_by_space == 2)
- out_char (' ');
- out_string (sign_string);
- }
- }
- }
-
- if (sign_posn == 2)
- {
- if (sep_by_space == 2)
- out_char (' ');
- out_string (sign_string);
- }
-
- if (sign_posn == 0 && is_negative)
- out_char (right_paren);
-
- /* Now test whether the output width is filled. */
- if (dest - startp < width)
- {
- if (left)
- /* We simply have to fill using spaces. */
- do
- out_char (' ');
- while (dest - startp < width);
- else
- {
- int dist = width - (dest - startp);
- char *cp;
- for (cp = dest - 1; cp >= startp; --cp)
- cp[dist] = cp[0];
-
- dest += dist;
-
- do
- startp[--dist] = ' ';
- while (dist > 0);
- }
- }
- }
-
- /* Terminate the string. */
- *dest = '\0';
+ ssize_t res = __vstrfmon_l (s, maxsize, _NL_CURRENT_LOCALE, format, ap);
va_end (ap);
- return dest - s;
+ return res;
}
/* Formatting a monetary value according to the given locale.
- Copyright (C) 1996, 1997, 2002 Free Software Foundation, Inc.
+ Copyright (C) 1996, 1997, 2002, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1996.
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
-#define USE_IN_EXTENDED_LOCALE_MODEL 1
-#include <strfmon.c>
+#include <ctype.h>
+#include <errno.h>
+#include <langinfo.h>
+#include <locale.h>
+#include <monetary.h>
+#ifdef USE_IN_LIBIO
+# include "../libio/libioP.h"
+# include "../libio/strfile.h"
+#endif
+#include <printf.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+#include "../locale/localeinfo.h"
+
+#define out_char(Ch) \
+ do { \
+ if (dest >= s + maxsize - 1) \
+ { \
+ __set_errno (E2BIG); \
+ va_end (ap); \
+ return -1; \
+ } \
+ *dest++ = (Ch); \
+ } while (0)
+
+#define out_string(String) \
+ do { \
+ const char *_s = (String); \
+ while (*_s) \
+ out_char (*_s++); \
+ } while (0)
+
+#define out_nstring(String, N) \
+ do { \
+ int _n = (N); \
+ const char *_s = (String); \
+ while (_n-- > 0) \
+ out_char (*_s++); \
+ } while (0)
+
+#define to_digit(Ch) ((Ch) - '0')
+
+
+/* We use this code also for the extended locale handling where the
+ function gets as an additional argument the locale which has to be
+ used. To access the values we have to redefine the _NL_CURRENT
+ macro. */
+#undef _NL_CURRENT
+#define _NL_CURRENT(category, item) \
+ (current->values[_NL_ITEM_INDEX (item)].string)
+
+extern int __printf_fp (FILE *, const struct printf_info *,
+ const void *const *);
+libc_hidden_proto (__printf_fp)
+/* This function determines the number of digit groups in the output.
+ The definition is in printf_fp.c. */
+extern unsigned int __guess_grouping (unsigned int intdig_max,
+ const char *grouping, wchar_t sepchar);
+
+
+/* We have to overcome some problems with this implementation. On the
+ one hand the strfmon() function is specified in XPG4 and of course
+ it has to follow this. But on the other hand POSIX.2 specifies
+ some information in the LC_MONETARY category which should be used,
+ too. Some of the information contradicts the information which can
+ be specified in format string. */
+ssize_t
+__vstrfmon_l (char *s, size_t maxsize, __locale_t loc, const char *format,
+ va_list ap)
+{
+ struct locale_data *current = loc->__locales[LC_MONETARY];
+#ifdef USE_IN_LIBIO
+ _IO_strfile f;
+# ifdef _IO_MTSAFE_IO
+ _IO_lock_t lock;
+# endif
+#else
+ FILE f;
+#endif
+ struct printf_info info;
+ char *dest; /* Pointer so copy the output. */
+ const char *fmt; /* Pointer that walks through format. */
+
+ dest = s;
+ fmt = format;
+
+ /* Loop through the format-string. */
+ while (*fmt != '\0')
+ {
+ /* The floating-point value to output. */
+ union
+ {
+ double dbl;
+ __long_double_t ldbl;
+ }
+ fpnum;
+ int int_format;
+ int print_curr_symbol;
+ int left_prec;
+ int left_pad;
+ int right_prec;
+ int group;
+ char pad;
+ int is_long_double;
+ int p_sign_posn;
+ int n_sign_posn;
+ int sign_posn;
+ int other_sign_posn;
+ int left;
+ int is_negative;
+ int sep_by_space;
+ int other_sep_by_space;
+ int cs_precedes;
+ int other_cs_precedes;
+ const char *sign_string;
+ const char *other_sign_string;
+ int done;
+ const char *currency_symbol;
+ size_t currency_symbol_len;
+ int width;
+ char *startp;
+ const void *ptr;
+ char space_char;
+
+ /* Process all character which do not introduce a format
+ specification. */
+ if (*fmt != '%')
+ {
+ out_char (*fmt++);
+ continue;
+ }
+
+ /* "%%" means a single '%' character. */
+ if (fmt[1] == '%')
+ {
+ out_char (*++fmt);
+ ++fmt;
+ continue;
+ }
+
+ /* Defaults for formatting. */
+ int_format = 0; /* Use international curr. symbol */
+ print_curr_symbol = 1; /* Print the currency symbol. */
+ left_prec = -1; /* No left precision specified. */
+ right_prec = -1; /* No right precision specified. */
+ group = 1; /* Print digits grouped. */
+ pad = ' '; /* Fill character is <SP>. */
+ is_long_double = 0; /* Double argument by default. */
+ p_sign_posn = -1; /* This indicates whether the */
+ n_sign_posn = -1; /* '(' flag is given. */
+ width = -1; /* No width specified so far. */
+ left = 0; /* Right justified by default. */
+
+ /* Parse group characters. */
+ while (1)
+ {
+ switch (*++fmt)
+ {
+ case '=': /* Set fill character. */
+ pad = *++fmt;
+ if (pad == '\0')
+ {
+ /* Premature EOS. */
+ __set_errno (EINVAL);
+ return -1;
+ }
+ continue;
+ case '^': /* Don't group digits. */
+ group = 0;
+ continue;
+ case '+': /* Use +/- for sign of number. */
+ if (n_sign_posn != -1)
+ {
+ __set_errno (EINVAL);
+ return -1;
+ }
+ p_sign_posn = *_NL_CURRENT (LC_MONETARY, P_SIGN_POSN);
+ n_sign_posn = *_NL_CURRENT (LC_MONETARY, N_SIGN_POSN);
+ continue;
+ case '(': /* Use ( ) for negative sign. */
+ if (n_sign_posn != -1)
+ {
+ __set_errno (EINVAL);
+ return -1;
+ }
+ p_sign_posn = 0;
+ n_sign_posn = 0;
+ continue;
+ case '!': /* Don't print the currency symbol. */
+ print_curr_symbol = 0;
+ continue;
+ case '-': /* Print left justified. */
+ left = 1;
+ continue;
+ default:
+ /* Will stop the loop. */;
+ }
+ break;
+ }
+
+ if (isdigit (*fmt))
+ {
+ /* Parse field width. */
+ width = to_digit (*fmt);
+
+ while (isdigit (*++fmt))
+ {
+ width *= 10;
+ width += to_digit (*fmt);
+ }
+
+ /* If we don't have enough room for the demanded width we
+ can stop now and return an error. */
+ if (dest + width >= s + maxsize)
+ {
+ __set_errno (E2BIG);
+ return -1;
+ }
+ }
+
+ /* Recognize left precision. */
+ if (*fmt == '#')
+ {
+ if (!isdigit (*++fmt))
+ {
+ __set_errno (EINVAL);
+ return -1;
+ }
+ left_prec = to_digit (*fmt);
+
+ while (isdigit (*++fmt))
+ {
+ left_prec *= 10;
+ left_prec += to_digit (*fmt);
+ }
+ }
+
+ /* Recognize right precision. */
+ if (*fmt == '.')
+ {
+ if (!isdigit (*++fmt))
+ {
+ __set_errno (EINVAL);
+ return -1;
+ }
+ right_prec = to_digit (*fmt);
+
+ while (isdigit (*++fmt))
+ {
+ right_prec *= 10;
+ right_prec += to_digit (*fmt);
+ }
+ }
+
+ /* Handle modifier. This is an extension. */
+ if (*fmt == 'L')
+ {
+ ++fmt;
+ is_long_double = 1;
+ }
+
+ /* Handle format specifier. */
+ char int_symbol[4];
+ switch (*fmt++)
+ {
+ case 'i': { /* Use international currency symbol. */
+ const char *int_curr_symbol;
+
+ int_curr_symbol = _NL_CURRENT (LC_MONETARY, INT_CURR_SYMBOL);
+ strncpy(int_symbol, int_curr_symbol, 3);
+ int_symbol[3] = '\0';
+
+ currency_symbol_len = 3;
+ currency_symbol = &int_symbol[0];
+ space_char = int_curr_symbol[3];
+ int_format = 1;
+ break;
+ }
+ case 'n': /* Use national currency symbol. */
+ currency_symbol = _NL_CURRENT (LC_MONETARY, CURRENCY_SYMBOL);
+ currency_symbol_len = strlen (currency_symbol);
+ space_char = ' ';
+ int_format = 0;
+ break;
+ default: /* Any unrecognized format is an error. */
+ __set_errno (EINVAL);
+ return -1;
+ }
+
+ /* If not specified by the format string now find the values for
+ the format specification. */
+ if (p_sign_posn == -1)
+ p_sign_posn = *_NL_CURRENT (LC_MONETARY, int_format ? INT_P_SIGN_POSN : P_SIGN_POSN);
+ if (n_sign_posn == -1)
+ n_sign_posn = *_NL_CURRENT (LC_MONETARY, int_format ? INT_N_SIGN_POSN : N_SIGN_POSN);
+
+ if (right_prec == -1)
+ {
+ right_prec = *_NL_CURRENT (LC_MONETARY, int_format ? INT_FRAC_DIGITS : FRAC_DIGITS);
+
+ if (right_prec == CHAR_MAX)
+ right_prec = 2;
+ }
+
+ /* If we have to print the digits grouped determine how many
+ extra characters this means. */
+ if (group && left_prec != -1)
+ left_prec += __guess_grouping (left_prec,
+ _NL_CURRENT (LC_MONETARY, MON_GROUPING),
+ *_NL_CURRENT (LC_MONETARY,
+ MON_THOUSANDS_SEP));
+
+ /* Now it's time to get the value. */
+ if (is_long_double == 1)
+ {
+ fpnum.ldbl = va_arg (ap, long double);
+ is_negative = fpnum.ldbl < 0;
+ if (is_negative)
+ fpnum.ldbl = -fpnum.ldbl;
+ }
+ else
+ {
+ fpnum.dbl = va_arg (ap, double);
+ is_negative = fpnum.dbl < 0;
+ if (is_negative)
+ fpnum.dbl = -fpnum.dbl;
+ }
+
+ /* We now know the sign of the value and can determine the format. */
+ if (is_negative)
+ {
+ sign_string = _NL_CURRENT (LC_MONETARY, NEGATIVE_SIGN);
+ /* If the locale does not specify a character for the
+ negative sign we use a '-'. */
+ if (*sign_string == '\0')
+ sign_string = (const char *) "-";
+ cs_precedes = *_NL_CURRENT (LC_MONETARY, int_format ? INT_N_CS_PRECEDES : N_CS_PRECEDES);
+ sep_by_space = *_NL_CURRENT (LC_MONETARY, int_format ? INT_N_SEP_BY_SPACE : N_SEP_BY_SPACE);
+ sign_posn = n_sign_posn;
+
+ other_sign_string = _NL_CURRENT (LC_MONETARY, POSITIVE_SIGN);
+ other_cs_precedes = *_NL_CURRENT (LC_MONETARY, int_format ? INT_P_CS_PRECEDES : P_CS_PRECEDES);
+ other_sep_by_space = *_NL_CURRENT (LC_MONETARY, int_format ? INT_P_SEP_BY_SPACE : P_SEP_BY_SPACE);
+ other_sign_posn = p_sign_posn;
+ }
+ else
+ {
+ sign_string = _NL_CURRENT (LC_MONETARY, POSITIVE_SIGN);
+ cs_precedes = *_NL_CURRENT (LC_MONETARY, int_format ? INT_P_CS_PRECEDES : P_CS_PRECEDES);
+ sep_by_space = *_NL_CURRENT (LC_MONETARY, int_format ? INT_P_SEP_BY_SPACE : P_SEP_BY_SPACE);
+ sign_posn = p_sign_posn;
+
+ other_sign_string = _NL_CURRENT (LC_MONETARY, NEGATIVE_SIGN);
+ if (*other_sign_string == '\0')
+ other_sign_string = (const char *) "-";
+ other_cs_precedes = *_NL_CURRENT (LC_MONETARY, int_format ? INT_N_CS_PRECEDES : N_CS_PRECEDES);
+ other_sep_by_space = *_NL_CURRENT (LC_MONETARY, int_format ? INT_N_SEP_BY_SPACE : N_SEP_BY_SPACE);
+ other_sign_posn = n_sign_posn;
+ }
+
+ /* Set default values for unspecified information. */
+ if (cs_precedes != 0)
+ cs_precedes = 1;
+ if (other_cs_precedes != 0)
+ other_cs_precedes = 1;
+ if (sep_by_space == CHAR_MAX)
+ sep_by_space = 0;
+ if (other_sep_by_space == CHAR_MAX)
+ other_sep_by_space = 0;
+ if (sign_posn == CHAR_MAX)
+ sign_posn = 1;
+ if (other_sign_posn == CHAR_MAX)
+ other_sign_posn = 1;
+
+ /* Check for degenerate cases */
+ if (sep_by_space == 2)
+ {
+ if (sign_posn == 0 ||
+ (sign_posn == 1 && !cs_precedes) ||
+ (sign_posn == 2 && cs_precedes))
+ /* sign and symbol are not adjacent, so no separator */
+ sep_by_space = 0;
+ }
+ if (other_sep_by_space == 2)
+ {
+ if (other_sign_posn == 0 ||
+ (other_sign_posn == 1 && !other_cs_precedes) ||
+ (other_sign_posn == 2 && other_cs_precedes))
+ /* sign and symbol are not adjacent, so no separator */
+ other_sep_by_space = 0;
+ }
+
+ /* Set the left precision and padding needed for alignment */
+ if (left_prec == -1)
+ {
+ left_prec = 0;
+ left_pad = 0;
+ }
+ else
+ {
+ /* Set left_pad to number of spaces needed to align positive
+ and negative formats */
+
+ int left_bytes = 0;
+ int other_left_bytes = 0;
+
+ /* Work out number of bytes for currency string and separator
+ preceding the value */
+ if (cs_precedes)
+ {
+ left_bytes += currency_symbol_len;
+ if (sep_by_space != 0)
+ ++left_bytes;
+ }
+
+ if (other_cs_precedes)
+ {
+ other_left_bytes += currency_symbol_len;
+ if (other_sep_by_space != 0)
+ ++other_left_bytes;
+ }
+
+ /* Work out number of bytes for the sign (or left parenthesis)
+ preceding the value */
+ if (sign_posn == 0 && is_negative)
+ ++left_bytes;
+ else if (sign_posn == 1)
+ left_bytes += strlen (sign_string);
+ else if (cs_precedes && (sign_posn == 3 || sign_posn == 4))
+ left_bytes += strlen (sign_string);
+
+ if (other_sign_posn == 0 && !is_negative)
+ ++other_left_bytes;
+ else if (other_sign_posn == 1)
+ other_left_bytes += strlen (other_sign_string);
+ else if (other_cs_precedes &&
+ (other_sign_posn == 3 || other_sign_posn == 4))
+ other_left_bytes += strlen (other_sign_string);
+
+ /* Compare the number of bytes preceding the value for
+ each format, and set the padding accordingly */
+ if (other_left_bytes > left_bytes)
+ left_pad = other_left_bytes - left_bytes;
+ else
+ left_pad = 0;
+ }
+
+ /* Perhaps we'll someday make these things configurable so
+ better start using symbolic names now. */
+#define left_paren '('
+#define right_paren ')'
+
+ startp = dest; /* Remember start so we can compute length. */
+
+ while (left_pad-- > 0)
+ out_char (' ');
+
+ if (sign_posn == 0 && is_negative)
+ out_char (left_paren);
+
+ if (cs_precedes)
+ {
+ if (sign_posn != 0 && sign_posn != 2 && sign_posn != 4
+ && sign_posn != 5)
+ {
+ out_string (sign_string);
+ if (sep_by_space == 2)
+ out_char (' ');
+ }
+
+ if (print_curr_symbol)
+ {
+ out_string (currency_symbol);
+
+ if (sign_posn == 4)
+ {
+ if (sep_by_space == 2)
+ out_char (space_char);
+ out_string (sign_string);
+ if (sep_by_space == 1)
+ /* POSIX.2 and SUS are not clear on this case, but C99
+ says a space follows the adjacent-symbol-and-sign */
+ out_char (' ');
+ }
+ else
+ if (sep_by_space == 1)
+ out_char (space_char);
+ }
+ }
+ else
+ if (sign_posn != 0 && sign_posn != 2 && sign_posn != 3
+ && sign_posn != 4 && sign_posn != 5)
+ out_string (sign_string);
+
+ /* Print the number. */
+#ifdef USE_IN_LIBIO
+# ifdef _IO_MTSAFE_IO
+ f._sbf._f._lock = &lock;
+# endif
+ INTUSE(_IO_init) ((_IO_FILE *) &f, 0);
+ _IO_JUMPS ((struct _IO_FILE_plus *) &f) = &_IO_str_jumps;
+ INTUSE(_IO_str_init_static) ((_IO_strfile *) &f, dest,
+ (s + maxsize) - dest, dest);
+#else
+ memset ((void *) &f, 0, sizeof (f));
+ f.__magic = _IOMAGIC;
+ f.__mode.__write = 1;
+ /* The buffer size is one less than MAXLEN
+ so we have space for the null terminator. */
+ f.__bufp = f.__buffer = (char *) dest;
+ f.__bufsize = (s + maxsize) - dest;
+ f.__put_limit = f.__buffer + f.__bufsize;
+ f.__get_limit = f.__buffer;
+ /* After the buffer is full (MAXLEN characters have been written),
+ any more characters written will go to the bit bucket. */
+ f.__room_funcs = __default_room_functions;
+ f.__io_funcs.__write = NULL;
+ f.__seen = 1;
+#endif
+ /* We clear the last available byte so we can find out whether
+ the numeric representation is too long. */
+ s[maxsize - 1] = '\0';
+
+ info.prec = right_prec;
+ info.width = left_prec + (right_prec ? (right_prec + 1) : 0);
+ info.spec = 'f';
+ info.is_long_double = is_long_double;
+ info.is_short = 0;
+ info.is_long = 0;
+ info.alt = 0;
+ info.space = 0;
+ info.left = 0;
+ info.showsign = 0;
+ info.group = group;
+ info.pad = pad;
+ info.extra = 1; /* This means use values from LC_MONETARY. */
+ info.wide = 0;
+
+ ptr = &fpnum;
+ done = __printf_fp ((FILE *) &f, &info, &ptr);
+ if (done < 0)
+ return -1;
+
+ if (s[maxsize - 1] != '\0')
+ {
+ __set_errno (E2BIG);
+ return -1;
+ }
+
+ dest += done;
+
+ if (!cs_precedes)
+ {
+ if (sign_posn == 3)
+ {
+ if (sep_by_space == 1)
+ out_char (' ');
+ out_string (sign_string);
+ }
+
+ if (print_curr_symbol)
+ {
+ if ((sign_posn == 3 && sep_by_space == 2)
+ || (sign_posn == 4 && sep_by_space == 1)
+ || (sign_posn == 2 && sep_by_space == 1)
+ || (sign_posn == 1 && sep_by_space == 1)
+ || (sign_posn == 0 && sep_by_space == 1))
+ out_char (space_char);
+ out_nstring (currency_symbol, currency_symbol_len);
+ if (sign_posn == 4)
+ {
+ if (sep_by_space == 2)
+ out_char (' ');
+ out_string (sign_string);
+ }
+ }
+ }
+
+ if (sign_posn == 2)
+ {
+ if (sep_by_space == 2)
+ out_char (' ');
+ out_string (sign_string);
+ }
+
+ if (sign_posn == 0 && is_negative)
+ out_char (right_paren);
+
+ /* Now test whether the output width is filled. */
+ if (dest - startp < width)
+ {
+ if (left)
+ /* We simply have to fill using spaces. */
+ do
+ out_char (' ');
+ while (dest - startp < width);
+ else
+ {
+ int dist = width - (dest - startp);
+ char *cp;
+ for (cp = dest - 1; cp >= startp; --cp)
+ cp[dist] = cp[0];
+
+ dest += dist;
+
+ do
+ startp[--dist] = ' ';
+ while (dist > 0);
+ }
+ }
+ }
+
+ /* Terminate the string. */
+ *dest = '\0';
+
+ return dest - s;
+}
+
+ssize_t
+__strfmon_l (char *s, size_t maxsize, __locale_t loc, const char *format, ...)
+{
+ va_list ap;
+
+ va_start (ap, format);
+
+ ssize_t res = __vstrfmon_l (s, maxsize, loc, format, ap);
+
+ va_end (ap);
+
+ return res;
+}
weak_alias (__strfmon_l, strfmon_l)
/* Read decimal floating point numbers.
This file is part of the GNU C Library.
- Copyright (C) 1995-2002, 2003 Free Software Foundation, Inc.
+ Copyright (C) 1995-2002, 2003, 2004 Free Software Foundation, Inc.
Contributed by Ulrich Drepper <drepper@gnu.org>, 1995.
The GNU C Library is free software; you can redistribute it and/or
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
-/* Configuration part. These macros are defined by `strtold.c',
- `strtof.c', `wcstod.c', `wcstold.c', and `wcstof.c' to produce the
- `long double' and `float' versions of the reader. */
+#include <stdlib.h>
+#include <wchar.h>
+#include <locale/localeinfo.h>
+
+
#ifndef FLOAT
-# define FLOAT double
-# define FLT DBL
+# define FLOAT double
# ifdef USE_WIDE_CHAR
-# ifdef USE_IN_EXTENDED_LOCALE_MODEL
-# define STRTOF __wcstod_l
-# else
-# define STRTOF wcstod
-# endif
+# define STRTOF wcstod
+# define STRTOF_L __wcstod_l
# else
-# ifdef USE_IN_EXTENDED_LOCALE_MODEL
-# define STRTOF __strtod_l
-# else
-# define STRTOF strtod
-# endif
+# define STRTOF strtod
+# define STRTOF_L __strtod_l
# endif
-# define MPN2FLOAT __mpn_construct_double
-# define FLOAT_HUGE_VAL HUGE_VAL
-# define SET_MANTISSA(flt, mant) \
- do { union ieee754_double u; \
- u.d = (flt); \
- if ((mant & 0xfffffffffffffULL) == 0) \
- mant = 0x8000000000000ULL; \
- u.ieee.mantissa0 = ((mant) >> 32) & 0xfffff; \
- u.ieee.mantissa1 = (mant) & 0xffffffff; \
- (flt) = u.d; \
- } while (0)
-#endif
-/* End of configuration part. */
-\f
-#include <ctype.h>
-#include <errno.h>
-#include <float.h>
-#include <ieee754.h>
-#include "../locale/localeinfo.h"
-#include <locale.h>
-#include <math.h>
-#include <stdlib.h>
-#include <string.h>
-
-/* The gmp headers need some configuration frobs. */
-#define HAVE_ALLOCA 1
-
-/* Include gmp-mparam.h first, such that definitions of _SHORT_LIMB
- and _LONG_LONG_LIMB in it can take effect into gmp.h. */
-#include <gmp-mparam.h>
-#include <gmp.h>
-#include <gmp-impl.h>
-#include <longlong.h>
-#include "fpioconst.h"
-
-#define NDEBUG 1
-#include <assert.h>
-
-
-/* We use this code also for the extended locale handling where the
- function gets as an additional argument the locale which has to be
- used. To access the values we have to redefine the _NL_CURRENT
- macro. */
-#ifdef USE_IN_EXTENDED_LOCALE_MODEL
-# undef _NL_CURRENT
-# define _NL_CURRENT(category, item) \
- (current->values[_NL_ITEM_INDEX (item)].string)
-# define LOCALE_PARAM , loc
-# define LOCALE_PARAM_DECL __locale_t loc;
-#else
-# define LOCALE_PARAM
-# define LOCALE_PARAM_DECL
-#endif
-
-#if defined _LIBC || defined HAVE_WCHAR_H
-# include <wchar.h>
#endif
#ifdef USE_WIDE_CHAR
# include <wctype.h>
# define STRING_TYPE wchar_t
-# define CHAR_TYPE wint_t
-# define L_(Ch) L##Ch
-# ifdef USE_IN_EXTENDED_LOCALE_MODEL
-# define ISSPACE(Ch) __iswspace_l ((Ch), loc)
-# define ISDIGIT(Ch) __iswdigit_l ((Ch), loc)
-# define ISXDIGIT(Ch) __iswxdigit_l ((Ch), loc)
-# define TOLOWER(Ch) __towlower_l ((Ch), loc)
-# define STRNCASECMP(S1, S2, N) __wcsncasecmp_l ((S1), (S2), (N), loc)
-# define STRTOULL(S, E, B) ____wcstoull_l_internal ((S), (E), (B), 0, loc)
-# else
-# define ISSPACE(Ch) iswspace (Ch)
-# define ISDIGIT(Ch) iswdigit (Ch)
-# define ISXDIGIT(Ch) iswxdigit (Ch)
-# define TOLOWER(Ch) towlower (Ch)
-# define STRNCASECMP(S1, S2, N) __wcsncasecmp ((S1), (S2), (N))
-# define STRTOULL(S, E, B) __wcstoull_internal ((S), (E), (B), 0)
-# endif
#else
# define STRING_TYPE char
-# define CHAR_TYPE char
-# define L_(Ch) Ch
-# ifdef USE_IN_EXTENDED_LOCALE_MODEL
-# define ISSPACE(Ch) __isspace_l ((Ch), loc)
-# define ISDIGIT(Ch) __isdigit_l ((Ch), loc)
-# define ISXDIGIT(Ch) __isxdigit_l ((Ch), loc)
-# define TOLOWER(Ch) __tolower_l ((Ch), loc)
-# define STRNCASECMP(S1, S2, N) __strncasecmp_l ((S1), (S2), (N), loc)
-# define STRTOULL(S, E, B) ____strtoull_l_internal ((S), (E), (B), 0, loc)
-# else
-# define ISSPACE(Ch) isspace (Ch)
-# define ISDIGIT(Ch) isdigit (Ch)
-# define ISXDIGIT(Ch) isxdigit (Ch)
-# define TOLOWER(Ch) tolower (Ch)
-# define STRNCASECMP(S1, S2, N) __strncasecmp ((S1), (S2), (N))
-# define STRTOULL(S, E, B) __strtoull_internal ((S), (E), 0, (B))
-# endif
-#endif
-
-
-/* Constants we need from float.h; select the set for the FLOAT precision. */
-#define MANT_DIG PASTE(FLT,_MANT_DIG)
-#define DIG PASTE(FLT,_DIG)
-#define MAX_EXP PASTE(FLT,_MAX_EXP)
-#define MIN_EXP PASTE(FLT,_MIN_EXP)
-#define MAX_10_EXP PASTE(FLT,_MAX_10_EXP)
-#define MIN_10_EXP PASTE(FLT,_MIN_10_EXP)
-
-/* Extra macros required to get FLT expanded before the pasting. */
-#define PASTE(a,b) PASTE1(a,b)
-#define PASTE1(a,b) a##b
-
-/* Function to construct a floating point number from an MP integer
- containing the fraction bits, a base 2 exponent, and a sign flag. */
-extern FLOAT MPN2FLOAT (mp_srcptr mpn, int exponent, int negative);
-\f
-/* Definitions according to limb size used. */
-#if BITS_PER_MP_LIMB == 32
-# define MAX_DIG_PER_LIMB 9
-# define MAX_FAC_PER_LIMB 1000000000UL
-#elif BITS_PER_MP_LIMB == 64
-# define MAX_DIG_PER_LIMB 19
-# define MAX_FAC_PER_LIMB 10000000000000000000ULL
-#else
-# error "mp_limb_t size " BITS_PER_MP_LIMB "not accounted for"
#endif
-
-/* Local data structure. */
-static const mp_limb_t _tens_in_limb[MAX_DIG_PER_LIMB + 1] =
-{ 0, 10, 100,
- 1000, 10000, 100000L,
- 1000000L, 10000000L, 100000000L,
- 1000000000L
-#if BITS_PER_MP_LIMB > 32
- , 10000000000ULL, 100000000000ULL,
- 1000000000000ULL, 10000000000000ULL, 100000000000000ULL,
- 1000000000000000ULL, 10000000000000000ULL, 100000000000000000ULL,
- 1000000000000000000ULL, 10000000000000000000ULL
-#endif
-#if BITS_PER_MP_LIMB > 64
- #error "Need to expand tens_in_limb table to" MAX_DIG_PER_LIMB
-#endif
-};
-\f
-#ifndef howmany
-#define howmany(x,y) (((x)+((y)-1))/(y))
-#endif
-#define SWAP(x, y) ({ typeof(x) _tmp = x; x = y; y = _tmp; })
-
-#define NDIG (MAX_10_EXP - MIN_10_EXP + 2 * MANT_DIG)
-#define HEXNDIG ((MAX_EXP - MIN_EXP + 7) / 8 + 2 * MANT_DIG)
-#define RETURN_LIMB_SIZE howmany (MANT_DIG, BITS_PER_MP_LIMB)
-
-#define RETURN(val,end) \
- do { if (endptr != NULL) *endptr = (STRING_TYPE *) (end); \
- return val; } while (0)
-
-/* Maximum size necessary for mpn integers to hold floating point numbers. */
-#define MPNSIZE (howmany (MAX_EXP + 2 * MANT_DIG, BITS_PER_MP_LIMB) \
- + 2)
-/* Declare an mpn integer variable that big. */
-#define MPN_VAR(name) mp_limb_t name[MPNSIZE]; mp_size_t name##size
-/* Copy an mpn integer value. */
-#define MPN_ASSIGN(dst, src) \
- memcpy (dst, src, (dst##size = src##size) * sizeof (mp_limb_t))
-
-
-/* Return a floating point number of the needed type according to the given
- multi-precision number after possible rounding. */
-static FLOAT
-round_and_return (mp_limb_t *retval, int exponent, int negative,
- mp_limb_t round_limb, mp_size_t round_bit, int more_bits)
-{
- if (exponent < MIN_EXP - 1)
- {
- mp_size_t shift = MIN_EXP - 1 - exponent;
-
- if (shift > MANT_DIG)
- {
- __set_errno (EDOM);
- return 0.0;
- }
-
- more_bits |= (round_limb & ((((mp_limb_t) 1) << round_bit) - 1)) != 0;
- if (shift == MANT_DIG)
- /* This is a special case to handle the very seldom case where
- the mantissa will be empty after the shift. */
- {
- int i;
-
- round_limb = retval[RETURN_LIMB_SIZE - 1];
- round_bit = (MANT_DIG - 1) % BITS_PER_MP_LIMB;
- for (i = 0; i < RETURN_LIMB_SIZE; ++i)
- more_bits |= retval[i] != 0;
- MPN_ZERO (retval, RETURN_LIMB_SIZE);
- }
- else if (shift >= BITS_PER_MP_LIMB)
- {
- int i;
-
- round_limb = retval[(shift - 1) / BITS_PER_MP_LIMB];
- round_bit = (shift - 1) % BITS_PER_MP_LIMB;
- for (i = 0; i < (shift - 1) / BITS_PER_MP_LIMB; ++i)
- more_bits |= retval[i] != 0;
- more_bits |= ((round_limb & ((((mp_limb_t) 1) << round_bit) - 1))
- != 0);
-
- (void) __mpn_rshift (retval, &retval[shift / BITS_PER_MP_LIMB],
- RETURN_LIMB_SIZE - (shift / BITS_PER_MP_LIMB),
- shift % BITS_PER_MP_LIMB);
- MPN_ZERO (&retval[RETURN_LIMB_SIZE - (shift / BITS_PER_MP_LIMB)],
- shift / BITS_PER_MP_LIMB);
- }
- else if (shift > 0)
- {
- round_limb = retval[0];
- round_bit = shift - 1;
- (void) __mpn_rshift (retval, retval, RETURN_LIMB_SIZE, shift);
- }
- /* This is a hook for the m68k long double format, where the
- exponent bias is the same for normalized and denormalized
- numbers. */
-#ifndef DENORM_EXP
-# define DENORM_EXP (MIN_EXP - 2)
-#endif
- exponent = DENORM_EXP;
- }
-
- if ((round_limb & (((mp_limb_t) 1) << round_bit)) != 0
- && (more_bits || (retval[0] & 1) != 0
- || (round_limb & ((((mp_limb_t) 1) << round_bit) - 1)) != 0))
- {
- mp_limb_t cy = __mpn_add_1 (retval, retval, RETURN_LIMB_SIZE, 1);
-
- if (((MANT_DIG % BITS_PER_MP_LIMB) == 0 && cy) ||
- ((MANT_DIG % BITS_PER_MP_LIMB) != 0 &&
- (retval[RETURN_LIMB_SIZE - 1]
- & (((mp_limb_t) 1) << (MANT_DIG % BITS_PER_MP_LIMB))) != 0))
- {
- ++exponent;
- (void) __mpn_rshift (retval, retval, RETURN_LIMB_SIZE, 1);
- retval[RETURN_LIMB_SIZE - 1]
- |= ((mp_limb_t) 1) << ((MANT_DIG - 1) % BITS_PER_MP_LIMB);
- }
- else if (exponent == DENORM_EXP
- && (retval[RETURN_LIMB_SIZE - 1]
- & (((mp_limb_t) 1) << ((MANT_DIG - 1) % BITS_PER_MP_LIMB)))
- != 0)
- /* The number was denormalized but now normalized. */
- exponent = MIN_EXP - 1;
- }
-
- if (exponent > MAX_EXP)
- return negative ? -FLOAT_HUGE_VAL : FLOAT_HUGE_VAL;
-
- return MPN2FLOAT (retval, exponent, negative);
-}
-
-
-/* Read a multi-precision integer starting at STR with exactly DIGCNT digits
- into N. Return the size of the number limbs in NSIZE at the first
- character od the string that is not part of the integer as the function
- value. If the EXPONENT is small enough to be taken as an additional
- factor for the resulting number (see code) multiply by it. */
-static const STRING_TYPE *
-str_to_mpn (const STRING_TYPE *str, int digcnt, mp_limb_t *n, mp_size_t *nsize,
- int *exponent
-#ifndef USE_WIDE_CHAR
- , const char *decimal, size_t decimal_len, const char *thousands
-#endif
-
- )
-{
- /* Number of digits for actual limb. */
- int cnt = 0;
- mp_limb_t low = 0;
- mp_limb_t start;
-
- *nsize = 0;
- assert (digcnt > 0);
- do
- {
- if (cnt == MAX_DIG_PER_LIMB)
- {
- if (*nsize == 0)
- {
- n[0] = low;
- *nsize = 1;
- }
- else
- {
- mp_limb_t cy;
- cy = __mpn_mul_1 (n, n, *nsize, MAX_FAC_PER_LIMB);
- cy += __mpn_add_1 (n, n, *nsize, low);
- if (cy != 0)
- {
- n[*nsize] = cy;
- ++(*nsize);
- }
- }
- cnt = 0;
- low = 0;
- }
-
- /* There might be thousands separators or radix characters in
- the string. But these all can be ignored because we know the
- format of the number is correct and we have an exact number
- of characters to read. */
-#ifdef USE_WIDE_CHAR
- if (*str < L'0' || *str > L'9')
- ++str;
-#else
- if (*str < '0' || *str > '9')
- {
- int inner = 0;
- if (thousands != NULL && *str == *thousands
- && ({ for (inner = 1; thousands[inner] != '\0'; ++inner)
- if (thousands[inner] != str[inner])
- break;
- thousands[inner] == '\0'; }))
- str += inner;
- else
- str += decimal_len;
- }
-#endif
- low = low * 10 + *str++ - L_('0');
- ++cnt;
- }
- while (--digcnt > 0);
-
- if (*exponent > 0 && cnt + *exponent <= MAX_DIG_PER_LIMB)
- {
- low *= _tens_in_limb[*exponent];
- start = _tens_in_limb[cnt + *exponent];
- *exponent = 0;
- }
- else
- start = _tens_in_limb[cnt];
-
- if (*nsize == 0)
- {
- n[0] = low;
- *nsize = 1;
- }
- else
- {
- mp_limb_t cy;
- cy = __mpn_mul_1 (n, n, *nsize, start);
- cy += __mpn_add_1 (n, n, *nsize, low);
- if (cy != 0)
- n[(*nsize)++] = cy;
- }
-
- return str;
-}
-
-
-/* Shift {PTR, SIZE} COUNT bits to the left, and fill the vacated bits
- with the COUNT most significant bits of LIMB.
-
- Tege doesn't like this function so I have to write it here myself. :)
- --drepper */
-static inline void
-__attribute ((always_inline))
-__mpn_lshift_1 (mp_limb_t *ptr, mp_size_t size, unsigned int count,
- mp_limb_t limb)
-{
- if (__builtin_constant_p (count) && count == BITS_PER_MP_LIMB)
- {
- /* Optimize the case of shifting by exactly a word:
- just copy words, with no actual bit-shifting. */
- mp_size_t i;
- for (i = size - 1; i > 0; --i)
- ptr[i] = ptr[i - 1];
- ptr[0] = limb;
- }
- else
- {
- (void) __mpn_lshift (ptr, ptr, size, count);
- ptr[0] |= limb >> (BITS_PER_MP_LIMB - count);
- }
-}
-
-
#define INTERNAL(x) INTERNAL1(x)
#define INTERNAL1(x) __##x##_internal
-/* This file defines a function to check for correct grouping. */
-#include "grouping.h"
-
-/* Return a floating point number with the value of the given string NPTR.
- Set *ENDPTR to the character after the last used one. If the number is
- smaller than the smallest representable number, set `errno' to ERANGE and
- return 0.0. If the number is too big to be represented, set `errno' to
- ERANGE and return HUGE_VAL with the appropriate sign. */
FLOAT
-INTERNAL (STRTOF) (nptr, endptr, group LOCALE_PARAM)
+INTERNAL (STRTOF) (nptr, endptr, group)
const STRING_TYPE *nptr;
STRING_TYPE **endptr;
int group;
- LOCALE_PARAM_DECL
{
- int negative; /* The sign of the number. */
- MPN_VAR (num); /* MP representation of the number. */
- int exponent; /* Exponent of the number. */
-
- /* Numbers starting `0X' or `0x' have to be processed with base 16. */
- int base = 10;
-
- /* When we have to compute fractional digits we form a fraction with a
- second multi-precision number (and we sometimes need a second for
- temporary results). */
- MPN_VAR (den);
-
- /* Representation for the return value. */
- mp_limb_t retval[RETURN_LIMB_SIZE];
- /* Number of bits currently in result value. */
- int bits;
-
- /* Running pointer after the last character processed in the string. */
- const STRING_TYPE *cp, *tp;
- /* Start of significant part of the number. */
- const STRING_TYPE *startp, *start_of_digits;
- /* Points at the character following the integer and fractional digits. */
- const STRING_TYPE *expp;
- /* Total number of digit and number of digits in integer part. */
- int dig_no, int_no, lead_zero;
- /* Contains the last character read. */
- CHAR_TYPE c;
-
-/* We should get wint_t from <stddef.h>, but not all GCC versions define it
- there. So define it ourselves if it remains undefined. */
-#ifndef _WINT_T
- typedef unsigned int wint_t;
-#endif
- /* The radix character of the current locale. */
-#ifdef USE_WIDE_CHAR
- wchar_t decimal;
-#else
- const char *decimal;
- size_t decimal_len;
-#endif
- /* The thousands character of the current locale. */
-#ifdef USE_WIDE_CHAR
- wchar_t thousands = L'\0';
-#else
- const char *thousands = NULL;
-#endif
- /* The numeric grouping specification of the current locale,
- in the format described in <locale.h>. */
- const char *grouping;
- /* Used in several places. */
- int cnt;
-
-#ifdef USE_IN_EXTENDED_LOCALE_MODEL
- struct locale_data *current = loc->__locales[LC_NUMERIC];
-#endif
-
- if (group)
- {
- grouping = _NL_CURRENT (LC_NUMERIC, GROUPING);
- if (*grouping <= 0 || *grouping == CHAR_MAX)
- grouping = NULL;
- else
- {
- /* Figure out the thousands separator character. */
-#ifdef USE_WIDE_CHAR
- thousands = _NL_CURRENT_WORD (LC_NUMERIC,
- _NL_NUMERIC_THOUSANDS_SEP_WC);
- if (thousands == L'\0')
- grouping = NULL;
-#else
- thousands = _NL_CURRENT (LC_NUMERIC, THOUSANDS_SEP);
- if (*thousands == '\0')
- {
- thousands = NULL;
- grouping = NULL;
- }
-#endif
- }
- }
- else
- grouping = NULL;
-
- /* Find the locale's decimal point character. */
-#ifdef USE_WIDE_CHAR
- decimal = _NL_CURRENT_WORD (LC_NUMERIC, _NL_NUMERIC_DECIMAL_POINT_WC);
- assert (decimal != L'\0');
-# define decimal_len 1
-#else
- decimal = _NL_CURRENT (LC_NUMERIC, DECIMAL_POINT);
- decimal_len = strlen (decimal);
- assert (decimal_len > 0);
-#endif
-
- /* Prepare number representation. */
- exponent = 0;
- negative = 0;
- bits = 0;
-
- /* Parse string to get maximal legal prefix. We need the number of
- characters of the integer part, the fractional part and the exponent. */
- cp = nptr - 1;
- /* Ignore leading white space. */
- do
- c = *++cp;
- while (ISSPACE (c));
-
- /* Get sign of the result. */
- if (c == L_('-'))
- {
- negative = 1;
- c = *++cp;
- }
- else if (c == L_('+'))
- c = *++cp;
-
- /* Return 0.0 if no legal string is found.
- No character is used even if a sign was found. */
-#ifdef USE_WIDE_CHAR
- if (c == (wint_t) decimal
- && (wint_t) cp[1] >= L'0' && (wint_t) cp[1] <= L'9')
- {
- /* We accept it. This funny construct is here only to indent
- the code directly. */
- }
-#else
- for (cnt = 0; decimal[cnt] != '\0'; ++cnt)
- if (cp[cnt] != decimal[cnt])
- break;
- if (decimal[cnt] == '\0' && cp[cnt] >= '0' && cp[cnt] <= '9')
- {
- /* We accept it. This funny construct is here only to indent
- the code directly. */
- }
-#endif
- else if (c < L_('0') || c > L_('9'))
- {
- /* Check for `INF' or `INFINITY'. */
- if (TOLOWER (c) == L_('i') && STRNCASECMP (cp, L_("inf"), 3) == 0)
- {
- /* Return +/- infinity. */
- if (endptr != NULL)
- *endptr = (STRING_TYPE *)
- (cp + (STRNCASECMP (cp + 3, L_("inity"), 5) == 0
- ? 8 : 3));
-
- return negative ? -FLOAT_HUGE_VAL : FLOAT_HUGE_VAL;
- }
-
- if (TOLOWER (c) == L_('n') && STRNCASECMP (cp, L_("nan"), 3) == 0)
- {
- /* Return NaN. */
- FLOAT retval = NAN;
-
- cp += 3;
-
- /* Match `(n-char-sequence-digit)'. */
- if (*cp == L_('('))
- {
- const STRING_TYPE *startp = cp;
- do
- ++cp;
- while ((*cp >= L_('0') && *cp <= L_('9'))
- || (TOLOWER (*cp) >= L_('a') && TOLOWER (*cp) <= L_('z'))
- || *cp == L_('_'));
-
- if (*cp != L_(')'))
- /* The closing brace is missing. Only match the NAN
- part. */
- cp = startp;
- else
- {
- /* This is a system-dependent way to specify the
- bitmask used for the NaN. We expect it to be
- a number which is put in the mantissa of the
- number. */
- STRING_TYPE *endp;
- unsigned long long int mant;
-
- mant = STRTOULL (startp + 1, &endp, 0);
- if (endp == cp)
- SET_MANTISSA (retval, mant);
- }
- }
-
- if (endptr != NULL)
- *endptr = (STRING_TYPE *) cp;
-
- return retval;
- }
-
- /* It is really a text we do not recognize. */
- RETURN (0.0, nptr);
- }
-
- /* First look whether we are faced with a hexadecimal number. */
- if (c == L_('0') && TOLOWER (cp[1]) == L_('x'))
- {
- /* Okay, it is a hexa-decimal number. Remember this and skip
- the characters. BTW: hexadecimal numbers must not be
- grouped. */
- base = 16;
- cp += 2;
- c = *cp;
- grouping = NULL;
- }
-
- /* Record the start of the digits, in case we will check their grouping. */
- start_of_digits = startp = cp;
-
- /* Ignore leading zeroes. This helps us to avoid useless computations. */
-#ifdef USE_WIDE_CHAR
- while (c == L'0' || ((wint_t) thousands != L'\0' && c == (wint_t) thousands))
- c = *++cp;
-#else
- if (thousands == NULL)
- while (c == '0')
- c = *++cp;
- else
- {
- /* We also have the multibyte thousands string. */
- while (1)
- {
- if (c != '0')
- {
- for (cnt = 0; thousands[cnt] != '\0'; ++cnt)
- if (c != thousands[cnt])
- break;
- if (thousands[cnt] != '\0')
- break;
- }
- c = *++cp;
- }
- }
-#endif
-
- /* If no other digit but a '0' is found the result is 0.0.
- Return current read pointer. */
- if ((c < L_('0') || c > L_('9'))
- && (base == 16 && (c < (CHAR_TYPE) TOLOWER (L_('a'))
- || c > (CHAR_TYPE) TOLOWER (L_('f'))))
-#ifdef USE_WIDE_CHAR
- && c != (wint_t) decimal
-#else
- && ({ for (cnt = 0; decimal[cnt] != '\0'; ++cnt)
- if (decimal[cnt] != cp[cnt])
- break;
- decimal[cnt] != '\0'; })
-#endif
- && (base == 16 && (cp == start_of_digits
- || (CHAR_TYPE) TOLOWER (c) != L_('p')))
- && (base != 16 && (CHAR_TYPE) TOLOWER (c) != L_('e')))
- {
-#ifdef USE_WIDE_CHAR
- tp = __correctly_grouped_prefixwc (start_of_digits, cp, thousands,
- grouping);
-#else
- tp = __correctly_grouped_prefixmb (start_of_digits, cp, thousands,
- grouping);
-#endif
- /* If TP is at the start of the digits, there was no correctly
- grouped prefix of the string; so no number found. */
- RETURN (0.0, tp == start_of_digits ? (base == 16 ? cp - 1 : nptr) : tp);
- }
-
- /* Remember first significant digit and read following characters until the
- decimal point, exponent character or any non-FP number character. */
- startp = cp;
- dig_no = 0;
- while (1)
- {
- if ((c >= L_('0') && c <= L_('9'))
- || (base == 16 && (wint_t) TOLOWER (c) >= L_('a')
- && (wint_t) TOLOWER (c) <= L_('f')))
- ++dig_no;
- else
- {
-#ifdef USE_WIDE_CHAR
- if ((wint_t) thousands == L'\0' || c != (wint_t) thousands)
- /* Not a digit or separator: end of the integer part. */
- break;
-#else
- if (thousands == NULL)
- break;
- else
- {
- for (cnt = 0; thousands[cnt] != '\0'; ++cnt)
- if (thousands[cnt] != cp[cnt])
- break;
- if (thousands[cnt] != '\0')
- break;
- }
-#endif
- }
- c = *++cp;
- }
-
- if (grouping && dig_no > 0)
- {
- /* Check the grouping of the digits. */
-#ifdef USE_WIDE_CHAR
- tp = __correctly_grouped_prefixwc (start_of_digits, cp, thousands,
- grouping);
-#else
- tp = __correctly_grouped_prefixmb (start_of_digits, cp, thousands,
- grouping);
-#endif
- if (cp != tp)
- {
- /* Less than the entire string was correctly grouped. */
-
- if (tp == start_of_digits)
- /* No valid group of numbers at all: no valid number. */
- RETURN (0.0, nptr);
-
- if (tp < startp)
- /* The number is validly grouped, but consists
- only of zeroes. The whole value is zero. */
- RETURN (0.0, tp);
-
- /* Recompute DIG_NO so we won't read more digits than
- are properly grouped. */
- cp = tp;
- dig_no = 0;
- for (tp = startp; tp < cp; ++tp)
- if (*tp >= L_('0') && *tp <= L_('9'))
- ++dig_no;
-
- int_no = dig_no;
- lead_zero = 0;
-
- goto number_parsed;
- }
- }
-
- /* We have the number digits in the integer part. Whether these are all or
- any is really a fractional digit will be decided later. */
- int_no = dig_no;
- lead_zero = int_no == 0 ? -1 : 0;
-
- /* Read the fractional digits. A special case are the 'american style'
- numbers like `16.' i.e. with decimal but without trailing digits. */
- if (
-#ifdef USE_WIDE_CHAR
- c == (wint_t) decimal
-#else
- ({ for (cnt = 0; decimal[cnt] != '\0'; ++cnt)
- if (decimal[cnt] != cp[cnt])
- break;
- decimal[cnt] == '\0'; })
-#endif
- )
- {
- cp += decimal_len;
- c = *cp;
- while ((c >= L_('0') && c <= L_('9')) ||
- (base == 16 && TOLOWER (c) >= L_('a') && TOLOWER (c) <= L_('f')))
- {
- if (c != L_('0') && lead_zero == -1)
- lead_zero = dig_no - int_no;
- ++dig_no;
- c = *++cp;
- }
- }
-
- /* Remember start of exponent (if any). */
- expp = cp;
-
- /* Read exponent. */
- if ((base == 16 && TOLOWER (c) == L_('p'))
- || (base != 16 && TOLOWER (c) == L_('e')))
- {
- int exp_negative = 0;
-
- c = *++cp;
- if (c == L_('-'))
- {
- exp_negative = 1;
- c = *++cp;
- }
- else if (c == L_('+'))
- c = *++cp;
-
- if (c >= L_('0') && c <= L_('9'))
- {
- int exp_limit;
-
- /* Get the exponent limit. */
- if (base == 16)
- exp_limit = (exp_negative ?
- -MIN_EXP + MANT_DIG + 4 * int_no :
- MAX_EXP - 4 * int_no + lead_zero);
- else
- exp_limit = (exp_negative ?
- -MIN_10_EXP + MANT_DIG + int_no :
- MAX_10_EXP - int_no + lead_zero);
-
- do
- {
- exponent *= 10;
-
- if (exponent > exp_limit)
- /* The exponent is too large/small to represent a valid
- number. */
- {
- FLOAT result;
-
- /* We have to take care for special situation: a joker
- might have written "0.0e100000" which is in fact
- zero. */
- if (lead_zero == -1)
- result = negative ? -0.0 : 0.0;
- else
- {
- /* Overflow or underflow. */
- __set_errno (ERANGE);
- result = (exp_negative ? 0.0 :
- negative ? -FLOAT_HUGE_VAL : FLOAT_HUGE_VAL);
- }
-
- /* Accept all following digits as part of the exponent. */
- do
- ++cp;
- while (*cp >= L_('0') && *cp <= L_('9'));
-
- RETURN (result, cp);
- /* NOTREACHED */
- }
-
- exponent += c - L_('0');
- c = *++cp;
- }
- while (c >= L_('0') && c <= L_('9'));
-
- if (exp_negative)
- exponent = -exponent;
- }
- else
- cp = expp;
- }
-
- /* We don't want to have to work with trailing zeroes after the radix. */
- if (dig_no > int_no)
- {
- while (expp[-1] == L_('0'))
- {
- --expp;
- --dig_no;
- }
- assert (dig_no >= int_no);
- }
-
- if (dig_no == int_no && dig_no > 0 && exponent < 0)
- do
- {
- while (! (base == 16 ? ISXDIGIT (expp[-1]) : ISDIGIT (expp[-1])))
- --expp;
-
- if (expp[-1] != L_('0'))
- break;
-
- --expp;
- --dig_no;
- --int_no;
- ++exponent;
- }
- while (dig_no > 0 && exponent < 0);
-
- number_parsed:
-
- /* The whole string is parsed. Store the address of the next character. */
- if (endptr)
- *endptr = (STRING_TYPE *) cp;
-
- if (dig_no == 0)
- return negative ? -0.0 : 0.0;
-
- if (lead_zero)
- {
- /* Find the decimal point */
-#ifdef USE_WIDE_CHAR
- while (*startp != decimal)
- ++startp;
-#else
- while (1)
- {
- if (*startp == decimal[0])
- {
- for (cnt = 1; decimal[cnt] != '\0'; ++cnt)
- if (decimal[cnt] != startp[cnt])
- break;
- if (decimal[cnt] == '\0')
- break;
- }
- ++startp;
- }
-#endif
- startp += lead_zero + decimal_len;
- exponent -= base == 16 ? 4 * lead_zero : lead_zero;
- dig_no -= lead_zero;
- }
-
- /* If the BASE is 16 we can use a simpler algorithm. */
- if (base == 16)
- {
- static const int nbits[16] = { 0, 1, 2, 2, 3, 3, 3, 3,
- 4, 4, 4, 4, 4, 4, 4, 4 };
- int idx = (MANT_DIG - 1) / BITS_PER_MP_LIMB;
- int pos = (MANT_DIG - 1) % BITS_PER_MP_LIMB;
- mp_limb_t val;
-
- while (!ISXDIGIT (*startp))
- ++startp;
- while (*startp == L_('0'))
- ++startp;
- if (ISDIGIT (*startp))
- val = *startp++ - L_('0');
- else
- val = 10 + TOLOWER (*startp++) - L_('a');
- bits = nbits[val];
- /* We cannot have a leading zero. */
- assert (bits != 0);
-
- if (pos + 1 >= 4 || pos + 1 >= bits)
- {
- /* We don't have to care for wrapping. This is the normal
- case so we add the first clause in the `if' expression as
- an optimization. It is a compile-time constant and so does
- not cost anything. */
- retval[idx] = val << (pos - bits + 1);
- pos -= bits;
- }
- else
- {
- retval[idx--] = val >> (bits - pos - 1);
- retval[idx] = val << (BITS_PER_MP_LIMB - (bits - pos - 1));
- pos = BITS_PER_MP_LIMB - 1 - (bits - pos - 1);
- }
-
- /* Adjust the exponent for the bits we are shifting in. */
- exponent += bits - 1 + (int_no - 1) * 4;
-
- while (--dig_no > 0 && idx >= 0)
- {
- if (!ISXDIGIT (*startp))
- startp += decimal_len;
- if (ISDIGIT (*startp))
- val = *startp++ - L_('0');
- else
- val = 10 + TOLOWER (*startp++) - L_('a');
-
- if (pos + 1 >= 4)
- {
- retval[idx] |= val << (pos - 4 + 1);
- pos -= 4;
- }
- else
- {
- retval[idx--] |= val >> (4 - pos - 1);
- val <<= BITS_PER_MP_LIMB - (4 - pos - 1);
- if (idx < 0)
- return round_and_return (retval, exponent, negative, val,
- BITS_PER_MP_LIMB - 1, dig_no > 0);
-
- retval[idx] = val;
- pos = BITS_PER_MP_LIMB - 1 - (4 - pos - 1);
- }
- }
-
- /* We ran out of digits. */
- MPN_ZERO (retval, idx);
-
- return round_and_return (retval, exponent, negative, 0, 0, 0);
- }
-
- /* Now we have the number of digits in total and the integer digits as well
- as the exponent and its sign. We can decide whether the read digits are
- really integer digits or belong to the fractional part; i.e. we normalize
- 123e-2 to 1.23. */
- {
- register int incr = (exponent < 0 ? MAX (-int_no, exponent)
- : MIN (dig_no - int_no, exponent));
- int_no += incr;
- exponent -= incr;
- }
-
- if (int_no + exponent > MAX_10_EXP + 1)
- {
- __set_errno (ERANGE);
- return negative ? -FLOAT_HUGE_VAL : FLOAT_HUGE_VAL;
- }
-
- if (exponent < MIN_10_EXP - (DIG + 1))
- {
- __set_errno (ERANGE);
- return 0.0;
- }
-
- if (int_no > 0)
- {
- /* Read the integer part as a multi-precision number to NUM. */
- startp = str_to_mpn (startp, int_no, num, &numsize, &exponent
-#ifndef USE_WIDE_CHAR
- , decimal, decimal_len, thousands
-#endif
- );
-
- if (exponent > 0)
- {
- /* We now multiply the gained number by the given power of ten. */
- mp_limb_t *psrc = num;
- mp_limb_t *pdest = den;
- int expbit = 1;
- const struct mp_power *ttab = &_fpioconst_pow10[0];
-
- do
- {
- if ((exponent & expbit) != 0)
- {
- size_t size = ttab->arraysize - _FPIO_CONST_OFFSET;
- mp_limb_t cy;
- exponent ^= expbit;
-
- /* FIXME: not the whole multiplication has to be
- done. If we have the needed number of bits we
- only need the information whether more non-zero
- bits follow. */
- if (numsize >= ttab->arraysize - _FPIO_CONST_OFFSET)
- cy = __mpn_mul (pdest, psrc, numsize,
- &__tens[ttab->arrayoff
- + _FPIO_CONST_OFFSET],
- size);
- else
- cy = __mpn_mul (pdest, &__tens[ttab->arrayoff
- + _FPIO_CONST_OFFSET],
- size, psrc, numsize);
- numsize += size;
- if (cy == 0)
- --numsize;
- (void) SWAP (psrc, pdest);
- }
- expbit <<= 1;
- ++ttab;
- }
- while (exponent != 0);
-
- if (psrc == den)
- memcpy (num, den, numsize * sizeof (mp_limb_t));
- }
-
- /* Determine how many bits of the result we already have. */
- count_leading_zeros (bits, num[numsize - 1]);
- bits = numsize * BITS_PER_MP_LIMB - bits;
-
- /* Now we know the exponent of the number in base two.
- Check it against the maximum possible exponent. */
- if (bits > MAX_EXP)
- {
- __set_errno (ERANGE);
- return negative ? -FLOAT_HUGE_VAL : FLOAT_HUGE_VAL;
- }
-
- /* We have already the first BITS bits of the result. Together with
- the information whether more non-zero bits follow this is enough
- to determine the result. */
- if (bits > MANT_DIG)
- {
- int i;
- const mp_size_t least_idx = (bits - MANT_DIG) / BITS_PER_MP_LIMB;
- const mp_size_t least_bit = (bits - MANT_DIG) % BITS_PER_MP_LIMB;
- const mp_size_t round_idx = least_bit == 0 ? least_idx - 1
- : least_idx;
- const mp_size_t round_bit = least_bit == 0 ? BITS_PER_MP_LIMB - 1
- : least_bit - 1;
-
- if (least_bit == 0)
- memcpy (retval, &num[least_idx],
- RETURN_LIMB_SIZE * sizeof (mp_limb_t));
- else
- {
- for (i = least_idx; i < numsize - 1; ++i)
- retval[i - least_idx] = (num[i] >> least_bit)
- | (num[i + 1]
- << (BITS_PER_MP_LIMB - least_bit));
- if (i - least_idx < RETURN_LIMB_SIZE)
- retval[RETURN_LIMB_SIZE - 1] = num[i] >> least_bit;
- }
-
- /* Check whether any limb beside the ones in RETVAL are non-zero. */
- for (i = 0; num[i] == 0; ++i)
- ;
-
- return round_and_return (retval, bits - 1, negative,
- num[round_idx], round_bit,
- int_no < dig_no || i < round_idx);
- /* NOTREACHED */
- }
- else if (dig_no == int_no)
- {
- const mp_size_t target_bit = (MANT_DIG - 1) % BITS_PER_MP_LIMB;
- const mp_size_t is_bit = (bits - 1) % BITS_PER_MP_LIMB;
-
- if (target_bit == is_bit)
- {
- memcpy (&retval[RETURN_LIMB_SIZE - numsize], num,
- numsize * sizeof (mp_limb_t));
- /* FIXME: the following loop can be avoided if we assume a
- maximal MANT_DIG value. */
- MPN_ZERO (retval, RETURN_LIMB_SIZE - numsize);
- }
- else if (target_bit > is_bit)
- {
- (void) __mpn_lshift (&retval[RETURN_LIMB_SIZE - numsize],
- num, numsize, target_bit - is_bit);
- /* FIXME: the following loop can be avoided if we assume a
- maximal MANT_DIG value. */
- MPN_ZERO (retval, RETURN_LIMB_SIZE - numsize);
- }
- else
- {
- mp_limb_t cy;
- assert (numsize < RETURN_LIMB_SIZE);
-
- cy = __mpn_rshift (&retval[RETURN_LIMB_SIZE - numsize],
- num, numsize, is_bit - target_bit);
- retval[RETURN_LIMB_SIZE - numsize - 1] = cy;
- /* FIXME: the following loop can be avoided if we assume a
- maximal MANT_DIG value. */
- MPN_ZERO (retval, RETURN_LIMB_SIZE - numsize - 1);
- }
-
- return round_and_return (retval, bits - 1, negative, 0, 0, 0);
- /* NOTREACHED */
- }
-
- /* Store the bits we already have. */
- memcpy (retval, num, numsize * sizeof (mp_limb_t));
-#if RETURN_LIMB_SIZE > 1
- if (numsize < RETURN_LIMB_SIZE)
- retval[numsize] = 0;
-#endif
- }
-
- /* We have to compute at least some of the fractional digits. */
- {
- /* We construct a fraction and the result of the division gives us
- the needed digits. The denominator is 1.0 multiplied by the
- exponent of the lowest digit; i.e. 0.123 gives 123 / 1000 and
- 123e-6 gives 123 / 1000000. */
-
- int expbit;
- int neg_exp;
- int more_bits;
- mp_limb_t cy;
- mp_limb_t *psrc = den;
- mp_limb_t *pdest = num;
- const struct mp_power *ttab = &_fpioconst_pow10[0];
-
- assert (dig_no > int_no && exponent <= 0);
-
-
- /* For the fractional part we need not process too many digits. One
- decimal digits gives us log_2(10) ~ 3.32 bits. If we now compute
- ceil(BITS / 3) =: N
- digits we should have enough bits for the result. The remaining
- decimal digits give us the information that more bits are following.
- This can be used while rounding. (Two added as a safety margin.) */
- if (dig_no - int_no > (MANT_DIG - bits + 2) / 3 + 2)
- {
- dig_no = int_no + (MANT_DIG - bits + 2) / 3 + 2;
- more_bits = 1;
- }
- else
- more_bits = 0;
-
- neg_exp = dig_no - int_no - exponent;
-
- /* Construct the denominator. */
- densize = 0;
- expbit = 1;
- do
- {
- if ((neg_exp & expbit) != 0)
- {
- mp_limb_t cy;
- neg_exp ^= expbit;
-
- if (densize == 0)
- {
- densize = ttab->arraysize - _FPIO_CONST_OFFSET;
- memcpy (psrc, &__tens[ttab->arrayoff + _FPIO_CONST_OFFSET],
- densize * sizeof (mp_limb_t));
- }
- else
- {
- cy = __mpn_mul (pdest, &__tens[ttab->arrayoff
- + _FPIO_CONST_OFFSET],
- ttab->arraysize - _FPIO_CONST_OFFSET,
- psrc, densize);
- densize += ttab->arraysize - _FPIO_CONST_OFFSET;
- if (cy == 0)
- --densize;
- (void) SWAP (psrc, pdest);
- }
- }
- expbit <<= 1;
- ++ttab;
- }
- while (neg_exp != 0);
-
- if (psrc == num)
- memcpy (den, num, densize * sizeof (mp_limb_t));
-
- /* Read the fractional digits from the string. */
- (void) str_to_mpn (startp, dig_no - int_no, num, &numsize, &exponent
-#ifndef USE_WIDE_CHAR
- , decimal, decimal_len, thousands
-#endif
- );
-
- /* We now have to shift both numbers so that the highest bit in the
- denominator is set. In the same process we copy the numerator to
- a high place in the array so that the division constructs the wanted
- digits. This is done by a "quasi fix point" number representation.
-
- num: ddddddddddd . 0000000000000000000000
- |--- m ---|
- den: ddddddddddd n >= m
- |--- n ---|
- */
-
- count_leading_zeros (cnt, den[densize - 1]);
-
- if (cnt > 0)
- {
- /* Don't call `mpn_shift' with a count of zero since the specification
- does not allow this. */
- (void) __mpn_lshift (den, den, densize, cnt);
- cy = __mpn_lshift (num, num, numsize, cnt);
- if (cy != 0)
- num[numsize++] = cy;
- }
-
- /* Now we are ready for the division. But it is not necessary to
- do a full multi-precision division because we only need a small
- number of bits for the result. So we do not use __mpn_divmod
- here but instead do the division here by hand and stop whenever
- the needed number of bits is reached. The code itself comes
- from the GNU MP Library by Torbj\"orn Granlund. */
-
- exponent = bits;
-
- switch (densize)
- {
- case 1:
- {
- mp_limb_t d, n, quot;
- int used = 0;
-
- n = num[0];
- d = den[0];
- assert (numsize == 1 && n < d);
-
- do
- {
- udiv_qrnnd (quot, n, n, 0, d);
-
-#define got_limb \
- if (bits == 0) \
- { \
- register int cnt; \
- if (quot == 0) \
- cnt = BITS_PER_MP_LIMB; \
- else \
- count_leading_zeros (cnt, quot); \
- exponent -= cnt; \
- if (BITS_PER_MP_LIMB - cnt > MANT_DIG) \
- { \
- used = MANT_DIG + cnt; \
- retval[0] = quot >> (BITS_PER_MP_LIMB - used); \
- bits = MANT_DIG + 1; \
- } \
- else \
- { \
- /* Note that we only clear the second element. */ \
- /* The conditional is determined at compile time. */ \
- if (RETURN_LIMB_SIZE > 1) \
- retval[1] = 0; \
- retval[0] = quot; \
- bits = -cnt; \
- } \
- } \
- else if (bits + BITS_PER_MP_LIMB <= MANT_DIG) \
- __mpn_lshift_1 (retval, RETURN_LIMB_SIZE, BITS_PER_MP_LIMB, \
- quot); \
- else \
- { \
- used = MANT_DIG - bits; \
- if (used > 0) \
- __mpn_lshift_1 (retval, RETURN_LIMB_SIZE, used, quot); \
- } \
- bits += BITS_PER_MP_LIMB
-
- got_limb;
- }
- while (bits <= MANT_DIG);
-
- return round_and_return (retval, exponent - 1, negative,
- quot, BITS_PER_MP_LIMB - 1 - used,
- more_bits || n != 0);
- }
- case 2:
- {
- mp_limb_t d0, d1, n0, n1;
- mp_limb_t quot = 0;
- int used = 0;
-
- d0 = den[0];
- d1 = den[1];
-
- if (numsize < densize)
- {
- if (num[0] >= d1)
- {
- /* The numerator of the number occupies fewer bits than
- the denominator but the one limb is bigger than the
- high limb of the numerator. */
- n1 = 0;
- n0 = num[0];
- }
- else
- {
- if (bits <= 0)
- exponent -= BITS_PER_MP_LIMB;
- else
- {
- if (bits + BITS_PER_MP_LIMB <= MANT_DIG)
- __mpn_lshift_1 (retval, RETURN_LIMB_SIZE,
- BITS_PER_MP_LIMB, 0);
- else
- {
- used = MANT_DIG - bits;
- if (used > 0)
- __mpn_lshift_1 (retval, RETURN_LIMB_SIZE, used, 0);
- }
- bits += BITS_PER_MP_LIMB;
- }
- n1 = num[0];
- n0 = 0;
- }
- }
- else
- {
- n1 = num[1];
- n0 = num[0];
- }
-
- while (bits <= MANT_DIG)
- {
- mp_limb_t r;
-
- if (n1 == d1)
- {
- /* QUOT should be either 111..111 or 111..110. We need
- special treatment of this rare case as normal division
- would give overflow. */
- quot = ~(mp_limb_t) 0;
-
- r = n0 + d1;
- if (r < d1) /* Carry in the addition? */
- {
- add_ssaaaa (n1, n0, r - d0, 0, 0, d0);
- goto have_quot;
- }
- n1 = d0 - (d0 != 0);
- n0 = -d0;
- }
- else
- {
- udiv_qrnnd (quot, r, n1, n0, d1);
- umul_ppmm (n1, n0, d0, quot);
- }
-
- q_test:
- if (n1 > r || (n1 == r && n0 > 0))
- {
- /* The estimated QUOT was too large. */
- --quot;
-
- sub_ddmmss (n1, n0, n1, n0, 0, d0);
- r += d1;
- if (r >= d1) /* If not carry, test QUOT again. */
- goto q_test;
- }
- sub_ddmmss (n1, n0, r, 0, n1, n0);
-
- have_quot:
- got_limb;
- }
-
- return round_and_return (retval, exponent - 1, negative,
- quot, BITS_PER_MP_LIMB - 1 - used,
- more_bits || n1 != 0 || n0 != 0);
- }
- default:
- {
- int i;
- mp_limb_t cy, dX, d1, n0, n1;
- mp_limb_t quot = 0;
- int used = 0;
-
- dX = den[densize - 1];
- d1 = den[densize - 2];
-
- /* The division does not work if the upper limb of the two-limb
- numerator is greater than the denominator. */
- if (__mpn_cmp (num, &den[densize - numsize], numsize) > 0)
- num[numsize++] = 0;
-
- if (numsize < densize)
- {
- mp_size_t empty = densize - numsize;
-
- if (bits <= 0)
- {
- register int i;
- for (i = numsize; i > 0; --i)
- num[i + empty] = num[i - 1];
- MPN_ZERO (num, empty + 1);
- exponent -= empty * BITS_PER_MP_LIMB;
- }
- else
- {
- if (bits + empty * BITS_PER_MP_LIMB <= MANT_DIG)
- {
- /* We make a difference here because the compiler
- cannot optimize the `else' case that good and
- this reflects all currently used FLOAT types
- and GMP implementations. */
- register int i;
-#if RETURN_LIMB_SIZE <= 2
- assert (empty == 1);
- __mpn_lshift_1 (retval, RETURN_LIMB_SIZE,
- BITS_PER_MP_LIMB, 0);
-#else
- for (i = RETURN_LIMB_SIZE; i > empty; --i)
- retval[i] = retval[i - empty];
-#endif
- for (i = numsize; i > 0; --i)
- num[i + empty] = num[i - 1];
- MPN_ZERO (num, empty + 1);
- }
- else
- {
- used = MANT_DIG - bits;
- if (used >= BITS_PER_MP_LIMB)
- {
- register int i;
- (void) __mpn_lshift (&retval[used
- / BITS_PER_MP_LIMB],
- retval, RETURN_LIMB_SIZE,
- used % BITS_PER_MP_LIMB);
- for (i = used / BITS_PER_MP_LIMB; i >= 0; --i)
- retval[i] = 0;
- }
- else if (used > 0)
- __mpn_lshift_1 (retval, RETURN_LIMB_SIZE, used, 0);
- }
- bits += empty * BITS_PER_MP_LIMB;
- }
- }
- else
- {
- int i;
- assert (numsize == densize);
- for (i = numsize; i > 0; --i)
- num[i] = num[i - 1];
- }
-
- den[densize] = 0;
- n0 = num[densize];
-
- while (bits <= MANT_DIG)
- {
- if (n0 == dX)
- /* This might over-estimate QUOT, but it's probably not
- worth the extra code here to find out. */
- quot = ~(mp_limb_t) 0;
- else
- {
- mp_limb_t r;
-
- udiv_qrnnd (quot, r, n0, num[densize - 1], dX);
- umul_ppmm (n1, n0, d1, quot);
-
- while (n1 > r || (n1 == r && n0 > num[densize - 2]))
- {
- --quot;
- r += dX;
- if (r < dX) /* I.e. "carry in previous addition?" */
- break;
- n1 -= n0 < d1;
- n0 -= d1;
- }
- }
-
- /* Possible optimization: We already have (q * n0) and (1 * n1)
- after the calculation of QUOT. Taking advantage of this, we
- could make this loop make two iterations less. */
-
- cy = __mpn_submul_1 (num, den, densize + 1, quot);
-
- if (num[densize] != cy)
- {
- cy = __mpn_add_n (num, num, den, densize);
- assert (cy != 0);
- --quot;
- }
- n0 = num[densize] = num[densize - 1];
- for (i = densize - 1; i > 0; --i)
- num[i] = num[i - 1];
-
- got_limb;
- }
-
- for (i = densize; num[i] == 0 && i >= 0; --i)
- ;
- return round_and_return (retval, exponent - 1, negative,
- quot, BITS_PER_MP_LIMB - 1 - used,
- more_bits || i >= 0);
- }
- }
- }
-
- /* NOTREACHED */
+ return INTERNAL(STRTOF_L) (nptr, endptr, group, _NL_CURRENT_LOCALE);
}
-#if defined _LIBC \
- && !(defined USE_IN_EXTENDED_LOCALE_MODEL && defined USE_WIDE_CHAR)
+#if defined _LIBC
libc_hidden_def (INTERNAL (STRTOF))
#endif
-\f
-/* External user entry point. */
+
FLOAT
#ifdef weak_function
weak_function
#endif
-STRTOF (nptr, endptr LOCALE_PARAM)
+STRTOF (nptr, endptr)
const STRING_TYPE *nptr;
STRING_TYPE **endptr;
- LOCALE_PARAM_DECL
{
- return INTERNAL (STRTOF) (nptr, endptr, 0 LOCALE_PARAM);
+ return INTERNAL(STRTOF_L) (nptr, endptr, 0, _NL_CURRENT_LOCALE);
}
/* Convert string representing a number to float value, using given locale.
- Copyright (C) 1997,98,2002 Free Software Foundation, Inc.
+ Copyright (C) 1997,98,2002, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
-#define USE_IN_EXTENDED_LOCALE_MODEL 1
-
#include <xlocale.h>
extern double ____strtod_l_internal (const char *, char **, int, __locale_t);
extern unsigned long long int ____strtoull_l_internal (const char *, char **,
int, int, __locale_t);
-#include <strtod.c>
+/* Configuration part. These macros are defined by `strtold.c',
+ `strtof.c', `wcstod.c', `wcstold.c', and `wcstof.c' to produce the
+ `long double' and `float' versions of the reader. */
+#ifndef FLOAT
+# define FLOAT double
+# define FLT DBL
+# ifdef USE_WIDE_CHAR
+# define STRTOF wcstod_l
+# define __STRTOF __wcstod_l
+# else
+# define STRTOF strtod_l
+# define __STRTOF __strtod_l
+# endif
+# define MPN2FLOAT __mpn_construct_double
+# define FLOAT_HUGE_VAL HUGE_VAL
+# define SET_MANTISSA(flt, mant) \
+ do { union ieee754_double u; \
+ u.d = (flt); \
+ if ((mant & 0xfffffffffffffULL) == 0) \
+ mant = 0x8000000000000ULL; \
+ u.ieee.mantissa0 = ((mant) >> 32) & 0xfffff; \
+ u.ieee.mantissa1 = (mant) & 0xffffffff; \
+ (flt) = u.d; \
+ } while (0)
+#endif
+/* End of configuration part. */
+\f
+#include <ctype.h>
+#include <errno.h>
+#include <float.h>
+#include <ieee754.h>
+#include "../locale/localeinfo.h"
+#include <locale.h>
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* The gmp headers need some configuration frobs. */
+#define HAVE_ALLOCA 1
+
+/* Include gmp-mparam.h first, such that definitions of _SHORT_LIMB
+ and _LONG_LONG_LIMB in it can take effect into gmp.h. */
+#include <gmp-mparam.h>
+#include <gmp.h>
+#include <gmp-impl.h>
+#include <longlong.h>
+#include "fpioconst.h"
+
+#define NDEBUG 1
+#include <assert.h>
+
+
+/* We use this code for the extended locale handling where the
+ function gets as an additional argument the locale which has to be
+ used. To access the values we have to redefine the _NL_CURRENT and
+ _NL_CURRENT_WORD macros. */
+#undef _NL_CURRENT
+#define _NL_CURRENT(category, item) \
+ (current->values[_NL_ITEM_INDEX (item)].string)
+#undef _NL_CURRENT_WORD
+#define _NL_CURRENT_WORD(category, item) \
+ ((uint32_t) current->values[_NL_ITEM_INDEX (item)].word)
+
+#if defined _LIBC || defined HAVE_WCHAR_H
+# include <wchar.h>
+#endif
+
+#ifdef USE_WIDE_CHAR
+# include <wctype.h>
+# define STRING_TYPE wchar_t
+# define CHAR_TYPE wint_t
+# define L_(Ch) L##Ch
+# define ISSPACE(Ch) __iswspace_l ((Ch), loc)
+# define ISDIGIT(Ch) __iswdigit_l ((Ch), loc)
+# define ISXDIGIT(Ch) __iswxdigit_l ((Ch), loc)
+# define TOLOWER(Ch) __towlower_l ((Ch), loc)
+# define STRNCASECMP(S1, S2, N) __wcsncasecmp_l ((S1), (S2), (N), loc)
+# define STRTOULL(S, E, B) ____wcstoull_l_internal ((S), (E), (B), 0, loc)
+#else
+# define STRING_TYPE char
+# define CHAR_TYPE char
+# define L_(Ch) Ch
+# define ISSPACE(Ch) __isspace_l ((Ch), loc)
+# define ISDIGIT(Ch) __isdigit_l ((Ch), loc)
+# define ISXDIGIT(Ch) __isxdigit_l ((Ch), loc)
+# define TOLOWER(Ch) __tolower_l ((Ch), loc)
+# define STRNCASECMP(S1, S2, N) __strncasecmp_l ((S1), (S2), (N), loc)
+# define STRTOULL(S, E, B) ____strtoull_l_internal ((S), (E), (B), 0, loc)
+#endif
+
+
+/* Constants we need from float.h; select the set for the FLOAT precision. */
+#define MANT_DIG PASTE(FLT,_MANT_DIG)
+#define DIG PASTE(FLT,_DIG)
+#define MAX_EXP PASTE(FLT,_MAX_EXP)
+#define MIN_EXP PASTE(FLT,_MIN_EXP)
+#define MAX_10_EXP PASTE(FLT,_MAX_10_EXP)
+#define MIN_10_EXP PASTE(FLT,_MIN_10_EXP)
+
+/* Extra macros required to get FLT expanded before the pasting. */
+#define PASTE(a,b) PASTE1(a,b)
+#define PASTE1(a,b) a##b
+
+/* Function to construct a floating point number from an MP integer
+ containing the fraction bits, a base 2 exponent, and a sign flag. */
+extern FLOAT MPN2FLOAT (mp_srcptr mpn, int exponent, int negative);
+\f
+/* Definitions according to limb size used. */
+#if BITS_PER_MP_LIMB == 32
+# define MAX_DIG_PER_LIMB 9
+# define MAX_FAC_PER_LIMB 1000000000UL
+#elif BITS_PER_MP_LIMB == 64
+# define MAX_DIG_PER_LIMB 19
+# define MAX_FAC_PER_LIMB 10000000000000000000ULL
+#else
+# error "mp_limb_t size " BITS_PER_MP_LIMB "not accounted for"
+#endif
+
+
+/* Local data structure. */
+static const mp_limb_t _tens_in_limb[MAX_DIG_PER_LIMB + 1] =
+{ 0, 10, 100,
+ 1000, 10000, 100000L,
+ 1000000L, 10000000L, 100000000L,
+ 1000000000L
+#if BITS_PER_MP_LIMB > 32
+ , 10000000000ULL, 100000000000ULL,
+ 1000000000000ULL, 10000000000000ULL, 100000000000000ULL,
+ 1000000000000000ULL, 10000000000000000ULL, 100000000000000000ULL,
+ 1000000000000000000ULL, 10000000000000000000ULL
+#endif
+#if BITS_PER_MP_LIMB > 64
+ #error "Need to expand tens_in_limb table to" MAX_DIG_PER_LIMB
+#endif
+};
+\f
+#ifndef howmany
+#define howmany(x,y) (((x)+((y)-1))/(y))
+#endif
+#define SWAP(x, y) ({ typeof(x) _tmp = x; x = y; y = _tmp; })
+
+#define NDIG (MAX_10_EXP - MIN_10_EXP + 2 * MANT_DIG)
+#define HEXNDIG ((MAX_EXP - MIN_EXP + 7) / 8 + 2 * MANT_DIG)
+#define RETURN_LIMB_SIZE howmany (MANT_DIG, BITS_PER_MP_LIMB)
+
+#define RETURN(val,end) \
+ do { if (endptr != NULL) *endptr = (STRING_TYPE *) (end); \
+ return val; } while (0)
+
+/* Maximum size necessary for mpn integers to hold floating point numbers. */
+#define MPNSIZE (howmany (MAX_EXP + 2 * MANT_DIG, BITS_PER_MP_LIMB) \
+ + 2)
+/* Declare an mpn integer variable that big. */
+#define MPN_VAR(name) mp_limb_t name[MPNSIZE]; mp_size_t name##size
+/* Copy an mpn integer value. */
+#define MPN_ASSIGN(dst, src) \
+ memcpy (dst, src, (dst##size = src##size) * sizeof (mp_limb_t))
+
+
+/* Return a floating point number of the needed type according to the given
+ multi-precision number after possible rounding. */
+static FLOAT
+round_and_return (mp_limb_t *retval, int exponent, int negative,
+ mp_limb_t round_limb, mp_size_t round_bit, int more_bits)
+{
+ if (exponent < MIN_EXP - 1)
+ {
+ mp_size_t shift = MIN_EXP - 1 - exponent;
+
+ if (shift > MANT_DIG)
+ {
+ __set_errno (EDOM);
+ return 0.0;
+ }
+
+ more_bits |= (round_limb & ((((mp_limb_t) 1) << round_bit) - 1)) != 0;
+ if (shift == MANT_DIG)
+ /* This is a special case to handle the very seldom case where
+ the mantissa will be empty after the shift. */
+ {
+ int i;
+
+ round_limb = retval[RETURN_LIMB_SIZE - 1];
+ round_bit = (MANT_DIG - 1) % BITS_PER_MP_LIMB;
+ for (i = 0; i < RETURN_LIMB_SIZE; ++i)
+ more_bits |= retval[i] != 0;
+ MPN_ZERO (retval, RETURN_LIMB_SIZE);
+ }
+ else if (shift >= BITS_PER_MP_LIMB)
+ {
+ int i;
+
+ round_limb = retval[(shift - 1) / BITS_PER_MP_LIMB];
+ round_bit = (shift - 1) % BITS_PER_MP_LIMB;
+ for (i = 0; i < (shift - 1) / BITS_PER_MP_LIMB; ++i)
+ more_bits |= retval[i] != 0;
+ more_bits |= ((round_limb & ((((mp_limb_t) 1) << round_bit) - 1))
+ != 0);
+
+ (void) __mpn_rshift (retval, &retval[shift / BITS_PER_MP_LIMB],
+ RETURN_LIMB_SIZE - (shift / BITS_PER_MP_LIMB),
+ shift % BITS_PER_MP_LIMB);
+ MPN_ZERO (&retval[RETURN_LIMB_SIZE - (shift / BITS_PER_MP_LIMB)],
+ shift / BITS_PER_MP_LIMB);
+ }
+ else if (shift > 0)
+ {
+ round_limb = retval[0];
+ round_bit = shift - 1;
+ (void) __mpn_rshift (retval, retval, RETURN_LIMB_SIZE, shift);
+ }
+ /* This is a hook for the m68k long double format, where the
+ exponent bias is the same for normalized and denormalized
+ numbers. */
+#ifndef DENORM_EXP
+# define DENORM_EXP (MIN_EXP - 2)
+#endif
+ exponent = DENORM_EXP;
+ }
+
+ if ((round_limb & (((mp_limb_t) 1) << round_bit)) != 0
+ && (more_bits || (retval[0] & 1) != 0
+ || (round_limb & ((((mp_limb_t) 1) << round_bit) - 1)) != 0))
+ {
+ mp_limb_t cy = __mpn_add_1 (retval, retval, RETURN_LIMB_SIZE, 1);
+
+ if (((MANT_DIG % BITS_PER_MP_LIMB) == 0 && cy) ||
+ ((MANT_DIG % BITS_PER_MP_LIMB) != 0 &&
+ (retval[RETURN_LIMB_SIZE - 1]
+ & (((mp_limb_t) 1) << (MANT_DIG % BITS_PER_MP_LIMB))) != 0))
+ {
+ ++exponent;
+ (void) __mpn_rshift (retval, retval, RETURN_LIMB_SIZE, 1);
+ retval[RETURN_LIMB_SIZE - 1]
+ |= ((mp_limb_t) 1) << ((MANT_DIG - 1) % BITS_PER_MP_LIMB);
+ }
+ else if (exponent == DENORM_EXP
+ && (retval[RETURN_LIMB_SIZE - 1]
+ & (((mp_limb_t) 1) << ((MANT_DIG - 1) % BITS_PER_MP_LIMB)))
+ != 0)
+ /* The number was denormalized but now normalized. */
+ exponent = MIN_EXP - 1;
+ }
+
+ if (exponent > MAX_EXP)
+ return negative ? -FLOAT_HUGE_VAL : FLOAT_HUGE_VAL;
+
+ return MPN2FLOAT (retval, exponent, negative);
+}
+
+
+/* Read a multi-precision integer starting at STR with exactly DIGCNT digits
+ into N. Return the size of the number limbs in NSIZE at the first
+ character od the string that is not part of the integer as the function
+ value. If the EXPONENT is small enough to be taken as an additional
+ factor for the resulting number (see code) multiply by it. */
+static const STRING_TYPE *
+str_to_mpn (const STRING_TYPE *str, int digcnt, mp_limb_t *n, mp_size_t *nsize,
+ int *exponent
+#ifndef USE_WIDE_CHAR
+ , const char *decimal, size_t decimal_len, const char *thousands
+#endif
+
+ )
+{
+ /* Number of digits for actual limb. */
+ int cnt = 0;
+ mp_limb_t low = 0;
+ mp_limb_t start;
+
+ *nsize = 0;
+ assert (digcnt > 0);
+ do
+ {
+ if (cnt == MAX_DIG_PER_LIMB)
+ {
+ if (*nsize == 0)
+ {
+ n[0] = low;
+ *nsize = 1;
+ }
+ else
+ {
+ mp_limb_t cy;
+ cy = __mpn_mul_1 (n, n, *nsize, MAX_FAC_PER_LIMB);
+ cy += __mpn_add_1 (n, n, *nsize, low);
+ if (cy != 0)
+ {
+ n[*nsize] = cy;
+ ++(*nsize);
+ }
+ }
+ cnt = 0;
+ low = 0;
+ }
+
+ /* There might be thousands separators or radix characters in
+ the string. But these all can be ignored because we know the
+ format of the number is correct and we have an exact number
+ of characters to read. */
+#ifdef USE_WIDE_CHAR
+ if (*str < L'0' || *str > L'9')
+ ++str;
+#else
+ if (*str < '0' || *str > '9')
+ {
+ int inner = 0;
+ if (thousands != NULL && *str == *thousands
+ && ({ for (inner = 1; thousands[inner] != '\0'; ++inner)
+ if (thousands[inner] != str[inner])
+ break;
+ thousands[inner] == '\0'; }))
+ str += inner;
+ else
+ str += decimal_len;
+ }
+#endif
+ low = low * 10 + *str++ - L_('0');
+ ++cnt;
+ }
+ while (--digcnt > 0);
+
+ if (*exponent > 0 && cnt + *exponent <= MAX_DIG_PER_LIMB)
+ {
+ low *= _tens_in_limb[*exponent];
+ start = _tens_in_limb[cnt + *exponent];
+ *exponent = 0;
+ }
+ else
+ start = _tens_in_limb[cnt];
+
+ if (*nsize == 0)
+ {
+ n[0] = low;
+ *nsize = 1;
+ }
+ else
+ {
+ mp_limb_t cy;
+ cy = __mpn_mul_1 (n, n, *nsize, start);
+ cy += __mpn_add_1 (n, n, *nsize, low);
+ if (cy != 0)
+ n[(*nsize)++] = cy;
+ }
+
+ return str;
+}
+
+
+/* Shift {PTR, SIZE} COUNT bits to the left, and fill the vacated bits
+ with the COUNT most significant bits of LIMB.
+
+ Tege doesn't like this function so I have to write it here myself. :)
+ --drepper */
+static inline void
+__attribute ((always_inline))
+__mpn_lshift_1 (mp_limb_t *ptr, mp_size_t size, unsigned int count,
+ mp_limb_t limb)
+{
+ if (__builtin_constant_p (count) && count == BITS_PER_MP_LIMB)
+ {
+ /* Optimize the case of shifting by exactly a word:
+ just copy words, with no actual bit-shifting. */
+ mp_size_t i;
+ for (i = size - 1; i > 0; --i)
+ ptr[i] = ptr[i - 1];
+ ptr[0] = limb;
+ }
+ else
+ {
+ (void) __mpn_lshift (ptr, ptr, size, count);
+ ptr[0] |= limb >> (BITS_PER_MP_LIMB - count);
+ }
+}
+
+
+#define INTERNAL(x) INTERNAL1(x)
+#define INTERNAL1(x) __##x##_internal
+
+/* This file defines a function to check for correct grouping. */
+#include "grouping.h"
+
+
+/* Return a floating point number with the value of the given string NPTR.
+ Set *ENDPTR to the character after the last used one. If the number is
+ smaller than the smallest representable number, set `errno' to ERANGE and
+ return 0.0. If the number is too big to be represented, set `errno' to
+ ERANGE and return HUGE_VAL with the appropriate sign. */
+FLOAT
+INTERNAL (__STRTOF) (nptr, endptr, group, loc)
+ const STRING_TYPE *nptr;
+ STRING_TYPE **endptr;
+ int group;
+ __locale_t loc;
+{
+ int negative; /* The sign of the number. */
+ MPN_VAR (num); /* MP representation of the number. */
+ int exponent; /* Exponent of the number. */
+
+ /* Numbers starting `0X' or `0x' have to be processed with base 16. */
+ int base = 10;
+
+ /* When we have to compute fractional digits we form a fraction with a
+ second multi-precision number (and we sometimes need a second for
+ temporary results). */
+ MPN_VAR (den);
+
+ /* Representation for the return value. */
+ mp_limb_t retval[RETURN_LIMB_SIZE];
+ /* Number of bits currently in result value. */
+ int bits;
+
+ /* Running pointer after the last character processed in the string. */
+ const STRING_TYPE *cp, *tp;
+ /* Start of significant part of the number. */
+ const STRING_TYPE *startp, *start_of_digits;
+ /* Points at the character following the integer and fractional digits. */
+ const STRING_TYPE *expp;
+ /* Total number of digit and number of digits in integer part. */
+ int dig_no, int_no, lead_zero;
+ /* Contains the last character read. */
+ CHAR_TYPE c;
+
+/* We should get wint_t from <stddef.h>, but not all GCC versions define it
+ there. So define it ourselves if it remains undefined. */
+#ifndef _WINT_T
+ typedef unsigned int wint_t;
+#endif
+ /* The radix character of the current locale. */
+#ifdef USE_WIDE_CHAR
+ wchar_t decimal;
+#else
+ const char *decimal;
+ size_t decimal_len;
+#endif
+ /* The thousands character of the current locale. */
+#ifdef USE_WIDE_CHAR
+ wchar_t thousands = L'\0';
+#else
+ const char *thousands = NULL;
+#endif
+ /* The numeric grouping specification of the current locale,
+ in the format described in <locale.h>. */
+ const char *grouping;
+ /* Used in several places. */
+ int cnt;
+
+ struct locale_data *current = loc->__locales[LC_NUMERIC];
+
+ if (group)
+ {
+ grouping = _NL_CURRENT (LC_NUMERIC, GROUPING);
+ if (*grouping <= 0 || *grouping == CHAR_MAX)
+ grouping = NULL;
+ else
+ {
+ /* Figure out the thousands separator character. */
+#ifdef USE_WIDE_CHAR
+ thousands = _NL_CURRENT_WORD (LC_NUMERIC,
+ _NL_NUMERIC_THOUSANDS_SEP_WC);
+ if (thousands == L'\0')
+ grouping = NULL;
+#else
+ thousands = _NL_CURRENT (LC_NUMERIC, THOUSANDS_SEP);
+ if (*thousands == '\0')
+ {
+ thousands = NULL;
+ grouping = NULL;
+ }
+#endif
+ }
+ }
+ else
+ grouping = NULL;
+
+ /* Find the locale's decimal point character. */
+#ifdef USE_WIDE_CHAR
+ decimal = _NL_CURRENT_WORD (LC_NUMERIC, _NL_NUMERIC_DECIMAL_POINT_WC);
+ assert (decimal != L'\0');
+# define decimal_len 1
+#else
+ decimal = _NL_CURRENT (LC_NUMERIC, DECIMAL_POINT);
+ decimal_len = strlen (decimal);
+ assert (decimal_len > 0);
+#endif
+
+ /* Prepare number representation. */
+ exponent = 0;
+ negative = 0;
+ bits = 0;
+
+ /* Parse string to get maximal legal prefix. We need the number of
+ characters of the integer part, the fractional part and the exponent. */
+ cp = nptr - 1;
+ /* Ignore leading white space. */
+ do
+ c = *++cp;
+ while (ISSPACE (c));
+
+ /* Get sign of the result. */
+ if (c == L_('-'))
+ {
+ negative = 1;
+ c = *++cp;
+ }
+ else if (c == L_('+'))
+ c = *++cp;
+
+ /* Return 0.0 if no legal string is found.
+ No character is used even if a sign was found. */
+#ifdef USE_WIDE_CHAR
+ if (c == (wint_t) decimal
+ && (wint_t) cp[1] >= L'0' && (wint_t) cp[1] <= L'9')
+ {
+ /* We accept it. This funny construct is here only to indent
+ the code directly. */
+ }
+#else
+ for (cnt = 0; decimal[cnt] != '\0'; ++cnt)
+ if (cp[cnt] != decimal[cnt])
+ break;
+ if (decimal[cnt] == '\0' && cp[cnt] >= '0' && cp[cnt] <= '9')
+ {
+ /* We accept it. This funny construct is here only to indent
+ the code directly. */
+ }
+#endif
+ else if (c < L_('0') || c > L_('9'))
+ {
+ /* Check for `INF' or `INFINITY'. */
+ if (TOLOWER (c) == L_('i') && STRNCASECMP (cp, L_("inf"), 3) == 0)
+ {
+ /* Return +/- infinity. */
+ if (endptr != NULL)
+ *endptr = (STRING_TYPE *)
+ (cp + (STRNCASECMP (cp + 3, L_("inity"), 5) == 0
+ ? 8 : 3));
+
+ return negative ? -FLOAT_HUGE_VAL : FLOAT_HUGE_VAL;
+ }
+
+ if (TOLOWER (c) == L_('n') && STRNCASECMP (cp, L_("nan"), 3) == 0)
+ {
+ /* Return NaN. */
+ FLOAT retval = NAN;
+
+ cp += 3;
+
+ /* Match `(n-char-sequence-digit)'. */
+ if (*cp == L_('('))
+ {
+ const STRING_TYPE *startp = cp;
+ do
+ ++cp;
+ while ((*cp >= L_('0') && *cp <= L_('9'))
+ || (TOLOWER (*cp) >= L_('a') && TOLOWER (*cp) <= L_('z'))
+ || *cp == L_('_'));
+
+ if (*cp != L_(')'))
+ /* The closing brace is missing. Only match the NAN
+ part. */
+ cp = startp;
+ else
+ {
+ /* This is a system-dependent way to specify the
+ bitmask used for the NaN. We expect it to be
+ a number which is put in the mantissa of the
+ number. */
+ STRING_TYPE *endp;
+ unsigned long long int mant;
+
+ mant = STRTOULL (startp + 1, &endp, 0);
+ if (endp == cp)
+ SET_MANTISSA (retval, mant);
+ }
+ }
+
+ if (endptr != NULL)
+ *endptr = (STRING_TYPE *) cp;
+
+ return retval;
+ }
+
+ /* It is really a text we do not recognize. */
+ RETURN (0.0, nptr);
+ }
+
+ /* First look whether we are faced with a hexadecimal number. */
+ if (c == L_('0') && TOLOWER (cp[1]) == L_('x'))
+ {
+ /* Okay, it is a hexa-decimal number. Remember this and skip
+ the characters. BTW: hexadecimal numbers must not be
+ grouped. */
+ base = 16;
+ cp += 2;
+ c = *cp;
+ grouping = NULL;
+ }
+
+ /* Record the start of the digits, in case we will check their grouping. */
+ start_of_digits = startp = cp;
+
+ /* Ignore leading zeroes. This helps us to avoid useless computations. */
+#ifdef USE_WIDE_CHAR
+ while (c == L'0' || ((wint_t) thousands != L'\0' && c == (wint_t) thousands))
+ c = *++cp;
+#else
+ if (thousands == NULL)
+ while (c == '0')
+ c = *++cp;
+ else
+ {
+ /* We also have the multibyte thousands string. */
+ while (1)
+ {
+ if (c != '0')
+ {
+ for (cnt = 0; thousands[cnt] != '\0'; ++cnt)
+ if (c != thousands[cnt])
+ break;
+ if (thousands[cnt] != '\0')
+ break;
+ }
+ c = *++cp;
+ }
+ }
+#endif
+
+ /* If no other digit but a '0' is found the result is 0.0.
+ Return current read pointer. */
+ if ((c < L_('0') || c > L_('9'))
+ && (base == 16 && (c < (CHAR_TYPE) TOLOWER (L_('a'))
+ || c > (CHAR_TYPE) TOLOWER (L_('f'))))
+#ifdef USE_WIDE_CHAR
+ && c != (wint_t) decimal
+#else
+ && ({ for (cnt = 0; decimal[cnt] != '\0'; ++cnt)
+ if (decimal[cnt] != cp[cnt])
+ break;
+ decimal[cnt] != '\0'; })
+#endif
+ && (base == 16 && (cp == start_of_digits
+ || (CHAR_TYPE) TOLOWER (c) != L_('p')))
+ && (base != 16 && (CHAR_TYPE) TOLOWER (c) != L_('e')))
+ {
+#ifdef USE_WIDE_CHAR
+ tp = __correctly_grouped_prefixwc (start_of_digits, cp, thousands,
+ grouping);
+#else
+ tp = __correctly_grouped_prefixmb (start_of_digits, cp, thousands,
+ grouping);
+#endif
+ /* If TP is at the start of the digits, there was no correctly
+ grouped prefix of the string; so no number found. */
+ RETURN (0.0, tp == start_of_digits ? (base == 16 ? cp - 1 : nptr) : tp);
+ }
+
+ /* Remember first significant digit and read following characters until the
+ decimal point, exponent character or any non-FP number character. */
+ startp = cp;
+ dig_no = 0;
+ while (1)
+ {
+ if ((c >= L_('0') && c <= L_('9'))
+ || (base == 16 && (wint_t) TOLOWER (c) >= L_('a')
+ && (wint_t) TOLOWER (c) <= L_('f')))
+ ++dig_no;
+ else
+ {
+#ifdef USE_WIDE_CHAR
+ if ((wint_t) thousands == L'\0' || c != (wint_t) thousands)
+ /* Not a digit or separator: end of the integer part. */
+ break;
+#else
+ if (thousands == NULL)
+ break;
+ else
+ {
+ for (cnt = 0; thousands[cnt] != '\0'; ++cnt)
+ if (thousands[cnt] != cp[cnt])
+ break;
+ if (thousands[cnt] != '\0')
+ break;
+ }
+#endif
+ }
+ c = *++cp;
+ }
+
+ if (grouping && dig_no > 0)
+ {
+ /* Check the grouping of the digits. */
+#ifdef USE_WIDE_CHAR
+ tp = __correctly_grouped_prefixwc (start_of_digits, cp, thousands,
+ grouping);
+#else
+ tp = __correctly_grouped_prefixmb (start_of_digits, cp, thousands,
+ grouping);
+#endif
+ if (cp != tp)
+ {
+ /* Less than the entire string was correctly grouped. */
+
+ if (tp == start_of_digits)
+ /* No valid group of numbers at all: no valid number. */
+ RETURN (0.0, nptr);
+
+ if (tp < startp)
+ /* The number is validly grouped, but consists
+ only of zeroes. The whole value is zero. */
+ RETURN (0.0, tp);
+
+ /* Recompute DIG_NO so we won't read more digits than
+ are properly grouped. */
+ cp = tp;
+ dig_no = 0;
+ for (tp = startp; tp < cp; ++tp)
+ if (*tp >= L_('0') && *tp <= L_('9'))
+ ++dig_no;
+
+ int_no = dig_no;
+ lead_zero = 0;
+
+ goto number_parsed;
+ }
+ }
+
+ /* We have the number digits in the integer part. Whether these are all or
+ any is really a fractional digit will be decided later. */
+ int_no = dig_no;
+ lead_zero = int_no == 0 ? -1 : 0;
+
+ /* Read the fractional digits. A special case are the 'american style'
+ numbers like `16.' i.e. with decimal but without trailing digits. */
+ if (
+#ifdef USE_WIDE_CHAR
+ c == (wint_t) decimal
+#else
+ ({ for (cnt = 0; decimal[cnt] != '\0'; ++cnt)
+ if (decimal[cnt] != cp[cnt])
+ break;
+ decimal[cnt] == '\0'; })
+#endif
+ )
+ {
+ cp += decimal_len;
+ c = *cp;
+ while ((c >= L_('0') && c <= L_('9')) ||
+ (base == 16 && TOLOWER (c) >= L_('a') && TOLOWER (c) <= L_('f')))
+ {
+ if (c != L_('0') && lead_zero == -1)
+ lead_zero = dig_no - int_no;
+ ++dig_no;
+ c = *++cp;
+ }
+ }
+
+ /* Remember start of exponent (if any). */
+ expp = cp;
+
+ /* Read exponent. */
+ if ((base == 16 && TOLOWER (c) == L_('p'))
+ || (base != 16 && TOLOWER (c) == L_('e')))
+ {
+ int exp_negative = 0;
+
+ c = *++cp;
+ if (c == L_('-'))
+ {
+ exp_negative = 1;
+ c = *++cp;
+ }
+ else if (c == L_('+'))
+ c = *++cp;
+
+ if (c >= L_('0') && c <= L_('9'))
+ {
+ int exp_limit;
+
+ /* Get the exponent limit. */
+ if (base == 16)
+ exp_limit = (exp_negative ?
+ -MIN_EXP + MANT_DIG + 4 * int_no :
+ MAX_EXP - 4 * int_no + lead_zero);
+ else
+ exp_limit = (exp_negative ?
+ -MIN_10_EXP + MANT_DIG + int_no :
+ MAX_10_EXP - int_no + lead_zero);
+
+ do
+ {
+ exponent *= 10;
+
+ if (exponent > exp_limit)
+ /* The exponent is too large/small to represent a valid
+ number. */
+ {
+ FLOAT result;
+
+ /* We have to take care for special situation: a joker
+ might have written "0.0e100000" which is in fact
+ zero. */
+ if (lead_zero == -1)
+ result = negative ? -0.0 : 0.0;
+ else
+ {
+ /* Overflow or underflow. */
+ __set_errno (ERANGE);
+ result = (exp_negative ? 0.0 :
+ negative ? -FLOAT_HUGE_VAL : FLOAT_HUGE_VAL);
+ }
+
+ /* Accept all following digits as part of the exponent. */
+ do
+ ++cp;
+ while (*cp >= L_('0') && *cp <= L_('9'));
+
+ RETURN (result, cp);
+ /* NOTREACHED */
+ }
+
+ exponent += c - L_('0');
+ c = *++cp;
+ }
+ while (c >= L_('0') && c <= L_('9'));
+
+ if (exp_negative)
+ exponent = -exponent;
+ }
+ else
+ cp = expp;
+ }
+
+ /* We don't want to have to work with trailing zeroes after the radix. */
+ if (dig_no > int_no)
+ {
+ while (expp[-1] == L_('0'))
+ {
+ --expp;
+ --dig_no;
+ }
+ assert (dig_no >= int_no);
+ }
+
+ if (dig_no == int_no && dig_no > 0 && exponent < 0)
+ do
+ {
+ while (! (base == 16 ? ISXDIGIT (expp[-1]) : ISDIGIT (expp[-1])))
+ --expp;
+
+ if (expp[-1] != L_('0'))
+ break;
+
+ --expp;
+ --dig_no;
+ --int_no;
+ ++exponent;
+ }
+ while (dig_no > 0 && exponent < 0);
+
+ number_parsed:
+
+ /* The whole string is parsed. Store the address of the next character. */
+ if (endptr)
+ *endptr = (STRING_TYPE *) cp;
+
+ if (dig_no == 0)
+ return negative ? -0.0 : 0.0;
+
+ if (lead_zero)
+ {
+ /* Find the decimal point */
+#ifdef USE_WIDE_CHAR
+ while (*startp != decimal)
+ ++startp;
+#else
+ while (1)
+ {
+ if (*startp == decimal[0])
+ {
+ for (cnt = 1; decimal[cnt] != '\0'; ++cnt)
+ if (decimal[cnt] != startp[cnt])
+ break;
+ if (decimal[cnt] == '\0')
+ break;
+ }
+ ++startp;
+ }
+#endif
+ startp += lead_zero + decimal_len;
+ exponent -= base == 16 ? 4 * lead_zero : lead_zero;
+ dig_no -= lead_zero;
+ }
+
+ /* If the BASE is 16 we can use a simpler algorithm. */
+ if (base == 16)
+ {
+ static const int nbits[16] = { 0, 1, 2, 2, 3, 3, 3, 3,
+ 4, 4, 4, 4, 4, 4, 4, 4 };
+ int idx = (MANT_DIG - 1) / BITS_PER_MP_LIMB;
+ int pos = (MANT_DIG - 1) % BITS_PER_MP_LIMB;
+ mp_limb_t val;
+
+ while (!ISXDIGIT (*startp))
+ ++startp;
+ while (*startp == L_('0'))
+ ++startp;
+ if (ISDIGIT (*startp))
+ val = *startp++ - L_('0');
+ else
+ val = 10 + TOLOWER (*startp++) - L_('a');
+ bits = nbits[val];
+ /* We cannot have a leading zero. */
+ assert (bits != 0);
+
+ if (pos + 1 >= 4 || pos + 1 >= bits)
+ {
+ /* We don't have to care for wrapping. This is the normal
+ case so we add the first clause in the `if' expression as
+ an optimization. It is a compile-time constant and so does
+ not cost anything. */
+ retval[idx] = val << (pos - bits + 1);
+ pos -= bits;
+ }
+ else
+ {
+ retval[idx--] = val >> (bits - pos - 1);
+ retval[idx] = val << (BITS_PER_MP_LIMB - (bits - pos - 1));
+ pos = BITS_PER_MP_LIMB - 1 - (bits - pos - 1);
+ }
+
+ /* Adjust the exponent for the bits we are shifting in. */
+ exponent += bits - 1 + (int_no - 1) * 4;
+
+ while (--dig_no > 0 && idx >= 0)
+ {
+ if (!ISXDIGIT (*startp))
+ startp += decimal_len;
+ if (ISDIGIT (*startp))
+ val = *startp++ - L_('0');
+ else
+ val = 10 + TOLOWER (*startp++) - L_('a');
+
+ if (pos + 1 >= 4)
+ {
+ retval[idx] |= val << (pos - 4 + 1);
+ pos -= 4;
+ }
+ else
+ {
+ retval[idx--] |= val >> (4 - pos - 1);
+ val <<= BITS_PER_MP_LIMB - (4 - pos - 1);
+ if (idx < 0)
+ return round_and_return (retval, exponent, negative, val,
+ BITS_PER_MP_LIMB - 1, dig_no > 0);
+
+ retval[idx] = val;
+ pos = BITS_PER_MP_LIMB - 1 - (4 - pos - 1);
+ }
+ }
+
+ /* We ran out of digits. */
+ MPN_ZERO (retval, idx);
+
+ return round_and_return (retval, exponent, negative, 0, 0, 0);
+ }
+
+ /* Now we have the number of digits in total and the integer digits as well
+ as the exponent and its sign. We can decide whether the read digits are
+ really integer digits or belong to the fractional part; i.e. we normalize
+ 123e-2 to 1.23. */
+ {
+ register int incr = (exponent < 0 ? MAX (-int_no, exponent)
+ : MIN (dig_no - int_no, exponent));
+ int_no += incr;
+ exponent -= incr;
+ }
+
+ if (int_no + exponent > MAX_10_EXP + 1)
+ {
+ __set_errno (ERANGE);
+ return negative ? -FLOAT_HUGE_VAL : FLOAT_HUGE_VAL;
+ }
+
+ if (exponent < MIN_10_EXP - (DIG + 1))
+ {
+ __set_errno (ERANGE);
+ return 0.0;
+ }
+
+ if (int_no > 0)
+ {
+ /* Read the integer part as a multi-precision number to NUM. */
+ startp = str_to_mpn (startp, int_no, num, &numsize, &exponent
+#ifndef USE_WIDE_CHAR
+ , decimal, decimal_len, thousands
+#endif
+ );
+
+ if (exponent > 0)
+ {
+ /* We now multiply the gained number by the given power of ten. */
+ mp_limb_t *psrc = num;
+ mp_limb_t *pdest = den;
+ int expbit = 1;
+ const struct mp_power *ttab = &_fpioconst_pow10[0];
+
+ do
+ {
+ if ((exponent & expbit) != 0)
+ {
+ size_t size = ttab->arraysize - _FPIO_CONST_OFFSET;
+ mp_limb_t cy;
+ exponent ^= expbit;
+
+ /* FIXME: not the whole multiplication has to be
+ done. If we have the needed number of bits we
+ only need the information whether more non-zero
+ bits follow. */
+ if (numsize >= ttab->arraysize - _FPIO_CONST_OFFSET)
+ cy = __mpn_mul (pdest, psrc, numsize,
+ &__tens[ttab->arrayoff
+ + _FPIO_CONST_OFFSET],
+ size);
+ else
+ cy = __mpn_mul (pdest, &__tens[ttab->arrayoff
+ + _FPIO_CONST_OFFSET],
+ size, psrc, numsize);
+ numsize += size;
+ if (cy == 0)
+ --numsize;
+ (void) SWAP (psrc, pdest);
+ }
+ expbit <<= 1;
+ ++ttab;
+ }
+ while (exponent != 0);
+
+ if (psrc == den)
+ memcpy (num, den, numsize * sizeof (mp_limb_t));
+ }
+
+ /* Determine how many bits of the result we already have. */
+ count_leading_zeros (bits, num[numsize - 1]);
+ bits = numsize * BITS_PER_MP_LIMB - bits;
+
+ /* Now we know the exponent of the number in base two.
+ Check it against the maximum possible exponent. */
+ if (bits > MAX_EXP)
+ {
+ __set_errno (ERANGE);
+ return negative ? -FLOAT_HUGE_VAL : FLOAT_HUGE_VAL;
+ }
+
+ /* We have already the first BITS bits of the result. Together with
+ the information whether more non-zero bits follow this is enough
+ to determine the result. */
+ if (bits > MANT_DIG)
+ {
+ int i;
+ const mp_size_t least_idx = (bits - MANT_DIG) / BITS_PER_MP_LIMB;
+ const mp_size_t least_bit = (bits - MANT_DIG) % BITS_PER_MP_LIMB;
+ const mp_size_t round_idx = least_bit == 0 ? least_idx - 1
+ : least_idx;
+ const mp_size_t round_bit = least_bit == 0 ? BITS_PER_MP_LIMB - 1
+ : least_bit - 1;
+
+ if (least_bit == 0)
+ memcpy (retval, &num[least_idx],
+ RETURN_LIMB_SIZE * sizeof (mp_limb_t));
+ else
+ {
+ for (i = least_idx; i < numsize - 1; ++i)
+ retval[i - least_idx] = (num[i] >> least_bit)
+ | (num[i + 1]
+ << (BITS_PER_MP_LIMB - least_bit));
+ if (i - least_idx < RETURN_LIMB_SIZE)
+ retval[RETURN_LIMB_SIZE - 1] = num[i] >> least_bit;
+ }
+
+ /* Check whether any limb beside the ones in RETVAL are non-zero. */
+ for (i = 0; num[i] == 0; ++i)
+ ;
+
+ return round_and_return (retval, bits - 1, negative,
+ num[round_idx], round_bit,
+ int_no < dig_no || i < round_idx);
+ /* NOTREACHED */
+ }
+ else if (dig_no == int_no)
+ {
+ const mp_size_t target_bit = (MANT_DIG - 1) % BITS_PER_MP_LIMB;
+ const mp_size_t is_bit = (bits - 1) % BITS_PER_MP_LIMB;
+
+ if (target_bit == is_bit)
+ {
+ memcpy (&retval[RETURN_LIMB_SIZE - numsize], num,
+ numsize * sizeof (mp_limb_t));
+ /* FIXME: the following loop can be avoided if we assume a
+ maximal MANT_DIG value. */
+ MPN_ZERO (retval, RETURN_LIMB_SIZE - numsize);
+ }
+ else if (target_bit > is_bit)
+ {
+ (void) __mpn_lshift (&retval[RETURN_LIMB_SIZE - numsize],
+ num, numsize, target_bit - is_bit);
+ /* FIXME: the following loop can be avoided if we assume a
+ maximal MANT_DIG value. */
+ MPN_ZERO (retval, RETURN_LIMB_SIZE - numsize);
+ }
+ else
+ {
+ mp_limb_t cy;
+ assert (numsize < RETURN_LIMB_SIZE);
+
+ cy = __mpn_rshift (&retval[RETURN_LIMB_SIZE - numsize],
+ num, numsize, is_bit - target_bit);
+ retval[RETURN_LIMB_SIZE - numsize - 1] = cy;
+ /* FIXME: the following loop can be avoided if we assume a
+ maximal MANT_DIG value. */
+ MPN_ZERO (retval, RETURN_LIMB_SIZE - numsize - 1);
+ }
+
+ return round_and_return (retval, bits - 1, negative, 0, 0, 0);
+ /* NOTREACHED */
+ }
+
+ /* Store the bits we already have. */
+ memcpy (retval, num, numsize * sizeof (mp_limb_t));
+#if RETURN_LIMB_SIZE > 1
+ if (numsize < RETURN_LIMB_SIZE)
+ retval[numsize] = 0;
+#endif
+ }
+
+ /* We have to compute at least some of the fractional digits. */
+ {
+ /* We construct a fraction and the result of the division gives us
+ the needed digits. The denominator is 1.0 multiplied by the
+ exponent of the lowest digit; i.e. 0.123 gives 123 / 1000 and
+ 123e-6 gives 123 / 1000000. */
+
+ int expbit;
+ int neg_exp;
+ int more_bits;
+ mp_limb_t cy;
+ mp_limb_t *psrc = den;
+ mp_limb_t *pdest = num;
+ const struct mp_power *ttab = &_fpioconst_pow10[0];
+
+ assert (dig_no > int_no && exponent <= 0);
+
+
+ /* For the fractional part we need not process too many digits. One
+ decimal digits gives us log_2(10) ~ 3.32 bits. If we now compute
+ ceil(BITS / 3) =: N
+ digits we should have enough bits for the result. The remaining
+ decimal digits give us the information that more bits are following.
+ This can be used while rounding. (Two added as a safety margin.) */
+ if (dig_no - int_no > (MANT_DIG - bits + 2) / 3 + 2)
+ {
+ dig_no = int_no + (MANT_DIG - bits + 2) / 3 + 2;
+ more_bits = 1;
+ }
+ else
+ more_bits = 0;
+
+ neg_exp = dig_no - int_no - exponent;
+
+ /* Construct the denominator. */
+ densize = 0;
+ expbit = 1;
+ do
+ {
+ if ((neg_exp & expbit) != 0)
+ {
+ mp_limb_t cy;
+ neg_exp ^= expbit;
+
+ if (densize == 0)
+ {
+ densize = ttab->arraysize - _FPIO_CONST_OFFSET;
+ memcpy (psrc, &__tens[ttab->arrayoff + _FPIO_CONST_OFFSET],
+ densize * sizeof (mp_limb_t));
+ }
+ else
+ {
+ cy = __mpn_mul (pdest, &__tens[ttab->arrayoff
+ + _FPIO_CONST_OFFSET],
+ ttab->arraysize - _FPIO_CONST_OFFSET,
+ psrc, densize);
+ densize += ttab->arraysize - _FPIO_CONST_OFFSET;
+ if (cy == 0)
+ --densize;
+ (void) SWAP (psrc, pdest);
+ }
+ }
+ expbit <<= 1;
+ ++ttab;
+ }
+ while (neg_exp != 0);
+
+ if (psrc == num)
+ memcpy (den, num, densize * sizeof (mp_limb_t));
+
+ /* Read the fractional digits from the string. */
+ (void) str_to_mpn (startp, dig_no - int_no, num, &numsize, &exponent
+#ifndef USE_WIDE_CHAR
+ , decimal, decimal_len, thousands
+#endif
+ );
+
+ /* We now have to shift both numbers so that the highest bit in the
+ denominator is set. In the same process we copy the numerator to
+ a high place in the array so that the division constructs the wanted
+ digits. This is done by a "quasi fix point" number representation.
+
+ num: ddddddddddd . 0000000000000000000000
+ |--- m ---|
+ den: ddddddddddd n >= m
+ |--- n ---|
+ */
+
+ count_leading_zeros (cnt, den[densize - 1]);
+
+ if (cnt > 0)
+ {
+ /* Don't call `mpn_shift' with a count of zero since the specification
+ does not allow this. */
+ (void) __mpn_lshift (den, den, densize, cnt);
+ cy = __mpn_lshift (num, num, numsize, cnt);
+ if (cy != 0)
+ num[numsize++] = cy;
+ }
+
+ /* Now we are ready for the division. But it is not necessary to
+ do a full multi-precision division because we only need a small
+ number of bits for the result. So we do not use __mpn_divmod
+ here but instead do the division here by hand and stop whenever
+ the needed number of bits is reached. The code itself comes
+ from the GNU MP Library by Torbj\"orn Granlund. */
+
+ exponent = bits;
+
+ switch (densize)
+ {
+ case 1:
+ {
+ mp_limb_t d, n, quot;
+ int used = 0;
+
+ n = num[0];
+ d = den[0];
+ assert (numsize == 1 && n < d);
+
+ do
+ {
+ udiv_qrnnd (quot, n, n, 0, d);
+
+#define got_limb \
+ if (bits == 0) \
+ { \
+ register int cnt; \
+ if (quot == 0) \
+ cnt = BITS_PER_MP_LIMB; \
+ else \
+ count_leading_zeros (cnt, quot); \
+ exponent -= cnt; \
+ if (BITS_PER_MP_LIMB - cnt > MANT_DIG) \
+ { \
+ used = MANT_DIG + cnt; \
+ retval[0] = quot >> (BITS_PER_MP_LIMB - used); \
+ bits = MANT_DIG + 1; \
+ } \
+ else \
+ { \
+ /* Note that we only clear the second element. */ \
+ /* The conditional is determined at compile time. */ \
+ if (RETURN_LIMB_SIZE > 1) \
+ retval[1] = 0; \
+ retval[0] = quot; \
+ bits = -cnt; \
+ } \
+ } \
+ else if (bits + BITS_PER_MP_LIMB <= MANT_DIG) \
+ __mpn_lshift_1 (retval, RETURN_LIMB_SIZE, BITS_PER_MP_LIMB, \
+ quot); \
+ else \
+ { \
+ used = MANT_DIG - bits; \
+ if (used > 0) \
+ __mpn_lshift_1 (retval, RETURN_LIMB_SIZE, used, quot); \
+ } \
+ bits += BITS_PER_MP_LIMB
+
+ got_limb;
+ }
+ while (bits <= MANT_DIG);
+
+ return round_and_return (retval, exponent - 1, negative,
+ quot, BITS_PER_MP_LIMB - 1 - used,
+ more_bits || n != 0);
+ }
+ case 2:
+ {
+ mp_limb_t d0, d1, n0, n1;
+ mp_limb_t quot = 0;
+ int used = 0;
+
+ d0 = den[0];
+ d1 = den[1];
+
+ if (numsize < densize)
+ {
+ if (num[0] >= d1)
+ {
+ /* The numerator of the number occupies fewer bits than
+ the denominator but the one limb is bigger than the
+ high limb of the numerator. */
+ n1 = 0;
+ n0 = num[0];
+ }
+ else
+ {
+ if (bits <= 0)
+ exponent -= BITS_PER_MP_LIMB;
+ else
+ {
+ if (bits + BITS_PER_MP_LIMB <= MANT_DIG)
+ __mpn_lshift_1 (retval, RETURN_LIMB_SIZE,
+ BITS_PER_MP_LIMB, 0);
+ else
+ {
+ used = MANT_DIG - bits;
+ if (used > 0)
+ __mpn_lshift_1 (retval, RETURN_LIMB_SIZE, used, 0);
+ }
+ bits += BITS_PER_MP_LIMB;
+ }
+ n1 = num[0];
+ n0 = 0;
+ }
+ }
+ else
+ {
+ n1 = num[1];
+ n0 = num[0];
+ }
+
+ while (bits <= MANT_DIG)
+ {
+ mp_limb_t r;
+
+ if (n1 == d1)
+ {
+ /* QUOT should be either 111..111 or 111..110. We need
+ special treatment of this rare case as normal division
+ would give overflow. */
+ quot = ~(mp_limb_t) 0;
+
+ r = n0 + d1;
+ if (r < d1) /* Carry in the addition? */
+ {
+ add_ssaaaa (n1, n0, r - d0, 0, 0, d0);
+ goto have_quot;
+ }
+ n1 = d0 - (d0 != 0);
+ n0 = -d0;
+ }
+ else
+ {
+ udiv_qrnnd (quot, r, n1, n0, d1);
+ umul_ppmm (n1, n0, d0, quot);
+ }
+
+ q_test:
+ if (n1 > r || (n1 == r && n0 > 0))
+ {
+ /* The estimated QUOT was too large. */
+ --quot;
+
+ sub_ddmmss (n1, n0, n1, n0, 0, d0);
+ r += d1;
+ if (r >= d1) /* If not carry, test QUOT again. */
+ goto q_test;
+ }
+ sub_ddmmss (n1, n0, r, 0, n1, n0);
+
+ have_quot:
+ got_limb;
+ }
+
+ return round_and_return (retval, exponent - 1, negative,
+ quot, BITS_PER_MP_LIMB - 1 - used,
+ more_bits || n1 != 0 || n0 != 0);
+ }
+ default:
+ {
+ int i;
+ mp_limb_t cy, dX, d1, n0, n1;
+ mp_limb_t quot = 0;
+ int used = 0;
+
+ dX = den[densize - 1];
+ d1 = den[densize - 2];
+
+ /* The division does not work if the upper limb of the two-limb
+ numerator is greater than the denominator. */
+ if (__mpn_cmp (num, &den[densize - numsize], numsize) > 0)
+ num[numsize++] = 0;
+
+ if (numsize < densize)
+ {
+ mp_size_t empty = densize - numsize;
+
+ if (bits <= 0)
+ {
+ register int i;
+ for (i = numsize; i > 0; --i)
+ num[i + empty] = num[i - 1];
+ MPN_ZERO (num, empty + 1);
+ exponent -= empty * BITS_PER_MP_LIMB;
+ }
+ else
+ {
+ if (bits + empty * BITS_PER_MP_LIMB <= MANT_DIG)
+ {
+ /* We make a difference here because the compiler
+ cannot optimize the `else' case that good and
+ this reflects all currently used FLOAT types
+ and GMP implementations. */
+ register int i;
+#if RETURN_LIMB_SIZE <= 2
+ assert (empty == 1);
+ __mpn_lshift_1 (retval, RETURN_LIMB_SIZE,
+ BITS_PER_MP_LIMB, 0);
+#else
+ for (i = RETURN_LIMB_SIZE; i > empty; --i)
+ retval[i] = retval[i - empty];
+#endif
+ for (i = numsize; i > 0; --i)
+ num[i + empty] = num[i - 1];
+ MPN_ZERO (num, empty + 1);
+ }
+ else
+ {
+ used = MANT_DIG - bits;
+ if (used >= BITS_PER_MP_LIMB)
+ {
+ register int i;
+ (void) __mpn_lshift (&retval[used
+ / BITS_PER_MP_LIMB],
+ retval, RETURN_LIMB_SIZE,
+ used % BITS_PER_MP_LIMB);
+ for (i = used / BITS_PER_MP_LIMB; i >= 0; --i)
+ retval[i] = 0;
+ }
+ else if (used > 0)
+ __mpn_lshift_1 (retval, RETURN_LIMB_SIZE, used, 0);
+ }
+ bits += empty * BITS_PER_MP_LIMB;
+ }
+ }
+ else
+ {
+ int i;
+ assert (numsize == densize);
+ for (i = numsize; i > 0; --i)
+ num[i] = num[i - 1];
+ }
+
+ den[densize] = 0;
+ n0 = num[densize];
+
+ while (bits <= MANT_DIG)
+ {
+ if (n0 == dX)
+ /* This might over-estimate QUOT, but it's probably not
+ worth the extra code here to find out. */
+ quot = ~(mp_limb_t) 0;
+ else
+ {
+ mp_limb_t r;
+
+ udiv_qrnnd (quot, r, n0, num[densize - 1], dX);
+ umul_ppmm (n1, n0, d1, quot);
+
+ while (n1 > r || (n1 == r && n0 > num[densize - 2]))
+ {
+ --quot;
+ r += dX;
+ if (r < dX) /* I.e. "carry in previous addition?" */
+ break;
+ n1 -= n0 < d1;
+ n0 -= d1;
+ }
+ }
+
+ /* Possible optimization: We already have (q * n0) and (1 * n1)
+ after the calculation of QUOT. Taking advantage of this, we
+ could make this loop make two iterations less. */
+
+ cy = __mpn_submul_1 (num, den, densize + 1, quot);
+
+ if (num[densize] != cy)
+ {
+ cy = __mpn_add_n (num, num, den, densize);
+ assert (cy != 0);
+ --quot;
+ }
+ n0 = num[densize] = num[densize - 1];
+ for (i = densize - 1; i > 0; --i)
+ num[i] = num[i - 1];
+
+ got_limb;
+ }
+
+ for (i = densize; num[i] == 0 && i >= 0; --i)
+ ;
+ return round_and_return (retval, exponent - 1, negative,
+ quot, BITS_PER_MP_LIMB - 1 - used,
+ more_bits || i >= 0);
+ }
+ }
+ }
+
+ /* NOTREACHED */
+}
+#if defined _LIBC && !defined USE_WIDE_CHAR
+libc_hidden_def (INTERNAL (__STRTOF))
+#endif
+\f
+/* External user entry point. */
-weak_alias (__strtod_l, strtod_l)
+FLOAT
+#ifdef weak_function
+weak_function
+#endif
+__STRTOF (nptr, endptr, loc)
+ const STRING_TYPE *nptr;
+ STRING_TYPE **endptr;
+ __locale_t loc;
+{
+ return INTERNAL (__STRTOF) (nptr, endptr, 0, loc);
+}
+weak_alias (__STRTOF, STRTOF)
+/* Read decimal floating point numbers.
+ This file is part of the GNU C Library.
+ Copyright (C) 1995-2002, 2003, 2004 Free Software Foundation, Inc.
+ Contributed by Ulrich Drepper <drepper@gnu.org>, 1995.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
/* The actual implementation for all floating point sizes is in strtod.c.
These macros tell it to produce the `float' version, `strtof'. */
#define FLOAT float
#define FLT FLT
-#ifdef USE_IN_EXTENDED_LOCALE_MODEL
-# define STRTOF __strtof_l
+#ifdef USE_WIDE_CHAR
+#define STRTOF wcstof
+#define STRTOF_L __wcstof_l
#else
# define STRTOF strtof
+# define STRTOF_L __strtof_l
#endif
-#define MPN2FLOAT __mpn_construct_float
-#define FLOAT_HUGE_VAL HUGE_VALF
-#define SET_MANTISSA(flt, mant) \
- do { union ieee754_float u; \
- u.f = (flt); \
- if ((mant & 0x7fffff) == 0) \
- mant = 0x400000; \
- u.ieee.mantissa = (mant) & 0x7fffff; \
- (flt) = u.f; \
- } while (0)
+
#include "strtod.c"
/* Convert string representing a number to float value, using given locale.
- Copyright (C) 1997,98,2002 Free Software Foundation, Inc.
+ Copyright (C) 1997,98,2002, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
-#define USE_IN_EXTENDED_LOCALE_MODEL 1
-
#include <xlocale.h>
extern float ____strtof_l_internal (const char *, char **, int, __locale_t);
extern unsigned long long int ____strtoull_l_internal (const char *, char **,
int, int, __locale_t);
-#include <strtof.c>
-
-weak_alias (__strtof_l, strtof_l)
+#define FLOAT float
+#define FLT FLT
+#ifdef USE_WIDE_CHAR
+# define STRTOF wcstof_l
+# define __STRTOF __wcstof_l
+#else
+# define STRTOF strtof_l
+# define __STRTOF __strtof_l
+#endif
+#define MPN2FLOAT __mpn_construct_float
+#define FLOAT_HUGE_VAL HUGE_VALF
+#define SET_MANTISSA(flt, mant) \
+ do { union ieee754_float u; \
+ u.f = (flt); \
+ if ((mant & 0x7fffff) == 0) \
+ mant = 0x400000; \
+ u.ieee.mantissa = (mant) & 0x7fffff; \
+ (flt) = u.f; \
+ } while (0)
+
+#include "strtod_l.c"
--- /dev/null
+/* Read decimal floating point numbers.
+ This file is part of the GNU C Library.
+ Copyright (C) 1995-2002, 2003, 2004 Free Software Foundation, Inc.
+ Contributed by Ulrich Drepper <drepper@gnu.org>, 1995.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+/* The actual implementation for all floating point sizes is in strtod.c.
+ These macros tell it to produce the `float' version, `strtof'. */
+
+#define FLOAT long double
+#define FLT LDBL
+#ifdef USE_WIDE_CHAR
+# define STRTOF wcstold
+# define STRTOF_L __wcstold_l
+#else
+# define STRTOF strtold
+# define STRTOF_L __strtold_l
+#endif
+
+
+#include "strtod.c"
+++ /dev/null
-/* Convert string representing a number to float value, using given locale.
- Copyright (C) 1997,98,99,2002 Free Software Foundation, Inc.
- This file is part of the GNU C Library.
- Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
-
- The GNU C Library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- The GNU C Library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with the GNU C Library; if not, write to the Free
- Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
- 02111-1307 USA. */
-
-#include <math.h>
-#include <xlocale.h>
-
-#ifndef __NO_LONG_DOUBLE_MATH
-
-#define USE_IN_EXTENDED_LOCALE_MODEL 1
-
-extern long double ____strtold_l_internal (const char *, char **, int,
- __locale_t);
-extern unsigned long long int ____strtoull_l_internal (const char *, char **,
- int, int, __locale_t);
-
-# include <strtold.c>
-
-#else
-/* There is no `long double' type, use the `double' implementations. */
-extern double ____strtod_l_internal (const char *, char **, int,
- __locale_t);
-long double
-____strtold_l_internal (const char *nptr, char **endptr, int group,
- __locale_t loc)
-{
- return ____strtod_l_internal (nptr, endptr, group, loc);
-}
-
-long double
-__strtold_l (const char *nptr, char **endptr, __locale_t loc)
-{
- return ____strtod_l_internal (nptr, endptr, 0, loc);
-}
-#endif
-
-weak_alias (__strtold_l, strtold_l)
-/* Copyright (C) 1995,96,97,98,99,2000,2001,2002 Free Software Foundation, Inc.
+/* Copyright (C) 1995-2002, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Written by Ulrich Drepper <drepper@cygnus.com>, 1995.
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
-#include <assert.h>
-#include <langinfo.h>
-#include <locale.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <stdlib.h>
#include <string.h>
#ifndef STRING_TYPE
# define STRING_TYPE char
-# define USTRING_TYPE unsigned char
-# ifdef USE_IN_EXTENDED_LOCALE_MODEL
-# define STRCOLL __strcoll_l
-# else
-# define STRCOLL strcoll
-# endif
-# define STRCMP strcmp
-# define STRLEN strlen
-# define WEIGHT_H "../locale/weight.h"
-# define SUFFIX MB
-# define L(arg) arg
+# define STRCOLL strcoll
+# define STRCOLL_L __strcoll_l
#endif
-#define CONCAT(a,b) CONCAT1(a,b)
-#define CONCAT1(a,b) a##b
-
#include "../locale/localeinfo.h"
-#ifndef USE_IN_EXTENDED_LOCALE_MODEL
+
int
STRCOLL (s1, s2)
const STRING_TYPE *s1;
const STRING_TYPE *s2;
-#else
-int
-STRCOLL (s1, s2, l)
- const STRING_TYPE *s1;
- const STRING_TYPE *s2;
- __locale_t l;
-#endif
{
-#ifdef USE_IN_EXTENDED_LOCALE_MODEL
- struct locale_data *current = l->__locales[LC_COLLATE];
- uint_fast32_t nrules = current->values[_NL_ITEM_INDEX (_NL_COLLATE_NRULES)].word;
-#else
- uint_fast32_t nrules = _NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES);
-#endif
- /* We don't assign the following values right away since it might be
- unnecessary in case there are no rules. */
- const unsigned char *rulesets;
- const int32_t *table;
- const USTRING_TYPE *weights;
- const USTRING_TYPE *extra;
- const int32_t *indirect;
- uint_fast32_t pass;
- int result = 0;
- const USTRING_TYPE *us1;
- const USTRING_TYPE *us2;
- size_t s1len;
- size_t s2len;
- int32_t *idx1arr;
- int32_t *idx2arr;
- unsigned char *rule1arr;
- unsigned char *rule2arr;
- size_t idx1max;
- size_t idx2max;
- size_t idx1cnt;
- size_t idx2cnt;
- size_t idx1now;
- size_t idx2now;
- size_t backw1_stop;
- size_t backw2_stop;
- size_t backw1;
- size_t backw2;
- int val1;
- int val2;
- int position;
- int seq1len;
- int seq2len;
- int use_malloc;
-
-#include WEIGHT_H
-
- if (nrules == 0)
- return STRCMP (s1, s2);
-
-#ifdef USE_IN_EXTENDED_LOCALE_MODEL
- rulesets = (const unsigned char *)
- current->values[_NL_ITEM_INDEX (_NL_COLLATE_RULESETS)].string;
- table = (const int32_t *)
- current->values[_NL_ITEM_INDEX (CONCAT(_NL_COLLATE_TABLE,SUFFIX))].string;
- weights = (const USTRING_TYPE *)
- current->values[_NL_ITEM_INDEX (CONCAT(_NL_COLLATE_WEIGHT,SUFFIX))].string;
- extra = (const USTRING_TYPE *)
- current->values[_NL_ITEM_INDEX (CONCAT(_NL_COLLATE_EXTRA,SUFFIX))].string;
- indirect = (const int32_t *)
- current->values[_NL_ITEM_INDEX (CONCAT(_NL_COLLATE_INDIRECT,SUFFIX))].string;
-#else
- rulesets = (const unsigned char *)
- _NL_CURRENT (LC_COLLATE, _NL_COLLATE_RULESETS);
- table = (const int32_t *)
- _NL_CURRENT (LC_COLLATE, CONCAT(_NL_COLLATE_TABLE,SUFFIX));
- weights = (const USTRING_TYPE *)
- _NL_CURRENT (LC_COLLATE, CONCAT(_NL_COLLATE_WEIGHT,SUFFIX));
- extra = (const USTRING_TYPE *)
- _NL_CURRENT (LC_COLLATE, CONCAT(_NL_COLLATE_EXTRA,SUFFIX));
- indirect = (const int32_t *)
- _NL_CURRENT (LC_COLLATE, CONCAT(_NL_COLLATE_INDIRECT,SUFFIX));
-#endif
- use_malloc = 0;
-
- assert (((uintptr_t) table) % __alignof__ (table[0]) == 0);
- assert (((uintptr_t) weights) % __alignof__ (weights[0]) == 0);
- assert (((uintptr_t) extra) % __alignof__ (extra[0]) == 0);
- assert (((uintptr_t) indirect) % __alignof__ (indirect[0]) == 0);
-
- /* We need this a few times. */
- s1len = STRLEN (s1);
- s2len = STRLEN (s2);
-
- /* Catch empty strings. */
- if (__builtin_expect (s1len == 0, 0) || __builtin_expect (s2len == 0, 0))
- return (s1len != 0) - (s2len != 0);
-
- /* We need the elements of the strings as unsigned values since they
- are used as indeces. */
- us1 = (const USTRING_TYPE *) s1;
- us2 = (const USTRING_TYPE *) s2;
-
- /* Perform the first pass over the string and while doing this find
- and store the weights for each character. Since we want this to
- be as fast as possible we are using `alloca' to store the temporary
- values. But since there is no limit on the length of the string
- we have to use `malloc' if the string is too long. We should be
- very conservative here.
-
- Please note that the localedef programs makes sure that `position'
- is not used at the first level. */
- if (! __libc_use_alloca (s1len + s2len))
- {
- idx1arr = (int32_t *) malloc ((s1len + s2len) * (sizeof (int32_t) + 1));
- idx2arr = &idx1arr[s1len];
- rule1arr = (unsigned char *) &idx2arr[s2len];
- rule2arr = &rule1arr[s1len];
-
- if (idx1arr == NULL)
- /* No memory. Well, go with the stack then.
-
- XXX Once this implementation is stable we will handle this
- differently. Instead of precomputing the indeces we will
- do this in time. This means, though, that this happens for
- every pass again. */
- goto try_stack;
- use_malloc = 1;
- }
- else
- {
- try_stack:
- idx1arr = (int32_t *) alloca (s1len * sizeof (int32_t));
- idx2arr = (int32_t *) alloca (s2len * sizeof (int32_t));
- rule1arr = (unsigned char *) alloca (s1len);
- rule2arr = (unsigned char *) alloca (s2len);
- }
-
- idx1cnt = 0;
- idx2cnt = 0;
- idx1max = 0;
- idx2max = 0;
- idx1now = 0;
- idx2now = 0;
- backw1_stop = ~0ul;
- backw2_stop = ~0ul;
- backw1 = ~0ul;
- backw2 = ~0ul;
- seq1len = 0;
- seq2len = 0;
- position = rulesets[0] & sort_position;
- while (1)
- {
- val1 = 0;
- val2 = 0;
-
- /* Get the next non-IGNOREd element for string `s1'. */
- if (seq1len == 0)
- do
- {
- ++val1;
-
- if (backw1_stop != ~0ul)
- {
- /* The is something pushed. */
- if (backw1 == backw1_stop)
- {
- /* The last pushed character was handled. Continue
- with forward characters. */
- if (idx1cnt < idx1max)
- idx1now = idx1cnt;
- else
- /* Nothing anymore. The backward sequence ended with
- the last sequence in the string. Note that seq1len
- is still zero. */
- break;
- }
- else
- idx1now = --backw1;
- }
- else
- {
- backw1_stop = idx1max;
-
- while (*us1 != L('\0'))
- {
- int32_t tmp = findidx (&us1);
- rule1arr[idx1max] = tmp >> 24;
- idx1arr[idx1max] = tmp & 0xffffff;
- idx1cnt = idx1max++;
-
- if ((rulesets[rule1arr[idx1cnt] * nrules]
- & sort_backward) == 0)
- /* No more backward characters to push. */
- break;
- ++idx1cnt;
- }
-
- if (backw1_stop >= idx1cnt)
- {
- /* No sequence at all or just one. */
- if (idx1cnt == idx1max || backw1_stop > idx1cnt)
- /* Note that seq1len is still zero. */
- break;
-
- backw1_stop = ~0ul;
- idx1now = idx1cnt;
- }
- else
- /* We pushed backward sequences. */
- idx1now = backw1 = idx1cnt - 1;
- }
- }
- while ((seq1len = weights[idx1arr[idx1now]++]) == 0);
-
- /* And the same for string `s2'. */
- if (seq2len == 0)
- do
- {
- ++val2;
-
- if (backw2_stop != ~0ul)
- {
- /* The is something pushed. */
- if (backw2 == backw2_stop)
- {
- /* The last pushed character was handled. Continue
- with forward characters. */
- if (idx2cnt < idx2max)
- idx2now = idx2cnt;
- else
- /* Nothing anymore. The backward sequence ended with
- the last sequence in the string. Note that seq2len
- is still zero. */
- break;
- }
- else
- idx2now = --backw2;
- }
- else
- {
- backw2_stop = idx2max;
-
- while (*us2 != L('\0'))
- {
- int32_t tmp = findidx (&us2);
- rule2arr[idx2max] = tmp >> 24;
- idx2arr[idx2max] = tmp & 0xffffff;
- idx2cnt = idx2max++;
-
- if ((rulesets[rule2arr[idx2cnt] * nrules]
- & sort_backward) == 0)
- /* No more backward characters to push. */
- break;
- ++idx2cnt;
- }
-
- if (backw2_stop >= idx2cnt)
- {
- /* No sequence at all or just one. */
- if (idx2cnt == idx2max || backw2_stop > idx2cnt)
- /* Note that seq1len is still zero. */
- break;
-
- backw2_stop = ~0ul;
- idx2now = idx2cnt;
- }
- else
- /* We pushed backward sequences. */
- idx2now = backw2 = idx2cnt - 1;
- }
- }
- while ((seq2len = weights[idx2arr[idx2now]++]) == 0);
-
- /* See whether any or both strings are empty. */
- if (seq1len == 0 || seq2len == 0)
- {
- if (seq1len == seq2len)
- /* Both ended. So far so good, both strings are equal at the
- first level. */
- break;
-
- /* This means one string is shorter than the other. Find out
- which one and return an appropriate value. */
- result = seq1len == 0 ? -1 : 1;
- goto free_and_return;
- }
-
- /* Test for position if necessary. */
- if (position && val1 != val2)
- {
- result = val1 - val2;
- goto free_and_return;
- }
-
- /* Compare the two sequences. */
- do
- {
- if (weights[idx1arr[idx1now]] != weights[idx2arr[idx2now]])
- {
- /* The sequences differ. */
- result = weights[idx1arr[idx1now]] - weights[idx2arr[idx2now]];
- goto free_and_return;
- }
-
- /* Increment the offsets. */
- ++idx1arr[idx1now];
- ++idx2arr[idx2now];
-
- --seq1len;
- --seq2len;
- }
- while (seq1len > 0 && seq2len > 0);
-
- if (position && seq1len != seq2len)
- {
- result = seq1len - seq2len;
- goto free_and_return;
- }
- }
-
- /* Now the remaining passes over the weights. We now use the
- indeces we found before. */
- for (pass = 1; pass < nrules; ++pass)
- {
- /* We assume that if a rule has defined `position' in one section
- this is true for all of them. */
- idx1cnt = 0;
- idx2cnt = 0;
- backw1_stop = ~0ul;
- backw2_stop = ~0ul;
- backw1 = ~0ul;
- backw2 = ~0ul;
- position = rulesets[rule1arr[0] * nrules + pass] & sort_position;
-
- while (1)
- {
- val1 = 0;
- val2 = 0;
-
- /* Get the next non-IGNOREd element for string `s1'. */
- if (seq1len == 0)
- do
- {
- ++val1;
-
- if (backw1_stop != ~0ul)
- {
- /* The is something pushed. */
- if (backw1 == backw1_stop)
- {
- /* The last pushed character was handled. Continue
- with forward characters. */
- if (idx1cnt < idx1max)
- idx1now = idx1cnt;
- else
- {
- /* Nothing anymore. The backward sequence
- ended with the last sequence in the string. */
- idx1now = ~0ul;
- break;
- }
- }
- else
- idx1now = --backw1;
- }
- else
- {
- backw1_stop = idx1cnt;
-
- while (idx1cnt < idx1max)
- {
- if ((rulesets[rule1arr[idx1cnt] * nrules + pass]
- & sort_backward) == 0)
- /* No more backward characters to push. */
- break;
- ++idx1cnt;
- }
-
- if (backw1_stop == idx1cnt)
- {
- /* No sequence at all or just one. */
- if (idx1cnt == idx1max)
- /* Note that seq1len is still zero. */
- break;
-
- backw1_stop = ~0ul;
- idx1now = idx1cnt++;
- }
- else
- /* We pushed backward sequences. */
- idx1now = backw1 = idx1cnt - 1;
- }
- }
- while ((seq1len = weights[idx1arr[idx1now]++]) == 0);
-
- /* And the same for string `s2'. */
- if (seq2len == 0)
- do
- {
- ++val2;
-
- if (backw2_stop != ~0ul)
- {
- /* The is something pushed. */
- if (backw2 == backw2_stop)
- {
- /* The last pushed character was handled. Continue
- with forward characters. */
- if (idx2cnt < idx2max)
- idx2now = idx2cnt;
- else
- {
- /* Nothing anymore. The backward sequence
- ended with the last sequence in the string. */
- idx2now = ~0ul;
- break;
- }
- }
- else
- idx2now = --backw2;
- }
- else
- {
- backw2_stop = idx2cnt;
-
- while (idx2cnt < idx2max)
- {
- if ((rulesets[rule2arr[idx2cnt] * nrules + pass]
- & sort_backward) == 0)
- /* No more backward characters to push. */
- break;
- ++idx2cnt;
- }
-
- if (backw2_stop == idx2cnt)
- {
- /* No sequence at all or just one. */
- if (idx2cnt == idx2max)
- /* Note that seq2len is still zero. */
- break;
-
- backw2_stop = ~0ul;
- idx2now = idx2cnt++;
- }
- else
- /* We pushed backward sequences. */
- idx2now = backw2 = idx2cnt - 1;
- }
- }
- while ((seq2len = weights[idx2arr[idx2now]++]) == 0);
-
- /* See whether any or both strings are empty. */
- if (seq1len == 0 || seq2len == 0)
- {
- if (seq1len == seq2len)
- /* Both ended. So far so good, both strings are equal
- at this level. */
- break;
-
- /* This means one string is shorter than the other. Find out
- which one and return an appropriate value. */
- result = seq1len == 0 ? -1 : 1;
- goto free_and_return;
- }
-
- /* Test for position if necessary. */
- if (position && val1 != val2)
- {
- result = val1 - val2;
- goto free_and_return;
- }
-
- /* Compare the two sequences. */
- do
- {
- if (weights[idx1arr[idx1now]] != weights[idx2arr[idx2now]])
- {
- /* The sequences differ. */
- result = (weights[idx1arr[idx1now]]
- - weights[idx2arr[idx2now]]);
- goto free_and_return;
- }
-
- /* Increment the offsets. */
- ++idx1arr[idx1now];
- ++idx2arr[idx2now];
-
- --seq1len;
- --seq2len;
- }
- while (seq1len > 0 && seq2len > 0);
-
- if (position && seq1len != seq2len)
- {
- result = seq1len - seq2len;
- goto free_and_return;
- }
- }
- }
-
- /* Free the memory if needed. */
- free_and_return:
- if (use_malloc)
- free (idx1arr);
-
- return result;
+ return STRCOLL_L (s1, s2, _NL_CURRENT_LOCALE);
}
-#if !defined WIDE_CHAR_VERSION && !defined USE_IN_EXTENDED_LOCALE_MODEL
+#if !defined WIDE_CHAR_VERSION
libc_hidden_def (strcoll)
#endif
-/* Copyright (C) 1995,96,97,2002 Free Software Foundation, Inc.
+/* Copyright (C) 1995,96,97,2002, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Written by Ulrich Drepper <drepper@gnu.org>, 1995.
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
-#define USE_IN_EXTENDED_LOCALE_MODEL 1
-#include <strcoll.c>
+#include <assert.h>
+#include <langinfo.h>
+#include <locale.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifndef STRING_TYPE
+# define STRING_TYPE char
+# define USTRING_TYPE unsigned char
+# define STRCOLL __strcoll_l
+# define STRCMP strcmp
+# define STRLEN strlen
+# define WEIGHT_H "../locale/weight.h"
+# define SUFFIX MB
+# define L(arg) arg
+#endif
+
+#define CONCAT(a,b) CONCAT1(a,b)
+#define CONCAT1(a,b) a##b
+
+#include "../locale/localeinfo.h"
+
+int
+STRCOLL (s1, s2, l)
+ const STRING_TYPE *s1;
+ const STRING_TYPE *s2;
+ __locale_t l;
+{
+ struct locale_data *current = l->__locales[LC_COLLATE];
+ uint_fast32_t nrules = current->values[_NL_ITEM_INDEX (_NL_COLLATE_NRULES)].word;
+ /* We don't assign the following values right away since it might be
+ unnecessary in case there are no rules. */
+ const unsigned char *rulesets;
+ const int32_t *table;
+ const USTRING_TYPE *weights;
+ const USTRING_TYPE *extra;
+ const int32_t *indirect;
+ uint_fast32_t pass;
+ int result = 0;
+ const USTRING_TYPE *us1;
+ const USTRING_TYPE *us2;
+ size_t s1len;
+ size_t s2len;
+ int32_t *idx1arr;
+ int32_t *idx2arr;
+ unsigned char *rule1arr;
+ unsigned char *rule2arr;
+ size_t idx1max;
+ size_t idx2max;
+ size_t idx1cnt;
+ size_t idx2cnt;
+ size_t idx1now;
+ size_t idx2now;
+ size_t backw1_stop;
+ size_t backw2_stop;
+ size_t backw1;
+ size_t backw2;
+ int val1;
+ int val2;
+ int position;
+ int seq1len;
+ int seq2len;
+ int use_malloc;
+
+#include WEIGHT_H
+
+ if (nrules == 0)
+ return STRCMP (s1, s2);
+
+ rulesets = (const unsigned char *)
+ current->values[_NL_ITEM_INDEX (_NL_COLLATE_RULESETS)].string;
+ table = (const int32_t *)
+ current->values[_NL_ITEM_INDEX (CONCAT(_NL_COLLATE_TABLE,SUFFIX))].string;
+ weights = (const USTRING_TYPE *)
+ current->values[_NL_ITEM_INDEX (CONCAT(_NL_COLLATE_WEIGHT,SUFFIX))].string;
+ extra = (const USTRING_TYPE *)
+ current->values[_NL_ITEM_INDEX (CONCAT(_NL_COLLATE_EXTRA,SUFFIX))].string;
+ indirect = (const int32_t *)
+ current->values[_NL_ITEM_INDEX (CONCAT(_NL_COLLATE_INDIRECT,SUFFIX))].string;
+ use_malloc = 0;
+
+ assert (((uintptr_t) table) % __alignof__ (table[0]) == 0);
+ assert (((uintptr_t) weights) % __alignof__ (weights[0]) == 0);
+ assert (((uintptr_t) extra) % __alignof__ (extra[0]) == 0);
+ assert (((uintptr_t) indirect) % __alignof__ (indirect[0]) == 0);
+
+ /* We need this a few times. */
+ s1len = STRLEN (s1);
+ s2len = STRLEN (s2);
+
+ /* Catch empty strings. */
+ if (__builtin_expect (s1len == 0, 0) || __builtin_expect (s2len == 0, 0))
+ return (s1len != 0) - (s2len != 0);
+
+ /* We need the elements of the strings as unsigned values since they
+ are used as indeces. */
+ us1 = (const USTRING_TYPE *) s1;
+ us2 = (const USTRING_TYPE *) s2;
+
+ /* Perform the first pass over the string and while doing this find
+ and store the weights for each character. Since we want this to
+ be as fast as possible we are using `alloca' to store the temporary
+ values. But since there is no limit on the length of the string
+ we have to use `malloc' if the string is too long. We should be
+ very conservative here.
+
+ Please note that the localedef programs makes sure that `position'
+ is not used at the first level. */
+ if (! __libc_use_alloca (s1len + s2len))
+ {
+ idx1arr = (int32_t *) malloc ((s1len + s2len) * (sizeof (int32_t) + 1));
+ idx2arr = &idx1arr[s1len];
+ rule1arr = (unsigned char *) &idx2arr[s2len];
+ rule2arr = &rule1arr[s1len];
+
+ if (idx1arr == NULL)
+ /* No memory. Well, go with the stack then.
+
+ XXX Once this implementation is stable we will handle this
+ differently. Instead of precomputing the indeces we will
+ do this in time. This means, though, that this happens for
+ every pass again. */
+ goto try_stack;
+ use_malloc = 1;
+ }
+ else
+ {
+ try_stack:
+ idx1arr = (int32_t *) alloca (s1len * sizeof (int32_t));
+ idx2arr = (int32_t *) alloca (s2len * sizeof (int32_t));
+ rule1arr = (unsigned char *) alloca (s1len);
+ rule2arr = (unsigned char *) alloca (s2len);
+ }
+
+ idx1cnt = 0;
+ idx2cnt = 0;
+ idx1max = 0;
+ idx2max = 0;
+ idx1now = 0;
+ idx2now = 0;
+ backw1_stop = ~0ul;
+ backw2_stop = ~0ul;
+ backw1 = ~0ul;
+ backw2 = ~0ul;
+ seq1len = 0;
+ seq2len = 0;
+ position = rulesets[0] & sort_position;
+ while (1)
+ {
+ val1 = 0;
+ val2 = 0;
+
+ /* Get the next non-IGNOREd element for string `s1'. */
+ if (seq1len == 0)
+ do
+ {
+ ++val1;
+
+ if (backw1_stop != ~0ul)
+ {
+ /* The is something pushed. */
+ if (backw1 == backw1_stop)
+ {
+ /* The last pushed character was handled. Continue
+ with forward characters. */
+ if (idx1cnt < idx1max)
+ idx1now = idx1cnt;
+ else
+ /* Nothing anymore. The backward sequence ended with
+ the last sequence in the string. Note that seq1len
+ is still zero. */
+ break;
+ }
+ else
+ idx1now = --backw1;
+ }
+ else
+ {
+ backw1_stop = idx1max;
+
+ while (*us1 != L('\0'))
+ {
+ int32_t tmp = findidx (&us1);
+ rule1arr[idx1max] = tmp >> 24;
+ idx1arr[idx1max] = tmp & 0xffffff;
+ idx1cnt = idx1max++;
+
+ if ((rulesets[rule1arr[idx1cnt] * nrules]
+ & sort_backward) == 0)
+ /* No more backward characters to push. */
+ break;
+ ++idx1cnt;
+ }
+
+ if (backw1_stop >= idx1cnt)
+ {
+ /* No sequence at all or just one. */
+ if (idx1cnt == idx1max || backw1_stop > idx1cnt)
+ /* Note that seq1len is still zero. */
+ break;
+
+ backw1_stop = ~0ul;
+ idx1now = idx1cnt;
+ }
+ else
+ /* We pushed backward sequences. */
+ idx1now = backw1 = idx1cnt - 1;
+ }
+ }
+ while ((seq1len = weights[idx1arr[idx1now]++]) == 0);
+
+ /* And the same for string `s2'. */
+ if (seq2len == 0)
+ do
+ {
+ ++val2;
+
+ if (backw2_stop != ~0ul)
+ {
+ /* The is something pushed. */
+ if (backw2 == backw2_stop)
+ {
+ /* The last pushed character was handled. Continue
+ with forward characters. */
+ if (idx2cnt < idx2max)
+ idx2now = idx2cnt;
+ else
+ /* Nothing anymore. The backward sequence ended with
+ the last sequence in the string. Note that seq2len
+ is still zero. */
+ break;
+ }
+ else
+ idx2now = --backw2;
+ }
+ else
+ {
+ backw2_stop = idx2max;
+
+ while (*us2 != L('\0'))
+ {
+ int32_t tmp = findidx (&us2);
+ rule2arr[idx2max] = tmp >> 24;
+ idx2arr[idx2max] = tmp & 0xffffff;
+ idx2cnt = idx2max++;
+
+ if ((rulesets[rule2arr[idx2cnt] * nrules]
+ & sort_backward) == 0)
+ /* No more backward characters to push. */
+ break;
+ ++idx2cnt;
+ }
+
+ if (backw2_stop >= idx2cnt)
+ {
+ /* No sequence at all or just one. */
+ if (idx2cnt == idx2max || backw2_stop > idx2cnt)
+ /* Note that seq1len is still zero. */
+ break;
+
+ backw2_stop = ~0ul;
+ idx2now = idx2cnt;
+ }
+ else
+ /* We pushed backward sequences. */
+ idx2now = backw2 = idx2cnt - 1;
+ }
+ }
+ while ((seq2len = weights[idx2arr[idx2now]++]) == 0);
+
+ /* See whether any or both strings are empty. */
+ if (seq1len == 0 || seq2len == 0)
+ {
+ if (seq1len == seq2len)
+ /* Both ended. So far so good, both strings are equal at the
+ first level. */
+ break;
+
+ /* This means one string is shorter than the other. Find out
+ which one and return an appropriate value. */
+ result = seq1len == 0 ? -1 : 1;
+ goto free_and_return;
+ }
+
+ /* Test for position if necessary. */
+ if (position && val1 != val2)
+ {
+ result = val1 - val2;
+ goto free_and_return;
+ }
+
+ /* Compare the two sequences. */
+ do
+ {
+ if (weights[idx1arr[idx1now]] != weights[idx2arr[idx2now]])
+ {
+ /* The sequences differ. */
+ result = weights[idx1arr[idx1now]] - weights[idx2arr[idx2now]];
+ goto free_and_return;
+ }
+
+ /* Increment the offsets. */
+ ++idx1arr[idx1now];
+ ++idx2arr[idx2now];
+
+ --seq1len;
+ --seq2len;
+ }
+ while (seq1len > 0 && seq2len > 0);
+
+ if (position && seq1len != seq2len)
+ {
+ result = seq1len - seq2len;
+ goto free_and_return;
+ }
+ }
+
+ /* Now the remaining passes over the weights. We now use the
+ indeces we found before. */
+ for (pass = 1; pass < nrules; ++pass)
+ {
+ /* We assume that if a rule has defined `position' in one section
+ this is true for all of them. */
+ idx1cnt = 0;
+ idx2cnt = 0;
+ backw1_stop = ~0ul;
+ backw2_stop = ~0ul;
+ backw1 = ~0ul;
+ backw2 = ~0ul;
+ position = rulesets[rule1arr[0] * nrules + pass] & sort_position;
+
+ while (1)
+ {
+ val1 = 0;
+ val2 = 0;
+
+ /* Get the next non-IGNOREd element for string `s1'. */
+ if (seq1len == 0)
+ do
+ {
+ ++val1;
+
+ if (backw1_stop != ~0ul)
+ {
+ /* The is something pushed. */
+ if (backw1 == backw1_stop)
+ {
+ /* The last pushed character was handled. Continue
+ with forward characters. */
+ if (idx1cnt < idx1max)
+ idx1now = idx1cnt;
+ else
+ {
+ /* Nothing anymore. The backward sequence
+ ended with the last sequence in the string. */
+ idx1now = ~0ul;
+ break;
+ }
+ }
+ else
+ idx1now = --backw1;
+ }
+ else
+ {
+ backw1_stop = idx1cnt;
+
+ while (idx1cnt < idx1max)
+ {
+ if ((rulesets[rule1arr[idx1cnt] * nrules + pass]
+ & sort_backward) == 0)
+ /* No more backward characters to push. */
+ break;
+ ++idx1cnt;
+ }
+
+ if (backw1_stop == idx1cnt)
+ {
+ /* No sequence at all or just one. */
+ if (idx1cnt == idx1max)
+ /* Note that seq1len is still zero. */
+ break;
+
+ backw1_stop = ~0ul;
+ idx1now = idx1cnt++;
+ }
+ else
+ /* We pushed backward sequences. */
+ idx1now = backw1 = idx1cnt - 1;
+ }
+ }
+ while ((seq1len = weights[idx1arr[idx1now]++]) == 0);
+
+ /* And the same for string `s2'. */
+ if (seq2len == 0)
+ do
+ {
+ ++val2;
+
+ if (backw2_stop != ~0ul)
+ {
+ /* The is something pushed. */
+ if (backw2 == backw2_stop)
+ {
+ /* The last pushed character was handled. Continue
+ with forward characters. */
+ if (idx2cnt < idx2max)
+ idx2now = idx2cnt;
+ else
+ {
+ /* Nothing anymore. The backward sequence
+ ended with the last sequence in the string. */
+ idx2now = ~0ul;
+ break;
+ }
+ }
+ else
+ idx2now = --backw2;
+ }
+ else
+ {
+ backw2_stop = idx2cnt;
+
+ while (idx2cnt < idx2max)
+ {
+ if ((rulesets[rule2arr[idx2cnt] * nrules + pass]
+ & sort_backward) == 0)
+ /* No more backward characters to push. */
+ break;
+ ++idx2cnt;
+ }
+
+ if (backw2_stop == idx2cnt)
+ {
+ /* No sequence at all or just one. */
+ if (idx2cnt == idx2max)
+ /* Note that seq2len is still zero. */
+ break;
+
+ backw2_stop = ~0ul;
+ idx2now = idx2cnt++;
+ }
+ else
+ /* We pushed backward sequences. */
+ idx2now = backw2 = idx2cnt - 1;
+ }
+ }
+ while ((seq2len = weights[idx2arr[idx2now]++]) == 0);
+
+ /* See whether any or both strings are empty. */
+ if (seq1len == 0 || seq2len == 0)
+ {
+ if (seq1len == seq2len)
+ /* Both ended. So far so good, both strings are equal
+ at this level. */
+ break;
+
+ /* This means one string is shorter than the other. Find out
+ which one and return an appropriate value. */
+ result = seq1len == 0 ? -1 : 1;
+ goto free_and_return;
+ }
+
+ /* Test for position if necessary. */
+ if (position && val1 != val2)
+ {
+ result = val1 - val2;
+ goto free_and_return;
+ }
+
+ /* Compare the two sequences. */
+ do
+ {
+ if (weights[idx1arr[idx1now]] != weights[idx2arr[idx2now]])
+ {
+ /* The sequences differ. */
+ result = (weights[idx1arr[idx1now]]
+ - weights[idx2arr[idx2now]]);
+ goto free_and_return;
+ }
+
+ /* Increment the offsets. */
+ ++idx1arr[idx1now];
+ ++idx2arr[idx2now];
+
+ --seq1len;
+ --seq2len;
+ }
+ while (seq1len > 0 && seq2len > 0);
+
+ if (position && seq1len != seq2len)
+ {
+ result = seq1len - seq2len;
+ goto free_and_return;
+ }
+ }
+ }
+
+ /* Free the memory if needed. */
+ free_and_return:
+ if (use_malloc)
+ free (idx1arr);
+
+ return result;
+}
+libc_hidden_def (STRCOLL)
+
+#ifndef WIDE_CHAR_VERSION
weak_alias (__strcoll_l, strcoll_l)
+#endif
-/* Copyright (C) 1995-1999,2000,2001,2002,2003 Free Software Foundation, Inc.
+/* Copyright (C) 1995-1999,2003, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Written by Ulrich Drepper <drepper@cygnus.com>, 1995.
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
-#include <assert.h>
-#include <langinfo.h>
-#include <locale.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <stdlib.h>
#include <string.h>
-#include <sys/param.h>
+#include <locale/localeinfo.h>
#ifndef STRING_TYPE
# define STRING_TYPE char
-# define USTRING_TYPE unsigned char
-# ifdef USE_IN_EXTENDED_LOCALE_MODEL
-# define STRXFRM __strxfrm_l
-# else
-# define STRXFRM strxfrm
-# endif
-# define STRCMP strcmp
-# define STRLEN strlen
-# define STPNCPY __stpncpy
-# define WEIGHT_H "../locale/weight.h"
-# define SUFFIX MB
-# define L(arg) arg
+# define STRXFRM strxfrm
+# define STRXFRM_L __strxfrm_l
#endif
-#define CONCAT(a,b) CONCAT1(a,b)
-#define CONCAT1(a,b) a##b
-
-#include "../locale/localeinfo.h"
-
-
-#ifndef WIDE_CHAR_VERSION
-
-/* We need UTF-8 encoding of numbers. */
-static int
-utf8_encode (char *buf, int val)
-{
- int retval;
-
- if (val < 0x80)
- {
- *buf++ = (char) val;
- retval = 1;
- }
- else
- {
- int step;
-
- for (step = 2; step < 6; ++step)
- if ((val & (~(uint32_t)0 << (5 * step + 1))) == 0)
- break;
- retval = step;
-
- *buf = (unsigned char) (~0xff >> step);
- --step;
- do
- {
- buf[step] = 0x80 | (val & 0x3f);
- val >>= 6;
- }
- while (--step > 0);
- *buf |= val;
- }
-
- return retval;
-}
-#endif
-
-
-#ifndef USE_IN_EXTENDED_LOCALE_MODEL
size_t
STRXFRM (STRING_TYPE *dest, const STRING_TYPE *src, size_t n)
-#else
-size_t
-STRXFRM (STRING_TYPE *dest, const STRING_TYPE *src, size_t n, __locale_t l)
-#endif
{
-#ifdef USE_IN_EXTENDED_LOCALE_MODEL
- struct locale_data *current = l->__locales[LC_COLLATE];
- uint_fast32_t nrules = current->values[_NL_ITEM_INDEX (_NL_COLLATE_NRULES)].word;
-#else
- uint32_t nrules = _NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES);
-#endif
- /* We don't assign the following values right away since it might be
- unnecessary in case there are no rules. */
- const unsigned char *rulesets;
- const int32_t *table;
- const USTRING_TYPE *weights;
- const USTRING_TYPE *extra;
- const int32_t *indirect;
- uint_fast32_t pass;
- size_t needed;
- const USTRING_TYPE *usrc;
- size_t srclen = STRLEN (src);
- int32_t *idxarr;
- unsigned char *rulearr;
- size_t idxmax;
- size_t idxcnt;
- int use_malloc;
-
-#include WEIGHT_H
-
- if (nrules == 0)
- {
- if (n != 0)
- STPNCPY (dest, src, MIN (srclen + 1, n));
-
- return srclen;
- }
-
-#ifdef USE_IN_EXTENDED_LOCALE_MODEL
- rulesets = (const unsigned char *)
- current->values[_NL_ITEM_INDEX (_NL_COLLATE_RULESETS)].string;
- table = (const int32_t *)
- current->values[_NL_ITEM_INDEX (CONCAT(_NL_COLLATE_TABLE,SUFFIX))].string;
- weights = (const USTRING_TYPE *)
- current->values[_NL_ITEM_INDEX (CONCAT(_NL_COLLATE_WEIGHT,SUFFIX))].string;
- extra = (const USTRING_TYPE *)
- current->values[_NL_ITEM_INDEX (CONCAT(_NL_COLLATE_EXTRA,SUFFIX))].string;
- indirect = (const int32_t *)
- current->values[_NL_ITEM_INDEX (CONCAT(_NL_COLLATE_INDIRECT,SUFFIX))].string;
-#else
- rulesets = (const unsigned char *)
- _NL_CURRENT (LC_COLLATE, _NL_COLLATE_RULESETS);
- table = (const int32_t *)
- _NL_CURRENT (LC_COLLATE, CONCAT(_NL_COLLATE_TABLE,SUFFIX));
- weights = (const USTRING_TYPE *)
- _NL_CURRENT (LC_COLLATE, CONCAT(_NL_COLLATE_WEIGHT,SUFFIX));
- extra = (const USTRING_TYPE *)
- _NL_CURRENT (LC_COLLATE, CONCAT(_NL_COLLATE_EXTRA,SUFFIX));
- indirect = (const int32_t *)
- _NL_CURRENT (LC_COLLATE, CONCAT(_NL_COLLATE_INDIRECT,SUFFIX));
-#endif
- use_malloc = 0;
-
- assert (((uintptr_t) table) % __alignof__ (table[0]) == 0);
- assert (((uintptr_t) weights) % __alignof__ (weights[0]) == 0);
- assert (((uintptr_t) extra) % __alignof__ (extra[0]) == 0);
- assert (((uintptr_t) indirect) % __alignof__ (indirect[0]) == 0);
-
- /* Handle an empty string as a special case. */
- if (srclen == 0)
- {
- if (n != 0)
- *dest = L('\0');
- return 0;
- }
-
- /* We need the elements of the string as unsigned values since they
- are used as indeces. */
- usrc = (const USTRING_TYPE *) src;
-
- /* Perform the first pass over the string and while doing this find
- and store the weights for each character. Since we want this to
- be as fast as possible we are using `alloca' to store the temporary
- values. But since there is no limit on the length of the string
- we have to use `malloc' if the string is too long. We should be
- very conservative here. */
- if (! __libc_use_alloca (srclen))
- {
- idxarr = (int32_t *) malloc ((srclen + 1) * (sizeof (int32_t) + 1));
- rulearr = (unsigned char *) &idxarr[srclen];
-
- if (idxarr == NULL)
- /* No memory. Well, go with the stack then.
-
- XXX Once this implementation is stable we will handle this
- differently. Instead of precomputing the indeces we will
- do this in time. This means, though, that this happens for
- every pass again. */
- goto try_stack;
- use_malloc = 1;
- }
- else
- {
- try_stack:
- idxarr = (int32_t *) alloca (srclen * sizeof (int32_t));
- rulearr = (unsigned char *) alloca (srclen + 1);
- }
-
- idxmax = 0;
- do
- {
- int32_t tmp = findidx (&usrc);
- rulearr[idxmax] = tmp >> 24;
- idxarr[idxmax] = tmp & 0xffffff;
-
- ++idxmax;
- }
- while (*usrc != L('\0'));
-
- /* This element is only read, the value never used but to determine
- another value which then is ignored. */
- rulearr[idxmax] = '\0';
-
- /* Now the passes over the weights. We now use the indeces we found
- before. */
- needed = 0;
- for (pass = 0; pass < nrules; ++pass)
- {
- size_t backw_stop = ~0ul;
- int rule = rulesets[rulearr[0] * nrules + pass];
- /* We assume that if a rule has defined `position' in one section
- this is true for all of them. */
- int position = rule & sort_position;
-
- if (position == 0)
- {
- for (idxcnt = 0; idxcnt < idxmax; ++idxcnt)
- {
- if ((rule & sort_forward) != 0)
- {
- size_t len;
-
- if (backw_stop != ~0ul)
- {
- /* Handle the pushed elements now. */
- size_t backw;
-
- for (backw = idxcnt - 1; backw >= backw_stop; --backw)
- {
- len = weights[idxarr[backw]++];
-
- if (needed + len < n)
- while (len-- > 0)
- dest[needed++] = weights[idxarr[backw]++];
- else
- {
- /* No more characters fit into the buffer. */
- needed += len;
- idxarr[backw] += len;
- }
- }
-
- backw_stop = ~0ul;
- }
-
- /* Now handle the forward element. */
- len = weights[idxarr[idxcnt]++];
- if (needed + len < n)
- while (len-- > 0)
- dest[needed++] = weights[idxarr[idxcnt]++];
- else
- {
- /* No more characters fit into the buffer. */
- needed += len;
- idxarr[idxcnt] += len;
- }
- }
- else
- {
- /* Remember where the backwards series started. */
- if (backw_stop == ~0ul)
- backw_stop = idxcnt;
- }
-
- rule = rulesets[rulearr[idxcnt + 1] * nrules + pass];
- }
-
-
- if (backw_stop != ~0ul)
- {
- /* Handle the pushed elements now. */
- size_t backw;
-
- backw = idxcnt;
- while (backw > backw_stop)
- {
- size_t len = weights[idxarr[--backw]++];
-
- if (needed + len < n)
- while (len-- > 0)
- dest[needed++] = weights[idxarr[backw]++];
- else
- {
- /* No more characters fit into the buffer. */
- needed += len;
- idxarr[backw] += len;
- }
- }
- }
- }
- else
- {
- int val = 1;
-#ifndef WIDE_CHAR_VERSION
- char buf[7];
- size_t buflen;
-#endif
- size_t i;
-
- for (idxcnt = 0; idxcnt < idxmax; ++idxcnt)
- {
- if ((rule & sort_forward) != 0)
- {
- size_t len;
-
- if (backw_stop != ~0ul)
- {
- /* Handle the pushed elements now. */
- size_t backw;
-
- for (backw = idxcnt - 1; backw >= backw_stop; --backw)
- {
- len = weights[idxarr[backw]++];
- if (len != 0)
- {
-#ifdef WIDE_CHAR_VERSION
- if (needed + 1 + len < n)
- {
- dest[needed] = val;
- for (i = 0; i < len; ++i)
- dest[needed + 1 + i] =
- weights[idxarr[backw] + i];
- }
- needed += 1 + len;
-#else
- buflen = utf8_encode (buf, val);
- if (needed + buflen + len < n)
- {
- for (i = 0; i < buflen; ++i)
- dest[needed + i] = buf[i];
- for (i = 0; i < len; ++i)
- dest[needed + buflen + i] =
- weights[idxarr[backw] + i];
- }
- needed += buflen + len;
-#endif
- idxarr[backw] += len;
- val = 1;
- }
- else
- ++val;
- }
-
- backw_stop = ~0ul;
- }
-
- /* Now handle the forward element. */
- len = weights[idxarr[idxcnt]++];
- if (len != 0)
- {
-#ifdef WIDE_CHAR_VERSION
- if (needed + 1+ len < n)
- {
- dest[needed] = val;
- for (i = 0; i < len; ++i)
- dest[needed + 1 + i] =
- weights[idxarr[idxcnt] + i];
- }
- needed += 1 + len;
-#else
- buflen = utf8_encode (buf, val);
- if (needed + buflen + len < n)
- {
- for (i = 0; i < buflen; ++i)
- dest[needed + i] = buf[i];
- for (i = 0; i < len; ++i)
- dest[needed + buflen + i] =
- weights[idxarr[idxcnt] + i];
- }
- needed += buflen + len;
-#endif
- idxarr[idxcnt] += len;
- val = 1;
- }
- else
- /* Note that we don't have to increment `idxarr[idxcnt]'
- since the length is zero. */
- ++val;
- }
- else
- {
- /* Remember where the backwards series started. */
- if (backw_stop == ~0ul)
- backw_stop = idxcnt;
- }
-
- rule = rulesets[rulearr[idxcnt + 1] * nrules + pass];
- }
-
- if (backw_stop != ~0ul)
- {
- /* Handle the pushed elements now. */
- size_t backw;
-
- backw = idxmax - 1;
- while (backw > backw_stop)
- {
- size_t len = weights[idxarr[--backw]++];
- if (len != 0)
- {
-#ifdef WIDE_CHAR_VERSION
- if (needed + 1 + len < n)
- {
- dest[needed] = val;
- for (i = 0; i < len; ++i)
- dest[needed + 1 + i] =
- weights[idxarr[backw] + i];
- }
- needed += 1 + len;
-#else
- buflen = utf8_encode (buf, val);
- if (needed + buflen + len < n)
- {
- for (i = 0; i < buflen; ++i)
- dest[needed + i] = buf[i];
- for (i = 0; i < len; ++i)
- dest[needed + buflen + i] =
- weights[idxarr[backw] + i];
- }
- needed += buflen + len;
-#endif
- idxarr[backw] += len;
- val = 1;
- }
- else
- ++val;
- }
- }
- }
-
- /* Finally store the byte to separate the passes or terminate
- the string. */
- if (needed < n)
- dest[needed] = pass + 1 < nrules ? L('\1') : L('\0');
- ++needed;
- }
-
- /* This is a little optimization: many collation specifications have
- a `position' rule at the end and if no non-ignored character
- is found the last \1 byte is immediately followed by a \0 byte
- signalling this. We can avoid the \1 byte(s). */
- if (needed <= n && needed > 2 && dest[needed - 2] == L('\1'))
- {
- /* Remove the \1 byte. */
- --needed;
- dest[needed - 1] = L('\0');
- }
-
- /* Free the memory if needed. */
- if (use_malloc)
- free (idxarr);
-
- /* Return the number of bytes/words we need, but don't count the NUL
- byte/word at the end. */
- return needed - 1;
+ return STRXFRM_L (dest, src, n, _NL_CURRENT_LOCALE);
}
-/* Copyright (C) 1995,96,97,2002 Free Software Foundation, Inc.
+/* Copyright (C) 1995,96,97,2002, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Written by Ulrich Drepper <drepper@gnu.org>, 1995.
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
-#define USE_IN_EXTENDED_LOCALE_MODEL 1
-#include <strxfrm.c>
+#include <assert.h>
+#include <langinfo.h>
+#include <locale.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/param.h>
+#ifndef STRING_TYPE
+# define STRING_TYPE char
+# define USTRING_TYPE unsigned char
+# define STRXFRM __strxfrm_l
+# define STRCMP strcmp
+# define STRLEN strlen
+# define STPNCPY __stpncpy
+# define WEIGHT_H "../locale/weight.h"
+# define SUFFIX MB
+# define L(arg) arg
+#endif
+
+#define CONCAT(a,b) CONCAT1(a,b)
+#define CONCAT1(a,b) a##b
+
+#include "../locale/localeinfo.h"
+
+
+#ifndef WIDE_CHAR_VERSION
+
+/* We need UTF-8 encoding of numbers. */
+static int
+utf8_encode (char *buf, int val)
+{
+ int retval;
+
+ if (val < 0x80)
+ {
+ *buf++ = (char) val;
+ retval = 1;
+ }
+ else
+ {
+ int step;
+
+ for (step = 2; step < 6; ++step)
+ if ((val & (~(uint32_t)0 << (5 * step + 1))) == 0)
+ break;
+ retval = step;
+
+ *buf = (unsigned char) (~0xff >> step);
+ --step;
+ do
+ {
+ buf[step] = 0x80 | (val & 0x3f);
+ val >>= 6;
+ }
+ while (--step > 0);
+ *buf |= val;
+ }
+
+ return retval;
+}
+#endif
+
+
+size_t
+STRXFRM (STRING_TYPE *dest, const STRING_TYPE *src, size_t n, __locale_t l)
+{
+ struct locale_data *current = l->__locales[LC_COLLATE];
+ uint_fast32_t nrules = current->values[_NL_ITEM_INDEX (_NL_COLLATE_NRULES)].word;
+ /* We don't assign the following values right away since it might be
+ unnecessary in case there are no rules. */
+ const unsigned char *rulesets;
+ const int32_t *table;
+ const USTRING_TYPE *weights;
+ const USTRING_TYPE *extra;
+ const int32_t *indirect;
+ uint_fast32_t pass;
+ size_t needed;
+ const USTRING_TYPE *usrc;
+ size_t srclen = STRLEN (src);
+ int32_t *idxarr;
+ unsigned char *rulearr;
+ size_t idxmax;
+ size_t idxcnt;
+ int use_malloc;
+
+#include WEIGHT_H
+
+ if (nrules == 0)
+ {
+ if (n != 0)
+ STPNCPY (dest, src, MIN (srclen + 1, n));
+
+ return srclen;
+ }
+
+ rulesets = (const unsigned char *)
+ current->values[_NL_ITEM_INDEX (_NL_COLLATE_RULESETS)].string;
+ table = (const int32_t *)
+ current->values[_NL_ITEM_INDEX (CONCAT(_NL_COLLATE_TABLE,SUFFIX))].string;
+ weights = (const USTRING_TYPE *)
+ current->values[_NL_ITEM_INDEX (CONCAT(_NL_COLLATE_WEIGHT,SUFFIX))].string;
+ extra = (const USTRING_TYPE *)
+ current->values[_NL_ITEM_INDEX (CONCAT(_NL_COLLATE_EXTRA,SUFFIX))].string;
+ indirect = (const int32_t *)
+ current->values[_NL_ITEM_INDEX (CONCAT(_NL_COLLATE_INDIRECT,SUFFIX))].string;
+ use_malloc = 0;
+
+ assert (((uintptr_t) table) % __alignof__ (table[0]) == 0);
+ assert (((uintptr_t) weights) % __alignof__ (weights[0]) == 0);
+ assert (((uintptr_t) extra) % __alignof__ (extra[0]) == 0);
+ assert (((uintptr_t) indirect) % __alignof__ (indirect[0]) == 0);
+
+ /* Handle an empty string as a special case. */
+ if (srclen == 0)
+ {
+ if (n != 0)
+ *dest = L('\0');
+ return 0;
+ }
+
+ /* We need the elements of the string as unsigned values since they
+ are used as indeces. */
+ usrc = (const USTRING_TYPE *) src;
+
+ /* Perform the first pass over the string and while doing this find
+ and store the weights for each character. Since we want this to
+ be as fast as possible we are using `alloca' to store the temporary
+ values. But since there is no limit on the length of the string
+ we have to use `malloc' if the string is too long. We should be
+ very conservative here. */
+ if (! __libc_use_alloca (srclen))
+ {
+ idxarr = (int32_t *) malloc ((srclen + 1) * (sizeof (int32_t) + 1));
+ rulearr = (unsigned char *) &idxarr[srclen];
+
+ if (idxarr == NULL)
+ /* No memory. Well, go with the stack then.
+
+ XXX Once this implementation is stable we will handle this
+ differently. Instead of precomputing the indeces we will
+ do this in time. This means, though, that this happens for
+ every pass again. */
+ goto try_stack;
+ use_malloc = 1;
+ }
+ else
+ {
+ try_stack:
+ idxarr = (int32_t *) alloca (srclen * sizeof (int32_t));
+ rulearr = (unsigned char *) alloca (srclen + 1);
+ }
+
+ idxmax = 0;
+ do
+ {
+ int32_t tmp = findidx (&usrc);
+ rulearr[idxmax] = tmp >> 24;
+ idxarr[idxmax] = tmp & 0xffffff;
+
+ ++idxmax;
+ }
+ while (*usrc != L('\0'));
+
+ /* This element is only read, the value never used but to determine
+ another value which then is ignored. */
+ rulearr[idxmax] = '\0';
+
+ /* Now the passes over the weights. We now use the indeces we found
+ before. */
+ needed = 0;
+ for (pass = 0; pass < nrules; ++pass)
+ {
+ size_t backw_stop = ~0ul;
+ int rule = rulesets[rulearr[0] * nrules + pass];
+ /* We assume that if a rule has defined `position' in one section
+ this is true for all of them. */
+ int position = rule & sort_position;
+
+ if (position == 0)
+ {
+ for (idxcnt = 0; idxcnt < idxmax; ++idxcnt)
+ {
+ if ((rule & sort_forward) != 0)
+ {
+ size_t len;
+
+ if (backw_stop != ~0ul)
+ {
+ /* Handle the pushed elements now. */
+ size_t backw;
+
+ for (backw = idxcnt - 1; backw >= backw_stop; --backw)
+ {
+ len = weights[idxarr[backw]++];
+
+ if (needed + len < n)
+ while (len-- > 0)
+ dest[needed++] = weights[idxarr[backw]++];
+ else
+ {
+ /* No more characters fit into the buffer. */
+ needed += len;
+ idxarr[backw] += len;
+ }
+ }
+
+ backw_stop = ~0ul;
+ }
+
+ /* Now handle the forward element. */
+ len = weights[idxarr[idxcnt]++];
+ if (needed + len < n)
+ while (len-- > 0)
+ dest[needed++] = weights[idxarr[idxcnt]++];
+ else
+ {
+ /* No more characters fit into the buffer. */
+ needed += len;
+ idxarr[idxcnt] += len;
+ }
+ }
+ else
+ {
+ /* Remember where the backwards series started. */
+ if (backw_stop == ~0ul)
+ backw_stop = idxcnt;
+ }
+
+ rule = rulesets[rulearr[idxcnt + 1] * nrules + pass];
+ }
+
+
+ if (backw_stop != ~0ul)
+ {
+ /* Handle the pushed elements now. */
+ size_t backw;
+
+ backw = idxcnt;
+ while (backw > backw_stop)
+ {
+ size_t len = weights[idxarr[--backw]++];
+
+ if (needed + len < n)
+ while (len-- > 0)
+ dest[needed++] = weights[idxarr[backw]++];
+ else
+ {
+ /* No more characters fit into the buffer. */
+ needed += len;
+ idxarr[backw] += len;
+ }
+ }
+ }
+ }
+ else
+ {
+ int val = 1;
+#ifndef WIDE_CHAR_VERSION
+ char buf[7];
+ size_t buflen;
+#endif
+ size_t i;
+
+ for (idxcnt = 0; idxcnt < idxmax; ++idxcnt)
+ {
+ if ((rule & sort_forward) != 0)
+ {
+ size_t len;
+
+ if (backw_stop != ~0ul)
+ {
+ /* Handle the pushed elements now. */
+ size_t backw;
+
+ for (backw = idxcnt - 1; backw >= backw_stop; --backw)
+ {
+ len = weights[idxarr[backw]++];
+ if (len != 0)
+ {
+#ifdef WIDE_CHAR_VERSION
+ if (needed + 1 + len < n)
+ {
+ dest[needed] = val;
+ for (i = 0; i < len; ++i)
+ dest[needed + 1 + i] =
+ weights[idxarr[backw] + i];
+ }
+ needed += 1 + len;
+#else
+ buflen = utf8_encode (buf, val);
+ if (needed + buflen + len < n)
+ {
+ for (i = 0; i < buflen; ++i)
+ dest[needed + i] = buf[i];
+ for (i = 0; i < len; ++i)
+ dest[needed + buflen + i] =
+ weights[idxarr[backw] + i];
+ }
+ needed += buflen + len;
+#endif
+ idxarr[backw] += len;
+ val = 1;
+ }
+ else
+ ++val;
+ }
+
+ backw_stop = ~0ul;
+ }
+
+ /* Now handle the forward element. */
+ len = weights[idxarr[idxcnt]++];
+ if (len != 0)
+ {
+#ifdef WIDE_CHAR_VERSION
+ if (needed + 1+ len < n)
+ {
+ dest[needed] = val;
+ for (i = 0; i < len; ++i)
+ dest[needed + 1 + i] =
+ weights[idxarr[idxcnt] + i];
+ }
+ needed += 1 + len;
+#else
+ buflen = utf8_encode (buf, val);
+ if (needed + buflen + len < n)
+ {
+ for (i = 0; i < buflen; ++i)
+ dest[needed + i] = buf[i];
+ for (i = 0; i < len; ++i)
+ dest[needed + buflen + i] =
+ weights[idxarr[idxcnt] + i];
+ }
+ needed += buflen + len;
+#endif
+ idxarr[idxcnt] += len;
+ val = 1;
+ }
+ else
+ /* Note that we don't have to increment `idxarr[idxcnt]'
+ since the length is zero. */
+ ++val;
+ }
+ else
+ {
+ /* Remember where the backwards series started. */
+ if (backw_stop == ~0ul)
+ backw_stop = idxcnt;
+ }
+
+ rule = rulesets[rulearr[idxcnt + 1] * nrules + pass];
+ }
+
+ if (backw_stop != ~0ul)
+ {
+ /* Handle the pushed elements now. */
+ size_t backw;
+
+ backw = idxmax - 1;
+ while (backw > backw_stop)
+ {
+ size_t len = weights[idxarr[--backw]++];
+ if (len != 0)
+ {
+#ifdef WIDE_CHAR_VERSION
+ if (needed + 1 + len < n)
+ {
+ dest[needed] = val;
+ for (i = 0; i < len; ++i)
+ dest[needed + 1 + i] =
+ weights[idxarr[backw] + i];
+ }
+ needed += 1 + len;
+#else
+ buflen = utf8_encode (buf, val);
+ if (needed + buflen + len < n)
+ {
+ for (i = 0; i < buflen; ++i)
+ dest[needed + i] = buf[i];
+ for (i = 0; i < len; ++i)
+ dest[needed + buflen + i] =
+ weights[idxarr[backw] + i];
+ }
+ needed += buflen + len;
+#endif
+ idxarr[backw] += len;
+ val = 1;
+ }
+ else
+ ++val;
+ }
+ }
+ }
+
+ /* Finally store the byte to separate the passes or terminate
+ the string. */
+ if (needed < n)
+ dest[needed] = pass + 1 < nrules ? L('\1') : L('\0');
+ ++needed;
+ }
+
+ /* This is a little optimization: many collation specifications have
+ a `position' rule at the end and if no non-ignored character
+ is found the last \1 byte is immediately followed by a \0 byte
+ signalling this. We can avoid the \1 byte(s). */
+ if (needed <= n && needed > 2 && dest[needed - 2] == L('\1'))
+ {
+ /* Remove the \1 byte. */
+ --needed;
+ dest[needed - 1] = L('\0');
+ }
+
+ /* Free the memory if needed. */
+ if (use_malloc)
+ free (idxarr);
+
+ /* Return the number of bytes/words we need, but don't count the NUL
+ byte/word at the end. */
+ return needed - 1;
+}
+libc_hidden_def (STRXFRM)
+
+#ifndef WIDE_CHAR_VERSION
weak_alias (__strxfrm_l, strxfrm_l)
+#endif
/* Convert string representation of a number into an integer value.
- Copyright (C) 1991,92,94,95,96,97,98,99,2000,2001,2002,2003
+ Copyright (C) 1991,92,94,95,96,97,98,99,2000,2001,2002,2003,2004
Free Software Foundation, Inc.
This file is part of the GNU C Library.
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
-#if HAVE_CONFIG_H
-# include <config.h>
-#endif
-
-#ifdef _LIBC
-# define USE_NUMBER_GROUPING
-# define STDC_HEADERS
-# define HAVE_LIMITS_H
-#endif
-
-#include <ctype.h>
-#include <errno.h>
-#ifndef errno
-extern int errno;
-#endif
-#ifndef __set_errno
-# define __set_errno(Val) errno = (Val)
-#endif
-
-#ifdef HAVE_LIMITS_H
-# include <limits.h>
-#endif
-
-#ifdef STDC_HEADERS
-# include <stddef.h>
-# include <stdlib.h>
-# include <string.h>
-# include <locale.h>
-#else
-# ifndef NULL
-# define NULL 0
-# endif
-#endif
-
-#ifdef USE_NUMBER_GROUPING
-# include "../locale/localeinfo.h"
-#endif
+#include <stdlib.h>
+#include <wchar.h>
+#include <locale/localeinfo.h>
-/* Nonzero if we are defining `strtoul' or `strtoull', operating on
- unsigned integers. */
#ifndef UNSIGNED
# define UNSIGNED 0
# define INT LONG int
# define INT unsigned LONG int
#endif
-/* Determine the name. */
-#ifdef USE_IN_EXTENDED_LOCALE_MODEL
-# if UNSIGNED
-# ifdef USE_WIDE_CHAR
-# ifdef QUAD
-# define strtol __wcstoull_l
-# else
-# define strtol __wcstoul_l
-# endif
+#if UNSIGNED
+# ifdef USE_WIDE_CHAR
+# ifdef QUAD
+# define strtol wcstoull
+# define __strtol_l __wcstoull_l
# else
-# ifdef QUAD
-# define strtol __strtoull_l
-# else
-# define strtol __strtoul_l
-# endif
+# define strtol wcstoul
+# define __strtol_l __wcstoul_l
# endif
# else
-# ifdef USE_WIDE_CHAR
-# ifdef QUAD
-# define strtol __wcstoll_l
-# else
-# define strtol __wcstol_l
-# endif
+# ifdef QUAD
+# define strtol strtoull
+# define __strtol_l __strtoull_l
# else
-# ifdef QUAD
-# define strtol __strtoll_l
-# else
-# define strtol __strtol_l
-# endif
+# define strtol strtoul
+# define __strtol_l __strtoul_l
# endif
# endif
#else
-# if UNSIGNED
-# ifdef USE_WIDE_CHAR
-# ifdef QUAD
-# define strtol wcstoull
-# else
-# define strtol wcstoul
-# endif
+# ifdef USE_WIDE_CHAR
+# ifdef QUAD
+# define strtol wcstoll
+# define __strtol_l __wcstoll_l
# else
-# ifdef QUAD
-# define strtol strtoull
-# else
-# define strtol strtoul
-# endif
+# define strtol wcstol
+# define __strtol_l __wcstol_l
# endif
# else
-# ifdef USE_WIDE_CHAR
-# ifdef QUAD
-# define strtol wcstoll
-# else
-# define strtol wcstol
-# endif
-# else
-# ifdef QUAD
-# define strtol strtoll
-# endif
+# ifdef QUAD
+# define strtol strtoll
+# define __strtol_l __strtoll_l
# endif
# endif
#endif
+
/* If QUAD is defined, we are defining `strtoll' or `strtoull',
operating on `long long int's. */
#ifdef QUAD
# define LONG long long
-# define STRTOL_LONG_MIN LONG_LONG_MIN
-# define STRTOL_LONG_MAX LONG_LONG_MAX
-# define STRTOL_ULONG_MAX ULONG_LONG_MAX
-# if __GNUC__ == 2 && __GNUC_MINOR__ < 7
- /* Work around gcc bug with using this constant. */
- static const unsigned long long int maxquad = ULONG_LONG_MAX;
-# undef STRTOL_ULONG_MAX
-# define STRTOL_ULONG_MAX maxquad
-# endif
#else
# define LONG long
-
-# ifndef ULONG_MAX
-# define ULONG_MAX ((unsigned long) ~(unsigned long) 0)
-# endif
-# ifndef LONG_MAX
-# define LONG_MAX ((long int) (ULONG_MAX >> 1))
-# endif
-# define STRTOL_LONG_MIN LONG_MIN
-# define STRTOL_LONG_MAX LONG_MAX
-# define STRTOL_ULONG_MAX ULONG_MAX
-#endif
-
-
-/* We use this code also for the extended locale handling where the
- function gets as an additional argument the locale which has to be
- used. To access the values we have to redefine the _NL_CURRENT
- macro. */
-#ifdef USE_IN_EXTENDED_LOCALE_MODEL
-# undef _NL_CURRENT
-# define _NL_CURRENT(category, item) \
- (current->values[_NL_ITEM_INDEX (item)].string)
-# define LOCALE_PARAM , loc
-# define LOCALE_PARAM_DECL __locale_t loc;
-#else
-# define LOCALE_PARAM
-# define LOCALE_PARAM_DECL
#endif
-#if defined _LIBC || defined HAVE_WCHAR_H
-# include <wchar.h>
-#endif
#ifdef USE_WIDE_CHAR
-# include <wctype.h>
-# define L_(Ch) L##Ch
-# define UCHAR_TYPE wint_t
# define STRING_TYPE wchar_t
-# ifdef USE_IN_EXTENDED_LOCALE_MODEL
-# define ISSPACE(Ch) __iswspace_l ((Ch), loc)
-# define ISALPHA(Ch) __iswalpha_l ((Ch), loc)
-# define TOUPPER(Ch) __towupper_l ((Ch), loc)
-# else
-# define ISSPACE(Ch) iswspace (Ch)
-# define ISALPHA(Ch) iswalpha (Ch)
-# define TOUPPER(Ch) towupper (Ch)
-# endif
-# else
-# if defined _LIBC \
- || defined STDC_HEADERS || (!defined isascii && !defined HAVE_ISASCII)
-# define IN_CTYPE_DOMAIN(c) 1
-# else
-# define IN_CTYPE_DOMAIN(c) isascii(c)
-# endif
-# define L_(Ch) Ch
-# define UCHAR_TYPE unsigned char
-# define STRING_TYPE char
-# ifdef USE_IN_EXTENDED_LOCALE_MODEL
-# define ISSPACE(Ch) __isspace_l ((Ch), loc)
-# define ISALPHA(Ch) __isalpha_l ((Ch), loc)
-# define TOUPPER(Ch) __toupper_l ((Ch), loc)
-# else
-# define ISSPACE(Ch) (IN_CTYPE_DOMAIN (Ch) && isspace (Ch))
-# define ISALPHA(Ch) (IN_CTYPE_DOMAIN (Ch) && isalpha (Ch))
-# define TOUPPER(Ch) (IN_CTYPE_DOMAIN (Ch) ? toupper (Ch) : (Ch))
-# endif
-#endif
-
-#ifdef __STDC__
-# define INTERNAL(X) INTERNAL1(X)
-# define INTERNAL1(X) __##X##_internal
-# define WEAKNAME(X) WEAKNAME1(X)
#else
-# define INTERNAL(X) __/**/X/**/_internal
+# define STRING_TYPE char
#endif
-#ifdef USE_NUMBER_GROUPING
-/* This file defines a function to check for correct grouping. */
-# include "grouping.h"
-#endif
+
+#define INTERNAL(X) INTERNAL1(X)
+#define INTERNAL1(X) __##X##_internal
+extern INT INTERNAL (__strtol_l) (const STRING_TYPE *, STRING_TYPE **, int,
+ int, __locale_t);
-/* Convert NPTR to an `unsigned long int' or `long int' in base BASE.
- If BASE is 0 the base is determined by the presence of a leading
- zero, indicating octal or a leading "0x" or "0X", indicating hexadecimal.
- If BASE is < 2 or > 36, it is reset to 10.
- If ENDPTR is not NULL, a pointer to the character after the last
- one converted is stored in *ENDPTR. */
INT
-INTERNAL (strtol) (nptr, endptr, base, group LOCALE_PARAM)
+INTERNAL (strtol) (nptr, endptr, base, group)
const STRING_TYPE *nptr;
STRING_TYPE **endptr;
int base;
int group;
- LOCALE_PARAM_DECL
{
- int negative;
- register unsigned LONG int cutoff;
- register unsigned int cutlim;
- register unsigned LONG int i;
- register const STRING_TYPE *s;
- register UCHAR_TYPE c;
- const STRING_TYPE *save, *end;
- int overflow;
-#ifndef USE_WIDE_CHAR
- size_t cnt;
-#endif
-
-#ifdef USE_NUMBER_GROUPING
-# ifdef USE_IN_EXTENDED_LOCALE_MODEL
- struct locale_data *current = loc->__locales[LC_NUMERIC];
-# endif
- /* The thousands character of the current locale. */
-# ifdef USE_WIDE_CHAR
- wchar_t thousands = L'\0';
-# else
- const char *thousands = NULL;
- size_t thousands_len = 0;
-# endif
- /* The numeric grouping specification of the current locale,
- in the format described in <locale.h>. */
- const char *grouping;
-
- if (__builtin_expect (group, 0))
- {
- grouping = _NL_CURRENT (LC_NUMERIC, GROUPING);
- if (*grouping <= 0 || *grouping == CHAR_MAX)
- grouping = NULL;
- else
- {
- /* Figure out the thousands separator character. */
-# ifdef USE_WIDE_CHAR
-# ifdef _LIBC
- thousands = _NL_CURRENT_WORD (LC_NUMERIC,
- _NL_NUMERIC_THOUSANDS_SEP_WC);
-# endif
- if (thousands == L'\0')
- grouping = NULL;
-# else
-# ifdef _LIBC
- thousands = _NL_CURRENT (LC_NUMERIC, THOUSANDS_SEP);
-# endif
- if (*thousands == '\0')
- {
- thousands = NULL;
- grouping = NULL;
- }
-# endif
- }
- }
- else
- grouping = NULL;
-#endif
-
- if (base < 0 || base == 1 || base > 36)
- {
- __set_errno (EINVAL);
- return 0;
- }
-
- save = s = nptr;
-
- /* Skip white space. */
- while (ISSPACE (*s))
- ++s;
- if (__builtin_expect (*s == L_('\0'), 0))
- goto noconv;
-
- /* Check for a sign. */
- negative = 0;
- if (*s == L_('-'))
- {
- negative = 1;
- ++s;
- }
- else if (*s == L_('+'))
- ++s;
-
- /* Recognize number prefix and if BASE is zero, figure it out ourselves. */
- if (*s == L_('0'))
- {
- if ((base == 0 || base == 16) && TOUPPER (s[1]) == L_('X'))
- {
- s += 2;
- base = 16;
- }
- else if (base == 0)
- base = 8;
- }
- else if (base == 0)
- base = 10;
-
- /* Save the pointer so we can check later if anything happened. */
- save = s;
-
-#ifdef USE_NUMBER_GROUPING
- if (base != 10)
- grouping = NULL;
-
- if (__builtin_expect (grouping != NULL, 0))
- {
-# ifndef USE_WIDE_CHAR
- thousands_len = strlen (thousands);
-# endif
-
- /* Find the end of the digit string and check its grouping. */
- end = s;
- if (
-# ifdef USE_WIDE_CHAR
- *s != thousands
-# else
- ({ for (cnt = 0; cnt < thousands_len; ++cnt)
- if (thousands[cnt] != end[cnt])
- break;
- cnt < thousands_len; })
-# endif
- )
- {
- for (c = *end; c != L_('\0'); c = *++end)
- if (((STRING_TYPE) c < L_('0') || (STRING_TYPE) c > L_('9'))
-# ifdef USE_WIDE_CHAR
- && (wchar_t) c != thousands
-# else
- && ({ for (cnt = 0; cnt < thousands_len; ++cnt)
- if (thousands[cnt] != end[cnt])
- break;
- cnt < thousands_len; })
-# endif
- && (!ISALPHA (c)
- || (int) (TOUPPER (c) - L_('A') + 10) >= base))
- break;
-
-# ifdef USE_WIDE_CHAR
- end = __correctly_grouped_prefixwc (s, end, thousands, grouping);
-# else
- end = __correctly_grouped_prefixmb (s, end, thousands, grouping);
-# endif
- }
- }
- else
-#endif
- end = NULL;
-
- cutoff = STRTOL_ULONG_MAX / (unsigned LONG int) base;
- cutlim = STRTOL_ULONG_MAX % (unsigned LONG int) base;
-
- overflow = 0;
- i = 0;
- c = *s;
- if (sizeof (long int) != sizeof (LONG int))
- {
- unsigned long int j = 0;
- unsigned long int jmax = ULONG_MAX / base;
-
- for (;c != L_('\0'); c = *++s)
- {
- if (s == end)
- break;
- if (c >= L_('0') && c <= L_('9'))
- c -= L_('0');
-#ifdef USE_NUMBER_GROUPING
-# ifdef USE_WIDE_CHAR
- else if (grouping && (wchar_t) c == thousands)
- continue;
-# else
- else if (thousands_len)
- {
- for (cnt = 0; cnt < thousands_len; ++cnt)
- if (thousands[cnt] != s[cnt])
- break;
- if (cnt == thousands_len)
- {
- s += thousands_len - 1;
- continue;
- }
- if (ISALPHA (c))
- c = TOUPPER (c) - L_('A') + 10;
- else
- break;
- }
-# endif
-#endif
- else if (ISALPHA (c))
- c = TOUPPER (c) - L_('A') + 10;
- else
- break;
- if ((int) c >= base)
- break;
- /* Note that we never can have an overflow. */
- else if (j >= jmax)
- {
- /* We have an overflow. Now use the long representation. */
- i = (unsigned LONG int) j;
- goto use_long;
- }
- else
- j = j * (unsigned long int) base + c;
- }
-
- i = (unsigned LONG int) j;
- }
- else
- for (;c != L_('\0'); c = *++s)
- {
- if (s == end)
- break;
- if (c >= L_('0') && c <= L_('9'))
- c -= L_('0');
-#ifdef USE_NUMBER_GROUPING
-# ifdef USE_WIDE_CHAR
- else if (grouping && (wchar_t) c == thousands)
- continue;
-# else
- else if (thousands_len)
- {
- for (cnt = 0; cnt < thousands_len; ++cnt)
- if (thousands[cnt] != s[cnt])
- break;
- if (cnt == thousands_len)
- {
- s += thousands_len - 1;
- continue;
- }
- if (ISALPHA (c))
- c = TOUPPER (c) - L_('A') + 10;
- else
- break;
- }
-# endif
-#endif
- else if (ISALPHA (c))
- c = TOUPPER (c) - L_('A') + 10;
- else
- break;
- if ((int) c >= base)
- break;
- /* Check for overflow. */
- if (i > cutoff || (i == cutoff && c > cutlim))
- overflow = 1;
- else
- {
- use_long:
- i *= (unsigned LONG int) base;
- i += c;
- }
- }
-
- /* Check if anything actually happened. */
- if (s == save)
- goto noconv;
-
- /* Store in ENDPTR the address of one character
- past the last character we converted. */
- if (endptr != NULL)
- *endptr = (STRING_TYPE *) s;
-
-#if !UNSIGNED
- /* Check for a value that is within the range of
- `unsigned LONG int', but outside the range of `LONG int'. */
- if (overflow == 0
- && i > (negative
- ? -((unsigned LONG int) (STRTOL_LONG_MIN + 1)) + 1
- : (unsigned LONG int) STRTOL_LONG_MAX))
- overflow = 1;
-#endif
-
- if (__builtin_expect (overflow, 0))
- {
- __set_errno (ERANGE);
-#if UNSIGNED
- return STRTOL_ULONG_MAX;
-#else
- return negative ? STRTOL_LONG_MIN : STRTOL_LONG_MAX;
-#endif
- }
-
- /* Return the result of the appropriate sign. */
- return negative ? -i : i;
-
-noconv:
- /* We must handle a special case here: the base is 0 or 16 and the
- first two characters are '0' and 'x', but the rest are no
- hexadecimal digits. This is no error case. We return 0 and
- ENDPTR points to the `x`. */
- if (endptr != NULL)
- {
- if (save - nptr >= 2 && TOUPPER (save[-1]) == L_('X')
- && save[-2] == L_('0'))
- *endptr = (STRING_TYPE *) &save[-1];
- else
- /* There was no number to convert. */
- *endptr = (STRING_TYPE *) nptr;
- }
-
- return 0L;
+ return INTERNAL (__strtol_l) (nptr, endptr, base, group, _NL_CURRENT_LOCALE);
}
-#if defined _LIBC \
- && !(defined USE_IN_EXTENDED_LOCALE_MODEL && defined USE_WIDE_CHAR)
libc_hidden_def (INTERNAL (strtol))
-#endif
-\f
-/* External user entry point. */
-
-#if _LIBC - 0 == 0
-# undef PARAMS
-# if defined (__STDC__) && __STDC__
-# define PARAMS(Args) Args
-# else
-# define PARAMS(Args) ()
-# endif
-
-/* Prototype. */
-INT strtol PARAMS ((const STRING_TYPE *nptr, STRING_TYPE **endptr, int base));
-#endif
INT
-#ifdef weak_function
-weak_function
-#endif
-strtol (nptr, endptr, base LOCALE_PARAM)
+strtol (nptr, endptr, base)
const STRING_TYPE *nptr;
STRING_TYPE **endptr;
int base;
- LOCALE_PARAM_DECL
{
- return INTERNAL (strtol) (nptr, endptr, base, 0 LOCALE_PARAM);
+ return INTERNAL (__strtol_l) (nptr, endptr, base, 0, _NL_CURRENT_LOCALE);
}
/* Convert string representing a number to integer value, using given locale.
- Copyright (C) 1997, 2002 Free Software Foundation, Inc.
+ Copyright (C) 1997, 2002, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
-#define USE_IN_EXTENDED_LOCALE_MODEL 1
+#if HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#ifdef _LIBC
+# define USE_NUMBER_GROUPING
+# define STDC_HEADERS
+# define HAVE_LIMITS_H
+#endif
+
+#include <ctype.h>
+#include <errno.h>
+#ifndef __set_errno
+# define __set_errno(Val) errno = (Val)
+#endif
+
+#ifdef HAVE_LIMITS_H
+# include <limits.h>
+#endif
+
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include <locale.h>
#include <xlocale.h>
-extern long int ____strtol_l_internal (const char *, char **, int, int,
- __locale_t);
+#ifdef USE_NUMBER_GROUPING
+# include "../locale/localeinfo.h"
+#endif
+
+/* Nonzero if we are defining `strtoul' or `strtoull', operating on
+ unsigned integers. */
+#ifndef UNSIGNED
+# define UNSIGNED 0
+# define INT LONG int
+#else
+# define INT unsigned LONG int
+#endif
+
+/* Determine the name. */
+#if UNSIGNED
+# ifdef USE_WIDE_CHAR
+# ifdef QUAD
+# define strtol_l wcstoull_l
+# else
+# define strtol_l wcstoul_l
+# endif
+# else
+# ifdef QUAD
+# define strtol_l strtoull_l
+# else
+# define strtol_l strtoul_l
+# endif
+# endif
+#else
+# ifdef USE_WIDE_CHAR
+# ifdef QUAD
+# define strtol_l wcstoll_l
+# else
+# define strtol_l wcstol_l
+# endif
+# else
+# ifdef QUAD
+# define strtol_l strtoll_l
+# else
+# define strtol_l strtol_l
+# endif
+# endif
+#endif
+
+#define __strtol_l __strtol_l2(strtol_l)
+#define __strtol_l2(name) __strtol_l3(name)
+#define __strtol_l3(name) __##name
+
+
+/* If QUAD is defined, we are defining `strtoll' or `strtoull',
+ operating on `long long int's. */
+#ifdef QUAD
+# define LONG long long
+# define STRTOL_LONG_MIN LONG_LONG_MIN
+# define STRTOL_LONG_MAX LONG_LONG_MAX
+# define STRTOL_ULONG_MAX ULONG_LONG_MAX
+#else
+# define LONG long
+
+# ifndef ULONG_MAX
+# define ULONG_MAX ((unsigned long int) ~(unsigned long int) 0)
+# endif
+# ifndef LONG_MAX
+# define LONG_MAX ((long int) (ULONG_MAX >> 1))
+# endif
+# define STRTOL_LONG_MIN LONG_MIN
+# define STRTOL_LONG_MAX LONG_MAX
+# define STRTOL_ULONG_MAX ULONG_MAX
+#endif
+
+
+/* We use this code for the extended locale handling where the
+ function gets as an additional argument the locale which has to be
+ used. To access the values we have to redefine the _NL_CURRENT and
+ _NL_CURRENT_WORD macros. */
+#undef _NL_CURRENT
+#define _NL_CURRENT(category, item) \
+ (current->values[_NL_ITEM_INDEX (item)].string)
+#undef _NL_CURRENT_WORD
+#define _NL_CURRENT_WORD(category, item) \
+ ((uint32_t) current->values[_NL_ITEM_INDEX (item)].word)
+
+#if defined _LIBC || defined HAVE_WCHAR_H
+# include <wchar.h>
+#endif
+
+#ifdef USE_WIDE_CHAR
+# include <wctype.h>
+# define L_(Ch) L##Ch
+# define UCHAR_TYPE wint_t
+# define STRING_TYPE wchar_t
+# define ISSPACE(Ch) __iswspace_l ((Ch), loc)
+# define ISALPHA(Ch) __iswalpha_l ((Ch), loc)
+# define TOUPPER(Ch) __towupper_l ((Ch), loc)
+#else
+# if defined _LIBC \
+ || defined STDC_HEADERS || (!defined isascii && !defined HAVE_ISASCII)
+# define IN_CTYPE_DOMAIN(c) 1
+# else
+# define IN_CTYPE_DOMAIN(c) isascii(c)
+# endif
+# define L_(Ch) Ch
+# define UCHAR_TYPE unsigned char
+# define STRING_TYPE char
+# define ISSPACE(Ch) __isspace_l ((Ch), loc)
+# define ISALPHA(Ch) __isalpha_l ((Ch), loc)
+# define TOUPPER(Ch) __toupper_l ((Ch), loc)
+#endif
+
+#define INTERNAL(X) INTERNAL1(X)
+#define INTERNAL1(X) __##X##_internal
+#define WEAKNAME(X) WEAKNAME1(X)
+
+#ifdef USE_NUMBER_GROUPING
+/* This file defines a function to check for correct grouping. */
+# include "grouping.h"
+#endif
+
+
+
+/* Convert NPTR to an `unsigned long int' or `long int' in base BASE.
+ If BASE is 0 the base is determined by the presence of a leading
+ zero, indicating octal or a leading "0x" or "0X", indicating hexadecimal.
+ If BASE is < 2 or > 36, it is reset to 10.
+ If ENDPTR is not NULL, a pointer to the character after the last
+ one converted is stored in *ENDPTR. */
+
+INT
+INTERNAL (__strtol_l) (nptr, endptr, base, group, loc)
+ const STRING_TYPE *nptr;
+ STRING_TYPE **endptr;
+ int base;
+ int group;
+ __locale_t loc;
+{
+ int negative;
+ register unsigned LONG int cutoff;
+ register unsigned int cutlim;
+ register unsigned LONG int i;
+ register const STRING_TYPE *s;
+ register UCHAR_TYPE c;
+ const STRING_TYPE *save, *end;
+ int overflow;
+#ifndef USE_WIDE_CHAR
+ size_t cnt;
+#endif
+
+#ifdef USE_NUMBER_GROUPING
+ struct locale_data *current = loc->__locales[LC_NUMERIC];
+ /* The thousands character of the current locale. */
+# ifdef USE_WIDE_CHAR
+ wchar_t thousands = L'\0';
+# else
+ const char *thousands = NULL;
+ size_t thousands_len = 0;
+# endif
+ /* The numeric grouping specification of the current locale,
+ in the format described in <locale.h>. */
+ const char *grouping;
+
+ if (__builtin_expect (group, 0))
+ {
+ grouping = _NL_CURRENT (LC_NUMERIC, GROUPING);
+ if (*grouping <= 0 || *grouping == CHAR_MAX)
+ grouping = NULL;
+ else
+ {
+ /* Figure out the thousands separator character. */
+# ifdef USE_WIDE_CHAR
+# ifdef _LIBC
+ thousands = _NL_CURRENT_WORD (LC_NUMERIC,
+ _NL_NUMERIC_THOUSANDS_SEP_WC);
+# endif
+ if (thousands == L'\0')
+ grouping = NULL;
+# else
+# ifdef _LIBC
+ thousands = _NL_CURRENT (LC_NUMERIC, THOUSANDS_SEP);
+# endif
+ if (*thousands == '\0')
+ {
+ thousands = NULL;
+ grouping = NULL;
+ }
+# endif
+ }
+ }
+ else
+ grouping = NULL;
+#endif
+
+ if (base < 0 || base == 1 || base > 36)
+ {
+ __set_errno (EINVAL);
+ return 0;
+ }
+
+ save = s = nptr;
+
+ /* Skip white space. */
+ while (ISSPACE (*s))
+ ++s;
+ if (__builtin_expect (*s == L_('\0'), 0))
+ goto noconv;
+
+ /* Check for a sign. */
+ negative = 0;
+ if (*s == L_('-'))
+ {
+ negative = 1;
+ ++s;
+ }
+ else if (*s == L_('+'))
+ ++s;
+
+ /* Recognize number prefix and if BASE is zero, figure it out ourselves. */
+ if (*s == L_('0'))
+ {
+ if ((base == 0 || base == 16) && TOUPPER (s[1]) == L_('X'))
+ {
+ s += 2;
+ base = 16;
+ }
+ else if (base == 0)
+ base = 8;
+ }
+ else if (base == 0)
+ base = 10;
+
+ /* Save the pointer so we can check later if anything happened. */
+ save = s;
+
+#ifdef USE_NUMBER_GROUPING
+ if (base != 10)
+ grouping = NULL;
+
+ if (__builtin_expect (grouping != NULL, 0))
+ {
+# ifndef USE_WIDE_CHAR
+ thousands_len = strlen (thousands);
+# endif
+
+ /* Find the end of the digit string and check its grouping. */
+ end = s;
+ if (
+# ifdef USE_WIDE_CHAR
+ *s != thousands
+# else
+ ({ for (cnt = 0; cnt < thousands_len; ++cnt)
+ if (thousands[cnt] != end[cnt])
+ break;
+ cnt < thousands_len; })
+# endif
+ )
+ {
+ for (c = *end; c != L_('\0'); c = *++end)
+ if (((STRING_TYPE) c < L_('0') || (STRING_TYPE) c > L_('9'))
+# ifdef USE_WIDE_CHAR
+ && (wchar_t) c != thousands
+# else
+ && ({ for (cnt = 0; cnt < thousands_len; ++cnt)
+ if (thousands[cnt] != end[cnt])
+ break;
+ cnt < thousands_len; })
+# endif
+ && (!ISALPHA (c)
+ || (int) (TOUPPER (c) - L_('A') + 10) >= base))
+ break;
+
+# ifdef USE_WIDE_CHAR
+ end = __correctly_grouped_prefixwc (s, end, thousands, grouping);
+# else
+ end = __correctly_grouped_prefixmb (s, end, thousands, grouping);
+# endif
+ }
+ }
+ else
+#endif
+ end = NULL;
+
+ cutoff = STRTOL_ULONG_MAX / (unsigned LONG int) base;
+ cutlim = STRTOL_ULONG_MAX % (unsigned LONG int) base;
+
+ overflow = 0;
+ i = 0;
+ c = *s;
+ if (sizeof (long int) != sizeof (LONG int))
+ {
+ unsigned long int j = 0;
+ unsigned long int jmax = ULONG_MAX / base;
+
+ for (;c != L_('\0'); c = *++s)
+ {
+ if (s == end)
+ break;
+ if (c >= L_('0') && c <= L_('9'))
+ c -= L_('0');
+#ifdef USE_NUMBER_GROUPING
+# ifdef USE_WIDE_CHAR
+ else if (grouping && (wchar_t) c == thousands)
+ continue;
+# else
+ else if (thousands_len)
+ {
+ for (cnt = 0; cnt < thousands_len; ++cnt)
+ if (thousands[cnt] != s[cnt])
+ break;
+ if (cnt == thousands_len)
+ {
+ s += thousands_len - 1;
+ continue;
+ }
+ if (ISALPHA (c))
+ c = TOUPPER (c) - L_('A') + 10;
+ else
+ break;
+ }
+# endif
+#endif
+ else if (ISALPHA (c))
+ c = TOUPPER (c) - L_('A') + 10;
+ else
+ break;
+ if ((int) c >= base)
+ break;
+ /* Note that we never can have an overflow. */
+ else if (j >= jmax)
+ {
+ /* We have an overflow. Now use the long representation. */
+ i = (unsigned LONG int) j;
+ goto use_long;
+ }
+ else
+ j = j * (unsigned long int) base + c;
+ }
+
+ i = (unsigned LONG int) j;
+ }
+ else
+ for (;c != L_('\0'); c = *++s)
+ {
+ if (s == end)
+ break;
+ if (c >= L_('0') && c <= L_('9'))
+ c -= L_('0');
+#ifdef USE_NUMBER_GROUPING
+# ifdef USE_WIDE_CHAR
+ else if (grouping && (wchar_t) c == thousands)
+ continue;
+# else
+ else if (thousands_len)
+ {
+ for (cnt = 0; cnt < thousands_len; ++cnt)
+ if (thousands[cnt] != s[cnt])
+ break;
+ if (cnt == thousands_len)
+ {
+ s += thousands_len - 1;
+ continue;
+ }
+ if (ISALPHA (c))
+ c = TOUPPER (c) - L_('A') + 10;
+ else
+ break;
+ }
+# endif
+#endif
+ else if (ISALPHA (c))
+ c = TOUPPER (c) - L_('A') + 10;
+ else
+ break;
+ if ((int) c >= base)
+ break;
+ /* Check for overflow. */
+ if (i > cutoff || (i == cutoff && c > cutlim))
+ overflow = 1;
+ else
+ {
+ use_long:
+ i *= (unsigned LONG int) base;
+ i += c;
+ }
+ }
+
+ /* Check if anything actually happened. */
+ if (s == save)
+ goto noconv;
+
+ /* Store in ENDPTR the address of one character
+ past the last character we converted. */
+ if (endptr != NULL)
+ *endptr = (STRING_TYPE *) s;
+
+#if !UNSIGNED
+ /* Check for a value that is within the range of
+ `unsigned LONG int', but outside the range of `LONG int'. */
+ if (overflow == 0
+ && i > (negative
+ ? -((unsigned LONG int) (STRTOL_LONG_MIN + 1)) + 1
+ : (unsigned LONG int) STRTOL_LONG_MAX))
+ overflow = 1;
+#endif
+
+ if (__builtin_expect (overflow, 0))
+ {
+ __set_errno (ERANGE);
+#if UNSIGNED
+ return STRTOL_ULONG_MAX;
+#else
+ return negative ? STRTOL_LONG_MIN : STRTOL_LONG_MAX;
+#endif
+ }
+
+ /* Return the result of the appropriate sign. */
+ return negative ? -i : i;
+
+noconv:
+ /* We must handle a special case here: the base is 0 or 16 and the
+ first two characters are '0' and 'x', but the rest are no
+ hexadecimal digits. This is no error case. We return 0 and
+ ENDPTR points to the `x`. */
+ if (endptr != NULL)
+ {
+ if (save - nptr >= 2 && TOUPPER (save[-1]) == L_('X')
+ && save[-2] == L_('0'))
+ *endptr = (STRING_TYPE *) &save[-1];
+ else
+ /* There was no number to convert. */
+ *endptr = (STRING_TYPE *) nptr;
+ }
+
+ return 0L;
+}
+#if defined _LIBC && !defined USE_WIDE_CHAR
+libc_hidden_def (INTERNAL (__strtol_l))
+#endif
+\f
+/* External user entry point. */
+
+#if _LIBC - 0 == 0
+# undef PARAMS
+# if defined (__STDC__) && __STDC__
+# define PARAMS(Args) Args
+# else
+# define PARAMS(Args) ()
+# endif
+
+/* Prototype. */
+extern INT __strtol_l PARAMS ((const STRING_TYPE *nptr, STRING_TYPE **endptr,
+ int base));
+#endif
-#include "strtol.c"
+INT
+#ifdef weak_function
+weak_function
+#endif
+__strtol_l (nptr, endptr, base, loc)
+ const STRING_TYPE *nptr;
+ STRING_TYPE **endptr;
+ int base;
+ __locale_t loc;
+{
+ return INTERNAL (__strtol_l) (nptr, endptr, base, 0, loc);
+}
weak_alias (__strtol_l, strtol_l)
-/* Copyright (C) 1999, 2002 Free Software Foundation, Inc.
+/* Copyright (C) 1999, 2002, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
#include <math.h>
#include <stdlib.h>
+#include <xlocale.h>
+
+
+extern double ____strtod_l_internal (const char *, char **, int, __locale_t);
+
/* There is no `long double' type, use the `double' implementations. */
long double
-__strtold_internal (const char *nptr, char **endptr, int group)
+____strtold_l_internal (const char *nptr, char **endptr, int group,
+ __locale_t loc)
{
- return __strtod_internal (nptr, endptr, group);
+ return ____strtod_l_internal (nptr, endptr, group, loc);
}
-libc_hidden_def (__strtold_internal)
+
long double
-strtold (const char *nptr, char **endptr)
+strtold (const char *nptr, char **endptr, __locale_t loc)
{
- return __strtod_internal (nptr, endptr, 0);
+ return ____strtod_l_internal (nptr, endptr, 0, loc);
}
/* Convert string representing a number to integer value, using given locale.
- Copyright (C) 1997, 2002 Free Software Foundation, Inc.
+ Copyright (C) 1997, 2002, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
-#define USE_IN_EXTENDED_LOCALE_MODEL 1
+#define QUAD 1
#include <xlocale.h>
extern long long int ____strtoll_l_internal (const char *, char **, int, int,
__locale_t);
-#include <strtoll.c>
-
-weak_alias (__strtoll_l, strtoll_l)
+#include <strtol_l.c>
/* Convert string representing a number to integer value, using given locale.
- Copyright (C) 1997, 2002 Free Software Foundation, Inc.
+ Copyright (C) 1997, 2002, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
-#define USE_IN_EXTENDED_LOCALE_MODEL 1
+#define UNSIGNED 1
#include <xlocale.h>
extern unsigned long int ____strtoul_l_internal (const char *, char **, int,
int, __locale_t);
-#include "strtoul.c"
-
-weak_alias (__strtoul_l, strtoul_l)
+#include "strtol_l.c"
/* Convert string representing a number to integer value, using given locale.
- Copyright (C) 1997, 2002 Free Software Foundation, Inc.
+ Copyright (C) 1997, 2002, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
-#define USE_IN_EXTENDED_LOCALE_MODEL 1
+#define QUAD 1
+#define UNSIGNED 1
#include <xlocale.h>
extern unsigned long long int ____strtoull_l_internal (const char *, char **,
int, int, __locale_t);
-#include <strtoull.c>
-
-weak_alias (__strtoull_l, strtoull_l)
+#include <strtol_l.c>
/* Convert string representing a number to integer value, using given locale.
- Copyright (C) 1997, 2002 Free Software Foundation, Inc.
+ Copyright (C) 1997, 2002, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
#include <stddef.h>
#include <locale.h>
-#define USE_IN_EXTENDED_LOCALE_MODEL 1
+#define USE_WIDE_CHAR 1
extern long int ____wcstol_l_internal (const wchar_t *, wchar_t **, int, int,
__locale_t);
-#include "wcstol.c"
-
-weak_alias (__wcstol_l, wcstol_l)
+#include "strtol_l.c"
/* Convert string representing a number to integer value, using given locale.
- Copyright (C) 1997 Free Software Foundation, Inc.
+ Copyright (C) 1997, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
#include <stddef.h>
#include <locale.h>
-#define USE_IN_EXTENDED_LOCALE_MODEL 1
+#define QUAD 1
extern long long int ____wcstoll_l_internal (const wchar_t *, wchar_t **,
int, int, __locale_t);
-#include <wcstoll.c>
-
-weak_alias (__wcstoll_l, wcstoll_l)
+#include <wcstol_l.c>
/* Convert string representing a number to integer value, using given locale.
- Copyright (C) 1997, 2002 Free Software Foundation, Inc.
+ Copyright (C) 1997, 2002, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
#include <stddef.h>
#include <locale.h>
-#define USE_IN_EXTENDED_LOCALE_MODEL 1
+#define UNSIGNED 1
extern unsigned long int ____wcstoul_l_internal (const wchar_t *, wchar_t **,
int, int, __locale_t);
-#include <wcstoul.c>
-
-weak_alias (__wcstoul_l, wcstoul_l)
+#include <wcstol_l.c>
/* Convert string representing a number to integer value, using given locale.
- Copyright (C) 1997, 2002 Free Software Foundation, Inc.
+ Copyright (C) 1997, 2002, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
#include <stddef.h>
#include <locale.h>
-#define USE_IN_EXTENDED_LOCALE_MODEL 1
+#define UNSIGNED 1
extern unsigned long long int ____wcstoull_l_internal (const wchar_t *,
wchar_t **, int, int,
__locale_t);
-#include <wcstoull.c>
-
-weak_alias (__wcstoull_l, wcstoull_l)
+#include <wcstoll_l.c>
-/* Copyright (C) 1999 Free Software Foundation, Inc.
+/* Copyright (C) 1999, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
/* The actual implementation for all floating point sizes is in strtod.c.
These macros tell it to produce the `long double' version, `strtold'. */
-# define FLOAT long double
-# define FLT LDBL
-# ifdef USE_IN_EXTENDED_LOCALE_MODEL
-# define STRTOF __strtold_l
-# else
-# define STRTOF strtold
-# endif
-# define MPN2FLOAT __mpn_construct_long_double
-# define FLOAT_HUGE_VAL HUGE_VALL
-# define SET_MANTISSA(flt, mant) \
+#define FLOAT long double
+#define FLT LDBL
+#ifdef USE_WIDE_CHAR
+# define STRTOF wcstold_l
+# define __STRTOF __wcstold_l
+#else
+# define STRTOF strtold_l
+# define __STRTOF __strtold_l
+#endif
+#define MPN2FLOAT __mpn_construct_long_double
+#define FLOAT_HUGE_VAL HUGE_VALL
+#define SET_MANTISSA(flt, mant) \
do { union ieee854_long_double u; \
u.d = (flt); \
u.ieee.mantissa0 = 0x8000; \
(flt) = u.d; \
} while (0)
-# include "strtod.c"
+#include <strtod_l.c>
-/* Copyright (C) 1999 Free Software Foundation, Inc.
+/* Copyright (C) 1999, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
/* The actual implementation for all floating point sizes is in strtod.c.
These macros tell it to produce the `long double' version, `strtold'. */
-# define FLOAT long double
-# define FLT LDBL
-# ifdef USE_IN_EXTENDED_LOCALE_MODEL
-# define STRTOF __strtold_l
-# else
-# define STRTOF strtold
-# endif
-# define MPN2FLOAT __mpn_construct_long_double
-# define FLOAT_HUGE_VAL HUGE_VALL
-# define SET_MANTISSA(flt, mant) \
+#define FLOAT long double
+#define FLT LDBL
+#ifdef USE_WIDE_CHAR
+# define STRTOF wcstold_l
+# define __STRTOF __wcstold_l
+#else
+# define STRTOF strtold_l
+# define __STRTOF __strtold_l
+#endif
+#define MPN2FLOAT __mpn_construct_long_double
+#define FLOAT_HUGE_VAL HUGE_VALL
+#define SET_MANTISSA(flt, mant) \
do { union ieee854_long_double u; \
u.d = (flt); \
if ((mant & 0x7fffffffffffffffULL) == 0) \
(flt) = u.d; \
} while (0)
-# include "strtod.c"
+#include <strtod_l.c>
+++ /dev/null
-#define DENORM_EXP (MIN_EXP - 1)
-#include <sysdeps/ieee754/ldbl-96/strtold.c>
--- /dev/null
+#define DENORM_EXP (MIN_EXP - 1)
+#include <sysdeps/ieee754/ldbl-96/strtold_l.c>
-/* Copyright (C) 1991-1999, 2000, 2001, 2002, 2003
+/* Copyright (C) 1991-1999, 2000, 2001, 2002, 2003, 2004
Free Software Foundation, Inc.
This file is part of the GNU C Library.
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
-#ifdef HAVE_CONFIG_H
-# include <config.h>
-#endif
+#include <time.h>
+#include <locale/localeinfo.h>
-#ifdef _LIBC
-# define HAVE_LIMITS_H 1
-# define HAVE_MBLEN 1
-# define HAVE_MBRLEN 1
-# define HAVE_STRUCT_ERA_ENTRY 1
-# define HAVE_TM_GMTOFF 1
-# define HAVE_TM_ZONE 1
-# define HAVE_TZNAME 1
-# define HAVE_TZSET 1
-# define MULTIBYTE_IS_FORMAT_SAFE 1
-# define STDC_HEADERS 1
-# include "../locale/localeinfo.h"
-#endif
-#if defined emacs && !defined HAVE_BCOPY
-# define HAVE_MEMCPY 1
-#endif
-
-#include <ctype.h>
-#include <sys/types.h> /* Some systems define `time_t' here. */
-
-#ifdef TIME_WITH_SYS_TIME
-# include <sys/time.h>
-# include <time.h>
-#else
-# ifdef HAVE_SYS_TIME_H
-# include <sys/time.h>
-# else
-# include <time.h>
-# endif
-#endif
-#if HAVE_TZNAME
-extern char *tzname[];
-#endif
-
-/* Do multibyte processing if multibytes are supported, unless
- multibyte sequences are safe in formats. Multibyte sequences are
- safe if they cannot contain byte sequences that look like format
- conversion specifications. The GNU C Library uses UTF8 multibyte
- encoding, which is safe for formats, but strftime.c can be used
- with other C libraries that use unsafe encodings. */
-#define DO_MULTIBYTE (HAVE_MBLEN && ! MULTIBYTE_IS_FORMAT_SAFE)
-
-#if DO_MULTIBYTE
-# if HAVE_MBRLEN
-# include <wchar.h>
-# else
- /* Simulate mbrlen with mblen as best we can. */
-# define mbstate_t int
-# define mbrlen(s, n, ps) mblen (s, n)
-# define mbsinit(ps) (*(ps) == 0)
-# endif
- static const mbstate_t mbstate_zero;
-#endif
-
-#if HAVE_LIMITS_H
-# include <limits.h>
-#endif
-
-#if STDC_HEADERS
-# include <stddef.h>
-# include <stdlib.h>
-# include <string.h>
-#else
-# ifndef HAVE_MEMCPY
-# define memcpy(d, s, n) bcopy ((s), (d), (n))
-# endif
-#endif
-
-#ifdef COMPILE_WIDE
-# include <endian.h>
-# define CHAR_T wchar_t
-# define UCHAR_T unsigned int
-# define L_(Str) L##Str
-# define NLW(Sym) _NL_W##Sym
-
-# define MEMCPY(d, s, n) __wmemcpy (d, s, n)
-# define STRLEN(s) __wcslen (s)
-
-#else
-# define CHAR_T char
-# define UCHAR_T unsigned char
-# define L_(Str) Str
-# define NLW(Sym) Sym
-
-# if !defined STDC_HEADERS && !defined HAVE_MEMCPY
-# define MEMCPY(d, s, n) bcopy ((s), (d), (n))
-# else
-# define MEMCPY(d, s, n) memcpy ((d), (s), (n))
-# endif
-# define STRLEN(s) strlen (s)
-
-# ifdef _LIBC
-# define MEMPCPY(d, s, n) __mempcpy (d, s, n)
-# else
-# ifndef HAVE_MEMPCPY
-# define MEMPCPY(d, s, n) ((void *) ((char *) memcpy (d, s, n) + (n)))
-# endif
-# endif
-#endif
-
-#ifndef __P
-# if defined __GNUC__ || (defined __STDC__ && __STDC__)
-# define __P(args) args
-# else
-# define __P(args) ()
-# endif /* GCC. */
-#endif /* Not __P. */
-
-#ifndef PTR
-# ifdef __STDC__
-# define PTR void *
-# else
-# define PTR char *
-# endif
-#endif
-
-#ifndef CHAR_BIT
-# define CHAR_BIT 8
-#endif
-
-#ifndef NULL
-# define NULL 0
-#endif
-
-#define TYPE_SIGNED(t) ((t) -1 < 0)
-
-/* Bound on length of the string representing an integer value of type t.
- Subtract one for the sign bit if t is signed;
- 302 / 1000 is log10 (2) rounded up;
- add one for integer division truncation;
- add one more for a minus sign if t is signed. */
-#define INT_STRLEN_BOUND(t) \
- ((sizeof (t) * CHAR_BIT - TYPE_SIGNED (t)) * 302 / 1000 + 1 + TYPE_SIGNED (t))
-
-#define TM_YEAR_BASE 1900
-
-#ifndef __isleap
-/* Nonzero if YEAR is a leap year (every 4 years,
- except every 100th isn't, and every 400th is). */
-# define __isleap(year) \
- ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
-#endif
-
-
-#ifdef _LIBC
-# define tzname __tzname
-# define tzset __tzset
-#endif
-
-#if !HAVE_TM_GMTOFF
-/* Portable standalone applications should supply a "time_r.h" that
- declares a POSIX-compliant localtime_r, for the benefit of older
- implementations that lack localtime_r or have a nonstandard one.
- Similarly for gmtime_r. See the gnulib time_r module for one way
- to implement this. */
-# include "time_r.h"
-# undef __gmtime_r
-# undef __localtime_r
-# define __gmtime_r gmtime_r
-# define __localtime_r localtime_r
-#endif
-
-
-#if !defined memset && !defined HAVE_MEMSET && !defined _LIBC
-/* Some systems lack the `memset' function and we don't want to
- introduce additional dependencies. */
-/* The SGI compiler reportedly barfs on the trailing null
- if we use a string constant as the initializer. 28 June 1997, rms. */
-static const CHAR_T spaces[16] = /* " " */
-{
- L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),
- L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' ')
-};
-static const CHAR_T zeroes[16] = /* "0000000000000000" */
-{
- L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),
- L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0')
-};
-
-# define memset_space(P, Len) \
- do { \
- int _len = (Len); \
- \
- do \
- { \
- int _this = _len > 16 ? 16 : _len; \
- (P) = MEMPCPY ((P), spaces, _this * sizeof (CHAR_T)); \
- _len -= _this; \
- } \
- while (_len > 0); \
- } while (0)
-
-# define memset_zero(P, Len) \
- do { \
- int _len = (Len); \
- \
- do \
- { \
- int _this = _len > 16 ? 16 : _len; \
- (P) = MEMPCPY ((P), zeroes, _this * sizeof (CHAR_T)); \
- _len -= _this; \
- } \
- while (_len > 0); \
- } while (0)
-#else
-# ifdef COMPILE_WIDE
-# define memset_space(P, Len) (wmemset ((P), L' ', (Len)), (P) += (Len))
-# define memset_zero(P, Len) (wmemset ((P), L'0', (Len)), (P) += (Len))
-# else
-# define memset_space(P, Len) (memset ((P), ' ', (Len)), (P) += (Len))
-# define memset_zero(P, Len) (memset ((P), '0', (Len)), (P) += (Len))
-# endif
-#endif
-
-#define add(n, f) \
- do \
- { \
- int _n = (n); \
- int _delta = width - _n; \
- int _incr = _n + (_delta > 0 ? _delta : 0); \
- if ((size_t) _incr >= maxsize - i) \
- return 0; \
- if (p) \
- { \
- if (_delta > 0) \
- { \
- if (pad == L_('0')) \
- memset_zero (p, _delta); \
- else \
- memset_space (p, _delta); \
- } \
- f; \
- p += _n; \
- } \
- i += _incr; \
- } while (0)
-
-#define cpy(n, s) \
- add ((n), \
- if (to_lowcase) \
- memcpy_lowcase (p, (s), _n LOCALE_ARG); \
- else if (to_uppcase) \
- memcpy_uppcase (p, (s), _n LOCALE_ARG); \
- else \
- MEMCPY ((PTR) p, (const PTR) (s), _n))
-
-#ifdef COMPILE_WIDE
-# ifndef USE_IN_EXTENDED_LOCALE_MODEL
-# undef __mbsrtowcs_l
-# define __mbsrtowcs_l(d, s, l, st, loc) __mbsrtowcs (d, s, l, st)
-# endif
-# define widen(os, ws, l) \
- { \
- mbstate_t __st; \
- const char *__s = os; \
- memset (&__st, '\0', sizeof (__st)); \
- l = __mbsrtowcs_l (NULL, &__s, 0, &__st, loc); \
- ws = alloca ((l + 1) * sizeof (wchar_t)); \
- (void) __mbsrtowcs_l (ws, &__s, l, &__st, loc); \
- }
-#endif
-
-
-#if defined _LIBC && defined USE_IN_EXTENDED_LOCALE_MODEL
-/* We use this code also for the extended locale handling where the
- function gets as an additional argument the locale which has to be
- used. To access the values we have to redefine the _NL_CURRENT
- macro. */
-# define strftime __strftime_l
-# define wcsftime __wcsftime_l
-# undef _NL_CURRENT
-# define _NL_CURRENT(category, item) \
- (current->values[_NL_ITEM_INDEX (item)].string)
-# define LOCALE_PARAM , loc
-# define LOCALE_ARG , loc
-# define LOCALE_PARAM_DECL __locale_t loc;
-# define LOCALE_PARAM_PROTO , __locale_t loc
-# define HELPER_LOCALE_ARG , current
-#else
-# define LOCALE_PARAM
-# define LOCALE_PARAM_PROTO
-# define LOCALE_ARG
-# define LOCALE_PARAM_DECL
-# ifdef _LIBC
-# define HELPER_LOCALE_ARG , _NL_CURRENT_DATA (LC_TIME)
-# else
-# define HELPER_LOCALE_ARG
-# endif
-#endif
-
-#ifdef COMPILE_WIDE
-# ifdef USE_IN_EXTENDED_LOCALE_MODEL
-# define TOUPPER(Ch, L) __towupper_l (Ch, L)
-# define TOLOWER(Ch, L) __towlower_l (Ch, L)
-# else
-# define TOUPPER(Ch, L) towupper (Ch)
-# define TOLOWER(Ch, L) towlower (Ch)
-# endif
-#else
-# ifdef _LIBC
-# ifdef USE_IN_EXTENDED_LOCALE_MODEL
-# define TOUPPER(Ch, L) __toupper_l (Ch, L)
-# define TOLOWER(Ch, L) __tolower_l (Ch, L)
-# else
-# define TOUPPER(Ch, L) toupper (Ch)
-# define TOLOWER(Ch, L) tolower (Ch)
-# endif
-# else
-# define TOUPPER(Ch, L) (islower (Ch) ? toupper (Ch) : (Ch))
-# define TOLOWER(Ch, L) (isupper (Ch) ? tolower (Ch) : (Ch))
-# endif
-#endif
-/* We don't use `isdigit' here since the locale dependent
- interpretation is not what we want here. We only need to accept
- the arabic digits in the ASCII range. One day there is perhaps a
- more reliable way to accept other sets of digits. */
-#define ISDIGIT(Ch) ((unsigned int) (Ch) - L_('0') <= 9)
-
-static CHAR_T *memcpy_lowcase __P ((CHAR_T *dest, const CHAR_T *src,
- size_t len LOCALE_PARAM_PROTO));
-
-static CHAR_T *
-memcpy_lowcase (dest, src, len LOCALE_PARAM)
- CHAR_T *dest;
- const CHAR_T *src;
- size_t len;
- LOCALE_PARAM_DECL
-{
- while (len-- > 0)
- dest[len] = TOLOWER ((UCHAR_T) src[len], loc);
- return dest;
-}
-
-static CHAR_T *memcpy_uppcase __P ((CHAR_T *dest, const CHAR_T *src,
- size_t len LOCALE_PARAM_PROTO));
-
-static CHAR_T *
-memcpy_uppcase (dest, src, len LOCALE_PARAM)
- CHAR_T *dest;
- const CHAR_T *src;
- size_t len;
- LOCALE_PARAM_DECL
-{
- while (len-- > 0)
- dest[len] = TOUPPER ((UCHAR_T) src[len], loc);
- return dest;
-}
-
-
-#if ! HAVE_TM_GMTOFF
-/* Yield the difference between *A and *B,
- measured in seconds, ignoring leap seconds. */
-# define tm_diff ftime_tm_diff
-static int tm_diff __P ((const struct tm *, const struct tm *));
-static int
-tm_diff (a, b)
- const struct tm *a;
- const struct tm *b;
-{
- /* Compute intervening leap days correctly even if year is negative.
- Take care to avoid int overflow in leap day calculations,
- but it's OK to assume that A and B are close to each other. */
- int a4 = (a->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (a->tm_year & 3);
- int b4 = (b->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (b->tm_year & 3);
- int a100 = a4 / 25 - (a4 % 25 < 0);
- int b100 = b4 / 25 - (b4 % 25 < 0);
- int a400 = a100 >> 2;
- int b400 = b100 >> 2;
- int intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400);
- int years = a->tm_year - b->tm_year;
- int days = (365 * years + intervening_leap_days
- + (a->tm_yday - b->tm_yday));
- return (60 * (60 * (24 * days + (a->tm_hour - b->tm_hour))
- + (a->tm_min - b->tm_min))
- + (a->tm_sec - b->tm_sec));
-}
-#endif /* ! HAVE_TM_GMTOFF */
-
-
-
-/* The number of days from the first day of the first ISO week of this
- year to the year day YDAY with week day WDAY. ISO weeks start on
- Monday; the first ISO week has the year's first Thursday. YDAY may
- be as small as YDAY_MINIMUM. */
-#define ISO_WEEK_START_WDAY 1 /* Monday */
-#define ISO_WEEK1_WDAY 4 /* Thursday */
-#define YDAY_MINIMUM (-366)
-static int iso_week_days __P ((int, int));
-#ifdef __GNUC__
-__inline__
-#endif
-static int
-iso_week_days (yday, wday)
- int yday;
- int wday;
-{
- /* Add enough to the first operand of % to make it nonnegative. */
- int big_enough_multiple_of_7 = (-YDAY_MINIMUM / 7 + 2) * 7;
- return (yday
- - (yday - wday + ISO_WEEK1_WDAY + big_enough_multiple_of_7) % 7
- + ISO_WEEK1_WDAY - ISO_WEEK_START_WDAY);
-}
-
-
-#if !(defined _NL_CURRENT || HAVE_STRFTIME)
-static CHAR_T const weekday_name[][10] =
- {
- L_("Sunday"), L_("Monday"), L_("Tuesday"), L_("Wednesday"),
- L_("Thursday"), L_("Friday"), L_("Saturday")
- };
-static CHAR_T const month_name[][10] =
- {
- L_("January"), L_("February"), L_("March"), L_("April"), L_("May"),
- L_("June"), L_("July"), L_("August"), L_("September"), L_("October"),
- L_("November"), L_("December")
- };
-#endif
-
-
-#ifdef emacs
-# define my_strftime emacs_strftimeu
-# define ut_argument , ut
-# define ut_argument_spec int ut;
-# define ut_argument_spec_iso , int ut
-#else
-# ifdef COMPILE_WIDE
-# define my_strftime wcsftime
-# define nl_get_alt_digit _nl_get_walt_digit
-# else
-# define my_strftime strftime
-# define nl_get_alt_digit _nl_get_alt_digit
-# endif
-# define ut_argument
-# define ut_argument_spec
-# define ut_argument_spec_iso
-/* We don't have this information in general. */
-# define ut 0
-#endif
-
-#if !defined _LIBC && HAVE_TZNAME && HAVE_TZSET
- /* Solaris 2.5 tzset sometimes modifies the storage returned by localtime.
- Work around this bug by copying *tp before it might be munged. */
- size_t _strftime_copytm __P ((char *, size_t, const char *,
- const struct tm * ut_argument_spec_iso));
- size_t
- my_strftime (s, maxsize, format, tp ut_argument)
- CHAR_T *s;
- size_t maxsize;
- const CHAR_T *format;
- const struct tm *tp;
- ut_argument_spec
- {
- struct tm tmcopy;
- tmcopy = *tp;
- return _strftime_copytm (s, maxsize, format, &tmcopy ut_argument);
- }
-# undef my_strftime
-# define my_strftime _strftime_copytm
-#endif
-
-
-/* Write information from TP into S according to the format
- string FORMAT, writing no more that MAXSIZE characters
- (including the terminating '\0') and returning number of
- characters written. If S is NULL, nothing will be written
- anywhere, so to determine how many characters would be
- written, use NULL for S and (size_t) UINT_MAX for MAXSIZE. */
-size_t
-my_strftime (s, maxsize, format, tp ut_argument LOCALE_PARAM)
- CHAR_T *s;
- size_t maxsize;
- const CHAR_T *format;
- const struct tm *tp;
- ut_argument_spec
- LOCALE_PARAM_DECL
-{
-#if defined _LIBC && defined USE_IN_EXTENDED_LOCALE_MODEL
- struct locale_data *const current = loc->__locales[LC_TIME];
-#endif
-
- int hour12 = tp->tm_hour;
-#ifdef _NL_CURRENT
- /* We cannot make the following values variables since we must delay
- the evaluation of these values until really needed since some
- expressions might not be valid in every situation. The `struct tm'
- might be generated by a strptime() call that initialized
- only a few elements. Dereference the pointers only if the format
- requires this. Then it is ok to fail if the pointers are invalid. */
-# define a_wkday \
- ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(ABDAY_1) + tp->tm_wday))
-# define f_wkday \
- ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(DAY_1) + tp->tm_wday))
-# define a_month \
- ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(ABMON_1) + tp->tm_mon))
-# define f_month \
- ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(MON_1) + tp->tm_mon))
-# define ampm \
- ((const CHAR_T *) _NL_CURRENT (LC_TIME, tp->tm_hour > 11 \
- ? NLW(PM_STR) : NLW(AM_STR)))
-
-# define aw_len STRLEN (a_wkday)
-# define am_len STRLEN (a_month)
-# define ap_len STRLEN (ampm)
-#else
-# if !HAVE_STRFTIME
-# define f_wkday (weekday_name[tp->tm_wday])
-# define f_month (month_name[tp->tm_mon])
-# define a_wkday f_wkday
-# define a_month f_month
-# define ampm (L_("AMPM") + 2 * (tp->tm_hour > 11))
-
- size_t aw_len = 3;
- size_t am_len = 3;
- size_t ap_len = 2;
-# endif
-#endif
- const char *zone;
- size_t i = 0;
- CHAR_T *p = s;
- const CHAR_T *f;
-#if DO_MULTIBYTE && !defined COMPILE_WIDE
- const char *format_end = NULL;
-#endif
-
- zone = NULL;
-#if HAVE_TM_ZONE
- /* The POSIX test suite assumes that setting
- the environment variable TZ to a new value before calling strftime()
- will influence the result (the %Z format) even if the information in
- TP is computed with a totally different time zone.
- This is bogus: though POSIX allows bad behavior like this,
- POSIX does not require it. Do the right thing instead. */
- zone = (const char *) tp->tm_zone;
-#endif
-#if HAVE_TZNAME
- if (ut)
- {
- if (! (zone && *zone))
- zone = "GMT";
- }
- else
- {
- /* POSIX.1 requires that local time zone information is used as
- though strftime called tzset. */
-# if HAVE_TZSET
- tzset ();
-# endif
- }
-#endif
-
- if (hour12 > 12)
- hour12 -= 12;
- else
- if (hour12 == 0)
- hour12 = 12;
-
- for (f = format; *f != '\0'; ++f)
- {
- int pad = 0; /* Padding for number ('-', '_', or 0). */
- int modifier; /* Field modifier ('E', 'O', or 0). */
- int digits; /* Max digits for numeric format. */
- int number_value; /* Numeric value to be printed. */
- int negative_number; /* 1 if the number is negative. */
- const CHAR_T *subfmt;
- CHAR_T *bufp;
- CHAR_T buf[1 + (sizeof (int) < sizeof (time_t)
- ? INT_STRLEN_BOUND (time_t)
- : INT_STRLEN_BOUND (int))];
- int width = -1;
- int to_lowcase = 0;
- int to_uppcase = 0;
- int change_case = 0;
- int format_char;
-
-#if DO_MULTIBYTE && !defined COMPILE_WIDE
- switch (*f)
- {
- case L_('%'):
- break;
-
- case L_('\b'): case L_('\t'): case L_('\n'):
- case L_('\v'): case L_('\f'): case L_('\r'):
- case L_(' '): case L_('!'): case L_('"'): case L_('#'): case L_('&'):
- case L_('\''): case L_('('): case L_(')'): case L_('*'): case L_('+'):
- case L_(','): case L_('-'): case L_('.'): case L_('/'): case L_('0'):
- case L_('1'): case L_('2'): case L_('3'): case L_('4'): case L_('5'):
- case L_('6'): case L_('7'): case L_('8'): case L_('9'): case L_(':'):
- case L_(';'): case L_('<'): case L_('='): case L_('>'): case L_('?'):
- case L_('A'): case L_('B'): case L_('C'): case L_('D'): case L_('E'):
- case L_('F'): case L_('G'): case L_('H'): case L_('I'): case L_('J'):
- case L_('K'): case L_('L'): case L_('M'): case L_('N'): case L_('O'):
- case L_('P'): case L_('Q'): case L_('R'): case L_('S'): case L_('T'):
- case L_('U'): case L_('V'): case L_('W'): case L_('X'): case L_('Y'):
- case L_('Z'): case L_('['): case L_('\\'): case L_(']'): case L_('^'):
- case L_('_'): case L_('a'): case L_('b'): case L_('c'): case L_('d'):
- case L_('e'): case L_('f'): case L_('g'): case L_('h'): case L_('i'):
- case L_('j'): case L_('k'): case L_('l'): case L_('m'): case L_('n'):
- case L_('o'): case L_('p'): case L_('q'): case L_('r'): case L_('s'):
- case L_('t'): case L_('u'): case L_('v'): case L_('w'): case L_('x'):
- case L_('y'): case L_('z'): case L_('{'): case L_('|'): case L_('}'):
- case L_('~'):
- /* The C Standard requires these 98 characters (plus '%') to
- be in the basic execution character set. None of these
- characters can start a multibyte sequence, so they need
- not be analyzed further. */
- add (1, *p = *f);
- continue;
-
- default:
- /* Copy this multibyte sequence until we reach its end, find
- an error, or come back to the initial shift state. */
- {
- mbstate_t mbstate = mbstate_zero;
- size_t len = 0;
- size_t fsize;
-
- if (! format_end)
- format_end = f + strlen (f) + 1;
- fsize = format_end - f;
-
- do
- {
- size_t bytes = mbrlen (f + len, fsize - len, &mbstate);
-
- if (bytes == 0)
- break;
-
- if (bytes == (size_t) -2)
- {
- len += strlen (f + len);
- break;
- }
-
- if (bytes == (size_t) -1)
- {
- len++;
- break;
- }
-
- len += bytes;
- }
- while (! mbsinit (&mbstate));
-
- cpy (len, f);
- f += len - 1;
- continue;
- }
- }
-
-#else /* ! DO_MULTIBYTE */
-
- /* Either multibyte encodings are not supported, they are
- safe for formats, so any non-'%' byte can be copied through,
- or this is the wide character version. */
- if (*f != L_('%'))
- {
- add (1, *p = *f);
- continue;
- }
-
-#endif /* ! DO_MULTIBYTE */
-
- /* Check for flags that can modify a format. */
- while (1)
- {
- switch (*++f)
- {
- /* This influences the number formats. */
- case L_('_'):
- case L_('-'):
- case L_('0'):
- pad = *f;
- continue;
-
- /* This changes textual output. */
- case L_('^'):
- to_uppcase = 1;
- continue;
- case L_('#'):
- change_case = 1;
- continue;
-
- default:
- break;
- }
- break;
- }
-
- /* As a GNU extension we allow to specify the field width. */
- if (ISDIGIT (*f))
- {
- width = 0;
- do
- {
- if (width > INT_MAX / 10
- || (width == INT_MAX / 10 && *f - L_('0') > INT_MAX % 10))
- /* Avoid overflow. */
- width = INT_MAX;
- else
- {
- width *= 10;
- width += *f - L_('0');
- }
- ++f;
- }
- while (ISDIGIT (*f));
- }
-
- /* Check for modifiers. */
- switch (*f)
- {
- case L_('E'):
- case L_('O'):
- modifier = *f++;
- break;
-
- default:
- modifier = 0;
- break;
- }
-
- /* Now do the specified format. */
- format_char = *f;
- switch (format_char)
- {
-#define DO_NUMBER(d, v) \
- digits = d > width ? d : width; \
- number_value = v; goto do_number
-#define DO_NUMBER_SPACEPAD(d, v) \
- digits = d > width ? d : width; \
- number_value = v; goto do_number_spacepad
-
- case L_('%'):
- if (modifier != 0)
- goto bad_format;
- add (1, *p = *f);
- break;
-
- case L_('a'):
- if (modifier != 0)
- goto bad_format;
- if (change_case)
- {
- to_uppcase = 1;
- to_lowcase = 0;
- }
-#if defined _NL_CURRENT || !HAVE_STRFTIME
- cpy (aw_len, a_wkday);
- break;
-#else
- goto underlying_strftime;
-#endif
-
- case 'A':
- if (modifier != 0)
- goto bad_format;
- if (change_case)
- {
- to_uppcase = 1;
- to_lowcase = 0;
- }
-#if defined _NL_CURRENT || !HAVE_STRFTIME
- cpy (STRLEN (f_wkday), f_wkday);
- break;
-#else
- goto underlying_strftime;
-#endif
-
- case L_('b'):
- case L_('h'):
- if (change_case)
- {
- to_uppcase = 1;
- to_lowcase = 0;
- }
- if (modifier != 0)
- goto bad_format;
-#if defined _NL_CURRENT || !HAVE_STRFTIME
- cpy (am_len, a_month);
- break;
-#else
- goto underlying_strftime;
-#endif
-
- case L_('B'):
- if (modifier != 0)
- goto bad_format;
- if (change_case)
- {
- to_uppcase = 1;
- to_lowcase = 0;
- }
-#if defined _NL_CURRENT || !HAVE_STRFTIME
- cpy (STRLEN (f_month), f_month);
- break;
-#else
- goto underlying_strftime;
-#endif
-
- case L_('c'):
- if (modifier == L_('O'))
- goto bad_format;
-#ifdef _NL_CURRENT
- if (! (modifier == 'E'
- && (*(subfmt =
- (const CHAR_T *) _NL_CURRENT (LC_TIME,
- NLW(ERA_D_T_FMT)))
- != '\0')))
- subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(D_T_FMT));
-#else
-# if HAVE_STRFTIME
- goto underlying_strftime;
-# else
- subfmt = L_("%a %b %e %H:%M:%S %Y");
-# endif
-#endif
-
- subformat:
- {
- CHAR_T *old_start = p;
- size_t len = my_strftime (NULL, (size_t) -1, subfmt,
- tp ut_argument LOCALE_ARG);
- add (len, my_strftime (p, maxsize - i, subfmt,
- tp ut_argument LOCALE_ARG));
-
- if (to_uppcase)
- while (old_start < p)
- {
- *old_start = TOUPPER ((UCHAR_T) *old_start, loc);
- ++old_start;
- }
- }
- break;
-
-#if HAVE_STRFTIME && ! (defined _NL_CURRENT && HAVE_STRUCT_ERA_ENTRY)
- underlying_strftime:
- {
- /* The relevant information is available only via the
- underlying strftime implementation, so use that. */
- char ufmt[4];
- char *u = ufmt;
- char ubuf[1024]; /* enough for any single format in practice */
- size_t len;
- /* Make sure we're calling the actual underlying strftime.
- In some cases, config.h contains something like
- "#define strftime rpl_strftime". */
-# ifdef strftime
-# undef strftime
- size_t strftime ();
-# endif
-
- *u++ = '%';
- if (modifier != 0)
- *u++ = modifier;
- *u++ = format_char;
- *u = '\0';
- len = strftime (ubuf, sizeof ubuf, ufmt, tp);
- if (len == 0 && ubuf[0] != '\0')
- return 0;
- cpy (len, ubuf);
- }
- break;
-#endif
-
- case L_('C'):
- if (modifier == L_('O'))
- goto bad_format;
- if (modifier == L_('E'))
- {
-#if HAVE_STRUCT_ERA_ENTRY
- struct era_entry *era = _nl_get_era_entry (tp HELPER_LOCALE_ARG);
- if (era)
- {
-# ifdef COMPILE_WIDE
- size_t len = __wcslen (era->era_wname);
- cpy (len, era->era_wname);
-# else
- size_t len = strlen (era->era_name);
- cpy (len, era->era_name);
-# endif
- break;
- }
-#else
-# if HAVE_STRFTIME
- goto underlying_strftime;
-# endif
-#endif
- }
-
- {
- int year = tp->tm_year + TM_YEAR_BASE;
- DO_NUMBER (1, year / 100 - (year % 100 < 0));
- }
-
- case L_('x'):
- if (modifier == L_('O'))
- goto bad_format;
-#ifdef _NL_CURRENT
- if (! (modifier == L_('E')
- && (*(subfmt =
- (const CHAR_T *)_NL_CURRENT (LC_TIME, NLW(ERA_D_FMT)))
- != L_('\0'))))
- subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(D_FMT));
- goto subformat;
-#else
-# if HAVE_STRFTIME
- goto underlying_strftime;
-# else
- /* Fall through. */
-# endif
-#endif
- case L_('D'):
- if (modifier != 0)
- goto bad_format;
- subfmt = L_("%m/%d/%y");
- goto subformat;
-
- case L_('d'):
- if (modifier == L_('E'))
- goto bad_format;
-
- DO_NUMBER (2, tp->tm_mday);
-
- case L_('e'):
- if (modifier == L_('E'))
- goto bad_format;
-
- DO_NUMBER_SPACEPAD (2, tp->tm_mday);
-
- /* All numeric formats set DIGITS and NUMBER_VALUE and then
- jump to one of these two labels. */
-
- do_number_spacepad:
- /* Force `_' flag unless overwritten by `0' or '-' flag. */
- if (pad != L_('0') && pad != L_('-'))
- pad = L_('_');
-
- do_number:
- /* Format the number according to the MODIFIER flag. */
-
- if (modifier == L_('O') && 0 <= number_value)
- {
-#ifdef _NL_CURRENT
- /* Get the locale specific alternate representation of
- the number NUMBER_VALUE. If none exist NULL is returned. */
- const CHAR_T *cp = nl_get_alt_digit (number_value
- HELPER_LOCALE_ARG);
-
- if (cp != NULL)
- {
- size_t digitlen = STRLEN (cp);
- if (digitlen != 0)
- {
- cpy (digitlen, cp);
- break;
- }
- }
-#else
-# if HAVE_STRFTIME
- goto underlying_strftime;
-# endif
-#endif
- }
- {
- unsigned int u = number_value;
-
- bufp = buf + sizeof (buf) / sizeof (buf[0]);
- negative_number = number_value < 0;
-
- if (negative_number)
- u = -u;
-
- do
- *--bufp = u % 10 + L_('0');
- while ((u /= 10) != 0);
- }
-
- do_number_sign_and_padding:
- if (negative_number)
- *--bufp = L_('-');
-
- if (pad != L_('-'))
- {
- int padding = digits - (buf + (sizeof (buf) / sizeof (buf[0]))
- - bufp);
-
- if (padding > 0)
- {
- if (pad == L_('_'))
- {
- if ((size_t) padding >= maxsize - i)
- return 0;
-
- if (p)
- memset_space (p, padding);
- i += padding;
- width = width > padding ? width - padding : 0;
- }
- else
- {
- if ((size_t) digits >= maxsize - i)
- return 0;
-
- if (negative_number)
- {
- ++bufp;
-
- if (p)
- *p++ = L_('-');
- ++i;
- }
-
- if (p)
- memset_zero (p, padding);
- i += padding;
- width = 0;
- }
- }
- }
-
- cpy (buf + sizeof (buf) / sizeof (buf[0]) - bufp, bufp);
- break;
-
- case L_('F'):
- if (modifier != 0)
- goto bad_format;
- subfmt = L_("%Y-%m-%d");
- goto subformat;
-
- case L_('H'):
- if (modifier == L_('E'))
- goto bad_format;
-
- DO_NUMBER (2, tp->tm_hour);
-
- case L_('I'):
- if (modifier == L_('E'))
- goto bad_format;
-
- DO_NUMBER (2, hour12);
-
- case L_('k'): /* GNU extension. */
- if (modifier == L_('E'))
- goto bad_format;
-
- DO_NUMBER_SPACEPAD (2, tp->tm_hour);
-
- case L_('l'): /* GNU extension. */
- if (modifier == L_('E'))
- goto bad_format;
-
- DO_NUMBER_SPACEPAD (2, hour12);
-
- case L_('j'):
- if (modifier == L_('E'))
- goto bad_format;
-
- DO_NUMBER (3, 1 + tp->tm_yday);
-
- case L_('M'):
- if (modifier == L_('E'))
- goto bad_format;
-
- DO_NUMBER (2, tp->tm_min);
-
- case L_('m'):
- if (modifier == L_('E'))
- goto bad_format;
-
- DO_NUMBER (2, tp->tm_mon + 1);
-
- case L_('n'):
- add (1, *p = L_('\n'));
- break;
-
- case L_('P'):
- to_lowcase = 1;
-#if !defined _NL_CURRENT && HAVE_STRFTIME
- format_char = L_('p');
-#endif
- /* FALLTHROUGH */
-
- case L_('p'):
- if (change_case)
- {
- to_uppcase = 0;
- to_lowcase = 1;
- }
-#if defined _NL_CURRENT || !HAVE_STRFTIME
- cpy (ap_len, ampm);
- break;
-#else
- goto underlying_strftime;
-#endif
-
- case L_('R'):
- subfmt = L_("%H:%M");
- goto subformat;
-
- case L_('r'):
-#if !defined _NL_CURRENT && HAVE_STRFTIME
- goto underlying_strftime;
-#else
-# ifdef _NL_CURRENT
- if (*(subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME,
- NLW(T_FMT_AMPM)))
- == L_('\0'))
-# endif
- subfmt = L_("%I:%M:%S %p");
- goto subformat;
-#endif
-
- case L_('S'):
- if (modifier == L_('E'))
- goto bad_format;
-
- DO_NUMBER (2, tp->tm_sec);
-
- case L_('s'): /* GNU extension. */
- {
- struct tm ltm;
- time_t t;
-
- ltm = *tp;
- t = mktime (<m);
-
- /* Generate string value for T using time_t arithmetic;
- this works even if sizeof (long) < sizeof (time_t). */
-
- bufp = buf + sizeof (buf) / sizeof (buf[0]);
- negative_number = t < 0;
-
- do
- {
- int d = t % 10;
- t /= 10;
-
- if (negative_number)
- {
- d = -d;
-
- /* Adjust if division truncates to minus infinity. */
- if (0 < -1 % 10 && d < 0)
- {
- t++;
- d += 10;
- }
- }
-
- *--bufp = d + L_('0');
- }
- while (t != 0);
-
- digits = 1;
- goto do_number_sign_and_padding;
- }
-
- case L_('X'):
- if (modifier == L_('O'))
- goto bad_format;
-#ifdef _NL_CURRENT
- if (! (modifier == L_('E')
- && (*(subfmt =
- (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(ERA_T_FMT)))
- != L_('\0'))))
- subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(T_FMT));
- goto subformat;
-#else
-# if HAVE_STRFTIME
- goto underlying_strftime;
-# else
- /* Fall through. */
-# endif
-#endif
- case L_('T'):
- subfmt = L_("%H:%M:%S");
- goto subformat;
-
- case L_('t'):
- add (1, *p = L_('\t'));
- break;
-
- case L_('u'):
- DO_NUMBER (1, (tp->tm_wday - 1 + 7) % 7 + 1);
-
- case L_('U'):
- if (modifier == L_('E'))
- goto bad_format;
-
- DO_NUMBER (2, (tp->tm_yday - tp->tm_wday + 7) / 7);
-
- case L_('V'):
- case L_('g'):
- case L_('G'):
- if (modifier == L_('E'))
- goto bad_format;
- {
- int year = tp->tm_year + TM_YEAR_BASE;
- int days = iso_week_days (tp->tm_yday, tp->tm_wday);
-
- if (days < 0)
- {
- /* This ISO week belongs to the previous year. */
- year--;
- days = iso_week_days (tp->tm_yday + (365 + __isleap (year)),
- tp->tm_wday);
- }
- else
- {
- int d = iso_week_days (tp->tm_yday - (365 + __isleap (year)),
- tp->tm_wday);
- if (0 <= d)
- {
- /* This ISO week belongs to the next year. */
- year++;
- days = d;
- }
- }
-
- switch (*f)
- {
- case L_('g'):
- DO_NUMBER (2, (year % 100 + 100) % 100);
-
- case L_('G'):
- DO_NUMBER (1, year);
-
- default:
- DO_NUMBER (2, days / 7 + 1);
- }
- }
-
- case L_('W'):
- if (modifier == L_('E'))
- goto bad_format;
-
- DO_NUMBER (2, (tp->tm_yday - (tp->tm_wday - 1 + 7) % 7 + 7) / 7);
-
- case L_('w'):
- if (modifier == L_('E'))
- goto bad_format;
-
- DO_NUMBER (1, tp->tm_wday);
-
- case L_('Y'):
- if (modifier == 'E')
- {
-#if HAVE_STRUCT_ERA_ENTRY
- struct era_entry *era = _nl_get_era_entry (tp HELPER_LOCALE_ARG);
- if (era)
- {
-# ifdef COMPILE_WIDE
- subfmt = era->era_wformat;
-# else
- subfmt = era->era_format;
-# endif
- goto subformat;
- }
-#else
-# if HAVE_STRFTIME
- goto underlying_strftime;
-# endif
-#endif
- }
- if (modifier == L_('O'))
- goto bad_format;
- else
- DO_NUMBER (1, tp->tm_year + TM_YEAR_BASE);
-
- case L_('y'):
- if (modifier == L_('E'))
- {
-#if HAVE_STRUCT_ERA_ENTRY
- struct era_entry *era = _nl_get_era_entry (tp HELPER_LOCALE_ARG);
- if (era)
- {
- int delta = tp->tm_year - era->start_date[0];
- DO_NUMBER (1, (era->offset
- + delta * era->absolute_direction));
- }
-#else
-# if HAVE_STRFTIME
- goto underlying_strftime;
-# endif
-#endif
- }
- DO_NUMBER (2, (tp->tm_year % 100 + 100) % 100);
-
- case L_('Z'):
- if (change_case)
- {
- to_uppcase = 0;
- to_lowcase = 1;
- }
-
-#if HAVE_TZNAME
- /* The tzset() call might have changed the value. */
- if (!(zone && *zone) && tp->tm_isdst >= 0)
- zone = tzname[tp->tm_isdst];
-#endif
- if (! zone)
- zone = "";
-
-#ifdef COMPILE_WIDE
- {
- /* The zone string is always given in multibyte form. We have
- to transform it first. */
- wchar_t *wczone;
- size_t len;
- widen (zone, wczone, len);
- cpy (len, wczone);
- }
-#else
- cpy (strlen (zone), zone);
-#endif
- break;
-
- case L_('z'):
- if (tp->tm_isdst < 0)
- break;
-
- {
- int diff;
-#if HAVE_TM_GMTOFF
- diff = tp->tm_gmtoff;
-#else
- if (ut)
- diff = 0;
- else
- {
- struct tm gtm;
- struct tm ltm;
- time_t lt;
-
- ltm = *tp;
- lt = mktime (<m);
-
- if (lt == (time_t) -1)
- {
- /* mktime returns -1 for errors, but -1 is also a
- valid time_t value. Check whether an error really
- occurred. */
- struct tm tm;
-
- if (! __localtime_r (<, &tm)
- || ((ltm.tm_sec ^ tm.tm_sec)
- | (ltm.tm_min ^ tm.tm_min)
- | (ltm.tm_hour ^ tm.tm_hour)
- | (ltm.tm_mday ^ tm.tm_mday)
- | (ltm.tm_mon ^ tm.tm_mon)
- | (ltm.tm_year ^ tm.tm_year)))
- break;
- }
-
- if (! __gmtime_r (<, >m))
- break;
-
- diff = tm_diff (<m, >m);
- }
-#endif
-
- if (diff < 0)
- {
- add (1, *p = L_('-'));
- diff = -diff;
- }
- else
- add (1, *p = L_('+'));
-
- diff /= 60;
- DO_NUMBER (4, (diff / 60) * 100 + diff % 60);
- }
-
- case L_('\0'): /* GNU extension: % at end of format. */
- --f;
- /* Fall through. */
- default:
- /* Unknown format; output the format, including the '%',
- since this is most likely the right thing to do if a
- multibyte string has been misparsed. */
- bad_format:
- {
- int flen;
- for (flen = 1; f[1 - flen] != L_('%'); flen++)
- continue;
- cpy (flen, &f[1 - flen]);
- }
- break;
- }
- }
-
- if (p && maxsize != 0)
- *p = L_('\0');
- return i;
-}
-#ifdef _LIBC
-libc_hidden_def (my_strftime)
-#endif
-
-
-#ifdef emacs
-/* For Emacs we have a separate interface which corresponds to the normal
- strftime function and does not have the extra information whether the
- TP arguments comes from a `gmtime' call or not. */
size_t
-emacs_strftime (s, maxsize, format, tp)
- char *s;
- size_t maxsize;
- const char *format;
- const struct tm *tp;
+strftime (char *s, size_t maxsize, const char *format, const struct tm *tp)
{
- return my_strftime (s, maxsize, format, tp, 0);
+ return __strftime_l (s, maxsize, format, tp, _NL_CURRENT_LOCALE);
}
-#endif
+libc_hidden_def (strftime)
-/* Copyright (C) 2002 Free Software Foundation, Inc.
+/* Copyright (C) 2002, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
-#define USE_IN_EXTENDED_LOCALE_MODEL 1
-#include <strftime.c>
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+#ifdef _LIBC
+# define USE_IN_EXTENDED_LOCALE_MODEL 1
+# define HAVE_LIMITS_H 1
+# define HAVE_MBLEN 1
+# define HAVE_MBRLEN 1
+# define HAVE_STRUCT_ERA_ENTRY 1
+# define HAVE_TM_GMTOFF 1
+# define HAVE_TM_ZONE 1
+# define HAVE_TZNAME 1
+# define HAVE_TZSET 1
+# define MULTIBYTE_IS_FORMAT_SAFE 1
+# define STDC_HEADERS 1
+# include "../locale/localeinfo.h"
+#endif
+
+#if defined emacs && !defined HAVE_BCOPY
+# define HAVE_MEMCPY 1
+#endif
+
+#include <ctype.h>
+#include <sys/types.h> /* Some systems define `time_t' here. */
+
+#ifdef TIME_WITH_SYS_TIME
+# include <sys/time.h>
+# include <time.h>
+#else
+# ifdef HAVE_SYS_TIME_H
+# include <sys/time.h>
+# else
+# include <time.h>
+# endif
+#endif
+#if HAVE_TZNAME
+extern char *tzname[];
+#endif
+
+/* Do multibyte processing if multibytes are supported, unless
+ multibyte sequences are safe in formats. Multibyte sequences are
+ safe if they cannot contain byte sequences that look like format
+ conversion specifications. The GNU C Library uses UTF8 multibyte
+ encoding, which is safe for formats, but strftime.c can be used
+ with other C libraries that use unsafe encodings. */
+#define DO_MULTIBYTE (HAVE_MBLEN && ! MULTIBYTE_IS_FORMAT_SAFE)
+
+#if DO_MULTIBYTE
+# if HAVE_MBRLEN
+# include <wchar.h>
+# else
+ /* Simulate mbrlen with mblen as best we can. */
+# define mbstate_t int
+# define mbrlen(s, n, ps) mblen (s, n)
+# define mbsinit(ps) (*(ps) == 0)
+# endif
+ static const mbstate_t mbstate_zero;
+#endif
+
+#if HAVE_LIMITS_H
+# include <limits.h>
+#endif
+
+#if STDC_HEADERS
+# include <stddef.h>
+# include <stdlib.h>
+# include <string.h>
+#else
+# ifndef HAVE_MEMCPY
+# define memcpy(d, s, n) bcopy ((s), (d), (n))
+# endif
+#endif
+
+#ifdef COMPILE_WIDE
+# include <endian.h>
+# define CHAR_T wchar_t
+# define UCHAR_T unsigned int
+# define L_(Str) L##Str
+# define NLW(Sym) _NL_W##Sym
+
+# define MEMCPY(d, s, n) __wmemcpy (d, s, n)
+# define STRLEN(s) __wcslen (s)
+
+#else
+# define CHAR_T char
+# define UCHAR_T unsigned char
+# define L_(Str) Str
+# define NLW(Sym) Sym
+
+# if !defined STDC_HEADERS && !defined HAVE_MEMCPY
+# define MEMCPY(d, s, n) bcopy ((s), (d), (n))
+# else
+# define MEMCPY(d, s, n) memcpy ((d), (s), (n))
+# endif
+# define STRLEN(s) strlen (s)
+
+# ifdef _LIBC
+# define MEMPCPY(d, s, n) __mempcpy (d, s, n)
+# else
+# ifndef HAVE_MEMPCPY
+# define MEMPCPY(d, s, n) ((void *) ((char *) memcpy (d, s, n) + (n)))
+# endif
+# endif
+#endif
+
+#ifndef __P
+# if defined __GNUC__ || (defined __STDC__ && __STDC__)
+# define __P(args) args
+# else
+# define __P(args) ()
+# endif /* GCC. */
+#endif /* Not __P. */
+
+#ifndef PTR
+# ifdef __STDC__
+# define PTR void *
+# else
+# define PTR char *
+# endif
+#endif
+
+#ifndef CHAR_BIT
+# define CHAR_BIT 8
+#endif
+
+#ifndef NULL
+# define NULL 0
+#endif
+
+#define TYPE_SIGNED(t) ((t) -1 < 0)
+
+/* Bound on length of the string representing an integer value of type t.
+ Subtract one for the sign bit if t is signed;
+ 302 / 1000 is log10 (2) rounded up;
+ add one for integer division truncation;
+ add one more for a minus sign if t is signed. */
+#define INT_STRLEN_BOUND(t) \
+ ((sizeof (t) * CHAR_BIT - TYPE_SIGNED (t)) * 302 / 1000 + 1 + TYPE_SIGNED (t))
+
+#define TM_YEAR_BASE 1900
+
+#ifndef __isleap
+/* Nonzero if YEAR is a leap year (every 4 years,
+ except every 100th isn't, and every 400th is). */
+# define __isleap(year) \
+ ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
+#endif
+
+
+#ifdef _LIBC
+# define tzname __tzname
+# define tzset __tzset
+#endif
+
+#if !HAVE_TM_GMTOFF
+/* Portable standalone applications should supply a "time_r.h" that
+ declares a POSIX-compliant localtime_r, for the benefit of older
+ implementations that lack localtime_r or have a nonstandard one.
+ Similarly for gmtime_r. See the gnulib time_r module for one way
+ to implement this. */
+# include "time_r.h"
+# undef __gmtime_r
+# undef __localtime_r
+# define __gmtime_r gmtime_r
+# define __localtime_r localtime_r
+#endif
+
+
+#if !defined memset && !defined HAVE_MEMSET && !defined _LIBC
+/* Some systems lack the `memset' function and we don't want to
+ introduce additional dependencies. */
+/* The SGI compiler reportedly barfs on the trailing null
+ if we use a string constant as the initializer. 28 June 1997, rms. */
+static const CHAR_T spaces[16] = /* " " */
+{
+ L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),
+ L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' ')
+};
+static const CHAR_T zeroes[16] = /* "0000000000000000" */
+{
+ L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),
+ L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0')
+};
+
+# define memset_space(P, Len) \
+ do { \
+ int _len = (Len); \
+ \
+ do \
+ { \
+ int _this = _len > 16 ? 16 : _len; \
+ (P) = MEMPCPY ((P), spaces, _this * sizeof (CHAR_T)); \
+ _len -= _this; \
+ } \
+ while (_len > 0); \
+ } while (0)
+
+# define memset_zero(P, Len) \
+ do { \
+ int _len = (Len); \
+ \
+ do \
+ { \
+ int _this = _len > 16 ? 16 : _len; \
+ (P) = MEMPCPY ((P), zeroes, _this * sizeof (CHAR_T)); \
+ _len -= _this; \
+ } \
+ while (_len > 0); \
+ } while (0)
+#else
+# ifdef COMPILE_WIDE
+# define memset_space(P, Len) (wmemset ((P), L' ', (Len)), (P) += (Len))
+# define memset_zero(P, Len) (wmemset ((P), L'0', (Len)), (P) += (Len))
+# else
+# define memset_space(P, Len) (memset ((P), ' ', (Len)), (P) += (Len))
+# define memset_zero(P, Len) (memset ((P), '0', (Len)), (P) += (Len))
+# endif
+#endif
+
+#define add(n, f) \
+ do \
+ { \
+ int _n = (n); \
+ int _delta = width - _n; \
+ int _incr = _n + (_delta > 0 ? _delta : 0); \
+ if ((size_t) _incr >= maxsize - i) \
+ return 0; \
+ if (p) \
+ { \
+ if (_delta > 0) \
+ { \
+ if (pad == L_('0')) \
+ memset_zero (p, _delta); \
+ else \
+ memset_space (p, _delta); \
+ } \
+ f; \
+ p += _n; \
+ } \
+ i += _incr; \
+ } while (0)
+
+#define cpy(n, s) \
+ add ((n), \
+ if (to_lowcase) \
+ memcpy_lowcase (p, (s), _n LOCALE_ARG); \
+ else if (to_uppcase) \
+ memcpy_uppcase (p, (s), _n LOCALE_ARG); \
+ else \
+ MEMCPY ((PTR) p, (const PTR) (s), _n))
+
+#ifdef COMPILE_WIDE
+# ifndef USE_IN_EXTENDED_LOCALE_MODEL
+# undef __mbsrtowcs_l
+# define __mbsrtowcs_l(d, s, l, st, loc) __mbsrtowcs (d, s, l, st)
+# endif
+# define widen(os, ws, l) \
+ { \
+ mbstate_t __st; \
+ const char *__s = os; \
+ memset (&__st, '\0', sizeof (__st)); \
+ l = __mbsrtowcs_l (NULL, &__s, 0, &__st, loc); \
+ ws = alloca ((l + 1) * sizeof (wchar_t)); \
+ (void) __mbsrtowcs_l (ws, &__s, l, &__st, loc); \
+ }
+#endif
+
+
+#if defined _LIBC && defined USE_IN_EXTENDED_LOCALE_MODEL
+/* We use this code also for the extended locale handling where the
+ function gets as an additional argument the locale which has to be
+ used. To access the values we have to redefine the _NL_CURRENT
+ macro. */
+# define strftime __strftime_l
+# define wcsftime __wcsftime_l
+# undef _NL_CURRENT
+# define _NL_CURRENT(category, item) \
+ (current->values[_NL_ITEM_INDEX (item)].string)
+# define LOCALE_PARAM , loc
+# define LOCALE_ARG , loc
+# define LOCALE_PARAM_DECL __locale_t loc;
+# define LOCALE_PARAM_PROTO , __locale_t loc
+# define HELPER_LOCALE_ARG , current
+#else
+# define LOCALE_PARAM
+# define LOCALE_PARAM_PROTO
+# define LOCALE_ARG
+# define LOCALE_PARAM_DECL
+# ifdef _LIBC
+# define HELPER_LOCALE_ARG , _NL_CURRENT_DATA (LC_TIME)
+# else
+# define HELPER_LOCALE_ARG
+# endif
+#endif
+
+#ifdef COMPILE_WIDE
+# ifdef USE_IN_EXTENDED_LOCALE_MODEL
+# define TOUPPER(Ch, L) __towupper_l (Ch, L)
+# define TOLOWER(Ch, L) __towlower_l (Ch, L)
+# else
+# define TOUPPER(Ch, L) towupper (Ch)
+# define TOLOWER(Ch, L) towlower (Ch)
+# endif
+#else
+# ifdef _LIBC
+# ifdef USE_IN_EXTENDED_LOCALE_MODEL
+# define TOUPPER(Ch, L) __toupper_l (Ch, L)
+# define TOLOWER(Ch, L) __tolower_l (Ch, L)
+# else
+# define TOUPPER(Ch, L) toupper (Ch)
+# define TOLOWER(Ch, L) tolower (Ch)
+# endif
+# else
+# define TOUPPER(Ch, L) (islower (Ch) ? toupper (Ch) : (Ch))
+# define TOLOWER(Ch, L) (isupper (Ch) ? tolower (Ch) : (Ch))
+# endif
+#endif
+/* We don't use `isdigit' here since the locale dependent
+ interpretation is not what we want here. We only need to accept
+ the arabic digits in the ASCII range. One day there is perhaps a
+ more reliable way to accept other sets of digits. */
+#define ISDIGIT(Ch) ((unsigned int) (Ch) - L_('0') <= 9)
+
+static CHAR_T *memcpy_lowcase __P ((CHAR_T *dest, const CHAR_T *src,
+ size_t len LOCALE_PARAM_PROTO));
+
+static CHAR_T *
+memcpy_lowcase (dest, src, len LOCALE_PARAM)
+ CHAR_T *dest;
+ const CHAR_T *src;
+ size_t len;
+ LOCALE_PARAM_DECL
+{
+ while (len-- > 0)
+ dest[len] = TOLOWER ((UCHAR_T) src[len], loc);
+ return dest;
+}
+
+static CHAR_T *memcpy_uppcase __P ((CHAR_T *dest, const CHAR_T *src,
+ size_t len LOCALE_PARAM_PROTO));
+
+static CHAR_T *
+memcpy_uppcase (dest, src, len LOCALE_PARAM)
+ CHAR_T *dest;
+ const CHAR_T *src;
+ size_t len;
+ LOCALE_PARAM_DECL
+{
+ while (len-- > 0)
+ dest[len] = TOUPPER ((UCHAR_T) src[len], loc);
+ return dest;
+}
+
+
+#if ! HAVE_TM_GMTOFF
+/* Yield the difference between *A and *B,
+ measured in seconds, ignoring leap seconds. */
+# define tm_diff ftime_tm_diff
+static int tm_diff __P ((const struct tm *, const struct tm *));
+static int
+tm_diff (a, b)
+ const struct tm *a;
+ const struct tm *b;
+{
+ /* Compute intervening leap days correctly even if year is negative.
+ Take care to avoid int overflow in leap day calculations,
+ but it's OK to assume that A and B are close to each other. */
+ int a4 = (a->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (a->tm_year & 3);
+ int b4 = (b->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (b->tm_year & 3);
+ int a100 = a4 / 25 - (a4 % 25 < 0);
+ int b100 = b4 / 25 - (b4 % 25 < 0);
+ int a400 = a100 >> 2;
+ int b400 = b100 >> 2;
+ int intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400);
+ int years = a->tm_year - b->tm_year;
+ int days = (365 * years + intervening_leap_days
+ + (a->tm_yday - b->tm_yday));
+ return (60 * (60 * (24 * days + (a->tm_hour - b->tm_hour))
+ + (a->tm_min - b->tm_min))
+ + (a->tm_sec - b->tm_sec));
+}
+#endif /* ! HAVE_TM_GMTOFF */
+
+
+
+/* The number of days from the first day of the first ISO week of this
+ year to the year day YDAY with week day WDAY. ISO weeks start on
+ Monday; the first ISO week has the year's first Thursday. YDAY may
+ be as small as YDAY_MINIMUM. */
+#define ISO_WEEK_START_WDAY 1 /* Monday */
+#define ISO_WEEK1_WDAY 4 /* Thursday */
+#define YDAY_MINIMUM (-366)
+static int iso_week_days __P ((int, int));
+#ifdef __GNUC__
+__inline__
+#endif
+static int
+iso_week_days (yday, wday)
+ int yday;
+ int wday;
+{
+ /* Add enough to the first operand of % to make it nonnegative. */
+ int big_enough_multiple_of_7 = (-YDAY_MINIMUM / 7 + 2) * 7;
+ return (yday
+ - (yday - wday + ISO_WEEK1_WDAY + big_enough_multiple_of_7) % 7
+ + ISO_WEEK1_WDAY - ISO_WEEK_START_WDAY);
+}
+
+
+#if !(defined _NL_CURRENT || HAVE_STRFTIME)
+static CHAR_T const weekday_name[][10] =
+ {
+ L_("Sunday"), L_("Monday"), L_("Tuesday"), L_("Wednesday"),
+ L_("Thursday"), L_("Friday"), L_("Saturday")
+ };
+static CHAR_T const month_name[][10] =
+ {
+ L_("January"), L_("February"), L_("March"), L_("April"), L_("May"),
+ L_("June"), L_("July"), L_("August"), L_("September"), L_("October"),
+ L_("November"), L_("December")
+ };
+#endif
+
+
+#ifdef emacs
+# define my_strftime emacs_strftimeu
+# define ut_argument , ut
+# define ut_argument_spec int ut;
+# define ut_argument_spec_iso , int ut
+#else
+# ifdef COMPILE_WIDE
+# define my_strftime wcsftime
+# define nl_get_alt_digit _nl_get_walt_digit
+# else
+# define my_strftime strftime
+# define nl_get_alt_digit _nl_get_alt_digit
+# endif
+# define ut_argument
+# define ut_argument_spec
+# define ut_argument_spec_iso
+/* We don't have this information in general. */
+# define ut 0
+#endif
+
+#if !defined _LIBC && HAVE_TZNAME && HAVE_TZSET
+ /* Solaris 2.5 tzset sometimes modifies the storage returned by localtime.
+ Work around this bug by copying *tp before it might be munged. */
+ size_t _strftime_copytm __P ((char *, size_t, const char *,
+ const struct tm * ut_argument_spec_iso));
+ size_t
+ my_strftime (s, maxsize, format, tp ut_argument)
+ CHAR_T *s;
+ size_t maxsize;
+ const CHAR_T *format;
+ const struct tm *tp;
+ ut_argument_spec
+ {
+ struct tm tmcopy;
+ tmcopy = *tp;
+ return _strftime_copytm (s, maxsize, format, &tmcopy ut_argument);
+ }
+# undef my_strftime
+# define my_strftime _strftime_copytm
+#endif
+
+
+/* Write information from TP into S according to the format
+ string FORMAT, writing no more that MAXSIZE characters
+ (including the terminating '\0') and returning number of
+ characters written. If S is NULL, nothing will be written
+ anywhere, so to determine how many characters would be
+ written, use NULL for S and (size_t) UINT_MAX for MAXSIZE. */
+size_t
+my_strftime (s, maxsize, format, tp ut_argument LOCALE_PARAM)
+ CHAR_T *s;
+ size_t maxsize;
+ const CHAR_T *format;
+ const struct tm *tp;
+ ut_argument_spec
+ LOCALE_PARAM_DECL
+{
+#if defined _LIBC && defined USE_IN_EXTENDED_LOCALE_MODEL
+ struct locale_data *const current = loc->__locales[LC_TIME];
+#endif
+
+ int hour12 = tp->tm_hour;
+#ifdef _NL_CURRENT
+ /* We cannot make the following values variables since we must delay
+ the evaluation of these values until really needed since some
+ expressions might not be valid in every situation. The `struct tm'
+ might be generated by a strptime() call that initialized
+ only a few elements. Dereference the pointers only if the format
+ requires this. Then it is ok to fail if the pointers are invalid. */
+# define a_wkday \
+ ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(ABDAY_1) + tp->tm_wday))
+# define f_wkday \
+ ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(DAY_1) + tp->tm_wday))
+# define a_month \
+ ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(ABMON_1) + tp->tm_mon))
+# define f_month \
+ ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(MON_1) + tp->tm_mon))
+# define ampm \
+ ((const CHAR_T *) _NL_CURRENT (LC_TIME, tp->tm_hour > 11 \
+ ? NLW(PM_STR) : NLW(AM_STR)))
+
+# define aw_len STRLEN (a_wkday)
+# define am_len STRLEN (a_month)
+# define ap_len STRLEN (ampm)
+#else
+# if !HAVE_STRFTIME
+# define f_wkday (weekday_name[tp->tm_wday])
+# define f_month (month_name[tp->tm_mon])
+# define a_wkday f_wkday
+# define a_month f_month
+# define ampm (L_("AMPM") + 2 * (tp->tm_hour > 11))
+
+ size_t aw_len = 3;
+ size_t am_len = 3;
+ size_t ap_len = 2;
+# endif
+#endif
+ const char *zone;
+ size_t i = 0;
+ CHAR_T *p = s;
+ const CHAR_T *f;
+#if DO_MULTIBYTE && !defined COMPILE_WIDE
+ const char *format_end = NULL;
+#endif
+
+ zone = NULL;
+#if HAVE_TM_ZONE
+ /* The POSIX test suite assumes that setting
+ the environment variable TZ to a new value before calling strftime()
+ will influence the result (the %Z format) even if the information in
+ TP is computed with a totally different time zone.
+ This is bogus: though POSIX allows bad behavior like this,
+ POSIX does not require it. Do the right thing instead. */
+ zone = (const char *) tp->tm_zone;
+#endif
+#if HAVE_TZNAME
+ if (ut)
+ {
+ if (! (zone && *zone))
+ zone = "GMT";
+ }
+ else
+ {
+ /* POSIX.1 requires that local time zone information is used as
+ though strftime called tzset. */
+# if HAVE_TZSET
+ tzset ();
+# endif
+ }
+#endif
+
+ if (hour12 > 12)
+ hour12 -= 12;
+ else
+ if (hour12 == 0)
+ hour12 = 12;
+
+ for (f = format; *f != '\0'; ++f)
+ {
+ int pad = 0; /* Padding for number ('-', '_', or 0). */
+ int modifier; /* Field modifier ('E', 'O', or 0). */
+ int digits; /* Max digits for numeric format. */
+ int number_value; /* Numeric value to be printed. */
+ int negative_number; /* 1 if the number is negative. */
+ const CHAR_T *subfmt;
+ CHAR_T *bufp;
+ CHAR_T buf[1 + (sizeof (int) < sizeof (time_t)
+ ? INT_STRLEN_BOUND (time_t)
+ : INT_STRLEN_BOUND (int))];
+ int width = -1;
+ int to_lowcase = 0;
+ int to_uppcase = 0;
+ int change_case = 0;
+ int format_char;
+
+#if DO_MULTIBYTE && !defined COMPILE_WIDE
+ switch (*f)
+ {
+ case L_('%'):
+ break;
+
+ case L_('\b'): case L_('\t'): case L_('\n'):
+ case L_('\v'): case L_('\f'): case L_('\r'):
+ case L_(' '): case L_('!'): case L_('"'): case L_('#'): case L_('&'):
+ case L_('\''): case L_('('): case L_(')'): case L_('*'): case L_('+'):
+ case L_(','): case L_('-'): case L_('.'): case L_('/'): case L_('0'):
+ case L_('1'): case L_('2'): case L_('3'): case L_('4'): case L_('5'):
+ case L_('6'): case L_('7'): case L_('8'): case L_('9'): case L_(':'):
+ case L_(';'): case L_('<'): case L_('='): case L_('>'): case L_('?'):
+ case L_('A'): case L_('B'): case L_('C'): case L_('D'): case L_('E'):
+ case L_('F'): case L_('G'): case L_('H'): case L_('I'): case L_('J'):
+ case L_('K'): case L_('L'): case L_('M'): case L_('N'): case L_('O'):
+ case L_('P'): case L_('Q'): case L_('R'): case L_('S'): case L_('T'):
+ case L_('U'): case L_('V'): case L_('W'): case L_('X'): case L_('Y'):
+ case L_('Z'): case L_('['): case L_('\\'): case L_(']'): case L_('^'):
+ case L_('_'): case L_('a'): case L_('b'): case L_('c'): case L_('d'):
+ case L_('e'): case L_('f'): case L_('g'): case L_('h'): case L_('i'):
+ case L_('j'): case L_('k'): case L_('l'): case L_('m'): case L_('n'):
+ case L_('o'): case L_('p'): case L_('q'): case L_('r'): case L_('s'):
+ case L_('t'): case L_('u'): case L_('v'): case L_('w'): case L_('x'):
+ case L_('y'): case L_('z'): case L_('{'): case L_('|'): case L_('}'):
+ case L_('~'):
+ /* The C Standard requires these 98 characters (plus '%') to
+ be in the basic execution character set. None of these
+ characters can start a multibyte sequence, so they need
+ not be analyzed further. */
+ add (1, *p = *f);
+ continue;
+
+ default:
+ /* Copy this multibyte sequence until we reach its end, find
+ an error, or come back to the initial shift state. */
+ {
+ mbstate_t mbstate = mbstate_zero;
+ size_t len = 0;
+ size_t fsize;
+
+ if (! format_end)
+ format_end = f + strlen (f) + 1;
+ fsize = format_end - f;
+
+ do
+ {
+ size_t bytes = mbrlen (f + len, fsize - len, &mbstate);
+
+ if (bytes == 0)
+ break;
+
+ if (bytes == (size_t) -2)
+ {
+ len += strlen (f + len);
+ break;
+ }
+
+ if (bytes == (size_t) -1)
+ {
+ len++;
+ break;
+ }
+
+ len += bytes;
+ }
+ while (! mbsinit (&mbstate));
+
+ cpy (len, f);
+ f += len - 1;
+ continue;
+ }
+ }
+
+#else /* ! DO_MULTIBYTE */
+
+ /* Either multibyte encodings are not supported, they are
+ safe for formats, so any non-'%' byte can be copied through,
+ or this is the wide character version. */
+ if (*f != L_('%'))
+ {
+ add (1, *p = *f);
+ continue;
+ }
+
+#endif /* ! DO_MULTIBYTE */
+
+ /* Check for flags that can modify a format. */
+ while (1)
+ {
+ switch (*++f)
+ {
+ /* This influences the number formats. */
+ case L_('_'):
+ case L_('-'):
+ case L_('0'):
+ pad = *f;
+ continue;
+
+ /* This changes textual output. */
+ case L_('^'):
+ to_uppcase = 1;
+ continue;
+ case L_('#'):
+ change_case = 1;
+ continue;
+
+ default:
+ break;
+ }
+ break;
+ }
+
+ /* As a GNU extension we allow to specify the field width. */
+ if (ISDIGIT (*f))
+ {
+ width = 0;
+ do
+ {
+ if (width > INT_MAX / 10
+ || (width == INT_MAX / 10 && *f - L_('0') > INT_MAX % 10))
+ /* Avoid overflow. */
+ width = INT_MAX;
+ else
+ {
+ width *= 10;
+ width += *f - L_('0');
+ }
+ ++f;
+ }
+ while (ISDIGIT (*f));
+ }
+
+ /* Check for modifiers. */
+ switch (*f)
+ {
+ case L_('E'):
+ case L_('O'):
+ modifier = *f++;
+ break;
+
+ default:
+ modifier = 0;
+ break;
+ }
+
+ /* Now do the specified format. */
+ format_char = *f;
+ switch (format_char)
+ {
+#define DO_NUMBER(d, v) \
+ digits = d > width ? d : width; \
+ number_value = v; goto do_number
+#define DO_NUMBER_SPACEPAD(d, v) \
+ digits = d > width ? d : width; \
+ number_value = v; goto do_number_spacepad
+
+ case L_('%'):
+ if (modifier != 0)
+ goto bad_format;
+ add (1, *p = *f);
+ break;
+
+ case L_('a'):
+ if (modifier != 0)
+ goto bad_format;
+ if (change_case)
+ {
+ to_uppcase = 1;
+ to_lowcase = 0;
+ }
+#if defined _NL_CURRENT || !HAVE_STRFTIME
+ cpy (aw_len, a_wkday);
+ break;
+#else
+ goto underlying_strftime;
+#endif
+
+ case 'A':
+ if (modifier != 0)
+ goto bad_format;
+ if (change_case)
+ {
+ to_uppcase = 1;
+ to_lowcase = 0;
+ }
+#if defined _NL_CURRENT || !HAVE_STRFTIME
+ cpy (STRLEN (f_wkday), f_wkday);
+ break;
+#else
+ goto underlying_strftime;
+#endif
+
+ case L_('b'):
+ case L_('h'):
+ if (change_case)
+ {
+ to_uppcase = 1;
+ to_lowcase = 0;
+ }
+ if (modifier != 0)
+ goto bad_format;
+#if defined _NL_CURRENT || !HAVE_STRFTIME
+ cpy (am_len, a_month);
+ break;
+#else
+ goto underlying_strftime;
+#endif
+
+ case L_('B'):
+ if (modifier != 0)
+ goto bad_format;
+ if (change_case)
+ {
+ to_uppcase = 1;
+ to_lowcase = 0;
+ }
+#if defined _NL_CURRENT || !HAVE_STRFTIME
+ cpy (STRLEN (f_month), f_month);
+ break;
+#else
+ goto underlying_strftime;
+#endif
+
+ case L_('c'):
+ if (modifier == L_('O'))
+ goto bad_format;
+#ifdef _NL_CURRENT
+ if (! (modifier == 'E'
+ && (*(subfmt =
+ (const CHAR_T *) _NL_CURRENT (LC_TIME,
+ NLW(ERA_D_T_FMT)))
+ != '\0')))
+ subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(D_T_FMT));
+#else
+# if HAVE_STRFTIME
+ goto underlying_strftime;
+# else
+ subfmt = L_("%a %b %e %H:%M:%S %Y");
+# endif
+#endif
+
+ subformat:
+ {
+ CHAR_T *old_start = p;
+ size_t len = my_strftime (NULL, (size_t) -1, subfmt,
+ tp ut_argument LOCALE_ARG);
+ add (len, my_strftime (p, maxsize - i, subfmt,
+ tp ut_argument LOCALE_ARG));
+
+ if (to_uppcase)
+ while (old_start < p)
+ {
+ *old_start = TOUPPER ((UCHAR_T) *old_start, loc);
+ ++old_start;
+ }
+ }
+ break;
+
+#if HAVE_STRFTIME && ! (defined _NL_CURRENT && HAVE_STRUCT_ERA_ENTRY)
+ underlying_strftime:
+ {
+ /* The relevant information is available only via the
+ underlying strftime implementation, so use that. */
+ char ufmt[4];
+ char *u = ufmt;
+ char ubuf[1024]; /* enough for any single format in practice */
+ size_t len;
+ /* Make sure we're calling the actual underlying strftime.
+ In some cases, config.h contains something like
+ "#define strftime rpl_strftime". */
+# ifdef strftime
+# undef strftime
+ size_t strftime ();
+# endif
+
+ *u++ = '%';
+ if (modifier != 0)
+ *u++ = modifier;
+ *u++ = format_char;
+ *u = '\0';
+ len = strftime (ubuf, sizeof ubuf, ufmt, tp);
+ if (len == 0 && ubuf[0] != '\0')
+ return 0;
+ cpy (len, ubuf);
+ }
+ break;
+#endif
+
+ case L_('C'):
+ if (modifier == L_('O'))
+ goto bad_format;
+ if (modifier == L_('E'))
+ {
+#if HAVE_STRUCT_ERA_ENTRY
+ struct era_entry *era = _nl_get_era_entry (tp HELPER_LOCALE_ARG);
+ if (era)
+ {
+# ifdef COMPILE_WIDE
+ size_t len = __wcslen (era->era_wname);
+ cpy (len, era->era_wname);
+# else
+ size_t len = strlen (era->era_name);
+ cpy (len, era->era_name);
+# endif
+ break;
+ }
+#else
+# if HAVE_STRFTIME
+ goto underlying_strftime;
+# endif
+#endif
+ }
+
+ {
+ int year = tp->tm_year + TM_YEAR_BASE;
+ DO_NUMBER (1, year / 100 - (year % 100 < 0));
+ }
+
+ case L_('x'):
+ if (modifier == L_('O'))
+ goto bad_format;
+#ifdef _NL_CURRENT
+ if (! (modifier == L_('E')
+ && (*(subfmt =
+ (const CHAR_T *)_NL_CURRENT (LC_TIME, NLW(ERA_D_FMT)))
+ != L_('\0'))))
+ subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(D_FMT));
+ goto subformat;
+#else
+# if HAVE_STRFTIME
+ goto underlying_strftime;
+# else
+ /* Fall through. */
+# endif
+#endif
+ case L_('D'):
+ if (modifier != 0)
+ goto bad_format;
+ subfmt = L_("%m/%d/%y");
+ goto subformat;
+
+ case L_('d'):
+ if (modifier == L_('E'))
+ goto bad_format;
+
+ DO_NUMBER (2, tp->tm_mday);
+
+ case L_('e'):
+ if (modifier == L_('E'))
+ goto bad_format;
+
+ DO_NUMBER_SPACEPAD (2, tp->tm_mday);
+
+ /* All numeric formats set DIGITS and NUMBER_VALUE and then
+ jump to one of these two labels. */
+
+ do_number_spacepad:
+ /* Force `_' flag unless overwritten by `0' or '-' flag. */
+ if (pad != L_('0') && pad != L_('-'))
+ pad = L_('_');
+
+ do_number:
+ /* Format the number according to the MODIFIER flag. */
+
+ if (modifier == L_('O') && 0 <= number_value)
+ {
+#ifdef _NL_CURRENT
+ /* Get the locale specific alternate representation of
+ the number NUMBER_VALUE. If none exist NULL is returned. */
+ const CHAR_T *cp = nl_get_alt_digit (number_value
+ HELPER_LOCALE_ARG);
+
+ if (cp != NULL)
+ {
+ size_t digitlen = STRLEN (cp);
+ if (digitlen != 0)
+ {
+ cpy (digitlen, cp);
+ break;
+ }
+ }
+#else
+# if HAVE_STRFTIME
+ goto underlying_strftime;
+# endif
+#endif
+ }
+ {
+ unsigned int u = number_value;
+
+ bufp = buf + sizeof (buf) / sizeof (buf[0]);
+ negative_number = number_value < 0;
+
+ if (negative_number)
+ u = -u;
+
+ do
+ *--bufp = u % 10 + L_('0');
+ while ((u /= 10) != 0);
+ }
+
+ do_number_sign_and_padding:
+ if (negative_number)
+ *--bufp = L_('-');
+
+ if (pad != L_('-'))
+ {
+ int padding = digits - (buf + (sizeof (buf) / sizeof (buf[0]))
+ - bufp);
+
+ if (padding > 0)
+ {
+ if (pad == L_('_'))
+ {
+ if ((size_t) padding >= maxsize - i)
+ return 0;
+
+ if (p)
+ memset_space (p, padding);
+ i += padding;
+ width = width > padding ? width - padding : 0;
+ }
+ else
+ {
+ if ((size_t) digits >= maxsize - i)
+ return 0;
+
+ if (negative_number)
+ {
+ ++bufp;
+
+ if (p)
+ *p++ = L_('-');
+ ++i;
+ }
+
+ if (p)
+ memset_zero (p, padding);
+ i += padding;
+ width = 0;
+ }
+ }
+ }
+
+ cpy (buf + sizeof (buf) / sizeof (buf[0]) - bufp, bufp);
+ break;
+
+ case L_('F'):
+ if (modifier != 0)
+ goto bad_format;
+ subfmt = L_("%Y-%m-%d");
+ goto subformat;
+
+ case L_('H'):
+ if (modifier == L_('E'))
+ goto bad_format;
+
+ DO_NUMBER (2, tp->tm_hour);
+
+ case L_('I'):
+ if (modifier == L_('E'))
+ goto bad_format;
+
+ DO_NUMBER (2, hour12);
+
+ case L_('k'): /* GNU extension. */
+ if (modifier == L_('E'))
+ goto bad_format;
+
+ DO_NUMBER_SPACEPAD (2, tp->tm_hour);
+
+ case L_('l'): /* GNU extension. */
+ if (modifier == L_('E'))
+ goto bad_format;
+
+ DO_NUMBER_SPACEPAD (2, hour12);
+
+ case L_('j'):
+ if (modifier == L_('E'))
+ goto bad_format;
+
+ DO_NUMBER (3, 1 + tp->tm_yday);
+
+ case L_('M'):
+ if (modifier == L_('E'))
+ goto bad_format;
+
+ DO_NUMBER (2, tp->tm_min);
+
+ case L_('m'):
+ if (modifier == L_('E'))
+ goto bad_format;
+
+ DO_NUMBER (2, tp->tm_mon + 1);
+
+ case L_('n'):
+ add (1, *p = L_('\n'));
+ break;
+
+ case L_('P'):
+ to_lowcase = 1;
+#if !defined _NL_CURRENT && HAVE_STRFTIME
+ format_char = L_('p');
+#endif
+ /* FALLTHROUGH */
+
+ case L_('p'):
+ if (change_case)
+ {
+ to_uppcase = 0;
+ to_lowcase = 1;
+ }
+#if defined _NL_CURRENT || !HAVE_STRFTIME
+ cpy (ap_len, ampm);
+ break;
+#else
+ goto underlying_strftime;
+#endif
+
+ case L_('R'):
+ subfmt = L_("%H:%M");
+ goto subformat;
+
+ case L_('r'):
+#if !defined _NL_CURRENT && HAVE_STRFTIME
+ goto underlying_strftime;
+#else
+# ifdef _NL_CURRENT
+ if (*(subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME,
+ NLW(T_FMT_AMPM)))
+ == L_('\0'))
+# endif
+ subfmt = L_("%I:%M:%S %p");
+ goto subformat;
+#endif
+
+ case L_('S'):
+ if (modifier == L_('E'))
+ goto bad_format;
+
+ DO_NUMBER (2, tp->tm_sec);
+
+ case L_('s'): /* GNU extension. */
+ {
+ struct tm ltm;
+ time_t t;
+
+ ltm = *tp;
+ t = mktime (<m);
+
+ /* Generate string value for T using time_t arithmetic;
+ this works even if sizeof (long) < sizeof (time_t). */
+
+ bufp = buf + sizeof (buf) / sizeof (buf[0]);
+ negative_number = t < 0;
+
+ do
+ {
+ int d = t % 10;
+ t /= 10;
+
+ if (negative_number)
+ {
+ d = -d;
+
+ /* Adjust if division truncates to minus infinity. */
+ if (0 < -1 % 10 && d < 0)
+ {
+ t++;
+ d += 10;
+ }
+ }
+
+ *--bufp = d + L_('0');
+ }
+ while (t != 0);
+
+ digits = 1;
+ goto do_number_sign_and_padding;
+ }
+
+ case L_('X'):
+ if (modifier == L_('O'))
+ goto bad_format;
+#ifdef _NL_CURRENT
+ if (! (modifier == L_('E')
+ && (*(subfmt =
+ (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(ERA_T_FMT)))
+ != L_('\0'))))
+ subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(T_FMT));
+ goto subformat;
+#else
+# if HAVE_STRFTIME
+ goto underlying_strftime;
+# else
+ /* Fall through. */
+# endif
+#endif
+ case L_('T'):
+ subfmt = L_("%H:%M:%S");
+ goto subformat;
+
+ case L_('t'):
+ add (1, *p = L_('\t'));
+ break;
+
+ case L_('u'):
+ DO_NUMBER (1, (tp->tm_wday - 1 + 7) % 7 + 1);
+
+ case L_('U'):
+ if (modifier == L_('E'))
+ goto bad_format;
+
+ DO_NUMBER (2, (tp->tm_yday - tp->tm_wday + 7) / 7);
+
+ case L_('V'):
+ case L_('g'):
+ case L_('G'):
+ if (modifier == L_('E'))
+ goto bad_format;
+ {
+ int year = tp->tm_year + TM_YEAR_BASE;
+ int days = iso_week_days (tp->tm_yday, tp->tm_wday);
+
+ if (days < 0)
+ {
+ /* This ISO week belongs to the previous year. */
+ year--;
+ days = iso_week_days (tp->tm_yday + (365 + __isleap (year)),
+ tp->tm_wday);
+ }
+ else
+ {
+ int d = iso_week_days (tp->tm_yday - (365 + __isleap (year)),
+ tp->tm_wday);
+ if (0 <= d)
+ {
+ /* This ISO week belongs to the next year. */
+ year++;
+ days = d;
+ }
+ }
+
+ switch (*f)
+ {
+ case L_('g'):
+ DO_NUMBER (2, (year % 100 + 100) % 100);
+
+ case L_('G'):
+ DO_NUMBER (1, year);
+
+ default:
+ DO_NUMBER (2, days / 7 + 1);
+ }
+ }
+
+ case L_('W'):
+ if (modifier == L_('E'))
+ goto bad_format;
+
+ DO_NUMBER (2, (tp->tm_yday - (tp->tm_wday - 1 + 7) % 7 + 7) / 7);
+
+ case L_('w'):
+ if (modifier == L_('E'))
+ goto bad_format;
+
+ DO_NUMBER (1, tp->tm_wday);
+
+ case L_('Y'):
+ if (modifier == 'E')
+ {
+#if HAVE_STRUCT_ERA_ENTRY
+ struct era_entry *era = _nl_get_era_entry (tp HELPER_LOCALE_ARG);
+ if (era)
+ {
+# ifdef COMPILE_WIDE
+ subfmt = era->era_wformat;
+# else
+ subfmt = era->era_format;
+# endif
+ goto subformat;
+ }
+#else
+# if HAVE_STRFTIME
+ goto underlying_strftime;
+# endif
+#endif
+ }
+ if (modifier == L_('O'))
+ goto bad_format;
+ else
+ DO_NUMBER (1, tp->tm_year + TM_YEAR_BASE);
+
+ case L_('y'):
+ if (modifier == L_('E'))
+ {
+#if HAVE_STRUCT_ERA_ENTRY
+ struct era_entry *era = _nl_get_era_entry (tp HELPER_LOCALE_ARG);
+ if (era)
+ {
+ int delta = tp->tm_year - era->start_date[0];
+ DO_NUMBER (1, (era->offset
+ + delta * era->absolute_direction));
+ }
+#else
+# if HAVE_STRFTIME
+ goto underlying_strftime;
+# endif
+#endif
+ }
+ DO_NUMBER (2, (tp->tm_year % 100 + 100) % 100);
+
+ case L_('Z'):
+ if (change_case)
+ {
+ to_uppcase = 0;
+ to_lowcase = 1;
+ }
+
+#if HAVE_TZNAME
+ /* The tzset() call might have changed the value. */
+ if (!(zone && *zone) && tp->tm_isdst >= 0)
+ zone = tzname[tp->tm_isdst];
+#endif
+ if (! zone)
+ zone = "";
+
+#ifdef COMPILE_WIDE
+ {
+ /* The zone string is always given in multibyte form. We have
+ to transform it first. */
+ wchar_t *wczone;
+ size_t len;
+ widen (zone, wczone, len);
+ cpy (len, wczone);
+ }
+#else
+ cpy (strlen (zone), zone);
+#endif
+ break;
+
+ case L_('z'):
+ if (tp->tm_isdst < 0)
+ break;
+
+ {
+ int diff;
+#if HAVE_TM_GMTOFF
+ diff = tp->tm_gmtoff;
+#else
+ if (ut)
+ diff = 0;
+ else
+ {
+ struct tm gtm;
+ struct tm ltm;
+ time_t lt;
+
+ ltm = *tp;
+ lt = mktime (<m);
+
+ if (lt == (time_t) -1)
+ {
+ /* mktime returns -1 for errors, but -1 is also a
+ valid time_t value. Check whether an error really
+ occurred. */
+ struct tm tm;
+
+ if (! __localtime_r (<, &tm)
+ || ((ltm.tm_sec ^ tm.tm_sec)
+ | (ltm.tm_min ^ tm.tm_min)
+ | (ltm.tm_hour ^ tm.tm_hour)
+ | (ltm.tm_mday ^ tm.tm_mday)
+ | (ltm.tm_mon ^ tm.tm_mon)
+ | (ltm.tm_year ^ tm.tm_year)))
+ break;
+ }
+
+ if (! __gmtime_r (<, >m))
+ break;
+
+ diff = tm_diff (<m, >m);
+ }
+#endif
+
+ if (diff < 0)
+ {
+ add (1, *p = L_('-'));
+ diff = -diff;
+ }
+ else
+ add (1, *p = L_('+'));
+
+ diff /= 60;
+ DO_NUMBER (4, (diff / 60) * 100 + diff % 60);
+ }
+
+ case L_('\0'): /* GNU extension: % at end of format. */
+ --f;
+ /* Fall through. */
+ default:
+ /* Unknown format; output the format, including the '%',
+ since this is most likely the right thing to do if a
+ multibyte string has been misparsed. */
+ bad_format:
+ {
+ int flen;
+ for (flen = 1; f[1 - flen] != L_('%'); flen++)
+ continue;
+ cpy (flen, &f[1 - flen]);
+ }
+ break;
+ }
+ }
+
+ if (p && maxsize != 0)
+ *p = L_('\0');
+ return i;
+}
+#ifdef _LIBC
+libc_hidden_def (my_strftime)
+#endif
+
+
+#ifdef emacs
+/* For Emacs we have a separate interface which corresponds to the normal
+ strftime function and does not have the extra information whether the
+ TP arguments comes from a `gmtime' call or not. */
+size_t
+emacs_strftime (s, maxsize, format, tp)
+ char *s;
+ size_t maxsize;
+ const char *format;
+ const struct tm *tp;
+{
+ return my_strftime (s, maxsize, format, tp, 0);
+}
+#endif
+
+#if defined _LIBC && !defined COMPILE_WIDE
weak_alias (__strftime_l, strftime_l)
+#endif
/* Convert a string representation of time to a time value.
- Copyright (C) 1996-2000, 2001, 2002 Free Software Foundation, Inc.
+ Copyright (C) 1996-2000, 2001, 2002, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1996.
some of them in the same format (such as year, week and weekday)
this is enough information for determining the date. */
-#ifdef HAVE_CONFIG_H
-# include <config.h>
-#endif
-
-#include <ctype.h>
-#include <langinfo.h>
-#include <limits.h>
-#include <string.h>
#include <time.h>
-
-#ifdef _LIBC
-# include "../locale/localeinfo.h"
-#endif
-
-
-#ifndef __P
-# if defined __GNUC__ || (defined __STDC__ && __STDC__)
-# define __P(args) args
-# else
-# define __P(args) ()
-# endif /* GCC. */
-#endif /* Not __P. */
-
-
-#if ! HAVE_LOCALTIME_R && ! defined localtime_r
-# ifdef _LIBC
-# define localtime_r __localtime_r
-# else
-/* Approximate localtime_r as best we can in its absence. */
-# define localtime_r my_localtime_r
-static struct tm *localtime_r __P ((const time_t *, struct tm *));
-static struct tm *
-localtime_r (t, tp)
- const time_t *t;
- struct tm *tp;
-{
- struct tm *l = localtime (t);
- if (! l)
- return 0;
- *tp = *l;
- return tp;
-}
-# endif /* ! _LIBC */
-#endif /* ! HAVE_LOCALTIME_R && ! defined (localtime_r) */
-
-
-#define match_char(ch1, ch2) if (ch1 != ch2) return NULL
-#if defined __GNUC__ && __GNUC__ >= 2
-# ifdef USE_IN_EXTENDED_LOCALE_MODEL
-# define match_string(cs1, s2) \
- ({ size_t len = strlen (cs1); \
- int result = __strncasecmp_l ((cs1), (s2), len, locale) == 0; \
- if (result) (s2) += len; \
- result; })
-# else
-# define match_string(cs1, s2) \
- ({ size_t len = strlen (cs1); \
- int result = strncasecmp ((cs1), (s2), len) == 0; \
- if (result) (s2) += len; \
- result; })
-# endif
-#else
-/* Oh come on. Get a reasonable compiler. */
-# define match_string(cs1, s2) \
- (strncasecmp ((cs1), (s2), strlen (cs1)) ? 0 : ((s2) += strlen (cs1), 1))
-#endif
-/* We intentionally do not use isdigit() for testing because this will
- lead to problems with the wide character version. */
-#define get_number(from, to, n) \
- do { \
- int __n = n; \
- val = 0; \
- while (*rp == ' ') \
- ++rp; \
- if (*rp < '0' || *rp > '9') \
- return NULL; \
- do { \
- val *= 10; \
- val += *rp++ - '0'; \
- } while (--__n > 0 && val * 10 <= to && *rp >= '0' && *rp <= '9'); \
- if (val < from || val > to) \
- return NULL; \
- } while (0)
-#ifdef _NL_CURRENT
-# define get_alt_number(from, to, n) \
- ({ \
- __label__ do_normal; \
- \
- if (*decided != raw) \
- { \
- val = _nl_parse_alt_digit (&rp HELPER_LOCALE_ARG); \
- if (val == -1 && *decided != loc) \
- { \
- *decided = loc; \
- goto do_normal; \
- } \
- if (val < from || val > to) \
- return NULL; \
- } \
- else \
- { \
- do_normal: \
- get_number (from, to, n); \
- } \
- 0; \
- })
-#else
-# define get_alt_number(from, to, n) \
- /* We don't have the alternate representation. */ \
- get_number(from, to, n)
-#endif
-#define recursive(new_fmt) \
- (*(new_fmt) != '\0' \
- && (rp = strptime_internal (rp, (new_fmt), tm, \
- decided, era_cnt LOCALE_ARG)) != NULL)
-
-
-#ifdef _LIBC
-/* This is defined in locale/C-time.c in the GNU libc. */
-extern const struct locale_data _nl_C_LC_TIME attribute_hidden;
-
-# define weekday_name (&_nl_C_LC_TIME.values[_NL_ITEM_INDEX (DAY_1)].string)
-# define ab_weekday_name \
- (&_nl_C_LC_TIME.values[_NL_ITEM_INDEX (ABDAY_1)].string)
-# define month_name (&_nl_C_LC_TIME.values[_NL_ITEM_INDEX (MON_1)].string)
-# define ab_month_name (&_nl_C_LC_TIME.values[_NL_ITEM_INDEX (ABMON_1)].string)
-# define HERE_D_T_FMT (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (D_T_FMT)].string)
-# define HERE_D_FMT (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (D_FMT)].string)
-# define HERE_AM_STR (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (AM_STR)].string)
-# define HERE_PM_STR (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (PM_STR)].string)
-# define HERE_T_FMT_AMPM \
- (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (T_FMT_AMPM)].string)
-# define HERE_T_FMT (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (T_FMT)].string)
-
-# define strncasecmp(s1, s2, n) __strncasecmp (s1, s2, n)
-#else
-static char const weekday_name[][10] =
- {
- "Sunday", "Monday", "Tuesday", "Wednesday",
- "Thursday", "Friday", "Saturday"
- };
-static char const ab_weekday_name[][4] =
- {
- "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
- };
-static char const month_name[][10] =
- {
- "January", "February", "March", "April", "May", "June",
- "July", "August", "September", "October", "November", "December"
- };
-static char const ab_month_name[][4] =
- {
- "Jan", "Feb", "Mar", "Apr", "May", "Jun",
- "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
- };
-# define HERE_D_T_FMT "%a %b %e %H:%M:%S %Y"
-# define HERE_D_FMT "%m/%d/%y"
-# define HERE_AM_STR "AM"
-# define HERE_PM_STR "PM"
-# define HERE_T_FMT_AMPM "%I:%M:%S %p"
-# define HERE_T_FMT "%H:%M:%S"
-
-static const unsigned short int __mon_yday[2][13] =
- {
- /* Normal years. */
- { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 },
- /* Leap years. */
- { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }
- };
-#endif
-
-#if defined _LIBC && defined USE_IN_EXTENDED_LOCALE_MODEL
-/* We use this code also for the extended locale handling where the
- function gets as an additional argument the locale which has to be
- used. To access the values we have to redefine the _NL_CURRENT
- macro. */
-# define strptime __strptime_l
-# undef _NL_CURRENT
-# define _NL_CURRENT(category, item) \
- (current->values[_NL_ITEM_INDEX (item)].string)
-# undef _NL_CURRENT_WORD
-# define _NL_CURRENT_WORD(category, item) \
- (current->values[_NL_ITEM_INDEX (item)].word)
-# define LOCALE_PARAM , locale
-# define LOCALE_ARG , locale
-# define LOCALE_PARAM_PROTO , __locale_t locale
-# define LOCALE_PARAM_DECL __locale_t locale;
-# define HELPER_LOCALE_ARG , current
-# define ISSPACE(Ch) __isspace_l (Ch, locale)
-#else
-# define LOCALE_PARAM
-# define LOCALE_ARG
-# define LOCALE_PARAM_DECL
-# define LOCALE_PARAM_PROTO
-# ifdef _LIBC
-# define HELPER_LOCALE_ARG , _NL_CURRENT_DATA (LC_TIME)
-# else
-# define HELPER_LOCALE_ARG
-# endif
-# define ISSPACE(Ch) isspace (Ch)
-#endif
-
-
-/* Status of lookup: do we use the locale data or the raw data? */
-enum locale_status { not, loc, raw };
-
-
-#ifndef __isleap
-/* Nonzero if YEAR is a leap year (every 4 years,
- except every 100th isn't, and every 400th is). */
-# define __isleap(year) \
- ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
-#endif
-
-/* Compute the day of the week. */
-static void
-day_of_the_week (struct tm *tm)
-{
- /* We know that January 1st 1970 was a Thursday (= 4). Compute the
- the difference between this data in the one on TM and so determine
- the weekday. */
- int corr_year = 1900 + tm->tm_year - (tm->tm_mon < 2);
- int wday = (-473
- + (365 * (tm->tm_year - 70))
- + (corr_year / 4)
- - ((corr_year / 4) / 25) + ((corr_year / 4) % 25 < 0)
- + (((corr_year / 4) / 25) / 4)
- + __mon_yday[0][tm->tm_mon]
- + tm->tm_mday - 1);
- tm->tm_wday = ((wday % 7) + 7) % 7;
-}
-
-/* Compute the day of the year. */
-static void
-day_of_the_year (struct tm *tm)
-{
- tm->tm_yday = (__mon_yday[__isleap (1900 + tm->tm_year)][tm->tm_mon]
- + (tm->tm_mday - 1));
-}
-
-
-static char *
-#ifdef _LIBC
-internal_function
-#endif
-strptime_internal __P ((const char *rp, const char *fmt, struct tm *tm,
- enum locale_status *decided, int era_cnt
- LOCALE_PARAM_PROTO));
-
-static char *
-#ifdef _LIBC
-internal_function
-#endif
-strptime_internal (rp, fmt, tm, decided, era_cnt LOCALE_PARAM)
- const char *rp;
- const char *fmt;
- struct tm *tm;
- enum locale_status *decided;
- int era_cnt;
- LOCALE_PARAM_DECL
-{
-#if defined _LIBC && defined USE_IN_EXTENDED_LOCALE_MODEL
- struct locale_data *const current = locale->__locales[LC_TIME];
-#endif
-
- const char *rp_backup;
- int cnt;
- size_t val;
- int have_I, is_pm;
- int century, want_century;
- int want_era;
- int have_wday, want_xday;
- int have_yday;
- int have_mon, have_mday;
- int have_uweek, have_wweek;
- int week_no;
- size_t num_eras;
- struct era_entry *era;
-
- have_I = is_pm = 0;
- century = -1;
- want_century = 0;
- want_era = 0;
- era = NULL;
- week_no = 0;
-
- have_wday = want_xday = have_yday = have_mon = have_mday = have_uweek = 0;
- have_wweek = 0;
-
- while (*fmt != '\0')
- {
- /* A white space in the format string matches 0 more or white
- space in the input string. */
- if (ISSPACE (*fmt))
- {
- while (ISSPACE (*rp))
- ++rp;
- ++fmt;
- continue;
- }
-
- /* Any character but `%' must be matched by the same character
- in the iput string. */
- if (*fmt != '%')
- {
- match_char (*fmt++, *rp++);
- continue;
- }
-
- ++fmt;
-#ifndef _NL_CURRENT
- /* We need this for handling the `E' modifier. */
- start_over:
-#endif
-
- /* Make back up of current processing pointer. */
- rp_backup = rp;
-
- switch (*fmt++)
- {
- case '%':
- /* Match the `%' character itself. */
- match_char ('%', *rp++);
- break;
- case 'a':
- case 'A':
- /* Match day of week. */
- for (cnt = 0; cnt < 7; ++cnt)
- {
-#ifdef _NL_CURRENT
- if (*decided !=raw)
- {
- if (match_string (_NL_CURRENT (LC_TIME, DAY_1 + cnt), rp))
- {
- if (*decided == not
- && strcmp (_NL_CURRENT (LC_TIME, DAY_1 + cnt),
- weekday_name[cnt]))
- *decided = loc;
- break;
- }
- if (match_string (_NL_CURRENT (LC_TIME, ABDAY_1 + cnt), rp))
- {
- if (*decided == not
- && strcmp (_NL_CURRENT (LC_TIME, ABDAY_1 + cnt),
- ab_weekday_name[cnt]))
- *decided = loc;
- break;
- }
- }
-#endif
- if (*decided != loc
- && (match_string (weekday_name[cnt], rp)
- || match_string (ab_weekday_name[cnt], rp)))
- {
- *decided = raw;
- break;
- }
- }
- if (cnt == 7)
- /* Does not match a weekday name. */
- return NULL;
- tm->tm_wday = cnt;
- have_wday = 1;
- break;
- case 'b':
- case 'B':
- case 'h':
- /* Match month name. */
- for (cnt = 0; cnt < 12; ++cnt)
- {
-#ifdef _NL_CURRENT
- if (*decided !=raw)
- {
- if (match_string (_NL_CURRENT (LC_TIME, MON_1 + cnt), rp))
- {
- if (*decided == not
- && strcmp (_NL_CURRENT (LC_TIME, MON_1 + cnt),
- month_name[cnt]))
- *decided = loc;
- break;
- }
- if (match_string (_NL_CURRENT (LC_TIME, ABMON_1 + cnt), rp))
- {
- if (*decided == not
- && strcmp (_NL_CURRENT (LC_TIME, ABMON_1 + cnt),
- ab_month_name[cnt]))
- *decided = loc;
- break;
- }
- }
-#endif
- if (match_string (month_name[cnt], rp)
- || match_string (ab_month_name[cnt], rp))
- {
- *decided = raw;
- break;
- }
- }
- if (cnt == 12)
- /* Does not match a month name. */
- return NULL;
- tm->tm_mon = cnt;
- want_xday = 1;
- break;
- case 'c':
- /* Match locale's date and time format. */
-#ifdef _NL_CURRENT
- if (*decided != raw)
- {
- if (!recursive (_NL_CURRENT (LC_TIME, D_T_FMT)))
- {
- if (*decided == loc)
- return NULL;
- else
- rp = rp_backup;
- }
- else
- {
- if (*decided == not &&
- strcmp (_NL_CURRENT (LC_TIME, D_T_FMT), HERE_D_T_FMT))
- *decided = loc;
- want_xday = 1;
- break;
- }
- *decided = raw;
- }
-#endif
- if (!recursive (HERE_D_T_FMT))
- return NULL;
- want_xday = 1;
- break;
- case 'C':
- /* Match century number. */
- match_century:
- get_number (0, 99, 2);
- century = val;
- want_xday = 1;
- break;
- case 'd':
- case 'e':
- /* Match day of month. */
- get_number (1, 31, 2);
- tm->tm_mday = val;
- have_mday = 1;
- want_xday = 1;
- break;
- case 'F':
- if (!recursive ("%Y-%m-%d"))
- return NULL;
- want_xday = 1;
- break;
- case 'x':
-#ifdef _NL_CURRENT
- if (*decided != raw)
- {
- if (!recursive (_NL_CURRENT (LC_TIME, D_FMT)))
- {
- if (*decided == loc)
- return NULL;
- else
- rp = rp_backup;
- }
- else
- {
- if (*decided == not
- && strcmp (_NL_CURRENT (LC_TIME, D_FMT), HERE_D_FMT))
- *decided = loc;
- want_xday = 1;
- break;
- }
- *decided = raw;
- }
-#endif
- /* Fall through. */
- case 'D':
- /* Match standard day format. */
- if (!recursive (HERE_D_FMT))
- return NULL;
- want_xday = 1;
- break;
- case 'k':
- case 'H':
- /* Match hour in 24-hour clock. */
- get_number (0, 23, 2);
- tm->tm_hour = val;
- have_I = 0;
- break;
- case 'l':
- /* Match hour in 12-hour clock. GNU extension. */
- case 'I':
- /* Match hour in 12-hour clock. */
- get_number (1, 12, 2);
- tm->tm_hour = val % 12;
- have_I = 1;
- break;
- case 'j':
- /* Match day number of year. */
- get_number (1, 366, 3);
- tm->tm_yday = val - 1;
- have_yday = 1;
- break;
- case 'm':
- /* Match number of month. */
- get_number (1, 12, 2);
- tm->tm_mon = val - 1;
- have_mon = 1;
- want_xday = 1;
- break;
- case 'M':
- /* Match minute. */
- get_number (0, 59, 2);
- tm->tm_min = val;
- break;
- case 'n':
- case 't':
- /* Match any white space. */
- while (ISSPACE (*rp))
- ++rp;
- break;
- case 'p':
- /* Match locale's equivalent of AM/PM. */
-#ifdef _NL_CURRENT
- if (*decided != raw)
- {
- if (match_string (_NL_CURRENT (LC_TIME, AM_STR), rp))
- {
- if (strcmp (_NL_CURRENT (LC_TIME, AM_STR), HERE_AM_STR))
- *decided = loc;
- break;
- }
- if (match_string (_NL_CURRENT (LC_TIME, PM_STR), rp))
- {
- if (strcmp (_NL_CURRENT (LC_TIME, PM_STR), HERE_PM_STR))
- *decided = loc;
- is_pm = 1;
- break;
- }
- *decided = raw;
- }
-#endif
- if (!match_string (HERE_AM_STR, rp))
- if (match_string (HERE_PM_STR, rp))
- is_pm = 1;
- else
- return NULL;
- break;
- case 'r':
-#ifdef _NL_CURRENT
- if (*decided != raw)
- {
- if (!recursive (_NL_CURRENT (LC_TIME, T_FMT_AMPM)))
- {
- if (*decided == loc)
- return NULL;
- else
- rp = rp_backup;
- }
- else
- {
- if (*decided == not &&
- strcmp (_NL_CURRENT (LC_TIME, T_FMT_AMPM),
- HERE_T_FMT_AMPM))
- *decided = loc;
- break;
- }
- *decided = raw;
- }
-#endif
- if (!recursive (HERE_T_FMT_AMPM))
- return NULL;
- break;
- case 'R':
- if (!recursive ("%H:%M"))
- return NULL;
- break;
- case 's':
- {
- /* The number of seconds may be very high so we cannot use
- the `get_number' macro. Instead read the number
- character for character and construct the result while
- doing this. */
- time_t secs = 0;
- if (*rp < '0' || *rp > '9')
- /* We need at least one digit. */
- return NULL;
-
- do
- {
- secs *= 10;
- secs += *rp++ - '0';
- }
- while (*rp >= '0' && *rp <= '9');
-
- if (localtime_r (&secs, tm) == NULL)
- /* Error in function. */
- return NULL;
- }
- break;
- case 'S':
- get_number (0, 61, 2);
- tm->tm_sec = val;
- break;
- case 'X':
-#ifdef _NL_CURRENT
- if (*decided != raw)
- {
- if (!recursive (_NL_CURRENT (LC_TIME, T_FMT)))
- {
- if (*decided == loc)
- return NULL;
- else
- rp = rp_backup;
- }
- else
- {
- if (strcmp (_NL_CURRENT (LC_TIME, T_FMT), HERE_T_FMT))
- *decided = loc;
- break;
- }
- *decided = raw;
- }
-#endif
- /* Fall through. */
- case 'T':
- if (!recursive (HERE_T_FMT))
- return NULL;
- break;
- case 'u':
- get_number (1, 7, 1);
- tm->tm_wday = val % 7;
- have_wday = 1;
- break;
- case 'g':
- get_number (0, 99, 2);
- /* XXX This cannot determine any field in TM. */
- break;
- case 'G':
- if (*rp < '0' || *rp > '9')
- return NULL;
- /* XXX Ignore the number since we would need some more
- information to compute a real date. */
- do
- ++rp;
- while (*rp >= '0' && *rp <= '9');
- break;
- case 'U':
- get_number (0, 53, 2);
- week_no = val;
- have_uweek = 1;
- break;
- case 'W':
- get_number (0, 53, 2);
- week_no = val;
- have_wweek = 1;
- break;
- case 'V':
- get_number (0, 53, 2);
- /* XXX This cannot determine any field in TM without some
- information. */
- break;
- case 'w':
- /* Match number of weekday. */
- get_number (0, 6, 1);
- tm->tm_wday = val;
- have_wday = 1;
- break;
- case 'y':
- match_year_in_century:
- /* Match year within century. */
- get_number (0, 99, 2);
- /* The "Year 2000: The Millennium Rollover" paper suggests that
- values in the range 69-99 refer to the twentieth century. */
- tm->tm_year = val >= 69 ? val : val + 100;
- /* Indicate that we want to use the century, if specified. */
- want_century = 1;
- want_xday = 1;
- break;
- case 'Y':
- /* Match year including century number. */
- get_number (0, 9999, 4);
- tm->tm_year = val - 1900;
- want_century = 0;
- want_xday = 1;
- break;
- case 'Z':
- /* XXX How to handle this? */
- break;
- case 'E':
-#ifdef _NL_CURRENT
- switch (*fmt++)
- {
- case 'c':
- /* Match locale's alternate date and time format. */
- if (*decided != raw)
- {
- const char *fmt = _NL_CURRENT (LC_TIME, ERA_D_T_FMT);
-
- if (*fmt == '\0')
- fmt = _NL_CURRENT (LC_TIME, D_T_FMT);
-
- if (!recursive (fmt))
- {
- if (*decided == loc)
- return NULL;
- else
- rp = rp_backup;
- }
- else
- {
- if (strcmp (fmt, HERE_D_T_FMT))
- *decided = loc;
- want_xday = 1;
- break;
- }
- *decided = raw;
- }
- /* The C locale has no era information, so use the
- normal representation. */
- if (!recursive (HERE_D_T_FMT))
- return NULL;
- want_xday = 1;
- break;
- case 'C':
- if (*decided != raw)
- {
- if (era_cnt >= 0)
- {
- era = _nl_select_era_entry (era_cnt HELPER_LOCALE_ARG);
- if (era != NULL && match_string (era->era_name, rp))
- {
- *decided = loc;
- break;
- }
- else
- return NULL;
- }
- else
- {
- num_eras = _NL_CURRENT_WORD (LC_TIME,
- _NL_TIME_ERA_NUM_ENTRIES);
- for (era_cnt = 0; era_cnt < (int) num_eras;
- ++era_cnt, rp = rp_backup)
- {
- era = _nl_select_era_entry (era_cnt
- HELPER_LOCALE_ARG);
- if (era != NULL && match_string (era->era_name, rp))
- {
- *decided = loc;
- break;
- }
- }
- if (era_cnt == (int) num_eras)
- {
- era_cnt = -1;
- if (*decided == loc)
- return NULL;
- }
- else
- break;
- }
-
- *decided = raw;
- }
- /* The C locale has no era information, so use the
- normal representation. */
- goto match_century;
- case 'y':
- if (*decided == raw)
- goto match_year_in_century;
-
- get_number(0, 9999, 4);
- tm->tm_year = val;
- want_era = 1;
- want_xday = 1;
- want_century = 1;
- break;
- case 'Y':
- if (*decided != raw)
- {
- num_eras = _NL_CURRENT_WORD (LC_TIME,
- _NL_TIME_ERA_NUM_ENTRIES);
- for (era_cnt = 0; era_cnt < (int) num_eras;
- ++era_cnt, rp = rp_backup)
- {
- era = _nl_select_era_entry (era_cnt HELPER_LOCALE_ARG);
- if (era != NULL && recursive (era->era_format))
- break;
- }
- if (era_cnt == (int) num_eras)
- {
- era_cnt = -1;
- if (*decided == loc)
- return NULL;
- else
- rp = rp_backup;
- }
- else
- {
- *decided = loc;
- era_cnt = -1;
- break;
- }
-
- *decided = raw;
- }
- get_number (0, 9999, 4);
- tm->tm_year = val - 1900;
- want_century = 0;
- want_xday = 1;
- break;
- case 'x':
- if (*decided != raw)
- {
- const char *fmt = _NL_CURRENT (LC_TIME, ERA_D_FMT);
-
- if (*fmt == '\0')
- fmt = _NL_CURRENT (LC_TIME, D_FMT);
-
- if (!recursive (fmt))
- {
- if (*decided == loc)
- return NULL;
- else
- rp = rp_backup;
- }
- else
- {
- if (strcmp (fmt, HERE_D_FMT))
- *decided = loc;
- break;
- }
- *decided = raw;
- }
- if (!recursive (HERE_D_FMT))
- return NULL;
- break;
- case 'X':
- if (*decided != raw)
- {
- const char *fmt = _NL_CURRENT (LC_TIME, ERA_T_FMT);
-
- if (*fmt == '\0')
- fmt = _NL_CURRENT (LC_TIME, T_FMT);
-
- if (!recursive (fmt))
- {
- if (*decided == loc)
- return NULL;
- else
- rp = rp_backup;
- }
- else
- {
- if (strcmp (fmt, HERE_T_FMT))
- *decided = loc;
- break;
- }
- *decided = raw;
- }
- if (!recursive (HERE_T_FMT))
- return NULL;
- break;
- default:
- return NULL;
- }
- break;
-#else
- /* We have no information about the era format. Just use
- the normal format. */
- if (*fmt != 'c' && *fmt != 'C' && *fmt != 'y' && *fmt != 'Y'
- && *fmt != 'x' && *fmt != 'X')
- /* This is an illegal format. */
- return NULL;
-
- goto start_over;
-#endif
- case 'O':
- switch (*fmt++)
- {
- case 'd':
- case 'e':
- /* Match day of month using alternate numeric symbols. */
- get_alt_number (1, 31, 2);
- tm->tm_mday = val;
- have_mday = 1;
- want_xday = 1;
- break;
- case 'H':
- /* Match hour in 24-hour clock using alternate numeric
- symbols. */
- get_alt_number (0, 23, 2);
- tm->tm_hour = val;
- have_I = 0;
- break;
- case 'I':
- /* Match hour in 12-hour clock using alternate numeric
- symbols. */
- get_alt_number (1, 12, 2);
- tm->tm_hour = val % 12;
- have_I = 1;
- break;
- case 'm':
- /* Match month using alternate numeric symbols. */
- get_alt_number (1, 12, 2);
- tm->tm_mon = val - 1;
- have_mon = 1;
- want_xday = 1;
- break;
- case 'M':
- /* Match minutes using alternate numeric symbols. */
- get_alt_number (0, 59, 2);
- tm->tm_min = val;
- break;
- case 'S':
- /* Match seconds using alternate numeric symbols. */
- get_alt_number (0, 61, 2);
- tm->tm_sec = val;
- break;
- case 'U':
- get_alt_number (0, 53, 2);
- week_no = val;
- have_uweek = 1;
- break;
- case 'W':
- get_alt_number (0, 53, 2);
- week_no = val;
- have_wweek = 1;
- break;
- case 'V':
- get_alt_number (0, 53, 2);
- /* XXX This cannot determine any field in TM without
- further information. */
- break;
- case 'w':
- /* Match number of weekday using alternate numeric symbols. */
- get_alt_number (0, 6, 1);
- tm->tm_wday = val;
- have_wday = 1;
- break;
- case 'y':
- /* Match year within century using alternate numeric symbols. */
- get_alt_number (0, 99, 2);
- tm->tm_year = val >= 69 ? val : val + 100;
- want_xday = 1;
- break;
- default:
- return NULL;
- }
- break;
- default:
- return NULL;
- }
- }
-
- if (have_I && is_pm)
- tm->tm_hour += 12;
-
- if (century != -1)
- {
- if (want_century)
- tm->tm_year = tm->tm_year % 100 + (century - 19) * 100;
- else
- /* Only the century, but not the year. Strange, but so be it. */
- tm->tm_year = (century - 19) * 100;
- }
-
- if (era_cnt != -1)
- {
- era = _nl_select_era_entry (era_cnt HELPER_LOCALE_ARG);
- if (era == NULL)
- return NULL;
- if (want_era)
- tm->tm_year = (era->start_date[0]
- + ((tm->tm_year - era->offset)
- * era->absolute_direction));
- else
- /* Era start year assumed. */
- tm->tm_year = era->start_date[0];
- }
- else
- if (want_era)
- {
- /* No era found but we have seen an E modifier. Rectify some
- values. */
- if (want_century && century == -1 && tm->tm_year < 69)
- tm->tm_year += 100;
- }
-
- if (want_xday && !have_wday)
- {
- if ( !(have_mon && have_mday) && have_yday)
- {
- /* We don't have tm_mon and/or tm_mday, compute them. */
- int t_mon = 0;
- while (__mon_yday[__isleap(1900 + tm->tm_year)][t_mon] <= tm->tm_yday)
- t_mon++;
- if (!have_mon)
- tm->tm_mon = t_mon - 1;
- if (!have_mday)
- tm->tm_mday =
- (tm->tm_yday
- - __mon_yday[__isleap(1900 + tm->tm_year)][t_mon - 1] + 1);
- }
- day_of_the_week (tm);
- }
-
- if (want_xday && !have_yday)
- day_of_the_year (tm);
-
- if ((have_uweek || have_wweek) && have_wday)
- {
- int save_wday = tm->tm_wday;
- int save_mday = tm->tm_mday;
- int save_mon = tm->tm_mon;
- int w_offset = have_uweek ? 0 : 1;
-
- tm->tm_mday = 1;
- tm->tm_mon = 0;
- day_of_the_week (tm);
- if (have_mday)
- tm->tm_mday = save_mday;
- if (have_mon)
- tm->tm_mon = save_mon;
-
- if (!have_yday)
- tm->tm_yday = ((7 - (tm->tm_wday - w_offset)) % 7
- + (week_no - 1) *7
- + save_wday - w_offset);
-
- if (!have_mday || !have_mon)
- {
- int t_mon = 0;
- while (__mon_yday[__isleap(1900 + tm->tm_year)][t_mon]
- <= tm->tm_yday)
- t_mon++;
- if (!have_mon)
- tm->tm_mon = t_mon - 1;
- if (!have_mday)
- tm->tm_mday =
- (tm->tm_yday
- - __mon_yday[__isleap(1900 + tm->tm_year)][t_mon - 1] + 1);
- }
-
- tm->tm_wday = save_wday;
- }
-
- return (char *) rp;
-}
+#include <locale/localeinfo.h>
char *
-strptime (buf, format, tm LOCALE_PARAM)
+strptime (buf, format, tm)
const char *buf;
const char *format;
struct tm *tm;
- LOCALE_PARAM_DECL
{
- enum locale_status decided;
-
-#ifdef _NL_CURRENT
- decided = not;
-#else
- decided = raw;
-#endif
- return strptime_internal (buf, format, tm, &decided, -1 LOCALE_ARG);
+ enum ptime_locale_status decided = not;
+ return __strptime_internal (buf, format, tm, &decided, -1,
+ _NL_CURRENT_LOCALE);
}
-#if defined _LIBC && !defined USE_IN_EXTENDED_LOCALE_MODEL
libc_hidden_def (strptime)
-#endif
-/* Copyright (C) 2002 Free Software Foundation, Inc.
+/* Copyright (C) 2002, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
-#define USE_IN_EXTENDED_LOCALE_MODEL 1
-#include <strptime.c>
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+#include <ctype.h>
+#include <langinfo.h>
+#include <limits.h>
+#include <string.h>
+#include <time.h>
+
+#ifdef _LIBC
+# include "../locale/localeinfo.h"
+#endif
+
+
+#ifndef __P
+# if defined __GNUC__ || (defined __STDC__ && __STDC__)
+# define __P(args) args
+# else
+# define __P(args) ()
+# endif /* GCC. */
+#endif /* Not __P. */
+
+
+#if ! HAVE_LOCALTIME_R && ! defined localtime_r
+# ifdef _LIBC
+# define localtime_r __localtime_r
+# else
+/* Approximate localtime_r as best we can in its absence. */
+# define localtime_r my_localtime_r
+static struct tm *localtime_r __P ((const time_t *, struct tm *));
+static struct tm *
+localtime_r (t, tp)
+ const time_t *t;
+ struct tm *tp;
+{
+ struct tm *l = localtime (t);
+ if (! l)
+ return 0;
+ *tp = *l;
+ return tp;
+}
+# endif /* ! _LIBC */
+#endif /* ! HAVE_LOCALTIME_R && ! defined (localtime_r) */
+
+
+#define match_char(ch1, ch2) if (ch1 != ch2) return NULL
+#if defined __GNUC__ && __GNUC__ >= 2
+# define match_string(cs1, s2) \
+ ({ size_t len = strlen (cs1); \
+ int result = __strncasecmp_l ((cs1), (s2), len, locale) == 0; \
+ if (result) (s2) += len; \
+ result; })
+#else
+/* Oh come on. Get a reasonable compiler. */
+# define match_string(cs1, s2) \
+ (strncasecmp ((cs1), (s2), strlen (cs1)) ? 0 : ((s2) += strlen (cs1), 1))
+#endif
+/* We intentionally do not use isdigit() for testing because this will
+ lead to problems with the wide character version. */
+#define get_number(from, to, n) \
+ do { \
+ int __n = n; \
+ val = 0; \
+ while (*rp == ' ') \
+ ++rp; \
+ if (*rp < '0' || *rp > '9') \
+ return NULL; \
+ do { \
+ val *= 10; \
+ val += *rp++ - '0'; \
+ } while (--__n > 0 && val * 10 <= to && *rp >= '0' && *rp <= '9'); \
+ if (val < from || val > to) \
+ return NULL; \
+ } while (0)
+#ifdef _NL_CURRENT
+# define get_alt_number(from, to, n) \
+ ({ \
+ __label__ do_normal; \
+ \
+ if (*decided != raw) \
+ { \
+ val = _nl_parse_alt_digit (&rp HELPER_LOCALE_ARG); \
+ if (val == -1 && *decided != loc) \
+ { \
+ *decided = loc; \
+ goto do_normal; \
+ } \
+ if (val < from || val > to) \
+ return NULL; \
+ } \
+ else \
+ { \
+ do_normal: \
+ get_number (from, to, n); \
+ } \
+ 0; \
+ })
+#else
+# define get_alt_number(from, to, n) \
+ /* We don't have the alternate representation. */ \
+ get_number(from, to, n)
+#endif
+#define recursive(new_fmt) \
+ (*(new_fmt) != '\0' \
+ && (rp = __strptime_internal (rp, (new_fmt), tm, \
+ decided, era_cnt LOCALE_ARG)) != NULL)
+
+
+#ifdef _LIBC
+/* This is defined in locale/C-time.c in the GNU libc. */
+extern const struct locale_data _nl_C_LC_TIME attribute_hidden;
+
+# define weekday_name (&_nl_C_LC_TIME.values[_NL_ITEM_INDEX (DAY_1)].string)
+# define ab_weekday_name \
+ (&_nl_C_LC_TIME.values[_NL_ITEM_INDEX (ABDAY_1)].string)
+# define month_name (&_nl_C_LC_TIME.values[_NL_ITEM_INDEX (MON_1)].string)
+# define ab_month_name (&_nl_C_LC_TIME.values[_NL_ITEM_INDEX (ABMON_1)].string)
+# define HERE_D_T_FMT (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (D_T_FMT)].string)
+# define HERE_D_FMT (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (D_FMT)].string)
+# define HERE_AM_STR (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (AM_STR)].string)
+# define HERE_PM_STR (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (PM_STR)].string)
+# define HERE_T_FMT_AMPM \
+ (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (T_FMT_AMPM)].string)
+# define HERE_T_FMT (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (T_FMT)].string)
+
+# define strncasecmp(s1, s2, n) __strncasecmp (s1, s2, n)
+#else
+static char const weekday_name[][10] =
+ {
+ "Sunday", "Monday", "Tuesday", "Wednesday",
+ "Thursday", "Friday", "Saturday"
+ };
+static char const ab_weekday_name[][4] =
+ {
+ "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
+ };
+static char const month_name[][10] =
+ {
+ "January", "February", "March", "April", "May", "June",
+ "July", "August", "September", "October", "November", "December"
+ };
+static char const ab_month_name[][4] =
+ {
+ "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+ "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
+ };
+# define HERE_D_T_FMT "%a %b %e %H:%M:%S %Y"
+# define HERE_D_FMT "%m/%d/%y"
+# define HERE_AM_STR "AM"
+# define HERE_PM_STR "PM"
+# define HERE_T_FMT_AMPM "%I:%M:%S %p"
+# define HERE_T_FMT "%H:%M:%S"
+
+static const unsigned short int __mon_yday[2][13] =
+ {
+ /* Normal years. */
+ { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 },
+ /* Leap years. */
+ { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }
+ };
+#endif
+
+#if defined _LIBC
+/* We use this code also for the extended locale handling where the
+ function gets as an additional argument the locale which has to be
+ used. To access the values we have to redefine the _NL_CURRENT
+ macro. */
+# define strptime __strptime_l
+# undef _NL_CURRENT
+# define _NL_CURRENT(category, item) \
+ (current->values[_NL_ITEM_INDEX (item)].string)
+# undef _NL_CURRENT_WORD
+# define _NL_CURRENT_WORD(category, item) \
+ (current->values[_NL_ITEM_INDEX (item)].word)
+# define LOCALE_PARAM , locale
+# define LOCALE_ARG , locale
+# define LOCALE_PARAM_PROTO , __locale_t locale
+# define LOCALE_PARAM_DECL __locale_t locale;
+# define HELPER_LOCALE_ARG , current
+# define ISSPACE(Ch) __isspace_l (Ch, locale)
+#else
+# define LOCALE_PARAM
+# define LOCALE_ARG
+# define LOCALE_PARAM_DECL
+# define LOCALE_PARAM_PROTO
+# define HELPER_LOCALE_ARG
+# define ISSPACE(Ch) isspace (Ch)
+#endif
+
+
+
+
+#ifndef __isleap
+/* Nonzero if YEAR is a leap year (every 4 years,
+ except every 100th isn't, and every 400th is). */
+# define __isleap(year) \
+ ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
+#endif
+
+/* Compute the day of the week. */
+static void
+day_of_the_week (struct tm *tm)
+{
+ /* We know that January 1st 1970 was a Thursday (= 4). Compute the
+ the difference between this data in the one on TM and so determine
+ the weekday. */
+ int corr_year = 1900 + tm->tm_year - (tm->tm_mon < 2);
+ int wday = (-473
+ + (365 * (tm->tm_year - 70))
+ + (corr_year / 4)
+ - ((corr_year / 4) / 25) + ((corr_year / 4) % 25 < 0)
+ + (((corr_year / 4) / 25) / 4)
+ + __mon_yday[0][tm->tm_mon]
+ + tm->tm_mday - 1);
+ tm->tm_wday = ((wday % 7) + 7) % 7;
+}
+
+/* Compute the day of the year. */
+static void
+day_of_the_year (struct tm *tm)
+{
+ tm->tm_yday = (__mon_yday[__isleap (1900 + tm->tm_year)][tm->tm_mon]
+ + (tm->tm_mday - 1));
+}
+
+
+#ifdef _LIBC
+char *
+internal_function
+#else
+static char *
+#endif
+__strptime_internal (rp, fmt, tm, decided, era_cnt LOCALE_PARAM)
+ const char *rp;
+ const char *fmt;
+ struct tm *tm;
+ enum ptime_locale_status *decided;
+ int era_cnt;
+ LOCALE_PARAM_DECL
+{
+#ifdef _LIBC
+ struct locale_data *const current = locale->__locales[LC_TIME];
+#endif
+
+ const char *rp_backup;
+ int cnt;
+ size_t val;
+ int have_I, is_pm;
+ int century, want_century;
+ int want_era;
+ int have_wday, want_xday;
+ int have_yday;
+ int have_mon, have_mday;
+ int have_uweek, have_wweek;
+ int week_no;
+ size_t num_eras;
+ struct era_entry *era;
+
+ have_I = is_pm = 0;
+ century = -1;
+ want_century = 0;
+ want_era = 0;
+ era = NULL;
+ week_no = 0;
+
+ have_wday = want_xday = have_yday = have_mon = have_mday = have_uweek = 0;
+ have_wweek = 0;
+
+ while (*fmt != '\0')
+ {
+ /* A white space in the format string matches 0 more or white
+ space in the input string. */
+ if (ISSPACE (*fmt))
+ {
+ while (ISSPACE (*rp))
+ ++rp;
+ ++fmt;
+ continue;
+ }
+
+ /* Any character but `%' must be matched by the same character
+ in the iput string. */
+ if (*fmt != '%')
+ {
+ match_char (*fmt++, *rp++);
+ continue;
+ }
+
+ ++fmt;
+#ifndef _NL_CURRENT
+ /* We need this for handling the `E' modifier. */
+ start_over:
+#endif
+
+ /* Make back up of current processing pointer. */
+ rp_backup = rp;
+
+ switch (*fmt++)
+ {
+ case '%':
+ /* Match the `%' character itself. */
+ match_char ('%', *rp++);
+ break;
+ case 'a':
+ case 'A':
+ /* Match day of week. */
+ for (cnt = 0; cnt < 7; ++cnt)
+ {
+#ifdef _NL_CURRENT
+ if (*decided !=raw)
+ {
+ if (match_string (_NL_CURRENT (LC_TIME, DAY_1 + cnt), rp))
+ {
+ if (*decided == not
+ && strcmp (_NL_CURRENT (LC_TIME, DAY_1 + cnt),
+ weekday_name[cnt]))
+ *decided = loc;
+ break;
+ }
+ if (match_string (_NL_CURRENT (LC_TIME, ABDAY_1 + cnt), rp))
+ {
+ if (*decided == not
+ && strcmp (_NL_CURRENT (LC_TIME, ABDAY_1 + cnt),
+ ab_weekday_name[cnt]))
+ *decided = loc;
+ break;
+ }
+ }
+#endif
+ if (*decided != loc
+ && (match_string (weekday_name[cnt], rp)
+ || match_string (ab_weekday_name[cnt], rp)))
+ {
+ *decided = raw;
+ break;
+ }
+ }
+ if (cnt == 7)
+ /* Does not match a weekday name. */
+ return NULL;
+ tm->tm_wday = cnt;
+ have_wday = 1;
+ break;
+ case 'b':
+ case 'B':
+ case 'h':
+ /* Match month name. */
+ for (cnt = 0; cnt < 12; ++cnt)
+ {
+#ifdef _NL_CURRENT
+ if (*decided !=raw)
+ {
+ if (match_string (_NL_CURRENT (LC_TIME, MON_1 + cnt), rp))
+ {
+ if (*decided == not
+ && strcmp (_NL_CURRENT (LC_TIME, MON_1 + cnt),
+ month_name[cnt]))
+ *decided = loc;
+ break;
+ }
+ if (match_string (_NL_CURRENT (LC_TIME, ABMON_1 + cnt), rp))
+ {
+ if (*decided == not
+ && strcmp (_NL_CURRENT (LC_TIME, ABMON_1 + cnt),
+ ab_month_name[cnt]))
+ *decided = loc;
+ break;
+ }
+ }
+#endif
+ if (match_string (month_name[cnt], rp)
+ || match_string (ab_month_name[cnt], rp))
+ {
+ *decided = raw;
+ break;
+ }
+ }
+ if (cnt == 12)
+ /* Does not match a month name. */
+ return NULL;
+ tm->tm_mon = cnt;
+ want_xday = 1;
+ break;
+ case 'c':
+ /* Match locale's date and time format. */
+#ifdef _NL_CURRENT
+ if (*decided != raw)
+ {
+ if (!recursive (_NL_CURRENT (LC_TIME, D_T_FMT)))
+ {
+ if (*decided == loc)
+ return NULL;
+ else
+ rp = rp_backup;
+ }
+ else
+ {
+ if (*decided == not &&
+ strcmp (_NL_CURRENT (LC_TIME, D_T_FMT), HERE_D_T_FMT))
+ *decided = loc;
+ want_xday = 1;
+ break;
+ }
+ *decided = raw;
+ }
+#endif
+ if (!recursive (HERE_D_T_FMT))
+ return NULL;
+ want_xday = 1;
+ break;
+ case 'C':
+ /* Match century number. */
+ match_century:
+ get_number (0, 99, 2);
+ century = val;
+ want_xday = 1;
+ break;
+ case 'd':
+ case 'e':
+ /* Match day of month. */
+ get_number (1, 31, 2);
+ tm->tm_mday = val;
+ have_mday = 1;
+ want_xday = 1;
+ break;
+ case 'F':
+ if (!recursive ("%Y-%m-%d"))
+ return NULL;
+ want_xday = 1;
+ break;
+ case 'x':
+#ifdef _NL_CURRENT
+ if (*decided != raw)
+ {
+ if (!recursive (_NL_CURRENT (LC_TIME, D_FMT)))
+ {
+ if (*decided == loc)
+ return NULL;
+ else
+ rp = rp_backup;
+ }
+ else
+ {
+ if (*decided == not
+ && strcmp (_NL_CURRENT (LC_TIME, D_FMT), HERE_D_FMT))
+ *decided = loc;
+ want_xday = 1;
+ break;
+ }
+ *decided = raw;
+ }
+#endif
+ /* Fall through. */
+ case 'D':
+ /* Match standard day format. */
+ if (!recursive (HERE_D_FMT))
+ return NULL;
+ want_xday = 1;
+ break;
+ case 'k':
+ case 'H':
+ /* Match hour in 24-hour clock. */
+ get_number (0, 23, 2);
+ tm->tm_hour = val;
+ have_I = 0;
+ break;
+ case 'l':
+ /* Match hour in 12-hour clock. GNU extension. */
+ case 'I':
+ /* Match hour in 12-hour clock. */
+ get_number (1, 12, 2);
+ tm->tm_hour = val % 12;
+ have_I = 1;
+ break;
+ case 'j':
+ /* Match day number of year. */
+ get_number (1, 366, 3);
+ tm->tm_yday = val - 1;
+ have_yday = 1;
+ break;
+ case 'm':
+ /* Match number of month. */
+ get_number (1, 12, 2);
+ tm->tm_mon = val - 1;
+ have_mon = 1;
+ want_xday = 1;
+ break;
+ case 'M':
+ /* Match minute. */
+ get_number (0, 59, 2);
+ tm->tm_min = val;
+ break;
+ case 'n':
+ case 't':
+ /* Match any white space. */
+ while (ISSPACE (*rp))
+ ++rp;
+ break;
+ case 'p':
+ /* Match locale's equivalent of AM/PM. */
+#ifdef _NL_CURRENT
+ if (*decided != raw)
+ {
+ if (match_string (_NL_CURRENT (LC_TIME, AM_STR), rp))
+ {
+ if (strcmp (_NL_CURRENT (LC_TIME, AM_STR), HERE_AM_STR))
+ *decided = loc;
+ break;
+ }
+ if (match_string (_NL_CURRENT (LC_TIME, PM_STR), rp))
+ {
+ if (strcmp (_NL_CURRENT (LC_TIME, PM_STR), HERE_PM_STR))
+ *decided = loc;
+ is_pm = 1;
+ break;
+ }
+ *decided = raw;
+ }
+#endif
+ if (!match_string (HERE_AM_STR, rp))
+ if (match_string (HERE_PM_STR, rp))
+ is_pm = 1;
+ else
+ return NULL;
+ break;
+ case 'r':
+#ifdef _NL_CURRENT
+ if (*decided != raw)
+ {
+ if (!recursive (_NL_CURRENT (LC_TIME, T_FMT_AMPM)))
+ {
+ if (*decided == loc)
+ return NULL;
+ else
+ rp = rp_backup;
+ }
+ else
+ {
+ if (*decided == not &&
+ strcmp (_NL_CURRENT (LC_TIME, T_FMT_AMPM),
+ HERE_T_FMT_AMPM))
+ *decided = loc;
+ break;
+ }
+ *decided = raw;
+ }
+#endif
+ if (!recursive (HERE_T_FMT_AMPM))
+ return NULL;
+ break;
+ case 'R':
+ if (!recursive ("%H:%M"))
+ return NULL;
+ break;
+ case 's':
+ {
+ /* The number of seconds may be very high so we cannot use
+ the `get_number' macro. Instead read the number
+ character for character and construct the result while
+ doing this. */
+ time_t secs = 0;
+ if (*rp < '0' || *rp > '9')
+ /* We need at least one digit. */
+ return NULL;
+
+ do
+ {
+ secs *= 10;
+ secs += *rp++ - '0';
+ }
+ while (*rp >= '0' && *rp <= '9');
+
+ if (localtime_r (&secs, tm) == NULL)
+ /* Error in function. */
+ return NULL;
+ }
+ break;
+ case 'S':
+ get_number (0, 61, 2);
+ tm->tm_sec = val;
+ break;
+ case 'X':
+#ifdef _NL_CURRENT
+ if (*decided != raw)
+ {
+ if (!recursive (_NL_CURRENT (LC_TIME, T_FMT)))
+ {
+ if (*decided == loc)
+ return NULL;
+ else
+ rp = rp_backup;
+ }
+ else
+ {
+ if (strcmp (_NL_CURRENT (LC_TIME, T_FMT), HERE_T_FMT))
+ *decided = loc;
+ break;
+ }
+ *decided = raw;
+ }
+#endif
+ /* Fall through. */
+ case 'T':
+ if (!recursive (HERE_T_FMT))
+ return NULL;
+ break;
+ case 'u':
+ get_number (1, 7, 1);
+ tm->tm_wday = val % 7;
+ have_wday = 1;
+ break;
+ case 'g':
+ get_number (0, 99, 2);
+ /* XXX This cannot determine any field in TM. */
+ break;
+ case 'G':
+ if (*rp < '0' || *rp > '9')
+ return NULL;
+ /* XXX Ignore the number since we would need some more
+ information to compute a real date. */
+ do
+ ++rp;
+ while (*rp >= '0' && *rp <= '9');
+ break;
+ case 'U':
+ get_number (0, 53, 2);
+ week_no = val;
+ have_uweek = 1;
+ break;
+ case 'W':
+ get_number (0, 53, 2);
+ week_no = val;
+ have_wweek = 1;
+ break;
+ case 'V':
+ get_number (0, 53, 2);
+ /* XXX This cannot determine any field in TM without some
+ information. */
+ break;
+ case 'w':
+ /* Match number of weekday. */
+ get_number (0, 6, 1);
+ tm->tm_wday = val;
+ have_wday = 1;
+ break;
+ case 'y':
+ match_year_in_century:
+ /* Match year within century. */
+ get_number (0, 99, 2);
+ /* The "Year 2000: The Millennium Rollover" paper suggests that
+ values in the range 69-99 refer to the twentieth century. */
+ tm->tm_year = val >= 69 ? val : val + 100;
+ /* Indicate that we want to use the century, if specified. */
+ want_century = 1;
+ want_xday = 1;
+ break;
+ case 'Y':
+ /* Match year including century number. */
+ get_number (0, 9999, 4);
+ tm->tm_year = val - 1900;
+ want_century = 0;
+ want_xday = 1;
+ break;
+ case 'Z':
+ /* XXX How to handle this? */
+ break;
+ case 'E':
+#ifdef _NL_CURRENT
+ switch (*fmt++)
+ {
+ case 'c':
+ /* Match locale's alternate date and time format. */
+ if (*decided != raw)
+ {
+ const char *fmt = _NL_CURRENT (LC_TIME, ERA_D_T_FMT);
+
+ if (*fmt == '\0')
+ fmt = _NL_CURRENT (LC_TIME, D_T_FMT);
+
+ if (!recursive (fmt))
+ {
+ if (*decided == loc)
+ return NULL;
+ else
+ rp = rp_backup;
+ }
+ else
+ {
+ if (strcmp (fmt, HERE_D_T_FMT))
+ *decided = loc;
+ want_xday = 1;
+ break;
+ }
+ *decided = raw;
+ }
+ /* The C locale has no era information, so use the
+ normal representation. */
+ if (!recursive (HERE_D_T_FMT))
+ return NULL;
+ want_xday = 1;
+ break;
+ case 'C':
+ if (*decided != raw)
+ {
+ if (era_cnt >= 0)
+ {
+ era = _nl_select_era_entry (era_cnt HELPER_LOCALE_ARG);
+ if (era != NULL && match_string (era->era_name, rp))
+ {
+ *decided = loc;
+ break;
+ }
+ else
+ return NULL;
+ }
+ else
+ {
+ num_eras = _NL_CURRENT_WORD (LC_TIME,
+ _NL_TIME_ERA_NUM_ENTRIES);
+ for (era_cnt = 0; era_cnt < (int) num_eras;
+ ++era_cnt, rp = rp_backup)
+ {
+ era = _nl_select_era_entry (era_cnt
+ HELPER_LOCALE_ARG);
+ if (era != NULL && match_string (era->era_name, rp))
+ {
+ *decided = loc;
+ break;
+ }
+ }
+ if (era_cnt == (int) num_eras)
+ {
+ era_cnt = -1;
+ if (*decided == loc)
+ return NULL;
+ }
+ else
+ break;
+ }
+
+ *decided = raw;
+ }
+ /* The C locale has no era information, so use the
+ normal representation. */
+ goto match_century;
+ case 'y':
+ if (*decided == raw)
+ goto match_year_in_century;
+
+ get_number(0, 9999, 4);
+ tm->tm_year = val;
+ want_era = 1;
+ want_xday = 1;
+ want_century = 1;
+ break;
+ case 'Y':
+ if (*decided != raw)
+ {
+ num_eras = _NL_CURRENT_WORD (LC_TIME,
+ _NL_TIME_ERA_NUM_ENTRIES);
+ for (era_cnt = 0; era_cnt < (int) num_eras;
+ ++era_cnt, rp = rp_backup)
+ {
+ era = _nl_select_era_entry (era_cnt HELPER_LOCALE_ARG);
+ if (era != NULL && recursive (era->era_format))
+ break;
+ }
+ if (era_cnt == (int) num_eras)
+ {
+ era_cnt = -1;
+ if (*decided == loc)
+ return NULL;
+ else
+ rp = rp_backup;
+ }
+ else
+ {
+ *decided = loc;
+ era_cnt = -1;
+ break;
+ }
+
+ *decided = raw;
+ }
+ get_number (0, 9999, 4);
+ tm->tm_year = val - 1900;
+ want_century = 0;
+ want_xday = 1;
+ break;
+ case 'x':
+ if (*decided != raw)
+ {
+ const char *fmt = _NL_CURRENT (LC_TIME, ERA_D_FMT);
+
+ if (*fmt == '\0')
+ fmt = _NL_CURRENT (LC_TIME, D_FMT);
+
+ if (!recursive (fmt))
+ {
+ if (*decided == loc)
+ return NULL;
+ else
+ rp = rp_backup;
+ }
+ else
+ {
+ if (strcmp (fmt, HERE_D_FMT))
+ *decided = loc;
+ break;
+ }
+ *decided = raw;
+ }
+ if (!recursive (HERE_D_FMT))
+ return NULL;
+ break;
+ case 'X':
+ if (*decided != raw)
+ {
+ const char *fmt = _NL_CURRENT (LC_TIME, ERA_T_FMT);
+
+ if (*fmt == '\0')
+ fmt = _NL_CURRENT (LC_TIME, T_FMT);
+
+ if (!recursive (fmt))
+ {
+ if (*decided == loc)
+ return NULL;
+ else
+ rp = rp_backup;
+ }
+ else
+ {
+ if (strcmp (fmt, HERE_T_FMT))
+ *decided = loc;
+ break;
+ }
+ *decided = raw;
+ }
+ if (!recursive (HERE_T_FMT))
+ return NULL;
+ break;
+ default:
+ return NULL;
+ }
+ break;
+#else
+ /* We have no information about the era format. Just use
+ the normal format. */
+ if (*fmt != 'c' && *fmt != 'C' && *fmt != 'y' && *fmt != 'Y'
+ && *fmt != 'x' && *fmt != 'X')
+ /* This is an illegal format. */
+ return NULL;
+
+ goto start_over;
+#endif
+ case 'O':
+ switch (*fmt++)
+ {
+ case 'd':
+ case 'e':
+ /* Match day of month using alternate numeric symbols. */
+ get_alt_number (1, 31, 2);
+ tm->tm_mday = val;
+ have_mday = 1;
+ want_xday = 1;
+ break;
+ case 'H':
+ /* Match hour in 24-hour clock using alternate numeric
+ symbols. */
+ get_alt_number (0, 23, 2);
+ tm->tm_hour = val;
+ have_I = 0;
+ break;
+ case 'I':
+ /* Match hour in 12-hour clock using alternate numeric
+ symbols. */
+ get_alt_number (1, 12, 2);
+ tm->tm_hour = val % 12;
+ have_I = 1;
+ break;
+ case 'm':
+ /* Match month using alternate numeric symbols. */
+ get_alt_number (1, 12, 2);
+ tm->tm_mon = val - 1;
+ have_mon = 1;
+ want_xday = 1;
+ break;
+ case 'M':
+ /* Match minutes using alternate numeric symbols. */
+ get_alt_number (0, 59, 2);
+ tm->tm_min = val;
+ break;
+ case 'S':
+ /* Match seconds using alternate numeric symbols. */
+ get_alt_number (0, 61, 2);
+ tm->tm_sec = val;
+ break;
+ case 'U':
+ get_alt_number (0, 53, 2);
+ week_no = val;
+ have_uweek = 1;
+ break;
+ case 'W':
+ get_alt_number (0, 53, 2);
+ week_no = val;
+ have_wweek = 1;
+ break;
+ case 'V':
+ get_alt_number (0, 53, 2);
+ /* XXX This cannot determine any field in TM without
+ further information. */
+ break;
+ case 'w':
+ /* Match number of weekday using alternate numeric symbols. */
+ get_alt_number (0, 6, 1);
+ tm->tm_wday = val;
+ have_wday = 1;
+ break;
+ case 'y':
+ /* Match year within century using alternate numeric symbols. */
+ get_alt_number (0, 99, 2);
+ tm->tm_year = val >= 69 ? val : val + 100;
+ want_xday = 1;
+ break;
+ default:
+ return NULL;
+ }
+ break;
+ default:
+ return NULL;
+ }
+ }
+
+ if (have_I && is_pm)
+ tm->tm_hour += 12;
+
+ if (century != -1)
+ {
+ if (want_century)
+ tm->tm_year = tm->tm_year % 100 + (century - 19) * 100;
+ else
+ /* Only the century, but not the year. Strange, but so be it. */
+ tm->tm_year = (century - 19) * 100;
+ }
+
+ if (era_cnt != -1)
+ {
+ era = _nl_select_era_entry (era_cnt HELPER_LOCALE_ARG);
+ if (era == NULL)
+ return NULL;
+ if (want_era)
+ tm->tm_year = (era->start_date[0]
+ + ((tm->tm_year - era->offset)
+ * era->absolute_direction));
+ else
+ /* Era start year assumed. */
+ tm->tm_year = era->start_date[0];
+ }
+ else
+ if (want_era)
+ {
+ /* No era found but we have seen an E modifier. Rectify some
+ values. */
+ if (want_century && century == -1 && tm->tm_year < 69)
+ tm->tm_year += 100;
+ }
+
+ if (want_xday && !have_wday)
+ {
+ if ( !(have_mon && have_mday) && have_yday)
+ {
+ /* We don't have tm_mon and/or tm_mday, compute them. */
+ int t_mon = 0;
+ while (__mon_yday[__isleap(1900 + tm->tm_year)][t_mon] <= tm->tm_yday)
+ t_mon++;
+ if (!have_mon)
+ tm->tm_mon = t_mon - 1;
+ if (!have_mday)
+ tm->tm_mday =
+ (tm->tm_yday
+ - __mon_yday[__isleap(1900 + tm->tm_year)][t_mon - 1] + 1);
+ }
+ day_of_the_week (tm);
+ }
+
+ if (want_xday && !have_yday)
+ day_of_the_year (tm);
+
+ if ((have_uweek || have_wweek) && have_wday)
+ {
+ int save_wday = tm->tm_wday;
+ int save_mday = tm->tm_mday;
+ int save_mon = tm->tm_mon;
+ int w_offset = have_uweek ? 0 : 1;
+
+ tm->tm_mday = 1;
+ tm->tm_mon = 0;
+ day_of_the_week (tm);
+ if (have_mday)
+ tm->tm_mday = save_mday;
+ if (have_mon)
+ tm->tm_mon = save_mon;
+
+ if (!have_yday)
+ tm->tm_yday = ((7 - (tm->tm_wday - w_offset)) % 7
+ + (week_no - 1) *7
+ + save_wday - w_offset);
+
+ if (!have_mday || !have_mon)
+ {
+ int t_mon = 0;
+ while (__mon_yday[__isleap(1900 + tm->tm_year)][t_mon]
+ <= tm->tm_yday)
+ t_mon++;
+ if (!have_mon)
+ tm->tm_mon = t_mon - 1;
+ if (!have_mday)
+ tm->tm_mday =
+ (tm->tm_yday
+ - __mon_yday[__isleap(1900 + tm->tm_year)][t_mon - 1] + 1);
+ }
+
+ tm->tm_wday = save_wday;
+ }
+
+ return (char *) rp;
+}
+
+
+char *
+strptime (buf, format, tm LOCALE_PARAM)
+ const char *buf;
+ const char *format;
+ struct tm *tm;
+ LOCALE_PARAM_DECL
+{
+ enum ptime_locale_status decided;
+
+#ifdef _NL_CURRENT
+ decided = not;
+#else
+ decided = raw;
+#endif
+ return __strptime_internal (buf, format, tm, &decided, -1 LOCALE_ARG);
+}
+
+#ifdef _LIBC
weak_alias (__strptime_l, strptime_l)
+#endif
-#include <wctype.h>
+/* Copyright (C) 1991-1999, 2000, 2001, 2002, 2003, 2004
+ Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
#include <wchar.h>
-#define COMPILE_WIDE 1
-#include "strftime.c"
+#include <locale/localeinfo.h>
+
+
+size_t
+wcsftime (wchar_t *s, size_t maxsize, const wchar_t *format,
+ const struct tm *tp)
+{
+ return __wcsftime_l (s, maxsize, format, tp, _NL_CURRENT_LOCALE);
+}
+libc_hidden_def (wcsftime)
-/* Copyright (C) 2002 Free Software Foundation, Inc.
+/* Copyright (C) 2002, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
+#include <wchar.h>
+#include <wctype.h>
+
#define USE_IN_EXTENDED_LOCALE_MODEL 1
-#include <wcsftime.c>
+#define COMPILE_WIDE 1
+#include "strftime_l.c"
weak_alias (__wcsftime_l, wcsftime_l)
-/* Copyright (C) 1996, 1997, 1999, 2000, 2001 Free Software Foundation, Inc.
+/* Copyright (C) 1996,1997,1999,2000,2001,2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1996.
#define STRING_TYPE wchar_t
#define USTRING_TYPE wint_t
-#ifdef USE_IN_EXTENDED_LOCALE_MODEL
-# define STRCOLL __wcscoll_l
-#else
-# define STRCOLL __wcscoll
-#endif
-#define STRCMP wcscmp
-#define STRLEN __wcslen
-#define WEIGHT_H "../locale/weightwc.h"
-#define SUFFIX WC
-#define L(arg) L##arg
-#define WIDE_CHAR_VERSION 1
+#define STRCOLL __wcscoll
+#define STRCOLL_L __wcscoll_l
#include "../string/strcoll.c"
-/* Copyright (C) 1996, 1997, 2002 Free Software Foundation, Inc.
+/* Copyright (C) 1996, 1997, 2002, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1996.
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
-#define USE_IN_EXTENDED_LOCALE_MODEL 1
-#include <wcscoll.c>
+
+#include <wchar.h>
+#include "../locale/coll-lookup.h"
+
+#define STRING_TYPE wchar_t
+#define USTRING_TYPE wint_t
+#define STRCOLL __wcscoll_l
+#define STRCMP wcscmp
+#define STRLEN __wcslen
+#define WEIGHT_H "../locale/weightwc.h"
+#define SUFFIX WC
+#define L(arg) L##arg
+#define WIDE_CHAR_VERSION 1
+
+#include "../string/strcoll_l.c"
weak_alias (__wcscoll_l, wcscoll_l)
-/* Copyright (C) 1996, 1997 Free Software Foundation, Inc.
+/* Copyright (C) 1996, 1997, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1996.
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
+#include <stddef.h>
+#include <xlocale.h>
-/* The actual implementation for all floating point sizes is in strtod.c. */
#define USE_WIDE_CHAR 1
+extern double ____wcstod_l_internal (const wchar_t *, wchar_t **, int,
+ __locale_t);
+
#include <stdlib/strtod.c>
/* Convert string representing a number to integer value, using given locale.
- Copyright (C) 1997, 1998, 2002 Free Software Foundation, Inc.
+ Copyright (C) 1997, 1998, 2002, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
-#define __need_wchar_t
#include <stddef.h>
-#include <locale.h>
+#include <xlocale.h>
-#define USE_IN_EXTENDED_LOCALE_MODEL 1
extern double ____wcstod_l_internal (const wchar_t *, wchar_t **, int,
__locale_t);
wchar_t **, int, int,
__locale_t);
-#include <wcstod.c>
+#define USE_WIDE_CHAR 1
-weak_alias (__wcstod_l, wcstod_l)
+#include <stdlib/strtod_l.c>
-/* Copyright (C) 1996, 1997 Free Software Foundation, Inc.
+/* Copyright (C) 1996, 1997, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1996.
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
+#include <stddef.h>
+#include <xlocale.h>
-/* The actual implementation for all floating point sizes is in strtod.c.
- These macros tell it to produce the `float' version, `wcstof'. */
-
-#define FLOAT float
-#define FLT FLT
-#ifdef USE_IN_EXTENDED_LOCALE_MODEL
-# define STRTOF __wcstof_l
-#else
-# define STRTOF wcstof
-#endif
-#define MPN2FLOAT __mpn_construct_float
-#define FLOAT_HUGE_VAL HUGE_VALF
#define USE_WIDE_CHAR 1
-#define SET_MANTISSA(flt, mant) \
- do { union ieee754_float u; \
- u.f = (flt); \
- if ((mant & 0x7fffff) == 0) \
- mant = 0x400000; \
- u.ieee.mantissa = (mant) & 0x7fffff; \
- (flt) = u.f; \
- } while (0)
-#include <stdlib/strtod.c>
+extern float ____wcstof_l_internal (const wchar_t *, wchar_t **, int,
+ __locale_t);
+
+#include <stdlib/strtof.c>
/* Convert string representing a number to integer value, using given locale.
- Copyright (C) 1997,98,2002 Free Software Foundation, Inc.
+ Copyright (C) 1997,98,2002, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
-#define __need_wchar_t
#include <stddef.h>
-#include <locale.h>
+#include <xlocale.h>
-#define USE_IN_EXTENDED_LOCALE_MODEL 1
+
+#define USE_WIDE_CHAR 1
extern float ____wcstof_l_internal (const wchar_t *, wchar_t **, int,
__locale_t);
wchar_t **, int, int,
__locale_t);
-#include <wcstof.c>
-
-weak_alias (__wcstof_l, wcstof_l)
+#include <stdlib/strtof_l.c>
-/* Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc.
+/* Copyright (C) 1996, 1997, 1998, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1996.
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
-#include <math.h>
-#include <wchar.h>
+#include <stddef.h>
+#include <xlocale.h>
-#ifndef __NO_LONG_DOUBLE_MATH
-/* The actual implementation for all floating point sizes is in strtod.c.
- These macros tell it to produce the `long double' version, `wcstold'. */
+#define USE_WIDE_CHAR 1
-# define FLOAT long double
-# define FLT LDBL
-# ifdef USE_IN_EXTENDED_LOCALE_MODEL
-# define STRTOF __wcstold_l
-# else
-# define STRTOF wcstold
-# endif
-# define MPN2FLOAT __mpn_construct_long_double
-# define FLOAT_HUGE_VAL HUGE_VALL
-# define USE_WIDE_CHAR 1
-# define SET_MANTISSA(flt, mant) \
- do { union ieee854_long_double u; \
- u.d = (flt); \
- if ((mant & 0x7fffffffffffffffULL) == 0) \
- mant = 0x4000000000000000ULL; \
- u.ieee.mantissa0 = (((mant) >> 32) & 0x7fffffff) | 0x80000000; \
- u.ieee.mantissa1 = (mant) & 0xffffffff; \
- (flt) = u.d; \
- } while (0)
+extern long double ____wcstold_l_internal (const wchar_t *, wchar_t **, int,
+ __locale_t);
-# include <stdlib/strtod.c>
-#else
-/* There is no `long double' type, use the `double' implementations. */
-long double
-__wcstold_internal (const wchar_t *nptr, wchar_t **endptr, int group)
-{
- return __wcstod_internal (nptr, endptr, group);
-}
-libc_hidden_def (__wcstold_internal)
-
-long double
-wcstold (const wchar_t *nptr, wchar_t **endptr)
-{
- return __wcstod_internal (nptr, endptr, 0);
-}
-#endif
+#include <stdlib/strtold.c>
/* Convert string representing a number to integer value, using given locale.
- Copyright (C) 1997,98,99,2002 Free Software Foundation, Inc.
+ Copyright (C) 1997,98,99,2002, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
-#define __need_wchar_t
-#include <math.h>
#include <stddef.h>
-#include <locale.h>
-#include <wchar.h>
+#include <xlocale.h>
-#define USE_IN_EXTENDED_LOCALE_MODEL 1
-
-#ifndef __NO_LONG_DOUBLE_MATH
+#define USE_WIDE_CHAR 1
extern long double ____wcstold_l_internal (const wchar_t *, wchar_t **, int,
__locale_t);
wchar_t **, int, int,
__locale_t);
-# include <wcstold.c>
-#else
-/* There is no `long double' type, use the `double' implementations. */
-extern double ____wcstod_l_internal (const wchar_t *, wchar_t **, int,
- __locale_t);
-long double
-____wcstold_l_internal (const wchar_t *nptr, wchar_t **endptr, int group,
- __locale_t loc)
-{
- return ____wcstod_l_internal (nptr, endptr, group, loc);
-}
-
-long double
-__wcstold_l (const wchar_t *nptr, wchar_t **endptr, __locale_t loc)
-{
- return ____wcstod_l_internal (nptr, endptr, 0, loc);
-}
-#endif
-
-weak_alias (__wcstold_l, wcstold_l)
+#include <strtold_l.c>
-/* Copyright (C) 1996, 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2000, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1996.
#include "../locale/coll-lookup.h"
#define STRING_TYPE wchar_t
-#define USTRING_TYPE wint_t
-#ifdef USE_IN_EXTENDED_LOCALE_MODEL
-# define STRXFRM __wcsxfrm_l
-#else
-# define STRXFRM wcsxfrm
-#endif
-#define STRCMP wcscmp
-#define STRLEN __wcslen
-#define STPNCPY __wcpncpy
-#define WEIGHT_H "../locale/weightwc.h"
-#define SUFFIX WC
-#define L(arg) L##arg
-#define WIDE_CHAR_VERSION 1
+#define STRXFRM wcsxfrm
+#define STRXFRM_L __wcsxfrm_l
#include "../string/strxfrm.c"
-/* Copyright (C) 1996,97,2002 Free Software Foundation, Inc.
+/* Copyright (C) 1996,97,2002, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1996.
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
-#define USE_IN_EXTENDED_LOCALE_MODEL 1
-#include <wcsxfrm.c>
+#include <wchar.h>
+#include "../locale/coll-lookup.h"
+
+#define STRING_TYPE wchar_t
+#define USTRING_TYPE wint_t
+#define STRXFRM __wcsxfrm_l
+#define STRCMP wcscmp
+#define STRLEN __wcslen
+#define STPNCPY __wcpncpy
+#define WEIGHT_H "../locale/weightwc.h"
+#define SUFFIX WC
+#define L(arg) L##arg
+#define WIDE_CHAR_VERSION 1
+
+#include "../string/strxfrm_l.c"
weak_alias (__wcsxfrm_l, wcsxfrm_l)
projects / external / glibc.git / commitdiff