VecPushBack

Documentation

API Reference

VecPushBack

Description

Push item into vector back.

Default behaviour is same as VecPushBackL

Parameters

Name	Direction	Description
`v`	in,out	Vector to push item into
`lval`	in	l-value to be pushed back

Success

return

Failure

Does not return

Usage example (Cross-references)

Usage examples (Cross-references)

In VecCharPtr.c:45:

                char *str = generate_cstring(data, offset, size, 32);
                if (str) {
                    VecPushBack(vec, str);
                }
                break;

In VecCharPtr.c:385:

                        char *str = generate_cstring(data, offset, size, 16);
                        if (str) {
                            VecPushBack(&temp, str);
                        }
                    }

In VecCharPtr.c:453:

                        char *str = generate_cstring(data, offset, size, 16);
                        if (str) {
                            VecPushBack(&temp, str);
                        }
                    }

In VecStr.c:50:

            case VEC_STR_PUSH_BACK : {
                Str str = generate_str_from_input(data, offset, size, 32);
                VecPushBack(vec, str);
                break;
            }

In VecStr.c:356:

                    for (size_t i = 0; i < count; i++) {
                        Str str = generate_str_from_input(data, offset, size, 16);
                        VecPushBack(&temp, str);
                    }

In VecStr.c:416:

                    for (size_t i = 0; i < count; i++) {
                        Str str = generate_str_from_input(data, offset, size, 16);
                        VecPushBack(&temp, str);
                    }

In VecInt.c:31:

            case VEC_INT_PUSH_BACK : {
                i32 value = (i32)extract_u32(data, offset, size);
                VecPushBack(vec, value);
                break;
            }

In VecInt.c:333:

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

In VecInt.c:387:

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

In Str.c:106:

            if (next) {
                StrIter si = {.data = (char *)prev, .length = next - prev, .pos = 0, .alignment = 1};
                VecPushBack(&sv, si);
                prev = next + keylen; // skip past delimiter
            } else {

In Str.c:110:

            } else {
                StrIter si = {.data = (char *)prev, .length = end - prev, .pos = 0, .alignment = 1};
                VecPushBack(&sv, si);
                break;
            }

In Str.c:132:

                if (next) {
                    Str tmp = StrInitFromCstr(prev, next - prev);
                    VecPushBack(&sv, tmp); // exclude delimiter
                    prev = next + keylen;  // skip past delimiter
                } else {

In Str.c:137:

                    if (ZstrCompareN(prev, key, end - prev)) {
                        Str tmp = StrInitFromCstr(prev, end - prev);
                        VecPushBack(&sv, tmp); // remaining part
                    }
                    break;

In Dir.c:110:

    
            direntry.name = StrInitFromZstr(findFileData.cFileName); // Copy file name
            VecPushBack(&dc, direntry);
        } while (FindNextFile(hFind, &findFileData) != 0);

In Dir.c:176:

                }
                direntry.name = StrInitFromCstr(entry->d_name, NAMELEN(entry));
                VecPushBack(&dc, direntry);
            }
        }

In MisraDoc.c:49:

                        Str s = StrInit();                                                                                 \
                        JR_STR(json, s);                                                                                   \
                        VecPushBack(&p.test_directories, s);                                                               \
                    });                                                                                                    \
                    JR_ARR_KV(json, "source_directories", {                                                                \

In MisraDoc.c:54:

                        Str s = StrInit();                                                                                 \
                        JR_STR(json, s);                                                                                   \
                        VecPushBack(&p.source_directories, s);                                                             \
                    });                                                                                                    \
                });                                                                                                        \

In MisraDoc.c:146:

    
                                    // store the directory name, ownersip transferred
                                    VecPushBack(&dir_paths, path);
                    }
                    else if (dir_entry.type == SYS_DIR_ENTRY_TYPE_REGULAR_FILE) {

In MisraDoc.c:156:

    
                        // store discovered file name, ownersip transferred
                        VecPushBack(&file_paths, path);
                    }
                    // any other file type is not documented

In MisraEnum.c:100:

                }
    
                VecPushBack(&entries, e);
            });
        });

