VecInitT

Documentation

API Reference

VecInitT

Description

Typed-cast variant of VecInit for assigning into a typed Vec variable. The cast makes the macro usable both as an in-place initializer (Vec(int) v = VecInitT(v, alloc);) and as an assignment target. The allocator argument is optional inside a Scope block.

Usage example (Cross-references)

Usage examples (Cross-references)

In VecInt.c:20:

    
    void init_int_vec(IntVec *vec, DefaultAllocator *alloc) {
        *vec = VecInitT(*vec, alloc);
    }

In VecInt.c:334:

    
            case VEC_INT_MERGE : {
                IntVec  temp  = VecInitT(temp, alloc);
                uint8_t count = extract_u8(data, offset, data_size);
                count         = count % 4;

In VecInt.c:388:

    
            case VEC_INT_INIT_CLONE : {
                IntVec  temp  = VecInitT(temp, alloc);
                uint8_t count = extract_u8(data, offset, data_size);
                count         = count % 4;

In Graph.c:162:

    
        deinit_vec(GENERIC_VEC(&slot->out_neighbors), sizeof(GraphNodeId));
        slot->out_neighbors = VecInitT(slot->out_neighbors, graph->allocator);
        deinit_vec(GENERIC_VEC(&slot->in_neighbors), sizeof(GraphNodeId));
        slot->in_neighbors = VecInitT(slot->in_neighbors, graph->allocator);

In Graph.c:164:

        slot->out_neighbors = VecInitT(slot->out_neighbors, graph->allocator);
        deinit_vec(GENERIC_VEC(&slot->in_neighbors), sizeof(GraphNodeId));
        slot->in_neighbors = VecInitT(slot->in_neighbors, graph->allocator);
    
        slot->visit_count = 0;

In Graph.c:479:

            } else {
                deinit_vec(GENERIC_VEC(&slot->out_neighbors), sizeof(GraphNodeId));
                slot->out_neighbors = VecInitT(slot->out_neighbors, graph->allocator);
                deinit_vec(GENERIC_VEC(&slot->in_neighbors), sizeof(GraphNodeId));
                slot->in_neighbors = VecInitT(slot->in_neighbors, graph->allocator);

In Graph.c:481:

                slot->out_neighbors = VecInitT(slot->out_neighbors, graph->allocator);
                deinit_vec(GENERIC_VEC(&slot->in_neighbors), sizeof(GraphNodeId));
                slot->in_neighbors = VecInitT(slot->in_neighbors, graph->allocator);
                slot->visit_count  = 0;
                slot->flags        = 0;

In Graph.c:541:

            }
    
            slot_ptr->out_neighbors = VecInitT(slot_ptr->out_neighbors, graph->allocator);
            slot_ptr->in_neighbors  = VecInitT(slot_ptr->in_neighbors, graph->allocator);
            slot_ptr->data          = graph_alloc_node_data(graph, item_size);

In Graph.c:542:

    
            slot_ptr->out_neighbors = VecInitT(slot_ptr->out_neighbors, graph->allocator);
            slot_ptr->in_neighbors  = VecInitT(slot_ptr->in_neighbors, graph->allocator);
            slot_ptr->data          = graph_alloc_node_data(graph, item_size);
            if (!slot_ptr->data) {

In Graph.c:554:

                slot_ptr->data = NULL;
                deinit_vec(GENERIC_VEC(&slot_ptr->out_neighbors), sizeof(GraphNodeId));
                slot_ptr->out_neighbors = VecInitT(slot_ptr->out_neighbors, graph->allocator);
                deinit_vec(GENERIC_VEC(&slot_ptr->in_neighbors), sizeof(GraphNodeId));
                slot_ptr->in_neighbors = VecInitT(slot_ptr->in_neighbors, graph->allocator);

In Graph.c:556:

                slot_ptr->out_neighbors = VecInitT(slot_ptr->out_neighbors, graph->allocator);
                deinit_vec(GENERIC_VEC(&slot_ptr->in_neighbors), sizeof(GraphNodeId));
                slot_ptr->in_neighbors = VecInitT(slot_ptr->in_neighbors, graph->allocator);
                slot_ptr->visit_count  = 0;
                slot_ptr->flags        = 0;

In Graph.c:573:

        }
    
        slot.out_neighbors = VecInitT(slot.out_neighbors, graph->allocator);
        slot.in_neighbors  = VecInitT(slot.in_neighbors, graph->allocator);
        slot.data          = graph_alloc_node_data(graph, item_size);

In Graph.c:574:

    
        slot.out_neighbors = VecInitT(slot.out_neighbors, graph->allocator);
        slot.in_neighbors  = VecInitT(slot.in_neighbors, graph->allocator);
        slot.data          = graph_alloc_node_data(graph, item_size);
        if (!slot.data) {

In SymbolResolver.c:187:

        MemSet(out, 0, sizeof(*out));
        out->allocator = alloc;
        out->cache     = VecInitT(out->cache, alloc);
        if (!ProcMapsLoad(&out->maps, alloc)) {
            VecDeinit(&out->cache);

In Dns.c:316:

        MemSet(out, 0, sizeof(*out));
        out->allocator   = alloc;
        out->hosts       = VecInitT(out->hosts, alloc);
        out->nameservers = VecInitT(out->nameservers, alloc);
        out->timeout_ms  = 5000;

In Dns.c:317:

        out->allocator   = alloc;
        out->hosts       = VecInitT(out->hosts, alloc);
        out->nameservers = VecInitT(out->nameservers, alloc);
        out->timeout_ms  = 5000;
        out->retries     = 2;

In Dns.c:521:

        ArenaAllocator scratch = ArenaAllocatorInit();
    
        DnsWireBuf query = VecInitT(query, &scratch);
        u16        id    = random_query_id();
        if (!DnsBuildQuery(&query, id, hostname, qtype)) {

In Dns.c:708:

            return false;
        }
        DnsAddrs addrs    = VecInitT(addrs, self->allocator);
        bool     ok       = dns_resolve_4_vec_zstr(self, spec, kind, &addrs);
        bool     have_one = ok && VecLen(&addrs) > 0;

In Pe.c:517:

        // Initialize the sections vec up-front so PeDeinit on a
        // failed-parse path doesn't trip ValidateVec.
        out->sections = VecInitT(out->sections, BufAllocator(&taken));
    
        PeContext ctx = {

In DwarfInfo.c:107:

    // by an entry with code 0. Returns false on malformed input.
    static bool parse_abbrev_table(BufIter cur, AbbrevTable *out, Allocator *alloc) {
        *out = VecInitT(*out, alloc);
        while (IterRemainingLength(&cur) > 0) {
            u64 code;

In DwarfInfo.c:128:

            e.tag          = (u32)tag;
            e.has_children = has_children != 0;
            e.attrs        = VecInitT(e.attrs, alloc);
    
            for (;;) {

In DwarfInfo.c:525:

        MemSet(out, 0, sizeof(*out));
        out->allocator   = alloc;
        out->entries     = VecInitT(out->entries, alloc);
        out->string_pool = StrInit(alloc);

In DwarfInfo.c:538:

        BufIter info_cur = BufIterFromMemory(info_bytes, info_size);
    
        PendingFns pending = VecInitT(pending, alloc);
    
        bool ok = true;

In Dns.c:179:

        rec->name   = StrInit(alloc);
        rec->target = StrInit(alloc);
        rec->rdata  = VecInitT(rec->rdata, alloc);
        MemSet(rec->ipv4, 0, sizeof(rec->ipv4));
        MemSet(rec->ipv6, 0, sizeof(rec->ipv6));

In Dns.c:275:

        }
        MemSet(out, 0, sizeof(*out));
        out->answers    = VecInitT(out->answers, alloc);
        out->authority  = VecInitT(out->authority, alloc);
        out->additional = VecInitT(out->additional, alloc);

In Dns.c:276:

        MemSet(out, 0, sizeof(*out));
        out->answers    = VecInitT(out->answers, alloc);
        out->authority  = VecInitT(out->authority, alloc);
        out->additional = VecInitT(out->additional, alloc);

In Dns.c:277:

        out->answers    = VecInitT(out->answers, alloc);
        out->authority  = VecInitT(out->authority, alloc);
        out->additional = VecInitT(out->additional, alloc);
    
        if (len < 12) {

In Pdb.c:644:

        // the pool may grow during the walk -- StrBegin() can move under
        // us each time pool_append_cstr() grows the backing storage.
        PendingPubs pending = VecInitT(pending, BufAllocator(&self->data));
        bool        ok      = walk_publics(self, dbi.symrec_stream, sections, num_sections, &self->name_pool, &pending);
        AllocatorFree(BufAllocator(&self->data), sections);

In Pdb.c:706:

        MemSet(out, 0, sizeof(*out));
        out->data      = taken;
        out->functions = VecInitT(out->functions, BufAllocator(&taken));
        out->name_pool = StrInit(BufAllocator(&taken));

In ProcMaps.c:231:

        MemSet(out, 0, sizeof(*out));
        out->raw     = StrInit(alloc);
        out->entries = VecInitT(out->entries, alloc);
    
        // `/proc/self/maps` reports stat-size 0 because it's generated by the

In ProcMaps.c:262:

        MemSet(out, 0, sizeof(*out));
        out->raw     = StrInit(alloc);
        out->entries = VecInitT(out->entries, alloc);
        if (!FileIsOpen(f)) {
            LOG_ERROR("ProcMapsLoadFrom: file is not open");

In ProcMaps.c:282:

        MemSet(out, 0, sizeof(*out));
        out->raw     = StrInit(alloc);
        out->entries = VecInitT(out->entries, alloc);
        if (len) {
            if (!StrReserve(&out->raw, len + 1)) {

In DwarfUnwind.c:431:

        MemSet(out, 0, sizeof(*out));
        out->allocator = alloc;
        out->cies      = VecInitT(out->cies, alloc);
        out->fdes      = VecInitT(out->fdes, alloc);

In DwarfUnwind.c:432:

        out->allocator = alloc;
        out->cies      = VecInitT(out->cies, alloc);
        out->fdes      = VecInitT(out->fdes, alloc);
    
        // Prefer .eh_frame. Fall back to .debug_frame: clang under -g often emits

In MachO.c:428:

        MemSet(out, 0, sizeof(*out));
        out->data     = taken;
        out->segments = VecInitT(out->segments, BufAllocator(&taken));
        out->sections = VecInitT(out->sections, BufAllocator(&taken));
        out->symbols  = VecInitT(out->symbols, BufAllocator(&taken));

In MachO.c:429:

        out->data     = taken;
        out->segments = VecInitT(out->segments, BufAllocator(&taken));
        out->sections = VecInitT(out->sections, BufAllocator(&taken));
        out->symbols  = VecInitT(out->symbols, BufAllocator(&taken));

In MachO.c:430:

        out->segments = VecInitT(out->segments, BufAllocator(&taken));
        out->sections = VecInitT(out->sections, BufAllocator(&taken));
        out->symbols  = VecInitT(out->symbols, BufAllocator(&taken));
    
        MachoContext ctx = {.out = out};

In Elf.c:487:

        MemSet(out, 0, sizeof(*out));
        out->data            = taken;
        out->sections        = VecInitT(out->sections, BufAllocator(&taken));
        out->segments        = VecInitT(out->segments, BufAllocator(&taken));
        out->symbols         = VecInitT(out->symbols, BufAllocator(&taken));

In Elf.c:488:

        out->data            = taken;
        out->sections        = VecInitT(out->sections, BufAllocator(&taken));
        out->segments        = VecInitT(out->segments, BufAllocator(&taken));
        out->symbols         = VecInitT(out->symbols, BufAllocator(&taken));
        out->dynamic_symbols = VecInitT(out->dynamic_symbols, BufAllocator(&taken));

In Elf.c:489:

        out->sections        = VecInitT(out->sections, BufAllocator(&taken));
        out->segments        = VecInitT(out->segments, BufAllocator(&taken));
        out->symbols         = VecInitT(out->symbols, BufAllocator(&taken));
        out->dynamic_symbols = VecInitT(out->dynamic_symbols, BufAllocator(&taken));

In Elf.c:490:

        out->segments        = VecInitT(out->segments, BufAllocator(&taken));
        out->symbols         = VecInitT(out->symbols, BufAllocator(&taken));
        out->dynamic_symbols = VecInitT(out->dynamic_symbols, BufAllocator(&taken));
    
        if (!elf_decode_header(out))

In Dwarf.c:212:

    
    static void cu_strings_init(CuStrings *cs, Allocator *alloc) {
        cs->dir_offsets  = VecInitT(cs->dir_offsets, alloc);
        cs->file_dir_idx = VecInitT(cs->file_dir_idx, alloc);
        cs->file_offsets = VecInitT(cs->file_offsets, alloc);

In Dwarf.c:213:

    static void cu_strings_init(CuStrings *cs, Allocator *alloc) {
        cs->dir_offsets  = VecInitT(cs->dir_offsets, alloc);
        cs->file_dir_idx = VecInitT(cs->file_dir_idx, alloc);
        cs->file_offsets = VecInitT(cs->file_offsets, alloc);
    }

In Dwarf.c:214:

        cs->dir_offsets  = VecInitT(cs->dir_offsets, alloc);
        cs->file_dir_idx = VecInitT(cs->file_dir_idx, alloc);
        cs->file_offsets = VecInitT(cs->file_offsets, alloc);
    }

In Dwarf.c:546:

        MemSet(out, 0, sizeof(*out));
        out->allocator   = alloc;
        out->entries     = VecInitT(out->entries, alloc);
        out->string_pool = StrInit(alloc);

In Dwarf.c:557:

        // Parallel arrays of file / dir offsets, one per emitted row. We
        // resolve them to pointers at the end after string_pool is final.
        U64Vec pending_file_offsets = VecInitT(pending_file_offsets, alloc);
        U64Vec pending_dir_offsets  = VecInitT(pending_dir_offsets, alloc);

In Dwarf.c:558:

        // resolve them to pointers at the end after string_pool is final.
        U64Vec pending_file_offsets = VecInitT(pending_file_offsets, alloc);
        U64Vec pending_dir_offsets  = VecInitT(pending_dir_offsets, alloc);
    
        BufIter section_cur = BufIterFromMemory(BufData(ElfBuf(elf)) + line_section->offset, line_section->size);

In Resolve.c:38:

            }
    
            DnsAddrs addrs = VecInitT(addrs, alloc);
            if (!DnsResolve(&r, hostname, 0, SOCKET_KIND_TCP, &addrs)) {
                DnsResolverDeinit(&r);

In Complex.c:547:

    
        // Create a new vector for testing fast delete operations
        vec = VecInitT(vec, &alloc);
    
        // Add elements again

In Complex.c:578:

    
        // Test with an L-value index
        vec = VecInitT(vec, &alloc);
    
        // Add elements again

In Complex.c:625:

        // Test with large number of elements
        VecDeinit(&vec);
        vec = VecInitT(vec, &alloc);
    
        // Push a large number of elements

In Complex.c:647:

        // Test with zero-capacity vector
        VecDeinit(&vec);
        vec = VecInitT(vec, &alloc);
    
        // Reserve zero capacity

In Init.c:187:

    
        TestVec vec_a = VecInit(&h_default);
        TestVec vec_b = VecInitT(vec_b, &h_default);
        TestVec vec_c = VecInitWithDeepCopy(TestItemCopyInit, TestItemDeinit, &h_default);
        TestVec vec_d = VecInitWithDeepCopyT(vec_d, TestItemCopyInit, TestItemDeinit, &h_default);

In Init.c:191:

        TestVec vec_d = VecInitWithDeepCopyT(vec_d, TestItemCopyInit, TestItemDeinit, &h_default);
        TestVec vec_e = VecInit(&h8);
        TestVec vec_f = VecInitT(vec_f, &h16);
        TestVec vec_g = VecInitWithDeepCopy(TestItemCopyInit, TestItemDeinit, &h32);
        TestVec vec_h = VecInitWithDeepCopyT(vec_h, TestItemCopyInit, TestItemDeinit, &h64);

In Pattern.Deadend.c:372:

        BitVecPush(&pattern, true);
    
        BitVecMatchIndices matches = VecInitT(matches, base);
        BitVecFindAllPattern(NULL, &pattern, &matches);
        return true; // Should never reach here.

In Pattern.Deadend.c:388:

        BitVecPush(&source, true);
    
        BitVecMatchIndices matches = VecInitT(matches, base);
        BitVecFindAllPattern(&source, NULL, &matches);
        return true; // Should never reach here.

In Foreach.Deadend.c:124:

        WriteFmt("Testing BitVecRunLengths (vec) with NULL bitvector\n");
    
        BitVecRuns runs = VecInitT(runs, base);
        BitVecRunLengths(NULL, &runs);
        return true; // Should never reach here.

In Foreach.Simple.c:539:

        BitVecPush(&bv, true);
    
        BitVecRuns runs   = VecInitT(runs, base);
        bool       result = BitVecRunLengths(&bv, &runs);
        result            = result && VecLen(&runs) == 5;

In Pattern.Simple.c:295:

        BitVecPush(&pattern, true);
    
        BitVecMatchIndices matches = VecInitT(matches, base);
        result                     = result && BitVecFindAllPattern(&source, &pattern, &matches);
        result                     = result && VecLen(&matches) == 5;

In Pattern.Simple.c:1100:

        BitVecPush(&pattern, false);
    
        BitVecMatchIndices matches = VecInitT(matches, base);
        result                     = result && BitVecFindAllPattern(&source, &pattern, &matches);
        // Exact-length match: exactly one hit, at index 0.

In Backtrace.c:73:

        Allocator       *alloc_base = ALLOCATOR_OF(&alloc);
    
        StackFrames frames = VecInitT(frames, alloc_base);
        bool        ok     = bt_vec_capture_outer(&frames);
        ok                 = ok && VecLen(&frames) >= 2;

In SysDns.c:36:

    static void resolver_init_empty(DnsResolver *r, Allocator *a) {
        r->allocator   = a;
        r->hosts       = VecInitT(r->hosts, a);
        r->nameservers = VecInitT(r->nameservers, a);
        r->timeout_ms  = 5000;

In SysDns.c:37:

        r->allocator   = a;
        r->hosts       = VecInitT(r->hosts, a);
        r->nameservers = VecInitT(r->nameservers, a);
        r->timeout_ms  = 5000;
        r->retries     = 2;

In SysDns.c:157:

        }
    
        DnsAddrs out = VecInitT(out, a);
        bool     got = DnsResolve(&r, "localhost", 8080, SOCKET_KIND_TCP, &out);

In SysDns.c:183:

        DnsResolverInit(&r, a);
    
        DnsAddrs out = VecInitT(out, a);
        bool     got = DnsResolve(&r, "LocalHost", 0, SOCKET_KIND_TCP, &out);

In SysDns.c:200:

        DnsResolverInit(&r, a);
    
        DnsAddrs out = VecInitT(out, a);
        bool     got = DnsResolve(&r, "localhost.", 0, SOCKET_KIND_TCP, &out);

In SysDns.c:217:

        DnsResolverInit(&r, a);
    
        DnsAddrs out = VecInitT(out, a);
        bool     got = DnsResolve(&r, "203.0.113.7:9999", SOCKET_KIND_TCP, &out);

In SysDns.c:241:

        DnsResolverInit(&r, a);
    
        DnsAddrs out = VecInitT(out, a);
        bool     got = DnsResolve(&r, "[::1]:443", SOCKET_KIND_TCP, &out);

In SysDns.c:265:

        DnsResolverInit(&r, a);
    
        DnsAddrs out = VecInitT(out, a);
        bool     got = DnsResolve(&r, "localhost:53", SOCKET_KIND_TCP, &out);

In SysDns.c:317:

        DnsResolverInit(&r, a);
    
        DnsAddrs out = VecInitT(out, a);
        bool     got = DnsResolve(&r, "localhost", SOCKET_KIND_TCP, &out);

In SysDns.c:336:

        DnsResolverInit(&r, a);
    
        DnsAddrs out = VecInitT(out, a);
        bool     got = DnsResolve(&r, "localhost:abc", SOCKET_KIND_TCP, &out);

In SysDns.c:1024:

        hosts_push_v4(&r, "a@z", 10, 0, 0, 1);
    
        DnsAddrs out = VecInitT(out, a);
        bool     got = dns_resolve_5_zstr(&r, "A@Z", 80, SOCKET_KIND_TCP, &out);

In SysDns.c:1044:

        hosts_push_v4(&r, "host", 10, 0, 0, 2);
    
        DnsAddrs out = VecInitT(out, a);
        bool     got = dns_resolve_5_zstr(&r, "HOST...", 80, SOCKET_KIND_TCP, &out);

In SysDns.c:1064:

        hosts_push_v4(&r, "a.b.c", 10, 0, 0, 3);
    
        DnsAddrs out = VecInitT(out, a);
        bool     got = dns_resolve_5_zstr(&r, "A.B.C.", 80, SOCKET_KIND_TCP, &out);

In SysDns.c:1084:

        hosts_push_v4(&r, "host", 10, 0, 0, 4);
    
        DnsAddrs out = VecInitT(out, a);
        bool     got = dns_resolve_5_zstr(&r, "...", 80, SOCKET_KIND_TCP, &out);

In SysDns.c:1112:

        hosts_push_v4(&r, "myhost", 1, 2, 3, 4);
    
        DnsAddrs out = VecInitT(out, a);
        bool     got = dns_resolve_5_zstr(&r, "myhost", 0x1234, SOCKET_KIND_TCP, &out);

In SysDns.c:1147:

        hosts_push_v6(&r, "myhost6", ip6);
    
        DnsAddrs out = VecInitT(out, a);
        bool     got = dns_resolve_5_zstr(&r, "myhost6", 0x1234, SOCKET_KIND_TCP, &out);

In SysDns.c:1343:

        Str p1 = write_temp(a, "2.2.2.2 beta\n");
    
        Strs paths = VecInitT(paths, a);
        VecPushBackR(&paths, p0);
        VecPushBackR(&paths, p1);

In SysDns.c:1374:

        Str p1 = write_temp(a, "nameserver 10.0.0.2\n");
    
        Strs paths = VecInitT(paths, a);
        VecPushBackR(&paths, p0);
        VecPushBackR(&paths, p1);

In SysDns.c:1405:

        Str p1 = write_temp(a, "nameserver 9.9.9.9\n");
    
        Strs paths = VecInitT(paths, a);
        VecPushBackR(&paths, p0);
        VecPushBackR(&paths, p1);

In SysDns.c:1496:

        resolver_init_crafted(&r, a);
    
        DnsAddrs out = VecInitT(out, a);
        bool     got = dns_resolve_5_zstr(&r, "single", 80, SOCKET_KIND_TCP, &out);

In SysDns.c:1514:

        resolver_init_crafted(&r, a);
    
        DnsAddrs out = VecInitT(out, a);
        bool     got = dns_resolve_5_zstr(&r, "multi", 1234, SOCKET_KIND_TCP, &out);

In SysDns.c:1533:

        resolver_init_crafted(&r, a);
    
        DnsAddrs out = VecInitT(out, a);
        bool     got = dns_resolve_5_zstr(&r, "both", 443, SOCKET_KIND_TCP, &out);

In SysDns.c:1552:

        resolver_init_crafted(&r, a);
    
        DnsAddrs out = VecInitT(out, a);
        bool     got = dns_resolve_5_zstr(&r, "v6name", 53, SOCKET_KIND_TCP, &out);

In SysDns.c:1570:

        resolver_init_crafted(&r, a);
    
        DnsAddrs out = VecInitT(out, a);
        bool     got = dns_resolve_5_zstr(&r, "SINGLE.", 80, SOCKET_KIND_TCP, &out);

In SysDns.c:1588:

        resolver_init_crafted(&r, a);
    
        DnsAddrs out = VecInitT(out, a);
        bool     got = dns_resolve_5_zstr(&r, "absent", 80, SOCKET_KIND_TCP, &out);

In SysDns.c:1612:

        longname[299] = '\0';
    
        DnsAddrs out = VecInitT(out, a);
        bool     got = dns_resolve_5_zstr(&r, longname, 80, SOCKET_KIND_TCP, &out);

In SysDns.c:1636:

        name[256] = '\0';
    
        DnsAddrs out = VecInitT(out, a);
        bool     got = dns_resolve_5_zstr(&r, name, 80, SOCKET_KIND_TCP, &out);

In SysDns.c:1666:

        name[255] = '\0';
    
        DnsAddrs out = VecInitT(out, a);
        bool     got = dns_resolve_5_zstr(&r, name, 80, SOCKET_KIND_TCP, &out);

In SysDns.c:1685:

        hosts_push_v4(&r, "", 7, 7, 7, 7);
    
        DnsAddrs out = VecInitT(out, a);
        bool     got = dns_resolve_5_zstr(&r, "", 80, SOCKET_KIND_TCP, &out);

In SysDns.c:1704:

    
        Str      name = StrInitFromZstr("multi", a);
        DnsAddrs out  = VecInitT(out, a);
        bool     got  = dns_resolve_5_str(&r, &name, 7000, SOCKET_KIND_TCP, &out);

In SysDns.c:1724:

        resolver_init_crafted(&r, a);
    
        DnsAddrs out = VecInitT(out, a);
        bool     got = dns_resolve_4_vec_zstr(&r, "single:80", SOCKET_KIND_TCP, &out);

In SysDns.c:1742:

        resolver_init_crafted(&r, a);
    
        DnsAddrs out = VecInitT(out, a);
        bool     got = dns_resolve_4_vec_zstr(&r, "multi:9090", SOCKET_KIND_TCP, &out);

In SysDns.c:1761:

        resolver_init_crafted(&r, a);
    
        DnsAddrs out = VecInitT(out, a);
        bool     got = dns_resolve_4_vec_zstr(&r, "203.0.113.7:9999", SOCKET_KIND_TCP, &out);

In SysDns.c:1779:

        resolver_init_crafted(&r, a);
    
        DnsAddrs out = VecInitT(out, a);
        bool     got = dns_resolve_4_vec_zstr(&r, "single", SOCKET_KIND_TCP, &out);

In SysDns.c:1797:

        resolver_init_crafted(&r, a);
    
        DnsAddrs out = VecInitT(out, a);
        bool     got = dns_resolve_4_vec_zstr(&r, "single:", SOCKET_KIND_TCP, &out);

In SysDns.c:1815:

        resolver_init_crafted(&r, a);
    
        DnsAddrs out = VecInitT(out, a);
        bool     got = dns_resolve_4_vec_zstr(&r, "single:9z9", SOCKET_KIND_TCP, &out);

In SysDns.c:1833:

        resolver_init_crafted(&r, a);
    
        DnsAddrs out = VecInitT(out, a);
        bool     got = dns_resolve_4_vec_zstr(&r, "single:65535", SOCKET_KIND_TCP, &out);

In SysDns.c:1860:

        spec[259] = '\0';
    
        DnsAddrs out = VecInitT(out, a);
        bool     got = dns_resolve_4_vec_zstr(&r, spec, SOCKET_KIND_TCP, &out);

In SysDns.c:1878:

        resolver_init_crafted(&r, a);
    
        DnsAddrs out = VecInitT(out, a);
        bool     got = dns_resolve_4_vec_zstr(&r, "absent:80", SOCKET_KIND_TCP, &out);

In SysDns.c:1897:

    
        Str      spec = StrInitFromZstr("multi:8080", a);
        DnsAddrs out  = VecInitT(out, a);
        bool     got  = dns_resolve_4_vec_str(&r, &spec, SOCKET_KIND_TCP, &out);

In SysDns.c:2001:

        bool        ok = dns_resolver_init(&r, a);
    
        DnsAddrs out = VecInitT(out, a);
        bool     got = dns_resolve_5_zstr(&r, "localhost", 80, SOCKET_KIND_TCP, &out);

In Dns.c:17:

        Allocator       *a     = ALLOCATOR_OF(&alloc);
    
        DnsWireBuf buf = VecInitT(buf, a);
        bool       ok  = DnsBuildQuery(&buf, 0x1234, "example.com", DNS_TYPE_A);

In Dns.c:44:

        Allocator       *a     = ALLOCATOR_OF(&alloc);
    
        DnsWireBuf no_dot = VecInitT(no_dot, a);
        DnsWireBuf w_dot  = VecInitT(w_dot, a);
        bool ok = DnsBuildQuery(&no_dot, 1, "a.b.c", DNS_TYPE_AAAA) && DnsBuildQuery(&w_dot, 1, "a.b.c.", DNS_TYPE_AAAA);

In Dns.c:45:

    
        DnsWireBuf no_dot = VecInitT(no_dot, a);
        DnsWireBuf w_dot  = VecInitT(w_dot, a);
        bool ok = DnsBuildQuery(&no_dot, 1, "a.b.c", DNS_TYPE_AAAA) && DnsBuildQuery(&w_dot, 1, "a.b.c.", DNS_TYPE_AAAA);

In Dns.c:315:

        Allocator       *a     = ALLOCATOR_OF(&alloc);
    
        DnsWireBuf buf = VecInitT(buf, a);
        bool       ok  = DnsBuildQuery(&buf, 0x1234, "www.example.com", DNS_TYPE_A);

In Dns.c:339:

        Allocator       *a     = ALLOCATOR_OF(&alloc);
    
        DnsWireBuf buf = VecInitT(buf, a);
        bool       ok  = DnsBuildQuery(&buf, 0x0001, "", DNS_TYPE_A);

In Dns.c:363:

        label[63] = '\0';
    
        DnsWireBuf buf = VecInitT(buf, a);
        bool       ok  = DnsBuildQuery(&buf, 1, label, DNS_TYPE_A);

In Dns.c:382:

        Allocator       *a     = ALLOCATOR_OF(&alloc);
    
        DnsWireBuf no_dot = VecInitT(no_dot, a);
        DnsWireBuf w_dot  = VecInitT(w_dot, a);
        bool       ok     = DnsBuildQuery(&no_dot, 7, "a.b", DNS_TYPE_A) && DnsBuildQuery(&w_dot, 7, "a.b.", DNS_TYPE_A);

In Dns.c:383:

    
        DnsWireBuf no_dot = VecInitT(no_dot, a);
        DnsWireBuf w_dot  = VecInitT(w_dot, a);
        bool       ok     = DnsBuildQuery(&no_dot, 7, "a.b", DNS_TYPE_A) && DnsBuildQuery(&w_dot, 7, "a.b.", DNS_TYPE_A);

In Dns.c:426:

        build_label_name(name, lens, 4);
    
        DnsWireBuf buf = VecInitT(buf, a);
        bool       ok  = DnsBuildQuery(&buf, 1, name, DNS_TYPE_A);

In Dns.c:449:

        build_label_name(name, lens, 4);
    
        DnsWireBuf buf = VecInitT(buf, a);
        bool       ok  = DnsBuildQuery(&buf, 1, name, DNS_TYPE_A);

In Dns.c:472:

    
        Str        name = StrInitFromZstr("example.com", a);
        DnsWireBuf buf  = VecInitT(buf, a);
        bool       ok   = DnsBuildQuery(&buf, 0x1234, &name, DNS_TYPE_A);

In Dns.c:1596:

        Allocator       *a     = ALLOCATOR_OF(&alloc);
    
        DnsWireBuf buf = VecInitT(buf, a);
        bool       ok  = DnsBuildQuery(&buf, 0x1234, "a..b", DNS_TYPE_A);

In ProcMaps.c:320:

        MemSet(&pm, 0, sizeof(pm));
        pm.raw     = StrInit(ALLOCATOR_OF(&alloc));
        pm.entries = VecInitT(pm.entries, ALLOCATOR_OF(&alloc));
    
        ProcMapEntry e0 = {.start = 0x1000, .end = 0x2000, .perms = 0, .file_offset = 0, .path = ""};

In RoundTrip.c:547:

        VecPushBack(&original.config.features, feature2);
    
        original.numbers = VecInitT(original.numbers, &alloc);
        i32 vals[3]      = {10, 20, -5};
        for (size i = 0; i < 3; i++) {

In RoundTrip.c:553:

        }
    
        original.flags = VecInitT(original.flags, &alloc);
        bool bools[3]  = {true, false, true};
        for (size i = 0; i < 3; i++) {

In RoundTrip.c:588:

        parsed.config.log_level  = StrInit(&alloc);
        parsed.config.features   = VecInitWithDeepCopyT(parsed.config.features, NULL, StrDeinit, &alloc);
        parsed.numbers           = VecInitT(parsed.numbers, &alloc);
        parsed.flags             = VecInitT(parsed.flags, &alloc);

In RoundTrip.c:589:

        parsed.config.features   = VecInitWithDeepCopyT(parsed.config.features, NULL, StrDeinit, &alloc);
        parsed.numbers           = VecInitT(parsed.numbers, &alloc);
        parsed.flags             = VecInitT(parsed.flags, &alloc);
    
        StrIter si = StrIterFromStr(json);

Last updated on July 1, 2026

VecInitStack VecInitWithDeepCopy