Timerix/tlibc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

renamed first argument of all methods to 'self'

Browse Source
This commit is contained in:
Timerix
2025-11-10 07:04:09 +05:00
parent 0a1e87817d
commit 958cb269b2
6 changed files with 101 additions and 101 deletions
Download Patch File Download Diff File Expand all files Collapse all files

100
src/collections/HashMap.c
View File

@@ -13,21 +13,21 @@ static const Array(u32) __HashMap_heights = ARRAY(u32, {
});
void HashMap_construct_size(HashMap_* ptr, u32 value_t_size, FreeFunction NULLABLE(value_destructor)){
ptr->value_t_size = value_t_size;
ptr->value_destructor = value_destructor;
ptr->height_n = 0;
ptr->height = 0;
ptr->table = NULL;
void HashMap_construct_size(HashMap_* self, u32 value_t_size, FreeFunction NULLABLE(value_destructor)){
self->value_t_size = value_t_size;
self->value_destructor = value_destructor;
self->height_n = 0;
self->height = 0;
self->table = NULL;
}
void HashMap_destroy(HashMap_* ptr){
if(!ptr)
void HashMap_destroy(HashMap_* self){
if(!self)
return;
for(u32 i = 0; i < ptr->height; i++){
HashMapBucket* bu = &ptr->table[i];
u32 len = List_len(&bu->key_hash_list, KeyHash);
for(u32 i = 0; i < self->height; i++){
HashMapBucket* bu = &self->table[i];
u32 len = List_len(bu->key_hash_list, KeyHash);
// free key strings
for(u32 j = 0; j < len; j++){
@@ -36,12 +36,12 @@ void HashMap_destroy(HashMap_* ptr){
}
// destroy values
if(ptr->value_destructor){
if(self->value_destructor){
u8* value_ptr = (u8*)bu->value_list.data;
u8* end = value_ptr + bu->value_list.size;
while(value_ptr < end){
ptr->value_destructor(value_ptr);
value_ptr += ptr->value_t_size;
self->value_destructor(value_ptr);
value_ptr += self->value_t_size;
}
}
@@ -49,7 +49,7 @@ void HashMap_destroy(HashMap_* ptr){
free(bu->value_list.data);
}
free(ptr->table);
free(self->table);
}
typedef struct BucketAndIndex {
@@ -62,13 +62,13 @@ typedef struct BucketAndIndex {
///@returns `HashMapBucket*` for specified key or NULL, if table hasn't been allocated yet;
/// Index of existing item with the same key or -1 if no item is present.
static BucketAndIndex __HashMap_search(const HashMap_* ptr, const str key, u32 hash){
if(ptr->height == 0)
static BucketAndIndex __HashMap_search(const HashMap_* self, const str key, u32 hash){
if(self->height == 0)
return BucketAndIndex_null;
BucketAndIndex r;
r.bu = &ptr->table[hash % ptr->height];
for(r.i = 0; r.i < (i32)List_len(&r.bu->key_hash_list, KeyHash); r.i++){
r.bu = &self->table[hash % self->height];
for(r.i = 0; r.i < (i32)List_len(r.bu->key_hash_list, KeyHash); r.i++){
KeyHash* kh = (KeyHash*)r.bu->key_hash_list.data + r.i;
if(kh->hash == hash && str_equals(kh->key, key)){
return r;
@@ -79,18 +79,18 @@ static BucketAndIndex __HashMap_search(const HashMap_* ptr, const str key, u32 h
return r;
}
void* HashMap_tryGetPtr(const HashMap_* ptr, const str key){
void* HashMap_tryGetPtr(const HashMap_* self, const str key){
u32 hash = __HashMap_HASH_FUNC(key);
BucketAndIndex r = __HashMap_search(ptr, key, hash);
BucketAndIndex r = __HashMap_search(self, key, hash);
// key not found
if(r.i == -1)
return NULL;
return ((u8*)r.bu->value_list.data) + r.i * ptr->value_t_size;
return ((u8*)r.bu->value_list.data) + r.i * self->value_t_size;
}
static void __HashMap_expand(HashMap_* ptr){
u32 height_expanded_n = ptr->height_n + 1;
static void __HashMap_expand(HashMap_* self){
u32 height_expanded_n = self->height_n + 1;
assert(height_expanded_n < Array_len(__HashMap_heights, u32) && "HashMap IS FULL! Fix your code.");
// alloc new HashMapBucket array
@@ -100,74 +100,74 @@ static void __HashMap_expand(HashMap_* ptr){
memset(table_expanded, 0, table_expanded_size);
// copy values from old buckets to new
for(u32 i = 0; i < ptr->height; i++){
HashMapBucket* old_bucket = &ptr->table[i];
u32 len = List_len(&old_bucket->key_hash_list, KeyHash);
for(u32 i = 0; i < self->height; i++){
HashMapBucket* old_bucket = &self->table[i];
u32 len = List_len(old_bucket->key_hash_list, KeyHash);
for(u32 j = 0; j < len; j++){
KeyHash kh = ((KeyHash*)old_bucket->key_hash_list.data)[j];
HashMapBucket* new_bucket = &table_expanded[kh.hash % height_expanded];
List_push(&new_bucket->key_hash_list, KeyHash, kh);
void* old_value_ptr = (u8*)old_bucket->value_list.data + j * ptr->value_t_size;
List_push_size(&new_bucket->value_list, old_value_ptr, ptr->value_t_size);
void* old_value_ptr = (u8*)old_bucket->value_list.data + j * self->value_t_size;
List_push_size(&new_bucket->value_list, old_value_ptr, self->value_t_size);
}
free(old_bucket->key_hash_list.data);
free(old_bucket->value_list.data);
}
free(ptr->table);
ptr->table = table_expanded;
ptr->height = height_expanded;
ptr->height_n = height_expanded_n;
free(self->table);
self->table = table_expanded;
self->height = height_expanded;
self->height_n = height_expanded_n;
}
bool HashMap_tryPush(HashMap_* ptr, const str key, void* value_ptr){
bool HashMap_tryPush(HashMap_* self, const str key, void* value_ptr){
u32 hash = __HashMap_HASH_FUNC(key);
BucketAndIndex r = __HashMap_search(ptr, key, hash);
BucketAndIndex r = __HashMap_search(self, key, hash);
// found existing item with the same key
if(r.i != -1)
return false;
HashMapBucket* bu = r.bu;
if(bu == NULL || List_len(&bu->key_hash_list, KeyHash) >= __HashMapBucket_MAX_LEN){
__HashMap_expand(ptr);
bu = &ptr->table[hash % ptr->height];
if(bu == NULL || List_len(bu->key_hash_list, KeyHash) >= __HashMapBucket_MAX_LEN){
__HashMap_expand(self);
bu = &self->table[hash % self->height];
}
KeyHash kh = { .key = str_copy(key), .hash = hash };
List_push(&bu->key_hash_list, KeyHash, kh);
List_push_size(&bu->value_list, value_ptr, ptr->value_t_size);
List_push_size(&bu->value_list, value_ptr, self->value_t_size);
return true;
}
void HashMap_pushOrUpdate(HashMap_* ptr, const str key, void* value_ptr){
void HashMap_pushOrUpdate(HashMap_* self, const str key, void* value_ptr){
u32 hash = __HashMap_HASH_FUNC(key);
BucketAndIndex r = __HashMap_search(ptr, key, hash);
BucketAndIndex r = __HashMap_search(self, key, hash);
// found existing item with the same key
if(r.i != -1){
void* existing_item = ((u8*)r.bu->value_list.data) + r.i * ptr->value_t_size;
memcpy(existing_item, value_ptr, ptr->value_t_size);
void* existing_item = ((u8*)r.bu->value_list.data) + r.i * self->value_t_size;
memcpy(existing_item, value_ptr, self->value_t_size);
}
HashMapBucket* bu = r.bu;
if(bu == NULL || List_len(&bu->key_hash_list, KeyHash) >= __HashMapBucket_MAX_LEN){
__HashMap_expand(ptr);
bu = &ptr->table[hash % ptr->height];
if(bu == NULL || List_len(bu->key_hash_list, KeyHash) >= __HashMapBucket_MAX_LEN){
__HashMap_expand(self);
bu = &self->table[hash % self->height];
}
KeyHash kh = { .key = str_copy(key), .hash = hash };
List_push(&bu->key_hash_list, KeyHash, kh);
List_push_size(&bu->value_list, value_ptr, ptr->value_t_size);
List_push_size(&bu->value_list, value_ptr, self->value_t_size);
}
bool HashMap_tryDelete(HashMap_* ptr, const str key){
bool HashMap_tryDelete(HashMap_* self, const str key){
u32 hash = __HashMap_HASH_FUNC(key);
BucketAndIndex r = __HashMap_search(ptr, key, hash);
BucketAndIndex r = __HashMap_search(self, key, hash);
// key not found
if(r.i == -1)
return false;
List_removeAt(&r.bu->key_hash_list, KeyHash, r.i, 1);
List_removeAt_size(&r.bu->value_list, r.i, ptr->value_t_size);
List_removeAt_size(&r.bu->value_list, r.i, self->value_t_size);
return true;
}

34
src/collections/List.c
View File

@@ -14,33 +14,33 @@ List_ List_copy(const List_ src){
return copy;
}
void* List_expand_size(List_* ptr, u32 size_to_add){
u32 occupied_size = ptr->size;
u32 expanded_alloc_size = ptr->allocated_size;
void* List_expand_size(List_* self, u32 size_to_add){
u32 occupied_size = self->size;
u32 expanded_alloc_size = self->allocated_size;
if(expanded_alloc_size == 0)
expanded_alloc_size = 64;
ptr->size += size_to_add;
while(ptr->size > expanded_alloc_size){
self->size += size_to_add;
while(self->size > expanded_alloc_size){
expanded_alloc_size *= 2;
}
// if ptr->data is null, realloc acts like malloc
ptr->data = realloc(ptr->data, expanded_alloc_size);
ptr->allocated_size = expanded_alloc_size;
return (u8*)(ptr->data) + occupied_size;
// if self->data is null, realloc acts like malloc
self->data = realloc(self->data, expanded_alloc_size);
self->allocated_size = expanded_alloc_size;
return (u8*)(self->data) + occupied_size;
}
void List_push_size(List_* ptr, void* values, u32 size){
void* empty_cell_ptr = List_expand_size(ptr, size);
void List_push_size(List_* self, void* values, u32 size){
void* empty_cell_ptr = List_expand_size(self, size);
memcpy(empty_cell_ptr, values, size);
}
bool List_removeAt_size(List_* ptr, u32 i, u32 remove_size){
if(i + remove_size >= ptr->size)
bool List_removeAt_size(List_* self, u32 i, u32 remove_size){
if(i + remove_size >= self->size)
return false;
ptr->size -= remove_size;
u8* src = (u8*)ptr->data + i + remove_size;
u8* dst = (u8*)ptr->data + i;
memmove(dst, src, ptr->size - i - remove_size);
self->size -= remove_size;
u8* src = (u8*)self->data + i + remove_size;
u8* dst = (u8*)self->data + i;
memmove(dst, src, self->size - i - remove_size);
return true;
}

2
src/errors.c
View File

@@ -24,7 +24,7 @@ void Error_addCallPos(Error* e, ErrorCallPos p){
}
str Error_toStr(Error* e){
u32 len = List_len(&e->call_stack, ErrorCallPos);
u32 len = List_len(e->call_stack, ErrorCallPos);
StringBuilder b = StringBuilder_alloc(e->msg.size + 80 * len);
StringBuilder_append_str(&b, STR("Catched Error: "));