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

fixed a lot of broken stuff

Browse Source
This commit is contained in:
timerix
2022-08-26 01:45:02 +06:00
parent d62405ccff
commit b627affbde
22 changed files with 380 additions and 238 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
src/Autoarr/Autoarr.h
View File

@@ -20,35 +20,35 @@ Autoarr_declare(uint32)
Autoarr_declare(int64)
Autoarr_declare(uint64)
kerepType_declare(AutoarrChar);
kerepType_declare(AutoarrBool);
kerepType_declare(AutoarrFloat32);
kerepType_declare(AutoarrFloat64);
kerepType_declare(AutoarrInt8);
kerepType_declare(AutoarrUInt8);
kerepType_declare(AutoarrInt16);
kerepType_declare(AutoarrUInt16);
kerepType_declare(AutoarrInt32);
kerepType_declare(AutoarrUInt32);
kerepType_declare(AutoarrInt64);
kerepType_declare(AutoarrUInt64);
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);
kerepType_declare(AutoarrCharPtr);
kerepType_declare(AutoarrBoolPtr);
kerepType_declare(AutoarrFloat32Ptr);
kerepType_declare(AutoarrFloat64Ptr);
kerepType_declare(AutoarrInt8Ptr);
kerepType_declare(AutoarrUInt8Ptr);
kerepType_declare(AutoarrInt16Ptr);
kerepType_declare(AutoarrUInt16Ptr);
kerepType_declare(AutoarrInt32Ptr);
kerepType_declare(AutoarrUInt32Ptr);
kerepType_declare(AutoarrInt64Ptr);
kerepType_declare(AutoarrUInt64Ptr);
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);
Autoarr_declare(Unitype)
kerepType_declare(AutoarrUnitype);
kerepType_declare(AutoarrUnitypePtr);
kerepTypeId_declare(kerepTypeId_AutoarrUnitype);
kerepTypeId_declare(kerepTypeId_AutoarrUnitypePtr);
// this function is injected in kerep_init()
void __Autoarr_free_Unitype_(Autoarr(Unitype)* ar, bool freePtr);

18
src/DtsodParser/DtsodV24_deserialize.c
View File

