From aa04fab6ea5b7569f220ffd0d540fa2586695155 Mon Sep 17 00:00:00 2001 From: Abdelrahman Said Date: Wed, 16 Apr 2025 10:05:42 +0100 Subject: [PATCH] Update codegen --- codegen/__main__.py | 12 ++- codegen/datatypes.py | 2 +- codegen/utils.py | 2 +- src/core/os/cpath/cpath.c | 12 +-- src/core/strings/str8/str8.c | 26 +++++-- src/core/strings/str8/str8_list.c | 18 ++--- tests/str8/test_str8.c | 24 +++--- tests/str8/test_str8_list.c | 124 +++++++++++++++--------------- 8 files changed, 119 insertions(+), 101 deletions(-) diff --git a/codegen/__main__.py b/codegen/__main__.py index 9135022..ee75b61 100644 --- a/codegen/__main__.py +++ b/codegen/__main__.py @@ -1,8 +1,16 @@ -from codegen.dbl_list.gen_dbl_list import gen_dbl_list +from pathlib import Path +from codegen.datatypes import CDataType +from codegen.dbl_list.gen_dbl_list import DblListData, gen_dbl_list def main(): - gen_dbl_list() + datatypes: dict[CDataType, DblListData] = { + "int": DblListData( + out_dir=Path("/Users/abdelrahman/dev/personal/wizapp-stdlib"), + ), + } + + gen_dbl_list(datatypes) if __name__ == "__main__": diff --git a/codegen/datatypes.py b/codegen/datatypes.py index 58e5baa..fab1b9d 100644 --- a/codegen/datatypes.py +++ b/codegen/datatypes.py @@ -162,7 +162,7 @@ class CFunc: return f"{str(self)};\n" def define(self) -> str: - return f"{str(self)} {{\n{self.body}}}\n\n" + return f"{str(self)} {{\n{self.body}\n}}\n\n" @dataclass diff --git a/codegen/utils.py b/codegen/utils.py index 5247512..47b6b16 100644 --- a/codegen/utils.py +++ b/codegen/utils.py @@ -3,4 +3,4 @@ from pathlib import Path def load_func_body_from_file(filename: Path) -> str: with open(filename, "r") as infile: - return infile.read() + return infile.read().strip() diff --git a/src/core/os/cpath/cpath.c b/src/core/os/cpath/cpath.c index e234448..69414ca 100644 --- a/src/core/os/cpath/cpath.c +++ b/src/core/os/cpath/cpath.c @@ -21,14 +21,14 @@ u32 wapp_cpath_join_path(Str8 *dst, const Str8List *parts) { Str8 separator = wapp_str8_buf(4); wapp_str8_push_back(&separator, PATH_SEP); - u64 required_capacity = parts->node_count * separator.size + parts->total_size; + u64 required_capacity = parts->node_count * separator.size + wapp_str8_list_total_size(parts); if (dst->capacity < required_capacity) { return CPATH_JOIN_INSUFFICIENT_DST_CAPACITY; } // Handle first node const Str8Node *first_node = wapp_str8_list_get(parts, 0); - wapp_str8_copy_str8_capped(dst, first_node->string); + wapp_str8_copy_str8_capped(dst, first_node->item); // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of // MSVC Spectre mitigation warnings @@ -37,13 +37,13 @@ u32 wapp_cpath_join_path(Str8 *dst, const Str8List *parts) { bool running = true; while (running && node->next) { node = node->next; - if (node->string->size == 0) { + if (node->item->size == 0) { continue; } if (dst->size > 0) { char dst_last = wapp_str8_get(dst, dst->size - 1); - char node_start = wapp_str8_get(node->string, 0); + char node_start = wapp_str8_get(node->item, 0); bool add_path_sep = dst_last != PATH_SEP && node_start != PATH_SEP; if (add_path_sep) { @@ -51,7 +51,7 @@ u32 wapp_cpath_join_path(Str8 *dst, const Str8List *parts) { } } - wapp_str8_concat_capped(dst, node->string); + wapp_str8_concat_capped(dst, node->item); ++node_index; running = node_index < parts->node_count; @@ -108,7 +108,7 @@ Str8 *dirup(const Allocator *allocator, Str8RO *path, u64 levels) { } u64 alignment = sizeof(void *) * 2; - u64 alloc_size = parts->total_size + parts->node_count * separator.size; + u64 alloc_size = wapp_str8_list_total_size(parts) + parts->node_count * separator.size; u64 modulo = alloc_size & (alignment - 1); alloc_size += alignment - modulo; diff --git a/src/core/strings/str8/str8.c b/src/core/strings/str8/str8.c index b86e2ac..fb6900b 100644 --- a/src/core/strings/str8/str8.c +++ b/src/core/strings/str8/str8.c @@ -311,7 +311,7 @@ Str8List *wapp_str8_split_with_max(const Allocator *allocator, Str8RO *str, Str8 Str8 *full = wapp_str8_alloc_str8(allocator, str); Str8Node *node = wapp_mem_allocator_alloc(allocator, sizeof(Str8Node)); if (node) { - node->string = full; + node->item = full; wapp_str8_list_push_back(output, node); } @@ -332,7 +332,7 @@ Str8List *wapp_str8_split_with_max(const Allocator *allocator, Str8RO *str, Str8 before_str = wapp_str8_alloc_substr(allocator, str, start, start + end); Str8Node *node = wapp_mem_allocator_alloc(allocator, sizeof(Str8Node)); if (node) { - node->string = before_str; + node->item = before_str; wapp_str8_list_push_back(output, node); } @@ -347,7 +347,7 @@ Str8List *wapp_str8_split_with_max(const Allocator *allocator, Str8RO *str, Str8 rest = wapp_str8_alloc_substr(allocator, str, start, str->size); Str8Node *node = wapp_mem_allocator_alloc(allocator, sizeof(Str8Node)); if (node) { - node->string = rest; + node->item = rest; wapp_str8_list_push_back(output, node); } @@ -366,7 +366,7 @@ Str8List *wapp_str8_rsplit_with_max(const Allocator *allocator, Str8RO *str, Str Str8 *full = wapp_str8_alloc_str8(allocator, str); Str8Node *node = wapp_mem_allocator_alloc(allocator, sizeof(Str8Node)); if (node) { - node->string = full; + node->item = full; wapp_str8_list_push_back(output, node); } @@ -386,7 +386,7 @@ Str8List *wapp_str8_rsplit_with_max(const Allocator *allocator, Str8RO *str, Str after_str = wapp_str8_alloc_substr(allocator, rest, end + delimiter->size, str->size); Str8Node *node = wapp_mem_allocator_alloc(allocator, sizeof(Str8Node)); if (node) { - node->string = after_str; + node->item = after_str; wapp_str8_list_push_front(output, node); } @@ -399,7 +399,7 @@ Str8List *wapp_str8_rsplit_with_max(const Allocator *allocator, Str8RO *str, Str rest = wapp_str8_alloc_substr(allocator, str, 0, rest->size); Str8Node *node = wapp_mem_allocator_alloc(allocator, sizeof(Str8Node)); if (node) { - node->string = rest; + node->item = rest; wapp_str8_list_push_front(output, node); } @@ -412,7 +412,7 @@ Str8 *wapp_str8_join(const Allocator *allocator, const Str8List *list, Str8RO *d return NULL; } - u64 capacity = list->total_size + (delimiter->size * (list->node_count - 1)); + u64 capacity = wapp_str8_list_total_size(list) + (delimiter->size * (list->node_count - 1)); Str8 *output = wapp_str8_alloc_buf(allocator, capacity * 2); // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of @@ -422,7 +422,7 @@ Str8 *wapp_str8_join(const Allocator *allocator, const Str8List *list, Str8RO *d bool running = true; while (running) { node = wapp_str8_list_get(list, node_index); - wapp_str8_concat_capped(output, node->string); + wapp_str8_concat_capped(output, node->item); if (node_index + 1 < list->node_count) { wapp_str8_concat_capped(output, delimiter); } @@ -435,5 +435,15 @@ Str8 *wapp_str8_join(const Allocator *allocator, const Str8List *list, Str8RO *d } u64 wapp_str8_list_total_size(const Str8List *list) { + if (!list) { + return 0; + } + u64 output = 0; + for (u64 i = 0; i < list->node_count; ++i) { + Str8Node *node = wapp_str8_list_get(list, i); + output += node->item->size; + } + + return output; } diff --git a/src/core/strings/str8/str8_list.c b/src/core/strings/str8/str8_list.c index 98f9f94..a648311 100644 --- a/src/core/strings/str8/str8_list.c +++ b/src/core/strings/str8/str8_list.c @@ -10,7 +10,7 @@ internal Str8List str8_node_to_list(Str8Node *node); Str8Node *wapp_str8_list_get(const Str8List *list, u64 index) { - if (index >= list->node_count) { +if (index >= list->node_count) { return NULL; } @@ -26,7 +26,7 @@ Str8Node *wapp_str8_list_get(const Str8List *list, u64 index) { } void wapp_str8_list_push_front(Str8List *list, Str8Node *node) { - if (!list || !node || !(node->item)) { +if (!list || !node || !(node->item)) { return; } @@ -49,7 +49,7 @@ void wapp_str8_list_push_front(Str8List *list, Str8Node *node) { } void wapp_str8_list_push_back(Str8List *list, Str8Node *node) { - if (!list || !node || !(node->item)) { +if (!list || !node || !(node->item)) { return; } @@ -72,7 +72,7 @@ void wapp_str8_list_push_back(Str8List *list, Str8Node *node) { } void wapp_str8_list_insert(Str8List *list, Str8Node *node, u64 index) { - if (!list || !node || !(node->item)) { +if (!list || !node || !(node->item)) { return; } @@ -103,7 +103,7 @@ void wapp_str8_list_insert(Str8List *list, Str8Node *node, u64 index) { } Str8Node *wapp_str8_list_pop_front(Str8List *list) { - Str8Node *output = NULL; +Str8Node *output = NULL; if (!list || list->node_count == 0) { goto RETURN_STR8_LIST_POP_FRONT; @@ -126,7 +126,7 @@ RETURN_STR8_LIST_POP_FRONT: } Str8Node *wapp_str8_list_pop_back(Str8List *list) { - Str8Node *output = NULL; +Str8Node *output = NULL; if (!list || list->node_count == 0) { goto RETURN_STR8_LIST_POP_BACK; @@ -149,7 +149,7 @@ RETURN_STR8_LIST_POP_BACK: } Str8Node *wapp_str8_list_remove(Str8List *list, u64 index) { - Str8Node *output = NULL; +Str8Node *output = NULL; if (!list) { goto RETURN_STR8_LIST_REMOVE; } @@ -179,7 +179,7 @@ RETURN_STR8_LIST_REMOVE: } void wapp_str8_list_empty(Str8List *list) { - if (!list) { +if (!list) { return; } @@ -190,7 +190,7 @@ void wapp_str8_list_empty(Str8List *list) { } internal Str8List str8_node_to_list(Str8Node *node) { - Str8List output = {.first = node, .last = node, .node_count = 1}; +Str8List output = {.first = node, .last = node, .node_count = 1}; while (output.first->prev != NULL) { output.first = output.first->prev; diff --git a/tests/str8/test_str8.c b/tests/str8/test_str8.c index adf41af..053c1da 100644 --- a/tests/str8/test_str8.c +++ b/tests/str8/test_str8.c @@ -438,14 +438,14 @@ TestFuncResult test_str8_split(void) { u64 count2 = ARRLEN(splits2); bool running2 = true; - result = list1->node_count == count1 && list1->total_size == str.size - 3; - result = result && list2->node_count == count2 && list2->total_size == str.size - 4; + result = list1->node_count == count1 && wapp_str8_list_total_size(list1) == str.size - 3; + result = result && list2->node_count == count2 && wapp_str8_list_total_size(list2) == str.size - 4; // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of // MSVC Spectre mitigation warnings while (running1) { Str8Node *node = wapp_str8_list_get(list1, index1); - result = result && wapp_str8_equal(node->string, &(splits1[index1])); + result = result && wapp_str8_equal(node->item, &(splits1[index1])); ++index1; running1 = index1 < count1; @@ -455,7 +455,7 @@ TestFuncResult test_str8_split(void) { // MSVC Spectre mitigation warnings while (running2) { Str8Node *node = wapp_str8_list_get(list2, index2); - result = result && wapp_str8_equal(node->string, &(splits2[index2])); + result = result && wapp_str8_equal(node->item, &(splits2[index2])); ++index2; running2 = index2 < count2; @@ -484,13 +484,13 @@ TestFuncResult test_str8_split_with_max(void) { u64 count = ARRLEN(splits); bool running = true; - result = list->node_count == count && list->total_size == str.size - 2; + result = list->node_count == count && wapp_str8_list_total_size(list) == str.size - 2; // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of // MSVC Spectre mitigation warnings while (running) { Str8Node *node = wapp_str8_list_get(list, index); - result = result && wapp_str8_equal(node->string, &(splits[index])); + result = result && wapp_str8_equal(node->item, &(splits[index])); ++index; running = index < count; @@ -530,14 +530,14 @@ TestFuncResult test_str8_rsplit(void) { u64 count2 = ARRLEN(splits2); bool running2 = true; - result = list1->node_count == count1 && list1->total_size == str.size - 3; - result = result && list2->node_count == count2 && list2->total_size == str.size - 4; + result = list1->node_count == count1 && wapp_str8_list_total_size(list1) == str.size - 3; + result = result && list2->node_count == count2 && wapp_str8_list_total_size(list2) == str.size - 4; // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of // MSVC Spectre mitigation warnings while (running1) { Str8Node *node = wapp_str8_list_get(list1, index1); - result = result && wapp_str8_equal(node->string, &(splits1[index1])); + result = result && wapp_str8_equal(node->item, &(splits1[index1])); ++index1; running1 = index1 < count1; @@ -547,7 +547,7 @@ TestFuncResult test_str8_rsplit(void) { // MSVC Spectre mitigation warnings while (running2) { Str8Node *node = wapp_str8_list_get(list2, index2); - result = result && wapp_str8_equal(node->string, &(splits2[index2])); + result = result && wapp_str8_equal(node->item, &(splits2[index2])); ++index2; running2 = index2 < count2; @@ -576,13 +576,13 @@ TestFuncResult test_str8_rsplit_with_max(void) { u64 count = ARRLEN(splits); bool running = true; - result = list->node_count == count && list->total_size == str.size - 2; + result = list->node_count == count && wapp_str8_list_total_size(list) == str.size - 2; // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of // MSVC Spectre mitigation warnings while (running) { Str8Node *node = wapp_str8_list_get(list, index); - result = result && wapp_str8_equal(node->string, &(splits[index])); + result = result && wapp_str8_equal(node->item, &(splits[index])); ++index; running = index < count; diff --git a/tests/str8/test_str8_list.c b/tests/str8/test_str8_list.c index b11ded9..d47e55c 100644 --- a/tests/str8/test_str8_list.c +++ b/tests/str8/test_str8_list.c @@ -11,11 +11,11 @@ TestFuncResult test_str8_list_get(void) { Str8 s5 = wapp_str8_lit("5"); Str8List list = {0}; - Str8Node n1 = { .string = &s1 }; - Str8Node n2 = { .string = &s2 }; - Str8Node n3 = { .string = &s3 }; - Str8Node n4 = { .string = &s4 }; - Str8Node n5 = { .string = &s5 }; + Str8Node n1 = { .item = &s1 }; + Str8Node n2 = { .item = &s2 }; + Str8Node n3 = { .item = &s3 }; + Str8Node n4 = { .item = &s4 }; + Str8Node n5 = { .item = &s5 }; wapp_str8_list_push_back(&list, &n1); wapp_str8_list_push_back(&list, &n2); @@ -24,19 +24,19 @@ TestFuncResult test_str8_list_get(void) { wapp_str8_list_push_back(&list, &n5); Str8Node *node = wapp_str8_list_get(&list, 0); - result = node->string == &s1 && wapp_str8_equal(node->string, &s1); + result = node->item == &s1 && wapp_str8_equal(node->item, &s1); node = wapp_str8_list_get(&list, 1); - result = result && node->string == &s2 && wapp_str8_equal(node->string, &s2); + result = result && node->item == &s2 && wapp_str8_equal(node->item, &s2); node = wapp_str8_list_get(&list, 2); - result = result && node->string == &s3 && wapp_str8_equal(node->string, &s3); + result = result && node->item == &s3 && wapp_str8_equal(node->item, &s3); node = wapp_str8_list_get(&list, 3); - result = result && node->string == &s4 && wapp_str8_equal(node->string, &s4); + result = result && node->item == &s4 && wapp_str8_equal(node->item, &s4); node = wapp_str8_list_get(&list, 4); - result = result && node->string == &s5 && wapp_str8_equal(node->string, &s5); + result = result && node->item == &s5 && wapp_str8_equal(node->item, &s5); return wapp_tester_result(result); } @@ -49,18 +49,18 @@ TestFuncResult test_str8_list_push_front(void) { Str8 s3 = wapp_str8_lit("3"); Str8List list = {0}; - Str8Node n1 = { .string = &s1 }; - Str8Node n2 = { .string = &s2 }; - Str8Node n3 = { .string = &s3 }; + Str8Node n1 = { .item = &s1 }; + Str8Node n2 = { .item = &s2 }; + Str8Node n3 = { .item = &s3 }; wapp_str8_list_push_front(&list, &n1); - result = list.first == list.last && list.first == &n1 && list.first->string == &s1 && list.total_size == 1 && list.node_count == 1; + result = list.first == list.last && list.first == &n1 && list.first->item == &s1 && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1; wapp_str8_list_push_front(&list, &n2); - result = result && list.first == &n2 && list.first->string == &s2 && list.total_size == 2 && list.node_count == 2; + result = result && list.first == &n2 && list.first->item == &s2 && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2; wapp_str8_list_push_front(&list, &n3); - result = result && list.first == &n3 && list.first->string == &s3 && list.total_size == 3 && list.node_count == 3; + result = result && list.first == &n3 && list.first->item == &s3 && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3; return wapp_tester_result(result); } @@ -73,18 +73,18 @@ TestFuncResult test_str8_list_push_back(void) { Str8 s3 = wapp_str8_lit("3"); Str8List list = {0}; - Str8Node n1 = { .string = &s1 }; - Str8Node n2 = { .string = &s2 }; - Str8Node n3 = { .string = &s3 }; + Str8Node n1 = { .item = &s1 }; + Str8Node n2 = { .item = &s2 }; + Str8Node n3 = { .item = &s3 }; wapp_str8_list_push_back(&list, &n1); - result = list.first == list.last && list.last == &n1 && list.last->string == &s1 && list.total_size == 1 && list.node_count == 1; + result = list.first == list.last && list.last == &n1 && list.last->item == &s1 && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1; wapp_str8_list_push_back(&list, &n2); - result = result && list.last == &n2 && list.last->string == &s2 && list.total_size == 2 && list.node_count == 2; + result = result && list.last == &n2 && list.last->item == &s2 && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2; wapp_str8_list_push_back(&list, &n3); - result = result && list.last == &n3 && list.last->string == &s3 && list.total_size == 3 && list.node_count == 3; + result = result && list.last == &n3 && list.last->item == &s3 && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3; return wapp_tester_result(result); } @@ -101,13 +101,13 @@ TestFuncResult test_str8_list_insert(void) { Str8 s7 = wapp_str8_lit("7"); Str8List list = {0}; - Str8Node n1 = { .string = &s1 }; - Str8Node n2 = { .string = &s2 }; - Str8Node n3 = { .string = &s3 }; - Str8Node n4 = { .string = &s4 }; - Str8Node n5 = { .string = &s5 }; - Str8Node n6 = { .string = &s6 }; - Str8Node n7 = { .string = &s7 }; + Str8Node n1 = { .item = &s1 }; + Str8Node n2 = { .item = &s2 }; + Str8Node n3 = { .item = &s3 }; + Str8Node n4 = { .item = &s4 }; + Str8Node n5 = { .item = &s5 }; + Str8Node n6 = { .item = &s6 }; + Str8Node n7 = { .item = &s7 }; wapp_str8_list_push_back(&list, &n1); wapp_str8_list_push_back(&list, &n2); @@ -118,10 +118,10 @@ TestFuncResult test_str8_list_insert(void) { Str8Node *node; wapp_str8_list_insert(&list, &n6, 2); node = wapp_str8_list_get(&list, 2); - result = node != NULL && node->string == &s6 && list.total_size == 6 && list.node_count == 6; + result = node != NULL && node->item == &s6 && wapp_str8_list_total_size(&list) == 6 && list.node_count == 6; wapp_str8_list_insert(&list, &n7, 5); node = wapp_str8_list_get(&list, 5); - result = result && node != NULL && node->string == &s7 && list.total_size == 7 && list.node_count == 7; + result = result && node != NULL && node->item == &s7 && wapp_str8_list_total_size(&list) == 7 && list.node_count == 7; return wapp_tester_result(result); } @@ -136,11 +136,11 @@ TestFuncResult test_str8_list_pop_front(void) { Str8 s5 = wapp_str8_lit("5"); Str8List list = {0}; - Str8Node n1 = { .string = &s1 }; - Str8Node n2 = { .string = &s2 }; - Str8Node n3 = { .string = &s3 }; - Str8Node n4 = { .string = &s4 }; - Str8Node n5 = { .string = &s5 }; + Str8Node n1 = { .item = &s1 }; + Str8Node n2 = { .item = &s2 }; + Str8Node n3 = { .item = &s3 }; + Str8Node n4 = { .item = &s4 }; + Str8Node n5 = { .item = &s5 }; wapp_str8_list_push_back(&list, &n1); wapp_str8_list_push_back(&list, &n2); @@ -149,19 +149,19 @@ TestFuncResult test_str8_list_pop_front(void) { wapp_str8_list_push_back(&list, &n5); Str8Node *node = wapp_str8_list_pop_front(&list); - result = node == &n1 && node->string == &s1 && wapp_str8_equal(node->string, &s1) && list.total_size == 4 && list.node_count == 4; + result = node == &n1 && node->item == &s1 && wapp_str8_equal(node->item, &s1) && wapp_str8_list_total_size(&list) == 4 && list.node_count == 4; node = wapp_str8_list_pop_front(&list); - result = result && node == &n2 && node->string == &s2 && wapp_str8_equal(node->string, &s2) && list.total_size == 3 && list.node_count == 3; + result = result && node == &n2 && node->item == &s2 && wapp_str8_equal(node->item, &s2) && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3; node = wapp_str8_list_pop_front(&list); - result = result && node == &n3 && node->string == &s3 && wapp_str8_equal(node->string, &s3) && list.total_size == 2 && list.node_count == 2; + result = result && node == &n3 && node->item == &s3 && wapp_str8_equal(node->item, &s3) && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2; node = wapp_str8_list_pop_front(&list); - result = result && node == &n4 && node->string == &s4 && wapp_str8_equal(node->string, &s4) && list.total_size == 1 && list.node_count == 1; + result = result && node == &n4 && node->item == &s4 && wapp_str8_equal(node->item, &s4) && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1; node = wapp_str8_list_pop_front(&list); - result = result && node == &n5 && node->string == &s5 && wapp_str8_equal(node->string, &s5) && list.total_size == 0 && list.node_count == 0; + result = result && node == &n5 && node->item == &s5 && wapp_str8_equal(node->item, &s5) && wapp_str8_list_total_size(&list) == 0 && list.node_count == 0; return wapp_tester_result(result); } @@ -176,11 +176,11 @@ TestFuncResult test_str8_list_pop_back(void) { Str8 s5 = wapp_str8_lit("5"); Str8List list = {0}; - Str8Node n1 = { .string = &s1 }; - Str8Node n2 = { .string = &s2 }; - Str8Node n3 = { .string = &s3 }; - Str8Node n4 = { .string = &s4 }; - Str8Node n5 = { .string = &s5 }; + Str8Node n1 = { .item = &s1 }; + Str8Node n2 = { .item = &s2 }; + Str8Node n3 = { .item = &s3 }; + Str8Node n4 = { .item = &s4 }; + Str8Node n5 = { .item = &s5 }; wapp_str8_list_push_front(&list, &n1); wapp_str8_list_push_front(&list, &n2); @@ -189,19 +189,19 @@ TestFuncResult test_str8_list_pop_back(void) { wapp_str8_list_push_front(&list, &n5); Str8Node *node = wapp_str8_list_pop_back(&list); - result = node == &n1 && node->string == &s1 && wapp_str8_equal(node->string, &s1) && list.total_size == 4 && list.node_count == 4; + result = node == &n1 && node->item == &s1 && wapp_str8_equal(node->item, &s1) && wapp_str8_list_total_size(&list) == 4 && list.node_count == 4; node = wapp_str8_list_pop_back(&list); - result = result && node == &n2 && node->string == &s2 && wapp_str8_equal(node->string, &s2) && list.total_size == 3 && list.node_count == 3; + result = result && node == &n2 && node->item == &s2 && wapp_str8_equal(node->item, &s2) && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3; node = wapp_str8_list_pop_back(&list); - result = result && node == &n3 && node->string == &s3 && wapp_str8_equal(node->string, &s3) && list.total_size == 2 && list.node_count == 2; + result = result && node == &n3 && node->item == &s3 && wapp_str8_equal(node->item, &s3) && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2; node = wapp_str8_list_pop_back(&list); - result = result && node == &n4 && node->string == &s4 && wapp_str8_equal(node->string, &s4) && list.total_size == 1 && list.node_count == 1; + result = result && node == &n4 && node->item == &s4 && wapp_str8_equal(node->item, &s4) && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1; node = wapp_str8_list_pop_back(&list); - result = result && node == &n5 && node->string == &s5 && wapp_str8_equal(node->string, &s5) && list.total_size == 0 && list.node_count == 0; + result = result && node == &n5 && node->item == &s5 && wapp_str8_equal(node->item, &s5) && wapp_str8_list_total_size(&list) == 0 && list.node_count == 0; return wapp_tester_result(result); } @@ -216,11 +216,11 @@ TestFuncResult test_str8_list_remove(void) { Str8 s5 = wapp_str8_lit("5"); Str8List list = {0}; - Str8Node n1 = { .string = &s1 }; - Str8Node n2 = { .string = &s2 }; - Str8Node n3 = { .string = &s3 }; - Str8Node n4 = { .string = &s4 }; - Str8Node n5 = { .string = &s5 }; + Str8Node n1 = { .item = &s1 }; + Str8Node n2 = { .item = &s2 }; + Str8Node n3 = { .item = &s3 }; + Str8Node n4 = { .item = &s4 }; + Str8Node n5 = { .item = &s5 }; wapp_str8_list_push_back(&list, &n1); wapp_str8_list_push_back(&list, &n2); @@ -229,19 +229,19 @@ TestFuncResult test_str8_list_remove(void) { wapp_str8_list_push_back(&list, &n5); Str8Node *node = wapp_str8_list_remove(&list, 0); - result = node == &n1 && node->string == &s1 && wapp_str8_equal(node->string, &s1) && list.total_size == 4 && list.node_count == 4; + result = node == &n1 && node->item == &s1 && wapp_str8_equal(node->item, &s1) && wapp_str8_list_total_size(&list) == 4 && list.node_count == 4; node = wapp_str8_list_remove(&list, 0); - result = result && node == &n2 && node->string == &s2 && wapp_str8_equal(node->string, &s2) && list.total_size == 3 && list.node_count == 3; + result = result && node == &n2 && node->item == &s2 && wapp_str8_equal(node->item, &s2) && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3; node = wapp_str8_list_remove(&list, 0); - result = result && node == &n3 && node->string == &s3 && wapp_str8_equal(node->string, &s3) && list.total_size == 2 && list.node_count == 2; + result = result && node == &n3 && node->item == &s3 && wapp_str8_equal(node->item, &s3) && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2; node = wapp_str8_list_remove(&list, 0); - result = result && node == &n4 && node->string == &s4 && wapp_str8_equal(node->string, &s4) && list.total_size == 1 && list.node_count == 1; + result = result && node == &n4 && node->item == &s4 && wapp_str8_equal(node->item, &s4) && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1; node = wapp_str8_list_remove(&list, 0); - result = result && node == &n5 && node->string == &s5 && wapp_str8_equal(node->string, &s5) && list.total_size == 0 && list.node_count == 0; + result = result && node == &n5 && node->item == &s5 && wapp_str8_equal(node->item, &s5) && wapp_str8_list_total_size(&list) == 0 && list.node_count == 0; return wapp_tester_result(result); } @@ -257,7 +257,7 @@ TestFuncResult test_str8_list_empty(void) { wapp_str8_list_empty(&list); - result = list.first == NULL && list.last == NULL && list.node_count == 0 && list.total_size == 0; + result = list.first == NULL && list.last == NULL && list.node_count == 0 && wapp_str8_list_total_size(&list) == 0; return wapp_tester_result(result); }