VecDeinit

Documentation

API Reference

VecDeinit

Description

Deinit a vec by freeing its backing buffer. If the vec was built with a deep-copy copy_deinit callback, that callback is invoked on every live element before the buffer is freed.

Parameters

Name	Direction	Description
`v`	in,out	Vec to deinitialize. Must not be used until reinitialized.

Success

Element deinit callbacks run, backing buffer freed; v left in the zeroed post-deinit state.

Failure

Cannot fail; aborts on a corrupted magic via the validator.

Usage example (Cross-references)

Usage examples (Cross-references)

In Buf.h:51:

    /// TAGS: Buf, Deinit, Lifecycle
    ///
    #define BufDeinit(b) VecDeinit(b)
    
    ///

In Insert.h:527:

        (ValidateVec(vd),                                                                                                  \
         ValidateVec(vs),                                                                                                  \
         VecDeinit(vd),                                                                                                    \
         *(vd) = (TYPE_OF(*(vd))) {.length      = 0,                                                                       \
                                   .capacity    = 0,                                                                       \

In VecInt.c:24:

    
    void deinit_int_vec(IntVec *vec) {
        VecDeinit(vec);
    }

In VecInt.c:344:

    
                VecMerge(vec, &temp);
                VecDeinit(&temp); // Clean up temp to prevent memory leak
                break;
            }

In VecInt.c:399:

                VecInitClone(vec, &temp);
    
                VecDeinit(&temp); // Clean up temp to prevent memory leak
                break;
            }

In VecCharPtr.c:41:

    void deinit_char_ptr_vec(CharPtrVec *vec) {
        // VecDeinit will automatically call char_ptr_deinit on each element
        VecDeinit(vec);
    }

In VecCharPtr.c:417:

    
                    VecMerge(vec, &temp);
                    VecDeinit(&temp);
                }
                break;

In VecCharPtr.c:487:

                    VecInitClone(vec, &temp);
    
                    VecDeinit(&temp);
                }
                break;

In VecStr.c:75:

    void deinit_str_vec(StrVec *vec) {
        // VecDeinit will automatically call StrDeinit on each element
        VecDeinit(vec);
    }

In VecStr.c:400:

    
                    VecMerge(vec, &temp);
                    VecDeinit(&temp);
                }
                break;

In VecStr.c:465:

                    VecInitClone(vec, &temp);
    
                    VecDeinit(&temp);
                }
                break;

In ArgParse.c:463:

        if (!self)
            return;
        VecDeinit(&self->specs);
    }

In Debug.c:485:

            MapDeinit(&self->live);
        if (self->freed.allocator)
            VecDeinit(&self->freed);
    
        HeapAllocatorDeinit(&self->meta);

In Dir.c:570:

            }
        }
        VecDeinit(&dc);
        HeapAllocatorDeinit(&ha);

In SymbolResolver.c:189:

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

In SymbolResolver.c:223:

            ElfDeinit(&e->elf);
        }
        VecDeinit(&self->cache);
        ProcMapsDeinit(&self->maps);
        MemSet(self, 0, sizeof(*self));

In PdbCache.c:129:

            StrDeinit(&e->module_path);
        }
        VecDeinit(&self->entries);
        MemSet(self, 0, sizeof(*self));
    }

In Dns.c:421:

                StrDeinit(&e->name);
            }
            VecDeinit(&self->hosts);
        }
        if (VecBegin(&self->nameservers)) {

In Dns.c:424:

        }
        if (VecBegin(&self->nameservers)) {
            VecDeinit(&self->nameservers);
        }
        self->allocator = NULL;

In Dns.c:524:

        u16        id    = random_query_id();
        if (!DnsBuildQuery(&query, id, hostname, qtype)) {
            VecDeinit(&query);
            ArenaAllocatorDeinit(&scratch);
            return false;

In Dns.c:531:

        u8  resp_buf[1232]; // safe UDP payload (avoids IP fragmentation)
        i64 got = udp_round_trip(ns, VecBegin(&query), VecLen(&query), resp_buf, sizeof(resp_buf), self->timeout_ms);
        VecDeinit(&query);
        if (got <= 0) {
            ArenaAllocatorDeinit(&scratch);

In Dns.c:714:

            *out = VecAt(&addrs, 0);
        }
        VecDeinit(&addrs);
        return have_one;
    }

In MachoCache.c:143:

            StrDeinit(&e->module_path);
        }
        VecDeinit(&self->entries);
        MemSet(self, 0, sizeof(*self));
    }

In Pe.c:573:

            return;
        BufDeinit(&self->data);
        VecDeinit(&self->sections);
        MemSet(self, 0, sizeof(*self));
    }

In DwarfInfo.c:99:

    static void abbrev_table_deinit(AbbrevTable *t) {
        for (size i = 0; i < VecLen(t); ++i) {
            VecDeinit(&VecPtrAt(t, i)->attrs);
        }
        VecDeinit(t);

In DwarfInfo.c:101:

            VecDeinit(&VecPtrAt(t, i)->attrs);
        }
        VecDeinit(t);
    }

In DwarfInfo.c:133:

                u64 name, form;
                if (!BufReadULeb128(&cur, &name)) {
                    VecDeinit(&e.attrs);
                    return false;
                }

In DwarfInfo.c:137:

                }
                if (!BufReadULeb128(&cur, &form)) {
                    VecDeinit(&e.attrs);
                    return false;
                }

In DwarfInfo.c:144:

                AbbrevAttr a = {.name = (u32)name, .form = (u32)form};
                if (!VecPushBackR(&e.attrs, a)) {
                    VecDeinit(&e.attrs);
                    return false;
                }

In DwarfInfo.c:149:

            }
            if (!VecPushBackR(out, e)) {
                VecDeinit(&e.attrs);
                return false;
            }

In DwarfInfo.c:631:

        }
    
        VecDeinit(&pending);
    
        if (!ok) {

In DwarfInfo.c:682:

            return;
        if (VecAllocator(&self->entries))
            VecDeinit(&self->entries);
        if (StrAllocator(&self->string_pool))
            StrDeinit(&self->string_pool);

In Dns.c:326:

        StrDeinit(&self->name);
        StrDeinit(&self->target);
        VecDeinit(&self->rdata);
    }

In Dns.c:336:

            DnsRecordDeinit(r);
        }
        VecDeinit(list);
    }

In Pdb.c:649:

    
        if (!ok) {
            VecDeinit(&pending);
            return false;
        }

In Pdb.c:654:

    
        if (VecLen(&pending) == 0) {
            VecDeinit(&pending);
            return true;
        }

In Pdb.c:685:

            }
        }
        VecDeinit(&pending);
    
        return ok;

In Pdb.c:772:

        }
        StrDeinit(&self->name_pool);
        VecDeinit(&self->functions);
        BufDeinit(&self->data);
        MemSet(self, 0, sizeof(*self));

In ProcMaps.c:298:

            return;
        StrDeinit(&self->raw);
        VecDeinit(&self->entries);
        MemSet(self, 0, sizeof(*self));
    }

In Http.c:192:

        }
        StrDeinit(&req->url);
        VecDeinit(&req->headers);
        MemSet(req, 0, sizeof(*req));
    }

In Http.c:502:

        }
        StrDeinit(&response->body);
        VecDeinit(&response->headers);
        MemSet(response, 0, sizeof(*response));
    }

In DwarfUnwind.c:484:

        if (!self)
            return;
        VecDeinit(&self->cies);
        VecDeinit(&self->fdes);
        MemSet(self, 0, sizeof(*self));

In DwarfUnwind.c:485:

            return;
        VecDeinit(&self->cies);
        VecDeinit(&self->fdes);
        MemSet(self, 0, sizeof(*self));
    }

In MachO.c:478:

            return;
        BufDeinit(&self->data);
        VecDeinit(&self->segments);
        VecDeinit(&self->sections);
        VecDeinit(&self->symbols);

In MachO.c:479:

        BufDeinit(&self->data);
        VecDeinit(&self->segments);
        VecDeinit(&self->sections);
        VecDeinit(&self->symbols);
        MemSet(self, 0, sizeof(*self));

