DarthMooMancer/libvec
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

REFACTOR: Made everything public and new name scheme

Browse Source
This commit is contained in:
DarthMooMancer
2026-10-14 10:20:19 -04:00
parent 813390b6ac
commit 4d96592a1e
9 changed files with 713 additions and 853 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/libvec/char.h
+40 -44
View File
@@ -7,14 +7,14 @@
typedef struct typedef struct
{ {
char* _internal_arr; char* array;
size_t _internal_size; size_t size;
size_t _internal_capacity; size_t capacity;
size_t _internal_max_size; size_t max_size;
} _VecCharInternal; } vec_char;
__attribute__((overloadable)) size_t __attribute__((overloadable)) size_t
__null_check(const _VecCharInternal* ptr, err_t* status); __null_check(const vec_char* ptr, err_t* status);
__attribute__((overloadable)) size_t __attribute__((overloadable)) size_t
__null_check(const char* ptr, err_t* status); __null_check(const char* ptr, err_t* status);
@@ -23,95 +23,91 @@ size_t
__origin_override(err_t* status, char* str); __origin_override(err_t* status, char* str);
void void
_vec_char_print_vec(const _VecCharInternal* ptr, err_t* err); vec_char_print_vec(const vec_char* ptr, err_t* err);
_VecCharInternal vec_char
_vec_char_cpy(const char* src, const size_t src_size, err_t* err); vec_char_cpy(const char* src, const size_t src_size, err_t* err);
void void
_vec_char_push_back(_VecCharInternal* ptr, const char val, err_t* err); vec_char_push_back(vec_char* ptr, const char val, err_t* err);
void void
_vec_char_pop_back(_VecCharInternal* ptr, err_t* err); vec_char_pop_back(vec_char* ptr, err_t* err);
void void
_vec_char_reserve(_VecCharInternal* ptr, const size_t capacity, err_t* err); vec_char_reserve(vec_char* ptr, const size_t capacity, err_t* err);
void void
_vec_char_shrink_to_fit(_VecCharInternal* ptr, err_t* err); vec_char_shrink_to_fit(vec_char* ptr, err_t* err);
void void
_vec_char_swap(_VecCharInternal* ptr_a, _VecCharInternal* ptr_b, err_t* err); vec_char_swap(vec_char* ptr_a, vec_char* ptr_b, err_t* err);
const char* const char*
_vec_char_data(const _VecCharInternal* ptr, err_t* err); vec_char_data(const vec_char* ptr, err_t* err);
size_t size_t
_vec_char_size(const _VecCharInternal* ptr, err_t* err); vec_char_size(const vec_char* ptr, err_t* err);
size_t size_t
_vec_char_capacity(const _VecCharInternal* ptr, err_t* err); vec_char_capacity(const vec_char* ptr, err_t* err);
size_t size_t
_vec_char_max_size(const _VecCharInternal* ptr, err_t* err); vec_char_max_size(const vec_char* ptr, err_t* err);
void void
_vec_char_delete(_VecCharInternal* ptr, err_t* err); vec_char_delete(vec_char* ptr, err_t* err);
void void
_vec_char_clear(_VecCharInternal* ptr, err_t* err); vec_char_clear(vec_char* ptr, err_t* err);
char* char*
_vec_char_at(const _VecCharInternal* ptr, const size_t idx, err_t* err); vec_char_at(const vec_char* ptr, const size_t idx, err_t* err);
size_t size_t
_vec_char_begin(const _VecCharInternal* ptr, err_t* err); vec_char_begin(const vec_char* ptr, err_t* err);
size_t size_t
_vec_char_end(const _VecCharInternal* ptr, err_t* err); vec_char_end(const vec_char* ptr, err_t* err);
char char
_vec_char_front(const _VecCharInternal* ptr, err_t* err); vec_char_front(const vec_char* ptr, err_t* err);
char char
_vec_char_back(const _VecCharInternal* ptr, err_t* err); vec_char_back(const vec_char* ptr, err_t* err);
size_t size_t
_vec_char_empty(const _VecCharInternal* ptr, err_t* err); vec_char_empty(const vec_char* ptr, err_t* err);
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_char_erase(_VecCharInternal* ptr, const size_t iter, err_t* err); vec_char_erase(vec_char* ptr, const size_t iter, err_t* err);
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_char_erase(_VecCharInternal* ptr, const size_t iter_start, vec_char_erase(vec_char* ptr, const size_t iter_start, const size_t iter_end,
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); err_t* err);
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_char_assign(_VecCharInternal* ptr, const _VecCharInternal* iterator, vec_char_resize(vec_char* ptr, const size_t size, err_t* err);
__attribute__((overloadable)) void
vec_char_resize(vec_char* ptr, const size_t size, const char val, err_t* err);
__attribute__((overloadable)) void
vec_char_assign(vec_char* ptr, const vec_char* iterator,
const size_t iter_start, const size_t iter_end, err_t* err); const size_t iter_start, const size_t iter_end, err_t* err);
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_char_assign(_VecCharInternal* ptr, const size_t amount, const char val, vec_char_assign(vec_char* ptr, const size_t amount, const char val, err_t* err);
err_t* err);
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_char_insert(_VecCharInternal* ptr, const size_t iter, const char val, vec_char_insert(vec_char* ptr, const size_t iter, const char val, err_t* err);
err_t* err);
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_char_insert(_VecCharInternal* ptr, const size_t iter, const size_t amount, vec_char_insert(vec_char* ptr, const size_t iter, const size_t amount,
const char val, err_t* err); const char val, err_t* err);
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_char_insert(_VecCharInternal* ptr, const _VecCharInternal* iterator, vec_char_insert(vec_char* ptr, const vec_char* iterator, const size_t iter,
const size_t iter, const size_t iter_start, const size_t iter_start, const size_t iter_end, err_t* err);
const size_t iter_end, err_t* err);
#endif #endif
include/libvec/float.h
+57 -67
View File
@@ -7,111 +7,101 @@
typedef struct typedef struct
{ {
char* _internal_arr; float* array;
size_t _internal_size; size_t size;
size_t _internal_capacity; size_t capacity;
size_t _internal_max_size; size_t max_size;
} _VecCharInternal; } vec_float;
__attribute__((overloadable)) size_t void
__null_check(const _VecCharInternal* ptr, err_t* status); vec_float_print_vec(const vec_float* ptr, err_t* err);
__attribute__((overloadable)) size_t vec_float
__null_check(const char* ptr, err_t* status); vec_float_cpy(const float* src, const size_t src_size, err_t* err);
void
vec_float_push_back(vec_float* ptr, const float val, err_t* err);
void
vec_float_pop_back(vec_float* ptr, err_t* err);
void
vec_float_reserve(vec_float* ptr, const size_t capacity, err_t* err);
void
vec_float_shrink_to_fit(vec_float* ptr, err_t* err);
void
vec_float_swap(vec_float* ptr_a, vec_float* ptr_b, err_t* err);
const float*
vec_float_data(const vec_float* ptr, err_t* err);
size_t size_t
__origin_override(err_t* status, char* str); vec_float_size(const vec_float* ptr, err_t* err);
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 size_t
_vec_char_size(const _VecCharInternal* ptr, err_t* err); vec_float_capacity(const vec_float* ptr, err_t* err);
size_t size_t
_vec_char_capacity(const _VecCharInternal* ptr, err_t* err); vec_float_max_size(const vec_float* ptr, err_t* err);
size_t
_vec_char_max_size(const _VecCharInternal* ptr, err_t* err);
void void
_vec_char_delete(_VecCharInternal* ptr, err_t* err); vec_float_delete(vec_float* ptr, err_t* err);
void void
_vec_char_clear(_VecCharInternal* ptr, err_t* err); vec_float_clear(vec_float* ptr, err_t* err);
char* float*
_vec_char_at(const _VecCharInternal* ptr, const size_t idx, err_t* err); vec_float_at(const vec_float* ptr, const size_t idx, err_t* err);
size_t size_t
_vec_char_begin(const _VecCharInternal* ptr, err_t* err); vec_float_begin(const vec_float* ptr, err_t* err);
size_t size_t
_vec_char_end(const _VecCharInternal* ptr, err_t* err); vec_float_end(const vec_float* ptr, err_t* err);
char float
_vec_char_front(const _VecCharInternal* ptr, err_t* err); vec_float_front(const vec_float* ptr, err_t* err);
char float
_vec_char_back(const _VecCharInternal* ptr, err_t* err); vec_float_back(const vec_float* ptr, err_t* err);
size_t size_t
_vec_char_empty(const _VecCharInternal* ptr, err_t* err); vec_float_empty(const vec_float* ptr, err_t* err);
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_char_erase(_VecCharInternal* ptr, const size_t iter, err_t* err); vec_float_erase(vec_float* ptr, const size_t iter, err_t* err);
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_char_erase(_VecCharInternal* ptr, const size_t iter_start, vec_float_erase(vec_float* ptr, const size_t iter_start, const size_t iter_end,
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); err_t* err);
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_char_assign(_VecCharInternal* ptr, const _VecCharInternal* iterator, vec_float_resize(vec_float* ptr, const size_t size, err_t* err);
__attribute__((overloadable)) void
vec_float_resize(vec_float* ptr, const size_t size, const float val,
err_t* err);
__attribute__((overloadable)) void
vec_float_assign(vec_float* ptr, const vec_float* iterator,
const size_t iter_start, const size_t iter_end, err_t* err); const size_t iter_start, const size_t iter_end, err_t* err);
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_char_assign(_VecCharInternal* ptr, const size_t amount, const char val, vec_float_assign(vec_float* ptr, const size_t amount, const float val,
err_t* err); err_t* err);
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_char_insert(_VecCharInternal* ptr, const size_t iter, const char val, vec_float_insert(vec_float* ptr, const size_t iter, const float val,
err_t* err); err_t* err);
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_char_insert(_VecCharInternal* ptr, const size_t iter, const size_t amount, vec_float_insert(vec_float* ptr, const size_t iter, const size_t amount,
const char val, err_t* err); const float val, err_t* err);
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_char_insert(_VecCharInternal* ptr, const _VecCharInternal* iterator, vec_float_insert(vec_float* ptr, const vec_float* iterator, const size_t iter,
const size_t iter, const size_t iter_start, const size_t iter_start, const size_t iter_end, err_t* err);
const size_t iter_end, err_t* err);
#endif #endif
include/libvec/int.h
+43 -47
View File
@@ -7,14 +7,14 @@
typedef struct typedef struct
{ {
int* _internal_arr; int* array;
size_t _internal_size; size_t size;
size_t _internal_capacity; size_t capacity;
size_t _internal_max_size; size_t max_size;
} _VecIntInternal; } vec_int;
__attribute__((overloadable)) size_t __attribute__((overloadable)) size_t
__null_check(const _VecIntInternal* ptr, err_t* status); __null_check(const vec_int* ptr, err_t* status);
__attribute__((overloadable)) size_t __attribute__((overloadable)) size_t
__null_check(const int* ptr, err_t* status); __null_check(const int* ptr, err_t* status);
@@ -23,95 +23,91 @@ size_t
__origin_override(err_t* status, char* str); __origin_override(err_t* status, char* str);
void void
_vec_int_print_vec(const _VecIntInternal* ptr, err_t* err); vec_int_print_vec(const vec_int* ptr, err_t* err);
_VecIntInternal vec_int
_vec_int_cpy(const int* src, const size_t src_size, err_t* err); vec_int_cpy(const int* src, const size_t src_size, err_t* err);
void void
_vec_int_push_back(_VecIntInternal* ptr, const int val, err_t* err); vec_int_push_back(vec_int* ptr, const int val, err_t* err);
void void
_vec_int_pop_back(_VecIntInternal* ptr, err_t* err); vec_int_pop_back(vec_int* ptr, err_t* err);
void void
_vec_int_reserve(_VecIntInternal* ptr, const size_t capacity, err_t* err); vec_int_reserve(vec_int* ptr, const size_t capacity, err_t* err);
void void
_vec_int_shrink_to_fit(_VecIntInternal* ptr, err_t* err); vec_int_shrink_to_fit(vec_int* ptr, err_t* err);
void void
_vec_int_swap(_VecIntInternal* ptr_a, _VecIntInternal* ptr_b, err_t* err); vec_int_swap(vec_int* ptr_a, vec_int* ptr_b, err_t* err);
const int* const int*
_vec_int_data(const _VecIntInternal* ptr, err_t* err); vec_int_data(const vec_int* ptr, err_t* err);
size_t size_t
_vec_int_size(const _VecIntInternal* ptr, err_t* err); vec_int_size(const vec_int* ptr, err_t* err);
size_t size_t
_vec_int_capacity(const _VecIntInternal* ptr, err_t* err); vec_int_capacity(const vec_int* ptr, err_t* err);
size_t size_t
_vec_int_max_size(const _VecIntInternal* ptr, err_t* err); vec_int_max_size(const vec_int* ptr, err_t* err);
void void
_vec_int_delete(_VecIntInternal* ptr, err_t* err); vec_int_delete(vec_int* ptr, err_t* err);
void void
_vec_int_clear(_VecIntInternal* ptr, err_t* err); vec_int_clear(vec_int* ptr, err_t* err);
int* int*
_vec_int_at(const _VecIntInternal* ptr, const size_t idx, err_t* err); vec_int_at(const vec_int* ptr, const size_t idx, err_t* err);
size_t size_t
_vec_int_begin(const _VecIntInternal* ptr, err_t* err); vec_int_begin(const vec_int* ptr, err_t* err);
size_t size_t
_vec_int_end(const _VecIntInternal* ptr, err_t* err); vec_int_end(const vec_int* ptr, err_t* err);
int int
_vec_int_front(const _VecIntInternal* ptr, err_t* err); vec_int_front(const vec_int* ptr, err_t* err);
int int
_vec_int_back(const _VecIntInternal* ptr, err_t* err); vec_int_back(const vec_int* ptr, err_t* err);
size_t size_t
_vec_int_empty(const _VecIntInternal* ptr, err_t* err); vec_int_empty(const vec_int* ptr, err_t* err);
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_int_erase(_VecIntInternal* ptr, const size_t iter, err_t* err); vec_int_erase(vec_int* ptr, const size_t iter, err_t* err);
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_int_erase(_VecIntInternal* ptr, const size_t iter_start, vec_int_erase(vec_int* ptr, const size_t iter_start, const size_t iter_end,
err_t* err);
__attribute__((overloadable)) void
vec_int_resize(vec_int* ptr, const size_t size, err_t* err);
__attribute__((overloadable)) void
vec_int_resize(vec_int* ptr, const size_t size, const int val, err_t* err);
__attribute__((overloadable)) void
vec_int_assign(vec_int* ptr, const vec_int* iterator, const size_t iter_start,
const size_t iter_end, err_t* err); const size_t iter_end, err_t* err);
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_int_resize(_VecIntInternal* ptr, const size_t size, err_t* err); vec_int_assign(vec_int* ptr, const size_t amount, const int val, err_t* err);
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_int_resize(_VecIntInternal* ptr, const size_t size, const int val, vec_int_insert(vec_int* ptr, const size_t iter, const int val, err_t* err);
err_t* err);
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_int_assign(_VecIntInternal* ptr, const _VecIntInternal* iterator, vec_int_insert(vec_int* ptr, const size_t iter, const size_t amount,
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); const int val, err_t* err);
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_int_insert(_VecIntInternal* ptr, const _VecIntInternal* iterator, vec_int_insert(vec_int* ptr, const vec_int* iterator, const size_t iter,
const size_t iter, const size_t iter_start, const size_t iter_start, const size_t iter_end, err_t* err);
const size_t iter_end, err_t* err);
#endif #endif
include/libvec/utils.h
+9 -11
View File
@@ -4,8 +4,6 @@
#include <stddef.h> #include <stddef.h>
#include <stdint.h> #include <stdint.h>
#define CAPACITY 1024
#define VEC_FAULT_BITS 32
static const size_t VEC_MAX = SIZE_MAX / sizeof(int); static const size_t VEC_MAX = SIZE_MAX / sizeof(int);
#define ERROR_LIST(X) \ #define ERROR_LIST(X) \
@@ -46,22 +44,22 @@ typedef struct
#define ERR_T_INIT { .flags = 0, .origin = NULL } #define ERR_T_INIT { .flags = 0, .origin = NULL }
#define VEC_INIT \ #define VEC_INIT \
{ ._internal_arr = NULL, \ { .array = NULL, .size = 0, .capacity = 0, .max_size = VEC_MAX }
._internal_size = 0, \
._internal_capacity = 0, \
._internal_max_size = VEC_MAX }
const char*
vec_get_error_desc(ERROR_CODES err);
void void
vec_print_errs(const err_t err); vec_print_errs(const err_t err);
void void
print_bits(unsigned int num); vec_print_bits(unsigned int num);
size_t
__origin_override(err_t* status, char* str);
__attribute__((overloadable)) size_t
__null_check(const float* ptr, err_t* status);
#define LOG(msg) printf("LOG: %s\n", msg) /**< Print log message*/ #define LOG(msg) printf("LOG: %s\n", msg) /**< Print log message*/
#define DEBUG(msg) printf("DEBUG: %s\n", msg) /**< Print debug message*/ #define DEBUG(msg) printf("DEBUG: %s\n", msg) /**< Print debug message*/
#define find_len(arr) sizeof(arr) / sizeof(arr[0]) #define find_len(arr) (sizeof(arr) / sizeof((arr)[0]))
#endif #endif
src/char.c
+170 -219
View File
@@ -1,5 +1,4 @@
#include "libvec/char.h" #include <libvec/char.h>
#include <libvec/utils.h> #include <libvec/utils.h>
#include <stddef.h> #include <stddef.h>
#include <stdio.h> #include <stdio.h>
@@ -7,7 +6,7 @@
#include <string.h> #include <string.h>
__attribute__((overloadable)) size_t __attribute__((overloadable)) size_t
__null_check(const _VecCharInternal* ptr, err_t* status) __null_check(const vec_char* ptr, err_t* status)
{ {
if (status == nullptr) if (status == nullptr)
{ {
@@ -18,7 +17,7 @@ __null_check(const _VecCharInternal* ptr, err_t* status)
status->flags |= ERR_VEC_NULL; status->flags |= ERR_VEC_NULL;
return ERR_VEC_NULL; return ERR_VEC_NULL;
} }
if (ptr->_internal_arr == nullptr) if (ptr->array == nullptr)
{ {
status->flags |= ERR_BUF_NULL; status->flags |= ERR_BUF_NULL;
} }
@@ -26,62 +25,24 @@ __null_check(const _VecCharInternal* ptr, err_t* status)
return status->flags; 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 void
_vec_char_print_vec(const _VecCharInternal* ptr, err_t* err) vec_char_print_vec(const vec_char* ptr, err_t* err)
{ {
if (__null_check(ptr, err) != 0) if (__null_check(ptr, err) != 0)
{ {
return; return;
} }
for (size_t i = 0; i < ptr->_internal_size; i++) for (size_t i = 0; i < ptr->size; i++)
{ {
printf("%c ", ptr->_internal_arr[i]); printf("%c ", ptr->array[i]);
} }
printf("\n"); printf("\n");
} }
_VecCharInternal vec_char
_vec_char_cpy(const char* src, const size_t src_size, err_t* err) vec_char_cpy(const char* src, const size_t src_size, err_t* err)
{ {
_VecCharInternal self = VEC_INIT; vec_char self = VEC_INIT;
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
size_t null = __null_check(src, err); size_t null = __null_check(src, err);
@@ -102,27 +63,27 @@ _vec_char_cpy(const char* src, const size_t src_size, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return self; return self;
} }
if (src_size > self._internal_max_size) if (src_size > self.max_size)
{ {
__origin_override(err, "CPY"); __origin_override(err, "CPY");
err->flags |= ERR_SIZE_OVERFLOW; err->flags |= ERR_SIZE_OVERFLOW;
return self; return self;
} }
self._internal_arr = malloc(src_size * sizeof(char)); self.array = malloc(src_size * sizeof(char));
if (self._internal_arr == nullptr) if (self.array == nullptr)
{ {
__origin_override(err, "CPY"); __origin_override(err, "CPY");
err->flags |= ERR_ALLOC_FAIL; err->flags |= ERR_ALLOC_FAIL;
return self; return self;
} }
memcpy(self._internal_arr, src, src_size * sizeof(char)); memcpy(self.array, src, src_size * sizeof(char));
self._internal_size = src_size; self.size = src_size;
self._internal_capacity = src_size; self.capacity = src_size;
return self; return self;
} }
void void
_vec_char_push_back(_VecCharInternal* ptr, const char val, err_t* err) vec_char_push_back(vec_char* ptr, const char val, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
char* res; char* res;
@@ -134,7 +95,7 @@ _vec_char_push_back(_VecCharInternal* ptr, const char val, err_t* err)
return; return;
} }
if (ptr->_internal_size + 1 > ptr->_internal_max_size) if (ptr->size + 1 > ptr->max_size)
{ {
__origin_override(err, "PUSH_BACK"); __origin_override(err, "PUSH_BACK");
err->flags |= ERR_SIZE_OVERFLOW; err->flags |= ERR_SIZE_OVERFLOW;
@@ -150,43 +111,42 @@ _vec_char_push_back(_VecCharInternal* ptr, const char val, err_t* err)
err->flags |= ERR_ALLOC_FAIL; err->flags |= ERR_ALLOC_FAIL;
return; return;
} }
ptr->_internal_arr = res; ptr->array = res;
ptr->_internal_capacity = 1; ptr->capacity = 1;
ptr->_internal_size = 0; ptr->size = 0;
} }
else if (ptr->_internal_size + 1 > ptr->_internal_capacity) else if (ptr->size + 1 > ptr->capacity)
{ {
size_t dst_cap = size_t dst_cap = (ptr->capacity / 2) + ptr->capacity;
(ptr->_internal_capacity / 2) + ptr->_internal_capacity; if (dst_cap == ptr->capacity)
if (dst_cap == ptr->_internal_capacity)
{ {
dst_cap++; dst_cap++;
} }
if (dst_cap > ptr->_internal_max_size) if (dst_cap > ptr->max_size)
{ {
dst_cap = ptr->_internal_max_size; dst_cap = ptr->max_size;
DEBUG( DEBUG(
"Capacity cannot be grown any further due " "Capacity cannot be grown any further due "
"to hitting max size"); "to hitting max size");
} }
res = realloc(ptr->_internal_arr, dst_cap * sizeof(char)); res = realloc(ptr->array, dst_cap * sizeof(char));
if (res == nullptr) if (res == nullptr)
{ {
__origin_override(err, "PUSH_BACK"); __origin_override(err, "PUSH_BACK");
err->flags |= ERR_SIZE_OVERFLOW; err->flags |= ERR_SIZE_OVERFLOW;
return; return;
} }
ptr->_internal_arr = res; ptr->array = res;
ptr->_internal_capacity = dst_cap; ptr->capacity = dst_cap;
} }
ptr->_internal_arr[ptr->_internal_size] = val; ptr->array[ptr->size] = val;
ptr->_internal_size++; ptr->size++;
return; return;
} }
void void
_vec_char_pop_back(_VecCharInternal* ptr, err_t* err) vec_char_pop_back(vec_char* ptr, err_t* err)
{ {
if (__null_check(ptr, err) != 0) if (__null_check(ptr, err) != 0)
{ {
@@ -194,19 +154,19 @@ _vec_char_pop_back(_VecCharInternal* ptr, err_t* err)
return; return;
} }
if (ptr->_internal_size == 0) if (ptr->size == 0)
{ {
__origin_override(err, "POP_BACK"); __origin_override(err, "POP_BACK");
err->flags |= ERR_SIZE_ZERO; err->flags |= ERR_SIZE_ZERO;
return; return;
} }
ptr->_internal_arr[ptr->_internal_size - 1] = 0; ptr->array[ptr->size - 1] = 0;
ptr->_internal_size--; ptr->size--;
} }
void void
_vec_char_reserve(_VecCharInternal* ptr, const size_t capacity, err_t* err) vec_char_reserve(vec_char* ptr, const size_t capacity, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -218,7 +178,7 @@ _vec_char_reserve(_VecCharInternal* ptr, const size_t capacity, err_t* err)
return; return;
} }
} }
if (ptr->_internal_max_size < capacity) if (ptr->max_size < capacity)
{ {
__origin_override(err, "RESERVE"); __origin_override(err, "RESERVE");
err->flags |= ERR_SIZE_OVERFLOW; err->flags |= ERR_SIZE_OVERFLOW;
@@ -231,24 +191,24 @@ _vec_char_reserve(_VecCharInternal* ptr, const size_t capacity, err_t* err)
return; return;
} }
char* res = realloc(ptr->_internal_arr, capacity * sizeof(char)); char* res = realloc(ptr->array, capacity * sizeof(char));
if (res == nullptr) if (res == nullptr)
{ {
__origin_override(err, "RESERVE"); __origin_override(err, "RESERVE");
err->flags |= ERR_ALLOC_FAIL; err->flags |= ERR_ALLOC_FAIL;
return; return;
} }
ptr->_internal_arr = res; ptr->array = res;
ptr->_internal_capacity = capacity; ptr->capacity = capacity;
if (ptr->_internal_size > capacity) if (ptr->size > capacity)
{ {
ptr->_internal_size = capacity; ptr->size = capacity;
} }
return; return;
} }
void void
_vec_char_shrink_to_fit(_VecCharInternal* ptr, err_t* err) vec_char_shrink_to_fit(vec_char* ptr, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -257,17 +217,17 @@ _vec_char_shrink_to_fit(_VecCharInternal* ptr, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return; return;
} }
if (ptr->_internal_size == 0) if (ptr->size == 0)
{ {
__origin_override(err, "SHRINK_TO_FIT"); __origin_override(err, "SHRINK_TO_FIT");
err->flags |= ERR_SIZE_ZERO; err->flags |= ERR_SIZE_ZERO;
return; return;
} }
_vec_char_reserve(ptr, ptr->_internal_size, err); vec_char_reserve(ptr, ptr->size, err);
} }
void void
_vec_char_swap(_VecCharInternal* ptr_a, _VecCharInternal* ptr_b, err_t* err) vec_char_swap(vec_char* ptr_a, vec_char* ptr_b, err_t* err)
{ {
err_t status_1 = ERR_T_INIT, status_2 = ERR_T_INIT; err_t status_1 = ERR_T_INIT, status_2 = ERR_T_INIT;
if ((__null_check(ptr_a, &status_1) & ERR_VEC_NULL) != 0 || if ((__null_check(ptr_a, &status_1) & ERR_VEC_NULL) != 0 ||
@@ -277,14 +237,14 @@ _vec_char_swap(_VecCharInternal* ptr_a, _VecCharInternal* ptr_b, err_t* err)
err->flags |= ERR_VEC_NULL; err->flags |= ERR_VEC_NULL;
return; return;
} }
_VecCharInternal self = *ptr_a; vec_char self = *ptr_a;
*ptr_a = *ptr_b; *ptr_a = *ptr_b;
*ptr_b = self; *ptr_b = self;
return; return;
} }
const char* const char*
_vec_char_data(const _VecCharInternal* ptr, err_t* err) vec_char_data(const vec_char* ptr, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -293,11 +253,11 @@ _vec_char_data(const _VecCharInternal* ptr, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return nullptr; return nullptr;
} }
return &ptr->_internal_arr[0]; return &ptr->array[0];
} }
size_t size_t
_vec_char_size(const _VecCharInternal* ptr, err_t* err) vec_char_size(const vec_char* ptr, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -306,11 +266,11 @@ _vec_char_size(const _VecCharInternal* ptr, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return 0; return 0;
} }
return ptr->_internal_size; return ptr->size;
} }
size_t size_t
_vec_char_capacity(const _VecCharInternal* ptr, err_t* err) vec_char_capacity(const vec_char* ptr, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -319,11 +279,11 @@ _vec_char_capacity(const _VecCharInternal* ptr, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return 0; return 0;
} }
return ptr->_internal_capacity; return ptr->capacity;
} }
size_t size_t
_vec_char_max_size(const _VecCharInternal* ptr, err_t* err) vec_char_max_size(const vec_char* ptr, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -332,11 +292,11 @@ _vec_char_max_size(const _VecCharInternal* ptr, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return 0; return 0;
} }
return ptr->_internal_max_size; return ptr->max_size;
} }
void void
_vec_char_delete(_VecCharInternal* ptr, err_t* err) vec_char_delete(vec_char* ptr, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -345,17 +305,17 @@ _vec_char_delete(_VecCharInternal* ptr, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return; return;
} }
if (ptr->_internal_arr != nullptr) if (ptr->array != nullptr)
{ {
free(ptr->_internal_arr); free(ptr->array);
ptr->_internal_arr = nullptr; ptr->array = nullptr;
} }
ptr->_internal_size = 0; ptr->size = 0;
ptr->_internal_capacity = 0; ptr->capacity = 0;
} }
void void
_vec_char_clear(_VecCharInternal* ptr, err_t* err) vec_char_clear(vec_char* ptr, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -364,15 +324,15 @@ _vec_char_clear(_VecCharInternal* ptr, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return; return;
} }
if (ptr->_internal_size > 0) if (ptr->size > 0)
{ {
memset(ptr->_internal_arr, 0, ptr->_internal_size); memset(ptr->array, 0, ptr->size);
ptr->_internal_size = 0; ptr->size = 0;
} }
} }
char* char*
_vec_char_at(const _VecCharInternal* ptr, const size_t idx, err_t* err) vec_char_at(const vec_char* ptr, const size_t idx, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -381,17 +341,17 @@ _vec_char_at(const _VecCharInternal* ptr, const size_t idx, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return nullptr; return nullptr;
} }
if (idx >= ptr->_internal_size) if (idx >= ptr->size)
{ {
__origin_override(err, "AT"); __origin_override(err, "AT");
err->flags |= ERR_OUT_OF_BOUNDS; err->flags |= ERR_OUT_OF_BOUNDS;
return nullptr; return nullptr;
} }
return &ptr->_internal_arr[idx]; return &ptr->array[idx];
} }
size_t size_t
_vec_char_begin(const _VecCharInternal* ptr, err_t* err) vec_char_begin(const vec_char* ptr, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -404,7 +364,7 @@ _vec_char_begin(const _VecCharInternal* ptr, err_t* err)
} }
size_t size_t
_vec_char_end(const _VecCharInternal* ptr, err_t* err) vec_char_end(const vec_char* ptr, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -413,17 +373,17 @@ _vec_char_end(const _VecCharInternal* ptr, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return status.flags; return status.flags;
} }
if (ptr->_internal_size == 0) if (ptr->size == 0)
{ {
__origin_override(err, "END"); __origin_override(err, "END");
err->flags |= ERR_SIZE_ZERO; err->flags |= ERR_SIZE_ZERO;
return status.flags; return status.flags;
} }
return (size_t)(ptr->_internal_size - 1); return (size_t)(ptr->size - 1);
} }
char char
_vec_char_front(const _VecCharInternal* ptr, err_t* err) vec_char_front(const vec_char* ptr, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -432,16 +392,16 @@ _vec_char_front(const _VecCharInternal* ptr, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return -1; return -1;
} }
if (_vec_char_at(ptr, 0, err) == nullptr) if (vec_char_at(ptr, 0, err) == nullptr)
{ {
err->flags |= ERR_OUT_OF_BOUNDS; err->flags |= ERR_OUT_OF_BOUNDS;
return 0; return 0;
} }
return *_vec_char_at(ptr, 0, err); return *vec_char_at(ptr, 0, err);
} }
char char
_vec_char_back(const _VecCharInternal* ptr, err_t* err) vec_char_back(const vec_char* ptr, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -450,16 +410,16 @@ _vec_char_back(const _VecCharInternal* ptr, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return -1; return -1;
} }
if (_vec_char_at(ptr, 0, err) == nullptr) if (vec_char_at(ptr, 0, err) == nullptr)
{ {
err->flags |= ERR_OUT_OF_BOUNDS; err->flags |= ERR_OUT_OF_BOUNDS;
return 0; return 0;
} }
return *_vec_char_at(ptr, ptr->_internal_size - 1, err); return *vec_char_at(ptr, ptr->size - 1, err);
} }
size_t size_t
_vec_char_empty(const _VecCharInternal* ptr, err_t* err) vec_char_empty(const vec_char* ptr, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -468,15 +428,15 @@ _vec_char_empty(const _VecCharInternal* ptr, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return status.flags; return status.flags;
} }
if (ptr->_internal_size == 0) if (ptr->size == 0)
{ {
return ptr->_internal_size; return ptr->size;
} }
return status.flags; return status.flags;
} }
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_char_erase(_VecCharInternal* ptr, const size_t iter, err_t* err) vec_char_erase(vec_char* ptr, const size_t iter, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -485,20 +445,20 @@ _vec_char_erase(_VecCharInternal* ptr, const size_t iter, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return; return;
} }
if (iter >= ptr->_internal_size) if (iter >= ptr->size)
{ {
return; return;
} }
memmove(&ptr->_internal_arr[iter], &ptr->_internal_arr[iter + 1], memmove(&ptr->array[iter], &ptr->array[iter + 1],
(ptr->_internal_size - iter - 1) * sizeof(char)); (ptr->size - iter - 1) * sizeof(char));
ptr->_internal_arr[ptr->_internal_size - 1] = 0; ptr->array[ptr->size - 1] = 0;
ptr->_internal_size--; ptr->size--;
return; return;
} }
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_char_erase(_VecCharInternal* ptr, const size_t iter_start, vec_char_erase(vec_char* ptr, const size_t iter_start, const size_t iter_end,
const size_t iter_end, err_t* err) err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -508,23 +468,22 @@ _vec_char_erase(_VecCharInternal* ptr, const size_t iter_start,
return; return;
} }
if (ptr->_internal_size < iter_end || iter_end <= iter_start) if (ptr->size < iter_end || iter_end <= iter_start)
{ {
__origin_override(err, "ERASE"); __origin_override(err, "ERASE");
err->flags |= ERR_OUT_OF_BOUNDS; err->flags |= ERR_OUT_OF_BOUNDS;
return; return;
} }
size_t diff = iter_end - iter_start; size_t diff = iter_end - iter_start;
memmove(&ptr->_internal_arr[iter_start], &ptr->_internal_arr[iter_end], memmove(&ptr->array[iter_start], &ptr->array[iter_end],
(ptr->_internal_size - iter_end) * sizeof(char)); (ptr->size - iter_end) * sizeof(char));
memset(&ptr->_internal_arr[ptr->_internal_size - diff], 0, memset(&ptr->array[ptr->size - diff], 0, sizeof(char) * diff);
sizeof(char) * diff); ptr->size -= diff;
ptr->_internal_size -= diff;
return; return;
} }
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_char_resize(_VecCharInternal* ptr, const size_t size, err_t* err) vec_char_resize(vec_char* ptr, const size_t size, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
__null_check(ptr, &status); __null_check(ptr, &status);
@@ -535,32 +494,32 @@ _vec_char_resize(_VecCharInternal* ptr, const size_t size, err_t* err)
return; return;
} }
if (ptr->_internal_size == size) if (ptr->size == size)
{ {
__origin_override(err, "RESIZE"); __origin_override(err, "RESIZE");
err->flags |= ERR_OUT_OF_BOUNDS; err->flags |= ERR_OUT_OF_BOUNDS;
return; return;
} }
else if (size > ptr->_internal_max_size) else if (size > ptr->max_size)
{ {
__origin_override(err, "RESIZE"); __origin_override(err, "RESIZE");
err->flags |= ERR_SIZE_OVERFLOW; err->flags |= ERR_SIZE_OVERFLOW;
return; return;
} }
else if ((status.flags & ERR_BUF_NULL) != 0 || ptr->_internal_size == 0) else if ((status.flags & ERR_BUF_NULL) != 0 || ptr->size == 0)
{ {
size_t max = ptr->_internal_max_size; size_t max = ptr->max_size;
err_t verr = ERR_T_INIT; err_t verr = ERR_T_INIT;
_vec_char_reserve(ptr, size, &verr); vec_char_reserve(ptr, size, &verr);
if (verr.flags != 0) if (verr.flags != 0)
{ {
__origin_override(err, "RESIZE"); __origin_override(err, "RESIZE");
err->flags |= verr.flags; err->flags |= verr.flags;
return; return;
} }
if (ptr->_internal_capacity != size) if (ptr->capacity != size)
{ {
__origin_override(err, "RESIZE"); __origin_override(err, "RESIZE");
err->flags |= ERR_ALLOC_FAIL; err->flags |= ERR_ALLOC_FAIL;
@@ -568,57 +527,54 @@ _vec_char_resize(_VecCharInternal* ptr, const size_t size, err_t* err)
} }
for (size_t i = 0; i < size; i++) for (size_t i = 0; i < size; i++)
{ {
ptr->_internal_arr[i] = 0; ptr->array[i] = 0;
} }
ptr->_internal_max_size = max; ptr->max_size = max;
ptr->_internal_size = size; ptr->size = size;
return; return;
} }
else if (size > ptr->_internal_capacity) else if (size > ptr->capacity)
{ {
size_t tmpcp = ptr->_internal_capacity; size_t tmpcp = ptr->capacity;
size_t tmpmx = ptr->_internal_max_size; size_t tmpmx = ptr->max_size;
err_t verr = ERR_T_INIT; err_t verr = ERR_T_INIT;
while (size > tmpcp) while (size > tmpcp)
{ {
tmpcp *= 2; tmpcp *= 2;
} }
if (tmpcp > ptr->_internal_max_size) if (tmpcp > ptr->max_size)
{ {
tmpcp = size; tmpcp = size;
} }
_vec_char_reserve(ptr, tmpcp, &verr); vec_char_reserve(ptr, tmpcp, &verr);
if (verr.flags != 0) if (verr.flags != 0)
{ {
__origin_override(err, "RESIZE"); __origin_override(err, "RESIZE");
err->flags |= verr.flags; err->flags |= verr.flags;
return; return;
} }
if (ptr->_internal_capacity != tmpcp) if (ptr->capacity != tmpcp)
{ {
__origin_override(err, "RESIZE"); __origin_override(err, "RESIZE");
err->flags |= ERR_ALLOC_FAIL; err->flags |= ERR_ALLOC_FAIL;
return; return;
} }
ptr->_internal_max_size = tmpmx; ptr->max_size = tmpmx;
} }
if (size < ptr->_internal_size) if (size < ptr->size)
{ {
memset(&ptr->_internal_arr[size], 0, memset(&ptr->array[size], 0, ptr->size - size);
ptr->_internal_size - size);
} }
if (ptr->_internal_size < size && size <= ptr->_internal_capacity) if (ptr->size < size && size <= ptr->capacity)
{ {
memset(&ptr->_internal_arr[ptr->_internal_size], 0, memset(&ptr->array[ptr->size], 0, size - ptr->size);
size - ptr->_internal_size);
} }
ptr->_internal_size = size; ptr->size = size;
return; return;
} }
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_char_resize(_VecCharInternal* ptr, const size_t size, const char val, vec_char_resize(vec_char* ptr, const size_t size, const char val, err_t* err)
err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
__null_check(ptr, &status); __null_check(ptr, &status);
@@ -628,32 +584,32 @@ _vec_char_resize(_VecCharInternal* ptr, const size_t size, const char val,
err->flags |= ERR_VEC_NULL; err->flags |= ERR_VEC_NULL;
return; return;
} }
if (ptr->_internal_size == size) if (ptr->size == size)
{ {
__origin_override(err, "RESIZE"); __origin_override(err, "RESIZE");
err->flags |= ERR_OUT_OF_BOUNDS; err->flags |= ERR_OUT_OF_BOUNDS;
return; return;
} }
else if (size > ptr->_internal_max_size) else if (size > ptr->max_size)
{ {
__origin_override(err, "RESIZE"); __origin_override(err, "RESIZE");
err->flags |= ERR_SIZE_OVERFLOW; err->flags |= ERR_SIZE_OVERFLOW;
return; return;
} }
else if ((status.flags & ERR_BUF_NULL) != 0 || ptr->_internal_size == 0) else if ((status.flags & ERR_BUF_NULL) != 0 || ptr->size == 0)
{ {
size_t max = ptr->_internal_max_size; size_t max = ptr->max_size;
err_t verr = ERR_T_INIT; err_t verr = ERR_T_INIT;
_vec_char_reserve(ptr, size, &verr); vec_char_reserve(ptr, size, &verr);
if (verr.flags != 0) if (verr.flags != 0)
{ {
__origin_override(err, "RESIZE"); __origin_override(err, "RESIZE");
err->flags |= verr.flags; err->flags |= verr.flags;
return; return;
} }
if (ptr->_internal_capacity != size) if (ptr->capacity != size)
{ {
__origin_override(err, "RESIZE"); __origin_override(err, "RESIZE");
err->flags |= ERR_ALLOC_FAIL; err->flags |= ERR_ALLOC_FAIL;
@@ -661,50 +617,48 @@ _vec_char_resize(_VecCharInternal* ptr, const size_t size, const char val,
} }
for (size_t i = 0; i < size; i++) for (size_t i = 0; i < size; i++)
{ {
ptr->_internal_arr[i] = val; ptr->array[i] = val;
} }
ptr->_internal_max_size = max; ptr->max_size = max;
ptr->_internal_size = size; ptr->size = size;
return; return;
} }
else if (size > ptr->_internal_capacity) else if (size > ptr->capacity)
{ {
size_t tmpcp = ptr->_internal_capacity; size_t tmpcp = ptr->capacity;
size_t tmpmx = ptr->_internal_max_size; size_t tmpmx = ptr->max_size;
err_t verr = ERR_T_INIT; err_t verr = ERR_T_INIT;
while (size > tmpcp) while (size > tmpcp)
{ {
tmpcp *= 2; tmpcp *= 2;
} }
if (tmpcp > ptr->_internal_max_size) if (tmpcp > ptr->max_size)
{ {
tmpcp = size; tmpcp = size;
} }
_vec_char_reserve(ptr, tmpcp, &verr); vec_char_reserve(ptr, tmpcp, &verr);
if (verr.flags != 0) if (verr.flags != 0)
{ {
__origin_override(err, "RESIZE"); __origin_override(err, "RESIZE");
err->flags |= verr.flags; err->flags |= verr.flags;
return; return;
} }
ptr->_internal_max_size = tmpmx; ptr->max_size = tmpmx;
} }
if (size < ptr->_internal_size) if (size < ptr->size)
{ {
memset(&ptr->_internal_arr[size], val, memset(&ptr->array[size], val, ptr->size - size);
ptr->_internal_size - size);
} }
if (ptr->_internal_size < size && size <= ptr->_internal_capacity) if (ptr->size < size && size <= ptr->capacity)
{ {
memset(&ptr->_internal_arr[ptr->_internal_size], val, memset(&ptr->array[ptr->size], val, size - ptr->size);
size - ptr->_internal_size);
} }
ptr->_internal_size = size; ptr->size = size;
return; return;
} }
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_char_assign(_VecCharInternal* ptr, const _VecCharInternal* iterator, vec_char_assign(vec_char* ptr, const vec_char* iterator,
const size_t iter_start, const size_t iter_end, err_t* err) const size_t iter_start, const size_t iter_end, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
@@ -715,27 +669,27 @@ _vec_char_assign(_VecCharInternal* ptr, const _VecCharInternal* iterator,
err->flags |= status.flags; err->flags |= status.flags;
return; return;
} }
if (ptr->_internal_arr == iterator->_internal_arr) if (ptr->array == iterator->array)
{ {
__origin_override(err, "ASSIGN"); __origin_override(err, "ASSIGN");
err->flags |= ERR_DOUBLE_BUF; err->flags |= ERR_DOUBLE_BUF;
return; return;
} }
if (iterator->_internal_size < iter_end || iter_end <= iter_start) if (iterator->size < iter_end || iter_end <= iter_start)
{ {
__origin_override(err, "ASSIGN"); __origin_override(err, "ASSIGN");
err->flags |= ERR_OUT_OF_BOUNDS; err->flags |= ERR_OUT_OF_BOUNDS;
return; return;
} }
_vec_char_erase(ptr, _vec_char_begin(ptr, &status), vec_char_erase(ptr, _vec_char_begin(ptr, &status),
_vec_char_end(ptr, &status) + 1, &status); vec_char_end(ptr, &status) + 1, &status);
if (status.flags != 0) if (status.flags != 0)
{ {
__origin_override(err, "ASSIGN"); __origin_override(err, "ASSIGN");
err->flags |= status.flags; err->flags |= status.flags;
return; return;
} }
_vec_char_reserve(ptr, (iter_end - iter_start), &status); vec_char_reserve(ptr, (iter_end - iter_start), &status);
if (status.flags != 0) if (status.flags != 0)
{ {
__origin_override(err, "ASSIGN"); __origin_override(err, "ASSIGN");
@@ -744,13 +698,13 @@ _vec_char_assign(_VecCharInternal* ptr, const _VecCharInternal* iterator,
} }
for (size_t i = iter_start; i < iter_end; i++) for (size_t i = iter_start; i < iter_end; i++)
{ {
char* res = _vec_char_at(iterator, i, &status); char* res = vec_char_at(iterator, i, &status);
if (res == nullptr) if (res == nullptr)
{ {
err->flags |= ERR_OUT_OF_BOUNDS; err->flags |= ERR_OUT_OF_BOUNDS;
return; return;
} }
_vec_char_push_back(ptr, *res, &status); vec_char_push_back(ptr, *res, &status);
if (status.flags != 0) if (status.flags != 0)
{ {
__origin_override(err, "ASSIGN"); __origin_override(err, "ASSIGN");
@@ -762,8 +716,7 @@ _vec_char_assign(_VecCharInternal* ptr, const _VecCharInternal* iterator,
} }
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_char_assign(_VecCharInternal* ptr, const size_t amount, const char val, vec_char_assign(vec_char* ptr, const size_t amount, const char val, err_t* err)
err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -778,15 +731,15 @@ _vec_char_assign(_VecCharInternal* ptr, const size_t amount, const char val,
err->flags |= ERR_SIZE_ZERO; err->flags |= ERR_SIZE_ZERO;
return; return;
} }
_vec_char_erase(ptr, _vec_char_begin(ptr, &status), vec_char_erase(ptr, _vec_char_begin(ptr, &status),
_vec_char_end(ptr, &status) + 1, &status); vec_char_end(ptr, &status) + 1, &status);
if (status.flags != 0) if (status.flags != 0)
{ {
__origin_override(err, "ASSIGN"); __origin_override(err, "ASSIGN");
err->flags |= status.flags; err->flags |= status.flags;
return; return;
} }
_vec_char_reserve(ptr, amount, &status); vec_char_reserve(ptr, amount, &status);
if (status.flags != 0) if (status.flags != 0)
{ {
__origin_override(err, "ASSIGN"); __origin_override(err, "ASSIGN");
@@ -795,7 +748,7 @@ _vec_char_assign(_VecCharInternal* ptr, const size_t amount, const char val,
} }
for (size_t i = 0; i < amount; i++) for (size_t i = 0; i < amount; i++)
{ {
_vec_char_push_back(ptr, val, &status); vec_char_push_back(ptr, val, &status);
if (status.flags != 0) if (status.flags != 0)
{ {
__origin_override(err, "ASSIGN"); __origin_override(err, "ASSIGN");
@@ -807,8 +760,7 @@ _vec_char_assign(_VecCharInternal* ptr, const size_t amount, const char val,
} }
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_char_insert(_VecCharInternal* ptr, const size_t iter, const char val, vec_char_insert(vec_char* ptr, const size_t iter, const char val, err_t* err)
err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
__null_check(ptr, &status); __null_check(ptr, &status);
@@ -827,42 +779,42 @@ _vec_char_insert(_VecCharInternal* ptr, const size_t iter, const char val,
err->flags |= ERR_BUF_NULL; err->flags |= ERR_BUF_NULL;
return; return;
} }
ptr->_internal_arr = res; ptr->array = res;
ptr->_internal_capacity = 1; ptr->capacity = 1;
ptr->_internal_arr[0] = val; ptr->array[0] = val;
ptr->_internal_size = 1; ptr->size = 1;
return; return;
} }
if (ptr->_internal_max_size < ptr->_internal_size + 1) if (ptr->max_size < ptr->size + 1)
{ {
__origin_override(err, "INSERT"); __origin_override(err, "INSERT");
err->flags |= ERR_SIZE_OVERFLOW; err->flags |= ERR_SIZE_OVERFLOW;
return; return;
} }
if (iter > ptr->_internal_size) if (iter > ptr->size)
{ {
__origin_override(err, "INSERT"); __origin_override(err, "INSERT");
err->flags |= ERR_OUT_OF_BOUNDS; err->flags |= ERR_OUT_OF_BOUNDS;
return; return;
} }
_vec_char_push_back(ptr, 0, &status); vec_char_push_back(ptr, 0, &status);
if (status.flags != 0) if (status.flags != 0)
{ {
__origin_override(err, "INSERT"); __origin_override(err, "INSERT");
err->flags |= status.flags; err->flags |= status.flags;
return; return;
} }
for (size_t i = ptr->_internal_size - 1; i > iter; i--) for (size_t i = ptr->size - 1; i > iter; i--)
{ {
ptr->_internal_arr[i] = ptr->_internal_arr[i - 1]; ptr->array[i] = ptr->array[i - 1];
} }
ptr->_internal_arr[iter] = val; ptr->array[iter] = val;
return; return;
} }
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_char_insert(_VecCharInternal* ptr, const size_t iter, const size_t amount, vec_char_insert(vec_char* ptr, const size_t iter, const size_t amount,
const char val, err_t* err) const char val, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
@@ -873,7 +825,7 @@ _vec_char_insert(_VecCharInternal* ptr, const size_t iter, const size_t amount,
err->flags |= status.flags; err->flags |= status.flags;
return; return;
} }
if (iter > ptr->_internal_size) if (iter > ptr->size)
{ {
__origin_override(err, "INSERT"); __origin_override(err, "INSERT");
err->flags |= ERR_OUT_OF_BOUNDS; err->flags |= ERR_OUT_OF_BOUNDS;
@@ -887,7 +839,7 @@ _vec_char_insert(_VecCharInternal* ptr, const size_t iter, const size_t amount,
} }
for (size_t i = iter; i < iter + amount; i++) for (size_t i = iter; i < iter + amount; i++)
{ {
_vec_char_insert(ptr, i, val, &status); vec_char_insert(ptr, i, val, &status);
if (status.flags != 0) if (status.flags != 0)
{ {
__origin_override(err, "INSERT"); __origin_override(err, "INSERT");
@@ -899,9 +851,8 @@ _vec_char_insert(_VecCharInternal* ptr, const size_t iter, const size_t amount,
} }
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_char_insert(_VecCharInternal* ptr, const _VecCharInternal* iterator, vec_char_insert(vec_char* ptr, const vec_char* iterator, const size_t iter,
const size_t iter, const size_t iter_start, const size_t iter_start, const size_t iter_end, err_t* err)
const size_t iter_end, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
__null_check(ptr, &status); __null_check(ptr, &status);
@@ -912,14 +863,14 @@ _vec_char_insert(_VecCharInternal* ptr, const _VecCharInternal* iterator,
err->flags |= status.flags; err->flags |= status.flags;
return; return;
} }
if (iter_end <= iter_start || iter_end > iterator->_internal_size || if (iter_end <= iter_start || iter_end > iterator->size ||
iter > ptr->_internal_size) iter > ptr->size)
{ {
__origin_override(err, "INSERT"); __origin_override(err, "INSERT");
err->flags |= ERR_OUT_OF_BOUNDS; err->flags |= ERR_OUT_OF_BOUNDS;
return; return;
} }
if (ptr->_internal_arr == iterator->_internal_arr) if (ptr->array == iterator->array)
{ {
__origin_override(err, "INSERT"); __origin_override(err, "INSERT");
err->flags |= ERR_DOUBLE_BUF; err->flags |= ERR_DOUBLE_BUF;
@@ -927,8 +878,8 @@ _vec_char_insert(_VecCharInternal* ptr, const _VecCharInternal* iterator,
} }
for (size_t i = iter_start; i < iter_end; i++) for (size_t i = iter_start; i < iter_end; i++)
{ {
_vec_char_insert(ptr, iter + (i - iter_start), vec_char_insert(ptr, iter + (i - iter_start),
iterator->_internal_arr[i], &status); iterator->array[i], &status);
if (status.flags != 0) if (status.flags != 0)
{ {
__origin_override(err, "INSERT"); __origin_override(err, "INSERT");
src/float.c
+177 -224
View File
@@ -5,7 +5,7 @@
#include <string.h> #include <string.h>
__attribute__((overloadable)) size_t __attribute__((overloadable)) size_t
__null_check(const _VecCharInternal* ptr, err_t* status) __null_check(const vec_float* ptr, err_t* status)
{ {
if (status == nullptr) if (status == nullptr)
{ {
@@ -16,7 +16,7 @@ __null_check(const _VecCharInternal* ptr, err_t* status)
status->flags |= ERR_VEC_NULL; status->flags |= ERR_VEC_NULL;
return ERR_VEC_NULL; return ERR_VEC_NULL;
} }
if (ptr->_internal_arr == nullptr) if (ptr->array == nullptr)
{ {
status->flags |= ERR_BUF_NULL; status->flags |= ERR_BUF_NULL;
} }
@@ -24,62 +24,24 @@ __null_check(const _VecCharInternal* ptr, err_t* status)
return status->flags; 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 void
_vec_char_print_vec(const _VecCharInternal* ptr, err_t* err) vec_float_print_vec(const vec_float* ptr, err_t* err)
{ {
if (__null_check(ptr, err) != 0) if (__null_check(ptr, err) != 0)
{ {
return; return;
} }
for (size_t i = 0; i < ptr->_internal_size; i++) for (size_t i = 0; i < ptr->size; i++)
{ {
printf("%c ", ptr->_internal_arr[i]); printf("%f ", ptr->array[i]);
} }
printf("\n"); printf("\n");
} }
_VecCharInternal vec_float
_vec_char_cpy(const char* src, const size_t src_size, err_t* err) vec_float_cpy(const float* src, const size_t src_size, err_t* err)
{ {
_VecCharInternal self = VEC_INIT; vec_float self = VEC_INIT;
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
size_t null = __null_check(src, err); size_t null = __null_check(src, err);
@@ -100,30 +62,30 @@ _vec_char_cpy(const char* src, const size_t src_size, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return self; return self;
} }
if (src_size > self._internal_max_size) if (src_size > self.max_size)
{ {
__origin_override(err, "CPY"); __origin_override(err, "CPY");
err->flags |= ERR_SIZE_OVERFLOW; err->flags |= ERR_SIZE_OVERFLOW;
return self; return self;
} }
self._internal_arr = malloc(src_size * sizeof(char)); self.array = malloc(src_size * sizeof(float));
if (self._internal_arr == nullptr) if (self.array == nullptr)
{ {
__origin_override(err, "CPY"); __origin_override(err, "CPY");
err->flags |= ERR_ALLOC_FAIL; err->flags |= ERR_ALLOC_FAIL;
return self; return self;
} }
memcpy(self._internal_arr, src, src_size * sizeof(char)); memcpy(self.array, src, src_size * sizeof(float));
self._internal_size = src_size; self.size = src_size;
self._internal_capacity = src_size; self.capacity = src_size;
return self; return self;
} }
void void
_vec_char_push_back(_VecCharInternal* ptr, const char val, err_t* err) vec_float_push_back(vec_float* ptr, const float val, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
char* res; float* res;
__null_check(ptr, &status); __null_check(ptr, &status);
if ((status.flags & ERR_VEC_NULL) != 0) if ((status.flags & ERR_VEC_NULL) != 0)
{ {
@@ -132,7 +94,7 @@ _vec_char_push_back(_VecCharInternal* ptr, const char val, err_t* err)
return; return;
} }
if (ptr->_internal_size + 1 > ptr->_internal_max_size) if (ptr->size + 1 > ptr->max_size)
{ {
__origin_override(err, "PUSH_BACK"); __origin_override(err, "PUSH_BACK");
err->flags |= ERR_SIZE_OVERFLOW; err->flags |= ERR_SIZE_OVERFLOW;
@@ -141,50 +103,49 @@ _vec_char_push_back(_VecCharInternal* ptr, const char val, err_t* err)
if ((status.flags & ERR_BUF_NULL) != 0) if ((status.flags & ERR_BUF_NULL) != 0)
{ {
res = malloc(1 * sizeof(char)); res = malloc(1 * sizeof(float));
if (res == nullptr) if (res == nullptr)
{ {
__origin_override(err, "PUSH_BACK"); __origin_override(err, "PUSH_BACK");
err->flags |= ERR_ALLOC_FAIL; err->flags |= ERR_ALLOC_FAIL;
return; return;
} }
ptr->_internal_arr = res; ptr->array = res;
ptr->_internal_capacity = 1; ptr->capacity = 1;
ptr->_internal_size = 0; ptr->size = 0;
} }
else if (ptr->_internal_size + 1 > ptr->_internal_capacity) else if (ptr->size + 1 > ptr->capacity)
{ {
size_t dst_cap = size_t dst_cap = (ptr->capacity / 2) + ptr->capacity;
(ptr->_internal_capacity / 2) + ptr->_internal_capacity; if (dst_cap == ptr->capacity)
if (dst_cap == ptr->_internal_capacity)
{ {
dst_cap++; dst_cap++;
} }
if (dst_cap > ptr->_internal_max_size) if (dst_cap > ptr->max_size)
{ {
dst_cap = ptr->_internal_max_size; dst_cap = ptr->max_size;
DEBUG( DEBUG(
"Capacity cannot be grown any further due " "Capacity cannot be grown any further due "
"to hitting max size"); "to hitting max size");
} }
res = realloc(ptr->_internal_arr, dst_cap * sizeof(char)); res = realloc(ptr->array, dst_cap * sizeof(float));
if (res == nullptr) if (res == nullptr)
{ {
__origin_override(err, "PUSH_BACK"); __origin_override(err, "PUSH_BACK");
err->flags |= ERR_SIZE_OVERFLOW; err->flags |= ERR_SIZE_OVERFLOW;
return; return;
} }
ptr->_internal_arr = res; ptr->array = res;
ptr->_internal_capacity = dst_cap; ptr->capacity = dst_cap;
} }
ptr->_internal_arr[ptr->_internal_size] = val; ptr->array[ptr->size] = val;
ptr->_internal_size++; ptr->size++;
return; return;
} }
void void
_vec_char_pop_back(_VecCharInternal* ptr, err_t* err) vec_float_pop_back(vec_float* ptr, err_t* err)
{ {
if (__null_check(ptr, err) != 0) if (__null_check(ptr, err) != 0)
{ {
@@ -192,19 +153,19 @@ _vec_char_pop_back(_VecCharInternal* ptr, err_t* err)
return; return;
} }
if (ptr->_internal_size == 0) if (ptr->size == 0)
{ {
__origin_override(err, "POP_BACK"); __origin_override(err, "POP_BACK");
err->flags |= ERR_SIZE_ZERO; err->flags |= ERR_SIZE_ZERO;
return; return;
} }
ptr->_internal_arr[ptr->_internal_size - 1] = 0; ptr->array[ptr->size - 1] = 0;
ptr->_internal_size--; ptr->size--;
} }
void void
_vec_char_reserve(_VecCharInternal* ptr, const size_t capacity, err_t* err) vec_float_reserve(vec_float* ptr, const size_t capacity, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -216,7 +177,7 @@ _vec_char_reserve(_VecCharInternal* ptr, const size_t capacity, err_t* err)
return; return;
} }
} }
if (ptr->_internal_max_size < capacity) if (ptr->max_size < capacity)
{ {
__origin_override(err, "RESERVE"); __origin_override(err, "RESERVE");
err->flags |= ERR_SIZE_OVERFLOW; err->flags |= ERR_SIZE_OVERFLOW;
@@ -229,24 +190,24 @@ _vec_char_reserve(_VecCharInternal* ptr, const size_t capacity, err_t* err)
return; return;
} }
char* res = realloc(ptr->_internal_arr, capacity * sizeof(char)); float* res = realloc(ptr->array, capacity * sizeof(float));
if (res == nullptr) if (res == nullptr)
{ {
__origin_override(err, "RESERVE"); __origin_override(err, "RESERVE");
err->flags |= ERR_ALLOC_FAIL; err->flags |= ERR_ALLOC_FAIL;
return; return;
} }
ptr->_internal_arr = res; ptr->array = res;
ptr->_internal_capacity = capacity; ptr->capacity = capacity;
if (ptr->_internal_size > capacity) if (ptr->size > capacity)
{ {
ptr->_internal_size = capacity; ptr->size = capacity;
} }
return; return;
} }
void void
_vec_char_shrink_to_fit(_VecCharInternal* ptr, err_t* err) vec_float_shrink_to_fit(vec_float* ptr, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -255,17 +216,17 @@ _vec_char_shrink_to_fit(_VecCharInternal* ptr, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return; return;
} }
if (ptr->_internal_size == 0) if (ptr->size == 0)
{ {
__origin_override(err, "SHRINK_TO_FIT"); __origin_override(err, "SHRINK_TO_FIT");
err->flags |= ERR_SIZE_ZERO; err->flags |= ERR_SIZE_ZERO;
return; return;
} }
_vec_char_reserve(ptr, ptr->_internal_size, err); vec_float_reserve(ptr, ptr->size, err);
} }
void void
_vec_char_swap(_VecCharInternal* ptr_a, _VecCharInternal* ptr_b, err_t* err) vec_float_swap(vec_float* ptr_a, vec_float* ptr_b, err_t* err)
{ {
err_t status_1 = ERR_T_INIT, status_2 = ERR_T_INIT; err_t status_1 = ERR_T_INIT, status_2 = ERR_T_INIT;
if ((__null_check(ptr_a, &status_1) & ERR_VEC_NULL) != 0 || if ((__null_check(ptr_a, &status_1) & ERR_VEC_NULL) != 0 ||
@@ -275,14 +236,14 @@ _vec_char_swap(_VecCharInternal* ptr_a, _VecCharInternal* ptr_b, err_t* err)
err->flags |= ERR_VEC_NULL; err->flags |= ERR_VEC_NULL;
return; return;
} }
_VecCharInternal self = *ptr_a; vec_float self = *ptr_a;
*ptr_a = *ptr_b; *ptr_a = *ptr_b;
*ptr_b = self; *ptr_b = self;
return; return;
} }
const char* const float*
_vec_char_data(const _VecCharInternal* ptr, err_t* err) vec_float_data(const vec_float* ptr, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -291,11 +252,11 @@ _vec_char_data(const _VecCharInternal* ptr, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return nullptr; return nullptr;
} }
return &ptr->_internal_arr[0]; return &ptr->array[0];
} }
size_t size_t
_vec_char_size(const _VecCharInternal* ptr, err_t* err) vec_float_size(const vec_float* ptr, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -304,11 +265,11 @@ _vec_char_size(const _VecCharInternal* ptr, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return 0; return 0;
} }
return ptr->_internal_size; return ptr->size;
} }
size_t size_t
_vec_char_capacity(const _VecCharInternal* ptr, err_t* err) vec_float_capacity(const vec_float* ptr, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -317,11 +278,11 @@ _vec_char_capacity(const _VecCharInternal* ptr, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return 0; return 0;
} }
return ptr->_internal_capacity; return ptr->capacity;
} }
size_t size_t
_vec_char_max_size(const _VecCharInternal* ptr, err_t* err) vec_float_max_size(const vec_float* ptr, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -330,11 +291,11 @@ _vec_char_max_size(const _VecCharInternal* ptr, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return 0; return 0;
} }
return ptr->_internal_max_size; return ptr->max_size;
} }
void void
_vec_char_delete(_VecCharInternal* ptr, err_t* err) vec_float_delete(vec_float* ptr, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -343,17 +304,17 @@ _vec_char_delete(_VecCharInternal* ptr, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return; return;
} }
if (ptr->_internal_arr != nullptr) if (ptr->array != nullptr)
{ {
free(ptr->_internal_arr); free(ptr->array);
ptr->_internal_arr = nullptr; ptr->array = nullptr;
} }
ptr->_internal_size = 0; ptr->size = 0;
ptr->_internal_capacity = 0; ptr->capacity = 0;
} }
void void
_vec_char_clear(_VecCharInternal* ptr, err_t* err) vec_float_clear(vec_float* ptr, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -362,15 +323,15 @@ _vec_char_clear(_VecCharInternal* ptr, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return; return;
} }
if (ptr->_internal_size > 0) if (ptr->size > 0)
{ {
memset(ptr->_internal_arr, 0, ptr->_internal_size); memset(ptr->array, 0, ptr->size);
ptr->_internal_size = 0; ptr->size = 0;
} }
} }
char* float*
_vec_char_at(const _VecCharInternal* ptr, const size_t idx, err_t* err) vec_float_at(const vec_float* ptr, const size_t idx, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -379,17 +340,17 @@ _vec_char_at(const _VecCharInternal* ptr, const size_t idx, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return nullptr; return nullptr;
} }
if (idx >= ptr->_internal_size) if (idx >= ptr->size)
{ {
__origin_override(err, "AT"); __origin_override(err, "AT");
err->flags |= ERR_OUT_OF_BOUNDS; err->flags |= ERR_OUT_OF_BOUNDS;
return nullptr; return nullptr;
} }
return &ptr->_internal_arr[idx]; return &ptr->array[idx];
} }
size_t size_t
_vec_char_begin(const _VecCharInternal* ptr, err_t* err) vec_float_begin(const vec_float* ptr, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -402,7 +363,7 @@ _vec_char_begin(const _VecCharInternal* ptr, err_t* err)
} }
size_t size_t
_vec_char_end(const _VecCharInternal* ptr, err_t* err) vec_float_end(const vec_float* ptr, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -411,17 +372,17 @@ _vec_char_end(const _VecCharInternal* ptr, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return status.flags; return status.flags;
} }
if (ptr->_internal_size == 0) if (ptr->size == 0)
{ {
__origin_override(err, "END"); __origin_override(err, "END");
err->flags |= ERR_SIZE_ZERO; err->flags |= ERR_SIZE_ZERO;
return status.flags; return status.flags;
} }
return (size_t)(ptr->_internal_size - 1); return (size_t)(ptr->size - 1);
} }
char float
_vec_char_front(const _VecCharInternal* ptr, err_t* err) vec_float_front(const vec_float* ptr, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -430,16 +391,16 @@ _vec_char_front(const _VecCharInternal* ptr, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return -1; return -1;
} }
if (_vec_char_at(ptr, 0, err) == nullptr) if (vec_float_at(ptr, 0, err) == nullptr)
{ {
err->flags |= ERR_OUT_OF_BOUNDS; err->flags |= ERR_OUT_OF_BOUNDS;
return 0; return 0;
} }
return *_vec_char_at(ptr, 0, err); return *vec_float_at(ptr, 0, err);
} }
char float
_vec_char_back(const _VecCharInternal* ptr, err_t* err) vec_float_back(const vec_float* ptr, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -448,16 +409,16 @@ _vec_char_back(const _VecCharInternal* ptr, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return -1; return -1;
} }
if (_vec_char_at(ptr, 0, err) == nullptr) if (vec_float_at(ptr, 0, err) == nullptr)
{ {
err->flags |= ERR_OUT_OF_BOUNDS; err->flags |= ERR_OUT_OF_BOUNDS;
return 0; return 0;
} }
return *_vec_char_at(ptr, ptr->_internal_size - 1, err); return *vec_float_at(ptr, ptr->size - 1, err);
} }
size_t size_t
_vec_char_empty(const _VecCharInternal* ptr, err_t* err) vec_float_empty(const vec_float* ptr, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -466,15 +427,15 @@ _vec_char_empty(const _VecCharInternal* ptr, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return status.flags; return status.flags;
} }
if (ptr->_internal_size == 0) if (ptr->size == 0)
{ {
return ptr->_internal_size; return ptr->size;
} }
return status.flags; return status.flags;
} }
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_char_erase(_VecCharInternal* ptr, const size_t iter, err_t* err) vec_float_erase(vec_float* ptr, const size_t iter, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -483,20 +444,20 @@ _vec_char_erase(_VecCharInternal* ptr, const size_t iter, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return; return;
} }
if (iter >= ptr->_internal_size) if (iter >= ptr->size)
{ {
return; return;
} }
memmove(&ptr->_internal_arr[iter], &ptr->_internal_arr[iter + 1], memmove(&ptr->array[iter], &ptr->array[iter + 1],
(ptr->_internal_size - iter - 1) * sizeof(char)); (ptr->size - iter - 1) * sizeof(float));
ptr->_internal_arr[ptr->_internal_size - 1] = 0; ptr->array[ptr->size - 1] = 0;
ptr->_internal_size--; ptr->size--;
return; return;
} }
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_char_erase(_VecCharInternal* ptr, const size_t iter_start, vec_float_erase(vec_float* ptr, const size_t iter_start, const size_t iter_end,
const size_t iter_end, err_t* err) err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -506,23 +467,22 @@ _vec_char_erase(_VecCharInternal* ptr, const size_t iter_start,
return; return;
} }
if (ptr->_internal_size < iter_end || iter_end <= iter_start) if (ptr->size < iter_end || iter_end <= iter_start)
{ {
__origin_override(err, "ERASE"); __origin_override(err, "ERASE");
err->flags |= ERR_OUT_OF_BOUNDS; err->flags |= ERR_OUT_OF_BOUNDS;
return; return;
} }
size_t diff = iter_end - iter_start; size_t diff = iter_end - iter_start;
memmove(&ptr->_internal_arr[iter_start], &ptr->_internal_arr[iter_end], memmove(&ptr->array[iter_start], &ptr->array[iter_end],
(ptr->_internal_size - iter_end) * sizeof(char)); (ptr->size - iter_end) * sizeof(float));
memset(&ptr->_internal_arr[ptr->_internal_size - diff], 0, memset(&ptr->array[ptr->size - diff], 0, sizeof(float) * diff);
sizeof(char) * diff); ptr->size -= diff;
ptr->_internal_size -= diff;
return; return;
} }
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_char_resize(_VecCharInternal* ptr, const size_t size, err_t* err) vec_float_resize(vec_float* ptr, const size_t size, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
__null_check(ptr, &status); __null_check(ptr, &status);
@@ -533,32 +493,32 @@ _vec_char_resize(_VecCharInternal* ptr, const size_t size, err_t* err)
return; return;
} }
if (ptr->_internal_size == size) if (ptr->size == size)
{ {
__origin_override(err, "RESIZE"); __origin_override(err, "RESIZE");
err->flags |= ERR_OUT_OF_BOUNDS; err->flags |= ERR_OUT_OF_BOUNDS;
return; return;
} }
else if (size > ptr->_internal_max_size) else if (size > ptr->max_size)
{ {
__origin_override(err, "RESIZE"); __origin_override(err, "RESIZE");
err->flags |= ERR_SIZE_OVERFLOW; err->flags |= ERR_SIZE_OVERFLOW;
return; return;
} }
else if ((status.flags & ERR_BUF_NULL) != 0 || ptr->_internal_size == 0) else if ((status.flags & ERR_BUF_NULL) != 0 || ptr->size == 0)
{ {
size_t max = ptr->_internal_max_size; size_t max = ptr->max_size;
err_t verr = ERR_T_INIT; err_t verr = ERR_T_INIT;
_vec_char_reserve(ptr, size, &verr); vec_float_reserve(ptr, size, &verr);
if (verr.flags != 0) if (verr.flags != 0)
{ {
__origin_override(err, "RESIZE"); __origin_override(err, "RESIZE");
err->flags |= verr.flags; err->flags |= verr.flags;
return; return;
} }
if (ptr->_internal_capacity != size) if (ptr->capacity != size)
{ {
__origin_override(err, "RESIZE"); __origin_override(err, "RESIZE");
err->flags |= ERR_ALLOC_FAIL; err->flags |= ERR_ALLOC_FAIL;
@@ -566,57 +526,54 @@ _vec_char_resize(_VecCharInternal* ptr, const size_t size, err_t* err)
} }
for (size_t i = 0; i < size; i++) for (size_t i = 0; i < size; i++)
{ {
ptr->_internal_arr[i] = 0; ptr->array[i] = 0;
} }
ptr->_internal_max_size = max; ptr->max_size = max;
ptr->_internal_size = size; ptr->size = size;
return; return;
} }
else if (size > ptr->_internal_capacity) else if (size > ptr->capacity)
{ {
size_t tmpcp = ptr->_internal_capacity; size_t tmpcp = ptr->capacity;
size_t tmpmx = ptr->_internal_max_size; size_t tmpmx = ptr->max_size;
err_t verr = ERR_T_INIT; err_t verr = ERR_T_INIT;
while (size > tmpcp) while (size > tmpcp)
{ {
tmpcp *= 2; tmpcp *= 2;
} }
if (tmpcp > ptr->_internal_max_size) if (tmpcp > ptr->max_size)
{ {
tmpcp = size; tmpcp = size;
} }
_vec_char_reserve(ptr, tmpcp, &verr); vec_float_reserve(ptr, tmpcp, &verr);
if (verr.flags != 0) if (verr.flags != 0)
{ {
__origin_override(err, "RESIZE"); __origin_override(err, "RESIZE");
err->flags |= verr.flags; err->flags |= verr.flags;
return; return;
} }
if (ptr->_internal_capacity != tmpcp) if (ptr->capacity != tmpcp)
{ {
__origin_override(err, "RESIZE"); __origin_override(err, "RESIZE");
err->flags |= ERR_ALLOC_FAIL; err->flags |= ERR_ALLOC_FAIL;
return; return;
} }
ptr->_internal_max_size = tmpmx; ptr->max_size = tmpmx;
} }
if (size < ptr->_internal_size) if (size < ptr->size)
{ {
memset(&ptr->_internal_arr[size], 0, memset(&ptr->array[size], 0, ptr->size - size);
ptr->_internal_size - size);
} }
if (ptr->_internal_size < size && size <= ptr->_internal_capacity) if (ptr->size < size && size <= ptr->capacity)
{ {
memset(&ptr->_internal_arr[ptr->_internal_size], 0, memset(&ptr->array[ptr->size], 0, size - ptr->size);
size - ptr->_internal_size);
} }
ptr->_internal_size = size; ptr->size = size;
return; return;
} }
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_char_resize(_VecCharInternal* ptr, const size_t size, const char val, vec_float_resize(vec_float* ptr, const size_t size, const float val, err_t* err)
err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
__null_check(ptr, &status); __null_check(ptr, &status);
@@ -626,32 +583,32 @@ _vec_char_resize(_VecCharInternal* ptr, const size_t size, const char val,
err->flags |= ERR_VEC_NULL; err->flags |= ERR_VEC_NULL;
return; return;
} }
if (ptr->_internal_size == size) if (ptr->size == size)
{ {
__origin_override(err, "RESIZE"); __origin_override(err, "RESIZE");
err->flags |= ERR_OUT_OF_BOUNDS; err->flags |= ERR_OUT_OF_BOUNDS;
return; return;
} }
else if (size > ptr->_internal_max_size) else if (size > ptr->max_size)
{ {
__origin_override(err, "RESIZE"); __origin_override(err, "RESIZE");
err->flags |= ERR_SIZE_OVERFLOW; err->flags |= ERR_SIZE_OVERFLOW;
return; return;
} }
else if ((status.flags & ERR_BUF_NULL) != 0 || ptr->_internal_size == 0) else if ((status.flags & ERR_BUF_NULL) != 0 || ptr->size == 0)
{ {
size_t max = ptr->_internal_max_size; size_t max = ptr->max_size;
err_t verr = ERR_T_INIT; err_t verr = ERR_T_INIT;
_vec_char_reserve(ptr, size, &verr); vec_float_reserve(ptr, size, &verr);
if (verr.flags != 0) if (verr.flags != 0)
{ {
__origin_override(err, "RESIZE"); __origin_override(err, "RESIZE");
err->flags |= verr.flags; err->flags |= verr.flags;
return; return;
} }
if (ptr->_internal_capacity != size) if (ptr->capacity != size)
{ {
__origin_override(err, "RESIZE"); __origin_override(err, "RESIZE");
err->flags |= ERR_ALLOC_FAIL; err->flags |= ERR_ALLOC_FAIL;
@@ -659,50 +616,48 @@ _vec_char_resize(_VecCharInternal* ptr, const size_t size, const char val,
} }
for (size_t i = 0; i < size; i++) for (size_t i = 0; i < size; i++)
{ {
ptr->_internal_arr[i] = val; ptr->array[i] = val;
} }
ptr->_internal_max_size = max; ptr->max_size = max;
ptr->_internal_size = size; ptr->size = size;
return; return;
} }
else if (size > ptr->_internal_capacity) else if (size > ptr->capacity)
{ {
size_t tmpcp = ptr->_internal_capacity; size_t tmpcp = ptr->capacity;
size_t tmpmx = ptr->_internal_max_size; size_t tmpmx = ptr->max_size;
err_t verr = ERR_T_INIT; err_t verr = ERR_T_INIT;
while (size > tmpcp) while (size > tmpcp)
{ {
tmpcp *= 2; tmpcp *= 2;
} }
if (tmpcp > ptr->_internal_max_size) if (tmpcp > ptr->max_size)
{ {
tmpcp = size; tmpcp = size;
} }
_vec_char_reserve(ptr, tmpcp, &verr); vec_float_reserve(ptr, tmpcp, &verr);
if (verr.flags != 0) if (verr.flags != 0)
{ {
__origin_override(err, "RESIZE"); __origin_override(err, "RESIZE");
err->flags |= verr.flags; err->flags |= verr.flags;
return; return;
} }
ptr->_internal_max_size = tmpmx; ptr->max_size = tmpmx;
} }
if (size < ptr->_internal_size) if (size < ptr->size)
{ {
memset(&ptr->_internal_arr[size], val, memset(&ptr->array[size], val, ptr->size - size);
ptr->_internal_size - size);
} }
if (ptr->_internal_size < size && size <= ptr->_internal_capacity) if (ptr->size < size && size <= ptr->capacity)
{ {
memset(&ptr->_internal_arr[ptr->_internal_size], val, memset(&ptr->array[ptr->size], val, size - ptr->size);
size - ptr->_internal_size);
} }
ptr->_internal_size = size; ptr->size = size;
return; return;
} }
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_char_assign(_VecCharInternal* ptr, const _VecCharInternal* iterator, vec_float_assign(vec_float* ptr, const vec_float* iterator,
const size_t iter_start, const size_t iter_end, err_t* err) const size_t iter_start, const size_t iter_end, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
@@ -713,27 +668,27 @@ _vec_char_assign(_VecCharInternal* ptr, const _VecCharInternal* iterator,
err->flags |= status.flags; err->flags |= status.flags;
return; return;
} }
if (ptr->_internal_arr == iterator->_internal_arr) if (ptr->array == iterator->array)
{ {
__origin_override(err, "ASSIGN"); __origin_override(err, "ASSIGN");
err->flags |= ERR_DOUBLE_BUF; err->flags |= ERR_DOUBLE_BUF;
return; return;
} }
if (iterator->_internal_size < iter_end || iter_end <= iter_start) if (iterator->size < iter_end || iter_end <= iter_start)
{ {
__origin_override(err, "ASSIGN"); __origin_override(err, "ASSIGN");
err->flags |= ERR_OUT_OF_BOUNDS; err->flags |= ERR_OUT_OF_BOUNDS;
return; return;
} }
_vec_char_erase(ptr, _vec_char_begin(ptr, &status), vec_float_erase(ptr, vec_float_begin(ptr, &status),
_vec_char_end(ptr, &status) + 1, &status); vec_float_end(ptr, &status) + 1, &status);
if (status.flags != 0) if (status.flags != 0)
{ {
__origin_override(err, "ASSIGN"); __origin_override(err, "ASSIGN");
err->flags |= status.flags; err->flags |= status.flags;
return; return;
} }
_vec_char_reserve(ptr, (iter_end - iter_start), &status); vec_float_reserve(ptr, (iter_end - iter_start), &status);
if (status.flags != 0) if (status.flags != 0)
{ {
__origin_override(err, "ASSIGN"); __origin_override(err, "ASSIGN");
@@ -742,13 +697,13 @@ _vec_char_assign(_VecCharInternal* ptr, const _VecCharInternal* iterator,
} }
for (size_t i = iter_start; i < iter_end; i++) for (size_t i = iter_start; i < iter_end; i++)
{ {
char* res = _vec_char_at(iterator, i, &status); float* res = vec_float_at(iterator, i, &status);
if (res == nullptr) if (res == nullptr)
{ {
err->flags |= ERR_OUT_OF_BOUNDS; err->flags |= ERR_OUT_OF_BOUNDS;
return; return;
} }
_vec_char_push_back(ptr, *res, &status); vec_float_push_back(ptr, *res, &status);
if (status.flags != 0) if (status.flags != 0)
{ {
__origin_override(err, "ASSIGN"); __origin_override(err, "ASSIGN");
@@ -760,7 +715,7 @@ _vec_char_assign(_VecCharInternal* ptr, const _VecCharInternal* iterator,
} }
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_char_assign(_VecCharInternal* ptr, const size_t amount, const char val, vec_float_assign(vec_float* ptr, const size_t amount, const float val,
err_t* err) err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
@@ -776,15 +731,15 @@ _vec_char_assign(_VecCharInternal* ptr, const size_t amount, const char val,
err->flags |= ERR_SIZE_ZERO; err->flags |= ERR_SIZE_ZERO;
return; return;
} }
_vec_char_erase(ptr, _vec_char_begin(ptr, &status), vec_float_erase(ptr, vec_float_begin(ptr, &status),
_vec_char_end(ptr, &status) + 1, &status); vec_float_end(ptr, &status) + 1, &status);
if (status.flags != 0) if (status.flags != 0)
{ {
__origin_override(err, "ASSIGN"); __origin_override(err, "ASSIGN");
err->flags |= status.flags; err->flags |= status.flags;
return; return;
} }
_vec_char_reserve(ptr, amount, &status); vec_float_reserve(ptr, amount, &status);
if (status.flags != 0) if (status.flags != 0)
{ {
__origin_override(err, "ASSIGN"); __origin_override(err, "ASSIGN");
@@ -793,7 +748,7 @@ _vec_char_assign(_VecCharInternal* ptr, const size_t amount, const char val,
} }
for (size_t i = 0; i < amount; i++) for (size_t i = 0; i < amount; i++)
{ {
_vec_char_push_back(ptr, val, &status); vec_float_push_back(ptr, val, &status);
if (status.flags != 0) if (status.flags != 0)
{ {
__origin_override(err, "ASSIGN"); __origin_override(err, "ASSIGN");
@@ -805,8 +760,7 @@ _vec_char_assign(_VecCharInternal* ptr, const size_t amount, const char val,
} }
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_char_insert(_VecCharInternal* ptr, const size_t iter, const char val, vec_float_insert(vec_float* ptr, const size_t iter, const float val, err_t* err)
err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
__null_check(ptr, &status); __null_check(ptr, &status);
@@ -818,50 +772,50 @@ _vec_char_insert(_VecCharInternal* ptr, const size_t iter, const char val,
} }
if ((status.flags & ERR_BUF_NULL) != 0) if ((status.flags & ERR_BUF_NULL) != 0)
{ {
char* res = malloc(1 * sizeof(char)); float* res = malloc(1 * sizeof(float));
if (res == nullptr) if (res == nullptr)
{ {
__origin_override(err, "INSERT"); __origin_override(err, "INSERT");
err->flags |= ERR_BUF_NULL; err->flags |= ERR_BUF_NULL;
return; return;
} }
ptr->_internal_arr = res; ptr->array = res;
ptr->_internal_capacity = 1; ptr->capacity = 1;
ptr->_internal_arr[0] = val; ptr->array[0] = val;
ptr->_internal_size = 1; ptr->size = 1;
return; return;
} }
if (ptr->_internal_max_size < ptr->_internal_size + 1) if (ptr->max_size < ptr->size + 1)
{ {
__origin_override(err, "INSERT"); __origin_override(err, "INSERT");
err->flags |= ERR_SIZE_OVERFLOW; err->flags |= ERR_SIZE_OVERFLOW;
return; return;
} }
if (iter > ptr->_internal_size) if (iter > ptr->size)
{ {
__origin_override(err, "INSERT"); __origin_override(err, "INSERT");
err->flags |= ERR_OUT_OF_BOUNDS; err->flags |= ERR_OUT_OF_BOUNDS;
return; return;
} }
_vec_char_push_back(ptr, 0, &status); vec_float_push_back(ptr, 0, &status);
if (status.flags != 0) if (status.flags != 0)
{ {
__origin_override(err, "INSERT"); __origin_override(err, "INSERT");
err->flags |= status.flags; err->flags |= status.flags;
return; return;
} }
for (size_t i = ptr->_internal_size - 1; i > iter; i--) for (size_t i = ptr->size - 1; i > iter; i--)
{ {
ptr->_internal_arr[i] = ptr->_internal_arr[i - 1]; ptr->array[i] = ptr->array[i - 1];
} }
ptr->_internal_arr[iter] = val; ptr->array[iter] = val;
return; return;
} }
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_char_insert(_VecCharInternal* ptr, const size_t iter, const size_t amount, vec_float_insert(vec_float* ptr, const size_t iter, const size_t amount,
const char val, err_t* err) const float val, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
__null_check(ptr, &status); __null_check(ptr, &status);
@@ -871,7 +825,7 @@ _vec_char_insert(_VecCharInternal* ptr, const size_t iter, const size_t amount,
err->flags |= status.flags; err->flags |= status.flags;
return; return;
} }
if (iter > ptr->_internal_size) if (iter > ptr->size)
{ {
__origin_override(err, "INSERT"); __origin_override(err, "INSERT");
err->flags |= ERR_OUT_OF_BOUNDS; err->flags |= ERR_OUT_OF_BOUNDS;
@@ -885,7 +839,7 @@ _vec_char_insert(_VecCharInternal* ptr, const size_t iter, const size_t amount,
} }
for (size_t i = iter; i < iter + amount; i++) for (size_t i = iter; i < iter + amount; i++)
{ {
_vec_char_insert(ptr, i, val, &status); vec_float_insert(ptr, i, val, &status);
if (status.flags != 0) if (status.flags != 0)
{ {
__origin_override(err, "INSERT"); __origin_override(err, "INSERT");
@@ -897,9 +851,8 @@ _vec_char_insert(_VecCharInternal* ptr, const size_t iter, const size_t amount,
} }
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_char_insert(_VecCharInternal* ptr, const _VecCharInternal* iterator, vec_float_insert(vec_float* ptr, const vec_float* iterator, const size_t iter,
const size_t iter, const size_t iter_start, const size_t iter_start, const size_t iter_end, err_t* err)
const size_t iter_end, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
__null_check(ptr, &status); __null_check(ptr, &status);
@@ -910,14 +863,14 @@ _vec_char_insert(_VecCharInternal* ptr, const _VecCharInternal* iterator,
err->flags |= status.flags; err->flags |= status.flags;
return; return;
} }
if (iter_end <= iter_start || iter_end > iterator->_internal_size || if (iter_end <= iter_start || iter_end > iterator->size ||
iter > ptr->_internal_size) iter > ptr->size)
{ {
__origin_override(err, "INSERT"); __origin_override(err, "INSERT");
err->flags |= ERR_OUT_OF_BOUNDS; err->flags |= ERR_OUT_OF_BOUNDS;
return; return;
} }
if (ptr->_internal_arr == iterator->_internal_arr) if (ptr->array == iterator->array)
{ {
__origin_override(err, "INSERT"); __origin_override(err, "INSERT");
err->flags |= ERR_DOUBLE_BUF; err->flags |= ERR_DOUBLE_BUF;
@@ -925,8 +878,8 @@ _vec_char_insert(_VecCharInternal* ptr, const _VecCharInternal* iterator,
} }
for (size_t i = iter_start; i < iter_end; i++) for (size_t i = iter_start; i < iter_end; i++)
{ {
_vec_char_insert(ptr, iter + (i - iter_start), vec_float_insert(ptr, iter + (i - iter_start),
iterator->_internal_arr[i], &status); iterator->array[i], &status);
if (status.flags != 0) if (status.flags != 0)
{ {
__origin_override(err, "INSERT"); __origin_override(err, "INSERT");
src/int.c
+173 -219
View File
@@ -5,7 +5,7 @@
#include <string.h> #include <string.h>
__attribute__((overloadable)) size_t __attribute__((overloadable)) size_t
__null_check(const _VecIntInternal* ptr, err_t* status) __null_check(const vec_int* ptr, err_t* status)
{ {
if (status == nullptr) if (status == nullptr)
{ {
@@ -16,7 +16,7 @@ __null_check(const _VecIntInternal* ptr, err_t* status)
status->flags |= ERR_VEC_NULL; status->flags |= ERR_VEC_NULL;
return ERR_VEC_NULL; return ERR_VEC_NULL;
} }
if (ptr->_internal_arr == nullptr) if (ptr->array == nullptr)
{ {
status->flags |= ERR_BUF_NULL; status->flags |= ERR_BUF_NULL;
} }
@@ -24,62 +24,24 @@ __null_check(const _VecIntInternal* ptr, err_t* status)
return status->flags; 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 void
_vec_int_print_vec(const _VecIntInternal* ptr, err_t* err) vec_int_print_vec(const vec_int* ptr, err_t* err)
{ {
if (__null_check(ptr, err) != 0) if (__null_check(ptr, err) != 0)
{ {
return; return;
} }
for (size_t i = 0; i < ptr->_internal_size; i++) for (size_t i = 0; i < ptr->size; i++)
{ {
printf("%d ", ptr->_internal_arr[i]); printf("%d ", ptr->array[i]);
} }
printf("\n"); printf("\n");
} }
_VecIntInternal vec_int
_vec_int_cpy(const int* src, const size_t src_size, err_t* err) vec_int_cpy(const int* src, const size_t src_size, err_t* err)
{ {
_VecIntInternal self = VEC_INIT; vec_int self = VEC_INIT;
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
size_t null = __null_check(src, err); size_t null = __null_check(src, err);
@@ -100,27 +62,27 @@ _vec_int_cpy(const int* src, const size_t src_size, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return self; return self;
} }
if (src_size > self._internal_max_size) if (src_size > self.max_size)
{ {
__origin_override(err, "CPY"); __origin_override(err, "CPY");
err->flags |= ERR_SIZE_OVERFLOW; err->flags |= ERR_SIZE_OVERFLOW;
return self; return self;
} }
self._internal_arr = malloc(src_size * sizeof(int)); self.array = malloc(src_size * sizeof(int));
if (self._internal_arr == nullptr) if (self.array == nullptr)
{ {
__origin_override(err, "CPY"); __origin_override(err, "CPY");
err->flags |= ERR_ALLOC_FAIL; err->flags |= ERR_ALLOC_FAIL;
return self; return self;
} }
memcpy(self._internal_arr, src, src_size * sizeof(int)); memcpy(self.array, src, src_size * sizeof(int));
self._internal_size = src_size; self.size = src_size;
self._internal_capacity = src_size; self.capacity = src_size;
return self; return self;
} }
void void
_vec_int_push_back(_VecIntInternal* ptr, const int val, err_t* err) vec_int_push_back(vec_int* ptr, const int val, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
int* res; int* res;
@@ -132,7 +94,7 @@ _vec_int_push_back(_VecIntInternal* ptr, const int val, err_t* err)
return; return;
} }
if (ptr->_internal_size + 1 > ptr->_internal_max_size) if (ptr->size + 1 > ptr->max_size)
{ {
__origin_override(err, "PUSH_BACK"); __origin_override(err, "PUSH_BACK");
err->flags |= ERR_SIZE_OVERFLOW; err->flags |= ERR_SIZE_OVERFLOW;
@@ -148,43 +110,42 @@ _vec_int_push_back(_VecIntInternal* ptr, const int val, err_t* err)
err->flags |= ERR_ALLOC_FAIL; err->flags |= ERR_ALLOC_FAIL;
return; return;
} }
ptr->_internal_arr = res; ptr->array = res;
ptr->_internal_capacity = 1; ptr->capacity = 1;
ptr->_internal_size = 0; ptr->size = 0;
} }
else if (ptr->_internal_size + 1 > ptr->_internal_capacity) else if (ptr->size + 1 > ptr->capacity)
{ {
size_t dst_cap = size_t dst_cap = (ptr->capacity / 2) + ptr->capacity;
(ptr->_internal_capacity / 2) + ptr->_internal_capacity; if (dst_cap == ptr->capacity)
if (dst_cap == ptr->_internal_capacity)
{ {
dst_cap++; dst_cap++;
} }
if (dst_cap > ptr->_internal_max_size) if (dst_cap > ptr->max_size)
{ {
dst_cap = ptr->_internal_max_size; dst_cap = ptr->max_size;
DEBUG( DEBUG(
"Capacity cannot be grown any further due " "Capacity cannot be grown any further due "
"to hitting max size"); "to hitting max size");
} }
res = realloc(ptr->_internal_arr, dst_cap * sizeof(int)); res = realloc(ptr->array, dst_cap * sizeof(int));
if (res == nullptr) if (res == nullptr)
{ {
__origin_override(err, "PUSH_BACK"); __origin_override(err, "PUSH_BACK");
err->flags |= ERR_SIZE_OVERFLOW; err->flags |= ERR_SIZE_OVERFLOW;
return; return;
} }
ptr->_internal_arr = res; ptr->array = res;
ptr->_internal_capacity = dst_cap; ptr->capacity = dst_cap;
} }
ptr->_internal_arr[ptr->_internal_size] = val; ptr->array[ptr->size] = val;
ptr->_internal_size++; ptr->size++;
return; return;
} }
void void
_vec_int_pop_back(_VecIntInternal* ptr, err_t* err) vec_int_pop_back(vec_int* ptr, err_t* err)
{ {
if (__null_check(ptr, err) != 0) if (__null_check(ptr, err) != 0)
{ {
@@ -192,19 +153,19 @@ _vec_int_pop_back(_VecIntInternal* ptr, err_t* err)
return; return;
} }
if (ptr->_internal_size == 0) if (ptr->size == 0)
{ {
__origin_override(err, "POP_BACK"); __origin_override(err, "POP_BACK");
err->flags |= ERR_SIZE_ZERO; err->flags |= ERR_SIZE_ZERO;
return; return;
} }
ptr->_internal_arr[ptr->_internal_size - 1] = 0; ptr->array[ptr->size - 1] = 0;
ptr->_internal_size--; ptr->size--;
} }
void void
_vec_int_reserve(_VecIntInternal* ptr, const size_t capacity, err_t* err) vec_int_reserve(vec_int* ptr, const size_t capacity, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -216,7 +177,7 @@ _vec_int_reserve(_VecIntInternal* ptr, const size_t capacity, err_t* err)
return; return;
} }
} }
if (ptr->_internal_max_size < capacity) if (ptr->max_size < capacity)
{ {
__origin_override(err, "RESERVE"); __origin_override(err, "RESERVE");
err->flags |= ERR_SIZE_OVERFLOW; err->flags |= ERR_SIZE_OVERFLOW;
@@ -229,24 +190,24 @@ _vec_int_reserve(_VecIntInternal* ptr, const size_t capacity, err_t* err)
return; return;
} }
int* res = realloc(ptr->_internal_arr, capacity * sizeof(int)); int* res = realloc(ptr->array, capacity * sizeof(int));
if (res == nullptr) if (res == nullptr)
{ {
__origin_override(err, "RESERVE"); __origin_override(err, "RESERVE");
err->flags |= ERR_ALLOC_FAIL; err->flags |= ERR_ALLOC_FAIL;
return; return;
} }
ptr->_internal_arr = res; ptr->array = res;
ptr->_internal_capacity = capacity; ptr->capacity = capacity;
if (ptr->_internal_size > capacity) if (ptr->size > capacity)
{ {
ptr->_internal_size = capacity; ptr->size = capacity;
} }
return; return;
} }
void void
_vec_int_shrink_to_fit(_VecIntInternal* ptr, err_t* err) vec_int_shrink_to_fit(vec_int* ptr, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -255,17 +216,17 @@ _vec_int_shrink_to_fit(_VecIntInternal* ptr, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return; return;
} }
if (ptr->_internal_size == 0) if (ptr->size == 0)
{ {
__origin_override(err, "SHRINK_TO_FIT"); __origin_override(err, "SHRINK_TO_FIT");
err->flags |= ERR_SIZE_ZERO; err->flags |= ERR_SIZE_ZERO;
return; return;
} }
_vec_int_reserve(ptr, ptr->_internal_size, err); vec_int_reserve(ptr, ptr->size, err);
} }
void void
_vec_int_swap(_VecIntInternal* ptr_a, _VecIntInternal* ptr_b, err_t* err) vec_int_swap(vec_int* ptr_a, vec_int* ptr_b, err_t* err)
{ {
err_t status_1 = ERR_T_INIT, status_2 = ERR_T_INIT; err_t status_1 = ERR_T_INIT, status_2 = ERR_T_INIT;
if ((__null_check(ptr_a, &status_1) & ERR_VEC_NULL) != 0 || if ((__null_check(ptr_a, &status_1) & ERR_VEC_NULL) != 0 ||
@@ -275,14 +236,14 @@ _vec_int_swap(_VecIntInternal* ptr_a, _VecIntInternal* ptr_b, err_t* err)
err->flags |= ERR_VEC_NULL; err->flags |= ERR_VEC_NULL;
return; return;
} }
_VecIntInternal self = *ptr_a; vec_int self = *ptr_a;
*ptr_a = *ptr_b; *ptr_a = *ptr_b;
*ptr_b = self; *ptr_b = self;
return; return;
} }
const int* const int*
_vec_int_data(const _VecIntInternal* ptr, err_t* err) vec_int_data(const vec_int* ptr, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -291,11 +252,11 @@ _vec_int_data(const _VecIntInternal* ptr, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return nullptr; return nullptr;
} }
return &ptr->_internal_arr[0]; return &ptr->array[0];
} }
size_t size_t
_vec_int_size(const _VecIntInternal* ptr, err_t* err) vec_int_size(const vec_int* ptr, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -304,11 +265,11 @@ _vec_int_size(const _VecIntInternal* ptr, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return 0; return 0;
} }
return ptr->_internal_size; return ptr->size;
} }
size_t size_t
_vec_int_capacity(const _VecIntInternal* ptr, err_t* err) vec_int_capacity(const vec_int* ptr, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -317,11 +278,11 @@ _vec_int_capacity(const _VecIntInternal* ptr, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return 0; return 0;
} }
return ptr->_internal_capacity; return ptr->capacity;
} }
size_t size_t
_vec_int_max_size(const _VecIntInternal* ptr, err_t* err) vec_int_max_size(const vec_int* ptr, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -330,11 +291,11 @@ _vec_int_max_size(const _VecIntInternal* ptr, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return 0; return 0;
} }
return ptr->_internal_max_size; return ptr->max_size;
} }
void void
_vec_int_delete(_VecIntInternal* ptr, err_t* err) vec_int_delete(vec_int* ptr, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -343,17 +304,17 @@ _vec_int_delete(_VecIntInternal* ptr, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return; return;
} }
if (ptr->_internal_arr != nullptr) if (ptr->array != nullptr)
{ {
free(ptr->_internal_arr); free(ptr->array);
ptr->_internal_arr = nullptr; ptr->array = nullptr;
} }
ptr->_internal_size = 0; ptr->size = 0;
ptr->_internal_capacity = 0; ptr->capacity = 0;
} }
void void
_vec_int_clear(_VecIntInternal* ptr, err_t* err) vec_int_clear(vec_int* ptr, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -362,16 +323,15 @@ _vec_int_clear(_VecIntInternal* ptr, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return; return;
} }
if (ptr->_internal_size > 0) if (ptr->size > 0)
{ {
memset(ptr->_internal_arr, 0, memset(ptr->array, 0, ptr->size * sizeof(int));
ptr->_internal_size * sizeof(int)); ptr->size = 0;
ptr->_internal_size = 0;
} }
} }
int* int*
_vec_int_at(const _VecIntInternal* ptr, const size_t idx, err_t* err) vec_int_at(const vec_int* ptr, const size_t idx, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -380,17 +340,17 @@ _vec_int_at(const _VecIntInternal* ptr, const size_t idx, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return nullptr; return nullptr;
} }
if (idx >= ptr->_internal_size) if (idx >= ptr->size)
{ {
__origin_override(err, "AT"); __origin_override(err, "AT");
err->flags |= ERR_OUT_OF_BOUNDS; err->flags |= ERR_OUT_OF_BOUNDS;
return nullptr; return nullptr;
} }
return &ptr->_internal_arr[idx]; return &ptr->array[idx];
} }
size_t size_t
_vec_int_begin(const _VecIntInternal* ptr, err_t* err) vec_int_begin(const vec_int* ptr, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -403,7 +363,7 @@ _vec_int_begin(const _VecIntInternal* ptr, err_t* err)
} }
size_t size_t
_vec_int_end(const _VecIntInternal* ptr, err_t* err) vec_int_end(const vec_int* ptr, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -412,17 +372,17 @@ _vec_int_end(const _VecIntInternal* ptr, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return status.flags; return status.flags;
} }
if (ptr->_internal_size == 0) if (ptr->size == 0)
{ {
__origin_override(err, "END"); __origin_override(err, "END");
err->flags |= ERR_SIZE_ZERO; err->flags |= ERR_SIZE_ZERO;
return status.flags; return status.flags;
} }
return (size_t)(ptr->_internal_size - 1); return (size_t)(ptr->size - 1);
} }
int int
_vec_int_front(const _VecIntInternal* ptr, err_t* err) vec_int_front(const vec_int* ptr, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -431,16 +391,16 @@ _vec_int_front(const _VecIntInternal* ptr, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return -1; return -1;
} }
if (_vec_int_at(ptr, 0, err) == nullptr) if (vec_int_at(ptr, 0, err) == nullptr)
{ {
err->flags |= ERR_OUT_OF_BOUNDS; err->flags |= ERR_OUT_OF_BOUNDS;
return 0; return 0;
} }
return *_vec_int_at(ptr, 0, err); return *vec_int_at(ptr, 0, err);
} }
int int
_vec_int_back(const _VecIntInternal* ptr, err_t* err) vec_int_back(const vec_int* ptr, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -449,16 +409,16 @@ _vec_int_back(const _VecIntInternal* ptr, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return -1; return -1;
} }
if (_vec_int_at(ptr, 0, err) == nullptr) if (vec_int_at(ptr, 0, err) == nullptr)
{ {
err->flags |= ERR_OUT_OF_BOUNDS; err->flags |= ERR_OUT_OF_BOUNDS;
return 0; return 0;
} }
return *_vec_int_at(ptr, ptr->_internal_size - 1, err); return *vec_int_at(ptr, ptr->size - 1, err);
} }
size_t size_t
_vec_int_empty(const _VecIntInternal* ptr, err_t* err) vec_int_empty(const vec_int* ptr, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -467,15 +427,15 @@ _vec_int_empty(const _VecIntInternal* ptr, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return status.flags; return status.flags;
} }
if (ptr->_internal_size == 0) if (ptr->size == 0)
{ {
return ptr->_internal_size; return ptr->size;
} }
return status.flags; return status.flags;
} }
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_int_erase(_VecIntInternal* ptr, const size_t iter, err_t* err) vec_int_erase(vec_int* ptr, const size_t iter, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -484,20 +444,20 @@ _vec_int_erase(_VecIntInternal* ptr, const size_t iter, err_t* err)
err->flags |= status.flags; err->flags |= status.flags;
return; return;
} }
if (iter >= ptr->_internal_size) if (iter >= ptr->size)
{ {
return; return;
} }
memmove(&ptr->_internal_arr[iter], &ptr->_internal_arr[iter + 1], memmove(&ptr->array[iter], &ptr->array[iter + 1],
(ptr->_internal_size - iter - 1) * sizeof(int)); (ptr->size - iter - 1) * sizeof(int));
ptr->_internal_arr[ptr->_internal_size - 1] = 0; ptr->array[ptr->size - 1] = 0;
ptr->_internal_size--; ptr->size--;
return; return;
} }
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_int_erase(_VecIntInternal* ptr, const size_t iter_start, vec_int_erase(vec_int* ptr, const size_t iter_start, const size_t iter_end,
const size_t iter_end, err_t* err) err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -507,23 +467,22 @@ _vec_int_erase(_VecIntInternal* ptr, const size_t iter_start,
return; return;
} }
if (ptr->_internal_size < iter_end || iter_end <= iter_start) if (ptr->size < iter_end || iter_end <= iter_start)
{ {
__origin_override(err, "ERASE"); __origin_override(err, "ERASE");
err->flags |= ERR_OUT_OF_BOUNDS; err->flags |= ERR_OUT_OF_BOUNDS;
return; return;
} }
size_t diff = iter_end - iter_start; size_t diff = iter_end - iter_start;
memmove(&ptr->_internal_arr[iter_start], &ptr->_internal_arr[iter_end], memmove(&ptr->array[iter_start], &ptr->array[iter_end],
(ptr->_internal_size - iter_end) * sizeof(int)); (ptr->size - iter_end) * sizeof(int));
memset(&ptr->_internal_arr[ptr->_internal_size - diff], 0, memset(&ptr->array[ptr->size - diff], 0, sizeof(int) * diff);
sizeof(int) * diff); ptr->size -= diff;
ptr->_internal_size -= diff;
return; return;
} }
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_int_resize(_VecIntInternal* ptr, const size_t size, err_t* err) vec_int_resize(vec_int* ptr, const size_t size, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
__null_check(ptr, &status); __null_check(ptr, &status);
@@ -534,87 +493,85 @@ _vec_int_resize(_VecIntInternal* ptr, const size_t size, err_t* err)
return; return;
} }
if (ptr->_internal_size == size) if (ptr->size == size)
{ {
__origin_override(err, "RESIZE"); __origin_override(err, "RESIZE");
err->flags |= ERR_OUT_OF_BOUNDS; err->flags |= ERR_OUT_OF_BOUNDS;
return; return;
} }
else if (size > ptr->_internal_max_size) else if (size > ptr->max_size)
{ {
__origin_override(err, "RESIZE"); __origin_override(err, "RESIZE");
err->flags |= ERR_SIZE_OVERFLOW; err->flags |= ERR_SIZE_OVERFLOW;
return; return;
} }
else if ((status.flags & ERR_BUF_NULL) != 0 || ptr->_internal_size == 0) else if ((status.flags & ERR_BUF_NULL) != 0 || ptr->size == 0)
{ {
size_t max = ptr->_internal_max_size; size_t max = ptr->max_size;
err_t verr = ERR_T_INIT; err_t verr = ERR_T_INIT;
_vec_int_reserve(ptr, size, &verr); vec_int_reserve(ptr, size, &verr);
if (verr.flags != 0) if (verr.flags != 0)
{ {
__origin_override(err, "RESIZE"); __origin_override(err, "RESIZE");
err->flags |= verr.flags; err->flags |= verr.flags;
return; return;
} }
if (ptr->_internal_capacity != size) if (ptr->capacity != size)
{ {
__origin_override(err, "RESIZE"); __origin_override(err, "RESIZE");
err->flags |= ERR_ALLOC_FAIL; err->flags |= ERR_ALLOC_FAIL;
return; return;
} }
memset(ptr->_internal_arr, 0, size * sizeof(int)); memset(ptr->array, 0, size * sizeof(int));
ptr->_internal_max_size = max; ptr->max_size = max;
ptr->_internal_size = size; ptr->size = size;
return; return;
} }
else if (size > ptr->_internal_capacity) else if (size > ptr->capacity)
{ {
size_t tmpcp = ptr->_internal_capacity; size_t tmpcp = ptr->capacity;
size_t tmpmx = ptr->_internal_max_size; size_t tmpmx = ptr->max_size;
err_t verr = ERR_T_INIT; err_t verr = ERR_T_INIT;
while (size > tmpcp) while (size > tmpcp)
{ {
tmpcp *= 2; tmpcp *= 2;
} }
if (tmpcp > ptr->_internal_max_size) if (tmpcp > ptr->max_size)
{ {
tmpcp = size; tmpcp = size;
} }
_vec_int_reserve(ptr, tmpcp, &verr); vec_int_reserve(ptr, tmpcp, &verr);
if (verr.flags != 0) if (verr.flags != 0)
{ {
__origin_override(err, "RESIZE"); __origin_override(err, "RESIZE");
err->flags |= verr.flags; err->flags |= verr.flags;
return; return;
} }
if (ptr->_internal_capacity != tmpcp) if (ptr->capacity != tmpcp)
{ {
__origin_override(err, "RESIZE"); __origin_override(err, "RESIZE");
err->flags |= ERR_ALLOC_FAIL; err->flags |= ERR_ALLOC_FAIL;
return; return;
} }
ptr->_internal_max_size = tmpmx; ptr->max_size = tmpmx;
} }
if (size < ptr->_internal_size) if (size < ptr->size)
{ {
memset(&ptr->_internal_arr[size], 0, memset(&ptr->array[size], 0, (ptr->size - size) * sizeof(int));
(ptr->_internal_size - size) * sizeof(int));
} }
if (ptr->_internal_size < size && size <= ptr->_internal_capacity) if (ptr->size < size && size <= ptr->capacity)
{ {
memset(&ptr->_internal_arr[ptr->_internal_size], 0, memset(&ptr->array[ptr->size], 0,
(size - ptr->_internal_size) * sizeof(int)); (size - ptr->size) * sizeof(int));
} }
ptr->_internal_size = size; ptr->size = size;
return; return;
} }
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_int_resize(_VecIntInternal* ptr, const size_t size, const int val, vec_int_resize(vec_int* ptr, const size_t size, const int val, err_t* err)
err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
__null_check(ptr, &status); __null_check(ptr, &status);
@@ -624,32 +581,32 @@ _vec_int_resize(_VecIntInternal* ptr, const size_t size, const int val,
err->flags |= ERR_VEC_NULL; err->flags |= ERR_VEC_NULL;
return; return;
} }
if (ptr->_internal_size == size) if (ptr->size == size)
{ {
__origin_override(err, "RESIZE"); __origin_override(err, "RESIZE");
err->flags |= ERR_OUT_OF_BOUNDS; err->flags |= ERR_OUT_OF_BOUNDS;
return; return;
} }
else if (size > ptr->_internal_max_size) else if (size > ptr->max_size)
{ {
__origin_override(err, "RESIZE"); __origin_override(err, "RESIZE");
err->flags |= ERR_SIZE_OVERFLOW; err->flags |= ERR_SIZE_OVERFLOW;
return; return;
} }
else if ((status.flags & ERR_BUF_NULL) != 0 || ptr->_internal_size == 0) else if ((status.flags & ERR_BUF_NULL) != 0 || ptr->size == 0)
{ {
size_t max = ptr->_internal_max_size; size_t max = ptr->max_size;
err_t verr = ERR_T_INIT; err_t verr = ERR_T_INIT;
_vec_int_reserve(ptr, size, &verr); vec_int_reserve(ptr, size, &verr);
if (verr.flags != 0) if (verr.flags != 0)
{ {
__origin_override(err, "RESIZE"); __origin_override(err, "RESIZE");
err->flags |= verr.flags; err->flags |= verr.flags;
return; return;
} }
if (ptr->_internal_capacity != size) if (ptr->capacity != size)
{ {
__origin_override(err, "RESIZE"); __origin_override(err, "RESIZE");
err->flags |= ERR_ALLOC_FAIL; err->flags |= ERR_ALLOC_FAIL;
@@ -657,55 +614,55 @@ _vec_int_resize(_VecIntInternal* ptr, const size_t size, const int val,
} }
for (size_t i = 0; i < size; i++) for (size_t i = 0; i < size; i++)
{ {
ptr->_internal_arr[i] = val; ptr->array[i] = val;
} }
ptr->_internal_max_size = max; ptr->max_size = max;
ptr->_internal_size = size; ptr->size = size;
return; return;
} }
else if (size > ptr->_internal_capacity) else if (size > ptr->capacity)
{ {
size_t tmpcp = ptr->_internal_capacity; size_t tmpcp = ptr->capacity;
size_t tmpmx = ptr->_internal_max_size; size_t tmpmx = ptr->max_size;
err_t verr = ERR_T_INIT; err_t verr = ERR_T_INIT;
while (size > tmpcp) while (size > tmpcp)
{ {
tmpcp *= 2; tmpcp *= 2;
} }
if (tmpcp > ptr->_internal_max_size) if (tmpcp > ptr->max_size)
{ {
tmpcp = size; tmpcp = size;
} }
_vec_int_reserve(ptr, tmpcp, &verr); vec_int_reserve(ptr, tmpcp, &verr);
if (verr.flags != 0) if (verr.flags != 0)
{ {
__origin_override(err, "RESIZE"); __origin_override(err, "RESIZE");
err->flags |= verr.flags; err->flags |= verr.flags;
return; return;
} }
ptr->_internal_max_size = tmpmx; ptr->max_size = tmpmx;
} }
if (size < ptr->_internal_size) if (size < ptr->size)
{ {
for (size_t i = size; i < ptr->_internal_size; i++) for (size_t i = size; i < ptr->size; i++)
{ {
ptr->_internal_arr[i] = 0; ptr->array[i] = 0;
} }
} }
if (ptr->_internal_size < size && size <= ptr->_internal_capacity) if (ptr->size < size && size <= ptr->capacity)
{ {
for (size_t i = ptr->_internal_size; i < size; i++) for (size_t i = ptr->size; i < size; i++)
{ {
ptr->_internal_arr[i] = val; ptr->array[i] = val;
} }
} }
ptr->_internal_size = size; ptr->size = size;
return; return;
} }
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_int_assign(_VecIntInternal* ptr, const _VecIntInternal* iterator, vec_int_assign(vec_int* ptr, const vec_int* iterator, const size_t iter_start,
const size_t iter_start, const size_t iter_end, err_t* err) const size_t iter_end, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0 || if (__null_check(ptr, &status) != 0 ||
@@ -715,27 +672,27 @@ _vec_int_assign(_VecIntInternal* ptr, const _VecIntInternal* iterator,
err->flags |= status.flags; err->flags |= status.flags;
return; return;
} }
if (ptr->_internal_arr == iterator->_internal_arr) if (ptr->array == iterator->array)
{ {
__origin_override(err, "ASSIGN"); __origin_override(err, "ASSIGN");
err->flags |= ERR_DOUBLE_BUF; err->flags |= ERR_DOUBLE_BUF;
return; return;
} }
if (iterator->_internal_size < iter_end || iter_end <= iter_start) if (iterator->size < iter_end || iter_end <= iter_start)
{ {
__origin_override(err, "ASSIGN"); __origin_override(err, "ASSIGN");
err->flags |= ERR_OUT_OF_BOUNDS; err->flags |= ERR_OUT_OF_BOUNDS;
return; return;
} }
_vec_int_erase(ptr, _vec_int_begin(ptr, &status), vec_int_erase(ptr, vec_int_begin(ptr, &status),
_vec_int_end(ptr, &status) + 1, &status); vec_int_end(ptr, &status) + 1, &status);
if (status.flags != 0) if (status.flags != 0)
{ {
__origin_override(err, "ASSIGN"); __origin_override(err, "ASSIGN");
err->flags |= status.flags; err->flags |= status.flags;
return; return;
} }
_vec_int_reserve(ptr, (iter_end - iter_start), &status); vec_int_reserve(ptr, (iter_end - iter_start), &status);
if (status.flags != 0) if (status.flags != 0)
{ {
__origin_override(err, "ASSIGN"); __origin_override(err, "ASSIGN");
@@ -744,13 +701,13 @@ _vec_int_assign(_VecIntInternal* ptr, const _VecIntInternal* iterator,
} }
for (size_t i = iter_start; i < iter_end; i++) for (size_t i = iter_start; i < iter_end; i++)
{ {
int* res = _vec_int_at(iterator, i, &status); int* res = vec_int_at(iterator, i, &status);
if (res == nullptr) if (res == nullptr)
{ {
err->flags |= ERR_OUT_OF_BOUNDS; err->flags |= ERR_OUT_OF_BOUNDS;
return; return;
} }
_vec_int_push_back(ptr, *res, &status); vec_int_push_back(ptr, *res, &status);
if (status.flags != 0) if (status.flags != 0)
{ {
__origin_override(err, "ASSIGN"); __origin_override(err, "ASSIGN");
@@ -762,8 +719,7 @@ _vec_int_assign(_VecIntInternal* ptr, const _VecIntInternal* iterator,
} }
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_int_assign(_VecIntInternal* ptr, const size_t amount, const int val, vec_int_assign(vec_int* ptr, const size_t amount, const int val, err_t* err)
err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0) if (__null_check(ptr, &status) != 0)
@@ -778,15 +734,15 @@ _vec_int_assign(_VecIntInternal* ptr, const size_t amount, const int val,
err->flags |= ERR_SIZE_ZERO; err->flags |= ERR_SIZE_ZERO;
return; return;
} }
_vec_int_erase(ptr, _vec_int_begin(ptr, &status), vec_int_erase(ptr, vec_int_begin(ptr, &status),
_vec_int_end(ptr, &status) + 1, &status); vec_int_end(ptr, &status) + 1, &status);
if (status.flags != 0) if (status.flags != 0)
{ {
__origin_override(err, "ASSIGN"); __origin_override(err, "ASSIGN");
err->flags |= status.flags; err->flags |= status.flags;
return; return;
} }
_vec_int_reserve(ptr, amount, &status); vec_int_reserve(ptr, amount, &status);
if (status.flags != 0) if (status.flags != 0)
{ {
__origin_override(err, "ASSIGN"); __origin_override(err, "ASSIGN");
@@ -795,7 +751,7 @@ _vec_int_assign(_VecIntInternal* ptr, const size_t amount, const int val,
} }
for (size_t i = 0; i < amount; i++) for (size_t i = 0; i < amount; i++)
{ {
_vec_int_push_back(ptr, val, &status); vec_int_push_back(ptr, val, &status);
if (status.flags != 0) if (status.flags != 0)
{ {
__origin_override(err, "ASSIGN"); __origin_override(err, "ASSIGN");
@@ -807,8 +763,7 @@ _vec_int_assign(_VecIntInternal* ptr, const size_t amount, const int val,
} }
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_int_insert(_VecIntInternal* ptr, const size_t iter, const int val, vec_int_insert(vec_int* ptr, const size_t iter, const int val, err_t* err)
err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
__null_check(ptr, &status); __null_check(ptr, &status);
@@ -827,42 +782,42 @@ _vec_int_insert(_VecIntInternal* ptr, const size_t iter, const int val,
err->flags |= ERR_BUF_NULL; err->flags |= ERR_BUF_NULL;
return; return;
} }
ptr->_internal_arr = res; ptr->array = res;
ptr->_internal_capacity = 1; ptr->capacity = 1;
ptr->_internal_arr[0] = val; ptr->array[0] = val;
ptr->_internal_size = 1; ptr->size = 1;
return; return;
} }
if (ptr->_internal_max_size < ptr->_internal_size + 1) if (ptr->max_size < ptr->size + 1)
{ {
__origin_override(err, "INSERT"); __origin_override(err, "INSERT");
err->flags |= ERR_SIZE_OVERFLOW; err->flags |= ERR_SIZE_OVERFLOW;
return; return;
} }
if (iter > ptr->_internal_size) if (iter > ptr->size)
{ {
__origin_override(err, "INSERT"); __origin_override(err, "INSERT");
err->flags |= ERR_OUT_OF_BOUNDS; err->flags |= ERR_OUT_OF_BOUNDS;
return; return;
} }
_vec_int_push_back(ptr, 0, &status); vec_int_push_back(ptr, 0, &status);
if (status.flags != 0) if (status.flags != 0)
{ {
__origin_override(err, "INSERT"); __origin_override(err, "INSERT");
err->flags |= status.flags; err->flags |= status.flags;
return; return;
} }
for (size_t i = ptr->_internal_size - 1; i > iter; i--) for (size_t i = ptr->size - 1; i > iter; i--)
{ {
ptr->_internal_arr[i] = ptr->_internal_arr[i - 1]; ptr->array[i] = ptr->array[i - 1];
} }
ptr->_internal_arr[iter] = val; ptr->array[iter] = val;
return; return;
} }
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_int_insert(_VecIntInternal* ptr, const size_t iter, const size_t amount, vec_int_insert(vec_int* ptr, const size_t iter, const size_t amount,
const int val, err_t* err) const int val, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
@@ -873,7 +828,7 @@ _vec_int_insert(_VecIntInternal* ptr, const size_t iter, const size_t amount,
err->flags |= status.flags; err->flags |= status.flags;
return; return;
} }
if (iter > ptr->_internal_size) if (iter > ptr->size)
{ {
__origin_override(err, "INSERT"); __origin_override(err, "INSERT");
err->flags |= ERR_OUT_OF_BOUNDS; err->flags |= ERR_OUT_OF_BOUNDS;
@@ -887,7 +842,7 @@ _vec_int_insert(_VecIntInternal* ptr, const size_t iter, const size_t amount,
} }
for (size_t i = iter; i < iter + amount; i++) for (size_t i = iter; i < iter + amount; i++)
{ {
_vec_int_insert(ptr, i, val, &status); vec_int_insert(ptr, i, val, &status);
if (status.flags != 0) if (status.flags != 0)
{ {
__origin_override(err, "INSERT"); __origin_override(err, "INSERT");
@@ -899,9 +854,8 @@ _vec_int_insert(_VecIntInternal* ptr, const size_t iter, const size_t amount,
} }
__attribute__((overloadable)) void __attribute__((overloadable)) void
_vec_int_insert(_VecIntInternal* ptr, const _VecIntInternal* iterator, vec_int_insert(vec_int* ptr, const vec_int* iterator, const size_t iter,
const size_t iter, const size_t iter_start, const size_t iter_start, const size_t iter_end, err_t* err)
const size_t iter_end, err_t* err)
{ {
err_t status = ERR_T_INIT; err_t status = ERR_T_INIT;
__null_check(ptr, &status); __null_check(ptr, &status);
@@ -912,14 +866,14 @@ _vec_int_insert(_VecIntInternal* ptr, const _VecIntInternal* iterator,
err->flags |= status.flags; err->flags |= status.flags;
return; return;
} }
if (iter_end <= iter_start || iter_end > iterator->_internal_size || if (iter_end <= iter_start || iter_end > iterator->size ||
iter > ptr->_internal_size) iter > ptr->size)
{ {
__origin_override(err, "INSERT"); __origin_override(err, "INSERT");
err->flags |= ERR_OUT_OF_BOUNDS; err->flags |= ERR_OUT_OF_BOUNDS;
return; return;
} }
if (ptr->_internal_arr == iterator->_internal_arr) if (ptr->array == iterator->array)
{ {
__origin_override(err, "INSERT"); __origin_override(err, "INSERT");
err->flags |= ERR_DOUBLE_BUF; err->flags |= ERR_DOUBLE_BUF;
@@ -927,8 +881,8 @@ _vec_int_insert(_VecIntInternal* ptr, const _VecIntInternal* iterator,
} }
for (size_t i = iter_start; i < iter_end; i++) for (size_t i = iter_start; i < iter_end; i++)
{ {
_vec_int_insert(ptr, iter + (i - iter_start), vec_int_insert(ptr, iter + (i - iter_start), iterator->array[i],
iterator->_internal_arr[i], &status); &status);
if (status.flags != 0) if (status.flags != 0)
{ {
__origin_override(err, "INSERT"); __origin_override(err, "INSERT");
src/main.c
+3 -2
View File
@@ -41,7 +41,8 @@ main()
unsigned int mask = 0; unsigned int mask = 0;
mask = ERR_BUF_NULL ^ status.flags; mask = ERR_BUF_NULL ^ status.flags;
print_bits(mask); vec_print_bits(mask);
print_bits(status.flags); vec_print_bits(status.flags);
vec_print_errs(status);
return 0; return 0;
} }
src/utils.c
+40 -19
View File
@@ -38,18 +38,13 @@ vec_print_errs(const err_t err)
void void
print_bits(unsigned int num) print_bits(unsigned int num)
{ {
// Determine the number of bits in an unsigned int (usually 32) unsigned int total_bits = sizeof(num) * 8;
int total_bits = sizeof(num) * 8;
// Loop from the most significant bit (MSB) down to the least for (unsigned int i = total_bits - 1; i >= 0; i--)
// 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 unsigned int bit = (num >> i) & 1;
int bit = (num >> i) & 1;
printf("%d ", bit); printf("%d ", bit);
// Optional: Add a space every 4 or 8 bits for readability
if (i % 8 == 0) if (i % 8 == 0)
{ {
printf(" "); printf(" ");
@@ -58,14 +53,40 @@ print_bits(unsigned int num)
printf("\n"); printf("\n");
} }
// void size_t
// _vec_update_origin(err_t* err, char* str) __origin_override(err_t* status, char* str)
// { {
// err_t res; if (status == nullptr)
// if (err == nullptr) {
// { return ERR_ERR_T_NULL;
// res.err = 0; }
// res.value = 0; if (status->origin != nullptr)
// } {
// if (!err->origin) err->origin = str; 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;
}
}
__attribute__((overloadable)) size_t
__null_check(const float* ptr, err_t* status)
{
if (status == nullptr)
{
return ERR_ERR_T_NULL;
}
if (ptr == nullptr)
{
status->flags |= ERR_BUF_NULL;
}
return status->flags;
}