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

fuck go back

Browse Source
This commit is contained in:
Timerix22 2022-04-17 00:06:28 +03:00
parent 07c5a0ce69
commit fb611882a1
21 changed files with 175 additions and 327 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
Autoarr/StringBuilder.c
View File

@ -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_s(buf,32,"%lf",a),
sprintf(buf,"%lf",a)
);
sprintf(buf,"%lf",a);
StringBuilder_append_cptr(b,buf);
}

2
DtsodParser/DtsodV24.h
View File

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

188
DtsodParser/DtsodV24_deserialize.c
View File

@ -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;
for(uint8 i=0; i<32; i++)
// writes 16 chars before and 15 after the wrongchar
errBuf[i+22]=*(text - 16 + i);
safethrow(cptr_copy(errBuf));
}
#define safethrow_wrongchar(C) return ERROR_WRONGCHAR(C, text)
errBuf[12]=_c;
for (uint8 i=0; i < 32; i++)
errBuf[i + 22]=*(_text - 16 + i);
printf("\n\e[91m[%s:%d %s] throwed error: %s\n", file, line, fname, errBuf);
exit(128);
};
#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);
return MaybeNull;
}
if (!c) throw(ERR_ENDOFSTR);
};
#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 '#': ;
try(SkipComment(),_);
case '#':
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);
return SUCCESS(UniPtr(CharPtr,NULL));
}
if(nameStr.length>0) throw(ERR_ENDOFSTR);
return nameStr;
};
#define ReadName() __ReadName(shared)
Maybe __deserialize(char** _text, bool _calledRecursively);
Maybe __ReadValue(DeserializeSharedData* shared);
Hashtable* __deserialize(char** _text, bool _calledRecursively);
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,val.value);
Autoarr_add(list,ReadValue());
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);
else safethrow_wrongchar(*str.ptr);
return UniNull;
else throw_wrongchar(*str.ptr);
break;
case 't':
if(string_compare(str,trueStr))
return SUCCESS(UniTrue);
else safethrow_wrongchar(*str.ptr);
return UniTrue;
else throw_wrongchar(*str.ptr);
break;
case 'f':
if(string_compare(str,falseStr))
return SUCCESS(UniFalse);
else safethrow_wrongchar(*str.ptr);
return UniFalse;
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_s(err,64,"can't parse to int: <%s>",_c),
sprintf(err,"can't parse to int: <%s>",_c)
);
safethrow(err);
sprintf(err,"can't parse to int: <%s>",_c);
throw(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 '\'':
safethrow_wrongchar(c);
throw_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);
try(ReadString(),maybeString)
value=maybeString.value;
if(valueStr.length!=0) throw_wrongchar(c);
value=UniPtr(CharPtr,ReadString());
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);
try(ReadList(),maybeList)
value=maybeList.value;
if(valueStr.length!=0) throw_wrongchar(c);
value=UniPtr(AutoarrUnitypePtr,ReadList());
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)
return SUCCESS(val.value);
value=UniPtr(HashtablePtr, __deserialize(&text,true));
return value;
case ';':
case ',':
if(valueStr.length!=0){
try(ParseValue(valueStr),maybeParsed)
value=maybeParsed.value;
}
return SUCCESS(value);
if(valueStr.length!=0)
value=ParseValue(valueStr);
return 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,31 +255,31 @@ Maybe __deserialize(char** _text, bool _calledRecursively) {
text--;
while((c=*++text)){
try(ReadName(), maybeName)
if(!maybeName.value.VoidPtr) //end of file or '}' in recursive call
string name=ReadName();
if(name.length==0) //end of file or '}' in recursive call
goto END;
char* nameCPtr=maybeName.value.VoidPtr;
try(ReadValue(), val)
if(partOfDollarList){
Autoarr(Unitype)* list;
Unitype lu;
if(Hashtable_try_get(dict,nameCPtr, &lu)){
list=(Autoarr(Unitype)*)lu.VoidPtr;
}
else{
list=malloc(sizeof(Autoarr(Unitype)));
*list=Autoarr_create(Unitype,ARR_BC,ARR_BL);
Hashtable_add(dict,nameCPtr,UniPtr(AutoarrUnitypePtr,list));
}
Autoarr_add(list,val.value);
char* nameCPtr=string_cpToCptr(name);
Unitype value=ReadValue();
if(partOfDollarList){
Autoarr(Unitype)* list;
Unitype lu;
if(Hashtable_try_get(dict,nameCPtr, &lu)){
list=(Autoarr(Unitype)*)lu.VoidPtr;
}
else Hashtable_add(dict,nameCPtr,val.value);
else{
list=malloc(sizeof(Autoarr(Unitype)));
*list=Autoarr_create(Unitype,ARR_BC,ARR_BL);
Hashtable_add(dict,nameCPtr,UniPtr(AutoarrUnitypePtr,list));
}
Autoarr_add(list,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);
}

6
DtsodParser/DtsodV24_exported.c
View File

@ -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){
Maybe r=DtsodV24_deserialize(text);
*errmsg= r.errmsg ? r.errmsg : NULL;
*output=r.value.VoidPtr;
EXPORT void CALL kerep_DtsodV24_deserialize(char* text, Hashtable** output){
*output=DtsodV24_deserialize(text);
}
//creates text representation of dtsod

5
DtsodParser/DtsodV24_serialize.c
View File

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

2
Makefile
View File

@ -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

37
base/base.h
View File

@ -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) ({\
struct timespec start, stop;\
clock_gettime(CLOCK_REALTIME, &start);\
for(uint64 ___OPREP=0;___OPREP<(uint64)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) ({\
clock_t start=clock();\
for(uint64 ___OPREP=0;___OPREP<(uint64)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
/*#define optime(opname,repeats,codeblock) ({\
struct timespec start, stop;\
clock_gettime(CLOCK_REALTIME, &start);\
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);\
})*/
#define optime(opname,repeats,codeblock) ({\
clock_t start=clock();\
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);\
})
#if __cplusplus
}

44
base/errors.c
View File

@ -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
char* __genErrMsg(const char* errmsg, const char* srcfile, int line, const char* funcname){
size_t bufsize=ERRMSG_MAXLENGTH;
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;
void _throwint(int err, const char* srcfile, int line, const char* funcname){
if(err){ // SUCCESS=0 is not an error
printf("\e[91m[%s:%d %s] throwed error: %s\e[0m\n",srcfile,line,funcname,errname(err));
exit(err);
}
else printf("\e[93m[%s:%d %s] throwed SUCCESS as an error",srcfile,line,funcname);
}
char* __extendErrMsg(const char* errmsg, const char* srcfile, int line, const char* funcname){
size_t bufsize=cptr_length(errmsg)+ERRMSG_MAXLENGTH;
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 _throwstr(const char* errmesg, const char* srcfile, int line, const char* funcname){
printf("\e[91m[%s:%d %s] throwed error: %s\e[0m\n",srcfile,line,funcname,errmesg);
exit(255);
}
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";}

54
base/errors.h
View File

@ -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);
char* __extendErrMsg(const char* errmsg, const char* srcfile, int line, const char* funcname);
typedef struct Maybe{
Unitype value;
char* errmsg;
} Maybe;
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
void _throwint(int err, 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"
#define throw(E) \
CHOOSE(IFTYPE(E,int), _throwint(E,__FILE__,__LINE__,__func__), \
CHOOSE(IFTYPE(E,char[]), _throwstr(E,__FILE__,__LINE__,__func__), \
printf("\e[31m[%s:%d/%s] UNKNOWN ERROR\n",__FILE__,__LINE__,__func__)))
#if __cplusplus
}

3
base/mystr.c
View File

@ -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];

1
base/std.h
View File

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

37
base/types.c
View File

@ -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);
sprintuni(s,v);
fputs(s, stdout);
free(s);
switch (v.type) {
case Null: printf("{Null}");break;
case Float64: printf("{%s : %lf}",my_type_name(v.type),v.Float64);break;
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;
}
}

2
base/types.h
View File

@ -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
}

