StrReadFmt

Documentation

API Reference

StrReadFmt

Description

Parse input string according to format string with rust-style placeholders, extracting values into provided arguments. Delegates to the in-tree formatted-read backend.

The new input value after a successful read will be in [input, input + len(input)]

Provided input string must be an assignable l-value. The macro automatically updates given input string to new parse position after a successful parse. If parse fails, the input pointer does not change.

The input must not be passed to any allocator’s deallocate call after use. The pointer value is updated on successful read; after the call it might be (input) + 1 or (input + 1233493783847394), neither of which is a valid free target.

Not providing an assignable input (first parameter) will result in undefined behavior. If you’re lucky you’ll get a segfault.

Parameters

Name	Direction	Description
`input`	in	Input string to parse (must be null-terminated).
`fmtstr`	in	Format string with `{}` placeholders (must be null-terminated). argument should be a modifiable l-value wrapped with `&variable`.

Usage example (from documentation)

   void ParseInput(Zstr in, Zstr *out_rest, DefaultAllocator *alloc) {
       Zstr p  = in;                       // local cursor; in is not mutated
       i32  id = 0;
       Str  name = StrInit(alloc);
       StrReadFmt(p, "Person id = {} and name = {}", &id, &name);
       // p now points one past the consumed text on success.
       *out_rest = p;
       StrDeinit(&name);
   }

Success

Statement form – input is advanced in place to point at the first character past the consumed text.

Failure

Backend logs an error and returns without consuming input; input is left pointing at its original position.

Usage example (Cross-references)

Usage examples (Cross-references)

In Proc.h:289:

            ProcReadFromStdout((p), &UNPL(buf));                                                                           \
            Zstr UNPL(in) = StrBegin(&UNPL(buf));                                                                          \
            StrReadFmt(UNPL(in), __VA_ARGS__);                                                                             \
            StrDeinit(&UNPL(buf));                                                                                         \
        } while (0)

In Proc.h:316:

            ProcReadFromStderr((p), &UNPL(buf));                                                                           \
            Zstr UNPL(in) = StrBegin(&UNPL(buf));                                                                          \
            StrReadFmt(UNPL(in), __VA_ARGS__);                                                                             \
            StrDeinit(&UNPL(buf));                                                                                         \
        } while (0)

In Io.c:1706:

        i32  year = 0;
        u32  mon = 0, day = 0, hh = 0, mm = 0, ss = 0;
        StrReadFmt(p, "{}-{}-{}T{}:{}:{}", year, mon, day, hh, mm, ss);
        if (p == i) {
            return i; // no date-time prefix matched

In Io.c:1715:

            p++;
            Zstr frac_at = p;
            StrReadFmt(p, "{}", nanos);
            if (p == frac_at) {
                return i; // '.' with no fraction

In Io.c:1728:

            Zstr off_at = ++p;
            u32  oh = 0, om = 0;
            StrReadFmt(p, "{}:{}", oh, om);
            if (p == off_at) {
                return i; // malformed offset

In Http.c:118:

        Str        version = StrInit(alloc);
    
        StrReadFmt(cursor, "{} {} {}\r\n", method, req->url, version);
        if (cursor == in) {
            LOG_ERROR("http request parse failed: invalid request line");

In Http.c:160:

    
            HttpHeader hh = HttpHeaderInit(alloc);
            StrReadFmt(cursor, "{}: {}\r\n", hh.key, hh.value);
            if (cursor == line_start) {
                LOG_ERROR("failed to parse header line");

In DateTime.c:186:

        DateTime b = {0};
        Zstr     p = StrBegin(&s);
        StrReadFmt(p, "{}", b);
    
        bool ok = DateTimeCompare(a, b) == 0 && b.utc_offset_seconds == MST && b.nanosecond == 123456789u &&

In DateTime.c:199:

        Zstr     in = "2026-06-26T17:34:11-07:00";
        DateTime d  = {0};
        StrReadFmt(in, "{}", d);
        return d.year == 2026 && d.month == 6 && d.day == 26 && d.hour == 17 && d.minute == 34 && d.second == 11 &&
               d.nanosecond == 0 && d.utc_offset_seconds == MST;

In UserTypes.c:73:

            return i;
        }
        StrReadFmt(i, "({}, {})", p->x, p->y);
        return i;
    }

In UserTypes.c:93:

            return i;
        }
        StrReadFmt(i, "[{}..{}]", b->min, b->max);
        return i;
    }

In UserTypes.c:113:

            return i;
        }
        StrReadFmt(i, "{}:{}@{}", r->id, r->bbox, r->centroid);
        return i;
    }

In UserTypes.c:163:

        Zstr    in = "(42, -9)";
        Point2D p  = {0};
        StrReadFmt(in, "{}", p);
        bool ok = (p.x == 42) && (p.y == -9);

In UserTypes.c:180:

        bool ok = StrAppendFmt(&out, "{}", src);
        Zstr in = StrBegin(&out);
        StrReadFmt(in, "{}", dst);
        ok = ok && (dst.x == src.x) && (dst.y == src.y);

In UserTypes.c:220:

        bool ok = StrAppendFmt(&out, "{}", src);
        Zstr in = StrBegin(&out);
        StrReadFmt(in, "{}", dst);
    
        ok = ok && (dst.min.x == src.min.x) && (dst.min.y == src.min.y);

In UserTypes.c:264:

        bool ok = StrAppendFmt(&out, "{}", src);
        Zstr in = StrBegin(&out);
        StrReadFmt(in, "{}", dst);
    
        ok = ok && (dst.id == src.id);

In Write.c:997:

        (void)FloatTryFromStr(&f, "99");
    
        StrReadFmt(input, "{}", f);
    
        Str  text = FloatToStr(&f);

In Write.c:1415:

        BitVec bv = BitVecInit(alloc_base);
        Zstr   z  = "0x1";
        StrReadFmt(z, "{}", bv);
    
        bool ok = (BitVecToInteger(&bv) == 1) && (BitVecLen(&bv) == 4);

In Write.c:1433:

        BitVec bv = BitVecInit(alloc_base);
        Zstr   z  = "0xDEAD";
        StrReadFmt(z, "{}", bv);
    
        bool ok = (BitVecToInteger(&bv) == 0xDEAD) && (BitVecLen(&bv) == 16);

In Write.c:1449:

        BitVec bv = BitVecInit(alloc_base);
        Zstr   z  = "0xDEAD";
        StrReadFmt(z, "{}", bv);
    
        bool ok = (BitVecToInteger(&bv) == 0xDEAD) && (*z == '\0');

In Write.c:1468:

        BitVec bv = BitVecInit(alloc_base);
        Zstr   z  = "0o1";
        StrReadFmt(z, "{}", bv);
    
        bool ok = (BitVecToInteger(&bv) == 1) && (BitVecLen(&bv) == 3);

In Write.c:1487:

        BitVec bv = BitVecInit(alloc_base);
        Zstr   z  = "0o10";
        StrReadFmt(z, "{}", bv);
    
        bool ok = (BitVecToInteger(&bv) == 8) && (*z == '\0');