In MachO.c:480:

        VecDeinit(&self->segments);
        VecDeinit(&self->sections);
        VecDeinit(&self->symbols);
        MemSet(self, 0, sizeof(*self));
    }

In Elf.c:542:

            return;
        BufDeinit(&self->data);
        VecDeinit(&self->sections);
        VecDeinit(&self->segments);
        VecDeinit(&self->symbols);

In Elf.c:543:

        BufDeinit(&self->data);
        VecDeinit(&self->sections);
        VecDeinit(&self->segments);
        VecDeinit(&self->symbols);
        VecDeinit(&self->dynamic_symbols);

In Elf.c:544:

        VecDeinit(&self->sections);
        VecDeinit(&self->segments);
        VecDeinit(&self->symbols);
        VecDeinit(&self->dynamic_symbols);
        MemSet(self, 0, sizeof(*self));

In Elf.c:545:

        VecDeinit(&self->segments);
        VecDeinit(&self->symbols);
        VecDeinit(&self->dynamic_symbols);
        MemSet(self, 0, sizeof(*self));
    }

In Dwarf.c:218:

    
    static void cu_strings_deinit(CuStrings *cs) {
        VecDeinit(&cs->dir_offsets);
        VecDeinit(&cs->file_dir_idx);
        VecDeinit(&cs->file_offsets);

In Dwarf.c:219:

    static void cu_strings_deinit(CuStrings *cs) {
        VecDeinit(&cs->dir_offsets);
        VecDeinit(&cs->file_dir_idx);
        VecDeinit(&cs->file_offsets);
    }

In Dwarf.c:220:

        VecDeinit(&cs->dir_offsets);
        VecDeinit(&cs->file_dir_idx);
        VecDeinit(&cs->file_offsets);
    }

In Dwarf.c:648:

        }
    
        VecDeinit(&pending_file_offsets);
        VecDeinit(&pending_dir_offsets);

In Dwarf.c:649:

    
        VecDeinit(&pending_file_offsets);
        VecDeinit(&pending_dir_offsets);
    
        if (!ok) {

In Dwarf.c:661:

        if (!self)
            return;
        VecDeinit(&self->entries);
        StrDeinit(&self->string_pool);
        MemSet(self, 0, sizeof(*self));

In Resolve.c:57:

            }
    
            VecDeinit(&addrs);
            DnsResolverDeinit(&r);
        }

In Ops.c:66:

    
        // Clean up
        VecDeinit(&vec);
    
        return result;

In Ops.c:118:

    
        // Clean up
        VecDeinit(&vec);
    
        return result;

In Ops.c:157:

    
        // Clean up
        VecDeinit(&vec);
    
        return result;

In Ops.c:177:

    
        // Unreachable on real code.
        VecDeinit(&vec);
        return false;
    }

In Ops.c:202:

    
        // Unreachable on real code.
        VecDeinit(&vec);
        return false;
    }

In Complex.c:215:

        // Clean up
        ComplexItemDeinit(&item);
        VecDeinit(&vec);
    
        return result;

In Complex.c:259:

        ComplexItemDeinit(&item2);
        ComplexItemDeinit(&item3);
        VecDeinit(&vec);
    
        return result;

In Complex.c:302:

        ComplexItemDeinit(&item2);
        ComplexItemDeinit(&item3);
        VecDeinit(&vec);
    
        return result;

In Complex.c:377:

        ComplexItemDeinit(&item2);
        ComplexItemDeinit(&item3);
        VecDeinit(&vec1);
        VecDeinit(&vec2);
        VecDeinit(&vec3);

In Complex.c:378:

        ComplexItemDeinit(&item3);
        VecDeinit(&vec1);
        VecDeinit(&vec2);
        VecDeinit(&vec3);
        VecDeinit(&vec4);

In Complex.c:379:

        VecDeinit(&vec1);
        VecDeinit(&vec2);
        VecDeinit(&vec3);
        VecDeinit(&vec4);

In Complex.c:380:

        VecDeinit(&vec2);
        VecDeinit(&vec3);
        VecDeinit(&vec4);
    
        return result;

In Complex.c:428:

    
        // Clean up
        VecDeinit(&vec);
    
        return result;

In Complex.c:471:

    
        // Clean up
        VecDeinit(&vec);
    
        // Now test VecInsertRangeFastR in isolation

In Complex.c:505:

    
        // Clean up
        VecDeinit(&vec2);
    
        return result;

In Complex.c:544:

    
        // Clean up this vector
        VecDeinit(&vec);
    
        // Create a new vector for testing fast delete operations

In Complex.c:575:

    
        // Clean up
        VecDeinit(&vec);
    
        // Test with an L-value index

In Complex.c:596:

    
        // Clean up
        VecDeinit(&vec);
    
        return result;

In Complex.c:624:

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

In Complex.c:646:

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

In Complex.c:658:

    
        // Clean up
        VecDeinit(&vec);
    
        return result;

In Complex.c:684:

    
        // Clean up the temporary vector
        VecDeinit(&temp_vec);
    
        return result;

In Complex.c:719:

    
        // Clean up the vector
        VecDeinit(&vec);
    
        return result;

In Complex.c:785:

    
        // Clean up the vector
        VecDeinit(&vec);
    
        return result;

In Complex.c:816:

    
        // Clean up the vector
        VecDeinit(&vec);
    
        return result;

In Complex.c:853:

    
        // Clean up
        VecDeinit(&vec1);
        VecDeinit(&vec2);

In Complex.c:854:

        // Clean up
        VecDeinit(&vec1);
        VecDeinit(&vec2);
    
        return result;

In Complex.c:891:

    
        // Clean up the vector
        VecDeinit(&vec);
    
        return result;

In Complex.c:920:

        bool result = (VecLen(&dst) == 3) && (VecAt(&dst, 0) == 1) && (VecAt(&dst, 1) == 2) && (VecAt(&dst, 2) == 3);
    
        VecDeinit(&src);
        VecDeinit(&dst);
        DefaultAllocatorDeinit(&local);

In Complex.c:921:

    
        VecDeinit(&src);
        VecDeinit(&dst);
        DefaultAllocatorDeinit(&local);
        return result;

In Complex.c:946:

        bool result = (VecLen(&dst) == 3) && (VecAt(&dst, 0) == 1);
    
        VecDeinit(&src);
        VecDeinit(&dst);
        DefaultAllocatorDeinit(&local);

In Complex.c:947:

    
        VecDeinit(&src);
        VecDeinit(&dst);
        DefaultAllocatorDeinit(&local);
        return result;

In Complex.c:971:

        bool result = (VecLen(&dst) == 3);
    
        VecDeinit(&src);
        VecDeinit(&dst);
        DefaultAllocatorDeinit(&local);

In Complex.c:972:

    
        VecDeinit(&src);
        VecDeinit(&dst);
        DefaultAllocatorDeinit(&local);
        return result;

In Complex.c:996:

        bool result = (VecLen(&dst) == 3) && (VecAt(&dst, 0) == 1) && (VecAt(&dst, 1) == 2) && (VecAt(&dst, 2) == 3);
    
        VecDeinit(&src);
        VecDeinit(&dst);
        DefaultAllocatorDeinit(&local);

In Complex.c:997:

    
        VecDeinit(&src);
        VecDeinit(&dst);
        DefaultAllocatorDeinit(&local);
        return result;

In Complex.c:1022:

        bool result = cloned && (VecLen(&dst) == 3);
    
        VecDeinit(&src);
        VecDeinit(&dst);
        DefaultAllocatorDeinit(&local);

In Complex.c:1023:

    
        VecDeinit(&src);
        VecDeinit(&dst);
        DefaultAllocatorDeinit(&local);
        return result;

In Memory.c:114:

    
        // Clean up
        VecDeinit(&vec);
    
        DefaultAllocatorDeinit(&alloc);

In Memory.c:162:

    
        // Clean up
        VecDeinit(&vec);
    
        DefaultAllocatorDeinit(&alloc);

