Consistent styling

3 files changed, 172 insertions, 259 deletions

diff --git a/README.md b/README.md
index 3ceab24..3aa48de 100644
--- a/README.md
+++ b/README.md
@@ -7,8 +7,8 @@ library         | latest version | category | languages | description
 **gb.h**        | 0.03           | misc     | C, C++    | A C helper library for C & C++
 **gb_math.h**   | 0.04d          | math     | C, C++    | A C/C++ vector math library geared towards game development
 **gb_gl.h**     | 0.01           | graphics | C, C++    | A C/C++ OpenGL Helper Library
-**gb_string.h** | 0.93           | strings  | C, C++    | A better string library for C & C++ (this is built into gb.h too with custom allocator support!)
-**gb_ini.h**    | 0.91a          | misc     | C, C++    | A simple ini file loader library for C & C++
+**gb_string.h** | 0.94           | strings  | C, C++    | A better string library for C & C++ (this is built into gb.h too with custom allocator support!)
+**gb_ini.h**    | 0.92           | misc     | C, C++    | A simple ini file loader library for C & C++
 
 
 ## FAQ
diff --git a/gb_ini.h b/gb_ini.h
index 29612cc..20e0c95 100644
--- a/gb_ini.h
+++ b/gb_ini.h
@@ -1,7 +1,8 @@
-// gb_ini.h - v0.91a - public domain ini file loader library - no warranty implied; use at your own risk
+// gb_ini.h - v0.92 - public domain ini file loader library - no warranty implied; use at your own risk
 // A Simple Ini File Loader Library for C and C++
 //
 // Version History:
+//     0.91  - New styling
 //     0.91a - Error handling fix
 //     0.91  - Add extern "C" if compiling as C++
 //     0.90  - Initial Version
@@ -59,17 +60,17 @@ name = Ginger Bill
 #include <stdlib.h>
 struct Library
 {
-	const char* name;
+	char const *name;
 	int         version;
-	const char* license;
-	const char* author;
+	char const *license;
+	char const *author;
 };
 
 // The below macro expands to this:
-// static test_ini_handler(void* data, const char* section, const char* name, const char* value)
+// static test_ini_handlerchar const *data, char const *section, char const *name, char const *value)
 static GB_INI_HANDLER(test_ini_handler)
 {
-	struct Library* lib = (struct Library*)data;
+	struct Library *lib = (struct Library *)data;
 
 	#define TEST(s, n) (strcmp(section, s) == 0 && strcmp(name, n) == 0)
 
@@ -89,10 +90,10 @@ static GB_INI_HANDLER(test_ini_handler)
 	return 1;
 }
 
