stdlib/strtol_l.c

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