lib/strtol.c

   1 /* Convert string representation of a number into an integer value.
   2
   3    Copyright (C) 1991, 1992, 1994, 1995, 1996, 1997, 1998, 1999, 2003, 2005, 2006
   4    Free Software Foundation, Inc.
   5
   6    NOTE: The canonical source of this file is maintained with the GNU C
   7    Library.  Bugs can be reported to bug-glibc@gnu.org.
   8
   9    This program is free software; you can redistribute it and/or modify it
  10    under the terms of the GNU General Public License as published by the
  11    Free Software Foundation; either version 2, or (at your option) any
  12    later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software Foundation,
  21    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 # include <config.h>
  25 #endif
  26
  27 #ifdef _LIBC
  28 # define USE_NUMBER_GROUPING
  29 #endif
  30
  31 #include <ctype.h>
  32 #include <errno.h>
  33 #ifndef __set_errno
  34 # define __set_errno(Val) errno = (Val)
  35 #endif
  36
  37 #include <limits.h>
  38 #include <stddef.h>
  39 #include <stdlib.h>
  40 #include <string.h>
  41
  42 #ifdef USE_NUMBER_GROUPING
  43 # include "../locale/localeinfo.h"
  44 #endif
  45
  46 /* Nonzero if we are defining `strtoul' or `strtoull', operating on
  47    unsigned integers.  */
  48 #ifndef UNSIGNED
  49 # define UNSIGNED 0
  50 # define INT LONG int
  51 #else
  52 # define INT unsigned LONG int
  53 #endif
  54
  55 /* Determine the name.  */
  56 #ifdef USE_IN_EXTENDED_LOCALE_MODEL
  57 # if UNSIGNED
  58 #  ifdef USE_WIDE_CHAR
  59 #   ifdef QUAD
  60 #    define strtol __wcstoull_l
  61 #   else
  62 #    define strtol __wcstoul_l
  63 #   endif
  64 #  else
  65 #   ifdef QUAD
  66 #    define strtol __strtoull_l
  67 #   else
  68 #    define strtol __strtoul_l
  69 #   endif
  70 #  endif
  71 # else
  72 #  ifdef USE_WIDE_CHAR
  73 #   ifdef QUAD
  74 #    define strtol __wcstoll_l
  75 #   else
  76 #    define strtol __wcstol_l
  77 #   endif
  78 #  else
  79 #   ifdef QUAD
  80 #    define strtol __strtoll_l
  81 #   else
  82 #    define strtol __strtol_l
  83 #   endif
  84 #  endif
  85 # endif
  86 #else
  87 # if UNSIGNED
  88 #  ifdef USE_WIDE_CHAR
  89 #   ifdef QUAD
  90 #    define strtol wcstoull
  91 #   else
  92 #    define strtol wcstoul
  93 #   endif
  94 #  else
  95 #   ifdef QUAD
  96 #    define strtol strtoull
  97 #   else
  98 #    define strtol strtoul
  99 #   endif
 100 #  endif
 101 # else
 102 #  ifdef USE_WIDE_CHAR
 103 #   ifdef QUAD
 104 #    define strtol wcstoll
 105 #   else
 106 #    define strtol wcstol
 107 #   endif
 108 #  else
 109 #   ifdef QUAD
 110 #    define strtol strtoll
 111 #   endif
 112 #  endif
 113 # endif
 114 #endif
 115
 116 /* If QUAD is defined, we are defining `strtoll' or `strtoull',
 117    operating on `long long int's.  */
 118 #ifdef QUAD
 119 # define LONG long long
 120 # define STRTOL_LONG_MIN LONG_LONG_MIN
 121 # define STRTOL_LONG_MAX LONG_LONG_MAX
 122 # define STRTOL_ULONG_MAX ULONG_LONG_MAX
 123
 124 /* The extra casts in the following macros work around compiler bugs,
 125    e.g., in Cray C 5.0.3.0.  */
 126
 127 /* True if negative values of the signed integer type T use two's
 128    complement, ones' complement, or signed magnitude representation,
 129    respectively.  Much GNU code assumes two's complement, but some
 130    people like to be portable to all possible C hosts.  */
 131 # define TYPE_TWOS_COMPLEMENT(t) ((t) ~ (t) 0 == (t) -1)
 132 # define TYPE_ONES_COMPLEMENT(t) ((t) ~ (t) 0 == 0)
 133 # define TYPE_SIGNED_MAGNITUDE(t) ((t) ~ (t) 0 < (t) -1)
 134
 135 /* True if the arithmetic type T is signed.  */
 136 # define TYPE_SIGNED(t) (! ((t) 0 < (t) -1))
 137
 138 /* The maximum and minimum values for the integer type T.  These
 139    macros have undefined behavior if T is signed and has padding bits.
 140    If this is a problem for you, please let us know how to fix it for
 141    your host.  */
 142 # define TYPE_MINIMUM(t) \
 143    ((t) (! TYPE_SIGNED (t) \
 144          ? (t) 0 \
 145          : TYPE_SIGNED_MAGNITUDE (t) \
 146          ? ~ (t) 0 \
 147          : ~ (t) 0 << (sizeof (t) * CHAR_BIT - 1)))
 148 # define TYPE_MAXIMUM(t) \
 149    ((t) (! TYPE_SIGNED (t) \
 150          ? (t) -1 \
 151          : ~ (~ (t) 0 << (sizeof (t) * CHAR_BIT - 1))))
 152
 153 # ifndef ULONG_LONG_MAX
 154 #  define ULONG_LONG_MAX TYPE_MAXIMUM (unsigned long long)
 155 # endif
 156 # ifndef LONG_LONG_MAX
 157 #  define LONG_LONG_MAX TYPE_MAXIMUM (long long int)
 158 # endif
 159 # ifndef LONG_LONG_MIN
 160 #  define LONG_LONG_MIN TYPE_MINIMUM (long long int)
 161 # endif
 162
 163 # if __GNUC__ == 2 && __GNUC_MINOR__ < 7
 164    /* Work around gcc bug with using this constant.  */
 165    static const unsigned long long int maxquad = ULONG_LONG_MAX;
 166 #  undef STRTOL_ULONG_MAX
 167 #  define STRTOL_ULONG_MAX maxquad
 168 # endif
 169 #else
 170 # define LONG long
 171 # define STRTOL_LONG_MIN LONG_MIN
 172 # define STRTOL_LONG_MAX LONG_MAX
 173 # define STRTOL_ULONG_MAX ULONG_MAX
 174 #endif
 175
 176
 177 /* We use this code also for the extended locale handling where the
 178    function gets as an additional argument the locale which has to be
 179    used.  To access the values we have to redefine the _NL_CURRENT
 180    macro.  */
 181 #ifdef USE_IN_EXTENDED_LOCALE_MODEL
 182 # undef _NL_CURRENT
 183 # define _NL_CURRENT(category, item) \
 184   (current->values[_NL_ITEM_INDEX (item)].string)
 185 # define LOCALE_PARAM , loc
 186 # define LOCALE_PARAM_PROTO , __locale_t loc
 187 #else
 188 # define LOCALE_PARAM
 189 # define LOCALE_PARAM_PROTO
 190 #endif
 191
 192 #if defined _LIBC || defined HAVE_WCHAR_H
 193 # include <wchar.h>
 194 #endif
 195
 196 #ifdef USE_WIDE_CHAR
 197 # include <wctype.h>
 198 # define L_(Ch) L##Ch
 199 # define UCHAR_TYPE wint_t
 200 # define STRING_TYPE wchar_t
 201 # ifdef USE_IN_EXTENDED_LOCALE_MODEL
 202 #  define ISSPACE(Ch) __iswspace_l ((Ch), loc)
 203 #  define ISALPHA(Ch) __iswalpha_l ((Ch), loc)
 204 #  define TOUPPER(Ch) __towupper_l ((Ch), loc)
 205 # else
 206 #  define ISSPACE(Ch) iswspace (Ch)
 207 #  define ISALPHA(Ch) iswalpha (Ch)
 208 #  define TOUPPER(Ch) towupper (Ch)
 209 # endif
 210 #else
 211 # define L_(Ch) Ch
 212 # define UCHAR_TYPE unsigned char
 213 # define STRING_TYPE char
 214 # ifdef USE_IN_EXTENDED_LOCALE_MODEL
 215 #  define ISSPACE(Ch) __isspace_l ((Ch), loc)
 216 #  define ISALPHA(Ch) __isalpha_l ((Ch), loc)
 217 #  define TOUPPER(Ch) __toupper_l ((Ch), loc)
 218 # else
 219 #  define ISSPACE(Ch) isspace (Ch)
 220 #  define ISALPHA(Ch) isalpha (Ch)
 221 #  define TOUPPER(Ch) toupper (Ch)
 222 # endif
 223 #endif
 224
 225 #define INTERNAL(X) INTERNAL1(X)
 226 #define INTERNAL1(X) __##X##_internal
 227 #define WEAKNAME(X) WEAKNAME1(X)
 228
 229 #ifdef USE_NUMBER_GROUPING
 230 /* This file defines a function to check for correct grouping.  */
 231 # include "grouping.h"
 232 #endif
 233
 234
 235
 236 /* Convert NPTR to an `unsigned long int' or `long int' in base BASE.
 237    If BASE is 0 the base is determined by the presence of a leading
 238    zero, indicating octal or a leading "0x" or "0X", indicating hexadecimal.
 239    If BASE is < 2 or > 36, it is reset to 10.
 240    If ENDPTR is not NULL, a pointer to the character after the last
 241    one converted is stored in *ENDPTR.  */
 242
 243 INT
 244 INTERNAL (strtol) (const STRING_TYPE *nptr, STRING_TYPE **endptr,
 245                    int base, int group LOCALE_PARAM_PROTO)
 246 {
 247   int negative;
 248   register unsigned LONG int cutoff;
 249   register unsigned int cutlim;
 250   register unsigned LONG int i;
 251   register const STRING_TYPE *s;
 252   register UCHAR_TYPE c;
 253   const STRING_TYPE *save, *end;
 254   int overflow;
 255
 256 #ifdef USE_NUMBER_GROUPING
 257 # ifdef USE_IN_EXTENDED_LOCALE_MODEL
 258   struct locale_data *current = loc->__locales[LC_NUMERIC];
 259 # endif
 260   /* The thousands character of the current locale.  */
 261   wchar_t thousands = L'\0';
 262   /* The numeric grouping specification of the current locale,
 263      in the format described in <locale.h>.  */
 264   const char *grouping;
 265
 266   if (group)
 267     {
 268       grouping = _NL_CURRENT (LC_NUMERIC, GROUPING);
 269       if (*grouping <= 0 || *grouping == CHAR_MAX)
 270         grouping = NULL;
 271       else
 272         {
 273           /* Figure out the thousands separator character.  */
 274 # if defined _LIBC || defined _HAVE_BTOWC
 275           thousands = __btowc (*_NL_CURRENT (LC_NUMERIC, THOUSANDS_SEP));
 276           if (thousands == WEOF)
 277             thousands = L'\0';
 278 # endif
 279           if (thousands == L'\0')
 280             grouping = NULL;
 281         }
 282     }
 283   else
 284     grouping = NULL;
 285 #endif
 286
 287   if (base < 0 || base == 1 || base > 36)
 288     {
 289       __set_errno (EINVAL);
 290       return 0;
 291     }
 292
 293   save = s = nptr;
 294
 295   /* Skip white space.  */
 296   while (ISSPACE (*s))
 297     ++s;
 298   if (*s == L_('\0'))
 299     goto noconv;
 300
 301   /* Check for a sign.  */
 302   if (*s == L_('-'))
 303     {
 304       negative = 1;
 305       ++s;
 306     }
 307   else if (*s == L_('+'))
 308     {
 309       negative = 0;
 310       ++s;
 311     }
 312   else
 313     negative = 0;
 314
 315   /* Recognize number prefix and if BASE is zero, figure it out ourselves.  */
 316   if (*s == L_('0'))
 317     {
 318       if ((base == 0 || base == 16) && TOUPPER (s[1]) == L_('X'))
 319         {
 320           s += 2;
 321           base = 16;
 322         }
 323       else if (base == 0)
 324         base = 8;
 325     }
 326   else if (base == 0)
 327     base = 10;
 328
 329   /* Save the pointer so we can check later if anything happened.  */
 330   save = s;
 331
 332 #ifdef USE_NUMBER_GROUPING
 333   if (group)
 334     {
 335       /* Find the end of the digit string and check its grouping.  */
 336       end = s;
 337       for (c = *end; c != L_('\0'); c = *++end)
 338         if ((wchar_t) c != thousands
 339             && ((wchar_t) c < L_('0') || (wchar_t) c > L_('9'))
 340             && (!ISALPHA (c) || (int) (TOUPPER (c) - L_('A') + 10) >= base))
 341           break;
 342       if (*s == thousands)
 343         end = s;
 344       else
 345         end = correctly_grouped_prefix (s, end, thousands, grouping);
 346     }
 347   else
 348 #endif
 349     end = NULL;
 350
 351   cutoff = STRTOL_ULONG_MAX / (unsigned LONG int) base;
 352   cutlim = STRTOL_ULONG_MAX % (unsigned LONG int) base;
 353
 354   overflow = 0;
 355   i = 0;
 356   for (c = *s; c != L_('\0'); c = *++s)
 357     {
 358       if (s == end)
 359         break;
 360       if (c >= L_('0') && c <= L_('9'))
 361         c -= L_('0');
 362       else if (ISALPHA (c))
 363         c = TOUPPER (c) - L_('A') + 10;
 364       else
 365         break;
 366       if ((int) c >= base)
 367         break;
 368       /* Check for overflow.  */
 369       if (i > cutoff || (i == cutoff && c > cutlim))
 370         overflow = 1;
 371       else
 372         {
 373           i *= (unsigned LONG int) base;
 374           i += c;
 375         }
 376     }
 377
 378   /* Check if anything actually happened.  */
 379   if (s == save)
 380     goto noconv;
 381
 382   /* Store in ENDPTR the address of one character
 383      past the last character we converted.  */
 384   if (endptr != NULL)
 385     *endptr = (STRING_TYPE *) s;
 386
 387 #if !UNSIGNED
 388   /* Check for a value that is within the range of
 389      `unsigned LONG int', but outside the range of `LONG int'.  */
 390   if (overflow == 0
 391       && i > (negative
 392               ? -((unsigned LONG int) (STRTOL_LONG_MIN + 1)) + 1
 393               : (unsigned LONG int) STRTOL_LONG_MAX))
 394     overflow = 1;
 395 #endif
 396
 397   if (overflow)
 398     {
 399       __set_errno (ERANGE);
 400 #if UNSIGNED
 401       return STRTOL_ULONG_MAX;
 402 #else
 403       return negative ? STRTOL_LONG_MIN : STRTOL_LONG_MAX;
 404 #endif
 405     }
 406
 407   /* Return the result of the appropriate sign.  */
 408   return negative ? -i : i;
 409
 410 noconv:
 411   /* We must handle a special case here: the base is 0 or 16 and the
 412      first two characters are '0' and 'x', but the rest are no
 413      hexadecimal digits.  This is no error case.  We return 0 and
 414      ENDPTR points to the `x`.  */
 415   if (endptr != NULL)
 416     {
 417       if (save - nptr >= 2 && TOUPPER (save[-1]) == L_('X')
 418           && save[-2] == L_('0'))
 419         *endptr = (STRING_TYPE *) &save[-1];
 420       else
 421         /*  There was no number to convert.  */
 422         *endptr = (STRING_TYPE *) nptr;
 423     }
 424
 425   return 0L;
 426 }
 427 \f
 428 /* External user entry point.  */
 429
 430
 431 INT
 432 #ifdef weak_function
 433 weak_function
 434 #endif
 435 strtol (const STRING_TYPE *nptr, STRING_TYPE **endptr,
 436         int base LOCALE_PARAM_PROTO)
 437 {
 438   return INTERNAL (strtol) (nptr, endptr, base, 0 LOCALE_PARAM);
 439 }