INITIAL COMMIT

wapp/os/allocators/arena/mem_arena.c

@@ -0,0 +1,192 @@
+// vim:fileencoding=utf-8:foldmethod=marker
+
+#include "mem_arena.h"
+#include "../../mem/mem_os.h"
+#include "../../../common/aliases/aliases.h"
+#include "../../../common/assert/assert.h"
+#include "../../../common/misc/misc_utils.h"
+#include "../../../base/mem/utils/mem_utils.h"
+#include <string.h>
+
+#ifndef DEFAULT_ALIGNMENT
+// Why 2 * sizeof(void *) instead of sizeof(void *)
+// https://handmade.network/forums/t/6860-alignment_arena_allocator
+#define DEFAULT_ALIGNMENT (2 * sizeof(void *))
+#endif /* ifndef DEFAULT_ALIGNMENT */
+
+#define ARENA_MINIMUM_CAPACITY KiB(16) // Allocate minimum of 4 pages
+
+typedef enum {
+	ARENA_STORAGE_TYPE_ALLOCATED,
+	ARENA_STORAGE_TYPE_BUFFER,
+} ArenaStorageType;
+
+struct Arena {
+	u8 *buf;
+	u8 *offset;
+	u8 *prev_offset;
+	u64 capacity;
+	ArenaStorageType type;
+	b8 committed;
+
+	wapp_misc_utils_reserve_padding(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)) {
+		return false;
+	}
+
+	*arena           = (Arena *)buffer;
+	Arena *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->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) {
+	if (!arena || *arena || base_capacity == 0) {
+		return false;
+	}
+
+	u64 size       = sizeof(Arena) + (base_capacity >= ARENA_MINIMUM_CAPACITY ? base_capacity : ARENA_MINIMUM_CAPACITY);
+	u64 alloc_size = wapp_misc_utils_u64_round_up_pow2(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);
+	if (!allocated) {
+		return false;
+	}
+
+	b8 committed = (flags & WAPP_MEM_ALLOC_COMMIT) == WAPP_MEM_ALLOC_COMMIT;
+
+#ifdef WAPP_PLATFORM_WINDOWS
+	if (!committed) {
+		wapp_os_mem_alloc(allocated, sizeof(Arena), WAPP_MEM_ACCESS_READ_WRITE, WAPP_MEM_ALLOC_COMMIT,
+		                  WAPP_MEM_INIT_INITIALISED);
+	}
+#endif // ifdef WAPP_PLATFORM_WINDOWS
+
+	if (!wapp_mem_arena_init_buffer(arena, allocated, alloc_size)) {
+		wapp_mem_arena_destroy(arena);
+		return false;
+	}
+
+	Arena *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 *wapp_mem_arena_alloc_aligned(Arena *arena, u64 size, u64 alignment) {
+	wapp_debug_assert(arena != NULL, "`arena` should not be NULL");
+
+	u8 *alloc_start = arena->offset;
+
+	u8 *output = wapp_mem_util_align_forward((void *)alloc_start, alignment);
+	if (output + size >= arena->buf + arena->capacity) {
+		return NULL;
+	}
+
+	arena->offset = output + size;
+
+#ifdef WAPP_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);
+	}
+#endif // ifdef WAPP_PLATFORM_WINDOWS
+
+	memset(output, 0, size);
+
+	return (void *)output;
+}
+
+void *wapp_mem_arena_realloc(Arena *arena, void *ptr, u64 old_size, u64 new_size) {
+	wapp_debug_assert(arena != NULL, "`arena` should not be NULL");
+
+	if ((u8*)ptr < arena->buf || (u8*)ptr > arena->offset ||
+		  arena->offset + new_size >= arena->buf + arena->capacity) {
+		return NULL;
+	}
+
+	void *new_ptr = wapp_mem_arena_alloc(arena, new_size);
+	if (!new_ptr) {
+		return NULL;
+	}
+
+	u64 copy_size = new_size <= old_size ? new_size : old_size;
+	memcpy(new_ptr, ptr, copy_size);
+
+	return new_ptr;
+}
+
+void *wapp_mem_arena_realloc_aligned(Arena *arena, void *ptr, u64 old_size, u64 new_size, u64 alignment) {
+	wapp_debug_assert(arena != NULL, "`arena` should not be NULL");
+
+	if ((u8*)ptr < arena->buf || (u8*)ptr > arena->offset ||
+		  arena->offset + new_size >= arena->buf + arena->capacity) {
+		return NULL;
+	}
+
+	void *new_ptr = wapp_mem_arena_alloc_aligned(arena, new_size, alignment);
+	if (!new_ptr) {
+		return NULL;
+	}
+
+	u64 copy_size = new_size <= old_size ? new_size : old_size;
+	memcpy(new_ptr, ptr, copy_size);
+
+	return new_ptr;
+}
+
+void wapp_mem_arena_temp_begin(Arena *arena) {
+	wapp_debug_assert(arena != NULL, "`arena` should not be NULL");
+
+	if (arena->prev_offset != NULL) {
+		return;
+	}
+
+	arena->prev_offset = arena->offset;
+}
+
+void wapp_mem_arena_temp_end(Arena *arena) {
+	wapp_debug_assert(arena != NULL, "`arena` should not be NULL");
+
+	if (arena->prev_offset == NULL) {
+		return;
+	}
+
+	arena->offset      = arena->prev_offset;
+	arena->prev_offset = NULL;
+}
+
+void wapp_mem_arena_clear(Arena *arena) {
+	wapp_debug_assert(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) {
+	wapp_debug_assert(arena != NULL && (*arena) != NULL, "`arena` double pointer is not valid");
+
+	Arena *arena_ptr = *arena;
+
+	if (arena_ptr->type == ARENA_STORAGE_TYPE_ALLOCATED) {
+		wapp_os_mem_free(*arena, sizeof(Arena) + arena_ptr->capacity);
+	}
+
+	*arena = NULL;
+}

wapp/os/allocators/arena/mem_arena.h

@@ -0,0 +1,45 @@
+// vim:fileencoding=utf-8:foldmethod=marker
+
+#ifndef MEM_ARENA_H
+#define MEM_ARENA_H
+
+#include "../../mem/mem_os.h"
+#include "../../../common/aliases/aliases.h"
+#include "../../../common/platform/platform.h"
+
+#ifdef WAPP_PLATFORM_CPP
+BEGIN_C_LINKAGE
+#endif // !WAPP_PLATFORM_CPP
+
+typedef struct Arena Arena;
+
+#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))
+
+/**
+ * Arena initialisation function. `wapp_mem_arena_init_allocated_custom` provides the most
+ * control over how the Arena 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);
+
+#ifdef WAPP_PLATFORM_CPP
+END_C_LINKAGE
+#endif // !WAPP_PLATFORM_CPP
+
+#endif // !MEM_ARENA_H

wapp/os/allocators/arena/mem_arena_allocator.c

@@ -0,0 +1,87 @@
+// vim:fileencoding=utf-8:foldmethod=marker
+
+#include "mem_arena_allocator.h"
+#include "mem_arena.h"
+#include "../../mem/mem_os.h"
+#include "../../../common/aliases/aliases.h"
+#include "../../../common/assert/assert.h"
+
+wapp_intern void initialise_arena_allocator(Allocator *allocator);
+wapp_intern void *mem_arena_alloc(u64 size, void *alloc_obj);
+wapp_intern void *mem_arena_alloc_aligned(u64 size, u64 alignment, void *alloc_obj);
+wapp_intern void *mem_arena_realloc(void *ptr, u64 old_size, u64 new_size, void *alloc_obj);
+wapp_intern void *mem_arena_realloc_aligned(void *ptr, u64 old_size, u64 new_size, u64 alignment,
+                                            void *alloc_obj);
+
+Allocator wapp_mem_arena_allocator_init_with_buffer(u8 *buffer, u64 buffer_size) {
+	Allocator allocator = {0};
+	b8 initialised = wapp_mem_arena_init_buffer((Arena **)(&allocator.obj), buffer, buffer_size);
+	if (!initialised) {
+		return allocator;
+	}
+
+	initialise_arena_allocator(&allocator);
+
+	return allocator;
+}
+
+Allocator wapp_mem_arena_allocator_init_custom(u64 base_capacity, MemAllocFlags flags, b8 zero_buffer) {
+	Allocator allocator = {0};
+	b8 initialised = wapp_mem_arena_init_allocated_custom((Arena **)(&allocator.obj), base_capacity, flags, zero_buffer);
+	if (!initialised) {
+		return allocator;
+	}
+
+	initialise_arena_allocator(&allocator);
+
+	return allocator;
+}
+
+void wapp_mem_arena_allocator_temp_begin(const Allocator *allocator) {
+	wapp_debug_assert(allocator != NULL, "`allocator` should not be NULL");
+	wapp_mem_arena_temp_begin((Arena *)(allocator->obj));
+}
+
+void wapp_mem_arena_allocator_temp_end(const Allocator *allocator) {
+	wapp_debug_assert(allocator != NULL, "`allocator` should not be NULL");
+	wapp_mem_arena_temp_end((Arena *)(allocator->obj));
+}
+
+void wapp_mem_arena_allocator_clear(Allocator *allocator) {
+	wapp_debug_assert(allocator != NULL, "`allocator` should not be NULL");
+	wapp_mem_arena_clear((Arena *)(allocator->obj));
+}
+
+void wapp_mem_arena_allocator_destroy(Allocator *allocator) {
+	wapp_debug_assert(allocator != NULL, "`allocator` should not be NULL");
+	wapp_mem_arena_destroy((Arena **)(&(allocator->obj)));
+	*allocator = (Allocator){0};
+}
+
+wapp_intern void initialise_arena_allocator(Allocator *allocator) {
+	allocator->alloc           = mem_arena_alloc;
+	allocator->alloc_aligned   = mem_arena_alloc_aligned;
+	allocator->realloc         = mem_arena_realloc;
+	allocator->realloc_aligned = mem_arena_realloc_aligned;
+}
+
+wapp_intern void *mem_arena_alloc(u64 size, void *alloc_obj) {
+	Arena *arena = (Arena *)alloc_obj;
+	return wapp_mem_arena_alloc(arena, size);
+}
+
+wapp_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);
+}
+
+wapp_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);
+}
+
+wapp_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);
+}

wapp/os/allocators/arena/mem_arena_allocator.h

@@ -0,0 +1,46 @@
+// vim:fileencoding=utf-8:foldmethod=marker
+
+#ifndef MEM_ARENA_ALLOCATOR_H
+#define MEM_ARENA_ALLOCATOR_H
+
+#include "../../mem/mem_os.h"
+#include "../../../common/aliases/aliases.h"
+#include "../../../common/platform/platform.h"
+#include "../../../base/mem/allocator/mem_allocator.h"
+
+#ifdef WAPP_PLATFORM_CPP
+BEGIN_C_LINKAGE
+#endif // !WAPP_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))
+
+/**
+ * Wraps an Arena in an Allocator object. It attempts to initialise the Arena
+ * and, if successful, defines the operations supported by it to be used by the
+ * Allocator.
+ *
+ * An Arena 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.
+ */
+Allocator wapp_mem_arena_allocator_init_custom(u64 base_capacity, MemAllocFlags flags, b8 zero_buffer);
+Allocator wapp_mem_arena_allocator_init_with_buffer(u8 *buffer, u64 buffer_size);
+void      wapp_mem_arena_allocator_temp_begin(const Allocator *allocator);
+void      wapp_mem_arena_allocator_temp_end(const Allocator *allocator);
+void      wapp_mem_arena_allocator_clear(Allocator *allocator);
+void      wapp_mem_arena_allocator_destroy(Allocator *allocator);
+
+#ifdef WAPP_PLATFORM_CPP
+END_C_LINKAGE
+#endif // !WAPP_PLATFORM_CPP
+
+#endif // !MEM_ARENA_ALLOCATOR_H

wapp/os/cpath/cpath.c

@@ -0,0 +1,136 @@
+// vim:fileencoding=utf-8:foldmethod=marker
+
+#include "cpath.h"
+#include "../allocators/arena/mem_arena_allocator.h"
+#include "../../common/aliases/aliases.h"
+#include "../../common/misc/misc_utils.h"
+#include "../../base/dbl_list/dbl_list.h"
+#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(Str8 *dst, const Str8List *parts) {
+	if (!dst || !parts) {
+		return CPATH_JOIN_INVALID_ARGS;
+	}
+
+	if (parts->node_count == 0) {
+		return CPATH_JOIN_EMPTY_PARTS;
+	}
+
+	Str8 separator = wapp_str8_buf(4);
+	wapp_str8_push_back(&separator, WAPP_PATH_SEP);
+
+	u64 required_capacity = parts->node_count * separator.size + wapp_str8_list_total_size(parts);
+	if (dst->capacity < required_capacity) {
+		return CPATH_JOIN_INSUFFICIENT_DST_CAPACITY;
+	}
+
+	// Handle first node
+	Str8 *first_node = wapp_dbl_list_get(Str8, parts, 0);
+	wapp_str8_copy_str8_capped(dst, first_node);
+
+	// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
+	// MSVC Spectre mitigation warnings
+	Str8 *node       = first_node;
+	u64 node_index   = 1;
+	b8 running       = node_index < parts->node_count;
+	while (running) {
+		node = wapp_dbl_list_get(Str8, parts, node_index);
+		if (node->size == 0) {
+			goto CPATH_JOIN_LOOP_END;
+		}
+
+		if (dst->size > 0) {
+			char dst_last   = wapp_str8_get(dst, dst->size - 1);
+			char node_start = wapp_str8_get(node, 0);
+			b8 add_path_sep = dst_last != WAPP_PATH_SEP && node_start != WAPP_PATH_SEP;
+
+			if (add_path_sep) {
+				wapp_str8_concat_capped(dst, &separator);
+			}
+		}
+
+		wapp_str8_concat_capped(dst, node);
+
+CPATH_JOIN_LOOP_END:
+		++node_index;
+		running = node_index < parts->node_count;
+	}
+
+	return CPATH_JOIN_SUCCESS;
+}
+
+Str8 *dirup(const Allocator *allocator, Str8RO *path, u64 levels) {
+	Str8 *output = NULL;
+	if (!allocator || !path) {
+		goto RETURN_DIRUP;
+	}
+
+	b8 absolute    = wapp_str8_get(path, 0) == WAPP_PATH_SEP;
+	Str8 separator = wapp_str8_buf(4);
+	wapp_str8_push_back(&separator, WAPP_PATH_SEP);
+
+	if (path->size == 0) {
+		output = wapp_str8_alloc_buf(allocator, 16);
+		if (!output) {
+			goto RETURN_DIRUP;
+		}
+
+		wapp_str8_push_back(output, absolute ? WAPP_PATH_SEP : '.');
+		goto RETURN_DIRUP;
+	}
+
+	if (levels < 1) {
+		output = wapp_str8_alloc_str8(allocator, path);
+		goto RETURN_DIRUP;
+	}
+
+	Allocator tmp_arena = wapp_mem_arena_allocator_init(MiB(8));
+	if (wapp_mem_allocator_invalid(&tmp_arena)) {
+		goto RETURN_DIRUP;
+	}
+
+	Str8List *parts = wapp_str8_split(&tmp_arena, path, &separator);
+	if (!parts) {
+		goto RETURN_DIRUP;
+	}
+
+	if (levels >= parts->node_count) {
+		output = wapp_str8_alloc_buf(allocator, 16);
+		if (!output) {
+			goto LIST_CLEANUP_DIRUP;
+		}
+
+		wapp_str8_push_back(output, absolute ? WAPP_PATH_SEP : '.');
+	} else {
+		for (u64 i = 0; i < levels; ++i) {
+			wapp_dbl_list_pop_back(Str8, parts);
+		}
+		
+		u64 alignment  = sizeof(void *) * 2;
+		u64 alloc_size = wapp_str8_list_total_size(parts) + parts->node_count * separator.size;
+		u64 modulo     = alloc_size & (alignment - 1);
+		alloc_size    += alignment - modulo;
+
+		output = wapp_str8_alloc_buf(allocator, alloc_size);
+		if (output) {
+			if (absolute) {
+				wapp_str8_push_back(output, WAPP_PATH_SEP);
+			}
+
+			Str8 *joined = wapp_str8_join(&tmp_arena, parts, &separator);
+			if (joined) {
+				wapp_str8_concat_capped(output, joined);
+			}
+		}
+	}
+
+LIST_CLEANUP_DIRUP:
+	wapp_mem_arena_allocator_destroy(&tmp_arena);
+
+RETURN_DIRUP:
+	return output;
+}

