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

Rename Str8

Browse Source
This commit is contained in:
Abdelrahman Said
2026-06-26 16:18:46 +01:00
parent acbfc9088c
commit e2b57d4aba
23 changed files with 867 additions and 867 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/base/strings/str8/str8.c
+54 -54
View File
@@ -13,7 +13,7 @@
#define STR8_BUF_ALLOC_SIZE(CAPACITY) (sizeof(WpStr8) + sizeof(c8) * CAPACITY)
WpStr8 *wapp_str8_alloc_buf(const Allocator *allocator, u64 capacity) {
WpStr8 *wpStr8AllocBuf(const Allocator *allocator, u64 capacity) {
wpDebugAssert(allocator != NULL, "`allocator` should not be NULL");
WpStr8 *str = wapp_mem_allocator_alloc(allocator, STR8_BUF_ALLOC_SIZE(capacity));
@@ -29,8 +29,8 @@ RETURN_STR8:
return str;
}
WpStr8 *wapp_str8_alloc_and_fill_buf(const Allocator *allocator, u64 capacity) {
WpStr8 *out = wapp_str8_alloc_buf(allocator, capacity);
WpStr8 *wpStr8AllocAndFillBuf(const Allocator *allocator, u64 capacity) {
WpStr8 *out = wpStr8AllocBuf(allocator, capacity);
if (out) {
memset(out->buf, 0, capacity);
out->size = capacity;
@@ -38,11 +38,11 @@ WpStr8 *wapp_str8_alloc_and_fill_buf(const Allocator *allocator, u64 capacity) {
return out;
}
WpStr8 *wapp_str8_alloc_cstr(const Allocator *allocator, const char *str) {
WpStr8 *wpStr8AllocCstr(const Allocator *allocator, const char *str) {
wpDebugAssert(allocator != NULL && str != NULL, "`allocator` and `str` should not be NULL");
u64 length = strlen(str);
WpStr8 *output = wapp_str8_alloc_buf(allocator, length * 2);
WpStr8 *output = wpStr8AllocBuf(allocator, length * 2);
if (!output) {
goto RETURN_ALLOC_CSTR;
}
@@ -54,10 +54,10 @@ RETURN_ALLOC_CSTR:
return output;
}
WpStr8 *wapp_str8_alloc_str8(const Allocator *allocator, WpStr8RO *str) {
WpStr8 *wpStr8AllocStr8(const Allocator *allocator, WpStr8RO *str) {
wpDebugAssert(allocator != NULL && str != NULL, "`allocator` and `str` should not be NULL");
WpStr8 *output = wapp_str8_alloc_buf(allocator, str->capacity);
WpStr8 *output = wpStr8AllocBuf(allocator, str->capacity);
if (!output) {
goto RETURN_ALLOC_STR8;
}
@@ -69,7 +69,7 @@ RETURN_ALLOC_STR8:
return output;
}
WpStr8 *wapp_str8_alloc_substr(const Allocator *allocator, WpStr8RO *str, u64 start, u64 end) {
WpStr8 *wpStr8AllocSubstr(const Allocator *allocator, WpStr8RO *str, u64 start, u64 end) {
wpDebugAssert(allocator != NULL && str != NULL, "`allocator` and `str` should not be NULL");
WpStr8 *output = NULL;
@@ -82,7 +82,7 @@ WpStr8 *wapp_str8_alloc_substr(const Allocator *allocator, WpStr8RO *str, u64 st
end = str->size;
}
output = wapp_str8_alloc_buf(allocator, str->capacity);
output = wpStr8AllocBuf(allocator, str->capacity);
if (!output) {
goto RETURN_ALLOC_SUBSTR;
}
@@ -94,12 +94,12 @@ RETURN_ALLOC_SUBSTR:
return output;
}
void wapp_str8_dealloc_buf(const Allocator *allocator, WpStr8 **str) {
void wpStr8DeallocBuf(const Allocator *allocator, WpStr8 **str) {
wpDebugAssert(allocator != NULL && str != NULL && (*str) != NULL, "Either `allocator` is NULL or `str` is an invalid double pointer");
wapp_mem_allocator_free(allocator, (void **)str, STR8_BUF_ALLOC_SIZE((*str)->capacity));
}
c8 wapp_str8_get(const WpStr8 *str, u64 index) {
c8 wpStr8Get(const WpStr8 *str, u64 index) {
if (index >= str->size) {
return '\0';
}
@@ -107,7 +107,7 @@ c8 wapp_str8_get(const WpStr8 *str, u64 index) {
return str->buf[index];
}
void wapp_str8_set(WpStr8 *str, u64 index, c8 c) {
void wpStr8Set(WpStr8 *str, u64 index, c8 c) {
if (index >= str->size) {
return;
}
@@ -115,24 +115,24 @@ void wapp_str8_set(WpStr8 *str, u64 index, c8 c) {
str->buf[index] = c;
}
void wapp_str8_push_back(WpStr8 *str, c8 c) {
void wpStr8PushBack(WpStr8 *str, c8 c) {
if (!(str->size < str->capacity)) {
return;
}
u64 index = (str->size)++;
wapp_str8_set(str, index, c);
wpStr8Set(str, index, c);
}
b8 wapp_str8_equal(WpStr8RO *s1, WpStr8RO *s2) {
b8 wpStr8Equal(WpStr8RO *s1, WpStr8RO *s2) {
if (s1->size != s2->size) {
return false;
}
return wapp_str8_equal_to_count(s1, s2, s1->size);
return wpStr8EqualToCount(s1, s2, s1->size);
}
b8 wapp_str8_equal_to_count(WpStr8RO* s1, WpStr8RO* s2, u64 count) {
b8 wpStr8EqualToCount(WpStr8RO* s1, WpStr8RO* s2, u64 count) {
if (!s1 || !s2) {
return false;
}
@@ -140,7 +140,7 @@ b8 wapp_str8_equal_to_count(WpStr8RO* s1, WpStr8RO* s2, u64 count) {
return memcmp(s1->buf, s2->buf, count) == 0;
}
WpStr8 wapp_str8_slice(WpStr8RO *str, u64 start, u64 end) {
WpStr8 wpStr8Slice(WpStr8RO *str, u64 start, u64 end) {
if (start >= str->size || start >= end) {
start = str->size;
end = str->size;
@@ -157,7 +157,7 @@ WpStr8 wapp_str8_slice(WpStr8RO *str, u64 start, u64 end) {
};
}
WpStr8 *wapp_str8_alloc_concat(const Allocator *allocator, WpStr8 *dst, WpStr8RO *src) {
WpStr8 *wpStr8AllocConcat(const Allocator *allocator, WpStr8 *dst, WpStr8RO *src) {
wpDebugAssert(allocator != NULL && dst != NULL && src != NULL, "`allocator`, `dst` and `src` should not be NULL");
WpStr8 *output = NULL;
@@ -169,21 +169,21 @@ WpStr8 *wapp_str8_alloc_concat(const Allocator *allocator, WpStr8 *dst, WpStr8RO
u64 capacity = dst->capacity + src->size;
output = wapp_str8_alloc_buf(allocator, capacity);
output = wpStr8AllocBuf(allocator, capacity);
if (!output) {
goto RETURN_STR8_CONCAT;
}
wapp_str8_concat_capped(output, dst);
wpStr8ConcatCapped(output, dst);
SOURCE_STRING_STR8_CONCAT:
wapp_str8_concat_capped(output, src);
wpStr8ConcatCapped(output, src);
RETURN_STR8_CONCAT:
return output;
}
void wapp_str8_concat_capped(WpStr8 *dst, WpStr8RO *src) {
void wpStr8ConcatCapped(WpStr8 *dst, WpStr8RO *src) {
wpDebugAssert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL");
u64 remaining = dst->capacity - dst->size;
@@ -193,7 +193,7 @@ void wapp_str8_concat_capped(WpStr8 *dst, WpStr8RO *src) {
dst->size += to_copy;
}
void wapp_str8_copy_cstr_capped(WpStr8 *dst, const char *src) {
void wpStr8CopyCstrCapped(WpStr8 *dst, const char *src) {
wpDebugAssert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL");
u64 length = strlen(src);
@@ -204,7 +204,7 @@ void wapp_str8_copy_cstr_capped(WpStr8 *dst, const char *src) {
dst->size = to_copy;
}
void wapp_str8_copy_str8_capped(WpStr8 *dst, WpStr8RO *src) {
void wpStr8CopyStr8Capped(WpStr8 *dst, WpStr8RO *src) {
wpDebugAssert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL");
u64 to_copy = src->size <= dst->capacity ? src->size : dst->capacity;
@@ -214,7 +214,7 @@ void wapp_str8_copy_str8_capped(WpStr8 *dst, WpStr8RO *src) {
dst->size = to_copy;
}
void wapp_str8_copy_to_cstr(char *dst, WpStr8RO *src, u64 dst_capacity) {
void wpStr8CopyToCstr(char *dst, WpStr8RO *src, u64 dst_capacity) {
wpDebugAssert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL");
u64 to_copy = src->size < dst_capacity ? src->size : dst_capacity - 1;
@@ -223,7 +223,7 @@ void wapp_str8_copy_to_cstr(char *dst, WpStr8RO *src, u64 dst_capacity) {
memcpy(dst, src->buf, to_copy);
}
void wapp_str8_format(WpStr8 *dst, const char *format, ...) {
void wpStr8Format(WpStr8 *dst, const char *format, ...) {
wpDebugAssert(dst != NULL && format != NULL, "`dst` and `format` should not be NULL");
va_list args1;
@@ -241,7 +241,7 @@ void wapp_str8_format(WpStr8 *dst, const char *format, ...) {
va_end(args2);
}
void wapp_str8_to_lower(WpStr8 *dst, WpStr8RO *src) {
void wpStr8ToLower(WpStr8 *dst, WpStr8RO *src) {
wpDebugAssert(src != NULL && dst != NULL, "`dst` and `src` should not be NULL");
wpDebugAssert(dst->capacity >= src->capacity, "`dst` does not have enough capacity");
@@ -252,13 +252,13 @@ void wapp_str8_to_lower(WpStr8 *dst, WpStr8RO *src) {
u64 index = 0;
b8 running = true;
while (running) {
wapp_str8_set(dst, index, (u8)tolower(wapp_str8_get(src, index)));
wpStr8Set(dst, index, (u8)tolower(wpStr8Get(src, index)));
++index;
running = index < src->size;
}
}
void wapp_str8_to_upper(WpStr8 *dst, WpStr8RO *src) {
void wpStr8ToUpper(WpStr8 *dst, WpStr8RO *src) {
wpDebugAssert(src != NULL && dst != NULL, "`dst` and `src` should not be NULL");
wpDebugAssert(dst->capacity >= src->capacity, "`dst` does not have enough capacity");
@@ -269,13 +269,13 @@ void wapp_str8_to_upper(WpStr8 *dst, WpStr8RO *src) {
u64 index = 0;
b8 running = true;
while (running) {
wapp_str8_set(dst, index, (u8)toupper(wapp_str8_get(src, index)));
wpStr8Set(dst, index, (u8)toupper(wpStr8Get(src, index)));
++index;
running = index < src->size;
}
}
void wapp_str8_from_bytes(WpStr8 *dst, const U8Array src) {
void wpStr8FromBytes(WpStr8 *dst, const U8Array src) {
wpDebugAssert(src != NULL && dst != NULL, "`dst` and `src` should not be NULL");
u64 size = wapp_array_count(src) * wapp_array_item_size(src);
@@ -286,7 +286,7 @@ void wapp_str8_from_bytes(WpStr8 *dst, const U8Array src) {
memcpy(dst->buf, src, size);
}
i64 wapp_str8_find(WpStr8RO *str, WpStr8RO substr) {
i64 wpStr8Find(WpStr8RO *str, WpStr8RO substr) {
if (!str || substr.size > str->size) {
return -1;
}
@@ -308,7 +308,7 @@ i64 wapp_str8_find(WpStr8RO *str, WpStr8RO substr) {
return -1;
}
i64 wapp_str8_rfind(WpStr8RO *str, WpStr8RO substr) {
i64 wpStr8Rfind(WpStr8RO *str, WpStr8RO substr) {
if (!str || substr.size > str->size) {
return -1;
}
@@ -330,13 +330,13 @@ i64 wapp_str8_rfind(WpStr8RO *str, WpStr8RO substr) {
return -1;
}
WpStr8List *wapp_str8_split_with_max(const Allocator *allocator, WpStr8RO *str, WpStr8RO *delimiter, i64 max_splits) {
WpStr8List *wpStr8SplitWithMax(const Allocator *allocator, WpStr8RO *str, WpStr8RO *delimiter, i64 max_splits) {
wpDebugAssert(allocator != NULL && str != NULL && delimiter != NULL, "`allocator`, `str` and `delimiter` should not be NULL");
WpStr8List *output = wapp_dbl_list_alloc(WpStr8, allocator);
if (delimiter->size > str->size) {
WpStr8 *full = wapp_str8_alloc_str8(allocator, str);
WpStr8 *full = wpStr8AllocStr8(allocator, str);
if (full) {
wapp_dbl_list_push_back_alloc(WpStr8, allocator, output, full);
}
@@ -347,28 +347,28 @@ WpStr8List *wapp_str8_split_with_max(const Allocator *allocator, WpStr8RO *str,
i64 start = 0;
i64 end = 0;
i64 splits = 0;
WpStr8 *rest = wapp_str8_alloc_str8(allocator, str);
WpStr8 *rest = wpStr8AllocStr8(allocator, str);
WpStr8 *before_str;
while ((end = wapp_str8_find(rest, *delimiter)) != -1) {
while ((end = wpStr8Find(rest, *delimiter)) != -1) {
if (max_splits > 0 && splits >= max_splits) {
break;
}
before_str = wapp_str8_alloc_substr(allocator, str, start, start + end);
before_str = wpStr8AllocSubstr(allocator, str, start, start + end);
if (before_str) {
wapp_dbl_list_push_back_alloc(WpStr8, allocator, output, before_str);
}
wapp_mem_allocator_free(allocator, (void **)&rest, sizeof(WpStr8));
rest = wapp_str8_alloc_substr(allocator, str, start + end + delimiter->size, str->size);
rest = wpStr8AllocSubstr(allocator, str, start + end + delimiter->size, str->size);
start += end + delimiter->size;
++splits;
}
// Ensure the last part of the string after the delimiter is added to the list
rest = wapp_str8_alloc_substr(allocator, str, start, str->size);
rest = wpStr8AllocSubstr(allocator, str, start, str->size);
if (rest) {
wapp_dbl_list_push_back_alloc(WpStr8, allocator, output, rest);
}
@@ -377,13 +377,13 @@ RETURN_STR8_SPLIT:
return output;
}
WpStr8List *wapp_str8_rsplit_with_max(const Allocator *allocator, WpStr8RO *str, WpStr8RO *delimiter, i64 max_splits) {
WpStr8List *wpStr8RsplitWithMax(const Allocator *allocator, WpStr8RO *str, WpStr8RO *delimiter, i64 max_splits) {
wpDebugAssert(allocator != NULL && str != NULL && delimiter != NULL, "`allocator`, `str` and `delimiter` should not be NULL");
WpStr8List *output = wapp_dbl_list_alloc(WpStr8, allocator);
if (delimiter->size > str->size) {
WpStr8 *full = wapp_str8_alloc_str8(allocator, str);
WpStr8 *full = wpStr8AllocStr8(allocator, str);
if (full) {
wapp_dbl_list_push_back_alloc(WpStr8, allocator, output, full);
}
@@ -393,26 +393,26 @@ WpStr8List *wapp_str8_rsplit_with_max(const Allocator *allocator, WpStr8RO *str,
i64 end = 0;
i64 splits = 0;
WpStr8 *rest = wapp_str8_alloc_str8(allocator, str);
WpStr8 *rest = wpStr8AllocStr8(allocator, str);
WpStr8 *after_str;
while ((end = wapp_str8_rfind(rest, *delimiter)) != -1) {
while ((end = wpStr8Rfind(rest, *delimiter)) != -1) {
if (max_splits > 0 && splits >= max_splits) {
break;
}
after_str = wapp_str8_alloc_substr(allocator, rest, end + delimiter->size, str->size);
after_str = wpStr8AllocSubstr(allocator, rest, end + delimiter->size, str->size);
if (after_str) {
wapp_dbl_list_push_front_alloc(WpStr8, allocator, output, after_str);
}
wapp_mem_allocator_free(allocator, (void **)&rest, sizeof(WpStr8));
rest = wapp_str8_alloc_substr(allocator, rest, 0, end);
rest = wpStr8AllocSubstr(allocator, rest, 0, end);
++splits;
}
rest = wapp_str8_alloc_substr(allocator, str, 0, rest->size);
rest = wpStr8AllocSubstr(allocator, str, 0, rest->size);
if (rest) {
wapp_dbl_list_push_front_alloc(WpStr8, allocator, output, rest);
}
@@ -421,11 +421,11 @@ RETURN_STR8_SPLIT:
return output;
}
WpStr8 *wapp_str8_join(const Allocator *allocator, const WpStr8List *list, WpStr8RO *delimiter) {
WpStr8 *wpStr8Join(const Allocator *allocator, const WpStr8List *list, WpStr8RO *delimiter) {
wpDebugAssert(allocator != NULL && list != NULL && delimiter != NULL, "`allocator`, `list` and `delimiter` should not be NULL");
u64 capacity = wapp_str8_list_total_size(list) + (delimiter->size * (list->node_count - 1));
WpStr8 *output = wapp_str8_alloc_buf(allocator, capacity * 2);
u64 capacity = wpStr8ListTotalSize(list) + (delimiter->size * (list->node_count - 1));
WpStr8 *output = wpStr8AllocBuf(allocator, capacity * 2);
// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
// MSVC Spectre mitigation warnings
@@ -438,13 +438,13 @@ WpStr8 *wapp_str8_join(const Allocator *allocator, const WpStr8List *list, WpStr
break;
}
wapp_str8_concat_capped(output, node);
wpStr8ConcatCapped(output, node);
// NOTE (Abdelrahman): Comparison extracted to variable to silence
// MSVC Spectre mitigation warnings
b8 not_last = node_index + 1 < list->node_count;
if (not_last) {
wapp_str8_concat_capped(output, delimiter);
wpStr8ConcatCapped(output, delimiter);
}
++node_index;
@@ -454,7 +454,7 @@ WpStr8 *wapp_str8_join(const Allocator *allocator, const WpStr8List *list, WpStr
return output;
}
u64 wapp_str8_list_total_size(const WpStr8List *list) {
u64 wpStr8ListTotalSize(const WpStr8List *list) {
if (!list) {
return 0;
}
src/base/strings/str8/str8.h
+49 -49
View File
@@ -36,92 +36,92 @@ typedef const WpStr8 WpStr8RO;
#ifdef WP_PLATFORM_CPP
// Uses a lambda to achieve the same behaviour achieved by the C macro
#define wapp_str8_buf(CAPACITY) ([&](){ \
wp_persist c8 buf[CAPACITY] = {}; \
memset(buf, 0, CAPACITY); \
return WpStr8{CAPACITY, 0, buf}; \
#define wpStr8Buf(CAPACITY) ([&](){ \
wp_persist c8 buf[CAPACITY] = {}; \
memset(buf, 0, CAPACITY); \
return WpStr8{CAPACITY, 0, buf}; \
}())
// Uses a lambda to achieve the same behaviour achieved by the C macro
#define wapp_str8_lit(STRING) ([&]() { \
wp_persist c8 buf[sizeof(STRING) * 2] = {}; \
memcpy(buf, STRING, sizeof(STRING)); \
return WpStr8{(sizeof(STRING) - 1) * 2, sizeof(STRING) - 1, buf}; \
#define wpStr8Lit(STRING) ([&]() { \
wp_persist c8 buf[sizeof(STRING) * 2] = {}; \
memcpy(buf, STRING, sizeof(STRING)); \
return WpStr8{(sizeof(STRING) - 1) * 2, sizeof(STRING) - 1, buf}; \
}())
#define wapp_str8_lit_ro(STRING) WpStr8RO{sizeof(STRING) - 1, sizeof(STRING) - 1, (c8 *)STRING}
#define wapp_str8_lit_ro_initialiser_list(STRING) {sizeof(STRING) - 1, sizeof(STRING) - 1, (c8 *)STRING}
#define wpStr8LitRo(STRING) WpStr8RO{sizeof(STRING) - 1, sizeof(STRING) - 1, (c8 *)STRING}
#define wpStr8LitRoInitialiserList(STRING) {sizeof(STRING) - 1, sizeof(STRING) - 1, (c8 *)STRING}
#else
#define wapp_str8_buf(CAPACITY) ((WpStr8){.capacity = CAPACITY, .size = 0, .buf = (c8[CAPACITY]){0}})
#define wpStr8Buf(CAPACITY) ((WpStr8){.capacity = CAPACITY, .size = 0, .buf = (c8[CAPACITY]){0}})
// Utilises the fact that memcpy returns pointer to dest buffer and that getting
// address of compound literals is valid in C to create a string on the stack
#define wapp_str8_lit(STRING) ((WpStr8){.capacity = (sizeof(STRING) - 1) * 2, \
.size = sizeof(STRING) - 1, \
.buf = memcpy(&((c8 [sizeof(STRING) * 2]){0}), \
STRING, \
#define wpStr8Lit(STRING) ((WpStr8){.capacity = (sizeof(STRING) - 1) * 2, \
.size = sizeof(STRING) - 1, \
.buf = memcpy(&((c8 [sizeof(STRING) * 2]){0}), \
STRING, \
sizeof(STRING))})
#define wapp_str8_lit_ro(STRING) ((WpStr8RO){.capacity = sizeof(STRING) - 1, \
.size = sizeof(STRING) - 1, \
#define wpStr8LitRo(STRING) ((WpStr8RO){.capacity = sizeof(STRING) - 1, \
.size = sizeof(STRING) - 1, \
.buf = (c8 *)STRING})
// To be used only when initialising a static storage variable in compilers that don't support
// initialisers with the syntax of wapp_str8_lit_ro (e.g. gcc). Should only be used when necessary
// initialisers with the syntax of wpStr8LitRo (e.g. gcc). Should only be used when necessary
// and only be assigned to a WpStr8RO variable to avoid any attempt at modifying the string
#define wapp_str8_lit_ro_initialiser_list(STRING) {.capacity = sizeof(STRING) - 1, \
.size = sizeof(STRING) - 1, \
#define wpStr8LitRoInitialiserList(STRING) {.capacity = sizeof(STRING) - 1, \
.size = sizeof(STRING) - 1, \
.buf = (c8 *)STRING}
#endif // !WP_PLATFORM_CPP
/**
* WpStr8 allocated buffers
*/
WpStr8 *wapp_str8_alloc_buf(const Allocator *allocator, u64 capacity);
WpStr8 *wapp_str8_alloc_and_fill_buf(const Allocator *allocator, u64 capacity);
WpStr8 *wapp_str8_alloc_cstr(const Allocator *allocator, const char *str);
WpStr8 *wapp_str8_alloc_str8(const Allocator *allocator, WpStr8RO *str);
WpStr8 *wapp_str8_alloc_substr(const Allocator *allocator, WpStr8RO *str, u64 start, u64 end);
WpStr8 *wapp_str8_alloc_concat(const Allocator *allocator, WpStr8 *dst, WpStr8RO *src);
WpStr8 *wpStr8AllocBuf(const Allocator *allocator, u64 capacity);
WpStr8 *wpStr8AllocAndFillBuf(const Allocator *allocator, u64 capacity);
WpStr8 *wpStr8AllocCstr(const Allocator *allocator, const char *str);
WpStr8 *wpStr8AllocStr8(const Allocator *allocator, WpStr8RO *str);
WpStr8 *wpStr8AllocSubstr(const Allocator *allocator, WpStr8RO *str, u64 start, u64 end);
WpStr8 *wpStr8AllocConcat(const Allocator *allocator, WpStr8 *dst, WpStr8RO *src);
// Only needed for allocators like malloc where each allocation has to be freed on its own.
// No need to use it for allocators like Arena.
void wapp_str8_dealloc_buf(const Allocator *allocator, WpStr8 **str);
void wpStr8DeallocBuf(const Allocator *allocator, WpStr8 **str);
/**
* WpStr8 utilities
*/
c8 wapp_str8_get(WpStr8RO *str, u64 index);
void wapp_str8_set(WpStr8 *str, u64 index, c8 c);
void wapp_str8_push_back(WpStr8 *str, c8 c);
b8 wapp_str8_equal(WpStr8RO *s1, WpStr8RO *s2);
b8 wapp_str8_equal_to_count(WpStr8RO* s1, WpStr8RO* s2, u64 count);
WpStr8 wapp_str8_slice(WpStr8RO *str, u64 start, u64 end);
void wapp_str8_concat_capped(WpStr8 *dst, WpStr8RO *src);
void wapp_str8_copy_cstr_capped(WpStr8 *dst, const char *src);
void wapp_str8_copy_str8_capped(WpStr8 *dst, WpStr8RO *src);
void wapp_str8_copy_to_cstr(char *dst, WpStr8RO *src, u64 dst_capacity);
void wapp_str8_format(WpStr8 *dst, const char *format, ...);
void wapp_str8_to_lower(WpStr8 *dst, WpStr8RO *src);
void wapp_str8_to_upper(WpStr8 *dst, WpStr8RO *src);
void wapp_str8_from_bytes(WpStr8 *dst, const U8Array src);
c8 wpStr8Get(WpStr8RO *str, u64 index);
void wpStr8Set(WpStr8 *str, u64 index, c8 c);
void wpStr8PushBack(WpStr8 *str, c8 c);
b8 wpStr8Equal(WpStr8RO *s1, WpStr8RO *s2);
b8 wpStr8EqualToCount(WpStr8RO* s1, WpStr8RO* s2, u64 count);
WpStr8 wpStr8Slice(WpStr8RO *str, u64 start, u64 end);
void wpStr8ConcatCapped(WpStr8 *dst, WpStr8RO *src);
void wpStr8CopyCstrCapped(WpStr8 *dst, const char *src);
void wpStr8CopyStr8Capped(WpStr8 *dst, WpStr8RO *src);
void wpStr8CopyToCstr(char *dst, WpStr8RO *src, u64 dst_capacity);
void wpStr8Format(WpStr8 *dst, const char *format, ...);
void wpStr8ToLower(WpStr8 *dst, WpStr8RO *src);
void wpStr8ToUpper(WpStr8 *dst, WpStr8RO *src);
void wpStr8FromBytes(WpStr8 *dst, const U8Array src);
/**
* WpStr8 find functions
*/
i64 wapp_str8_find(WpStr8RO *str, WpStr8RO substr);
i64 wapp_str8_rfind(WpStr8RO *str, WpStr8RO substr);
i64 wpStr8Find(WpStr8RO *str, WpStr8RO substr);
i64 wpStr8Rfind(WpStr8RO *str, WpStr8RO substr);
/**
* WpStr8 split and join
*/
#define wapp_str8_split(ALLOCATOR, STR, DELIMITER) wapp_str8_split_with_max(ALLOCATOR, STR, DELIMITER, -1)
#define wapp_str8_rsplit(ALLOCATOR, STR, DELIMITER) wapp_str8_rsplit_with_max(ALLOCATOR, STR, DELIMITER, -1)
WpStr8List *wapp_str8_split_with_max(const Allocator *allocator, WpStr8RO *str, WpStr8RO *delimiter, i64 max_splits);
WpStr8List *wapp_str8_rsplit_with_max(const Allocator *allocator, WpStr8RO *str, WpStr8RO *delimiter, i64 max_splits);
WpStr8 *wapp_str8_join(const Allocator *allocator, const WpStr8List *list, WpStr8RO *delimiter);
#define wpStr8Split(ALLOCATOR, STR, DELIMITER) wpStr8SplitWithMax(ALLOCATOR, STR, DELIMITER, -1)
#define wpStr8Rsplit(ALLOCATOR, STR, DELIMITER) wpStr8RsplitWithMax(ALLOCATOR, STR, DELIMITER, -1)
WpStr8List *wpStr8SplitWithMax(const Allocator *allocator, WpStr8RO *str, WpStr8RO *delimiter, i64 max_splits);
WpStr8List *wpStr8RsplitWithMax(const Allocator *allocator, WpStr8RO *str, WpStr8RO *delimiter, i64 max_splits);
WpStr8 *wpStr8Join(const Allocator *allocator, const WpStr8List *list, WpStr8RO *delimiter);
/**
* WpStr8 list utilities
*/
u64 wapp_str8_list_total_size(const WpStr8List *list);
u64 wpStr8ListTotalSize(const WpStr8List *list);
#ifdef WP_PLATFORM_CPP
END_C_LINKAGE
src/log/log.c
+13 -13
View File
@@ -11,9 +11,9 @@
#define MIN_LOG_MSG_LENGTH 32
#define TIME_BUF_CAPACITY 70
wp_intern WpStr8RO L_BRACKET = wapp_str8_lit_ro("[");
wp_intern WpStr8RO R_BRACKET_SPACE = wapp_str8_lit_ro("] ");
wp_intern WpStr8RO R_BRACKET_NEWLINE = wapp_str8_lit_ro("]\n");
wp_intern WpStr8RO L_BRACKET = wpStr8LitRo("[");
wp_intern WpStr8RO R_BRACKET_SPACE = wpStr8LitRo("] ");
wp_intern WpStr8RO R_BRACKET_NEWLINE = wpStr8LitRo("]\n");
typedef struct {
WFile *outlog;
@@ -27,12 +27,12 @@ wp_intern LogConfig LOG_CONFIG = {
.level = WP_LOG_LEVEL_DEBUG,
};
wp_intern WpStr8RO LOG_LEVEL_STRINGS[COUNT_LOG_LEVEL] = {
[WP_LOG_LEVEL_FATAL] = wapp_str8_lit_ro_initialiser_list("fatal "),
[WP_LOG_LEVEL_CRITICAL] = wapp_str8_lit_ro_initialiser_list("critical "),
[WP_LOG_LEVEL_ERROR] = wapp_str8_lit_ro_initialiser_list("error "),
[WP_LOG_LEVEL_WARNING] = wapp_str8_lit_ro_initialiser_list("warning "),
[WP_LOG_LEVEL_INFO] = wapp_str8_lit_ro_initialiser_list("info "),
[WP_LOG_LEVEL_DEBUG] = wapp_str8_lit_ro_initialiser_list("debug "),
[WP_LOG_LEVEL_FATAL] = wpStr8LitRoInitialiserList("fatal "),
[WP_LOG_LEVEL_CRITICAL] = wpStr8LitRoInitialiserList("critical "),
[WP_LOG_LEVEL_ERROR] = wpStr8LitRoInitialiserList("error "),
[WP_LOG_LEVEL_WARNING] = wpStr8LitRoInitialiserList("warning "),
[WP_LOG_LEVEL_INFO] = wpStr8LitRoInitialiserList("info "),
[WP_LOG_LEVEL_DEBUG] = wpStr8LitRoInitialiserList("debug "),
};
wp_intern void _get_current_time_string(WpStr8 *dst);
@@ -107,15 +107,15 @@ wp_intern void _get_current_time_string(WpStr8 *dst) {
struct tm utc;
gmtime_r(&now, &utc);
strftime(buf, sizeof(buf), "%FT%TZ ", &utc);
wapp_str8_copy_cstr_capped(dst, buf);
wpStr8CopyCstrCapped(dst, buf);
}
wp_intern void _write_log_line(WFile *fp, const WpLogger *logger, WpStr8 msg, LogLevel level) {
WpStr8 padding = wapp_str8_buf(MIN_LOG_MSG_LENGTH);
WpStr8 padding = wpStr8Buf(MIN_LOG_MSG_LENGTH);
u32 padding_size = msg.size < MIN_LOG_MSG_LENGTH ? MIN_LOG_MSG_LENGTH - msg.size + 1 : 0;
wapp_str8_format(&padding, "%-*s", padding_size, " ");
wpStr8Format(&padding, "%-*s", padding_size, " ");
WpStr8 time_str = wapp_str8_buf(TIME_BUF_CAPACITY);
WpStr8 time_str = wpStr8Buf(TIME_BUF_CAPACITY);
_get_current_time_string(&time_str);
WpStr8RO **strings = wapp_array(
src/os/cpath/cpath.c
+22 -22
View File
@@ -20,17 +20,17 @@ u32 wapp_cpath_join_path(WpStr8 *dst, const WpStr8List *parts) {
return CPATH_JOIN_EMPTY_PARTS;
}
WpStr8 separator = wapp_str8_buf(4);
wapp_str8_push_back(&separator, WAPP_PATH_SEP);
WpStr8 separator = wpStr8Buf(4);
wpStr8PushBack(&separator, WAPP_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;
}
// Handle first node
WpStr8 *first_node = wapp_dbl_list_get(WpStr8, parts, 0);
wapp_str8_copy_str8_capped(dst, first_node);
wpStr8CopyStr8Capped(dst, first_node);
// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
// MSVC Spectre mitigation warnings
@@ -44,16 +44,16 @@ u32 wapp_cpath_join_path(WpStr8 *dst, const WpStr8List *parts) {
}
if (dst->size > 0) {
char dst_last = wapp_str8_get(dst, dst->size - 1);
char node_start = wapp_str8_get(node, 0);
char dst_last = wpStr8Get(dst, dst->size - 1);
char node_start = wpStr8Get(node, 0);
b8 add_path_sep = dst_last != WAPP_PATH_SEP && node_start != WAPP_PATH_SEP;
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;
@@ -69,22 +69,22 @@ WpStr8 *dirup(const Allocator *allocator, WpStr8RO *path, u64 levels) {
goto RETURN_DIRUP;
}
b8 absolute = wapp_str8_get(path, 0) == WAPP_PATH_SEP;
WpStr8 separator = wapp_str8_buf(4);
wapp_str8_push_back(&separator, WAPP_PATH_SEP);
b8 absolute = wpStr8Get(path, 0) == WAPP_PATH_SEP;
WpStr8 separator = wpStr8Buf(4);
wpStr8PushBack(&separator, WAPP_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 ? WAPP_PATH_SEP : '.');
goto RETURN_DIRUP;
}
if (levels < 1) {
output = wapp_str8_alloc_str8(allocator, path);
output = wpStr8AllocStr8(allocator, path);
goto RETURN_DIRUP;
}
@@ -93,37 +93,37 @@ WpStr8 *dirup(const Allocator *allocator, WpStr8RO *path, u64 levels) {
goto RETURN_DIRUP;
}
WpStr8List *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 ? WAPP_PATH_SEP : '.');
} else {
for (u64 i = 0; i < levels; ++i) {
wapp_dbl_list_pop_back(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, WAPP_PATH_SEP);
}
WpStr8 *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);
}
}
}
src/os/shell/commander/commander.c
+5 -5
View File
@@ -27,14 +27,14 @@ CMDResult wapp_shell_commander_execute(CMDOutHandling out_handling, WpStr8 *out_
Allocator arena = wapp_mem_arena_allocator_init(KiB(500));
WpStr8 *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);
}
// 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);
@@ -45,7 +45,7 @@ CMDResult wapp_shell_commander_execute(CMDOutHandling out_handling, WpStr8 *out_
wp_intern CMDResult execute_command(WpStr8RO *cmd, CMDOutHandling 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");
if (!fp) {
@@ -84,7 +84,7 @@ EXECUTE_COMMAND_CLOSE:
}
wp_intern CMDError get_command_output(FILE *fp, CMDOutHandling out_handling, WpStr8 *out_buf) {
WpStr8 out = wapp_str8_buf(OUT_BUF_LEN);
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) {
@@ -92,7 +92,7 @@ wp_intern CMDError get_command_output(FILE *fp, CMDOutHandling out_handling, WpS
return SHELL_ERR_OUT_BUF_FULL;
}
wapp_str8_concat_capped(out_buf, &out);
wpStr8ConcatCapped(out_buf, &out);
} else if (out_handling == SHELL_OUTPUT_PRINT) {
printf(WP_STR8_SPEC, wpStr8Varg(out));
}
src/os/shell/termcolour/posix/termcolour_posix.c
+17 -17
View File
@@ -10,23 +10,23 @@
#include <stdio.h>
wp_intern WpStr8RO 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"),
[WAPP_TERM_COLOUR_FG_BLACK] = wpStr8LitRoInitialiserList("\033[30m"),
[WAPP_TERM_COLOUR_FG_RED] = wpStr8LitRoInitialiserList("\033[31m"),
[WAPP_TERM_COLOUR_FG_GREEN] = wpStr8LitRoInitialiserList("\033[32m"),
[WAPP_TERM_COLOUR_FG_BLUE] = wpStr8LitRoInitialiserList("\033[34m"),
[WAPP_TERM_COLOUR_FG_CYAN] = wpStr8LitRoInitialiserList("\033[36m"),
[WAPP_TERM_COLOUR_FG_MAGENTA] = wpStr8LitRoInitialiserList("\033[35m"),
[WAPP_TERM_COLOUR_FG_YELLOW] = wpStr8LitRoInitialiserList("\033[33m"),
[WAPP_TERM_COLOUR_FG_WHITE] = wpStr8LitRoInitialiserList("\033[37m"),
[WAPP_TERM_COLOUR_FG_BR_BLACK] = wpStr8LitRoInitialiserList("\033[90m"),
[WAPP_TERM_COLOUR_FG_BR_RED] = wpStr8LitRoInitialiserList("\033[91m"),
[WAPP_TERM_COLOUR_FG_BR_GREEN] = wpStr8LitRoInitialiserList("\033[92m"),
[WAPP_TERM_COLOUR_FG_BR_BLUE] = wpStr8LitRoInitialiserList("\033[94m"),
[WAPP_TERM_COLOUR_FG_BR_CYAN] = wpStr8LitRoInitialiserList("\033[96m"),
[WAPP_TERM_COLOUR_FG_BR_MAGENTA] = wpStr8LitRoInitialiserList("\033[95m"),
[WAPP_TERM_COLOUR_FG_BR_YELLOW] = wpStr8LitRoInitialiserList("\033[93m"),
[WAPP_TERM_COLOUR_FG_BR_WHITE] = wpStr8LitRoInitialiserList("\033[97m"),
[WAPP_TERM_COLOUR_CLEAR] = wpStr8LitRoInitialiserList("\033[0m"),
};
void print_coloured_text(WpStr8RO *text, TerminalColour colour) {
src/os/shell/termcolour/termcolour.c
+1 -1
View File
@@ -13,6 +13,6 @@ void wapp_shell_termcolour_print_text(WpStr8RO *text, TerminalColour colour) {
}
void wapp_shell_termcolour_clear_colour(void) {
WpStr8RO empty = wapp_str8_lit_ro("");
WpStr8RO empty = wpStr8LitRo("");
print_coloured_text(&empty, WAPP_TERM_COLOUR_CLEAR);
}
src/testing/tester/tester.c
+3 -3
View File
@@ -34,14 +34,14 @@ void _runTests(WpTestFunc *func1, ...) {
wp_intern void handleTestResult(WpTestFuncResult result) {
TerminalColour colour;
WpStr8 result_text = wapp_str8_buf(64);
WpStr8 result_text = wpStr8Buf(64);
if (result.passed) {
colour = WAPP_TERM_COLOUR_FG_BR_GREEN;
wapp_str8_copy_cstr_capped(&result_text, "PASSED");
wpStr8CopyCstrCapped(&result_text, "PASSED");
} else {
colour = WAPP_TERM_COLOUR_FG_BR_RED;
wapp_str8_copy_cstr_capped(&result_text, "FAILED");
wpStr8CopyCstrCapped(&result_text, "FAILED");
}
printf("[");
src/testing/tester/tester.h
+2 -2
View File
@@ -10,9 +10,9 @@
#ifdef WP_PLATFORM_CPP
BEGIN_C_LINKAGE
#define wpTesterResult(PASSED) (WpTestFuncResult{wapp_str8_lit_ro(__func__), PASSED, {}})
#define wpTesterResult(PASSED) (WpTestFuncResult{wpStr8LitRo(__func__), PASSED, {}})
#else
#define wpTesterResult(PASSED) ((WpTestFuncResult){.name = wapp_str8_lit_ro(__func__), .passed = PASSED})
#define wpTesterResult(PASSED) ((WpTestFuncResult){.name = wpStr8LitRo(__func__), .passed = PASSED})
#endif // !WP_PLATFORM_CPP
#define wpTesterRun(...) _runTests(__VA_ARGS__, NULL)
src/uuid/uuid.c
+1 -1
View File
@@ -54,5 +54,5 @@ wp_intern void uuid4_to_uuid(const UUID4* uuid4, WpUuid *uuid) {
u64 group4 = uuid4->low >> 48;
u64 group5 = (uuid4->low << 16) >> 16;
wapp_str8_format(&(uuid->uuid), UUID_STR_FORMAT, group1, group2, group3, group4, group5);
wpStr8Format(&(uuid->uuid), UUID_STR_FORMAT, group1, group2, group3, group4, group5);
}
src/uuid/uuid.h
+2 -2
View File
@@ -34,9 +34,9 @@ struct WpUuid {
/* Low level UUID API */
#ifdef WP_PLATFORM_CPP
#define wpUuidCreate() ([&](){ return WpUuid{wapp_str8_buf(WP_UUID_BUF_LENGTH)}; }())
#define wpUuidCreate() ([&](){ return WpUuid{wpStr8Buf(WP_UUID_BUF_LENGTH)}; }())
#else
#define wpUuidCreate() ((WpUuid){.uuid = wapp_str8_buf(WP_UUID_BUF_LENGTH)})
#define wpUuidCreate() ((WpUuid){.uuid = wpStr8Buf(WP_UUID_BUF_LENGTH)})
#endif
// Just returns the same pointer that was passed in with the UUID initialised.