In Write.c:1504:

        BitVec bv = BitVecInit(alloc_base);
        Zstr   z  = "0o755";
        StrReadFmt(z, "{}", bv);
    
        bool ok = (BitVecToInteger(&bv) == 0755) && (BitVecLen(&bv) == 9);

In Write.c:1735:

        Zstr z = "0x1f";
        u8   v = 0;
        StrReadFmt(z, "{}", v);
        return v == 31;
    }

In Write.c:1749:

        Zstr z = " 5";
        u8   v = 0;
        StrReadFmt(z, "{}", v);
        return v == 5;
    }

In Write.c:1762:

        Zstr z = "0xff";
        u8   v = 0;
        StrReadFmt(z, "{}", v);
        return v == 255;
    }

In Write.c:1777:

        Zstr z = "05";
        u8   v = 0;
        StrReadFmt(z, "{}", v);
        return v == 5;
    }

In Write.c:2085:

        Zstr z = "\\xZZ";            // '\', 'x', 'Z', 'Z'
        u8   v = 0;
        StrReadFmt(z, "{c}", v);
        bool ok = (v == 0x5C);       // '\'; mutant stores 42
        ok      = ok && (*z == 'x'); // only '\' consumed

In Write.c:2099:

        Zstr z = "A";
        u8   v = 0;
        StrReadFmt(z, "{a}", v);
        return v == 'a'; // mutants give 'A' (0x41) or '*' (42)
    }

In Write.c:2110:

        Zstr z = "a";
        u8   v = 0;
        StrReadFmt(z, "{A}", v);
        return v == 'A'; // mutant gives 'a' (0x61) or '*' (42)
    }

In Write.c:2124:

        u8   buf[4] = {0, 0, 0, 0};
        Zstr z      = "AB";
        StrReadFmt(z, "{c}", buf[0]);
        bool ok = (buf[0] == 'A');
        ok      = ok && (*z == 'B'); // exactly one byte consumed; mutant -> 0

In Write.c:2145:

        Zstr z    = "-inf";
        Zstr orig = z;
        StrReadFmt(z, "{}", v);
        // Real: consumed (z advanced) and v is -inf. Mutant: not consumed.
        return (z != orig) && F64IsInf(v) && (v < 0.0);

In Write.c:2164:

        Zstr z    = "-Inf";
        Zstr orig = z;
        StrReadFmt(z, "{}", v);
        return (z != orig) && F64IsInf(v) && (v < 0.0);
    }

In Write.c:2185:

        f64  v = 0.0;
        Zstr z = "5inf";
        StrReadFmt(z, "{}", v);
        // Real: advanced by 1 -> *z == 'i'. Mutant: advanced by 4 -> *z == '\0'.
        return double_equals(v, 5.0) && (*z == 'i');

In Write.c:2205:

        Zstr z    = "info";
        Zstr orig = z;
        StrReadFmt(z, "{}", v);
        // Real: not consumed (z unchanged). Mutant: consumed (z advanced).
        return (z == orig);

In Write.c:2225:

        f64  v = -1.0;
        Zstr z = " 3.14";
        StrReadFmt(z, "{}", v);
        // Real: v == 3.14. Mutant: parse fails, v left at -1.0.
        return double_equals(v, 3.14);

In Write.c:2245:

        Zstr z    = "1f";
        Zstr orig = z;
        StrReadFmt(z, "{}", v);
        // Real: rejected, not consumed (z unchanged). Mutant: consumed.
        return (z == orig);

In Write.c:2272:

        f64  v = SENTINEL;
        Zstr z = "0x";
        StrReadFmt(z, "{}", v);
    
        // Real code: rejected, v untouched. Mutant: accepted -> 0.0.

In Write.c:2286:

        f64  v = SENTINEL;
        Zstr z = "0b";
        StrReadFmt(z, "{}", v);
    
        return is_sentinel(v);

In Write.c:2296:

        f64  v = SENTINEL;
        Zstr z = "0o";
        StrReadFmt(z, "{}", v);
    
        return is_sentinel(v);

In Write.c:2315:

        f64  v = SENTINEL;
        Zstr z = "0X1F";
        StrReadFmt(z, "{}", v);
    
        // Real code: is_hex set via the 'X' branch, slice accepted, value 0.0.

In Write.c:2329:

        f64  v = SENTINEL;
        Zstr z = "0B11";
        StrReadFmt(z, "{}", v);
    
        return is_zero(v);

In Write.c:2342:

        f64  v = SENTINEL;
        Zstr z = "0O7";
        StrReadFmt(z, "{}", v);
    
        return is_zero(v);

In Write.c:2356:

        f64  v = SENTINEL;
        Zstr z = "12.5";
        StrReadFmt(z, "{}", v);
    
        return F64Abs(v - 12.5) < 1e-9;

In Write.c:2366:

        f64  v = SENTINEL;
        Zstr z = "0x1f";
        StrReadFmt(z, "{}", v);
    
        // Real: is_hex via lowercase 'x', accepted, StrToF64 -> 0.0.

In Write.c:2388:

    
        Zstr z = "3.5;";
        StrReadFmt(z, "{};", val);
    
        // On success the macro advances `z` to the cursor returned by

In Write.c:2418:

    
        Zstr z = "12.25";
        StrReadFmt(z, "{}", val);
    
        success = success && (ZstrLen(z) == 0);

In Write.c:2444:

    
        Zstr z = "1.5e2!";
        StrReadFmt(z, "{e}!", val);
    
        success = success && (ZstrLen(z) == 0);

In Write.c:2470:

    
        Zstr z = "-0.25";
        StrReadFmt(z, "{}", val);
    
        success = success && (ZstrLen(z) == 0);

In Write.c:2492:

        BitVec bv = BitVecInit(alloc_base);
        Zstr   z  = "0x3ff";
        StrReadFmt(z, "{}", bv);
    
        bool ok = (BitVecLen(&bv) == 10) && (BitVecToInteger(&bv) == 0x3ff);

In Write.c:2511:

        BitVec bv = BitVecInit(alloc_base);
        Zstr   z  = "0xff";
        StrReadFmt(z, "{}", bv);
    
        bool ok = (BitVecLen(&bv) == 8) && (BitVecToInteger(&bv) == 0xff);

In Write.c:2530:

        BitVec bv = BitVecInit(alloc_base);
        Zstr   z  = "0x10000";
        StrReadFmt(z, "{}", bv);
    
        bool ok = (BitVecLen(&bv) == 17) && (BitVecToInteger(&bv) == 0x10000);

In Write.c:3181:

        u8   v = 0;
        Zstr z = "\\x41";
        StrReadFmt(z, "{c}", v);
        return v == 0x41;
    }

In Write.c:3191:

        u8   v = 0;
        Zstr z = "\\x01";
        StrReadFmt(z, "{c}", v);
        return v == 0x01;
    }

In Write.c:3200:

        u8   v = 0;
        Zstr z = "\\x10";
        StrReadFmt(z, "{c}", v);
        return v == 0x10;
    }