@@ -98,9 +98,9 @@ Maybe __ReadName(DeserializeSharedData* shared){
case '}':
if(!calledRecursively || nameStr.length!=0)
safethrow_wrongchar(c,;);
return SUCCESS(UniPtr(CharPtr,NULL));
return SUCCESS(UniPtrHeap(kerepTypeId_CharPtr,NULL));
case ':':
return SUCCESS(UniPtr(CharPtr,string_extract(nameStr)));
return SUCCESS(UniPtrHeap(kerepTypeId_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(UniPtr(CharPtr,NULL));
return SUCCESS(UniPtrHeap(kerepTypeId_CharPtr,NULL));
}
#define ReadName() __ReadName(shared)
@@ -137,7 +137,7 @@ Maybe __ReadString(DeserializeSharedData* shared){
}
else {
char* str=StringBuilder_build(b).ptr;
return SUCCESS(UniPtr(CharPtr,str));
return SUCCESS(UniPtrHeap(kerepTypeId_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.type==Null)
if(val.value.typeId==kerepTypeId_Null)
Autoarr_pop(list);
break;
}
}
return SUCCESS(UniPtr(AutoarrUnitypePtr,list));
return SUCCESS(UniPtrHeap(kerepTypeId_AutoarrUnitypePtr,list));
};
#define ReadList() __ReadList(shared)
@@ -275,7 +275,7 @@ Maybe __ReadValue(DeserializeSharedData* shared, bool* readingList){
case ';':
case ',':
if(valueStr.length!=0){
if(value.type!=Null)
if(value.typeId!=kerepTypeId_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,UniPtr(AutoarrUnitypePtr,list));
Hashtable_add(dict,nameCPtr,UniPtrHeap(kerepTypeId_AutoarrUnitypePtr,list));
}
Autoarr_add(list,val.value);
}
@@ -331,7 +331,7 @@ Maybe __deserialize(char** _text, bool _calledRecursively) {
END:
*_text=text;
return SUCCESS(UniPtr(HashtablePtr,dict));
return SUCCESS(UniPtrHeap(kerepTypeId_HashtablePtr,dict));
}
Maybe DtsodV24_deserialize(char* _text) {

147
src/DtsodParser/DtsodV24_serialize.c
View File

@@ -23,81 +23,78 @@ void __AppendTabs(SerializeSharedData* shared) {
Maybe __AppendValue(SerializeSharedData* shared, Unitype u);
#define AppendValue(UNI) __AppendValue(shared, UNI)
Maybe __AppendValue(SerializeSharedData* shared, Unitype u){
switch(u.type){
case Int64:
StringBuilder_append_int64(b,u.Int64);
break;
case UInt64:
StringBuilder_append_uint64(b,u.UInt64);
addc('u');
break;
case Float64:
StringBuilder_append_float64(b,u.Float64);
addc('f');
break;
case CharPtr:
addc('"');
char c;
while((c=*(char*)(u.VoidPtr++))){
if(c=='\"') addc('\\');
addc(c);
}
addc('"');
break;
case Bool:
StringBuilder_append_cptr(b, u.Bool ? "true" : "false");
break;
case Null:
safethrow("Null isn't supported in DtsodV24",;);
case AutoarrUnitypePtr:
if(Autoarr_length(((Autoarr_Unitype*)(u.VoidPtr)))){
addc('\n');
AppendTabs();
addc('[');
tabs++;
Autoarr_foreach(((Autoarr_Unitype*)(u.VoidPtr)), e, ({
addc('\n');
AppendTabs();
try(AppendValue(e),__,;);
addc(',');
}));
StringBuilder_rmchar(b);
addc('\n');
tabs--;
AppendTabs();
addc(']');
}
else {
addc('[');
addc(']');
}
break;
case HashtablePtr:
// check hashtable is blank
Hashtable_foreach(((Hashtable*)u.VoidPtr), __, ({
goto hashtableNotBlank;
if(__.key); // weird way to disable warning
}));
// blank hashtable
addc('{');
addc('}');
break;
// not blank hashtable
hashtableNotBlank:
addc('\n');
AppendTabs();
addc('{');
addc('\n');
try(__serialize(b,tabs+1,u.VoidPtr),___,;);
AppendTabs();
addc('}');
break;
default: dbg((u.type)); safethrow(ERR_WRONGTYPE,;);
if(u.typeId==kerepTypeId_Int64){
StringBuilder_append_int64(b,u.Int64);
}
else if(u.typeId==kerepTypeId_UInt64){
StringBuilder_append_uint64(b,u.UInt64);
addc('u');
}
else if(u.typeId==kerepTypeId_Float64){
StringBuilder_append_float64(b,u.Float64);
addc('f');
}
else if(u.typeId==kerepTypeId_CharPtr){
addc('"');
char c;
while((c=*(char*)(u.VoidPtr++))){
if(c=='\"') addc('\\');
addc(c);
}
addc('"');
}
else if(u.typeId==kerepTypeId_Bool){
StringBuilder_append_cptr(b, u.Bool ? "true" : "false");
}
else if(u.typeId==kerepTypeId_Null){
safethrow("Null isn't supported in DtsodV24",;);
}
else if(u.typeId==kerepTypeId_AutoarrUnitypePtr){
if(Autoarr_length(((Autoarr_Unitype*)(u.VoidPtr)))){
addc('\n');
AppendTabs();
addc('[');
tabs++;
Autoarr_foreach(((Autoarr_Unitype*)(u.VoidPtr)), e, ({
addc('\n');
AppendTabs();
try(AppendValue(e),__,;);
addc(',');
}));
StringBuilder_rmchar(b);
addc('\n');
tabs--;
AppendTabs();
addc(']');
}
else {
addc('[');
addc(']');
}
}
else if(u.typeId==kerepTypeId_HashtablePtr){
// check hashtable is blank
Hashtable_foreach(((Hashtable*)u.VoidPtr), __, ({
goto hashtableNotBlank;
if(__.key); // weird way to disable warning
}));
// blank hashtable
addc('{');
addc('}');
// not blank hashtable
hashtableNotBlank:
addc('\n');
AppendTabs();
addc('{');
addc('\n');
try(__serialize(b,tabs+1,u.VoidPtr),___,;);
AppendTabs();
addc('}');
}
else {
dbg((u.typeId));
safethrow(ERR_WRONGTYPE,;);
}
return MaybeNull;
};
@@ -125,5 +122,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(UniPtr(CharPtr, str));
return SUCCESS(UniPtrHeap(kerepTypeId_CharPtr, str));
}

2
src/Hashtable/Hashtable.c
View File

@@ -92,7 +92,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.type!=Null;
return u.typeId!=kerepTypeId_Null;
}
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]
Autoarr(KVPair)** rows; // Autoarr[height]
} Hashtable;
kerepType_declare(Hashtable);
kerepType_declare(HashtablePtr);
kerepTypeId_declare(kerepTypeId_Hashtable);
kerepTypeId_declare(kerepTypeId_HashtablePtr);
Hashtable* Hashtable_create();
void Hashtable_free(Hashtable* ht);

