strformat.h

Go to the documentation of this file.

// String Formatter
// Copyright (C) 2026 S.Fuchita (soramimi_jp)
// This software is distributed under the MIT license.
 
#ifndef STRFORMAT_H
#define STRFORMAT_H
 
// #define STRFORMAT_NO_LOCALE
// #define STRFORMAT_NO_FP
 
#include <algorithm>
#include <charconv>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <string>
#include <vector>
#include <string_view>
#include <cstddef>
#include <limits>
#include <type_traits>
 
#ifndef STRFORMAT_NO_LOCALE
#include <locale.h>
#endif
 
#ifdef _MSC_VER
#include <io.h>
#else
#include <unistd.h>
#endif
 
namespace strformat_ns {
 
class StdAlloc {
public:
    void *alloc(size_t size)
    {
        return ::malloc(size);
    }
    void free(void *ptr)
    {
        ::free(ptr);
    }
};
 
class QuickAlloc {
private:
    constexpr static size_t default_buffer_size = 256;
    constexpr static size_t alignment = alignof(std::max_align_t);
    // Bookkeeping placed at the top of every block; the block's usable
    // memory follows immediately after.
    struct Header {
        Header *next = nullptr; // singly linked list of blocks
        size_t capacity = 0;    // usable bytes in this block
        size_t allocated = 0;   // bytes handed out so far
    };
    // First block of the list. Lives inside the allocator object itself
    // (typically on the stack), so small formatting jobs never touch the heap.
    alignas(std::max_align_t) char default_buffer[default_buffer_size];
 
    static_assert(sizeof(default_buffer) > sizeof(Header), "default_buffer too small");
    