In Write.c:3210:

        u8   v = 0;
        Zstr z = "\\x4f";
        StrReadFmt(z, "{c}", v);
        return v == 0x4f;
    }

In Write.c:3823:

    
        Zstr z = "78";
        StrReadFmt(z, "{o}", oct);
    
        Str  oct_text = IntToOctStr(&oct);

In Write.c:4261:

        f32  v = -1.0f;
        Zstr z = " ";
        StrReadFmt(z, "{c}", v);
        return f32_close(v, 0.0f);
    }

In Write.c:4272:

        f32  v = 0.0f;
        Zstr z = "inf";
        StrReadFmt(z, "{}", v);
        return v > 1e30f;
    }

In Write.c:4279:

        f32  v = 0.0f;
        Zstr z = "INF";
        StrReadFmt(z, "{}", v);
        return v > 1e30f;
    }

In Write.c:4286:

        f32  v = 0.0f;
        Zstr z = "nan";
        StrReadFmt(z, "{}", v);
        return v != v;                            // NaN is the only value not equal to itself
    }

In Write.c:4293:

        f32  v = 0.0f;
        Zstr z = "NAN";
        StrReadFmt(z, "{}", v);
        return v != v;
    }

In Write.c:4300:

        f32  v = 0.0f;
        Zstr z = "-inf";
        StrReadFmt(z, "{}", v);
        return v < -1e30f;
    }

In Write.c:4307:

        f32  v = 0.0f;
        Zstr z = "-inf";
        StrReadFmt(z, "{}", v);
        return v < -1e30f;
    }

In Write.c:4314:

        f32  v = 0.0f;
        Zstr z = "-INF";
        StrReadFmt(z, "{}", v);
        return v < -1e30f;
    }

In Write.c:4323:

        f32  v = 0.0f;
        Zstr z = "inf";
        StrReadFmt(z, "{}", v);
        return v > 1e30f; // 42.0 would fail this
    }

In Write.c:4334:

        f32  v = 0.0f;
        Zstr z = "1e+3";
        StrReadFmt(z, "{}", v);
        return f32_close(v, 1000.0f);
    }

In Write.c:4342:

        f32  v = 0.0f;
        Zstr z = "1E+3";
        StrReadFmt(z, "{}", v);
        return f32_close(v, 1000.0f);
    }

In Write.c:4352:

        f32  v = 0.0f;
        Zstr z = "2e-2";
        StrReadFmt(z, "{}", v);
        return f32_close(v, 0.02f);
    }

In Write.c:4361:

        f32  v = 0.0f;
        Zstr z = "1e+3";
        StrReadFmt(z, "{}", v);
        return f32_close(v, 1000.0f);
    }

In Write.c:4369:

        f32  v = 0.0f;
        Zstr z = "1e-3";
        StrReadFmt(z, "{}", v);
        return f32_close(v, 0.001f);
    }

In Write.c:4381:

        f32  v = 0.0f;
        Zstr z = "+1.5";
        StrReadFmt(z, "{}", v);
        return f32_close(v, 1.5f);
    }

In Write.c:4393:

        f32  v = 0.0f;
        Zstr z = "  3.5";
        StrReadFmt(z, "{}", v);
        return f32_close(v, 3.5f);
    }

In Write.c:4407:

        Int  v = IntInit(ALLOCATOR_OF(&alloc));
        Zstr z = "9z";
        StrReadFmt(z, "{}", v);
        bool ok = (IntCompare(&v, 9) == 0);

In Write.c:4424:

        Int  v = IntInit(ALLOCATOR_OF(&alloc));
        Zstr z = "5";
        StrReadFmt(z, "{}", v);
        bool ok = (IntCompare(&v, 5) == 0);

In Write.c:4440:

        Int  v = IntInit(ALLOCATOR_OF(&alloc));
        Zstr z = "+8";
        StrReadFmt(z, "{}", v);
        bool ok = (IntCompare(&v, 8) == 0);

In Write.c:4456:

        Int  v = IntFromStr("123", &alloc);
        Zstr z = "9_";
        StrReadFmt(z, "{}", v);
        bool ok = (IntCompare(&v, 123) == 0);

In Write.c:4473:

        Int  v = IntFromStr("200", &alloc);
        Zstr z = "0xFF";
        StrReadFmt(z, "{x}", v);
        bool ok = (IntCompare(&v, 200) == 0);

In Write.c:4489:

        Int  v = IntFromStr("200", &alloc);
        Zstr z = "0XFF";
        StrReadFmt(z, "{x}", v);
        bool ok = (IntCompare(&v, 200) == 0);

In Write.c:4504:

        Int  v = IntInit(ALLOCATOR_OF(&alloc));
        Zstr z = "ff";
        StrReadFmt(z, "{x}", v);
        bool ok = (IntCompare(&v, 255) == 0);

In Write.c:4519:

        Int  v = IntFromStr("5", &alloc);
        Zstr z = "0b1";
        StrReadFmt(z, "{b}", v);
        bool ok = (IntCompare(&v, 5) == 0);

In Write.c:4533:

        Int  v = IntFromStr("5", &alloc);
        Zstr z = "0B1";
        StrReadFmt(z, "{b}", v);
        bool ok = (IntCompare(&v, 5) == 0);

In Write.c:4547:

        Int  v = IntInit(ALLOCATOR_OF(&alloc));
        Zstr z = "101";
        StrReadFmt(z, "{b}", v);
        bool ok = (IntCompare(&v, 5) == 0);

In Write.c:4562:

        Int  v = IntFromStr("9", &alloc);
        Zstr z = "0o7";
        StrReadFmt(z, "{o}", v);
        bool ok = (IntCompare(&v, 9) == 0);

In Write.c:4576:

        Int  v = IntFromStr("9", &alloc);
        Zstr z = "0O7";
        StrReadFmt(z, "{o}", v);
        bool ok = (IntCompare(&v, 9) == 0);

In Write.c:4590:

        Int  v = IntInit(ALLOCATOR_OF(&alloc));
        Zstr z = "17";
        StrReadFmt(z, "{o}", v);
        bool ok = (IntCompare(&v, 15) == 0);

In Write.c:4605:

        Int  v = IntInit(ALLOCATOR_OF(&alloc));
        Zstr z = "   42";
        StrReadFmt(z, "{}", v);
        bool ok = (IntCompare(&v, 42) == 0);

In Read.c:78:

        i8 i8_val = 0;
        z         = "-42";
        StrReadFmt(z, "{}", i8_val);
        success = success && (i8_val == -42);

In Read.c:83:

        i16 i16_val = 0;
        z           = "-1234";
        StrReadFmt(z, "{}", i16_val);
        success = success && (i16_val == -1234);

In Read.c:88:

        i32 i32_val = 0;
        z           = "-123456";
        StrReadFmt(z, "{}", i32_val);
        success = success && (i32_val == -123456);

In Read.c:93:

        i64 i64_val = 0;
        z           = "-1234567890";
        StrReadFmt(z, "{}", i64_val);
        success = success && (i64_val == -1234567890LL);

