abdelrahman/wizapp-stdlib
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 17 Wiki Activity

Standardize naming conventions (#12)
Release / release (push) Successful in 8s
Details

Browse Source 
## 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>
This commit was merged in pull request #12.
This commit is contained in:
Abdelrahman Said
2026-06-26 17:17:27 +00:00
committed by Abdelrahman Said
parent ea689e7357
commit a998f6b981
89 changed files with 4081 additions and 3486 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/os/allocators/arena/mem_arena.c
+46 -46
View File
@@ -21,7 +21,7 @@ typedef enum {
ARENA_STORAGE_TYPE_BUFFER,
} ArenaStorageType;
struct Arena {
struct WpArena {
u8 *buf;
u8 *offset;
u8 *prev_offset;
@@ -29,99 +29,99 @@ struct Arena {
ArenaStorageType type;
b8 committed;
wapp_misc_utils_reserve_padding(sizeof(u8 *) * 3 + sizeof(u64) + sizeof(ArenaStorageType) + sizeof(b8));
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 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);
u64 size = sizeof(WpArena) + (base_capacity >= ARENA_MINIMUM_CAPACITY ? base_capacity : ARENA_MINIMUM_CAPACITY);
u64 alloc_size = wpMiscUtilsU64RoundUpPow2(size);
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 WAPP_PLATFORM_WINDOWS
#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 WAPP_PLATFORM_WINDOWS
#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) {
wapp_debug_assert(arena != NULL, "`arena` should not be NULL");
void *wpMemArenaAllocAligned(WpArena *arena, u64 size, u64 alignment) {
wpDebugAssert(arena != NULL, "`arena` should not be NULL");
u8 *alloc_start = arena->offset;
u8 *output = wapp_mem_util_align_forward((void *)alloc_start, alignment);
u8 *output = wpMemUtilAlignForward((void *)alloc_start, alignment);
if (output + size >= arena->buf + arena->capacity) {
return NULL;
}
arena->offset = output + size;
#ifdef WAPP_PLATFORM_WINDOWS
#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 WAPP_PLATFORM_WINDOWS
#endif // ifdef WP_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");
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 ||
arena->offset + new_size >= arena->buf + arena->capacity) {
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,15 +132,15 @@ 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) {
wapp_debug_assert(arena != NULL, "`arena` should not be NULL");
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 ||
arena->offset + new_size >= arena->buf + arena->capacity) {
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,8 +151,8 @@ 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) {
wapp_debug_assert(arena != NULL, "`arena` should not be NULL");
void wpMemArenaTempBegin(WpArena *arena) {
wpDebugAssert(arena != NULL, "`arena` should not be NULL");
if (arena->prev_offset != NULL) {
return;
@@ -161,8 +161,8 @@ void wapp_mem_arena_temp_begin(Arena *arena) {
arena->prev_offset = arena->offset;
}
void wapp_mem_arena_temp_end(Arena *arena) {
wapp_debug_assert(arena != NULL, "`arena` should not be NULL");
void wpMemArenaTempEnd(WpArena *arena) {
wpDebugAssert(arena != NULL, "`arena` should not be NULL");
if (arena->prev_offset == NULL) {
return;
@@ -172,20 +172,20 @@ void wapp_mem_arena_temp_end(Arena *arena) {
arena->prev_offset = NULL;
}
void wapp_mem_arena_clear(Arena *arena) {
wapp_debug_assert(arena != NULL, "`arena` should not be NULL");
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) {
wapp_debug_assert(arena != NULL && (*arena) != NULL, "`arena` double pointer is not valid");
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
+25 -25
View File
@@ -7,39 +7,39 @@
#include "../../../common/aliases/aliases.h"
#include "../../../common/platform/platform.h"
#ifdef WAPP_PLATFORM_CPP
#ifdef WP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WAPP_PLATFORM_CPP
#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 WAPP_PLATFORM_CPP
#ifdef WP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WAPP_PLATFORM_CPP
#endif // !WP_PLATFORM_CPP
#endif // !MEM_ARENA_H
src/os/allocators/arena/mem_arena_allocator.c
+37 -37
View File
@@ -6,16 +6,16 @@
#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,
wp_intern void initialise_arena_allocator(WpAllocator *allocator);
wp_intern void *mem_arena_alloc(u64 size, void *alloc_obj);
wp_intern void *mem_arena_alloc_aligned(u64 size, u64 alignment, void *alloc_obj);
wp_intern void *mem_arena_realloc(void *ptr, u64 old_size, u64 new_size, void *alloc_obj);
wp_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);
WpAllocator wpMemArenaAllocatorInitWithBuffer(u8 *buffer, u64 buffer_size) {
WpAllocator allocator = {0};
b8 initialised = wpMemArenaInitBuffer((WpArena **)(&allocator.obj), buffer, buffer_size);
if (!initialised) {
return allocator;
}
@@ -25,9 +25,9 @@ Allocator wapp_mem_arena_allocator_init_with_buffer(u8 *buffer, u64 buffer_size)
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);
WpAllocator wpMemArenaAllocatorInitCustom(u64 base_capacity, WpMemAllocFlags flags, b8 zero_buffer) {
WpAllocator allocator = {0};
b8 initialised = wpMemArenaInitAllocatedCustom((WpArena **)(&allocator.obj), base_capacity, flags, zero_buffer);
if (!initialised) {
return allocator;
}
@@ -37,51 +37,51 @@ Allocator wapp_mem_arena_allocator_init_custom(u64 base_capacity, MemAllocFlags
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 wpMemArenaAllocatorTempBegin(const WpAllocator *allocator) {
wpDebugAssert(allocator != NULL, "`allocator` should not be NULL");
wpMemArenaTempBegin((WpArena *)(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 wpMemArenaAllocatorTempEnd(const WpAllocator *allocator) {
wpDebugAssert(allocator != NULL, "`allocator` should not be NULL");
wpMemArenaTempEnd((WpArena *)(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 wpMemArenaAllocatorClear(WpAllocator *allocator) {
wpDebugAssert(allocator != NULL, "`allocator` should not be NULL");
wpMemArenaClear((WpArena *)(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};
void wpMemArenaAllocatorDestroy(WpAllocator *allocator) {
wpDebugAssert(allocator != NULL, "`allocator` should not be NULL");
wpMemArenaDestroy((WpArena **)(&(allocator->obj)));
*allocator = (WpAllocator){0};
}
wapp_intern void initialise_arena_allocator(Allocator *allocator) {
wp_intern void initialise_arena_allocator(WpAllocator *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);
wp_intern void *mem_arena_alloc(u64 size, void *alloc_obj) {
WpArena *arena = (WpArena *)alloc_obj;
return wpMemArenaAlloc(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);
wp_intern void *mem_arena_alloc_aligned(u64 size, u64 alignment, void *alloc_obj) {
WpArena *arena = (WpArena *)alloc_obj;
return wpMemArenaAllocAligned(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);
wp_intern void *mem_arena_realloc(void *ptr, u64 old_size, u64 new_size, void *alloc_obj) {
WpArena *arena = (WpArena *)alloc_obj;
return wpMemArenaRealloc(arena, ptr, old_size, new_size);
}
wapp_intern void *mem_arena_realloc_aligned(void *ptr, u64 old_size, u64 new_size, u64 alignment,
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
+23 -23
View File
@@ -8,39 +8,39 @@
#include "../../../common/platform/platform.h"
#include "../../../base/mem/allocator/mem_allocator.h"
#ifdef WAPP_PLATFORM_CPP
#ifdef WP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WAPP_PLATFORM_CPP
#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 Allocator 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
* Allocator.
* 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.
*/
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);
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 WAPP_PLATFORM_CPP
#ifdef WP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WAPP_PLATFORM_CPP
#endif // !WP_PLATFORM_CPP
#endif // !MEM_ARENA_ALLOCATOR_H
src/os/cpath/cpath.c
+37 -39
View File
@@ -8,128 +8,126 @@
#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) {
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;
}
Str8 separator = wapp_str8_buf(4);
wapp_str8_push_back(&separator, WAPP_PATH_SEP);
WpStr8 separator = wpStr8Buf(4);
wpStr8PushBack(&separator, WP_PATH_SEP);
u64 required_capacity = parts->node_count * separator.size + wapp_str8_list_total_size(parts);
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
Str8 *first_node = wapp_dbl_list_get(Str8, parts, 0);
wapp_str8_copy_str8_capped(dst, first_node);
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
// MSVC Spectre mitigation warnings
Str8 *node = first_node;
WpStr8 *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);
node = wpDblListGet(WpStr8, 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;
char dst_last = wpStr8Get(dst, dst->size - 1);
char node_start = wpStr8Get(node, 0);
b8 add_path_sep = dst_last != WP_PATH_SEP && node_start != WP_PATH_SEP;
if (add_path_sep) {
wapp_str8_concat_capped(dst, &separator);
wpStr8ConcatCapped(dst, &separator);
}
}
wapp_str8_concat_capped(dst, node);
wpStr8ConcatCapped(dst, node);
CPATH_JOIN_LOOP_END:
++node_index;
running = node_index < parts->node_count;
}
return CPATH_JOIN_SUCCESS;
return WP_CPATH_JOIN_RESULT_SUCCESS;
}
Str8 *dirup(const Allocator *allocator, Str8RO *path, u64 levels) {
Str8 *output = NULL;
WpStr8 *_dirup(const WpAllocator *allocator, WpStr8RO *path, u64 levels) {
WpStr8 *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);
b8 absolute = wpStr8Get(path, 0) == WP_PATH_SEP;
WpStr8 separator = wpStr8Buf(4);
wpStr8PushBack(&separator, WP_PATH_SEP);
if (path->size == 0) {
output = wapp_str8_alloc_buf(allocator, 16);
output = wpStr8AllocBuf(allocator, 16);
if (!output) {
goto RETURN_DIRUP;
}
wapp_str8_push_back(output, absolute ? WAPP_PATH_SEP : '.');
wpStr8PushBack(output, absolute ? WP_PATH_SEP : '.');
goto RETURN_DIRUP;
}
if (levels < 1) {
output = wapp_str8_alloc_str8(allocator, path);
output = wpStr8AllocStr8(allocator, path);
goto RETURN_DIRUP;
}
Allocator tmp_arena = wapp_mem_arena_allocator_init(MiB(8));
if (wapp_mem_allocator_invalid(&tmp_arena)) {
WpAllocator tmp_arena = wpMemArenaAllocatorInit(MiB(8));
if (wpMemAllocatorInvalid(&tmp_arena)) {
goto RETURN_DIRUP;
}
Str8List *parts = wapp_str8_split(&tmp_arena, path, &separator);
WpStr8List *parts = wpStr8Split(&tmp_arena, path, &separator);
if (!parts) {
goto RETURN_DIRUP;
}
if (levels >= parts->node_count) {
output = wapp_str8_alloc_buf(allocator, 16);
output = wpStr8AllocBuf(allocator, 16);
if (!output) {
goto LIST_CLEANUP_DIRUP;
}
wapp_str8_push_back(output, absolute ? WAPP_PATH_SEP : '.');
wpStr8PushBack(output, absolute ? WP_PATH_SEP : '.');
} else {
for (u64 i = 0; i < levels; ++i) {
wapp_dbl_list_pop_back(Str8, parts);
wpDblListPopBack(WpStr8, parts);
}
u64 alignment = sizeof(void *) * 2;
u64 alloc_size = wapp_str8_list_total_size(parts) + parts->node_count * separator.size;
u64 alloc_size = wpStr8ListTotalSize(parts) + parts->node_count * separator.size;
u64 modulo = alloc_size & (alignment - 1);
alloc_size += alignment - modulo;
output = wapp_str8_alloc_buf(allocator, alloc_size);
output = wpStr8AllocBuf(allocator, alloc_size);
if (output) {
if (absolute) {
wapp_str8_push_back(output, WAPP_PATH_SEP);
wpStr8PushBack(output, WP_PATH_SEP);
}
Str8 *joined = wapp_str8_join(&tmp_arena, parts, &separator);
WpStr8 *joined = wpStr8Join(&tmp_arena, parts, &separator);
if (joined) {
wapp_str8_concat_capped(output, joined);
wpStr8ConcatCapped(output, joined);
}
}
}
LIST_CLEANUP_DIRUP:
wapp_mem_arena_allocator_destroy(&tmp_arena);
wpMemArenaAllocatorDestroy(&tmp_arena);
RETURN_DIRUP:
return output;
src/os/cpath/cpath.h
+20 -20
View File
@@ -8,38 +8,38 @@
#include "../../base/mem/allocator/mem_allocator.h"
#include "../../base/strings/str8/str8.h"
#ifdef WAPP_PLATFORM_CPP
#ifdef WP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WAPP_PLATFORM_CPP
#endif // !WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_POSIX
#ifdef WP_PLATFORM_POSIX
#include <limits.h>
#define WAPP_PATH_SEP '/'
#define WAPP_PATH_MAX PATH_MAX
#elif defined(WAPP_PLATFORM_WINDOWS)
#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(Str8 *dst, const Str8List *parts);
Str8 *dirup(const Allocator *allocator, Str8RO *path, u64 levels);
WpCpathJoinResult wpCpathJoinPath(WpStr8 *dst, const WpStr8List *parts);
WpStr8 *_dirup(const WpAllocator *allocator, WpStr8RO *path, u64 levels);
#ifdef WAPP_PLATFORM_CPP
#ifdef WP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WAPP_PLATFORM_CPP
#endif // !WP_PLATFORM_CPP
#endif // !CPATH_H
src/os/file/file.c
+57 -57
View File
@@ -7,77 +7,77 @@
#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);
WpFile *wpFileOpen(const WpAllocator *allocator, WpStr8RO *filepath, WpFileAccessMode mode) {
wpDebugAssert(allocator != NULL && filepath != NULL, "`allocator` and `filepath` should not be NULL");
wpDebugAssert(filepath->size < WP_PATH_MAX, "`filepath` exceeds max path limit.");
return _fileOpen(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 wpFileGetCurrentPosition(WpFile *file) {
wpDebugAssert(file != NULL, "`file` should not be NULL.");
return _fileSeek(file, 0, WP_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 wpFileSeek(WpFile *file, i64 offset, WpFileSeekOrigin origin) {
wpDebugAssert(file != NULL, "`file` should not be NULL.");
return _fileSeek(file, offset, origin);
}
i64 wapp_file_get_length(WFile *file) {
wapp_debug_assert(file != NULL, "`file` should not be NULL.");
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) {
wapp_debug_assert(dst_buf != NULL && file != NULL,
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) {
wapp_debug_assert(src_buf != NULL && file != NULL,
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(Str8 *str, WFile *file) {
wapp_debug_assert(str != NULL, "`str` should not be NULL.");
return wapp_file_read((void *)(str->buf), file, str->size);
u64 wpFileReadStr8(WpStr8 *str, WpFile *file) {
wpDebugAssert(str != NULL, "`str` should not be NULL.");
return wpFileRead((void *)(str->buf), file, str->size);
}
i64 wapp_file_write_str8(Str8RO *str, WFile *file) {
wapp_debug_assert(str != NULL, "`str` should not be NULL.");
return wapp_file_write((void *)(str->buf), file, str->size);
i64 wpFileWriteStr8(WpStr8RO *str, WpFile *file) {
wpDebugAssert(str != NULL, "`str` should not be NULL.");
return wpFileWrite((void *)(str->buf), file, str->size);
}
u64 wapp_file_read_array(GenericArray dst_buf, WFile *file, u64 item_count) {
wapp_debug_assert(dst_buf != NULL && file != NULL,
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) {
wapp_debug_assert(src_buf != NULL && file != NULL,
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) {
wapp_debug_assert(file != NULL, "`file` should not be NULL.");
return _file_flush(file);
i32 wpFileFlush(WpFile *file) {
wpDebugAssert(file != NULL, "`file` should not be NULL.");
return _fileFlush(file);
}
i32 wapp_file_close(WFile *file) {
wapp_debug_assert(file != NULL, "`file` should not be NULL.");
return _file_close(file);
i32 wpFileClose(WpFile *file) {
wpDebugAssert(file != NULL, "`file` should not be NULL.");
return _fileClose(file);
}
i32 wapp_file_rename(Str8RO *old_filepath, Str8RO *new_filepath) {
wapp_debug_assert(old_filepath != NULL && new_filepath != NULL,
i32 wpFileRename(WpStr8RO *old_filepath, WpStr8RO *new_filepath) {
wpDebugAssert(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);
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(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);
i32 wpFileRemove(WpStr8RO *filepath) {
wpDebugAssert(filepath != NULL, "`filepath` should not be NULL");
wpDebugAssert(filepath->size < WP_PATH_MAX, "`filepath` exceeds max path limit.");
return _fileRemove(filepath);
}
src/os/file/file.h
+48 -48
View File
@@ -7,71 +7,71 @@
#include "../../common/aliases/aliases.h"
#include "../../base/strings/str8/str8.h"
#ifdef WAPP_PLATFORM_CPP
#ifdef WP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WAPP_PLATFORM_CPP
#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
wapp_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
wapp_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
wapp_extern WFile *wapp_file_stderr(void);
// wpFileStderr to get the standard error stream
wp_extern WpFile *wpFileStderr(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_str8(Str8 *str, WFile *file);
i64 wapp_file_write_str8(Str8RO *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(Str8RO *old_filepath, Str8RO *new_filepath);
i32 wapp_file_remove(Str8RO *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);
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);
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 WAPP_PLATFORM_CPP
#ifdef WP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WAPP_PLATFORM_CPP
#endif // !WP_PLATFORM_CPP
#endif // !FILE_H
src/os/file/posix/file_posix.c
+50 -50
View File
@@ -3,7 +3,7 @@
#include "file_posix.h"
#include "../../../common/platform/platform.h"
#ifdef WAPP_PLATFORM_POSIX
#ifdef WP_PLATFORM_POSIX
#include "../file.h"
#include "../../cpath/cpath.h"
@@ -11,62 +11,62 @@
#include "../../../base/array/array.h"
#include "../../../base/strings/str8/str8.h"
#ifdef WAPP_PLATFORM_APPLE
#ifdef WP_PLATFORM_APPLE
#define _FILE_OFFSET_BITS 64
#define lseek64 lseek
#endif // !WAPP_PLATFORM_APPLE
#endif // !WP_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,
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,
};
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,
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,
};
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,
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) {
wapp_persist WFile _stdin = { .fd = STDIN_FILENO };
WpFile *wpFileStdin(void) {
wp_persist WpFile _stdin = { .fd = STDIN_FILENO };
return &_stdin;
}
WFile *wapp_file_stdout(void) {
wapp_persist WFile _stdout = { .fd = STDOUT_FILENO };
WpFile *wpFileStdout(void) {
wp_persist WpFile _stdout = { .fd = STDOUT_FILENO };
return &_stdout;
}
WFile *wapp_file_stderr(void) {
wapp_persist WFile _stderr = { .fd = STDERR_FILENO };
WpFile *wpFileStderr(void) {
wp_persist WpFile _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);
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 Allocator *allocator, Str8RO *filepath, FileAccessMode m
return NULL;
}
WFile *output = wapp_mem_allocator_alloc(allocator, sizeof(WFile));
WpFile *output = wpMemAllocatorAlloc(allocator, sizeof(WpFile));
if (output) {
output->fd = fd;
}
@@ -82,11 +82,11 @@ WFile *_file_open(const Allocator *allocator, Str8RO *filepath, FileAccessMode m
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,40 +95,40 @@ 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(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);
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(Str8RO *filepath) {
wapp_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);
}
#endif // !WAPP_PLATFORM_POSIX
#endif // !WP_PLATFORM_POSIX
src/os/file/posix/file_posix.h
+8 -8
View File
@@ -6,22 +6,22 @@
#include "../../../common/aliases/aliases.h"
#include "../../../common/platform/platform.h"
#ifdef WAPP_PLATFORM_CPP
#ifdef WP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WAPP_PLATFORM_CPP
#endif // !WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_POSIX
#ifdef WP_PLATFORM_POSIX
#define END_OF_LINE "\n"
#define WP_END_OF_LINE "\n"
struct WFile {
struct WpFile {
i32 fd;
};
#endif // !WAPP_PLATFORM_POSIX
#endif // !WP_PLATFORM_POSIX
#ifdef WAPP_PLATFORM_CPP
#ifdef WP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WAPP_PLATFORM_CPP
#endif // !WP_PLATFORM_CPP
#endif // !FILE_POSIX_H
src/os/file/win/file_win.c
+58 -58
View File
@@ -3,7 +3,7 @@
#include "file_win.h"
#include "../../../common/platform/platform.h"
#ifdef WAPP_PLATFORM_WINDOWS
#ifdef WP_PLATFORM_WINDOWS
#include "../file.h"
#include "../../cpath/cpath.h"
@@ -15,66 +15,66 @@
#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,
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,
};
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,
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,
};
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,
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,
};
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,
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) {
wapp_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) {
wapp_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) {
wapp_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 Allocator *allocator, Str8RO *filepath, FileAccessMode mode) {
wapp_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 Allocator *allocator, Str8RO *filepath, FileAccessMode m
return NULL;
}
WFile *output = wapp_mem_allocator_alloc(allocator, sizeof(WFile));
WpFile *output = wpMemAllocatorAlloc(allocator, sizeof(WpFile));
if (output) {
output->fh = fh;
}
@@ -96,7 +96,7 @@ WFile *_file_open(const Allocator *allocator, Str8RO *filepath, FileAccessMode m
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,9 +109,9 @@ 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;
wapp_debug_assert(copy_byte_count <= DWORD_MAX, "Attempting to read large number of bytes at once");
wpDebugAssert(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)) {
@@ -121,8 +121,8 @@ 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) {
wapp_debug_assert(byte_count <= DWORD_MAX, "Attempting to write large number of bytes at once");
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;
if (!WriteFile(file->fh, src_buf, (DWORD)byte_count, &write_count, NULL)) {
@@ -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(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);
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(Str8RO *old_filepath, Str8RO *new_filepath) {
return 0;
}
i32 _file_remove(Str8RO *filepath) {
wapp_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)) {
@@ -174,4 +174,4 @@ i32 _file_remove(Str8RO *filepath) {
return 0;
}
#endif // !WAPP_PLATFORM_WINDOWS
#endif // !WP_PLATFORM_WINDOWS
src/os/file/win/file_win.h
+8 -8
View File
@@ -6,26 +6,26 @@
#include "../../../common/aliases/aliases.h"
#include "../../../common/platform/platform.h"
#ifdef WAPP_PLATFORM_CPP
#ifdef WP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WAPP_PLATFORM_CPP
#endif // !WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_WINDOWS
#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;
};
#endif // !WAPP_PLATFORM_WINDOWS
#endif // !WP_PLATFORM_WINDOWS
#ifdef WAPP_PLATFORM_CPP
#ifdef WP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WAPP_PLATFORM_CPP
#endif // !WP_PLATFORM_CPP
#endif // !FILE_WIN_H
src/os/mem/mem_os.c
+7 -7
View File
@@ -7,24 +7,24 @@
#include <assert.h>
#include <string.h>
#if defined(WAPP_PLATFORM_WINDOWS)
#if defined(WP_PLATFORM_WINDOWS)
#include "win/mem_os_win.h"
#elif defined(WAPP_PLATFORM_POSIX)
#elif defined(WP_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);
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
+10 -10
View File
@@ -8,26 +8,26 @@
#include "mem_os_ops.h"
#ifdef WAPP_PLATFORM_CPP
#ifdef WP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WAPP_PLATFORM_CPP
#endif // !WP_PLATFORM_CPP
#if defined(WAPP_PLATFORM_WINDOWS)
#if defined(WP_PLATFORM_WINDOWS)
#include "win/mem_os_win.h"
#elif defined(WAPP_PLATFORM_POSIX)
#elif defined(WP_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);
void *wpOsMemAlloc(void *addr, u64 size, WpMemAccess access, WpMemAllocFlags flags, WpMemInitType type);
void wpOsMemFree(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);
wp_extern void *_osMemAllocate(void *addr, u64 size, WpMemAccess access, WpMemAllocFlags flags, WpMemInitType type);
wp_extern void _osMemFree(void *ptr, u64 size);
#ifdef WAPP_PLATFORM_CPP
#ifdef WP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WAPP_PLATFORM_CPP
#endif // !WP_PLATFORM_CPP
#endif // !MEM_OS_H
src/os/mem/mem_os_ops.h
+16 -16
View File
@@ -5,26 +5,26 @@
#include "../../common/platform/platform.h"
#ifdef WAPP_PLATFORM_CPP
#ifdef WP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WAPP_PLATFORM_CPP
#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 WAPP_PLATFORM_CPP
#ifdef WP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WAPP_PLATFORM_CPP
#endif // !WP_PLATFORM_CPP
#endif // !MEM_OS_OPS_H
src/os/mem/posix/mem_os_posix.c
+12 -12
View File
@@ -3,34 +3,34 @@
#include "../../../common/aliases/aliases.h"
#include "../../../common/platform/platform.h"
#ifdef WAPP_PLATFORM_POSIX
#ifdef WP_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,
wp_intern const i32 access_types[] = {
[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;
#if defined(WAPP_PLATFORM_LINUX) || defined(WAPP_PLATFORM_GNU) || defined(WAPP_PLATFORM_NET_BSD)
#if defined(WP_PLATFORM_LINUX) || defined(WP_PLATFORM_GNU) || defined(WP_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) {
void _osMemFree(void *ptr, u64 size) {
munmap(ptr, size);
}
#endif // !WAPP_PLATFORM_POSIX
#endif // !WP_PLATFORM_POSIX
src/os/mem/posix/mem_os_posix.h
+17 -17
View File
@@ -5,31 +5,31 @@
#include "../../../common/platform/platform.h"
#ifdef WAPP_PLATFORM_CPP
#ifdef WP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WAPP_PLATFORM_CPP
#endif // !WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_POSIX
#ifdef WP_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,
typedef enum {
#if defined(WP_PLATFORM_LINUX) || defined(WP_PLATFORM_GNU)
WP_MEM_ALLOC_RESERVE = 0,
WP_MEM_ALLOC_COMMIT = MAP_POPULATE,
#elif defined(WP_PLATFORM_FREE_BSD)
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)
WP_MEM_ALLOC_RESERVE = 0,
WP_MEM_ALLOC_COMMIT = 0,
#endif
} MemAllocFlags;
} WpMemAllocFlags;
#endif // !WAPP_PLATFORM_POSIX
#endif // !WP_PLATFORM_POSIX
#ifdef WAPP_PLATFORM_CPP
#ifdef WP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WAPP_PLATFORM_CPP
#endif // !WP_PLATFORM_CPP
#endif // !MEM_OS_POSIX_H
src/os/mem/win/mem_os_win.c
+13 -13
View File
@@ -3,7 +3,7 @@
#include "../../../common/aliases/aliases.h"
#include "../../../common/platform/platform.h"
#ifdef WAPP_PLATFORM_WINDOWS
#ifdef WP_PLATFORM_WINDOWS
#include "mem_os_win.h"
#include "../mem_os_ops.h"
@@ -12,26 +12,26 @@
#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,
wp_intern const i32 access_types[] = {
[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);
}
#endif // !WAPP_PLATFORM_WINDOWS
#endif // !WP_PLATFORM_WINDOWS
src/os/mem/win/mem_os_win.h
+10 -10
View File
@@ -5,25 +5,25 @@
#include "../../../common/platform/platform.h"
#ifdef WAPP_PLATFORM_CPP
#ifdef WP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WAPP_PLATFORM_CPP
#endif // !WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_WINDOWS
#ifdef WP_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;
typedef enum {
WP_MEM_ALLOC_RESERVE = MEM_RESERVE,
WP_MEM_ALLOC_COMMIT = MEM_COMMIT,
} WpMemAllocFlags;
#endif // !WAPP_PLATFORM_WINDOWS
#endif // !WP_PLATFORM_WINDOWS
#ifdef WAPP_PLATFORM_CPP
#ifdef WP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WAPP_PLATFORM_CPP
#endif // !WP_PLATFORM_CPP
#endif // !MEM_OS_WIN_H
src/os/shell/commander/commander.c
+37 -37
View File
@@ -17,85 +17,85 @@
#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);
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, Str8 *out_buf, const Str8List *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);
}
Allocator arena = wapp_mem_arena_allocator_init(KiB(500));
WpAllocator arena = wpMemArenaAllocatorInit(KiB(500));
Str8 *cmd_str = wapp_str8_join(&arena, cmd, &wapp_str8_lit_ro(" "));
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 = wapp_str8_alloc_concat(&arena, cmd_str, &wapp_str8_lit_ro(" 2>&1"));
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;
}
wapp_intern CMDResult execute_command(Str8RO *cmd, CMDOutHandling out_handling, Str8 *out_buf) {
wp_intern WpCmdResult executeCommand(WpStr8RO *cmd, WpCmdOutHandling out_handling, WpStr8 *out_buf) {
char cmd_buf[CMD_BUF_LEN] = {0};
wapp_str8_copy_to_cstr(cmd_buf, cmd, CMD_BUF_LEN);
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;
}
wapp_intern CMDError get_command_output(FILE *fp, CMDOutHandling out_handling, Str8 *out_buf) {
Str8 out = wapp_str8_buf(OUT_BUF_LEN);
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;
}
wapp_str8_concat_capped(out_buf, &out);
} else if (out_handling == SHELL_OUTPUT_PRINT) {
printf(WAPP_STR8_SPEC, wapp_str8_varg(out));
wpStr8ConcatCapped(out_buf, &out);
} 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
+7 -7
View File
@@ -12,18 +12,18 @@
// TODO (Abdelrahman): This module needs rethinking
#ifdef WAPP_PLATFORM_CPP
#ifdef WP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WAPP_PLATFORM_CPP
#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, Str8 *out_buf, const Str8List *cmd);
WpCmdResult wpShellCommanderExecute(WpCmdOutHandling out_handling, WpStr8 *out_buf, const WpStr8List *cmd);
wapp_extern CMDError get_output_status(FILE *fp, i32 *status_out);
wp_extern WpCmdError _getOutputStatus(FILE *fp, i32 *status_out);
#ifdef WAPP_PLATFORM_CPP
#ifdef WP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WAPP_PLATFORM_CPP
#endif // !WP_PLATFORM_CPP
#endif // !COMMANDER_H
src/os/shell/commander/commander_output.h
+19 -19
View File
@@ -7,36 +7,36 @@
#include "../../../common/platform/platform.h"
#include "../../../common/misc/misc_utils.h"
#ifdef WAPP_PLATFORM_CPP
#ifdef WP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WAPP_PLATFORM_CPP
#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;
wapp_misc_utils_reserve_padding(sizeof(b8) + sizeof(i32) + sizeof(CMDError));
wpMiscUtilsReservePadding(sizeof(b8) + sizeof(i32) + sizeof(WpCmdError));
};
#ifdef WAPP_PLATFORM_CPP
#ifdef WP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WAPP_PLATFORM_CPP
#endif // !WP_PLATFORM_CPP
#endif // !COMMANDER_OUTPUT_H
src/os/shell/commander/posix/commander_posix.c
+6 -6
View File
@@ -3,23 +3,23 @@
#include "../../../../common/aliases/aliases.h"
#include "../../../../common/platform/platform.h"
#ifdef WAPP_PLATFORM_POSIX
#ifdef WP_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);
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 // !WAPP_PLATFORM_POSIX
#endif // !WP_PLATFORM_POSIX
src/os/shell/commander/win/commander_win.c
+7 -7
View File
@@ -3,22 +3,22 @@
#include "../../../../common/aliases/aliases.h"
#include "../../../../common/platform/platform.h"
#ifdef WAPP_PLATFORM_WINDOWS
#ifdef WP_PLATFORM_WINDOWS
#include "../commander_output.h"
#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 // !WAPP_PLATFORM_WINDOWS
#endif // !WP_PLATFORM_WINDOWS
src/os/shell/termcolour/posix/termcolour_posix.c
+22 -22
View File
@@ -4,33 +4,33 @@
#include "../../../../common/platform/platform.h"
#include "../../../../base/strings/str8/str8.h"
#ifdef WAPP_PLATFORM_POSIX
#ifdef WP_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"),
wp_intern WpStr8RO colours[COUNT_TERM_COLOUR] = {
[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(Str8RO *text, TerminalColour colour) {
printf(WAPP_STR8_SPEC WAPP_STR8_SPEC, wapp_str8_varg(colours[colour]), wapp_str8_varg((*text)));
void _printColouredText(WpStr8RO *text, WpTerminalColour colour) {
printf(WP_STR8_SPEC WP_STR8_SPEC, wpStr8Varg(colours[colour]), wpStr8Varg((*text)));
}
#endif // !WAPP_PLATFORM_POSIX
#endif // !WP_PLATFORM_POSIX
src/os/shell/termcolour/termcolour.c
+6 -6
View File
@@ -4,15 +4,15 @@
#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) {
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) {
Str8RO empty = wapp_str8_lit_ro("");
print_coloured_text(&empty, WAPP_TERM_COLOUR_CLEAR);
void wpShellTermcolourClearColour(void) {
WpStr8RO empty = wpStr8LitRo("");
_printColouredText(&empty, WP_TERM_COLOUR_CLEAR);
}
src/os/shell/termcolour/termcolour.h
+7 -7
View File
@@ -8,19 +8,19 @@
#include "../../../common/platform/platform.h"
#include "../../../base/strings/str8/str8.h"
#ifdef WAPP_PLATFORM_CPP
#ifdef WP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WAPP_PLATFORM_CPP
#endif // !WP_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);
void wpShellTermcolourPrintText(WpStr8RO *text, WpTerminalColour colour);
void wpShellTermcolourClearColour(void);
wapp_extern void print_coloured_text(Str8RO *text, TerminalColour colour);
wp_extern void _printColouredText(WpStr8RO *text, WpTerminalColour colour);
#ifdef WAPP_PLATFORM_CPP
#ifdef WP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WAPP_PLATFORM_CPP
#endif // !WP_PLATFORM_CPP
#endif // !TERM_COLOUR_H
src/os/shell/termcolour/terminal_colours.h
+22 -22
View File
@@ -6,34 +6,34 @@
#include "../../../common/aliases/aliases.h"
#include "../../../common/platform/platform.h"
#ifdef WAPP_PLATFORM_CPP
#ifdef WP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WAPP_PLATFORM_CPP
#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 WAPP_PLATFORM_CPP
#ifdef WP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WAPP_PLATFORM_CPP
#endif // !WP_PLATFORM_CPP
#endif // !TERMINAL_COLOURS_H
src/os/shell/termcolour/win/termcolour_win.c
+26 -26
View File
@@ -4,7 +4,7 @@
#include "../../../../common/platform/platform.h"
#include "../../../../base/strings/str8/str8.h"
#ifdef WAPP_PLATFORM_WINDOWS
#ifdef WP_PLATFORM_WINDOWS
#include "../terminal_colours.h"
#include "../../../../common/misc/misc_utils.h"
@@ -19,47 +19,47 @@ struct TermcolourData {
WORD default_colour;
WORD current_colour;
wapp_misc_utils_reserve_padding(sizeof(HANDLE) + sizeof(WORD) + sizeof(WORD));
wpMiscUtilsReservePadding(sizeof(HANDLE) + sizeof(WORD) + sizeof(WORD));
};
wapp_intern void init_data(TermcolourData *data);
wp_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,
wp_intern WORD colours[COUNT_TERM_COLOUR] = {
[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(Str8RO *text, TerminalColour colour) {
wapp_persist TermcolourData data = {0};
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];
}
SetConsoleTextAttribute(data.handle, data.current_colour);
printf(WAPP_STR8_SPEC, wapp_str8_varg((*text)));
printf(WP_STR8_SPEC, wpStr8Varg((*text)));
}
wapp_intern void init_data(TermcolourData *data) {
wp_intern void init_data(TermcolourData *data) {
// create handle
data->handle = GetStdHandle(STD_OUTPUT_HANDLE);
@@ -70,4 +70,4 @@ wapp_intern void init_data(TermcolourData *data) {
data->current_colour = data->default_colour;
}
#endif // !WAPP_PLATFORM_WINDOWS
#endif // !WP_PLATFORM_WINDOWS
src/os/shell/utils/shell_utils.h
+10 -10
View File
@@ -7,20 +7,20 @@
#include "../../../common/platform/platform.h"
#include <stdio.h>
#ifdef WAPP_PLATFORM_CPP
#ifdef WP_PLATFORM_CPP
BEGIN_C_LINKAGE
#endif // !WAPP_PLATFORM_CPP
#endif // !WP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_WINDOWS
#define wapp_shell_utils_popen _popen
#define wapp_shell_utils_pclose _pclose
#ifdef WP_PLATFORM_WINDOWS
#define wpShellUtilsPopen _popen
#define wpShellUtilsPclose _pclose
#else
#define wapp_shell_utils_popen popen
#define wapp_shell_utils_pclose pclose
#endif /* ifdef WAPP_PLATFORM_WINDOWS */
#define wpShellUtilsPopen popen
#define wpShellUtilsPclose pclose
#endif /* ifdef WP_PLATFORM_WINDOWS */
#ifdef WAPP_PLATFORM_CPP
#ifdef WP_PLATFORM_CPP
END_C_LINKAGE
#endif // !WAPP_PLATFORM_CPP
#endif // !WP_PLATFORM_CPP
#endif // !SHELL_UTILS_H