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

Merge pull request #11 from Timerix22/new_unitype

Browse Source 
new build system
This commit is contained in:
Timerix22 2022-09-09 22:14:26 +06:00 committed by GitHub
commit d9b0daf543
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
64 changed files with 971 additions and 634 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -5,7 +5,6 @@ obj/
# user files # user files
.old*/ .old*/
.vs/ .vs/
.vscode/
.vshistory/ .vshistory/
.editorconfig .editorconfig
*.user *.user

3
.gitmodules vendored Normal file
View File

@ -0,0 +1,3 @@
[submodule "cbuild"]
path = cbuild
url = https://github.com/Timerix22/cbuild.git

1
.vscode/.gitignore vendored Normal file
View File

@ -0,0 +1 @@
settings.json

34
.vscode/launch.json vendored Normal file
View File

@ -0,0 +1,34 @@
{
"version": "0.2.0",
"configurations": [
{
"name": "(gdb) Debug",
"type": "cppdbg",
"request": "launch",
"preLaunchTask": "build_exec_dbg",
"program": "${workspaceFolder}/bin/kerep.com",
"stopAtEntry": false,
"cwd": "${workspaceFolder}",
"externalConsole": true,
"internalConsoleOptions": "openOnSessionStart",
"miDebuggerPath": "/usr/bin/gdb",
"MIMode": "gdb",
"pipeTransport": {
"debuggerPath": "gdb",
"pipeProgram": "bash",
"pipeArgs": ["-c"],
"pipeCwd": "${workspaceFolder}"
}
},
{
"name": "(msvc) Debug",
"type": "cppvsdbg",
"request": "launch",
"preLaunchTask": "build_dbg",
"cwd": "${workspaceFolder}\\bin",
"program": "${workspaceFolder}\\bin\\kerep.com",
"stopAtEntry": false,
"console": "integratedTerminal"
}
]
}

57
.vscode/tasks.json vendored Normal file
View File

@ -0,0 +1,57 @@
{
"version": "2.0.0",
"tasks": [
{
"label": "build_exec",
"detail": "build project",
"type": "cppbuild",
"command": "make",
"args": [
"build_exec"
],
"options": {
"cwd": "${workspaceFolder}"
},
"problemMatcher": ["$gcc"],
"group": {
"kind": "build",
"isDefault": true
},
"presentation": {
"echo": true,
"reveal": "always",
"focus": true,
"panel": "shared",
"showReuseMessage": false,
"clear": true
}
},
{
"label": "build_exec_dbg",
"detail": "build project with debug symbols",
"type": "cppbuild",
"command": "make",
"args": [
"build_exec_dbg"
],
"options": {
"cwd": "${workspaceFolder}"
},
"problemMatcher": ["$gcc"],
"group": {
"kind": "build"
},
"presentation": {
"echo": true,
"reveal": "always",
"focus": true,
"panel": "shared",
"showReuseMessage": false,
"clear": true
}
}
]
}

32
Makefile
View File

@ -1,24 +1,24 @@
###### Building tasks ####### ###### Build cbuild/default_tasks #######
build_test: build_exec:
@build_scripts/build_configurations/build_test.sh @cbuild/call_task.sh build_exec
build_exec_dbg:
build_test_dbg: @cbuild/call_task.sh build_exec_dbg
@build_scripts/build_configurations/build_test_dbg.sh
build_shared_lib: build_shared_lib:
@build_scripts/build_configurations/build_shared_lib.sh @cbuild/call_task.sh build_shared_lib
build_shared_lib_dbg:
@cbuild/call_task.sh build_shared_lib_dbg
build_static_lib: build_static_lib:
@build_scripts/build_configurations/build_static_lib.sh @cbuild/call_task.sh build_static_lib
build_static_lib_dbg: build_static_lib_dbg:
@build_scripts/build_configurations/build_static_lib_dbg.sh @cbuild/call_task.sh build_static_lib_dbg
###### Testing tasks ####### ###### Launch cbuild/default_tasks #######
test: build_test exec: build_exec
@build_scripts/build_configurations/test.sh @cbuild/call_task.sh exec
test_valgrind: build_test_dbg valgrind: build_exec_dbg
@build_scripts/build_configurations/test_valgrind.sh @cbuild/call_task.sh valgrind
all: build_test all: build_exec

10
build_scripts/build_configurations/build_shared_lib.sh
View File

@ -1,10 +0,0 @@
#!/bin/bash
source build_scripts/init.sh
print "${CYAN}==========[build_shared_lib]==========\n"
clear_dir "$OUTDIR"
clear_dir "$OBJDIR"
compile_c "$BUILD_SHARED_LIB_C_ARGS" "$SRC_C tests/test_marshalling.c"
compile_cpp "$BUILD_SHARED_LIB_CPP_ARGS" "$SRC_CPP"
link "$BUILD_SHARED_LIB_CPP_ARGS $BUILD_SHARED_LIB_LINKER_ARGS" "$SHARED_LIB_FILE"

10
build_scripts/build_configurations/build_static_lib.sh
View File

@ -1,10 +0,0 @@
#!/bin/bash
source build_scripts/init.sh
print "${CYAN}==========[build_static_lib]==========\n"
clear_dir "$OUTDIR"
clear_dir "$OBJDIR"
compile_c "$BUILD_STATIC_LIB_C_ARGS" "$SRC_C tests/test_marshalling.c"
compile_cpp "$BUILD_STATIC_LIB_CPP_ARGS" "$SRC_CPP"
pack_static_lib "$STATIC_LIB_FILE"

10
build_scripts/build_configurations/build_static_lib_dbg.sh
View File

@ -1,10 +0,0 @@
#!/bin/bash
source build_scripts/init.sh
print "${CYAN}==========[build_static_lib_dbg]==========\n"
clear_dir "$OUTDIR"
clear_dir "$OBJDIR"
compile_c "$BUILD_STATIC_LIB_DBG_C_ARGS" "$SRC_C tests/test_marshalling.c"
compile_cpp "$BUILD_STATIC_LIB_DBG_CPP_ARGS" "$SRC_CPP"
pack_static_lib "$STATIC_LIB_DBG_FILE"

10
build_scripts/build_configurations/build_test.sh
View File

@ -1,10 +0,0 @@
#!/bin/bash
source build_scripts/init.sh
print "${CYAN}=============[build_test]=============\n"
clear_dir "$OUTDIR"
clear_dir "$OBJDIR"
compile_c "$BUILD_TEST_C_ARGS" "$SRC_C $TESTS_C"
compile_cpp "$BUILD_TEST_CPP_ARGS" "$SRC_CPP $TESTS_CPP"
link "$BUILD_TEST_CPP_ARGS $BUILD_TEST_LINKER_ARGS" $TEST_FILE

10
build_scripts/build_configurations/build_test_dbg.sh
View File

@ -1,10 +0,0 @@
#!/bin/bash
source build_scripts/init.sh
print "${CYAN}===========[build_test_dbg]===========\n"
clear_dir "$OUTDIR"
clear_dir "$OBJDIR"
compile_c "$BUILD_TEST_DBG_C_ARGS" "$SRC_C $TESTS_C"
compile_cpp "$BUILD_TEST_DBG_CPP_ARGS" "$SRC_CPP $TESTS_CPP"
link "$BUILD_TEST_DBG_CPP_ARGS $BUILD_TEST_DBG_LINKER_ARGS" $TEST_DBG_FILE

8
build_scripts/build_configurations/test.sh
View File

@ -1,8 +0,0 @@
#!/bin/bash
source build_scripts/init.sh
print "${CYAN}================[test]================\n"
cd $OUTDIR
./$TEST_FILE
cd ..

9
build_scripts/build_configurations/test_valgrind.sh
View File

@ -1,9 +0,0 @@
#!/bin/bash
source build_scripts/init.sh
print "${CYAN}===========[test_valgrind]============\n"
cd $OUTDIR
valgrind $VALGRIND_ARGS ./$TEST_DBG_FILE
cat "valgrind.log"
cd ..

11
build_scripts/colors.sh
View File

@ -1,11 +0,0 @@
#!/bin/bash
BLACK='\033[0;30m'
GRAY='\033[0;37m'
WHITE='\033[0;97m'
RED='\033[0;91m'
GREEN='\033[0;92m'
YELLOW='\033[0;93m'
BLUE='\033[0;94m'
PURPLE='\033[0;95m'
CYAN='\033[0;96m'

43
build_scripts/default.config.sh
View File

@ -1,43 +0,0 @@
#!/bin/bash
OUTDIR=bin
OBJDIR=obj
CMP_C=gcc
CMP_CPP=g++
STD_C=c11
STD_CPP=c++17
WARN_C="-Wall -Wno-discarded-qualifiers"
WARN_CPP="-Wall"
SRC_C="$( find src -name '*.c')"
SRC_CPP="$( find src -name '*.cpp')"
TESTS_C="$( find tests -name '*.c')"
TESTS_CPP="$(find tests -name '*.cpp')"
VALGRIND_ARGS="-s --log-file=valgrind.log --read-var-info=yes --track-origins=yes --fullpath-after=kerep/ --leak-check=full --show-leak-kinds=all"
# build_test
TEST_FILE=kerep.com
BUILD_TEST_C_ARGS="-O2"
BUILD_TEST_CPP_ARGS="$BUILD_TEST_C_ARGS"
BUILD_TEST_LINKER_ARGS=""
# build_test_dbg
TEST_DBG_FILE=$TEST_FILE.dbg
BUILD_TEST_DBG_C_ARGS="-O0 -g"
BUILD_TEST_DBG_CPP_ARGS="$BUILD_TEST_DBG_C_ARGS"
BUILD_TEST_DBG_LINKER_ARGS=""
# build_shared_lib
SHARED_LIB_FILE=kerep.so
BUILD_SHARED_LIB_C_ARGS="-O2 -fpic -flto -shared"
BUILD_SHARED_LIB_CPP_ARGS="$BUILD_SHARED_LIB_C_ARGS"
BUILD_SHARED_LIB_LINKER_ARGS="-Wl,-soname,$SHARED_LIB_FILE"
# build_static_lib
STATIC_LIB_FILE=kerep.a
BUILD_STATIC_LIB_C_ARGS="-O2 -fpic"
BUILD_STATIC_LIB_CPP_ARGS="$BUILD_STATIC_LIB_C_ARGS"
# build_static_lib_dbg
STATIC_LIB_DBG_FILE="$STATIC_LIB_FILE"
BUILD_STATIC_LIB_DBG_C_ARGS="-O0 -g"
BUILD_STATIC_LIB_DBG_CPP_ARGS="$BUILD_STATIC_LIB_DBG_C_ARGS"

89
build_scripts/functions.sh
View File

@ -1,89 +0,0 @@
#!/bin/bash
function print {
printf "$1$GRAY"
}
function clear_dir {
print "${BLUE}clearing $1\n"
rm -rf $1
mkdir $1
}
function compile {
local cmp=$1
print "${BLUE}compiler: ${GRAY}$cmp\n"
local std=$2
print "${BLUE}standard: ${GRAY}$std\n"
local warn=$3
print "${BLUE}warnings: ${GRAY}$warn\n"
local args=$4
print "${BLUE}args: ${GRAY}$args\n"
local sources=$5
print "${BLUE}sources: ${GRAY}$sources\n"
local compilation_error=0
for srcfile in $sources
do (
local object="$OBJDIR/$(basename $srcfile).o"
if ! $($cmp -std=$std $warn $args -c -o $object $srcfile)
then
print "${RED}some error happened\n"
compilation_error=1
fi
) & done
wait
if [ $compilation_error != 0 ]
then
exit 1
fi
}
# (args, sources)
function compile_c {
print "${CYAN}-------------[compile_c]--------------\n"
compile $CMP_C $STD_C "$WARN_C" "$1" "$2"
}
# (args, sources)
function compile_cpp {
print "${CYAN}------------[compile_cpp]-------------\n"
compile $CMP_CPP $STD_CPP "$WARN_CPP" "$1" "$2"
}
# (args, outfile)
function link {
print "${CYAN}----------------[link]----------------\n"
local args=$1
print "${BLUE}args: ${GRAY}$args\n"
local outfile=$OUTDIR/$2
print "${BLUE}outfile: ${GRAY}$outfile\n"
local objects="$(find $OBJDIR -name *.o)"
print "${BLUE}objects: ${GRAY}$objects\n"
if $CMP_CPP $args -o $outfile $(echo $objects | tr '\n' ' ')
then
print "${GREEN}file $CYAN$outfile ${GREEN}created\n"
rm -rf $OBJDIR
else
print "${RED}some error happened\n"
exit 1
fi
}
# (outfile)
function pack_static_lib {
print "${CYAN}----------------[link]----------------\n"
local outfile=$OUTDIR/$1
print "${BLUE}outfile: ${GRAY}$outfile\n"
local objects="$(find $OBJDIR -name *.o)"
print "${BLUE}objects: ${GRAY}$objects\n"
if ar rcs $outfile $(echo $objects | tr '\n' ' ')
then
print "${GREEN}file $CYAN$outfile ${GREEN}created\n"
rm -rf $OBJDIR
else
print "${RED}some error happened\n"
exit 1
fi
}