    void *x_alloc(size_t size)
    {
        return ::malloc(size);
    }
    void x_free(void *p)
    {
        ::free(p);
    }
    static size_t align_up(size_t n)
    {
        return (n + alignment - 1) & ~(alignment - 1);
    }
public:
    QuickAlloc(const QuickAlloc &) = delete;
    QuickAlloc &operator=(const QuickAlloc &) = delete;
    QuickAlloc(QuickAlloc &&) = delete;
    QuickAlloc &operator=(QuickAlloc &&) = delete;
    QuickAlloc()
    {
        Header *h = (Header *)default_buffer;
        *h = {};
        h->capacity = sizeof(default_buffer) - sizeof(Header);
    }
    ~QuickAlloc()
    {
        // Release every heap block; the first block is the in-object
        // buffer and must not be freed.
        Header *h = (Header *)default_buffer;
        Header *next = h->next;
        while (next) {
            void *p = next;
            next = next->next;
            x_free(p);
        }
    }
    void *alloc(size_t size)
    {
        if (size == 0) size = 1;
        size = align_up(size);
        Header *h = (Header *)default_buffer;
        auto Alloc = [&]()-> void * {
            if (h->allocated + size <= h->capacity) {
                void *p = (char *)h + sizeof(Header) + h->allocated;
                h->allocated += size;
                return p;
            }
            return nullptr;
        };
        // 1st probe: the in-object buffer
        void *p = Alloc();
        if (p) return p;
        // 2nd probe: the newest heap block, if any
        if (h->next) {
            h = h->next;
            p = Alloc();
            if (p) return p;
        }
        // Both probes failed: allocate a new block. `h` is where the new
        // block gets linked in (the new block follows `h`).
        h = (Header *)default_buffer;
        size_t bufsize = sizeof(Header) + size;
        if (bufsize < default_buffer_size) {
            // standard block: insert as the new 2nd block, displacing the
            // old one out of the search window
            bufsize = default_buffer_size;
        } else if (h->next) {
            // oversized block, exactly filled by this request: insert as
            // the 3rd block so it never occupies the search window
            h = h->next;
        }
        Header *next = (Header *)x_alloc(bufsize);
        *next = {};
        next->capacity = bufsize - sizeof(Header);
        next->next = h->next;
        h->next = next;
        h = next;
        return Alloc();
    }
    void free(void *p)
    {
        (void)p;
        // nop: free all at destructor
    }
};
 
class misc {
private:
    static double pow10_int(int exp)
    {
        // Pre‑computed powers for |exp| ≤ 16
        static const double tbl[] = {
            1e+00, 1e+01, 1e+02, 1e+03, 1e+04, 1e+05, 1e+06,
            1e+07, 1e+08, 1e+09, 1e+10, 1e+11, 1e+12, 1e+13,
            1e+14, 1e+15, 1e+16
        };
        if (exp >= 0 && exp < static_cast<int>(sizeof tbl / sizeof *tbl))
            return tbl[exp];
        if (exp <= 0 && exp > -static_cast<int>(sizeof tbl / sizeof *tbl))
            return 1.0 / tbl[-exp];
        // Rare case: delegate to libm
        return std::pow(10.0, exp);
    }
public:
    static double my_strtod(const char *nptr, char **endptr)
    {
        const char *s = nptr;
        bool sign = false;
        bool saw_digit = false;
        int frac_digits = 0;
        long exp_val = 0;
        bool exp_sign = false;
        double value = 0.0;
 
        // Skip leading white‑space
        while (std::isspace((unsigned char)*s)) ++s;
 
        // Parse optional sign
        if (*s == '+' || *s == '-') {
            if (*s == '-') sign = true;
            s++;
        }
 
        // Integer part
        while (std::isdigit((unsigned char)*s)) {
            saw_digit = true;
            value = value * 10.0 + (*s - '0');
            s++;
        }
 
        // Fractional part
        if (*s == '.') {
            s++;
            while (std::isdigit((unsigned char)*s)) {
                saw_digit = true;
                value = value * 10.0 + (*s - '0');
                s++;
                frac_digits++;
            }
        }
 
        // No digits at all -> conversion failure
        if (!saw_digit) {
            if (endptr) *endptr = const_cast<char *>(nptr);
            return 0.0;
        }
 
        // Exponent part
        if (*s == 'e' || *s == 'E') {
            s++;
            const char *exp_start = s;
            if (*s == '+' || *s == '-') {
                if (*s == '-') exp_sign = true;
                s++;
            }
            if (std::isdigit((unsigned char)*s)) {
                while (std::isdigit((unsigned char)*s)) {
                    exp_val = exp_val * 10 + (*s - '0');
                    s++;
                }
                if (exp_sign) {
                    exp_val = -exp_val;
                }
            } else {
                // Roll back if 'e' is not followed by a valid exponent
                s = exp_start - 1;
            }
        }
 
        // Scale by 10^(exponent − #fractional‑digits)
        int total_exp = exp_val - frac_digits;
        if (total_exp != 0) {
            value *= pow10_int(total_exp);
        }
 
        // Apply sign
        if (sign) {
            value = -value;
        }
 
        // Set errno on overflow/underflow
        if (!std::isfinite(value)) {
            // errno = ERANGE;
            value = sign ? -HUGE_VAL : HUGE_VAL;
        } else if (value == 0.0 && saw_digit && total_exp != 0) {
            // errno = ERANGE;  // underflow
        }
 
        // Report where parsing stopped
        if (endptr) *endptr = const_cast<char *>(s);
        return value;
    }
};
 
struct NumberParser {
    char const *p;
    bool sign = false;
    int radix = 10;
    NumberParser(char const *ptr)
        : p(ptr)
    {
        while (isspace((unsigned char)*p)) {
            p++;
        }
        if (*p == '+') {
            p++;
        } else if (*p == '-') {
            sign = true;
            p++;
        }
        if (p[0] == '0') {
            if (p[1] == 'x' || p[1] == 'X') {
                p += 2;
                radix = 16;
            } else {
                int i = 1;
                while (p[i]) {
                    int c = (unsigned char)p[i];
                    if (c < '0' || c > '7') break;
                    radix = 8;
                    i++;
                }
            }
        }
    }
};
 
template <typename T> static inline T parse_number(char const *ptr, std::function<T(char const *p, int radix)> conv)
{
    NumberParser t(ptr);
    T v = conv(t.p, t.radix);
    if (t.sign) {
        if constexpr (std::is_integral_v<T>) {
            // negate in the unsigned domain to avoid signed overflow on INT_MIN
            v = static_cast<T>(0 - static_cast<std::make_unsigned_t<T>>(v));
        } else {
            v = -v;
        }
        return v;
    } else {
 
        return v;
    }
}
 
struct Option_ {
#ifdef STRFORMAT_NO_LOCALE
    void *lc = nullptr;
#else
    struct lconv *lc = nullptr;
#endif
};
 
template <typename T> static inline T num(char const *value, Option_ const &opt);
template <> inline char num<char>(char const *value, Option_ const &opt)
{
    (void)opt;
    return parse_number<char>(value, [](char const *p, int radix){
        return (char)strtol(p, nullptr, radix);
    });
}
template <> inline int32_t num<int32_t>(char const *value, Option_ const &opt)
{
    (void)opt;
    return parse_number<uint32_t>(value, [](char const *p, int radix){
        return strtoul(p, nullptr, radix);
    });
}
template <> inline uint32_t num<uint32_t>(char const *value, Option_ const &opt)
{
    (void)opt;
    return parse_number<uint32_t>(value, [](char const *p, int radix){
        return strtoul(p, nullptr, radix);
    });
}
template <> inline int64_t num<int64_t>(char const *value, Option_ const &opt)
{
    (void)opt;
    return parse_number<uint64_t>(value, [](char const *p, int radix){
        return strtoull(p, nullptr, radix);
    });
}
template <> inline uint64_t num<uint64_t>(char const *value, Option_ const &opt)
{
    (void)opt;
    return parse_number<uint64_t>(value, [](char const *p, int radix){
        return strtoull(p, nullptr, radix);
    });
}
#ifndef STRFORMAT_NO_FP
template <> inline double num<double>(char const *value, Option_ const &opt)
{
    return parse_number<double>(value, [&opt](char const *p, int radix){
        if (radix == 10) {
            if (opt.lc) {
                // locale-dependent
                return strtod(p, nullptr);
            } else {
                // locale-independent
                return misc::my_strtod(p, nullptr);
            }
        } else {
            return (double)strtoll(p, nullptr, radix);
        }
    });
}
#endif
template <typename T> static inline T num(std::string const &value, Option_ const &opt)
{
    return num<T>(value.data(), opt);
}
 
class string_formatter {
public:
    enum Flags {
        Locale = 0x0001,
    };
    static constexpr int max_precision = 1000;
private:
#if 0
    StdAlloc allocator;
#else
    QuickAlloc allocator;
#endif
    void *x_alloc(size_t size)
    {
        return allocator.alloc(size);
    }
    void x_free(void *ptr)
    {
        allocator.free(ptr);
    }
private:
    struct Part {
        Part *next;
        int size;
        char data[1];
    };
    struct PartList {
        Part *head = nullptr;
        Part *last = nullptr;
    };
    Part *alloc_part(const char *data, int size)
    {
        Part *p = (Part *)x_alloc(sizeof(Part) + size);
        p->next = nullptr;
        p->size = size;
        memcpy(p->data, data, size);
        p->data[size] = 0;
        return p;
    }
    Part *alloc_part(const char *begin, const char *end)
    {
        return alloc_part(begin, int(end - begin));
    }
    Part *alloc_part(const char *str)
    {
        return alloc_part(str, (int)strlen(str));
    }
    Part *alloc_part(const std::string_view &str)
    {
        return alloc_part(str.data(), (int)str.size());
    }
    void free_part(Part **p)
    {
        if (p && *p) {
            x_free(*p);
            *p = nullptr;
        }
    }
    static void add_part(PartList *list, Part *part)
    {
        if (part) {
            if (!list->head) {
                list->head = part;
            }
            if (list->last) {
                list->last->next = part;
            }
            list->last = part;
        }
    }
    void free_list(PartList *list)
    {
        Part *p = list->head;
        while (p) {
            Part *next = p->next;
            free_part(&p);
            p = next;
        }
        list->head = nullptr;
        list->last = nullptr;
    }
    void add_chars(PartList *list, char c, int n)
    {
        Part *p = (Part *)x_alloc(sizeof(Part) + n);
        p->next = nullptr;
        p->size = n;
        memset(p->data, c, n);
        p->data[n] = 0;
        add_part(list, p);
    }
    //
    static char const *digits_lower()
    {
        return "0123456789abcdef";
    }
    static char const *digits_upper()
    {
        return "0123456789ABCDEF";
    }
    //
#ifndef STRFORMAT_NO_FP
    Part *format_double(double val, int precision, bool trim_zeros, bool plus)
    {
        if (std::isnan(val)) return alloc_part("#NAN");
        if (std::isinf(val)) return alloc_part("#INF");
 
        bool sign = val < 0;
        if (sign) val = -val;
 
        int bufsize = precision + 400;
        char *buf = (char *)alloca(bufsize);
        char *ptr = buf + 1; // reserve buf[0] for sign
 
        auto result = std::to_chars(ptr, buf + bufsize, val, std::chars_format::fixed, precision);
        char *end = result.ptr;
 
        if (trim_zeros) {
            char *dot = std::find(ptr, end, '.');
            if (dot != end) {
                while (end > dot + 1 && end[-1] == '0') end--;
                if (end[-1] == '.') end--;
            }
        }
 
        if (sign) {
            *--ptr = '-';
        } else if (plus) {
            *--ptr = '+';
        }
 
        return alloc_part(ptr, end);
    }
#endif
    Part *format_int32(int32_t val, bool force_sign)
    {
        int n = 30;
        char *end = (char *)alloca(n) + n - 1;
        char *ptr = end;
        *end = 0;
 
        if (val == 0) {
            *--ptr = '0';
        } else {
            bool sign = (val < 0);
            using U = std::make_unsigned_t<decltype(val)>;
            U u = (U)val;
            if (sign) {
                u = 0u - u;
            }
            while (u != 0) {
                int c = u % 10 + '0';
                u /= 10;
                *--ptr = c;
            }
            if (sign) {
                *--ptr = '-';
            } else if (force_sign) {
                *--ptr = '+';
            }
        }
 
        return alloc_part(ptr, end);
    }
    Part *format_uint32(uint32_t val)
    {
        int n = 30;
        char *end = (char *)alloca(n) + n - 1;
        char *ptr = end;
        *end = 0;
 
        if (val == 0) {
            *--ptr = '0';
        } else {
            while (val != 0) {
                int c = val % 10 + '0';
                val /= 10;
                *--ptr = c;
            }
        }
 
        return alloc_part(ptr, end);
    }
    Part *format_int64(int64_t val, bool force_sign)
    {
        int n = 30;
        char *end = (char *)alloca(n) + n - 1;
        char *ptr = end;
        *end = 0;
 
        if (val == 0) {
            *--ptr = '0';
        } else {
            bool sign = (val < 0);
            using U = std::make_unsigned_t<decltype(val)>;
            U u = (U)val;
            if (sign) {
                u = 0u - u;
            }
 
            while (u != 0) {
                int c = u % 10 + '0';
                u /= 10;
                *--ptr = c;
            }
            if (sign) {
                *--ptr = '-';
            } else if (force_sign) {
                *--ptr = '+';
            }
        }
 
        return alloc_part(ptr, end);
    }
    Part *format_uint64(uint64_t val)
    {
        int n = 30;
        char *end = (char *)alloca(n) + n - 1;
        char *ptr = end;
        *end = 0;
 
        if (val == 0) {
            *--ptr = '0';
        } else {
            while (val != 0) {
                int c = val % 10 + '0';
                val /= 10;
                *--ptr = c;
            }
        }
 
        return alloc_part(ptr, end);
    }
    Part *format_oct32(uint32_t val)
    {
        int n = 30;
        char *end = (char *)alloca(n) + n - 1;
        char *ptr = end;
        *end = 0;
 
        char const *digits = digits_lower();
 
        if (val == 0) {
            *--ptr = '0';
        } else {
            while (val != 0) {
                char c = digits[val & 7];
                val >>= 3;
                *--ptr = c;
            }
        }
 
        return alloc_part(ptr, end);
    }
    Part *format_oct64(uint64_t val)
    {
        int n = 30;
        char *end = (char *)alloca(n) + n - 1;
        char *ptr = end;
        *end = 0;
 
        char const *digits = digits_lower();
 
        if (val == 0) {
            *--ptr = '0';
        } else {
            while (val != 0) {
                char c = digits[val & 7];
                val >>= 3;
                *--ptr = c;
            }
        }
 
        return alloc_part(ptr, end);
    }
    Part *format_hex32(uint32_t val, bool upper)
    {
        int n = 30;
        char *end = (char *)alloca(n) + n - 1;
        char *ptr = end;
        *end = 0;
 
        char const *digits = upper ? digits_upper() : digits_lower();
 
        if (val == 0) {
            *--ptr = '0';
        } else {
            while (val != 0) {
                char c = digits[val & 15];
                val >>= 4;
                *--ptr = c;
            }
        }
 
        return alloc_part(ptr, end);
    }
    Part *format_hex64(uint64_t val, bool upper)
    {
        int n = 30;
        char *end = (char *)alloca(n) + n - 1;
        char *ptr = end;
        *end = 0;
 
        char const *digits = upper ? digits_upper() : digits_lower();
 
        if (val == 0) {
            *--ptr = '0';
        } else {
            while (val != 0) {
                char c = digits[val & 15];
                val >>= 4;
                *--ptr = c;
            }
        }
 
        return alloc_part(ptr, end);
    }
    Part *format_pointer(void *val)
    {
        int n = sizeof(uintptr_t) * 2 + 1;
        char *end = (char *)alloca(n) + n - 1;
        char *ptr = end;
        *end = 0;
 
        char const *digits = digits_upper();
 
        uintptr_t v = (uintptr_t)val;
        for (int i = 0; i < (int)sizeof(uintptr_t) * 2; i++) {
            char c = digits[v & 15];
            v >>= 4;
            *--ptr = c;
        }
 
        return alloc_part(ptr, end);
    }
private:
    struct Private {
        std::string_view text;
        char const *head;
        char const *next;
        PartList list;
        bool upper : 1;
        bool zero_padding : 1;
        bool align_left : 1;
        bool plus : 1;
        int width = 0;
        int precision;
        int lflag;
        Option_ opt;
    } q;
 
