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>

VERSION

@@ -1 +1 @@
-1.2.0
+2.0.0

src/base/dbl_list/dbl_list.h

@@ -103,37 +103,37 @@ typedef WpDblNode WpStr8Node;
 	(_dblListAlloc(ALLOCATOR, sizeof(TYPE)))
 #define wpDblListGet(TYPE, LIST_PTR, ITEM_INDEX)                                                   \
 	((TYPE *)(_dblListGet(LIST_PTR, ITEM_INDEX, sizeof(TYPE))->item))
-#define wpDblListGet_node(TYPE, LIST_PTR, ITEM_INDEX)                                              \
+#define wpDblListGetNode(TYPE, LIST_PTR, ITEM_INDEX)                                               \
 	(_dblListGet(LIST_PTR, ITEM_INDEX, sizeof(TYPE)))
-#define wpDblListGet_node_item(TYPE, NODE_PTR)                                                     \
+#define wpDblListGetNodeItem(TYPE, NODE_PTR)                                                       \
 	((TYPE *)(                                                                                       \
 		(NODE_PTR == NULL) ?                                                                           \
 		NULL :                                                                                         \
 		(NODE_PTR)->item                                                                               \
 	))
-#define wpDblListPush_front(TYPE, LIST_PTR, ITEM_PTR)                                              \
+#define wpDblListPushFront(TYPE, LIST_PTR, ITEM_PTR)                                               \
 	(_dblListPushFront(LIST_PTR, _dblListNode(TYPE, ITEM_PTR), sizeof(TYPE)))
-#define wpDblListPush_back(TYPE, LIST_PTR, ITEM_PTR)                                               \
+#define wpDblListPushBack(TYPE, LIST_PTR, ITEM_PTR)                                                \
 	(_dblListPushBack(LIST_PTR, _dblListNode(TYPE, ITEM_PTR), sizeof(TYPE)))
 #define wpDblListInsert(TYPE, LIST_PTR, ITEM_PTR, ITEM_INDEX)                                      \
 	(_dblListInsert(LIST_PTR, _dblListNode(TYPE, ITEM_PTR),                                          \
 	                  ITEM_INDEX, sizeof(TYPE)))
-#define wpDblListPush_front_alloc(TYPE, ALLOCATOR, LIST_PTR, ITEM_PTR)                             \
+#define wpDblListPushFrontAlloc(TYPE, ALLOCATOR, LIST_PTR, ITEM_PTR)                               \
 	(_dblListPushFront(LIST_PTR, _dblListNodeAlloc(ALLOCATOR, ITEM_PTR, sizeof(TYPE)),               \
 	                      sizeof(TYPE)))
-#define wpDblListPush_back_alloc(TYPE, ALLOCATOR, LIST_PTR, ITEM_PTR)                              \
+#define wpDblListPushBackAlloc(TYPE, ALLOCATOR, LIST_PTR, ITEM_PTR)                                \
 	(_dblListPushBack(LIST_PTR, _dblListNodeAlloc(ALLOCATOR, ITEM_PTR, sizeof(TYPE)),                \
 	                     sizeof(TYPE)))
-#define wpDblListInsert_alloc(TYPE, ALLOCATOR, LIST_PTR, ITEM_PTR, ITEM_INDEX)                     \
+#define wpDblListInsertAlloc(TYPE, ALLOCATOR, LIST_PTR, ITEM_PTR, ITEM_INDEX)                      \
 	(_dblListInsert(LIST_PTR, _dblListNodeAlloc(ALLOCATOR, ITEM_PTR, sizeof(TYPE)),                  \
 	                  ITEM_INDEX, sizeof(TYPE)))
-#define wpDblListPop_front(TYPE, LIST_PTR)                                                         \
+#define wpDblListPopFront(TYPE, LIST_PTR)                                                          \
 	((TYPE *)(                                                                                       \
 		(LIST_PTR == NULL || (LIST_PTR)->node_count == 0) ?                                            \
 		NULL :                                                                                         \
 		_dblListPopFront(LIST_PTR, sizeof(TYPE))->item                                                 \
 	))
-#define wpDblListPop_back(TYPE, LIST_PTR)                                                          \
+#define wpDblListPopBack(TYPE, LIST_PTR)                                                           \
 	((TYPE *)(                                                                                       \
 		(LIST_PTR == NULL || (LIST_PTR)->node_count == 0) ?                                            \
 		NULL :                                                                                         \
@@ -145,19 +145,19 @@ typedef WpDblNode WpStr8Node;
 		NULL :                                                                                         \
 		_dblListRemove(LIST_PTR, ITEM_INDEX, sizeof(TYPE))->item                                       \
 	))
-#define wpDblListPop_front_node(TYPE, LIST_PTR)                                                    \
+#define wpDblListPopFrontNode(TYPE, LIST_PTR)                                                      \
 	(                                                                                                \
 		(LIST_PTR == NULL || (LIST_PTR)->node_count == 0) ?                                            \
 		NULL :                                                                                         \
 		_dblListPopFront(LIST_PTR, sizeof(TYPE))                                                       \
 	)
-#define wpDblListPop_back_node(TYPE, LIST_PTR)                                                     \
+#define wpDblListPopBackNode(TYPE, LIST_PTR)                                                       \
 	(                                                                                                \
 		(LIST_PTR == NULL || (LIST_PTR)->node_count == 0) ?                                            \
 		NULL :                                                                                         \
 		_dblListPopBack(LIST_PTR, sizeof(TYPE))                                                        \
 	)
