Missing commit

build.sh

@@ -2,4 +2,4 @@
 CFLAGS=${CFLAGS:-"-fsanitize=address -ggdb"}
 CC=${CC:-gcc}
 set -x
-${CC} -DDEBUG -pipe  -Wall -Wextra -Wno-unused-parameter -Wno-unused-variable -std=gnu2x $CFLAGS src/*c
+${CC} -DDEBUG -pipe  -Wall -Wextra -Wno-unused-parameter -Wno-unused-variable -std=gnu2x $CFLAGS src/*c src/base/*c

src/base/arena.c

@@ -1,5 +1,5 @@
 #include "arena.h"
-#include "base_core.h"
+#include "core.h"
 #include "platform.h"
 
 

src/base/arena.h

@@ -1,16 +1,17 @@
 #pragma once
-#include "base_core.h"
+#include "core.h"
 
 
 typedef U32 ArenaFlags;
 typedef struct ArenaOptions ArenaOptions;
 enum {
-    ArenaFlag_NoDecommit, // arena_ temp_end/reset/reset_to doesn't decommit memory
+    ArenaFlag_NoDecommit = 1, // operations which shrinks the arena does not decommit memory.
+                              // (arena_trim() can still decommit when called explicitly)
 };
 struct ArenaOptions {
     U32 size;
     U32 commit_size;
-    ArenaFlags flags; // No flags defined yet
+    ArenaFlags flags;
 };
 
 typedef struct MemoryBlock MemoryBlock;

src/base/core.h

@@ -250,7 +250,20 @@ typedef unsigned __int128 U128;
 #define MemMove(dst, src, len)      memmove(dst, src, len)
 #define MemCopy(dst, src, len)       memcpy(dst, src, len)
 #define MemAppend(dst, src, len)    mempcpy(dst, src, len)
+#define MemCompare(first, second, len) memcmp(first, second, len)
 
+static INLINE U8 *MemFind(U8 *mem, U64 mem_len, U8 *needle, U64 needle_len)
+{
+  if (needle_len > mem_len) {
+      return NULL;
+  }
+  for (U64 i = 0 ; i + needle_len <= mem_len; i++) {
+      if (MemCompare(&mem[i], needle, needle_len) == 0) {
+        return &mem[i];
+      }
+  }
+  return NULL;
+}
 // atomics
 #define Atomic(type) _Atomic(type)
 #define AtomicSub(ptr, val) __atomic_fetch_sub((ptr), (val), __ATOMIC_SEQ_CST)
@@ -397,3 +410,171 @@ static INLINE void  allocator_free_all(Allocator *allocator)
 #define ASAN_UNPOISON_MEMORY_REGION(addr, size) \
   ((void)(addr), (void)(size))
 #endif
+
+
+// linked lists
+
+/*
+  SList - singly linked lists
+    "list" struct must have a "*first" and "**last" member to entrys
+    "first"/"last" structs must have a "*next" member
+*/
+
+/**
+ * Initialize a list
+ *
+ * @param list struct pointer with a *first and a **last member to an entry struct
+ */
+#define SListInit(list)           \
+do {                               \
+    (list)->first = NULL;          \
+    (list)->last = &(list)->first; \
+} while (0)
+
+/**
+ * Adds entry to the head of a list
+ *
+ * @param list struct pointer with a *first and a **last member to an entry struct
+ * @param entry struct pointer with a *next member to an entry struct
+ */
+#define SListAddFirst(list, entry)    \
+do {                                   \
+    (entry)->next = (list)->first;     \
+    if ((entry)->next == NULL) {       \
+        (list)->last = &(entry)->next; \
+    }                                  \
+    (list)->first = (entry);           \
+} while (0)
+
+/**
+ * Adds entry to the tail of a list
+ *
+ * @param list struct pointer with a *first and a **last member to an entry struct
+ * @param entry struct pointer with a *next member to an entry struct
+ */
+#define SListAddLast(list, entry) \
+do {                                \
+    (entry)->next = NULL;           \
+    *(list)->last = (entry);        \
+    (list)->last = &(entry)->next;  \
+} while (0)
+
+/**
+ * Remove head from list, list MUST not be empty
+ *
+ * @param entry struct pointer with a *next member to an entry struct
+ */
+#define SListRemoveFirst(list)          \
+do {                                     \
+    (list)->first = (list)->first->next; \
+    if ((list)->first == NULL) {         \
+        (list)->last = &(list)->first;   \
+    }                                    \
+} while (0)
+
+#define SListIsEmpty(list)    ((list)->first == NULL)
+#define SListResetNode(node)  ((node)->next = NULL)
+
+/*
+  DList - doubly linked lists
+    "list" struct must have a "*first" and "*last" member to entrys
+    "first"/"last" structs must have a "*next" and a "*prev" member
+*/
+
+/**
+ * Initialize a list
+ *
+ * @param list struct pointer with a *first and a *last member to an entry struct
+ */
+#define DListInit(list)           \
+do {                              \
+    (list)->first = NULL;         \
+    (list)->last = NULL;          \
+} while (0)
+
+/**
+ * Adds entry to the head of a list
+ *
+ * @param list struct pointer with a *first and a *last member to an entry struct
+ * @param entry struct pointer with a *next and *prev member to an entry struct
+ */
+#define DListAddFirst(list, entry)             \
+do {                                          \
+  (entry)->next = (list)->first;              \
+  (entry)->prev = NULL;                       \
+    if ((list)->first != NULL) {              \
+        (list)->first->prev = (entry);        \
+    } else {                                  \
+        (list)->last = (entry);               \
+    }                                         \
+    (list)->first = (entry);                  \
+} while (0)
+/**
+ * Adds entry to the tail of a list
+ *
+ * @param list struct pointer with a *first and a *last member to an entry struct
+ * @param entry struct pointer with a *next and *prev member to an entry struct
+ */
+#define DListAddLast(list, entry)  \
+do {                                \
+  (entry)->prev = (list)->last;     \
+  (entry)->next = NULL;             \
+  if ((list)->last != NULL) {       \
+    (list)->last->next = (entry);   \
+  } else {                          \
+    (list)->first = (entry);        \
+  }                                 \
+  (list)->last = (entry);           \
+} while (0)
+
+/**
+ * Remove first entry from list, list MUST not be empty
+ *
+ * @param entry struct pointer with a *next and *prev member to an entry struct
+ */
+#define DListRemoveFirst(list)           \
+do {                                     \
+    (list)->first = (list)->first->next; \
+    if ((list)->first != NULL) {         \
+        (list)->first->prev = NULL;      \
+    } else {                             \
+        (list)->last = NULL;             \
+    }                                    \
+} while (0)
+
+/**
+ * Remove last entry from list, list MUST not be empty
+ *
+ * @param entry struct pointer with a *next and *prev member to an entry struct
+ */
+#define DListRemoveLast(list)             \
+do {                                      \
+    (list)->last = (list)->last->prev;    \
+    if ((list)->last != NULL) {           \
+        (list)->last->next = NULL;        \
+    } else {                              \
+        (list)->first = NULL;             \
+    }                                     \
+} while (0)
+
+/**
+ * Remove last entry from list, entry must be in the list
+ *
+ * @param entry struct pointer with a *next and *prev member to an entry struct
+ */
+#define DListRemove(list, entry)                \
+do {                                            \
+    if ((entry)->next != NULL) {                \
+      (entry)->next->prev = (entry)->prev;      \
+    } else {                                    \
+      (list)->last = (entry)->prev;             \
+    }                                           \
+    if ((entry)->prev != NULL) {                \
+      (entry)->prev->next = (entry)->next;      \
+    } else {                                    \
+      (list)->first = (entry)->next;            \
+    }                                           \
+} while (0)
+
+#define DListIsEmpty(list)    ((list)->first == NULL)
+#define DListResetNode(node) ((node)->next = (node)->prev = NULL)