In Read.c:98:

        u8 u8_val = 0;
        z         = "42";
        StrReadFmt(z, "{}", u8_val);
        success = success && (u8_val == 42);

In Read.c:103:

        u16 u16_val = 0;
        z           = "1234";
        StrReadFmt(z, "{}", u16_val);
        success = success && (u16_val == 1234);

In Read.c:108:

        u32 u32_val = 0;
        z           = "123456";
        StrReadFmt(z, "{}", u32_val);
        success = success && (u32_val == 123456);

In Read.c:113:

        u64 u64_val = 0;
        z           = "1234567890";
        StrReadFmt(z, "{}", u64_val);
        success = success && (u64_val == 1234567890ULL);

In Read.c:118:

        i8_val = 0;
        z      = "127";
        StrReadFmt(z, "{}", i8_val);
        success = success && (i8_val == 127);

In Read.c:123:

        i8_val = 0;
        z      = "-128";
        StrReadFmt(z, "{}", i8_val);
        success = success && (i8_val == -128);

In Read.c:128:

        u8_val = 0;
        z      = "255";
        StrReadFmt(z, "{}", u8_val);
        success = success && (u8_val == 255);

In Read.c:133:

        u8_val = 0;
        z      = "0";
        StrReadFmt(z, "{}", u8_val);
        success = success && (u8_val == 0);

In Read.c:138:

        i32_val = 0;
        z       = "000042";
        StrReadFmt(z, "{}", i32_val);
        success = success && (i32_val == 42);

In Read.c:143:

        i32_val = 0;
        z       = "-000042";
        StrReadFmt(z, "{}", i32_val);
        success = success && (i32_val == -42);

In Read.c:148:

        i32_val = 0;
        z       = "   42";
        StrReadFmt(z, "{}", i32_val);
        success = success && (i32_val == 42);

In Read.c:153:

        i32_val = 0;
        z       = "42   ";
        StrReadFmt(z, "{}", i32_val);
        success = success && (i32_val == 42);

In Read.c:158:

        i32_val = 0;
        z       = "  42  ";
        StrReadFmt(z, "{}", i32_val);
        success = success && (i32_val == 42);

In Read.c:173:

        u32 val = 0;
        z       = "0xdeadbeef";
        StrReadFmt(z, "{}", val);
        success = success && (val == 0xdeadbeef);

In Read.c:178:

        val = 0;
        z   = "0xDEADBEEF";
        StrReadFmt(z, "{}", val);
        success = success && (val == 0xDEADBEEF);

In Read.c:183:

        val = 0;
        z   = "0x0";
        StrReadFmt(z, "{}", val);
        success = success && (val == 0);

In Read.c:188:

        val = 0;
        z   = "0xf";
        StrReadFmt(z, "{}", val);
        success = success && (val == 0xf);

In Read.c:193:

        val = 0;
        z   = "0xaBcDeF";
        StrReadFmt(z, "{}", val);
        success = success && (val == 0xabcdef);

In Read.c:208:

        i8 val = 0;
        z      = "0b101010";
        StrReadFmt(z, "{}", val);
        success = success && (val == 42);

In Read.c:213:

        val = 0;
        z   = "0b0";
        StrReadFmt(z, "{}", val);
        success = success && (val == 0);

In Read.c:218:

        val = 0;
        z   = "0b1";
        StrReadFmt(z, "{}", val);
        success = success && (val == 1);

In Read.c:233:

        i32 val = 0;
        z       = "0o755";
        StrReadFmt(z, "{}", val);
        success = success && (val == 0755);

In Read.c:238:

        val = 0;
        z   = "755";
        StrReadFmt(z, "{}", val);
        success = success && (val == 755);

In Read.c:243:

        val = 0;
        z   = "0o0";
        StrReadFmt(z, "{}", val);
        success = success && (val == 0);

In Read.c:248:

        val = 0;
        z   = "0o7";
        StrReadFmt(z, "{}", val);
        success = success && (val == 7);

In Read.c:263:

        f32 f32_val = 0.0f;
        z           = "3.14159";
        StrReadFmt(z, "{}", f32_val);
        success = success && float_equals(f32_val, 3.14159f);

In Read.c:268:

        f64 f64_val = 0.0;
        z           = "3.14159265359";
        StrReadFmt(z, "{}", f64_val);
        success = success && double_equals(f64_val, 3.14159265359);

In Read.c:273:

        f64_val = 1.0;
        z       = "0.0";
        StrReadFmt(z, "{}", f64_val);
        success = success && double_equals(f64_val, 0.0);

In Read.c:278:

        f64_val = 1.0;
        z       = "-0.0";
        StrReadFmt(z, "{}", f64_val);
        // -0.0 compares == to +0.0; the epsilon check captures the magnitude
        // regardless of which sign bit the parser landed on.

In Read.c:285:

        f64_val = 0.0;
        z       = "42.0";
        StrReadFmt(z, "{}", f64_val);
        success = success && double_equals(f64_val, 42.0);

In Read.c:290:

        f64_val = 0.0;
        z       = "0.42";
        StrReadFmt(z, "{}", f64_val);
        success = success && double_equals(f64_val, 0.42);

In Read.c:305:

        f64 val = 0.0;
        z       = "1.23e4";
        StrReadFmt(z, "{}", val);
        success = success && double_equals(val, 12300.0);

In Read.c:310:

        val = 0.0;
        z   = "1.23E4";
        StrReadFmt(z, "{}", val);
        success = success && double_equals(val, 12300.0);

In Read.c:315:

        val = 0.0;
        z   = "1.23e+4";
        StrReadFmt(z, "{}", val);
        success = success && double_equals(val, 12300.0);

In Read.c:320:

        val = 0.0;
        z   = "1.23e-4";
        StrReadFmt(z, "{}", val);
        success = success && double_equals(val, 0.000123);

In Read.c:325:

        val = 0.0;
        z   = "1.0e0";
        StrReadFmt(z, "{}", val);
        success = success && double_equals(val, 1.0);

In Read.c:330:

        val = 0.0;
        z   = "1.0E-0";
        StrReadFmt(z, "{}", val);
        success = success && double_equals(val, 1.0);

In Read.c:335:

        val = 0.0;
        z   = "1.0e+0";
        StrReadFmt(z, "{}", val);
        success = success && double_equals(val, 1.0);

In Read.c:353:

        Str s = StrInit(&alloc);
        z     = "Hello";
        StrReadFmt(z, "{}", s);
    
        Str expected = StrInitFromZstr("Hello", &alloc);

In Read.c:361:

    
        z = "\"Hello, World!\"";
        StrReadFmt(z, "{s}", s);
    
        expected = StrInitFromZstr("Hello, World!", &alloc);

In Read.c:371:

    
            z = "Allocator-backed";
            StrReadFmt(z, "{s}", ZstrIO(zs, alloc_base));
            success = success && (ZstrCompare(zs, "Allocator-backed") == 0);