-#define wpDblListRemove_node(TYPE, LIST_PTR, ITEM_INDEX)                                           \
+#define wpDblListRemoveNode(TYPE, LIST_PTR, ITEM_INDEX)                                            \
 	(                                                                                                \
 		(LIST_PTR == NULL || (LIST_PTR)->node_count == 0 || ITEM_INDEX >= (LIST_PTR)->node_count) ?    \
 		NULL :                                                                                         \

src/base/strings/str8/str8.c

@@ -338,7 +338,7 @@ WpStr8List *wpStr8SplitWithMax(const WpAllocator *allocator, WpStr8RO *str, WpSt
 	if (delimiter->size > str->size) {
 		WpStr8 *full = wpStr8AllocStr8(allocator, str);
 		if (full) {
-			wpDblListPush_back_alloc(WpStr8, allocator, output, full);
+			wpDblListPushBackAlloc(WpStr8, allocator, output, full);
 		}
 
 		goto RETURN_STR8_SPLIT;
@@ -357,7 +357,7 @@ WpStr8List *wpStr8SplitWithMax(const WpAllocator *allocator, WpStr8RO *str, WpSt
 
 		before_str = wpStr8AllocSubstr(allocator, str, start, start + end);
 		if (before_str) {
-			wpDblListPush_back_alloc(WpStr8, allocator, output, before_str);
+			wpDblListPushBackAlloc(WpStr8, allocator, output, before_str);
 		}
 
 		wpMemAllocatorFree(allocator, (void **)&rest, sizeof(WpStr8));
@@ -370,7 +370,7 @@ WpStr8List *wpStr8SplitWithMax(const WpAllocator *allocator, WpStr8RO *str, WpSt
 	// Ensure the last part of the string after the delimiter is added to the list
 	rest = wpStr8AllocSubstr(allocator, str, start, str->size);
 	if (rest) {
-		wpDblListPush_back_alloc(WpStr8, allocator, output, rest);
+		wpDblListPushBackAlloc(WpStr8, allocator, output, rest);
 	}
 
 RETURN_STR8_SPLIT:
@@ -385,7 +385,7 @@ WpStr8List *wpStr8RsplitWithMax(const WpAllocator *allocator, WpStr8RO *str, WpS
 	if (delimiter->size > str->size) {
 		WpStr8 *full = wpStr8AllocStr8(allocator, str);
 		if (full) {
-			wpDblListPush_back_alloc(WpStr8, allocator, output, full);
+			wpDblListPushBackAlloc(WpStr8, allocator, output, full);
 		}
 
 		goto RETURN_STR8_SPLIT;
@@ -403,7 +403,7 @@ WpStr8List *wpStr8RsplitWithMax(const WpAllocator *allocator, WpStr8RO *str, WpS
 
 		after_str = wpStr8AllocSubstr(allocator, rest, end + delimiter->size, str->size);
 		if (after_str) {
-			wpDblListPush_front_alloc(WpStr8, allocator, output, after_str);
+			wpDblListPushFrontAlloc(WpStr8, allocator, output, after_str);
 		}
 
 		wpMemAllocatorFree(allocator, (void **)&rest, sizeof(WpStr8));
@@ -414,7 +414,7 @@ WpStr8List *wpStr8RsplitWithMax(const WpAllocator *allocator, WpStr8RO *str, WpS
 
 	rest = wpStr8AllocSubstr(allocator, str, 0, rest->size);
 	if (rest) {
-		wpDblListPush_front_alloc(WpStr8, allocator, output, rest);
+		wpDblListPushFrontAlloc(WpStr8, allocator, output, rest);
 	}
 
 RETURN_STR8_SPLIT:

src/log/log.c

@@ -16,11 +16,11 @@ wp_intern WpStr8RO R_BRACKET_SPACE   = wpStr8LitRo("] ");
 wp_intern WpStr8RO R_BRACKET_NEWLINE = wpStr8LitRo("]\n");
 
 typedef struct {
-	WFile *outlog;
-	WFile *errlog;
+	WpFile *outlog;
+	WpFile *errlog;
 	WpLogLevel level;
 
-	wpMiscUtilsReservePadding(2 * sizeof(WFile *) + sizeof(WpLogLevel));
+	wpMiscUtilsReservePadding(2 * sizeof(WpFile *) + sizeof(WpLogLevel));
 } LogConfig;
 
 wp_intern LogConfig LOG_CONFIG = {
@@ -36,13 +36,13 @@ wp_intern WpStr8RO LOG_LEVEL_STRINGS[COUNT_LOG_LEVEL] = {
 };
 
 wp_intern void _get_current_time_string(WpStr8 *dst);
-wp_intern void _write_log_line(WFile *fp, const WpLogger *logger, WpStr8 msg, WpLogLevel level);
+wp_intern void _write_log_line(WpFile *fp, const WpLogger *logger, WpStr8 msg, WpLogLevel level);
 
 void wpLogSetLevel(WpLogLevel level) {
 	LOG_CONFIG.level = level;
 }
 
-void wpLogConfigure(WFile *outlog, WFile *errlog, WpLogLevel level) {
+void wpLogConfigure(WpFile *outlog, WpFile *errlog, WpLogLevel level) {
 	LOG_CONFIG.outlog = outlog;
 	LOG_CONFIG.errlog = errlog;
 	LOG_CONFIG.level  = level;
@@ -56,7 +56,7 @@ void wpLogDebug(const WpLogger *logger, WpStr8 msg) {
 	wpDebugAssert(logger != NULL, "`logger` should not be NULL");
 	if (LOG_CONFIG.level < WP_LOG_LEVEL_DEBUG) { return; }
 
-	WFile *fp = LOG_CONFIG.outlog != NULL ? LOG_CONFIG.outlog : wapp_file_stdout();
+	WpFile *fp = LOG_CONFIG.outlog != NULL ? LOG_CONFIG.outlog : wpFileStdout();
 	_write_log_line(fp, logger, msg, WP_LOG_LEVEL_DEBUG);
 }
 
@@ -64,7 +64,7 @@ void wpLogInfo(const WpLogger *logger, WpStr8 msg) {
 	wpDebugAssert(logger != NULL, "`logger` should not be NULL");
 	if (LOG_CONFIG.level < WP_LOG_LEVEL_INFO) { return; }
 
-	WFile *fp = LOG_CONFIG.outlog != NULL ? LOG_CONFIG.outlog : wapp_file_stdout();
+	WpFile *fp = LOG_CONFIG.outlog != NULL ? LOG_CONFIG.outlog : wpFileStdout();
 	_write_log_line(fp, logger, msg, WP_LOG_LEVEL_INFO);
 }
 
@@ -72,7 +72,7 @@ void wpLogWarning(const WpLogger *logger, WpStr8 msg) {
 	wpDebugAssert(logger != NULL, "`logger` should not be NULL");
 	if (LOG_CONFIG.level < WP_LOG_LEVEL_WARNING) { return; }
 
-	WFile *fp = LOG_CONFIG.outlog != NULL ? LOG_CONFIG.outlog : wapp_file_stdout();
+	WpFile *fp = LOG_CONFIG.outlog != NULL ? LOG_CONFIG.outlog : wpFileStdout();
 	_write_log_line(fp, logger, msg, WP_LOG_LEVEL_WARNING);
 }
 
@@ -80,7 +80,7 @@ void wpLogError(const WpLogger *logger, WpStr8 msg) {
 	wpDebugAssert(logger != NULL, "`logger` should not be NULL");
 	if (LOG_CONFIG.level < WP_LOG_LEVEL_ERROR) { return; }
 
-	WFile *fp = LOG_CONFIG.errlog != NULL ? LOG_CONFIG.errlog : wapp_file_stderr();
+	WpFile *fp = LOG_CONFIG.errlog != NULL ? LOG_CONFIG.errlog : wpFileStderr();
 	_write_log_line(fp, logger, msg, WP_LOG_LEVEL_ERROR);
 }
 
@@ -88,7 +88,7 @@ void wpLogCritical(const WpLogger *logger, WpStr8 msg) {
 	wpDebugAssert(logger != NULL, "`logger` should not be NULL");
 	if (LOG_CONFIG.level < WP_LOG_LEVEL_CRITICAL) { return; }
 
-	WFile *fp = LOG_CONFIG.errlog != NULL ? LOG_CONFIG.errlog : wapp_file_stderr();
+	WpFile *fp = LOG_CONFIG.errlog != NULL ? LOG_CONFIG.errlog : wpFileStderr();
 	_write_log_line(fp, logger, msg, WP_LOG_LEVEL_CRITICAL);
 }
 
@@ -96,7 +96,7 @@ void wpLogFatal(const WpLogger *logger, WpStr8 msg) {
 	wpDebugAssert(logger != NULL, "`logger` should not be NULL");
 	if (LOG_CONFIG.level < WP_LOG_LEVEL_FATAL) { return; }
 
-	WFile *fp = LOG_CONFIG.errlog != NULL ? LOG_CONFIG.errlog : wapp_file_stderr();
+	WpFile *fp = LOG_CONFIG.errlog != NULL ? LOG_CONFIG.errlog : wpFileStderr();
 	_write_log_line(fp, logger, msg, WP_LOG_LEVEL_FATAL);
 }
 
@@ -110,7 +110,7 @@ wp_intern void _get_current_time_string(WpStr8 *dst) {
 	wpStr8CopyCstrCapped(dst, buf);
 }
 
-wp_intern void _write_log_line(WFile *fp, const WpLogger *logger, WpStr8 msg, WpLogLevel level) {
+wp_intern void _write_log_line(WpFile *fp, const WpLogger *logger, WpStr8 msg, WpLogLevel level) {
 	WpStr8 padding     = wpStr8Buf(MIN_LOG_MSG_LENGTH);
 	u32 padding_size = msg.size < MIN_LOG_MSG_LENGTH ? MIN_LOG_MSG_LENGTH - msg.size + 1 : 0;
 	wpStr8Format(&padding, "%-*s", padding_size, " ");
@@ -118,7 +118,7 @@ wp_intern void _write_log_line(WFile *fp, const WpLogger *logger, WpStr8 msg, Wp
 	WpStr8 time_str = wpStr8Buf(TIME_BUF_CAPACITY);
 	_get_current_time_string(&time_str);
 
-	WpStr8RO **strings = wapp_array(
+	WpStr8RO **strings = wpArray(
 		WpStr8RO *,
 		&time_str,
 		&L_BRACKET,
@@ -131,7 +131,7 @@ wp_intern void _write_log_line(WFile *fp, const WpLogger *logger, WpStr8 msg, Wp
 		&R_BRACKET_NEWLINE
 	);
 
-	for (u64 i = 0; i < wapp_array_count(strings); ++i) {
-		wapp_file_write_str8(strings[i], fp);
+	for (u64 i = 0; i < wpArrayCount(strings); ++i) {
+		wpFileWriteStr8(strings[i], fp);
 	}
 }

src/log/log.h

@@ -22,7 +22,7 @@ typedef struct {
 } WpLogger;
 
 void wpLogSetLevel(WpLogLevel level);
-void wpLogConfigure(WFile *outlog, WFile *errlog, WpLogLevel level);
+void wpLogConfigure(WpFile *outlog, WpFile *errlog, WpLogLevel level);
 WpLogger wpLogMakeLogger(WpStr8 name);
 void wpLogDebug(const WpLogger *logger, WpStr8 msg);
 void wpLogInfo(const WpLogger *logger, WpStr8 msg);

src/oldnames.h

@@ -0,0 +1,597 @@
+// vim:fileencoding=utf-8:foldmethod=marker
+//
+// oldnames.h — backward-compatible #define mappings for renames in the
+// wizapp-stdlib naming-conventions branch.
+//
+// Every public API symbol that was renamed is mapped from its old name to
+// its new name so that existing code continues to compile without changes.
+//
+// Rename patterns applied across all modules:
+//   wapp_xxx()  →  wpXxx()
+//   WAPP_XXX    →  WP_XXX
+//   GenericXxx  →  WpXxx
+//   SHELL_XXX   →  WP_SHELL_XXX
+//   _xxx_yyy()  →  _xxxYyy()
+//
+// Sections: Constants → Types → Functions
+
+#ifndef OLDNAMES_H
+#define OLDNAMES_H
+
+// ============================================================================
+// ===== Constants =====
+// ============================================================================
+
+// --- Aliases ---
+
+#define WAPP_PLATFORM_CPP    WP_PLATFORM_CPP
+#define WAPP_PLATFORM_C      WP_PLATFORM_C
+
+// --- Arena ---
+
+#define WAPP_MEM_ALLOC_RESERVE WP_MEM_ALLOC_RESERVE
+#define WAPP_MEM_ALLOC_COMMIT  WP_MEM_ALLOC_COMMIT
+
+// --- Array ---
+
+#define WAPP_ARRAY_MAGIC     WP_ARRAY_MAGIC
+#define ARRAY_INIT_NONE      WP_ARRAY_INIT_NONE
+#define ARRAY_INIT_FILLED    WP_ARRAY_INIT_FILLED
+
+// --- Assert ---
+
+#define WAPP_NO_RUNTIME_ASSERT  WP_NO_RUNTIME_ASSERT
+#define WAPP_DEBUG_ASSERT       WP_DEBUG_ASSERT
+
+// --- CPath ---
+
+#define WAPP_PATH_SEP WP_PATH_SEP
+#define WAPP_PATH_MAX WP_PATH_MAX
+
+#define CPATH_JOIN_SUCCESS                    WP_CPATH_JOIN_RESULT_SUCCESS
+#define CPATH_JOIN_INVALID_ARGS               WP_CPATH_JOIN_RESULT_INVALID_ARGS
+#define CPATH_JOIN_EMPTY_PARTS                WP_CPATH_JOIN_RESULT_EMPTY_PARTS
+#define CPATH_JOIN_INSUFFICIENT_DST_CAPACITY  WP_CPATH_JOIN_RESULT_INSUFFICIENT_DST_CAPACITY
+
+// --- DblList ---
+
+#define WAPP_DBL_LIST_MAGIC WP_DBL_LIST_MAGIC
+#define WAPP_DBL_NODE_MAGIC WP_DBL_NODE_MAGIC
+
+// --- File ---
+
+#define WAPP_ACCESS_READ                    WP_ACCESS_READ
+#define WAPP_ACCESS_WRITE                   WP_ACCESS_WRITE
+#define WAPP_ACCESS_APPEND                  WP_ACCESS_APPEND
+#define WAPP_ACCESS_READ_EX                 WP_ACCESS_READ_EX
+#define WAPP_ACCESS_WRITE_EX                WP_ACCESS_WRITE_EX
+#define WAPP_ACCESS_APPEND_EX               WP_ACCESS_APPEND_EX
+#define WAPP_ACCESS_WRITE_FAIL_ON_EXIST     WP_ACCESS_WRITE_FAIL_ON_EXIST
+#define WAPP_ACCESS_WRITE_FAIL_ON_EXIST_EX  WP_ACCESS_WRITE_FAIL_ON_EXIST_EX
+#define WAPP_SEEK_START                     WP_SEEK_START
+#define WAPP_SEEK_CURRENT                   WP_SEEK_CURRENT
+#define WAPP_SEEK_END                       WP_SEEK_END
+#define END_OF_LINE                         WP_END_OF_LINE
+
+// --- Log ---
+
+#define WAPP_LOG_FATAL     WP_LOG_LEVEL_FATAL
+#define WAPP_LOG_CRITICAL  WP_LOG_LEVEL_CRITICAL
+#define WAPP_LOG_ERROR     WP_LOG_LEVEL_ERROR
+#define WAPP_LOG_WARNING   WP_LOG_LEVEL_WARNING
+#define WAPP_LOG_INFO      WP_LOG_LEVEL_INFO
+#define WAPP_LOG_DEBUG     WP_LOG_LEVEL_DEBUG
+
+// --- Mem Os ---
+
+#define WAPP_MEM_ACCESS_NONE             WP_MEM_ACCESS_NONE
+#define WAPP_MEM_ACCESS_READ_ONLY        WP_MEM_ACCESS_READ_ONLY
+#define WAPP_MEM_ACCESS_EXEC_ONLY        WP_MEM_ACCESS_EXEC_ONLY
+#define WAPP_MEM_ACCESS_READ_WRITE       WP_MEM_ACCESS_READ_WRITE
+#define WAPP_MEM_ACCESS_READ_EXEC        WP_MEM_ACCESS_READ_EXEC
+#define WAPP_MEM_ACCESS_READ_WRITE_EXEC  WP_MEM_ACCESS_READ_WRITE_EXEC
+#define WAPP_MEM_INIT_UNINITIALISED      WP_MEM_INIT_UNINITIALISED
+#define WAPP_MEM_INIT_INITIALISED        WP_MEM_INIT_INITIALISED
+
+// --- Platform ---
+
+#define WAPP_PLATFORM_ANDROID        WP_PLATFORM_ANDROID
+#define WAPP_PLATFORM_FREE_BSD       WP_PLATFORM_FREE_BSD
+#define WAPP_PLATFORM_NET_BSD        WP_PLATFORM_NET_BSD
+#define WAPP_PLATFORM_OPEN_BSD       WP_PLATFORM_OPEN_BSD
+#define WAPP_PLATFORM_DRAGON_FLY     WP_PLATFORM_DRAGON_FLY
+#define WAPP_PLATFORM_BSD            WP_PLATFORM_BSD
+#define WAPP_PLATFORM_POSIX          WP_PLATFORM_POSIX
+#define WAPP_PLATFORM_LINUX          WP_PLATFORM_LINUX
+#define WAPP_PLATFORM_GNU            WP_PLATFORM_GNU
+#define WAPP_PLATFORM_IOS            WP_PLATFORM_IOS
+#define WAPP_PLATFORM_APPLE          WP_PLATFORM_APPLE
+#define WAPP_PLATFORM_MACOS          WP_PLATFORM_MACOS
+#define WAPP_PLATFORM_WINDOWS64      WP_PLATFORM_WINDOWS64
+#define WAPP_PLATFORM_WINDOWS32      WP_PLATFORM_WINDOWS32
+#define WAPP_PLATFORM_WINDOWS        WP_PLATFORM_WINDOWS
+#define WAPP_PLATFORM_CYGWIN         WP_PLATFORM_CYGWIN
+#define WAPP_PLATFORM_UNIX           WP_PLATFORM_UNIX
+#define WAPP_PLATFORM_CPP_VERSION    WP_PLATFORM_CPP_VERSION
+#define WAPP_PLATFORM_CPP98_VERSION  WP_PLATFORM_CPP98_VERSION
+#define WAPP_PLATFORM_CPP11_VERSION  WP_PLATFORM_CPP11_VERSION
+#define WAPP_PLATFORM_CPP14_VERSION  WP_PLATFORM_CPP14_VERSION
+#define WAPP_PLATFORM_CPP17_VERSION  WP_PLATFORM_CPP17_VERSION
+#define WAPP_PLATFORM_CPP20_VERSION  WP_PLATFORM_CPP20_VERSION
+#define WAPP_PLATFORM_CPP23_VERSION  WP_PLATFORM_CPP23_VERSION
+#define WAPP_PLATFORM_CPP98          WP_PLATFORM_CPP98
+#define WAPP_PLATFORM_CPP11          WP_PLATFORM_CPP11
+#define WAPP_PLATFORM_CPP14          WP_PLATFORM_CPP14
+#define WAPP_PLATFORM_CPP17          WP_PLATFORM_CPP17
+#define WAPP_PLATFORM_CPP20          WP_PLATFORM_CPP20
+#define WAPP_PLATFORM_CPP23          WP_PLATFORM_CPP23
+#define WAPP_PLATFORM_C_VERSION      WP_PLATFORM_C_VERSION
+#define WAPP_PLATFORM_C99_VERSION    WP_PLATFORM_C99_VERSION
+#define WAPP_PLATFORM_C11_VERSION    WP_PLATFORM_C11_VERSION
+#define WAPP_PLATFORM_C17_VERSION    WP_PLATFORM_C17_VERSION
+#define WAPP_PLATFORM_C23_VERSION    WP_PLATFORM_C23_VERSION
+#define WAPP_PLATFORM_C99            WP_PLATFORM_C99
+#define WAPP_PLATFORM_C11            WP_PLATFORM_C11
+#define WAPP_PLATFORM_C17            WP_PLATFORM_C17
+#define WAPP_PLATFORM_C23            WP_PLATFORM_C23
+#define WAPP_PLATFORM_C89            WP_PLATFORM_C89
+
+// --- Shell Commander ---
+
+#define SHELL_OUTPUT_DISCARD       WP_SHELL_OUTPUT_DISCARD
+#define SHELL_OUTPUT_PRINT         WP_SHELL_OUTPUT_PRINT
+#define SHELL_OUTPUT_CAPTURE       WP_SHELL_OUTPUT_CAPTURE
+#define SHELL_ERR_NO_ERROR         WP_SHELL_ERR_NO_ERROR
+#define SHELL_ERR_INVALID_ARGS     WP_SHELL_ERR_INVALID_ARGS
+#define SHELL_ERR_ALLOCATION_FAIL  WP_SHELL_ERR_ALLOCATION_FAIL
+#define SHELL_ERR_PROC_START_FAIL  WP_SHELL_ERR_PROC_START_FAIL
+#define SHELL_ERR_OUT_BUF_FULL     WP_SHELL_ERR_OUT_BUF_FULL
+#define SHELL_ERR_PROC_EXIT_FAIL   WP_SHELL_ERR_PROC_EXIT_FAIL
+
+// --- Shell Termcolour ---
+
+#define WAPP_TERM_COLOUR_FG_BLACK       WP_TERM_COLOUR_FG_BLACK
+#define WAPP_TERM_COLOUR_FG_RED         WP_TERM_COLOUR_FG_RED
+#define WAPP_TERM_COLOUR_FG_GREEN       WP_TERM_COLOUR_FG_GREEN
+#define WAPP_TERM_COLOUR_FG_BLUE        WP_TERM_COLOUR_FG_BLUE
+#define WAPP_TERM_COLOUR_FG_CYAN        WP_TERM_COLOUR_FG_CYAN
+#define WAPP_TERM_COLOUR_FG_MAGENTA     WP_TERM_COLOUR_FG_MAGENTA
+#define WAPP_TERM_COLOUR_FG_YELLOW      WP_TERM_COLOUR_FG_YELLOW
+#define WAPP_TERM_COLOUR_FG_WHITE       WP_TERM_COLOUR_FG_WHITE
+#define WAPP_TERM_COLOUR_FG_BR_BLACK    WP_TERM_COLOUR_FG_BR_BLACK
+#define WAPP_TERM_COLOUR_FG_BR_RED      WP_TERM_COLOUR_FG_BR_RED
+#define WAPP_TERM_COLOUR_FG_BR_GREEN    WP_TERM_COLOUR_FG_BR_GREEN
+#define WAPP_TERM_COLOUR_FG_BR_BLUE     WP_TERM_COLOUR_FG_BR_BLUE
+#define WAPP_TERM_COLOUR_FG_BR_CYAN     WP_TERM_COLOUR_FG_BR_CYAN
+#define WAPP_TERM_COLOUR_FG_BR_MAGENTA  WP_TERM_COLOUR_FG_BR_MAGENTA
+#define WAPP_TERM_COLOUR_FG_BR_YELLOW   WP_TERM_COLOUR_FG_BR_YELLOW
+#define WAPP_TERM_COLOUR_FG_BR_WHITE    WP_TERM_COLOUR_FG_BR_WHITE
+#define WAPP_TERM_COLOUR_CLEAR          WP_TERM_COLOUR_CLEAR
+
+// --- Str8 ---
+
+#define WAPP_STR8_SPEC WP_STR8_SPEC
+
+// --- UUID ---
+
+#define UUID_BUF_LENGTH WP_UUID_BUF_LENGTH
+#define WAPP_UUID_SPEC  WP_UUID_SPEC
+
+// ============================================================================
+// ===== Types =====
+// ============================================================================
+
+// --- Aliases ---
+
+#define wapp_extern    wp_extern
+#define wapp_intern    wp_intern
+#define wapp_persist   wp_persist
+#define wapp_class_mem wp_class_mem
+
+// --- Arena ---
+
+#define Arena WpArena
+
+// --- Array ---
+
+#define GenericArray    WpArray
+#define VoidPtrArray    WpVoidPtrArray
+#define C8Array         WpC8Array
+#define C16Array        WpC16Array
+#define C32Array        WpC32Array
+#define U8Array         WpU8Array
+#define U16Array        WpU16Array
+#define U32Array        WpU32Array
+#define U64Array        WpU64Array
+#define B8Array         WpB8Array
+#define I8Array         WpI8Array
+#define I16Array        WpI16Array
+#define I32Array        WpI32Array
+#define I64Array        WpI64Array
+#define F32Array        WpF32Array
+#define F64Array        WpF64Array
+#define F128Array       WpF128Array
+#define UptrArray       WpUptrArray
+#define IptrArray       WpIptrArray
+#define Str8Array       WpStr8Array
+#define ArrayHeader     WpArrayHeader
+#define ArrayInitFlags  WpArrayInitFlags
+
+// --- DblList ---
+
+#define GenericNode      WpDblNode
+#define NodeHeader       WpDblNodeHeader
+#define GenericList      WpDblList
+#define VoidPtrList      WpVoidPtrList
+#define C8List           WpC8List
+#define C16List          WpC16List
+#define C32List          WpC32List
+#define U8List           WpU8List
+#define U16List          WpU16List
+#define U32List          WpU32List
+#define U64List          WpU64List
+#define B8List           WpB8List
+#define I8List           WpI8List
+#define I16List          WpI16List
+#define I32List          WpI32List
+#define I64List          WpI64List
+#define F32List          WpF32List
+#define F64List          WpF64List
+#define F128List         WpF128List
+#define UptrList         WpUptrList
+#define IptrList         WpIptrList
+#define Str8List         WpStr8List
+#define VoidPtrNode      WpVoidPtrNode
+#define C8Node           WpC8Node
+#define C16Node          WpC16Node
+#define C32Node          WpC32Node
+#define U8Node           WpU8Node
+#define U16Node          WpU16Node
+#define U32Node          WpU32Node
+#define U64Node          WpU64Node
+#define B8Node           WpB8Node
+#define I8Node           WpI8Node
+#define I16Node          WpI16Node
+#define I32Node          WpI32Node
+#define I64Node          WpI64Node
+#define F32Node          WpF32Node
+#define F64Node          WpF64Node
+#define F128Node         WpF128Node
+#define UptrNode         WpUptrNode
+#define IptrNode         WpIptrNode
+#define Str8Node         WpStr8Node
+
+// --- File ---
+
+#define WFile           WpFile
+#define FileAccessMode  WpFileAccessMode
+#define FileSeekOrigin  WpFileSeekOrigin
+
+// --- Log ---
+
+#define LogLevel WpLogLevel
+#define Logger   WpLogger
+
+// --- Mem Allocator ---
+
+#define Allocator              WpAllocator
+#define MemAllocFunc           WpMemAllocFunc
+#define MemAllocAlignedFunc    WpMemAllocAlignedFunc
+#define MemReallocFunc         WpMemReallocFunc
+#define MemReallocAlignedFunc  WpMemReallocAlignedFunc
+#define MemFreeFunc            WpMemFreeFunc
+
+// --- Mem Os ---
+
+#define MemAccess      WpMemAccess
+#define MemInitType    WpMemInitType
+#define MemAllocFlags  WpMemAllocFlags
+
+// --- PRNG Xorshift ---
+
+#define XOR256State WpXor256State
+
+// --- Queue ---
+
+#define GenericQueue   WpQueue
+#define VoidPtrQueue   WpVoidPtrQueue
+#define C8Queue        WpC8Queue
+#define C16Queue       WpC16Queue
+#define C32Queue       WpC32Queue
+#define U8Queue        WpU8Queue
+#define U16Queue       WpU16Queue
+#define U32Queue       WpU32Queue
+#define U64Queue       WpU64Queue
+#define B8Queue        WpB8Queue
+#define I8Queue        WpI8Queue
+#define I16Queue       WpI16Queue
+#define I32Queue       WpI32Queue
+#define I64Queue       WpI64Queue
+#define F32Queue       WpF32Queue
+#define F64Queue       WpF64Queue
+#define F128Queue      WpF128Queue
+#define UptrQueue      WpUptrQueue
+#define IptrQueue      WpIptrQueue
+#define Str8Queue      WpStr8Queue
+
+// --- Shell Commander ---
+
+#define CMDResult        WpCmdResult
+#define CMDOutHandling   WpCmdOutHandling
+#define CMDError         WpCmdError
+
+// --- Shell Termcolour ---
+
+#define TerminalColour WpTerminalColour
+
+// --- Str8 ---
+
+#define Str8   WpStr8
+#define Str8RO WpStr8RO
+
+// --- Tester ---
+
+#define TestFuncResult WpTestFuncResult
+#define TestFunc       WpTestFunc
+
+// --- UUID ---
+
+#define WUUID WpUuid
+
+// ============================================================================
+// ===== Functions =====
+// ============================================================================
+
+// --- Arena ---
+
+#define wapp_mem_arena_init_allocated                  wpMemArenaInitAllocated
+#define wapp_mem_arena_init_allocated_commit           wpMemArenaInitAllocatedCommit
+#define wapp_mem_arena_init_allocated_zero             wpMemArenaInitAllocatedZero
+#define wapp_mem_arena_init_allocated_commit_and_zero  wpMemArenaInitAllocatedCommitAndZero
+#define wapp_mem_arena_init_allocated_custom           wpMemArenaInitAllocatedCustom
+#define wapp_mem_arena_init_buffer                     wpMemArenaInitBuffer
+#define wapp_mem_arena_alloc                           wpMemArenaAlloc
+#define wapp_mem_arena_alloc_aligned                   wpMemArenaAllocAligned
+#define wapp_mem_arena_realloc                         wpMemArenaRealloc
+#define wapp_mem_arena_realloc_aligned                 wpMemArenaReallocAligned
+#define wapp_mem_arena_temp_begin                      wpMemArenaTempBegin
+#define wapp_mem_arena_temp_end                        wpMemArenaTempEnd
+#define wapp_mem_arena_clear                           wpMemArenaClear
+#define wapp_mem_arena_destroy                         wpMemArenaDestroy
+
+#define wapp_mem_arena_allocator_init                  wpMemArenaAllocatorInit
+#define wapp_mem_arena_allocator_init_commit           wpMemArenaAllocatorInitCommit
+#define wapp_mem_arena_allocator_init_zero             wpMemArenaAllocatorInitZero
+#define wapp_mem_arena_allocator_init_commit_and_zero  wpMemArenaAllocatorInitCommitAndZero
+#define wapp_mem_arena_allocator_init_custom           wpMemArenaAllocatorInitCustom
+#define wapp_mem_arena_allocator_init_with_buffer      wpMemArenaAllocatorInitWithBuffer
+#define wapp_mem_arena_allocator_temp_begin            wpMemArenaAllocatorTempBegin
+#define wapp_mem_arena_allocator_temp_end              wpMemArenaAllocatorTempEnd
+#define wapp_mem_arena_allocator_clear                 wpMemArenaAllocatorClear
+#define wapp_mem_arena_allocator_destroy               wpMemArenaAllocatorDestroy
+
+// --- Array ---
+
+#define wapp_array                          wpArray
+#define wapp_array_with_capacity            wpArrayWithCapacity
+#define wapp_array_pop                      wpArrayPop
+#define wapp_array_count                    wpArrayCount
+#define wapp_array_capacity                 wpArrayCapacity
+#define wapp_array_item_size                wpArrayItemSize
+#define wapp_array_set_count                wpArraySetCount
+#define wapp_array_get                      wpArrayGet
+#define wapp_array_set                      wpArraySet
+#define wapp_array_append_capped            wpArrayAppendCapped
+#define wapp_array_extend_capped            wpArrayExtendCapped
+#define wapp_array_copy_capped              wpArrayCopyCapped
+#define wapp_array_append_alloc             wpArrayAppendAlloc
+#define wapp_array_extend_alloc             wpArrayExtendAlloc
+#define wapp_array_copy_alloc               wpArrayCopyAlloc
+#define wapp_array_clear                    wpArrayClear
+#define wapp_array_calc_alloc_size          wpArrayCalcAllocSize
+#define wapp_array_alloc_capacity           wpArrayAllocCapacity
+#define wapp_array_from_preallcated_buffer  wpArrayFromPreallcatedBuffer
+
+// --- Assert ---
+
+#define wapp_static_assert   wpStaticAssert
+#define wapp_runtime_assert  wpRuntimeAssert
+#define wapp_debug_assert    wpDebugAssert
+
+// --- CPath ---
+
+#define wapp_cpath_dirname    wpCpathDirname
+#define wapp_cpath_dirup      wpCpathDirup
+#define wapp_cpath_join_path  wpCpathJoinPath
+#define dirup                 _dirup
+
+// --- DblList ---
+
+#define wapp_dbl_list                   wpDblList
+#define wapp_dbl_list_alloc             wpDblListAlloc
+#define wapp_dbl_list_get               wpDblListGet
+#define wapp_dbl_list_get_node          wpDblListGetNode
+#define wapp_dbl_list_get_node_item     wpDblListGetNodeItem
+#define wapp_dbl_list_push_front        wpDblListPushFront
+#define wapp_dbl_list_push_back         wpDblListPushBack
+#define wapp_dbl_list_insert            wpDblListInsert
+#define wapp_dbl_list_push_front_alloc  wpDblListPushFrontAlloc
+#define wapp_dbl_list_push_back_alloc   wpDblListPushBackAlloc
+#define wapp_dbl_list_insert_alloc      wpDblListInsertAlloc
+#define wapp_dbl_list_pop_front         wpDblListPopFront
+#define wapp_dbl_list_pop_back          wpDblListPopBack
+#define wapp_dbl_list_remove            wpDblListRemove
+#define wapp_dbl_list_pop_front_node    wpDblListPopFrontNode
+#define wapp_dbl_list_pop_back_node     wpDblListPopBackNode
+#define wapp_dbl_list_remove_node       wpDblListRemoveNode
+#define wapp_dbl_list_empty             wpDblListEmpty
+
+#define _dbl_list_alloc       _dblListAlloc
+#define _dbl_list_node_alloc  _dblListNodeAlloc
+#define _dbl_list_get         _dblListGet
+#define _dbl_list_push_front  _dblListPushFront
+#define _dbl_list_push_back   _dblListPushBack
+#define _dbl_list_insert      _dblListInsert
+#define _dbl_list_pop_front   _dblListPopFront
+#define _dbl_list_pop_back    _dblListPopBack
+#define _dbl_list_remove      _dblListRemove
+#define _dbl_list_empty       _dblListEmpty
+
+// --- File ---
+
+#define wapp_file_stdin                 wpFileStdin
+#define wapp_file_stdout                wpFileStdout
+#define wapp_file_stderr                wpFileStderr
+#define wapp_file_open                  wpFileOpen
+#define wapp_file_get_current_position  wpFileGetCurrentPosition
+#define wapp_file_seek                  wpFileSeek
+#define wapp_file_get_length            wpFileGetLength
+#define wapp_file_read                  wpFileRead
+#define wapp_file_write                 wpFileWrite
+#define wapp_file_read_str8             wpFileReadStr8
+#define wapp_file_write_str8            wpFileWriteStr8
+#define wapp_file_read_array            wpFileReadArray
+#define wapp_file_write_array           wpFileWriteArray
+#define wapp_file_flush                 wpFileFlush
+#define wapp_file_close                 wpFileClose
+#define wapp_file_rename                wpFileRename
+#define wapp_file_remove                wpFileRemove
+
+#define _file_open    _fileOpen
+#define _file_seek    _fileSeek
+#define _file_read    _fileRead
+#define _file_write   _fileWrite
+#define _file_flush   _fileFlush
+#define _file_close   _fileClose
+#define _file_rename  _fileRename
+#define _file_remove  _fileRemove
+
+// --- Log ---
+
+#define wapp_log_set_level    wpLogSetLevel
+#define wapp_log_configure    wpLogConfigure
+#define wapp_log_make_logger  wpLogMakeLogger
+#define wapp_log_debug        wpLogDebug
+#define wapp_log_info         wpLogInfo
+#define wapp_log_warning      wpLogWarning
+#define wapp_log_error        wpLogError
+#define wapp_log_critical     wpLogCritical
+#define wapp_log_fatal        wpLogFatal
+
+// --- Mem Allocator ---
+
+#define wapp_mem_allocator_invalid          wpMemAllocatorInvalid
+#define wapp_mem_allocator_alloc            wpMemAllocatorAlloc
+#define wapp_mem_allocator_alloc_aligned    wpMemAllocatorAllocAligned
+#define wapp_mem_allocator_realloc          wpMemAllocatorRealloc
+#define wapp_mem_allocator_realloc_aligned  wpMemAllocatorReallocAligned
+#define wapp_mem_allocator_free             wpMemAllocatorFree
+
+// --- Mem Os ---
+
+#define wapp_os_mem_alloc  wpOsMemAlloc
+#define wapp_os_mem_free   wpOsMemFree
+#define os_mem_allocate    _osMemAllocate
+#define os_mem_free        _osMemFree
+
+// --- Mem Utils ---
+
+#define wapp_mem_util_align_forward wpMemUtilAlignForward
+
+// --- Misc Utils ---
+
+#define wapp_misc_utils_reserve_padding    wpMiscUtilsReservePadding
+#define wapp_misc_utils_u64_round_up_pow2  wpMiscUtilsU64RoundUpPow2
+#define wapp_is_power_of_two               wpMiscUtilsIsPowerOfTwo
+#define wapp_pointer_offset                wpMiscUtilsOffsetPointer
+#define wapp_misc_utils_va_args_count      wpMiscUtilsVaArgsCount
+
+// --- PRNG Xorshift ---
+
+#define wapp_prng_xorshift_init_state  wpPrngXorshiftInit
+#define wapp_prng_xorshift_256         wpPrngXorshift256
+#define wapp_prng_xorshift_256ss       wpPrngXorshift256ss
+#define wapp_prng_xorshift_256p        wpPrngXorshift256p
+
+// --- Queue ---
+
+#define wapp_queue                   wpQueue
+#define wapp_queue_alloc             wpQueueAlloc
+#define wapp_queue_capacity          wpQueueCapacity
+#define wapp_queue_item_size         wpQueueItemSize
+#define wapp_queue_push              wpQueuePush
+#define wapp_queue_push_alloc        wpQueuePushAlloc
+#define wapp_queue_pop               wpQueuePop
+
+#define _queue_push        _queuePush
+#define _queue_push_alloc  _queuePushAlloc
+#define _queue_pop         _queuePop
+
+// --- Shell Commander ---
+
+#define CMD_NO_EXIT                   wpCmdNoExit
+#define wapp_shell_commander_execute  wpShellCommanderExecute
+#define get_output_status             _getOutputStatus
+
+// --- Shell Termcolour ---
+
+#define wapp_shell_termcolour_print_text    wpShellTermcolourPrintText
+#define wapp_shell_termcolour_clear_colour  wpShellTermcolourClearColour
+#define print_coloured_text                 _printColouredText
+
+// --- Shell Utils ---
+
+#define wapp_shell_utils_popen   wpShellUtilsPopen
+#define wapp_shell_utils_pclose  wpShellUtilsPclose
+
+// --- Str8 ---
+
+#define wapp_str8_varg                        wpStr8Varg
+#define wapp_str8_buf                         wpStr8Buf
+#define wapp_str8_lit                         wpStr8Lit
+#define wapp_str8_lit_ro                      wpStr8LitRo
+#define wapp_str8_lit_ro_initialiser_list     wpStr8LitRoInitialiserList
+#define wapp_str8_alloc_buf                   wpStr8AllocBuf
+#define wapp_str8_alloc_and_fill_buf          wpStr8AllocAndFillBuf
+#define wapp_str8_alloc_cstr                  wpStr8AllocCstr
+#define wapp_str8_alloc_str8                  wpStr8AllocStr8
+#define wapp_str8_alloc_substr                wpStr8AllocSubstr
+#define wapp_str8_alloc_concat                wpStr8AllocConcat
+#define wapp_str8_dealloc_buf                 wpStr8DeallocBuf
+#define wapp_str8_get                         wpStr8Get
+#define wapp_str8_set                         wpStr8Set
+#define wapp_str8_push_back                   wpStr8PushBack
+#define wapp_str8_equal                       wpStr8Equal
+#define wapp_str8_equal_to_count              wpStr8EqualToCount
+#define wapp_str8_slice                       wpStr8Slice
+#define wapp_str8_concat_capped               wpStr8ConcatCapped
+#define wapp_str8_copy_cstr_capped            wpStr8CopyCstrCapped
+#define wapp_str8_copy_str8_capped            wpStr8CopyStr8Capped
+#define wapp_str8_copy_to_cstr                wpStr8CopyToCstr
+#define wapp_str8_format                      wpStr8Format
+#define wapp_str8_to_lower                    wpStr8ToLower
+#define wapp_str8_to_upper                    wpStr8ToUpper
+#define wapp_str8_from_bytes                  wpStr8FromBytes
+#define wapp_str8_find                        wpStr8Find
+#define wapp_str8_rfind                       wpStr8Rfind
+#define wapp_str8_split                       wpStr8Split
+#define wapp_str8_rsplit                      wpStr8Rsplit
+#define wapp_str8_split_with_max              wpStr8SplitWithMax
+#define wapp_str8_rsplit_with_max             wpStr8RsplitWithMax
+#define wapp_str8_join                        wpStr8Join
+#define wapp_str8_list_total_size             wpStr8ListTotalSize
+
+// --- Tester ---
+
+#define wapp_tester_result  wpTesterResult
+#define wapp_tester_run     wpTesterRun
+#define run_tests           _runTests
+
+// --- UUID ---
+
+#define wapp_uuid_varg        wpUuidVarg
+#define wapp_uuid_gen_uuid4   wpUuidGenUuid4
+#define wapp_uuid_create      wpUuidCreate
+#define wapp_uuid_init_uuid4  wpUuidInitUuid4
+
+#endif // !OLDNAMES_H

src/os/allocators/arena/mem_arena.c

@@ -21,7 +21,7 @@ typedef enum {
 	ARENA_STORAGE_TYPE_BUFFER,
 } ArenaStorageType;
 
-struct Arena {
+struct WpArena {
 	u8 *buf;
 	u8 *offset;
 	u8 *prev_offset;
@@ -32,63 +32,63 @@ struct Arena {
 	wpMiscUtilsReservePadding(sizeof(u8 *) * 3 + sizeof(u64) + sizeof(ArenaStorageType) + sizeof(b8));
 };
 
-b8 wapp_mem_arena_init_buffer(Arena **arena, u8 *buffer, u64 buffer_size) {
-	if (!arena || *arena || buffer_size < sizeof(Arena)) {
+b8 wpMemArenaInitBuffer(WpArena **arena, u8 *buffer, u64 buffer_size) {
+	if (!arena || *arena || buffer_size < sizeof(WpArena)) {
 		return false;
 	}
 
-	*arena           = (Arena *)buffer;
-	Arena *arena_ptr = *arena;
+	*arena           = (WpArena *)buffer;
+	WpArena *arena_ptr = *arena;
 
 	arena_ptr->buf         = (u8 *)(arena_ptr + 1);
 	arena_ptr->offset      = arena_ptr->buf;
 	arena_ptr->prev_offset = NULL;
-	arena_ptr->capacity    = buffer_size - sizeof(Arena);
+	arena_ptr->capacity    = buffer_size - sizeof(WpArena);
 	arena_ptr->type        = ARENA_STORAGE_TYPE_BUFFER;
 	arena_ptr->committed   = true;
 
 	return true;
 }
 
-b8 wapp_mem_arena_init_allocated_custom(Arena **arena, u64 base_capacity, MemAllocFlags flags, b8 zero_buffer) {
+b8 wpMemArenaInitAllocatedCustom(WpArena **arena, u64 base_capacity, WpMemAllocFlags flags, b8 zero_buffer) {
 	if (!arena || *arena || base_capacity == 0) {
 		return false;
 	}
 
-	u64 size       = sizeof(Arena) + (base_capacity >= ARENA_MINIMUM_CAPACITY ? base_capacity : ARENA_MINIMUM_CAPACITY);
+	u64 size       = sizeof(WpArena) + (base_capacity >= ARENA_MINIMUM_CAPACITY ? base_capacity : ARENA_MINIMUM_CAPACITY);
 	u64 alloc_size = wpMiscUtilsU64RoundUpPow2(size);
-	u8 *allocated  = (u8 *)wapp_os_mem_alloc(NULL, alloc_size, WAPP_MEM_ACCESS_READ_WRITE, flags,
-	                                         zero_buffer ? WAPP_MEM_INIT_INITIALISED : WAPP_MEM_INIT_UNINITIALISED);
+	u8 *allocated  = (u8 *)wpOsMemAlloc(NULL, alloc_size, WP_MEM_ACCESS_READ_WRITE, flags,
+	                                         zero_buffer ? WP_MEM_INIT_INITIALISED : WP_MEM_INIT_UNINITIALISED);
 	if (!allocated) {
 		return false;
 	}
 
-	b8 committed = (flags & WAPP_MEM_ALLOC_COMMIT) == WAPP_MEM_ALLOC_COMMIT;
+	b8 committed = (flags & WP_MEM_ALLOC_COMMIT) == WP_MEM_ALLOC_COMMIT;
 
 #ifdef WP_PLATFORM_WINDOWS
 	if (!committed) {
-		wapp_os_mem_alloc(allocated, sizeof(Arena), WAPP_MEM_ACCESS_READ_WRITE, WAPP_MEM_ALLOC_COMMIT,
-		                  WAPP_MEM_INIT_INITIALISED);
+		wpOsMemAlloc(allocated, sizeof(WpArena), WP_MEM_ACCESS_READ_WRITE, WP_MEM_ALLOC_COMMIT,
+		                  WP_MEM_INIT_INITIALISED);
 	}
 #endif // ifdef WP_PLATFORM_WINDOWS
 
-	if (!wapp_mem_arena_init_buffer(arena, allocated, alloc_size)) {
-		wapp_mem_arena_destroy(arena);
+	if (!wpMemArenaInitBuffer(arena, allocated, alloc_size)) {
+		wpMemArenaDestroy(arena);
 		return false;
 	}
 
-	Arena *arena_ptr     = *arena;
+	WpArena *arena_ptr     = *arena;
 	arena_ptr->type      = ARENA_STORAGE_TYPE_ALLOCATED;
 	arena_ptr->committed = committed;
 
 	return true;
 }
 
-void *wapp_mem_arena_alloc(Arena *arena, u64 size) {
-	return wapp_mem_arena_alloc_aligned(arena, size, DEFAULT_ALIGNMENT);
+void *wpMemArenaAlloc(WpArena *arena, u64 size) {
+	return wpMemArenaAllocAligned(arena, size, DEFAULT_ALIGNMENT);
 }
 
-void *wapp_mem_arena_alloc_aligned(Arena *arena, u64 size, u64 alignment) {
+void *wpMemArenaAllocAligned(WpArena *arena, u64 size, u64 alignment) {
 	wpDebugAssert(arena != NULL, "`arena` should not be NULL");
 
 	u8 *alloc_start = arena->offset;
@@ -102,9 +102,9 @@ void *wapp_mem_arena_alloc_aligned(Arena *arena, u64 size, u64 alignment) {
 
 #ifdef WP_PLATFORM_WINDOWS
 	if (arena->type == ARENA_STORAGE_TYPE_ALLOCATED && !(arena->committed)) {
-		wapp_os_mem_alloc(alloc_start, (uptr)(arena->offset) - (uptr)(alloc_start),
-		                  WAPP_MEM_ACCESS_READ_WRITE, WAPP_MEM_ALLOC_COMMIT,
-		                  WAPP_MEM_INIT_UNINITIALISED);
+		wpOsMemAlloc(alloc_start, (uptr)(arena->offset) - (uptr)(alloc_start),
+		                  WP_MEM_ACCESS_READ_WRITE, WP_MEM_ALLOC_COMMIT,
+		                  WP_MEM_INIT_UNINITIALISED);
 	}
 #endif // ifdef WP_PLATFORM_WINDOWS
 
@@ -113,7 +113,7 @@ void *wapp_mem_arena_alloc_aligned(Arena *arena, u64 size, u64 alignment) {
 	return (void *)output;
 }
 
-void *wapp_mem_arena_realloc(Arena *arena, void *ptr, u64 old_size, u64 new_size) {
+void *wpMemArenaRealloc(WpArena *arena, void *ptr, u64 old_size, u64 new_size) {
 	wpDebugAssert(arena != NULL, "`arena` should not be NULL");
 
 	if ((u8*)ptr < arena->buf || (u8*)ptr > arena->offset ||
@@ -121,7 +121,7 @@ void *wapp_mem_arena_realloc(Arena *arena, void *ptr, u64 old_size, u64 new_size
 		return NULL;
 	}
 
-	void *new_ptr = wapp_mem_arena_alloc(arena, new_size);
+	void *new_ptr = wpMemArenaAlloc(arena, new_size);
 	if (!new_ptr) {
 		return NULL;
 	}
@@ -132,7 +132,7 @@ void *wapp_mem_arena_realloc(Arena *arena, void *ptr, u64 old_size, u64 new_size
 	return new_ptr;
 }
 
-void *wapp_mem_arena_realloc_aligned(Arena *arena, void *ptr, u64 old_size, u64 new_size, u64 alignment) {
+void *wpMemArenaReallocAligned(WpArena *arena, void *ptr, u64 old_size, u64 new_size, u64 alignment) {
 	wpDebugAssert(arena != NULL, "`arena` should not be NULL");
 
 	if ((u8*)ptr < arena->buf || (u8*)ptr > arena->offset ||
@@ -140,7 +140,7 @@ void *wapp_mem_arena_realloc_aligned(Arena *arena, void *ptr, u64 old_size, u64
 		return NULL;
 	}
 
-	void *new_ptr = wapp_mem_arena_alloc_aligned(arena, new_size, alignment);
+	void *new_ptr = wpMemArenaAllocAligned(arena, new_size, alignment);
 	if (!new_ptr) {
 		return NULL;
 	}
@@ -151,7 +151,7 @@ void *wapp_mem_arena_realloc_aligned(Arena *arena, void *ptr, u64 old_size, u64
 	return new_ptr;
 }
 
-void wapp_mem_arena_temp_begin(Arena *arena) {
+void wpMemArenaTempBegin(WpArena *arena) {
 	wpDebugAssert(arena != NULL, "`arena` should not be NULL");
 
 	if (arena->prev_offset != NULL) {
@@ -161,7 +161,7 @@ void wapp_mem_arena_temp_begin(Arena *arena) {
 	arena->prev_offset = arena->offset;
 }
 
-void wapp_mem_arena_temp_end(Arena *arena) {
+void wpMemArenaTempEnd(WpArena *arena) {
 	wpDebugAssert(arena != NULL, "`arena` should not be NULL");
 
 	if (arena->prev_offset == NULL) {
@@ -172,20 +172,20 @@ void wapp_mem_arena_temp_end(Arena *arena) {
 	arena->prev_offset = NULL;
 }
 
-void wapp_mem_arena_clear(Arena *arena) {
+void wpMemArenaClear(WpArena *arena) {
 	wpDebugAssert(arena != NULL, "`arena` should not be NULL");
 
 	memset(arena->buf, 0, arena->offset - arena->buf);
 	arena->offset = arena->buf;
 }
 
-void wapp_mem_arena_destroy(Arena **arena) {
+void wpMemArenaDestroy(WpArena **arena) {
 	wpDebugAssert(arena != NULL && (*arena) != NULL, "`arena` double pointer is not valid");
 
-	Arena *arena_ptr = *arena;
+	WpArena *arena_ptr = *arena;
 
 	if (arena_ptr->type == ARENA_STORAGE_TYPE_ALLOCATED) {
-		wapp_os_mem_free(*arena, sizeof(Arena) + arena_ptr->capacity);
+		wpOsMemFree(*arena, sizeof(WpArena) + arena_ptr->capacity);
 	}
 
 	*arena = NULL;

src/os/allocators/arena/mem_arena.h

@@ -11,32 +11,32 @@
 BEGIN_C_LINKAGE
 #endif // !WP_PLATFORM_CPP
 
-typedef struct Arena Arena;
+typedef struct WpArena WpArena;
 
-#define wapp_mem_arena_init_allocated(arena_dptr, base_capacity)                                                           \
-	(wapp_mem_arena_init_allocated_custom(arena_dptr, base_capacity, WAPP_MEM_ALLOC_RESERVE, false))
-#define wapp_mem_arena_init_allocated_commit(arena_dptr, base_capacity)                                                    \
-	(wapp_mem_arena_init_allocated_custom(arena_dptr, base_capacity, WAPP_MEM_ALLOC_RESERVE | WAPP_MEM_ALLOC_COMMIT, false))
-#define wapp_mem_arena_init_allocated_zero(arena_dptr, base_capacity)                                                      \
-	(wapp_mem_arena_init_allocated_custom(arena_dptr, base_capacity, WAPP_MEM_ALLOC_RESERVE, true))
-#define wapp_mem_arena_init_allocated_commit_and_zero(arena_dptr, base_capacity)                                           \
-	(wapp_mem_arena_init_allocated_custom(arena_dptr, base_capacity, WAPP_MEM_ALLOC_RESERVE | WAPP_MEM_ALLOC_COMMIT, true))
+#define wpMemArenaInitAllocated(arena_dptr, base_capacity)                                                      \
+	(wpMemArenaInitAllocatedCustom(arena_dptr, base_capacity, WP_MEM_ALLOC_RESERVE, false))
+#define wpMemArenaInitAllocatedCommit(arena_dptr, base_capacity)                                                \
+	(wpMemArenaInitAllocatedCustom(arena_dptr, base_capacity, WP_MEM_ALLOC_RESERVE | WP_MEM_ALLOC_COMMIT, false))
+#define wpMemArenaInitAllocatedZero(arena_dptr, base_capacity)                                                  \
+	(wpMemArenaInitAllocatedCustom(arena_dptr, base_capacity, WP_MEM_ALLOC_RESERVE, true))
+#define wpMemArenaInitAllocatedCommitAndZero(arena_dptr, base_capacity)                                         \
+	(wpMemArenaInitAllocatedCustom(arena_dptr, base_capacity, WP_MEM_ALLOC_RESERVE | WP_MEM_ALLOC_COMMIT, true))
 
 /**
- * Arena initialisation function. `wapp_mem_arena_init_allocated_custom` provides the most
- * control over how the Arena is initialised. Wrapper macros are provided for
+ * WpArena initialisation function. `wpMemArenaInitAllocatedCustom` provides the most
+ * control over how the WpArena is initialised. Wrapper macros are provided for
  * easier use.
  */
-b8    wapp_mem_arena_init_allocated_custom(Arena **arena, u64 base_capacity, MemAllocFlags flags, b8 zero_buffer);
-b8    wapp_mem_arena_init_buffer(Arena **arena, u8 *buffer, u64 buffer_size);
-void *wapp_mem_arena_alloc(Arena *arena, u64 size);
-void *wapp_mem_arena_alloc_aligned(Arena *arena, u64 size, u64 alignment);
-void *wapp_mem_arena_realloc(Arena *arena, void *ptr, u64 old_size, u64 new_size);
-void *wapp_mem_arena_realloc_aligned(Arena *arena, void *ptr, u64 old_size, u64 new_size, u64 alignment);
-void  wapp_mem_arena_temp_begin(Arena *arena);
-void  wapp_mem_arena_temp_end(Arena *arena);
-void  wapp_mem_arena_clear(Arena *arena);
-void  wapp_mem_arena_destroy(Arena **arena);
+b8    wpMemArenaInitAllocatedCustom(WpArena **arena, u64 base_capacity, WpMemAllocFlags flags, b8 zero_buffer);
+b8    wpMemArenaInitBuffer(WpArena **arena, u8 *buffer, u64 buffer_size);
+void *wpMemArenaAlloc(WpArena *arena, u64 size);
+void *wpMemArenaAllocAligned(WpArena *arena, u64 size, u64 alignment);
+void *wpMemArenaRealloc(WpArena *arena, void *ptr, u64 old_size, u64 new_size);
+void *wpMemArenaReallocAligned(WpArena *arena, void *ptr, u64 old_size, u64 new_size, u64 alignment);
+void  wpMemArenaTempBegin(WpArena *arena);
+void  wpMemArenaTempEnd(WpArena *arena);
+void  wpMemArenaClear(WpArena *arena);
+void  wpMemArenaDestroy(WpArena **arena);
 
 #ifdef WP_PLATFORM_CPP
 END_C_LINKAGE

src/os/allocators/arena/mem_arena_allocator.c

@@ -13,9 +13,9 @@ wp_intern void *mem_arena_realloc(void *ptr, u64 old_size, u64 new_size, void *a
 wp_intern void *mem_arena_realloc_aligned(void *ptr, u64 old_size, u64 new_size, u64 alignment,
                                             void *alloc_obj);
 
-WpAllocator wapp_mem_arena_allocator_init_with_buffer(u8 *buffer, u64 buffer_size) {
+WpAllocator wpMemArenaAllocatorInitWithBuffer(u8 *buffer, u64 buffer_size) {
 	WpAllocator allocator = {0};
-	b8 initialised = wapp_mem_arena_init_buffer((Arena **)(&allocator.obj), buffer, buffer_size);
+	b8 initialised = wpMemArenaInitBuffer((WpArena **)(&allocator.obj), buffer, buffer_size);
 	if (!initialised) {
 		return allocator;
 	}
@@ -25,9 +25,9 @@ WpAllocator wapp_mem_arena_allocator_init_with_buffer(u8 *buffer, u64 buffer_siz
 	return allocator;
 }
 
-WpAllocator wapp_mem_arena_allocator_init_custom(u64 base_capacity, MemAllocFlags flags, b8 zero_buffer) {
+WpAllocator wpMemArenaAllocatorInitCustom(u64 base_capacity, WpMemAllocFlags flags, b8 zero_buffer) {
 	WpAllocator allocator = {0};
-	b8 initialised = wapp_mem_arena_init_allocated_custom((Arena **)(&allocator.obj), base_capacity, flags, zero_buffer);
+	b8 initialised = wpMemArenaInitAllocatedCustom((WpArena **)(&allocator.obj), base_capacity, flags, zero_buffer);
 	if (!initialised) {
 		return allocator;
 	}
@@ -37,24 +37,24 @@ WpAllocator wapp_mem_arena_allocator_init_custom(u64 base_capacity, MemAllocFlag
 	return allocator;
 }
 
-void wapp_mem_arena_allocator_temp_begin(const WpAllocator *allocator) {
+void wpMemArenaAllocatorTempBegin(const WpAllocator *allocator) {
 	wpDebugAssert(allocator != NULL, "`allocator` should not be NULL");
-	wapp_mem_arena_temp_begin((Arena *)(allocator->obj));
+	wpMemArenaTempBegin((WpArena *)(allocator->obj));
 }
 
-void wapp_mem_arena_allocator_temp_end(const WpAllocator *allocator) {
+void wpMemArenaAllocatorTempEnd(const WpAllocator *allocator) {
 	wpDebugAssert(allocator != NULL, "`allocator` should not be NULL");
-	wapp_mem_arena_temp_end((Arena *)(allocator->obj));
+	wpMemArenaTempEnd((WpArena *)(allocator->obj));
 }
 
-void wapp_mem_arena_allocator_clear(WpAllocator *allocator) {
+void wpMemArenaAllocatorClear(WpAllocator *allocator) {
 	wpDebugAssert(allocator != NULL, "`allocator` should not be NULL");
-	wapp_mem_arena_clear((Arena *)(allocator->obj));
+	wpMemArenaClear((WpArena *)(allocator->obj));
 }
 
-void wapp_mem_arena_allocator_destroy(WpAllocator *allocator) {
+void wpMemArenaAllocatorDestroy(WpAllocator *allocator) {
 	wpDebugAssert(allocator != NULL, "`allocator` should not be NULL");
-	wapp_mem_arena_destroy((Arena **)(&(allocator->obj)));
+	wpMemArenaDestroy((WpArena **)(&(allocator->obj)));
 	*allocator = (WpAllocator){0};
 }
 
@@ -66,22 +66,22 @@ wp_intern void initialise_arena_allocator(WpAllocator *allocator) {
 }
 
 wp_intern void *mem_arena_alloc(u64 size, void *alloc_obj) {
-	Arena *arena = (Arena *)alloc_obj;
-	return wapp_mem_arena_alloc(arena, size);
+	WpArena *arena = (WpArena *)alloc_obj;
+	return wpMemArenaAlloc(arena, size);
 }
 
 wp_intern void *mem_arena_alloc_aligned(u64 size, u64 alignment, void *alloc_obj) {
-	Arena *arena = (Arena *)alloc_obj;
-	return wapp_mem_arena_alloc_aligned(arena, size, alignment);
+	WpArena *arena = (WpArena *)alloc_obj;
+	return wpMemArenaAllocAligned(arena, size, alignment);
 }
 
 wp_intern void *mem_arena_realloc(void *ptr, u64 old_size, u64 new_size, void *alloc_obj) {
-	Arena *arena = (Arena *)alloc_obj;
-	return wapp_mem_arena_realloc(arena, ptr, old_size, new_size);
+	WpArena *arena = (WpArena *)alloc_obj;
+	return wpMemArenaRealloc(arena, ptr, old_size, new_size);
 }
 
 wp_intern void *mem_arena_realloc_aligned(void *ptr, u64 old_size, u64 new_size, u64 alignment,
                                             void *alloc_obj) {
-	Arena *arena = (Arena *)alloc_obj;
-	return wapp_mem_arena_realloc_aligned(arena, ptr, old_size, new_size, alignment);
+	WpArena *arena = (WpArena *)alloc_obj;
+	return wpMemArenaReallocAligned(arena, ptr, old_size, new_size, alignment);
 }

src/os/allocators/arena/mem_arena_allocator.h

@@ -12,32 +12,32 @@
 BEGIN_C_LINKAGE
 #endif // !WP_PLATFORM_CPP
 
-#define wapp_mem_arena_allocator_init(base_capacity)                                                           \
-	(wapp_mem_arena_allocator_init_custom(base_capacity, WAPP_MEM_ALLOC_RESERVE, false))
-#define wapp_mem_arena_allocator_init_commit(base_capacity)                                                    \
-	(wapp_mem_arena_allocator_init_custom(base_capacity, WAPP_MEM_ALLOC_RESERVE | WAPP_MEM_ALLOC_COMMIT, false))
-#define wapp_mem_arena_allocator_init_zero(base_capacity)                                                      \
-	(wapp_mem_arena_allocator_init_custom(base_capacity, WAPP_MEM_ALLOC_RESERVE, true))
-#define wapp_mem_arena_allocator_init_commit_and_zero(base_capacity)                                           \
-	(wapp_mem_arena_allocator_init_custom(base_capacity, WAPP_MEM_ALLOC_RESERVE | WAPP_MEM_ALLOC_COMMIT, true))
+#define wpMemArenaAllocatorInit(base_capacity)                                                     \
+	(wpMemArenaAllocatorInitCustom(base_capacity, WP_MEM_ALLOC_RESERVE, false))
+#define wpMemArenaAllocatorInitCommit(base_capacity)                                               \
+	(wpMemArenaAllocatorInitCustom(base_capacity, WP_MEM_ALLOC_RESERVE | WP_MEM_ALLOC_COMMIT, false))
+#define wpMemArenaAllocatorInitZero(base_capacity)                                                 \
+	(wpMemArenaAllocatorInitCustom(base_capacity, WP_MEM_ALLOC_RESERVE, true))
+#define wpMemArenaAllocatorInitCommitAndZero(base_capacity)                                        \
+	(wpMemArenaAllocatorInitCustom(base_capacity, WP_MEM_ALLOC_RESERVE | WP_MEM_ALLOC_COMMIT, true))
 
 /**
- * Wraps an Arena in an WpAllocator object. It attempts to initialise the Arena
+ * Wraps a WpArena in a WpAllocator object. It attempts to initialise the WpArena
  * and, if successful, defines the operations supported by it to be used by the
  * WpAllocator.
  *
- * An Arena allocator only supports normal allocation and aligned allocation.
+ * An WpArena allocator only supports normal allocation and aligned allocation.
  * Reallocation, aligned reallocation and freeing aren't implemented.
  *
- * The `wapp_mem_arena_allocator_init_custom` provides the most control over how
- * the Arena is initialised. Wrapper macros are provided for easier use.
+ * The `wpMemArenaAllocatorInitCustom` provides the most control over how
+ * the WpArena is initialised. Wrapper macros are provided for easier use.
  */
-WpAllocator wapp_mem_arena_allocator_init_custom(u64 base_capacity, MemAllocFlags flags, b8 zero_buffer);
-WpAllocator wapp_mem_arena_allocator_init_with_buffer(u8 *buffer, u64 buffer_size);
-void      wapp_mem_arena_allocator_temp_begin(const WpAllocator *allocator);
-void      wapp_mem_arena_allocator_temp_end(const WpAllocator *allocator);
-void      wapp_mem_arena_allocator_clear(WpAllocator *allocator);
-void      wapp_mem_arena_allocator_destroy(WpAllocator *allocator);
+WpAllocator wpMemArenaAllocatorInitCustom(u64 base_capacity, WpMemAllocFlags flags, b8 zero_buffer);
+WpAllocator wpMemArenaAllocatorInitWithBuffer(u8 *buffer, u64 buffer_size);
+void        wpMemArenaAllocatorTempBegin(const WpAllocator *allocator);
+void        wpMemArenaAllocatorTempEnd(const WpAllocator *allocator);
+void        wpMemArenaAllocatorClear(WpAllocator *allocator);
+void        wpMemArenaAllocatorDestroy(WpAllocator *allocator);
 
 #ifdef WP_PLATFORM_CPP
 END_C_LINKAGE

src/os/cpath/cpath.c

@@ -8,28 +8,26 @@
 #include "../../base/mem/allocator/mem_allocator.h"
 #include "../../base/strings/str8/str8.h"
 #include <stdarg.h>
-#include <stdio.h>
-#include <string.h>
 
-u32 wapp_cpath_join_path(WpStr8 *dst, const WpStr8List *parts) {
+u32 wpCpathJoinPath(WpStr8 *dst, const WpStr8List *parts) {
 	if (!dst || !parts) {
-		return CPATH_JOIN_INVALID_ARGS;
+		return WP_CPATH_JOIN_RESULT_INVALID_ARGS;
 	}
 
 	if (parts->node_count == 0) {
-		return CPATH_JOIN_EMPTY_PARTS;
+		return WP_CPATH_JOIN_RESULT_EMPTY_PARTS;
 	}
 
 	WpStr8 separator = wpStr8Buf(4);
-	wpStr8PushBack(&separator, WAPP_PATH_SEP);
+	wpStr8PushBack(&separator, WP_PATH_SEP);
 
 	u64 required_capacity = parts->node_count * separator.size + wpStr8ListTotalSize(parts);
 	if (dst->capacity < required_capacity) {
-		return CPATH_JOIN_INSUFFICIENT_DST_CAPACITY;
+		return WP_CPATH_JOIN_RESULT_INSUFFICIENT_DST_CAPACITY;
 	}
 
 	// Handle first node
-	WpStr8 *first_node = wapp_dbl_list_get(WpStr8, parts, 0);
+	WpStr8 *first_node = wpDblListGet(WpStr8, parts, 0);
 	wpStr8CopyStr8Capped(dst, first_node);
 
 	// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
@@ -38,7 +36,7 @@ u32 wapp_cpath_join_path(WpStr8 *dst, const WpStr8List *parts) {
 	u64 node_index   = 1;
 	b8 running       = node_index < parts->node_count;
 	while (running) {
-		node = wapp_dbl_list_get(WpStr8, parts, node_index);
+		node = wpDblListGet(WpStr8, parts, node_index);
 		if (node->size == 0) {
 			goto CPATH_JOIN_LOOP_END;
 		}
@@ -46,7 +44,7 @@ u32 wapp_cpath_join_path(WpStr8 *dst, const WpStr8List *parts) {
 		if (dst->size > 0) {
 			char dst_last   = wpStr8Get(dst, dst->size - 1);
 			char node_start = wpStr8Get(node, 0);
-			b8 add_path_sep = dst_last != WAPP_PATH_SEP && node_start != WAPP_PATH_SEP;
+			b8 add_path_sep = dst_last != WP_PATH_SEP && node_start != WP_PATH_SEP;
 
 			if (add_path_sep) {
 				wpStr8ConcatCapped(dst, &separator);
@@ -60,18 +58,18 @@ CPATH_JOIN_LOOP_END:
 		running = node_index < parts->node_count;
 	}
 
-	return CPATH_JOIN_SUCCESS;
+	return WP_CPATH_JOIN_RESULT_SUCCESS;
 }
 
-WpStr8 *dirup(const WpAllocator *allocator, WpStr8RO *path, u64 levels) {
+WpStr8 *_dirup(const WpAllocator *allocator, WpStr8RO *path, u64 levels) {
 	WpStr8 *output = NULL;
 	if (!allocator || !path) {
 		goto RETURN_DIRUP;
 	}
 
-	b8 absolute    = wpStr8Get(path, 0) == WAPP_PATH_SEP;
+	b8 absolute    = wpStr8Get(path, 0) == WP_PATH_SEP;
 	WpStr8 separator = wpStr8Buf(4);
-	wpStr8PushBack(&separator, WAPP_PATH_SEP);
+	wpStr8PushBack(&separator, WP_PATH_SEP);
 
 	if (path->size == 0) {
 		output = wpStr8AllocBuf(allocator, 16);
@@ -79,7 +77,7 @@ WpStr8 *dirup(const WpAllocator *allocator, WpStr8RO *path, u64 levels) {
 			goto RETURN_DIRUP;
 		}
 
-		wpStr8PushBack(output, absolute ? WAPP_PATH_SEP : '.');
+		wpStr8PushBack(output, absolute ? WP_PATH_SEP : '.');
 		goto RETURN_DIRUP;
 	}
 
@@ -88,7 +86,7 @@ WpStr8 *dirup(const WpAllocator *allocator, WpStr8RO *path, u64 levels) {
 		goto RETURN_DIRUP;
 	}
 
-	WpAllocator tmp_arena = wapp_mem_arena_allocator_init(MiB(8));
+	WpAllocator tmp_arena = wpMemArenaAllocatorInit(MiB(8));
 	if (wpMemAllocatorInvalid(&tmp_arena)) {
 		goto RETURN_DIRUP;
 	}
@@ -104,10 +102,10 @@ WpStr8 *dirup(const WpAllocator *allocator, WpStr8RO *path, u64 levels) {
 			goto LIST_CLEANUP_DIRUP;
 		}
 
-		wpStr8PushBack(output, absolute ? WAPP_PATH_SEP : '.');
+		wpStr8PushBack(output, absolute ? WP_PATH_SEP : '.');
 	} else {
 		for (u64 i = 0; i < levels; ++i) {
-			wapp_dbl_list_pop_back(WpStr8, parts);
+			wpDblListPopBack(WpStr8, parts);
 		}
 		
 		u64 alignment  = sizeof(void *) * 2;
@@ -118,7 +116,7 @@ WpStr8 *dirup(const WpAllocator *allocator, WpStr8RO *path, u64 levels) {
 		output = wpStr8AllocBuf(allocator, alloc_size);
 		if (output) {
 			if (absolute) {
-				wpStr8PushBack(output, WAPP_PATH_SEP);
+				wpStr8PushBack(output, WP_PATH_SEP);
 			}
 
 			WpStr8 *joined = wpStr8Join(&tmp_arena, parts, &separator);
@@ -129,7 +127,7 @@ WpStr8 *dirup(const WpAllocator *allocator, WpStr8RO *path, u64 levels) {
 	}
 
 LIST_CLEANUP_DIRUP:
-	wapp_mem_arena_allocator_destroy(&tmp_arena);
+	wpMemArenaAllocatorDestroy(&tmp_arena);
 
 RETURN_DIRUP:
 	return output;

src/os/cpath/cpath.h

@@ -14,29 +14,29 @@ BEGIN_C_LINKAGE
 
 #ifdef WP_PLATFORM_POSIX
 #include <limits.h>
-#define WAPP_PATH_SEP '/'
-#define WAPP_PATH_MAX PATH_MAX
+#define WP_PATH_SEP '/'
+#define WP_PATH_MAX PATH_MAX
 #elif defined(WP_PLATFORM_WINDOWS)
 #define WIN32_LEAN_AND_MEAN
 #include <Windows.h>
-#define WAPP_PATH_SEP '\\'
-#define WAPP_PATH_MAX MAX_PATH
+#define WP_PATH_SEP '\\'
+#define WP_PATH_MAX MAX_PATH
 #else
 #error "Unrecognised platform"
 #endif
 
-#define wapp_cpath_dirname(ALLOCATOR, PATH) dirup(ALLOCATOR, PATH, 1)
-#define wapp_cpath_dirup(ALLOCATOR, PATH, COUNT) dirup(ALLOCATOR, PATH, COUNT)
+#define wpCpathDirname(ALLOCATOR, PATH) _dirup(ALLOCATOR, PATH, 1)
+#define wpCpathDirup(ALLOCATOR, PATH, COUNT) _dirup(ALLOCATOR, PATH, COUNT)
 
-enum {
-	CPATH_JOIN_SUCCESS = 0,
-	CPATH_JOIN_INVALID_ARGS,
-	CPATH_JOIN_EMPTY_PARTS,
-	CPATH_JOIN_INSUFFICIENT_DST_CAPACITY,
-};
+typedef enum {
+	WP_CPATH_JOIN_RESULT_SUCCESS = 0,
+	WP_CPATH_JOIN_RESULT_INVALID_ARGS,
+	WP_CPATH_JOIN_RESULT_EMPTY_PARTS,
+	WP_CPATH_JOIN_RESULT_INSUFFICIENT_DST_CAPACITY,
+} WpCpathJoinResult;
 
-u32   wapp_cpath_join_path(WpStr8 *dst, const WpStr8List *parts);
-WpStr8 *dirup(const WpAllocator *allocator, WpStr8RO *path, u64 levels);
+WpCpathJoinResult wpCpathJoinPath(WpStr8 *dst, const WpStr8List *parts);
+WpStr8           *_dirup(const WpAllocator *allocator, WpStr8RO *path, u64 levels);
 
 #ifdef WP_PLATFORM_CPP
 END_C_LINKAGE

src/os/file/file.c

@@ -7,77 +7,77 @@
 #include "../../base/array/array.h"
 #include "../../base/strings/str8/str8.h"
 
-WFile *wapp_file_open(const WpAllocator *allocator, WpStr8RO *filepath, FileAccessMode mode) {
+WpFile *wpFileOpen(const WpAllocator *allocator, WpStr8RO *filepath, WpFileAccessMode mode) {
 	wpDebugAssert(allocator != NULL && filepath != NULL, "`allocator` and `filepath` should not be NULL");
-	wpDebugAssert(filepath->size < WAPP_PATH_MAX, "`filepath` exceeds max path limit.");
-	return _file_open(allocator, filepath, mode);
+	wpDebugAssert(filepath->size < WP_PATH_MAX, "`filepath` exceeds max path limit.");
+	return _fileOpen(allocator, filepath, mode);
 }
 
-i64 wapp_file_get_current_position(WFile *file) {
+i64 wpFileGetCurrentPosition(WpFile *file) {
 	wpDebugAssert(file != NULL, "`file` should not be NULL.");
-	return _file_seek(file, 0, WAPP_SEEK_CURRENT);
+	return _fileSeek(file, 0, WP_SEEK_CURRENT);
 }
 
-i64 wapp_file_seek(WFile *file, i64 offset, FileSeekOrigin origin) {
+i64 wpFileSeek(WpFile *file, i64 offset, WpFileSeekOrigin origin) {
 	wpDebugAssert(file != NULL, "`file` should not be NULL.");
-	return _file_seek(file, offset, origin);
+	return _fileSeek(file, offset, origin);
 }
 
-i64 wapp_file_get_length(WFile *file) {
+i64 wpFileGetLength(WpFile *file) {
 	wpDebugAssert(file != NULL, "`file` should not be NULL.");
 
-	i64 current = wapp_file_get_current_position(file);
+	i64 current = wpFileGetCurrentPosition(file);
 
-	_file_seek(file, 0, WAPP_SEEK_END);
+	_fileSeek(file, 0, WP_SEEK_END);
 
-	i64 output = wapp_file_get_current_position(file);
+	i64 output = wpFileGetCurrentPosition(file);
 
 	// Restore position
-	_file_seek(file, current, WAPP_SEEK_START);
+	_fileSeek(file, current, WP_SEEK_START);
 
 	return output;
 }
 
-u64 wapp_file_read(void *dst_buf, WFile *file, u64 byte_count) {
+u64 wpFileRead(void *dst_buf, WpFile *file, u64 byte_count) {
 	wpDebugAssert(dst_buf != NULL && file != NULL,
 	                  "`dst_buf` and `file` should not be NULL.");
 
-	i64 file_length = wapp_file_get_length(file);
+	i64 file_length = wpFileGetLength(file);
 	if (file_length < 0) {
 		return 0;
 	}
 
-	return _file_read(dst_buf, byte_count, file, file_length);
+	return _fileRead(dst_buf, byte_count, file, file_length);
 }
 
-i64 wapp_file_write(const void *src_buf, WFile *file, u64 byte_count) {
+i64 wpFileWrite(const void *src_buf, WpFile *file, u64 byte_count) {
 	wpDebugAssert(src_buf != NULL && file != NULL,
 	                  "`src_buf` and `file` should not be NULL.");
-	return _file_write(src_buf, file, byte_count);
+	return _fileWrite(src_buf, file, byte_count);
 }
 
-u64 wapp_file_read_str8(WpStr8 *str, WFile *file) {
+u64 wpFileReadStr8(WpStr8 *str, WpFile *file) {
 	wpDebugAssert(str != NULL, "`str` should not be NULL.");
-	return wapp_file_read((void *)(str->buf), file, str->size);
+	return wpFileRead((void *)(str->buf), file, str->size);
 }
 
-i64 wapp_file_write_str8(WpStr8RO *str, WFile *file) {
+i64 wpFileWriteStr8(WpStr8RO *str, WpFile *file) {
 	wpDebugAssert(str != NULL, "`str` should not be NULL.");
-	return wapp_file_write((void *)(str->buf), file, str->size);
+	return wpFileWrite((void *)(str->buf), file, str->size);
 }
 
-u64 wapp_file_read_array(GenericArray dst_buf, WFile *file, u64 item_count) {
+u64 wpFileReadArray(WpArray dst_buf, WpFile *file, u64 item_count) {
 	wpDebugAssert(dst_buf != NULL && file != NULL,
 	                  "`dst_buf` and `file` should not be NULL.");
 
-	i64 _file_length = wapp_file_get_length(file);
+	i64 _file_length = wpFileGetLength(file);
 	if (_file_length < 0) {
 		return 0;
 	}
 
 	u64 file_length       = (u64)_file_length;
-	u64 item_size         = wapp_array_item_size(dst_buf);
-	u64 dst_byte_capacity = wapp_array_capacity(dst_buf) * item_size;
+	u64 item_size         = wpArrayItemSize(dst_buf);
+	u64 dst_byte_capacity = wpArrayCapacity(dst_buf) * item_size;
 	u64 req_byte_count    = item_count * item_size;
 	u64 copy_byte_count   = 0;
 
@@ -87,26 +87,26 @@ u64 wapp_file_read_array(GenericArray dst_buf, WFile *file, u64 item_count) {
 		copy_byte_count = file_length <= dst_byte_capacity ? file_length : dst_byte_capacity;
 	}
 
-	u64 byte_count = _file_read(dst_buf, copy_byte_count, file, file_length);
+	u64 byte_count = _fileRead(dst_buf, copy_byte_count, file, file_length);
 	if (byte_count == 0) {
 		return 0;
 	}
 
-	wapp_array_set_count(dst_buf, byte_count / item_size);
+	wpArraySetCount(dst_buf, byte_count / item_size);
 
-	return wapp_array_count(dst_buf);
+	return wpArrayCount(dst_buf);
 }
 
-i64 wapp_file_write_array(const GenericArray src_buf, WFile *file, u64 item_count) {
+i64 wpFileWriteArray(const WpArray src_buf, WpFile *file, u64 item_count) {
 	wpDebugAssert(src_buf != NULL && file != NULL,
 	                  "`src_buf` and `file` should not be NULL.");
 
-	u64 item_size      = wapp_array_item_size(src_buf);
-	u64 src_byte_count = wapp_array_count(src_buf) * item_size;
+	u64 item_size      = wpArrayItemSize(src_buf);
+	u64 src_byte_count = wpArrayCount(src_buf) * item_size;
 	u64 req_byte_count = item_count * item_size;
 	u64 to_copy        = req_byte_count <= src_byte_count ? req_byte_count : src_byte_count;
 
-	i64 bytes_written = _file_write(src_buf, file, to_copy);
+	i64 bytes_written = _fileWrite(src_buf, file, to_copy);
 	if (bytes_written < 0) {
 		return 0;
 	}
@@ -114,26 +114,26 @@ i64 wapp_file_write_array(const GenericArray src_buf, WFile *file, u64 item_coun
 	return (u64)bytes_written / item_size;
 }
 
-i32 wapp_file_flush(WFile *file) {
+i32 wpFileFlush(WpFile *file) {
 	wpDebugAssert(file != NULL, "`file` should not be NULL.");
-	return _file_flush(file);
+	return _fileFlush(file);
 }
 
-i32 wapp_file_close(WFile *file) {
+i32 wpFileClose(WpFile *file) {
 	wpDebugAssert(file != NULL, "`file` should not be NULL.");
-	return _file_close(file);
+	return _fileClose(file);
 }
 
-i32 wapp_file_rename(WpStr8RO *old_filepath, WpStr8RO *new_filepath) {
+i32 wpFileRename(WpStr8RO *old_filepath, WpStr8RO *new_filepath) {
 	wpDebugAssert(old_filepath != NULL && new_filepath != NULL,
 	                  "`old_filepath` and `new_filepath` should not be NULL");
-	wpDebugAssert(old_filepath->size < WAPP_PATH_MAX, "`old_filepath` exceeds max path limit.");
-	wpDebugAssert(new_filepath->size < WAPP_PATH_MAX, "`new_filepath` exceeds max path limit.");
-	return _file_rename(old_filepath, new_filepath);
+	wpDebugAssert(old_filepath->size < WP_PATH_MAX, "`old_filepath` exceeds max path limit.");
+	wpDebugAssert(new_filepath->size < WP_PATH_MAX, "`new_filepath` exceeds max path limit.");
+	return _fileRename(old_filepath, new_filepath);
 }
 
-i32 wapp_file_remove(WpStr8RO *filepath) {
+i32 wpFileRemove(WpStr8RO *filepath) {
 	wpDebugAssert(filepath != NULL, "`filepath` should not be NULL");
-	wpDebugAssert(filepath->size < WAPP_PATH_MAX, "`filepath` exceeds max path limit.");
-	return _file_remove(filepath);
+	wpDebugAssert(filepath->size < WP_PATH_MAX, "`filepath` exceeds max path limit.");
+	return _fileRemove(filepath);
 }

src/os/file/file.h

@@ -11,64 +11,64 @@
 BEGIN_C_LINKAGE
 #endif // !WP_PLATFORM_CPP
 
-typedef struct WFile WFile;
+typedef struct WpFile WpFile;
 
 typedef enum {
-	WAPP_ACCESS_READ,                       // Equivalent to r
-	WAPP_ACCESS_WRITE,                      // Equivalent to w
-	WAPP_ACCESS_APPEND,                     // Equivalent to a
-	WAPP_ACCESS_READ_EX,                    // Equivalent to r+
-	WAPP_ACCESS_WRITE_EX,                   // Equivalent to w+
-	WAPP_ACCESS_APPEND_EX,                  // Equivalent to a+
-	WAPP_ACCESS_WRITE_FAIL_ON_EXIST,        // Equivalent to wx
-	WAPP_ACCESS_WRITE_FAIL_ON_EXIST_EX,     // Equivalent to wx+
+	WP_ACCESS_READ,                       // Equivalent to r
+	WP_ACCESS_WRITE,                      // Equivalent to w
+	WP_ACCESS_APPEND,                     // Equivalent to a
+	WP_ACCESS_READ_EX,                    // Equivalent to r+
+	WP_ACCESS_WRITE_EX,                   // Equivalent to w+
+	WP_ACCESS_APPEND_EX,                  // Equivalent to a+
+	WP_ACCESS_WRITE_FAIL_ON_EXIST,        // Equivalent to wx
+	WP_ACCESS_WRITE_FAIL_ON_EXIST_EX,     // Equivalent to wx+
 
-	FILE_ACCESS_MODE_COUNT,
-} FileAccessMode;
+	COUNT_FILE_ACCESS_MODE,
+} WpFileAccessMode;
 
 typedef enum {
-	WAPP_SEEK_START,
-	WAPP_SEEK_CURRENT,
-	WAPP_SEEK_END,
+	WP_SEEK_START,
+	WP_SEEK_CURRENT,
+	WP_SEEK_END,
 
-	FILE_SEEK_ORIGIN_COUNT,
-} FileSeekOrigin;
+	COUNT_FILE_SEEK_ORIGIN,
+} WpFileSeekOrigin;
 
 // Return value should not be cached as it's not guaranteed to remain the same. Always call
-// wapp_file_stdin to get the standard input stream
-wp_extern WFile *wapp_file_stdin(void);
+// wpFileStdin to get the standard input stream
+wp_extern WpFile *wpFileStdin(void);
 
 // Return value should not be cached as it's not guaranteed to remain the same. Always call
-// wapp_file_stdout to get the standard output stream
-wp_extern WFile *wapp_file_stdout(void);
+// wpFileStdout to get the standard output stream
+wp_extern WpFile *wpFileStdout(void);
 
 // Return value should not be cached as it's not guaranteed to remain the same. Always call
-// wapp_file_stderr to get the standard error stream
-wp_extern WFile *wapp_file_stderr(void);
+// wpFileStderr to get the standard error stream
+wp_extern WpFile *wpFileStderr(void);
 
-WFile *wapp_file_open(const WpAllocator *allocator, WpStr8RO *filepath, FileAccessMode mode);
-i64    wapp_file_get_current_position(WFile *file);
-i64    wapp_file_seek(WFile *file, i64 offset, FileSeekOrigin origin);
-i64    wapp_file_get_length(WFile *file);
-u64    wapp_file_read(void *dst_buf, WFile *file, u64 byte_count);
-i64    wapp_file_write(const void *src_buf, WFile *file, u64 byte_count);
-u64    wapp_file_read_str8(WpStr8 *str, WFile *file);
-i64    wapp_file_write_str8(WpStr8RO *str, WFile *file);
-u64    wapp_file_read_array(GenericArray dst_buf, WFile *file, u64 item_count);
-i64    wapp_file_write_array(const GenericArray src_buf, WFile *file, u64 item_count);
-i32    wapp_file_flush(WFile *file);
-i32    wapp_file_close(WFile *file);
-i32    wapp_file_rename(WpStr8RO *old_filepath, WpStr8RO *new_filepath);
-i32    wapp_file_remove(WpStr8RO *filepath);
+WpFile *wpFileOpen(const WpAllocator *allocator, WpStr8RO *filepath, WpFileAccessMode mode);
+i64     wpFileGetCurrentPosition(WpFile *file);
+i64     wpFileSeek(WpFile *file, i64 offset, WpFileSeekOrigin origin);
+i64     wpFileGetLength(WpFile *file);
+u64     wpFileRead(void *dst_buf, WpFile *file, u64 byte_count);
+i64     wpFileWrite(const void *src_buf, WpFile *file, u64 byte_count);
+u64     wpFileReadStr8(WpStr8 *str, WpFile *file);
+i64     wpFileWriteStr8(WpStr8RO *str, WpFile *file);
+u64     wpFileReadArray(WpArray dst_buf, WpFile *file, u64 item_count);
+i64     wpFileWriteArray(const WpArray src_buf, WpFile *file, u64 item_count);
+i32     wpFileFlush(WpFile *file);
+i32     wpFileClose(WpFile *file);
+i32     wpFileRename(WpStr8RO *old_filepath, WpStr8RO *new_filepath);
+i32     wpFileRemove(WpStr8RO *filepath);
 
-wp_extern WFile *_file_open(const WpAllocator *allocator, WpStr8RO *filepath, FileAccessMode mode);
-wp_extern i64    _file_seek(WFile *file, i64 offset, FileSeekOrigin origin);
-wp_extern u64    _file_read(void *dst_buf, u64 byte_count, WFile *file, u64 file_length);
-wp_extern i64    _file_write(const void *src_buf, WFile *file, u64 byte_count);
-wp_extern i32    _file_flush(WFile *file);
-wp_extern i32    _file_close(WFile *file);
-wp_extern i32    _file_rename(WpStr8RO *old_filepath, WpStr8RO *new_filepath);
-wp_extern i32    _file_remove(WpStr8RO *filepath);
+wp_extern WpFile *_fileOpen(const WpAllocator *allocator, WpStr8RO *filepath, WpFileAccessMode mode);
+wp_extern i64     _fileSeek(WpFile *file, i64 offset, WpFileSeekOrigin origin);
+wp_extern u64     _fileRead(void *dst_buf, u64 byte_count, WpFile *file, u64 file_length);
+wp_extern i64     _fileWrite(const void *src_buf, WpFile *file, u64 byte_count);
+wp_extern i32     _fileFlush(WpFile *file);
+wp_extern i32     _fileClose(WpFile *file);
+wp_extern i32     _fileRename(WpStr8RO *old_filepath, WpStr8RO *new_filepath);
+wp_extern i32     _fileRemove(WpStr8RO *filepath);
 
 #ifdef WP_PLATFORM_CPP
 END_C_LINKAGE

src/os/file/posix/file_posix.c

@@ -21,52 +21,52 @@
 #include <unistd.h>
 #include <sys/types.h>
 
-wp_intern i32 file_flags[FILE_ACCESS_MODE_COUNT] = {
-	[WAPP_ACCESS_READ]                       = O_RDONLY,
-	[WAPP_ACCESS_WRITE]                      = O_WRONLY | O_CREAT,
-	[WAPP_ACCESS_APPEND]                     = O_WRONLY | O_APPEND | O_CREAT,
-	[WAPP_ACCESS_READ_EX]                    = O_RDWR,
-	[WAPP_ACCESS_WRITE_EX]                   = O_RDWR | O_CREAT,
-	[WAPP_ACCESS_APPEND_EX]                  = O_RDWR | O_APPEND | O_CREAT,
-	[WAPP_ACCESS_WRITE_FAIL_ON_EXIST]        = O_WRONLY | O_CREAT | O_EXCL,
-	[WAPP_ACCESS_WRITE_FAIL_ON_EXIST_EX]     = O_RDWR | O_CREAT | O_EXCL,
+wp_intern i32 file_flags[COUNT_FILE_ACCESS_MODE] = {
+	[WP_ACCESS_READ]                       = O_RDONLY,
+	[WP_ACCESS_WRITE]                      = O_WRONLY | O_CREAT,
+	[WP_ACCESS_APPEND]                     = O_WRONLY | O_APPEND | O_CREAT,
+	[WP_ACCESS_READ_EX]                    = O_RDWR,
+	[WP_ACCESS_WRITE_EX]                   = O_RDWR | O_CREAT,
+	[WP_ACCESS_APPEND_EX]                  = O_RDWR | O_APPEND | O_CREAT,
+	[WP_ACCESS_WRITE_FAIL_ON_EXIST]        = O_WRONLY | O_CREAT | O_EXCL,
+	[WP_ACCESS_WRITE_FAIL_ON_EXIST_EX]     = O_RDWR | O_CREAT | O_EXCL,
 };
 
-wp_intern mode_t file_modes[FILE_ACCESS_MODE_COUNT] = {
-	[WAPP_ACCESS_READ]                       = 0,
-	[WAPP_ACCESS_WRITE]                      = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
-	[WAPP_ACCESS_APPEND]                     = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
-	[WAPP_ACCESS_READ_EX]                    = 0,
-	[WAPP_ACCESS_WRITE_EX]                   = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
-	[WAPP_ACCESS_APPEND_EX]                  = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
-	[WAPP_ACCESS_WRITE_FAIL_ON_EXIST]        = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
-	[WAPP_ACCESS_WRITE_FAIL_ON_EXIST_EX]     = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
+wp_intern mode_t file_modes[COUNT_FILE_ACCESS_MODE] = {
+	[WP_ACCESS_READ]                       = 0,
+	[WP_ACCESS_WRITE]                      = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
+	[WP_ACCESS_APPEND]                     = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
+	[WP_ACCESS_READ_EX]                    = 0,
+	[WP_ACCESS_WRITE_EX]                   = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
+	[WP_ACCESS_APPEND_EX]                  = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
+	[WP_ACCESS_WRITE_FAIL_ON_EXIST]        = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
+	[WP_ACCESS_WRITE_FAIL_ON_EXIST_EX]     = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
 };
 
-wp_intern i32 file_seek_origins[FILE_SEEK_ORIGIN_COUNT] = {
-	[WAPP_SEEK_START]   = SEEK_SET,
-	[WAPP_SEEK_CURRENT] = SEEK_CUR,
-	[WAPP_SEEK_END]     = SEEK_END,
+wp_intern i32 file_seek_origins[COUNT_FILE_SEEK_ORIGIN] = {
+	[WP_SEEK_START]   = SEEK_SET,
+	[WP_SEEK_CURRENT] = SEEK_CUR,
+	[WP_SEEK_END]     = SEEK_END,
 };
 
-WFile *wapp_file_stdin(void) {
-	wp_persist WFile _stdin  = { .fd = STDIN_FILENO };
+WpFile *wpFileStdin(void) {
+	wp_persist WpFile _stdin  = { .fd = STDIN_FILENO };
 	return &_stdin;
 }
 
-WFile *wapp_file_stdout(void) {
-	wp_persist WFile _stdout = { .fd = STDOUT_FILENO };
+WpFile *wpFileStdout(void) {
+	wp_persist WpFile _stdout = { .fd = STDOUT_FILENO };
 	return &_stdout;
 }
 
-WFile *wapp_file_stderr(void) {
-	wp_persist WFile _stderr = { .fd = STDERR_FILENO };
+WpFile *wpFileStderr(void) {
+	wp_persist WpFile _stderr = { .fd = STDERR_FILENO };
 	return &_stderr;
 }
 
-WFile *_file_open(const WpAllocator *allocator, WpStr8RO *filepath, FileAccessMode mode) {
-	wp_persist c8 tmp[WAPP_PATH_MAX] = {0};
-	memset(tmp, 0, WAPP_PATH_MAX);
+WpFile *_fileOpen(const WpAllocator *allocator, WpStr8RO *filepath, WpFileAccessMode mode) {
+	wp_persist c8 tmp[WP_PATH_MAX] = {0};
+	memset(tmp, 0, WP_PATH_MAX);
 	memcpy(tmp, filepath->buf, filepath->size);
 
 	i32 fd = open((const char *)tmp, file_flags[mode], file_modes[mode]);
@@ -74,7 +74,7 @@ WFile *_file_open(const WpAllocator *allocator, WpStr8RO *filepath, FileAccessMo
 		return NULL;
 	}
 
-	WFile *output = wpMemAllocatorAlloc(allocator, sizeof(WFile));
+	WpFile *output = wpMemAllocatorAlloc(allocator, sizeof(WpFile));
 	if (output) {
 		output->fd = fd;
 	}
@@ -82,11 +82,11 @@ WFile *_file_open(const WpAllocator *allocator, WpStr8RO *filepath, FileAccessMo
 	return output;
 }
 
-i64 _file_seek(WFile *file, i64 offset, FileSeekOrigin origin) {
+i64 _fileSeek(WpFile *file, i64 offset, WpFileSeekOrigin origin) {
 	return lseek64(file->fd, offset, file_seek_origins[origin]);
 }
 
-u64 _file_read(void *dst_buf, u64 byte_count, WFile *file, u64 file_length) {
+u64 _fileRead(void *dst_buf, u64 byte_count, WpFile *file, u64 file_length) {
 	u64 copy_byte_count = file_length <= byte_count ? file_length : byte_count;
 
 	i64 count = read(file->fd, dst_buf, copy_byte_count);
@@ -95,37 +95,37 @@ u64 _file_read(void *dst_buf, u64 byte_count, WFile *file, u64 file_length) {
 	return count;
 }
 
-i64 _file_write(const void *src_buf, WFile *file, u64 byte_count) {
+i64 _fileWrite(const void *src_buf, WpFile *file, u64 byte_count) {
 	return write(file->fd, src_buf, byte_count);
 }
 
-i32 _file_flush(WFile *file) {
+i32 _fileFlush(WpFile *file) {
 	return fsync(file->fd);
 }
 
-i32 _file_close(WFile *file) {
+i32 _fileClose(WpFile *file) {
 	return close(file->fd);
 }
 
-i32 _file_rename(WpStr8RO *old_filepath, WpStr8RO *new_filepath) {
-	wp_persist c8 old_tmp[WAPP_PATH_MAX] = {0};
-	wp_persist c8 new_tmp[WAPP_PATH_MAX] = {0};
-	memset(old_tmp, 0, WAPP_PATH_MAX);
+i32 _fileRename(WpStr8RO *old_filepath, WpStr8RO *new_filepath) {
+	wp_persist c8 old_tmp[WP_PATH_MAX] = {0};
+	wp_persist c8 new_tmp[WP_PATH_MAX] = {0};
+	memset(old_tmp, 0, WP_PATH_MAX);
 	memcpy(old_tmp, old_filepath->buf, old_filepath->size);
-	memset(new_tmp, 0, WAPP_PATH_MAX);
+	memset(new_tmp, 0, WP_PATH_MAX);
 	memcpy(new_tmp, new_filepath->buf, new_filepath->size);
 
 	i32 link_result = link((const char *)old_tmp, (const char *)new_tmp);
 	if (link_result == 0) {
-		_file_remove(old_filepath);
+		_fileRemove(old_filepath);
 	}
 
 	return link_result;
 }
 
-i32 _file_remove(WpStr8RO *filepath) {
-	wp_persist c8 tmp[WAPP_PATH_MAX] = {0};
-	memset(tmp, 0, WAPP_PATH_MAX);
+i32 _fileRemove(WpStr8RO *filepath) {
+	wp_persist c8 tmp[WP_PATH_MAX] = {0};
+	memset(tmp, 0, WP_PATH_MAX);
 	memcpy(tmp, filepath->buf, filepath->size);
 
 	return unlink((const char *)tmp);

src/os/file/posix/file_posix.h

@@ -12,9 +12,9 @@ BEGIN_C_LINKAGE
 
 #ifdef WP_PLATFORM_POSIX
 
-#define END_OF_LINE "\n"
+#define WP_END_OF_LINE "\n"
 
-struct WFile {
+struct WpFile {
 	i32 fd;
 };
 

src/os/file/win/file_win.c

@@ -15,66 +15,66 @@
 #include <fileapi.h>
 #include <intsafe.h>
 
-wp_intern DWORD file_accesses[FILE_ACCESS_MODE_COUNT] = {
-	[WAPP_ACCESS_READ]                       = FILE_READ_DATA,
-	[WAPP_ACCESS_WRITE]                      = FILE_WRITE_DATA,
-	[WAPP_ACCESS_APPEND]                     = FILE_APPEND_DATA,
-	[WAPP_ACCESS_READ_EX]                    = FILE_READ_DATA | FILE_WRITE_DATA,
-	[WAPP_ACCESS_WRITE_EX]                   = FILE_READ_DATA | FILE_WRITE_DATA,
-	[WAPP_ACCESS_APPEND_EX]                  = FILE_READ_DATA | FILE_APPEND_DATA,
-	[WAPP_ACCESS_WRITE_FAIL_ON_EXIST]        = FILE_WRITE_DATA,
-	[WAPP_ACCESS_WRITE_FAIL_ON_EXIST_EX]     = FILE_READ_DATA | FILE_WRITE_DATA,
+wp_intern DWORD file_accesses[COUNT_FILE_ACCESS_MODE] = {
+	[WP_ACCESS_READ]                       = FILE_READ_DATA,
+	[WP_ACCESS_WRITE]                      = FILE_WRITE_DATA,
+	[WP_ACCESS_APPEND]                     = FILE_APPEND_DATA,
+	[WP_ACCESS_READ_EX]                    = FILE_READ_DATA | FILE_WRITE_DATA,
+	[WP_ACCESS_WRITE_EX]                   = FILE_READ_DATA | FILE_WRITE_DATA,
+	[WP_ACCESS_APPEND_EX]                  = FILE_READ_DATA | FILE_APPEND_DATA,
+	[WP_ACCESS_WRITE_FAIL_ON_EXIST]        = FILE_WRITE_DATA,
+	[WP_ACCESS_WRITE_FAIL_ON_EXIST_EX]     = FILE_READ_DATA | FILE_WRITE_DATA,
 };
 
-wp_intern DWORD creation_dispositions[FILE_ACCESS_MODE_COUNT] = {
-	[WAPP_ACCESS_READ]                       = OPEN_EXISTING,
-	[WAPP_ACCESS_WRITE]                      = CREATE_ALWAYS,
-	[WAPP_ACCESS_APPEND]                     = OPEN_ALWAYS,
-	[WAPP_ACCESS_READ_EX]                    = OPEN_EXISTING,
-	[WAPP_ACCESS_WRITE_EX]                   = CREATE_ALWAYS,
-	[WAPP_ACCESS_APPEND_EX]                  = OPEN_ALWAYS,
-	[WAPP_ACCESS_WRITE_FAIL_ON_EXIST]        = CREATE_NEW,
-	[WAPP_ACCESS_WRITE_FAIL_ON_EXIST_EX]     = CREATE_NEW,
+wp_intern DWORD creation_dispositions[COUNT_FILE_ACCESS_MODE] = {
+	[WP_ACCESS_READ]                       = OPEN_EXISTING,
+	[WP_ACCESS_WRITE]                      = CREATE_ALWAYS,
+	[WP_ACCESS_APPEND]                     = OPEN_ALWAYS,
+	[WP_ACCESS_READ_EX]                    = OPEN_EXISTING,
+	[WP_ACCESS_WRITE_EX]                   = CREATE_ALWAYS,
+	[WP_ACCESS_APPEND_EX]                  = OPEN_ALWAYS,
+	[WP_ACCESS_WRITE_FAIL_ON_EXIST]        = CREATE_NEW,
+	[WP_ACCESS_WRITE_FAIL_ON_EXIST_EX]     = CREATE_NEW,
 };
 
-wp_intern DWORD sharing_modes[FILE_ACCESS_MODE_COUNT] = {
-	[WAPP_ACCESS_READ]                       = FILE_SHARE_READ | FILE_SHARE_WRITE,
-	[WAPP_ACCESS_WRITE]                      = FILE_SHARE_READ,
-	[WAPP_ACCESS_APPEND]                     = FILE_SHARE_READ,
-	[WAPP_ACCESS_READ_EX]                    = FILE_SHARE_READ | FILE_SHARE_WRITE,
-	[WAPP_ACCESS_WRITE_EX]                   = FILE_SHARE_READ,
-	[WAPP_ACCESS_APPEND_EX]                  = FILE_SHARE_READ,
-	[WAPP_ACCESS_WRITE_FAIL_ON_EXIST]        = FILE_SHARE_READ,
-	[WAPP_ACCESS_WRITE_FAIL_ON_EXIST_EX]     = FILE_SHARE_READ,
+wp_intern DWORD sharing_modes[COUNT_FILE_ACCESS_MODE] = {
+	[WP_ACCESS_READ]                       = FILE_SHARE_READ | FILE_SHARE_WRITE,
+	[WP_ACCESS_WRITE]                      = FILE_SHARE_READ,
+	[WP_ACCESS_APPEND]                     = FILE_SHARE_READ,
+	[WP_ACCESS_READ_EX]                    = FILE_SHARE_READ | FILE_SHARE_WRITE,
+	[WP_ACCESS_WRITE_EX]                   = FILE_SHARE_READ,
+	[WP_ACCESS_APPEND_EX]                  = FILE_SHARE_READ,
+	[WP_ACCESS_WRITE_FAIL_ON_EXIST]        = FILE_SHARE_READ,
+	[WP_ACCESS_WRITE_FAIL_ON_EXIST_EX]     = FILE_SHARE_READ,
 };
 
-wp_intern DWORD file_seek_origins[FILE_SEEK_ORIGIN_COUNT] = {
-	[WAPP_SEEK_START]   = FILE_BEGIN,
-	[WAPP_SEEK_CURRENT] = FILE_CURRENT,
-	[WAPP_SEEK_END]     = FILE_END,
+wp_intern DWORD file_seek_origins[COUNT_FILE_SEEK_ORIGIN] = {
+	[WP_SEEK_START]   = FILE_BEGIN,
+	[WP_SEEK_CURRENT] = FILE_CURRENT,
+	[WP_SEEK_END]     = FILE_END,
 };
 
-WFile *wapp_file_stdin(void) {
-	wp_persist WFile _stdin  = { .fh = INVALID_HANDLE_VALUE };
+WpFile *wpFileStdin(void) {
+	wp_persist WpFile _stdin  = { .fh = INVALID_HANDLE_VALUE };
 	_stdin.fh = GetStdHandle(STD_INPUT_HANDLE);
 	return &_stdin;
 }
 
-WFile *wapp_file_stdout(void) {
-	wp_persist WFile _stdout = { .fh = INVALID_HANDLE_VALUE };
+WpFile *wpFileStdout(void) {
+	wp_persist WpFile _stdout = { .fh = INVALID_HANDLE_VALUE };
 	_stdout.fh = GetStdHandle(STD_OUTPUT_HANDLE);
 	return &_stdout;
 }
 
-WFile *wapp_file_stderr(void) {
-	wp_persist WFile _stderr = { .fh = INVALID_HANDLE_VALUE };
+WpFile *wpFileStderr(void) {
+	wp_persist WpFile _stderr = { .fh = INVALID_HANDLE_VALUE };
 	_stderr.fh = GetStdHandle(STD_ERROR_HANDLE);
 	return &_stderr;
 }
 
-WFile *_file_open(const WpAllocator *allocator, WpStr8RO *filepath, FileAccessMode mode) {
-	wp_persist c8 tmp[WAPP_PATH_MAX] = {0};
-	memset(tmp, 0, WAPP_PATH_MAX);
+WpFile *_fileOpen(const WpAllocator *allocator, WpStr8RO *filepath, WpFileAccessMode mode) {
+	wp_persist c8 tmp[WP_PATH_MAX] = {0};
+	memset(tmp, 0, WP_PATH_MAX);
 	memcpy(tmp, filepath->buf, filepath->size);
 
 	HANDLE fh = CreateFileA((LPCSTR)tmp,
@@ -88,7 +88,7 @@ WFile *_file_open(const WpAllocator *allocator, WpStr8RO *filepath, FileAccessMo
 		return NULL;
 	}
 
-	WFile *output = wpMemAllocatorAlloc(allocator, sizeof(WFile));
+	WpFile *output = wpMemAllocatorAlloc(allocator, sizeof(WpFile));
 	if (output) {
 		output->fh = fh;
 	}
@@ -96,7 +96,7 @@ WFile *_file_open(const WpAllocator *allocator, WpStr8RO *filepath, FileAccessMo
 	return output;
 }
 
-i64 _file_seek(WFile *file, i64 offset, FileSeekOrigin origin) {
+i64 _fileSeek(WpFile *file, i64 offset, WpFileSeekOrigin origin) {
 	LARGE_INTEGER distance = {0};
 	LARGE_INTEGER output   = {0};
 
@@ -109,7 +109,7 @@ i64 _file_seek(WFile *file, i64 offset, FileSeekOrigin origin) {
 	return output.QuadPart;
 }
 
-u64 _file_read(void* dst_buf, u64 byte_count, WFile* file, u64 file_length) {
+u64 _fileRead(void* dst_buf, u64 byte_count, WpFile* file, u64 file_length) {
 	u64 copy_byte_count = file_length <= byte_count ? file_length : byte_count;
 	wpDebugAssert(copy_byte_count <= DWORD_MAX, "Attempting to read large number of bytes at once");
 
@@ -121,7 +121,7 @@ u64 _file_read(void* dst_buf, u64 byte_count, WFile* file, u64 file_length) {
 	return (u64)read_count;
 }
 
-i64 _file_write(const void *src_buf, WFile *file, u64 byte_count) {
+i64 _fileWrite(const void *src_buf, WpFile *file, u64 byte_count) {
 	wpDebugAssert(byte_count <= DWORD_MAX, "Attempting to write large number of bytes at once");
 
 	DWORD write_count = 0;
@@ -131,7 +131,7 @@ i64 _file_write(const void *src_buf, WFile *file, u64 byte_count) {
 	return (i64)write_count;
 }
 
-i32 _file_flush(WFile *file) {
+i32 _fileFlush(WpFile *file) {
 	if (!FlushFileBuffers(file->fh)) {
 		return -1;
 	}
@@ -139,7 +139,7 @@ i32 _file_flush(WFile *file) {
 	return 0;
 }
 
-i32 _file_close(WFile *file) {
+i32 _fileClose(WpFile *file) {
 	if (!CloseHandle(file->fh)) {
 		return -1;
 	}
@@ -147,12 +147,12 @@ i32 _file_close(WFile *file) {
 	return 0;
 }
 
-i32 _file_rename(WpStr8RO *old_filepath, WpStr8RO *new_filepath) {
-	wp_persist c8 old_tmp[WAPP_PATH_MAX] = {0};
-	wp_persist c8 new_tmp[WAPP_PATH_MAX] = {0};
-	memset(old_tmp, 0, WAPP_PATH_MAX);
+i32 _fileRename(WpStr8RO *old_filepath, WpStr8RO *new_filepath) {
+	wp_persist c8 old_tmp[WP_PATH_MAX] = {0};
+	wp_persist c8 new_tmp[WP_PATH_MAX] = {0};
+	memset(old_tmp, 0, WP_PATH_MAX);
 	memcpy(old_tmp, old_filepath->buf, old_filepath->size);
-	memset(new_tmp, 0, WAPP_PATH_MAX);
+	memset(new_tmp, 0, WP_PATH_MAX);
 	memcpy(new_tmp, new_filepath->buf, new_filepath->size);
 
 	if (!MoveFile((LPCSTR)old_tmp, (LPCSTR)new_tmp)) {
@@ -162,9 +162,9 @@ i32 _file_rename(WpStr8RO *old_filepath, WpStr8RO *new_filepath) {
 	return 0;
 }
 
-i32 _file_remove(WpStr8RO *filepath) {
-	wp_persist c8 tmp[WAPP_PATH_MAX] = {0};
-	memset(tmp, 0, WAPP_PATH_MAX);
+i32 _fileRemove(WpStr8RO *filepath) {
+	wp_persist c8 tmp[WP_PATH_MAX] = {0};
+	memset(tmp, 0, WP_PATH_MAX);
 	memcpy(tmp, filepath->buf, filepath->size);
 
 	if (!DeleteFile((LPCSTR)tmp)) {

src/os/file/win/file_win.h

@@ -12,13 +12,13 @@ BEGIN_C_LINKAGE
 
 #ifdef WP_PLATFORM_WINDOWS
 
-#define END_OF_LINE "\r\n"
+#define WP_END_OF_LINE "\r\n"
 
 #define WIN32_LEAN_AND_MEAN
 #include <Windows.h>
 #include <fileapi.h>
 
-struct WFile {
+struct WpFile {
 	HANDLE fh;
 };
 

src/os/mem/mem_os.c

@@ -15,16 +15,16 @@
 #error "Unrecognised platform"
 #endif
 
-void *wapp_os_mem_alloc(void *addr, u64 size, MemAccess access, MemAllocFlags flags, MemInitType type) {
-	void *output = os_mem_allocate(addr, size, access, flags, type);
+void *wpOsMemAlloc(void *addr, u64 size, WpMemAccess access, WpMemAllocFlags flags, WpMemInitType type) {
+	void *output = _osMemAllocate(addr, size, access, flags, type);
 
-	if (type == WAPP_MEM_INIT_INITIALISED) {
+	if (type == WP_MEM_INIT_INITIALISED) {
 		memset(output, 0, size);
 	}
 
 	return output;
 }
 
-void wapp_os_mem_free(void *ptr, u64 size) {
-	os_mem_free(ptr, size);
+void wpOsMemFree(void *ptr, u64 size) {
+	_osMemFree(ptr, size);
 }

src/os/mem/mem_os.h

@@ -20,11 +20,11 @@ BEGIN_C_LINKAGE
 #error "Unrecognised platform"
 #endif
 
-void *wapp_os_mem_alloc(void *addr, u64 size, MemAccess access, MemAllocFlags flags, MemInitType type);
-void wapp_os_mem_free(void *ptr, u64 size);
+void *wpOsMemAlloc(void *addr, u64 size, WpMemAccess access, WpMemAllocFlags flags, WpMemInitType type);
+void wpOsMemFree(void *ptr, u64 size);
 
-wp_extern void *os_mem_allocate(void *addr, u64 size, MemAccess access, MemAllocFlags flags, MemInitType type);
-wp_extern void os_mem_free(void *ptr, u64 size);
+wp_extern void *_osMemAllocate(void *addr, u64 size, WpMemAccess access, WpMemAllocFlags flags, WpMemInitType type);
+wp_extern void  _osMemFree(void *ptr, u64 size);
 
 #ifdef WP_PLATFORM_CPP
 END_C_LINKAGE

src/os/mem/mem_os_ops.h

@@ -9,19 +9,19 @@
 BEGIN_C_LINKAGE
 #endif // !WP_PLATFORM_CPP
 
-typedef enum mem_access {
-	WAPP_MEM_ACCESS_NONE,
-	WAPP_MEM_ACCESS_READ_ONLY,
-	WAPP_MEM_ACCESS_EXEC_ONLY,
-	WAPP_MEM_ACCESS_READ_WRITE,
-	WAPP_MEM_ACCESS_READ_EXEC,
-	WAPP_MEM_ACCESS_READ_WRITE_EXEC,
-} MemAccess;
+typedef enum {
+	WP_MEM_ACCESS_NONE,
+	WP_MEM_ACCESS_READ_ONLY,
+	WP_MEM_ACCESS_EXEC_ONLY,
+	WP_MEM_ACCESS_READ_WRITE,
+	WP_MEM_ACCESS_READ_EXEC,
+	WP_MEM_ACCESS_READ_WRITE_EXEC,
+} WpMemAccess;
 
-typedef enum mem_init_type {
-	WAPP_MEM_INIT_UNINITIALISED,
-	WAPP_MEM_INIT_INITIALISED,
-} MemInitType;
+typedef enum {
+	WP_MEM_INIT_UNINITIALISED,
+	WP_MEM_INIT_INITIALISED,
+} WpMemInitType;
 
 #ifdef WP_PLATFORM_CPP
 END_C_LINKAGE

src/os/mem/posix/mem_os_posix.c

@@ -10,15 +10,15 @@
 #include <sys/mman.h>
 
 wp_intern const i32 access_types[] = {
-	[WAPP_MEM_ACCESS_NONE]            = PROT_NONE,
-	[WAPP_MEM_ACCESS_READ_ONLY]       = PROT_READ,
-	[WAPP_MEM_ACCESS_EXEC_ONLY]       = PROT_EXEC,
-	[WAPP_MEM_ACCESS_READ_WRITE]      = PROT_READ | PROT_WRITE,
-	[WAPP_MEM_ACCESS_READ_EXEC]       = PROT_READ | PROT_EXEC,
-	[WAPP_MEM_ACCESS_READ_WRITE_EXEC] = PROT_READ | PROT_WRITE | PROT_EXEC,
+	[WP_MEM_ACCESS_NONE]            = PROT_NONE,
+	[WP_MEM_ACCESS_READ_ONLY]       = PROT_READ,
+	[WP_MEM_ACCESS_EXEC_ONLY]       = PROT_EXEC,
+	[WP_MEM_ACCESS_READ_WRITE]      = PROT_READ | PROT_WRITE,
+	[WP_MEM_ACCESS_READ_EXEC]       = PROT_READ | PROT_EXEC,
+	[WP_MEM_ACCESS_READ_WRITE_EXEC] = PROT_READ | PROT_WRITE | PROT_EXEC,
 };
 
-void *os_mem_allocate(void *addr, u64 size, MemAccess access, MemAllocFlags flags, MemInitType type) {
+void *_osMemAllocate(void *addr, u64 size, WpMemAccess access, WpMemAllocFlags flags, WpMemInitType type) {
 	(void)type;
 	i32 alloc_flags = flags | MAP_ANON | MAP_PRIVATE;
 
@@ -29,7 +29,7 @@ void *os_mem_allocate(void *addr, u64 size, MemAccess access, MemAllocFlags flag
 	return mmap(addr, size, access_types[access], alloc_flags, -1, 0);
 }
 
-void os_mem_free(void *ptr, u64 size) {
+void _osMemFree(void *ptr, u64 size) {
 	munmap(ptr, size);
 }
 

src/os/mem/posix/mem_os_posix.h

@@ -13,18 +13,18 @@ BEGIN_C_LINKAGE
 
 #include <sys/mman.h>
 
-typedef enum mem_alloc_flags {
+typedef enum {
 #if defined(WP_PLATFORM_LINUX) || defined(WP_PLATFORM_GNU)
-	WAPP_MEM_ALLOC_RESERVE = 0,
-	WAPP_MEM_ALLOC_COMMIT  = MAP_POPULATE,
+	WP_MEM_ALLOC_RESERVE = 0,
+	WP_MEM_ALLOC_COMMIT  = MAP_POPULATE,
 #elif defined(WP_PLATFORM_FREE_BSD)
-	WAPP_MEM_ALLOC_RESERVE = 0,
-	WAPP_MEM_ALLOC_COMMIT  = MAP_PREFAULT_READ,
+	WP_MEM_ALLOC_RESERVE = 0,
+	WP_MEM_ALLOC_COMMIT  = MAP_PREFAULT_READ,
 #elif defined(WP_PLATFORM_BSD) || defined(WP_PLATFORM_UNIX) || defined(WP_PLATFORM_APPLE)
-	WAPP_MEM_ALLOC_RESERVE = 0,
-	WAPP_MEM_ALLOC_COMMIT  = 0,
+	WP_MEM_ALLOC_RESERVE = 0,
+	WP_MEM_ALLOC_COMMIT  = 0,
 #endif
-} MemAllocFlags;
+} WpMemAllocFlags;
 
 #endif // !WP_PLATFORM_POSIX
 

src/os/mem/win/mem_os_win.c

@@ -13,24 +13,24 @@
 #include <memoryapi.h>
 
 wp_intern const i32 access_types[] = {
-	[WAPP_MEM_ACCESS_NONE]            = PAGE_NOACCESS,
-	[WAPP_MEM_ACCESS_READ_ONLY]       = PAGE_READONLY,
-	[WAPP_MEM_ACCESS_EXEC_ONLY]       = PAGE_EXECUTE,
-	[WAPP_MEM_ACCESS_READ_WRITE]      = PAGE_READWRITE,
-	[WAPP_MEM_ACCESS_READ_EXEC]       = PAGE_EXECUTE_READ,
-	[WAPP_MEM_ACCESS_READ_WRITE_EXEC] = PAGE_EXECUTE_READWRITE,
+	[WP_MEM_ACCESS_NONE]            = PAGE_NOACCESS,
+	[WP_MEM_ACCESS_READ_ONLY]       = PAGE_READONLY,
+	[WP_MEM_ACCESS_EXEC_ONLY]       = PAGE_EXECUTE,
+	[WP_MEM_ACCESS_READ_WRITE]      = PAGE_READWRITE,
+	[WP_MEM_ACCESS_READ_EXEC]       = PAGE_EXECUTE_READ,
+	[WP_MEM_ACCESS_READ_WRITE_EXEC] = PAGE_EXECUTE_READWRITE,
 };
 
-void *os_mem_allocate(void *addr, u64 size, MemAccess access, MemAllocFlags flags, MemInitType type) {
+void *_osMemAllocate(void *addr, u64 size, WpMemAccess access, WpMemAllocFlags flags, WpMemInitType type) {
 	// Ensure memory is committed if it's meant to be initialised
-	if (type == WAPP_MEM_INIT_INITIALISED) {
-		flags |= WAPP_MEM_ALLOC_COMMIT;
+	if (type == WP_MEM_INIT_INITIALISED) {
+		flags |= WP_MEM_ALLOC_COMMIT;
 	}
 
 	return VirtualAlloc(addr, (SIZE_T)size, flags, access_types[access]);
 }
 
-void os_mem_free(void *ptr, u64 size) {
+void _osMemFree(void *ptr, u64 size) {
 	VirtualFree(ptr, size, MEM_RELEASE);
 }
 

src/os/mem/win/mem_os_win.h

@@ -15,10 +15,10 @@ BEGIN_C_LINKAGE
 #include <Windows.h>
 #include <memoryapi.h>
 
-typedef enum mem_alloc_flags {
-	WAPP_MEM_ALLOC_RESERVE = MEM_RESERVE,
-	WAPP_MEM_ALLOC_COMMIT  = MEM_COMMIT,
-} MemAllocFlags;
+typedef enum {
+	WP_MEM_ALLOC_RESERVE = MEM_RESERVE,
+	WP_MEM_ALLOC_COMMIT  = MEM_COMMIT,
+} WpMemAllocFlags;
 
 #endif // !WP_PLATFORM_WINDOWS
 

src/os/shell/commander/commander.c

@@ -17,85 +17,85 @@
 #define CMD_BUF_LEN 8192
 #define OUT_BUF_LEN 4096
 
-wp_intern CMDResult execute_command(WpStr8RO *cmd, CMDOutHandling out_handling, WpStr8 *out_buf);
-wp_intern CMDError get_command_output(FILE *fp, CMDOutHandling out_handling, WpStr8 *out_buf);
+wp_intern WpCmdResult executeCommand(WpStr8RO *cmd, WpCmdOutHandling out_handling, WpStr8 *out_buf);
+wp_intern WpCmdError getCommandOutput(FILE *fp, WpCmdOutHandling out_handling, WpStr8 *out_buf);
 
-CMDResult wapp_shell_commander_execute(CMDOutHandling out_handling, WpStr8 *out_buf, const WpStr8List *cmd) {
+WpCmdResult wpShellCommanderExecute(WpCmdOutHandling out_handling, WpStr8 *out_buf, const WpStr8List *cmd) {
 	if (!cmd) {
-		return CMD_NO_EXIT(SHELL_ERR_INVALID_ARGS);
+		return wpCmdNoExit(WP_SHELL_ERR_INVALID_ARGS);
 	}
 
-	WpAllocator arena = wapp_mem_arena_allocator_init(KiB(500));
+	WpAllocator arena = wpMemArenaAllocatorInit(KiB(500));
 
 	WpStr8 *cmd_str = wpStr8Join(&arena, cmd, &wpStr8LitRo(" "));
 	if (!cmd_str) {
-		wapp_mem_arena_allocator_destroy(&arena);
-		return CMD_NO_EXIT(SHELL_ERR_ALLOCATION_FAIL);
+		wpMemArenaAllocatorDestroy(&arena);
+		return wpCmdNoExit(WP_SHELL_ERR_ALLOCATION_FAIL);
 	}
 
 	// Redirect output
 	cmd_str = wpStr8AllocConcat(&arena, cmd_str, &wpStr8LitRo(" 2>&1"));
 
-	CMDResult output = execute_command(cmd_str, out_handling, out_buf);
+	WpCmdResult output = executeCommand(cmd_str, out_handling, out_buf);
 
-	wapp_mem_arena_allocator_destroy(&arena);
+	wpMemArenaAllocatorDestroy(&arena);
 
 	return output;
 }
 
-wp_intern CMDResult execute_command(WpStr8RO *cmd, CMDOutHandling out_handling, WpStr8 *out_buf) {
+wp_intern WpCmdResult executeCommand(WpStr8RO *cmd, WpCmdOutHandling out_handling, WpStr8 *out_buf) {
 	char cmd_buf[CMD_BUF_LEN] = {0};
 	wpStr8CopyToCstr(cmd_buf, cmd, CMD_BUF_LEN);
 
-	FILE *fp = wapp_shell_utils_popen(cmd_buf, "r");
+	FILE *fp = wpShellUtilsPopen(cmd_buf, "r");
 	if (!fp) {
-		return CMD_NO_EXIT(SHELL_ERR_PROC_START_FAIL);
+		return wpCmdNoExit(WP_SHELL_ERR_PROC_START_FAIL);
 	}
 
-	CMDResult output;
+	WpCmdResult output;
 
-	CMDError err = get_command_output(fp, out_handling, out_buf);
-	if (err > SHELL_ERR_NO_ERROR) {
-		output = CMD_NO_EXIT(err);
-		goto EXECUTE_COMMAND_CLOSE;
+	WpCmdError err = getCommandOutput(fp, out_handling, out_buf);
+	if (err > WP_SHELL_ERR_NO_ERROR) {
+		output = wpCmdNoExit(err);
+		goto executeCommand_CLOSE;
 	}
 
 	i32 st = EXIT_SUCCESS;
-	err = get_output_status(fp, &st);
-	if (err > SHELL_ERR_NO_ERROR) {
-		output = CMD_NO_EXIT(err);
-		goto EXECUTE_COMMAND_CLOSE;
+	err = _getOutputStatus(fp, &st);
+	if (err > WP_SHELL_ERR_NO_ERROR) {
+		output = wpCmdNoExit(err);
+		goto executeCommand_CLOSE;
 	}
 
-	// Process is already closed in get_output_status
+	// Process is already closed in _getOutputStatus
 	fp = NULL;
 
-	output = (CMDResult){
+	output = (WpCmdResult){
 		.exited    = true,
 		.exit_code = st,
-		.error     = SHELL_ERR_NO_ERROR,
+		.error     = WP_SHELL_ERR_NO_ERROR,
 	};
 
-EXECUTE_COMMAND_CLOSE:
+executeCommand_CLOSE:
 	if (fp) {
-		wapp_shell_utils_pclose(fp);
+		wpShellUtilsPclose(fp);
 	}
 	return output;
 }
 
-wp_intern CMDError get_command_output(FILE *fp, CMDOutHandling out_handling, WpStr8 *out_buf) {
+wp_intern WpCmdError getCommandOutput(FILE *fp, WpCmdOutHandling out_handling, WpStr8 *out_buf) {
 	WpStr8 out = wpStr8Buf(OUT_BUF_LEN);
 
 	out.size = fread((void *)out.buf, sizeof(c8), out.capacity, fp);
-	if (out_handling == SHELL_OUTPUT_CAPTURE && out_buf != NULL) {
+	if (out_handling == WP_SHELL_OUTPUT_CAPTURE && out_buf != NULL) {
 		if (out.size >= out_buf->capacity) {
-			return SHELL_ERR_OUT_BUF_FULL;
+			return WP_SHELL_ERR_OUT_BUF_FULL;
 		}
 
 		wpStr8ConcatCapped(out_buf, &out);
-	} else if (out_handling == SHELL_OUTPUT_PRINT) {
+	} else if (out_handling == WP_SHELL_OUTPUT_PRINT) {
 		printf(WP_STR8_SPEC, wpStr8Varg(out));
 	}
 
-	return SHELL_ERR_NO_ERROR;
+	return WP_SHELL_ERR_NO_ERROR;
 }

src/os/shell/commander/commander.h

@@ -16,11 +16,11 @@
 BEGIN_C_LINKAGE
 #endif // !WP_PLATFORM_CPP
 
-#define CMD_NO_EXIT(ERR) ((CMDResult){.exited = false, .exit_code = EXIT_FAILURE, .error = ERR})
+#define wpCmdNoExit(ERR) ((WpCmdResult){.exited = false, .exit_code = EXIT_FAILURE, .error = ERR})
 
-CMDResult wapp_shell_commander_execute(CMDOutHandling out_handling, WpStr8 *out_buf, const WpStr8List *cmd);
+WpCmdResult wpShellCommanderExecute(WpCmdOutHandling out_handling, WpStr8 *out_buf, const WpStr8List *cmd);
 
-wp_extern CMDError get_output_status(FILE *fp, i32 *status_out);
+wp_extern WpCmdError _getOutputStatus(FILE *fp, i32 *status_out);
 
 #ifdef WP_PLATFORM_CPP
 END_C_LINKAGE

src/os/shell/commander/commander_output.h

@@ -12,27 +12,27 @@ BEGIN_C_LINKAGE
 #endif // !WP_PLATFORM_CPP
 
 typedef enum {
-	SHELL_OUTPUT_DISCARD,
-	SHELL_OUTPUT_PRINT,
-	SHELL_OUTPUT_CAPTURE,
-} CMDOutHandling;
+	WP_SHELL_OUTPUT_DISCARD,
+	WP_SHELL_OUTPUT_PRINT,
+	WP_SHELL_OUTPUT_CAPTURE,
+} WpCmdOutHandling;
 
 typedef enum {
-	SHELL_ERR_NO_ERROR,
-	SHELL_ERR_INVALID_ARGS,
-	SHELL_ERR_ALLOCATION_FAIL,
-	SHELL_ERR_PROC_START_FAIL,
-	SHELL_ERR_OUT_BUF_FULL,
-	SHELL_ERR_PROC_EXIT_FAIL,
-} CMDError;
+	WP_SHELL_ERR_NO_ERROR,
+	WP_SHELL_ERR_INVALID_ARGS,
+	WP_SHELL_ERR_ALLOCATION_FAIL,
+	WP_SHELL_ERR_PROC_START_FAIL,
+	WP_SHELL_ERR_OUT_BUF_FULL,
+	WP_SHELL_ERR_PROC_EXIT_FAIL,
+} WpCmdError;
 
-typedef struct CMDResult CMDResult;
-struct CMDResult {
+typedef struct WpCmdResult WpCmdResult;
+struct WpCmdResult {
 	i32 exit_code;
-	CMDError error;
+	WpCmdError error;
 	b8 exited;
 
-	wpMiscUtilsReservePadding(sizeof(b8) + sizeof(i32) + sizeof(CMDError));
+	wpMiscUtilsReservePadding(sizeof(b8) + sizeof(i32) + sizeof(WpCmdError));
 };
 
 #ifdef WP_PLATFORM_CPP

src/os/shell/commander/posix/commander_posix.c

@@ -10,16 +10,16 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-CMDError get_output_status(FILE *fp, i32 *status_out) {
-	*status_out = wapp_shell_utils_pclose(fp);
+WpCmdError _getOutputStatus(FILE *fp, i32 *status_out) {
+	*status_out = wpShellUtilsPclose(fp);
 
 	if (!WIFEXITED(*status_out)) {
-		return SHELL_ERR_PROC_EXIT_FAIL;
+		return WP_SHELL_ERR_PROC_EXIT_FAIL;
 	}
 
 	*status_out = WEXITSTATUS(*status_out);
 
-	return SHELL_ERR_NO_ERROR;
+	return WP_SHELL_ERR_NO_ERROR;
 }
 
 #endif // !WP_PLATFORM_POSIX

src/os/shell/commander/win/commander_win.c

@@ -9,16 +9,16 @@
 #include "../../utils/shell_utils.h"
 #include <stdio.h>
 
-CMDError get_output_status(FILE *fp, i32 *status_out) {
+WpCmdError _getOutputStatus(FILE *fp, i32 *status_out) {
 	if (!feof(fp)) {
 		// Ensure process is closed on failure
-		wapp_shell_utils_pclose(fp);
-		return SHELL_ERR_PROC_EXIT_FAIL;
+		wpShellUtilsPclose(fp);
+		return WP_SHELL_ERR_PROC_EXIT_FAIL;
 	}
 
-	*status_out = wapp_shell_utils_pclose(fp);
+	*status_out = wpShellUtilsPclose(fp);
 
-	return SHELL_ERR_NO_ERROR;
+	return WP_SHELL_ERR_NO_ERROR;
 }
 
 #endif // !WP_PLATFORM_WINDOWS

src/os/shell/termcolour/posix/termcolour_posix.c

@@ -10,26 +10,26 @@
 #include <stdio.h>
 
 wp_intern WpStr8RO colours[COUNT_TERM_COLOUR] = {
-	[WAPP_TERM_COLOUR_FG_BLACK]      = wpStr8LitRoInitialiserList("\033[30m"),
-	[WAPP_TERM_COLOUR_FG_RED]        = wpStr8LitRoInitialiserList("\033[31m"),
-	[WAPP_TERM_COLOUR_FG_GREEN]      = wpStr8LitRoInitialiserList("\033[32m"),
-	[WAPP_TERM_COLOUR_FG_BLUE]       = wpStr8LitRoInitialiserList("\033[34m"),
-	[WAPP_TERM_COLOUR_FG_CYAN]       = wpStr8LitRoInitialiserList("\033[36m"),
-	[WAPP_TERM_COLOUR_FG_MAGENTA]    = wpStr8LitRoInitialiserList("\033[35m"),
-	[WAPP_TERM_COLOUR_FG_YELLOW]     = wpStr8LitRoInitialiserList("\033[33m"),
-	[WAPP_TERM_COLOUR_FG_WHITE]      = wpStr8LitRoInitialiserList("\033[37m"),
-	[WAPP_TERM_COLOUR_FG_BR_BLACK]   = wpStr8LitRoInitialiserList("\033[90m"),
-	[WAPP_TERM_COLOUR_FG_BR_RED]     = wpStr8LitRoInitialiserList("\033[91m"),
-	[WAPP_TERM_COLOUR_FG_BR_GREEN]   = wpStr8LitRoInitialiserList("\033[92m"),
-	[WAPP_TERM_COLOUR_FG_BR_BLUE]    = wpStr8LitRoInitialiserList("\033[94m"),
-	[WAPP_TERM_COLOUR_FG_BR_CYAN]    = wpStr8LitRoInitialiserList("\033[96m"),
-	[WAPP_TERM_COLOUR_FG_BR_MAGENTA] = wpStr8LitRoInitialiserList("\033[95m"),
-	[WAPP_TERM_COLOUR_FG_BR_YELLOW]  = wpStr8LitRoInitialiserList("\033[93m"),
-	[WAPP_TERM_COLOUR_FG_BR_WHITE]   = wpStr8LitRoInitialiserList("\033[97m"),
-	[WAPP_TERM_COLOUR_CLEAR]         = wpStr8LitRoInitialiserList("\033[0m"),
+	[WP_TERM_COLOUR_FG_BLACK]      = wpStr8LitRoInitialiserList("\033[30m"),
+	[WP_TERM_COLOUR_FG_RED]        = wpStr8LitRoInitialiserList("\033[31m"),
+	[WP_TERM_COLOUR_FG_GREEN]      = wpStr8LitRoInitialiserList("\033[32m"),
+	[WP_TERM_COLOUR_FG_BLUE]       = wpStr8LitRoInitialiserList("\033[34m"),
+	[WP_TERM_COLOUR_FG_CYAN]       = wpStr8LitRoInitialiserList("\033[36m"),
+	[WP_TERM_COLOUR_FG_MAGENTA]    = wpStr8LitRoInitialiserList("\033[35m"),
+	[WP_TERM_COLOUR_FG_YELLOW]     = wpStr8LitRoInitialiserList("\033[33m"),
+	[WP_TERM_COLOUR_FG_WHITE]      = wpStr8LitRoInitialiserList("\033[37m"),
+	[WP_TERM_COLOUR_FG_BR_BLACK]   = wpStr8LitRoInitialiserList("\033[90m"),
+	[WP_TERM_COLOUR_FG_BR_RED]     = wpStr8LitRoInitialiserList("\033[91m"),
+	[WP_TERM_COLOUR_FG_BR_GREEN]   = wpStr8LitRoInitialiserList("\033[92m"),
+	[WP_TERM_COLOUR_FG_BR_BLUE]    = wpStr8LitRoInitialiserList("\033[94m"),
+	[WP_TERM_COLOUR_FG_BR_CYAN]    = wpStr8LitRoInitialiserList("\033[96m"),
+	[WP_TERM_COLOUR_FG_BR_MAGENTA] = wpStr8LitRoInitialiserList("\033[95m"),
+	[WP_TERM_COLOUR_FG_BR_YELLOW]  = wpStr8LitRoInitialiserList("\033[93m"),
+	[WP_TERM_COLOUR_FG_BR_WHITE]   = wpStr8LitRoInitialiserList("\033[97m"),
+	[WP_TERM_COLOUR_CLEAR]         = wpStr8LitRoInitialiserList("\033[0m"),
 };
 
-void print_coloured_text(WpStr8RO *text, TerminalColour colour) {
+void _printColouredText(WpStr8RO *text, WpTerminalColour colour) {
 	printf(WP_STR8_SPEC WP_STR8_SPEC, wpStr8Varg(colours[colour]), wpStr8Varg((*text)));
 }
 

src/os/shell/termcolour/termcolour.c

@@ -4,15 +4,15 @@
 #include "terminal_colours.h"
 #include "../../../base/strings/str8/str8.h"
 
-void wapp_shell_termcolour_print_text(WpStr8RO *text, TerminalColour colour) {
-	if (colour < WAPP_TERM_COLOUR_FG_BLACK || colour > WAPP_TERM_COLOUR_FG_BR_WHITE) {
+void wpShellTermcolourPrintText(WpStr8RO *text, WpTerminalColour colour) {
+	if (colour < WP_TERM_COLOUR_FG_BLACK || colour > WP_TERM_COLOUR_FG_BR_WHITE) {
 		return;
 	}
 
-	print_coloured_text(text, colour);
+	_printColouredText(text, colour);
 }
 
-void wapp_shell_termcolour_clear_colour(void) {
+void wpShellTermcolourClearColour(void) {
 	WpStr8RO empty = wpStr8LitRo("");
-	print_coloured_text(&empty, WAPP_TERM_COLOUR_CLEAR);
+	_printColouredText(&empty, WP_TERM_COLOUR_CLEAR);
 }

src/os/shell/termcolour/termcolour.h

@@ -14,10 +14,10 @@ BEGIN_C_LINKAGE
 
 // TODO (Abdelrahman): Look into moving away from stdio in the implementation
 
-void wapp_shell_termcolour_print_text(WpStr8RO *text, TerminalColour colour);
-void wapp_shell_termcolour_clear_colour(void);
+void wpShellTermcolourPrintText(WpStr8RO *text, WpTerminalColour colour);
+void wpShellTermcolourClearColour(void);
 
-wp_extern void print_coloured_text(WpStr8RO *text, TerminalColour colour);
+wp_extern void _printColouredText(WpStr8RO *text, WpTerminalColour colour);
 
 #ifdef WP_PLATFORM_CPP
 END_C_LINKAGE

src/os/shell/termcolour/terminal_colours.h

@@ -11,26 +11,26 @@ BEGIN_C_LINKAGE
 #endif // !WP_PLATFORM_CPP
 
 typedef enum {
-	WAPP_TERM_COLOUR_FG_BLACK,
-	WAPP_TERM_COLOUR_FG_RED,
-	WAPP_TERM_COLOUR_FG_GREEN,
-	WAPP_TERM_COLOUR_FG_BLUE,
-	WAPP_TERM_COLOUR_FG_CYAN,
-	WAPP_TERM_COLOUR_FG_MAGENTA,
-	WAPP_TERM_COLOUR_FG_YELLOW,
-	WAPP_TERM_COLOUR_FG_WHITE,
-	WAPP_TERM_COLOUR_FG_BR_BLACK,
-	WAPP_TERM_COLOUR_FG_BR_RED,
-	WAPP_TERM_COLOUR_FG_BR_GREEN,
-	WAPP_TERM_COLOUR_FG_BR_BLUE,
-	WAPP_TERM_COLOUR_FG_BR_CYAN,
-	WAPP_TERM_COLOUR_FG_BR_MAGENTA,
-	WAPP_TERM_COLOUR_FG_BR_YELLOW,
-	WAPP_TERM_COLOUR_FG_BR_WHITE,
-	WAPP_TERM_COLOUR_CLEAR,
+	WP_TERM_COLOUR_FG_BLACK,
+	WP_TERM_COLOUR_FG_RED,
+	WP_TERM_COLOUR_FG_GREEN,
+	WP_TERM_COLOUR_FG_BLUE,
+	WP_TERM_COLOUR_FG_CYAN,
+	WP_TERM_COLOUR_FG_MAGENTA,
+	WP_TERM_COLOUR_FG_YELLOW,
+	WP_TERM_COLOUR_FG_WHITE,
+	WP_TERM_COLOUR_FG_BR_BLACK,
+	WP_TERM_COLOUR_FG_BR_RED,
+	WP_TERM_COLOUR_FG_BR_GREEN,
+	WP_TERM_COLOUR_FG_BR_BLUE,
+	WP_TERM_COLOUR_FG_BR_CYAN,
+	WP_TERM_COLOUR_FG_BR_MAGENTA,
+	WP_TERM_COLOUR_FG_BR_YELLOW,
+	WP_TERM_COLOUR_FG_BR_WHITE,
+	WP_TERM_COLOUR_CLEAR,
 
 	COUNT_TERM_COLOUR,
-} TerminalColour;
+} WpTerminalColour;
 
 #ifdef WP_PLATFORM_CPP
 END_C_LINKAGE

src/os/shell/termcolour/win/termcolour_win.c

@@ -25,31 +25,31 @@ struct TermcolourData {
 wp_intern void init_data(TermcolourData *data);
 
 wp_intern WORD colours[COUNT_TERM_COLOUR] = {
-	[WAPP_TERM_COLOUR_FG_BLACK]      = 0,
-	[WAPP_TERM_COLOUR_FG_RED]        = FOREGROUND_RED,
-	[WAPP_TERM_COLOUR_FG_GREEN]      = FOREGROUND_GREEN,
-	[WAPP_TERM_COLOUR_FG_BLUE]       = FOREGROUND_BLUE,
-	[WAPP_TERM_COLOUR_FG_CYAN]       = FOREGROUND_GREEN | FOREGROUND_BLUE,
-	[WAPP_TERM_COLOUR_FG_MAGENTA]    = FOREGROUND_RED | FOREGROUND_BLUE,
-	[WAPP_TERM_COLOUR_FG_YELLOW]     = FOREGROUND_RED | FOREGROUND_GREEN,
-	[WAPP_TERM_COLOUR_FG_WHITE]      = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE,
-	[WAPP_TERM_COLOUR_FG_BR_BLACK]   = FOREGROUND_INTENSITY,
-	[WAPP_TERM_COLOUR_FG_BR_RED]     = FOREGROUND_RED | FOREGROUND_INTENSITY,
-	[WAPP_TERM_COLOUR_FG_BR_GREEN]   = FOREGROUND_GREEN | FOREGROUND_INTENSITY,
-	[WAPP_TERM_COLOUR_FG_BR_BLUE]    = FOREGROUND_BLUE | FOREGROUND_INTENSITY,
-	[WAPP_TERM_COLOUR_FG_BR_CYAN]    = FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY,
-	[WAPP_TERM_COLOUR_FG_BR_MAGENTA] = FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY,
-	[WAPP_TERM_COLOUR_FG_BR_YELLOW]  = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY,
-	[WAPP_TERM_COLOUR_FG_BR_WHITE]   = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY,
+	[WP_TERM_COLOUR_FG_BLACK]      = 0,
+	[WP_TERM_COLOUR_FG_RED]        = FOREGROUND_RED,
+	[WP_TERM_COLOUR_FG_GREEN]      = FOREGROUND_GREEN,
+	[WP_TERM_COLOUR_FG_BLUE]       = FOREGROUND_BLUE,
+	[WP_TERM_COLOUR_FG_CYAN]       = FOREGROUND_GREEN | FOREGROUND_BLUE,
+	[WP_TERM_COLOUR_FG_MAGENTA]    = FOREGROUND_RED | FOREGROUND_BLUE,
+	[WP_TERM_COLOUR_FG_YELLOW]     = FOREGROUND_RED | FOREGROUND_GREEN,
+	[WP_TERM_COLOUR_FG_WHITE]      = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE,
+	[WP_TERM_COLOUR_FG_BR_BLACK]   = FOREGROUND_INTENSITY,
+	[WP_TERM_COLOUR_FG_BR_RED]     = FOREGROUND_RED | FOREGROUND_INTENSITY,
+	[WP_TERM_COLOUR_FG_BR_GREEN]   = FOREGROUND_GREEN | FOREGROUND_INTENSITY,
+	[WP_TERM_COLOUR_FG_BR_BLUE]    = FOREGROUND_BLUE | FOREGROUND_INTENSITY,
+	[WP_TERM_COLOUR_FG_BR_CYAN]    = FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY,
+	[WP_TERM_COLOUR_FG_BR_MAGENTA] = FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY,
+	[WP_TERM_COLOUR_FG_BR_YELLOW]  = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY,
+	[WP_TERM_COLOUR_FG_BR_WHITE]   = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY,
 };
 
-void print_coloured_text(WpStr8RO *text, TerminalColour colour) {
+void _printColouredText(WpStr8RO *text, WpTerminalColour colour) {
 	wp_persist TermcolourData data = {0};
 	if (data.handle == 0) {
 		init_data(&data);
 	}
 
-	if (colour == WAPP_TERM_COLOUR_CLEAR) {
+	if (colour == WP_TERM_COLOUR_CLEAR) {
 		data.current_colour = data.default_colour;
 	} else {
 		data.current_colour = colours[colour];

src/os/shell/utils/shell_utils.h

@@ -12,11 +12,11 @@ BEGIN_C_LINKAGE
 #endif // !WP_PLATFORM_CPP
 
 #ifdef WP_PLATFORM_WINDOWS
-	#define wapp_shell_utils_popen  _popen
-	#define wapp_shell_utils_pclose _pclose
+	#define wpShellUtilsPopen  _popen
+	#define wpShellUtilsPclose _pclose
 #else
-	#define wapp_shell_utils_popen  popen
-	#define wapp_shell_utils_pclose pclose
+	#define wpShellUtilsPopen  popen
+	#define wpShellUtilsPclose pclose
 #endif /* ifdef WP_PLATFORM_WINDOWS */
 
 #ifdef WP_PLATFORM_CPP

src/testing/tester/tester.c

@@ -33,20 +33,20 @@ void _runTests(WpTestFunc *func1, ...) {
 }
 
 wp_intern void handleTestResult(WpTestFuncResult result) {
-	TerminalColour colour;
+	WpTerminalColour colour;
 	WpStr8 result_text = wpStr8Buf(64);
 
 	if (result.passed) {
-		colour = WAPP_TERM_COLOUR_FG_BR_GREEN;
+		colour = WP_TERM_COLOUR_FG_BR_GREEN;
 		wpStr8CopyCstrCapped(&result_text, "PASSED");
 	} else {
-		colour = WAPP_TERM_COLOUR_FG_BR_RED;
+		colour = WP_TERM_COLOUR_FG_BR_RED;
 		wpStr8CopyCstrCapped(&result_text, "FAILED");
 	}
 
 	printf("[");
-	wapp_shell_termcolour_print_text(&result_text, colour);
-	wapp_shell_termcolour_clear_colour();
+	wpShellTermcolourPrintText(&result_text, colour);
+	wpShellTermcolourClearColour();
 	printf("] " WP_STR8_SPEC "\n", wpStr8Varg(result.name));
 
 	if (!result.passed) {

tests/allocator/test_allocator.c

@@ -10,7 +10,7 @@ wp_intern u8 temp_buf[TEMP_BUF_SIZE] = {0};
 wp_intern WpAllocator temp_allocator   = {0};
 
 WpTestFuncResult test_arena_allocator(void) {
-	WpAllocator allocator = wapp_mem_arena_allocator_init(4096);
+	WpAllocator allocator = wpMemArenaAllocatorInit(4096);
 	b8 result           = allocator.obj != NULL && allocator.alloc != NULL &&
 	                      allocator.alloc_aligned != NULL &&
 	                      allocator.realloc != NULL && allocator.realloc_aligned != NULL &&
@@ -18,7 +18,7 @@ WpTestFuncResult test_arena_allocator(void) {
 	void *ptr           = wpMemAllocatorAlloc(&allocator, 20);
 	result              = result && (ptr != NULL);
 
-	wapp_mem_arena_allocator_destroy(&allocator);
+	wpMemArenaAllocatorDestroy(&allocator);
 
 	return wpTesterResult(result);
 }
@@ -26,7 +26,7 @@ WpTestFuncResult test_arena_allocator(void) {
 WpTestFuncResult test_arena_allocator_with_buffer(void) {
 	u8 buffer[KiB(4)] = {0};
 
-	WpAllocator allocator = wapp_mem_arena_allocator_init_with_buffer(buffer, KiB(4));
+	WpAllocator allocator = wpMemArenaAllocatorInitWithBuffer(buffer, KiB(4));
 	b8 result           = allocator.obj != NULL && allocator.alloc != NULL &&
 	                      allocator.alloc_aligned != NULL &&
 	                      allocator.realloc != NULL && allocator.realloc_aligned != NULL &&
@@ -34,18 +34,18 @@ WpTestFuncResult test_arena_allocator_with_buffer(void) {
 	void *ptr           = wpMemAllocatorAlloc(&allocator, 20);
 	result              = result && (ptr != NULL);
 
-	wapp_mem_arena_allocator_destroy(&allocator);
+	wpMemArenaAllocatorDestroy(&allocator);
 
 	return wpTesterResult(result);
 }
 
 WpTestFuncResult test_arena_allocator_temp_begin(void) {
-	temp_allocator = wapp_mem_arena_allocator_init_with_buffer(temp_buf, TEMP_BUF_SIZE);
+	temp_allocator = wpMemArenaAllocatorInitWithBuffer(temp_buf, TEMP_BUF_SIZE);
 
 	i32 *num1 = (i32 *)wpMemAllocatorAlloc(&temp_allocator, sizeof(i32));
 	b8 result = num1 != NULL;
 
-	wapp_mem_arena_allocator_temp_begin(&temp_allocator);
+	wpMemArenaAllocatorTempBegin(&temp_allocator);
 	i32 *num2 = (i32 *)wpMemAllocatorAlloc(&temp_allocator, sizeof(i32));
 	result    = result && num2 != NULL;
 	i32 *num3 = (i32 *)wpMemAllocatorAlloc(&temp_allocator, sizeof(i32));
@@ -55,13 +55,13 @@ WpTestFuncResult test_arena_allocator_temp_begin(void) {
 }
 
 WpTestFuncResult test_arena_allocator_temp_end(void) {
-	wapp_mem_arena_allocator_temp_end(&temp_allocator);
+	wpMemArenaAllocatorTempEnd(&temp_allocator);
 	i32 *num1 = (i32 *)wpMemAllocatorAlloc(&temp_allocator, sizeof(i32));
 	b8 result = num1 != NULL;
 	i32 *num2 = (i32 *)wpMemAllocatorAlloc(&temp_allocator, sizeof(i32));
 	result    = result && num2 == NULL;
 
-	wapp_mem_arena_allocator_destroy(&temp_allocator);
+	wpMemArenaAllocatorDestroy(&temp_allocator);
 
 	return wpTesterResult(result);
 }

tests/allocator/test_allocator.cc

@@ -10,7 +10,7 @@ wp_intern u8 temp_buf[TEMP_BUF_SIZE] = {};
 wp_intern WpAllocator temp_allocator   = {};
 
 WpTestFuncResult test_arena_allocator(void) {
-	WpAllocator allocator = wapp_mem_arena_allocator_init(4096);
+	WpAllocator allocator = wpMemArenaAllocatorInit(4096);
 	b8 result           = allocator.obj != nullptr && allocator.alloc != nullptr &&
 	                      allocator.alloc_aligned != nullptr &&
 	                      allocator.realloc != nullptr && allocator.realloc_aligned != nullptr &&
@@ -18,7 +18,7 @@ WpTestFuncResult test_arena_allocator(void) {
 	void *ptr           = wpMemAllocatorAlloc(&allocator, 20);
 	result              = result && (ptr != nullptr);
 
-	wapp_mem_arena_allocator_destroy(&allocator);
+	wpMemArenaAllocatorDestroy(&allocator);
 
 	return wpTesterResult(result);
 }
@@ -26,7 +26,7 @@ WpTestFuncResult test_arena_allocator(void) {
 WpTestFuncResult test_arena_allocator_with_buffer(void) {
 	u8 buffer[KiB(4)] = {0};
 
-	WpAllocator allocator = wapp_mem_arena_allocator_init_with_buffer(buffer, KiB(4));
+	WpAllocator allocator = wpMemArenaAllocatorInitWithBuffer(buffer, KiB(4));
 	b8 result           = allocator.obj != NULL && allocator.alloc != NULL &&
 	                      allocator.alloc_aligned != NULL &&
 	                      allocator.realloc != NULL && allocator.realloc_aligned != NULL &&
@@ -34,18 +34,18 @@ WpTestFuncResult test_arena_allocator_with_buffer(void) {
 	void *ptr           = wpMemAllocatorAlloc(&allocator, 20);
 	result              = result && (ptr != NULL);
 
-	wapp_mem_arena_allocator_destroy(&allocator);
+	wpMemArenaAllocatorDestroy(&allocator);
 
 	return wpTesterResult(result);
 }
 
 WpTestFuncResult test_arena_allocator_temp_begin(void) {
-	temp_allocator = wapp_mem_arena_allocator_init_with_buffer(temp_buf, TEMP_BUF_SIZE);
+	temp_allocator = wpMemArenaAllocatorInitWithBuffer(temp_buf, TEMP_BUF_SIZE);
 
 	i32 *num1 = (i32 *)wpMemAllocatorAlloc(&temp_allocator, sizeof(i32));
 	b8 result = num1 != NULL;
 
-	wapp_mem_arena_allocator_temp_begin(&temp_allocator);
+	wpMemArenaAllocatorTempBegin(&temp_allocator);
 	i32 *num2 = (i32 *)wpMemAllocatorAlloc(&temp_allocator, sizeof(i32));
 	result    = result && num2 != NULL;
 	i32 *num3 = (i32 *)wpMemAllocatorAlloc(&temp_allocator, sizeof(i32));
@@ -55,13 +55,13 @@ WpTestFuncResult test_arena_allocator_temp_begin(void) {
 }
 
 WpTestFuncResult test_arena_allocator_temp_end(void) {
-	wapp_mem_arena_allocator_temp_end(&temp_allocator);
+	wpMemArenaAllocatorTempEnd(&temp_allocator);
 	i32 *num1 = (i32 *)wpMemAllocatorAlloc(&temp_allocator, sizeof(i32));
 	b8 result = num1 != NULL;
 	i32 *num2 = (i32 *)wpMemAllocatorAlloc(&temp_allocator, sizeof(i32));
 	result    = result && num2 == NULL;
 
-	wapp_mem_arena_allocator_destroy(&temp_allocator);
+	wpMemArenaAllocatorDestroy(&temp_allocator);
 
 	return wpTesterResult(result);
 }

tests/arena/test_arena.c

@@ -4,42 +4,42 @@
 
 #define ARENA_CAPACITY KiB(16)
 #define ARENA_BUF_SIZE KiB(4)
-// NOTE (Abdelrahman): Cannot query size of Arena here so it's hardcoded. Similarly, since arena
+// NOTE (Abdelrahman): Cannot query size of WpArena here so it's hardcoded. Similarly, since arena
 // allocation are aligned to power of 2 boundaries, the number of i32 values needed is hardcoded.
 #define TEMP_BUF_SIZE (40 + sizeof(i32) * 8)
 
-wp_intern Arena *arena               = NULL;
+wp_intern WpArena *arena               = NULL;
 wp_intern i32 count                  = 20;
 wp_intern i32 *array                 = NULL;
-wp_intern Arena *buf_arena           = NULL;
+wp_intern WpArena *buf_arena           = NULL;
 wp_intern u8 buf[ARENA_BUF_SIZE]     = {0};
-wp_intern Arena *temp_arena          = NULL;
+wp_intern WpArena *temp_arena          = NULL;
 wp_intern u8 temp_buf[TEMP_BUF_SIZE] = {0};
 
 WpTestFuncResult test_arena_init_buffer(void) {
-	b8 result = wapp_mem_arena_init_buffer(&buf_arena, buf, ARENA_BUF_SIZE);
+	b8 result = wpMemArenaInitBuffer(&buf_arena, buf, ARENA_BUF_SIZE);
 	return wpTesterResult(result);
 }
 
 WpTestFuncResult test_arena_init_allocated(void) {
-	b8 result = wapp_mem_arena_init_allocated(&arena, ARENA_CAPACITY);
+	b8 result = wpMemArenaInitAllocated(&arena, ARENA_CAPACITY);
 
 	return wpTesterResult(result);
 }
 
 WpTestFuncResult test_arena_init_succeeds_when_reserving_very_large_size(void) {
-	Arena *large_arena = NULL;
+	WpArena *large_arena = NULL;
 	u64 capacity       = GiB(512);
-	b8 result          = wapp_mem_arena_init_allocated(&large_arena, capacity);
+	b8 result          = wpMemArenaInitAllocated(&large_arena, capacity);
 	if (result) {
-		wapp_mem_arena_destroy(&large_arena);
+		wpMemArenaDestroy(&large_arena);
 	}
 
 	return wpTesterResult(result);
 }
 
 WpTestFuncResult test_arena_alloc_with_buffer(void) {
-	i32 *arr  = (i32 *)wapp_mem_arena_alloc(arena, count * sizeof(i32));
+	i32 *arr  = (i32 *)wpMemArenaAlloc(arena, count * sizeof(i32));
 	b8 result = arr != NULL;
 
 	for (i32 i = 0; i < count; ++i) {
@@ -50,7 +50,7 @@ WpTestFuncResult test_arena_alloc_with_buffer(void) {
 }
 
 WpTestFuncResult test_arena_alloc_succeeds_when_within_capacity(void) {
-	array     = wapp_mem_arena_alloc(arena, count * sizeof(i32));
+	array     = wpMemArenaAlloc(arena, count * sizeof(i32));
 	b8 result = array != NULL;
 
 	for (i32 i = 0; i < count; ++i) {
@@ -61,7 +61,7 @@ WpTestFuncResult test_arena_alloc_succeeds_when_within_capacity(void) {
 }
 
 WpTestFuncResult test_arena_alloc_fails_when_over_capacity(void) {
-	u8 *bytes = wapp_mem_arena_alloc(arena, ARENA_CAPACITY * 2);
+	u8 *bytes = wpMemArenaAlloc(arena, ARENA_CAPACITY * 2);
 	b8 result = bytes == NULL;
 
 	return wpTesterResult(result);
@@ -70,13 +70,13 @@ WpTestFuncResult test_arena_alloc_fails_when_over_capacity(void) {
 WpTestFuncResult test_arena_realloc_bigger_size(void) {
 	u64 old_count = 10;
 	u64 new_count = 20;
-	i32 *bytes    = wapp_mem_arena_alloc(arena, old_count * sizeof(i32));
+	i32 *bytes    = wpMemArenaAlloc(arena, old_count * sizeof(i32));
 
 	for (u64 i = 0; i < old_count; ++i) {
 		bytes[i] = (i32)i;
 	}
 
-	i32 *new_bytes = wapp_mem_arena_realloc(arena, bytes, old_count * sizeof(i32), new_count * sizeof(i32));
+	i32 *new_bytes = wpMemArenaRealloc(arena, bytes, old_count * sizeof(i32), new_count * sizeof(i32));
 	if (!new_bytes) {
 		return wpTesterResult(false);
 	}
@@ -93,13 +93,13 @@ WpTestFuncResult test_arena_realloc_bigger_size(void) {
 WpTestFuncResult test_arena_realloc_smaller_size(void) {
 	u64 old_count = 10;
 	u64 new_count = 5;
-	i32 *bytes    = wapp_mem_arena_alloc(arena, old_count * sizeof(i32));
+	i32 *bytes    = wpMemArenaAlloc(arena, old_count * sizeof(i32));
 
 	for (u64 i = 0; i < old_count; ++i) {
 		bytes[i] = (i32)i;
 	}
 
-	i32 *new_bytes = wapp_mem_arena_realloc(arena, bytes, old_count * sizeof(i32), new_count * sizeof(i32));
+	i32 *new_bytes = wpMemArenaRealloc(arena, bytes, old_count * sizeof(i32), new_count * sizeof(i32));
 	if (!new_bytes) {
 		return wpTesterResult(false);
 	}
@@ -114,33 +114,33 @@ WpTestFuncResult test_arena_realloc_smaller_size(void) {
 }
 
 WpTestFuncResult test_arena_temp_begin(void) {
-	b8 result = wapp_mem_arena_init_buffer(&temp_arena, temp_buf, TEMP_BUF_SIZE);
-	i32 *num1 = (i32 *)wapp_mem_arena_alloc(temp_arena, sizeof(i32));
+	b8 result = wpMemArenaInitBuffer(&temp_arena, temp_buf, TEMP_BUF_SIZE);
+	i32 *num1 = (i32 *)wpMemArenaAlloc(temp_arena, sizeof(i32));
 	result    = result && num1 != NULL;
 
-	wapp_mem_arena_temp_begin(temp_arena);
-	i32 *num2 = (i32 *)wapp_mem_arena_alloc(temp_arena, sizeof(i32));
+	wpMemArenaTempBegin(temp_arena);
+	i32 *num2 = (i32 *)wpMemArenaAlloc(temp_arena, sizeof(i32));
 	result    = result && num2 != NULL;
-	i32 *num3 = (i32 *)wapp_mem_arena_alloc(temp_arena, sizeof(i32));
+	i32 *num3 = (i32 *)wpMemArenaAlloc(temp_arena, sizeof(i32));
 	result    = result && num3 == NULL;
 
 	return wpTesterResult(result);
 }
 
 WpTestFuncResult test_arena_temp_end(void) {
-	wapp_mem_arena_temp_end(temp_arena);
-	i32 *num1 = (i32 *)wapp_mem_arena_alloc(temp_arena, sizeof(i32));
+	wpMemArenaTempEnd(temp_arena);
+	i32 *num1 = (i32 *)wpMemArenaAlloc(temp_arena, sizeof(i32));
 	b8 result = num1 != NULL;
-	i32 *num2 = (i32 *)wapp_mem_arena_alloc(temp_arena, sizeof(i32));
+	i32 *num2 = (i32 *)wpMemArenaAlloc(temp_arena, sizeof(i32));
 	result    = result && num2 == NULL;
 
-	wapp_mem_arena_destroy(&temp_arena);
+	wpMemArenaDestroy(&temp_arena);
 
 	return wpTesterResult(result);
 }
 
 WpTestFuncResult test_arena_clear(void) {
-	wapp_mem_arena_clear(arena);
+	wpMemArenaClear(arena);
 	b8 result = true;
 
 	for (i32 i = 0; i < count; ++i) {
@@ -154,14 +154,14 @@ WpTestFuncResult test_arena_clear(void) {
 }
 
 WpTestFuncResult test_arena_destroy_buffer(void) {
-	wapp_mem_arena_destroy(&buf_arena);
+	wpMemArenaDestroy(&buf_arena);
 	b8 result = buf_arena == NULL;
 
 	return wpTesterResult(result);
 }
 
 WpTestFuncResult test_arena_destroy_allocated(void) {
-	wapp_mem_arena_destroy(&arena);
+	wpMemArenaDestroy(&arena);
 	b8 result = arena == NULL;
 
 	return wpTesterResult(result);

tests/arena/test_arena.cc

@@ -4,42 +4,42 @@
 
 #define ARENA_CAPACITY KiB(16)
 #define ARENA_BUF_SIZE KiB(4)
-// NOTE (Abdelrahman): Cannot query size of Arena here so it's hardcoded. Similarly, since arena
+// NOTE (Abdelrahman): Cannot query size of WpArena here so it's hardcoded. Similarly, since arena
 // allocation are aligned to power of 2 boundaries, the number of i32 values needed is hardcoded.
 #define TEMP_BUF_SIZE (40 + sizeof(i32) * 8)
 
-wp_intern Arena *arena               = NULL;
+wp_intern WpArena *arena               = NULL;
 wp_intern i32 count                  = 20;
 wp_intern i32 *array                 = NULL;
-wp_intern Arena *buf_arena           = NULL;
+wp_intern WpArena *buf_arena           = NULL;
 wp_intern u8 buf[ARENA_BUF_SIZE]     = {};
-wp_intern Arena *temp_arena          = NULL;
+wp_intern WpArena *temp_arena          = NULL;
 wp_intern u8 temp_buf[TEMP_BUF_SIZE] = {};
 
 WpTestFuncResult test_arena_init_buffer(void) {
-	b8 result = wapp_mem_arena_init_buffer(&buf_arena, buf, ARENA_BUF_SIZE);
+	b8 result = wpMemArenaInitBuffer(&buf_arena, buf, ARENA_BUF_SIZE);
 	return wpTesterResult(result);
 }
 
 WpTestFuncResult test_arena_init_allocated(void) {
-	b8 result = wapp_mem_arena_init_allocated(&arena, ARENA_CAPACITY);
+	b8 result = wpMemArenaInitAllocated(&arena, ARENA_CAPACITY);
 
 	return wpTesterResult(result);
 }
 
 WpTestFuncResult test_arena_init_succeeds_when_reserving_very_large_size(void) {
-	Arena *large_arena = nullptr;
+	WpArena *large_arena = nullptr;
 	u64 capacity       = GiB(512);
-	b8 result          = wapp_mem_arena_init_allocated(&large_arena, capacity);
+	b8 result          = wpMemArenaInitAllocated(&large_arena, capacity);
 	if (result) {
-		wapp_mem_arena_destroy(&large_arena);
+		wpMemArenaDestroy(&large_arena);
 	}
 
 	return wpTesterResult(result);
 }
 
 WpTestFuncResult test_arena_alloc_with_buffer(void) {
-	i32 *arr  = (i32 *)wapp_mem_arena_alloc(arena, count * sizeof(i32));
+	i32 *arr  = (i32 *)wpMemArenaAlloc(arena, count * sizeof(i32));
 	b8 result = arr != NULL;
 
 	for (i32 i = 0; i < count; ++i) {
@@ -50,7 +50,7 @@ WpTestFuncResult test_arena_alloc_with_buffer(void) {
 }
 
 WpTestFuncResult test_arena_alloc_succeeds_when_within_capacity(void) {
-	array     = (i32 *)wapp_mem_arena_alloc(arena, count * sizeof(i32));
+	array     = (i32 *)wpMemArenaAlloc(arena, count * sizeof(i32));
 	b8 result = array != nullptr;
 
 	for (i32 i = 0; i < count; ++i) {
@@ -61,7 +61,7 @@ WpTestFuncResult test_arena_alloc_succeeds_when_within_capacity(void) {
 }
 
 WpTestFuncResult test_arena_alloc_fails_when_over_capacity(void) {
-	u8 *bytes = (u8 *)wapp_mem_arena_alloc(arena, ARENA_CAPACITY * 2);
+	u8 *bytes = (u8 *)wpMemArenaAlloc(arena, ARENA_CAPACITY * 2);
 	b8 result = bytes == nullptr;
 
 	return wpTesterResult(result);
@@ -70,13 +70,13 @@ WpTestFuncResult test_arena_alloc_fails_when_over_capacity(void) {
 WpTestFuncResult test_arena_realloc_bigger_size(void) {
 	u64 old_count = 10;
 	u64 new_count = 20;
-	i32 *bytes    = (i32 *)wapp_mem_arena_alloc(arena, old_count * sizeof(i32));
+	i32 *bytes    = (i32 *)wpMemArenaAlloc(arena, old_count * sizeof(i32));
 
 	for (u64 i = 0; i < old_count; ++i) {
 		bytes[i] = (i32)i;
 	}
 
-	i32 *new_bytes = (i32 *)wapp_mem_arena_realloc(arena, bytes, old_count * sizeof(i32), new_count * sizeof(i32));
+	i32 *new_bytes = (i32 *)wpMemArenaRealloc(arena, bytes, old_count * sizeof(i32), new_count * sizeof(i32));
 	if (!new_bytes) {
 		return wpTesterResult(false);
 	}
@@ -93,13 +93,13 @@ WpTestFuncResult test_arena_realloc_bigger_size(void) {
 WpTestFuncResult test_arena_realloc_smaller_size(void) {
 	u64 old_count = 10;
 	u64 new_count = 5;
-	i32 *bytes    = (i32 *)wapp_mem_arena_alloc(arena, old_count * sizeof(i32));
+	i32 *bytes    = (i32 *)wpMemArenaAlloc(arena, old_count * sizeof(i32));
 
 	for (u64 i = 0; i < old_count; ++i) {
 		bytes[i] = (i32)i;
 	}
 
-	i32 *new_bytes = (i32 *)wapp_mem_arena_realloc(arena, bytes, old_count * sizeof(i32), new_count * sizeof(i32));
+	i32 *new_bytes = (i32 *)wpMemArenaRealloc(arena, bytes, old_count * sizeof(i32), new_count * sizeof(i32));
 	if (!new_bytes) {
 		return wpTesterResult(false);
 	}
@@ -114,33 +114,33 @@ WpTestFuncResult test_arena_realloc_smaller_size(void) {
 }
 
 WpTestFuncResult test_arena_temp_begin(void) {
-	b8 result = wapp_mem_arena_init_buffer(&temp_arena, temp_buf, TEMP_BUF_SIZE);
-	i32 *num1 = (i32 *)wapp_mem_arena_alloc(temp_arena, sizeof(i32));
+	b8 result = wpMemArenaInitBuffer(&temp_arena, temp_buf, TEMP_BUF_SIZE);
+	i32 *num1 = (i32 *)wpMemArenaAlloc(temp_arena, sizeof(i32));
 	result    = result && num1 != NULL;
 
-	wapp_mem_arena_temp_begin(temp_arena);
-	i32 *num2 = (i32 *)wapp_mem_arena_alloc(temp_arena, sizeof(i32));
+	wpMemArenaTempBegin(temp_arena);
+	i32 *num2 = (i32 *)wpMemArenaAlloc(temp_arena, sizeof(i32));
 	result    = result && num2 != NULL;
-	i32 *num3 = (i32 *)wapp_mem_arena_alloc(temp_arena, sizeof(i32));
+	i32 *num3 = (i32 *)wpMemArenaAlloc(temp_arena, sizeof(i32));
 	result    = result && num3 == NULL;
 
 	return wpTesterResult(result);
 }
 
 WpTestFuncResult test_arena_temp_end(void) {
-	wapp_mem_arena_temp_end(temp_arena);
-	i32 *num1 = (i32 *)wapp_mem_arena_alloc(temp_arena, sizeof(i32));
+	wpMemArenaTempEnd(temp_arena);
+	i32 *num1 = (i32 *)wpMemArenaAlloc(temp_arena, sizeof(i32));
 	b8 result = num1 != NULL;
-	i32 *num2 = (i32 *)wapp_mem_arena_alloc(temp_arena, sizeof(i32));
+	i32 *num2 = (i32 *)wpMemArenaAlloc(temp_arena, sizeof(i32));
 	result    = result && num2 == NULL;
 
-	wapp_mem_arena_destroy(&temp_arena);
+	wpMemArenaDestroy(&temp_arena);
 
 	return wpTesterResult(result);
 }
 
 WpTestFuncResult test_arena_clear(void) {
-	wapp_mem_arena_clear(arena);
+	wpMemArenaClear(arena);
 	b8 result = true;
 
 	for (i32 i = 0; i < count; ++i) {
@@ -154,14 +154,14 @@ WpTestFuncResult test_arena_clear(void) {
 }
 
 WpTestFuncResult test_arena_destroy_buffer(void) {
-	wapp_mem_arena_destroy(&buf_arena);
+	wpMemArenaDestroy(&buf_arena);
 	b8 result = buf_arena == NULL;
 
 	return wpTesterResult(result);
 }
 
 WpTestFuncResult test_arena_destroy_allocated(void) {
-	wapp_mem_arena_destroy(&arena);
+	wpMemArenaDestroy(&arena);
 	b8 result = arena == nullptr;
 
 	return wpTesterResult(result);

tests/cpath/test_cpath.c

@@ -13,75 +13,75 @@ WpTestFuncResult test_cpath_join_path(void) {
 	WpStr8 out      = wpStr8Buf(MAIN_BUF_SIZE);
 	WpStr8 tmp      = wpStr8Buf(TMP_BUF_SIZE);
 
-	wpStr8Format(&expected, "%chome%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP);
-	wpStr8Format(&tmp, "%c", WAPP_PATH_SEP);
+	wpStr8Format(&expected, "%chome%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP, WP_PATH_SEP);
+	wpStr8Format(&tmp, "%c", WP_PATH_SEP);
 
-	WpStr8List parts = wapp_dbl_list(WpStr8);
-	wapp_dbl_list_push_back(WpStr8, &parts, &tmp);
-	wapp_dbl_list_push_back(WpStr8, &parts, &wpStr8Lit("home"));
-	wapp_dbl_list_push_back(WpStr8, &parts, &wpStr8Lit("abdelrahman"));
-	wapp_dbl_list_push_back(WpStr8, &parts, &wpStr8Lit("Documents"));
+	WpStr8List parts = wpDblList(WpStr8);
+	wpDblListPushBack(WpStr8, &parts, &tmp);
+	wpDblListPushBack(WpStr8, &parts, &wpStr8Lit("home"));
+	wpDblListPushBack(WpStr8, &parts, &wpStr8Lit("abdelrahman"));
+	wpDblListPushBack(WpStr8, &parts, &wpStr8Lit("Documents"));
 
-	wapp_cpath_join_path(&out, &parts);
+	wpCpathJoinPath(&out, &parts);
 	result = wpStr8Equal(&out, &expected);
 
-	wapp_dbl_list_pop_front(WpStr8, &parts);
+	wpDblListPopFront(WpStr8, &parts);
 
-	wpStr8Format(&expected, "home%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP);
+	wpStr8Format(&expected, "home%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP);
 
-	wapp_cpath_join_path(&out, &parts);
+	wpCpathJoinPath(&out, &parts);
 	result = result && wpStr8Equal(&out, &expected);
 
 	wpStr8ConcatCapped(&tmp, &wpStr8LitRo("home"));
-	wapp_dbl_list_pop_front(WpStr8, &parts);
-	wapp_dbl_list_push_front(WpStr8, &parts, &tmp);
+	wpDblListPopFront(WpStr8, &parts);
+	wpDblListPushFront(WpStr8, &parts, &tmp);
 
-	wpStr8Format(&expected, "%chome%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP);
+	wpStr8Format(&expected, "%chome%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP, WP_PATH_SEP);
 
-	wapp_cpath_join_path(&out, &parts);
+	wpCpathJoinPath(&out, &parts);
 	result = result && wpStr8Equal(&out, &expected);
 
-	wpStr8Format(&tmp, "home%c", WAPP_PATH_SEP);
-	wapp_dbl_list_pop_front(WpStr8, &parts);
-	wapp_dbl_list_push_front(WpStr8, &parts, &wpStr8Lit("home"));
+	wpStr8Format(&tmp, "home%c", WP_PATH_SEP);
+	wpDblListPopFront(WpStr8, &parts);
+	wpDblListPushFront(WpStr8, &parts, &wpStr8Lit("home"));
 
-	wpStr8Format(&expected, "home%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP);
+	wpStr8Format(&expected, "home%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP);
 
-	wapp_cpath_join_path(&out, &parts);
+	wpCpathJoinPath(&out, &parts);
 	result = result && wpStr8Equal(&out, &expected);
 
-	wapp_dbl_list_empty(WpStr8, &parts);
+	wpDblListEmpty(WpStr8, &parts);
 
-	wpStr8Format(&tmp, "%chome", WAPP_PATH_SEP);
-	wapp_dbl_list_push_back(WpStr8, &parts, &tmp);
-	wapp_dbl_list_push_back(WpStr8, &parts, &wpStr8Lit(""));
+	wpStr8Format(&tmp, "%chome", WP_PATH_SEP);
+	wpDblListPushBack(WpStr8, &parts, &tmp);
+	wpDblListPushBack(WpStr8, &parts, &wpStr8Lit(""));
 
-	wpStr8Format(&expected, "%chome", WAPP_PATH_SEP);
+	wpStr8Format(&expected, "%chome", WP_PATH_SEP);
 
-	wapp_cpath_join_path(&out, &parts);
+	wpCpathJoinPath(&out, &parts);
 	result = result && wpStr8Equal(&out, &expected);
 
-	wapp_dbl_list_pop_front(WpStr8, &parts);
-	wapp_dbl_list_push_back(WpStr8, &parts, &wpStr8Lit(""));
+	wpDblListPopFront(WpStr8, &parts);
+	wpDblListPushBack(WpStr8, &parts, &wpStr8Lit(""));
 
 	wpStr8Format(&expected, "%s", "");
 
-	wapp_cpath_join_path(&out, &parts);
+	wpCpathJoinPath(&out, &parts);
 	result = result && wpStr8Equal(&out, &expected);
 
-	wapp_dbl_list_pop_back(WpStr8, &parts);
-	wapp_dbl_list_push_back(WpStr8, &parts, &wpStr8Lit("home"));
+	wpDblListPopBack(WpStr8, &parts);
+	wpDblListPushBack(WpStr8, &parts, &wpStr8Lit("home"));
 
 	wpStr8CopyCstrCapped(&expected, "home");
 
-	wapp_cpath_join_path(&out, &parts);
+	wpCpathJoinPath(&out, &parts);
 	result = result && wpStr8Equal(&out, &expected);
 
 	return wpTesterResult(result);
 }
 
 WpTestFuncResult test_cpath_dirname(void) {
-	WpAllocator arena = wapp_mem_arena_allocator_init(MiB(8));
+	WpAllocator arena = wpMemArenaAllocatorInit(MiB(8));
 	if (wpMemAllocatorInvalid(&arena)) {
 		return wpTesterResult(false);
 	}
@@ -93,43 +93,43 @@ WpTestFuncResult test_cpath_dirname(void) {
 	WpStr8 tmp      = wpStr8Buf(TMP_BUF_SIZE);
 
 	// CASE 1
-	wpStr8Format(&tmp, "%c", WAPP_PATH_SEP);
-	wpStr8Format(&expected, "%c", WAPP_PATH_SEP);
+	wpStr8Format(&tmp, "%c", WP_PATH_SEP);
+	wpStr8Format(&expected, "%c", WP_PATH_SEP);
 
-	output = wapp_cpath_dirname(&arena, &tmp);
+	output = wpCpathDirname(&arena, &tmp);
 	result = output != NULL && wpStr8Equal(output, &expected);
 
 	// CASE 2
 	wpStr8Format(&expected, "%s", ".");
 
-	output = wapp_cpath_dirname(&arena, &wpStr8Lit("home"));
+	output = wpCpathDirname(&arena, &wpStr8Lit("home"));
 	result = result && output != NULL && wpStr8Equal(output, &expected);
 
 	// CASE 3
-	output = wapp_cpath_dirname(&arena, &wpStr8Lit(""));
+	output = wpCpathDirname(&arena, &wpStr8Lit(""));
 	result = result && output != NULL && wpStr8Equal(output, &expected);
 
 	// CASE 4
-	wpStr8Format(&tmp, "%chome%ctest", WAPP_PATH_SEP, WAPP_PATH_SEP);
-	wpStr8Format(&expected, "%chome", WAPP_PATH_SEP);
+	wpStr8Format(&tmp, "%chome%ctest", WP_PATH_SEP, WP_PATH_SEP);
+	wpStr8Format(&expected, "%chome", WP_PATH_SEP);
 
-	output = wapp_cpath_dirname(&arena, &tmp);
+	output = wpCpathDirname(&arena, &tmp);
 	result = result && output != NULL && wpStr8Equal(output, &expected);
 
 	// CASE 5
-	wpStr8Format(&tmp, "%chome%ctest%c", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP);
-	wpStr8Format(&expected, "%chome", WAPP_PATH_SEP);
+	wpStr8Format(&tmp, "%chome%ctest%c", WP_PATH_SEP, WP_PATH_SEP, WP_PATH_SEP);
+	wpStr8Format(&expected, "%chome", WP_PATH_SEP);
 
-	output = wapp_cpath_dirname(&arena, &tmp);
+	output = wpCpathDirname(&arena, &tmp);
 	result = result && output != NULL && wpStr8Equal(output, &expected);
 
-	wapp_mem_arena_allocator_destroy(&arena);
+	wpMemArenaAllocatorDestroy(&arena);
 
 	return wpTesterResult(result);
 }
 
 WpTestFuncResult test_cpath_dirup(void) {
-	WpAllocator arena = wapp_mem_arena_allocator_init(MiB(8));
+	WpAllocator arena = wpMemArenaAllocatorInit(MiB(8));
 	if (wpMemAllocatorInvalid(&arena)) {
 		return wpTesterResult(false);
 	}
@@ -141,41 +141,41 @@ WpTestFuncResult test_cpath_dirup(void) {
 	WpStr8 tmp      = wpStr8Buf(TMP_BUF_SIZE);
 
 	// CASE 1
-	wpStr8Format(&tmp, "%c", WAPP_PATH_SEP);
-	wpStr8Format(&expected, "%c", WAPP_PATH_SEP);
+	wpStr8Format(&tmp, "%c", WP_PATH_SEP);
+	wpStr8Format(&expected, "%c", WP_PATH_SEP);
 
-	output = wapp_cpath_dirup(&arena, &tmp, 3);
+	output = wpCpathDirup(&arena, &tmp, 3);
 	result = output != NULL && wpStr8Equal(output, &expected);
 
 	// CASE 2
-	wpStr8Format(&tmp, "%chome%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP);
-	wpStr8Format(&expected, "%c", WAPP_PATH_SEP);
+	wpStr8Format(&tmp, "%chome%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP, WP_PATH_SEP);
+	wpStr8Format(&expected, "%c", WP_PATH_SEP);
 
-	output = wapp_cpath_dirup(&arena, &tmp, 3);
+	output = wpCpathDirup(&arena, &tmp, 3);
 	result = result && output != NULL && wpStr8Equal(output, &expected);
 
 	// CASE 3
-	wpStr8Format(&tmp, "home%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP);
+	wpStr8Format(&tmp, "home%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP);
 	wpStr8CopyCstrCapped(&expected, ".");
 
-	output = wapp_cpath_dirup(&arena, &tmp, 3);
+	output = wpCpathDirup(&arena, &tmp, 3);
 	result = result && output != NULL && wpStr8Equal(output, &expected);
 
 	// CASE 4
-	wpStr8Format(&tmp, "%chome%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP);
-	wpStr8Format(&expected, "%chome", WAPP_PATH_SEP);
+	wpStr8Format(&tmp, "%chome%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP, WP_PATH_SEP);
+	wpStr8Format(&expected, "%chome", WP_PATH_SEP);
 
-	output = wapp_cpath_dirup(&arena, &tmp, 2);
+	output = wpCpathDirup(&arena, &tmp, 2);
 	result = result && output != NULL && wpStr8Equal(output, &expected);
 
 	// CASE 5
-	wpStr8Format(&tmp, "home%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP);
+	wpStr8Format(&tmp, "home%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP);
 	wpStr8CopyCstrCapped(&expected, "home");
 
-	output = wapp_cpath_dirup(&arena, &tmp, 2);
+	output = wpCpathDirup(&arena, &tmp, 2);
 	result = result && output != NULL && wpStr8Equal(output, &expected);
 
-	wapp_mem_arena_allocator_destroy(&arena);
+	wpMemArenaAllocatorDestroy(&arena);
 
 	return wpTesterResult(result);
 }

tests/cpath/test_cpath.cc

@@ -13,93 +13,93 @@ WpTestFuncResult test_cpath_join_path(void) {
 	WpStr8 out      = wpStr8Buf(MAIN_BUF_SIZE);
 	WpStr8 tmp      = wpStr8Buf(TMP_BUF_SIZE);
 
-	wpStr8Format(&expected, "%chome%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP);
-	wpStr8Format(&tmp, "%c", WAPP_PATH_SEP);
+	wpStr8Format(&expected, "%chome%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP, WP_PATH_SEP);
+	wpStr8Format(&tmp, "%c", WP_PATH_SEP);
 
-	WpStr8List parts = wapp_dbl_list(WpStr8);
+	WpStr8List parts = wpDblList(WpStr8);
 
-	wapp_dbl_list_push_back(WpStr8, &parts, &tmp);
+	wpDblListPushBack(WpStr8, &parts, &tmp);
 
 	WpStr8 home = wpStr8Lit("home");
-	wapp_dbl_list_push_back(WpStr8, &parts, &home);
+	wpDblListPushBack(WpStr8, &parts, &home);
 
 	WpStr8 user = wpStr8Lit("abdelrahman");
-	wapp_dbl_list_push_back(WpStr8, &parts, &user);
+	wpDblListPushBack(WpStr8, &parts, &user);
 
 	WpStr8 docs = wpStr8Lit("Documents");
-	wapp_dbl_list_push_back(WpStr8, &parts, &docs);
+	wpDblListPushBack(WpStr8, &parts, &docs);
 
-	wapp_cpath_join_path(&out, &parts);
+	wpCpathJoinPath(&out, &parts);
 	result = wpStr8Equal(&out, &expected);
 
-	wapp_dbl_list_pop_front(WpStr8, &parts);
+	wpDblListPopFront(WpStr8, &parts);
 
-	wpStr8Format(&expected, "home%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP);
+	wpStr8Format(&expected, "home%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP);
 
-	wapp_cpath_join_path(&out, &parts);
+	wpCpathJoinPath(&out, &parts);
 	result = result && wpStr8Equal(&out, &expected);
 
 	WpStr8RO str = wpStr8LitRo("home");
 	wpStr8ConcatCapped(&tmp, &str);
-	wapp_dbl_list_pop_front(WpStr8, &parts);
+	wpDblListPopFront(WpStr8, &parts);
 
-	wapp_dbl_list_push_front(WpStr8, &parts, &tmp);
+	wpDblListPushFront(WpStr8, &parts, &tmp);
 
-	wpStr8Format(&expected, "%chome%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP);
+	wpStr8Format(&expected, "%chome%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP, WP_PATH_SEP);
 
-	wapp_cpath_join_path(&out, &parts);
+	wpCpathJoinPath(&out, &parts);
 	result = result && wpStr8Equal(&out, &expected);
 
-	wpStr8Format(&tmp, "home%c", WAPP_PATH_SEP);
-	wapp_dbl_list_pop_front(WpStr8, &parts);
+	wpStr8Format(&tmp, "home%c", WP_PATH_SEP);
+	wpDblListPopFront(WpStr8, &parts);
 
 	WpStr8 home_2 = wpStr8Lit("home");
-	wapp_dbl_list_push_front(WpStr8, &parts, &home_2);
+	wpDblListPushFront(WpStr8, &parts, &home_2);
 
-	wpStr8Format(&expected, "home%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP);
+	wpStr8Format(&expected, "home%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP);
 
-	wapp_cpath_join_path(&out, &parts);
+	wpCpathJoinPath(&out, &parts);
 	result = result && wpStr8Equal(&out, &expected);
 
-	wapp_dbl_list_empty(WpStr8, &parts);
+	wpDblListEmpty(WpStr8, &parts);
 
-	wpStr8Format(&tmp, "%chome", WAPP_PATH_SEP);
+	wpStr8Format(&tmp, "%chome", WP_PATH_SEP);
 
-	wapp_dbl_list_push_back(WpStr8, &parts, &tmp);
+	wpDblListPushBack(WpStr8, &parts, &tmp);
 
 	WpStr8 empty = wpStr8Lit("");
-	wapp_dbl_list_push_back(WpStr8, &parts, &empty);
+	wpDblListPushBack(WpStr8, &parts, &empty);
 
-	wpStr8Format(&expected, "%chome", WAPP_PATH_SEP);
+	wpStr8Format(&expected, "%chome", WP_PATH_SEP);
 
-	wapp_cpath_join_path(&out, &parts);
+	wpCpathJoinPath(&out, &parts);
 	result = result && wpStr8Equal(&out, &expected);
 
-	wapp_dbl_list_pop_front(WpStr8, &parts);
+	wpDblListPopFront(WpStr8, &parts);
 
 	WpStr8 empty_2 = wpStr8Lit("");
-	wapp_dbl_list_push_back(WpStr8, &parts, &empty_2);
+	wpDblListPushBack(WpStr8, &parts, &empty_2);
 
 	wpStr8Format(&expected, "%s", "");
 
-	wapp_cpath_join_path(&out, &parts);
+	wpCpathJoinPath(&out, &parts);
 	result = result && wpStr8Equal(&out, &expected);
 
-	wapp_dbl_list_pop_back(WpStr8, &parts);
+	wpDblListPopBack(WpStr8, &parts);
 
 	WpStr8 home_3 = wpStr8Lit("home");
-	wapp_dbl_list_push_back(WpStr8, &parts, &home_3);
+	wpDblListPushBack(WpStr8, &parts, &home_3);
 
 	wpStr8CopyCstrCapped(&expected, "home");
 
-	wapp_cpath_join_path(&out, &parts);
+	wpCpathJoinPath(&out, &parts);
 	result = result && wpStr8Equal(&out, &expected);
 
 	return wpTesterResult(result);
 }
 
 WpTestFuncResult test_cpath_dirname(void) {
-	WpAllocator arena = wapp_mem_arena_allocator_init(MiB(8));
+	WpAllocator arena = wpMemArenaAllocatorInit(MiB(8));
 	if (wpMemAllocatorInvalid(&arena)) {
 		return wpTesterResult(false);
 	}
@@ -111,45 +111,45 @@ WpTestFuncResult test_cpath_dirname(void) {
 	WpStr8 tmp      = wpStr8Buf(TMP_BUF_SIZE);
 
 	// CASE 1
-	wpStr8Format(&tmp, "%c", WAPP_PATH_SEP);
-	wpStr8Format(&expected, "%c", WAPP_PATH_SEP);
+	wpStr8Format(&tmp, "%c", WP_PATH_SEP);
+	wpStr8Format(&expected, "%c", WP_PATH_SEP);
 
-	output = wapp_cpath_dirname(&arena, &tmp);
+	output = wpCpathDirname(&arena, &tmp);
 	result = output != nullptr && wpStr8Equal(output, &expected);
 
 	// CASE 2
 	wpStr8Format(&expected, "%s", ".");
 
 	WpStr8 path = wpStr8Lit("home");
-	output    = wapp_cpath_dirname(&arena, &path);
+	output    = wpCpathDirname(&arena, &path);
 	result    = result && output != nullptr && wpStr8Equal(output, &expected);
 
 	// CASE 3
 	path   = wpStr8Lit("");
-	output = wapp_cpath_dirname(&arena, &path);
+	output = wpCpathDirname(&arena, &path);
 	result = result && output != nullptr && wpStr8Equal(output, &expected);
 
 	// CASE 4
-	wpStr8Format(&tmp, "%chome%ctest", WAPP_PATH_SEP, WAPP_PATH_SEP);
-	wpStr8Format(&expected, "%chome", WAPP_PATH_SEP);
+	wpStr8Format(&tmp, "%chome%ctest", WP_PATH_SEP, WP_PATH_SEP);
+	wpStr8Format(&expected, "%chome", WP_PATH_SEP);
 
-	output = wapp_cpath_dirname(&arena, &tmp);
+	output = wpCpathDirname(&arena, &tmp);
 	result = result && output != nullptr && wpStr8Equal(output, &expected);
 
 	// CASE 5
-	wpStr8Format(&tmp, "%chome%ctest%c", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP);
-	wpStr8Format(&expected, "%chome", WAPP_PATH_SEP);
+	wpStr8Format(&tmp, "%chome%ctest%c", WP_PATH_SEP, WP_PATH_SEP, WP_PATH_SEP);
+	wpStr8Format(&expected, "%chome", WP_PATH_SEP);
 
-	output = wapp_cpath_dirname(&arena, &tmp);
+	output = wpCpathDirname(&arena, &tmp);
 	result = result && output != nullptr && wpStr8Equal(output, &expected);
 
-	wapp_mem_arena_allocator_destroy(&arena);
+	wpMemArenaAllocatorDestroy(&arena);
 
 	return wpTesterResult(result);
 }
 
 WpTestFuncResult test_cpath_dirup(void) {
-	WpAllocator arena = wapp_mem_arena_allocator_init(MiB(8));
+	WpAllocator arena = wpMemArenaAllocatorInit(MiB(8));
 	if (wpMemAllocatorInvalid(&arena)) {
 		return wpTesterResult(false);
 	}
@@ -161,41 +161,41 @@ WpTestFuncResult test_cpath_dirup(void) {
 	WpStr8 tmp      = wpStr8Buf(TMP_BUF_SIZE);
 
 	// CASE 1
-	wpStr8Format(&tmp, "%c", WAPP_PATH_SEP);
-	wpStr8Format(&expected, "%c", WAPP_PATH_SEP);
+	wpStr8Format(&tmp, "%c", WP_PATH_SEP);
+	wpStr8Format(&expected, "%c", WP_PATH_SEP);
 
-	output = wapp_cpath_dirup(&arena, &tmp, 3);
+	output = wpCpathDirup(&arena, &tmp, 3);
 	result = output != nullptr && wpStr8Equal(output, &expected);
 
 	// CASE 2
-	wpStr8Format(&tmp, "%chome%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP);
-	wpStr8Format(&expected, "%c", WAPP_PATH_SEP);
+	wpStr8Format(&tmp, "%chome%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP, WP_PATH_SEP);
+	wpStr8Format(&expected, "%c", WP_PATH_SEP);
 
-	output = wapp_cpath_dirup(&arena, &tmp, 3);
+	output = wpCpathDirup(&arena, &tmp, 3);
 	result = result && output != nullptr && wpStr8Equal(output, &expected);
 
 	// CASE 3
-	wpStr8Format(&tmp, "home%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP);
+	wpStr8Format(&tmp, "home%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP);
 	wpStr8CopyCstrCapped(&expected, ".");
 
-	output = wapp_cpath_dirup(&arena, &tmp, 3);
+	output = wpCpathDirup(&arena, &tmp, 3);
 	result = result && output != nullptr && wpStr8Equal(output, &expected);
 
 	// CASE 4
-	wpStr8Format(&tmp, "%chome%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP);
-	wpStr8Format(&expected, "%chome", WAPP_PATH_SEP);
+	wpStr8Format(&tmp, "%chome%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP, WP_PATH_SEP);
+	wpStr8Format(&expected, "%chome", WP_PATH_SEP);
 
-	output = wapp_cpath_dirup(&arena, &tmp, 2);
+	output = wpCpathDirup(&arena, &tmp, 2);
 	result = result && output != nullptr && wpStr8Equal(output, &expected);
 
 	// CASE 5
-	wpStr8Format(&tmp, "home%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP);
+	wpStr8Format(&tmp, "home%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP);
 	wpStr8CopyCstrCapped(&expected, "home");
 
-	output = wapp_cpath_dirup(&arena, &tmp, 2);
+	output = wpCpathDirup(&arena, &tmp, 2);
 	result = result && output != nullptr && wpStr8Equal(output, &expected);
 
-	wapp_mem_arena_allocator_destroy(&arena);
+	wpMemArenaAllocatorDestroy(&arena);
 
 	return wpTesterResult(result);
 }

tests/file/test_file.c

@@ -6,45 +6,45 @@
 wp_intern WpAllocator arena           = {0};
 wp_intern WpStr8RO test_filename      = wpStr8LitRoInitialiserList("wapptest.bin");
 wp_intern WpStr8RO new_filename       = wpStr8LitRoInitialiserList("wapptest2.bin");
-wp_intern WFile *test_fp            = NULL;
-wp_intern I32Array src_array1       = wapp_array(i32,  0,  1,  2,  3,  4);
-wp_intern I32Array src_array2       = wapp_array(i32,  5,  6,  7,  8,  9);
-wp_intern I32Array src_array3       = wapp_array(i32, 10, 11, 12, 13, 14);
-wp_intern I32Array dst_array        = wapp_array_with_capacity(i32, DST_CAPACITY, false);
+wp_intern WpFile *test_fp            = NULL;
+wp_intern WpI32Array src_array1       = wpArray(i32,  0,  1,  2,  3,  4);
+wp_intern WpI32Array src_array2       = wpArray(i32,  5,  6,  7,  8,  9);
+wp_intern WpI32Array src_array3       = wpArray(i32, 10, 11, 12, 13, 14);
+wp_intern WpI32Array dst_array        = wpArrayWithCapacity(i32, DST_CAPACITY, false);
 wp_intern i32 dst_buf[DST_CAPACITY] = {0};
 
 WpTestFuncResult test_wapp_file_open(void) {
-	arena   = wapp_mem_arena_allocator_init(KiB(16));
-	test_fp = wapp_file_open(&arena, &test_filename, WAPP_ACCESS_WRITE_EX);
+	arena   = wpMemArenaAllocatorInit(KiB(16));
+	test_fp = wpFileOpen(&arena, &test_filename, WP_ACCESS_WRITE_EX);
 	return wpTesterResult(test_fp != NULL);
 }
 
 WpTestFuncResult test_wapp_file_get_current_position(void) {
-	i64 pos = wapp_file_get_current_position(test_fp);
+	i64 pos = wpFileGetCurrentPosition(test_fp);
 	return wpTesterResult(pos == 0);
 }
 
 WpTestFuncResult test_wapp_file_seek(void) {
-	wapp_file_write_array((GenericArray)src_array1, test_fp, wapp_array_count(src_array1));
+	wpFileWriteArray((WpArray)src_array1, test_fp, wpArrayCount(src_array1));
 
-	i64 seek_result = wapp_file_seek(test_fp, 0, WAPP_SEEK_END);
-	b8 result       = seek_result == (i64)(wapp_array_count(src_array1) * wapp_array_item_size(src_array1));
+	i64 seek_result = wpFileSeek(test_fp, 0, WP_SEEK_END);
+	b8 result       = seek_result == (i64)(wpArrayCount(src_array1) * wpArrayItemSize(src_array1));
 
-	wapp_file_seek(test_fp, 0, WAPP_SEEK_START);
+	wpFileSeek(test_fp, 0, WP_SEEK_START);
 
 	return wpTesterResult(result);
 }
 
 WpTestFuncResult test_wapp_file_get_length(void) {
-	i64 length = wapp_file_get_length(test_fp);
-	return wpTesterResult(length == (i64)(wapp_array_count(src_array1) * wapp_array_item_size(src_array1)));
+	i64 length = wpFileGetLength(test_fp);
+	return wpTesterResult(length == (i64)(wpArrayCount(src_array1) * wpArrayItemSize(src_array1)));
 }
 
 WpTestFuncResult test_wapp_file_read(void) {
-	wapp_file_seek(test_fp, 0, WAPP_SEEK_START);
+	wpFileSeek(test_fp, 0, WP_SEEK_START);
 
 	u64 byte_count = DST_CAPACITY * sizeof(i32);
-	u64 count      = wapp_file_read((void *)dst_buf, test_fp, byte_count);
+	u64 count      = wpFileRead((void *)dst_buf, test_fp, byte_count);
 	b8 result      = count == byte_count;
 
 	// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
@@ -52,7 +52,7 @@ WpTestFuncResult test_wapp_file_read(void) {
 	u64 index  = 0;
 	b8 running = true;
 	while (running) {
-		result = result && (dst_buf[index] == *wapp_array_get(i32, src_array1, index));
+		result = result && (dst_buf[index] == *wpArrayGet(i32, src_array1, index));
 		++index;
 		running = index < DST_CAPACITY;
 	}
@@ -61,58 +61,58 @@ WpTestFuncResult test_wapp_file_read(void) {
 }
 
 WpTestFuncResult test_wapp_file_write(void) {
-	wapp_file_seek(test_fp, 0, WAPP_SEEK_END);
+	wpFileSeek(test_fp, 0, WP_SEEK_END);
 
-	u64 expected_count = wapp_array_count(src_array2) * wapp_array_item_size(src_array2);
-	i64 count = wapp_file_write((void *)src_array2, test_fp, expected_count);
+	u64 expected_count = wpArrayCount(src_array2) * wpArrayItemSize(src_array2);
+	i64 count = wpFileWrite((void *)src_array2, test_fp, expected_count);
 
 	return wpTesterResult(count >= 0 && (u64)count == expected_count);
 }
 
 WpTestFuncResult test_wapp_file_read_array(void) {
-	wapp_file_seek(test_fp, 0, WAPP_SEEK_START);
+	wpFileSeek(test_fp, 0, WP_SEEK_START);
 
-	u64 count = wapp_file_read_array((GenericArray)dst_array, test_fp, wapp_array_count(src_array1));
-	b8 result = count == wapp_array_count(src_array1) &&
-	            wapp_array_count(dst_array) == wapp_array_count(src_array1);
+	u64 count = wpFileReadArray((WpArray)dst_array, test_fp, wpArrayCount(src_array1));
+	b8 result = count == wpArrayCount(src_array1) &&
+	            wpArrayCount(dst_array) == wpArrayCount(src_array1);
 
 	// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
 	// MSVC Spectre mitigation warnings
 	u64 index  = 0;
 	b8 running = true;
 	while (running) {
-		result = result && (*wapp_array_get(i32, dst_array, index) == *wapp_array_get(i32, src_array1, index));
+		result = result && (*wpArrayGet(i32, dst_array, index) == *wpArrayGet(i32, src_array1, index));
 		++index;
-		running = index < wapp_array_count(dst_array);
+		running = index < wpArrayCount(dst_array);
 	}
 
 	return wpTesterResult(result);
 }
 
 WpTestFuncResult test_wapp_file_write_array(void) {
-	wapp_file_seek(test_fp, 0, WAPP_SEEK_END);
+	wpFileSeek(test_fp, 0, WP_SEEK_END);
 
-	i64 count = wapp_file_write_array((GenericArray)src_array3, test_fp, wapp_array_count(src_array3));
+	i64 count = wpFileWriteArray((WpArray)src_array3, test_fp, wpArrayCount(src_array3));
 
-	return wpTesterResult(count >= 0 && (u64)count == wapp_array_count(src_array3));
+	return wpTesterResult(count >= 0 && (u64)count == wpArrayCount(src_array3));
 }
 
 WpTestFuncResult test_wapp_file_flush(void) {
-	i32 flush_result = wapp_file_flush(test_fp);
+	i32 flush_result = wpFileFlush(test_fp);
 	return wpTesterResult(flush_result == 0);
 }
 
 WpTestFuncResult test_wapp_file_close(void) {
-	i32 close_result = wapp_file_close(test_fp);
+	i32 close_result = wpFileClose(test_fp);
 	return wpTesterResult(close_result == 0);
 }
 
 WpTestFuncResult test_wapp_file_rename(void) {
-	i32 rename_result = wapp_file_rename(&test_filename, &new_filename);
+	i32 rename_result = wpFileRename(&test_filename, &new_filename);
 	return wpTesterResult(rename_result == 0);
 }
 
 WpTestFuncResult test_wapp_file_remove(void) {
-	i32 remove_result = wapp_file_remove(&new_filename);
+	i32 remove_result = wpFileRemove(&new_filename);
 	return wpTesterResult(remove_result == 0);
 }

tests/file/test_file.cc

@@ -6,49 +6,49 @@
 wp_intern WpAllocator arena           = {};
 wp_intern WpStr8RO test_filename      = wpStr8LitRoInitialiserList("wapptest.bin");
 wp_intern WpStr8RO new_filename       = wpStr8LitRoInitialiserList("wapptest2.bin");
-wp_intern WFile *test_fp            = NULL;
+wp_intern WpFile *test_fp            = NULL;
 wp_intern i32 dst_buf[DST_CAPACITY] = {0};
-wp_intern I32Array src_array1;
-wp_intern I32Array src_array2;
-wp_intern I32Array src_array3;
-wp_intern I32Array dst_array ;
+wp_intern WpI32Array src_array1;
+wp_intern WpI32Array src_array2;
+wp_intern WpI32Array src_array3;
+wp_intern WpI32Array dst_array ;
 
 WpTestFuncResult test_wapp_file_open(void) {
-	arena      = wapp_mem_arena_allocator_init(KiB(16));
-	src_array1 = wapp_array(i32,  0,  1,  2,  3,  4);
-	src_array2 = wapp_array(i32,  5,  6,  7,  8,  9);
-	src_array3 = wapp_array(i32, 10, 11, 12, 13, 14);
-	dst_array  = wapp_array_with_capacity(i32, DST_CAPACITY, false);
-	test_fp    = wapp_file_open(&arena, &test_filename, WAPP_ACCESS_WRITE_EX);
+	arena      = wpMemArenaAllocatorInit(KiB(16));
+	src_array1 = wpArray(i32,  0,  1,  2,  3,  4);
+	src_array2 = wpArray(i32,  5,  6,  7,  8,  9);
+	src_array3 = wpArray(i32, 10, 11, 12, 13, 14);
+	dst_array  = wpArrayWithCapacity(i32, DST_CAPACITY, false);
+	test_fp    = wpFileOpen(&arena, &test_filename, WP_ACCESS_WRITE_EX);
 	return wpTesterResult(test_fp != NULL);
 }
 
 WpTestFuncResult test_wapp_file_get_current_position(void) {
-	i64 pos = wapp_file_get_current_position(test_fp);
+	i64 pos = wpFileGetCurrentPosition(test_fp);
 	return wpTesterResult(pos == 0);
 }
 
 WpTestFuncResult test_wapp_file_seek(void) {
-	wapp_file_write_array((GenericArray)src_array1, test_fp, wapp_array_count(src_array1));
+	wpFileWriteArray((WpArray)src_array1, test_fp, wpArrayCount(src_array1));
 
-	i64 seek_result = wapp_file_seek(test_fp, 0, WAPP_SEEK_END);
-	b8 result       = seek_result == (i64)(wapp_array_count(src_array1) * wapp_array_item_size(src_array1));
+	i64 seek_result = wpFileSeek(test_fp, 0, WP_SEEK_END);
+	b8 result       = seek_result == (i64)(wpArrayCount(src_array1) * wpArrayItemSize(src_array1));
 
-	wapp_file_seek(test_fp, 0, WAPP_SEEK_START);
+	wpFileSeek(test_fp, 0, WP_SEEK_START);
 
 	return wpTesterResult(result);
 }
 
 WpTestFuncResult test_wapp_file_get_length(void) {
-	i64 length = wapp_file_get_length(test_fp);
-	return wpTesterResult(length == (i64)(wapp_array_count(src_array1) * wapp_array_item_size(src_array1)));
+	i64 length = wpFileGetLength(test_fp);
+	return wpTesterResult(length == (i64)(wpArrayCount(src_array1) * wpArrayItemSize(src_array1)));
 }
 
 WpTestFuncResult test_wapp_file_read(void) {
-	wapp_file_seek(test_fp, 0, WAPP_SEEK_START);
+	wpFileSeek(test_fp, 0, WP_SEEK_START);
 
 	u64 byte_count = DST_CAPACITY * sizeof(i32);
-	u64 count      = wapp_file_read((void *)dst_buf, test_fp, byte_count);
+	u64 count      = wpFileRead((void *)dst_buf, test_fp, byte_count);
 	b8 result      = count == byte_count;
 
 	// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
@@ -56,7 +56,7 @@ WpTestFuncResult test_wapp_file_read(void) {
 	u64 index  = 0;
 	b8 running = true;
 	while (running) {
-		result = result && (dst_buf[index] == *wapp_array_get(i32, src_array1, index));
+		result = result && (dst_buf[index] == *wpArrayGet(i32, src_array1, index));
 		++index;
 		running = index < DST_CAPACITY;
 	}
@@ -65,58 +65,58 @@ WpTestFuncResult test_wapp_file_read(void) {
 }
 
 WpTestFuncResult test_wapp_file_write(void) {
-	wapp_file_seek(test_fp, 0, WAPP_SEEK_END);
+	wpFileSeek(test_fp, 0, WP_SEEK_END);
 
-	u64 expected_count = wapp_array_count(src_array2) * wapp_array_item_size(src_array2);
-	i64 count = wapp_file_write((void *)src_array2, test_fp, expected_count);
+	u64 expected_count = wpArrayCount(src_array2) * wpArrayItemSize(src_array2);
+	i64 count = wpFileWrite((void *)src_array2, test_fp, expected_count);
 
 	return wpTesterResult(count >= 0 && (u64)count == expected_count);
 }
 
 WpTestFuncResult test_wapp_file_read_array(void) {
-	wapp_file_seek(test_fp, 0, WAPP_SEEK_START);
+	wpFileSeek(test_fp, 0, WP_SEEK_START);
 
-	u64 count = wapp_file_read_array((GenericArray)dst_array, test_fp, wapp_array_count(src_array1));
-	b8 result = count == wapp_array_count(src_array1) &&
-	            wapp_array_count(dst_array) == wapp_array_count(src_array1);
+	u64 count = wpFileReadArray((WpArray)dst_array, test_fp, wpArrayCount(src_array1));
+	b8 result = count == wpArrayCount(src_array1) &&
+	            wpArrayCount(dst_array) == wpArrayCount(src_array1);
 
 	// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
 	// MSVC Spectre mitigation warnings
 	u64 index  = 0;
 	b8 running = true;
 	while (running) {
-		result = result && (*wapp_array_get(i32, dst_array, index) == *wapp_array_get(i32, src_array1, index));
+		result = result && (*wpArrayGet(i32, dst_array, index) == *wpArrayGet(i32, src_array1, index));
 		++index;
-		running = index < wapp_array_count(dst_array);
+		running = index < wpArrayCount(dst_array);
 	}
 
 	return wpTesterResult(result);
 }
 
 WpTestFuncResult test_wapp_file_write_array(void) {
-	wapp_file_seek(test_fp, 0, WAPP_SEEK_END);
+	wpFileSeek(test_fp, 0, WP_SEEK_END);
 
-	i64 count = wapp_file_write_array((GenericArray)src_array3, test_fp, wapp_array_count(src_array3));
+	i64 count = wpFileWriteArray((WpArray)src_array3, test_fp, wpArrayCount(src_array3));
 
-	return wpTesterResult(count >= 0 && (u64)count == wapp_array_count(src_array3));
+	return wpTesterResult(count >= 0 && (u64)count == wpArrayCount(src_array3));
 }
 
 WpTestFuncResult test_wapp_file_flush(void) {
-	i32 flush_result = wapp_file_flush(test_fp);
+	i32 flush_result = wpFileFlush(test_fp);
 	return wpTesterResult(flush_result == 0);
 }
 
 WpTestFuncResult test_wapp_file_close(void) {
-	i32 close_result = wapp_file_close(test_fp);
+	i32 close_result = wpFileClose(test_fp);
 	return wpTesterResult(close_result == 0);
 }
 
 WpTestFuncResult test_wapp_file_rename(void) {
-	i32 rename_result = wapp_file_rename(&test_filename, &new_filename);
+	i32 rename_result = wpFileRename(&test_filename, &new_filename);
 	return wpTesterResult(rename_result == 0);
 }
 
 WpTestFuncResult test_wapp_file_remove(void) {
-	i32 remove_result = wapp_file_remove(&new_filename);
+	i32 remove_result = wpFileRemove(&new_filename);
 	return wpTesterResult(remove_result == 0);
 }

tests/queue/test_queue.c

@@ -23,7 +23,7 @@ WpTestFuncResult test_queue_push(void) {
 }
 
 WpTestFuncResult test_queue_push_alloc(void) {
-	WpAllocator arena = wapp_mem_arena_allocator_init(MiB(64));
+	WpAllocator arena = wpMemArenaAllocatorInit(MiB(64));
 	WpI32Queue queue  = wpQueue(i32, CAPACITY);
 
 	for (u64 i = 0; i < CAPACITY; ++i) {
@@ -65,7 +65,7 @@ WpTestFuncResult test_queue_push_alloc(void) {
 		result = result && arr[i] == (i32)(2 + i);
 	}
 
-	wapp_mem_arena_allocator_destroy(&arena);
+	wpMemArenaAllocatorDestroy(&arena);
 
 	return wpTesterResult(result);
 }

tests/queue/test_queue.cc

@@ -21,7 +21,7 @@ WpTestFuncResult test_queue_push(void) {
 }
 
 WpTestFuncResult test_queue_push_alloc(void) {
-	WpAllocator arena = wapp_mem_arena_allocator_init(MiB(64));
+	WpAllocator arena = wpMemArenaAllocatorInit(MiB(64));
 	WpI32Queue queue  = wpQueue(i32, CAPACITY);
 
 	for (u64 i = 0; i < CAPACITY; ++i) {
@@ -63,7 +63,7 @@ WpTestFuncResult test_queue_push_alloc(void) {
 		result = result && arr[i] == (i32)(2 + i);
 	}
 
-	wapp_mem_arena_allocator_destroy(&arena);
+	wpMemArenaAllocatorDestroy(&arena);
 
 	return wpTesterResult(result);
 }

tests/shell_commander/test_shell_commander.c

@@ -5,24 +5,24 @@
 #include <string.h>
 
 WpTestFuncResult test_commander_cmd_success(void) {
-	WpStr8List cmd = wapp_dbl_list(WpStr8);
-	wapp_dbl_list_push_back(WpStr8, &cmd, &wpStr8Lit("echo"));
-	wapp_dbl_list_push_back(WpStr8, &cmd, &wpStr8Lit("hello world"));
+	WpStr8List cmd = wpDblList(WpStr8);
+	wpDblListPushBack(WpStr8, &cmd, &wpStr8Lit("echo"));
+	wpDblListPushBack(WpStr8, &cmd, &wpStr8Lit("hello world"));
 
-	CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_DISCARD, NULL, &cmd);
+	WpCmdResult result = wpShellCommanderExecute(WP_SHELL_OUTPUT_DISCARD, NULL, &cmd);
 	b8 succeeded     = result.exited && result.exit_code == EXIT_SUCCESS &&
-	                   result.error == SHELL_ERR_NO_ERROR;
+	                   result.error == WP_SHELL_ERR_NO_ERROR;
 
 	return wpTesterResult(succeeded);
 }
 
 WpTestFuncResult test_commander_cmd_failure(void) {
-	WpStr8List cmd = wapp_dbl_list(WpStr8);
-	wapp_dbl_list_push_back(WpStr8, &cmd, &wpStr8Lit("grep"));
+	WpStr8List cmd = wpDblList(WpStr8);
+	wpDblListPushBack(WpStr8, &cmd, &wpStr8Lit("grep"));
 
-	CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_DISCARD, NULL, &cmd);
+	WpCmdResult result = wpShellCommanderExecute(WP_SHELL_OUTPUT_DISCARD, NULL, &cmd);
 	b8 failed        = result.exited && result.exit_code != EXIT_SUCCESS &&
-	                   result.error == SHELL_ERR_NO_ERROR;
+	                   result.error == WP_SHELL_ERR_NO_ERROR;
 
 	return wpTesterResult(failed);
 }
@@ -33,13 +33,13 @@ WpTestFuncResult test_commander_cmd_out_buf_success(void) {
 	char msg[]    = "hello world";
 	wpStr8CopyCstrCapped(&expected, msg);
 
-	WpStr8List cmd = wapp_dbl_list(WpStr8);
-	wapp_dbl_list_push_back(WpStr8, &cmd, &wpStr8Lit("echo"));
-	wapp_dbl_list_push_back(WpStr8, &cmd, &wpStr8Lit(msg));
+	WpStr8List cmd = wpDblList(WpStr8);
+	wpDblListPushBack(WpStr8, &cmd, &wpStr8Lit("echo"));
+	wpDblListPushBack(WpStr8, &cmd, &wpStr8Lit(msg));
 
-	CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_CAPTURE, &buf, &cmd);
+	WpCmdResult result = wpShellCommanderExecute(WP_SHELL_OUTPUT_CAPTURE, &buf, &cmd);
 	b8 succeeded     = result.exited && result.exit_code == EXIT_SUCCESS &&
-	                   result.error == SHELL_ERR_NO_ERROR && wpStr8EqualToCount(&buf, &expected, strlen(msg));
+	                   result.error == WP_SHELL_ERR_NO_ERROR && wpStr8EqualToCount(&buf, &expected, strlen(msg));
 
 	return wpTesterResult(succeeded);
 }
@@ -50,13 +50,13 @@ WpTestFuncResult test_commander_cmd_out_buf_failure(void) {
 	char msg[]    = "hello world";
 	wpStr8CopyCstrCapped(&expected, msg);
 
-	WpStr8List cmd = wapp_dbl_list(WpStr8);
-	wapp_dbl_list_push_back(WpStr8, &cmd, &wpStr8Lit("echo"));
-	wapp_dbl_list_push_back(WpStr8, &cmd, &wpStr8Lit(msg));
+	WpStr8List cmd = wpDblList(WpStr8);
+	wpDblListPushBack(WpStr8, &cmd, &wpStr8Lit("echo"));
+	wpDblListPushBack(WpStr8, &cmd, &wpStr8Lit(msg));
 
-	CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_CAPTURE, &buf, &cmd);
+	WpCmdResult result = wpShellCommanderExecute(WP_SHELL_OUTPUT_CAPTURE, &buf, &cmd);
 	b8 failed        = !result.exited && result.exit_code != EXIT_SUCCESS &&
-	                   result.error == SHELL_ERR_OUT_BUF_FULL && !wpStr8Equal(&buf, &expected);
+	                   result.error == WP_SHELL_ERR_OUT_BUF_FULL && !wpStr8Equal(&buf, &expected);
 
 	return wpTesterResult(failed);
 }

tests/shell_commander/test_shell_commander.cc

@@ -5,27 +5,27 @@
 #include <string.h>
 
 WpTestFuncResult test_commander_cmd_success(void) {
-	WpStr8List cmd  = wapp_dbl_list(WpStr8);
+	WpStr8List cmd  = wpDblList(WpStr8);
 	WpStr8 echo  = wpStr8Lit("echo");
 	WpStr8 msg  = wpStr8Lit("hello world");
-	wapp_dbl_list_push_back(WpStr8, &cmd, &echo);
-	wapp_dbl_list_push_back(WpStr8, &cmd, &msg);
+	wpDblListPushBack(WpStr8, &cmd, &echo);
+	wpDblListPushBack(WpStr8, &cmd, &msg);
 
-	CMDResult result  = wapp_shell_commander_execute(SHELL_OUTPUT_DISCARD, nullptr, &cmd);
+	WpCmdResult result  = wpShellCommanderExecute(WP_SHELL_OUTPUT_DISCARD, nullptr, &cmd);
 	b8 succeeded      = result.exited && result.exit_code == EXIT_SUCCESS &&
-	                    result.error == SHELL_ERR_NO_ERROR;
+	                    result.error == WP_SHELL_ERR_NO_ERROR;
 
 	return wpTesterResult(succeeded);
 }
 
 WpTestFuncResult test_commander_cmd_failure(void) {
-	WpStr8List cmd  = wapp_dbl_list(WpStr8);
+	WpStr8List cmd  = wpDblList(WpStr8);
 	WpStr8 grep  = wpStr8Lit("grep");
-	wapp_dbl_list_push_back(WpStr8, &cmd, &grep);
+	wpDblListPushBack(WpStr8, &cmd, &grep);
 
-	CMDResult result  = wapp_shell_commander_execute(SHELL_OUTPUT_DISCARD, nullptr, &cmd);
+	WpCmdResult result  = wpShellCommanderExecute(WP_SHELL_OUTPUT_DISCARD, nullptr, &cmd);
 	b8 failed          = result.exited && result.exit_code != EXIT_SUCCESS &&
-	                    result.error == SHELL_ERR_NO_ERROR;
+	                    result.error == WP_SHELL_ERR_NO_ERROR;
 
 	return wpTesterResult(failed);
 }
@@ -36,15 +36,15 @@ WpTestFuncResult test_commander_cmd_out_buf_success(void) {
 	char msg[]    = "hello world";
 	wpStr8CopyCstrCapped(&expected, msg);
 
-	WpStr8List cmd  = wapp_dbl_list(WpStr8);
+	WpStr8List cmd  = wpDblList(WpStr8);
 	WpStr8 echo  = wpStr8Lit("echo");
 	WpStr8 arg  = wpStr8Lit(msg);
-	wapp_dbl_list_push_back(WpStr8, &cmd, &echo);
-	wapp_dbl_list_push_back(WpStr8, &cmd, &arg);
+	wpDblListPushBack(WpStr8, &cmd, &echo);
+	wpDblListPushBack(WpStr8, &cmd, &arg);
 
-	CMDResult result  = wapp_shell_commander_execute(SHELL_OUTPUT_CAPTURE, &buf, &cmd);
+	WpCmdResult result  = wpShellCommanderExecute(WP_SHELL_OUTPUT_CAPTURE, &buf, &cmd);
 	b8 succeeded      = result.exited && result.exit_code == EXIT_SUCCESS &&
-	                    result.error == SHELL_ERR_NO_ERROR && wpStr8EqualToCount(&buf, &expected, strlen(msg));
+	                    result.error == WP_SHELL_ERR_NO_ERROR && wpStr8EqualToCount(&buf, &expected, strlen(msg));
 
 	return wpTesterResult(succeeded);
 }
@@ -55,15 +55,15 @@ WpTestFuncResult test_commander_cmd_out_buf_failure(void) {
 	char msg[]    = "hello world";
 	wpStr8CopyCstrCapped(&expected, msg);
 
-	WpStr8List cmd  = wapp_dbl_list(WpStr8);
+	WpStr8List cmd  = wpDblList(WpStr8);
 	WpStr8 echo  = wpStr8Lit("echo");
 	WpStr8 arg  = wpStr8Lit(msg);
-	wapp_dbl_list_push_back(WpStr8, &cmd, &echo);
-	wapp_dbl_list_push_back(WpStr8, &cmd, &arg);
+	wpDblListPushBack(WpStr8, &cmd, &echo);
+	wpDblListPushBack(WpStr8, &cmd, &arg);
 
-	CMDResult result  = wapp_shell_commander_execute(SHELL_OUTPUT_CAPTURE, &buf, &cmd);
+	WpCmdResult result  = wpShellCommanderExecute(WP_SHELL_OUTPUT_CAPTURE, &buf, &cmd);
 	b8 failed          = !result.exited && result.exit_code != EXIT_SUCCESS &&
-	                    result.error == SHELL_ERR_OUT_BUF_FULL && !wpStr8Equal(&buf, &expected);
+	                    result.error == WP_SHELL_ERR_OUT_BUF_FULL && !wpStr8Equal(&buf, &expected);
 
 	return wpTesterResult(failed);
 }

tests/str8/test_str8.c

@@ -77,7 +77,7 @@ WpTestFuncResult test_str8_buf(void) {
 
 WpTestFuncResult test_str8_alloc_buf(void) {
 	b8 result;
-	WpAllocator allocator = wapp_mem_arena_allocator_init(KiB(100));
+	WpAllocator allocator = wpMemArenaAllocatorInit(KiB(100));
 	if (wpMemAllocatorInvalid(&allocator)) {
 		return wpTesterResult(false);
 	}
@@ -98,14 +98,14 @@ WpTestFuncResult test_str8_alloc_buf(void) {
 	result = result && s->capacity == capacity && s->size == strlen(cstr) && memcmp(s->buf, cstr, s->size) == 0;
 
 TEST_ALLOC_BUF_CLEANUP:
-	wapp_mem_arena_allocator_destroy(&allocator);
+	wpMemArenaAllocatorDestroy(&allocator);
 
 	return wpTesterResult(result);
 }
 
 WpTestFuncResult test_str8_alloc_cstr(void) {
 	b8 result;
-	WpAllocator allocator = wapp_mem_arena_allocator_init(KiB(100));
+	WpAllocator allocator = wpMemArenaAllocatorInit(KiB(100));
 	if (wpMemAllocatorInvalid(&allocator)) {
 		return wpTesterResult(false);
 	}
@@ -119,14 +119,14 @@ WpTestFuncResult test_str8_alloc_cstr(void) {
 
 	result = s->size == length && memcmp(s->buf, str, length) == 0;
 
-	wapp_mem_arena_allocator_destroy(&allocator);
+	wpMemArenaAllocatorDestroy(&allocator);
 
 	return wpTesterResult(result);
 }
 
 WpTestFuncResult test_str8_alloc_str8(void) {
 	b8 result;
-	WpAllocator allocator = wapp_mem_arena_allocator_init(KiB(100));
+	WpAllocator allocator = wpMemArenaAllocatorInit(KiB(100));
 	if (wpMemAllocatorInvalid(&allocator)) {
 		return wpTesterResult(false);
 	}
@@ -139,14 +139,14 @@ WpTestFuncResult test_str8_alloc_str8(void) {
 
 	result = wpStr8Equal(s, &str);
 
-	wapp_mem_arena_allocator_destroy(&allocator);
+	wpMemArenaAllocatorDestroy(&allocator);
 
 	return wpTesterResult(result);
 }
 
 WpTestFuncResult test_str8_alloc_substr(void) {
 	b8 result;
-	WpAllocator allocator = wapp_mem_arena_allocator_init(KiB(100));
+	WpAllocator allocator = wpMemArenaAllocatorInit(KiB(100));
 	if (wpMemAllocatorInvalid(&allocator)) {
 		return wpTesterResult(false);
 	}
@@ -159,7 +159,7 @@ WpTestFuncResult test_str8_alloc_substr(void) {
 
 	result = s->size == 5 && memcmp(s->buf, "elrah", s->size) == 0;
 
-	wapp_mem_arena_allocator_destroy(&allocator);
+	wpMemArenaAllocatorDestroy(&allocator);
 
 	return wpTesterResult(result);
 }
@@ -289,7 +289,7 @@ WpTestFuncResult test_str8_slice(void) {
 
 WpTestFuncResult test_str8_alloc_concat(void) {
 	b8 result;
-	WpAllocator arena = wapp_mem_arena_allocator_init(KiB(100));
+	WpAllocator arena = wpMemArenaAllocatorInit(KiB(100));
 
 	WpStr8 str     = wpStr8Lit("Hello world");
 	WpStr8 suffix1 = wpStr8Lit(" from me.");
@@ -305,7 +305,7 @@ WpTestFuncResult test_str8_alloc_concat(void) {
 	output = wpStr8AllocConcat(&arena, output, &suffix2);
 	result = result && output->size == concat2.size && wpStr8Equal(output, &concat2);
 
-	wapp_mem_arena_allocator_destroy(&arena);
+	wpMemArenaAllocatorDestroy(&arena);
 
 	return wpTesterResult(result);
 }
@@ -410,7 +410,7 @@ WpTestFuncResult test_str8_rfind(void) {
 
 WpTestFuncResult test_str8_split(void) {
 	b8 result;
-	WpAllocator arena = wapp_mem_arena_allocator_init(KiB(100));
+	WpAllocator arena = wpMemArenaAllocatorInit(KiB(100));
 
 	WpStr8 str        = wpStr8Lit("hello world from me");
 	WpStr8 delim1     = wpStr8Lit(" ");
@@ -443,7 +443,7 @@ WpTestFuncResult test_str8_split(void) {
 	// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
 	// MSVC Spectre mitigation warnings
 	while (running1) {
-		WpStr8 *node = wapp_dbl_list_get(WpStr8, list1, index1);
+		WpStr8 *node = wpDblListGet(WpStr8, list1, index1);
 		result = result && wpStr8Equal(node, &(splits1[index1]));
 
 		++index1;
@@ -453,21 +453,21 @@ WpTestFuncResult test_str8_split(void) {
 	// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
 	// MSVC Spectre mitigation warnings
 	while (running2) {
-		WpStr8 *node = wapp_dbl_list_get(WpStr8, list2, index2);
+		WpStr8 *node = wpDblListGet(WpStr8, list2, index2);
 		result = result && wpStr8Equal(node, &(splits2[index2]));
 
 		++index2;
 		running2 = index2 < count2;
 	}
 
-	wapp_mem_arena_allocator_destroy(&arena);
+	wpMemArenaAllocatorDestroy(&arena);
 
 	return wpTesterResult(result);
 }
 
 WpTestFuncResult test_str8_split_with_max(void) {
 	b8 result;
-	WpAllocator arena = wapp_mem_arena_allocator_init(KiB(100));
+	WpAllocator arena = wpMemArenaAllocatorInit(KiB(100));
 
 	WpStr8 str        = wpStr8Lit("hello world from me");
 	WpStr8 delim      = wpStr8Lit(" ");
@@ -488,21 +488,21 @@ WpTestFuncResult test_str8_split_with_max(void) {
 	// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
 	// MSVC Spectre mitigation warnings
 	while (running) {
-		WpStr8 *node = wapp_dbl_list_get(WpStr8, list, index);
+		WpStr8 *node = wpDblListGet(WpStr8, list, index);
 		result = result && wpStr8Equal(node, &(splits[index]));
 
 		++index;
 		running = index < count;
 	}
 
-	wapp_mem_arena_allocator_destroy(&arena);
+	wpMemArenaAllocatorDestroy(&arena);
 
 	return wpTesterResult(result);
 }
 
 WpTestFuncResult test_str8_rsplit(void) {
 	b8 result;
-	WpAllocator arena = wapp_mem_arena_allocator_init(KiB(100));
+	WpAllocator arena = wpMemArenaAllocatorInit(KiB(100));
 
 	WpStr8 str        = wpStr8Lit("hello world from me");
 	WpStr8 delim1     = wpStr8Lit(" ");
@@ -535,7 +535,7 @@ WpTestFuncResult test_str8_rsplit(void) {
 	// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
 	// MSVC Spectre mitigation warnings
 	while (running1) {
-		WpStr8 *node = wapp_dbl_list_get(WpStr8, list1, index1);
+		WpStr8 *node = wpDblListGet(WpStr8, list1, index1);
 		result = result && wpStr8Equal(node, &(splits1[index1]));
 
 		++index1;
@@ -545,21 +545,21 @@ WpTestFuncResult test_str8_rsplit(void) {
 	// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
 	// MSVC Spectre mitigation warnings
 	while (running2) {
-		WpStr8 *node = wapp_dbl_list_get(WpStr8, list2, index2);
+		WpStr8 *node = wpDblListGet(WpStr8, list2, index2);
 		result = result && wpStr8Equal(node, &(splits2[index2]));
 
 		++index2;
 		running2 = index2 < count2;
 	}
 
-	wapp_mem_arena_allocator_destroy(&arena);
+	wpMemArenaAllocatorDestroy(&arena);
 
 	return wpTesterResult(result);
 }
 
 WpTestFuncResult test_str8_rsplit_with_max(void) {
 	b8 result;
-	WpAllocator arena = wapp_mem_arena_allocator_init(KiB(100));
+	WpAllocator arena = wpMemArenaAllocatorInit(KiB(100));
 
 	WpStr8 str        = wpStr8Lit("hello world from me");
 	WpStr8 delim      = wpStr8Lit(" ");
@@ -580,21 +580,21 @@ WpTestFuncResult test_str8_rsplit_with_max(void) {
 	// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
 	// MSVC Spectre mitigation warnings
 	while (running) {
-		WpStr8 *node = wapp_dbl_list_get(WpStr8, list, index);
+		WpStr8 *node = wpDblListGet(WpStr8, list, index);
 		result = result && wpStr8Equal(node, &(splits[index]));
 
 		++index;
 		running = index < count;
 	}
 
-	wapp_mem_arena_allocator_destroy(&arena);
+	wpMemArenaAllocatorDestroy(&arena);
 
 	return wpTesterResult(result);
 }
 
 WpTestFuncResult test_str8_join(void) {
 	b8 result;
-	WpAllocator arena = wapp_mem_arena_allocator_init(KiB(100));
+	WpAllocator arena = wpMemArenaAllocatorInit(KiB(100));
 
 	WpStr8 str        = wpStr8Lit("hello world from me");
 	WpStr8 delim1     = wpStr8Lit(" ");
@@ -607,7 +607,7 @@ WpTestFuncResult test_str8_join(void) {
 	result = join1->size == str.size && wpStr8Equal(join1, &str);
 	result = result && join2->size == str.size && wpStr8Equal(join2, &str);
 
-	wapp_mem_arena_allocator_destroy(&arena);
+	wpMemArenaAllocatorDestroy(&arena);
 
 	return wpTesterResult(result);
 }
@@ -616,10 +616,10 @@ WpTestFuncResult test_str8_from_bytes(void) {
 	b8 result;
 
 	WpStr8 str      = wpStr8Buf(1024);
-	U8Array bytes = wapp_array(u8, 'W', 'A', 'P', 'P');
+	WpU8Array bytes = wpArray(u8, 'W', 'A', 'P', 'P');
 	wpStr8FromBytes(&str, bytes);
 
-	result = str.size == wapp_array_count(bytes) * wapp_array_item_size(bytes);
+	result = str.size == wpArrayCount(bytes) * wpArrayItemSize(bytes);
 	result = result && wpStr8Equal(&str, &wpStr8LitRo("WAPP"));
 
 	return wpTesterResult(result);

tests/str8/test_str8.cc

@@ -77,7 +77,7 @@ WpTestFuncResult test_str8_buf(void) {
 
 WpTestFuncResult test_str8_alloc_buf(void) {
 	b8 result;
-	WpAllocator allocator = wapp_mem_arena_allocator_init(KiB(100));
+	WpAllocator allocator = wpMemArenaAllocatorInit(KiB(100));
 	if (wpMemAllocatorInvalid(&allocator)) {
 		return wpTesterResult(false);
 	}
@@ -87,7 +87,7 @@ WpTestFuncResult test_str8_alloc_buf(void) {
 	WpStr8 *s = wpStr8AllocBuf(&allocator, capacity);
 	if (!s) {
 		result = false;
-		wapp_mem_arena_allocator_destroy(&allocator);
+		wpMemArenaAllocatorDestroy(&allocator);
 		return wpTesterResult(result);
 	}
 
@@ -98,14 +98,14 @@ WpTestFuncResult test_str8_alloc_buf(void) {
 
 	result = result && s->capacity == capacity && s->size == strlen(cstr) && memcmp(s->buf, cstr, s->size) == 0;
 
-	wapp_mem_arena_allocator_destroy(&allocator);
+	wpMemArenaAllocatorDestroy(&allocator);
 
 	return wpTesterResult(result);
 }
 
 WpTestFuncResult test_str8_alloc_cstr(void) {
 	b8 result;
-	WpAllocator allocator = wapp_mem_arena_allocator_init(KiB(100));
+	WpAllocator allocator = wpMemArenaAllocatorInit(KiB(100));
 	if (wpMemAllocatorInvalid(&allocator)) {
 		return wpTesterResult(false);
 	}
@@ -119,14 +119,14 @@ WpTestFuncResult test_str8_alloc_cstr(void) {
 
 	result = s->size == length && memcmp(s->buf, str, length) == 0;
 
-	wapp_mem_arena_allocator_destroy(&allocator);
+	wpMemArenaAllocatorDestroy(&allocator);
 
 	return wpTesterResult(result);
 }
 
 WpTestFuncResult test_str8_alloc_str8(void) {
 	b8 result;
-	WpAllocator allocator = wapp_mem_arena_allocator_init(KiB(100));
+	WpAllocator allocator = wpMemArenaAllocatorInit(KiB(100));
 	if (wpMemAllocatorInvalid(&allocator)) {
 		return wpTesterResult(false);
 	}
@@ -139,14 +139,14 @@ WpTestFuncResult test_str8_alloc_str8(void) {
 
 	result = wpStr8Equal(s, &str);
 
-	wapp_mem_arena_allocator_destroy(&allocator);
+	wpMemArenaAllocatorDestroy(&allocator);
 
 	return wpTesterResult(result);
 }
 
 WpTestFuncResult test_str8_alloc_substr(void) {
 	b8 result;
-	WpAllocator allocator = wapp_mem_arena_allocator_init(KiB(100));
+	WpAllocator allocator = wpMemArenaAllocatorInit(KiB(100));
 	if (wpMemAllocatorInvalid(&allocator)) {
 		return wpTesterResult(false);
 	}
@@ -159,7 +159,7 @@ WpTestFuncResult test_str8_alloc_substr(void) {
 
 	result = s->size == 5 && memcmp(s->buf, "elrah", s->size) == 0;
 
-	wapp_mem_arena_allocator_destroy(&allocator);
+	wpMemArenaAllocatorDestroy(&allocator);
 
 	return wpTesterResult(result);
 }
@@ -289,7 +289,7 @@ WpTestFuncResult test_str8_slice(void) {
 
 WpTestFuncResult test_str8_alloc_concat(void) {
 	b8 result;
-	WpAllocator arena = wapp_mem_arena_allocator_init(KiB(100));
+	WpAllocator arena = wpMemArenaAllocatorInit(KiB(100));
 
 	WpStr8 str     = wpStr8Lit("Hello world");
 	WpStr8 suffix1 = wpStr8Lit(" from me.");
@@ -305,7 +305,7 @@ WpTestFuncResult test_str8_alloc_concat(void) {
 	output = wpStr8AllocConcat(&arena, output, &suffix2);
 	result = result && output->size == concat2.size && wpStr8Equal(output, &concat2);
 
-	wapp_mem_arena_allocator_destroy(&arena);
+	wpMemArenaAllocatorDestroy(&arena);
 
 	return wpTesterResult(result);
 }
@@ -410,7 +410,7 @@ WpTestFuncResult test_str8_rfind(void) {
 
 WpTestFuncResult test_str8_split(void) {
 	b8 result;
-	WpAllocator arena = wapp_mem_arena_allocator_init(KiB(100));
+	WpAllocator arena = wpMemArenaAllocatorInit(KiB(100));
 
 	WpStr8 str        = wpStr8Lit("hello world from me");
 	WpStr8 delim1     = wpStr8Lit(" ");
@@ -443,7 +443,7 @@ WpTestFuncResult test_str8_split(void) {
 	// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
 	// MSVC Spectre mitigation warnings
 	while (running1) {
-		WpStr8 *node = wapp_dbl_list_get(WpStr8, list1, index1);
+		WpStr8 *node = wpDblListGet(WpStr8, list1, index1);
 		result = result && wpStr8Equal(node, &(splits1[index1]));
 
 		++index1;
@@ -453,21 +453,21 @@ WpTestFuncResult test_str8_split(void) {
 	// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
 	// MSVC Spectre mitigation warnings
 	while (running2) {
-		WpStr8 *node = wapp_dbl_list_get(WpStr8, list2, index2);
+		WpStr8 *node = wpDblListGet(WpStr8, list2, index2);
 		result = result && wpStr8Equal(node, &(splits2[index2]));
 
 		++index2;
 		running2 = index2 < count2;
 	}
 
-	wapp_mem_arena_allocator_destroy(&arena);
+	wpMemArenaAllocatorDestroy(&arena);
 
 	return wpTesterResult(result);
 }
 
 WpTestFuncResult test_str8_split_with_max(void) {
 	b8 result;
-	WpAllocator arena = wapp_mem_arena_allocator_init(KiB(100));
+	WpAllocator arena = wpMemArenaAllocatorInit(KiB(100));
 
 	WpStr8 str        = wpStr8Lit("hello world from me");
 	WpStr8 delim      = wpStr8Lit(" ");
@@ -488,21 +488,21 @@ WpTestFuncResult test_str8_split_with_max(void) {
 	// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
 	// MSVC Spectre mitigation warnings
 	while (running) {
-		WpStr8 *node = wapp_dbl_list_get(WpStr8, list, index);
+		WpStr8 *node = wpDblListGet(WpStr8, list, index);
 		result = result && wpStr8Equal(node, &(splits[index]));
 
 		++index;
 		running = index < count;
 	}
 
-	wapp_mem_arena_allocator_destroy(&arena);
+	wpMemArenaAllocatorDestroy(&arena);
 
 	return wpTesterResult(result);
 }
 
 WpTestFuncResult test_str8_rsplit(void) {
 	b8 result;
-	WpAllocator arena = wapp_mem_arena_allocator_init(KiB(100));
+	WpAllocator arena = wpMemArenaAllocatorInit(KiB(100));
 
 	WpStr8 str        = wpStr8Lit("hello world from me");
 	WpStr8 delim1     = wpStr8Lit(" ");
@@ -535,7 +535,7 @@ WpTestFuncResult test_str8_rsplit(void) {
 	// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
 	// MSVC Spectre mitigation warnings
 	while (running1) {
-		WpStr8 *node = wapp_dbl_list_get(WpStr8, list1, index1);
+		WpStr8 *node = wpDblListGet(WpStr8, list1, index1);
 		result = result && wpStr8Equal(node, &(splits1[index1]));
 
 		++index1;
@@ -545,21 +545,21 @@ WpTestFuncResult test_str8_rsplit(void) {
 	// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
 	// MSVC Spectre mitigation warnings
 	while (running2) {
-		WpStr8 *node = wapp_dbl_list_get(WpStr8, list2, index2);
+		WpStr8 *node = wpDblListGet(WpStr8, list2, index2);
 		result = result && wpStr8Equal(node, &(splits2[index2]));
 
 		++index2;
 		running2 = index2 < count2;
 	}
 
-	wapp_mem_arena_allocator_destroy(&arena);
+	wpMemArenaAllocatorDestroy(&arena);
 
 	return wpTesterResult(result);
 }
 
 WpTestFuncResult test_str8_rsplit_with_max(void) {
 	b8 result;
-	WpAllocator arena = wapp_mem_arena_allocator_init(KiB(100));
+	WpAllocator arena = wpMemArenaAllocatorInit(KiB(100));
 
 	WpStr8 str        = wpStr8Lit("hello world from me");
 	WpStr8 delim      = wpStr8Lit(" ");
@@ -580,21 +580,21 @@ WpTestFuncResult test_str8_rsplit_with_max(void) {
 	// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
 	// MSVC Spectre mitigation warnings
 	while (running) {
-		WpStr8 *node = wapp_dbl_list_get(WpStr8, list, index);
+		WpStr8 *node = wpDblListGet(WpStr8, list, index);
 		result = result && wpStr8Equal(node, &(splits[index]));
 
 		++index;
 		running = index < count;
 	}
 
-	wapp_mem_arena_allocator_destroy(&arena);
+	wpMemArenaAllocatorDestroy(&arena);
 
 	return wpTesterResult(result);
 }
 
 WpTestFuncResult test_str8_join(void) {
 	b8 result;
-	WpAllocator arena = wapp_mem_arena_allocator_init(KiB(100));
+	WpAllocator arena = wpMemArenaAllocatorInit(KiB(100));
 
 	WpStr8 str        = wpStr8Lit("hello world from me");
 	WpStr8 delim1     = wpStr8Lit(" ");
@@ -607,7 +607,7 @@ WpTestFuncResult test_str8_join(void) {
 	result = join1->size == str.size && wpStr8Equal(join1, &str);
 	result = result && join2->size == str.size && wpStr8Equal(join2, &str);
 
-	wapp_mem_arena_allocator_destroy(&arena);
+	wpMemArenaAllocatorDestroy(&arena);
 
 	return wpTesterResult(result);
 }
@@ -617,10 +617,10 @@ WpTestFuncResult test_str8_from_bytes(void) {
 
 	WpStr8 str      = wpStr8Buf(1024);
 	WpStr8 expected = wpStr8LitRo("WAPP");
-	U8Array bytes = wapp_array(u8, 'W', 'A', 'P', 'P');
+	WpU8Array bytes = wpArray(u8, 'W', 'A', 'P', 'P');
 	wpStr8FromBytes(&str, bytes);
 
-	result = str.size == wapp_array_count(bytes) * wapp_array_item_size(bytes);
+	result = str.size == wpArrayCount(bytes) * wpArrayItemSize(bytes);
 	result = result && wpStr8Equal(&str, &expected);
 
 	return wpTesterResult(result);

tests/str8/test_str8_list.c

@@ -10,27 +10,27 @@ WpTestFuncResult test_str8_list_get(void) {
 	WpStr8 s4 = wpStr8Lit("4");
 	WpStr8 s5 = wpStr8Lit("5");
 
-	WpStr8List list = wapp_dbl_list(WpStr8);
+	WpStr8List list = wpDblList(WpStr8);
 
-	wapp_dbl_list_push_back(WpStr8, &list, &s1);
-	wapp_dbl_list_push_back(WpStr8, &list, &s2);
-	wapp_dbl_list_push_back(WpStr8, &list, &s3);
-	wapp_dbl_list_push_back(WpStr8, &list, &s4);
-	wapp_dbl_list_push_back(WpStr8, &list, &s5);
+	wpDblListPushBack(WpStr8, &list, &s1);
+	wpDblListPushBack(WpStr8, &list, &s2);
+	wpDblListPushBack(WpStr8, &list, &s3);
+	wpDblListPushBack(WpStr8, &list, &s4);
+	wpDblListPushBack(WpStr8, &list, &s5);
 
-	WpStr8 *node = wapp_dbl_list_get(WpStr8, &list, 0);
+	WpStr8 *node = wpDblListGet(WpStr8, &list, 0);
 	result = node == &s1 && wpStr8Equal(node, &s1);
 
-	node   = wapp_dbl_list_get(WpStr8, &list, 1);
+	node   = wpDblListGet(WpStr8, &list, 1);
 	result = result && node == &s2 && wpStr8Equal(node, &s2);
 
-	node   = wapp_dbl_list_get(WpStr8, &list, 2);
+	node   = wpDblListGet(WpStr8, &list, 2);
 	result = result && node == &s3 && wpStr8Equal(node, &s3);
 
-	node   = wapp_dbl_list_get(WpStr8, &list, 3);
+	node   = wpDblListGet(WpStr8, &list, 3);
 	result = result && node == &s4 && wpStr8Equal(node, &s4);
 
-	node   = wapp_dbl_list_get(WpStr8, &list, 4);
+	node   = wpDblListGet(WpStr8, &list, 4);
 	result = result && node == &s5 && wpStr8Equal(node, &s5);
 
 	return wpTesterResult(result);
@@ -43,15 +43,15 @@ WpTestFuncResult test_str8_list_push_front(void) {
 	WpStr8 s2 = wpStr8Lit("2");
 	WpStr8 s3 = wpStr8Lit("3");
 
-	WpStr8List list = wapp_dbl_list(WpStr8);
+	WpStr8List list = wpDblList(WpStr8);
 
-	wapp_dbl_list_push_front(WpStr8, &list, &s1);
+	wpDblListPushFront(WpStr8, &list, &s1);
 	result = list.first == list.last && list.first->item == &s1 && wpStr8ListTotalSize(&list) == 1 && list.node_count == 1;
 
-	wapp_dbl_list_push_front(WpStr8, &list, &s2);
+	wpDblListPushFront(WpStr8, &list, &s2);
 	result = result && list.first->item == &s2 && wpStr8ListTotalSize(&list) == 2 && list.node_count == 2;
 
-	wapp_dbl_list_push_front(WpStr8, &list, &s3);
+	wpDblListPushFront(WpStr8, &list, &s3);
 	result = result && list.first->item == &s3 && wpStr8ListTotalSize(&list) == 3 && list.node_count == 3;
 
 	return wpTesterResult(result);
@@ -64,15 +64,15 @@ WpTestFuncResult test_str8_list_push_back(void) {
 	WpStr8 s2 = wpStr8Lit("2");
 	WpStr8 s3 = wpStr8Lit("3");
 
-	WpStr8List list = wapp_dbl_list(WpStr8);
+	WpStr8List list = wpDblList(WpStr8);
 
-	wapp_dbl_list_push_back(WpStr8, &list, &s1);
+	wpDblListPushBack(WpStr8, &list, &s1);
 	result = list.first == list.last && list.last->item == &s1 && wpStr8ListTotalSize(&list) == 1 && list.node_count == 1;
 
-	wapp_dbl_list_push_back(WpStr8, &list, &s2);
+	wpDblListPushBack(WpStr8, &list, &s2);
 	result = result && list.last->item == &s2 && wpStr8ListTotalSize(&list) == 2 && list.node_count == 2;
 
-	wapp_dbl_list_push_back(WpStr8, &list, &s3);
+	wpDblListPushBack(WpStr8, &list, &s3);
 	result = result && list.last->item == &s3 && wpStr8ListTotalSize(&list) == 3 && list.node_count == 3;
 
 	return wpTesterResult(result);
@@ -89,20 +89,20 @@ WpTestFuncResult test_str8_list_insert(void) {
 	WpStr8 s6 = wpStr8Lit("6");
 	WpStr8 s7 = wpStr8Lit("7");
 
-	WpStr8List list = wapp_dbl_list(WpStr8);
+	WpStr8List list = wpDblList(WpStr8);
 
-	wapp_dbl_list_push_back(WpStr8, &list, &s1);
-	wapp_dbl_list_push_back(WpStr8, &list, &s2);
-	wapp_dbl_list_push_back(WpStr8, &list, &s3);
-	wapp_dbl_list_push_back(WpStr8, &list, &s4);
-	wapp_dbl_list_push_back(WpStr8, &list, &s5);
+	wpDblListPushBack(WpStr8, &list, &s1);
+	wpDblListPushBack(WpStr8, &list, &s2);
+	wpDblListPushBack(WpStr8, &list, &s3);
+	wpDblListPushBack(WpStr8, &list, &s4);
+	wpDblListPushBack(WpStr8, &list, &s5);
 
 	WpStr8 *node;
-	wapp_dbl_list_insert(WpStr8, &list, &s6, 2);
-	node    = wapp_dbl_list_get(WpStr8, &list, 2);
+	wpDblListInsert(WpStr8, &list, &s6, 2);
+	node    = wpDblListGet(WpStr8, &list, 2);
 	result  = node != NULL && node == &s6 && wpStr8ListTotalSize(&list) == 6 && list.node_count == 6;
-	wapp_dbl_list_insert(WpStr8, &list, &s7, 5);
-	node    = wapp_dbl_list_get(WpStr8, &list, 5);
+	wpDblListInsert(WpStr8, &list, &s7, 5);
+	node    = wpDblListGet(WpStr8, &list, 5);
 	result  = result && node != NULL && node == &s7 && wpStr8ListTotalSize(&list) == 7 && list.node_count == 7;
 
 	return wpTesterResult(result);
@@ -117,27 +117,27 @@ WpTestFuncResult test_str8_list_pop_front(void) {
 	WpStr8 s4 = wpStr8Lit("4");
 	WpStr8 s5 = wpStr8Lit("5");
 
-	WpStr8List list = wapp_dbl_list(WpStr8);
+	WpStr8List list = wpDblList(WpStr8);
 
-	wapp_dbl_list_push_back(WpStr8, &list, &s1);
-	wapp_dbl_list_push_back(WpStr8, &list, &s2);
-	wapp_dbl_list_push_back(WpStr8, &list, &s3);
-	wapp_dbl_list_push_back(WpStr8, &list, &s4);
-	wapp_dbl_list_push_back(WpStr8, &list, &s5);
+	wpDblListPushBack(WpStr8, &list, &s1);
+	wpDblListPushBack(WpStr8, &list, &s2);
+	wpDblListPushBack(WpStr8, &list, &s3);
+	wpDblListPushBack(WpStr8, &list, &s4);
+	wpDblListPushBack(WpStr8, &list, &s5);
 
-	WpStr8 *node = wapp_dbl_list_pop_front(WpStr8, &list);
+	WpStr8 *node = wpDblListPopFront(WpStr8, &list);
 	result = node == &s1 && wpStr8Equal(node, &s1) && wpStr8ListTotalSize(&list) == 4 && list.node_count == 4;
 
-	node   = wapp_dbl_list_pop_front(WpStr8, &list);
+	node   = wpDblListPopFront(WpStr8, &list);
 	result = result && node == &s2 && wpStr8Equal(node, &s2) && wpStr8ListTotalSize(&list) == 3 && list.node_count == 3;
 
-	node   = wapp_dbl_list_pop_front(WpStr8, &list);
+	node   = wpDblListPopFront(WpStr8, &list);
 	result = result && node == &s3 && wpStr8Equal(node, &s3) && wpStr8ListTotalSize(&list) == 2 && list.node_count == 2;
 
-	node   = wapp_dbl_list_pop_front(WpStr8, &list);
+	node   = wpDblListPopFront(WpStr8, &list);
 	result = result && node == &s4 && wpStr8Equal(node, &s4) && wpStr8ListTotalSize(&list) == 1 && list.node_count == 1;
 
-	node   = wapp_dbl_list_pop_front(WpStr8, &list);
+	node   = wpDblListPopFront(WpStr8, &list);
 	result = result && node == &s5 && wpStr8Equal(node, &s5) && wpStr8ListTotalSize(&list) == 0 && list.node_count == 0;
 
 	return wpTesterResult(result);
@@ -152,27 +152,27 @@ WpTestFuncResult test_str8_list_pop_back(void) {
 	WpStr8 s4 = wpStr8Lit("4");
 	WpStr8 s5 = wpStr8Lit("5");
 
-	WpStr8List list = wapp_dbl_list(WpStr8);
+	WpStr8List list = wpDblList(WpStr8);
 
-	wapp_dbl_list_push_front(WpStr8, &list, &s1);
-	wapp_dbl_list_push_front(WpStr8, &list, &s2);
-	wapp_dbl_list_push_front(WpStr8, &list, &s3);
-	wapp_dbl_list_push_front(WpStr8, &list, &s4);
-	wapp_dbl_list_push_front(WpStr8, &list, &s5);
+	wpDblListPushFront(WpStr8, &list, &s1);
+	wpDblListPushFront(WpStr8, &list, &s2);
+	wpDblListPushFront(WpStr8, &list, &s3);
+	wpDblListPushFront(WpStr8, &list, &s4);
+	wpDblListPushFront(WpStr8, &list, &s5);
 
-	WpStr8 *node = wapp_dbl_list_pop_back(WpStr8, &list);
+	WpStr8 *node = wpDblListPopBack(WpStr8, &list);
 	result = node == &s1 && wpStr8Equal(node, &s1) && wpStr8ListTotalSize(&list) == 4 && list.node_count == 4;
 
-	node   = wapp_dbl_list_pop_back(WpStr8, &list);
+	node   = wpDblListPopBack(WpStr8, &list);
 	result = result && node == &s2 && wpStr8Equal(node, &s2) && wpStr8ListTotalSize(&list) == 3 && list.node_count == 3;
 
-	node   = wapp_dbl_list_pop_back(WpStr8, &list);
+	node   = wpDblListPopBack(WpStr8, &list);
 	result = result && node == &s3 && wpStr8Equal(node, &s3) && wpStr8ListTotalSize(&list) == 2 && list.node_count == 2;
 
-	node   = wapp_dbl_list_pop_back(WpStr8, &list);
+	node   = wpDblListPopBack(WpStr8, &list);
 	result = result && node == &s4 && wpStr8Equal(node, &s4) && wpStr8ListTotalSize(&list) == 1 && list.node_count == 1;
 
-	node   = wapp_dbl_list_pop_back(WpStr8, &list);
+	node   = wpDblListPopBack(WpStr8, &list);
 	result = result && node == &s5 && wpStr8Equal(node, &s5) && wpStr8ListTotalSize(&list) == 0 && list.node_count == 0;
 
 	return wpTesterResult(result);
@@ -187,27 +187,27 @@ WpTestFuncResult test_str8_list_remove(void) {
 	WpStr8 s4 = wpStr8Lit("4");
 	WpStr8 s5 = wpStr8Lit("5");
 
-	WpStr8List list = wapp_dbl_list(WpStr8);
+	WpStr8List list = wpDblList(WpStr8);
 
-	wapp_dbl_list_push_back(WpStr8, &list, &s1);
-	wapp_dbl_list_push_back(WpStr8, &list, &s2);
-	wapp_dbl_list_push_back(WpStr8, &list, &s3);
-	wapp_dbl_list_push_back(WpStr8, &list, &s4);
-	wapp_dbl_list_push_back(WpStr8, &list, &s5);
+	wpDblListPushBack(WpStr8, &list, &s1);
+	wpDblListPushBack(WpStr8, &list, &s2);
+	wpDblListPushBack(WpStr8, &list, &s3);
+	wpDblListPushBack(WpStr8, &list, &s4);
+	wpDblListPushBack(WpStr8, &list, &s5);
 
-	WpStr8 *node = wapp_dbl_list_remove(WpStr8, &list, 0);
+	WpStr8 *node = wpDblListRemove(WpStr8, &list, 0);
 	result = node == &s1 && wpStr8Equal(node, &s1) && wpStr8ListTotalSize(&list) == 4 && list.node_count == 4;
 
-	node   = wapp_dbl_list_remove(WpStr8, &list, 0);
+	node   = wpDblListRemove(WpStr8, &list, 0);
 	result = result && node == &s2 && wpStr8Equal(node, &s2) && wpStr8ListTotalSize(&list) == 3 && list.node_count == 3;
 
-	node   = wapp_dbl_list_remove(WpStr8, &list, 0);
+	node   = wpDblListRemove(WpStr8, &list, 0);
 	result = result && node == &s3 && wpStr8Equal(node, &s3) && wpStr8ListTotalSize(&list) == 2 && list.node_count == 2;
 
-	node   = wapp_dbl_list_remove(WpStr8, &list, 0);
+	node   = wpDblListRemove(WpStr8, &list, 0);
 	result = result && node == &s4 && wpStr8Equal(node, &s4) && wpStr8ListTotalSize(&list) == 1 && list.node_count == 1;
 
-	node   = wapp_dbl_list_remove(WpStr8, &list, 0);
+	node   = wpDblListRemove(WpStr8, &list, 0);
 	result = result && node == &s5 && wpStr8Equal(node, &s5) && wpStr8ListTotalSize(&list) == 0 && list.node_count == 0;
 
 	return wpTesterResult(result);
@@ -216,13 +216,13 @@ WpTestFuncResult test_str8_list_remove(void) {
 WpTestFuncResult test_str8_list_empty(void) {
 	b8 result;
 
-	WpStr8List list = wapp_dbl_list(WpStr8);
-	wapp_dbl_list_push_back(WpStr8, &list, &wpStr8Lit("Hello"));
-	wapp_dbl_list_push_back(WpStr8, &list, &wpStr8Lit("from"));
-	wapp_dbl_list_push_back(WpStr8, &list, &wpStr8Lit("wizapp"));
-	wapp_dbl_list_push_back(WpStr8, &list, &wpStr8Lit("stdlib"));
+	WpStr8List list = wpDblList(WpStr8);
+	wpDblListPushBack(WpStr8, &list, &wpStr8Lit("Hello"));
+	wpDblListPushBack(WpStr8, &list, &wpStr8Lit("from"));
+	wpDblListPushBack(WpStr8, &list, &wpStr8Lit("wizapp"));
+	wpDblListPushBack(WpStr8, &list, &wpStr8Lit("stdlib"));
 
-	wapp_dbl_list_empty(WpStr8, &list);
+	wpDblListEmpty(WpStr8, &list);
 
 	result = list.first == NULL && list.last == NULL && list.node_count == 0 && wpStr8ListTotalSize(&list) == 0;
 

tests/str8/test_str8_list.cc

@@ -10,27 +10,27 @@ WpTestFuncResult test_str8_list_get(void) {
 	WpStr8 s4 = wpStr8Lit("4");
 	WpStr8 s5 = wpStr8Lit("5");
 
-	WpStr8List list = wapp_dbl_list(WpStr8);
+	WpStr8List list = wpDblList(WpStr8);
 
-	wapp_dbl_list_push_back(WpStr8, &list, &s1);
-	wapp_dbl_list_push_back(WpStr8, &list, &s2);
-	wapp_dbl_list_push_back(WpStr8, &list, &s3);
-	wapp_dbl_list_push_back(WpStr8, &list, &s4);
-	wapp_dbl_list_push_back(WpStr8, &list, &s5);
+	wpDblListPushBack(WpStr8, &list, &s1);
+	wpDblListPushBack(WpStr8, &list, &s2);
+	wpDblListPushBack(WpStr8, &list, &s3);
+	wpDblListPushBack(WpStr8, &list, &s4);
+	wpDblListPushBack(WpStr8, &list, &s5);
 
-	WpStr8 *node = wapp_dbl_list_get(WpStr8, &list, 0);
+	WpStr8 *node = wpDblListGet(WpStr8, &list, 0);
 	result = node == &s1 && wpStr8Equal(node, &s1);
 
-	node   = wapp_dbl_list_get(WpStr8, &list, 1);
+	node   = wpDblListGet(WpStr8, &list, 1);
 	result = result && node == &s2 && wpStr8Equal(node, &s2);
 
-	node   = wapp_dbl_list_get(WpStr8, &list, 2);
+	node   = wpDblListGet(WpStr8, &list, 2);
 	result = result && node == &s3 && wpStr8Equal(node, &s3);
 
-	node   = wapp_dbl_list_get(WpStr8, &list, 3);
+	node   = wpDblListGet(WpStr8, &list, 3);
 	result = result && node == &s4 && wpStr8Equal(node, &s4);
 
-	node   = wapp_dbl_list_get(WpStr8, &list, 4);
+	node   = wpDblListGet(WpStr8, &list, 4);
 	result = result && node == &s5 && wpStr8Equal(node, &s5);
 
 	return wpTesterResult(result);
@@ -43,15 +43,15 @@ WpTestFuncResult test_str8_list_push_front(void) {
 	WpStr8 s2 = wpStr8Lit("2");
 	WpStr8 s3 = wpStr8Lit("3");
 
-	WpStr8List list = wapp_dbl_list(WpStr8);
+	WpStr8List list = wpDblList(WpStr8);
 
-	wapp_dbl_list_push_front(WpStr8, &list, &s1);
+	wpDblListPushFront(WpStr8, &list, &s1);
 	result = list.first == list.last && list.first->item == &s1 && wpStr8ListTotalSize(&list) == 1 && list.node_count == 1;
 
-	wapp_dbl_list_push_front(WpStr8, &list, &s2);
+	wpDblListPushFront(WpStr8, &list, &s2);
 	result = result && list.first->item == &s2 && wpStr8ListTotalSize(&list) == 2 && list.node_count == 2;
 
-	wapp_dbl_list_push_front(WpStr8, &list, &s3);
+	wpDblListPushFront(WpStr8, &list, &s3);
 	result = result && list.first->item == &s3 && wpStr8ListTotalSize(&list) == 3 && list.node_count == 3;
 
 	return wpTesterResult(result);
@@ -64,15 +64,15 @@ WpTestFuncResult test_str8_list_push_back(void) {
 	WpStr8 s2 = wpStr8Lit("2");
 	WpStr8 s3 = wpStr8Lit("3");
 
-	WpStr8List list = wapp_dbl_list(WpStr8);
+	WpStr8List list = wpDblList(WpStr8);
 
-	wapp_dbl_list_push_back(WpStr8, &list, &s1);
+	wpDblListPushBack(WpStr8, &list, &s1);
 	result = list.first == list.last && list.last->item == &s1 && wpStr8ListTotalSize(&list) == 1 && list.node_count == 1;
 
-	wapp_dbl_list_push_back(WpStr8, &list, &s2);
+	wpDblListPushBack(WpStr8, &list, &s2);
 	result = result && list.last->item == &s2 && wpStr8ListTotalSize(&list) == 2 && list.node_count == 2;
 
-	wapp_dbl_list_push_back(WpStr8, &list, &s3);
+	wpDblListPushBack(WpStr8, &list, &s3);
 	result = result && list.last->item == &s3 && wpStr8ListTotalSize(&list) == 3 && list.node_count == 3;
 
 	return wpTesterResult(result);
@@ -89,20 +89,20 @@ WpTestFuncResult test_str8_list_insert(void) {
 	WpStr8 s6 = wpStr8Lit("6");
 	WpStr8 s7 = wpStr8Lit("7");
 
-	WpStr8List list = wapp_dbl_list(WpStr8);
+	WpStr8List list = wpDblList(WpStr8);
 
-	wapp_dbl_list_push_back(WpStr8, &list, &s1);
-	wapp_dbl_list_push_back(WpStr8, &list, &s2);
-	wapp_dbl_list_push_back(WpStr8, &list, &s3);
-	wapp_dbl_list_push_back(WpStr8, &list, &s4);
-	wapp_dbl_list_push_back(WpStr8, &list, &s5);
+	wpDblListPushBack(WpStr8, &list, &s1);
+	wpDblListPushBack(WpStr8, &list, &s2);
+	wpDblListPushBack(WpStr8, &list, &s3);
+	wpDblListPushBack(WpStr8, &list, &s4);
+	wpDblListPushBack(WpStr8, &list, &s5);
 
 	WpStr8 *node;
-	wapp_dbl_list_insert(WpStr8, &list, &s6, 2);
-	node   = wapp_dbl_list_get(WpStr8, &list, 2);
+	wpDblListInsert(WpStr8, &list, &s6, 2);
+	node   = wpDblListGet(WpStr8, &list, 2);
 	result = node != NULL && node == &s6 && wpStr8ListTotalSize(&list) == 6 && list.node_count == 6;
-	wapp_dbl_list_insert(WpStr8, &list, &s7, 5);
-	node   = wapp_dbl_list_get(WpStr8, &list, 5);
+	wpDblListInsert(WpStr8, &list, &s7, 5);
+	node   = wpDblListGet(WpStr8, &list, 5);
 	result = result && node != NULL && node == &s7 && wpStr8ListTotalSize(&list) == 7 && list.node_count == 7;
 
 	return wpTesterResult(result);
@@ -117,27 +117,27 @@ WpTestFuncResult test_str8_list_pop_front(void) {
 	WpStr8 s4 = wpStr8Lit("4");
 	WpStr8 s5 = wpStr8Lit("5");
 
-	WpStr8List list = wapp_dbl_list(WpStr8);
+	WpStr8List list = wpDblList(WpStr8);
 
-	wapp_dbl_list_push_back(WpStr8, &list, &s1);
-	wapp_dbl_list_push_back(WpStr8, &list, &s2);
-	wapp_dbl_list_push_back(WpStr8, &list, &s3);
-	wapp_dbl_list_push_back(WpStr8, &list, &s4);
-	wapp_dbl_list_push_back(WpStr8, &list, &s5);
+	wpDblListPushBack(WpStr8, &list, &s1);
+	wpDblListPushBack(WpStr8, &list, &s2);
+	wpDblListPushBack(WpStr8, &list, &s3);
+	wpDblListPushBack(WpStr8, &list, &s4);
+	wpDblListPushBack(WpStr8, &list, &s5);
 
-	WpStr8 *node = wapp_dbl_list_pop_front(WpStr8, &list);
+	WpStr8 *node = wpDblListPopFront(WpStr8, &list);
 	result = node == &s1 && wpStr8Equal(node, &s1) && wpStr8ListTotalSize(&list) == 4 && list.node_count == 4;
 
-	node   = wapp_dbl_list_pop_front(WpStr8, &list);
+	node   = wpDblListPopFront(WpStr8, &list);
 	result = result && node == &s2 && wpStr8Equal(node, &s2) && wpStr8ListTotalSize(&list) == 3 && list.node_count == 3;
 
-	node   = wapp_dbl_list_pop_front(WpStr8, &list);
+	node   = wpDblListPopFront(WpStr8, &list);
 	result = result && node == &s3 && wpStr8Equal(node, &s3) && wpStr8ListTotalSize(&list) == 2 && list.node_count == 2;
 
-	node   = wapp_dbl_list_pop_front(WpStr8, &list);
+	node   = wpDblListPopFront(WpStr8, &list);
 	result = result && node == &s4 && wpStr8Equal(node, &s4) && wpStr8ListTotalSize(&list) == 1 && list.node_count == 1;
 
-	node   = wapp_dbl_list_pop_front(WpStr8, &list);
+	node   = wpDblListPopFront(WpStr8, &list);
 	result = result && node == &s5 && wpStr8Equal(node, &s5) && wpStr8ListTotalSize(&list) == 0 && list.node_count == 0;
 
 	return wpTesterResult(result);
@@ -152,27 +152,27 @@ WpTestFuncResult test_str8_list_pop_back(void) {
 	WpStr8 s4 = wpStr8Lit("4");
 	WpStr8 s5 = wpStr8Lit("5");
 
-	WpStr8List list = wapp_dbl_list(WpStr8);
+	WpStr8List list = wpDblList(WpStr8);
 
-	wapp_dbl_list_push_front(WpStr8, &list, &s1);
-	wapp_dbl_list_push_front(WpStr8, &list, &s2);
-	wapp_dbl_list_push_front(WpStr8, &list, &s3);
-	wapp_dbl_list_push_front(WpStr8, &list, &s4);
-	wapp_dbl_list_push_front(WpStr8, &list, &s5);
+	wpDblListPushFront(WpStr8, &list, &s1);
+	wpDblListPushFront(WpStr8, &list, &s2);
+	wpDblListPushFront(WpStr8, &list, &s3);
+	wpDblListPushFront(WpStr8, &list, &s4);
+	wpDblListPushFront(WpStr8, &list, &s5);
 
-	WpStr8 *node = wapp_dbl_list_pop_back(WpStr8, &list);
+	WpStr8 *node = wpDblListPopBack(WpStr8, &list);
 	result = node == &s1 && wpStr8Equal(node, &s1) && wpStr8ListTotalSize(&list) == 4 && list.node_count == 4;
 
-	node   = wapp_dbl_list_pop_back(WpStr8, &list);
+	node   = wpDblListPopBack(WpStr8, &list);
 	result = result && node == &s2 && wpStr8Equal(node, &s2) && wpStr8ListTotalSize(&list) == 3 && list.node_count == 3;
 
-	node   = wapp_dbl_list_pop_back(WpStr8, &list);
+	node   = wpDblListPopBack(WpStr8, &list);
 	result = result && node == &s3 && wpStr8Equal(node, &s3) && wpStr8ListTotalSize(&list) == 2 && list.node_count == 2;
 
-	node   = wapp_dbl_list_pop_back(WpStr8, &list);
+	node   = wpDblListPopBack(WpStr8, &list);
 	result = result && node == &s4 && wpStr8Equal(node, &s4) && wpStr8ListTotalSize(&list) == 1 && list.node_count == 1;
 
-	node   = wapp_dbl_list_pop_back(WpStr8, &list);
+	node   = wpDblListPopBack(WpStr8, &list);
 	result = result && node == &s5 && wpStr8Equal(node, &s5) && wpStr8ListTotalSize(&list) == 0 && list.node_count == 0;
 
 	return wpTesterResult(result);
@@ -187,27 +187,27 @@ WpTestFuncResult test_str8_list_remove(void) {
 	WpStr8 s4 = wpStr8Lit("4");
 	WpStr8 s5 = wpStr8Lit("5");
 
-	WpStr8List list = wapp_dbl_list(WpStr8);
+	WpStr8List list = wpDblList(WpStr8);
 
-	wapp_dbl_list_push_back(WpStr8, &list, &s1);
-	wapp_dbl_list_push_back(WpStr8, &list, &s2);
-	wapp_dbl_list_push_back(WpStr8, &list, &s3);
-	wapp_dbl_list_push_back(WpStr8, &list, &s4);
-	wapp_dbl_list_push_back(WpStr8, &list, &s5);
+	wpDblListPushBack(WpStr8, &list, &s1);
+	wpDblListPushBack(WpStr8, &list, &s2);
+	wpDblListPushBack(WpStr8, &list, &s3);
+	wpDblListPushBack(WpStr8, &list, &s4);
+	wpDblListPushBack(WpStr8, &list, &s5);
 
-	WpStr8 *node = wapp_dbl_list_remove(WpStr8, &list, 0);
+	WpStr8 *node = wpDblListRemove(WpStr8, &list, 0);
 	result = node == &s1 && wpStr8Equal(node, &s1) && wpStr8ListTotalSize(&list) == 4 && list.node_count == 4;
 
-	node   = wapp_dbl_list_remove(WpStr8, &list, 0);
+	node   = wpDblListRemove(WpStr8, &list, 0);
 	result = result && node == &s2 && wpStr8Equal(node, &s2) && wpStr8ListTotalSize(&list) == 3 && list.node_count == 3;
 
-	node   = wapp_dbl_list_remove(WpStr8, &list, 0);
+	node   = wpDblListRemove(WpStr8, &list, 0);
 	result = result && node == &s3 && wpStr8Equal(node, &s3) && wpStr8ListTotalSize(&list) == 2 && list.node_count == 2;
 
-	node   = wapp_dbl_list_remove(WpStr8, &list, 0);
+	node   = wpDblListRemove(WpStr8, &list, 0);
 	result = result && node == &s4 && wpStr8Equal(node, &s4) && wpStr8ListTotalSize(&list) == 1 && list.node_count == 1;
 
-	node   = wapp_dbl_list_remove(WpStr8, &list, 0);
+	node   = wpDblListRemove(WpStr8, &list, 0);
 	result = result && node == &s5 && wpStr8Equal(node, &s5) && wpStr8ListTotalSize(&list) == 0 && list.node_count == 0;
 
 	return wpTesterResult(result);
@@ -216,21 +216,21 @@ WpTestFuncResult test_str8_list_remove(void) {
 WpTestFuncResult test_str8_list_empty(void) {
 	b8 result;
 
-	WpStr8List list = wapp_dbl_list(WpStr8);
+	WpStr8List list = wpDblList(WpStr8);
 
 	WpStr8 hello = wpStr8Lit("Hello");
-	wapp_dbl_list_push_back(WpStr8, &list, &hello);
+	wpDblListPushBack(WpStr8, &list, &hello);
 
 	WpStr8 from = wpStr8Lit("from");
-	wapp_dbl_list_push_back(WpStr8, &list, &from);
+	wpDblListPushBack(WpStr8, &list, &from);
 
 	WpStr8 wizapp = wpStr8Lit("wizapp");
-	wapp_dbl_list_push_back(WpStr8, &list, &wizapp);
+	wpDblListPushBack(WpStr8, &list, &wizapp);
 
 	WpStr8 stdlib = wpStr8Lit("stdlib");
-	wapp_dbl_list_push_back(WpStr8, &list, &stdlib);
+	wpDblListPushBack(WpStr8, &list, &stdlib);
 
-	wapp_dbl_list_empty(WpStr8, &list);
+	wpDblListEmpty(WpStr8, &list);
 
 	result = list.first == NULL && list.last == NULL && list.node_count == 0 && wpStr8ListTotalSize(&list) == 0;