compiler/clib/strtoull.c

   1 /*
   2     Copyright © 1995-2012, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     C99 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 #ifndef AROSC_ROM
  94         errno = EINVAL;
  95 #endif
  96         if (endptr)
  97             *endptr = (char *)str;
  98
  99         return 0;
 100     }
 101
 102     while (isspace (*str))
 103         str ++;
 104
 105     if (*str)
 106     {
 107         if (*str == '+' || *str == '-')
 108             c = *str ++;
 109
 110         /* Assume base ? */
 111         if (base == 0 || base == 16)
 112         {
 113             if (*str == '0') /* Base 8 or 16 */
 114             {
 115                 str++;
 116                 if (*str == 'x' || *str == 'X')
 117                 {
 118                     base = 16;
 119                     str++;
 120                 }
 121                 else if(base == 0)
 122                     base = 8;
 123             }
 124             else if(base == 0) /* Any other digit: Base 10 (decimal) */
 125                 base = 10;
 126         }
 127
 128         /*
 129             Conversion loop, from FreeBSD's src/lib/libc/stdlib/strtoull.c
 130
 131             The previous AROS loop was
 132             a) inefficient - it did a division each time around.
 133             b) buggy - it returned the wrong value in endptr on overflow.
 134         */
 135         cutoff = (unsigned long long)ULLONG_MAX / (unsigned long long)base;
 136         cutlim = (unsigned long long)ULLONG_MAX % (unsigned long long)base;
 137         val = 0;
 138         any = 0;
 139
 140         while (*str)
 141         {
 142             digit = *str;
 143
 144             if (!isascii(digit))
 145                 break;
 146
 147             if (isdigit(digit))
 148                 digit -= '0';
 149             else if (isalpha(digit))
 150                 digit -= isupper(digit) ? 'A' - 10 : 'a' - 10;
 151             else
 152                 break;
 153
 154             if (digit >= base)
 155                 break;
 156
 157             /*
 158                 any < 0 when we have overflowed. We still need to find the
 159                 end of the subject sequence
 160             */
 161             if (any < 0 || val > cutoff || (val == cutoff && digit > cutlim))
 162             {
 163                 any = -1;
 164             }
 165             else
 166             {
 167                 any = 1;
 168                 val = (val * base) + digit;
 169             }
 170
 171             str++;
 172         }
 173
 174         /* Range overflow */
 175         if (any < 0)
 176         {
 177             val = ULLONG_MAX;
 178 #ifndef AROSC_ROM
 179             errno = ERANGE;
 180 #endif
 181         }
 182
 183         if (c == '-')
 184             val = -val;
 185     }
 186
 187     if (endptr)
 188         *endptr = (char *)str;
 189
 190     return val;
 191 } /* strtoull */
 192
 193 #endif /* AROS_HAVE_LONG_LONG */