From f98b2371b15233501ce2f7538f469171529199dd Mon Sep 17 00:00:00 2001 From: Eric-Paul Ickhorn Date: Sun, 3 Mar 2024 20:28:59 +0100 Subject: [PATCH] Made the code compile without libRR The redundancy-reduction library (libRR), which was used, has now been thrown out in favor of functions from the C standard library. --- build-config/dependencies.txt | 1 + inc-c/context.h | 2 +- inc-c/entity.h | 4 ++-- inc-c/shadow-tag.h | 39 ++++++++++++++++++----------------- inc-c/shadow.h | 14 ++++++------- src-c/shadow-lookup.c | 34 +++++++++++++++--------------- src-c/shadow-pool.c | 8 +++---- src-c/shadow-registry.c | 10 ++++----- src-c/shadow-tag.c | 33 ++++++++++++++--------------- 9 files changed, 73 insertions(+), 72 deletions(-) create mode 100644 build-config/dependencies.txt diff --git a/build-config/dependencies.txt b/build-config/dependencies.txt new file mode 100644 index 0000000..19e45d2 --- /dev/null +++ b/build-config/dependencies.txt @@ -0,0 +1 @@ +Maths \ No newline at end of file diff --git a/inc-c/context.h b/inc-c/context.h index 374bdc5..e9944ce 100644 --- a/inc-c/context.h +++ b/inc-c/context.h @@ -2,7 +2,7 @@ #ifndef MT_CONTEXT_H #define MT_CONTEXT_H -#include +#include #include #include diff --git a/inc-c/entity.h b/inc-c/entity.h index 895e7a3..34b0a64 100644 --- a/inc-c/entity.h +++ b/inc-c/entity.h @@ -2,7 +2,7 @@ #ifndef MT_ENTITY_H #define MT_ENTITY_H -#include +#include typedef struct MtEntity MtEntity; @@ -18,7 +18,7 @@ struct MtEntity /// @brief: The identifier of the background structure "shadow". /// This is used for resolving this entity to its actual data. - u32_t shadow_id; + uint32_t shadow_id; }; #endif // MT_ENTITY_H diff --git a/inc-c/shadow-tag.h b/inc-c/shadow-tag.h index d38f319..5508177 100644 --- a/inc-c/shadow-tag.h +++ b/inc-c/shadow-tag.h @@ -2,8 +2,9 @@ #ifndef MT_SHADOW_TAG_H #define MT_SHADOW_TAG_H -#include -#include +#include +#include +#include #include typedef struct MtShadowTag MtShadowTag; @@ -34,24 +35,24 @@ struct MtShadowTag MtShadowTag *next; MtShadowTagType type; - u32_t name_identifier; + uint32_t name_identifier; union MtShadowTagData { - bool_t boolean; - i64_t integer; - f64_t decimal; + bool boolean; + int64_t integer; + double decimal; char *string; void *raw_pointer; - rr_vec2f_s vec2f; - rr_vec3f_s vec3f; - rr_vec4f_s vec4f; + AuVec2f vec2f; + AuVec3f vec3f; + AuVec4f vec4f; MtEntity entity; } data; }; struct MtShadowTagPool { - usz_t capacity; + uint32_t capacity; MtShadowTag *allocation; MtShadowTag *first_free; MtShadowTagPool *continuation; @@ -59,8 +60,8 @@ struct MtShadowTagPool struct MtShadowTagNameArena { - usz_t capacity; - usz_t usage; + uint32_t capacity; + uint32_t usage; char *allocation; MtShadowTagNameArena *continuation; }; @@ -68,15 +69,15 @@ struct MtShadowTagNameArena struct MtShadowTagName { char *string_in_arena; - u32_t identifier; + uint32_t identifier; }; struct MtShadowTagNameRegistry { - usz_t names_capacity; - usz_t num_names; + uint32_t names_capacity; + uint32_t num_names; MtShadowTagName *names; - u32_t id_counter; + uint32_t id_counter; MtShadowTagNameArena *root_arena; }; @@ -90,7 +91,7 @@ struct MtShadowTagSystem void mt_init_shadow_tag_system(MtShadowTagSystem *tag_system); void mt_cleanup_shadow_tag_system(MtShadowTagSystem *tag_system); -MtShadowTagPool * mt_new_shadow_tag_pool(usz_t capacity); +MtShadowTagPool * mt_new_shadow_tag_pool(uint32_t capacity); /// @brief Crates a new MtShadowTagPool with a given capacity. /// @warning Don't use `mt_free_shadow_tag_pool()` with use created with this method. @@ -98,7 +99,7 @@ MtShadowTagPool * mt_new_shadow_tag_pool(usz_t capacity); /// @param pool A pointer to the location at which the pool should be created. /// @param capacity The number of entity shadow tags which should be able to reside in /// the first instance of the pool. The pool will allocate more once needed. -void mt_init_shadow_tag_pool(MtShadowTagPool *pool, usz_t capacity); +void mt_init_shadow_tag_pool(MtShadowTagPool *pool, uint32_t capacity); void mt_free_shadow_tag_pool(MtShadowTagPool *pool); MtShadowTag * mt_alloc_shadow_tag(void *context_ptr); @@ -112,6 +113,6 @@ MtShadowTag * mt_alloc_shadow_tag_in_pool(MtShadowTagPool *pool); MtShadowTag * mt_alloc_shadow_tag_before(MtShadowTag *chain_start); void mt_free_shadow_tag_chain(MtShadowTag *tag); -u32_t mt_tag_name_to_id(void *context_ptr, const char *tag_name); +uint32_t mt_tag_name_to_id(void *context_ptr, const char *tag_name); #endif // MT_SHADOW_TAG_H diff --git a/inc-c/shadow.h b/inc-c/shadow.h index c892aa6..038c2b4 100644 --- a/inc-c/shadow.h +++ b/inc-c/shadow.h @@ -2,7 +2,7 @@ #ifndef MT_SHADOW_H #define MT_SHADOW_H -#include +#include #include typedef struct MtShadowRegistry MtShadowRegistry; @@ -17,7 +17,7 @@ struct MtShadow { void *context; MtShadowTag *tag_chain_start; - u32_t identifier; + uint32_t identifier; MtShadowPool *pool; MtShadow *pool_next; @@ -25,7 +25,7 @@ struct MtShadow struct MtShadowPool { - usz_t capacity; + uint32_t capacity; MtShadow *shadows; MtShadow *first_free; MtShadowPool *continuation; @@ -57,7 +57,7 @@ struct MtShadowRegistry // to the next free entry, the index representing the ID's value and having // stored the next free entry's index. Conceptually similar to the internals // of the old File Allocation Table filesystems (FAT12, FAT16, FAT32). - u32_t id_counter; + uint32_t id_counter; MtShadowPool root_pool; MtShadowLookupTree lookup_tree; void *context_ptr; @@ -67,15 +67,15 @@ MtShadowRegistry mt_create_shadow_registry(void *context_ptr); void mt_cleanup_shadow_registry(MtShadowRegistry *registry); MtShadow * mt_create_shadow(MtShadowRegistry *registry); -MtShadow * mt_lookup_shadow(MtShadowRegistry *registry, u32_t identifier); +MtShadow * mt_lookup_shadow(MtShadowRegistry *registry, uint32_t identifier); void mt_delete_shadow(MtShadowRegistry *registry, MtShadow *shadow); void mt_cleanup_shadow_pool(MtShadowPool *pool); void mt_free_shadow_pool(MtShadowPool *pool); MtShadowLookupTree mt_create_shadow_lookup_tree(); -void mt_init_shadow_pool(MtShadowPool *pool, usz_t capacity); -MtShadowPool * mt_new_shadow_pool(usz_t capacity); +void mt_init_shadow_pool(MtShadowPool *pool, uint32_t capacity); +MtShadowPool * mt_new_shadow_pool(uint32_t capacity); MtShadow * mt_pool_shadow(MtShadowPool *pool); void mt_unpool_shadow(MtShadow *shadow); diff --git a/src-c/shadow-lookup.c b/src-c/shadow-lookup.c index 7cdb2dc..42fb76e 100644 --- a/src-c/shadow-lookup.c +++ b/src-c/shadow-lookup.c @@ -1,21 +1,21 @@ #include #include #include -#include +#include MtShadowLookupTree mt_create_shadow_lookup_tree() { MtShadowLookupTree lookup_tree; - rr_memset(&lookup_tree.next[0], sizeof(MtShadow *) * 256, 0); + memset(&lookup_tree.next[0], sizeof(MtShadow *) * 256, 0); return lookup_tree; } -MtShadow * mt_lookup_shadow(MtShadowRegistry *registry, u32_t identifier) +MtShadow * mt_lookup_shadow(MtShadowRegistry *registry, uint32_t identifier) { - u8_t index_1 = identifier >> 24; - u8_t index_2 = (identifier >> 16) & 0xff; - u8_t index_3 = (identifier >> 8) & 0xff; - u8_t index_4 = identifier & 0xff; + uint8_t index_1 = identifier >> 24; + uint8_t index_2 = (identifier >> 16) & 0xff; + uint8_t index_3 = (identifier >> 8) & 0xff; + uint8_t index_4 = identifier & 0xff; MtShadowLookupLevel1 *level_1 = registry->lookup_tree.next[index_1]; if(level_1 == NULL) return NULL; @@ -31,13 +31,13 @@ MtShadow * mt_lookup_shadow(MtShadowRegistry *registry, u32_t identifier) void mt_delete_shadow(MtShadowRegistry *registry, MtShadow *shadow) { - u32_t identifier = shadow->identifier; + uint32_t identifier = shadow->identifier; mt_unpool_shadow(shadow); - u8_t index_1 = identifier >> 24; - u8_t index_2 = (identifier >> 16) & 0xff; - u8_t index_3 = (identifier >> 8) & 0xff; - u8_t index_4 = identifier & 0xff; + uint8_t index_1 = identifier >> 24; + uint8_t index_2 = (identifier >> 16) & 0xff; + uint8_t index_3 = (identifier >> 8) & 0xff; + uint8_t index_4 = identifier & 0xff; MtShadowLookupLevel1 *level_1 = registry->lookup_tree.next[index_1]; if(level_1 == NULL) return; @@ -52,12 +52,12 @@ void mt_delete_shadow(MtShadowRegistry *registry, MtShadow *shadow) void mt_write_shadow_lookup_entry(MtShadowLookupTree *tree, MtShadow *shadow) { - u32_t identifier = shadow->identifier; + uint32_t identifier = shadow->identifier; - u8_t index_1 = identifier >> 24; - u8_t index_2 = (identifier >> 16) & 0xff; - u8_t index_3 = (identifier >> 8) & 0xff; - u8_t index_4 = identifier & 0xff; + uint8_t index_1 = identifier >> 24; + uint8_t index_2 = (identifier >> 16) & 0xff; + uint8_t index_3 = (identifier >> 8) & 0xff; + uint8_t index_4 = identifier & 0xff; MtShadowLookupLevel1 *level_1 = tree->next[index_1]; if(level_1 == NULL) { diff --git a/src-c/shadow-pool.c b/src-c/shadow-pool.c index 1fc283a..0d67469 100644 --- a/src-c/shadow-pool.c +++ b/src-c/shadow-pool.c @@ -3,8 +3,8 @@ void mt_init_shadow_pool_allocation(MtShadowPool *pool) { - usz_t capacity = pool->capacity; - usz_t shadow_index = 0; + uint32_t capacity = pool->capacity; + uint32_t shadow_index = 0; while(shadow_index < capacity) { pool->shadows[shadow_index].pool = pool; @@ -14,7 +14,7 @@ void mt_init_shadow_pool_allocation(MtShadowPool *pool) pool->shadows[capacity-1].pool_next = NULL; } -void mt_init_shadow_pool(MtShadowPool *pool, usz_t capacity) +void mt_init_shadow_pool(MtShadowPool *pool, uint32_t capacity) { pool->capacity = capacity; pool->continuation = NULL; @@ -39,7 +39,7 @@ void mt_free_shadow_pool(MtShadowPool *pool) free(pool); } -MtShadowPool * mt_new_shadow_pool(usz_t capacity) +MtShadowPool * mt_new_shadow_pool(uint32_t capacity) { MtShadowPool *pool = malloc(sizeof(MtShadowPool)); mt_init_shadow_pool(pool, capacity); diff --git a/src-c/shadow-registry.c b/src-c/shadow-registry.c index af8e090..30de340 100644 --- a/src-c/shadow-registry.c +++ b/src-c/shadow-registry.c @@ -1,5 +1,5 @@ #include -#include +#include #include void mt_delete_shadow_lookup_tree_of_registry(MtShadowRegistry *registry); @@ -29,7 +29,7 @@ void mt_cleanup_shadow_data(MtShadow *shadow) void mt_delete_shadow_lookup_tree_of_registry(MtShadowRegistry *registry) { MtShadowLookupTree *lookup_tree = ®istry->lookup_tree; - u32_t index_1 = 0; + uint32_t index_1 = 0; while(index_1 < 256) { MtShadowLookupLevel1 *level_1 = lookup_tree->next[index_1]; @@ -38,7 +38,7 @@ void mt_delete_shadow_lookup_tree_of_registry(MtShadowRegistry *registry) ++index_1; continue; } - u32_t index_2 = 0; + uint32_t index_2 = 0; while(index_2 < 256) { MtShadowLookupLevel2 *level_2 = level_1->next[index_2]; @@ -47,7 +47,7 @@ void mt_delete_shadow_lookup_tree_of_registry(MtShadowRegistry *registry) ++index_2; continue; } - u32_t index_3 = 0; + uint32_t index_3 = 0; while(index_3 < 256) { MtShadowLookupLevel3 *level_3 = level_2->next[index_3]; @@ -56,7 +56,7 @@ void mt_delete_shadow_lookup_tree_of_registry(MtShadowRegistry *registry) ++index_3; continue; } - u32_t index_4 = 0; + uint32_t index_4 = 0; while(index_4 < 256) { MtShadow *shadow = level_3->next[index_4]; diff --git a/src-c/shadow-tag.c b/src-c/shadow-tag.c index 3d05046..d96881a 100644 --- a/src-c/shadow-tag.c +++ b/src-c/shadow-tag.c @@ -1,12 +1,11 @@ #include #include -#include -#include +#include #include -void mt_init_shadow_tag_pool_allocation(MtShadowTagPool *pool, usz_t capacity) +void mt_init_shadow_tag_pool_allocation(MtShadowTagPool *pool, uint32_t capacity) { - usz_t slot_index = 0; + uint32_t slot_index = 0; while(slot_index < capacity) { pool->allocation[slot_index].pool = pool; @@ -16,7 +15,7 @@ void mt_init_shadow_tag_pool_allocation(MtShadowTagPool *pool, usz_t capacity) pool->allocation[capacity - 1].next = NULL; } -void mt_init_shadow_tag_pool(MtShadowTagPool *pool, usz_t capacity) +void mt_init_shadow_tag_pool(MtShadowTagPool *pool, uint32_t capacity) { pool->capacity = capacity; pool->allocation = calloc(sizeof(MtShadowTag), capacity); @@ -25,7 +24,7 @@ void mt_init_shadow_tag_pool(MtShadowTagPool *pool, usz_t capacity) mt_init_shadow_tag_pool_allocation(pool, capacity); } -MtShadowTagPool * mt_new_shadow_tag_pool(usz_t capacity) +MtShadowTagPool * mt_new_shadow_tag_pool(uint32_t capacity) { MtShadowTagPool *pool = malloc(sizeof(MtShadowTagPool)); mt_init_shadow_tag_pool(pool, capacity * 2); @@ -52,7 +51,7 @@ MtShadowTag * mt_alloc_shadow_tag_in_pool(MtShadowTagPool *pool) pool->first_free = allocated_tag->next; // Reset the tag's old data - rr_memset(allocated_tag, sizeof(MtShadowTag), 0x00); + memset(allocated_tag, sizeof(MtShadowTag), 0x00); allocated_tag->pool = pool; return allocated_tag; @@ -85,7 +84,7 @@ void mt_free_shadow_tag_chain(MtShadowTag *tag) -void mt_init_shadow_tag_name_arena(MtShadowTagNameArena *arena, usz_t size) +void mt_init_shadow_tag_name_arena(MtShadowTagNameArena *arena, uint32_t size) { arena->usage = 0; arena->capacity = size; @@ -93,7 +92,7 @@ void mt_init_shadow_tag_name_arena(MtShadowTagNameArena *arena, usz_t size) arena->continuation = NULL; } -MtShadowTagNameArena * mt_new_shadow_tag_name_arena(usz_t size) +MtShadowTagNameArena * mt_new_shadow_tag_name_arena(uint32_t size) { MtShadowTagNameArena *arena = malloc(sizeof(MtShadowTagNameArena)); mt_init_shadow_tag_name_arena(arena, size); @@ -137,9 +136,9 @@ void mt_cleanup_shadow_tag_system(MtShadowTagSystem *tag_system) -char * mt_shadow_tag_name_arena_alloc(MtShadowTagNameArena *arena, usz_t num_bytes) +char * mt_shadow_tag_name_arena_alloc(MtShadowTagNameArena *arena, uint32_t num_bytes) { - usz_t end_size = arena->usage + num_bytes; + uint32_t end_size = arena->usage + num_bytes; if(end_size >= arena->capacity) { if(arena->continuation == NULL) @@ -151,7 +150,7 @@ char * mt_shadow_tag_name_arena_alloc(MtShadowTagNameArena *arena, usz_t num_byt return allocation; } -u32_t mt_force_create_new_tag_name_entry(MtShadowTagNameRegistry *name_registry, const char *tag_name) +uint32_t mt_force_create_new_tag_name_entry(MtShadowTagNameRegistry *name_registry, const char *tag_name) { if(name_registry->num_names >= name_registry->names_capacity) { @@ -160,9 +159,9 @@ u32_t mt_force_create_new_tag_name_entry(MtShadowTagNameRegistry *name_registry, } MtShadowTagName *name_entry = &name_registry->names[name_registry->num_names++]; - usz_t len_tag_name = rr_measure_string(tag_name); + uint32_t len_tag_name = strlen(tag_name); char *tag_name_copy = mt_shadow_tag_name_arena_alloc(name_registry->root_arena, len_tag_name+1); - rr_memcopy(tag_name_copy, tag_name, len_tag_name + 1); + memcpy(tag_name_copy, tag_name, len_tag_name + 1); name_entry->string_in_arena = tag_name_copy; name_entry->identifier = name_registry->id_counter++; @@ -170,15 +169,15 @@ u32_t mt_force_create_new_tag_name_entry(MtShadowTagNameRegistry *name_registry, return name_entry->identifier; } -u32_t mt_tag_name_to_id(void *context_ptr, const char *tag_name) +uint32_t mt_tag_name_to_id(void *context_ptr, const char *tag_name) { MtContext *context = context_ptr; MtShadowTagNameRegistry *name_registry = &context->shadow_tag_system.name_registry; - usz_t name_index = 0; + uint32_t name_index = 0; while(name_index < name_registry->num_names) { - if(rr_strings_equal(name_registry->names[name_index].string_in_arena, tag_name)) + if(!strcmp(name_registry->names[name_index].string_in_arena, tag_name)) return name_registry->names[name_index].identifier; ++name_index; }