demake 0.2.2 → 0.2.4

data/lib/data/libsrc/auto_string_clamp_test.c

@@ -0,0 +1,52 @@
+/*
+  !!!		IMPORTANT NOTE ON CLAMP		!!!
+
+  This works:
+
+  c8 my_string[] = "This will work. Pretty cool, right?";
+
+  !!!	Can't clamp on: *char literals		!!!
+  !!!						!!!
+  !!!	Can 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));
+
+*/
+
+#define AUTO_STRING_IMPLEMENTATION
+#include "auto_string.h"
+
+i32 main(i32 argc, c8 *argv[])
+{
+  AutoView view = { 0 }, view2 = { 0 };
+  c8 my_string[] = "This will work. Pretty cool, right?";
+  c8 *my_string2 = "This will segfault if you try to clamp it. Unfortunately.";
+
+  view = auto_view(my_string);
+  auto_view_chop_right(&view, 20);
+  printf("view: ");
+  auto_view_print(&view);
+  printf("\n");
+
+  printf("view clamped: %s\n", auto_view_clamp(&view));
+  printf("my_string clamped: %s\n", my_string);
+  auto_view_unclamp(&view);
+  printf("my_string unclamped: %s\n", my_string);
+
+  view2 = auto_view(my_string2);
+  auto_view_chop_right(&view2, 15);
+  printf("view2: ");
+  auto_view_print(&view2);
+  printf("\n");
+
+  exit(0);
+}

data/lib/data/libsrc/defines.h

@@ -2,9 +2,9 @@
    defines.h -- Basic C preprocessor macro definitions
 */
 
-#ifndef DEFINES_H_Minaswan	/* Header guard to prevent multiple inclusions */
+#ifndef DEFINES_H_Minaswan	/* Prevent multiple inclusions */
   #define DEFINES_H_Minaswan
-  #define DEFINES_VERSION	"0.1.0"
+  #define DEFINES_VERSION	"0.1.1"
   #ifndef NULL
     #define NULL		((void *) 0)
   #endif
@@ -26,4 +26,30 @@
   #ifndef ON
     #define ON			1
   #endif
-#endif /* DEFINES_H_Minaswan */
+  #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 */

data/lib/data/libsrc/memory_arena.c

@@ -0,0 +1,32 @@
+  #define MEMORY_ARENA_IMPLEMENTATION
+  #include "memory_arena.h"
+
+  i32 main(i32 argc, c8 *argv[])
+  {
+    i32 memory_arena_identifier = 0;
+    c8 *data1 = NULL, *data2 = NULL, *data3 = NULL;
+
+    printf("Direct allocate 4096 bytes in literal memory arena 1\n");
+    data1 = memory_arena_allocate(1, 4096);
+    printf("Direct allocate 16 KB in literal memory arena 2\n");
+    data2 = memory_arena_allocate(2, KB(16));
+    printf("Initialize a 4 MB block in a new (3) memory arena\n");
+    memory_arena_identifier = memory_arena_init(MB(4));
+    printf("Allocate 1 MB block from existing memory arena (3)\n");
+    data3 = memory_arena_allocate(memory_arena_identifier, MB(1));
+    memory_arena_show();
+    printf("Reset all memory in existing arena (3)\n");
+    memory_arena_reset(memory_arena_identifier);
+    memory_arena_show();
+    printf("Free all memory in existing arena (3)\n");
+    memory_arena_free(memory_arena_identifier);
+    memory_arena_show();
+    printf("Reset all memory in all arenas\n");
+    memory_arena_reset_all();
+    memory_arena_show();
+    printf("Free all memory\n");
+    memory_arena_free_all();
+    memory_arena_show();
+
+    return 0;
+  }

data/lib/data/libsrc/memory_arena.h