In Memory.c:209:

    
        // Clean up
        VecDeinit(&vec);
    
        DefaultAllocatorDeinit(&alloc);

In Memory.c:250:

    
        // Clean up
        VecDeinit(&vec);
    
        DefaultAllocatorDeinit(&alloc);

In Memory.c:277:

        bool result = ok && (VecLen(&vec) == 100) && (VecCapacity(&vec) >= 100);
    
        VecDeinit(&vec);
        return result;
    }

In Memory.c:300:

        bool result = (VecLen(&vec) == 1) && (g_deinit_count == 3);
    
        VecDeinit(&vec);
        return result;
    }

In Memory.c:323:

        bool result = (VecCapacity(&vec) >= 64);
    
        VecDeinit(&vec);
        return result;
    }

In Memory.c:343:

        bool result = (VecLen(&vec) == 50);
    
        VecDeinit(&vec);
        return result;
    }

In Memory.c:360:

        bool result = (VecLen(&vec) == 10) && (VecCapacity(&vec) == 16);
    
        VecDeinit(&vec);
        return result;
    }

In Memory.c:402:

        bool result = (VecAt(&vec, 0) == 0x11111111 && VecAt(&vec, probe_index) == 0);
    
        VecDeinit(&vec);
        HeapAllocatorDeinit(&heap);
        return result;

In Memory.c:435:

        bool result = (ok == false) && (VecLen(&vec) == 0);
    
        VecDeinit(&vec);
        HeapAllocatorDeinit(&heap);
        return result;

In Memory.c:502:

        bool result = (VecLen(&vec) == 0);
    
        VecDeinit(&vec);
        DefaultAllocatorDeinit(&local);
        return result;

In Memory.c:530:

        // Drop the hook so the final teardown does not re-run the counter.
        vec.copy_deinit = NULL;
        VecDeinit(&vec);
        DefaultAllocatorDeinit(&local);
        return result;

In Memory.c:568:

        }
    
        VecDeinit(&vec);
        DefaultAllocatorDeinit(&local);
        return result;

In Memory.c:593:

        bool result = (VecLen(&vec) == 5);
    
        VecDeinit(&vec);
        DefaultAllocatorDeinit(&local);
        return result;

In Memory.c:614:

        bool result = (VecCapacity(&vec) == 0);
    
        VecDeinit(&vec);
        DefaultAllocatorDeinit(&local);
        return result;

In Memory.c:635:

        bool result = (VecLen(&vec) == 0);
    
        VecDeinit(&vec);
        DefaultAllocatorDeinit(&local);
        return result;

In Memory.c:660:

        bool result = (VecCapacity(&vec) == 5);
    
        VecDeinit(&vec);
        DefaultAllocatorDeinit(&local);
        return result;

In Memory.c:694:

    
        // Unreachable on real code: the structural validator LOG_FATALs above.
        VecDeinit(&vec);
        DefaultAllocatorDeinit(&local);
        return false;

In Memory.c:721:

    
        // Unreachable: the guard LOG_FATALs above.
        VecDeinit(&vec);
        DefaultAllocatorDeinit(&alloc);
        return false;

In Init.c:69:

    
        // Clean up
        VecDeinit(&vec);
    
        // Test with struct type

In Init.c:81:

    
        // Clean up
        VecDeinit(&test_vec);
    
        return result;

In Init.c:103:

    
        // Clean up
        VecDeinit(&vec);
    
        // Test with struct type and 16-byte alignment

In Init.c:115:

    
        // Clean up
        VecDeinit(&test_vec);
    
        HeapAllocatorDeinit(&aligned4);

In Init.c:137:

    
        // Clean up
        VecDeinit(&vec);
    
        return result;

In Init.c:159:

    
        // Clean up
        VecDeinit(&vec);
    
        HeapAllocatorDeinit(&aligned8);

In Init.c:204:

        result      = result && (VecCopyDeinit(&vec_d) == (GenericCopyDeinit)TestItemDeinit);
    
        VecDeinit(&vec_a);
        VecDeinit(&vec_b);
        VecDeinit(&vec_c);

In Init.c:205:

    
        VecDeinit(&vec_a);
        VecDeinit(&vec_b);
        VecDeinit(&vec_c);
        VecDeinit(&vec_d);

In Init.c:206:

        VecDeinit(&vec_a);
        VecDeinit(&vec_b);
        VecDeinit(&vec_c);
        VecDeinit(&vec_d);
        VecDeinit(&vec_e);

In Init.c:207:

        VecDeinit(&vec_b);
        VecDeinit(&vec_c);
        VecDeinit(&vec_d);
        VecDeinit(&vec_e);
        VecDeinit(&vec_f);

In Init.c:208:

        VecDeinit(&vec_c);
        VecDeinit(&vec_d);
        VecDeinit(&vec_e);
        VecDeinit(&vec_f);
        VecDeinit(&vec_g);

In Init.c:209:

        VecDeinit(&vec_d);
        VecDeinit(&vec_e);
        VecDeinit(&vec_f);
        VecDeinit(&vec_g);
        VecDeinit(&vec_h);

In Init.c:210:

        VecDeinit(&vec_e);
        VecDeinit(&vec_f);
        VecDeinit(&vec_g);
        VecDeinit(&vec_h);

In Init.c:211:

        VecDeinit(&vec_f);
        VecDeinit(&vec_g);
        VecDeinit(&vec_h);
    
        HeapAllocatorDeinit(&h_default);

In Init.c:327:

    
        // Clean up
        VecDeinit(&src);
        VecDeinit(&clone);

In Init.c:328:

        // Clean up
        VecDeinit(&src);
        VecDeinit(&clone);
    
        return result;

In Init.c:336:

    // element before storage is freed.
    bool test_deinit_runs_deinit_once_per_element(void) {
        WriteFmt("Testing VecDeinit invokes copy_deinit once per element\n");
    
        DefaultAllocator local = DefaultAllocatorInit();

In Init.c:350:

    
        g_deinit_calls = 0;
        VecDeinit(&vec);
    
        bool result = (g_deinit_calls == 3);

In Insert.c:101:

    
        // Clean up
        VecDeinit(&vec);
    
        return result;

In Insert.c:129:

    
        // Clean up
        VecDeinit(&vec);
    
        return result;

In Insert.c:164:

    
        // Clean up
        VecDeinit(&vec);
    
        return result;

In Insert.c:205:

    
        // Clean up
        VecDeinit(&vec);
    
        return result;

In Insert.c:246:

    
        // Clean up
        VecDeinit(&vec);
    
        return result;

In Insert.c:279:

    
        // Clean up
        VecDeinit(&vec);
    
        return result;

In Insert.c:316:

    
        // Clean up
        VecDeinit(&vec);
        VecDeinit(&src);

In Insert.c:317:

        // Clean up
        VecDeinit(&vec);
        VecDeinit(&src);
    
        return result;

In Insert.c:357:

    
        // Clean up
        VecDeinit(&vec1);
        VecDeinit(&vec2);

In Insert.c:358:

        // Clean up
        VecDeinit(&vec1);
        VecDeinit(&vec2);
    
        return result;

In Insert.c:402:

                      VecAt(&dst, 0) == 10 && VecAt(&dst, 1) == 20 && VecAt(&dst, 2) == 30;
    
        VecDeinit(&src);
        VecDeinit(&dst);
        HeapAllocatorDeinit(&local_heap);

In Insert.c:403:

    
        VecDeinit(&src);
        VecDeinit(&dst);
        HeapAllocatorDeinit(&local_heap);
        return result;

In Insert.c:486:

    
        // Clean up
        VecDeinit(&vec);
    
        return result;

In Insert.c:561:

    
        // Clean up
        VecDeinit(&vec);
        VecDeinit(&vec2);

In Insert.c:562:

        // Clean up
        VecDeinit(&vec);
        VecDeinit(&vec2);
    
        return result;

In Insert.c:616:

        }
    
        VecDeinit(&vec);
        return result;
    }

