Start to rewriting code

Since there's some UB in the master I decided to rewrite code from
scratch again. I hope that attempt will be better :D

11 files changed, 151 insertions, 595 deletions

diff --git a/include/3cl.h b/include/3cl.h
new file mode 100644
index 0000000..a6b9065
--- /dev/null
+++ b/include/3cl.h
@@ -0,0 +1,118 @@
+#ifndef __3CL_H__
+#define __3CL_H__
+
+#include <stddef.h>
+#include <stdint.h>
+
+
+#ifndef CCL_STACKSIZE
+#define CCL_STACKSIZE 8192
+#endif
+
+typedef int16_t CCLNum;   /**< Abstract type for numbers in ccl */
+typedef size_t  CCLAddr;  /**< Abstract type for address in ccl */
+
+/**
+ * Type of CCLFrame
+ */
+enum CCLFrameType
+{
+    CCL_ROOT,    /**< Root frame, stores global variables    */
+    CCL_PROC,    /**< Function frame, stores local variables */
+    CCL_INFLOOP, /**< Infinity loop, stores start and repeat */
+    CCL_REPLOOP, /**< Repeat loop, stores start and repeat   */
+};
+
+/**
+ * Pair which contains variable's name and value
+ */
+struct CCLVariable
+{
+    struct CCLVariable *prev, *next;
+    char                name;
+    CCLNum              value;
+};
+
+/**
+ * Pair which contains procedure's name and address
+ */
+struct CCLProcedure
+{
+    struct CCLProcedure *prev, *next;
+    char                 name;
+    CCLAddr              address;
+};
+
+/**
+ * Pair with length of stack and stack itself
+ */
+struct CCLStack
+{
+    size_t  length;
+    size_t  cur;
+    CCLNum *stack;
+};
+
+/**
+ * Linked list that stores current state and allows to do recursion with local variables.
+ */
+struct CCLFrame
+{
+    struct  CCLFrame      *prev, *next;  /**< Frames are connected as linked list */
+    enum    CCLFrameType   type;         /**< Type of the frame                   */
+    CCLAddr                ep;           /**< Execution point                     */
+    union
+    {
+        /* Frame stores either variables (for procedures)... */
+        struct
+        {
+            struct  CCLVariable vars;    /**< For root frame variables are global */
+        };
+        /* ...or start address and repeats left (for loops) */
+        struct
+        {
+            CCLAddr start;               /**< Used by CCL_*LOOP                   */
+            int     repeats;             /**< Used by CCL_REPLOOP                 */
+        };
+    };
+};
+
+/**
+ * Main structure for 3cl. It contains root frame, stack and code it's executing.
+ */
+struct CCL
+{
+    struct CCLStack   stack;
+    struct CCLFrame   rootframe;
+    const char       *code;
+    int             (*in)();
+    void            (*out)(int);
+};
+
+/**
+ * Inits CCL.
+ * @see ccl_free
+ * @see ccl_exec
+ * @param ccl The structure to init
+ * @param code The code to execute
+ * @param in Function to get input
+ * @param out Function to show output
+ * @return 0 on success, any other number otherwise
+ */
+int ccl_init(struct CCL *ccl, const char *code, int (*in)(), void (*out)(int));
+
+/**
+ * Frees all things that ware allocated in ccl_init.
+ * @see ccl_init
+ * @param ccl The structure to free
+ */
+void ccl_free(struct CCL *ccl);
+
+/**
+ * Executes inited CCL instance
+ * @see ccl_init
+ * @param ccl The strcture to execute
+ */
+void ccl_exec(struct CCL *ccl);
+
+#endif /* __3CL_H__ */
diff --git a/include/cccl.h b/include/cccl.h
deleted file mode 100644
index 119adf5..0000000
--- a/include/cccl.h
+++ /dev/null
@@ -1,52 +0,0 @@
-#ifndef __CCCL_H__
-#define __CCCL_H__
-
-#include "types.h"
-
-#include <stdbool.h>
-
-
-typedef struct cccl_varpair
-{
-    i16 value;
-    s8  name;
-} cccl_varpair;
-
-typedef struct cccl_procpair
-{
-    i32 value;
-    s8  name;
-} cccl_procpair;
-
-typedef struct cccl_pointer
-{
-    i32  value;
-    i32  meta;
-} cccl_pointer;
-
-typedef struct cccl_brpair
-{
-    i32 pointer;
-    s8  bracket;
-} cccl_brpair;
-
-typedef struct cccl
-{
-    cccl_varpair    *variables;  /* Array with variables      */
-    cccl_procpair   *procedures; /* Array with procedures     */
-    i16             *stack;      /* User stack                */
-    cccl_brpair     *br_stack;   /* Stack for brackets        */
-    cccl_varpair   **lv_stack;   /* Local variable stack      */
-    cccl_pointer    *ep_stack;   /* Call stack                */
-    i32              ep;         /* Pointer to current symbol */
-    s8              *code;       /* Code being executed       */
-    s8              *filename;   /* File being executed       */
-    i32              size;       /* File size                 */
-} cccl;
-
-void cccl_init(s8 *filename);
-void cccl_read(void);
-void cccl_run(void);
-void cccl_free(void);
-
-#endif /* __CCCL_H__ */
diff --git a/include/instruction.h b/include/instruction.h
new file mode 100644
index 0000000..449c760
--- /dev/null
+++ b/include/instruction.h
@@ -0,0 +1,16 @@
+#ifndef __CCL_INSTRUCTION_H__
+#define __CCL_INSTRUCTION_H__
+
+#include "3cl.h"
+
+
+typedef struct CCLFrame *(*CCLInstruction)(struct CCL *ccl, struct CCLFrame *frame);
+
+struct CCLFrame *ccl_instruction_nop(struct CCL *ccl, struct CCLFrame *frame);
+struct CCLFrame *ccl_instruction_pushzero(struct CCL *ccl, struct CCLFrame *frame);
+struct CCLFrame *ccl_instruction_increment(struct CCL *ccl, struct CCLFrame *frame);
+struct CCLFrame *ccl_instruction_decrement(struct CCL *ccl, struct CCLFrame *frame);
+
+struct CCLFrame *ccl_instruction(struct CCL *ccl, struct CCLFrame *frame);
+
+#endif /* __CCL_INSTRUCTION_H__ */
diff --git a/include/main.h b/include/main.h
index 9cdf6ac..ad3bdc6 100644
--- a/include/main.h
+++ b/include/main.h
@@ -1,9 +1,6 @@
 #ifndef __MAIN_H__
 #define __MAIN_H__
 
