List – MisraStdC

Documentation

API Reference

List

Description

Double linked list.

Fields

Name	Description
`head`	Reference to head node of linked list.
`tail`	Reference to tail node of linked list.
`copy_init`	A user-provided type-specific method to initialize copies of types.
`copy_deinit`	A user-provided type-specific method deinitialize already created copies of types.
`length`	Length of this linked list.

Usage example (Cross-references)

Usage examples (Cross-references)

In Container.h:22:

    #endif
    #if FEATURE_LIST
    #    include <Misra/Std/Container/List.h>
    #endif
    #if FEATURE_MAP

In List.h:11:

    
    // clang-format off
    #include "List/Type.h"
    #include "List/Init.h"
    #include "List/Insert.h"

In List.h:12:

    // clang-format off
    #include "List/Type.h"
    #include "List/Init.h"
    #include "List/Insert.h"
    #include "List/Remove.h"

In List.h:13:

    #include "List/Type.h"
    #include "List/Init.h"
    #include "List/Insert.h"
    #include "List/Remove.h"
    #include "List/Access.h"

In List.h:14:

    #include "List/Init.h"
    #include "List/Insert.h"
    #include "List/Remove.h"
    #include "List/Access.h"
    #include "List/Foreach.h"

In List.h:15:

    #include "List/Insert.h"
    #include "List/Remove.h"
    #include "List/Access.h"
    #include "List/Foreach.h"
    #include "List/Ops.h"

In List.h:16:

    #include "List/Remove.h"
    #include "List/Access.h"
    #include "List/Foreach.h"
    #include "List/Ops.h"
    #include "List/Private.h"

In List.h:17:

    #include "List/Access.h"
    #include "List/Foreach.h"
    #include "List/Ops.h"
    #include "List/Private.h"
    // clang-format on

In List.h:18:

    #include "List/Foreach.h"
    #include "List/Ops.h"
    #include "List/Private.h"
    // clang-format on

In ListInt.h:10:

    #define FUZZ_LIST_INT_H
    
    #include <Misra/Std/Container/List.h>
    #include <Misra/Std/Allocator/Default.h>
    #include <Misra/Types.h>

In ListInt.h:15:

    
    // List(i32) typedef
    typedef List(i32) IntList;
    
    // List(i32) function enumeration

In ListInt.c:9:

    #include "../Harness.h"
    #include "ListInt.h"
    #include <Misra/Std/Container/List.h>
    #include <Misra/Std/Log.h>

In List.c:8:

    /// merge primitives consumed by the typed `List(T)` macros.
    
    #include <Misra/Std/Container/List.h>
    #include <Misra/Std/Log.h>
    #include <Misra/Std/Memory.h>

In List.c:112:

        }
        if (start + count > list->length) {
            LOG_FATAL("List range out of bounds.");
        }

In List.c:402:

    static void validate_list_structural(const GenericList *l) {
        if (!l->allocator) {
            LOG_FATAL("List allocator pointer is NULL.");
        }
        if (!l->allocator->allocate || !l->allocator->resize || !l->allocator->remap || !l->allocator->deallocate) {

In List.c:419:

            }
            if (l->head->prev) {
                LOG_FATAL("List head must not have a previous node.");
            }
            if (l->tail->next) {

In List.c:422:

            }
            if (l->tail->next) {
                LOG_FATAL("List tail must not have a next node.");
            }
        }

