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

Compare commits

base: Timerix:6a1067a612a5cf610822c6b17361e1423945a166
Branches Tags
Timerix:main
..
compare: Timerix:e2f1f6c09be85f43f1e73e6fc25d2e86846133b4
Branches Tags
Timerix:main

No commits in common. "6a1067a612a5cf610822c6b17361e1423945a166" and "e2f1f6c09be85f43f1e73e6fc25d2e86846133b4" have entirely different histories.
6a1067a612 ... e2f1f6c09b

13 changed files with 172 additions and 318 deletions
Show Stats Expand all files Collapse all files

33
include/tlibc/collections/Array.h
View File

@ -8,7 +8,7 @@ typedef struct Array_ {
u32 size;
} Array_;
/// creates Array_ from self const array
/// creates Array_ from a const array
#define ARRAY(T, A...) Array_construct_size(((T[])A), sizeof((T[])A))
#define Array_construct(DATA, T, COUNT) Array_construct_size(DATA, (COUNT) * sizeof(T))
@ -20,31 +20,30 @@ static inline Array_ Array_alloc_size(u32 size){
return Array_construct_size(malloc(size), size);
}
#define Array_realloc(SELF, T, COUNT) Array_realloc_size(SELF, (COUNT) * sizeof(T))
#define Array_realloc(AR, T, COUNT) Array_realloc_size(AR, (COUNT) * sizeof(T))
static inline void Array_realloc_size(Array_* self, u32 new_size){
self->data = realloc(self->data, new_size);
self->size = new_size;
static inline void Array_realloc_size(Array_* ar, u32 new_size){
ar->data = realloc(ar->data, new_size);
ar->size = new_size;
}
static inline Array_ Array_copy(const Array_ self){
Array_ copy = Array_alloc_size(self.size);
if(copy.data != NULL)
memcpy(copy.data, self.data, self.size);
static inline Array_ Array_copy(Array_ src){
Array_ copy = Array_alloc_size(src.size);
memcpy(copy.data, src.data, src.size);
return copy;
}
#define Array_len(SELF, T) (SELF.size / sizeof(T))
#define Array_memset(SELF, VAL) memset(SELF.data, VAL, SELF.size)
#define Array_len(A, T) (A.size / sizeof(T))
#define Array_memset(A, VAL) memset(A.data, VAL, A.size)
#define struct_castTo_Array(STRUCT_PTR) Array_construct_size((STRUCT_PTR), sizeof(*STRUCT_PTR))
///@return self[0..i-1]
static inline Array(u8) Array_sliceTo(const Array(u8) self, u32 i){
return Array_construct_size(self.data, i);
///@return a[0..i-1]
static inline Array(u8) Array_sliceTo(Array(u8) a, u32 i){
return Array_construct_size(a.data, i);
}
///@return self[i...]
static inline Array(u8) Array_sliceFrom(const Array(u8) self, u32 i){
return Array_construct_size((u8*)self.data + i, self.size - i);
///@return a[i...]
static inline Array(u8) Array_sliceFrom(Array(u8) a, u32 i){
return Array_construct_size((u8*)a.data + i, a.size - i);
}

44
include/tlibc/collections/HashMap.h
View File

@ -6,51 +6,29 @@
typedef void (*FreeFunction)(void*);
typedef struct HashMapKeyHash {
typedef struct KeyHash {
str key;
u32 hash;
} HashMapKeyHash;
} KeyHash;
typedef struct HashMapBucket {
List(HashMapKeyHash) key_hash_list;
List(KeyHash) key_hash_list;
List(T) value_list;
} HashMapBucket;
#define HashMap(T) HashMap_
typedef struct HashMap_ {
NULLABLE(HashMapBucket*) table;
NULLABLE(FreeFunction) value_destructor;
HashMapBucket* table;
FreeFunction NULLABLE(value_destructor);
u32 value_t_size;
u32 height;
u16 height_n;
} HashMap_;
#define HashMap_construct(SELF, T, VALUE_DESTRUCTOR) HashMap_construct_size(SELF, sizeof(T), VALUE_DESTRUCTOR)
void HashMap_construct_size(HashMap_* self, u32 value_t_size, FreeFunction NULLABLE(value_destructor));
void HashMap_destroy(HashMap_* self);
bool HashMap_tryPush(HashMap_* self, const str key, void* value_ptr);
void HashMap_pushOrUpdate(HashMap_* self, const str key, void* value_ptr);
NULLABLE(void*) HashMap_tryGetPtr(const HashMap_* self, const str key);
bool HashMap_tryDelete(HashMap_* self, const str key);
typedef struct {
const HashMap_* map;
i32 bucket_n;
i32 elem_n;
} HashMapIter;
typedef struct HashMapKeyValue {
str key;
void* value;
} HashMapKeyValue;
static inline HashMapIter HashMapIter_create(const HashMap_* table){
return (HashMapIter){ .map = table, .bucket_n = -1, .elem_n = -1 };
}
bool HashMapIter_moveNext(HashMapIter* self);
/// don't forget to call HashMapIter_moveNext() first
bool HashMapIter_getCurrent(HashMapIter* self, HashMapKeyValue* kv);
#define HashMap_construct(PTR, T, VALUE_DESTRUCTOR) HashMap_construct_size(PTR, sizeof(T), VALUE_DESTRUCTOR)
void HashMap_construct_size(HashMap_* ptr, u32 value_t_size, FreeFunction NULLABLE(value_destructor));
void HashMap_destroy(HashMap_* ptr);
void* NULLABLE(HashMap_tryGetPtr)(HashMap_* ptr, str key);
bool HashMap_tryPush(HashMap_* ptr, str key, void* value_ptr);
bool HashMap_tryDelete(HashMap_* ptr, str key);

22
include/tlibc/collections/List.h
View File

@ -19,19 +19,13 @@ static inline List_ List_construct_size(void* data_ptr, u32 occupied_size, u32 a
#define List_alloc(T, INITIAL_COUNT) List_alloc_size((INITIAL_COUNT) * sizeof(T))
List_ List_alloc_size(u32 initial_size);
List_ List_copy(List_ src);
void* List_expand_size(List_* ptr, u32 expansion_size);
#define List_push(L, T, VALUE) *(T*)(List_expand_size(L, sizeof(T))) = VALUE
#define List_pushMany(L, T, VALUES_PTR, COUNT) List_push_size(L, VALUES_PTR, (COUNT) * sizeof(T))
void List_push_size(List_* ptr, void* values, u32 size);
// alloc bigger buffer if size + size_to_add won't fit in current
void List_increaseCapacity_size(List_* self, u32 size_to_add);
void* List_expand_size(List_* self, u32 size_to_add);
#define List_push(SELF, T, VALUE) *(T*)(List_expand_size(SELF, sizeof(T))) = VALUE
#define List_pushMany(SELF, T, VALUES_PTR, COUNT) List_push_size(SELF, VALUES_PTR, (COUNT) * sizeof(T))
void List_push_size(List_* self, void* values, u32 size);
#define List_removeAt(L, T, I, COUNT) List_removeAt_size(L, (I)*sizeof(T), (COUNT) * sizeof(T))
bool List_removeAt_size(List_* ptr, u32 i, u32 remove_size);
#define List_removeAt(SELF, T, I, COUNT) List_removeAt_size(SELF, (I)*sizeof(T), (COUNT) * sizeof(T))
bool List_removeAt_size(List_* self, u32 i, u32 remove_size);
#define List_len(SELF, T) (SELF.size / sizeof(T))
#define List_index(SELF, T, I) ((T*)SELF.data)[I]
#define List_castTo_Array(SELF) Array_construct_size(SELF.data, SELF.size)
#define List_len(L, T) ((L)->size / sizeof(T))
#define List_castTo_Array(l) Array_construct_size(l.data, l.size)

2
include/tlibc/errors.h
View File

@ -47,7 +47,7 @@ typedef struct Result_ {
#define IGNORE_RESULT Result_ __ignored_##__LINE__ ATTRIBUTE_UNUSED =
#define RESULT_ERROR(MSG, IS_MSG_ON_HEAP) (Result_){ .error = Error_create(MSG, IS_MSG_ON_HEAP, ErrorCallPos_here()) }
#define RESULT_ERROR_FMT(FORMAT, ARGS...) RESULT_ERROR(sprintf_malloc(FORMAT ,##ARGS), true)
#define RESULT_ERROR_FMT(FORMAT, ARGS...) RESULT_ERROR(sprintf_malloc(4096, FORMAT ,##ARGS), true)
#define RESULT_ERROR_ERRNO() RESULT_ERROR(strerror(errno), false)
#define RESULT_VOID (Result_){ .error = NULL, .u = 0 }
#define RESULT_VALUE(FIELD, V) (Result_){ .error = NULL, .FIELD = V }

12
include/tlibc/string/StringBuilder.h
View File

@ -13,16 +13,6 @@ static inline StringBuilder StringBuilder_alloc(u32 initial_size) {
}
void StringBuilder_destroy(StringBuilder* b);
static inline StringBuilder StringBuilder_copy(const StringBuilder* b){
return (StringBuilder) { .buffer = List_copy(b->buffer) };
}
// alloc bigger buffer if size + size_to_add won't fit in current
static inline void StringBuilder_increaseCapacity(StringBuilder* b, u32 size_to_add){
List_increaseCapacity_size(&b->buffer, size_to_add);
}
/// @param count set to -1 to clear StringBuilder
void StringBuilder_removeFromEnd(StringBuilder* b, u32 count);
void StringBuilder_append_char(StringBuilder* b, char c);
@ -35,5 +25,3 @@ void StringBuilder_append_memory(StringBuilder* b, Array(u8) mem, bool uppercase
// adds '\0' to the buffer and returns pointer to buffer content
str StringBuilder_getStr(StringBuilder* b);
bool StringBuilder_equals(const StringBuilder* a, const StringBuilder* b);

8
include/tlibc/string/cstr.h
View File

@ -2,8 +2,8 @@
#include "../std.h"
#define strcat_malloc(STR0, ...) _strcat_malloc(count_args(__VA_ARGS__), STR0, __VA_ARGS__)
char* _strcat_malloc(u64 n, cstr str0, ...);
char* _vstrcat_malloc(u64 n, cstr str0, va_list args);
char* _strcat_malloc(size_t n, cstr str0, ...);
char* _vstrcat_malloc(size_t n, cstr str0, va_list argv);
char* sprintf_malloc(cstr format, ...) ATTRIBUTE_CHECK_FORMAT_PRINTF(1, 2);
char* vsprintf_malloc(cstr format, va_list args);
char* NULLABLE(sprintf_malloc)(size_t buffer_size, cstr format, ...) ATTRIBUTE_CHECK_FORMAT_PRINTF(2, 3);
char* NULLABLE(vsprintf_malloc)(size_t buffer_size, cstr format, va_list argv);

26
include/tlibc/string/str.h
View File

@ -20,10 +20,6 @@ static inline str str_from_cstr(cstr s_ptr){
return str_construct((void*)s_ptr, strlen(s_ptr), true);
}
static inline void str_destroy(str s){
free(s.data);
}
static inline Array_ str_castTo_Array(str s) {
return Array_construct_size(s.data, s.size);
}
@ -35,29 +31,29 @@ static inline str Array_castTo_str(Array_ a, bool isZeroTerminated) {
static const str str_null = str_construct(NULL, 0, 0);
/// copies src content to new string and adds \0 at the end
str str_copy(const str self);
str str_copy(str src);
/// compares two strings, NullPtr-friendly
bool str_equals(const str self, const str other);
bool str_equals(str str0, str str1);
/// allocates new string which is reversed variant of <s>
str str_reverse(str s);
i32 str_seek(const str src, const str fragment, u32 startIndex);
i32 str_seekReverse(const str src, const str fragment, u32 startIndex);
i32 str_seek(str src, str fragment, u32 startIndex);
i32 str_seekReverse(str src, str fragment, u32 startIndex);
i32 str_seekChar(const str src, char c, u32 startIndex);
i32 str_seekCharReverse(const str src, char c, u32 startIndex);
i32 str_seekChar(str src, char c, u32 startIndex);
i32 str_seekCharReverse(str src, char c, u32 startIndex);
bool str_startsWith(const str src, const str fragment);
bool str_endsWith(const str src, const str fragment);
bool str_startsWith(str src, str fragment);
bool str_endsWith(str src, str fragment);
/// @brief calculates string hash using sdbm32 algorythm (something like lightweight crc32)
/// @return non-cryptografic hash of the string
u32 str_hash32(const str s);
u32 str_hash32(str s);
str str_toUpper(const str src);
str str_toLower(const str src);
str str_toUpper(str src);
str str_toLower(str src);
str hex_to_str(Array(u8) buf, bool uppercase);

160
src/collections/HashMap.c
View File

@ -13,35 +13,35 @@ static const Array(u32) __HashMap_heights = ARRAY(u32, {
});
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_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_destroy(HashMap_* self){
if(!self)
void HashMap_destroy(HashMap_* ptr){
if(!ptr)
return;
for(u32 i = 0; i < self->height; i++){
HashMapBucket* bu = &self->table[i];
u32 len = List_len(bu->key_hash_list, HashMapKeyHash);
for(u32 i = 0; i < ptr->height; i++){
HashMapBucket* bu = &ptr->table[i];
u32 len = List_len(&bu->key_hash_list, KeyHash);
// free key strings
for(u32 j = 0; j < len; j++){
HashMapKeyHash* kh = (HashMapKeyHash*)bu->key_hash_list.data + j;
KeyHash* kh = (KeyHash*)bu->key_hash_list.data + j;
free(kh->key.data);
}
// destroy values
if(self->value_destructor){
if(ptr->value_destructor){
u8* value_ptr = (u8*)bu->value_list.data;
u8* end = value_ptr + bu->value_list.size;
while(value_ptr < end){
self->value_destructor(value_ptr);
value_ptr += self->value_t_size;
ptr->value_destructor(value_ptr);
value_ptr += ptr->value_t_size;
}
}
@ -49,7 +49,7 @@ void HashMap_destroy(HashMap_* self){
free(bu->value_list.data);
}
free(self->table);
free(ptr->table);
}
typedef struct BucketAndIndex {
@ -62,14 +62,14 @@ 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_* self, const str key, u32 hash){
if(self->height == 0)
static BucketAndIndex __HashMap_search(HashMap_* ptr, str key, u32 hash){
if(ptr->height == 0)
return BucketAndIndex_null;
BucketAndIndex r;
r.bu = &self->table[hash % self->height];
for(r.i = 0; r.i < (i32)List_len(r.bu->key_hash_list, HashMapKeyHash); r.i++){
HashMapKeyHash* kh = (HashMapKeyHash*)r.bu->key_hash_list.data + r.i;
r.bu = &ptr->table[hash % ptr->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_* self, const str key, u32
return r;
}
void* HashMap_tryGetPtr(const HashMap_* self, const str key){
void* NULLABLE(HashMap_tryGetPtr)(HashMap_* ptr, str key){
u32 hash = __HashMap_HASH_FUNC(key);
BucketAndIndex r = __HashMap_search(self, key, hash);
BucketAndIndex r = __HashMap_search(ptr, key, hash);
// key not found
if(r.i == -1)
return NULL;
return (u8*)r.bu->value_list.data + r.i * self->value_t_size;
return ((u8*)r.bu->value_list.data) + r.i * ptr->value_t_size;
}
static void __HashMap_expand(HashMap_* self){
u32 height_expanded_n = self->height_n + 1;
static void __HashMap_expand(HashMap_* ptr){
u32 height_expanded_n = ptr->height_n + 1;
assert(height_expanded_n < Array_len(__HashMap_heights, u32) && "HashMap IS FULL! Fix your code.");
// alloc new HashMapBucket array
@ -100,116 +100,54 @@ static void __HashMap_expand(HashMap_* self){
memset(table_expanded, 0, table_expanded_size);
// copy values from old buckets to new
for(u32 i = 0; i < self->height; i++){
HashMapBucket* old_bucket = &self->table[i];
u32 len = List_len(old_bucket->key_hash_list, HashMapKeyHash);
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 j = 0; j < len; j++){
HashMapKeyHash kh = ((HashMapKeyHash*)old_bucket->key_hash_list.data)[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, HashMapKeyHash, kh);
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);
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);
}
free(old_bucket->key_hash_list.data);
free(old_bucket->value_list.data);
}
free(self->table);
self->table = table_expanded;
self->height = height_expanded;
self->height_n = height_expanded_n;
free(ptr->table);
ptr->table = table_expanded;
ptr->height = height_expanded;
ptr->height_n = height_expanded_n;
}
bool HashMap_tryPush(HashMap_* self, const str key, void* value_ptr){
bool HashMap_tryPush(HashMap_* ptr, str key, void* value_ptr){
u32 hash = __HashMap_HASH_FUNC(key);
BucketAndIndex r = __HashMap_search(self, key, hash);
BucketAndIndex r = __HashMap_search(ptr, 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, HashMapKeyHash) >= __HashMapBucket_MAX_LEN){
__HashMap_expand(self);
bu = &self->table[hash % self->height];
if(bu == NULL || List_len(&bu->key_hash_list, KeyHash) >= __HashMapBucket_MAX_LEN){
__HashMap_expand(ptr);
bu = &ptr->table[hash % ptr->height];
}
HashMapKeyHash kh = { .key = str_copy(key), .hash = hash };
List_push(&bu->key_hash_list, HashMapKeyHash, kh);
List_push_size(&bu->value_list, value_ptr, self->value_t_size);
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);
return true;
}
void HashMap_pushOrUpdate(HashMap_* self, const str key, void* value_ptr){
bool HashMap_tryDelete(HashMap_* ptr, str key){
u32 hash = __HashMap_HASH_FUNC(key);
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 * self->value_t_size;
memcpy(existing_item, value_ptr, self->value_t_size);
return;
}
HashMapBucket* bu = r.bu;
if(bu == NULL || List_len(bu->key_hash_list, HashMapKeyHash) >= __HashMapBucket_MAX_LEN){
__HashMap_expand(self);
bu = &self->table[hash % self->height];
}
HashMapKeyHash kh = { .key = str_copy(key), .hash = hash };
List_push(&bu->key_hash_list, HashMapKeyHash, kh);
List_push_size(&bu->value_list, value_ptr, self->value_t_size);
}
bool HashMap_tryDelete(HashMap_* self, const str key){
u32 hash = __HashMap_HASH_FUNC(key);
BucketAndIndex r = __HashMap_search(self, key, hash);
BucketAndIndex r = __HashMap_search(ptr, key, hash);
// key not found
if(r.i == -1)
return false;
List_removeAt(&r.bu->key_hash_list, HashMapKeyHash, r.i, 1);
List_removeAt_size(&r.bu->value_list, r.i, self->value_t_size);
return true;
}
bool HashMapIter_moveNext(HashMapIter* self){
if(self->map == NULL)
return false;
if(self->bucket_n == -1){
self->bucket_n = 0;
}
// move to next element in current bucket
const HashMapBucket* bu = &self->map->table[self->bucket_n];
i32 bu_elem_len = List_len(bu->key_hash_list, HashMapKeyHash);
if(self->elem_n + 1 < bu_elem_len){
self->elem_n++;
return true;
}
else {
// move to next non-empty bucket
while(self->bucket_n + 1 < (i32)self->map->height){
self->bucket_n++;
self->elem_n = 0;
bu = &self->map->table[self->bucket_n];
if(bu->key_hash_list.size != 0)
return true;
}
}
return false;
}
bool HashMapIter_getCurrent(HashMapIter* self, HashMapKeyValue* kv){
if(self->map == NULL || self->bucket_n == -1 || self->elem_n == -1)
return false;
const HashMapBucket* bu = &self->map->table[self->bucket_n];
// table is empty
if(bu->key_hash_list.size == 0)
return false;
kv->key = List_index(bu->key_hash_list, HashMapKeyHash, self->elem_n).key;
kv->value = (u8*)bu->value_list.data + self->map->value_t_size * self->elem_n;
List_removeAt(&r.bu->key_hash_list, KeyHash, r.i, 1);
List_removeAt_size(&r.bu->value_list, r.i, ptr->value_t_size);
return true;
}

52
src/collections/List.c
View File

@ -7,49 +7,33 @@ List_ List_alloc_size(u32 initial_size){
return List_construct_size(malloc(allocated_size), 0, allocated_size);
}
List_ List_copy(const List_ src){
List_ copy = List_alloc_size(src.allocated_size);
if(copy.data != NULL)
memcpy(copy.data, src.data, src.size);
return copy;
}
void List_increaseCapacity_size(List_* self, u32 size_to_add){
u32 occupied_size = self->size;
u32 expanded_size = occupied_size + size_to_add;
if(self->allocated_size < expanded_size) {
u32 expanded_alloc_size = self->allocated_size;
void* List_expand_size(List_* ptr, u32 expansion_size){
u32 occupied_size = ptr->size;
u32 expanded_alloc_size = ptr->allocated_size;
if(expanded_alloc_size == 0)
expanded_alloc_size = 32;
while(expanded_alloc_size < expanded_size){
expanded_alloc_size = 64;
ptr->size += expansion_size;
while(ptr->size > expanded_alloc_size){
expanded_alloc_size *= 2;
}
// if self->data is null, realloc acts like malloc
self->data = realloc(self->data, expanded_alloc_size);
self->allocated_size = expanded_alloc_size;
}
// 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;
}
void* List_expand_size(List_* self, u32 size_to_add){
List_increaseCapacity_size(self, size_to_add);
u8* empty_cell_ptr = (u8*)self->data + self->size;
self->size += size_to_add;
return empty_cell_ptr;
}
void List_push_size(List_* self, void* values, u32 size){
void* empty_cell_ptr = List_expand_size(self, size);
void List_push_size(List_* ptr, void* values, u32 size){
void* empty_cell_ptr = List_expand_size(ptr, size);
memcpy(empty_cell_ptr, values, size);
}
bool List_removeAt_size(List_* self, u32 i, u32 remove_size){
if(i + remove_size >= self->size)
bool List_removeAt_size(List_* ptr, u32 i, u32 remove_size){
if(i + remove_size >= ptr->size)
return false;
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);
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);
return true;
}

4
src/errors.c
View File

@ -8,7 +8,7 @@ Error* Error_create(const char* msg, bool is_msg_on_heap, ErrorCallPos p){
e->msg = str_construct((char*)(void*)msg, strlen(msg), true);
e->is_msg_on_heap = is_msg_on_heap;
e->call_stack = List_alloc(ErrorCallPos, 16);
Error_addCallPos(e, p);
List_push(&e->call_stack, ErrorCallPos, p);
return e;
}
@ -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: "));

14
src/string/StringBuilder.c
View File

@ -5,24 +5,16 @@ void StringBuilder_destroy(StringBuilder* b){
return;
free(b->buffer.data);
b->buffer = List_construct_size(NULL, 0, 0);
}
str StringBuilder_getStr(StringBuilder* b){
if(b->buffer.size == 0 || ((char*)b->buffer.data)[b->buffer.size - 1] != '\0'){
if(b->buffer.size == 0 || ((char*)b->buffer.data)[b->buffer.size - 1] != '\0')
List_push(&b->buffer, u8, '\0');
// '\0' at the end doesn't increase buffer.size
b->buffer.size -= 1;
}
str result = str_construct((char*)b->buffer.data, b->buffer.size, true);
str result = str_construct((char*)b->buffer.data, b->buffer.size - 1, true);
return result;
}
bool StringBuilder_equals(const StringBuilder* a, const StringBuilder* b){
str a_str = str_construct((char*)a->buffer.data, a->buffer.size, false);
str b_str = str_construct((char*)b->buffer.data, b->buffer.size, false);
return str_equals(a_str, b_str);
}
void StringBuilder_removeFromEnd(StringBuilder* b, u32 count){
if(count < b->buffer.size){
b->buffer.size -= count;

56
src/string/cstr.c
View File

@ -1,21 +1,21 @@
#include "tlibc/string/cstr.h"
char* _strcat_malloc(u64 n, cstr str0, ...){
va_list args;
va_start(args, str0);
char* heap_ptr = _vstrcat_malloc(n, str0, args);
va_end(args);
char* _strcat_malloc(size_t n, cstr str0, ...){
va_list argv;
va_start(argv, str0);
char* heap_ptr = _vstrcat_malloc(n, str0, argv);
va_end(argv);
return heap_ptr;
}
char* _vstrcat_malloc(u64 n, cstr str0, va_list args){
u64 str0_len = strlen(str0);
u64 total_len = str0_len;
char* _vstrcat_malloc(size_t n, cstr str0, va_list argv){
size_t str0_len = strlen(str0);
size_t total_len = str0_len;
cstr* const parts = malloc(sizeof(cstr) * n);
u64* const part_lengths = malloc(sizeof(u64) * n);
for(u64 i = 0; i < n; i++){
cstr part = va_arg(args, cstr);
u64 length = strlen(part);
size_t* const part_lengths = malloc(sizeof(size_t) * n);
for(size_t i = 0; i < n; i++){
cstr part = va_arg(argv, cstr);
size_t length = strlen(part);
parts[i] = part;
part_lengths[i] = length;
total_len += length;
@ -23,7 +23,7 @@ char* _vstrcat_malloc(u64 n, cstr str0, va_list args){
char* const buf = malloc(total_len + 1);
memcpy(buf, str0, str0_len);
char* walking_ptr = buf + str0_len;
for(u64 i = 0; i < n; i++){
for(size_t i = 0; i < n; i++){
memcpy(walking_ptr, parts[i], part_lengths[i]);
walking_ptr += part_lengths[i];
}
@ -33,30 +33,20 @@ char* _vstrcat_malloc(u64 n, cstr str0, va_list args){
return buf;
}
char* NULLABLE(sprintf_malloc)(cstr format, ...){
va_list args;
va_start(args, format);
char* heap_ptr = vsprintf_malloc(format, args);
va_end(args);
char* NULLABLE(sprintf_malloc)(size_t buffer_size, cstr format, ...){
va_list argv;
va_start(argv, format);
char* NULLABLE(heap_ptr) = vsprintf_malloc(buffer_size, format, argv);
va_end(argv);
return heap_ptr;
}
char* vsprintf_malloc(cstr format, va_list args){
// thanks to libtoml developer
va_list args_copy;
va_copy(args_copy, args);
i32 buf_size = vsnprintf(NULL, 0, format, args_copy);
va_end(args_copy);
if(buf_size < 63)
buf_size = 63;
buf_size += 1; // for '\0'
char* buf = malloc(buf_size);
int r = vsnprintf(buf, buf_size, format, args);
char* NULLABLE(vsprintf_malloc)(size_t buffer_size, cstr format, va_list argv){
char* buf = malloc(buffer_size);
int r = vsprintf(buf, format, argv);
if(r < 0){
char err_msg[] = "<ERROR vsprintf_malloc (tlibc/src/cstr.c:55)>";
u32 err_msg_size = sizeof(err_msg);
memcpy(buf, err_msg, err_msg_size);
free(buf);
return NULL;
}
return buf;
}

53
src/string/str.c
View File

@ -1,21 +1,19 @@
#include "tlibc/string/str.h"
#include "tlibc/string/StringBuilder.h"
str str_copy(const str self){
if(self.data == NULL || self.size == 0)
return self;
str str_copy(str src){
if(src.data == NULL || src.size == 0)
return src;
str copy = str_construct((char*)malloc(self.size + 1), self.size, true);
memcpy(copy.data, self.data, self.size);
copy.data[copy.size] = '\0';
return copy;
str nstr = str_construct((char*)malloc(src.size + 1), src.size, true);
memcpy(nstr.data, src.data, src.size);
nstr.data[nstr.size] = '\0';
return nstr;
}
bool str_equals(const str self, const str other){
if(self.size != other.size)
bool str_equals(str s0, str s1){
if(s0.size != s1.size)
return false;
if(self.data == other.data)
return true;
/*
BENCHMARK:
str_equals64: 2.967s
@ -23,7 +21,7 @@ bool str_equals(const str self, const str other){
strncmp: 1.611s
memcmp: 0.710s
*/
return memcmp(self.data, other.data, self.size) == 0;
return memcmp(s0.data, s1.data, s0.size) == 0;
}
str str_reverse(str s){
@ -36,7 +34,7 @@ str str_reverse(str s){
return r;
}
i32 str_seek(const str src, const str fragment, u32 startIndex){
i32 str_seek(str src, str fragment, u32 startIndex){
if(src.size == 0 || fragment.size == 0)
return -1;
@ -51,7 +49,7 @@ i32 str_seek(const str src, const str fragment, u32 startIndex){
return -1;
}
i32 str_seekReverse(const str src, const str fragment, u32 startIndex){
i32 str_seekReverse(str src, str fragment, u32 startIndex){
if(src.size == 0 || fragment.size == 0)
return -1;
@ -68,7 +66,7 @@ i32 str_seekReverse(const str src, const str fragment, u32 startIndex){
return -1;
}
i32 str_seekChar(const str src, char c, u32 startIndex){
i32 str_seekChar(str src, char c, u32 startIndex){
for(u32 i = startIndex; i < src.size; i++){
if(src.data[i] == c)
return i;
@ -76,7 +74,7 @@ i32 str_seekChar(const str src, char c, u32 startIndex){
return -1;
}
i32 str_seekCharReverse(const str src, char c, u32 startIndex){
i32 str_seekCharReverse(str src, char c, u32 startIndex){
if(startIndex > src.size - 1)
startIndex = src.size - 1;
for(u32 i = startIndex; i != (u32)-1; i--){
@ -86,27 +84,24 @@ i32 str_seekCharReverse(const str src, char c, u32 startIndex){
return -1;
}
bool str_startsWith(const str src, const str fragment){
bool str_startsWith(str src, str fragment){
if(src.size < fragment.size)
return false;
str src_fragment = str_null;
src_fragment.data = src.data;
src_fragment.size = fragment.size;
return str_equals(src_fragment, fragment);
src.size = fragment.size;
return str_equals(src, fragment);
}
bool str_endsWith(const str src, const str fragment){
bool str_endsWith(str src, str fragment){
if(src.size < fragment.size)
return false;
str src_fragment = str_null;
src_fragment.data = (char*)(src.data + src.size - fragment.size);
src_fragment.size = fragment.size;
return str_equals(src_fragment, fragment);
src.data = (char*)(src.data + src.size - fragment.size);
src.size = fragment.size;
return str_equals(src, fragment);
}
u32 str_hash32(const str s){
u32 str_hash32(str s){
u8* ubuf = (u8*)s.data;
u32 hash=0;
for (u32 i = 0; i < s.size; i++)
@ -114,7 +109,7 @@ u32 str_hash32(const str s){
return hash;
}
str str_toUpper(const str src){
str str_toUpper(str src){
str r = str_copy(src);
for (u32 i = 0; i < r.size; i++){
if(isAlphabeticalLower(r.data[i]))
@ -123,7 +118,7 @@ str str_toUpper(const str src){
return r;
}
str str_toLower(const str src){
str str_toLower(str src){
str r = str_copy(src);
for (u32 i = 0; i < r.size; i++){
if(isAlphabeticalUpper(r.data[i]))