In Insert.c:720:

        bool result = (ok == false) && (VecLen(&vec) == 0);
    
        VecDeinit(&vec);
        return result;
    }

In Insert.c:764:

        result = result && found_all;
    
        VecDeinit(&vec);
        return result;
    }

In Insert.c:798:

        }
    
        VecDeinit(&vec);
        return result;
    }

In Insert.c:821:

        }
    
        VecDeinit(&vec);
        return result;
    }

In Insert.c:846:

        }
    
        VecDeinit(&vec);
        return result;
    }

In Insert.c:900:

        result = result && found13;
    
        VecDeinit(&vec);
        return result;
    }

In Insert.c:943:

        result = result && (VecAt(&vec, N).value >= 0);
    
        VecDeinit(&ins);
        VecDeinit(&vec);
        return result;

In Insert.c:944:

    
        VecDeinit(&ins);
        VecDeinit(&vec);
        return result;
    }

In Insert.c:974:

        result = result && (VecAt(&vec, 3).value == 200);
    
        VecDeinit(&vec);
        return result;
    }

In Insert.c:1003:

        result = result && (VecAt(&vec, 1).value == 11);
    
        VecDeinit(&vec);
        return result;
    }

In Insert.c:1032:

        result      = result && (VecAt(&vec, 3).value == 300);
    
        VecDeinit(&vec);
        return result;
    }

In Insert.c:1060:

        result = result && (VecAt(&vec, 3).value == 13);
    
        g_fail_at = 0; // let VecDeinit clean up the live originals
        VecDeinit(&vec);
        return result;

In Insert.c:1061:

    
        g_fail_at = 0; // let VecDeinit clean up the live originals
        VecDeinit(&vec);
        return result;
    }

In Insert.c:1088:

    
        g_fail_at = 0;
        VecDeinit(&vec);
        return result;
    }

In Insert.c:1114:

    
        g_fail_at = 0;
        VecDeinit(&vec);
        return result;
    }

In Insert.c:1145:

    
        g_fail_at = 0;
        VecDeinit(&vec);
        return result;
    }

In Insert.c:1173:

    
        g_fail_at = 0;
        VecDeinit(&vec);
        return result;
    }

In Insert.c:1206:

    
        g_fail_at = 0;
        VecDeinit(&vec);
        return result;
    }

In Insert.c:1231:

    
        g_fail_at = 0;
        VecDeinit(&vec);
        return result;
    }

In Insert.c:1261:

    
        g_fail_at = 0;
        VecDeinit(&vec);
        return result;
    }

In Insert.c:1289:

    
        g_fail_at = 0;
        VecDeinit(&vec);
        return result;
    }

In Insert.c:1321:

    
        g_fail_at = 0;
        VecDeinit(&vec);
        return result;
    }

In Insert.c:1423:

        bool result = (ret == false) && (VecLen(&vec) == 0);
    
        VecDeinit(&vec);
        return result;
    }

In Insert.c:1442:

                      (VecAt(&vec, 2) == 20) && (VecAt(&vec, 3) == 30);
    
        VecDeinit(&vec);
        return result;
    }

In Insert.c:1461:

        bool result = ret && (VecLen(&vec) == 4) && (VecAt(&vec, 0) == 77) && (VecAt(&vec, 1) == 11);
    
        VecDeinit(&vec);
        return result;
    }

In Insert.c:1485:

                      (VecAt(&vec, N - 1) == 999999) && (VecAt(&vec, N) == (u64)(N - 1));
    
        VecDeinit(&vec);
        return result;
    }

In Insert.c:1505:

        bool result = (ret == false) && (ti_deinit_count == 0) && (VecLen(&vec) == 3);
    
        VecDeinit(&vec);
        return result;
    }

In Insert.c:1528:

        bool result = (ret == false) && (ti_deinit_count == 2) && (VecLen(&vec) == 3);
    
        VecDeinit(&vec);
        return result;
    }

In Insert.c:1550:

        bool result = (ret == false) && (ti_deinit_count == 1) && (VecLen(&vec) == 3);
    
        VecDeinit(&vec);
        return result;
    }

In Insert.c:1572:

        bool result = (ret == false) && (ti_deinit_count == 1) && (g_deinit_saw_zero == false) && (VecLen(&vec) == 3);
    
        VecDeinit(&vec);
        return result;
    }

In Insert.c:1595:

        bool result = (ret == false) && (ti_deinit_count == 2) && (VecLen(&vec) == 3);
    
        VecDeinit(&vec);
        return result;
    }

In Insert.c:1619:

                      !deinit_tags_contain(1) && (VecLen(&vec) == 1) && (VecAt(&vec, 0).tag == 1);
    
        VecDeinit(&vec);
        return result;
    }

In Insert.c:1641:

        bool result = (ret == false) && (ti_deinit_count == 1) && (VecLen(&vec) == 3);
    
        VecDeinit(&vec);
        return result;
    }

In Insert.c:1661:

                      (VecAt(&vec, 2).tag == 3);
    
        VecDeinit(&vec);
        return result;
    }

In Insert.c:1680:

                      (VecAt(&vec, 2).tag == 3);
    
        VecDeinit(&vec);
        return result;
    }

In Insert.c:1707:

                      (VecAt(&vec, N - 2).tag == (int)(N - 1)) && (VecAt(&vec, N - 1).tag == (int)N);
    
        VecDeinit(&vec);
        return result;
    }

In Insert.c:1727:

                      (VecAt(&vec, 2).tag == 3);
    
        VecDeinit(&vec);
        return result;
    }

In Insert.c:1750:

            ok && (VecLen(&vec) == 3) && (VecAt(&vec, 0) == 111u) && (VecAt(&vec, 1) == 222u) && (VecAt(&vec, 2) == 333u);
    
        VecDeinit(&vec);
        DefaultAllocatorDeinit(&local);
        return result;

In Insert.c:1772:

            ok && (VecLen(&vec) == 3) && (VecAt(&vec, 0) == 444u) && (VecAt(&vec, 1) == 555u) && (VecAt(&vec, 2) == 666u);
    
        VecDeinit(&vec);
        DefaultAllocatorDeinit(&local);
        return result;

In Insert.c:1791:

        bool result = ok && (VecLen(&vec) == 1) && (VecAt(&vec, 0) == 777u);
    
        VecDeinit(&vec);
        DefaultAllocatorDeinit(&local);
        return result;

In Insert.c:1853:

        bool result = (ok == false) && (VecLen(&vec) == 0);
    
        VecDeinit(&vec);
        result = result && (DebugAllocatorOverflows(&dbg) == 0);
        DebugAllocatorDeinit(&dbg);

In Insert.c:1882:

        bool result = (ok == false) && (VecLen(&vec) == 0);
    
        VecDeinit(&vec);
        return result;
    }

In Insert.c:1933:

        result = result && (VecAt(&vec, 5).value == 0);
    
        g_fail_at = 0; // let VecDeinit run copy_deinit on the live originals
        VecDeinit(&vec);
        return result;

In Insert.c:1934:

    
        g_fail_at = 0; // let VecDeinit run copy_deinit on the live originals
        VecDeinit(&vec);
        return result;
    }

In Insert.c:1985:

    
        g_fail_at = 0;
        VecDeinit(&vec);
        return result;
    }

In Type.c:35:

    
        // Clean up
        VecDeinit(&vec);
    
        // Test with a struct type

In Type.c:47:

    
        // Clean up
        VecDeinit(&test_vec);
    
        DefaultAllocatorDeinit(&alloc);

In Type.c:67:

    
        // Clean up
        VecDeinit(&vec);
    
        // Note: We can't easily test the negative case (invalid vector)

In Remove.c:159:

    
        // Clean up
        VecDeinit(&vec);
    
        return result;

In Remove.c:207:

    
        // Clean up
        VecDeinit(&vec);
    
        return result;

In Remove.c:255:

    
        // Clean up
        VecDeinit(&vec);
    
        return result;

In Remove.c:292:

    
        // Clean up
        VecDeinit(&vec);
    
        return result;

