#include <util/system/defaults.h>

#if defined(_freebsd_) && !defined(__LONG_LONG_SUPPORTED)

#define __LONG_LONG_SUPPORTED

#endif

#include <cstdio>

#include <string>

#include <cmath>

#include <util/string/type.h>

#include <util/string/cast.h>

#include <util/string/escape.h>

#include <contrib/libs/double-conversion/double-conversion.h>

#include <util/generic/string.h>

#include <util/system/yassert.h>

#include <util/generic/yexception.h>

#include <util/generic/typetraits.h>

#include <util/generic/ylimits.h>

#include <util/generic/singleton.h>

#include <util/generic/utility.h>

using double_conversion::DoubleToStringConverter;

using double_conversion::StringBuilder;

using double_conversion::StringToDoubleConverter;

/*

* ------------------------------ formatters ------------------------------

*/

namespace {

constexpr char IntToChar[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};

static_assert(Y_ARRAY_SIZE(IntToChar) == 16, "expect Y_ARRAY_SIZE(IntToChar) == 16");

// clang-format off

constexpr int LetterToIntMap[] = {

20, 20, 20, 20, 20, 20, 20, 20, 20, 20,

20, 20, 20, 20, 20, 20, 20, 20, 20, 20,

20, 20, 20, 20, 20, 20, 20, 20, 20, 20,

20, 20, 20, 20, 20, 20, 20, 20, 20, 20,

20, 20, 20, 20, 20, 20, 20, 20, 0, 1,

2, 3, 4, 5, 6, 7, 8, 9, 20, 20,

20, 20, 20, 20, 20, 10, 11, 12, 13, 14,

15, 20, 20, 20, 20, 20, 20, 20, 20, 20,

20, 20, 20, 20, 20, 20, 20, 20, 20, 20,

20, 20, 20, 20, 20, 20, 20, 10, 11, 12,

13, 14, 15,

};

// clang-format on

template <class T>

std::enable_if_t<std::is_signed<T>::value, std::make_unsigned_t<T>> NegateNegativeSigned(T value) noexcept {

return std::make_unsigned_t<T>(-(value + 1)) + std::make_unsigned_t<T>(1);

}

template <class T>

std::enable_if_t<std::is_unsigned<T>::value, std::make_unsigned_t<T>> NegateNegativeSigned(T) noexcept {

Y_UNREACHABLE();

}

template <class T>

std::make_signed_t<T> NegatePositiveSigned(T value) noexcept {

return value > 0 ? (-std::make_signed_t<T>(value - 1) - 1) : 0;

}

template <class T, unsigned base, class TChar>

struct TBasicIntFormatter {

static_assert(1 < base && base < 17, "expect 1 < base && base < 17");

static_assert(std::is_unsigned<T>::value, "TBasicIntFormatter can only handle unsigned integers.");

static inline size_t Format(T value, TChar* buf, size_t len) {

Y_ENSURE(len, TStringBuf("zero length"));

TChar* tmp = buf;

do {

// divide only once, do not use mod

const T nextVal = static_cast<T>(value / base);

*tmp++ = IntToChar[base == 2 || base == 4 || base == 8 || base == 16 ? value & (base - 1) : value - base * nextVal];

value = nextVal;

} while (value && --len);

Y_ENSURE(!value, TStringBuf("not enough room in buffer"));

const size_t result = tmp - buf;

--tmp;

while (buf < tmp) {

TChar c = *buf;

*buf = *tmp;

*tmp = c;

++buf;

--tmp;

}

return result;

}

};

template <class T, unsigned base, class TChar>

struct TIntFormatter {

static_assert(1 < base && base < 17, "expect 1 < base && base < 17");

static_assert(std::is_integral<T>::value, "T must be an integral type.");

static inline size_t Format(T value, TChar* buf, size_t len) {

using TUFmt = TBasicIntFormatter<std::make_unsigned_t<T>, base, TChar>;

if (std::is_signed<T>::value && value < 0) {

Y_ENSURE(len >= 2, TStringBuf("not enough room in buffer"));

*buf = '-';

return 1 + TUFmt::Format(NegateNegativeSigned(value), buf + 1, len - 1);

}

return TUFmt::Format(value, buf, len);

}

};

template <class T>

struct TFltModifiers;

template <class T, int base, class TChar>

Y_NO_INLINE size_t FormatInt(T value, TChar* buf, size_t len) {

return TIntFormatter<T, base, TChar>::Format(value, buf, len);

}

template <class T>

inline size_t FormatFlt(T t, char* buf, size_t len) {

const int ret = snprintf(buf, len, TFltModifiers<T>::ModifierWrite, t);

Y_ENSURE(ret >= 0 && (size_t)ret <= len, TStringBuf("cannot format float"));

return (size_t)ret;

}

enum EParseStatus {

PS_OK = 0,

PS_EMPTY_STRING,

PS_PLUS_STRING,

PS_MINUS_STRING,

PS_BAD_SYMBOL,

PS_OVERFLOW,

};

constexpr ui8 SAFE_LENS[4][17] = {

{0, 0, 7, 5, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1},

{0, 0, 15, 10, 7, 6, 6, 5, 5, 5, 4, 4, 4, 4, 4, 4, 3},

{0, 0, 31, 20, 15, 13, 12, 11, 10, 10, 9, 9, 8, 8, 8, 8, 7},

{0, 0, 63, 40, 31, 27, 24, 22, 21, 20, 19, 18, 17, 17, 16, 16, 15},

};

inline constexpr ui8 ConstLog2(ui8 x) noexcept {

return x == 1 ? 0 : 1 + ConstLog2(x / 2);

}

template <unsigned BASE, class TChar, class T>

inline std::enable_if_t<(BASE > 10), bool> CharToDigit(TChar c, T* digit) noexcept {

unsigned uc = c;

if (uc >= Y_ARRAY_SIZE(LetterToIntMap)) {

return false;

}

*digit = LetterToIntMap[uc];

return *digit < BASE;

}

template <unsigned BASE, class TChar, class T>

inline std::enable_if_t<(BASE <= 10), bool> CharToDigit(TChar c, T* digit) noexcept {

return (c >= '0') && ((*digit = (c - '0')) < BASE);

}

template <class T, unsigned base, class TChar>

struct TBasicIntParser {

static_assert(1 < base && base < 17, "Expect 1 < base && base < 17.");

static_assert(std::is_unsigned<T>::value, "TBasicIntParser can only handle unsigned integers.");

enum : unsigned {

BASE_POW_2 = base * base,

};

static inline EParseStatus Parse(const TChar** ppos, const TChar* end, T max, T* target) noexcept {

Y_ASSERT(*ppos != end); /* This check should be somewhere up the stack. */

const size_t maxSafeLen = SAFE_LENS[ConstLog2(sizeof(T))][base];

// can parse without overflow

if (size_t(end - *ppos) <= maxSafeLen) {

T result;

if (ParseFast(*ppos, end, &result) && result <= max) {

*target = result;

return PS_OK;

}

}

return ParseSlow(ppos, end, max, target);

}

static inline bool ParseFast(const TChar* pos, const TChar* end, T* target) noexcept {

T result = T();

T d1;

T d2;

// we have end > pos

auto beforeEnd = end - 1;

while (pos < beforeEnd && CharToDigit<base>(*pos, &d1) && CharToDigit<base>(*(pos + 1), &d2)) {

result = result * BASE_POW_2 + d1 * base + d2;

pos += 2;

}

while (pos != end && CharToDigit<base>(*pos, &d1)) {

result = result * base + d1;

++pos;

}

*target = result;

return pos == end;

}

static inline EParseStatus ParseSlow(const TChar** ppos, const TChar* end, T max, T* target) noexcept {

T result = T();

T preMulMax = max / base;

const TChar* pos = *ppos;

while (pos != end) {

T digit;

if (!CharToDigit<base>(*pos, &digit)) {

*ppos = pos;

return PS_BAD_SYMBOL;

}

if (result > preMulMax) {

return PS_OVERFLOW;

}

result *= base;

if (result > max - digit) {

return PS_OVERFLOW;

}

result += digit;

pos++;

}

*target = result;

return PS_OK;

}

};

template <class T>

struct TBounds {

T PositiveMax;

T NegativeMax;

};

template <class T, unsigned base, class TChar>

struct TIntParser {

static_assert(1 < base && base < 17, "Expect 1 < base && base < 17.");

static_assert(std::is_integral<T>::value, "T must be an integral type.");

enum {

IsSigned = std::is_signed<T>::value

};

using TUnsigned = std::make_unsigned_t<T>;

static inline EParseStatus Parse(const TChar** ppos, const TChar* end, const TBounds<TUnsigned>& bounds, T* target) {

const TChar* pos = *ppos;

if (pos == end) {

return PS_EMPTY_STRING;

}

bool negative = false;

TUnsigned max;

if (*pos == '+') {

pos++;

max = bounds.PositiveMax;

if (pos == end) {

return PS_PLUS_STRING;

}

} else if (IsSigned && *pos == '-') {

pos++;

max = bounds.NegativeMax;

negative = true;

if (pos == end) {

return PS_MINUS_STRING;

}

} else {

max = bounds.PositiveMax;

}

TUnsigned result;

EParseStatus error = TBasicIntParser<TUnsigned, base, TChar>::Parse(&pos, end, max, &result);

if (error != PS_OK) {

*ppos = pos;

return error;

}

if (IsSigned) {

*target = negative ? NegatePositiveSigned(result) : static_cast<T>(result);

} else {

*target = result;

}

return PS_OK;

}

};

template <class TChar>

[[noreturn]] static Y_NO_INLINE void ThrowParseError(EParseStatus status, const TChar* data, size_t len, const TChar* pos) {

Y_ASSERT(status != PS_OK);

typedef TBasicString<TChar> TStringType;

switch (status) {

case PS_EMPTY_STRING:

ythrow TFromStringException() << TStringBuf("Cannot parse empty string as number. ");

case PS_PLUS_STRING:

ythrow TFromStringException() << TStringBuf("Cannot parse string \"+\" as number. ");

case PS_MINUS_STRING:

ythrow TFromStringException() << TStringBuf("Cannot parse string \"-\" as number. ");

case PS_BAD_SYMBOL:

ythrow TFromStringException() << TStringBuf("Unexpected symbol \"") << EscapeC(*pos) << TStringBuf("\" at pos ") << (pos - data) << TStringBuf(" in string ") << TStringType(data, len).Quote() << TStringBuf(". ");

case PS_OVERFLOW:

ythrow TFromStringException() << TStringBuf("Integer overflow in string ") << TStringType(data, len).Quote() << TStringBuf(". ");

default:

ythrow yexception() << TStringBuf("Unknown error code in string converter. ");

}

}

template <typename T, typename TUnsigned, int base, typename TChar>

Y_NO_INLINE T ParseInt(const TChar* data, size_t len, const TBounds<TUnsigned>& bounds) {

T result;

const TChar* pos = data;

EParseStatus status = TIntParser<T, base, TChar>::Parse(&pos, pos + len, bounds, &result);

if (status == PS_OK) {

return result;

} else {

ThrowParseError(status, data, len, pos);

}

}

template <typename T, typename TUnsigned, int base, typename TChar>

Y_NO_INLINE bool TryParseInt(const TChar* data, size_t len, const TBounds<TUnsigned>& bounds, T* result) {

return TIntParser<T, base, TChar>::Parse(&data, data + len, bounds, result) == PS_OK;

}

template <class T>

inline T ParseFlt(const char* data, size_t len) {

/*

* TODO

*/

if (len > 256) {

len = 256;

}

char* c = (char*)alloca(len + 1);

memcpy(c, data, len);

c[len] = 0;

T ret;

char ec;

// try to read a value and an extra character in order to catch cases when

// the string start with a valid float but is followed by unexpected characters

if (sscanf(c, TFltModifiers<T>::ModifierReadAndChar, &ret, &ec) == 1) {

return ret;

}

ythrow TFromStringException() << TStringBuf("cannot parse float(") << TStringBuf(data, len) << TStringBuf(")");

}

#define DEF_FLT_MOD(type, modifierWrite, modifierRead) \

template <> \

struct TFltModifiers<type> { \

static const char* const ModifierWrite; \

static const char* const ModifierReadAndChar; \

}; \

\

const char* const TFltModifiers<type>::ModifierWrite = modifierWrite; \

const char* const TFltModifiers<type>::ModifierReadAndChar = modifierRead "%c";

DEF_FLT_MOD(long double, "%.10Lg", "%Lg")

#undef DEF_FLT_MOD

/* The following constants are initialized in terms of <climits> constants to make

* sure they go into binary as actual values and there is no associated

* initialization code.

* */

constexpr TBounds<ui64> bSBounds = {static_cast<ui64>(SCHAR_MAX), static_cast<ui64>(UCHAR_MAX - SCHAR_MAX)};

constexpr TBounds<ui64> bUBounds = {static_cast<ui64>(UCHAR_MAX), 0};

constexpr TBounds<ui64> sSBounds = {static_cast<ui64>(SHRT_MAX), static_cast<ui64>(USHRT_MAX - SHRT_MAX)};

constexpr TBounds<ui64> sUBounds = {static_cast<ui64>(USHRT_MAX), 0};

constexpr TBounds<ui64> iSBounds = {static_cast<ui64>(INT_MAX), static_cast<ui64>(UINT_MAX - INT_MAX)};

constexpr TBounds<ui64> iUBounds = {static_cast<ui64>(UINT_MAX), 0};

constexpr TBounds<ui64> lSBounds = {static_cast<ui64>(LONG_MAX), static_cast<ui64>(ULONG_MAX - LONG_MAX)};

constexpr TBounds<ui64> lUBounds = {static_cast<ui64>(ULONG_MAX), 0};

constexpr TBounds<ui64> llSBounds = {static_cast<ui64>(LLONG_MAX), static_cast<ui64>(ULLONG_MAX - LLONG_MAX)};

constexpr TBounds<ui64> llUBounds = {static_cast<ui64>(ULLONG_MAX), 0};

}