8
src/Hashtable/KeyValuePair.h
View File

@@ -11,12 +11,12 @@ typedef struct KVPair{
char* key;
Unitype value;
} KVPair;
kerepType_declare(KVPair);
kerepType_declare(KVPairPtr);
kerepTypeId_declare(kerepTypeId_KVPair);
kerepTypeId_declare(kerepTypeId_KVPairPtr);
Autoarr_declare(KVPair)
kerepType_declare(AutoarrKVPair);
kerepType_declare(AutoarrKVPairPtr);
kerepTypeId_declare(kerepTypeId_AutoarrKVPair);
kerepTypeId_declare(kerepTypeId_AutoarrKVPairPtr);
// proper way to clear a KVP
void KVPair_free(KVPair p);

2
src/SearchTree/SearchTree.c
View File

@@ -3,7 +3,7 @@
STNode* STNode_create(){
STNode* node=malloc(sizeof(STNode));
node->branches=NULL;
node->value.type=Null;
node->value.typeId=kerepTypeId_Null;
node->value.UInt64=0;
return node;
}

4
src/SearchTree/SearchTree.h
View File

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

4
src/String/StringBuilder.h
View File

@@ -13,8 +13,8 @@ typedef struct StringBuilder{
Autoarr(string)* compl_bufs;
Autoarr(int8)* curr_buf;
} StringBuilder;
kerepType_declare(StringBuilder);
kerepType_declare(StringBuilderPtr);
kerepTypeId_declare(kerepTypeId_StringBuilder);
kerepTypeId_declare(kerepTypeId_StringBuilderPtr);
StringBuilder* StringBuilder_create(void);
void StringBuilder_free(StringBuilder* b);

126
src/base/init.c
View File

