prick_btree: rearrange prick_bnode_print function arguments

Something you can feed in to the init function to be used by the
printer functions.

.gitignore

@@ -1,2 +1,3 @@
 TAGS
-main*
+main*
+*.sh

README.org

@@ -0,0 +1,21 @@
+#+begin_example
+┌──────────────────────────────────┐
+│  _____  _____  _____ _____ _  __ │
+│ |  __ \|  __ \|_   _/ ____| |/ / │
+│ | |__) | |__) | | || |    | ' /  │
+│ |  ___/|  _  /  | || |    |  <   │
+│ | |    | | \ \ _| || |____| . \  │
+│ |_|    |_|  \_\_____\_____|_|\_\ │
+└──────────────────────────────────┘
+#+end_example
+
+A set of STB-style header-only libraries for common data structures
+and algorithms that I may require while working on a C code base.  The
+idea is to be as close to "plug-and-play" as possible.
+
+All you need to do is copy the relevant header files over to your
+project, then setup the implementation code within one code unit by:
+#+begin_src c
+#define <LIB>_IMPL
+#include "./<lib.h>"
+#+end_src

prick_aliases.h

@@ -0,0 +1,44 @@
+/* prick_aliases.h:
+ * Created: 2025-04-09
+ * Author: Aryadev Chavali
+ * License: See end of file
+ * Commentary:
+
+ This library defines some useful aliases for common types.  These are mostly
+ handpicked, and aren't necessary.
+ */
+
+#ifndef PRICK_ALIASES_H
+#define PRICK_ALIASES_H
+
+#include <assert.h>
+#include <stdint.h>
+
+typedef uint8_t u8;
+typedef uint16_t u16;
+typedef uint32_t u32;
+typedef uint64_t u64;
+
+typedef int8_t i8;
+typedef int16_t i16;
+typedef int32_t i32;
+typedef int64_t i64;
+
+static_assert(sizeof(float) == 4, "f32 requires 4 byte floats");
+static_assert(sizeof(double) == 8, "f64 requires 8 byte doubles");
+typedef float f32;
+typedef double f64;
+
+#endif
+
+/* Copyright (C) 2025 Aryadev Chavali
+
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE.  See the Unlicense for details.
+
+ * You may distribute and modify this code under the terms of the Unlicense,
+ * which you should have received a copy of along with this program.  If not,
+ * please go to <https://unlicense.org/>.
+
+*/

prick_arena.h