wapp/os/cpath/cpath.h

@@ -0,0 +1,45 @@
+// vim:fileencoding=utf-8:foldmethod=marker
+
+#ifndef CPATH_H
+#define CPATH_H
+
+#include "../../common/aliases/aliases.h"
+#include "../../common/platform/platform.h"
+#include "../../base/mem/allocator/mem_allocator.h"
+#include "../../base/strings/str8/str8.h"
+
+#ifdef WAPP_PLATFORM_CPP
+BEGIN_C_LINKAGE
+#endif // !WAPP_PLATFORM_CPP
+
+#ifdef WAPP_PLATFORM_POSIX
+#include <limits.h>
+#define WAPP_PATH_SEP '/'
+#define WAPP_PATH_MAX PATH_MAX
+#elif defined(WAPP_PLATFORM_WINDOWS)
+#define WIN32_LEAN_AND_MEAN
+#include <Windows.h>
+#define WAPP_PATH_SEP '\\'
+#define WAPP_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)
+
+enum {
+	CPATH_JOIN_SUCCESS = 0,
+	CPATH_JOIN_INVALID_ARGS,
+	CPATH_JOIN_EMPTY_PARTS,
+	CPATH_JOIN_INSUFFICIENT_DST_CAPACITY,
+};
+
+u32   wapp_cpath_join_path(Str8 *dst, const Str8List *parts);
+Str8 *dirup(const Allocator *allocator, Str8RO *path, u64 levels);
+
+#ifdef WAPP_PLATFORM_CPP
+END_C_LINKAGE
+#endif // !WAPP_PLATFORM_CPP
+
+#endif // !CPATH_H

