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
.old*/
#temp
messages.dtsod

135
DtsodParser/DtsodV24_deserialize.c
View File

@ -1,20 +1,35 @@
#include "DtsodV24.h"
#include "../Autoarr/StringBuilder.h"
#define ARR_BC 8
#define ARR_BL 16
#define ARR_BC 64
#define ARR_BL 1024
#define STRB_BC 64
#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
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];
errBuf[67]='\0';
char* errText=text-32;
for(uint8 n=0; n<sizeof(errBuf);n++)
errBuf[n]='\0';
char* errText=_text-32;
uint8 cplace=32;
if(errText<text_first) {
cplace=errText-text_first;
cplace=_text-text_first;
errText=text_first;
}
uint8 i=0;
@ -32,9 +47,9 @@ Maybe ERROR_WRONGCHAR(const char c, char* text, char* text_first, const char* sr
errBuf[i]=_c;
if(!_c) break;
}
char* errmsg=malloc(512);
char errmsg[1024];
IFWIN(
sprintf_s(errmsg,512, "unexpected <%c> at:\n"
sprintf_s(errmsg,1024, "unexpected <%c> at:\n"
" \"%s\"\n"
"\\___[%s:%d] %s()",
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()",
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__)
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
#define safethrow_wrongchar(C, freeMem) { freeMem; return ERROR_WRONGCHAR(C, text, shared->sh_text_first, __FILE__,__LINE__,__func__); }
Maybe __SkipComment(DeserializeSharedData* shared) {
char c;
while ((c=*++text) != '\n')
if (!c) safethrow(ERR_ENDOFSTR);
if (!c) safethrow(ERR_ENDOFSTR,;);
return MaybeNull;
}
@ -80,29 +81,34 @@ Maybe __ReadName(DeserializeSharedData* shared){
case ' ': case '\t':
case '\r': case '\n':
if(nameStr.length!=0)
safethrow_wrongchar(c);
safethrow_wrongchar(c,;);
nameStr.ptr++;
break;
case '=': case ';':
case '\'': case '"':
case '[': case ']':
case '{':
safethrow_wrongchar(c);
safethrow_wrongchar(c,;);
break;
case '#': ;
try(SkipComment(),_);
if(nameStr.length!=0)
safethrow_wrongchar(c);
char _c=c;
char* _text=text;
try(SkipComment(),_,;);
if(nameStr.length!=0){
text=_text;
safethrow_wrongchar(_c,;);
}
nameStr.ptr=text+1; // skips '\n'
break;
case '}':
if(!calledRecursively || nameStr.length!=0) safethrow_wrongchar(c);
if(!calledRecursively || nameStr.length!=0)
safethrow_wrongchar(c,;);
return SUCCESS(UniPtr(CharPtr,NULL));
case ':':
return SUCCESS(UniPtr(CharPtr,string_cpToCptr(nameStr)));
case '$':
if(nameStr.length!=0)
safethrow_wrongchar(c);
safethrow_wrongchar(c,;);
nameStr.ptr++;
partOfDollarList=true;
break;
@ -111,7 +117,7 @@ Maybe __ReadName(DeserializeSharedData* shared){
break;
}
if(nameStr.length>0) safethrow(ERR_ENDOFSTR);
if(nameStr.length>0) safethrow(ERR_ENDOFSTR,;);
return SUCCESS(UniPtr(CharPtr,NULL));
}
#define ReadName() __ReadName(shared)
@ -133,6 +139,7 @@ Maybe __ReadString(DeserializeSharedData* shared){
// replacing <\"> with <">
Autoarr_remove(b);
StringBuilder_append_char(b,c);
prevIsBackslash=false;
}
else {
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)
@ -156,7 +163,10 @@ Maybe __ReadList(DeserializeSharedData* shared){
readingList=true;
while (true){
try(ReadValue(), val)
try(ReadValue(), val,{
Autoarr_clear(list);
free(list);
})
Autoarr_add(list,val.value);
if (!readingList) break;
}
@ -176,7 +186,7 @@ Maybe __ParseValue(DeserializeSharedData* shared, string str){
return SUCCESS(UniTrue);
else if(string_compare(str,falseStr))
return SUCCESS(UniFalse);
else safethrow_wrongchar(*str.ptr);
else safethrow_wrongchar(*str.ptr,;);
break;
// Float64
case 'f': {
@ -189,7 +199,14 @@ Maybe __ParseValue(DeserializeSharedData* shared, string str){
case 'u': {
uint64 lu=0;
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);
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(err,"can't parse to int: <%s>",_c)
);
safethrow(err);
safethrow(err,free(_c));
}
free(_c);
return SUCCESS(Uni(Int64,li));
}
// wrong type
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)
@ -234,29 +251,32 @@ Maybe __ReadValue(DeserializeSharedData* shared){
case '=': case ':':
case '}': case '$':
case '\'':
safethrow_wrongchar(c);
safethrow_wrongchar(c,;);
break;
case '#':;
char _c=c;
try(SkipComment(),_);
if(valueStr.length!=0)
safethrow_wrongchar(_c);
char* _text=text;
try(SkipComment(),_,;);
if(valueStr.length!=0){
text=_text;
safethrow_wrongchar(_c,;);
}
valueStr.ptr=text+1; // skips '\n'
break;
case '"':
if(valueStr.length!=0) { printf("length: %u valueStr: %s\n",valueStr.length, string_cpToCptr(valueStr)); safethrow_wrongchar(c);}
try(ReadString(),maybeString)
if(valueStr.length!=0) safethrow_wrongchar(c,;);
try(ReadString(),maybeString,;)
value=maybeString.value;
break;
case '{':
if(valueStr.length!=0) safethrow_wrongchar(c);
if(valueStr.length!=0) safethrow_wrongchar(c,;);
++text; // skips '{'
try(__deserialize(&text,true), val)
try(__deserialize(&text,true), val,;)
value=val.value;
break;
case '[':
if(valueStr.length!=0) safethrow_wrongchar(c);
try(ReadList(),maybeList)
if(valueStr.length!=0) safethrow_wrongchar(c,;);
try(ReadList(),maybeList,;)
value=maybeList.value;
break;
case ']':
@ -264,18 +284,18 @@ Maybe __ReadValue(DeserializeSharedData* shared){
case ';':
case ',':
if(valueStr.length!=0){
try(ParseValue(valueStr),maybeParsed)
try(ParseValue(valueStr),maybeParsed,;)
value=maybeParsed.value;
}
return SUCCESS(value);
default:
if(spaceAfterVal)
safethrow_wrongchar(c);
safethrow_wrongchar(c,;);
valueStr.length++;
break;
}
safethrow(ERR_ENDOFSTR);
safethrow(ERR_ENDOFSTR,;);
}
@ -292,13 +312,14 @@ Maybe __deserialize(char** _text, bool _calledRecursively) {
text--;
while(true){
try(ReadName(), maybeName)
try(ReadName(), maybeName, Hashtable_free(dict))
if(!maybeName.value.VoidPtr) // end of file or '}' in recursive call
goto END;
char* nameCPtr=maybeName.value.VoidPtr;
printf("name: %s ", nameCPtr);
try(ReadValue(), val){
printuni(val.value);printf("\n");
try(ReadValue(), val, {
Hashtable_free(dict);
free(nameCPtr);
}) {
if(partOfDollarList){
Autoarr(Unitype)* list;
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");
break;
case Null:
safethrow("Null isn't supported in DtsodV24");
safethrow("Null isn't supported in DtsodV24",;);
break;
case AutoarrUnitypePtr:
addc('\n');
@ -61,7 +61,7 @@ Maybe __AppendValue(SerializeSharedData* shared, Unitype u){
Autoarr_foreach(((Autoarr_Unitype*)(u.VoidPtr)), e, ({
addc('\n');
AppendTabs();
try(AppendValue(e),__);
try(AppendValue(e),__,;);
addc(',');
}));
Autoarr_remove(b);
@ -75,11 +75,11 @@ Maybe __AppendValue(SerializeSharedData* shared, Unitype u){
AppendTabs();
addc('{');
addc('\n');
try(__serialize(b,tabs+1,u.VoidPtr),___);
try(__serialize(b,tabs+1,u.VoidPtr),___,;);
AppendTabs();
addc('}');
break;
default: dbg((u.type)); safethrow(ERR_WRONGTYPE);
default: dbg((u.type)); safethrow(ERR_WRONGTYPE,;);
}
return MaybeNull;
@ -97,7 +97,7 @@ Maybe __serialize(StringBuilder* _b, uint8 _tabs, Hashtable* dtsod){
StringBuilder_append_cptr(b,p.key);
addc(':');
addc(' ');
try(AppendValue(p.value),__);
try(AppendValue(p.value),__,;);
addc(';');
addc('\n');
}));
@ -107,7 +107,7 @@ Maybe __serialize(StringBuilder* _b, uint8 _tabs, Hashtable* dtsod){
Maybe DtsodV24_serialize(Hashtable* dtsod){
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);
Autoarr_clear((&sb));
return SUCCESS(UniPtr(CharPtr, str));

17
Makefile
View File

@ -6,35 +6,38 @@ CMP=gcc
OPT_ARGS=-O2 -flto
WARN_ARGS=-Wall -Wno-discarded-qualifiers
all: build_lib
all: build_test
clear_c:
clear
clear_bin:
@echo -e '\e[96m--------------[clear_bin]--------------\e[0m'
@echo -e '\n\e[96m-------------[clear_bin]--------------\e[0m'
rm -rf $(OUTDIR)
mkdir $(OUTDIR)
clang: CMP=clang
clang: WARN_ARGS=-Wall -Wno-ignored-qualifiers -Wno-incompatible-pointer-types-discards-qualifiers
clang: all
TEST_FILE=kerep_test.com
TEST_ARGS=$(WARN_ARGS) $(SRC) $(TESTS) -o $(OUTDIR)/$(TEST_FILE)
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)
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
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)
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/ \
--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)\
$(SRC) tests/test_marshalling.c -o $(OUTDIR)/$(LIB_FILE)
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)

3
README.md
View File

@ -1,3 +1,6 @@
# kerep
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)
#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__);\
return _rezult;\
}else

32
base/types.c
View File

@ -115,17 +115,22 @@ void Unitype_free(Unitype u){
}
}
#define SPRINT_BUFSIZE 1024
void sprintuni(char* buf,Unitype v){
#define BUFSIZE 64
char* sprintuni(Unitype v){
char* buf=malloc(BUFSIZE);
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 Null: sprintf_s(buf, BUFSIZE, "{Null}");break;
case Float64: sprintf_s(buf, 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;
case UInt64: sprintf_s(buf, BUFSIZE, "{%s : %lu}", my_type_name(v.type),v.UInt64);break;
case Int64: sprintf_s(buf, BUFSIZE, "{%s : %ld}", my_type_name(v.type),v.Int64);break;
case CharPtr: ;
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) {
case Null: sprintf(buf, "{Null}");break;
@ -133,14 +138,19 @@ void sprintuni(char* buf,Unitype v){
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;
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;
}
);
return buf;
}
void printuni(Unitype v){
char s[SPRINT_BUFSIZE];
sprintuni(s,v);
char* s=sprintuni(v);
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
void Unitype_free(Unitype u);
void printuni(Unitype v);
void sprintuni(char* s, Unitype v);
char* sprintuni(Unitype v);
#if __cplusplus
}

4
tests/test_dtsod.c
View File

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

13
tests/test_safethrow.c
View File

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