@@ -6,90 +6,90 @@
void kerepTypeDescriptors_initKerepTypes(){
// null
kerepType_register(NULL, Null, NULL);
kerepType_register(NULL, kerepTypeId_Null, NULL);
// base types
kerepType_register(char, Char, NULL);
kerepType_register(bool, Bool, NULL);
kerepType_register(float32, Float32, NULL);
kerepType_register(float64, Float64, NULL);
kerepType_register(int8, Int8, NULL);
kerepType_register(uint8, UInt8, NULL);
kerepType_register(int16, Int16, NULL);
kerepType_register(uint16, UInt16, NULL);
kerepType_register(int32, Int32, NULL);
kerepType_register(uint32, UInt32, NULL);
kerepType_register(int64, Int64, NULL);
kerepType_register(uint64, UInt64, NULL);
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*, CharPtr, NULL);
kerepType_register(bool*, BoolPtr, NULL);
kerepType_register(float32*, Float32Ptr, NULL);
kerepType_register(float64*, Float64Ptr, NULL);
kerepType_register(int8*, Int8Ptr, NULL);
kerepType_register(uint8*, UInt8Ptr, NULL);
kerepType_register(int16*, Int16Ptr, NULL);
kerepType_register(uint16*, UInt16Ptr, NULL);
kerepType_register(int32*, Int32Ptr, NULL);
kerepType_register(uint32*, UInt32Ptr, NULL);
kerepType_register(int64*, Int64Ptr, NULL);
kerepType_register(uint64*, UInt64Ptr, NULL);
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, AutoarrChar, ____Autoarr_free_char);
kerepType_register(Autoarr_bool, AutoarrBool, ____Autoarr_free_bool);
kerepType_register(Autoarr_float32, AutoarrFloat32, ____Autoarr_free_float32);
kerepType_register(Autoarr_float64, AutoarrFloat64, ____Autoarr_free_float64);
kerepType_register(Autoarr_int8, AutoarrInt8, ____Autoarr_free_int8);
kerepType_register(Autoarr_uint8, AutoarrUInt8, ____Autoarr_free_uint8);
kerepType_register(Autoarr_int16, AutoarrInt16, ____Autoarr_free_int16);
kerepType_register(Autoarr_uint16, AutoarrUInt16, ____Autoarr_free_uint16);
kerepType_register(Autoarr_int32, AutoarrInt32, ____Autoarr_free_int32);
kerepType_register(Autoarr_uint32, AutoarrUInt32, ____Autoarr_free_uint32);
kerepType_register(Autoarr_int64, AutoarrInt64, ____Autoarr_free_int64);
kerepType_register(Autoarr_uint64, AutoarrUInt64, ____Autoarr_free_uint64);
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*, AutoarrCharPtr, ____Autoarr_free_char);
kerepType_register(Autoarr_bool*, AutoarrBoolPtr, ____Autoarr_free_bool);
kerepType_register(Autoarr_float32*, AutoarrFloat32Ptr, ____Autoarr_free_float32);
kerepType_register(Autoarr_float64*, AutoarrFloat64Ptr, ____Autoarr_free_float64);
kerepType_register(Autoarr_int8*, AutoarrInt8Ptr, ____Autoarr_free_int8);
kerepType_register(Autoarr_uint8*, AutoarrUInt8Ptr, ____Autoarr_free_uint8);
kerepType_register(Autoarr_int16*, AutoarrInt16Ptr, ____Autoarr_free_int16);
kerepType_register(Autoarr_uint16*, AutoarrUInt16Ptr, ____Autoarr_free_uint16);
kerepType_register(Autoarr_int32*, AutoarrInt32Ptr, ____Autoarr_free_int32);
kerepType_register(Autoarr_uint32*, AutoarrUInt32Ptr, ____Autoarr_free_uint32);
kerepType_register(Autoarr_int64*, AutoarrInt64Ptr, ____Autoarr_free_int64);
kerepType_register(Autoarr_uint64*, AutoarrUInt64Ptr, ____Autoarr_free_uint64);
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, Unitype, __UnitypePtr_free);
kerepType_register(Unitype*, UnitypePtr, __UnitypePtr_free);
kerepType_register(Autoarr_Unitype, AutoarrUnitype, ____Autoarr_free_Unitype_);
kerepType_register(Autoarr_Unitype*, AutoarrUnitypePtr, ____Autoarr_free_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, STNode, __STNode_free);
kerepType_register(STNode*, STNodePtr, __STNode_free);
kerepType_register(STNode, kerepTypeId_STNode, __STNode_free);
kerepType_register(STNode*, kerepTypeId_STNodePtr, __STNode_free);
// KeyValuePair
kerepType_register(KVPair, KVPair, __KVPair_free);
kerepType_register(KVPair*, KVPairPtr, __KVPair_free);
kerepType_register(Autoarr_KVPair, AutoarrKVPair, ____Autoarr_free_KVPair_);
kerepType_register(Autoarr_KVPair*, AutoarrKVPairPtr, ____Autoarr_free_KVPair_);
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, Hashtable, __Hashtable_free);
kerepType_register(Hashtable*, HashtablePtr, __Hashtable_free);
kerepType_register(Hashtable, kerepTypeId_Hashtable, __Hashtable_free);
kerepType_register(Hashtable*, kerepTypeId_HashtablePtr, __Hashtable_free);
// StringBuilder
kerepType_register(StringBuilder, StringBuilder, __StringBuilder_free);
kerepType_register(StringBuilder*, StringBuilderPtr, __StringBuilder_free);
kerepType_register(StringBuilder, kerepTypeId_StringBuilder, __StringBuilder_free);
kerepType_register(StringBuilder*, kerepTypeId_StringBuilderPtr, __StringBuilder_free);
}

