VecPushBackR

Documentation

API Reference

VecPushBackR

Description

Append a single element to the end of the vector. R-value form.

Success

Returns true. The vector length grows by one; the value of val occupies the new tail.

Failure

Returns false on allocation failure. The vector is unchanged.

Usage example (Cross-references)

Usage examples (Cross-references)

In BitVec.c:1322:

            if (BitVecContainsAt(bv, pattern, i)) {
                size idx = (size)i;
                if (!VecPushBackR(out, idx))
                    return false;
            }

In BitVec.c:1390:

            } else {
                BitVecRun r = {.length = current_run_length, .value = current_value};
                if (!VecPushBackR(out, r))
                    return false;
                current_value      = bit;

In BitVec.c:1397:

        }
        BitVecRun r = {.length = current_run_length, .value = current_value};
        if (!VecPushBackR(out, r))
            return false;
        return true;

In PdbCache.c:107:

        }
    
        if (!VecPushBackR(&self->entries, entry)) {
            StrDeinit(&entry.module_path);
            return NULL;

In Backtrace.c:62:

        VecSinkCtx *s = (VecSinkCtx *)user;
        StackFrame  f = {.ip = ip};
        if (!VecPushBackR(s->vec, f)) {
            s->oom = true;
            return false;

In SymbolResolver.c:167:

            entry.has_sidecar = true;
        }
        if (!VecPushBackR(&self->cache, entry)) {
            if (entry.has_sidecar)
                ElfDeinit(&entry.sidecar);

In ProcMaps.c:231:

                continue;
            }
            if (!VecPushBackR(&out->entries, e)) {
                ProcMapsDeinit(out);
                return false;

In MachoCache.c:53:

        }
    
        if (!VecPushBackR(&self->entries, entry)) {
            StrDeinit(&entry.module_path);
            return NULL;

In Dns.c:226:

                    e.is_ipv6 = true;
                }
                if (!VecPushBackR(table, e)) {
                    // VecPushBackR is R-form (copy semantics) -- on
                    // failure ownership of `e.name` stays with us. Release

In Dns.c:291:

                        if (parse_ipv4(StrBegin(&ip_buf), v4)) {
                            SocketAddr a = sockaddr_v4(v4, 53);
                            VecPushBackR(out, a);
                        } else if (parse_ipv6(StrBegin(&ip_buf), v6)) {
                            SocketAddr a = sockaddr_v6(v6, 53);

In Dns.c:294:

                        } else if (parse_ipv6(StrBegin(&ip_buf), v6)) {
                            SocketAddr a = sockaddr_v6(v6, 53);
                            VecPushBackR(out, a);
                        }
                    }

In Dns.c:470:

            if (rec->type == qtype) {
                SocketAddr a = qtype == DNS_TYPE_A ? sockaddr_v4(rec->ipv4, port) : sockaddr_v6(rec->ipv6, port);
                VecPushBackR(out, a);
                found = true;
            }

In Dns.c:505:

                if (StrLen(&e->name) > 0 && ZstrCompare(StrBegin(&e->name), nq) == 0) {
                    SocketAddr a = e->is_ipv6 ? sockaddr_v6(e->ip, port) : sockaddr_v4(e->ip, port);
                    VecPushBackR(out, a);
                    found = true;
                }

In Dns.c:553:

        SocketAddr direct;
        if (SocketAddrParse(&direct, spec, kind)) {
            VecPushBackR(out, direct);
            return true;
        }

In Http.c:167:

            }
    
            if (!VecPushBackR(&req->headers, hh)) {
                HttpHeaderDeinit(&hh);
                LOG_ERROR("failed to push header");

In MachO.c:206:

        (void)maxprot;
        (void)initprot;
        if (!VecPushBackR(&ctx->out->segments, seg))
            return false;

In MachO.c:252:

            (void)reserved2;
            (void)reserved3;
            if (!VecPushBackR(&ctx->out->sections, sec))
                return false;
            // Must-precondition: the `IterIndex + SECT64_SIZE > IterLength`

In MachO.c:406:

            sym.type          = n_type;
            sym.section_index = n_sect;
            if (!VecPushBackR(&ctx->out->symbols, sym))
                return false;
        }

In Elf.c:240:

            s.info       = info;
            s.entry_size = entsize;
            if (!VecPushBackR(&self->sections, s)) {
                return false;
            }

In Elf.c:307:

            s.value         = value;
            s.size          = size_;
            if (!VecPushBackR(out, s)) {
                return false;
            }

In Dwarf.c:236:

            if (!pool_append(pool, dir, &off))
                return false;
            if (!VecPushBackR(&cs->dir_offsets, off))
                return false;
        }