wapp/os/file/file.c

@@ -0,0 +1,129 @@
+// vim:fileencoding=utf-8:foldmethod=marker
+
+#include "file.h"
+#include "../cpath/cpath.h"
+#include "../../common/assert/assert.h"
+#include "../../common/aliases/aliases.h"
+#include "../../base/array/array.h"
+#include "../../base/strings/str8/str8.h"
+
+WFile *wapp_file_open(const Allocator *allocator, Str8RO *filepath, FileAccessMode mode) {
+	wapp_debug_assert(allocator != NULL && filepath != NULL, "`allocator` and `filepath` should not be NULL");
+	wapp_debug_assert(filepath->size < WAPP_PATH_MAX, "`filepath` exceeds max path limit.");
+	return _file_open(allocator, filepath, mode);
+}
+
+i64 wapp_file_get_current_position(WFile *file) {
+	wapp_debug_assert(file != NULL, "`file` should not be NULL.");
+	return _file_seek(file, 0, WAPP_SEEK_CURRENT);
+}
+
+i64 wapp_file_seek(WFile *file, i64 offset, FileSeekOrigin origin) {
+	wapp_debug_assert(file != NULL, "`file` should not be NULL.");
+	return _file_seek(file, offset, origin);
+}
+
+i64 wapp_file_get_length(WFile *file) {
+	wapp_debug_assert(file != NULL, "`file` should not be NULL.");
+
+	i64 current = wapp_file_get_current_position(file);
+
+	_file_seek(file, 0, WAPP_SEEK_END);
+
+	i64 output = wapp_file_get_current_position(file);
+
+	// Restore position
+	_file_seek(file, current, WAPP_SEEK_START);
+
+	return output;
+}
+
+u64 wapp_file_read(void *dst_buf, WFile *file, u64 byte_count) {
+	wapp_debug_assert(dst_buf != NULL && file != NULL,
+	                  "`dst_buf` and `file` should not be NULL.");
+
+	i64 file_length = wapp_file_get_length(file);
+	if (file_length < 0) {
+		return 0;
+	}
+
+	return _file_read(dst_buf, byte_count, file, file_length);
+}
+
+i64 wapp_file_write(const void *src_buf, WFile *file, u64 byte_count) {
+	wapp_debug_assert(src_buf != NULL && file != NULL,
+	                  "`src_buf` and `file` should not be NULL.");
+	return _file_write(src_buf, file, byte_count);
+}
+
+u64 wapp_file_read_array(GenericArray dst_buf, WFile *file, u64 item_count) {
+	wapp_debug_assert(dst_buf != NULL && file != NULL,
+	                  "`dst_buf` and `file` should not be NULL.");
+
+	i64 _file_length = wapp_file_get_length(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 req_byte_count    = item_count * item_size;
+	u64 copy_byte_count   = 0;
+
+	if (req_byte_count <= file_length && req_byte_count <= dst_byte_capacity) {
+		copy_byte_count = req_byte_count;
+	} else {
+		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);
+	if (byte_count == 0) {
+		return 0;
+	}
+
+	wapp_array_set_count(dst_buf, byte_count / item_size);
+
+	return wapp_array_count(dst_buf);
+}
+
+i64 wapp_file_write_array(const GenericArray src_buf, WFile *file, u64 item_count) {
+	wapp_debug_assert(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 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);
+	if (bytes_written < 0) {
+		return 0;
+	}
+
+	return (u64)bytes_written / item_size;
+}
+
+i32 wapp_file_flush(WFile *file) {
+	wapp_debug_assert(file != NULL, "`file` should not be NULL.");
+	return _file_flush(file);
+}
+
+i32 wapp_file_close(WFile *file) {
+	wapp_debug_assert(file != NULL, "`file` should not be NULL.");
+	return _file_close(file);
+}
+
+i32 wapp_file_rename(Str8RO *old_filepath, Str8RO *new_filepath) {
+	wapp_debug_assert(old_filepath != NULL && new_filepath != NULL,
+	                  "`old_filepath` and `new_filepath` should not be NULL");
+	wapp_debug_assert(old_filepath->size < WAPP_PATH_MAX, "`old_filepath` exceeds max path limit.");
+	wapp_debug_assert(new_filepath->size < WAPP_PATH_MAX, "`new_filepath` exceeds max path limit.");
+	return _file_rename(old_filepath, new_filepath);
+}
+
+i32 wapp_file_remove(Str8RO *filepath) {
+	wapp_debug_assert(filepath != NULL, "`filepath` should not be NULL");
+	wapp_debug_assert(filepath->size < WAPP_PATH_MAX, "`filepath` exceeds max path limit.");
+	return _file_remove(filepath);
+}

wapp/os/file/file.h

@@ -0,0 +1,75 @@
+// vim:fileencoding=utf-8:foldmethod=marker
+
+#ifndef FILE_H
+#define FILE_H
+
+#include "../../base/mem/allocator/mem_allocator.h"
+#include "../../common/aliases/aliases.h"
+#include "../../base/strings/str8/str8.h"
+
+#ifdef WAPP_PLATFORM_CPP
+BEGIN_C_LINKAGE
+#endif // !WAPP_PLATFORM_CPP
+
+typedef struct WFile WFile;
+
+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+
+
+	FILE_ACCESS_MODE_COUNT,
+} FileAccessMode;
+
+typedef enum {
+	WAPP_SEEK_START,
+	WAPP_SEEK_CURRENT,
+	WAPP_SEEK_END,
+
+	FILE_SEEK_ORIGIN_COUNT,
+} FileSeekOrigin;
+
+// 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
+wapp_extern WFile *wapp_file_stdin(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
+wapp_extern WFile *wapp_file_stdout(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
+wapp_extern WFile *wapp_file_stderr(void);
+
+WFile *wapp_file_open(const Allocator *allocator, Str8RO *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_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(Str8RO *old_filepath, Str8RO *new_filepath);
+i32    wapp_file_remove(Str8RO *filepath);
+
+wapp_extern WFile *_file_open(const Allocator *allocator, Str8RO *filepath, FileAccessMode mode);
+wapp_extern i64    _file_seek(WFile *file, i64 offset, FileSeekOrigin origin);
+wapp_extern u64    _file_read(void *dst_buf, u64 byte_count, WFile *file, u64 file_length);
+wapp_extern i64    _file_write(const void *src_buf, WFile *file, u64 byte_count);
+wapp_extern i32    _file_flush(WFile *file);
+wapp_extern i32    _file_close(WFile *file);
+wapp_extern i32    _file_rename(Str8RO *old_filepath, Str8RO *new_filepath);
+wapp_extern i32    _file_remove(Str8RO *filepath);
+
+#ifdef WAPP_PLATFORM_CPP
+END_C_LINKAGE
+#endif // !WAPP_PLATFORM_CPP
+
+#endif // !FILE_H

wapp/os/file/posix/file_posix.c

@@ -0,0 +1,134 @@
+// vim:fileencoding=utf-8:foldmethod=marker
+
+#include "file_posix.h"
+#include "../../../common/platform/platform.h"
+
+#ifdef WAPP_PLATFORM_POSIX
+
+#include "../file.h"
+#include "../../cpath/cpath.h"
+#include "../../../common/aliases/aliases.h"
+#include "../../../base/array/array.h"
+#include "../../../base/strings/str8/str8.h"
+
+#ifdef WAPP_PLATFORM_APPLE
+#define _FILE_OFFSET_BITS 64
+#define lseek64 lseek
+#endif // !WAPP_PLATFORM_APPLE
+
+#define __USE_LARGEFILE64
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/types.h>
+
+wapp_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,
+};
+
+wapp_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,
+};
+
+wapp_intern i32 file_seek_origins[FILE_SEEK_ORIGIN_COUNT] = {
+	[WAPP_SEEK_START]   = SEEK_SET,
+	[WAPP_SEEK_CURRENT] = SEEK_CUR,
+	[WAPP_SEEK_END]     = SEEK_END,
+};
+
+WFile *wapp_file_stdin(void) {
+	wapp_persist WFile _stdin  = { .fd = STDIN_FILENO };
+	return &_stdin;
+}
+
+WFile *wapp_file_stdout(void) {
+	wapp_persist WFile _stdout = { .fd = STDOUT_FILENO };
+	return &_stdout;
+}
+
+WFile *wapp_file_stderr(void) {
+	wapp_persist WFile _stderr = { .fd = STDERR_FILENO };
+	return &_stderr;
+}
+
+WFile *_file_open(const Allocator *allocator, Str8RO *filepath, FileAccessMode mode) {
+	wapp_persist c8 tmp[WAPP_PATH_MAX] = {0};
+	memset(tmp, 0, WAPP_PATH_MAX);
+	memcpy(tmp, filepath->buf, filepath->size);
+
+	i32 fd = open((const char *)tmp, file_flags[mode], file_modes[mode]);
+	if (fd < 0) {
+		return NULL;
+	}
+
+	WFile *output = wapp_mem_allocator_alloc(allocator, sizeof(WFile));
+	if (output) {
+		output->fd = fd;
+	}
+
+	return output;
+}
+
+i64 _file_seek(WFile *file, i64 offset, FileSeekOrigin 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 copy_byte_count = file_length <= byte_count ? file_length : byte_count;
+
+	i64 count = read(file->fd, dst_buf, copy_byte_count);
+	if (count < 0) { return 0; }
+
+	return count;
+}
+
+i64 _file_write(const void *src_buf, WFile *file, u64 byte_count) {
+	return write(file->fd, src_buf, byte_count);
+}
+
+i32 _file_flush(WFile *file) {
+	return fsync(file->fd);
+}
+
+i32 _file_close(WFile *file) {
+	return close(file->fd);
+}
+
+i32 _file_rename(Str8RO *old_filepath, Str8RO *new_filepath) {
+	wapp_persist c8 old_tmp[WAPP_PATH_MAX] = {0};
+	wapp_persist c8 new_tmp[WAPP_PATH_MAX] = {0};
+	memset(old_tmp, 0, WAPP_PATH_MAX);
+	memcpy(old_tmp, old_filepath->buf, old_filepath->size);
+	memset(new_tmp, 0, WAPP_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);
+	}
+
+	return link_result;
+}
+
+i32 _file_remove(Str8RO *filepath) {
+	wapp_persist c8 tmp[WAPP_PATH_MAX] = {0};
+	memset(tmp, 0, WAPP_PATH_MAX);
+	memcpy(tmp, filepath->buf, filepath->size);
+
+	return unlink((const char *)tmp);
+}
+
+#endif // !WAPP_PLATFORM_POSIX