#define DEF_INT_SPEC_II(TYPE, ITYPE, BASE) \

template <> \

size_t IntToString<BASE, TYPE>(TYPE value, char* buf, size_t len) { \

return FormatInt<ITYPE, BASE, char>(value, buf, len); \

}

#define DEF_INT_SPEC_I(TYPE, ITYPE) \

template <> \

size_t ToStringImpl<TYPE>(TYPE value, char* buf, size_t len) { \

return FormatInt<ITYPE, 10, char>(value, buf, len); \

} \

DEF_INT_SPEC_II(TYPE, ITYPE, 2) \

DEF_INT_SPEC_II(TYPE, ITYPE, 8) \

DEF_INT_SPEC_II(TYPE, ITYPE, 10) \

DEF_INT_SPEC_II(TYPE, ITYPE, 16)

#define DEF_INT_SPEC(TYPE) \

DEF_INT_SPEC_I(signed TYPE, i64) \

DEF_INT_SPEC_I(unsigned TYPE, ui64)

DEF_INT_SPEC(char)

DEF_INT_SPEC(short)

DEF_INT_SPEC(int)

DEF_INT_SPEC(long)

DEF_INT_SPEC(long long)

#ifdef __cpp_char8_t

template <>

size_t ToStringImpl<char8_t>(char8_t value, char* buf, size_t len) {

return FormatInt<ui64, 10, char>(value, buf, len);

}

