VecInit

Documentation

API Reference

VecInit

Description

Initialize a Vec bound to an allocator. The argument may be either a typed allocator handle (&heap, &arena, …) or a raw Allocator * — ALLOCATOR_OF typechecks both at compile time and converts to Allocator * via a whole-pointer typecast.

Inside a Scope(...) block the allocator argument may be omitted; the macro then binds to the internal MisraScope allocator the scope provides. Outside a Scope, calling VecInit() with no argument fails to compile because MisraScope is undeclared - the safety net the design relies on.

Usage example (from documentation)

  Scope(alloc, DefaultAllocator) {
      Vec(int) v = VecInit();      // uses MisraScope
      Vec(int) w = VecInit(alloc); // uses the named user-pool
      ...
      VecDeinit(&v);
      VecDeinit(&w);
  }

Usage example (Cross-references)

Usage examples (Cross-references)

In Str.c:258:

        ValidateStr(s);
    
        StrIters sv   = (StrIters)VecInit(s->allocator);
        Zstr     prev = s->data;
        Zstr     end  = s->data + s->length;

In Str.c:292:

        ValidateStr(s);
    
        Strs sv        = (Strs)VecInit(s->allocator);
        sv.copy_deinit = (GenericCopyDeinit)str_deinit;
        Zstr prev      = s->data;

In Dir.c:70:

        }
    
        DirContents dc = (DirContents)VecInit(alloc);
    
        // Construct the search path: "<path>\*". Built with the in-tree

In Dir.c:198:

        }
    
        DirContents dc = (DirContents)VecInit(alloc);
    
        // O_RDONLY | O_DIRECTORY | O_CLOEXEC. Values match between Linux

