created HashMap iterator

include/tlibc/collections/Array.h

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

include/tlibc/collections/HashMap.h

@@ -6,29 +6,51 @@
 
 typedef void (*FreeFunction)(void*);
 
-typedef struct KeyHash {
+typedef struct HashMapKeyHash {
     str key;
     u32 hash;
-} KeyHash;
+} HashMapKeyHash;
 
 typedef struct HashMapBucket {
-    List(KeyHash) key_hash_list;
+    List(HashMapKeyHash) key_hash_list;
     List(T) value_list;
 } HashMapBucket;
 
 #define HashMap(T) HashMap_
 
 typedef struct HashMap_ {
-    HashMapBucket* table;
+    NULLABLE(HashMapBucket*) table;
-    FreeFunction NULLABLE(value_destructor);
+    NULLABLE(FreeFunction) value_destructor;
     u32 value_t_size;
     u32 height;
     u16 height_n;
 } HashMap_;
 
-#define HashMap_construct(PTR, T, VALUE_DESTRUCTOR) HashMap_construct_size(PTR, sizeof(T), VALUE_DESTRUCTOR)
+#define HashMap_construct(SELF, T, VALUE_DESTRUCTOR) HashMap_construct_size(SELF, sizeof(T), VALUE_DESTRUCTOR)
-void HashMap_construct_size(HashMap_* ptr, u32 value_t_size, FreeFunction NULLABLE(value_destructor));
+void HashMap_construct_size(HashMap_* self, u32 value_t_size, FreeFunction NULLABLE(value_destructor));
-void HashMap_destroy(HashMap_* ptr);
+void HashMap_destroy(HashMap_* self);
-void* NULLABLE(HashMap_tryGetPtr)(HashMap_* ptr, str key);
+
-bool HashMap_tryPush(HashMap_* ptr, str key, void* value_ptr);
+bool HashMap_tryPush(HashMap_* self, const str key, void* value_ptr);
-bool HashMap_tryDelete(HashMap_* ptr, str key);
+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);

include/tlibc/collections/List.h

@@ -19,13 +19,19 @@ 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);
 
-void* List_expand_size(List_* ptr, u32 expansion_size);
+List_ List_copy(List_ src);
-#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);
 
-#define List_removeAt(L, T, I, COUNT) List_removeAt_size(L, (I)*sizeof(T), (COUNT) * sizeof(T))
+// alloc bigger buffer if size + size_to_add won't fit in current
-bool List_removeAt_size(List_* ptr, u32 i, u32 remove_size);
+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_len(L, T) ((L)->size / sizeof(T))
+#define List_removeAt(SELF, T, I, COUNT) List_removeAt_size(SELF, (I)*sizeof(T), (COUNT) * sizeof(T))
-#define List_castTo_Array(l) Array_construct_size(l.data, l.size)
+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)

include/tlibc/errors.h

@@ -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(4096, FORMAT ,##ARGS), true)
+#define RESULT_ERROR_FMT(FORMAT, ARGS...) RESULT_ERROR(sprintf_malloc(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 }

include/tlibc/string/StringBuilder.h

@@ -13,6 +13,16 @@ 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);
@@ -25,3 +35,5 @@ 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);

include/tlibc/string/cstr.h

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

include/tlibc/string/str.h

@@ -20,6 +20,10 @@ 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);
 }
@@ -31,29 +35,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(str src);
+str str_copy(const str self);
 
 /// compares two strings, NullPtr-friendly
-bool str_equals(str str0, str str1);
+bool str_equals(const str self, const str other);
 
 /// allocates new string which is reversed variant of <s>
 str str_reverse(str s);
 
-i32 str_seek(str src, str fragment, u32 startIndex);
+i32 str_seek(const str src, const str fragment, u32 startIndex);
-i32 str_seekReverse(str src, str fragment, u32 startIndex);
+i32 str_seekReverse(const str src, const str fragment, u32 startIndex);
 
-i32 str_seekChar(str src, char c, u32 startIndex);
+i32 str_seekChar(const str src, char c, u32 startIndex);
-i32 str_seekCharReverse(str src, char c, u32 startIndex);
+i32 str_seekCharReverse(const str src, char c, u32 startIndex);
 
-bool str_startsWith(str src, str fragment);
+bool str_startsWith(const str src, const str fragment);
-bool str_endsWith(str src, str fragment);
+bool str_endsWith(const str src, const str fragment);
 
 /// @brief calculates string hash using sdbm32 algorythm (something like lightweight crc32)
 /// @return non-cryptografic hash of the string
-u32 str_hash32(str s);
+u32 str_hash32(const str s);
 
-str str_toUpper(str src);
+str str_toUpper(const str src);
-str str_toLower(str src);
+str str_toLower(const str src);
 
 str hex_to_str(Array(u8) buf, bool uppercase);
 

src/collections/HashMap.c

@@ -13,35 +13,35 @@ static const Array(u32) __HashMap_heights = ARRAY(u32, {
 });
 
 