-int main(int argc, char** argv)
+int main(int argc, char **argv)
 {
 	struct Library lib = {0};
-	struct gb_Ini_Error err = gb_ini_parse("test.ini", &test_ini_handler, &lib);
+	gbIniError err = gb_ini_parse("test.ini", &test_ini_handler, &lib);
 	if (err.type != GB_INI_ERROR_NONE)
 	{
 		if (err.line_num > 0)
@@ -122,14 +123,14 @@ int main(int argc, char** argv)
 
 struct Library
 {
-	const char* name;
+	char const *name;
 	int         version;
-	const char* license;
-	const char* author;
+	char const *license;
+	char const *author;
 };
 
 // The below macro expands to this:
-// static test_ini_handler(void* data, const char* section, const char* name, const char* value)
+// static test_ini_handler(void *data, char const *section, char const *name, char const *value)
 static GB_INI_HANDLER(test_ini_handler)
 {
 	Library* lib = (Library*)data;
@@ -213,8 +214,7 @@ int main(int argc, char** argv)
 extern "C" {
 #endif
 
-enum
-{
+enum {
 	GB_INI_ERROR_NONE = 0,
 
 	GB_INI_ERROR_FILE_ERROR,
@@ -225,33 +225,27 @@ enum
 	GB_INI_ERROR_COUNT,
 };
 
-typedef struct gb_Ini_Error gb_Ini_Error;
-struct gb_Ini_Error
-{
+typedef struct gbIniError {
 	int    type;
 	size_t line_num;
-};
+} gbIniError;
 
 #ifndef GB_INI_HANDLER_RETURN_TYPE
 #define GB_INI_HANDLER_RETURN_TYPE
-typedef int gb_Ini_HRT;
+typedef int gbIniHRT;
 #endif
 
 // This macro can be use to declare this type of function without
 // needing to define all the of the parameters
-#define GB_INI_HANDLER(func_name) gb_Ini_HRT func_name(void* data, const char* section, const char* name, const char* value)
-typedef GB_INI_HANDLER(gb_Ini_Handler);
+#define GB_INI_HANDLER(func_name) gbIniHRT func_name(void *data, char const *section, char const *name, char const *value)
+typedef GB_INI_HANDLER(gbIniHandler);
 
-extern const char* GB_ERROR_STRINGS[GB_INI_ERROR_COUNT];
+extern char const *GB_ERROR_STRINGS[GB_INI_ERROR_COUNT];
 
-gb_Ini_Error gb_ini_parse(const char* filename, gb_Ini_Handler* handler_func, void* data);
-gb_Ini_Error gb_ini_parse_file(FILE* file, gb_Ini_Handler* handler_func, void* data);
+gbIniError gb_ini_parse(char const *filename, gbIniHandler* handler_func, void *data);
+gbIniError gb_ini_parse_file(FILE *file, gbIniHandler* handler_func, void *data);
 
-gb_inline const char*
-gb_ini_error_string(const struct gb_Ini_Error err)
-{
-	return GB_ERROR_STRINGS[err.type];
-}
+gb_inline char const *gb_ini_error_string(gbIniError const err) { return GB_ERROR_STRINGS[err.type]; }
 
 #ifdef __cplusplus
 }
@@ -264,12 +258,11 @@ gb_ini_error_string(const struct gb_Ini_Error err)
 
 namespace gb
 {
-typedef gb_Ini_Error   Ini_Error;
-typedef gb_Ini_Handler Ini_Handler;
+typedef gbIniError   IniError;
+typedef gbIniHandler IniHandler;
 
 // Just a copy but with the GB_ prefix stripped
-enum
-{
+enum {
 	INI_ERROR_NONE = 0,
 
 	INI_ERROR_FILE_ERROR,
@@ -280,23 +273,9 @@ enum
 	// No need for enum count
 };
 
-Ini_Error
-ini_parse(const char* filename, Ini_Handler* handler_func, void* data)
-{
-	return gb_ini_parse(filename, handler_func, data);
-}
-
-Ini_Error
-ini_parse(FILE* file, Ini_Handler* handler_func, void* data)
-{
-	return gb_ini_parse_file(file, handler_func, data);
-}
-
-const char*
-ini_error_string(const Ini_Error err)
-{
-	return GB_ERROR_STRINGS[err.type];
-}
+inline Ini_Error ini_parse(char const *filename, Ini_Handler *handler_func, void *data) { return gb_ini_parse(filename, handler_func, data); }
+inline Ini_Error ini_parse(FILE *file, Ini_Handler *handler_func, void *data) { return gb_ini_parse_file(file, handler_func, data); }
+inline char const *ini_error_string(const Ini_Error err) { return GB_ERROR_STRINGS[err.type]; }
 
 } // namespace gb
 #endif // GB_INI_CPP
@@ -306,7 +285,7 @@ ini_error_string(const Ini_Error err)
 #include <ctype.h>
 #include <string.h>
 
-const char* GB_ERROR_STRINGS[GB_INI_ERROR_COUNT] = {
+char const *GB_ERROR_STRINGS[GB_INI_ERROR_COUNT] = {
 	"",
 
 	"Error in opening file",
@@ -316,7 +295,7 @@ const char* GB_ERROR_STRINGS[GB_INI_ERROR_COUNT] = {
 };
 
 static gb_inline char*
-gb__left_whitespace_skip(const char* str)
+gb__left_whitespace_skip(char const *str)
 {
 	while (*str && isspace((unsigned char)(*str)))
 		str++;
@@ -333,12 +312,10 @@ gb__right_whitespace_strip(char* str)
 }
 
 static gb_inline char*
-gb__find_char_or_comment_in_string(const char* str, char c)
+gb__find_char_or_comment_in_string(char const *str, char c)
 {
 	int was_whitespace = 0;
-	while (*str && *str != c &&
-	       !(was_whitespace && *str == ';'))
-	{
+	while (*str && *str != c && !(was_whitespace && *str == ';')) {
 		was_whitespace = isspace((unsigned char)(*str));
 		str++;
 	}
@@ -347,7 +324,7 @@ gb__find_char_or_comment_in_string(const char* str, char c)
 }
 
 static gb_inline char*
-gb__string_copy(char* dst, const char* src, size_t size)
+gb__string_copy(char* dst, char const *src, size_t size)
 {
 	strncpy(dst, src, size);
 	dst[size - 1] = '\0';
@@ -355,12 +332,12 @@ gb__string_copy(char* dst, const char* src, size_t size)
 }
 
 
-struct gb_Ini_Error
-gb_ini_parse(const char* filename, gb_Ini_Handler* handler_func, void* data)
+gbIniError
+gb_ini_parse(char const *filename, gbIniHandler *handler_func, void *data)
 {
-	struct gb_Ini_Error err = {GB_INI_ERROR_FILE_ERROR, 0};
+	gbIniError err = {GB_INI_ERROR_FILE_ERROR, 0};
 
-	FILE* file = fopen(filename, "r");
+	FILE *file = fopen(filename, "r");
 	if (!file)
 		return err;
 
@@ -369,8 +346,8 @@ gb_ini_parse(const char* filename, gb_Ini_Handler* handler_func, void* data)
 	return err;
 }
 
-struct gb_Ini_Error
-gb_ini_parse_file(FILE* file, gb_Ini_Handler* handler_func, void* data)
+gbIniError
+gb_ini_parse_file(FILE *file, gbIniHandler *handler_func, void *data)
 {
 	char line[GB_INI_MAX_LINE_LENGTH] = "";
 	size_t line_num = 0;
@@ -378,13 +355,12 @@ gb_ini_parse_file(FILE* file, gb_Ini_Handler* handler_func, void* data)
 	char section[GB_INI_MAX_SECTION_LENGTH] = "";
 	char prev_name[GB_INI_MAX_NAME_LENGTH]  = "";
 
-	char* start;
-	char* end;
+	char *start;
+	char *end;
 
-	struct gb_Ini_Error err = {GB_INI_ERROR_NONE, 0};
+	struct gbIniError err = {GB_INI_ERROR_NONE, 0};
 
-	while (fgets(line, GB_INI_MAX_LINE_LENGTH, file) != 0)
-	{
+	while (fgets(line, GB_INI_MAX_LINE_LENGTH, file) != 0) {
 		line_num++;
 
 		start = line;
@@ -394,8 +370,7 @@ gb_ini_parse_file(FILE* file, gb_Ini_Handler* handler_func, void* data)
 		if (line_num == 1 &&
 		    (unsigned char)start[0] == 0xef &&
 		    (unsigned char)start[1] == 0xbb &&
-		    (unsigned char)start[2] == 0xbf)
-		{
+		    (unsigned char)start[2] == 0xbf) {
 			start += 3;
 		}
 #endif
@@ -405,46 +380,37 @@ gb_ini_parse_file(FILE* file, gb_Ini_Handler* handler_func, void* data)
 		if (start[0] == ';' || start[0] == '#')
 			continue; // Allow '#' and ';' comments at start of line
 
-		if (start[0] == '[') // [section]
-		{
+		if (start[0] == '[') { // [section]
 			end = gb__find_char_or_comment_in_string(start+1, ']');
-			if (*end == ']')
-			{
+			if (*end == ']') {
+				char *sect = start + 1;
 				*end = '\0';
-				char* sect = start + 1;
 				sect = gb__left_whitespace_skip(gb__right_whitespace_strip(sect));
 
 				gb__string_copy(section, sect, sizeof(section));
 				*prev_name = '\0';
-			}
-			else if (!err.type)
-			{
+			} else if (!err.type) {
 				err.type = GB_INI_ERROR_MISSING_SECTION_BRACKET;
 				err.line_num = line_num;
 			}
-		}
-		else if (start[0] && start[0] != ';')
-		{
+		} else if (start[0] && start[0] != ';') {
 			end = gb__find_char_or_comment_in_string(start, '=');
-			if (*end == '=')
-			{
+			if (*end == '=') {
+				char *name, *value;
 				*end = '\0';
-				char* name = gb__right_whitespace_strip(start);
-				char* value = gb__left_whitespace_skip(end + 1);
+				name = gb__right_whitespace_strip(start);
+				value = gb__left_whitespace_skip(end + 1);
 				end = gb__find_char_or_comment_in_string(value, '\0');
 				if (*end == ';')
 					*end = '\0';
 				gb__right_whitespace_strip(value);
 
 				gb__string_copy(prev_name, name, sizeof(prev_name));
-				if (!handler_func(data, section, name, value) && !err.type)
-				{
+				if (!handler_func(data, section, name, value) && !err.type) {
 					err.type = GB_INI_ERROR_HANDLER_ERROR;
 					err.line_num = line_num;
 				}
-			}
-			else if (!err.type)
-			{
+			} else if (!err.type) {
 				// No '=' found on name=value line
 				err.type = GB_INI_ERROR_ASSIGNMENT_MISSING;
 				err.line_num = line_num;
diff --git a/gb_string.h b/gb_string.h
index 90e24b0..e3ae331 100644
--- a/gb_string.h
+++ b/gb_string.h
@@ -1,10 +1,11 @@
-// gb_string.h - v0.93 - public domain string library - no warranty implied; use at your own risk
+// gb_string.h - v0.94 - public domain string library - no warranty implied; use at your own risk
 // A Simple Dynamic Strings Library for C and C++
 //
 // Version History:
+//     0.94 - Remove "declare anywhere"
 //     0.93 - Fix typos and errors
 //     0.92 - Add extern "C" if compiling as C++
-//     0.91 - Remove `char* cstr` from String_Header
+//     0.91 - Remove `char * cstr` from String_Header
 //     0.90 - Initial Version
 //
 // LICENSE
@@ -58,7 +59,7 @@
 //         {
 //             size_t length;
 //             size_t capacity;
-//             char*  cstring;
+//             char *  cstring;
 //         };
 //
 //     This library tries to augment normal C strings in a better way that is still
@@ -119,10 +120,10 @@
 #define GB_STRING_IMPLEMENTATION
 #include "gb_string.h"
 
-int main(int argc, char** argv)
+int main(int argc, char **argv)
 {
-	gb_String str = gb_make_string("Hello");
-	gb_String other_str = gb_make_string_length(", ", 2);
+	gbString str = gb_make_string("Hello");
+	gbString other_str = gb_make_string_length(", ", 2);
 	str = gb_append_string(str, other_str);
 	str = gb_append_cstring(str, "world!");
 
@@ -159,7 +160,7 @@ int main(int argc, char** argv)
 #define GB_STRING_IMPLEMENTATION
 #include "gb_string.h"
 
-int main(int argc, char** argv)
+int main(int argc, char **argv)
 {
 	using namespace gb;
 
@@ -196,7 +197,7 @@ int main(int argc, char** argv)
 
 #ifndef GB_ALLOC
 #define GB_ALLOC(sz) malloc(sz)
-#define GB_FREE(sz)  free(sz)
+#define GB_FREE(ptr) free(ptr)
 #endif
 
 #ifndef _MSC_VER
@@ -215,9 +216,9 @@ int main(int argc, char** argv)
 extern "C" {
 #endif
 
-typedef char* gb_String;
+typedef char *gbString;
 
-typedef signed int gb_bool;
+typedef int gbBool;
 #if !defined(GB_TRUE) || !defined(GB_FALSE)
 #define GB_TRUE  1
 #define GB_FALSE 0
@@ -225,7 +226,7 @@ typedef signed int gb_bool;
 
 #ifndef GB_SIZE_TYPE
 #define GB_SIZE_TYPE
-typedef size_t gb_usize;
+typedef size_t gbUsize;
 #endif
 
 #ifndef GB_NULLPTR
@@ -240,38 +241,37 @@ typedef size_t gb_usize;
 	#endif
 #endif
 
-struct gb_String_Header
-{
-	gb_usize len;
-	gb_usize cap;
-};
+typedef struct gbStringHeader {
+	gbUsize len;
+	gbUsize cap;
+} gbStringHeader;
 
-#define GB_STRING_HEADER(s) ((struct gb_String_Header*)s - 1)
+#define GB_STRING_HEADER(s) ((gbStringHeader *)s - 1)
 
-gb_String gb_make_string(const char* str);
-gb_String gb_make_string_length(const void* str, gb_usize len);
-void gb_free_string(gb_String str);
+gbString gb_make_string(char const *str);
+gbString gb_make_string_length(void const *str, gbUsize len);
+void gb_free_string(gbString str);
 
-gb_String gb_duplicate_string(const gb_String str);
+gbString gb_duplicate_string(gbString const str);
 
-gb_usize gb_string_length(const gb_String str);
-gb_usize gb_string_capacity(const gb_String str);
-gb_usize gb_string_available_space(const gb_String str);
+gbUsize gb_string_length(gbString const str);
+gbUsize gb_string_capacity(gbString const str);
+gbUsize gb_string_available_space(gbString const str);
 
-void gb_clear_string(gb_String str);
+void gb_clear_string(gbString str);
 
-gb_String gb_append_string_length(gb_String str, const void* other, gb_usize len);
-gb_String gb_append_string(gb_String str, const gb_String other);
-gb_String gb_append_cstring(gb_String str, const char* other);
+gbString gb_append_string_length(gbString str, void const *other, gbUsize len);
+gbString gb_append_string(gbString str, gbString const other);
+gbString gb_append_cstring(gbString str, char const *other);
 
-gb_String gb_set_string(gb_String str, const char* cstr);
+gbString gb_set_string(gbString str, char const *cstr);
 
-gb_String gb_string_make_space_for(gb_String str, gb_usize add_len);
-gb_usize gb_string_allocation_size(const gb_String str);
+gbString gb_string_make_space_for(gbString str, gbUsize add_len);
+gbUsize gb_string_allocation_size(gbString const str);
 
-gb_bool gb_strings_are_equal(const gb_String lhs, const gb_String rhs);
+gbBool gb_strings_are_equal(gbString const lhs, gbString const rhs);
 
-gb_String gb_trim_string(gb_String str, const char* cut_set);
+gbString gb_trim_string(gbString str, char const *cut_set);
 
 
 #ifdef __cplusplus
@@ -286,117 +286,57 @@ gb_String gb_trim_string(gb_String str, const char* cut_set);
 
 namespace gb
 {
-typedef gb_String String;
-typedef gb_usize usize;
-
-gb_inline String make_string(const char* str = "")
-{
-	return gb_make_string(str);
-}
-
-gb_inline String make_string(const void* str, usize len)
-{
-	return gb_make_string_length(str, len);
-}
-
-gb_inline void free_string(String& str)
-{
-	gb_free_string(str);
-	str = GB_NULLPTR;
-}
-
-gb_inline String duplicate_string(const String str)
-{
-	return gb_duplicate_string(str);
-}
-
-gb_inline usize string_length(const String str)
-{
-	return gb_string_length(str);
-}
-
-gb_inline usize string_capacity(const String str)
-{
-	return gb_string_capacity(str);
-}
-
-gb_inline usize string_available_space(const String str)
-{
-	return gb_string_available_space(str);
-}
-
-gb_inline void clear_string(String str)
-{
-	gb_clear_string(str);
-}
-
-gb_inline void append_string_length(String& str, const void* other, usize len)
-{
-	str = gb_append_string_length(str, other, len);
-}
-
-gb_inline void append_string(String& str, const String other)
-{
-	str = gb_append_string(str, other);
-}
-
-gb_inline void append_cstring(String& str, const char* other)
-{
-	str = gb_append_cstring(str, other);
-}
-
-gb_inline void set_string(String& str, const char* cstr)
-{
-	str = gb_set_string(str, cstr);
-}
-
-gb_inline void string_make_space_for(String& str, usize add_len)
-{
-	str = gb_string_make_space_for(str, add_len);
-}
-
-gb_inline usize string_allocation_size(const String str)
-{
-	return gb_string_allocation_size(str);
-}
-
-gb_inline bool strings_are_equal(const String lhs, const String rhs)
-{
-	return gb_strings_are_equal(lhs, rhs) == GB_TRUE;
-}
-
-gb_inline void trim_string(String& str, const char* cut_set)
-{
-	str = gb_trim_string(str, cut_set);
-}
-
+typedef gbString String;
+typedef gbUsize usize;
+
+gb_inline String make_string(char const *str = "") { return gb_make_string(str); }
+gb_inline String make_string(void const *str, usize len) { return gb_make_string_length(str, len); }
+gb_inline void free_string(String& str) { gb_free_string(str); str = GB_NULLPTR; }
+gb_inline String duplicate_string(const String str) { return gb_duplicate_string(str); }
+gb_inline usize string_length(const String str) { return gb_string_length(str); }
+gb_inline usize string_capacity(const String str) { return gb_string_capacity(str); }
+gb_inline usize string_available_space(const String str) { return gb_string_available_space(str); }
+gb_inline void clear_string(String str) { gb_clear_string(str); }
+gb_inline void append_string_length(String& str, void const *other, usize len) { str = gb_append_string_length(str, other, len); }
+gb_inline void append_string(String& str, const String other) { str = gb_append_string(str, other); }
+gb_inline void append_cstring(String& str, char const *other) { str = gb_append_cstring(str, other); }
+gb_inline void set_string(String& str, char const *cstr) { str = gb_set_string(str, cstr); }
+gb_inline void string_make_space_for(String& str, usize add_len) { str = gb_string_make_space_for(str, add_len); }
+gb_inline usize string_allocation_size(const String str) { return gb_string_allocation_size(str); }
+gb_inline bool strings_are_equal(const String lhs, const String rhs) { return gb_strings_are_equal(lhs, rhs) == GB_TRUE; }
+gb_inline void trim_string(String& str, char const *cut_set) { str = gb_trim_string(str, cut_set); }
 } // namespace gb
 #endif // GB_STRING_CPP
 #endif // GB_STRING_H
 #ifdef GB_STRING_IMPLEMENTATION
-static void gb_set_string_length(gb_String str, gb_usize len)
+static void
+gb_set_string_length(gbString str, gbUsize len)
 {
 	GB_STRING_HEADER(str)->len = len;
 }
 
-static void gb_set_string_capacity(gb_String str, gb_usize cap)
+static void
+gb_set_string_capacity(gbString str, gbUsize cap)
 {
 	GB_STRING_HEADER(str)->cap = cap;
 }
 
 
-gb_String gb_make_string_length(const void* init_str, gb_usize len)
+gbString
+gb_make_string_length(void const *init_str, gbUsize len)
 {
-	gb_usize header_size = sizeof(struct gb_String_Header);
-	void* ptr = GB_ALLOC(header_size + len + 1);
+	gbString str;
+	gbStringHeader *header;
+	gbUsize header_size = sizeof(gbStringHeader);
+	void *ptr = GB_ALLOC(header_size + len + 1);
 	if (!init_str)
 		memset(ptr, 0, header_size + len + 1);
 
 	if (ptr == GB_NULLPTR)
 		return GB_NULLPTR;
 
-	gb_String str = (char*)ptr + header_size;
-	struct gb_String_Header* header = GB_STRING_HEADER(str);
+	str = (char *)ptr + header_size;
+	header = GB_STRING_HEADER(str);
 	header->len = len;
 	header->cap = len;
 	if (len && init_str)
@@ -406,52 +346,59 @@ gb_String gb_make_string_length(const void* init_str, gb_usize len)
 	return str;
 }
 
-gb_String gb_make_string(const char* str)
+gbString
+gb_make_string(char const *str)
 {
-	gb_usize len = str ? strlen(str) : 0;
+	gbUsize len = str ? strlen(str) : 0;
 	return gb_make_string_length(str, len);
 }
 
-void gb_free_string(gb_String str)
+void
+gb_free_string(gbString str)
 {
 	if (str == GB_NULLPTR)
 		return;
 
-	GB_FREE((struct gb_String_Header*)str - 1);
+	GB_FREE((gbStringHeader *)str - 1);
 }
 
-gb_String gb_duplicate_string(const gb_String str)
+gbString
+gb_duplicate_string(gbString const str)
 {
 	return gb_make_string_length(str, gb_string_length(str));
 }
 
-gb_usize gb_string_length(const gb_String str)
+gbUsize
+gb_string_length(gbString const str)
 {
 	return GB_STRING_HEADER(str)->len;
 }
 
-gb_usize gb_string_capacity(const gb_String str)
+gbUsize
+gb_string_capacity(gbString const str)
 {
 	return GB_STRING_HEADER(str)->cap;
 }
 
-gb_usize gb_string_available_space(const gb_String str)
+gbUsize
+gb_string_available_space(gbString const str)
 {
-	struct gb_String_Header* h = GB_STRING_HEADER(str);
+	gbStringHeader *h = GB_STRING_HEADER(str);
 	if (h->cap > h->len)
 		return h->cap - h->len;
 	return 0;
 }
 
-void gb_clear_string(gb_String str)
+void
+gb_clear_string(gbString str)
 {
 	gb_set_string_length(str, 0);
 	str[0] = '\0';
 }
 
-gb_String gb_append_string_length(gb_String str, const void* other, gb_usize other_len)
+gbString gb_append_string_length(gbString str, void const *other, gbUsize other_len)
 {
-	gb_usize curr_len = gb_string_length(str);
+	gbUsize curr_len = gb_string_length(str);
 
 	str = gb_string_make_space_for(str, other_len);
 	if (str == GB_NULLPTR)
@@ -464,21 +411,20 @@ gb_String gb_append_string_length(gb_String str, const void* other, gb_usize oth
 	return str;
 }
 
-gb_String gb_append_string(gb_String str, const gb_String other)
+gbString gb_append_string(gbString str, gbString const other)
 {
 	return gb_append_string_length(str, other, gb_string_length(other));
 }
 
-gb_String gb_append_cstring(gb_String str, const char* other)
+gbString gb_append_cstring(gbString str, char const *other)
 {
 	return gb_append_string_length(str, other, strlen(other));
 }
 
-gb_String gb_set_string(gb_String str, const char* cstr)
+gbString gb_set_string(gbString str, char const *cstr)
 {
-	gb_usize len = strlen(cstr);
-	if (gb_string_capacity(str) < len)
-	{
+	gbUsize len = strlen(cstr);
+	if (gb_string_capacity(str) < len) {
 		str = gb_string_make_space_for(str, len - gb_string_length(str));
 		if (str == GB_NULLPTR)
 			return GB_NULLPTR;
@@ -491,8 +437,9 @@ gb_String gb_set_string(gb_String str, const char* cstr)
 	return str;
 }
 
-static gb_inline void* gb__string_realloc(void* ptr, gb_usize old_size, gb_usize new_size)
+static gb_inline void *gb__string_realloc(void *ptr, gbUsize old_size, gbUsize new_size)
 {
+	void *new_ptr;
 	if (!ptr)
 		return GB_ALLOC(new_size);
 
@@ -502,7 +449,7 @@ static gb_inline void* gb__string_realloc(void* ptr, gb_usize old_size, gb_usize
 	if (old_size == new_size)
 		return ptr;
 
-	void* new_ptr = GB_ALLOC(new_size);
+	new_ptr = GB_ALLOC(new_size);
 	if (!new_ptr)
 		return GB_NULLPTR;
 
@@ -513,45 +460,47 @@ static gb_inline void* gb__string_realloc(void* ptr, gb_usize old_size, gb_usize
 	return new_ptr;
 }
 
-gb_String gb_string_make_space_for(gb_String str, gb_usize add_len)
+gbString gb_string_make_space_for(gbString str, gbUsize add_len)
 {
-	gb_usize len = gb_string_length(str);
-	gb_usize new_len = len + add_len;
+	gbUsize len = gb_string_length(str);
+	gbUsize new_len = len + add_len;
+	void *ptr, *new_ptr;
+	gbUsize available, old_size, new_size;
 
-	gb_usize available = gb_string_available_space(str);
+	available = gb_string_available_space(str);
 	if (available >= add_len) // Return if there is enough space left
 		return str;
 
 
-	void* ptr = (char*)str - sizeof(struct gb_String_Header);
-	gb_usize old_size = sizeof(struct gb_String_Header) + gb_string_length(str) + 1;
-	gb_usize new_size = sizeof(struct gb_String_Header) + new_len + 1;
+	ptr = (char *)str - sizeof(gbStringHeader);
+	old_size = sizeof(gbStringHeader) + gb_string_length(str) + 1;
+	new_size = sizeof(gbStringHeader) + new_len + 1;
 
-	void* new_ptr = gb__string_realloc(ptr, old_size, new_size);
+	new_ptr = gb__string_realloc(ptr, old_size, new_size);
 	if (new_ptr == GB_NULLPTR)
 		return GB_NULLPTR;
-	str = (char*)new_ptr + sizeof(struct gb_String_Header);
+	str = (char *)new_ptr + sizeof(gbStringHeader);
 
 	gb_set_string_capacity(str, new_len);
 
 	return str;
 }
 
-gb_usize gb_string_allocation_size(const gb_String s)
+gbUsize gb_string_allocation_size(gbString const s)
 {
-	gb_usize cap = gb_string_capacity(s);
-	return sizeof(struct gb_String_Header) + cap;
+	gbUsize cap = gb_string_capacity(s);
+	return sizeof(gbStringHeader) + cap;
 }
 
-gb_bool gb_strings_are_equal(const gb_String lhs, const gb_String rhs)
+gbBool gb_strings_are_equal(gbString const lhs, gbString const rhs)
 {
-	gb_usize lhs_len = gb_string_length(lhs);
-	gb_usize rhs_len = gb_string_length(rhs);
+	gbUsize lhs_len, rhs_len, i;
+	lhs_len = gb_string_length(lhs);
+	rhs_len = gb_string_length(rhs);
 	if (lhs_len != rhs_len)
 		return GB_FALSE;
 
-	for (gb_usize i = 0; i < lhs_len; i++)
-	{
+	for (i = 0; i < lhs_len; i++) {
 		if (lhs[i] != rhs[i])
 			return GB_FALSE;
 	}
@@ -559,12 +508,10 @@ gb_bool gb_strings_are_equal(const gb_String lhs, const gb_String rhs)
 	return GB_TRUE;
 }
 
-gb_String gb_trim_string(gb_String str, const char* cut_set)
+gbString gb_trim_string(gbString str, char const *cut_set)
 {
-	char* start;
-	char* end;
-	char* start_pos;
-	char* end_pos;
+	char *start, *end, *start_pos, *end_pos;
+	gbUsize len;
 
 	start_pos = start = str;
 	end_pos   = end   = str + gb_string_length(str) - 1;
@@ -574,7 +521,7 @@ gb_String gb_trim_string(gb_String str, const char* cut_set)
 	while (end_pos > start_pos && strchr(cut_set, *end_pos))
 		end_pos--;
 
-	gb_usize len = (start_pos > end_pos) ? 0 : ((end_pos - start_pos)+1);
+	len = (start_pos > end_pos) ? 0 : ((end_pos - start_pos)+1);
 
 	if (str != start_pos)
 		memmove(str, start_pos, len);