wapp/os/file/posix/file_posix.h

@@ -0,0 +1,27 @@
+// vim:fileencoding=utf-8:foldmethod=marker
+
+#ifndef FILE_POSIX_H
+#define FILE_POSIX_H
+
+#include "../../../common/aliases/aliases.h"
+#include "../../../common/platform/platform.h"
+
+#ifdef WAPP_PLATFORM_CPP
+BEGIN_C_LINKAGE
+#endif // !WAPP_PLATFORM_CPP
+
+#ifdef WAPP_PLATFORM_POSIX
+
+#define END_OF_LINE "\n"
+
+struct WFile {
+	i32 fd;
+};
+
+#endif // !WAPP_PLATFORM_POSIX
+
+#ifdef WAPP_PLATFORM_CPP
+END_C_LINKAGE
+#endif // !WAPP_PLATFORM_CPP
+
+#endif // !FILE_POSIX_H

wapp/os/file/win/file_win.c

@@ -0,0 +1,177 @@
+// vim:fileencoding=utf-8:foldmethod=marker
+
+#include "file_win.h"
+#include "../../../common/platform/platform.h"
+
+#ifdef WAPP_PLATFORM_WINDOWS
+
+#include "../file.h"
+#include "../../cpath/cpath.h"
+#include "../../../common/aliases/aliases.h"
+#include "../../../base/array/array.h"
+#include "../../../base/strings/str8/str8.h"
+#define WIN32_LEAN_AND_MEAN
+#include <Windows.h>
+#include <fileapi.h>
+#include <intsafe.h>
+
+wapp_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,
+};
+
+wapp_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,
+};
+
+wapp_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,
+};
+
+wapp_intern DWORD file_seek_origins[FILE_SEEK_ORIGIN_COUNT] = {
+	[WAPP_SEEK_START]   = FILE_BEGIN,
+	[WAPP_SEEK_CURRENT] = FILE_CURRENT,
+	[WAPP_SEEK_END]     = FILE_END,
+};
+
+WFile *wapp_file_stdin(void) {
+	wapp_persist WFile _stdin  = { .fh = INVALID_HANDLE_VALUE };
+	_stdin.fh = GetStdHandle(STD_INPUT_HANDLE);
+	return &_stdin;
+}
+
+WFile *wapp_file_stdout(void) {
+	wapp_persist WFile _stdout = { .fh = INVALID_HANDLE_VALUE };
+	_stdout.fh = GetStdHandle(STD_OUTPUT_HANDLE);
+	return &_stdout;
+}
+
+WFile *wapp_file_stderr(void) {
+	wapp_persist WFile _stderr = { .fh = INVALID_HANDLE_VALUE };
+	_stderr.fh = GetStdHandle(STD_ERROR_HANDLE);
+	return &_stderr;
+}
+
+WFile *_file_open(const Allocator *allocator, Str8RO *filepath, FileAccessMode mode) {
+	wapp_persist c8 tmp[WAPP_PATH_MAX] = {0};
+	memset(tmp, 0, WAPP_PATH_MAX);
+	memcpy(tmp, filepath->buf, filepath->size);
+
+	HANDLE fh = CreateFileA((LPCSTR)tmp,
+	                        file_accesses[mode],
+	                        sharing_modes[mode],
+	                        NULL,
+	                        creation_dispositions[mode],
+	                        FILE_ATTRIBUTE_NORMAL,
+	                        NULL);
+	if (fh == INVALID_HANDLE_VALUE) {
+		return NULL;
+	}
+
+	WFile *output = wapp_mem_allocator_alloc(allocator, sizeof(WFile));
+	if (output) {
+		output->fh = fh;
+	}
+
+	return output;
+}
+
+i64 _file_seek(WFile *file, i64 offset, FileSeekOrigin origin) {
+	LARGE_INTEGER distance = {0};
+	LARGE_INTEGER output   = {0};
+
+	distance.QuadPart = offset;
+
+	if (!SetFilePointerEx(file->fh, distance, &output, file_seek_origins[origin])) {
+		return -1;
+	}
+
+	return output.QuadPart;
+}
+
+u64 _file_read(void* dst_buf, u64 byte_count, WFile* file, u64 file_length) {
+	u64 copy_byte_count = file_length <= byte_count ? file_length : byte_count;
+	wapp_debug_assert(copy_byte_count <= DWORD_MAX, "Attempting to read large number of bytes at once");
+
+	DWORD read_count = 0;
+	if (!ReadFile(file->fh, dst_buf, (DWORD)copy_byte_count, &read_count, NULL)) {
+		return 0;
+	}
+
+	return (u64)read_count;
+}
+
+i64 _file_write(const void *src_buf, WFile *file, u64 byte_count) {
+	wapp_debug_assert(byte_count <= DWORD_MAX, "Attempting to write large number of bytes at once");
+
+	DWORD write_count = 0;
+	if (!WriteFile(file->fh, src_buf, (DWORD)byte_count, &write_count, NULL)) {
+		return 0;
+	}
+	return (i64)write_count;
+}
+
+i32 _file_flush(WFile *file) {
+	if (!FlushFileBuffers(file->fh)) {
+		return -1;
+	}
+
+	return 0;
+}
+
+i32 _file_close(WFile *file) {
+	if (!CloseHandle(file->fh)) {
+		return -1;
+	}
+
+	return 0;
+}
+
+i32 _file_rename(Str8RO *old_filepath, Str8RO *new_filepath) {
+	wapp_persist c8 old_tmp[WAPP_PATH_MAX] = {0};
+	wapp_persist c8 new_tmp[WAPP_PATH_MAX] = {0};
+	memset(old_tmp, 0, WAPP_PATH_MAX);
+	memcpy(old_tmp, old_filepath->buf, old_filepath->size);
+	memset(new_tmp, 0, WAPP_PATH_MAX);
+	memcpy(new_tmp, new_filepath->buf, new_filepath->size);
+
+	if (!MoveFile((LPCSTR)old_tmp, (LPCSTR)new_tmp)) {
+		return -1;
+	}
+
+	return 0;
+}
+
+i32 _file_remove(Str8RO *filepath) {
+	wapp_persist c8 tmp[WAPP_PATH_MAX] = {0};
+	memset(tmp, 0, WAPP_PATH_MAX);
+	memcpy(tmp, filepath->buf, filepath->size);
+
+	if (!DeleteFile((LPCSTR)tmp)) {
+		return -1;
+	}
+
+	return 0;
+}
+
+#endif // !WAPP_PLATFORM_WINDOWS

