VecLen
Description
Number of elements currently stored in the vector.
Parameters
| Name | Direction | Description |
|---|---|---|
v |
in | Vector to query. |
Usage example (Cross-references)
Usage examples (Cross-references)
- In
Init.h:83:
#define IterInitFromVec(v) \
{.data = VecBegin(&(v)), \
.length = VecLen(&(v)), \
.pos = 0, \
.alignment = VecAllocator(&(v)) ? AllocatorAlignment(VecAllocator(&(v))) : 1, \- In
Init.h:102:
#define IterInitRevFromVec(v) \
{.data = VecBegin(&(v)), \
.length = VecLen(&(v)), \
.pos = 0, \
.alignment = VecAllocator(&(v)) ? AllocatorAlignment(VecAllocator(&(v))) : 1, \- In
Init.h:181:
#define IterInitFromVecT(i, v) \
((TYPE_OF(i)) {.data = VecBegin(&(v)), \
.length = VecLen(&(v)), \
.pos = 0, \
.alignment = VecAllocator(&(v)) ? AllocatorAlignment(VecAllocator(&(v))) : 1, \- In
Init.h:201:
#define IterInitRevFromVecT(i, v) \
((TYPE_OF(i)) {.data = VecBegin(&(v)), \
.length = VecLen(&(v)), \
.pos = 0, \
.alignment = VecAllocator(&(v)) ? AllocatorAlignment(VecAllocator(&(v))) : 1, \- In
Access.h:154:
/// TAGS: Vec, Empty, Query
///
#define VecEmpty(v) (VecLen(v) == 0)
///
- In
Access.h:27:
/// TAGS: Str, Length, Query
///
#define StrLen(str) VecLen(str)
///
- In
VecInt.c:49:
case VEC_INT_POP_BACK : {
if (VecLen(vec) > 0) {
i32 popped;
VecPopBack(vec, &popped);- In
VecInt.c:57:
case VEC_INT_POP_FRONT : {
if (VecLen(vec) > 0) {
i32 popped;
VecPopFront(vec, &popped);- In
VecInt.c:68:
i32 value = (i32)extract_u32(data, offset, data_size);
if (idx <= VecLen(vec)) {
VecInsert(vec, value, idx);
}- In
VecInt.c:76:
case VEC_INT_REMOVE : {
uint16_t idx = extract_u16(data, offset, data_size);
if (idx < VecLen(vec)) {
i32 removed;
VecRemove(vec, &removed, idx);- In
VecInt.c:85:
case VEC_INT_DELETE : {
uint16_t idx = extract_u16(data, offset, data_size);
if (idx < VecLen(vec)) {
VecDelete(vec, idx);
}- In
VecInt.c:93:
case VEC_INT_AT : {
uint16_t idx = extract_u16(data, offset, data_size);
if (idx < VecLen(vec)) {
volatile i32 value = VecAt(vec, idx);
(void)value; // Prevent optimization
- In
VecInt.c:101:
case VEC_INT_LEN : {
volatile uint64_t len = VecLen(vec);
(void)len;
break;- In
VecInt.c:107:
case VEC_INT_FIRST : {
if (VecLen(vec) > 0) {
volatile i32 first = VecFirst(vec);
(void)first;- In
VecInt.c:115:
case VEC_INT_LAST : {
if (VecLen(vec) > 0) {
volatile i32 last = VecLast(vec);
(void)last;- In
VecInt.c:163:
uint16_t idx2 = extract_u16(data, offset, data_size);
uint64_t len = VecLen(vec);
if (len > 1 && idx1 < len && idx2 < len) {
VecSwapItems(vec, idx1, idx2);- In
VecInt.c:176:
count = count % 16;
if (idx <= VecLen(vec) && count > 0) {
i32 values[16];
for (uint8_t i = 0; i < count && *offset + 4 <= data_size; i++) {- In
VecInt.c:191:
count = count % 16;
uint64_t len = VecLen(vec);
if (len > 0 && start < len && count > 0 && start + count <= len) {
i32 removed_items[16];- In
VecInt.c:204:
count = count % 16;
uint64_t len = VecLen(vec);
if (len > 0 && start < len && count > 0 && start + count <= len) {
VecDeleteRange(vec, start, count);- In
VecInt.c:215:
i32 value = (i32)extract_u32(data, offset, data_size);
if (idx <= VecLen(vec)) {
VecInsertFast(vec, value, idx);
}- In
VecInt.c:223:
case VEC_INT_REMOVE_FAST : {
uint16_t idx = extract_u16(data, offset, data_size);
if (idx < VecLen(vec)) {
i32 removed;
VecRemoveFast(vec, &removed, idx);- In
VecInt.c:235:
count = count % 16;
uint64_t len = VecLen(vec);
if (len > 0 && start < len && count > 0 && start + count <= len) {
i32 removed_items[16];- In
VecInt.c:255:
count = count % 16;
uint64_t len = VecLen(vec);
if (len > 0 && start < len && count > 0 && start + count <= len) {
VecDeleteRangeFast(vec, start, count);- In
VecInt.c:325:
case VEC_INT_PTR_AT : {
uint16_t idx = extract_u16(data, offset, data_size);
if (idx < VecLen(vec)) {
volatile i32 *ptr = VecPtrAt(vec, idx);
volatile i32 val = *ptr;- In
VecInt.c:353:
count = count % 16;
if (idx <= VecLen(vec) && count > 0) {
i32 values[16];
for (uint8_t i = 0; i < count && *offset + 4 <= data_size; i++) {- In
VecInt.c:365:
case VEC_INT_ALIGNED_OFFSET_AT : {
uint16_t idx = extract_u16(data, offset, data_size);
if (idx <= VecLen(vec)) {
volatile uint64_t offset_val = VecAlignedOffsetAt(vec, idx);
(void)offset_val;- In
VecInt.c:373:
case VEC_INT_DELETE_LAST : {
if (VecLen(vec) > 0) {
VecDeleteLast(vec);
}- In
VecInt.c:381:
case VEC_INT_DELETE_FAST : {
uint16_t idx = extract_u16(data, offset, data_size);
if (idx < VecLen(vec)) {
VecDeleteFast(vec, idx);
}- In
VecInt.c:405:
// Foreach operations
case VEC_INT_FOREACH : {
if (VecLen(vec) > 0) {
int sum = 0;
VecForeach(vec, item) {- In
VecInt.c:416:
case VEC_INT_FOREACH_IDX : {
if (VecLen(vec) > 0) {
int sum = 0;
VecForeachIdx(vec, item, idx) {- In
VecInt.c:427:
case VEC_INT_FOREACH_PTR : {
if (VecLen(vec) > 0) {
int sum = 0;
VecForeachPtr(vec, item_ptr) {- In
VecInt.c:438:
case VEC_INT_FOREACH_PTR_IDX : {
if (VecLen(vec) > 0) {
int sum = 0;
VecForeachPtrIdx(vec, item_ptr, idx) {- In
VecInt.c:449:
case VEC_INT_FOREACH_REVERSE : {
if (VecLen(vec) > 0) {
int sum = 0;
VecForeachReverse(vec, item) {- In
VecInt.c:460:
case VEC_INT_FOREACH_REVERSE_IDX : {
if (VecLen(vec) > 0) {
int sum = 0;
VecForeachReverseIdx(vec, item, idx) {- In
VecInt.c:471:
case VEC_INT_FOREACH_PTR_REVERSE : {
if (VecLen(vec) > 0) {
int sum = 0;
VecForeachPtrReverse(vec, item_ptr) {- In
VecInt.c:482:
case VEC_INT_FOREACH_PTR_REVERSE_IDX : {
if (VecLen(vec) > 0) {
int sum = 0;
VecForeachPtrReverseIdx(vec, item_ptr, idx) {- In
VecInt.c:493:
case VEC_INT_FOREACH_IN_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);- In
VecInt.c:494:
case VEC_INT_FOREACH_IN_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {- In
VecInt.c:495:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {
int sum = 0;- In
VecInt.c:508:
case VEC_INT_FOREACH_IN_RANGE_IDX : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);- In
VecInt.c:509:
case VEC_INT_FOREACH_IN_RANGE_IDX : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {- In
VecInt.c:510:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {
int sum = 0;- In
VecInt.c:523:
case VEC_INT_FOREACH_PTR_IN_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);- In
VecInt.c:524:
case VEC_INT_FOREACH_PTR_IN_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {- In
VecInt.c:525:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {
int sum = 0;- In
VecInt.c:538:
case VEC_INT_FOREACH_PTR_IN_RANGE_IDX : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);- In
VecInt.c:539:
case VEC_INT_FOREACH_PTR_IN_RANGE_IDX : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {- In
VecInt.c:540:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {
int sum = 0;- In
VecCharPtr.c:75:
case VEC_CHAR_PTR_POP_BACK : {
if (VecLen(vec) > 0) {
char *str;
VecPopBack(vec, &str);- In
VecCharPtr.c:84:
case VEC_CHAR_PTR_POP_FRONT : {
if (VecLen(vec) > 0) {
char *str;
VecPopFront(vec, &str);- In
VecCharPtr.c:94:
case VEC_CHAR_PTR_INSERT : {
if (*offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
char *str = generate_cstring(data, offset, data_size, 32);
if (str) {- In
VecCharPtr.c:105:
case VEC_CHAR_PTR_REMOVE : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
char *str;- In
VecCharPtr.c:106:
case VEC_CHAR_PTR_REMOVE : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
char *str;
VecRemove(vec, &str, index);- In
VecCharPtr.c:115:
case VEC_CHAR_PTR_DELETE : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
VecDelete(vec, index);- In
VecCharPtr.c:116:
case VEC_CHAR_PTR_DELETE : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
VecDelete(vec, index);
// char_ptr_deinit is called automatically by the vector
- In
VecCharPtr.c:124:
case VEC_CHAR_PTR_AT : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
char *str = VecAt(vec, index);- In
VecCharPtr.c:125:
case VEC_CHAR_PTR_AT : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
char *str = VecAt(vec, index);
(void)str; // Use the result to avoid warnings
- In
VecCharPtr.c:133:
case VEC_CHAR_PTR_LEN : {
size_t len = VecLen(vec);
(void)len; // Use the result to avoid warnings
break;- In
VecCharPtr.c:139:
case VEC_CHAR_PTR_FIRST : {
if (VecLen(vec) > 0) {
char *first = VecFirst(vec);
(void)first; // Use the result to avoid warnings
- In
VecCharPtr.c:147:
case VEC_CHAR_PTR_LAST : {
if (VecLen(vec) > 0) {
char *last = VecLast(vec);
(void)last; // Use the result to avoid warnings
- In
VecCharPtr.c:163:
if (*offset + 4 <= data_size) {
size_t new_size = extract_u32(data, offset, data_size) % 100; // Limit to reasonable size
size_t old_size = VecLen(vec);
// VecResize automatically handles cleanup of removed elements and
- In
VecCharPtr.c:213:
case VEC_CHAR_PTR_SWAP_ITEMS : {
if (VecLen(vec) >= 2 && *offset + 8 <= data_size) {
size_t i = extract_u32(data, offset, data_size) % VecLen(vec);
size_t j = extract_u32(data, offset, data_size) % VecLen(vec);- In
VecCharPtr.c:214:
case VEC_CHAR_PTR_SWAP_ITEMS : {
if (VecLen(vec) >= 2 && *offset + 8 <= data_size) {
size_t i = extract_u32(data, offset, data_size) % VecLen(vec);
size_t j = extract_u32(data, offset, data_size) % VecLen(vec);
VecSwapItems(vec, i, j);- In
VecCharPtr.c:215:
if (VecLen(vec) >= 2 && *offset + 8 <= data_size) {
size_t i = extract_u32(data, offset, data_size) % VecLen(vec);
size_t j = extract_u32(data, offset, data_size) % VecLen(vec);
VecSwapItems(vec, i, j);
}- In
VecCharPtr.c:223:
case VEC_CHAR_PTR_INSERT_RANGE : {
if (*offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
size_t count = extract_u32(data, offset, data_size) % 10; // Limit to reasonable count
- In
VecCharPtr.c:245:
case VEC_CHAR_PTR_REMOVE_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);- In
VecCharPtr.c:246:
case VEC_CHAR_PTR_REMOVE_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);
VecRemoveRange(vec, (char **)NULL, index, count);- In
VecCharPtr.c:247:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);
VecRemoveRange(vec, (char **)NULL, index, count);
}- In
VecCharPtr.c:254:
case VEC_CHAR_PTR_DELETE_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);- In
VecCharPtr.c:255:
case VEC_CHAR_PTR_DELETE_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);
VecDeleteRange(vec, index, count);- In
VecCharPtr.c:256:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);
VecDeleteRange(vec, index, count);
}- In
VecCharPtr.c:264:
case VEC_CHAR_PTR_INSERT_FAST : {
if (*offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
char *str = generate_cstring(data, offset, data_size, 32);
if (str) {- In
VecCharPtr.c:275:
case VEC_CHAR_PTR_REMOVE_FAST : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
char *str;- In
VecCharPtr.c:276:
case VEC_CHAR_PTR_REMOVE_FAST : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
char *str;
VecRemoveFast(vec, &str, index);- In
VecCharPtr.c:285:
case VEC_CHAR_PTR_REMOVE_RANGE_FAST : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);- In
VecCharPtr.c:286:
case VEC_CHAR_PTR_REMOVE_RANGE_FAST : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);
VecRemoveRangeFast(vec, (char **)NULL, index, count);- In
VecCharPtr.c:287:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);
VecRemoveRangeFast(vec, (char **)NULL, index, count);
}- In
VecCharPtr.c:294:
case VEC_CHAR_PTR_DELETE_RANGE_FAST : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);- In
VecCharPtr.c:295:
case VEC_CHAR_PTR_DELETE_RANGE_FAST : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);
VecDeleteRangeFast(vec, index, count);- In
VecCharPtr.c:296:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);
VecDeleteRangeFast(vec, index, count);
}- In
VecCharPtr.c:375:
case VEC_CHAR_PTR_BEGIN : {
if (VecLen(vec) > 0) {
char **begin = VecBegin(vec);
(void)begin; // Use the result to avoid warnings
- In
VecCharPtr.c:383:
case VEC_CHAR_PTR_END : {
if (VecLen(vec) > 0) {
char **end = VecEnd(vec);
(void)end; // Use the result to avoid warnings
- In
VecCharPtr.c:391:
case VEC_CHAR_PTR_PTR_AT : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
char **ptr = VecPtrAt(vec, index);- In
VecCharPtr.c:392:
case VEC_CHAR_PTR_PTR_AT : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
char **ptr = VecPtrAt(vec, index);
(void)ptr; // Use the result to avoid warnings
- In
VecCharPtr.c:424:
case VEC_CHAR_PTR_INSERT_RANGE_FAST : {
if (*offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
size_t count = extract_u32(data, offset, data_size) % 10; // Limit to reasonable count
- In
VecCharPtr.c:446:
case VEC_CHAR_PTR_ALIGNED_OFFSET_AT : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t aligned = VecAlignedOffsetAt(vec, index);- In
VecCharPtr.c:447:
case VEC_CHAR_PTR_ALIGNED_OFFSET_AT : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t aligned = VecAlignedOffsetAt(vec, index);
(void)aligned;- In
VecCharPtr.c:455:
case VEC_CHAR_PTR_DELETE_LAST : {
if (VecLen(vec) > 0) {
VecDeleteLast(vec);
}- In
VecCharPtr.c:462:
case VEC_CHAR_PTR_DELETE_FAST : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
VecDeleteFast(vec, index);- In
VecCharPtr.c:463:
case VEC_CHAR_PTR_DELETE_FAST : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
VecDeleteFast(vec, index);
}- In
VecCharPtr.c:494:
// Foreach operations
case VEC_CHAR_PTR_FOREACH : {
if (VecLen(vec) > 0) {
size_t total_len = 0;
VecForeach(vec, str) {- In
VecCharPtr.c:505:
case VEC_CHAR_PTR_FOREACH_IDX : {
if (VecLen(vec) > 0) {
size_t total_len = 0;
VecForeachIdx(vec, str, idx) {- In
VecCharPtr.c:516:
case VEC_CHAR_PTR_FOREACH_PTR : {
if (VecLen(vec) > 0) {
size_t total_len = 0;
VecForeachPtr(vec, str_ptr) {- In
VecCharPtr.c:527:
case VEC_CHAR_PTR_FOREACH_PTR_IDX : {
if (VecLen(vec) > 0) {
size_t total_len = 0;
VecForeachPtrIdx(vec, str_ptr, idx) {- In
VecCharPtr.c:538:
case VEC_CHAR_PTR_FOREACH_REVERSE : {
if (VecLen(vec) > 0) {
size_t total_len = 0;
VecForeachReverse(vec, str) {- In
VecCharPtr.c:549:
case VEC_CHAR_PTR_FOREACH_REVERSE_IDX : {
if (VecLen(vec) > 0) {
size_t total_len = 0;
VecForeachReverseIdx(vec, str, idx) {- In
VecCharPtr.c:560:
case VEC_CHAR_PTR_FOREACH_PTR_REVERSE : {
if (VecLen(vec) > 0) {
size_t total_len = 0;
VecForeachPtrReverse(vec, str_ptr) {- In
VecCharPtr.c:571:
case VEC_CHAR_PTR_FOREACH_PTR_REVERSE_IDX : {
if (VecLen(vec) > 0) {
size_t total_len = 0;
VecForeachPtrReverseIdx(vec, str_ptr, idx) {- In
VecCharPtr.c:582:
case VEC_CHAR_PTR_FOREACH_IN_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);- In
VecCharPtr.c:583:
case VEC_CHAR_PTR_FOREACH_IN_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {- In
VecCharPtr.c:584:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {
size_t total_len = 0;- In
VecCharPtr.c:597:
case VEC_CHAR_PTR_FOREACH_IN_RANGE_IDX : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);- In
VecCharPtr.c:598:
case VEC_CHAR_PTR_FOREACH_IN_RANGE_IDX : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {- In
VecCharPtr.c:599:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {
size_t total_len = 0;- In
VecCharPtr.c:612:
case VEC_CHAR_PTR_FOREACH_PTR_IN_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);- In
VecCharPtr.c:613:
case VEC_CHAR_PTR_FOREACH_PTR_IN_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {- In
VecCharPtr.c:614:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {
size_t total_len = 0;- In
VecCharPtr.c:627:
case VEC_CHAR_PTR_FOREACH_PTR_IN_RANGE_IDX : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);- In
VecCharPtr.c:628:
case VEC_CHAR_PTR_FOREACH_PTR_IN_RANGE_IDX : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {- In
VecCharPtr.c:629:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {
size_t total_len = 0;- In
VecStr.c:100:
case VEC_STR_POP_BACK : {
if (VecLen(vec) > 0) {
Str str;
VecPopBack(vec, &str);- In
VecStr.c:109:
case VEC_STR_POP_FRONT : {
if (VecLen(vec) > 0) {
Str str;
VecPopFront(vec, &str);- In
VecStr.c:119:
case VEC_STR_INSERT : {
if (*offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
Str str = generate_str_from_input(data, offset, data_size, 32, alloc);
VecInsert(vec, str, index);- In
VecStr.c:127:
case VEC_STR_REMOVE : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
Str str;- In
VecStr.c:128:
case VEC_STR_REMOVE : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
Str str;
VecRemove(vec, &str, index);- In
VecStr.c:137:
case VEC_STR_DELETE : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
VecDelete(vec, index);- In
VecStr.c:138:
case VEC_STR_DELETE : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
VecDelete(vec, index);
// StrDeinit is called automatically by the vector
- In
VecStr.c:146:
case VEC_STR_AT : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
Str str = VecAt(vec, index);- In
VecStr.c:147:
case VEC_STR_AT : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
Str str = VecAt(vec, index);
(void)str; // Use the result to avoid warnings
- In
VecStr.c:155:
case VEC_STR_LEN : {
size_t len = VecLen(vec);
(void)len; // Use the result to avoid warnings
break;- In
VecStr.c:161:
case VEC_STR_FIRST : {
if (VecLen(vec) > 0) {
Str first = VecFirst(vec);
(void)first; // Use the result to avoid warnings
- In
VecStr.c:169:
case VEC_STR_LAST : {
if (VecLen(vec) > 0) {
Str last = VecLast(vec);
(void)last; // Use the result to avoid warnings
- In
VecStr.c:185:
if (*offset + 4 <= data_size) {
size_t new_size = extract_u32(data, offset, data_size) % 100; // Limit to reasonable size
size_t old_size = VecLen(vec);
// VecResize automatically handles cleanup of removed elements and
- In
VecStr.c:227:
case VEC_STR_SWAP_ITEMS : {
if (VecLen(vec) >= 2 && *offset + 8 <= data_size) {
size_t i = extract_u32(data, offset, data_size) % VecLen(vec);
size_t j = extract_u32(data, offset, data_size) % VecLen(vec);- In
VecStr.c:228:
case VEC_STR_SWAP_ITEMS : {
if (VecLen(vec) >= 2 && *offset + 8 <= data_size) {
size_t i = extract_u32(data, offset, data_size) % VecLen(vec);
size_t j = extract_u32(data, offset, data_size) % VecLen(vec);
VecSwapItems(vec, i, j);- In
VecStr.c:229:
if (VecLen(vec) >= 2 && *offset + 8 <= data_size) {
size_t i = extract_u32(data, offset, data_size) % VecLen(vec);
size_t j = extract_u32(data, offset, data_size) % VecLen(vec);
VecSwapItems(vec, i, j);
}- In
VecStr.c:237:
case VEC_STR_INSERT_RANGE : {
if (*offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
size_t count = extract_u32(data, offset, data_size) % 10; // Limit to reasonable count
- In
VecStr.c:254:
case VEC_STR_REMOVE_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);- In
VecStr.c:255:
case VEC_STR_REMOVE_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);
VecRemoveRange(vec, (Str *)NULL, index, count);- In
VecStr.c:256:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);
VecRemoveRange(vec, (Str *)NULL, index, count);
}- In
VecStr.c:263:
case VEC_STR_DELETE_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);- In
VecStr.c:264:
case VEC_STR_DELETE_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);
VecDeleteRange(vec, index, count);- In
VecStr.c:265:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);
VecDeleteRange(vec, index, count);
}- In
VecStr.c:273:
case VEC_STR_INSERT_FAST : {
if (*offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
Str str = generate_str_from_input(data, offset, data_size, 32, alloc);
VecInsertFast(vec, str, index);- In
VecStr.c:281:
case VEC_STR_REMOVE_FAST : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
Str str;- In
VecStr.c:282:
case VEC_STR_REMOVE_FAST : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
Str str;
VecRemoveFast(vec, &str, index);- In
VecStr.c:291:
case VEC_STR_REMOVE_RANGE_FAST : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);- In
VecStr.c:292:
case VEC_STR_REMOVE_RANGE_FAST : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);
VecRemoveRangeFast(vec, (Str *)NULL, index, count);- In
VecStr.c:293:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);
VecRemoveRangeFast(vec, (Str *)NULL, index, count);
}- In
VecStr.c:300:
case VEC_STR_DELETE_RANGE_FAST : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);- In
VecStr.c:301:
case VEC_STR_DELETE_RANGE_FAST : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);
VecDeleteRangeFast(vec, index, count);- In
VecStr.c:302:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);
VecDeleteRangeFast(vec, index, count);
}- In
VecStr.c:363:
case VEC_STR_BEGIN : {
if (VecLen(vec) > 0) {
Str *begin = VecBegin(vec);
(void)begin; // Use the result to avoid warnings
- In
VecStr.c:371:
case VEC_STR_END : {
if (VecLen(vec) > 0) {
Str *end = VecEnd(vec);
(void)end; // Use the result to avoid warnings
- In
VecStr.c:379:
case VEC_STR_PTR_AT : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
Str *ptr = VecPtrAt(vec, index);- In
VecStr.c:380:
case VEC_STR_PTR_AT : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
Str *ptr = VecPtrAt(vec, index);
(void)ptr; // Use the result to avoid warnings
- In
VecStr.c:407:
case VEC_STR_INSERT_RANGE_FAST : {
if (*offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
size_t count = extract_u32(data, offset, data_size) % 10; // Limit to reasonable count
- In
VecStr.c:423:
case VEC_STR_ALIGNED_OFFSET_AT : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t aligned = VecAlignedOffsetAt(vec, index);- In
VecStr.c:424:
case VEC_STR_ALIGNED_OFFSET_AT : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t aligned = VecAlignedOffsetAt(vec, index);
(void)aligned;- In
VecStr.c:432:
case VEC_STR_DELETE_LAST : {
if (VecLen(vec) > 0) {
VecDeleteLast(vec);
}- In
VecStr.c:439:
case VEC_STR_DELETE_FAST : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
VecDeleteFast(vec, index);- In
VecStr.c:440:
case VEC_STR_DELETE_FAST : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
VecDeleteFast(vec, index);
}- In
VecStr.c:472:
// Foreach operations
case VEC_STR_FOREACH : {
if (VecLen(vec) > 0) {
size_t total_len = 0;
VecForeach(vec, str) {- In
VecStr.c:483:
case VEC_STR_FOREACH_IDX : {
if (VecLen(vec) > 0) {
size_t total_len = 0;
VecForeachIdx(vec, str, idx) {- In
VecStr.c:494:
case VEC_STR_FOREACH_PTR : {
if (VecLen(vec) > 0) {
size_t total_len = 0;
VecForeachPtr(vec, str_ptr) {- In
VecStr.c:505:
case VEC_STR_FOREACH_PTR_IDX : {
if (VecLen(vec) > 0) {
size_t total_len = 0;
VecForeachPtrIdx(vec, str_ptr, idx) {- In
VecStr.c:516:
case VEC_STR_FOREACH_REVERSE : {
if (VecLen(vec) > 0) {
size_t total_len = 0;
VecForeachReverse(vec, str) {- In
VecStr.c:527:
case VEC_STR_FOREACH_REVERSE_IDX : {
if (VecLen(vec) > 0) {
size_t total_len = 0;
VecForeachReverseIdx(vec, str, idx) {- In
VecStr.c:538:
case VEC_STR_FOREACH_PTR_REVERSE : {
if (VecLen(vec) > 0) {
size_t total_len = 0;
VecForeachPtrReverse(vec, str_ptr) {- In
VecStr.c:549:
case VEC_STR_FOREACH_PTR_REVERSE_IDX : {
if (VecLen(vec) > 0) {
size_t total_len = 0;
VecForeachPtrReverseIdx(vec, str_ptr, idx) {- In
VecStr.c:560:
case VEC_STR_FOREACH_IN_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);- In
VecStr.c:561:
case VEC_STR_FOREACH_IN_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {- In
VecStr.c:562:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {
size_t total_len = 0;- In
VecStr.c:575:
case VEC_STR_FOREACH_IN_RANGE_IDX : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);- In
VecStr.c:576:
case VEC_STR_FOREACH_IN_RANGE_IDX : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {- In
VecStr.c:577:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {
size_t total_len = 0;- In
VecStr.c:590:
case VEC_STR_FOREACH_PTR_IN_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);- In
VecStr.c:591:
case VEC_STR_FOREACH_PTR_IN_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {- In
VecStr.c:592:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {
size_t total_len = 0;- In
VecStr.c:605:
case VEC_STR_FOREACH_PTR_IN_RANGE_IDX : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);- In
VecStr.c:606:
case VEC_STR_FOREACH_PTR_IN_RANGE_IDX : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {- In
VecStr.c:607:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {
size_t total_len = 0;- In
ArgParse.c:370:
u64 left_w[64];
u64 max_w = 0;
u64 n_specs = VecLen(&self->specs);
if (n_specs > 64)
n_specs = 64;- In
Graph.c:37:
static void graph_validate_slot_limit(const GenericGraph *graph) {
if (VecLen(&graph->slots) > (u64)UINT32_MAX) {
LOG_FATAL("Graph exceeded maximum supported slot count");
}- In
Graph.c:51:
static void graph_validate_node_index_raw(const GenericGraph *graph, u32 index) {
if ((u64)index >= VecLen(&graph->slots)) {
LOG_FATAL("graph node id out of bounds");
}- In
Graph.c:178:
(const u8 *)&index,
sizeof(u32),
VecLen(&graph->free_indices),
1
)) {- In
Graph.c:188:
u32 index;
if (!VecLen(&graph->free_indices)) {
LOG_FATAL("expected at least one free graph slot");
}- In
Graph.c:199:
size idx;
for (idx = 0; idx < VecLen(neighbors); idx++) {
if (VecAt(neighbors, idx) == node_id) {
return true;- In
Graph.c:211:
size idx;
for (idx = 0; idx < VecLen(neighbors); idx++) {
if (VecAt(neighbors, idx) == node_id) {
return idx;- In
Graph.c:223:
size idx;
for (idx = 0; idx < VecLen(&graph->pending_edge_removals); idx++) {
const GraphPendingEdgeRemoval *pending =
VecPtrAt((GraphPendingEdgeRemovals *)&graph->pending_edge_removals, idx);- In
Graph.c:263:
size idx = 0;
while (idx < VecLen(neighbors)) {
GraphNodeId neighbor_id = VecAt(neighbors, idx);
const GenericGraphSlot *slot;- In
Graph.c:288:
GraphNeighbors *neighbors = graph_out_neighbors_ptr(graph, from);
while (VecLen(neighbors)) {
GraphNodeId to = VecLast(neighbors);
if (!graph_remove_edge_now(graph, from, to)) {- In
Graph.c:343:
graph_validate_slot_limit(graph);
if (graph->live_count > VecLen(&graph->slots)) {
LOG_FATAL("Graph live node count exceeds slot count");
}- In
Graph.c:351:
}
if ((graph->live_count + VecLen(&graph->free_indices)) != VecLen(&graph->slots)) {
LOG_FATAL("Graph slot accounting is inconsistent");
}- In
Graph.c:355:
}
for (slot_index = 0; slot_index < VecLen(&graph->slots); slot_index++) {
const GenericGraphSlot *slot = VecPtrAt((GraphSlots *)&graph->slots, slot_index);
GraphNodeId self_id = graph_make_node_id((u32)slot_index, slot->generation);- In
Graph.c:373:
live_count += 1;
out_edge_count += VecLen(&slot->out_neighbors);
in_edge_count += VecLen(&slot->in_neighbors);
marked_count += graph_slot_is_marked(slot) ? 1 : 0;- In
Graph.c:374:
live_count += 1;
out_edge_count += VecLen(&slot->out_neighbors);
in_edge_count += VecLen(&slot->in_neighbors);
marked_count += graph_slot_is_marked(slot) ? 1 : 0;- In
Graph.c:377:
marked_count += graph_slot_is_marked(slot) ? 1 : 0;
for (neighbor_i = 0; neighbor_i < VecLen(&slot->out_neighbors); neighbor_i++) {
GraphNodeId neighbor_id = VecAt(&slot->out_neighbors, neighbor_i);
const GenericGraphSlot *target_slot;- In
Graph.c:388:
}
for (neighbor_i = 0; neighbor_i < VecLen(&slot->in_neighbors); neighbor_i++) {
GraphNodeId predecessor_id = VecAt(&slot->in_neighbors, neighbor_i);
const GenericGraphSlot *source_slot;- In
Graph.c:407:
}
if (VecLen(&slot->out_neighbors) != 0) {
LOG_FATAL("Free graph slot retains outgoing edges");
}- In
Graph.c:411:
}
if (VecLen(&slot->in_neighbors) != 0) {
LOG_FATAL("Free graph slot retains incoming edges");
}- In
Graph.c:417:
}
for (free_index_i = 0; free_index_i < VecLen(&graph->free_indices); free_index_i++) {
u32 index = VecAt(&graph->free_indices, free_index_i);
if ((u64)index >= VecLen(&graph->slots)) {- In
Graph.c:419:
for (free_index_i = 0; free_index_i < VecLen(&graph->free_indices); free_index_i++) {
u32 index = VecAt(&graph->free_indices, free_index_i);
if ((u64)index >= VecLen(&graph->slots)) {
LOG_FATAL("Graph free slot index out of bounds");
}- In
Graph.c:428:
}
for (free_index_i = 0; free_index_i < VecLen(&graph->pending_edge_removals); free_index_i++) {
const GraphPendingEdgeRemoval *pending =
VecPtrAt((GraphPendingEdgeRemovals *)&graph->pending_edge_removals, free_index_i);- In
Graph.c:473:
ValidateGraph(graph);
for (slot_index = 0; slot_index < VecLen(&graph->slots); slot_index++) {
GenericGraphSlot *slot = VecPtrAt(&graph->slots, slot_index);
if (graph_slot_is_occupied(slot)) {- In
Graph.c:489:
clear_vec(GENERIC_VEC(&graph->free_indices), sizeof(u32));
clear_vec(GENERIC_VEC(&graph->pending_edge_removals), sizeof(GraphPendingEdgeRemoval));
for (slot_index = 0; slot_index < VecLen(&graph->slots); slot_index++) {
u32 index = (u32)slot_index;
graph_push_free_index(graph, index);- In
Graph.c:534:
ValidateGraph(graph);
if (VecLen(&graph->free_indices)) {
slot_index = graph_take_free_index(graph);
slot_ptr = graph_slot_ptr_raw(graph, slot_index);- In
Graph.c:569:
graph_validate_slot_limit(graph);
if (!reserve_graph(graph, item_size, VecLen(&graph->slots) + 1)) {
return 0;
}- In
Graph.c:591:
(const u8 *)&slot,
sizeof(GenericGraphSlot),
VecLen(&graph->slots),
1
)) {- In
Graph.c:600:
}
slot_index = (u32)(VecLen(&graph->slots) - 1);
node_id = graph_make_node_id(slot_index, 1);- In
Graph.c:638:
generation = GraphNodeIdGeneration(node_id);
if (!generation || ((u64)index >= VecLen(&graph->slots))) {
return false;
}- In
Graph.c:680:
size graph_out_degree(GenericGraph *graph, GraphNodeId node_id) {
return VecLen(graph_out_neighbors_ptr(graph, node_id));
}- In
Graph.c:684:
size graph_in_degree(GenericGraph *graph, GraphNodeId node_id) {
return VecLen(graph_in_neighbors_ptr(graph, node_id));
}- In
Graph.c:694:
neighbors = graph_out_neighbors_ptr(graph, from);
if (neighbor_idx >= VecLen(neighbors)) {
LOG_FATAL("graph neighbor index out of bounds");
}- In
Graph.c:708:
neighbors = graph_in_neighbors_ptr(graph, to);
if (predecessor_idx >= VecLen(neighbors)) {
LOG_FATAL("graph predecessor index out of bounds");
}- In
Graph.c:744:
(const u8 *)&to,
sizeof(GraphNodeId),
VecLen(out_neighbors),
1
)) {- In
Graph.c:753:
(const u8 *)&from,
sizeof(GraphNodeId),
VecLen(in_neighbors),
1
)) {- In
Graph.c:756:
1
)) {
remove_range_vec(GENERIC_VEC(out_neighbors), NULL, sizeof(GraphNodeId), VecLen(out_neighbors) - 1, 1);
return false;
}- In
Graph.c:871:
(const u8 *)&pending,
sizeof(GraphPendingEdgeRemoval),
VecLen(&graph->pending_edge_removals),
1
);- In
Graph.c:908:
ValidateGraph(graph);
if (!graph->pending_delete_count && !VecLen(&graph->pending_edge_removals)) {
return 0;
}- In
Graph.c:912:
}
explicit_edge_removal_count = VecLen(&graph->pending_edge_removals);
for (edge_idx = 0; edge_idx < VecLen(&graph->pending_edge_removals); edge_idx++) {
GraphPendingEdgeRemoval *pending = VecPtrAt(&graph->pending_edge_removals, edge_idx);- In
Graph.c:913:
explicit_edge_removal_count = VecLen(&graph->pending_edge_removals);
for (edge_idx = 0; edge_idx < VecLen(&graph->pending_edge_removals); edge_idx++) {
GraphPendingEdgeRemoval *pending = VecPtrAt(&graph->pending_edge_removals, edge_idx);
(void)graph_remove_edge_now(graph, pending->from, pending->to);- In
Graph.c:919:
clear_vec(GENERIC_VEC(&graph->pending_edge_removals), sizeof(GraphPendingEdgeRemoval));
for (slot_index = 0; slot_index < VecLen(&graph->slots); slot_index++) {
GenericGraphSlot *slot = VecPtrAt(&graph->slots, slot_index);
if (graph_slot_is_occupied(slot) && graph_slot_is_marked(slot)) {- In
Graph.c:927:
}
for (slot_index = 0; slot_index < VecLen(&graph->slots); slot_index++) {
GenericGraphSlot *slot = VecPtrAt(&graph->slots, slot_index);
if (graph_slot_is_occupied(slot) && !graph_slot_is_marked(slot)) {- In
Graph.c:935:
}
for (slot_index = 0; slot_index < VecLen(&graph->slots); slot_index++) {
GenericGraphSlot *slot = VecPtrAt(&graph->slots, slot_index);
if (graph_slot_is_occupied(slot) && graph_slot_is_marked(slot)) {- In
Graph.c:938:
GenericGraphSlot *slot = VecPtrAt(&graph->slots, slot_index);
if (graph_slot_is_occupied(slot) && graph_slot_is_marked(slot)) {
if (VecLen(&slot->out_neighbors) || VecLen(&slot->in_neighbors)) {
LOG_FATAL("Graph marked node retained incident edges before release");
}- In
Graph.c:978:
}
while (iter->slot_index < VecLen(&iter->graph->slots)) {
u32 index = (u32)iter->slot_index;
GenericGraphSlot *slot = VecPtrAt(&iter->graph->slots, iter->slot_index);- In
Graph.c:1026:
neighbors = graph_out_neighbors_ptr(iter->graph, iter->source_id);
while (iter->neighbor_index < VecLen(neighbors)) {
GraphNodeId neighbor_id = VecAt(neighbors, iter->neighbor_index);
iter->neighbor_index += 1;- In
Graph.c:1073:
neighbors = graph_in_neighbors_ptr(iter->graph, iter->target_id);
while (iter->predecessor_index < VecLen(neighbors)) {
GraphNodeId predecessor_id = VecAt(neighbors, iter->predecessor_index);
iter->predecessor_index += 1;- In
Debug.c:210:
static const DebugFreedEntry *debug_freed_find(const DebugAllocator *dbg, void *ptr) {
for (u32 i = 0; i < VecLen(&dbg->freed); i++) {
if (VecPtrAt(&dbg->freed, i)->ptr == ptr)
return VecPtrAt(&dbg->freed, i);- In
Debug.c:526:
if (!self)
return 0;
return VecLen(&self->freed);
}- In
Dir.c:545:
size path_len = ZstrLen(path);
bool trail_sep = (path_len > 0 && path[path_len - 1] == '/');
for (size i = 0; i < VecLen(&dc); ++i) {
DirEntry *e = VecPtrAt(&dc, i);
Zstr entry_nm = StrBegin(&e->name);
static ResolverCacheEntry *resolver_cache_find_or_open(SymbolResolver *self, Zstr path) {
for (u64 i = 0; i < VecLen(&self->cache); ++i) {
ResolverCacheEntry *e = VecPtrAt(&self->cache, i);
if (e->path == path) { return NULL;
}
return VecPtrAt(&self->cache, VecLen(&self->cache) - 1);
} if (!self)
return;
for (u64 i = 0; i < VecLen(&self->cache); ++i) {
ResolverCacheEntry *e = VecPtrAt(&self->cache, i);
#if FEATURE_PARSER_DWARF static const ElfSymbol *resolver_search_symbols(const Elf *elf, const ElfSymbols *syms, u64 vaddr) {
const ElfSymbol *best = NULL;
for (u64 i = 0; i < VecLen(syms); ++i) {
const ElfSymbol *s = VecPtrAt(syms, i);
// Consider only real address symbols. Like llvm-symbolizer, keep
- In
PdbCache.c:94:
// Find an existing entry for `module_path` or create a fresh one.
static PdbCacheEntry *cache_find_or_open(PdbCache *self, Zstr module_path) {
for (size i = 0; i < VecLen(&self->entries); ++i) {
PdbCacheEntry *e = VecPtrAt(&self->entries, i);
if (StrBegin(&e->module_path) && ZstrCompare(StrBegin(&e->module_path), module_path) == 0) {- In
PdbCache.c:111:
return NULL;
}
return VecPtrAt(&self->entries, VecLen(&self->entries) - 1);
}- In
PdbCache.c:121:
if (!self)
return;
for (size i = 0; i < VecLen(&self->entries); ++i) {
PdbCacheEntry *e = VecPtrAt(&self->entries, i);
if (e->pdb_open)- In
Dns.c:530:
u8 resp_buf[1232]; // safe UDP payload (avoids IP fragmentation)
i64 got = udp_round_trip(ns, VecBegin(&query), VecLen(&query), resp_buf, sizeof(resp_buf), self->timeout_ms);
VecDeinit(&query);
if (got <= 0) {- In
Dns.c:595:
// 2. Nameserver query path.
if (VecLen(&self->nameservers) == 0) {
LOG_ERROR("DnsResolve: no nameservers configured (read /etc/resolv.conf at init)");
break;- In
Dns.c:710:
DnsAddrs addrs = VecInitT(addrs, self->allocator);
bool ok = dns_resolve_4_vec_zstr(self, spec, kind, &addrs);
bool have_one = ok && VecLen(&addrs) > 0;
if (have_one) {
*out = VecAt(&addrs, 0);- In
Backtrace.c:274:
if (!out || !frames)
return;
format_walk_win(out, VecBegin(frames), VecLen(frames), alloc);
}- In
Backtrace.c:436:
if (!out || !frames || !alloc)
return;
format_walk_mac(out, VecBegin(frames), VecLen(frames), alloc);
}- In
Backtrace.c:514:
if (!out || !frames || !resolver)
return;
format_walk_with(out, VecBegin(frames), VecLen(frames), resolver);
}- In
Backtrace.c:526:
if (!out || !frames || !alloc)
return;
format_walk_alloc(out, VecBegin(frames), VecLen(frames), alloc);
}- In
MachoCache.c:40:
static MachoCacheEntry *cache_find_or_create(MachoCache *self, Zstr module_path) {
for (size i = 0; i < VecLen(&self->entries); ++i) {
MachoCacheEntry *e = VecPtrAt(&self->entries, i);
if (StrBegin(&e->module_path) && ZstrCompare(StrBegin(&e->module_path), module_path) == 0) {- In
MachoCache.c:57:
return NULL;
}
return VecPtrAt(&self->entries, VecLen(&self->entries) - 1);
}- In
MachoCache.c:133:
if (!self)
return;
for (size i = 0; i < VecLen(&self->entries); ++i) {
MachoCacheEntry *e = VecPtrAt(&self->entries, i);
if (e->fns_built && e->fns_ok)- In
Pe.c:580:
if (!self || !name)
return NULL;
for (size i = 0; i < VecLen(&self->sections); ++i) {
const PeSection *s = VecPtrAt(&self->sections, i);
if (ZstrCompare(s->name, name) == 0) {- In
Pe.c:598:
if (!self || !out_offset)
return false;
for (size i = 0; i < VecLen(&self->sections); ++i) {
const PeSection *s = VecPtrAt(&self->sections, i);
// Compute the section end in u64; u32 + u32 can wrap.
- In
DwarfInfo.c:98:
static void abbrev_table_deinit(AbbrevTable *t) {
for (size i = 0; i < VecLen(t); ++i) {
VecDeinit(&VecPtrAt(t, i)->attrs);
}- In
DwarfInfo.c:160:
static const AbbrevEntry *abbrev_table_find(const AbbrevTable *t, u64 code) {
for (size i = 0; i < VecLen(t); ++i) {
if (VecPtrAt(t, i)->code == code)
return VecPtrAt(t, i);- In
DwarfInfo.c:378:
bool name_from_strp = false;
for (size ai = 0; ai < VecLen(&e->attrs); ++ai) {
const AbbrevAttr *a = VecPtrAt(&e->attrs, ai);
AttrVal v;- In
DwarfInfo.c:609:
// Resolve name_offset_in_pool into char* now that string_pool
// has stopped growing.
for (size i = 0; i < VecLen(&pending); ++i) {
const PendingFn *pf = VecPtrAt(&pending, i);
DwarfFunction f = {- In
DwarfInfo.c:622:
}
// Sort by low_pc to enable binary-search lookup.
if (ok && VecLen(&out->entries) > 1) {
VecSort(&out->entries, cmp_dwarf_function);
}- In
DwarfInfo.c:659:
const DwarfFunction *DwarfFunctionsResolve(const DwarfFunctions *self, u64 vaddr) {
if (!self || VecLen(&self->entries) == 0)
return NULL;
// Binary-search for the largest low_pc <= vaddr.
- In
DwarfInfo.c:662:
return NULL;
// Binary-search for the largest low_pc <= vaddr.
size lo = 0, hi = VecLen(&self->entries);
while (lo < hi) {
size mid = lo + (hi - lo) / 2;- In
Pdb.c:653:
}
if (VecLen(&pending) == 0) {
VecDeinit(&pending);
return true;- In
Pdb.c:664:
// (now-stable) pool buffer, push into self->functions, and fill
// sizes by next-rva diff.
for (size i = 0; i < VecLen(&pending); ++i) {
const PendingPub *pp = VecPtrAt(&pending, i);
PdbFunction f = {- In
Pdb.c:671:
.name = StrBegin(&self->name_pool) + pp->name_offset_in_pool,
};
if (i + 1 < VecLen(&pending)) {
// Although `pending` is sorted ascending by rva, treat the
// u32 subtraction defensively in case a future sort
- In
Pdb.c:778:
const PdbFunction *PdbResolveRva(const Pdb *self, u32 rva) {
if (!self || VecLen(&self->functions) == 0)
return NULL;
// Binary search for the largest rva <= input.
- In
Pdb.c:781:
return NULL;
// Binary search for the largest rva <= input.
size lo = 0, hi = VecLen(&self->functions);
while (lo < hi) {
size mid = lo + (hi - lo) / 2;- In
ProcMaps.c:195:
// Cache the lowest mapped address so callers don't rescan the vector.
for (u64 i = 0; i < VecLen(&out->entries); ++i) {
const ProcMapEntry *e = VecPtrAt(&out->entries, i);
if (i == 0 || e->start < out->min_addr)- In
ProcMaps.c:305:
if (!self)
return NULL;
for (u64 i = 0; i < VecLen(&self->entries); ++i) {
const ProcMapEntry *e = VecPtrAt(&self->entries, i);
if (addr >= e->start && addr < e->end) {- In
Http.c:154:
}
if (VecLen(&req->headers) >= HTTP_REQUEST_HEADERS_MAX) {
LOG_ERROR("http request header count exceeds {} cap", HTTP_REQUEST_HEADERS_MAX);
return in; if (!self)
return NULL;
for (u64 i = 0; i < VecLen(&self->cies); ++i) {
if (VecPtrAt(&self->cies, i)->offset == cie_offset) {
return VecPtrAt(&self->cies, i); return NULL;
// Linear scan -- fine up to a few thousand FDEs.
for (u64 i = 0; i < VecLen(&self->fdes); ++i) {
const DwarfFde *f = VecPtrAt(&self->fdes, i);
if (vaddr >= f->pc_begin && vaddr < f->pc_begin + f->pc_range) {- In
MachO.c:487:
if (!self || !segment || !section)
return NULL;
for (size i = 0; i < VecLen(&self->sections); ++i) {
const MachoSection *s = VecPtrAt(&self->sections, i);
if (ZstrCompare(s->segment, segment) == 0 && ZstrCompare(s->section, section) == 0) {- In
MachO.c:501:
// stab iff any of the high three bits of n_type is set.
const MachoSymbol *MachoResolveAddress(const Macho *self, u64 vaddr) {
if (!self || VecLen(&self->symbols) == 0)
return NULL;
enum {- In
MachO.c:512:
u64 next_value = (u64)-1;
for (size i = 0; i < VecLen(&self->symbols); ++i) {
const MachoSymbol *s = VecPtrAt(&self->symbols, i);
if (s->type & N_STAB_MASK)- In
Elf.c:317:
// associated string table.
u32 strtab_idx = symtab->link;
if (strtab_idx >= VecLen(&self->sections)) {
LOG_ERROR("Elf: symtab link {} out of range", (u32)strtab_idx);
return false;- In
Elf.c:368:
const ElfSection *dynsymtab = NULL;
for (u64 i = 0; i < VecLen(&self->sections); ++i) {
const ElfSection *s = VecPtrAt(&self->sections, i);
if (s->type == ELF_SECTION_TYPE_SYMTAB) {- In
Elf.c:555:
static const ElfSymbol *elf_search_symbols(const ElfSymbols *syms, u64 vaddr) {
const ElfSymbol *best = NULL;
for (u64 i = 0; i < VecLen(syms); ++i) {
const ElfSymbol *s = VecPtrAt(syms, i);
if (s->size == 0) {- In
Elf.c:588:
if (!self || !name)
return NULL;
for (u64 i = 0; i < VecLen(&self->sections); ++i) {
const ElfSection *s = VecPtrAt(&self->sections, i);
if (s->name && ZstrCompare(s->name, name) == 0) {- In
Dwarf.c:314:
u64 file_off = 0;
u64 dir_off = 0;
if (st->file >= 1 && st->file - 1 < VecLen(&cs->file_offsets)) {
file_off = VecAt(&cs->file_offsets, st->file - 1);
u64 dir_idx = VecAt(&cs->file_dir_idx, st->file - 1);- In
Dwarf.c:317:
file_off = VecAt(&cs->file_offsets, st->file - 1);
u64 dir_idx = VecAt(&cs->file_dir_idx, st->file - 1);
if (dir_idx >= 1 && dir_idx - 1 < VecLen(&cs->dir_offsets)) {
dir_off = VecAt(&cs->dir_offsets, dir_idx - 1);
}- In
Dwarf.c:640:
// Resolve offsets -> pointers now that string_pool won't grow.
if (ok) {
for (u64 i = 0; i < VecLen(&out->entries); ++i) {
u64 fo = VecAt(&pending_file_offsets, i);
u64 dofs = VecAt(&pending_dir_offsets, i);- In
Dwarf.c:671:
const DwarfLineEntry *DwarfLinesResolve(const DwarfLines *self, u64 vaddr) {
if (!self || VecLen(&self->entries) == 0)
return NULL;- In
Dwarf.c:680:
const DwarfLineEntry *best = NULL;
const DwarfLineEntry *seq_open = NULL;
for (u64 i = 0; i < VecLen(&self->entries); ++i) {
const DwarfLineEntry *e = VecPtrAt(&self->entries, i);
if (e->end_sequence) {- In
Init.c:30:
GraphNodeId second_id = GraphAddNodeR(&graph, 20);
GraphNodeId third_id = GraphAddNodeR(&graph, 30);
u64 slot_count = VecLen(&graph.slots);
size slot_capacity = VecCapacity(&graph.slots);
u32 first_generation = GraphNodeIdGeneration(first_id);- In
Init.c:54:
// on the graph's private bookkeeping after GraphClear, which the public
// surface does not expose.
result = result && VecLen(&graph.slots) == slot_count && VecLen(&graph.free_indices) == slot_count;
result = result && VecCapacity(&graph.slots) == slot_capacity && VecCapacity(&graph.free_indices) >= slot_count;
result = result && graph.pending_delete_count == 0 && VecLen(&graph.pending_edge_removals) == 0;- In
Init.c:56:
result = result && VecLen(&graph.slots) == slot_count && VecLen(&graph.free_indices) == slot_count;
result = result && VecCapacity(&graph.slots) == slot_capacity && VecCapacity(&graph.free_indices) >= slot_count;
result = result && graph.pending_delete_count == 0 && VecLen(&graph.pending_edge_removals) == 0;
for (slot_index = 0; slot_index < VecLen(&graph.slots); slot_index++) {- In
Init.c:58:
result = result && graph.pending_delete_count == 0 && VecLen(&graph.pending_edge_removals) == 0;
for (slot_index = 0; slot_index < VecLen(&graph.slots); slot_index++) {
// `graph.slots` is the typed `Vec(GraphSlot(int))`, so iterate via
// the runtime-shared layout to avoid an anonymous-struct annotation.
- In
Init.c:65:
result = result && (slot->visit_count == 0);
result = result && (slot->flags == 0);
result = result && (VecLen(&slot->out_neighbors) == 0);
result = result && (VecLen(&slot->in_neighbors) == 0);
}- In
Init.c:66:
result = result && (slot->flags == 0);
result = result && (VecLen(&slot->out_neighbors) == 0);
result = result && (VecLen(&slot->in_neighbors) == 0);
}- In
Type.c:411:
GenericGraph *g = GENERIC_GRAPH(&graph);
// Point the free index exactly one past the last slot.
*VecPtrAt(&g->free_indices, 0) = (u32)VecLen(&g->slots);
MAGIC_MARK_DIRTY(g);- In
Type.c:443:
// free_indices now holds two freed indices; redirect the last to a
// (occupied) so only a loop that reaches the last entry catches it.
*VecPtrAt(&g->free_indices, VecLen(&g->free_indices) - 1) = GraphNodeIdIndex(a);
MAGIC_MARK_DIRTY(g);- In
Ops.c:90:
// Check that the elements are reversed
bool result = true;
for (size i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == values[4 - i]);
}- In
Ops.c:98:
// Check that the elements are back in the original order
for (size i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == values[i]);
}- In
Ops.c:113:
// Check that the elements are reversed
for (size i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == even_values[3 - i]);
}- In
Ops.c:143:
bool result = true;
int sorted_asc[] = {10, 20, 30, 40, 50};
for (size i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == sorted_asc[i]);
}- In
Ops.c:152:
// Check that the elements are sorted in descending order
int sorted_desc[] = {50, 40, 30, 20, 10};
for (size i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == sorted_desc[i]);
}- In
Complex.c:187:
// Check initial state
bool result =
(VecLen(&vec) == 0 && VecCapacity(&vec) == 0 && VecBegin(&vec) == NULL &&
VecCopyInit(&vec) == (GenericCopyInit)ComplexItemCopyInit &&
VecCopyDeinit(&vec) == (GenericCopyDeinit)ComplexItemDeinit);- In
Complex.c:199:
// Check that the vector now has one item
result = result && (VecLen(&vec) == 1);
// Check that the item was copied correctly
- In
Complex.c:243:
// Check vector length
bool result = (VecLen(&vec) == 3);
// Check items order: item2, item1, item3
- In
Complex.c:291:
// Check vector length
bool result = (VecLen(&vec) == 3);
// Check items order: item2, item3, item1
- In
Complex.c:334:
// Check vector lengths
bool result = (VecLen(&vec1) == 3);
result = result && (VecLen(&vec2) == 2); // VecMergeR doesn't modify source vector
- In
Complex.c:335:
// Check vector lengths
bool result = (VecLen(&vec1) == 3);
result = result && (VecLen(&vec2) == 2); // VecMergeR doesn't modify source vector
// Check items in vec1: item1, item2, item3
- In
Complex.c:365:
// Check vector lengths
result = result && (VecLen(&vec3) == 2);
result = result && (VecLen(&vec4) == 0); // VecMergeL resets source vector
result = result && (VecBegin(&vec4) == NULL);- In
Complex.c:366:
// Check vector lengths
result = result && (VecLen(&vec3) == 2);
result = result && (VecLen(&vec4) == 0); // VecMergeL resets source vector
result = result && (VecBegin(&vec4) == NULL);- In
Complex.c:406:
// Check vector length
bool result = (VecLen(&vec) == 3);
// Check items order: val2, val3, val1
- In
Complex.c:420:
// Check vector length
result = result && (VecLen(&vec) == 6);
// Check items: val2, val3, val1, arr[0], arr[1], arr[2]
- In
Complex.c:452:
// Check vector length
bool result = (VecLen(&vec) == 6);
// Check that the element was inserted
- In
Complex.c:463:
// Check vector length
result = result && (VecLen(&vec) == 9);
// Check that the array was inserted
- In
Complex.c:482:
// Ensure we have enough capacity to avoid reallocation during the test
VecReserve(&vec2, VecLen(&vec2) + 10);
// Try inserting just one element first with fast insert
- In
Complex.c:488:
VecInsertFastR(&vec2, single_val, 2);
result = result && (VecLen(&vec2) == 6);
result = result && (VecAt(&vec2, 2) == 42);- In
Complex.c:498:
// Check vector length
result = result && (VecLen(&vec2) == 8);
// Check that the array was inserted
- In
Complex.c:526:
// Check vector length after deletion
bool result = (VecLen(&vec) == 8);
// Check that the element was deleted and elements shifted
- In
Complex.c:537:
// Check vector length after range deletion
result = result && (VecLen(&vec) == 6);
// Check that elements were deleted and remaining elements shifted
- In
Complex.c:557:
// Check vector length after fast deletion
result = result && (VecLen(&vec) == 8);
// Check that the element was deleted and replaced with the last element (90)
- In
Complex.c:569:
// Check vector length after fast range deletion
result = result && (VecLen(&vec) == 6);
// Check that elements were deleted and replaced with elements from the end
- In
Complex.c:590:
// Check vector length after deletion
result = result && (VecLen(&vec) == 8);
// Check that the element was deleted
- In
Complex.c:611:
// Test pushing to empty vector
VecPushBackR(&vec, 10);
bool result = (VecLen(&vec) == 1 && VecAt(&vec, 0) == 10);
// Test pushing with zero count
- In
Complex.c:617:
int small_arr[1] = {42};
VecPushBackArrR(&vec, small_arr, 0);
result = result && (VecLen(&vec) == 1); // Length should not change
// Test inserting at end index
- In
Complex.c:620:
// Test inserting at end index
VecInsertR(&vec, 20, VecLen(&vec));
result = result && (VecLen(&vec) == 2 && VecAt(&vec, 1) == 20);- In
Complex.c:621:
// Test inserting at end index
VecInsertR(&vec, 20, VecLen(&vec));
result = result && (VecLen(&vec) == 2 && VecAt(&vec, 1) == 20);
// Test with large number of elements
- In
Complex.c:633:
}
result = result && (VecLen(&vec) == large_count);
// Verify all elements
- In
Complex.c:655:
// Push an element (should auto-resize)
VecPushBackR(&vec, 42);
result = result && (VecLen(&vec) == 1 && VecAt(&vec, 0) == 42);
// Clean up
- In
Complex.c:774:
int values3[] = {70, 80, 90};
ComplexItem item3 = InitComplexItem("Fast Item 3", values3, 3);
VecInsertFastL(&vec, item3, VecLen(&vec));
// Check that the item was zeroed
- In
Complex.c:782:
// Verify vector integrity - should have 6 items now
result = result && (VecLen(&vec) == 6);
// Clean up the vector
- In
Complex.c:849:
// Check that vec2 is now empty (data has been transferred)
result = result && (VecLen(&vec2) == 0);
result = result && (VecBegin(&vec2) == NULL);- In
Complex.c:918:
// Under the mutant src->length != 0 returns true immediately and dst is
// left empty (length 0).
bool result = (VecLen(&dst) == 3) && (VecAt(&dst, 0) == 1) && (VecAt(&dst, 1) == 2) && (VecAt(&dst, 2) == 3);
VecDeinit(&src);- In
Complex.c:944:
// Real: dst has all 3 elements starting at index 0. Mutant (init 42):
// 42 < 3 is false, loop skipped, dst length 0.
bool result = (VecLen(&dst) == 3) && (VecAt(&dst, 0) == 1);
VecDeinit(&src);- In
Complex.c:969:
// Mutant (i >= length): 0 >= 3 is false, loop never runs, dst empty.
bool result = (VecLen(&dst) == 3);
VecDeinit(&src);- In
Complex.c:994:
// Real: dst length 3, all values present. Mutant (i--): dst length 1.
bool result = (VecLen(&dst) == 3) && (VecAt(&dst, 0) == 1) && (VecAt(&dst, 1) == 2) && (VecAt(&dst, 2) == 3);
VecDeinit(&src);- In
Complex.c:1020:
// Real: cloned true, dst length 3. Mutant: insert expression is 0 so the
// clone returns false with dst empty.
bool result = cloned && (VecLen(&dst) == 3);
VecDeinit(&src);- In
Memory.c:106:
// Capacity should now be closer to the actual length
result = result && (VecCapacity(&vec) < 100) && (VecCapacity(&vec) >= VecLen(&vec));
// Check that the data is still intact
- In
Memory.c:109:
// Check that the data is still intact
for (size i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == values[i]);
}- In
Memory.c:137:
// Initial length should be 5
bool result = (VecLen(&vec) == 5);
// Resize to a smaller length
- In
Memory.c:143:
// Length should now be 3
result = result && (VecLen(&vec) == 3);
// First 3 elements should be unchanged
- In
Memory.c:154:
// Length should now be 8
result = result && (VecLen(&vec) == 8);
// First 3 elements should still be the same
- In
Memory.c:188:
// Length should still be 0
result = result && (VecLen(&vec) == 0);
// Add some data
- In
Memory.c:200:
// Length should now be 5
result = result && (VecLen(&vec) == 5);
// Reserve less space (should be a no-op)
- In
Memory.c:232:
// Initial length should be 5
bool result = (VecLen(&vec) == 5);
// Remember the capacity
- In
Memory.c:241:
// Length should now be 0
result = result && (VecLen(&vec) == 0);
// Capacity should remain the same
- In
Memory.c:275:
bool ok = VecResize(&vec, 100);
bool result = ok && (VecLen(&vec) == 100) && (VecCapacity(&vec) >= 100);
VecDeinit(&vec);- In
Memory.c:298:
VecResize(&vec, 1);
bool result = (VecLen(&vec) == 1) && (g_deinit_count == 3);
VecDeinit(&vec);- In
Memory.c:341:
VecResize(&vec, 50);
bool result = (VecLen(&vec) == 50);
VecDeinit(&vec);- In
Memory.c:358:
VecResize(&vec, 10);
bool result = (VecLen(&vec) == 10) && (VecCapacity(&vec) == 16);
VecDeinit(&vec);- In
Memory.c:389:
// Live data in [0,8); resize re-zeroes only the sentinel slot.
VecResize(&vec, 8);
for (u64 i = 0; i < VecLen(&vec); i++) {
VecAt(&vec, i) = 0x11111111;
}- In
Memory.c:433:
bool ok = VecReserve(&vec, (size)-1 - 1);
bool result = (ok == false) && (VecLen(&vec) == 0);
VecDeinit(&vec);- In
Memory.c:500:
VecClear(&vec);
bool result = (VecLen(&vec) == 0);
VecDeinit(&vec);- In
Memory.c:526:
VecClear(&vec);
bool result = (g_deinit_calls == 3) && (VecLen(&vec) == 0);
// Drop the hook so the final teardown does not re-run the counter.
- In
Memory.c:563:
// Real: every element survives the shrink.
bool result = (VecLen(&vec) == N);
for (u32 i = 0; i < N; i++) {
result = result && (VecAt(&vec, i).tag == 100 + i);- In
Memory.c:591:
// Real: length stays 5.
bool result = (VecLen(&vec) == 5);
VecDeinit(&vec);- In
Memory.c:633:
// Real: length 0.
bool result = (VecLen(&vec) == 0);
VecDeinit(&vec);- In
Init.c:65:
// Check initial state
bool result =
(VecLen(&vec) == 0 && VecCapacity(&vec) == 0 && VecBegin(&vec) == NULL && VecAllocator(&vec)->alignment == 1 &&
VecCopyInit(&vec) == NULL && VecCopyDeinit(&vec) == NULL);- In
Init.c:76:
// Check initial state
result = result && (VecLen(&test_vec) == 0 && VecCapacity(&test_vec) == 0 && VecBegin(&test_vec) == NULL &&
VecAllocator(&test_vec)->alignment == 1 && VecCopyInit(&test_vec) == NULL &&
VecCopyDeinit(&test_vec) == NULL);- In
Init.c:99:
// Check initial state
bool result =
(VecLen(&vec) == 0 && VecCapacity(&vec) == 0 && VecBegin(&vec) == NULL && VecAllocator(&vec)->alignment == 4 &&
VecCopyInit(&vec) == NULL && VecCopyDeinit(&vec) == NULL);- In
Init.c:110:
// Check initial state
result = result && (VecLen(&test_vec) == 0 && VecCapacity(&test_vec) == 0 && VecBegin(&test_vec) == NULL &&
VecAllocator(&test_vec)->alignment == 16 && VecCopyInit(&test_vec) == NULL &&
VecCopyDeinit(&test_vec) == NULL);- In
Init.c:132:
// Check initial state
bool result =
(VecLen(&vec) == 0 && VecCapacity(&vec) == 0 && VecBegin(&vec) == NULL && VecAllocator(&vec)->alignment == 1 &&
VecCopyInit(&vec) == (GenericCopyInit)TestItemCopyInit &&
VecCopyDeinit(&vec) == (GenericCopyDeinit)TestItemDeinit);- In
Init.c:154:
// Check initial state
bool result =
(VecLen(&vec) == 0 && VecCapacity(&vec) == 0 && VecBegin(&vec) == NULL && VecAllocator(&vec)->alignment == 8 &&
VecCopyInit(&vec) == (GenericCopyInit)TestItemCopyInit &&
VecCopyDeinit(&vec) == (GenericCopyDeinit)TestItemDeinit);- In
Init.c:231:
VecInitStack(int, vec, 10) {
// Stack-init: NULL allocator distinguishes from heap-init.
if (VecLen(&vec) != 0 || VecCapacity(&vec) != 10 || VecBegin(&vec) == NULL || VecAllocator(&vec) != NULL) {
result = false;
}- In
Init.c:239:
VecPushBackR(&vec, 30);
if (VecLen(&vec) != 3 || VecAt(&vec, 0) != 10 || VecAt(&vec, 1) != 20 || VecAt(&vec, 2) != 30) {
result = false;
}- In
Init.c:246:
// Test with struct type
VecInitStack(TestItem, test_vec, 5) {
if (VecLen(&test_vec) != 0 || VecCapacity(&test_vec) != 5 || VecBegin(&test_vec) == NULL ||
VecAllocator(&test_vec) != NULL) {
result = false;- In
Init.c:256:
VecPushBackR(&test_vec, item);
if (VecLen(&test_vec) != 1 || VecAt(&test_vec, 0).id != 1 || VecAt(&test_vec, 0).value != 3.14f) {
result = false;
}- In
Init.c:274:
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:283:
VecInitStack(int, breakable, 8) {
VecPushBackR(&breakable, 1);
if (VecLen(&breakable) != 1) {
result = false;
}- In
Init.c:309:
// Clone the source vector into the destination
VecPushBackArrR(&clone, VecBegin(&src), VecLen(&src));
// Check that the clone has the same data but different memory
- In
Init.c:313:
// Check that the clone has the same data but different memory
bool result =
(VecLen(&clone) == VecLen(&src) && VecCapacity(&clone) >= VecLen(&src) && VecBegin(&clone) != VecBegin(&src) &&
VecAllocator(&clone)->alignment == VecAllocator(&src)->alignment);- In
Init.c:318:
// Check the actual data
if (result) {
for (size i = 0; i < VecLen(&src); i++) {
if (VecAt(&clone, i) != VecAt(&src, i)) {
result = false;- In
Insert.c:93:
// Check length
bool result = (VecLen(&vec) == 5);
// Check elements in order
- In
Insert.c:96:
// Check elements in order
for (size i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == values[i]);
}- In
Insert.c:121:
// Check length
bool result = (VecLen(&vec) == 5);
// Check elements in reverse order (since we pushed to front)
- In
Insert.c:124:
// Check elements in reverse order (since we pushed to front)
for (size i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == values[4 - i]);
}- In
Insert.c:146:
// Check first element
bool result = (VecLen(&vec) == 1 && VecAt(&vec, 0) == 10);
// Insert at the end
- In
Insert.c:152:
// Check elements
result = result && (VecLen(&vec) == 2 && VecAt(&vec, 0) == 10 && VecAt(&vec, 1) == 30);
// Insert in the middle
- In
Insert.c:158:
// Check all elements
result = result && (VecLen(&vec) == 3);
result = result && (VecAt(&vec, 0) == 10);
result = result && (VecAt(&vec, 1) == 20);- In
Insert.c:182:
// Check length
bool result = (VecLen(&vec) == 5);
// Check elements in order
- In
Insert.c:185:
// Check elements in order
for (size i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == values[i]);
}- In
Insert.c:194:
// Check length
result = result && (VecLen(&vec) == 8);
// Check all elements
- In
Insert.c:223:
// Check length
bool result = (VecLen(&vec) == 5);
// Check elements in order
- In
Insert.c:226:
// Check elements in order
for (size i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == values[i]);
}- In
Insert.c:235:
// Check length
result = result && (VecLen(&vec) == 8);
// Check all elements
- In
Insert.c:268:
// Check length
bool result = (VecLen(&vec) == 5);
// Expected result: [10, 30, 40, 50, 20]
- In
Insert.c:274:
// Check all elements
for (size i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == expected[i]);
}- In
Insert.c:302:
// Insert range in the middle
VecInsertRangeR(&vec, VecBegin(&src), 1, VecLen(&src));
// Check length
- In
Insert.c:305:
// Check length
bool result = (VecLen(&vec) == 6);
// Expected result: [10, 40, 50, 60, 20, 30]
- In
Insert.c:311:
// Check all elements
for (size i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == expected[i]);
}- In
Insert.c:345:
// Check lengths
bool result = (VecLen(&vec1) == 6);
result = result && (VecLen(&vec2) == 3); // VecMergeR doesn't modify source vector
- In
Insert.c:346:
// Check lengths
bool result = (VecLen(&vec1) == 6);
result = result && (VecLen(&vec2) == 3); // VecMergeR doesn't modify source vector
// Expected result in vec1: [10, 20, 30, 40, 50, 60]
- In
Insert.c:352:
// Check all elements in vec1
for (size i = 0; i < VecLen(&vec1); i++) {
result = result && (VecAt(&vec1, i) == expected[i]);
}- In
Insert.c:392:
dst.copy_init = src.copy_init;
dst.copy_deinit = src.copy_deinit;
bool cloned = VecPushBackArrR(&dst, VecBegin(&src), VecLen(&src));
bool allocator_matches = VecAllocator(&dst) == VecAllocator(&src);- In
Insert.c:398:
bool result = cloned && VecCopyInit(&dst) == VecCopyInit(&src) && VecCopyDeinit(&dst) == VecCopyDeinit(&src) &&
VecAllocator(&dst)->effort == ALLOCATOR_EFFORT_RETRY_FALLBACK &&
VecAllocator(&dst)->retry_limit == 11 && allocator_matches && VecLen(&src) == 3 &&
VecAt(&src, 0) == 10 && VecAt(&src, 1) == 20 && VecAt(&src, 2) == 30 && VecLen(&dst) == 3 &&
VecAt(&dst, 0) == 10 && VecAt(&dst, 1) == 20 && VecAt(&dst, 2) == 30;- In
Insert.c:399:
VecAllocator(&dst)->effort == ALLOCATOR_EFFORT_RETRY_FALLBACK &&
VecAllocator(&dst)->retry_limit == 11 && allocator_matches && VecLen(&src) == 3 &&
VecAt(&src, 0) == 10 && VecAt(&src, 1) == 20 && VecAt(&src, 2) == 30 && VecLen(&dst) == 3 &&
VecAt(&dst, 0) == 10 && VecAt(&dst, 1) == 20 && VecAt(&dst, 2) == 30;- In
Insert.c:420:
// Check that the element was added
bool result = (VecLen(&vec) == 1 && VecAt(&vec, 0) == 42);
// Test L-value insert operations
- In
Insert.c:427:
// Check that the element was added
result = result && (VecLen(&vec) == 2 && VecAt(&vec, 1) == 100);
// Test R-value insert at index
- In
Insert.c:433:
// Check that the element was inserted
result = result && (VecLen(&vec) == 3);
result = result && (VecAt(&vec, 0) == 42);
result = result && (VecAt(&vec, 1) == 50);- In
Insert.c:443:
// Check that the element was inserted
result = result && (VecLen(&vec) == 4);
result = result && (VecAt(&vec, 0) == 42);
result = result && (VecAt(&vec, 1) == 50);- In
Insert.c:453:
// Check that the element was inserted
result = result && (VecLen(&vec) == 5);
result = result && (VecAt(&vec, 1) == 60);- In
Insert.c:461:
// Check that the element was inserted
result = result && (VecLen(&vec) == 6);
result = result && (VecAt(&vec, 3) == 80);- In
Insert.c:471:
// Check that the elements were added
result = result && (VecLen(&vec) == 9);
result = result && (VecAt(&vec, 6) == 200);
result = result && (VecAt(&vec, 7) == 300);- In
Insert.c:480:
// Check that the elements were added
result = result && (VecLen(&vec) == 12);
result = result && (VecAt(&vec, 0) == 200);
result = result && (VecAt(&vec, 1) == 300);- In
Insert.c:557:
// Check that the source vector is cleared
result = result && (VecLen(&vec2) == 0);
result = result && (VecBegin(&vec2) == NULL);- In
Insert.c:590:
bool result = VecInsertRangeFastR(&vec, new_items, idx, new_count);
result = result && (VecLen(&vec) == orig_count + new_count);
for (size i = 0; i < idx; i++) {- In
Insert.c:603:
// [idx + new_count, new length). Order is intentionally unspecified.
size tail_start = idx + new_count;
size tail_end = VecLen(&vec);
result = result && (tail_end - tail_start == orig_count - idx);
for (size i = idx; i < orig_count; i++) {- In
Insert.c:718:
bool ok = VecInsertRangeFastR(&vec, src, 0, (size)-1);
bool result = (ok == false) && (VecLen(&vec) == 0);
VecDeinit(&vec);- In
Insert.c:741:
int add[8] = {100, 101, 102, 103, 104, 105, 106, 107};
bool ok = VecInsertRangeFastR(&vec, add, VecLen(&vec), 8);
// Capacity contract: holding 16 live elements requires the grow to have
- In
Insert.c:746:
// run, so capacity must have expanded past the old value of 8. The mutant
// skips the grow and leaves capacity == 8.
bool result = ok && (VecLen(&vec) == 16) && (VecCapacity(&vec) >= 16);
for (int i = 0; i < 8; i++) {
result = result && (VecAt(&vec, (size)i) == i);- In
Insert.c:754:
for (int v = 100; v < 108; v++) {
bool found = false;
for (size j = 8; j < VecLen(&vec); j++) {
if (VecAt(&vec, j) == v) {
found = true;- In
Insert.c:789:
// length 5 + count 5 == capacity 10: the equality boundary.
int add[5] = {100, 101, 102, 103, 104};
bool ok = VecInsertRangeFastR(&vec, add, VecLen(&vec), 5);
// Real code reserves past the old capacity (10 -> 16). The `>` mutant skips
- In
Insert.c:793:
// Real code reserves past the old capacity (10 -> 16). The `>` mutant skips
// the grow and leaves capacity at 10.
bool result = ok && (VecLen(&vec) == 10) && (VecCapacity(&vec) > 10);
for (int i = 0; i < 5; i++) {
result = result && (VecAt(&vec, (size)i) == i);- In
Insert.c:816:
// Holding 8 elements requires growth from capacity 0; the mutant's
// inverted predicate skips it.
bool result = ok && (VecLen(&vec) == 8) && (VecCapacity(&vec) >= 8);
for (size i = 0; i < 8; i++) {
result = result && (VecAt(&vec, i) == add[i]);- In
Insert.c:841:
// replacement makes the call return false. Either way the real growth
// contract (true return, all 10 elements, capacity >= 10) breaks.
bool result = ok && (VecLen(&vec) == 10) && (VecCapacity(&vec) >= 10);
for (size i = 0; i < 10; i++) {
result = result && (VecAt(&vec, i) == add[i]);- In
Insert.c:874:
bool ok = VecInsertRangeFastR(&vec, add, 1, 2);
bool result = ok && (VecLen(&vec) == 6);
// Prefix [0,1) intact, inserted block at [1,3).
result = result && (VecAt(&vec, 0).value == 10);- In
Insert.c:882:
for (int v = 11; v <= 12; v++) {
bool found = false;
for (size j = 3; j < VecLen(&vec); j++) {
if (VecAt(&vec, j).value == v) {
found = true;- In
Insert.c:892:
// Trailing original 13 (never displaced) also survives.
bool found13 = false;
for (size j = 3; j < VecLen(&vec); j++) {
if (VecAt(&vec, j).value == 13) {
found13 = true;- In
Insert.c:937:
bool ok = VecInsertRangeFastR(&vec, VecBegin(&ins), 0, N);
bool result = ok && (VecLen(&vec) == 2 * N);
// The new block occupies the front [0, N).
result = result && (VecAt(&vec, 0).value == 1000000);- In
Insert.c:966:
bool ok = VecInsertRangeFastR(&vec, add, 2, 2);
bool result = ok && (VecLen(&vec) == 6);
// Prefix [0,2) must be the original 10,11.
result = result && (VecAt(&vec, 0).value == 10);- In
Insert.c:996:
bool ok = VecInsertRangeFastR(&vec, add, 2, 2);
bool result = ok && (VecLen(&vec) == 6);
result = result && (VecAt(&vec, 2).value == 100);
result = result && (VecAt(&vec, 3).value == 200);- In
Insert.c:1027:
bool ok = VecInsertRangeFastR(&vec, add, 1, 3);
bool result = ok && (VecLen(&vec) == 5);
result = result && (VecAt(&vec, 1).value == 100);
result = result && (VecAt(&vec, 2).value == 200);- In
Insert.c:1055:
bool ok = VecInsertRangeFastR(&vec, add, 2, 3);
bool result = (ok == false) && (g_deinit_count == 0) && (VecLen(&vec) == 4);
// Originals fully intact after rollback.
result = result && (VecAt(&vec, 0).value == 10);- In
Insert.c:1253:
bool ok = VecInsertRangeFastR(&vec, add, 1, 2);
bool result = (ok == false) && (VecLen(&vec) == 5);
// Original elements must all be present and unchanged after rollback.
for (size i = 0; i < 5; i++) {- In
Insert.c:1282:
bool ok = VecInsertRangeFastR(&vec, add, 1, 2);
bool result = (ok == false) && (VecLen(&vec) == 5);
for (size i = 0; i < 5; i++) {
result = result && (VecAt(&vec, i).value == 20 + (int)i);- In
Insert.c:1314:
bool ok = VecInsertRangeFastR(&vec, add, 1, 3);
bool result = (ok == false) && (VecLen(&vec) == 6);
for (size i = 0; i < 6; i++) {
result = result && (VecAt(&vec, i).value == 30 + (int)i);- In
Insert.c:1407:
for (size i = 0; i < n; i++) {
TrackItem it = {tags[i], NULL};
VecInsertRangeR(&v, &it, VecLen(&v), 1);
}
return v;- In
Insert.c:1421:
bool ret = VecInsertRangeR(&vec, &one, 0, (size)-1);
bool result = (ret == false) && (VecLen(&vec) == 0);
VecDeinit(&vec);- In
Insert.c:1439:
bool ret = VecInsertRangeR(&vec, &newv, 0, 1);
bool result = ret && (VecLen(&vec) == 4) && (VecAt(&vec, 0) == 99) && (VecAt(&vec, 1) == 10) &&
(VecAt(&vec, 2) == 20) && (VecAt(&vec, 3) == 30);- In
Insert.c:1459:
// The original at index 0 (11) must survive at index 1 after the insert.
bool result = ret && (VecLen(&vec) == 4) && (VecAt(&vec, 0) == 77) && (VecAt(&vec, 1) == 11);
VecDeinit(&vec);- In
Insert.c:1476:
for (size i = 0; i < N; i++) {
u64 v = (u64)i;
VecInsertRangeR(&vec, &v, VecLen(&vec), 1);
}- In
Insert.c:1482:
bool ret = VecInsertRangeR(&vec, &newv, N - 1, 1); // insert just before the last element
bool result = ret && (VecLen(&vec) == N + 1) && (VecAt(&vec, 0) == 0) && (VecAt(&vec, N - 2) == (u64)(N - 2)) &&
(VecAt(&vec, N - 1) == 999999) && (VecAt(&vec, N) == (u64)(N - 1));- In
Insert.c:1503:
bool ret = VecInsertRangeR(&vec, &it, 0, 1);
bool result = (ret == false) && (ti_deinit_count == 0) && (VecLen(&vec) == 3);
VecDeinit(&vec);- In
Insert.c:1524:
{102, NULL}
};
bool ret = VecInsertRangeR(&vec, items, VecLen(&vec), 3);
bool result = (ret == false) && (ti_deinit_count == 2) && (VecLen(&vec) == 3);- In
Insert.c:1526:
bool ret = VecInsertRangeR(&vec, items, VecLen(&vec), 3);
bool result = (ret == false) && (ti_deinit_count == 2) && (VecLen(&vec) == 3);
VecDeinit(&vec);- In
Insert.c:1546:
{101, NULL}
};
bool ret = VecInsertRangeR(&vec, items, VecLen(&vec), 2);
bool result = (ret == false) && (ti_deinit_count == 1) && (VecLen(&vec) == 3);- In
Insert.c:1548:
bool ret = VecInsertRangeR(&vec, items, VecLen(&vec), 2);
bool result = (ret == false) && (ti_deinit_count == 1) && (VecLen(&vec) == 3);
VecDeinit(&vec);- In
Insert.c:1568:
{101, NULL}
};
bool ret = VecInsertRangeR(&vec, items, VecLen(&vec), 2);
bool result = (ret == false) && (ti_deinit_count == 1) && (g_deinit_saw_zero == false) && (VecLen(&vec) == 3);- In
Insert.c:1570:
bool ret = VecInsertRangeR(&vec, items, VecLen(&vec), 2);
bool result = (ret == false) && (ti_deinit_count == 1) && (g_deinit_saw_zero == false) && (VecLen(&vec) == 3);
VecDeinit(&vec);- In
Insert.c:1591:
{102, NULL}
};
bool ret = VecInsertRangeR(&vec, items, VecLen(&vec), 3);
bool result = (ret == false) && (ti_deinit_count == 2) && (VecLen(&vec) == 3);- In
Insert.c:1593:
bool ret = VecInsertRangeR(&vec, items, VecLen(&vec), 3);
bool result = (ret == false) && (ti_deinit_count == 2) && (VecLen(&vec) == 3);
VecDeinit(&vec);- In
Insert.c:1617:
bool result = (ret == false) && (ti_deinit_count == 2) && deinit_tags_contain(100) && deinit_tags_contain(101) &&
!deinit_tags_contain(1) && (VecLen(&vec) == 1) && (VecAt(&vec, 0).tag == 1);
VecDeinit(&vec);- In
Insert.c:1637:
{101, NULL}
};
bool ret = VecInsertRangeR(&vec, items, VecLen(&vec), 2);
bool result = (ret == false) && (ti_deinit_count == 1) && (VecLen(&vec) == 3);- In
Insert.c:1639:
bool ret = VecInsertRangeR(&vec, items, VecLen(&vec), 2);
bool result = (ret == false) && (ti_deinit_count == 1) && (VecLen(&vec) == 3);
VecDeinit(&vec);- In
Insert.c:1658:
bool ret = VecInsertRangeR(&vec, &it, 1, 1);
bool result = (ret == false) && (VecLen(&vec) == 3) && (VecAt(&vec, 0).tag == 1) && (VecAt(&vec, 1).tag == 2) &&
(VecAt(&vec, 2).tag == 3);- In
Insert.c:1677:
bool ret = VecInsertRangeR(&vec, &it, 1, 1);
bool result = (ret == false) && (VecLen(&vec) == 3) && (VecAt(&vec, 0).tag == 1) && (VecAt(&vec, 1).tag == 2) &&
(VecAt(&vec, 2).tag == 3);- In
Insert.c:1696:
for (size i = 0; i < N; i++) {
TrackItem it = {(int)(i + 1), NULL};
VecInsertRangeR(&vec, &it, VecLen(&vec), 1);
}- In
Insert.c:1704:
bool ret = VecInsertRangeR(&vec, &it, N - 1, 1);
bool result = (ret == false) && (VecLen(&vec) == N) && (VecAt(&vec, 0).tag == 1) &&
(VecAt(&vec, N - 2).tag == (int)(N - 1)) && (VecAt(&vec, N - 1).tag == (int)N);- In
Insert.c:1724:
bool ret = VecInsertRangeR(&vec, &it, 1, 1);
bool result = (ret == false) && (VecLen(&vec) == 3) && (VecAt(&vec, 0).tag == 1) && (VecAt(&vec, 1).tag == 2) &&
(VecAt(&vec, 2).tag == 3);- In
Insert.c:1748:
bool result =
ok && (VecLen(&vec) == 3) && (VecAt(&vec, 0) == 111u) && (VecAt(&vec, 1) == 222u) && (VecAt(&vec, 2) == 333u);
VecDeinit(&vec);- In
Insert.c:1770:
// check is valid here.
bool result =
ok && (VecLen(&vec) == 3) && (VecAt(&vec, 0) == 444u) && (VecAt(&vec, 1) == 555u) && (VecAt(&vec, 2) == 666u);
VecDeinit(&vec);- In
Insert.c:1789:
bool ok = VecInsertL(&vec, val, 0);
bool result = ok && (VecLen(&vec) == 1) && (VecAt(&vec, 0) == 777u);
VecDeinit(&vec);- In
Insert.c:1851:
// Real: the insert fails, ok == false, nothing landed in the vec.
bool result = (ok == false) && (VecLen(&vec) == 0);
VecDeinit(&vec);- In
Insert.c:1880:
// Real: the insert fails, ok == false, nothing landed in the vec.
bool result = (ok == false) && (VecLen(&vec) == 0);
VecDeinit(&vec);- In
Insert.c:1911:
}
size length_before = VecLen(&vec); // 4
// Middle insert at idx 1 of 2 elements; fail on the very first copy_init of
- In
Insert.c:1920:
bool ok = VecInsertRangeR(&vec, add, 1, 2);
bool result = (ok == false) && (VecLen(&vec) == length_before);
// Originals fully intact after rollback.
- In
Insert.c:1956:
}
size length_before = VecLen(&vec); // 4
// Front insert at idx 0 of 2 elements -> displaced = min(length-idx,count)
- In
Insert.c:1965:
bool ok = VecInsertRangeFastR(&vec, add, 0, 2);
bool result = (ok == false) && (VecLen(&vec) == length_before);
// Originals must all still be present (order may differ for the fast path,
- In
Insert.c:1970:
// but a front-insert with displaced==count restores them in place).
bool found100 = false, found101 = false, found102 = false, found103 = false;
for (size i = 0; i < VecLen(&vec); i++) {
u64 v = (u64)VecAt(&vec, i).value;
found100 = found100 || (v == 100);- In
Type.c:31:
// Check initial state
bool result =
(VecLen(&vec) == 0 && VecCapacity(&vec) == 0 && VecBegin(&vec) == NULL && VecAllocator(&vec)->alignment == 1 &&
VecCopyInit(&vec) == NULL && VecCopyDeinit(&vec) == NULL);- In
Type.c:42:
// Check initial state
result = result && (VecLen(&test_vec) == 0 && VecCapacity(&test_vec) == 0 && VecBegin(&test_vec) == NULL &&
VecAllocator(&test_vec)->alignment == 1 && VecCopyInit(&test_vec) == NULL &&
VecCopyDeinit(&test_vec) == NULL);- In
Remove.c:132:
// Initial length should be 5
bool result = (VecLen(&vec) == 5);
// Pop from the back
- In
Remove.c:142:
// Check new length
result = result && (VecLen(&vec) == 4);
// Check remaining elements
- In
Remove.c:145:
// Check remaining elements
for (u64 i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == values[i]);
}- In
Remove.c:156:
// Check new length
result = result && (VecLen(&vec) == 3);
// Clean up
- In
Remove.c:180:
// Initial length should be 5
bool result = (VecLen(&vec) == 5);
// Pop from the front
- In
Remove.c:190:
// Check new length
result = result && (VecLen(&vec) == 4);
// Check remaining elements
- In
Remove.c:193:
// Check remaining elements
for (u64 i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == values[i + 1]);
}- In
Remove.c:204:
// Check new length
result = result && (VecLen(&vec) == 3);
// Clean up
- In
Remove.c:228:
// Initial length should be 5
bool result = (VecLen(&vec) == 5);
// Delete element at index 2 (value 30)
- In
Remove.c:234:
// Check new length
result = result && (VecLen(&vec) == 4);
// Check remaining elements (should be [10, 20, 40, 50])
- In
Remove.c:238:
// Check remaining elements (should be [10, 20, 40, 50])
int expected1[] = {10, 20, 40, 50};
for (u64 i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == expected1[i]);
}- In
Remove.c:246:
// Check new length
result = result && (VecLen(&vec) == 3);
// Check remaining elements (should be [20, 40, 50])
- In
Remove.c:250:
// Check remaining elements (should be [20, 40, 50])
int expected2[] = {20, 40, 50};
for (u64 i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == expected2[i]);
}- In
Remove.c:276:
// Initial length should be 5
bool result = (VecLen(&vec) == 5);
// Delete element at index 1 (value 20) using fast delete
- In
Remove.c:282:
// Check new length
result = result && (VecLen(&vec) == 4);
// With fast delete, the last element is moved to the deleted position
- In
Remove.c:287:
// So the vector should now be [10, 50, 30, 40]
int expected[] = {10, 50, 30, 40};
for (u64 i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == expected[i]);
}- In
Remove.c:313:
// Initial length should be 7
bool result = (VecLen(&vec) == 7);
// Delete range from index 2 to 4 (values 30, 40, 50)
- In
Remove.c:319:
// Check new length
result = result && (VecLen(&vec) == 4);
// Check remaining elements (should be [10, 20, 60, 70])
- In
Remove.c:323:
// Check remaining elements (should be [10, 20, 60, 70])
int expected[] = {10, 20, 60, 70};
for (u64 i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == expected[i]);
}- In
Remove.c:348:
// Initial length should be 10
bool result = (VecLen(&vec) == 10);
// Print before state
- In
Remove.c:352:
// Print before state
WriteFmt("Before fast range delete: ");
for (u64 i = 0; i < VecLen(&vec); i++) {
WriteFmt("{} ", VecAt(&vec, i));
}- In
Remove.c:364:
int end_values[3];
for (int i = 0; i < count; i++) {
end_values[i] = VecAt(&vec, VecLen(&vec) - count + i);
}- In
Remove.c:371:
// Print after state
WriteFmt("After fast range delete: ");
for (u64 i = 0; i < VecLen(&vec); i++) {
WriteFmt("{} ", VecAt(&vec, i));
}- In
Remove.c:377:
// Check length after deletion
result = result && (VecLen(&vec) == 7);
// Check that the last 3 elements moved to the deleted positions
- In
Remove.c:386:
// Verify all values that should still be present
bool values_found[10] = {false};
for (u64 i = 0; i < VecLen(&vec); i++) {
int val = VecAt(&vec, i);
int index = val / 10;- In
Remove.c:425:
// Initial length should be 5
bool result = (VecLen(&vec) == 5);
// Delete the last element
- In
Remove.c:431:
// Check new length
result = result && (VecLen(&vec) == 4);
// Check remaining elements
- In
Remove.c:434:
// Check remaining elements
for (u64 i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == values[i]);
}- In
Remove.c:442:
// Check new length
result = result && (VecLen(&vec) == 3);
// Check remaining elements
- In
Remove.c:445:
// Check remaining elements
for (u64 i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == values[i]);
}- In
Remove.c:470:
// Initial length should be 5
bool result = (VecLen(&vec) == 5);
// Test L-value delete operation
- In
Remove.c:477:
// Check vector after L-value deletion
result = result && (VecLen(&vec) == 4);
// Check remaining elements (should be [10, 20, 40, 50])
- In
Remove.c:481:
// Check remaining elements (should be [10, 20, 40, 50])
int expected[] = {10, 20, 40, 50};
for (u64 i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == expected[i]);
}- In
Remove.c:506:
// Initial length should be 5
bool result = (VecLen(&vec) == 5);
// Test R-value delete operation
- In
Remove.c:512:
// Check vector after deletion
result = result && (VecLen(&vec) == 4);
// Check remaining elements (should be [10, 20, 40, 50])
- In
Remove.c:516:
// Check remaining elements (should be [10, 20, 40, 50])
int expected[] = {10, 20, 40, 50};
for (u64 i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == expected[i]);
}- In
Remove.c:541:
// Initial length should be 5
bool result = (VecLen(&vec) == 5);
// Print before state
- In
Remove.c:545:
// Print before state
WriteFmt("Before L-value fast delete: ");
for (u64 i = 0; i < VecLen(&vec); i++) {
WriteFmt("{} ", VecAt(&vec, i));
}- In
Remove.c:553:
int fast_index = 2; // Delete 30
int valueToBeDeleted = VecAt(&vec, fast_index);
int lastValue = VecAt(&vec, VecLen(&vec) - 1); // Should move to deleted position
VecDeleteFast(&vec, fast_index);- In
Remove.c:558:
// Print after state
WriteFmt("After L-value fast delete: ");
for (u64 i = 0; i < VecLen(&vec); i++) {
WriteFmt("{} ", VecAt(&vec, i));
}- In
Remove.c:564:
// Check vector after L-value fast deletion
result = result && (VecLen(&vec) == 4);
// Verify the deleted value is no longer present
- In
Remove.c:568:
// Verify the deleted value is no longer present
bool containsValue = false;
for (u64 i = 0; i < VecLen(&vec); i++) {
if (VecAt(&vec, i) == valueToBeDeleted) {
containsValue = true;- In
Remove.c:589:
for (int i = 0; i < 3; i++) {
bool found = false;
for (u64 j = 0; j < VecLen(&vec); j++) {
if (VecAt(&vec, j) == expected_values[i]) {
found = true;- In
Remove.c:622:
// Initial length should be 5
bool result = (VecLen(&vec) == 5);
// Print before state
- In
Remove.c:626:
// Print before state
WriteFmt("Before R-value fast delete: ");
for (u64 i = 0; i < VecLen(&vec); i++) {
WriteFmt("{} ", VecAt(&vec, i));
}- In
Remove.c:633:
// Remember the value to be deleted and the last value
int valueToBeDeleted = VecAt(&vec, 2); // 30
int lastValue = VecAt(&vec, VecLen(&vec) - 1); // Should move to deleted position
// Test R-value fast delete operation
- In
Remove.c:640:
// Print after state
WriteFmt("After R-value fast delete: ");
for (u64 i = 0; i < VecLen(&vec); i++) {
WriteFmt("{} ", VecAt(&vec, i));
}- In
Remove.c:646:
// Check length
result = result && (VecLen(&vec) == 4);
// Verify the deleted value is no longer present
- In
Remove.c:650:
// Verify the deleted value is no longer present
bool containsValue = false;
for (u64 i = 0; i < VecLen(&vec); i++) {
if (VecAt(&vec, i) == valueToBeDeleted) {
containsValue = true;- In
Remove.c:666:
for (int i = 0; i < 3; i++) {
bool found = false;
for (u64 j = 0; j < VecLen(&vec); j++) {
if (VecAt(&vec, j) == expected_values[i]) {
found = true;- In
Remove.c:699:
// Initial length should be 7
bool result = (VecLen(&vec) == 7);
// Test L-value delete range operation
- In
Remove.c:707:
// Check vector after L-value range deletion
result = result && (VecLen(&vec) == 4);
// Expected result: [10, 20, 60, 70]
- In
Remove.c:711:
// Expected result: [10, 20, 60, 70]
int expected[] = {10, 20, 60, 70};
for (u64 i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == expected[i]);
}- In
Remove.c:736:
// Initial length should be 7
bool result = (VecLen(&vec) == 7);
// Test R-value delete range operation
- In
Remove.c:742:
// Check vector after R-value range deletion
result = result && (VecLen(&vec) == 4);
// Expected result: [10, 20, 60, 70]
- In
Remove.c:746:
// Expected result: [10, 20, 60, 70]
int expected[] = {10, 20, 60, 70};
for (u64 i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == expected[i]);
}- In
Remove.c:771:
// Initial length should be 7
bool result = (VecLen(&vec) == 7);
// Print before state
- In
Remove.c:775:
// Print before state
WriteFmt("Before L-value fast range delete: ");
for (u64 i = 0; i < VecLen(&vec); i++) {
WriteFmt("{} ", VecAt(&vec, i));
}- In
Remove.c:790:
// Print after state
WriteFmt("After L-value fast range delete: ");
for (u64 i = 0; i < VecLen(&vec); i++) {
WriteFmt("{} ", VecAt(&vec, i));
}- In
Remove.c:796:
// Check vector after L-value fast range deletion
result = result && (VecLen(&vec) == 4);
// Verify the deleted values are no longer present
- In
Remove.c:801:
for (int i = 0; i < 3; i++) {
bool found = false;
for (u64 j = 0; j < VecLen(&vec); j++) {
if (VecAt(&vec, j) == valuesToDelete[i]) {
found = true;- In
Remove.c:817:
for (int i = 0; i < 4; i++) {
bool found = false;
for (u64 j = 0; j < VecLen(&vec); j++) {
if (VecAt(&vec, j) == remainingValues[i]) {
found = true;- In
Remove.c:850:
// Initial length should be 7
bool result = (VecLen(&vec) == 7);
// Print before state
- In
Remove.c:854:
// Print before state
WriteFmt("Before R-value fast range delete: ");
for (u64 i = 0; i < VecLen(&vec); i++) {
WriteFmt("{} ", VecAt(&vec, i));
}- In
Remove.c:867:
// Print after state
WriteFmt("After R-value fast range delete: ");
for (u64 i = 0; i < VecLen(&vec); i++) {
WriteFmt("{} ", VecAt(&vec, i));
}- In
Remove.c:873:
// Check vector after R-value fast range deletion
result = result && (VecLen(&vec) == 4);
// Verify the deleted values are no longer present
- In
Remove.c:878:
for (int i = 0; i < 3; i++) {
bool found = false;
for (u64 j = 0; j < VecLen(&vec); j++) {
if (VecAt(&vec, j) == valuesToDelete[i]) {
found = true;- In
Remove.c:894:
for (int i = 0; i < 4; i++) {
bool found = false;
for (u64 j = 0; j < VecLen(&vec); j++) {
if (VecAt(&vec, j) == remainingValues[i]) {
found = true;- In
Remove.c:932:
VecDeleteRangeFast(&vec, 0, 3);
bool result = (VecLen(&vec) == 0);
VecDeinit(&vec);- In
Remove.c:1114:
// Length is now 3; the raw slot at index 4 was part of the vacated tail
// and must read back zero.
bool result = (VecLen(&vec) == 3) && (*VecPtrAt(&vec, 4) == 0);
VecDeinit(&vec);- In
Remove.c:1135:
VecDeleteRangeFast(&vec, 0, 2);
bool result = (VecLen(&vec) == 3) && (*VecPtrAt(&vec, 4) == 0);
VecDeinit(&vec);- In
Remove.c:1160:
VecDeleteRangeFast(&vec, 0, K);
bool result = (VecLen(&vec) == (u64)N - K);
VecDeinit(&vec);- In
Remove.c:1265:
VecDeleteRange(&vec, 20000, 2);
bool result = (VecLen(&vec) == (u64)(N - 2)) && (VecAt(&vec, 0) == 0) && (VecAt(&vec, 19999) == 19999) &&
(VecAt(&vec, 20000) == 20002);- In
Remove.c:1289:
VecDeleteRange(&vec, 0, K);
bool result = (VecLen(&vec) == (u64)N - K) && (VecAt(&vec, 0) == (int)K) && (VecAt(&vec, 19999) == (int)(N - 1));
VecDeinit(&vec);- In
Remove.c:1309:
VecDeleteRange(&vec, 1, 2); // real move ~ (N-3)*4 bytes; mutant ~ (N-3)*42 (~1.5 MB)
bool result = (VecLen(&vec) == (u64)(N - 2)) && (VecAt(&vec, 0) == 0) && (VecAt(&vec, 1) == 3) &&
(VecAt(&vec, (u64)(N - 3)) == (int)(N - 1));- In
Remove.c:1329:
// Dead slot 9 (previously a duplicate of 9) must be zeroed.
bool result = (VecLen(&vec) == 8 && *VecPtrAt(&vec, 9) == 0);
VecDeinit(&vec);- In
Remove.c:1348:
// Dead slot 9 must be zeroed, not left as a stale duplicate.
bool result = (VecLen(&vec) == 8 && *VecPtrAt(&vec, 9) == 0);
VecDeinit(&vec);- In
Remove.c:1372:
VecDeleteRange(&vec, 0, K); // length becomes N-K
bool result = (VecLen(&vec) == (u64)N - K) && (VecAt(&vec, 0) == (int)K);
VecDeinit(&vec);- In
Remove.c:1411:
VecTryReduceSpace(&vec); // capacity := length, buffer := length + 1
size old_len = VecLen(&vec);
// Remove the final element. Real move size = length - (length-1) - 1 = 0.
- In
Remove.c:1417:
VecDeleteRange(&vec, old_len - 1, 1);
bool result = (VecLen(&vec) == old_len - 1);
// Surviving prefix is intact (the real path moved nothing).
result = result && (VecAt(&vec, 0) == 1);- In
Remove.c:1447:
VecTryReduceSpace(&vec); // capacity := length, buffer := length + 1
size old_len = VecLen(&vec);
// Remove all but the last element from the front. Real move size =
- In
Remove.c:1454:
VecDeleteRange(&vec, 0, old_len - 1);
bool result = (VecLen(&vec) == 1);
// The single survivor is the original last element.
result = result && (VecAt(&vec, 0) == (u64)old_len);- In
Foreach.c:59:
// Check that the values in the vector are unchanged (foreach uses value, not reference)
for (u64 i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == values[i]);
}- In
Foreach.c:126:
// Check that the values in the vector are doubled
bool result = true;
for (u64 i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == values[i] * 2);
}- In
Foreach.c:167:
// Check that the values in the vector are set to their indices
bool result = true;
for (u64 i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == i);
}- In
Foreach.c:261:
int expected[] = {15, 24, 33, 42, 51};
bool result = true;
for (size i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == expected[i]);
}- In
Foreach.c:296:
int expected[] = {100, 101, 102, 103, 104};
bool result = true;
for (size i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == expected[i]);
}- In
Foreach.c:321:
int iteration_count = 0;
VecForeach(&vec, val) {
WriteFmt("Iteration {} (vec.length={}): {}\n", iteration_count, VecLen(&vec), val);
// After 2nd iteration, shrink the vector dramatically
- In
Foreach.c:326:
if (iteration_count == 2) {
VecResize(&vec, 2); // Shrink to only 2 elements
WriteFmt("Vector resized to length {} during foreach iteration...\n", VecLen(&vec));
}- In
Foreach.c:360:
// VecForeachIdx has explicit bounds checking: if ((idx) >= (v)->length) LOG_FATAL(...)
VecForeachIdx(&vec, val, idx) {
WriteFmt("Accessing idx {} (vec.length={}): {}\n", idx, VecLen(&vec), val);
// When we reach idx=2, drastically shrink the vector to make the current idx invalid
- In
Foreach.c:366:
if (idx == 2) {
VecResize(&vec, 2); // Shrink so that idx=2 becomes out of bounds (valid indices: 0,1)
WriteFmt("Vector resized to length {}, current idx={} is now out of bounds...\n", VecLen(&vec), idx);
}- In
Foreach.c:398:
// VecForeachReverseIdx has explicit bounds checking: if ((idx) >= (v)->length) LOG_FATAL(...)
VecForeachReverseIdx(&vec, val, idx) {
WriteFmt("Accessing idx {} (vec.length={}): {}\n", idx, VecLen(&vec), val);
// When we reach idx=4, drastically shrink the vector
- In
Foreach.c:405:
if (idx == 4) {
VecResize(&vec, 2); // Shrink to only 2 elements
WriteFmt("Vector resized to length {} during reverse iteration...\n", VecLen(&vec));
}- In
Foreach.c:437:
// VecForeachPtrIdx has explicit bounds checking: if ((idx) >= (v)->length) LOG_FATAL(...)
VecForeachPtrIdx(&vec, val_ptr, idx) {
WriteFmt("Accessing idx {} (vec.length={}): {}\n", idx, VecLen(&vec), *val_ptr);
// When we reach idx=3, shrink the vector to make the CURRENT idx invalid
- In
Foreach.c:443:
if (idx == 3) {
VecResize(&vec, 3); // Shrink so that idx=3 becomes out of bounds (valid indices: 0,1,2)
WriteFmt("Vector resized to length {}, current idx={} is now out of bounds...\n", VecLen(&vec), idx);
}- In
Foreach.c:475:
// VecForeachPtrReverseIdx has explicit bounds checking: if ((idx) >= (v)->length) LOG_FATAL(...)
VecForeachPtrReverseIdx(&vec, val_ptr, idx) {
WriteFmt("Accessing idx {} (vec.length={}): {}\n", idx, VecLen(&vec), *val_ptr);
// When we reach idx=5, shrink the vector significantly
- In
Foreach.c:480:
if (idx == 5) {
VecResize(&vec, 3); // Shrink to only 3 elements
WriteFmt("Vector resized to length {} during reverse ptr iteration...\n", VecLen(&vec));
}- In
Foreach.c:511:
// Use VecForeachPtrInRangeIdx with a fixed range that becomes invalid when we modify the vector
size original_length = VecLen(&vec); // Capture this as 9
VecForeachPtrInRangeIdx(&vec, val_ptr, idx, 0, original_length) {
WriteFmt("Accessing idx {} (vec.length={}): {}\n", idx, VecLen(&vec), *val_ptr);- In
Foreach.c:513:
size original_length = VecLen(&vec); // Capture this as 9
VecForeachPtrInRangeIdx(&vec, val_ptr, idx, 0, original_length) {
WriteFmt("Accessing idx {} (vec.length={}): {}\n", idx, VecLen(&vec), *val_ptr);
// When we reach idx=3, delete several elements
- In
Foreach.c:518:
if (idx == 3) {
VecDeleteRange(&vec, 0, 6); // Remove first 6 elements
WriteFmt("Deleted first 6 elements, new length={}, idx = {}\n", VecLen(&vec), original_length, idx);
}- In
Foreach.c:524:
// loop will automatically terminate
if (idx > VecLen(&vec)) {
LOG_ERROR("Should've terminated");
VecDeinit(&vec);- In
Foreach.c:550:
// Basic VecForeachIdx now has explicit bounds checking: if ((idx) >= (v)->length) LOG_FATAL(...)
VecForeachIdx(&vec, val, idx) {
WriteFmt("Accessing idx {} (vec.length={}): {}\n", idx, VecLen(&vec), val);
// When we reach idx=2, drastically shrink the vector
- In
Foreach.c:556:
if (idx == 2) {
VecResize(&vec, 1); // Shrink to only 1 element
WriteFmt("Vector resized to length {}, current index={}\n", VecLen(&vec), idx);
}- In
Access.c:172:
// Test VecSize and VecLen functions
bool test_vec_size_len(void) {
WriteFmt("Testing VecSize and VecLen\n");
DefaultAllocator alloc = DefaultAllocatorInit();- In
Access.c:183:
// Check initial size and length
size vec_size = VecSize(&vec);
size vec_len = VecLen(&vec);
bool result = (vec_size == 0);
result = result && (vec_len == 0);- In
Access.c:194:
// Check size and length after adding elements
vec_size = VecSize(&vec);
vec_len = VecLen(&vec);
size aligned_offset = VecAlignedOffsetAt(&vec, VecLen(&vec));
result = result && (vec_size == aligned_offset);- In
Access.c:195:
vec_size = VecSize(&vec);
vec_len = VecLen(&vec);
size aligned_offset = VecAlignedOffsetAt(&vec, VecLen(&vec));
result = result && (vec_size == aligned_offset);
result = result && (vec_len == VecLen(&vec));- In
Access.c:197:
size aligned_offset = VecAlignedOffsetAt(&vec, VecLen(&vec));
result = result && (vec_size == aligned_offset);
result = result && (vec_len == VecLen(&vec));
// Clean up
- In
Access.c:213:
// Check size and length
size aligned_vec_size = VecSize(&aligned_vec);
size aligned_vec_len = VecLen(&aligned_vec);
size aligned_offset_at = VecAlignedOffsetAt(&aligned_vec, VecLen(&aligned_vec));
result = result && (aligned_vec_size == aligned_offset_at);- In
Access.c:214:
size aligned_vec_size = VecSize(&aligned_vec);
size aligned_vec_len = VecLen(&aligned_vec);
size aligned_offset_at = VecAlignedOffsetAt(&aligned_vec, VecLen(&aligned_vec));
result = result && (aligned_vec_size == aligned_offset_at);
result = result && (aligned_vec_len == VecLen(&aligned_vec));- In
Access.c:216:
size aligned_offset_at = VecAlignedOffsetAt(&aligned_vec, VecLen(&aligned_vec));
result = result && (aligned_vec_size == aligned_offset_at);
result = result && (aligned_vec_len == VecLen(&aligned_vec));
// Clean up
- In
Access.c:312:
// Store and load both use stride `sizeof(u32)`, so values match.
bool result = (VecLen(&vec) == 4);
for (int i = 0; i < 4; i++) {
result = result && (VecAt(&vec, i) == values[i]);- In
Access.c:343:
// Real: dst == {10,20,30,40}. Mutant (constant offset): every source read
// hits the same element, e.g. dst == {10,10,10,10}.
bool result = (VecLen(&dst) == 4) && (VecAt(&dst, 0) == 10) && (VecAt(&dst, 1) == 20) && (VecAt(&dst, 2) == 30) &&
(VecAt(&dst, 3) == 40); BitVecRuns runs = VecInitT(runs, base);
bool result = BitVecRunLengths(&bv, &runs);
result = result && VecLen(&runs) == 5;
if (result) {
result = result && VecPtrAt(&runs, 0)->length == 3 && VecPtrAt(&runs, 0)->value == true; BitVecMatchIndices matches = VecInitT(matches, base);
result = result && BitVecFindAllPattern(&source, &pattern, &matches);
result = result && VecLen(&matches) == 5;
if (result) {
result = result && VecAt(&matches, 0) == 0; result = result && BitVecFindAllPattern(&source, &pattern, &matches);
// Exact-length match: exactly one hit, at index 0.
result = result && (VecLen(&matches) == 1);
if (result) {
result = result && (VecAt(&matches, 0) == 0);- In
Arena.c:84:
}
ok = ok && VecLen(&v) == 4096 && VecAt(&v, 0) == 0 && VecAt(&v, 4095) == 4095;
VecDeinit(&v);
ArenaAllocatorDeinit(&arena);- In
Page.c:81:
}
ok = ok && (VecLen(&v) == 1024) && (VecAt(&v, 0) == 0) && (VecAt(&v, 1023) == 1023);
VecDeinit(&v);
PageAllocatorDeinit(&alloc);- In
Ops.c:211:
Strs split = StrSplit(&s, ",");
bool result = (VecLen(&split) == 3);
if (VecLen(&split) >= 3) {
result = result && (ZstrCompare(StrBegin(VecPtrAt(&split, 0)), "Hello") == 0);- In
Ops.c:212:
bool result = (VecLen(&split) == 3);
if (VecLen(&split) >= 3) {
result = result && (ZstrCompare(StrBegin(VecPtrAt(&split, 0)), "Hello") == 0);
result = result && (ZstrCompare(StrBegin(VecPtrAt(&split, 1)), "World") == 0);- In
Ops.c:222:
// Test StrSplitToIters
StrIters iters = StrSplitToIters(&s, ",");
result = result && (VecLen(&iters) == 3);
if (VecLen(&iters) >= 3) {- In
Ops.c:224:
result = result && (VecLen(&iters) == 3);
if (VecLen(&iters) >= 3) {
// .length goes through StrIterLength; .data has no accessor
// (the base-pointer of an Iter range is the Iter contract --
- In
Ops.c:488:
StrIters iters = StrSplitToIters(&s, ",");
bool result = (VecLen(&iters) == 3);
if (VecLen(&iters) == 3) {
result = result && (StrIterLength(VecPtrAt(&iters, 0)) == 1);- In
Ops.c:489:
bool result = (VecLen(&iters) == 3);
if (VecLen(&iters) == 3) {
result = result && (StrIterLength(VecPtrAt(&iters, 0)) == 1);
result = result && (StrIterLength(VecPtrAt(&iters, 1)) == 1);- In
Ops.c:515:
Strs split = StrSplit(&s, "abc");
bool result = (VecLen(&split) == 0);
if (!result) {
WriteFmt(" FAIL: Expected 0 split elements, got {}\n", (u64)VecLen(&split));- In
Ops.c:517:
bool result = (VecLen(&split) == 0);
if (!result) {
WriteFmt(" FAIL: Expected 0 split elements, got {}\n", (u64)VecLen(&split));
}- In
Ops.c:538:
Strs split = StrSplit(&s, "abc");
bool result = (VecLen(&split) == 0);
if (!result) {
WriteFmt(" FAIL: Expected 0 split elements, got {}\n", (u64)VecLen(&split));- In
Ops.c:540:
bool result = (VecLen(&split) == 0);
if (!result) {
WriteFmt(" FAIL: Expected 0 split elements, got {}\n", (u64)VecLen(&split));
}- In
Init.c:290:
// Sanity: the split really produced multiple heap-backed elements,
// otherwise the leak would be unobservable.
bool produced = VecLen(&parts) == 4 && DebugAllocatorLiveCount(&dbg) > before;
VecDeinit(&parts); // invokes str_deinit per element on real code.
- In
Type.c:60:
// Check that it behaves like a Vec of Str objects
bool result = (VecLen(&sv) == 2);
// Check the content of the strings
- In
Backtrace.c:75:
StackFrames frames = VecInitT(frames, alloc_base);
bool ok = bt_vec_capture_outer(&frames);
ok = ok && VecLen(&frames) >= 2;
Str rendered = StrInit(alloc_base);- In
SysDns.c:131:
// Compare nameserver `i` formatted as "ip:port" against `expect`.
static bool ns_fmt_is(DnsResolver *r, u64 i, Allocator *a, Zstr expect) {
if (VecLen(&r->nameservers) <= i) {
return false;
}- In
SysDns.c:220:
bool got = DnsResolve(&r, "203.0.113.7:9999", SOCKET_KIND_TCP, &out);
bool ok = got && VecLen(&out) == 1 && VecPtrAt(&out, 0)->family == SOCKET_FAMILY_INET;
if (ok) {
Str s = SocketAddrFormat(VecPtrAt(&out, 0), a);- In
SysDns.c:244:
bool got = DnsResolve(&r, "[::1]:443", SOCKET_KIND_TCP, &out);
bool ok = got && VecLen(&out) == 1 && VecPtrAt(&out, 0)->family == SOCKET_FAMILY_INET6;
if (ok) {
Str s = SocketAddrFormat(VecPtrAt(&out, 0), a);- In
SysDns.c:268:
bool got = DnsResolve(&r, "localhost:53", SOCKET_KIND_TCP, &out);
bool ok = got && VecLen(&out) > 0;
if (ok) {
VecForeachPtr(&out, ad) {- In
SysDns.c:320:
bool got = DnsResolve(&r, "localhost", SOCKET_KIND_TCP, &out);
bool ok = !got && VecLen(&out) == 0;
VecDeinit(&out);- In
SysDns.c:362:
const HostsEntry *e = find_host(&r.hosts, "localhost");
bool ok = VecLen(&r.hosts) == 1 && host_v4_is(e, 127, 0, 0, 1) && ZstrCompare(StrBegin(&e->name), "localhost") == 0;
drop_temp(&path);- In
SysDns.c:380:
DnsResolverAddHostsPath(&r, &path);
bool ok = VecLen(&r.hosts) == 4 && host_v4_is(find_host(&r.hosts, "host.example"), 192, 168, 1, 5) &&
host_v4_is(find_host(&r.hosts, "alias1"), 192, 168, 1, 5) &&
host_v4_is(find_host(&r.hosts, "alias2"), 192, 168, 1, 5) &&- In
SysDns.c:408:
DnsResolverAddHostsPath(&r, &path);
bool ok = VecLen(&r.hosts) == 1 && host_v4_is(find_host(&r.hosts, "a"), 10, 0, 0, 1) &&
find_host(&r.hosts, "commented.host") == (const HostsEntry *)0;- In
SysDns.c:427:
DnsResolverAddHostsPath(&r, &path);
bool ok = VecLen(&r.hosts) == 1 && host_v4_is(find_host(&r.hosts, "namex"), 10, 0, 0, 2) &&
find_host(&r.hosts, "trailing") == (const HostsEntry *)0 &&
find_host(&r.hosts, "#") == (const HostsEntry *)0;- In
SysDns.c:448:
const HostsEntry *e =