@@ -0,0 +1,345 @@
+/*
+
+  memory_arena.h -- *Full Library* Header File
+
+  Used to create areas / regions of memory
+
+  - Uses basic 32-bit integers as identifiers for lifetimes
+  - 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:
+
+  static u32 memory_arena_init(i64 capacity);
+  static void *memory_arena_allocate(u32 identifier, i64 capacity);
+  static void memory_arena_reset(u32 identifier);
+  static void memory_arena_reset_all(void);
+  static void memory_arena_free(u32 identifier);
+  static void memory_arena_free_all(void);
+  static void memory_arena_show(void);
+
+*/
+
+#ifndef MEMORY_ARENA_H_Minaswan	/* Prevent multiple inclusions	*/
+#define MEMORY_ARENA_H_Minaswan
+  #define MEMORY_ARENA_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 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
+  #endif			/* DEFINES_H_Minaswan */
+
+  #include <stdio.h>
+  #include <stdlib.h>
+  #include <string.h>
+
+  /* Public Functions */
+  static u32 memory_arena_init(i64 capacity);
+  static void *memory_arena_allocate(u32 identifier, i64 capacity);
+  static void memory_arena_reset(u32 identifier);
+  static void memory_arena_reset_all(void);
+  static void memory_arena_free(u32 identifier);
+  static void memory_arena_free_all(void);
+  static void memory_arena_show(void);
+
+  #ifdef MEMORY_ARENA_IMPLEMENTATION
+    #ifndef DEFAULT_MEMORY_ARENA_CAPACITY
+      #define DEFAULT_MEMORY_ARENA_CAPACITY		4096
+    #endif
+
+  struct memory_arena_data {
+    u64 capacity;
+    u64 position;
+    u32 identifier;
+    void *data;
+
+    struct memory_arena_data *next;
+  };
+
+  struct memory_arena_data *memory_arena_list = NULL;
+
+  static u32 memory_arena_init(i64 capacity)
+  {
+    struct memory_arena_data *arena = NULL, *next = NULL;
+    u32 next_identifier = 0;
+
+    for(arena = memory_arena_list; arena; arena = arena->next) {
+      if(arena->identifier > next_identifier)
+        next_identifier = arena->identifier;
+    }
+    next_identifier++;
+    if(capacity == 0)
+      capacity = DEFAULT_MEMORY_ARENA_CAPACITY;
+    else if(capacity < 0)	/* Negative is multiples of default */
+      capacity *= -DEFAULT_MEMORY_ARENA_CAPACITY;
+
+    arena = calloc(1, sizeof(struct memory_arena_data));
+    arena->capacity = capacity;
+    arena->position = 0;
+    arena->identifier = next_identifier;
+    arena->data = calloc(capacity, sizeof(c8));
+    arena->next = NULL;
+    if(!memory_arena_list)
+      memory_arena_list = arena;
+    else {
+      next = memory_arena_list;
+      while(next && next->next)
+        next = next->next;
+      next->next = arena;
+    }
+
+    return arena->identifier;
+  }
+
+  static void *memory_arena_allocate(u32 identifier, i64 capacity)
+  {
+    struct memory_arena_data *arena = NULL, *next = NULL;
+    u64 position = 0;
+
+    if(capacity == 0)
+      capacity = DEFAULT_MEMORY_ARENA_CAPACITY;
+    else if(capacity < 0)	/* Negative is multiples of default */
+      capacity *= -DEFAULT_MEMORY_ARENA_CAPACITY;
+
+    for(arena = memory_arena_list; arena; arena = arena->next) {
+      if(arena->identifier == identifier) {
+        if(arena->capacity >= capacity) {
+          position = arena->position;
+          arena->position += capacity;
+          arena->capacity -= capacity;
+          return ((uc8 *)arena->data + position);
+        }
+      }
+    }
+    /* Didn't find an arena or we found an arena but it didn't have space */
+    arena = calloc(1, sizeof(struct memory_arena_data));
+    arena->capacity = 0;
+    arena->position = capacity;
+    arena->identifier = identifier;
+    arena->data = calloc(capacity, sizeof(c8));
+    arena->next = NULL;
+    if(!memory_arena_list)
+      memory_arena_list = arena;
+    else {
+      next = memory_arena_list;
+      while(next && next->next)
+        next = next->next;
+      next->next = arena;
+    }
+    return arena->data;
+  }
+
+  static void memory_wipe(void *data, u64 capacity)
+  {
+    volatile unsigned char *volatile_data = (volatile unsigned char *)data;
+
+    if(!volatile_data || !data || capacity == 0)
+      return;
+
+    while(capacity--)
+      *volatile_data++ = 0;
+  }
+
+  static void memory_arena_reset(u32 identifier)
+  {
+    struct memory_arena_data *arena = NULL;
+
+    for(arena = memory_arena_list; arena; arena = arena->next) {
+      if(arena->identifier == identifier) {
+        arena->capacity += arena->position;
+        memory_wipe(arena->data, arena->capacity);
+        arena->position = 0;
+      }
+    }
+  }
+
+  static void memory_arena_reset_all(void)
+  {
+    struct memory_arena_data *arena = NULL;
+
+    for(arena = memory_arena_list; arena; arena = arena->next) {
+      arena->capacity += arena->position;
+      memory_wipe(arena->data, arena->capacity);
+      arena->position = 0;
+    }
+  }
+
+  static void memory_arena_free(u32 identifier)
+  {
+    struct memory_arena_data *arena = NULL, *next = NULL;
+
+    arena = memory_arena_list;
+    while(arena && arena->identifier == identifier) {
+      next = arena->next;
+      memory_wipe(arena->data, arena->capacity + arena->position);
+      free(arena->data);
+      free(arena);
+      memory_arena_list = arena = next;
+    }
+    for(; arena; arena = next) {
+      next = arena->next;
+      while(next && next->identifier == identifier) {
+        if(next->next)
+          arena->next = next->next;
+        else
+          arena->next = NULL;
+        memory_wipe(arena->data, arena->capacity + arena->position);
+        free(next->data);
+        free(next);
+        next = arena->next;
+      }
+    }
+  }
+
+  static void memory_arena_free_all(void)
+  {
+    struct memory_arena_data *arena = NULL, *next = NULL;
+
+    for(arena = memory_arena_list; arena; arena = next) {
+      next = arena->next;
+      memory_wipe(arena->data, arena->capacity + arena->position);
+      free(arena->data);
+      free(arena);
+    }
+    memory_arena_list = NULL;
+  }
+
+  static void memory_arena_show(void)
+  {
+    struct memory_arena_data *arena = NULL;
+    u32 top_identifier = 0, identifier = 0;
+    b8 found = FALSE;
+
+    for(arena = memory_arena_list; arena; arena = arena->next) {
+      if(arena->identifier > top_identifier)
+        top_identifier = arena->identifier;
+    }
+    if(!top_identifier)
+      printf("\nNo memory arenas are currently created.\n");
+    else {
+      printf("\nCurrent Memory Arenas - Version: %s\n\n", MEMORY_ARENA_VERSION);
+      printf("Id     Used       Unused     Total      Data / Location\n");
+      printf("-------------------------------------------------------\n");
+      while(identifier <= top_identifier) {
+        for(arena = memory_arena_list; arena; arena = arena->next) {
+          if(arena->identifier == identifier) {
+            if(!found)
+              printf("%-6d %-10ld %-10ld %-10ld %p\n", arena->identifier, arena->position,
+                 arena->capacity, arena->position + arena->capacity, arena->data);
+            else
+              printf("  %-4d %-10ld %-10ld %-10ld %p\n", arena->identifier, arena->position,
+                 arena->capacity, arena->position + arena->capacity, arena->data);
+            found = TRUE;
+          }
+        }
+        identifier++;
+        found = FALSE;
+      }
+      printf("-------------------------------------------------------\n");
+    }
+  }
+  #endif	/* MEMORY_ARENA_IMPLEMENTATION */
+#endif		/* MEMORY_ARENA_H_Minaswan */
+
+/*
+  Example:
+
+  #define MEMORY_ARENA_IMPLEMENTATION
+  #include "memory_arena.h"
+
+  i32 main(i32 argc, c8 *argv[])
+  {
+    i32 memory_arena_identifier = 0;
+    c8 *data1 = NULL, *data2 = NULL, *data3 = NULL;
+
+    printf("Direct allocate 4096 bytes in literal memory arena 1\n");
+    data1 = memory_arena_allocate(1, 4096);
+    printf("Direct allocate 16 KB in literal memory arena 2\n");
+    data2 = memory_arena_allocate(2, KB(16));
+    printf("Initialize a 4 MB block in a new (3) memory arena\n");
+    memory_arena_identifier = memory_arena_init(MB(4));
+    printf("Allocate 1 MB block from existing memory arena (3)\n");
+    data3 = memory_arena_allocate(memory_arena_identifier, MB(1));
+    memory_arena_show();
+    printf("Reset all memory in existing arena (3)\n");
+    memory_arena_reset(memory_arena_identifier);
+    memory_arena_show();
+    printf("Free all memory in existing arena (3)\n");
+    memory_arena_free(memory_arena_identifier);
+    memory_arena_show();
+    printf("Reset all memory in all arenas\n");
+    memory_arena_reset_all();
+    memory_arena_show();
+    printf("Free all memory\n");
+    memory_arena_free_all();
+    memory_arena_show();
+
+    return 0;
+  }
+
+*/