wapp/os/file/win/file_win.h

@@ -0,0 +1,31 @@
+// vim:fileencoding=utf-8:foldmethod=marker
+
+#ifndef FILE_WIN_H
+#define FILE_WIN_H
+
+#include "../../../common/aliases/aliases.h"
+#include "../../../common/platform/platform.h"
+
+#ifdef WAPP_PLATFORM_CPP
+BEGIN_C_LINKAGE
+#endif // !WAPP_PLATFORM_CPP
+
+#ifdef WAPP_PLATFORM_WINDOWS
+
+#define END_OF_LINE "\r\n"
+
+#define WIN32_LEAN_AND_MEAN
+#include <Windows.h>
+#include <fileapi.h>
+
+struct WFile {
+	HANDLE fh;
+};
+
+#endif // !WAPP_PLATFORM_WINDOWS
+
+#ifdef WAPP_PLATFORM_CPP
+END_C_LINKAGE
+#endif // !WAPP_PLATFORM_CPP
+
+#endif // !FILE_WIN_H

wapp/os/mem/mem_os.c

@@ -0,0 +1,30 @@
+// vim:fileencoding=utf-8:foldmethod=marker
+
+#include "mem_os.h"
+#include "mem_os_ops.h"
+#include "../../common/aliases/aliases.h"
+#include "../../common/platform/platform.h"
+#include <assert.h>
+#include <string.h>
+
+#if defined(WAPP_PLATFORM_WINDOWS)
+#include "win/mem_os_win.h"
+#elif defined(WAPP_PLATFORM_POSIX)
+#include "posix/mem_os_posix.h"
+#else
+#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);
+
+	if (type == WAPP_MEM_INIT_INITIALISED) {
+		memset(output, 0, size);
+	}
+
+	return output;
+}
+
+void wapp_os_mem_free(void *ptr, u64 size) {
+	os_mem_free(ptr, size);
+}

wapp/os/mem/mem_os.h

@@ -0,0 +1,33 @@
+// vim:fileencoding=utf-8:foldmethod=marker
+
+#ifndef MEM_OS_H
+#define MEM_OS_H
+
+#include "../../common/aliases/aliases.h"
+#include "../../common/platform/platform.h"
+
+#include "mem_os_ops.h"
+
+#ifdef WAPP_PLATFORM_CPP
+BEGIN_C_LINKAGE
+#endif // !WAPP_PLATFORM_CPP
+
+#if defined(WAPP_PLATFORM_WINDOWS)
+#include "win/mem_os_win.h"
+#elif defined(WAPP_PLATFORM_POSIX)
+#include "posix/mem_os_posix.h"
+#else
+#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);
+
+wapp_extern void *os_mem_allocate(void *addr, u64 size, MemAccess access, MemAllocFlags flags, MemInitType type);
+wapp_extern void os_mem_free(void *ptr, u64 size);
+
+#ifdef WAPP_PLATFORM_CPP
+END_C_LINKAGE
+#endif // !WAPP_PLATFORM_CPP
+
+#endif // !MEM_OS_H

wapp/os/mem/mem_os_ops.h

@@ -0,0 +1,30 @@
+// vim:fileencoding=utf-8:foldmethod=marker
+
+#ifndef MEM_OS_OPS_H
+#define MEM_OS_OPS_H
+
+#include "../../common/platform/platform.h"
+
+#ifdef WAPP_PLATFORM_CPP
+BEGIN_C_LINKAGE
+#endif // !WAPP_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 mem_init_type {
+	WAPP_MEM_INIT_UNINITIALISED,
+	WAPP_MEM_INIT_INITIALISED,
+} MemInitType;
+
+#ifdef WAPP_PLATFORM_CPP
+END_C_LINKAGE
+#endif // !WAPP_PLATFORM_CPP
+
+#endif // !MEM_OS_OPS_H

