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