Autoarr2 renamed to Autoarr

DtsodC/src/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);
+}

DtsodC/src/Autoarr/Autoarr.h

@@ -0,0 +1,19 @@
+#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);

DtsodC/src/Autoarr/Autoarr2.c

@@ -1,23 +0,0 @@
-#include "Autoarr2.h"
-
-define_Autoarr2(uint8)
-define_Autoarr2(int8)
-define_Autoarr2(uint16)
-define_Autoarr2(int16)
-define_Autoarr2(uint32)
-define_Autoarr2(int32)
-define_Autoarr2(uint64)
-define_Autoarr2(int64)
-define_Autoarr2(float)
-define_Autoarr2(double)
-define_Autoarr2(Unitype)
-
-//right func to clear array of unitype values
-void Autoarr2_Unitype_clear(Autoarr2(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]);
-    Autoarr2_clear(ar);
-}

DtsodC/src/Autoarr/Autoarr2.h

@@ -1,19 +0,0 @@
-#pragma once
-
-#include "Autoarr2_declare.h"
-#include "Autoarr2_define.h"
-
-declare_Autoarr2(uint8)
-declare_Autoarr2(int8)
-declare_Autoarr2(uint16)
-declare_Autoarr2(int16)
-declare_Autoarr2(uint32)
-declare_Autoarr2(int32)
-declare_Autoarr2(uint64)
-declare_Autoarr2(int64)
-declare_Autoarr2(float)
-declare_Autoarr2(double)
-declare_Autoarr2(Unitype)
-
-//right func to clear array of unitype values
-void Autoarr2_Unitype_clear(Autoarr2(Unitype)* ar);

DtsodC/src/Autoarr/Autoarr2_declare.h

