Update codegen

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__":

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

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()

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;
 

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;
 }

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;

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 = list1->node_count == count1 && wapp_str8_list_total_size(list1) == str.size - 3;
-  result = result && list2->node_count == count2 && list2->total_size == str.size - 4;
+  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 = list1->node_count == count1 && wapp_str8_list_total_size(list1) == str.size - 3;
-  result = result && list2->node_count == count2 && list2->total_size == str.size - 4;
+  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;

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 n1   = { .item = &s1 };
-  Str8Node n2   = { .string = &s2 };
+  Str8Node n2   = { .item = &s2 };
-  Str8Node n3   = { .string = &s3 };
+  Str8Node n3   = { .item = &s3 };
-  Str8Node n4   = { .string = &s4 };
+  Str8Node n4   = { .item = &s4 };
-  Str8Node n5   = { .string = &s5 };
+  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 n1   = { .item = &s1 };
-  Str8Node n2   = { .string = &s2 };
+  Str8Node n2   = { .item = &s2 };
-  Str8Node n3   = { .string = &s3 };
+  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 n1   = { .item = &s1 };
-  Str8Node n2   = { .string = &s2 };
+  Str8Node n2   = { .item = &s2 };
-  Str8Node n3   = { .string = &s3 };
+  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 n1   = { .item = &s1 };
-  Str8Node n2   = { .string = &s2 };
+  Str8Node n2   = { .item = &s2 };
-  Str8Node n3   = { .string = &s3 };
+  Str8Node n3   = { .item = &s3 };
-  Str8Node n4   = { .string = &s4 };
+  Str8Node n4   = { .item = &s4 };
-  Str8Node n5   = { .string = &s5 };
+  Str8Node n5   = { .item = &s5 };
-  Str8Node n6   = { .string = &s6 };
+  Str8Node n6   = { .item = &s6 };
-  Str8Node n7   = { .string = &s7 };
+  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 n1   = { .item = &s1 };
-  Str8Node n2   = { .string = &s2 };
+  Str8Node n2   = { .item = &s2 };
-  Str8Node n3   = { .string = &s3 };
+  Str8Node n3   = { .item = &s3 };
-  Str8Node n4   = { .string = &s4 };
+  Str8Node n4   = { .item = &s4 };
-  Str8Node n5   = { .string = &s5 };
+  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 n1   = { .item = &s1 };
-  Str8Node n2   = { .string = &s2 };
+  Str8Node n2   = { .item = &s2 };
-  Str8Node n3   = { .string = &s3 };
+  Str8Node n3   = { .item = &s3 };
-  Str8Node n4   = { .string = &s4 };
+  Str8Node n4   = { .item = &s4 };
-  Str8Node n5   = { .string = &s5 };
+  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 n1   = { .item = &s1 };
-  Str8Node n2   = { .string = &s2 };
+  Str8Node n2   = { .item = &s2 };
-  Str8Node n3   = { .string = &s3 };
+  Str8Node n3   = { .item = &s3 };
-  Str8Node n4   = { .string = &s4 };
+  Str8Node n4   = { .item = &s4 };
-  Str8Node n5   = { .string = &s5 };
+  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);
 }