source: mainline/uspace/lib/c/generic/strtol.c@ 16d748ee

Last change on this file since 16d748ee was 1c9bf292, checked in by Jiří Zárevúcky <zarevucky.jiri@…>, 6 years ago

Reunite uspace string-to-int conversion functions
  • Property mode set to 100644
File size: 12.8 KB
Line 
1/*
2 * Copyright (c) 2005 Martin Decky
3 * Copyright (c) 2008 Jiri Svoboda
4 * Copyright (c) 2011 Martin Sucha
5 * Copyright (c) 2011 Oleg Romanenko
6 * Copyright (c) 2011 Jiri Zarevucky
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 *
13 * - Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * - Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 * - The name of the author may not be used to endorse or promote products
19 * derived from this software without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
22 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
23 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
24 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
26 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
30 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 */
32
33/** @addtogroup libc
34 * @{
35 */
36/** @file
37 */
38
39#include <assert.h>
40#include <ctype.h>
41#include <errno.h>
42#include <inttypes.h>
43#include <limits.h>
44#include <stdbool.h>
45#include <stdlib.h>
46#include <str.h>
47
48// FIXME: The original HelenOS functions return EOVERFLOW instead
49// of ERANGE. It's a pointless distinction from standard functions,
50// so we should change that. Beware the callers though.
51
52// TODO: more unit tests
53
54static inline int _digit_value(int c)
55{
56 if (isdigit(c)) {
57 return c - '0';
58 } else if (islower(c)) {
59 return c - 'a' + 10;
60 } else if (isupper(c)) {
61 return c - 'A' + 10;
62 }
63 return INT_MAX;
64}
65
66/*
67 * FIXME: workaround for GCC "optimizing" the overflow check
68 * into soft-emulated 128b multiplication using `__multi3`,
69 * which we don't currently implement.
70 */
71__attribute__((noinline)) static uintmax_t _max_value(int base)
72{
73 return UINTMAX_MAX / base;
74}
75
76static inline int _prefixbase(const char *restrict *nptrptr, bool nonstd)
77{
78 const char *nptr = *nptrptr;
79
80 if (nptr[0] != '0')
81 return 10;
82
83 if (nptr[1] == 'x' || nptr[1] == 'X') {
84 if (_digit_value(nptr[2]) < 16) {
85 *nptrptr += 2;
86 return 16;
87 }
88 }
89
90 if (nonstd) {
91 switch (nptr[1]) {
92 case 'b':
93 case 'B':
94 if (_digit_value(nptr[2]) < 2) {
95 *nptrptr += 2;
96 return 2;
97 }
98 break;
99 case 'o':
100 case 'O':
101 if (_digit_value(nptr[2]) < 8) {
102 *nptrptr += 2;
103 return 8;
104 }
105 break;
106 case 'd':
107 case 'D':
108 case 't':
109 case 'T':
110 if (_digit_value(nptr[2]) < 10) {
111 *nptrptr += 2;
112 return 10;
113 }
114 break;
115 }
116 }
117
118 return 8;
119}
120
121static inline uintmax_t _strtoumax(
122 const char *restrict nptr, char **restrict endptr, int base,
123 bool *restrict sgn, errno_t *err, bool nonstd)
124{
125 assert(nptr != NULL);
126 assert(sgn != NULL);
127
128 const char *first = nptr;
129
130 /* Skip leading whitespace. */
131
132 while (isspace(*nptr)) {
133 nptr++;
134 }
135
136 /* Parse sign, if any. */
137
138 switch (*nptr) {
139 case '-':
140 *sgn = true;
141 nptr++;
142 break;
143 case '+':
144 nptr++;
145 break;
146 }
147
148 /* Figure out the base. */
149
150 if (base == 0)
151 base = _prefixbase(&nptr, nonstd);
152
153 if (base == 16 && !nonstd) {
154 /*
155 * Standard strto* functions allow hexadecimal prefix to be
156 * present when base is explicitly set to 16.
157 * Our nonstandard str_* functions don't allow it.
158 * I don't know if that is intended, just matching the original
159 * functionality here.
160 */
161
162 if (nptr[0] == '0' && (nptr[1] == 'x' || nptr[1] == 'X') &&
163 _digit_value(nptr[2]) < base)
164 nptr += 2;
165 }
166
167 if (base < 2 || base > 36) {
168 *err = EINVAL;
169 return 0;
170 }
171
172 /* Must be at least one digit. */
173
174 if (_digit_value(*nptr) >= base) {
175 /* No digits on input. */
176 if (endptr != NULL)
177 *endptr = (char *) first;
178 return 0;
179 }
180
181 /* Read the value. */
182
183 uintmax_t result = 0;
184 uintmax_t max = _max_value(base);
185 int digit;
186
187 while (digit = _digit_value(*nptr), digit < base) {
188 if (result > max ||
189 __builtin_add_overflow(result * base, digit, &result)) {
190
191 *err = nonstd ? EOVERFLOW : ERANGE;
192 result = UINTMAX_MAX;
193 break;
194 }
195
196 nptr++;
197 }
198
199 /* Set endptr. */
200
201 if (endptr != NULL) {
202 /*
203 * Move the pointer to the end of the number,
204 * in case it isn't there already.
205 * This can happen when the number has legal formatting,
206 * but is out of range of the target type.
207 */
208 while (_digit_value(*nptr) < base) {
209 nptr++;
210 }
211
212 *endptr = (char *) nptr;
213 }
214
215 return result;
216}
217
218static inline intmax_t _strtosigned(const char *nptr, char **endptr, int base,
219 intmax_t min, intmax_t max, errno_t *err, bool nonstd)
220{
221 bool sgn = false;
222 uintmax_t number = _strtoumax(nptr, endptr, base, &sgn, err, nonstd);
223
224 if (number > (uintmax_t) max) {
225 if (sgn && (number - 1 == (uintmax_t) max)) {
226 return min;
227 }
228
229 *err = nonstd ? EOVERFLOW : ERANGE;
230 return (sgn ? min : max);
231 }
232
233 return (sgn ? -number : number);
234}
235
236static inline uintmax_t _strtounsigned(const char *nptr, char **endptr, int base,
237 uintmax_t max, errno_t *err, bool nonstd)
238{
239 bool sgn = false;
240 uintmax_t number = _strtoumax(nptr, endptr, base, &sgn, err, nonstd);
241
242 if (nonstd && sgn) {
243 /* Do not allow negative values */
244 *err = EINVAL;
245 return 0;
246 }
247
248 if (number > max) {
249 *err = nonstd ? EOVERFLOW : ERANGE;
250 return max;
251 }
252
253 return (sgn ? -number : number);
254}
255
256/** Convert initial part of string to long int according to given base.
257 * The number may begin with an arbitrary number of whitespaces followed by
258 * optional sign (`+' or `-'). If the base is 0 or 16, the prefix `0x' may be
259 * inserted and the number will be taken as hexadecimal one. If the base is 0
260 * and the number begin with a zero, number will be taken as octal one (as with
261 * base 8). Otherwise the base 0 is taken as decimal.
262 *
263 * @param nptr Pointer to string.
264 * @param[out] endptr If not NULL, function stores here pointer to the first
265 * invalid character.
266 * @param base Zero or number between 2 and 36 inclusive.
267 * @return Result of conversion.
268 */
269long strtol(const char *nptr, char **endptr, int base)
270{
271 return _strtosigned(nptr, endptr, base, LONG_MIN, LONG_MAX, &errno, false);
272}
273
274/** Convert initial part of string to unsigned long according to given base.
275 * The number may begin with an arbitrary number of whitespaces followed by
276 * optional sign (`+' or `-'). If the base is 0 or 16, the prefix `0x' may be
277 * inserted and the number will be taken as hexadecimal one. If the base is 0
278 * and the number begin with a zero, number will be taken as octal one (as with
279 * base 8). Otherwise the base 0 is taken as decimal.
280 *
281 * @param nptr Pointer to string.
282 * @param[out] endptr If not NULL, function stores here pointer to the first
283 * invalid character
284 * @param base Zero or number between 2 and 36 inclusive.
285 * @return Result of conversion.
286 */
287unsigned long strtoul(const char *nptr, char **endptr, int base)
288{
289 return _strtounsigned(nptr, endptr, base, ULONG_MAX, &errno, false);
290}
291
292long long strtoll(const char *nptr, char **endptr, int base)
293{
294 return _strtosigned(nptr, endptr, base, LLONG_MIN, LLONG_MAX, &errno, false);
295}
296
297unsigned long long strtoull(const char *nptr, char **endptr, int base)
298{
299 return _strtounsigned(nptr, endptr, base, ULLONG_MAX, &errno, false);
300}
301
302intmax_t strtoimax(const char *nptr, char **endptr, int base)
303{
304 return _strtosigned(nptr, endptr, base, INTMAX_MIN, INTMAX_MAX, &errno, false);
305}
306
307uintmax_t strtoumax(const char *nptr, char **endptr, int base)
308{
309 return _strtounsigned(nptr, endptr, base, UINTMAX_MAX, &errno, false);
310}
311
312int atoi(const char *nptr)
313{
314 return (int)strtol(nptr, NULL, 10);
315}
316
317long atol(const char *nptr)
318{
319 return strtol(nptr, NULL, 10);
320}
321
322long long atoll(const char *nptr)
323{
324 return strtoll(nptr, NULL, 10);
325}
326
327/** Convert string to uint8_t.
328 *
329 * @param nptr Pointer to string.
330 * @param endptr If not NULL, pointer to the first invalid character
331 * is stored here.
332 * @param base Zero or number between 2 and 36 inclusive.
333 * @param strict Do not allow any trailing characters.
334 * @param result Result of the conversion.
335 *
336 * @return EOK if conversion was successful.
337 *
338 */
339errno_t str_uint8_t(const char *nptr, const char **endptr, unsigned int base,
340 bool strict, uint8_t *result)
341{
342 assert(result != NULL);
343
344 errno_t rc = EOK;
345 char *lendptr = (char *) nptr;
346
347 uintmax_t r = _strtounsigned(nptr, &lendptr, base, UINT8_MAX, &rc, true);
348
349 if (endptr)
350 *endptr = lendptr;
351
352 if (rc != EOK)
353 return rc;
354
355 if (strict && *lendptr != '\0')
356 return EINVAL;
357
358 *result = r;
359 return EOK;
360}
361
362/** Convert string to uint16_t.
363 *
364 * @param nptr Pointer to string.
365 * @param endptr If not NULL, pointer to the first invalid character
366 * is stored here.
367 * @param base Zero or number between 2 and 36 inclusive.
368 * @param strict Do not allow any trailing characters.
369 * @param result Result of the conversion.
370 *
371 * @return EOK if conversion was successful.
372 *
373 */
374errno_t str_uint16_t(const char *nptr, const char **endptr, unsigned int base,
375 bool strict, uint16_t *result)
376{
377 assert(result != NULL);
378
379 errno_t rc = EOK;
380 char *lendptr = (char *) nptr;
381
382 uintmax_t r = _strtounsigned(nptr, &lendptr, base, UINT16_MAX, &rc, true);
383
384 if (endptr)
385 *endptr = lendptr;
386
387 if (rc != EOK)
388 return rc;
389
390 if (strict && *lendptr != '\0')
391 return EINVAL;
392
393 *result = r;
394 return EOK;
395}
396
397/** Convert string to uint32_t.
398 *
399 * @param nptr Pointer to string.
400 * @param endptr If not NULL, pointer to the first invalid character
401 * is stored here.
402 * @param base Zero or number between 2 and 36 inclusive.
403 * @param strict Do not allow any trailing characters.
404 * @param result Result of the conversion.
405 *
406 * @return EOK if conversion was successful.
407 *
408 */
409errno_t str_uint32_t(const char *nptr, const char **endptr, unsigned int base,
410 bool strict, uint32_t *result)
411{
412 assert(result != NULL);
413
414 errno_t rc = EOK;
415 char *lendptr = (char *) nptr;
416
417 uintmax_t r = _strtounsigned(nptr, &lendptr, base, UINT32_MAX, &rc, true);
418
419 if (endptr)
420 *endptr = lendptr;
421
422 if (rc != EOK)
423 return rc;
424
425 if (strict && *lendptr != '\0')
426 return EINVAL;
427
428 *result = r;
429 return EOK;
430}
431
432/** Convert string to uint64_t.
433 *
434 * @param nptr Pointer to string.
435 * @param endptr If not NULL, pointer to the first invalid character
436 * is stored here.
437 * @param base Zero or number between 2 and 36 inclusive.
438 * @param strict Do not allow any trailing characters.
439 * @param result Result of the conversion.
440 *
441 * @return EOK if conversion was successful.
442 *
443 */
444errno_t str_uint64_t(const char *nptr, const char **endptr, unsigned int base,
445 bool strict, uint64_t *result)
446{
447 assert(result != NULL);
448
449 errno_t rc = EOK;
450 char *lendptr = (char *) nptr;
451
452 uintmax_t r = _strtounsigned(nptr, &lendptr, base, UINT64_MAX, &rc, true);
453
454 if (endptr)
455 *endptr = lendptr;
456
457 if (rc != EOK)
458 return rc;
459
460 if (strict && *lendptr != '\0')
461 return EINVAL;
462
463 *result = r;
464 return EOK;
465}
466
467/** Convert string to int64_t.
468 *
469 * @param nptr Pointer to string.
470 * @param endptr If not NULL, pointer to the first invalid character
471 * is stored here.
472 * @param base Zero or number between 2 and 36 inclusive.
473 * @param strict Do not allow any trailing characters.
474 * @param result Result of the conversion.
475 *
476 * @return EOK if conversion was successful.
477 *
478 */
479errno_t str_int64_t(const char *nptr, const char **endptr, unsigned int base,
480 bool strict, int64_t *result)
481{
482 assert(result != NULL);
483
484 errno_t rc = EOK;
485 char *lendptr = (char *) nptr;
486
487 intmax_t r = _strtosigned(nptr, &lendptr, base, INT64_MIN, INT64_MAX, &rc, true);
488
489 if (endptr)
490 *endptr = lendptr;
491
492 if (rc != EOK)
493 return rc;
494
495 if (strict && *lendptr != '\0')
496 return EINVAL;
497
498 *result = r;
499 return EOK;
500}
501
502/** Convert string to size_t.
503 *
504 * @param nptr Pointer to string.
505 * @param endptr If not NULL, pointer to the first invalid character
506 * is stored here.
507 * @param base Zero or number between 2 and 36 inclusive.
508 * @param strict Do not allow any trailing characters.
509 * @param result Result of the conversion.
510 *
511 * @return EOK if conversion was successful.
512 *
513 */
514errno_t str_size_t(const char *nptr, const char **endptr, unsigned int base,
515 bool strict, size_t *result)
516{
517 assert(result != NULL);
518
519 errno_t rc = EOK;
520 char *lendptr = (char *) nptr;
521
522 uintmax_t r = _strtounsigned(nptr, &lendptr, base, SIZE_MAX, &rc, true);
523
524 if (endptr)
525 *endptr = lendptr;
526
527 if (rc != EOK)
528 return rc;
529
530 if (strict && *lendptr != '\0')
531 return EINVAL;
532
533 *result = r;
534 return EOK;
535}
536
537/** @}
538 */
Note: See TracBrowser for help on using the repository browser.