ListPushBackR

Documentation

API Reference

ListPushBackR

Description

Append an element at the tail of the list. R-value form.

Success

Returns true. A new node holding a copy of rval is linked as the new tail; the list length grows by one.

Failure

Returns false on allocation failure. The list is unchanged.

Usage example (Cross-references)

Usage examples (Cross-references)

In ListInt.c:38:

            case LIST_INT_PUSH_BACK : {
                i32 value = (i32)extract_u32(data, offset, data_size);
                ListPushBackR(list, value);
                break;
            }

In ListInt.c:208:

                for (uint8_t i = 0; i < count && *offset + 4 <= data_size; i++) {
                    i32 value = (i32)extract_u32(data, offset, data_size);
                    ListPushBackR(&temp, value);
                }

In List.Init.c:98:

    
        reset_counters();
        ListPushBackR(&list, 7);
        ListPushBackR(&list, 9);

In List.Init.c:99:

        reset_counters();
        ListPushBackR(&list, 7);
        ListPushBackR(&list, 9);
    
        bool result = (g_copy_init_count == 2);

In List.Insert.c:66:

        ListPushFrontL(&list, d);
        ListPushFrontR(&list, h);
        ListPushBackR(&list, e);
        ListPushFront(&list, f);
        ListPushBackL(&list, i);

In List.Insert.c:108:

        int     arr[] = {4, 5, 6};
    
        ListPushBackR(&list, 1);
        ListPushArrL(&list, arr, 0);

In List.Insert.c:130:

    
        reset_counters();
        ListPushBackR(&list, x);
        ListInsertL(&list, x, 1);
        ListPushArrL(&list, arr, 2);

In List.Insert.c:155:

    
        reset_counters();
        ListPushBackR(&src, 3);
        ListPushBackR(&src, 4);
        ListMergeL(&dest, &src);

In List.Insert.c:156:

        reset_counters();
        ListPushBackR(&src, 3);
        ListPushBackR(&src, 4);
        ListMergeL(&dest, &src);

In List.Insert.c:164:

        result      = result && (ListCopyInit(&src) == tracked_copy_init) && (ListCopyDeinit(&src) == tracked_copy_deinit);
    
        ListPushBackR(&src, 5);
        result = result && (g_copy_init_count == 3);
        result = result && list_matches(GENERIC_LIST(&src), (const int[]) {1005}, 1);

In List.Insert.c:188:

        IntList src_a  = ListInit(&alloc);
    
        ListPushBackR(&dest_l, 1);
        ListPushBackR(&dest_l, 2);
        ListPushBackR(&src_l, 3);

In List.Insert.c:189:

    
        ListPushBackR(&dest_l, 1);
        ListPushBackR(&dest_l, 2);
        ListPushBackR(&src_l, 3);
        ListPushBackR(&src_l, 4);

In List.Insert.c:190:

        ListPushBackR(&dest_l, 1);
        ListPushBackR(&dest_l, 2);
        ListPushBackR(&src_l, 3);
        ListPushBackR(&src_l, 4);
        ListMergeL(&dest_l, &src_l);

In List.Insert.c:191:

        ListPushBackR(&dest_l, 2);
        ListPushBackR(&src_l, 3);
        ListPushBackR(&src_l, 4);
        ListMergeL(&dest_l, &src_l);

In List.Insert.c:194:

        ListMergeL(&dest_l, &src_l);
    
        ListPushBackR(&dest_r, 1);
        ListPushBackR(&dest_r, 2);
        ListPushBackR(&src_r, 3);

In List.Insert.c:195:

    
        ListPushBackR(&dest_r, 1);
        ListPushBackR(&dest_r, 2);
        ListPushBackR(&src_r, 3);
        ListPushBackR(&src_r, 4);

In List.Insert.c:196:

        ListPushBackR(&dest_r, 1);
        ListPushBackR(&dest_r, 2);
        ListPushBackR(&src_r, 3);
        ListPushBackR(&src_r, 4);
        ListMergeR(&dest_r, &src_r);

