fuck go back

Autoarr/StringBuilder.c

@@ -25,7 +25,6 @@ void StringBuilder_append_int64(StringBuilder* b, int64 a){
     uint8 i=0;
     if(a==0){
         Autoarr_add(b,'0');
-        return;
     }
     else if(a<0){
         Autoarr_add(b,'-');
@@ -45,7 +44,6 @@ void StringBuilder_append_uint64(StringBuilder* b, uint64 a){
     uint8 i=0;
     if(a==0){
         Autoarr_add(b,'0');
-        return;
     }
     char buf[24];
     while(a!=0){
@@ -53,17 +51,13 @@ void StringBuilder_append_uint64(StringBuilder* b, uint64 a){
         a/=10;
     }
     string rev=string_reverse((string){buf,i});
-    printf("\e[95mrev:%s\n",string_cpToCptr(rev));
     StringBuilder_append_string(b,rev);
     free(rev.ptr);
 }
 
 void StringBuilder_append_double(StringBuilder* b, double a){
     char buf[32];
-    IFWIN(
+    sprintf(buf,"%lf",a);
-        sprintf_s(buf,32,"%lf",a),
-        sprintf(buf,"%lf",a)
-    );
     StringBuilder_append_cptr(b,buf);
 }
 

DtsodParser/DtsodV24.h

@@ -7,7 +7,7 @@ extern "C" {
 #include "../Hashtable/Hashtable.h"
 
 //parses text to binary values
-Maybe DtsodV24_deserialize(char* text);
+Hashtable* DtsodV24_deserialize(char* text);
 
 //creates text representation of dtsod
 char* DtsodV24_serialize(Hashtable* dtsod);

DtsodParser/DtsodV24_deserialize.c

@@ -6,16 +6,16 @@
 #define STRB_BC 64
 #define STRB_BL 1024
 
-Maybe ERROR_WRONGCHAR(char c, char* text){
+void __throw_wrongchar(char* file, int line, char* fname, char _c, char* _text) {
     char errBuf[]="unexpected <c> at:\n  \""
         "00000000000000000000000000000000\"";
-    errBuf[12]=c;
+    errBuf[12]=_c;
-    for(uint8 i=0; i<32; i++)
+    for (uint8 i=0; i < 32; i++)
-        // writes 16 chars before and 15 after the wrongchar
+        errBuf[i + 22]=*(_text - 16 + i);
-        errBuf[i+22]=*(text - 16 + i);
+    printf("\n\e[91m[%s:%d %s] throwed error: %s\n", file, line, fname, errBuf);
-    safethrow(cptr_copy(errBuf));
+    exit(128);
-}
+};
-#define safethrow_wrongchar(C) return ERROR_WRONGCHAR(C, text)
+#define throw_wrongchar(C) __throw_wrongchar(__FILE__,__LINE__,__func__,C, text)
 
 
 typedef struct DeserializeSharedData{
@@ -29,15 +29,14 @@ typedef struct DeserializeSharedData{
 #define readingList shared->sh_readingList
 #define calledRecursively shared->sh_calledRecursively
 
-Maybe __SkipComment(DeserializeSharedData* shared) {
+void __SkipComment(DeserializeSharedData* shared) {
     char c;
     while ((c=*++text) != '\n')
-        if (!c) safethrow(ERR_ENDOFSTR);
+        if (!c) throw(ERR_ENDOFSTR);
-    return MaybeNull;
+};
-}
 #define SkipComment() __SkipComment(shared)
 
-Maybe __ReadName(DeserializeSharedData* shared){
+string __ReadName(DeserializeSharedData* shared){
     char c;
     string nameStr={text,0};
     text--;
@@ -45,30 +44,30 @@ Maybe __ReadName(DeserializeSharedData* shared){
         case ' ':  case '\t':
         case '\r': case '\n':
             if(nameStr.length!=0)
-                safethrow_wrongchar(c);
+                throw_wrongchar(c);
             nameStr.ptr++;
             break;
         case '=':  case ';':
         case '\'': case '"':
         case '[':  case ']':
         case '{':
-            safethrow_wrongchar(c);
+            throw_wrongchar(c);
             break;
-        case '#': ;
+        case '#':
-            try(SkipComment(),_);
+            SkipComment();
             if(nameStr.length!=0)
-                safethrow_wrongchar(c);
+                throw_wrongchar(c);
             nameStr.ptr=text+1; //skips '\n'
             break;
         case '}':
-            if(!calledRecursively) safethrow_wrongchar(c);
+            if(!calledRecursively) throw_wrongchar(c);
             if((*++text)!=';')
-                safethrow_wrongchar(c);
+                throw_wrongchar(c);
         case ':':
-            return SUCCESS(UniPtr(CharPtr,string_cpToCptr(nameStr)));
+            return nameStr;
         case '$':
             if(nameStr.length!=0)
-                safethrow_wrongchar(c);
+                throw_wrongchar(c);
             nameStr.ptr++;
             partOfDollarList=true;
             break;
@@ -77,17 +76,17 @@ Maybe __ReadName(DeserializeSharedData* shared){
             break;
     }
 
-    if(nameStr.length>0) safethrow(ERR_ENDOFSTR);
+    if(nameStr.length>0) throw(ERR_ENDOFSTR);
-    return SUCCESS(UniPtr(CharPtr,NULL));
+    return nameStr;
-}
+};
 #define ReadName() __ReadName(shared)
 
-Maybe __deserialize(char** _text, bool _calledRecursively);
+Hashtable* __deserialize(char** _text, bool _calledRecursively);
-Maybe __ReadValue(DeserializeSharedData* shared);
+Unitype __ReadValue(DeserializeSharedData* shared);
 #define ReadValue() __ReadValue(shared)
 
 //returns part of <text> without quotes
-Maybe __ReadString(DeserializeSharedData* shared){
+char* __ReadString(DeserializeSharedData* shared){
     char c;
     bool prevIsBackslash=false;
     StringBuilder _b=StringBuilder_create(STRB_BC,STRB_BL);
@@ -102,7 +101,7 @@ Maybe __ReadString(DeserializeSharedData* shared){
             else {
                 char* str=StringBuilder_build(b);
                 Autoarr_clear(b);
-                return SUCCESS(UniPtr(CharPtr,str));
+                return str;
             }
         } 
         else {
@@ -110,24 +109,24 @@ Maybe __ReadString(DeserializeSharedData* shared){
             StringBuilder_append_char(b,c);
         }
     }
-    safethrow(ERR_ENDOFSTR);
+    throw(ERR_ENDOFSTR);
-}
+    return NULL;
+};
 #define ReadString() __ReadString(shared)
 
-Maybe __ReadList(DeserializeSharedData* shared){
+Autoarr(Unitype)* __ReadList(DeserializeSharedData* shared){
     Autoarr(Unitype)* list=malloc(sizeof(Autoarr(Unitype)));
     *list=Autoarr_create(Unitype,ARR_BC,ARR_BL);
     readingList=true;
     while (true){
-        try(ReadValue(), val)
+        Autoarr_add(list,ReadValue());
-            Autoarr_add(list,val.value);
         if (!readingList) break;
     }
-    return SUCCESS(UniPtr(AutoarrUnitypePtr,list));
+    return list;
 };
 #define ReadList() __ReadList(shared)
 
-Maybe __ParseValue(DeserializeSharedData* shared, string str){
+Unitype __ParseValue(DeserializeSharedData* shared, string str){
     //printf("\e[94m<\e[96m%s\e[94m>\n",string_cpToCptr(str));
     const string nullStr={"null",4};
     const string trueStr={"true",4};
@@ -135,18 +134,18 @@ Maybe __ParseValue(DeserializeSharedData* shared, string str){
     switch(*str.ptr){
         case 'n':
             if(string_compare(str,nullStr))
-                return SUCCESS(UniNull);
+                return UniNull;
-            else safethrow_wrongchar(*str.ptr);
+            else throw_wrongchar(*str.ptr);
             break;
         case 't':
             if(string_compare(str,trueStr))
-                return SUCCESS(UniTrue);
+                return UniTrue;
-            else safethrow_wrongchar(*str.ptr);
+            else throw_wrongchar(*str.ptr);
             break;
         case 'f':
             if(string_compare(str,falseStr))
-                return SUCCESS(UniFalse);
+                return UniFalse;
-            else safethrow_wrongchar(*str.ptr);
+            else throw_wrongchar(*str.ptr);
             break;
         default: 
             switch(str.ptr[str.length-1]){
@@ -154,14 +153,14 @@ Maybe __ParseValue(DeserializeSharedData* shared, string str){
                         char* _c=string_cpToCptr(str);
                         Unitype rez=Uni(Float64,strtod(_c,NULL));
                         free(_c);
-                        return SUCCESS(rez);
+                        return rez;
                     }
                 case 'u': {
                         uint64 lu=0;
                         char* _c=string_cpToCptr(str);
                         sscanf(_c,"%lu",&lu);
                         free(_c);
-                        return SUCCESS(Uni(UInt64,lu));
+                        return Uni(UInt64,lu);
                     }
                 case '0': case '1': case '2': case '3': case '4':
                 case '5': case '6': case '7': case '8': case '9': {
@@ -169,24 +168,23 @@ Maybe __ParseValue(DeserializeSharedData* shared, string str){
                         char* _c=string_cpToCptr(str);
                         if(sscanf(_c,"%li",&li)!=1){
                             char err[64];
-                            IFWIN(
+                            sprintf(err,"can't parse to int: <%s>",_c);
-                                sprintf_s(err,64,"can't parse to int: <%s>",_c),
+                            throw(err);
-                                sprintf(err,"can't parse to int: <%s>",_c)
-                            );
-                            safethrow(err);
                         }
+                            
                         free(_c);
-                        return SUCCESS(Uni(Int64,li));
+                        return Uni(Int64,li);
                     }
                 default:
-                    safethrow_wrongchar(str.ptr[str.length-1]);
+                    throw_wrongchar(str.ptr[str.length-1]);
             }
     }
-    safethrow(ERR_ENDOFSTR);
+    throw(ERR_ENDOFSTR);
+    return UniNull;
 };
 #define ParseValue(str) __ParseValue(shared, str)
 
-Maybe __ReadValue(DeserializeSharedData* shared){
+Unitype __ReadValue(DeserializeSharedData* shared){
     char c;
     string valueStr={text+1,0};
     Unitype value;
@@ -194,55 +192,57 @@ Maybe __ReadValue(DeserializeSharedData* shared){
         case ' ':  case '\t':
         case '\r': case '\n':
             if(valueStr.length!=0)
-                safethrow_wrongchar(c);
+                throw_wrongchar(c);
             valueStr.ptr++;
             break;
         case '=': case ':': 
         case '}': case '$':
-        case '\'':
+            throw_wrongchar(c);
-            safethrow_wrongchar(c);
             break;
         case '#':;
             char _c=c;
-            try(SkipComment(),_);
+            SkipComment();
             if(valueStr.length!=0)
-                safethrow_wrongchar(_c);
+                throw_wrongchar(_c);
             valueStr.ptr=text+1; //skips '\n'
             break;
         case '"':
-            if(valueStr.length!=0) safethrow_wrongchar(c);
+            if(valueStr.length!=0) throw_wrongchar(c);
-            try(ReadString(),maybeString)
+            value=UniPtr(CharPtr,ReadString());
-                value=maybeString.value;
+            break;
+        case '\'':
+            if(valueStr.length!=0) throw_wrongchar(c);
+            char valueChar=*++text;
+            if (*++text != '\'') throw("after <'> should be char");
+            value=Uni(Char,valueChar);
             break;
         case '[':
-            if(valueStr.length!=0) safethrow_wrongchar(c);
+            if(valueStr.length!=0) throw_wrongchar(c);
-            try(ReadList(),maybeList)
+            value=UniPtr(AutoarrUnitypePtr,ReadList());
-                value=maybeList.value;
         case ']':
             readingList=false;
             break;
         case '{':
-            if(valueStr.length!=0) safethrow_wrongchar(c);
+            if(valueStr.length!=0) throw_wrongchar(c);
             ++text; //skips '{' 
-            try(__deserialize(&text,true), val)
+            value=UniPtr(HashtablePtr, __deserialize(&text,true));
-                return SUCCESS(val.value);
+            return value;
         case ';':
         case ',':
-            if(valueStr.length!=0){
+            if(valueStr.length!=0)
-                try(ParseValue(valueStr),maybeParsed)
+                value=ParseValue(valueStr);
-                    value=maybeParsed.value;
+            return value;
-            }
-            return SUCCESS(value);
         default:
             valueStr.length++;
             break;
     }
 
-    safethrow(ERR_ENDOFSTR);
+    throw(ERR_ENDOFSTR);
-}
+    return UniNull;
+};
 
 
-Maybe __deserialize(char** _text, bool _calledRecursively) {
+Hashtable* __deserialize(char** _text, bool _calledRecursively) {
     DeserializeSharedData _shared={
         .sh_text=*_text,
         .sh_partOfDollarList=false,
@@ -255,11 +255,11 @@ Maybe __deserialize(char** _text, bool _calledRecursively) {
     
     text--;
     while((c=*++text)){
-        try(ReadName(), maybeName)
+        string name=ReadName();
-        if(!maybeName.value.VoidPtr) //end of file or '}' in recursive call 
+        if(name.length==0) //end of file or '}' in recursive call 
             goto END;
-        char* nameCPtr=maybeName.value.VoidPtr;
+        char* nameCPtr=string_cpToCptr(name);
-        try(ReadValue(), val)
+        Unitype value=ReadValue();
         if(partOfDollarList){
             Autoarr(Unitype)* list;
             Unitype lu;
@@ -271,15 +271,15 @@ Maybe __deserialize(char** _text, bool _calledRecursively) {
                 *list=Autoarr_create(Unitype,ARR_BC,ARR_BL);
                 Hashtable_add(dict,nameCPtr,UniPtr(AutoarrUnitypePtr,list));
             }
-                Autoarr_add(list,val.value);
+            Autoarr_add(list,value);
         }
-        else Hashtable_add(dict,nameCPtr,val.value);
+        else Hashtable_add(dict,nameCPtr,value);
     }
     END:
     *_text=text;
-    return SUCCESS(UniPtr(HashtablePtr,dict));
+    return dict;
 }
 
-Maybe DtsodV24_deserialize(char* _text) {
+Hashtable* DtsodV24_deserialize(char* _text) {
     return __deserialize(&_text, false);
 }

DtsodParser/DtsodV24_exported.c

@@ -11,10 +11,8 @@ extern "C" {
 #include "DtsodV24.h"
 
 //parses text to binary values
-EXPORT void CALL kerep_DtsodV24_deserialize(char* text, Hashtable** output, char** errmsg){
+EXPORT void CALL kerep_DtsodV24_deserialize(char* text, Hashtable** output){
-    Maybe r=DtsodV24_deserialize(text);
+    *output=DtsodV24_deserialize(text);
-    *errmsg= r.errmsg ? r.errmsg : NULL;
-    *output=r.value.VoidPtr;
 }
 
 //creates text representation of dtsod

DtsodParser/DtsodV24_serialize.c

@@ -47,6 +47,11 @@ void __AppendValue(SerializeSharedData* shared, Unitype u){
                 }
                 addc('"');
                 break;
+            case Char:
+                addc('\'');
+                addc(u.Char);
+                addc('\'');
+                break;
             case Bool:
                 StringBuilder_append_cptr(b, u.Bool ? "true" : "false");
                 break;

Makefile

@@ -3,7 +3,7 @@ TESTS=$(wildcard tests/*c) $(wildcard tests/**/*.c)
 OUTDIR=bin
 CMP=gcc
 
-all: clear_c clear_bin build_test
+all: clear_c clear_bin build_test build_lib
 
 clear_c:
 	clear

base/base.h

@@ -10,26 +10,23 @@ extern "C" {
 #include "mystr.h"
 
 // executes codeblock and prints execution time
-#ifdef CLOCK_REALTIME //non-standard high-precision clock
+/*#define optime(opname,repeats,codeblock) ({\
-    #define optime(opname,repeats,codeblock) ({\
     struct timespec start, stop;\
     clock_gettime(CLOCK_REALTIME, &start);\
-        for(uint64 ___OPREP=0;___OPREP<(uint64)repeats;___OPREP++)\
+    for(uint64 ___OPREP=0;___OPREP<repeats;___OPREP++)\
         (codeblock);\
     clock_gettime(CLOCK_REALTIME, &stop);\
     double t=(double)(stop.tv_sec-start.tv_sec+(double)(stop.tv_nsec-start.tv_nsec)/1000000000)/repeats;\
     printf("\e[93moperation \e[94m%s\e[93m lasted \e[94m%lf \e[93mseconds\n",opname,t);\
-    })
+})*/
-#else //
+#define optime(opname,repeats,codeblock) ({\
-    #define optime(opname,repeats,codeblock) ({\
     clock_t start=clock();\
-        for(uint64 ___OPREP=0;___OPREP<(uint64)repeats;___OPREP++)\
+    for(uint64 ___OPREP=0;___OPREP<repeats;___OPREP++)\
         (codeblock);\
     clock_t stop=clock();\
     double t=(double)(stop-start)/CLOCKS_PER_SEC/repeats;\
     printf("\e[93moperation \e[94m%s\e[93m lasted \e[94m%lf \e[93mseconds\n",opname,t);\
-    })
+})
-#endif
 
 #if __cplusplus
 }

base/errors.c

@@ -1,8 +1,7 @@
 #include "std.h"
 #include "errors.h"
-#include "mystr.h"
 
-char* errname(err_t err){
+const char* errname(err_t err){
     switch(err){
         case SUCCESS: return "SUCCESS";
         case ERR_MAXLENGTH: return "ERR_MAXLENGTH";
@@ -15,37 +14,14 @@ char* errname(err_t err){
     }
 }
 
-#define ERRMSG_MAXLENGTH 1024
+void _throwint(int err, const char* srcfile, int line, const char* funcname){
-
+    if(err){ // SUCCESS=0 is not an error
-char* __genErrMsg(const char* errmsg, const char* srcfile, int line, const char* funcname){
+        printf("\e[91m[%s:%d %s] throwed error: %s\e[0m\n",srcfile,line,funcname,errname(err));
-    size_t bufsize=ERRMSG_MAXLENGTH;
+        exit(err); 
-    char* rezult=malloc(bufsize);
+    }
-    IFWIN(
+    else printf("\e[93m[%s:%d %s] throwed SUCCESS as an error",srcfile,line,funcname);
-        sprintf_s(rezult,bufsize,"[%s:%d] %s() throwed error: %s",srcfile,line,funcname,errmsg),
-        sprintf(rezult,"[%s:%d] %s() throwed error: %s",srcfile,line,funcname,errmsg)
-    );
-    return rezult;
 }
-
+void _throwstr(const char* errmesg, const char* srcfile, int line, const char* funcname){
-char* __extendErrMsg(const char* errmsg, const char* srcfile, int line, const char* funcname){
+    printf("\e[91m[%s:%d %s] throwed error: %s\e[0m\n",srcfile,line,funcname,errmesg);
-    size_t bufsize=cptr_length(errmsg)+ERRMSG_MAXLENGTH;
+    exit(255); 
-    char* rezult=malloc(bufsize);
-    IFWIN(
-        sprintf_s(rezult,bufsize,"%s\n \\___[%s:%d] %s()",errmsg,srcfile,line,funcname),
-        sprintf(rezult,"%s\n \\___[%s:%d] %s()",errmsg,srcfile,line,funcname)
-    );
-    free(errmsg);
-    return rezult;
 }
-
-void Maybe_free(Maybe e){
-    free(e.errmsg);
-    Unitype_free(e.value);
-}
-void printMaybe(Maybe e){
-    if(e.errmsg) printf("%s\n",e.errmsg);
-    else printuni(e.value);
-}
-
-char* __doNothing(char* a) {return a;}
-char* __unknownErr() {return "UNKNOWN ERROR";}

base/errors.h

@@ -4,58 +4,20 @@
 extern "C" {
 #endif
 
-#include "std.h"
-#include "types.h"
-
 typedef enum err_t {
     SUCCESS, //not an error 
     ERR_MAXLENGTH, ERR_WRONGTYPE, ERR_WRONGINDEX, ERR_NOTIMPLEMENTED, ERR_NULLPTR, ERR_ENDOFSTR
 } err_t;
 
-char* errname(err_t err);
+const char* errname(err_t err);
 
-char* __genErrMsg(const char* errmsg, const char* srcfile, int line, const char* funcname);
+void _throwint(int err, const char* srcfile, int line, const char* funcname) ;
-char* __extendErrMsg(const char* errmsg, const char* srcfile, int line, const char* funcname);
+void _throwstr(const char* errmesg, const char* srcfile, int line, const char* funcname);
-
+#pragma GCC diagnostic ignored "-Wint-conversion"
-typedef struct Maybe{
+#define throw(E) \
-    Unitype value;
+    CHOOSE(IFTYPE(E,int), _throwint(E,__FILE__,__LINE__,__func__), \
-    char* errmsg;
+    CHOOSE(IFTYPE(E,char[]), _throwstr(E,__FILE__,__LINE__,__func__), \
-} Maybe;
+    printf("\e[31m[%s:%d/%s] UNKNOWN ERROR\n",__FILE__,__LINE__,__func__)))
-static const Maybe MaybeNull={.value.type=Null, .value.VoidPtr=NULL,.errmsg=NULL};
-
-void Maybe_free(Maybe e);
-void printMaybe(Maybe e);
-
-
-#define SUCCESS(REZLT) (Maybe){.errmsg=NULL, .value=REZLT}
-
-#define __RETURN_EXCEPTION(ERRMSG) return (Maybe){.errmsg=ERRMSG, .value=UniNull}
-
-#define __EXIT(ERRMSG) ({ printf("\e[91m%s\e[0m \n", ERRMSG); exit(128); })
-
-char* __doNothing(char* a);
-char* __unknownErr( );
-
-#define __stringify_err(E) _Generic(\
-    (E),\
-    char*: __doNothing,\
-    int: errname,\
-    default: __unknownErr\
-)(E)
-
-#define throw(E) __EXIT(((char*)__genErrMsg((__stringify_err(E)), __FILE__,__LINE__,__func__)))
-#define safethrow(E) __RETURN_EXCEPTION(((char*)__genErrMsg((__stringify_err(E)), __FILE__,__LINE__,__func__)))
-
-
-#define try(_funcCall, _rezult) Maybe _rezult=_funcCall; if(_rezult.errmsg){\
-        _rezult.errmsg=__extendErrMsg(_rezult.errmsg, __FILE__,__LINE__,__func__);\
-        return _rezult;\
-    }else 
-
-#define tryLast(_funcCall, _rezult) Maybe _rezult=_funcCall; if(_rezult.errmsg){\
-        _rezult.errmsg=__extendErrMsg(_rezult.errmsg, __FILE__,__LINE__,__func__);\
-        __EXIT(_rezult.errmsg);\
-    }else 
 
 #if __cplusplus
 }

base/mystr.c

@@ -37,8 +37,8 @@ char* char_multiply(char c, uint32 n){
 
 //copies str content to new char pointer value (adding '\0' at the end)
 char* string_cpToCptr(string str){
-    if(str.length==0) return NULL;
     char* cptr=malloc(str.length*sizeof(char)+1);
+    if(str.length==0) return NULL;
     cptr[str.length]=0;
     while(str.length-->0)
         cptr[str.length]=str.ptr[str.length];
@@ -69,7 +69,6 @@ bool string_compare(string str0, string str1){
 
 //creates new string which is reversed variant of <s>
 string string_reverse(string s){
-    if(s.length==0) return s;
     string r={malloc(s.length), s.length};
     for(uint32 i=0; i<s.length; i++)
         r.ptr[i]=s.ptr[s.length-i-1];

base/std.h

@@ -10,7 +10,6 @@ extern "C" {
 #include <stdbool.h>
 #include <locale.h>
 #include <time.h>
-#include <setjmp.h>
 
 #define CHOOSE(B, Y, N) __builtin_choose_expr(B, Y, N)
 

base/types.c

@@ -115,33 +115,16 @@ void Unitype_free(Unitype u){
     }
 }
 
-#define SPRINT_BUFSIZE 64
-void sprintuni(char* buf,Unitype v){
-    IFWIN(
-        switch (v.type) {
-            case Null: sprintf_s(buf, SPRINT_BUFSIZE, "{Null}");break;
-            case Float64: sprintf_s(buf, SPRINT_BUFSIZE, "{%s : %lf}", my_type_name(v.type),v.Float64);break;
-            case Bool:
-            case UInt64: sprintf_s(buf, SPRINT_BUFSIZE, "{%s : %lu}", my_type_name(v.type),v.UInt64);break;
-            case Int64: sprintf_s(buf, SPRINT_BUFSIZE, "{%s : %ld}", my_type_name(v.type),v.Int64);break;
-            case CharPtr: sprintf_s(buf, SPRINT_BUFSIZE, "{%s : \"%s\"}", my_type_name(v.type),(char*)v.VoidPtr);break;
-            default: sprintf_s(buf, SPRINT_BUFSIZE, "{%s : %p}", my_type_name(v.type),v.VoidPtr);break;
-        },
-        switch (v.type) {
-            case Null: sprintf(buf, "{Null}");break;
-            case Float64: sprintf(buf, "{%s : %lf}", my_type_name(v.type),v.Float64);break;
-            case Bool:
-            case UInt64: sprintf(buf, "{%s : %lu}", my_type_name(v.type),v.UInt64);break;
-            case Int64: sprintf(buf, "{%s : %ld}", my_type_name(v.type),v.Int64);break;
-            case CharPtr: sprintf(buf, "{%s : \"%s\"}", my_type_name(v.type),(char*)v.VoidPtr);break;
-            default: sprintf(buf, "{%s : %p}", my_type_name(v.type),v.VoidPtr);break;
-        }
-    );
-}
 
 void printuni(Unitype v){
-    char* s=malloc(SPRINT_BUFSIZE);
+    switch (v.type) {
-    sprintuni(s,v);
+        case Null: printf("{Null}");break;
-    fputs(s, stdout);
+        case Float64: printf("{%s : %lf}",my_type_name(v.type),v.Float64);break;
-    free(s);
+        case Char: printf("{%s : '%c'}",my_type_name(v.type),v.Char);break;
+        case Bool:
+        case UInt64: printf("{%s : %lu}",my_type_name(v.type),v.UInt64);break;
+        case Int64: printf("{%s : %ld}",my_type_name(v.type),v.Int64);break;
+        case CharPtr: printf("{%s : \"%s\"}",my_type_name(v.type),(char*)v.VoidPtr);break;
+        default: printf("{%s : %p}",my_type_name(v.type),v.VoidPtr);break;
+    }
 }

base/types.h

@@ -34,6 +34,7 @@ typedef struct Unitype{
         int64 Int64;
         uint64 UInt64;
         double Float64;
+        char Char;
         bool Bool;
         void* VoidPtr;
     };
@@ -50,7 +51,6 @@ static const Unitype UniFalse={.Bool=false,.type=Bool};
 //frees VoidPtr value or does nothing if type isn't pointer
 void Unitype_free(Unitype u);
 void printuni(Unitype v);
-void sprintuni(char* s, Unitype v);
 
 #if __cplusplus
 }

kerep.vcxproj

@@ -75,27 +75,27 @@
   </ImportGroup>
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <OutDir>bin\$(Configuration)-$(Platform)\</OutDir>
+    <OutDir>bin-$(Platform)\$(Configuration)\</OutDir>
-    <IntDir>obj\$(Configuration)-$(Platform)\</IntDir>
+    <IntDir>obj-$(Platform)\$(Configuration)\</IntDir>
     <RunCodeAnalysis>true</RunCodeAnalysis>
     <ManagedAssembly>false</ManagedAssembly>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <OutDir>bin\$(Configuration)-$(Platform)\</OutDir>
+    <OutDir>bin-$(Platform)\$(Configuration)\</OutDir>
-    <IntDir>obj\$(Configuration)-$(Platform)\</IntDir>
+    <IntDir>obj-$(Platform)\$(Configuration)\</IntDir>
     <RunCodeAnalysis>true</RunCodeAnalysis>
     <ManagedAssembly>false</ManagedAssembly>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <RunCodeAnalysis>true</RunCodeAnalysis>
-    <OutDir>bin\$(Configuration)-$(Platform)\</OutDir>
+    <OutDir>bin-$(Platform)\$(Configuration)\</OutDir>
-    <IntDir>obj\$(Configuration)-$(Platform)\</IntDir>
+    <IntDir>obj-$(Platform)\$(Configuration)\</IntDir>
     <ManagedAssembly>false</ManagedAssembly>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <RunCodeAnalysis>true</RunCodeAnalysis>
-    <OutDir>bin\$(Configuration)-$(Platform)\</OutDir>
+    <OutDir>bin-$(Platform)\$(Configuration)\</OutDir>
-    <IntDir>obj\$(Configuration)-$(Platform)\</IntDir>
+    <IntDir>obj-$(Platform)\$(Configuration)\</IntDir>
     <ManagedAssembly>false</ManagedAssembly>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
@@ -220,8 +220,6 @@
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Autoarr\Autoarr.c" />
-    <ClCompile Include="Autoarr\Autoarr_KVPair_exported.c" />
-    <ClCompile Include="Autoarr\Autoarr_Unitype_exported.c" />
     <ClCompile Include="Autoarr\StringBuilder.c" />
     <ClCompile Include="base\errors.c" />
     <ClCompile Include="base\mystr.c" />
@@ -239,7 +237,6 @@
     <ClCompile Include="tests\test_dtsod.c" />
     <ClCompile Include="tests\test_hashtable.c" />
     <ClCompile Include="tests\test_marshalling.c" />
-    <ClCompile Include="tests\test_safethrow.c" />
     <ClCompile Include="tests\test_searchtree.c" />
     <ClCompile Include="tests\test_string.c" />
   </ItemGroup>

kerep.vcxproj.filters

@@ -125,14 +125,5 @@
     <ClCompile Include="DtsodParser\DtsodV24_exported.c">
       <Filter>Исходные файлы</Filter>
     </ClCompile>
-    <ClCompile Include="Autoarr\Autoarr_KVPair_exported.c">
-      <Filter>Исходные файлы</Filter>
-    </ClCompile>
-    <ClCompile Include="Autoarr\Autoarr_Unitype_exported.c">
-      <Filter>Исходные файлы</Filter>
-    </ClCompile>
-    <ClCompile Include="tests\test_safethrow.c">
-      <Filter>Исходные файлы</Filter>
-    </ClCompile>
   </ItemGroup>
 </Project>

tests/main.c

@@ -1,11 +1,10 @@
 #include "tests.h"
 
 void test_all(){
-    test_autoarr();
-    test_string();
-    test_safethrow();
     test_searchtree();
+    test_autoarr();
     test_hashtable();
+    test_string();
     test_dtsod();
     printf("\e[96m---------------------------------------\e[0m\n");
 }

tests/test_dtsod.c

@@ -4,11 +4,12 @@
 const char text[]=
 "message: {\n"
 "    bool: false;"
+"    char: 'v';"
 "    int: -2515;"
 "    uint:#comment!\n 0u;"
 "    double: 965.557f;#another comment!\n"
 "    text: \"_$\\\"\\\\'''a ыыы000;2;=:%d;```\";\n"
-"};";
+"}; ";
 
 void print_dtsod(Hashtable* dtsod){
     printf("\e[92m");
@@ -32,21 +33,18 @@ void test_dtsod(){
     optime(__func__,1,({
         printf("\e[96m-------------[test_dtsod]-------------\n");
         Hashtable* dtsod;
+        char* s=cptr_copy(text);
 
-        optime("deserialize",1,({
+        optime("deserialize",1,(dtsod=DtsodV24_deserialize(s)));
-            tryLast(DtsodV24_deserialize(text),r) 
+        free(s);
-                dtsod=r.value.VoidPtr;
-        }));
         print_dtsod(dtsod);
 
-        char* s;
         optime("serialize",1,(s=DtsodV24_serialize(dtsod)));
         Hashtable_free(dtsod);
         printf("\e[92m%s",s);
 
         optime("reserialize",10,({
-            tryLast(DtsodV24_deserialize(s),r) 
+            dtsod=DtsodV24_deserialize(s);
-                dtsod=r.value.VoidPtr;
             free(s);
             s=DtsodV24_serialize(dtsod);
             Hashtable_free(dtsod);

tests/test_hashtable.c

@@ -39,10 +39,7 @@ void printrowgraph(Hashtable* ht){
 void fill(Hashtable* ht){
     for(uint32 i=0;i<100000;i++){
         char* key=malloc(12);
-        IFWIN(
+        sprintf(key,"key__%u",i);
-            sprintf_s(key,12,"key_%u",i),
-            sprintf(key,"key_%u",i)
-        );
         Hashtable_add(ht,key,Uni(UInt64,i));
     }
 }
@@ -51,10 +48,7 @@ Unitype gett(Hashtable* ht){
     char* key=malloc(12);
     Unitype u;
     for(uint32 i=0;i<100000;i++){
-        IFWIN(
+        sprintf(key,"key__%u",i);
-            sprintf_s(key,12,"key_%u",i),
-            sprintf(key,"key_%u",i)
-        );
         u=Hashtable_get(ht,key);
     }
     free(key);

tests/test_safethrow.c

@@ -1,43 +0,0 @@
-#include "tests.h"
-
-Maybe dont_throw(){
-    return SUCCESS(Uni(UInt64, 9/2));
-}
-
-Maybe throw_error(){
-    safethrow("test exception");
-}
-
-Maybe throw_errcode(){
-    safethrow(ERR_NULLPTR);
-}
-
-Maybe test_maybe(){
-    printf("\e[94mdont_throw returns \e[92m");
-    tryLast(dont_throw(),rez0)
-        printMaybe(rez0);
-    printf("\n");
-    try(throw_error(),rez1)
-        printMaybe(rez1);
-    throw("test_maybe failed");
-    return MaybeNull;
-}
-
-
-Maybe c(){ try(throw_errcode(),_) return MaybeNull; }
-Maybe b(){ try(c(),_) return MaybeNull; }
-Maybe a(){ try(b(),_) return MaybeNull; }
-
-void test_safethrow(){
-    printf("\e[96m-----------[test_safethrow]-----------\n");
-    optime("test_safethrow", 1, ({
-        Maybe e=test_maybe();
-        printf("\e[94mthrow_error:\n\e[92m");
-        printMaybe(e);
-        Maybe_free(e);
-        printf("\e[94mthrow_errcode:\n\e[92m");
-        e=a();
-        printMaybe(e);
-        Maybe_free(e);
-    }));
-}

tests/test_string.c

@@ -6,10 +6,10 @@ void test_string(){
         printf("\e[96m-------------[test_string]-------------\n");
         char c[]="0123456789abcdef";
         string s=string_cpFromCharPtr(c);
-        printf("\e[92m\"%s\" \e[94m-> string_cpFromCharPtr()\n",c);
+        printf("\e[92m\"%s\" -> string_cpFromCharPtr()\n",c);
         if(s.length!=16) throw("string created with incorrect length");
         char* p=string_cpToCptr(s);
-        printf("\e[94mstring_cpToCptr() -> \e[92m\"%s\"\n",p);
+        printf("\e[92mstring_cpToCptr() -> \"%s\"\n",p);
         free(p);
         free(s.ptr);
     }));

tests/tests.h

@@ -9,4 +9,3 @@ void test_autoarr();
 void test_hashtable();
 void test_string();
 void test_dtsod();
-void test_safethrow();