In Read.c:375:

    
            z = "\"Allocator-backed replacement\"";
            StrReadFmt(z, "{s}", ZstrIO(zs, alloc_base));
            success = success && (ZstrCompare(zs, "Allocator-backed replacement") == 0);
            zstr_deinit(&zs, alloc_base);

In Read.c:398:

        Str name = StrInit(&alloc);
        z        = "Count: 42, Name: Alice";
        StrReadFmt(z, "Count: {}, Name: {}", num, name);
    
        success = success && (num == 42);

In Read.c:409:

        f64 val = 0.0;
        z       = "Value: 3.14, Name: Bob";
        StrReadFmt(z, "Value: {}, Name: {}", val, name);
    
        success = success && double_equals(val, 3.14);

In Read.c:434:

        i32 num = 42;
        z       = "Count: forty-two";
        StrReadFmt(z, "Count: {}", num);
        success = success && (num == 42);

In Read.c:439:

        num = 42;
        z   = "Count: abc";
        StrReadFmt(z, "Count: {}", num);
        success = success && (num == 42);

In Read.c:444:

        i8 small = 42;
        z        = "Value: 1000";
        StrReadFmt(z, "Value: {}", small);
        success = success && (small == 42);

In Read.c:461:

        u8 u8_val = 0;
        z         = "A";
        StrReadFmt(z, "{c}", u8_val);
        WriteFmt("u8_val = {}, expected = {}, pass = {}\n", u8_val, 'A', (u8_val == 'A') ? "true" : "false");
        success = success && (u8_val == 'A');

In Read.c:467:

        u8_val = 0;
        z      = "z";
        StrReadFmt(z, "{c}", u8_val);
        WriteFmt("u8_val = {}, expected = {}, pass = {}\n", u8_val, 'z', (u8_val == 'z') ? "true" : "false");
        success = success && (u8_val == 'z');

In Read.c:473:

        i8 i8_val = 0;
        z         = "B";
        StrReadFmt(z, "{c}", i8_val);
        WriteFmt("i8_val = {}, expected = {}, pass = {}\n", i8_val, 'B', (i8_val == 'B') ? "true" : "false");
        success = success && (i8_val == 'B');

In Read.c:479:

        i16 i16_val = 0;
        z           = "C";
        StrReadFmt(z, "{c}", i16_val);
        WriteFmt("i16_val = {}, expected = {}, pass = {}\n", i16_val, 'C', (i16_val == 'C') ? "true" : "false");
        success = success && (i16_val == 'C');

In Read.c:485:

        i32 i32_val = 0;
        z           = "D";
        StrReadFmt(z, "{c}", i32_val);
        WriteFmt("i32_val = {}, expected = {}, pass = {}\n", i32_val, 'D', (i32_val == 'D') ? "true" : "false");
        success = success && (i32_val == 'D');

In Read.c:491:

        i64 i64_val = 0;
        z           = "E";
        StrReadFmt(z, "{c}", i64_val);
        WriteFmt("i64_val = {}, expected = {}, pass = {}\n", i64_val, 'E', (i64_val == 'E') ? "true" : "false");
        success = success && (i64_val == 'E');

In Read.c:497:

        u16 u16_val = 0;
        z           = "F";
        StrReadFmt(z, "{c}", u16_val);
        WriteFmt("u16_val = {}, expected = {}, pass = {}\n", u16_val, 'F', (u16_val == 'F') ? "true" : "false");
        success = success && (u16_val == 'F');

In Read.c:503:

        u32 u32_val = 0;
        z           = "G";
        StrReadFmt(z, "{c}", u32_val);
        WriteFmt("u32_val = {}, expected = {}, pass = {}\n", u32_val, 'G', (u32_val == 'G') ? "true" : "false");
        success = success && (u32_val == 'G');

In Read.c:509:

        u64 u64_val = 0;
        z           = "H";
        StrReadFmt(z, "{c}", u64_val);
        WriteFmt("u64_val = {}, expected = {}, pass = {}\n", u64_val, 'H', (u64_val == 'H') ? "true" : "false");
        success = success && (u64_val == 'H');

In Read.c:515:

        u16_val = 0;
        z       = "AB";
        StrReadFmt(z, "{c}", u16_val);
        bool u16_multi_pass = (ZstrCompareN((Zstr)&u16_val, "AB", 2) == 0);
        WriteFmt("u16_val multi-char test: comparing memory with 'AB', pass = {}\n", u16_multi_pass ? "true" : "false");

In Read.c:529:

        i16_val = 0;
        z       = "CD";
        StrReadFmt(z, "{c}", i16_val);
        bool i16_multi_pass = (ZstrCompareN((Zstr)&i16_val, "CD", 2) == 0);
        WriteFmt("i16_val multi-char test: comparing memory with 'CD', pass = {}\n", i16_multi_pass ? "true" : "false");

In Read.c:536:

        u32_val = 0;
        z       = "EFGH";
        StrReadFmt(z, "{c}", u32_val);
        bool u32_multi_pass = (ZstrCompareN((Zstr)&u32_val, "EFGH", 4) == 0);
        WriteFmt("u32_val multi-char test: comparing memory with 'EFGH', pass = {}\n", u32_multi_pass ? "true" : "false");

In Read.c:543:

        i32_val = 0;
        z       = "IJKL";
        StrReadFmt(z, "{c}", i32_val);
        bool i32_multi_pass = (ZstrCompareN((Zstr)&i32_val, "IJKL", 4) == 0);
        WriteFmt("i32_val multi-char test: comparing memory with 'IJKL', pass = {}\n", i32_multi_pass ? "true" : "false");