wapp/os/mem/posix/mem_os_posix.c

@@ -0,0 +1,36 @@
+// vim:fileencoding=utf-8:foldmethod=marker
+
+#include "../../../common/aliases/aliases.h"
+#include "../../../common/platform/platform.h"
+
+#ifdef WAPP_PLATFORM_POSIX
+
+#include "mem_os_posix.h"
+#include "../mem_os_ops.h"
+#include <sys/mman.h>
+
+wapp_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,
+};
+
+void *os_mem_allocate(void *addr, u64 size, MemAccess access, MemAllocFlags flags, MemInitType type) {
+	(void)type;
+	i32 alloc_flags = flags | MAP_ANON | MAP_PRIVATE;
+
+#if defined(WAPP_PLATFORM_LINUX) || defined(WAPP_PLATFORM_GNU) || defined(WAPP_PLATFORM_NET_BSD)
+	alloc_flags |= MAP_NORESERVE;
+#endif
+
+	return mmap(addr, size, access_types[access], alloc_flags, -1, 0);
+}
+
+void os_mem_free(void *ptr, u64 size) {
+	munmap(ptr, size);
+}
+
+#endif // !WAPP_PLATFORM_POSIX

wapp/os/mem/posix/mem_os_posix.h

@@ -0,0 +1,35 @@
+// vim:fileencoding=utf-8:foldmethod=marker
+
+#ifndef MEM_OS_POSIX_H
+#define MEM_OS_POSIX_H
+
+#include "../../../common/platform/platform.h"
+
+#ifdef WAPP_PLATFORM_CPP
+BEGIN_C_LINKAGE
+#endif // !WAPP_PLATFORM_CPP
+
+#ifdef WAPP_PLATFORM_POSIX
+
+#include <sys/mman.h>
+
+typedef enum mem_alloc_flags {
+#if defined(WAPP_PLATFORM_LINUX) || defined(WAPP_PLATFORM_GNU)
+	WAPP_MEM_ALLOC_RESERVE = 0,
+	WAPP_MEM_ALLOC_COMMIT  = MAP_POPULATE,
+#elif defined(WAPP_PLATFORM_FREE_BSD)
+	WAPP_MEM_ALLOC_RESERVE = 0,
+	WAPP_MEM_ALLOC_COMMIT  = MAP_PREFAULT_READ,
+#elif defined(WAPP_PLATFORM_BSD) || defined(WAPP_PLATFORM_UNIX) || defined(WAPP_PLATFORM_APPLE)
+	WAPP_MEM_ALLOC_RESERVE = 0,
+	WAPP_MEM_ALLOC_COMMIT  = 0,
+#endif
+} MemAllocFlags;
+
+#endif // !WAPP_PLATFORM_POSIX
+
+#ifdef WAPP_PLATFORM_CPP
+END_C_LINKAGE
+#endif // !WAPP_PLATFORM_CPP
+
+#endif // !MEM_OS_POSIX_H

wapp/os/mem/win/mem_os_win.c

@@ -0,0 +1,37 @@
+// vim:fileencoding=utf-8:foldmethod=marker
+
+#include "../../../common/aliases/aliases.h"
+#include "../../../common/platform/platform.h"
+
+#ifdef WAPP_PLATFORM_WINDOWS
+
+#include "mem_os_win.h"
+#include "../mem_os_ops.h"
+
+#define WIN32_LEAN_AND_MEAN
+#include <Windows.h>
+#include <memoryapi.h>
+
+wapp_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,
+};
+
+void *os_mem_allocate(void *addr, u64 size, MemAccess access, MemAllocFlags flags, MemInitType type) {
+	// Ensure memory is committed if it's meant to be initialised
+	if (type == WAPP_MEM_INIT_INITIALISED) {
+		flags |= WAPP_MEM_ALLOC_COMMIT;
+	}
+
+	return VirtualAlloc(addr, (SIZE_T)size, flags, access_types[access]);
+}
+
+void os_mem_free(void *ptr, u64 size) {
+	VirtualFree(ptr, size, MEM_RELEASE);
+}
+
+#endif // !WAPP_PLATFORM_WINDOWS

wapp/os/mem/win/mem_os_win.h

@@ -0,0 +1,29 @@
+// vim:fileencoding=utf-8:foldmethod=marker
+
+#ifndef MEM_OS_WIN_H
+#define MEM_OS_WIN_H
+
+#include "../../../common/platform/platform.h"
+
+#ifdef WAPP_PLATFORM_CPP
+BEGIN_C_LINKAGE
+#endif // !WAPP_PLATFORM_CPP
+
+#ifdef WAPP_PLATFORM_WINDOWS
+
+#define WIN32_LEAN_AND_MEAN
+#include <Windows.h>
+#include <memoryapi.h>
+
+typedef enum mem_alloc_flags {
+	WAPP_MEM_ALLOC_RESERVE = MEM_RESERVE,
+	WAPP_MEM_ALLOC_COMMIT  = MEM_COMMIT,
+} MemAllocFlags;
+
+#endif // !WAPP_PLATFORM_WINDOWS
+
+#ifdef WAPP_PLATFORM_CPP
+END_C_LINKAGE
+#endif // !WAPP_PLATFORM_CPP
+
+#endif // !MEM_OS_WIN_H

wapp/os/shell/commander/commander.c

@@ -0,0 +1,101 @@
+// vim:fileencoding=utf-8:foldmethod=marker
+
+#include "commander.h"
+#include "commander_output.h"
+#include "../utils/shell_utils.h"
+#include "../../allocators/arena/mem_arena_allocator.h"
+#include "../../../common/aliases/aliases.h"
+#include "../../../common/misc/misc_utils.h"
+#include "../../../base/dbl_list/dbl_list.h"
+#include "../../../base/mem/allocator/mem_allocator.h"
+#include "../../../base/strings/str8/str8.h"
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define CMD_BUF_LEN 8192
+#define OUT_BUF_LEN 4096
+
+wapp_intern CMDResult execute_command(Str8RO *cmd, CMDOutHandling out_handling, Str8 *out_buf);
+wapp_intern CMDError get_command_output(FILE *fp, CMDOutHandling out_handling, Str8 *out_buf);
+
+CMDResult wapp_shell_commander_execute(CMDOutHandling out_handling, Str8 *out_buf, const Str8List *cmd) {
+	if (!cmd) {
+		return CMD_NO_EXIT(SHELL_ERR_INVALID_ARGS);
+	}
+
+	Allocator arena = wapp_mem_arena_allocator_init(KiB(500));
+
+	Str8 *cmd_str = wapp_str8_join(&arena, cmd, &wapp_str8_lit_ro(" "));
+	if (!cmd_str) {
+		wapp_mem_arena_allocator_destroy(&arena);
+		return CMD_NO_EXIT(SHELL_ERR_ALLOCATION_FAIL);
+	}
+
+	// Redirect output
+	cmd_str = wapp_str8_alloc_concat(&arena, cmd_str, &wapp_str8_lit_ro(" 2>&1"));
+
+	CMDResult output = execute_command(cmd_str, out_handling, out_buf);
+
+	wapp_mem_arena_allocator_destroy(&arena);
+
+	return output;
+}
+
+wapp_intern CMDResult execute_command(Str8RO *cmd, CMDOutHandling out_handling, Str8 *out_buf) {
+	char cmd_buf[CMD_BUF_LEN] = {0};
+	wapp_str8_copy_to_cstr(cmd_buf, cmd, CMD_BUF_LEN);
+
+	FILE *fp = wapp_shell_utils_popen(cmd_buf, "r");
+	if (!fp) {
+		return CMD_NO_EXIT(SHELL_ERR_PROC_START_FAIL);
+	}
+
+	CMDResult 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;
+	}
+
+	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;
+	}
+
+	// Process is already closed in get_output_status
+	fp = NULL;
+
+	output = (CMDResult){
+		.exited    = true,
+		.exit_code = st,
+		.error     = SHELL_ERR_NO_ERROR,
+	};
+
+EXECUTE_COMMAND_CLOSE:
+	if (fp) {
+		wapp_shell_utils_pclose(fp);
+	}
+	return output;
+}
+
+wapp_intern CMDError get_command_output(FILE *fp, CMDOutHandling out_handling, Str8 *out_buf) {
+	Str8 out = wapp_str8_buf(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.size >= out_buf->capacity) {
+			return SHELL_ERR_OUT_BUF_FULL;
+		}
+
+		wapp_str8_concat_capped(out_buf, &out);
+	} else if (out_handling == SHELL_OUTPUT_PRINT) {
+		printf(WAPP_STR8_SPEC, wapp_str8_varg(out));
+	}
+
+	return SHELL_ERR_NO_ERROR;
+}

