VecLen

Macro
October 8, 2025

Table of Contents

`VecLen`

Description

Length of vector.

Parameters

Name	Direction	Description
`v`	in	Vector to get length of

Usage example (Cross-references)

In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In rogrammer/MisraStdC/blob/master/Tests/Std/Vec.Access.c#L149 target=_blank>Vec.Access.c:149:
// Test VecSize and VecLen functions style=color:#75715e> bool test_vec_size_len(void) { WriteFmt("Testing VecSize and VecLen\n"); // Create a vector of integers Vec.Access.c:157:
// Check initial size and length style=color:#75715e> size vec_size = VecSize(&vec); size vec_len = VecLen(&vec); bool result = (vec_size == 0); result = result && (vec_len == 0); Vec.Access.c:168:
// Check size and length after adding elements style=color:#75715e> vec_size = VecSize(&vec); vec_len = VecLen(&vec); size aligned_offset = VecAlignedOffsetAt(&vec, vec.length); result = result && (vec_size == aligned_offset); Vec.Access.c:186:
// Check size and length with alignment style=color:#75715e> size aligned_vec_size = VecSize(&aligned_vec); size aligned_vec_len = VecLen(&aligned_vec); size aligned_offset_at = VecAlignedOffsetAt(&aligned_vec, aligned_vec.length); result = result && (aligned_vec_size == aligned_offset_at); RoundTrip.c:72:
bool compare_configs(const TestConfig *a, const TestConfig *b) { if (a->debug_mode != b->debug_mode || a->timeout != b->timeout || StrCmp(&a->log_level, &b->log_level) != 0 || VecLen(&a->features) != VecLen(&b->features)) { return false; } RoundTrip.c:76:
} for (size i = 0; i < VecLen(&a->features); i++) { if (StrCmp(&VecAt(&a->features, i), &VecAt(&b->features, i)) != 0) { return false; RoundTrip.c:398:
// Compare arrays style=color:#75715e> bool numbers_match = (VecLen(&original_numbers) == VecLen(&parsed_numbers)); if (numbers_match) { for (size i = 0; i < VecLen(&original_numbers); i++) { RoundTrip.c:400:
bool numbers_match = (VecLen(&original_numbers) == VecLen(&parsed_numbers)); if (numbers_match) { for (size i = 0; i < VecLen(&original_numbers); i++) { if (VecAt(&original_numbers, i) != VecAt(&parsed_numbers, i)) { numbers_match = false; RoundTrip.c:408:
} bool strings_match = (VecLen(&original_strings) == VecLen(&parsed_strings)); if (strings_match) { for (size i = 0; i < VecLen(&original_strings); i++) { RoundTrip.c:410:
bool strings_match = (VecLen(&original_strings) == VecLen(&parsed_strings)); if (strings_match) { for (size i = 0; i < VecLen(&original_strings); i++) { if (VecAt(&original_strings, i).length != VecAt(&parsed_strings, i).length || (VecAt(&original_strings, i).length && RoundTrip.c:427:
"[DEBUG] Numbers match: {} (orig {}, parsed {})\n", numbers_match ? "true" : "false", VecLen(&original_numbers), VecLen(&parsed_numbers) ); RoundTrip.c:428:
numbers_match ? "true" : "false", VecLen(&original_numbers), VecLen(&parsed_numbers) ); WriteFmtLn( RoundTrip.c:433:
"[DEBUG] Strings match: {} (orig {}, parsed {})\n", strings_match ? "true" : "false", VecLen(&original_strings), VecLen(&parsed_strings) ); RoundTrip.c:434:
strings_match ? "true" : "false", VecLen(&original_strings), VecLen(&parsed_strings) ); success = false; RoundTrip.c:603:
bool config_match = compare_configs(&original.config, &parsed.config); bool numbers_match = (VecLen(&original.numbers) == VecLen(&parsed.numbers)); if (numbers_match) { for (size i = 0; i < VecLen(&original.numbers); i++) { RoundTrip.c:605:
bool numbers_match = (VecLen(&original.numbers) == VecLen(&parsed.numbers)); if (numbers_match) { for (size i = 0; i < VecLen(&original.numbers); i++) { if (VecAt(&original.numbers, i) != VecAt(&parsed.numbers, i)) { numbers_match = false; RoundTrip.c:613:
} bool flags_match = (VecLen(&original.flags) == VecLen(&parsed.flags)); if (flags_match) { for (size i = 0; i < VecLen(&original.flags); i++) { RoundTrip.c:615:
bool flags_match = (VecLen(&original.flags) == VecLen(&parsed.flags)); if (flags_match) { for (size i = 0; i < VecLen(&original.flags); i++) { if (VecAt(&original.flags, i) != VecAt(&parsed.flags, i)) { flags_match = false; RoundTrip.c:690:
// Compare empty containers style=color:#75715e> if (parsed_str.length == 0 && VecLen(&parsed_numbers) == 0 && VecLen(&parsed_strings) == 0 && !found_empty_object) { // Empty object should not execute the content style=color:#75715e> WriteFmtLn("[DEBUG] Empty containers round-trip test passed"); RoundTrip.c:698:
"[DEBUG] String length: {}, numbers: {}, strings: {}, found_obj: {}\n", parsed_str.length, VecLen(&parsed_numbers), VecLen(&parsed_strings), found_empty_object ? "true" : "false" RoundTrip.c:699:
parsed_str.length, VecLen(&parsed_numbers), VecLen(&parsed_strings), found_empty_object ? "true" : "false" ); Read.EdgeCases.c:112:
}); if (VecLen(&items) == 0) { WriteFmtLn("[DEBUG] Empty array test passed - no items added"); } else { Read.EdgeCases.c:115:
WriteFmtLn("[DEBUG] Empty array test passed - no items added"); } else { WriteFmtLn("[DEBUG] Empty array test FAILED - {} items found", VecLen(&items)); success = false; } Read.EdgeCases.c:133:
}); if (VecLen(&data) == 0) { WriteFmtLn("[DEBUG] Empty array with whitespace test passed"); } else { Read.EdgeCases.c:526:
}); if (obj.x_value == 1 && VecLen(&obj.filled_items) == 2 && VecAt(&obj.filled_items, 0) == 1 && VecAt(&obj.filled_items, 1) == 2) { WriteFmt( Read.EdgeCases.c:531:
"[DEBUG] Mixed empty and filled test passed - x: {}, items: {}\n", obj.x_value, VecLen(&obj.filled_items) ); } else { Read.EdgeCases.c:537:
"[DEBUG] Mixed empty and filled test FAILED - x: {}, items: {}\n", obj.x_value, VecLen(&obj.filled_items) ); if (VecLen(&obj.filled_items) > 0) { Read.EdgeCases.c:539:
VecLen(&obj.filled_items) ); if (VecLen(&obj.filled_items) > 0) { WriteFmt("[DEBUG] First item: {}\n", VecAt(&obj.filled_items, 0)); } Str.c:72:
case STR_INIT_FROM_STR : { if (VecLen(str) > 0) { Str temp = StrInitFromStr(str); StrDeinit(str); Str.c:81:
case STR_DUP : { if (VecLen(str) > 0) { Str temp = StrDup(str); StrDeinit(str); Str.c:97:
// Access operations style=color:#75715e> case STR_FIRST : { if (VecLen(str) > 0) { char first = StrFirst(str); (void)first; // Suppress unused variable warning Str.c:105:
case STR_LAST : { if (VecLen(str) > 0) { char last = StrLast(str); (void)last; // Suppress unused variable warning Str.c:125:
case STR_CHAR_AT : { if (VecLen(str) > 0 && *offset + 2 <= size) { size_t idx = extract_u16(data, offset, size) % VecLen(str); char ch = StrCharAt(str, idx); Str.c:126:
case STR_CHAR_AT : { if (VecLen(str) > 0 && *offset + 2 <= size) { size_t idx = extract_u16(data, offset, size) % VecLen(str); char ch = StrCharAt(str, idx); (void)ch; // Suppress unused variable warning Str.c:134:
case STR_CHAR_PTR_AT : { if (VecLen(str) > 0 && *offset + 2 <= size) { size_t idx = extract_u16(data, offset, size) % VecLen(str); char *ptr = StrCharPtrAt(str, idx); Str.c:135:
case STR_CHAR_PTR_AT : { if (VecLen(str) > 0 && *offset + 2 <= size) { size_t idx = extract_u16(data, offset, size) % VecLen(str); char *ptr = StrCharPtrAt(str, idx); (void)ptr; // Suppress unused variable warning Str.c:170:
case STR_LEN : { size_t len = VecLen(str); (void)len; // Suppress unused variable warning style=color:#75715e> break; Str.c:183:
// String operations style=color:#75715e> case STR_CMP : { if (VecLen(str) > 0) { Str temp = generate_str_from_input(data, offset, size, 20); int result = StrCmp(str, &temp); Str.c:193:
case STR_CMP_CSTR : { if (VecLen(str) > 0 && *offset + 1 <= size) { char *cstr = generate_cstring(data, offset, size, 20); if (cstr) { Str.c:205:
case STR_CMP_ZSTR : { if (VecLen(str) > 0 && *offset + 1 <= size) { char *zstr = generate_cstring(data, offset, size, 20); if (zstr) { Str.c:217:
case STR_FIND_STR : { if (VecLen(str) > 0) { Str temp = generate_str_from_input(data, offset, size, 10); char *found = StrFindStr(str, &temp); Str.c:227:
case STR_FIND_ZSTR : { if (VecLen(str) > 0 && *offset + 1 <= size) { char *zstr = generate_cstring(data, offset, size, 10); if (zstr) { Str.c:239:
case STR_FIND_CSTR : { if (VecLen(str) > 0 && *offset + 1 <= size) { char *cstr = generate_cstring(data, offset, size, 10); if (cstr) { Str.c:253:
case STR_INSERT : { if (*offset + 3 <= size) { size_t idx = extract_u16(data, offset, size) % (VecLen(str) + 1); char ch = (char)extract_u8(data, offset, size); StrInsertCharAt(str, ch, idx); Str.c:262:
case STR_INSERT_CSTR : { if (*offset + 3 <= size) { size_t idx = extract_u16(data, offset, size) % (VecLen(str) + 1); char *cstr = generate_cstring(data, offset, size, 20); if (cstr) { Str.c:274:
case STR_INSERT_ZSTR : { if (*offset + 3 <= size) { size_t idx = extract_u16(data, offset, size) % (VecLen(str) + 1); char *zstr = generate_cstring(data, offset, size, 20); if (zstr) { Str.c:286:
case STR_INSERT_STR : { if (*offset + 2 <= size) { size_t idx = extract_u16(data, offset, size) % (VecLen(str) + 1); Str temp = generate_str_from_input(data, offset, size, 20); StrInsert(str, &temp, idx); Str.c:349:
// Remove operations style=color:#75715e> case STR_POP_BACK : { if (VecLen(str) > 0) { char ch; StrPopBack(str, &ch); Str.c:358:
case STR_POP_FRONT : { if (VecLen(str) > 0) { char ch; StrPopFront(str, &ch); Str.c:367:
case STR_REMOVE : { if (VecLen(str) > 0 && *offset + 2 <= size) { size_t idx = extract_u16(data, offset, size) % VecLen(str); char ch; Str.c:368:
case STR_REMOVE : { if (VecLen(str) > 0 && *offset + 2 <= size) { size_t idx = extract_u16(data, offset, size) % VecLen(str); char ch; StrRemove(str, &ch, idx); Str.c:377:
case STR_REMOVE_RANGE : { if (VecLen(str) > 0 && *offset + 4 <= size) { size_t start = extract_u16(data, offset, size) % VecLen(str); size_t count = extract_u16(data, offset, size) % (VecLen(str) - start + 1); Str.c:378:
case STR_REMOVE_RANGE : { if (VecLen(str) > 0 && *offset + 4 <= size) { size_t start = extract_u16(data, offset, size) % VecLen(str); size_t count = extract_u16(data, offset, size) % (VecLen(str) - start + 1); StrRemoveRange(str, (char *)NULL, start, count); Str.c:379:
if (VecLen(str) > 0 && *offset + 4 <= size) { size_t start = extract_u16(data, offset, size) % VecLen(str); size_t count = extract_u16(data, offset, size) % (VecLen(str) - start + 1); StrRemoveRange(str, (char *)NULL, start, count); } Str.c:386:
case STR_DELETE : { if (VecLen(str) > 0 && *offset + 2 <= size) { size_t idx = extract_u16(data, offset, size) % VecLen(str); StrDelete(str, idx); Str.c:387:
case STR_DELETE : { if (VecLen(str) > 0 && *offset + 2 <= size) { size_t idx = extract_u16(data, offset, size) % VecLen(str); StrDelete(str, idx); } Str.c:394:
case STR_DELETE_RANGE : { if (VecLen(str) > 0 && *offset + 4 <= size) { size_t start = extract_u16(data, offset, size) % VecLen(str); size_t count = extract_u16(data, offset, size) % (VecLen(str) - start + 1); Str.c:395:
case STR_DELETE_RANGE : { if (VecLen(str) > 0 && *offset + 4 <= size) { size_t start = extract_u16(data, offset, size) % VecLen(str); size_t count = extract_u16(data, offset, size) % (VecLen(str) - start + 1); StrDeleteRange(str, start, count); Str.c:396:
if (VecLen(str) > 0 && *offset + 4 <= size) { size_t start = extract_u16(data, offset, size) % VecLen(str); size_t count = extract_u16(data, offset, size) % (VecLen(str) - start + 1); StrDeleteRange(str, start, count); } Str.c:409:
case STR_SWAP_ITEMS : { if (VecLen(str) > 1 && *offset + 4 <= size) { size_t idx1 = extract_u16(data, offset, size) % VecLen(str); size_t idx2 = extract_u16(data, offset, size) % VecLen(str); Str.c:410:
case STR_SWAP_ITEMS : { if (VecLen(str) > 1 && *offset + 4 <= size) { size_t idx1 = extract_u16(data, offset, size) % VecLen(str); size_t idx2 = extract_u16(data, offset, size) % VecLen(str); StrSwapCharAt(str, idx1, idx2); Str.c:411:
if (VecLen(str) > 1 && *offset + 4 <= size) { size_t idx1 = extract_u16(data, offset, size) % VecLen(str); size_t idx2 = extract_u16(data, offset, size) % VecLen(str); StrSwapCharAt(str, idx1, idx2); } Str.c:460:
// Foreach operations style=color:#75715e> case STR_FOREACH : { if (VecLen(str) > 0) { size_t total_len = 0; StrForeach(str, ch) { Str.c:471:
case STR_FOREACH_IDX : { if (VecLen(str) > 0) { size_t total_len = 0; StrForeachIdx(str, ch, idx) { Str.c:482:
case STR_FOREACH_PTR : { if (VecLen(str) > 0) { size_t total_len = 0; StrForeachPtr(str, ch_ptr) { Str.c:493:
case STR_FOREACH_PTR_IDX : { if (VecLen(str) > 0) { size_t total_len = 0; StrForeachPtrIdx(str, ch_ptr, idx) { Str.c:504:
case STR_FOREACH_REVERSE : { if (VecLen(str) > 0) { size_t total_len = 0; StrForeachReverse(str, ch) { Str.c:515:
case STR_FOREACH_REVERSE_IDX : { if (VecLen(str) > 0) { size_t total_len = 0; StrForeachReverseIdx(str, ch, idx) { Str.c:526:
case STR_FOREACH_PTR_REVERSE : { if (VecLen(str) > 0) { size_t total_len = 0; StrForeachPtrReverse(str, ch_ptr) { Str.c:537:
case STR_FOREACH_PTR_REVERSE_IDX : { if (VecLen(str) > 0) { size_t total_len = 0; StrForeachReversePtrIdx(str, ch_ptr, idx) { Str.c:548:
case STR_FOREACH_IN_RANGE : { if (VecLen(str) > 0 && *offset + 4 <= size) { size_t start = extract_u16(data, offset, size) % VecLen(str); size_t end = extract_u16(data, offset, size) % (VecLen(str) + 1); Str.c:549:
case STR_FOREACH_IN_RANGE : { if (VecLen(str) > 0 && *offset + 4 <= size) { size_t start = extract_u16(data, offset, size) % VecLen(str); size_t end = extract_u16(data, offset, size) % (VecLen(str) + 1); if (start < end) { Str.c:550:
if (VecLen(str) > 0 && *offset + 4 <= size) { size_t start = extract_u16(data, offset, size) % VecLen(str); size_t end = extract_u16(data, offset, size) % (VecLen(str) + 1); if (start < end) { size_t total_len = 0; Str.c:563:
case STR_FOREACH_IN_RANGE_IDX : { if (VecLen(str) > 0 && *offset + 4 <= size) { size_t start = extract_u16(data, offset, size) % VecLen(str); size_t end = extract_u16(data, offset, size) % (VecLen(str) + 1); Str.c:564:
case STR_FOREACH_IN_RANGE_IDX : { if (VecLen(str) > 0 && *offset + 4 <= size) { size_t start = extract_u16(data, offset, size) % VecLen(str); size_t end = extract_u16(data, offset, size) % (VecLen(str) + 1); if (start < end) { Str.c:565:
if (VecLen(str) > 0 && *offset + 4 <= size) { size_t start = extract_u16(data, offset, size) % VecLen(str); size_t end = extract_u16(data, offset, size) % (VecLen(str) + 1); if (start < end) { size_t total_len = 0; Str.c:578:
case STR_FOREACH_PTR_IN_RANGE : { if (VecLen(str) > 0 && *offset + 4 <= size) { size_t start = extract_u16(data, offset, size) % VecLen(str); size_t end = extract_u16(data, offset, size) % (VecLen(str) + 1); Str.c:579:
case STR_FOREACH_PTR_IN_RANGE : { if (VecLen(str) > 0 && *offset + 4 <= size) { size_t start = extract_u16(data, offset, size) % VecLen(str); size_t end = extract_u16(data, offset, size) % (VecLen(str) + 1); if (start < end) { Str.c:580:
if (VecLen(str) > 0 && *offset + 4 <= size) { size_t start = extract_u16(data, offset, size) % VecLen(str); size_t end = extract_u16(data, offset, size) % (VecLen(str) + 1); if (start < end) { size_t total_len = 0; Str.c:593:
case STR_FOREACH_PTR_IN_RANGE_IDX : { if (VecLen(str) > 0 && *offset + 4 <= size) { size_t start = extract_u16(data, offset, size) % VecLen(str); size_t end = extract_u16(data, offset, size) % (VecLen(str) + 1); Str.c:594:
case STR_FOREACH_PTR_IN_RANGE_IDX : { if (VecLen(str) > 0 && *offset + 4 <= size) { size_t start = extract_u16(data, offset, size) % VecLen(str); size_t end = extract_u16(data, offset, size) % (VecLen(str) + 1); if (start < end) { Str.c:595:
if (VecLen(str) > 0 && *offset + 4 <= size) { size_t start = extract_u16(data, offset, size) % VecLen(str); size_t end = extract_u16(data, offset, size) % (VecLen(str) + 1); if (start < end) { size_t total_len = 0; VecInt.c:42:
case VEC_INT_POP_BACK : { if (VecLen(vec) > 0) { i32 popped; VecPopBack(vec, &popped); VecInt.c:50:
case VEC_INT_POP_FRONT : { if (VecLen(vec) > 0) { i32 popped; VecPopFront(vec, &popped); VecInt.c:61:
i32 value = (i32)extract_u32(data, offset, size); if (idx <= VecLen(vec)) { VecInsert(vec, value, idx); } VecInt.c:69:
case VEC_INT_REMOVE : { uint16_t idx = extract_u16(data, offset, size); if (idx < VecLen(vec)) { i32 removed; VecRemove(vec, &removed, idx); VecInt.c:78:
case VEC_INT_DELETE : { uint16_t idx = extract_u16(data, offset, size); if (idx < VecLen(vec)) { VecDelete(vec, idx); } VecInt.c:86:
case VEC_INT_AT : { uint16_t idx = extract_u16(data, offset, size); if (idx < VecLen(vec)) { volatile i32 value = VecAt(vec, idx); (void)value; // Prevent optimization VecInt.c:94:
case VEC_INT_LEN : { volatile uint64_t len = VecLen(vec); (void)len; break; VecInt.c:100:
case VEC_INT_FIRST : { if (VecLen(vec) > 0) { volatile i32 first = VecFirst(vec); (void)first; VecInt.c:108:
case VEC_INT_LAST : { if (VecLen(vec) > 0) { volatile i32 last = VecLast(vec); (void)last; VecInt.c:156:
uint16_t idx2 = extract_u16(data, offset, size); uint64_t len = VecLen(vec); if (len > 1 && idx1 < len && idx2 < len) { VecSwapItems(vec, idx1, idx2); VecInt.c:169:
count = count % 16; if (idx <= VecLen(vec) && count > 0) { i32 values[16]; for (uint8_t i = 0; i < count && *offset + 4 <= size; i++) { VecInt.c:184:
count = count % 16; uint64_t len = VecLen(vec); if (len > 0 && start < len && count > 0 && start + count <= len) { i32 removed_items[16]; VecInt.c:197:
count = count % 16; uint64_t len = VecLen(vec); if (len > 0 && start < len && count > 0 && start + count <= len) { VecDeleteRange(vec, start, count); VecInt.c:208:
i32 value = (i32)extract_u32(data, offset, size); if (idx <= VecLen(vec)) { VecInsertFast(vec, value, idx); } VecInt.c:216:
case VEC_INT_REMOVE_FAST : { uint16_t idx = extract_u16(data, offset, size); if (idx < VecLen(vec)) { i32 removed; VecRemoveFast(vec, &removed, idx); VecInt.c:228:
count = count % 16; uint64_t len = VecLen(vec); if (len > 0 && start < len && count > 0 && start + count <= len) { i32 removed_items[16]; VecInt.c:248:
count = count % 16; uint64_t len = VecLen(vec); if (len > 0 && start < len && count > 0 && start + count <= len) { VecDeleteRangeFast(vec, start, count); VecInt.c:318:
case VEC_INT_PTR_AT : { uint16_t idx = extract_u16(data, offset, size); if (idx < VecLen(vec)) { volatile i32 *ptr = VecPtrAt(vec, idx); volatile i32 val = *ptr; VecInt.c:346:
count = count % 16; if (idx <= VecLen(vec) && count > 0) { i32 values[16]; for (uint8_t i = 0; i < count && *offset + 4 <= size; i++) { VecInt.c:358:
case VEC_INT_ALIGNED_OFFSET_AT : { uint16_t idx = extract_u16(data, offset, size); if (idx <= VecLen(vec)) { volatile uint64_t offset_val = VecAlignedOffsetAt(vec, idx); (void)offset_val; VecInt.c:366:
case VEC_INT_DELETE_LAST : { if (VecLen(vec) > 0) { VecDeleteLast(vec); } VecInt.c:374:
case VEC_INT_DELETE_FAST : { uint16_t idx = extract_u16(data, offset, size); if (idx < VecLen(vec)) { VecDeleteFast(vec, idx); } VecInt.c:397:
// Foreach operations style=color:#75715e> case VEC_INT_FOREACH : { if (VecLen(vec) > 0) { int sum = 0; VecForeach(vec, item) { VecInt.c:408:
case VEC_INT_FOREACH_IDX : { if (VecLen(vec) > 0) { int sum = 0; VecForeachIdx(vec, item, idx) { VecInt.c:419:
case VEC_INT_FOREACH_PTR : { if (VecLen(vec) > 0) { int sum = 0; VecForeachPtr(vec, item_ptr) { VecInt.c:430:
case VEC_INT_FOREACH_PTR_IDX : { if (VecLen(vec) > 0) { int sum = 0; VecForeachPtrIdx(vec, item_ptr, idx) { VecInt.c:441:
case VEC_INT_FOREACH_REVERSE : { if (VecLen(vec) > 0) { int sum = 0; VecForeachReverse(vec, item) { VecInt.c:452:
case VEC_INT_FOREACH_REVERSE_IDX : { if (VecLen(vec) > 0) { int sum = 0; VecForeachReverseIdx(vec, item, idx) { VecInt.c:463:
case VEC_INT_FOREACH_PTR_REVERSE : { if (VecLen(vec) > 0) { int sum = 0; VecForeachPtrReverse(vec, item_ptr) { VecInt.c:474:
case VEC_INT_FOREACH_PTR_REVERSE_IDX : { if (VecLen(vec) > 0) { int sum = 0; VecForeachPtrReverseIdx(vec, item_ptr, idx) { VecInt.c:485:
case VEC_INT_FOREACH_IN_RANGE : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t start = extract_u32(data, offset, size) % VecLen(vec); size_t end = extract_u32(data, offset, size) % (VecLen(vec) + 1); VecInt.c:486:
case VEC_INT_FOREACH_IN_RANGE : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t start = extract_u32(data, offset, size) % VecLen(vec); size_t end = extract_u32(data, offset, size) % (VecLen(vec) + 1); if (start < end) { VecInt.c:487:
if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t start = extract_u32(data, offset, size) % VecLen(vec); size_t end = extract_u32(data, offset, size) % (VecLen(vec) + 1); if (start < end) { int sum = 0; VecInt.c:500:
case VEC_INT_FOREACH_IN_RANGE_IDX : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t start = extract_u32(data, offset, size) % VecLen(vec); size_t end = extract_u32(data, offset, size) % (VecLen(vec) + 1); VecInt.c:501:
case VEC_INT_FOREACH_IN_RANGE_IDX : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t start = extract_u32(data, offset, size) % VecLen(vec); size_t end = extract_u32(data, offset, size) % (VecLen(vec) + 1); if (start < end) { VecInt.c:502:
if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t start = extract_u32(data, offset, size) % VecLen(vec); size_t end = extract_u32(data, offset, size) % (VecLen(vec) + 1); if (start < end) { int sum = 0; VecInt.c:515:
case VEC_INT_FOREACH_PTR_IN_RANGE : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t start = extract_u32(data, offset, size) % VecLen(vec); size_t end = extract_u32(data, offset, size) % (VecLen(vec) + 1); VecInt.c:516:
case VEC_INT_FOREACH_PTR_IN_RANGE : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t start = extract_u32(data, offset, size) % VecLen(vec); size_t end = extract_u32(data, offset, size) % (VecLen(vec) + 1); if (start < end) { VecInt.c:517:
if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t start = extract_u32(data, offset, size) % VecLen(vec); size_t end = extract_u32(data, offset, size) % (VecLen(vec) + 1); if (start < end) { int sum = 0; VecInt.c:530:
case VEC_INT_FOREACH_PTR_IN_RANGE_IDX : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t start = extract_u32(data, offset, size) % VecLen(vec); size_t end = extract_u32(data, offset, size) % (VecLen(vec) + 1); VecInt.c:531:
case VEC_INT_FOREACH_PTR_IN_RANGE_IDX : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t start = extract_u32(data, offset, size) % VecLen(vec); size_t end = extract_u32(data, offset, size) % (VecLen(vec) + 1); if (start < end) { VecInt.c:532:
if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t start = extract_u32(data, offset, size) % VecLen(vec); size_t end = extract_u32(data, offset, size) % (VecLen(vec) + 1); if (start < end) { int sum = 0; VecStr.c:61:
case VEC_STR_POP_BACK : { if (VecLen(vec) > 0) { Str str; VecPopBack(vec, &str); VecStr.c:70:
case VEC_STR_POP_FRONT : { if (VecLen(vec) > 0) { Str str; VecPopFront(vec, &str); VecStr.c:80:
case VEC_STR_INSERT : { if (*offset + 4 <= size) { size_t index = extract_u32(data, offset, size) % (VecLen(vec) + 1); Str str = generate_str_from_input(data, offset, size, 32); VecInsert(vec, str, index); VecStr.c:88:
case VEC_STR_REMOVE : { if (VecLen(vec) > 0 && *offset + 4 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); Str str; VecStr.c:89:
case VEC_STR_REMOVE : { if (VecLen(vec) > 0 && *offset + 4 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); Str str; VecRemove(vec, &str, index); VecStr.c:98:
case VEC_STR_DELETE : { if (VecLen(vec) > 0 && *offset + 4 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); VecDelete(vec, index); VecStr.c:99:
case VEC_STR_DELETE : { if (VecLen(vec) > 0 && *offset + 4 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); VecDelete(vec, index); // StrDeinit is called automatically by the vector VecStr.c:107:
case VEC_STR_AT : { if (VecLen(vec) > 0 && *offset + 4 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); Str str = VecAt(vec, index); VecStr.c:108:
case VEC_STR_AT : { if (VecLen(vec) > 0 && *offset + 4 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); Str str = VecAt(vec, index); (void)str; // Use the result to avoid warnings VecStr.c:116:
case VEC_STR_LEN : { size_t len = VecLen(vec); (void)len; // Use the result to avoid warnings style=color:#75715e> break; VecStr.c:122:
case VEC_STR_FIRST : { if (VecLen(vec) > 0) { Str first = VecFirst(vec); (void)first; // Use the result to avoid warnings VecStr.c:130:
case VEC_STR_LAST : { if (VecLen(vec) > 0) { Str last = VecLast(vec); (void)last; // Use the result to avoid warnings VecStr.c:146:
if (*offset + 4 <= size) { size_t new_size = extract_u32(data, offset, size) % 100; // Limit to reasonable size style=color:#75715e> size_t old_size = VecLen(vec); // VecResize automatically handles cleanup of removed elements and VecStr.c:188:
case VEC_STR_SWAP_ITEMS : { if (VecLen(vec) >= 2 && *offset + 8 <= size) { size_t i = extract_u32(data, offset, size) % VecLen(vec); size_t j = extract_u32(data, offset, size) % VecLen(vec); VecStr.c:189:
case VEC_STR_SWAP_ITEMS : { if (VecLen(vec) >= 2 && *offset + 8 <= size) { size_t i = extract_u32(data, offset, size) % VecLen(vec); size_t j = extract_u32(data, offset, size) % VecLen(vec); VecSwapItems(vec, i, j); VecStr.c:190:
if (VecLen(vec) >= 2 && *offset + 8 <= size) { size_t i = extract_u32(data, offset, size) % VecLen(vec); size_t j = extract_u32(data, offset, size) % VecLen(vec); VecSwapItems(vec, i, j); } VecStr.c:198:
case VEC_STR_INSERT_RANGE : { if (*offset + 8 <= size) { size_t index = extract_u32(data, offset, size) % (VecLen(vec) + 1); size_t count = extract_u32(data, offset, size) % 10; // Limit to reasonable count VecStr.c:214:
case VEC_STR_REMOVE_RANGE : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); size_t count = extract_u32(data, offset, size) % (VecLen(vec) - index + 1); VecStr.c:215:
case VEC_STR_REMOVE_RANGE : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); size_t count = extract_u32(data, offset, size) % (VecLen(vec) - index + 1); VecRemoveRange(vec, (Str *)NULL, index, count); VecStr.c:216:
if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); size_t count = extract_u32(data, offset, size) % (VecLen(vec) - index + 1); VecRemoveRange(vec, (Str *)NULL, index, count); } VecStr.c:223:
case VEC_STR_DELETE_RANGE : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); size_t count = extract_u32(data, offset, size) % (VecLen(vec) - index + 1); VecStr.c:224:
case VEC_STR_DELETE_RANGE : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); size_t count = extract_u32(data, offset, size) % (VecLen(vec) - index + 1); VecDeleteRange(vec, index, count); VecStr.c:225:
if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); size_t count = extract_u32(data, offset, size) % (VecLen(vec) - index + 1); VecDeleteRange(vec, index, count); } VecStr.c:233:
case VEC_STR_INSERT_FAST : { if (*offset + 4 <= size) { size_t index = extract_u32(data, offset, size) % (VecLen(vec) + 1); Str str = generate_str_from_input(data, offset, size, 32); VecInsertFast(vec, str, index); VecStr.c:241:
case VEC_STR_REMOVE_FAST : { if (VecLen(vec) > 0 && *offset + 4 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); Str str; VecStr.c:242:
case VEC_STR_REMOVE_FAST : { if (VecLen(vec) > 0 && *offset + 4 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); Str str; VecRemoveFast(vec, &str, index); VecStr.c:251:
case VEC_STR_REMOVE_RANGE_FAST : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); size_t count = extract_u32(data, offset, size) % (VecLen(vec) - index + 1); VecStr.c:252:
case VEC_STR_REMOVE_RANGE_FAST : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); size_t count = extract_u32(data, offset, size) % (VecLen(vec) - index + 1); VecRemoveRangeFast(vec, (Str *)NULL, index, count); VecStr.c:253:
if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); size_t count = extract_u32(data, offset, size) % (VecLen(vec) - index + 1); VecRemoveRangeFast(vec, (Str *)NULL, index, count); } VecStr.c:260:
case VEC_STR_DELETE_RANGE_FAST : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); size_t count = extract_u32(data, offset, size) % (VecLen(vec) - index + 1); VecStr.c:261:
case VEC_STR_DELETE_RANGE_FAST : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); size_t count = extract_u32(data, offset, size) % (VecLen(vec) - index + 1); VecDeleteRangeFast(vec, index, count); VecStr.c:262:
if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); size_t count = extract_u32(data, offset, size) % (VecLen(vec) - index + 1); VecDeleteRangeFast(vec, index, count); } VecStr.c:323:
case VEC_STR_BEGIN : { if (VecLen(vec) > 0) { Str *begin = VecBegin(vec); (void)begin; // Use the result to avoid warnings VecStr.c:331:
case VEC_STR_END : { if (VecLen(vec) > 0) { char *end = VecEnd(vec); (void)end; // Use the result to avoid warnings VecStr.c:339:
case VEC_STR_PTR_AT : { if (VecLen(vec) > 0 && *offset + 4 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); Str *ptr = VecPtrAt(vec, index); VecStr.c:340:
case VEC_STR_PTR_AT : { if (VecLen(vec) > 0 && *offset + 4 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); Str *ptr = VecPtrAt(vec, index); (void)ptr; // Use the result to avoid warnings VecStr.c:367:
case VEC_STR_INSERT_RANGE_FAST : { if (*offset + 8 <= size) { size_t index = extract_u32(data, offset, size) % (VecLen(vec) + 1); size_t count = extract_u32(data, offset, size) % 10; // Limit to reasonable count VecStr.c:383:
case VEC_STR_ALIGNED_OFFSET_AT : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); // Note: VecAlignedOffsetAt doesn't take alignment parameter VecStr.c:384:
case VEC_STR_ALIGNED_OFFSET_AT : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); // Note: VecAlignedOffsetAt doesn't take alignment parameter style=color:#75715e> size_t offset = VecAlignedOffsetAt(vec, index); VecStr.c:393:
case VEC_STR_DELETE_LAST : { if (VecLen(vec) > 0) { VecDeleteLast(vec); } VecStr.c:400:
case VEC_STR_DELETE_FAST : { if (VecLen(vec) > 0 && *offset + 4 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); VecDeleteFast(vec, index); VecStr.c:401:
case VEC_STR_DELETE_FAST : { if (VecLen(vec) > 0 && *offset + 4 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); VecDeleteFast(vec, index); } VecStr.c:427:
// Foreach operations style=color:#75715e> case VEC_STR_FOREACH : { if (VecLen(vec) > 0) { size_t total_len = 0; VecForeach(vec, str) { VecStr.c:438:
case VEC_STR_FOREACH_IDX : { if (VecLen(vec) > 0) { size_t total_len = 0; VecForeachIdx(vec, str, idx) { VecStr.c:449:
case VEC_STR_FOREACH_PTR : { if (VecLen(vec) > 0) { size_t total_len = 0; VecForeachPtr(vec, str_ptr) { VecStr.c:460:
case VEC_STR_FOREACH_PTR_IDX : { if (VecLen(vec) > 0) { size_t total_len = 0; VecForeachPtrIdx(vec, str_ptr, idx) { VecStr.c:471:
case VEC_STR_FOREACH_REVERSE : { if (VecLen(vec) > 0) { size_t total_len = 0; VecForeachReverse(vec, str) { VecStr.c:482:
case VEC_STR_FOREACH_REVERSE_IDX : { if (VecLen(vec) > 0) { size_t total_len = 0; VecForeachReverseIdx(vec, str, idx) { VecStr.c:493:
case VEC_STR_FOREACH_PTR_REVERSE : { if (VecLen(vec) > 0) { size_t total_len = 0; VecForeachPtrReverse(vec, str_ptr) { VecStr.c:504:
case VEC_STR_FOREACH_PTR_REVERSE_IDX : { if (VecLen(vec) > 0) { size_t total_len = 0; VecForeachPtrReverseIdx(vec, str_ptr, idx) { VecStr.c:515:
case VEC_STR_FOREACH_IN_RANGE : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t start = extract_u32(data, offset, size) % VecLen(vec); size_t end = extract_u32(data, offset, size) % (VecLen(vec) + 1); VecStr.c:516:
case VEC_STR_FOREACH_IN_RANGE : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t start = extract_u32(data, offset, size) % VecLen(vec); size_t end = extract_u32(data, offset, size) % (VecLen(vec) + 1); if (start < end) { VecStr.c:517:
if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t start = extract_u32(data, offset, size) % VecLen(vec); size_t end = extract_u32(data, offset, size) % (VecLen(vec) + 1); if (start < end) { size_t total_len = 0; VecStr.c:530:
case VEC_STR_FOREACH_IN_RANGE_IDX : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t start = extract_u32(data, offset, size) % VecLen(vec); size_t end = extract_u32(data, offset, size) % (VecLen(vec) + 1); VecStr.c:531:
case VEC_STR_FOREACH_IN_RANGE_IDX : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t start = extract_u32(data, offset, size) % VecLen(vec); size_t end = extract_u32(data, offset, size) % (VecLen(vec) + 1); if (start < end) { VecStr.c:532:
if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t start = extract_u32(data, offset, size) % VecLen(vec); size_t end = extract_u32(data, offset, size) % (VecLen(vec) + 1); if (start < end) { size_t total_len = 0; VecStr.c:545:
case VEC_STR_FOREACH_PTR_IN_RANGE : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t start = extract_u32(data, offset, size) % VecLen(vec); size_t end = extract_u32(data, offset, size) % (VecLen(vec) + 1); VecStr.c:546:
case VEC_STR_FOREACH_PTR_IN_RANGE : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t start = extract_u32(data, offset, size) % VecLen(vec); size_t end = extract_u32(data, offset, size) % (VecLen(vec) + 1); if (start < end) { VecStr.c:547:
if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t start = extract_u32(data, offset, size) % VecLen(vec); size_t end = extract_u32(data, offset, size) % (VecLen(vec) + 1); if (start < end) { size_t total_len = 0; VecStr.c:560:
case VEC_STR_FOREACH_PTR_IN_RANGE_IDX : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t start = extract_u32(data, offset, size) % VecLen(vec); size_t end = extract_u32(data, offset, size) % (VecLen(vec) + 1); VecStr.c:561:
case VEC_STR_FOREACH_PTR_IN_RANGE_IDX : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t start = extract_u32(data, offset, size) % VecLen(vec); size_t end = extract_u32(data, offset, size) % (VecLen(vec) + 1); if (start < end) { VecStr.c:562:
if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t start = extract_u32(data, offset, size) % VecLen(vec); size_t end = extract_u32(data, offset, size) % (VecLen(vec) + 1); if (start < end) { size_t total_len = 0; VecCharPtr.c:59:
case VEC_CHAR_PTR_POP_BACK : { if (VecLen(vec) > 0) { char *str; VecPopBack(vec, &str); VecCharPtr.c:68:
case VEC_CHAR_PTR_POP_FRONT : { if (VecLen(vec) > 0) { char *str; VecPopFront(vec, &str); VecCharPtr.c:78:
case VEC_CHAR_PTR_INSERT : { if (*offset + 4 <= size) { size_t index = extract_u32(data, offset, size) % (VecLen(vec) + 1); char *str = generate_cstring(data, offset, size, 32); if (str) { VecCharPtr.c:88:
case VEC_CHAR_PTR_REMOVE : { if (VecLen(vec) > 0 && *offset + 4 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); char *str; VecCharPtr.c:89:
case VEC_CHAR_PTR_REMOVE : { if (VecLen(vec) > 0 && *offset + 4 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); char *str; VecRemove(vec, &str, index); VecCharPtr.c:98:
case VEC_CHAR_PTR_DELETE : { if (VecLen(vec) > 0 && *offset + 4 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); VecDelete(vec, index); VecCharPtr.c:99:
case VEC_CHAR_PTR_DELETE : { if (VecLen(vec) > 0 && *offset + 4 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); VecDelete(vec, index); // char_ptr_deinit is called automatically by the vector VecCharPtr.c:107:
case VEC_CHAR_PTR_AT : { if (VecLen(vec) > 0 && *offset + 4 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); char *str = VecAt(vec, index); VecCharPtr.c:108:
case VEC_CHAR_PTR_AT : { if (VecLen(vec) > 0 && *offset + 4 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); char *str = VecAt(vec, index); (void)str; // Use the result to avoid warnings VecCharPtr.c:116:
case VEC_CHAR_PTR_LEN : { size_t len = VecLen(vec); (void)len; // Use the result to avoid warnings style=color:#75715e> break; VecCharPtr.c:122:
case VEC_CHAR_PTR_FIRST : { if (VecLen(vec) > 0) { char *first = VecFirst(vec); (void)first; // Use the result to avoid warnings VecCharPtr.c:130:
case VEC_CHAR_PTR_LAST : { if (VecLen(vec) > 0) { char *last = VecLast(vec); (void)last; // Use the result to avoid warnings VecCharPtr.c:146:
if (*offset + 4 <= size) { size_t new_size = extract_u32(data, offset, size) % 100; // Limit to reasonable size style=color:#75715e> size_t old_size = VecLen(vec); // VecResize automatically handles cleanup of removed elements and VecCharPtr.c:190:
case VEC_CHAR_PTR_SWAP_ITEMS : { if (VecLen(vec) >= 2 && *offset + 8 <= size) { size_t i = extract_u32(data, offset, size) % VecLen(vec); size_t j = extract_u32(data, offset, size) % VecLen(vec); VecCharPtr.c:191:
case VEC_CHAR_PTR_SWAP_ITEMS : { if (VecLen(vec) >= 2 && *offset + 8 <= size) { size_t i = extract_u32(data, offset, size) % VecLen(vec); size_t j = extract_u32(data, offset, size) % VecLen(vec); VecSwapItems(vec, i, j); VecCharPtr.c:192:
if (VecLen(vec) >= 2 && *offset + 8 <= size) { size_t i = extract_u32(data, offset, size) % VecLen(vec); size_t j = extract_u32(data, offset, size) % VecLen(vec); VecSwapItems(vec, i, j); } VecCharPtr.c:200:
case VEC_CHAR_PTR_INSERT_RANGE : { if (*offset + 8 <= size) { size_t index = extract_u32(data, offset, size) % (VecLen(vec) + 1); size_t count = extract_u32(data, offset, size) % 10; // Limit to reasonable count VecCharPtr.c:222:
case VEC_CHAR_PTR_REMOVE_RANGE : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); size_t count = extract_u32(data, offset, size) % (VecLen(vec) - index + 1); VecCharPtr.c:223:
case VEC_CHAR_PTR_REMOVE_RANGE : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); size_t count = extract_u32(data, offset, size) % (VecLen(vec) - index + 1); VecRemoveRange(vec, (char **)NULL, index, count); VecCharPtr.c:224:
if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); size_t count = extract_u32(data, offset, size) % (VecLen(vec) - index + 1); VecRemoveRange(vec, (char **)NULL, index, count); } VecCharPtr.c:231:
case VEC_CHAR_PTR_DELETE_RANGE : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); size_t count = extract_u32(data, offset, size) % (VecLen(vec) - index + 1); VecCharPtr.c:232:
case VEC_CHAR_PTR_DELETE_RANGE : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); size_t count = extract_u32(data, offset, size) % (VecLen(vec) - index + 1); VecDeleteRange(vec, index, count); VecCharPtr.c:233:
if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); size_t count = extract_u32(data, offset, size) % (VecLen(vec) - index + 1); VecDeleteRange(vec, index, count); } VecCharPtr.c:241:
case VEC_CHAR_PTR_INSERT_FAST : { if (*offset + 4 <= size) { size_t index = extract_u32(data, offset, size) % (VecLen(vec) + 1); char *str = generate_cstring(data, offset, size, 32); if (str) { VecCharPtr.c:251:
case VEC_CHAR_PTR_REMOVE_FAST : { if (VecLen(vec) > 0 && *offset + 4 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); char *str; VecCharPtr.c:252:
case VEC_CHAR_PTR_REMOVE_FAST : { if (VecLen(vec) > 0 && *offset + 4 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); char *str; VecRemoveFast(vec, &str, index); VecCharPtr.c:261:
case VEC_CHAR_PTR_REMOVE_RANGE_FAST : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); size_t count = extract_u32(data, offset, size) % (VecLen(vec) - index + 1); VecCharPtr.c:262:
case VEC_CHAR_PTR_REMOVE_RANGE_FAST : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); size_t count = extract_u32(data, offset, size) % (VecLen(vec) - index + 1); VecRemoveRangeFast(vec, (char **)NULL, index, count); VecCharPtr.c:263:
if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); size_t count = extract_u32(data, offset, size) % (VecLen(vec) - index + 1); VecRemoveRangeFast(vec, (char **)NULL, index, count); } VecCharPtr.c:270:
case VEC_CHAR_PTR_DELETE_RANGE_FAST : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); size_t count = extract_u32(data, offset, size) % (VecLen(vec) - index + 1); VecCharPtr.c:271:
case VEC_CHAR_PTR_DELETE_RANGE_FAST : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); size_t count = extract_u32(data, offset, size) % (VecLen(vec) - index + 1); VecDeleteRangeFast(vec, index, count); VecCharPtr.c:272:
if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); size_t count = extract_u32(data, offset, size) % (VecLen(vec) - index + 1); VecDeleteRangeFast(vec, index, count); } VecCharPtr.c:351:
case VEC_CHAR_PTR_BEGIN : { if (VecLen(vec) > 0) { char **begin = VecBegin(vec); (void)begin; // Use the result to avoid warnings VecCharPtr.c:359:
case VEC_CHAR_PTR_END : { if (VecLen(vec) > 0) { char *end = VecEnd(vec); (void)end; // Use the result to avoid warnings VecCharPtr.c:367:
case VEC_CHAR_PTR_PTR_AT : { if (VecLen(vec) > 0 && *offset + 4 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); char **ptr = VecPtrAt(vec, index); VecCharPtr.c:368:
case VEC_CHAR_PTR_PTR_AT : { if (VecLen(vec) > 0 && *offset + 4 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); char **ptr = VecPtrAt(vec, index); (void)ptr; // Use the result to avoid warnings VecCharPtr.c:397:
case VEC_CHAR_PTR_INSERT_RANGE_FAST : { if (*offset + 8 <= size) { size_t index = extract_u32(data, offset, size) % (VecLen(vec) + 1); size_t count = extract_u32(data, offset, size) % 10; // Limit to reasonable count VecCharPtr.c:419:
case VEC_CHAR_PTR_ALIGNED_OFFSET_AT : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); // Note: VecAlignedOffsetAt doesn't take alignment parameter VecCharPtr.c:420:
case VEC_CHAR_PTR_ALIGNED_OFFSET_AT : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); // Note: VecAlignedOffsetAt doesn't take alignment parameter style=color:#75715e> size_t offset = VecAlignedOffsetAt(vec, index); VecCharPtr.c:429:
case VEC_CHAR_PTR_DELETE_LAST : { if (VecLen(vec) > 0) { VecDeleteLast(vec); } VecCharPtr.c:436:
case VEC_CHAR_PTR_DELETE_FAST : { if (VecLen(vec) > 0 && *offset + 4 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); VecDeleteFast(vec, index); VecCharPtr.c:437:
case VEC_CHAR_PTR_DELETE_FAST : { if (VecLen(vec) > 0 && *offset + 4 <= size) { size_t index = extract_u32(data, offset, size) % VecLen(vec); VecDeleteFast(vec, index); } VecCharPtr.c:465:
// Foreach operations style=color:#75715e> case VEC_CHAR_PTR_FOREACH : { if (VecLen(vec) > 0) { size_t total_len = 0; VecForeach(vec, str) { VecCharPtr.c:476:
case VEC_CHAR_PTR_FOREACH_IDX : { if (VecLen(vec) > 0) { size_t total_len = 0; VecForeachIdx(vec, str, idx) { VecCharPtr.c:487:
case VEC_CHAR_PTR_FOREACH_PTR : { if (VecLen(vec) > 0) { size_t total_len = 0; VecForeachPtr(vec, str_ptr) { VecCharPtr.c:498:
case VEC_CHAR_PTR_FOREACH_PTR_IDX : { if (VecLen(vec) > 0) { size_t total_len = 0; VecForeachPtrIdx(vec, str_ptr, idx) { VecCharPtr.c:509:
case VEC_CHAR_PTR_FOREACH_REVERSE : { if (VecLen(vec) > 0) { size_t total_len = 0; VecForeachReverse(vec, str) { VecCharPtr.c:520:
case VEC_CHAR_PTR_FOREACH_REVERSE_IDX : { if (VecLen(vec) > 0) { size_t total_len = 0; VecForeachReverseIdx(vec, str, idx) { VecCharPtr.c:531:
case VEC_CHAR_PTR_FOREACH_PTR_REVERSE : { if (VecLen(vec) > 0) { size_t total_len = 0; VecForeachPtrReverse(vec, str_ptr) { VecCharPtr.c:542:
case VEC_CHAR_PTR_FOREACH_PTR_REVERSE_IDX : { if (VecLen(vec) > 0) { size_t total_len = 0; VecForeachPtrReverseIdx(vec, str_ptr, idx) { VecCharPtr.c:553:
case VEC_CHAR_PTR_FOREACH_IN_RANGE : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t start = extract_u32(data, offset, size) % VecLen(vec); size_t end = extract_u32(data, offset, size) % (VecLen(vec) + 1); VecCharPtr.c:554:
case VEC_CHAR_PTR_FOREACH_IN_RANGE : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t start = extract_u32(data, offset, size) % VecLen(vec); size_t end = extract_u32(data, offset, size) % (VecLen(vec) + 1); if (start < end) { VecCharPtr.c:555:
if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t start = extract_u32(data, offset, size) % VecLen(vec); size_t end = extract_u32(data, offset, size) % (VecLen(vec) + 1); if (start < end) { size_t total_len = 0; VecCharPtr.c:568:
case VEC_CHAR_PTR_FOREACH_IN_RANGE_IDX : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t start = extract_u32(data, offset, size) % VecLen(vec); size_t end = extract_u32(data, offset, size) % (VecLen(vec) + 1); VecCharPtr.c:569:

    case VEC_CHAR_PTR_FOREACH_IN_RANGE_IDX : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t start = extract_u32(data, offset, size) % VecLen(vec); size_t end   = extract_u32(data, offset, size) % (VecLen(vec) + 1); if (start < end) { VecCharPtr.c:570:

    if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t start = extract_u32(data, offset, size) % VecLen(vec); size_t end   = extract_u32(data, offset, size) % (VecLen(vec) + 1); if (start < end) { size_t total_len = 0; VecCharPtr.c:583:

 case VEC_CHAR_PTR_FOREACH_PTR_IN_RANGE : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t start = extract_u32(data, offset, size) % VecLen(vec); size_t end   = extract_u32(data, offset, size) % (VecLen(vec) + 1); VecCharPtr.c:584:    case VEC_CHAR_PTR_FOREACH_PTR_IN_RANGE : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t start = extract_u32(data, offset, size) % VecLen(vec); size_t end   = extract_u32(data, offset, size) % (VecLen(vec) + 1); if (start < end) { VecCharPtr.c:585:    if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t start = extract_u32(data, offset, size) % VecLen(vec); size_t end   = extract_u32(data, offset, size) % (VecLen(vec) + 1); if (start < end) { size_t total_len = 0; VecCharPtr.c:598: case VEC_CHAR_PTR_FOREACH_PTR_IN_RANGE_IDX : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t start = extract_u32(data, offset, size) % VecLen(vec); size_t end   = extract_u32(data, offset, size) % (VecLen(vec) + 1); VecCharPtr.c:599:    case VEC_CHAR_PTR_FOREACH_PTR_IN_RANGE_IDX : { if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t start = extract_u32(data, offset, size) % VecLen(vec); size_t end   = extract_u32(data, offset, size) % (VecLen(vec) + 1); if (start < end) { VecCharPtr.c:600:    if (VecLen(vec) > 0 && *offset + 8 <= size) { size_t start = extract_u32(data, offset, size) % VecLen(vec); size_t end   = extract_u32(data, offset, size) % (VecLen(vec) + 1); if (start < end) { size_t total_len = 0;
Share :