VecDeinit

Macro
October 8, 2025

Table of Contents

`VecDeinit`

Description

Deinit vec by freeing all allocations.

Parameters

Name	Direction	Description
`v`	in,out	Pointer to `Vec` to be deinited

Usage example (from documentation)

  Vec(Model)* models = GetAllModels(...);
  ... // use vector
  DeinitVec(models)

Usage example (Cross-references)

In Vec.Foreach.c:62:

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

In Vec.Foreach.c:98:

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

In Vec.Foreach.c:139:

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

In Vec.Foreach.c:170:

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

In Vec.Foreach.c:203:

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

In Vec.Foreach.c:230:

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

In Vec.Foreach.c:264:

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

In Vec.Foreach.c:299:

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

In Vec.Foreach.c:332:

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

In Vec.Foreach.c:340:

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

In Vec.Foreach.c:372:

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

In Vec.Foreach.c:378:

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

In Vec.Foreach.c:411:

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

In Vec.Foreach.c:417:

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

In Vec.Foreach.c:449:

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

In Vec.Foreach.c:455:

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

In Vec.Foreach.c:486:

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

In Vec.Foreach.c:492:

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

In Vec.Foreach.c:524:

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

In Vec.Foreach.c:530:

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

In Vec.Foreach.c:562:

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

In Vec.Foreach.c:568:

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

In Vec.Type.c:33:

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

In Vec.Type.c:44:

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

In Vec.Type.c:61:

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

In Vec.Memory.c:47:

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

In Vec.Memory.c:92:

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

In Vec.Memory.c:136:

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

In Vec.Memory.c:174:

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

In Str.Type.c:66:

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

In Str.Type.c:105:

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

In Vec.Complex.c:174:

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

In Vec.Complex.c:218:

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

In Vec.Complex.c:261:

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

In Vec.Complex.c:336:

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

In Vec.Complex.c:337:

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

In Vec.Complex.c:338:

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

In Vec.Complex.c:339:

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

In Vec.Complex.c:387:

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

In Vec.Complex.c:430:

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

In Vec.Complex.c:464:

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

In Vec.Complex.c:503:

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

In Vec.Complex.c:534:

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

In Vec.Complex.c:555:

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

In Vec.Complex.c:583:

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

In Vec.Complex.c:605:

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

In Vec.Complex.c:617:

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

In Vec.Complex.c:643:

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

In Vec.Complex.c:678:

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

In Vec.Complex.c:744:

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

In Vec.Complex.c:775:

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

In Vec.Complex.c:812:

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

In Vec.Complex.c:813:

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

In Vec.Complex.c:850:

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

In Vec.Access.c:44:

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

In Vec.Access.c:81:

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

In Vec.Access.c:112:

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

In Vec.Access.c:142:

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

In Vec.Access.c:174:

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

In Vec.Access.c:192:

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

In Vec.Access.c:211:

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

In Vec.Access.c:226:

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

In Vec.Remove.c:70:

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

In Vec.Remove.c:118:

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

In Vec.Remove.c:166:

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

In Vec.Remove.c:203:

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

In Vec.Remove.c:239:

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

In Vec.Remove.c:315:

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

In Vec.Remove.c:361:

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

In Vec.Remove.c:397:

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

In Vec.Remove.c:432:

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

In Vec.Remove.c:513:

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

In Vec.Remove.c:590:

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

In Vec.Remove.c:627:

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

In Vec.Remove.c:662:

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

In Vec.Remove.c:741:

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

In Vec.Remove.c:818:

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

In BitVec.Pattern.Deadend.c:246:

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

In BitVec.Pattern.Deadend.c:264:

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

In Str.Ops.c:176:

    }
    
    VecDeinit(&split);
    
    // Test StrSplitToIters

In Str.Ops.c:202:

    }
    
    VecDeinit(&iters);
    StrDeinit(&s);
    return result;

In BitVec.Pattern.Simple.c:858:

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

In BitVec.Pattern.Simple.c:907:

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

In Vec.Init.c:55:

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

In Vec.Init.c:66:

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

In Vec.Init.c:85:

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

In Vec.Init.c:96:

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

In Vec.Init.c:115:

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

In Vec.Init.c:134:

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

In Vec.Init.c:246:

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

In Vec.Init.c:247:

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

In Vec.Ops.c:58:

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

In Vec.Ops.c:110:

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

In Vec.Ops.c:149:

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

In Vec.Insert.c:45:

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

In Vec.Insert.c:73:

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

In Vec.Insert.c:108:

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

In Vec.Insert.c:149:

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

In Vec.Insert.c:190:

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

In Vec.Insert.c:223:

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

In Vec.Insert.c:260:

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

In Vec.Insert.c:261:

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

In Vec.Insert.c:301:

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

In Vec.Insert.c:302:

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

In Vec.Insert.c:385:

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

In Vec.Insert.c:460:

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

In Vec.Insert.c:461:

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

In RoundTrip.c:42:

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

In RoundTrip.c:48:

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

In RoundTrip.c:49:

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

In RoundTrip.c:441:

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

In RoundTrip.c:442:

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

In RoundTrip.c:443:

    VecDeinit(&original_numbers);
    VecDeinit(&original_strings);
    VecDeinit(&parsed_numbers);
    VecDeinit(&parsed_strings);
    return success;

