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

added freeMem argument in safethrow and try, fixed throw_wrongchar

Browse Source
This commit is contained in:
Timerix22 2022-04-18 23:34:40 +03:00
parent 1d7beebf6c
commit fd95e311f0
6 changed files with 103 additions and 68 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

133
DtsodParser/DtsodV24_deserialize.c
View File

@ -7,14 +7,29 @@
#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=malloc(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)
@ -146,7 +152,7 @@ Maybe __ReadString(DeserializeSharedData* shared){
} }
} }
safethrow(ERR_ENDOFSTR); safethrow(ERR_ENDOFSTR, Autoarr_clear(b));
} }
#define ReadString() __ReadString(shared) #define ReadString() __ReadString(shared)
@ -156,7 +162,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 +185,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 +198,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 +220,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 +250,37 @@ 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) {
try(ReadString(),maybeString) char* vp=string_cpToCptr(valueStr);
printf("\nlength: %u valueStr: %s\n",valueStr.length, vp);
free(vp);
safethrow_wrongchar(c,;);
}
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 +288,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,12 +316,15 @@ 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); printf("name: %s ", nameCPtr);
try(ReadValue(), val){ try(ReadValue(), val, {
Hashtable_free(dict);
free(nameCPtr);
}) {
printuni(val.value);printf("\n"); printuni(val.value);printf("\n");
if(partOfDollarList){ if(partOfDollarList){
Autoarr(Unitype)* list; Autoarr(Unitype)* list;

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));

5
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

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");