mirror of
https://github.com/AsahiLinux/u-boot
synced 2024-11-27 15:12:21 +00:00
1fae74125b
This reverts commit 0486497e2b.
The strtoul has well-defined semantics. It is defined by the C standard and
POSIX. To quote the relevant section of the man pages,
> If base is zero or 16, the string may then include a "0x" prefix, and the
> number will be read in base 16; otherwise, a zero base is taken as 10
> (decimal) unless the next character is '0', in which case it is taken as
> 8 (octal).
Keeping these semantics is important for several reasons. First, it is very
surprising for standard library functions to behave differently than usual.
Every other implementation of strtoul has different semantics than the
implementation in U-Boot at the moment. Second, it can result in very
surprising results from small changes. For example, changing the string
"1f" to "20" causes the parsed value to *decrease*. Forcing use of the "0x"
prefix to specify hexidecimal numbers is a feature, not a bug. Lastly, this
is slightly less performant, since the entire number is parsed twice.
This fixes the str_simple_strtoul test failing with
test/str_ut.c:29, run_strtoul(): expect_val == val: Expected 0x44b (1099), got 0x1099ab (1087915)
test/str_ut.c:46, str_simple_strtoul(): 0 == run_strtoul(uts, str2, 0, 1099, 4): Expected 0x0 (0), got 0x1 (1)
Signed-off-by: Sean Anderson <seanga2@gmail.com>
CC: Michal Simek <michal.simek@xilinx.com>
CC: Shiril Tichkule <shirilt@xilinx.com>
Reviewed-by: Simon Glass <sjg@chromium.org>
173 lines
3.2 KiB
C
173 lines
3.2 KiB
C
/*
|
|
* linux/lib/vsprintf.c
|
|
*
|
|
* Copyright (C) 1991, 1992 Linus Torvalds
|
|
*/
|
|
|
|
/* vsprintf.c -- Lars Wirzenius & Linus Torvalds. */
|
|
/*
|
|
* Wirzenius wrote this portably, Torvalds fucked it up :-)
|
|
*/
|
|
|
|
#include <common.h>
|
|
#include <errno.h>
|
|
#include <linux/ctype.h>
|
|
|
|
/* from lib/kstrtox.c */
|
|
static const char *_parse_integer_fixup_radix(const char *s, unsigned int *base)
|
|
{
|
|
if (*base == 0) {
|
|
if (s[0] == '0') {
|
|
if (tolower(s[1]) == 'x' && isxdigit(s[2]))
|
|
*base = 16;
|
|
else
|
|
*base = 8;
|
|
} else
|
|
*base = 10;
|
|
}
|
|
if (*base == 16 && s[0] == '0' && tolower(s[1]) == 'x')
|
|
s += 2;
|
|
return s;
|
|
}
|
|
|
|
unsigned long simple_strtoul(const char *cp, char **endp,
|
|
unsigned int base)
|
|
{
|
|
unsigned long result = 0;
|
|
unsigned long value;
|
|
|
|
cp = _parse_integer_fixup_radix(cp, &base);
|
|
|
|
while (isxdigit(*cp) && (value = isdigit(*cp) ? *cp-'0' : (islower(*cp)
|
|
? toupper(*cp) : *cp)-'A'+10) < base) {
|
|
result = result*base + value;
|
|
cp++;
|
|
}
|
|
|
|
if (endp)
|
|
*endp = (char *)cp;
|
|
|
|
return result;
|
|
}
|
|
|
|
int strict_strtoul(const char *cp, unsigned int base, unsigned long *res)
|
|
{
|
|
char *tail;
|
|
unsigned long val;
|
|
size_t len;
|
|
|
|
*res = 0;
|
|
len = strlen(cp);
|
|
if (len == 0)
|
|
return -EINVAL;
|
|
|
|
val = simple_strtoul(cp, &tail, base);
|
|
if (tail == cp)
|
|
return -EINVAL;
|
|
|
|
if ((*tail == '\0') ||
|
|
((len == (size_t)(tail - cp) + 1) && (*tail == '\n'))) {
|
|
*res = val;
|
|
return 0;
|
|
}
|
|
|
|
return -EINVAL;
|
|
}
|
|
|
|
long simple_strtol(const char *cp, char **endp, unsigned int base)
|
|
{
|
|
if (*cp == '-')
|
|
return -simple_strtoul(cp + 1, endp, base);
|
|
|
|
return simple_strtoul(cp, endp, base);
|
|
}
|
|
|
|
unsigned long ustrtoul(const char *cp, char **endp, unsigned int base)
|
|
{
|
|
unsigned long result = simple_strtoul(cp, endp, base);
|
|
switch (tolower(**endp)) {
|
|
case 'g':
|
|
result *= 1024;
|
|
/* fall through */
|
|
case 'm':
|
|
result *= 1024;
|
|
/* fall through */
|
|
case 'k':
|
|
result *= 1024;
|
|
(*endp)++;
|
|
if (**endp == 'i')
|
|
(*endp)++;
|
|
if (**endp == 'B')
|
|
(*endp)++;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
unsigned long long ustrtoull(const char *cp, char **endp, unsigned int base)
|
|
{
|
|
unsigned long long result = simple_strtoull(cp, endp, base);
|
|
switch (tolower(**endp)) {
|
|
case 'g':
|
|
result *= 1024;
|
|
/* fall through */
|
|
case 'm':
|
|
result *= 1024;
|
|
/* fall through */
|
|
case 'k':
|
|
result *= 1024;
|
|
(*endp)++;
|
|
if (**endp == 'i')
|
|
(*endp)++;
|
|
if (**endp == 'B')
|
|
(*endp)++;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
unsigned long long simple_strtoull(const char *cp, char **endp,
|
|
unsigned int base)
|
|
{
|
|
unsigned long long result = 0, value;
|
|
|
|
cp = _parse_integer_fixup_radix(cp, &base);
|
|
|
|
while (isxdigit(*cp) && (value = isdigit(*cp) ? *cp - '0'
|
|
: (islower(*cp) ? toupper(*cp) : *cp) - 'A' + 10) < base) {
|
|
result = result * base + value;
|
|
cp++;
|
|
}
|
|
|
|
if (endp)
|
|
*endp = (char *) cp;
|
|
|
|
return result;
|
|
}
|
|
|
|
long trailing_strtoln(const char *str, const char *end)
|
|
{
|
|
const char *p;
|
|
|
|
if (!end)
|
|
end = str + strlen(str);
|
|
if (isdigit(end[-1])) {
|
|
for (p = end - 1; p > str; p--) {
|
|
if (!isdigit(*p))
|
|
return simple_strtoul(p + 1, NULL, 10);
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
long trailing_strtol(const char *str)
|
|
{
|
|
return trailing_strtoln(str, NULL);
|
|
}
|
|
|
|
void str_to_upper(const char *in, char *out, size_t len)
|
|
{
|
|
for (; len > 0 && *in; len--)
|
|
*out++ = toupper(*in++);
|
|
if (len)
|
|
*out = '\0';
|
|
}
|