1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
|
/* Copyright (C) 1991, 1992, 1994, 1995 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with the GNU C Library; see the file COPYING.LIB. If
not, write to the Free Software Foundation, Inc., 675 Mass Ave,
Cambridge, MA 02139, USA. */
/* Convert NPTR to an `unsigned long int' or `long int' in base BASE.
If BASE is 0 the base is determined by the presence of a leading
zero, indicating octal or a leading "0x" or "0X", indicating hexadecimal.
If BASE is < 2 or > 36, it is reset to 10.
If ENDPTR is not NULL, a pointer to the character after the last
one converted is stored in *ENDPTR. */
#include "quik.h"
int strtol (const char *nptr, char **endptr, int base)
{
int negative;
register unsigned int cutoff;
register unsigned int cutlim;
register unsigned int i;
register const char *s;
register unsigned char c;
const char *save, *end;
int overflow;
if (base < 0 || base == 1 || base > 36)
base = 10;
save = s = nptr;
/* Skip white space. */
while (((unsigned char) *s) <= 32 && *s)
++s;
if (*s == '\0')
goto noconv;
/* Check for a sign. */
if (*s == '-') {
negative = 1;
++s;
} else if (*s == '+') {
negative = 0;
++s;
} else
negative = 0;
if (base == 16 && s[0] == '0' && (s[1] == 'X' || s[1] == 'x'))
s += 2;
/* If BASE is zero, figure it out ourselves. */
if (base == 0) {
if (*s == '0') {
if (s[1] == 'X' || s[1] == 'x') {
s += 2;
base = 16;
} else
base = 8;
} else
base = 10;
}
/* Save the pointer so we can check later if anything happened. */
save = s;
end = 0;
cutoff = 0x7FFFFFFF / (unsigned int) base;
cutlim = 0x7FFFFFFF % (unsigned int) base;
overflow = 0;
i = 0;
for (c = *s; c != '\0'; c = *++s) {
if (s == end)
break;
if (c >= '0' && c <= '9')
c -= '0';
else if (c >= 'A' && c <= 'Z')
c = c - 'A' + 10;
else if (c >= 'a' && c <= 'z')
c = c - 'a' + 10;
else
break;
if (c >= base)
break;
/* Check for overflow. */
if (i > cutoff || (i == cutoff && c > cutlim))
overflow = 1;
else {
i *= (unsigned int) base;
i += c;
}
}
/* Check if anything actually happened. */
if (s == save)
goto noconv;
/* Store in ENDPTR the address of one character
past the last character we converted. */
if (endptr)
*endptr = (char *) s;
if (overflow)
return negative ? (int) 0x80000000 : (int) 0x7FFFFFFF;
/* Return the result of the appropriate sign. */
return (negative ? -i : i);
noconv:
/* We must handle a special case here: the base is 0 or 16 and the
first two characters and '0' and 'x', but the rest are no
hexadecimal digits. This is no error case. We return 0 and
ENDPTR points to the `x`. */
if (endptr) {
if (save - nptr >= 2 && tolower (save[-1]) == 'x' && save[-2] == '0')
*endptr = (char *) &save[-1];
else
/* There was no number to convert. */
*endptr = (char *) nptr;
}
return 0L;
}
|
