uint32_t validateIndex(WrenVM* vm, Value arg, uint32_t count, const char* argName) { if (!validateNum(vm, arg, argName)) return UINT32_MAX; return validateIndexValue(vm, count, AS_NUM(arg), argName); }
// Validates that the argument at [argIndex] is an integer within `[0, count)`. // Also allows negative indices which map backwards from the end. Returns the // valid positive index value. If invalid, reports an error and returns -1. static int validateIndex(WrenVM* vm, Value* args, int count, int argIndex, const char* argName) { if (!validateNum(vm, args, argIndex, argName)) return -1; return validateIndexValue(vm, args, count, AS_NUM(args[argIndex]), argName); }
uint32_t calculateRange(WrenVM* vm, Value* args, ObjRange* range, uint32_t* length, int* step) { *step = 0; // Corner case: an empty range at zero is allowed on an empty sequence. // This way, list[0..-1] and list[0...list.count] can be used to copy a list // even when empty. if (*length == 0 && range->from == 0 && range->to == (range->isInclusive ? -1 : 0)) { return 0; } uint32_t from = validateIndexValue(vm, args, *length, range->from, "Range start"); if (from == UINT32_MAX) return UINT32_MAX; // Bounds check the end manually to handle exclusive ranges. double value = range->to; if (!validateIntValue(vm, args, value, "Range end")) return UINT32_MAX; // Negative indices count from the end. if (value < 0) value = *length + value; // Convert the exclusive range to an inclusive one. if (!range->isInclusive) { // An exclusive range with the same start and end points is empty. if (value == from) { *length = 0; return from; } // Shift the endpoint to make it inclusive, handling both increasing and // decreasing ranges. value += value >= from ? -1 : 1; } // Check bounds. if (value < 0 || value >= *length) { args[0] = CONST_STRING(vm, "Range end out of bounds."); return UINT32_MAX; } uint32_t to = (uint32_t)value; *length = abs((int)(from - to)) + 1; *step = from < to ? 1 : -1; return from; }