wapp/os/shell/commander/commander.h

@@ -0,0 +1,29 @@
+// vim:fileencoding=utf-8:foldmethod=marker
+
+#ifndef COMMANDER_H
+#define COMMANDER_H
+
+#include "commander_output.h"
+#include "../../../common/aliases/aliases.h"
+#include "../../../common/platform/platform.h"
+#include "../../../base/strings/str8/str8.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+// TODO (Abdelrahman): This module needs rethinking
+
+#ifdef WAPP_PLATFORM_CPP
+BEGIN_C_LINKAGE
+#endif // !WAPP_PLATFORM_CPP
+
+#define CMD_NO_EXIT(ERR) ((CMDResult){.exited = false, .exit_code = EXIT_FAILURE, .error = ERR})
+
+CMDResult wapp_shell_commander_execute(CMDOutHandling out_handling, Str8 *out_buf, const Str8List *cmd);
+
+wapp_extern CMDError get_output_status(FILE *fp, i32 *status_out);
+
+#ifdef WAPP_PLATFORM_CPP
+END_C_LINKAGE
+#endif // !WAPP_PLATFORM_CPP
+
+#endif // !COMMANDER_H

wapp/os/shell/commander/commander_output.h

@@ -0,0 +1,42 @@
+// vim:fileencoding=utf-8:foldmethod=marker
+
+#ifndef COMMANDER_OUTPUT_H
+#define COMMANDER_OUTPUT_H
+
+#include "../../../common/aliases/aliases.h"
+#include "../../../common/platform/platform.h"
+#include "../../../common/misc/misc_utils.h"
+
+#ifdef WAPP_PLATFORM_CPP
+BEGIN_C_LINKAGE
+#endif // !WAPP_PLATFORM_CPP
+
+typedef enum {
+	SHELL_OUTPUT_DISCARD,
+	SHELL_OUTPUT_PRINT,
+	SHELL_OUTPUT_CAPTURE,
+} CMDOutHandling;
+
+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;
+
+typedef struct CMDResult CMDResult;
+struct CMDResult {
+	i32 exit_code;
+	CMDError error;
+	b8 exited;
+
+	wapp_misc_utils_reserve_padding(sizeof(b8) + sizeof(i32) + sizeof(CMDError));
+};
+
+#ifdef WAPP_PLATFORM_CPP
+END_C_LINKAGE
+#endif // !WAPP_PLATFORM_CPP
+
+#endif // !COMMANDER_OUTPUT_H

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

@@ -0,0 +1,25 @@
+// vim:fileencoding=utf-8:foldmethod=marker
+
+#include "../../../../common/aliases/aliases.h"
+#include "../../../../common/platform/platform.h"
+
+#ifdef WAPP_PLATFORM_POSIX
+
+#include "../commander_output.h"
+#include "../../utils/shell_utils.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+CMDError get_output_status(FILE *fp, i32 *status_out) {
+	*status_out = wapp_shell_utils_pclose(fp);
+
+	if (!WIFEXITED(*status_out)) {
+		return SHELL_ERR_PROC_EXIT_FAIL;
+	}
+
+	*status_out = WEXITSTATUS(*status_out);
+
+	return SHELL_ERR_NO_ERROR;
+}
+
+#endif // !WAPP_PLATFORM_POSIX

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

@@ -0,0 +1,24 @@
+// vim:fileencoding=utf-8:foldmethod=marker
+
+#include "../../../../common/aliases/aliases.h"
+#include "../../../../common/platform/platform.h"
+
+#ifdef WAPP_PLATFORM_WINDOWS
+
+#include "../commander_output.h"
+#include "../../utils/shell_utils.h"
+#include <stdio.h>
+
+CMDError get_output_status(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;
+	}
+
+	*status_out = wapp_shell_utils_pclose(fp);
+
+	return SHELL_ERR_NO_ERROR;
+}
+
+#endif // !WAPP_PLATFORM_WINDOWS

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

@@ -0,0 +1,36 @@
+// vim:fileencoding=utf-8:foldmethod=marker
+
+#include "../../../../common/aliases/aliases.h"
+#include "../../../../common/platform/platform.h"
+#include "../../../../base/strings/str8/str8.h"
+
+#ifdef WAPP_PLATFORM_POSIX
+
+#include "../terminal_colours.h"
+#include <stdio.h>
+
+wapp_intern Str8RO colours[COUNT_TERM_COLOUR] = {
+	[WAPP_TERM_COLOUR_FG_BLACK]      = wapp_str8_lit_ro_initialiser_list("\033[30m"),
+	[WAPP_TERM_COLOUR_FG_RED]        = wapp_str8_lit_ro_initialiser_list("\033[31m"),
+	[WAPP_TERM_COLOUR_FG_GREEN]      = wapp_str8_lit_ro_initialiser_list("\033[32m"),
+	[WAPP_TERM_COLOUR_FG_BLUE]       = wapp_str8_lit_ro_initialiser_list("\033[34m"),
+	[WAPP_TERM_COLOUR_FG_CYAN]       = wapp_str8_lit_ro_initialiser_list("\033[36m"),
+	[WAPP_TERM_COLOUR_FG_MAGENTA]    = wapp_str8_lit_ro_initialiser_list("\033[35m"),
+	[WAPP_TERM_COLOUR_FG_YELLOW]     = wapp_str8_lit_ro_initialiser_list("\033[33m"),
+	[WAPP_TERM_COLOUR_FG_WHITE]      = wapp_str8_lit_ro_initialiser_list("\033[37m"),
+	[WAPP_TERM_COLOUR_FG_BR_BLACK]   = wapp_str8_lit_ro_initialiser_list("\033[90m"),
+	[WAPP_TERM_COLOUR_FG_BR_RED]     = wapp_str8_lit_ro_initialiser_list("\033[91m"),
+	[WAPP_TERM_COLOUR_FG_BR_GREEN]   = wapp_str8_lit_ro_initialiser_list("\033[92m"),
+	[WAPP_TERM_COLOUR_FG_BR_BLUE]    = wapp_str8_lit_ro_initialiser_list("\033[94m"),
+	[WAPP_TERM_COLOUR_FG_BR_CYAN]    = wapp_str8_lit_ro_initialiser_list("\033[96m"),
+	[WAPP_TERM_COLOUR_FG_BR_MAGENTA] = wapp_str8_lit_ro_initialiser_list("\033[95m"),
+	[WAPP_TERM_COLOUR_FG_BR_YELLOW]  = wapp_str8_lit_ro_initialiser_list("\033[93m"),
+	[WAPP_TERM_COLOUR_FG_BR_WHITE]   = wapp_str8_lit_ro_initialiser_list("\033[97m"),
+	[WAPP_TERM_COLOUR_CLEAR]         = wapp_str8_lit_ro_initialiser_list("\033[0m"),
+};
+
+void print_coloured_text(Str8RO *text, TerminalColour colour) {
+	printf(WAPP_STR8_SPEC WAPP_STR8_SPEC, wapp_str8_varg(colours[colour]), wapp_str8_varg((*text)));
+}
+
+#endif // !WAPP_PLATFORM_POSIX

