FmtInfo

Documentation

API Reference

FmtInfo

Description

Stores formatting information for text output.

align : Text alignment (left, right, center). width : Minimum field width. precision : Number of decimal places for floating point. flags : Format flags (see FormatFlags enum).

Usage example (Cross-references)

Usage examples (Cross-references)

In Io.c:58:

    }
    
    static bool _write_r8(Str *o, FmtInfo *fmt_info, u8 *v);
    static bool _write_r16(Str *o, FmtInfo *fmt_info, u16 *v);
    static bool _write_r32(Str *o, FmtInfo *fmt_info, u32 *v);

In Io.c:59:

    
    static bool _write_r8(Str *o, FmtInfo *fmt_info, u8 *v);
    static bool _write_r16(Str *o, FmtInfo *fmt_info, u16 *v);
    static bool _write_r32(Str *o, FmtInfo *fmt_info, u32 *v);
    static bool _write_r64(Str *o, FmtInfo *fmt_info, u64 *v);

In Io.c:60:

    static bool _write_r8(Str *o, FmtInfo *fmt_info, u8 *v);
    static bool _write_r16(Str *o, FmtInfo *fmt_info, u16 *v);
    static bool _write_r32(Str *o, FmtInfo *fmt_info, u32 *v);
    static bool _write_r64(Str *o, FmtInfo *fmt_info, u64 *v);

In Io.c:61:

    static bool _write_r16(Str *o, FmtInfo *fmt_info, u16 *v);
    static bool _write_r32(Str *o, FmtInfo *fmt_info, u32 *v);
    static bool _write_r64(Str *o, FmtInfo *fmt_info, u64 *v);
    
    static Zstr _read_r8(Zstr i, FmtInfo *fmt_info, u8 *v);

In Io.c:63:

    static bool _write_r64(Str *o, FmtInfo *fmt_info, u64 *v);
    
    static Zstr _read_r8(Zstr i, FmtInfo *fmt_info, u8 *v);
    static Zstr _read_r16(Zstr i, FmtInfo *fmt_info, u16 *v);
    static Zstr _read_r32(Zstr i, FmtInfo *fmt_info, u32 *v);

In Io.c:64:

    
    static Zstr _read_r8(Zstr i, FmtInfo *fmt_info, u8 *v);
    static Zstr _read_r16(Zstr i, FmtInfo *fmt_info, u16 *v);
    static Zstr _read_r32(Zstr i, FmtInfo *fmt_info, u32 *v);
    static Zstr _read_r64(Zstr i, FmtInfo *fmt_info, u64 *v);

In Io.c:65:

    static Zstr _read_r8(Zstr i, FmtInfo *fmt_info, u8 *v);
    static Zstr _read_r16(Zstr i, FmtInfo *fmt_info, u16 *v);
    static Zstr _read_r32(Zstr i, FmtInfo *fmt_info, u32 *v);
    static Zstr _read_r64(Zstr i, FmtInfo *fmt_info, u64 *v);

In Io.c:66:

    static Zstr _read_r16(Zstr i, FmtInfo *fmt_info, u16 *v);
    static Zstr _read_r32(Zstr i, FmtInfo *fmt_info, u32 *v);
    static Zstr _read_r64(Zstr i, FmtInfo *fmt_info, u64 *v);
    
    // Avoids `__builtin_clzll`: we'd need a separate MSVC branch via

