deserialization completed?

.vscode/settings.json

@@ -8,7 +8,12 @@
         "ranges": "c",
         "streambuf": "c",
         "chrono": "c",
-        "string": "c"
+        "string": "c",
+        "deque": "c",
+        "list": "c",
+        "unordered_map": "c",
+        "vector": "c",
+        "system_error": "c"
     },
     "C_Cpp.errorSquiggles": "Disabled"
 }

DTLib/Experimental/Tester.cs

@@ -12,6 +12,6 @@ public static class Tester
             operation();
         clock.Stop();
         double time=(double)(clock.ElapsedTicks)/Stopwatch.Frequency/repeats;
-        LogNoTime("y",$"operation ","b",op_name,"y"," took ","b",time.ToString(),"y"," seconds");
+        LogNoTime("y",$"operation ","b",op_name,"y"," lasted ","b",time.ToString(),"y"," seconds");
     }
 }

DtsodC/src/Autoarr/Autoarr2.c

@@ -11,3 +11,13 @@ 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

@@ -15,4 +15,5 @@ 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_define.h

@@ -37,7 +37,7 @@ void __Autoarr2_set_##type(Autoarr2_##type* ar, uint32 index, type element){\
 \
 void __Autoarr2_clear_##type(Autoarr2_##type* ar){\
     for(uint16 i=0; i<ar->blocks_count;i++)\
-                free(ar->values[i]); \
+        free(ar->values[i]); \
     free(ar->values);\
     ar->values=NULL;\
     ar->blocks_count=0;\

DtsodC/src/DtsodParser/DtsodV24.c

