Timerix/kerep
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

safethrow in DtsodV24_deserialize and sprintf_s on windows

Browse Source
This commit is contained in:
Timerix22 2022-04-06 23:30:05 +03:00
parent a9b1545024
commit 9d336fd46c
12 changed files with 177 additions and 127 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
Autoarr/StringBuilder.c
View File

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

2
DtsodParser/DtsodV24.h
View File

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

159
DtsodParser/DtsodV24_deserialize.c
View File

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

6
DtsodParser/DtsodV24_exported.c
View File

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

4
base/base.h
View File

@ -14,7 +14,7 @@ extern "C" {
#define optime(opname,repeats,codeblock) ({\ #define optime(opname,repeats,codeblock) ({\
struct timespec start, stop;\ struct timespec start, stop;\
clock_gettime(CLOCK_REALTIME, &start);\ clock_gettime(CLOCK_REALTIME, &start);\
for(uint64 ___OPREP=0;___OPREP<repeats;___OPREP++)\ for(uint64 ___OPREP=0;___OPREP<(uint64)repeats;___OPREP++)\
(codeblock);\ (codeblock);\
clock_gettime(CLOCK_REALTIME, &stop);\ clock_gettime(CLOCK_REALTIME, &stop);\
double t=(double)(stop.tv_sec-start.tv_sec+(double)(stop.tv_nsec-start.tv_nsec)/1000000000)/repeats;\ double t=(double)(stop.tv_sec-start.tv_sec+(double)(stop.tv_nsec-start.tv_nsec)/1000000000)/repeats;\
@ -23,7 +23,7 @@ extern "C" {
#else // #else //
#define optime(opname,repeats,codeblock) ({\ #define optime(opname,repeats,codeblock) ({\
clock_t start=clock();\ clock_t start=clock();\
for(uint64 ___OPREP=0;___OPREP<repeats;___OPREP++)\ for(uint64 ___OPREP=0;___OPREP<(uint64)repeats;___OPREP++)\
(codeblock);\ (codeblock);\
clock_t stop=clock();\ clock_t stop=clock();\
double t=(double)(stop-start)/CLOCKS_PER_SEC/repeats;\ double t=(double)(stop-start)/CLOCKS_PER_SEC/repeats;\

16
base/errors.c
View File

@ -18,14 +18,22 @@ char* errname(err_t err){
#define ERRMSG_MAXLENGTH 1024 #define ERRMSG_MAXLENGTH 1024
char* __genErrMsg(const char* errmsg, const char* srcfile, int line, const char* funcname){ char* __genErrMsg(const char* errmsg, const char* srcfile, int line, const char* funcname){
char* rezult=malloc(ERRMSG_MAXLENGTH); size_t bufsize=ERRMSG_MAXLENGTH;
sprintf(rezult,"[%s:%d] %s() throwed error: %s",srcfile,line,funcname,errmsg); char* rezult=malloc(bufsize);
IFWIN(
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; return rezult;
} }
char* __extendErrMsg(const char* errmsg, const char* srcfile, int line, const char* funcname){ char* __extendErrMsg(const char* errmsg, const char* srcfile, int line, const char* funcname){
char* rezult=malloc(cptr_length(errmsg)+ERRMSG_MAXLENGTH); size_t bufsize=cptr_length(errmsg)+ERRMSG_MAXLENGTH;
sprintf(rezult,"%s\n \\___[%s:%d] %s()",errmsg,srcfile,line,funcname); 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); free(errmsg);
return rezult; return rezult;
} }

15
base/errors.h
View File

@ -26,10 +26,6 @@ static const Maybe MaybeNull={.value.type=Null, .value.VoidPtr=NULL,.errmsg=NULL
void Maybe_free(Maybe e); void Maybe_free(Maybe e);
void printMaybe(Maybe e); void printMaybe(Maybe e);
#define throwNext(_funcCall, _rezult) Maybe _rezult=_funcCall; if(_rezult.errmsg){\
_rezult.errmsg=__extendErrMsg(_rezult.errmsg, __FILE__,__LINE__,__func__);\
return _rezult;\
}else
#define SUCCESS(REZLT) (Maybe){.errmsg=NULL, .value=REZLT} #define SUCCESS(REZLT) (Maybe){.errmsg=NULL, .value=REZLT}
@ -50,6 +46,17 @@ char* __unknownErr( );
#define throw(E) __EXIT(((char*)__genErrMsg((__stringify_err(E)), __FILE__,__LINE__,__func__))) #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 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 #if __cplusplus
} }
#endif #endif

15
base/types.c
View File

@ -115,7 +115,19 @@ void Unitype_free(Unitype u){
} }
} }
#define SPRINT_BUFSIZE 64
void sprintuni(char* buf,Unitype v){ 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 Char: sprintf_s(buf, SPRINT_BUFSIZE, "{%s : '%c'}", my_type_name(v.type),v.Char);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) { switch (v.type) {
case Null: sprintf(buf, "{Null}");break; case Null: sprintf(buf, "{Null}");break;
case Float64: sprintf(buf, "{%s : %lf}", my_type_name(v.type),v.Float64);break; case Float64: sprintf(buf, "{%s : %lf}", my_type_name(v.type),v.Float64);break;
@ -126,10 +138,11 @@ void sprintuni(char* buf,Unitype v){
case CharPtr: sprintf(buf, "{%s : \"%s\"}", my_type_name(v.type),(char*)v.VoidPtr);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; default: sprintf(buf, "{%s : %p}", my_type_name(v.type),v.VoidPtr);break;
} }
);
} }
void printuni(Unitype v){ void printuni(Unitype v){
char* s=malloc(64); char* s=malloc(SPRINT_BUFSIZE);
sprintuni(s,v); sprintuni(s,v);
fputs(s, stdout); fputs(s, stdout);
free(s); free(s);

6
tests/main.c
View File

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

11
tests/test_dtsod.c
View File

@ -33,18 +33,21 @@ void test_dtsod(){
optime(__func__,1,({ optime(__func__,1,({
printf("\e[96m-------------[test_dtsod]-------------\n"); printf("\e[96m-------------[test_dtsod]-------------\n");
Hashtable* dtsod; Hashtable* dtsod;
char* s=cptr_copy(text);
optime("deserialize",1,(dtsod=DtsodV24_deserialize(s))); optime("deserialize",1,({
free(s); tryLast(DtsodV24_deserialize(text),r)
dtsod=r.value.VoidPtr;
}));
print_dtsod(dtsod); print_dtsod(dtsod);
char* s;
optime("serialize",1,(s=DtsodV24_serialize(dtsod))); optime("serialize",1,(s=DtsodV24_serialize(dtsod)));
Hashtable_free(dtsod); Hashtable_free(dtsod);
printf("\e[92m%s",s); printf("\e[92m%s",s);
optime("reserialize",10,({ optime("reserialize",10,({
dtsod=DtsodV24_deserialize(s); tryLast(DtsodV24_deserialize(s),r)
dtsod=r.value.VoidPtr;
free(s); free(s);
s=DtsodV24_serialize(dtsod); s=DtsodV24_serialize(dtsod);
Hashtable_free(dtsod); Hashtable_free(dtsod);

10
tests/test_hashtable.c
View File

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

10
tests/test_safethrow.c
View File

@ -14,19 +14,19 @@ Maybe throw_errcode(){
Maybe test_maybe(){ Maybe test_maybe(){
printf("\e[94mdont_throw returns \e[92m"); printf("\e[94mdont_throw returns \e[92m");
throwNext(dont_throw(),rez0) tryLast(dont_throw(),rez0)
printMaybe(rez0); printMaybe(rez0);
printf("\n"); printf("\n");
throwNext(throw_error(),rez1) try(throw_error(),rez1)
printMaybe(rez1); printMaybe(rez1);
throw("test_maybe failed"); throw("test_maybe failed");
return MaybeNull; return MaybeNull;
} }
Maybe c(){ throwNext(throw_errcode(),_) return MaybeNull; } Maybe c(){ try(throw_errcode(),_) return MaybeNull; }
Maybe b(){ throwNext(c(),_) return MaybeNull; } Maybe b(){ try(c(),_) return MaybeNull; }
Maybe a(){ throwNext(b(),_) return MaybeNull; } Maybe a(){ try(b(),_) return MaybeNull; }
void test_safethrow(){ void test_safethrow(){
printf("\e[96m-----------[test_safethrow]-----------\n"); printf("\e[96m-----------[test_safethrow]-----------\n");