@@ -0,0 +1,191 @@
+/* prick_arena.h: An arena implementation.
+ * Created: 2024-11-01
+ * Author: Aryadev Chavali
+ * License: see end of file
+ * Commentary:
+
+ To utilise this library, please put:
+    #define PRICK_ARENA_IMPL
+    #include "prick_arena.h"
+ in one of your code units.
+
+ This library defines both:
+ - A simple bump allocator for regions, with the ability to attach more regions
+   via a linked list in case the current region when the current region is full.
+ - A simple arena memory allocator, using the bump allocator for its regions.
+
+ The regions of the arena are arranged in a linked list for simplicity.  As
+ regions aren't reallocated (instead, a new region is generated), they are
+ stable pointers, and may be used throughout a program as long as the underlying
+ arena isn't deleted.
+ */
+
+#ifndef PRICK_ARENA_H
+#define PRICK_ARENA_H
+
+#include <stdint.h>
+
+typedef struct Region
+{
+  struct Region *next;
+  uint32_t size, capacity;
+  uint8_t bytes[];
+} region_t;
+
+region_t *region_make(uint32_t capacity, region_t *next);
+uint8_t *region_alloc_flat(region_t *region, uint32_t size);
+uint8_t *region_alloc_rec(region_t *region, uint32_t size);
+void region_delete_rec(region_t *region);
+
+typedef struct
+{
+  region_t *beg, *end;
+} arena_t;
+
+uint8_t *arena_alloc(arena_t *arena, uint32_t size);
+uint8_t *arena_realloc(arena_t *arena, uint8_t *pointer, uint32_t old_size,
+                       uint32_t new_size);
+void arena_reset(arena_t *arena);
+void arena_free(arena_t *arena);
+
+#ifdef PRICK_ARENA_IMPL
+
+#include <malloc.h>
+#include <string.h>
+
+#ifndef REGION_DEFAULT_SIZE
+#define REGION_DEFAULT_SIZE 512
+#endif
+
+#ifndef REGION_CAPACITY_MULT
+#define REGION_CAPACITY_MULT 2
+#endif
+
+#define MAX(A, B) ((A) > (B) ? (A) : (B))
+#define MIN(A, B) ((A) < (B) ? (A) : (B))
+
+region_t *region_make(uint32_t capacity, region_t *next)
+{
+  capacity         = MAX(capacity, REGION_DEFAULT_SIZE);
+  region_t *region = calloc(1, sizeof(*region) + capacity);
+  region->next     = next;
+  region->size     = 0;
+  region->capacity = capacity;
+  return region;
+}
+
+uint8_t *region_alloc_rec(region_t *region, uint32_t capacity)
+{
+  if (!region)
+    return NULL;
+
+  for (; region->next && region->capacity - region->size < capacity;
+       region = region->next)
+    continue;
+
+  if (region->capacity - region->size < capacity)
+  {
+    // no region->next, so make a new region that can fit the capacity required.
+    region_t *new = region_make(capacity * REGION_CAPACITY_MULT, NULL);
+    region->next  = new;
+    region        = new;
+  }
+
+  uint8_t *start = region->bytes + region->size;
+  region->size += capacity;
+  return start;
+}
+
+void region_delete_rec(region_t *region)
+{
+  for (region_t *next = NULL; region;
+       next = region->next, free(region), region = next)
+    continue;
+}
+
+uint8_t *arena_alloc(arena_t *arena, uint32_t size)
+{
+  if (!arena->beg)
+  {
+    arena->beg = region_make(size, NULL);
+    arena->end = arena->beg;
+  }
+
+  uint8_t *start = region_alloc_rec(arena->beg, size);
+  // if we've attached a new region, end needs to be at that region
+  if (arena->end->next)
+    arena->end = arena->end->next;
+  return start;
+}
+
+uint8_t *arena_realloc(arena_t *arena, uint8_t *pointer, uint32_t old_size,
+                       uint32_t new_size)
+{
+  if (!pointer)
+    // Basically the same as allocating at this point
+    return arena_alloc(arena, newsize);
+
+  // Firstly find the region the pointer exists in
+  region_t *prev, *reg;
+  for (prev = NULL, reg = arena->beg;
+       reg &&
+       !(reg->bytes <= pointer && reg->bytes + reg->size >= pointer + old_size);
+       prev = reg, reg = reg->next)
+    continue;
+
+  uint8_t *new_ptr = NULL;
+
+  // pointer isn't allocated in the arena, just allocate a new pointer
+  if (!reg)
+    goto arena_realloc__allocate_new;
+
+  /*
+    If `ptr` is the latest allocation in `reg` and `reg` has enough capacity to
+    handle newsize, then we can adjust `reg` and not have to do any further
+    allocation work.
+
+    This check is not UB because ptr is confirmed to be in reg.
+   */
+  if (ptr + oldsize == reg->bytes + reg->size &&
+      (reg->capacity - reg->size) > (newsize - oldsize))
+  {
+    reg->size += newsize - oldsize;
+    return ptr;
+  }
+
+arena_realloc__allocate_new:
+  new_ptr = arena_alloc(arena, newsize);
+  memcpy(new_ptr, ptr, oldsize);
+  return new_ptr;
+}
+
+void arena_reset(arena_t *arena)
+{
+  for (region_t *region = arena->beg; region; region = region->next)
+  {
+    region->size = 0;
+    memset(region->bytes, 0, region->capacity);
+  }
+}
+
+void arena_free(arena_t *arena)
+{
+  region_delete_rec(arena->beg);
+  memset(arena, 0, sizeof(*arena));
+}
+
+#endif
+
+#endif
+/* Copyright (C) 2024 Aryadev Chavali
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the Unlicense
+ * for details.
+
+ * You may distribute and modify this code under the terms of the
+ * Unlicense, which you should have received a copy of along with this
+ * program.  If not, please go to <https://unlicense.org/>.
+
+ */

prick_btree.h

