Basic computational life as a single file done!

lib/prick_vec.h

@@ -30,8 +30,8 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#define PRICK_VEC_INLINE_CAPACITY 32
-#define PRICK_VEC_MULT            2
+#define VEC_INLINE_CAPACITY 32
+#define VEC_MULT            2
 
 typedef struct
 {
@@ -40,48 +40,47 @@ typedef struct
   union
   {
     void *ptr;
-    alignas(max_align_t) uint8_t inlined[PRICK_VEC_INLINE_CAPACITY];
+    alignas(max_align_t) uint8_t inlined[VEC_INLINE_CAPACITY];
   };
-} prick_vec_t;
+} vec_t;
 
-static_assert(sizeof(prick_vec_t) == 64,
-              "Expected sizeof(prick_vec_t) to be 64");
+static_assert(sizeof(vec_t) == 64, "Expected sizeof(vec_t) to be 64");
 
-void prick_vec_append(prick_vec_t *vec, const void *const ptr, uint64_t size);
-void prick_vec_append_byte(prick_vec_t *vec, uint8_t byte);
-void *prick_vec_data(prick_vec_t *vec);
-void prick_vec_ensure_capacity(prick_vec_t *vec, uint64_t capacity);
-void prick_vec_ensure_free(prick_vec_t *vec, uint64_t size);
-void prick_vec_free(prick_vec_t *vec);
-void prick_vec_clone(prick_vec_t *v2, prick_vec_t *v1);
+void vec_append(vec_t *vec, const void *const ptr, uint64_t size);
+void vec_append_byte(vec_t *vec, uint8_t byte);
+void *vec_data(vec_t *vec);
+void vec_ensure_capacity(vec_t *vec, uint64_t capacity);
+void vec_ensure_free(vec_t *vec, uint64_t size);
+void vec_free(vec_t *vec);
+void vec_clone(vec_t *v2, vec_t *v1);
 
-#define PRICK_VEC_GET(VEC, INDEX, TYPE) (((TYPE *)prick_vec_data(VEC))[INDEX])
+#define VEC_GET(VEC, INDEX, TYPE) (((TYPE *)vec_data(VEC))[INDEX])
 
-#ifdef PRICK_VEC_IMPL
+#ifdef VEC_IMPL
 #define MAX(A, B) ((A) > (B) ? (A) : (B))
 
 #include <stdlib.h>
 #include <string.h>
 
-void prick_vec_append(prick_vec_t *vec, const void *const ptr, uint64_t size)
+void vec_append(vec_t *vec, const void *const ptr, uint64_t size)
 {
   if (!vec || !ptr || !size)
     return;
-  prick_vec_ensure_free(vec, size);
-  memcpy(&PRICK_VEC_GET(vec, vec->size, uint8_t), ptr, size);
+  vec_ensure_free(vec, size);
+  memcpy(&VEC_GET(vec, vec->size, uint8_t), ptr, size);
   vec->size += size;
 }
 
-void prick_vec_append_byte(prick_vec_t *vec, uint8_t byte)
+void vec_append_byte(vec_t *vec, uint8_t byte)
 {
   if (!vec)
     return;
-  prick_vec_ensure_free(vec, 1);
-  PRICK_VEC_GET(vec, vec->size, uint8_t) = byte;
+  vec_ensure_free(vec, 1);
+  VEC_GET(vec, vec->size, uint8_t) = byte;
   ++vec->size;
 }
 
-void *prick_vec_data(prick_vec_t *vec)
+void *vec_data(vec_t *vec)
 {
   if (!vec)
     return NULL;
@@ -96,15 +95,15 @@ void *prick_vec_data(prick_vec_t *vec)
   }
 }
 
-void prick_vec_ensure_capacity(prick_vec_t *vec, uint64_t capacity)
+void vec_ensure_capacity(vec_t *vec, uint64_t capacity)
 {
   if (!vec)
     return;
   if (vec->capacity == 0)
-    vec->capacity = PRICK_VEC_INLINE_CAPACITY;
+    vec->capacity = VEC_INLINE_CAPACITY;
   if (vec->capacity < capacity)
   {
-    vec->capacity = MAX(vec->capacity * PRICK_VEC_MULT, capacity);
+    vec->capacity = MAX(vec->capacity * VEC_MULT, capacity);
     if (!vec->not_inlined)
     {
       // We were a small buffer, and now we cannot be i.e. we need to allocate
@@ -123,14 +122,14 @@ void prick_vec_ensure_capacity(prick_vec_t *vec, uint64_t capacity)
   }
 }
 
-void prick_vec_ensure_free(prick_vec_t *vec, uint64_t size)
+void vec_ensure_free(vec_t *vec, uint64_t size)
 {
   if (!vec)
     return;
-  prick_vec_ensure_capacity(vec, vec->size + size);
+  vec_ensure_capacity(vec, vec->size + size);
 }
 
-void prick_vec_free(prick_vec_t *vec)
+void vec_free(vec_t *vec)
 {
   if (!vec)
     return;
@@ -139,11 +138,11 @@ void prick_vec_free(prick_vec_t *vec)
   memset(vec, 1, sizeof(*vec));
 }
 
-void prick_vec_clone(prick_vec_t *v2, prick_vec_t *v1)
+void vec_clone(vec_t *v2, vec_t *v1)
 {
   if (!v1 || !v2)
     return;
-  prick_vec_append(v2, prick_vec_data(v1), v1->size);
+  vec_append(v2, vec_data(v1), v1->size);
 }
 
 #undef MAX