In Read.c:550:

        u64_val = 0;
        z       = "MNOPQRST";
        StrReadFmt(z, "{c}", u64_val);
        bool u64_multi_pass = (ZstrCompareN((Zstr)&u64_val, "MNOPQRST", 8) == 0);
        WriteFmt(

In Read.c:560:

        i64_val = 0;
        z       = "UVWXYZab";
        StrReadFmt(z, "{c}", i64_val);
        bool i64_multi_pass = (ZstrCompareN((Zstr)&i64_val, "UVWXYZab", 8) == 0);
        WriteFmt(

In Read.c:570:

        f32 f32_val = 0.0f;
        z           = "A";
        StrReadFmt(z, "{c}", f32_val);
        bool f32_pass = (f32_val == (f32)'A');
        WriteFmt("f32_val = {}, expected = {}, pass = {}\n", f32_val, (f32)'A', f32_pass ? "true" : "false");

In Read.c:577:

        f64 f64_val = 0.0;
        z           = "B";
        StrReadFmt(z, "{c}", f64_val);
        bool f64_pass = (f64_val == (f64)'B');
        WriteFmt("f64_val = {}, expected = {}, pass = {}\n", f64_val, (f64)'B', f64_pass ? "true" : "false");

In Read.c:584:

        u8_val = 0;
        z      = "~";
        StrReadFmt(z, "{c}", u8_val);
        bool tilde_pass = (u8_val == '~');
        WriteFmt("u8_val = {}, expected = {} (~), pass = {}\n", u8_val, '~', tilde_pass ? "true" : "false");

In Read.c:591:

        u32_val = 0;
        z       = "XY";
        StrReadFmt(z, "{c}", u32_val);
        bool xy_pass = (ZstrCompareN((Zstr)&u32_val, "XY", 2) == 0);
        WriteFmt("u32_val partial test: comparing memory with 'XY', pass = {}\n", xy_pass ? "true" : "false");

In Read.c:598:

        u64_val = 0;
        z       = "abc";
        StrReadFmt(z, "{c}", u64_val);
        bool abc_pass = (ZstrCompareN((Zstr)&u64_val, "abc", 3) == 0);
        WriteFmt("u64_val partial test: comparing memory with 'abc', pass = {}\n", abc_pass ? "true" : "false");

In Read.c:605:

        Str str_val = StrInit(&alloc);
        z           = "Hello";
        StrReadFmt(z, "{c}", str_val);
        Str  expected = StrInitFromZstr("Hello", &alloc);
        bool str_pass = (StrCmp(&str_val, &expected) == 0);

In Read.c:615:

        str_val = StrInit(&alloc);
        z       = "\"World\"";
        StrReadFmt(z, "{cs}", str_val);
        expected             = StrInitFromZstr("World", &alloc);
        bool quoted_str_pass = (StrCmp(&str_val, &expected) == 0);

In Read.c:643:

    
            z = in;
            StrReadFmt(z, "{a}", result);
    
            WriteFmt("Test 1 - :a (lowercase)\n");

In Read.c:668:

    
            z = in;
            StrReadFmt(z, "{as}", result);
    
            WriteFmt("Test 1.1 - :as (lowercase string single word)\n");

In Read.c:693:

    
            z = in;
            StrReadFmt(z, "{A}", result);
    
            WriteFmt("Test 2 - :A (uppercase)\n");

In Read.c:719:

    
            z = in;
            StrReadFmt(z, "{A} {A}", result1, result2);
    
            WriteFmt("Test 2 - :A (uppercase with split format)\n");

In Read.c:740:

    
            z = in;
            StrReadFmt(z, "{As}{A}", result1, result2);
            // result1 must consume first word only
            // result2 must consume the space after hello and then everything after it

In Read.c:762:

    
            z = in;
            StrReadFmt(z, "{as}", result);
    
            WriteFmt("Test 3 - :a with quoted string\n");

In Read.c:787:

    
            z = in;
            StrReadFmt(z, "{As}", result);
    
            WriteFmt("Test 4 - :A with mixed alphanumeric\n");

In Read.c:812:

    
            z = in;
            StrReadFmt(z, "{c}", result);
    
            WriteFmt("Test 5 - :c (no case conversion)\n");

In Read.c:848:

        BitVec bv1 = BitVecInit(alloc_base);
        z          = "10110";
        StrReadFmt(z, "{}", bv1);
        Str result1 = BitVecToStr(&bv1);
        success     = success && (ZstrCompare(StrBegin(&result1), "10110") == 0);

In Read.c:861:

        BitVec bv2 = BitVecInit(alloc_base);
        z          = "0xDEAD";
        StrReadFmt(z, "{}", bv2);
        u64 value2 = BitVecToInteger(&bv2);
        success    = success && (value2 == 0xDEAD);

In Read.c:869:

        BitVec bv3 = BitVecInit(alloc_base);
        z          = "0o755";
        StrReadFmt(z, "{}", bv3);
        u64 value3 = BitVecToInteger(&bv3);
        success    = success && (value3 == 0755);

In Read.c:877:

        BitVec bv4 = BitVecInit(alloc_base);
        z          = "   1101";
        StrReadFmt(z, "{}", bv4);
        Str result4 = BitVecToStr(&bv4);
        success     = success && (ZstrCompare(StrBegin(&result4), "1101") == 0);

In Read.c:890:

        BitVec bv5 = BitVecInit(alloc_base);
        z          = "0";
        StrReadFmt(z, "{}", bv5);
        Str result5 = BitVecToStr(&bv5);
        success     = success && (ZstrCompare(StrBegin(&result5), "0") == 0);

In Read.c:926:

    
        z = "123456789012345678901234567890";
        StrReadFmt(z, "{}", dec);
        dec_text = IntToStr(&dec);
        success  = success && (ZstrCompare(StrBegin(&dec_text), "123456789012345678901234567890") == 0);

In Read.c:931:

    
        z = "deadbeefcafebabe1234";
        StrReadFmt(z, "{x}", hex);
        hex_text = IntToHexStr(&hex);
        success  = success && (ZstrCompare(StrBegin(&hex_text), "deadbeefcafebabe1234") == 0);

In Read.c:936:

    
        z = "10100011";
        StrReadFmt(z, "{b}", bin);
        bin_text = IntToBinary(&bin);
        success  = success && (ZstrCompare(StrBegin(&bin_text), "10100011") == 0);

In Read.c:941:

    
        z = "755";
        StrReadFmt(z, "{o}", oct);
        oct_text = IntToOctStr(&oct);
        success  = success && (ZstrCompare(StrBegin(&oct_text), "755") == 0);

In Read.c:976:

    
        z = "1234567890.012345";
        StrReadFmt(z, "{}", dec);
        dec_text = FloatToStr(&dec);
        success  = success && (ZstrCompare(StrBegin(&dec_text), "1234567890.012345") == 0);

In Read.c:981:

    
        z = "1.234567e+04";
        StrReadFmt(z, "{e}", sci);
        sci_text = FloatToStr(&sci);
        success  = success && (ZstrCompare(StrBegin(&sci_text), "12345.67") == 0);

In Read.c:986:

    
        z = "-0.00125";
        StrReadFmt(z, "{}", neg);
        neg_text = FloatToStr(&neg);
        success  = success && (ZstrCompare(StrBegin(&neg_text), "-0.00125") == 0);

In Read.c:1144:

        Zstr z = "42!";
        u8   v = 0;
        StrReadFmt(z, "{}", v);
        // Live: v == 42 and z advanced past "42" (now points at "!").
        return v == 42 && z[0] == '!';

In Read.c:1162:

        Zstr beg = z;
        u8   v   = 0;
        StrReadFmt(z, "{c}", v);
        bool ok = (v == 0x41);     // 'A'; mutants give 0x5C ('\') or 42 ('*')
        ok      = ok && (*z == 0); // all 4 bytes consumed; mutants leave "x41"

In Read.c:1175:

        Zstr z = "\\x00";      // '\', 'x', '0', '0'
        u8   v = 0xAA;         // poison so a no-write is detectable too
        StrReadFmt(z, "{c}", v);
        bool ok = (v == 0x00); // mutant stores 0x5C ('\')
        ok      = ok && (*z == 0);

In Read.c:1190:

        Zstr z = "\\x";              // '\', 'x', then NUL
        u8   v = 0;
        StrReadFmt(z, "{c}", v);
        bool ok = (v == 0x5C);       // '\' salvaged; mutants store 42 ('*')
        ok      = ok && (*z == 'x'); // only the '\' consumed

In Read.c:1535:

        Zstr start = input;
        u16  v     = 0;
        StrReadFmt(input, "{>2r}", v); // advances `input` on success
        return (input != start) && (v == 0x1234);
    }

In Read.c:1550:

        u16  v        = 0;
        u16  expected = IS_LITTLE_ENDIAN() ? (u16)0x3412 : (u16)0x1234;
        StrReadFmt(input, "{^2r}", v); // real: resolves NATIVE; mutant: LOG_FATAL
        return (input != start) && (v == expected);
    }