In Write.Nested.c:238:

        sym.binary_id             = 888;
        sym.debug                 = true;
        VecPushBack(&response.data, sym);
    
        JW_OBJ(json, {

In Write.Nested.c:300:

        FunctionInfo func1 = {12345, StrInitFromZstr("test_func"), 1024, 4096};
        FunctionInfo func2 = {54321, StrInitFromZstr("helper_func"), 512, 8192};
        VecPushBack(&functions, func1);
        VecPushBack(&functions, func2);

In Write.Nested.c:301:

        FunctionInfo func2 = {54321, StrInitFromZstr("helper_func"), 512, 8192};
        VecPushBack(&functions, func1);
        VecPushBack(&functions, func2);
    
        JW_OBJ(json, {

In Write.Nested.c:344:

        Str tag2 = StrInitFromZstr("x86");
    
        VecPushBack(&result.tags, tag1);
        VecPushBack(&result.tags, tag2);

In Write.Nested.c:345:

    
        VecPushBack(&result.tags, tag1);
        VecPushBack(&result.tags, tag2);
    
        result.created_at = StrInitFromZstr("2024-04-01");

In Write.Nested.c:394:

        sym1.target_function_id    = 222;
        sym1.distance              = 0.9;
        VecPushBack(&symbols, sym1);
    
        AnnSymbol sym2             = {0};

In Write.Nested.c:404:

        sym2.target_function_id    = 444;
        sym2.distance              = 0.8;
        VecPushBack(&symbols, sym2);
    
        JW_OBJ(json, {

In Write.Nested.c:486:

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

In Write.Nested.c:487:

        u32 num1 = 1, num2 = 2, num3 = 3;
        VecPushBack(&numbers, num1);
        VecPushBack(&numbers, num2);
        VecPushBack(&numbers, num3);

In Write.Nested.c:488:

        VecPushBack(&numbers, num1);
        VecPushBack(&numbers, num2);
        VecPushBack(&numbers, num3);
    
        Vec(Str) strings = VecInitWithDeepCopy(NULL, StrDeinit);

In Write.Nested.c:497:

        Str str3 = StrInitFromZstr("c");
    
        VecPushBack(&strings, str1);
        VecPushBack(&strings, str2);
        VecPushBack(&strings, str3);

In Write.Nested.c:498:

    
        VecPushBack(&strings, str1);
        VecPushBack(&strings, str2);
        VecPushBack(&strings, str3);

In Write.Nested.c:499:

        VecPushBack(&strings, str1);
        VecPushBack(&strings, str2);
        VecPushBack(&strings, str3);
    
        Vec(bool) booleans = VecInit();

In Write.Nested.c:503:

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

In Write.Nested.c:504:

        bool bool1 = true, bool2 = false, bool3 = true;
        VecPushBack(&booleans, bool1);
        VecPushBack(&booleans, bool2);
        VecPushBack(&booleans, bool3);

In Write.Nested.c:505:

        VecPushBack(&booleans, bool1);
        VecPushBack(&booleans, bool2);
        VecPushBack(&booleans, bool3);
    
        JW_OBJ(json, {

In Read.Simple.c:273:

                Str lang = StrInit();
                JR_STR(si, lang);
                VecPushBack(&languages, lang);
            });
        });

In Read.Simple.c:399:

                Str tag = StrInit();
                JR_STR(si, tag);
                VecPushBack(&product.tags, tag);
            });
        });

In Read.Nested.c:362:

                    });
    
                    VecPushBack(&symbols, sym);
                });
            });

In Read.Nested.c:468:

                        });
    
                        VecPushBack(&response.data, sym);
                    });
                });

In Read.Nested.c:803:

                        );
    
                        VecPushBack(&response.data, sym);
                        WriteFmt("[DEBUG] Added symbol to vector, length now: {}\n", response.data.length);
                    });

In Read.Nested.c:972:

                        );
    
                        VecPushBack(&response.data, sym);
                        WriteFmt("[DEBUG] Added symbol to vector, length now: {}\n", response.data.length);
                    });

In Write.EdgeCases.c:352:

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