    void _init()
    {
        q.list = {};
    }
 
    void clear()
    {
        free_list(&q.list);
    }
    bool advance(bool complete)
    {
        bool r = false;
        auto Flush = [&](){
            if (q.head < q.next) {
                Part *p = alloc_part(q.head, q.next);
                add_part(&q.list, p);
                q.head = q.next;
            }
        };
        char const *end = q.text.data() + q.text.size();
        while (q.next < end) {
            if (*q.next == '%') {
                if (q.next[1] == '%') {
                    q.next++;
                    Flush();
                    q.next++;
                    q.head = q.next;
                } else if (complete) {
                    q.next++;
                } else {
                    r = true;
                    break;
                }
            } else {
                q.next++;
            }
        }
        Flush();
        return r;
    }
#ifndef STRFORMAT_NO_FP
    Part *format_f(double value, bool trim_zeros)
    {
        int pr = q.precision < 0 ? 6 : q.precision;
        if (pr > max_precision) pr = max_precision;
        return format_double(value, pr, trim_zeros, q.plus);
    }
#endif
    Part *format_c(char c)
    {
        return alloc_part(&c, &c + 1);
    }
    Part *format_o32(uint32_t value, int hint)
    {
        if (hint) {
            switch (hint) {
            case 'c': return format_c((char)value);
            case 'd': return format((int32_t)value, 0);
            case 'u': return format(value, 0);
            case 'x': return format_x32(value, 0);
#ifndef STRFORMAT_NO_FP
            case 'f': return format((double)value, 0);
#endif
            }
        }
        return format_oct32(value);
    }
    Part *format_o64(uint64_t value, int hint)
    {
        if (hint) {
            switch (hint) {
            case 'c': return format_c((char)value);
            case 'd': return format((int64_t)value, 0);
            case 'u': return format(value, 0);
            case 'x': return format_x64(value, 0);
#ifndef STRFORMAT_NO_FP
            case 'f': return format((double)value, 0);
#endif
            }
        }
        return format_oct64(value);
    }
    Part *format_x32(uint32_t value, int hint)
    {
        if (hint) {
            switch (hint) {
            case 'c': return format_c((char)value);
            case 'd': return format((int32_t)value, 0);
            case 'u': return format(value, 0);
            case 'o': return format_o32(value, 0);
#ifndef STRFORMAT_NO_FP
            case 'f': return format((double)value, 0);
#endif
            }
        }
        return format_hex32(value, q.upper);
    }
    Part *format_x64(uint64_t value, int hint)
    {
        if (hint) {
            switch (hint) {
            case 'c': return format_c((char)value);
            case 'd': return format((int64_t)value, 0);
            case 'u': return format(value, 0);
            case 'o': return format_o64(value, 0);
#ifndef STRFORMAT_NO_FP
            case 'f': return format((double)value, 0);
#endif
            }
        }
        return format_hex64(value, q.upper);
    }
    Part *format(char c, int hint)
    {
        return format((int32_t)c, hint);
    }
#ifndef STRFORMAT_NO_FP
    Part *format(double value, int hint)
    {
        if (hint) {
            switch (hint) {
            case 'c': return format_c((char)value);
            case 'd': return format((int64_t)value, 0);
            case 'u': return format((uint64_t)value, 0);
            case 'o': return format_o64((uint64_t)value, 0);
            case 'x': return format_x64((uint64_t)value, 0);
            case 's': return format_f(value, true);
            }
        }
        return format_f(value, false);
    }
#endif
    Part *format(int32_t value, int hint)
    {
        if (hint) {
            switch (hint) {
            case 'c': return format_c((char)value);
            case 'u': return format((uint32_t)value, 0);
            case 'o': return format_o32((uint32_t)value, 0);
            case 'x': return format_x32((uint32_t)value, 0);
#ifndef STRFORMAT_NO_FP
            case 'f': return format((double)value, 0);
#endif
            }
        }
        return format_int32(value, q.plus);
    }
    Part *format(uint32_t value, int hint)
    {
        if (hint) {
            switch (hint) {
            case 'c': return format_c((char)value);
            case 'd': return format((int32_t)value, 0);
            case 'o': return format_o32((uint32_t)value, 0);
            case 'x': return format_x32((uint32_t)value, 0);
#ifndef STRFORMAT_NO_FP
            case 'f': return format((double)value, 0);
#endif
            }
        }
        return format_uint32(value);
    }
    Part *format(int64_t value, int hint)
    {
        if (hint) {
            switch (hint) {
            case 'c': return format_c((char)value);
            case 'u': return format((uint64_t)value, 0);
            case 'o': return format_o64((uint64_t)value, 0);
            case 'x': return format_x64((uint64_t)value, 0);
#ifndef STRFORMAT_NO_FP
            case 'f': return format((double)value, 0);
#endif
            }
        }
        return format_int64(value, q.plus);
    }
    Part *format(uint64_t value, int hint)
    {
        if (hint) {
            switch (hint) {
            case 'c': return format_c((char)value);
            case 'd': return format((int64_t)value, 0);
            case 'o': return format_oct64(value);
            case 'x': return format_hex64(value, false);
#ifndef STRFORMAT_NO_FP
            case 'f': return format((double)value, 0);
#endif
            }
        }
        return format_uint64(value);
    }
    Part *format(char const *value, int hint)
    {
        if (!value) {
            return alloc_part("(null)");
        }
        if (hint) {
            switch (hint) {
            case 'c':
                return format_c(num<char>(value, q.opt));
            case 'd':
                if (q.lflag == 0) {
                    return format(num<int32_t>(value, q.opt), 0);
                } else {
                    return format(num<int64_t>(value, q.opt), 0);
                }
            case 'u': case 'o': case 'x':
                if (q.lflag == 0) {
                    return format(num<uint32_t>(value, q.opt), hint);
                } else {
                    return format(num<uint64_t>(value, q.opt), hint);
                }
#ifndef STRFORMAT_NO_FP
            case 'f':
                return format(num<double>(value, q.opt), hint);
#endif
            }
        }
        return alloc_part(value, value + strlen(value));
    }
    Part *format(std::string_view const &value, int hint)
    {
        if (hint == 's') {
            return alloc_part(value);
        }
        return format(value.data(), hint);
    }
    Part *format(std::vector<char> const &value, int hint)
    {
        std::string_view sv(value.data(), value.size());
        if (hint == 's') {
            return alloc_part(sv);
        }
        return format(sv, hint);
    }
    Part *format_p(void *val)
    {
        return format_pointer(val);
    }
    void reset_format_params()
    {
        q.upper = false;
        q.zero_padding = false;
        q.align_left = false;
        q.plus = false;
        q.width = -1;
        q.precision = -1;
        q.lflag = 0;
    }
    void format(std::function<Part *(int)> const &callback, int width, int precision)
    {
        if (advance(false)) {
            if (*q.next == '%') {
                q.next++;
            }
 
            reset_format_params();
 
            while (1) {
                int c = (unsigned char)*q.next;
                if (c == '0') {
                    q.zero_padding = true;
                } else if (c == '+') {
                    q.plus = true;
                } else if (c == '-') {
                    q.align_left = true;
                } else {
                    break;
                }
                q.next++;
            }
 
            auto GetNumber = [&](int alternate_value){
                int value = -1;
                if (*q.next == '*') {
                    q.next++;
                } else {
                    while (1) {
                        int c = (unsigned char)*q.next;
                        if (!isdigit(c)) break;
                        if (value < 0) {
                            value = 0;
                        }
                        if (value <= (std::numeric_limits<int>::max() - (c - '0')) / 10) {
                            value = value * 10 + (c - '0');
                        } else {
                            value = std::numeric_limits<int>::max();
                        }
                        q.next++;
                    }
                }
                if (value < 0) {
                    value = alternate_value;
                }
                return value;
            };
 
            q.width = GetNumber(width);
 
            if (*q.next == '.') {
                q.next++;
            }
 
            q.precision = GetNumber(precision);
 
            while (*q.next == 'l') {
                q.lflag++;
                q.next++;
            }
 
            Part *p = nullptr;
 
            int c = (unsigned char)*q.next;
            if (isupper(c)) {
                q.upper = true;
                c = tolower(c);
            }
            if (isalpha(c)) {
                p = callback(c);
                q.next++;
            }
            if (p) {
                int padlen = q.width - p->size;
                if (padlen > 0 && !q.align_left) {
                    if (q.zero_padding) {
                        char c = p->data[0];
                        add_chars(&q.list, '0', padlen);
                        if (c == '+' || c == '-') {
                            q.list.last->data[0] = c;
                            p->data[0] = '0';
                        }
                    } else {
                        add_chars(&q.list, ' ', padlen);
                    }
                }
 
                add_part(&q.list, p);
 
                if (padlen > 0 && q.align_left) {
                    add_chars(&q.list, ' ', padlen);
                }
            }
 
            q.head = q.next;
        }
    }
    int length()
    {
        advance(true);
        int len = 0;
        for (Part *p = q.list.head; p; p = p->next) {
            len += p->size;
        }
        return len;
    }
#ifndef STRFORMAT_NO_LOCALE
    void use_locale(bool use)
    {
        if (use) {
            q.opt.lc = localeconv();
        } else {
            q.opt.lc = nullptr;
        }
    }
#endif
    void set_flags(int flags)
    {
        (void)flags;
#ifndef STRFORMAT_NO_LOCALE
        use_locale(flags & Locale);
#endif
    }
public:
    string_formatter(string_formatter const &) = delete;
    void operator = (string_formatter const &) = delete;
    string_formatter(string_formatter &&r) = delete;
    void operator = (string_formatter &&r) = delete;
 
