953c6c4a90c9b4ea636e4c2b33dd019e2d6dcaf7
[kopensolaris-gnu/glibc.git] / sysdeps / generic / strtol.c
1 /* Convert string representation of a number into an integer value.
2    Copyright (C) 1991,92,94,95,96,97,98,99,2000,2001,2002,2003
3         Free Software Foundation, Inc.
4    This file is part of the GNU C Library.
5
6    The GNU C Library is free software; you can redistribute it and/or
7    modify it under the terms of the GNU Lesser General Public
8    License as published by the Free Software Foundation; either
9    version 2.1 of the License, or (at your option) any later version.
10
11    The GNU C Library is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14    Lesser General Public License for more details.
15
16    You should have received a copy of the GNU Lesser General Public
17    License along with the GNU C Library; if not, write to the Free
18    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
19    02111-1307 USA.  */
20
21 #if HAVE_CONFIG_H
22 # include <config.h>
23 #endif
24
25 #ifdef _LIBC
26 # define USE_NUMBER_GROUPING
27 # define STDC_HEADERS
28 # define HAVE_LIMITS_H
29 #endif
30
31 #include <ctype.h>
32 #include <errno.h>
33 #ifndef errno
34 extern int errno;
35 #endif
36 #ifndef __set_errno
37 # define __set_errno(Val) errno = (Val)
38 #endif
39
40 #ifdef HAVE_LIMITS_H
41 # include <limits.h>
42 #endif
43
44 #ifdef STDC_HEADERS
45 # include <stddef.h>
46 # include <stdlib.h>
47 # include <string.h>
48 # include <locale.h>
49 #else
50 # ifndef NULL
51 #  define NULL 0
52 # endif
53 #endif
54
55 #ifdef USE_NUMBER_GROUPING
56 # include "../locale/localeinfo.h"
57 #endif
58
59 /* Nonzero if we are defining `strtoul' or `strtoull', operating on
60    unsigned integers.  */
61 #ifndef UNSIGNED
62 # define UNSIGNED 0
63 # define INT LONG int
64 #else
65 # define INT unsigned LONG int
66 #endif
67
68 /* Determine the name.  */
69 #ifdef USE_IN_EXTENDED_LOCALE_MODEL
70 # if UNSIGNED
71 #  ifdef USE_WIDE_CHAR
72 #   ifdef QUAD
73 #    define strtol __wcstoull_l
74 #   else
75 #    define strtol __wcstoul_l
76 #   endif
77 #  else
78 #   ifdef QUAD
79 #    define strtol __strtoull_l
80 #   else
81 #    define strtol __strtoul_l
82 #   endif
83 #  endif
84 # else
85 #  ifdef USE_WIDE_CHAR
86 #   ifdef QUAD
87 #    define strtol __wcstoll_l
88 #   else
89 #    define strtol __wcstol_l
90 #   endif
91 #  else
92 #   ifdef QUAD
93 #    define strtol __strtoll_l
94 #   else
95 #    define strtol __strtol_l
96 #   endif
97 #  endif
98 # endif
99 #else
100 # if UNSIGNED
101 #  ifdef USE_WIDE_CHAR
102 #   ifdef QUAD
103 #    define strtol wcstoull
104 #   else
105 #    define strtol wcstoul
106 #   endif
107 #  else
108 #   ifdef QUAD
109 #    define strtol strtoull
110 #   else
111 #    define strtol strtoul
112 #   endif
113 #  endif
114 # else
115 #  ifdef USE_WIDE_CHAR
116 #   ifdef QUAD
117 #    define strtol wcstoll
118 #   else
119 #    define strtol wcstol
120 #   endif
121 #  else
122 #   ifdef QUAD
123 #    define strtol strtoll
124 #   endif
125 #  endif
126 # endif
127 #endif
128
129 /* If QUAD is defined, we are defining `strtoll' or `strtoull',
130    operating on `long long int's.  */
131 #ifdef QUAD
132 # define LONG long long
133 # define STRTOL_LONG_MIN LONG_LONG_MIN
134 # define STRTOL_LONG_MAX LONG_LONG_MAX
135 # define STRTOL_ULONG_MAX ULONG_LONG_MAX
136 # if __GNUC__ == 2 && __GNUC_MINOR__ < 7
137    /* Work around gcc bug with using this constant.  */
138    static const unsigned long long int maxquad = ULONG_LONG_MAX;
139 #  undef STRTOL_ULONG_MAX
140 #  define STRTOL_ULONG_MAX maxquad
141 # endif
142 #else
143 # define LONG long
144
145 # ifndef ULONG_MAX
146 #  define ULONG_MAX ((unsigned long) ~(unsigned long) 0)
147 # endif
148 # ifndef LONG_MAX
149 #  define LONG_MAX ((long int) (ULONG_MAX >> 1))
150 # endif
151 # define STRTOL_LONG_MIN LONG_MIN
152 # define STRTOL_LONG_MAX LONG_MAX
153 # define STRTOL_ULONG_MAX ULONG_MAX
154 #endif
155
156
157 /* We use this code also for the extended locale handling where the
158    function gets as an additional argument the locale which has to be
159    used.  To access the values we have to redefine the _NL_CURRENT
160    macro.  */
161 #ifdef USE_IN_EXTENDED_LOCALE_MODEL
162 # undef _NL_CURRENT
163 # define _NL_CURRENT(category, item) \
164   (current->values[_NL_ITEM_INDEX (item)].string)
165 # define LOCALE_PARAM , loc
166 # define LOCALE_PARAM_DECL __locale_t loc;
167 #else
168 # define LOCALE_PARAM
169 # define LOCALE_PARAM_DECL
170 #endif
171
172 #if defined _LIBC || defined HAVE_WCHAR_H
173 # include <wchar.h>
174 #endif
175
176 #ifdef USE_WIDE_CHAR
177 # include <wctype.h>
178 # define L_(Ch) L##Ch
179 # define UCHAR_TYPE wint_t
180 # define STRING_TYPE wchar_t
181 # ifdef USE_IN_EXTENDED_LOCALE_MODEL
182 #  define ISSPACE(Ch) __iswspace_l ((Ch), loc)
183 #  define ISALPHA(Ch) __iswalpha_l ((Ch), loc)
184 #  define TOUPPER(Ch) __towupper_l ((Ch), loc)
185 # else
186 #  define ISSPACE(Ch) iswspace (Ch)
187 #  define ISALPHA(Ch) iswalpha (Ch)
188 #  define TOUPPER(Ch) towupper (Ch)
189 # endif
190 # else
191 #  if defined _LIBC \
192    || defined STDC_HEADERS || (!defined isascii && !defined HAVE_ISASCII)
193 #   define IN_CTYPE_DOMAIN(c) 1
194 #  else
195 #   define IN_CTYPE_DOMAIN(c) isascii(c)
196 #  endif
197 #  define L_(Ch) Ch
198 #  define UCHAR_TYPE unsigned char
199 #  define STRING_TYPE char
200 # ifdef USE_IN_EXTENDED_LOCALE_MODEL
201 #  define ISSPACE(Ch) __isspace_l ((Ch), loc)
202 #  define ISALPHA(Ch) __isalpha_l ((Ch), loc)
203 #  define TOUPPER(Ch) __toupper_l ((Ch), loc)
204 # else
205 #  define ISSPACE(Ch) (IN_CTYPE_DOMAIN (Ch) && isspace (Ch))
206 #  define ISALPHA(Ch) (IN_CTYPE_DOMAIN (Ch) && isalpha (Ch))
207 #  define TOUPPER(Ch) (IN_CTYPE_DOMAIN (Ch) ? toupper (Ch) : (Ch))
208 # endif
209 #endif
210
211 #ifdef __STDC__
212 # define INTERNAL(X) INTERNAL1(X)
213 # define INTERNAL1(X) __##X##_internal
214 # define WEAKNAME(X) WEAKNAME1(X)
215 #else
216 # define INTERNAL(X) __/**/X/**/_internal
217 #endif
218
219 #ifdef USE_NUMBER_GROUPING
220 /* This file defines a function to check for correct grouping.  */
221 # include "grouping.h"
222 #endif
223
224
225
226 /* Convert NPTR to an `unsigned long int' or `long int' in base BASE.
227    If BASE is 0 the base is determined by the presence of a leading
228    zero, indicating octal or a leading "0x" or "0X", indicating hexadecimal.
229    If BASE is < 2 or > 36, it is reset to 10.
230    If ENDPTR is not NULL, a pointer to the character after the last
231    one converted is stored in *ENDPTR.  */
232
233 INT
234 INTERNAL (strtol) (nptr, endptr, base, group LOCALE_PARAM)
235      const STRING_TYPE *nptr;
236      STRING_TYPE **endptr;
237      int base;
238      int group;
239      LOCALE_PARAM_DECL
240 {
241   int negative;
242   register unsigned LONG int cutoff;
243   register unsigned int cutlim;
244   register unsigned LONG int i;
245   register const STRING_TYPE *s;
246   register UCHAR_TYPE c;
247   const STRING_TYPE *save, *end;
248   int overflow;
249 #ifndef USE_WIDE_CHAR
250   size_t cnt;
251 #endif
252
253 #ifdef USE_NUMBER_GROUPING
254 # ifdef USE_IN_EXTENDED_LOCALE_MODEL
255   struct locale_data *current = loc->__locales[LC_NUMERIC];
256 # endif
257   /* The thousands character of the current locale.  */
258 # ifdef USE_WIDE_CHAR
259   wchar_t thousands = L'\0';
260 # else
261   const char *thousands = NULL;
262   size_t thousands_len = 0;
263 # endif
264   /* The numeric grouping specification of the current locale,
265      in the format described in <locale.h>.  */
266   const char *grouping;
267
268   if (__builtin_expect (group, 0))
269     {
270       grouping = _NL_CURRENT (LC_NUMERIC, GROUPING);
271       if (*grouping <= 0 || *grouping == CHAR_MAX)
272         grouping = NULL;
273       else
274         {
275           /* Figure out the thousands separator character.  */
276 # ifdef USE_WIDE_CHAR
277 #  ifdef _LIBC
278           thousands = _NL_CURRENT_WORD (LC_NUMERIC,
279                                         _NL_NUMERIC_THOUSANDS_SEP_WC);
280 #  endif
281           if (thousands == L'\0')
282             grouping = NULL;
283 # else
284 #  ifdef _LIBC
285           thousands = _NL_CURRENT (LC_NUMERIC, THOUSANDS_SEP);
286 #  endif
287           if (*thousands == '\0')
288             {
289               thousands = NULL;
290               grouping = NULL;
291             }
292 # endif
293         }
294     }
295   else
296     grouping = NULL;
297 #endif
298
299   if (base < 0 || base == 1 || base > 36)
300     {
301       __set_errno (EINVAL);
302       return 0;
303     }
304
305   save = s = nptr;
306
307   /* Skip white space.  */
308   while (ISSPACE (*s))
309     ++s;
310   if (__builtin_expect (*s == L_('\0'), 0))
311     goto noconv;
312
313   /* Check for a sign.  */
314   negative = 0;
315   if (*s == L_('-'))
316     {
317       negative = 1;
318       ++s;
319     }
320   else if (*s == L_('+'))
321     ++s;
322
323   /* Recognize number prefix and if BASE is zero, figure it out ourselves.  */
324   if (*s == L_('0'))
325     {
326       if ((base == 0 || base == 16) && TOUPPER (s[1]) == L_('X'))
327         {
328           s += 2;
329           base = 16;
330         }
331       else if (base == 0)
332         base = 8;
333     }
334   else if (base == 0)
335     base = 10;
336
337   /* Save the pointer so we can check later if anything happened.  */
338   save = s;
339
340 #ifdef USE_NUMBER_GROUPING
341   if (base != 10)
342     grouping = NULL;
343
344   if (__builtin_expect (grouping != NULL, 0))
345     {
346 # ifndef USE_WIDE_CHAR
347       thousands_len = strlen (thousands);
348 # endif
349
350       /* Find the end of the digit string and check its grouping.  */
351       end = s;
352       if (
353 # ifdef USE_WIDE_CHAR
354           *s != thousands
355 # else
356           ({ for (cnt = 0; cnt < thousands_len; ++cnt)
357                if (thousands[cnt] != end[cnt])
358                  break;
359              cnt < thousands_len; })
360 # endif
361           )
362         {
363           for (c = *end; c != L_('\0'); c = *++end)
364             if (((STRING_TYPE) c < L_('0') || (STRING_TYPE) c > L_('9'))
365 # ifdef USE_WIDE_CHAR
366                 && (wchar_t) c != thousands
367 # else
368                 && ({ for (cnt = 0; cnt < thousands_len; ++cnt)
369                       if (thousands[cnt] != end[cnt])
370                         break;
371                       cnt < thousands_len; })
372 # endif
373                 && (!ISALPHA (c)
374                     || (int) (TOUPPER (c) - L_('A') + 10) >= base))
375               break;
376
377 # ifdef USE_WIDE_CHAR
378           end = __correctly_grouped_prefixwc (s, end, thousands, grouping);
379 # else
380           end = __correctly_grouped_prefixmb (s, end, thousands, grouping);
381 # endif
382         }
383     }
384   else
385 #endif
386     end = NULL;
387
388   cutoff = STRTOL_ULONG_MAX / (unsigned LONG int) base;
389   cutlim = STRTOL_ULONG_MAX % (unsigned LONG int) base;
390
391   overflow = 0;
392   i = 0;
393   c = *s;
394   if (sizeof (long int) != sizeof (LONG int))
395     {
396       unsigned long int j = 0;
397       unsigned long int jmax = ULONG_MAX / base;
398
399       for (;c != L_('\0'); c = *++s)
400         {
401           if (s == end)
402             break;
403           if (c >= L_('0') && c <= L_('9'))
404             c -= L_('0');
405 #ifdef USE_NUMBER_GROUPING
406 # ifdef USE_WIDE_CHAR
407           else if (grouping && (wchar_t) c == thousands)
408             continue;
409 # else
410           else if (thousands_len)
411             {
412               for (cnt = 0; cnt < thousands_len; ++cnt)
413                 if (thousands[cnt] != s[cnt])
414                   break;
415               if (cnt == thousands_len)
416                 {
417                   s += thousands_len - 1;
418                   continue;
419                 }
420               if (ISALPHA (c))
421                 c = TOUPPER (c) - L_('A') + 10;
422               else
423                 break;
424             }
425 # endif
426 #endif
427           else if (ISALPHA (c))
428             c = TOUPPER (c) - L_('A') + 10;
429           else
430             break;
431           if ((int) c >= base)
432             break;
433           /* Note that we never can have an overflow.  */
434           else if (j >= jmax)
435             {
436               /* We have an overflow.  Now use the long representation.  */
437               i = (unsigned LONG int) j;
438               goto use_long;
439             }
440           else
441             j = j * (unsigned long int) base + c;
442         }
443
444       i = (unsigned LONG int) j;
445     }
446   else
447     for (;c != L_('\0'); c = *++s)
448       {
449         if (s == end)
450           break;
451         if (c >= L_('0') && c <= L_('9'))
452           c -= L_('0');
453 #ifdef USE_NUMBER_GROUPING
454 # ifdef USE_WIDE_CHAR
455         else if (grouping && (wchar_t) c == thousands)
456           continue;
457 # else
458         else if (thousands_len)
459           {
460             for (cnt = 0; cnt < thousands_len; ++cnt)
461               if (thousands[cnt] != s[cnt])
462                 break;
463             if (cnt == thousands_len)
464               {
465                 s += thousands_len - 1;
466                 continue;
467               }
468             if (ISALPHA (c))
469               c = TOUPPER (c) - L_('A') + 10;
470             else
471               break;
472           }
473 # endif
474 #endif
475         else if (ISALPHA (c))
476           c = TOUPPER (c) - L_('A') + 10;
477         else
478           break;
479         if ((int) c >= base)
480           break;
481         /* Check for overflow.  */
482         if (i > cutoff || (i == cutoff && c > cutlim))
483           overflow = 1;
484         else
485           {
486           use_long:
487             i *= (unsigned LONG int) base;
488             i += c;
489           }
490       }
491
492   /* Check if anything actually happened.  */
493   if (s == save)
494     goto noconv;
495
496   /* Store in ENDPTR the address of one character
497      past the last character we converted.  */
498   if (endptr != NULL)
499     *endptr = (STRING_TYPE *) s;
500
501 #if !UNSIGNED
502   /* Check for a value that is within the range of
503      `unsigned LONG int', but outside the range of `LONG int'.  */
504   if (overflow == 0
505       && i > (negative
506               ? -((unsigned LONG int) (STRTOL_LONG_MIN + 1)) + 1
507               : (unsigned LONG int) STRTOL_LONG_MAX))
508     overflow = 1;
509 #endif
510
511   if (__builtin_expect (overflow, 0))
512     {
513       __set_errno (ERANGE);
514 #if UNSIGNED
515       return STRTOL_ULONG_MAX;
516 #else
517       return negative ? STRTOL_LONG_MIN : STRTOL_LONG_MAX;
518 #endif
519     }
520
521   /* Return the result of the appropriate sign.  */
522   return negative ? -i : i;
523
524 noconv:
525   /* We must handle a special case here: the base is 0 or 16 and the
526      first two characters are '0' and 'x', but the rest are no
527      hexadecimal digits.  This is no error case.  We return 0 and
528      ENDPTR points to the `x`.  */
529   if (endptr != NULL)
530     {
531       if (save - nptr >= 2 && TOUPPER (save[-1]) == L_('X')
532           && save[-2] == L_('0'))
533         *endptr = (STRING_TYPE *) &save[-1];
534       else
535         /*  There was no number to convert.  */
536         *endptr = (STRING_TYPE *) nptr;
537     }
538
539   return 0L;
540 }
541 #if defined _LIBC \
542     && !(defined USE_IN_EXTENDED_LOCALE_MODEL && defined USE_WIDE_CHAR)
543 libc_hidden_def (INTERNAL (strtol))
544 #endif
545 \f
546 /* External user entry point.  */
547
548 #if _LIBC - 0 == 0
549 # undef PARAMS
550 # if defined (__STDC__) && __STDC__
551 #  define PARAMS(Args) Args
552 # else
553 #  define PARAMS(Args) ()
554 # endif
555
556 /* Prototype.  */
557 INT strtol PARAMS ((const STRING_TYPE *nptr, STRING_TYPE **endptr, int base));
558 #endif
559
560
561 INT
562 #ifdef weak_function
563 weak_function
564 #endif
565 strtol (nptr, endptr, base LOCALE_PARAM)
566      const STRING_TYPE *nptr;
567      STRING_TYPE **endptr;
568      int base;
569      LOCALE_PARAM_DECL
570 {
571   return INTERNAL (strtol) (nptr, endptr, base, 0 LOCALE_PARAM);
572 }