In Io.c:109:

    // any base prefix; type is one of `c`/`a`/`A`/`x`/`X`/`b`/`o`/`r`/`e`/
    // `E`/`s`.
    static bool parse_format_spec(Zstr spec, u32 len, FmtInfo *fi) {
        if (!spec || !fi) {
            LOG_FATAL("Invalid arguments");

In Io.c:117:

        // case and must fall through to the defaulted FmtInfo below.
    
        *fi = (FmtInfo) {.align = ALIGN_RIGHT, .width = 0, .precision = 6, .flags = FMT_FLAG_NONE};
    
        u32 pos = 0;

In Io.c:326:

    
                size    spec_len = brace_end - brace_start - 1;
                FmtInfo fmt_info;
                if (spec_len == 0) {
                    // Empty `{}` body falls through to the same defaults

In Io.c:331:

                    // parse_format_spec would have emitted for an empty
                    // input, without the bounds check overhead.
                    fmt_info = (FmtInfo) {.align = ALIGN_RIGHT, .width = 0, .precision = 6, .flags = FMT_FLAG_NONE};
                } else if (!parse_format_spec(fmt + brace_start + 1, spec_len, &fmt_info)) {
                    return false;

In Io.c:617:

                // Validate format specifier. The spec scratch lives only
                // long enough to NUL-terminate the slice for parse_format_spec.
                FmtInfo fmt_info = {0};
                bool    spec_ok  = false;
                StrInitStack(spec_buf, 32) {

In Io.c:838:

            u32 spec_len = (u32)(StrIterRemainingLength(&spec_start_fsi) - StrIterRemainingLength(&fsi));
    
            FmtInfo fmt_info = {0};
            if (!parse_format_spec(spec_start, spec_len, &fmt_info)) {
                *iter = start;

In Io.c:951:

    // raw output. Returns the index of the next byte after the directive,
    // or 0 on a failed write (fmt error / OOM).
    static bool render_one_raw_field(Str *out, FmtInfo *fmt_info, TypeSpecificIO *io, u64 arg_index) {
        if (!io->writer) {
            LOG_FATAL("buf_*_fmt: argument {} has no writer", arg_index);

In Io.c:1021:

            u32 spec_len = (u32)(StrIterRemainingLength(&spec_start_fsi) - StrIterRemainingLength(&fsi));
    
            FmtInfo fmt_info = {0};
            if (!parse_format_spec(spec_start, spec_len, &fmt_info)) {
                return false;

In Io.c:1262:

    }
    
    static u8 int_fmt_radix_from_flags(FmtInfo *fmt_info) {
        if (fmt_info && (fmt_info->flags & FMT_FLAG_HEX)) {
            return 16;

In Io.c:1278:

    
    #if FEATURE_FLOAT
    static bool float_fmt_uses_unsupported_flags(FmtInfo *fmt_info) {
        return fmt_info && (fmt_info->flags & (FMT_FLAG_CHAR | FMT_FLAG_HEX | FMT_FLAG_BINARY | FMT_FLAG_OCTAL |
                                               FMT_FLAG_RAW | FMT_FLAG_STRING)) != 0;

In Io.c:1568:

    // post-read cursor so the outer reader can splice it back into the
    // surrounding format-walk.
    static inline Zstr read_chars_internal(Zstr i, u8 *buffer, size buffer_size, FmtInfo *fmt_info) {
        if (!i || !buffer || !buffer_size) {
            LOG_FATAL("Invalid arguments");

In Io.c:1617:

    }
    
    bool _write_Str(Str *o, FmtInfo *fmt_info, Str *s) {
        if (!o || !s || !fmt_info) {
            LOG_FATAL("Invalid arguments");

In Io.c:1704:

    }
    
    bool _write_Zstr(Str *o, FmtInfo *fmt_info, Zstr *s) {
        if (!o || !s || !*s || !fmt_info) {
            LOG_FATAL("Invalid arguments");

In Io.c:1792:

    }
    
    bool _write_ZstrAlloc(Str *o, FmtInfo *fmt_info, ZstrIOArg *arg) {
        Zstr *value = NULL;

In Io.c:1803:

    }
    
    bool _write_u64(Str *o, FmtInfo *fmt_info, u64 *v) {
        if (!o || !fmt_info || !v) {
            LOG_FATAL("Invalid arguments");

In Io.c:1862:

    }
    
    bool _write_u32(Str *o, FmtInfo *fmt_info, u32 *v) {
        if (!o || !fmt_info || !v) {
            LOG_FATAL("Invalid arguments");

In Io.c:1876:

    }
    
    bool _write_u16(Str *o, FmtInfo *fmt_info, u16 *v) {
        if (!o || !fmt_info || !v) {
            LOG_FATAL("Invalid arguments");

In Io.c:1890:

    }
    
    bool _write_u8(Str *o, FmtInfo *fmt_info, u8 *v) {
        if (!o || !fmt_info || !v) {
            LOG_FATAL("Invalid arguments");

In Io.c:1904:

    }
    
    bool _write_i64(Str *o, FmtInfo *fmt_info, i64 *v) {
        if (!o || !fmt_info || !v) {
            LOG_FATAL("Invalid arguments");

In Io.c:1962:

    }
    
    bool _write_i32(Str *o, FmtInfo *fmt_info, i32 *v) {
        if (!o || !fmt_info || !v) {
            LOG_FATAL("Invalid arguments");

In Io.c:1976:

    }
    
    bool _write_i16(Str *o, FmtInfo *fmt_info, i16 *v) {
        if (!o || !fmt_info || !v) {
            LOG_FATAL("Invalid arguments");

In Io.c:1990:

    }
    
    bool _write_i8(Str *o, FmtInfo *fmt_info, i8 *v) {
        if (!o || !fmt_info || !v) {
            LOG_FATAL("Invalid arguments");

In Io.c:2004:

    }
    
    bool _write_f64(Str *o, FmtInfo *fmt_info, f64 *v) {
        if (!o || !fmt_info || !v) {
            LOG_FATAL("Invalid arguments");

In Io.c:2086:

    }
    
    bool _write_f32(Str *o, FmtInfo *fmt_info, f32 *v) {
        if (!o || !fmt_info || !v) {
            LOG_FATAL("Invalid arguments");

In Io.c:2105:

    
    #if FEATURE_FLOAT
    bool _write_Float(Str *o, FmtInfo *fmt_info, Float *value) {
        size start_len = 0;
        Str  temp;

In Io.c:2235:

    }
    
    Zstr _read_Str(Zstr i, FmtInfo *fmt_info, Str *s) {
        if (!i || !s)
            LOG_FATAL("Invalid arguments");

In Io.c:2505:

    // ---------------------------------------------------------------------------
    
    Zstr _read_f64(Zstr i, FmtInfo *fmt_info, f64 *v) {
        DefaultAllocator scratch = DefaultAllocatorInit();

In Io.c:2626:

    }
    
    Zstr _read_u8(Zstr i, FmtInfo *fmt_info, u8 *v) {
        DefaultAllocator scratch = DefaultAllocatorInit();

In Io.c:2738:

    // ---------------------------------------------------------------------------
    #define _MAKE_READ_TXT_INT(NAME, T, VAL_T, PARSER, BOUND_CHECK)                                                        \
        Zstr _read_##NAME(Zstr i, FmtInfo *fmt_info, T *v) {                                                               \
            DefaultAllocator scratch = DefaultAllocatorInit();                                                             \
                                                                                                                           \

In Io.c:2840:

    #undef _I_BOUND
    
    Zstr _read_Zstr(Zstr i, FmtInfo *fmt_info, Zstr *out) {
        (void)fmt_info;
        (void)out;

In Io.c:2847:

    }
    
    Zstr _read_ZstrAlloc(Zstr i, FmtInfo *fmt_info, ZstrIOArg *arg) {
        char     **out           = NULL;
        char      *previous      = NULL;

In Io.c:2854:

        Allocator *allocator_ptr = NULL;
        Str        temp;
        FmtInfo    default_fmt;
    
        if (!i || !arg || !arg->value || !arg->allocator) {

In Io.c:2866:

    
        default_fmt        = fmt_info ? *fmt_info :
                                        (FmtInfo) {
                                            .align        = ALIGN_RIGHT,
                                            .width        = 0,

In Io.c:2904:

    
    #if FEATURE_BITVEC
    bool _write_BitVec(Str *o, FmtInfo *fmt_info, BitVec *bv) {
        if (!o || !fmt_info || !bv) {
            LOG_FATAL("Invalid arguments");

In Io.c:2978:

    
    #if FEATURE_INT
    bool _write_Int(Str *o, FmtInfo *fmt_info, Int *value) {
        if (!o || !fmt_info || !value) {
            LOG_FATAL("Invalid arguments");

In Io.c:3042:

    
    #if FEATURE_BITVEC
    Zstr _read_BitVec(Zstr i, FmtInfo *fmt_info, BitVec *bv) {
        (void)fmt_info; // Unused parameter
        if (!i || !bv) {

In Io.c:3175:

    
    #if FEATURE_INT
    Zstr _read_Int(Zstr i, FmtInfo *fmt_info, Int *value) {
        if (!i || !value) {
            LOG_FATAL("Invalid arguments");

In Io.c:3262:

    
    #if FEATURE_FLOAT
    Zstr _read_Float(Zstr i, FmtInfo *fmt_info, Float *value) {
        size  token_len = 0;
        Zstr  start     = NULL;

In Io.c:3324:

    #endif // FEATURE_FLOAT
    
    Zstr _read_f32(Zstr i, FmtInfo *fmt_info, f32 *v) {
        DefaultAllocator scratch = DefaultAllocatorInit();

In Io.c:3448:

    }
    
    static bool _write_r8(Str *o, FmtInfo *fmt_info, u8 *v) {
        if (!o || !fmt_info || !v) {
            LOG_FATAL("Invalid arguments");

In Io.c:3457:

    }
    
    static bool _write_r16(Str *o, FmtInfo *fmt_info, u16 *v) {
        if (!o || !fmt_info || !v) {
            LOG_FATAL("Invalid arguments");

In Io.c:3483:

    }
    
    static bool _write_r32(Str *o, FmtInfo *fmt_info, u32 *v) {
        if (!o || !fmt_info || !v) {
            LOG_FATAL("Invalid arguments");

In Io.c:3511:

    }
    
    static bool _write_r64(Str *o, FmtInfo *fmt_info, u64 *v) {
        if (!o || !fmt_info || !v) {
            LOG_FATAL("Invalid arguments");

In Io.c:3543:

    }
    
    static Zstr _read_r8(Zstr i, FmtInfo *fmt_info, u8 *v) {
        if (!i || !fmt_info || !v) {
            LOG_FATAL("Invalid arguments");

In Io.c:3552:

    }
    
    static Zstr _read_r16(Zstr i, FmtInfo *fmt_info, u16 *v) {
        if (!i || !fmt_info || !v) {
            LOG_FATAL("Invalid arguments");

In Io.c:3580:

    }
    
    static Zstr _read_r32(Zstr i, FmtInfo *fmt_info, u32 *v) {
        if (!i || !fmt_info || !v) {
            LOG_FATAL("Invalid arguments");

In Io.c:3606:

    }
    
    static Zstr _read_r64(Zstr i, FmtInfo *fmt_info, u64 *v) {
        if (!i || !fmt_info || !v) {
            LOG_FATAL("Invalid arguments");

In Io.UserTypes.c:53:

    // nested expansions from inside an outer writer's own body. Pattern A in
    // the extending-io guide.
    bool _write_Point2D(Str *o, FmtInfo *info, Point2D *p);
    Zstr _read_Point2D(Zstr i, FmtInfo *info, Point2D *p);
    bool _write_Bounds(Str *o, FmtInfo *info, Bounds *b);

In Io.UserTypes.c:54:

    // the extending-io guide.
    bool _write_Point2D(Str *o, FmtInfo *info, Point2D *p);
    Zstr _read_Point2D(Zstr i, FmtInfo *info, Point2D *p);
    bool _write_Bounds(Str *o, FmtInfo *info, Bounds *b);
    Zstr _read_Bounds(Zstr i, FmtInfo *info, Bounds *b);

In Io.UserTypes.c:55:

    bool _write_Point2D(Str *o, FmtInfo *info, Point2D *p);
    Zstr _read_Point2D(Zstr i, FmtInfo *info, Point2D *p);
    bool _write_Bounds(Str *o, FmtInfo *info, Bounds *b);
    Zstr _read_Bounds(Zstr i, FmtInfo *info, Bounds *b);
    bool _write_Region(Str *o, FmtInfo *info, Region *r);

In Io.UserTypes.c:56:

    Zstr _read_Point2D(Zstr i, FmtInfo *info, Point2D *p);
    bool _write_Bounds(Str *o, FmtInfo *info, Bounds *b);
    Zstr _read_Bounds(Zstr i, FmtInfo *info, Bounds *b);
    bool _write_Region(Str *o, FmtInfo *info, Region *r);
    Zstr _read_Region(Zstr i, FmtInfo *info, Region *r);

In Io.UserTypes.c:57:

    bool _write_Bounds(Str *o, FmtInfo *info, Bounds *b);
    Zstr _read_Bounds(Zstr i, FmtInfo *info, Bounds *b);
    bool _write_Region(Str *o, FmtInfo *info, Region *r);
    Zstr _read_Region(Zstr i, FmtInfo *info, Region *r);

In Io.UserTypes.c:58:

    Zstr _read_Bounds(Zstr i, FmtInfo *info, Bounds *b);
    bool _write_Region(Str *o, FmtInfo *info, Region *r);
    Zstr _read_Region(Zstr i, FmtInfo *info, Region *r);
    
    bool _write_Point2D(Str *o, FmtInfo *info, Point2D *p) {

In Io.UserTypes.c:60:

    Zstr _read_Region(Zstr i, FmtInfo *info, Region *r);
    
    bool _write_Point2D(Str *o, FmtInfo *info, Point2D *p) {
        (void)info;
        if (!o || !p) {

In Io.UserTypes.c:68:

    }
    
    Zstr _read_Point2D(Zstr i, FmtInfo *info, Point2D *p) {
        (void)info;
        if (!i || !p) {

In Io.UserTypes.c:80:

    // `_Generic` arm for `Point2D` resolves correctly from inside another
    // user-type writer.
    bool _write_Bounds(Str *o, FmtInfo *info, Bounds *b) {
        (void)info;
        if (!o || !b) {

In Io.UserTypes.c:88:

    }
    
    Zstr _read_Bounds(Zstr i, FmtInfo *info, Bounds *b) {
        (void)info;
        if (!i || !b) {

In Io.UserTypes.c:100:

    // a standalone Point2D plus an in-tree i32. Exercises a writer that mixes
    // nested user types, repeated user types, and built-ins in one call.
    bool _write_Region(Str *o, FmtInfo *info, Region *r) {
        (void)info;
        if (!o || !r) {

In Io.UserTypes.c:108:

    }
    
    Zstr _read_Region(Zstr i, FmtInfo *info, Region *r) {
        (void)info;
        if (!i || !r) {

In Io.h:100:

        FormatFlags flags;
        u32         max_read_len;
    } FmtInfo;
    
    ///

In Io.h:107:

    /// TAGS: I/O, Callback, Generic
    ///
    typedef bool (*TypeSpecificWriter)(Str *o, FmtInfo *fmt_info, void *data);
    
    ///

In Io.h:114:

    /// TAGS: I/O, Callback, Generic
    ///
    typedef Zstr (*TypeSpecificReader)(Zstr i, FmtInfo *fmt_info, void *data);
    
    ///

In Io.h:731:

    
    // not for direct use
    bool _write_Str(Str *o, FmtInfo *fmt_info, Str *s);
    bool _write_u8(Str *o, FmtInfo *fmt_info, u8 *v);
    bool _write_u16(Str *o, FmtInfo *fmt_info, u16 *v);

In Io.h:732:

    // not for direct use
    bool _write_Str(Str *o, FmtInfo *fmt_info, Str *s);
    bool _write_u8(Str *o, FmtInfo *fmt_info, u8 *v);
    bool _write_u16(Str *o, FmtInfo *fmt_info, u16 *v);
    bool _write_u32(Str *o, FmtInfo *fmt_info, u32 *v);

In Io.h:733:

    bool _write_Str(Str *o, FmtInfo *fmt_info, Str *s);
    bool _write_u8(Str *o, FmtInfo *fmt_info, u8 *v);
    bool _write_u16(Str *o, FmtInfo *fmt_info, u16 *v);
    bool _write_u32(Str *o, FmtInfo *fmt_info, u32 *v);
    bool _write_u64(Str *o, FmtInfo *fmt_info, u64 *v);

In Io.h:734:

    bool _write_u8(Str *o, FmtInfo *fmt_info, u8 *v);
    bool _write_u16(Str *o, FmtInfo *fmt_info, u16 *v);
    bool _write_u32(Str *o, FmtInfo *fmt_info, u32 *v);
    bool _write_u64(Str *o, FmtInfo *fmt_info, u64 *v);
    bool _write_i8(Str *o, FmtInfo *fmt_info, i8 *v);

In Io.h:735:

    bool _write_u16(Str *o, FmtInfo *fmt_info, u16 *v);
    bool _write_u32(Str *o, FmtInfo *fmt_info, u32 *v);
    bool _write_u64(Str *o, FmtInfo *fmt_info, u64 *v);
    bool _write_i8(Str *o, FmtInfo *fmt_info, i8 *v);
    bool _write_i16(Str *o, FmtInfo *fmt_info, i16 *v);

In Io.h:736:

    bool _write_u32(Str *o, FmtInfo *fmt_info, u32 *v);
    bool _write_u64(Str *o, FmtInfo *fmt_info, u64 *v);
    bool _write_i8(Str *o, FmtInfo *fmt_info, i8 *v);
    bool _write_i16(Str *o, FmtInfo *fmt_info, i16 *v);
    bool _write_i32(Str *o, FmtInfo *fmt_info, i32 *v);

In Io.h:737:

    bool _write_u64(Str *o, FmtInfo *fmt_info, u64 *v);
    bool _write_i8(Str *o, FmtInfo *fmt_info, i8 *v);
    bool _write_i16(Str *o, FmtInfo *fmt_info, i16 *v);
    bool _write_i32(Str *o, FmtInfo *fmt_info, i32 *v);
    bool _write_i64(Str *o, FmtInfo *fmt_info, i64 *v);

In Io.h:738:

    bool _write_i8(Str *o, FmtInfo *fmt_info, i8 *v);
    bool _write_i16(Str *o, FmtInfo *fmt_info, i16 *v);
    bool _write_i32(Str *o, FmtInfo *fmt_info, i32 *v);
    bool _write_i64(Str *o, FmtInfo *fmt_info, i64 *v);
    bool _write_Zstr(Str *o, FmtInfo *fmt_info, Zstr *s);

In Io.h:739:

    bool _write_i16(Str *o, FmtInfo *fmt_info, i16 *v);
    bool _write_i32(Str *o, FmtInfo *fmt_info, i32 *v);
    bool _write_i64(Str *o, FmtInfo *fmt_info, i64 *v);
    bool _write_Zstr(Str *o, FmtInfo *fmt_info, Zstr *s);
    bool _write_ZstrAlloc(Str *o, FmtInfo *fmt_info, ZstrIOArg *arg);

In Io.h:740:

    bool _write_i32(Str *o, FmtInfo *fmt_info, i32 *v);
    bool _write_i64(Str *o, FmtInfo *fmt_info, i64 *v);
    bool _write_Zstr(Str *o, FmtInfo *fmt_info, Zstr *s);
    bool _write_ZstrAlloc(Str *o, FmtInfo *fmt_info, ZstrIOArg *arg);
    bool _write_f32(Str *o, FmtInfo *fmt_info, f32 *v);

In Io.h:741:

    bool _write_i64(Str *o, FmtInfo *fmt_info, i64 *v);
    bool _write_Zstr(Str *o, FmtInfo *fmt_info, Zstr *s);
    bool _write_ZstrAlloc(Str *o, FmtInfo *fmt_info, ZstrIOArg *arg);
    bool _write_f32(Str *o, FmtInfo *fmt_info, f32 *v);
    bool _write_f64(Str *o, FmtInfo *fmt_info, f64 *v);

In Io.h:742:

    bool _write_Zstr(Str *o, FmtInfo *fmt_info, Zstr *s);
    bool _write_ZstrAlloc(Str *o, FmtInfo *fmt_info, ZstrIOArg *arg);
    bool _write_f32(Str *o, FmtInfo *fmt_info, f32 *v);
    bool _write_f64(Str *o, FmtInfo *fmt_info, f64 *v);
    #if FEATURE_FLOAT

In Io.h:743:

    bool _write_ZstrAlloc(Str *o, FmtInfo *fmt_info, ZstrIOArg *arg);
    bool _write_f32(Str *o, FmtInfo *fmt_info, f32 *v);
    bool _write_f64(Str *o, FmtInfo *fmt_info, f64 *v);
    #if FEATURE_FLOAT
    bool _write_Float(Str *o, FmtInfo *fmt_info, Float *value);

In Io.h:745:

    bool _write_f64(Str *o, FmtInfo *fmt_info, f64 *v);
    #if FEATURE_FLOAT
    bool _write_Float(Str *o, FmtInfo *fmt_info, Float *value);
    #endif
    #if FEATURE_BITVEC

In Io.h:748:

    #endif
    #if FEATURE_BITVEC
    bool _write_BitVec(Str *o, FmtInfo *fmt_info, BitVec *bv);
    #endif
    #if FEATURE_INT

In Io.h:751:

    #endif
    #if FEATURE_INT
    bool _write_Int(Str *o, FmtInfo *fmt_info, Int *value);
    #endif

In Io.h:754:

    #endif
    
    Zstr _read_Str(Zstr i, FmtInfo *fmt_info, Str *s);
    Zstr _read_u8(Zstr i, FmtInfo *fmt_info, u8 *v);
    Zstr _read_u16(Zstr i, FmtInfo *fmt_info, u16 *v);

In Io.h:755:

    
    Zstr _read_Str(Zstr i, FmtInfo *fmt_info, Str *s);
    Zstr _read_u8(Zstr i, FmtInfo *fmt_info, u8 *v);
    Zstr _read_u16(Zstr i, FmtInfo *fmt_info, u16 *v);
    Zstr _read_u32(Zstr i, FmtInfo *fmt_info, u32 *v);

In Io.h:756:

    Zstr _read_Str(Zstr i, FmtInfo *fmt_info, Str *s);
    Zstr _read_u8(Zstr i, FmtInfo *fmt_info, u8 *v);
    Zstr _read_u16(Zstr i, FmtInfo *fmt_info, u16 *v);
    Zstr _read_u32(Zstr i, FmtInfo *fmt_info, u32 *v);
    Zstr _read_u64(Zstr i, FmtInfo *fmt_info, u64 *v);

In Io.h:757:

    Zstr _read_u8(Zstr i, FmtInfo *fmt_info, u8 *v);
    Zstr _read_u16(Zstr i, FmtInfo *fmt_info, u16 *v);
    Zstr _read_u32(Zstr i, FmtInfo *fmt_info, u32 *v);
    Zstr _read_u64(Zstr i, FmtInfo *fmt_info, u64 *v);
    Zstr _read_i8(Zstr i, FmtInfo *fmt_info, i8 *v);

In Io.h:758:

    Zstr _read_u16(Zstr i, FmtInfo *fmt_info, u16 *v);
    Zstr _read_u32(Zstr i, FmtInfo *fmt_info, u32 *v);
    Zstr _read_u64(Zstr i, FmtInfo *fmt_info, u64 *v);
    Zstr _read_i8(Zstr i, FmtInfo *fmt_info, i8 *v);
    Zstr _read_i16(Zstr i, FmtInfo *fmt_info, i16 *v);

In Io.h:759:

    Zstr _read_u32(Zstr i, FmtInfo *fmt_info, u32 *v);
    Zstr _read_u64(Zstr i, FmtInfo *fmt_info, u64 *v);
    Zstr _read_i8(Zstr i, FmtInfo *fmt_info, i8 *v);
    Zstr _read_i16(Zstr i, FmtInfo *fmt_info, i16 *v);
    Zstr _read_i32(Zstr i, FmtInfo *fmt_info, i32 *v);

In Io.h:760:

    Zstr _read_u64(Zstr i, FmtInfo *fmt_info, u64 *v);
    Zstr _read_i8(Zstr i, FmtInfo *fmt_info, i8 *v);
    Zstr _read_i16(Zstr i, FmtInfo *fmt_info, i16 *v);
    Zstr _read_i32(Zstr i, FmtInfo *fmt_info, i32 *v);
    Zstr _read_i64(Zstr i, FmtInfo *fmt_info, i64 *v);

In Io.h:761:

    Zstr _read_i8(Zstr i, FmtInfo *fmt_info, i8 *v);
    Zstr _read_i16(Zstr i, FmtInfo *fmt_info, i16 *v);
    Zstr _read_i32(Zstr i, FmtInfo *fmt_info, i32 *v);
    Zstr _read_i64(Zstr i, FmtInfo *fmt_info, i64 *v);
    Zstr _read_Zstr(Zstr i, FmtInfo *fmt_info, Zstr *v);

In Io.h:762:

    Zstr _read_i16(Zstr i, FmtInfo *fmt_info, i16 *v);
    Zstr _read_i32(Zstr i, FmtInfo *fmt_info, i32 *v);
    Zstr _read_i64(Zstr i, FmtInfo *fmt_info, i64 *v);
    Zstr _read_Zstr(Zstr i, FmtInfo *fmt_info, Zstr *v);
    Zstr _read_ZstrAlloc(Zstr i, FmtInfo *fmt_info, ZstrIOArg *arg);

In Io.h:763:

    Zstr _read_i32(Zstr i, FmtInfo *fmt_info, i32 *v);
    Zstr _read_i64(Zstr i, FmtInfo *fmt_info, i64 *v);
    Zstr _read_Zstr(Zstr i, FmtInfo *fmt_info, Zstr *v);
    Zstr _read_ZstrAlloc(Zstr i, FmtInfo *fmt_info, ZstrIOArg *arg);
    Zstr _read_f32(Zstr i, FmtInfo *fmt_info, f32 *v);

In Io.h:764:

    Zstr _read_i64(Zstr i, FmtInfo *fmt_info, i64 *v);
    Zstr _read_Zstr(Zstr i, FmtInfo *fmt_info, Zstr *v);
    Zstr _read_ZstrAlloc(Zstr i, FmtInfo *fmt_info, ZstrIOArg *arg);
    Zstr _read_f32(Zstr i, FmtInfo *fmt_info, f32 *v);
    Zstr _read_f64(Zstr i, FmtInfo *fmt_info, f64 *v);

In Io.h:765:

    Zstr _read_Zstr(Zstr i, FmtInfo *fmt_info, Zstr *v);
    Zstr _read_ZstrAlloc(Zstr i, FmtInfo *fmt_info, ZstrIOArg *arg);
    Zstr _read_f32(Zstr i, FmtInfo *fmt_info, f32 *v);
    Zstr _read_f64(Zstr i, FmtInfo *fmt_info, f64 *v);
    #if FEATURE_FLOAT

In Io.h:766:

    Zstr _read_ZstrAlloc(Zstr i, FmtInfo *fmt_info, ZstrIOArg *arg);
    Zstr _read_f32(Zstr i, FmtInfo *fmt_info, f32 *v);
    Zstr _read_f64(Zstr i, FmtInfo *fmt_info, f64 *v);
    #if FEATURE_FLOAT
    Zstr _read_Float(Zstr i, FmtInfo *fmt_info, Float *value);

In Io.h:768:

    Zstr _read_f64(Zstr i, FmtInfo *fmt_info, f64 *v);
    #if FEATURE_FLOAT
    Zstr _read_Float(Zstr i, FmtInfo *fmt_info, Float *value);
    #endif
    #if FEATURE_BITVEC

In Io.h:771:

    #endif
    #if FEATURE_BITVEC
    Zstr _read_BitVec(Zstr i, FmtInfo *fmt_info, BitVec *bv);
    #endif
    #if FEATURE_INT

In Io.h:774:

    #endif
    #if FEATURE_INT
    Zstr _read_Int(Zstr i, FmtInfo *fmt_info, Int *value);
    #endif

Last updated on June 4, 2026

FloatTryToScientificStr FORMAT_STRING