19
kerep.vcxproj
View File

@ -75,27 +75,27 @@
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<OutDir>bin\$(Configuration)-$(Platform)\</OutDir>
<IntDir>obj\$(Configuration)-$(Platform)\</IntDir>
<OutDir>bin-$(Platform)\$(Configuration)\</OutDir>
<IntDir>obj-$(Platform)\$(Configuration)\</IntDir>
<RunCodeAnalysis>true</RunCodeAnalysis>
<ManagedAssembly>false</ManagedAssembly>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<OutDir>bin\$(Configuration)-$(Platform)\</OutDir>
<IntDir>obj\$(Configuration)-$(Platform)\</IntDir>
<OutDir>bin-$(Platform)\$(Configuration)\</OutDir>
<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>
<IntDir>obj\$(Configuration)-$(Platform)\</IntDir>
<OutDir>bin-$(Platform)\$(Configuration)\</OutDir>
<IntDir>obj-$(Platform)\$(Configuration)\</IntDir>
<ManagedAssembly>false</ManagedAssembly>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<RunCodeAnalysis>true</RunCodeAnalysis>
<OutDir>bin\$(Configuration)-$(Platform)\</OutDir>
<IntDir>obj\$(Configuration)-$(Platform)\</IntDir>
<OutDir>bin-$(Platform)\$(Configuration)\</OutDir>
<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>

9
kerep.vcxproj.filters
View File

@ -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>

5
tests/main.c
View File

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

14
tests/test_dtsod.c
View File

@ -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,({
tryLast(DtsodV24_deserialize(text),r)
dtsod=r.value.VoidPtr;
}));
optime("deserialize",1,(dtsod=DtsodV24_deserialize(s)));
free(s);
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=r.value.VoidPtr;
dtsod=DtsodV24_deserialize(s);
free(s);
s=DtsodV24_serialize(dtsod);
Hashtable_free(dtsod);

10
tests/test_hashtable.c
View File

@ -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_s(key,12,"key_%u",i),
sprintf(key,"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_s(key,12,"key_%u",i),
sprintf(key,"key_%u",i)
);
sprintf(key,"key__%u",i);
u=Hashtable_get(ht,key);
}
free(key);

43
tests/test_safethrow.c
View File

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

4
tests/test_string.c
View File

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

1
tests/tests.h
View File

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