StdLib/LibC/StdLib/NumericInt.c

   1 /** @file
   2   Integer Numeric Conversion Functions.
   3
   4   The atoi, atol, and atoll functions convert the initial portion of the string
   5   pointed to by nptr to int, long int, and long long int representation,
   6   respectively.  They are equivalent to:
   7     - atoi: (int)strtol(nptr, (char **)NULL, 10)
   8     - atol: strtol(nptr, (char **)NULL, 10)
   9     - atoll: strtoll(nptr, (char **)NULL, 10)
  10
  11   Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>
  12   This program and the accompanying materials are licensed and made available under
  13   the terms and conditions of the BSD License that accompanies this distribution.
  14   The full text of the license may be found at
  15   http://opensource.org/licenses/bsd-license.php.
  16
  17   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  18   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  19 **/
  20 #include  <Uefi.h>
  21 #include  <Library/BaseLib.h>
  22
  23 #include  <LibConfig.h>
  24
  25 #include  <ctype.h>
  26 #include  <errno.h>
  27 #include  <limits.h>
  28 #include  <stdlib.h>
  29
  30 /** The atoi function converts the initial portion of the string pointed to by
  31     nptr to int representation.  Except for the behavior on error, it is
  32     equivalent to:
  33       - (int)strtol(nptr, (char **)NULL, 10)
  34
  35   @return   The atoi function returns the converted value.
  36 **/
  37 int
  38 atoi(const char *nptr)
  39 {
  40   int       Retval;
  41   BOOLEAN   Negative = FALSE;
  42
  43   while(isspace((const unsigned char)*nptr)) ++nptr; // Skip leading spaces
  44
  45   if(*nptr == '+') {
  46     Negative = FALSE;
  47     ++nptr;
  48   }
  49   else if(*nptr == '-') {
  50     Negative = TRUE;
  51     ++nptr;
  52   }
  53   Retval = (int)AsciiStrDecimalToUintn(nptr);
  54   if(Negative) {
  55     Retval = -Retval;
  56   }
  57   return Retval;
  58 }
  59
  60 /** The atol function converts the initial portion of the string pointed to by
  61     nptr to long int representation.  Except for the behavior on error, it is
  62     equivalent to:
  63       - strtol(nptr, (char **)NULL, 10)
  64
  65   @return   The atol function returns the converted value.
  66 **/
  67 long int
  68 atol(const char *nptr)
  69 {
  70   long int  Retval;
  71   BOOLEAN   Negative = FALSE;
  72
  73   while(isspace(*nptr)) ++nptr; // Skip leading spaces
  74
  75   if(*nptr == '+') {
  76     Negative = FALSE;
  77     ++nptr;
  78   }
  79   else if(*nptr == '-') {
  80     Negative = TRUE;
  81     ++nptr;
  82   }
  83   Retval = (long int)AsciiStrDecimalToUint64(nptr);
  84   if(Negative) {
  85     Retval = -Retval;
  86   }
  87   return Retval;
  88 }
  89
  90 /** The atoll function converts the initial portion of the string pointed to by
  91     nptr to long long int representation.  Except for the behavior on error, it
  92     is equivalent to:
  93       - strtoll(nptr, (char **)NULL, 10)
  94
  95   @return   The atoll function returns the converted value.
  96 **/
  97 long long int
  98 atoll(const char *nptr)
  99 {
 100   long long int   Retval;
 101   BOOLEAN         Negative = FALSE;
 102
 103   while(isspace(*nptr)) ++nptr; // Skip leading spaces
 104
 105   if(*nptr == '+') {
 106     Negative = FALSE;
 107     ++nptr;
 108   }
 109   else if(*nptr == '-') {
 110     Negative = TRUE;
 111     ++nptr;
 112   }
 113   Retval = (long long int)AsciiStrDecimalToUint64(nptr);
 114   if(Negative) {
 115     Retval = -Retval;
 116   }
 117   return Retval;
 118 }
 119
 120 static int
 121 Digit2Val( int c)
 122 {
 123   if(isalpha(c)) {  /* If c is one of [A-Za-z]... */
 124     c = toupper(c) - 7;   // Adjust so 'A' is ('9' + 1)
 125   }
 126   return c - '0';   // Value returned is between 0 and 35, inclusive.
 127 }
 128
 129 /** The strtol, strtoll, strtoul, and strtoull functions convert the initial
 130     portion of the string pointed to by nptr to long int, long long int,
 131     unsigned long int, and unsigned long long int representation, respectively.
 132     First, they decompose the input string into three parts: an initial,
 133     possibly empty, sequence of white-space characters (as specified by the
 134     isspace function), a subject sequence resembling an integer represented in
 135     some radix determined by the value of base, and a final string of one or
 136     more unrecognized characters, including the terminating null character of
 137     the input string. Then, they attempt to convert the subject sequence to an
 138     integer, and return the result.
 139
 140     If the value of base is zero, the expected form of the subject sequence is
 141     that of an integer constant, optionally preceded
 142     by a plus or minus sign, but not including an integer suffix. If the value
 143     of base is between 2 and 36 (inclusive), the expected form of the subject
 144     sequence is a sequence of letters and digits representing an integer with
 145     the radix specified by base, optionally preceded by a plus or minus sign,
 146     but not including an integer suffix. The letters from a (or A) through z
 147     (or Z) are ascribed the values 10 through 35; only letters and digits whose
 148     ascribed values are less than that of base are permitted. If the value of
 149     base is 16, the characters 0x or 0X may optionally precede the sequence of
 150     letters and digits, following the sign if present.
 151
 152     The subject sequence is defined as the longest initial subsequence of the
 153     input string, starting with the first non-white-space character, that is of
 154     the expected form. The subject sequence contains no characters if the input
 155     string is empty or consists entirely of white space, or if the first
 156     non-white-space character is other than a sign or a permissible letter or digit.
 157
 158     If the subject sequence has the expected form and the value of base is
 159     zero, the sequence of characters starting with the first digit is
 160     interpreted as an integer constant. If the subject sequence has the
 161     expected form and the value of base is between 2 and 36, it is used as the
 162     base for conversion, ascribing to each letter its value as given above. If
 163     the subject sequence begins with a minus sign, the value resulting from the
 164     conversion is negated (in the return type). A pointer to the final string
 165     is stored in the object pointed to by endptr, provided that endptr is
 166     not a null pointer.
 167
 168     In other than the "C" locale, additional locale-specific subject sequence
 169     forms may be accepted.
 170
 171     If the subject sequence is empty or does not have the expected form, no
 172     conversion is performed; the value of nptr is stored in the object pointed
 173     to by endptr, provided that endptr is not a null pointer.
 174
 175   @return   The strtol, strtoll, strtoul, and strtoull functions return the
 176             converted value, if any. If no conversion could be performed, zero
 177             is returned. If the correct value is outside the range of
 178             representable values, LONG_MIN, LONG_MAX, LLONG_MIN, LLONG_MAX,
 179             ULONG_MAX, or ULLONG_MAX is returned (according to the return type
 180             and sign of the value, if any), and the value of the macro ERANGE
 181             is stored in errno.
 182 **/
 183 long
 184 strtol(const char * __restrict nptr, char ** __restrict endptr, int base)
 185 {
 186   const char *pEnd;
 187   long        Result = 0;
 188   long        Previous;
 189   int         temp;
 190   BOOLEAN     Negative = FALSE;
 191
 192   pEnd = nptr;
 193
 194   if((base < 0) || (base == 1) || (base > 36)) {
 195     if(endptr != NULL) {
 196     *endptr = NULL;
 197     }
 198     return 0;
 199   }
 200   // Skip leading spaces.
 201   while(isspace(*nptr))   ++nptr;
 202
 203   // Process Subject sequence: optional sign followed by digits.
 204   if(*nptr == '+') {
 205     Negative = FALSE;
 206     ++nptr;
 207   }
 208   else if(*nptr == '-') {
 209     Negative = TRUE;
 210     ++nptr;
 211   }
 212
 213   if(*nptr == '0') {  /* Might be Octal or Hex */
 214     if(toupper(nptr[1]) == 'X') {   /* Looks like Hex */
 215       if((base == 0) || (base == 16)) {
 216         nptr += 2;  /* Skip the "0X"      */
 217         base = 16;  /* In case base was 0 */
 218       }
 219     }
 220     else {    /* Looks like Octal */
 221       if((base == 0) || (base == 8)) {
 222         ++nptr;     /* Skip the leading "0" */
 223         base = 8;   /* In case base was 0   */
 224       }
 225     }
 226   }
 227   if(base == 0) {   /* If still zero then must be decimal */
 228     base = 10;
 229   }
 230   if(*nptr  == '0') {
 231     for( ; *nptr == '0'; ++nptr);  /* Skip any remaining leading zeros */
 232     pEnd = nptr;
 233   }
 234
 235   while( isalnum(*nptr) && ((temp = Digit2Val(*nptr)) < base)) {
 236     Previous = Result;
 237     Result = (Result * base) + (long int)temp;
 238     if( Result <= Previous) {   // Detect Overflow
 239       if(Negative) {
 240         Result = LONG_MIN;
 241       }
 242       else {
 243         Result = LONG_MAX;
 244       }
 245       Negative = FALSE;
 246       errno = ERANGE;
 247       break;
 248     }
 249     pEnd = ++nptr;
 250   }
 251   if(Negative) {
 252     Result = -Result;
 253   }
 254
 255   // Save pointer to final sequence
 256   if(endptr != NULL) {
 257     *endptr = (char *)pEnd;
 258   }
 259   return Result;
 260 }
 261
 262 /** The strtoul function converts the initial portion of the string pointed to
 263     by nptr to unsigned long int representation.
 264
 265     See the description for strtol for more information.
 266
 267   @return   The strtoul function returns the converted value, if any. If no
 268             conversion could be performed, zero is returned. If the correct
 269             value is outside the range of representable values, ULONG_MAX is
 270             returned and the value of the macro ERANGE is stored in errno.
 271 **/
 272 unsigned long
 273 strtoul(const char * __restrict nptr, char ** __restrict endptr, int base)
 274 {
 275   const char     *pEnd;
 276   unsigned long   Result = 0;
 277   unsigned long   Previous;
 278   int             temp;
 279
 280   pEnd = nptr;
 281
 282   if((base < 0) || (base == 1) || (base > 36)) {
 283     if(endptr != NULL) {
 284     *endptr = NULL;
 285     }
 286     return 0;
 287   }
 288   // Skip leading spaces.
 289   while(isspace(*nptr))   ++nptr;
 290
 291   // Process Subject sequence: optional + sign followed by digits.
 292   if(*nptr == '+') {
 293     ++nptr;
 294   }
 295
 296   if(*nptr == '0') {  /* Might be Octal or Hex */
 297     if(toupper(nptr[1]) == 'X') {   /* Looks like Hex */
 298       if((base == 0) || (base == 16)) {
 299         nptr += 2;  /* Skip the "0X"      */
 300         base = 16;  /* In case base was 0 */
 301       }
 302     }
 303     else {    /* Looks like Octal */
 304       if((base == 0) || (base == 8)) {
 305         ++nptr;     /* Skip the leading "0" */
 306         base = 8;   /* In case base was 0   */
 307       }
 308     }
 309   }
 310   if(base == 0) {   /* If still zero then must be decimal */
 311     base = 10;
 312   }
 313   if(*nptr  == '0') {
 314     for( ; *nptr == '0'; ++nptr);  /* Skip any remaining leading zeros */
 315     pEnd = nptr;
 316   }
 317
 318   while( isalnum(*nptr) && ((temp = Digit2Val(*nptr)) < base)) {
 319     Previous = Result;
 320     Result = (Result * base) + (unsigned long)temp;
 321     if( Result < Previous)  {   // If we overflowed
 322       Result = ULONG_MAX;
 323       errno = ERANGE;
 324       break;
 325     }
 326     pEnd = ++nptr;
 327   }
 328
 329   // Save pointer to final sequence
 330   if(endptr != NULL) {
 331     *endptr = (char *)pEnd;
 332   }
 333   return Result;
 334 }
 335
 336 /** The strtoll function converts the initial portion of the string pointed to
 337     by nptr to long long int representation.
 338
 339     See the description for strtol for more information.
 340
 341   @return   The strtoll function returns the converted value, if any. If no
 342             conversion could be performed, zero is returned. If the correct
 343             value is outside the range of representable values, LLONG_MIN or
 344             LLONG_MAX is returned (according to the sign of the value, if any),
 345             and the value of the macro ERANGE is stored in errno.
 346 **/
 347 long long
 348 strtoll(const char * __restrict nptr, char ** __restrict endptr, int base)
 349 {
 350   const char *pEnd;
 351   long long   Result = 0;
 352   long long   Previous;
 353   int         temp;
 354   BOOLEAN     Negative = FALSE;
 355
 356   pEnd = nptr;
 357
 358   if((base < 0) || (base == 1) || (base > 36)) {
 359     if(endptr != NULL) {
 360     *endptr = NULL;
 361     }
 362     return 0;
 363   }
 364   // Skip leading spaces.
 365   while(isspace(*nptr))   ++nptr;
 366
 367   // Process Subject sequence: optional sign followed by digits.
 368   if(*nptr == '+') {
 369     Negative = FALSE;
 370     ++nptr;
 371   }
 372   else if(*nptr == '-') {
 373     Negative = TRUE;
 374     ++nptr;
 375   }
 376
 377   if(*nptr == '0') {  /* Might be Octal or Hex */
 378     if(toupper(nptr[1]) == 'X') {   /* Looks like Hex */
 379       if((base == 0) || (base == 16)) {
 380         nptr += 2;  /* Skip the "0X"      */
 381         base = 16;  /* In case base was 0 */
 382       }
 383     }
 384     else {    /* Looks like Octal */
 385       if((base == 0) || (base == 8)) {
 386         ++nptr;     /* Skip the leading "0" */
 387         base = 8;   /* In case base was 0   */
 388       }
 389     }
 390   }
 391   if(base == 0) {   /* If still zero then must be decimal */
 392     base = 10;
 393   }
 394   if(*nptr  == '0') {
 395     for( ; *nptr == '0'; ++nptr);  /* Skip any remaining leading zeros */
 396     pEnd = nptr;
 397   }
 398
 399   while( isalnum(*nptr) && ((temp = Digit2Val(*nptr)) < base)) {
 400     Previous = Result;
 401     Result = (Result * base) + (long long int)temp;
 402     if( Result <= Previous) {   // Detect Overflow
 403       if(Negative) {
 404         Result = LLONG_MIN;
 405       }
 406       else {
 407         Result = LLONG_MAX;
 408       }
 409       Negative = FALSE;
 410       errno = ERANGE;
 411       break;
 412     }
 413     pEnd = ++nptr;
 414   }
 415   if(Negative) {
 416     Result = -Result;
 417   }
 418
 419   // Save pointer to final sequence
 420   if(endptr != NULL) {
 421     *endptr = (char *)pEnd;
 422   }
 423   return Result;
 424 }
 425
 426 /** The strtoull function converts the initial portion of the string pointed to
 427     by nptr to unsigned long long int representation.
 428
 429     See the description for strtol for more information.
 430
 431   @return   The strtoull function returns the converted value, if any. If no
 432             conversion could be performed, zero is returned. If the correct
 433             value is outside the range of representable values, ULLONG_MAX is
 434             returned and the value of the macro ERANGE is stored in errno.
 435 **/
 436 unsigned long long
 437 strtoull(const char * __restrict nptr, char ** __restrict endptr, int base)
 438 {
 439   const char           *pEnd;
 440   unsigned long long    Result = 0;
 441   unsigned long long    Previous;
 442   int                   temp;
 443
 444   pEnd = nptr;
 445
 446   if((base < 0) || (base == 1) || (base > 36)) {
 447     if(endptr != NULL) {
 448     *endptr = NULL;
 449     }
 450     return 0;
 451   }
 452   // Skip leading spaces.
 453   while(isspace(*nptr))   ++nptr;
 454
 455   // Process Subject sequence: optional + sign followed by digits.
 456   if(*nptr == '+') {
 457     ++nptr;
 458   }
 459
 460   if(*nptr == '0') {  /* Might be Octal or Hex */
 461     if(toupper(nptr[1]) == 'X') {   /* Looks like Hex */
 462       if((base == 0) || (base == 16)) {
 463         nptr += 2;  /* Skip the "0X"      */
 464         base = 16;  /* In case base was 0 */
 465       }
 466     }
 467     else {    /* Looks like Octal */
 468       if((base == 0) || (base == 8)) {
 469         ++nptr;     /* Skip the leading "0" */
 470         base = 8;   /* In case base was 0   */
 471       }
 472     }
 473   }
 474   if(base == 0) {   /* If still zero then must be decimal */
 475     base = 10;
 476   }
 477   if(*nptr  == '0') {
 478     for( ; *nptr == '0'; ++nptr);  /* Skip any remaining leading zeros */
 479     pEnd = nptr;
 480   }
 481
 482   while( isalnum(*nptr) && ((temp = Digit2Val(*nptr)) < base)) {
 483     Previous = Result;
 484     Result = (Result * base) + (unsigned long long)temp;
 485     if( Result < Previous)  {   // If we overflowed
 486       Result = ULLONG_MAX;
 487       errno = ERANGE;
 488       break;
 489     }
 490     pEnd = ++nptr;
 491   }
 492
 493   // Save pointer to final sequence
 494   if(endptr != NULL) {
 495     *endptr = (char *)pEnd;
 496   }
 497   return Result;
 498 }