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 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 PdbCache.c:129:

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

In SymbolResolver.c:188:

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

In SymbolResolver.c:222:

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

In ProcMaps.c:244:

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

In Dir.c:570:

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

In MachoCache.c:143:

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

In Dns.c:340:

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

In Dns.c:343:

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

In Dns.c:443:

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

In Dns.c:450:

        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:633:

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

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 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:494:

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

In Elf.c:495:

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

In Elf.c:496:

        VecDeinit(&self->sections);
        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 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 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 DwarfUnwind.c:464:

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

In DwarfUnwind.c:465:

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

In Dns.c:326:

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

In Dns.c:336:

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

In Pe.c:573:

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

In Resolve.c:57:

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

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 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 Read.EdgeCases.c:27:

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

In Read.EdgeCases.c:28:

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

In Read.EdgeCases.c:150:

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

In Read.EdgeCases.c:151:

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

In Read.EdgeCases.c:586:

    
        StrDeinit(&json);
        VecDeinit(&obj.filled_items);
        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 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 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 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 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 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:459:

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

In RoundTrip.c:460:

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

In RoundTrip.c:461:

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

In RoundTrip.c:462:

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

In RoundTrip.c:736:

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

In RoundTrip.c:737:

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

In RoundTrip.c:738:

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

In RoundTrip.c:739:

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

In Str.Ops.c:218:

        }
    
        VecDeinit(&split);
    
        // Test StrSplitToIters

In Str.Ops.c:244:

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

In Backtrace.c:85:

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

In Allocator.Page.c:82:

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

In Vec.Ops.c:60:

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

In Vec.Ops.c:112:

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

In Vec.Ops.c:151:

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

In SysDns.c:37:

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

In SysDns.c:54:

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

In SysDns.c:72:

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

In SysDns.c:98:

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

In SysDns.c:123:

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

In SysDns.c:153:

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

In SysDns.c:196:

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

In SysDns.c:215:

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

In Vec.Foreach.c:64:

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

In Vec.Foreach.c:100:

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

In Vec.Foreach.c:141:

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

In Vec.Foreach.c:172:

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

In Vec.Foreach.c:205:

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

In Vec.Foreach.c:232:

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

In Vec.Foreach.c:266:

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

In Vec.Foreach.c:301:

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

In Vec.Foreach.c:334:

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

In Vec.Foreach.c:342:

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

In Vec.Foreach.c:374:

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

In Vec.Foreach.c:380:

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

In Vec.Foreach.c:413:

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

In Vec.Foreach.c:419:

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

In Vec.Foreach.c:451:

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

In Vec.Foreach.c:457:

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

In Vec.Foreach.c:488:

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

In Vec.Foreach.c:494:

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

In Vec.Foreach.c:526:

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

In Vec.Foreach.c:532:

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

In Vec.Foreach.c:564:

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

In Vec.Foreach.c:570:

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

In BitVec.Pattern.Simple.c:286:

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

In BitVec.Pattern.Simple.c:960:

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

In BitVec.Pattern.Simple.c:1012:

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

In Allocator.Arena.c:85:

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

In Vec.Init.c:56:

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

In Vec.Init.c:69:

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

In Vec.Init.c:90:

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

In Vec.Init.c:103:

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

In Vec.Init.c:125:

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

In Vec.Init.c:147:

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

In Vec.Init.c:192:

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

In Vec.Init.c:193:

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

In Vec.Init.c:194:

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

In Vec.Init.c:195:

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

In Vec.Init.c:196:

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

In Vec.Init.c:197:

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

In Vec.Init.c:198:

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

In Vec.Init.c:199:

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

In Vec.Init.c:316:

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

In Vec.Init.c:317:

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

In Vec.Memory.c:49:

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

In Vec.Memory.c:97:

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

In Vec.Memory.c:144:

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

In Vec.Memory.c:185:

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

In Vec.Remove.c:72:

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

In Vec.Remove.c:120:

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

In Vec.Remove.c:168:

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

In Vec.Remove.c:205:

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

In Vec.Remove.c:241:

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

In Vec.Remove.c:317:

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

In Vec.Remove.c:363:

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

In Vec.Remove.c:399:

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

In Vec.Remove.c:434:

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

In Vec.Remove.c:515:

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

In Vec.Remove.c:592:

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

In Vec.Remove.c:629:

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

In Vec.Remove.c:664:

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

In Vec.Remove.c:743:

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

In Vec.Remove.c:820:

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

In BitVec.Foreach.Simple.c:550:

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

In Str.Type.c:71:

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

In Str.Type.c:116:

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

In Vec.Complex.c:215:

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

In Vec.Complex.c:259:

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

In Vec.Complex.c:302:

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

In Vec.Complex.c:377:

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

In Vec.Complex.c:378:

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

In Vec.Complex.c:379:

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

In Vec.Complex.c:380:

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

In Vec.Complex.c:428:

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

In Vec.Complex.c:471:

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

In Vec.Complex.c:505:

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

In Vec.Complex.c:544:

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

In Vec.Complex.c:575:

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

In Vec.Complex.c:596:

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

In Vec.Complex.c:624:

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

In Vec.Complex.c:646:

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

In Vec.Complex.c:658:

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

In Vec.Complex.c:684:

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

In Vec.Complex.c:719:

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

In Vec.Complex.c:785:

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

In Vec.Complex.c:816:

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

In Vec.Complex.c:853:

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

In Vec.Complex.c:854:

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

In Vec.Complex.c:891:

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

In Vec.Access.c:53:

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

In Vec.Access.c:93:

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

In Vec.Access.c:127:

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

In Vec.Access.c:160:

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

In Vec.Access.c:196:

    
        // Clean up
        VecDeinit(&vec);
    
        // Test with a vector with alignment > 1

In Vec.Access.c:214:

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

In Vec.Access.c:238:

    
        // Clean up
        VecDeinit(&vec);
    
        // Create a vector with 8-byte alignment

In Vec.Access.c:253:

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

In Vec.Access.c:286:

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

In Vec.Type.c:35:

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

In Vec.Type.c:48:

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

In Vec.Type.c:68:

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

In Vec.Insert.c:48:

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

In Vec.Insert.c:76:

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

In Vec.Insert.c:111:

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

In Vec.Insert.c:152:

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

In Vec.Insert.c:193:

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

In Vec.Insert.c:226:

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

In Vec.Insert.c:263:

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

In Vec.Insert.c:264:

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

In Vec.Insert.c:304:

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

In Vec.Insert.c:305:

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

In Vec.Insert.c:349:

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

In Vec.Insert.c:350:

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

In Vec.Insert.c:433:

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

In Vec.Insert.c:508:

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

In Vec.Insert.c:509:

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

In Vec.Insert.c:563:

        }
    
        VecDeinit(&vec);
        return result;
    }

In Dns.c:32:

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

In Dns.c:53:

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

In Dns.c:54:

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

In BitVec.Pattern.Deadend.c:292:

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

In BitVec.Pattern.Deadend.c:315:

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

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,                                                                       \

Last updated on June 4, 2026

VecCopyInit VecDelete