StrIterFromStr

Documentation

API Reference

StrIterFromStr

Description

Construct a forward-walking StrIter from a Str value. Alias- reframe of IterInitFromVec in string vocabulary: Str is a Vec(char), so the borrowed-data semantics and NULL-allocator alignment fallback documented on IterInitFromVec apply unchanged.

Parameters

Name	Direction	Description
`s`	in	Source string (by value – the resulting iter holds a non-owning pointer into `s`’s buffer).

Success

Returns a struct-literal StrIter covering [StrBegin(&s), StrBegin(&s) + StrLen(&s)) with pos = 0, dir = 1.

Failure

Macro cannot fail; an empty Str yields a remaining- length-0 iterator.

Usage example (Cross-references)

Usage examples (Cross-references)

In Dns.c:161:

        }
    
        StrIter si = StrIterFromStr(buf);
        char    c;
        while (StrIterRemainingLength(&si)) {

In Dns.c:259:

        u64               kw_len       = sizeof(NS_KEYWORD) - 1;
    
        StrIter si = StrIterFromStr(buf);
        char    c;
        while (StrIterRemainingLength(&si)) {

In ProcMaps.c:174:

        // `StrResize`/`StrReserve` keep a NUL sentinel at index `length`, so path
        // slices that alias the buffer are usable as `Zstr`.
        StrIter si = StrIterFromStr(out->raw);
        while (StrIterRemainingLength(&si)) {
            ProcMapEntry e = {0};

In Read.Simple.c:68:

        bool    success = true;
        Str     json    = StrInitFromZstr("{\"name\": \"Alice\", \"city\": \"New York\"}", &alloc);
        StrIter si      = StrIterFromStr(json);
    
        Str name = StrInit(&alloc);

In Read.Simple.c:111:

        bool    success = true;
        Str     json    = StrInitFromZstr("{\"count\": 42, \"score\": 95.5, \"year\": 2024}", &alloc);
        StrIter si      = StrIterFromStr(json);
    
        u32 count = 0;

In Read.Simple.c:151:

        bool    success = true;
        Str     json    = StrInitFromZstr("{\"enabled\": true, \"visible\": false}", &alloc);
        StrIter si      = StrIterFromStr(json);
    
        bool enabled = false;

In Read.Simple.c:187:

            &alloc
        );
        StrIter si = StrIterFromStr(json);
    
        Person person = {0};

In Read.Simple.c:243:

        bool    success = true;
        Str     json    = StrInitFromZstr("{\"debug_mode\": false, \"timeout\": 30, \"log_level\": \"INFO\"}", &alloc);
        StrIter si      = StrIterFromStr(json);
    
        Config config    = {0};

In Read.Simple.c:287:

        bool    success = true;
        Str     json    = StrInitFromZstr("{\"languages\": [\"C\", \"Python\", \"Rust\"]}", &alloc);
        StrIter si      = StrIterFromStr(json);
    
        Vec(Str) languages = VecInitWithDeepCopy(NULL, StrDeinit, &alloc);

In Read.Simple.c:354:

            &alloc
        );
        StrIter si = StrIterFromStr(json);
    
        struct {

In Read.Simple.c:417:

            &alloc
        );
        StrIter si = StrIterFromStr(json);
    
        SimpleProduct product = {0};

In Read.Nested.c:114:

    
        Str     json = StrInitFromZstr("{\"test\": \"value\"}", &alloc);
        StrIter si   = StrIterFromStr(json);
    
        bool success = true;

In Read.Nested.c:142:

        bool    success = true;
        Str     json    = StrInitFromZstr("{\"id\": 12345, \"name\": \"test\", \"active\": true, \"score\": 98.5}", &alloc);
        StrIter si      = StrIterFromStr(json);
    
        struct {

In Read.Nested.c:199:

            &alloc
        );
        StrIter si = StrIterFromStr(json);
    
        struct {

In Read.Nested.c:273:

            &alloc
        );
        StrIter si = StrIterFromStr(json);
    
        struct {

In Read.Nested.c:356:

            &alloc
        );
        StrIter si = StrIterFromStr(json);
    
        typedef Vec(AnnSymbol) Symbols;

In Read.Nested.c:461:

            &alloc
        );
        StrIter si = StrIterFromStr(json);
    
        ApiResponse response = {false, StrInit(&alloc), VecInitWithDeepCopy(NULL, AnnSymbolDeinit, &alloc)};