@@ -1,52 +0,0 @@
-#pragma once
-
-#include "../base/base.h"
-
-#define declare_Autoarr2(type)\
-\
-struct Autoarr2_##type;\
-\
-typedef struct {\
-    void (*add)(struct Autoarr2_##type* ar, type element);\
-    type (*get)(struct Autoarr2_##type* ar, uint32 index);\
-    type* (*getptr)(struct Autoarr2_##type* ar, uint32 index);\
-    void (*set)(struct Autoarr2_##type* ar, uint32 index, type element);\
-    void (*clear)(struct Autoarr2_##type* ar);\
-} __functions_list_t_##type;\
-\
-typedef struct Autoarr2_##type{\
-    uint16 blocks_count;\
-    uint16 max_blocks_count;\
-    uint16 block_length;\
-    uint16 max_block_length;\
-    type** values;\
-    __functions_list_t_##type* functions;\
-} Autoarr2_##type;\
-\
-void __Autoarr2_add_##type(Autoarr2_##type* ar, type element);\
-type __Autoarr2_get_##type(Autoarr2_##type* ar, uint32 index);\
-type* __Autoarr2_getptr_##type(Autoarr2_##type* ar, uint32 index);\
-void __Autoarr2_set_##type(Autoarr2_##type* ar, uint32 index, type element);\
-void __Autoarr2_clear_##type(Autoarr2_##type* ar);\
-Autoarr2_##type __Autoarr2_create_##type(uint16 max_blocks_count, uint16 max_block_length);
-
-#define Autoarr2(type) Autoarr2_##type
-
-#define Autoarr2_add(autoarr, element)\
-    autoarr->functions->add(autoarr, element)
-#define Autoarr2_get(autoarr, index)\
-    autoarr->functions->get(autoarr,index)
-#define Autoarr2_getptr(autoarr, index)\
-    autoarr->functions->getptr(autoarr,index)
-#define Autoarr2_set(autoarr, index, element)\
-    autoarr->functions->set(autoarr, index, element)
-#define Autoarr2_clear(autoarr)\
-    autoarr->functions->clear(autoarr)
-#define Autoarr2_create(type, max_blocks_count, max_block_length)\
-    __Autoarr2_create_##type(max_blocks_count, max_block_length)
-
-#define Autoarr2_length(autoarr) \
-    (uint32)(!autoarr->blocks_count ? 0 : \
-    autoarr->max_block_length*(autoarr->blocks_count-1)+autoarr->block_length)
-#define Autoarr2_max_length(autoarr)\
-    (uint32)(autoarr->max_block_length*autoarr->max_blocks_count)

DtsodC/src/Autoarr/Autoarr_declare.h

@@ -0,0 +1,52 @@
+#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)

DtsodC/src/Autoarr/Autoarr_define.h

@@ -2,9 +2,9 @@
 
 #include "../base/base.h"
 
-#define define_Autoarr2(type)\
+#define define_Autoarr(type)\
 \
-void __Autoarr2_add_##type(Autoarr2_##type* ar, type element){\
+void __Autoarr_add_##type(Autoarr_##type* ar, type element){\
     if(!ar->values){\
         ar->values=malloc(ar->max_blocks_count*sizeof(type*));\
         goto create_block;\
@@ -20,22 +20,22 @@ create_block:\
     ar->block_length++;\
 }\
 \
-type __Autoarr2_get_##type(Autoarr2_##type* ar, uint32 index){\
+type __Autoarr_get_##type(Autoarr_##type* ar, uint32 index){\
-    if(index>=Autoarr2_length(ar)) throw(ERR_WRONGINDEX);\
+    if(index>=Autoarr_length(ar)) throw(ERR_WRONGINDEX);\
     return ar->values[index/ar->max_block_length][index%ar->max_block_length];\
 }\
 \
-type* __Autoarr2_getptr_##type(Autoarr2_##type* ar, uint32 index){\
+type* __Autoarr_getptr_##type(Autoarr_##type* ar, uint32 index){\
-    if(index>=Autoarr2_length(ar)) throw(ERR_WRONGINDEX);\
+    if(index>=Autoarr_length(ar)) throw(ERR_WRONGINDEX);\
     return ar->values[index/ar->max_block_length]+(index%ar->max_block_length);\
 }\
 \
-void __Autoarr2_set_##type(Autoarr2_##type* ar, uint32 index, type element){\
+void __Autoarr_set_##type(Autoarr_##type* ar, uint32 index, type element){\
-    if(index>=Autoarr2_length(ar)) throw(ERR_WRONGINDEX);\
+    if(index>=Autoarr_length(ar)) throw(ERR_WRONGINDEX);\
     ar->values[index/ar->max_block_length][index%ar->max_block_length]=element;\
 }\
 \
-void __Autoarr2_clear_##type(Autoarr2_##type* ar){\
+void __Autoarr_clear_##type(Autoarr_##type* ar){\
     for(uint16 i=0; i<ar->blocks_count;i++)\
         free(ar->values[i]); \
     free(ar->values);\
@@ -45,15 +45,15 @@ void __Autoarr2_clear_##type(Autoarr2_##type* ar){\
 }\
 \
 __functions_list_t_##type __functions_list_##type={\
-    &__Autoarr2_add_##type,\
+    &__Autoarr_add_##type,\
-    &__Autoarr2_get_##type,\
+    &__Autoarr_get_##type,\
-    &__Autoarr2_getptr_##type,\
+    &__Autoarr_getptr_##type,\
-    &__Autoarr2_set_##type,\
+    &__Autoarr_set_##type,\
-    &__Autoarr2_clear_##type\
+    &__Autoarr_clear_##type\
 };\
 \
