Add BasicString and StringView

This reverts commit d4313fb8e4.

compile

@@ -2,15 +2,10 @@
 
 CC=clang
 INCLUDE="\
-	-Ialiases \
+	$(find src -type d | xargs -I{} echo -n "-I{} ") \
-	-Icpath/include \
-	-Idstr/include \
-	$(find mem/include -type d | xargs -I{} echo -n "-I{} ") \
 "
 SRC="\
-	cpath/src/*.c \
+	$(find src -type f -name *.c | xargs -I{} echo -n "{} ") \
-	dstr/src/*.c \
-	mem/src/*/*.c \
 "
 CFLAGS="-O3 -shared -fPIC -Wall -Werror -pedantic"
 OUT="libwapp.so"

dstr/src/dstr.c

@@ -1,217 +0,0 @@
-#include "dstr.h"
-#include "aliases.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-// Use this scalar to allocate extra memory in order to avoid having to
-// constantly reallocate
-#define CAPACITY_SCALAR 8
-
-struct dstr {
-  u64 capacity;
-  u64 size;
-  char buf[];
-};
-
-String *wapp_dstr_with_capacity(u64 capacity) {
-  String *out = (String *)calloc(1, sizeof(String) + capacity + 1);
-  if (!out) {
-    return NULL;
-  }
-
-  out->capacity = capacity;
-  out->size = 0;
-
-  return out;
-}
-
-String *wapp_dstr_from_string(const char *str) {
-  if (!str) {
-    return NULL;
-  }
-
-  u64 length = strlen(str);
-
-  u64 capacity = length * CAPACITY_SCALAR;
-
-  String *out = wapp_dstr_with_capacity(capacity);
-
-  if (!out) {
-    return NULL;
-  }
-
-  out->size = length;
-  strncpy(out->buf, str, length);
-
-  return out;
-}
-
-void wapp_dstr_update(String **dst, const char *src) {
-  if (!dst || !(*dst)) {
-    return;
-  }
-
-  u64 length = strlen(src);
-
-  String *str = *dst;
-
-  if (length <= str->capacity) {
-    memset(str->buf, 0, str->capacity);
-
-    str->size = length;
-
-    strncpy(str->buf, src, length);
-  } else {
-    u64 capacity = length * CAPACITY_SCALAR;
-
-    String *tmp = (String *)realloc(*dst, sizeof(String) + capacity + 1);
-
-    if (!tmp) {
-      return;
-    }
-
-    tmp->capacity = capacity;
-    tmp->size = length;
-    strncpy(tmp->buf, src, length);
-
-    *dst = tmp;
-  }
-}
-
-void wapp_dstr_free(String **str) {
-  if (!str || !(*str)) {
-    return;
-  }
-
-  free(*str);
-  *str = NULL;
-}
-
-void wapp_dstr_concat(String **dst, const char *src) {
-  if (!dst || !(*dst)) {
-    return;
-  }
-
-  u64 src_length = strlen(src);
-
-  if (src_length == 0) {
-    return;
-  }
-
-  u64 new_length = (*dst)->size + src_length;
-
-  char str[new_length + 1];
-  memset(str, 0, new_length + 1);
-
-  strncpy(str, (*dst)->buf, (*dst)->size);
-  strncat(str, src, src_length);
-
-  wapp_dstr_update(dst, str);
-}
-
-void wapp_dstr_append(String **dst, char c) {
-  if (!dst || !(*dst)) {
-    return;
-  }
-
-  u64 new_length = (*dst)->size + 1;
-
-  char str[new_length + 1];
-  memset(str, 0, new_length + 1);
-
-  strncpy(str, (*dst)->buf, (*dst)->size);
-  str[(*dst)->size] = c;
-
-  wapp_dstr_update(dst, str);
-}
-
-void wapp_dstr_resize(String **str) {
-  if (!str || !(*str)) {
-    return;
-  }
-
-  u64 capacity = (*str)->size;
-
-  String *tmp = (String *)realloc(*str, sizeof(String) + capacity + 1);
-
-  if (!tmp) {
-    return;
-  }
-
-  tmp->capacity = capacity;
-
-  *str = tmp;
-}
-
-void wapp_dstr_clear(String *str) {
-  if (!str || str->size == 0) {
-    return;
-  }
-
-  memset(str->buf, 0, str->capacity);
-  str->size = 0;
-}
-
-void wapp_dstr_print(const String *str) {
-  if (!str) {
-    return;
-  }
-
-  printf("%s\n", str->buf);
-}
-
-i64 wapp_dstr_find(const String *str, const char *substr) {
-  if (!str || !substr) {
-    return -1;
-  }
-
-  u64 substr_length = strlen(substr);
-
-  if (substr_length == 0 || substr_length > str->size) {
-    return -1;
-  }
-
-  char buf[substr_length + 1];
-  memset(buf, 0, substr_length + 1);
-
-  for (u64 i = 0; i < str->size; ++i) {
-    if (i + substr_length >= str->size) {
-      break;
-    }
-
-    for (u64 j = 0; j < substr_length; ++j) {
-      buf[j] = str->buf[i + j];
-    }
-
-    if (strcmp(buf, substr) == 0) {
-      return i;
-    }
-  }
-
-  return -1;
-}
-
-u64 wapp_dstr_length(const String *str) {
-  if (!str) {
-    return 0;
-  }
-
-  return str->size;
-}
-
-u64 wapp_dstr_capacity(const String *str) {
-  if (!str) {
-    return 0;
-  }
-
-  return str->capacity;
-}
-
-const char *wapp_dstr_to_cstr(const String *str) {
-  if (!str) {
-    return "";
-  }
-
-  return str->buf;
-}