-#include "types.h"
-
-
-extern const s8 *program_name;
+extern const char *program_name;
 
 #endif /* __MAIN_H__ */
diff --git a/include/operation.h b/include/operation.h
deleted file mode 100644
index ce487da..0000000
--- a/include/operation.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#ifndef __OPERATION_H__
-#define __OPERATION_H__
-
-#include "cccl.h"
-
-
-typedef void (*cccl_operation)(void);
-
-void cccl_operation_init(cccl *pc);
-cccl_operation cccl_select_operation(void);
-
-#endif /* __OPERATION_H__ */
diff --git a/include/readfile.h b/include/readfile.h
new file mode 100644
index 0000000..5358fc7
--- /dev/null
+++ b/include/readfile.h
@@ -0,0 +1,6 @@
+#ifndef __READFILE_H__
+#define __READFILE_H__
+
+char *readfile(const char *name);
+
+#endif /* __READFILE_H__ */
diff --git a/include/stack.h b/include/stack.h
new file mode 100644
index 0000000..27cc2f0
--- /dev/null
+++ b/include/stack.h
@@ -0,0 +1,9 @@
+#ifndef __CCL_STACK_H__
+#define __CCL_STACK_H__
+
+#include "3cl.h"
+
+void ccl_stack_push(struct CCLStack *stack, CCLNum num);
+CCLNum ccl_stack_pop(struct CCLStack *stack);
+
+#endif /* __CCL_STACK_H__ */
diff --git a/include/thirdparty/cvector/LICENSE b/include/thirdparty/cvector/LICENSE
deleted file mode 100644
index 2eb0839..0000000
--- a/include/thirdparty/cvector/LICENSE
+++ /dev/null
@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2015 Evan Teran
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
diff --git a/include/thirdparty/cvector/cvector.h b/include/thirdparty/cvector/cvector.h
deleted file mode 100644
index 7be970d..0000000
--- a/include/thirdparty/cvector/cvector.h
+++ /dev/null
@@ -1,483 +0,0 @@
-/*
- * Copyright (c) 2015 Evan Teran
- *
- * License: The MIT License (MIT)
- */
-
-#ifndef CVECTOR_H_
-#define CVECTOR_H_
-
-#ifndef CVECTOR_LOGARITHMIC_GROWTH
-#define CVECTOR_LOGARITHMIC_GROWTH
-#endif
-
-/* cvector heap implemented using C library malloc() */
-
-/* in case C library malloc() needs extra protection,
- * allow these defines to be overridden.
- */
-#ifndef cvector_clib_free
-#include <stdlib.h> /* for free */
-#define cvector_clib_free free
-#endif
-#ifndef cvector_clib_malloc
-#include <stdlib.h> /* for malloc */
-#define cvector_clib_malloc malloc
-#endif
-#ifndef cvector_clib_calloc
-#include <stdlib.h> /* for calloc */
-#define cvector_clib_calloc calloc
-#endif
-#ifndef cvector_clib_realloc
-#include <stdlib.h> /* for realloc */
-#define cvector_clib_realloc realloc
-#endif
-#ifndef cvector_clib_assert
-#include <assert.h> /* for assert */
-#define cvector_clib_assert assert
-#endif
-#ifndef cvector_clib_memcpy
-#include <string.h> /* for memcpy */
-#define cvector_clib_memcpy memcpy
-#endif
-#ifndef cvector_clib_memmove
-#include <string.h> /* for memmove */
-#define cvector_clib_memmove memmove
-#endif
-
-/* NOTE: Similar to C's qsort and bsearch, you will receive a T*
- * for a vector of Ts. This means that you cannot use `free` directly
- * as a destructor. Instead if you have for example a cvector_vector_type(int *)
- * you will need to supply a function which casts `elem_ptr` to an `int**`
- * and then does a free on what that pointer points to:
- *
- * ex:
- *
- * void free_int(void *p) { free(*(int **)p); }
- */
-typedef void (*cvector_elem_destructor_t)(void *elem_ptr);
-
-typedef struct cvector_metadata_t {
-    size_t size;
-    size_t capacity;
-    cvector_elem_destructor_t elem_destructor;
-} cvector_metadata_t;
-
-/**
- * @brief cvector_vector_type - The vector type used in this library
- */
-#define cvector_vector_type(type) type *
-
-/**
- * @brief cvector - Syntactic sugar to retrieve a vector type
- *
- * @param type The type of vector to act on.
- */
-#define cvector(type) cvector_vector_type(type)
-
-/*
- * @brief cvector_iterator - The iterator type used for cvector
- */
-#define cvector_iterator(type) cvector_vector_type(type)
-
-/**
- * @brief cvector_vec_to_base - For internal use, converts a vector pointer to a metadata pointer
- * @param vec - the vector
- * @return the metadata pointer of the vector
- * @internal
- */
-#define cvector_vec_to_base(vec) \
-    (&((cvector_metadata_t *)(vec))[-1])
-
-/**
- * @brief cvector_base_to_vec - For internal use, converts a metadata pointer to a vector pointer
- * @param ptr - pointer to the metadata
- * @return the vector
- * @internal
- */
-#define cvector_base_to_vec(ptr) \
-    ((void *)&((cvector_metadata_t *)(ptr))[1])
-
-/**
- * @brief cvector_capacity - gets the current capacity of the vector
- * @param vec - the vector
- * @return the capacity as a size_t
- */
-#define cvector_capacity(vec) \
-    ((vec) ? cvector_vec_to_base(vec)->capacity : (size_t)0)
-
-/**
- * @brief cvector_size - gets the current size of the vector
- * @param vec - the vector
- * @return the size as a size_t
- */
-#define cvector_size(vec) \
-    ((vec) ? cvector_vec_to_base(vec)->size : (size_t)0)
-
-/**
- * @brief cvector_elem_destructor - get the element destructor function used
- * to clean up elements
- * @param vec - the vector
- * @return the function pointer as cvector_elem_destructor_t
- */
-#define cvector_elem_destructor(vec) \
-    ((vec) ? cvector_vec_to_base(vec)->elem_destructor : NULL)
-
-/**
- * @brief cvector_empty - returns non-zero if the vector is empty
- * @param vec - the vector
- * @return non-zero if empty, zero if non-empty
- */
-#define cvector_empty(vec) \
-    (cvector_size(vec) == 0)
-
-/**
- * @brief cvector_reserve - Requests that the vector capacity be at least enough
- * to contain n elements. If n is greater than the current vector capacity, the
- * function causes the container to reallocate its storage increasing its
- * capacity to n (or greater).
- * @param vec - the vector
- * @param n - Minimum capacity for the vector.
- * @return void
- */
-#define cvector_reserve(vec, n)                  \
-    do {                                         \
-        size_t cv_cap__ = cvector_capacity(vec); \
-        if (cv_cap__ < (n)) {                    \
-            cvector_grow((vec), (n));            \
-        }                                        \
-    } while (0)
-
-/*
- * @brief cvector_init - Initialize a vector.  The vector must be NULL for this to do anything.
- * @param vec - the vector
- * @param capacity - vector capacity to reserve
- * @param elem_destructor_fn - element destructor function
- * @return void
- */
-#define cvector_init(vec, capacity, elem_destructor_fn)               \
-    do {                                                              \
-        if (!(vec)) {                                                 \
-            cvector_reserve((vec), capacity);                         \
-            cvector_set_elem_destructor((vec), (elem_destructor_fn)); \
-        }                                                             \
-    } while (0)
-
-/**
- * @brief cvector_erase - removes the element at index i from the vector
- * @param vec - the vector
- * @param i - index of element to remove
- * @return void
- */
-#define cvector_erase(vec, i)                                                               \
-    do {                                                                                    \
-        if (vec) {                                                                          \
-            const size_t cv_sz__ = cvector_size(vec);                                       \
-            if ((i) < cv_sz__) {                                                            \
-                cvector_elem_destructor_t elem_destructor__ = cvector_elem_destructor(vec); \
-                if (elem_destructor__) {                                                    \
-                    elem_destructor__(&(vec)[i]);                                           \
-                }                                                                           \
-                cvector_set_size((vec), cv_sz__ - 1);                                       \
-                cvector_clib_memmove(                                                       \
-                    (vec) + (i),                                                            \
-                    (vec) + (i) + 1,                                                        \
-                    sizeof(*(vec)) * (cv_sz__ - 1 - (i)));                                  \
-            }                                                                               \
-        }                                                                                   \
-    } while (0)
-
-/**
- * @brief cvector_clear - erase all of the elements in the vector
- * @param vec - the vector
- * @return void
- */
-#define cvector_clear(vec)                                                              \
-    do {                                                                                \
-        if (vec) {                                                                      \
-            cvector_elem_destructor_t elem_destructor__ = cvector_elem_destructor(vec); \
-            if (elem_destructor__) {                                                    \
-                size_t i__;                                                             \
-                for (i__ = 0; i__ < cvector_size(vec); ++i__) {                         \
-                    elem_destructor__(&(vec)[i__]);                                     \
-                }                                                                       \
-            }                                                                           \
-            cvector_set_size(vec, 0);                                                   \
-        }                                                                               \
-    } while (0)
-
-/**
- * @brief cvector_free - frees all memory associated with the vector
- * @param vec - the vector
- * @return void
- */
-#define cvector_free(vec)                                                               \
-    do {                                                                                \
-        if (vec) {                                                                      \
-            void *p1__                                  = cvector_vec_to_base(vec);     \
-            cvector_elem_destructor_t elem_destructor__ = cvector_elem_destructor(vec); \
-            if (elem_destructor__) {                                                    \
-                size_t i__;                                                             \
-                for (i__ = 0; i__ < cvector_size(vec); ++i__) {                         \
-                    elem_destructor__(&(vec)[i__]);                                     \
-                }                                                                       \
-            }                                                                           \
-            cvector_clib_free(p1__);                                                    \
-        }                                                                               \
-    } while (0)
-
-/**
- * @brief cvector_begin - returns an iterator to first element of the vector
- * @param vec - the vector
- * @return a pointer to the first element (or NULL)
- */
-#define cvector_begin(vec) \
-    (vec)
-
-/**
- * @brief cvector_end - returns an iterator to one past the last element of the vector
- * @param vec - the vector
- * @return a pointer to one past the last element (or NULL)
- */
-#define cvector_end(vec) \
-    ((vec) ? &((vec)[cvector_size(vec)]) : NULL)
-
-/* user request to use logarithmic growth algorithm */
-#ifdef CVECTOR_LOGARITHMIC_GROWTH
-
-/**
- * @brief cvector_compute_next_grow - returns an the computed size in next vector grow
- * size is increased by multiplication of 2
- * @param size - current size
- * @return size after next vector grow
- */
-#define cvector_compute_next_grow(size) \
-    ((size) ? ((size) << 1) : 1)
-
-#else
-
-/**
- * @brief cvector_compute_next_grow - returns an the computed size in next vector grow
- * size is increased by 1
- * @param size - current size
- * @return size after next vector grow
- */
-#define cvector_compute_next_grow(size) \
-    ((size) + 1)
-
-#endif /* CVECTOR_LOGARITHMIC_GROWTH */
-
-/**
- * @brief cvector_push_back - adds an element to the end of the vector
- * @param vec - the vector
- * @param value - the value to add
- * @return void
- */
-#define cvector_push_back(vec, value)                                 \
-    do {                                                              \
-        size_t cv_cap__ = cvector_capacity(vec);                      \
-        if (cv_cap__ <= cvector_size(vec)) {                          \
-            cvector_grow((vec), cvector_compute_next_grow(cv_cap__)); \
-        }                                                             \
-        (vec)[cvector_size(vec)] = (value);                           \
-        cvector_set_size((vec), cvector_size(vec) + 1);               \
-    } while (0)
-
-/**
- * @brief cvector_insert - insert element at position pos to the vector
- * @param vec - the vector
- * @param pos - position in the vector where the new elements are inserted.
- * @param val - value to be copied (or moved) to the inserted elements.
- * @return void
- */
-#define cvector_insert(vec, pos, val)                                 \
-    do {                                                              \
-        size_t cv_cap__ = cvector_capacity(vec);                      \
-        if (cv_cap__ <= cvector_size(vec)) {                          \
-            cvector_grow((vec), cvector_compute_next_grow(cv_cap__)); \
-        }                                                             \
-        if ((pos) < cvector_size(vec)) {                              \
-            cvector_clib_memmove(                                     \
-                (vec) + (pos) + 1,                                    \
-                (vec) + (pos),                                        \
-                sizeof(*(vec)) * ((cvector_size(vec)) - (pos)));      \
-        }                                                             \
-        (vec)[(pos)] = (val);                                         \
-        cvector_set_size((vec), cvector_size(vec) + 1);               \
-    } while (0)
-
-/**
- * @brief cvector_pop_back - removes the last element from the vector
- * @param vec - the vector
- * @return void
- */
-#define cvector_pop_back(vec)                                                       \
-    do {                                                                            \
-        cvector_elem_destructor_t elem_destructor__ = cvector_elem_destructor(vec); \
-        if (elem_destructor__) {                                                    \
-            elem_destructor__(&(vec)[cvector_size(vec) - 1]);                       \
-        }                                                                           \
-        cvector_set_size((vec), cvector_size(vec) - 1);                             \
-    } while (0)
-
-/**
- * @brief cvector_copy - copy a vector
- * @param from - the original vector
- * @param to - destination to which the function copy to
- * @return void
- */
-#define cvector_copy(from, to)                                                       \
-    do {                                                                             \
-        if ((from)) {                                                                \
-            cvector_grow(to, cvector_size(from));                                    \
-            cvector_set_size(to, cvector_size(from));                                \
-            cvector_clib_memcpy((to), (from), cvector_size(from) * sizeof(*(from))); \
-        }                                                                            \
-    } while (0)
-
-/**
- * @brief cvector_swap - exchanges the content of the vector by the content of another vector of the same type
- * @param vec - the original vector
- * @param other - the other vector to swap content with
- * @param type - the type of both vectors
- * @return void
- */
-#define cvector_swap(vec, other, type)                       \
-    do {                                                     \
-        if (vec && other) {                                  \
-            cvector_vector_type(type) cv_swap__ = vec;       \
-            vec                                 = other;     \
-            other                               = cv_swap__; \
-        }                                                    \
-    } while (0)
-
-/**
- * @brief cvector_set_capacity - For internal use, sets the capacity variable of the vector
- * @param vec - the vector
- * @param size - the new capacity to set
- * @return void
- * @internal
- */
-#define cvector_set_capacity(vec, size)                  \
-    do {                                                 \
-        if (vec) {                                       \
-            cvector_vec_to_base(vec)->capacity = (size); \
-        }                                                \
-    } while (0)
-
-/**
- * @brief cvector_set_size - For internal use, sets the size variable of the vector
- * @param vec - the vector
- * @param size - the new capacity to set
- * @return void
- * @internal
- */
-#define cvector_set_size(vec, _size)                  \
-    do {                                              \
-        if (vec) {                                    \
-            cvector_vec_to_base(vec)->size = (_size); \
-        }                                             \
-    } while (0)
-
-/**
- * @brief cvector_set_elem_destructor - set the element destructor function
- * used to clean up removed elements. The vector must NOT be NULL for this to do anything.
- * @param vec - the vector
- * @param elem_destructor_fn - function pointer of type cvector_elem_destructor_t used to destroy elements
- * @return void
- */
-#define cvector_set_elem_destructor(vec, elem_destructor_fn)                  \
-    do {                                                                      \
-        if (vec) {                                                            \
-            cvector_vec_to_base(vec)->elem_destructor = (elem_destructor_fn); \
-        }                                                                     \
-    } while (0)
-
-/**
- * @brief cvector_grow - For internal use, ensures that the vector is at least <count> elements big
- * @param vec - the vector
- * @param count - the new capacity to set
- * @return void
- * @internal
- */
-#define cvector_grow(vec, count)                                                      \
-    do {                                                                              \
-        const size_t cv_sz__ = (count) * sizeof(*(vec)) + sizeof(cvector_metadata_t); \
-        if (vec) {                                                                    \
-            void *cv_p1__ = cvector_vec_to_base(vec);                                 \
-            void *cv_p2__ = cvector_clib_realloc(cv_p1__, cv_sz__);                   \
-            cvector_clib_assert(cv_p2__);                                             \
-            (vec) = cvector_base_to_vec(cv_p2__);                                     \
-        } else {                                                                      \
-            void *cv_p__ = cvector_clib_malloc(cv_sz__);                              \
-            cvector_clib_assert(cv_p__);                                              \
-            (vec) = cvector_base_to_vec(cv_p__);                                      \
-            cvector_set_size((vec), 0);                                               \
-            cvector_set_elem_destructor((vec), NULL);                                 \
-        }                                                                             \
-        cvector_set_capacity((vec), (count));                                         \
-    } while (0)
-
-/**
- * @brief cvector_shrink_to_fit - requests the container to reduce its capacity to fit its size
- * @param vec - the vector
- * @return void
- */
-#define cvector_shrink_to_fit(vec)                     \
-    do {                                               \
-        if (vec) {                                     \
-            const size_t cv_sz___ = cvector_size(vec); \
-            cvector_grow(vec, cv_sz___);               \
-        }                                              \
-    } while (0)
-
-/**
- * @brief cvector_at - returns a reference to the element at position n in the vector.
- * @param vec - the vector
- * @param n - position of an element in the vector.
- * @return the element at the specified position in the vector.
- */
-#define cvector_at(vec, n) \
-    ((vec) ? (((int)(n) < 0 || (size_t)(n) >= cvector_size(vec)) ? NULL : &(vec)[n]) : NULL)
-
-/**
- * @brief cvector_front - returns a reference to the first element in the vector. Unlike member cvector_begin, which returns an iterator to this same element, this function returns a direct reference.
- * @return a reference to the first element in the vector container.
- */
-#define cvector_front(vec) \
-    ((vec) ? ((cvector_size(vec) > 0) ? cvector_at(vec, 0) : NULL) : NULL)
-
-/**
- * @brief cvector_back - returns a reference to the last element in the vector.Unlike member cvector_end, which returns an iterator just past this element, this function returns a direct reference.
- * @return a reference to the last element in the vector.
- */
-#define cvector_back(vec) \
-    ((vec) ? ((cvector_size(vec) > 0) ? cvector_at(vec, cvector_size(vec) - 1) : NULL) : NULL)
-
-/**
- * @brief cvector_resize - resizes the container to contain count elements.
- * @param vec - the vector
- * @param count - new size of the vector
- * @param value - the value to initialize new elements with
- * @return void
- */
-#define cvector_resize(vec, count, value)                          \
-    do {                                                           \
-        if (vec) {                                                 \
-            size_t cv_sz_count__ = (size_t)(count);                \
-            size_t cv_sz__       = cvector_vec_to_base(vec)->size; \
-            if (cv_sz_count__ > cv_sz__) {                         \
-                cvector_reserve((vec), cv_sz_count__);             \
-                cvector_set_size((vec), cv_sz_count__);            \
-                do {                                               \
-                    (vec)[cv_sz__++] = (value);                    \
-                } while (cv_sz__ < cv_sz_count__);                 \
-            } else {                                               \
-                while (cv_sz_count__ < cv_sz__--) {                \
-                    cvector_pop_back(vec);                         \
-                }                                                  \
-            }                                                      \
-        }                                                          \
-    } while (0)
-
-#endif /* CVECTOR_H_ */
diff --git a/include/types.h b/include/types.h
deleted file mode 100644
index 4bf1da9..0000000
--- a/include/types.h
+++ /dev/null
@@ -1,19 +0,0 @@
-#ifndef __TYPES_H__
-#define __TYPES_H__
-
-#include <stdint.h>
-
-
-typedef char     s8;
-
-typedef uint8_t  u8;
-typedef uint16_t u16;
-typedef uint32_t u32;
-typedef uint64_t i64;
-
-typedef int8_t   i8;
-typedef int16_t  i16;
-typedef int32_t  i32;
-typedef uint64_t i64;
-
-#endif /* __TYPES_H__ */
diff --git a/include/utils.h b/include/utils.h
index 29c59f1..40bb642 100644
--- a/include/utils.h
+++ b/include/utils.h
@@ -3,9 +3,6 @@
 
 #include <stdnoreturn.h>
 
-#include "types.h"
-
-
-noreturn void die(i32 code, s8 *fmt, ...);
+noreturn void die(int code, char *fmt, ...);
 
 #endif /* __UTILS_H__ */