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

Autoarr2 renamed to Autoarr

Browse Source
This commit is contained in:
Timerix22 2022-03-02 22:30:56 +03:00
parent 83f4a1775e
commit 9776a2c423
21 changed files with 225 additions and 225 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
DtsodC/src/Autoarr/Autoarr.c Normal file
View File

@ -0,0 +1,23 @@
#include "Autoarr.h"
define_Autoarr(uint8)
define_Autoarr(int8)
define_Autoarr(uint16)
define_Autoarr(int16)
define_Autoarr(uint32)
define_Autoarr(int32)
define_Autoarr(uint64)
define_Autoarr(int64)
define_Autoarr(float)
define_Autoarr(double)
define_Autoarr(Unitype)
//right func to clear array of unitype values
void Autoarr_Unitype_clear(Autoarr(Unitype)* ar){
for(uint32 blockI=0;blockI<ar->blocks_count-1;blockI++)
for(uint32 elemI=0;elemI<ar->max_block_length;elemI++)
Unitype_free(ar->values[blockI][elemI]);
for(uint32 elemI=0;elemI<ar->block_length;elemI++)
Unitype_free(ar->values[ar->blocks_count-1][elemI]);
Autoarr_clear(ar);
}

19
DtsodC/src/Autoarr/Autoarr.h Normal file
View File

@ -0,0 +1,19 @@
#pragma once
#include "Autoarr_declare.h"
#include "Autoarr_define.h"
declare_Autoarr(uint8)
declare_Autoarr(int8)
declare_Autoarr(uint16)
declare_Autoarr(int16)
declare_Autoarr(uint32)
declare_Autoarr(int32)
declare_Autoarr(uint64)
declare_Autoarr(int64)
declare_Autoarr(float)
declare_Autoarr(double)
declare_Autoarr(Unitype)
//right func to clear array of unitype values
void Autoarr_Unitype_clear(Autoarr(Unitype)* ar);

23
DtsodC/src/Autoarr/Autoarr2.c
View File

@ -1,23 +0,0 @@
#include "Autoarr2.h"
define_Autoarr2(uint8)
define_Autoarr2(int8)
define_Autoarr2(uint16)
define_Autoarr2(int16)
define_Autoarr2(uint32)
define_Autoarr2(int32)
define_Autoarr2(uint64)
define_Autoarr2(int64)
define_Autoarr2(float)
define_Autoarr2(double)
define_Autoarr2(Unitype)
//right func to clear array of unitype values
void Autoarr2_Unitype_clear(Autoarr2(Unitype)* ar){
for(uint32 blockI=0;blockI<ar->blocks_count-1;blockI++)
for(uint32 elemI=0;elemI<ar->max_block_length;elemI++)
Unitype_free(ar->values[blockI][elemI]);
for(uint32 elemI=0;elemI<ar->block_length;elemI++)
Unitype_free(ar->values[ar->blocks_count-1][elemI]);
Autoarr2_clear(ar);
}

19
DtsodC/src/Autoarr/Autoarr2.h
View File

@ -1,19 +0,0 @@
#pragma once
#include "Autoarr2_declare.h"
#include "Autoarr2_define.h"
declare_Autoarr2(uint8)
declare_Autoarr2(int8)
declare_Autoarr2(uint16)
declare_Autoarr2(int16)
declare_Autoarr2(uint32)
declare_Autoarr2(int32)
declare_Autoarr2(uint64)
declare_Autoarr2(int64)
declare_Autoarr2(float)
declare_Autoarr2(double)
declare_Autoarr2(Unitype)
//right func to clear array of unitype values
void Autoarr2_Unitype_clear(Autoarr2(Unitype)* ar);

52
DtsodC/src/Autoarr/Autoarr2_declare.h
View File