In List.Insert.c:197:

        ListPushBackR(&dest_r, 2);
        ListPushBackR(&src_r, 3);
        ListPushBackR(&src_r, 4);
        ListMergeR(&dest_r, &src_r);

In List.Insert.c:200:

        ListMergeR(&dest_r, &src_r);
    
        ListPushBackR(&dest_a, 5);
        ListPushBackR(&src_a, 6);
        ListMerge(&dest_a, &src_a);

In List.Insert.c:201:

    
        ListPushBackR(&dest_a, 5);
        ListPushBackR(&src_a, 6);
        ListMerge(&dest_a, &src_a);

In List.Insert.c:233:

    
        reset_counters();
        ListPushBackR(&shallow_src, 11);
        ListPushBackR(&shallow_src, 12);
        ListMergeL(&deep_dest, &shallow_src);

In List.Insert.c:234:

        reset_counters();
        ListPushBackR(&shallow_src, 11);
        ListPushBackR(&shallow_src, 12);
        ListMergeL(&deep_dest, &shallow_src);
        ListMergeL(&empty_dest, &empty_src);

In List.Foreach.c:24:

    #define FILL_INT_LIST(list_ptr)                                                                                        \
        do {                                                                                                               \
            ListPushBackR((list_ptr), 10);                                                                                 \
            ListPushBackR((list_ptr), 20);                                                                                 \
            ListPushBackR((list_ptr), 30);                                                                                 \

In List.Foreach.c:25:

        do {                                                                                                               \
            ListPushBackR((list_ptr), 10);                                                                                 \
            ListPushBackR((list_ptr), 20);                                                                                 \
            ListPushBackR((list_ptr), 30);                                                                                 \
            ListPushBackR((list_ptr), 40);                                                                                 \

In List.Foreach.c:26:

            ListPushBackR((list_ptr), 10);                                                                                 \
            ListPushBackR((list_ptr), 20);                                                                                 \
            ListPushBackR((list_ptr), 30);                                                                                 \
            ListPushBackR((list_ptr), 40);                                                                                 \
            ListPushBackR((list_ptr), 50);                                                                                 \

In List.Foreach.c:27:

            ListPushBackR((list_ptr), 20);                                                                                 \
            ListPushBackR((list_ptr), 30);                                                                                 \
            ListPushBackR((list_ptr), 40);                                                                                 \
            ListPushBackR((list_ptr), 50);                                                                                 \
        } while (0)

In List.Foreach.c:28:

            ListPushBackR((list_ptr), 30);                                                                                 \
            ListPushBackR((list_ptr), 40);                                                                                 \
            ListPushBackR((list_ptr), 50);                                                                                 \
        } while (0)

In List.Ops.c:58:

    
        ListClear(&list);
        ListPushBackR(&list, 1);
        ListPushBackR(&list, 2);
        ListPushBackR(&list, 3);

In List.Ops.c:59:

        ListClear(&list);
        ListPushBackR(&list, 1);
        ListPushBackR(&list, 2);
        ListPushBackR(&list, 3);
        ListClear(&list);

In List.Ops.c:60:

        ListPushBackR(&list, 1);
        ListPushBackR(&list, 2);
        ListPushBackR(&list, 3);
        ListClear(&list);

In List.Ops.c:65:

        bool result = (ListLen(&list) == 0) && (ListHead(&list) == NULL) && (ListTail(&list) == NULL);
    
        ListPushBackR(&list, 9);
        result = result && list_matches(GENERIC_LIST(&list), (const int[]) {9}, 1);

In List.Ops.c:81:

        IntList list = ListInit(&alloc);
    
        ListPushBackR(&list, 4);
        ListPushBackR(&list, 1);
        ListPushBackR(&list, 3);

In List.Ops.c:82:

    
        ListPushBackR(&list, 4);
        ListPushBackR(&list, 1);
        ListPushBackR(&list, 3);
        ListPushBackR(&list, 2);