In RoundTrip.c:444:

    VecDeinit(&original_strings);
    VecDeinit(&parsed_numbers);
    VecDeinit(&parsed_strings);
    return success;
    }

In RoundTrip.c:709:

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

In RoundTrip.c:710:

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

In RoundTrip.c:711:

    VecDeinit(&empty_numbers);
    VecDeinit(&empty_strings);
    VecDeinit(&parsed_numbers);
    VecDeinit(&parsed_strings);
    return success;

In RoundTrip.c:712:

    VecDeinit(&empty_strings);
    VecDeinit(&parsed_numbers);
    VecDeinit(&parsed_strings);
    return success;
    }

In Read.Simple.c:44:

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

In Read.Simple.c:316:

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

In Write.Simple.c:44:

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

In Write.Simple.c:255:

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

In Read.Nested.c:85:

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

In Read.Nested.c:420:

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

In Read.Nested.c:568:

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

In Read.Nested.c:905:

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

In Read.Nested.c:1075:

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

In Read.EdgeCases.c:24:

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

In Read.EdgeCases.c:25:

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

In Read.EdgeCases.c:142:

    StrDeinit(&json1);
    StrDeinit(&json2);
    VecDeinit(&items);
    VecDeinit(&data);
    return success;

In Read.EdgeCases.c:143:

    StrDeinit(&json2);
    VecDeinit(&items);
    VecDeinit(&data);
    return success;
    }

In Read.EdgeCases.c:546:

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

In Write.EdgeCases.c:116:

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

In Write.EdgeCases.c:117:

    StrDeinit(&json);
    VecDeinit(&empty_numbers);
    VecDeinit(&empty_strings);
    return success;
    }

In Write.EdgeCases.c:338:

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

In Write.EdgeCases.c:376:

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

In Write.EdgeCases.c:377:

    StrDeinit(&json);
    VecDeinit(&empty_arr);
    VecDeinit(&filled_arr);
    return success;
    }

In Write.Nested.c:67:

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

In Write.Nested.c:285:

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

In Write.Nested.c:322:

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

In Write.Nested.c:437:

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

In Write.Nested.c:519:

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

In Write.Nested.c:520:

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

In Write.Nested.c:521:

    VecDeinit(&numbers);
    VecDeinit(&strings);
    VecDeinit(&booleans);
    return success;
    }

In MisraEnum.c:216:

    StrDeinit(&e.str);
    };
    VecDeinit(&entries);
    
    LogDeinit();

In MisraDoc.c:34:

    
    StrDeinit(&p->build_dir);
    VecDeinit(&p->source_directories);
    VecDeinit(&p->test_directories);
    }

In MisraDoc.c:35:

    StrDeinit(&p->build_dir);
    VecDeinit(&p->source_directories);
    VecDeinit(&p->test_directories);
    }

In MisraDoc.c:121:

    // recursively explore directories and get files that need documentation
    Strs file_paths = VecInit();
    Scope(&file_paths, VecDeinit, {
    // temporary vector to store all directory paths to explore files in
    Strs dir_paths = VecInitWithDeepCopy(NULL, StrDeinit);

In MisraDoc.c:124:

    // temporary vector to store all directory paths to explore files in
    Strs dir_paths = VecInitWithDeepCopy(NULL, StrDeinit);
    Scope(&dir_paths, VecDeinit, {
    VecMerge(&dir_paths, &project.source_directories);
    VecMerge(&dir_paths, &project.test_directories);

In MisraDoc.c:135:

    
    SysDirContents dir_contents = SysGetDirContents(dir_name.data);
    Scope(&dir_contents, VecDeinit, {
    VecForeach(&dir_contents, dir_entry) {
    // if it's a directory then store it for exploration later on

In Main.c:21:

    }
    
    VecDeinit(&lines);
    VecDeinit(&file);
    } else {

In Main.c:22:

    
    VecDeinit(&lines);
    VecDeinit(&file);
    } else {
    LOG_ERROR("Failed to read file");

In Insert.h:684:

    #define VecInitClone(vd, vs)                                                                                           \
    do {                                                                                                               \
    VecDeinit(vd);                                                                                                 \
    VecMerge(vd, vs);                                                                                              \
    } while (0)

In VecInt.c:24:

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

In VecInt.c:337:

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

In VecInt.c:391:

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

In VecStr.c:43:

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

In VecStr.c:208:

    
    VecInsertRange(vec, temp_strings, index, count);
    VecDeinit(vec);
    }
    break;

In VecStr.c:279:

    
    VecPushBackArr(vec, temp_strings, count);
    VecDeinit(vec);
    }
    break;

In VecStr.c:295:

    
    VecPushFrontArr(vec, temp_strings, count);
    VecDeinit(vec);
    }
    break;

In VecStr.c:311:

    
    VecPushFrontArrFast(vec, temp_strings, count);
    VecDeinit(vec);
    }
    break;

In VecStr.c:360:

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

In VecStr.c:377:

    
    VecInsertRangeFast(vec, temp_strings, index, count);
    VecDeinit(vec);
    }
    break;

In VecStr.c:420:

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

In VecCharPtr.c:37:

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

In VecCharPtr.c:390:

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

In VecCharPtr.c:458:

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

VecDeinit

VecDeinit

Description

Parameters

Usage example (from documentation)

Usage example (Cross-references)

Share :

`VecDeinit`