62
src/base/types.h
View File

@@ -15,47 +15,49 @@ typedef struct kerepTypeDescriptor{
uint16 size;
} kerepTypeDescriptor;
#define kerepType_declare(NAME)\
extern kerepTypeId kerepTypeId_##NAME
#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, NAME, FREE_MEMBERS_FUNC)\
__kerepType_register(#NAME, sizeof(TYPE), FREE_MEMBERS_FUNC);\
kerepTypeId_##NAME=kerepTypeId_last;
#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);
kerepType_declare(Null);
kerepTypeId_declare(kerepTypeId_Null);
kerepType_declare(Char);
kerepType_declare(Bool);
kerepType_declare(Float32);
kerepType_declare(Float64);
kerepType_declare(Int8);
kerepType_declare(UInt8);
kerepType_declare(Int16);
kerepType_declare(UInt16);
kerepType_declare(Int32);
kerepType_declare(UInt32);
kerepType_declare(Int64);
kerepType_declare(UInt64);
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);
kerepType_declare(CharPtr);
kerepType_declare(BoolPtr);
kerepType_declare(Float32Ptr);
kerepType_declare(Float64Ptr);
kerepType_declare(Int8Ptr);
kerepType_declare(UInt8Ptr);
kerepType_declare(Int16Ptr);
kerepType_declare(UInt16Ptr);
kerepType_declare(Int32Ptr);
kerepType_declare(UInt32Ptr);
kerepType_declare(Int64Ptr);
kerepType_declare(UInt64Ptr);
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
}

26
src/base/unitype.h
View File

@@ -18,24 +18,24 @@ typedef struct Unitype{
kerepTypeId typeId;
bool allocatedInHeap; // should Unitype_free call free() to VoidPtr*
} Unitype;
kerepType_declare(Unitype);
kerepType_declare(UnitypePtr);
kerepTypeId_declare(kerepTypeId_Unitype);
kerepTypeId_declare(kerepTypeId_UnitypePtr);
#define __Uni(TYPE,VAL) (Unitype){\
.TYPE_NAME=VAL, .typeId=kerepTypeId_##TYPE, .allocatedInHeap=false}
#define Uni(TYPE, VAL) (Unitype){\
.TYPE=VAL, .typeId=kerepTypeId_##TYPE, .allocatedInHeap=false}
#define UniInt64(VAL) __Uni(Int64, VAL)
#define UniUInt64(VAL) __Uni(UInt64, VAL)
#define UniFloat64(VAL) __Uni(Float64, VAL)
#define UniBool(VAL) __Uni(Bool, VAL)
#define UniInt64(VAL) Uni(Int64, VAL)
#define UniUInt64(VAL) Uni(UInt64, VAL)
#define UniFloat64(VAL) Uni(Float64, VAL)
#define UniBool(VAL) Uni(Bool, VAL)
#define UniPtrStack(TYPE_NAME,VAL) (Unitype){\
.VoidPtr=VAL, .typeId=kerepTypeId_##TYPE_NAME, .allocatedInHeap=false}
#define UniPtrHeap (TYPE_NAME,VAL) (Unitype){\
.VoidPtr=VAL, .typeId=kerepTypeId_##TYPE_NAME, .allocatedInHeap=true}
#define UniPtrStack(ID_VAR_NAME, VAL) (Unitype){\
.VoidPtr=VAL, .typeId=ID_VAR_NAME, .allocatedInHeap=false}
#define UniPtrHeap(ID_VAR_NAME, VAL) (Unitype){\
.VoidPtr=VAL, .typeId=ID_VAR_NAME, .allocatedInHeap=true}
#define UniNull UniPtrStack(Null, NULL)
#define UniNull UniPtrStack(kerepTypeId_Null, NULL)
#define UniTrue UniBool(true)
#define UniFalse UniBool(false)