In Write.EdgeCases.c:353:

        i32 val1 = 1, val2 = 2;
        VecPushBack(&filled_arr, val1);
        VecPushBack(&filled_arr, val2);
    
        i32 x_value = 1;

In Write.Simple.c:243:

        Str lang3 = StrInitFromZstr("Rust");
    
        VecPushBack(&languages, lang1);
        VecPushBack(&languages, lang2);
        VecPushBack(&languages, lang3);

In Write.Simple.c:244:

    
        VecPushBack(&languages, lang1);
        VecPushBack(&languages, lang2);
        VecPushBack(&languages, lang3);

In Write.Simple.c:245:

        VecPushBack(&languages, lang1);
        VecPushBack(&languages, lang2);
        VecPushBack(&languages, lang3);
    
        JW_OBJ(json, { JW_ARR_KV(json, "languages", languages, lang, { JW_STR(json, lang); }); });

In Write.Simple.c:314:

        Str tag3 = StrInitFromZstr("portable");
    
        VecPushBack(&product.tags, tag1);
        VecPushBack(&product.tags, tag2);
        VecPushBack(&product.tags, tag3);

In Write.Simple.c:315:

    
        VecPushBack(&product.tags, tag1);
        VecPushBack(&product.tags, tag2);
        VecPushBack(&product.tags, tag3);

In Write.Simple.c:316:

        VecPushBack(&product.tags, tag1);
        VecPushBack(&product.tags, tag2);
        VecPushBack(&product.tags, tag3);
    
        JW_OBJ(json, {

In RoundTrip.c:358:

        i32 nums[5] = {1, 2, 3, -5, 0};
        for (size i = 0; i < 5; i++) {
            VecPushBack(&original_numbers, nums[i]);
        }

In RoundTrip.c:367:

        Str str4 = StrInitFromZstr("last");
    
        VecPushBack(&original_strings, str1);
        VecPushBack(&original_strings, str2);
        VecPushBack(&original_strings, str3);

In RoundTrip.c:368:

    
        VecPushBack(&original_strings, str1);
        VecPushBack(&original_strings, str2);
        VecPushBack(&original_strings, str3);
        VecPushBack(&original_strings, str4);

In RoundTrip.c:369:

        VecPushBack(&original_strings, str1);
        VecPushBack(&original_strings, str2);
        VecPushBack(&original_strings, str3);
        VecPushBack(&original_strings, str4);

In RoundTrip.c:370:

        VecPushBack(&original_strings, str2);
        VecPushBack(&original_strings, str3);
        VecPushBack(&original_strings, str4);
    
        // Write to JSON

In RoundTrip.c:388:

                i32 num = 0;
                JR_INT(si, num);
                VecPushBack(&parsed_numbers, num);
            });
            JR_ARR_KV(si, "strings", {

In RoundTrip.c:393:

                Str str = StrInit();
                JR_STR(si, str);
                VecPushBack(&parsed_strings, str);
            });
        });

In RoundTrip.c:521:

        Str feature2 = StrInitFromZstr("logging");
    
        VecPushBack(&original.config.features, feature1);
        VecPushBack(&original.config.features, feature2);

In RoundTrip.c:522:

    
        VecPushBack(&original.config.features, feature1);
        VecPushBack(&original.config.features, feature2);
    
        original.numbers = VecInitT(original.numbers);

In RoundTrip.c:527:

        i32 vals[3]      = {10, 20, -5};
        for (size i = 0; i < 3; i++) {
            VecPushBack(&original.numbers, vals[i]);
        }

In RoundTrip.c:533:

        bool bools[3]  = {true, false, true};
        for (size i = 0; i < 3; i++) {
            VecPushBack(&original.flags, bools[i]);
        }

In RoundTrip.c:584:

                    Str feature = StrInit();
                    JR_STR(si, feature);
                    VecPushBack(&parsed.config.features, feature);
                });
            });

In RoundTrip.c:590:

                i32 num = 0;
                JR_INT(si, num);
                VecPushBack(&parsed.numbers, num);
            });
            JR_ARR_KV(si, "flags", {

In RoundTrip.c:595:

                bool flag = false;
                JR_BOOL(si, flag);
                VecPushBack(&parsed.flags, flag);
            });
        });