@@ -0,0 +1,210 @@
+/* prick_btree.h: A generic ordered binary tree.
+ * Created: 2025-04-09
+ * Author: Aryadev Chavali
+ * License: See end of file
+ * Commentary:
+
+ To utilise this library, please put:
+    #define PRICK_BTREE_IMPL
+    #include "prick_btree.h"
+ in one of your code units.
+
+ An ordered binary tree implementation, allowing the use of custom comparators
+ and allocators.
+ */
+
+#ifndef PRICK_BTREE_H
+#define PRICK_BTREE_H
+
+#include <stdio.h>
+
+typedef struct Prick_Bnode
+{
+  void *value;
+  struct Prick_Bnode *left, *right;
+} prick_bnode_t;
+
+typedef int (*prick_bnode_comp_fn)(void *, void *);
+typedef prick_bnode_t *(*prick_bnode_alloc_fn)();
+typedef void (*prick_bnode_free_fn)(prick_bnode_t *);
+typedef void (*prick_print_fn)(FILE *, void *);
+
+typedef struct
+{
+  prick_bnode_t *root;
+  prick_bnode_comp_fn comp;
+  prick_bnode_alloc_fn alloc;
+  prick_bnode_free_fn free;
+  prick_print_fn print;
+} prick_btree_t;
+
+void prick_btree_init(prick_btree_t *tree, prick_bnode_comp_fn comparator,
+                      prick_bnode_alloc_fn allocator, prick_bnode_free_fn free,
+                      prick_print_fn print);
+prick_bnode_t *prick_btree_insert(prick_btree_t *tree, void *value);
+void prick_btree_print(FILE *fp, prick_btree_t *tree);
+void prick_btree_free(prick_btree_t *tree);
+
+void prick_bnode_right_rotate(prick_bnode_t **node);
+void prick_bnode_left_rotate(prick_bnode_t **node);
+void prick_bnode_print(FILE *fp, prick_print_fn print, prick_bnode_t *root);
+
+#ifdef PRICK_BTREE_IMPL
+
+#include <assert.h>
+#include <stdlib.h>
+
+void prick_btree_init(prick_btree_t *tree, prick_bnode_comp_fn comparator,
+                      prick_bnode_alloc_fn allocator, prick_bnode_free_fn free,
+                      prick_print_fn print)
+{
+  // NOTE: These NEED to be supplied.
+  assert(comparator);
+  assert(allocator);
+  assert(free);
+  assert(print);
+  if (tree)
+  {
+    tree->root  = NULL;
+    tree->comp  = comparator;
+    tree->alloc = allocator;
+    tree->free  = free;
+    tree->print = print;
+  }
+}
+
+prick_bnode_t *prick_bnode_insert(prick_bnode_t *node, prick_btree_t *tree,
+                                  void *value)
+{
+  if (!node)
+  {
+    node        = tree->alloc();
+    node->value = value;
+    node->left  = NULL;
+    node->right = NULL;
+    return node;
+  }
+
+  int comp                    = tree->comp(value, node->value);
+  prick_bnode_t **picked_node = NULL;
+  if (comp < 0)
+    picked_node = &node->left;
+  else
+    picked_node = &node->right;
+
+  if (*picked_node)
+    prick_bnode_insert(*picked_node, tree, value);
+  else
+  {
+    *picked_node          = tree->alloc();
+    picked_node[0]->value = value;
+    picked_node[0]->left  = NULL;
+    picked_node[0]->right = NULL;
+  }
+
+  return node;
+}
+
+prick_bnode_t *prick_btree_insert(prick_btree_t *tree, void *value)
+{
+  tree->root = prick_bnode_insert(tree->root, tree, value);
+  return tree->root;
+}
+
+void prick_btree_print(FILE *fp, prick_btree_t *tree)
+{
+  if (!tree->root)
+  {
+    fprintf(fp, "()");
+  }
+  else
+  {
+    prick_bnode_print(fp, tree->print, tree->root);
+  }
+}
+
+void prick_bnode_free(prick_bnode_t *bnode, prick_bnode_free_fn free_fn)
+{
+  if (!bnode)
+    return;
+  prick_bnode_t *left  = bnode->left;
+  prick_bnode_t *right = bnode->right;
+
+  free_fn(bnode);
+  prick_bnode_free(left, free_fn);
+  prick_bnode_free(right, free_fn);
+}
+
+void prick_btree_free(prick_btree_t *tree)
+{
+  if (!tree)
+    return;
+  prick_bnode_free(tree->root, tree->free);
+  tree->root = NULL;
+}
+
+void prick_bnode_right_rotate(prick_bnode_t **node)
+{
+  if (!node || !*node)
+    return;
+
+  prick_bnode_t *left = (*node)->left;
+  if (left)
+  {
+    (*node)->left = left->right;
+    left->right   = *node;
+    *node         = left;
+  }
+}
+
+void prick_bnode_left_rotate(prick_bnode_t **node)
+{
+  if (!node || !*node)
+    return;
+
+  prick_bnode_t *right = (*node)->right;
+  if (right)
+  {
+    (*node)->right = right->left;
+    right->left    = *node;
+    *node          = right;
+  }
+}
+
+void prick_bnode_print(FILE *fp, prick_print_fn print, prick_bnode_t *root)
+{
+  if (!root)
+    return;
+  fprintf(fp, "(");
+  print(fp, root->value);
+  if (root->left)
+  {
+    fprintf(fp, " l");
+    prick_bnode_print(fp, print, root->left);
+  }
+
+  if (root->right)
+  {
+    fprintf(fp, " r");
+    prick_bnode_print(fp, print, root->right);
+  }
+
+  fprintf(fp, ")");
+}
+
+#endif
+
+#endif
+
+/* Copyright (C) 2025 Aryadev Chavali
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the Unlicense
+ * for details.
+
+ * You may distribute and modify this code under the terms of the
+ * Unlicense, which you should have received a copy of along with this
+ * program.  If not, please go to <https://unlicense.org/>.
+
+*/

