demake 0.2.2 → 0.2.4

data/lib/data/libsrc/auto_string.h

@@ -0,0 +1,1023 @@
+/*
+
+  auto_string.h -- *Full Library* Header File
+
+  Used to create string based areas / regions of memory and views
+
+  - Uses basic 32-bit integers as identifiers for lifetimes / arenas
+  - Automatically expands when new allocations don't fit existing
+  - Automatically zeros data blocks upon reset / free
+
+  See the end of this file for an example.
+
+  Public Functions:
+
+
+*/
+
+#ifndef AUTO_STRING_H_Minaswan	/* Prevent multiple inclusions	*/
+#define AUTO_STRING_H_Minaswan
+  #define AUTO_STRING_VERSION	"0.1.0"
+  #ifndef TYPEDEFS_H_Minaswan	/* Prevents multiple inclusions	*/
+    #define TYPEDEFS_H_Minaswan
+    #define TYPEDEFS_VERSION	"0.1.1"
+    #include <stdint.h>
+
+    typedef uint8_t b8;		/* Booleans			*/
+    typedef uint16_t b16;
+    typedef uint32_t b32;
+    typedef uint64_t b64;
+
+    typedef char c8;		/* Characters			*/
+    typedef const char cc8;
+    typedef unsigned char uc8;
+    typedef char as8;		/* Auto string			*/
+
+    typedef uint8_t u8;		/* Unsigned Numbers		*/
+    typedef uint16_t u16;
+    typedef uint32_t u32;
+    typedef uint64_t u64;
+
+    typedef int8_t i8;		/* Signed Numbers		*/
+    typedef int16_t i16;
+    typedef int32_t i32;
+    typedef int64_t i64;
+
+    typedef float f32;		/* Floating Point Numbers	*/
+    typedef double f64;
+  #endif			/* TYPEDEFS_H_Minaswan		*/
+
+  #ifndef DEFINES_H_Minaswan	/* Prevents multiple inclusions	*/
+    #define DEFINES_H_Minaswan
+    #define DEFINES_VERSION	"0.1.1"
+    #ifndef NULL
+      #define NULL		((void *) 0)
+    #endif
+    #ifndef FALSE
+      #define FALSE		0
+    #endif
+    #ifndef TRUE
+      #define TRUE		1
+    #endif
+    #ifndef NO
+      #define NO		0
+    #endif
+    #ifndef YES
+      #define YES		1
+    #endif
+    #ifndef OFF
+      #define OFF		0
+    #endif
+    #ifndef ON
+      #define ON		1
+    #endif
+    #ifndef MIN
+      #define MIN(x, y)		(x) < (y) ? (x) : (y)
+    #endif
+    #ifndef MAX
+      #define MAX(x, y)		(x) > (y) ? (x) : (y)
+    #endif
+    #ifndef KB
+      #define KB(x)		((u64)(x) * 1024)
+    #endif
+    #ifndef MB
+      #define MB(x)		((u64)(x) * 1024 * 1024)
+    #endif
+    #ifndef GB
+      #define GB(x)		((u64)(x) * 1024 * 1024 * 1024)
+    #endif
+    #ifndef TO_UPPER_CASE
+      #define TO_UPPER_CASE(x)	(((uc8)(x) >= (uc8)'a' && (uc8)(x) <= (uc8)'z') ? \
+				(uc8)((uc8)(x) - (uc8)'a' + (uc8)'A') : (uc8)(x))
+    #endif
+    #ifndef TO_LOWER_CASE
+      #define TO_LOWER_CASE(x)	(((uc8)(x) >= (uc8)'A' && (uc8)(x) <= (uc8)'Z') ? \
+				(uc8)((uc8)(x) - (uc8)'A' + (uc8)'a') : (uc8)(x))
+    #endif
+    #ifndef IS_WHITE_SPACE
+      #define IS_WHITE_SPACE(x)	((uc8)(x) == ' ' || (uc8)(x) - (uc8)'\t' < 5)
+    #endif
+  #endif			/* DEFINES_H_Minaswan */
+
+  #include <stdio.h>
+  #include <stdlib.h>
+  #include <string.h>
+
+  #ifndef _SCOPE_	/* _SCOPE_ is short and can be easily redefined */
+    #define _SCOPE_WAS_NOT_PREDEFINED_
+/*
+    #define _SCOPE_		extern
+    #define _SCOPE_		static
+*/
+    #if defined(__GNUC__) || defined(__clang__)
+      #define _SCOPE_		static __inline__
+    #elif defined(_MSC_VER)
+      #define _SCOPE_		static __inline
+    #else
+      #define _SCOPE_		static inline
+    #endif
+  #endif
+
+  #define NO_AUTO_STRING	0
+
+  struct auto_view_data {
+    u64 length;
+    c8 *data;
+    c8 clamp;
+  };
+
+  /* These all use the global i32 auto_string_arena variable */
+  _SCOPE_ as8 *auto_string_new(cc8 *string, b8 thin);
+  _SCOPE_ as8 *auto_string_extra(cc8 *string, i64 extra_capacity);
+  _SCOPE_ as8 *auto_string_substring(cc8 *string, u64 position, u64 length, b8 thin);
+  _SCOPE_ void auto_string_free(void);
+  _SCOPE_ void auto_string_reset(void);
+
+  /* Public Functions */
+  _SCOPE_ b8 is_auto_string(cc8 *string);
+  _SCOPE_ b8 auto_string_contains(cc8 *string, cc8 *sub_string);
+  _SCOPE_ b8 auto_string_match(cc8 *string, cc8 *string2);
+  _SCOPE_ b8 auto_string_match_no_case(cc8 *string, cc8 *string2);
+  _SCOPE_ b8 auto_string_prefixed(cc8 *string, cc8 *prefix);
+  _SCOPE_ b8 auto_string_prefixed_no_case(cc8 *string, cc8 *prefix);
+  _SCOPE_ b8 auto_view_match(struct auto_view_data *view, cc8 *string);
+  _SCOPE_ b8 auto_view_match_no_case(struct auto_view_data *view, cc8 *string);
+  _SCOPE_ b8 auto_views_match(struct auto_view_data *view,
+      struct auto_view_data *view2);
+  _SCOPE_ b8 auto_views_match_no_case(struct auto_view_data *view,
+      struct auto_view_data *view2);
+  _SCOPE_ as8 *auto_string_by_id_new(i32 identifier, cc8 *string, b8 thin);
+  _SCOPE_ as8 *auto_string_by_id_extra(i32 identifier, cc8 *string, i64 extra_capacity);
+  _SCOPE_ as8 *auto_string_by_id_substring(i32 identifier, cc8 *string, u64 position, u64 length, b8 thin);
+  _SCOPE_ as8 *auto_string_add(c8 *string, cc8 *add_string);
+  _SCOPE_ u32 auto_string_init(i64 capacity);
+  _SCOPE_ i32 find_auto_string_identifier(cc8 *string);
+  _SCOPE_ i32 find_next_auto_string_identifier(void);
+  _SCOPE_ u64 find_string_length(cc8 *string);
+  _SCOPE_ u64 auto_string_length(cc8 *string);
+  _SCOPE_ u64 auto_string_available(cc8 *string);
+  _SCOPE_ struct auto_view_data auto_view(cc8 *string);
+  _SCOPE_ c8 *auto_view_clamp(struct auto_view_data *view);
+  _SCOPE_ c8 *auto_view_unclamp(struct auto_view_data *view);
+  _SCOPE_ void auto_view_slice(struct auto_view_data *view, u64 start, u64 end);
+  _SCOPE_ void auto_view_chop_left(struct auto_view_data *view, u64 length);
+  _SCOPE_ void auto_view_chop_right(struct auto_view_data *view, u64 length);
+  _SCOPE_ void auto_view_trim_left(struct auto_view_data *view);
+  _SCOPE_ void auto_view_trim_right(struct auto_view_data *view);
+  _SCOPE_ void auto_view_trim(struct auto_view_data *view);
+  _SCOPE_ void auto_view_print(struct auto_view_data *view);
+  _SCOPE_ void auto_string_update(as8 *string);
+  _SCOPE_ void auto_string_by_id_reset(u32 identifier);
+  _SCOPE_ void auto_string_reset_all(void);
+  _SCOPE_ void auto_string_by_id_free(u32 identifier);
+  _SCOPE_ void auto_string_free_all(void);
+  _SCOPE_ void auto_string_show(void);
+
+  #ifdef AUTO_STRING_IMPLEMENTATION		/* Effectively auto_string.c */
+  #ifndef DEFAULT_AUTO_STRING_CAPACITY
+    #define DEFAULT_AUTO_STRING_CAPACITY	512
+  #endif
+
+  #ifndef AUTO_VIEW
+    #define AUTO_VIEW(view)			(u32)(view).length, (view).data
+  #endif
+  #ifndef AUTO_PVIEW
+    #define AUTO_PVIEW(view)			(u32)(view)->length, (view)->data
+  #endif
+
+  struct auto_string_data {
+    struct auto_string_data *next;
+    u64 capacity;
+    u64 position;
+    u32 identifier;
+    c8 guard[4];
+    c8 *data;
+  };
+
+  #ifndef NO_AUTO_STRING_HELPERS
+    /* -- auto_view -- shortcuts -- */
+    #define as_contains				auto_string_contains
+    #define as_match				auto_string_match
+    #define as_match_no_case			auto_string_match_no_case
+    #define as_equal				auto_string_match
+    #define as_equal_no_case			auto_string_match_no_case
+    #define as_prefixed				auto_string_prefixed
+    #define as_prefixed_no_case			auto_string_prefixed_no_case
+    #define as_starts_with			auto_string_prefixed
+    #define as_starts_with_no_case		auto_string_prefixed_no_case
+    #define as_new				auto_string_new
+    #define as_add				auto_string_add
+    #define as_extra				auto_string_extra
+    #define as_by_id_new			auto_string_by_id_new
+    #define as_by_id_extra			auto_string_by_id_extra
+    #define as_by_id_substring			auto_string_by_id_substring
+    #define as_substring			auto_string_substring
+    #define as_init				auto_string_init
+    #define as_length				auto_string_length
+    #define as_available			auto_string_available
+    #define as_update				auto_string_update
+    #define as_reset				auto_string_reset
+    #define as_reset_all			auto_string_reset_all
+    #define as_free				auto_string_free
+    #define as_free_all				auto_string_free_all
+    #define as_show				auto_string_show
+    #define find_as_id				find_auto_string_identifier
+    #define find_next_as_id			find_next_auto_string_identifier
+
+    typedef struct auto_string_data 		AutoString;
+
+    /* -- auto_view -- shortcuts -- */
+    #define VIEW				"%.*s"
+    #define VIEW_WIDTH(x)			"%"#x".*s"
+    #define A_VIEW(view)			AUTO_VIEW(view)
+    #define A_PVIEW(view)			AUTO_PVIEW(view)
+
+    #define a_view				auto_view
+    #define av_match				auto_view_match
+    #define av_match_no_case			auto_view_match_no_case
+    #define av_chop_left			auto_view_chop_left
+    #define av_chop_right			auto_view_chop_right
+    #define av_trim_left			auto_view_trim_left
+    #define av_trim_right			auto_view_trim_right
+    #define av_trim				auto_view_trim
+    #define av_slice				auto_view_slice
+    #define av_print				auto_view_print
+    #define avs_match				auto_views_match
+    #define avs_match_no_case			auto_views_match_no_case
+
+    typedef struct auto_view_data 		AutoView;
+  #endif
+
+  i32 auto_string_arena = 0;
+  struct auto_string_data *auto_string_list = NULL;
+
+  _SCOPE_ u32 auto_string_init(i64 capacity)
+  {
+    struct auto_string_data *as = NULL, *next = NULL;
+
+    if(capacity == 0)
+      capacity = DEFAULT_AUTO_STRING_CAPACITY;
+    else if(capacity < 0)	/* Negative is multiples of default */
+      capacity *= -DEFAULT_AUTO_STRING_CAPACITY;
+    as = calloc(1, sizeof(struct auto_string_data) + capacity);
+    if(as == NULL)
+      return NO_AUTO_STRING;
+    as->capacity = capacity;
+    as->position = 0;
+    if(auto_string_arena)
+      as->identifier = auto_string_arena;
+    else
+      as->identifier = find_next_auto_string_identifier();
+    as->guard[0] = 'o';	/* Used primarily to detect auto strings */
+    as->guard[1] = 't';
+    as->guard[2] = 'u';
+    as->guard[3] = 'a';
+    as->data = (c8 *)as + sizeof(struct auto_string_data);
+    *as->data = '\0';
+    as->next = NULL;
+    if(!auto_string_list)
+      auto_string_list = as;
+    else {
+      next = auto_string_list;
+      while(next && next->next)
+        next = next->next;
+      next->next = as;
+    }
+    return as->identifier;
+  }
+
+  _SCOPE_ as8 *auto_string_by_id_extra(i32 identifier, cc8 *string, i64 extra_capacity)
+  {
+    struct auto_string_data *as = NULL, *next = NULL;
+    u64 capacity = 0, length = 0;
+
+    if(!identifier && auto_string_arena)
+      identifier = auto_string_arena;
+    else if(!identifier)
+      identifier = find_next_auto_string_identifier();
+    if(string) {
+      length = auto_string_length(string);
+      /* Negative extra capacity becames a multiple of the original string length */
+      if(extra_capacity < 0)
+        extra_capacity *= -length;
+    } else {
+      /* Negative extra capacity becames a multiple of the default */
+      if(extra_capacity < 0)
+        extra_capacity *= -DEFAULT_AUTO_STRING_CAPACITY;
+    }
+    capacity = length;
+    capacity += extra_capacity;
+    for(as = auto_string_list; as; as = as->next) {
+      if(as->identifier == identifier) {
+        if(as->capacity >= capacity && as->position == 0) {
+          as->position += capacity;
+          as->capacity -= capacity;
+          as->guard[0] = 'o';  /* Used primarily to detect auto strings */
+          as->guard[1] = 't';
+          as->guard[2] = 'u';
+          as->guard[3] = 'a';
+          if(string && length > 0) {
+            length = 0;
+            while(length < capacity) {
+              *(as->data + length) = *(string + length);
+              length++;
+            }
+            *(as->data + length + 1) = '\0';
+          }
+          return(as->data);
+        }
+      }
+    }
+    /* Didn't find an auto_string or we found an auto_string but it didn't have space */
+    as = calloc(1, sizeof(struct auto_string_data) + capacity + 1);
+    if(as == NULL)
+      return NO_AUTO_STRING;
+    as->capacity = extra_capacity;
+    as->position = length;
+    as->identifier = identifier;
+    as->guard[0] = 'o';
+    as->guard[1] = 't';
+    as->guard[2] = 'u';
+    as->guard[3] = 'a';
+    as->data = (c8 *)as + sizeof(struct auto_string_data);
+    as->next = NULL;
+    if(!auto_string_list)
+      auto_string_list = as;
+    else {
+      next = auto_string_list;
+      while(next && next->next)
+        next = next->next;
+      next->next = as;
+    }
+    if(string && length > 0) {
+      length = 0;
+      while(length < capacity) {
+        *(as->data + length) = *(string + length);
+        length++;
+      }
+      *(as->data + length + 1) = '\0';
+    }
+    return as->data;
+  }
+
+  _SCOPE_ as8 *auto_string_extra(cc8 *string, i64 extra_capacity)
+  {
+    return auto_string_by_id_extra(auto_string_arena, string, extra_capacity);
+  }
+
+  _SCOPE_ as8 *auto_string_by_id_new(i32 identifier, cc8 *string, b8 thin)
+  {
+    u64 length = 0, extra_capacity = 0;
+
+    if(string)
+      length = auto_string_length(string);
+    if(length <= DEFAULT_AUTO_STRING_CAPACITY)
+      extra_capacity = DEFAULT_AUTO_STRING_CAPACITY - length;
+    else {
+      extra_capacity = length / DEFAULT_AUTO_STRING_CAPACITY;
+      extra_capacity *= DEFAULT_AUTO_STRING_CAPACITY;
+    }
+    if(thin)
+      extra_capacity = 0;
+    return auto_string_by_id_extra(identifier, string, extra_capacity);
+  }
+
+  _SCOPE_ as8 *auto_string_new(cc8 *string, b8 thin)
+  {
+    return auto_string_by_id_new(auto_string_arena, string, thin);
+  }
+
+  _SCOPE_ as8 *auto_string_by_id_substring(i32 identifier, cc8 *string, u64 position, u64 length, b8 thin)
+  {
+    struct auto_string_data *as = NULL;
+    u64 string_length = auto_string_length(string);
+    u64 substring_length = 0, capacity = 0;
+    c8 *substring = NULL;
+
+    if(!string || length == 0 || string_length <= position)
+      return NULL;
+
+    substring_length = auto_string_length(string);
+    substring_length -= position;
+    if(length > substring_length)
+      length = substring_length;
+    if(length < DEFAULT_AUTO_STRING_CAPACITY)
+      capacity = DEFAULT_AUTO_STRING_CAPACITY;
+    else {
+      capacity = length / DEFAULT_AUTO_STRING_CAPACITY;
+      capacity *= DEFAULT_AUTO_STRING_CAPACITY;
+    }
+    if(thin)
+      capacity = length;
+    substring_length = length;
+    substring = auto_string_by_id_extra(identifier, "", capacity);
+    while(length) {
+      *(substring + length - 1) = *(string + position + length);
+      length--;
+    }
+    *(substring + substring_length + 1) = '\0';
+    as = (struct auto_string_data *)(substring - sizeof(struct auto_string_data));
+    as->capacity -= substring_length;
+    as->position += substring_length;
+
+    return substring;
+  }
+
+  _SCOPE_ as8 *auto_string_substring(cc8 *string, u64 position, u64 length, b8 thin)
+  {
+    return auto_string_by_id_substring(auto_string_arena, string, position, length, thin);
+  }
+
+  _SCOPE_ as8 *auto_string_add(c8 *string, cc8 *add_string)	/* b8 thin? */
+  {
+    struct auto_string_data *as = NULL;
+    u64 length = 0, add_length = auto_string_length(add_string);
+    i32 identifier = 0;
+    as8 *new_string = NULL;
+
+    if(!add_string)
+      return string;
+
+    if(is_auto_string(string)) {
+      as = (struct auto_string_data *)(string - sizeof(struct auto_string_data));
+      if(as->capacity >= add_length) {
+        while(length <= add_length) {
+          *(string + as->position + length) = *(add_string + length);
+          length++;
+        }
+        *(string + as->position + add_length + 1) = '\0';
+        as->capacity -= add_length;
+        as->position += add_length;
+        return string;
+      } else {
+        identifier = find_auto_string_identifier(string);
+        new_string = auto_string_by_id_extra(identifier, string, add_length);
+        return auto_string_add(new_string, add_string);
+      }
+    } else if(is_auto_string(add_string)) {
+      identifier = find_auto_string_identifier(add_string);
+      new_string = auto_string_by_id_extra(identifier, string, add_length);
+      return auto_string_add(new_string, add_string);
+    }
+    new_string = auto_string_by_id_extra(auto_string_arena, string, add_length);
+    return auto_string_add(new_string, add_string);
+  }
+
+  _SCOPE_ void auto_string_update(as8 *string)
+  {
+    struct auto_string_data *as = NULL;
+    u64 length = find_string_length(string);	/* manual count */
+
+    if(!string || !is_auto_string(string))
+      return;
+
+    for(as = auto_string_list; as; as = as->next) {
+      if(as->data && as->data <= string &&
+          as->data + as->position >= string) {
+        if(as->position < length) {
+          as->capacity -= length - as->position;
+          as->position = length;
+        } else if(as->position > length) {
+          as->capacity += as->position - length;
+          as->position = length;
+        }
+      }
+    }
+  }
+
+  _SCOPE_ i32 find_auto_string_identifier(cc8 *string)
+  {
+    struct auto_string_data *as = NULL;
+
+    if(!string)
+      return 0;
+
+    for(as = auto_string_list; as; as = as->next) {
+      if(as->data && as->data <= string &&
+          as->data + as->position >= string)
+        return as->identifier;
+    }
+    return 0;
+  }
+
+  _SCOPE_ i32 find_next_auto_string_identifier(void)
+  {
+    struct auto_string_data *as = NULL;
+    u32 next_identifier = 0;
+
+    for(as = auto_string_list; as; as = as->next) {
+      if(as->identifier > next_identifier)
+        next_identifier = as->identifier;
+    }
+    next_identifier++;
+    return next_identifier;
+  }
+
+  _SCOPE_ b8 is_auto_string(cc8 *string)
+  {
+    struct auto_string_data *as = NULL;
+
+    if(!string)
+      return FALSE;
+    as = (struct auto_string_data *)(string - sizeof(struct auto_string_data));
+    if(as && as->guard[3] == 'a' &&
+        as->guard[2] == 'u' &&
+        as->guard[1] == 't' &&
+        as->guard[0] == 'o')
+      return TRUE;
+    return FALSE;
+  }
+
+  _SCOPE_ u64 find_string_length(cc8 *string)
+  {
+    u64 length = 0;
+
+    while(*(string + length) != '\0')
+      length++;
+    return length;
+  }
+
+  _SCOPE_ b8 auto_string_contains(cc8 *string, cc8 *sub_string)
+  {
+    cc8 *haystack = NULL, *needle = NULL, *hay = NULL;
+
+    if(string == sub_string)
+      return TRUE;
+    if(!string || !sub_string)
+      return FALSE;
+    for(haystack = string; *haystack; ++haystack) {
+      needle = sub_string;
+      hay = haystack;
+      while(*needle && *hay && *needle++ == *hay++);
+      if(*needle == '\0')
+        return TRUE;
+    }
+    return FALSE;
+  }
+
+  _SCOPE_ b8 auto_string_match(cc8 *string, cc8 *string2)
+  {
+    u64 length = auto_string_length(string);
+    u64 length2 = auto_string_length(string2);
+
+    if(string == string2)
+      return TRUE;
+    if(length != length2)
+      return FALSE;
+    while(*string++ && *string2++ && *string == *string2);
+    if(*string || *string2)
+      return FALSE;
+    return TRUE;
+  }
+
+  _SCOPE_ b8 auto_string_match_no_case(cc8 *string, cc8 *string2)
+  {
+    u64 length = auto_string_length(string);
+    u64 length2 = auto_string_length(string2);
+
+    if(string == string2)
+      return TRUE;
+    if(length != length2)
+      return FALSE;
+    while(*string++ && *string2++ && TO_LOWER_CASE(*string) == TO_LOWER_CASE(*string2));
+    if(*string || *string2)
+      return FALSE;
+    return TRUE;
+  }
+
+  _SCOPE_ b8 auto_string_prefixed(cc8 *string, cc8 *prefix)
+  {
+    u64 length = auto_string_length(string);
+    u64 prefix_length = auto_string_length(prefix);
+
+    if(string == prefix)
+      return TRUE;
+    if(prefix_length > length)
+      return FALSE;
+    while(*string && *prefix && *string++ == *prefix++);
+    if(!*prefix)
+      return TRUE;
+    return FALSE;
+  }
+
+  _SCOPE_ b8 auto_string_prefixed_no_case(cc8 *string, cc8 *prefix)
+  {
+    u64 length = auto_string_length(string);
+    u64 prefix_length = auto_string_length(prefix);
+
+    if(string == prefix)
+      return TRUE;
+    if(prefix_length > length)
+      return FALSE;
+    while(*string++ && *prefix++ && TO_LOWER_CASE(*string) == TO_LOWER_CASE(*prefix));
+    if(!*prefix)
+      return TRUE;
+    return FALSE;
+  }
+
+  _SCOPE_ b8 auto_view_match(struct auto_view_data *view, cc8 *string)
+  {
+    u64 length = 0;
+
+    if(!view || !string)
+      return FALSE;
+    length = view->length;
+    while(length > 0) {
+      length--;
+      if(*(string + length) != *(view->data + length))
+        return FALSE;
+    }
+    if(length > 0)
+      return FALSE;
+    return TRUE;
+  }
+
+  _SCOPE_ b8 auto_views_match(struct auto_view_data *view,
+      struct auto_view_data *view2)
+  {
+    u64 length = 0;
+
+    if(!view && !view2)
+      return TRUE;
+    if(!view || !view2)
+      return FALSE;
+    length = view->length;
+    if(length != view2->length)
+      return FALSE;
+    if(length == 0)
+      return TRUE;
+    if(view->data == view2->data)
+      return TRUE;
+    while(length > 0) {
+      length--;
+      if(*(view->data + length) != *(view2->data + length))
+        return FALSE;
+    }
+    return TRUE;
+  }
+
+  _SCOPE_ b8 auto_views_match_no_case(struct auto_view_data *view,
+      struct auto_view_data *view2)
+  {
+    u64 length = 0;
+
+    if(!view && !view2)
+      return TRUE;
+    if(!view || !view2)
+      return FALSE;
+    length = view->length;
+    if(length != view2->length)
+      return FALSE;
+    if(length == 0)
+      return TRUE;
+    if(view->data == view2->data)
+      return TRUE;
+    while(length > 0) {
+      length--;
+      if(TO_LOWER_CASE(*(view->data + length)) != TO_LOWER_CASE(*(view2->data + length)))
+        return FALSE;
+    }
+    return TRUE;
+  }
+
+  _SCOPE_ b8 auto_view_match_no_case(struct auto_view_data *view, cc8 *string)
+  {
+    u64 length = 0;
+
+    if(!view || !string)
+      return FALSE;
+
+    length = view->length;
+    while(length > 0) {
+      length--;
+      if(TO_LOWER_CASE(*(string + length)) != TO_LOWER_CASE(*(view->data + length)))
+        return FALSE;
+    }
+    return TRUE;
+  }
+
+  _SCOPE_ b8 auto_view_prefixed(struct auto_view_data *view, cc8 *prefix)
+  {
+    u64 length = auto_string_length(prefix);
+
+    if(!view || !prefix || !length || length > view->length)
+      return FALSE;
+    while(length > 0) {
+      length--;
+      if(*(prefix + length) != *(view->data + length))
+        return FALSE;
+    }
+    return TRUE;
+  }
+
+  _SCOPE_ b8 auto_view_prefixed_no_case(struct auto_view_data *view, cc8 *prefix)
+  {
+    u64 length = auto_string_length(prefix);
+
+    if(!view || !prefix || !length || length > view->length)
+      return FALSE;
+    while(length > 0) {
+      length--;
+      if(*(prefix + length) != *(view->data + length))
+        return FALSE;
+    }
+    return TRUE;
+  }
+
+  _SCOPE_ void auto_view_print(struct auto_view_data *view)
+  {
+    u64 length = 0;
+
+    if(!view || !view->length)
+      return;
+    while(length < view->length) {
+      putchar(*(view->data + length));
+      length++;
+    }
+  }
+
+  _SCOPE_ u64 auto_string_length(cc8 *string)
+  {
+    struct auto_string_data *as = NULL;
+
+    if(!string)
+      return 0;
+    if(is_auto_string(string)) {	/* length = as->position */
+      as = (struct auto_string_data *)(string - sizeof(struct auto_string_data));
+      return as->position;
+    }
+    return find_string_length(string);
+  }
+
+  _SCOPE_ u64 auto_string_available(cc8 *string)
+  {
+    struct auto_string_data *as = NULL;
+
+    if(!string)
+      return 0;
+    if(is_auto_string(string)) {	/* available = as->capacity */
+      as = (struct auto_string_data *)(string - sizeof(struct auto_string_data));
+      return as->capacity;
+    }
+    return 0;
+  }
+
+  _SCOPE_ struct auto_view_data auto_view(cc8 *string)
+  {
+    struct auto_view_data view = { 0 };
+
+    view.length = auto_string_length(string);
+    view.data = (c8 *)string;
+    view.clamp = '\0';
+
+    return view;
+  }
+
+  /*
+    !!!		IMPORTANT NOTE ON CLAMP		!!!
+
+    This works:
+
+    c8 my_string[] = "This will work. Pretty cool, right?";
+
+    !!!	** You can't clamp on: *char literals	!!!
+    !!!						!!!
+    !!!	** Only clamp on: char[] and heap	!!!
+    !!!						!!!
+    !!!	This will segfault:			!!!
+
+    c8 *my_string2 = "This will segfault if you try to clamp it. Unfortunately.";
+
+    view2 = auto_view(my_string2);
+    auto_view_chop_right(&view2, 15);
+
+    This will segfault:
+
+    auto_view_clamp(&view2));
+
+  */
+
+  _SCOPE_ c8 *auto_view_clamp(struct auto_view_data *view)
+  {
+    if(view->data && *(view->data + view->length)) {
+      view->clamp = *(view->data + view->length);
+      *(view->data + view->length) = '\0';
+    }
+    return view->data;
+  }
+
+  _SCOPE_ c8 *auto_view_unclamp(struct auto_view_data *view)
+  {
+    if(view->data && view->clamp) {
+      *(view->data + view->length) = view->clamp;
+      view->clamp = '\0';
+    }
+    return view->data;
+  }
+
+  _SCOPE_ void auto_view_slice(struct auto_view_data *view, u64 start, u64 end)
+  {
+    if(start > view->length || start > end) {
+      view->length = 0;
+      view->data = "";
+      view->clamp = 0;
+    } else {
+      view->data += start;
+      view->length = end;
+    }
+  }
+
+  _SCOPE_ void auto_view_chop_left(struct auto_view_data *view, u64 length)
+  {
+    if(view->length <= length) {
+      view->length = 0;
+      view->data = "";
+    } else {
+      view->length -= length;
+      view->data += length;
+    }
+  }
+
+  _SCOPE_ void auto_view_chop_right(struct auto_view_data *view, u64 length)
+  {
+    if(view->length <= length) {
+      view->length = 0;
+      view->data = "";
+    } else
+      view->length -= length;
+  }
+
+  _SCOPE_ void auto_view_trim_left(struct auto_view_data *view)
+  {
+    while(*view->data && IS_WHITE_SPACE(*view->data)) {
+      view->data++;
+      view->length--;
+    }
+  }
+
+  _SCOPE_ void auto_view_trim_right(struct auto_view_data *view)
+  {
+    while(*(view->data + view->length - 1) && IS_WHITE_SPACE(*(view->data + view->length - 1)))
+      view->length--;
+  }
+
+  _SCOPE_ void auto_view_trim(struct auto_view_data *view)
+  {
+    auto_view_trim_left(view);
+    auto_view_trim_right(view);
+  }
+
+  _SCOPE_ void auto_string_memory_wipe(void *data, u64 capacity)
+  {
+    volatile unsigned char *volatile_data = (volatile unsigned char *)data;
+
+    if(!volatile_data || !data || capacity == 0)
+      return;
+
+    capacity -= 1;	/* 0-based */
+    while(capacity--)
+      *volatile_data++ = 0;
+    *volatile_data = 0;
+  }
+
+  _SCOPE_ void auto_string_by_id_reset(u32 identifier)
+  {
+    struct auto_string_data *as = NULL;
+
+    for(as = auto_string_list; as; as = as->next) {
+      if(as->identifier == identifier) {
+        as->capacity += as->position;
+        auto_string_memory_wipe(as->data, as->capacity);
+        as->position = 0;
+      }
+    }
+  }
+
+  _SCOPE_ void auto_string_reset(void)
+  {
+    auto_string_by_id_reset(auto_string_arena);
+  }
+
+  _SCOPE_ void auto_string_reset_all(void)
+  {
+    struct auto_string_data *as = NULL;
+
+    for(as = auto_string_list; as; as = as->next) {
+      as->capacity += as->position;
+      auto_string_memory_wipe(as->data, as->capacity);
+      as->position = 0;
+    }
+  }
+
+  _SCOPE_ void auto_string_by_id_free(u32 identifier)
+  {
+    struct auto_string_data *as = NULL, *next = NULL;
+
+    as = auto_string_list;
+    while(as && as->identifier == identifier) {
+      next = as->next;
+      auto_string_memory_wipe(as->data, as->capacity + as->position);
+      free(as);
+      auto_string_list = as = next;
+    }
+    for(; as; as = next) {
+      next = as->next;
+      while(next && next->identifier == identifier) {
+        if(next->next)
+          as->next = next->next;
+        else
+          as->next = NULL;
+        auto_string_memory_wipe(next->data, next->capacity + next->position);
+        free(next);
+        next = as->next;
+      }
+    }
+  }
+
+  _SCOPE_ void auto_string_free(void)
+  {
+    auto_string_by_id_free(auto_string_arena);
+  }
+
+  _SCOPE_ void auto_string_free_all(void)
+  {
+    struct auto_string_data *as = NULL, *next = NULL;
+
+    for(as = auto_string_list; as; as = next) {
+      next = as->next;
+      auto_string_memory_wipe(as->data, as->capacity + as->position);
+      free(as);
+    }
+    auto_string_list = NULL;
+  }
+
+  _SCOPE_ void auto_string_show(void)
+  {
+    struct auto_string_data *as = NULL;
+    u32 top_identifier = 0, identifier = 0;
+    b8 found = FALSE;
+
+    for(as = auto_string_list; as; as = as->next) {
+      if(as->identifier > top_identifier)
+        top_identifier = as->identifier;
+    }
+    if(!top_identifier)
+      printf("No auto strings are currently created.\n");
+    else {
+      printf("---------------------------------------------------------------------------------\n");
+      printf("Id     Used       Unused     Total      Location / Data   (Version: %s)\n", AUTO_STRING_VERSION);
+      printf("---------------------------------------------------------------------------------\n");
+      while(identifier <= top_identifier) {
+        for(as = auto_string_list; as; as = as->next) {
+          if(as->identifier == identifier) {
+            if(!found)
+              printf("%-6d %-10ld %-10ld %-10ld %p %-30.30s\n", as->identifier, as->position,
+                 as->capacity, as->position + as->capacity, as->data,
+                 as->data);
+            else
+              printf("  %-4d %-10ld %-10ld %-10ld %p %-30.30s\n", as->identifier, as->position,
+                 as->capacity, as->position + as->capacity, as->data,
+                 as->data);
+            found = TRUE;
+          }
+        }
+        identifier++;
+        found = FALSE;
+      }
+      printf("---------------------------------------------------------------------------------\n");
+    }
+  }
+  #else
+    extern i32 auto_string_arena = 0;
+  #endif	/* AUTO_STRING_IMPLEMENTATION */
+  #if defined(_SCOPE_WAS_NOT_PREDEFINED_)
+    #undef _SCOPE_WAS_NOT_PREDEFINED_
+    #undef _SCOPE_
+  #endif
+#endif		/* AUTO_STRING_H_Minaswan */
+
+/*
+  Example:
+
+  #define AUTO_STRING_IMPLEMENTATION
+  #include "auto_string.h"
+
+  i32 main(i32 argc, c8 *argv[])
+  {
+    i32 identifier = 0;
+    c8 *data = NULL;
+
+    identifier = auto_string_init(MB(4));
+
+    data = auto_string_add("hello", 1);
+
+    auto_string_show();
+    auto_string_reset(identifier);
+    auto_string_free(identifier);
+    auto_string_free_all();
+    auto_string_show();
+
+    return 0;
+  }
+
+*/