-void HashMap_construct_size(HashMap_* ptr, u32 value_t_size, FreeFunction NULLABLE(value_destructor)){
+void HashMap_construct_size(HashMap_* self, u32 value_t_size, FreeFunction NULLABLE(value_destructor)){
-    ptr->value_t_size = value_t_size;
+    self->value_t_size = value_t_size;
-    ptr->value_destructor = value_destructor;
+    self->value_destructor = value_destructor;
-    ptr->height_n = 0;
+    self->height_n = 0;
-    ptr->height = 0;
+    self->height = 0;
-    ptr->table = NULL;
+    self->table = NULL;
 }
 
-void HashMap_destroy(HashMap_* ptr){
+void HashMap_destroy(HashMap_* self){
-    if(!ptr)
+    if(!self)
         return;
 
-    for(u32 i = 0; i < ptr->height; i++){
+    for(u32 i = 0; i < self->height; i++){
-        HashMapBucket* bu = &ptr->table[i];
+        HashMapBucket* bu = &self->table[i];
-        u32 len = List_len(&bu->key_hash_list, KeyHash);
+        u32 len = List_len(bu->key_hash_list, HashMapKeyHash);
         
         // free key strings
         for(u32 j = 0; j < len; j++){
-            KeyHash* kh = (KeyHash*)bu->key_hash_list.data + j;
+            HashMapKeyHash* kh = (HashMapKeyHash*)bu->key_hash_list.data + j;
             free(kh->key.data);
         }
         
         // 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);
+                self->value_destructor(value_ptr);
-                value_ptr += ptr->value_t_size;
+                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,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(HashMap_* ptr, str key, u32 hash){
+static BucketAndIndex __HashMap_search(const HashMap_* self, const str key, u32 hash){
-    if(ptr->height == 0)
+    if(self->height == 0)
         return BucketAndIndex_null;
 
     BucketAndIndex r;
-    r.bu = &ptr->table[hash % ptr->height];
+    r.bu = &self->table[hash % self->height];
-    for(r.i = 0; r.i < (i32)List_len(&r.bu->key_hash_list, KeyHash); r.i++){
+    for(r.i = 0; r.i < (i32)List_len(r.bu->key_hash_list, HashMapKeyHash); r.i++){
-        KeyHash* kh = (KeyHash*)r.bu->key_hash_list.data + r.i;
+        HashMapKeyHash* kh = (HashMapKeyHash*)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(HashMap_* ptr, str key, u32 hash){
     return r;
 }
 
-void* NULLABLE(HashMap_tryGetPtr)(HashMap_* ptr, 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){
+static void __HashMap_expand(HashMap_* self){
-    u32 height_expanded_n = ptr->height_n + 1;
+    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,54 +100,116 @@ 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++){
+    for(u32 i = 0; i < self->height; i++){
-        HashMapBucket* old_bucket = &ptr->table[i];
+        HashMapBucket* old_bucket = &self->table[i];
-        u32 len = List_len(&old_bucket->key_hash_list, KeyHash);
+        u32 len = List_len(old_bucket->key_hash_list, HashMapKeyHash);
         
         for(u32 j = 0; j < len; j++){
-            KeyHash kh = ((KeyHash*)old_bucket->key_hash_list.data)[j];
+            HashMapKeyHash kh = ((HashMapKeyHash*)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);
+            List_push(&new_bucket->key_hash_list, HashMapKeyHash, kh);
-            void* old_value_ptr = (u8*)old_bucket->value_list.data + j * 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, ptr->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);
+    free(self->table);
-    ptr->table = table_expanded;
+    self->table = table_expanded;
-    ptr->height = height_expanded;
+    self->height = height_expanded;
-    ptr->height_n = height_expanded_n;
+    self->height_n = height_expanded_n;
 }
 
-bool HashMap_tryPush(HashMap_* ptr, 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){
+    if(bu == NULL || List_len(bu->key_hash_list, HashMapKeyHash) >= __HashMapBucket_MAX_LEN){
-        __HashMap_expand(ptr);
+        __HashMap_expand(self);
-        bu = &ptr->table[hash % ptr->height];
+        bu = &self->table[hash % self->height];
     }
     
-    KeyHash kh = { .key = str_copy(key), .hash = hash };
+    HashMapKeyHash kh = { .key = str_copy(key), .hash = hash };
-    List_push(&bu->key_hash_list, KeyHash, kh);
+    List_push(&bu->key_hash_list, HashMapKeyHash, 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;
 }
 
-bool HashMap_tryDelete(HashMap_* ptr, str key){
+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 * 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);
     // key not found
     if(r.i == -1)
         return false;
     
-    List_removeAt(&r.bu->key_hash_list, KeyHash, r.i, 1);
+    List_removeAt(&r.bu->key_hash_list, HashMapKeyHash, 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;
+}
+
+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;
     return true;
 }

src/collections/List.c

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

src/errors.c

@@ -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);
-    List_push(&e->call_stack, ErrorCallPos, p);
+    Error_addCallPos(e, 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: "));

src/string/StringBuilder.c

@@ -5,16 +5,24 @@ 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');
-    str result = str_construct((char*)b->buffer.data, b->buffer.size - 1, true);
+        // '\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);
     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;

src/string/cstr.c

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

src/string/str.c

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