In Read.c:1582:

        i32  v = 0;
        Zstr z = "+5";
        StrReadFmt(z, "{}", v);
        return v == 5;
    }

In Read.c:1620:

        f32  v = 7.5f;
        Zstr z = "1f";
        StrReadFmt(z, "{}", v);
        // Real rejects "1f" -> v stays 7.5. Mutant bypasses the gate.
        ok = ok && (v == 7.5f);

In Read.c:1694:

        f32  v = 0.0f;
        Zstr z = "A";
        StrReadFmt(z, "{c}", v); // 'A' == 0x41 == 65
        return f32_close(v, 65.0f);
    }

In Read.c:1706:

        f32  v = 0.0f;
        Zstr z = "12g3";
        StrReadFmt(z, "{}", v);
        return f32_close(v, 12.0f);
    }

In Read.c:1724:

        Str  s = StrInit(&alloc);
        Zstr z = "\\x41BC"; // backslash, x, 4, 1, B, C  ->  'A', 'B', 'C'
        StrReadFmt(z, "{}", s);
    
        Str  expected = StrInitFromZstr("ABC", &alloc);

In Read.c:1745:

        Str  s = StrInit(&alloc);
        Zstr z = "\\x41"; // -> 'A'
        StrReadFmt(z, "{}", s);
    
        Str  expected = StrInitFromZstr("A", &alloc);

In Read.c:1766:

        Str  s = StrInit(&alloc);
        Zstr z = "\\x61";                             // -> 'a'
        StrReadFmt(z, "{A}", s);
    
        Str  expected = StrInitFromZstr("A", &alloc); // uppercased

In Read.c:1790:

        // "\x41BC" inside double quotes -> decoded "ABC"
        Zstr z = "\"\\x41BC\"";
        StrReadFmt(z, "{s}", s);
    
        Str  expected = StrInitFromZstr("ABC", &alloc);

In Read.c:1810:

        Str  s = StrInit(&alloc);
        Zstr z = "\"\\x41\""; // quoted -> 'A'
        StrReadFmt(z, "{s}", s);
    
        Str  expected = StrInitFromZstr("A", &alloc);

In Read.c:1830:

        Str  s = StrInit(&alloc);
        Zstr z = "\"\\x61\"";                         // quoted -> 'a'
        StrReadFmt(z, "{As}", s);
    
        Str  expected = StrInitFromZstr("A", &alloc); // uppercased

In Read.c:1995:

            Zstr     in = "2021-01-01T00:00:00Z";
            DateTime d  = {0};
            StrReadFmt(in, "{}", d);
            ok = ok && d.year == 2021 && d.month == 1 && d.day == 1 && d.hour == 0 && d.minute == 0 && d.second == 0 &&
                 d.nanosecond == 0 && d.utc_offset_seconds == 0 && d.weekday == 5 /* Friday, derived on parse */;

In Read.c:2002:

            Zstr     in = "2021-01-01T05:30:00+05:30";
            DateTime d  = {0};
            StrReadFmt(in, "{}", d);
            ok = ok && d.year == 2021 && d.hour == 5 && d.minute == 30 && d.utc_offset_seconds == 19800;
        }

In Read.c:2008:

            Zstr     in = "2020-12-31T14:30:00-09:30";
            DateTime d  = {0};
            StrReadFmt(in, "{}", d);
            ok = ok && d.year == 2020 && d.month == 12 && d.day == 31 && d.hour == 14 && d.minute == 30 &&
                 d.utc_offset_seconds == -34200;

In Read.c:2015:

            Zstr     in = "2021-01-01T00:00:00.123456789Z";
            DateTime d  = {0};
            StrReadFmt(in, "{}", d);
            ok = ok && d.nanosecond == 123456789 && d.utc_offset_seconds == 0;
        }

In Read.c:2027:

        Zstr p     = "ff";
        Zstr start = p;
        StrReadFmt(p, "{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}", v); // exactly 32 'x'
        return (p == start) && (v == 0);
    }

In Read.c:2035:

        Zstr p     = "5";
        Zstr start = p;
        StrReadFmt(p, "{11111111111111111111111111111111}", v); // valid 32-char width spec
        return (p == start) && (v == 999);
    }

In Read.c:2046:

        Str              out = StrInit(ALLOCATOR_OF(&a));
        Zstr             p   = "\\n\\n#rest";
        StrReadFmt(p, "{}#", out);
        bool ok = (StrLen(&out) == 2) && (StrBegin(&out)[0] == '\n') && (StrBegin(&out)[1] == '\n');
        StrDeinit(&out);

In Read.c:2060:

        {
            Zstr p = "0xff";
            StrReadFmt(p, "{}", v);
            if (v != 255)
                return false;

In Read.c:2071:

            Zstr start = p;
            u8   w     = 7;
            StrReadFmt(p, "{}", w);
            if (p != start || w != 7) // real: read fails, cursor + dest untouched
                return false;

In Read.c:2087:

        // read; the `max_read_len = rem_in` survivor would cap it at 42.
        Zstr p = "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\""; // 50 'a' quoted
        StrReadFmt(p, "{s}", out);
        bool ok = (StrLen(&out) == 50);
        StrDeinit(&out);

In Read.c:2116:

        Float            f     = FloatInit(ab);
        (void)FloatTryFromStr(&f, "99"); // sentinel
        StrReadFmt(in, "{}", f);
        Str  t  = FloatToStr(&f);
        bool ok = (ZstrCompare(StrBegin(&t), expect) == 0);

In Read.c:2278:

        f64  v = SENTINEL;
        Zstr z = "inf";
        StrReadFmt(z, "{}", v);
        return F64IsInf(v) && v > 0;
    }

In Read.c:2287:

        f64  a = SENTINEL, b = SENTINEL, c = SENTINEL;
        Zstr za = "INF", zb = "nan", zc = "NaN";
        StrReadFmt(za, "{}", a);
        StrReadFmt(zb, "{}", b);
        StrReadFmt(zc, "{}", c);

In Read.c:2288:

        Zstr za = "INF", zb = "nan", zc = "NaN";
        StrReadFmt(za, "{}", a);
        StrReadFmt(zb, "{}", b);
        StrReadFmt(zc, "{}", c);
        return F64IsInf(a) && F64IsNan(b) && F64IsNan(c);

In Read.c:2289:

        StrReadFmt(za, "{}", a);
        StrReadFmt(zb, "{}", b);
        StrReadFmt(zc, "{}", c);
        return F64IsInf(a) && F64IsNan(b) && F64IsNan(c);
    }

