From 67e1328ee7d28430707425145d0fb6f720c04864 Mon Sep 17 00:00:00 2001 From: timerix Date: Tue, 6 Sep 2022 21:25:03 +0600 Subject: [PATCH] kerepType -> kt --- src/Autoarr/Autoarr.c | 52 ++++----- src/Autoarr/Autoarr.h | 52 ++++----- src/DtsodParser/DtsodV24_deserialize.c | 18 +-- src/DtsodParser/DtsodV24_serialize.c | 18 +-- src/Hashtable/Hashtable.c | 6 +- src/Hashtable/Hashtable.h | 4 +- src/Hashtable/KeyValuePair.c | 8 +- src/Hashtable/KeyValuePair.h | 8 +- src/SearchTree/SearchTree.c | 6 +- src/SearchTree/SearchTree.h | 4 +- src/String/StringBuilder.c | 8 +- src/String/StringBuilder.h | 8 +- src/String/string.c | 4 +- src/String/string.h | 4 +- src/base/base.h | 4 +- src/base/init.c | 103 ------------------ src/base/init.h | 12 -- src/base/kprint/README.md | 8 +- src/base/kprint/kprint.c | 22 ++-- src/base/kprint/kprint_format.h | 4 +- src/base/kprint/kprint_format.md | 2 +- src/base/type_system/init.c | 103 ++++++++++++++++++ src/base/type_system/init.h | 12 ++ src/base/type_system/kerepTypeId.h | 17 --- .../{kerepTypeDescriptor.h => ktDescriptor.h} | 8 +- src/base/type_system/ktId.h | 17 +++ src/base/type_system/kt_functions.c | 75 +++++++++++++ src/base/type_system/kt_functions.h | 59 ++++++++++ src/base/type_system/type_system.h | 4 + src/base/type_system/types.c | 76 ------------- src/base/type_system/types.h | 59 ---------- src/base/type_system/unitype.c | 22 ++-- src/base/type_system/unitype.h | 12 +- tests/main.cpp | 6 +- tests/test_dtsod.c | 2 +- tests/test_marshalling.c | 2 +- tests/test_searchtree.c | 4 +- 37 files changed, 417 insertions(+), 416 deletions(-) delete mode 100644 src/base/init.c delete mode 100644 src/base/init.h create mode 100644 src/base/type_system/init.c create mode 100644 src/base/type_system/init.h delete mode 100644 src/base/type_system/kerepTypeId.h rename src/base/type_system/{kerepTypeDescriptor.h => ktDescriptor.h} (77%) create mode 100644 src/base/type_system/ktId.h create mode 100644 src/base/type_system/kt_functions.c create mode 100644 src/base/type_system/kt_functions.h create mode 100644 src/base/type_system/type_system.h delete mode 100644 src/base/type_system/types.c delete mode 100644 src/base/type_system/types.h diff --git a/src/Autoarr/Autoarr.c b/src/Autoarr/Autoarr.c index abff22b..a87502c 100644 --- a/src/Autoarr/Autoarr.c +++ b/src/Autoarr/Autoarr.c @@ -13,35 +13,35 @@ Autoarr_define(int32) Autoarr_define(uint64) Autoarr_define(int64) -kerepTypeId_define(kerepTypeId_AutoarrChar); -kerepTypeId_define(kerepTypeId_AutoarrBool); -kerepTypeId_define(kerepTypeId_AutoarrFloat32); -kerepTypeId_define(kerepTypeId_AutoarrFloat64); -kerepTypeId_define(kerepTypeId_AutoarrInt8); -kerepTypeId_define(kerepTypeId_AutoarrUInt8); -kerepTypeId_define(kerepTypeId_AutoarrInt16); -kerepTypeId_define(kerepTypeId_AutoarrUInt16); -kerepTypeId_define(kerepTypeId_AutoarrInt32); -kerepTypeId_define(kerepTypeId_AutoarrUInt32); -kerepTypeId_define(kerepTypeId_AutoarrInt64); -kerepTypeId_define(kerepTypeId_AutoarrUInt64); +ktId_define(ktId_AutoarrChar); +ktId_define(ktId_AutoarrBool); +ktId_define(ktId_AutoarrFloat32); +ktId_define(ktId_AutoarrFloat64); +ktId_define(ktId_AutoarrInt8); +ktId_define(ktId_AutoarrUInt8); +ktId_define(ktId_AutoarrInt16); +ktId_define(ktId_AutoarrUInt16); +ktId_define(ktId_AutoarrInt32); +ktId_define(ktId_AutoarrUInt32); +ktId_define(ktId_AutoarrInt64); +ktId_define(ktId_AutoarrUInt64); -kerepTypeId_define(kerepTypeId_AutoarrCharPtr); -kerepTypeId_define(kerepTypeId_AutoarrBoolPtr); -kerepTypeId_define(kerepTypeId_AutoarrFloat32Ptr); -kerepTypeId_define(kerepTypeId_AutoarrFloat64Ptr); -kerepTypeId_define(kerepTypeId_AutoarrInt8Ptr); -kerepTypeId_define(kerepTypeId_AutoarrUInt8Ptr); -kerepTypeId_define(kerepTypeId_AutoarrInt16Ptr); -kerepTypeId_define(kerepTypeId_AutoarrUInt16Ptr); -kerepTypeId_define(kerepTypeId_AutoarrInt32Ptr); -kerepTypeId_define(kerepTypeId_AutoarrUInt32Ptr); -kerepTypeId_define(kerepTypeId_AutoarrInt64Ptr); -kerepTypeId_define(kerepTypeId_AutoarrUInt64Ptr); +ktId_define(ktId_AutoarrCharPtr); +ktId_define(ktId_AutoarrBoolPtr); +ktId_define(ktId_AutoarrFloat32Ptr); +ktId_define(ktId_AutoarrFloat64Ptr); +ktId_define(ktId_AutoarrInt8Ptr); +ktId_define(ktId_AutoarrUInt8Ptr); +ktId_define(ktId_AutoarrInt16Ptr); +ktId_define(ktId_AutoarrUInt16Ptr); +ktId_define(ktId_AutoarrInt32Ptr); +ktId_define(ktId_AutoarrUInt32Ptr); +ktId_define(ktId_AutoarrInt64Ptr); +ktId_define(ktId_AutoarrUInt64Ptr); Autoarr_define(Unitype) -kerepTypeId_define(kerepTypeId_AutoarrUnitype); -kerepTypeId_define(kerepTypeId_AutoarrUnitypePtr); +ktId_define(ktId_AutoarrUnitype); +ktId_define(ktId_AutoarrUnitypePtr); // right func to clear array of unitype values void __Autoarr_free_Unitype_(Autoarr(Unitype)* ar, bool freePtr){ diff --git a/src/Autoarr/Autoarr.h b/src/Autoarr/Autoarr.h index d96fcf6..be32c5c 100644 --- a/src/Autoarr/Autoarr.h +++ b/src/Autoarr/Autoarr.h @@ -20,35 +20,35 @@ Autoarr_declare(uint32) Autoarr_declare(int64) Autoarr_declare(uint64) -kerepTypeId_declare(kerepTypeId_AutoarrChar); -kerepTypeId_declare(kerepTypeId_AutoarrBool); -kerepTypeId_declare(kerepTypeId_AutoarrFloat32); -kerepTypeId_declare(kerepTypeId_AutoarrFloat64); -kerepTypeId_declare(kerepTypeId_AutoarrInt8); -kerepTypeId_declare(kerepTypeId_AutoarrUInt8); -kerepTypeId_declare(kerepTypeId_AutoarrInt16); -kerepTypeId_declare(kerepTypeId_AutoarrUInt16); -kerepTypeId_declare(kerepTypeId_AutoarrInt32); -kerepTypeId_declare(kerepTypeId_AutoarrUInt32); -kerepTypeId_declare(kerepTypeId_AutoarrInt64); -kerepTypeId_declare(kerepTypeId_AutoarrUInt64); +ktId_declare(ktId_AutoarrChar); +ktId_declare(ktId_AutoarrBool); +ktId_declare(ktId_AutoarrFloat32); +ktId_declare(ktId_AutoarrFloat64); +ktId_declare(ktId_AutoarrInt8); +ktId_declare(ktId_AutoarrUInt8); +ktId_declare(ktId_AutoarrInt16); +ktId_declare(ktId_AutoarrUInt16); +ktId_declare(ktId_AutoarrInt32); +ktId_declare(ktId_AutoarrUInt32); +ktId_declare(ktId_AutoarrInt64); +ktId_declare(ktId_AutoarrUInt64); -kerepTypeId_declare(kerepTypeId_AutoarrCharPtr); -kerepTypeId_declare(kerepTypeId_AutoarrBoolPtr); -kerepTypeId_declare(kerepTypeId_AutoarrFloat32Ptr); -kerepTypeId_declare(kerepTypeId_AutoarrFloat64Ptr); -kerepTypeId_declare(kerepTypeId_AutoarrInt8Ptr); -kerepTypeId_declare(kerepTypeId_AutoarrUInt8Ptr); -kerepTypeId_declare(kerepTypeId_AutoarrInt16Ptr); -kerepTypeId_declare(kerepTypeId_AutoarrUInt16Ptr); -kerepTypeId_declare(kerepTypeId_AutoarrInt32Ptr); -kerepTypeId_declare(kerepTypeId_AutoarrUInt32Ptr); -kerepTypeId_declare(kerepTypeId_AutoarrInt64Ptr); -kerepTypeId_declare(kerepTypeId_AutoarrUInt64Ptr); +ktId_declare(ktId_AutoarrCharPtr); +ktId_declare(ktId_AutoarrBoolPtr); +ktId_declare(ktId_AutoarrFloat32Ptr); +ktId_declare(ktId_AutoarrFloat64Ptr); +ktId_declare(ktId_AutoarrInt8Ptr); +ktId_declare(ktId_AutoarrUInt8Ptr); +ktId_declare(ktId_AutoarrInt16Ptr); +ktId_declare(ktId_AutoarrUInt16Ptr); +ktId_declare(ktId_AutoarrInt32Ptr); +ktId_declare(ktId_AutoarrUInt32Ptr); +ktId_declare(ktId_AutoarrInt64Ptr); +ktId_declare(ktId_AutoarrUInt64Ptr); Autoarr_declare(Unitype) -kerepTypeId_declare(kerepTypeId_AutoarrUnitype); -kerepTypeId_declare(kerepTypeId_AutoarrUnitypePtr); +ktId_declare(ktId_AutoarrUnitype); +ktId_declare(ktId_AutoarrUnitypePtr); // this function is injected in kerep_init() void __Autoarr_free_Unitype_(Autoarr(Unitype)* ar, bool freePtr); diff --git a/src/DtsodParser/DtsodV24_deserialize.c b/src/DtsodParser/DtsodV24_deserialize.c index ecf1322..20107ef 100644 --- a/src/DtsodParser/DtsodV24_deserialize.c +++ b/src/DtsodParser/DtsodV24_deserialize.c @@ -98,9 +98,9 @@ Maybe __ReadName(DeserializeSharedData* shared){ case '}': if(!calledRecursively || nameStr.length!=0) safethrow_wrongchar(c,;); - return SUCCESS(UniHeap(kerepTypeId_CharPtr,NULL)); + return SUCCESS(UniHeap(ktId_CharPtr,NULL)); case ':': - return SUCCESS(UniHeap(kerepTypeId_CharPtr,string_extract(nameStr))); + return SUCCESS(UniHeap(ktId_CharPtr,string_extract(nameStr))); case '$': if(nameStr.length!=0) safethrow_wrongchar(c,;); @@ -113,7 +113,7 @@ Maybe __ReadName(DeserializeSharedData* shared){ } if(nameStr.length>0) safethrow(ERR_ENDOFSTR,;); - return SUCCESS(UniHeap(kerepTypeId_CharPtr,NULL)); + return SUCCESS(UniHeap(ktId_CharPtr,NULL)); } #define ReadName() __ReadName(shared) @@ -137,7 +137,7 @@ Maybe __ReadString(DeserializeSharedData* shared){ } else { char* str=StringBuilder_build(b).ptr; - return SUCCESS(UniHeap(kerepTypeId_CharPtr,str)); + return SUCCESS(UniHeap(ktId_CharPtr,str)); } } else { @@ -157,13 +157,13 @@ Maybe __ReadList(DeserializeSharedData* shared){ try(ReadValue((&readingList)), val, Autoarr_free(list, true)) Autoarr_add(list,val.value); if (!readingList){ - if(val.value.typeId==kerepTypeId_Null) + if(val.value.typeId==ktId_Null) Autoarr_pop(list); break; } } - return SUCCESS(UniHeap(kerepTypeId_AutoarrUnitypePtr,list)); + return SUCCESS(UniHeap(ktId_AutoarrUnitypePtr,list)); }; #define ReadList() __ReadList(shared) @@ -275,7 +275,7 @@ Maybe __ReadValue(DeserializeSharedData* shared, bool* readingList){ case ';': case ',': if(valueStr.length!=0){ - if(value.typeId!=kerepTypeId_Null) + if(value.typeId!=ktId_Null) safethrow_wrongchar(c,Unitype_free(value)); try(ParseValue(valueStr),maybeParsed,;) value=maybeParsed.value; @@ -321,7 +321,7 @@ Maybe __deserialize(char** _text, bool _calledRecursively) { } else{ list=Autoarr_create(Unitype,ARR_BC,ARR_BL); - Hashtable_add(dict,nameCPtr,UniHeap(kerepTypeId_AutoarrUnitypePtr,list)); + Hashtable_add(dict,nameCPtr,UniHeap(ktId_AutoarrUnitypePtr,list)); } Autoarr_add(list,val.value); } @@ -331,7 +331,7 @@ Maybe __deserialize(char** _text, bool _calledRecursively) { END: *_text=text; - return SUCCESS(UniHeap(kerepTypeId_HashtablePtr,dict)); + return SUCCESS(UniHeap(ktId_HashtablePtr,dict)); } Maybe DtsodV24_deserialize(char* _text) { diff --git a/src/DtsodParser/DtsodV24_serialize.c b/src/DtsodParser/DtsodV24_serialize.c index 3ab0346..cf48d34 100644 --- a/src/DtsodParser/DtsodV24_serialize.c +++ b/src/DtsodParser/DtsodV24_serialize.c @@ -23,18 +23,18 @@ void __AppendTabs(SerializeSharedData* shared) { Maybe __AppendValue(SerializeSharedData* shared, Unitype u); #define AppendValue(UNI) __AppendValue(shared, UNI) Maybe __AppendValue(SerializeSharedData* shared, Unitype u){ - if(u.typeId==kerepTypeId_Int64){ + if(u.typeId==ktId_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); addc('u'); } - else if(u.typeId==kerepTypeId_Float64){ + else if(u.typeId==ktId_Float64){ StringBuilder_append_float64(b,u.Float64); addc('f'); } - else if(u.typeId==kerepTypeId_CharPtr){ + else if(u.typeId==ktId_CharPtr){ addc('"'); char c; while((c=*(char*)(u.VoidPtr++))){ @@ -43,13 +43,13 @@ Maybe __AppendValue(SerializeSharedData* shared, Unitype u){ } addc('"'); } - else if(u.typeId==kerepTypeId_Bool){ + else if(u.typeId==ktId_Bool){ 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",;); } - else if(u.typeId==kerepTypeId_AutoarrUnitypePtr){ + else if(u.typeId==ktId_AutoarrUnitypePtr){ if(Autoarr_length(((Autoarr_Unitype*)(u.VoidPtr)))){ addc('\n'); AppendTabs(); @@ -72,7 +72,7 @@ Maybe __AppendValue(SerializeSharedData* shared, Unitype u){ addc(']'); } } - else if(u.typeId==kerepTypeId_HashtablePtr){ + else if(u.typeId==ktId_HashtablePtr){ // check hashtable is blank bool hashtableNotBlank=false; Hashtable_foreach(((Hashtable*)u.VoidPtr), __, ({ @@ -126,5 +126,5 @@ Maybe DtsodV24_serialize(Hashtable* dtsod){ StringBuilder* sb=StringBuilder_create(); try(__serialize(sb,0,dtsod),__, StringBuilder_free(sb)); char* str=StringBuilder_build(sb).ptr; - return SUCCESS(UniHeap(kerepTypeId_CharPtr, str)); + return SUCCESS(UniHeap(ktId_CharPtr, str)); } diff --git a/src/Hashtable/Hashtable.c b/src/Hashtable/Hashtable.c index 4b1b921..e5eb77d 100644 --- a/src/Hashtable/Hashtable.c +++ b/src/Hashtable/Hashtable.c @@ -1,7 +1,7 @@ #include "Hashtable.h" -kerepTypeId_define(kerepTypeId_Hashtable); -kerepTypeId_define(kerepTypeId_HashtablePtr); +ktId_define(ktId_Hashtable); +ktId_define(ktId_HashtablePtr); // amount of rows 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){ Unitype u=Hashtable_get(ht,key); *output=u; - return u.typeId!=kerepTypeId_Null; + return u.typeId!=ktId_Null; } void Hashtable_addOrSet(Hashtable* ht, char* key, Unitype u){ diff --git a/src/Hashtable/Hashtable.h b/src/Hashtable/Hashtable.h index 58f446d..9437ca2 100644 --- a/src/Hashtable/Hashtable.h +++ b/src/Hashtable/Hashtable.h @@ -11,8 +11,8 @@ typedef struct Hashtable{ uint8 hein; // height=HT_HEIGHTS[hein] Autoarr(KVPair)** rows; // Autoarr[height] } Hashtable; -kerepTypeId_declare(kerepTypeId_Hashtable); -kerepTypeId_declare(kerepTypeId_HashtablePtr); +ktId_declare(ktId_Hashtable); +ktId_declare(ktId_HashtablePtr); Hashtable* Hashtable_create(); void Hashtable_free(Hashtable* ht); diff --git a/src/Hashtable/KeyValuePair.c b/src/Hashtable/KeyValuePair.c index 22c3f5e..cb4a2d0 100644 --- a/src/Hashtable/KeyValuePair.c +++ b/src/Hashtable/KeyValuePair.c @@ -1,11 +1,11 @@ #include "KeyValuePair.h" -kerepTypeId_define(kerepTypeId_KVPair); -kerepTypeId_define(kerepTypeId_KVPairPtr); +ktId_define(ktId_KVPair); +ktId_define(ktId_KVPairPtr); Autoarr_define(KVPair) -kerepTypeId_define(kerepTypeId_AutoarrKVPair); -kerepTypeId_define(kerepTypeId_AutoarrKVPairPtr); +ktId_define(ktId_AutoarrKVPair); +ktId_define(ktId_AutoarrKVPairPtr); // proper way to clear a KVP void KVPair_free(KVPair p){ diff --git a/src/Hashtable/KeyValuePair.h b/src/Hashtable/KeyValuePair.h index 832c6c7..666b839 100644 --- a/src/Hashtable/KeyValuePair.h +++ b/src/Hashtable/KeyValuePair.h @@ -11,12 +11,12 @@ typedef struct KVPair{ char* key; Unitype value; } KVPair; -kerepTypeId_declare(kerepTypeId_KVPair); -kerepTypeId_declare(kerepTypeId_KVPairPtr); +ktId_declare(ktId_KVPair); +ktId_declare(ktId_KVPairPtr); Autoarr_declare(KVPair) -kerepTypeId_declare(kerepTypeId_AutoarrKVPair); -kerepTypeId_declare(kerepTypeId_AutoarrKVPairPtr); +ktId_declare(ktId_AutoarrKVPair); +ktId_declare(ktId_AutoarrKVPairPtr); // proper way to clear a KVP void KVPair_free(KVPair p); diff --git a/src/SearchTree/SearchTree.c b/src/SearchTree/SearchTree.c index 23aa853..c174da9 100644 --- a/src/SearchTree/SearchTree.c +++ b/src/SearchTree/SearchTree.c @@ -1,12 +1,12 @@ #include "SearchTree.h" -kerepTypeId_define(kerepTypeId_STNode); -kerepTypeId_define(kerepTypeId_STNodePtr); +ktId_define(ktId_STNode); +ktId_define(ktId_STNodePtr); STNode* STNode_create(){ STNode* node=malloc(sizeof(STNode)); node->branches=NULL; - node->value.typeId=kerepTypeId_Null; + node->value.typeId=ktId_Null; node->value.UInt64=0; return node; } diff --git a/src/SearchTree/SearchTree.h b/src/SearchTree/SearchTree.h index 3d1a8e0..6ae9e74 100644 --- a/src/SearchTree/SearchTree.h +++ b/src/SearchTree/SearchTree.h @@ -11,8 +11,8 @@ typedef struct SearchTreeNode{ struct SearchTreeNode**** branches; // *STNode[8][8][4] Unitype value; } STNode; -kerepTypeId_declare(kerepTypeId_STNode); -kerepTypeId_declare(kerepTypeId_STNodePtr); +ktId_declare(ktId_STNode); +ktId_declare(ktId_STNodePtr); STNode* STNode_create(); void STNode_free(STNode* node); diff --git a/src/String/StringBuilder.c b/src/String/StringBuilder.c index 167e916..461f45d 100644 --- a/src/String/StringBuilder.c +++ b/src/String/StringBuilder.c @@ -1,11 +1,11 @@ #include "StringBuilder.h" Autoarr_define(string) -kerepTypeId_define(kerepTypeId_AutoarrString); -kerepTypeId_define(kerepTypeId_AutoarrStringPtr); +ktId_define(ktId_AutoarrString); +ktId_define(ktId_AutoarrStringPtr); -kerepTypeId_define(kerepTypeId_StringBuilder); -kerepTypeId_define(kerepTypeId_StringBuilderPtr); +ktId_define(ktId_StringBuilder); +ktId_define(ktId_StringBuilderPtr); #define BL_C 32 #define BL_L 1024 diff --git a/src/String/StringBuilder.h b/src/String/StringBuilder.h index 50e63a7..7cb5d91 100644 --- a/src/String/StringBuilder.h +++ b/src/String/StringBuilder.h @@ -8,15 +8,15 @@ extern "C" { #include "string.h" Autoarr_declare(string) -kerepTypeId_declare(kerepTypeId_AutoarrString); -kerepTypeId_declare(kerepTypeId_AutoarrStringPtr); +ktId_declare(ktId_AutoarrString); +ktId_declare(ktId_AutoarrStringPtr); typedef struct StringBuilder{ Autoarr(string)* compl_bufs; Autoarr(int8)* curr_buf; } StringBuilder; -kerepTypeId_declare(kerepTypeId_StringBuilder); -kerepTypeId_declare(kerepTypeId_StringBuilderPtr); +ktId_declare(ktId_StringBuilder); +ktId_declare(ktId_StringBuilderPtr); StringBuilder* StringBuilder_create(void); void StringBuilder_free(StringBuilder* b); diff --git a/src/String/string.c b/src/String/string.c index e7d92a6..cbcb46e 100644 --- a/src/String/string.c +++ b/src/String/string.c @@ -1,7 +1,7 @@ #include "string.h" -kerepTypeId_define(kerepTypeId_string); -kerepTypeId_define(kerepTypeId_stringPtr); +ktId_define(ktId_string); +ktId_define(ktId_stringPtr); // copies str content to new char pointer value (adding '\0' at the end) char* string_extract(string str){ diff --git a/src/String/string.h b/src/String/string.h index 0b9a658..9313dae 100644 --- a/src/String/string.h +++ b/src/String/string.h @@ -12,8 +12,8 @@ typedef struct string{ char* ptr; // char pointer uint32 length; // amount of chars in ptr value } string; -kerepTypeId_declare(kerepTypeId_string); -kerepTypeId_declare(kerepTypeId_stringPtr); +ktId_declare(ktId_string); +ktId_declare(ktId_stringPtr); static const string stringNull={NULL,0}; diff --git a/src/base/base.h b/src/base/base.h index fce8588..9ca2951 100644 --- a/src/base/base.h +++ b/src/base/base.h @@ -8,9 +8,7 @@ extern "C" { #include "errors.h" #include "cptr.h" #include "optime.h" -#include "type_system/types.h" -#include "type_system/unitype.h" -#include "init.h" +#include "type_system/type_system.h" #include "kprint/kprint.h" #if __cplusplus diff --git a/src/base/init.c b/src/base/init.c deleted file mode 100644 index cef81d1..0000000 --- a/src/base/init.c +++ /dev/null @@ -1,103 +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, NULL); - // base types - kerepType_register(char, kerepTypeId_Char, NULL, NULL); - kerepType_register(bool, kerepTypeId_Bool, NULL, NULL); - kerepType_register(float32, kerepTypeId_Float32, NULL, NULL); - kerepType_register(float64, kerepTypeId_Float64, NULL, NULL); - kerepType_register(int8, kerepTypeId_Int8, NULL, NULL); - kerepType_register(uint8, kerepTypeId_UInt8, NULL, NULL); - kerepType_register(int16, kerepTypeId_Int16, NULL, NULL); - kerepType_register(uint16, kerepTypeId_UInt16, NULL, NULL); - kerepType_register(int32, kerepTypeId_Int32, NULL, NULL); - kerepType_register(uint32, kerepTypeId_UInt32, NULL, NULL); - kerepType_register(int64, kerepTypeId_Int64, NULL, NULL); - kerepType_register(uint64, kerepTypeId_UInt64, NULL, NULL); - // base type pointers - kerepType_register(char*, kerepTypeId_CharPtr, NULL, NULL); - kerepType_register(bool*, kerepTypeId_BoolPtr, NULL, NULL); - kerepType_register(float32*, kerepTypeId_Float32Ptr, NULL, NULL); - kerepType_register(float64*, kerepTypeId_Float64Ptr, NULL, NULL); - kerepType_register(int8*, kerepTypeId_Int8Ptr, NULL, NULL); - kerepType_register(uint8*, kerepTypeId_UInt8Ptr, NULL, NULL); - kerepType_register(int16*, kerepTypeId_Int16Ptr, NULL, NULL); - kerepType_register(uint16*, kerepTypeId_UInt16Ptr, NULL, NULL); - kerepType_register(int32*, kerepTypeId_Int32Ptr, NULL, NULL); - kerepType_register(uint32*, kerepTypeId_UInt32Ptr, NULL, NULL); - kerepType_register(int64*, kerepTypeId_Int64Ptr, NULL, NULL); - kerepType_register(uint64*, kerepTypeId_UInt64Ptr, NULL, NULL); - // kerepTypeDescriptor - kerepType_register(kerepTypeDescriptor, kerepTypeId_kerepTypeDescriptor, NULL, NULL); - kerepType_register(kerepTypeDescriptor*, kerepTypeId_kerepTypeDescriptorPtr, NULL, NULL); - - // base type autoarrs - kerepType_register(Autoarr_char, kerepTypeId_AutoarrChar, ____Autoarr_free_char, NULL); - kerepType_register(Autoarr_bool, kerepTypeId_AutoarrBool, ____Autoarr_free_bool, NULL); - kerepType_register(Autoarr_float32, kerepTypeId_AutoarrFloat32, ____Autoarr_free_float32, NULL); - kerepType_register(Autoarr_float64, kerepTypeId_AutoarrFloat64, ____Autoarr_free_float64, NULL); - kerepType_register(Autoarr_int8, kerepTypeId_AutoarrInt8, ____Autoarr_free_int8, NULL); - kerepType_register(Autoarr_uint8, kerepTypeId_AutoarrUInt8, ____Autoarr_free_uint8, NULL); - kerepType_register(Autoarr_int16, kerepTypeId_AutoarrInt16, ____Autoarr_free_int16, NULL); - kerepType_register(Autoarr_uint16, kerepTypeId_AutoarrUInt16, ____Autoarr_free_uint16, NULL); - kerepType_register(Autoarr_int32, kerepTypeId_AutoarrInt32, ____Autoarr_free_int32, NULL); - kerepType_register(Autoarr_uint32, kerepTypeId_AutoarrUInt32, ____Autoarr_free_uint32, NULL); - kerepType_register(Autoarr_int64, kerepTypeId_AutoarrInt64, ____Autoarr_free_int64, NULL); - kerepType_register(Autoarr_uint64, kerepTypeId_AutoarrUInt64, ____Autoarr_free_uint64, NULL); - // base type autoarr pointers - kerepType_register(Autoarr_char*, kerepTypeId_AutoarrCharPtr, ____Autoarr_free_char, NULL); - kerepType_register(Autoarr_bool*, kerepTypeId_AutoarrBoolPtr, ____Autoarr_free_bool, NULL); - kerepType_register(Autoarr_float32*, kerepTypeId_AutoarrFloat32Ptr, ____Autoarr_free_float32, NULL); - kerepType_register(Autoarr_float64*, kerepTypeId_AutoarrFloat64Ptr, ____Autoarr_free_float64, NULL); - kerepType_register(Autoarr_int8*, kerepTypeId_AutoarrInt8Ptr, ____Autoarr_free_int8, NULL); - kerepType_register(Autoarr_uint8*, kerepTypeId_AutoarrUInt8Ptr, ____Autoarr_free_uint8, NULL); - kerepType_register(Autoarr_int16*, kerepTypeId_AutoarrInt16Ptr, ____Autoarr_free_int16, NULL); - kerepType_register(Autoarr_uint16*, kerepTypeId_AutoarrUInt16Ptr, ____Autoarr_free_uint16, NULL); - kerepType_register(Autoarr_int32*, kerepTypeId_AutoarrInt32Ptr, ____Autoarr_free_int32, NULL); - kerepType_register(Autoarr_uint32*, kerepTypeId_AutoarrUInt32Ptr, ____Autoarr_free_uint32, NULL); - kerepType_register(Autoarr_int64*, kerepTypeId_AutoarrInt64Ptr, ____Autoarr_free_int64, NULL); - kerepType_register(Autoarr_uint64*, kerepTypeId_AutoarrUInt64Ptr, ____Autoarr_free_uint64, NULL); - - // Unitype - kerepType_register(Unitype, kerepTypeId_Unitype, __UnitypePtr_free, NULL); - kerepType_register(Unitype*, kerepTypeId_UnitypePtr, __UnitypePtr_free, NULL); - kerepType_register(Autoarr_Unitype, kerepTypeId_AutoarrUnitype, ____Autoarr_free_Unitype_, NULL); - kerepType_register(Autoarr_Unitype*, kerepTypeId_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 - kerepType_register(STNode, kerepTypeId_STNode, __STNode_free, NULL); - kerepType_register(STNode*, kerepTypeId_STNodePtr, __STNode_free, NULL); - - // KeyValuePair - kerepType_register(KVPair, kerepTypeId_KVPair, __KVPair_free, NULL); - kerepType_register(KVPair*, kerepTypeId_KVPairPtr, __KVPair_free, NULL); - kerepType_register(Autoarr_KVPair, kerepTypeId_AutoarrKVPair, ____Autoarr_free_KVPair_, NULL); - kerepType_register(Autoarr_KVPair*, kerepTypeId_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 - kerepType_register(Hashtable, kerepTypeId_Hashtable, __Hashtable_free, NULL); - kerepType_register(Hashtable*, kerepTypeId_HashtablePtr, __Hashtable_free, NULL); - - // string - kerepType_register(string, kerepTypeId_string, NULL, NULL); - kerepType_register(string*, kerepTypeId_stringPtr, NULL, NULL); - kerepType_register(string, kerepTypeId_AutoarrString, ____Autoarr_free_string, NULL); - kerepType_register(string*, kerepTypeId_AutoarrStringPtr, ____Autoarr_free_string, NULL); - // StringBuilder - kerepType_register(StringBuilder, kerepTypeId_StringBuilder, __StringBuilder_free, NULL); - kerepType_register(StringBuilder*, kerepTypeId_StringBuilderPtr, __StringBuilder_free, NULL); -} diff --git a/src/base/init.h b/src/base/init.h deleted file mode 100644 index dfe5e69..0000000 --- a/src/base/init.h +++ /dev/null @@ -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 \ No newline at end of file diff --git a/src/base/kprint/README.md b/src/base/kprint/README.md index c02cdac..6961b00 100644 --- a/src/base/kprint/README.md +++ b/src/base/kprint/README.md @@ -10,11 +10,11 @@ I don't really like printf function (and its variants), so i made safer and more ## how to use it: + **format construction:** ``` - kprint_format fmt= kprint_fgColor | kprint_fbgColor | kprint_fdataFmt | flags | kerepTypeId; + 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 kerepTypeId for other types + + 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 @@ -28,6 +28,6 @@ I don't really like printf function (and its variants), so i made safer and more should be sent as pointers ``` Maybe m=MaybeNull; - kprint(kprint_fgBlue | kprint_fmtString, "Maybe: ", kprint_fgGreen | kerepTypeId_MaybePtr, &m); + kprint(kprint_fgBlue | kprint_fmtString, "Maybe: ", kprint_fgGreen | ktId_MaybePtr, &m); ``` - output: Maybe: {value={0, kerepTypeId_Null}} \ No newline at end of file + output: Maybe: {value={0, ktId_Null}} \ No newline at end of file diff --git a/src/base/kprint/kprint.c b/src/base/kprint/kprint.c index fc89c72..3ef337a 100644 --- a/src/base/kprint/kprint.c +++ b/src/base/kprint/kprint.c @@ -7,20 +7,20 @@ Maybe __next_toString(kprint_format format, void* object){ case kprint_fmtInt: case kprint_fmtHex: case kprint_fmtBin: - format.typeId=kerepTypeId_Int64; break; + format.typeId=ktId_Int64; break; case kprint_fmtUInt: - format.typeId=kerepTypeId_UInt64; break; + format.typeId=ktId_UInt64; break; case kprint_fmtFloat: - format.typeId=kerepTypeId_Float64; break; + format.typeId=ktId_Float64; break; case kprint_fmtChar: - format.typeId=kerepTypeId_Char; break; + format.typeId=ktId_Char; break; case kprint_fmtString: - format.typeId=kerepTypeId_CharPtr; break; + format.typeId=ktId_CharPtr; break; default: safethrow("typeId is not set, can't autodetect type",;); } - try(kerepTypeDescriptor_get(format.typeId),mtd,;); - kerepTypeDescriptor typeDesc=*(kerepTypeDescriptor*)mtd.value.VoidPtr; + 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,;); @@ -34,7 +34,7 @@ Maybe __ksprint(uint8 n, kprint_format* formats, void** objects){ StringBuilder_append_cptr(strb, mStr.value.VoidPtr); } char* rezult=StringBuilder_build(strb).ptr; - return SUCCESS(UniHeap(kerepTypeId_CharPtr, rezult)); + return SUCCESS(UniHeap(ktId_CharPtr, rezult)); } Maybe __kfprint(FILE* file, uint8 n, kprint_format* formats, void** objects){ @@ -68,9 +68,9 @@ void kprint_setColor(kprint_format f){ -Maybe ksprint_ar(uint32 count, kprint_format format, kerepTypeId typeId, void* array){ - try(kerepTypeDescriptor_get(format.typeId),mtd,;); - kerepTypeDescriptor typeDesc=*(kerepTypeDescriptor*)mtd.value.VoidPtr; +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(); diff --git a/src/base/kprint/kprint_format.h b/src/base/kprint/kprint_format.h index 3fcfc68..1087c71 100644 --- a/src/base/kprint/kprint_format.h +++ b/src/base/kprint/kprint_format.h @@ -4,7 +4,7 @@ extern "C" { #endif -#include "../type_system/kerepTypeId.h" +#include "../type_system/ktId.h" typedef enum kprint_dataFormat{ // 00000000 00000000 00000000 00000000 @@ -39,7 +39,7 @@ typedef struct { unsigned char fgColor : 4; unsigned char bgColor : 4; unsigned char dataFmt : 4; - kerepTypeId typeId; + ktId typeId; } kprint_format; #if __cplusplus diff --git a/src/base/kprint/kprint_format.md b/src/base/kprint/kprint_format.md index 9d3da81..fcd4a95 100644 --- a/src/base/kprint/kprint_format.md +++ b/src/base/kprint/kprint_format.md @@ -2,7 +2,7 @@ ``` 00000000 00000000 00000000 00000000 -fgColorSet┘│││└┼┴┘ └┼┴┘└┴┴┤ kerepTypeId +fgColorSet┘│││└┼┴┘ └┼┴┘└┴┴┤ ktId bgColorSet─┘││ │ bgColor └data format prefix┬────┘│ └fgColor postfix └uppercase diff --git a/src/base/type_system/init.c b/src/base/type_system/init.c new file mode 100644 index 0000000..755756a --- /dev/null +++ b/src/base/type_system/init.c @@ -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); +} diff --git a/src/base/type_system/init.h b/src/base/type_system/init.h new file mode 100644 index 0000000..d08ef9d --- /dev/null +++ b/src/base/type_system/init.h @@ -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 \ No newline at end of file diff --git a/src/base/type_system/kerepTypeId.h b/src/base/type_system/kerepTypeId.h deleted file mode 100644 index 6f4f4af..0000000 --- a/src/base/type_system/kerepTypeId.h +++ /dev/null @@ -1,17 +0,0 @@ -#pragma once - -#if __cplusplus -extern "C" { -#endif - -#include "../std.h" -typedef uint16 kerepTypeId; - -#define kerepTypeId_declare(ID_VAR_NAME)\ - extern kerepTypeId ID_VAR_NAME -#define kerepTypeId_define(ID_VAR_NAME)\ - kerepTypeId ID_VAR_NAME=-1 - -#if __cplusplus -} -#endif \ No newline at end of file diff --git a/src/base/type_system/kerepTypeDescriptor.h b/src/base/type_system/ktDescriptor.h similarity index 77% rename from src/base/type_system/kerepTypeDescriptor.h rename to src/base/type_system/ktDescriptor.h index b402200..907d002 100644 --- a/src/base/type_system/kerepTypeDescriptor.h +++ b/src/base/type_system/ktDescriptor.h @@ -6,16 +6,16 @@ extern "C" { #include "../std.h" #include "../errors.h" -#include "kerepTypeId.h" +#include "ktId.h" -typedef struct kerepTypeDescriptor{ +typedef struct ktDescriptor{ char* name; - kerepTypeId id; + ktId id; uint16 size; void (*freeMembers)(void*); // NULL or function which frees all struct members ///@return Maybe Maybe (*toString)(void*, int32); // NULL or function which generates string representaion of object -} kerepTypeDescriptor; +} ktDescriptor; #if __cplusplus } diff --git a/src/base/type_system/ktId.h b/src/base/type_system/ktId.h new file mode 100644 index 0000000..8c37985 --- /dev/null +++ b/src/base/type_system/ktId.h @@ -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 \ No newline at end of file diff --git a/src/base/type_system/kt_functions.c b/src/base/type_system/kt_functions.c new file mode 100644 index 0000000..0bc4f7d --- /dev/null +++ b/src/base/type_system/kt_functions.c @@ -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])); +} diff --git a/src/base/type_system/kt_functions.h b/src/base/type_system/kt_functions.h new file mode 100644 index 0000000..2f13b74 --- /dev/null +++ b/src/base/type_system/kt_functions.h @@ -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 +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 \ No newline at end of file diff --git a/src/base/type_system/type_system.h b/src/base/type_system/type_system.h new file mode 100644 index 0000000..f685112 --- /dev/null +++ b/src/base/type_system/type_system.h @@ -0,0 +1,4 @@ + +#include "init.h" +#include "kt_functions.h" +#include "unitype.h" \ No newline at end of file diff --git a/src/base/type_system/types.c b/src/base/type_system/types.c deleted file mode 100644 index 82d2d6d..0000000 --- a/src/base/type_system/types.c +++ /dev/null @@ -1,76 +0,0 @@ -#include "../../Autoarr/Autoarr.h" -#include "types.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); - -kerepTypeId_define(kerepTypeId_kerepTypeDescriptor); -kerepTypeId_define(kerepTypeId_kerepTypeDescriptorPtr); - -// 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 (*freeMembers)(void*), Maybe (*toString)(void*, int32)){ - kerepTypeDescriptor typeDesc={ - .name=name, - .size=size, - .id=++kerepTypeId_last, - .freeMembers=freeMembers, - .toString=toString - }; - Autoarr_add(__kerepTypeDescriptors, typeDesc); -} - -Maybe kerepTypeDescriptor_get(kerepTypeId id){ - if(id>kerepTypeId_last) safethrow("invalid type id",;); - return SUCCESS(UniStack(kerepTypeId_kerepTypeDescriptorPtr, &typeDescriptors[id])); -} diff --git a/src/base/type_system/types.h b/src/base/type_system/types.h deleted file mode 100644 index 8cbaa6b..0000000 --- a/src/base/type_system/types.h +++ /dev/null @@ -1,59 +0,0 @@ -#pragma once - -#if __cplusplus -extern "C" { -#endif - -#include "../std.h" -#include "kerepTypeId.h" -#include "kerepTypeDescriptor.h" - - -extern kerepTypeId kerepTypeId_last; -void __kerepType_register(char* name, int16 size, void (*freeMembers)(void*), Maybe (*toString)(void*, int32)); - -#define kerepType_register(TYPE, ID_VAR_NAME, FREE_MEMBERS_FUNC, TO_STRING_FUNC)\ - __kerepType_register(#ID_VAR_NAME, sizeof(TYPE), FREE_MEMBERS_FUNC, TO_STRING_FUNC);\ - ID_VAR_NAME=kerepTypeId_last; - -void kerepTypeDescriptors_beginInit(); -void kerepTypeDescriptors_endInit(); -/// @param id id of registered type -/// @return Maybe -Maybe 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); - -kerepTypeId_declare(kerepTypeId_kerepTypeDescriptor); -kerepTypeId_declare(kerepTypeId_kerepTypeDescriptorPtr); - -#if __cplusplus -} -#endif \ No newline at end of file diff --git a/src/base/type_system/unitype.c b/src/base/type_system/unitype.c index 8b44641..f727fc7 100644 --- a/src/base/type_system/unitype.c +++ b/src/base/type_system/unitype.c @@ -1,11 +1,11 @@ #include "../base.h" -kerepTypeId_define(kerepTypeId_Unitype); -kerepTypeId_define(kerepTypeId_UnitypePtr); +ktId_define(ktId_Unitype); +ktId_define(ktId_UnitypePtr); void Unitype_free(Unitype u){ - tryLast(kerepTypeDescriptor_get(u.typeId), mType); - kerepTypeDescriptor type=*(kerepTypeDescriptor*)mType.value.VoidPtr; + tryLast(ktDescriptor_get(u.typeId), mType); + ktDescriptor type=*(ktDescriptor*)mType.value.VoidPtr; if(type.freeMembers) type.freeMembers(u.VoidPtr); if(u.allocatedInHeap) @@ -16,17 +16,17 @@ void __UnitypePtr_free(void* u) { Unitype_free(*(Unitype*)u); } #define BUFSIZE 64 char* sprintuni(Unitype v){ char* buf=malloc(BUFSIZE); - tryLast(kerepTypeDescriptor_get(v.typeId), mType); - kerepTypeDescriptor type=*(kerepTypeDescriptor*)mType.value.VoidPtr; - if(v.typeId==kerepTypeId_Null) + tryLast(ktDescriptor_get(v.typeId), mType); + ktDescriptor type=*(ktDescriptor*)mType.value.VoidPtr; + if(v.typeId==ktId_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); - 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); - else if(v.typeId==kerepTypeId_Int64) + else if(v.typeId==ktId_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; buf=realloc(buf, newBUFSIZE); sprintf_s(buf, BUFSIZE, "{%s : \"%s\"}", type.name,(char*)v.VoidPtr); diff --git a/src/base/type_system/unitype.h b/src/base/type_system/unitype.h index 9f28bf7..2fbbdf6 100644 --- a/src/base/type_system/unitype.h +++ b/src/base/type_system/unitype.h @@ -4,7 +4,7 @@ extern "C" { #endif -#include "kerepTypeId.h" +#include "ktId.h" typedef struct Unitype{ union { @@ -15,15 +15,15 @@ typedef struct Unitype{ void* VoidPtr; char Bytes[8]; }; - kerepTypeId typeId; + ktId typeId; bool allocatedInHeap; // should Unitype_free call free() to VoidPtr* } Unitype; -kerepTypeId_declare(kerepTypeId_Unitype); -kerepTypeId_declare(kerepTypeId_UnitypePtr); +ktId_declare(ktId_Unitype); +ktId_declare(ktId_UnitypePtr); #define __UniDef(TYPE, VAL) (Unitype){\ - .TYPE=VAL, .typeId=kerepTypeId_##TYPE, .allocatedInHeap=false} + .TYPE=VAL, .typeId=ktId_##TYPE, .allocatedInHeap=false} #define UniInt64(VAL) __UniDef(Int64, VAL) #define UniUInt64(VAL) __UniDef(UInt64, VAL) @@ -35,7 +35,7 @@ kerepTypeId_declare(kerepTypeId_UnitypePtr); #define UniHeap(ID_VAR_NAME, VAL) (Unitype){\ .VoidPtr=VAL, .typeId=ID_VAR_NAME, .allocatedInHeap=true} -#define UniNull UniStack(kerepTypeId_Null, NULL) +#define UniNull UniStack(ktId_Null, NULL) #define UniTrue UniBool(true) #define UniFalse UniBool(false) diff --git a/tests/main.cpp b/tests/main.cpp index 1f74e68..9136271 100644 --- a/tests/main.cpp +++ b/tests/main.cpp @@ -13,9 +13,9 @@ void test_all(){ int main(){ setlocale(LC_ALL, "en-US.Unicode"); - kerepTypeDescriptors_beginInit(); - kerepTypeDescriptors_initKerepTypes(); - kerepTypeDescriptors_endInit(); + ktDescriptors_beginInit(); + ktDescriptors_initKerepTypes(); + ktDescriptors_endInit(); printf("\e[97mkerep tests are starting!\n"); optime("test_all",1,test_all()); printf("\e[0m\n"); diff --git a/tests/test_dtsod.c b/tests/test_dtsod.c index f14c582..23ef429 100644 --- a/tests/test_dtsod.c +++ b/tests/test_dtsod.c @@ -18,7 +18,7 @@ void print_dtsod(Hashtable* dtsod){ printf("\e[92m"); Hashtable_foreach(dtsod, p,({ printkvp(p); - if(p.value.typeId==kerepTypeId_HashtablePtr){ + if(p.value.typeId==ktId_HashtablePtr){ printf(": {\n"); Hashtable* sub=p.value.VoidPtr; Hashtable_foreach(sub, _p,({ diff --git a/tests/test_marshalling.c b/tests/test_marshalling.c index 74e2129..1614c6c 100644 --- a/tests/test_marshalling.c +++ b/tests/test_marshalling.c @@ -4,7 +4,7 @@ EXPORT void CALL test_marshalling(char* text, KVPair** kptr){ KVPair* k=malloc(sizeof(KVPair)); k->key="message"; char* tc=cptr_copy(text); - Unitype u=UniHeap(kerepTypeId_CharPtr,tc); + Unitype u=UniHeap(ktId_CharPtr,tc); k->value=u; *kptr=k; } diff --git a/tests/test_searchtree.c b/tests/test_searchtree.c index c67e8fd..109c116 100644 --- a/tests/test_searchtree.c +++ b/tests/test_searchtree.c @@ -44,11 +44,11 @@ void test_searchtree(){ printuni(u); ST_push(node,"channel_id", u); printf(" -> channel_id\n "); - u=UniHeap(kerepTypeId_CharPtr, cptr_copy("32.2004")); + u=UniHeap(ktId_CharPtr, cptr_copy("32.2004")); printuni(u); ST_push(node,"message_id", u); printf(" -> message_id\n "); - u=UniStack(kerepTypeId_CharPtr,"some text UwU"); + u=UniStack(ktId_CharPtr,"some text UwU"); printuni(u); ST_push(node,"text", u); printf(" -> text\n");