stdlib/strtol_l.c

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