mem/include/allocator/mem_allocator.h

@@ -1,31 +0,0 @@
-#ifndef MEM_ALLOCATOR_H
-#define MEM_ALLOCATOR_H
-
-#include "aliases.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif // __cplusplus
-
-typedef void *(MemAllocFunc)(u64 size, void *alloc_obj);
-typedef void *(MemAllocAlignedFunc)(u64 size, u64 alignment, void *alloc_obj);
-typedef void *(MemReallocFunc)(void *ptr, u64 size, void *alloc_obj);
-typedef void *(MemReallocAlignedFunc)(void *ptr, u64 size, u64 alignment,
-                                      void *alloc_obj);
-typedef void(MemFreeFunc)(void *ptr, void *alloc_obj);
-
-typedef struct allocator Allocator;
-struct allocator {
-	void *obj;
-  MemAllocFunc *alloc;
-  MemAllocAlignedFunc *alloc_aligned;
-  MemReallocFunc *realloc;
-  MemReallocAlignedFunc *realloc_aligned;
-  MemFreeFunc *free;
-};
-
-#ifdef __cplusplus
-}
-#endif // __cplusplus
-
-#endif // !MEM_ALLOCATOR_H

mem/include/ctx/mem_ctx.h

@@ -1,30 +0,0 @@
-#ifndef MEM_CTX_H
-#define MEM_CTX_H
-
-#include "mem_arena.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif // __cplusplus
-
-typedef enum {
-  CTX_DEST_BUFFER_MAIN,
-  CTX_DEST_BUFFER_TEMP,
-
-  COUNT_CTX_DEST_BUFFER,
-} CTXDestBuffer;
-
-void wapp_mem_ctx_init(u64 main_buf_capacity, u64 temp_buf_capacity);
-void *wapp_mem_ctx_alloc(CTXDestBuffer buffer, u64 size);
-void *wapp_mem_ctx_alloc_aligned(CTXDestBuffer buffer, u64 size, u64 alignment);
-void *wapp_mem_ctx_realloc(CTXDestBuffer buffer, void *ptr, u64 size);
-void *wapp_mem_ctx_realloc_aligned(CTXDestBuffer buffer, void *ptr, u64 size,
-                                   u64 alignment);
-void wapp_mem_ctx_clear(CTXDestBuffer buffer);
-void wapp_mem_ctx_free(void);
-
-#ifdef __cplusplus
-}
-#endif // __cplusplus
-
-#endif // !MEM_CTX_H

mem/include/libc/mem_libc.h

@@ -1,15 +0,0 @@
-#ifndef MEM_LIBC_H
-#define MEM_LIBC_H
-
-#include "mem_allocator.h"
-#ifdef __cplusplus
-extern "C" {
-#endif // __cplusplus
-
-Allocator wapp_mem_libc_allocator(void);
-
-#ifdef __cplusplus
-}
-#endif // __cplusplus
-
-#endif // !MEM_LIBC_H