prick_darr.h

@@ -0,0 +1,130 @@
+/* prick_darr.h: A dynamically sized array, all on the heap.
+ * Created: 2024-10-01
+ * Author: Aryadev Chavali
+ * License: see end of file
+ * Commentary:
+
+ To utilise this library, please put:
+    #define PRICK_DARR_IMPL
+    #include "prick_darr.h"
+ in one of your code units.
+
+ This library defines a dynamic array purely on the heap.  We split the one
+ dynamic array allocation into two parts: the metadata, and the actual data.
+ Consumers of the library will only ever need to deal with the latter component
+ i.e. they'll only ever have access to the data they require.
+
+ Unfortuntely this does mean that the underlying data pointer is _not_ stable
+ during capacity reallocation, as we're allocating a whole new pointer with the
+ correct size.  Therefore, if you're expecting the array to grow during the
+ runtime of your program, you should ensure any pointers to components of it are
+ updated as they will otherwise be dangling.
+ */
+
+#ifndef PRICK_DARR_H
+#define PRICK_DARR_H
+
+#include <stdint.h>
+
+typedef struct
+{
+  uint32_t size, capacity;
+  uint8_t bytes[];
+} darr_t;
+
+#define DARR_GET(P)  (((darr_t *)(P)) - 1)
+#define DARR_SIZE(P) (DARR_GET(P)->size)
+#define DARR_CAP(P)  (DARR_GET(P)->capacity)
+
+void darr_make(void **ptr, uint32_t size);
+void darr_free(void **ptr);
+void darr_append_byte(void **ptr, uint8_t byte);
+void darr_append(void **ptr, void *data, uint32_t size);
+void darr_clone(void **dest, void **src);
+void darr_ensure_remaining(void **ptr, uint32_t space);
+
+#ifdef PRICK_DARR_IMPL
+
+#include <malloc.h>
+#include <string.h>
+
+#ifndef DARR_MULT
+#define DARR_MULT 2
+#endif
+
+#define MAX(A, B) ((A) > (B) ? (A) : (B))
+#define MIN(A, B) ((A) < (B) ? (A) : (B))
+
+void darr_make(void **ptr, uint32_t size)
+{
+  if (!ptr)
+    return;
+  darr_t *darrtor   = calloc(1, sizeof(*darrtor) + size);
+  darrtor->size     = 0;
+  darrtor->capacity = size;
+  *ptr              = (darrtor + 1);
+}
+
+void darr_free(void **data)
+{
+  if (!data || !*data)
+    return;
+  free(DARR_GET(*data));
+  *data = NULL;
+}
+
+void darr_ensure_remaining(void **ptr, uint32_t space)
+{
+  if (!ptr || !*ptr)
+    return;
+  darr_t *darr = DARR_GET(*ptr);
+  if (darr->capacity - darr->size < space)
+  {
+    void *new_darr = NULL;
+    darr_make(&new_darr, MAX(darr->capacity * DARR_MULT, darr->size + space));
+    DARR_SIZE(new_darr) = darr->size;
+    memcpy(new_darr, *ptr, darr->size);
+    darr_free(ptr);
+    *ptr = new_darr;
+  }
+}
+
+void darr_append_byte(void **ptr, uint8_t byte)
+{
+  darr_ensure_remaining(ptr, 1);
+  darr_t *darr              = DARR_GET(*ptr);
+  darr->bytes[darr->size++] = byte;
+}
+
+void darr_append(void **ptr, void *data, uint32_t size)
+{
+  darr_ensure_remaining(ptr, size);
+  darr_t *darr = DARR_GET(*ptr);
+  memcpy(*ptr + darr->size, data, size);
+  darr->size += size;
+}
+
+void darr_clone(void **dest, void **src)
+{
+  if (!dest || !src || !*src)
+    return;
+  darr_make(dest, DARR_SIZE(*src));
+  memcpy(*dest, *src, DARR_SIZE(*src));
+  DARR_SIZE(*dest) = DARR_SIZE(*src);
+}
+
+#endif
+
+#endif
+
+/* Copyright (C) 2024 Aryadev Chavali
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the Unlicense
+ * for details.
+
+ * You may distribute and modify this code under the terms of the
+ * Unlicense, which you should have received a copy of along with this
+ * program.  If not, please go to <https://unlicense.org/>.
+
+ */

