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

Merge pull request #2 from Timerix22/free_mem_on_safethrow

Browse Source 
Free mem on safethrow
This commit is contained in:
Timerix22 2022-04-19 16:55:37 +03:00 committed by GitHub
commit a9860691ab
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 137 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.gitignore vendored
View File

@ -18,3 +18,6 @@ logs-*/
#backups #backups
.old*/ .old*/
#temp
messages.dtsod

135
DtsodParser/DtsodV24_deserialize.c
View File

@ -1,20 +1,35 @@
#include "DtsodV24.h" #include "DtsodV24.h"
#include "../Autoarr/StringBuilder.h" #include "../Autoarr/StringBuilder.h"
#define ARR_BC 8 #define ARR_BC 64
#define ARR_BL 16 #define ARR_BL 1024
#define STRB_BC 64 #define STRB_BC 64
#define STRB_BL 1024 #define STRB_BL 1024
typedef struct DeserializeSharedData{
const char* sh_text_first;
char* sh_text;
bool sh_partOfDollarList;
bool sh_readingList;
bool sh_calledRecursively;
} DeserializeSharedData;
#define text shared->sh_text
#define partOfDollarList shared->sh_partOfDollarList
#define readingList shared->sh_readingList
#define calledRecursively shared->sh_calledRecursively
// special func for throwing error messages about wrong characters in deserializing text // special func for throwing error messages about wrong characters in deserializing text
Maybe ERROR_WRONGCHAR(const char c, char* text, char* text_first, const char* srcfile, int line, const char* funcname){ Maybe ERROR_WRONGCHAR(const char c, char* _text, char* text_first, const char* srcfile, int line, const char* funcname){
char errBuf[68]; char errBuf[68];
errBuf[67]='\0'; for(uint8 n=0; n<sizeof(errBuf);n++)
char* errText=text-32; errBuf[n]='\0';
char* errText=_text-32;
uint8 cplace=32; uint8 cplace=32;
if(errText<text_first) { if(errText<text_first) {
cplace=errText-text_first; cplace=_text-text_first;
errText=text_first; errText=text_first;
} }
uint8 i=0; uint8 i=0;
@ -32,9 +47,9 @@ Maybe ERROR_WRONGCHAR(const char c, char* text, char* text_first, const char* sr
errBuf[i]=_c; errBuf[i]=_c;
if(!_c) break; if(!_c) break;
} }
char* errmsg=malloc(512); char errmsg[1024];
IFWIN( IFWIN(
sprintf_s(errmsg,512, "unexpected <%c> at:\n" sprintf_s(errmsg,1024, "unexpected <%c> at:\n"
" \"%s\"\n" " \"%s\"\n"
"\\___[%s:%d] %s()", "\\___[%s:%d] %s()",
c,errBuf, srcfile,line,funcname), c,errBuf, srcfile,line,funcname),
@ -43,30 +58,16 @@ Maybe ERROR_WRONGCHAR(const char c, char* text, char* text_first, const char* sr
" \\___[%s:%d] %s()", " \\___[%s:%d] %s()",
c,errBuf, srcfile,line,funcname) c,errBuf, srcfile,line,funcname)
); );
safethrow(cptr_copy(errmsg)); safethrow(errmsg,;);
} }
#define safethrow_wrongchar(C) return ERROR_WRONGCHAR(C, text, shared->sh_text_first, __FILE__,__LINE__,__func__) #define safethrow_wrongchar(C, freeMem) { freeMem; return ERROR_WRONGCHAR(C, text, shared->sh_text_first, __FILE__,__LINE__,__func__); }
typedef struct DeserializeSharedData{
const char* sh_text_first;
char* sh_text;
bool sh_partOfDollarList;
bool sh_readingList;
bool sh_calledRecursively;
} DeserializeSharedData;
#define text shared->sh_text
#define partOfDollarList shared->sh_partOfDollarList
#define readingList shared->sh_readingList
#define calledRecursively shared->sh_calledRecursively
Maybe __SkipComment(DeserializeSharedData* shared) { Maybe __SkipComment(DeserializeSharedData* shared) {
char c; char c;
while ((c=*++text) != '\n') while ((c=*++text) != '\n')
if (!c) safethrow(ERR_ENDOFSTR); if (!c) safethrow(ERR_ENDOFSTR,;);
return MaybeNull; return MaybeNull;
} }
@ -80,29 +81,34 @@ Maybe __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)
safethrow_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 '{':
safethrow_wrongchar(c); safethrow_wrongchar(c,;);
break; break;
case '#': ; case '#': ;
try(SkipComment(),_); char _c=c;
if(nameStr.length!=0) char* _text=text;
safethrow_wrongchar(c); try(SkipComment(),_,;);
if(nameStr.length!=0){
text=_text;
safethrow_wrongchar(_c,;);
}
nameStr.ptr=text+1; // skips '\n' nameStr.ptr=text+1; // skips '\n'
break; break;
case '}': case '}':
if(!calledRecursively || nameStr.length!=0) safethrow_wrongchar(c); if(!calledRecursively || nameStr.length!=0)
safethrow_wrongchar(c,;);
return SUCCESS(UniPtr(CharPtr,NULL)); return SUCCESS(UniPtr(CharPtr,NULL));
case ':': case ':':
return SUCCESS(UniPtr(CharPtr,string_cpToCptr(nameStr))); return SUCCESS(UniPtr(CharPtr,string_cpToCptr(nameStr)));
case '$': case '$':
if(nameStr.length!=0) if(nameStr.length!=0)
safethrow_wrongchar(c); safethrow_wrongchar(c,;);
nameStr.ptr++; nameStr.ptr++;
partOfDollarList=true; partOfDollarList=true;
break; break;
@ -111,7 +117,7 @@ Maybe __ReadName(DeserializeSharedData* shared){
break; break;
} }
if(nameStr.length>0) safethrow(ERR_ENDOFSTR); if(nameStr.length>0) safethrow(ERR_ENDOFSTR,;);
return SUCCESS(UniPtr(CharPtr,NULL)); return SUCCESS(UniPtr(CharPtr,NULL));
} }
#define ReadName() __ReadName(shared) #define ReadName() __ReadName(shared)
@ -133,6 +139,7 @@ Maybe __ReadString(DeserializeSharedData* shared){
// replacing <\"> with <"> // replacing <\"> with <">
Autoarr_remove(b); Autoarr_remove(b);
StringBuilder_append_char(b,c); StringBuilder_append_char(b,c);
prevIsBackslash=false;
} }
else { else {
char* str=StringBuilder_build(b); char* str=StringBuilder_build(b);
@ -146,7 +153,7 @@ Maybe __ReadString(DeserializeSharedData* shared){
} }
} }
safethrow(ERR_ENDOFSTR); safethrow(ERR_ENDOFSTR, Autoarr_clear(b));
} }
#define ReadString() __ReadString(shared) #define ReadString() __ReadString(shared)
@ -156,7 +163,10 @@ Maybe __ReadList(DeserializeSharedData* shared){
readingList=true; readingList=true;
while (true){ while (true){
try(ReadValue(), val) try(ReadValue(), val,{
Autoarr_clear(list);
free(list);
})
Autoarr_add(list,val.value); Autoarr_add(list,val.value);
if (!readingList) break; if (!readingList) break;
} }
@ -176,7 +186,7 @@ Maybe __ParseValue(DeserializeSharedData* shared, string str){
return SUCCESS(UniTrue); return SUCCESS(UniTrue);
else if(string_compare(str,falseStr)) else if(string_compare(str,falseStr))
return SUCCESS(UniFalse); return SUCCESS(UniFalse);
else safethrow_wrongchar(*str.ptr); else safethrow_wrongchar(*str.ptr,;);
break; break;
// Float64 // Float64
case 'f': { case 'f': {
@ -189,7 +199,14 @@ Maybe __ParseValue(DeserializeSharedData* shared, string str){
case 'u': { case 'u': {
uint64 lu=0; uint64 lu=0;
char* _c=string_cpToCptr(str); char* _c=string_cpToCptr(str);
sscanf(_c,"%lu",&lu); if(sscanf(_c,"%lu",&lu)!=1){
char err[64];
IFWIN(
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); free(_c);
return SUCCESS(Uni(UInt64,lu)); return SUCCESS(Uni(UInt64,lu));
} }
@ -204,17 +221,17 @@ Maybe __ParseValue(DeserializeSharedData* shared, string str){
sprintf_s(err,64,"can't parse to int: <%s>",_c), sprintf_s(err,64,"can't parse to int: <%s>",_c),
sprintf(err,"can't parse to int: <%s>",_c) sprintf(err,"can't parse to int: <%s>",_c)
); );
safethrow(err); safethrow(err,free(_c));
} }
free(_c); free(_c);
return SUCCESS(Uni(Int64,li)); return SUCCESS(Uni(Int64,li));
} }
// wrong type // wrong type
default: default:
safethrow_wrongchar(str.ptr[str.length-1]); safethrow_wrongchar(str.ptr[str.length-1],;);
} }
safethrow(ERR_ENDOFSTR); safethrow(ERR_ENDOFSTR,;);
}; };
#define ParseValue(str) __ParseValue(shared, str) #define ParseValue(str) __ParseValue(shared, str)
@ -234,29 +251,32 @@ Maybe __ReadValue(DeserializeSharedData* shared){
case '=': case ':': case '=': case ':':
case '}': case '$': case '}': case '$':
case '\'': case '\'':
safethrow_wrongchar(c); safethrow_wrongchar(c,;);
break; break;
case '#':; case '#':;
char _c=c; char _c=c;
try(SkipComment(),_); char* _text=text;
if(valueStr.length!=0) try(SkipComment(),_,;);
safethrow_wrongchar(_c); if(valueStr.length!=0){
text=_text;
safethrow_wrongchar(_c,;);
}
valueStr.ptr=text+1; // skips '\n' valueStr.ptr=text+1; // skips '\n'
break; break;
case '"': case '"':
if(valueStr.length!=0) { printf("length: %u valueStr: %s\n",valueStr.length, string_cpToCptr(valueStr)); safethrow_wrongchar(c);} if(valueStr.length!=0) safethrow_wrongchar(c,;);
try(ReadString(),maybeString) try(ReadString(),maybeString,;)
value=maybeString.value; value=maybeString.value;
break; break;
case '{': case '{':
if(valueStr.length!=0) safethrow_wrongchar(c); if(valueStr.length!=0) safethrow_wrongchar(c,;);
++text; // skips '{' ++text; // skips '{'
try(__deserialize(&text,true), val) try(__deserialize(&text,true), val,;)
value=val.value; value=val.value;
break; break;
case '[': case '[':
if(valueStr.length!=0) safethrow_wrongchar(c); if(valueStr.length!=0) safethrow_wrongchar(c,;);
try(ReadList(),maybeList) try(ReadList(),maybeList,;)
value=maybeList.value; value=maybeList.value;
break; break;
case ']': case ']':
@ -264,18 +284,18 @@ Maybe __ReadValue(DeserializeSharedData* shared){
case ';': case ';':
case ',': case ',':
if(valueStr.length!=0){ if(valueStr.length!=0){
try(ParseValue(valueStr),maybeParsed) try(ParseValue(valueStr),maybeParsed,;)
value=maybeParsed.value; value=maybeParsed.value;
} }
return SUCCESS(value); return SUCCESS(value);
default: default:
if(spaceAfterVal) if(spaceAfterVal)
safethrow_wrongchar(c); safethrow_wrongchar(c,;);
valueStr.length++; valueStr.length++;
break; break;
} }
safethrow(ERR_ENDOFSTR); safethrow(ERR_ENDOFSTR,;);
} }
@ -292,13 +312,14 @@ Maybe __deserialize(char** _text, bool _calledRecursively) {
text--; text--;
while(true){ while(true){
try(ReadName(), maybeName) try(ReadName(), maybeName, Hashtable_free(dict))
if(!maybeName.value.VoidPtr) // end of file or '}' in recursive call if(!maybeName.value.VoidPtr) // end of file or '}' in recursive call
goto END; goto END;
char* nameCPtr=maybeName.value.VoidPtr; char* nameCPtr=maybeName.value.VoidPtr;
printf("name: %s ", nameCPtr); try(ReadValue(), val, {
try(ReadValue(), val){ Hashtable_free(dict);
printuni(val.value);printf("\n"); free(nameCPtr);
}) {
if(partOfDollarList){ if(partOfDollarList){
Autoarr(Unitype)* list; Autoarr(Unitype)* list;
Unitype lu; Unitype lu;

12
DtsodParser/DtsodV24_serialize.c
View File

@ -51,7 +51,7 @@ Maybe __AppendValue(SerializeSharedData* shared, Unitype u){
StringBuilder_append_cptr(b, u.Bool ? "true" : "false"); StringBuilder_append_cptr(b, u.Bool ? "true" : "false");
break; break;
case Null: case Null:
safethrow("Null isn't supported in DtsodV24"); safethrow("Null isn't supported in DtsodV24",;);
break; break;
case AutoarrUnitypePtr: case AutoarrUnitypePtr:
addc('\n'); addc('\n');
@ -61,7 +61,7 @@ Maybe __AppendValue(SerializeSharedData* shared, Unitype u){
Autoarr_foreach(((Autoarr_Unitype*)(u.VoidPtr)), e, ({ Autoarr_foreach(((Autoarr_Unitype*)(u.VoidPtr)), e, ({
addc('\n'); addc('\n');
AppendTabs(); AppendTabs();
try(AppendValue(e),__); try(AppendValue(e),__,;);
addc(','); addc(',');
})); }));
Autoarr_remove(b); Autoarr_remove(b);
@ -75,11 +75,11 @@ Maybe __AppendValue(SerializeSharedData* shared, Unitype u){
AppendTabs(); AppendTabs();
addc('{'); addc('{');
addc('\n'); addc('\n');
try(__serialize(b,tabs+1,u.VoidPtr),___); try(__serialize(b,tabs+1,u.VoidPtr),___,;);
AppendTabs(); AppendTabs();
addc('}'); addc('}');
break; break;
default: dbg((u.type)); safethrow(ERR_WRONGTYPE); default: dbg((u.type)); safethrow(ERR_WRONGTYPE,;);
} }
return MaybeNull; return MaybeNull;
@ -97,7 +97,7 @@ Maybe __serialize(StringBuilder* _b, uint8 _tabs, Hashtable* dtsod){
StringBuilder_append_cptr(b,p.key); StringBuilder_append_cptr(b,p.key);
addc(':'); addc(':');
addc(' '); addc(' ');
try(AppendValue(p.value),__); try(AppendValue(p.value),__,;);
addc(';'); addc(';');
addc('\n'); addc('\n');
})); }));
@ -107,7 +107,7 @@ Maybe __serialize(StringBuilder* _b, uint8 _tabs, Hashtable* dtsod){
Maybe DtsodV24_serialize(Hashtable* dtsod){ Maybe DtsodV24_serialize(Hashtable* dtsod){
StringBuilder sb=StringBuilder_create(STRB_BC,STRB_BL); StringBuilder sb=StringBuilder_create(STRB_BC,STRB_BL);
try(__serialize(&sb,0,dtsod),__); try(__serialize(&sb,0,dtsod),__, Autoarr_clear((&sb)));
char* str=StringBuilder_build(&sb); char* str=StringBuilder_build(&sb);
Autoarr_clear((&sb)); Autoarr_clear((&sb));
return SUCCESS(UniPtr(CharPtr, str)); return SUCCESS(UniPtr(CharPtr, str));

17
Makefile
View File

@ -6,35 +6,38 @@ CMP=gcc
OPT_ARGS=-O2 -flto OPT_ARGS=-O2 -flto
WARN_ARGS=-Wall -Wno-discarded-qualifiers WARN_ARGS=-Wall -Wno-discarded-qualifiers
all: build_lib all: build_test
clear_c: clear_c:
clear clear
clear_bin: clear_bin:
@echo -e '\e[96m--------------[clear_bin]--------------\e[0m' @echo -e '\n\e[96m-------------[clear_bin]--------------\e[0m'
rm -rf $(OUTDIR) rm -rf $(OUTDIR)
mkdir $(OUTDIR) mkdir $(OUTDIR)
clang: CMP=clang clang: CMP=clang
clang: WARN_ARGS=-Wall -Wno-ignored-qualifiers -Wno-incompatible-pointer-types-discards-qualifiers
clang: all clang: all
TEST_FILE=kerep_test.com TEST_FILE=kerep_test.com
TEST_ARGS=$(WARN_ARGS) $(SRC) $(TESTS) -o $(OUTDIR)/$(TEST_FILE) TEST_ARGS=$(WARN_ARGS) $(SRC) $(TESTS) -o $(OUTDIR)/$(TEST_FILE)
build_test: clear_c clear_bin build_test: clear_c clear_bin
@echo -e '\n\e[96m----------------[build_test]----------------\e[0m' @echo -e '\n\e[96m-------------[build_test]-------------\e[0m'
$(CMP) $(OPT_ARGS) $(TEST_ARGS) $(CMP) $(OPT_ARGS) $(TEST_ARGS)
build_test_dbg: clear_c clear_bin build_test_dbg: clear_c clear_bin
@echo -e '\n\e[96m--------------[build_test_dbg]--------------\e[0m' @echo -e '\n\e[96m-----------[build_test_dbg]-----------\e[0m'
$(CMP) -g -O0 $(TEST_ARGS).dbg $(CMP) -g -O0 $(TEST_ARGS).dbg
test: build_test test: build_test
@echo -e '\n\e[96m----------------[test]-----------------\e[0m' @echo -e '\n\e[96m-------------[build_test]-------------\e[0m'
tabs 4
$(OUTDIR)/$(TEST_FILE) $(OUTDIR)/$(TEST_FILE)
valgrind: build_test_dbg valgrind: build_test_dbg
@echo -e '\n\e[96m--------------[valgrind]---------------\e[0m' @echo -e '\n\e[96m--------------[valgrind]--------------\e[0m'
tabs 4
valgrind -s --read-var-info=yes --track-origins=yes --fullpath-after=kerep/ \ valgrind -s --read-var-info=yes --track-origins=yes --fullpath-after=kerep/ \
--leak-check=full --show-leak-kinds=all $(OUTDIR)/$(TEST_FILE).dbg --leak-check=full --show-leak-kinds=all $(OUTDIR)/$(TEST_FILE).dbg
@ -43,5 +46,5 @@ LIB_ARGS=$(OPT_ARGS) $(WARN_ARGS)\
-fpic -shared -Wl,-soname,$(LIB_FILE)\ -fpic -shared -Wl,-soname,$(LIB_FILE)\
$(SRC) tests/test_marshalling.c -o $(OUTDIR)/$(LIB_FILE) $(SRC) tests/test_marshalling.c -o $(OUTDIR)/$(LIB_FILE)
build_lib: clear_c clear_bin build_lib: clear_c clear_bin
@echo -e '\n\e[96m-------------[build_lib]---------------\e[0m' @echo -e '\n\e[96m-------------[build_lib]--------------\e[0m'
$(CMP) $(LIB_ARGS) $(CMP) $(LIB_ARGS)

3
README.md
View File

@ -1,3 +1,6 @@
# kerep # kerep
My library written in C My library written in C
# TODO
change return type of Autoarr_create() and StringBuilder_create() to pointers

5
base/errors.h
View File

@ -45,10 +45,11 @@ char* __unknownErr( );
)(E) )(E)
#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, FREEMEM) { FREEMEM; __RETURN_EXCEPTION(((char*)__genErrMsg((__stringify_err(E)), __FILE__,__LINE__,__func__))); }
#define try(_funcCall, _rezult) Maybe _rezult=_funcCall; if(_rezult.errmsg){\ #define try(_funcCall, _rezult, freeMem) Maybe _rezult=_funcCall; if(_rezult.errmsg){\
freeMem;\
_rezult.errmsg=__extendErrMsg(_rezult.errmsg, __FILE__,__LINE__,__func__);\ _rezult.errmsg=__extendErrMsg(_rezult.errmsg, __FILE__,__LINE__,__func__);\
return _rezult;\ return _rezult;\
}else }else

32
base/types.c
View File

@ -115,17 +115,22 @@ void Unitype_free(Unitype u){
} }
} }
#define SPRINT_BUFSIZE 1024 #define BUFSIZE 64
void sprintuni(char* buf,Unitype v){ char* sprintuni(Unitype v){
char* buf=malloc(BUFSIZE);
IFWIN( IFWIN(
switch (v.type) { switch (v.type) {
case Null: sprintf_s(buf, SPRINT_BUFSIZE, "{Null}");break; case Null: sprintf_s(buf, BUFSIZE, "{Null}");break;
case Float64: sprintf_s(buf, SPRINT_BUFSIZE, "{%s : %lf}", my_type_name(v.type),v.Float64);break; case Float64: sprintf_s(buf, BUFSIZE, "{%s : %lf}", my_type_name(v.type),v.Float64);break;
case Bool: case Bool:
case UInt64: sprintf_s(buf, SPRINT_BUFSIZE, "{%s : %lu}", my_type_name(v.type),v.UInt64);break; case UInt64: sprintf_s(buf, 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 Int64: sprintf_s(buf, 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; case CharPtr: ;
default: sprintf_s(buf, SPRINT_BUFSIZE, "{%s : %p}", my_type_name(v.type),v.VoidPtr);break; size_t newBUFSIZE=cptr_length(v.VoidPtr) + BUFSIZE/2;
buf=realloc(buf, newBUFSIZE);
sprintf_s(buf, newBUFSIZE, "{%s : \"%s\"}", my_type_name(v.type),(char*)v.VoidPtr);
break;
default: sprintf_s(buf, 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;
@ -133,14 +138,19 @@ void sprintuni(char* buf,Unitype v){
case Bool: case Bool:
case UInt64: sprintf(buf, "{%s : %lu}", my_type_name(v.type),v.UInt64);break; 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 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; case CharPtr: ;
size_t newBUFSIZE=cptr_length(v.VoidPtr) + BUFSIZE/2;
buf=realloc(buf, newBUFSIZE);
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;
} }
); );
return buf;
} }
void printuni(Unitype v){ void printuni(Unitype v){
char s[SPRINT_BUFSIZE]; char* s=sprintuni(v);
sprintuni(s,v);
fputs(s, stdout); fputs(s, stdout);
free(s);
} }

2
base/types.h
View File

@ -50,7 +50,7 @@ static const Unitype UniFalse={.Bool=false,.type=Bool};
// frees VoidPtr value or does nothing if type isn't pointer // frees VoidPtr value or does nothing if type isn't pointer
void Unitype_free(Unitype u); void Unitype_free(Unitype u);
void printuni(Unitype v); void printuni(Unitype v);
void sprintuni(char* s, Unitype v); char* sprintuni(Unitype v);
#if __cplusplus #if __cplusplus
} }

4
tests/test_dtsod.c
View File

@ -38,6 +38,7 @@ 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;
optime("deserialize",1,({ optime("deserialize",1,({
tryLast(DtsodV24_deserialize(text),r) tryLast(DtsodV24_deserialize(text),r)
@ -45,7 +46,6 @@ void test_dtsod(){
})); }));
print_dtsod(dtsod); print_dtsod(dtsod);
char* s;
optime("serialize",1,({ optime("serialize",1,({
tryLast(DtsodV24_serialize(dtsod),r) tryLast(DtsodV24_serialize(dtsod),r)
s=r.value.VoidPtr; s=r.value.VoidPtr;
@ -65,7 +65,6 @@ void test_dtsod(){
free(s); free(s);
FILE* f=fopen("messages.dtsod", "r"); FILE* f=fopen("messages.dtsod", "r");
printf("f: %p\n", f);
if(f==NULL){ if(f==NULL){
perror("error "); perror("error ");
throw("can't open file"); throw("can't open file");
@ -77,6 +76,7 @@ void test_dtsod(){
fbuf[i++]=cc; fbuf[i++]=cc;
} }
fbuf[i]='\0'; fbuf[i]='\0';
fclose(f);
printf("read %u chars", i); printf("read %u chars", i);
Maybe rrr=DtsodV24_deserialize(fbuf); Maybe rrr=DtsodV24_deserialize(fbuf);
if(rrr.errmsg) { if(rrr.errmsg) {

13
tests/test_safethrow.c
View File

@ -5,11 +5,12 @@ Maybe dont_throw(){
} }
Maybe throw_error(){ Maybe throw_error(){
safethrow("test exception"); char* k=malloc(64);
safethrow("test exception",free(k));
} }
Maybe throw_errcode(){ Maybe throw_errcode(){
safethrow(ERR_NULLPTR); safethrow(ERR_NULLPTR,;);
} }
Maybe test_maybe(){ Maybe test_maybe(){
@ -17,16 +18,16 @@ Maybe test_maybe(){
tryLast(dont_throw(),rez0) tryLast(dont_throw(),rez0)
printMaybe(rez0); printMaybe(rez0);
printf("\n"); printf("\n");
try(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(){ try(throw_errcode(),_) return MaybeNull; } Maybe c(){ try(throw_errcode(),_,;) return MaybeNull; }
Maybe b(){ try(c(),_) return MaybeNull; } Maybe b(){ try(c(),_,;) return MaybeNull; }
Maybe a(){ try(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");