Function array_reserve

src/simulate/runtime_array.cpp:60–88

    }

    void array_reserve(Context & context, Array & arr, uint64_t newCapacity, uint32_t stride, LineInfo * at) {
        if ( arr.isLocked() ) context.throw_error_at(at, "can't change capacity of a locked array");
        if ( arr.capacity >= newCapacity ) return;
        // Explicit mul_overflow guard: stride is uint32, newCapacity is uint64.
        // The product can overflow uint64 when newCapacity > UINT64_MAX / stride
        // (with stride > 0). Panic before passing a wrap-around byte count to
        // the heap allocator (where it would silently allocate a small block
        // and the next memcpy would overrun random memory).
        if ( stride && newCapacity > UINT64_MAX / uint64_t(stride) ) {
            context.throw_error_at(at, "array_reserve: capacity*stride overflows uint64 [capacity=%llu] [stride=%u]", (unsigned long long)newCapacity, stride);
        }
        uint64_t memSize64 = newCapacity * uint64_t(stride);
        const char * prev_comment = arr.data ? context.heap->get_comment(arr.data) : nullptr;
        char * newData = nullptr;
        if ( context.verySafeContext ) {
            newData = (char *)context.allocate(memSize64, at);
            if ( newData && arr.data ) {
                memcpy(newData, arr.data, arr.size*stride);
            }
        } else {
            newData = (char *)context.reallocate(arr.data, arr.capacity*stride, memSize64, at);
        }
        context.heap->mark_comment(newData, prev_comment ? prev_comment : "array");
        if ( newData != arr.data ) {
            // memcpy(newData, arr.data, arr.capacity);
            arr.data = newData;
        }
        arr.capacity = newCapacity;
    }

    void array_resize ( Context & context, Array & arr, uint64_t newSize, uint32_t stride, bool zero, LineInfo * at ) {
        if ( arr.isLocked() ) context.throw_error_at(at, "can't resize locked array");