#endif

using TCharIType = std::conditional_t<std::is_signed<char>::value, i64, ui64>;

using TWCharIType = std::conditional_t<std::is_signed<wchar_t>::value, i64, ui64>;

DEF_INT_SPEC_I(char, TCharIType)

DEF_INT_SPEC_I(wchar_t, TWCharIType)

DEF_INT_SPEC_I(wchar16, ui64) // wchar16 is always unsigned

DEF_INT_SPEC_I(wchar32, ui64) // wchar32 is always unsigned

#undef DEF_INT_SPEC

#undef DEF_INT_SPEC_I

#undef DEF_INT_SPEC_II

#define DEF_FLT_SPEC(type) \

template <> \

size_t ToStringImpl<type>(type t, char* buf, size_t len) { \

return FormatFlt<type>(t, buf, len); \

}

DEF_FLT_SPEC(long double)

#undef DEF_FLT_SPEC

template <>

size_t ToStringImpl<bool>(bool t, char* buf, size_t len) {

Y_ENSURE(len, TStringBuf("zero length"));

*buf = t ? '1' : '0';

return 1;

}

/*

* ------------------------------ parsers ------------------------------

*/

template <>

bool TryFromStringImpl<bool>(const char* data, size_t len, bool& result) {

if (len == 1) {

if (data[0] == '0') {

result = false;

return true;

} else if (data[0] == '1') {

result = true;

return true;

}

}

TStringBuf buf(data, len);

if (IsTrue(buf)) {

result = true;

return true;

} else if (IsFalse(buf)) {

result = false;

return true;

}

return false;

}

