101 lines
2.9 KiB
C++
101 lines
2.9 KiB
C++
#include <limits.h>
|
|
#include <luna/CType.h>
|
|
#include <luna/NumberParsing.h>
|
|
|
|
// This function assumes you have called is_valid_digit_for_base() to validate the digit first.
|
|
static isize parse_digit_unchecked(char c)
|
|
{
|
|
if (_isdigit(c)) return c - '0';
|
|
if (_islower(c)) return (c - 'a') + 10;
|
|
return (c - 'A') + 10;
|
|
}
|
|
|
|
static bool is_valid_digit_for_base(int base, char c)
|
|
{
|
|
if (!_isalnum(c)) return false;
|
|
if (parse_digit_unchecked(c) >= (isize)base) return false;
|
|
return true;
|
|
}
|
|
|
|
static usize do_unsigned_parse(const char* str, const char** endptr, int base)
|
|
{
|
|
usize val = 0;
|
|
|
|
// 1. 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).
|
|
if ((base == 0 || base == 16) && *str == '0')
|
|
{
|
|
str++;
|
|
if (_tolower(*str) == 'x')
|
|
{
|
|
base = 16;
|
|
str++;
|
|
}
|
|
else if (base == 0)
|
|
base = 8;
|
|
}
|
|
else if (base == 0)
|
|
base = 10;
|
|
|
|
// 2. The remainder of the string is converted to an unsigned long value in
|
|
// the obvious manner, stopping at the first character which is not a
|
|
// valid digit in the given base.
|
|
while (is_valid_digit_for_base(base, *str))
|
|
{
|
|
val = ((usize)base * val) + (usize)parse_digit_unchecked(*str);
|
|
str++;
|
|
}
|
|
|
|
// 3. If endptr is not NULL, this function stores the address of the first invalid character in *endptr.
|
|
if (endptr) *endptr = str;
|
|
|
|
return val;
|
|
}
|
|
|
|
usize parse_unsigned_integer(const char* str, const char** endptr, int base)
|
|
{
|
|
// The string may begin with an arbitrary amount of white space (as determined by isspace(3)),
|
|
while (_isspace(*str)) str++;
|
|
|
|
// followed by a single optional '+' or '-' sign.
|
|
if (*str == '-' || *str == '+') str++;
|
|
|
|
return do_unsigned_parse(str, endptr, base);
|
|
}
|
|
|
|
#define SSIZE_MAX LONG_MAX
|
|
#define SSIZE_MIN (-SSIZE_MAX - (isize)1)
|
|
|
|
isize parse_signed_integer(const char* str, const char** endptr, int base)
|
|
{
|
|
bool negative = false;
|
|
|
|
// The string may begin with an arbitrary amount of white space (as determined by isspace(3)),
|
|
while (_isspace(*str)) str++;
|
|
|
|
// followed by a single optional '+' or '-' sign.
|
|
if (*str == '-' || *str == '+')
|
|
{
|
|
if (*str == '-') negative = true;
|
|
str++;
|
|
}
|
|
|
|
usize rc = do_unsigned_parse(str, endptr, base);
|
|
|
|
// If an underflow occurs, this function returns SSIZE_MIN. If an overflow occurs, this function returns SSIZE_MAX.
|
|
if (rc > SSIZE_MAX) { return negative ? SSIZE_MIN : SSIZE_MAX; }
|
|
|
|
return negative ? -(isize)rc : (isize)rc;
|
|
}
|
|
|
|
usize scan_unsigned_integer(const char** str, int base)
|
|
{
|
|
return parse_unsigned_integer(*str, str, base);
|
|
}
|
|
|
|
isize scan_signed_integer(const char** str, int base)
|
|
{
|
|
return parse_signed_integer(*str, str, base);
|
|
}
|