old autoarr removed

DtsodC/src/Autoarr/Autoarr.c

@@ -1,197 +0,0 @@
-#include "Autoarr.h"
-
-Autoarr Autoarr_create(uint16 _max_block_count, uint16 _max_block_length, my_type _type){
-    Autoarr ar={
-        .type=_type,
-        .max_block_count=_max_block_count,
-        .max_block_length=_max_block_length,
-        .curr_block_count=1,
-        .curr_block_length=0,
-        .max_length=_max_block_count*_max_block_length,
-        .curr_length=0,
-        .values=malloc(_max_block_count*sizeof(void*))
-    };
-    *ar.values=malloc(_max_block_length*typesize(ar.type));
-    return ar;
-}
-
-// creates new block if the current one is filled
-void __Autoarr_create_block(Autoarr *ar){
-    if (ar->curr_block_count>=ar->max_block_count) throw(ERR_MAXLENGTH);
-    ar->curr_block_length=0;
-    ar->values[ar->curr_block_count]=malloc(ar->max_block_length*typesize(ar->type));
-    ar->curr_block_count++;
-}
-
-void __Autoarr_add_pre(Autoarr* ar, my_type t){
-    if(ar->type!=t) throw(ERR_WRONGTYPE);
-    if(ar->curr_length>=ar->max_length)  throw(ERR_MAXLENGTH);
-    if (ar->curr_block_length==ar->max_block_length)
-        __Autoarr_create_block(ar);
-    ar->curr_block_length++;
-    ar->curr_length++;
-}
-
-void Autoarr_add_int8(Autoarr *ar, int8 element){
-    __Autoarr_add_pre(ar,Int8);
-    *(*((int8**)ar->values+ar->curr_block_count-1)+ar->curr_block_length-1)=element;
-}
-void Autoarr_add_uint8(Autoarr *ar, uint8 element){
-    __Autoarr_add_pre(ar,UInt8);
-    *(*((uint8**)ar->values+ar->curr_block_count-1)+ar->curr_block_length-1)=element;
-}
-void Autoarr_add_int16(Autoarr *ar, int16 element){
-    __Autoarr_add_pre(ar,Int16);
-    *(*((int16**)ar->values+ar->curr_block_count-1)+ar->curr_block_length-1)=element;
-}
-void Autoarr_add_uint16(Autoarr *ar, uint16 element){
-    __Autoarr_add_pre(ar,UInt16);
-    *(*((uint16**)ar->values+ar->curr_block_count-1)+ar->curr_block_length-1)=element;
-}
-void Autoarr_add_int32(Autoarr *ar, int32 element){
-    __Autoarr_add_pre(ar,Int32);
-    *(*((int32**)ar->values+ar->curr_block_count-1)+ar->curr_block_length-1)=element;
-}
-void Autoarr_add_uint32(Autoarr *ar, uint32 element){
-    __Autoarr_add_pre(ar,UInt32);
-    *(*((uint32**)ar->values+ar->curr_block_count-1)+ar->curr_block_length-1)=element;
-}
-void Autoarr_add_int64(Autoarr *ar, int64 element){
-    __Autoarr_add_pre(ar,Int64);
-    *(*((int64**)ar->values+ar->curr_block_count-1)+ar->curr_block_length-1)=element;
-}
-void Autoarr_add_uint64(Autoarr *ar, uint64 element){
-    __Autoarr_add_pre(ar,UInt64);
-    *(*((uint64**)ar->values+ar->curr_block_count-1)+ar->curr_block_length-1)=element;
-}
-void Autoarr_add_uni(Autoarr *ar, Unitype element){
-    __Autoarr_add_pre(ar,UniversalType);
-    *(*((Unitype**)ar->values+ar->curr_block_count-1)+ar->curr_block_length-1)=element;
-}
-
-// calculates a block number and element position in the block
-// also verifies type of array
-div_t __Autoarr_div_index(Autoarr* ar, uint32 i, my_type t){
-    if(ar->type!=t) throw(ERR_WRONGTYPE);
-    if(i>=ar->curr_length) throw(ERR_WRONGINDEX);
-    return (div_t){
-        .quot=i/ar->max_block_length,
-        .rem=i%ar->max_block_length
-    };;
-}
-
-int8 Autoarr_get_int8(Autoarr *ar, uint32 index){
-    div_t d = __Autoarr_div_index(ar, index, Int8);
-    return *(*((int8**)ar->values+d.quot)+d.rem);
-}
-uint8 Autoarr_get_uint8(Autoarr *ar, uint32 index){
-    div_t d = __Autoarr_div_index(ar, index, UInt8);
-    return *(*((uint8**)ar->values+d.quot)+d.rem);
-}
-int16 Autoarr_get_int16(Autoarr *ar, uint32 index){
-    div_t d = __Autoarr_div_index(ar, index, Int16);
-    return *(*((int16**)ar->values+d.quot)+d.rem);
-}
-uint16 Autoarr_get_uint16(Autoarr *ar, uint32 index){
-    div_t d = __Autoarr_div_index(ar, index, UInt16);
-    return *(*((uint16**)ar->values+d.quot)+d.rem);
-}
-int32 Autoarr_get_int32(Autoarr *ar, uint32 index){
-    div_t d = __Autoarr_div_index(ar, index, Int32);
-    return *(*((int32**)ar->values+d.quot)+d.rem);
-}
-uint32 Autoarr_get_uint32(Autoarr *ar, uint32 index){
-    div_t d = __Autoarr_div_index(ar, index, UInt32);
-    return *(*((uint32**)ar->values+d.quot)+d.rem);
-}
-int64 Autoarr_get_int64(Autoarr *ar, uint32 index){
-    div_t d = __Autoarr_div_index(ar, index, Int64);
-    return *(*((int64**)ar->values+d.quot)+d.rem);
-}
-uint64 Autoarr_get_uint64(Autoarr *ar, uint32 index){
-    div_t d = __Autoarr_div_index(ar, index, UInt64);
-    return *(*((uint64**)ar->values+d.quot)+d.rem);
-}
-Unitype Autoarr_get_uni(Autoarr *ar, uint32 index){
-    div_t d = __Autoarr_div_index(ar, index, UniversalType);
-    return *(*((Unitype**)ar->values+d.quot)+d.rem);
-}
-
-void Autoarr_set_int8(Autoarr *ar, uint32 index, int8 element){
-    div_t d =__Autoarr_div_index(ar, index, Int8);
-    *(*((int8**)ar->values+d.quot)+d.rem)=element;
-}
-void Autoarr_set_uint8(Autoarr *ar, uint32 index, uint8 element){
-    div_t d =__Autoarr_div_index(ar, index, UInt8);
-    *(*((uint8**)ar->values+d.quot)+d.rem)=element;
-}
-void Autoarr_set_int16(Autoarr *ar, uint32 index, int16 element){
-    div_t d =__Autoarr_div_index(ar, index, Int16);
-    *(*((int16**)ar->values+d.quot)+d.rem)=element;
-}
-void Autoarr_set_uint16(Autoarr *ar, uint32 index, uint16 element){
-    div_t d =__Autoarr_div_index(ar, index, UInt16);
-    *(*((uint16**)ar->values+d.quot)+d.rem)=element;
-}
-void Autoarr_set_int32(Autoarr *ar, uint32 index, int32 element){
-    div_t d =__Autoarr_div_index(ar, index, Int32);
-    *(*((int32**)ar->values+d.quot)+d.rem)=element;
-}
-void Autoarr_set_uint32(Autoarr *ar, uint32 index, uint32 element){
-    div_t d =__Autoarr_div_index(ar, index, UInt32);
-    *(*((uint32**)ar->values+d.quot)+d.rem)=element;
-}
-void Autoarr_set_int64(Autoarr *ar, uint32 index, int64 element){
-    div_t d =__Autoarr_div_index(ar, index, Int64);
-    *(*((int64**)ar->values+d.quot)+d.rem)=element;
-}
-void Autoarr_set_uint64(Autoarr *ar, uint32 index, uint64 element){
-    div_t d =__Autoarr_div_index(ar, index, UInt64);
-    *(*((uint64**)ar->values+d.quot)+d.rem)=element;
-}
-void Autoarr_set_uni(Autoarr *ar, uint32 index, Unitype element){
-    div_t d =__Autoarr_div_index(ar, index, UniversalType);
-    *(*((Unitype**)ar->values+d.quot)+d.rem)=element;
-}
-
-void Autoarr_clear(Autoarr* ar){
-    switch (ar->type) {   
-        case Int8:
-            for(uint16 i = 0; i < ar->curr_block_count;i++)
-                free((int8*)ar->values[i]); 
-            break;
-        case UInt8:
-            for(uint16 i = 0; i < ar->curr_block_count;i++)
-                free((uint8*)ar->values[i]); 
-            break;
-        case Int16:
-            for(uint16 i = 0; i < ar->curr_block_count;i++)
-                free((int16*)ar->values[i]); 
-            break;
-        case UInt16:
-            for(uint16 i = 0; i < ar->curr_block_count;i++)
-                free((uint16*)ar->values[i]); 
-            break;
-        case Int32:
-            for(uint16 i = 0; i < ar->curr_block_count;i++)
-                free((int32*)ar->values[i]); 
-            break;
-        case UInt32:
-            for(uint16 i = 0; i < ar->curr_block_count;i++)
-                free((uint32*)ar->values[i]); 
-            break;
-        case Int64:
-            for(uint16 i = 0; i < ar->curr_block_count;i++)
-                free((int64*)ar->values[i]); 
-            break;
-        case UInt64:
-            for(uint16 i = 0; i < ar->curr_block_count;i++)
-                free((uint64*)ar->values[i]); 
-            break;
-        default: 
-            throw(ERR_WRONGTYPE); 
-            break;
-    }
-    free(ar->values);
-    ar->type=Null;
-}

