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 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))
    
    ///

In BitVec.c:1377:

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

In BitVec.c:1445:

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

In BitVec.c:1452:

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

In SymbolResolver.c:168:

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

In PdbCache.c:107:

        }
    
        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:404:

        if (!self)
            return false;
        return VecPushBackR(&self->nameservers, ns);
    }

In Dns.c:551:

            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:586:

                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:634:

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

In Backtrace.c:62:

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

In MachoCache.c:53:

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

In Pe.c:413:

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

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 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 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 ProcMaps.c:188:

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

In DwarfUnwind.c:391:

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

In DwarfUnwind.c:414:

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

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:252:

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

In Elf.c:290:

            seg.memsz  = memsz;
            seg.align  = align;
            if (!VecPushBackR(&self->segments, seg)) {
                return false;
            }

In Elf.c:357:

            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 Ops.c:47:

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

In Ops.c:82:

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

In Ops.c:106:

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

In Ops.c:134:

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

In Ops.c:171:

        U32Vec vec = VecInit(&alloc);
        for (u32 i = 0; i < 3; i++) {
            VecPushBackR(&vec, i);
        }

In Ops.c:196:

        U32Vec vec = VecInit(&alloc);
        for (u32 i = 0; i < 3; i++) {
            VecPushBackR(&vec, i);
        }

In Complex.c:196:

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

In Complex.c:238:

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

In Complex.c:240:

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

In Complex.c:282:

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

In Complex.c:326:

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

In Complex.c:327:

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

In Complex.c:328:

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

In Complex.c:443:

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

In Complex.c:478:

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

In Complex.c:610:

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

In Complex.c:630:

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

In Complex.c:654:

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

In Complex.c:910:

        int    values[] = {1, 2, 3};
        for (int i = 0; i < 3; i++) {
            VecPushBackR(&src, values[i]);
        }

In Complex.c:936:

        int    values[] = {1, 2, 3};
        for (int i = 0; i < 3; i++) {
            VecPushBackR(&src, values[i]);
        }

In Complex.c:962:

        int    values[] = {1, 2, 3};
        for (int i = 0; i < 3; i++) {
            VecPushBackR(&src, values[i]);
        }

In Complex.c:987:

        int    values[] = {1, 2, 3};
        for (int i = 0; i < 3; i++) {
            VecPushBackR(&src, values[i]);
        }

In Complex.c:1012:

        int    values[] = {1, 2, 3};
        for (int i = 0; i < 3; i++) {
            VecPushBackR(&src, values[i]);
        }

In Memory.c:96:

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

In Memory.c:133:

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

In Memory.c:193:

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

In Memory.c:228:

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

In Memory.c:495:

        for (size i = 0; i < N; i++) {
            char c = (char)('a' + (int)(i % 26));
            VecPushBackR(&vec, c);
        }

In Memory.c:520:

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

In Memory.c:557:

            Wide w = {0};
            w.tag  = 100 + i;
            VecPushBackR(&vec, w);
        }

In Memory.c:585:

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

In Memory.c:652:

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

In Memory.c:681:

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

In Init.c:235:

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

In Init.c:236:

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

In Init.c:237:

            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 Init.c:254:

            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 Init.c:273:

            }
            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 Init.c:282:

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

In Init.c:301:

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

In Init.c:302:

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

In Init.c:303:

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

In Init.c:346:

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

In Insert.c:89:

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

In Insert.c:260:

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

In Insert.c:261:

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

In Insert.c:417:

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

In Insert.c:550:

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

In Insert.c:582:

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

In Insert.c:699:

        for (size i = 0; i < count; i++) {
            Elem e = {.value = seed + (int)i, .live = false};
            VecPushBackR(&vec, e);
        }
        return vec;

In Insert.c:737:

        VecReserve(&vec, 8);
        for (int i = 0; i < 8; i++) {
            VecPushBackR(&vec, i);
        }

In Insert.c:784:

        VecReserve(&vec, 10); // exact, non-power-of-2 capacity
        for (int i = 0; i < 5; i++) {
            VecPushBackR(&vec, i);
        }

In Insert.c:924:

        for (size i = 0; i < N; i++) {
            Elem e = {.value = (int)i, .live = false};
            VecPushBackR(&vec, e);
        }

In Insert.c:932:

        for (size i = 0; i < N; i++) {
            Elem e = {.value = 1000000 + (int)i, .live = false};
            VecPushBackR(&ins, e);
        }

In Insert.c:1908:

        for (u64 i = 0; i < 4; i++) {
            Elem e = {.value = 10 + (int)i};
            VecPushBackR(&vec, e);
        }

In Insert.c:1953:

        for (u64 i = 0; i < 4; i++) {
            Elem e = {.value = 100 + (int)i}; // 100..103
            VecPushBackR(&vec, e);
        }