template <>

bool FromStringImpl<bool>(const char* data, size_t len) {

bool result;

if (!TryFromStringImpl<bool>(data, len, result)) {

ythrow TFromStringException() << TStringBuf("Cannot parse bool(") << TStringBuf(data, len) << TStringBuf("). ");

}

return result;

}

template <>

TString FromStringImpl<TString>(const char* data, size_t len) {

return TString(data, len);

}

template <>

TStringBuf FromStringImpl<TStringBuf>(const char* data, size_t len) {

return TStringBuf(data, len);

}

template <>

std::string FromStringImpl<std::string>(const char* data, size_t len) {

return std::string(data, len);

}

template <>

TUtf16String FromStringImpl<TUtf16String>(const wchar16* data, size_t len) {

return TUtf16String(data, len);

}

template <>

TWtringBuf FromStringImpl<TWtringBuf>(const wchar16* data, size_t len) {

return TWtringBuf(data, len);

}

// Try-versions

template <>

bool TryFromStringImpl<TStringBuf>(const char* data, size_t len, TStringBuf& result) {

result = {data, len};

return true;

}

template <>

bool TryFromStringImpl<TString>(const char* data, size_t len, TString& result) {

result = TString(data, len);

return true;

}

template <>

bool TryFromStringImpl<std::string>(const char* data, size_t len, std::string& result) {

result.assign(data, len);

return true;

}

