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 }