In List.c:429:

    void validate_list(const GenericList *l) {
        if (!l) {
            LOG_FATAL("List pointer is NULL.");
        }
        if (!MAGIC_MATCHES(l->__magic, LIST_MAGIC)) {

In Foreach.Deadend.c:146:

    
        DefaultAllocator alloc = DefaultAllocatorInit();
        typedef List(int) LI;
        LI li = ListInit(ALLOCATOR_OF(&alloc));
        ListForeach(&li, i) {

In Ops.c:2:

    #include <Misra/Std/Allocator/Default.h>
    #include <Misra/Std/Container/List.h>
    #include <Misra/Std/Log.h>
    #include <Misra/Types.h>

In Ops.c:92:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        typedef List(int) IntList;
        IntList list = ListInit(&alloc);

In Ops.c:116:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        typedef List(int) IntList;
        IntList list = ListInit(&alloc);

In Ops.c:141:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        typedef List(int) IntList;
        IntList empty     = ListInit(&alloc);
        IntList singleton = ListInit(&alloc);

In Ops.c:165:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        typedef List(int) IntList;
        IntList list = ListInitWithDeepCopy(tracked_copy_init, tracked_copy_deinit, &alloc);

In Ops.c:197:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        typedef List(int) IntList;
        IntList list = ListInit(&alloc);
        ListPushBackR(&list, 2);

In Ops.c:228:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        typedef List(int) IntList;
        IntList dst = ListInitWithDeepCopy(failing_copy_init, plain_copy_deinit, &alloc);
        IntList src = ListInit(&alloc);

In Ops.c:271:

        };
    
        WriteFmt("[INFO] Starting List.Ops tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "List.Ops");
    }

In Ops.c:272:

    
        WriteFmt("[INFO] Starting List.Ops tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "List.Ops");
    }

In Init.c:2:

    #include <Misra/Std/Allocator/Default.h>
    #include <Misra/Std/Container/List.h>
    #include <Misra/Std/Log.h>

In Init.c:29:

    
    static bool test_list_init_variants(void) {
        WriteFmt("Testing List init variants\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Init.c:33:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        typedef List(int) IntList;
        IntList list_a = ListInit(&alloc);
        IntList list_b = ListInitT(list_b, &alloc);

In Init.c:58:

    
    static bool test_list_init_optional_allocator(void) {
        WriteFmt("Testing List init optional allocator\n");
    
        typedef List(int) IntList;

In Init.c:60:

        WriteFmt("Testing List init optional allocator\n");
    
        typedef List(int) IntList;
        DefaultAllocator alloc = DefaultAllocatorInit();
        // intentional bypass: no public setter on `Allocator` for effort /

In Init.c:94:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        typedef List(int) IntList;
        IntList list = ListInitWithDeepCopy(tracked_copy_init, tracked_copy_deinit, &alloc);

In Init.c:122:

        };
    
        WriteFmt("[INFO] Starting List.Init tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "List.Init");
    }

In Init.c:123:

    
        WriteFmt("[INFO] Starting List.Init tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "List.Init");
    }

In Insert.c:2:

    #include <Misra/Std/Allocator/Default.h>
    #include <Misra/Std/Container/List.h>
    #include <Misra/Std/Log.h>
    #include <Misra/Types.h>

In Insert.c:82:

    
    static bool test_list_insert_and_push_aliases(void) {
        WriteFmt("Testing List insert and push aliases\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Insert.c:86:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        typedef List(int) IntList;
        IntList list = ListInit(&alloc);
        int     a    = 10;

In Insert.c:122:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        typedef List(int) IntList;
        IntList list  = ListInit(&alloc);
        int     arr[] = {1, 2, 3};

In Insert.c:141:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        typedef List(int) IntList;
        IntList list  = ListInit(&alloc);
        int     arr[] = {4, 5, 6};

In Insert.c:157:

    
    static bool test_list_insert_with_deep_copy(void) {
        WriteFmt("Testing List insert with deep copy\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Insert.c:161:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        typedef List(int) IntList;
        IntList list  = ListInitWithDeepCopy(tracked_copy_init, tracked_copy_deinit, &alloc);
        int     x     = 7;

In Insert.c:187:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        typedef List(int) IntList;
        IntList dest = ListInit(&alloc);
        IntList src  = ListInitWithDeepCopy(tracked_copy_init, tracked_copy_deinit, &alloc);

In Insert.c:213:

    
    static bool test_list_merge_variants(void) {
        WriteFmt("Testing List merge variants\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Insert.c:217:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        typedef List(int) IntList;
        IntList dest_l = ListInit(&alloc);
        IntList src_l  = ListInit(&alloc);

In Insert.c:259:

    
    static bool test_list_merge_edge_cases(void) {
        WriteFmt("Testing List merge edge cases\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Insert.c:263:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        typedef List(int) IntList;
        IntList deep_dest   = ListInitWithDeepCopy(tracked_copy_init, tracked_copy_deinit, &alloc);
        IntList shallow_src = ListInit(&alloc);

In Insert.c:300:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        typedef List(int) IntList;
        IntList list  = ListInit(&alloc);
        int     arr[] = {7, 8, 9};

In Insert.c:333:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        typedef List(int) IntList;
        IntList list = ListInitWithDeepCopy(failing_copy_init, plain_copy_deinit, &alloc);

In Insert.c:370:

        };
    
        WriteFmt("[INFO] Starting List.Insert tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "List.Insert");
    }

In Insert.c:371:

    
        WriteFmt("[INFO] Starting List.Insert tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "List.Insert");
    }

In Type.c:2:

    #include <Misra/Std/Allocator/Default.h>
    #include <Misra/Std/Container/List.h>
    #include <Misra/Std/Container/List/Private.h>
    #include <Misra/Std/Log.h>

In Type.c:3:

    #include <Misra/Std/Allocator/Default.h>
    #include <Misra/Std/Container/List.h>
    #include <Misra/Std/Container/List/Private.h>
    #include <Misra/Std/Log.h>

In Type.c:12:

        for (u64 i = 0; i < count; i++) {
            int v = (int)(i * 10);
            ListPushBackR((List(int) *)list, v);
        }
    }

In Type.c:17:

    
    static bool test_list_type_defaults(void) {
        WriteFmt("Testing List type defaults\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Type.c:21:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        typedef List(int) IntList;
        IntList list = ListInit(&alloc);

In Type.c:68:

    
        DefaultAllocator alloc = DefaultAllocatorInit();
        List(int) list         = ListInit(&alloc);
        fill_decades(GENERIC_LIST(&list), 4);

In Type.c:102:

        };
    
        WriteFmt("[INFO] Starting List.Type tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "List.Type");
    }

In Type.c:103:

    
        WriteFmt("[INFO] Starting List.Type tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "List.Type");
    }

In Deadend.c:2:

    #include <Misra/Std/Allocator/Default.h>
    #include <Misra/Std/Container/List.h>
    #include <Misra/Std/Container/List/Private.h>
    #include <Misra/Std/Log.h>

In Deadend.c:3:

    #include <Misra/Std/Allocator/Default.h>
    #include <Misra/Std/Container/List.h>
    #include <Misra/Std/Container/List/Private.h>
    #include <Misra/Std/Log.h>

In Deadend.c:36:

        for (u64 i = 0; i < count; i++) {
            int v = (int)(i * 10);
            ListPushBackR((List(int) *)list, v);
        }
    }

In Deadend.c:43:

        WriteFmt("Testing ValidateList on corrupt empty list\n");
    
        List(int) list = ListInit(get_test_alloc());
        // intentional bypass: ListHead is read-only, no public setter exists --
        // plant a bogus head pointer on an empty list so ValidateList trips its

In Deadend.c:64:

        WriteFmt("Testing ValidateList on invalid magic\n");
    
        List(int) list = ListInit(get_test_alloc());
        // intentional bypass: __magic is the private sentinel ValidateList
        // checks; scramble it directly to exercise the type-confusion /

In Deadend.c:78:

    
        GenericListNode node = {0};
        List(int) list       = ListInit(get_test_alloc());
        GenericList *g       = GENERIC_LIST(&list);

In Deadend.c:98:

        int             value = 1;
        GenericListNode node  = {.next = NULL, .prev = NULL, .data = &value};
        List(int) list        = ListInit(get_test_alloc());
        GenericList *g        = GENERIC_LIST(&list);

In Deadend.c:118:

        int             value = 1;
        GenericListNode node  = {.next = NULL, .prev = (GenericListNode *)1, .data = &value};
        List(int) list        = ListInit(get_test_alloc());
        GenericList *g        = GENERIC_LIST(&list);

In Deadend.c:138:

        int             value = 1;
        GenericListNode node  = {.next = (GenericListNode *)1, .prev = NULL, .data = &value};
        List(int) list        = ListInit(get_test_alloc());
        GenericList *g        = GENERIC_LIST(&list);

In Deadend.c:156:

        WriteFmt("Testing ListPtrAt on empty list\n");
    
        List(int) list = ListInit(get_test_alloc());
        ListPtrAt(&list, 0);

In Deadend.c:165:

        WriteFmt("Testing ListPtrAt out of bounds\n");
    
        List(int) list = ListInit(get_test_alloc());
        ListPushBackR(&list, 10);
        ListPtrAt(&list, 1);

In Deadend.c:175:

        WriteFmt("Testing ListAt out of bounds\n");
    
        List(int) list = ListInit(get_test_alloc());
        ListPushBackR(&list, 10);
        (void)ListAt(&list, 1);

In Deadend.c:185:

        WriteFmt("Testing ListNodePtrAt on empty list\n");
    
        List(int) list = ListInit(get_test_alloc());
        ListNodePtrAt(&list, 0);

In Deadend.c:194:

        WriteFmt("Testing ListNodePtrAt out of bounds\n");
    
        List(int) list = ListInit(get_test_alloc());
        ListPushBackR(&list, 10);
        ListNodePtrAt(&list, 1);

In Deadend.c:204:

        WriteFmt("Testing ListNodeAt out of bounds\n");
    
        List(int) list = ListInit(get_test_alloc());
        ListPushBackR(&list, 10);
        (void)ListNodeAt(&list, 1);

In Deadend.c:214:

        WriteFmt("Testing ListFirst on empty list\n");
    
        List(int) list = ListInit(get_test_alloc());
        ListFirst(&list);

In Deadend.c:223:

        WriteFmt("Testing ListLast on empty list\n");
    
        List(int) list = ListInit(get_test_alloc());
        ListLast(&list);

In Deadend.c:232:

        WriteFmt("Testing ListNodeAt on empty list\n");
    
        List(int) list = ListInit(get_test_alloc());
        (void)ListNodeAt(&list, 0);

In Deadend.c:241:

        WriteFmt("Testing ListInsertR out of range\n");
    
        List(int) list = ListInit(get_test_alloc());
        ListInsertR(&list, 10, 1);

In Deadend.c:250:

        WriteFmt("Testing ListRemove out of range\n");
    
        List(int) list = ListInit(get_test_alloc());
        ListPushBackR(&list, 10);
        ListRemove(&list, NULL, 1);

In Deadend.c:260:

        WriteFmt("Testing ListPopFront on empty list\n");
    
        List(int) list = ListInit(get_test_alloc());
        ListPopFront(&list, NULL);

In Deadend.c:269:

        WriteFmt("Testing ListPopBack on empty list\n");
    
        List(int) list = ListInit(get_test_alloc());
        ListPopBack(&list, NULL);

In Deadend.c:278:

        WriteFmt("Testing ListRemoveRange out of range\n");
    
        List(int) list = ListInit(get_test_alloc());
        ListPushBackR(&list, 10);
        ListPushBackR(&list, 20);

In Deadend.c:289:

        WriteFmt("Testing ListSwapItems out of range\n");
    
        List(int) list = ListInit(get_test_alloc());
        ListPushBackR(&list, 10);
        ListSwapItems(&list, 0, 1);

In Deadend.c:299:

        WriteFmt("Testing ListFind without compare function\n");
    
        List(int) list = ListInit(get_test_alloc());
        int key        = 10;
        ListPushBackR(&list, 10);

In Deadend.c:310:

        WriteFmt("Testing ListFind without key pointer\n");
    
        List(int) list = ListInit(get_test_alloc());
        ListPushBackR(&list, 10);
        ListFind(&list, NULL, compare_ints);

In Deadend.c:327:

        WriteFmt("Testing ListSort without compare function\n");
    
        List(int) list = ListInit(get_test_alloc());
        ListPushBackR(&list, 10);
        ListSort(&list, NULL);

In Deadend.c:340:

        WriteFmt("Testing get_node_for_list_iteration target == length\n");
    
        List(int) list = ListInit(get_test_alloc());
        FILL_EIGHT(&list);

In Deadend.c:359:

        WriteFmt("Testing get_node_random_access relative target == length aborts\n");
    
        List(int) list = ListInit(get_test_alloc());
        FILL_EIGHT(&list);

In Deadend.c:381:

    
        DefaultAllocator alloc = DefaultAllocatorInit();
        List(int) list         = ListInit(&alloc);
        fill_decades(GENERIC_LIST(&list), 4);

In Deadend.c:429:

        };
    
        WriteFmt("[INFO] Starting List.Deadend tests\n\n");
        return run_test_suite(
            NULL,

In Deadend.c:435:

            deadend_tests,
            (int)(sizeof(deadend_tests) / sizeof(deadend_tests[0])),
            "List.Deadend"
        );
    }

In Remove.c:2:

    #include <Misra/Std/Allocator/Default.h>
    #include <Misra/Std/Container/List.h>
    #include <Misra/Std/Log.h>
    #include <Misra/Types.h>

In Remove.c:49:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        typedef List(int) IntList;
        IntList list    = ListInit(&alloc);
        int     removed = 0;

In Remove.c:82:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        typedef List(int) IntList;
        IntList list       = ListInit(&alloc);
        int     removed[2] = {0, 0};

In Remove.c:116:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        typedef List(int) IntList;
        IntList list      = ListInit(&alloc);
        int     prefix[2] = {0, 0};

In Remove.c:148:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        typedef List(int) IntList;
        IntList list       = ListInit(&alloc);
        int     removed[3] = {0, 0, 0};

In Remove.c:170:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        typedef List(int) IntList;
        IntList list    = ListInitWithDeepCopy(tracked_copy_init, tracked_copy_deinit, &alloc);
        int     removed = 0;

In Remove.c:209:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        typedef List(int) IntList;
        IntList list       = ListInitWithDeepCopy(tracked_copy_init, tracked_copy_deinit, &alloc);
        int     removed[2] = {0, 0};

In Remove.c:241:

        };
    
        WriteFmt("[INFO] Starting List.Remove tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "List.Remove");
    }

In Remove.c:242:

    
        WriteFmt("[INFO] Starting List.Remove tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "List.Remove");
    }

In Foreach.c:2:

    #include <Misra/Std/Allocator/Default.h>
    #include <Misra/Std/Container/List.h>
    #include <Misra/Std/Log.h>

In Foreach.c:32:

    
    static bool test_list_foreach_basic(void) {
        WriteFmt("Testing basic List foreach macros\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Foreach.c:36:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        typedef List(int) IntList;
        IntList list              = ListInit(&alloc);
        int     reverse_values[5] = {0};

In Foreach.c:72:

    
    static bool test_list_foreach_ranges(void) {
        WriteFmt("Testing ranged List foreach macros\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Foreach.c:76:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        typedef List(int) IntList;
        IntList list              = ListInit(&alloc);
        int     forward_range_sum = 0;

In Foreach.c:109:

    
    static bool test_list_foreach_range_edge_cases(void) {
        WriteFmt("Testing List ranged foreach edge cases\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Foreach.c:113:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        typedef List(int) IntList;
        IntList list  = ListInit(&alloc);
        int     count = 0;

In Foreach.c:158:

    
    static bool test_list_foreach_index_variants(void) {
        WriteFmt("Testing indexed List foreach macros\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Foreach.c:162:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        typedef List(int) IntList;
        IntList list              = ListInit(&alloc);
        int     reverse_values[5] = {0};

In Foreach.c:202:

    
    static bool test_list_foreach_index_jump_contract(void) {
        WriteFmt("Testing indexed List foreach jump contract\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Foreach.c:206:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        typedef List(int) IntList;
        IntList list              = ListInit(&alloc);
        int     forward_values[3] = {0};

In Foreach.c:262:

    
    static bool test_list_foreach_empty_lists(void) {
        WriteFmt("Testing List foreach macros on empty list\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Foreach.c:266:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        typedef List(int) IntList;
        IntList list  = ListInit(&alloc);
        u64     count = 0;

In Foreach.c:349:

        };
    
        WriteFmt("[INFO] Starting List.Foreach tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "List.Foreach");
    }

In Foreach.c:350:

    
        WriteFmt("[INFO] Starting List.Foreach tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "List.Foreach");
    }

In Access.c:2:

    #include <Misra/Std/Allocator/Default.h>
    #include <Misra/Std/Container/List.h>
    #include <Misra/Std/Container/List/Private.h>
    #include <Misra/Std/Log.h>

In Access.c:3:

    #include <Misra/Std/Allocator/Default.h>
    #include <Misra/Std/Container/List.h>
    #include <Misra/Std/Container/List/Private.h>
    #include <Misra/Std/Log.h>
    #include <Misra/Types.h>

In Access.c:31:

        for (u64 i = 0; i < count; i++) {
            int v = (int)(i * 10);
            ListPushBackR((List(int) *)list, v);
        }
    }

In Access.c:65:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        typedef List(int) IntList;
        IntList list = ListInit(&alloc);

In Access.c:91:

    
    static bool test_list_value_access_and_swap(void) {
        WriteFmt("Testing List accessors and swap\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Access.c:95:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        typedef List(int) IntList;
        IntList list = ListInit(&alloc);

In Access.c:121:

    
    static bool test_list_node_access_and_navigation(void) {
        WriteFmt("Testing List node access and navigation\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Access.c:125:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        typedef List(int) IntList;
        IntList list = ListInit(&alloc);

In Access.c:169:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        typedef List(int) IntList;
        IntList list = ListInit(&alloc);

In Access.c:213:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        typedef List(int) IntList;
        IntList list = ListInit(&alloc);

In Access.c:259:

    
        DefaultAllocator alloc = DefaultAllocatorInit();
        List(int) list         = ListInit(&alloc);
        fill_decades(GENERIC_LIST(&list), 9);

In Access.c:281:

    
        DefaultAllocator alloc = DefaultAllocatorInit();
        List(int) list         = ListInit(&alloc);
        fill_decades(GENERIC_LIST(&list), 9);

In Access.c:301:

    
        DefaultAllocator alloc = DefaultAllocatorInit();
        List(int) list         = ListInit(&alloc);
        fill_decades(GENERIC_LIST(&list), 9);

In Access.c:322:

        WriteFmt("Testing get_node_random_access head-walk origin\n");
    
        List(int) list = ListInit(get_test_alloc());
        FILL_EIGHT(&list);

In Access.c:343:

        WriteFmt("Testing get_node_random_access tail-walk origin\n");
    
        List(int) list = ListInit(get_test_alloc());
        FILL_EIGHT(&list);

In Access.c:363:

        WriteFmt("Testing get_node_for_list_iteration no-cursor resolution\n");
    
        List(int) list = ListInit(get_test_alloc());
        FILL_EIGHT(&list);

In Access.c:390:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        typedef List(int) IntList;
        IntList list = ListInit(&alloc);
        ListPushBackR(&list, 10);

In Access.c:417:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        typedef List(int) IntList;
        IntList list = ListInit(&alloc);
        ListPushBackR(&list, 10);

In Access.c:445:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        typedef List(int) IntList;
        IntList list = ListInit(&alloc);

In Access.c:487:

    
        DefaultAllocator alloc = DefaultAllocatorInit();
        List(int) list         = ListInit(&alloc);
        fill_decades(GENERIC_LIST(&list), 9); // indices 0..8, tail value 80

In Access.c:521:

        };
    
        WriteFmt("[INFO] Starting List.Access tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "List.Access");
    }

In Access.c:522:

    
        WriteFmt("[INFO] Starting List.Access tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "List.Access");
    }

Last updated on July 1, 2026

GenericList LIST_DATA_TYPE