From 813390b6acd7c9300216267d34aa192465f4f8f8 Mon Sep 17 00:00:00 2001 From: Andrew Haynes Date: Wed, 14 Oct 2026 09:48:58 -0400 Subject: [PATCH] API: Cutting my losses and having singular types and files for the 4 types { char, int, float, string } and can come back later to make it one type to call. GITIGNORE: Added tests and Makefile to cleanup fuzzyfinder but dont need them pushed either as I have enough testing done. --- .DS_Store | Bin 6148 -> 6148 bytes .gitignore | 3 + CMakeLists.txt | 13 +- Makefile | 4 +- include/libvec.h | 6 - {src/lib/char => include/libvec}/char.h | 2 +- include/libvec/float.h | 117 +++ include/libvec/int.h | 117 +++ {src/lib/utils => include/libvec}/utils.h | 0 src/.DS_Store | Bin 6148 -> 6148 bytes src/{lib/char => }/char.c | 5 +- src/float.c | 938 +++++++++++++++++++++ src/int.c | 940 ++++++++++++++++++++++ src/lib/.DS_Store | Bin 6148 -> 0 bytes src/libvec.c | 1 - src/main.c | 4 +- src/{lib/utils => }/utils.c | 2 +- tests/test_learn.c | 383 ++++----- 18 files changed, 2322 insertions(+), 213 deletions(-) delete mode 100644 include/libvec.h rename {src/lib/char => include/libvec}/char.h (99%) create mode 100644 include/libvec/float.h create mode 100644 include/libvec/int.h rename {src/lib/utils => include/libvec}/utils.h (100%) rename src/{lib/char => }/char.c (99%) create mode 100644 src/float.c create mode 100644 src/int.c delete mode 100644 src/lib/.DS_Store delete mode 100644 src/libvec.c rename src/{lib/utils => }/utils.c (98%) diff --git a/.DS_Store b/.DS_Store index 1fe44add5c22498b3fd8827eca9913bc05cb0275..fdc48d5f15266f7af406e179109ba7b03f180650 100644 GIT binary patch delta 184 zcmZoMXffEJ#lm#z*JK@*G`RoPNY2f7 paY@R_PXdZ?@GCN!ytO;wh%B3eN46jX;*ibnMG6=;TC{tz7OT|cG*+?6QLJyn=idNoV`eC3C}K#?&3AE0 w%E?axig2iF%;cP4cft`_HU%zgc<8x$pbfHYK?agD7(Q$)%w*im&heKY06@?-4FCWD diff --git a/.gitignore b/.gitignore index 640f1a7..b0ab16a 100644 --- a/.gitignore +++ b/.gitignore @@ -3,3 +3,6 @@ build/ tests/cache/ tests/bin/ coverage.html + +tests +Makefile diff --git a/CMakeLists.txt b/CMakeLists.txt index 2ff6302..caa9895 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -5,13 +5,12 @@ set(CMAKE_C_STANDARD_REQUIRED ON) set(CMAKE_EXPORT_COMPILE_COMMANDS ON) add_library(libvec STATIC - src/libvec.c - src/lib/char/char.c - src/lib/utils/utils.c + src/char.c + src/int.c + src/utils.c + src/float.c + # src/string.c # Add your other types here as you implement them: - # src/lib/float/float.c - # src/lib/int/int.c - # src/lib/string/string.c ) target_include_directories(libvec @@ -22,7 +21,7 @@ target_include_directories(libvec # 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 + # ${CMAKE_CURRENT_SOURCE_DIR}/src/lib # Turn back to private when ready ) add_executable(libvec_bin src/main.c) diff --git a/Makefile b/Makefile index e004316..168fd2c 100644 --- a/Makefile +++ b/Makefile @@ -14,7 +14,7 @@ CFLAGS := -std=c23 -Wall -Wextra -Wpedantic -Wshadow \ -Wconversion -Wsign-conversion \ -g -O1 -fno-omit-frame-pointer SAN_FLAGS := -fsanitize=address,undefined -INCLUDES := -Iinclude -Isrc/lib -Isrc/lib/char -Isrc/lib/utils +INCLUDES := -Iinclude -Isrc/lib -Isrc/lib/int -Isrc/lib/utils ASAN_ENV := ASAN_OPTIONS="allocator_may_return_null=1:detect_stack_use_after_return=1" \ UBSAN_OPTIONS="halt_on_error=1:print_stacktrace=1" @@ -31,7 +31,7 @@ CPPCHECK_FLAGS := --enable=all \ $(INCLUDES) # Sources & Build Directories -SRCS := src/lib/char/char.c src/lib/utils/utils.c +SRCS := src/lib/int/int.c src/lib/utils/utils.c TEST_SRC := tests/test_learn.c FUZZ_SRC := tests/fuzz_char.c diff --git a/include/libvec.h b/include/libvec.h deleted file mode 100644 index 968f47f..0000000 --- a/include/libvec.h +++ /dev/null @@ -1,6 +0,0 @@ -#ifndef LIBVEC_H -#define LIBVEC_H - -// Add code here - -#endif diff --git a/src/lib/char/char.h b/include/libvec/char.h similarity index 99% rename from src/lib/char/char.h rename to include/libvec/char.h index 1e3569e..de1a681 100644 --- a/src/lib/char/char.h +++ b/include/libvec/char.h @@ -1,7 +1,7 @@ #ifndef CHAR_H #define CHAR_H -#include +#include // Will add DOCS later diff --git a/include/libvec/float.h b/include/libvec/float.h new file mode 100644 index 0000000..de1a681 --- /dev/null +++ b/include/libvec/float.h @@ -0,0 +1,117 @@ +#ifndef CHAR_H +#define CHAR_H + +#include + +// Will add DOCS later + +typedef struct +{ + char* _internal_arr; + size_t _internal_size; + size_t _internal_capacity; + size_t _internal_max_size; +} _VecCharInternal; + +__attribute__((overloadable)) size_t +__null_check(const _VecCharInternal* ptr, err_t* status); + +__attribute__((overloadable)) size_t +__null_check(const char* ptr, err_t* status); + +size_t +__origin_override(err_t* status, char* str); + +void +_vec_char_print_vec(const _VecCharInternal* ptr, err_t* err); + +_VecCharInternal +_vec_char_cpy(const char* src, const size_t src_size, err_t* err); + +void +_vec_char_push_back(_VecCharInternal* ptr, const char val, err_t* err); + +void +_vec_char_pop_back(_VecCharInternal* ptr, err_t* err); + +void +_vec_char_reserve(_VecCharInternal* ptr, const size_t capacity, err_t* err); + +void +_vec_char_shrink_to_fit(_VecCharInternal* ptr, err_t* err); + +void +_vec_char_swap(_VecCharInternal* ptr_a, _VecCharInternal* ptr_b, err_t* err); + +const char* +_vec_char_data(const _VecCharInternal* ptr, err_t* err); + +size_t +_vec_char_size(const _VecCharInternal* ptr, err_t* err); + +size_t +_vec_char_capacity(const _VecCharInternal* ptr, err_t* err); + +size_t +_vec_char_max_size(const _VecCharInternal* ptr, err_t* err); + +void +_vec_char_delete(_VecCharInternal* ptr, err_t* err); + +void +_vec_char_clear(_VecCharInternal* ptr, err_t* err); + +char* +_vec_char_at(const _VecCharInternal* ptr, const size_t idx, err_t* err); + +size_t +_vec_char_begin(const _VecCharInternal* ptr, err_t* err); + +size_t +_vec_char_end(const _VecCharInternal* ptr, err_t* err); + +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, err_t* err); + +__attribute__((overloadable)) void +_vec_char_resize(_VecCharInternal* ptr, const size_t size, err_t* err); + +__attribute__((overloadable)) void +_vec_char_resize(_VecCharInternal* ptr, const size_t size, const char val, + err_t* err); + +__attribute__((overloadable)) void +_vec_char_assign(_VecCharInternal* ptr, const _VecCharInternal* iterator, + const size_t iter_start, const size_t iter_end, err_t* err); + +__attribute__((overloadable)) void +_vec_char_assign(_VecCharInternal* ptr, const size_t amount, const char val, + err_t* err); + +__attribute__((overloadable)) void +_vec_char_insert(_VecCharInternal* ptr, const size_t iter, const char val, + err_t* err); + +__attribute__((overloadable)) void +_vec_char_insert(_VecCharInternal* ptr, const size_t iter, const size_t amount, + const char val, err_t* err); + +__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); + +#endif diff --git a/include/libvec/int.h b/include/libvec/int.h new file mode 100644 index 0000000..9608520 --- /dev/null +++ b/include/libvec/int.h @@ -0,0 +1,117 @@ +#ifndef INT_H +#define INT_H + +#include + +// Will add DOCS later + +typedef struct +{ + int* _internal_arr; + size_t _internal_size; + size_t _internal_capacity; + size_t _internal_max_size; +} _VecIntInternal; + +__attribute__((overloadable)) size_t +__null_check(const _VecIntInternal* ptr, err_t* status); + +__attribute__((overloadable)) size_t +__null_check(const int* ptr, err_t* status); + +size_t +__origin_override(err_t* status, char* str); + +void +_vec_int_print_vec(const _VecIntInternal* ptr, err_t* err); + +_VecIntInternal +_vec_int_cpy(const int* src, const size_t src_size, err_t* err); + +void +_vec_int_push_back(_VecIntInternal* ptr, const int val, err_t* err); + +void +_vec_int_pop_back(_VecIntInternal* ptr, err_t* err); + +void +_vec_int_reserve(_VecIntInternal* ptr, const size_t capacity, err_t* err); + +void +_vec_int_shrink_to_fit(_VecIntInternal* ptr, err_t* err); + +void +_vec_int_swap(_VecIntInternal* ptr_a, _VecIntInternal* ptr_b, err_t* err); + +const int* +_vec_int_data(const _VecIntInternal* ptr, err_t* err); + +size_t +_vec_int_size(const _VecIntInternal* ptr, err_t* err); + +size_t +_vec_int_capacity(const _VecIntInternal* ptr, err_t* err); + +size_t +_vec_int_max_size(const _VecIntInternal* ptr, err_t* err); + +void +_vec_int_delete(_VecIntInternal* ptr, err_t* err); + +void +_vec_int_clear(_VecIntInternal* ptr, err_t* err); + +int* +_vec_int_at(const _VecIntInternal* ptr, const size_t idx, err_t* err); + +size_t +_vec_int_begin(const _VecIntInternal* ptr, err_t* err); + +size_t +_vec_int_end(const _VecIntInternal* ptr, err_t* err); + +int +_vec_int_front(const _VecIntInternal* ptr, err_t* err); + +int +_vec_int_back(const _VecIntInternal* ptr, err_t* err); + +size_t +_vec_int_empty(const _VecIntInternal* ptr, err_t* err); + +__attribute__((overloadable)) void +_vec_int_erase(_VecIntInternal* ptr, const size_t iter, err_t* err); + +__attribute__((overloadable)) void +_vec_int_erase(_VecIntInternal* ptr, const size_t iter_start, + const size_t iter_end, err_t* err); + +__attribute__((overloadable)) void +_vec_int_resize(_VecIntInternal* ptr, const size_t size, err_t* err); + +__attribute__((overloadable)) void +_vec_int_resize(_VecIntInternal* ptr, const size_t size, const int val, + err_t* err); + +__attribute__((overloadable)) void +_vec_int_assign(_VecIntInternal* ptr, const _VecIntInternal* iterator, + const size_t iter_start, const size_t iter_end, err_t* err); + +__attribute__((overloadable)) void +_vec_int_assign(_VecIntInternal* ptr, const size_t amount, const int val, + err_t* err); + +__attribute__((overloadable)) void +_vec_int_insert(_VecIntInternal* ptr, const size_t iter, const int val, + err_t* err); + +__attribute__((overloadable)) void +_vec_int_insert(_VecIntInternal* ptr, const size_t iter, const size_t amount, + const int val, err_t* err); + +__attribute__((overloadable)) void +_vec_int_insert(_VecIntInternal* ptr, const _VecIntInternal* iterator, + const size_t iter, const size_t iter_start, + const size_t iter_end, err_t* err); + +#endif diff --git a/src/lib/utils/utils.h b/include/libvec/utils.h similarity index 100% rename from src/lib/utils/utils.h rename to include/libvec/utils.h diff --git a/src/.DS_Store b/src/.DS_Store index f0a8e65a184a429a509251ac51497cc0b348798c..b72c074d6473ac590e0eb5c4d5cb6db3cc87cfc0 100644 GIT binary patch delta 29 lcmZoMXffDe&d79Q;bcq3U`EEx6B*0cCN{8aX6N|J4*-(s36cN+ delta 26 hcmZoMXffDe&dAi9JlT>ln2BM-=824DY>Qbq1ORTp2a5mz diff --git a/src/lib/char/char.c b/src/char.c similarity index 99% rename from src/lib/char/char.c rename to src/char.c index 4a54b44..58deb8b 100644 --- a/src/lib/char/char.c +++ b/src/char.c @@ -1,12 +1,11 @@ -#include "char.h" +#include "libvec/char.h" +#include #include #include #include #include -#include "utils/utils.h" - __attribute__((overloadable)) size_t __null_check(const _VecCharInternal* ptr, err_t* status) { diff --git a/src/float.c b/src/float.c new file mode 100644 index 0000000..3937a42 --- /dev/null +++ b/src/float.c @@ -0,0 +1,938 @@ +#include +#include +#include +#include +#include + +__attribute__((overloadable)) size_t +__null_check(const _VecCharInternal* ptr, err_t* status) +{ + if (status == nullptr) + { + return ERR_ERR_T_NULL; + } + if (ptr == nullptr) + { + status->flags |= ERR_VEC_NULL; + return ERR_VEC_NULL; + } + if (ptr->_internal_arr == nullptr) + { + status->flags |= ERR_BUF_NULL; + } + + return status->flags; +} + +__attribute__((overloadable)) size_t +__null_check(const char* ptr, err_t* status) +{ + if (status == nullptr) + { + return ERR_ERR_T_NULL; + } + if (ptr == nullptr) + { + status->flags |= ERR_BUF_NULL; + } + return status->flags; +} + +size_t +__origin_override(err_t* status, char* str) +{ + if (status == nullptr) + { + return ERR_ERR_T_NULL; + } + 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_cpy(const char* src, const size_t src_size, err_t* err) +{ + _VecCharInternal self = VEC_INIT; + err_t status = ERR_T_INIT; + + size_t null = __null_check(src, err); + if (null != 0) + { + if (null & ERR_ERR_T_NULL) + { + return self; + } + __origin_override(err, "CPY"); + err->flags |= status.flags; + return self; + } + if (src_size == 0) + { + __origin_override(err, "CPY"); + err->flags |= ERR_SIZE_ZERO; + err->flags |= status.flags; + return self; + } + if (src_size > self._internal_max_size) + { + __origin_override(err, "CPY"); + err->flags |= ERR_SIZE_OVERFLOW; + return self; + } + self._internal_arr = malloc(src_size * sizeof(char)); + if (self._internal_arr == nullptr) + { + __origin_override(err, "CPY"); + err->flags |= ERR_ALLOC_FAIL; + return self; + } + memcpy(self._internal_arr, src, src_size * sizeof(char)); + self._internal_size = src_size; + self._internal_capacity = src_size; + return self; +} + +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_ALLOC_FAIL; + return; + } + ptr->_internal_arr = res; + ptr->_internal_capacity = 1; + ptr->_internal_size = 0; + } + + 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; + } + + if (ptr->_internal_size == 0) + { + __origin_override(err, "POP_BACK"); + err->flags |= ERR_SIZE_ZERO; + 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; + if (__null_check(ptr, &status) != 0) + { + if ((status.flags & ERR_VEC_NULL) != 0) + { + __origin_override(err, "RESERVE"); + err->flags |= ERR_VEC_NULL; + return; + } + } + if (ptr->_internal_max_size < capacity) + { + __origin_override(err, "RESERVE"); + err->flags |= ERR_SIZE_OVERFLOW; + return; + } + if (capacity == 0) + { + __origin_override(err, "RESERVE"); + err->flags |= ERR_SIZE_ZERO; + return; + } + + char* res = realloc(ptr->_internal_arr, capacity * sizeof(char)); + if (res == nullptr) + { + __origin_override(err, "RESERVE"); + err->flags |= ERR_ALLOC_FAIL; + return; + } + ptr->_internal_arr = res; + ptr->_internal_capacity = capacity; + if (ptr->_internal_size > capacity) + { + ptr->_internal_size = capacity; + } + return; +} + +void +_vec_char_shrink_to_fit(_VecCharInternal* ptr, err_t* err) +{ + err_t status = ERR_T_INIT; + if (__null_check(ptr, &status) != 0) + { + __origin_override(err, "SHRINK_TO_FIT"); + err->flags |= status.flags; + return; + } + if (ptr->_internal_size == 0) + { + __origin_override(err, "SHRINK_TO_FIT"); + err->flags |= ERR_SIZE_ZERO; + return; + } + _vec_char_reserve(ptr, ptr->_internal_size, err); +} + +void +_vec_char_swap(_VecCharInternal* ptr_a, _VecCharInternal* ptr_b, err_t* err) +{ + err_t status_1 = ERR_T_INIT, status_2 = ERR_T_INIT; + if ((__null_check(ptr_a, &status_1) & ERR_VEC_NULL) != 0 || + (__null_check(ptr_b, &status_2) & ERR_VEC_NULL) != 0) + { + __origin_override(err, "SWAP"); + err->flags |= ERR_VEC_NULL; + return; + } + _VecCharInternal self = *ptr_a; + *ptr_a = *ptr_b; + *ptr_b = self; + return; +} + +const 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_size(const _VecCharInternal* ptr, err_t* err) +{ + err_t status = ERR_T_INIT; + if (__null_check(ptr, &status) != 0) + { + __origin_override(err, "SIZE"); + err->flags |= status.flags; + return 0; + } + return ptr->_internal_size; +} + +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(_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; + } + if (ptr->_internal_arr != nullptr) + { + free(ptr->_internal_arr); + ptr->_internal_arr = nullptr; + } + ptr->_internal_size = 0; + ptr->_internal_capacity = 0; +} + +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) + { + memset(ptr->_internal_arr, 0, ptr->_internal_size); + 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 nullptr; + } + if (idx >= ptr->_internal_size) + { + __origin_override(err, "AT"); + err->flags |= ERR_OUT_OF_BOUNDS; + return nullptr; + } + 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; + } + if (ptr->_internal_size == 0) + { + __origin_override(err, "END"); + err->flags |= ERR_SIZE_ZERO; + return status.flags; + } + return (size_t)(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 -1; + } + if (_vec_char_at(ptr, 0, err) == nullptr) + { + err->flags |= ERR_OUT_OF_BOUNDS; + return 0; + } + 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 -1; + } + if (_vec_char_at(ptr, 0, err) == nullptr) + { + err->flags |= ERR_OUT_OF_BOUNDS; + return 0; + } + 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) + { + __origin_override(err, "EMPTY"); + err->flags |= status.flags; + return status.flags; + } + if (ptr->_internal_size == 0) + { + return ptr->_internal_size; + } + return status.flags; +} + +__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; +} + +__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)); + memset(&ptr->_internal_arr[ptr->_internal_size - diff], 0, + sizeof(char) * diff); + 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_VEC_NULL) != 0) + { + __origin_override(err, "RESIZE"); + err->flags |= 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_BUF_NULL) != 0 || ptr->_internal_size == 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) + { + memset(&ptr->_internal_arr[size], 0, + ptr->_internal_size - size); + } + if (ptr->_internal_size < size && size <= ptr->_internal_capacity) + { + memset(&ptr->_internal_arr[ptr->_internal_size], 0, + size - ptr->_internal_size); + } + 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_VEC_NULL) != 0) + { + __origin_override(err, "RESIZE"); + err->flags |= 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_BUF_NULL) != 0 || ptr->_internal_size == 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) + { + memset(&ptr->_internal_arr[size], val, + ptr->_internal_size - size); + } + if (ptr->_internal_size < size && size <= ptr->_internal_capacity) + { + memset(&ptr->_internal_arr[ptr->_internal_size], val, + size - ptr->_internal_size); + } + 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++) + { + char* res = _vec_char_at(iterator, i, &status); + if (res == nullptr) + { + err->flags |= ERR_OUT_OF_BOUNDS; + return; + } + _vec_char_push_back(ptr, *res, &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; + return; + } + 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) != 0) + { + __origin_override(err, "INSERT"); + err->flags |= status.flags; + return; + } + if ((status.flags & ERR_BUF_NULL) != 0) + { + char* res = malloc(1 * sizeof(char)); + if (res == nullptr) + { + __origin_override(err, "INSERT"); + err->flags |= ERR_BUF_NULL; + return; + } + ptr->_internal_arr = res; + ptr->_internal_capacity = 1; + ptr->_internal_arr[0] = val; + ptr->_internal_size = 1; + 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; + __null_check(ptr, &status); + 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/int.c b/src/int.c new file mode 100644 index 0000000..2cb813b --- /dev/null +++ b/src/int.c @@ -0,0 +1,940 @@ +#include +#include +#include +#include +#include + +__attribute__((overloadable)) size_t +__null_check(const _VecIntInternal* ptr, err_t* status) +{ + if (status == nullptr) + { + return ERR_ERR_T_NULL; + } + if (ptr == nullptr) + { + status->flags |= ERR_VEC_NULL; + return ERR_VEC_NULL; + } + if (ptr->_internal_arr == nullptr) + { + status->flags |= ERR_BUF_NULL; + } + + return status->flags; +} + +__attribute__((overloadable)) size_t +__null_check(const int* ptr, err_t* status) +{ + if (status == nullptr) + { + return ERR_ERR_T_NULL; + } + if (ptr == nullptr) + { + status->flags |= ERR_BUF_NULL; + } + return status->flags; +} + +size_t +__origin_override(err_t* status, char* str) +{ + if (status == nullptr) + { + return ERR_ERR_T_NULL; + } + 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_int_print_vec(const _VecIntInternal* ptr, err_t* err) +{ + if (__null_check(ptr, err) != 0) + { + return; + } + for (size_t i = 0; i < ptr->_internal_size; i++) + { + printf("%d ", ptr->_internal_arr[i]); + } + printf("\n"); +} + +_VecIntInternal +_vec_int_cpy(const int* src, const size_t src_size, err_t* err) +{ + _VecIntInternal self = VEC_INIT; + err_t status = ERR_T_INIT; + + size_t null = __null_check(src, err); + if (null != 0) + { + if (null & ERR_ERR_T_NULL) + { + return self; + } + __origin_override(err, "CPY"); + err->flags |= status.flags; + return self; + } + if (src_size == 0) + { + __origin_override(err, "CPY"); + err->flags |= ERR_SIZE_ZERO; + err->flags |= status.flags; + return self; + } + if (src_size > self._internal_max_size) + { + __origin_override(err, "CPY"); + err->flags |= ERR_SIZE_OVERFLOW; + return self; + } + self._internal_arr = malloc(src_size * sizeof(int)); + if (self._internal_arr == nullptr) + { + __origin_override(err, "CPY"); + err->flags |= ERR_ALLOC_FAIL; + return self; + } + memcpy(self._internal_arr, src, src_size * sizeof(int)); + self._internal_size = src_size; + self._internal_capacity = src_size; + return self; +} + +void +_vec_int_push_back(_VecIntInternal* ptr, const int val, err_t* err) +{ + err_t status = ERR_T_INIT; + int* 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(int)); + if (res == nullptr) + { + __origin_override(err, "PUSH_BACK"); + err->flags |= ERR_ALLOC_FAIL; + return; + } + ptr->_internal_arr = res; + ptr->_internal_capacity = 1; + ptr->_internal_size = 0; + } + + 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(int)); + 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_int_pop_back(_VecIntInternal* ptr, err_t* err) +{ + if (__null_check(ptr, err) != 0) + { + __origin_override(err, "POP_BACK"); + return; + } + + if (ptr->_internal_size == 0) + { + __origin_override(err, "POP_BACK"); + err->flags |= ERR_SIZE_ZERO; + return; + } + + ptr->_internal_arr[ptr->_internal_size - 1] = 0; + ptr->_internal_size--; +} + +void +_vec_int_reserve(_VecIntInternal* ptr, const size_t capacity, err_t* err) +{ + err_t status = ERR_T_INIT; + if (__null_check(ptr, &status) != 0) + { + if ((status.flags & ERR_VEC_NULL) != 0) + { + __origin_override(err, "RESERVE"); + err->flags |= ERR_VEC_NULL; + return; + } + } + if (ptr->_internal_max_size < capacity) + { + __origin_override(err, "RESERVE"); + err->flags |= ERR_SIZE_OVERFLOW; + return; + } + if (capacity == 0) + { + __origin_override(err, "RESERVE"); + err->flags |= ERR_SIZE_ZERO; + return; + } + + int* res = realloc(ptr->_internal_arr, capacity * sizeof(int)); + if (res == nullptr) + { + __origin_override(err, "RESERVE"); + err->flags |= ERR_ALLOC_FAIL; + return; + } + ptr->_internal_arr = res; + ptr->_internal_capacity = capacity; + if (ptr->_internal_size > capacity) + { + ptr->_internal_size = capacity; + } + return; +} + +void +_vec_int_shrink_to_fit(_VecIntInternal* ptr, err_t* err) +{ + err_t status = ERR_T_INIT; + if (__null_check(ptr, &status) != 0) + { + __origin_override(err, "SHRINK_TO_FIT"); + err->flags |= status.flags; + return; + } + if (ptr->_internal_size == 0) + { + __origin_override(err, "SHRINK_TO_FIT"); + err->flags |= ERR_SIZE_ZERO; + return; + } + _vec_int_reserve(ptr, ptr->_internal_size, err); +} + +void +_vec_int_swap(_VecIntInternal* ptr_a, _VecIntInternal* ptr_b, err_t* err) +{ + err_t status_1 = ERR_T_INIT, status_2 = ERR_T_INIT; + if ((__null_check(ptr_a, &status_1) & ERR_VEC_NULL) != 0 || + (__null_check(ptr_b, &status_2) & ERR_VEC_NULL) != 0) + { + __origin_override(err, "SWAP"); + err->flags |= ERR_VEC_NULL; + return; + } + _VecIntInternal self = *ptr_a; + *ptr_a = *ptr_b; + *ptr_b = self; + return; +} + +const int* +_vec_int_data(const _VecIntInternal* 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_int_size(const _VecIntInternal* ptr, err_t* err) +{ + err_t status = ERR_T_INIT; + if (__null_check(ptr, &status) != 0) + { + __origin_override(err, "SIZE"); + err->flags |= status.flags; + return 0; + } + return ptr->_internal_size; +} + +size_t +_vec_int_capacity(const _VecIntInternal* 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_int_max_size(const _VecIntInternal* 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_int_delete(_VecIntInternal* 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; + } + if (ptr->_internal_arr != nullptr) + { + free(ptr->_internal_arr); + ptr->_internal_arr = nullptr; + } + ptr->_internal_size = 0; + ptr->_internal_capacity = 0; +} + +void +_vec_int_clear(_VecIntInternal* 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) + { + memset(ptr->_internal_arr, 0, + ptr->_internal_size * sizeof(int)); + ptr->_internal_size = 0; + } +} + +int* +_vec_int_at(const _VecIntInternal* 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 nullptr; + } + if (idx >= ptr->_internal_size) + { + __origin_override(err, "AT"); + err->flags |= ERR_OUT_OF_BOUNDS; + return nullptr; + } + return &ptr->_internal_arr[idx]; +} + +size_t +_vec_int_begin(const _VecIntInternal* 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_int_end(const _VecIntInternal* 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; + } + if (ptr->_internal_size == 0) + { + __origin_override(err, "END"); + err->flags |= ERR_SIZE_ZERO; + return status.flags; + } + return (size_t)(ptr->_internal_size - 1); +} + +int +_vec_int_front(const _VecIntInternal* 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 -1; + } + if (_vec_int_at(ptr, 0, err) == nullptr) + { + err->flags |= ERR_OUT_OF_BOUNDS; + return 0; + } + return *_vec_int_at(ptr, 0, err); +} + +int +_vec_int_back(const _VecIntInternal* 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 -1; + } + if (_vec_int_at(ptr, 0, err) == nullptr) + { + err->flags |= ERR_OUT_OF_BOUNDS; + return 0; + } + return *_vec_int_at(ptr, ptr->_internal_size - 1, err); +} + +size_t +_vec_int_empty(const _VecIntInternal* ptr, err_t* err) +{ + err_t status = ERR_T_INIT; + if (__null_check(ptr, &status) != 0) + { + __origin_override(err, "EMPTY"); + err->flags |= status.flags; + return status.flags; + } + if (ptr->_internal_size == 0) + { + return ptr->_internal_size; + } + return status.flags; +} + +__attribute__((overloadable)) void +_vec_int_erase(_VecIntInternal* 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(int)); + ptr->_internal_arr[ptr->_internal_size - 1] = 0; + ptr->_internal_size--; + return; +} + +__attribute__((overloadable)) void +_vec_int_erase(_VecIntInternal* 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(int)); + memset(&ptr->_internal_arr[ptr->_internal_size - diff], 0, + sizeof(int) * diff); + ptr->_internal_size -= diff; + return; +} + +__attribute__((overloadable)) void +_vec_int_resize(_VecIntInternal* ptr, const size_t size, err_t* err) +{ + err_t status = ERR_T_INIT; + __null_check(ptr, &status); + if ((status.flags & ERR_VEC_NULL) != 0) + { + __origin_override(err, "RESIZE"); + err->flags |= 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_BUF_NULL) != 0 || ptr->_internal_size == 0) + { + size_t max = ptr->_internal_max_size; + err_t verr = ERR_T_INIT; + _vec_int_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; + } + memset(ptr->_internal_arr, 0, size * sizeof(int)); + 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_int_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) + { + memset(&ptr->_internal_arr[size], 0, + (ptr->_internal_size - size) * sizeof(int)); + } + if (ptr->_internal_size < size && size <= ptr->_internal_capacity) + { + memset(&ptr->_internal_arr[ptr->_internal_size], 0, + (size - ptr->_internal_size) * sizeof(int)); + } + ptr->_internal_size = size; + return; +} + +__attribute__((overloadable)) void +_vec_int_resize(_VecIntInternal* ptr, const size_t size, const int val, + err_t* err) +{ + err_t status = ERR_T_INIT; + __null_check(ptr, &status); + if ((status.flags & ERR_VEC_NULL) != 0) + { + __origin_override(err, "RESIZE"); + err->flags |= 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_BUF_NULL) != 0 || ptr->_internal_size == 0) + { + size_t max = ptr->_internal_max_size; + err_t verr = ERR_T_INIT; + _vec_int_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_int_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] = 0; + } + } + 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_int_assign(_VecIntInternal* ptr, const _VecIntInternal* 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_int_erase(ptr, _vec_int_begin(ptr, &status), + _vec_int_end(ptr, &status) + 1, &status); + if (status.flags != 0) + { + __origin_override(err, "ASSIGN"); + err->flags |= status.flags; + return; + } + _vec_int_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++) + { + int* res = _vec_int_at(iterator, i, &status); + if (res == nullptr) + { + err->flags |= ERR_OUT_OF_BOUNDS; + return; + } + _vec_int_push_back(ptr, *res, &status); + if (status.flags != 0) + { + __origin_override(err, "ASSIGN"); + err->flags |= status.flags; + return; + } + } + return; +} + +__attribute__((overloadable)) void +_vec_int_assign(_VecIntInternal* ptr, const size_t amount, const int val, + err_t* err) +{ + err_t status = ERR_T_INIT; + if (__null_check(ptr, &status) != 0) + { + __origin_override(err, "ASSIGN"); + err->flags |= status.flags; + return; + } + if (amount == 0) + { + __origin_override(err, "ASSIGN"); + err->flags |= ERR_SIZE_ZERO; + return; + } + _vec_int_erase(ptr, _vec_int_begin(ptr, &status), + _vec_int_end(ptr, &status) + 1, &status); + if (status.flags != 0) + { + __origin_override(err, "ASSIGN"); + err->flags |= status.flags; + return; + } + _vec_int_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_int_push_back(ptr, val, &status); + if (status.flags != 0) + { + __origin_override(err, "ASSIGN"); + err->flags |= status.flags; + return; + } + } + return; +} + +__attribute__((overloadable)) void +_vec_int_insert(_VecIntInternal* ptr, const size_t iter, const int val, + err_t* err) +{ + err_t status = ERR_T_INIT; + __null_check(ptr, &status); + if ((status.flags & ERR_VEC_NULL) != 0) + { + __origin_override(err, "INSERT"); + err->flags |= status.flags; + return; + } + if ((status.flags & ERR_BUF_NULL) != 0) + { + int* res = malloc(1 * sizeof(int)); + if (res == nullptr) + { + __origin_override(err, "INSERT"); + err->flags |= ERR_BUF_NULL; + return; + } + ptr->_internal_arr = res; + ptr->_internal_capacity = 1; + ptr->_internal_arr[0] = val; + ptr->_internal_size = 1; + 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_int_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_int_insert(_VecIntInternal* ptr, const size_t iter, const size_t amount, + const int 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 (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_int_insert(ptr, i, val, &status); + if (status.flags != 0) + { + __origin_override(err, "INSERT"); + err->flags |= status.flags; + return; + } + } + return; +} + +__attribute__((overloadable)) void +_vec_int_insert(_VecIntInternal* ptr, const _VecIntInternal* 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_int_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/.DS_Store b/src/lib/.DS_Store deleted file mode 100644 index 561adb04a4af2c998fe435191ef7ad2ecb24cde8..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 6148 zcmeHKze~eF6nfV5T^{zViDYwSmIyM#X&*S(jSnTlD6QO#of_WaB=dl5Oj8M zbaL_^a1ng(-I3hcbS*{RgS#)e_uhT)zK~oF0913@X#ms#poWdmTf?rz$WLv?R?NsI zqM|vvopC!#k{EBqL;+D?`4ymd*Mm0n;Sy5&{mlpCUZd4ch9kX}^T zw?DsMk6w;le<$}hAMUPq4qgAKZ_mvXRp>$t36?W)nVH}6+T4{<_L1)M+)hNnULN7{ zGeZRia8=4}JT~v{Fz3y^1?Q}{gl`qbFoBd=dnGG&{5JPnnsfh&DJqy3Q&LA2rdY=S zwI91xZ2X`ume;P~Ywzs-RzGtmqNw2J@#*yWz&x3p!R7Z^cx(89K2bmv zSb7EM``}|E3=C!(`O|?N9{~_O9A?97I!jQFZ!j>JX+#g2(y53#Rhc7((&;$vo4CMW zrctMZVrHDjFe`IHQOu6xK8J$}G)gZDhytzx6@6Q${r_bC`QJ^FJ5fLs_*V)jFKmTP zT$0&aXBJ0$t&i;j8yUrA8aV|!vmNsVZN*#I*wE+G1!7<@(}*Kz@*}`9NGA#`RDoY< CGoecW diff --git a/src/libvec.c b/src/libvec.c deleted file mode 100644 index 1b97595..0000000 --- a/src/libvec.c +++ /dev/null @@ -1 +0,0 @@ -#include diff --git a/src/main.c b/src/main.c index baecdc5..4a9b8e6 100644 --- a/src/main.c +++ b/src/main.c @@ -12,13 +12,12 @@ * String 32 Bits with suffix of 's' */ +#include #include #include #include #include -#include "lib/utils/utils.h" - void print_bits(unsigned int num); @@ -26,6 +25,7 @@ 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 diff --git a/src/lib/utils/utils.c b/src/utils.c similarity index 98% rename from src/lib/utils/utils.c rename to src/utils.c index cf61493..8c9d673 100644 --- a/src/lib/utils/utils.c +++ b/src/utils.c @@ -1,5 +1,5 @@ +#include #include -#include const char* vec_get_error_desc(ERROR_CODES err) diff --git a/tests/test_learn.c b/tests/test_learn.c index 03f0dfa..28171e7 100644 --- a/tests/test_learn.c +++ b/tests/test_learn.c @@ -1,5 +1,5 @@ #include -#include +#include #include #include #include @@ -23,15 +23,15 @@ __asan_default_options(void) static void test_push_back_single(void) { - printf("[1] Testing push_back with a single character...\n"); - _VecCharInternal vec = VEC_INIT; + printf("[1] Testing push_back with a single integer...\n"); + _VecIntInternal vec = VEC_INIT; err_t err = ERR_T_INIT; - _vec_char_push_back(&vec, 'A', &err); + _vec_int_push_back(&vec, 65, &err); assert(err.flags == 0); assert(vec._internal_size == 1); - assert(vec._internal_arr[0] == 'A'); - _vec_char_delete(&vec, &err); + assert(vec._internal_arr[0] == 65); + _vec_int_delete(&vec, &err); printf("Passed\n"); } @@ -39,13 +39,13 @@ static void test_null_guards(void) { printf("[2] Testing null pointer checks in __null_check...\n"); - _VecCharInternal vec = VEC_INIT; + _VecIntInternal vec = VEC_INIT; err_t err = ERR_T_INIT; size_t res1 = __null_check(&vec, nullptr); assert(res1 == ERR_ERR_T_NULL); - size_t res2 = __null_check((const _VecCharInternal*)nullptr, &err); + size_t res2 = __null_check((const _VecIntInternal*)nullptr, &err); assert(res2 == ERR_VEC_NULL); assert((err.flags & ERR_VEC_NULL) != 0); @@ -60,7 +60,7 @@ test_null_guards(void) assert((err.flags & ERR_BUF_NULL) != 0); err = (err_t)ERR_T_INIT; - size_t res5 = __null_check((const char*)nullptr, nullptr); + size_t res5 = __null_check((const int*)nullptr, nullptr); assert(res5 == ERR_ERR_T_NULL); printf("Passed\n"); @@ -98,42 +98,42 @@ test_origin_override(void) static void test_print_vec(void) { - _VecCharInternal vec = VEC_INIT; + _VecIntInternal vec = VEC_INIT; err_t err = ERR_T_INIT; printf("[4] Testing print_vec with null vector\n"); - _vec_char_print_vec(nullptr, &err); + _vec_int_print_vec(nullptr, &err); assert((err.flags & ERR_VEC_NULL) != 0); printf("Passed\n"); printf("[5] Testing print_vec with null array\n"); err = (err_t)ERR_T_INIT; - _vec_char_print_vec(&vec, &err); + _vec_int_print_vec(&vec, &err); assert((err.flags & ERR_BUF_NULL) != 0); printf("Passed\n"); printf("[6] Testing print_vec with null err\n"); - _vec_char_print_vec(&vec, nullptr); + _vec_int_print_vec(&vec, nullptr); printf("Passed\n"); printf("[7] Testing print_vec with valid parameters\n"); err = (err_t)ERR_T_INIT; - _vec_char_push_back(&vec, 'a', &err); - _vec_char_push_back(&vec, 'b', &err); - _vec_char_print_vec(&vec, &err); - _vec_char_delete(&vec, &err); + _vec_int_push_back(&vec, 1, &err); + _vec_int_push_back(&vec, 2, &err); + _vec_int_print_vec(&vec, &err); + _vec_int_delete(&vec, &err); printf("Passed\n"); } static void test_cpy(void) { - char arr[3] = { 'a', 'b', 'c' }; - _VecCharInternal blank = VEC_INIT; + int arr[3] = { 1, 2, 3 }; + _VecIntInternal blank = VEC_INIT; - printf("[8] Testing _vec_char_cpy with null source arr\n"); + printf("[8] Testing _vec_int_cpy with null source arr\n"); err_t err1 = ERR_T_INIT; - _VecCharInternal tmp = _vec_char_cpy(nullptr, 3, &err1); + _VecIntInternal tmp = _vec_int_cpy(nullptr, 3, &err1); assert(blank._internal_arr == tmp._internal_arr && blank._internal_capacity == tmp._internal_capacity && blank._internal_size == tmp._internal_size && @@ -141,17 +141,17 @@ test_cpy(void) assert((err1.flags & ERR_BUF_NULL) != 0); printf("Passed\n"); - printf("[9] Testing _vec_char_cpy with null err\n"); - _VecCharInternal res2 = _vec_char_cpy(arr, 3, nullptr); + printf("[9] Testing _vec_int_cpy with null err\n"); + _VecIntInternal res2 = _vec_int_cpy(arr, 3, nullptr); assert(blank._internal_arr == res2._internal_arr && blank._internal_capacity == res2._internal_capacity && blank._internal_size == res2._internal_size && blank._internal_max_size == res2._internal_max_size); printf("Passed\n"); - printf("[10] Testing _vec_char_cpy with size 0\n"); + printf("[10] Testing _vec_int_cpy with size 0\n"); err_t err3 = ERR_T_INIT; - _VecCharInternal res3 = _vec_char_cpy(arr, 0, &err3); + _VecIntInternal res3 = _vec_int_cpy(arr, 0, &err3); assert(blank._internal_arr == res3._internal_arr && blank._internal_capacity == res3._internal_capacity && blank._internal_size == res3._internal_size && @@ -159,10 +159,10 @@ test_cpy(void) assert((err3.flags & ERR_SIZE_ZERO) != 0); printf("Passed\n"); - printf("[11] Testing _vec_char_cpy with size exceeding max_size\n"); + printf("[11] Testing _vec_int_cpy with size exceeding max_size\n"); err_t err4 = ERR_T_INIT; - _VecCharInternal res4 = - _vec_char_cpy(arr, res3._internal_max_size + 1, &err4); + _VecIntInternal res4 = + _vec_int_cpy(arr, res3._internal_max_size + 1, &err4); assert(blank._internal_arr == res4._internal_arr && blank._internal_capacity == res4._internal_capacity && blank._internal_size == res4._internal_size && @@ -170,22 +170,23 @@ test_cpy(void) assert((err4.flags & ERR_SIZE_OVERFLOW) != 0); printf("Passed\n"); - printf("[12] Testing _vec_char_cpy allocation failure\n"); + printf("[12] Testing _vec_int_cpy allocation failure\n"); err_t err5 = ERR_T_INIT; size_t huge_size = ((size_t)1 << 40); - _VecCharInternal res5 = _vec_char_cpy(arr, huge_size, &err5); + _VecIntInternal res5 = _vec_int_cpy(arr, huge_size, &err5); + assert(res5._internal_arr == blank._internal_arr); assert((err5.flags & ERR_ALLOC_FAIL) != 0); printf("Passed\n"); - printf("[13] Testing _vec_char_cpy with valid inputs\n"); + printf("[13] Testing _vec_int_cpy with valid inputs\n"); err_t err = ERR_T_INIT; - char res[4] = { 'a', 'b', 'c', 'd' }; - _VecCharInternal vec = _vec_char_cpy(res, 4, &err); + int res[4] = { 10, 20, 30, 40 }; + _VecIntInternal vec = _vec_int_cpy(res, 4, &err); assert(err.flags == 0); assert(vec._internal_size == 4); assert(vec._internal_capacity == 4); - assert(memcmp(vec._internal_arr, res, 4) == 0); - _vec_char_delete(&vec, &err); + assert(memcmp(vec._internal_arr, res, sizeof(int) * 4) == 0); + _vec_int_delete(&vec, &err); printf("Passed\n"); } @@ -196,151 +197,151 @@ test_cpy(void) static void test_push_back(void) { - printf("[14] Testing _vec_char_push_back null vec\n"); + printf("[14] Testing _vec_int_push_back null vec\n"); err_t err = ERR_T_INIT; - _vec_char_push_back(nullptr, 'a', &err); + _vec_int_push_back(nullptr, 1, &err); assert((err.flags & ERR_VEC_NULL) != 0); printf("Passed\n"); - printf("[15] Testing _vec_char_push_back null err\n"); - _VecCharInternal vec1 = VEC_INIT; - _vec_char_push_back(&vec1, 'a', nullptr); + printf("[15] Testing _vec_int_push_back null err\n"); + _VecIntInternal vec1 = VEC_INIT; + _vec_int_push_back(&vec1, 1, nullptr); assert(vec1._internal_size == 1); - _vec_char_delete(&vec1, &err); + _vec_int_delete(&vec1, &err); printf("Passed\n"); - printf("[16] Testing _vec_char_push_back size overflow\n"); - _VecCharInternal vec2 = VEC_INIT; + printf("[16] Testing _vec_int_push_back size overflow\n"); + _VecIntInternal vec2 = VEC_INIT; err_t err2 = ERR_T_INIT; vec2._internal_size = vec2._internal_max_size; - _vec_char_push_back(&vec2, 'a', &err2); + _vec_int_push_back(&vec2, 1, &err2); assert((err2.flags & ERR_SIZE_OVERFLOW) != 0); printf("Passed\n"); printf("[17] Testing push_back capacity growth realloc\n"); err_t err3 = ERR_T_INIT; - _VecCharInternal vec3 = VEC_INIT; - for (char c = '0'; c <= '9'; c++) + _VecIntInternal vec3 = VEC_INIT; + for (int val = 0; val < 10; val++) { - _vec_char_push_back(&vec3, c, &err3); + _vec_int_push_back(&vec3, val, &err3); assert(err3.flags == 0); } assert(vec3._internal_size == 10); assert(vec3._internal_capacity >= 10); - _vec_char_delete(&vec3, &err3); + _vec_int_delete(&vec3, &err3); printf("Passed\n"); } static void test_pop_back(void) { - _VecCharInternal vec = VEC_INIT; + _VecIntInternal vec = VEC_INIT; err_t err = ERR_T_INIT; - printf("[18] Testing _vec_char_pop_back null vector\n"); - _vec_char_pop_back(nullptr, &err); + printf("[18] Testing _vec_int_pop_back null vector\n"); + _vec_int_pop_back(nullptr, &err); assert((err.flags & ERR_VEC_NULL) != 0); printf("Passed\n"); - printf("[19] Testing _vec_char_pop_back size 0\n"); + printf("[19] Testing _vec_int_pop_back size 0\n"); err = (err_t)ERR_T_INIT; - _vec_char_push_back(&vec, 'x', &err); - _vec_char_pop_back(&vec, - &err); // size is now 0, but buffer is allocated + _vec_int_push_back(&vec, 42, &err); + _vec_int_pop_back(&vec, + &err); // size is now 0, but buffer is allocated err = (err_t)ERR_T_INIT; - _vec_char_pop_back(&vec, &err); + _vec_int_pop_back(&vec, &err); assert((err.flags & ERR_SIZE_ZERO) != 0); printf("Passed\n"); - printf("[20] Testing _vec_char_pop_back valid pop\n"); + printf("[20] Testing _vec_int_pop_back valid pop\n"); err = (err_t)ERR_T_INIT; - _vec_char_push_back(&vec, 'a', &err); - _vec_char_push_back(&vec, 'b', &err); + _vec_int_push_back(&vec, 1, &err); + _vec_int_push_back(&vec, 2, &err); assert(vec._internal_size == 2); - _vec_char_pop_back(&vec, &err); + _vec_int_pop_back(&vec, &err); assert(vec._internal_size == 1); - assert(vec._internal_arr[0] == 'a'); + assert(vec._internal_arr[0] == 1); assert(vec._internal_arr[1] == 0); - _vec_char_delete(&vec, &err); + _vec_int_delete(&vec, &err); printf("Passed\n"); } static void test_reserve(void) { - _VecCharInternal vec = VEC_INIT; + _VecIntInternal vec = VEC_INIT; err_t err = ERR_T_INIT; - printf("[21] Testing _vec_char_reserve null vector\n"); - _vec_char_reserve(nullptr, 1, &err); + printf("[21] Testing _vec_int_reserve null vector\n"); + _vec_int_reserve(nullptr, 1, &err); assert((err.flags & ERR_VEC_NULL) != 0); printf("Passed\n"); - printf("[22] Testing _vec_char_reserve capacity 0\n"); + printf("[22] Testing _vec_int_reserve capacity 0\n"); err = (err_t)ERR_T_INIT; - _vec_char_reserve(&vec, 0, &err); + _vec_int_reserve(&vec, 0, &err); assert((err.flags & ERR_SIZE_ZERO) != 0); printf("Passed\n"); - printf("[23] Testing _vec_char_reserve calloc on unallocated buffer\n"); + printf("[23] Testing _vec_int_reserve calloc on unallocated buffer\n"); err = (err_t)ERR_T_INIT; - _vec_char_reserve(&vec, 32, &err); + _vec_int_reserve(&vec, 32, &err); assert(err.flags == 0); assert(vec._internal_capacity == 32); assert(vec._internal_arr != nullptr); printf("Passed\n"); - printf("[24] Testing _vec_char_reserve realloc to larger capacity\n"); - _vec_char_reserve(&vec, 64, &err); + printf("[24] Testing _vec_int_reserve realloc to larger capacity\n"); + _vec_int_reserve(&vec, 64, &err); assert(err.flags == 0); assert(vec._internal_capacity == 64); printf("Passed\n"); - printf("[25] Testing _vec_char_reserve truncating size\n"); + printf("[25] Testing _vec_int_reserve truncating size\n"); vec._internal_size = 50; - _vec_char_reserve(&vec, 20, &err); + _vec_int_reserve(&vec, 20, &err); assert(vec._internal_size == 20); assert(vec._internal_capacity == 20); - _vec_char_delete(&vec, &err); + _vec_int_delete(&vec, &err); printf("Passed\n"); } static void test_shrink_to_fit(void) { - _VecCharInternal vec = VEC_INIT; + _VecIntInternal vec = VEC_INIT; err_t err = ERR_T_INIT; - printf("[26] Testing _vec_char_shrink_to_fit null vector\n"); - _vec_char_shrink_to_fit(nullptr, &err); + printf("[26] Testing _vec_int_shrink_to_fit null vector\n"); + _vec_int_shrink_to_fit(nullptr, &err); assert((err.flags & ERR_VEC_NULL) != 0); printf("Passed\n"); printf( - "[27] Testing _vec_char_shrink_to_fit size 0 with allocated " + "[27] Testing _vec_int_shrink_to_fit size 0 with allocated " "buffer\n"); err = (err_t)ERR_T_INIT; - _vec_char_push_back(&vec, 'a', &err); - _vec_char_pop_back(&vec, &err); + _vec_int_push_back(&vec, 1, &err); + _vec_int_pop_back(&vec, &err); err = (err_t)ERR_T_INIT; - _vec_char_shrink_to_fit(&vec, &err); + _vec_int_shrink_to_fit(&vec, &err); assert((err.flags & ERR_SIZE_ZERO) != 0); printf("Passed\n"); - printf("[28] Testing _vec_char_shrink_to_fit normal shrinkage\n"); - _vec_char_reserve(&vec, 128, &err); - for (char c = '0'; c < '5'; c++) + printf("[28] Testing _vec_int_shrink_to_fit normal shrinkage\n"); + _vec_int_reserve(&vec, 128, &err); + for (int val = 0; val < 5; val++) { - _vec_char_push_back(&vec, c, &err); + _vec_int_push_back(&vec, val, &err); } assert(vec._internal_capacity == 128); assert(vec._internal_size == 5); err = (err_t)ERR_T_INIT; - _vec_char_shrink_to_fit(&vec, &err); + _vec_int_shrink_to_fit(&vec, &err); assert(err.flags == 0); assert(vec._internal_capacity == 5); assert(vec._internal_size == 5); - _vec_char_delete(&vec, &err); + _vec_int_delete(&vec, &err); printf("Passed\n"); } @@ -352,75 +353,75 @@ static void test_getters_and_access(void) { printf("[29] Testing getters, clear, and boundary element access...\n"); - _VecCharInternal vec = VEC_INIT; + _VecIntInternal vec = VEC_INIT; err_t err = ERR_T_INIT; // 1. Null pointer check - assert(_vec_char_data(nullptr, &err) == nullptr); + assert(_vec_int_data(nullptr, &err) == nullptr); assert((err.flags & ERR_VEC_NULL) != 0); err = (err_t)ERR_T_INIT; - assert(_vec_char_size(nullptr, &err) == 0); + assert(_vec_int_size(nullptr, &err) == 0); assert((err.flags & ERR_VEC_NULL) != 0); err = (err_t)ERR_T_INIT; - assert(_vec_char_capacity(nullptr, &err) == 0); + assert(_vec_int_capacity(nullptr, &err) == 0); assert((err.flags & ERR_VEC_NULL) != 0); err = (err_t)ERR_T_INIT; - assert(_vec_char_max_size(nullptr, &err) == 0); + assert(_vec_int_max_size(nullptr, &err) == 0); assert((err.flags & ERR_VEC_NULL) != 0); // 2. Unallocated buffer check for empty() err = (err_t)ERR_T_INIT; - size_t unalloc_empty = _vec_char_empty(&vec, &err); + size_t unalloc_empty = _vec_int_empty(&vec, &err); assert((err.flags & ERR_BUF_NULL) != 0); assert(unalloc_empty != 0); // 3. Allocate the buffer and pop so size is 0 with valid arr err = (err_t)ERR_T_INIT; - _vec_char_push_back(&vec, 'x', &err); - _vec_char_pop_back(&vec, &err); + _vec_int_push_back(&vec, 100, &err); + _vec_int_pop_back(&vec, &err); err = (err_t)ERR_T_INIT; // Now _internal_arr is non-null and size is 0: - assert(_vec_char_empty(&vec, &err) == 0); + assert(_vec_int_empty(&vec, &err) == 0); // Boundary element access on size 0 err = (err_t)ERR_T_INIT; - assert(_vec_char_front(&vec, &err) == 0 || + assert(_vec_int_front(&vec, &err) == 0 || (err.flags & ERR_OUT_OF_BOUNDS) != 0); err = (err_t)ERR_T_INIT; - assert(_vec_char_back(&vec, &err) == 0 || + assert(_vec_int_back(&vec, &err) == 0 || (err.flags & ERR_OUT_OF_BOUNDS) != 0); // 4. Populate container err = (err_t)ERR_T_INIT; - _vec_char_push_back(&vec, 'x', &err); - _vec_char_push_back(&vec, 'y', &err); - _vec_char_push_back(&vec, 'z', &err); + _vec_int_push_back(&vec, 10, &err); + _vec_int_push_back(&vec, 20, &err); + _vec_int_push_back(&vec, 30, &err); - assert(_vec_char_size(&vec, &err) == 3); - assert(_vec_char_capacity(&vec, &err) >= 3); - assert(_vec_char_data(&vec, &err) == vec._internal_arr); - assert(_vec_char_front(&vec, &err) == 'x'); - assert(_vec_char_back(&vec, &err) == 'z'); - assert(_vec_char_begin(&vec, &err) == 0); - assert(_vec_char_end(&vec, &err) == 2); + assert(_vec_int_size(&vec, &err) == 3); + assert(_vec_int_capacity(&vec, &err) >= 3); + assert(_vec_int_data(&vec, &err) == vec._internal_arr); + assert(_vec_int_front(&vec, &err) == 10); + assert(_vec_int_back(&vec, &err) == 30); + assert(_vec_int_begin(&vec, &err) == 0); + assert(_vec_int_end(&vec, &err) == 2); // Out of bounds at() err = (err_t)ERR_T_INIT; - assert(_vec_char_at(&vec, 10, &err) == nullptr); + assert(_vec_int_at(&vec, 10, &err) == nullptr); assert((err.flags & ERR_OUT_OF_BOUNDS) != 0); // Clear container err = (err_t)ERR_T_INIT; - _vec_char_clear(&vec, &err); + _vec_int_clear(&vec, &err); assert(vec._internal_size == 0); assert(vec._internal_arr[0] == 0); - _vec_char_delete(&vec, &err); + _vec_int_delete(&vec, &err); assert(vec._internal_arr == nullptr); assert(vec._internal_size == 0); assert(vec._internal_capacity == 0); @@ -435,220 +436,222 @@ test_getters_and_access(void) static void test_swap(void) { - printf("[30] Testing _vec_char_swap...\n"); - _VecCharInternal a = VEC_INIT; - _VecCharInternal b = VEC_INIT; + printf("[30] Testing _vec_int_swap...\n"); + _VecIntInternal a = VEC_INIT; + _VecIntInternal b = VEC_INIT; err_t err = ERR_T_INIT; // Null vector checks - _vec_char_swap(nullptr, &b, &err); + _vec_int_swap(nullptr, &b, &err); assert((err.flags & ERR_VEC_NULL) != 0); err = (err_t)ERR_T_INIT; - _vec_char_swap(&a, nullptr, &err); + _vec_int_swap(&a, nullptr, &err); assert((err.flags & ERR_VEC_NULL) != 0); // Normal swap err = (err_t)ERR_T_INIT; - _vec_char_push_back(&a, 'A', &err); - _vec_char_push_back(&b, 'B', &err); - _vec_char_push_back(&b, 'C', &err); + _vec_int_push_back(&a, 100, &err); + _vec_int_push_back(&b, 200, &err); + _vec_int_push_back(&b, 300, &err); - _vec_char_swap(&a, &b, &err); + _vec_int_swap(&a, &b, &err); assert(a._internal_size == 2); - assert(a._internal_arr[0] == 'B'); + assert(a._internal_arr[0] == 200); assert(b._internal_size == 1); - assert(b._internal_arr[0] == 'A'); + assert(b._internal_arr[0] == 100); - _vec_char_delete(&a, &err); - _vec_char_delete(&b, &err); + _vec_int_delete(&a, &err); + _vec_int_delete(&b, &err); printf("Passed\n"); } static void test_erase_variants(void) { - printf("[31] Testing _vec_char_erase single & range overloads...\n"); - _VecCharInternal vec = VEC_INIT; + printf("[31] Testing _vec_int_erase single & range overloads...\n"); + _VecIntInternal vec = VEC_INIT; err_t err = ERR_T_INIT; - for (char c = '0'; c <= '5'; c++) + for (int val = 0; val <= 5; val++) { - _vec_char_push_back(&vec, c, &err); - } // "012345" + _vec_int_push_back(&vec, val, &err); + } // {0, 1, 2, 3, 4, 5} // Single element erase out of bounds (noop) - _vec_char_erase(&vec, 10, &err); + _vec_int_erase(&vec, 10, &err); assert(vec._internal_size == 6); - // Erase index 2 ('2') -> "01345" - _vec_char_erase(&vec, 2, &err); + // Erase index 2 (value 2) -> {0, 1, 3, 4, 5} + _vec_int_erase(&vec, 2, &err); assert(vec._internal_size == 5); - assert(vec._internal_arr[2] == '3'); + assert(vec._internal_arr[2] == 3); // Range erase invalid bounds err = (err_t)ERR_T_INIT; - _vec_char_erase(&vec, 4, 2, &err); // iter_end <= iter_start + _vec_int_erase(&vec, 4, 2, &err); // iter_end <= iter_start assert((err.flags & ERR_OUT_OF_BOUNDS) != 0); err = (err_t)ERR_T_INIT; - _vec_char_erase(&vec, 0, 10, &err); // iter_end > size + _vec_int_erase(&vec, 0, 10, &err); // iter_end > size assert((err.flags & ERR_OUT_OF_BOUNDS) != 0); - // Range erase middle: index 1 through 3 ("0[13]45" -> "045") + // Range erase middle: index 1 through 3 ({0, [1, 3], 4, 5} -> {0, 4, + // 5}) err = (err_t)ERR_T_INIT; - _vec_char_erase(&vec, 1, 3, &err); + _vec_int_erase(&vec, 1, 3, &err); assert(vec._internal_size == 3); - assert(vec._internal_arr[0] == '0'); - assert(vec._internal_arr[1] == '4'); - assert(vec._internal_arr[2] == '5'); + assert(vec._internal_arr[0] == 0); + assert(vec._internal_arr[1] == 4); + assert(vec._internal_arr[2] == 5); - _vec_char_delete(&vec, &err); + _vec_int_delete(&vec, &err); printf("Passed\n"); } static void test_resize(void) { - printf("[32] Testing _vec_char_resize (zero-fill & value-fill)...\n"); - _VecCharInternal vec = VEC_INIT; + printf("[32] Testing _vec_int_resize (zero-fill & value-fill)...\n"); + _VecIntInternal vec = VEC_INIT; err_t err = ERR_T_INIT; // Null vector - _vec_char_resize((_VecCharInternal*)nullptr, 10, &err); + _vec_int_resize((_VecIntInternal*)nullptr, 10, &err); assert((err.flags & ERR_VEC_NULL) != 0); // Resize unallocated buffer to size 5 err = (err_t)ERR_T_INIT; - _vec_char_resize(&vec, 5, &err); + _vec_int_resize(&vec, 5, &err); assert(err.flags == 0); assert(vec._internal_size == 5); assert(vec._internal_arr[0] == 0); // Same size requested err = (err_t)ERR_T_INIT; - _vec_char_resize(&vec, 5, &err); + _vec_int_resize(&vec, 5, &err); assert((err.flags & ERR_OUT_OF_BOUNDS) != 0); // Exceeds max size err = (err_t)ERR_T_INIT; - _vec_char_resize(&vec, vec._internal_max_size + 1, &err); + _vec_int_resize(&vec, vec._internal_max_size + 1, &err); assert((err.flags & ERR_SIZE_OVERFLOW) != 0); // Grow with value fill err = (err_t)ERR_T_INIT; - _vec_char_resize(&vec, 8, 'Z', &err); + _vec_int_resize(&vec, 8, 5, &err); assert(vec._internal_size == 8); - assert(vec._internal_arr[5] == 'Z'); - assert(vec._internal_arr[7] == 'Z'); + assert(vec._internal_arr[5] == 5); + assert(vec._internal_arr[7] == 5); // Shrink with value fill err = (err_t)ERR_T_INIT; - _vec_char_resize(&vec, 3, 'A', &err); + _vec_int_resize(&vec, 3, 10, &err); assert(vec._internal_size == 3); - _vec_char_delete(&vec, &err); + _vec_int_delete(&vec, &err); printf("Passed\n"); } static void test_assign(void) { - printf("[33] Testing _vec_char_assign overloads...\n"); - _VecCharInternal dst = VEC_INIT; - _VecCharInternal src = VEC_INIT; + printf("[33] Testing _vec_int_assign overloads...\n"); + _VecIntInternal dst = VEC_INIT; + _VecIntInternal src = VEC_INIT; err_t err = ERR_T_INIT; - // Populate src: 'A', 'B', 'C', 'D', 'E' - for (char c = 'A'; c <= 'E'; c++) + // Populate src: 1, 2, 3, 4, 5 + for (int val = 1; val <= 5; val++) { - _vec_char_push_back(&src, c, &err); + _vec_int_push_back(&src, val, &err); } // Allocate dst buffer first so it is not unallocated - _vec_char_push_back(&dst, 'z', &err); + _vec_int_push_back(&dst, 999, &err); err = (err_t)ERR_T_INIT; - // 1. Fill assign: 4 'X's - _vec_char_assign(&dst, 4, 'X', &err); + // 1. Fill assign: 4 42's + _vec_int_assign(&dst, 4, 42, &err); assert(err.flags == 0); assert(dst._internal_size == 4); - assert(dst._internal_arr[0] == 'X'); - assert(dst._internal_arr[3] == 'X'); + assert(dst._internal_arr[0] == 42); + assert(dst._internal_arr[3] == 42); // 2. Fill assign with 0 amount err = (err_t)ERR_T_INIT; - _vec_char_assign(&dst, 0, 'Y', &err); + _vec_int_assign(&dst, 0, 50, &err); assert((err.flags & ERR_SIZE_ZERO) != 0); // 3. Range assign self-buffer check err = (err_t)ERR_T_INIT; - _vec_char_assign(&dst, &dst, 0, 2, &err); + _vec_int_assign(&dst, &dst, 0, 2, &err); assert((err.flags & ERR_DOUBLE_BUF) != 0); // 4. Range assign invalid sub-range (start >= end) err = (err_t)ERR_T_INIT; - _vec_char_assign(&dst, &src, 3, 2, &err); + _vec_int_assign(&dst, &src, 3, 2, &err); assert((err.flags & ERR_OUT_OF_BOUNDS) != 0); // 5. Range assign out of bounds end err = (err_t)ERR_T_INIT; - _vec_char_assign(&dst, &src, 0, 10, &err); + _vec_int_assign(&dst, &src, 0, 10, &err); assert((err.flags & ERR_OUT_OF_BOUNDS) != 0); - _vec_char_delete(&dst, &err); - _vec_char_delete(&src, &err); + _vec_int_delete(&dst, &err); + _vec_int_delete(&src, &err); printf("Passed\n"); } static void test_insert(void) { - printf("[34] Testing _vec_char_insert overloads...\n"); - _VecCharInternal vec = VEC_INIT; - _VecCharInternal other = VEC_INIT; + printf("[34] Testing _vec_int_insert overloads...\n"); + _VecIntInternal vec = VEC_INIT; + _VecIntInternal other = VEC_INIT; err_t err = ERR_T_INIT; // Single insert on unallocated buffer - _vec_char_insert(&vec, 0, 'M', &err); + _vec_int_insert(&vec, 0, 500, &err); assert(vec._internal_size == 1); - assert(vec._internal_arr[0] == 'M'); + assert(vec._internal_arr[0] == 500); // Single insert out of bounds err = (err_t)ERR_T_INIT; - _vec_char_insert(&vec, 5, 'O', &err); + _vec_int_insert(&vec, 5, 999, &err); assert((err.flags & ERR_OUT_OF_BOUNDS) != 0); - // Single insert at middle: index 0 ('A', then 'M' shifts to 1) + // Single insert at middle: index 0 (100, then 500 shifts to 1) err = (err_t)ERR_T_INIT; - _vec_char_insert(&vec, 0, 'A', &err); + _vec_int_insert(&vec, 0, 100, &err); assert(vec._internal_size == 2); - assert(vec._internal_arr[0] == 'A'); - assert(vec._internal_arr[1] == 'M'); + assert(vec._internal_arr[0] == 100); + assert(vec._internal_arr[1] == 500); - // Repeated insert: insert 3 'B's at index 1 -> 'A', 'B', 'B', 'B', 'M' - _vec_char_insert(&vec, 1, 3, 'B', &err); + // Repeated insert: insert 3 200s at index 1 -> {100, 200, 200, 200, + // 500} + _vec_int_insert(&vec, 1, 3, 200, &err); assert(vec._internal_size == 5); - assert(vec._internal_arr[1] == 'B'); - assert(vec._internal_arr[3] == 'B'); - assert(vec._internal_arr[4] == 'M'); + assert(vec._internal_arr[1] == 200); + assert(vec._internal_arr[3] == 200); + assert(vec._internal_arr[4] == 500); // Repeated insert amount 0 err = (err_t)ERR_T_INIT; - _vec_char_insert(&vec, 0, 0, 'Z', &err); + _vec_int_insert(&vec, 0, 0, 300, &err); assert((err.flags & ERR_SIZE_ZERO) != 0); // Vector-from-vector range insert - _vec_char_push_back(&other, '1', &err); - _vec_char_push_back(&other, '2', &err); + _vec_int_push_back(&other, 1, &err); + _vec_int_push_back(&other, 2, &err); // Double buffer check err = (err_t)ERR_T_INIT; - _vec_char_insert(&vec, &vec, 0, 0, 1, &err); + _vec_int_insert(&vec, &vec, 0, 0, 1, &err); assert((err.flags & ERR_DOUBLE_BUF) != 0); - _vec_char_delete(&vec, &err); - _vec_char_delete(&other, &err); + _vec_int_delete(&vec, &err); + _vec_int_delete(&other, &err); printf("Passed\n"); }