@ -1,52 +0,0 @@
#pragma once
#include "../base/base.h"
#define declare_Autoarr2(type)\
\
struct Autoarr2_##type;\
\
typedef struct {\
void (*add)(struct Autoarr2_##type* ar, type element);\
type (*get)(struct Autoarr2_##type* ar, uint32 index);\
type* (*getptr)(struct Autoarr2_##type* ar, uint32 index);\
void (*set)(struct Autoarr2_##type* ar, uint32 index, type element);\
void (*clear)(struct Autoarr2_##type* ar);\
} __functions_list_t_##type;\
\
typedef struct Autoarr2_##type{\
uint16 blocks_count;\
uint16 max_blocks_count;\
uint16 block_length;\
uint16 max_block_length;\
type** values;\
__functions_list_t_##type* functions;\
} Autoarr2_##type;\
\
void __Autoarr2_add_##type(Autoarr2_##type* ar, type element);\
type __Autoarr2_get_##type(Autoarr2_##type* ar, uint32 index);\
type* __Autoarr2_getptr_##type(Autoarr2_##type* ar, uint32 index);\
void __Autoarr2_set_##type(Autoarr2_##type* ar, uint32 index, type element);\
void __Autoarr2_clear_##type(Autoarr2_##type* ar);\
Autoarr2_##type __Autoarr2_create_##type(uint16 max_blocks_count, uint16 max_block_length);
#define Autoarr2(type) Autoarr2_##type
#define Autoarr2_add(autoarr, element)\
autoarr->functions->add(autoarr, element)
#define Autoarr2_get(autoarr, index)\
autoarr->functions->get(autoarr,index)
#define Autoarr2_getptr(autoarr, index)\
autoarr->functions->getptr(autoarr,index)
#define Autoarr2_set(autoarr, index, element)\
autoarr->functions->set(autoarr, index, element)
#define Autoarr2_clear(autoarr)\
autoarr->functions->clear(autoarr)
#define Autoarr2_create(type, max_blocks_count, max_block_length)\
__Autoarr2_create_##type(max_blocks_count, max_block_length)
#define Autoarr2_length(autoarr) \
(uint32)(!autoarr->blocks_count ? 0 : \
autoarr->max_block_length*(autoarr->blocks_count-1)+autoarr->block_length)
#define Autoarr2_max_length(autoarr)\
(uint32)(autoarr->max_block_length*autoarr->max_blocks_count)

52
DtsodC/src/Autoarr/Autoarr_declare.h Normal file
View File

@ -0,0 +1,52 @@
#pragma once
#include "../base/base.h"
#define declare_Autoarr(type)\
\
struct Autoarr_##type;\
\
typedef struct {\
void (*add)(struct Autoarr_##type* ar, type element);\
type (*get)(struct Autoarr_##type* ar, uint32 index);\
type* (*getptr)(struct Autoarr_##type* ar, uint32 index);\
void (*set)(struct Autoarr_##type* ar, uint32 index, type element);\
void (*clear)(struct Autoarr_##type* ar);\
} __functions_list_t_##type;\
\
typedef struct Autoarr_##type{\
uint16 blocks_count;\
uint16 max_blocks_count;\
uint16 block_length;\
uint16 max_block_length;\
type** values;\
__functions_list_t_##type* functions;\
} Autoarr_##type;\
\
void __Autoarr_add_##type(Autoarr_##type* ar, type element);\
type __Autoarr_get_##type(Autoarr_##type* ar, uint32 index);\
type* __Autoarr_getptr_##type(Autoarr_##type* ar, uint32 index);\
void __Autoarr_set_##type(Autoarr_##type* ar, uint32 index, type element);\
void __Autoarr_clear_##type(Autoarr_##type* ar);\
Autoarr_##type __Autoarr_create_##type(uint16 max_blocks_count, uint16 max_block_length);
#define Autoarr(type) Autoarr_##type
#define Autoarr_add(autoarr, element)\
autoarr->functions->add(autoarr, element)
#define Autoarr_get(autoarr, index)\
autoarr->functions->get(autoarr,index)
#define Autoarr_getptr(autoarr, index)\
autoarr->functions->getptr(autoarr,index)
#define Autoarr_set(autoarr, index, element)\
autoarr->functions->set(autoarr, index, element)
#define Autoarr_clear(autoarr)\
autoarr->functions->clear(autoarr)
#define Autoarr_create(type, max_blocks_count, max_block_length)\
__Autoarr_create_##type(max_blocks_count, max_block_length)
#define Autoarr_length(autoarr) \
(uint32)(!autoarr->blocks_count ? 0 : \
autoarr->max_block_length*(autoarr->blocks_count-1)+autoarr->block_length)
#define Autoarr_max_length(autoarr)\
(uint32)(autoarr->max_block_length*autoarr->max_blocks_count)

32
DtsodC/src/Autoarr/Autoarr2_define.h → DtsodC/src/Autoarr/Autoarr_define.h
View File

@ -2,9 +2,9 @@
#include "../base/base.h"
#define define_Autoarr2(type)\
#define define_Autoarr(type)\
\
void __Autoarr2_add_##type(Autoarr2_##type* ar, type element){\
void __Autoarr_add_##type(Autoarr_##type* ar, type element){\
if(!ar->values){\
ar->values=malloc(ar->max_blocks_count*sizeof(type*));\
goto create_block;\
@ -20,22 +20,22 @@ create_block:\
ar->block_length++;\
}\
\
type __Autoarr2_get_##type(Autoarr2_##type* ar, uint32 index){\
if(index>=Autoarr2_length(ar)) throw(ERR_WRONGINDEX);\
type __Autoarr_get_##type(Autoarr_##type* ar, uint32 index){\
if(index>=Autoarr_length(ar)) throw(ERR_WRONGINDEX);\
return ar->values[index/ar->max_block_length][index%ar->max_block_length];\
}\
\
type* __Autoarr2_getptr_##type(Autoarr2_##type* ar, uint32 index){\
if(index>=Autoarr2_length(ar)) throw(ERR_WRONGINDEX);\
type* __Autoarr_getptr_##type(Autoarr_##type* ar, uint32 index){\
if(index>=Autoarr_length(ar)) throw(ERR_WRONGINDEX);\
return ar->values[index/ar->max_block_length]+(index%ar->max_block_length);\
}\
\
void __Autoarr2_set_##type(Autoarr2_##type* ar, uint32 index, type element){\
if(index>=Autoarr2_length(ar)) throw(ERR_WRONGINDEX);\
void __Autoarr_set_##type(Autoarr_##type* ar, uint32 index, type element){\
if(index>=Autoarr_length(ar)) throw(ERR_WRONGINDEX);\
ar->values[index/ar->max_block_length][index%ar->max_block_length]=element;\
}\
\
void __Autoarr2_clear_##type(Autoarr2_##type* ar){\
void __Autoarr_clear_##type(Autoarr_##type* ar){\
for(uint16 i=0; i<ar->blocks_count;i++)\
free(ar->values[i]); \
free(ar->values);\
@ -45,15 +45,15 @@ void __Autoarr2_clear_##type(Autoarr2_##type* ar){\
}\
\
__functions_list_t_##type __functions_list_##type={\
&__Autoarr2_add_##type,\
&__Autoarr2_get_##type,\
&__Autoarr2_getptr_##type,\
&__Autoarr2_set_##type,\
&__Autoarr2_clear_##type\
&__Autoarr_add_##type,\
&__Autoarr_get_##type,\
&__Autoarr_getptr_##type,\
&__Autoarr_set_##type,\
&__Autoarr_clear_##type\
};\
\
Autoarr2_##type __Autoarr2_create_##type(uint16 max_blocks_count, uint16 max_block_length){\
return (Autoarr2_##type){\
Autoarr_##type __Autoarr_create_##type(uint16 max_blocks_count, uint16 max_block_length){\
return (Autoarr_##type){\
.max_blocks_count=max_blocks_count,\
.blocks_count=0,\
.max_block_length=max_block_length,\

10
DtsodC/src/Autoarr/StringBuilder.c
View File

@ -1,24 +1,24 @@
#include "StringBuilder.h"
StringBuilder StringBuilder_create(uint16 max_blocks_count, uint16 max_block_length){
return Autoarr2_create(int8,max_blocks_count,max_block_length);
return Autoarr_create(int8,max_blocks_count,max_block_length);
}
void StringBuilder_append(StringBuilder* b, char c){
Autoarr2_add(b,c);
Autoarr_add(b,c);
}
void StringBuilder_append_str(StringBuilder* b, char* s){
char c;
while((c=*s++))
Autoarr2_add(b,c);
Autoarr_add(b,c);
}
char* StringBuilder_build(StringBuilder* b){
uint32 len=Autoarr2_length(b);
uint32 len=Autoarr_length(b);
char* str=malloc(len+1);
str[len]=0;
for(uint32 i=0;i<len;i++)
str[i]=Autoarr2_get(b,i);
str[i]=Autoarr_get(b,i);
return str;
}

4
DtsodC/src/Autoarr/StringBuilder.h
View File

@ -1,8 +1,8 @@
#pragma once
#include "Autoarr2.h"
#include "Autoarr.h"
typedef Autoarr2(int8) StringBuilder;
typedef Autoarr(int8) StringBuilder;
StringBuilder StringBuilder_create(uint16 max_blocks_count, uint16 max_block_length);
void StringBuilder_append(StringBuilder* b, char c);

18
DtsodC/src/DtsodParser/DtsodV24.c
View File

@ -85,12 +85,12 @@ Hashtable* __deserialize(char** _text, bool calledRecursively){
return str;
};
Autoarr2(Unitype)* ReadList(){
Autoarr2(Unitype)* list=malloc(sizeof(Autoarr2(Unitype)));
*list=Autoarr2_create(Unitype,ARR_BC,ARR_BL);
Autoarr(Unitype)* ReadList(){
Autoarr(Unitype)* list=malloc(sizeof(Autoarr(Unitype)));
*list=Autoarr_create(Unitype,ARR_BC,ARR_BL);
readingList=true;
while (true){
Autoarr2_add(list,ReadValue());
Autoarr_add(list,ReadValue());
if (!readingList) break;
}
return list;
@ -212,17 +212,17 @@ Hashtable* __deserialize(char** _text, bool calledRecursively){
char* nameCPtr=string_cpToCharPtr(name);
Unitype value=ReadValue();
if(partOfDollarList){
Autoarr2(Unitype)* list;
Autoarr(Unitype)* list;
Unitype lu;
if(Hashtable_try_get(dict,nameCPtr, &lu)){
list=(Autoarr2(Unitype)*)lu.VoidPtr;
list=(Autoarr(Unitype)*)lu.VoidPtr;
}
else{
list=malloc(sizeof(Autoarr2(Unitype)));
*list=Autoarr2_create(Unitype,ARR_BC,ARR_BL);
list=malloc(sizeof(Autoarr(Unitype)));
*list=Autoarr_create(Unitype,ARR_BC,ARR_BL);
Hashtable_add(dict,nameCPtr,UniPtr(AutoarrUnitypePtr,list));
}
Autoarr2_add(list,value);
Autoarr_add(list,value);
}
else Hashtable_add(dict,nameCPtr,value);
}

42
DtsodC/src/Hashtable/Hashtable.c
View File

@ -11,15 +11,15 @@ static const uint16 HT_HEIGHTS[]={61,257,1021,4099,16381,65521};
Hashtable* Hashtable_create(){
Hashtable* ht=malloc(sizeof(Hashtable));
ht->hein=HT_HEIN_MIN;
ht->rows=malloc(HT_HEIGHTS[HT_HEIN_MIN]*sizeof(Autoarr2(KeyValuePair)));
ht->rows=malloc(HT_HEIGHTS[HT_HEIN_MIN]*sizeof(Autoarr(KeyValuePair)));
for(uint16 i=0;i<HT_HEIGHTS[HT_HEIN_MIN];i++)
ht->rows[i]=Autoarr2_create(KeyValuePair,ARR_BC,ARR_BL);
ht->rows[i]=Autoarr_create(KeyValuePair,ARR_BC,ARR_BL);
return ht;
}
void Hashtable_free(Hashtable* ht){
for(uint16 i=0;i<HT_HEIGHTS[ht->hein];i++){
Autoarr2_KeyValuePair_clear(ht->rows+i);
Autoarr_KeyValuePair_clear(ht->rows+i);
}
free(ht->rows);
free(ht);
@ -30,27 +30,27 @@ uint32 Hashtable_height(Hashtable* ht){ return HT_HEIGHTS[ht->hein]; }
void Hashtable_expand(Hashtable* ht){
if(ht->hein>=HT_HEIN_MAX) throw(ERR_MAXLENGTH);
Autoarr2(KeyValuePair)* newrows=malloc(HT_HEIGHTS[++ht->hein]*sizeof(Autoarr2(KeyValuePair)));
Autoarr(KeyValuePair)* newrows=malloc(HT_HEIGHTS[++ht->hein]*sizeof(Autoarr(KeyValuePair)));
for(uint16 i=0;i<HT_HEIGHTS[ht->hein];i++)
newrows[i]=Autoarr2_create(KeyValuePair,ARR_BC,ARR_BL);
newrows[i]=Autoarr_create(KeyValuePair,ARR_BC,ARR_BL);
for(uint16 i=0;i<HT_HEIGHTS[ht->hein-1];i++){
Autoarr2(KeyValuePair)* ar=ht->rows+i;
uint32 arlen=Autoarr2_length(ar);
Autoarr(KeyValuePair)* ar=ht->rows+i;
uint32 arlen=Autoarr_length(ar);
for(uint16 k=0;k<arlen;k++){
KeyValuePair p=Autoarr2_get(ar,k);
KeyValuePair p=Autoarr_get(ar,k);
uint16 newrown=ihash(p.key)%HT_HEIGHTS[ht->hein];
Autoarr2(KeyValuePair)* newar=newrows+newrown;
Autoarr2_add(newar,p);
Autoarr(KeyValuePair)* newar=newrows+newrown;
Autoarr_add(newar,p);
}
Autoarr2_clear(ar);
Autoarr_clear(ar);
}
free(ht->rows);
ht->rows=newrows;
}
Autoarr2(KeyValuePair)* getrow(Hashtable* ht, char* key, bool can_expand){
Autoarr2(KeyValuePair)* ar=ht->rows+ihash(key)%HT_HEIGHTS[ht->hein];
if(can_expand && Autoarr2_length(ar)==Autoarr2_max_length(ar))
Autoarr(KeyValuePair)* getrow(Hashtable* ht, char* key, bool can_expand){
Autoarr(KeyValuePair)* ar=ht->rows+ihash(key)%HT_HEIGHTS[ht->hein];
if(can_expand && Autoarr_length(ar)==Autoarr_max_length(ar))
optime("expand",1,(Hashtable_expand(ht)));
ar=ht->rows+ihash(key)%HT_HEIGHTS[ht->hein];
return ar;
@ -58,7 +58,7 @@ Autoarr2(KeyValuePair)* getrow(Hashtable* ht, char* key, bool can_expand){
void Hashtable_add_pair(Hashtable* ht, KeyValuePair p){
Autoarr2_add(getrow(ht,p.key,true),p);
Autoarr_add(getrow(ht,p.key,true),p);
}
void Hashtable_add(Hashtable* ht, char* key, Unitype u){
Hashtable_add_pair(ht,KVPair(key,u));
@ -66,20 +66,20 @@ void Hashtable_add(Hashtable* ht, char* key, Unitype u){
//returns null or pointer to value in hashtable
Unitype* Hashtable_getptr(Hashtable* ht, char* key){
Autoarr2(KeyValuePair)* ar=getrow(ht,key,false);
uint32 arlen=Autoarr2_length(ar);
Autoarr(KeyValuePair)* ar=getrow(ht,key,false);
uint32 arlen=Autoarr_length(ar);
for(uint32 i=0;i<arlen;i++){
KeyValuePair* p=Autoarr2_getptr(ar,i);
KeyValuePair* p=Autoarr_getptr(ar,i);
if(charbuf_compare(key,p->key)) return &p->value;
}
return NULL;
}
Unitype Hashtable_get(Hashtable* ht, char* key){
Autoarr2(KeyValuePair)* ar=getrow(ht,key,false);
uint32 arlen=Autoarr2_length(ar);
Autoarr(KeyValuePair)* ar=getrow(ht,key,false);
uint32 arlen=Autoarr_length(ar);
for(uint32 i=0;i<arlen;i++){
KeyValuePair p=Autoarr2_get(ar,i);
KeyValuePair p=Autoarr_get(ar,i);
if(charbuf_compare(key,p.key)) return p.value;
}
return UniNull;

2
DtsodC/src/Hashtable/Hashtable.h
View File

@ -6,7 +6,7 @@
typedef struct Hashtable{
uint8 hein; //height=HT_HEIGHTS[hein]
Autoarr2(KeyValuePair)* rows; // Autoarr[height]
Autoarr(KeyValuePair)* rows; // Autoarr[height]
} Hashtable;
Hashtable* Hashtable_create();

6
DtsodC/src/Hashtable/KeyValuePair.c
View File

@ -1,6 +1,6 @@
#include "KeyValuePair.h"
define_Autoarr2(KeyValuePair)
define_Autoarr(KeyValuePair)
//proper way to clear a KVP
@ -10,11 +10,11 @@ void KeyValuePair_free(KeyValuePair p){
}
//func for KVP array clearing
void Autoarr2_KeyValuePair_clear(Autoarr2_KeyValuePair* ar){
void Autoarr_KeyValuePair_clear(Autoarr_KeyValuePair* ar){
for(uint16 blockI=0; blockI < ar->blocks_count-1; blockI++)
for(uint16 elemI=0; elemI < ar->max_block_length; elemI++)
KeyValuePair_free(ar->values[blockI][elemI]);
for(uint16 elemI=0; elemI < ar->block_length; elemI++)
KeyValuePair_free(ar->values[ar->blocks_count-1][elemI]);
Autoarr2_clear(ar);
Autoarr_clear(ar);
}

6
DtsodC/src/Hashtable/KeyValuePair.h
View File

@ -1,15 +1,15 @@
#include "../base/base.h"
#include "../Autoarr/Autoarr2.h"
#include "../Autoarr/Autoarr.h"
typedef struct KeyValuePair{
char* key;
Unitype value;
} KeyValuePair;
declare_Autoarr2(KeyValuePair)
declare_Autoarr(KeyValuePair)
//proper way to clear a KVP
void KeyValuePair_free(KeyValuePair p);
//func to clear KVP array
void Autoarr2_KeyValuePair_clear(Autoarr2_KeyValuePair* ar);
void Autoarr_KeyValuePair_clear(Autoarr_KeyValuePair* ar);

26
DtsodC/src/base/types.c
View File

@ -1,6 +1,6 @@
#include "types.h"
#include "errors.h"
#include "../Autoarr/Autoarr2.h"
#include "../Autoarr/Autoarr.h"
#include "../Hashtable/Hashtable.h"
#include "../SearchTree/SearchTree.h"
@ -80,36 +80,36 @@ void Unitype_free(Unitype u){
STNode_free(u.VoidPtr);
break;
case AutoarrInt8Ptr:
Autoarr2_clear(((Autoarr2(int8)*)u.VoidPtr));
Autoarr_clear(((Autoarr(int8)*)u.VoidPtr));
break;
case AutoarrUInt8Ptr:
Autoarr2_clear(((Autoarr2(uint8)*)u.VoidPtr));
Autoarr_clear(((Autoarr(uint8)*)u.VoidPtr));
break;
case AutoarrInt16Ptr:
Autoarr2_clear(((Autoarr2(int16)*)u.VoidPtr));
Autoarr_clear(((Autoarr(int16)*)u.VoidPtr));
break;
case AutoarrUInt16Ptr:
Autoarr2_clear(((Autoarr2(uint16)*)u.VoidPtr));
Autoarr_clear(((Autoarr(uint16)*)u.VoidPtr));
break;
case AutoarrInt32Ptr:
Autoarr2_clear(((Autoarr2(int32)*)u.VoidPtr));
Autoarr_clear(((Autoarr(int32)*)u.VoidPtr));
break;
case AutoarrUInt32Ptr:
Autoarr2_clear(((Autoarr2(uint32)*)u.VoidPtr));
Autoarr_clear(((Autoarr(uint32)*)u.VoidPtr));
break;
case AutoarrInt64Ptr:
Autoarr2_clear(((Autoarr2(int64)*)u.VoidPtr));
Autoarr_clear(((Autoarr(int64)*)u.VoidPtr));
break;
case AutoarrUInt64Ptr:
Autoarr2_clear(((Autoarr2(uint64)*)u.VoidPtr));
Autoarr_clear(((Autoarr(uint64)*)u.VoidPtr));
break;
case AutoarrUnitypePtr:
Autoarr2_Unitype_clear(u.VoidPtr);
free((Autoarr2(Unitype)*)u.VoidPtr);
Autoarr_Unitype_clear(u.VoidPtr);
free((Autoarr(Unitype)*)u.VoidPtr);
break;
case AutoarrKVPairPtr:
Autoarr2_KeyValuePair_clear(u.VoidPtr);
free((Autoarr2(KeyValuePair)*)u.VoidPtr);
Autoarr_KeyValuePair_clear(u.VoidPtr);
free((Autoarr(KeyValuePair)*)u.VoidPtr);
break;
default: throw(ERR_WRONGTYPE);
}

2
DtsodC/tests/main.c
View File

@ -16,7 +16,7 @@ void printuni(Unitype v){
void test_all(){
test_searchtree();
test_autoarr2();
test_autoarr();
test_hashtable();
test_string();
test_dtsod();

52
DtsodC/tests/test_autoarr.c Normal file
View File

@ -0,0 +1,52 @@
#include "tests.h"
#include "../src/Autoarr/Autoarr.h"
static void printautoarr(Autoarr(uint16)* ar){
printf("\e[94mAutoarr(uint16): %lu\n"
" max_blocks_count: %u\n"
" blocks_count: %u\n"
" max_block_length: %u\n"
" block_length: %u\n"
" max_length: %u\n"
" length: %u\n",
sizeof(Autoarr(uint16)),
ar->max_blocks_count,
ar->blocks_count,
ar->max_block_length,
ar->block_length,
Autoarr_max_length(ar),
Autoarr_length(ar));
}
static void fillar(Autoarr(uint16)* ar){
for (uint16 i=0;i<Autoarr_max_length(ar);i++)
Autoarr_add(ar,i);
}
static void resetar(Autoarr(uint16)* ar){
for (uint16 i=0;i<Autoarr_max_length(ar);i++)
Autoarr_set(ar,i,Autoarr_max_length(ar)-i-1);
}
static void printallval(Autoarr(uint16)* ar){
printf("\e[90m");
for (uint16 i=0;i<Autoarr_length(ar);i++)
printf("%u ",Autoarr_get(ar,i));
printf("\n");
}
void test_autoarr(){
optime("test_autoarr",1,({
printf("\e[96m------------[test_autoarr]------------\n");
Autoarr(uint16) ar=Autoarr_create(uint16,10,16);
printf("\e[92mautoarr created\n");
fillar(&ar);
printf("\e[92mautoarr filled up\n");
printautoarr(&ar);
printallval(&ar);
resetar(&ar);
printf("\e[92mautoarr values reset\n");
printallval(&ar);
Autoarr_clear(((&ar)));
printf("\e[92mautoarr cleared\n");
}));
}

52
DtsodC/tests/test_autoarr2.c
View File

@ -1,52 +0,0 @@
#include "tests.h"
#include "../src/Autoarr/Autoarr2.h"
static void printautoarr(Autoarr2(uint16)* ar){
printf("\e[94mAutoarr2(uint16): %lu\n"
" max_blocks_count: %u\n"
" blocks_count: %u\n"
" max_block_length: %u\n"
" block_length: %u\n"
" max_length: %u\n"
" length: %u\n",
sizeof(Autoarr2(uint16)),
ar->max_blocks_count,
ar->blocks_count,
ar->max_block_length,
ar->block_length,
Autoarr2_max_length(ar),
Autoarr2_length(ar));
}
static void fillar(Autoarr2(uint16)* ar){
for (uint16 i=0;i<Autoarr2_max_length(ar);i++)
Autoarr2_add(ar,i);
}
static void resetar(Autoarr2(uint16)* ar){
for (uint16 i=0;i<Autoarr2_max_length(ar);i++)
Autoarr2_set(ar,i,Autoarr2_max_length(ar)-i-1);
}
static void printallval(Autoarr2(uint16)* ar){
printf("\e[90m");
for (uint16 i=0;i<Autoarr2_length(ar);i++)
printf("%u ",Autoarr2_get(ar,i));
printf("\n");
}
void test_autoarr2(){
optime("test_autoarr2",1,({
printf("\e[96m------------[test_autoarr2]------------\n");
Autoarr2(uint16) ar=Autoarr2_create(uint16,10,16);
printf("\e[92mautoarr created\n");
fillar(&ar);
printf("\e[92mautoarr filled up\n");
printautoarr(&ar);
printallval(&ar);
resetar(&ar);
printf("\e[92mautoarr values reset\n");
printallval(&ar);
Autoarr2_clear(((&ar)));
printf("\e[92mautoarr cleared\n");
}));
}

4
DtsodC/tests/test_dtsod.c
View File

@ -20,8 +20,8 @@ void test_dtsod(){
printf("\e[92mhashtable_get(message)->\n\e[94m");
Unitype msg=Hashtable_get(dtsod,"message");
printuni(msg);
Autoarr2(Unitype)* ar=msg.VoidPtr;
id=Hashtable_get(Autoarr2_get(ar,0).VoidPtr,"message_id");
Autoarr(Unitype)* ar=msg.VoidPtr;
id=Hashtable_get(Autoarr_get(ar,0).VoidPtr,"message_id");
printf("\e[92m\nmessage_id: %lu\n",id.UInt64);
Hashtable_free(dtsod);
}));

4
DtsodC/tests/test_hashtable.c
View File

@ -25,8 +25,8 @@ void printrowgraph(Hashtable* ht){
for(uint32 i=0; i<lgs_l; i++)
lgs[i]=0;
for(uint16 h=0;h<Hashtable_height(ht);h++){
Autoarr2(KeyValuePair)* ar=ht->rows+h;
uint32 l=Autoarr2_length(ar);
Autoarr(KeyValuePair)* ar=ht->rows+h;
uint32 l=Autoarr_length(ar);
lgs[l]++;
}
for(uint32 i=0; i<lgs_l; i++)

2
DtsodC/tests/tests.h
View File

@ -5,7 +5,7 @@
void printuni(Unitype v);
void test_searchtree();
void test_autoarr2();
void test_autoarr();
void test_hashtable();
void test_string();
void test_dtsod();