diff --git a/.DS_Store b/.DS_Store
index 50d7e99..0d98060 100644
Binary files a/.DS_Store and b/.DS_Store differ
diff --git a/CMakeLists.txt b/CMakeLists.txt
index ae7073f..2ff6302 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -17,12 +17,12 @@ add_library(libvec STATIC
target_include_directories(libvec
# PRIVATE: Internal headers under src/lib are only visible
# to files being compiled into libvec (char.c, utils.c, libvec.c).
- PRIVATE
- ${CMAKE_CURRENT_SOURCE_DIR}/src/lib
+ # PRIVATE
# PUBLIC: Consumers (and test_runner) are granted access ONLY to include/
PUBLIC
${CMAKE_CURRENT_SOURCE_DIR}/include
+ ${CMAKE_CURRENT_SOURCE_DIR}/src/lib # Turn back to private when ready
)
add_executable(libvec_bin src/main.c)
diff --git a/Notes.md b/Notes.md
new file mode 100644
index 0000000..a1943b0
--- /dev/null
+++ b/Notes.md
@@ -0,0 +1,23 @@
+```mermaid
+flowchart TD
+ Start([Function Called]) --> CheckErr{Did an error occur?}
+
+ %% Error path
+ CheckErr -->|Yes| PushBit["Bitwise OR error code into err
err |= ERROR_BIT"]
+ PushBit --> CheckOrigin{Is origin == NULL?}
+ CheckOrigin -->|Yes| SetOrigin["Record location in origin
origin = __func__ / __FILE__"]
+ CheckOrigin -->|No| KeepOrigin[Preserve original root cause]
+
+ SetOrigin --> ReturnStruct
+ KeepOrigin --> ReturnStruct
+
+ %% Success / Normal path
+ CheckErr -->|No| ComputeValue["Write computation result
value = result"]
+ ComputeValue --> ReturnStruct
+
+ ReturnStruct(["Return / Pass Out _err_t"]) --> Caller{Caller Inspection}
+
+ Caller -->|Check errors| InspectBits[Inspect bit flags in err]
+ Caller -->|Read payload| ReadValue[Access value data]
+ Caller -->|Debug / Log| PrintOrigin[Print root cause origin]
+```
diff --git a/src/.DS_Store b/src/.DS_Store
index 3ef53b6..49e043b 100644
Binary files a/src/.DS_Store and b/src/.DS_Store differ
diff --git a/src/lib/.DS_Store b/src/lib/.DS_Store
index b856baa..40c092a 100644
Binary files a/src/lib/.DS_Store and b/src/lib/.DS_Store differ
diff --git a/src/lib/char/char.c b/src/lib/char/char.c
index ced1a96..ae6e4ec 100644
--- a/src/lib/char/char.c
+++ b/src/lib/char/char.c
@@ -4,801 +4,874 @@
#include "utils/utils.h"
-unsigned int
-_vec_char_raise_err(const _VecCharInternal* ptr, unsigned int mask)
+__attribute__((overloadable)) size_t
+__null_check(const _VecCharInternal* ptr, err_t* status)
{
- unsigned int res = SUCCESS;
- res |= mask;
- if (ptr == nullptr) res |= ERR_VEC_NULL;
- if (ptr->_internal_arr == nullptr) res |= ERR_BUF_NULL;
+ unsigned int res = 0;
+ if (ptr == nullptr)
+ {
+ status->flags |= ERR_VEC_NULL;
+ return ERR_VEC_NULL;
+ }
+ if (ptr->_internal_arr == nullptr) status->flags |= ERR_BUF_NULL;
+ if (ptr->_internal_size == 0) status->flags |= ERR_SIZE_ZERO;
+ return status->flags;
+}
- return res;
+__attribute__((overloadable)) size_t
+__null_check(const char* ptr, err_t* status)
+{
+ if (ptr == nullptr) status->flags |= ERR_BUF_NULL;
+ return status->flags;
+}
+
+size_t
+__origin_override(err_t* status, char* str)
+{
+ if (status->origin != nullptr)
+ {
+ status->flags |= ERR_ORIGIN_UNALTERABLE;
+ return status->flags;
+ }
+ else if (str == nullptr)
+ {
+ status->flags |= ERR_STR_NULL;
+ return status->flags;
+ }
+ else
+ {
+ status->origin = str;
+ return status->flags;
+ }
+}
+
+void
+_vec_char_print_vec(const _VecCharInternal* ptr, err_t* err)
+{
+ if (__null_check(ptr, err) != 0) return;
+ for (size_t i = 0; i < ptr->_internal_size; i++)
+ printf("%c ", ptr->_internal_arr[i]);
+ printf("\n");
}
_VecCharInternal
-_vec_char_create(const char* src, const size_t size)
+_vec_char_cpy(const char* src, const size_t src_size, err_t* err)
{
- unsigned int err = 0;
- _VecCharInternal self = {
- ._internal_arr = NULL,
- ._internal_size = 0,
- ._internal_capacity = CAPACITY,
- ._internal_max_size = VEC_MAX,
- };
- if (size >= self._internal_max_size)
+ _VecCharInternal self = VEC_INIT;
+ err_t status = ERR_T_INIT;
+
+ if (__null_check(src, &status) != 0)
{
- LOG("If you need more memory to start, create a blank and "
- "reserve.");
+ __origin_override(err, "CPY");
+ err->flags |= status.flags;
return self;
}
- if (self._internal_capacity < size)
+ if (src_size == 0)
{
- size_t dst_cap = self._internal_capacity;
- while (dst_cap < size && dst_cap * 2 < self._internal_max_size)
- dst_cap *= 2;
- self._internal_capacity = (dst_cap < size) ? size : dst_cap;
+ __origin_override(err, "CPY");
+ err->flags |= ERR_SIZE_ZERO;
+ err->flags |= status.flags;
+ return self;
}
- if (size > 0)
+ self._internal_arr = malloc(src_size * sizeof(char));
+ __null_check(self._internal_arr, &status);
+ if (status.flags != 0)
{
- self._internal_arr =
- calloc(self._internal_capacity, sizeof(char));
- err = _vec_char_raise_err(&self, err);
- if (!(err & SUCCESS))
- {
- self._internal_arr = NULL;
- vec_print_errs(err);
- free(self._internal_arr);
- return self;
- }
- }
- if (!src) err |= ERR_BUF_NULL;
- else
- {
- for (size_t i = 0; i < size; i++)
- {
- self._internal_arr[i] = src[i];
- self._internal_size++;
- }
+ __origin_override(err, "CPY");
+ err->flags |= status.flags;
+ free(self._internal_arr);
+ self._internal_arr = NULL;
+ return self;
}
+ memcpy(self._internal_arr, src, src_size * sizeof(char));
+ self._internal_size = src_size;
+ self._internal_capacity = src_size;
return self;
}
-// size_t
-// _vec_char_push_back(_VecCharInternal* ptr, const char val)
-// {
-// char* res;
-// size_t _ptr_err = _vec_char_is_valid(ptr);
-// if (_ptr_err == ERR_VECTOR_NULL)
-// {
-// return ERR_VECTOR_NULL;
-// }
-//
-// if (ptr->_internal_size + 1 > ptr->_internal_max_size)
-// {
-// LOGERROR(ERR_MAX_PASSED);
-// return ERR_MAX_PASSED;
-// }
-//
-// if (_ptr_err == ERR_BUF_NULL && ptr->_internal_size == 0)
-// {
-// res = calloc(1, sizeof(char));
-// if (!res)
-// {
-// LOGERROR(ERR_ALLOC_FAIL);
-// return ERR_ALLOC_FAIL;
-// }
-// ptr->_internal_arr = res;
-// ptr->_internal_arr[0] = val;
-// ptr->_internal_size++;
-// return SUCCESS;
-// }
-//
-// else if (ptr->_internal_size + 1 > ptr->_internal_capacity)
-// {
-// size_t dst_cap = ptr->_internal_capacity * 2;
-// if (dst_cap > ptr->_internal_max_size)
-// {
-// ptr->_internal_capacity = ptr->_internal_max_size;
-// res = realloc(ptr->_internal_arr,
-// ptr->_internal_capacity * sizeof(char));
-// DEBUG(
-// "Capacity cannot be grown any further due "
-// "to hitting max size");
-// }
-// else
-// {
-// res =
-// realloc(ptr->_internal_arr, dst_cap * sizeof(char));
-// ptr->_internal_capacity = dst_cap;
-// }
-//
-// if (!res)
-// {
-// LOGERROR(ERR_ALLOC_FAIL);
-// return ERR_ALLOC_FAIL;
-// }
-// }
-// else
-// {
-// res = ptr->_internal_arr;
-// }
-// ptr->_internal_arr = res;
-// ptr->_internal_arr[ptr->_internal_size] = val;
-// ptr->_internal_size++;
-// return SUCCESS;
-// }
-//
-// size_t
-// _vec_char_pop_back(_VecCharInternal* ptr)
-// {
-// size_t _ptr_err = _vec_char_is_valid(ptr);
-// if (_ptr_err == ERR_VECTOR_NULL)
-// {
-// return ERR_VECTOR_NULL;
-// }
-// if (_ptr_err == ERR_BUF_NULL)
-// {
-// return ERR_BUF_NULL;
-// }
-// if (ptr->_internal_size < 1)
-// {
-// LOGERROR(ERR_SIZE_ZERO);
-// return ERR_SIZE_ZERO;
-// }
-//
-// ptr->_internal_arr[ptr->_internal_size - 1] = '\0';
-// ptr->_internal_size--;
-// return SUCCESS;
-// }
-//
-// size_t
-// _vec_char_reserve(_VecCharInternal* ptr, const size_t capacity)
-// {
-// char* res;
-// size_t _ptr_err = _vec_char_is_valid(ptr);
-// if (capacity == 0)
-// {
-// LOGERROR(ERR_SIZE_ZERO);
-// return ERR_SIZE_ZERO;
-// }
-// if (_ptr_err == ERR_VECTOR_NULL)
-// {
-// return ERR_VECTOR_NULL;
-// }
-// if (_ptr_err == ERR_BUF_NULL)
-// {
-// res = calloc(ptr->_internal_capacity, sizeof(char));
-// if (!res)
-// {
-// LOGERROR(ERR_ALLOC_FAIL);
-// return ERR_ALLOC_FAIL;
-// }
-// }
-// else if (_ptr_err == SUCCESS)
-// {
-// res = realloc(ptr->_internal_arr, capacity * sizeof(char));
-// if (!res)
-// {
-// LOGERROR(ERR_ALLOC_FAIL);
-// return ERR_ALLOC_FAIL;
-// }
-// if (ptr->_internal_size > capacity)
-// {
-// for (size_t i = capacity; i < ptr->_internal_size; i++)
-// {
-// ptr->_internal_arr[i] = '\0';
-// }
-// ptr->_internal_size = capacity;
-// }
-// }
-// ptr->_internal_arr = res;
-// ptr->_internal_capacity = capacity;
-// ptr->_internal_max_size = capacity;
-// return SUCCESS;
-// }
-//
-// size_t
-// _vec_char_shrink_to_fit(_VecCharInternal* ptr)
-// {
-// size_t _ptr_err = _vec_char_is_valid(ptr);
-// if (_ptr_err == ERR_VECTOR_NULL)
-// {
-// LOGERROR(ERR_VECTOR_NULL);
-// return ERR_VECTOR_NULL;
-// }
-// if (_ptr_err == ERR_BUF_NULL)
-// {
-// LOGERROR(ERR_BUF_NULL);
-// return ERR_BUF_NULL;
-// }
-// if (_ptr_err == 0)
-// {
-// LOGERROR(ERR_SIZE_ZERO);
-// return ERR_SIZE_ZERO;
-// }
-// return _vec_char_reserve(ptr, ptr->_internal_size);
-// }
-//
-// size_t
-// _vec_char_swap(_VecCharInternal* ptr1, _VecCharInternal* ptr2)
-// {
-// _VecCharInternal self = _vec_char_create(nullptr, 0);
-// size_t _ptr1_err = _vec_char_is_valid(ptr1);
-// size_t _ptr2_err = _vec_char_is_valid(ptr2);
-// if (_ptr1_err == ERR_VECTOR_NULL || _ptr2_err == ERR_VECTOR_NULL)
-// {
-// LOGERROR(ERR_VECTOR_NULL);
-// return ERR_VECTOR_NULL;
-// }
-// if (_ptr1_err == ERR_BUF_NULL || _ptr2_err == ERR_BUF_NULL)
-// {
-// LOGERROR(ERR_BUF_NULL);
-// return ERR_BUF_NULL;
-// }
-// self._internal_arr = ptr1->_internal_arr;
-// ptr1->_internal_arr = ptr2->_internal_arr;
-// ptr2->_internal_arr = self._internal_arr;
-//
-// self._internal_capacity = ptr1->_internal_capacity;
-// self._internal_size = ptr1->_internal_size;
-// self._internal_max_size = ptr1->_internal_max_size;
-// ptr1->_internal_capacity = ptr2->_internal_capacity;
-// ptr1->_internal_size = ptr2->_internal_size;
-// ptr1->_internal_max_size = ptr2->_internal_max_size;
-//
-// ptr2->_internal_capacity = self._internal_capacity;
-// ptr2->_internal_size = self._internal_size;
-// ptr2->_internal_max_size = self._internal_max_size;
-// return SUCCESS;
-// }
-//
-// char*
-// _vec_char_data(const _VecCharInternal* ptr)
-// {
-// if (_vec_char_is_valid(ptr) == ERR_BUF_NULL ||
-// _vec_char_is_valid(ptr) == ERR_VECTOR_NULL)
-// return nullptr;
-// return &ptr->_internal_arr[0];
-// }
-//
-// size_t
-// _vec_char_capacity(const _VecCharInternal* ptr)
-// {
-// if (_vec_char_is_valid(ptr) == ERR_VECTOR_NULL)
-// {
-// return ERR_VECTOR_NULL;
-// }
-// if (_vec_char_is_valid(ptr) == ERR_BUF_NULL)
-// {
-// return ERR_BUF_NULL;
-// }
-// return ptr->_internal_capacity;
-// }
-//
-// size_t
-// _vec_char_max_size(const _VecCharInternal* ptr)
-// {
-// if (_vec_char_is_valid(ptr) == ERR_VECTOR_NULL)
-// {
-// return ERR_VECTOR_NULL;
-// }
-// if (_vec_char_is_valid(ptr) == ERR_BUF_NULL)
-// {
-// return ERR_BUF_NULL;
-// }
-// return ptr->_internal_max_size;
-// }
-//
-// void
-// _vec_char_delete(const _VecCharInternal* ptr)
-// {
-// if (_vec_char_is_valid(ptr) == SUCCESS)
-// {
-// free((void*)ptr->_internal_arr);
-// }
-// }
-//
-// size_t
-// _vec_char_clear(_VecCharInternal* ptr)
-// {
-// if (_vec_char_is_valid(ptr) == ERR_VECTOR_NULL)
-// {
-// return ERR_VECTOR_NULL;
-// }
-// if (_vec_char_is_valid(ptr) == ERR_BUF_NULL)
-// {
-// return ERR_BUF_NULL;
-// }
-// if (ptr->_internal_size > 0)
-// {
-// for (size_t i = 0; i < ptr->_internal_size; i++)
-// {
-// ptr->_internal_arr[i] = 0;
-// }
-// ptr->_internal_size = 0;
-// }
-// return SUCCESS;
-// }
-//
-// char
-// _vec_char_at(const _VecCharInternal* ptr, const size_t idx)
-// {
-// if (_vec_char_is_valid(ptr) == ERR_VECTOR_NULL)
-// {
-// return ERR_VECTOR_NULL;
-// }
-// if (_vec_char_is_valid(ptr) == ERR_BUF_NULL)
-// {
-// return ERR_BUF_NULL;
-// }
-// if (idx >= ptr->_internal_size)
-// {
-// fprintf(stderr,
-// "At Index: [%zu] is out of bounds for size: [%zu]\n",
-// idx, ptr->_internal_size);
-// return ERR_OUT_OF_BOUNDS;
-// }
-// return ptr->_internal_arr[idx];
-// }
-//
-// void
-// _vec_char_print_vec(const _VecCharInternal* ptr)
-// {
-// if (_vec_char_is_valid(ptr) == ERR_VECTOR_NULL ||
-// _vec_char_is_valid(ptr) == ERR_BUF_NULL)
-// return;
-// for (size_t i = 0; i < ptr->_internal_size; i++)
-// printf("%c ", ptr->_internal_arr[i]);
-// printf("\n");
-// }
-//
-// size_t
-// _vec_char_begin(const _VecCharInternal* ptr)
-// {
-// if (_vec_char_is_valid(ptr) == SUCCESS) return 0;
-// return FAILURE;
-// }
-//
-// size_t
-// _vec_char_end(const _VecCharInternal* ptr)
-// {
-// if (_vec_char_is_valid(ptr) == SUCCESS)
-// {
-// if (ptr->_internal_size != 0)
-// return (int)(ptr->_internal_size - 1);
-// else return FAILURE;
-// }
-// return FAILURE;
-// }
-//
-// char
-// _vec_char_front(const _VecCharInternal* ptr)
-// {
-// if (_vec_char_is_valid(ptr) == ERR_VECTOR_NULL) return FAILURE;
-// if (ptr->_internal_size == 0) return FAILURE;
-// return _vec_char_at(ptr, 0);
-// }
-//
-// char
-// _vec_char_back(const _VecCharInternal* ptr)
-// {
-// if (_vec_char_is_valid(ptr) == ERR_VECTOR_NULL) return FAILURE;
-// if (ptr->_internal_size == 0) return FAILURE;
-// return _vec_char_at(ptr, ptr->_internal_size - 1);
-// }
-//
-// size_t
-// _vec_char_empty(const _VecCharInternal* ptr)
-// {
-// if (_vec_char_is_valid(ptr) == ERR_VECTOR_NULL ||
-// _vec_char_is_valid(ptr) == ERR_BUF_NULL)
-// return FAILURE;
-// if (ptr->_internal_size == 0) return SUCCESS;
-// return FAILURE;
-// }
-//
+void
+_vec_char_push_back(_VecCharInternal* ptr, const char val, err_t* err)
+{
+ err_t status = ERR_T_INIT;
+ char* res;
+ __null_check(ptr, &status);
+ if ((status.flags & ERR_VEC_NULL) != 0)
+ {
+ __origin_override(err, "PUSH_BACK");
+ err->flags |= ERR_VEC_NULL;
+ return;
+ }
+
+ if (ptr->_internal_size + 1 > ptr->_internal_max_size)
+ {
+ __origin_override(err, "PUSH_BACK");
+ err->flags |= ERR_SIZE_OVERFLOW;
+ return;
+ }
+
+ if ((status.flags & ERR_BUF_NULL) != 0)
+ {
+ res = malloc(1 * sizeof(char));
+ if (res == nullptr)
+ {
+ __origin_override(err, "PUSH_BACK");
+ err->flags |= ERR_BUF_NULL;
+ return;
+ }
+ ptr->_internal_arr = res;
+ ptr->_internal_capacity = 1;
+ }
+
+ else if (ptr->_internal_size + 1 > ptr->_internal_capacity)
+ {
+ size_t dst_cap =
+ (ptr->_internal_capacity / 2) + ptr->_internal_capacity;
+ if (dst_cap == ptr->_internal_capacity) dst_cap++;
+ if (dst_cap > ptr->_internal_max_size)
+ {
+ dst_cap = ptr->_internal_max_size;
+ DEBUG(
+ "Capacity cannot be grown any further due "
+ "to hitting max size");
+ }
+ res = realloc(ptr->_internal_arr, dst_cap * sizeof(char));
+ if (res == nullptr)
+ {
+ __origin_override(err, "PUSH_BACK");
+ err->flags |= ERR_SIZE_OVERFLOW;
+ return;
+ }
+ ptr->_internal_arr = res;
+ ptr->_internal_capacity = dst_cap;
+ }
+ ptr->_internal_arr[ptr->_internal_size] = val;
+ ptr->_internal_size++;
+ return;
+}
+
+void
+_vec_char_pop_back(_VecCharInternal* ptr, err_t* err)
+{
+ if (__null_check(ptr, err) != 0)
+ {
+ __origin_override(err, "POP_BACK");
+ return;
+ }
+
+ ptr->_internal_arr[ptr->_internal_size - 1] = '\0';
+ ptr->_internal_size--;
+}
+
+void
+_vec_char_reserve(_VecCharInternal* ptr, const size_t capacity, err_t* err)
+{
+ err_t status = ERR_T_INIT;
+ char* res;
+ if (capacity == 0)
+ {
+ __origin_override(err, "RESERVE");
+ err->flags |= ERR_SIZE_ZERO;
+ return;
+ }
+ if (__null_check(ptr, &status) != 0)
+ {
+ if ((status.flags & ERR_BUF_NULL) != 0)
+ {
+ res = calloc(ptr->_internal_capacity, sizeof(char));
+ if (res == nullptr)
+ {
+ __origin_override(err, "RESERVE");
+ err->flags |= ERR_ALLOC_FAIL;
+ return;
+ }
+ }
+
+ else
+ {
+ __origin_override(err, "RESERVE");
+ err->flags |= (status.flags ^ ERR_BUF_NULL);
+ return;
+ }
+ }
+
+ else
+ {
+ res = realloc(ptr->_internal_arr, capacity * sizeof(char));
+ if (res == nullptr)
+ {
+ __origin_override(err, "RESERVE");
+ err->flags |= ERR_ALLOC_FAIL;
+ return;
+ }
+ if (ptr->_internal_size > capacity)
+ {
+ for (size_t i = capacity; i < ptr->_internal_size; i++)
+ {
+ ptr->_internal_arr[i] = '\0';
+ }
+ ptr->_internal_size = capacity;
+ }
+ }
+ ptr->_internal_arr = res;
+ ptr->_internal_capacity = capacity;
+ ptr->_internal_max_size = capacity;
+ return;
+}
+
+void
+_vec_char_shrink_to_fit(_VecCharInternal* ptr, err_t* err)
+{
+ err_t status = ERR_T_INIT;
+ __null_check(ptr, &status);
+ if (__null_check(ptr, &status) != 0)
+ {
+ __origin_override(err, "SHRINK_TO_FIT");
+ err->flags |= status.flags;
+ return;
+ }
+ return _vec_char_reserve(ptr, ptr->_internal_size, err);
+}
+
+void
+_vec_char_swap(_VecCharInternal* ptr1, _VecCharInternal* ptr2, err_t* err)
+{
+ _VecCharInternal self = VEC_INIT;
+ err_t status_1 = ERR_T_INIT, status_2 = ERR_T_INIT;
+ if (__null_check(ptr1, &status_1) != 0 ||
+ __null_check(ptr2, &status_2) != 0)
+ {
+ __origin_override(err, "SWAP");
+ err->flags |= status_1.flags | status_2.flags;
+ return;
+ }
+ self._internal_arr = ptr1->_internal_arr;
+ ptr1->_internal_arr = ptr2->_internal_arr;
+ ptr2->_internal_arr = self._internal_arr;
+
+ self._internal_capacity = ptr1->_internal_capacity;
+ self._internal_size = ptr1->_internal_size;
+ self._internal_max_size = ptr1->_internal_max_size;
+ ptr1->_internal_capacity = ptr2->_internal_capacity;
+ ptr1->_internal_size = ptr2->_internal_size;
+ ptr1->_internal_max_size = ptr2->_internal_max_size;
+
+ ptr2->_internal_capacity = self._internal_capacity;
+ ptr2->_internal_size = self._internal_size;
+ ptr2->_internal_max_size = self._internal_max_size;
+ return;
+}
+
+char*
+_vec_char_data(const _VecCharInternal* ptr, err_t* err)
+{
+ err_t status = ERR_T_INIT;
+ if (__null_check(ptr, &status) != 0)
+ {
+ __origin_override(err, "DATA");
+ err->flags |= status.flags;
+ return nullptr;
+ }
+ return &ptr->_internal_arr[0];
+}
+
+size_t
+_vec_char_capacity(const _VecCharInternal* ptr, err_t* err)
+{
+ err_t status = ERR_T_INIT;
+ if (__null_check(ptr, &status) != 0)
+ {
+ __origin_override(err, "CAPACITY");
+ err->flags |= status.flags;
+ return 0;
+ }
+ return ptr->_internal_capacity;
+}
+
+size_t
+_vec_char_max_size(const _VecCharInternal* ptr, err_t* err)
+{
+ err_t status = ERR_T_INIT;
+ if (__null_check(ptr, &status) != 0)
+ {
+ __origin_override(err, "MAX_SIZE");
+ err->flags |= status.flags;
+ return 0;
+ }
+ return ptr->_internal_max_size;
+}
+
+void
+_vec_char_delete(const _VecCharInternal* ptr, err_t* err)
+{
+ err_t status = ERR_T_INIT;
+ if (__null_check(ptr, &status) != 0)
+ {
+ __origin_override(err, "DELETE");
+ err->flags |= status.flags;
+ return;
+ }
+ free((void*)ptr->_internal_arr);
+}
+
+void
+_vec_char_clear(_VecCharInternal* ptr, err_t* err)
+{
+ err_t status = ERR_T_INIT;
+ if (__null_check(ptr, &status) != 0)
+ {
+ __origin_override(err, "CLEAR");
+ err->flags |= status.flags;
+ return;
+ }
+ if (ptr->_internal_size > 0)
+ {
+ for (size_t i = 0; i < ptr->_internal_size; i++)
+ {
+ ptr->_internal_arr[i] = 0;
+ }
+ ptr->_internal_size = 0;
+ }
+}
+
+char
+_vec_char_at(const _VecCharInternal* ptr, const size_t idx, err_t* err)
+{
+ err_t status = ERR_T_INIT;
+ if (__null_check(ptr, &status) != 0)
+ {
+ __origin_override(err, "AT");
+ err->flags |= status.flags;
+ return status.flags;
+ }
+ if (idx >= ptr->_internal_size)
+ {
+ fprintf(stderr,
+ "At Index: [%zu] is out of bounds for size: [%zu]\n",
+ idx, ptr->_internal_size);
+ return ERR_OUT_OF_BOUNDS;
+ }
+ return ptr->_internal_arr[idx];
+}
+
+size_t
+_vec_char_begin(const _VecCharInternal* ptr, err_t* err)
+{
+ err_t status = ERR_T_INIT;
+ if (__null_check(ptr, &status) != 0)
+ {
+ __origin_override(err, "BEGIN");
+ err->flags |= status.flags;
+ return status.flags;
+ }
+ return 0;
+}
+
+size_t
+_vec_char_end(const _VecCharInternal* ptr, err_t* err)
+{
+ err_t status = ERR_T_INIT;
+ if (__null_check(ptr, &status) != 0)
+ {
+ __origin_override(err, "END");
+ err->flags |= status.flags;
+ return status.flags;
+ }
+ return (int)(ptr->_internal_size - 1);
+}
+
+char
+_vec_char_front(const _VecCharInternal* ptr, err_t* err)
+{
+ err_t status = ERR_T_INIT;
+ if (__null_check(ptr, &status) != 0)
+ {
+ __origin_override(err, "FRONT");
+ err->flags |= status.flags;
+ return status.flags;
+ }
+ return _vec_char_at(ptr, 0, err);
+}
+
+char
+_vec_char_back(const _VecCharInternal* ptr, err_t* err)
+{
+ err_t status = ERR_T_INIT;
+ if (__null_check(ptr, &status) != 0)
+ {
+ __origin_override(err, "BACK");
+ err->flags |= status.flags;
+ return status.flags;
+ }
+ return _vec_char_at(ptr, ptr->_internal_size - 1, err);
+}
+
+size_t
+_vec_char_empty(const _VecCharInternal* ptr, err_t* err)
+{
+ err_t status = ERR_T_INIT;
+ if (__null_check(ptr, &status) != 0)
+ {
+ if ((status.flags & ERR_SIZE_ZERO) != 0)
+ {
+ err->flags ^= ERR_SIZE_ZERO;
+ return SUCCESS;
+ }
+ __origin_override(err, "EMPTY");
+ err->flags |= status.flags;
+ return status.flags;
+ }
+ return status.flags;
+}
+
+// TODO: Fix return value
+__attribute__((overloadable)) void
+_vec_char_erase(_VecCharInternal* ptr, const size_t iter, err_t* err)
+{
+ err_t status = ERR_T_INIT;
+ if (__null_check(ptr, &status) != 0)
+ {
+ __origin_override(err, "ERASE");
+ err->flags |= status.flags;
+ return;
+ }
+ if (iter >= ptr->_internal_size) return;
+ memmove(&ptr->_internal_arr[iter], &ptr->_internal_arr[iter + 1],
+ (ptr->_internal_size - iter - 1) * sizeof(char));
+ ptr->_internal_arr[ptr->_internal_size - 1] = 0;
+ ptr->_internal_size--;
+ return;
+}
+
// // TODO: Fix return value
-// __attribute__((overloadable)) size_t
-// _vec_char_erase(_VecCharInternal* ptr, const size_t iter)
-// {
-// if (_vec_char_is_valid(ptr) == ERR_VECTOR_NULL) return ERR_VECTOR_NULL;
-// if (_vec_char_is_valid(ptr) == ERR_BUF_NULL) return ERR_BUF_NULL;
-// if (iter >= ptr->_internal_size) return ERR_OUT_OF_BOUNDS;
-// memmove(&ptr->_internal_arr[iter], &ptr->_internal_arr[iter + 1],
-// (ptr->_internal_size - iter - 1) * sizeof(char));
-// ptr->_internal_arr[ptr->_internal_size - 1] = 0;
-// ptr->_internal_size--;
-// return SUCCESS;
-// }
-//
-// // TODO: Fix return value
-// __attribute__((overloadable)) size_t
-// _vec_char_erase(_VecCharInternal* ptr, const size_t iter_start,
-// const size_t iter_end)
-// {
-// if (_vec_char_is_valid(ptr) == ERR_VECTOR_NULL) return ERR_VECTOR_NULL;
-// if (_vec_char_is_valid(ptr) == ERR_BUF_NULL) return ERR_BUF_NULL;
-// if (iter_end > ptr->_internal_size) return ERR_OUT_OF_BOUNDS;
-// if (iter_start >= iter_end) return ERR_OUT_OF_BOUNDS;
-// size_t diff = iter_end - iter_start;
-// memmove(&ptr->_internal_arr[iter_start], &ptr->_internal_arr[iter_end],
-// (ptr->_internal_size - iter_end) * sizeof(char));
-// for (size_t i = ptr->_internal_size - diff; i < ptr->_internal_size;
-// i++)
-// {
-// ptr->_internal_arr[i] = 0;
-// }
-// ptr->_internal_size -= diff;
-// return SUCCESS;
-// }
-//
-// __attribute__((overloadable)) size_t
-// _vec_char_resize(_VecCharInternal* ptr, const size_t size)
-// {
-// if (_vec_char_is_valid(ptr) == ERR_VECTOR_NULL)
-// {
-// return ERR_VECTOR_NULL;
-// }
-// if (_vec_char_is_valid(ptr) == ERR_BUF_NULL)
-// {
-// return ERR_BUF_NULL;
-// }
-// if (ptr->_internal_size == size)
-// {
-// LOG("ERR :- Ptr size and size are the same");
-// return ERR_OUT_OF_BOUNDS;
-// }
-//
-// else if (size > ptr->_internal_max_size)
-// {
-// LOGERROR(ERR_MAX_PASSED);
-// return ERR_MAX_PASSED;
-// }
-//
-// else if (ptr->_internal_size == 0)
-// {
-// size_t max = ptr->_internal_max_size;
-// size_t res = _vec_char_reserve(ptr, size);
-// if (res != SUCCESS)
-// {
-// return res;
-// }
-// if (ptr->_internal_capacity != size)
-// {
-// LOGERROR(ERR_ALLOC_FAIL);
-// return ERR_ALLOC_FAIL;
-// }
-// for (size_t i = 0; i < size; i++)
-// {
-// ptr->_internal_arr[i] = '\0';
-// }
-// ptr->_internal_max_size = max;
-// ptr->_internal_size = size;
-// return SUCCESS;
-// }
-// else if (size > ptr->_internal_capacity)
-// {
-// size_t tmpcp = ptr->_internal_capacity;
-// size_t tmpmx = ptr->_internal_max_size;
-// while (size > tmpcp)
-// {
-// tmpcp *= 2;
-// }
-// if (tmpcp > ptr->_internal_max_size)
-// {
-// tmpcp = size;
-// }
-// size_t res = _vec_char_reserve(ptr, tmpcp);
-// if (res != SUCCESS)
-// {
-// return res;
-// }
-// if (ptr->_internal_capacity != tmpcp)
-// {
-// LOGERROR(ERR_ALLOC_FAIL);
-// return ERR_ALLOC_FAIL;
-// }
-// ptr->_internal_max_size = tmpmx;
-// }
-// if (size < ptr->_internal_size)
-// {
-// for (size_t i = size; i < ptr->_internal_size; i++)
-// {
-// ptr->_internal_arr[i] = '\0';
-// }
-// }
-// if (ptr->_internal_size < size && size <= ptr->_internal_capacity)
-// {
-// for (size_t i = ptr->_internal_size; i < size; i++)
-// {
-// ptr->_internal_arr[i] = '\0';
-// }
-// }
-// ptr->_internal_size = size;
-// return SUCCESS;
-// }
-//
-// __attribute__((overloadable)) size_t
-// _vec_char_resize(_VecCharInternal* ptr, const size_t size, const char val)
-// {
-// if (_vec_char_is_valid(ptr) == ERR_VECTOR_NULL)
-// {
-// return ERR_VECTOR_NULL;
-// }
-// if (_vec_char_is_valid(ptr) == ERR_BUF_NULL)
-// {
-// return ERR_BUF_NULL;
-// }
-// if (ptr->_internal_size == size)
-// {
-// LOG("ERR :- Ptr size and size are the same");
-// return ERR_OUT_OF_BOUNDS;
-// }
-//
-// else if (size > ptr->_internal_max_size)
-// {
-// LOGERROR(ERR_MAX_PASSED);
-// return ERR_MAX_PASSED;
-// }
-//
-// else if (ptr->_internal_size == 0)
-// {
-// size_t max = ptr->_internal_max_size;
-// size_t res = _vec_char_reserve(ptr, size);
-// if (res != SUCCESS)
-// {
-// return res;
-// }
-// if (ptr->_internal_capacity != size)
-// {
-// LOGERROR(ERR_ALLOC_FAIL);
-// return ERR_ALLOC_FAIL;
-// }
-// for (size_t i = 0; i < size; i++)
-// {
-// ptr->_internal_arr[i] = val;
-// }
-// ptr->_internal_max_size = max;
-// ptr->_internal_size = size;
-// return SUCCESS;
-// }
-// else if (size > ptr->_internal_capacity)
-// {
-// size_t tmpcp = ptr->_internal_capacity;
-// size_t tmpmx = ptr->_internal_max_size;
-// while (size > tmpcp)
-// {
-// tmpcp *= 2;
-// }
-// if (tmpcp > ptr->_internal_max_size)
-// {
-// tmpcp = size;
-// }
-// size_t _ptr_err = _vec_char_reserve(ptr, tmpcp);
-// if (_ptr_err != SUCCESS)
-// {
-// LOGERROR(ERR_ALLOC_FAIL);
-// return ERR_ALLOC_FAIL;
-// }
-// ptr->_internal_max_size = tmpmx;
-// }
-// if (size < ptr->_internal_size)
-// {
-// for (size_t i = size; i < ptr->_internal_size; i++)
-// {
-// ptr->_internal_arr[i] = val;
-// }
-// }
-// if (ptr->_internal_size < size && size <= ptr->_internal_capacity)
-// {
-// for (size_t i = ptr->_internal_size; i < size; i++)
-// {
-// ptr->_internal_arr[i] = val;
-// }
-// }
-// ptr->_internal_size = size;
-// return SUCCESS;
-// }
-//
-// __attribute__((overloadable)) size_t
-// _vec_char_assign(_VecCharInternal* ptr, const _VecCharInternal* iterator,
-// const size_t iter_start, const size_t iter_end)
-// {
-// if (_vec_char_is_valid(ptr) == ERR_VECTOR_NULL)
-// {
-// return ERR_VECTOR_NULL;
-// }
-// if (_vec_char_is_valid(ptr) == ERR_BUF_NULL)
-// {
-// return ERR_BUF_NULL;
-// }
-// if (_vec_char_is_valid(iterator) == ERR_VECTOR_NULL)
-// {
-// return ERR_VECTOR_NULL;
-// }
-// if (_vec_char_is_valid(iterator) == ERR_BUF_NULL)
-// {
-// return ERR_BUF_NULL;
-// }
-// if (ptr->_internal_arr == iterator->_internal_arr)
-// {
-// LOGERROR(ERR_DOUBLE_BUF);
-// return ERR_DOUBLE_BUF;
-// }
-// if (iterator->_internal_size < iter_end || iter_end <= iter_start)
-// {
-// LOGERROR(ERR_OUT_OF_BOUNDS);
-// return ERR_OUT_OF_BOUNDS;
-// }
-// size_t res =
-// _vec_char_erase(ptr, _vec_char_begin(ptr), _vec_char_end(ptr) + 1);
-// if (res != SUCCESS)
-// {
-// return res;
-// }
-// res = _vec_char_reserve(ptr, (iter_end - iter_start));
-// if (res != SUCCESS)
-// {
-// return res;
-// }
-// for (size_t i = iter_start; i < iter_end; i++)
-// {
-// res = _vec_char_push_back(ptr, _vec_char_at(iterator, i));
-// if (res != SUCCESS)
-// {
-// return res;
-// }
-// }
-// return SUCCESS;
-// }
-//
-// __attribute__((overloadable)) size_t
-// _vec_char_assign(_VecCharInternal* ptr, const size_t amount, const char val)
-// {
-// if (_vec_char_is_valid(ptr) == ERR_VECTOR_NULL)
-// {
-// return ERR_VECTOR_NULL;
-// }
-// if (_vec_char_is_valid(ptr) == ERR_BUF_NULL)
-// {
-// return ERR_BUF_NULL;
-// }
-// if (amount == 0)
-// {
-// LOGERROR(ERR_SIZE_ZERO);
-// return ERR_SIZE_ZERO;
-// }
-// size_t res =
-// _vec_char_erase(ptr, _vec_char_begin(ptr), _vec_char_end(ptr) + 1);
-// if (res != SUCCESS)
-// {
-// return res;
-// }
-// res = _vec_char_reserve(ptr, amount);
-// if (res != SUCCESS)
-// {
-// return res;
-// }
-//
-// for (size_t i = 0; i < amount; i++)
-// {
-// res = _vec_char_push_back(ptr, val);
-// if (res != SUCCESS)
-// {
-// return res;
-// }
-// }
-// return SUCCESS;
-// }
-//
-// __attribute__((overloadable)) size_t
-// _vec_char_insert(_VecCharInternal* ptr, const size_t iter, const char val)
-// {
-// if (_vec_char_is_valid(ptr) == ERR_VECTOR_NULL)
-// {
-// return ERR_VECTOR_NULL;
-// }
-// if (_vec_char_is_valid(ptr) == ERR_BUF_NULL)
-// {
-// return ERR_BUF_NULL;
-// }
-// if (ptr->_internal_max_size < ptr->_internal_size + 1)
-// {
-// LOGERROR(ERR_MAX_PASSED);
-// return ERR_MAX_PASSED;
-// }
-// if (iter > ptr->_internal_size)
-// {
-// LOGERROR(ERR_OUT_OF_BOUNDS);
-// return ERR_OUT_OF_BOUNDS;
-// }
-// size_t _ptr_err = _vec_char_push_back(ptr, 0);
-// if (_ptr_err != SUCCESS)
-// {
-// return _ptr_err;
-// }
-// for (size_t i = ptr->_internal_size - 1; i > iter; i--)
-// {
-// ptr->_internal_arr[i] = ptr->_internal_arr[i - 1];
-// }
-// ptr->_internal_arr[iter] = val;
-//
-// return SUCCESS;
-// }
-//
-// __attribute__((overloadable)) size_t
-// _vec_char_insert(_VecCharInternal* ptr, const size_t iter, const size_t
-// amount, const char val)
-// {
-// if (_vec_char_is_valid(ptr) == ERR_VECTOR_NULL)
-// {
-// return ERR_VECTOR_NULL;
-// }
-// if (_vec_char_is_valid(ptr) == ERR_BUF_NULL)
-// {
-// return ERR_BUF_NULL;
-// }
-// if (iter > ptr->_internal_size)
-// {
-// LOGERROR(ERR_OUT_OF_BOUNDS);
-// return ERR_OUT_OF_BOUNDS;
-// }
-// if (amount <= 0)
-// {
-// LOGERROR(ERR_SIZE_ZERO);
-// return ERR_SIZE_ZERO;
-// }
-// for (size_t i = iter; i < iter + amount; i++)
-// {
-// size_t _ptr_err = _vec_char_insert(ptr, i, val);
-// if (_ptr_err != SUCCESS)
-// {
-// return _ptr_err;
-// }
-// }
-// return SUCCESS;
-// }
-//
-// __attribute__((overloadable)) size_t
-// _vec_char_insert(_VecCharInternal* ptr, const _VecCharInternal* iterator,
-// const size_t iter, const size_t iter_start,
-// const size_t iter_end)
-// {
-// if (_vec_char_is_valid(ptr) == ERR_VECTOR_NULL)
-// {
-// return ERR_VECTOR_NULL;
-// }
-// if (_vec_char_is_valid(ptr) == ERR_BUF_NULL)
-// {
-// return ERR_BUF_NULL;
-// }
-// if (_vec_char_is_valid(iterator) == ERR_VECTOR_NULL)
-// {
-// return ERR_VECTOR_NULL;
-// }
-// if (_vec_char_is_valid(iterator) == ERR_BUF_NULL)
-// {
-// return ERR_BUF_NULL;
-// }
-// if (iter_end > iter_start || iter_end > iterator->_internal_size ||
-// iter > ptr->_internal_size)
-// {
-// LOGERROR(ERR_OUT_OF_BOUNDS);
-// return ERR_OUT_OF_BOUNDS;
-// }
-// if (ptr->_internal_arr == iterator->_internal_arr)
-// {
-// LOGERROR(ERR_DOUBLE_BUF);
-// return ERR_DOUBLE_BUF;
-// }
-// for (size_t i = iter_start; i < iter_end; i++)
-// {
-// size_t _ptr_err = _vec_char_insert(ptr, iter + (i - iter_start),
-// iterator->_internal_arr[i]);
-// if (_ptr_err != SUCCESS)
-// {
-// return _ptr_err;
-// }
-// }
-// return SUCCESS;
-// }
+__attribute__((overloadable)) void
+_vec_char_erase(_VecCharInternal* ptr, const size_t iter_start,
+ const size_t iter_end, err_t* err)
+{
+ err_t status = ERR_T_INIT;
+ if (__null_check(ptr, &status) != 0)
+ {
+ __origin_override(err, "ERASE");
+ err->flags |= status.flags;
+ return;
+ }
+
+ if (ptr->_internal_size < iter_end || iter_end <= iter_start)
+ {
+ __origin_override(err, "ERASE");
+ err->flags |= ERR_OUT_OF_BOUNDS;
+ return;
+ }
+ size_t diff = iter_end - iter_start;
+ memmove(&ptr->_internal_arr[iter_start], &ptr->_internal_arr[iter_end],
+ (ptr->_internal_size - iter_end) * sizeof(char));
+ for (size_t i = ptr->_internal_size - diff; i < ptr->_internal_size;
+ i++)
+ {
+ ptr->_internal_arr[i] = 0;
+ }
+ ptr->_internal_size -= diff;
+ return;
+}
+
+__attribute__((overloadable)) void
+_vec_char_resize(_VecCharInternal* ptr, const size_t size, err_t* err)
+{
+ err_t status = ERR_T_INIT;
+ __null_check(ptr, &status);
+ if ((status.flags & (ERR_BUF_NULL | ERR_VEC_NULL)) != 0)
+ {
+ __origin_override(err, "RESIZE");
+ err->flags |= ERR_BUF_NULL | ERR_VEC_NULL;
+ return;
+ }
+
+ if (ptr->_internal_size == size)
+ {
+ __origin_override(err, "RESIZE");
+ err->flags |= ERR_OUT_OF_BOUNDS;
+ return;
+ }
+
+ else if (size > ptr->_internal_max_size)
+ {
+ __origin_override(err, "RESIZE");
+ err->flags |= ERR_SIZE_OVERFLOW;
+ return;
+ }
+
+ else if ((status.flags & ERR_SIZE_ZERO) != 0)
+ {
+ size_t max = ptr->_internal_max_size;
+ err_t verr = ERR_T_INIT;
+ _vec_char_reserve(ptr, size, &verr);
+ if (verr.flags != 0)
+ {
+ __origin_override(err, "RESIZE");
+ err->flags |= verr.flags;
+ return;
+ }
+ if (ptr->_internal_capacity != size)
+ {
+ __origin_override(err, "RESIZE");
+ err->flags |= ERR_ALLOC_FAIL;
+ return;
+ }
+ for (size_t i = 0; i < size; i++)
+ {
+ ptr->_internal_arr[i] = '\0';
+ }
+ ptr->_internal_max_size = max;
+ ptr->_internal_size = size;
+ return;
+ }
+ else if (size > ptr->_internal_capacity)
+ {
+ size_t tmpcp = ptr->_internal_capacity;
+ size_t tmpmx = ptr->_internal_max_size;
+ err_t verr = ERR_T_INIT;
+ while (size > tmpcp)
+ {
+ tmpcp *= 2;
+ }
+ if (tmpcp > ptr->_internal_max_size)
+ {
+ tmpcp = size;
+ }
+ _vec_char_reserve(ptr, tmpcp, &verr);
+ if (verr.flags != 0)
+ {
+ __origin_override(err, "RESIZE");
+ err->flags |= verr.flags;
+ return;
+ }
+ if (ptr->_internal_capacity != tmpcp)
+ {
+ __origin_override(err, "RESIZE");
+ err->flags |= ERR_ALLOC_FAIL;
+ return;
+ }
+ ptr->_internal_max_size = tmpmx;
+ }
+ if (size < ptr->_internal_size)
+ {
+ for (size_t i = size; i < ptr->_internal_size; i++)
+ {
+ ptr->_internal_arr[i] = '\0';
+ }
+ }
+ if (ptr->_internal_size < size && size <= ptr->_internal_capacity)
+ {
+ for (size_t i = ptr->_internal_size; i < size; i++)
+ {
+ ptr->_internal_arr[i] = '\0';
+ }
+ }
+ ptr->_internal_size = size;
+ return;
+}
+
+__attribute__((overloadable)) void
+_vec_char_resize(_VecCharInternal* ptr, const size_t size, const char val,
+ err_t* err)
+{
+ err_t status = ERR_T_INIT;
+ __null_check(ptr, &status);
+ if ((status.flags & (ERR_BUF_NULL | ERR_VEC_NULL)) != 0)
+ {
+ __origin_override(err, "RESIZE");
+ err->flags |= ERR_BUF_NULL | ERR_VEC_NULL;
+ return;
+ }
+ if (ptr->_internal_size == size)
+ {
+ __origin_override(err, "RESIZE");
+ err->flags |= ERR_OUT_OF_BOUNDS;
+ return;
+ }
+
+ else if (size > ptr->_internal_max_size)
+ {
+ __origin_override(err, "RESIZE");
+ err->flags |= ERR_SIZE_OVERFLOW;
+ return;
+ }
+
+ else if ((status.flags & ERR_SIZE_ZERO) != 0)
+ {
+ size_t max = ptr->_internal_max_size;
+ err_t verr = ERR_T_INIT;
+ _vec_char_reserve(ptr, size, &verr);
+ if (verr.flags != 0)
+ {
+ __origin_override(err, "RESIZE");
+ err->flags |= verr.flags;
+ return;
+ }
+ if (ptr->_internal_capacity != size)
+ {
+ __origin_override(err, "RESIZE");
+ err->flags |= ERR_ALLOC_FAIL;
+ return;
+ }
+ for (size_t i = 0; i < size; i++)
+ {
+ ptr->_internal_arr[i] = val;
+ }
+ ptr->_internal_max_size = max;
+ ptr->_internal_size = size;
+ return;
+ }
+ else if (size > ptr->_internal_capacity)
+ {
+ size_t tmpcp = ptr->_internal_capacity;
+ size_t tmpmx = ptr->_internal_max_size;
+ err_t verr = ERR_T_INIT;
+ while (size > tmpcp)
+ {
+ tmpcp *= 2;
+ }
+ if (tmpcp > ptr->_internal_max_size)
+ {
+ tmpcp = size;
+ }
+ _vec_char_reserve(ptr, tmpcp, &verr);
+ if (verr.flags != 0)
+ {
+ __origin_override(err, "RESIZE");
+ err->flags |= verr.flags;
+ return;
+ }
+ ptr->_internal_max_size = tmpmx;
+ }
+ if (size < ptr->_internal_size)
+ {
+ for (size_t i = size; i < ptr->_internal_size; i++)
+ {
+ ptr->_internal_arr[i] = val;
+ }
+ }
+ if (ptr->_internal_size < size && size <= ptr->_internal_capacity)
+ {
+ for (size_t i = ptr->_internal_size; i < size; i++)
+ {
+ ptr->_internal_arr[i] = val;
+ }
+ }
+ ptr->_internal_size = size;
+ return;
+}
+
+__attribute__((overloadable)) void
+_vec_char_assign(_VecCharInternal* ptr, const _VecCharInternal* iterator,
+ const size_t iter_start, const size_t iter_end, err_t* err)
+{
+ err_t status = ERR_T_INIT;
+ if (__null_check(ptr, &status) != 0 ||
+ __null_check(iterator, &status) != 0)
+ {
+ __origin_override(err, "ASSIGN");
+ err->flags |= status.flags;
+ return;
+ }
+ if (ptr->_internal_arr == iterator->_internal_arr)
+ {
+ __origin_override(err, "ASSIGN");
+ err->flags |= ERR_DOUBLE_BUF;
+ return;
+ }
+ if (iterator->_internal_size < iter_end || iter_end <= iter_start)
+ {
+ __origin_override(err, "ASSIGN");
+ err->flags |= ERR_OUT_OF_BOUNDS;
+ return;
+ }
+ _vec_char_erase(ptr, _vec_char_begin(ptr, &status),
+ _vec_char_end(ptr, &status) + 1, &status);
+ if (status.flags != 0)
+ {
+ __origin_override(err, "ASSIGN");
+ err->flags |= status.flags;
+ return;
+ }
+ _vec_char_reserve(ptr, (iter_end - iter_start), &status);
+ if (status.flags != 0)
+ {
+ __origin_override(err, "ASSIGN");
+ err->flags |= status.flags;
+ return;
+ }
+ for (size_t i = iter_start; i < iter_end; i++)
+ {
+ _vec_char_push_back(ptr, _vec_char_at(iterator, i, &status),
+ &status);
+ if (status.flags != 0)
+ {
+ __origin_override(err, "ASSIGN");
+ err->flags |= status.flags;
+ return;
+ }
+ }
+ return;
+}
+
+__attribute__((overloadable)) void
+_vec_char_assign(_VecCharInternal* ptr, const size_t amount, const char val,
+ err_t* err)
+{
+ err_t status = ERR_T_INIT;
+ if (__null_check(ptr, &status) != 0)
+ {
+ __origin_override(err, "ASSIGN");
+ err->flags |= status.flags;
+ }
+ if (amount == 0)
+ {
+ __origin_override(err, "ASSIGN");
+ err->flags |= ERR_SIZE_ZERO;
+ return;
+ }
+ _vec_char_erase(ptr, _vec_char_begin(ptr, &status),
+ _vec_char_end(ptr, &status) + 1, &status);
+ if (status.flags != 0)
+ {
+ __origin_override(err, "ASSIGN");
+ err->flags |= status.flags;
+ return;
+ }
+ _vec_char_reserve(ptr, amount, &status);
+ if (status.flags != 0)
+ {
+ __origin_override(err, "ASSIGN");
+ err->flags |= status.flags;
+ return;
+ }
+ for (size_t i = 0; i < amount; i++)
+ {
+ _vec_char_push_back(ptr, val, &status);
+ if (status.flags != 0)
+ {
+ __origin_override(err, "ASSIGN");
+ err->flags |= status.flags;
+ return;
+ }
+ }
+ return;
+}
+
+__attribute__((overloadable)) void
+_vec_char_insert(_VecCharInternal* ptr, const size_t iter, const char val,
+ err_t* err)
+{
+ err_t status = ERR_T_INIT;
+ __null_check(ptr, &status);
+ if ((status.flags & (ERR_VEC_NULL | ERR_BUF_NULL)) != 0)
+ {
+ __origin_override(err, "INSERT");
+ err->flags |= status.flags;
+ return;
+ }
+ if (ptr->_internal_max_size < ptr->_internal_size + 1)
+ {
+ __origin_override(err, "INSERT");
+ err->flags |= ERR_SIZE_OVERFLOW;
+ return;
+ }
+ if (iter > ptr->_internal_size)
+ {
+ __origin_override(err, "INSERT");
+ err->flags |= ERR_OUT_OF_BOUNDS;
+ return;
+ }
+ _vec_char_push_back(ptr, 0, &status);
+ if (status.flags != 0)
+ {
+ __origin_override(err, "INSERT");
+ err->flags |= status.flags;
+ return;
+ }
+ for (size_t i = ptr->_internal_size - 1; i > iter; i--)
+ {
+ ptr->_internal_arr[i] = ptr->_internal_arr[i - 1];
+ }
+ ptr->_internal_arr[iter] = val;
+
+ return;
+}
+
+__attribute__((overloadable)) void
+_vec_char_insert(_VecCharInternal* ptr, const size_t iter, const size_t amount,
+ const char val, err_t* err)
+{
+ err_t status = ERR_T_INIT;
+ if ((status.flags & (ERR_VEC_NULL | ERR_BUF_NULL)) != 0)
+ {
+ __origin_override(err, "INSERT");
+ err->flags |= status.flags;
+ return;
+ }
+ if (iter > ptr->_internal_size)
+ {
+ __origin_override(err, "INSERT");
+ err->flags |= ERR_OUT_OF_BOUNDS;
+ return;
+ }
+ if (amount <= 0)
+ {
+ __origin_override(err, "INSERT");
+ err->flags |= ERR_SIZE_ZERO;
+ return;
+ }
+ for (size_t i = iter; i < iter + amount; i++)
+ {
+ _vec_char_insert(ptr, i, val, &status);
+ if (status.flags != 0)
+ {
+ __origin_override(err, "INSERT");
+ err->flags |= status.flags;
+ return;
+ }
+ }
+ return;
+}
+
+__attribute__((overloadable)) void
+_vec_char_insert(_VecCharInternal* ptr, const _VecCharInternal* iterator,
+ const size_t iter, const size_t iter_start,
+ const size_t iter_end, err_t* err)
+{
+ err_t status = ERR_T_INIT;
+ __null_check(ptr, &status);
+ __null_check(iterator, &status);
+ if ((status.flags & (ERR_VEC_NULL | ERR_BUF_NULL)) != 0)
+
+ {
+ __origin_override(err, "INSERT");
+ err->flags |= status.flags;
+ return;
+ }
+ if (iter_end > iter_start || iter_end > iterator->_internal_size ||
+ iter > ptr->_internal_size)
+ {
+ __origin_override(err, "INSERT");
+ err->flags |= ERR_OUT_OF_BOUNDS;
+ return;
+ }
+ if (ptr->_internal_arr == iterator->_internal_arr)
+ {
+ __origin_override(err, "INSERT");
+ err->flags |= ERR_DOUBLE_BUF;
+ return;
+ }
+ for (size_t i = iter_start; i < iter_end; i++)
+ {
+ _vec_char_insert(ptr, iter + (i - iter_start),
+ iterator->_internal_arr[i], &status);
+ if (status.flags != 0)
+ {
+ __origin_override(err, "INSERT");
+ err->flags |= status.flags;
+ return;
+ }
+ }
+ return;
+}
diff --git a/src/lib/char/char.h b/src/lib/char/char.h
index 86cdeeb..b3329dc 100644
--- a/src/lib/char/char.h
+++ b/src/lib/char/char.h
@@ -16,93 +16,93 @@ typedef struct
size_t _internal_max_size;
} _VecCharInternal;
-unsigned int
-_vec_char_raise_err(const _VecCharInternal* ptr, unsigned int mask);
+void
+_vec_char_print_vec(const _VecCharInternal* ptr, err_t* err);
_VecCharInternal
-_vec_char_create(const char* src, const size_t size);
+_vec_char_cpy(const char* src, const size_t src_size, err_t* err);
-size_t
-_vec_char_push_back(_VecCharInternal* vec, const char val);
+void
+_vec_char_push_back(_VecCharInternal* ptr, const char val, err_t* err);
-size_t
-_vec_char_pop_back(_VecCharInternal* ptr);
+void
+_vec_char_pop_back(_VecCharInternal* ptr, err_t* err);
-size_t
-_vec_char_reserve(_VecCharInternal* ptr, const size_t max_size);
+void
+_vec_char_reserve(_VecCharInternal* ptr, const size_t capacity, err_t* err);
-size_t
-_vec_char_shrink_to_fit(_VecCharInternal* ptr);
+void
+_vec_char_shrink_to_fit(_VecCharInternal* ptr, err_t* err);
-size_t
-_vec_char_swap(_VecCharInternal* ptr, _VecCharInternal* ptr_other);
+void
+_vec_char_swap(_VecCharInternal* ptr, _VecCharInternal* ptr_other, err_t* err);
char*
-_vec_char_data(const _VecCharInternal* ptr);
+_vec_char_data(const _VecCharInternal* ptr, err_t* err);
size_t
-_vec_char_capacity(const _VecCharInternal* ptr);
+_vec_char_capacity(const _VecCharInternal* ptr, err_t* err);
size_t
-_vec_char_max_size(const _VecCharInternal* ptr);
+_vec_char_max_size(const _VecCharInternal* ptr, err_t* err);
void
-_vec_char_delete(const _VecCharInternal* ptr);
-
-size_t
-_vec_char_clear(_VecCharInternal* ptr);
-
-char
-_vec_char_at(const _VecCharInternal* ptr, const size_t idx);
+_vec_char_delete(const _VecCharInternal* ptr, err_t* err);
void
-_vec_char_print_vec(const _VecCharInternal* ptr);
-
-size_t
-_vec_char_begin(const _VecCharInternal* ptr);
-
-size_t
-_vec_char_end(const _VecCharInternal* ptr);
+_vec_char_clear(_VecCharInternal* ptr, err_t* err);
char
-_vec_char_front(const _VecCharInternal* ptr);
-
-char
-_vec_char_back(const _VecCharInternal* ptr);
+_vec_char_at(const _VecCharInternal* ptr, const size_t idx, err_t* err);
size_t
-_vec_char_empty(const _VecCharInternal* ptr);
+_vec_char_begin(const _VecCharInternal* ptr, err_t* err);
-__attribute__((overloadable)) size_t
-_vec_char_erase(_VecCharInternal* ptr, const size_t iter);
+size_t
+_vec_char_end(const _VecCharInternal* ptr, err_t* err);
-__attribute__((overloadable)) size_t
+char
+_vec_char_front(const _VecCharInternal* ptr, err_t* err);
+
+char
+_vec_char_back(const _VecCharInternal* ptr, err_t* err);
+
+size_t
+_vec_char_empty(const _VecCharInternal* ptr, err_t* err);
+
+__attribute__((overloadable)) void
+_vec_char_erase(_VecCharInternal* ptr, const size_t iter, err_t* err);
+
+__attribute__((overloadable)) void
_vec_char_erase(_VecCharInternal* ptr, const size_t iter_start,
- const size_t iter_end);
+ const size_t iter_end, err_t* err);
-__attribute__((overloadable)) size_t
-_vec_char_resize(_VecCharInternal* ptr, const size_t size);
+__attribute__((overloadable)) void
+_vec_char_resize(_VecCharInternal* ptr, const size_t size, err_t* err);
-__attribute__((overloadable)) size_t
-_vec_char_resize(_VecCharInternal* ptr, const size_t size, const char val);
+__attribute__((overloadable)) void
+_vec_char_resize(_VecCharInternal* ptr, const size_t size, const char val,
+ err_t* err);
-__attribute__((overloadable)) size_t
+__attribute__((overloadable)) void
_vec_char_assign(_VecCharInternal* ptr, const _VecCharInternal* iterator,
- const size_t iter_start, const size_t iter_end);
+ const size_t iter_start, const size_t iter_end, err_t* err);
-__attribute__((overloadable)) size_t
-_vec_char_assign(_VecCharInternal* ptr, const size_t amount, const char val);
+__attribute__((overloadable)) void
+_vec_char_assign(_VecCharInternal* ptr, const size_t amount, const char val,
+ err_t* err);
-__attribute__((overloadable)) size_t
-_vec_char_insert(_VecCharInternal* ptr, const size_t iter, const char val);
+__attribute__((overloadable)) void
+_vec_char_insert(_VecCharInternal* ptr, const size_t iter, const char val,
+ err_t* err);
-__attribute__((overloadable)) size_t
+__attribute__((overloadable)) void
_vec_char_insert(_VecCharInternal* ptr, const size_t iter, const size_t amount,
- const char val);
+ const char val, err_t* err);
-__attribute__((overloadable)) size_t
+__attribute__((overloadable)) void
_vec_char_insert(_VecCharInternal* ptr, const _VecCharInternal* iterator,
const size_t iter, const size_t iter_start,
- const size_t iter_end);
+ const size_t iter_end, err_t* err);
#endif
diff --git a/src/lib/utils/utils.c b/src/lib/utils/utils.c
index ddb82ea..5a8e497 100644
--- a/src/lib/utils/utils.c
+++ b/src/lib/utils/utils.c
@@ -17,16 +17,16 @@ vec_get_error_desc(ERROR_CODES err)
}
void
-vec_print_errs(const unsigned int err)
+vec_print_errs(const err_t err)
{
- if (err == SUCCESS)
+ if (err.flags == SUCCESS)
{
- printf("%s", vec_get_error_desc(SUCCESS));
+ printf("%s: %s\n", err.origin, vec_get_error_desc(SUCCESS));
return;
}
{
#define X(name, val, desc) \
- if ((val) != 0 && ((err) & (val))) \
+ if ((val) != 0 && ((err.flags) & (val))) \
{ \
printf("%s\n", vec_get_error_desc(name)); \
}
@@ -34,3 +34,38 @@ vec_print_errs(const unsigned int err)
#undef X
}
}
+
+void
+print_bits(unsigned int num)
+{
+ // Determine the number of bits in an unsigned int (usually 32)
+ int total_bits = sizeof(num) * 8;
+
+ // Loop from the most significant bit (MSB) down to the least
+ // significant bit (LSB)
+ for (int i = total_bits - 1; i >= 0; i--)
+ {
+ // Shift a 1 to the i-th position and check if that bit is set
+ int bit = (num >> i) & 1;
+ printf("%d", bit);
+
+ // Optional: Add a space every 4 or 8 bits for readability
+ if (i % 8 == 0)
+ {
+ printf(" ");
+ }
+ }
+ printf("\n");
+}
+
+// void
+// _vec_update_origin(err_t* err, char* str)
+// {
+// err_t res;
+// if (err == nullptr)
+// {
+// res.err = 0;
+// res.value = 0;
+// }
+// if (!err->origin) err->origin = str;
+// }
diff --git a/src/lib/utils/utils.h b/src/lib/utils/utils.h
index 00cb768..01aa096 100644
--- a/src/lib/utils/utils.h
+++ b/src/lib/utils/utils.h
@@ -6,18 +6,23 @@
#define CAPACITY 1024
#define VEC_FAULT_BITS 32
+static const size_t VEC_MAX = SIZE_MAX / sizeof(int);
#define ERROR_LIST(X) \
X(SUCCESS, 0, "No Errors Found") \
- X(ERR_ALLOC_FAIL, (1u << 1), "Calloc :- Failed to allocate") \
- X(ERR_VEC_NULL, (1u << 2), "Vector :- Given vector is null") \
- X(ERR_BUF_NULL, (1u << 3), "Buffer :- NULL") \
- X(ERR_SIZE_ZERO, (1u << 4), \
+ X(ERR_ALLOC_FAIL, (1u << 0), "Alloc :- Failed to allocate") \
+ X(ERR_VEC_NULL, (1u << 1), "Vector :- Given vector is null") \
+ X(ERR_BUF_NULL, (1u << 2), "Buffer :- NULL") \
+ X(ERR_SIZE_ZERO, (1u << 3), \
"Size :- Size is or is less than 0 or invalid") \
- X(ERR_OUT_OF_BOUNDS, (1u << 5), "Bounds:- Value is out of bounds") \
- X(ERR_DOUBLE_BUF, (1u << 6), \
+ X(ERR_OUT_OF_BOUNDS, (1u << 4), "Bounds:- Value is out of bounds") \
+ X(ERR_DOUBLE_BUF, (1u << 5), \
"Buffer :- Both buffers are copies of each other") \
- X(ERR_SIZE_OVERFLOW, (1u << 7), "Max :- Vector Max value is overloaded")
+ X(ERR_SIZE_OVERFLOW, (1u << 6), \
+ "Max :- Vector Max value is overloaded") \
+ X(ERR_ORIGIN_UNALTERABLE, (1u << 7), \
+ "Origin :- Origin is non-null and cannot be overridden") \
+ X(ERR_STR_NULL, (1u << 8), "String :- String is null value")
typedef enum
{
@@ -26,11 +31,36 @@ typedef enum
#undef X
} ERROR_CODES;
+/* NOTE
+ * Value is the return value for functions like _vec_char_capacity
+ * Err is the unsigned bit range for all the errors tracked
+ * origin is a string for where the bug started and IS CHANGED ONLY WHEN NULL
+ * */
+
+typedef struct
+{
+ unsigned int flags;
+ char* origin; // Where the main bug started
+} err_t;
+
+#define ERR_T_INIT { .flags = 0, .origin = NULL }
+#define VEC_INIT \
+ { ._internal_arr = NULL, \
+ ._internal_size = 0, \
+ ._internal_capacity = 0, \
+ ._internal_max_size = VEC_MAX }
+
const char*
vec_get_error_desc(ERROR_CODES err);
void
-vec_print_errs(const unsigned int err);
+vec_print_errs(const err_t err);
+
+// void
+// _vec_update_origin(err_t* err, char* str);
+
+void
+print_bits(unsigned int num);
#define LOG(msg) printf("LOG: %s\n", msg) /**< Print log message*/
#define DEBUG(msg) printf("DEBUB: %s\n", msg) /**< Print debug message*/
@@ -40,6 +70,4 @@ vec_print_errs(const unsigned int err);
#define find_len(arr) sizeof(arr) / sizeof(arr[0])
-static const size_t VEC_MAX = SIZE_MAX / sizeof(int);
-
#endif
diff --git a/src/main.c b/src/main.c
index 55698e7..1b63a60 100644
--- a/src/main.c
+++ b/src/main.c
@@ -12,143 +12,52 @@
* String 32 Bits with suffix of 's'
*/
-#include
+// #include
#include
#include
#include
#include
+#include "lib/char/char.h"
#include "lib/utils/utils.h"
void
print_bits(unsigned int num);
-typedef struct
-{
- char* _internal_arr;
- size_t _internal_size;
- size_t _internal_capacity;
- size_t _internal_max_size;
-} _VecCharInternal;
-
-/* NOTE
- * Value is the return value for functions like _vec_char_capacity
- * Err is the unsigned bit range for all the errors tracked
- * origin is a string for where the bug started and IS CHANGED ONLY WHEN NULL
- * */
-
-typedef struct
-{
- unsigned int err;
- size_t value;
- char* origin; // Where the main bug started
-} _err_t;
-
-void
-_vec_update_origin(_err_t* err, char* str)
-{
- _err_t res;
- if (err == nullptr)
- {
- res.err = 0;
- res.value = 0;
- }
- if (!err->origin) err->origin = str;
-}
-
-unsigned int
-_vec_char_raise_err(const _VecCharInternal* ptr, unsigned int mask)
-
-{
- unsigned int res = SUCCESS;
- res |= mask;
- if (ptr == nullptr) res |= ERR_VEC_NULL;
- if (ptr->_internal_arr == nullptr) res |= ERR_BUF_NULL;
-
- return res;
-}
-
-_VecCharInternal
-_vec_char_create(const char* src, const size_t size)
-{
- unsigned int err = 0;
- _VecCharInternal self = {
- ._internal_arr = NULL,
- ._internal_size = 0,
- ._internal_capacity = CAPACITY,
- ._internal_max_size = VEC_MAX,
- };
- if (size >= self._internal_max_size)
- {
- LOG("If you need more memory to start, create a blank and "
- "reserve.");
- return self;
- }
- if (self._internal_capacity < size)
- {
- size_t dst_cap = self._internal_capacity;
- while (dst_cap < size && dst_cap * 2 < self._internal_max_size)
- dst_cap *= 2;
- self._internal_capacity = (dst_cap < size) ? size : dst_cap;
- }
- if (size > 0)
- {
- self._internal_arr =
- calloc(self._internal_capacity, sizeof(char));
- err = _vec_char_raise_err(&self, err);
- if ((err & SUCCESS) == 1)
- {
- self._internal_arr = NULL;
- vec_print_errs(err);
- free(self._internal_arr);
- return self;
- }
- }
- if (!src) err |= ERR_BUF_NULL;
- else
- {
- for (size_t i = 0; i < size; i++)
- {
- self._internal_arr[i] = src[i];
- self._internal_size++;
- }
- }
- vec_print_errs(err);
- return self;
-}
-
-void
-print_bits(unsigned int num)
-{
- // Determine the number of bits in an unsigned int (usually 32)
- int total_bits = sizeof(num) * 8;
-
- // Loop from the most significant bit (MSB) down to the least
- // significant bit (LSB)
- for (int i = total_bits - 1; i >= 0; i--)
- {
- // Shift a 1 to the i-th position and check if that bit is set
- int bit = (num >> i) & 1;
- printf("%d", bit);
-
- // Optional: Add a space every 4 or 8 bits for readability
- if (i % 8 == 0)
- {
- printf(" ");
- }
- }
- printf("\n");
-}
-
int
main()
{
+ // TODO:
+ // Fix the error checking because you make a status to hold all local
+ // errors but then in some cases you or them to the main err handler and
+ // if the error doesnt need to be there like a good error but one that
+ // exists (i.e push_back getting a blank array), then you will have a
+ // bloated and broken error handler
+ //
+ // Your pop back is a great example of how to handle it and is a clean
+ // if statement as a header to all functions.
char res[4] = { 'a', 'b', 'c', 'd' };
- _VecCharInternal v1 = _vec_char_create(nullptr, 3);
- unsigned int mark = 1 << 0;
- _err_t err = { 0, 0, "Te" };
- _vec_update_origin(&err, "Test");
- printf("%s", err.origin);
+ err_t status = ERR_T_INIT, err = ERR_T_INIT;
+ status.flags |= ERR_BUF_NULL | ERR_VEC_NULL | ERR_STR_NULL;
+ // _VecCharInternal v1 = VEC_INIT;
+ // _vec_char_push_back(&v1, 'c', &status);
+ // _vec_char_print_vec(&v1, &status);
+
+ unsigned int mask = 0;
+ mask = ERR_BUF_NULL ^ status.flags;
+
+ print_bits(mask);
+ print_bits(status.flags);
+
+ // if (status.origin)
+ // {
+ // printf("Error started in: %s\n", status.origin);
+ // }
+ // printf("%s: %s", err.origin, vec_print_errs(err));
+ // vec_print_errs(status);
+ // printf("%u\n", status.err);
+ // _vec_update_origin(&err, "Test");
+ // printf("%s", err.origin);
// for (int i = 0; i < VEC_FAULT_BITS; i++)
// {
// print_bits(mark);