In Remove.c:328:

    
        // Clean up
        VecDeinit(&vec);
    
        return result;

In Remove.c:404:

    
        // Clean up
        VecDeinit(&vec);
    
        return result;

In Remove.c:450:

    
        // Clean up
        VecDeinit(&vec);
    
        return result;

In Remove.c:486:

    
        // Clean up
        VecDeinit(&vec);
    
        return result;

In Remove.c:521:

    
        // Clean up
        VecDeinit(&vec);
    
        return result;

In Remove.c:602:

    
        // Clean up
        VecDeinit(&vec);
    
        return result;

In Remove.c:679:

    
        // Clean up
        VecDeinit(&vec);
    
        return result;

In Remove.c:716:

    
        // Clean up
        VecDeinit(&vec);
    
        return result;

In Remove.c:751:

    
        // Clean up
        VecDeinit(&vec);
    
        return result;

In Remove.c:830:

    
        // Clean up
        VecDeinit(&vec);
    
        return result;

In Remove.c:907:

    
        // Clean up
        VecDeinit(&vec);
    
        return result;

In Remove.c:934:

        bool result = (VecLen(&vec) == 0);
    
        VecDeinit(&vec);
        return result;
    }

In Remove.c:956:

        bool result = (out[0] == 10) && (out[1] == 20);
    
        VecDeinit(&vec);
        return result;
    }

In Remove.c:978:

        bool result = (out[0] == 11) && (out[1] == 22);
    
        VecDeinit(&vec);
        return result;
    }

In Remove.c:1001:

        bool result = (g_deinit_count == 3);
    
        VecDeinit(&vec);
        return result;
    }

In Remove.c:1023:

        bool result = (g_deinit_count == 3);
    
        VecDeinit(&vec);
        return result;
    }

In Remove.c:1046:

        bool result = (g_deinit_count == 2);
    
        VecDeinit(&vec);
        return result;
    }

In Remove.c:1068:

        bool result = (g_deinit_count == 3);
    
        VecDeinit(&vec);
        return result;
    }

In Remove.c:1093:

            (g_deinit_nvals == 3) && (g_deinit_vals[0] == 10) && (g_deinit_vals[1] == 20) && (g_deinit_vals[2] == 30);
    
        VecDeinit(&vec);
        return result;
    }

In Remove.c:1116:

        bool result = (VecLen(&vec) == 3) && (*VecPtrAt(&vec, 4) == 0);
    
        VecDeinit(&vec);
        return result;
    }

In Remove.c:1137:

        bool result = (VecLen(&vec) == 3) && (*VecPtrAt(&vec, 4) == 0);
    
        VecDeinit(&vec);
        return result;
    }

In Remove.c:1162:

        bool result = (VecLen(&vec) == (u64)N - K);
    
        VecDeinit(&vec);
        return result;
    }

In Remove.c:1182:

        bool result = (g_freed[0] == 1 && g_freed[1] == 1);
    
        VecDeinit(&vec);
        return result;
    }

In Remove.c:1198:

        bool result = (g_freed[0] == 1 && g_freed[1] == 1);
    
        VecDeinit(&vec);
        return result;
    }

In Remove.c:1215:

        bool result = (g_freed[2] == 0 && g_freed[0] == 1 && g_freed[1] == 1);
    
        VecDeinit(&vec);
        return result;
    }

In Remove.c:1230:

        bool result = (g_freed[0] == 1 && g_freed[1] == 1 && g_freed[2] == 1);
    
        VecDeinit(&vec);
        return result;
    }

In Remove.c:1245:

        bool result = (g_freed[1] == 1 && g_freed[2] == 1 && g_freed[3] == 1);
    
        VecDeinit(&vec);
        return result;
    }

In Remove.c:1268:

                      (VecAt(&vec, 20000) == 20002);
    
        VecDeinit(&vec);
        return result;
    }

In Remove.c:1291:

        bool result = (VecLen(&vec) == (u64)N - K) && (VecAt(&vec, 0) == (int)K) && (VecAt(&vec, 19999) == (int)(N - 1));
    
        VecDeinit(&vec);
        return result;
    }

In Remove.c:1312:

                      (VecAt(&vec, (u64)(N - 3)) == (int)(N - 1));
    
        VecDeinit(&vec);
        return result;
    }

In Remove.c:1331:

        bool result = (VecLen(&vec) == 8 && *VecPtrAt(&vec, 9) == 0);
    
        VecDeinit(&vec);
        return result;
    }

In Remove.c:1350:

        bool result = (VecLen(&vec) == 8 && *VecPtrAt(&vec, 9) == 0);
    
        VecDeinit(&vec);
        return result;
    }

In Remove.c:1374:

        bool result = (VecLen(&vec) == (u64)N - K) && (VecAt(&vec, 0) == (int)K);
    
        VecDeinit(&vec);
        return result;
    }

In Remove.c:1422:

        result = result && (VecAt(&vec, old_len - 2) == (u64)(old_len - 1));
    
        VecDeinit(&vec);
        return result;
    }

In Remove.c:1458:

        result = result && (VecAt(&vec, 0) == (u64)old_len);
    
        VecDeinit(&vec);
        return result;
    }

In Foreach.c:64:

    
        // Clean up
        VecDeinit(&vec);
    
        return result;

In Foreach.c:100:

    
        // Clean up
        VecDeinit(&vec);
    
        return result;

In Foreach.c:141:

    
        // Clean up
        VecDeinit(&vec);
    
        return result;

In Foreach.c:172:

    
        // Clean up
        VecDeinit(&vec);
    
        return result;

In Foreach.c:205:

    
        // Clean up
        VecDeinit(&vec);
    
        return result;

In Foreach.c:232:

    
        // Clean up
        VecDeinit(&vec);
    
        return result;

In Foreach.c:266:

    
        // Clean up
        VecDeinit(&vec);
    
        return result;

In Foreach.c:301:

    
        // Clean up
        VecDeinit(&vec);
    
        return result;

In Foreach.c:334:

            if (iteration_count > 2) {
                LOG_ERROR("Should've terminated");
                VecDeinit(&vec);
                return false;
            }

In Foreach.c:342:

    
        // Should never reach here if bounds checking triggers
        VecDeinit(&vec);
        return true;
    }

In Foreach.c:374:

            if (idx > 2) {
                LOG_ERROR("Should've terminated");
                VecDeinit(&vec);
                return false;
            }

In Foreach.c:380:

    
        // Should never reach here if bounds checking triggers
        VecDeinit(&vec);
        return true;
    }

In Foreach.c:413:

            if (idx < 4) {
                LOG_ERROR("Should've terminated");
                VecDeinit(&vec);
                return false;
            }

In Foreach.c:419:

    
        // Should never reach here if bounds checking triggers
        VecDeinit(&vec);
        return true;
    }

In Foreach.c:451:

            if (idx > 3) {
                LOG_ERROR("Should've terminated");
                VecDeinit(&vec);
                return false;
            }

In Foreach.c:457:

    
        // Should never reach here if bounds checking triggers
        VecDeinit(&vec);
        return true;
    }

In Foreach.c:488:

            if (idx < 5) {
                LOG_ERROR("Should've terminated");
                VecDeinit(&vec);
                return false;
            }

In Foreach.c:494:

    
        // Should never reach here if bounds checking triggers
        VecDeinit(&vec);
        return true;
    }

In Foreach.c:526:

            if (idx > VecLen(&vec)) {
                LOG_ERROR("Should've terminated");
                VecDeinit(&vec);
                return false;
            }

In Foreach.c:532:

    
        // Should never reach here if bounds checking triggers
        VecDeinit(&vec);
        return true;
    }

In Foreach.c:564:

            if (idx > 2) {
                LOG_ERROR("Should've terminated");
                VecDeinit(&vec);
                return false;
            }

In Foreach.c:570:

    
        // Should never reach here if bounds checking triggers
        VecDeinit(&vec);
        return true;
    }

In Access.c:57:

    
        // Clean up
        VecDeinit(&vec);
    
        DefaultAllocatorDeinit(&alloc);

