95

DtsodC/Autoarr/Autoarr.h

@@ -19,9 +19,10 @@ declare_Autoarr(Unitype)
 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++){\
+            for(uint32 elemI=0;elemI<ar->max_block_length;elemI++){dbg(5);\
                 elem=ar->values[blockI][elemI];\
                 (codeblock);\
             }\
@@ -29,4 +30,5 @@ void Autoarr_Unitype_clear(Autoarr(Unitype)* ar);
             elem=ar->values[ar->blocks_count-1][elemI];\
             (codeblock);\
         }\
+    }\
 })

DtsodC/DtsodParser/DtsodV24_deserialize.c

@@ -17,7 +17,7 @@ Hashtable* __deserialize(char** _text, bool calledRecursively){
                 errBuf[12]=_c;
                 for(uint8 i=0;i<32;i++)
                     errBuf[i+22]=*(text-16+i);
-                printf("\n\e[31m>%s:%d/%s\n",file,line,fname);
+                printf("\n\e[31m[%s:%d/%s]\n",file,line,fname);
                 throw(errBuf);
     };
     #define throw_wrongchar(C) __throw_wrongchar(__FILE__,__LINE__,__func__,C)
@@ -38,6 +38,12 @@ Hashtable* __deserialize(char** _text, bool calledRecursively){
                     throw_wrongchar(c);
                 nameStr.ptr++;
                 break;
+            case '=':  case ';':
+            case '\'': case '"':
+            case '[':  case ']':
+            case '{':
+                throw_wrongchar(c);
+                break;
             case '#':
                 SkipComment();
                 if(nameStr.length!=0)
@@ -48,20 +54,14 @@ Hashtable* __deserialize(char** _text, bool calledRecursively){
                 if(!calledRecursively) throw_wrongchar(c);
                 if((*++text)!=';')
                     throw_wrongchar(c);
-            case ':':
-                return nameStr;
             case '$':
                 if(nameStr.length!=0)
                     throw_wrongchar(c);
                 nameStr.ptr++;
                 partOfDollarList=true;
                 break;
-            case '=':  case ';':
+            case ':':
-            case '\'': case '"':
+                return nameStr;
-            case '[':  case ']':
-            case '{':
-                throw_wrongchar(c);
-                break;
             default:
                 nameStr.length++;
                 break;
@@ -72,18 +72,16 @@ Hashtable* __deserialize(char** _text, bool calledRecursively){
     };
 
     Unitype ReadValue(){
-        string valueStr={text,0};
 
-        //returns part of <text> with quotes
+        //returns part of <text> without quotes
         string ReadString(){
             bool prevIsBackslash=false;
-            string str={text,1};
+            string str={text+1,0};
             while ((c=*++text)!='"' || prevIsBackslash){
                 if (!c) throw(ERR_ENDOFSTR);
                 prevIsBackslash= c=='\\' && !prevIsBackslash;
                 str.length++;
             }
-            str.length++;
             return str;
         };
 
@@ -108,6 +106,7 @@ Hashtable* __deserialize(char** _text, bool calledRecursively){
         };
 
         Unitype ParseValue(string str){
+            printf("\e[94m<\e[96m%s\e[94m>\n",string_cpToCharPtr(str));
             const string nullStr={"null",4};
             const string trueStr={"true",4};
             const string falseStr={"false",5};
@@ -127,14 +126,6 @@ Hashtable* __deserialize(char** _text, bool calledRecursively){
                        return UniFalse;
                     else throw_wrongchar(*str.ptr);
                     break;
-                case '"':
-                    if(str.ptr[str.length-1]=='"'){
-                        //removing quotes
-                        string _str={str.ptr+1,str.length-1};
-                        return UniPtr(CharPtr,string_cpToCharPtr(_str));
-                    }
-                    else throw_wrongchar(*str.ptr);
-                    break;
                 default: 
                     switch(str.ptr[str.length-1]){
                         case 'f': {
@@ -154,7 +145,12 @@ Hashtable* __deserialize(char** _text, bool calledRecursively){
                         case '5': case '6': case '7': case '8': case '9': {
                                 int64 li=0;
                                 char* _c=string_cpToCharPtr(str);
-                                sscanf(_c,"%li",&li);
+                                if(sscanf(_c,"%li",&li)!=1){
+                                    char err[64];
+                                    sprintf(err,"can't parse to int: <%s>",_c);
+                                    throw(err);
+                                }
+                                    
                                 free(_c);
                                 return Uni(Int64,li);
                             }
@@ -166,37 +162,50 @@ Hashtable* __deserialize(char** _text, bool calledRecursively){
             return UniNull;
         };
 
+        string valueStr={text+1,0};
+        Unitype value;
         while ((c=*++text)) switch (c){
             case ' ':  case '\t':
             case '\r': case '\n':
+                if(valueStr.length!=0)
+                    throw_wrongchar(c);
+                valueStr.ptr++;
                 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);
                 break;
+            case '#':
+                SkipComment();
+                if(valueStr.length!=0)
+                    throw_wrongchar(c);
+                valueStr.ptr=text;
+                break;
+            case '"':
+                if(valueStr.length!=0) throw_wrongchar(c);
+                value=UniPtr(CharPtr,string_cpToCharPtr(ReadString()));
+                break;
+            case '\'':
+                if(valueStr.length!=0) throw_wrongchar(c);
+                text++;
+                char valueChar=*++text;
+                if (*++text != '\'') throw("after <'> should be char");
+                value=Uni(Char,valueChar);
+                break;
+            case '[':
+                if(valueStr.length!=0) throw_wrongchar(c);
+                value=UniPtr(AutoarrUnitypePtr,ReadList());
+            case ']':
+                readingList=false;
+                break;
+            case '{':
+                if(valueStr.length!=0) throw_wrongchar(c);
+                value=UniPtr(HashtablePtr,ReadDtsod());
+            case ';':
+            case ',':
+                if(valueStr.length!=0)
+                    value=ParseValue(valueStr);
+                return value;
             default:
                 valueStr.length++;
                 break;

DtsodC/DtsodV24_serialize.c

@@ -1,76 +0,0 @@
-#include "DtsodV24.h"
-#include "../Autoarr/StringBuilder.h"
-
-#define STRB_BC 64
-#define STRB_BL 1024
-
-#define addc(B,C) StringBuilder_append_char(B,C)
-
-void __serialize(StringBuilder* b, uint8 tabs, Hashtable* dtsod){
-    
-    void AppendTabs(){
-        for(uint8 t; t<tabs; t++)
-            addc('\t');
-    };
-    
-    void AppendValue(Unitype u){
-        switch(u.type){
-                case Int64:
-                    StringBuilder_append_int64(b,u.Int64);
-                    break;
-                case UInt64:
-                    StringBuilder_append_uint64(b,u.UInt64);
-                    addc(b,'u');
-                    break;
-                case Double:
-                    StringBuilder_append_double(b,u.Double);
-                    addc(b,'d');
-                    break;
-                case String:
-                    addc(b,'"');
-                    StringBuilder_append_cptr(b,u.VoidPtr);
-                    addc(b,'"');
-                    break;
-                case Char:
-                    addc(b,'\'');
-                    addc(b,u.Char);
-                    addc(b,'\'');
-                    break;
-                case AutoarrUnitypePtr:
-                    addc(b,'[');
-                    Autoarr_foreach(((Autoarr_Unitype)(u.VoidPtr)), e, ({
-                        addc(b,' ');
-                        AppendValue(e);
-                        addc(b,',');
-                    }));
-                    Autoarr_remove(b);
-                    addc(b,' ');
-                    addc(b,']');
-                    break;
-                case HashtablePtr:
-                    addc(b,'{');
-                    addc(b,'\n');
-                    __serialize(b,tabs+1,u.VoidPtr);
-                    AppendTabs();
-                    addc(b,'}');
-                    break;
-                default: throw(ERR_WRONGTYPE); 
-        }
-    };
-    
-    Hashtable_foreach(dtsod, p, ({
-        AppendTabs();
-        StringBuilder_append_cptr(p.key);
-        addc(b,':');
-        addc(b,' ');
-        AppendValue(p.value);
-        addc(b,';');
-        addc(b,'\n');
-    }));
-}
-
-char* DtsodV24_serialize(Hashtable* dtsod){
-    StringBuilder b=StringBuilder_create(STRB_BC,STR_BL); //65536 max!
-    __serialize(&b,0,dtsod);
-    return StringBuilder_build(&b);
-}

DtsodC/tests/test_dtsod.c

@@ -1,31 +1,35 @@
 #include "tests.h"
 #include "../DtsodParser/DtsodV24.h"
 
-void test_dtsod(){
-    printf("\e[96m-------------[test_dtsod]-------------\n");
-    optime(__func__,1,({
 const char text[]=
-            "$message:\n"
+"message: {\n"
-            "{\n"
+"    bool: false;"
-            "    type: \"sent\";\n"
+//"    char: 'v';"
-            "    time: \"15.12.2021 20:51:24 +03:00\";\n"
+"    int: -2515;"
-            "    author_id: 293798876950036480ul;\n"
+"    uint: 0u;"
-            "    channel_id: 913088838761603212ul;\n"
+"    double: 965.557f;"
-            "    message_id: 920734809096077353ul;\n"
 "    text: \"_$\\\"\\\\'''\n\ta ыыы000;2;=:%d;```\";\n"
 "}; \n";
-        KeyValuePair id;
+
+void test_dtsod(){
+    printf("\e[96m-------------[test_dtsod]-------------\n");
+    //optime(__func__,1,({
         Hashtable* dtsod;
         optime("deserialize",1,(dtsod=DtsodV24_deserialize(text)));
-        printf("\e[92mhashtable_get(\"message\")->\n\e[94m");
+        Hashtable_foreach(dtsod, p,({
-        KeyValuePair msg=Hashtable_get_pair(dtsod,"message");
+            printkvp(p);
-        printkvp(msg);
+            if(p.value.type==HashtablePtr){
+                printf(":\n{\n");
+                Hashtable* sub=p.value.VoidPtr;
+                Hashtable_foreach(sub, _p,({
+                    printf("    ");
+                    printkvp(_p);
                     printf("\n");
-        Autoarr(Unitype)* ar=msg.value.VoidPtr;
-        printf("\e[92mhashtable_get(\"message_id\")->\n\e[94m");
-        id=Hashtable_get_pair(Autoarr_get(ar,0).VoidPtr,"message_id");
-        printkvp(id);
-        printf("\n");
-        Hashtable_free(dtsod);
                 }));
+                printf("}");
+            }
+            printf("\n");
+        }));
+        Hashtable_free(dtsod);
+    //}));
 }