DtsodC/src/Autoarr/Autoarr.h

@@ -1,48 +0,0 @@
-#pragma once
-
-#include "../base/base.h"
-
-typedef struct Autoarr{         // a collection with dynamic memory allocation
-    my_type type;               // type of data
-    uint16 max_block_count;     // max amount of blocks
-    uint16 curr_block_count;    // amount of blocks
-    uint16 max_block_length;    // max amount of data in block
-    uint16 curr_block_length;   // amount of data in the last block
-    uint32 max_length;          // max_block_count*max_block_length
-    uint32 curr_length;         // (curr_block_count-1)*max_block_length+curr_block_length
-    void** values;              // pointers to blocks
-} Autoarr;
-
-Autoarr Autoarr_create(uint16 _max_block_count, uint16 _max_block_length, my_type _type);
-void Autoarr_clear(Autoarr* ar);
-
-void Autoarr_add_int8(Autoarr *ar, int8 element);
-void Autoarr_add_uint8(Autoarr *ar, uint8 element);
-void Autoarr_add_int16(Autoarr *ar, int16 element);
-void Autoarr_add_uint16(Autoarr *ar, uint16 element);
-void Autoarr_add_int32(Autoarr *ar, int32 element);
-void Autoarr_add_uint32(Autoarr *ar, uint32 element);
-void Autoarr_add_int64(Autoarr *ar, int64 element);
-void Autoarr_add_uint64(Autoarr *ar, uint64 element);
-
-int8 Autoarr_get_int8(Autoarr *ar, uint32 index);
-uint8 Autoarr_get_uint8(Autoarr *ar, uint32 index);
-int16 Autoarr_get_int16(Autoarr *ar, uint32 index);
-uint16 Autoarr_get_uint16(Autoarr *ar, uint32 index);
-int32 Autoarr_get_int32(Autoarr *ar, uint32 index);
-uint32 Autoarr_get_uint32(Autoarr *ar, uint32 index);
-int64 Autoarr_get_int64(Autoarr *ar, uint32 index);
-uint64 Autoarr_get_uint64(Autoarr *ar, uint32 index);
-
-void Autoarr_set_int8(Autoarr *ar, uint32 index, int8 element);
-void Autoarr_set_uint8(Autoarr *ar, uint32 index, uint8 element);
-void Autoarr_set_int16(Autoarr *ar, uint32 index, int16 element);
-void Autoarr_set_uint16(Autoarr *ar, uint32 index, uint16 element);
-void Autoarr_set_int32(Autoarr *ar, uint32 index, int32 element);
-void Autoarr_set_uint32(Autoarr *ar, uint32 index, uint32 element);
-void Autoarr_set_int64(Autoarr *ar, uint32 index, int64 element);
-void Autoarr_set_uint64(Autoarr *ar, uint32 index, uint64 element);
-
-void Autoarr_add_uni(Autoarr *ar, Unitype element);
-Unitype Autoarr_get_uni(Autoarr *ar, uint32 index);
-void Autoarr_set_uni(Autoarr *ar, uint32 index, Unitype element);