In Access.c:97:

    
        // Clean up
        VecDeinit(&vec);
    
        DefaultAllocatorDeinit(&alloc);

In Access.c:131:

    
        // Clean up
        VecDeinit(&vec);
    
        DefaultAllocatorDeinit(&alloc);

In Access.c:164:

    
        // Clean up
        VecDeinit(&vec);
    
        DefaultAllocatorDeinit(&alloc);

In Access.c:200:

    
        // Clean up
        VecDeinit(&vec);
    
        // Same self-consistency on a higher-alignment allocator: the stride is

In Access.c:219:

    
        // Clean up
        VecDeinit(&aligned_vec);
    
        HeapAllocatorDeinit(&aligned8);

In Access.c:243:

    
        // Clean up
        VecDeinit(&vec);
    
        // The element stride is `sizeof(T)` regardless of the allocator's base

In Access.c:256:

    
        // Clean up
        VecDeinit(&aligned_vec);
    
        HeapAllocatorDeinit(&aligned8);

In Access.c:289:

        result = result && (VecFind(&vec, &missing, compare_ints) == SIZE_MAX);
    
        VecDeinit(&vec);
        DefaultAllocatorDeinit(&alloc);
        return result;

In Access.c:317:

        }
    
        VecDeinit(&vec);
        HeapAllocatorDeinit(&alloc);
        return result;

In Access.c:346:

                      (VecAt(&dst, 3) == 40);
    
        VecDeinit(&src);
        VecDeinit(&dst);
        DefaultAllocatorDeinit(&alloc);

In Access.c:347:

    
        VecDeinit(&src);
        VecDeinit(&dst);
        DefaultAllocatorDeinit(&alloc);
        return result;

In Pattern.Deadend.c:312:

        BitVecPush(VecPtrAt(&vp, 0), true);
        BitVecPrefixMatch(NULL, &vp);
        VecDeinit(&vp);
        DefaultAllocatorDeinit(&alloc);
        return true;

In Pattern.Deadend.c:335:

        BitVecPush(VecPtrAt(&vp, 0), true);
        BitVecSuffixMatch(NULL, &vp);
        VecDeinit(&vp);
        DefaultAllocatorDeinit(&alloc);
        return true;

In Pattern.Deadend.c:619:

        BitVecPrefixMatch(NULL, &patterns);
    
        VecDeinit(&patterns);
        DefaultAllocatorDeinit(&alloc);
        return true;

In Pattern.Deadend.c:639:

        BitVecSuffixMatch(NULL, &patterns);
    
        VecDeinit(&patterns);
        DefaultAllocatorDeinit(&alloc);
        return true;

In Foreach.Simple.c:550:

        }
    
        VecDeinit(&runs);
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);

In Pattern.Simple.c:306:

        }
    
        VecDeinit(&matches);
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);

In Pattern.Simple.c:988:

        result        = result && (match_idx == 1);
    
        VecDeinit(&patterns);
        BitVecDeinit(&source);
        DefaultAllocatorDeinit(&alloc);

In Pattern.Simple.c:1040:

        result        = result && (match_idx == 1);
    
        VecDeinit(&patterns);
        BitVecDeinit(&source);
        DefaultAllocatorDeinit(&alloc);

In Pattern.Simple.c:1108:

        }
    
        VecDeinit(&matches);
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);

In Arena.c:85:

    
        ok = ok && VecLen(&v) == 4096 && VecAt(&v, 0) == 0 && VecAt(&v, 4095) == 4095;
        VecDeinit(&v);
        ArenaAllocatorDeinit(&arena);
        return ok;

In Page.c:82:

    
        ok = ok && (VecLen(&v) == 1024) && (VecAt(&v, 0) == 0) && (VecAt(&v, 1023) == 1023);
        VecDeinit(&v);
        PageAllocatorDeinit(&alloc);
        return ok;

In Ops.c:218:

        }
    
        VecDeinit(&split);
    
        // Test StrSplitToIters

In Ops.c:244:

        }
    
        VecDeinit(&iters);
        StrDeinit(&s);
        DefaultAllocatorDeinit(&alloc);

In Ops.c:495:

        }
    
        VecDeinit(&iters);
        StrDeinit(&s);
        DefaultAllocatorDeinit(&alloc);

In Ops.c:520:

        }
    
        VecDeinit(&split);
        StrDeinit(&s);
        DefaultAllocatorDeinit(&alloc);

In Ops.c:543:

        }
    
        VecDeinit(&split);
        StrDeinit(&s);
        DefaultAllocatorDeinit(&alloc);

In Ops.c:877:

        StrIters iters            = StrSplitToIters(&s, ",");
    
        VecDeinit(&iters);
        GENERIC_VEC(&s)->__magic ^= 0x1;
        StrDeinit(&s);

In Ops.c:936:

    
        GENERIC_VEC(VecPtrAt(&strs, 0))->__magic ^= 0x1;
        VecDeinit(&strs);
        StrDeinit(&s);
        DefaultAllocatorDeinit(&alloc);

In Init.c:292:

        bool produced = VecLen(&parts) == 4 && DebugAllocatorLiveCount(&dbg) > before;
    
        VecDeinit(&parts); // invokes str_deinit per element on real code.
        size after = DebugAllocatorLiveCount(&dbg);

In Type.c:71:

        }
    
        VecDeinit(&sv); // This should call StrDeinit on each element
        DefaultAllocatorDeinit(&alloc);
        return result;

In Type.c:116:

        bool result = true; // If we got here, the validation didn't crash
    
        VecDeinit(&sv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In Backtrace.c:85:

    
        StrDeinit(&rendered);
        VecDeinit(&frames);
        DefaultAllocatorDeinit(&alloc);
        return ok;

In SysDns.c:169:

        }
    
        VecDeinit(&out);
        DnsResolverDeinit(&r);
        DefaultAllocatorDeinit(&alloc);

In SysDns.c:186:

        bool     got = DnsResolve(&r, "LocalHost", 0, SOCKET_KIND_TCP, &out);
    
        VecDeinit(&out);
        DnsResolverDeinit(&r);
        DefaultAllocatorDeinit(&alloc);

In SysDns.c:203:

        bool     got = DnsResolve(&r, "localhost.", 0, SOCKET_KIND_TCP, &out);
    
        VecDeinit(&out);
        DnsResolverDeinit(&r);
        DefaultAllocatorDeinit(&alloc);

In SysDns.c:227:

        }
    
        VecDeinit(&out);
        DnsResolverDeinit(&r);
        DefaultAllocatorDeinit(&alloc);

In SysDns.c:251:

        }
    
        VecDeinit(&out);
        DnsResolverDeinit(&r);
        DefaultAllocatorDeinit(&alloc);

In SysDns.c:280:

        }
    
        VecDeinit(&out);
        DnsResolverDeinit(&r);
        DefaultAllocatorDeinit(&alloc);

In SysDns.c:322:

        bool ok = !got && VecLen(&out) == 0;
    
        VecDeinit(&out);
        DnsResolverDeinit(&r);
        DefaultAllocatorDeinit(&alloc);

In SysDns.c:341:

        bool ok = !got;
    
        VecDeinit(&out);
        DnsResolverDeinit(&r);
        DefaultAllocatorDeinit(&alloc);

In SysDns.c:1029:

        bool ok = got && VecLen(&out) == 1 && v4_is(VecPtrAt(&out, 0), a, "10.0.0.1:80");
    
        VecDeinit(&out);
        DnsResolverDeinit(&r);
        DefaultAllocatorDeinit(&alloc);

In SysDns.c:1049:

        bool ok = got && VecLen(&out) == 1 && v4_is(VecPtrAt(&out, 0), a, "10.0.0.2:80");
    
        VecDeinit(&out);
        DnsResolverDeinit(&r);
        DefaultAllocatorDeinit(&alloc);

In SysDns.c:1069:

        bool ok = got && VecLen(&out) == 1 && v4_is(VecPtrAt(&out, 0), a, "10.0.0.3:80");
    
        VecDeinit(&out);
        DnsResolverDeinit(&r);
        DefaultAllocatorDeinit(&alloc);