-Autoarr2_##type __Autoarr2_create_##type(uint16 max_blocks_count, uint16 max_block_length){\
+Autoarr_##type __Autoarr_create_##type(uint16 max_blocks_count, uint16 max_block_length){\
-    return (Autoarr2_##type){\
+    return (Autoarr_##type){\
         .max_blocks_count=max_blocks_count,\
         .blocks_count=0,\
         .max_block_length=max_block_length,\

DtsodC/src/Autoarr/StringBuilder.c

@@ -1,24 +1,24 @@
 #include "StringBuilder.h"
 
 StringBuilder StringBuilder_create(uint16 max_blocks_count, uint16 max_block_length){
-    return Autoarr2_create(int8,max_blocks_count,max_block_length);
+    return Autoarr_create(int8,max_blocks_count,max_block_length);
 }
 
 void StringBuilder_append(StringBuilder* b, char c){
-    Autoarr2_add(b,c);
+    Autoarr_add(b,c);
 }
 
 void StringBuilder_append_str(StringBuilder* b, char* s){
     char c;
     while((c=*s++))
-        Autoarr2_add(b,c);
+        Autoarr_add(b,c);
 }
 
 char* StringBuilder_build(StringBuilder* b){
-    uint32 len=Autoarr2_length(b);
+    uint32 len=Autoarr_length(b);
     char* str=malloc(len+1);
     str[len]=0;
     for(uint32 i=0;i<len;i++)
-        str[i]=Autoarr2_get(b,i);
+        str[i]=Autoarr_get(b,i);
     return str;
 }

DtsodC/src/Autoarr/StringBuilder.h

@@ -1,8 +1,8 @@
 #pragma once
 
-#include "Autoarr2.h"
+#include "Autoarr.h"
 
-typedef Autoarr2(int8) StringBuilder;
+typedef Autoarr(int8) StringBuilder;
 
 StringBuilder StringBuilder_create(uint16 max_blocks_count, uint16 max_block_length);
 void StringBuilder_append(StringBuilder* b, char c);

DtsodC/src/DtsodParser/DtsodV24.c

@@ -85,12 +85,12 @@ Hashtable* __deserialize(char** _text, bool calledRecursively){
             return str;
         };
 
-        Autoarr2(Unitype)* ReadList(){
+        Autoarr(Unitype)* ReadList(){
-            Autoarr2(Unitype)* list=malloc(sizeof(Autoarr2(Unitype)));
+            Autoarr(Unitype)* list=malloc(sizeof(Autoarr(Unitype)));
-            *list=Autoarr2_create(Unitype,ARR_BC,ARR_BL);
+            *list=Autoarr_create(Unitype,ARR_BC,ARR_BL);
             readingList=true;
             while (true){
-                Autoarr2_add(list,ReadValue());
+                Autoarr_add(list,ReadValue());
                 if (!readingList) break;
             }
             return list;
@@ -212,17 +212,17 @@ Hashtable* __deserialize(char** _text, bool calledRecursively){
         char* nameCPtr=string_cpToCharPtr(name);
         Unitype value=ReadValue();
         if(partOfDollarList){
-            Autoarr2(Unitype)* list;
+            Autoarr(Unitype)* list;
             Unitype lu;
             if(Hashtable_try_get(dict,nameCPtr, &lu)){
-                list=(Autoarr2(Unitype)*)lu.VoidPtr;
+                list=(Autoarr(Unitype)*)lu.VoidPtr;
             }
             else{
-                list=malloc(sizeof(Autoarr2(Unitype)));
+                list=malloc(sizeof(Autoarr(Unitype)));
-                *list=Autoarr2_create(Unitype,ARR_BC,ARR_BL);
+                *list=Autoarr_create(Unitype,ARR_BC,ARR_BL);
                 Hashtable_add(dict,nameCPtr,UniPtr(AutoarrUnitypePtr,list));
             }
-            Autoarr2_add(list,value);
+            Autoarr_add(list,value);
         }
         else Hashtable_add(dict,nameCPtr,value);
     }

DtsodC/src/Hashtable/Hashtable.c

@@ -11,15 +11,15 @@ static const uint16 HT_HEIGHTS[]={61,257,1021,4099,16381,65521};
 Hashtable* Hashtable_create(){
     Hashtable* ht=malloc(sizeof(Hashtable));
     ht->hein=HT_HEIN_MIN;
-    ht->rows=malloc(HT_HEIGHTS[HT_HEIN_MIN]*sizeof(Autoarr2(KeyValuePair)));
+    ht->rows=malloc(HT_HEIGHTS[HT_HEIN_MIN]*sizeof(Autoarr(KeyValuePair)));
     for(uint16 i=0;i<HT_HEIGHTS[HT_HEIN_MIN];i++)
-        ht->rows[i]=Autoarr2_create(KeyValuePair,ARR_BC,ARR_BL);
+        ht->rows[i]=Autoarr_create(KeyValuePair,ARR_BC,ARR_BL);
     return ht;
 }
 
 void Hashtable_free(Hashtable* ht){
     for(uint16 i=0;i<HT_HEIGHTS[ht->hein];i++){
-        Autoarr2_KeyValuePair_clear(ht->rows+i);
+        Autoarr_KeyValuePair_clear(ht->rows+i);
     }
     free(ht->rows);
     free(ht);
@@ -30,27 +30,27 @@ uint32 Hashtable_height(Hashtable* ht){ return HT_HEIGHTS[ht->hein]; }
 
 void Hashtable_expand(Hashtable* ht){
     if(ht->hein>=HT_HEIN_MAX) throw(ERR_MAXLENGTH);
-    Autoarr2(KeyValuePair)* newrows=malloc(HT_HEIGHTS[++ht->hein]*sizeof(Autoarr2(KeyValuePair)));
+    Autoarr(KeyValuePair)* newrows=malloc(HT_HEIGHTS[++ht->hein]*sizeof(Autoarr(KeyValuePair)));
     for(uint16 i=0;i<HT_HEIGHTS[ht->hein];i++)
-        newrows[i]=Autoarr2_create(KeyValuePair,ARR_BC,ARR_BL);
+        newrows[i]=Autoarr_create(KeyValuePair,ARR_BC,ARR_BL);
     for(uint16 i=0;i<HT_HEIGHTS[ht->hein-1];i++){
-        Autoarr2(KeyValuePair)* ar=ht->rows+i;
+        Autoarr(KeyValuePair)* ar=ht->rows+i;
-        uint32 arlen=Autoarr2_length(ar);
+        uint32 arlen=Autoarr_length(ar);
         for(uint16 k=0;k<arlen;k++){
-            KeyValuePair p=Autoarr2_get(ar,k);
+            KeyValuePair p=Autoarr_get(ar,k);
             uint16 newrown=ihash(p.key)%HT_HEIGHTS[ht->hein];
-            Autoarr2(KeyValuePair)* newar=newrows+newrown;
+            Autoarr(KeyValuePair)* newar=newrows+newrown;
-            Autoarr2_add(newar,p);
+            Autoarr_add(newar,p);
         }
-        Autoarr2_clear(ar);
+        Autoarr_clear(ar);
     }
     free(ht->rows);
     ht->rows=newrows;
 }
 
-Autoarr2(KeyValuePair)* getrow(Hashtable* ht, char* key, bool can_expand){
+Autoarr(KeyValuePair)* getrow(Hashtable* ht, char* key, bool can_expand){
-    Autoarr2(KeyValuePair)* ar=ht->rows+ihash(key)%HT_HEIGHTS[ht->hein];
+    Autoarr(KeyValuePair)* ar=ht->rows+ihash(key)%HT_HEIGHTS[ht->hein];
-    if(can_expand && Autoarr2_length(ar)==Autoarr2_max_length(ar))
+    if(can_expand && Autoarr_length(ar)==Autoarr_max_length(ar))
         optime("expand",1,(Hashtable_expand(ht)));
     ar=ht->rows+ihash(key)%HT_HEIGHTS[ht->hein];
     return ar;
@@ -58,7 +58,7 @@ Autoarr2(KeyValuePair)* getrow(Hashtable* ht, char* key, bool can_expand){
 
 
 void Hashtable_add_pair(Hashtable* ht, KeyValuePair p){
-    Autoarr2_add(getrow(ht,p.key,true),p);
+    Autoarr_add(getrow(ht,p.key,true),p);
 }
 void Hashtable_add(Hashtable* ht, char* key, Unitype u){
     Hashtable_add_pair(ht,KVPair(key,u));
@@ -66,20 +66,20 @@ void Hashtable_add(Hashtable* ht, char* key, Unitype u){
 
 //returns null or pointer to value in hashtable
 Unitype* Hashtable_getptr(Hashtable* ht, char* key){
-    Autoarr2(KeyValuePair)* ar=getrow(ht,key,false);
+    Autoarr(KeyValuePair)* ar=getrow(ht,key,false);
-    uint32 arlen=Autoarr2_length(ar);
+    uint32 arlen=Autoarr_length(ar);
     for(uint32 i=0;i<arlen;i++){
-        KeyValuePair* p=Autoarr2_getptr(ar,i);
+        KeyValuePair* p=Autoarr_getptr(ar,i);
         if(charbuf_compare(key,p->key)) return &p->value;
     }
     return NULL;
 }
 
 Unitype Hashtable_get(Hashtable* ht, char* key){
-    Autoarr2(KeyValuePair)* ar=getrow(ht,key,false);
+    Autoarr(KeyValuePair)* ar=getrow(ht,key,false);
-    uint32 arlen=Autoarr2_length(ar);
+    uint32 arlen=Autoarr_length(ar);
     for(uint32 i=0;i<arlen;i++){
-        KeyValuePair p=Autoarr2_get(ar,i);
+        KeyValuePair p=Autoarr_get(ar,i);
         if(charbuf_compare(key,p.key)) return p.value;
     }
     return UniNull;

DtsodC/src/Hashtable/Hashtable.h

@@ -6,7 +6,7 @@
 
 typedef struct Hashtable{
     uint8 hein;  //height=HT_HEIGHTS[hein] 
-    Autoarr2(KeyValuePair)* rows; // Autoarr[height]
+    Autoarr(KeyValuePair)* rows; // Autoarr[height]
 } Hashtable;
 
 Hashtable* Hashtable_create();

DtsodC/src/Hashtable/KeyValuePair.c

@@ -1,6 +1,6 @@
 #include "KeyValuePair.h"
 
-define_Autoarr2(KeyValuePair)
+define_Autoarr(KeyValuePair)
 
 
 //proper way to clear a KVP
@@ -10,11 +10,11 @@ void KeyValuePair_free(KeyValuePair p){
 }
 
 //func for  KVP array clearing
-void Autoarr2_KeyValuePair_clear(Autoarr2_KeyValuePair* ar){
+void Autoarr_KeyValuePair_clear(Autoarr_KeyValuePair* ar){
     for(uint16 blockI=0; blockI < ar->blocks_count-1; blockI++)
         for(uint16 elemI=0; elemI < ar->max_block_length; elemI++)
             KeyValuePair_free(ar->values[blockI][elemI]);
     for(uint16 elemI=0; elemI < ar->block_length; elemI++)
         KeyValuePair_free(ar->values[ar->blocks_count-1][elemI]);
-    Autoarr2_clear(ar);
+    Autoarr_clear(ar);
 }

DtsodC/src/Hashtable/KeyValuePair.h

@@ -1,15 +1,15 @@
 #include "../base/base.h"
-#include "../Autoarr/Autoarr2.h"
+#include "../Autoarr/Autoarr.h"
 
 typedef struct KeyValuePair{
     char* key;
     Unitype value;
 } KeyValuePair;
 
-declare_Autoarr2(KeyValuePair)
+declare_Autoarr(KeyValuePair)
 
 //proper way to clear a KVP
 void KeyValuePair_free(KeyValuePair p);
 
 //func to clear KVP array
-void Autoarr2_KeyValuePair_clear(Autoarr2_KeyValuePair* ar);
+void Autoarr_KeyValuePair_clear(Autoarr_KeyValuePair* ar);

DtsodC/src/base/types.c

@@ -1,6 +1,6 @@
 #include "types.h"
 #include "errors.h"
-#include "../Autoarr/Autoarr2.h"
+#include "../Autoarr/Autoarr.h"
 #include "../Hashtable/Hashtable.h"
 #include "../SearchTree/SearchTree.h"
 
@@ -80,36 +80,36 @@ void Unitype_free(Unitype u){
             STNode_free(u.VoidPtr);
             break;
         case AutoarrInt8Ptr: 
-            Autoarr2_clear(((Autoarr2(int8)*)u.VoidPtr));
+            Autoarr_clear(((Autoarr(int8)*)u.VoidPtr));
             break;
         case AutoarrUInt8Ptr:
-            Autoarr2_clear(((Autoarr2(uint8)*)u.VoidPtr));
+            Autoarr_clear(((Autoarr(uint8)*)u.VoidPtr));
             break;
         case AutoarrInt16Ptr: 
-            Autoarr2_clear(((Autoarr2(int16)*)u.VoidPtr));
+            Autoarr_clear(((Autoarr(int16)*)u.VoidPtr));
             break;
         case AutoarrUInt16Ptr: 
-            Autoarr2_clear(((Autoarr2(uint16)*)u.VoidPtr));
+            Autoarr_clear(((Autoarr(uint16)*)u.VoidPtr));
             break;
         case AutoarrInt32Ptr: 
-            Autoarr2_clear(((Autoarr2(int32)*)u.VoidPtr));
+            Autoarr_clear(((Autoarr(int32)*)u.VoidPtr));
             break;
         case AutoarrUInt32Ptr: 
-            Autoarr2_clear(((Autoarr2(uint32)*)u.VoidPtr));
+            Autoarr_clear(((Autoarr(uint32)*)u.VoidPtr));
             break;
         case AutoarrInt64Ptr: 
-            Autoarr2_clear(((Autoarr2(int64)*)u.VoidPtr));
+            Autoarr_clear(((Autoarr(int64)*)u.VoidPtr));
             break;
         case AutoarrUInt64Ptr: 
-            Autoarr2_clear(((Autoarr2(uint64)*)u.VoidPtr));
+            Autoarr_clear(((Autoarr(uint64)*)u.VoidPtr));
             break;
         case AutoarrUnitypePtr:
-            Autoarr2_Unitype_clear(u.VoidPtr);
+            Autoarr_Unitype_clear(u.VoidPtr);
-            free((Autoarr2(Unitype)*)u.VoidPtr);
+            free((Autoarr(Unitype)*)u.VoidPtr);
             break;
         case AutoarrKVPairPtr: 
-            Autoarr2_KeyValuePair_clear(u.VoidPtr);
+            Autoarr_KeyValuePair_clear(u.VoidPtr);
-            free((Autoarr2(KeyValuePair)*)u.VoidPtr);
+            free((Autoarr(KeyValuePair)*)u.VoidPtr);
             break;
         default: throw(ERR_WRONGTYPE);
     }

DtsodC/tests/main.c

@@ -16,7 +16,7 @@ void printuni(Unitype v){
 
 void test_all(){
     test_searchtree();
-    test_autoarr2();
+    test_autoarr();
     test_hashtable();
     test_string();
     test_dtsod();

DtsodC/tests/test_autoarr.c

@@ -0,0 +1,52 @@
+#include "tests.h"
+#include "../src/Autoarr/Autoarr.h"
+
+static void printautoarr(Autoarr(uint16)* ar){
+    printf("\e[94mAutoarr(uint16): %lu\n"
+        "  max_blocks_count: %u\n"
+        "  blocks_count: %u\n"
+        "  max_block_length: %u\n"
+        "  block_length: %u\n"
+        "  max_length: %u\n" 
+        "  length: %u\n",
+        sizeof(Autoarr(uint16)),
+        ar->max_blocks_count,
+        ar->blocks_count,
+        ar->max_block_length,
+        ar->block_length,
+        Autoarr_max_length(ar),
+        Autoarr_length(ar));
+}
+
+static void fillar(Autoarr(uint16)* ar){
+    for (uint16 i=0;i<Autoarr_max_length(ar);i++)
+        Autoarr_add(ar,i);
+}
+static void resetar(Autoarr(uint16)* ar){
+    for (uint16 i=0;i<Autoarr_max_length(ar);i++)
+        Autoarr_set(ar,i,Autoarr_max_length(ar)-i-1);
+}
+
+static void printallval(Autoarr(uint16)* ar){
+    printf("\e[90m");
+    for (uint16 i=0;i<Autoarr_length(ar);i++)
+        printf("%u ",Autoarr_get(ar,i));
+    printf("\n");
+}
+
+void test_autoarr(){
+    optime("test_autoarr",1,({
+        printf("\e[96m------------[test_autoarr]------------\n");
+        Autoarr(uint16) ar=Autoarr_create(uint16,10,16);
+        printf("\e[92mautoarr created\n");
+        fillar(&ar);
+        printf("\e[92mautoarr filled up\n");
+        printautoarr(&ar);
+        printallval(&ar);
+        resetar(&ar);
+        printf("\e[92mautoarr values reset\n");
+        printallval(&ar);
+        Autoarr_clear(((&ar)));
+        printf("\e[92mautoarr cleared\n");
+    }));
+}

DtsodC/tests/test_autoarr2.c

@@ -1,52 +0,0 @@
-#include "tests.h"
-#include "../src/Autoarr/Autoarr2.h"
-
-static void printautoarr(Autoarr2(uint16)* ar){
-    printf("\e[94mAutoarr2(uint16): %lu\n"
-        "  max_blocks_count: %u\n"
-        "  blocks_count: %u\n"
-        "  max_block_length: %u\n"
-        "  block_length: %u\n"
-        "  max_length: %u\n" 
-        "  length: %u\n",
-        sizeof(Autoarr2(uint16)),
-        ar->max_blocks_count,
-        ar->blocks_count,
-        ar->max_block_length,
-        ar->block_length,
-        Autoarr2_max_length(ar),
-        Autoarr2_length(ar));
-}
-
-static void fillar(Autoarr2(uint16)* ar){
-    for (uint16 i=0;i<Autoarr2_max_length(ar);i++)
-        Autoarr2_add(ar,i);
-}
-static void resetar(Autoarr2(uint16)* ar){
-    for (uint16 i=0;i<Autoarr2_max_length(ar);i++)
-        Autoarr2_set(ar,i,Autoarr2_max_length(ar)-i-1);
-}
-
-static void printallval(Autoarr2(uint16)* ar){
-    printf("\e[90m");
-    for (uint16 i=0;i<Autoarr2_length(ar);i++)
-        printf("%u ",Autoarr2_get(ar,i));
-    printf("\n");
-}
-
-void test_autoarr2(){
-    optime("test_autoarr2",1,({
-        printf("\e[96m------------[test_autoarr2]------------\n");
-        Autoarr2(uint16) ar=Autoarr2_create(uint16,10,16);
-        printf("\e[92mautoarr created\n");
-        fillar(&ar);
-        printf("\e[92mautoarr filled up\n");
-        printautoarr(&ar);
-        printallval(&ar);
-        resetar(&ar);
-        printf("\e[92mautoarr values reset\n");
-        printallval(&ar);
-        Autoarr2_clear(((&ar)));
-        printf("\e[92mautoarr cleared\n");
-    }));
-}

DtsodC/tests/test_dtsod.c

@@ -20,8 +20,8 @@ void test_dtsod(){
         printf("\e[92mhashtable_get(message)->\n\e[94m");
         Unitype msg=Hashtable_get(dtsod,"message");
         printuni(msg);
-        Autoarr2(Unitype)* ar=msg.VoidPtr;
+        Autoarr(Unitype)* ar=msg.VoidPtr;
-        id=Hashtable_get(Autoarr2_get(ar,0).VoidPtr,"message_id");
+        id=Hashtable_get(Autoarr_get(ar,0).VoidPtr,"message_id");
         printf("\e[92m\nmessage_id: %lu\n",id.UInt64);
         Hashtable_free(dtsod);
     }));

DtsodC/tests/test_hashtable.c

@@ -25,8 +25,8 @@ void printrowgraph(Hashtable* ht){
      for(uint32 i=0; i<lgs_l; i++)
         lgs[i]=0; 
     for(uint16 h=0;h<Hashtable_height(ht);h++){
-        Autoarr2(KeyValuePair)* ar=ht->rows+h;
+        Autoarr(KeyValuePair)* ar=ht->rows+h;
-        uint32 l=Autoarr2_length(ar);
+        uint32 l=Autoarr_length(ar);
         lgs[l]++;
     }
     for(uint32 i=0; i<lgs_l; i++)

DtsodC/tests/tests.h

@@ -5,7 +5,7 @@
 void printuni(Unitype v);
 
 void test_searchtree();
-void test_autoarr2();
+void test_autoarr();
 void test_hashtable();
 void test_string();
 void test_dtsod();