LibC: Move strtoT implementation to common header
This commit is contained in:
317
userspace/libraries/LibC/include/bits/strtoT.hpp
Normal file
317
userspace/libraries/LibC/include/bits/strtoT.hpp
Normal file
@@ -0,0 +1,317 @@
|
||||
#ifndef _BITS_STRTOT_HPP
|
||||
#define _BITS_STRTOT_HPP 1
|
||||
|
||||
#include <BAN/Math.h>
|
||||
|
||||
#include <errno.h>
|
||||
#include <ctype.h>
|
||||
#include <wchar.h>
|
||||
|
||||
template<typename CHAR>
|
||||
struct strtoT_traits;
|
||||
|
||||
template<>
|
||||
struct strtoT_traits<char>
|
||||
{
|
||||
static constexpr int (&isalnum)(int) = ::isalnum;
|
||||
static constexpr int (&isalpha)(int) = ::isalpha;
|
||||
static constexpr int (&isdigit)(int) = ::isdigit;
|
||||
static constexpr int (&isspace)(int) = ::isspace;
|
||||
static constexpr int (&isxdigit)(int) = ::isxdigit;
|
||||
static constexpr int (&tolower)(int) = ::tolower;
|
||||
static constexpr int (&strncasecmp)(const char*, const char*, size_t) = ::strncasecmp;
|
||||
static constexpr const char* lit_0b = "0b";
|
||||
static constexpr const char* lit_0x = "0x";
|
||||
static constexpr const char* lit_inf = "inf";
|
||||
static constexpr const char* lit_infinity = "infinity";
|
||||
static constexpr const char* lit_nan = "nan";
|
||||
};
|
||||
|
||||
template<>
|
||||
struct strtoT_traits<wchar_t>
|
||||
{
|
||||
static constexpr int (&isalnum)(wint_t) = ::iswalnum;
|
||||
static constexpr int (&isalpha)(wint_t) = ::iswalpha;
|
||||
static constexpr int (&isdigit)(wint_t) = ::iswdigit;
|
||||
static constexpr int (&isspace)(wint_t) = ::iswspace;
|
||||
static constexpr int (&isxdigit)(wint_t) = ::iswxdigit;
|
||||
static constexpr wint_t (&tolower)(wint_t) = ::towlower;
|
||||
static constexpr int (&strncasecmp)(const wchar_t*, const wchar_t*, size_t) = ::wcsncasecmp;
|
||||
static constexpr const wchar_t* lit_0x = L"0x";
|
||||
static constexpr const wchar_t* lit_inf = L"inf";
|
||||
static constexpr const wchar_t* lit_infinity = L"infinity";
|
||||
static constexpr const wchar_t* lit_nan = L"nan";
|
||||
};
|
||||
|
||||
template<BAN::integral T, typename CHAR>
|
||||
static T strtoT(const CHAR* str, CHAR** endp, int base, int& error)
|
||||
{
|
||||
using traits = strtoT_traits<CHAR>;
|
||||
|
||||
constexpr auto will_digit_append_overflow = [](T current, int digit, int base) -> bool {
|
||||
if (BAN::Math::will_multiplication_overflow<T>(current, base))
|
||||
return true;
|
||||
if (BAN::Math::will_addition_overflow<T>(current * base, current < 0 ? -digit : digit))
|
||||
return true;
|
||||
return false;
|
||||
};
|
||||
|
||||
constexpr auto get_base_digit = [](CHAR c, int base) {
|
||||
int digit = -1;
|
||||
if (traits::isdigit(c))
|
||||
digit = c - CHAR('0');
|
||||
else if (traits::isalpha(c))
|
||||
digit = 10 + traits::tolower(c) - CHAR('a');
|
||||
if (digit < 0 || digit >= base)
|
||||
digit = -1;
|
||||
return digit;
|
||||
};
|
||||
|
||||
const CHAR* orig_str = str;
|
||||
|
||||
// validate base
|
||||
if (base != 0 && (base < 2 || base > 36))
|
||||
{
|
||||
if (endp)
|
||||
*endp = const_cast<CHAR*>(str);
|
||||
error = EINVAL;
|
||||
return 0;
|
||||
}
|
||||
|
||||
// skip whitespace
|
||||
while (traits::isspace(*str))
|
||||
str++;
|
||||
|
||||
// get sign and skip it
|
||||
const bool negative = (*str == CHAR('-'));
|
||||
if (*str == CHAR('-') || *str == CHAR('+'))
|
||||
str++;
|
||||
|
||||
// determine base from prefix
|
||||
if (base == 0)
|
||||
{
|
||||
if (*str != CHAR('0'))
|
||||
base = 10;
|
||||
else if (traits::tolower(str[1]) == CHAR('x'))
|
||||
base = 16;
|
||||
else
|
||||
base = 8;
|
||||
}
|
||||
|
||||
// check for invalid conversion
|
||||
if (get_base_digit(*str, base) == -1)
|
||||
{
|
||||
if (endp)
|
||||
*endp = const_cast<CHAR*>(orig_str);
|
||||
error = EINVAL;
|
||||
return 0;
|
||||
}
|
||||
|
||||
// remove "0x" prefix from hexadecimal
|
||||
if (base == 16 && traits::strncasecmp(str, traits::lit_0x, 2) == 0 && get_base_digit(str[2], base) != -1)
|
||||
str += 2;
|
||||
|
||||
bool overflow = false;
|
||||
|
||||
T result = 0;
|
||||
// calculate the value of the number in string
|
||||
while (!overflow)
|
||||
{
|
||||
int digit = get_base_digit(*str, base);
|
||||
if (digit == -1)
|
||||
break;
|
||||
str++;
|
||||
|
||||
overflow = will_digit_append_overflow(result, digit, base);
|
||||
if (!overflow)
|
||||
{
|
||||
if (negative && !BAN::is_unsigned_v<T>)
|
||||
digit = -digit;
|
||||
result = result * base + digit;
|
||||
}
|
||||
}
|
||||
|
||||
if (negative && BAN::is_unsigned_v<T>)
|
||||
result = -result;
|
||||
|
||||
// save endp if asked
|
||||
if (endp)
|
||||
{
|
||||
while (get_base_digit(*str, base) != -1)
|
||||
str++;
|
||||
*endp = const_cast<CHAR*>(str);
|
||||
}
|
||||
|
||||
// return error on overflow
|
||||
if (overflow)
|
||||
{
|
||||
error = ERANGE;
|
||||
if constexpr(BAN::is_unsigned_v<T>)
|
||||
return BAN::numeric_limits<T>::max();
|
||||
return negative ? BAN::numeric_limits<T>::min() : BAN::numeric_limits<T>::max();
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
template<BAN::floating_point T, typename CHAR>
|
||||
static T strtoT(const CHAR* str, CHAR** endp, int& error)
|
||||
{
|
||||
using traits = strtoT_traits<CHAR>;
|
||||
|
||||
constexpr auto get_base_digit = [](CHAR c, int base) {
|
||||
int digit = -1;
|
||||
if (traits::isdigit(c))
|
||||
digit = c - CHAR('0');
|
||||
else if (traits::isalpha(c))
|
||||
digit = 10 + traits::tolower(c) - CHAR('a');
|
||||
if (digit < 0 || digit >= base)
|
||||
digit = -1;
|
||||
return digit;
|
||||
};
|
||||
|
||||
// find nan end including possible n-char-sequence
|
||||
const auto get_nan_end = [](const CHAR* str) -> const CHAR* {
|
||||
ASSERT(traits::strncasecmp(str, traits::lit_nan, 3) == 0);
|
||||
if (str[3] != CHAR('('))
|
||||
return str + 3;
|
||||
for (size_t i = 4; traits::isalnum(str[i]) || str[i] == CHAR('_'); i++)
|
||||
if (str[i] == CHAR(')'))
|
||||
return str + i + 1;
|
||||
return str + 3;
|
||||
};
|
||||
|
||||
// skip whitespace
|
||||
while (traits::isspace(*str))
|
||||
str++;
|
||||
|
||||
// get sign and skip it
|
||||
const bool negative = (*str == CHAR('-'));
|
||||
if (*str == CHAR('-') || *str == CHAR('+'))
|
||||
str++;
|
||||
|
||||
// check for infinity or nan
|
||||
{
|
||||
T result = 0;
|
||||
|
||||
if (traits::strncasecmp(str, traits::lit_inf, 3) == 0)
|
||||
{
|
||||
result = BAN::numeric_limits<T>::infinity();
|
||||
str += traits::strncasecmp(str, traits::lit_infinity, 8) ? 3 : 8;
|
||||
}
|
||||
else if (traits::strncasecmp(str, traits::lit_nan, 3) == 0)
|
||||
{
|
||||
result = BAN::numeric_limits<T>::quiet_NaN();
|
||||
str = get_nan_end(str);
|
||||
}
|
||||
|
||||
if (result != 0)
|
||||
{
|
||||
if (endp)
|
||||
*endp = const_cast<CHAR*>(str);
|
||||
return negative ? -result : result;
|
||||
}
|
||||
}
|
||||
|
||||
// no conversion can be performed -- not ([digit] || .[digit])
|
||||
if (!(traits::isdigit(*str) || (str[0] == CHAR('.') && traits::isdigit(str[1]))))
|
||||
{
|
||||
if (endp)
|
||||
*endp = const_cast<CHAR*>(str);
|
||||
error = EINVAL;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int base = 10;
|
||||
int exponent = 0;
|
||||
int exponents_per_digit = 1;
|
||||
|
||||
// check whether we have base 16 value -- (0x[xdigit] || 0x.[xdigit])
|
||||
if (traits::strncasecmp(str, traits::lit_0x, 2) == 0 && (traits::isxdigit(str[2]) || (str[2] == CHAR('.') && traits::isxdigit(str[3]))))
|
||||
{
|
||||
base = 16;
|
||||
exponents_per_digit = 4;
|
||||
str += 2;
|
||||
}
|
||||
|
||||
// parse whole part
|
||||
T result = 0;
|
||||
T multiplier = 1;
|
||||
while (true)
|
||||
{
|
||||
int digit = get_base_digit(*str, base);
|
||||
if (digit == -1)
|
||||
break;
|
||||
str++;
|
||||
|
||||
if (result)
|
||||
exponent += exponents_per_digit;
|
||||
if (digit)
|
||||
result += multiplier * digit;
|
||||
if (result)
|
||||
multiplier /= base;
|
||||
}
|
||||
|
||||
if (*str == CHAR('.'))
|
||||
str++;
|
||||
|
||||
while (true)
|
||||
{
|
||||
const int digit = get_base_digit(*str, base);
|
||||
if (digit == -1)
|
||||
break;
|
||||
str++;
|
||||
|
||||
if (result == 0)
|
||||
exponent -= exponents_per_digit;
|
||||
if (digit)
|
||||
result += multiplier * digit;
|
||||
if (result)
|
||||
multiplier /= base;
|
||||
}
|
||||
|
||||
if (traits::tolower(*str) == (base == 10 ? CHAR('e') : CHAR('p')))
|
||||
{
|
||||
CHAR* maybe_end = nullptr;
|
||||
int exp_error = 0;
|
||||
|
||||
const int extra_exponent = strtoT<int>(str + 1, &maybe_end, 10, exp_error);
|
||||
if (exp_error != EINVAL)
|
||||
{
|
||||
if (exp_error == ERANGE || BAN::Math::will_addition_overflow(exponent, extra_exponent))
|
||||
exponent = negative ? BAN::numeric_limits<int>::min() : BAN::numeric_limits<int>::max();
|
||||
else
|
||||
exponent += extra_exponent;
|
||||
str = maybe_end;
|
||||
}
|
||||
}
|
||||
|
||||
if (endp)
|
||||
*endp = const_cast<CHAR*>(str);
|
||||
|
||||
// no over/underflow can happed with zero
|
||||
if (result == 0)
|
||||
return 0;
|
||||
|
||||
const int max_exponent = (base == 10) ? BAN::numeric_limits<T>::max_exponent10() : BAN::numeric_limits<T>::max_exponent2();
|
||||
if (exponent > max_exponent)
|
||||
{
|
||||
error = ERANGE;
|
||||
result = BAN::numeric_limits<T>::infinity();
|
||||
return negative ? -result : result;
|
||||
}
|
||||
|
||||
const int min_exponent = (base == 10) ? BAN::numeric_limits<T>::min_exponent10() : BAN::numeric_limits<T>::min_exponent2();
|
||||
if (exponent < min_exponent)
|
||||
{
|
||||
error = ERANGE;
|
||||
result = 0;
|
||||
return negative ? -result : result;
|
||||
}
|
||||
|
||||
if (exponent)
|
||||
result *= BAN::Math::pow<T>((base == 10) ? 10 : 2, exponent);
|
||||
return negative ? -result : result;
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -3,7 +3,6 @@
|
||||
#include <BAN/Math.h>
|
||||
#include <BAN/UTF8.h>
|
||||
|
||||
#include <ctype.h>
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
#include <locale.h>
|
||||
@@ -16,6 +15,8 @@
|
||||
#include <sys/syscall.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include <bits/strtoT.hpp>
|
||||
|
||||
#include <icxxabi.h>
|
||||
|
||||
void abort(void)
|
||||
@@ -50,264 +51,6 @@ int atexit(void (*func)(void))
|
||||
return __cxa_atexit([](void* func_ptr) { reinterpret_cast<void (*)(void)>(func_ptr)(); }, func_addr, nullptr);
|
||||
}
|
||||
|
||||
static constexpr int get_base_digit(char c, int base)
|
||||
{
|
||||
int digit = -1;
|
||||
if (isdigit(c))
|
||||
digit = c - '0';
|
||||
else if (isalpha(c))
|
||||
digit = 10 + tolower(c) - 'a';
|
||||
if (digit < base)
|
||||
return digit;
|
||||
return -1;
|
||||
}
|
||||
|
||||
template<BAN::integral T>
|
||||
static constexpr bool will_digit_append_overflow(T current, int digit, int base)
|
||||
{
|
||||
if (BAN::Math::will_multiplication_overflow<T>(current, base))
|
||||
return true;
|
||||
if (BAN::Math::will_addition_overflow<T>(current * base, current < 0 ? -digit : digit))
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
template<BAN::integral T>
|
||||
static T strtoT(const char* str, char** endp, int base, int& error)
|
||||
{
|
||||
// validate base
|
||||
if (base != 0 && (base < 2 || base > 36))
|
||||
{
|
||||
if (endp)
|
||||
*endp = const_cast<char*>(str);
|
||||
error = EINVAL;
|
||||
return 0;
|
||||
}
|
||||
|
||||
// skip whitespace
|
||||
while (isspace(*str))
|
||||
str++;
|
||||
|
||||
// get sign and skip it
|
||||
bool negative = (*str == '-');
|
||||
if (*str == '-' || *str == '+')
|
||||
str++;
|
||||
|
||||
// determine base from prefix
|
||||
if (base == 0)
|
||||
{
|
||||
if (strncasecmp(str, "0x", 2) == 0)
|
||||
base = 16;
|
||||
else if (*str == '0')
|
||||
base = 8;
|
||||
else if (isdigit(*str))
|
||||
base = 10;
|
||||
}
|
||||
|
||||
// check for invalid conversion
|
||||
if (get_base_digit(*str, base) == -1)
|
||||
{
|
||||
if (endp)
|
||||
*endp = const_cast<char*>(str);
|
||||
error = EINVAL;
|
||||
return 0;
|
||||
}
|
||||
|
||||
// remove "0x" prefix from hexadecimal
|
||||
if (base == 16 && strncasecmp(str, "0x", 2) == 0 && get_base_digit(str[2], base) != -1)
|
||||
str += 2;
|
||||
|
||||
bool overflow = false;
|
||||
|
||||
T result = 0;
|
||||
// calculate the value of the number in string
|
||||
while (!overflow)
|
||||
{
|
||||
int digit = get_base_digit(*str, base);
|
||||
if (digit == -1)
|
||||
break;
|
||||
str++;
|
||||
|
||||
overflow = will_digit_append_overflow(result, digit, base);
|
||||
if (!overflow)
|
||||
{
|
||||
if (negative && !BAN::is_unsigned_v<T>)
|
||||
digit = -digit;
|
||||
result = result * base + digit;
|
||||
}
|
||||
}
|
||||
|
||||
if (negative && BAN::is_unsigned_v<T>)
|
||||
result = -result;
|
||||
|
||||
// save endp if asked
|
||||
if (endp)
|
||||
{
|
||||
while (get_base_digit(*str, base) != -1)
|
||||
str++;
|
||||
*endp = const_cast<char*>(str);
|
||||
}
|
||||
|
||||
// return error on overflow
|
||||
if (overflow)
|
||||
{
|
||||
error = ERANGE;
|
||||
if constexpr(BAN::is_unsigned_v<T>)
|
||||
return BAN::numeric_limits<T>::max();
|
||||
return negative ? BAN::numeric_limits<T>::min() : BAN::numeric_limits<T>::max();
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
template<BAN::floating_point T>
|
||||
static T strtoT(const char* str, char** endp, int& error)
|
||||
{
|
||||
// find nan end including possible n-char-sequence
|
||||
auto get_nan_end = [](const char* str) -> const char*
|
||||
{
|
||||
ASSERT(strcasecmp(str, "nan") == 0);
|
||||
if (str[3] != '(')
|
||||
return str + 3;
|
||||
for (size_t i = 4; isalnum(str[i]) || str[i] == '_'; i++)
|
||||
if (str[i] == ')')
|
||||
return str + i + 1;
|
||||
return str + 3;
|
||||
};
|
||||
|
||||
// skip whitespace
|
||||
while (isspace(*str))
|
||||
str++;
|
||||
|
||||
// get sign and skip it
|
||||
bool negative = (*str == '-');
|
||||
if (*str == '-' || *str == '+')
|
||||
str++;
|
||||
|
||||
// check for infinity or nan
|
||||
{
|
||||
T result = 0;
|
||||
|
||||
if (strncasecmp(str, "inf", 3) == 0)
|
||||
{
|
||||
result = BAN::numeric_limits<T>::infinity();
|
||||
str += strncasecmp(str, "infinity", 8) ? 3 : 8;
|
||||
}
|
||||
else if (strncasecmp(str, "nan", 3) == 0)
|
||||
{
|
||||
result = BAN::numeric_limits<T>::quiet_NaN();
|
||||
str = get_nan_end(str);
|
||||
}
|
||||
|
||||
if (result != 0)
|
||||
{
|
||||
if (endp)
|
||||
*endp = const_cast<char*>(str);
|
||||
return negative ? -result : result;
|
||||
}
|
||||
}
|
||||
|
||||
// no conversion can be performed -- not ([digit] || .[digit])
|
||||
if (!(isdigit(*str) || (str[0] == '.' && isdigit(str[1]))))
|
||||
{
|
||||
if (endp)
|
||||
*endp = const_cast<char*>(str);
|
||||
error = EINVAL;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int base = 10;
|
||||
int exponent = 0;
|
||||
int exponents_per_digit = 1;
|
||||
|
||||
// check whether we have base 16 value -- (0x[xdigit] || 0x.[xdigit])
|
||||
if (strncasecmp(str, "0x", 2) == 0 && (isxdigit(str[2]) || (str[2] == '.' && isxdigit(str[3]))))
|
||||
{
|
||||
base = 16;
|
||||
exponents_per_digit = 4;
|
||||
str += 2;
|
||||
}
|
||||
|
||||
// parse whole part
|
||||
T result = 0;
|
||||
T multiplier = 1;
|
||||
while (true)
|
||||
{
|
||||
int digit = get_base_digit(*str, base);
|
||||
if (digit == -1)
|
||||
break;
|
||||
str++;
|
||||
|
||||
if (result)
|
||||
exponent += exponents_per_digit;
|
||||
if (digit)
|
||||
result += multiplier * digit;
|
||||
if (result)
|
||||
multiplier /= base;
|
||||
}
|
||||
|
||||
if (*str == '.')
|
||||
str++;
|
||||
|
||||
while (true)
|
||||
{
|
||||
int digit = get_base_digit(*str, base);
|
||||
if (digit == -1)
|
||||
break;
|
||||
str++;
|
||||
|
||||
if (result == 0)
|
||||
exponent -= exponents_per_digit;
|
||||
if (digit)
|
||||
result += multiplier * digit;
|
||||
if (result)
|
||||
multiplier /= base;
|
||||
}
|
||||
|
||||
if (tolower(*str) == (base == 10 ? 'e' : 'p'))
|
||||
{
|
||||
char* maybe_end = nullptr;
|
||||
int exp_error = 0;
|
||||
|
||||
int extra_exponent = strtoT<int>(str + 1, &maybe_end, 10, exp_error);
|
||||
if (exp_error != EINVAL)
|
||||
{
|
||||
if (exp_error == ERANGE || BAN::Math::will_addition_overflow(exponent, extra_exponent))
|
||||
exponent = negative ? BAN::numeric_limits<int>::min() : BAN::numeric_limits<int>::max();
|
||||
else
|
||||
exponent += extra_exponent;
|
||||
str = maybe_end;
|
||||
}
|
||||
}
|
||||
|
||||
if (endp)
|
||||
*endp = const_cast<char*>(str);
|
||||
|
||||
// no over/underflow can happed with zero
|
||||
if (result == 0)
|
||||
return 0;
|
||||
|
||||
const int max_exponent = (base == 10) ? BAN::numeric_limits<T>::max_exponent10() : BAN::numeric_limits<T>::max_exponent2();
|
||||
if (exponent > max_exponent)
|
||||
{
|
||||
error = ERANGE;
|
||||
result = BAN::numeric_limits<T>::infinity();
|
||||
return negative ? -result : result;
|
||||
}
|
||||
|
||||
const int min_exponent = (base == 10) ? BAN::numeric_limits<T>::min_exponent10() : BAN::numeric_limits<T>::min_exponent2();
|
||||
if (exponent < min_exponent)
|
||||
{
|
||||
error = ERANGE;
|
||||
result = 0;
|
||||
return negative ? -result : result;
|
||||
}
|
||||
|
||||
if (exponent)
|
||||
result *= BAN::Math::pow<T>((base == 10) ? 10 : 2, exponent);
|
||||
return negative ? -result : result;
|
||||
}
|
||||
|
||||
double atof(const char* str)
|
||||
{
|
||||
return strtod(str, nullptr);
|
||||
|
||||
Reference in New Issue
Block a user