In SysDns.c:1089:

        bool ok = !got && VecLen(&out) == 0;
    
        VecDeinit(&out);
        DnsResolverDeinit(&r);
        DefaultAllocatorDeinit(&alloc);

In SysDns.c:1130:

        }
    
        VecDeinit(&out);
        DnsResolverDeinit(&r);
        DefaultAllocatorDeinit(&alloc);

In SysDns.c:1170:

        }
    
        VecDeinit(&out);
        DnsResolverDeinit(&r);
        DefaultAllocatorDeinit(&alloc);

In SysDns.c:1357:

            StrDeinit(p);
        }
        VecDeinit(&paths);
        DnsResolverDeinit(&r);
        DefaultAllocatorDeinit(&alloc);

In SysDns.c:1388:

            StrDeinit(p);
        }
        VecDeinit(&paths);
        DnsResolverDeinit(&r);
        DefaultAllocatorDeinit(&alloc);

In SysDns.c:1419:

            StrDeinit(p);
        }
        VecDeinit(&paths);
        DnsResolverDeinit(&r);
        DefaultAllocatorDeinit(&alloc);

In SysDns.c:1501:

        bool ok = got && VecLen(&out) == 1 && v4_is(VecPtrAt(&out, 0), a, "1.2.3.4:80");
    
        VecDeinit(&out);
        DnsResolverDeinit(&r);
        DefaultAllocatorDeinit(&alloc);

In SysDns.c:1520:

                  v4_is(VecPtrAt(&out, 1), a, "9.10.11.12:1234");
    
        VecDeinit(&out);
        DnsResolverDeinit(&r);
        DefaultAllocatorDeinit(&alloc);

In SysDns.c:1539:

                  v6_is(VecPtrAt(&out, 1), a, "[2606::1]:443");
    
        VecDeinit(&out);
        DnsResolverDeinit(&r);
        DefaultAllocatorDeinit(&alloc);

In SysDns.c:1557:

        bool ok = got && VecLen(&out) == 1 && v6_is(VecPtrAt(&out, 0), a, "[::1]:53");
    
        VecDeinit(&out);
        DnsResolverDeinit(&r);
        DefaultAllocatorDeinit(&alloc);

In SysDns.c:1575:

        bool ok = got && VecLen(&out) == 1 && v4_is(VecPtrAt(&out, 0), a, "1.2.3.4:80");
    
        VecDeinit(&out);
        DnsResolverDeinit(&r);
        DefaultAllocatorDeinit(&alloc);

In SysDns.c:1593:

        bool ok = !got && VecLen(&out) == 0;
    
        VecDeinit(&out);
        DnsResolverDeinit(&r);
        DefaultAllocatorDeinit(&alloc);

In SysDns.c:1617:

        bool ok = !got && VecLen(&out) == 0;
    
        VecDeinit(&out);
        DnsResolverDeinit(&r);
        DefaultAllocatorDeinit(&alloc);

In SysDns.c:1641:

        bool ok = !got && VecLen(&out) == 0;
    
        VecDeinit(&out);
        DnsResolverDeinit(&r);
        DefaultAllocatorDeinit(&alloc);

In SysDns.c:1671:

        bool ok = got && VecLen(&out) == 1 && v4_is(VecPtrAt(&out, 0), a, "1.2.3.4:80");
    
        VecDeinit(&out);
        DnsResolverDeinit(&r);
        DefaultAllocatorDeinit(&alloc);

In SysDns.c:1690:

        bool ok = !got && VecLen(&out) == 0;
    
        VecDeinit(&out);
        DnsResolverDeinit(&r);
        DefaultAllocatorDeinit(&alloc);

In SysDns.c:1711:

    
        StrDeinit(&name);
        VecDeinit(&out);
        DnsResolverDeinit(&r);
        DefaultAllocatorDeinit(&alloc);

In SysDns.c:1729:

        bool ok = got && VecLen(&out) == 1 && v4_is(VecPtrAt(&out, 0), a, "1.2.3.4:80");
    
        VecDeinit(&out);
        DnsResolverDeinit(&r);
        DefaultAllocatorDeinit(&alloc);

In SysDns.c:1748:

                  v4_is(VecPtrAt(&out, 1), a, "9.10.11.12:9090");
    
        VecDeinit(&out);
        DnsResolverDeinit(&r);
        DefaultAllocatorDeinit(&alloc);

In SysDns.c:1766:

        bool ok = got && VecLen(&out) == 1 && v4_is(VecPtrAt(&out, 0), a, "203.0.113.7:9999");
    
        VecDeinit(&out);
        DnsResolverDeinit(&r);
        DefaultAllocatorDeinit(&alloc);

In SysDns.c:1784:

        bool ok = !got && VecLen(&out) == 0;
    
        VecDeinit(&out);
        DnsResolverDeinit(&r);
        DefaultAllocatorDeinit(&alloc);

In SysDns.c:1802:

        bool ok = !got && VecLen(&out) == 0;
    
        VecDeinit(&out);
        DnsResolverDeinit(&r);
        DefaultAllocatorDeinit(&alloc);

In SysDns.c:1820:

        bool ok = !got && VecLen(&out) == 0;
    
        VecDeinit(&out);
        DnsResolverDeinit(&r);
        DefaultAllocatorDeinit(&alloc);

In SysDns.c:1838:

        bool ok = got && VecLen(&out) == 1 && v4_is(VecPtrAt(&out, 0), a, "1.2.3.4:65535");
    
        VecDeinit(&out);
        DnsResolverDeinit(&r);
        DefaultAllocatorDeinit(&alloc);

In SysDns.c:1865:

        bool ok = !got && VecLen(&out) == 0;
    
        VecDeinit(&out);
        DnsResolverDeinit(&r);
        DefaultAllocatorDeinit(&alloc);

In SysDns.c:1883:

        bool ok = !got && VecLen(&out) == 0;
    
        VecDeinit(&out);
        DnsResolverDeinit(&r);
        DefaultAllocatorDeinit(&alloc);

In SysDns.c:1904:

    
        StrDeinit(&spec);
        VecDeinit(&out);
        DnsResolverDeinit(&r);
        DefaultAllocatorDeinit(&alloc);

In SysDns.c:2013:

        }
    
        VecDeinit(&out);
        DnsResolverDeinit(&r);
        DefaultAllocatorDeinit(&alloc);

In Dns.c:34:

        }
    
        VecDeinit(&buf);
        DefaultAllocatorDeinit(&alloc);
        return match;

In Dns.c:55:

        }
    
        VecDeinit(&no_dot);
        VecDeinit(&w_dot);
        DefaultAllocatorDeinit(&alloc);

In Dns.c:56:

    
        VecDeinit(&no_dot);
        VecDeinit(&w_dot);
        DefaultAllocatorDeinit(&alloc);
        return match;

In Dns.c:328:

        }
    
        VecDeinit(&buf);
        DefaultAllocatorDeinit(&alloc);
        return match;

In Dns.c:346:

                     BufData(&buf)[14] == 0x01 && BufData(&buf)[15] == 0x00 && BufData(&buf)[16] == 0x01;
    
        VecDeinit(&buf);
        DefaultAllocatorDeinit(&alloc);
        return match;

In Dns.c:370:

        bool match = ok && BufLength(&buf) == 81 && BufData(&buf)[12] == 63;
    
        VecDeinit(&buf);
        DefaultAllocatorDeinit(&alloc);
        return match;

In Dns.c:393:

        }
    
        VecDeinit(&no_dot);
        VecDeinit(&w_dot);
        DefaultAllocatorDeinit(&alloc);

In Dns.c:394:

    
        VecDeinit(&no_dot);
        VecDeinit(&w_dot);
        DefaultAllocatorDeinit(&alloc);
        return match;

In Dns.c:432:

        bool match = ok && BufLength(&buf) == 237;
    
        VecDeinit(&buf);
        DefaultAllocatorDeinit(&alloc);
        return match;

