moved files from DTLib repo

Autoarr/Autoarr.c

@@ -0,0 +1,23 @@
+#include "Autoarr.h"
+
+define_Autoarr(uint8)
+define_Autoarr(int8)
+define_Autoarr(uint16)
+define_Autoarr(int16)
+define_Autoarr(uint32)
+define_Autoarr(int32)
+define_Autoarr(uint64)
+define_Autoarr(int64)
+define_Autoarr(float)
+define_Autoarr(double)
+define_Autoarr(Unitype)
+
+//right func to clear array of unitype values
+void Autoarr_Unitype_clear(Autoarr(Unitype)* ar){
+    for(uint32 blockI=0;blockI<ar->blocks_count-1;blockI++)
+        for(uint32 elemI=0;elemI<ar->max_block_length;elemI++)
+            Unitype_free(ar->values[blockI][elemI]);
+    for(uint32 elemI=0;elemI<ar->block_length;elemI++)
+        Unitype_free(ar->values[ar->blocks_count-1][elemI]);
+    Autoarr_clear(ar);
+}

Autoarr/Autoarr.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "Autoarr_declare.h"
+#include "Autoarr_define.h"
+
+declare_Autoarr(uint8)
+declare_Autoarr(int8)
+declare_Autoarr(uint16)
+declare_Autoarr(int16)
+declare_Autoarr(uint32)
+declare_Autoarr(int32)
+declare_Autoarr(uint64)
+declare_Autoarr(int64)
+declare_Autoarr(float)
+declare_Autoarr(double)
+declare_Autoarr(Unitype)
+
+//right func to clear array of unitype values
+void Autoarr_Unitype_clear(Autoarr(Unitype)* ar);
+
+#define Autoarr_foreach(ar,elem,codeblock)({\
+    if(ar->blocks_count>0) {\
+        typeof(**ar->values) elem;\
+        for(uint32 blockI=0;blockI<ar->blocks_count-1;blockI++)\
+            for(uint32 elemI=0;elemI<ar->max_block_length;elemI++){dbg(5);\
+                elem=ar->values[blockI][elemI];\
+                (codeblock);\
+            }\
+        for(uint32 elemI=0;elemI<ar->block_length;elemI++){\
+            elem=ar->values[ar->blocks_count-1][elemI];\
+            (codeblock);\
+        }\
+    }\
+})

Autoarr/Autoarr_declare.h

@@ -0,0 +1,61 @@
+#pragma once
+
+#include "../base/base.h"
+
+#define declare_Autoarr(type)\
+\
+struct Autoarr_##type;\
+\
+typedef struct {\
+    void (*add)(struct Autoarr_##type* ar, type element);\
+    type (*get)(struct Autoarr_##type* ar, uint32 index);\
+    type* (*getptr)(struct Autoarr_##type* ar, uint32 index);\
+    void (*set)(struct Autoarr_##type* ar, uint32 index, type element);\
+    void (*clear)(struct Autoarr_##type* ar);\
+} __functions_list_t_##type;\
+\
+typedef struct Autoarr_##type{\
+    uint16 blocks_count;\
+    uint16 max_blocks_count;\
+    uint16 block_length;\
+    uint16 max_block_length;\
+    type** values;\
+    __functions_list_t_##type* functions;\
+} Autoarr_##type;\
+\
+void __Autoarr_add_##type(Autoarr_##type* ar, type element);\
+type __Autoarr_get_##type(Autoarr_##type* ar, uint32 index);\
+type* __Autoarr_getptr_##type(Autoarr_##type* ar, uint32 index);\
+void __Autoarr_set_##type(Autoarr_##type* ar, uint32 index, type element);\
+void __Autoarr_clear_##type(Autoarr_##type* ar);\
+Autoarr_##type __Autoarr_create_##type(uint16 max_blocks_count, uint16 max_block_length);
+
+#define Autoarr(type) Autoarr_##type
+
+#define Autoarr_add(autoarr, element)\
+    autoarr->functions->add(autoarr, element)
+#define Autoarr_get(autoarr, index)\
+    autoarr->functions->get(autoarr,index)
+#define Autoarr_getptr(autoarr, index)\
+    autoarr->functions->getptr(autoarr,index)
+#define Autoarr_set(autoarr, index, element)\
+    autoarr->functions->set(autoarr, index, element)
+#define Autoarr_clear(autoarr)\
+    autoarr->functions->clear(autoarr)
+#define Autoarr_create(type, max_blocks_count, max_block_length)\
+    __Autoarr_create_##type(max_blocks_count, max_block_length)
+
+#define Autoarr_length(autoarr) \
+    (uint32)(!autoarr->blocks_count ? 0 : \
+    autoarr->max_block_length*(autoarr->blocks_count-1)+autoarr->block_length)
+#define Autoarr_max_length(autoarr)\
+    (uint32)(autoarr->max_block_length*autoarr->max_blocks_count)
+    
+#define Autoarr_remove(AR){\
+    if(AR->block_length==1){\
+                        AR->blocks_count--;\
+                         AR->block_length=AR->max_block_length;\
+                         free(AR->values[AR->blocks_count]);\
+                    }\
+                    else AR->block_length--;\
+}

Autoarr/Autoarr_define.h

@@ -0,0 +1,64 @@
+#pragma once
+
+#include "../base/base.h"
+
+#define define_Autoarr(type)\
+\
+void __Autoarr_add_##type(Autoarr_##type* ar, type element){\
+    if(!ar->values){\
+        ar->values=malloc(ar->max_blocks_count*sizeof(type*));\
+        goto create_block;\
+    }\
+    if(ar->block_length==ar->max_block_length){\
+        if (ar->blocks_count>=ar->max_blocks_count) throw(ERR_MAXLENGTH);\
+        ar->block_length=0;\
+create_block:\
+        ar->values[ar->blocks_count]=malloc(ar->max_block_length*sizeof(type));\
+        ar->blocks_count++;\
+    }\
+    ar->values[ar->blocks_count-1][ar->block_length]=element;\
+    ar->block_length++;\
+}\
+\
+type __Autoarr_get_##type(Autoarr_##type* ar, uint32 index){\
+    if(index>=Autoarr_length(ar)) throw(ERR_WRONGINDEX);\
+    return ar->values[index/ar->max_block_length][index%ar->max_block_length];\
+}\
+\
+type* __Autoarr_getptr_##type(Autoarr_##type* ar, uint32 index){\
+    if(index>=Autoarr_length(ar)) throw(ERR_WRONGINDEX);\
+    return ar->values[index/ar->max_block_length]+(index%ar->max_block_length);\
+}\
+\
+void __Autoarr_set_##type(Autoarr_##type* ar, uint32 index, type element){\
+    if(index>=Autoarr_length(ar)) throw(ERR_WRONGINDEX);\
+    ar->values[index/ar->max_block_length][index%ar->max_block_length]=element;\
+}\
+\
+void __Autoarr_clear_##type(Autoarr_##type* ar){\
+    for(uint16 i=0; i<ar->blocks_count;i++)\
+        free(ar->values[i]); \
+    free(ar->values);\
+    ar->values=NULL;\
+    ar->blocks_count=0;\
+    ar->block_length=0;\
+}\
+\
+__functions_list_t_##type __functions_list_##type={\
+    &__Autoarr_add_##type,\
+    &__Autoarr_get_##type,\
+    &__Autoarr_getptr_##type,\
+    &__Autoarr_set_##type,\
+    &__Autoarr_clear_##type\
+};\
+\
+Autoarr_##type __Autoarr_create_##type(uint16 max_blocks_count, uint16 max_block_length){\
+    return (Autoarr_##type){\
+        .max_blocks_count=max_blocks_count,\
+        .blocks_count=0,\
+        .max_block_length=max_block_length,\
+        .block_length=0,\
+        .values=NULL,\
+        .functions=&__functions_list_##type\
+    };\
+}