data/lib/data/libsrc/memory_arena_test.c

@@ -0,0 +1,173 @@
+#define MEMORY_ARENA_IMPLEMENTATION
+#include "memory_arena.h"
+
+void show_arena_data(i32 arena_id, c8 *a, c8 *b, c8 *c)
+{
+  printf("data%da = %-44.44s ...\n", arena_id, a);
+  printf("data%da strlen = %ld\n", arena_id, strlen(a));
+  printf("data%db = %-44.44s ...\n", arena_id, b);
+  printf("data%db strlen = %ld\n", arena_id, strlen(b));
+  printf("data%dc = %-44.44s ...\n", arena_id, c);
+  printf("data%dc strlen = %ld\n", arena_id, strlen(c));
+}
+
+i32 main(i32 argc, c8 *argv[])
+{
+  i32 i = 0, j = 0, memory_arena_identifier1 = 0, memory_arena_identifier2 = 0;
+  c8 *data1a = NULL, *data1b = NULL, *data1c = NULL;
+  c8 *data2a = NULL, *data2b = NULL, *data2c = NULL;
+  c8 *data3a = NULL, *data3b = NULL, *data3c = NULL;
+  i32 *other_data = NULL, *medium_data = NULL;
+  f64 *large_data = NULL, *large_data2 = NULL;
+
+  printf("\nDirect allocate using 1 (literal) with 3 x 4096 byte allocations, filled with some data:\n");
+  data1a = memory_arena_allocate(1, 4096);
+  j = 'a';
+  for(i = 0; i < 4095; i++)
+    data1a[i] = j + i % 26;
+  data1a[4095] = '\0';
+  data1b = memory_arena_allocate(1, 4096);
+  j = 'A';
+  for(i = 0; i < 4095; i++)
+    data1b[i] = j + i % 26;
+  data1b[4095] = '\0';
+  data1c = memory_arena_allocate(1, 4096);
+  j = '0';
+  for(i = 0; i < 4095; i++)
+    data1c[i] = j + i % 10;
+  data1c[4095] = '\0';
+  show_arena_data(1, data1a, data1b, data1c);
+
+  printf("\nDirect allocate using 2 (literal) with 3 x 8 KB allocations, filled with some data:\n");
+  data2a = memory_arena_allocate(2, KB(8));
+  j = 'a';
+  for(i = 0; i < KB(8) - 1; i++)
+    data2a[i] = j + i % 26;
+  data2a[KB(8) - 1] = '\0';
+  data2b = memory_arena_allocate(2, KB(8));
+  j = 'A';
+  for(i = 0; i < KB(8) - 1; i++)
+    data2b[i] = j + i % 26;
+  data2b[KB(8) - 1] = '\0';
+  data2c = memory_arena_allocate(2, KB(8));
+  j = '0';
+  for(i = 0; i < KB(8) - 1; i++)
+    data2c[i] = j + i % 10;
+  data2c[KB(8) - 1] = '\0';
+  show_arena_data(2, data2a, data2b, data2c);
+
+  printf("\nDirect allocate using 3 (literal) with 8 KB, 128 KB and 16 KB blocks, fill with some data:\n");
+  data3a = memory_arena_allocate(3, 8192);
+  j = 'a';
+  for(i = 0; i < 8191; i++)
+    data3a[i] = j + i % 26;
+  data3a[8191] = '\0';
+  data3b = memory_arena_allocate(3, KB(128));
+  j = 'A';
+  for(i = 0; i < KB(128) - 1; i++)
+    data3b[i] = j + i % 26;
+  data3b[KB(128) - 1] = '\0';
+  data3c = memory_arena_allocate(3, KB(16));
+  j = '0';
+  for(i = 0; i < KB(16) - 1; i++)
+    data3c[i] = j + i % 10;
+  data3c[KB(16) - 1] = '\0';
+  show_arena_data(3, data3a, data3b, data3c);
+
+  printf("\nInitalize a new memory arena (4) with a single 4 KB (default) block\n");
+  memory_arena_identifier1 = memory_arena_init(0);
+  printf("Allocate 2048 bytes in memory arena (4) and fill with some data:\n");
+  other_data = memory_arena_allocate(memory_arena_identifier1, 2048);
+  j = '0';
+  for(i = 0; i < 512; i++)
+    other_data[i] = j + i % 10;
+  printf("other  = ");
+  for(i = 0; i < 22; i++)
+    printf("%d", other_data[i]);
+  printf(" ...\n");
+
+  printf("\nInitalize a new large dynamic memory arena (5) with a single 100 MB block\n");
+  memory_arena_identifier2 = memory_arena_init(MB(100));
+  printf("Allocate 50 MB in memory arena (5) and fill with some data:\n");
+  large_data = memory_arena_allocate(memory_arena_identifier2, MB(50));
+  j = '0';
+  for(i = 0; i < MB(50) / 8; i++)
+    large_data[i] = j + i % 10;
+  printf("large> = ");
+  for(i = 0; i < 22; i++)
+    printf("%.f", large_data[i]);
+  printf(" ...\n");
+  printf("large< = ");
+  for(i = MB(50) / 8 - 30; i < MB(50) / 8 - 8; i++)
+    printf("%.f", large_data[i]);
+  printf(" ...\n");
+
+  printf("Direct (over) allocate 75 MB in memory arena (5) and fill with some data:\n");
+  large_data2 = memory_arena_allocate(memory_arena_identifier2, MB(75));
+  j = '0';
+  for(i = 0; i < MB(75) / 8; i++)
+    large_data2[i] = j + i % 10;
+  printf("large> = ");
+  for(i = 0; i < 22; i++)
+    printf("%.f", large_data2[i]);
+  printf(" ...\n");
+  printf("large< = ");
+  for(i = MB(75) / 8 - 30; i < MB(75) / 8 - 8; i++)
+    printf("%.f", large_data2[i]);
+  printf(" ...\n");
+
+  printf("Allocate another 25 MB in memory arena (5) and fill with some data:\n");
+  medium_data = memory_arena_allocate(memory_arena_identifier1, MB(25));
+  j = '0';
+  for(i = 0; i < MB(25) / 4; i++)
+    medium_data[i] = j + i % 10;
+  printf("medium = ");
+  for(i = 0; i < 22; i++)
+    printf("%d", medium_data[i]);
+  printf(" ...\n");
+
+  printf("\n--- All memory arenas created ---");
+  memory_arena_show();
+
+  memory_arena_reset(3);
+  printf("\n--- Reset arena #3 ---\n");
+  show_arena_data(3, data3a, data3b, data3c);
+
+  memory_arena_show();
+
+  memory_arena_free(3);
+  printf("\n--- Free arena #3 ---");
+  memory_arena_show();
+
+  memory_arena_reset(1);
+  printf("\n--- Reset arena #1 ---\n");
+  show_arena_data(1, data1a, data1b, data1c);
+  memory_arena_show();
+
+  memory_arena_free(1);
+  printf("\n--- Free arena #1 ---");
+  memory_arena_show();
+
+  memory_arena_free(memory_arena_identifier1);
+  printf("\n--- Free arena #%d ---", memory_arena_identifier1);
+  memory_arena_show();
+
+  memory_arena_reset_all();
+  printf("\n--- Reset all ---\n");
+  show_arena_data(2, data2a, data2b, data2c);
+  printf("large> = ");
+  for(i = 0; i < 25; i++)
+    printf("%.f", large_data[i]);
+  printf(" ...\n");
+  printf("large< = ");
+  for(i = MB(100) / 8 - 30; i < MB(100) / 8 - 5; i++)
+    printf("%.f", large_data[i]);
+  printf(" ...\n");
+  memory_arena_show();
+
+  memory_arena_free_all();
+  printf("\n--- Free all ---\n");
+  memory_arena_show();
+
+  return 0;
+}