vec.h

@@ -1,112 +0,0 @@
-/* Copyright (C) 2024 Aryadev Chavali
-
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the Unlicense
- * for details.
-
- * You may distribute and modify this code under the terms of the
- * Unlicense, which you should have received a copy of along with this
- * program.  If not, please go to <https://unlicense.org/>.
-
- * Created: 2024-10-01
- * Author: Aryadev Chavali
- * Description: A dynamically sized container.
- */
-
-#ifndef VEC_H
-#define VEC_H
-
-#include <stdint.h>
-
-typedef struct
-{
-  uint32_t size, capacity;
-  uint8_t bytes[];
-} vec_t;
-
-#define VEC_GET(P)  (((vec_t *)(P)) - 1)
-#define VEC_SIZE(P) (VEC_GET(P)->size)
-#define VEC_CAP(P)  (VEC_GET(P)->capacity)
-
-void vec_make(void **ptr, uint32_t size);
-void vec_free(void **ptr);
-void vec_append_byte(void **ptr, uint8_t byte);
-void vec_append(void **ptr, void *data, uint32_t size);
-void vec_clone(void **dest, void **src);
-void vec_ensure_remaining(void **ptr, uint32_t space);
-
-#define VEC_IMPL
-#ifdef VEC_IMPL
-
-#include <malloc.h>
-#include <string.h>
-
-#ifndef MAX
-#define MAX(A, B) ((A) > (B) ? (A) : (B))
-#endif
-
-#ifndef MIN
-#define MIN(A, B) ((A) < (B) ? (A) : (B))
-#endif
-
-void vec_make(void **ptr, uint32_t size)
-{
-  if (!ptr)
-    return;
-  vec_t *vector    = calloc(1, sizeof(*vector) + size);
-  vector->size     = 0;
-  vector->capacity = size;
-  *ptr             = (vector + 1);
-}
-
-void vec_free(void **data)
-{
-  if (!data || !*data)
-    return;
-  free(VEC_GET(*data));
-  *data = NULL;
-}
-
-void vec_ensure_remaining(void **ptr, uint32_t space)
-{
-  if (!ptr || !*ptr)
-    return;
-  vec_t *vec = VEC_GET(*ptr);
-  if (vec->capacity - vec->size < space)
-  {
-    void *new_vec = NULL;
-    vec_make(&new_vec, MAX(vec->capacity * 2, vec->size + space));
-    VEC_SIZE(new_vec) = vec->size;
-    memcpy(new_vec, *ptr, vec->size);
-    vec_free(ptr);
-    *ptr = new_vec;
-  }
-}
-
-void vec_append_byte(void **ptr, uint8_t byte)
-{
-  vec_ensure_remaining(ptr, 1);
-  vec_t *vec              = VEC_GET(*ptr);
-  vec->bytes[vec->size++] = byte;
-}
-
-void vec_append(void **ptr, void *data, uint32_t size)
-{
-  vec_ensure_remaining(ptr, size);
-  vec_t *vec = VEC_GET(*ptr);
-  memcpy(vec->bytes + vec->size, data, size);
-  vec->size += size;
-}
-
-void vec_clone(void **dest, void **src)
-{
-  if (!dest || !src || !*src)
-    return;
-  vec_make(dest, VEC_SIZE(*src));
-  memcpy(*dest, *src, VEC_SIZE(*src));
-  VEC_SIZE(*dest) = VEC_SIZE(*src);
-}
-#endif
-
-#endif