AppPkg/Applications/Python/Python-2.7.2/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 }