Standardize naming conventions (#12)

## Summary

Standardize naming conventions across the entire wizapp-stdlib codebase by replacing inconsistent prefixes and snake_case with a unified `wp` prefix + CamelCase scheme.

## Changes

### Naming convention applied

| Pattern | Before | After |
|---|---|---|
| Public functions | `wapp_module_function` | `wpModuleFunction` |
| Public types | `GenericXxx`, bare `Xxx` | `WpXxx` |
| Constants / enum values | `WAPP_XXX`, `SHELL_XXX` | `WP_XXX`, `WP_SHELL_XXX` |
| Internal functions | `_module_function` | `_moduleFunction` |
| Storage-class macros | `wapp_extern`, `wapp_intern` | `wp_extern`, `wp_intern` |

### Modules affected

All 20 modules were renamed: `arena`, `array`, `dbl_list`, `queue`, `str8`, `mem_allocator`, `mem_utils`, `mem_os`, `file`, `cpath`, `log`, `shell_commander`, `shell_termcolour`, `shell_utils`, `prng/xorshift`, `uuid`, `tester`, `aliases`, `assert`, `misc_utils`, `platform` — plus their test files.

### Backward compatibility

Added `src/oldnames.h` with `#define OLD_NAME NEW_NAME` for every renamed symbol, organized by module under Constants → Types → Functions sections. Existing code that includes this file will compile without changes.

Reviewed-on: #12
Co-authored-by: Abdelrahman <said.abdelrahman89@gmail.com>
Co-committed-by: Abdelrahman <said.abdelrahman89@gmail.com>

src/base/strings/str8/str8.c

@@ -11,17 +11,17 @@
 #include <stdio.h>
 #include <string.h>
 
-#define STR8_BUF_ALLOC_SIZE(CAPACITY) (sizeof(Str8) + sizeof(c8) * CAPACITY)
+#define STR8_BUF_ALLOC_SIZE(CAPACITY) (sizeof(WpStr8) + sizeof(c8) * CAPACITY)
 
-Str8 *wapp_str8_alloc_buf(const Allocator *allocator, u64 capacity) {
-	wapp_debug_assert(allocator != NULL, "`allocator` should not be NULL");
+WpStr8 *wpStr8AllocBuf(const WpAllocator *allocator, u64 capacity) {
+	wpDebugAssert(allocator != NULL, "`allocator` should not be NULL");
 
-	Str8 *str = wapp_mem_allocator_alloc(allocator, STR8_BUF_ALLOC_SIZE(capacity));
+	WpStr8 *str = wpMemAllocatorAlloc(allocator, STR8_BUF_ALLOC_SIZE(capacity));
 	if (!str) {
 		goto RETURN_STR8;
 	}
 
-	str->buf      = (u8 *)str + sizeof(Str8);
+	str->buf      = (u8 *)str + sizeof(WpStr8);
 	str->size     = 0;
 	str->capacity = capacity;
 
@@ -29,8 +29,8 @@ RETURN_STR8:
 	return str;
 }
 
-Str8 *wapp_str8_alloc_and_fill_buf(const Allocator *allocator, u64 capacity) {
-	Str8 *out = wapp_str8_alloc_buf(allocator, capacity);
+WpStr8 *wpStr8AllocAndFillBuf(const WpAllocator *allocator, u64 capacity) {
+	WpStr8 *out = wpStr8AllocBuf(allocator, capacity);
 	if (out) {
 		memset(out->buf, 0, capacity);
 		out->size = capacity;
@@ -38,11 +38,11 @@ Str8 *wapp_str8_alloc_and_fill_buf(const Allocator *allocator, u64 capacity) {
 	return out;
 }
 
-Str8 *wapp_str8_alloc_cstr(const Allocator *allocator, const char *str) {
-	wapp_debug_assert(allocator != NULL && str != NULL, "`allocator` and `str` should not be NULL");
+WpStr8 *wpStr8AllocCstr(const WpAllocator *allocator, const char *str) {
+	wpDebugAssert(allocator != NULL && str != NULL, "`allocator` and `str` should not be NULL");
 
 	u64 length    = strlen(str);
-	Str8 *output  = wapp_str8_alloc_buf(allocator, length * 2);
+	WpStr8 *output  = wpStr8AllocBuf(allocator, length * 2);
 	if (!output) {
 		goto RETURN_ALLOC_CSTR;
 	}
@@ -54,10 +54,10 @@ RETURN_ALLOC_CSTR:
 	return output;
 }
 
-Str8 *wapp_str8_alloc_str8(const Allocator *allocator, Str8RO *str) {
-	wapp_debug_assert(allocator != NULL && str != NULL, "`allocator` and `str` should not be NULL");
+WpStr8 *wpStr8AllocStr8(const WpAllocator *allocator, WpStr8RO *str) {
+	wpDebugAssert(allocator != NULL && str != NULL, "`allocator` and `str` should not be NULL");
 
-	Str8 *output = wapp_str8_alloc_buf(allocator, str->capacity);
+	WpStr8 *output = wpStr8AllocBuf(allocator, str->capacity);
 	if (!output) {
 		goto RETURN_ALLOC_STR8;
 	}
@@ -69,10 +69,10 @@ RETURN_ALLOC_STR8:
 	return output;
 }
 
-Str8 *wapp_str8_alloc_substr(const Allocator *allocator, Str8RO *str, u64 start, u64 end) {
-	wapp_debug_assert(allocator != NULL && str != NULL, "`allocator` and `str` should not be NULL");
+WpStr8 *wpStr8AllocSubstr(const WpAllocator *allocator, WpStr8RO *str, u64 start, u64 end) {
+	wpDebugAssert(allocator != NULL && str != NULL, "`allocator` and `str` should not be NULL");
 
-	Str8 *output = NULL;
+	WpStr8 *output = NULL;
 
 	if (start >= str->size || start >= end) {
 		goto RETURN_ALLOC_SUBSTR;
@@ -82,7 +82,7 @@ Str8 *wapp_str8_alloc_substr(const Allocator *allocator, Str8RO *str, u64 start,
 		end = str->size;
 	}
 
-	output = wapp_str8_alloc_buf(allocator, str->capacity);
+	output = wpStr8AllocBuf(allocator, str->capacity);
 	if (!output) {
 		goto RETURN_ALLOC_SUBSTR;
 	}
@@ -94,12 +94,12 @@ RETURN_ALLOC_SUBSTR:
 	return output;
 }
 
-void wapp_str8_dealloc_buf(const Allocator *allocator, Str8 **str) {
-	wapp_debug_assert(allocator != NULL && str != NULL && (*str) != NULL, "Either `allocator` is NULL or `str` is an invalid double pointer");
-	wapp_mem_allocator_free(allocator, (void **)str, STR8_BUF_ALLOC_SIZE((*str)->capacity));
+void wpStr8DeallocBuf(const WpAllocator *allocator, WpStr8 **str) {
+	wpDebugAssert(allocator != NULL && str != NULL && (*str) != NULL, "Either `allocator` is NULL or `str` is an invalid double pointer");
+	wpMemAllocatorFree(allocator, (void **)str, STR8_BUF_ALLOC_SIZE((*str)->capacity));
 }
 
-c8 wapp_str8_get(const Str8 *str, u64 index) {
+c8 wpStr8Get(const WpStr8 *str, u64 index) {
 	if (index >= str->size) {
 		return '\0';
 	}
@@ -107,7 +107,7 @@ c8 wapp_str8_get(const Str8 *str, u64 index) {
 	return str->buf[index];
 }
 
-void wapp_str8_set(Str8 *str, u64 index, c8 c) {
+void wpStr8Set(WpStr8 *str, u64 index, c8 c) {
 	if (index >= str->size) {
 		return;
 	}
@@ -115,24 +115,24 @@ void wapp_str8_set(Str8 *str, u64 index, c8 c) {
 	str->buf[index] = c;
 }
 
-void wapp_str8_push_back(Str8 *str, c8 c) {
+void wpStr8PushBack(WpStr8 *str, c8 c) {
 	if (!(str->size < str->capacity)) {
 		return;
 	}
 
 	u64 index = (str->size)++;
-	wapp_str8_set(str, index, c);
+	wpStr8Set(str, index, c);
 }
 
-b8 wapp_str8_equal(Str8RO *s1, Str8RO *s2) {
+b8 wpStr8Equal(WpStr8RO *s1, WpStr8RO *s2) {
 	if (s1->size != s2->size) {
 		return false;
 	}
 
-	return wapp_str8_equal_to_count(s1, s2, s1->size);
+	return wpStr8EqualToCount(s1, s2, s1->size);
 }
 
-b8 wapp_str8_equal_to_count(Str8RO* s1, Str8RO* s2, u64 count) {
+b8 wpStr8EqualToCount(WpStr8RO* s1, WpStr8RO* s2, u64 count) {
 	if (!s1 || !s2) {
 		return false;
 	}
@@ -140,7 +140,7 @@ b8 wapp_str8_equal_to_count(Str8RO* s1, Str8RO* s2, u64 count) {
 	return memcmp(s1->buf, s2->buf, count) == 0;
 }
 
-Str8 wapp_str8_slice(Str8RO *str, u64 start, u64 end) {
+WpStr8 wpStr8Slice(WpStr8RO *str, u64 start, u64 end) {
 	if (start >= str->size || start >= end) {
 		start  = str->size;
 		end    = str->size;
@@ -150,17 +150,17 @@ Str8 wapp_str8_slice(Str8RO *str, u64 start, u64 end) {
 		end = str->size;
 	}
 
-	return (Str8RO){
+	return (WpStr8RO){
 		.capacity = end - start,
 		.size     = end - start,
 		.buf      = str->buf + start,
 	};
 }
 
-Str8 *wapp_str8_alloc_concat(const Allocator *allocator, Str8 *dst, Str8RO *src) {
-	wapp_debug_assert(allocator != NULL && dst != NULL && src != NULL, "`allocator`, `dst` and `src` should not be NULL");
+WpStr8 *wpStr8AllocConcat(const WpAllocator *allocator, WpStr8 *dst, WpStr8RO *src) {
+	wpDebugAssert(allocator != NULL && dst != NULL && src != NULL, "`allocator`, `dst` and `src` should not be NULL");
 
-	Str8 *output  = NULL;
+	WpStr8 *output  = NULL;
 	u64 remaining = dst->capacity - dst->size;
 	if (src->size <= remaining) {
 		output = dst;
@@ -169,22 +169,22 @@ Str8 *wapp_str8_alloc_concat(const Allocator *allocator, Str8 *dst, Str8RO *src)
 
 	u64 capacity = dst->capacity + src->size;
 
-	output = wapp_str8_alloc_buf(allocator, capacity);
+	output = wpStr8AllocBuf(allocator, capacity);
 	if (!output) {
 		goto RETURN_STR8_CONCAT;
 	}
 
-	wapp_str8_concat_capped(output, dst);
+	wpStr8ConcatCapped(output, dst);
 
 SOURCE_STRING_STR8_CONCAT:
-	wapp_str8_concat_capped(output, src);
+	wpStr8ConcatCapped(output, src);
 
 RETURN_STR8_CONCAT:
 	return output;
 }
 
-void wapp_str8_concat_capped(Str8 *dst, Str8RO *src) {
-	wapp_debug_assert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL");
+void wpStr8ConcatCapped(WpStr8 *dst, WpStr8RO *src) {
+	wpDebugAssert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL");
 
 	u64 remaining = dst->capacity - dst->size;
 	u64 to_copy   = remaining < src->size ? remaining : src->size;
@@ -193,8 +193,8 @@ void wapp_str8_concat_capped(Str8 *dst, Str8RO *src) {
 	dst->size += to_copy;
 }
 
-void wapp_str8_copy_cstr_capped(Str8 *dst, const char *src) {
-	wapp_debug_assert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL");
+void wpStr8CopyCstrCapped(WpStr8 *dst, const char *src) {
+	wpDebugAssert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL");
 
 	u64 length  = strlen(src);
 	u64 to_copy = length <= dst->capacity ? length : dst->capacity;
@@ -204,8 +204,8 @@ void wapp_str8_copy_cstr_capped(Str8 *dst, const char *src) {
 	dst->size = to_copy;
 }
 
-void wapp_str8_copy_str8_capped(Str8 *dst, Str8RO *src) {
-	wapp_debug_assert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL");
+void wpStr8CopyStr8Capped(WpStr8 *dst, WpStr8RO *src) {
+	wpDebugAssert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL");
 
 	u64 to_copy = src->size <= dst->capacity ? src->size : dst->capacity;
 
@@ -214,8 +214,8 @@ void wapp_str8_copy_str8_capped(Str8 *dst, Str8RO *src) {
 	dst->size = to_copy;
 }
 
-void wapp_str8_copy_to_cstr(char *dst, Str8RO *src, u64 dst_capacity) {
-	wapp_debug_assert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL");
+void wpStr8CopyToCstr(char *dst, WpStr8RO *src, u64 dst_capacity) {
+	wpDebugAssert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL");
 
 	u64 to_copy = src->size < dst_capacity ? src->size : dst_capacity - 1;
 
@@ -223,8 +223,8 @@ void wapp_str8_copy_to_cstr(char *dst, Str8RO *src, u64 dst_capacity) {
 	memcpy(dst, src->buf, to_copy);
 }
 
-void wapp_str8_format(Str8 *dst, const char *format, ...) {
-	wapp_debug_assert(dst != NULL && format != NULL, "`dst` and `format` should not be NULL");
+void wpStr8Format(WpStr8 *dst, const char *format, ...) {
+	wpDebugAssert(dst != NULL && format != NULL, "`dst` and `format` should not be NULL");
 
 	va_list args1;
 	va_list args2;
@@ -241,9 +241,9 @@ void wapp_str8_format(Str8 *dst, const char *format, ...) {
 	va_end(args2);
 }
 
-void wapp_str8_to_lower(Str8 *dst, Str8RO *src) {
-	wapp_debug_assert(src != NULL && dst != NULL, "`dst` and `src` should not be NULL");
-	wapp_debug_assert(dst->capacity >= src->capacity, "`dst` does not have enough capacity");
+void wpStr8ToLower(WpStr8 *dst, WpStr8RO *src) {
+	wpDebugAssert(src != NULL && dst != NULL, "`dst` and `src` should not be NULL");
+	wpDebugAssert(dst->capacity >= src->capacity, "`dst` does not have enough capacity");
 
 	dst->size = src->size;
 
@@ -252,15 +252,15 @@ void wapp_str8_to_lower(Str8 *dst, Str8RO *src) {
 	u64 index  = 0;
 	b8 running = true;
 	while (running) {
-		wapp_str8_set(dst, index, (u8)tolower(wapp_str8_get(src, index)));
+		wpStr8Set(dst, index, (u8)tolower(wpStr8Get(src, index)));
 		++index;
 		running = index < src->size;
 	}
 }
 
-void wapp_str8_to_upper(Str8 *dst, Str8RO *src) {
-	wapp_debug_assert(src != NULL && dst != NULL, "`dst` and `src` should not be NULL");
-	wapp_debug_assert(dst->capacity >= src->capacity, "`dst` does not have enough capacity");
+void wpStr8ToUpper(WpStr8 *dst, WpStr8RO *src) {
+	wpDebugAssert(src != NULL && dst != NULL, "`dst` and `src` should not be NULL");
+	wpDebugAssert(dst->capacity >= src->capacity, "`dst` does not have enough capacity");
 
 	dst->size = src->size;
 
@@ -269,24 +269,24 @@ void wapp_str8_to_upper(Str8 *dst, Str8RO *src) {
 	u64 index  = 0;
 	b8 running = true;
 	while (running) {
-		wapp_str8_set(dst, index, (u8)toupper(wapp_str8_get(src, index)));
+		wpStr8Set(dst, index, (u8)toupper(wpStr8Get(src, index)));
 		++index;
 		running = index < src->size;
 	}
 }
 
-void wapp_str8_from_bytes(Str8 *dst, const U8Array src) {
-	wapp_debug_assert(src != NULL && dst != NULL, "`dst` and `src` should not be NULL");
+void wpStr8FromBytes(WpStr8 *dst, const WpU8Array src) {
+	wpDebugAssert(src != NULL && dst != NULL, "`dst` and `src` should not be NULL");
 
-	u64 size = wapp_array_count(src) * wapp_array_item_size(src);
+	u64 size = wpArrayCount(src) * wpArrayItemSize(src);
 
-	wapp_debug_assert(dst->capacity >= size, "`dst` does not have enough capacity");
+	wpDebugAssert(dst->capacity >= size, "`dst` does not have enough capacity");
 
 	dst->size = size;
 	memcpy(dst->buf, src, size);
 }
 
-i64 wapp_str8_find(Str8RO *str, Str8RO substr) {
+i64 wpStr8Find(WpStr8RO *str, WpStr8RO substr) {
 	if (!str || substr.size > str->size) {
 		return -1;
 	}
@@ -308,7 +308,7 @@ i64 wapp_str8_find(Str8RO *str, Str8RO substr) {
 	return -1;
 }
 
-i64 wapp_str8_rfind(Str8RO *str, Str8RO substr) {
+i64 wpStr8Rfind(WpStr8RO *str, WpStr8RO substr) {
 	if (!str || substr.size > str->size) {
 		return -1;
 	}
@@ -330,15 +330,15 @@ i64 wapp_str8_rfind(Str8RO *str, Str8RO substr) {
 	return -1;
 }
 
-Str8List *wapp_str8_split_with_max(const Allocator *allocator, Str8RO *str, Str8RO *delimiter, i64 max_splits) {
-	wapp_debug_assert(allocator != NULL && str != NULL && delimiter != NULL, "`allocator`, `str` and `delimiter` should not be NULL");
+WpStr8List *wpStr8SplitWithMax(const WpAllocator *allocator, WpStr8RO *str, WpStr8RO *delimiter, i64 max_splits) {
+	wpDebugAssert(allocator != NULL && str != NULL && delimiter != NULL, "`allocator`, `str` and `delimiter` should not be NULL");
 
-	Str8List *output = wapp_dbl_list_alloc(Str8, allocator);
+	WpStr8List *output = wpDblListAlloc(WpStr8, allocator);
 
 	if (delimiter->size > str->size) {
-		Str8 *full = wapp_str8_alloc_str8(allocator, str);
+		WpStr8 *full = wpStr8AllocStr8(allocator, str);
 		if (full) {
-			wapp_dbl_list_push_back_alloc(Str8, allocator, output, full);
+			wpDblListPushBackAlloc(WpStr8, allocator, output, full);
 		}
 
 		goto RETURN_STR8_SPLIT;
@@ -347,45 +347,45 @@ Str8List *wapp_str8_split_with_max(const Allocator *allocator, Str8RO *str, Str8
 	i64 start  = 0;
 	i64 end    = 0;
 	i64 splits = 0;
-	Str8 *rest = wapp_str8_alloc_str8(allocator, str);
-	Str8 *before_str;
+	WpStr8 *rest = wpStr8AllocStr8(allocator, str);
+	WpStr8 *before_str;
 
-	while ((end = wapp_str8_find(rest, *delimiter)) != -1) {
+	while ((end = wpStr8Find(rest, *delimiter)) != -1) {
 		if (max_splits > 0 && splits >= max_splits) {
 			break;
 		}
 
-		before_str = wapp_str8_alloc_substr(allocator, str, start, start + end);
+		before_str = wpStr8AllocSubstr(allocator, str, start, start + end);
 		if (before_str) {
-			wapp_dbl_list_push_back_alloc(Str8, allocator, output, before_str);
+			wpDblListPushBackAlloc(WpStr8, allocator, output, before_str);
 		}
 
-		wapp_mem_allocator_free(allocator, (void **)&rest, sizeof(Str8));
-		rest   = wapp_str8_alloc_substr(allocator, str, start + end + delimiter->size, str->size);
+		wpMemAllocatorFree(allocator, (void **)&rest, sizeof(WpStr8));
+		rest   = wpStr8AllocSubstr(allocator, str, start + end + delimiter->size, str->size);
 		start += end + delimiter->size;
 
 		++splits;
 	}
 
 	// Ensure the last part of the string after the delimiter is added to the list
-	rest = wapp_str8_alloc_substr(allocator, str, start, str->size);
+	rest = wpStr8AllocSubstr(allocator, str, start, str->size);
 	if (rest) {
-		wapp_dbl_list_push_back_alloc(Str8, allocator, output, rest);
+		wpDblListPushBackAlloc(WpStr8, allocator, output, rest);
 	}
 
 RETURN_STR8_SPLIT:
 	return output;
 }
 
-Str8List *wapp_str8_rsplit_with_max(const Allocator *allocator, Str8RO *str, Str8RO *delimiter, i64 max_splits) {
-	wapp_debug_assert(allocator != NULL && str != NULL && delimiter != NULL, "`allocator`, `str` and `delimiter` should not be NULL");
+WpStr8List *wpStr8RsplitWithMax(const WpAllocator *allocator, WpStr8RO *str, WpStr8RO *delimiter, i64 max_splits) {
+	wpDebugAssert(allocator != NULL && str != NULL && delimiter != NULL, "`allocator`, `str` and `delimiter` should not be NULL");
 
-	Str8List *output = wapp_dbl_list_alloc(Str8, allocator);
+	WpStr8List *output = wpDblListAlloc(WpStr8, allocator);
 
 	if (delimiter->size > str->size) {
-		Str8 *full = wapp_str8_alloc_str8(allocator, str);
+		WpStr8 *full = wpStr8AllocStr8(allocator, str);
 		if (full) {
-			wapp_dbl_list_push_back_alloc(Str8, allocator, output, full);
+			wpDblListPushBackAlloc(WpStr8, allocator, output, full);
 		}
 
 		goto RETURN_STR8_SPLIT;
@@ -393,58 +393,58 @@ Str8List *wapp_str8_rsplit_with_max(const Allocator *allocator, Str8RO *str, Str
 
 	i64 end    = 0;
 	i64 splits = 0;
-	Str8 *rest = wapp_str8_alloc_str8(allocator, str);
-	Str8 *after_str;
+	WpStr8 *rest = wpStr8AllocStr8(allocator, str);
+	WpStr8 *after_str;
 
-	while ((end = wapp_str8_rfind(rest, *delimiter)) != -1) {
+	while ((end = wpStr8Rfind(rest, *delimiter)) != -1) {
 		if (max_splits > 0 && splits >= max_splits) {
 			break;
 		}
 
-		after_str = wapp_str8_alloc_substr(allocator, rest, end + delimiter->size, str->size);
+		after_str = wpStr8AllocSubstr(allocator, rest, end + delimiter->size, str->size);
 		if (after_str) {
-			wapp_dbl_list_push_front_alloc(Str8, allocator, output, after_str);
+			wpDblListPushFrontAlloc(WpStr8, allocator, output, after_str);
 		}
 
-		wapp_mem_allocator_free(allocator, (void **)&rest, sizeof(Str8));
-		rest = wapp_str8_alloc_substr(allocator, rest, 0, end);
+		wpMemAllocatorFree(allocator, (void **)&rest, sizeof(WpStr8));
+		rest = wpStr8AllocSubstr(allocator, rest, 0, end);
 
 		++splits;
 	}
 
-	rest = wapp_str8_alloc_substr(allocator, str, 0, rest->size);
+	rest = wpStr8AllocSubstr(allocator, str, 0, rest->size);
 	if (rest) {
-		wapp_dbl_list_push_front_alloc(Str8, allocator, output, rest);
+		wpDblListPushFrontAlloc(WpStr8, allocator, output, rest);
 	}
 
 RETURN_STR8_SPLIT:
 	return output;
 }
 
-Str8 *wapp_str8_join(const Allocator *allocator, const Str8List *list, Str8RO *delimiter) {
-	wapp_debug_assert(allocator != NULL && list != NULL && delimiter != NULL, "`allocator`, `list` and `delimiter` should not be NULL");
+WpStr8 *wpStr8Join(const WpAllocator *allocator, const WpStr8List *list, WpStr8RO *delimiter) {
+	wpDebugAssert(allocator != NULL && list != NULL && delimiter != NULL, "`allocator`, `list` and `delimiter` should not be NULL");
 
-	u64 capacity = wapp_str8_list_total_size(list) + (delimiter->size * (list->node_count - 1));
-	Str8 *output = wapp_str8_alloc_buf(allocator, capacity * 2);
+	u64 capacity = wpStr8ListTotalSize(list) + (delimiter->size * (list->node_count - 1));
+	WpStr8 *output = wpStr8AllocBuf(allocator, capacity * 2);
 
 	// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
 	// MSVC Spectre mitigation warnings
-	Str8 *node;
+	WpStr8 *node;
 	u64 node_index = 0;
 	b8 running     = node_index < list->node_count;
 	while (running) {
-		node = wapp_dbl_list_get(Str8, list, node_index);
+		node = wpDblListGet(WpStr8, list, node_index);
 		if (!node) {
 			break;
 		}
 
-		wapp_str8_concat_capped(output, node);
+		wpStr8ConcatCapped(output, node);
 
 		// NOTE (Abdelrahman): Comparison extracted to variable to silence
 		// MSVC Spectre mitigation warnings
 		b8 not_last = node_index + 1 < list->node_count;
 		if (not_last) {
-			wapp_str8_concat_capped(output, delimiter);
+			wpStr8ConcatCapped(output, delimiter);
 		}
 
 		++node_index;
@@ -454,19 +454,19 @@ Str8 *wapp_str8_join(const Allocator *allocator, const Str8List *list, Str8RO *d
 	return output;
 }
 
-u64 wapp_str8_list_total_size(const Str8List *list) {
+u64 wpStr8ListTotalSize(const WpStr8List *list) {
 	if (!list) {
 		return 0;
 	}
 
 	// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
 	// MSVC Spectre mitigation warnings
-	Str8 *node;
+	WpStr8 *node;
 	u64 node_index = 0;
 	u64 output     = 0;
 	b8 running     = node_index < list->node_count;
 	while (running) {
-		node = wapp_dbl_list_get(Str8, list, node_index);
+		node = wpDblListGet(WpStr8, list, node_index);
 		if (!node) {
 				break;
 		}

src/base/strings/str8/str8.h

@@ -11,120 +11,120 @@
 #include "../../mem/allocator/mem_allocator.h"
 #include <string.h>
 
-#ifdef WAPP_PLATFORM_CPP
+#ifdef WP_PLATFORM_CPP
 BEGIN_C_LINKAGE
-#endif // !WAPP_PLATFORM_CPP
+#endif // !WP_PLATFORM_CPP
 
-typedef struct Str8 Str8;
-struct Str8 {
+typedef struct WpStr8 WpStr8;
+struct WpStr8 {
 	u64 capacity;
 	u64 size;
 	c8 *buf;
 };
 
-typedef const Str8 Str8RO;
+typedef const WpStr8 WpStr8RO;
 
 /**
  * Utilities to be used with printf functions
  */
-#define WAPP_STR8_SPEC "%.*s"
-#define wapp_str8_varg(STRING) (int)((STRING).size), (STRING).buf
+#define WP_STR8_SPEC "%.*s"
+#define wpStr8Varg(STRING) (int)((STRING).size), (STRING).buf
 
 /**
- * Str8 stack buffers
+ * WpStr8 stack buffers
  */
 
-#ifdef WAPP_PLATFORM_CPP
+#ifdef WP_PLATFORM_CPP
 // Uses a lambda to achieve the same behaviour achieved by the C macro
-#define wapp_str8_buf(CAPACITY) ([&](){ \
-	wapp_persist c8 buf[CAPACITY] = {};   \
-	memset(buf, 0, CAPACITY);             \
-	return Str8{CAPACITY, 0, buf};        \
+#define wpStr8Buf(CAPACITY) ([&](){                                                                \
+	wp_persist c8 buf[CAPACITY] = {};                                                                \
+	memset(buf, 0, CAPACITY);                                                                        \
+	return WpStr8{CAPACITY, 0, buf};                                                                 \
 }())
 
 // Uses a lambda to achieve the same behaviour achieved by the C macro
-#define wapp_str8_lit(STRING) ([&]() {                            \
-	wapp_persist c8 buf[sizeof(STRING) * 2] = {};                   \
-	memcpy(buf, STRING, sizeof(STRING));                            \
-	return Str8{(sizeof(STRING) - 1) * 2, sizeof(STRING) - 1, buf}; \
+#define wpStr8Lit(STRING) ([&]() {                                                                 \
+	wp_persist c8 buf[sizeof(STRING) * 2] = {};                                                      \
+	memcpy(buf, STRING, sizeof(STRING));                                                             \
+	return WpStr8{(sizeof(STRING) - 1) * 2, sizeof(STRING) - 1, buf};                                \
 }())
 
-#define wapp_str8_lit_ro(STRING) Str8RO{sizeof(STRING) - 1, sizeof(STRING) - 1, (c8 *)STRING}
-#define wapp_str8_lit_ro_initialiser_list(STRING) {sizeof(STRING) - 1, sizeof(STRING) - 1, (c8 *)STRING}
+#define wpStr8LitRo(STRING) WpStr8RO{sizeof(STRING) - 1, sizeof(STRING) - 1, (c8 *)STRING}
+#define wpStr8LitRoInitialiserList(STRING) {sizeof(STRING) - 1, sizeof(STRING) - 1, (c8 *)STRING}
 #else
-#define wapp_str8_buf(CAPACITY) ((Str8){.capacity = CAPACITY, .size = 0, .buf = (c8[CAPACITY]){0}})
+#define wpStr8Buf(CAPACITY) ((WpStr8){.capacity = CAPACITY, .size = 0, .buf = (c8[CAPACITY]){0}})
 
 // Utilises the fact that memcpy returns pointer to dest buffer and that getting
 // address of compound literals is valid in C to create a string on the stack
-#define wapp_str8_lit(STRING) ((Str8){.capacity  = (sizeof(STRING) - 1) * 2,               \
-                                      .size      = sizeof(STRING) - 1,                     \
-                                      .buf       = memcpy(&((c8 [sizeof(STRING) * 2]){0}), \
-                                                          STRING,                          \
+#define wpStr8Lit(STRING) ((WpStr8){.capacity  = (sizeof(STRING) - 1) * 2,                         \
+                                      .size      = sizeof(STRING) - 1,                             \
+                                      .buf       = memcpy(&((c8 [sizeof(STRING) * 2]){0}),         \
+                                                          STRING,                                  \
                                                           sizeof(STRING))})
-#define wapp_str8_lit_ro(STRING) ((Str8RO){.capacity  = sizeof(STRING) - 1,  \
-                                           .size      = sizeof(STRING) - 1,  \
+#define wpStr8LitRo(STRING) ((WpStr8RO){.capacity  = sizeof(STRING) - 1,                           \
+                                           .size      = sizeof(STRING) - 1,                        \
                                            .buf       = (c8 *)STRING})
 // To be used only when initialising a static storage variable in compilers that don't support
-// initialisers with the syntax of wapp_str8_lit_ro (e.g. gcc). Should only be used when necessary
-// and only be assigned to a Str8RO variable to avoid any attempt at modifying the string
-#define wapp_str8_lit_ro_initialiser_list(STRING) {.capacity  = sizeof(STRING) - 1,  \
-                                                   .size      = sizeof(STRING) - 1,  \
+// initialisers with the syntax of wpStr8LitRo (e.g. gcc). Should only be used when necessary
+// and only be assigned to a WpStr8RO variable to avoid any attempt at modifying the string
+#define wpStr8LitRoInitialiserList(STRING) {.capacity  = sizeof(STRING) - 1,                       \
+                                                   .size      = sizeof(STRING) - 1,                \
                                                    .buf       = (c8 *)STRING}
-#endif // !WAPP_PLATFORM_CPP
+#endif // !WP_PLATFORM_CPP
 
 /**
- * Str8 allocated buffers
+ * WpStr8 allocated buffers
  */
-Str8 *wapp_str8_alloc_buf(const Allocator *allocator, u64 capacity);
-Str8 *wapp_str8_alloc_and_fill_buf(const Allocator *allocator, u64 capacity);
-Str8 *wapp_str8_alloc_cstr(const Allocator *allocator, const char *str);
-Str8 *wapp_str8_alloc_str8(const Allocator *allocator, Str8RO *str);
-Str8 *wapp_str8_alloc_substr(const Allocator *allocator, Str8RO *str, u64 start, u64 end);
-Str8 *wapp_str8_alloc_concat(const Allocator *allocator, Str8 *dst, Str8RO *src);
+WpStr8 *wpStr8AllocBuf(const WpAllocator *allocator, u64 capacity);
+WpStr8 *wpStr8AllocAndFillBuf(const WpAllocator *allocator, u64 capacity);
+WpStr8 *wpStr8AllocCstr(const WpAllocator *allocator, const char *str);
+WpStr8 *wpStr8AllocStr8(const WpAllocator *allocator, WpStr8RO *str);
+WpStr8 *wpStr8AllocSubstr(const WpAllocator *allocator, WpStr8RO *str, u64 start, u64 end);
+WpStr8 *wpStr8AllocConcat(const WpAllocator *allocator, WpStr8 *dst, WpStr8RO *src);
 // Only needed for allocators like malloc where each allocation has to be freed on its own.
 // No need to use it for allocators like Arena.
-void wapp_str8_dealloc_buf(const Allocator *allocator, Str8 **str);
+void wpStr8DeallocBuf(const WpAllocator *allocator, WpStr8 **str);
 
 /**
- * Str8 utilities
+ * WpStr8 utilities
  */
-c8   wapp_str8_get(Str8RO *str, u64 index);
-void wapp_str8_set(Str8 *str, u64 index, c8 c);
-void wapp_str8_push_back(Str8 *str, c8 c);
-b8   wapp_str8_equal(Str8RO *s1, Str8RO *s2);
-b8   wapp_str8_equal_to_count(Str8RO* s1, Str8RO* s2, u64 count);
-Str8 wapp_str8_slice(Str8RO *str, u64 start, u64 end);
-void wapp_str8_concat_capped(Str8 *dst, Str8RO *src);
-void wapp_str8_copy_cstr_capped(Str8 *dst, const char *src);
-void wapp_str8_copy_str8_capped(Str8 *dst, Str8RO *src);
-void wapp_str8_copy_to_cstr(char *dst, Str8RO *src, u64 dst_capacity);
-void wapp_str8_format(Str8 *dst, const char *format, ...);
-void wapp_str8_to_lower(Str8 *dst, Str8RO *src);
-void wapp_str8_to_upper(Str8 *dst, Str8RO *src);
-void wapp_str8_from_bytes(Str8 *dst, const U8Array src);
+c8   wpStr8Get(WpStr8RO *str, u64 index);
+void wpStr8Set(WpStr8 *str, u64 index, c8 c);
+void wpStr8PushBack(WpStr8 *str, c8 c);
+b8   wpStr8Equal(WpStr8RO *s1, WpStr8RO *s2);
+b8   wpStr8EqualToCount(WpStr8RO* s1, WpStr8RO* s2, u64 count);
+WpStr8 wpStr8Slice(WpStr8RO *str, u64 start, u64 end);
+void wpStr8ConcatCapped(WpStr8 *dst, WpStr8RO *src);
+void wpStr8CopyCstrCapped(WpStr8 *dst, const char *src);
+void wpStr8CopyStr8Capped(WpStr8 *dst, WpStr8RO *src);
+void wpStr8CopyToCstr(char *dst, WpStr8RO *src, u64 dst_capacity);
+void wpStr8Format(WpStr8 *dst, const char *format, ...);
+void wpStr8ToLower(WpStr8 *dst, WpStr8RO *src);
+void wpStr8ToUpper(WpStr8 *dst, WpStr8RO *src);
+void wpStr8FromBytes(WpStr8 *dst, const WpU8Array src);
 
 /**
- * Str8 find functions
+ * WpStr8 find functions
  */
-i64 wapp_str8_find(Str8RO *str, Str8RO substr);
-i64 wapp_str8_rfind(Str8RO *str, Str8RO substr);
+i64 wpStr8Find(WpStr8RO *str, WpStr8RO substr);
+i64 wpStr8Rfind(WpStr8RO *str, WpStr8RO substr);
 
 /**
- * Str8 split and join
+ * WpStr8 split and join
  */
-#define wapp_str8_split(ALLOCATOR, STR, DELIMITER) wapp_str8_split_with_max(ALLOCATOR, STR, DELIMITER, -1)
-#define wapp_str8_rsplit(ALLOCATOR, STR, DELIMITER) wapp_str8_rsplit_with_max(ALLOCATOR, STR, DELIMITER, -1)
-Str8List *wapp_str8_split_with_max(const Allocator *allocator, Str8RO *str, Str8RO *delimiter, i64 max_splits);
-Str8List *wapp_str8_rsplit_with_max(const Allocator *allocator, Str8RO *str, Str8RO *delimiter, i64 max_splits);
-Str8     *wapp_str8_join(const Allocator *allocator, const Str8List *list, Str8RO *delimiter);
+#define wpStr8Split(ALLOCATOR, STR, DELIMITER) wpStr8SplitWithMax(ALLOCATOR, STR, DELIMITER, -1)
+#define wpStr8Rsplit(ALLOCATOR, STR, DELIMITER) wpStr8RsplitWithMax(ALLOCATOR, STR, DELIMITER, -1)
+WpStr8List *wpStr8SplitWithMax(const WpAllocator *allocator, WpStr8RO *str, WpStr8RO *delimiter, i64 max_splits);
+WpStr8List *wpStr8RsplitWithMax(const WpAllocator *allocator, WpStr8RO *str, WpStr8RO *delimiter, i64 max_splits);
+WpStr8     *wpStr8Join(const WpAllocator *allocator, const WpStr8List *list, WpStr8RO *delimiter);
 
 /**
- * Str8 list utilities
+ * WpStr8 list utilities
  */
-u64 wapp_str8_list_total_size(const Str8List *list);
+u64 wpStr8ListTotalSize(const WpStr8List *list);
 
-#ifdef WAPP_PLATFORM_CPP
+#ifdef WP_PLATFORM_CPP
 END_C_LINKAGE
-#endif // !WAPP_PLATFORM_CPP
+#endif // !WP_PLATFORM_CPP
 
 #endif // !STR8_H