DtsodC/src/DtsodParser/DtsodV24.h

@@ -1,4 +1,3 @@
 #pragma once
 #include "../base/base.h"
-#include "../Autoarr/Autoarr.h"
 

DtsodC/src/Hashtable/Hashtable.h

@@ -1,12 +1,12 @@
 #pragma once
 
 #include "../base/base.h"
-#include "../Autoarr/Autoarr.h"
+#include "../Autoarr/Autoarr2.h"
 #include "hash.h"
 
 typedef struct Hashtable{
     uint16 height;    // amount of rows
-    Autoarr* rows;    // Autoarr[height]s
+    Autoarr2(Unitype)* rows;    // Autoarr[height]s
 } Hashtable;
 
 Hashtable Hashtable_create(uint16 height);

DtsodC/src/SearchTree/SearchTree.c

@@ -1,5 +1,4 @@
 #include "SearchTree.h"
-#include "../Autoarr/Autoarr.h"
 
 STNode* STNode_create(){
     STNode* node=malloc(sizeof(STNode));

DtsodC/src/main.c

@@ -1,6 +1,5 @@
 #include "base/base.h"
 #include "tests/tests.h"
-#include "Autoarr/Autoarr.h"
 #include "Autoarr/Autoarr2.h"
 
 int main(){
@@ -13,11 +12,5 @@ int main(){
         for(uint32 i=0;i<Autoarr2_max_length(ar2);i++)
             Autoarr2_add(ar2,8);
     });
-    optime({
-        Autoarr _ar=Autoarr_create(10000,20000,UInt64);
-        Autoarr* ar=&_ar;
-        for(uint32 i=0;i<ar->max_length;i++)
-            Autoarr_add_uint64(ar,8);
-    });
     return 0;
 }