template <>

bool TryFromStringImpl<TWtringBuf>(const wchar16* data, size_t len, TWtringBuf& result) {

result = {data, len};

return true;

}

template <>

bool TryFromStringImpl<TUtf16String>(const wchar16* data, size_t len, TUtf16String& result) {

result = TUtf16String(data, len);

return true;

}

#define DEF_INT_SPEC_III(CHAR, TYPE, ITYPE, BOUNDS, BASE) \

template <> \

TYPE IntFromString<TYPE, BASE>(const CHAR* data, size_t len) { \

return ParseInt<ITYPE, ui64, BASE>(data, len, BOUNDS); \

} \

template <> \

bool TryIntFromString<BASE>(const CHAR* data, size_t len, TYPE& result) { \

ITYPE tmp; \

bool status = TryParseInt<ITYPE, ui64, BASE>(data, len, BOUNDS, &tmp); \

if (status) { \

result = tmp; \

} \

return status; \

}

#define DEF_INT_SPEC_II(CHAR, TYPE, ITYPE, BOUNDS) \

template <> \

TYPE FromStringImpl<TYPE>(const CHAR* data, size_t len) { \

return ParseInt<ITYPE, ui64, 10>(data, len, BOUNDS); \

} \

template <> \

bool TryFromStringImpl<TYPE>(const CHAR* data, size_t len, TYPE& result) { \

ITYPE tmp; \

bool status = TryParseInt<ITYPE, ui64, 10>(data, len, BOUNDS, &tmp); \

if (status) { \

result = tmp; \

} \

return status; \

} \

