compiler/clib/strtoull.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     ANSI C function strtoull().
   6 */
   7
   8 /* This function requires the use of the long long type. */
   9 #include <aros/system.h>
  10 #if defined(AROS_HAVE_LONG_LONG)
  11
  12 #include <ctype.h>
  13 #include <errno.h>
  14 #include <stdlib.h>
  15 #ifndef AROS_NO_LIMITS_H
  16 #       include <limits.h>
  17 #else
  18 #       define ULLONG_MAX       0xffffffffffffffffULL
  19 #endif
  20
  21 /*****************************************************************************
  22
  23     NAME */
  24 #include <stdlib.h>
  25
  26         unsigned long long strtoull (
  27
  28 /*  SYNOPSIS */
  29         const char * restrict   str,
  30         char      ** restrict   endptr,
  31         int                     base)
  32
  33 /*  FUNCTION
  34         Convert a string of digits into an integer according to the
  35         given base.
  36
  37     INPUTS
  38         str - The string which should be converted. Leading
  39                 whitespace are ignored. The number may be prefixed
  40                 by a '+' or '-'. If base is above 10, then the
  41                 alphabetic characters from 'A' are used to specify
  42                 digits above 9 (ie. 'A' or 'a' is 10, 'B' or 'b' is
  43                 11 and so on until 'Z' or 'z' is 35).
  44         endptr - If this is non-NULL, then the address of the first
  45                 character after the number in the string is stored
  46                 here.
  47         base - The base for the number. May be 0 or between 2 and 36,
  48                 including both. 0 means to autodetect the base. strtoull()
  49                 selects the base by inspecting the first characters
  50                 of the string. If they are "0x", then base 16 is
  51                 assumed. If they are "0", then base 8 is assumed. Any
  52                 other digit will assume base 10. This is like in C.
  53
  54                 If you give base 16, then an optional "0x" may
  55                 precede the number in the string.
  56
  57     RESULT
  58         The value of the string. The first character after the number
  59         is returned in *endptr, if endptr is non-NULL. If no digits can
  60         be converted, *endptr contains str (if non-NULL) and 0 is
  61         returned.
  62
  63     NOTES
  64
  65     EXAMPLE
  66         // Returns 1, ptr points to the 0-Byte
  67         strtoull ("  \t +0x1", &ptr, 0);
  68
  69         // Returns 15. ptr points to the a
  70         strtoull ("017a", &ptr, 0);
  71
  72         // Returns 215 (5*36 + 35)
  73         strtoull ("5z", &ptr, 36);
  74
  75     BUGS
  76
  77     SEE ALSO
  78         strtoll(), strtoull()
  79
  80     INTERNALS
  81
  82 ******************************************************************************/
  83 {
  84     unsigned long long  val = 0;
  85     int                 digit;
  86     char                c = 0;
  87     unsigned long long  cutoff;
  88     int                 cutlim;
  89     int                 any;
  90
  91     if (base < 0 || base == 1 || base > 36)
  92     {
  93         errno = EINVAL;
  94
  95         if (endptr)
  96             *endptr = (char *)str;
  97
  98         return 0;
  99     }
 100
 101     while (isspace (*str))
 102         str ++;
 103
 104     if (*str)
 105     {
 106         if (*str == '+' || *str == '-')
 107             c = *str ++;
 108
 109         /* Assume base ? */
 110         if (base == 0 || base == 16)
 111         {
 112             if (*str == '0') /* Base 8 or 16 */
 113             {
 114                 str++;
 115                 if (*str == 'x' || *str == 'X')
 116                 {
 117                     base = 16;
 118                     str++;
 119                 }
 120                 else if(base == 0)
 121                     base = 8;
 122             }
 123             else if(base == 0) /* Any other digit: Base 10 (decimal) */
 124                 base = 10;
 125         }
 126
 127         /*
 128             Conversion loop, from FreeBSD's src/lib/libc/stdlib/strtoull.c
 129
 130             The previous AROS loop was
 131             a) inefficient - it did a division each time around.
 132             b) buggy - it returned the wrong value in endptr on overflow.
 133         */
 134         cutoff = (unsigned long long)ULLONG_MAX / (unsigned long long)base;
 135         cutlim = (unsigned long long)ULLONG_MAX % (unsigned long long)base;
 136         val = 0;
 137         any = 0;
 138
 139         while (*str)
 140         {
 141             digit = *str;
 142
 143             if (!isascii(digit))
 144                 break;
 145
 146             if (isdigit(digit))
 147                 digit -= '0';
 148             else if (isalpha(digit))
 149                 digit -= isupper(c) ? 'A' - 10 : 'a' - 10;
 150             else
 151                 break;
 152
 153             if (digit >= base)
 154                 break;
 155
 156             /*
 157                 any < 0 when we have overflowed. We still need to find the
 158                 end of the subject sequence
 159             */
 160             if (any < 0 || val > cutoff || (val == cutoff && digit > cutlim))
 161             {
 162                 any = -1;
 163             }
 164             else
 165             {
 166                 any = 1;
 167                 val = (val * base) + digit;
 168             }
 169
 170             str++;
 171         }
 172
 173         /* Range overflow */
 174         if (any < 0)
 175         {
 176             val = ULLONG_MAX;
 177             errno = ERANGE;
 178         }
 179
 180         if (c == '-')
 181             val = -val;
 182     }
 183
 184     if (endptr)
 185         *endptr = (char *)str;
 186
 187     return val;
 188 } /* strtoull */
 189
 190 #endif /* AROS_HAVE_LONG_LONG */