mem/src/ctx/mem_ctx.c

@@ -1,101 +0,0 @@
-#include "mem_ctx.h"
-#include "aliases.h"
-#include "mem_arena.h"
-#include <assert.h>
-#include <stdlib.h>
-
-typedef struct mem_ctx MemCTX;
-struct mem_ctx {
-  Arena *main;
-  Arena *temp;
-  bool main_initialised;
-  bool temp_initialised;
-};
-
-internal MemCTX g_context = {0};
-
-internal Arena *get_arena(CTXDestBuffer buffer);
-
-void wapp_mem_ctx_init(u64 main_buf_capacity, u64 temp_buf_capacity) {
-  g_context.main_initialised =
-      wapp_mem_arena_init(&g_context.main, main_buf_capacity);
-  g_context.temp_initialised =
-      wapp_mem_arena_init(&g_context.temp, temp_buf_capacity);
-}
-
-void *wapp_mem_ctx_alloc(CTXDestBuffer buffer, u64 size) {
-  Arena *arena = get_arena(buffer);
-  if (!arena) {
-    return NULL;
-  }
-
-  return wapp_mem_arena_alloc(arena, size);
-}
-
-void *wapp_mem_ctx_alloc_aligned(CTXDestBuffer buffer, u64 size,
-                                 u64 alignment) {
-  Arena *arena = get_arena(buffer);
-  if (!arena) {
-    return NULL;
-  }
-
-  return wapp_mem_arena_alloc_aligned(arena, size, alignment);
-}
-
-void *wapp_mem_ctx_realloc(CTXDestBuffer buffer, void *ptr, u64 size) {
-  Arena *arena = get_arena(buffer);
-  if (!arena) {
-    return NULL;
-  }
-
-	return wapp_mem_arena_realloc(arena, ptr, size);
-}
-
-void *wapp_mem_ctx_realloc_aligned(CTXDestBuffer buffer, void *ptr, u64 size,
-																	 u64 alignment) {
-  Arena *arena = get_arena(buffer);
-  if (!arena) {
-    return NULL;
-  }
-
-	return wapp_mem_arena_realloc_aligned(arena, ptr, size, alignment);
-}
-
-void wapp_mem_ctx_clear(CTXDestBuffer buffer) {
-  Arena *arena = get_arena(buffer);
-  if (!arena) {
-    return;
-  }
-
-  wapp_mem_arena_clear(arena);
-}
-
-void wapp_mem_ctx_free(void) {
-  wapp_mem_arena_free(&(g_context.main));
-  g_context.main_initialised = false;
-
-  wapp_mem_arena_free(&(g_context.temp));
-  g_context.temp_initialised = false;
-}
-
-internal Arena *get_arena(CTXDestBuffer buffer) {
-  Arena *output = NULL;
-
-  switch (buffer) {
-  case CTX_DEST_BUFFER_MAIN:
-    if (g_context.main_initialised) {
-      output = g_context.main;
-    }
-    break;
-  case CTX_DEST_BUFFER_TEMP:
-    if (g_context.temp_initialised) {
-      output = g_context.temp;
-    }
-    break;
-  default:
-    assert(false && "Not all context destination buffers are handled");
-    break;
-  }
-
-  return output;
-}

mem/src/libc/mem_libc.c

@@ -1,46 +0,0 @@
-#include "mem_libc.h"
-#include "aliases.h"
-#include "mem_allocator.h"
-#include <stdlib.h>
-#include <string.h>
-
-internal void *mem_libc_alloc(u64 size, void *alloc_obj);
-internal void *mem_libc_alloc_aligned(u64 size, u64 alignment, void *alloc_obj);
-internal void *mem_libc_realloc(void *ptr, u64 size, void *alloc_obj);
-internal void mem_libc_free(void *ptr, void *alloc_obj);
-
-Allocator wapp_mem_libc_allocator(void) {
-  return (Allocator){
-      .obj = NULL,
-      .alloc = mem_libc_alloc,
-      .alloc_aligned = mem_libc_alloc_aligned,
-      .realloc = mem_libc_realloc,
-      .realloc_aligned = NULL,
-      .free = mem_libc_free,
-  };
-}
-
-internal void *mem_libc_alloc(u64 size, void *alloc_obj) {
-  return calloc(1, size);
-}
-
-internal void *mem_libc_alloc_aligned(u64 size, u64 alignment,
-                                      void *alloc_obj) {
-	void *output = aligned_alloc(alignment, size);
-	if (output) {
-		memset(output, 0, size);
-	}
-
-  return output;
-}
-
-internal void *mem_libc_realloc(void *ptr, u64 size, void *alloc_obj) {
-  void *output = realloc(ptr, size);
-  if (output) {
-    memset(output, 0, size);
-  }
-
-  return output;
-}
-
-internal void mem_libc_free(void *ptr, void *alloc_obj) { free(ptr); }