22
build_scripts/init.sh
View File

@ -1,22 +0,0 @@
#!/bin/bash
tabs 4
source build_scripts/colors.sh
source build_scripts/functions.sh
if [ ! -f ".config" ]; then
print "${YELLOW}./.config doesn't exists\n"
cp build_scripts/default.config.sh .config
print "${YELLOW}default config created\n"
while true; do
print "${WHITE}continue? (y/n) "
read answ
case $answ in
[Yy] ) break;;
[Nn] ) exit;;
* ) print "${RED}incorrect answer\n";;
esac
done
fi
source .config

1
cbuild Submodule

@ -0,0 +1 @@
Subproject commit ff04da5c198cea82a7948eb882e3cc96c7b5686c

52
src/Autoarr/Autoarr.c
View File

@ -13,35 +13,35 @@ Autoarr_define(int32)
Autoarr_define(uint64) Autoarr_define(uint64)
Autoarr_define(int64) Autoarr_define(int64)
kerepTypeId_define(kerepTypeId_AutoarrChar); ktId_define(ktId_AutoarrChar);
kerepTypeId_define(kerepTypeId_AutoarrBool); ktId_define(ktId_AutoarrBool);
kerepTypeId_define(kerepTypeId_AutoarrFloat32); ktId_define(ktId_AutoarrFloat32);
kerepTypeId_define(kerepTypeId_AutoarrFloat64); ktId_define(ktId_AutoarrFloat64);
kerepTypeId_define(kerepTypeId_AutoarrInt8); ktId_define(ktId_AutoarrInt8);
kerepTypeId_define(kerepTypeId_AutoarrUInt8); ktId_define(ktId_AutoarrUInt8);
kerepTypeId_define(kerepTypeId_AutoarrInt16); ktId_define(ktId_AutoarrInt16);
kerepTypeId_define(kerepTypeId_AutoarrUInt16); ktId_define(ktId_AutoarrUInt16);
kerepTypeId_define(kerepTypeId_AutoarrInt32); ktId_define(ktId_AutoarrInt32);
kerepTypeId_define(kerepTypeId_AutoarrUInt32); ktId_define(ktId_AutoarrUInt32);
kerepTypeId_define(kerepTypeId_AutoarrInt64); ktId_define(ktId_AutoarrInt64);
kerepTypeId_define(kerepTypeId_AutoarrUInt64); ktId_define(ktId_AutoarrUInt64);
kerepTypeId_define(kerepTypeId_AutoarrCharPtr); ktId_define(ktId_AutoarrCharPtr);
kerepTypeId_define(kerepTypeId_AutoarrBoolPtr); ktId_define(ktId_AutoarrBoolPtr);
kerepTypeId_define(kerepTypeId_AutoarrFloat32Ptr); ktId_define(ktId_AutoarrFloat32Ptr);
kerepTypeId_define(kerepTypeId_AutoarrFloat64Ptr); ktId_define(ktId_AutoarrFloat64Ptr);
kerepTypeId_define(kerepTypeId_AutoarrInt8Ptr); ktId_define(ktId_AutoarrInt8Ptr);
kerepTypeId_define(kerepTypeId_AutoarrUInt8Ptr); ktId_define(ktId_AutoarrUInt8Ptr);
kerepTypeId_define(kerepTypeId_AutoarrInt16Ptr); ktId_define(ktId_AutoarrInt16Ptr);
kerepTypeId_define(kerepTypeId_AutoarrUInt16Ptr); ktId_define(ktId_AutoarrUInt16Ptr);
kerepTypeId_define(kerepTypeId_AutoarrInt32Ptr); ktId_define(ktId_AutoarrInt32Ptr);
kerepTypeId_define(kerepTypeId_AutoarrUInt32Ptr); ktId_define(ktId_AutoarrUInt32Ptr);
kerepTypeId_define(kerepTypeId_AutoarrInt64Ptr); ktId_define(ktId_AutoarrInt64Ptr);
kerepTypeId_define(kerepTypeId_AutoarrUInt64Ptr); ktId_define(ktId_AutoarrUInt64Ptr);
Autoarr_define(Unitype) Autoarr_define(Unitype)
kerepTypeId_define(kerepTypeId_AutoarrUnitype); ktId_define(ktId_AutoarrUnitype);
kerepTypeId_define(kerepTypeId_AutoarrUnitypePtr); ktId_define(ktId_AutoarrUnitypePtr);
// right func to clear array of unitype values // right func to clear array of unitype values
void __Autoarr_free_Unitype_(Autoarr(Unitype)* ar, bool freePtr){ void __Autoarr_free_Unitype_(Autoarr(Unitype)* ar, bool freePtr){

52
src/Autoarr/Autoarr.h
View File

@ -20,35 +20,35 @@ Autoarr_declare(uint32)
Autoarr_declare(int64) Autoarr_declare(int64)
Autoarr_declare(uint64) Autoarr_declare(uint64)
kerepTypeId_declare(kerepTypeId_AutoarrChar); ktId_declare(ktId_AutoarrChar);
kerepTypeId_declare(kerepTypeId_AutoarrBool); ktId_declare(ktId_AutoarrBool);
kerepTypeId_declare(kerepTypeId_AutoarrFloat32); ktId_declare(ktId_AutoarrFloat32);
kerepTypeId_declare(kerepTypeId_AutoarrFloat64); ktId_declare(ktId_AutoarrFloat64);
kerepTypeId_declare(kerepTypeId_AutoarrInt8); ktId_declare(ktId_AutoarrInt8);
kerepTypeId_declare(kerepTypeId_AutoarrUInt8); ktId_declare(ktId_AutoarrUInt8);
kerepTypeId_declare(kerepTypeId_AutoarrInt16); ktId_declare(ktId_AutoarrInt16);
kerepTypeId_declare(kerepTypeId_AutoarrUInt16); ktId_declare(ktId_AutoarrUInt16);
kerepTypeId_declare(kerepTypeId_AutoarrInt32); ktId_declare(ktId_AutoarrInt32);
kerepTypeId_declare(kerepTypeId_AutoarrUInt32); ktId_declare(ktId_AutoarrUInt32);
kerepTypeId_declare(kerepTypeId_AutoarrInt64); ktId_declare(ktId_AutoarrInt64);
kerepTypeId_declare(kerepTypeId_AutoarrUInt64); ktId_declare(ktId_AutoarrUInt64);
kerepTypeId_declare(kerepTypeId_AutoarrCharPtr); ktId_declare(ktId_AutoarrCharPtr);
kerepTypeId_declare(kerepTypeId_AutoarrBoolPtr); ktId_declare(ktId_AutoarrBoolPtr);
kerepTypeId_declare(kerepTypeId_AutoarrFloat32Ptr); ktId_declare(ktId_AutoarrFloat32Ptr);
kerepTypeId_declare(kerepTypeId_AutoarrFloat64Ptr); ktId_declare(ktId_AutoarrFloat64Ptr);
kerepTypeId_declare(kerepTypeId_AutoarrInt8Ptr); ktId_declare(ktId_AutoarrInt8Ptr);
kerepTypeId_declare(kerepTypeId_AutoarrUInt8Ptr); ktId_declare(ktId_AutoarrUInt8Ptr);
kerepTypeId_declare(kerepTypeId_AutoarrInt16Ptr); ktId_declare(ktId_AutoarrInt16Ptr);
kerepTypeId_declare(kerepTypeId_AutoarrUInt16Ptr); ktId_declare(ktId_AutoarrUInt16Ptr);
kerepTypeId_declare(kerepTypeId_AutoarrInt32Ptr); ktId_declare(ktId_AutoarrInt32Ptr);
kerepTypeId_declare(kerepTypeId_AutoarrUInt32Ptr); ktId_declare(ktId_AutoarrUInt32Ptr);
kerepTypeId_declare(kerepTypeId_AutoarrInt64Ptr); ktId_declare(ktId_AutoarrInt64Ptr);
kerepTypeId_declare(kerepTypeId_AutoarrUInt64Ptr); ktId_declare(ktId_AutoarrUInt64Ptr);
Autoarr_declare(Unitype) Autoarr_declare(Unitype)
kerepTypeId_declare(kerepTypeId_AutoarrUnitype); ktId_declare(ktId_AutoarrUnitype);
kerepTypeId_declare(kerepTypeId_AutoarrUnitypePtr); ktId_declare(ktId_AutoarrUnitypePtr);
// this function is injected in kerep_init() // this function is injected in kerep_init()
void __Autoarr_free_Unitype_(Autoarr(Unitype)* ar, bool freePtr); void __Autoarr_free_Unitype_(Autoarr(Unitype)* ar, bool freePtr);

24
src/DtsodParser/DtsodV24_deserialize.c
View File

@ -98,9 +98,9 @@ Maybe __ReadName(DeserializeSharedData* shared){
case '}': case '}':
if(!calledRecursively || nameStr.length!=0) if(!calledRecursively || nameStr.length!=0)
safethrow_wrongchar(c,;); safethrow_wrongchar(c,;);
return SUCCESS(UniPtrHeap(kerepTypeId_CharPtr,NULL)); return SUCCESS(UniHeap(ktId_CharPtr,NULL));
case ':': case ':':
return SUCCESS(UniPtrHeap(kerepTypeId_CharPtr,string_extract(nameStr))); return SUCCESS(UniHeap(ktId_CharPtr,string_extract(nameStr)));
case '$': case '$':
if(nameStr.length!=0) if(nameStr.length!=0)
safethrow_wrongchar(c,;); safethrow_wrongchar(c,;);
@ -113,7 +113,7 @@ Maybe __ReadName(DeserializeSharedData* shared){
} }
if(nameStr.length>0) safethrow(ERR_ENDOFSTR,;); if(nameStr.length>0) safethrow(ERR_ENDOFSTR,;);
return SUCCESS(UniPtrHeap(kerepTypeId_CharPtr,NULL)); return SUCCESS(UniHeap(ktId_CharPtr,NULL));
} }
#define ReadName() __ReadName(shared) #define ReadName() __ReadName(shared)
@ -137,7 +137,7 @@ Maybe __ReadString(DeserializeSharedData* shared){
} }
else { else {
char* str=StringBuilder_build(b).ptr; char* str=StringBuilder_build(b).ptr;
return SUCCESS(UniPtrHeap(kerepTypeId_CharPtr,str)); return SUCCESS(UniHeap(ktId_CharPtr,str));
} }
} }
else { else {
@ -157,13 +157,13 @@ Maybe __ReadList(DeserializeSharedData* shared){
try(ReadValue((&readingList)), val, Autoarr_free(list, true)) try(ReadValue((&readingList)), val, Autoarr_free(list, true))
Autoarr_add(list,val.value); Autoarr_add(list,val.value);
if (!readingList){ if (!readingList){
if(val.value.typeId==kerepTypeId_Null) if(val.value.typeId==ktId_Null)
Autoarr_pop(list); Autoarr_pop(list);
break; break;
} }
} }
return SUCCESS(UniPtrHeap(kerepTypeId_AutoarrUnitypePtr,list)); return SUCCESS(UniHeap(ktId_AutoarrUnitypePtr,list));
}; };
#define ReadList() __ReadList(shared) #define ReadList() __ReadList(shared)
@ -182,7 +182,7 @@ Maybe __ParseValue(DeserializeSharedData* shared, string str){
// Float64 // Float64
case 'f': { case 'f': {
char* _c=string_extract(str); char* _c=string_extract(str);
Unitype rez=Uni(Float64,strtod(_c,NULL)); Unitype rez=UniFloat64(strtod(_c,NULL));
free(_c); free(_c);
return SUCCESS(rez); return SUCCESS(rez);
} }
@ -199,7 +199,7 @@ Maybe __ParseValue(DeserializeSharedData* shared, string str){
safethrow(err,free(_c)); safethrow(err,free(_c));
} }
free(_c); free(_c);
return SUCCESS(Uni(UInt64,lu)); return SUCCESS(UniUInt64(lu));
} }
// Int64 // Int64
case '0': case '1': case '2': case '3': case '4': case '0': case '1': case '2': case '3': case '4':
@ -215,7 +215,7 @@ Maybe __ParseValue(DeserializeSharedData* shared, string str){
safethrow(err,free(_c)); safethrow(err,free(_c));
} }
free(_c); free(_c);
return SUCCESS(Uni(Int64,li)); return SUCCESS(UniInt64(li));
} }
// wrong type // wrong type
default: default:
@ -275,7 +275,7 @@ Maybe __ReadValue(DeserializeSharedData* shared, bool* readingList){
case ';': case ';':
case ',': case ',':
if(valueStr.length!=0){ if(valueStr.length!=0){
if(value.typeId!=kerepTypeId_Null) if(value.typeId!=ktId_Null)
safethrow_wrongchar(c,Unitype_free(value)); safethrow_wrongchar(c,Unitype_free(value));
try(ParseValue(valueStr),maybeParsed,;) try(ParseValue(valueStr),maybeParsed,;)
value=maybeParsed.value; value=maybeParsed.value;
@ -321,7 +321,7 @@ Maybe __deserialize(char** _text, bool _calledRecursively) {
} }
else{ else{
list=Autoarr_create(Unitype,ARR_BC,ARR_BL); list=Autoarr_create(Unitype,ARR_BC,ARR_BL);
Hashtable_add(dict,nameCPtr,UniPtrHeap(kerepTypeId_AutoarrUnitypePtr,list)); Hashtable_add(dict,nameCPtr,UniHeap(ktId_AutoarrUnitypePtr,list));
} }
Autoarr_add(list,val.value); Autoarr_add(list,val.value);
} }
@ -331,7 +331,7 @@ Maybe __deserialize(char** _text, bool _calledRecursively) {
END: END:
*_text=text; *_text=text;
return SUCCESS(UniPtrHeap(kerepTypeId_HashtablePtr,dict)); return SUCCESS(UniHeap(ktId_HashtablePtr,dict));
} }
Maybe DtsodV24_deserialize(char* _text) { Maybe DtsodV24_deserialize(char* _text) {

18
src/DtsodParser/DtsodV24_serialize.c
View File

@ -23,18 +23,18 @@ void __AppendTabs(SerializeSharedData* shared) {
Maybe __AppendValue(SerializeSharedData* shared, Unitype u); Maybe __AppendValue(SerializeSharedData* shared, Unitype u);
#define AppendValue(UNI) __AppendValue(shared, UNI) #define AppendValue(UNI) __AppendValue(shared, UNI)
Maybe __AppendValue(SerializeSharedData* shared, Unitype u){ Maybe __AppendValue(SerializeSharedData* shared, Unitype u){
if(u.typeId==kerepTypeId_Int64){ if(u.typeId==ktId_Int64){
StringBuilder_append_int64(b,u.Int64); StringBuilder_append_int64(b,u.Int64);
} }
else if(u.typeId==kerepTypeId_UInt64){ else if(u.typeId==ktId_UInt64){
StringBuilder_append_uint64(b,u.UInt64); StringBuilder_append_uint64(b,u.UInt64);
addc('u'); addc('u');
} }
else if(u.typeId==kerepTypeId_Float64){ else if(u.typeId==ktId_Float64){
StringBuilder_append_float64(b,u.Float64); StringBuilder_append_float64(b,u.Float64);
addc('f'); addc('f');
} }
else if(u.typeId==kerepTypeId_CharPtr){ else if(u.typeId==ktId_CharPtr){
addc('"'); addc('"');
char c; char c;
while((c=*(char*)(u.VoidPtr++))){ while((c=*(char*)(u.VoidPtr++))){
@ -43,13 +43,13 @@ Maybe __AppendValue(SerializeSharedData* shared, Unitype u){
} }
addc('"'); addc('"');
} }
else if(u.typeId==kerepTypeId_Bool){ else if(u.typeId==ktId_Bool){
StringBuilder_append_cptr(b, u.Bool ? "true" : "false"); StringBuilder_append_cptr(b, u.Bool ? "true" : "false");
} }
else if(u.typeId==kerepTypeId_Null){ else if(u.typeId==ktId_Null){
safethrow("Null isn't supported in DtsodV24",;); safethrow("Null isn't supported in DtsodV24",;);
} }
else if(u.typeId==kerepTypeId_AutoarrUnitypePtr){ else if(u.typeId==ktId_AutoarrUnitypePtr){
if(Autoarr_length(((Autoarr_Unitype*)(u.VoidPtr)))){ if(Autoarr_length(((Autoarr_Unitype*)(u.VoidPtr)))){
addc('\n'); addc('\n');
AppendTabs(); AppendTabs();
@ -72,7 +72,7 @@ Maybe __AppendValue(SerializeSharedData* shared, Unitype u){
addc(']'); addc(']');
} }
} }
else if(u.typeId==kerepTypeId_HashtablePtr){ else if(u.typeId==ktId_HashtablePtr){
// check hashtable is blank // check hashtable is blank
bool hashtableNotBlank=false; bool hashtableNotBlank=false;
Hashtable_foreach(((Hashtable*)u.VoidPtr), __, ({ Hashtable_foreach(((Hashtable*)u.VoidPtr), __, ({
@ -126,5 +126,5 @@ Maybe DtsodV24_serialize(Hashtable* dtsod){
StringBuilder* sb=StringBuilder_create(); StringBuilder* sb=StringBuilder_create();
try(__serialize(sb,0,dtsod),__, StringBuilder_free(sb)); try(__serialize(sb,0,dtsod),__, StringBuilder_free(sb));
char* str=StringBuilder_build(sb).ptr; char* str=StringBuilder_build(sb).ptr;
return SUCCESS(UniPtrHeap(kerepTypeId_CharPtr, str)); return SUCCESS(UniHeap(ktId_CharPtr, str));
} }

6
src/Hashtable/Hashtable.c
View File

@ -1,7 +1,7 @@
#include "Hashtable.h" #include "Hashtable.h"
kerepTypeId_define(kerepTypeId_Hashtable); ktId_define(ktId_Hashtable);
kerepTypeId_define(kerepTypeId_HashtablePtr); ktId_define(ktId_HashtablePtr);
// amount of rows // amount of rows
static const uint16 HT_HEIGHTS[]={17,61,257,1021,4099,16381,65521}; static const uint16 HT_HEIGHTS[]={17,61,257,1021,4099,16381,65521};
@ -96,7 +96,7 @@ Unitype Hashtable_get(Hashtable* ht, char* key){
bool Hashtable_try_get(Hashtable* ht, char* key, Unitype* output){ bool Hashtable_try_get(Hashtable* ht, char* key, Unitype* output){
Unitype u=Hashtable_get(ht,key); Unitype u=Hashtable_get(ht,key);
*output=u; *output=u;
return u.typeId!=kerepTypeId_Null; return u.typeId!=ktId_Null;
} }
void Hashtable_addOrSet(Hashtable* ht, char* key, Unitype u){ void Hashtable_addOrSet(Hashtable* ht, char* key, Unitype u){

4
src/Hashtable/Hashtable.h
View File

@ -11,8 +11,8 @@ typedef struct Hashtable{
uint8 hein; // height=HT_HEIGHTS[hein] uint8 hein; // height=HT_HEIGHTS[hein]
Autoarr(KVPair)** rows; // Autoarr[height] Autoarr(KVPair)** rows; // Autoarr[height]
} Hashtable; } Hashtable;
kerepTypeId_declare(kerepTypeId_Hashtable); ktId_declare(ktId_Hashtable);
kerepTypeId_declare(kerepTypeId_HashtablePtr); ktId_declare(ktId_HashtablePtr);
Hashtable* Hashtable_create(); Hashtable* Hashtable_create();
void Hashtable_free(Hashtable* ht); void Hashtable_free(Hashtable* ht);

8
src/Hashtable/KeyValuePair.c
View File

@ -1,11 +1,11 @@
#include "KeyValuePair.h" #include "KeyValuePair.h"
kerepTypeId_define(kerepTypeId_KVPair); ktId_define(ktId_KVPair);
kerepTypeId_define(kerepTypeId_KVPairPtr); ktId_define(ktId_KVPairPtr);
Autoarr_define(KVPair) Autoarr_define(KVPair)
kerepTypeId_define(kerepTypeId_AutoarrKVPair); ktId_define(ktId_AutoarrKVPair);
kerepTypeId_define(kerepTypeId_AutoarrKVPairPtr); ktId_define(ktId_AutoarrKVPairPtr);
// proper way to clear a KVP // proper way to clear a KVP
void KVPair_free(KVPair p){ void KVPair_free(KVPair p){

8
src/Hashtable/KeyValuePair.h
View File

@ -11,12 +11,12 @@ typedef struct KVPair{
char* key; char* key;
Unitype value; Unitype value;
} KVPair; } KVPair;
kerepTypeId_declare(kerepTypeId_KVPair); ktId_declare(ktId_KVPair);
kerepTypeId_declare(kerepTypeId_KVPairPtr); ktId_declare(ktId_KVPairPtr);
Autoarr_declare(KVPair) Autoarr_declare(KVPair)
kerepTypeId_declare(kerepTypeId_AutoarrKVPair); ktId_declare(ktId_AutoarrKVPair);
kerepTypeId_declare(kerepTypeId_AutoarrKVPairPtr); ktId_declare(ktId_AutoarrKVPairPtr);
// proper way to clear a KVP // proper way to clear a KVP
void KVPair_free(KVPair p); void KVPair_free(KVPair p);

6
src/SearchTree/SearchTree.c
View File

@ -1,12 +1,12 @@
#include "SearchTree.h" #include "SearchTree.h"
kerepTypeId_define(kerepTypeId_STNode); ktId_define(ktId_STNode);
kerepTypeId_define(kerepTypeId_STNodePtr); ktId_define(ktId_STNodePtr);
STNode* STNode_create(){ STNode* STNode_create(){
STNode* node=malloc(sizeof(STNode)); STNode* node=malloc(sizeof(STNode));
node->branches=NULL; node->branches=NULL;
node->value.typeId=kerepTypeId_Null; node->value.typeId=ktId_Null;
node->value.UInt64=0; node->value.UInt64=0;
return node; return node;
} }

4
src/SearchTree/SearchTree.h
View File

@ -11,8 +11,8 @@ typedef struct SearchTreeNode{
struct SearchTreeNode**** branches; // *STNode[8][8][4] struct SearchTreeNode**** branches; // *STNode[8][8][4]
Unitype value; Unitype value;
} STNode; } STNode;
kerepTypeId_declare(kerepTypeId_STNode); ktId_declare(ktId_STNode);
kerepTypeId_declare(kerepTypeId_STNodePtr); ktId_declare(ktId_STNodePtr);
STNode* STNode_create(); STNode* STNode_create();
void STNode_free(STNode* node); void STNode_free(STNode* node);

8
src/String/StringBuilder.c
View File

@ -1,11 +1,11 @@
#include "StringBuilder.h" #include "StringBuilder.h"
Autoarr_define(string) Autoarr_define(string)
kerepTypeId_define(kerepTypeId_AutoarrString); ktId_define(ktId_AutoarrString);
kerepTypeId_define(kerepTypeId_AutoarrStringPtr); ktId_define(ktId_AutoarrStringPtr);
kerepTypeId_define(kerepTypeId_StringBuilder); ktId_define(ktId_StringBuilder);
kerepTypeId_define(kerepTypeId_StringBuilderPtr); ktId_define(ktId_StringBuilderPtr);
#define BL_C 32 #define BL_C 32
#define BL_L 1024 #define BL_L 1024

8
src/String/StringBuilder.h
View File

@ -8,15 +8,15 @@ extern "C" {
#include "string.h" #include "string.h"
Autoarr_declare(string) Autoarr_declare(string)
kerepTypeId_declare(kerepTypeId_AutoarrString); ktId_declare(ktId_AutoarrString);
kerepTypeId_declare(kerepTypeId_AutoarrStringPtr); ktId_declare(ktId_AutoarrStringPtr);
typedef struct StringBuilder{ typedef struct StringBuilder{
Autoarr(string)* compl_bufs; Autoarr(string)* compl_bufs;
Autoarr(int8)* curr_buf; Autoarr(int8)* curr_buf;
} StringBuilder; } StringBuilder;
kerepTypeId_declare(kerepTypeId_StringBuilder); ktId_declare(ktId_StringBuilder);
kerepTypeId_declare(kerepTypeId_StringBuilderPtr); ktId_declare(ktId_StringBuilderPtr);
StringBuilder* StringBuilder_create(void); StringBuilder* StringBuilder_create(void);
void StringBuilder_free(StringBuilder* b); void StringBuilder_free(StringBuilder* b);

3
src/String/string.c
View File

@ -1,5 +1,8 @@
#include "string.h" #include "string.h"
ktId_define(ktId_string);
ktId_define(ktId_stringPtr);
// copies str content to new char pointer value (adding '\0' at the end) // copies str content to new char pointer value (adding '\0' at the end)
char* string_extract(string str){ char* string_extract(string str){
if(str.length==0) return NULL; if(str.length==0) return NULL;

2
src/String/string.h
View File

@ -12,6 +12,8 @@ typedef struct string{
char* ptr; // char pointer char* ptr; // char pointer
uint32 length; // amount of chars in ptr value uint32 length; // amount of chars in ptr value
} string; } string;
ktId_declare(ktId_string);
ktId_declare(ktId_stringPtr);
static const string stringNull={NULL,0}; static const string stringNull={NULL,0};

5
src/base/base.h
View File

@ -8,9 +8,8 @@ extern "C" {
#include "errors.h" #include "errors.h"
#include "cptr.h" #include "cptr.h"
#include "optime.h" #include "optime.h"
#include "types.h" #include "type_system/type_system.h"
#include "unitype.h" #include "kprint/kprint.h"
#include "init.h"
#if __cplusplus #if __cplusplus
} }

13
src/base/cptr.c
View File

@ -34,3 +34,16 @@ char* char_multiply(char c, uint32 n){
rez[n]=c; rez[n]=c;
return rez; return rez;
} }
bool cptr_startsWith(char* ptr, char* fragment){
for(char cs=*ptr, cf=*fragment; cf; cs=*++ptr, cf=*++fragment)
if(cs!=cf) return false;
return true;
}
bool cptr_endsWith(char* ptr, char* fragment){
ptr+=cptr_length(ptr)-cptr_length(fragment);
for(char cs=*ptr, cf=*fragment; cf; cs=*++ptr, cf=*++fragment)
if(cs!=cf) return false;
return true;
}

6
src/base/cptr.h
View File

@ -4,7 +4,7 @@
extern "C" { extern "C" {
#endif #endif
#include "types.h" #include "std.h"
// returns length of char buffer (without \0) // returns length of char buffer (without \0)
uint32 cptr_length(char* str); uint32 cptr_length(char* str);
@ -18,6 +18,10 @@ bool cptr_compare(char* key0, char* key1);
// multiplies char n times // multiplies char n times
char* char_multiply(char c, uint32 n); char* char_multiply(char c, uint32 n);
bool cptr_startsWith(char* ptr, char* fragment);
bool cptr_endsWith(char* ptr, char* fragment);
#if __cplusplus #if __cplusplus
} }
#endif #endif

6
src/base/errors.h
View File

@ -5,7 +5,7 @@ extern "C" {
#endif #endif
#include "std.h" #include "std.h"
#include "unitype.h" #include "type_system/unitype.h"
typedef enum ErrorId { typedef enum ErrorId {
SUCCESS, // not an error SUCCESS, // not an error
@ -59,12 +59,12 @@ char* __unknownErr( );
freeMem;\ freeMem;\
_rezult.errmsg=__extendErrMsg(_rezult.errmsg, __FILE__,__LINE__,__func__);\ _rezult.errmsg=__extendErrMsg(_rezult.errmsg, __FILE__,__LINE__,__func__);\
return _rezult;\ return _rezult;\
}else }
#define tryLast(_funcCall, _rezult) Maybe _rezult=_funcCall; if(_rezult.errmsg){\ #define tryLast(_funcCall, _rezult) Maybe _rezult=_funcCall; if(_rezult.errmsg){\
_rezult.errmsg=__extendErrMsg(_rezult.errmsg, __FILE__,__LINE__,__func__);\ _rezult.errmsg=__extendErrMsg(_rezult.errmsg, __FILE__,__LINE__,__func__);\
__EXIT(_rezult.errmsg);\ __EXIT(_rezult.errmsg);\
}else }
#endif #endif

97
src/base/init.c
View File

@ -1,97 +0,0 @@
#include "base.h"
#include "../Autoarr/Autoarr.h"
#include "../SearchTree/SearchTree.h"
#include "../Hashtable/Hashtable.h"
#include "../String/StringBuilder.h"
void kerepTypeDescriptors_initKerepTypes(){
// null
kerepType_register(NULL, kerepTypeId_Null, NULL);
// base types
kerepType_register(char, kerepTypeId_Char, NULL);
kerepType_register(bool, kerepTypeId_Bool, NULL);
kerepType_register(float32, kerepTypeId_Float32, NULL);
kerepType_register(float64, kerepTypeId_Float64, NULL);
kerepType_register(int8, kerepTypeId_Int8, NULL);
kerepType_register(uint8, kerepTypeId_UInt8, NULL);
kerepType_register(int16, kerepTypeId_Int16, NULL);
kerepType_register(uint16, kerepTypeId_UInt16, NULL);
kerepType_register(int32, kerepTypeId_Int32, NULL);
kerepType_register(uint32, kerepTypeId_UInt32, NULL);
kerepType_register(int64, kerepTypeId_Int64, NULL);
kerepType_register(uint64, kerepTypeId_UInt64, NULL);
// base type pointers
kerepType_register(char*, kerepTypeId_CharPtr, NULL);
kerepType_register(bool*, kerepTypeId_BoolPtr, NULL);
kerepType_register(float32*, kerepTypeId_Float32Ptr, NULL);
kerepType_register(float64*, kerepTypeId_Float64Ptr, NULL);
kerepType_register(int8*, kerepTypeId_Int8Ptr, NULL);
kerepType_register(uint8*, kerepTypeId_UInt8Ptr, NULL);
kerepType_register(int16*, kerepTypeId_Int16Ptr, NULL);
kerepType_register(uint16*, kerepTypeId_UInt16Ptr, NULL);
kerepType_register(int32*, kerepTypeId_Int32Ptr, NULL);
kerepType_register(uint32*, kerepTypeId_UInt32Ptr, NULL);
kerepType_register(int64*, kerepTypeId_Int64Ptr, NULL);
kerepType_register(uint64*, kerepTypeId_UInt64Ptr, NULL);
// base type autoarrs
kerepType_register(Autoarr_char, kerepTypeId_AutoarrChar, ____Autoarr_free_char);
kerepType_register(Autoarr_bool, kerepTypeId_AutoarrBool, ____Autoarr_free_bool);
kerepType_register(Autoarr_float32, kerepTypeId_AutoarrFloat32, ____Autoarr_free_float32);
kerepType_register(Autoarr_float64, kerepTypeId_AutoarrFloat64, ____Autoarr_free_float64);
kerepType_register(Autoarr_int8, kerepTypeId_AutoarrInt8, ____Autoarr_free_int8);
kerepType_register(Autoarr_uint8, kerepTypeId_AutoarrUInt8, ____Autoarr_free_uint8);
kerepType_register(Autoarr_int16, kerepTypeId_AutoarrInt16, ____Autoarr_free_int16);
kerepType_register(Autoarr_uint16, kerepTypeId_AutoarrUInt16, ____Autoarr_free_uint16);
kerepType_register(Autoarr_int32, kerepTypeId_AutoarrInt32, ____Autoarr_free_int32);
kerepType_register(Autoarr_uint32, kerepTypeId_AutoarrUInt32, ____Autoarr_free_uint32);
kerepType_register(Autoarr_int64, kerepTypeId_AutoarrInt64, ____Autoarr_free_int64);
kerepType_register(Autoarr_uint64, kerepTypeId_AutoarrUInt64, ____Autoarr_free_uint64);
// base type autoarr pointers
kerepType_register(Autoarr_char*, kerepTypeId_AutoarrCharPtr, ____Autoarr_free_char);
kerepType_register(Autoarr_bool*, kerepTypeId_AutoarrBoolPtr, ____Autoarr_free_bool);
kerepType_register(Autoarr_float32*, kerepTypeId_AutoarrFloat32Ptr, ____Autoarr_free_float32);
kerepType_register(Autoarr_float64*, kerepTypeId_AutoarrFloat64Ptr, ____Autoarr_free_float64);
kerepType_register(Autoarr_int8*, kerepTypeId_AutoarrInt8Ptr, ____Autoarr_free_int8);
kerepType_register(Autoarr_uint8*, kerepTypeId_AutoarrUInt8Ptr, ____Autoarr_free_uint8);
kerepType_register(Autoarr_int16*, kerepTypeId_AutoarrInt16Ptr, ____Autoarr_free_int16);
kerepType_register(Autoarr_uint16*, kerepTypeId_AutoarrUInt16Ptr, ____Autoarr_free_uint16);
kerepType_register(Autoarr_int32*, kerepTypeId_AutoarrInt32Ptr, ____Autoarr_free_int32);
kerepType_register(Autoarr_uint32*, kerepTypeId_AutoarrUInt32Ptr, ____Autoarr_free_uint32);
kerepType_register(Autoarr_int64*, kerepTypeId_AutoarrInt64Ptr, ____Autoarr_free_int64);
kerepType_register(Autoarr_uint64*, kerepTypeId_AutoarrUInt64Ptr, ____Autoarr_free_uint64);
// Unitype
kerepType_register(Unitype, kerepTypeId_Unitype, __UnitypePtr_free);
kerepType_register(Unitype*, kerepTypeId_UnitypePtr, __UnitypePtr_free);
kerepType_register(Autoarr_Unitype, kerepTypeId_AutoarrUnitype, ____Autoarr_free_Unitype_);
kerepType_register(Autoarr_Unitype*, kerepTypeId_AutoarrUnitypePtr, ____Autoarr_free_Unitype_);
// replacing autogenerated freear() function to custom
Autoarr_Unitype* _uar=Autoarr_create(Unitype, 1, 1);
_uar->functions->freear=__Autoarr_free_Unitype_;
Autoarr_free(_uar, true);
// SearchTreeNode
kerepType_register(STNode, kerepTypeId_STNode, __STNode_free);
kerepType_register(STNode*, kerepTypeId_STNodePtr, __STNode_free);
// KeyValuePair
kerepType_register(KVPair, kerepTypeId_KVPair, __KVPair_free);
kerepType_register(KVPair*, kerepTypeId_KVPairPtr, __KVPair_free);
kerepType_register(Autoarr_KVPair, kerepTypeId_AutoarrKVPair, ____Autoarr_free_KVPair_);
kerepType_register(Autoarr_KVPair*, kerepTypeId_AutoarrKVPairPtr, ____Autoarr_free_KVPair_);
// replacing autogenerated freear() function to custom
Autoarr_KVPair* _kvpar=Autoarr_create(KVPair, 1, 1);
_kvpar->functions->freear=__Autoarr_free_KVPair_;
Autoarr_free(_kvpar, true);
// Hashtable
kerepType_register(Hashtable, kerepTypeId_Hashtable, __Hashtable_free);
kerepType_register(Hashtable*, kerepTypeId_HashtablePtr, __Hashtable_free);
// StringBuilder
kerepType_register(Autoarr_string, kerepTypeId_AutoarrString, ____Autoarr_free_string);
kerepType_register(Autoarr_string*, kerepTypeId_AutoarrStringPtr, ____Autoarr_free_string);
kerepType_register(StringBuilder, kerepTypeId_StringBuilder, __StringBuilder_free);
kerepType_register(StringBuilder*, kerepTypeId_StringBuilderPtr, __StringBuilder_free);
}

12
src/base/init.h
View File

@ -1,12 +0,0 @@
#pragma once
#if __cplusplus
extern "C" {
#endif
// call this between kerepTypeDescriptors_beginInit() and kerepTypeDescriptors_endInit()
void kerepTypeDescriptors_initKerepTypes();
#if __cplusplus
}
#endif

33
src/base/kprint/README.md Normal file
View File

@ -0,0 +1,33 @@
# kprint
I don't really like printf function (and its variants), so i made safer and more convinient replacement.
| function | returns | arguments |
|----------|---------|-----------|
| kprint | void/throw | kprint_format, void*, kprint_format, void*... |
| ksprint | Maybe<char*> | kprint_format, void*, kprint_format, void*... |
| kfprint | Maybe<void> | FILE*, kprint_format, void*, kprint_format, void*... |
## how to use it:
+ **format construction:**
```
kprint_format fmt= kprint_fgColor | kprint_fbgColor | kprint_fdataFmt | flags | ktId;
```
[more about `kprint_format`](kprint_format.md)
+ fgColor and bgColor can be set to change console output color
+ you should set dataFormat for `int`/`uint`/`float`/`char*` arguments and ktId for other types
+ flags can be set to modify TypeDescriptor.toString() behavior
+ don't forget to set TypeDescriptor.toString when registering type, or kprint will crash
+ **using base type arguments:**
you can just put them into a function
```
kprint(kprint_fmtHex | kprint_fmtUppercase | kprint_fmtWithPrefix, 255);
```
output: 0xFF
+ **using other registered types:**
should be sent as pointers
```
Maybe m=MaybeNull;
kprint(kprint_fgBlue | kprint_fmtString, "Maybe: ", kprint_fgGreen | ktId_MaybePtr, &m);
```
output: <span style="color:blue">Maybe:</span> <span style="color:lightgreen">{value={0, ktId_Null}}</span>

87
src/base/kprint/kprint.c Normal file
View File

@ -0,0 +1,87 @@
/* #include "../base.h"
#include "../../String/StringBuilder.h"
Maybe __next_toString(kprint_format format, void* object){
// detecting type
if(!format.typeId) switch((kprint_dataFormat)((uint32)0 | format.dataFmt)){
case kprint_fmtInt:
case kprint_fmtHex:
case kprint_fmtBin:
format.typeId=ktId_Int64; break;
case kprint_fmtUInt:
format.typeId=ktId_UInt64; break;
case kprint_fmtFloat:
format.typeId=ktId_Float64; break;
case kprint_fmtChar:
format.typeId=ktId_Char; break;
case kprint_fmtString:
format.typeId=ktId_CharPtr; break;
default:
safethrow("typeId is not set, can't autodetect type",;);
}
try(ktDescriptor_get(format.typeId),mtd,;);
ktDescriptor typeDesc=*(ktDescriptor*)mtd.value.VoidPtr;
if(!typeDesc.toString)
safethrow("type descriptor doesnt have toString() func",;);
try(typeDesc.toString(object, &format), mStr,;);
return SUCCESS(mStr.value);
}
Maybe __ksprint(uint8 n, kprint_format* formats, void** objects){
StringBuilder* strb=StringBuilder_create();
for(uint8 i=0; i<n; i++){
try(__next_toString(formats[i], objects[i]),mStr,;);
StringBuilder_append_cptr(strb, mStr.value.VoidPtr);
}
char* rezult=StringBuilder_build(strb).ptr;
return SUCCESS(UniHeap(ktId_CharPtr, rezult));
}
Maybe __kfprint(FILE* file, uint8 n, kprint_format* formats, void** objects){
for(uint8 i=0; i<n; i++){
try(__next_toString(formats[i], objects[i]),maybeStr,;);
if(fputs(maybeStr.value.VoidPtr, file)==EOF)
safethrow("can't write string to file", Unitype_free(maybeStr.value));
Unitype_free(maybeStr.value);
}
return MaybeNull;
}
void __kprint(uint8 n, kprint_format* formats, void** objects){
for(uint8 i=0; i<n; i++){
kprint_format fmt=formats[i];
kprint_setColor(fmt);
tryLast(__next_toString(fmt, objects[i]),maybeStr);
if(fputs(maybeStr.value.VoidPtr, stdout)==EOF)\
throw("can't write string to stdout");
//, Unitype_free(maybeStr.value)
Unitype_free(maybeStr.value);
}
}
void kprint_setColor(kprint_format f){
if(!f.bgColorChanged | !f.fgColorChanged)
return;
}
Maybe ksprint_ar(uint32 count, kprint_format format, ktId typeId, void* array){
try(ktDescriptor_get(format.typeId),mtd,;);
ktDescriptor typeDesc=*(ktDescriptor*)mtd.value.VoidPtr;
if(!typeDesc.toString)
safethrow("type descriptor doesnt have toString() func",;);
StringBuilder* strb=StringBuilder_create();
StringBuilder_append_char(strb, '[');
for (uint16 e=1; e<count; e++){
StringBuilder_append_char(strb, ' ');
try(typeDesc.toString(array+typeDesc.size*e, &format), estr, StringBuilder_free(strb));
StringBuilder_append_cptr(strb, estr.value.VoidPtr);
StringBuilder_append_char(strb, ',');
}
StringBuilder_rmchar(strb);
StringBuilder_append_char(strb, ' ');
StringBuilder_append_char(strb, ']');
} */

78
src/base/kprint/kprint.h Normal file
View File

@ -0,0 +1,78 @@
#pragma once
#if __cplusplus
extern "C" {
#endif
#include "../errors.h"
#include "kprint_colors.h"
#include "kprint_format.h"
#define __count_args(\
a0, a1, a2, a3, a4, a5, a6, a7,\
a8, a9, a10,a11,a12,a13,a14,a15,\
a16,a17,a18,a19,a20,a21,a22,a23,\
a24,a25,a26,a27,a28,a29,a30,a31,\
a32) a32
#define count_args(ARGS...) __count_args(\
ARGS,\
32,31,30,29,28,27,26,25,\
24,23,22,21,20,19,18,17,\
16,15,14,13,12,11,10,9,\
8, 7, 6, 5, 4, 3, 2, 1, 0)
#define __kprint_argsToFormats8(\
a0, a1, a2, a3, a4, a5, a6, a7)\
(kprint_format[]{ a0,a2,a4,a6 })
#define __kprint_argsToObjects8(\
a0, a1, a2, a3, a4, a5, a6, a7)\
(void*[]{ a1,a3,a5,a7 })
#define __kprint_argsToFormats16(\
a0, a1, a2, a3, a4, a5, a6, a7,\
a8, a9, a10,a11,a12,a13,a14,a15)\
(kprint_format[]{ a0,a2,a4,a6,a8,a10,a12,a14 })
#define __kprint_argsToObjects16(\
a0, a1, a2, a3, a4, a5, a6, a7,\
a8, a9, a10,a11,a12,a13,a14,a15)\
(void*[]{ a1,a3,a5,a7,a9,a11,a13,a15 })
#define __kprint_argsToFormats32(\
a0, a1, a2, a3, a4, a5, a6, a7,\
a8, a9, a10,a11,a12,a13,a14,a15,\
a16,a17,a18,a19,a20,a21,a22,a23,\
a24,a25,a26,a27,a28,a29,a30,a31)\
(kprint_format[]{ a0,a2,a4,a6,a8,a10,a12,a14,a16,a18,a20,a22,a24,a26,a28,a30 }
#define __kprint_argsToObjects32(\
a0, a1, a2, a3, a4, a5, a6, a7,\
a8, a9, a10,a11,a12,a13,a14,a15,\
a16,a17,a18,a19,a20,a21,a22,a23,\
a24,a25,a26,a27,a28,a29,a30,a31)\
(void*[]{ a1,a3,a5,a7,a9,a11,a13,a15,a17,a19,a21,a23,a25,a27,a29,a31 })
#define __32zeroes 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
#define __kprint_argsToArrs(COUNT,ARGS...)(\
(COUNT<=8 __kprint_argsToFormats8(ARGS,__32zeroes) :\
COUNT<=16 __kprint_argsToFormats16(ARGS,__32zeroes) :\
__kprint_argsToFormats32(ARGS,__32zeroes)),\
(COUNT<=8 __kprint_argsToObjects8(ARGS,__32zeroes) :\
COUNT<=16 __kprint_argsToObjects16(ARGS) :\
__kprint_argsToObjects32(ARGS,__32zeroes))
Maybe __ksprint(uint8 n, kprint_format* formats, void** objects);
#define ksprint(ARGS...) __ksprint(count_args(ARGS), __kprint_argsToArrs(count_args(ARGS),ARGS))
Maybe __kfprint(FILE* fd, uint8 n, kprint_format* formats, void** objects);
#define kfprint(FD, ARGS...) __kfprint(FD, count_args(ARGS), __kprint_argsToArrs(count_args(ARGS),ARGS))
void __kprint(uint8 n, kprint_format* formats, void** objects);
#define kprint(ARGS...) __kprint(count_args(ARGS), __kprint_argsToArrs(count_args(ARGS),ARGS))
// can take (bgColor | fgColor)
void kprint_setColor(kprint_format f);
#if __cplusplus
}
#endif

55
src/base/kprint/kprint_colors.h Normal file
View File

@ -0,0 +1,55 @@
#pragma once
#if __cplusplus
extern "C" {
#endif
typedef enum kprint_fgColor{
// 10000000 00000000 00000000 00000000
// ^ ^^^^
// | color num
// fgColorChanged flag
kprint_fgBlack = 0x80000000,
kprint_fgDarkRed = 0x81000000,
kprint_fgDarkGreen = 0x82000000,
kprint_fgDarkYellow = 0x83000000,
kprint_fgDarkBlue = 0x84000000,
kprint_fgDarkMagneta= 0x85000000,
kprint_fgDarkCyan = 0x86000000,
kprint_fgGray = 0x87000000,
kprint_fgDarkGray = 0x88000000,
kprint_fgRed = 0x89000000,
kprint_fgGreen = 0x8a000000,
kprint_fgYellow = 0x8b000000,
kprint_fgBlue = 0x8c000000,
kprint_fgMagneta = 0x8d000000,
kprint_fgCyan = 0x8e000000,
kprint_fgWhite = 0x8f000000
} kprint_fgColor;
typedef enum kprint_bgColor{
// 01000000 00000000 00000000 00000000
// ^ ^^^^
// bgColorChanged flag color num
kprint_bgBlack = 0x40000000,
kprint_bgDarkRed = 0x40100000,
kprint_bgDarkGreen = 0x40200000,
kprint_bgDarkYellow = 0x40300000,
kprint_bgDarkBlue = 0x40400000,
kprint_bgDarkMagneta= 0x40500000,
kprint_bgDarkCyan = 0x40600000,
kprint_bgGray = 0x40700000,
kprint_bgDarkGray = 0x40800000,
kprint_bgRed = 0x40900000,
kprint_bgGreen = 0x40a00000,
kprint_bgYellow = 0x40b00000,
kprint_bgBlue = 0x40c00000,
kprint_bgMagneta = 0x40d00000,
kprint_bgCyan = 0x40e00000,
kprint_bgWhite = 0x40f00000
} kprint_bgColor;
#if __cplusplus
}
#endif

47
src/base/kprint/kprint_format.h Normal file
View File

@ -0,0 +1,47 @@
#pragma once
#if __cplusplus
extern "C" {
#endif
#include "../type_system/ktId.h"
typedef enum kprint_dataFormat{
// 00000000 00000000 00000000 00000000
// ^^^^
// type
kprint_fmtInt = 0x00000000,
kprint_fmtUInt = 0x00010000,
kprint_fmtHex = 0x00020000,
kprint_fmtBin = 0x00030000,
kprint_fmtFloat = 0x00040000,
kprint_fmtChar = 0x00050000,
kprint_fmtString = 0x00060000,
// 00100000 00000000 00000000 00000000
// ^
// prefix/postfix flag
kprint_fmtWithPrefix=0x20000000,
kprint_fmtWithPostfix=kprint_fmtWithPrefix,
// 00010000 00000000 00000000 00000000
// ^
// uppercase flag
kprint_fmtUppercase=0x10000000
} kprint_dataFormat;
typedef struct {
unsigned char fgColorChanged : 1;
unsigned char bgColorChanged : 1;
unsigned char withPrefix : 1;
unsigned char uppercase : 1;
unsigned char fgColor : 4;
unsigned char bgColor : 4;
unsigned char dataFmt : 4;
ktId typeId;
} kprint_format;
#if __cplusplus
}
#endif

72
src/base/kprint/kprint_format.md Normal file
View File

@ -0,0 +1,72 @@
# kerep_format
```
00000000 00000000 00000000 00000000
fgColorSet┘│││└┼┴┘ └┼┴┘└┴┴┤ ktId
bgColorSet─┘││ │ bgColor └data format
prefix┬────┘│ └fgColor
postfix └uppercase
```
## Console colors
### *Foreground*
| kprint_fg | hex | bin |
|-----------|-----|-----|
| Black | 0x80000000 | 10000000 00000000... |
| DarkRed | 0x81000000 | 10000001 00000000... |
| DarkGreen | 0x82000000 | 10000010 00000000... |
| DarkYellow | 0x83000000 | 10000011 00000000... |
| DarkBlue | 0x84000000 | 10000100 00000000... |
| DarkMagneta | 0x85000000 | 10000101 00000000... |
| DarkCyan | 0x86000000 | 10000110 00000000... |
| Gray | 0x87000000 | 10000111 00000000... |
| DarkGray | 0x88000000 | 10001000 00000000... |
| Red | 0x89000000 | 10001001 00000000... |
| Green | 0x8a000000 | 10001010 00000000... |
| Yellow | 0x8b000000 | 10001011 00000000... |
| Blue | 0x8c000000 | 10001100 00000000... |
| Magneta | 0x8d000000 | 10001101 00000000... |
| Cyan | 0x8e000000 | 10001110 00000000... |
| White | 0x8f000000 | 10001111 00000000... |
### *Background*
| kprint_bg | hex | bin |
|-----------|-----|-----|
| Black | 0x40000000 | 01000000 00000000... |
| DarkRed | 0x40100000 | 01000000 00010000... |
| DarkGreen | 0x40200000 | 01000000 00100000... |
| DarkYellow | 0x40300000 | 01000000 00110000... |
| DarkBlue | 0x40400000 | 01000000 01000000... |
| DarkMagneta | 0x40500000 | 01000000 01010000... |
| DarkCyan | 0x40600000 | 01000000 01100000... |
| Gray | 0x40700000 | 01000000 01110000... |
| DarkGray | 0x40800000 | 01000000 10000000... |
| Red | 0x40900000 | 01000000 10010000... |
| Green | 0x40a00000 | 01000000 10100000... |
| Yellow | 0x40b00000 | 01000000 10110000... |
| Blue | 0x40c00000 | 01000000 11000000... |
| Magneta | 0x40d00000 | 01000000 11010000... |
| Cyan | 0x40e00000 | 01000000 11100000... |
| White | 0x40f00000 | 01000000 11110000... |
## Data format
| kprint_fmt | possible flags | data types | hex value | bin value |
|------------|----------------|------------|-----------|-----------|
| Int | | int8... int64 | 0x00000000 | 00000000 00000000... |
| UInt | WithPostfix, Uppercase | uint8... uint64 | 0x00010000 | 00000000 00000001... |
| Hex | WithPrefix, Uppercase | any | 0x00020000 | 00000000 00000010... |
| Bin | WithPrefix, | any | 0x00030000 | 00000000 00000011... |
| Float | WithPostfix, Uppercase | float32, float64 | 0x00040000 | 00000000 00000100... |
| Char | | char | 0x00050000 | 00000000 00000101... |
| String | | char* | 0x00060000 | 00000000 00000110... |
### *Flags*
| kprint_fmt | hex value | bin value |
|-------------|------------|-----------|
| withPrefix | 0x20000000 | 00100000 00000000... |
| withPostfix | 0x20000000 | 00100000 00000000... |
| upperase | 0x10000000 | 00010000 00000000... |

2
src/base/optime.h
View File

@ -1,6 +1,6 @@
#pragma once #pragma once
#include "types.h" #include "std.h"
// executes codeblock and prints execution time // executes codeblock and prints execution time
#ifdef CLOCK_REALTIME // non-standard high-precision clock #ifdef CLOCK_REALTIME // non-standard high-precision clock

1
src/base/std.h
View File

@ -8,6 +8,7 @@ extern "C" {
#include <stdlib.h> #include <stdlib.h>
#include <stdint.h> #include <stdint.h>
#include <stdbool.h> #include <stdbool.h>
#include <stdarg.h>
#include <locale.h> #include <locale.h>
#include <time.h> #include <time.h>
#include <setjmp.h> #include <setjmp.h>

30
src/base/type_system/README.md Normal file
View File

@ -0,0 +1,30 @@
# kerep type system
For using some kerep capabilities, such as generic structs, unitype, and kprint, types should be *registered*.
## type id
Every registered type has its own id (`ktId`), which should be declared in header file and defined in source file.
Example:
```c
//someStruct.h
typedef struct { } someStruct;
ktId_declare(ktId_someStruct);
ktId_declare(ktId_someStructPtr); // pointer to type is another type
```
```c
//someStruct.c
ktId_define(ktId_someStruct);
ktId_define(ktId_someStructPtr);
```
## type descriptors
Every registered type should have it's own descriptor (`ktDescriptor`). It's a struct, which contains some information about type and pointers to some specific functions for this type (`toString`, `freeMembers`).
## type registration
To finally register a type, you should call macro `kt_register()` between `ktDescriptors_beginInit()` and `ktDescriptors_endInit()`. Better do it at the start of your program. To register all types from kerep, call `ktDescriptors_initKerepTypes()`.
Examples:
+ [ktDescriptors_initKerepTypes()](src/base/type_system/init.c)
+ [kerep types registration](tests/main.cpp)

103
src/base/type_system/init.c Normal file
View File

@ -0,0 +1,103 @@
#include "../base.h"
#include "../../Autoarr/Autoarr.h"
#include "../../SearchTree/SearchTree.h"
#include "../../Hashtable/Hashtable.h"
#include "../../String/StringBuilder.h"
void ktDescriptors_initKerepTypes(){
// null
kt_register(NULL, ktId_Null, NULL, NULL);
// base types
kt_register(char, ktId_Char, NULL, NULL);
kt_register(bool, ktId_Bool, NULL, NULL);
kt_register(float32, ktId_Float32, NULL, NULL);
kt_register(float64, ktId_Float64, NULL, NULL);
kt_register(int8, ktId_Int8, NULL, NULL);
kt_register(uint8, ktId_UInt8, NULL, NULL);
kt_register(int16, ktId_Int16, NULL, NULL);
kt_register(uint16, ktId_UInt16, NULL, NULL);
kt_register(int32, ktId_Int32, NULL, NULL);
kt_register(uint32, ktId_UInt32, NULL, NULL);
kt_register(int64, ktId_Int64, NULL, NULL);
kt_register(uint64, ktId_UInt64, NULL, NULL);
// base type pointers
kt_register(char*, ktId_CharPtr, NULL, NULL);
kt_register(bool*, ktId_BoolPtr, NULL, NULL);
kt_register(float32*, ktId_Float32Ptr, NULL, NULL);
kt_register(float64*, ktId_Float64Ptr, NULL, NULL);
kt_register(int8*, ktId_Int8Ptr, NULL, NULL);
kt_register(uint8*, ktId_UInt8Ptr, NULL, NULL);
kt_register(int16*, ktId_Int16Ptr, NULL, NULL);
kt_register(uint16*, ktId_UInt16Ptr, NULL, NULL);
kt_register(int32*, ktId_Int32Ptr, NULL, NULL);
kt_register(uint32*, ktId_UInt32Ptr, NULL, NULL);
kt_register(int64*, ktId_Int64Ptr, NULL, NULL);
kt_register(uint64*, ktId_UInt64Ptr, NULL, NULL);
// ktDescriptor
kt_register(ktDescriptor, ktId_ktDescriptor, NULL, NULL);
kt_register(ktDescriptor*, ktId_ktDescriptorPtr, NULL, NULL);
// base type autoarrs
kt_register(Autoarr_char, ktId_AutoarrChar, ____Autoarr_free_char, NULL);
kt_register(Autoarr_bool, ktId_AutoarrBool, ____Autoarr_free_bool, NULL);
kt_register(Autoarr_float32, ktId_AutoarrFloat32, ____Autoarr_free_float32, NULL);
kt_register(Autoarr_float64, ktId_AutoarrFloat64, ____Autoarr_free_float64, NULL);
kt_register(Autoarr_int8, ktId_AutoarrInt8, ____Autoarr_free_int8, NULL);
kt_register(Autoarr_uint8, ktId_AutoarrUInt8, ____Autoarr_free_uint8, NULL);
kt_register(Autoarr_int16, ktId_AutoarrInt16, ____Autoarr_free_int16, NULL);
kt_register(Autoarr_uint16, ktId_AutoarrUInt16, ____Autoarr_free_uint16, NULL);
kt_register(Autoarr_int32, ktId_AutoarrInt32, ____Autoarr_free_int32, NULL);
kt_register(Autoarr_uint32, ktId_AutoarrUInt32, ____Autoarr_free_uint32, NULL);
kt_register(Autoarr_int64, ktId_AutoarrInt64, ____Autoarr_free_int64, NULL);
kt_register(Autoarr_uint64, ktId_AutoarrUInt64, ____Autoarr_free_uint64, NULL);
// base type autoarr pointers
kt_register(Autoarr_char*, ktId_AutoarrCharPtr, ____Autoarr_free_char, NULL);
kt_register(Autoarr_bool*, ktId_AutoarrBoolPtr, ____Autoarr_free_bool, NULL);
kt_register(Autoarr_float32*, ktId_AutoarrFloat32Ptr, ____Autoarr_free_float32, NULL);
kt_register(Autoarr_float64*, ktId_AutoarrFloat64Ptr, ____Autoarr_free_float64, NULL);
kt_register(Autoarr_int8*, ktId_AutoarrInt8Ptr, ____Autoarr_free_int8, NULL);
kt_register(Autoarr_uint8*, ktId_AutoarrUInt8Ptr, ____Autoarr_free_uint8, NULL);
kt_register(Autoarr_int16*, ktId_AutoarrInt16Ptr, ____Autoarr_free_int16, NULL);
kt_register(Autoarr_uint16*, ktId_AutoarrUInt16Ptr, ____Autoarr_free_uint16, NULL);
kt_register(Autoarr_int32*, ktId_AutoarrInt32Ptr, ____Autoarr_free_int32, NULL);
kt_register(Autoarr_uint32*, ktId_AutoarrUInt32Ptr, ____Autoarr_free_uint32, NULL);
kt_register(Autoarr_int64*, ktId_AutoarrInt64Ptr, ____Autoarr_free_int64, NULL);
kt_register(Autoarr_uint64*, ktId_AutoarrUInt64Ptr, ____Autoarr_free_uint64, NULL);
// Unitype
kt_register(Unitype, ktId_Unitype, __UnitypePtr_free, NULL);
kt_register(Unitype*, ktId_UnitypePtr, __UnitypePtr_free, NULL);
kt_register(Autoarr_Unitype, ktId_AutoarrUnitype, ____Autoarr_free_Unitype_, NULL);
kt_register(Autoarr_Unitype*, ktId_AutoarrUnitypePtr, ____Autoarr_free_Unitype_, NULL);
// replacing autogenerated freear() function to custom
Autoarr_Unitype* _uar=Autoarr_create(Unitype, 1, 1);
_uar->functions->freear=__Autoarr_free_Unitype_;
Autoarr_free(_uar, true);
// SearchTreeNode
kt_register(STNode, ktId_STNode, __STNode_free, NULL);
kt_register(STNode*, ktId_STNodePtr, __STNode_free, NULL);
// KeyValuePair
kt_register(KVPair, ktId_KVPair, __KVPair_free, NULL);
kt_register(KVPair*, ktId_KVPairPtr, __KVPair_free, NULL);
kt_register(Autoarr_KVPair, ktId_AutoarrKVPair, ____Autoarr_free_KVPair_, NULL);
kt_register(Autoarr_KVPair*, ktId_AutoarrKVPairPtr, ____Autoarr_free_KVPair_, NULL);
// replacing autogenerated freear() function to custom
Autoarr_KVPair* _kvpar=Autoarr_create(KVPair, 1, 1);
_kvpar->functions->freear=__Autoarr_free_KVPair_;
Autoarr_free(_kvpar, true);
// Hashtable
kt_register(Hashtable, ktId_Hashtable, __Hashtable_free, NULL);
kt_register(Hashtable*, ktId_HashtablePtr, __Hashtable_free, NULL);
// string
kt_register(string, ktId_string, NULL, NULL);
kt_register(string*, ktId_stringPtr, NULL, NULL);
kt_register(string, ktId_AutoarrString, ____Autoarr_free_string, NULL);
kt_register(string*, ktId_AutoarrStringPtr, ____Autoarr_free_string, NULL);
// StringBuilder
kt_register(StringBuilder, ktId_StringBuilder, __StringBuilder_free, NULL);
kt_register(StringBuilder*, ktId_StringBuilderPtr, __StringBuilder_free, NULL);
}

12
src/base/type_system/init.h Normal file
View File

@ -0,0 +1,12 @@
#pragma once
#if __cplusplus
extern "C" {
#endif
// call this between ktDescriptors_beginInit() and ktDescriptors_endInit()
void ktDescriptors_initKerepTypes();
#if __cplusplus
}
#endif

22
src/base/type_system/ktDescriptor.h Normal file
View File

@ -0,0 +1,22 @@
#pragma once
#if __cplusplus
extern "C" {
#endif
#include "../std.h"
#include "../errors.h"
#include "ktId.h"
typedef struct ktDescriptor{
char* name;
ktId id;
uint16 size;
void (*freeMembers)(void*); // NULL or function which frees all struct members
///@return Maybe<char*>
Maybe (*toString)(void*, int32); // NULL or function which generates string representaion of object
} ktDescriptor;
#if __cplusplus
}
#endif

17
src/base/type_system/ktId.h Normal file
View File

@ -0,0 +1,17 @@
#pragma once
#if __cplusplus
extern "C" {
#endif
#include "../std.h"
typedef uint16 ktId;
#define ktId_declare(ID_VAR_NAME)\
extern ktId ID_VAR_NAME
#define ktId_define(ID_VAR_NAME)\
ktId ID_VAR_NAME=-1
#if __cplusplus
}
#endif

75
src/base/type_system/kt_functions.c Normal file
View File

@ -0,0 +1,75 @@
#include "../../Autoarr/Autoarr.h"
Autoarr_declare(ktDescriptor)
Autoarr_define(ktDescriptor)
ktId_define(ktId_Null);
ktId_define(ktId_Char);
ktId_define(ktId_Bool);
ktId_define(ktId_Float32);
ktId_define(ktId_Float64);
ktId_define(ktId_Int8);
ktId_define(ktId_UInt8);
ktId_define(ktId_Int16);
ktId_define(ktId_UInt16);
ktId_define(ktId_Int32);
ktId_define(ktId_UInt32);
ktId_define(ktId_Int64);
ktId_define(ktId_UInt64);
ktId_define(ktId_CharPtr);
ktId_define(ktId_BoolPtr);
ktId_define(ktId_Float32Ptr);
ktId_define(ktId_Float64Ptr);
ktId_define(ktId_Int8Ptr);
ktId_define(ktId_UInt8Ptr);
ktId_define(ktId_Int16Ptr);
ktId_define(ktId_UInt16Ptr);
ktId_define(ktId_Int32Ptr);
ktId_define(ktId_UInt32Ptr);
ktId_define(ktId_Int64Ptr);
ktId_define(ktId_UInt64Ptr);
ktId_define(ktId_ktDescriptor);
ktId_define(ktId_ktDescriptorPtr);
// type descriptors are stored here during initialization
Autoarr(ktDescriptor)* __ktDescriptors=NULL;
// here type descriptors are stored when initialization is complited
ktDescriptor* typeDescriptors=NULL;
ktId ktId_last=-1;
typedef enum{
NotInitialized, Initializing, Initialized
} ktDescriptorsState;
ktDescriptorsState initState=NotInitialized;
void ktDescriptors_beginInit(){
printf("\e[94mtype descriptors initializing...\n");
__ktDescriptors=Autoarr_create(ktDescriptor, 256, 256);
if(__ktDescriptors==NULL) throw(ERR_NULLPTR);
}
void ktDescriptors_endInit(){
typeDescriptors=Autoarr_toArray(__ktDescriptors);
Autoarr_free(__ktDescriptors,true);
if(typeDescriptors==NULL) throw(ERR_NULLPTR);
printf("\e[92minitialized %u type descriptors\n", ktId_last);
}
void __kt_register(char* name, int16 size, void (*freeMembers)(void*), Maybe (*toString)(void*, int32)){
ktDescriptor typeDesc={
.name=name,
.size=size,
.id=++ktId_last,
.freeMembers=freeMembers,
.toString=toString
};
Autoarr_add(__ktDescriptors, typeDesc);
}
Maybe ktDescriptor_get(ktId id){
if(id>ktId_last) safethrow("invalid type id",;);
return SUCCESS(UniStack(ktId_ktDescriptorPtr, &typeDescriptors[id]));
}

59
src/base/type_system/kt_functions.h Normal file
View File

@ -0,0 +1,59 @@
#pragma once
#if __cplusplus
extern "C" {
#endif
#include "../std.h"
#include "ktId.h"
#include "ktDescriptor.h"
extern ktId ktId_last;
void __kt_register(char* name, int16 size, void (*freeMembers)(void*), Maybe (*toString)(void*, int32));
#define kt_register(TYPE, ID_VAR_NAME, FREE_MEMBERS_FUNC, TO_STRING_FUNC)\
__kt_register(#ID_VAR_NAME, sizeof(TYPE), FREE_MEMBERS_FUNC, TO_STRING_FUNC);\
ID_VAR_NAME=ktId_last;
void ktDescriptors_beginInit();
void ktDescriptors_endInit();
/// @param id id of registered type
/// @return Maybe<ktDescriptor*>
Maybe ktDescriptor_get(ktId id);
ktId_declare(ktId_Null);
ktId_declare(ktId_Char);
ktId_declare(ktId_Bool);
ktId_declare(ktId_Float32);
ktId_declare(ktId_Float64);
ktId_declare(ktId_Int8);
ktId_declare(ktId_UInt8);
ktId_declare(ktId_Int16);
ktId_declare(ktId_UInt16);
ktId_declare(ktId_Int32);
ktId_declare(ktId_UInt32);
ktId_declare(ktId_Int64);
ktId_declare(ktId_UInt64);
ktId_declare(ktId_CharPtr);
ktId_declare(ktId_BoolPtr);
ktId_declare(ktId_Float32Ptr);
ktId_declare(ktId_Float64Ptr);
ktId_declare(ktId_Int8Ptr);
ktId_declare(ktId_UInt8Ptr);
ktId_declare(ktId_Int16Ptr);
ktId_declare(ktId_UInt16Ptr);
ktId_declare(ktId_Int32Ptr);
ktId_declare(ktId_UInt32Ptr);
ktId_declare(ktId_Int64Ptr);
ktId_declare(ktId_UInt64Ptr);
ktId_declare(ktId_ktDescriptor);
ktId_declare(ktId_ktDescriptorPtr);
#if __cplusplus
}
#endif

4
src/base/type_system/type_system.h Normal file
View File

@ -0,0 +1,4 @@
#include "init.h"
#include "kt_functions.h"
#include "unitype.h"

26
src/base/unitype.c → src/base/type_system/unitype.c
View File

@ -1,12 +1,13 @@
#include "base.h" #include "../base.h"
kerepTypeId_define(kerepTypeId_Unitype); ktId_define(ktId_Unitype);
kerepTypeId_define(kerepTypeId_UnitypePtr); ktId_define(ktId_UnitypePtr);
void Unitype_free(Unitype u){ void Unitype_free(Unitype u){
kerepTypeDescriptor type=kerepTypeDescriptor_get(u.typeId); tryLast(ktDescriptor_get(u.typeId), mType);
if(type.free_members) ktDescriptor type=*(ktDescriptor*)mType.value.VoidPtr;
type.free_members(u.VoidPtr); if(type.freeMembers)
type.freeMembers(u.VoidPtr);
if(u.allocatedInHeap) if(u.allocatedInHeap)
free(u.VoidPtr); free(u.VoidPtr);
} }
@ -15,16 +16,17 @@ void __UnitypePtr_free(void* u) { Unitype_free(*(Unitype*)u); }
#define BUFSIZE 64 #define BUFSIZE 64
char* sprintuni(Unitype v){ char* sprintuni(Unitype v){
char* buf=malloc(BUFSIZE); char* buf=malloc(BUFSIZE);
kerepTypeDescriptor type=kerepTypeDescriptor_get(v.typeId); tryLast(ktDescriptor_get(v.typeId), mType);
if(v.typeId==kerepTypeId_Null) ktDescriptor type=*(ktDescriptor*)mType.value.VoidPtr;
if(v.typeId==ktId_Null)
sprintf_s(buf, BUFSIZE, "{Null}"); sprintf_s(buf, BUFSIZE, "{Null}");
else if(v.typeId==kerepTypeId_Float64) else if(v.typeId==ktId_Float64)
sprintf_s(buf, BUFSIZE, "{%s : %lf}", type.name,v.Float64); sprintf_s(buf, BUFSIZE, "{%s : %lf}", type.name,v.Float64);
else if(v.typeId==kerepTypeId_Bool || v.typeId==kerepTypeId_UInt64) else if(v.typeId==ktId_Bool || v.typeId==ktId_UInt64)
sprintf_s(buf, BUFSIZE, "{%s : " IFWIN("%llu", "%lu") "}", type.name,v.UInt64); sprintf_s(buf, BUFSIZE, "{%s : " IFWIN("%llu", "%lu") "}", type.name,v.UInt64);
else if(v.typeId==kerepTypeId_Int64) else if(v.typeId==ktId_Int64)
sprintf_s(buf, BUFSIZE, "{%s : " IFWIN("%lld", "%ld") "}", type.name,v.Int64); sprintf_s(buf, BUFSIZE, "{%s : " IFWIN("%lld", "%ld") "}", type.name,v.Int64);
else if(v.typeId==kerepTypeId_CharPtr){ else if(v.typeId==ktId_CharPtr){
size_t newBUFSIZE=cptr_length(v.VoidPtr) + BUFSIZE/2; size_t newBUFSIZE=cptr_length(v.VoidPtr) + BUFSIZE/2;
buf=realloc(buf, newBUFSIZE); buf=realloc(buf, newBUFSIZE);
sprintf_s(buf, BUFSIZE, "{%s : \"%s\"}", type.name,(char*)v.VoidPtr); sprintf_s(buf, BUFSIZE, "{%s : \"%s\"}", type.name,(char*)v.VoidPtr);

26
src/base/unitype.h → src/base/type_system/unitype.h
View File

@ -4,7 +4,7 @@
extern "C" { extern "C" {
#endif #endif
#include "types.h" #include "ktId.h"
typedef struct Unitype{ typedef struct Unitype{
union { union {
@ -15,27 +15,27 @@ typedef struct Unitype{
void* VoidPtr; void* VoidPtr;
char Bytes[8]; char Bytes[8];
}; };
kerepTypeId typeId; ktId typeId;
bool allocatedInHeap; // should Unitype_free call free() to VoidPtr* bool allocatedInHeap; // should Unitype_free call free() to VoidPtr*
} Unitype; } Unitype;
kerepTypeId_declare(kerepTypeId_Unitype); ktId_declare(ktId_Unitype);
kerepTypeId_declare(kerepTypeId_UnitypePtr); ktId_declare(ktId_UnitypePtr);
#define Uni(TYPE, VAL) (Unitype){\ #define __UniDef(TYPE, VAL) (Unitype){\
.TYPE=VAL, .typeId=kerepTypeId_##TYPE, .allocatedInHeap=false} .TYPE=VAL, .typeId=ktId_##TYPE, .allocatedInHeap=false}
#define UniInt64(VAL) Uni(Int64, VAL) #define UniInt64(VAL) __UniDef(Int64, VAL)
#define UniUInt64(VAL) Uni(UInt64, VAL) #define UniUInt64(VAL) __UniDef(UInt64, VAL)
#define UniFloat64(VAL) Uni(Float64, VAL) #define UniFloat64(VAL) __UniDef(Float64, VAL)
#define UniBool(VAL) Uni(Bool, VAL) #define UniBool(VAL) __UniDef(Bool, VAL)
#define UniPtrStack(ID_VAR_NAME, VAL) (Unitype){\ #define UniStack(ID_VAR_NAME, VAL) (Unitype){\
.VoidPtr=VAL, .typeId=ID_VAR_NAME, .allocatedInHeap=false} .VoidPtr=VAL, .typeId=ID_VAR_NAME, .allocatedInHeap=false}
#define UniPtrHeap(ID_VAR_NAME, VAL) (Unitype){\ #define UniHeap(ID_VAR_NAME, VAL) (Unitype){\
.VoidPtr=VAL, .typeId=ID_VAR_NAME, .allocatedInHeap=true} .VoidPtr=VAL, .typeId=ID_VAR_NAME, .allocatedInHeap=true}
#define UniNull UniPtrStack(kerepTypeId_Null, NULL) #define UniNull UniStack(ktId_Null, NULL)
#define UniTrue UniBool(true) #define UniTrue UniBool(true)
#define UniFalse UniBool(false) #define UniFalse UniBool(false)

71
src/base/types.c
View File

@ -1,71 +0,0 @@
#include "../Autoarr/Autoarr.h"
#include "unitype.h"
Autoarr_declare(kerepTypeDescriptor)
Autoarr_define(kerepTypeDescriptor)
kerepTypeId_define(kerepTypeId_Null);
kerepTypeId_define(kerepTypeId_Char);
kerepTypeId_define(kerepTypeId_Bool);
kerepTypeId_define(kerepTypeId_Float32);
kerepTypeId_define(kerepTypeId_Float64);
kerepTypeId_define(kerepTypeId_Int8);
kerepTypeId_define(kerepTypeId_UInt8);
kerepTypeId_define(kerepTypeId_Int16);
kerepTypeId_define(kerepTypeId_UInt16);
kerepTypeId_define(kerepTypeId_Int32);
kerepTypeId_define(kerepTypeId_UInt32);
kerepTypeId_define(kerepTypeId_Int64);
kerepTypeId_define(kerepTypeId_UInt64);
kerepTypeId_define(kerepTypeId_CharPtr);
kerepTypeId_define(kerepTypeId_BoolPtr);
kerepTypeId_define(kerepTypeId_Float32Ptr);
kerepTypeId_define(kerepTypeId_Float64Ptr);
kerepTypeId_define(kerepTypeId_Int8Ptr);
kerepTypeId_define(kerepTypeId_UInt8Ptr);
kerepTypeId_define(kerepTypeId_Int16Ptr);
kerepTypeId_define(kerepTypeId_UInt16Ptr);
kerepTypeId_define(kerepTypeId_Int32Ptr);
kerepTypeId_define(kerepTypeId_UInt32Ptr);
kerepTypeId_define(kerepTypeId_Int64Ptr);
kerepTypeId_define(kerepTypeId_UInt64Ptr);
// type descriptors are stored here during initialization
Autoarr(kerepTypeDescriptor)* __kerepTypeDescriptors=NULL;
// here type descriptors are stored when initialization is complited
kerepTypeDescriptor* typeDescriptors=NULL;
kerepTypeId kerepTypeId_last=-1;
typedef enum{
NotInitialized, Initializing, Initialized
} kerepTypeDescriptorsState;
kerepTypeDescriptorsState initState=NotInitialized;
void kerepTypeDescriptors_beginInit(){
printf("\e[94mtype descriptors initializing...\n");
__kerepTypeDescriptors=Autoarr_create(kerepTypeDescriptor, 256, 256);
if(__kerepTypeDescriptors==NULL) throw(ERR_NULLPTR);
}
void kerepTypeDescriptors_endInit(){
typeDescriptors=Autoarr_toArray(__kerepTypeDescriptors);
Autoarr_free(__kerepTypeDescriptors,true);
if(typeDescriptors==NULL) throw(ERR_NULLPTR);
printf("\e[92minitialized %u type descriptors\n", kerepTypeId_last);
}
void __kerepType_register(char* name, int16 size, void (*free_members)(void*)){
kerepTypeDescriptor typeDesc={
.name=name,
.size=size,
.free_members=free_members,
.id=++kerepTypeId_last
};
Autoarr_add(__kerepTypeDescriptors, typeDesc);
}
kerepTypeDescriptor kerepTypeDescriptor_get(kerepTypeId id){
return typeDescriptors[id];
}

64
src/base/types.h
View File

@ -1,64 +0,0 @@
#pragma once
#if __cplusplus
extern "C" {
#endif
#include "std.h"
typedef uint16 kerepTypeId;
typedef struct kerepTypeDescriptor{
void (*free_members)(void*); // NULL or function which frees all struct members
char* name;
kerepTypeId id;
uint16 size;
} kerepTypeDescriptor;
#define kerepTypeId_declare(ID_VAR_NAME)\
extern kerepTypeId ID_VAR_NAME
#define kerepTypeId_define(ID_VAR_NAME)\
kerepTypeId ID_VAR_NAME=-1
extern kerepTypeId kerepTypeId_last;
void __kerepType_register(char* name, int16 size, void (*free_members)(void*));
#define kerepType_register(TYPE, ID_VAR_NAME, FREE_MEMBERS_FUNC)\
__kerepType_register(#ID_VAR_NAME, sizeof(TYPE), FREE_MEMBERS_FUNC);\
ID_VAR_NAME=kerepTypeId_last;
void kerepTypeDescriptors_beginInit();
void kerepTypeDescriptors_endInit();
kerepTypeDescriptor kerepTypeDescriptor_get(kerepTypeId id);
kerepTypeId_declare(kerepTypeId_Null);
kerepTypeId_declare(kerepTypeId_Char);
kerepTypeId_declare(kerepTypeId_Bool);
kerepTypeId_declare(kerepTypeId_Float32);
kerepTypeId_declare(kerepTypeId_Float64);
kerepTypeId_declare(kerepTypeId_Int8);
kerepTypeId_declare(kerepTypeId_UInt8);
kerepTypeId_declare(kerepTypeId_Int16);
kerepTypeId_declare(kerepTypeId_UInt16);
kerepTypeId_declare(kerepTypeId_Int32);
kerepTypeId_declare(kerepTypeId_UInt32);
kerepTypeId_declare(kerepTypeId_Int64);
kerepTypeId_declare(kerepTypeId_UInt64);
kerepTypeId_declare(kerepTypeId_CharPtr);
kerepTypeId_declare(kerepTypeId_BoolPtr);
kerepTypeId_declare(kerepTypeId_Float32Ptr);
kerepTypeId_declare(kerepTypeId_Float64Ptr);
kerepTypeId_declare(kerepTypeId_Int8Ptr);
kerepTypeId_declare(kerepTypeId_UInt8Ptr);
kerepTypeId_declare(kerepTypeId_Int16Ptr);
kerepTypeId_declare(kerepTypeId_UInt16Ptr);
kerepTypeId_declare(kerepTypeId_Int32Ptr);
kerepTypeId_declare(kerepTypeId_UInt32Ptr);
kerepTypeId_declare(kerepTypeId_Int64Ptr);
kerepTypeId_declare(kerepTypeId_UInt64Ptr);
#if __cplusplus
}
#endif

6
tests/main.cpp
View File

@ -13,9 +13,9 @@ void test_all(){
int main(){ int main(){
setlocale(LC_ALL, "en-US.Unicode"); setlocale(LC_ALL, "en-US.Unicode");
kerepTypeDescriptors_beginInit(); ktDescriptors_beginInit();
kerepTypeDescriptors_initKerepTypes(); ktDescriptors_initKerepTypes();
kerepTypeDescriptors_endInit(); ktDescriptors_endInit();
printf("\e[97mkerep tests are starting!\n"); printf("\e[97mkerep tests are starting!\n");
optime("test_all",1,test_all()); optime("test_all",1,test_all());
printf("\e[0m\n"); printf("\e[0m\n");

2
tests/test_dtsod.c
View File

@ -18,7 +18,7 @@ void print_dtsod(Hashtable* dtsod){
printf("\e[92m"); printf("\e[92m");
Hashtable_foreach(dtsod, p,({ Hashtable_foreach(dtsod, p,({
printkvp(p); printkvp(p);
if(p.value.typeId==kerepTypeId_HashtablePtr){ if(p.value.typeId==ktId_HashtablePtr){
printf(": {\n"); printf(": {\n");
Hashtable* sub=p.value.VoidPtr; Hashtable* sub=p.value.VoidPtr;
Hashtable_foreach(sub, _p,({ Hashtable_foreach(sub, _p,({

2
tests/test_hashtable.c
View File

@ -47,7 +47,7 @@ char* genkey(uint32 i){
void fill(Hashtable* ht){ void fill(Hashtable* ht){
for(uint32 i=0;i<100000;i++) for(uint32 i=0;i<100000;i++)
Hashtable_add(ht,genkey(i),Uni(UInt64,i)); Hashtable_add(ht,genkey(i),UniUInt64(i));
} }
Unitype gett(Hashtable* ht){ Unitype gett(Hashtable* ht){

2
tests/test_marshalling.c
View File

@ -4,7 +4,7 @@ EXPORT void CALL test_marshalling(char* text, KVPair** kptr){
KVPair* k=malloc(sizeof(KVPair)); KVPair* k=malloc(sizeof(KVPair));
k->key="message"; k->key="message";
char* tc=cptr_copy(text); char* tc=cptr_copy(text);
Unitype u=UniPtrHeap(kerepTypeId_CharPtr,tc); Unitype u=UniHeap(ktId_CharPtr,tc);
k->value=u; k->value=u;
*kptr=k; *kptr=k;
} }

2
tests/test_safethrow.c
View File

@ -1,7 +1,7 @@
#include "tests.h" #include "tests.h"
Maybe dont_throw(){ Maybe dont_throw(){
return SUCCESS(Uni(UInt64, 9/2)); return SUCCESS(UniUInt64(9/2));
} }
Maybe throw_error(){ Maybe throw_error(){

4
tests/test_searchtree.c
View File

@ -44,11 +44,11 @@ void test_searchtree(){
printuni(u); printuni(u);
ST_push(node,"channel_id", u); ST_push(node,"channel_id", u);
printf(" -> channel_id\n "); printf(" -> channel_id\n ");
u=UniPtrHeap(kerepTypeId_CharPtr, cptr_copy("32.2004")); u=UniHeap(ktId_CharPtr, cptr_copy("32.2004"));
printuni(u); printuni(u);
ST_push(node,"message_id", u); ST_push(node,"message_id", u);
printf(" -> message_id\n "); printf(" -> message_id\n ");
u=UniPtrStack(kerepTypeId_CharPtr,"some text UwU"); u=UniStack(ktId_CharPtr,"some text UwU");
printuni(u); printuni(u);
ST_push(node,"text", u); ST_push(node,"text", u);
printf(" -> text\n"); printf(" -> text\n");