In Read.EdgeCases.c:110:

        StrIter si1   = StrIterFromStr(json1);
    
        Vec(i32) items = VecInit(&alloc);
    
        JR_OBJ(si1, {

In Read.EdgeCases.c:541:

            i32 x_value;
            Vec(i32) filled_items;
        } obj = {0, VecInit(&alloc)};
    
        JR_OBJ(si, {

In Write.Nested.c:509:

        Str  json    = StrInit(&alloc);
    
        Vec(u32) numbers = VecInit(&alloc);
        u32 num1 = 1, num2 = 2, num3 = 3;
        VecPushBack(&numbers, num1);

In Write.Nested.c:526:

        VecPushBack(&strings, str3);
    
        Vec(bool) booleans = VecInit(&alloc);
        bool bool1 = true, bool2 = false, bool3 = true;
        VecPushBack(&booleans, bool1);

In Write.EdgeCases.c:106:

        Str  json    = StrInit(&alloc);
    
        Vec(i32) empty_numbers = VecInit(&alloc);
        Vec(Str) empty_strings = VecInitWithDeepCopy(NULL, StrDeinit, &alloc);

In Write.EdgeCases.c:335:

        Str  json    = StrInit(&alloc);
    
        Vec(i32) empty_list = VecInit(&alloc);
    
        JW_OBJ(json, {

In Write.EdgeCases.c:377:

        Str  json    = StrInit(&alloc);
    
        Vec(i32) empty_arr  = VecInit(&alloc);
        Vec(i32) filled_arr = VecInit(&alloc);
        i32 val1 = 1, val2 = 2;

In Write.EdgeCases.c:378:

    
        Vec(i32) empty_arr  = VecInit(&alloc);
        Vec(i32) filled_arr = VecInit(&alloc);
        i32 val1 = 1, val2 = 2;
        VecPushBack(&filled_arr, val1);

In RoundTrip.c:370:

    
        // Original data
        Vec(i32) original_numbers = VecInit(&alloc);
        Vec(Str) original_strings = VecInitWithDeepCopy(NULL, StrDeinit, &alloc);

In RoundTrip.c:398:

    
        // Read back from JSON
        Vec(i32) parsed_numbers = VecInit(&alloc);
        Vec(Str) parsed_strings = VecInitWithDeepCopy(NULL, StrDeinit, &alloc);

In RoundTrip.c:675:

    
        // Original empty data
        Vec(i32) empty_numbers = VecInit(&alloc);
        Vec(Str) empty_strings = VecInitWithDeepCopy(NULL, StrDeinit, &alloc);
        Str empty_str          = StrInit(&alloc);

In RoundTrip.c:695:

    
        // Read back from JSON
        Vec(i32) parsed_numbers = VecInit(&alloc);
        Vec(Str) parsed_strings = VecInitWithDeepCopy(NULL, StrDeinit, &alloc);
        Str  parsed_str         = StrInit(&alloc);

In Allocator.Page.c:71:

        PageAllocator alloc = PageAllocatorInit();
        typedef Vec(int) IntVec;
        IntVec v  = VecInit(&alloc);
        bool   ok = true;

In Vec.Ops.c:36:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add some data

In Vec.Ops.c:71:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add some data

In Vec.Ops.c:123:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add some data in unsorted order

In Vec.Foreach.c:36:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add some data

In Vec.Foreach.c:75:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add some data

In Vec.Foreach.c:111:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add some data

In Vec.Foreach.c:152:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add some data

In Vec.Foreach.c:183:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add some data

In Vec.Foreach.c:216:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add some data

In Vec.Foreach.c:243:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add some data

In Vec.Foreach.c:277:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add some data

In Vec.Foreach.c:311:

    
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add some elements

In Vec.Foreach.c:351:

    
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add some elements

In Vec.Foreach.c:389:

    
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add several elements

In Vec.Foreach.c:428:

    
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add several elements

In Vec.Foreach.c:466:

    
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add several elements

In Vec.Foreach.c:503:

    
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add several elements

In Vec.Foreach.c:541:

    
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add several elements

In Allocator.Arena.c:74:

        ArenaAllocator arena = ArenaAllocatorInit();
        typedef Vec(int) IntVec;
        IntVec v  = VecInit(&arena);
        bool   ok = true;

In Vec.Init.c:45:

    // Test basic vector initialization
    bool test_vec_init_basic(void) {
        WriteFmt("Testing VecInit\n");
    
        // Test with int type

In Vec.Init.c:49:

        // Test with int type
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Check initial state

In Vec.Init.c:60:

        // Test with struct type
        typedef Vec(TestItem) TestVec;
        TestVec test_vec = VecInit(&alloc);
    
        // Check initial state

In Vec.Init.c:76:

    // Test aligned vector initialization
    bool test_vec_init_aligned(void) {
        WriteFmt("Testing VecInit with aligned allocator\n");
    
        HeapAllocator aligned4  = HeapAllocatorInitAligned(4);

In Vec.Init.c:83:

        // Test with int type and 4-byte alignment
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&aligned4);
    
        // Check initial state

In Vec.Init.c:94:

        // Test with struct type and 16-byte alignment
        typedef Vec(TestItem) TestVec;
        TestVec test_vec = VecInit(&aligned16);
    
        // Check initial state

In Vec.Init.c:132:

    // Test vector initialization with alignment and deep copy functions
    bool test_vec_init_aligned_with_deep_copy(void) {
        WriteFmt("Testing VecInit with aligned allocator and deep copy\n");
    
        HeapAllocator aligned8 = HeapAllocatorInitAligned(8);

In Vec.Init.c:155:

    // Test vector initialization variants with an explicit optional allocator
    bool test_vec_init_optional_allocator(void) {
        WriteFmt("Testing VecInit optional allocator\n");
    
        typedef Vec(TestItem) TestVec;

In Vec.Init.c:174:

        h64.base.retry_limit       = 17;
    
        TestVec vec_a = VecInit(&h_default);
        TestVec vec_b = VecInitT(vec_b, &h_default);
        TestVec vec_c = VecInitWithDeepCopy(TestItemCopyInit, TestItemDeinit, &h_default);

In Vec.Init.c:178:

        TestVec vec_c = VecInitWithDeepCopy(TestItemCopyInit, TestItemDeinit, &h_default);
        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);

In Vec.Init.c:287:

        // Create a source vector
        typedef Vec(int) IntVec;
        IntVec src = VecInit(&alloc);
    
        // Add some data

In Vec.Init.c:295:

    
        // Create a destination vector
        IntVec clone = VecInit(&alloc);
    
        // Clone the source vector into the destination

In Vec.Memory.c:23:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Reserve more space than needed

In Vec.Memory.c:63:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add some data

In Vec.Memory.c:111:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Initial capacity should be 0

In Vec.Memory.c:158:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add some data

In Vec.Remove.c:35:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add some data

In Vec.Remove.c:83:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add some data

In Vec.Remove.c:131:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add some data

In Vec.Remove.c:179:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add some data

In Vec.Remove.c:216:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add some data

In Vec.Remove.c:252:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add some data

In Vec.Remove.c:328:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add some data

In Vec.Remove.c:374:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add some data

In Vec.Remove.c:410:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add some data

In Vec.Remove.c:445:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add some data

In Vec.Remove.c:526:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add some data

In Vec.Remove.c:603:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add some data

In Vec.Remove.c:640:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add some data

In Vec.Remove.c:675:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add some data

In Vec.Remove.c:754:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add some data

In Str.Type.c:106:

    
        // Create a valid Strs
        Strs sv = VecInit(&alloc);
    
        // This should not crash

In Str.Type.c:156:

    
        // Create an invalid Strs by corrupting its fields
        Strs sv = VecInit(&alloc);
    
        // Corrupt the vector to make it invalid

In Vec.Complex.c:391:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Test VecPushBackL

In Vec.Complex.c:439:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add some initial elements

In Vec.Complex.c:474:

    
        // Now test VecInsertRangeFastR in isolation
        IntVec vec2 = VecInit(&alloc);
    
        // Add some initial elements

In Vec.Complex.c:516:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add some initial elements

In Vec.Complex.c:607:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Test pushing to empty vector

In Vec.Access.c:32:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add some data

In Vec.Access.c:67:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add some data

In Vec.Access.c:107:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add some data

In Vec.Access.c:141:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add some data

In Vec.Access.c:175:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Check initial size and length

In Vec.Access.c:200:

        // Test with a vector with alignment > 1
        typedef Vec(int) AlignedIntVec;
        AlignedIntVec aligned_vec = VecInit(&aligned8);
    
        // Add some data

In Vec.Access.c:230:

        // Create a vector of integers with default alignment (1)
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Check offsets

In Vec.Access.c:242:

        // Create a vector with 8-byte alignment
        typedef Vec(int) AlignedIntVec;
        AlignedIntVec aligned_vec = VecInit(&aligned8);
    
        // For 8-byte alignment, each int (4 bytes) should be padded to 8 bytes

In Vec.Access.c:267:

    
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        int  needle  = 20;

In Vec.Type.c:27:

        // Define a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Check initial state

In Vec.Type.c:39:

        // Test with a struct type
        typedef Vec(TestItem) TestVec;
        TestVec test_vec = VecInit(&alloc);
    
        // Check initial state

In Vec.Type.c:62:

        // Create a valid vector
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // This should not abort

In Vec.Insert.c:31:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Push some elements to the back

In Vec.Insert.c:59:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Push some elements to the front

In Vec.Insert.c:87:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Insert at index 0 (empty vector)

In Vec.Insert.c:122:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Push an array to the back

In Vec.Insert.c:163:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Push an array to the front of empty vector

In Vec.Insert.c:204:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Push some elements first

In Vec.Insert.c:237:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Add some initial elements

In Vec.Insert.c:244:

    
        // Create another vector with elements to insert
        IntVec src          = VecInit(&alloc);
        int    src_values[] = {40, 50, 60};
        VecPushBackArrR(&src, src_values, 3);

In Vec.Insert.c:275:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec1 = VecInit(&alloc);
    
        // Add some elements to first vector

In Vec.Insert.c:282:

    
        // Create second vector
        IntVec vec2 = VecInit(&alloc);
    
        // Add some elements to second vector

In Vec.Insert.c:326:

        local_heap.base.retry_limit = 11;
    
        IntVec src      = VecInit(&local_heap);
        int    values[] = {10, 20, 30};
        VecPushBackArrR(&src, values, 3);

In Vec.Insert.c:335:

        // int[]. Stronger alignment is exercised separately - it's not what
        // this test is asserting.
        IntVec dst = VecInit(VecAllocator(&src));
        // intentional bypass: testing hook propagation; no public VecSetCopyHooks mutator exists
        dst.copy_init   = src.copy_init;

In Vec.Insert.c:361:

        // Create a vector of integers
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Test R-value insert operations

In Vec.Insert.c:444:

        // Create a vector of integers without copy_init
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        // Test VecPushBackL

In Vec.Insert.c:494:

    
        // Test VecMergeL
        IntVec vec2         = VecInit(&alloc);
        int    merge_vals[] = {140, 150, 160};
        for (int i = 0; i < 3; i++) {

In Vec.Insert.c:524:

    
        typedef Vec(int) IntVec;
        IntVec vec = VecInit(&alloc);
    
        int  originals[] = {10, 20, 30, 40, 50, 60, 70, 80};

In Buf.h:41:

    /// TAGS: Buf, Init, Construct, Lifecycle
    ///
    #define BufInit(...) VecInit(__VA_ARGS__)
    
    ///

Last updated on June 4, 2026

VecForeachReverseIdx VecInitClone