• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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
PyOS_strtoul(register char * str,char ** ptr,int base)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
PyOS_strtol(char * str,char ** ptr,int base)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 }
286