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

rewritten Array and List, changed str.size -> .len

Browse Source
This commit is contained in:
Timerix
2025-11-25 14:13:25 +05:00
parent b557881168
commit 82bd234d08
48 changed files with 389 additions and 227 deletions
Download Patch File Download Diff File Expand all files Collapse all files

67
src/collections/HashMap.c
View File

@@ -1,4 +1,6 @@
#include "tlibc/collections/HashMap.h"
#include "tlibc/collections/Array.h"
#include "tlibc/collections/Array_impl/Array_u32.h"
#include <assert.h>
//TODO: sort bucket keys for binary search
@@ -9,9 +11,14 @@
static const Array(u32) __HashMap_heights = ARRAY(u32, {
0, 17, 31, 61, 127, 257, 521, 1021, 2053, 4099, 8191, 16381,
32771, 65521, 131071, 262147, 524287, 1048583, 2097169, 4194319,
8388617, 16777213, 33554467, 67108859, 134217757, 268435493
8388617, 16777213, 33554467, 67108859, 134217757, 268435493,
536871001, 1073742037, 2147484061
});
void HashMapBucket_construct(HashMapBucket* self, u32 value_t_size){
self->key_hash_list = List_HashMapKeyHash_construct(NULL, 0, 0);
self->value_list = _List_construct(NULL, 0, 0, value_t_size);
}
void HashMap_construct_size(HashMap_* self, u32 value_t_size, Destructor_t NULLABLE(value_destructor)){
self->value_t_size = value_t_size;
@@ -27,9 +34,9 @@ void HashMap_destroy(HashMap_* self){
for(u32 i = 0; i < self->height; i++){
HashMapBucket* bu = &self->table[i];
u32 len = List_len(bu->key_hash_list, HashMapKeyHash);
// free key strings
u32 len = bu->key_hash_list.len;
for(u32 j = 0; j < len; j++){
HashMapKeyHash* kh = (HashMapKeyHash*)bu->key_hash_list.data + j;
free(kh->key.data);
@@ -38,7 +45,7 @@ void HashMap_destroy(HashMap_* self){
// destroy values
if(self->value_destructor){
u8* value_ptr = (u8*)bu->value_list.data;
u8* end = value_ptr + bu->value_list.size;
u8* end = value_ptr + bu->value_list.len * bu->value_list.elem_t_size;
while(value_ptr < end){
self->value_destructor(value_ptr);
value_ptr += self->value_t_size;
@@ -68,7 +75,8 @@ static BucketAndIndex __HashMap_search(const HashMap_* self, const str key, u32
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++){
i32 len = r.bu->key_hash_list.len;
for(r.i = 0; r.i < len; r.i++){
HashMapKeyHash* kh = (HashMapKeyHash*)r.bu->key_hash_list.data + r.i;
if(kh->hash == hash && str_equals(kh->key, key)){
return r;
@@ -91,29 +99,33 @@ void* HashMap_tryGetPtr(const HashMap_* self, const str key){
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.");
assert(height_expanded_n < __HashMap_heights.len && "HashMap IS FULL! Fix your code.");
// alloc new HashMapBucket array
u32 height_expanded = ((u32*)__HashMap_heights.data)[height_expanded_n];
u32 height_expanded = __HashMap_heights.data[height_expanded_n];
u32 table_expanded_size = height_expanded * sizeof(HashMapBucket);
HashMapBucket* table_expanded = (HashMapBucket*)malloc(table_expanded_size);
memset(table_expanded, 0, table_expanded_size);
// init buckets
for(u32 i = 0; i < height_expanded; i++){
HashMapBucket_construct(table_expanded + i, self->value_t_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);
u32 len = old_bucket->key_hash_list.len;
for(u32 j = 0; j < len; 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, HashMapKeyHash, kh);
HashMapKeyHash* kh = old_bucket->key_hash_list.data + j;
HashMapBucket* new_bucket = &table_expanded[kh->hash % height_expanded];
List_HashMapKeyHash_pushMany(&new_bucket->key_hash_list, kh, 1);
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->value_list, old_value_ptr, 1);
}
free(old_bucket->key_hash_list.data);
free(old_bucket->value_list.data);
List_HashMapKeyHash_destroy(&old_bucket->key_hash_list);
_List_destroy(&old_bucket->value_list);
}
free(self->table);
self->table = table_expanded;
@@ -129,14 +141,14 @@ bool HashMap_tryPush(HashMap_* self, const str key, void* value_ptr){
return false;
HashMapBucket* bu = r.bu;
if(bu == NULL || List_len(bu->key_hash_list, HashMapKeyHash) >= __HashMapBucket_MAX_LEN){
if(bu == NULL || r.bu->key_hash_list.len >= __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);
List_HashMapKeyHash_push(&bu->key_hash_list, kh);
_List_push(&bu->value_list, value_ptr, 1);
return true;
}
@@ -151,14 +163,14 @@ void HashMap_pushOrUpdate(HashMap_* self, const str key, void* value_ptr){
}
HashMapBucket* bu = r.bu;
if(bu == NULL || List_len(bu->key_hash_list, HashMapKeyHash) >= __HashMapBucket_MAX_LEN){
if(bu == NULL || r.bu->key_hash_list.len >= __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);
List_HashMapKeyHash_push(&bu->key_hash_list, kh);
_List_push(&bu->value_list, value_ptr, 1);
}
bool HashMap_tryDelete(HashMap_* self, const str key){
@@ -168,8 +180,11 @@ bool HashMap_tryDelete(HashMap_* self, const str key){
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);
if(!List_HashMapKeyHash_tryRemoveAt(&r.bu->key_hash_list, r.i, 1))
return false;
if(!_List_tryRemoveAt(&r.bu->value_list, r.i, 1))
return false;
return true;
}
@@ -182,7 +197,7 @@ bool HashMapIter_moveNext(HashMapIter* self){
}
// 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);
i32 bu_elem_len = bu->key_hash_list.len;
if(self->elem_n + 1 < bu_elem_len){
self->elem_n++;
return true;
@@ -193,7 +208,7 @@ bool HashMapIter_moveNext(HashMapIter* self){
self->bucket_n++;
self->elem_n = 0;
bu = &self->map->table[self->bucket_n];
if(bu->key_hash_list.size != 0)
if(bu->key_hash_list.len != 0)
return true;
}
}
@@ -206,10 +221,10 @@ bool HashMapIter_getCurrent(HashMapIter* self, HashMapKeyValue* kv){
const HashMapBucket* bu = &self->map->table[self->bucket_n];
// table is empty
if(bu->key_hash_list.size == 0)
if(bu->key_hash_list.len == 0)
return false;
kv->key = List_index(bu->key_hash_list, HashMapKeyHash, self->elem_n).key;
kv->key = bu->key_hash_list.data[self->elem_n].key;
kv->value = (u8*)bu->value_list.data + self->map->value_t_size * self->elem_n;
return true;
}

88
src/collections/List.c
View File

@@ -1,55 +1,73 @@
#include "tlibc/collections/List.h"
#include <assert.h>
List_ List_alloc_size(u32 initial_size){
if(initial_size == 0)
return List_null;
u32 allocated_size = ALIGN_TO(initial_size, sizeof(void*));
return List_construct_size(malloc(allocated_size), 0, allocated_size);
List_ _List_alloc(u32 initial_capacity, u32 elem_t_size){
assert(elem_t_size != 0);
if(initial_capacity == 0)
return _List_construct(NULL, 0, 0, elem_t_size);
u32 initial_size = initial_capacity * elem_t_size;
u32 aligned_capacity = ALIGN_TO(initial_size, sizeof(void*));
return _List_construct(malloc(aligned_capacity), 0, aligned_capacity, elem_t_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);
List_ _List_copy(const List_* src){
assert(src->elem_t_size != 0);
List_ copy = _List_alloc(src->capacity, src->elem_t_size);
if(copy.data != NULL){
memcpy(copy.data, src->data, src->len * src->elem_t_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;
void _List_increaseCapacity(List_* self, u32 len_to_add){
assert(self->elem_t_size != 0);
u32 expanded_len = self->len + len_to_add;
if(self->capacity > expanded_len)
return;
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;
u32 expanded_capacity = self->capacity;
if(expanded_capacity == 0)
expanded_capacity = 32;
while(expanded_capacity < expanded_len){
expanded_capacity *= 2;
}
// if self->data is null, realloc acts like malloc
self->data = realloc(self->data, expanded_capacity * self->elem_t_size);
self->capacity = expanded_capacity;
}
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;
void* _List_expand(List_* self, u32 len_to_add){
assert(self->elem_t_size != 0);
_List_increaseCapacity(self, len_to_add);
u8* empty_cell_ptr = (u8*)self->data + self->len * self->elem_t_size;
self->len += len_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);
void _List_push(List_* self, void* values, u32 len){
assert(self->elem_t_size != 0);
void* empty_cell_ptr = _List_expand(self, len);
memcpy(empty_cell_ptr, values, len * self->elem_t_size);
}
bool List_removeAt_size(List_* self, u32 i, u32 remove_size){
if(i + remove_size >= self->size)
bool _List_tryRemoveAt(List_* self, u32 i, u32 remove_len){
assert(self->elem_t_size != 0);
if(i >= self->len)
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);
if(remove_len + i > self->len)
remove_len = self->len - i;
u32 move_back_n_elements = self->len - i - remove_len;
if(move_back_n_elements > 0){
u32 move_back_size = move_back_n_elements * self->elem_t_size;
u8* dst = (u8*)self->data + i * self->elem_t_size;
u8* src = (u8*)self->data + (i + remove_len) * self->elem_t_size;
memmove(dst, src, move_back_size);
}
self->len -= remove_len;
return true;
}

10
src/errors.c
View File

@@ -11,7 +11,7 @@ Error* Error_create(const char* msg, bool is_msg_on_heap, ErrorCallPos p,
e->is_msg_on_heap = is_msg_on_heap;
e->error_code_page = error_code_page;
e->error_code = error_code;
e->call_stack = List_alloc(ErrorCallPos, 16);
e->call_stack = List_ErrorCallPos_alloc(16);
Error_addCallPos(e, p);
return e;
}
@@ -24,12 +24,12 @@ void Error_free(Error* e){
}
void Error_addCallPos(Error* e, ErrorCallPos p){
List_push(&e->call_stack, ErrorCallPos, p);
List_ErrorCallPos_push(&e->call_stack, p);
}
str Error_toStr(Error* e){
u32 len = List_len(e->call_stack, ErrorCallPos);
StringBuilder b = StringBuilder_alloc(e->msg.size + 80 * len);
u32 len = e->call_stack.len;
StringBuilder b = StringBuilder_alloc(e->msg.len + 80 * len);
StringBuilder_append_str(&b, STR("Catched Error: "));
StringBuilder_append_str(&b, e->msg);
@@ -50,7 +50,7 @@ str Error_toStr(Error* e){
void Error_printAndExit(Error* e){
str e_str = Error_toStr(e);
printfe("\n"FMT_str"\n", e_str.size, e_str.data);
printfe("\n"FMT_str"\n", e_str.len, e_str.data);
free(e_str.data);
Error_free(e);
exit(111);

2
src/filesystem/file.c
View File

@@ -141,7 +141,7 @@ Result(void) file_readWhole(FILE* f, Array(u8)* out_buf){
bool success = false;
try(i64 f_size, i, file_getSize(f));
Array(u8) buf = Array_alloc(u8, f_size);
Array(u8) buf = Array_u8_alloc(f_size);
Defer(if(!success) free(buf.data));
try_void(file_readBytesArray(f, buf));

18
src/filesystem/path.c
View File

@@ -1,36 +1,36 @@
#include "tlibc/filesystem.h"
str path_dirname(str path){
if(path.size == 0)
if(path.len == 0)
return path;
// remove trailing slash (name/)
if(path.data[path.size - 1] == path_sep){
path.size -= 1;
if(path.data[path.len - 1] == path_sep){
path.len -= 1;
}
i32 sepIndex = str_seekCharReverse(path, path_sep, -1);
if(sepIndex < 0)
return STR(".");
path.size = sepIndex;
path.len = sepIndex;
path.isZeroTerminated = false;
return path;
}
str path_basename(str path, bool remove_ext){
if(path.size == 0)
if(path.len == 0)
return path;
// remove trailing slash (name/)
if(path.data[path.size - 1] == path_sep){
path.size -= 1;
if(path.data[path.len - 1] == path_sep){
path.len -= 1;
}
i32 nameIndex = str_seekCharReverse(path, path_sep, -1) + 1;
if((u32)nameIndex != 0){
path.data += nameIndex;
path.size -= nameIndex;
path.len -= nameIndex;
}
if(!remove_ext)
@@ -38,7 +38,7 @@ str path_basename(str path, bool remove_ext){
i32 extIndex = str_seekCharReverse(path, '.', -1);
if(extIndex > 0){
path.size = extIndex;
path.len = extIndex;
path.isZeroTerminated = false;
}
return path;

27
src/string/StringBuilder.c
View File

@@ -8,41 +8,40 @@ void StringBuilder_destroy(StringBuilder* b){
}
str StringBuilder_getStr(StringBuilder* b){
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;
if(b->buffer.len == 0 || b->buffer.data[b->buffer.len - 1] != '\0'){
List_char_push(&b->buffer, '\0');
// '\0' at the end doesn't increase buffer.len
b->buffer.len -= 1;
}
str result = str_construct((char*)b->buffer.data, b->buffer.size, true);
str result = str_construct(b->buffer.data, b->buffer.len, 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);
str a_str = str_construct(a->buffer.data, a->buffer.len, false);
str b_str = str_construct(b->buffer.data, b->buffer.len, false);
return str_equals(a_str, b_str);
}
void StringBuilder_removeFromEnd(StringBuilder* b, u32 count){
if(count < b->buffer.size){
b->buffer.size -= count;
if(count < b->buffer.len){
b->buffer.len -= count;
}
else{
b->buffer.size = 0;
b->buffer.len = 0;
}
}
void StringBuilder_append_char(StringBuilder* b, char c){
List_push(&b->buffer, u8, c);
List_char_push(&b->buffer, c);
}
void StringBuilder_append_str(StringBuilder* b, str s){
if(s.data == NULL)
return;
List_push_size(&b->buffer, s.data, s.size);
List_char_pushMany(&b->buffer, s.data, s.len);
}
void StringBuilder_append_cstr(StringBuilder* b, cstr s){
@@ -78,7 +77,7 @@ void StringBuilder_append_memory(StringBuilder* b, Array(u8) mem, bool uppercase
return;
char buf[8];
for (u32 i=0; i < mem.size; i++) {
for (u32 i=0; i < mem.len; i++) {
sprintf(buf, uppercase ? "%02X" : "%02x", ((u8*)mem.data)[i]);
StringBuilder_append_str(b, str_construct(buf, 2, true));
}

74
src/string/str.c
View File

@@ -2,17 +2,17 @@
#include "tlibc/string/StringBuilder.h"
str str_copy(const str self){
if(self.data == NULL || self.size == 0)
if(self.data == NULL || self.len == 0)
return self;
str copy = str_construct((char*)malloc(self.size + 1), self.size, true);
memcpy(copy.data, self.data, self.size);
copy.data[copy.size] = '\0';
str copy = str_construct((char*)malloc(self.len + 1), self.len, true);
memcpy(copy.data, self.data, self.len);
copy.data[copy.len] = '\0';
return copy;
}
bool str_equals(const str self, const str other){
if(self.size != other.size)
if(self.len != other.len)
return false;
if(self.data == other.data)
return true;
@@ -23,26 +23,26 @@ 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(self.data, other.data, self.len) == 0;
}
str str_reverse(str s){
if(s.data == NULL || s.size == 0)
if(s.data == NULL || s.len == 0)
return s;
str r = str_construct(malloc(s.size), s.size, s.isZeroTerminated);
for(u32 i = 0; i < s.size; i++ )
r.data[i] = s.data[s.size - i - 1];
str r = str_construct(malloc(s.len), s.len, s.isZeroTerminated);
for(u32 i = 0; i < s.len; i++ )
r.data[i] = s.data[s.len - i - 1];
return r;
}
i32 str_seek(const str src, const str fragment, u32 startIndex){
if(src.size == 0 || fragment.size == 0)
if(src.len == 0 || fragment.len == 0)
return -1;
for(u32 i = startIndex; i < src.size - fragment.size + 1; i++){
for(u32 i = startIndex; i < src.len - fragment.len + 1; i++){
for(u32 j = 0;; j++){
if(j == fragment.size)
if(j == fragment.len)
return i;
if(src.data[i + j] != fragment.data[j])
break;
@@ -52,16 +52,16 @@ i32 str_seek(const str src, const str fragment, u32 startIndex){
}
i32 str_seekReverse(const str src, const str fragment, u32 startIndex){
if(src.size == 0 || fragment.size == 0)
if(src.len == 0 || fragment.len == 0)
return -1;
if(startIndex > src.size - 1)
startIndex = src.size - 1;
for(u32 i = startIndex; i >= fragment.size - 1; i--){
if(startIndex > src.len - 1)
startIndex = src.len - 1;
for(u32 i = startIndex; i >= fragment.len - 1; i--){
for(u32 j = 0;; j++){
if(j == fragment.size)
if(j == fragment.len)
return i - j + 1;
if(src.data[i - j] != fragment.data[fragment.size - 1 - j])
if(src.data[i - j] != fragment.data[fragment.len - 1 - j])
break;
}
}
@@ -69,7 +69,7 @@ i32 str_seekReverse(const str src, const str fragment, u32 startIndex){
}
i32 str_seekChar(const str src, char c, u32 startIndex){
for(u32 i = startIndex; i < src.size; i++){
for(u32 i = startIndex; i < src.len; i++){
if(src.data[i] == c)
return i;
}
@@ -77,8 +77,8 @@ i32 str_seekChar(const 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;
if(startIndex > src.len - 1)
startIndex = src.len - 1;
for(u32 i = startIndex; i != (u32)-1; i--){
if(src.data[i] == c)
return i;
@@ -87,36 +87,36 @@ i32 str_seekCharReverse(const str src, char c, u32 startIndex){
}
bool str_startsWith(const str src, const str fragment){
if(src.size < fragment.size)
if(src.len < fragment.len)
return false;
str src_fragment = str_null;
src_fragment.data = src.data;
src_fragment.size = fragment.size;
src_fragment.len = fragment.len;
return str_equals(src_fragment, fragment);
}
bool str_endsWith(const str src, const str fragment){
if(src.size < fragment.size)
if(src.len < fragment.len)
return false;
str src_fragment = str_null;
src_fragment.data = (char*)(src.data + src.size - fragment.size);
src_fragment.size = fragment.size;
src_fragment.data = (char*)(src.data + src.len - fragment.len);
src_fragment.len = fragment.len;
return str_equals(src_fragment, fragment);
}
u32 str_hash32(const str s){
u8* ubuf = (u8*)s.data;
u32 hash=0;
for (u32 i = 0; i < s.size; i++)
for (u32 i = 0; i < s.len; i++)
hash = (hash<<6) + (hash<<16) - hash + ubuf[i];
return hash;
}
str str_toUpper(const str src){
str r = str_copy(src);
for (u32 i = 0; i < r.size; i++){
for (u32 i = 0; i < r.len; i++){
if(char_isLatinLower(r.data[i]))
r.data[i] = r.data[i] - 'a' + 'A';
}
@@ -125,7 +125,7 @@ str str_toUpper(const str src){
str str_toLower(const str src){
str r = str_copy(src);
for (u32 i = 0; i < r.size; i++){
for (u32 i = 0; i < r.len; i++){
if(char_isLatinUpper(r.data[i]))
r.data[i] = r.data[i] - 'A' + 'a';
}
@@ -133,7 +133,7 @@ str str_toLower(const str src){
}
str hex_to_str(Array(u8) buf, bool uppercase){
StringBuilder sb = StringBuilder_alloc(buf.size * 2 + 1);
StringBuilder sb = StringBuilder_alloc(buf.len * 2 + 1);
StringBuilder_append_memory(&sb, buf, uppercase);
return StringBuilder_getStr(&sb);
}
@@ -141,13 +141,13 @@ str hex_to_str(Array(u8) buf, bool uppercase){
void str_trim(str* line, bool set_zero_at_end){
// loop forward
bool stop = false;
while(line->size > 0 && !stop){
while(line->len > 0 && !stop){
char first_char = line->data[0];
switch(first_char){
case '\0': case '\r': case '\n':
case '\t': case ' ':
line->data++;
line->size--;
line->len--;
break;
default:
stop = true;
@@ -157,13 +157,13 @@ void str_trim(str* line, bool set_zero_at_end){
// loop backward
stop = false;
while(line->size > 0 && !stop)
while(line->len > 0 && !stop)
{
char last_char = line->data[line->size - 1];
char last_char = line->data[line->len - 1];
switch(last_char){
case '\0': case '\r': case '\n':
case '\t': case ' ':
line->size--;
line->len--;
break;
default:
stop = true;
@@ -172,7 +172,7 @@ void str_trim(str* line, bool set_zero_at_end){
}
if(set_zero_at_end){
line->data[line->size] = '\0';
line->data[line->len] = '\0';
line->isZeroTerminated = true;
}
}