lib/strto.c

   1 /*
   2  *  linux/lib/vsprintf.c
   3  *
   4  *  Copyright (C) 1991, 1992  Linus Torvalds
   5  */
   6
   7 /* vsprintf.c -- Lars Wirzenius & Linus Torvalds. */
   8 /*
   9  * Wirzenius wrote this portably, Torvalds fucked it up :-)
  10  */
  11
  12 #include <common.h>
  13 #include <errno.h>
  14 #include <linux/ctype.h>
  15
  16 /* from lib/kstrtox.c */
  17 static const char *_parse_integer_fixup_radix(const char *s, unsigned int *base)
  18 {
  19         if (*base == 0) {
  20                 if (s[0] == '0') {
  21                         if (tolower(s[1]) == 'x' && isxdigit(s[2]))
  22                                 *base = 16;
  23                         else
  24                                 *base = 8;
  25                 } else {
  26                         int i = 0;
  27                         char var;
  28
  29                         *base = 10;
  30
  31                         do {
  32                                 var = tolower(s[i++]);
  33                                 if (var >= 'a' && var <= 'f') {
  34                                         *base = 16;
  35                                         break;
  36                                 }
  37                         } while (var);
  38                 }
  39         }
  40
  41         if (*base == 16 && s[0] == '0' && tolower(s[1]) == 'x')
  42                 s += 2;
  43         return s;
  44 }
  45
  46 unsigned long simple_strtoul(const char *cp, char **endp,
  47                                 unsigned int base)
  48 {
  49         unsigned long result = 0;
  50         unsigned long value;
  51
  52         cp = _parse_integer_fixup_radix(cp, &base);
  53
  54         while (isxdigit(*cp) && (value = isdigit(*cp) ? *cp-'0' : (islower(*cp)
  55             ? toupper(*cp) : *cp)-'A'+10) < base) {
  56                 result = result*base + value;
  57                 cp++;
  58         }
  59
  60         if (endp)
  61                 *endp = (char *)cp;
  62
  63         return result;
  64 }
  65
  66 int strict_strtoul(const char *cp, unsigned int base, unsigned long *res)
  67 {
  68         char *tail;
  69         unsigned long val;
  70         size_t len;
  71
  72         *res = 0;
  73         len = strlen(cp);
  74         if (len == 0)
  75                 return -EINVAL;
  76
  77         val = simple_strtoul(cp, &tail, base);
  78         if (tail == cp)
  79                 return -EINVAL;
  80
  81         if ((*tail == '\0') ||
  82                 ((len == (size_t)(tail - cp) + 1) && (*tail == '\n'))) {
  83                 *res = val;
  84                 return 0;
  85         }
  86
  87         return -EINVAL;
  88 }
  89
  90 long simple_strtol(const char *cp, char **endp, unsigned int base)
  91 {
  92         if (*cp == '-')
  93                 return -simple_strtoul(cp + 1, endp, base);
  94
  95         return simple_strtoul(cp, endp, base);
  96 }
  97
  98 unsigned long ustrtoul(const char *cp, char **endp, unsigned int base)
  99 {
 100         unsigned long result = simple_strtoul(cp, endp, base);
 101         switch (tolower(**endp)) {
 102         case 'g':
 103                 result *= 1024;
 104                 /* fall through */
 105         case 'm':
 106                 result *= 1024;
 107                 /* fall through */
 108         case 'k':
 109                 result *= 1024;
 110                 (*endp)++;
 111                 if (**endp == 'i')
 112                         (*endp)++;
 113                 if (**endp == 'B')
 114                         (*endp)++;
 115         }
 116         return result;
 117 }
 118
 119 unsigned long long ustrtoull(const char *cp, char **endp, unsigned int base)
 120 {
 121         unsigned long long result = simple_strtoull(cp, endp, base);
 122         switch (tolower(**endp)) {
 123         case 'g':
 124                 result *= 1024;
 125                 /* fall through */
 126         case 'm':
 127                 result *= 1024;
 128                 /* fall through */
 129         case 'k':
 130                 result *= 1024;
 131                 (*endp)++;
 132                 if (**endp == 'i')
 133                         (*endp)++;
 134                 if (**endp == 'B')
 135                         (*endp)++;
 136         }
 137         return result;
 138 }
 139
 140 unsigned long long simple_strtoull(const char *cp, char **endp,
 141                                         unsigned int base)
 142 {
 143         unsigned long long result = 0, value;
 144
 145         cp = _parse_integer_fixup_radix(cp, &base);
 146
 147         while (isxdigit(*cp) && (value = isdigit(*cp) ? *cp - '0'
 148                 : (islower(*cp) ? toupper(*cp) : *cp) - 'A' + 10) < base) {
 149                 result = result * base + value;
 150                 cp++;
 151         }
 152
 153         if (endp)
 154                 *endp = (char *) cp;
 155
 156         return result;
 157 }
 158
 159 long trailing_strtoln(const char *str, const char *end)
 160 {
 161         const char *p;
 162
 163         if (!end)
 164                 end = str + strlen(str);
 165         if (isdigit(end[-1])) {
 166                 for (p = end - 1; p > str; p--) {
 167                         if (!isdigit(*p))
 168                                 return simple_strtoul(p + 1, NULL, 10);
 169                 }
 170         }
 171
 172         return -1;
 173 }
 174
 175 long trailing_strtol(const char *str)
 176 {
 177         return trailing_strtoln(str, NULL);
 178 }