new version of autoarr

DtsodC/Makefile

@@ -14,13 +14,16 @@ clear_bin:
 clang: CMP=clang
 clang: all
 
-CMPARGS=-O0 -g -Wall -Werror
+CMPARGS= -Wall $(SRC) -o $(OUTFILE)
 build: 
 	@echo "\e[36m-------------[build]---------------\e[0m"
-	$(CMP) $(CMPARGS) $(SRC) -o $(OUTFILE)
+	$(CMP) -O2 $(CMPARGS)
+build_dbg: 
+	@echo "\e[36m-------------[build_dbg]---------------\e[0m"
+	$(CMP) -O0 $(CMPARGS).dbg
 test:
 	@echo "\e[36m-------------[test]----------------\e[0m"
 	$(OUTFILE)
-valgrind: clear_c build
+valgrind: clear_c build_dbg
 	@echo "\e[36m-----------[valgrind]--------------\e[0m"
-	valgrind -s --read-var-info=yes --fullpath-after=DtsodC/ $(OUTFILE)
+	valgrind -s --read-var-info=yes --fullpath-after=DtsodC/ $(OUTFILE).dbg

DtsodC/src/Autoarr/Autoarr.c

@@ -12,7 +12,6 @@ Autoarr Autoarr_create(uint16 _max_block_count, uint16 _max_block_length, my_typ
         .values=malloc(_max_block_count*sizeof(void*))
     };
     *ar.values=malloc(_max_block_length*typesize(ar.type));
-    printf("%p %p\n",ar.values, *ar.values);
     return ar;
 }
 

DtsodC/src/Autoarr/Autoarr2.c

@@ -0,0 +1,13 @@
+#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)

DtsodC/src/Autoarr/Autoarr2.h

@@ -0,0 +1,17 @@
+#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)
+

DtsodC/src/Autoarr/Autoarr2_declare.h

@@ -0,0 +1,48 @@
+#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);\
+    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);\
+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_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)

DtsodC/src/Autoarr/Autoarr2_define.h

@@ -0,0 +1,58 @@
+#pragma once
+
+#include "../base/base.h"
+
+#define define_Autoarr2(type)\
+\
+void __Autoarr2_add_##type(Autoarr2_##type* ar, type element){\
+    if(!ar->values){\
+        ar->values=malloc(ar->max_blocks_count*sizeof(type*));\
+        goto create_block;\
+    }\
+    if(ar->block_length==ar->max_block_length){\
+        if (ar->blocks_count>=ar->max_blocks_count) throw(ERR_MAXLENGTH);\
+        ar->block_length=0;\
+create_block:\
+        ar->values[ar->blocks_count]=malloc(ar->max_block_length*sizeof(type));\
+        ar->blocks_count++;\
+    }\
+    ar->values[ar->blocks_count-1][ar->block_length]=element;\
+    ar->block_length++;\
+}\
+\
+type __Autoarr2_get_##type(Autoarr2_##type* ar, uint32 index){\
+    if(index>=Autoarr2_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);\
+    ar->values[index/ar->max_block_length][index%ar->max_block_length]=element;\
+}\
+\
+void __Autoarr2_clear_##type(Autoarr2_##type* ar){\
+    for(uint16 i=0; i<ar->blocks_count;i++)\
+                free(ar->values[i]); \
+    free(ar->values);\
+    ar->values=NULL;\
+    ar->blocks_count=0;\
+    ar->block_length=0;\
+}\
+\
+__functions_list_t_##type __functions_list_##type={\
+    &__Autoarr2_add_##type,\
+    &__Autoarr2_get_##type,\
+    &__Autoarr2_set_##type,\
+    &__Autoarr2_clear_##type\
+};\
+\
+Autoarr2_##type __Autoarr2_create_##type(uint16 max_blocks_count, uint16 max_block_length){\
+    return (Autoarr2_##type){\
+        .max_blocks_count=max_blocks_count,\
+        .blocks_count=0,\
+        .max_block_length=max_block_length,\
+        .block_length=0,\
+        .values=NULL,\
+        .functions=&__functions_list_##type\
+    };\
+}