    string_formatter(int flags = 0, std::string_view text = {})
    {
        reset(flags, text);
    }
 
    string_formatter(std::string_view text)
    {
        reset(0, text);
    }
    ~string_formatter()
    {
        clear();
    }
 
    char decimal_point() const
    {
#ifndef STRFORMAT_NO_LOCALE
        if (q.opt.lc && q.opt.lc->decimal_point) {
            return *q.opt.lc->decimal_point;
        }
#endif
        return '.';
    }
 
    string_formatter &reset(int flags, std::string_view text)
    {
        (void)flags;
        clear();
        q.text = text.empty() ? std::string_view("") : text;
        q.head = q.text.data();
        q.next = q.head;
        reset_format_params();
 
#ifndef STRFORMAT_NO_LOCALE
        use_locale(flags & Locale);
#endif
 
        return *this;
    }
 
    template <typename T> string_formatter &arg(T const &value, int width = -1, int precision = -1)
    {
        format([&](int hint){ return format(value, hint); }, width, precision);
        return *this;
    }
#ifndef STRFORMAT_NO_FP
    string_formatter &f(double value, int width = -1, int precision = -1)
    {
        return arg(value, width, precision);
    }
#endif
    string_formatter &c(char value, int width = -1, int precision = -1)
    {
        return arg(value, width, precision);
    }
    string_formatter &d(int32_t value, int width = -1, int precision = -1)
    {
        return arg(value, width, precision);
    }
    string_formatter &ld(int64_t value, int width = -1, int precision = -1)
    {
        return arg(value, width, precision);
    }
    string_formatter &u(uint32_t value, int width = -1, int precision = -1)
    {
        return arg(value, width, precision);
    }
    string_formatter &lu(uint64_t value, int width = -1, int precision = -1)
    {
        return arg(value, width, precision);
    }
    string_formatter &o(int32_t value, int width = -1, int precision = -1)
    {
        format([&](int hint){ return format_o32(value, hint); }, width, precision);
        return *this;
    }
    string_formatter &lo(int64_t value, int width = -1, int precision = -1)
    {
        format([&](int hint){ return format_o64(value, hint); }, width, precision);
        return *this;
    }
    string_formatter &x(int32_t value, int width = -1, int precision = -1)
    {
        format([&](int hint){ return format_x32(value, hint); }, width, precision);
        return *this;
    }
    string_formatter &lx(int64_t value, int width = -1, int precision = -1)
    {
        format([&](int hint){ return format_x64(value, hint); }, width, precision);
        return *this;
    }
    string_formatter &s(char const *value, int width = -1, int precision = -1)
    {
        return arg(value, width, precision);
    }
    string_formatter &s(std::string_view const &value, int width = -1, int precision = -1)
    {
        return arg(value, width, precision);
    }
    string_formatter &p(void *value, int width = -1, int precision = -1)
    {
        format([&](int hint){ (void)hint; return format_p(value); }, width, precision);
        return *this;
    }
 