In Dwarf.c:259:

            if (!pool_append(pool, name, &off))
                return false;
            if (!VecPushBackR(&cs->file_offsets, off))
                return false;
            if (!VecPushBackR(&cs->file_dir_idx, dir_idx))

In Dwarf.c:261:

            if (!VecPushBackR(&cs->file_offsets, off))
                return false;
            if (!VecPushBackR(&cs->file_dir_idx, dir_idx))
                return false;
        }

In Dwarf.c:321:

            }
        }
        if (!VecPushBackR(pending_file_offsets, file_off))
            return false;
        if (!VecPushBackR(pending_dir_offsets, dir_off))

In Dwarf.c:323:

        if (!VecPushBackR(pending_file_offsets, file_off))
            return false;
        if (!VecPushBackR(pending_dir_offsets, dir_off))
            return false;

In Dwarf.c:326:

            return false;
    
        if (!VecPushBackR(&out->entries, e))
            return false;
        (void)pool;

In DwarfInfo.c:143:

                    break;
                AbbrevAttr a = {.name = (u32)name, .form = (u32)form};
                if (!VecPushBackR(&e.attrs, a)) {
                    VecDeinit(&e.attrs);
                    return false;

In DwarfInfo.c:148:

                }
            }
            if (!VecPushBackR(out, e)) {
                VecDeinit(&e.attrs);
                return false;

In DwarfInfo.c:485:

                            return false;
                        PendingFn pf = {.low_pc = low_pc, .high_pc = hi, .name_offset_in_pool = offset};
                        if (!VecPushBackR(pending, pf))
                            return false;
                    }