DtsodC/src/Autoarr/new.h

@@ -1,73 +0,0 @@
-#include "../base/base.h"
-
-#ifndef AUTOARR_H
-#define AUTOARR_H
-
-#define Autoarr_length(autoarr) (uint32)(autoarr->max_block_length*(autoarr->max_blocks_count-1)+autoarr->block_length)
-#define Autoarr_max_length(autoarr) (uint32)(autoarr->max_block_length*autoarr->max_blocks_count)
-
-#define define_Autoarr(type) \
-typedef struct Autoarr_##type{ \
-    uint16 blocks_count; \
-    uint16 max_blocks_count; \
-    uint16 block_length; \
-    uint16 max_block_length; \
-    type** values; \
-    void (*Autoarr_add)(struct Autoarr_##type* ar, type element); \
-    type (*Autoarr_get)(struct Autoarr_##type* ar, uint32 index); \
-    void (*Autoarr_set)(struct Autoarr_##type* ar, uint32 index, type element); \
-} Autoarr_##type; \
-\
-void Autoarr_add_##type(Autoarr_##type* ar, type element){ \
-    if(!ar->values){ \
-        ar->values=malloc(ar->max_blocks_count*sizeof(type*)); \
-        goto create_block; \
-    } \
-    if(ar->block_length==ar->max_block_length){ \
-        if (ar->blocks_count>=ar->max_blocks_count) throw(ERR_MAXLENGTH); \
-        ar->block_length=0; \
-create_block: \
-        ar->values[ar->blocks_count]=malloc(ar->max_block_length*sizeof(type)); \
-        ar->blocks_count++; \
-    } \
-    ar->values[ar->blocks_count-1][ar->block_length]=element; \
-    ar->block_length++; \
-} \
-\
-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]; \
-} \
-\
-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; \
-} \
-\
-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, \
-        .block_length=0, \
-        .values=NULL, \
-        .Autoarr_add=Autoarr_add_##type, \
-        .Autoarr_get=Autoarr_get_##type, \
-        .Autoarr_set=Autoarr_set_##type \
-    }; \
-} \
-\
-void Autoarr_clear_##type(Autoarr_##type* ar){ \
-    for(uint16 i=0; i<ar->blocks_count;i++) \
-                free(ar->values[i]);  \
-    free(ar->values); \
-    ar->values=NULL; \
-    ar->blocks_count=0; \
-    ar->block_length=0; \
-}
-
-#define Autoarr(type) Autoarr_##type
-#define Autoarr_create(type, max_blocks_count, max_block_length) \
-    Autoarr_create_##type(max_blocks_count, max_block_length)
-    
-#endif

DtsodC/src/SearchTree/SearchTree.c