In List.Ops.c:83:

        ListPushBackR(&list, 4);
        ListPushBackR(&list, 1);
        ListPushBackR(&list, 3);
        ListPushBackR(&list, 2);
        ListPushBackR(&list, 2);

In List.Ops.c:84:

        ListPushBackR(&list, 1);
        ListPushBackR(&list, 3);
        ListPushBackR(&list, 2);
        ListPushBackR(&list, 2);

In List.Ops.c:85:

        ListPushBackR(&list, 3);
        ListPushBackR(&list, 2);
        ListPushBackR(&list, 2);
    
        ListSort(&list, compare_ints);

In List.Ops.c:109:

        ListSort(&empty, compare_ints);
        ListReverse(&empty);
        ListPushBackR(&singleton, 42);
        ListSort(&singleton, compare_ints);
        ListReverse(&singleton);

In List.Ops.c:131:

    
        reset_counters();
        ListPushBackR(&list, 7);
        ListPushBackR(&list, 8);

In List.Ops.c:132:

        reset_counters();
        ListPushBackR(&list, 7);
        ListPushBackR(&list, 8);
    
        bool result = (g_copy_init_count == 2);

In List.Ops.c:140:

        result = result && (ListLen(&list) == 0) && (ListHead(&list) == NULL) && (ListTail(&list) == NULL);
    
        ListPushBackR(&list, 9);
        result = result && (g_copy_init_count == 3);
        result = result && list_matches(GENERIC_LIST(&list), (const int[]) {9}, 1);

In List.Access.c:40:

        result      = result && ListEmpty(&list);
    
        ListPushBackR(&list, 10);
        ListPushBackR(&list, 20);

In List.Access.c:41:

    
        ListPushBackR(&list, 10);
        ListPushBackR(&list, 20);
    
        result = result && (ListLen(&list) == 2);

In List.Access.c:51:

        result = result && (ListHead(&list) == NULL) && (ListTail(&list) == NULL);
    
        ListPushBackR(&list, 30);
        result = result && list_matches(GENERIC_LIST(&list), (const int[]) {30}, 1);

In List.Access.c:67:

        IntList list = ListInit(&alloc);
    
        ListPushBackR(&list, 10);
        ListPushBackR(&list, 20);
        ListPushBackR(&list, 30);

In List.Access.c:68:

    
        ListPushBackR(&list, 10);
        ListPushBackR(&list, 20);
        ListPushBackR(&list, 30);
        ListPushBackR(&list, 40);

In List.Access.c:69:

        ListPushBackR(&list, 10);
        ListPushBackR(&list, 20);
        ListPushBackR(&list, 30);
        ListPushBackR(&list, 40);

In List.Access.c:70:

        ListPushBackR(&list, 20);
        ListPushBackR(&list, 30);
        ListPushBackR(&list, 40);
    
        bool result = ListPtrAt(&list, 0) && (*ListPtrAt(&list, 0) == 10);

In List.Access.c:97:

        IntList list = ListInit(&alloc);
    
        ListPushBackR(&list, 10);
        ListPushBackR(&list, 20);
        ListPushBackR(&list, 30);

In List.Access.c:98:

    
        ListPushBackR(&list, 10);
        ListPushBackR(&list, 20);
        ListPushBackR(&list, 30);
        ListPushBackR(&list, 40);

In List.Access.c:99:

        ListPushBackR(&list, 10);
        ListPushBackR(&list, 20);
        ListPushBackR(&list, 30);
        ListPushBackR(&list, 40);

In List.Access.c:100:

        ListPushBackR(&list, 20);
        ListPushBackR(&list, 30);
        ListPushBackR(&list, 40);
    
        GenericListNode *node1   = GENERIC_LIST_NODE(ListNodePtrAt(&list, 1));

In List.Access.c:146:

        result       = result && !ListContains(&list, &needle, compare_ints);
    
        ListPushBackR(&list, 10);
        ListPushBackR(&list, 20);
        ListPushBackR(&list, 30);