In Read.c:2297:

        f64  a = SENTINEL, b = SENTINEL;
        Zstr za = "-inf", zb = "-INF";
        StrReadFmt(za, "{}", a);
        StrReadFmt(zb, "{}", b);
        return F64IsInf(a) && a < 0 && F64IsInf(b) && b < 0;

In Read.c:2298:

        Zstr za = "-inf", zb = "-INF";
        StrReadFmt(za, "{}", a);
        StrReadFmt(zb, "{}", b);
        return F64IsInf(a) && a < 0 && F64IsInf(b) && b < 0;
    }

In Read.c:2307:

        f64  v = SENTINEL;
        Zstr z = "1234";
        StrReadFmt(z, "{}", v);
        return f64_is(v, 1234.0);
    }

In Read.c:2320:

        f64  v = SENTINEL;
        Zstr z = "0x1f";
        StrReadFmt(z, "{}", v);
        // accepted -> StrToF64("0x1f") parses leading 0 -> 0.0.
        return f64_is(v, 0.0);

In Read.c:2328:

        f64  v = SENTINEL;
        Zstr z = "0b11";
        StrReadFmt(z, "{}", v);
        return f64_is(v, 0.0);
    }

In Read.c:2335:

        f64  v = SENTINEL;
        Zstr z = "0o7";
        StrReadFmt(z, "{}", v);
        return f64_is(v, 0.0);
    }

In Read.c:2345:

        f64  v = SENTINEL;
        Zstr z = "0b101";
        StrReadFmt(z, "{}", v);
        return f64_is(v, 0.0);
    }

In Read.c:2352:

        f64  v = SENTINEL;
        Zstr z = "0o17";
        StrReadFmt(z, "{}", v);
        return f64_is(v, 0.0);
    }

In Read.c:2361:

        f64  v = SENTINEL;
        Zstr z = "0o70";
        StrReadFmt(z, "{}", v);
        return f64_is(v, 0.0);
    }

In Read.c:2372:

        f64  v = SENTINEL;
        Zstr z = "1e+5";
        StrReadFmt(z, "{}", v);
        return f64_is(v, 100000.0);
    }

In Read.c:2382:

        f64  v = SENTINEL;
        Zstr z = "1.2.3";
        StrReadFmt(z, "{}", v);
        // The f64 scanner stops the token at the 2nd '.', so the slice is "1.2" and
        // parses to 1.2, leaving ".3" unconsumed.  has_decimal must gate so a

In Read.c:2396:

        f64  v = SENTINEL;
        Zstr z = "12e";
        StrReadFmt(z, "{}", v);
        return f64_is(v, 12.0);
    }

In Read.c:2515:

        BitVec         bv  = BitVecInit(&dbg.base);
        Zstr           z   = "0x1";
        StrReadFmt(z, "{}", bv);
        bool ok = (BitVecToInteger(&bv) == 1) && (BitVecLen(&bv) == 4); // min-width clamp
        BitVecDeinit(&bv);

In Read.c:2528:

        BitVec           bv    = BitVecInit(&alloc.base);
        Zstr             z     = "0xDEAD";
        StrReadFmt(z, "{}", bv);
        bool ok = (BitVecToInteger(&bv) == 0xDEAD) && (BitVecLen(&bv) == 16);
        BitVecDeinit(&bv);

In Read.c:2540:

        BitVec         bv  = BitVecInit(&dbg.base);
        Zstr           z   = "0o1";
        StrReadFmt(z, "{}", bv);
        bool ok = (BitVecToInteger(&bv) == 1) && (BitVecLen(&bv) == 3);
        BitVecDeinit(&bv);

In Read.c:2553:

        BitVec         bv  = BitVecInit(&dbg.base);
        Zstr           z   = "10110";
        StrReadFmt(z, "{}", bv);
        bool ok = (BitVecLen(&bv) == 5) && (BitVecToInteger(&bv) == 13);
        BitVecDeinit(&bv);

In Read.c:2567:

        Int            v   = IntInit(&dbg.base);
        Zstr           z   = "12345";
        StrReadFmt(z, "{}", v);
        Str  t  = IntToStr(&v);
        bool ok = (ZstrCompare(StrBegin(&t), "12345") == 0);

In Read.c:2582:

        Int              v     = IntInit(&alloc.base);
        Zstr             z     = "+99";
        StrReadFmt(z, "{}", v);
        Str  t  = IntToStr(&v);
        bool ok = (ZstrCompare(StrBegin(&t), "99") == 0);

In Read.c:2598:

        Int              v     = IntInit(&alloc.base);
        Zstr             z     = "ff";
        StrReadFmt(z, "{x}", v);
        Str  t  = IntToStr(&v);
        bool ok = (ZstrCompare(StrBegin(&t), "255") == 0);

In Read.c:2634:

        Float          f   = FloatInit(&dbg.base);
        Zstr           z   = "3.14159";
        StrReadFmt(z, "{}", f);
        Str  t  = FloatToStr(&f);
        bool ok = (ZstrCompare(StrBegin(&t), "3.14159") == 0);

In Read.c:2733:

        Str            s   = StrInit(ALLOCATOR_OF(&dbg));
        Zstr           p   = input;
        StrReadFmt(p, fmt, s); // reader frees s on the unterminated/error branch
        bool ok = (DebugAllocatorLiveCount(&dbg) == 0) && (DebugAllocatorLiveBytes(&dbg) == 0);
        DebugAllocatorDeinit(&dbg);

In Read.c:2745:

        BitVec         bv  = BitVecInit(ALLOCATOR_OF(&dbg));
        Zstr           p   = input;
        StrReadFmt(p, "{}", bv);
        BitVecDeinit(&bv);
        bool ok = (DebugAllocatorLiveCount(&dbg) == 0) && (DebugAllocatorLiveBytes(&dbg) == 0);

In Read.c:2773:

        Str            s   = StrInit(ALLOCATOR_OF(&dbg));
        Zstr           p   = "aaaaaaaaaaaaaaaaaaaaaaaa\\q"; // 24 'a' + invalid \q
        StrReadFmt(p, "{}", s);
        bool ok = (DebugAllocatorLiveCount(&dbg) == 0) && (DebugAllocatorLiveBytes(&dbg) == 0);
        DebugAllocatorDeinit(&dbg);

In Read.c:2793:

        Float          fv  = FloatInit(ALLOCATOR_OF(&dbg));
        Zstr           p   = "1e99999999999999999999999999999999999999999999999999";
        StrReadFmt(p, "{}", fv);
        FloatDeinit(&fv);
        bool ok = (DebugAllocatorLiveCount(&dbg) == 0) && (DebugAllocatorLiveBytes(&dbg) == 0);

In Read.c:2825:

        Zstr input = "42";
        Zstr start = input;
        StrReadFmt(input, "{}", value);
        bool ok = (input != start); // pointer advanced => read succeeded

In Read.c:2852:

        Zstr input = "2.5";
        Zstr start = input;
        StrReadFmt(input, "{}", value);
        bool ok = (input != start); // pointer advanced => read succeeded

Last updated on July 1, 2026

StrPatchFmt StrWriteFmt