@@ -39,10 +39,10 @@ void STNode_free(STNode* node){
             case Int64Ptr: case UInt64Ptr:
                 free(node->value.VoidPtr);
                 break;
-            case AutoarrPtr:
+            /*case AutoarrPtr:
                 Autoarr_clear((Autoarr*)node->value.VoidPtr);
                 free(node->value.VoidPtr);
-                break;
+                break;*/
             case STNodePtr:
                 STNode_free((STNode*)node->value.VoidPtr);
                 break;

DtsodC/src/base/base.h

@@ -4,6 +4,5 @@
 #include "types.h"
 #include "errors.h"
 
-// just sleeping function
+// sleep function based on std nanosleep()
-// dont set 'milisec' > 1000 for good perfomance
+void fsleep(float sec);
-void msleep(uint8 sec, uint16 milisec);

DtsodC/src/base/fsleep.c

@@ -0,0 +1,8 @@
+#include "base.h"
+
+void fsleep(float sec){
+    struct timespec t;
+    t.tv_sec=sec+0.0001f;
+    t.tv_nsec=(sec-t.tv_sec)*1000000000;
+    nanosleep(&t, NULL);
+}

DtsodC/src/base/msleep.c

@@ -1,8 +0,0 @@
-#include "base.h"
-
-void msleep(uint8 sec, uint16 milisec){
-    if (sec>0)
-        sleep(sec);
-    if (milisec>0)
-        usleep(milisec*1000);
-}

DtsodC/src/base/std.h

@@ -6,9 +6,7 @@
 #include <locale.h>
 #include <uchar.h>
 #include <wchar.h>
-#include <sys/stat.h>
 #include <time.h>
-#include <unistd.h>
 
 #define CHOOSE(B, Y, N) __builtin_choose_expr(B, Y, N)
 

DtsodC/src/base/types.c

@@ -1,4 +1,3 @@
-#include "std.h"
 #include "types.h"
 #include "errors.h"
 

DtsodC/src/base/types.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include "std.h"
-#include "errors.h"
 
 typedef int8_t int8;
 typedef uint8_t uint8;
@@ -15,7 +14,7 @@ typedef enum my_type{
     Null, Float, Double, Char, Bool,
     UInt8, Int8, UInt16, Int16, UInt32, Int32, UInt64, Int64, 
     UInt8Ptr, Int8Ptr, UInt16Ptr, Int16Ptr, UInt32Ptr, Int32Ptr, UInt64Ptr, Int64Ptr,
-    UniversalType, AutoarrPtr, STNodePtr
+    UniversalType, STNodePtr
 } __attribute__ ((__packed__)) my_type;
 
 //returns type name

DtsodC/src/list.h

@@ -0,0 +1,85 @@
+
+#define define_list(type) \
+\
+    struct _list_##type; \
+    \
+    typedef struct \
+    { \
+        bool (*is_empty)(const struct _list_##type*); \
+        size_t (*size)(const struct _list_##type*); \
+        const type (*front)(const struct _list_##type*); \
+        void (*push_front)(struct _list_##type*, type); \
+    } _list_functions_##type; \
+    \
+    typedef struct _list_elem_##type \
+    { \
+        type _data; \
+        struct _list_elem_##type* _next; \
+    } list_elem_##type; \
+    \
+    typedef struct _list_##type \
+    { \
+        size_t _size; \
+        list_elem_##type* _first; \
+        list_elem_##type* _last; \
+        _list_functions_##type* _functions; \
+    } List_##type; \
+    \
+    List_##type* new_list_##type(); \
+    bool list_is_empty_##type(const List_##type* list); \
+    size_t list_size_##type(const List_##type* list); \
+    const type list_front_##type(const List_##type* list); \
+    void list_push_front_##type(List_##type* list, type elem); \
+    \
+    bool list_is_empty_##type(const List_##type* list) \
+    { \
+        return list->_size == 0; \
+    } \
+    \
+    size_t list_size_##type(const List_##type* list) \
+    { \
+        return list->_size; \
+    } \
+    \
+    const type list_front_##type(const List_##type* list) \
+    { \
+        return list->_first->_data; \
+    } \
+    \
+    void list_push_front_##type(List_##type* list, type elem) \
+    { \
+        printf("%x",elem);\
+    } \
+    \
+    _list_functions_##type _list_funcs_##type = { \
+        &list_is_empty_##type, \
+        &list_size_##type, \
+        &list_front_##type, \
+        &list_push_front_##type, \
+    }; \
+    \
+    List_##type* new_list_##type() \
+    { \
+        List_##type* res = (List_##type*) malloc(sizeof(List_##type)); \
+        res->_size = 0; \
+        res->_first = NULL; \
+        res->_functions = &_list_funcs_##type; \
+        return res; \
+    }
+
+#define List(type) \
+    List_##type
+
+#define new_list(type) \
+    new_list_##type()
+#define is_empty(collection) \
+    collection->_functions->is_empty(collection)
+
+#define size(collection) \
+    collection->_functions->size(collection)
+
+#define front(collection) \
+    collection->_functions->front(collection)
+
+#define push_front(collection, elem) \
+    collection->_functions->push_front(collection, elem)

DtsodC/src/main.c

@@ -1,10 +1,26 @@
 #include "base/base.h"
 #include "tests/tests.h"
+#include "Autoarr/Autoarr.h"
+#include "Autoarr/Autoarr2.h"
 
 int main(){
     setlocale(LC_ALL, "en-US.Unicode");
     printf("\e[92mdtsod parser in c language!\e[97m\n");
     //test_all();
-    test_new();
+    //test_autoarr2();
+    long start=clock();
+    Autoarr2(uint64) _ar2=Autoarr2_create(uint64,10000,20000);
+    Autoarr2(uint64)* ar2=&_ar2;
+    for(uint32 i=0;i<Autoarr2_max_length(ar2);i++)
+        Autoarr2_add(ar2,8);
+    long stop=clock();
+    printf("\e[96m%li\n",stop-start);
+    start=clock();
+    Autoarr _ar=Autoarr_create(10000,20000,UInt64);
+    Autoarr* ar=&_ar;
+    for(uint32 i=0;i<ar->max_length;i++)
+        Autoarr_add_uint64(ar,8);
+    stop=clock();
+    printf("\e[96m%li\n",stop-start);
     return 0;
 }

DtsodC/src/tests/new.c

@@ -1,46 +0,0 @@
-#include "tests.h"
-#include "../Autoarr/new.h"
-
-#ifndef Aaaa
-#define Aaaa
-define_Autoarr(uint16)
-#endif
-
-void printautoarr(Autoarr(uint16)* ar){
-    printf("\e[94mAUTOARR:%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));
-}
-
-void fillar(Autoarr(uint16)* ar){
-    for (uint16 i=0;i<Autoarr_max_length(ar);i++)
-        Autoarr_add_uint16(ar,i);
-}
-
-void printallval(Autoarr(uint16)* ar){
-    for (uint16 i=0;i<Autoarr_max_length(ar);i++)
-        printf("%u ", Autoarr_get_uint16(ar,i));
-}
-
-void test_new(){
-    printf("\e[96m------------[test_autoarr]-------------\n");
-    Autoarr(uint16) ar=Autoarr_create(uint16,10,16);
-    printf("\e[92mautoarr created\n\e[90m");
-    fillar(&ar);
-    printallval(&ar);
-    printf("\n\e[92mautoarr filled up\n");
-    printautoarr(&ar);
-    Autoarr_clear_uint16(&ar);
-    printf("\e[92mautoarr cleared\n");
-}

DtsodC/src/tests/test_autoarr.c

@@ -1,7 +1,7 @@
 #include "tests.h"
 #include "../Autoarr/Autoarr.h"
 
-void printautoarr(Autoarr* ar){
+static void printautoarr(Autoarr* ar){
     printf("\e[94mAUTOARR:%lu\n"
         "  type: %s\n"
         "  max_block_count: %u\n"
@@ -20,14 +20,20 @@ void printautoarr(Autoarr* ar){
         ar->curr_length);
 }
 
-void fillar(Autoarr* ar){
+static void fillar(Autoarr* ar){
     for (uint16 i=0;i<ar->max_length;i++)
         Autoarr_add_uint16(ar,i);
 }
-
+static void resetar(Autoarr* ar){
-void printallval(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(){
@@ -35,9 +41,12 @@ void test_autoarr(){
     Autoarr ar=Autoarr_create(10,16,UInt16);
     printf("\e[92mautoarr created\n\e[90m");
     fillar(&ar);
-    printallval(&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/test_autoarr2.c

@@ -0,0 +1,50 @@
+#include "tests.h"
+#include "../Autoarr/Autoarr2.h"
+
+static void printautoarr(Autoarr2(uint16)* ar){
+    printf("\e[94mAUTOARR:%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(){
+    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");
+}

DtsodC/src/tests/tests.h

@@ -7,4 +7,4 @@ void printuni(Unitype v);
 void test_autoarr(void);
 void test_searchtree(void);
 void test_all(void);
-void test_new(void);
+void test_autoarr2(void);