refactoring

.gitignore

@@ -4,6 +4,10 @@ obj/
 
 # user files
 .old*/
+[Tt]mp/
+[Tt]emp/
+.[Tt]mp/
+.[Tt]emp/
 .vs/
 .vshistory/
 .editorconfig

src/Array/Array.c

@@ -1,27 +0,0 @@
-#include "Array.h"
-
-Array_define(char)
-Array_define(bool)
-Array_define(f32)
-Array_define(f64)
-Array_define(i8)
-Array_define(u8)
-Array_define(i16)
-Array_define(u16)
-Array_define(i32)
-Array_define(u32)
-Array_define(i64)
-Array_define(u64)
-Array_define(Pointer)
-
-Array_define(Unitype)
-
-void Array_Unitype_free_(Array_Unitype* array, bool freeMembers){
-    if(freeMembers) for (u32 i=0; i<array->length; i++)
-        Unitype_free(array->values[i]);
-    if(array->allocatedOnHeap)
-        free(array->values);
-}
-
-void __Array_Unitype_free_(void* ar)
-{ Array_Unitype_free_(ar, true); }

src/Array/Array.h

@@ -1,32 +0,0 @@
-#pragma once
-
-#if __cplusplus
-extern "C" {
-#endif
-
-#include "Array_declare.h"
-#include "Array_define.h"
-
-Array_declare(char)
-Array_declare(bool)
-Array_declare(f32)
-Array_declare(f64)
-Array_declare(i8)
-Array_declare(u8)
-Array_declare(i16)
-Array_declare(u16)
-Array_declare(i32)
-Array_declare(u32)
-Array_declare(i64)
-Array_declare(u64)
-Array_declare(Pointer)
-
-Array_declare(Unitype)
-
-/// use this function instead of auto generated
-void Array_Unitype_free_(Array_Unitype* array, bool freeMembers);
-void __Array_Unitype_free_(void* ar);
-
-#if __cplusplus
-}
-#endif

src/Array/Array_declare.h

@@ -1,39 +0,0 @@
-#pragma once
-
-#if __cplusplus
-extern "C" {
-#endif
-
-#include "../base/base.h"
-
-#define Array_declare(type) \
-STRUCT(Array_##type, \
-    type* values; \
-    u32 length; \
-    bool allocatedOnHeap; \
-) \
-\
-static inline Array_##type Array_##type##_allocValues(u32 length){ \
-    return (Array_##type) { \
-        .values=(type*)malloc(sizeof(type)*length), \
-        .length=length, \
-        .allocatedOnHeap=true \
-    }; \
-} \
-\
-static inline Array_##type Array_##type##_fromBuffer(type* buffer, u32 bufferLength, bool allocatedOnHeap){ \
-    return (Array_##type) { \
-        .values=buffer, \
-        .length=bufferLength, \
-        .allocatedOnHeap=allocatedOnHeap \
-    }; \
-} \
-\
-static inline void Array_##type##_free(Array_##type* array){ \
-    if(array->allocatedOnHeap) \
-        free(array->values); \
-}
-
-#if __cplusplus
-}
-#endif

src/Array/Array_define.h