DtsodC/src/tests/test_autoarr.c

@@ -1,52 +0,0 @@
-#include "tests.h"
-#include "../Autoarr/Autoarr.h"
-
-static void printautoarr(Autoarr* ar){
-    printf("\e[94mAUTOARR:%lu\n"
-        "  type: %s\n"
-        "  max_block_count: %u\n"
-        "  curr_block_count: %u\n"
-        "  max_block_length: %u\n"
-        "  curr_block_length: %u\n"
-        "  max_length: %u\n" 
-        "  curr_length: %u\n",
-        sizeof(Autoarr),
-        typename(ar->type),
-        ar->max_block_count,
-        ar->curr_block_count,
-        ar->max_block_length,
-        ar->curr_block_length,
-        ar->max_length,
-        ar->curr_length);
-}
-
-static void fillar(Autoarr* ar){
-    for (uint16 i=0;i<ar->max_length;i++)
-        Autoarr_add_uint16(ar,i);
-}
-static void resetar(Autoarr* ar){
-    for (uint16 i=0;i<ar->max_length;i++)
-        Autoarr_set_uint16(ar,i,ar->max_length-i-1);
-}
-
-static void printallval(Autoarr* ar){
-    printf("\e[90m");
-    for (uint16 i=0;i<ar->curr_length;i++)
-        printf("%u ", Autoarr_get_uint16(ar,i));
-    printf("\n");
-}
-
-void test_autoarr(){
-    printf("\e[96m------------[test_autoarr]-------------\n");
-    Autoarr ar=Autoarr_create(10,16,UInt16);
-    printf("\e[92mautoarr created\n\e[90m");
-    fillar(&ar);
-    printf("\n\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");
-}

DtsodC/src/tests/tests.c

@@ -30,7 +30,6 @@ void printuni(Unitype v){
 
 void test_all(void){
     test_searchtree();
-    test_autoarr();
     test_autoarr2();
     printf("\e[96m---------------------------------------\n");
 }

DtsodC/src/tests/tests.h

@@ -4,9 +4,8 @@
 
 void printuni(Unitype v);
 
-void test_autoarr(void);
-void test_searchtree(void);
 void test_all(void);
+void test_searchtree(void);
 void test_autoarr2(void);
 
 // executes codeblock and prints execution time