From b39911f57e2d6ed1d59082cf4a2c24713bdc833b Mon Sep 17 00:00:00 2001 From: Andrew Haynes Date: Thu, 8 Oct 2026 13:25:26 -0400 Subject: [PATCH] REFACTOR: Completely refactored and fixed the error handling --- .DS_Store | Bin 6148 -> 6148 bytes CMakeLists.txt | 4 +- Notes.md | 23 + src/.DS_Store | Bin 6148 -> 6148 bytes src/lib/.DS_Store | Bin 6148 -> 6148 bytes src/lib/char/char.c | 1635 +++++++++++++++++++++-------------------- src/lib/char/char.h | 106 +-- src/lib/utils/utils.c | 43 +- src/lib/utils/utils.h | 48 +- src/main.c | 155 +--- 10 files changed, 1041 insertions(+), 973 deletions(-) create mode 100644 Notes.md diff --git a/.DS_Store b/.DS_Store index 50d7e99fbd737ecdb9476b8229fe0068fb9cac37..0d98060310a5abc12a5d791c465a7debe38248d2 100644 GIT binary patch delta 183 zcmZoMXffEJ#lke_)npx(MrM}fk0x(mkzi9en;4sFKKUGr6pZ-30dTrPCmyX1!KNrk!Ioun9R*8!_2m_ zc(N9&6x$i|+L{FO$zH57FlG*`EFG&0iWrh}^Icq$a`KaaA{_Ch s7Ch($ 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 3ef53b6b38243fb1a2fcee88f38270c59cccc1e3..49e043b0eed0d8c3eef56a9b6d4b38ecff3c53ea 100644 GIT binary patch delta 15 WcmZoMXffDe&d5|FxY?5Nv={&<3IwhI delta 15 WcmZoMXffDe&d5|Yf3qdyX)ypQGzB&Q diff --git a/src/lib/.DS_Store b/src/lib/.DS_Store index b856baa30592e30333f536c7dc3a2daf518dc0a8..40c092a9448cbe79305999a29f4493b2c37fc5d9 100644 GIT binary patch delta 64 zcmV-G0Kfl)FoZC$I|Kq%qmw-Z7zRio^Q&Y#lUoEDlT`#1vxx+x0Rj$clP?Au2DdLK WeN#J=PX-(Yg{iMt#Wu5X29ptoiWFS{ delta 64 zcmV-G0Kfl)FoZC$I|Kq&ag#j+7?X7b6q9KL3lNEFT 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);