In Remove.c:1151:

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

In Remove.c:1258:

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

In Remove.c:1281:

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

In Remove.c:1304:

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

In Remove.c:1323:

        IntVec vec = VecInit(&alloc);
        for (int i = 0; i < 10; i++) {
            VecPushBackR(&vec, i);  // [0..9]
        }

In Remove.c:1342:

        IntVec vec = VecInit(&alloc);
        for (int i = 0; i < 10; i++) {
            VecPushBackR(&vec, i);  // [0..9]
        }

In Remove.c:1363:

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

In Remove.c:1407:

        const size N = 100000;
        for (u64 i = 0; i < N; i++) {
            VecPushBackR(&vec, i + 1); // all non-zero
        }
        VecTryReduceSpace(&vec);       // capacity := length, buffer := length + 1

In Remove.c:1443:

        const size N = 100000;
        for (u64 i = 0; i < N; i++) {
            VecPushBackR(&vec, i + 1); // all non-zero
        }
        VecTryReduceSpace(&vec);       // capacity := length, buffer := length + 1

In Foreach.c:41:

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

In Foreach.c:80:

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

In Foreach.c:116:

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

In Foreach.c:157:

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

In Foreach.c:188:

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

In Foreach.c:221:

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

In Foreach.c:248:

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

In Foreach.c:282:

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

In Foreach.c:315:

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

In Foreach.c:355:

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

In Foreach.c:393:

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

In Foreach.c:432:

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

In Foreach.c:470:

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

In Foreach.c:507:

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

In Foreach.c:545:

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

In Access.c:39:

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

In Access.c:40:

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

In Access.c:41:

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

In Access.c:42:

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

In Access.c:43:

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

In Access.c:74:

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

In Access.c:75:

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

In Access.c:76:

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

In Access.c:114:

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

In Access.c:115:

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

In Access.c:116:

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

In Access.c:148:

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

In Access.c:149:

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

In Access.c:150:

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

In Access.c:188:

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

In Access.c:189:

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

In Access.c:190:

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

In Access.c:208:

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

In Access.c:209:

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

In Access.c:278:

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

In Access.c:279:

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

In Access.c:280:

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

In Access.c:281:

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

In Access.c:308:

        u32 values[] = {111, 222, 333, 444};
        for (int i = 0; i < 4; i++) {
            VecPushBackR(&vec, values[i]);
        }

In Access.c:335:

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

In Arena.c:78:

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

In Page.c:75:

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

In SysDns.c:50:

        e.ip[3]      = b3;
        e.is_ipv6    = false;
        VecPushBackR(&r->hosts, e);
    }

In SysDns.c:60:

        }
        e.is_ipv6 = true;
        VecPushBackR(&r->hosts, e);
    }

In SysDns.c:1344:

    
        Strs paths = VecInitT(paths, a);
        VecPushBackR(&paths, p0);
        VecPushBackR(&paths, p1);

In SysDns.c:1345:

        Strs paths = VecInitT(paths, a);
        VecPushBackR(&paths, p0);
        VecPushBackR(&paths, p1);
    
        bool added = DnsResolverAddHostsPaths(&r, &paths);

In SysDns.c:1375:

    
        Strs paths = VecInitT(paths, a);
        VecPushBackR(&paths, p0);
        VecPushBackR(&paths, p1);

In SysDns.c:1376:

        Strs paths = VecInitT(paths, a);
        VecPushBackR(&paths, p0);
        VecPushBackR(&paths, p1);
    
        bool added = DnsResolverAddResolvPaths(&r, &paths);

In SysDns.c:1406:

    
        Strs paths = VecInitT(paths, a);
        VecPushBackR(&paths, p0);
        VecPushBackR(&paths, p1);

In SysDns.c:1407:

        Strs paths = VecInitT(paths, a);
        VecPushBackR(&paths, p0);
        VecPushBackR(&paths, p1);
    
        bool added = DnsResolverAddPaths(&r, &paths);

In ProcMaps.c:326:

        ProcMapEntry e2 = {.start = 0x5000, .end = 0x6000, .perms = 0, .file_offset = 0, .path = ""};
    
        bool pushed = VecPushBackR(&pm.entries, e0) && VecPushBackR(&pm.entries, e1) && VecPushBackR(&pm.entries, e2);
        if (!pushed) {
            ProcMapsDeinit(&pm);

In Http.c:303:

        StrAppendFmt(&hh.value, "a-reasonably-long-header-value-string");
    
        bool ok = VecPushBackR(&headers, hh);
        ok      = ok && (VecLen(&headers) == 1);
        // R-push deep-copied into the vec and left `hh` owning its own storage;

Last updated on July 1, 2026

VecPushBackL VecPushFront