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