lunacat/pawengine
lunacat/pawengine
0
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

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

Browse source
This commit is contained in:
qwertzuiopy 2025-04-04 19:58:54 +02:00
parent e30b8f0abc
commit 6dcddb4da3
35 changed files with 394 additions and 392 deletions
Download patch file Download diff file Expand all files Collapse all files

4
Makefile
View file

@ -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+=object.c register.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+=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))

10
main.c
View file

@ -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);

28
src/allocator.h
View file

@ -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_

2
src/glfw.c
View file

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

2
src/gpu_allocator.c
View file

@ -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;

2
src/hashmap.c
View file

@ -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

2
src/io.c
View file

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

48
src/kitty.c
View file

@ -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);
dyn_array_create_inplace(&kitty->vertex_buffer.format);
dyn_array_create_inplace(&kitty->instance_buffer.format);
paw_da_make_inplace(&kitty->attatchments);
paw_da_make_inplace(&kitty->vertex_buffer.format);
paw_da_make_inplace(&kitty->instance_buffer.format);
} else {
dyn_array_create_inplace_mem(&kitty->attatchments, kitty->mem);
dyn_array_create_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->attatchments, kitty->mem);
paw_da_make_inplace_mem(&kitty->vertex_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);
dyn_array_destroy(&kitty->attatchments);
paw_da_free(&kitty->vertex_buffer.format);
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;

14
src/kitty.h
View file

