nyaaaa thats all the namespacing your going to get for nyow, im tired :3

Makefile

@@ -9,8 +9,8 @@ FLAGS=-g $(CFLAGS) $(LDFLAGS) $(LIBS)
 
 S=comp.c wayland.c glfw.c
 S+=vulkan.c kitty.c
-S+=string.c gpu_allocator.c hashmap.c util.c io.c matrix.c dynarray.c image.c types.c allocator.c log.c
+S+=string.c gpu_allocator.c hashmap.c util.c io.c matrix.c paw_da.c image.c types.c paw_allocator.c paw_log.c
-S+=object.c register.c
+S+=paw_object.c register.c
 S+=Wayland/xdg-shell-protocol.c
 S+=lang/ast.c lang/vstack.c lang/ast_disc.c lang/functable.c lang/glue.c
 SO=$(addprefix build/,$(S:.c=.o))

main.c

@@ -1,5 +1,5 @@
 #include "src/comp.h"
-#include "src/object.h"
+#include "src/paw_object.h"
 #include "src/register.h"
 #include "trig.c"
 
@@ -22,16 +22,16 @@ int main() {
   struct Register *reg = make_register();
   reg_attatch_type(reg, "trig", OBJ_MAKE make_trig, OBJ_FREE free_trig,
                    OBJ_TICK trig_tick);
-  struct Scene *scene = make_scene(vk, reg);
+  struct PawScene *scene = paw_scene_make(vk, reg);
 
-  scene_queue_insert(scene, "trig", trig_make_args(scene));
+  paw_scene_queue_insert(scene, "trig", trig_make_args(scene));
 
   while (!cat_comp_should_close(state)) {
-    scene_tick(scene);
+    paw_scene_tick(scene);
     cat_comp_draw(state);
   }
 
-  free_scene(scene);
+  paw_scene_free(scene);
   free_register(reg);
 
   cat_comp_uninit(state);

src/allocator.h

@@ -1,28 +0,0 @@
-#ifndef INCLUDE_WAYLANDCLIENT_ALLOCATOR_H_
-#define INCLUDE_WAYLANDCLIENT_ALLOCATOR_H_
-
-#include "sys/types.h"
-
-#define MAX_ALLOCS 256
-struct Alloc {
-  void *start;
-  uint size;
-  struct Alloc *next;
-};
-struct Mem {
-  void *mem;
-  size_t mem_size;
-  uint count;
-  struct Alloc *alloc;
-  struct Alloc allocs[MAX_ALLOCS];
-};
-
-struct Mem *make_mem(size_t size);
-void uninit_mem(struct Mem *mem);
-
-void *mem_malloc(struct Mem *mem, size_t size);
-void mem_free(struct Mem *mem, void *p);
-void *malloc_or_mem_malloc(struct Mem *mem, size_t size);
-void free_or_mem_free(struct Mem *mem, void *ptr);
-
-#endif // INCLUDE_WAYLANDCLIENT_ALLOCATOR_H_

src/glfw.c

@@ -1,4 +1,4 @@
-#include "log.h"
+#include "paw_log.h"
 #include "vulkan.h"
 
 #include <GLFW/glfw3.h>

src/gpu_allocator.c

@@ -146,7 +146,7 @@ void gpu_mem_free(struct Vk *state, struct GpuMem *mem,
       if (current == NULL || pointer.offset != current->start) {
         meow("WHOOOPPSIIIEEEE could not find allocated block, potential dobble "
              "free");
-        print_backtrace();
+        paw_print_backtrace();
         return;
       }
       prev->next = current->next;

src/hashmap.c

@@ -3,7 +3,7 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "log.h"
+#include "paw_log.h"
 
 #define HASH_MASK 0b111111
 #define TYPE uint32_t

src/io.c

@@ -1,4 +1,4 @@
-#include "log.h"
+#include "paw_log.h"
 
 #include <stdint.h>
 #include <stdio.h>

src/kitty.c

@@ -3,30 +3,30 @@
 #include <vulkan/vulkan.h>
 #include <vulkan/vulkan_core.h>
 
-#include "allocator.h"
-#include "dynarray.h"
 #include "io.h"
 #include "kitty.h"
+#include "paw_allocator.h"
+#include "paw_da.h"
 #include "vulkan.h"
 #include "vulkan_helpers.c"
 
-struct Kitty *kitty_make(struct Mem *mem) {
+struct Kitty *kitty_make(struct PawMem *mem) {
   struct Kitty *kitty;
   if (mem == NULL) {
     kitty = malloc(sizeof(struct Kitty));
   } else {
-    kitty = mem_malloc(mem, sizeof(struct Kitty));
+    kitty = paw_memmalloc(mem, sizeof(struct Kitty));
   }
   memset(kitty, 0, sizeof(struct Kitty));
   kitty->mem = mem;
   if (kitty->mem == NULL) {
-    dyn_array_create_inplace(&kitty->attatchments);
+    paw_da_make_inplace(&kitty->attatchments);
-    dyn_array_create_inplace(&kitty->vertex_buffer.format);
+    paw_da_make_inplace(&kitty->vertex_buffer.format);
-    dyn_array_create_inplace(&kitty->instance_buffer.format);
+    paw_da_make_inplace(&kitty->instance_buffer.format);
   } else {
-    dyn_array_create_inplace_mem(&kitty->attatchments, kitty->mem);
+    paw_da_make_inplace_mem(&kitty->attatchments, kitty->mem);
-    dyn_array_create_inplace_mem(&kitty->vertex_buffer.format, kitty->mem);
+    paw_da_make_inplace_mem(&kitty->vertex_buffer.format, kitty->mem);
-    dyn_array_create_inplace_mem(&kitty->instance_buffer.format, kitty->mem);
+    paw_da_make_inplace_mem(&kitty->instance_buffer.format, kitty->mem);
   }
   meow("alloced a kitty at %p", kitty);
   return kitty;
@@ -63,34 +63,34 @@ void kitty_add_instance_buffer(struct Kitty *kitty, void *data, uint32_t count,
 }
 void kitty_add_instance_buffer_format(struct Kitty *kitty,
                                       enum VkFormat format) {
-  dyn_array_append(&kitty->instance_buffer.format, format);
+  paw_da_append(&kitty->instance_buffer.format, format);
 }
 
 void kitty_add_vertex_buffer_format(struct Kitty *kitty, enum VkFormat format) {
-  dyn_array_append(&kitty->vertex_buffer.format, format);
+  paw_da_append(&kitty->vertex_buffer.format, format);
 }
 void kitty_attatch_image(struct Kitty *kitty, const char *path) {
-  struct Attatchment attatchment = {0};
+  struct KittyAttatchment attatchment = {0};
   attatchment.type = CAT_ATTATCH_IMAGE;
   attatchment.image.path = path;
-  dyn_array_append(&kitty->attatchments, attatchment);
+  paw_da_append(&kitty->attatchments, attatchment);
   meow("image was attatched");
 }
 int kitty_attatch_ubo(struct Kitty *kitty, uint32_t size) {
-  struct Attatchment attatchment = {0};
+  struct KittyAttatchment attatchment = {0};
   attatchment.type = CAT_ATTATCH_UBO;
   attatchment.ubo.size = size;
-  dyn_array_append(&kitty->attatchments, attatchment);
+  paw_da_append(&kitty->attatchments, attatchment);
   meow("ubo of size %d was attatched", size);
   return kitty->attatchments.count - 1;
 }
 int kitty_attatch_ubo_array(struct Kitty *kitty, uint32_t size,
                             uint32_t count) {
-  struct Attatchment attatchment = {0};
+  struct KittyAttatchment attatchment = {0};
   attatchment.type = CAT_ATTATCH_UBO_ARRAY;
   attatchment.ubo_array.size = size;
   attatchment.ubo_array.count = count;
-  dyn_array_append(&kitty->attatchments, attatchment);
+  paw_da_append(&kitty->attatchments, attatchment);
   return kitty->attatchments.count - 1;
 }
 
@@ -107,10 +107,10 @@ void kitty_finalise(struct Vk *state, struct Kitty *kitty) {
     kitty_create_instance_buffer(kitty, state);
   }
 
-  dyn_array_append(&state->kitties, kitty);
+  paw_da_append(&state->kitties, kitty);
 }
 
-void free_kitty(struct Vk *state, struct Kitty *kitty) {
+void kitty_free(struct Vk *state, struct Kitty *kitty) {
   vkDeviceWaitIdle(state->device);
   vkDestroyBuffer(state->device, kitty->vertex_buffer.buffer, NULL);
   gpu_mem_free(state, state->mem, kitty->vertex_buffer.memory);
@@ -154,14 +154,14 @@ void free_kitty(struct Vk *state, struct Kitty *kitty) {
     }
   }
 
-  dyn_array_destroy(&kitty->vertex_buffer.format);
+  paw_da_free(&kitty->vertex_buffer.format);
-  dyn_array_destroy(&kitty->attatchments);
+  paw_da_free(&kitty->attatchments);
 
   if (kitty->mem == NULL) {
     memset(kitty, 0, sizeof(struct Kitty));
     free(kitty);
   } else {
-    mem_free(kitty->mem, kitty);
+    paw_memfree(kitty->mem, kitty);
   }
 }
 
@@ -537,7 +537,7 @@ void kitty_create_image_attatchments(struct Kitty *kitty, struct Vk *state) {
     if (kitty->attatchments.items[index].type != CAT_ATTATCH_IMAGE) {
       continue;
     }
-    struct Attatchment *atch = &kitty->attatchments.items[index];
+    struct KittyAttatchment *atch = &kitty->attatchments.items[index];
     atch->image.pixels = load_image(atch->image.path, &atch->image.dims);
     atch->image.size = atch->image.dims.x * atch->image.dims.y * 4;
 

src/kitty.h

@@ -5,14 +5,14 @@
 #include "vulkan.h"
 #include <vulkan/vulkan.h>
 
-enum AttatchType {
+enum KittyAttatchType {
   CAT_ATTATCH_IMAGE,
   CAT_ATTATCH_UBO,
   CAT_ATTATCH_UBO_ARRAY,
 };
 
-struct Attatchment {
+struct KittyAttatchment {
-  enum AttatchType type;
+  enum KittyAttatchType type;
   union {
     struct {
       const char *path;
@@ -38,7 +38,7 @@ struct Attatchment {
   };
 };
 
-dyn_array_define(da_Attatchment, struct Attatchment);
+paw_da_define(da_Attatchment, struct KittyAttatchment);
 
 struct Kitty {
   VkPipeline pipeline;
@@ -60,10 +60,10 @@ struct Kitty {
   VkDescriptorSetLayout descriptor_set_layout;
   VkDescriptorSet descriptor_sets[MAX_FRAMES_IN_FLIGHT];
 
-  struct Mem *mem;
+  struct PawMem *mem;
 };
 
-struct Kitty *kitty_make(struct Mem *mem);
+struct Kitty *kitty_make(struct PawMem *mem);
 void kitty_set_vertex_shader(struct Kitty *thingy, const char *path);
 void kitty_set_fragment_shader(struct Kitty *thingy, const char *path);
 
@@ -105,7 +105,7 @@ void *kitty_get_next_ubo_pointer(struct Vk *state, struct Kitty *kitty,
 
 void kitty_draw(struct Vk *state, uint32_t image_index, struct Kitty *thingy);
 
-void free_kitty(struct Vk *state, struct Kitty *kitty);
+void kitty_free(struct Vk *state, struct Kitty *kitty);
 
 void kitty_create_layout_bindings(struct Kitty *kitty, struct Vk *state);
 void kitty_create_pipeline(struct Kitty *kitty, struct Vk *state);

src/lang/ast.c

@@ -1,7 +1,7 @@
 #include <stdbool.h>
 #include <stdlib.h>
 
-#include "../log.h"
+#include "../paw_log.h"
 #include "ast.h"
 
 const bool log_stack = false;
@@ -73,7 +73,7 @@ char *print_stackval(struct PawStackVal val) {
     sprintf(res, "%d", val.i);
     break;
   case PAW_VAL_BOOL:
-    strcpy(res, bool_to_string(val.b));
+    strcpy(res, paw_b_to_s(val.b));
     break;
   case PAW_VAL_CHAR:
     sprintf(res, "%c", val.c);
@@ -178,7 +178,7 @@ struct PawStackVal try_cast(enum PawVal target, enum PawVal *val) {
   return PSV_NULL;
 }
 
-enum PawVal *ast_stack_to_heap(struct Mem *mem, struct PawStackVal val) {
+enum PawVal *ast_stack_to_heap(struct PawMem *mem, struct PawStackVal val) {
   switch (val.type) {
   case PAW_VAL_FLOAT:
     return make_pawval_float(mem, val.f);
@@ -229,7 +229,7 @@ struct PawStackVal op_add(struct PawStackVal lhs, struct PawStackVal rhs) {
   return PSV_NULL;
 }
 
-enum PawVal *make_pawval_float(struct Mem *mem, float n) {
+enum PawVal *make_pawval_float(struct PawMem *mem, float n) {
   enum PawVal *val;
   val_make(val, float, PAW_VAL_FLOAT);
   float *f = val_get_data(val);
@@ -237,7 +237,7 @@ enum PawVal *make_pawval_float(struct Mem *mem, float n) {
   return val;
 }
 
-enum PawVal *make_pawval_int(struct Mem *mem, int n) {
+enum PawVal *make_pawval_int(struct PawMem *mem, int n) {
   enum PawVal *val;
   val_make(val, int, PAW_VAL_INT);
   int *i = (int *)val_get_data(val);
@@ -245,7 +245,7 @@ enum PawVal *make_pawval_int(struct Mem *mem, int n) {
   return val;
 }
 
-enum PawVal *make_pawval_bool(struct Mem *mem, bool n) {
+enum PawVal *make_pawval_bool(struct PawMem *mem, bool n) {
   enum PawVal *val;
   val_make(val, bool, PAW_VAL_BOOL);
   bool *i = val_get_data(val);
@@ -253,7 +253,7 @@ enum PawVal *make_pawval_bool(struct Mem *mem, bool n) {
   return val;
 }
 
-enum PawVal *make_pawval_point(struct Mem *mem, paw_p n) {
+enum PawVal *make_pawval_point(struct PawMem *mem, paw_p n) {
   enum PawVal *val;
   val_make(val, paw_p, PAW_VAL_POINT);
   paw_p *i = val_get_data(val);
@@ -261,7 +261,7 @@ enum PawVal *make_pawval_point(struct Mem *mem, paw_p n) {
   return val;
 }
 
-enum PawVal *make_pawval_spoint(struct Mem *mem, int n) {
+enum PawVal *make_pawval_spoint(struct PawMem *mem, int n) {
   enum PawVal *val;
   val_make(val, paw_p, PAW_VAL_SPOINT);
   int *i = val_get_data(val);
@@ -269,7 +269,7 @@ enum PawVal *make_pawval_spoint(struct Mem *mem, int n) {
   return val;
 }
 
-enum PawVal *make_pawval_char(struct Mem *mem, char n) {
+enum PawVal *make_pawval_char(struct PawMem *mem, char n) {
   enum PawVal *val;
   val_make(val, paw_p, PAW_VAL_CHAR);
   char *i = val_get_data(val);
@@ -277,7 +277,7 @@ enum PawVal *make_pawval_char(struct Mem *mem, char n) {
   return val;
 }
 
-enum PawVal *make_pawval_expr(struct Mem *mem, enum PawVal *lhs,
+enum PawVal *make_pawval_expr(struct PawMem *mem, enum PawVal *lhs,
                               enum PawVal *rhs, uint32_t op) {
   enum PawVal *val;
   val_make(val, struct PawExpr, PAW_VAL_EXPR);
@@ -288,7 +288,7 @@ enum PawVal *make_pawval_expr(struct Mem *mem, enum PawVal *lhs,
   return val;
 }
 
-void free_pawval(struct Mem *mem, enum PawVal *val) {
+void free_pawval(struct PawMem *mem, enum PawVal *val) {
   switch (*val) {
   case PAW_VAL_FLOAT:
   case PAW_VAL_INT:
@@ -296,58 +296,58 @@ void free_pawval(struct Mem *mem, enum PawVal *val) {
   case PAW_VAL_POINT:
   case PAW_VAL_SPOINT:
   case PAW_VAL_CHAR:
-    mem_free(mem, val);
+    paw_memfree(mem, val);
     break;
   case PAW_VAL_EXPR:;
     struct PawExpr *expr = val_get_data(val);
     free_pawval(mem, expr->lhs);
     free_pawval(mem, expr->rhs);
-    mem_free(mem, val);
+    paw_memfree(mem, val);
     break;
   }
 }
 
-enum PawCtrl *make_pawctrl_seq(struct Mem *mem) {
+enum PawCtrl *make_pawctrl_seq(struct PawMem *mem) {
   enum PawCtrl *ctrl;
   ctrl_make(ctrl, struct PawSeq, PAW_CTRL_SEQ);
   struct PawSeq *i = ctrl_get_data(ctrl);
-  dyn_array_create_inplace_mem(&i->seq, mem);
+  paw_da_make_inplace_mem(&i->seq, mem);
   return ctrl;
 }
 
-enum PawCtrl *make_pawctrl_call(struct Mem *mem, enum PawCtrl *body) {
+enum PawCtrl *make_pawctrl_call(struct PawMem *mem, enum PawCtrl *body) {
   enum PawCtrl *ctrl;
   ctrl_make(ctrl, struct PawCall, PAW_CTRL_CALL);
   struct PawCall *i = ctrl_get_data(ctrl);
   i->body = body;
   return ctrl;
 }
-enum PawCtrl *make_pawctrl_spush(struct Mem *mem, struct PawStackVal val) {
+enum PawCtrl *make_pawctrl_spush(struct PawMem *mem, struct PawStackVal val) {
   enum PawCtrl *ctrl;
   ctrl_make(ctrl, struct PawStackPush, PAW_CTRL_SPUSH);
   struct PawStackPush *i = ctrl_get_data(ctrl);
   i->v = val;
   return ctrl;
 }
-enum PawCtrl *make_pawctrl_spop(struct Mem *mem) {
+enum PawCtrl *make_pawctrl_spop(struct PawMem *mem) {
   enum PawCtrl *ctrl;
   ctrl_make(ctrl, struct PawEmpty, PAW_CTRL_SPOP);
   return ctrl;
 }
-enum PawCtrl *make_pawctrl_break(struct Mem *mem) {
+enum PawCtrl *make_pawctrl_break(struct PawMem *mem) {
   enum PawCtrl *ctrl;
   ctrl_make(ctrl, struct PawEmpty, PAW_CTRL_BREAK);
   return ctrl;
 }
 
-enum PawCtrl *make_pawctrl_loop(struct Mem *mem, enum PawCtrl *body) {
+enum PawCtrl *make_pawctrl_loop(struct PawMem *mem, enum PawCtrl *body) {
   enum PawCtrl *ctrl;
   ctrl_make(ctrl, struct PawLoop, PAW_CTRL_LOOP);
   struct PawLoop *i = ctrl_get_data(ctrl);
   i->body = body;
   return ctrl;
 }
-enum PawCtrl *make_pawctrl_if(struct Mem *mem, enum PawVal *cond,
+enum PawCtrl *make_pawctrl_if(struct PawMem *mem, enum PawVal *cond,
                               enum PawCtrl *truthy, enum PawCtrl *falsy) {
   enum PawCtrl *ctrl;
   ctrl_make(ctrl, struct PawIf, PAW_CTRL_IF);
@@ -358,7 +358,7 @@ enum PawCtrl *make_pawctrl_if(struct Mem *mem, enum PawVal *cond,
   return ctrl;
 }
 
-enum PawCtrl *make_pawctrl_asign(struct Mem *mem, struct PawStackVal target,
+enum PawCtrl *make_pawctrl_asign(struct PawMem *mem, struct PawStackVal target,
                                  enum PawVal *val) {
   enum PawCtrl *ctrl;
   ctrl_make(ctrl, struct PawAsign, PAW_CTRL_ASIGN);
@@ -368,7 +368,7 @@ enum PawCtrl *make_pawctrl_asign(struct Mem *mem, struct PawStackVal target,
   return ctrl;
 }
 
-enum PawCtrl *make_pawctrl_ccall(struct Mem *mem, int index) {
+enum PawCtrl *make_pawctrl_ccall(struct PawMem *mem, int index) {
   enum PawCtrl *ctrl;
   ctrl_make(ctrl, struct PawCCall, PAW_CTRL_CCALL);
   struct PawCCall *i = ctrl_get_data(ctrl);
@@ -378,32 +378,32 @@ enum PawCtrl *make_pawctrl_ccall(struct Mem *mem, int index) {
 
 void pawseq_append(enum PawCtrl *seq, enum PawCtrl *ctrl) {
   struct PawSeq *seqval = ctrl_get_data(seq);
-  dyn_array_append(&seqval->seq, ctrl);
+  paw_da_append(&seqval->seq, ctrl);
 }
 void pawseq_insert(enum PawCtrl *seq, int index, enum PawCtrl *ctrl) {
   struct PawSeq *seqval = ctrl_get_data(seq);
-  dyn_array_insert(&seqval->seq, index, ctrl);
+  paw_da_insert(&seqval->seq, index, ctrl);
 }
 
 struct PawAST *ast_make() {
-  struct Mem *mem = make_mem(8192);
+  struct PawMem *mem = paw_memmake(8192);
   // ast HAS to be the first thing allocated with mem
-  struct PawAST *ast = mem_malloc(mem, sizeof(struct PawAST));
+  struct PawAST *ast = paw_memmalloc(mem, sizeof(struct PawAST));
 
   char *t = "meow\n";
-  char *test = mem_malloc(mem, strlen(t) + 1);
+  char *test = paw_memmalloc(mem, strlen(t) + 1);
   memcpy(test, t, strlen(t) + 1);
 
   ast->mem = mem;
-  dyn_array_create_inplace_mem(&ast->properties, ast->mem);
+  paw_da_make_inplace_mem(&ast->properties, ast->mem);
-  dyn_array_create_inplace_mem(&ast->methods, ast->mem);
+  paw_da_make_inplace_mem(&ast->methods, ast->mem);
 
   return ast;
 }
 
 void ast_register_method(struct PawAST *ast, char *name, enum PawCtrl *body) {
-  dyn_array_append(&ast->methods,
+  paw_da_append(&ast->methods,
-                   ((struct PawMethod){.body = body, .name = name}));
+                ((struct PawMethod){.body = body, .name = name}));
 }
 
 enum PawVal *ast_get_property(struct PawAST *ast, char *name) {
@@ -417,12 +417,12 @@ enum PawVal *ast_get_property(struct PawAST *ast, char *name) {
 }
 
 void ast_insert_property(struct PawAST *ast, char *name, enum PawVal *val) {
-  dyn_array_append(&ast->properties, ((struct PawProperty){name, val}));
+  paw_da_append(&ast->properties, ((struct PawProperty){name, val}));
 }
 
-struct Stack *stack_make(struct Mem *mem, size_t size) {
+struct Stack *stack_make(struct PawMem *mem, size_t size) {
-  struct Stack *stack = mem_malloc(mem, sizeof(struct Stack));
+  struct Stack *stack = paw_memmalloc(mem, sizeof(struct Stack));
-  stack->left = mem_malloc(mem, size);
+  stack->left = paw_memmalloc(mem, size);
   stack->right = stack->left + size;
   stack->top = stack->right;
   return stack;
@@ -452,9 +452,9 @@ void stack_set2(struct Stack *stack, void *v) {
   *n = v;
 }
 
-void stack_free(struct Stack *stack, struct Mem *mem) {
+void stack_free(struct Stack *stack, struct PawMem *mem) {
-  mem_free(mem, stack->left);
+  paw_memfree(mem, stack->left);
-  mem_free(mem, stack);
+  paw_memfree(mem, stack);
 }
 
 void print(struct VStack *stack, int offset) {
@@ -468,7 +468,7 @@ void print(struct VStack *stack, int offset) {
     meow("%i", val.i);
     break;
   case PAW_VAL_BOOL:
-    meow("%s", bool_to_string(val.b));
+    meow("%s", paw_b_to_s(val.b));
     break;
   case PAW_VAL_CHAR:
     meow("%c", val.c);
@@ -573,7 +573,7 @@ void unwind_stack(struct Stack *stack) {
   crash("unwound stack, exiting");
 }
 
-void ast_call(struct PawAST *ast, char *method, struct Scene *scene) {
+void ast_call(struct PawAST *ast, char *method, struct PawScene *scene) {
   enum PawCtrl *entry;
   for (int i = 0; i < ast->methods.count; i++) {
     if (strcmp(ast->methods.items[i].name, method) == 0) {

src/lang/ast.h

@@ -5,9 +5,9 @@
 #include <stdint.h>
 #include <stdlib.h>
 
-#include "../allocator.h"
+#include "../paw_allocator.h"
-#include "../dynarray.h"
+#include "../paw_da.h"
-#include "../object.h"
+#include "../paw_object.h"
 
 #define paw_p void *
 #define paw_sp int
@@ -67,20 +67,19 @@ enum PawCtrl {
   PAW_CTRL_CALL,
   PAW_CTRL_CCALL,
 };
-dyn_array_define(da_paw_ctrl, enum PawCtrl *);
+paw_da_define(da_paw_ctrl, enum PawCtrl *);
-dyn_array_define(da_paw_val, enum PawVal *);
+paw_da_define(da_paw_val, enum PawVal *);
 
 struct PawProperty {
   char *name;
   enum PawVal *val;
 };
 
-dyn_array_define(da_paw_property, struct PawProperty);
+paw_da_define(da_paw_property, struct PawProperty);
-
+paw_da_define(da_method, struct PawMethod);
-dyn_array_define(da_method, struct PawMethod);
 
 struct PawAST {
-  struct Mem *mem;
+  struct PawMem *mem;
   struct da_paw_property properties;
   struct da_method methods;
 };
@@ -146,7 +145,7 @@ struct PawCCall {
 };
 
 struct VStack {
-  struct Scene *scene;
+  struct PawScene *scene;
   void *left;
   void *right;
   void *top;
@@ -154,8 +153,8 @@ struct VStack {
 
 void print(struct VStack *stack, int offset);
 
-struct VStack *vstack_make(struct Mem *mem, size_t size);
+struct VStack *vstack_make(struct PawMem *mem, size_t size);
-void vstack_free(struct VStack *stack, struct Mem *mem);
+void vstack_free(struct VStack *stack, struct PawMem *mem);
 void vstack_pop(struct VStack *stack);
 void vstack_push(struct VStack *stack, struct PawStackVal val);
 struct PawStackVal vstack_poke(struct VStack *stack);
@@ -175,47 +174,47 @@ struct PawStackVal op_equals(struct PawStackVal lhs, struct PawStackVal rhs);
 struct PawStackVal op_unequals(struct PawStackVal lhs, struct PawStackVal rhs);
 struct PawStackVal op_add(struct PawStackVal lhs, struct PawStackVal rhs);
 
-enum PawVal *make_pawval_float(struct Mem *mem, float n);
+enum PawVal *make_pawval_float(struct PawMem *mem, float n);
-enum PawVal *make_pawval_int(struct Mem *mem, int n);
+enum PawVal *make_pawval_int(struct PawMem *mem, int n);
-enum PawVal *make_pawval_bool(struct Mem *mem, bool n);
+enum PawVal *make_pawval_bool(struct PawMem *mem, bool n);
-enum PawVal *make_pawval_point(struct Mem *mem, paw_p n);
+enum PawVal *make_pawval_point(struct PawMem *mem, paw_p n);
-enum PawVal *make_pawval_spoint(struct Mem *mem, int n);
+enum PawVal *make_pawval_spoint(struct PawMem *mem, int n);
-enum PawVal *make_pawval_expr(struct Mem *mem, enum PawVal *lhs,
+enum PawVal *make_pawval_expr(struct PawMem *mem, enum PawVal *lhs,
                               enum PawVal *rhs, uint32_t op);
-void free_pawval(struct Mem *mem, enum PawVal *val);
+void free_pawval(struct PawMem *mem, enum PawVal *val);
-enum PawCtrl *make_pawctrl_seq(struct Mem *mem);
+enum PawCtrl *make_pawctrl_seq(struct PawMem *mem);
-enum PawCtrl *make_pawctrl_spush(struct Mem *mem, struct PawStackVal val);
+enum PawCtrl *make_pawctrl_spush(struct PawMem *mem, struct PawStackVal val);
-enum PawCtrl *make_pawctrl_spop(struct Mem *mem);
+enum PawCtrl *make_pawctrl_spop(struct PawMem *mem);
-enum PawCtrl *make_pawctrl_call(struct Mem *mem, enum PawCtrl *body);
+enum PawCtrl *make_pawctrl_call(struct PawMem *mem, enum PawCtrl *body);
-enum PawCtrl *make_pawctrl_ccall(struct Mem *mem, int index);
+enum PawCtrl *make_pawctrl_ccall(struct PawMem *mem, int index);
-enum PawCtrl *make_pawctrl_loop(struct Mem *mem, enum PawCtrl *body);
+enum PawCtrl *make_pawctrl_loop(struct PawMem *mem, enum PawCtrl *body);
-enum PawCtrl *make_pawctrl_break(struct Mem *mem);
+enum PawCtrl *make_pawctrl_break(struct PawMem *mem);
-enum PawCtrl *make_pawctrl_if(struct Mem *mem, enum PawVal *cond,
+enum PawCtrl *make_pawctrl_if(struct PawMem *mem, enum PawVal *cond,
                               enum PawCtrl *truthy, enum PawCtrl *falsy);
-enum PawCtrl *make_pawctrl_asign(struct Mem *mem, struct PawStackVal target,
+enum PawCtrl *make_pawctrl_asign(struct PawMem *mem, struct PawStackVal target,
                                  enum PawVal *val);
 void pawseq_append(enum PawCtrl *seq, enum PawCtrl *ctrl);
 void pawseq_insert(enum PawCtrl *seq, int index, enum PawCtrl *ctrl);
-enum PawVal *ast_stack_to_heap(struct Mem *mem, struct PawStackVal val);
+enum PawVal *ast_stack_to_heap(struct PawMem *mem, struct PawStackVal val);
 struct PawAST *ast_make();
 void ast_insert_property(struct PawAST *ast, char *name, enum PawVal *val);
 void ast_register_method(struct PawAST *ast, char *name, enum PawCtrl *body);
 void ast_append_cfunc(struct PawAST *ast,
                       void (*func)(struct VStack *stack, int offset));
 enum PawVal *ast_get_property(struct PawAST *ast, char *name);
-void ast_call(struct PawAST *ast, char *method, struct Scene *scene);
+void ast_call(struct PawAST *ast, char *method, struct PawScene *scene);
 
 #define val_get_data($val) ((void *)$val + sizeof(enum PawVal))
 #define val_make($ret, $type, $TYPE_ENUM)                                      \
   do {                                                                         \
-    $ret = mem_malloc(mem, sizeof(enum PawVal) + sizeof($type));               \
+    $ret = paw_memmalloc(mem, sizeof(enum PawVal) + sizeof($type));            \
     *$ret = $TYPE_ENUM;                                                        \
   } while (0)
 
 #define ctrl_get_data($ctrl) (void *)$ctrl + sizeof(enum PawCtrl)
 #define ctrl_make($ret, $type, $TYPE_ENUM)                                     \
   do {                                                                         \
-    $ret = mem_malloc(mem, sizeof(enum PawCtrl) + sizeof($type));              \
+    $ret = paw_memmalloc(mem, sizeof(enum PawCtrl) + sizeof($type));           \
     *$ret = $TYPE_ENUM;                                                        \
   } while (0)
 

src/lang/ast_disc.c

@@ -1,7 +1,7 @@
 #include "ast_disc.h"
 
 #include "../io.h"
-#include "../log.h"
+#include "../paw_log.h"
 #include "ast.h"
 
 #define AO1($p)                                                                \
@@ -23,10 +23,10 @@ bool apply_before = false;
 
 // for nyow ast and ast->mem will be garbled afterwards
 void ast_write(struct PawAST *ast, char *path) {
-  int size = ast->mem->mem_size + sizeof(struct Mem);
+  int size = ast->mem->mem_size + sizeof(struct PawMem);
   char *data = (char *)ast->mem;
   region_start = ast->mem;
-  region_end = ast->mem + ast->mem->mem_size + sizeof(struct Mem);
+  region_end = ast->mem + ast->mem->mem_size + sizeof(struct PawMem);
   offset = -(long)region_start;
   apply_before = false;
   AO2(ast->mem->alloc);
@@ -68,7 +68,7 @@ struct PawAST *ast_read(char *path) {
   char *data = (char *)read_binary_file(path, &size);
   offset = (long)data;
   region_end = (void *)(long)size;
-  struct Mem *mem = (struct Mem *)data;
+  struct PawMem *mem = (struct PawMem *)data;
 
   apply_before = true;
   for (int i = 0; i < MAX_ALLOCS; i++) {

src/lang/functable.c

@@ -1,4 +1,4 @@
-#include "../log.h"
+#include "../paw_log.h"
 #include "../util.h"
 #include "ast.h"
 #include "glue.h"

src/lang/glue.c

@@ -8,5 +8,5 @@ void pawlang_kitty_make(struct VStack *stack, int offset) {
 }
 
 void pawlang_kitty_free(struct VStack *stack, int offset) {
-  free_kitty(stack->scene->vk, vstack_poke_n(stack, offset).p);
+  kitty_free(stack->scene->vk, vstack_poke_n(stack, offset).p);
 }

src/lang/vstack.c

@@ -1,16 +1,16 @@
-#include "../log.h"
+#include "../paw_log.h"
 #include "ast.h"
 
-struct VStack *vstack_make(struct Mem *mem, size_t size) {
+struct VStack *vstack_make(struct PawMem *mem, size_t size) {
-  struct VStack *stack = mem_malloc(mem, sizeof(struct VStack));
+  struct VStack *stack = paw_memmalloc(mem, sizeof(struct VStack));
-  stack->left = mem_malloc(mem, size);
+  stack->left = paw_memmalloc(mem, size);
   stack->right = stack->left + size;
   stack->top = stack->right;
   return stack;
 }
-void vstack_free(struct VStack *stack, struct Mem *mem) {
+void vstack_free(struct VStack *stack, struct PawMem *mem) {
-  mem_free(mem, stack->left);
+  paw_memfree(mem, stack->left);
-  mem_free(mem, stack);
+  paw_memfree(mem, stack);
 }
 
 void vstack_pop(struct VStack *stack) {

src/object.h

@@ -1,45 +0,0 @@
-#ifndef INCLUDE_WAYLANDCLIENT_OBJECT_H_
-#define INCLUDE_WAYLANDCLIENT_OBJECT_H_
-
-#include "dynarray.h"
-// #include "vulkan_internal.h"
-
-dyn_array_define(da_Object, struct Object *);
-dyn_array_define(da_Named, struct Named);
-
-struct Scene {
-  struct Vk *vk;
-  struct Mem *mem;
-  struct da_Object objects;
-  struct da_Object insert_queue;
-  struct da_Named named;
-  struct Register *reg;
-
-  float delta_secs;
-  long avg_delta;
-  long sleep;
-  long target_delta;
-  long last_start_time;
-};
-
-struct Object {
-  struct Type *type;
-  void *data;
-};
-
-struct Named {
-  const char *id;
-  struct Object *object;
-};
-
-struct Scene *make_scene(struct Vk *vk, struct Register *reg);
-void free_scene(struct Scene *scene);
-void scene_tick(struct Scene *scene);
-void scene_queue_insert(struct Scene *scene, char *name, void *object_data);
-
-void scene_register_named(struct Scene *scene, const char *id,
-                          struct Object *object);
-void scene_unregister_named(struct Scene *scene, const char *id);
-struct Object *scene_get_named(struct Scene *scene, const char *id);
-
-#endif // INCLUDE_WAYLANDCLIENT_OBJECT_H_

src/paw_allocator.c

@@ -1,5 +1,5 @@
-#include "allocator.h"
+#include "paw_allocator.h"
-#include "log.h"
+#include "paw_log.h"
 
 #include <stddef.h>
 #include <stdint.h>
@@ -7,21 +7,27 @@
 #include <string.h>
 #include <sys/types.h>
 
-struct Mem *make_mem(size_t size) {
+struct PawMem *paw_memmake(size_t size) {
-  struct Mem *mem = malloc(sizeof(struct Mem) + size);
+  struct PawMem *mem = malloc(sizeof(struct PawMem) + size);
   mem->mem_size = size;
   mem->mem = mem + 1;
   memset(mem->mem, 0, mem->mem_size);
   mem->count = 0;
-  memset(&mem->allocs, 0, sizeof(struct Alloc) * MAX_ALLOCS);
+  memset(&mem->allocs, 0, sizeof(struct PawAlloc) * MAX_ALLOCS);
-  mem->allocs[0] = (struct Alloc){mem->mem + mem->mem_size, 0, NULL};
+  mem->allocs[0] = (struct PawAlloc){mem->mem + mem->mem_size, 0, NULL};
-  mem->allocs[1] = (struct Alloc){mem->mem, 0, &mem->allocs[0]};
+  mem->allocs[1] = (struct PawAlloc){mem->mem, 0, &mem->allocs[0]};
   mem->alloc = &mem->allocs[1];
   return mem;
 }
-void uninit_mem(struct Mem *mem) { free(mem); }
+void paw_memunmake(struct PawMem *mem) {
+  if (mem != NULL) {
+    free(mem);
+  } else {
+    meow("tried to free a null mem");
+  }
+}
 
-static struct Alloc *get_next_alloc(struct Mem *mem) {
+static struct PawAlloc *get_next_alloc(struct PawMem *mem) {
   while (mem->allocs[mem->count].start != NULL ||
          mem->allocs[mem->count].size != 0 ||
          mem->allocs[mem->count].next != NULL) {
@@ -33,31 +39,31 @@ static struct Alloc *get_next_alloc(struct Mem *mem) {
   return &mem->allocs[mem->count];
 }
 
-void *malloc_or_mem_malloc(struct Mem *mem, size_t size) {
+void *paw_malloc_memmalloc(struct PawMem *mem, size_t size) {
   if (mem == NULL) {
     return malloc(size);
   } else {
-    return mem_malloc(mem, size);
+    return paw_memmalloc(mem, size);
   }
 }
-void free_or_mem_free(struct Mem *mem, void *ptr) {
+void paw_free_memfree(struct PawMem *mem, void *ptr) {
   if (mem == NULL) {
     free(ptr);
   } else {
-    mem_free(mem, ptr);
+    paw_memfree(mem, ptr);
   }
 }
 
-void *mem_malloc(struct Mem *mem, size_t size) {
+void *paw_memmalloc(struct PawMem *mem, size_t size) {
   if (size <= 0) {
     size = 1;
   }
-  struct Alloc *prev = mem->alloc;
+  struct PawAlloc *prev = mem->alloc;
   while (prev->next != NULL) {
-    struct Alloc *next = prev->next;
+    struct PawAlloc *next = prev->next;
     if (next->start - (prev->start + prev->size) > size && next != prev) {
-      struct Alloc *new = get_next_alloc(mem);
+      struct PawAlloc *new = get_next_alloc(mem);
-      *new = (struct Alloc){
+      *new = (struct PawAlloc){
           prev->start + prev->size,
           size,
           next,
@@ -76,16 +82,16 @@ void *mem_malloc(struct Mem *mem, size_t size) {
   return NULL;
 }
 
-void mem_free(struct Mem *mem, void *p) {
+void paw_memfree(struct PawMem *mem, void *p) {
-  struct Alloc *current = mem->alloc;
+  struct PawAlloc *current = mem->alloc;
-  struct Alloc *prev = mem->alloc;
+  struct PawAlloc *prev = mem->alloc;
   while (current != NULL && (p > current->start || current->size <= 0)) {
     prev = current;
     current = current->next;
   }
   if (current == NULL || p != current->start) {
     meow("OOPSIE DAISY double free");
-    print_backtrace();
+    paw_print_backtrace();
     return;
   }
   prev->next = current->next;
@@ -95,5 +101,5 @@ void mem_free(struct Mem *mem, void *p) {
   }
   /*meow("FREE at %d : %p", index, current->start);
   print_backtrace(); */
-  memset(&mem->allocs[index], 0, sizeof(struct Alloc));
+  memset(&mem->allocs[index], 0, sizeof(struct PawAlloc));
 }

src/paw_allocator.h

@@ -0,0 +1,28 @@
+#ifndef INCLUDE_WAYLANDCLIENT_ALLOCATOR_H_
+#define INCLUDE_WAYLANDCLIENT_ALLOCATOR_H_
+
+#include "sys/types.h"
+
+#define MAX_ALLOCS 256
+struct PawAlloc {
+  void *start;
+  uint size;
+  struct PawAlloc *next;
+};
+struct PawMem {
+  void *mem;
+  size_t mem_size;
+  uint count;
+  struct PawAlloc *alloc;
+  struct PawAlloc allocs[MAX_ALLOCS];
+};
+
+struct PawMem *paw_memmake(size_t size);
+void paw_memunmake(struct PawMem *mem);
+
+void *paw_memmalloc(struct PawMem *mem, size_t size);
+void *paw_malloc_memmalloc(struct PawMem *mem, size_t size);
+void paw_memfree(struct PawMem *mem, void *p);
+void paw_free_memfree(struct PawMem *mem, void *ptr);
+
+#endif // INCLUDE_WAYLANDCLIENT_ALLOCATOR_H_

src/paw_da.c

@@ -1,4 +1,4 @@
-#include "allocator.h"
+#include "paw_da.h"
 
 #include <stdlib.h>
 
@@ -6,12 +6,12 @@ struct da_template {
   int count;
   int capacity;
   void *items;
-  struct Mem *mem;
+  struct PawMem *mem;
 };
 
 // the array struct has to be freed manually, all internal data is freedd by
 // dyn_array_destroy
-void *dyn_array_create() {
+void *paw_da_make() {
   struct da_template *da = malloc(sizeof(struct da_template));
   da->items = malloc(0);
   da->capacity = 0;
@@ -21,24 +21,24 @@ void *dyn_array_create() {
 }
 // the array struct has to be freed manually, all internal data is freedd by
 // dyn_array_destroy
-void *dyn_array_create_mem(struct Mem *mem) {
+void *paw_da_make_mem(struct PawMem *mem) {
-  struct da_template *da = mem_malloc(mem, sizeof(struct da_template));
+  struct da_template *da = paw_memmalloc(mem, sizeof(struct da_template));
-  da->items = mem_malloc(mem, 0);
+  da->items = paw_memmalloc(mem, 0);
   da->capacity = 0;
   da->count = 0;
   da->mem = mem;
   return da;
 }
-void dyn_array_create_inplace(void *array) {
+void paw_da_make_inplace(void *array) {
   struct da_template *da = array;
   da->items = malloc(0);
   da->count = 0;
   da->capacity = 0;
   da->mem = NULL;
 }
-void dyn_array_create_inplace_mem(void *array, struct Mem *mem) {
+void paw_da_make_inplace_mem(void *array, struct PawMem *mem) {
   struct da_template *da = array;
-  da->items = mem_malloc(mem, 0);
+  da->items = paw_memmalloc(mem, 0);
   da->count = 0;
   da->capacity = 0;
   da->mem = mem;

src/paw_da.h

@@ -1,13 +1,13 @@
 #ifndef INCLUDE_WAYLANDCLIENT_DYNARRAY_H_
 #define INCLUDE_WAYLANDCLIENT_DYNARRAY_H_
 
-#include "allocator.h"
+#include "paw_allocator.h"
 
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 
-#define dyn_array_append(array, item)                                          \
+#define paw_da_append(array, item)                                             \
   do {                                                                         \
     if ((array)->count >= (array)->capacity) {                                 \
       (array)->capacity += 10;                                                 \
@@ -16,39 +16,39 @@
                                  (array)->capacity * sizeof(*(array)->items)); \
       } else {                                                                 \
         void *temp = (array)->items;                                           \
-        (array)->items = mem_malloc(                                           \
+        (array)->items = paw_memmalloc(                                        \
             (array)->mem, (array)->capacity * sizeof(*(array)->items));        \
         memcpy((array)->items, temp,                                           \
                ((array)->count) * sizeof(*(array)->items));                    \
-        mem_free((array)->mem, temp);                                          \
+        paw_memfree((array)->mem, temp);                                       \
       }                                                                        \
     }                                                                          \
     (array)->items[(array)->count++] = (item);                                 \
   } while (0)
 
-#define dyn_array_insert(array, index, item)                                   \
+#define paw_da_insert(array, index, item)                                      \
   do {                                                                         \
-    dyn_array_append(array, item);                                             \
+    paw_da_append(array, item);                                                \
     memcpy(&(array)->items[(index) + 1], &(array)->items[(index)],             \
            sizeof(*(array)->items) * ((array)->count - index));                \
     (array)->items[(index)] = (item);                                          \
   } while (0)
 
-#define dyn_array_remove(array, index)                                         \
+#define paw_da_remove(array, index)                                            \
   do {                                                                         \
     (array)->items[(index)] = (array)->items[(array)->count - 1];              \
     memset(&(array)->items[(array)->count], 0, sizeof((array)->items[0]));     \
     (array)->count--;                                                          \
   } while (0)
 
-#define dyn_array_destroy(array)                                               \
+#define paw_da_free(array)                                                     \
   if ((array)->mem == NULL) {                                                  \
     free((array)->items);                                                      \
   } else {                                                                     \
-    mem_free((array)->mem, (array)->items);                                    \
+    paw_memfree((array)->mem, (array)->items);                                 \
   }
 
-#define dyn_array_reset(array)                                                 \
+#define paw_da_reset(array)                                                    \
   do {                                                                         \
     (array)->capacity = 10;                                                    \
     (array)->count = 0;                                                        \
@@ -56,26 +56,26 @@
       (array)->items = realloc((array)->items,                                 \
                                (array)->capacity * sizeof(*(array)->items));   \
     } else {                                                                   \
-      mem_free((array)->mem, (array)->items);                                  \
+      paw_memfree((array)->mem, (array)->items);                               \
-      (array)->items = mem_malloc((array)->mem, (array)->capacity *            \
+      (array)->items = paw_memmalloc(                                          \
-                                                    sizeof(*(array)->items));  \
+          (array)->mem, (array)->capacity * sizeof(*(array)->items));          \
     }                                                                          \
   } while (0)
 
-#define dyn_array_define($name, $type)                                         \
+#define paw_da_define($name, $type)                                            \
   struct $name {                                                               \
     int count;                                                                 \
     int capacity;                                                              \
     $type *items;                                                              \
-    struct Mem *mem;                                                           \
+    struct PawMem *mem;                                                        \
   }
 
-dyn_array_define(da_uint32_t, uint32_t);
+paw_da_define(da_uint32_t, uint32_t);
-dyn_array_define(da_string, char *);
+paw_da_define(da_string, char *);
 
-void *dyn_array_create();
+void *paw_da_make();
-void *dyn_array_create_mem(struct Mem *mem);
+void *paw_da_make_mem(struct PawMem *mem);
-void dyn_array_create_inplace(void *array);
+void paw_da_make_inplace(void *array);
-void dyn_array_create_inplace_mem(void *array, struct Mem *mem);
+void paw_da_make_inplace_mem(void *array, struct PawMem *mem);
 
 #endif // INCLUDE_WAYLANDCLIENT_DYNARRAY_H_

src/paw_log.c

@@ -1,4 +1,4 @@
-#include "log.h"
+#include "paw_log.h"
 
 #include <errno.h>
 #include <execinfo.h>
@@ -17,7 +17,7 @@ static void full_write(int fd, const char *buf, size_t len) {
   }
 }
 
-void print_backtrace() {
+void paw_print_backtrace() {
   static const char start[] = "BACKTRACE ------------\n";
   static const char end[] = "----------------------\n";
 
@@ -38,7 +38,7 @@ void print_backtrace() {
   free(bt_syms);
 }
 
-char *bool_to_string(bool b) {
+const char *paw_b_to_s(bool b) {
   if (b) {
     return "true";
   } else {

src/paw_log.h

@@ -11,7 +11,7 @@
   fprintf(stderr, "[%s:%d] " fmt "\n", __FILE__, __LINE__, ##__VA_ARGS__);     \
   *(int *)0 = 0;
 
-void print_backtrace();
+void paw_print_backtrace();
-char *bool_to_string(bool b);
+const char *paw_b_to_s(bool b);
 
 #endif // INCLUDE_WAYLANDCLIENT_LOG_H_

src/paw_object.c

@@ -1,7 +1,6 @@
-#include "object.h"
+#include "paw_object.h"
-#include "allocator.h"
+#include "paw_allocator.h"
-#include "dynarray.h"
+#include "paw_log.h"
-#include "log.h"
 #include "register.h"
 
 #include <stdlib.h>
@@ -10,20 +9,20 @@
 
 #define DT_TARGET 0.016
 
-struct Scene *make_scene(struct Vk *vk, struct Register *reg) {
+struct PawScene *paw_scene_make(struct Vk *vk, struct Register *reg) {
-  struct Scene *scene = malloc(sizeof(struct Scene));
+  struct PawScene *scene = malloc(sizeof(struct PawScene));
-  memset(scene, 0, sizeof(struct Scene));
+  memset(scene, 0, sizeof(struct PawScene));
   scene->vk = vk;
-  scene->mem = make_mem(100000);
+  scene->mem = paw_memmake(100000);
   if (reg == NULL) {
     scene->reg = make_register();
   } else {
     scene->reg = reg;
   }
 
-  dyn_array_create_inplace_mem(&scene->objects, scene->mem);
+  paw_da_make_inplace_mem(&scene->objects, scene->mem);
-  dyn_array_create_inplace_mem(&scene->insert_queue, scene->mem);
+  paw_da_make_inplace_mem(&scene->insert_queue, scene->mem);
-  dyn_array_create_inplace_mem(&scene->named, scene->mem);
+  paw_da_make_inplace_mem(&scene->named, scene->mem);
 
   struct timespec time;
   clock_gettime(CLOCK_MONOTONIC, &time);
@@ -35,26 +34,26 @@ struct Scene *make_scene(struct Vk *vk, struct Register *reg) {
   return scene;
 }
 
-void free_scene(struct Scene *scene) {
+void paw_scene_free(struct PawScene *scene) {
   for (int i = 0; i < scene->objects.count; i++) {
     scene->objects.items[i]->type->free(scene, scene->objects.items[i]->data);
-    mem_free(scene->mem, scene->objects.items[i]);
+    paw_memfree(scene->mem, scene->objects.items[i]);
   }
-  dyn_array_destroy(&scene->objects);
+  paw_da_free(&scene->objects);
   for (int i = 0; i < scene->insert_queue.count; i++) {
     scene->insert_queue.items[i]->type->free(
         scene, scene->insert_queue.items[i]->data);
-    mem_free(scene->mem, scene->insert_queue.items[i]);
+    paw_memfree(scene->mem, scene->insert_queue.items[i]);
   }
-  dyn_array_destroy(&scene->insert_queue);
+  paw_da_free(&scene->insert_queue);
-  dyn_array_destroy(&scene->named);
+  paw_da_free(&scene->named);
-  uninit_mem(scene->mem);
+  paw_memunmake(scene->mem);
 
-  memset(scene, 0, sizeof(struct Scene));
+  memset(scene, 0, sizeof(struct PawScene));
   free(scene);
 }
 
-void scene_tick(struct Scene *scene) {
+void paw_scene_tick(struct PawScene *scene) {
   struct timespec time;
   clock_gettime(CLOCK_MONOTONIC, &time);
   long msecs_start = time.tv_sec * 1000000 + time.tv_nsec / 1000;
@@ -65,7 +64,7 @@ void scene_tick(struct Scene *scene) {
 
   if (scene->insert_queue.count > 0) {
     for (int i = 0; i < scene->insert_queue.count; i++) {
-      dyn_array_append(&scene->objects, scene->insert_queue.items[i]);
+      paw_da_append(&scene->objects, scene->insert_queue.items[i]);
     }
     scene->insert_queue.count = 0;
   }
@@ -74,7 +73,7 @@ void scene_tick(struct Scene *scene) {
   }
   if (scene->insert_queue.count > 0) {
     for (int i = 0; i < scene->insert_queue.count; i++) {
-      dyn_array_append(&scene->objects, scene->insert_queue.items[i]);
+      paw_da_append(&scene->objects, scene->insert_queue.items[i]);
     }
     scene->insert_queue.count = 0;
   }
@@ -91,38 +90,41 @@ void scene_tick(struct Scene *scene) {
   scene->last_start_time = msecs_start;
 }
 
-void scene_queue_insert(struct Scene *scene, char *name, void *object_data) {
+void paw_scene_queue_insert(struct PawScene *scene, char *name,
+                            void *object_data) {
   struct Type *type = reg_get_type(scene->reg, name);
-  struct Object *object = mem_malloc(scene->mem, sizeof(struct Object));
+  struct PawObject *object =
+      paw_memmalloc(scene->mem, sizeof(struct PawObject));
   object->type = type;
   object->data = object_data;
-  dyn_array_append(&scene->insert_queue, object);
+  paw_da_append(&scene->insert_queue, object);
 }
-void scene_queue_insert_from_data(struct Scene *scene, char *name, char *data,
+void paw_scene_queue_insert_from_data(struct PawScene *scene, char *name,
-                                  int len) {
+                                      char *data, int len) {
   struct Type *type = reg_get_type(scene->reg, name);
-  struct Object *object = mem_malloc(scene->mem, sizeof(struct Object));
+  struct PawObject *object =
+      paw_memmalloc(scene->mem, sizeof(struct PawObject));
   object->type = type;
   object->data = type->make(scene, data, len);
-  dyn_array_append(&scene->insert_queue, object);
+  paw_da_append(&scene->insert_queue, object);
 }
 
-void scene_register_named(struct Scene *scene, const char *id,
+void paw_scene_reg_named(struct PawScene *scene, const char *id,
-                          struct Object *object) {
+                         struct PawObject *object) {
-  dyn_array_append(&scene->named, ((struct Named){id, object}));
+  paw_da_append(&scene->named, ((struct PawNamed){id, object}));
 }
 
-void scene_unregister_named(struct Scene *scene, const char *id) {
+void paw_scene_unreg_named(struct PawScene *scene, const char *id) {
   for (int i = 0; i < scene->named.count; i++) {
     if (strcmp(scene->named.items[i].id, id) == 0) {
-      dyn_array_remove(&scene->named, i);
+      paw_da_remove(&scene->named, i);
       return;
     }
   }
   meow("object with name %s was not found", id);
 }
 
-struct Object *scene_get_named(struct Scene *scene, const char *id) {
+struct PawObject *paw_scene_get_named(struct PawScene *scene, const char *id) {
   for (int i = 0; i < scene->named.count; i++) {
     if (strcmp(scene->named.items[i].id, id) == 0) {
       return scene->named.items[i].object;

src/paw_object.h

@@ -0,0 +1,46 @@
+#ifndef INCLUDE_WAYLANDCLIENT_OBJECT_H_
+#define INCLUDE_WAYLANDCLIENT_OBJECT_H_
+
+#include "paw_da.h"
+// #include "vulkan_internal.h"
+
+paw_da_define(da_Object, struct PawObject *);
+paw_da_define(da_Named, struct PawNamed);
+
+struct PawScene {
+  struct Vk *vk;
+  struct PawMem *mem;
+  struct da_Object objects;
+  struct da_Object insert_queue;
+  struct da_Named named;
+  struct Register *reg;
+
+  float delta_secs;
+  long avg_delta;
+  long sleep;
+  long target_delta;
+  long last_start_time;
+};
+
+struct PawObject {
+  struct Type *type;
+  void *data;
+};
+
+struct PawNamed {
+  const char *id;
+  struct PawObject *object;
+};
+
+struct PawScene *paw_scene_make(struct Vk *vk, struct Register *reg);
+void paw_scene_free(struct PawScene *scene);
+void paw_scene_tick(struct PawScene *scene);
+void paw_scene_queue_insert(struct PawScene *scene, char *name,
+                            void *object_data);
+
+void paw_scene_reg_named(struct PawScene *scene, const char *id,
+                         struct PawObject *object);
+void paw_scene_unreg_named(struct PawScene *scene, const char *id);
+struct PawObject *paw_scene_get_named(struct PawScene *scene, const char *id);
+
+#endif // INCLUDE_WAYLANDCLIENT_OBJECT_H_

src/register.c

@@ -1,28 +1,27 @@
 #include "register.h"
-#include "dynarray.h"
+#include "paw_log.h"
-#include "log.h"
+#include "paw_object.h"
-#include "object.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 struct Register *make_register() {
   struct Register *reg = malloc(sizeof(struct Register));
-  dyn_array_create_inplace(&reg->reg);
+  paw_da_make_inplace(&reg->reg);
   return reg;
 }
 
 void free_register(struct Register *reg) {
-  dyn_array_destroy(&reg->reg);
+  paw_da_free(&reg->reg);
   free(reg);
 }
 
 void reg_attatch_type(struct Register *reg, char *name,
-                      void *(*make)(struct Scene *, char *, int len),
+                      void *(*make)(struct PawScene *, char *, int len),
-                      void (*free)(struct Scene *, void *),
+                      void (*free)(struct PawScene *, void *),
-                      void (*tick)(struct Scene *, void *)) {
+                      void (*tick)(struct PawScene *, void *)) {
   struct Type type = {name, make, free, tick};
-  dyn_array_append(&reg->reg, type);
+  paw_da_append(&reg->reg, type);
 }
 
 struct Type *reg_get_type(struct Register *reg, char *name) {

src/register.h

@@ -1,33 +1,32 @@
 #ifndef INCLUDE_WAYLANDCLIENT_REGISTER_H_
 #define INCLUDE_WAYLANDCLIENT_REGISTER_H_
 
-#include "dynarray.h"
+#include "paw_object.h"
-#include "object.h"
 
-dyn_array_define(da_Type, struct Type);
+paw_da_define(da_Type, struct Type);
 
 struct Type {
   char *name;
 
-  void *(*make)(struct Scene *, char *, int len);
+  void *(*make)(struct PawScene *, char *, int len);
-  void (*free)(struct Scene *, void *);
+  void (*free)(struct PawScene *, void *);
-  void (*tick)(struct Scene *, void *);
+  void (*tick)(struct PawScene *, void *);
 };
 
 struct Register {
   struct da_Type reg;
 };
 
-#define OBJ_FREE (void (*)(struct Scene *, void *))
+#define OBJ_FREE (void (*)(struct PawScene *, void *))
-#define OBJ_TICK (void (*)(struct Scene *, void *))
+#define OBJ_TICK (void (*)(struct PawScene *, void *))
-#define OBJ_MAKE (void *(*)(struct Scene *, char *, int len))
+#define OBJ_MAKE (void *(*)(struct PawScene *, char *, int len))
 
 struct Register *make_register();
 void free_register(struct Register *reg);
 struct Type *reg_get_type(struct Register *reg, char *name);
 void reg_attatch_type(struct Register *reg, char *name,
-                      void *(*make)(struct Scene *, char *, int len),
+                      void *(*make)(struct PawScene *, char *, int len),
-                      void (*free)(struct Scene *, void *),
+                      void (*free)(struct PawScene *, void *),
-                      void (*tick)(struct Scene *, void *));
+                      void (*tick)(struct PawScene *, void *));
 
 #endif // INCLUDE_WAYLANDCLIENT_REGISTER_H_

src/string.c

@@ -1,31 +1,31 @@
 #include "string.h"
-#include "allocator.h"
+#include "paw_allocator.h"
-#include "log.h"
+#include "paw_log.h"
 #include "util.h"
 
 #include <stdarg.h>
 #include <stdio.h>
 #include <string.h>
 
-struct da_string split(struct Mem *mem, char *string, char needle) {
+struct da_string split(struct PawMem *mem, char *string, char needle) {
   struct da_string items;
-  dyn_array_create_inplace_mem(&items, mem);
+  paw_da_make_inplace_mem(&items, mem);
 
   int last = 0;
   for (int i = 0; i < strlen(string); i++) {
     meow("got match!");
     if (string[i] == needle) {
-      char *tmp = mem_malloc(mem, i - last + 1);
+      char *tmp = paw_memmalloc(mem, i - last + 1);
       memcpy(tmp, &string[last], i - last);
       tmp[i - last + 1] = 0x0;
-      dyn_array_append(&items, tmp);
+      paw_da_append(&items, tmp);
       last = i;
     }
   }
-  char *tmp = mem_malloc(mem, strlen(string) - last + 1);
+  char *tmp = paw_memmalloc(mem, strlen(string) - last + 1);
   memcpy(tmp, &string[last], strlen(string) - last);
   tmp[strlen(string) - last + 1] = 0x0;
-  dyn_array_append(&items, tmp);
+  paw_da_append(&items, tmp);
 
   return items;
 }
@@ -34,7 +34,7 @@ bool start_matches(char *string, char *match) {
   return memcmp(string, match, strlen(match)) == 0;
 }
 
-char *extract_brackets(struct Mem *mem, char *start, char open, char close) {
+char *extract_brackets(struct PawMem *mem, char *start, char open, char close) {
   char *end = skip_brackets(start, open, close);
   // { ... }
   //        ^ end
@@ -47,7 +47,7 @@ char *extract_brackets(struct Mem *mem, char *start, char open, char close) {
   //       { ... }
   //  start ^   ^ end
   start++;
-  char *res = mem_malloc(mem, end - start + 1);
+  char *res = paw_memmalloc(mem, end - start + 1);
   memcpy(res, start, end - start);
   res[end - start] = 0x0;
 
@@ -90,14 +90,14 @@ int index_of_char(char *string, char key) {
   }
 }
 
-char *extract(struct Mem *mem, char *string, int start, int size) {
+char *extract(struct PawMem *mem, char *string, int start, int size) {
-  char *new = mem_malloc(mem, size + 1);
+  char *new = paw_memmalloc(mem, size + 1);
   memcpy(new, string + start, size);
   new[size + 1] = 0x0;
   return new;
 }
 
-char *extract_inbetween_chars(struct Mem *mem, char *string, char one,
+char *extract_inbetween_chars(struct PawMem *mem, char *string, char one,
                               char two) {
   int start = index_of_char(string, one) + 1;
   int end = index_of_char(string, two);
@@ -108,13 +108,13 @@ char *extract_inbetween_chars(struct Mem *mem, char *string, char one,
   return extract(mem, string, start, end - start);
 }
 
-char *tmp_format(struct Mem *mem, char *format, ...) {
+char *tmp_format(struct PawMem *mem, char *format, ...) {
   char *res = malloc(1024);
   va_list ap;
   va_start(ap, NULL);
   vsprintf(res, format, ap);
 
-  char *new = mem_malloc(mem, (strlen(res) + 1) * sizeof(char));
+  char *new = paw_memmalloc(mem, (strlen(res) + 1) * sizeof(char));
   memcpy(new, res, (strlen(res) + 1) * sizeof(char));
 
   free(res);
@@ -165,15 +165,15 @@ bool includes_between(char *start, char *end, char n) {
   }
 }
 
-char *mem_strdup(char *string, struct Mem *mem) {
+char *mem_strdup(char *string, struct PawMem *mem) {
-  char *new = mem_malloc(mem, (strlen(string) + 1) * sizeof(char));
+  char *new = paw_memmalloc(mem, (strlen(string) + 1) * sizeof(char));
   memcpy(new, string, (strlen(string) + 1) * sizeof(char));
   return new;
 }
 
 // inclusive!!!
-char *mem_strdup_reg(char *start, char *end, struct Mem *mem) {
+char *mem_strdup_reg(char *start, char *end, struct PawMem *mem) {
-  char *new = mem_malloc(mem, end - start + 2);
+  char *new = paw_memmalloc(mem, end - start + 2);
   memcpy(new, start, end - start + 1);
   new[end - start + 2] = 0x0;
   return new;

src/string.h

@@ -1,27 +1,27 @@
 #ifndef INCLUDE_SRC_STRING_H_
 #define INCLUDE_SRC_STRING_H_
 
-#include "allocator.h"
+#include "paw_allocator.h"
-#include "dynarray.h"
+#include "paw_da.h"
 
 #include <stdbool.h>
 
-struct da_string split(struct Mem *mem, char *string, char needle);
+struct da_string split(struct PawMem *mem, char *string, char needle);
 bool start_matches(char *string, char *match);
-char *extract_brackets(struct Mem *mem, char *start, char open, char close);
+char *extract_brackets(struct PawMem *mem, char *start, char open, char close);
 char *skip_brackets(char *start, char open, char close);
 int index_of_char(char *string, char key);
-char *extract(struct Mem *mem, char *string, int start, int size);
+char *extract(struct PawMem *mem, char *string, int start, int size);
-char *extract_inbetween_chars(struct Mem *mem, char *string, char one,
+char *extract_inbetween_chars(struct PawMem *mem, char *string, char one,
                               char two);
-char *tmp_format(struct Mem *mem, char *format, ...);
+char *tmp_format(struct PawMem *mem, char *format, ...);
 char *trim_start(char *string);
 char *trim_end(char *string);
 bool is_digid(char n);
 bool is_char(char n);
 bool includes_between(char *start, char *end, char n);
-char *mem_strdup(char *string, struct Mem *mem);
+char *mem_strdup(char *string, struct PawMem *mem);
-char *mem_strdup_reg(char *start, char *end, struct Mem *mem);
+char *mem_strdup_reg(char *start, char *end, struct PawMem *mem);
 char *strdup_reg(char *start, char *end);
 char *skip_to_char(char *string, char n);
 char *skip_after_char(char *string, char n);

src/util.c

@@ -1,8 +1,10 @@
-#include "allocator.h"
+#include "paw_allocator.h"
-#include "dynarray.h"
+#include "paw_da.h"
 #include <stdbool.h>
 #include <stdlib.h>
 
+#include "util.h"
+
 float randf() { return (float)rand() / (float)RAND_MAX; }
 
 struct ST_key {
@@ -10,29 +12,29 @@ struct ST_key {
   void *value;
 };
 
-dyn_array_define(da_ST_key, struct ST_key);
+paw_da_define(da_ST_key, struct ST_key);
 
 struct StringTable {
   struct da_ST_key keys;
 };
 
-struct StringTable *st_make(struct Mem *mem) {
+struct StringTable *st_make(struct PawMem *mem) {
   struct StringTable *st =
-      malloc_or_mem_malloc(mem, sizeof(struct StringTable));
+      paw_malloc_memmalloc(mem, sizeof(struct StringTable));
   if (mem == NULL) {
-    dyn_array_create_inplace(&st->keys);
+    paw_da_make_inplace(&st->keys);
   } else {
-    dyn_array_create_inplace_mem(&st->keys, mem);
+    paw_da_make_inplace_mem(&st->keys, mem);
   }
   return st;
 }
 struct StringTable *st_dup(struct StringTable *st) {
   struct StringTable *new =
-      malloc_or_mem_malloc(st->keys.mem, sizeof(struct StringTable));
+      paw_malloc_memmalloc(st->keys.mem, sizeof(struct StringTable));
   new->keys.mem = st->keys.mem;
   new->keys.count = st->keys.count;
   new->keys.capacity = st->keys.capacity;
-  new->keys.items = malloc_or_mem_malloc(new->keys.mem, sizeof(struct ST_key) *
+  new->keys.items = paw_malloc_memmalloc(new->keys.mem, sizeof(struct ST_key) *
                                                             new->keys.capacity);
   memcpy(new->keys.items, st->keys.items,
          st->keys.capacity * sizeof(struct ST_key));
@@ -40,7 +42,7 @@ struct StringTable *st_dup(struct StringTable *st) {
   return new;
 }
 void st_insert(struct StringTable *st, char *key, void *value) {
-  dyn_array_append(&st->keys, ((struct ST_key){.key = key, .value = value}));
+  paw_da_append(&st->keys, ((struct ST_key){.key = key, .value = value}));
 }
 bool st_has_key(struct StringTable *st, char *key) {
   for (int i = 0; i < st->keys.count; i++) {
@@ -79,18 +81,13 @@ int st_get_index(struct StringTable *st, char *key) {
 void st_remove(struct StringTable *st, char *key) {
   for (int i = 0; i < st->keys.count; i++) {
     if (strcmp(st->keys.items[i].key, key) == 0) {
-      dyn_array_remove(&st->keys, i);
+      paw_da_remove(&st->keys, i);
     }
   }
 }
 void st_unmake(struct StringTable *st) {
-  if (st->keys.mem == NULL) {
+  paw_da_free(&st->keys);
-    dyn_array_destroy(&st->keys);
+  paw_free_memfree(st->keys.mem, st);
-    free(st);
-  } else {
-    dyn_array_destroy(&st->keys);
-    mem_free(st->keys.mem, st);
-  }
 }
 int st_get_size(struct StringTable *st) { return st->keys.count; }
 char *st_get_nth_key(struct StringTable *st, int index) {

src/util.h

@@ -3,7 +3,7 @@
 
 #define UINT32_NULL 42424242
 
-#include "allocator.h"
+#include "paw_allocator.h"
 
 float randf();
 
@@ -16,7 +16,7 @@ float randf();
   } while (0)
 
 struct StringTable;
-struct StringTable *st_make(struct Mem *mem);
+struct StringTable *st_make(struct PawMem *mem);
 struct StringTable *st_dup(struct StringTable *st);
 void st_insert(struct StringTable *st, char *key, void *value);
 bool st_has_key(struct StringTable *st, char *key);

src/vulkan.c

@@ -1,6 +1,5 @@
 #include "vulkan.h"
 #include "kitty.h"
-#include "log.h"
 #include "types.h"
 
 #include "image.h"
@@ -62,7 +61,7 @@ handle_vulkan_error(VkDebugUtilsMessageSeverityFlagBitsEXT severity,
   }
   printf("%s\n", callbackData->pMessage);
   if (backtrace) {
-    print_backtrace();
+    paw_print_backtrace();
   }
   return 0;
 }
@@ -737,7 +736,7 @@ struct Vk *init_vk(void *data, int width, int heigh,
   setup_command_buffers(state);
   setup_sync_objects(state);
 
-  dyn_array_create_inplace(&state->kitties);
+  paw_da_make_inplace(&state->kitties);
 
   return state;
 }
@@ -745,7 +744,7 @@ struct Vk *init_vk(void *data, int width, int heigh,
 void uninit_vk(struct Vk *state) {
   CHECK_VK_RESULT(vkDeviceWaitIdle(state->device));
 
-  dyn_array_destroy(&state->kitties);
+  paw_da_free(&state->kitties);
 
   destroy_swapchain(state);
 

src/vulkan.h

@@ -4,8 +4,8 @@
 #include <stdbool.h>
 #include <vulkan/vulkan.h>
 
-#include "dynarray.h"
+#include "paw_da.h"
-#include "log.h"
+#include "paw_log.h"
 #include "types.h"
 
 struct GpuMem;
@@ -28,8 +28,8 @@ struct GpuPointer {
 
 #define MAX_FRAMES_IN_FLIGHT 2
 
-dyn_array_define(da_VK_FORMAT, enum VkFormat);
+paw_da_define(da_VK_FORMAT, enum VkFormat);
-dyn_array_define(da_Kitty, struct Kitty *);
+paw_da_define(da_Kitty, struct Kitty *);
 
 struct VertexBuffer {
   void *data;

src/vulkan_helpers.c

@@ -1,4 +1,4 @@
-#include "log.h"
+#include "paw_log.h"
 
 #include <vulkan/vulkan.h>
 

src/wayland.c

@@ -12,9 +12,9 @@
 #include <xkbcommon/xkbcommon-keysyms.h>
 #include <xkbcommon/xkbcommon.h>
 
-#include "dynarray.h"
 #include "hashmap.h"
-#include "log.h"
+#include "paw_da.h"
+#include "paw_log.h"
 
 #include "vulkan.h"
 #include <vulkan/vulkan_wayland.h>
@@ -116,10 +116,10 @@ static void keyboard_event_key(void *data, struct wl_keyboard *wl_keyboard,
   xkb_state_key_get_utf8(state->xkb_state, key, buffer, sizeof(buffer));
   if (key_state == 1) {
     insert_hashmap_ui32(state->keys, sym);
-    dyn_array_append(&state->pressed, sym);
+    paw_da_append(&state->pressed, sym);
   } else if (key_state == 0) {
     remove_hashmap_ui32(state->keys, sym);
-    dyn_array_append(&state->released, sym);
+    paw_da_append(&state->released, sym);
   } else {
     meow("bad wayland, a key can either go up or down, not %d", key_state);
   }
@@ -243,8 +243,8 @@ struct cat_Wl *cat_init_wl(const char *name, int width, int heigh,
   struct cat_Wl *state = malloc(sizeof(struct cat_Wl));
   memset(state, 0, sizeof(struct cat_Wl));
   state->keys = create_hashmap_ui32();
-  dyn_array_create_inplace(&state->pressed);
+  paw_da_make_inplace(&state->pressed);
-  dyn_array_create_inplace(&state->released);
+  paw_da_make_inplace(&state->released);
 
   state->should_close = state->resize_ready = state->resize_coming = false;
 
@@ -279,8 +279,8 @@ struct cat_Wl *cat_init_wl(const char *name, int width, int heigh,
 }
 
 void cat_wl_draw(struct cat_Wl *state) {
-  dyn_array_reset(&state->pressed);
+  paw_da_reset(&state->pressed);
-  dyn_array_reset(&state->released);
+  paw_da_reset(&state->released);
 
   if (state->resize_ready && state->resize_coming) {
     meow("resizing to %d x %d", state->new_width, state->new_heigh);
@@ -306,8 +306,8 @@ void cat_uninit_wl(struct cat_Wl *state) {
   uninit_vk(state->vk);
 
   destroy_hashmap_ui32(state->keys);
-  dyn_array_destroy(&state->pressed);
+  paw_da_free(&state->pressed);
-  dyn_array_destroy(&state->released);
+  paw_da_free(&state->released);
 
   if (state->xkb_state != NULL) {
     xkb_state_unref(state->xkb_state);

trig.c

@@ -1,8 +1,8 @@
-#include "src/allocator.h"
 #include "src/kitty.h"
-#include "src/log.h"
 #include "src/matrix.h"
-#include "src/object.h"
+#include "src/paw_allocator.h"
+#include "src/paw_log.h"
+#include "src/paw_object.h"
 #include "src/types.h"
 #include "src/util.h"
 
@@ -34,8 +34,8 @@ struct TrigUBO {
   struct mat3x3 view;
   struct mat3x3 proj;
 };
-struct Trig *trig_make_args(struct Scene *scene) {
+struct Trig *trig_make_args(struct PawScene *scene) {
-  struct Trig *trig = mem_malloc(scene->mem, sizeof(struct Trig));
+  struct Trig *trig = paw_memmalloc(scene->mem, sizeof(struct Trig));
 
   trig->kitty = kitty_make(scene->mem);
   kitty_set_vertex_shader(trig->kitty, "./Shaders/vert.spv");
@@ -67,16 +67,16 @@ struct Trig *trig_make_args(struct Scene *scene) {
   return trig;
 }
 
-struct Trig *make_trig(struct Scene *scene, char *_data, int _len) {
+struct Trig *make_trig(struct PawScene *scene, char *_data, int _len) {
   return trig_make_args(scene);
 }
 
-void free_trig(struct Scene *scene, struct Trig *trig) {
+void free_trig(struct PawScene *scene, struct Trig *trig) {
-  free_kitty(scene->vk, trig->kitty);
+  kitty_free(scene->vk, trig->kitty);
-  mem_free(scene->mem, trig);
+  paw_memfree(scene->mem, trig);
 }
 
-void trig_tick(struct Scene *scene, struct Trig *trig) {
+void trig_tick(struct PawScene *scene, struct Trig *trig) {
   struct TrigUBO ubo = {0};
   ubo.view = multiply3x3(translate3x3((struct Vec2){-1.5f, -0.5f}),
                          scale3x3((struct Vec2){1.0f, 1.0f}));