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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
|
/*
You need to define the following (example):
#define type long
#define xstrtou(rest) xstrtoul##rest
#define xstrto(rest) xstrtol##rest
#define xatou(rest) xatoul##rest
#define xato(rest) xatol##rest
#define XSTR_UTYPE_MAX ULONG_MAX
#define XSTR_TYPE_MAX LONG_MAX
#define XSTR_TYPE_MIN LONG_MIN
#define XSTR_STRTOU strtoul
*/
unsigned type xstrtou(_range_sfx)(const char *numstr, int base,
unsigned type lower,
unsigned type upper,
const struct suffix_mult *suffixes)
{
unsigned type r;
int old_errno;
char *e;
/* Disallow '-' and any leading whitespace. Make sure we get the
* actual isspace function rather than a macro implementaion. */
if (*numstr == '-' || *numstr == '+' || (isspace)(*numstr))
goto inval;
/* Since this is a lib function, we're not allowed to reset errno to 0.
* Doing so could break an app that is deferring checking of errno.
* So, save the old value so that we can restore it if successful. */
old_errno = errno;
errno = 0;
r = XSTR_STRTOU(numstr, &e, base);
/* Do the initial validity check. Note: The standards do not
* guarantee that errno is set if no digits were found. So we
* must test for this explicitly. */
if (errno || numstr == e)
goto inval; /* error / no digits / illegal trailing chars */
errno = old_errno; /* Ok. So restore errno. */
/* Do optional suffix parsing. Allow 'empty' suffix tables.
* Note that we also allow nul suffixes with associated multipliers,
* to allow for scaling of the numstr by some default multiplier. */
if (suffixes) {
while (suffixes->mult) {
if (strcmp(suffixes->suffix, e) == 0) {
if (XSTR_UTYPE_MAX / suffixes->mult < r)
goto range; /* overflow! */
r *= suffixes->mult;
goto chk_range;
}
++suffixes;
}
}
/* Note: trailing space is an error.
It would be easy enough to allow though if desired. */
if (*e)
goto inval;
chk_range:
/* Finally, check for range limits. */
if (r >= lower && r <= upper)
return r;
range:
bb_error_msg_and_die("number %s is not in %llu..%llu range",
numstr, (unsigned long long)lower,
(unsigned long long)upper);
inval:
bb_error_msg_and_die("invalid number '%s'", numstr);
}
unsigned type xstrtou(_range)(const char *numstr, int base,
unsigned type lower,
unsigned type upper)
{
return xstrtou(_range_sfx)(numstr, base, lower, upper, NULL);
}
unsigned type xstrtou(_sfx)(const char *numstr, int base,
const struct suffix_mult *suffixes)
{
return xstrtou(_range_sfx)(numstr, base, 0, XSTR_UTYPE_MAX, suffixes);
}
unsigned type xstrtou()(const char *numstr, int base)
{
return xstrtou(_range_sfx)(numstr, base, 0, XSTR_UTYPE_MAX, NULL);
}
unsigned type xatou(_range_sfx)(const char *numstr,
unsigned type lower,
unsigned type upper,
const struct suffix_mult *suffixes)
{
return xstrtou(_range_sfx)(numstr, 10, lower, upper, suffixes);
}
unsigned type xatou(_range)(const char *numstr,
unsigned type lower,
unsigned type upper)
{
return xstrtou(_range_sfx)(numstr, 10, lower, upper, NULL);
}
unsigned type xatou(_sfx)(const char *numstr,
const struct suffix_mult *suffixes)
{
return xstrtou(_range_sfx)(numstr, 10, 0, XSTR_UTYPE_MAX, suffixes);
}
unsigned type xatou()(const char *numstr)
{
return xatou(_sfx)(numstr, NULL);
}
/* Signed ones */
type xstrto(_range_sfx)(const char *numstr, int base,
type lower,
type upper,
const struct suffix_mult *suffixes)
{
unsigned type u = XSTR_TYPE_MAX;
type r;
const char *p = numstr;
/* NB: if you'll decide to disallow '+':
* at least renice applet needs to allow it */
if (p[0] == '+' || p[0] == '-') {
++p;
if (p[0] == '-')
++u; /* = <type>_MIN (01111... + 1 == 10000...) */
}
r = xstrtou(_range_sfx)(p, base, 0, u, suffixes);
if (*numstr == '-') {
r = -r;
}
if (r < lower || r > upper) {
bb_error_msg_and_die("number %s is not in %lld..%lld range",
numstr, (long long)lower, (long long)upper);
}
return r;
}
type xstrto(_range)(const char *numstr, int base, type lower, type upper)
{
return xstrto(_range_sfx)(numstr, base, lower, upper, NULL);
}
type xato(_range_sfx)(const char *numstr,
type lower,
type upper,
const struct suffix_mult *suffixes)
{
return xstrto(_range_sfx)(numstr, 10, lower, upper, suffixes);
}
type xato(_range)(const char *numstr, type lower, type upper)
{
return xstrto(_range_sfx)(numstr, 10, lower, upper, NULL);
}
type xato(_sfx)(const char *numstr, const struct suffix_mult *suffixes)
{
return xstrto(_range_sfx)(numstr, 10, XSTR_TYPE_MIN, XSTR_TYPE_MAX, suffixes);
}
type xato()(const char *numstr)
{
return xstrto(_range_sfx)(numstr, 10, XSTR_TYPE_MIN, XSTR_TYPE_MAX, NULL);
}
#undef type
#undef xstrtou
#undef xstrto
#undef xatou
#undef xato
#undef XSTR_UTYPE_MAX
#undef XSTR_TYPE_MAX
#undef XSTR_TYPE_MIN
#undef XSTR_STRTOU
|