DEF_INT_SPEC_III(CHAR, TYPE, ITYPE, BOUNDS, 2) \

DEF_INT_SPEC_III(CHAR, TYPE, ITYPE, BOUNDS, 8) \

DEF_INT_SPEC_III(CHAR, TYPE, ITYPE, BOUNDS, 10) \

DEF_INT_SPEC_III(CHAR, TYPE, ITYPE, BOUNDS, 16)

#define DEF_INT_SPEC_I(TYPE, ITYPE, BOUNDS) \

DEF_INT_SPEC_II(char, TYPE, ITYPE, BOUNDS) \

DEF_INT_SPEC_II(wchar16, TYPE, ITYPE, BOUNDS)

#define DEF_INT_SPEC(TYPE, ID) \

DEF_INT_SPEC_I(signed TYPE, i64, ID##SBounds) \

DEF_INT_SPEC_I(unsigned TYPE, ui64, ID##UBounds)

#define DEF_INT_SPEC_FIXED_WIDTH(TYPE, ID) \

DEF_INT_SPEC_I(TYPE, i64, ID##SBounds) \

DEF_INT_SPEC_I(u##TYPE, ui64, ID##UBounds)

DEF_INT_SPEC_FIXED_WIDTH(i8, b)

DEF_INT_SPEC(short, s)

DEF_INT_SPEC(int, i)

DEF_INT_SPEC(long, l)

DEF_INT_SPEC(long long, ll)

#undef DEF_INT_SPEC_FIXED_WIDTH

#undef DEF_INT_SPEC

#undef DEF_INT_SPEC_I

#undef DEF_INT_SPEC_II

#undef DEF_INT_SPEC_III

#define DEF_FLT_SPEC(type) \

template <> \

type FromStringImpl<type>(const char* data, size_t len) { \

return ParseFlt<type>(data, len); \

}

DEF_FLT_SPEC(long double)

#undef DEF_FLT_SPEC

// Using StrToD for float and double because it is faster than sscanf.

// Exception-free, specialized for float types

template <>

bool TryFromStringImpl<double>(const char* data, size_t len, double& result) {

if (!len) {

return false;

}

char* se = nullptr;

double d = StrToD(data, data + len, &se);

if (se != data + len) {

return false;

}

result = d;

return true;

}

template <>

bool TryFromStringImpl<float>(const char* data, size_t len, float& result) {

double d;

if (TryFromStringImpl<double>(data, len, d)) {

result = static_cast<float>(d);

return true;

}

return false;

}

template <>

bool TryFromStringImpl<long double>(const char* data, size_t len, long double& result) {

double d;

if (TryFromStringImpl<double>(data, len, d)) {

result = static_cast<long double>(d);

return true;

}

return false;

}

// Exception-throwing, specialized for float types

template <>

double FromStringImpl<double>(const char* data, size_t len) {

double d = 0.0;

if (!TryFromStringImpl(data, len, d)) {

ythrow TFromStringException() << TStringBuf("cannot parse float(") << TStringBuf(data, len) << TStringBuf(")");

}

return d;

}

template <>

float FromStringImpl<float>(const char* data, size_t len) {

return static_cast<float>(FromStringImpl<double>(data, len));

}

double StrToD(const char* b, const char* e, char** se) {

struct TCvt: public StringToDoubleConverter {

inline TCvt()

: StringToDoubleConverter(ALLOW_TRAILING_JUNK | ALLOW_HEX | ALLOW_LEADING_SPACES, 0.0, NAN, nullptr, nullptr)

{

}

};

int out = 0;

const auto res = SingletonWithPriority<TCvt, 0>()->StringToDouble(b, e - b, &out);

if (se) {

*se = (char*)(b + out);

}

return res;

}

double StrToD(const char* b, char** se) {

return StrToD(b, b + strlen(b), se);

}

namespace {

static inline DoubleToStringConverter& ToStringConverterNoPad() noexcept {

struct TCvt: public DoubleToStringConverter {

inline TCvt() noexcept

: DoubleToStringConverter(EMIT_POSITIVE_EXPONENT_SIGN, "inf", "nan", 'e', -10, 21, 4, 0)

{

}

};

return *SingletonWithPriority<TCvt, 0>();

}

struct TBuilder {

alignas(StringBuilder) char Store[sizeof(StringBuilder)];

StringBuilder* SB;

inline TBuilder(char* buf, size_t len) noexcept

: SB(new (Store) StringBuilder(buf, len))

{

}

};

static inline size_t FixZeros(char* buf, size_t len) noexcept {

auto end = buf + len;

auto point = (char*)memchr(buf, '.', len);

if (!point) {

return len;

}

auto exp = (char*)memchr(point, 'e', end - point);

if (!exp) {

exp = end;

}

auto c = exp;

c -= 1;

while (point < c && *c == '0') {

--c;

}

if (*c == '.') {

--c;

}

memmove(c + 1, exp, end - exp);

return c - buf + 1 + end - exp;

}

static inline size_t FixEnd(char* buf, size_t len) noexcept {

if (len > 2) {

auto sign = buf[len - 2];

if (sign == '-' || sign == '+') {

buf[len] = buf[len - 1];

buf[len - 1] = '0';

++len;

}

}

buf[len] = 0;

return len;

}

static inline size_t DoDtoa(double d, char* buf, size_t len, int prec) noexcept {

TBuilder sb(buf, len);

Y_VERIFY(ToStringConverterNoPad().ToPrecision(d, prec, sb.SB), "conversion failed");

return FixEnd(buf, FixZeros(buf, sb.SB->position()));

}

}

template <>

size_t ToStringImpl<double>(double d, char* buf, size_t len) {

return DoDtoa(d, buf, len, 10);

}

template <>

size_t ToStringImpl<float>(float f, char* buf, size_t len) {

return DoDtoa(f, buf, len, 6);

}

size_t FloatToString(float t, char* buf, size_t len, EFloatToStringMode mode, int ndigits) {

if (mode == PREC_AUTO) {

TBuilder sb(buf, len);

Y_VERIFY(ToStringConverterNoPad().ToShortestSingle(t, sb.SB), "conversion failed");

return FixEnd(buf, sb.SB->position());

}

return FloatToString((double)t, buf, len, mode, ndigits);

}

size_t FloatToString(double t, char* buf, size_t len, EFloatToStringMode mode, int ndigits) {

if (mode == PREC_NDIGITS) {

auto minDigits = DoubleToStringConverter::kMinPrecisionDigits;

auto maxDigits = DoubleToStringConverter::kMaxPrecisionDigits;

return DoDtoa(t, buf, len, ClampVal(ndigits, minDigits, maxDigits));

}

TBuilder sb(buf, len);

if (mode == PREC_AUTO) {

Y_VERIFY(ToStringConverterNoPad().ToShortest(t, sb.SB), "conversion failed");

return FixEnd(buf, sb.SB->position());

}

if (!ToStringConverterNoPad().ToFixed(t, ndigits, sb.SB)) {

return FloatToString(t, buf, len, PREC_AUTO);

}

if (mode == PREC_POINT_DIGITS_STRIP_ZEROES) {

return FixZeros(buf, sb.SB->position());

}

return sb.SB->position();

}