In List.Access.c:147:

    
        ListPushBackR(&list, 10);
        ListPushBackR(&list, 20);
        ListPushBackR(&list, 30);
        ListPushBackR(&list, 20);

In List.Access.c:148:

        ListPushBackR(&list, 10);
        ListPushBackR(&list, 20);
        ListPushBackR(&list, 30);
        ListPushBackR(&list, 20);

In List.Access.c:149:

        ListPushBackR(&list, 20);
        ListPushBackR(&list, 30);
        ListPushBackR(&list, 20);
    
        result = result && (ListFind(&list, &needle, compare_ints) == 1);

In List.Remove.c:53:

        int     removed = 0;
    
        ListPushBackR(&list, 10);
        ListPushBackR(&list, 20);
        ListPushBackR(&list, 30);

In List.Remove.c:54:

    
        ListPushBackR(&list, 10);
        ListPushBackR(&list, 20);
        ListPushBackR(&list, 30);
        ListPushBackR(&list, 40);

In List.Remove.c:55:

        ListPushBackR(&list, 10);
        ListPushBackR(&list, 20);
        ListPushBackR(&list, 30);
        ListPushBackR(&list, 40);

In List.Remove.c:56:

        ListPushBackR(&list, 20);
        ListPushBackR(&list, 30);
        ListPushBackR(&list, 40);
    
        ListRemove(&list, &removed, 1);

In List.Remove.c:86:

        int     removed[2] = {0, 0};
    
        ListPushBackR(&list, 1);
        ListPushBackR(&list, 2);
        ListPushBackR(&list, 3);

In List.Remove.c:87:

    
        ListPushBackR(&list, 1);
        ListPushBackR(&list, 2);
        ListPushBackR(&list, 3);
        ListPushBackR(&list, 4);

In List.Remove.c:88:

        ListPushBackR(&list, 1);
        ListPushBackR(&list, 2);
        ListPushBackR(&list, 3);
        ListPushBackR(&list, 4);
        ListPushBackR(&list, 5);

In List.Remove.c:89:

        ListPushBackR(&list, 2);
        ListPushBackR(&list, 3);
        ListPushBackR(&list, 4);
        ListPushBackR(&list, 5);
        ListPushBackR(&list, 6);

In List.Remove.c:90:

        ListPushBackR(&list, 3);
        ListPushBackR(&list, 4);
        ListPushBackR(&list, 5);
        ListPushBackR(&list, 6);

In List.Remove.c:91:

        ListPushBackR(&list, 4);
        ListPushBackR(&list, 5);
        ListPushBackR(&list, 6);
    
        ListRemoveRange(&list, removed, 2, 2);

In List.Remove.c:121:

        int     suffix[2] = {0, 0};
    
        ListPushBackR(&list, 1);
        ListPushBackR(&list, 2);
        ListPushBackR(&list, 3);

In List.Remove.c:122:

    
        ListPushBackR(&list, 1);
        ListPushBackR(&list, 2);
        ListPushBackR(&list, 3);
        ListPushBackR(&list, 4);

In List.Remove.c:123:

        ListPushBackR(&list, 1);
        ListPushBackR(&list, 2);
        ListPushBackR(&list, 3);
        ListPushBackR(&list, 4);
        ListPushBackR(&list, 5);

In List.Remove.c:124:

        ListPushBackR(&list, 2);
        ListPushBackR(&list, 3);
        ListPushBackR(&list, 4);
        ListPushBackR(&list, 5);
        ListPushBackR(&list, 6);

In List.Remove.c:125:

        ListPushBackR(&list, 3);
        ListPushBackR(&list, 4);
        ListPushBackR(&list, 5);
        ListPushBackR(&list, 6);

In List.Remove.c:126:

        ListPushBackR(&list, 4);
        ListPushBackR(&list, 5);
        ListPushBackR(&list, 6);
    
        ListRemoveRange(&list, prefix, 0, 2);

In List.Remove.c:152:

        int     removed[3] = {0, 0, 0};
    
        ListPushBackR(&list, 7);
        ListPushBackR(&list, 8);
        ListPushBackR(&list, 9);