In DwarfInfo.c:616:

                        .name    = StrBegin(&out->string_pool) + pf->name_offset_in_pool,
                };
                if (!VecPushBackR(&out->entries, f)) {
                    ok = false;
                    break;

In Pdb.c:613:

                            return false;
                        }
                        if (!VecPushBackR(pending, pp)) {
                            AllocatorFree(BufAllocator(&self->data), buf);
                            return false;

In Pdb.c:680:

                f.size       = next_rva >= f.rva ? next_rva - f.rva : 0;
            }
            if (!VecPushBackR(&self->functions, f)) {
                ok = false;
                break;

In DwarfUnwind.c:399:

                BufIter body = BufIterFromMemory(IterDataAt(&section_cur, IterIndex(&section_cur)), length32 - 4);
                if (parse_cie(&body, cie_offset, &cie)) {
                    if (!VecPushBackR(&out->cies, cie)) {
                        DwarfCfiDeinit(out);
                        return false;

In DwarfUnwind.c:423:

                BufIter  body = BufIterFromMemory(IterDataAt(&section_cur, IterIndex(&section_cur)), length32 - 4);
                if (parse_fde(&body, rec_start, cie_offset, out, section_data, eh->addr, &fde)) {
                    if (!VecPushBackR(&out->fdes, fde)) {
                        DwarfCfiDeinit(out);
                        return false;

In Dns.c:262:

            // The record carries owned Str/Vec fields; leaking it on a
            // push-failure path would orphan their backing allocations.
            if (!VecPushBackR(out, rec)) {
                DnsRecordDeinit(&rec);
                return false;

In Pe.c:413:

            (void)num_linenums;
    
            if (!VecPushBackR(&ctx->out->sections, s))
                return false;
        }

In Allocator.Page.c:75:

    
        for (int i = 0; i < 1024; i++) {
            if (!VecPushBackR(&v, i)) {
                ok = false;
                break;

In Vec.Ops.c:41:

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

In Vec.Ops.c:76:

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

In Vec.Ops.c:100:

        int even_values[] = {10, 20, 30, 40};
        for (int i = 0; i < 4; i++) {
            VecPushBackR(&vec, even_values[i]);
        }

In Vec.Ops.c:128:

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

In Vec.Foreach.c:41:

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

In Vec.Foreach.c:80:

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

In Vec.Foreach.c:116:

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

In Vec.Foreach.c:157:

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

In Vec.Foreach.c:188:

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

In Vec.Foreach.c:221:

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

In Vec.Foreach.c:248:

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

In Vec.Foreach.c:282:

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

In Vec.Foreach.c:315:

        // Add some elements
        for (int i = 0; i < 5; i++) {
            VecPushBackR(&vec, i * 10);
        }

In Vec.Foreach.c:355:

        // Add some elements
        for (int i = 0; i < 6; i++) {
            VecPushBackR(&vec, i * 20);
        }

In Vec.Foreach.c:393:

        // Add several elements
        for (int i = 0; i < 6; i++) {
            VecPushBackR(&vec, i * 15);
        }

In Vec.Foreach.c:432:

        // Add several elements
        for (int i = 0; i < 7; i++) {
            VecPushBackR(&vec, i * 25);
        }

In Vec.Foreach.c:470:

        // Add several elements
        for (int i = 0; i < 8; i++) {
            VecPushBackR(&vec, i * 35);
        }

In Vec.Foreach.c:507:

        // Add several elements
        for (int i = 0; i < 9; i++) {
            VecPushBackR(&vec, i * 45);
        }

In Vec.Foreach.c:545:

        // Add several elements
        for (int i = 0; i < 5; i++) {
            VecPushBackR(&vec, i * 30);
        }

In Allocator.Arena.c:78:

    
        for (int i = 0; i < 4096; i++) {
            if (!VecPushBackR(&v, i)) {
                ok = false;
                break;

In Vec.Init.c:224:

            }
    
            VecPushBackR(&vec, 10);
            VecPushBackR(&vec, 20);
            VecPushBackR(&vec, 30);

In Vec.Init.c:225:

    
            VecPushBackR(&vec, 10);
            VecPushBackR(&vec, 20);
            VecPushBackR(&vec, 30);

In Vec.Init.c:226:

            VecPushBackR(&vec, 10);
            VecPushBackR(&vec, 20);
            VecPushBackR(&vec, 30);
    
            if (VecLen(&vec) != 3 || VecAt(&vec, 0) != 10 || VecAt(&vec, 1) != 20 || VecAt(&vec, 2) != 30) {

In Vec.Init.c:243:

            item.id       = 1;
            item.value    = 3.14;
            VecPushBackR(&test_vec, item);
    
            if (VecLen(&test_vec) != 1 || VecAt(&test_vec, 0).id != 1 || VecAt(&test_vec, 0).value != 3.14f) {

In Vec.Init.c:262:

            }
            AlignedItem item = {.a = 7, .b = 2.71828};
            VecPushBackR(&av, item);
            if (VecLen(&av) != 1 || VecAt(&av, 0).a != 7 || VecAt(&av, 0).b != 2.71828) {
                result = false;

In Vec.Init.c:271:

        // outer-for update still runs.
        VecInitStack(int, breakable, 8) {
            VecPushBackR(&breakable, 1);
            if (VecLen(&breakable) != 1) {
                result = false;

In Vec.Init.c:290:

    
        // Add some data
        VecPushBackR(&src, 1);
        VecPushBackR(&src, 2);
        VecPushBackR(&src, 3);

In Vec.Init.c:291:

        // Add some data
        VecPushBackR(&src, 1);
        VecPushBackR(&src, 2);
        VecPushBackR(&src, 3);

In Vec.Init.c:292:

        VecPushBackR(&src, 1);
        VecPushBackR(&src, 2);
        VecPushBackR(&src, 3);
    
        // Create a destination vector

In Vec.Memory.c:31:

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

In Vec.Memory.c:68:

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

In Vec.Memory.c:128:

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

In Vec.Memory.c:163:

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

In Vec.Complex.c:196:

    
        // Add the item to the vector
        VecPushBackR(&vec, item);
    
        // Check that the vector now has one item

In Vec.Complex.c:238:

    
        // Push items to the vector
        VecPushBackR(&vec, item1);
        VecPushFrontR(&vec, item2);
        VecPushBackR(&vec, item3);

In Vec.Complex.c:240:

        VecPushBackR(&vec, item1);
        VecPushFrontR(&vec, item2);
        VecPushBackR(&vec, item3);
    
        // Check vector length

In Vec.Complex.c:282:

    
        // Add item1 to the vector
        VecPushBackR(&vec, item1);
    
        // Insert item2 at index 0

In Vec.Complex.c:326:

    
        // Add items to vectors
        VecPushBackR(&vec1, item1);
        VecPushBackR(&vec2, item2);
        VecPushBackR(&vec2, item3);

In Vec.Complex.c:327:

        // Add items to vectors
        VecPushBackR(&vec1, item1);
        VecPushBackR(&vec2, item2);
        VecPushBackR(&vec2, item3);

In Vec.Complex.c:328:

        VecPushBackR(&vec1, item1);
        VecPushBackR(&vec2, item2);
        VecPushBackR(&vec2, item3);
    
        // Merge vec2 into vec1

In Vec.Complex.c:443:

        // Add some initial elements
        for (int i = 0; i < 5; i++) {
            VecPushBackR(&vec, i * 10);
        }

In Vec.Complex.c:478:

        // Add some initial elements
        for (int i = 0; i < 5; i++) {
            VecPushBackR(&vec2, i * 10);
        }

In Vec.Complex.c:610:

    
        // Test pushing to empty vector
        VecPushBackR(&vec, 10);
        bool result = (VecLen(&vec) == 1 && VecAt(&vec, 0) == 10);

In Vec.Complex.c:630:

        const int large_count = 1000;
        for (int i = 0; i < large_count; i++) {
            VecPushBackR(&vec, i);
        }

In Vec.Complex.c:654:

    
        // Push an element (should auto-resize)
        VecPushBackR(&vec, 42);
        result = result && (VecLen(&vec) == 1 && VecAt(&vec, 0) == 42);

In Vec.Access.c:35:

    
        // Add some data
        VecPushBackR(&vec, 10);
        VecPushBackR(&vec, 20);
        VecPushBackR(&vec, 30);

In Vec.Access.c:36:

        // Add some data
        VecPushBackR(&vec, 10);
        VecPushBackR(&vec, 20);
        VecPushBackR(&vec, 30);
        VecPushBackR(&vec, 40);

In Vec.Access.c:37:

        VecPushBackR(&vec, 10);
        VecPushBackR(&vec, 20);
        VecPushBackR(&vec, 30);
        VecPushBackR(&vec, 40);
        VecPushBackR(&vec, 50);

In Vec.Access.c:38:

        VecPushBackR(&vec, 20);
        VecPushBackR(&vec, 30);
        VecPushBackR(&vec, 40);
        VecPushBackR(&vec, 50);

In Vec.Access.c:39:

        VecPushBackR(&vec, 30);
        VecPushBackR(&vec, 40);
        VecPushBackR(&vec, 50);
    
        // Check values using VecAt

In Vec.Access.c:70:

    
        // Add some data
        VecPushBackR(&vec, 10);
        VecPushBackR(&vec, 20);
        VecPushBackR(&vec, 30);

In Vec.Access.c:71:

        // Add some data
        VecPushBackR(&vec, 10);
        VecPushBackR(&vec, 20);
        VecPushBackR(&vec, 30);

In Vec.Access.c:72:

        VecPushBackR(&vec, 10);
        VecPushBackR(&vec, 20);
        VecPushBackR(&vec, 30);
    
        // Get pointers to elements

In Vec.Access.c:110:

    
        // Add some data
        VecPushBackR(&vec, 10);
        VecPushBackR(&vec, 20);
        VecPushBackR(&vec, 30);

In Vec.Access.c:111:

        // Add some data
        VecPushBackR(&vec, 10);
        VecPushBackR(&vec, 20);
        VecPushBackR(&vec, 30);

In Vec.Access.c:112:

        VecPushBackR(&vec, 10);
        VecPushBackR(&vec, 20);
        VecPushBackR(&vec, 30);
    
        // Check first and last elements

In Vec.Access.c:144:

    
        // Add some data
        VecPushBackR(&vec, 10);
        VecPushBackR(&vec, 20);
        VecPushBackR(&vec, 30);

In Vec.Access.c:145:

        // Add some data
        VecPushBackR(&vec, 10);
        VecPushBackR(&vec, 20);
        VecPushBackR(&vec, 30);

In Vec.Access.c:146:

        VecPushBackR(&vec, 10);
        VecPushBackR(&vec, 20);
        VecPushBackR(&vec, 30);
    
        // Get begin and end pointers

In Vec.Access.c:184:

    
        // Add some data
        VecPushBackR(&vec, 10);
        VecPushBackR(&vec, 20);
        VecPushBackR(&vec, 30);

In Vec.Access.c:185:

        // Add some data
        VecPushBackR(&vec, 10);
        VecPushBackR(&vec, 20);
        VecPushBackR(&vec, 30);

In Vec.Access.c:186:

        VecPushBackR(&vec, 10);
        VecPushBackR(&vec, 20);
        VecPushBackR(&vec, 30);
    
        // Check size and length after adding elements

In Vec.Access.c:203:

    
        // Add some data
        VecPushBackR(&aligned_vec, 10);
        VecPushBackR(&aligned_vec, 20);

In Vec.Access.c:204:

        // Add some data
        VecPushBackR(&aligned_vec, 10);
        VecPushBackR(&aligned_vec, 20);
    
        // Check size and length with alignment

In Vec.Access.c:275:

        result       = result && !VecContains(&vec, &needle, compare_ints);
    
        VecPushBackR(&vec, 10);
        VecPushBackR(&vec, 20);
        VecPushBackR(&vec, 30);

In Vec.Access.c:276:

    
        VecPushBackR(&vec, 10);
        VecPushBackR(&vec, 20);
        VecPushBackR(&vec, 30);
        VecPushBackR(&vec, 20);

In Vec.Access.c:277:

        VecPushBackR(&vec, 10);
        VecPushBackR(&vec, 20);
        VecPushBackR(&vec, 30);
        VecPushBackR(&vec, 20);

In Vec.Access.c:278:

        VecPushBackR(&vec, 20);
        VecPushBackR(&vec, 30);
        VecPushBackR(&vec, 20);
    
        result = result && !VecEmpty(&vec);

In Vec.Insert.c:36:

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

In Vec.Insert.c:207:

    
        // Push some elements first
        VecPushBackR(&vec, 10);
        VecPushBackR(&vec, 20);

In Vec.Insert.c:208:

        // Push some elements first
        VecPushBackR(&vec, 10);
        VecPushBackR(&vec, 20);
    
        // Push an array at a specific index

In Vec.Insert.c:364:

    
        // Test R-value insert operations
        VecPushBackR(&vec, LVAL(42));
    
        // Check that the element was added

In Vec.Insert.c:497:

        int    merge_vals[] = {140, 150, 160};
        for (int i = 0; i < 3; i++) {
            VecPushBackR(&vec2, merge_vals[i]);
        }

In Vec.Insert.c:529:

        size orig_count  = sizeof(originals) / sizeof(originals[0]);
        for (size i = 0; i < orig_count; i++) {
            VecPushBackR(&vec, originals[i]);
        }

In Buf.h:167:

    static inline bool BufPushBytes(Buf *b, const u8 *data, size n) {
        for (size i = 0; i < n; ++i) {
            if (!VecPushBackR(b, data[i])) {
                return false;
            }

In Buf.h:431:

    ///
    static inline bool BufWriteU8(Buf *b, u8 v) {
        return VecPushBackR(b, v);
    }

In Buf.h:444:

    ///
    static inline bool BufWriteU16LE(Buf *b, u16 v) {
        return VecPushBackR(b, (u8)(v & 0xFFu)) && VecPushBackR(b, (u8)((v >> 8) & 0xFFu));
    }

In Buf.h:457:

    ///
    static inline bool BufWriteU16BE(Buf *b, u16 v) {
        return VecPushBackR(b, (u8)((v >> 8) & 0xFFu)) && VecPushBackR(b, (u8)(v & 0xFFu));
    }

In Buf.h:471:

    static inline bool BufWriteU32LE(Buf *b, u32 v) {
        for (int i = 0; i < 4; ++i) {
            if (!VecPushBackR(b, (u8)((v >> (i * 8)) & 0xFFu))) {
                return false;
            }

In Buf.h:489:

    static inline bool BufWriteU32BE(Buf *b, u32 v) {
        for (int i = 3; i >= 0; --i) {
            if (!VecPushBackR(b, (u8)((v >> (i * 8)) & 0xFFu))) {
                return false;
            }

In Buf.h:507:

    static inline bool BufWriteU64LE(Buf *b, u64 v) {
        for (int i = 0; i < 8; ++i) {
            if (!VecPushBackR(b, (u8)((v >> (i * 8)) & 0xFFu))) {
                return false;
            }

In Buf.h:525:

    static inline bool BufWriteU64BE(Buf *b, u64 v) {
        for (int i = 7; i >= 0; --i) {
            if (!VecPushBackR(b, (u8)((v >> (i * 8)) & 0xFFu))) {
                return false;
            }

In Buf.h:549:

                byte_ |= 0x80;
            }
            if (!VecPushBackR(b, byte_)) {
                return false;
            }

In Buf.h:578:

                byte_ |= 0x80;
            }
            if (!VecPushBackR(b, byte_)) {
                return false;
            }

In Buf.h:597:

    static inline bool BufWriteZstr(Buf *b, Zstr s) {
        while (*s) {
            if (!VecPushBackR(b, (u8)*s)) {
                return false;
            }

In Buf.h:602:

            ++s;
        }
        return VecPushBackR(b, (u8)0);
    }

In Insert.h:986:

    #define VecMustPushBackR(v, val)                                                                                       \
        do {                                                                                                               \
            if (!VecPushBackR((v), (val))) {                                                                               \
                LOG_FATAL("VecMustPushBackR failed");                                                                      \
            }                                                                                                              \

In Insert.h:162:

    /// TAGS: Str, PushBack, Char, RValue
    ///
    #define StrPushBackR(str, rval) VecPushBackR((str), (rval))
    
    ///

Last updated on June 4, 2026

VecPushBackL VecPushFront