uspace/lib/c/generic/strtol.c

   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
  54 static 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
  76 static 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
 121 static 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
 218 static 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
 236 static 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  */
 269 long 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  */
 287 unsigned long strtoul(const char *nptr, char **endptr, int base)
 288 {
 289         return _strtounsigned(nptr, endptr, base, ULONG_MAX, &errno, false);
 290 }
 291
 292 long long strtoll(const char *nptr, char **endptr, int base)
 293 {
 294         return _strtosigned(nptr, endptr, base, LLONG_MIN, LLONG_MAX, &errno, false);
 295 }
 296
 297 unsigned long long strtoull(const char *nptr, char **endptr, int base)
 298 {
 299         return _strtounsigned(nptr, endptr, base, ULLONG_MAX, &errno, false);
 300 }
 301
 302 intmax_t strtoimax(const char *nptr, char **endptr, int base)
 303 {
 304         return _strtosigned(nptr, endptr, base, INTMAX_MIN, INTMAX_MAX, &errno, false);
 305 }
 306
 307 uintmax_t strtoumax(const char *nptr, char **endptr, int base)
 308 {
 309         return _strtounsigned(nptr, endptr, base, UINTMAX_MAX, &errno, false);
 310 }
 311
 312 int atoi(const char *nptr)
 313 {
 314         return (int)strtol(nptr, NULL, 10);
 315 }
 316
 317 long atol(const char *nptr)
 318 {
 319         return strtol(nptr, NULL, 10);
 320 }
 321
 322 long 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  */
 339 errno_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  */
 374 errno_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  */
 409 errno_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  */
 444 errno_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  */
 479 errno_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  */
 514 errno_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  */