Python/mystrtoul.c

   1
   2 #include "Python.h"
   3
   4 #if defined(__sgi) && defined(WITH_THREAD) && !defined(_SGI_MP_SOURCE)
   5 #define _SGI_MP_SOURCE
   6 #endif
   7
   8 /* strtol and strtoul, renamed to avoid conflicts */
   9
  10
  11 #include <ctype.h>
  12 #ifdef HAVE_ERRNO_H
  13 #include <errno.h>
  14 #endif
  15
  16 /* Static overflow check values for bases 2 through 36.
  17  * smallmax[base] is the largest unsigned long i such that
  18  * i * base doesn't overflow unsigned long.
  19  */
  20 static unsigned long smallmax[] = {
  21         0, /* bases 0 and 1 are invalid */
  22         0,
  23         ULONG_MAX / 2,
  24         ULONG_MAX / 3,
  25         ULONG_MAX / 4,
  26         ULONG_MAX / 5,
  27         ULONG_MAX / 6,
  28         ULONG_MAX / 7,
  29         ULONG_MAX / 8,
  30         ULONG_MAX / 9,
  31         ULONG_MAX / 10,
  32         ULONG_MAX / 11,
  33         ULONG_MAX / 12,
  34         ULONG_MAX / 13,
  35         ULONG_MAX / 14,
  36         ULONG_MAX / 15,
  37         ULONG_MAX / 16,
  38         ULONG_MAX / 17,
  39         ULONG_MAX / 18,
  40         ULONG_MAX / 19,
  41         ULONG_MAX / 20,
  42         ULONG_MAX / 21,
  43         ULONG_MAX / 22,
  44         ULONG_MAX / 23,
  45         ULONG_MAX / 24,
  46         ULONG_MAX / 25,
  47         ULONG_MAX / 26,
  48         ULONG_MAX / 27,
  49         ULONG_MAX / 28,
  50         ULONG_MAX / 29,
  51         ULONG_MAX / 30,
  52         ULONG_MAX / 31,
  53         ULONG_MAX / 32,
  54         ULONG_MAX / 33,
  55         ULONG_MAX / 34,
  56         ULONG_MAX / 35,
  57         ULONG_MAX / 36,
  58 };
  59
  60 /* maximum digits that can't ever overflow for bases 2 through 36,
  61  * calculated by [int(math.floor(math.log(2**32, i))) for i in range(2, 37)].
  62  * Note that this is pessimistic if sizeof(long) > 4.
  63  */
  64 #if SIZEOF_LONG == 4
  65 static int digitlimit[] = {
  66         0,  0, 32, 20, 16, 13, 12, 11, 10, 10,  /*  0 -  9 */
  67         9,  9,  8,  8,  8,  8,  8,  7,  7,  7,  /* 10 - 19 */
  68         7,  7,  7,  7,  6,  6,  6,  6,  6,  6,  /* 20 - 29 */
  69         6,  6,  6,  6,  6,  6,  6};             /* 30 - 36 */
  70 #elif SIZEOF_LONG == 8
  71 /* [int(math.floor(math.log(2**64, i))) for i in range(2, 37)] */
  72 static int digitlimit[] = {
  73          0,   0, 64, 40, 32, 27, 24, 22, 21, 20,  /*  0 -  9 */
  74         19,  18, 17, 17, 16, 16, 16, 15, 15, 15,  /* 10 - 19 */
  75         14,  14, 14, 14, 13, 13, 13, 13, 13, 13,  /* 20 - 29 */
  76         13,  12, 12, 12, 12, 12, 12};             /* 30 - 36 */
  77 #else
  78 #error "Need table for SIZEOF_LONG"
  79 #endif
  80
  81 /*
  82 **      strtoul
  83 **              This is a general purpose routine for converting
  84 **              an ascii string to an integer in an arbitrary base.
  85 **              Leading white space is ignored.  If 'base' is zero
  86 **              it looks for a leading 0, 0b, 0B, 0o, 0O, 0x or 0X
  87 **              to tell which base.  If these are absent it defaults
  88 **              to 10. Base must be 0 or between 2 and 36 (inclusive).
  89 **              If 'ptr' is non-NULL it will contain a pointer to
  90 **              the end of the scan.
  91 **              Errors due to bad pointers will probably result in
  92 **              exceptions - we don't check for them.
  93 */
  94 unsigned long
  95 PyOS_strtoul(register char *str, char **ptr, int base)
  96 {
  97         register unsigned long result = 0; /* return value of the function */
  98         register int c;         /* current input character */
  99         register int ovlimit;   /* required digits to overflow */
 100
 101         /* skip leading white space */
 102         while (*str && isspace(Py_CHARMASK(*str)))
 103                 ++str;
 104
 105         /* check for leading 0 or 0x for auto-base or base 16 */
 106         switch (base) {
 107         case 0:         /* look for leading 0, 0b, 0o or 0x */
 108                 if (*str == '0') {
 109                         ++str;
 110                         if (*str == 'x' || *str == 'X') {
 111                                 /* there must be at least one digit after 0x */
 112                                 if (_PyLong_DigitValue[Py_CHARMASK(str[1])] >= 16) {
 113                                         if (ptr)
 114                                                 *ptr = str;
 115                                         return 0;
 116                                 }
 117                                 ++str;
 118                                 base = 16;
 119                         } else if (*str == 'o' || *str == 'O') {
 120                                 /* there must be at least one digit after 0o */
 121                                 if (_PyLong_DigitValue[Py_CHARMASK(str[1])] >= 8) {
 122                                         if (ptr)
 123                                                 *ptr = str;
 124                                         return 0;
 125                                 }
 126                                 ++str;
 127                                 base = 8;
 128                         } else if (*str == 'b' || *str == 'B') {
 129                                 /* there must be at least one digit after 0b */
 130                                 if (_PyLong_DigitValue[Py_CHARMASK(str[1])] >= 2) {
 131                                         if (ptr)
 132                                                 *ptr = str;
 133                                         return 0;
 134                                 }
 135                                 ++str;
 136                                 base = 2;
 137                         } else {
 138                                 base = 8;
 139                         }
 140                 }
 141                 else
 142                         base = 10;
 143                 break;
 144
 145         case 2: /* skip leading 0b or 0B */
 146                 if (*str == '0') {
 147                         ++str;
 148                         if (*str == 'b' || *str == 'B') {
 149                                 /* there must be at least one digit after 0b */
 150                                 if (_PyLong_DigitValue[Py_CHARMASK(str[1])] >= 2) {
 151                                         if (ptr)
 152                                                 *ptr = str;
 153                                         return 0;
 154                                 }
 155                                 ++str;
 156                         }
 157                 }
 158                 break;
 159
 160         case 8: /* skip leading 0o or 0O */
 161                 if (*str == '0') {
 162                         ++str;
 163                         if (*str == 'o' || *str == 'O') {
 164                                 /* there must be at least one digit after 0o */
 165                                 if (_PyLong_DigitValue[Py_CHARMASK(str[1])] >= 8) {
 166                                         if (ptr)
 167                                                 *ptr = str;
 168                                         return 0;
 169                                 }
 170                                 ++str;
 171                         }
 172                 }
 173                 break;
 174
 175         case 16:        /* skip leading 0x or 0X */
 176                 if (*str == '0') {
 177                         ++str;
 178                         if (*str == 'x' || *str == 'X') {
 179                                 /* there must be at least one digit after 0x */
 180                                 if (_PyLong_DigitValue[Py_CHARMASK(str[1])] >= 16) {
 181                                         if (ptr)
 182                                                 *ptr = str;
 183                                         return 0;
 184                                 }
 185                                 ++str;
 186                         }
 187                 }
 188                 break;
 189         }
 190
 191         /* catch silly bases */
 192         if (base < 2 || base > 36) {
 193                 if (ptr)
 194                         *ptr = str;
 195                 return 0;
 196         }
 197
 198         /* skip leading zeroes */
 199         while (*str == '0')
 200                 ++str;
 201
 202         /* base is guaranteed to be in [2, 36] at this point */
 203         ovlimit = digitlimit[base];
 204
 205         /* do the conversion until non-digit character encountered */
 206         while ((c = _PyLong_DigitValue[Py_CHARMASK(*str)]) < base) {
 207                 if (ovlimit > 0) /* no overflow check required */
 208                         result = result * base + c;
 209                 else { /* requires overflow check */
 210                         register unsigned long temp_result;
 211
 212                         if (ovlimit < 0) /* guaranteed overflow */
 213                                 goto overflowed;
 214
 215                         /* there could be an overflow */
 216                         /* check overflow just from shifting */
 217                         if (result > smallmax[base])
 218                                 goto overflowed;
 219
 220                         result *= base;
 221
 222                         /* check overflow from the digit's value */
 223                         temp_result = result + c;
 224                         if (temp_result < result)
 225                                 goto overflowed;
 226
 227                         result = temp_result;
 228                 }
 229
 230                 ++str;
 231                 --ovlimit;
 232         }
 233
 234         /* set pointer to point to the last character scanned */
 235         if (ptr)
 236                 *ptr = str;
 237
 238         return result;
 239
 240 overflowed:
 241         if (ptr) {
 242                 /* spool through remaining digit characters */
 243                 while (_PyLong_DigitValue[Py_CHARMASK(*str)] < base)
 244                         ++str;
 245                 *ptr = str;
 246         }
 247         errno = ERANGE;
 248         return (unsigned long)-1;
 249 }
 250
 251 /* Checking for overflow in PyOS_strtol is a PITA; see comments
 252  * about PY_ABS_LONG_MIN in longobject.c.
 253  */
 254 #define PY_ABS_LONG_MIN         (0-(unsigned long)LONG_MIN)
 255
 256 long
 257 PyOS_strtol(char *str, char **ptr, int base)
 258 {
 259         long result;
 260         unsigned long uresult;
 261         char sign;
 262
 263         while (*str && isspace(Py_CHARMASK(*str)))
 264                 str++;
 265
 266         sign = *str;
 267         if (sign == '+' || sign == '-')
 268                 str++;
 269
 270         uresult = PyOS_strtoul(str, ptr, base);
 271
 272         if (uresult <= (unsigned long)LONG_MAX) {
 273                 result = (long)uresult;
 274                 if (sign == '-')
 275                         result = -result;
 276         }
 277         else if (sign == '-' && uresult == PY_ABS_LONG_MIN) {
 278                 result = LONG_MIN;
 279         }
 280         else {
 281                 errno = ERANGE;
 282                 result = LONG_MAX;
 283         }
 284         return result;
 285 }