src/base/marena.h

@@ -1,5 +1,5 @@
 #pragma once
-#include "base_core.h"
+#include "core.h"
 
 // Mini Arena for arena allocations from a supplied buffer
 

src/base/platform.c

@@ -1,4 +1,4 @@
-#include "base_core.h"
+#include "core.h"
 #include "platform.h"
 #include <stdlib.h>
 #include <stdio.h>

src/base/platform.h

@@ -1,6 +1,6 @@
 #pragma once
 #include <stdlib.h>
-#include "base_core.h"
+#include "core.h"
 
 void *platform_malloc(size_t size);
 void platform_free(void *mem);

src/base/pool.c

@@ -19,7 +19,8 @@ APool *apool_create_ex(Allocator *allocator, U32 n_elements, U32 element_size, U
     pool->start = NULL;
 
     if (size != APOOL_AUTOGROW) {
-        U32 total_size = n_elements * size; // Note(nos): guard against unreasonable sizes
+        Assert(n_elements <= U32_Max / size );
+        U32 total_size = n_elements * size;
         U8 * start = allocator_push(allocator, total_size, align);
         for (U32 i = 0; i < total_size; i += size) {
             APoolElement *element = (APoolElement *)&start[i];
@@ -47,6 +48,8 @@ void *apool_alloc(APool *pool)
 void apool_free(APool *pool, void *ptr)
 {
     if (ptr != NULL) {
+        Assert((U8 *)ptr >= pool->start);
+
         APoolElement *element = (APoolElement *)ptr;
         element->next = pool->free_list;
         pool->free_list = element;

src/base/pool.h

@@ -1,5 +1,5 @@
 #pragma once
-#include "base_core.h"
+#include "core.h"
 
 typedef union APoolElement APoolElement;
 union APoolElement {

src/base/string.c

@@ -0,0 +1,583 @@
+#include "string.h"
+
+Str str_empty(void)
+{
+    static const U8 empty_;
+    static const Str str = {(U8 *)&empty_, 0};
+    return str;
+}
+
+Str str_slice(Str str, U32 start, U32 len)
+{
+    Assert(start <= str.len);
+    Assert(len <= str.len - start);
+
+    Str new_str = str_create(&str.str[start], len);
+    return new_str;
+}
+
+Str str_concat(Allocator *alloc, Str first, Str second)
+{
+    Str str;
+    Assert(first.len <= U32_Max - second.len);
+    str.len = first.len + second.len;
+    str.str = allocator_push(alloc, str.len, 1);;
+
+    MemCopy(str.str, first.str, first.len);
+    MemCopy(&str.str[first.len], second.str, second.len);
+
+    return str;
+}
+
+Str str_push(Allocator *alloc, Str str)
+{
+    U8 *mem = (U8 *)allocator_push(alloc, str.len, 1);
+    MemCopy(mem, str.str, str.len);
+
+    return str_create(mem, str.len);
+}
+
+Str str_ascii_trim_left(Str str)
+{
+    U8 *start = str.str;
+    U8 *end = str.str + str.len;
+    while (start != end) {
+        if (!char_is_ascii_whitespace(*start)) {
+            break;
+        }
+        start++;
+    }
+
+    return str_create(start, (U32)(end - start));
+}
+
+Str str_ascii_trim_right(Str str)
+{
+    U8 *start = str.str;
+    U8 *end = str.str + str.len;
+    while (start != end) {
+        if (!char_is_ascii_whitespace(*(end - 1))) {
+            break;
+        }
+        end--;
+    }
+
+    return str_create(start, (U32)(end - start));
+}
+
+Str str_ascii_trim(Str str)
+{
+    Str new_str = str_ascii_trim_left(str);
+    new_str = str_ascii_trim_right(new_str);
+    return new_str;
+}
+
+S64 str_index(Str haystack, Str needle)
+{
+    if (needle.len == 0) {
+        return 0;
+    }
+
+    if (needle.len == 1) {
+        return str_find_byte(haystack, needle.str[0]);
+    }
+    if (needle.len > haystack.len) {
+        return -1;
+    }
+
+    U8 *found = MemFind(haystack.str, haystack.len, needle.str, needle.len);
+    if (found != NULL) {
+        return (S64)(found - haystack.str);
+    }
+
+    return -1;
+}
+
+
+
+static INLINE S16 char_hex_to_binary(U8 c)
+{
+    if (c >='0' && c <='9')
+        return c - '0';
+    else if (c >= 'A' && c <= 'F')
+        return c - 'A' + 10;
+    else if (c >= 'a' && c <= 'f')
+        return c - 'a' + 10;
+
+    return -1;
+}
+
+static const char hex_chars[] = "0123456789ABCDEF";
+
+Str str_hex_encode(Str binary_data, Str hex_result)
+{
+    Assert(hex_result.len  >= binary_data.len * 2);
+    U32 hex_len = binary_data.len * 2;
+    for (U32 i = 0, t = 0; i < binary_data.len; ++i,t+=2) {
+        U8 high_nibble;
+        U8 low_nibble;
+
+        high_nibble = (binary_data.str[i] & 0xF0) >> 4 ;
+        low_nibble =  binary_data.str[i] & 0x0F ;
+
+        hex_result.str[t]   = hex_chars[high_nibble];
+        hex_result.str[t+1] = hex_chars[low_nibble];
+    }
+
+    hex_result.len = hex_len;
+    return hex_result;
+}
+
+Str str_hex_decode(Str hex_str, Str result)
+{
+    Assert(result.len >= hex_str.len/2);
+    U32 dest_pos = 0;
+    U32 source_pos = 0;
+
+    while (source_pos + 1 < hex_str.len) {
+
+        if (char_is_ascii_whitespace(hex_str.str[source_pos])) {
+            source_pos++;
+            continue;
+        }
+
+        S16 high_nibble;
+        S16 low_nibble;
+
+        high_nibble = char_hex_to_binary(hex_str.str[source_pos]);
+        low_nibble = char_hex_to_binary(hex_str.str[source_pos + 1]);
+        if (high_nibble == -1 || low_nibble == -1) {
+            result.len = 0;
+            return result;
+        }
+
+        result.str[dest_pos] = (high_nibble << 4 ) | low_nibble;
+        source_pos += 2;
+        dest_pos++;
+    }
+
+    result.len = dest_pos;
+    return result;
+}
+// split @str on any byte in @separators, place split strings in @vec
+void str_split(Str str, Str separators, StrVec *vec)
+{
+    if (vec->max_len == 0 || str.len == 0) {
+        return;
+    }
+
+    U32 start_pos = 0;
+    for (U32 i = 0; i < str.len; i++) {
+        U8 byte = str.str[i];
+        if (str_find_byte(separators, byte) != -1) {
+            if (vec->len >= vec->max_len) {
+                break;
+            }
+
+            Str sub_str = str_slice(str, start_pos, i - start_pos);
+            vec->strings[vec->len] = sub_str;
+            vec->len++;
+            start_pos = i + 1;
+        }
+    }
+    if (start_pos <= str.len && vec->len < vec->max_len) {
+        Str sub_str = str_slice(str, start_pos, str.len - start_pos);
+        vec->strings[vec->len] = sub_str;
+        vec->len++;
+    }
+}
+
+Str str_join(Allocator *allocator, StrVec strings, Str separator)
+{
+    U32 joined_str_len = 0;
+
+    for (U32 i = 0; i < strings.len; i++) {
+        U32 part_len = strings.strings[i].len;
+        Assert(joined_str_len <= U32_Max - part_len); // overflow
+        joined_str_len += part_len;
+    }
+    if (strings.len > 1) {
+        U32 separator_count = strings.len - 1;
+        Assert(separator.len <= U32_Max / separator_count); // overflow
+        Assert(joined_str_len <= U32_Max - separator.len * separator_count); // overflow
+        joined_str_len += separator.len * separator_count;
+    }
+
+    U8 *joined_str = allocator_push(allocator, joined_str_len, 1);
+    if (strings.len > 0) {
+        U32 pos = 0;
+        Str *str = &strings.strings[0];
+
+        MemCopy(&joined_str[pos], str->str, str->len);
+        pos += str->len;
+
+        for (U32 i = 1; i < strings.len; i++) {
+            str = &strings.strings[i];
+            MemCopy(&joined_str[pos], separator.str, separator.len);
+            pos += separator.len;
+            MemCopy(&joined_str[pos], str->str, str->len);
+            pos += str->len;
+        }
+    }
+
+    return str_create(joined_str, joined_str_len);
+}
+
+
+
+/*
+ * Each entry in utf8_lead[] is an 8-bit descriptor:
+ *
+ *     7 6 5 4 3 2 1 0
+ *    +---------+-----+
+ *    |  range  | len |
+ *    +---------+-----+
+ *
+ * len:
+ *     Number of bytes in the UTF-8 sequence.
+ *
+ *     0 = byte cannot start a valid UTF-8 sequence
+ *     1 = ASCII
+ *     2 = two-byte UTF-8 sequence
+ *     3 = three-byte UTF-8 sequence
+ *     4 = four-byte UTF-8 sequence
+ *
+ * range:
+ *     Selects the legal range for byte 1, the first continuation byte.
+ *
+ * This range is enough to encode all of UTF-8's special boundary rules:
+ *
+ *     E0 A0..BF    prevents overlong 3-byte encodings
+ *     ED 80..9F    excludes UTF-16 surrogate code points
+ *     F0 90..BF    prevents overlong 4-byte encodings
+ *     F4 80..8F    limits Unicode to U+10FFFF
+ *
+ * All continuation bytes after byte 1 simply use the normal 80..BF range.
+ */
+
+#define UTF8_LENGTH_BITS 3u
+#define UTF8_LENGTH_MASK ((1u << UTF8_LENGTH_BITS) - 1u)
+
+#define UTF8_DESC(length, range) \
+    ((U8)((length) | ((U8)(range) << UTF8_LENGTH_BITS)))
+
+#define UTF8_DESC_LENGTH(desc) \
+    ((U8)((desc) & UTF8_LENGTH_MASK))
+
+#define UTF8_DESC_RANGE(desc) \
+    ((U8)((desc) >> UTF8_LENGTH_BITS))
+
+
+/*
+ * Classes of allowed values for the first continuation byte.
+ */
+enum Utf8RangeClass {
+    /*
+     * No continuation byte exists.
+     *
+     * Used only by ASCII descriptors.
+     */
+    UTF8_RANGE_NONE = 0,
+
+    /*
+     * Normal continuation-byte range.
+     */
+    UTF8_RANGE_80_BF,
+
+    /*
+     * E0 xx xx:
+     *
+     * E0 80..9F would encode values below U+0800 and therefore be
+     * non-canonical overlong UTF-8.
+     */
+    UTF8_RANGE_A0_BF,
+
+    /*
+     * ED xx xx:
+     *
+     * ED A0..BF would encode U+D800..U+DFFF, which are UTF-16 surrogate
+     * code points and are not Unicode scalar values.
+     */
+    UTF8_RANGE_80_9F,
+
+    /*
+     * F0 xx xx xx:
+     *
+     * F0 80..8F would encode values below U+10000 and therefore be
+     * non-canonical overlong UTF-8.
+     */
+    UTF8_RANGE_90_BF,
+
+    /*
+     * F4 xx xx xx:
+     *
+     * F4 90..BF would encode values above Unicode's maximum scalar value,
+     * U+10FFFF.
+     */
+    UTF8_RANGE_80_8F,
+};
+
+
+typedef struct {
+    U8 lo;
+    U8 hi;
+} Utf8Range;
+
+/*
+ * Allowed range of the first continuation byte for each range class.
+ *
+ * The normal continuation-byte interval is 0x80..0xBF.
+ */
+static const Utf8Range utf8_ranges[] = {
+    [UTF8_RANGE_NONE]  = { 0x00, 0x00 },
+    [UTF8_RANGE_80_BF] = { 0x80, 0xBF },
+    [UTF8_RANGE_A0_BF] = { 0xA0, 0xBF },
+    [UTF8_RANGE_80_9F] = { 0x80, 0x9F },
+    [UTF8_RANGE_90_BF] = { 0x90, 0xBF },
+    [UTF8_RANGE_80_8F] = { 0x80, 0x8F },
+};
+
+
+
+/*
+ * Each entry in utf8_lead[] is an 8-bit descriptor:
+ *
+ *     7 6 5 4 3 2 1 0
+ *    +---------+-----+
+ *    |  range  | len |
+ *    +---------+-----+
+ *
+ * len:
+ *     Number of bytes in the UTF-8 sequence.
+ *
+ *     0 = byte cannot start a valid UTF-8 sequence
+ *     1 = ASCII
+ *     2 = two-byte UTF-8 sequence
+ *     3 = three-byte UTF-8 sequence
+ *     4 = four-byte UTF-8 sequence
+ *
+ * range:
+ *     Selects the legal range for byte 1, the first continuation byte.
+ *
+ * This range is enough to encode all of UTF-8's special boundary rules:
+ *
+ *     E0 A0..BF    prevents overlong 3-byte encodings
+ *     ED 80..9F    excludes UTF-16 surrogate code points
+ *     F0 90..BF    prevents overlong 4-byte encodings
+ *     F4 80..8F    limits Unicode to U+10FFFF
+ *
+ * All continuation bytes after byte 1 simply use the normal 80..BF range.
+ */
+/*
+ * Classification of every possible first byte.
+ *
+ * The zero-initialized entries are invalid UTF-8 leading bytes:
+ *
+ *     80..BF  continuation bytes cannot start a sequence
+ *     C0..C1  would produce overlong two-byte encodings
+ *     F5..FF  would encode values above U+10FFFF or are otherwise invalid
+ *
+ * Valid leading-byte ranges:
+ *
+ *     00..7F  ASCII
+ *     C2..DF  2 bytes
+ *     E0..EF  3 bytes
+ *     F0..F4  4 bytes
+ *
+ * E0, ED, F0, and F4 receive special range classes because their second
+ * byte is constrained beyond the normal 80..BF continuation-byte range.
+ *
+ */
+static const U8 utf8_lead[256] = {
+    [0x00 ... 0x7F] = UTF8_DESC(1, UTF8_RANGE_NONE),
+
+    [0xC2 ... 0xDF] = UTF8_DESC(2, UTF8_RANGE_80_BF),
+
+    [0xE0]          = UTF8_DESC(3, UTF8_RANGE_A0_BF),
+
+    [0xE1 ... 0xEC] = UTF8_DESC(3, UTF8_RANGE_80_BF),
+
+    [0xED]          = UTF8_DESC(3, UTF8_RANGE_80_9F),
+
+    [0xEE ... 0xEF] = UTF8_DESC(3, UTF8_RANGE_80_BF),
+
+    [0xF0]          = UTF8_DESC(4, UTF8_RANGE_90_BF),
+
+    [0xF1 ... 0xF3] = UTF8_DESC(4, UTF8_RANGE_80_BF),
+
+    [0xF4]          = UTF8_DESC(4, UTF8_RANGE_80_8F),
+};
+
+/*
+ * Decode one Unicode scalar value from UTF-8.
+ *
+ * Valid input:
+ *
+ *     returns the decoded Rune
+ *     valid = true
+ *     width = number of UTF-8 bytes consumed
+ *
+ * Invalid input:
+ *
+ *     returns U+FFFD
+ *     valid = false
+ *     width = 1
+ *
+ * Consuming one byte on malformed input guarantees forward progress and
+ * allows decoding to resume immediately after the offending byte.
+ *
+ * End of input:
+ *
+ *     returns RUNE_EOF
+ *     valid = false
+ *     width = 0
+ */
+RuneDecode _str_utf8_decode_full(Str str, U32 offset)
+{
+    if (str.len == 0 || str.len <= offset) {
+        return (RuneDecode) {
+            .rune  = RUNE_EOF,
+            .width = 0,
+            .valid = false,
+        };
+    }
+    U8 b0 = str.str[offset];
+    U8 desc = utf8_lead[b0];
+    U8 width = UTF8_DESC_LENGTH(desc);
+    /*
+     * width == 0 covers:
+     *
+     *     80..BF
+     *     C0..C1
+     *     F5..FF
+     */
+    if (width == 0)
+        goto invalid;
+
+    /*
+     * We must have the complete candidate sequence before accessing any
+     * continuation bytes below.
+     */
+    if (str.len - offset < width)
+        goto invalid;
+
+    /*
+     * Validate the first continuation byte.
+     *
+     * Its descriptor-selected range handles both the normal continuation
+     * range and the E0 / ED / F0 / F4 boundary cases.
+     */
+    Utf8Range range = utf8_ranges[UTF8_DESC_RANGE(desc)];
+    U8 b1 = str.str[offset + 1];
+
+    if (b1 < range.lo || b1 > range.hi)
+        goto invalid;
+
+    /*
+     * Decode paths are intentionally unrolled.
+     *
+     * Besides avoiding a loop in this hot function, each case combines
+     * continuation-byte validation with scalar construction. The compiler
+     * therefore sees fixed-width operations for every UTF-8 length.
+     */
+    switch (width) {
+    case 2: {
+        /*
+         * 110xxxxx 10xxxxxx
+         *
+         * C2..DF in the lead table already guarantees:
+         *
+         *     - exactly a legal two-byte leader
+         *     - no C0/C1 overlong encoding
+         *
+         * b1 has already been checked against 80..BF.
+         */
+        Rune rune =
+            ((Rune)(b0 & 0x1F) << 6) |
+             (Rune)(b1 & 0x3F);
+
+        return (RuneDecode) {
+            .rune  = rune,
+            .width = 2,
+            .valid = true,
+        };
+    }
+
+    case 3: {
+        /*
+         * 1110xxxx 10xxxxxx 10xxxxxx
+         *
+         * b1 has already been validated using the descriptor-specific
+         * range. Only b2 still needs a continuation-byte check.
+         */
+        U8 b2 = str.str[offset + 2];
+
+        if ((b2 & 0xC0) != 0x80)
+            goto invalid;
+
+        Rune rune =
+            ((Rune)(b0 & 0x0F) << 12) |
+            ((Rune)(b1 & 0x3F) <<  6) |
+             (Rune)(b2 & 0x3F);
+
+        return (RuneDecode) {
+            .rune  = rune,
+            .width = 3,
+            .valid = true,
+        };
+    }
+
+    case 4: {
+        /*
+         * 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+         *
+         * b1 has already been validated using the descriptor-specific
+         * range. b2 and b3 use the ordinary continuation-byte form.
+         */
+        U8 b2 = str.str[offset + 2];
+        U8 b3 = str.str[offset + 3];
+
+        /*
+         * Validate both remaining continuation bytes with one expression.
+         *
+         * For a valid continuation byte:
+         *
+         *     byte & 0xC0 == 0x80
+         *
+         * XOR with 0x80 therefore gives zero in the high two bits.
+         * ORing the two transformed bytes lets us test both at once.
+         */
+        if ((((b2 ^ 0x80) | (b3 ^ 0x80)) & 0xC0) != 0)
+            goto invalid;
+
+        Rune rune =
+            ((Rune)(b0 & 0x07) << 18) |
+            ((Rune)(b1 & 0x3F) << 12) |
+            ((Rune)(b2 & 0x3F) <<  6) |
+             (Rune)(b3 & 0x3F);
+
+        return (RuneDecode) {
+            .rune  = rune,
+            .width = 4,
+            .valid = true,
+        };
+    }
+
+    default:
+        /*
+         * The descriptor table can only produce widths 0..4.
+         * Width 1 was handled by the ASCII fast path.
+         */
+        goto invalid;
+    }
+
+
+invalid:
+    return (RuneDecode) {
+        .rune  = RUNE_ERROR,
+        .width = 1,
+        .valid = false,
+    };
+}
+
+

src/base/string.h

@@ -0,0 +1,295 @@
+#pragma once
+#include "core.h"
+
+typedef struct Str Str;
+struct Str {
+    U8 *str;
+    U32 len;
+};
+
+Str str_empty(void);
+Str str_slice(Str str, U32 start, U32 len);
+// returns -1 if not found, or index start of first needle
+S64 str_index(Str haystack, Str needle);
+
+Str str_concat(Allocator *alloc, Str first, Str second);
+Str str_push(Allocator *alloc, Str str);
+Str str_ascii_trim(Str str);
+Str str_ascii_trim_left(Str str);
+Str str_ascii_trim_right(Str str);
+
+
+#define  str_from_lit(str) str_create(((U8 *)str), sizeof(str) -1)
+#define  S(str) str_from_lit(str)
+#define cstr_len(str) (U32)strlen(str)
+#define str_dup(alloc, str) str_push((alloc), (str))
+
+static INLINE bool str_eq(Str first, Str second)
+{
+    if (first.len != second.len) {
+        return false;
+    }
+    return MemCompare(first.str, second.str, first.len) == 0;
+}
+
+static INLINE bool str_is_empty(Str str)
+{
+    return str.len == 0;
+}
+
+static INLINE Str str_create(U8 *start, U32 len)
+{
+    Str str = {start, len};
+    return str;
+}
+
+static INLINE Str str_from_cstr(const char *cstr)
+{
+    Str str = str_create((U8 *)cstr, cstr_len(cstr));
+    return str;
+}
+
+static INLINE Str str_push_cstr(Allocator *alloc, const char *cstr)
+{
+    Str str = str_from_cstr(cstr);
+    return str_push(alloc, str);
+}
+
+static INLINE S64 str_find_byte(Str str, U8 byte)
+{
+    for (U32 i = 0; i < str.len; i++) {
+        if (str.str[i] == byte) {
+            return i;
+        }
+    }
+
+    return -1;
+}
+
+static INLINE Str str_replace_byte(Str str, U8 orig_byte, U8 new_byte)
+{
+    for (U32 i = 0; i < str.len; i++) {
+        if (str.str[i] == orig_byte) {
+            str.str[i] = new_byte;
+        }
+    }
+
+    return str;
+}
+
+static INLINE bool str_starts_with(Str str, Str prefix)
+{
+    if (prefix.len > str.len) {
+        return false;
+    }
+
+    return MemCompare(str.str, prefix.str, prefix.len) == 0;
+}
+
+static INLINE bool str_ends_with(Str str, Str suffix)
+{
+    if (suffix.len > str.len) {
+        return false;
+    }
+    U32 start = str.len - suffix.len;
+    return MemCompare(&str.str[start], suffix.str, suffix.len) == 0;
+}
+
+static INLINE Str str_skip(Str str, U32 len)
+{
+    U32 skip_len = Min(str.len, len);
+    Str new_str = str_slice(str, skip_len, str.len - skip_len);
+
+    return new_str;
+}
+
+// hex_result must be at least source.len * 2. Returns hex_result.
+Str str_hex_encode(Str binary_data, Str hex_result);
+// result must be at least source.len / 2. Returns result.
+Str str_hex_decode(Str hex_str, Str result);
+
+static INLINE Str str_hex_encode_alloc(Allocator *allocator, Str binary_data)
+{
+    Assert(binary_data.len <= U32_Max / 2);
+    U8 hex_len = binary_data.len * 2;
+    U8 *result = allocator_push_array(allocator, U8, hex_len);
+    Str destination = str_create(result, hex_len);
+
+    return str_hex_encode(binary_data, destination);
+}
+
+static INLINE Str str_hex_decode_alloc(Allocator *allocator, Str hex_str)
+{
+    U8 binary_len = hex_str.len / 2;
+    U8 *result = allocator_push_array(allocator, U8, binary_len);
+    Str destination = str_create(result, binary_len);
+
+    return str_hex_decode(hex_str, destination);
+}
+// String Vector
+typedef struct StrVec StrVec;
+struct StrVec {
+    Str *strings;
+    U32 len;
+    U32 max_len;
+};
+#define STRVEC_STATIC_INITIALIZER(strings_) STRVEC_INITIALIZER((strings_), ArraySize(strings_), ArraySize(strings_))
+#define STRVEC_STATIC_INITIALIZER_EMPTY(strings_) STRVEC_INITIALIZER((strings_), 0, ArraySize(strings_))
+#define STRVEC_INITIALIZER(strings_, len_, max_len_) {.strings = (strings_), .len = (len_), .max_len = (max_len_)}
+
+#define STRVEC_DEFINE(var_name, len_)  \
+    struct { \
+        Str strings[len_];\
+    } var_name##_strvec_array; \
+    StrVec var_name = STRVEC_STATIC_INITIALIZER_EMPTY(var_name##_strvec_array.strings)
+
+void str_split(Str str, Str separators, StrVec *vec);
+Str str_join(Allocator *allocator, StrVec strings, Str separator);
+
+
+// Characters
+
+static INLINE bool char_is_ascii_whitespace(U8 byte)
+{
+    return byte == ' ' || byte == '\t' || byte == '\v' || byte == '\f' || byte == '\r' || byte == '\n';
+}
+
+static INLINE bool char_is_digit(U8 byte)
+{
+    return byte >= '0' && byte <= '9';
+}
+
+
+// UTF-8/Unicode
+
+typedef S32 Rune;
+
+
+/*
+ * Unicode replacement character.
+ *
+ * Returned for malformed UTF-8
+ */
+#define RUNE_ERROR ((Rune)0xFFFD)
+
+#define RUNE_EOF ((Rune)-1)
+#define RUNE_INVALID (-1)
+
+// Maximum valid Unicode code point.
+#define RUNE_MAX  0x10FFFF
+#define RUNE_SURROGATE_MIN 0xD800
+#define RUNE_SURROGATE_MAX 0xDFFF
+#define RUNE_1_MAX ((1 <<  7)- 1)
+#define RUNE_2_MAX ((1 << 11)- 1)
+#define RUNE_3_MAX ((1 << 16)- 1)
+
+typedef struct {
+    Rune rune;
+
+    /*
+     * Number of input bytes consumed.
+     *
+     *   valid UTF-8 : 1..4
+     *   invalid     : 1
+     *   end of input: 0
+     */
+    U8 width;
+
+    /*
+     * True only when rune was decoded from valid UTF-8.
+     *
+     *  U+FFFD itself may legitimately occur in  valid
+     *  input, so rune == RUNE_ERROR does not imply an error.
+     */
+    bool valid;
+} RuneDecode;
+
+// Helper:
+RuneDecode _str_utf8_decode_full(Str str, U32 offset);
+/*
+ * Decode one Unicode scalar value from UTF-8.
+ *
+ * Valid input:
+ *
+ *     returns the decoded Rune
+ *     valid = true
+ *     width = number of UTF-8 bytes consumed
+ *
+ * Invalid input:
+ *
+ *     returns U+FFFD
+ *     valid = false
+ *     width = 1
+ *
+ * Consuming one byte on malformed input guarantees forward progress and
+ * allows decoding to resume immediately after the offending byte.
+ *
+ * End of input:
+ *
+ *     returns RUNE_EOF
+ *     valid = false
+ *     width = 0
+ */
+static INLINE RuneDecode str_utf8_decode(Str str, U32 offset)
+{
+    if (str.len == 0 || str.len <= offset) {
+        return (RuneDecode) {
+            .rune  = RUNE_EOF,
+            .width = 0,
+            .valid = false,
+        };
+    }
+
+    U8 b0 = str.str[offset];
+
+    /*
+     * Testing b0 directly also avoids consulting utf8_ranges[] for the
+     * overwhelmingly common single-byte/ascii case.
+     */
+    if (b0 <= RUNE_1_MAX) {
+        return (RuneDecode) {
+            .rune  = (Rune)b0,
+            .width = 1,
+            .valid = true,
+        };
+    }
+
+    return _str_utf8_decode_full(str, offset);
+}
+
+// Length of bytes to encode the Rune in utf-8.
+// returns -1 if the Rune is not a valid value to encode in UTF-8.
+static INLINE S32 rune_utf8_len(Rune rune) {
+
+	if (rune < 0) {
+		return RUNE_INVALID;
+    } else if (rune <= RUNE_1_MAX) {
+		return 1;
+	} else if (rune <= RUNE_2_MAX) {
+		return 2;
+	} else if (rune >= RUNE_SURROGATE_MIN && rune <= RUNE_SURROGATE_MAX) {
+		return RUNE_INVALID;
+	} else if (rune <= RUNE_3_MAX) {
+		return 3;
+	} else if (rune <= RUNE_MAX) {
+		return 4;
+	}
+
+	return RUNE_INVALID;
+}
+
+// Number of unicode Runes in str. 1 invalid UTF-8 byte is counted as 1 Rune.
+static INLINE U32 str_rune_count(Str str)
+{
+    U32 offset = 0;
+    U32 runes = 0;
+
+    RuneDecode d = str_utf8_decode(str, offset);
+    while (d.rune != RUNE_EOF) {
+        offset += d.width;
+        runes++;
+        d = str_utf8_decode(str, offset);
+    }
+
+    return runes;
+}

src/main.c

@@ -1,9 +1,9 @@
-#include "base_core.h"
-#include "arena.h"
-#include "mini_arena.h"
-#include "platform.h"
-#include "pool.h"
-#include "string.h"
+#include "base/core.h"
+#include "base/arena.h"
+#include "base/marena.h"
+#include "base/platform.h"
+#include "base/pool.h"
+#include "base/string.h"
 #include <stdio.h>
 #include <stdlib.h>
 
@@ -416,7 +416,7 @@ void string_test_1(void)
 {
     TRACEF("\n");
 
-    Str str1 = S_("Hello");
+    Str str1 = S("Hello");
     printf("str1: %.*s len %d\n", str1.len, str1.str, str1.len);
     U64 str1_index_of_l = str_find_byte(str1, 'l');
     U64 str1_index_of_g = str_find_byte(str1, 'g');
@@ -424,7 +424,7 @@ void string_test_1(void)
 
     MARENA_DEFINE(arena, 512, 1);
     Allocator alloc = marena_allocator(&arena);
-    Str str2 = str_dup(&alloc, S_(" World"));
+    Str str2 = str_dup(&alloc, S(" World"));
     Str str3 = str_concat(&alloc, str1, str2);
     printf("str3: %.*s len %d\n", str3.len, str3.str, str3.len);
 }
@@ -433,8 +433,8 @@ void string_split_test_1(void)
 {
     TRACEF("\n");
 
-    Str str1 = S_("a:bb|ccc");
-    Str sep = S_("|:");
+    Str str1 = S("|a:bb|ccc|");
+    Str sep = S("|:");
     STRVEC_DEFINE(strings, 16);
 
     str_split(str1, sep, &strings);
@@ -443,6 +443,235 @@ void string_split_test_1(void)
         printf("split %u: '%.*s'\n", i, str->len, str->str);
     }
 }
+void string_test_misc(void)
+{
+    TRACEF("\n");
+
+    Str str1 = S("Hello World");
+    bool prefix1 = str_starts_with(str1, S("He"));
+    bool prefix2 = str_starts_with(str1, S(""));
+    bool prefix3 = str_starts_with(str1, S("false"));
+    bool prefix4 = str_starts_with(str1, S("Hello World"));
+
+    bool suffix1 = str_ends_with(str1, S("orld"));
+    bool suffix2 = str_ends_with(str1, S(""));
+    bool suffix3 = str_ends_with(str1, S("false"));
+    bool suffix4 = str_ends_with(str1, S("Hello World"));
+    printf("matches: %d %d %d %d %d %d %d %d\n", prefix1, prefix2, prefix3, prefix4, suffix1, suffix2, suffix3, suffix4);
+
+    Str str2 = S(" Hello World\t \n");
+    Str str2_trim = str_ascii_trim(str2);
+    printf("str2_trim: '%.*s'\n", str2_trim.len, str2_trim.str);
+    printf("str2_trim == str1: %d\n", str_eq(str1, str2_trim));
+
+    Str str3 = str_empty();
+    Str str3_trim = str_ascii_trim(str3);
+    printf("str3_trim: '%.*s'\n", str3_trim.len, str3_trim.str);
+
+    Str str4 = S("   \t\t    ");
+    Str str4_trim = str_ascii_trim(str4);
+    printf("str4_trim: '%.*s'\n", str4_trim.len, str4_trim.str);
+
+    S64 found = str_index(str1, S("World"));
+    printf("1. found %ld\n", found);
+    found = str_index(str_empty(), S("World"));
+    printf("2. found %ld\n", found);
+    found = str_index(str_empty(), S(""));
+    printf("3. found %ld\n", found);
+    found = str_index(str1, S(" "));
+    printf("4. found %ld\n", found);
+
+}
+void string_test_join(void)
+{
+    TRACEF("\n");
+    Arena arena;
+    arena_init(&arena, &ArenaOptions_Default);
+    Allocator allocator = arena_allocator(&arena);
+    Str strs[3] = {S("1"), S("two"), S("3-3")};
+    StrVec vec = STRVEC_STATIC_INITIALIZER(strs);
+
+    Str str = str_join(&allocator, vec, S("/"));
+    printf("str_join 1 '%.*s'\n", str.len, str.str);
+    str = str_join(&allocator, vec, S(""));
+    printf("str_join 2 '%.*s'\n", str.len, str.str);
+    vec.len = 0;
+    str = str_join(&allocator, vec, S("/"));
+    printf("str_join 2 '%.*s'\n", str.len, str.str);
+
+}
+
+void print_runes(Str str)
+{
+    U32 offset = 0;
+    U32 len = str_rune_count(str);
+    printf("rune len %d\n", len);
+    while (offset < str.len) {
+        RuneDecode d = str_utf8_decode(str, offset);
+        printf("Rune: %d  valid: %d\n", d.rune, d.valid);
+        offset += d.width;
+    }
+}
+
+void string_test_utf8(void)
+{
+    TRACEF("\n");
+
+    Str str1 = S("Test 1ø2 ☺");
+
+    TRACEF("str1:\n");
+    print_runes(str1);
+
+    Str str2 = str_empty();
+    TRACEF("str2:\n");
+    print_runes(str2);
+
+    Str str3 = S("1Å 2\xc6" "3\xc3");
+    TRACEF("str3:\n");
+    print_runes(str3);
+
+    const char rune_error[] = {0xEF, 0xBF, 0xBD, 0x00} ; // RUNE_ERROR encoded in utf-8
+    Str str4 = S(rune_error);
+    TRACEF("str4:\n");
+    print_runes(str4);  // this should be a valid code point
+
+}
+
+void string_test_hex(void)
+{
+    TRACEF("\n");
+
+    MArena arena;
+    U8 data[4096];
+    marena_init(&arena, data, sizeof data);
+    Allocator allocator = marena_allocator(&arena);
+
+    Str str1 = S("Hello World ☺");
+
+    Str str1_encoded = str_hex_encode_alloc(&allocator, str1);
+    printf("str1_encoded: '%.*s'\n", str1_encoded.len, str1_encoded.str);
+
+    Str str1_decoded = str_hex_decode_alloc(&allocator, str1_encoded);
+    printf("str1_decoded: '%.*s'\n", str1_decoded.len, str1_decoded.str);
+
+    Str str2 = S("");
+
+    Str str2_encoded = str_hex_encode_alloc(&allocator, str2);
+    printf("str2_encoded: '%.*s'\n", str2_encoded.len, str2_encoded.str);
+
+    Str str2_decoded = str_hex_decode_alloc(&allocator, str2_encoded);
+    printf("str2_decoded: '%.*s'\n", str2_decoded.len, str2_decoded.str);
+}
+
+typedef struct StrSLNode StrSLNode;
+struct StrSLNode {
+    Str str;
+    StrSLNode *next;
+};
+
+typedef struct StrSList StrSList;
+struct StrSList {
+    StrSLNode *first;
+    StrSLNode **last;
+};
+
+void string_test_slist(void)
+{
+    TRACEF("\n");
+
+    Str str1 = S("one");
+    Str str2 = S("two");
+    Str str3 = S("three");
+    StrSList strlist = {};
+    StrSLNode n1 = {str1, NULL};
+    StrSLNode n2 = {str2, NULL};
+    StrSLNode n3 = {str3, NULL};
+
+    SListInit(&strlist);
+    SListAddFirst(&strlist, &n1);
+    SListAddFirst(&strlist, &n2);
+    SListAddFirst(&strlist, &n3);
+    TRACEF("List test first\n");
+
+    for (StrSLNode *n = strlist.first; n != NULL; n = n->next) {
+        printf("Node: %.*s\n", n->str.len, n->str.str);
+    }
+    TRACEF("List test first done\n");
+    SListInit(&strlist);
+    SListAddLast(&strlist, &n1);
+    SListAddLast(&strlist, &n2);
+    SListAddLast(&strlist, &n3);
+    SListRemoveFirst(&strlist);
+    TRACEF("List test last\n");
+
+    for (StrSLNode *n = strlist.first; n != NULL; n = n->next) {
+        printf("Node: %.*s\n", n->str.len, n->str.str);
+    }
+    TRACEF("List test last done\n");
+
+}
+typedef struct StrDLNode StrDLNode;
+struct StrDLNode {
+    Str str;
+    StrDLNode *next;
+    StrDLNode *prev;
+};
+
+typedef struct StrDList StrDList;
+struct StrDList {
+    StrDLNode *first;
+    StrDLNode *last;
+};
+
+void string_test_dlist(void)
+{
+    TRACEF("\n");
+
+    Str str1 = S("one");
+    Str str2 = S("two");
+    Str str3 = S("three");
+    Str str4 = S("four");
+    StrDList strlist = {};
+    StrDLNode n1 = {str1, NULL, NULL};
+    StrDLNode n2 = {str2, NULL, NULL};
+    StrDLNode n3 = {str3, NULL, NULL};
+    StrDLNode n4 = {str4, NULL, NULL};
+
+    DListInit(&strlist);
+    DListAddFirst(&strlist, &n1);
+    DListAddFirst(&strlist, &n2);
+    DListAddFirst(&strlist, &n3);
+    TRACEF("List test first\n");
+
+    for (StrDLNode *n = strlist.first; n != NULL; n = n->next) {
+        printf("Node: %.*s\n", n->str.len, n->str.str);
+    }
+    TRACEF("List test first done\n");
+
+    DListInit(&strlist);
+    DListAddLast(&strlist, &n2);
+    DListAddLast(&strlist, &n3);
+    DListAddLast(&strlist, &n4);
+    DListAddFirst(&strlist, &n1);
+
+    TRACEF("List test full\n");
+
+    for (StrDLNode *n = strlist.first; n != NULL; n = n->next) {
+        printf("Node: %.*s\n", n->str.len, n->str.str);
+    }
+    TRACEF("List test full done\n");
+
+    DListRemove(&strlist, &n1);
+    DListRemoveFirst(&strlist);
+    DListRemoveLast(&strlist);
+    TRACEF("List test tail removed\n");
+
+    for (StrDLNode *n = strlist.first; n != NULL; n = n->next) {
+        printf("Node: %.*s\n", n->str.len, n->str.str);
+    }
+    TRACEF("List test tail removed done\n");
+
+}
 
 int main(int argc, char *argv[])
 {
@@ -458,6 +687,12 @@ int main(int argc, char *argv[])
     apool_test_miniarena();
     string_test_1();
     string_split_test_1();
+    string_test_misc();
+    string_test_join();
+    string_test_utf8();
+    string_test_hex();
+    string_test_slist();
+    string_test_dlist();
 
 }
 

src/string.c

@@ -1,72 +0,0 @@
-#include "string.h"
-
-Str str_empty(void)
-{
-    static const U8 empty_;
-    static const Str str = {(U8 *)&empty_, 0};
-    return str;
-}
-
-Str str_substr(Str str, U32 start, U32 len)
-{
-    Assert(start < str.len);
-    Assert(len <= str.len);
-
-    Str new_str = str_create(&str.str[start], len);
-    return new_str;
-}
-
-
-Str str_concat(Allocator *alloc, Str first, Str second)
-{
-    Str str;
-
-    str.len = first.len + second.len;
-    str.str = allocator_push(alloc, str.len, 1);;
-
-    MemCopy(str.str, first.str, first.len);
-    MemCopy(&str.str[first.len], second.str, second.len);
-
-    return str;
-}
-
-Str str_push(Allocator *alloc, Str str)
-{
-    U8 *mem = (U8 *)allocator_push(alloc, sizeof(Str) + str.len, alignof(Str));
-    Str *new_str = (Str *)mem;
-    new_str->len = str.len;
-    new_str->str = &mem[sizeof(Str)];
-    if (!str_is_empty(str)) {
-        MemCopy(new_str->str, str.str, str.len);
-    }
-
-    return *new_str;
-}
-
-// split @str on any byte in @separators, place split strings in @vec
-void str_split(Str str, Str separators, StrVec *vec)
-{
-    if (vec->max_len == 0 || str.len == 0) {
-        return;
-    }
-
-    U32 start_pos = 0;
-    for (U32 i = 0; i < str.len; i++) {
-        U8 byte = str.str[i];
-        if (str_find_byte(separators, byte) != -1) {
-            if (vec->len >= vec->max_len) {
-                break;
-            }
-
-            Str sub_str = str_substr(str, start_pos, i - start_pos);
-            vec->strings[vec->len] = sub_str;
-            vec->len++;
-            start_pos = i + 1;
-        }
-    }
-    if (start_pos < str.len && vec->len < vec->max_len) {
-        Str sub_str = str_substr(str, start_pos, str.len - start_pos);
-        vec->strings[vec->len] = sub_str;
-        vec->len++;
-    }
-}

src/string.h

@@ -1,78 +0,0 @@
-#pragma once
-#include "base_core.h"
-
-typedef struct Str Str;
-struct Str {
-    U8 *str;
-    U32 len;
-};
-
-Str str_empty(void);
-Str str_substr(Str str, U32 start, U32 len);
-Str str_concat(Allocator *alloc, Str first, Str second);
-Str str_push(Allocator *alloc, Str str);
-
-#define  str_from_lit(str) str_create(((U8 *)str), sizeof(str) -1)
-#define  S_(str) str_from_lit(str)
-#define cstr_len(str) (U32)strlen(str)
-#define str_dup(alloc, str) str_push((alloc), (str))
-
-static INLINE bool str_is_empty(Str str)
-{
-    return str.len == 0;
-}
-
-static INLINE Str str_create(U8 *start, U32 len)
-{
-    Str str = {start, len};
-    return str;
-}
-
-static INLINE Str str_from_cstr(const char *cstr)
-{
-    Str str = str_create((U8 *)cstr, cstr_len(cstr));
-    return str;
-}
-
-static INLINE Str str_push_cstr(Allocator *alloc, const char *cstr)
-{
-    Str str = str_from_cstr(cstr);
-    return str_push(alloc, str);
-}
-
-static INLINE S64 str_find_byte(Str str, U8 byte)
-{
-    for (U32 i = 0; i < str.len; i++) {
-        if (str.str[i] == byte) {
-            return i;
-        }
-    }
-
-    return -1;
-}
-
-static INLINE Str str_skip(Str str, U32 len)
-{
-    U32 skip_len = Min(str.len, len);
-    Str new_str = str_substr(str, skip_len, str.len - skip_len);
-
-    return new_str;
-}
-
-
-// String Vector
-typedef struct StrVec StrVec;
-struct StrVec {
-    Str *strings;
-    U32 len;
-    U32 max_len;
-};
-#define STRVEC_STATIC_INITIALIZER(strings_) STRVEC_INITIALIZER((strings_), ArraySize(strings_))
-#define STRVEC_INITIALIZER(strings_, len_) {.strings = (strings_), .len = 0, .max_len = (len_)}
-#define STRVEC_DEFINE(var_name, len_)  \
-    struct { \
-        Str strings[len_];\
-    } var_name##_strvec_array; \
-    StrVec var_name = STRVEC_STATIC_INITIALIZER(var_name##_strvec_array.strings)
-
-void str_split(Str str, Str separators, StrVec *vec);