In List.Remove.c:153:

    
        ListPushBackR(&list, 7);
        ListPushBackR(&list, 8);
        ListPushBackR(&list, 9);
        ListRemoveRange(&list, removed, 0, 3);

In List.Remove.c:154:

        ListPushBackR(&list, 7);
        ListPushBackR(&list, 8);
        ListPushBackR(&list, 9);
        ListRemoveRange(&list, removed, 0, 3);

In List.Remove.c:175:

    
        reset_counters();
        ListPushBackR(&list, 7);
        ListPushBackR(&list, 8);
        ListPushBackR(&list, 9);

In List.Remove.c:176:

        reset_counters();
        ListPushBackR(&list, 7);
        ListPushBackR(&list, 8);
        ListPushBackR(&list, 9);

In List.Remove.c:177:

        ListPushBackR(&list, 7);
        ListPushBackR(&list, 8);
        ListPushBackR(&list, 9);
    
        ListRemoveRange(&list, NULL, 1, 0);

In List.Remove.c:214:

    
        reset_counters();
        ListPushBackR(&list, 4);
        ListPushBackR(&list, 5);
        ListPushBackR(&list, 6);

In List.Remove.c:215:

        reset_counters();
        ListPushBackR(&list, 4);
        ListPushBackR(&list, 5);
        ListPushBackR(&list, 6);

In List.Remove.c:216:

        ListPushBackR(&list, 4);
        ListPushBackR(&list, 5);
        ListPushBackR(&list, 6);
    
        ListRemoveRange(&list, removed, 1, 2);

In List.Deadend.c:149:

    
        List(int) list = ListInit(get_test_alloc());
        ListPushBackR(&list, 10);
        ListPtrAt(&list, 1);

In List.Deadend.c:159:

    
        List(int) list = ListInit(get_test_alloc());
        ListPushBackR(&list, 10);
        (void)ListAt(&list, 1);

In List.Deadend.c:178:

    
        List(int) list = ListInit(get_test_alloc());
        ListPushBackR(&list, 10);
        ListNodePtrAt(&list, 1);

In List.Deadend.c:188:

    
        List(int) list = ListInit(get_test_alloc());
        ListPushBackR(&list, 10);
        (void)ListNodeAt(&list, 1);

In List.Deadend.c:234:

    
        List(int) list = ListInit(get_test_alloc());
        ListPushBackR(&list, 10);
        ListRemove(&list, NULL, 1);

In List.Deadend.c:262:

    
        List(int) list = ListInit(get_test_alloc());
        ListPushBackR(&list, 10);
        ListPushBackR(&list, 20);
        ListRemoveRange(&list, NULL, 1, 2);

In List.Deadend.c:263:

        List(int) list = ListInit(get_test_alloc());
        ListPushBackR(&list, 10);
        ListPushBackR(&list, 20);
        ListRemoveRange(&list, NULL, 1, 2);

In List.Deadend.c:273:

    
        List(int) list = ListInit(get_test_alloc());
        ListPushBackR(&list, 10);
        ListSwapItems(&list, 0, 1);

In List.Deadend.c:284:

        List(int) list = ListInit(get_test_alloc());
        int key        = 10;
        ListPushBackR(&list, 10);
        ListFind(&list, &key, NULL);

In List.Deadend.c:294:

    
        List(int) list = ListInit(get_test_alloc());
        ListPushBackR(&list, 10);
        ListFind(&list, NULL, compare_ints);

In List.Deadend.c:311:

    
        List(int) list = ListInit(get_test_alloc());
        ListPushBackR(&list, 10);
        ListSort(&list, NULL);

In Insert.h:416:

    #define ListMustPushBackR(l, rval)                                                                                     \
        do {                                                                                                               \
            if (!ListPushBackR((l), (rval))) {                                                                             \
                LOG_FATAL("ListMustPushBackR failed");                                                                     \
            }                                                                                                              \

Last updated on June 4, 2026

ListPushBackL ListPushFront