In Dns.c:455:

        bool match = ok && BufLength(&buf) == 271;
    
        VecDeinit(&buf);
        DefaultAllocatorDeinit(&alloc);
        return match;

In Dns.c:485:

        }
    
        VecDeinit(&buf);
        StrDeinit(&name);
        DefaultAllocatorDeinit(&alloc);

In Dns.c:1601:

        bool match = !ok; // empty internal label must be rejected.
    
        VecDeinit(&buf);
        DefaultAllocatorDeinit(&alloc);
        return match;

In Http.c:311:

    
        // VecDeinit runs http_header_deinit on the surviving copy.
        VecDeinit(&headers);
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);

In Read.Simple.c:47:

    void SimpleProductDeinit(SimpleProduct *product) {
        StrDeinit(&product->name);
        VecDeinit(&product->tags);
    }

In Read.Simple.c:338:

    
        StrDeinit(&json);
        VecDeinit(&languages);
        DefaultAllocatorDeinit(&alloc);
        return success;

In Write.EdgeCases.c:120:

    
        StrDeinit(&json);
        VecDeinit(&empty_numbers);
        VecDeinit(&empty_strings);
        DefaultAllocatorDeinit(&alloc);

In Write.EdgeCases.c:121:

        StrDeinit(&json);
        VecDeinit(&empty_numbers);
        VecDeinit(&empty_strings);
        DefaultAllocatorDeinit(&alloc);
        return success;

In Write.EdgeCases.c:363:

    
        StrDeinit(&json);
        VecDeinit(&empty_list);
        DefaultAllocatorDeinit(&alloc);
        return success;

In Write.EdgeCases.c:404:

    
        StrDeinit(&json);
        VecDeinit(&empty_arr);
        VecDeinit(&filled_arr);
        DefaultAllocatorDeinit(&alloc);

In Write.EdgeCases.c:405:

        StrDeinit(&json);
        VecDeinit(&empty_arr);
        VecDeinit(&filled_arr);
        DefaultAllocatorDeinit(&alloc);
        return success;

In Write.Nested.c:66:

        StrDeinit(&result->binary_name);
        StrDeinit(&result->sha256);
        VecDeinit(&result->tags);
        StrDeinit(&result->created_at);
        StrDeinit(&result->model_name);

In Write.Nested.c:296:

        StrDeinit(&json);
        StrDeinit(&response.message);
        VecDeinit(&response.data);
        DefaultAllocatorDeinit(&alloc);
        return success;

In Write.Nested.c:336:

    
        StrDeinit(&json);
        VecDeinit(&functions);
        DefaultAllocatorDeinit(&alloc);
        return success;

In Write.Nested.c:457:

    
    StrDeinit(&json);
    VecDeinit(&symbols);
    return success;
    }

In Write.Nested.c:544:

    
        StrDeinit(&json);
        VecDeinit(&numbers);
        VecDeinit(&strings);
        VecDeinit(&booleans);

In Write.Nested.c:545:

        StrDeinit(&json);
        VecDeinit(&numbers);
        VecDeinit(&strings);
        VecDeinit(&booleans);
        DefaultAllocatorDeinit(&alloc);

In Write.Nested.c:546:

        VecDeinit(&numbers);
        VecDeinit(&strings);
        VecDeinit(&booleans);
        DefaultAllocatorDeinit(&alloc);
        return success;

In Read.Nested.c:88:

            StrDeinit(&tag);
        }
        VecDeinit(&result->tags);
        StrDeinit(&result->created_at);
        StrDeinit(&result->model_name);

In Read.Nested.c:441:

    
        StrDeinit(&json);
        VecDeinit(&symbols);
        DefaultAllocatorDeinit(&alloc);
        return success;

In Read.Nested.c:593:

        StrDeinit(&json);
        StrDeinit(&response.message);
        VecDeinit(&response.data);
        DefaultAllocatorDeinit(&alloc);
        return success;

In Read.Nested.c:944:

        StrDeinit(&json);
        StrDeinit(&response.message);
        VecDeinit(&response.data);
        DefaultAllocatorDeinit(&alloc);
        return success;

In Read.Nested.c:1118:

        StrDeinit(&json);
        StrDeinit(&response.message);
        VecDeinit(&response.data);
        DefaultAllocatorDeinit(&alloc);
        return success;

In Write.Simple.c:43:

    void SimpleProductDeinit(SimpleProduct *product) {
        StrDeinit(&product->name);
        VecDeinit(&product->tags);
    }

In Write.Simple.c:271:

    
        StrDeinit(&json);
        VecDeinit(&languages);
        DefaultAllocatorDeinit(&alloc);
        return success;

In Read.EdgeCases.c:28:

    void EdgeCaseDataDeinit(EdgeCaseData *data) {
        StrDeinit(&data->empty_string);
        VecDeinit(&data->empty_array);
        VecDeinit(&data->numbers);
    }

In Read.EdgeCases.c:29:

        StrDeinit(&data->empty_string);
        VecDeinit(&data->empty_array);
        VecDeinit(&data->numbers);
    }

In Read.EdgeCases.c:161:

        StrDeinit(&json1);
        StrDeinit(&json2);
        VecDeinit(&items);
        VecDeinit(&data);
        DefaultAllocatorDeinit(&alloc);

In Read.EdgeCases.c:162:

        StrDeinit(&json2);
        VecDeinit(&items);
        VecDeinit(&data);
        DefaultAllocatorDeinit(&alloc);
        return success;

In Read.EdgeCases.c:665:

    
        StrDeinit(&json);
        VecDeinit(&obj.filled_items);
        DefaultAllocatorDeinit(&alloc);
        return success;

In RoundTrip.c:45:

    void TestConfigDeinit(TestConfig *config) {
        StrDeinit(&config->log_level);
        VecDeinit(&config->features);
    }

In RoundTrip.c:51:

        TestPersonDeinit(&data->user);
        TestConfigDeinit(&data->config);
        VecDeinit(&data->numbers);
        VecDeinit(&data->flags);
    }

In RoundTrip.c:52:

        TestConfigDeinit(&data->config);
        VecDeinit(&data->numbers);
        VecDeinit(&data->flags);
    }

In RoundTrip.c:458:

        // Cleanup
        StrDeinit(&json);
        VecDeinit(&original_numbers);
        VecDeinit(&original_strings);
        VecDeinit(&parsed_numbers);

In RoundTrip.c:459:

        StrDeinit(&json);
        VecDeinit(&original_numbers);
        VecDeinit(&original_strings);
        VecDeinit(&parsed_numbers);
        VecDeinit(&parsed_strings);

In RoundTrip.c:460:

        VecDeinit(&original_numbers);
        VecDeinit(&original_strings);
        VecDeinit(&parsed_numbers);
        VecDeinit(&parsed_strings);
        DefaultAllocatorDeinit(&alloc);

In RoundTrip.c:461:

        VecDeinit(&original_strings);
        VecDeinit(&parsed_numbers);
        VecDeinit(&parsed_strings);
        DefaultAllocatorDeinit(&alloc);
        return success;

In RoundTrip.c:735:

        StrDeinit(&empty_str);
        StrDeinit(&parsed_str);
        VecDeinit(&empty_numbers);
        VecDeinit(&empty_strings);
        VecDeinit(&parsed_numbers);

In RoundTrip.c:736:

        StrDeinit(&parsed_str);
        VecDeinit(&empty_numbers);
        VecDeinit(&empty_strings);
        VecDeinit(&parsed_numbers);
        VecDeinit(&parsed_strings);

In RoundTrip.c:737:

        VecDeinit(&empty_numbers);
        VecDeinit(&empty_strings);
        VecDeinit(&parsed_numbers);
        VecDeinit(&parsed_strings);
        DefaultAllocatorDeinit(&alloc);

In RoundTrip.c:738:

        VecDeinit(&empty_strings);
        VecDeinit(&parsed_numbers);
        VecDeinit(&parsed_strings);
        DefaultAllocatorDeinit(&alloc);
        return success;

Last updated on July 1, 2026

VecClear VecForeach