In Read.Nested.c:606:

        bool    success = true;
        Str     json = StrInitFromZstr("{\"id\": 12345, \"name\": \"test_func\", \"size\": 1024, \"vaddr\": 4096}", &alloc);
        StrIter si   = StrIterFromStr(json);
    
        FunctionInfo info = {0};

In Read.Nested.c:656:

        bool    success = true;
        Str     json    = StrInitFromZstr("{\"id\": 54321, \"name\": \"test_model\"}", &alloc);
        StrIter si      = StrIterFromStr(json);
    
        ModelInfo info = {0};

In Read.Nested.c:698:

            &alloc
        );
        StrIter si = StrIterFromStr(json);
    
        SearchResult result = {0};

In Read.Nested.c:791:

            &alloc
        );
        StrIter si = StrIterFromStr(json);
    
        ApiResponse response = {false, StrInit(&alloc), VecInitWithDeepCopy(NULL, AnnSymbolDeinit, &alloc)};

In Read.Nested.c:964:

            &alloc
        );
        StrIter si = StrIterFromStr(json);
    
        ApiResponse response = {false, StrInit(&alloc), VecInitWithDeepCopy(NULL, AnnSymbolDeinit, &alloc)};

In Read.EdgeCases.c:67:

        // Test completely empty object
        Str     json1 = StrInitFromZstr("{}", &alloc);
        StrIter si1   = StrIterFromStr(json1);
    
        struct {

In Read.EdgeCases.c:87:

        // Test empty object with whitespace
        Str     json2 = StrInitFromZstr("  {   }  ", &alloc);
        StrIter si2   = StrIterFromStr(json2);
    
        struct {

In Read.EdgeCases.c:119:

        // Test completely empty array
        Str     json1 = StrInitFromZstr("{\"items\":[]}", &alloc);
        StrIter si1   = StrIterFromStr(json1);
    
        Vec(i32) items = VecInit(&alloc);

In Read.EdgeCases.c:140:

        // Test empty array with whitespace
        Str     json2 = StrInitFromZstr("{\"data\": [  ] }", &alloc);
        StrIter si2   = StrIterFromStr(json2);
    
        Vec(Str) data = VecInitWithDeepCopy(NULL, StrDeinit, &alloc);

In Read.EdgeCases.c:176:

    
        Str     json = StrInitFromZstr("{\"name\":\"\",\"description\":\"\"}", &alloc);
        StrIter si   = StrIterFromStr(json);
    
        struct {

In Read.EdgeCases.c:215:

    
        Str     json = StrInitFromZstr("{\"temp\":-25,\"balance\":-1000.50,\"delta\":-0.001}", &alloc);
        StrIter si   = StrIterFromStr(json);
    
        struct {

In Read.EdgeCases.c:264:

            &alloc
        );
        StrIter si = StrIterFromStr(json);
    
        struct {

In Read.EdgeCases.c:307:

    
        Str     json = StrInitFromZstr("{\"int_zero\":0,\"float_zero\":0.0,\"bool_false\":false}", &alloc);
        StrIter si   = StrIterFromStr(json);
    
        struct {

In Read.EdgeCases.c:357:

            &alloc
        );
        StrIter si = StrIterFromStr(json);
    
        struct {

In Read.EdgeCases.c:431:

            &alloc
        );
        StrIter si = StrIterFromStr(json);
    
        struct {

In Read.EdgeCases.c:519:

        // Test with lots of different whitespace patterns
        Str     json = StrInitFromZstr("  {\n\t\"name\"  :  \"test\"  ,\n  \"value\": 42\t,\"flag\"\n:\ntrue\n}\t", &alloc);
        StrIter si   = StrIterFromStr(json);
    
        struct {

In Read.EdgeCases.c:565:

    
        Str     json = StrInitFromZstr("{\"outer\":{},\"list\":[],\"deep\":{\"inner\":{}}}", &alloc);
        StrIter si   = StrIterFromStr(json);
    
        struct {

In Read.EdgeCases.c:615:

        Str json =
            StrInitFromZstr("{\"empty_obj\":{},\"filled_obj\":{\"x\":1},\"empty_arr\":[],\"filled_arr\":[1,2]}", &alloc);
        StrIter si = StrIterFromStr(json);
    
        struct {

In Read.EdgeCases.c:680:

        // Using smaller values that are safer to work with
        Str json   = StrInitFromZstr("{\"max_int\":2147483647,\"min_int\":-2147483648,\"one\":1,\"minus_one\":-1}", &alloc);
        StrIter si = StrIterFromStr(json);
    
        struct {

In Read.EdgeCases.c:730:

        Str json =
            StrInitFromZstr("{\"tiny\":0.000001,\"huge\":999999.999999,\"zero\":0.0,\"negative_tiny\":-0.000001}", &alloc);
        StrIter si = StrIterFromStr(json);
    
        struct {

In Read.EdgeCases.c:783:

        {
            Str     j   = StrInitFromZstr("tru3", &alloc);
            StrIter si  = StrIterFromStr(j);
            bool    b   = true;
            StrIter out = JReadBool(si, &b);

In Read.EdgeCases.c:794:

        {
            Str     j   = StrInitFromZstr("fXlse", &alloc);
            StrIter si  = StrIterFromStr(j);
            bool    b   = true;
            StrIter out = JReadBool(si, &b);

In Read.EdgeCases.c:806:

        {
            Str     j   = StrInitFromZstr("tr", &alloc);
            StrIter si  = StrIterFromStr(j);
            bool    b   = true;
            StrIter out = JReadBool(si, &b);

In Read.EdgeCases.c:818:

        {
            Str     j       = StrInitFromZstr("nuXX", &alloc);
            StrIter si      = StrIterFromStr(j);
            bool    is_null = true;
            StrIter out     = JReadNull(si, &is_null);

In Read.EdgeCases.c:841:

        {
            Str     j   = StrInitFromZstr("true rest", &alloc);
            StrIter si  = StrIterFromStr(j);
            bool    b   = false;
            StrIter out = JReadBool(si, &b);

In Read.EdgeCases.c:853:

        {
            Str     j   = StrInitFromZstr("false rest", &alloc);
            StrIter si  = StrIterFromStr(j);
            bool    b   = true;
            StrIter out = JReadBool(si, &b);

In Read.EdgeCases.c:864:

        {
            Str     j       = StrInitFromZstr("null rest", &alloc);
            StrIter si      = StrIterFromStr(j);
            bool    is_null = false;
            StrIter out     = JReadNull(si, &is_null);

In Read.EdgeCases.c:879:

        {
            Str     j   = StrInitFromZstr("true", &alloc);
            StrIter si  = StrIterFromStr(j);
            bool    b   = false;
            StrIter out = JReadBool(si, &b);

In Read.EdgeCases.c:890:

        {
            Str     j   = StrInitFromZstr("false", &alloc);
            StrIter si  = StrIterFromStr(j);
            bool    b   = true;
            StrIter out = JReadBool(si, &b);

In Read.EdgeCases.c:901:

        {
            Str     j       = StrInitFromZstr("null", &alloc);
            StrIter si      = StrIterFromStr(j);
            bool    is_null = false;
            StrIter out     = JReadNull(si, &is_null);

In Read.EdgeCases.c:928:

        for (u64 i = 0; i < sizeof(cases) / sizeof(cases[0]); i++) {
            Str     j   = StrInitFromZstr(cases[i], &alloc);
            StrIter si  = StrIterFromStr(j);
            Str     out = StrInit(&alloc);
            StrIter r   = JReadString(si, &out);

In Read.EdgeCases.c:947:

        {
            Str     j   = StrInitFromZstr("\"a\\u00e9b\"", &alloc);
            StrIter si  = StrIterFromStr(j);
            Str     out = StrInit(&alloc);
            StrIter r   = JReadString(si, &out);

In Read.EdgeCases.c:966:

        {
            Str     j   = StrInitFromZstr("\"plain\"", &alloc);
            StrIter si  = StrIterFromStr(j);
            Str     out = StrInit(&alloc);
            StrIter r   = JReadString(si, &out);

In Read.EdgeCases.c:1008:

            &alloc
        );
        StrIter si     = StrIterFromStr(json);
        i64     wanted = 0;

In Read.EdgeCases.c:1052:

        for (u64 i = 0; i < sizeof(cases) / sizeof(cases[0]); i++) {
            Str     json = StrInitFromZstr(cases[i], &alloc);
            StrIter si   = StrIterFromStr(json);
            i64     a    = 0;
            i64     b    = 0;

In Read.EdgeCases.c:1086:

        {
            Str     j   = StrInitFromZstr("-12345", &alloc);
            StrIter si  = StrIterFromStr(j);
            i64     v   = 0;
            StrIter out = JReadInteger(si, &v);

In Read.EdgeCases.c:1098:

            // Positive control: a sign-flip mutation would make this negative.
            Str     j   = StrInitFromZstr("12345", &alloc);
            StrIter si  = StrIterFromStr(j);
            i64     v   = 0;
            StrIter out = JReadInteger(si, &v);

In Read.EdgeCases.c:1109:

        {
            Str     j   = StrInitFromZstr("-2.5", &alloc);
            StrIter si  = StrIterFromStr(j);
            f64     v   = 0.0;
            StrIter out = JReadFloat(si, &v);

In Read.EdgeCases.c:1134:

    
        Str     j   = StrInitFromZstr("7", &alloc);
        StrIter si  = StrIterFromStr(j);
        f64     val = 0.0;
        StrIter out = JReadFloat(si, &val);

In Read.EdgeCases.c:1162:

    
        Str     j   = StrInitFromZstr("13", &alloc);
        StrIter si  = StrIterFromStr(j);
        f64     val = 0.0;
        StrIter out = JReadFloat(si, &val);

In Read.EdgeCases.c:1195:

        // value the unconditional clear set it to, which must be false.
        Str     j       = StrInitFromZstr("nuII", &alloc);
        StrIter si      = StrIterFromStr(j);
        bool    is_null = true; // poison: must be overwritten to false
        StrIter out     = JReadNull(si, &is_null);

In Read.EdgeCases.c:1225:

    
        Str     j       = StrInitFromZstr("null", &alloc);
        StrIter si      = StrIterFromStr(j);
        bool    is_null = false;
        StrIter out     = JReadNull(si, &is_null);

In RoundTrip.c:122:

        } parsed = {0, 0.0, false, StrInit(&alloc)};
    
        StrIter si = StrIterFromStr(json);
        JR_OBJ(si, {
            JR_INT_KV(si, "count", parsed.count);

In RoundTrip.c:201:

        } parsed = {0};
    
        StrIter si = StrIterFromStr(json);
        JR_OBJ(si, {
            JR_INT_KV(si, "big_int", parsed.big_int);

In RoundTrip.c:268:

        } parsed = {false, true, false, true}; // Initialize with opposite values
    
        StrIter si = StrIterFromStr(json);
        JR_OBJ(si, {
            JR_BOOL_KV(si, "flag1", parsed.flag1);

In RoundTrip.c:328:

        } parsed = {StrInit(&alloc), StrInit(&alloc), StrInit(&alloc), StrInit(&alloc)};
    
        StrIter si = StrIterFromStr(json);
        JR_OBJ(si, {
            JR_STR_KV(si, "empty", parsed.empty);

In RoundTrip.c:400:

        Vec(Str) parsed_strings = VecInitWithDeepCopy(NULL, StrDeinit, &alloc);
    
        StrIter si = StrIterFromStr(json);
        JR_OBJ(si, {
            JR_ARR_KV(si, "numbers", {

In RoundTrip.c:492:

        TestPerson parsed_person = {0, StrInit(&alloc), 0, false, 0.0};
    
        StrIter si = StrIterFromStr(json);
        JR_OBJ(si, {
            JR_OBJ_KV(si, "user", {

In RoundTrip.c:591:

        parsed.flags             = VecInitT(parsed.flags, &alloc);
    
        StrIter si = StrIterFromStr(json);
        JR_OBJ(si, {
            JR_OBJ_KV(si, "user", {

In RoundTrip.c:699:

        bool found_empty_object = false;
    
        StrIter si = StrIterFromStr(json);
        JR_OBJ(si, {
            JR_STR_KV(si, "empty_string", parsed_str);

In RoundTrip.c:782:

        } parsed = {0, 0, 999, 999.0, false, true}; // Initialize with different values
    
        StrIter si = StrIterFromStr(json);
        JR_OBJ(si, {
            JR_INT_KV(si, "max_int", parsed.max_int);

In Parse.c:17:

        KvConfig         cfg   = KvConfigInit(&alloc);
        Str              text  = StrInitFromZstr(src, &alloc);
        StrIter          input = StrIterFromStr(text);
        Str             *got   = NULL;
        bool             ok    = false;

In Parse.c:39:

        KvConfig         cfg    = KvConfigInit(&alloc);
        Str              src    = StrInitFromZstr("flag = yes\n", &alloc);
        StrIter          input  = StrIterFromStr(src);
        bool             v      = false;
        bool             result = true;

In Parse.c:65:

        DefaultAllocator alloc  = DefaultAllocatorInit();
        Str              src    = StrInitFromZstr("xy\nZ", &alloc);
        StrIter          input  = StrIterFromStr(src);
        StrIter          si     = KvConfigSkipLine(input);
        char             c      = 0;

In Parse.c:87:

        DefaultAllocator alloc  = DefaultAllocatorInit();
        Str              src    = StrInitFromZstr("a\n\nZ", &alloc);
        StrIter          input  = StrIterFromStr(src);
        StrIter          si     = KvConfigSkipLine(input);
        char             c      = 0;

In Parse.c:108:

        KvConfig         cfg    = KvConfigInit(&alloc);
        Str              src    = StrInitFromZstr("a=1\r\nb=2\r\n", &alloc);
        StrIter          input  = StrIterFromStr(src);
        StrIter          si     = KvConfigParse(input, &cfg);
        i64              a      = 0;

In Parse.c:171:

        KvConfig         cfg    = KvConfigInit(&alloc);
        Str              src    = StrInitFromZstr("k = # just a comment\n", &alloc);
        StrIter          input  = StrIterFromStr(src);
        Str             *v      = NULL;
        bool             result = true;

In Parse.c:199:

        // case. Pair with a trailing-comment line so both branches matter.
        Str     src    = StrInitFromZstr("a = 1 # c\nb = 2\n", &alloc);
        StrIter input  = StrIterFromStr(src);
        StrIter si     = KvConfigParse(input, &cfg);
        i64     a      = 0;

In Parse.c:224:

        KvConfig         cfg    = KvConfigInit(&alloc);
        Str              src    = StrInitFromZstr("k = \"v\" junk\n", &alloc);
        StrIter          input  = StrIterFromStr(src);
        StrIter          si     = KvConfigParse(input, &cfg);
        bool             result = true;

In Parse.c:247:

        KvConfig         cfg    = KvConfigInit(&alloc);
        Str              src    = StrInitFromZstr("   k = v\n", &alloc);
        StrIter          input  = StrIterFromStr(src);
        StrIter          si     = KvConfigParse(input, &cfg);
        Str             *v      = NULL;

In Parse.c:272:

        // A line with only spaces, then a real pair.
        Str     src    = StrInitFromZstr("   \nk = v\n", &alloc);
        StrIter input  = StrIterFromStr(src);
        StrIter si     = KvConfigParse(input, &cfg);
        Str    *v      = NULL;

In Parse.c:295:

        KvConfig         cfg    = KvConfigInit(&alloc);
        Str              src    = StrInitFromZstr("k = v\n   \n", &alloc);
        StrIter          input  = StrIterFromStr(src);
        StrIter          si     = KvConfigParse(input, &cfg);
        bool             result = true;

In Parse.c:318:

            &alloc
        );
        StrIter input  = StrIterFromStr(src);
        StrIter si     = KvConfigParse(input, &cfg);
        Str    *host   = KvConfigGetPtr(&cfg, "host");

In Parse.c:351:

            &alloc
        );
        StrIter input  = StrIterFromStr(src);
        StrIter si     = KvConfigParse(input, &cfg);
        Str    *path   = KvConfigGetPtr(&cfg, "path");

In Parse.c:376:

        KvConfig         cfg         = KvConfigInit(&alloc);
        Str              src         = StrInitFromZstr("host = localhost\n", &alloc);
        StrIter          input       = StrIterFromStr(src);
        Str              host_copy   = StrInit(&alloc);
        Str             *stored_host = NULL;

In Parse.c:421:

        bool    disabled = true;
        bool    result   = true;
        StrIter input    = StrIterFromStr(src);
    
        (void)KvConfigParse(input, &cfg);

In Parse.c:448:

            &alloc
        );
        StrIter input   = StrIterFromStr(src);
        StrIter si      = KvConfigParse(input, &cfg);
        bool    enabled = false;

In Parse.c:481:

            &alloc
        );
        StrIter input  = StrIterFromStr(src);
        bool    result = true;
        bool    v      = false;

In Parse.c:519:

            &alloc
        );
        StrIter input  = StrIterFromStr(src);
        bool    result = true;

In Parse.c:569:

            &alloc
        );
        StrIter input  = StrIterFromStr(src);
        Str    *a      = NULL;
        Str    *b      = NULL;

In Parse.c:602:

            &alloc
        );
        StrIter input  = StrIterFromStr(src);
        StrIter si     = KvConfigParse(input, &cfg);
        Str    *host   = NULL;

In Parse.c:644:

        KvConfig cfg   = KvConfigInit(base);
        Str      text  = StrInitFromZstr(src, base);
        StrIter  input = StrIterFromStr(text);
    
        (void)KvConfigParse(input, &cfg);

In Parse.c:706:

        // keeps both buffers off any small-string fast path.
        Str     text  = StrInitFromZstr("key =   spaced-out-value-here   \n", adbg);
        StrIter input = StrIterFromStr(text);
    
        (void)KvConfigParse(input, &cfg);

In Parse.c:737:

        KvConfig cfg   = KvConfigInit(adbg);
        Str      text  = StrInitFromZstr("a-reasonably-long-config-key = v\n", adbg);
        StrIter  input = StrIterFromStr(text);
    
        (void)KvConfigParse(input, &cfg);

In Parse.c:767:

        KvConfig cfg   = KvConfigInit(adbg);
        Str      text  = StrInitFromZstr("k = a-reasonably-long-config-value\n", adbg);
        StrIter  input = StrIterFromStr(text);
    
        (void)KvConfigParse(input, &cfg);

In Parse.c:799:

        KvConfig cfg   = KvConfigInit(adbg);
        Str      text  = StrInitFromZstr("present-config-key = value\n", adbg);
        StrIter  input = StrIterFromStr(text);
    
        (void)KvConfigParse(input, &cfg);

Last updated on July 1, 2026

StrIterFromCstr StrIterFromZstr