From 83f4a1775e5d76bda38b96c40638203ad04d1e51 Mon Sep 17 00:00:00 2001 From: Timerix22 Date: Wed, 2 Mar 2022 22:25:16 +0300 Subject: [PATCH] deserialization completed? --- .vscode/settings.json | 7 +- DTLib/Experimental/Tester.cs | 2 +- DtsodC/src/Autoarr/Autoarr2.c | 10 ++ DtsodC/src/Autoarr/Autoarr2.h | 3 +- DtsodC/src/Autoarr/Autoarr2_define.h | 2 +- DtsodC/src/DtsodParser/DtsodV24.c | 51 +++++-- DtsodC/src/DtsodParser/DtsodV24.c.backup | 187 ----------------------- DtsodC/src/Hashtable/Hashtable.c | 15 +- DtsodC/src/Hashtable/Hashtable.h | 16 +- DtsodC/src/Hashtable/KeyValuePair.c | 20 +++ DtsodC/src/Hashtable/KeyValuePair.h | 15 ++ DtsodC/src/SearchTree/SearchTree.c | 18 +-- DtsodC/src/base/base.h | 2 +- DtsodC/src/base/twmp.h | 14 -- DtsodC/src/base/types.c | 101 ++++++++---- DtsodC/src/base/types.h | 6 +- DtsodC/tests/test_dtsod.c | 17 ++- TestProgram/DtsodC/DictTest.cs | 1 - TestProgram/Program.cs | 2 + 19 files changed, 191 insertions(+), 298 deletions(-) delete mode 100644 DtsodC/src/DtsodParser/DtsodV24.c.backup create mode 100644 DtsodC/src/Hashtable/KeyValuePair.c create mode 100644 DtsodC/src/Hashtable/KeyValuePair.h delete mode 100644 DtsodC/src/base/twmp.h diff --git a/.vscode/settings.json b/.vscode/settings.json index 6e4b5f2..b119ca9 100644 --- a/.vscode/settings.json +++ b/.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" } \ No newline at end of file diff --git a/DTLib/Experimental/Tester.cs b/DTLib/Experimental/Tester.cs index 8ebd784..d9e9fbb 100644 --- a/DTLib/Experimental/Tester.cs +++ b/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"); } } \ No newline at end of file diff --git a/DtsodC/src/Autoarr/Autoarr2.c b/DtsodC/src/Autoarr/Autoarr2.c index c95c954..84888c2 100644 --- a/DtsodC/src/Autoarr/Autoarr2.c +++ b/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;blockIblocks_count-1;blockI++) + for(uint32 elemI=0;elemImax_block_length;elemI++) + Unitype_free(ar->values[blockI][elemI]); + for(uint32 elemI=0;elemIblock_length;elemI++) + Unitype_free(ar->values[ar->blocks_count-1][elemI]); + Autoarr2_clear(ar); +} diff --git a/DtsodC/src/Autoarr/Autoarr2.h b/DtsodC/src/Autoarr/Autoarr2.h index 74b89f2..1eed943 100644 --- a/DtsodC/src/Autoarr/Autoarr2.h +++ b/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); diff --git a/DtsodC/src/Autoarr/Autoarr2_define.h b/DtsodC/src/Autoarr/Autoarr2_define.h index fd7aa46..4924789 100644 --- a/DtsodC/src/Autoarr/Autoarr2_define.h +++ b/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; iblocks_count;i++)\ - free(ar->values[i]); \ + free(ar->values[i]); \ free(ar->values);\ ar->values=NULL;\ ar->blocks_count=0;\ diff --git a/DtsodC/src/DtsodParser/DtsodV24.c b/DtsodC/src/DtsodParser/DtsodV24.c index 389d42c..c719f30 100644 --- a/DtsodC/src/DtsodParser/DtsodV24.c +++ b/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': - return Uni(Double,strtod(string_cpToCharPtr(str),NULL)); - case 'u': ; //some weird "empty statement" - //not "statement" - uint64 lu=0; - sscanf(string_cpToCharPtr(str),"%lu",&lu); - return Uni(UInt64,lu); + case 'f': { + char* _c=string_cpToCharPtr(str); + Unitype rez=Uni(Double,strtod(_c,NULL)); + free(_c); + return rez; + } + 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': ; - int64 li=0; - sscanf(string_cpToCharPtr(str),"%li",&li); - return Uni(Int64,li); + case '5': case '6': case '7': case '8': case '9': { + int64 li=0; + char* _c=string_cpToCharPtr(str); + 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); diff --git a/DtsodC/src/DtsodParser/DtsodV24.c.backup b/DtsodC/src/DtsodParser/DtsodV24.c.backup deleted file mode 100644 index bb9fc3e..0000000 --- a/DtsodC/src/DtsodParser/DtsodV24.c.backup +++ /dev/null @@ -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 "; - 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 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); } diff --git a/DtsodC/src/Hashtable/Hashtable.c b/DtsodC/src/Hashtable/Hashtable.c index 0e950bb..bc9da94 100644 --- a/DtsodC/src/Hashtable/Hashtable.c +++ b/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;ihein];i++){ - Autoarr2(KeyValuePair)* ar=(Autoarr2(KeyValuePair)*)(ht->rows+i); - for(uint32 i=0;ikey); - Autoarr2_clear(ar); + Autoarr2_KeyValuePair_clear(ht->rows+i); } 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)); } */ diff --git a/DtsodC/src/Hashtable/Hashtable.h b/DtsodC/src/Hashtable/Hashtable.h index e053daf..c9ad214 100644 --- a/DtsodC/src/Hashtable/Hashtable.h +++ b/DtsodC/src/Hashtable/Hashtable.h @@ -1,18 +1,8 @@ #pragma once #include "../base/base.h" -#include "../Autoarr/Autoarr2.h" #include "hash.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) +#include "KeyValuePair.h" 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); \ No newline at end of file +void Hashtable_set(Hashtable* ht, char* key, Unitype u); diff --git a/DtsodC/src/Hashtable/KeyValuePair.c b/DtsodC/src/Hashtable/KeyValuePair.c new file mode 100644 index 0000000..f306aea --- /dev/null +++ b/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); +} diff --git a/DtsodC/src/Hashtable/KeyValuePair.h b/DtsodC/src/Hashtable/KeyValuePair.h new file mode 100644 index 0000000..130b71f --- /dev/null +++ b/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); diff --git a/DtsodC/src/SearchTree/SearchTree.c b/DtsodC/src/SearchTree/SearchTree.c index 9a09800..6e47548 100644 --- a/DtsodC/src/SearchTree/SearchTree.c +++ b/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) { - 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; - } + Unitype_free(node->value); free(node); } diff --git a/DtsodC/src/base/base.h b/DtsodC/src/base/base.h index 6a680d1..808d662 100644 --- a/DtsodC/src/base/base.h +++ b/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);\ }) diff --git a/DtsodC/src/base/twmp.h b/DtsodC/src/base/twmp.h deleted file mode 100644 index f21f1e3..0000000 --- a/DtsodC/src/base/twmp.h +++ /dev/null @@ -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"; \ No newline at end of file diff --git a/DtsodC/src/base/types.c b/DtsodC/src/base/types.c index a70232e..6841722 100644 --- a/DtsodC/src/base/types.c +++ b/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 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"; + case STNodePtr: return "STNodePtr"; + case HashtablePtr: return "HashtablePtr"; + case UniversalType: return "Unitype"; + 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"; default: throw(ERR_WRONGTYPE); return "ERROR"; } } -int8 typesize(my_type type){ - switch (type){ - case Null: return 0; - case Double: return sizeof(double); - case Float: return sizeof(float); - case Bool: return sizeof(bool); - case Char: +//frees VoidPtr value or does nothing if type isn't pointer +void Unitype_free(Unitype u){ + switch (u.type) { + case Null: + case Float: + case Double: + 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 UniversalType: return "Unitype"; - default: throw(ERR_WRONGTYPE); return -1; + case UInt64Ptr: + case CharPtr: + 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); } } diff --git a/DtsodC/src/base/types.h b/DtsodC/src/base/types.h index 9d52dbd..e82db22 100644 --- a/DtsodC/src/base/types.h +++ b/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); diff --git a/DtsodC/tests/test_dtsod.c b/DtsodC/tests/test_dtsod.c index 5d1fd01..b120a9b 100644 --- a/DtsodC/tests/test_dtsod.c +++ b/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"); - char text[]= - "message:\n" + const char text[]= + "$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"); - printf("\e[92mid: %lu",id.UInt64); + Autoarr2(Unitype)* ar=msg.VoidPtr; + id=Hashtable_get(Autoarr2_get(ar,0).VoidPtr,"message_id"); + printf("\e[92m\nmessage_id: %lu\n",id.UInt64); + Hashtable_free(dtsod); })); } \ No newline at end of file diff --git a/TestProgram/DtsodC/DictTest.cs b/TestProgram/DtsodC/DictTest.cs index 571e51e..38c3ca4 100644 --- a/TestProgram/DtsodC/DictTest.cs +++ b/TestProgram/DtsodC/DictTest.cs @@ -1,4 +1,3 @@ -using static DTLib.Experimental.Tester; using static TestProgram.Program; namespace TestProgram; diff --git a/TestProgram/Program.cs b/TestProgram/Program.cs index a08d3e6..90579ac 100644 --- a/TestProgram/Program.cs +++ b/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