    template <typename T> string_formatter &operator () (T const &value, int width = -1, int precision = -1)
    {
        return arg(value, width, precision);
    }
    void render(std::function<void (char const *ptr, int len)> const &to)
    {
        advance(true);
        for (Part *p = q.list.head; p; p = p->next) {
            to(p->data, p->size);
        }
    }
    void write_to(FILE *fp)
    {
        render([&](char const *ptr, int len){
            fwrite(ptr, 1, len, fp);
        });
    }
    void write_to(int fd)
    {
        render([&](char const *ptr, int len){
            ::write(fd, ptr, len);
        });
    }
    void put()
    {
        write_to(stdout);
    }
    void err()
    {
        write_to(stderr);
    }
    void append_to(std::vector<char> *vec)
    {
        vec->reserve(vec->size() + length());
        render([&](char const *ptr, int len){
            vec->insert(vec->end(), ptr, ptr + len);
        });
    }
    void append_to(std::string *str)
    {
        str->reserve(str->size() + length());
        render([&](char const *ptr, int len){
            str->append(ptr, len);
        });
    }
    std::vector<char> vec()
    {
        std::vector<char> ret;
        append_to(&ret);
        return ret;
    }
    std::string str()
    {
        std::string result;
        result.reserve(length());
        render([&](char const *ptr, int len){
            result.append(ptr, len);
        });
        return result;
    }
    operator std::string ()
    {
        return str();
    }
};
 
} // namespace strformat_ns
 
#endif // STRFORMAT_H