wapp/os/shell/termcolour/termcolour.c

@@ -0,0 +1,18 @@
+// vim:fileencoding=utf-8:foldmethod=marker
+
+#include "termcolour.h"
+#include "terminal_colours.h"
+#include "../../../base/strings/str8/str8.h"
+
+void wapp_shell_termcolour_print_text(Str8RO *text, TerminalColour colour) {
+	if (colour < WAPP_TERM_COLOUR_FG_BLACK || colour > WAPP_TERM_COLOUR_FG_BR_WHITE) {
+		return;
+	}
+
+	print_coloured_text(text, colour);
+}
+
+void wapp_shell_termcolour_clear_colour(void) {
+	Str8RO empty = wapp_str8_lit_ro("");
+	print_coloured_text(&empty, WAPP_TERM_COLOUR_CLEAR);
+}

wapp/os/shell/termcolour/termcolour.h

@@ -0,0 +1,26 @@
+// vim:fileencoding=utf-8:foldmethod=marker
+
+#ifndef TERM_COLOUR_H
+#define TERM_COLOUR_H
+
+#include "terminal_colours.h"
+#include "../../../common/aliases/aliases.h"
+#include "../../../common/platform/platform.h"
+#include "../../../base/strings/str8/str8.h"
+
+#ifdef WAPP_PLATFORM_CPP
+BEGIN_C_LINKAGE
+#endif // !WAPP_PLATFORM_CPP
+
+// TODO (Abdelrahman): Look into moving away from stdio in the implementation
+
+void wapp_shell_termcolour_print_text(Str8RO *text, TerminalColour colour);
+void wapp_shell_termcolour_clear_colour(void);
+
+wapp_extern void print_coloured_text(Str8RO *text, TerminalColour colour);
+
+#ifdef WAPP_PLATFORM_CPP
+END_C_LINKAGE
+#endif // !WAPP_PLATFORM_CPP
+
+#endif // !TERM_COLOUR_H

wapp/os/shell/termcolour/terminal_colours.h

@@ -0,0 +1,39 @@
+// vim:fileencoding=utf-8:foldmethod=marker
+
+#ifndef TERMINAL_COLOURS_H
+#define TERMINAL_COLOURS_H
+
+#include "../../../common/aliases/aliases.h"
+#include "../../../common/platform/platform.h"
+
+#ifdef WAPP_PLATFORM_CPP
+BEGIN_C_LINKAGE
+#endif // !WAPP_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,
+
+	COUNT_TERM_COLOUR,
+} TerminalColour;
+
+#ifdef WAPP_PLATFORM_CPP
+END_C_LINKAGE
+#endif // !WAPP_PLATFORM_CPP
+
+#endif // !TERMINAL_COLOURS_H

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

@@ -0,0 +1,73 @@
+// vim:fileencoding=utf-8:foldmethod=marker
+
+#include "../../../../common/aliases/aliases.h"
+#include "../../../../common/platform/platform.h"
+#include "../../../../base/strings/str8/str8.h"
+
+#ifdef WAPP_PLATFORM_WINDOWS
+
+#include "../terminal_colours.h"
+#include "../../../../common/misc/misc_utils.h"
+#include <stdio.h>
+
+#define WIN32_LEAN_AND_MEAN
+#include <Windows.h>
+
+typedef struct TermcolourData TermcolourData;
+struct TermcolourData {
+	HANDLE handle;
+	WORD   default_colour;
+	WORD   current_colour;
+
+	wapp_misc_utils_reserve_padding(sizeof(HANDLE) + sizeof(WORD) + sizeof(WORD));
+};
+
+wapp_intern void init_data(TermcolourData *data);
+
+wapp_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,
+};
+
+void print_coloured_text(Str8RO *text, TerminalColour colour) {
+	wapp_persist TermcolourData data = {0};
+	if (data.handle == 0) {
+		init_data(&data);
+	}
+
+	if (colour == WAPP_TERM_COLOUR_CLEAR) {
+		data.current_colour = data.default_colour;
+	} else {
+		data.current_colour = colours[colour];
+	}
+
+	SetConsoleTextAttribute(data.handle, data.current_colour);
+	printf(WAPP_STR8_SPEC, wapp_str8_varg((*text)));
+}
+
+wapp_intern void init_data(TermcolourData *data) {
+	// create handle
+	data->handle = GetStdHandle(STD_OUTPUT_HANDLE);
+
+	// get console colour information
+	CONSOLE_SCREEN_BUFFER_INFO csbi;
+	GetConsoleScreenBufferInfo(data->handle, &csbi);
+	data->default_colour = csbi.wAttributes;
+	data->current_colour = data->default_colour;
+}
+
+#endif // !WAPP_PLATFORM_WINDOWS

wapp/os/shell/utils/shell_utils.h

@@ -0,0 +1,26 @@
+// vim:fileencoding=utf-8:foldmethod=marker
+
+#ifndef SHELL_UTILS_H
+#define SHELL_UTILS_H
+
+#include "../../../common/aliases/aliases.h"
+#include "../../../common/platform/platform.h"
+#include <stdio.h>
+
+#ifdef WAPP_PLATFORM_CPP
+BEGIN_C_LINKAGE
+#endif // !WAPP_PLATFORM_CPP
+
+#ifdef WAPP_PLATFORM_WINDOWS
+	#define wapp_shell_utils_popen  _popen
+	#define wapp_shell_utils_pclose _pclose
+#else
+	#define wapp_shell_utils_popen  popen
+	#define wapp_shell_utils_pclose pclose
+#endif /* ifdef WAPP_PLATFORM_WINDOWS */
+
+#ifdef WAPP_PLATFORM_CPP
+END_C_LINKAGE
+#endif // !WAPP_PLATFORM_CPP
+
+#endif // !SHELL_UTILS_H

wapp/os/wapp_os.c

@@ -0,0 +1,24 @@
+// vim:fileencoding=utf-8:foldmethod=marker
+
+#ifndef WAPP_OS_C
+#define WAPP_OS_C
+
+#include "wapp_os.h"
+#include "file/file.c"
+#include "file/posix/file_posix.c"
+#include "file/win/file_win.c"
+#include "shell/termcolour/posix/termcolour_posix.c"
+#include "shell/termcolour/win/termcolour_win.c"
+#include "shell/termcolour/termcolour.c"
+#include "shell/commander/posix/commander_posix.c"
+#include "shell/commander/win/commander_win.c"
+#include "shell/commander/commander.c"
+#include "cpath/cpath.c"
+#include "allocators/arena/mem_arena.c"
+#include "allocators/arena/mem_arena_allocator.c"
+#include "mem/posix/mem_os_posix.c"
+#include "mem/win/mem_os_win.c"
+#include "mem/mem_os.c"
+#include "../base/wapp_base.c"
+
+#endif // !WAPP_OS_C

wapp/os/wapp_os.h

@@ -0,0 +1,24 @@
+// vim:fileencoding=utf-8:foldmethod=marker
+
+#ifndef WAPP_CORE_H
+#define WAPP_CORE_H
+
+#include "file/file.h"
+#include "file/posix/file_posix.h"
+#include "file/win/file_win.h"
+#include "shell/termcolour/termcolour.h"
+#include "shell/termcolour/terminal_colours.h"
+#include "shell/commander/commander.h"
+#include "shell/commander/commander_output.h"
+#include "shell/utils/shell_utils.h"
+#include "cpath/cpath.h"
+#include "allocators/arena/mem_arena.h"
+#include "allocators/arena/mem_arena_allocator.h"
+#include "mem/posix/mem_os_posix.h"
+#include "mem/win/mem_os_win.h"
+#include "mem/mem_os_ops.h"
+#include "mem/mem_os.h"
+#include "../common/wapp_common.h"
+#include "../base/wapp_base.h"
+
+#endif // !WAPP_CORE_H