@@ -1,14 +0,0 @@
-#pragma once
-
-#if __cplusplus
-extern "C" {
-#endif
-
-#include "../base/base.h"
-
-#define Array_define(type) \
-kt_define(Array_##type, (freeMembers_t)Array_##type##_free, NULL);
-
-#if __cplusplus
-}
-#endif

src/Array/README.md

@@ -1,2 +0,0 @@
-# Array struct
-This struct stores array pointer and length.  If you want to use `Array` of some type, it should be declared in header file by macro `Array_declare` and defined in source file by `Array_define`.

src/Autoarr/Autoarr_KVPair_exported.c

@@ -9,8 +9,8 @@ EXPORT void CALL kerep_Autoarr_KVPair_create(u16 max_chunks_count, u16 max_chunk
     *output=Autoarr_create(KVPair, max_chunks_count, max_chunk_length);
 }
 
-EXPORT void CALL kerep_Autoarr_KVPair_free(Autoarr_KVPair* ar){
+EXPORT void CALL kerep_Autoarr_KVPair_destruct(Autoarr_KVPair* ar){
-    Autoarr_free(ar, true);
+    Autoarr_destruct(ar, true);
 }
 
 EXPORT void CALL kerep_Autoarr_KVPair_get(Autoarr_KVPair* ar, u32 index, KVPair* output){

src/Autoarr/Autoarr_Unitype_exported.c

@@ -8,8 +8,8 @@ EXPORT void CALL kerep_Autoarr_Unitype_create(u16 max_chunks_count, u16 max_chun
     *output=Autoarr_create(Unitype, max_chunks_count, max_chunk_length);
 }
 
-EXPORT void CALL kerep_Autoarr_Unitype_free(Autoarr_Unitype* ar){
+EXPORT void CALL kerep_Autoarr_Unitype_destruct(Autoarr_Unitype* ar){
-    Autoarr_free(ar, true);
+    Autoarr_destruct(ar, true);
 }
 
 EXPORT void CALL kerep_Autoarr_Unitype_get(Autoarr_Unitype* ar, u32 index, Unitype* output){

src/Autoarr/Autoarr_declare.h

@@ -32,8 +32,8 @@ STRUCT(Autoarr_##type, \
 ) \
 \
 Autoarr_##type* __Autoarr_##type##_create(u16 max_chunks_count, u16 max_chunk_length); \
-void __Autoarr_##type##_freeWithMembers(Autoarr_##type* ar, bool freePtr); \
+void __Autoarr_##type##_destructWithMembers(Autoarr_##type* ar, bool freePtr); \
-void ____Autoarr_##type##_freeWithMembers(void* ar);
+void ____Autoarr_##type##_destructWithMembers(void* ar);
 
 #define Autoarr(type) Autoarr_##type
 
@@ -47,9 +47,9 @@ void ____Autoarr_##type##_freeWithMembers(void* ar);
     autoarr->functions->getPtr(autoarr,index)
 #define Autoarr_set(autoarr, index, element) \
     autoarr->functions->set(autoarr, index, element)
-#define Autoarr_free(autoarr, freePtr) \
+#define Autoarr_destruct(autoarr, freePtr) \
     autoarr->functions->freeWithMembers(autoarr, freePtr)
-#define Autoarr_freeWithoutMembers(autoarr, freePtr) \
+#define Autoarr_destructWithoutMembers(autoarr, freePtr) \
     autoarr->functions->freeWithoutMembers(autoarr, freePtr)
 #define Autoarr_toArray(autoarr) \
     autoarr->functions->toArray(autoarr)

src/Autoarr/Autoarr_define.h

@@ -8,7 +8,7 @@ extern "C" {
 
 #define Autoarr_define(type, TYPE_IS_PTR) \
 \
-kt_define(Autoarr_##type, ____Autoarr_##type##_freeWithMembers, NULL); \
+kt_define(Autoarr_##type, ____Autoarr_##type##_destructWithMembers, NULL); \
 \
 void __Autoarr_##type##_add(Autoarr_##type* ar, type element){ \
     if(!ar->chunks){ \
@@ -41,14 +41,14 @@ void __Autoarr_##type##_set(Autoarr_##type* ar, u32 index, type element){ \
     ar->chunks[index/ar->max_chunk_length][index%ar->max_chunk_length]=element; \
 } \
 \
-void __Autoarr_##type##_freeWithoutMembers(Autoarr_##type* ar, bool freePtr){ \
+void __Autoarr_##type##_destructWithoutMembers(Autoarr_##type* ar, bool freePtr){ \
     for(u16 i=0; i<ar->chunks_count;i++) \
         free(ar->chunks[i]); \
     free(ar->chunks); \
     if(freePtr) free(ar); \
 } \
 \
-void __Autoarr_##type##_freeWithMembers(Autoarr_##type* ar, bool freePtr){ \
+void __Autoarr_##type##_destructWithMembers(Autoarr_##type* ar, bool freePtr){ \
     if(ktDescriptor_##type.freeMembers!=NULL) { \
         Autoarr_foreach(ar, el,  \
             void* members_ptr=&el; \
@@ -56,10 +56,10 @@ void __Autoarr_##type##_freeWithMembers(Autoarr_##type* ar, bool freePtr){ \
             ktDescriptor_##type.freeMembers(members_ptr); \
         ); \
     } \
-    __Autoarr_##type##_freeWithoutMembers(ar, freePtr);\
+    __Autoarr_##type##_destructWithoutMembers(ar, freePtr); \
 } \
-void ____Autoarr_##type##_freeWithMembers(void* ar){ \
+void ____Autoarr_##type##_destructWithMembers(void* ar){ \
-    __Autoarr_##type##_freeWithMembers((Autoarr_##type*)ar, false); \
+    __Autoarr_##type##_destructWithMembers((Autoarr_##type*)ar, false); \
 } \
 \
 type* __Autoarr_##type##_toArray(Autoarr_##type* ar){ \
@@ -77,8 +77,8 @@ __Autoarr_##type##_functions_list_t __Autoarr_##type##_functions_list={ \
     &__Autoarr_##type##_get, \
     &__Autoarr_##type##_getPtr, \
     &__Autoarr_##type##_set, \
-    &__Autoarr_##type##_freeWithMembers, \
+    &__Autoarr_##type##_destructWithMembers, \
-    &__Autoarr_##type##_freeWithoutMembers, \
+    &__Autoarr_##type##_destructWithoutMembers, \
     &__Autoarr_##type##_toArray \
 }; \
 \

src/DtsodParser/DtsodV24.c

@@ -25,6 +25,6 @@ bool DtsodV24_remove(Hashtable* dtsod, char* key){
 }
 
 // frees memory including memory of elements (hashtables, autoarrs, etc.)
-void DtsodV24_free(Hashtable* dtsod){
+void DtsodV24_destruct(Hashtable* dtsod){
-    Hashtable_free(dtsod);
+    Hashtable_destruct(dtsod);
 }

src/DtsodParser/DtsodV24.h

@@ -25,7 +25,7 @@ bool DtsodV24_contains(Hashtable* dtsod, char* key);
 bool DtsodV24_remove(Hashtable* dtsod, char* key);
 
 // frees memory including memory of elements (hashtables, autoarrs, etc.)
-void DtsodV24_free(Hashtable* dtsod);
+void DtsodV24_destruct(Hashtable* dtsod);
 
 #if __cplusplus
 }

src/DtsodParser/DtsodV24_deserialize.c

@@ -44,16 +44,10 @@ Maybe ERROR_WRONGCHAR(const char c, char* _text, char* text_first, const char* s
         if(!_c) break;
     }
     char errmsg[1024];
-    IFMSC(
+    sprintf_s(errmsg, sizeof(errmsg), "unexpected <%c> at:\n"
-        sprintf_s(errmsg,1024, "unexpected <%c> at:\n"
                     "  \"%s\"\n"
                     "\\___[%s:%d] %s()",
-                        c,errBuf, srcfile,line,funcname),
+                    c,errBuf, srcfile,line,funcname);
-        sprintf(errmsg, "unexpected <%c> at:\n"
-                        "  \"%s\"\n"
-                        " \\___[%s:%d] %s()", 
-                        c,errBuf, srcfile,line,funcname)
-    );
     safethrow(errmsg,;);
 }
 #define safethrow_wrongchar(C, freeMem) { freeMem; return ERROR_WRONGCHAR(C, text, shared->sh_text_first, __FILE__,__LINE__,__func__); }
@@ -146,7 +140,7 @@ Maybe __ReadString(DeserializeSharedData* shared){
         }
     }
 
-    safethrow(ERR_ENDOFSTR, StringBuilder_free(b));
+    safethrow(ERR_ENDOFSTR, StringBuilder_destruct(b));
 }
 #define ReadString() __ReadString(shared)
 
@@ -154,7 +148,7 @@ Maybe __ReadList(DeserializeSharedData* shared){
     Autoarr(Unitype)* list=Autoarr_create(Unitype,ARR_BC,ARR_BL);
     bool readingList=true;
     while (true){
-        try(ReadValue((&readingList)), m_val, Autoarr_free(list, true))
+        try(ReadValue((&readingList)), m_val, Autoarr_destruct(list, true))
             Autoarr_add(list,m_val.value);
         if (!readingList){
             if(Unitype_isUniNull(m_val.value))
@@ -192,10 +186,7 @@ Maybe __ParseValue(DeserializeSharedData* shared, string str){
             char* _c=string_extract(str);
             if(sscanf(_c, IFWIN("%llu", "%lu"), &lu)!=1){
                 char err[64];
-                IFMSC(
+                sprintf_s(err, sizeof(err), "can't parse to int: <%s>", _c);
-                    sprintf_s(err,64,"can't parse to int: <%s>",_c),
-                    sprintf(err,"can't parse to int: <%s>",_c)
-                );
                 safethrow(err,free(_c));
             }
             free(_c);
@@ -208,10 +199,7 @@ Maybe __ParseValue(DeserializeSharedData* shared, string str){
             char* _c=string_extract(str);
             if(sscanf(_c, IFWIN("%lli", "%li"), &li)!=1){
                 char err[64];
-                IFMSC(
+                sprintf_s(err, sizeof(err),"can't parse to int: <%s>",_c);
-                    sprintf_s(err,64,"can't parse to int: <%s>",_c),
-                    sprintf(err,"can't parse to int: <%s>",_c)
-                );
                 safethrow(err,free(_c));
             }
             free(_c);
@@ -242,35 +230,35 @@ Maybe __ReadValue(DeserializeSharedData* shared, bool* readingList){
         case '=': case ':':
         case '}': case '$':
         case '\'':
-            safethrow_wrongchar(c,Unitype_free(value));
+            safethrow_wrongchar(c,Unitype_destruct(&value));
         case '#':;
             char _c=c;
             char* _text=text;
             try(SkipComment(),_,;);
             if(valueStr.length!=0){
                 text=_text;
-                safethrow_wrongchar(_c,Unitype_free(value));
+                safethrow_wrongchar(_c,Unitype_destruct(&value));
             }
             valueStr.ptr=text+1; // skips '\n'
             break;
         case '"':
-            if(valueStr.length!=0) safethrow_wrongchar(c,Unitype_free(value));
+            if(valueStr.length!=0) safethrow_wrongchar(c,Unitype_destruct(&value));
             try(ReadString(),maybeString,;)
                 value=maybeString.value;
             break;
         case '{':
-            if(valueStr.length!=0) safethrow_wrongchar(c,Unitype_free(value));
+            if(valueStr.length!=0) safethrow_wrongchar(c,Unitype_destruct(&value));
             ++text; // skips '{'
-            try(__deserialize(&text,true), val,Unitype_free(value))
+            try(__deserialize(&text,true), val,Unitype_destruct(&value))
                 value=val.value;
             break;
         case '[':
-            if(valueStr.length!=0) safethrow_wrongchar(c,Unitype_free(value));
+            if(valueStr.length!=0) safethrow_wrongchar(c,Unitype_destruct(&value));
-            try(ReadList(),maybeList,Unitype_free(value))
+            try(ReadList(),maybeList,Unitype_destruct(&value))
                 value=maybeList.value;
             break;
         case ']':
-            if(!readingList) safethrow_wrongchar(c,Unitype_free(value));
+            if(!readingList) safethrow_wrongchar(c,Unitype_destruct(&value));
             *readingList=false;
             goto return_value;
         case ';':
@@ -278,14 +266,14 @@ Maybe __ReadValue(DeserializeSharedData* shared, bool* readingList){
             return_value:
             if(valueStr.length!=0){
                 if(!Unitype_isUniNull(value))
-                    safethrow_wrongchar(c,Unitype_free(value));
+                    safethrow_wrongchar(c,Unitype_destruct(&value));
                 try(ParseValue(valueStr),maybeParsed,;)
                     value=maybeParsed.value;
             }
             return SUCCESS(value);
         default:
             if(spaceAfterVal)
-                safethrow_wrongchar(c,Unitype_free(value)); 
+                safethrow_wrongchar(c,Unitype_destruct(&value));
             valueStr.length++;
             break;
     }
@@ -306,12 +294,12 @@ Maybe __deserialize(char** _text, bool _calledRecursively) {
     
     text--;
     while(true){
-        try(ReadName(), maybeName, Hashtable_free(dict))
+        try(ReadName(), maybeName, Hashtable_destruct(dict))
             if(!maybeName.value.VoidPtr) // end of file or '}' in recursive call
                 goto END;
         char* nameCPtr=maybeName.value.VoidPtr;
         try(ReadValue(NULL), val, {
-            Hashtable_free(dict);
+            Hashtable_destruct(dict);
             free(nameCPtr);
         }) {
             if(partOfDollarList){

src/DtsodParser/DtsodV24_exported.c

@@ -45,8 +45,8 @@ EXPORT void CALL kerep_DtsodV24_remove(Hashtable* dtsod, char* key, bool* output
 }
 
 // replaces value with UniNull if key exists in dtsod
-EXPORT void CALL kerep_DtsodV24_free(Hashtable* dtsod){
+EXPORT void CALL kerep_DtsodV24_destruct(Hashtable* dtsod){
-    DtsodV24_free(dtsod);
+    DtsodV24_destruct(dtsod);
 }
 
 EXPORT void CALL kerep_DtsodV24_height(Hashtable* dtsod, u16* heigth){

src/DtsodParser/DtsodV24_serialize.c

@@ -124,7 +124,7 @@ Maybe __serialize(StringBuilder* _b, u8 _tabs, Hashtable* dtsod){
 
 Maybe DtsodV24_serialize(Hashtable* dtsod){
     StringBuilder* sb=StringBuilder_create();
-    try(__serialize(sb,0,dtsod),__, StringBuilder_free(sb));
+    try(__serialize(sb,0,dtsod),__, StringBuilder_destruct(sb));
     char* str=StringBuilder_build(sb).ptr;
     return SUCCESS(UniHeapPtr(char, str));
 }

src/Filesystem/dir.c

@@ -26,9 +26,10 @@ bool dir_exists(const char* path){
 Maybe dir_create(const char* path){
     if (dir_exists(path))
         return MaybeNull;
-    char* parentDir=path_parentDir(path);
+    LinearAllocator _al; LinearAllocator_construct(&_al, 128);
+    allocator_ptr al=&_al.base;
+    char* parentDir=path_parentDir(al, path);
     dir_create(parentDir);
-    free(parentDir);
 #if KFS_USE_WINDOWS_H
     if(!CreateDirectory(path, NULL))
 #else
@@ -36,12 +37,10 @@ Maybe dir_create(const char* path){
 #endif
     {
         char err[512];
-        IFWIN(
+        sprintf_s(err, sizeof(err), "can't create dicectory <%s>", path);
-            sprintf_s(err, 512, "can't create dicectory <%s>", path),
-            sprintf(err, "can't create dicectory <%s>", path));
         safethrow(err,;);
     }
-
+    LinearAllocator_destruct(&_al);
     return MaybeNull;
 }
 

src/Filesystem/file.c

@@ -2,9 +2,9 @@
 #include "../String/StringBuilder.h"
 #include "io_includes.h"
 
-void __file_freeMembers(void* _f){ fclose((FileHandle)_f); }
+void __file_destructMembers(void* _f){ fclose((FileHandle)_f); }
 
-kt_define(FileHandle, __file_freeMembers, NULL)
+kt_define(FileHandle, __file_destructMembers, NULL)
 
 bool file_exists(const char* path){
     if(path[0]=='.'){
@@ -50,8 +50,11 @@ char* FileOpenMode_toStr(FileOpenMode m){
 
 Maybe file_open(const char* path, FileOpenMode mode){
     FileHandle file=fopen(path, FileOpenMode_toStr(mode));
+    LinearAllocator _al; LinearAllocator_construct(&_al, 128);
+    allocator_ptr al=&_al.base;
     if(!file)
-        safethrow(cptr_concat("can't open file ", (char*)path),;);
+        safethrow(cptr_concat(al, "can't open file ", (char*)path),;);
+    LinearAllocator_destruct(&_al);
     return SUCCESS(UniHeapPtr(FileHandle,file));
 }
 
@@ -118,7 +121,7 @@ Maybe file_readAll(FileHandle file, char** allBytes){
         rezult=fgetc(file);
         if(rezult==EOF){
             if(ferror(file))
-                safethrow(ERR_IO, StringBuilder_free(sb));
+                safethrow(ERR_IO, StringBuilder_destruct(sb));
             break;
         }
         buffer[i%sizeof(buffer)]=(char)rezult;

src/Filesystem/file.h

@@ -5,7 +5,6 @@ extern "C" {
 #endif
 
 #include "../base/base.h"
-#include "../Array/Array.h"
 #include "../String/string.h"
 
 typedef FILE* FileHandle;

src/Filesystem/path.c

@@ -1,8 +1,8 @@
 #include "filesystem.h"
 
-char* __path_concat(u32 n, ...){
+char* __path_concat(allocator_ptr al, u32 n, ...){
-    char** parts=(char**)malloc(n*sizeof(char*));
+    char** parts=(char**)allocator_alloc(al, n*sizeof(char*));
-    u32* lengths=malloc(n*sizeof(u32));
+    u32* lengths=allocator_alloc(al, n*sizeof(u32));
     u32 totalLength=0;
 
     // reading args from va_list
@@ -18,7 +18,7 @@ char* __path_concat(u32 n, ...){
     va_end(vl);
 
     // allocating memory for output value
-    char* totality=malloc(totalLength+1);
+    char* totality=allocator_alloc(al, totalLength+1);
     const char* output=totality;
     totality[totalLength]=0;
     
@@ -32,13 +32,13 @@ char* __path_concat(u32 n, ...){
     }
     memcpy(totality, parts[k], lengths[k]);
 
-    free(parts);
+    allocator_free(al, lengths);
-    free(lengths);
+    allocator_free(al, parts);
     return output;
 }
 
-char* path_fixSeparators(const char* path){
+char* path_fixSeparators(allocator_ptr al, const char* path){
-    char* pathCopy=cptr_copy(path);
+    char* pathCopy=cptr_copy(al, path);
     char c;
     while((c=*pathCopy)){
         if(c==path_notSep)
@@ -49,13 +49,16 @@ char* path_fixSeparators(const char* path){
 }
 
 Maybe path_throwIfEscapes(const char* path){
+    LinearAllocator _al; LinearAllocator_construct(&_al, 128);
+    allocator_ptr al=&_al.base;
     if(cptr_contains(path,".."))
-        safethrow(cptr_concat("path <",path,"> uses <..>, that's not allowed"),);
+        safethrow(cptr_concat(al, "path <",path,"> uses <..>, that's not allowed"),);
+    LinearAllocator_destruct(&_al);
     return MaybeNull;
 }
 
-char* path_parentDir(char* dir){
+char* path_parentDir(allocator_ptr al, char* dir){
-    char* copy=cptr_copy(dir);
+    char* copy=cptr_copy(al, dir);
     i32 length=cptr_length(copy);
     i32 i=cptr_lastIndexOfChar(copy,path_sep);
     if(i!=-1 && i==length-1){
@@ -63,8 +66,8 @@ char* path_parentDir(char* dir){
         i=cptr_lastIndexOfChar(copy,path_sep);
     }
     if(i==-1){
-        free(copy);
+        allocator_free(al, copy);
-        copy=malloc(2);
+        copy=allocator_alloc(al, 2);
         copy[0]='.';
         copy[1]=0;
     }
@@ -72,7 +75,7 @@ char* path_parentDir(char* dir){
 }
 
 
-char* path_basename(char* path, bool with_extension){
+char* path_basename(allocator_ptr al, char* path, bool with_extension){
     i32 nameIndex=cptr_lastIndexOfChar(path, path_sep)+1;
     string rezult=string_fromCptr(path+nameIndex);
     if(!with_extension){

src/Filesystem/path.h

@@ -14,17 +14,17 @@ static const char path_sep='/';
 static const char path_notSep='\\';
 #endif
 
-char* __path_concat(u32 n, ...);
+char* __path_concat(allocator_ptr al, u32 n, ...);
 /// @brief merges path parts together and puts <path_sep> between them
 /// @return new cstr
-#define path_concat(PATH_PARTS...) __path_concat(count_args(PATH_PARTS), PATH_PARTS)
+#define path_concat(ALLOCATOR, PATH_PARTS...) __path_concat(ALLOCATOR, count_args(PATH_PARTS), PATH_PARTS)
 
 /// @brief fixes path separators
 /// @param cstr where can be <path_notSep>
 /// @return new cstr with correct separators
-char* path_fixSeparators(const char* path);
+char* path_fixSeparators(allocator_ptr al, const char* path);
 
-#define path_resolve(PATH_PARTS...) path_fixSeparators(path_concat(PATH_PARTS))
+#define path_resolve(ALLOCATOR, PATH_PARTS...) path_fixSeparators(ALLOCATOR, path_concat(ALLOCATOR, PATH_PARTS))
 
 /// @brief calls safethrow() if finds escape sequense in path
 /// @param path cstr where can be <..>
@@ -32,10 +32,10 @@ char* path_fixSeparators(const char* path);
 Maybe path_throwIfEscapes(const char* path);
 
 ///@return  path of parent dir
-char* path_parentDir(char* path);
+char* path_parentDir(allocator_ptr al, char* path);
 
 ///@return file name
-char* path_basename(char* path, bool with_extension);
+char* path_basename(allocator_ptr al, char* path, bool with_extension);
 
 #if __cplusplus
 }

src/Hashtable/Hashtable.c

@@ -1,6 +1,6 @@
 #include "Hashtable.h"
 
-kt_define(Hashtable, __Hashtable_free, NULL);
+kt_define(Hashtable, __Hashtable_destruct, NULL);
 
 // amount of rows
 static const u16 HT_HEIGHTS[]={17,61,257,1021,4099,16381,65521};
@@ -19,14 +19,14 @@ Hashtable* Hashtable_create(){
     return ht;
 }
 
-void __Hashtable_free(void* _ht){
+void __Hashtable_destruct(void* _ht){
     Hashtable* ht=_ht;
     for(u16 i=0;i<HT_HEIGHTS[ht->hein];i++)
-        Autoarr_free(ht->rows[i], true);
+        Autoarr_destruct(ht->rows[i], true);
     free(ht->rows);
 }
-void Hashtable_free(Hashtable* ht){
+void Hashtable_destruct(Hashtable* ht){
-    __Hashtable_free(ht);
+    __Hashtable_destruct(ht);
     free(ht);
 }
 
@@ -51,7 +51,7 @@ void Hashtable_expand(Hashtable* ht){
         }
         // there is no need to free array values, because they are copied into new array
         // so dont replace this incorrect auto-generated function
-        Autoarr_freeWithoutMembers(ar, true);
+        Autoarr_destructWithoutMembers(ar, true);
     }
 
     free(ht->rows);
@@ -68,7 +68,7 @@ Autoarr(KVPair)* getrow(Hashtable* ht, char* key, bool can_expand){
 }
 
 /// @param key must be heap allocated
-/// Hashtable_free will free this pointer
+/// Hashtable_destruct will free this pointer
 void Hashtable_add(Hashtable* ht, char* key, Unitype u){
     KVPair p={ .key=key, .value=u };
     Autoarr_add(getrow(ht,key,true),p);

src/Hashtable/Hashtable.h

@@ -14,8 +14,8 @@ STRUCT(Hashtable,
 )
 
 Hashtable* Hashtable_create();
-void Hashtable_free(Hashtable* ht);
+void Hashtable_destruct(Hashtable* ht);
-void __Hashtable_free(void* ht);
+void __Hashtable_destruct(void* ht);
 
 // amount of rows
 u16 Hashtable_height(Hashtable* ht);

src/Hashtable/KeyValuePair.c

@@ -1,15 +1,15 @@
 #include "KeyValuePair.h"
 
-kt_define(KVPair, __KVPair_free, NULL);
+kt_define(KVPair, __KVPair_destruct, NULL);
 
 Autoarr_define(KVPair, false)
 
 // proper way to clean a KVP
-void KVPair_free(KVPair p){
+void KVPair_destruct(KVPair p){
     free(p.key);
-    Unitype_free(p.value);
+    Unitype_destruct(&p.value);
 }
-void __KVPair_free(void* p){ KVPair_free(*(KVPair*)p); }
+void __KVPair_destruct(void* p){ KVPair_destruct(*(KVPair*)p); }
 
 void printkvp(KVPair p){
     kprintf("{\"%s\", ",p.key);

src/Hashtable/KeyValuePair.h

@@ -15,8 +15,8 @@ STRUCT(KVPair,
 Autoarr_declare(KVPair)
 
 // proper way to clean a KVP
-void KVPair_free(KVPair p);
+void KVPair_destruct(KVPair p);
-void __KVPair_free(void* p);
+void __KVPair_destruct(void* p);
 
 void printkvp(KVPair p);
 

src/LinkedList/LinkedList.h

@@ -16,7 +16,7 @@ extern "C" {
 #define LLNode_create(TYPE, VALUE) LLNode_##TYPE##_create(VALUE)
 
 #define LinkedList_create(TYPE) LinkedList_##TYPE##_create()
-#define LinkedList_free(LLIST)  ({ LLIST->_functions->freeMembers(LLIST); free(LLIST); })
+#define LinkedList_destruct(LLIST)  ({ LLIST->_functions->freeMembers(LLIST); free(LLIST); })
 
 
 void LinkedList_addToBeginning(void* _llist, void* _new_node);

src/LinkedList/LinkedList_declare.h

@@ -12,7 +12,7 @@ STRUCT(LLNode(TYPE), \
 ) \
 \
 LLNode(TYPE)* LLNode_##TYPE##_create(TYPE value); \
-void LLNode_##TYPE##_free(LLNode(TYPE)* node, bool free_value);
+void LLNode_##TYPE##_destruct(LLNode(TYPE)* node, bool free_value);
 
 
 #define LinkedList_declare(TYPE)\

src/LinkedList/LinkedList_define.h

@@ -14,19 +14,19 @@ LLNode(TYPE)* LLNode_##TYPE##_create(TYPE value){ \
     return node; \
 } \
 \
-void LLNode_##TYPE##_freeMembers(void* _node){ \
+void LLNode_##TYPE##_destructMembers(void* _node){ \
     LLNode(TYPE)* node=(LLNode(TYPE)*)_node; \
     void* value_ptr=&node->value; \
     if(TYPE_IS_PTR) value_ptr=*(TYPE**)value_ptr; \
     ktDescriptor_##TYPE.freeMembers(value_ptr); \
 } \
 \
-void LLNode_##TYPE##_free(LLNode(TYPE)* node, bool free_value){ \
+void LLNode_##TYPE##_destruct(LLNode(TYPE)* node, bool free_value){ \
-    if(free_value) LLNode_##TYPE##_freeMembers(node); \
+    if(free_value) LLNode_##TYPE##_destructMembers(node); \
     free(node); \
 } \
 \
-kt_define(LLNode_##TYPE, LLNode_##TYPE##_freeMembers, NULL)
+kt_define(LLNode_##TYPE, LLNode_##TYPE##_destructMembers, NULL)
 
 
 #define LinkedList_define(TYPE, VALUE_IS_PTR)\
@@ -41,10 +41,10 @@ LinkedList(TYPE)* LinkedList_##TYPE##_create(){ \
     return l; \
 } \
 \
-void LinkedList_##TYPE##_freeMembers(void* _l){ \
+void LinkedList_##TYPE##_destructMembers(void* _l){ \
     LinkedList(TYPE)* l=(LinkedList(TYPE)*)_l; \
     if(l->first_node!=NULL) \
-        LinkedList_foreach(l, node, LLNode_##TYPE##_free(node, true)); \
+        LinkedList_foreach(l, node, LLNode_##TYPE##_destruct(node, true)); \
     l->first_node=NULL; l->last_node=NULL; l->count=0; \
 } \
 \
@@ -55,7 +55,7 @@ void LinkedList_##TYPE##_removePrev(LinkedList(TYPE)* llist, LLNode(TYPE)* nextN
     nextNode->prev=prevNode; \
     prevNode->next=nextNode; \
     if(freeRemoved) \
-        LLNode_##TYPE##_free(removedNode, true); \
+        LLNode_##TYPE##_destruct(removedNode, true); \
 } \
 \
 void LinkedList_##TYPE##_removeNext(LinkedList(TYPE)* llist, LLNode(TYPE)* prevNode, bool freeRemoved){ \
@@ -65,16 +65,16 @@ void LinkedList_##TYPE##_removeNext(LinkedList(TYPE)* llist, LLNode(TYPE)* prevN
     prevNode->next=nextNode; \
     nextNode->prev=prevNode; \
     if(freeRemoved) \
-        LLNode_##TYPE##_free(removedNode, true); \
+        LLNode_##TYPE##_destruct(removedNode, true); \
 } \
 \
 LinkedList_##TYPE##_functions_t _LinkedList_##TYPE##_functions={ \
-    .freeMembers=LinkedList_##TYPE##_freeMembers, \
+    .freeMembers=LinkedList_##TYPE##_destructMembers, \
     .removePrev=LinkedList_##TYPE##_removePrev, \
     .removeNext=LinkedList_##TYPE##_removeNext \
 }; \
 \
-kt_define(LinkedList_##TYPE, LinkedList_##TYPE##_freeMembers, NULL)
+kt_define(LinkedList_##TYPE, LinkedList_##TYPE##_destructMembers, NULL)
 
 
 #if __cplusplus

src/SearchTree/SearchTree.c

@@ -1,6 +1,6 @@
 #include "SearchTree.h"
 
-kt_define(STNode, __STNode_free, NULL);
+kt_define(STNode, __STNode_destruct, NULL);
 
 STNode* STNode_create(){
     STNode* node=malloc(sizeof(STNode));
@@ -9,7 +9,7 @@ STNode* STNode_create(){
     return node;
 }
 
-void __STNode_free(void* _node){
+void __STNode_destruct(void* _node){
     STNode* node=_node;
     if (!node) throw(ERR_NULLPTR);
     if(node->branches){
@@ -22,7 +22,7 @@ void __STNode_free(void* _node){
                         for(u8 rem=0;rem<4;rem++){
                             STNode* ptrrem=ptrn4[rem];
                             if(ptrrem)
-                                STNode_free(ptrrem);
+                                STNode_destruct(ptrrem);
                         }
                         free(ptrn4);
                     }
@@ -33,10 +33,10 @@ void __STNode_free(void* _node){
         free(node->branches);
     }
     if(node->value.VoidPtr)
-        Unitype_free(node->value);
+        Unitype_destruct(&node->value);
 }
-void STNode_free(STNode* node){
+void STNode_destruct(STNode* node){
-    __STNode_free(node);
+    __STNode_destruct(node);
     free(node);
 }
 

src/SearchTree/SearchTree.h

@@ -13,8 +13,8 @@ STRUCT(STNode,
 )
 
 STNode* STNode_create();
-void STNode_free(STNode* node);
+void STNode_destruct(STNode* node);
-void __STNode_free(void* node);
+void __STNode_destruct(void* node);
 
 void ST_push(STNode* node, char* key, Unitype value);
 void ST_pushString(STNode* node, string key, Unitype value);

src/String/StringBuilder.c

@@ -1,6 +1,6 @@
 #include "StringBuilder.h"
 
-kt_define(StringBuilder, __StringBuilder_free, NULL);
+kt_define(StringBuilder, __StringBuilder_destruct, NULL);
 
 #define BL_C 32
 #define BL_L 1024
@@ -17,7 +17,7 @@ void complete_buf(StringBuilder* b){
         str.ptr[i++]=c;
     );
     Autoarr_add(b->compl_bufs,str);
-    Autoarr_free(b->curr_buf, true);
+    Autoarr_destruct(b->curr_buf, true);
     b->curr_buf=Autoarr_create(i8,BL_C,BL_L);
 }
 
@@ -34,13 +34,13 @@ StringBuilder* StringBuilder_create(){
     return b;
 }
 
-void __StringBuilder_free(void* _b){
+void __StringBuilder_destruct(void* _b){
     StringBuilder* b=_b;
-    if(b->compl_bufs) Autoarr_free(b->compl_bufs, true);
+    if(b->compl_bufs) Autoarr_destruct(b->compl_bufs, true);
-    Autoarr_free(b->curr_buf, true);
+    Autoarr_destruct(b->curr_buf, true);
 }
-void StringBuilder_free(StringBuilder* b){
+void StringBuilder_destruct(StringBuilder* b){
-    __StringBuilder_free(b);
+    __StringBuilder_destruct(b);
     free(b);
 }
 
@@ -58,7 +58,7 @@ string StringBuilder_build(StringBuilder* b){
             str.ptr[i++]=cs.ptr[n];
         free(cs.ptr);
     );
-    StringBuilder_free(b);
+    StringBuilder_destruct(b);
     return str;
 }
 
@@ -139,9 +139,6 @@ void StringBuilder_append_u64(StringBuilder* b, u64 a){
 void StringBuilder_append_f64(StringBuilder* b, f64 a){
     try_complete_buf(b);
     char buf[32];
-    IFMSC(
+    sprintf_s(buf, sizeof(buf), "%lf", a);
-        sprintf_s(buf,32,"%lf",a),
-        sprintf(buf,"%lf",a)
-    );
     curr_buf_add_string(b, (string){.ptr=buf, .length=cptr_length(buf)});
 }

src/String/StringBuilder.h

@@ -13,8 +13,8 @@ STRUCT(StringBuilder,
 )
 
 StringBuilder* StringBuilder_create(void);
-void StringBuilder_free(StringBuilder* b);
+void StringBuilder_destruct(StringBuilder* b);
-void __StringBuilder_free(void* b);
+void __StringBuilder_destruct(void* b);
 // Joins all strings from compl_bufs.
 // Returns zero-terminated string.
 // No need to call string_extract()!

src/String/string.c

@@ -1,8 +1,7 @@
 #include "string.h"
 
 kt_define(string, NULL, NULL);
-Array_define(string)
+Autoarr_define(string, false);
-Autoarr_define(string, false)
 
 // copies str content to new char pointer value (adding '\0' at the end)
 char* string_extract(string str){

src/String/string.h

@@ -5,7 +5,6 @@ extern "C" {
 #endif
 
 #include "../base/base.h"
-#include "../Array/Array.h"
 #include "../Autoarr/Autoarr.h"
 
 // my fixed length string struct
@@ -15,7 +14,6 @@ STRUCT(string,
     u64 length;  // amount of chars in ptr value
 )
 
-Array_declare(string)
 Autoarr_declare(string)
 
 static const string stringNull={NULL,0};

src/base/cptr.c

@@ -11,16 +11,16 @@ u32 cptr_length(const char* str){
 }
 
 // allocates new char[] and copies src there
-char* cptr_copy(const char* src){
+char* cptr_copy(allocator_ptr al, const char* src){
     u32 len=cptr_length(src)+1;
-    char* dst=malloc(len);
+    char* dst=allocator_alloc(al, len);
     memcpy(dst, src, len);
     return dst;
 }
 
 // multiplies char n times
-char* char_multiply(char c, u32 n){
+char* char_multiply(allocator_ptr al, char c, u32 n){
-    char* rez=malloc(n+1);
+    char* rez=allocator_alloc(al, n+1);
     rez[n]=0;
     while(n--!=0)
         rez[n]=c;
@@ -130,9 +130,9 @@ i32 cptr_seekCharReverse(const char* src, char fragment, u32 startIndex, u32 see
     return -1;
 }
 
-char* __cptr_concat(u32 n, ...){
+char* __cptr_concat(allocator_ptr al, u32 n, ...){
-    char** strs=(char**)malloc(n*sizeof(char*));
+    char** strs=(char**)allocator_alloc(al, n*sizeof(char*));
-    u32* lengths=malloc(n*sizeof(u32));
+    u32* lengths=allocator_alloc(al, n*sizeof(u32));
     u32 totalLength=0;
 
     // reading args from va_list
@@ -148,7 +148,7 @@ char* __cptr_concat(u32 n, ...){
     va_end(vl);
 
     // allocating memory for output value
-    char* totality=malloc(totalLength+1);
+    char* totality=allocator_alloc(al, totalLength+1);
     char* output=totality;
     totality[totalLength]=0;
     
@@ -163,26 +163,26 @@ char* __cptr_concat(u32 n, ...){
     return output;
 }
 
-char* cptr_toLower(const char* src) {
+char* cptr_toLower(allocator_ptr al, const char* src) {
     u32 length=cptr_length(src);
-    char *p=malloc(length+1);
+    char *p=allocator_alloc(al, length+1);
     p[length]=0;
     for(u32 i=0; i<length; i++)
         p[i]=tolower(src[i]);
     return p;
 }
 
-char* cptr_toUpper(const char* src) {
+char* cptr_toUpper(allocator_ptr al, const char* src) {
     u32 length=cptr_length(src);
-    char *p=malloc(length+1);
+    char *p=allocator_alloc(al, length+1);
     p[length]=0;
     for(u32 i=0; i<length; i++)
         p[i]=toupper(src[i]);
     return p;
 }
 
-char* cptr_replaceCharIn(const char* src, char c_old, char c_new, u32 startIndex, u32 seekLength){
+char* cptr_replaceCharIn(allocator_ptr al, const char* src, char c_old, char c_new, u32 startIndex, u32 seekLength){
-    char* rzlt=cptr_copy(src);
+    char* rzlt=cptr_copy(al, src);
     for(u32 i=startIndex; i!=seekLength && src[i]!=0; i++){
         if(src[i]==c_old)
             rzlt[i]=c_new;
@@ -190,7 +190,7 @@ char* cptr_replaceCharIn(const char* src, char c_old, char c_new, u32 startIndex
     return rzlt;
 }
 
-char* cptr_replaceIn(const char* src, const char* str_old, const char* str_new, u32 startIndex, u32 seekLength){
+char* cptr_replaceIn(allocator_ptr al, const char* src, const char* str_old, const char* str_new, u32 startIndex, u32 seekLength){
     StringBuilder* sb=StringBuilder_create();
     const u32 str_old_len=cptr_length(str_old);
     const u32 str_new_len=cptr_length(str_new);

src/base/cptr.h

@@ -5,12 +5,13 @@ extern "C" {
 #endif
 
 #include "std.h"
+#include "memory/allocator_base.h"
 
 // returns length of char buffer (without \0)
 u32 cptr_length(const char* str);
 
 // allocates new char[] and copies src there
-char* cptr_copy(const char* src);
+char* cptr_copy(allocator_ptr al, const char* src);
 
 bool cptr_equals(const char* key0, const char* key1);
 
@@ -19,7 +20,7 @@ bool cptr_startsWith(const char* src, const char* fragment);
 bool cptr_endsWith(const char* src, const char* fragment);
 
 // multiplies char n times
-char* char_multiply(char c, u32 n);
+char* char_multiply(allocator_ptr al, char c, u32 n);
 
 /// @param startIndex 0 ... src length
 /// @param seekLength 0 ... -1
@@ -66,26 +67,26 @@ static inline bool cptr_contains(const char* src, const char* fragment){
     return cptr_seek(src, fragment, 0, -1) +1;
 }
 
-char* __cptr_concat(u32 n, ...);
+char* __cptr_concat(allocator_ptr al, u32 n, ...);
-#define cptr_concat(STR...) __cptr_concat(count_args(STR), STR)
+#define cptr_concat(ALLOCATOR, STR...) __cptr_concat(ALLOCATOR, count_args(STR), STR)
 
-char* cptr_toLower(const char* src);
+char* cptr_toLower(allocator_ptr al, const char* src);
-char* cptr_toUpper(const char* src);
+char* cptr_toUpper(allocator_ptr al, const char* src);
 
 /// @param startIndex 0 ... src length
 /// @param seekLength 0 ... -1
 /// @return <src> with <str_old> replaced by <str_new> or empty cstring if <str_old> not found
-char* cptr_replaceIn(const char* src, const char* str_old, const char* str_new, u32 startIndex, u32 seekLength);
+char* cptr_replaceIn(allocator_ptr al, const char* src, const char* str_old, const char* str_new, u32 startIndex, u32 seekLength);
 /// @param startIndex 0 ... src length
 /// @param seekLength 0 ... -1
 /// @return <src> with <c_old> replaced by <c_new> or empty cstring if <str_old> not found
-char* cptr_replaceCharIn(const char* src, char c_old, char c_new, u32 startIndex, u32 seekLength);
+char* cptr_replaceCharIn(allocator_ptr al, const char* src, char c_old, char c_new, u32 startIndex, u32 seekLength);
 
-static inline char* cptr_replace(const char* src, const char* str_old, const char* str_new)
+static inline char* cptr_replace(allocator_ptr al, const char* src, const char* str_old, const char* str_new)
-{ return cptr_replaceIn(src, str_old, str_new, 0, -1); }
+{ return cptr_replaceIn(al, src, str_old, str_new, 0, -1); }
 
-static inline char* cptr_replaceChar(const char* src, char c_old, char c_new)
+static inline char* cptr_replaceChar(allocator_ptr al, const char* src, char c_old, char c_new)
-{ return cptr_replaceCharIn(src, c_old, c_new, 0, -1); }
+{ return cptr_replaceCharIn(al, src, c_old, c_new, 0, -1); }
 
 #if __cplusplus
 }

src/base/errors.c

@@ -26,27 +26,21 @@ char* errname(ErrorId err){
 char* __genErrMsg(const char* errmsg, const char* srcfile, i32 line, const char* funcname){
     size_t bufsize=ERRMSG_MAXLENGTH;
     char* rezult=malloc(bufsize);
-    IFMSC(
+    sprintf_s(rezult,bufsize,"[%s:%d] %s() throwed error: %s",srcfile,line,funcname,errmsg);
-        sprintf_s(rezult,bufsize,"[%s:%d] %s() throwed error: %s",srcfile,line,funcname,errmsg),
-        sprintf(rezult,"[%s:%d] %s() throwed error: %s",srcfile,line,funcname,errmsg)
-    );
     return rezult;
 }
 
 char* __extendErrMsg(const char* errmsg, const char* srcfile, i32 line, const char* funcname){
     size_t bufsize=cptr_length(errmsg)+ERRMSG_MAXLENGTH;
     char* rezult=malloc(bufsize);
-    IFMSC(
+    sprintf_s(rezult,bufsize,"%s\n \\___[%s:%d] %s()",errmsg,srcfile,line,funcname);
-        sprintf_s(rezult,bufsize,"%s\n \\___[%s:%d] %s()",errmsg,srcfile,line,funcname),
-        sprintf(rezult,"%s\n \\___[%s:%d] %s()",errmsg,srcfile,line,funcname)
-    );
     free(errmsg);
     return rezult;
 }
 
-void Maybe_free(Maybe e){
+void Maybe_destruct(Maybe e){
     free(e.errmsg);
-    Unitype_free(e.value);
+    Unitype_destruct(&e.value);
 }
 
 void printMaybe(Maybe e){

src/base/errors.h

@@ -29,7 +29,7 @@ STRUCT(Maybe,
 //                            .value  .errmsg
 #define MaybeNull (Maybe){UniNull, NULL}
 
-void Maybe_free(Maybe e);
+void Maybe_destruct(Maybe e);
 void printMaybe(Maybe e);
 
 

src/base/memory/CstdAllocator.c

@@ -1,12 +1,12 @@
 #include "allocators_internal.h"
 
-void* CstdAllocator_alloc(allocator_t* self, size_t size){
+void* CstdAllocator_alloc(allocator_ptr self, size_t size){
-    assert(size>0);
+    // assert(size>0);
     return malloc(size);
 }
 
-void CstdAllocator_free(allocator_t* self, void* ptr){
+void CstdAllocator_free(allocator_ptr self, void* ptr){
-    assert(ptr!=NULL);
+    // assert(ptr!=NULL);
     free(ptr);
 }
 

src/base/memory/LinearAllocator.c

@@ -30,7 +30,7 @@ __attribute__ ((noinline)) void* __alloc_new_chunk(LinearAllocator* self, size_t
     return curr_chunk->data;
 }
 
-void* LinearAllocator_alloc(allocator_t* _self, size_t size){
+void* LinearAllocator_alloc(allocator_ptr _self, size_t size){
     // assert(_self!=NULL);
     // assert(size>0);
     LinearAllocator* self = (LinearAllocator*)_self;
@@ -55,7 +55,7 @@ void* LinearAllocator_alloc(allocator_t* _self, size_t size){
     }
 }
 
-void LinearAllocator_free(allocator_t* _self, void* ptr){
+void LinearAllocator_free(allocator_ptr _self, void* ptr){
     // LinearAllocator can't free pointers
 }
 

src/base/memory/StackingAllocator.c

@@ -8,7 +8,7 @@ typedef struct {
     size_t data_size;
 } AllocationHeader;
 
-void* StackingAllocator_alloc(allocator_t* _self, size_t size){
+void* StackingAllocator_alloc(allocator_ptr _self, size_t size){
     assert(_self!=NULL);
     assert(size>0);
     StackingAllocator* self = (StackingAllocator*)_self;
@@ -23,7 +23,7 @@ void* StackingAllocator_alloc(allocator_t* _self, size_t size){
     return data_ptr;
 }
 
-void StackingAllocator_free(allocator_t* _self, void* data_ptr){
+void StackingAllocator_free(allocator_ptr _self, void* data_ptr){
     assert(_self!=NULL);
     assert(data_ptr!=NULL);
     StackingAllocator* self = (StackingAllocator*)_self;

src/base/memory/allocator_base.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../std.h"
+
+///////////////////////////////////////////
+//       MemoryAllocator interface       //
+///////////////////////////////////////////
+
+typedef struct MemoryAllocator* allocator_ptr;
+
+typedef void* (*alloc_t)(allocator_ptr, size_t size);
+typedef void (*free_t)(allocator_ptr, void* ptr);
+
+typedef struct MemoryAllocator {
+    alloc_t alloc_f;
+    free_t free_f;
+} MemoryAllocator;
+
+#define allocator_alloc(ALLOCATOR, SIZE) \
+    ((allocator_ptr)ALLOCATOR)->alloc_f(ALLOCATOR, SIZE)
+#define allocator_free(ALLOCATOR, PTR) \
+    ((allocator_ptr)ALLOCATOR)->free_f(ALLOCATOR, PTR)
+#define allocator_destruct(ALLOCATOR) \
+    ((allocator_ptr)ALLOCATOR)->destruct_f(ALLOCATOR)
+
+void* allocator_transfer(allocator_ptr src, allocator_ptr dest, void* data, size_t data_size);
+
+#ifdef __cplusplus
+}
+#endif

src/base/memory/allocators.c

@@ -1,6 +1,6 @@
 #include "memory.h"
 
-void* allocator_transfer(allocator_t* src, allocator_t* dest, void* data, size_t data_size)
+void* allocator_transfer(allocator_ptr src, allocator_ptr dest, void* data, size_t data_size)
 {
     void* transfered=allocator_alloc(dest, data_size); 
     memcpy(transfered, data, data_size);

src/base/memory/allocators.h

@@ -6,30 +6,7 @@ extern "C" {
 
 #include "../std.h"
 #include "../type_system/ktDescriptor.h"
-
+#include "allocator_base.h"
-///////////////////////////////////////////
-//       MemoryAllocator interface       //
-///////////////////////////////////////////
-
-typedef struct MemoryAllocator allocator_t;
-
-typedef void* (*alloc_t)(allocator_t*, size_t size);
-typedef void (*free_t)(allocator_t*, void* ptr);
-
-typedef struct MemoryAllocator {
-    alloc_t alloc_f;
-    free_t free_f;
-} allocator_t;
-
-#define allocator_alloc(ALLOCATOR, SIZE) \
-    ((allocator_t*)ALLOCATOR)->alloc_f(ALLOCATOR, SIZE)
-#define allocator_free(ALLOCATOR, PTR) \
-    ((allocator_t*)ALLOCATOR)->free_f(ALLOCATOR, PTR)
-#define allocator_destruct(ALLOCATOR) \
-    ((allocator_t*)ALLOCATOR)->destruct_f(ALLOCATOR)
-
-void* allocator_transfer(allocator_t* src, allocator_t* dest, void* data, size_t data_size);
-
 
 ///////////////////////////////////////////
 //             CstdAllocator             //
@@ -38,7 +15,7 @@ void* allocator_transfer(allocator_t* src, allocator_t* dest, void* data, size_t
 ///////////////////////////////////////////
 
 STRUCT(CstdAllocator,
-    allocator_t base;
+    MemoryAllocator base;
 );
 
 void CstdAllocator_construct(CstdAllocator* self);
@@ -59,7 +36,7 @@ typedef struct MemoryChunk {
 } MemoryChunk;
 
 STRUCT(LinearAllocator,
-    allocator_t base;
+    MemoryAllocator base;
     MemoryChunk* chunks;    /* MemoryChunk[max_chunks_count] */
     u16 chunks_count;       /* allocated chunks */
     u16 max_chunks_count;   /* chunks that can be allocated without reallocating .chunks */

src/base/memory/allocators_internal.h

@@ -1,4 +1,4 @@
 #include <assert.h>
 #include "memory.h"
 
-void* LinearAllocator_alloc(allocator_t* _self, size_t size);
+void* LinearAllocator_alloc(allocator_ptr _self, size_t size);

src/base/type_system/base_toString.c

@@ -5,14 +5,14 @@
 
 // accepts char* (ptr to char) and char* (ptr to string)
 // uses format kp_s and kp_c to determine what type is <c> argument
-char* __toString_char(void* c, u32 fmt) {
+char* __toString_char(allocator_ptr al, void* c, u32 fmt) {
     // *c=char*
     if(kp_fmt_dataFormat(fmt)==kp_s){
-        return cptr_copy((char*)c); // to avoid segmentation fault on free() when *c allocalet on stack
+        return cptr_copy(al, (char*)c); // to avoid segmentation fault on free() when *c allocalet on stack
     }
     // *c=char
     if(kp_fmt_dataFormat(fmt)==kp_c){
-        char* cc=malloc(2); 
+        char* cc=allocator_alloc(al, 2);
         cc[0]=*(char*)c;
         cc[1]=0;
         return cc;
@@ -20,10 +20,10 @@ char* __toString_char(void* c, u32 fmt) {
     else throw(ERR_FORMAT);
 }
 
-char* __toString_bool(void* c, u32 fmt) {
+char* __toString_bool(allocator_ptr al, void* c, u32 fmt) {
     static const char _strbool[4][6]={ "false", "true\0", "False", "True\0" };
     u8 strind=*(bool*)c==1 + kp_fmt_isUpper(fmt)*2;
-    char* rez=malloc(6);
+    char* rez=allocator_alloc(al, 6);
     rez[0]=_strbool[strind][0];
     rez[1]=_strbool[strind][1];
     rez[2]=_strbool[strind][2];
@@ -33,7 +33,7 @@ char* __toString_bool(void* c, u32 fmt) {
     return rez;
 }
 
-char* toString_i64(i64 n){
+char* toString_i64(allocator_ptr al, i64 n){
     i64 d=n<0 ? -1*n : n;
     char str[32];
     u8 i=sizeof(str);
@@ -46,10 +46,10 @@ char* toString_i64(i64 n){
     }
     if(n<0)
         str[--i]='-';
-    return cptr_copy((char*)str+i);
+    return cptr_copy(al, (char*)str+i);
 }
 
-char* toString_u64(u64 n, bool withPostfix, bool uppercase){
+char* toString_u64(allocator_ptr al, u64 n, bool withPostfix, bool uppercase){
     char str[32];
     u8 i=sizeof(str);
     str[--i]=0;
@@ -61,33 +61,30 @@ char* toString_u64(u64 n, bool withPostfix, bool uppercase){
         str[--i]='0' + n%10;
         n/=10;
     }
-    return cptr_copy((char*)str+i);
+    return cptr_copy(al, (char*)str+i);
 }
 
-#define _toString_float_impl(bufsize, maxPrecision) { \
+#define _toString_float_impl(al, bufsize, maxPrecision) { \
     char str[bufsize]; \
     if(precision>maxPrecision) \
         throw("too big precision"); \
     if(precision==0) \
         precision=toString_float_default_precision; \
-    i32 cn=IFMSC( \
+    i32 cn=sprintf_s(str, bufsize, "%.*f", precision, n); \
-        sprintf_s(str, bufsize, "%.*f", precision, n), \
-        sprintf(str, "%.*f", precision, n) \
-    ); \
     /* remove trailing zeroes except .0*/ \
     while(str[cn-1]=='0' && str[cn-2]!='.') \
         cn--; \
     if(withPostfix) \
         str[cn++]= uppercase ? 'F' : 'f'; \
     str[cn]='\0'; \
-    return cptr_copy(str); \
+    return cptr_copy(al, str); \
 }
 
-char* toString_f32(f32 n, u8 precision, bool withPostfix, bool uppercase)
+char* toString_f32(allocator_ptr al, f32 n, u8 precision, bool withPostfix, bool uppercase)
-    _toString_float_impl(48, toString_f32_max_precision)
+    _toString_float_impl(al, 48, toString_f32_max_precision)
 
-char* toString_f64(f64 n, u8 precision, bool withPostfix, bool uppercase)
+char* toString_f64(allocator_ptr al, f64 n, u8 precision, bool withPostfix, bool uppercase)
-    _toString_float_impl(512, toString_f64_max_precision)
+    _toString_float_impl(al, 512, toString_f64_max_precision)
 
 #define byte_to_bits(byte) { \
     str[cn++]='0' + (u8)((byte>>7)&1); /* 8th bit */ \
@@ -100,9 +97,9 @@ char* toString_f64(f64 n, u8 precision, bool withPostfix, bool uppercase)
     str[cn++]='0' + (u8)((byte>>0)&1); /* 1th bit */ \
 }
 
-char* toString_bin(void* _bytes, u32 size, bool inverse, bool withPrefix){
+char* toString_bin(allocator_ptr al, void* _bytes, u32 size, bool inverse, bool withPrefix){
     char* bytes=_bytes;
-    char* str=malloc(size*8 + (withPrefix?2:0) +1);
+    char* str=allocator_alloc(al, size*8 + (withPrefix?2:0) +1);
     u32 cn=0; // char number
     if(withPrefix){
         str[cn++]='0';
@@ -132,13 +129,13 @@ char _4bitsHex(u8 u, bool uppercase){
         default:
             dbg(u);
             throw("incorrect number");
-            return 219;
+            return (char)219;
     }
 }
 
-char* toString_hex(void* _bytes, u32 size, bool inverse, bool withPrefix, bool uppercase){
+char* toString_hex(allocator_ptr al, void* _bytes, u32 size, bool inverse, bool withPrefix, bool uppercase){
     char* bytes=_bytes;
-    char* str=malloc(size*2 + (withPrefix?2:0) + 1);
+    char* str=allocator_alloc(al, size*2 + (withPrefix?2:0) + 1);
     u32 cn=0; // char number
     if(withPrefix){
         str[cn++]='0';
@@ -166,67 +163,58 @@ char* toString_hex(void* _bytes, u32 size, bool inverse, bool withPrefix, bool u
 }
 
 
-#define __toString_i32_def(BITS) char* __toString_i##BITS(void* _n, u32 f){ \
+#define __toString_i_def(BITS) char* __toString_i##BITS(allocator_ptr al, void* _n, u32 f){ \
     switch(kp_fmt_dataFormat(f)){ \
         case kp_i: ; \
             i##BITS n=*(i##BITS*)_n; \
-            return toString_i64(n); \
+            return toString_i64(al,n); \
         case kp_b: \
-            return toString_bin(_n, BITS/8, getEndian()==LittleEndian, kp_fmt_withPrefix(f)); \
+            return toString_bin(al, _n, BITS/8, getEndian()==LittleEndian, kp_fmt_withPrefix(f)); \
         case kp_h: \
-            return toString_hex(_n, BITS/8, getEndian()==LittleEndian, kp_fmt_withPrefix(f), kp_fmt_isUpper(f)); \
+            return toString_hex(al, _n, BITS/8, getEndian()==LittleEndian, kp_fmt_withPrefix(f), kp_fmt_isUpper(f)); \
         default: \
             kprintf("\n%u\n", kp_fmt_dataFormat(f)); \
             throw(ERR_FORMAT); \
             return NULL; \
     } \
 }
-__toString_i32_def(8)
-__toString_i32_def(16)
-__toString_i32_def(32)
-__toString_i32_def(64)
 
-#define __toString_u_def(BITS) char* __toString_u##BITS(void* _n, u32 f){ \
+__toString_i_def(8)
+__toString_i_def(16)
+__toString_i_def(32)
+__toString_i_def(64)
+
+#define __toString_u_def(BITS) char* __toString_u##BITS(allocator_ptr al, void* _n, u32 f){ \
     switch(kp_fmt_dataFormat(f)){ \
         case kp_u: ; \
             u##BITS n=*(u##BITS*)_n; \
-            return toString_u64(n, kp_fmt_withPostfix(f), kp_fmt_isUpper(f)); \
+            return toString_u64(al, n, kp_fmt_withPostfix(f), kp_fmt_isUpper(f)); \
         case kp_b: \
-            return toString_bin(_n, BITS/8, getEndian()==LittleEndian, kp_fmt_withPrefix(f)); \
+            return toString_bin(al, _n, BITS/8, getEndian()==LittleEndian, kp_fmt_withPrefix(f)); \
         case kp_h: \
-            return toString_hex(_n, BITS/8, getEndian()==LittleEndian, kp_fmt_withPrefix(f), kp_fmt_isUpper(f)); \
+            return toString_hex(al, _n, BITS/8, getEndian()==LittleEndian, kp_fmt_withPrefix(f), kp_fmt_isUpper(f)); \
         default: \
             kprintf("\n%u\n", kp_fmt_dataFormat(f)); \
             throw(ERR_FORMAT); \
             return NULL; \
     } \
 }
+
 __toString_u_def(8)
 __toString_u_def(16)
 __toString_u_def(32)
-// __toString_u_def(64)
+__toString_u_def(64)
-char* __toString_u64(void* _n, u32 f){
-    switch(kp_fmt_dataFormat(f)){ 
-        case kp_u: ; 
-            u64 n=*(u64*)_n; 
-            return toString_u64(n, kp_fmt_withPostfix(f), kp_fmt_isUpper(f)); 
-        case kp_b: 
-            return toString_bin(_n, 64/8, getEndian()==LittleEndian, kp_fmt_withPrefix(f)); 
-        case kp_h: 
-            return toString_hex(_n, 64/8, getEndian()==LittleEndian, kp_fmt_withPrefix(f), kp_fmt_isUpper(f)); 
-        default: 
-            kprintf("\n%u\n", kp_fmt_dataFormat(f)); throw(ERR_FORMAT); return NULL; } 
-}
 
-#define __toString_float_def(BITS) char* __toString_f##BITS(void* _n, u32 f){ \
+
+#define __toString_f_def(BITS) char* __toString_f##BITS(allocator_ptr al, void* _n, u32 f){ \
     switch(kp_fmt_dataFormat(f)){ \
         case kp_f: ; \
             f##BITS n=*(f##BITS*)_n; \
-            return toString_f64(n, toString_float_default_precision, kp_fmt_withPostfix(f), kp_fmt_isUpper(f)); \
+            return toString_f64(al, n, toString_float_default_precision, kp_fmt_withPostfix(f), kp_fmt_isUpper(f)); \
         case kp_b: \
-            return toString_bin(_n, BITS/8, getEndian()==LittleEndian, kp_fmt_withPrefix(f)); \
+            return toString_bin(al, _n, BITS/8, getEndian()==LittleEndian, kp_fmt_withPrefix(f)); \
         case kp_h: \
-            return toString_hex(_n, BITS/8, getEndian()==LittleEndian, kp_fmt_withPrefix(f), kp_fmt_isUpper(f)); \
+            return toString_hex(al, _n, BITS/8, getEndian()==LittleEndian, kp_fmt_withPrefix(f), kp_fmt_isUpper(f)); \
         default: \
             kprintf("\n%u\n", kp_fmt_dataFormat(f)); \
             throw(ERR_FORMAT); \
@@ -234,5 +222,5 @@ char* __toString_u64(void* _n, u32 f){
     } \
 }
 
-__toString_float_def(32)
+__toString_f_def(32)
-__toString_float_def(64)
+__toString_f_def(64)

src/base/type_system/base_toString.h

@@ -5,42 +5,43 @@ extern "C" {
 #endif
 
 #include "../errors.h"
+#include "../memory/allocator_base.h"
 
 // accepts char* (ptr to char) and char* (ptr to string)
 // uses format kp_s and kp_c to determine what type is <c> argument
-char* __toString_char(void* c, u32 fmt);
+char* __toString_char(allocator_ptr al, void* c, u32 fmt);
 
 // bool
-char* __toString_bool(void* c, u32 fmt);
+char* __toString_bool(allocator_ptr al, void* c, u32 fmt);
 
 // signed int
-char* toString_i64(i64 n);
+char* toString_i64(allocator_ptr al, i64 n);
-char* __toString_i8(void* n, u32 fmt);
+char* __toString_i8(allocator_ptr al, void* n, u32 fmt);
-char* __toString_i16(void* n, u32 fmt);
+char* __toString_i16(allocator_ptr al, void* n, u32 fmt);
-char* __toString_i32(void* n, u32 fmt);
+char* __toString_i32(allocator_ptr al, void* n, u32 fmt);
-char* __toString_i64(void* n, u32 fmt);
+char* __toString_i64(allocator_ptr al, void* n, u32 fmt);
 
 // unsigned int
-char* toString_u64(u64 n, bool withPostfix, bool uppercase);
+char* toString_u64(allocator_ptr al, u64 n, bool withPostfix, bool uppercase);
-char* __toString_u8(void* n, u32 fmt);
+char* __toString_u8(allocator_ptr al, void* n, u32 fmt);
-char* __toString_u16(void* n, u32 fmt);
+char* __toString_u16(allocator_ptr al, void* n, u32 fmt);
-char* __toString_u32(void* n, u32 fmt);
+char* __toString_u32(allocator_ptr al, void* n, u32 fmt);
-char* __toString_u64(void* n, u32 fmt);
+char* __toString_u64(allocator_ptr al, void* n, u32 fmt);
 
 // float
 #define toString_f32_max_precision 6
 #define toString_f64_max_precision 15
 #define toString_float_default_precision 6
-char* toString_f32(f32 n, u8 precision, bool withPostfix, bool uppercase); // uses sprintf
+char* toString_f32(allocator_ptr al, f32 n, u8 precision, bool withPostfix, bool uppercase); // uses sprintf
-char* toString_f64(f64 n, u8 precision, bool withPostfix, bool uppercase); // uses sprintf
+char* toString_f64(allocator_ptr al, f64 n, u8 precision, bool withPostfix, bool uppercase); // uses sprintf
-char* __toString_f32(void* n, u32 fmt);
+char* __toString_f32(allocator_ptr al, void* n, u32 fmt);
-char* __toString_f64(void* n, u32 fmt); 
+char* __toString_f64(allocator_ptr al, void* n, u32 fmt);
 
 
 ///@param inverse set to true for little endian numbers (their bytes are in reverse order)
-char* toString_bin(void* bytes, u32 size, bool inverse, bool withPrefix);
+char* toString_bin(allocator_ptr al, void* bytes, u32 size, bool inverse, bool withPrefix);
 ///@param inverse set to true for little endian numbers (their bytes are in reverse order)
-char* toString_hex(void* bytes, u32 size, bool inverse, bool withPrefix, bool uppercase);
+char* toString_hex(allocator_ptr al, void* bytes, u32 size, bool inverse, bool withPrefix, bool uppercase);
 
 #if __cplusplus
 }

src/base/type_system/init.c

@@ -1,5 +1,4 @@
 #include "../base.h"
-#include "../../Array/Array.h"
 #include "../../Autoarr/Autoarr.h"
 #include "../../SearchTree/SearchTree.h"
 #include "../../Hashtable/Hashtable.h"
@@ -29,21 +28,6 @@ void kt_initKerepTypes(){
     // ktDescriptor
     kt_register(ktDescriptor);
 
-    // base type arrays
-    kt_register(Array_char);
-    kt_register(Array_bool);
-    kt_register(Array_f32);
-    kt_register(Array_f64);
-    kt_register(Array_i8);
-    kt_register(Array_u8);
-    kt_register(Array_i16);
-    kt_register(Array_u16);
-    kt_register(Array_i32);
-    kt_register(Array_u32);
-    kt_register(Array_i64);
-    kt_register(Array_u64);
-    kt_register(Array_Pointer);
-
     // base type autoarrs
     kt_register(Autoarr_Pointer);
     kt_register(Autoarr_char);
@@ -61,7 +45,6 @@ void kt_initKerepTypes(){
 
     // Unitype
     kt_register(Unitype);
-    kt_register(Array_Unitype);
     kt_register(Autoarr_Unitype);
 
     // STNode
@@ -76,12 +59,16 @@ void kt_initKerepTypes(){
 
     // string
     kt_register(string);
-    kt_register(Array_string);
     kt_register(Autoarr_string);
 
     // StringBuilder
     kt_register(StringBuilder);
 
-    //File
+    // File
     kt_register(FileHandle);
+
+    // Allocators
+    kt_register(CstdAllocator);
+    kt_register(LinearAllocator);
+    kt_register(StackingAllocator);
 }

src/base/type_system/ktDescriptor.h

@@ -7,6 +7,7 @@ extern "C" {
 #include "../std.h"
 #include "ktid.h"
 #include "typedef_macros.h"
+#include "../memory/allocator_base.h"
 
 #define kt_declare(TYPE)\
     ktid_declare(TYPE);\
@@ -31,7 +32,7 @@ extern "C" {
     };
 
 typedef void (*freeMembers_t)(void*);
-typedef char* (*toString_t)(void* obj, u32 fmt);
+typedef char* (*toString_t)(allocator_ptr al, void* obj, u32 fmt);
 
 STRUCT(ktDescriptor,
     char* name;

src/base/type_system/kt_functions.c

@@ -17,27 +17,27 @@ kt_define(i64, NULL, __toString_i64);
 kt_define(u64, NULL, __toString_u64);
 
 
-char* ktDescriptor_toString(ktDescriptor* d){
+char* ktDescriptor_toString(allocator_ptr al, ktDescriptor* d){
     const char* n="null";
-    char *s0 = toString_u64(d->id, 0,0);
+    char *s0 = toString_u64(al, d->id, 0,0);
-    char *s1 = toString_u64(d->size, 0,0);
+    char *s1 = toString_u64(al, d->size, 0,0);
-    char *s2 = d->toString ? toString_hex(d->toString, sizeof(void*), 0,1,0) : n;
+    char *s2 = d->toString ? toString_hex(al, d->toString, sizeof(void*), 0,1,0) : n;
-    char *s3 = d->freeMembers ? toString_hex(d->freeMembers, sizeof(void*), 0,1,0) : n;
+    char *s3 = d->freeMembers ? toString_hex(al, d->freeMembers, sizeof(void*), 0,1,0) : n;
-    char *rez=cptr_concat("ktDescriptor {"
+    char *rez=cptr_concat(al, "ktDescriptor {"
         " name:", d->name,
         " id:",s0,
         " size:",s1,
         " toString:",s2,
         " freeMembers:",s3,
         " }");
-    free(s0);
+    if(s3!=n) allocator_free(al, s3);
-    free(s1);
+    if(s2!=n) allocator_free(al, s2);
-    if(s2!=n) free(s2);
+    allocator_free(al, s1);
-    if(s3!=n) free(s3);
+    allocator_free(al, s0);
     return rez;
 }
 
-char* _ktDescriptor_toString(void* _d, u32 fmt) { return ktDescriptor_toString(_d); }
+char* _ktDescriptor_toString(allocator_ptr al, void* _d, u32 fmt) { return ktDescriptor_toString(al, _d); }
 
 kt_define(ktDescriptor, NULL, _ktDescriptor_toString);
 
@@ -63,7 +63,7 @@ void kt_endInit(){
     if(__descriptorPointers==NULL)
         throw(ERR_NULLPTR);
     typeDescriptors=(ktDescriptor**)Autoarr_toArray(__descriptorPointers);
-    Autoarr_free(__descriptorPointers,true);
+    Autoarr_destruct(__descriptorPointers,true);
     if(typeDescriptors==NULL) throw(ERR_NULLPTR);
     kprintf("\e[92minitialized %u type descriptors\n", ktid_last);
 }
@@ -81,6 +81,6 @@ ktDescriptor* ktDescriptor_get(ktid id){
     return typeDescriptors[id];
 }
 
-void kt_free(){
+void kt_deinit(){
     free(typeDescriptors);
 }

src/base/type_system/kt_functions.h

@@ -23,10 +23,10 @@ void kt_endInit();
 /// @param id id of registered type
 ktDescriptor* ktDescriptor_get(ktid id);
 
-char* ktDescriptor_toString(ktDescriptor* d);
+char* ktDescriptor_toString(allocator_ptr al, ktDescriptor* d);
 
 // call it to free heap-allocated ktDescriptors array
-void kt_free();
+void kt_deinit();
 
 kt_declare(Pointer);
 kt_declare(char);

src/base/type_system/unitype.c

@@ -1,40 +1,36 @@
 #include "../../kprint/kprint_format.h"
 #include "../base.h"
 
-char *__Unitype_toString(void *_u, u32 fmt)
+char *__Unitype_toString(allocator_ptr al, void *_u, u32 fmt)
 {
-    return Unitype_toString(*(Unitype *)_u, fmt);
+    return Unitype_toString(al, *(Unitype *)_u, fmt);
 }
 
-kt_define(Unitype, __UnitypePtr_free, __Unitype_toString);
+kt_define(Unitype, (freeMembers_t)Unitype_destruct, __Unitype_toString);
 
-void Unitype_free(Unitype u)
+void Unitype_destruct(Unitype* u)
 {
-    if (u.typeId == ktid_undefined)
+    if (u->typeId == ktid_undefined)
     {
-        if (u.VoidPtr != NULL)
+        if (u->VoidPtr != NULL)
             throw("unitype with undefined typeId has value");
         return;
     }
 
-    ktDescriptor *type = ktDescriptor_get(u.typeId);
+    ktDescriptor *type = ktDescriptor_get(u->typeId);
     if (type->freeMembers)
-        type->freeMembers(u.VoidPtr);
+        type->freeMembers(u->VoidPtr);
-    if (u.allocatedInHeap)
+    if (u->allocatedInHeap)
-        free(u.VoidPtr);
+        free(u->VoidPtr);
-}
-void __UnitypePtr_free(void *u)
-{
-    Unitype_free(*(Unitype *)u);
 }
 
-char *Unitype_toString(Unitype u, u32 fmt)
+char *Unitype_toString(allocator_ptr al, Unitype u, u32 fmt)
 {
     if (u.typeId == ktid_undefined)
     {
         if (u.VoidPtr != NULL)
             throw("unitype with undefined typeId has value");
-        return cptr_copy("{ERROR_TYPE}");
+        return cptr_copy(al, "{ERROR_TYPE}");
     }
 
     if (fmt == 0)
@@ -74,7 +70,7 @@ char *Unitype_toString(Unitype u, u32 fmt)
         else if (u.typeId == ktid_name(Pointer))
         {
             if (u.VoidPtr == NULL)
-                return cptr_copy("{ UniNull }");
+                return cptr_copy(al, "{ UniNull }");
             fmt = kp_h;
         }
     }
@@ -82,19 +78,22 @@ char *Unitype_toString(Unitype u, u32 fmt)
     ktDescriptor *type = ktDescriptor_get(u.typeId);
     char *valuestr;
     if (type->toString)
-        valuestr = type->toString(u.VoidPtr, fmt);
+        valuestr = type->toString(al, u.VoidPtr, fmt);
     else
         valuestr = "ERR_NO_TOSTRING_FUNC";
-    char *rezult = cptr_concat("{ type: ", type->name, ", allocated on heap: ", (u.allocatedInHeap ? "true" : "false"),
+    char *rezult = cptr_concat(al, "{ type: ", type->name, ", allocated on heap: ", (u.allocatedInHeap ? "true" : "false"),
                                ", value:", valuestr, " }");
     if (type->toString)
-        free(valuestr);
+        allocator_free(al, valuestr);
     return rezult;
 }
 
 void printuni(Unitype v)
 {
-    char *s = Unitype_toString(v, 0);
+    LinearAllocator _al;
+    LinearAllocator_construct(&_al, 256);
+    allocator_ptr al=&_al.base;
+    char *s = Unitype_toString(al, v, 0);
     fputs(s, stdout);
-    free(s);
+    LinearAllocator_destruct(&_al);
 }

src/base/type_system/unitype.h

@@ -17,7 +17,7 @@ STRUCT(Unitype,
         char Bytes[8];
     };
     ktid typeId;
-    bool allocatedInHeap; // should Unitype_free call free() to VoidPtr*
+    bool allocatedInHeap; // should Unitype_destruct call free() to VoidPtr*
 )
 
 
@@ -45,9 +45,8 @@ STRUCT(Unitype,
 #define UniCheckTypePtr(UNI, TYPE) UniCheckTypeId(UNI, ktid_ptrName(TYPE))
 
 // frees VoidPtr value or does nothing if type isn't pointer
-void Unitype_free(Unitype u);
+void Unitype_destruct(Unitype* u);
-void __UnitypePtr_free(void* u);
+char* Unitype_toString(allocator_ptr al, Unitype v, u32 fmt);
-char* Unitype_toString(Unitype v, u32 fmt);
 void printuni(Unitype v);
 
 #if __cplusplus

src/kprint/kprint.c

@@ -23,7 +23,7 @@ ktid __typeFromFormat(kp_fmt f){
     }
 }
 
-Maybe __next_toString(kp_fmt f, void* object){
+Maybe __next_toString(allocator_ptr al, kp_fmt f, void* object){
     // detecting type
     ktid typeId=__typeFromFormat(f);
     if(typeId==ktid_undefined)
@@ -35,7 +35,7 @@ Maybe __next_toString(kp_fmt f, void* object){
     ktDescriptor* type=ktDescriptor_get(typeId);
     if(!type->toString)
         safethrow("type descriptor doesnt have toString() func",;);
-    return SUCCESS(UniHeapPtr(char, type->toString(object, f)));
+    return SUCCESS(UniHeapPtr(char, type->toString(al, object, f)));
 }
 
 Maybe check_argsN(u8 n){
@@ -44,14 +44,14 @@ Maybe check_argsN(u8 n){
     return MaybeNull;
 }
 
-Maybe __ksprint(u8 n, kp_fmt* formats, __kp_value_union* objects){
+Maybe __ksprint(allocator_ptr al, u8 n, kp_fmt* formats, __kp_value_union* objects){
     try(check_argsN(n), _,;);
     n/=2;
     StringBuilder* strb=StringBuilder_create();
     for(u8 i=0; i<n; i++){
-        try(__next_toString(formats[i], &objects[i]),mStr,;);
+        try(__next_toString(al, formats[i], &objects[i]),mStr,;);
         StringBuilder_append_cptr(strb, mStr.value.VoidPtr);
-        Unitype_free(mStr.value);
+        allocator_free(al, mStr.value.VoidPtr);
     }
     char* rezult=StringBuilder_build(strb).ptr;
     return SUCCESS(UniHeapPtr(char, rezult));
@@ -60,29 +60,36 @@ Maybe __ksprint(u8 n, kp_fmt* formats, __kp_value_union* objects){
 Maybe __kfprint(FILE* file, u8 n, kp_fmt* formats, __kp_value_union* objects){
     try(check_argsN(n), _,;);
     n/=2;
+    LinearAllocator _al;
+    LinearAllocator_construct(&_al, 256);
+    allocator_ptr al=&_al.base;
     for(u8 i=0; i<n; i++){
-        try(__next_toString(formats[i], &objects[i]),maybeStr,;);
+        try(__next_toString(al, formats[i], &objects[i]),maybeStr, LinearAllocator_destruct(&_al));
         if(fputs(maybeStr.value.VoidPtr, file)==EOF)
-            safethrow("can't write string to file", Unitype_free(maybeStr.value));
+            safethrow("can't write string to file", LinearAllocator_destruct(&_al));
-        Unitype_free(maybeStr.value);
     }
     fflush(file);
+    LinearAllocator_destruct(&_al);
     return MaybeNull;
 }
 
 void __kprint(u8 n, kp_fmt* formats, __kp_value_union* objects){
     tryLast(check_argsN(n), _,;);
     n/=2;
+    LinearAllocator _al;
+    LinearAllocator_construct(&_al, 256);
+    allocator_ptr al=&_al.base;
     for(u8 i=0; i<n; i++){
         kp_fmt fmt=formats[i];
         kprint_setColor(fmt);
-        tryLast(__next_toString(fmt, &objects[i]),maybeStr, kprint_setColor(kp_bgBlack|kp_fgGray));
+        tryLast(__next_toString(al, fmt, &objects[i]), maybeStr,
-        if(fputs(maybeStr.value.VoidPtr, stdout)==EOF) \
+            LinearAllocator_destruct(&_al);
+            kprint_setColor(kp_bgBlack|kp_fgGray););
+        if(fputs(maybeStr.value.VoidPtr, stdout)==EOF)
             throw("can't write string to stdout");
-            //, Unitype_free(maybeStr.value)
-        Unitype_free(maybeStr.value);
     }
     fflush(stdout);
+    LinearAllocator_destruct(&_al);
 }
 
 #if defined(_WIN32)|| defined(_WIN64)
@@ -199,12 +206,12 @@ static const char* _kp_colorNames[16]={
     "white"
 };
 
-char* kp_bgColor_toString(kp_bgColor c){
+char* kp_bgColor_toString(allocator_ptr al, kp_bgColor c){
     u32 color_index=(c&0x00f00000)>>20;
     if(color_index>15) throw(ERR_WRONGINDEX);
     return _kp_colorNames[color_index];
 }
-char* kp_fgColor_toString(kp_fgColor c){
+char* kp_fgColor_toString(allocator_ptr al, kp_fgColor c){
     u32 color_index=(c&0x00f00000)>>24;
     if(color_index>15) throw(ERR_WRONGINDEX);
     return _kp_colorNames[color_index];

src/kprint/kprint.h

@@ -70,12 +70,12 @@ static inline __kp_value_union __kpVU_i(i64 f) { return (__kp_value_union){ .i64
         __kp_argsToObjs32(ARGS))
 
 
-Maybe __ksprint(u8 n, kp_fmt* formats, __kp_value_union* objects);
+Maybe __ksprint(allocator_ptr al, u8 n, kp_fmt* formats, __kp_value_union* objects);
 
 /// @param ARGS kp_fmt, value, kp_fmt, value...
 ///@returns Maybe<char*>
-#define ksprint(ARGS...) WARNING_DISABLE( W_INT_CONVERSION, \
+#define ksprint(ALLOCATOR, ARGS...) WARNING_DISABLE( W_INT_CONVERSION, \
-        __ksprint(count_args(ARGS), __kp_argsToArrs(count_args(ARGS),ARGS, __32zeroes)) \
+        __ksprint(ALLOCATOR, count_args(ARGS), __kp_argsToArrs(count_args(ARGS),ARGS, __32zeroes)) \
     )
 /*-Wint-conversion warning was produced during value to __kp_value_union conversion*/
 

src/kprint/kprint_colors.h

@@ -4,6 +4,8 @@
 extern "C" {
 #endif
 
+#include "../base/memory/allocator_base.h"
+
 //         10000000 00000000  00000000 00000000
 //         ^   ^^^^
 //         |   color num
@@ -81,8 +83,8 @@ PACKED_ENUM(kp_bgColor,
     kp_bgWhite   = 0x40f00000
 )
 
-char* kp_bgColor_toString(kp_bgColor c);
+char* kp_bgColor_toString(allocator_ptr al, kp_bgColor c);
-char* kp_fgColor_toString(kp_fgColor c);
+char* kp_fgColor_toString(allocator_ptr al, kp_fgColor c);
 
 #if __cplusplus
 }

src/kprint/kprintf.c

@@ -49,6 +49,9 @@ void kprintf(const char* format, ...){
     va_list vl;
     va_start(vl, format);
     u32 i=0;
+    LinearAllocator _al;
+    LinearAllocator_construct(&_al, 256);
+    allocator_ptr al=(allocator_ptr)&_al;
     for(char c=format[i++]; c!=0; c=format[i++]){
         // value format specifiers
         if(c=='%'){
@@ -58,18 +61,18 @@ void kprintf(const char* format, ...){
             format_escape_seq:
             switch (c) {
                 case 'u':
-                    argstr=toString_u64(
+                    argstr=toString_u64(al,
                         l ? va_arg(vl, u64) : va_arg(vl, u32)
                         ,0,0);
                     break;
                 case 'i': case 'd':
-                    argstr=toString_i64(
+                    argstr=toString_i64(al,
                         l ? va_arg(vl, i64) : va_arg(vl, i32)
                         );
                     break;
                 case 'f':
                     // f32 is promoted to f64 when passed through '...'
-                    argstr=toString_f64(va_arg(vl, f64), toString_float_default_precision,0,0);
+                    argstr=toString_f64(al, va_arg(vl, f64), toString_float_default_precision,0,0);
                     break;
                case 'l':
                     l=true;
@@ -78,16 +81,16 @@ void kprintf(const char* format, ...){
                     break;
                 case 'p': ;
                     void* phex=va_arg(vl, void*);
-                    argstr=toString_hex(&phex,getEndian()==LittleEndian,sizeof(phex),1,0);
+                    argstr=toString_hex(al, &phex,getEndian()==LittleEndian,sizeof(phex),1,0);
                     break;
                 case 'x': ;
                     if(l){
                         u64 xhex=va_arg(vl, u64);
-                        argstr=toString_hex(&xhex,getEndian()==LittleEndian,sizeof(xhex),0,1);
+                        argstr=toString_hex(al, &xhex,getEndian()==LittleEndian,sizeof(xhex),0,1);
                     }
                     else {
                         u32 xhex=va_arg(vl, u32);
-                        argstr=toString_hex(&xhex,getEndian()==LittleEndian,sizeof(xhex),0,1);
+                        argstr=toString_hex(al, &xhex,getEndian()==LittleEndian,sizeof(xhex),0,1);
                     }
                     break;
                 case 's': ;
@@ -98,7 +101,7 @@ void kprintf(const char* format, ...){
                         fputs(cptr, stdout);
                     break;
                 case 'c':
-                    argstr=malloc(2);
+                    argstr=allocator_alloc(al, 2);
                     argstr[0]=(char)va_arg(vl,int);
                     argstr[1]=0;
                     break;
@@ -111,7 +114,6 @@ void kprintf(const char* format, ...){
             }
             if(argstr){
                 fputs(argstr, stdout);
-                free(argstr);
             }
         }
         // escape sequences
@@ -152,4 +154,5 @@ void kprintf(const char* format, ...){
         #endif
     }
     va_end(vl);
+    LinearAllocator_destruct(&_al);
 }

src/random/xoshiro-xoroshiro.md

@@ -1,24 +0,0 @@
-# Xoshiro/Xoroshiro RNG algorithms
-There are a bunch of versions of xoshiro/xoroshiro algorithms, which are created by [David Blackman and Sebastiano Vigna](https://prng.di.unimi.it/)
-
-
-```
-xoroshiro
-├── 32bitValue
-|   ├── xoroshiro64star.c
-|   └── xoroshiro64starstar.c
-└── 64bitValue
-    ├── xoroshiro128plus.c
-    ├── xoroshiro128plusplus.c
-    └── xoroshiro128starstar.c
-
-xoshiro
-├── 32bitValue
-│   ├── xoshiro128plus.c
-│   ├── xoshiro128plusplus.c
-│   └── xoshiro128starstar.c
-└── 64bitValue
-    ├── xoshiro256plus.c
-    ├── xoshiro256plusplus.c
-    └── xoshiro256starstar.c
-```

tests/main.cpp

@@ -7,7 +7,7 @@ i32 main(){
     kt_initKerepTypes();
     kt_endInit();
     test_all();
-    kt_free();
+    kt_deinit();
     kprintf("\e[0m\n");
     return 0;
 }

tests/test_allocators.c

@@ -1,6 +1,6 @@
 #include "tests.h"
 
-void _test_allocator(allocator_t* al){
+void _test_allocator(allocator_ptr al){
     void* ptr=allocator_alloc(al, 1);
     allocator_free(al, ptr);
     ptr=allocator_alloc(al, 5);
@@ -30,18 +30,18 @@ void test_allocators(){
     optime("test CstdAllocator", 10000,
         CstdAllocator al;
         CstdAllocator_construct(&al);
-        _test_allocator((allocator_t*)&al);
+        _test_allocator((allocator_ptr)&al);
     );
     optime("test LinearAllocator", 10000,
         LinearAllocator al;
         LinearAllocator_construct(&al, 4096);
-        _test_allocator((allocator_t*)&al);
+        _test_allocator((allocator_ptr)&al);
         LinearAllocator_destruct(&al);
     );
     optime("test StackingAllocator", 10000,
         StackingAllocator al;
         StackingAllocator_construct(&al, 4096);
-        _test_allocator((allocator_t*)&al);
+        _test_allocator((allocator_ptr)&al);
         StackingAllocator_destruct(&al);
     );
 }

tests/test_autoarr-vs-vector.cpp

@@ -16,7 +16,7 @@ i64 _autoarrVsVector(u16 chunkCount, u16 chunkLength){
         t=Autoarr_get(ar, op_i));
     optime("vector_get", count,
         t=vec[op_i]);
-    Autoarr_free(ar, true);
+    Autoarr_destruct(ar, true);
     return t;
 }
 

tests/test_autoarr.c

@@ -47,7 +47,7 @@ void test_autoarr(){
         resetar(ar);
         kprintf("\e[92mautoarr values reset\n");
         printallval(ar);
-        Autoarr_free(ar, true);
+        Autoarr_destruct(ar, true);
         kprintf("\e[92mautoarr deleted\n");
     );
 }

tests/test_dtsod.c

@@ -52,7 +52,7 @@ void test_dtsod(){
             tryLast(DtsodV24_serialize(dtsod),r,;)
                 s=r.value.VoidPtr;
         );
-        DtsodV24_free(dtsod);
+        DtsodV24_destruct(dtsod);
         kprintf("\e[92m%s",s);
 
         optime("reserialize",10,
@@ -61,7 +61,7 @@ void test_dtsod(){
             free(s);
             tryLast(DtsodV24_serialize(dtsod),rr,;)
                 s=rr.value.VoidPtr;
-            DtsodV24_free(dtsod);
+            DtsodV24_destruct(dtsod);
         );
 
         free(s);

tests/test_hash_functions.c

@@ -33,7 +33,7 @@ char data[]="iojihiojopijiugbjmoihftytryfdrh";
         } \
         kprintf("\e[93m%u \e[94mcollisions detected in %u hashes\n", collisions, COLLISION_TESTS); \
     ); \
-    Autoarr_free(hashes, true); \
+    Autoarr_destruct(hashes, true); \
     kprintf("\e[96m--------------------------------------\n"); \
 }
 

tests/test_hashtable.c

@@ -13,7 +13,7 @@ void print_hashtable(Hashtable* ht){
         ht->rows);
 }
 
-void printrowgraph(Hashtable* ht){
+void printrowgraph(allocator_ptr al, Hashtable* ht){
     kprintf("\e[94mrow length graph:\n");
     u16 lgs_l=1000;
     u32 lgs[lgs_l];
@@ -26,36 +26,33 @@ void printrowgraph(Hashtable* ht){
     }
     for(u32 i=0; i<lgs_l; i++)
         if(lgs[i]>0) {
-            char* str0=char_multiply(' ',i>=100?0:(i>=10?1:2));
+            char* str0=char_multiply(al, ' ',i>=100?0:(i>=10?1:2));
-            char* str1=char_multiply(' ',lgs[i]>=100?0:(lgs[i]>=10?1:2));
+            char* str1=char_multiply(al, ' ',lgs[i]>=100?0:(lgs[i]>=10?1:2));
-            char* str2=char_multiply('#',lgs[i]/100);
+            char* str2=char_multiply(al, '#',lgs[i]/100);
             kprintf("\e[94m  length: \e[96m%u %s \e[94mfrequency: \e[96m%u %s \e[90m%s\n",i,str0,lgs[i],str1,str2);
-            free(str0);
+            allocator_free(al, str2);
-            free(str1);
+            allocator_free(al, str1);
-            free(str2);
+            allocator_free(al, str0);
         }
 }
 
-char* genkey(u32 i){
+char* genkey(allocator_ptr al, u32 i){
-    char* key=malloc(12);
+    char* key=allocator_alloc(al, 16);
-    IFMSC(
+    sprintf_s(key,16,"key_%u",i);
-        sprintf_s(key,12,"key_%u",i),
-        sprintf(key,"key_%u",i)
-    );
     return key;
 }
 
-void fill(Hashtable* ht){
+void fill(allocator_ptr al, Hashtable* ht){
     for(u32 i=0;i<100000;i++)
-        Hashtable_add(ht,genkey(i),UniUInt64(i));
+        Hashtable_add(ht,genkey(al, i), UniUInt64(i));
 }
 
-Unitype gett(Hashtable* ht){
+Unitype gett(allocator_ptr al, Hashtable* ht){
     Unitype u;
     for(u32 i=0;i<100000;i++){
-        char* key=genkey(i);
+        char* key=genkey(al, i);
         u=Hashtable_get(ht,key);
-        free(key);
+        allocator_free(al, key);
     }
     return u;
 }
@@ -64,14 +61,18 @@ Unitype gett(Hashtable* ht){
 void test_hashtable(){
     optime("test_hashtable",1,
         kprintf("\e[96m-----------[test_hashtable]-----------\n");
+        StackingAllocator _al;
+        allocator_ptr al=(allocator_ptr)&_al;
+        StackingAllocator_construct(&_al, 4096);
         Hashtable* ht=Hashtable_create();
         kprintf("\e[92mhashtable created\n");
         print_hashtable(ht);
-        optime("fill",1,fill(ht));
+        optime("fill",1,fill(al, ht));
-        optime("get",1,gett(ht));
+        optime("get",1,gett(al, ht));
-        printrowgraph(ht);
+        printrowgraph(al, ht);
         print_hashtable(ht);
-        Hashtable_free(ht);
+        Hashtable_destruct(ht);
         kprintf("\e[92mhashtable freed\n");
+        StackingAllocator_destruct(&_al);
     );
 }

tests/test_marshalling.c

@@ -1,9 +1,12 @@
 #include "../src/Hashtable/KeyValuePair.h"
 
 EXPORT void CALL test_marshalling(char* text, KVPair** kptr){
-    KVPair* k=malloc(sizeof(KVPair));
+    CstdAllocator _al;
+    allocator_ptr al=(allocator_ptr)&_al;
+    CstdAllocator_construct(&_al);
+    KVPair* k=allocator_alloc(al, sizeof(KVPair));
     k->key="message";
-    char* tc=cptr_copy(text);
+    char* tc=cptr_copy(al, text);
     Unitype u=UniHeapPtr(char,tc);
     k->value=u;
     *kptr=k;

tests/test_rng_algorithms.c

@@ -1,45 +1,43 @@
 #include "tests.h"
-#include "../src/random/krandom.h"
+#include "../src/random/random.h"
 
-
+#define test_alg(ALG, STATE_TYPE, EXPECTED_FROM_ZERO) { \
-#define test_alg(ALG, VALUE_SIZE, EXPECTED_FROM_ZERO) { \
     kprintf("\e[94mrng algorithm: \e[96m" #ALG "\n"); \
-    void* s= ALG##_init(0); \
+    STATE_TYPE##_state state; \
-    u##VALUE_SIZE r=ALG##_next(s); \
+    STATE_TYPE##_construct(&state, 0); \
+    u64 rn=ALG##_next(&state); \
     kprintf("\e[97m  next from zero seed:"); \
-    if(r!=EXPECTED_FROM_ZERO){ \
+    if(rn != EXPECTED_FROM_ZERO){ \
-        kprintf("\e[91m " IFWIN("%llu\n","%lu\n"), (u64)r); \
+        kprintf("\e[91m %lu\n", rn); \
         throw(ERR_UNEXPECTEDVAL); \
     } \
-    kprintf("\e[92m " IFWIN("%llu\n","%lu\n"), (u64)r); \
+    kprintf("\e[92m %lu\n", rn); \
-    ALG##_free(s); \
+    STATE_TYPE##_construct(&state, random_seedFromTime()); \
-    s= ALG##_initFromTime(); \
+    rn=ALG##_next(&state); \
-    r=ALG##_next(s); \
+    kprintf("\e[97m  next from time seed:\e[92m %lu\n", rn); \
-    ALG##_free(s); \
-    kprintf("\e[97m  next from time seed:\e[92m " IFWIN("%llu\n","%lu\n"), (u64)r); \
 }
 
 void test_rng_algorithms(){
-    optime("test_rng_algorithms",1,
+    // optime("test_rng_algorithms",1,
         kprintf("\e[96m--------[test_rng_algorithms]---------\n");
-        // for ALG32      
-            // xoroshiro64
-        test_alg(xoroshiro64star, 32, 932574677ULL)
-        test_alg(xoroshiro64starstar, 32, 3183060286ULL)
-            // xoshiro128
-        test_alg(xoshiro128plus, 32, 3918949401ULL)
-        test_alg(xoshiro128plusplus, 32, 1179900579ULL)
-        test_alg(xoshiro128starstar, 32, 3737715805ULL)
-        // for ALG64
-            // xoroshiro128
-        test_alg(xoroshiro128plus, 64, 4778832803ULL)
-        test_alg(xoroshiro128plusplus, 64, 626373238705583ULL)
-        test_alg(xoroshiro128starstar, 64, 11897572417920ULL)
-            // xoshiro256
-        test_alg(xoshiro256plus, 64, 15757075719729598363ULL)
-        test_alg(xoshiro256plusplus, 64, 5987356902031041503ULL)
-        test_alg(xoshiro256starstar, 64, 11091344671253066420ULL)
         // splitmix64
-        test_alg(splitmix64, 64, 16294208416658607535ULL)
+        test_alg(splitmix64,            splitmix64, 16294208416658607535ULL)
-    );
+        // 32-bit
+        // xoroshiro64
+        test_alg(xoroshiro64star,       xoroshiro64, 932574677ULL)
+        test_alg(xoroshiro64starstar,   xoroshiro64, 3183060286ULL)
+        // xoshiro128
+        test_alg(xoshiro128plus,        xoshiro128, 3918949401ULL)
+        test_alg(xoshiro128plusplus,    xoshiro128, 1179900579ULL)
+        test_alg(xoshiro128starstar,    xoshiro128, 3737715805ULL)
+        // 64-bit
+        // xoroshiro128
+        test_alg(xoroshiro128plus,      xoroshiro128, 4778832803ULL)
+        test_alg(xoroshiro128plusplus,  xoroshiro128, 626373238705583ULL)
+        test_alg(xoroshiro128starstar,  xoroshiro128, 11897572417920ULL)
+        // xoshiro256
+        test_alg(xoshiro256plus,        xoshiro256, 15757075719729598363ULL)
+        test_alg(xoshiro256plusplus,    xoshiro256, 5987356902031041503ULL)
+        test_alg(xoshiro256starstar,    xoshiro256, 11091344671253066420ULL)
+    // );
 }

tests/test_safethrow.c

@@ -34,10 +34,10 @@ void test_safethrow(){
         Maybe e=test_maybe();
         kprintf("\e[94mthrow_error:\n\e[92m");
         printMaybe(e);
-        Maybe_free(e);
+        Maybe_destruct(e);
         kprintf("\e[94mthrow_errcode:\n\e[92m");
         e=a();
         printMaybe(e);
-        Maybe_free(e);
+        Maybe_destruct(e);
     );
 }

tests/test_searchtree.c

@@ -25,6 +25,9 @@ void printstnode(STNode* node){
 void test_searchtree(){
     optime("test_searchtree",1,
         kprintf("\e[96m-----------[test_searchtree]----------\n");
+        LinearAllocator _al;
+        LinearAllocator_construct(&_al, 1024);
+        allocator_ptr al=(allocator_ptr)&_al;
         STNode* node=STNode_create();
         kprintf("\e[92mnode created\n");
         kprintf("push:\e[94m\n  ");
@@ -44,7 +47,7 @@ void test_searchtree(){
         printuni(u);
         ST_push(node,"channel_id", u);
         kprintf(" -> channel_id\n  ");
-        u=UniHeapPtr(char, cptr_copy("32.2004"));
+        u=UniHeapPtr(char, cptr_copy(al, "32.2004"));
         printuni(u);
         ST_push(node,"message_id", u);
         kprintf(" -> message_id\n  ");
@@ -68,7 +71,8 @@ void test_searchtree(){
         kprintf("\n");
         kprintf("\e[92mfirst node:  ");
         printstnode(node);
-        STNode_free(node);
+        STNode_destruct(node);
         kprintf("\e[92mnode deleted\n");
+        LinearAllocator_destruct(&_al);
     );
 }

tests/test_type_system.c

@@ -1,7 +1,7 @@
 #include "tests.h"
 
 void test_type_system(){
-    for(ktid id=0; id<ktid_last; id++){
+    for(ktid id=0; id <= ktid_last; id++){
         ktDescriptor* type=ktDescriptor_get(id);
         kprintf("\e[37m{ id:%u name:%s size:%u freeMembers:%p toString:%p }\n",
                     type->id, type->name, type->size, type->freeMembers, type->toString);

tests/tests.h

@@ -24,20 +24,20 @@ void test_type_system();
 static inline void test_all(){
     kprintf("\e[97mkerep tests are starting!\n");
     optime(__func__, 1,
+        // test_type_system();
         test_allocators();
-        /*test_cptr();
+        // test_kprint_colors();
-        test_string();
+        // test_kprint();
-        test_safethrow();
+        // test_safethrow();
-        test_searchtree();
+        // test_rng_algorithms();
-        test_autoarr();
+        // test_cptr();
-        test_hash_functions();
+        // test_string();
-        test_hashtable();
+        // test_searchtree();
-        test_dtsod();
+        // test_autoarr();
-        test_autoarrVsVector();
+        // test_autoarrVsVector();
-        test_rng_algorithms();
+        // test_hash_functions();
-        test_kprint_colors();
+        // test_hashtable();
-        test_kprint();
+        // test_dtsod();*/
-        test_type_system();*/
         kprintf("\e[96m--------------------------------------\e[0m\n");
     );
 }