@ -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 {
enum AttatchType type;
struct KittyAttatchment {
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);

82
src/lang/ast.c
View file

@ -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);
dyn_array_create_inplace_mem(&ast->methods, ast->mem);
paw_da_make_inplace_mem(&ast->properties, 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,
((struct PawMethod){.body = body, .name = name}));
paw_da_append(&ast->methods,
((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 = mem_malloc(mem, sizeof(struct Stack));
stack->left = mem_malloc(mem, size);
struct Stack *stack_make(struct PawMem *mem, size_t size) {
struct Stack *stack = paw_memmalloc(mem, sizeof(struct Stack));
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) {
mem_free(mem, stack->left);
mem_free(mem, stack);
void stack_free(struct Stack *stack, struct PawMem *mem) {
paw_memfree(mem, stack->left);
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) {

63
src/lang/ast.h
View file

@ -5,9 +5,9 @@
#include <stdint.h>
#include <stdlib.h>
#include "../allocator.h"
#include "../dynarray.h"
#include "../object.h"
#include "../paw_allocator.h"
#include "../paw_da.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 *);
dyn_array_define(da_paw_val, enum PawVal *);
paw_da_define(da_paw_ctrl, enum PawCtrl *);
paw_da_define(da_paw_val, enum PawVal *);
struct PawProperty {
char *name;
enum PawVal *val;
};
dyn_array_define(da_paw_property, struct PawProperty);
dyn_array_define(da_method, struct PawMethod);
paw_da_define(da_paw_property, struct PawProperty);
paw_da_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);
void vstack_free(struct VStack *stack, struct Mem *mem);
struct VStack *vstack_make(struct PawMem *mem, size_t size);
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_int(struct Mem *mem, int n);
enum PawVal *make_pawval_bool(struct Mem *mem, bool n);
enum PawVal *make_pawval_point(struct Mem *mem, paw_p n);
enum PawVal *make_pawval_spoint(struct Mem *mem, int n);
enum PawVal *make_pawval_expr(struct Mem *mem, enum PawVal *lhs,
enum PawVal *make_pawval_float(struct PawMem *mem, float n);
enum PawVal *make_pawval_int(struct PawMem *mem, int n);
enum PawVal *make_pawval_bool(struct PawMem *mem, bool n);
enum PawVal *make_pawval_point(struct PawMem *mem, paw_p n);
enum PawVal *make_pawval_spoint(struct PawMem *mem, int n);
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);
enum PawCtrl *make_pawctrl_seq(struct Mem *mem);
enum PawCtrl *make_pawctrl_spush(struct Mem *mem, struct PawStackVal val);
enum PawCtrl *make_pawctrl_spop(struct Mem *mem);
enum PawCtrl *make_pawctrl_call(struct Mem *mem, enum PawCtrl *body);
enum PawCtrl *make_pawctrl_ccall(struct Mem *mem, int index);
enum PawCtrl *make_pawctrl_loop(struct Mem *mem, enum PawCtrl *body);
enum PawCtrl *make_pawctrl_break(struct Mem *mem);
enum PawCtrl *make_pawctrl_if(struct Mem *mem, enum PawVal *cond,
void free_pawval(struct PawMem *mem, enum PawVal *val);
enum PawCtrl *make_pawctrl_seq(struct PawMem *mem);
enum PawCtrl *make_pawctrl_spush(struct PawMem *mem, struct PawStackVal val);
enum PawCtrl *make_pawctrl_spop(struct PawMem *mem);
enum PawCtrl *make_pawctrl_call(struct PawMem *mem, enum PawCtrl *body);
enum PawCtrl *make_pawctrl_ccall(struct PawMem *mem, int index);
enum PawCtrl *make_pawctrl_loop(struct PawMem *mem, enum PawCtrl *body);
enum PawCtrl *make_pawctrl_break(struct PawMem *mem);
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)

8
src/lang/ast_disc.c
View file

@ -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++) {

2
src/lang/functable.c
View file

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

2
src/lang/glue.c
View file

@ -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);
}

14
src/lang/vstack.c
View file

@ -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 *stack = mem_malloc(mem, sizeof(struct VStack));
stack->left = mem_malloc(mem, size);
struct VStack *vstack_make(struct PawMem *mem, size_t size) {
struct VStack *stack = paw_memmalloc(mem, sizeof(struct VStack));
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) {
mem_free(mem, stack->left);
mem_free(mem, stack);
void vstack_free(struct VStack *stack, struct PawMem *mem) {
paw_memfree(mem, stack->left);
paw_memfree(mem, stack);
}
void vstack_pop(struct VStack *stack) {

45
src/object.h
View file

@ -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_

52
src/allocator.c → src/paw_allocator.c
View file

@ -1,5 +1,5 @@
#include "allocator.h"
#include "log.h"
#include "paw_allocator.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 Mem *mem = malloc(sizeof(struct Mem) + size);
struct PawMem *paw_memmake(size_t 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);
mem->allocs[0] = (struct Alloc){mem->mem + mem->mem_size, 0, NULL};
mem->allocs[1] = (struct Alloc){mem->mem, 0, &mem->allocs[0]};
memset(&mem->allocs, 0, sizeof(struct PawAlloc) * MAX_ALLOCS);
mem->allocs[0] = (struct PawAlloc){mem->mem + mem->mem_size, 0, NULL};
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);
*new = (struct Alloc){
struct PawAlloc *new = get_next_alloc(mem);
*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) {
struct Alloc *current = mem->alloc;
struct Alloc *prev = mem->alloc;
void paw_memfree(struct PawMem *mem, void *p) {
struct PawAlloc *current = 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));
}

28
src/paw_allocator.h Normal file
View file

@ -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_

18
src/dynarray.c → src/paw_da.c
View file

@ -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) {
struct da_template *da = mem_malloc(mem, sizeof(struct da_template));
da->items = mem_malloc(mem, 0);
void *paw_da_make_mem(struct PawMem *mem) {
struct da_template *da = paw_memmalloc(mem, sizeof(struct da_template));
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;

42
src/dynarray.h → src/paw_da.h
View file

@ -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); \
(array)->items = mem_malloc((array)->mem, (array)->capacity * \
sizeof(*(array)->items)); \
paw_memfree((array)->mem, (array)->items); \
(array)->items = paw_memmalloc( \
(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);
dyn_array_define(da_string, char *);
paw_da_define(da_uint32_t, uint32_t);
paw_da_define(da_string, char *);
void *dyn_array_create();
void *dyn_array_create_mem(struct Mem *mem);
void dyn_array_create_inplace(void *array);
void dyn_array_create_inplace_mem(void *array, struct Mem *mem);
void *paw_da_make();
void *paw_da_make_mem(struct PawMem *mem);
void paw_da_make_inplace(void *array);
void paw_da_make_inplace_mem(void *array, struct PawMem *mem);
#endif // INCLUDE_WAYLANDCLIENT_DYNARRAY_H_

6
src/log.c → src/paw_log.c
View file

@ -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 {

4
src/log.h → src/paw_log.h
View file

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

72
src/object.c → src/paw_object.c
View file

@ -1,7 +1,6 @@
#include "object.h"
#include "allocator.h"
#include "dynarray.h"
#include "log.h"
#include "paw_object.h"
#include "paw_allocator.h"
#include "paw_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 Scene *scene = malloc(sizeof(struct Scene));
memset(scene, 0, sizeof(struct Scene));
struct PawScene *paw_scene_make(struct Vk *vk, struct Register *reg) {
struct PawScene *scene = malloc(sizeof(struct PawScene));
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);
dyn_array_create_inplace_mem(&scene->insert_queue, scene->mem);
dyn_array_create_inplace_mem(&scene->named, scene->mem);
paw_da_make_inplace_mem(&scene->objects, scene->mem);
paw_da_make_inplace_mem(&scene->insert_queue, 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);
dyn_array_destroy(&scene->named);
uninit_mem(scene->mem);
paw_da_free(&scene->insert_queue);
paw_da_free(&scene->named);
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,
int len) {
void paw_scene_queue_insert_from_data(struct PawScene *scene, char *name,
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,
struct Object *object) {
dyn_array_append(&scene->named, ((struct Named){id, object}));
void paw_scene_reg_named(struct PawScene *scene, const char *id,
struct PawObject *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;

46
src/paw_object.h Normal file
View file

@ -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_

17
src/register.c
View file

@ -1,28 +1,27 @@
#include "register.h"
#include "dynarray.h"
#include "log.h"
#include "object.h"
#include "paw_log.h"
#include "paw_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 (*free)(struct Scene *, void *),
void (*tick)(struct Scene *, void *)) {
void *(*make)(struct PawScene *, char *, int len),
void (*free)(struct PawScene *, 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) {

23
src/register.h
View file

@ -1,33 +1,32 @@
#ifndef INCLUDE_WAYLANDCLIENT_REGISTER_H_
#define INCLUDE_WAYLANDCLIENT_REGISTER_H_
#include "dynarray.h"
#include "object.h"
#include "paw_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 (*free)(struct Scene *, void *);
void (*tick)(struct Scene *, void *);
void *(*make)(struct PawScene *, char *, int len);
void (*free)(struct PawScene *, void *);
void (*tick)(struct PawScene *, void *);
};
struct Register {
struct da_Type reg;
};
#define OBJ_FREE (void (*)(struct Scene *, void *))
#define OBJ_TICK (void (*)(struct Scene *, void *))
#define OBJ_MAKE (void *(*)(struct Scene *, char *, int len))
#define OBJ_FREE (void (*)(struct PawScene *, void *))
#define OBJ_TICK (void (*)(struct PawScene *, void *))
#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 (*free)(struct Scene *, void *),
void (*tick)(struct Scene *, void *));
void *(*make)(struct PawScene *, char *, int len),
void (*free)(struct PawScene *, void *),
void (*tick)(struct PawScene *, void *));
#endif // INCLUDE_WAYLANDCLIENT_REGISTER_H_

38
src/string.c
View file

@ -1,31 +1,31 @@
#include "string.h"
#include "allocator.h"
#include "log.h"
#include "paw_allocator.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 *new = mem_malloc(mem, size + 1);
char *extract(struct PawMem *mem, char *string, int start, int size) {
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 *new = mem_malloc(mem, (strlen(string) + 1) * sizeof(char));
char *mem_strdup(char *string, struct PawMem *mem) {
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 *new = mem_malloc(mem, end - start + 2);
char *mem_strdup_reg(char *start, char *end, struct PawMem *mem) {
char *new = paw_memmalloc(mem, end - start + 2);
memcpy(new, start, end - start + 1);
new[end - start + 2] = 0x0;
return new;

18
src/string.h
View file

@ -1,27 +1,27 @@
#ifndef INCLUDE_SRC_STRING_H_
#define INCLUDE_SRC_STRING_H_
#include "allocator.h"
#include "dynarray.h"
#include "paw_allocator.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_inbetween_chars(struct Mem *mem, char *string, char one,
char *extract(struct PawMem *mem, char *string, int start, int size);
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_reg(char *start, char *end, struct Mem *mem);
char *mem_strdup(char *string, struct PawMem *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);

33
src/util.c
View file

@ -1,8 +1,10 @@
#include "allocator.h"
#include "dynarray.h"
#include "paw_allocator.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) {
dyn_array_destroy(&st->keys);
free(st);
} else {
dyn_array_destroy(&st->keys);
mem_free(st->keys.mem, st);
}
paw_da_free(&st->keys);
paw_free_memfree(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) {

4
src/util.h
View file

@ -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);

7
src/vulkan.c
View file

@ -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);

8
src/vulkan.h
View file

@ -4,8 +4,8 @@
#include <stdbool.h>
#include <vulkan/vulkan.h>
#include "dynarray.h"
#include "log.h"
#include "paw_da.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);
dyn_array_define(da_Kitty, struct Kitty *);
paw_da_define(da_VK_FORMAT, enum VkFormat);
paw_da_define(da_Kitty, struct Kitty *);
struct VertexBuffer {
void *data;

2
src/vulkan_helpers.c
View file

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

20
src/wayland.c
View file

@ -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);
dyn_array_create_inplace(&state->released);
paw_da_make_inplace(&state->pressed);
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);
dyn_array_reset(&state->released);
paw_da_reset(&state->pressed);
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);
dyn_array_destroy(&state->released);
paw_da_free(&state->pressed);
paw_da_free(&state->released);
if (state->xkb_state != NULL) {
xkb_state_unref(state->xkb_state);

20
trig.c
View file

@ -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 = mem_malloc(scene->mem, sizeof(struct Trig));
struct Trig *trig_make_args(struct PawScene *scene) {
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) {
free_kitty(scene->vk, trig->kitty);
mem_free(scene->mem, trig);
void free_trig(struct PawScene *scene, struct Trig *trig) {
kitty_free(scene->vk, trig->kitty);
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}));