@@ -31,18 +31,27 @@ Hashtable* __deserialize(char** _text, bool calledRecursively){
 
     string ReadName(){
         string nameStr={text,0};
-        while ((c=*++text)) switch (c){
+        while ((c=*text++)) switch (c){
             case ' ':  case '\t':
             case '\r': case '\n':
+                if(nameStr.length!=0)
+                    throw_wrongchar(c);
+                nameStr.ptr++;
                 break;
             case '#':
                 SkipComment();
+                if(nameStr.length!=0)
+                    throw_wrongchar(c);
+                nameStr.ptr=text;
                 break;
             case '}':
                 if(!calledRecursively) throw_wrongchar(c);
             case ':':
                 return nameStr;
             case '$':
+                if(nameStr.length!=0)
+                    throw_wrongchar(c);
+                nameStr.ptr++;
                 partOfDollarList=true;
                 break;
             case '=':  case ';':
@@ -68,7 +77,6 @@ Hashtable* __deserialize(char** _text, bool calledRecursively){
             bool prevIsBackslash = false;
             string str={text,1};
             while ((c=*++text)!='"' || prevIsBackslash){
-                printf("%c",c);
                 if (!c) throw(ERR_ENDOFSTR);
                 prevIsBackslash= c=='\\' && !prevIsBackslash;
                 str.length++;
@@ -121,24 +129,33 @@ Hashtable* __deserialize(char** _text, bool calledRecursively){
                     if(str.ptr[str.length-1]=='"'){
                         //removing quotes
                         string _str={str.ptr+1,str.length-1};
-                        return UniPtr(CharPtr, string_cpToCharPtr(_str));
+                        return UniPtr(CharPtr,string_cpToCharPtr(_str));
                     }
                     else throw_wrongchar(*str.ptr);
                     break;
                 default: 
                     switch(str.ptr[str.length-1]){
-                        case 'f':
+                        case 'f': {
-                            return Uni(Double,strtod(string_cpToCharPtr(str),NULL));
+                                char* _c=string_cpToCharPtr(str);
-                        case 'u': ; //some weird "empty statement"
+                                Unitype rez=Uni(Double,strtod(_c,NULL));
-                            //not "statement"
+                                free(_c);
-                            uint64 lu=0;
+                                return rez;
-                            sscanf(string_cpToCharPtr(str),"%lu",&lu);
+                            }
-                            return Uni(UInt64,lu);
+                        case 'u': {
+                                uint64 lu=0;
+                                char* _c=string_cpToCharPtr(str);
+                                sscanf(_c,"%lu",&lu);
+                                free(_c);
+                                return Uni(UInt64,lu);
+                            }
                         case '0': case '1': case '2': case '3': case '4':
-                        case '5': case '6': case '7': case '8': case '9': ;
+                        case '5': case '6': case '7': case '8': case '9': {
-                            int64 li=0;
+                                int64 li=0;
-                            sscanf(string_cpToCharPtr(str),"%li",&li);
+                                char* _c=string_cpToCharPtr(str);
-                            return Uni(Int64,li);
+                                sscanf(_c,"%li",&li);
+                                free(_c);
+                                return Uni(Int64,li);
+                            }
                         default:
                             throw_wrongchar(str.ptr[str.length-1]);
                     }
@@ -187,7 +204,8 @@ Hashtable* __deserialize(char** _text, bool calledRecursively){
         return UniNull;
     };
 
-    while((c=*text++)){
+    text--;
+    while((c=*++text)){
         string name=ReadName();
         if(name.length==0) //end of file or '}' in recursive call 
             goto END;
@@ -196,8 +214,9 @@ Hashtable* __deserialize(char** _text, bool calledRecursively){
         if(partOfDollarList){
             Autoarr2(Unitype)* list;
             Unitype lu;
-            if(Hashtable_try_get(dict,nameCPtr, &lu))
+            if(Hashtable_try_get(dict,nameCPtr, &lu)){
                 list=(Autoarr2(Unitype)*)lu.VoidPtr;
+            }
             else{
                 list=malloc(sizeof(Autoarr2(Unitype)));
                 *list=Autoarr2_create(Unitype,ARR_BC,ARR_BL);

DtsodC/src/DtsodParser/DtsodV24.c.backup

@@ -1,187 +0,0 @@
-#include "DtsodV24.h"
-#include "../Autoarr/StringBuilder.h"
-
-#define ARR_BC 2
-#define ARR_BL 8
-
-Hashtable* __parse(string textStr, bool called_recursively){
-    Hashtable* dict=Hashtable_create();
-    char* text=textStr.ptr;
-    char c;
-    bool partOfDollarList=false;
-    bool readingList=false;
-
-    void throw_wrongchar(char _c){
-                char errstr[]="unexpected <c>";
-                errstr[12]=_c;
-                throw(errstr);
-    };
-
-    void SkipComment(){
-        while((c=*++text)!='\n')
-            if(!c) throw(ERR_ENDOFSTR);
-    };
-
-    string ReadName(){
-        string nameStr={text,0};
-        while ((c=*++text)) switch (c){
-            case ' ':  case '\t':
-            case '\r': case '\n':
-                break;
-            case '#':
-                SkipComment();
-                break;
-            case '}':
-                if(!called_recursively) throw_wrongchar(c);
-            case ':':
-                return nameStr;
-            case '$':
-                partOfDollarList=true;
-                break;
-            case '=':  case ';':
-            case '\'': case '"':
-            case '[':  case ']':
-            case '{':  
-                throw_wrongchar(c);
-            default:
-                nameStr.length++;
-                break;
-        }
-
-        if(nameStr.length>0) throw(ERR_ENDOFSTR);
-        return nameStr;
-    };
-
-    Unitype ReadValue(){
-        string valueStr={text,0};
-
-        //returns part of <text> with brackets
-        string ReadString(){
-            bool prevIsBackslash = false;
-            string str={text,1};
-            while ((c=*++text)!='"' || prevIsBackslash){
-                if (!c) throw(ERR_ENDOFSTR);
-                prevIsBackslash= c=='\\' && !prevIsBackslash;
-                str.length++;
-            }
-            str.length++;
-            return str;
-        };
-
-        Autoarr2(Unitype)* ReadList(){
-            Autoarr2(Unitype)* list=malloc(sizeof(Autoarr2(Unitype)));
-            *list=Autoarr2_create(Unitype,ARR_BC,ARR_BL);
-            readingList=true;
-            while (true){
-                Autoarr2_add(list,ReadValue());
-                if (!readingList) break;
-            }
-            return list;
-        };
-
-        Hashtable* ReadDtsod(){
-            short bracketBalance = 1;
-            string dtsodStr={text+1,0};
-            while ((c=*++text))//пропускает начальный символ '{'
-            {
-                if(bracketBalance) switch (c)
-                {
-                    case ' ':  case '\t':
-                    case '\r': case '\n':
-                        break;
-                    case '#':
-                        SkipComment();
-                        break;
-                    case '{':
-                        bracketBalance++;
-                        dtsodStr.length++;
-                        break;
-                    case '}':
-                        bracketBalance--;
-                        if (bracketBalance != 0)
-                            dtsodStr.length++;
-                        break;
-                    case '"':
-                        string _str=ReadString();
-                        dtsodStr.length+=_str.length;
-                        break;
-                    default:
-                        dtsodStr.length++;
-                        break;
-                }
-                else return __parse(dtsodStr,true);
-            }
-
-            throw(ERR_ENDOFSTR);
-            return NULL;
-        };
-
-        Unitype ParseValue(string str){
-
-            throw(ERR_NOTIMPLEMENTED);
-            return UniNull;
-        };
-
-        while ((c=*++text)) switch (c){
-            case ' ':  case '\t':
-            case '\r': case '\n':
-                break;
-            case '#':
-                SkipComment();
-                break;
-            case '"':
-                valueStr=ReadString();
-                break;
-            case '\'':
-                text++;
-                char valueChar=*++text;
-                if (*++text != '\'') throw("after <'> should be char");
-                else if (valueStr.length!=0) throw("char assignement error");
-                else return Uni(Char,valueChar);
-                break;
-            case ';':
-            case ',':
-                return ParseValue(valueStr);
-            case '[':
-                return UniPtr(AutoarrUnitypePtr,ReadList());
-            case ']':
-                readingList=false;
-                break;
-            case '{':
-                return UniPtr(HashtablePtr,ReadDtsod());
-            case '=': case ':': 
-            case '}': case '$':
-                throw_wrongchar(c);
-            default:
-                valueStr.length++;
-                break;
-        }
-
-        throw(ERR_ENDOFSTR);
-        return UniNull;
-    };
-
-    while((c=*text++)){
-        string name=ReadName();
-        if(name.length==0) //closing figure bracket in recursive call or end of file
-            return dict;
-        char* nameCPtr=string_cpToCharPtr(name);
-        Unitype value=ReadValue();
-        if(partOfDollarList){
-            Autoarr2(Unitype)* list;
-            Unitype lu;
-            if(Hashtable_try_get(dict,nameCPtr, &lu))
-                list=(Autoarr2(Unitype)*)lu.VoidPtr;
-            else{
-                list=malloc(sizeof(Autoarr2(Unitype)));
-                *list=Autoarr2_create(Unitype,ARR_BC,ARR_BL);
-                Hashtable_add(dict,nameCPtr,UniPtr(AutoarrUnitypePtr,list));
-            }
-            Autoarr2_add(list,value);
-        }
-        else Hashtable_add(dict,nameCPtr,value);
-    }
-    return dict;
-}
-
-Hashtable* DtsodV24_parse(const char* text) { return __parse((text,false); }

DtsodC/src/Hashtable/Hashtable.c

@@ -1,7 +1,5 @@
 #include "Hashtable.h"
 
-define_Autoarr2(KeyValuePair)
-
 // amount of rows
 #define HT_HEIN_MIN 0
 #define HT_HEIN_MAX 5
@@ -21,10 +19,7 @@ Hashtable* Hashtable_create(){
 
 void Hashtable_free(Hashtable* ht){
     for(uint16 i=0;i<HT_HEIGHTS[ht->hein];i++){
-        Autoarr2(KeyValuePair)* ar=(Autoarr2(KeyValuePair)*)(ht->rows+i);
+        Autoarr2_KeyValuePair_clear(ht->rows+i);
-        for(uint32 i=0;i<Autoarr2_length(ar);i++)
-            free(Autoarr2_getptr(ar,i)->key);
-        Autoarr2_clear(ar);
     }
     free(ht->rows);
     free(ht);
@@ -66,7 +61,7 @@ void Hashtable_add_pair(Hashtable* ht, KeyValuePair p){
     Autoarr2_add(getrow(ht,p.key,true),p);
 }
 void Hashtable_add(Hashtable* ht, char* key, Unitype u){
-    Hashtable_add_pair(ht,cpair(key,u));
+    Hashtable_add_pair(ht,KVPair(key,u));
 }
 
 //returns null or pointer to value in hashtable
@@ -90,12 +85,12 @@ Unitype Hashtable_get(Hashtable* ht, char* key){
     return UniNull;
 }
 KeyValuePair Hashtable_get_pair(Hashtable* ht, char* key){
-    return cpair(key,Hashtable_get(ht,key));
+    return KVPair(key,Hashtable_get(ht,key));
 }
 bool Hashtable_try_get(Hashtable* ht, char* key, Unitype* output){
     Unitype u=Hashtable_get(ht,key);
     *output=u;
-    return u.type==Null;
+    return u.type!=Null;
 }
 
 /* void Hashtable_set_pair(Hashtable* ht, KeyValuePair p){
@@ -103,4 +98,4 @@ bool Hashtable_try_get(Hashtable* ht, char* key, Unitype* output){
 
     }
 }
-void Hashtable_set(Hashtable* ht, char* key, Unitype u){ Hashtable_set_pair(ht,cpair(key,u)); } */
+void Hashtable_set(Hashtable* ht, char* key, Unitype u){ Hashtable_set_pair(ht,KVPair(key,u)); } */

DtsodC/src/Hashtable/Hashtable.h

@@ -1,18 +1,8 @@
 #pragma once
 
 #include "../base/base.h"
-#include "../Autoarr/Autoarr2.h"
 #include "hash.h"
-
+#include "KeyValuePair.h"
-typedef struct KeyValuePair{
-    char* key;
-    Unitype value;
-} KeyValuePair;
-
-//copies string and value to new KeyValuePair
-KeyValuePair cpair(char* key, Unitype value);
-
-declare_Autoarr2(KeyValuePair)
 
 typedef struct Hashtable{
     uint8 hein;  //height=HT_HEIGHTS[hein] 
@@ -27,7 +17,7 @@ uint32 Hashtable_height(Hashtable* ht);
 
 //adds charptr and value to new KeyValuePair
 //use charbuf_copy() to create new string if needed
-#define cpair(key,value) (KeyValuePair){key,value}
+#define KVPair(key,value) (KeyValuePair){key,value}
 
 
 void Hashtable_add_pair(Hashtable* ht, KeyValuePair p);
@@ -42,4 +32,4 @@ bool Hashtable_try_get(Hashtable* ht, char* key, Unitype* output);
 
 //not implemented yet
 void Hashtable_set_pair(Hashtable* ht, KeyValuePair p);
-void Hashtable_set(Hashtable* ht, char* key, Unitype u);
+void Hashtable_set(Hashtable* ht, char* key, Unitype u);

DtsodC/src/Hashtable/KeyValuePair.c

@@ -0,0 +1,20 @@
+#include "KeyValuePair.h"
+
+define_Autoarr2(KeyValuePair)
+
+
+//proper way to clear a KVP
+void KeyValuePair_free(KeyValuePair p){
+    free(p.key);
+    Unitype_free(p.value);
+}
+
+//func for  KVP array clearing
+void Autoarr2_KeyValuePair_clear(Autoarr2_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);
+}

DtsodC/src/Hashtable/KeyValuePair.h

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

DtsodC/src/SearchTree/SearchTree.c

@@ -31,23 +31,7 @@ void STNode_free(STNode* node){
         free(node->branches);
     }
     if(node->value.VoidPtr) 
-        switch (node->value.type) {   
+        Unitype_free(node->value);
-            case Int8Ptr: case UInt8Ptr: 
-            case Int16Ptr: case UInt16Ptr: 
-            case Int32Ptr: case UInt32Ptr: 
-            case Int64Ptr: case UInt64Ptr:
-                free(node->value.VoidPtr);
-                break;
-            /*case AutoarrPtr:
-                Autoarr_clear((Autoarr*)node->value.VoidPtr);
-                free(node->value.VoidPtr);
-                break;*/
-            case STNodePtr:
-                STNode_free((STNode*)node->value.VoidPtr);
-                break;
-            default: // value is not ptr
-                break;
-    }
     free(node);
 }
 

DtsodC/src/base/base.h

@@ -15,5 +15,5 @@ void fsleep(float sec);
         (codeblock);\
     clock_t stop=clock();\
     double t=(double)(stop-start)/CLOCKS_PER_SEC/repeats;\
-    printf("\e[93moperation \e[94m%s\e[93m took \e[94m%lf \e[93mseconds\n",opname,t);\
+    printf("\e[93moperation \e[94m%s\e[93m lasted \e[94m%lf \e[93mseconds\n",opname,t);\
 })

DtsodC/src/base/twmp.h

@@ -1,14 +0,0 @@
-case CharPtr: return "CharPtr";
-case UniversalType: return "UniversalType";
-case STNodePtr: return "STNodePtr";
-case HashtablePtr: return "HashtablePtr";
-case AutoarrInt8Ptr: return "AutoarrInt8Ptr";
-case AutoarrUInt8Ptr: return "AutoarrUInt8Ptr";
-case AutoarrInt16Ptr: return "AutoarrInt16Ptr";
-case AutoarrUInt16Ptr: return "AutoarrUInt16Ptr";
-case AutoarrInt32Ptr: return "AutoarrInt32Ptr";
-case AutoarrUInt32Ptr: return "AutoarrUInt32Ptr";
-case AutoarrInt64Ptr: return "AutoarrInt64Ptr";
-case AutoarrUInt64Ptr: return "AutoarrUInt64Ptr";
-case AutoarrUnitypePtr: return "AutoarrUnitypePtr";
-case AutoarrKVPairPtr: return "AutoarrKVPairPtr";

DtsodC/src/base/types.c

@@ -1,5 +1,8 @@
 #include "types.h"
 #include "errors.h"
+#include "../Autoarr/Autoarr2.h"
+#include "../Hashtable/Hashtable.h"
+#include "../SearchTree/SearchTree.h"
 
 const char* typename(my_type t){
     switch (t) {
@@ -24,48 +27,90 @@ const char* typename(my_type t){
         case UInt32Ptr: return "UInt32Ptr";
         case Int64Ptr: return "Int64Ptr";
         case UInt64Ptr: return "UInt64Ptr";
-        case UniversalType: return "Unitype";
         case CharPtr: return "CharPtr";
-case STNodePtr: return "STNodePtr";
+        case STNodePtr: return "STNodePtr";
-case HashtablePtr: return "HashtablePtr";
+        case HashtablePtr: return "HashtablePtr";
-case AutoarrInt8Ptr: return "AutoarrInt8Ptr";
+        case UniversalType: return "Unitype";
-case AutoarrUInt8Ptr: return "AutoarrUInt8Ptr";
+        case AutoarrInt8Ptr: return "AutoarrInt8Ptr";
-case AutoarrInt16Ptr: return "AutoarrInt16Ptr";
+        case AutoarrUInt8Ptr: return "AutoarrUInt8Ptr";
-case AutoarrUInt16Ptr: return "AutoarrUInt16Ptr";
+        case AutoarrInt16Ptr: return "AutoarrInt16Ptr";
-case AutoarrInt32Ptr: return "AutoarrInt32Ptr";
+        case AutoarrUInt16Ptr: return "AutoarrUInt16Ptr";
-case AutoarrUInt32Ptr: return "AutoarrUInt32Ptr";
+        case AutoarrInt32Ptr: return "AutoarrInt32Ptr";
-case AutoarrInt64Ptr: return "AutoarrInt64Ptr";
+        case AutoarrUInt32Ptr: return "AutoarrUInt32Ptr";
-case AutoarrUInt64Ptr: return "AutoarrUInt64Ptr";
+        case AutoarrInt64Ptr: return "AutoarrInt64Ptr";
-case AutoarrUnitypePtr: return "AutoarrUnitypePtr";
+        case AutoarrUInt64Ptr: return "AutoarrUInt64Ptr";
-case AutoarrKVPairPtr: return "AutoarrKVPairPtr";
+        case AutoarrUnitypePtr: return "AutoarrUnitypePtr";
+        case AutoarrKVPairPtr: return "AutoarrKVPairPtr";
         default: throw(ERR_WRONGTYPE); return "ERROR";
     }
 }
 
-int8 typesize(my_type type){
+//frees VoidPtr value or does nothing if type isn't pointer
-    switch (type){
+void Unitype_free(Unitype u){
-        case Null: return 0;
+    switch (u.type) {
-        case Double: return sizeof(double);
+        case Null: 
-        case Float: return sizeof(float);
+        case Float:
-        case Bool: return sizeof(bool);
+        case Double: 
-        case Char:
+        case Char: 
+        case Bool: 
         case Int8: 
-        case UInt8: return 1;
+        case UInt8: 
         case Int16: 
-        case UInt16: return 2;
+        case UInt16:
         case Int32: 
-        case UInt32: return 4;
+        case UInt32: 
         case Int64:
-        case UInt64: return 8;
+        case UInt64: 
+            break;
         case Int8Ptr: 
-        case UInt8Ptr: 
+        case UInt8Ptr:
         case Int16Ptr: 
         case UInt16Ptr: 
         case Int32Ptr: 
         case UInt32Ptr: 
         case Int64Ptr: 
-        case UInt64Ptr: return sizeof(void*);
+        case UInt64Ptr: 
-        case UniversalType: return "Unitype";
+        case CharPtr: 
-        default: throw(ERR_WRONGTYPE); return -1;
+            free(u.VoidPtr);
+            break;
+        case HashtablePtr: 
+            Hashtable_free(u.VoidPtr);
+            break;
+        case STNodePtr: 
+            STNode_free(u.VoidPtr);
+            break;
+        case AutoarrInt8Ptr: 
+            Autoarr2_clear(((Autoarr2(int8)*)u.VoidPtr));
+            break;
+        case AutoarrUInt8Ptr:
+            Autoarr2_clear(((Autoarr2(uint8)*)u.VoidPtr));
+            break;
+        case AutoarrInt16Ptr: 
+            Autoarr2_clear(((Autoarr2(int16)*)u.VoidPtr));
+            break;
+        case AutoarrUInt16Ptr: 
+            Autoarr2_clear(((Autoarr2(uint16)*)u.VoidPtr));
+            break;
+        case AutoarrInt32Ptr: 
+            Autoarr2_clear(((Autoarr2(int32)*)u.VoidPtr));
+            break;
+        case AutoarrUInt32Ptr: 
+            Autoarr2_clear(((Autoarr2(uint32)*)u.VoidPtr));
+            break;
+        case AutoarrInt64Ptr: 
+            Autoarr2_clear(((Autoarr2(int64)*)u.VoidPtr));
+            break;
+        case AutoarrUInt64Ptr: 
+            Autoarr2_clear(((Autoarr2(uint64)*)u.VoidPtr));
+            break;
+        case AutoarrUnitypePtr:
+            Autoarr2_Unitype_clear(u.VoidPtr);
+            free((Autoarr2(Unitype)*)u.VoidPtr);
+            break;
+        case AutoarrKVPairPtr: 
+            Autoarr2_KeyValuePair_clear(u.VoidPtr);
+            free((Autoarr2(KeyValuePair)*)u.VoidPtr);
+            break;
+        default: throw(ERR_WRONGTYPE);
     }
 }

DtsodC/src/base/types.h

@@ -14,7 +14,8 @@ typedef enum my_type{
     Null, Float, Double, Char, Bool,
     UInt8, Int8, UInt16, Int16, UInt32, Int32, UInt64, Int64, 
     UInt8Ptr, Int8Ptr, UInt16Ptr, Int16Ptr, UInt32Ptr, Int32Ptr, UInt64Ptr, Int64Ptr,
-    CharPtr, UniversalType, STNodePtr, HashtablePtr,
+    CharPtr, STNodePtr, HashtablePtr,
+    UniversalType,
     AutoarrInt8Ptr, AutoarrUInt8Ptr, AutoarrInt16Ptr, AutoarrUInt16Ptr, 
     AutoarrInt32Ptr, AutoarrUInt32Ptr, AutoarrInt64Ptr, AutoarrUInt64Ptr,
     AutoarrUnitypePtr, AutoarrKVPairPtr
@@ -45,3 +46,6 @@ static const Unitype UniFalse={Bool,.Bool=false};
 
 #define Uni(TYPE,VAL) (Unitype){.type=TYPE,.TYPE=VAL}
 #define UniPtr(TYPE,VAL) (Unitype){.type=TYPE,.VoidPtr=VAL}
+
+//frees VoidPtr value or does nothing if type isn't pointer
+void Unitype_free(Unitype u);

DtsodC/tests/test_dtsod.c

@@ -2,10 +2,10 @@
 #include "../src/DtsodParser/DtsodV24.h"
 
 void test_dtsod(){
+    printf("\e[96m-------------[test_dtsod]-------------\n");
     optime(__func__,1,({
-        printf("\e[96m-------------[test_dtsod]-------------\n");
+        const char text[]=
-        char text[]=
+            "$message:\n"
-            "message:\n"
             "{\n"
             "    type: \"sent\";\n"
             "    time: \"15.12.2021 20:51:24 +03:00\";\n"
@@ -14,10 +14,15 @@ void test_dtsod(){
             "    message_id: 920734809096077353ul;\n"
             "    text: \"_$\\\"\\\\'''\n\ta ыыы000;2;=:%d;```\";\n"
             "};\n";
-        Hashtable* dtsod=DtsodV24_deserialize(text);
+        Unitype id;
+        Hashtable* dtsod;
+        optime("deserialize",1,(dtsod=DtsodV24_deserialize(text)));
+        printf("\e[92mhashtable_get(message)->\n\e[94m");
         Unitype msg=Hashtable_get(dtsod,"message");
         printuni(msg);
-        Unitype id=Hashtable_get(msg.VoidPtr,"message_id");
+        Autoarr2(Unitype)* ar=msg.VoidPtr;
-    printf("\e[92mid: %lu",id.UInt64);
+        id=Hashtable_get(Autoarr2_get(ar,0).VoidPtr,"message_id");
+        printf("\e[92m\nmessage_id: %lu\n",id.UInt64);
+        Hashtable_free(dtsod);
     }));
 }

TestProgram/DtsodC/DictTest.cs

@@ -1,4 +1,3 @@
-using static DTLib.Experimental.Tester;
 using static TestProgram.Program;
 
 namespace TestProgram;

TestProgram/Program.cs

@@ -8,11 +8,13 @@ global using System.Threading.Tasks;
 global using DTLib;
 global using DTLib.Extensions;
 global using DTLib.Experimental;
+global using static DTLib.Experimental.Tester;
 global using DTLib.Filesystem;
 global using DTLib.Dtsod;
 using DTLib.Loggers;
 using TestProgram.DtsodV2X;
 
+
 namespace TestProgram;
 
 static class Program