In RoundTrip.c:679:

                i32 num = 0;
                JR_INT(si, num);
                VecPushBack(&parsed_numbers, num);
            });
            JR_ARR_KV(si, "empty_strings", {

In RoundTrip.c:684:

                Str str = StrInit();
                JR_STR(si, str);
                VecPushBack(&parsed_strings, str);
            });
            JR_OBJ_KV(si, "empty_object", { found_empty_object = true; });

In Read.EdgeCases.c:108:

                i32 value = 0;
                JR_INT(si1, value);
                VecPushBack(&items, value);
            });
        });

In Read.EdgeCases.c:129:

                Str value = StrInit();
                JR_STR(si2, value);
                VecPushBack(&data, value);
            });
        });

In Read.EdgeCases.c:522:

                i32 item = 0;
                JR_INT(si, item);
                VecPushBack(&obj.filled_items, item);
            });
        });

In Vec.Remove.c:39:

        for (int i = 0; i < 5; i++) {
            int val = values[i];
            VecPushBack(&vec, val);
        }

In Vec.Remove.c:87:

        for (int i = 0; i < 5; i++) {
            int val = values[i];
            VecPushBack(&vec, val);
        }

In Vec.Remove.c:135:

        for (int i = 0; i < 5; i++) {
            int val = values[i];
            VecPushBack(&vec, val);
        }

In Vec.Remove.c:183:

        for (int i = 0; i < 5; i++) {
            int val = values[i];
            VecPushBack(&vec, val);
        }

In Vec.Remove.c:220:

        for (int i = 0; i < 7; i++) {
            int val = values[i];
            VecPushBack(&vec, val);
        }

In Vec.Remove.c:255:

        for (int i = 0; i < 10; i++) {
            int val = i * 10;
            VecPushBack(&vec, val);
        }

In Vec.Remove.c:332:

        for (int i = 0; i < 5; i++) {
            int val = values[i];
            VecPushBack(&vec, val);
        }

In Vec.Remove.c:377:

        int values[] = {10, 20, 30, 40, 50};
        for (int i = 0; i < 5; i++) {
            VecPushBack(&vec, values[i]);
        }

In Vec.Remove.c:413:

        int values[] = {10, 20, 30, 40, 50};
        for (int i = 0; i < 5; i++) {
            VecPushBack(&vec, values[i]);
        }

In Vec.Remove.c:448:

        int values[] = {10, 20, 30, 40, 50};
        for (int i = 0; i < 5; i++) {
            VecPushBack(&vec, values[i]);
        }

In Vec.Remove.c:529:

        int values[] = {10, 20, 30, 40, 50};
        for (int i = 0; i < 5; i++) {
            VecPushBack(&vec, values[i]);
        }

In Vec.Remove.c:606:

        int values[] = {10, 20, 30, 40, 50, 60, 70};
        for (int i = 0; i < 7; i++) {
            VecPushBack(&vec, values[i]);
        }

In Vec.Remove.c:643:

        int values[] = {10, 20, 30, 40, 50, 60, 70};
        for (int i = 0; i < 7; i++) {
            VecPushBack(&vec, values[i]);
        }

In Vec.Remove.c:678:

        int values[] = {10, 20, 30, 40, 50, 60, 70};
        for (int i = 0; i < 7; i++) {
            VecPushBack(&vec, values[i]);
        }

In Vec.Remove.c:757:

        int values[] = {10, 20, 30, 40, 50, 60, 70};
        for (int i = 0; i < 7; i++) {
            VecPushBack(&vec, values[i]);
        }

In Str.Type.c:51:

        Str s2 = StrInitFromZstr("World");
    
        VecPushBack(&sv, s1);
        VecPushBack(&sv, s2);

In Str.Type.c:52:

    
        VecPushBack(&sv, s1);
        VecPushBack(&sv, s2);
    
        // Check that it behaves like a Vec of Str objects

In Vec.Insert.c:24:

    // Test VecPushBack function
    bool test_vec_push_back(void) {
        WriteFmt("Testing VecPushBack\n");
    
        // Create a vector of integers

Last updated on April 20, 2026

VecPtrAt VecPushBackArr