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
+39 -43
View File
@@ -7,14 +7,14 @@
typedef struct
{
char* _internal_arr;
size_t _internal_size;
size_t _internal_capacity;
size_t _internal_max_size;
} _VecCharInternal;
char* array;
size_t size;
size_t capacity;
size_t max_size;
} vec_char;
__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
__null_check(const char* ptr, err_t* status);
@@ -23,95 +23,91 @@ size_t
__origin_override(err_t* status, char* str);
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_cpy(const char* src, const size_t src_size, err_t* err);
vec_char
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);
vec_char_push_back(vec_char* ptr, const char val, err_t* err);
void
_vec_char_pop_back(_VecCharInternal* ptr, err_t* err);
vec_char_pop_back(vec_char* ptr, err_t* err);
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
_vec_char_shrink_to_fit(_VecCharInternal* ptr, err_t* err);
vec_char_shrink_to_fit(vec_char* ptr, err_t* err);
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*
_vec_char_data(const _VecCharInternal* ptr, err_t* err);
vec_char_data(const vec_char* ptr, err_t* err);
size_t
_vec_char_size(const _VecCharInternal* ptr, err_t* err);
vec_char_size(const vec_char* ptr, err_t* err);
size_t
_vec_char_capacity(const _VecCharInternal* ptr, err_t* err);
vec_char_capacity(const vec_char* ptr, err_t* err);
size_t
_vec_char_max_size(const _VecCharInternal* ptr, err_t* err);
vec_char_max_size(const vec_char* ptr, err_t* err);
void
_vec_char_delete(_VecCharInternal* ptr, err_t* err);
vec_char_delete(vec_char* ptr, err_t* err);
void
_vec_char_clear(_VecCharInternal* ptr, err_t* err);
vec_char_clear(vec_char* ptr, err_t* err);
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
_vec_char_begin(const _VecCharInternal* ptr, err_t* err);
vec_char_begin(const vec_char* ptr, err_t* err);
size_t
_vec_char_end(const _VecCharInternal* ptr, err_t* err);
vec_char_end(const vec_char* ptr, err_t* err);
char
_vec_char_front(const _VecCharInternal* ptr, err_t* err);
vec_char_front(const vec_char* ptr, err_t* err);
char
_vec_char_back(const _VecCharInternal* ptr, err_t* err);
vec_char_back(const vec_char* ptr, err_t* err);
size_t
_vec_char_empty(const _VecCharInternal* ptr, err_t* err);
vec_char_empty(const vec_char* ptr, err_t* err);
__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
_vec_char_erase(_VecCharInternal* ptr, const size_t iter_start,
const size_t iter_end, err_t* err);
vec_char_erase(vec_char* ptr, const size_t iter_start, const size_t iter_end,
err_t* err);
__attribute__((overloadable)) void
_vec_char_resize(_VecCharInternal* ptr, const size_t size, err_t* err);
vec_char_resize(vec_char* 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);
vec_char_resize(vec_char* ptr, const size_t size, const char val, err_t* err);
__attribute__((overloadable)) void
_vec_char_assign(_VecCharInternal* ptr, const _VecCharInternal* iterator,
const size_t iter_start, const size_t iter_end, err_t* err);
vec_char_assign(vec_char* ptr, const vec_char* iterator,
const size_t iter_start, const size_t iter_end, err_t* err);
__attribute__((overloadable)) void
_vec_char_assign(_VecCharInternal* ptr, const size_t amount, const char val,
err_t* err);
vec_char_assign(vec_char* ptr, const size_t amount, const char val, err_t* err);
__attribute__((overloadable)) void
_vec_char_insert(_VecCharInternal* ptr, const size_t iter, const char val,
err_t* err);
vec_char_insert(vec_char* ptr, const size_t iter, const char val, err_t* err);
__attribute__((overloadable)) void
_vec_char_insert(_VecCharInternal* ptr, const size_t iter, const size_t amount,
const char val, err_t* err);
vec_char_insert(vec_char* ptr, const size_t iter, const size_t amount,
const char val, err_t* err);
__attribute__((overloadable)) void
_vec_char_insert(_VecCharInternal* ptr, const _VecCharInternal* iterator,
const size_t iter, const size_t iter_start,
const size_t iter_end, err_t* err);
vec_char_insert(vec_char* ptr, const vec_char* iterator, const size_t iter,
const size_t iter_start, const size_t iter_end, err_t* err);
#endif
include/libvec/float.h
+53 -63
View File
@@ -7,111 +7,101 @@
typedef struct
{
char* _internal_arr;
size_t _internal_size;
size_t _internal_capacity;
size_t _internal_max_size;
} _VecCharInternal;
float* array;
size_t size;
size_t capacity;
size_t max_size;
} vec_float;
__attribute__((overloadable)) size_t
__null_check(const _VecCharInternal* ptr, err_t* status);
void
vec_float_print_vec(const vec_float* ptr, err_t* err);
__attribute__((overloadable)) size_t
__null_check(const char* ptr, err_t* status);
vec_float
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
__origin_override(err_t* status, char* str);
void
_vec_char_print_vec(const _VecCharInternal* ptr, err_t* err);
_VecCharInternal
_vec_char_cpy(const char* src, const size_t src_size, err_t* err);
void
_vec_char_push_back(_VecCharInternal* ptr, const char val, err_t* err);
void
_vec_char_pop_back(_VecCharInternal* ptr, err_t* err);
void
_vec_char_reserve(_VecCharInternal* ptr, const size_t capacity, err_t* err);
void
_vec_char_shrink_to_fit(_VecCharInternal* ptr, err_t* err);
void
_vec_char_swap(_VecCharInternal* ptr_a, _VecCharInternal* ptr_b, err_t* err);
const char*
_vec_char_data(const _VecCharInternal* ptr, err_t* err);
vec_float_size(const vec_float* ptr, err_t* err);
size_t
_vec_char_size(const _VecCharInternal* ptr, err_t* err);
vec_float_capacity(const vec_float* ptr, err_t* err);
size_t
_vec_char_capacity(const _VecCharInternal* ptr, err_t* err);
size_t
_vec_char_max_size(const _VecCharInternal* ptr, err_t* err);
vec_float_max_size(const vec_float* ptr, err_t* err);
void
_vec_char_delete(_VecCharInternal* ptr, err_t* err);
vec_float_delete(vec_float* ptr, err_t* err);
void
_vec_char_clear(_VecCharInternal* ptr, err_t* err);
vec_float_clear(vec_float* ptr, err_t* err);
char*
_vec_char_at(const _VecCharInternal* ptr, const size_t idx, err_t* err);
float*
vec_float_at(const vec_float* ptr, const size_t idx, err_t* err);
size_t
_vec_char_begin(const _VecCharInternal* ptr, err_t* err);
vec_float_begin(const vec_float* ptr, err_t* err);
size_t
_vec_char_end(const _VecCharInternal* ptr, err_t* err);
vec_float_end(const vec_float* ptr, err_t* err);
char
_vec_char_front(const _VecCharInternal* ptr, err_t* err);
float
vec_float_front(const vec_float* ptr, err_t* err);
char
_vec_char_back(const _VecCharInternal* ptr, err_t* err);
float
vec_float_back(const vec_float* ptr, err_t* err);
size_t
_vec_char_empty(const _VecCharInternal* ptr, err_t* err);
vec_float_empty(const vec_float* ptr, err_t* err);
__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
_vec_char_erase(_VecCharInternal* ptr, const size_t iter_start,
const size_t iter_end, err_t* err);
vec_float_erase(vec_float* ptr, const size_t iter_start, const size_t iter_end,
err_t* err);
__attribute__((overloadable)) void
_vec_char_resize(_VecCharInternal* ptr, const size_t size, err_t* err);
vec_float_resize(vec_float* ptr, const size_t size, err_t* err);
__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);
__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);
__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);
__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);
__attribute__((overloadable)) void
_vec_char_insert(_VecCharInternal* ptr, const size_t iter, const size_t amount,
const char val, err_t* err);
vec_float_insert(vec_float* ptr, const size_t iter, const size_t amount,
const float val, err_t* err);
__attribute__((overloadable)) void
_vec_char_insert(_VecCharInternal* ptr, const _VecCharInternal* iterator,
const size_t iter, const size_t iter_start,
const size_t iter_end, err_t* err);
vec_float_insert(vec_float* ptr, const vec_float* iterator, const size_t iter,
const size_t iter_start, const size_t iter_end, err_t* err);
#endif
include/libvec/int.h
+44 -48
View File
@@ -7,14 +7,14 @@
typedef struct
{
int* _internal_arr;
size_t _internal_size;
size_t _internal_capacity;
size_t _internal_max_size;
} _VecIntInternal;
int* array;
size_t size;
size_t capacity;
size_t max_size;
} vec_int;
__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
__null_check(const int* ptr, err_t* status);
@@ -23,95 +23,91 @@ size_t
__origin_override(err_t* status, char* str);
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_cpy(const int* src, const size_t src_size, err_t* err);
vec_int
vec_int_cpy(const int* src, const size_t src_size, err_t* err);
void
_vec_int_push_back(_VecIntInternal* ptr, const int val, err_t* err);
vec_int_push_back(vec_int* ptr, const int val, err_t* err);
void
_vec_int_pop_back(_VecIntInternal* ptr, err_t* err);
vec_int_pop_back(vec_int* ptr, err_t* err);
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
_vec_int_shrink_to_fit(_VecIntInternal* ptr, err_t* err);
vec_int_shrink_to_fit(vec_int* ptr, err_t* err);
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*
_vec_int_data(const _VecIntInternal* ptr, err_t* err);
vec_int_data(const vec_int* ptr, err_t* err);
size_t
_vec_int_size(const _VecIntInternal* ptr, err_t* err);
vec_int_size(const vec_int* ptr, err_t* err);
size_t
_vec_int_capacity(const _VecIntInternal* ptr, err_t* err);
vec_int_capacity(const vec_int* ptr, err_t* err);
size_t
_vec_int_max_size(const _VecIntInternal* ptr, err_t* err);
vec_int_max_size(const vec_int* ptr, err_t* err);
void
_vec_int_delete(_VecIntInternal* ptr, err_t* err);
vec_int_delete(vec_int* ptr, err_t* err);
void
_vec_int_clear(_VecIntInternal* ptr, err_t* err);
vec_int_clear(vec_int* ptr, err_t* err);
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
_vec_int_begin(const _VecIntInternal* ptr, err_t* err);
vec_int_begin(const vec_int* ptr, err_t* err);
size_t
_vec_int_end(const _VecIntInternal* ptr, err_t* err);
vec_int_end(const vec_int* ptr, err_t* err);
int
_vec_int_front(const _VecIntInternal* ptr, err_t* err);
vec_int_front(const vec_int* ptr, err_t* err);
int
_vec_int_back(const _VecIntInternal* ptr, err_t* err);
vec_int_back(const vec_int* ptr, err_t* err);
size_t
_vec_int_empty(const _VecIntInternal* ptr, err_t* err);
vec_int_empty(const vec_int* ptr, err_t* err);
__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
_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);
__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
_vec_int_resize(_VecIntInternal* ptr, const size_t size, const int val,
err_t* err);
vec_int_insert(vec_int* ptr, const size_t iter, const int val, err_t* err);
__attribute__((overloadable)) void
_vec_int_assign(_VecIntInternal* ptr, const _VecIntInternal* iterator,
const size_t iter_start, const size_t iter_end, err_t* err);
vec_int_insert(vec_int* ptr, const size_t iter, const size_t amount,
const int val, err_t* err);
__attribute__((overloadable)) void
_vec_int_assign(_VecIntInternal* ptr, const size_t amount, const int val,
err_t* err);
__attribute__((overloadable)) void
_vec_int_insert(_VecIntInternal* ptr, const size_t iter, const int val,
err_t* err);
__attribute__((overloadable)) void
_vec_int_insert(_VecIntInternal* ptr, const size_t iter, const size_t amount,
const int val, err_t* err);
__attribute__((overloadable)) void
_vec_int_insert(_VecIntInternal* ptr, const _VecIntInternal* iterator,
const size_t iter, const size_t iter_start,
const size_t iter_end, err_t* err);
vec_int_insert(vec_int* ptr, const vec_int* iterator, const size_t iter,
const size_t iter_start, const size_t iter_end, err_t* err);
#endif
include/libvec/utils.h
+10 -12
View File
@@ -4,8 +4,6 @@
#include <stddef.h>
#include <stdint.h>
#define CAPACITY 1024
#define VEC_FAULT_BITS 32
static const size_t VEC_MAX = SIZE_MAX / sizeof(int);
#define ERROR_LIST(X) \
@@ -45,23 +43,23 @@ typedef struct
} err_t;
#define ERR_T_INIT { .flags = 0, .origin = NULL }
#define VEC_INIT \
{ ._internal_arr = NULL, \
._internal_size = 0, \
._internal_capacity = 0, \
._internal_max_size = VEC_MAX }
const char*
vec_get_error_desc(ERROR_CODES err);
#define VEC_INIT \
{ .array = NULL, .size = 0, .capacity = 0, .max_size = VEC_MAX }
void
vec_print_errs(const err_t err);
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 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
src/char.c
+172 -221
View File
@@ -1,5 +1,4 @@
#include "libvec/char.h"
#include <libvec/char.h>
#include <libvec/utils.h>
#include <stddef.h>
#include <stdio.h>
@@ -7,7 +6,7 @@
#include <string.h>
__attribute__((overloadable)) size_t
__null_check(const _VecCharInternal* ptr, err_t* status)
__null_check(const vec_char* ptr, err_t* status)
{
if (status == nullptr)
{
@@ -18,7 +17,7 @@ __null_check(const _VecCharInternal* ptr, err_t* status)
status->flags |= ERR_VEC_NULL;
return ERR_VEC_NULL;
}
if (ptr->_internal_arr == nullptr)
if (ptr->array == nullptr)
{
status->flags |= ERR_BUF_NULL;
}
@@ -26,62 +25,24 @@ __null_check(const _VecCharInternal* ptr, err_t* status)
return status->flags;
}
__attribute__((overloadable)) size_t
__null_check(const char* ptr, err_t* status)
{
if (status == nullptr)
{
return ERR_ERR_T_NULL;
}
if (ptr == nullptr)
{
status->flags |= ERR_BUF_NULL;
}
return status->flags;
}
size_t
__origin_override(err_t* status, char* str)
{
if (status == nullptr)
{
return ERR_ERR_T_NULL;
}
if (status->origin != nullptr)
{
status->flags |= ERR_ORIGIN_UNALTERABLE;
return status->flags;
}
else if (str == nullptr)
{
status->flags |= ERR_STR_NULL;
return status->flags;
}
else
{
status->origin = str;
return status->flags;
}
}
void
_vec_char_print_vec(const _VecCharInternal* ptr, err_t* err)
vec_char_print_vec(const vec_char* ptr, err_t* err)
{
if (__null_check(ptr, err) != 0)
{
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");
}
_VecCharInternal
_vec_char_cpy(const char* src, const size_t src_size, err_t* err)
vec_char
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;
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;
return self;
}
if (src_size > self._internal_max_size)
if (src_size > self.max_size)
{
__origin_override(err, "CPY");
err->flags |= ERR_SIZE_OVERFLOW;
return self;
}
self._internal_arr = malloc(src_size * sizeof(char));
if (self._internal_arr == nullptr)
self.array = malloc(src_size * sizeof(char));
if (self.array == nullptr)
{
__origin_override(err, "CPY");
err->flags |= ERR_ALLOC_FAIL;
return self;
}
memcpy(self._internal_arr, src, src_size * sizeof(char));
self._internal_size = src_size;
self._internal_capacity = src_size;
memcpy(self.array, src, src_size * sizeof(char));
self.size = src_size;
self.capacity = src_size;
return self;
}
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;
char* res;
@@ -134,7 +95,7 @@ _vec_char_push_back(_VecCharInternal* ptr, const char val, err_t* err)
return;
}
if (ptr->_internal_size + 1 > ptr->_internal_max_size)
if (ptr->size + 1 > ptr->max_size)
{
__origin_override(err, "PUSH_BACK");
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;
return;
}
ptr->_internal_arr = res;
ptr->_internal_capacity = 1;
ptr->_internal_size = 0;
ptr->array = res;
ptr->capacity = 1;
ptr->size = 0;
}
else if (ptr->_internal_size + 1 > ptr->_internal_capacity)
else if (ptr->size + 1 > ptr->capacity)
{
size_t dst_cap =
(ptr->_internal_capacity / 2) + ptr->_internal_capacity;
if (dst_cap == ptr->_internal_capacity)
size_t dst_cap = (ptr->capacity / 2) + ptr->capacity;
if (dst_cap == ptr->capacity)
{
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(
"Capacity cannot be grown any further due "
"to hitting max size");
}
res = realloc(ptr->_internal_arr, dst_cap * sizeof(char));
res = realloc(ptr->array, dst_cap * sizeof(char));
if (res == nullptr)
{
__origin_override(err, "PUSH_BACK");
err->flags |= ERR_SIZE_OVERFLOW;
return;
}
ptr->_internal_arr = res;
ptr->_internal_capacity = dst_cap;
ptr->array = res;
ptr->capacity = dst_cap;
}
ptr->_internal_arr[ptr->_internal_size] = val;
ptr->_internal_size++;
ptr->array[ptr->size] = val;
ptr->size++;
return;
}
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)
{
@@ -194,19 +154,19 @@ _vec_char_pop_back(_VecCharInternal* ptr, err_t* err)
return;
}
if (ptr->_internal_size == 0)
if (ptr->size == 0)
{
__origin_override(err, "POP_BACK");
err->flags |= ERR_SIZE_ZERO;
return;
}
ptr->_internal_arr[ptr->_internal_size - 1] = 0;
ptr->_internal_size--;
ptr->array[ptr->size - 1] = 0;
ptr->size--;
}
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;
if (__null_check(ptr, &status) != 0)
@@ -218,7 +178,7 @@ _vec_char_reserve(_VecCharInternal* ptr, const size_t capacity, err_t* err)
return;
}
}
if (ptr->_internal_max_size < capacity)
if (ptr->max_size < capacity)
{
__origin_override(err, "RESERVE");
err->flags |= ERR_SIZE_OVERFLOW;
@@ -231,24 +191,24 @@ _vec_char_reserve(_VecCharInternal* ptr, const size_t capacity, err_t* err)
return;
}
char* res = realloc(ptr->_internal_arr, capacity * sizeof(char));
char* res = realloc(ptr->array, capacity * sizeof(char));
if (res == nullptr)
{
__origin_override(err, "RESERVE");
err->flags |= ERR_ALLOC_FAIL;
return;
}
ptr->_internal_arr = res;
ptr->_internal_capacity = capacity;
if (ptr->_internal_size > capacity)
ptr->array = res;
ptr->capacity = capacity;
if (ptr->size > capacity)
{
ptr->_internal_size = capacity;
ptr->size = capacity;
}
return;
}
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;
if (__null_check(ptr, &status) != 0)
@@ -257,17 +217,17 @@ _vec_char_shrink_to_fit(_VecCharInternal* ptr, err_t* err)
err->flags |= status.flags;
return;
}
if (ptr->_internal_size == 0)
if (ptr->size == 0)
{
__origin_override(err, "SHRINK_TO_FIT");
err->flags |= ERR_SIZE_ZERO;
return;
}
_vec_char_reserve(ptr, ptr->_internal_size, err);
vec_char_reserve(ptr, ptr->size, err);
}
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;
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;
return;
}
_VecCharInternal self = *ptr_a;
vec_char self = *ptr_a;
*ptr_a = *ptr_b;
*ptr_b = self;
return;
}
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;
if (__null_check(ptr, &status) != 0)
@@ -293,11 +253,11 @@ _vec_char_data(const _VecCharInternal* ptr, err_t* err)
err->flags |= status.flags;
return nullptr;
}
return &ptr->_internal_arr[0];
return &ptr->array[0];
}
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;
if (__null_check(ptr, &status) != 0)
@@ -306,11 +266,11 @@ _vec_char_size(const _VecCharInternal* ptr, err_t* err)
err->flags |= status.flags;
return 0;
}
return ptr->_internal_size;
return ptr->size;
}
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;
if (__null_check(ptr, &status) != 0)
@@ -319,11 +279,11 @@ _vec_char_capacity(const _VecCharInternal* ptr, err_t* err)
err->flags |= status.flags;
return 0;
}
return ptr->_internal_capacity;
return ptr->capacity;
}
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;
if (__null_check(ptr, &status) != 0)
@@ -332,11 +292,11 @@ _vec_char_max_size(const _VecCharInternal* ptr, err_t* err)
err->flags |= status.flags;
return 0;
}
return ptr->_internal_max_size;
return ptr->max_size;
}
void
_vec_char_delete(_VecCharInternal* ptr, err_t* err)
vec_char_delete(vec_char* ptr, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
@@ -345,17 +305,17 @@ _vec_char_delete(_VecCharInternal* ptr, err_t* err)
err->flags |= status.flags;
return;
}
if (ptr->_internal_arr != nullptr)
if (ptr->array != nullptr)
{
free(ptr->_internal_arr);
ptr->_internal_arr = nullptr;
free(ptr->array);
ptr->array = nullptr;
}
ptr->_internal_size = 0;
ptr->_internal_capacity = 0;
ptr->size = 0;
ptr->capacity = 0;
}
void
_vec_char_clear(_VecCharInternal* ptr, err_t* err)
vec_char_clear(vec_char* ptr, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
@@ -364,15 +324,15 @@ _vec_char_clear(_VecCharInternal* ptr, err_t* err)
err->flags |= status.flags;
return;
}
if (ptr->_internal_size > 0)
if (ptr->size > 0)
{
memset(ptr->_internal_arr, 0, ptr->_internal_size);
ptr->_internal_size = 0;
memset(ptr->array, 0, ptr->size);
ptr->size = 0;
}
}
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;
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;
return nullptr;
}
if (idx >= ptr->_internal_size)
if (idx >= ptr->size)
{
__origin_override(err, "AT");
err->flags |= ERR_OUT_OF_BOUNDS;
return nullptr;
}
return &ptr->_internal_arr[idx];
return &ptr->array[idx];
}
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;
if (__null_check(ptr, &status) != 0)
@@ -404,7 +364,7 @@ _vec_char_begin(const _VecCharInternal* ptr, err_t* err)
}
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;
if (__null_check(ptr, &status) != 0)
@@ -413,17 +373,17 @@ _vec_char_end(const _VecCharInternal* ptr, err_t* err)
err->flags |= status.flags;
return status.flags;
}
if (ptr->_internal_size == 0)
if (ptr->size == 0)
{
__origin_override(err, "END");
err->flags |= ERR_SIZE_ZERO;
return status.flags;
}
return (size_t)(ptr->_internal_size - 1);
return (size_t)(ptr->size - 1);
}
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;
if (__null_check(ptr, &status) != 0)
@@ -432,16 +392,16 @@ _vec_char_front(const _VecCharInternal* ptr, err_t* err)
err->flags |= status.flags;
return -1;
}
if (_vec_char_at(ptr, 0, err) == nullptr)
if (vec_char_at(ptr, 0, err) == nullptr)
{
err->flags |= ERR_OUT_OF_BOUNDS;
return 0;
}
return *_vec_char_at(ptr, 0, err);
return *vec_char_at(ptr, 0, err);
}
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;
if (__null_check(ptr, &status) != 0)
@@ -450,16 +410,16 @@ _vec_char_back(const _VecCharInternal* ptr, err_t* err)
err->flags |= status.flags;
return -1;
}
if (_vec_char_at(ptr, 0, err) == nullptr)
if (vec_char_at(ptr, 0, err) == nullptr)
{
err->flags |= ERR_OUT_OF_BOUNDS;
return 0;
}
return *_vec_char_at(ptr, ptr->_internal_size - 1, err);
return *vec_char_at(ptr, ptr->size - 1, err);
}
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;
if (__null_check(ptr, &status) != 0)
@@ -468,15 +428,15 @@ _vec_char_empty(const _VecCharInternal* ptr, err_t* err)
err->flags |= status.flags;
return status.flags;
}
if (ptr->_internal_size == 0)
if (ptr->size == 0)
{
return ptr->_internal_size;
return ptr->size;
}
return status.flags;
}
__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;
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;
return;
}
if (iter >= ptr->_internal_size)
if (iter >= ptr->size)
{
return;
}
memmove(&ptr->_internal_arr[iter], &ptr->_internal_arr[iter + 1],
(ptr->_internal_size - iter - 1) * sizeof(char));
ptr->_internal_arr[ptr->_internal_size - 1] = 0;
ptr->_internal_size--;
memmove(&ptr->array[iter], &ptr->array[iter + 1],
(ptr->size - iter - 1) * sizeof(char));
ptr->array[ptr->size - 1] = 0;
ptr->size--;
return;
}
__attribute__((overloadable)) void
_vec_char_erase(_VecCharInternal* ptr, const size_t iter_start,
const size_t iter_end, err_t* err)
vec_char_erase(vec_char* ptr, const size_t iter_start, const size_t iter_end,
err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
@@ -508,23 +468,22 @@ _vec_char_erase(_VecCharInternal* ptr, const size_t iter_start,
return;
}
if (ptr->_internal_size < iter_end || iter_end <= iter_start)
if (ptr->size < iter_end || iter_end <= iter_start)
{
__origin_override(err, "ERASE");
err->flags |= ERR_OUT_OF_BOUNDS;
return;
}
size_t diff = iter_end - iter_start;
memmove(&ptr->_internal_arr[iter_start], &ptr->_internal_arr[iter_end],
(ptr->_internal_size - iter_end) * sizeof(char));
memset(&ptr->_internal_arr[ptr->_internal_size - diff], 0,
sizeof(char) * diff);
ptr->_internal_size -= diff;
memmove(&ptr->array[iter_start], &ptr->array[iter_end],
(ptr->size - iter_end) * sizeof(char));
memset(&ptr->array[ptr->size - diff], 0, sizeof(char) * diff);
ptr->size -= diff;
return;
}
__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;
__null_check(ptr, &status);
@@ -535,32 +494,32 @@ _vec_char_resize(_VecCharInternal* ptr, const size_t size, err_t* err)
return;
}
if (ptr->_internal_size == size)
if (ptr->size == size)
{
__origin_override(err, "RESIZE");
err->flags |= ERR_OUT_OF_BOUNDS;
return;
}
else if (size > ptr->_internal_max_size)
else if (size > ptr->max_size)
{
__origin_override(err, "RESIZE");
err->flags |= ERR_SIZE_OVERFLOW;
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;
_vec_char_reserve(ptr, size, &verr);
vec_char_reserve(ptr, size, &verr);
if (verr.flags != 0)
{
__origin_override(err, "RESIZE");
err->flags |= verr.flags;
return;
}
if (ptr->_internal_capacity != size)
if (ptr->capacity != size)
{
__origin_override(err, "RESIZE");
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++)
{
ptr->_internal_arr[i] = 0;
ptr->array[i] = 0;
}
ptr->_internal_max_size = max;
ptr->_internal_size = size;
ptr->max_size = max;
ptr->size = size;
return;
}
else if (size > ptr->_internal_capacity)
else if (size > ptr->capacity)
{
size_t tmpcp = ptr->_internal_capacity;
size_t tmpmx = ptr->_internal_max_size;
size_t tmpcp = ptr->capacity;
size_t tmpmx = ptr->max_size;
err_t verr = ERR_T_INIT;
while (size > tmpcp)
{
tmpcp *= 2;
}
if (tmpcp > ptr->_internal_max_size)
if (tmpcp > ptr->max_size)
{
tmpcp = size;
}
_vec_char_reserve(ptr, tmpcp, &verr);
vec_char_reserve(ptr, tmpcp, &verr);
if (verr.flags != 0)
{
__origin_override(err, "RESIZE");
err->flags |= verr.flags;
return;
}
if (ptr->_internal_capacity != tmpcp)
if (ptr->capacity != tmpcp)
{
__origin_override(err, "RESIZE");
err->flags |= ERR_ALLOC_FAIL;
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,
ptr->_internal_size - size);
memset(&ptr->array[size], 0, ptr->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,
size - ptr->_internal_size);
memset(&ptr->array[ptr->size], 0, size - ptr->size);
}
ptr->_internal_size = size;
ptr->size = size;
return;
}
__attribute__((overloadable)) void
_vec_char_resize(_VecCharInternal* ptr, const size_t size, const char val,
err_t* err)
vec_char_resize(vec_char* ptr, const size_t size, const char val, err_t* err)
{
err_t status = ERR_T_INIT;
__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;
return;
}
if (ptr->_internal_size == size)
if (ptr->size == size)
{
__origin_override(err, "RESIZE");
err->flags |= ERR_OUT_OF_BOUNDS;
return;
}
else if (size > ptr->_internal_max_size)
else if (size > ptr->max_size)
{
__origin_override(err, "RESIZE");
err->flags |= ERR_SIZE_OVERFLOW;
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;
_vec_char_reserve(ptr, size, &verr);
vec_char_reserve(ptr, size, &verr);
if (verr.flags != 0)
{
__origin_override(err, "RESIZE");
err->flags |= verr.flags;
return;
}
if (ptr->_internal_capacity != size)
if (ptr->capacity != size)
{
__origin_override(err, "RESIZE");
err->flags |= ERR_ALLOC_FAIL;
@@ -661,51 +617,49 @@ _vec_char_resize(_VecCharInternal* ptr, const size_t size, const char val,
}
for (size_t i = 0; i < size; i++)
{
ptr->_internal_arr[i] = val;
ptr->array[i] = val;
}
ptr->_internal_max_size = max;
ptr->_internal_size = size;
ptr->max_size = max;
ptr->size = size;
return;
}
else if (size > ptr->_internal_capacity)
else if (size > ptr->capacity)
{
size_t tmpcp = ptr->_internal_capacity;
size_t tmpmx = ptr->_internal_max_size;
size_t tmpcp = ptr->capacity;
size_t tmpmx = ptr->max_size;
err_t verr = ERR_T_INIT;
while (size > tmpcp)
{
tmpcp *= 2;
}
if (tmpcp > ptr->_internal_max_size)
if (tmpcp > ptr->max_size)
{
tmpcp = size;
}
_vec_char_reserve(ptr, tmpcp, &verr);
vec_char_reserve(ptr, tmpcp, &verr);
if (verr.flags != 0)
{
__origin_override(err, "RESIZE");
err->flags |= verr.flags;
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,
ptr->_internal_size - size);
memset(&ptr->array[size], val, ptr->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,
size - ptr->_internal_size);
memset(&ptr->array[ptr->size], val, size - ptr->size);
}
ptr->_internal_size = size;
ptr->size = size;
return;
}
__attribute__((overloadable)) void
_vec_char_assign(_VecCharInternal* ptr, const _VecCharInternal* iterator,
const size_t iter_start, const size_t iter_end, err_t* err)
vec_char_assign(vec_char* ptr, const vec_char* iterator,
const size_t iter_start, const size_t iter_end, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0 ||
@@ -715,27 +669,27 @@ _vec_char_assign(_VecCharInternal* ptr, const _VecCharInternal* iterator,
err->flags |= status.flags;
return;
}
if (ptr->_internal_arr == iterator->_internal_arr)
if (ptr->array == iterator->array)
{
__origin_override(err, "ASSIGN");
err->flags |= ERR_DOUBLE_BUF;
return;
}
if (iterator->_internal_size < iter_end || iter_end <= iter_start)
if (iterator->size < iter_end || iter_end <= iter_start)
{
__origin_override(err, "ASSIGN");
err->flags |= ERR_OUT_OF_BOUNDS;
return;
}
_vec_char_erase(ptr, _vec_char_begin(ptr, &status),
_vec_char_end(ptr, &status) + 1, &status);
vec_char_erase(ptr, _vec_char_begin(ptr, &status),
vec_char_end(ptr, &status) + 1, &status);
if (status.flags != 0)
{
__origin_override(err, "ASSIGN");
err->flags |= status.flags;
return;
}
_vec_char_reserve(ptr, (iter_end - iter_start), &status);
vec_char_reserve(ptr, (iter_end - iter_start), &status);
if (status.flags != 0)
{
__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++)
{
char* res = _vec_char_at(iterator, i, &status);
char* res = vec_char_at(iterator, i, &status);
if (res == nullptr)
{
err->flags |= ERR_OUT_OF_BOUNDS;
return;
}
_vec_char_push_back(ptr, *res, &status);
vec_char_push_back(ptr, *res, &status);
if (status.flags != 0)
{
__origin_override(err, "ASSIGN");
@@ -762,8 +716,7 @@ _vec_char_assign(_VecCharInternal* ptr, const _VecCharInternal* iterator,
}
__attribute__((overloadable)) void
_vec_char_assign(_VecCharInternal* ptr, const size_t amount, const char val,
err_t* err)
vec_char_assign(vec_char* ptr, const size_t amount, const char val, err_t* err)
{
err_t status = ERR_T_INIT;
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;
return;
}
_vec_char_erase(ptr, _vec_char_begin(ptr, &status),
_vec_char_end(ptr, &status) + 1, &status);
vec_char_erase(ptr, _vec_char_begin(ptr, &status),
vec_char_end(ptr, &status) + 1, &status);
if (status.flags != 0)
{
__origin_override(err, "ASSIGN");
err->flags |= status.flags;
return;
}
_vec_char_reserve(ptr, amount, &status);
vec_char_reserve(ptr, amount, &status);
if (status.flags != 0)
{
__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++)
{
_vec_char_push_back(ptr, val, &status);
vec_char_push_back(ptr, val, &status);
if (status.flags != 0)
{
__origin_override(err, "ASSIGN");
@@ -807,8 +760,7 @@ _vec_char_assign(_VecCharInternal* ptr, const size_t amount, const char val,
}
__attribute__((overloadable)) void
_vec_char_insert(_VecCharInternal* ptr, const size_t iter, const char val,
err_t* err)
vec_char_insert(vec_char* ptr, const size_t iter, const char val, err_t* err)
{
err_t status = ERR_T_INIT;
__null_check(ptr, &status);
@@ -827,43 +779,43 @@ _vec_char_insert(_VecCharInternal* ptr, const size_t iter, const char val,
err->flags |= ERR_BUF_NULL;
return;
}
ptr->_internal_arr = res;
ptr->_internal_capacity = 1;
ptr->_internal_arr[0] = val;
ptr->_internal_size = 1;
ptr->array = res;
ptr->capacity = 1;
ptr->array[0] = val;
ptr->size = 1;
return;
}
if (ptr->_internal_max_size < ptr->_internal_size + 1)
if (ptr->max_size < ptr->size + 1)
{
__origin_override(err, "INSERT");
err->flags |= ERR_SIZE_OVERFLOW;
return;
}
if (iter > ptr->_internal_size)
if (iter > ptr->size)
{
__origin_override(err, "INSERT");
err->flags |= ERR_OUT_OF_BOUNDS;
return;
}
_vec_char_push_back(ptr, 0, &status);
vec_char_push_back(ptr, 0, &status);
if (status.flags != 0)
{
__origin_override(err, "INSERT");
err->flags |= status.flags;
return;
}
for (size_t i = ptr->_internal_size - 1; i > iter; i--)
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;
}
__attribute__((overloadable)) void
_vec_char_insert(_VecCharInternal* ptr, const size_t iter, const size_t amount,
const char val, err_t* err)
vec_char_insert(vec_char* ptr, const size_t iter, const size_t amount,
const char val, err_t* err)
{
err_t status = ERR_T_INIT;
__null_check(ptr, &status);
@@ -873,7 +825,7 @@ _vec_char_insert(_VecCharInternal* ptr, const size_t iter, const size_t amount,
err->flags |= status.flags;
return;
}
if (iter > ptr->_internal_size)
if (iter > ptr->size)
{
__origin_override(err, "INSERT");
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++)
{
_vec_char_insert(ptr, i, val, &status);
vec_char_insert(ptr, i, val, &status);
if (status.flags != 0)
{
__origin_override(err, "INSERT");
@@ -899,9 +851,8 @@ _vec_char_insert(_VecCharInternal* ptr, const size_t iter, const size_t amount,
}
__attribute__((overloadable)) void
_vec_char_insert(_VecCharInternal* ptr, const _VecCharInternal* iterator,
const size_t iter, const size_t iter_start,
const size_t iter_end, err_t* err)
vec_char_insert(vec_char* ptr, const vec_char* iterator, const size_t iter,
const size_t iter_start, const size_t iter_end, err_t* err)
{
err_t status = ERR_T_INIT;
__null_check(ptr, &status);
@@ -912,14 +863,14 @@ _vec_char_insert(_VecCharInternal* ptr, const _VecCharInternal* iterator,
err->flags |= status.flags;
return;
}
if (iter_end <= iter_start || iter_end > iterator->_internal_size ||
iter > ptr->_internal_size)
if (iter_end <= iter_start || iter_end > iterator->size ||
iter > ptr->size)
{
__origin_override(err, "INSERT");
err->flags |= ERR_OUT_OF_BOUNDS;
return;
}
if (ptr->_internal_arr == iterator->_internal_arr)
if (ptr->array == iterator->array)
{
__origin_override(err, "INSERT");
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++)
{
_vec_char_insert(ptr, iter + (i - iter_start),
iterator->_internal_arr[i], &status);
vec_char_insert(ptr, iter + (i - iter_start),
iterator->array[i], &status);
if (status.flags != 0)
{
__origin_override(err, "INSERT");
src/float.c
+177 -224
View File
@@ -5,7 +5,7 @@
#include <string.h>
__attribute__((overloadable)) size_t
__null_check(const _VecCharInternal* ptr, err_t* status)
__null_check(const vec_float* ptr, err_t* status)
{
if (status == nullptr)
{
@@ -16,7 +16,7 @@ __null_check(const _VecCharInternal* ptr, err_t* status)
status->flags |= ERR_VEC_NULL;
return ERR_VEC_NULL;
}
if (ptr->_internal_arr == nullptr)
if (ptr->array == nullptr)
{
status->flags |= ERR_BUF_NULL;
}
@@ -24,62 +24,24 @@ __null_check(const _VecCharInternal* ptr, err_t* status)
return status->flags;
}
__attribute__((overloadable)) size_t
__null_check(const char* ptr, err_t* status)
{
if (status == nullptr)
{
return ERR_ERR_T_NULL;
}
if (ptr == nullptr)
{
status->flags |= ERR_BUF_NULL;
}
return status->flags;
}
size_t
__origin_override(err_t* status, char* str)
{
if (status == nullptr)
{
return ERR_ERR_T_NULL;
}
if (status->origin != nullptr)
{
status->flags |= ERR_ORIGIN_UNALTERABLE;
return status->flags;
}
else if (str == nullptr)
{
status->flags |= ERR_STR_NULL;
return status->flags;
}
else
{
status->origin = str;
return status->flags;
}
}
void
_vec_char_print_vec(const _VecCharInternal* ptr, err_t* err)
vec_float_print_vec(const vec_float* ptr, err_t* err)
{
if (__null_check(ptr, err) != 0)
{
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");
}
_VecCharInternal
_vec_char_cpy(const char* src, const size_t src_size, err_t* err)
vec_float
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;
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;
return self;
}
if (src_size > self._internal_max_size)
if (src_size > self.max_size)
{
__origin_override(err, "CPY");
err->flags |= ERR_SIZE_OVERFLOW;
return self;
}
self._internal_arr = malloc(src_size * sizeof(char));
if (self._internal_arr == nullptr)
self.array = malloc(src_size * sizeof(float));
if (self.array == nullptr)
{
__origin_override(err, "CPY");
err->flags |= ERR_ALLOC_FAIL;
return self;
}
memcpy(self._internal_arr, src, src_size * sizeof(char));
self._internal_size = src_size;
self._internal_capacity = src_size;
memcpy(self.array, src, src_size * sizeof(float));
self.size = src_size;
self.capacity = src_size;
return self;
}
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;
char* res;
float* res;
__null_check(ptr, &status);
if ((status.flags & ERR_VEC_NULL) != 0)
{
@@ -132,7 +94,7 @@ _vec_char_push_back(_VecCharInternal* ptr, const char val, err_t* err)
return;
}
if (ptr->_internal_size + 1 > ptr->_internal_max_size)
if (ptr->size + 1 > ptr->max_size)
{
__origin_override(err, "PUSH_BACK");
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)
{
res = malloc(1 * sizeof(char));
res = malloc(1 * sizeof(float));
if (res == nullptr)
{
__origin_override(err, "PUSH_BACK");
err->flags |= ERR_ALLOC_FAIL;
return;
}
ptr->_internal_arr = res;
ptr->_internal_capacity = 1;
ptr->_internal_size = 0;
ptr->array = res;
ptr->capacity = 1;
ptr->size = 0;
}
else if (ptr->_internal_size + 1 > ptr->_internal_capacity)
else if (ptr->size + 1 > ptr->capacity)
{
size_t dst_cap =
(ptr->_internal_capacity / 2) + ptr->_internal_capacity;
if (dst_cap == ptr->_internal_capacity)
size_t dst_cap = (ptr->capacity / 2) + ptr->capacity;
if (dst_cap == ptr->capacity)
{
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(
"Capacity cannot be grown any further due "
"to hitting max size");
}
res = realloc(ptr->_internal_arr, dst_cap * sizeof(char));
res = realloc(ptr->array, dst_cap * sizeof(float));
if (res == nullptr)
{
__origin_override(err, "PUSH_BACK");
err->flags |= ERR_SIZE_OVERFLOW;
return;
}
ptr->_internal_arr = res;
ptr->_internal_capacity = dst_cap;
ptr->array = res;
ptr->capacity = dst_cap;
}
ptr->_internal_arr[ptr->_internal_size] = val;
ptr->_internal_size++;
ptr->array[ptr->size] = val;
ptr->size++;
return;
}
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)
{
@@ -192,19 +153,19 @@ _vec_char_pop_back(_VecCharInternal* ptr, err_t* err)
return;
}
if (ptr->_internal_size == 0)
if (ptr->size == 0)
{
__origin_override(err, "POP_BACK");
err->flags |= ERR_SIZE_ZERO;
return;
}
ptr->_internal_arr[ptr->_internal_size - 1] = 0;
ptr->_internal_size--;
ptr->array[ptr->size - 1] = 0;
ptr->size--;
}
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;
if (__null_check(ptr, &status) != 0)
@@ -216,7 +177,7 @@ _vec_char_reserve(_VecCharInternal* ptr, const size_t capacity, err_t* err)
return;
}
}
if (ptr->_internal_max_size < capacity)
if (ptr->max_size < capacity)
{
__origin_override(err, "RESERVE");
err->flags |= ERR_SIZE_OVERFLOW;
@@ -229,24 +190,24 @@ _vec_char_reserve(_VecCharInternal* ptr, const size_t capacity, err_t* err)
return;
}
char* res = realloc(ptr->_internal_arr, capacity * sizeof(char));
float* res = realloc(ptr->array, capacity * sizeof(float));
if (res == nullptr)
{
__origin_override(err, "RESERVE");
err->flags |= ERR_ALLOC_FAIL;
return;
}
ptr->_internal_arr = res;
ptr->_internal_capacity = capacity;
if (ptr->_internal_size > capacity)
ptr->array = res;
ptr->capacity = capacity;
if (ptr->size > capacity)
{
ptr->_internal_size = capacity;
ptr->size = capacity;
}
return;
}
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;
if (__null_check(ptr, &status) != 0)
@@ -255,17 +216,17 @@ _vec_char_shrink_to_fit(_VecCharInternal* ptr, err_t* err)
err->flags |= status.flags;
return;
}
if (ptr->_internal_size == 0)
if (ptr->size == 0)
{
__origin_override(err, "SHRINK_TO_FIT");
err->flags |= ERR_SIZE_ZERO;
return;
}
_vec_char_reserve(ptr, ptr->_internal_size, err);
vec_float_reserve(ptr, ptr->size, err);
}
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;
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;
return;
}
_VecCharInternal self = *ptr_a;
vec_float self = *ptr_a;
*ptr_a = *ptr_b;
*ptr_b = self;
return;
}
const char*
_vec_char_data(const _VecCharInternal* ptr, err_t* err)
const float*
vec_float_data(const vec_float* ptr, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
@@ -291,11 +252,11 @@ _vec_char_data(const _VecCharInternal* ptr, err_t* err)
err->flags |= status.flags;
return nullptr;
}
return &ptr->_internal_arr[0];
return &ptr->array[0];
}
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;
if (__null_check(ptr, &status) != 0)
@@ -304,11 +265,11 @@ _vec_char_size(const _VecCharInternal* ptr, err_t* err)
err->flags |= status.flags;
return 0;
}
return ptr->_internal_size;
return ptr->size;
}
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;
if (__null_check(ptr, &status) != 0)
@@ -317,11 +278,11 @@ _vec_char_capacity(const _VecCharInternal* ptr, err_t* err)
err->flags |= status.flags;
return 0;
}
return ptr->_internal_capacity;
return ptr->capacity;
}
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;
if (__null_check(ptr, &status) != 0)
@@ -330,11 +291,11 @@ _vec_char_max_size(const _VecCharInternal* ptr, err_t* err)
err->flags |= status.flags;
return 0;
}
return ptr->_internal_max_size;
return ptr->max_size;
}
void
_vec_char_delete(_VecCharInternal* ptr, err_t* err)
vec_float_delete(vec_float* ptr, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
@@ -343,17 +304,17 @@ _vec_char_delete(_VecCharInternal* ptr, err_t* err)
err->flags |= status.flags;
return;
}
if (ptr->_internal_arr != nullptr)
if (ptr->array != nullptr)
{
free(ptr->_internal_arr);
ptr->_internal_arr = nullptr;
free(ptr->array);
ptr->array = nullptr;
}
ptr->_internal_size = 0;
ptr->_internal_capacity = 0;
ptr->size = 0;
ptr->capacity = 0;
}
void
_vec_char_clear(_VecCharInternal* ptr, err_t* err)
vec_float_clear(vec_float* ptr, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
@@ -362,15 +323,15 @@ _vec_char_clear(_VecCharInternal* ptr, err_t* err)
err->flags |= status.flags;
return;
}
if (ptr->_internal_size > 0)
if (ptr->size > 0)
{
memset(ptr->_internal_arr, 0, ptr->_internal_size);
ptr->_internal_size = 0;
memset(ptr->array, 0, ptr->size);
ptr->size = 0;
}
}
char*
_vec_char_at(const _VecCharInternal* ptr, const size_t idx, err_t* err)
float*
vec_float_at(const vec_float* ptr, const size_t idx, err_t* err)
{
err_t status = ERR_T_INIT;
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;
return nullptr;
}
if (idx >= ptr->_internal_size)
if (idx >= ptr->size)
{
__origin_override(err, "AT");
err->flags |= ERR_OUT_OF_BOUNDS;
return nullptr;
}
return &ptr->_internal_arr[idx];
return &ptr->array[idx];
}
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;
if (__null_check(ptr, &status) != 0)
@@ -402,7 +363,7 @@ _vec_char_begin(const _VecCharInternal* ptr, err_t* err)
}
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;
if (__null_check(ptr, &status) != 0)
@@ -411,17 +372,17 @@ _vec_char_end(const _VecCharInternal* ptr, err_t* err)
err->flags |= status.flags;
return status.flags;
}
if (ptr->_internal_size == 0)
if (ptr->size == 0)
{
__origin_override(err, "END");
err->flags |= ERR_SIZE_ZERO;
return status.flags;
}
return (size_t)(ptr->_internal_size - 1);
return (size_t)(ptr->size - 1);
}
char
_vec_char_front(const _VecCharInternal* ptr, err_t* err)
float
vec_float_front(const vec_float* ptr, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
@@ -430,16 +391,16 @@ _vec_char_front(const _VecCharInternal* ptr, err_t* err)
err->flags |= status.flags;
return -1;
}
if (_vec_char_at(ptr, 0, err) == nullptr)
if (vec_float_at(ptr, 0, err) == nullptr)
{
err->flags |= ERR_OUT_OF_BOUNDS;
return 0;
}
return *_vec_char_at(ptr, 0, err);
return *vec_float_at(ptr, 0, err);
}
char
_vec_char_back(const _VecCharInternal* ptr, err_t* err)
float
vec_float_back(const vec_float* ptr, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
@@ -448,16 +409,16 @@ _vec_char_back(const _VecCharInternal* ptr, err_t* err)
err->flags |= status.flags;
return -1;
}
if (_vec_char_at(ptr, 0, err) == nullptr)
if (vec_float_at(ptr, 0, err) == nullptr)
{
err->flags |= ERR_OUT_OF_BOUNDS;
return 0;
}
return *_vec_char_at(ptr, ptr->_internal_size - 1, err);
return *vec_float_at(ptr, ptr->size - 1, err);
}
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;
if (__null_check(ptr, &status) != 0)
@@ -466,15 +427,15 @@ _vec_char_empty(const _VecCharInternal* ptr, err_t* err)
err->flags |= status.flags;
return status.flags;
}
if (ptr->_internal_size == 0)
if (ptr->size == 0)
{
return ptr->_internal_size;
return ptr->size;
}
return status.flags;
}
__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;
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;
return;
}
if (iter >= ptr->_internal_size)
if (iter >= ptr->size)
{
return;
}
memmove(&ptr->_internal_arr[iter], &ptr->_internal_arr[iter + 1],
(ptr->_internal_size - iter - 1) * sizeof(char));
ptr->_internal_arr[ptr->_internal_size - 1] = 0;
ptr->_internal_size--;
memmove(&ptr->array[iter], &ptr->array[iter + 1],
(ptr->size - iter - 1) * sizeof(float));
ptr->array[ptr->size - 1] = 0;
ptr->size--;
return;
}
__attribute__((overloadable)) void
_vec_char_erase(_VecCharInternal* ptr, const size_t iter_start,
const size_t iter_end, err_t* err)
vec_float_erase(vec_float* ptr, const size_t iter_start, const size_t iter_end,
err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
@@ -506,23 +467,22 @@ _vec_char_erase(_VecCharInternal* ptr, const size_t iter_start,
return;
}
if (ptr->_internal_size < iter_end || iter_end <= iter_start)
if (ptr->size < iter_end || iter_end <= iter_start)
{
__origin_override(err, "ERASE");
err->flags |= ERR_OUT_OF_BOUNDS;
return;
}
size_t diff = iter_end - iter_start;
memmove(&ptr->_internal_arr[iter_start], &ptr->_internal_arr[iter_end],
(ptr->_internal_size - iter_end) * sizeof(char));
memset(&ptr->_internal_arr[ptr->_internal_size - diff], 0,
sizeof(char) * diff);
ptr->_internal_size -= diff;
memmove(&ptr->array[iter_start], &ptr->array[iter_end],
(ptr->size - iter_end) * sizeof(float));
memset(&ptr->array[ptr->size - diff], 0, sizeof(float) * diff);
ptr->size -= diff;
return;
}
__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;
__null_check(ptr, &status);
@@ -533,32 +493,32 @@ _vec_char_resize(_VecCharInternal* ptr, const size_t size, err_t* err)
return;
}
if (ptr->_internal_size == size)
if (ptr->size == size)
{
__origin_override(err, "RESIZE");
err->flags |= ERR_OUT_OF_BOUNDS;
return;
}
else if (size > ptr->_internal_max_size)
else if (size > ptr->max_size)
{
__origin_override(err, "RESIZE");
err->flags |= ERR_SIZE_OVERFLOW;
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;
_vec_char_reserve(ptr, size, &verr);
vec_float_reserve(ptr, size, &verr);
if (verr.flags != 0)
{
__origin_override(err, "RESIZE");
err->flags |= verr.flags;
return;
}
if (ptr->_internal_capacity != size)
if (ptr->capacity != size)
{
__origin_override(err, "RESIZE");
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++)
{
ptr->_internal_arr[i] = 0;
ptr->array[i] = 0;
}
ptr->_internal_max_size = max;
ptr->_internal_size = size;
ptr->max_size = max;
ptr->size = size;
return;
}
else if (size > ptr->_internal_capacity)
else if (size > ptr->capacity)
{
size_t tmpcp = ptr->_internal_capacity;
size_t tmpmx = ptr->_internal_max_size;
size_t tmpcp = ptr->capacity;
size_t tmpmx = ptr->max_size;
err_t verr = ERR_T_INIT;
while (size > tmpcp)
{
tmpcp *= 2;
}
if (tmpcp > ptr->_internal_max_size)
if (tmpcp > ptr->max_size)
{
tmpcp = size;
}
_vec_char_reserve(ptr, tmpcp, &verr);
vec_float_reserve(ptr, tmpcp, &verr);
if (verr.flags != 0)
{
__origin_override(err, "RESIZE");
err->flags |= verr.flags;
return;
}
if (ptr->_internal_capacity != tmpcp)
if (ptr->capacity != tmpcp)
{
__origin_override(err, "RESIZE");
err->flags |= ERR_ALLOC_FAIL;
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,
ptr->_internal_size - size);
memset(&ptr->array[size], 0, ptr->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,
size - ptr->_internal_size);
memset(&ptr->array[ptr->size], 0, size - ptr->size);
}
ptr->_internal_size = size;
ptr->size = size;
return;
}
__attribute__((overloadable)) void
_vec_char_resize(_VecCharInternal* ptr, const size_t size, const char val,
err_t* err)
vec_float_resize(vec_float* ptr, const size_t size, const float val, err_t* err)
{
err_t status = ERR_T_INIT;
__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;
return;
}
if (ptr->_internal_size == size)
if (ptr->size == size)
{
__origin_override(err, "RESIZE");
err->flags |= ERR_OUT_OF_BOUNDS;
return;
}
else if (size > ptr->_internal_max_size)
else if (size > ptr->max_size)
{
__origin_override(err, "RESIZE");
err->flags |= ERR_SIZE_OVERFLOW;
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;
_vec_char_reserve(ptr, size, &verr);
vec_float_reserve(ptr, size, &verr);
if (verr.flags != 0)
{
__origin_override(err, "RESIZE");
err->flags |= verr.flags;
return;
}
if (ptr->_internal_capacity != size)
if (ptr->capacity != size)
{
__origin_override(err, "RESIZE");
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++)
{
ptr->_internal_arr[i] = val;
ptr->array[i] = val;
}
ptr->_internal_max_size = max;
ptr->_internal_size = size;
ptr->max_size = max;
ptr->size = size;
return;
}
else if (size > ptr->_internal_capacity)
else if (size > ptr->capacity)
{
size_t tmpcp = ptr->_internal_capacity;
size_t tmpmx = ptr->_internal_max_size;
size_t tmpcp = ptr->capacity;
size_t tmpmx = ptr->max_size;
err_t verr = ERR_T_INIT;
while (size > tmpcp)
{
tmpcp *= 2;
}
if (tmpcp > ptr->_internal_max_size)
if (tmpcp > ptr->max_size)
{
tmpcp = size;
}
_vec_char_reserve(ptr, tmpcp, &verr);
vec_float_reserve(ptr, tmpcp, &verr);
if (verr.flags != 0)
{
__origin_override(err, "RESIZE");
err->flags |= verr.flags;
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,
ptr->_internal_size - size);
memset(&ptr->array[size], val, ptr->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,
size - ptr->_internal_size);
memset(&ptr->array[ptr->size], val, size - ptr->size);
}
ptr->_internal_size = size;
ptr->size = size;
return;
}
__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)
{
err_t status = ERR_T_INIT;
@@ -713,27 +668,27 @@ _vec_char_assign(_VecCharInternal* ptr, const _VecCharInternal* iterator,
err->flags |= status.flags;
return;
}
if (ptr->_internal_arr == iterator->_internal_arr)
if (ptr->array == iterator->array)
{
__origin_override(err, "ASSIGN");
err->flags |= ERR_DOUBLE_BUF;
return;
}
if (iterator->_internal_size < iter_end || iter_end <= iter_start)
if (iterator->size < iter_end || iter_end <= iter_start)
{
__origin_override(err, "ASSIGN");
err->flags |= ERR_OUT_OF_BOUNDS;
return;
}
_vec_char_erase(ptr, _vec_char_begin(ptr, &status),
_vec_char_end(ptr, &status) + 1, &status);
vec_float_erase(ptr, vec_float_begin(ptr, &status),
vec_float_end(ptr, &status) + 1, &status);
if (status.flags != 0)
{
__origin_override(err, "ASSIGN");
err->flags |= status.flags;
return;
}
_vec_char_reserve(ptr, (iter_end - iter_start), &status);
vec_float_reserve(ptr, (iter_end - iter_start), &status);
if (status.flags != 0)
{
__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++)
{
char* res = _vec_char_at(iterator, i, &status);
float* res = vec_float_at(iterator, i, &status);
if (res == nullptr)
{
err->flags |= ERR_OUT_OF_BOUNDS;
return;
}
_vec_char_push_back(ptr, *res, &status);
vec_float_push_back(ptr, *res, &status);
if (status.flags != 0)
{
__origin_override(err, "ASSIGN");
@@ -760,7 +715,7 @@ _vec_char_assign(_VecCharInternal* ptr, const _VecCharInternal* iterator,
}
__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 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;
return;
}
_vec_char_erase(ptr, _vec_char_begin(ptr, &status),
_vec_char_end(ptr, &status) + 1, &status);
vec_float_erase(ptr, vec_float_begin(ptr, &status),
vec_float_end(ptr, &status) + 1, &status);
if (status.flags != 0)
{
__origin_override(err, "ASSIGN");
err->flags |= status.flags;
return;
}
_vec_char_reserve(ptr, amount, &status);
vec_float_reserve(ptr, amount, &status);
if (status.flags != 0)
{
__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++)
{
_vec_char_push_back(ptr, val, &status);
vec_float_push_back(ptr, val, &status);
if (status.flags != 0)
{
__origin_override(err, "ASSIGN");
@@ -805,8 +760,7 @@ _vec_char_assign(_VecCharInternal* ptr, const size_t amount, const char val,
}
__attribute__((overloadable)) void
_vec_char_insert(_VecCharInternal* ptr, const size_t iter, const char val,
err_t* err)
vec_float_insert(vec_float* ptr, const size_t iter, const float val, err_t* err)
{
err_t status = ERR_T_INIT;
__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)
{
char* res = malloc(1 * sizeof(char));
float* res = malloc(1 * sizeof(float));
if (res == nullptr)
{
__origin_override(err, "INSERT");
err->flags |= ERR_BUF_NULL;
return;
}
ptr->_internal_arr = res;
ptr->_internal_capacity = 1;
ptr->_internal_arr[0] = val;
ptr->_internal_size = 1;
ptr->array = res;
ptr->capacity = 1;
ptr->array[0] = val;
ptr->size = 1;
return;
}
if (ptr->_internal_max_size < ptr->_internal_size + 1)
if (ptr->max_size < ptr->size + 1)
{
__origin_override(err, "INSERT");
err->flags |= ERR_SIZE_OVERFLOW;
return;
}
if (iter > ptr->_internal_size)
if (iter > ptr->size)
{
__origin_override(err, "INSERT");
err->flags |= ERR_OUT_OF_BOUNDS;
return;
}
_vec_char_push_back(ptr, 0, &status);
vec_float_push_back(ptr, 0, &status);
if (status.flags != 0)
{
__origin_override(err, "INSERT");
err->flags |= status.flags;
return;
}
for (size_t i = ptr->_internal_size - 1; i > iter; i--)
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;
}
__attribute__((overloadable)) void
_vec_char_insert(_VecCharInternal* ptr, const size_t iter, const size_t amount,
const char val, err_t* err)
vec_float_insert(vec_float* ptr, const size_t iter, const size_t amount,
const float val, err_t* err)
{
err_t status = ERR_T_INIT;
__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;
return;
}
if (iter > ptr->_internal_size)
if (iter > ptr->size)
{
__origin_override(err, "INSERT");
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++)
{
_vec_char_insert(ptr, i, val, &status);
vec_float_insert(ptr, i, val, &status);
if (status.flags != 0)
{
__origin_override(err, "INSERT");
@@ -897,9 +851,8 @@ _vec_char_insert(_VecCharInternal* ptr, const size_t iter, const size_t amount,
}
__attribute__((overloadable)) void
_vec_char_insert(_VecCharInternal* ptr, const _VecCharInternal* iterator,
const size_t iter, const size_t iter_start,
const size_t iter_end, err_t* err)
vec_float_insert(vec_float* ptr, const vec_float* iterator, const size_t iter,
const size_t iter_start, const size_t iter_end, err_t* err)
{
err_t status = ERR_T_INIT;
__null_check(ptr, &status);
@@ -910,14 +863,14 @@ _vec_char_insert(_VecCharInternal* ptr, const _VecCharInternal* iterator,
err->flags |= status.flags;
return;
}
if (iter_end <= iter_start || iter_end > iterator->_internal_size ||
iter > ptr->_internal_size)
if (iter_end <= iter_start || iter_end > iterator->size ||
iter > ptr->size)
{
__origin_override(err, "INSERT");
err->flags |= ERR_OUT_OF_BOUNDS;
return;
}
if (ptr->_internal_arr == iterator->_internal_arr)
if (ptr->array == iterator->array)
{
__origin_override(err, "INSERT");
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++)
{
_vec_char_insert(ptr, iter + (i - iter_start),
iterator->_internal_arr[i], &status);
vec_float_insert(ptr, iter + (i - iter_start),
iterator->array[i], &status);
if (status.flags != 0)
{
__origin_override(err, "INSERT");
src/int.c
+174 -220
View File
@@ -5,7 +5,7 @@
#include <string.h>
__attribute__((overloadable)) size_t
__null_check(const _VecIntInternal* ptr, err_t* status)
__null_check(const vec_int* ptr, err_t* status)
{
if (status == nullptr)
{
@@ -16,7 +16,7 @@ __null_check(const _VecIntInternal* ptr, err_t* status)
status->flags |= ERR_VEC_NULL;
return ERR_VEC_NULL;
}
if (ptr->_internal_arr == nullptr)
if (ptr->array == nullptr)
{
status->flags |= ERR_BUF_NULL;
}
@@ -24,62 +24,24 @@ __null_check(const _VecIntInternal* ptr, err_t* status)
return status->flags;
}
__attribute__((overloadable)) size_t
__null_check(const int* ptr, err_t* status)
{
if (status == nullptr)
{
return ERR_ERR_T_NULL;
}
if (ptr == nullptr)
{
status->flags |= ERR_BUF_NULL;
}
return status->flags;
}
size_t
__origin_override(err_t* status, char* str)
{
if (status == nullptr)
{
return ERR_ERR_T_NULL;
}
if (status->origin != nullptr)
{
status->flags |= ERR_ORIGIN_UNALTERABLE;
return status->flags;
}
else if (str == nullptr)
{
status->flags |= ERR_STR_NULL;
return status->flags;
}
else
{
status->origin = str;
return status->flags;
}
}
void
_vec_int_print_vec(const _VecIntInternal* ptr, err_t* err)
vec_int_print_vec(const vec_int* ptr, err_t* err)
{
if (__null_check(ptr, err) != 0)
{
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");
}
_VecIntInternal
_vec_int_cpy(const int* src, const size_t src_size, err_t* err)
vec_int
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;
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;
return self;
}
if (src_size > self._internal_max_size)
if (src_size > self.max_size)
{
__origin_override(err, "CPY");
err->flags |= ERR_SIZE_OVERFLOW;
return self;
}
self._internal_arr = malloc(src_size * sizeof(int));
if (self._internal_arr == nullptr)
self.array = malloc(src_size * sizeof(int));
if (self.array == nullptr)
{
__origin_override(err, "CPY");
err->flags |= ERR_ALLOC_FAIL;
return self;
}
memcpy(self._internal_arr, src, src_size * sizeof(int));
self._internal_size = src_size;
self._internal_capacity = src_size;
memcpy(self.array, src, src_size * sizeof(int));
self.size = src_size;
self.capacity = src_size;
return self;
}
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;
int* res;
@@ -132,7 +94,7 @@ _vec_int_push_back(_VecIntInternal* ptr, const int val, err_t* err)
return;
}
if (ptr->_internal_size + 1 > ptr->_internal_max_size)
if (ptr->size + 1 > ptr->max_size)
{
__origin_override(err, "PUSH_BACK");
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;
return;
}
ptr->_internal_arr = res;
ptr->_internal_capacity = 1;
ptr->_internal_size = 0;
ptr->array = res;
ptr->capacity = 1;
ptr->size = 0;
}
else if (ptr->_internal_size + 1 > ptr->_internal_capacity)
else if (ptr->size + 1 > ptr->capacity)
{
size_t dst_cap =
(ptr->_internal_capacity / 2) + ptr->_internal_capacity;
if (dst_cap == ptr->_internal_capacity)
size_t dst_cap = (ptr->capacity / 2) + ptr->capacity;
if (dst_cap == ptr->capacity)
{
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(
"Capacity cannot be grown any further due "
"to hitting max size");
}
res = realloc(ptr->_internal_arr, dst_cap * sizeof(int));
res = realloc(ptr->array, dst_cap * sizeof(int));
if (res == nullptr)
{
__origin_override(err, "PUSH_BACK");
err->flags |= ERR_SIZE_OVERFLOW;
return;
}
ptr->_internal_arr = res;
ptr->_internal_capacity = dst_cap;
ptr->array = res;
ptr->capacity = dst_cap;
}
ptr->_internal_arr[ptr->_internal_size] = val;
ptr->_internal_size++;
ptr->array[ptr->size] = val;
ptr->size++;
return;
}
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)
{
@@ -192,19 +153,19 @@ _vec_int_pop_back(_VecIntInternal* ptr, err_t* err)
return;
}
if (ptr->_internal_size == 0)
if (ptr->size == 0)
{
__origin_override(err, "POP_BACK");
err->flags |= ERR_SIZE_ZERO;
return;
}
ptr->_internal_arr[ptr->_internal_size - 1] = 0;
ptr->_internal_size--;
ptr->array[ptr->size - 1] = 0;
ptr->size--;
}
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;
if (__null_check(ptr, &status) != 0)
@@ -216,7 +177,7 @@ _vec_int_reserve(_VecIntInternal* ptr, const size_t capacity, err_t* err)
return;
}
}
if (ptr->_internal_max_size < capacity)
if (ptr->max_size < capacity)
{
__origin_override(err, "RESERVE");
err->flags |= ERR_SIZE_OVERFLOW;
@@ -229,24 +190,24 @@ _vec_int_reserve(_VecIntInternal* ptr, const size_t capacity, err_t* err)
return;
}
int* res = realloc(ptr->_internal_arr, capacity * sizeof(int));
int* res = realloc(ptr->array, capacity * sizeof(int));
if (res == nullptr)
{
__origin_override(err, "RESERVE");
err->flags |= ERR_ALLOC_FAIL;
return;
}
ptr->_internal_arr = res;
ptr->_internal_capacity = capacity;
if (ptr->_internal_size > capacity)
ptr->array = res;
ptr->capacity = capacity;
if (ptr->size > capacity)
{
ptr->_internal_size = capacity;
ptr->size = capacity;
}
return;
}
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;
if (__null_check(ptr, &status) != 0)
@@ -255,17 +216,17 @@ _vec_int_shrink_to_fit(_VecIntInternal* ptr, err_t* err)
err->flags |= status.flags;
return;
}
if (ptr->_internal_size == 0)
if (ptr->size == 0)
{
__origin_override(err, "SHRINK_TO_FIT");
err->flags |= ERR_SIZE_ZERO;
return;
}
_vec_int_reserve(ptr, ptr->_internal_size, err);
vec_int_reserve(ptr, ptr->size, err);
}
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;
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;
return;
}
_VecIntInternal self = *ptr_a;
vec_int self = *ptr_a;
*ptr_a = *ptr_b;
*ptr_b = self;
return;
}
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;
if (__null_check(ptr, &status) != 0)
@@ -291,11 +252,11 @@ _vec_int_data(const _VecIntInternal* ptr, err_t* err)
err->flags |= status.flags;
return nullptr;
}
return &ptr->_internal_arr[0];
return &ptr->array[0];
}
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;
if (__null_check(ptr, &status) != 0)
@@ -304,11 +265,11 @@ _vec_int_size(const _VecIntInternal* ptr, err_t* err)
err->flags |= status.flags;
return 0;
}
return ptr->_internal_size;
return ptr->size;
}
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;
if (__null_check(ptr, &status) != 0)
@@ -317,11 +278,11 @@ _vec_int_capacity(const _VecIntInternal* ptr, err_t* err)
err->flags |= status.flags;
return 0;
}
return ptr->_internal_capacity;
return ptr->capacity;
}
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;
if (__null_check(ptr, &status) != 0)
@@ -330,11 +291,11 @@ _vec_int_max_size(const _VecIntInternal* ptr, err_t* err)
err->flags |= status.flags;
return 0;
}
return ptr->_internal_max_size;
return ptr->max_size;
}
void
_vec_int_delete(_VecIntInternal* ptr, err_t* err)
vec_int_delete(vec_int* ptr, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
@@ -343,17 +304,17 @@ _vec_int_delete(_VecIntInternal* ptr, err_t* err)
err->flags |= status.flags;
return;
}
if (ptr->_internal_arr != nullptr)
if (ptr->array != nullptr)
{
free(ptr->_internal_arr);
ptr->_internal_arr = nullptr;
free(ptr->array);
ptr->array = nullptr;
}
ptr->_internal_size = 0;
ptr->_internal_capacity = 0;
ptr->size = 0;
ptr->capacity = 0;
}
void
_vec_int_clear(_VecIntInternal* ptr, err_t* err)
vec_int_clear(vec_int* ptr, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
@@ -362,16 +323,15 @@ _vec_int_clear(_VecIntInternal* ptr, err_t* err)
err->flags |= status.flags;
return;
}
if (ptr->_internal_size > 0)
if (ptr->size > 0)
{
memset(ptr->_internal_arr, 0,
ptr->_internal_size * sizeof(int));
ptr->_internal_size = 0;
memset(ptr->array, 0, ptr->size * sizeof(int));
ptr->size = 0;
}
}
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;
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;
return nullptr;
}
if (idx >= ptr->_internal_size)
if (idx >= ptr->size)
{
__origin_override(err, "AT");
err->flags |= ERR_OUT_OF_BOUNDS;
return nullptr;
}
return &ptr->_internal_arr[idx];
return &ptr->array[idx];
}
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;
if (__null_check(ptr, &status) != 0)
@@ -403,7 +363,7 @@ _vec_int_begin(const _VecIntInternal* ptr, err_t* err)
}
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;
if (__null_check(ptr, &status) != 0)
@@ -412,17 +372,17 @@ _vec_int_end(const _VecIntInternal* ptr, err_t* err)
err->flags |= status.flags;
return status.flags;
}
if (ptr->_internal_size == 0)
if (ptr->size == 0)
{
__origin_override(err, "END");
err->flags |= ERR_SIZE_ZERO;
return status.flags;
}
return (size_t)(ptr->_internal_size - 1);
return (size_t)(ptr->size - 1);
}
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;
if (__null_check(ptr, &status) != 0)
@@ -431,16 +391,16 @@ _vec_int_front(const _VecIntInternal* ptr, err_t* err)
err->flags |= status.flags;
return -1;
}
if (_vec_int_at(ptr, 0, err) == nullptr)
if (vec_int_at(ptr, 0, err) == nullptr)
{
err->flags |= ERR_OUT_OF_BOUNDS;
return 0;
}
return *_vec_int_at(ptr, 0, err);
return *vec_int_at(ptr, 0, err);
}
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;
if (__null_check(ptr, &status) != 0)
@@ -449,16 +409,16 @@ _vec_int_back(const _VecIntInternal* ptr, err_t* err)
err->flags |= status.flags;
return -1;
}
if (_vec_int_at(ptr, 0, err) == nullptr)
if (vec_int_at(ptr, 0, err) == nullptr)
{
err->flags |= ERR_OUT_OF_BOUNDS;
return 0;
}
return *_vec_int_at(ptr, ptr->_internal_size - 1, err);
return *vec_int_at(ptr, ptr->size - 1, err);
}
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;
if (__null_check(ptr, &status) != 0)
@@ -467,15 +427,15 @@ _vec_int_empty(const _VecIntInternal* ptr, err_t* err)
err->flags |= status.flags;
return status.flags;
}
if (ptr->_internal_size == 0)
if (ptr->size == 0)
{
return ptr->_internal_size;
return ptr->size;
}
return status.flags;
}
__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;
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;
return;
}
if (iter >= ptr->_internal_size)
if (iter >= ptr->size)
{
return;
}
memmove(&ptr->_internal_arr[iter], &ptr->_internal_arr[iter + 1],
(ptr->_internal_size - iter - 1) * sizeof(int));
ptr->_internal_arr[ptr->_internal_size - 1] = 0;
ptr->_internal_size--;
memmove(&ptr->array[iter], &ptr->array[iter + 1],
(ptr->size - iter - 1) * sizeof(int));
ptr->array[ptr->size - 1] = 0;
ptr->size--;
return;
}
__attribute__((overloadable)) void
_vec_int_erase(_VecIntInternal* ptr, const size_t iter_start,
const size_t iter_end, err_t* err)
vec_int_erase(vec_int* ptr, const size_t iter_start, const size_t iter_end,
err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
@@ -507,23 +467,22 @@ _vec_int_erase(_VecIntInternal* ptr, const size_t iter_start,
return;
}
if (ptr->_internal_size < iter_end || iter_end <= iter_start)
if (ptr->size < iter_end || iter_end <= iter_start)
{
__origin_override(err, "ERASE");
err->flags |= ERR_OUT_OF_BOUNDS;
return;
}
size_t diff = iter_end - iter_start;
memmove(&ptr->_internal_arr[iter_start], &ptr->_internal_arr[iter_end],
(ptr->_internal_size - iter_end) * sizeof(int));
memset(&ptr->_internal_arr[ptr->_internal_size - diff], 0,
sizeof(int) * diff);
ptr->_internal_size -= diff;
memmove(&ptr->array[iter_start], &ptr->array[iter_end],
(ptr->size - iter_end) * sizeof(int));
memset(&ptr->array[ptr->size - diff], 0, sizeof(int) * diff);
ptr->size -= diff;
return;
}
__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;
__null_check(ptr, &status);
@@ -534,87 +493,85 @@ _vec_int_resize(_VecIntInternal* ptr, const size_t size, err_t* err)
return;
}
if (ptr->_internal_size == size)
if (ptr->size == size)
{
__origin_override(err, "RESIZE");
err->flags |= ERR_OUT_OF_BOUNDS;
return;
}
else if (size > ptr->_internal_max_size)
else if (size > ptr->max_size)
{
__origin_override(err, "RESIZE");
err->flags |= ERR_SIZE_OVERFLOW;
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;
_vec_int_reserve(ptr, size, &verr);
vec_int_reserve(ptr, size, &verr);
if (verr.flags != 0)
{
__origin_override(err, "RESIZE");
err->flags |= verr.flags;
return;
}
if (ptr->_internal_capacity != size)
if (ptr->capacity != size)
{
__origin_override(err, "RESIZE");
err->flags |= ERR_ALLOC_FAIL;
return;
}
memset(ptr->_internal_arr, 0, size * sizeof(int));
ptr->_internal_max_size = max;
ptr->_internal_size = size;
memset(ptr->array, 0, size * sizeof(int));
ptr->max_size = max;
ptr->size = size;
return;
}
else if (size > ptr->_internal_capacity)
else if (size > ptr->capacity)
{
size_t tmpcp = ptr->_internal_capacity;
size_t tmpmx = ptr->_internal_max_size;
size_t tmpcp = ptr->capacity;
size_t tmpmx = ptr->max_size;
err_t verr = ERR_T_INIT;
while (size > tmpcp)
{
tmpcp *= 2;
}
if (tmpcp > ptr->_internal_max_size)
if (tmpcp > ptr->max_size)
{
tmpcp = size;
}
_vec_int_reserve(ptr, tmpcp, &verr);
vec_int_reserve(ptr, tmpcp, &verr);
if (verr.flags != 0)
{
__origin_override(err, "RESIZE");
err->flags |= verr.flags;
return;
}
if (ptr->_internal_capacity != tmpcp)
if (ptr->capacity != tmpcp)
{
__origin_override(err, "RESIZE");
err->flags |= ERR_ALLOC_FAIL;
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,
(ptr->_internal_size - size) * sizeof(int));
memset(&ptr->array[size], 0, (ptr->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,
(size - ptr->_internal_size) * sizeof(int));
memset(&ptr->array[ptr->size], 0,
(size - ptr->size) * sizeof(int));
}
ptr->_internal_size = size;
ptr->size = size;
return;
}
__attribute__((overloadable)) void
_vec_int_resize(_VecIntInternal* ptr, const size_t size, const int val,
err_t* err)
vec_int_resize(vec_int* ptr, const size_t size, const int val, err_t* err)
{
err_t status = ERR_T_INIT;
__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;
return;
}
if (ptr->_internal_size == size)
if (ptr->size == size)
{
__origin_override(err, "RESIZE");
err->flags |= ERR_OUT_OF_BOUNDS;
return;
}
else if (size > ptr->_internal_max_size)
else if (size > ptr->max_size)
{
__origin_override(err, "RESIZE");
err->flags |= ERR_SIZE_OVERFLOW;
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;
_vec_int_reserve(ptr, size, &verr);
vec_int_reserve(ptr, size, &verr);
if (verr.flags != 0)
{
__origin_override(err, "RESIZE");
err->flags |= verr.flags;
return;
}
if (ptr->_internal_capacity != size)
if (ptr->capacity != size)
{
__origin_override(err, "RESIZE");
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++)
{
ptr->_internal_arr[i] = val;
ptr->array[i] = val;
}
ptr->_internal_max_size = max;
ptr->_internal_size = size;
ptr->max_size = max;
ptr->size = size;
return;
}
else if (size > ptr->_internal_capacity)
else if (size > ptr->capacity)
{
size_t tmpcp = ptr->_internal_capacity;
size_t tmpmx = ptr->_internal_max_size;
size_t tmpcp = ptr->capacity;
size_t tmpmx = ptr->max_size;
err_t verr = ERR_T_INIT;
while (size > tmpcp)
{
tmpcp *= 2;
}
if (tmpcp > ptr->_internal_max_size)
if (tmpcp > ptr->max_size)
{
tmpcp = size;
}
_vec_int_reserve(ptr, tmpcp, &verr);
vec_int_reserve(ptr, tmpcp, &verr);
if (verr.flags != 0)
{
__origin_override(err, "RESIZE");
err->flags |= verr.flags;
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;
}
__attribute__((overloadable)) void
_vec_int_assign(_VecIntInternal* ptr, const _VecIntInternal* iterator,
const size_t iter_start, const size_t iter_end, err_t* err)
vec_int_assign(vec_int* ptr, const vec_int* iterator, const size_t iter_start,
const size_t iter_end, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0 ||
@@ -715,27 +672,27 @@ _vec_int_assign(_VecIntInternal* ptr, const _VecIntInternal* iterator,
err->flags |= status.flags;
return;
}
if (ptr->_internal_arr == iterator->_internal_arr)
if (ptr->array == iterator->array)
{
__origin_override(err, "ASSIGN");
err->flags |= ERR_DOUBLE_BUF;
return;
}
if (iterator->_internal_size < iter_end || iter_end <= iter_start)
if (iterator->size < iter_end || iter_end <= iter_start)
{
__origin_override(err, "ASSIGN");
err->flags |= ERR_OUT_OF_BOUNDS;
return;
}
_vec_int_erase(ptr, _vec_int_begin(ptr, &status),
_vec_int_end(ptr, &status) + 1, &status);
vec_int_erase(ptr, vec_int_begin(ptr, &status),
vec_int_end(ptr, &status) + 1, &status);
if (status.flags != 0)
{
__origin_override(err, "ASSIGN");
err->flags |= status.flags;
return;
}
_vec_int_reserve(ptr, (iter_end - iter_start), &status);
vec_int_reserve(ptr, (iter_end - iter_start), &status);
if (status.flags != 0)
{
__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++)
{
int* res = _vec_int_at(iterator, i, &status);
int* res = vec_int_at(iterator, i, &status);
if (res == nullptr)
{
err->flags |= ERR_OUT_OF_BOUNDS;
return;
}
_vec_int_push_back(ptr, *res, &status);
vec_int_push_back(ptr, *res, &status);
if (status.flags != 0)
{
__origin_override(err, "ASSIGN");
@@ -762,8 +719,7 @@ _vec_int_assign(_VecIntInternal* ptr, const _VecIntInternal* iterator,
}
__attribute__((overloadable)) void
_vec_int_assign(_VecIntInternal* ptr, const size_t amount, const int val,
err_t* err)
vec_int_assign(vec_int* ptr, const size_t amount, const int val, err_t* err)
{
err_t status = ERR_T_INIT;
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;
return;
}
_vec_int_erase(ptr, _vec_int_begin(ptr, &status),
_vec_int_end(ptr, &status) + 1, &status);
vec_int_erase(ptr, vec_int_begin(ptr, &status),
vec_int_end(ptr, &status) + 1, &status);
if (status.flags != 0)
{
__origin_override(err, "ASSIGN");
err->flags |= status.flags;
return;
}
_vec_int_reserve(ptr, amount, &status);
vec_int_reserve(ptr, amount, &status);
if (status.flags != 0)
{
__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++)
{
_vec_int_push_back(ptr, val, &status);
vec_int_push_back(ptr, val, &status);
if (status.flags != 0)
{
__origin_override(err, "ASSIGN");
@@ -807,8 +763,7 @@ _vec_int_assign(_VecIntInternal* ptr, const size_t amount, const int val,
}
__attribute__((overloadable)) void
_vec_int_insert(_VecIntInternal* ptr, const size_t iter, const int val,
err_t* err)
vec_int_insert(vec_int* ptr, const size_t iter, const int val, err_t* err)
{
err_t status = ERR_T_INIT;
__null_check(ptr, &status);
@@ -827,43 +782,43 @@ _vec_int_insert(_VecIntInternal* ptr, const size_t iter, const int val,
err->flags |= ERR_BUF_NULL;
return;
}
ptr->_internal_arr = res;
ptr->_internal_capacity = 1;
ptr->_internal_arr[0] = val;
ptr->_internal_size = 1;
ptr->array = res;
ptr->capacity = 1;
ptr->array[0] = val;
ptr->size = 1;
return;
}
if (ptr->_internal_max_size < ptr->_internal_size + 1)
if (ptr->max_size < ptr->size + 1)
{
__origin_override(err, "INSERT");
err->flags |= ERR_SIZE_OVERFLOW;
return;
}
if (iter > ptr->_internal_size)
if (iter > ptr->size)
{
__origin_override(err, "INSERT");
err->flags |= ERR_OUT_OF_BOUNDS;
return;
}
_vec_int_push_back(ptr, 0, &status);
vec_int_push_back(ptr, 0, &status);
if (status.flags != 0)
{
__origin_override(err, "INSERT");
err->flags |= status.flags;
return;
}
for (size_t i = ptr->_internal_size - 1; i > iter; i--)
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;
}
__attribute__((overloadable)) void
_vec_int_insert(_VecIntInternal* ptr, const size_t iter, const size_t amount,
const int val, err_t* err)
vec_int_insert(vec_int* ptr, const size_t iter, const size_t amount,
const int val, err_t* err)
{
err_t status = ERR_T_INIT;
__null_check(ptr, &status);
@@ -873,7 +828,7 @@ _vec_int_insert(_VecIntInternal* ptr, const size_t iter, const size_t amount,
err->flags |= status.flags;
return;
}
if (iter > ptr->_internal_size)
if (iter > ptr->size)
{
__origin_override(err, "INSERT");
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++)
{
_vec_int_insert(ptr, i, val, &status);
vec_int_insert(ptr, i, val, &status);
if (status.flags != 0)
{
__origin_override(err, "INSERT");
@@ -899,9 +854,8 @@ _vec_int_insert(_VecIntInternal* ptr, const size_t iter, const size_t amount,
}
__attribute__((overloadable)) void
_vec_int_insert(_VecIntInternal* ptr, const _VecIntInternal* iterator,
const size_t iter, const size_t iter_start,
const size_t iter_end, err_t* err)
vec_int_insert(vec_int* ptr, const vec_int* iterator, const size_t iter,
const size_t iter_start, const size_t iter_end, err_t* err)
{
err_t status = ERR_T_INIT;
__null_check(ptr, &status);
@@ -912,14 +866,14 @@ _vec_int_insert(_VecIntInternal* ptr, const _VecIntInternal* iterator,
err->flags |= status.flags;
return;
}
if (iter_end <= iter_start || iter_end > iterator->_internal_size ||
iter > ptr->_internal_size)
if (iter_end <= iter_start || iter_end > iterator->size ||
iter > ptr->size)
{
__origin_override(err, "INSERT");
err->flags |= ERR_OUT_OF_BOUNDS;
return;
}
if (ptr->_internal_arr == iterator->_internal_arr)
if (ptr->array == iterator->array)
{
__origin_override(err, "INSERT");
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++)
{
_vec_int_insert(ptr, iter + (i - iter_start),
iterator->_internal_arr[i], &status);
vec_int_insert(ptr, iter + (i - iter_start), iterator->array[i],
&status);
if (status.flags != 0)
{
__origin_override(err, "INSERT");
src/main.c
+3 -2
View File
@@ -41,7 +41,8 @@ main()
unsigned int mask = 0;
mask = ERR_BUF_NULL ^ status.flags;
print_bits(mask);
print_bits(status.flags);
vec_print_bits(mask);
vec_print_bits(status.flags);
vec_print_errs(status);
return 0;
}
src/utils.c
+41 -20
View File
@@ -38,18 +38,13 @@ vec_print_errs(const err_t err)
void
print_bits(unsigned int num)
{
// Determine the number of bits in an unsigned int (usually 32)
int total_bits = sizeof(num) * 8;
unsigned int total_bits = sizeof(num) * 8;
// Loop from the most significant bit (MSB) down to the least
// significant bit (LSB)
for (int i = total_bits - 1; i >= 0; i--)
for (unsigned int i = total_bits - 1; i >= 0; i--)
{
// Shift a 1 to the i-th position and check if that bit is set
int bit = (num >> i) & 1;
printf("%d", bit);
unsigned int bit = (num >> i) & 1;
printf("%d ", bit);
// Optional: Add a space every 4 or 8 bits for readability
if (i % 8 == 0)
{
printf(" ");
@@ -58,14 +53,40 @@ print_bits(unsigned int num)
printf("\n");
}
// void
// _vec_update_origin(err_t* err, char* str)
// {
// err_t res;
// if (err == nullptr)
// {
// res.err = 0;
// res.value = 0;
// }
// if (!err->origin) err->origin = str;
// }
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;
}
}
__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;
}