path: root/util/string/cast.cpp

#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();
}