src/mem/arena/mem_arena.c

@@ -1,7 +1,6 @@
 #include "mem_arena.h"
 #include "aliases.h"
 #include "mem_utils.h"
-#include <math.h>
 #include <stdbool.h>
 #include <stdlib.h>
 #include <string.h>
@@ -12,18 +11,7 @@
 #define DEFAULT_ALIGNMENT (2 * sizeof(void *))
 #endif /* ifndef DEFAULT_ALIGNMENT */
 
-#define HDR_MAGIC_BYTE_COUNT 8
+#define ARENA_MINIMUM_CAPACITY 1024
-#define HDR_MAGIC                                                              \
-  { 0x57, 0x41, 0x41, 0x52, 0x4e, 0x48, 0x44, 0x52 }
-#define MAX_HDR_SEARCH_LENGTH 256
-
-typedef struct arena_alloc_hdr ArenaAllocHDR;
-struct arena_alloc_hdr {
-  u8 magic[HDR_MAGIC_BYTE_COUNT];
-  u64 alloc_size;
-  u64 alignment;
-  u8 *alloc_start;
-};
 
 typedef struct base_arena BaseArena;
 struct base_arena {
@@ -40,14 +28,11 @@ struct growing_arena {
   u64 initial_capacity;
 };
 
-internal BaseArena *find_arena_from_pointer(const Arena *arena, void *ptr);
-
 internal bool base_arena_init(BaseArena *arena, u64 capacity);
 internal void *base_arena_alloc_aligned(BaseArena *arena, u64 size,
                                         u64 alignment);
 internal void base_arena_clear(BaseArena *arena);
-internal void base_arena_free(BaseArena *arena);
+internal void base_arena_destroy(BaseArena *arena);
-internal ArenaAllocHDR *find_alloc_header(BaseArena *arena, void *alloc_ptr);
 
 // PUBLIC API
 
@@ -64,12 +49,12 @@ bool wapp_mem_arena_init(Arena **arena, u64 base_capacity) {
 
   arena_ptr->active_arena = (BaseArena *)calloc(1, sizeof(BaseArena));
   if (!(arena_ptr->active_arena)) {
-    wapp_mem_arena_free(arena);
+    wapp_mem_arena_destroy(arena);
     return false;
   }
 
   if (!base_arena_init(arena_ptr->active_arena, base_capacity)) {
-    wapp_mem_arena_free(arena);
+    wapp_mem_arena_destroy(arena);
     return false;
   }
 
@@ -121,54 +106,6 @@ void *wapp_mem_arena_alloc_aligned(Arena *arena, u64 size, u64 alignment) {
   return output;
 }
 
-void *wapp_mem_arena_realloc(Arena *arena, void *ptr, u64 size) {
-  return wapp_mem_arena_realloc_aligned(arena, ptr, size, DEFAULT_ALIGNMENT);
-}
-
-void *wapp_mem_arena_realloc_aligned(Arena *arena, void *ptr, u64 size,
-                                     u64 alignment) {
-  if (!arena) {
-    return NULL;
-  }
-
-  BaseArena *base_arena = find_arena_from_pointer(arena, ptr);
-  if (!base_arena) {
-    return NULL;
-  }
-
-  ArenaAllocHDR *header = find_alloc_header(base_arena, ptr);
-  if (!header) {
-    return NULL;
-  }
-
-  if (header->alloc_start + header->alloc_size == base_arena->offset) {
-    // Avoid allocating new pointer and copying memory if pointer is at the end
-    // of the arena
-    i64 diff = size - header->alloc_size;
-
-    u8 *new_offset = base_arena->offset + diff;
-
-    u8 *clear_start = diff < 0 ? new_offset : base_arena->offset;
-    memset(clear_start, 0, llabs(diff));
-
-    header->alloc_size = size;
-    base_arena->offset = new_offset;
-
-    return header->alloc_start;
-  }
-
-  void *new_alloc = wapp_mem_arena_alloc_aligned(arena, size, alignment);
-  if (!new_alloc) {
-    return NULL;
-  }
-
-  u64 to_copy = size < header->alloc_size ? size : header->alloc_size;
-
-  memcpy(new_alloc, ptr, to_copy);
-
-  return new_alloc;
-}
-
 void wapp_mem_arena_clear(Arena *arena) {
   if (!arena) {
     return;
@@ -186,7 +123,7 @@ void wapp_mem_arena_clear(Arena *arena) {
   arena->active_arena = last_active;
 }
 
-void wapp_mem_arena_free(Arena **arena) {
+void wapp_mem_arena_destroy(Arena **arena) {
   if (!arena) {
     return;
   }
@@ -204,7 +141,7 @@ void wapp_mem_arena_free(Arena **arena) {
   while (current) {
     next = current->next;
 
-    base_arena_free(current);
+    base_arena_destroy(current);
     free(current);
 
     current = next;
@@ -214,13 +151,13 @@ void wapp_mem_arena_free(Arena **arena) {
   while (current) {
     prev = current->prev;
 
-    base_arena_free(current);
+    base_arena_destroy(current);
     free(current);
 
     current = prev;
   }
 
-  base_arena_free(arena_ptr->active_arena);
+  base_arena_destroy(arena_ptr->active_arena);
 
   free(arena_ptr->active_arena);
   arena_ptr->active_arena = NULL;
@@ -234,41 +171,20 @@ void wapp_mem_arena_free(Arena **arena) {
 
 // INTERNAL FUNCTIONS
 
-internal BaseArena *find_arena_from_pointer(const Arena *arena, void *ptr) {
-  if (!arena || !ptr) {
-    return NULL;
-  }
-
-  // Ensure pointer is not out of bounds
-  u8 *alloc = (u8 *)ptr;
-  BaseArena *active = arena->active_arena;
-
-  if (alloc > active->buf + arena->initial_capacity) {
-    return NULL;
-  }
-
-  for (u64 i = 0; i < arena->count; ++i) {
-    if (alloc >= active->buf && alloc < active->buf + arena->initial_capacity) {
-      return (BaseArena *)active;
-    }
-
-    active = active->prev;
-  }
-
-  return NULL;
-}
-
 internal bool base_arena_init(BaseArena *arena, u64 capacity) {
   if (!arena || arena->buf || capacity == 0) {
     return false;
   }
 
-  arena->buf = (u8 *)calloc(capacity, sizeof(u8));
+  u64 arena_capacity =
+      capacity >= ARENA_MINIMUM_CAPACITY ? capacity : ARENA_MINIMUM_CAPACITY;
+
+  arena->buf = (u8 *)calloc(arena_capacity, sizeof(u8));
   if (!(arena->buf)) {
     return false;
   }
 
-  arena->capacity = capacity;
+  arena->capacity = arena_capacity;
   arena->offset = arena->buf;
   arena->prev = arena->next = NULL;
 
@@ -281,22 +197,13 @@ internal void *base_arena_alloc_aligned(BaseArena *arena, u64 size,
     return NULL;
   }
 
-  u8 *start_offset = arena->offset;
+  u8 *alloc_start = arena->offset;
-  u8 *alloc_start = arena->offset + sizeof(ArenaAllocHDR);
 
   u8 *output = wapp_mem_util_align_forward((void *)alloc_start, alignment);
   if (output + size >= arena->buf + arena->capacity) {
     return NULL;
   }
 
-  ArenaAllocHDR *header = (ArenaAllocHDR *)start_offset;
-  *header = (ArenaAllocHDR){
-      .magic = HDR_MAGIC,
-      .alloc_size = size,
-      .alignment = alignment,
-      .alloc_start = output,
-  };
-
   arena->offset = output + size;
 
   return (void *)output;
@@ -311,7 +218,7 @@ internal void base_arena_clear(BaseArena *arena) {
   arena->offset = arena->buf;
 }
 
-internal void base_arena_free(BaseArena *arena) {
+internal void base_arena_destroy(BaseArena *arena) {
   if (!arena) {
     return;
   }
@@ -324,33 +231,3 @@ internal void base_arena_free(BaseArena *arena) {
   arena->capacity = 0;
   arena->prev = arena->next = NULL;
 }
-
-internal ArenaAllocHDR *find_alloc_header(BaseArena *arena, void *alloc_ptr) {
-  persistent const u8 magic[HDR_MAGIC_BYTE_COUNT] = HDR_MAGIC;
-
-  u8 *current = (u8 *)alloc_ptr;
-
-  u8 *max_search_end = current - MAX_HDR_SEARCH_LENGTH;
-  u8 *arena_buf_start = arena->buf;
-
-  u8 *search_end =
-      max_search_end > arena_buf_start ? max_search_end : arena_buf_start;
-
-  bool match;
-	for (; current >= search_end; --current) {
-    match = true;
-
-    for (u64 i = 0; i < HDR_MAGIC_BYTE_COUNT; ++i) {
-      if (current[i] != magic[i]) {
-        match = false;
-        break;
-      }
-    }
-
-    if (match) {
-      return (ArenaAllocHDR *)current;
-    }
-	}
-
-  return NULL;
-}

src/mem/arena/mem_arena.h

@@ -13,11 +13,8 @@ typedef struct growing_arena Arena;
 bool wapp_mem_arena_init(Arena **arena, u64 base_capacity);
 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 size);
-void *wapp_mem_arena_realloc_aligned(Arena *arena, void *ptr, u64 size,
-                                     u64 alignment);
 void wapp_mem_arena_clear(Arena *arena);
-void wapp_mem_arena_free(Arena **arena);
+void wapp_mem_arena_destroy(Arena **arena);
 
 #ifdef __cplusplus
 }

src/strings/basic_strings/basic_strings.h

@@ -0,0 +1,34 @@
+#ifndef BASIC_STRING_H
+#define BASIC_STRING_H
+
+#include "aliases.h"
+#include <stdio.h>
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+typedef struct bstr BasicString;
+struct bstr {
+  u64 size;
+  const char *buf;
+};
+
+typedef struct strvw StringView;
+struct strvw {
+  const u64 size;
+  const char *buf;
+};
+
+#define new_string(STR)                                                        \
+  { .size = strlen(STR), .buf = STR }
+#define wapp_bstr_new(STR) ((BasicString)new_string(STR))
+#define wapp_strvw_new(STR) ((StringView)new_string(STR))
+#define wapp_string_print(STR) (printf("%.*s\n", (i32)STR.size, STR.buf))
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+#endif // !BASIC_STRING_H

src/strings/dstr/dstr.c

@@ -0,0 +1,174 @@
+#include "dstr.h"
+#include "aliases.h"
+#include "mem_arena.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+// Use this scalar to allocate extra memory in order to avoid having to
+// constantly reallocate
+#define CAPACITY_SCALAR 8
+#define MINIMUM_DSTR_CAPACITY 1024
+
+struct dstr {
+  u64 capacity;
+  u64 size;
+  char buf[];
+};
+
+String *wapp_dstr_with_capacity(u64 capacity, Arena *arena) {
+  if (!arena) {
+    return NULL;
+  }
+
+  String *out =
+      (String *)wapp_mem_arena_alloc(arena, sizeof(String) + capacity + 1);
+  if (!out) {
+    return NULL;
+  }
+
+  out->capacity = capacity;
+  out->size = 0;
+
+  return out;
+}
+
+String *wapp_dstr_from_string(const char *str, Arena *arena) {
+  if (!str || !arena) {
+    return NULL;
+  }
+
+  u64 length = strlen(str);
+  u64 capacity = length * CAPACITY_SCALAR;
+  capacity =
+      capacity >= MINIMUM_DSTR_CAPACITY ? capacity : MINIMUM_DSTR_CAPACITY;
+
+  String *out = wapp_dstr_with_capacity(capacity, arena);
+  if (!out) {
+    return NULL;
+  }
+
+  out->size = length;
+  strncpy(out->buf, str, length + 1);
+
+  return out;
+}
+
+StringUpdate wapp_dstr_update(String **dst, const char *src, Arena *arena) {
+  if (!dst || !(*dst)) {
+    return (StringUpdate){.updated = false, .str = *dst};
+  }
+
+  u64 length = strlen(src);
+
+  String *str = *dst;
+
+  if (length >= str->capacity) {
+    if (!arena) {
+      return (StringUpdate){.updated = false, .str = *dst};
+    }
+
+    String *new_str = wapp_dstr_from_string(src, arena);
+    if (!new_str) {
+      return (StringUpdate){.updated = false, .str = *dst};
+    }
+
+    return (StringUpdate){.updated = true, .str = new_str};
+  }
+
+  memset(str->buf, 0, str->capacity);
+
+  str->size = length;
+
+  strncpy(str->buf, src, length + 1);
+
+  return (StringUpdate){.updated = true, .str = *dst};
+}
+
+StringUpdate wapp_dstr_concat(String **dst, const char *src, Arena *arena) {
+  if (!dst || !(*dst)) {
+    return (StringUpdate){.updated = false, .str = *dst};
+  }
+
+  u64 src_length = strlen(src);
+  if (src_length == 0) {
+    return (StringUpdate){.updated = false, .str = *dst};
+  }
+
+  u64 new_length = (*dst)->size + src_length;
+
+  char str[new_length + 1];
+  memset(str, 0, new_length + 1);
+
+  strncpy(str, (*dst)->buf, (*dst)->size);
+  strncat(str, src, new_length + 1 - (*dst)->size);
+
+  return wapp_dstr_update(dst, str, arena);
+}
+
+void wapp_dstr_clear(String *str) {
+  if (!str || str->size == 0) {
+    return;
+  }
+
+  memset(str->buf, 0, str->capacity);
+  str->size = 0;
+}
+
+void wapp_dstr_print(const String *str) {
+  if (!str) {
+    return;
+  }
+
+  printf("%.*s\n", (i32)str->size, str->buf);
+}
+
+i64 wapp_dstr_find(const String *str, const char *substr) {
+  if (!str || !substr) {
+    return -1;
+  }
+
+  u64 substr_length = strlen(substr);
+  if (substr_length == 0 || substr_length > str->size) {
+    return -1;
+  }
+
+  const char *s1;
+  for (u64 i = 0; i < str->size; ++i) {
+    if (i + substr_length > str->size) {
+      break;
+    }
+
+    s1 = &(str->buf[i]);
+
+    if (strncmp(s1, substr, substr_length) == 0) {
+      return i;
+    }
+  }
+
+  return -1;
+}
+
+u64 wapp_dstr_length(const String *str) {
+  if (!str) {
+    return 0;
+  }
+
+  return str->size;
+}
+
+u64 wapp_dstr_capacity(const String *str) {
+  if (!str) {
+    return 0;
+  }
+
+  return str->capacity;
+}
+
+const char *wapp_dstr_to_cstr(const String *str) {
+  if (!str) {
+    return "";
+  }
+
+  return str->buf;
+}

src/strings/dstr/dstr.h

@@ -2,6 +2,8 @@
 #define DSTR_H
 
 #include "aliases.h"
+#include "mem_arena.h"
+#include <stdbool.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -9,13 +11,16 @@ extern "C" {
 
 typedef struct dstr String;
 
-String *wapp_dstr_with_capacity(u64 capacity);
+typedef struct string_update StringUpdate;
-String *wapp_dstr_from_string(const char *str);
+struct string_update {
-void wapp_dstr_update(String **dst, const char *src);
+  bool updated;
-void wapp_dstr_free(String **str);
+  String *str;
-void wapp_dstr_concat(String **dst, const char *src);
+};
-void wapp_dstr_append(String **dst, char c);
+
-void wapp_dstr_resize(String **str);
+String *wapp_dstr_with_capacity(u64 capacity, Arena *arena);
+String *wapp_dstr_from_string(const char *str, Arena *arena);
+StringUpdate wapp_dstr_update(String **dst, const char *src, Arena *arena);
+StringUpdate wapp_dstr_concat(String **dst, const char *src, Arena *arena);
 void wapp_dstr_clear(String *str);
 void wapp_dstr_print(const String *str);
 i64 wapp_dstr_find(const String *str, const char *substr);