10 files changed, 134 insertions, 133 deletions

diff --git a/Array.c b/Array.c
index c9c9984..c97f741 100644
--- a/Array.c
+++ b/Array.c
@@ -1,5 +1,6 @@
 #include "Array.h"
 #include "Types.h"
+#include "GlobalArena.h"
 #include <stdlib.h>
 #include <string.h>
 
@@ -11,14 +12,14 @@ struct ArrayMeta {
 };
 
 static inline struct ArrayMeta*
-Array_metadata(void* arr) {
+A_metadata(void* arr) {
     return arr - sizeof(struct ArrayMeta);
 }
 
 typedef void* Array;
 
 Array
-Array_new(BumpArena b, usize element_size, usize length) {
+A_new(BumpArena b, usize element_size, usize length) {
     if (NULL == b)
         return NULL;
 
@@ -29,36 +30,36 @@ Array_new(BumpArena b, usize element_size, usize length) {
         .length = length,
     };
 
-    void* start = Balloc(b, sizeof(am) + element_size * length);
+    void* start = B_alloc(b, sizeof(am) + element_size * length);
     memcpy(start, &am, sizeof(am));
     return start + sizeof(am);
 }
 
 usize
-Array_length(Array arr) {
+A_length(Array arr) {
     if (NULL == arr)
         return 0;
-    return Array_metadata(arr)->length;
+    return A_metadata(arr)->length;
 }
 
 usize
-Array_count(Array arr) {
+A_count(Array arr) {
     if (NULL == arr)
         return 0;
-    return Array_metadata(arr)->count;
+    return A_metadata(arr)->count;
 }
 
 Result
-Array_push(Array arr, void *value) {
+A_push(Array arr, void *value) {
     if (NULL == arr)
         return R_Uninitialized;
 
-    struct ArrayMeta *am = Array_metadata(arr);
+    struct ArrayMeta *am = A_metadata(arr);
 
     if (am->count >= am->length) {
-        if (!Bresizeable(am->b, arr))
+        if (!B_resizeable(am->b, arr))
             abort();
-        Bresize(am->b, sizeof(*am) + am->element_size * (am->length <<= 2));
+        B_resize(am->b, sizeof(*am) + am->element_size * (am->length <<= 2));
     }
 
     memcpy(arr + am->count++ * am->element_size, value, am->element_size);
@@ -67,14 +68,19 @@ Array_push(Array arr, void *value) {
 }
 
 void*
-Array_pop(Array arr) {
+A_pop(Array arr) {
     if (NULL == arr)
         return NULL;
 
-    struct ArrayMeta *am = Array_metadata(arr);
+    struct ArrayMeta *am = A_metadata(arr);
 
     if (am->count == 0)
         return NULL;
 
     return arr + am->element_size * --am->count;
 }
+
+Array
+AG_new(usize element_size, usize length) {
+    return A_new(g_arena, element_size, length);
+}
diff --git a/Array.h b/Array.h
index 41b36e7..e7705b2 100644
--- a/Array.h
+++ b/Array.h
@@ -6,10 +6,12 @@
 
 typedef void* Array;
 
-Array  Array_new(BumpArena b, usize element_size, usize length);
-usize  Array_length(Array arr);
-usize  Array_count(Array arr);
-Result Array_push(Array arr, void *value);
-void*  Array_pop(Array arr);
+Array  A_new(BumpArena b, usize element_size, usize length);
+usize  A_length(Array arr);
+usize  A_count(Array arr);
+Result A_push(Array arr, void *value);
+void*  A_pop(Array arr);
+
+Array AG_new(usize element_size, usize length);
 
 #endif /* _ARRAY */
diff --git a/BumpAlloc.c b/BumpAlloc.c
index 327bfd5..77f2bb7 100644
--- a/BumpAlloc.c
+++ b/BumpAlloc.c
@@ -10,7 +10,7 @@ struct BumpArena {
 };
 
 BumpArena
-Bcreate(usize size) {
+B_create(usize size) {
     struct BumpArena *b = malloc(sizeof(struct BumpArena));
     b->memory = malloc(size);
     b->size = size;
@@ -20,7 +20,7 @@ Bcreate(usize size) {
 }
 
 Result
-Bdestroy(BumpArena bp) {
+B_destroy(BumpArena bp) {
     if (NULL == bp)
         return R_Uninitialized;
 
@@ -42,7 +42,7 @@ top_size(struct BumpArena* b) {
 }
 
 void*
-Balloc(BumpArena bp, usize size) {
+B_alloc(BumpArena bp, usize size) {
     if (bp == NULL || size == 0)
         return NULL;
 
@@ -63,7 +63,7 @@ Balloc(BumpArena bp, usize size) {
 }
 
 int
-Bresizeable(BumpArena bp, void* ptr) {
+B_resizeable(BumpArena bp, void* ptr) {
     if (NULL == bp)
         return 0;
 
@@ -74,14 +74,14 @@ Bresizeable(BumpArena bp, void* ptr) {
 }
 
 Result
-Bresize(BumpArena bp, usize size) {
+B_resize(BumpArena bp, usize size) {
     if (NULL == bp)
         return R_Uninitialized;
 
     struct BumpArena *b = (struct BumpArena*)bp;
 
     if (size == 0) {
-        Bfree(bp);
+        B_free(bp);
         return R_Ok;
     }
 
@@ -100,7 +100,7 @@ Bresize(BumpArena bp, usize size) {
 }
 
 Result
-Bfree(BumpArena bp) {
+B_free(BumpArena bp) {
     if (NULL == bp)
         return R_Uninitialized;
 
diff --git a/BumpAlloc.h b/BumpAlloc.h
index e6ba3e3..a381134 100644
--- a/BumpAlloc.h
+++ b/BumpAlloc.h
@@ -5,12 +5,12 @@
 
 typedef void* BumpArena;
 
-BumpArena Bcreate(usize size);
-Result    Bdestroy(BumpArena b);
+BumpArena B_create(usize size);
+Result    B_destroy(BumpArena b);
 
-void*  Balloc(BumpArena b, usize size);
-int    Bresizeable(BumpArena b, void* ptr);
-Result Bresize(BumpArena b, usize size);
-Result Bfree(BumpArena b);
+void*  B_alloc(BumpArena b, usize size);
+int    B_resizeable(BumpArena b, void* ptr);
+Result B_resize(BumpArena b, usize size);
+Result B_free(BumpArena b);
 
 #endif /* _BUMP_ALLOC */
diff --git a/GlobalArena.c b/GlobalArena.c
index 2b45f84..e19e38d 100644
--- a/GlobalArena.c
+++ b/GlobalArena.c
@@ -3,26 +3,21 @@
 BumpArena g_arena = NULL;
 
 void*
-GBalloc(usize size) {
-    return Balloc(g_arena, size);
+BG_alloc(usize size) {
+    return B_alloc(g_arena, size);
 }
 
 int
-GBresizeable(void* ptr) {
-    return Bresizeable(g_arena, ptr);
+BG_resizeable(void* ptr) {
+    return B_resizeable(g_arena, ptr);
 }
 
 Result
-GBresize(usize size) {
-    return Bresize(g_arena, size);
+BG_resize(usize size) {
+    return B_resize(g_arena, size);
 }
 
 Result
-GBfree() {
-    return Bfree(g_arena);
-}
-
-Array
-Array_Gnew(usize element_size, usize length) {
-    return Array_new(g_arena, element_size, length);
+BG_free() {
+    return B_free(g_arena);
 }
diff --git a/GlobalArena.h b/GlobalArena.h
index 219e743..8c2b524 100644
--- a/GlobalArena.h
+++ b/GlobalArena.h
@@ -7,11 +7,9 @@
 // Global bump arena
 extern BumpArena g_arena;
 
-void*  GBalloc(usize size);
-int    GBresizeable(void* ptr);
-Result GBresize(usize size);
-Result GBfree();
-
-Array Array_Gnew(usize element_size, usize length);
+void*  BG_alloc(usize size);
+int    BG_resizeable(void* ptr);
+Result BG_resize(usize size);
+Result BG_free();
 
 #endif /* _GLOBAL_ARENA */
diff --git a/String.c b/String.c
index 2467189..d5bcb88 100644
--- a/String.c
+++ b/String.c
@@ -11,12 +11,12 @@ struct StringMeta {
 };
 
 static inline struct StringMeta*
-String_metadata(String s) {
+S_metadata(String s) {
     return (struct StringMeta*)(s - sizeof(struct StringMeta));
 }
 
 String
-String_new(BumpArena b, const char* str) {
+S_new(BumpArena b, const char* str) {
     if (NULL == b || NULL == str)
         return NULL;
 
@@ -25,7 +25,7 @@ String_new(BumpArena b, const char* str) {
         .length = strlen(str),
     };
 
-    void* start = Balloc(b, sizeof(sm) + sm.length + 1);
+    void* start = B_alloc(b, sizeof(sm) + sm.length + 1);
 
     memcpy(start, &sm, sizeof(sm));
     start += sizeof(sm);
@@ -35,7 +35,7 @@ String_new(BumpArena b, const char* str) {
 }
 
 String
-String_newlen(BumpArena b, usize length) {
+S_newlen(BumpArena b, usize length) {
     if (NULL == b)
         return NULL;
 
@@ -44,7 +44,7 @@ String_newlen(BumpArena b, usize length) {
         .length = length,
     };
 
-    void* start = Balloc(b, sizeof(sm) + sm.length + 1);
+    void* start = B_alloc(b, sizeof(sm) + sm.length + 1);
 
     memcpy(start, &sm, sizeof(sm));
     start += sizeof(sm);
@@ -54,42 +54,42 @@ String_newlen(BumpArena b, usize length) {
 }
 
 static inline usize
-String_allocated(String s) {
-    return sizeof(struct StringMeta) + String_length(s) + 1;
+S_allocated(String s) {
+    return sizeof(struct StringMeta) + S_length(s) + 1;
 }
 
 String
-String_dup(BumpArena b, String s) {
+S_dup(BumpArena b, String s) {
     if (NULL == b || NULL == s)
         return NULL;
 
-    usize allocated = String_allocated(s);
+    usize allocated = S_allocated(s);
 
-    void* start = Balloc(b, allocated);
+    void* start = B_alloc(b, allocated);
     memcpy(start, s - sizeof(struct StringMeta), allocated);
 
     return NULL;
 }
 
 usize
-String_length(String s) {
+S_length(String s) {
     if (NULL == s)
         return 0;
-    return String_metadata(s)->length;
+    return S_metadata(s)->length;
 }
 
 Result
-String_append(String s, const char* str) {
+S_append(String s, const char* str) {
     if (NULL == s)
         return R_Uninitialized;
 
-    struct StringMeta* sm = String_metadata(s);
+    struct StringMeta* sm = S_metadata(s);
 
     usize strlength = strlen(str);
     if (sm->length - strlen(s) < strlength) {
-        if (!Bresizeable(sm->b, s))
+        if (!B_resizeable(sm->b, s))
             return R_Err;
-        Bresize(sm->b, sizeof(*sm) + (sm->length += strlength) + 1);
+        B_resize(sm->b, sizeof(*sm) + (sm->length += strlength) + 1);
     }
 
     strcat(s, str);
@@ -97,18 +97,18 @@ String_append(String s, const char* str) {
 }
 
 Result
-String_prepend(String s, const char* str) {
+S_prepend(String s, const char* str) {
     if (NULL == s)
         return R_Uninitialized;
 
-    struct StringMeta* sm = String_metadata(s);
+    struct StringMeta* sm = S_metadata(s);
 
     usize strlength = strlen(str);
-    if (!Bresizeable(sm->b, s))
+    if (!B_resizeable(sm->b, s))
         return R_Err;
 
     usize orig_len = sm->length;
-    RETURN_NOTOK(Bresize(sm->b, sizeof(*sm) + (sm->length += strlength) + 1));
+    RETURN_NOTOK(B_resize(sm->b, sizeof(*sm) + (sm->length += strlength) + 1));
 
     for (usize i = orig_len; i > 0; --i)
         s[i - 1 + strlength] = s[i - 1];
@@ -119,7 +119,7 @@ String_prepend(String s, const char* str) {
 }
 
 usize
-String_find(String s, char c) {
+S_find(String s, char c) {
     if (NULL == s)
         return -1;
 
@@ -131,7 +131,7 @@ String_find(String s, char c) {
 }
 
 static String
-String_vconcat(BumpArena b, va_list args) {
+S_vconcat(BumpArena b, va_list args) {
     usize length = 0;
 
     va_list temp;
@@ -142,7 +142,7 @@ String_vconcat(BumpArena b, va_list args) {
     va_end(temp);
     printf("%lu\n", length);
 
-    String result = String_newlen(b, length);
+    String result = S_newlen(b, length);
 
     if (0 < length) {
         for (const char* str = va_arg(args, const char*); str != NULL; str = va_arg(args, const char*))
@@ -152,78 +152,78 @@ String_vconcat(BumpArena b, va_list args) {
 }
 
 String
-String_concat(BumpArena b, ...) {
+S_concat(BumpArena b, ...) {
     va_list args;
     usize length = 0;
 
     va_start(args, b);
-    String result = String_vconcat(b, args);
+    String result = S_vconcat(b, args);
     va_end(args);
 
     return result;
 }
 
 static String
-String_vprintf(BumpArena b, const char* fmt, va_list args) {
+S_vprintf(BumpArena b, const char* fmt, va_list args) {
     va_list temp;
     va_copy(temp, args);
     usize length = vsnprintf(NULL, 0, fmt, temp);
     va_end(temp);
 
-    String result = String_newlen(b, length);
+    String result = S_newlen(b, length);
     vsnprintf(result, length, fmt, args);
 
     return result;
 }
 
 String
-String_printf(BumpArena b, const char* fmt, ...) {
+S_printf(BumpArena b, const char* fmt, ...) {
     va_list args;
 
     va_start(args, fmt);
-    String result = String_vprintf(b, fmt, args);
+    String result = S_vprintf(b, fmt, args);
     va_end(args);
 
     return result;
 }
 
 String
-String_Gnew(const char* str) {
-    return String_new(g_arena, str);
+SG_new(const char* str) {
+    return S_new(g_arena, str);
 }
 
 String
-String_Gnewlen(usize length) {
-    return String_newlen(g_arena, length);
+SG_newlen(usize length) {
+    return S_newlen(g_arena, length);
 }
 
 String
-String_Gdup(String s) {
-    return String_dup(g_arena, s);
+SG_dup(String s) {
+    return S_dup(g_arena, s);
 }
 
 String
-String_Gconcat(const char* str, ...) {
+SG_concat(const char* str, ...) {
     if (str == NULL)
         return NULL;
 
     va_list args;
 
     va_start(args, str);
-    String result = String_vconcat(g_arena, args);
+    String result = S_vconcat(g_arena, args);
     va_end(args);
 
-    String_prepend(result, str);
+    S_prepend(result, str);
 
     return result;
 }
 
 String
-String_Gprintf(const char* fmt, ...) {
+SG_printf(const char* fmt, ...) {
     va_list args;
 
     va_start(args, fmt);
-    String result = String_vprintf(g_arena, fmt, args);
+    String result = S_vprintf(g_arena, fmt, args);
     va_end(args);
 
     return result;
diff --git a/String.h b/String.h
index 3955339..9be9195 100644
--- a/String.h
+++ b/String.h
@@ -5,21 +5,21 @@
 
 typedef char* String;
 
-String String_new(BumpArena b, const char* str);
-String String_newlen(BumpArena b, usize length);
-String String_dup(BumpArena b, String s);
-String String_concat(BumpArena b, ...);
-String String_printf(BumpArena b, const char* fmt, ...);
+String S_new(BumpArena b, const char* str);
+String S_newlen(BumpArena b, usize length);
+String S_dup(BumpArena b, String s);
+String S_concat(BumpArena b, ...);
+String S_printf(BumpArena b, const char* fmt, ...);
 
-usize  String_length(String s);
-Result String_append(String s, const char* str);
-Result String_prepend(String s, const char* str);
-usize  String_find(String s, char c);
+usize  S_length(String s);
+Result S_append(String s, const char* str);
+Result S_prepend(String s, const char* str);
+usize  S_find(String s, char c);
 
-String String_Gnew(const char* str);
-String String_Gnewlen(usize length);
-String String_Gdup(String s);
-String String_Gconcat(const char* str, ...);
-String String_Gprintf(const char* fmt, ...);
+String SG_new(const char* str);
+String SG_newlen(usize length);
+String SG_dup(String s);
+String SG_concat(const char* str, ...);
+String SG_printf(const char* fmt, ...);
 
 #endif /* _STRING */
diff --git a/example.c b/example.c
new file mode 100644
index 0000000..bddf398
--- /dev/null
+++ b/example.c
@@ -0,0 +1,29 @@
+#include "Array.h"
+#include "BumpAlloc.h"
+#include "GlobalArena.h"
+#include "String.h"
+#include <stdio.h>
+
+int
+main() {
+    g_arena = B_create(KiB(4));
+
+    int *nums = AG_new(sizeof(int), 8);
+    for (int i = 10; i < 20; ++i) {
+        A_push(nums, &i);
+    }
+
+    printf("%lu/%lu |", A_count(nums), A_length(nums));
+    for (int i = 0; i < A_count(nums); ++i)
+        printf(" %d", nums[i]);
+    printf("\n");
+
+    String s = SG_concat("Hello", " ", "World", "!", NULL);
+    printf("%s\n", s);
+
+    String s1 = SG_printf("%s #%d\n", s, 5);
+    printf("%s\n", s1);
+
+    B_destroy(g_arena);
+    return 0;
+}
diff --git a/main.c b/main.c
deleted file mode 100644
index ccec7b2..0000000
--- a/main.c
+++ /dev/null
@@ -1,29 +0,0 @@
-#include "Array.h"
-#include "BumpAlloc.h"
-#include "GlobalArena.h"
-#include "String.h"
-#include <stdio.h>
-
-int
-main() {
-    g_arena = Bcreate(KiB(4));
-
-    int *nums = Array_Gnew(sizeof(int), 8);
-    for (int i = 10; i < 20; ++i) {
-        Array_push(nums, &i);
-    }
-
-    printf("%lu/%lu |", Array_count(nums), Array_length(nums));
-    for (int i = 0; i < Array_count(nums); ++i)
-        printf(" %d", nums[i]);
-    printf("\n");
-
-    String s = String_Gconcat("Hello", " ", "World", "!", NULL);
-    printf("%s\n", s);
-
-    String s1 = String_Gprintf("%s #%d\n", s, 5);
-    printf("%s\n", s1);
-
-    Bdestroy(g_arena);
-    return 0;
-}