Autoarr/StringBuilder.c

@@ -0,0 +1,71 @@
+#include "StringBuilder.h"
+
+StringBuilder StringBuilder_create(uint16 max_blocks_count, uint16 max_block_length){
+    return Autoarr_create(int8,max_blocks_count,max_block_length);
+}
+
+void StringBuilder_append_char(StringBuilder* b, char c){
+    Autoarr_add(b,c);
+}
+
+void StringBuilder_append_cptr(StringBuilder* b, char* s){
+    char c;
+    while((c=*s++))
+        Autoarr_add(b,c);
+}
+
+void StringBuilder_append_string(StringBuilder* b, string s){
+    while(s.length>0){
+        Autoarr_add(b,*s.ptr++);
+        s.length--;
+    }
+}
+
+void StringBuilder_append_int64(StringBuilder* b, int64 a){
+    uint8 i=0;
+    if(a==0){
+        Autoarr_add(b,'0');
+    }
+    else if(a<0){
+        Autoarr_add(b,'-');
+        a=-a;
+    }
+    char buf[24];
+    while(a!=0){
+        buf[i++]='0'+a%10;
+        a/=10;
+    }
+    string rev=string_reverse((string){buf,i});
+    StringBuilder_append_string(b,rev);
+    free(rev.ptr);
+}
+
+void StringBuilder_append_uint64(StringBuilder* b, uint64 a){
+    uint8 i=0;
+    if(a==0){
+        Autoarr_add(b,'0');
+    }
+    char buf[24];
+    while(a!=0){
+        buf[i++]='0'+a%10;
+        a/=10;
+    }
+    string rev=string_reverse((string){buf,i});
+    StringBuilder_append_string(b,rev);
+    free(rev.ptr);
+}
+
+void StringBuilder_append_double(StringBuilder* b, double a){
+    char buf[32];
+    sprintf(buf,"%lf",a);
+    StringBuilder_append_cptr(b,buf);
+}
+
+char* StringBuilder_build(StringBuilder* b){
+    uint32 len=Autoarr_length(b);
+    char* str=malloc(len+1);
+    str[len]=0;
+    for(uint32 i=0;i<len;i++)
+        str[i]=Autoarr_get(b,i);
+    return str;
+}

Autoarr/StringBuilder.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Autoarr.h"
+
+typedef Autoarr(int8) StringBuilder;
+
+StringBuilder StringBuilder_create(uint16 max_blocks_count, uint16 max_block_length);
+void StringBuilder_append_char(StringBuilder* b, char c);
+void StringBuilder_append_cptr(StringBuilder* b, char* s);
+void StringBuilder_append_string(StringBuilder* b, string s);
+void StringBuilder_append_int64(StringBuilder* b, int64 a);
+void StringBuilder_append_uint64(StringBuilder* b, uint64 a);
+void StringBuilder_append_double(StringBuilder* b, double a);
+char* StringBuilder_build(StringBuilder* b);