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

API: Cutting my losses and having singular types and files for the 4

Browse Source 
types { char, int, float, string } and can come back later to make it
one type to call.

GITIGNORE: Added tests and Makefile to cleanup fuzzyfinder but dont need
them pushed either as I have enough testing done.
This commit is contained in:
DarthMooMancer
2026-10-14 09:48:58 -04:00
parent b89579a5e7
commit 813390b6ac
18 changed files with 2322 additions and 213 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/.DS_Store
Vendored
BIN
View File
Binary file not shown.
src/lib/char/char.c → src/char.c
+2 -3
View File
@@ -1,12 +1,11 @@
#include "char.h"
#include "libvec/char.h"
#include <libvec/utils.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "utils/utils.h"
__attribute__((overloadable)) size_t
__null_check(const _VecCharInternal* ptr, err_t* status)
{
src/float.c
+938
View File
@@ -0,0 +1,938 @@
#include <libvec/float.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
__attribute__((overloadable)) size_t
__null_check(const _VecCharInternal* ptr, err_t* status)
{
if (status == nullptr)
{
return ERR_ERR_T_NULL;
}
if (ptr == nullptr)
{
status->flags |= ERR_VEC_NULL;
return ERR_VEC_NULL;
}
if (ptr->_internal_arr == nullptr)
{
status->flags |= ERR_BUF_NULL;
}
return status->flags;
}
__attribute__((overloadable)) size_t
__null_check(const char* ptr, err_t* status)
{
if (status == nullptr)
{
return ERR_ERR_T_NULL;
}
if (ptr == nullptr)
{
status->flags |= ERR_BUF_NULL;
}
return status->flags;
}
size_t
__origin_override(err_t* status, char* str)
{
if (status == nullptr)
{
return ERR_ERR_T_NULL;
}
if (status->origin != nullptr)
{
status->flags |= ERR_ORIGIN_UNALTERABLE;
return status->flags;
}
else if (str == nullptr)
{
status->flags |= ERR_STR_NULL;
return status->flags;
}
else
{
status->origin = str;
return status->flags;
}
}
void
_vec_char_print_vec(const _VecCharInternal* ptr, err_t* err)
{
if (__null_check(ptr, err) != 0)
{
return;
}
for (size_t i = 0; i < ptr->_internal_size; i++)
{
printf("%c ", ptr->_internal_arr[i]);
}
printf("\n");
}
_VecCharInternal
_vec_char_cpy(const char* src, const size_t src_size, err_t* err)
{
_VecCharInternal self = VEC_INIT;
err_t status = ERR_T_INIT;
size_t null = __null_check(src, err);
if (null != 0)
{
if (null & ERR_ERR_T_NULL)
{
return self;
}
__origin_override(err, "CPY");
err->flags |= status.flags;
return self;
}
if (src_size == 0)
{
__origin_override(err, "CPY");
err->flags |= ERR_SIZE_ZERO;
err->flags |= status.flags;
return self;
}
if (src_size > self._internal_max_size)
{
__origin_override(err, "CPY");
err->flags |= ERR_SIZE_OVERFLOW;
return self;
}
self._internal_arr = malloc(src_size * sizeof(char));
if (self._internal_arr == nullptr)
{
__origin_override(err, "CPY");
err->flags |= ERR_ALLOC_FAIL;
return self;
}
memcpy(self._internal_arr, src, src_size * sizeof(char));
self._internal_size = src_size;
self._internal_capacity = src_size;
return self;
}
void
_vec_char_push_back(_VecCharInternal* ptr, const char val, err_t* err)
{
err_t status = ERR_T_INIT;
char* res;
__null_check(ptr, &status);
if ((status.flags & ERR_VEC_NULL) != 0)
{
__origin_override(err, "PUSH_BACK");
err->flags |= ERR_VEC_NULL;
return;
}
if (ptr->_internal_size + 1 > ptr->_internal_max_size)
{
__origin_override(err, "PUSH_BACK");
err->flags |= ERR_SIZE_OVERFLOW;
return;
}
if ((status.flags & ERR_BUF_NULL) != 0)
{
res = malloc(1 * sizeof(char));
if (res == nullptr)
{
__origin_override(err, "PUSH_BACK");
err->flags |= ERR_ALLOC_FAIL;
return;
}
ptr->_internal_arr = res;
ptr->_internal_capacity = 1;
ptr->_internal_size = 0;
}
else if (ptr->_internal_size + 1 > ptr->_internal_capacity)
{
size_t dst_cap =
(ptr->_internal_capacity / 2) + ptr->_internal_capacity;
if (dst_cap == ptr->_internal_capacity)
{
dst_cap++;
}
if (dst_cap > ptr->_internal_max_size)
{
dst_cap = ptr->_internal_max_size;
DEBUG(
"Capacity cannot be grown any further due "
"to hitting max size");
}
res = realloc(ptr->_internal_arr, dst_cap * sizeof(char));
if (res == nullptr)
{
__origin_override(err, "PUSH_BACK");
err->flags |= ERR_SIZE_OVERFLOW;
return;
}
ptr->_internal_arr = res;
ptr->_internal_capacity = dst_cap;
}
ptr->_internal_arr[ptr->_internal_size] = val;
ptr->_internal_size++;
return;
}
void
_vec_char_pop_back(_VecCharInternal* ptr, err_t* err)
{
if (__null_check(ptr, err) != 0)
{
__origin_override(err, "POP_BACK");
return;
}
if (ptr->_internal_size == 0)
{
__origin_override(err, "POP_BACK");
err->flags |= ERR_SIZE_ZERO;
return;
}
ptr->_internal_arr[ptr->_internal_size - 1] = 0;
ptr->_internal_size--;
}
void
_vec_char_reserve(_VecCharInternal* ptr, const size_t capacity, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
{
if ((status.flags & ERR_VEC_NULL) != 0)
{
__origin_override(err, "RESERVE");
err->flags |= ERR_VEC_NULL;
return;
}
}
if (ptr->_internal_max_size < capacity)
{
__origin_override(err, "RESERVE");
err->flags |= ERR_SIZE_OVERFLOW;
return;
}
if (capacity == 0)
{
__origin_override(err, "RESERVE");
err->flags |= ERR_SIZE_ZERO;
return;
}
char* res = realloc(ptr->_internal_arr, capacity * sizeof(char));
if (res == nullptr)
{
__origin_override(err, "RESERVE");
err->flags |= ERR_ALLOC_FAIL;
return;
}
ptr->_internal_arr = res;
ptr->_internal_capacity = capacity;
if (ptr->_internal_size > capacity)
{
ptr->_internal_size = capacity;
}
return;
}
void
_vec_char_shrink_to_fit(_VecCharInternal* ptr, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
{
__origin_override(err, "SHRINK_TO_FIT");
err->flags |= status.flags;
return;
}
if (ptr->_internal_size == 0)
{
__origin_override(err, "SHRINK_TO_FIT");
err->flags |= ERR_SIZE_ZERO;
return;
}
_vec_char_reserve(ptr, ptr->_internal_size, err);
}
void
_vec_char_swap(_VecCharInternal* ptr_a, _VecCharInternal* ptr_b, err_t* err)
{
err_t status_1 = ERR_T_INIT, status_2 = ERR_T_INIT;
if ((__null_check(ptr_a, &status_1) & ERR_VEC_NULL) != 0 ||
(__null_check(ptr_b, &status_2) & ERR_VEC_NULL) != 0)
{
__origin_override(err, "SWAP");
err->flags |= ERR_VEC_NULL;
return;
}
_VecCharInternal self = *ptr_a;
*ptr_a = *ptr_b;
*ptr_b = self;
return;
}
const char*
_vec_char_data(const _VecCharInternal* ptr, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
{
__origin_override(err, "DATA");
err->flags |= status.flags;
return nullptr;
}
return &ptr->_internal_arr[0];
}
size_t
_vec_char_size(const _VecCharInternal* ptr, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
{
__origin_override(err, "SIZE");
err->flags |= status.flags;
return 0;
}
return ptr->_internal_size;
}
size_t
_vec_char_capacity(const _VecCharInternal* ptr, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
{
__origin_override(err, "CAPACITY");
err->flags |= status.flags;
return 0;
}
return ptr->_internal_capacity;
}
size_t
_vec_char_max_size(const _VecCharInternal* ptr, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
{
__origin_override(err, "MAX_SIZE");
err->flags |= status.flags;
return 0;
}
return ptr->_internal_max_size;
}
void
_vec_char_delete(_VecCharInternal* ptr, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
{
__origin_override(err, "DELETE");
err->flags |= status.flags;
return;
}
if (ptr->_internal_arr != nullptr)
{
free(ptr->_internal_arr);
ptr->_internal_arr = nullptr;
}
ptr->_internal_size = 0;
ptr->_internal_capacity = 0;
}
void
_vec_char_clear(_VecCharInternal* ptr, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
{
__origin_override(err, "CLEAR");
err->flags |= status.flags;
return;
}
if (ptr->_internal_size > 0)
{
memset(ptr->_internal_arr, 0, ptr->_internal_size);
ptr->_internal_size = 0;
}
}
char*
_vec_char_at(const _VecCharInternal* ptr, const size_t idx, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
{
__origin_override(err, "AT");
err->flags |= status.flags;
return nullptr;
}
if (idx >= ptr->_internal_size)
{
__origin_override(err, "AT");
err->flags |= ERR_OUT_OF_BOUNDS;
return nullptr;
}
return &ptr->_internal_arr[idx];
}
size_t
_vec_char_begin(const _VecCharInternal* ptr, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
{
__origin_override(err, "BEGIN");
err->flags |= status.flags;
return status.flags;
}
return 0;
}
size_t
_vec_char_end(const _VecCharInternal* ptr, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
{
__origin_override(err, "END");
err->flags |= status.flags;
return status.flags;
}
if (ptr->_internal_size == 0)
{
__origin_override(err, "END");
err->flags |= ERR_SIZE_ZERO;
return status.flags;
}
return (size_t)(ptr->_internal_size - 1);
}
char
_vec_char_front(const _VecCharInternal* ptr, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
{
__origin_override(err, "FRONT");
err->flags |= status.flags;
return -1;
}
if (_vec_char_at(ptr, 0, err) == nullptr)
{
err->flags |= ERR_OUT_OF_BOUNDS;
return 0;
}
return *_vec_char_at(ptr, 0, err);
}
char
_vec_char_back(const _VecCharInternal* ptr, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
{
__origin_override(err, "BACK");
err->flags |= status.flags;
return -1;
}
if (_vec_char_at(ptr, 0, err) == nullptr)
{
err->flags |= ERR_OUT_OF_BOUNDS;
return 0;
}
return *_vec_char_at(ptr, ptr->_internal_size - 1, err);
}
size_t
_vec_char_empty(const _VecCharInternal* ptr, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
{
__origin_override(err, "EMPTY");
err->flags |= status.flags;
return status.flags;
}
if (ptr->_internal_size == 0)
{
return ptr->_internal_size;
}
return status.flags;
}
__attribute__((overloadable)) void
_vec_char_erase(_VecCharInternal* ptr, const size_t iter, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
{
__origin_override(err, "ERASE");
err->flags |= status.flags;
return;
}
if (iter >= ptr->_internal_size)
{
return;
}
memmove(&ptr->_internal_arr[iter], &ptr->_internal_arr[iter + 1],
(ptr->_internal_size - iter - 1) * sizeof(char));
ptr->_internal_arr[ptr->_internal_size - 1] = 0;
ptr->_internal_size--;
return;
}
__attribute__((overloadable)) void
_vec_char_erase(_VecCharInternal* ptr, const size_t iter_start,
const size_t iter_end, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
{
__origin_override(err, "ERASE");
err->flags |= status.flags;
return;
}
if (ptr->_internal_size < iter_end || iter_end <= iter_start)
{
__origin_override(err, "ERASE");
err->flags |= ERR_OUT_OF_BOUNDS;
return;
}
size_t diff = iter_end - iter_start;
memmove(&ptr->_internal_arr[iter_start], &ptr->_internal_arr[iter_end],
(ptr->_internal_size - iter_end) * sizeof(char));
memset(&ptr->_internal_arr[ptr->_internal_size - diff], 0,
sizeof(char) * diff);
ptr->_internal_size -= diff;
return;
}
__attribute__((overloadable)) void
_vec_char_resize(_VecCharInternal* ptr, const size_t size, err_t* err)
{
err_t status = ERR_T_INIT;
__null_check(ptr, &status);
if ((status.flags & ERR_VEC_NULL) != 0)
{
__origin_override(err, "RESIZE");
err->flags |= ERR_VEC_NULL;
return;
}
if (ptr->_internal_size == size)
{
__origin_override(err, "RESIZE");
err->flags |= ERR_OUT_OF_BOUNDS;
return;
}
else if (size > ptr->_internal_max_size)
{
__origin_override(err, "RESIZE");
err->flags |= ERR_SIZE_OVERFLOW;
return;
}
else if ((status.flags & ERR_BUF_NULL) != 0 || ptr->_internal_size == 0)
{
size_t max = ptr->_internal_max_size;
err_t verr = ERR_T_INIT;
_vec_char_reserve(ptr, size, &verr);
if (verr.flags != 0)
{
__origin_override(err, "RESIZE");
err->flags |= verr.flags;
return;
}
if (ptr->_internal_capacity != size)
{
__origin_override(err, "RESIZE");
err->flags |= ERR_ALLOC_FAIL;
return;
}
for (size_t i = 0; i < size; i++)
{
ptr->_internal_arr[i] = 0;
}
ptr->_internal_max_size = max;
ptr->_internal_size = size;
return;
}
else if (size > ptr->_internal_capacity)
{
size_t tmpcp = ptr->_internal_capacity;
size_t tmpmx = ptr->_internal_max_size;
err_t verr = ERR_T_INIT;
while (size > tmpcp)
{
tmpcp *= 2;
}
if (tmpcp > ptr->_internal_max_size)
{
tmpcp = size;
}
_vec_char_reserve(ptr, tmpcp, &verr);
if (verr.flags != 0)
{
__origin_override(err, "RESIZE");
err->flags |= verr.flags;
return;
}
if (ptr->_internal_capacity != tmpcp)
{
__origin_override(err, "RESIZE");
err->flags |= ERR_ALLOC_FAIL;
return;
}
ptr->_internal_max_size = tmpmx;
}
if (size < ptr->_internal_size)
{
memset(&ptr->_internal_arr[size], 0,
ptr->_internal_size - size);
}
if (ptr->_internal_size < size && size <= ptr->_internal_capacity)
{
memset(&ptr->_internal_arr[ptr->_internal_size], 0,
size - ptr->_internal_size);
}
ptr->_internal_size = size;
return;
}
__attribute__((overloadable)) void
_vec_char_resize(_VecCharInternal* ptr, const size_t size, const char val,
err_t* err)
{
err_t status = ERR_T_INIT;
__null_check(ptr, &status);
if ((status.flags & ERR_VEC_NULL) != 0)
{
__origin_override(err, "RESIZE");
err->flags |= ERR_VEC_NULL;
return;
}
if (ptr->_internal_size == size)
{
__origin_override(err, "RESIZE");
err->flags |= ERR_OUT_OF_BOUNDS;
return;
}
else if (size > ptr->_internal_max_size)
{
__origin_override(err, "RESIZE");
err->flags |= ERR_SIZE_OVERFLOW;
return;
}
else if ((status.flags & ERR_BUF_NULL) != 0 || ptr->_internal_size == 0)
{
size_t max = ptr->_internal_max_size;
err_t verr = ERR_T_INIT;
_vec_char_reserve(ptr, size, &verr);
if (verr.flags != 0)
{
__origin_override(err, "RESIZE");
err->flags |= verr.flags;
return;
}
if (ptr->_internal_capacity != size)
{
__origin_override(err, "RESIZE");
err->flags |= ERR_ALLOC_FAIL;
return;
}
for (size_t i = 0; i < size; i++)
{
ptr->_internal_arr[i] = val;
}
ptr->_internal_max_size = max;
ptr->_internal_size = size;
return;
}
else if (size > ptr->_internal_capacity)
{
size_t tmpcp = ptr->_internal_capacity;
size_t tmpmx = ptr->_internal_max_size;
err_t verr = ERR_T_INIT;
while (size > tmpcp)
{
tmpcp *= 2;
}
if (tmpcp > ptr->_internal_max_size)
{
tmpcp = size;
}
_vec_char_reserve(ptr, tmpcp, &verr);
if (verr.flags != 0)
{
__origin_override(err, "RESIZE");
err->flags |= verr.flags;
return;
}
ptr->_internal_max_size = tmpmx;
}
if (size < ptr->_internal_size)
{
memset(&ptr->_internal_arr[size], val,
ptr->_internal_size - size);
}
if (ptr->_internal_size < size && size <= ptr->_internal_capacity)
{
memset(&ptr->_internal_arr[ptr->_internal_size], val,
size - ptr->_internal_size);
}
ptr->_internal_size = size;
return;
}
__attribute__((overloadable)) void
_vec_char_assign(_VecCharInternal* ptr, const _VecCharInternal* iterator,
const size_t iter_start, const size_t iter_end, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0 ||
__null_check(iterator, &status) != 0)
{
__origin_override(err, "ASSIGN");
err->flags |= status.flags;
return;
}
if (ptr->_internal_arr == iterator->_internal_arr)
{
__origin_override(err, "ASSIGN");
err->flags |= ERR_DOUBLE_BUF;
return;
}
if (iterator->_internal_size < iter_end || iter_end <= iter_start)
{
__origin_override(err, "ASSIGN");
err->flags |= ERR_OUT_OF_BOUNDS;
return;
}
_vec_char_erase(ptr, _vec_char_begin(ptr, &status),
_vec_char_end(ptr, &status) + 1, &status);
if (status.flags != 0)
{
__origin_override(err, "ASSIGN");
err->flags |= status.flags;
return;
}
_vec_char_reserve(ptr, (iter_end - iter_start), &status);
if (status.flags != 0)
{
__origin_override(err, "ASSIGN");
err->flags |= status.flags;
return;
}
for (size_t i = iter_start; i < iter_end; i++)
{
char* res = _vec_char_at(iterator, i, &status);
if (res == nullptr)
{
err->flags |= ERR_OUT_OF_BOUNDS;
return;
}
_vec_char_push_back(ptr, *res, &status);
if (status.flags != 0)
{
__origin_override(err, "ASSIGN");
err->flags |= status.flags;
return;
}
}
return;
}
__attribute__((overloadable)) void
_vec_char_assign(_VecCharInternal* ptr, const size_t amount, const char val,
err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
{
__origin_override(err, "ASSIGN");
err->flags |= status.flags;
return;
}
if (amount == 0)
{
__origin_override(err, "ASSIGN");
err->flags |= ERR_SIZE_ZERO;
return;
}
_vec_char_erase(ptr, _vec_char_begin(ptr, &status),
_vec_char_end(ptr, &status) + 1, &status);
if (status.flags != 0)
{
__origin_override(err, "ASSIGN");
err->flags |= status.flags;
return;
}
_vec_char_reserve(ptr, amount, &status);
if (status.flags != 0)
{
__origin_override(err, "ASSIGN");
err->flags |= status.flags;
return;
}
for (size_t i = 0; i < amount; i++)
{
_vec_char_push_back(ptr, val, &status);
if (status.flags != 0)
{
__origin_override(err, "ASSIGN");
err->flags |= status.flags;
return;
}
}
return;
}
__attribute__((overloadable)) void
_vec_char_insert(_VecCharInternal* ptr, const size_t iter, const char val,
err_t* err)
{
err_t status = ERR_T_INIT;
__null_check(ptr, &status);
if ((status.flags & ERR_VEC_NULL) != 0)
{
__origin_override(err, "INSERT");
err->flags |= status.flags;
return;
}
if ((status.flags & ERR_BUF_NULL) != 0)
{
char* res = malloc(1 * sizeof(char));
if (res == nullptr)
{
__origin_override(err, "INSERT");
err->flags |= ERR_BUF_NULL;
return;
}
ptr->_internal_arr = res;
ptr->_internal_capacity = 1;
ptr->_internal_arr[0] = val;
ptr->_internal_size = 1;
return;
}
if (ptr->_internal_max_size < ptr->_internal_size + 1)
{
__origin_override(err, "INSERT");
err->flags |= ERR_SIZE_OVERFLOW;
return;
}
if (iter > ptr->_internal_size)
{
__origin_override(err, "INSERT");
err->flags |= ERR_OUT_OF_BOUNDS;
return;
}
_vec_char_push_back(ptr, 0, &status);
if (status.flags != 0)
{
__origin_override(err, "INSERT");
err->flags |= status.flags;
return;
}
for (size_t i = ptr->_internal_size - 1; i > iter; i--)
{
ptr->_internal_arr[i] = ptr->_internal_arr[i - 1];
}
ptr->_internal_arr[iter] = val;
return;
}
__attribute__((overloadable)) void
_vec_char_insert(_VecCharInternal* ptr, const size_t iter, const size_t amount,
const char val, err_t* err)
{
err_t status = ERR_T_INIT;
__null_check(ptr, &status);
if ((status.flags & (ERR_VEC_NULL | ERR_BUF_NULL)) != 0)
{
__origin_override(err, "INSERT");
err->flags |= status.flags;
return;
}
if (iter > ptr->_internal_size)
{
__origin_override(err, "INSERT");
err->flags |= ERR_OUT_OF_BOUNDS;
return;
}
if (amount == 0)
{
__origin_override(err, "INSERT");
err->flags |= ERR_SIZE_ZERO;
return;
}
for (size_t i = iter; i < iter + amount; i++)
{
_vec_char_insert(ptr, i, val, &status);
if (status.flags != 0)
{
__origin_override(err, "INSERT");
err->flags |= status.flags;
return;
}
}
return;
}
__attribute__((overloadable)) void
_vec_char_insert(_VecCharInternal* ptr, const _VecCharInternal* iterator,
const size_t iter, const size_t iter_start,
const size_t iter_end, err_t* err)
{
err_t status = ERR_T_INIT;
__null_check(ptr, &status);
__null_check(iterator, &status);
if ((status.flags & (ERR_VEC_NULL | ERR_BUF_NULL)) != 0)
{
__origin_override(err, "INSERT");
err->flags |= status.flags;
return;
}
if (iter_end <= iter_start || iter_end > iterator->_internal_size ||
iter > ptr->_internal_size)
{
__origin_override(err, "INSERT");
err->flags |= ERR_OUT_OF_BOUNDS;
return;
}
if (ptr->_internal_arr == iterator->_internal_arr)
{
__origin_override(err, "INSERT");
err->flags |= ERR_DOUBLE_BUF;
return;
}
for (size_t i = iter_start; i < iter_end; i++)
{
_vec_char_insert(ptr, iter + (i - iter_start),
iterator->_internal_arr[i], &status);
if (status.flags != 0)
{
__origin_override(err, "INSERT");
err->flags |= status.flags;
return;
}
}
return;
}
src/int.c
+940
View File
@@ -0,0 +1,940 @@
#include <libvec/int.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
__attribute__((overloadable)) size_t
__null_check(const _VecIntInternal* ptr, err_t* status)
{
if (status == nullptr)
{
return ERR_ERR_T_NULL;
}
if (ptr == nullptr)
{
status->flags |= ERR_VEC_NULL;
return ERR_VEC_NULL;
}
if (ptr->_internal_arr == nullptr)
{
status->flags |= ERR_BUF_NULL;
}
return status->flags;
}
__attribute__((overloadable)) size_t
__null_check(const int* ptr, err_t* status)
{
if (status == nullptr)
{
return ERR_ERR_T_NULL;
}
if (ptr == nullptr)
{
status->flags |= ERR_BUF_NULL;
}
return status->flags;
}
size_t
__origin_override(err_t* status, char* str)
{
if (status == nullptr)
{
return ERR_ERR_T_NULL;
}
if (status->origin != nullptr)
{
status->flags |= ERR_ORIGIN_UNALTERABLE;
return status->flags;
}
else if (str == nullptr)
{
status->flags |= ERR_STR_NULL;
return status->flags;
}
else
{
status->origin = str;
return status->flags;
}
}
void
_vec_int_print_vec(const _VecIntInternal* ptr, err_t* err)
{
if (__null_check(ptr, err) != 0)
{
return;
}
for (size_t i = 0; i < ptr->_internal_size; i++)
{
printf("%d ", ptr->_internal_arr[i]);
}
printf("\n");
}
_VecIntInternal
_vec_int_cpy(const int* src, const size_t src_size, err_t* err)
{
_VecIntInternal self = VEC_INIT;
err_t status = ERR_T_INIT;
size_t null = __null_check(src, err);
if (null != 0)
{
if (null & ERR_ERR_T_NULL)
{
return self;
}
__origin_override(err, "CPY");
err->flags |= status.flags;
return self;
}
if (src_size == 0)
{
__origin_override(err, "CPY");
err->flags |= ERR_SIZE_ZERO;
err->flags |= status.flags;
return self;
}
if (src_size > self._internal_max_size)
{
__origin_override(err, "CPY");
err->flags |= ERR_SIZE_OVERFLOW;
return self;
}
self._internal_arr = malloc(src_size * sizeof(int));
if (self._internal_arr == nullptr)
{
__origin_override(err, "CPY");
err->flags |= ERR_ALLOC_FAIL;
return self;
}
memcpy(self._internal_arr, src, src_size * sizeof(int));
self._internal_size = src_size;
self._internal_capacity = src_size;
return self;
}
void
_vec_int_push_back(_VecIntInternal* ptr, const int val, err_t* err)
{
err_t status = ERR_T_INIT;
int* res;
__null_check(ptr, &status);
if ((status.flags & ERR_VEC_NULL) != 0)
{
__origin_override(err, "PUSH_BACK");
err->flags |= ERR_VEC_NULL;
return;
}
if (ptr->_internal_size + 1 > ptr->_internal_max_size)
{
__origin_override(err, "PUSH_BACK");
err->flags |= ERR_SIZE_OVERFLOW;
return;
}
if ((status.flags & ERR_BUF_NULL) != 0)
{
res = malloc(1 * sizeof(int));
if (res == nullptr)
{
__origin_override(err, "PUSH_BACK");
err->flags |= ERR_ALLOC_FAIL;
return;
}
ptr->_internal_arr = res;
ptr->_internal_capacity = 1;
ptr->_internal_size = 0;
}
else if (ptr->_internal_size + 1 > ptr->_internal_capacity)
{
size_t dst_cap =
(ptr->_internal_capacity / 2) + ptr->_internal_capacity;
if (dst_cap == ptr->_internal_capacity)
{
dst_cap++;
}
if (dst_cap > ptr->_internal_max_size)
{
dst_cap = ptr->_internal_max_size;
DEBUG(
"Capacity cannot be grown any further due "
"to hitting max size");
}
res = realloc(ptr->_internal_arr, dst_cap * sizeof(int));
if (res == nullptr)
{
__origin_override(err, "PUSH_BACK");
err->flags |= ERR_SIZE_OVERFLOW;
return;
}
ptr->_internal_arr = res;
ptr->_internal_capacity = dst_cap;
}
ptr->_internal_arr[ptr->_internal_size] = val;
ptr->_internal_size++;
return;
}
void
_vec_int_pop_back(_VecIntInternal* ptr, err_t* err)
{
if (__null_check(ptr, err) != 0)
{
__origin_override(err, "POP_BACK");
return;
}
if (ptr->_internal_size == 0)
{
__origin_override(err, "POP_BACK");
err->flags |= ERR_SIZE_ZERO;
return;
}
ptr->_internal_arr[ptr->_internal_size - 1] = 0;
ptr->_internal_size--;
}
void
_vec_int_reserve(_VecIntInternal* ptr, const size_t capacity, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
{
if ((status.flags & ERR_VEC_NULL) != 0)
{
__origin_override(err, "RESERVE");
err->flags |= ERR_VEC_NULL;
return;
}
}
if (ptr->_internal_max_size < capacity)
{
__origin_override(err, "RESERVE");
err->flags |= ERR_SIZE_OVERFLOW;
return;
}
if (capacity == 0)
{
__origin_override(err, "RESERVE");
err->flags |= ERR_SIZE_ZERO;
return;
}
int* res = realloc(ptr->_internal_arr, capacity * sizeof(int));
if (res == nullptr)
{
__origin_override(err, "RESERVE");
err->flags |= ERR_ALLOC_FAIL;
return;
}
ptr->_internal_arr = res;
ptr->_internal_capacity = capacity;
if (ptr->_internal_size > capacity)
{
ptr->_internal_size = capacity;
}
return;
}
void
_vec_int_shrink_to_fit(_VecIntInternal* ptr, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
{
__origin_override(err, "SHRINK_TO_FIT");
err->flags |= status.flags;
return;
}
if (ptr->_internal_size == 0)
{
__origin_override(err, "SHRINK_TO_FIT");
err->flags |= ERR_SIZE_ZERO;
return;
}
_vec_int_reserve(ptr, ptr->_internal_size, err);
}
void
_vec_int_swap(_VecIntInternal* ptr_a, _VecIntInternal* ptr_b, err_t* err)
{
err_t status_1 = ERR_T_INIT, status_2 = ERR_T_INIT;
if ((__null_check(ptr_a, &status_1) & ERR_VEC_NULL) != 0 ||
(__null_check(ptr_b, &status_2) & ERR_VEC_NULL) != 0)
{
__origin_override(err, "SWAP");
err->flags |= ERR_VEC_NULL;
return;
}
_VecIntInternal self = *ptr_a;
*ptr_a = *ptr_b;
*ptr_b = self;
return;
}
const int*
_vec_int_data(const _VecIntInternal* ptr, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
{
__origin_override(err, "DATA");
err->flags |= status.flags;
return nullptr;
}
return &ptr->_internal_arr[0];
}
size_t
_vec_int_size(const _VecIntInternal* ptr, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
{
__origin_override(err, "SIZE");
err->flags |= status.flags;
return 0;
}
return ptr->_internal_size;
}
size_t
_vec_int_capacity(const _VecIntInternal* ptr, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
{
__origin_override(err, "CAPACITY");
err->flags |= status.flags;
return 0;
}
return ptr->_internal_capacity;
}
size_t
_vec_int_max_size(const _VecIntInternal* ptr, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
{
__origin_override(err, "MAX_SIZE");
err->flags |= status.flags;
return 0;
}
return ptr->_internal_max_size;
}
void
_vec_int_delete(_VecIntInternal* ptr, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
{
__origin_override(err, "DELETE");
err->flags |= status.flags;
return;
}
if (ptr->_internal_arr != nullptr)
{
free(ptr->_internal_arr);
ptr->_internal_arr = nullptr;
}
ptr->_internal_size = 0;
ptr->_internal_capacity = 0;
}
void
_vec_int_clear(_VecIntInternal* ptr, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
{
__origin_override(err, "CLEAR");
err->flags |= status.flags;
return;
}
if (ptr->_internal_size > 0)
{
memset(ptr->_internal_arr, 0,
ptr->_internal_size * sizeof(int));
ptr->_internal_size = 0;
}
}
int*
_vec_int_at(const _VecIntInternal* ptr, const size_t idx, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
{
__origin_override(err, "AT");
err->flags |= status.flags;
return nullptr;
}
if (idx >= ptr->_internal_size)
{
__origin_override(err, "AT");
err->flags |= ERR_OUT_OF_BOUNDS;
return nullptr;
}
return &ptr->_internal_arr[idx];
}
size_t
_vec_int_begin(const _VecIntInternal* ptr, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
{
__origin_override(err, "BEGIN");
err->flags |= status.flags;
return status.flags;
}
return 0;
}
size_t
_vec_int_end(const _VecIntInternal* ptr, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
{
__origin_override(err, "END");
err->flags |= status.flags;
return status.flags;
}
if (ptr->_internal_size == 0)
{
__origin_override(err, "END");
err->flags |= ERR_SIZE_ZERO;
return status.flags;
}
return (size_t)(ptr->_internal_size - 1);
}
int
_vec_int_front(const _VecIntInternal* ptr, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
{
__origin_override(err, "FRONT");
err->flags |= status.flags;
return -1;
}
if (_vec_int_at(ptr, 0, err) == nullptr)
{
err->flags |= ERR_OUT_OF_BOUNDS;
return 0;
}
return *_vec_int_at(ptr, 0, err);
}
int
_vec_int_back(const _VecIntInternal* ptr, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
{
__origin_override(err, "BACK");
err->flags |= status.flags;
return -1;
}
if (_vec_int_at(ptr, 0, err) == nullptr)
{
err->flags |= ERR_OUT_OF_BOUNDS;
return 0;
}
return *_vec_int_at(ptr, ptr->_internal_size - 1, err);
}
size_t
_vec_int_empty(const _VecIntInternal* ptr, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
{
__origin_override(err, "EMPTY");
err->flags |= status.flags;
return status.flags;
}
if (ptr->_internal_size == 0)
{
return ptr->_internal_size;
}
return status.flags;
}
__attribute__((overloadable)) void
_vec_int_erase(_VecIntInternal* ptr, const size_t iter, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
{
__origin_override(err, "ERASE");
err->flags |= status.flags;
return;
}
if (iter >= ptr->_internal_size)
{
return;
}
memmove(&ptr->_internal_arr[iter], &ptr->_internal_arr[iter + 1],
(ptr->_internal_size - iter - 1) * sizeof(int));
ptr->_internal_arr[ptr->_internal_size - 1] = 0;
ptr->_internal_size--;
return;
}
__attribute__((overloadable)) void
_vec_int_erase(_VecIntInternal* ptr, const size_t iter_start,
const size_t iter_end, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
{
__origin_override(err, "ERASE");
err->flags |= status.flags;
return;
}
if (ptr->_internal_size < iter_end || iter_end <= iter_start)
{
__origin_override(err, "ERASE");
err->flags |= ERR_OUT_OF_BOUNDS;
return;
}
size_t diff = iter_end - iter_start;
memmove(&ptr->_internal_arr[iter_start], &ptr->_internal_arr[iter_end],
(ptr->_internal_size - iter_end) * sizeof(int));
memset(&ptr->_internal_arr[ptr->_internal_size - diff], 0,
sizeof(int) * diff);
ptr->_internal_size -= diff;
return;
}
__attribute__((overloadable)) void
_vec_int_resize(_VecIntInternal* ptr, const size_t size, err_t* err)
{
err_t status = ERR_T_INIT;
__null_check(ptr, &status);
if ((status.flags & ERR_VEC_NULL) != 0)
{
__origin_override(err, "RESIZE");
err->flags |= ERR_VEC_NULL;
return;
}
if (ptr->_internal_size == size)
{
__origin_override(err, "RESIZE");
err->flags |= ERR_OUT_OF_BOUNDS;
return;
}
else if (size > ptr->_internal_max_size)
{
__origin_override(err, "RESIZE");
err->flags |= ERR_SIZE_OVERFLOW;
return;
}
else if ((status.flags & ERR_BUF_NULL) != 0 || ptr->_internal_size == 0)
{
size_t max = ptr->_internal_max_size;
err_t verr = ERR_T_INIT;
_vec_int_reserve(ptr, size, &verr);
if (verr.flags != 0)
{
__origin_override(err, "RESIZE");
err->flags |= verr.flags;
return;
}
if (ptr->_internal_capacity != size)
{
__origin_override(err, "RESIZE");
err->flags |= ERR_ALLOC_FAIL;
return;
}
memset(ptr->_internal_arr, 0, size * sizeof(int));
ptr->_internal_max_size = max;
ptr->_internal_size = size;
return;
}
else if (size > ptr->_internal_capacity)
{
size_t tmpcp = ptr->_internal_capacity;
size_t tmpmx = ptr->_internal_max_size;
err_t verr = ERR_T_INIT;
while (size > tmpcp)
{
tmpcp *= 2;
}
if (tmpcp > ptr->_internal_max_size)
{
tmpcp = size;
}
_vec_int_reserve(ptr, tmpcp, &verr);
if (verr.flags != 0)
{
__origin_override(err, "RESIZE");
err->flags |= verr.flags;
return;
}
if (ptr->_internal_capacity != tmpcp)
{
__origin_override(err, "RESIZE");
err->flags |= ERR_ALLOC_FAIL;
return;
}
ptr->_internal_max_size = tmpmx;
}
if (size < ptr->_internal_size)
{
memset(&ptr->_internal_arr[size], 0,
(ptr->_internal_size - size) * sizeof(int));
}
if (ptr->_internal_size < size && size <= ptr->_internal_capacity)
{
memset(&ptr->_internal_arr[ptr->_internal_size], 0,
(size - ptr->_internal_size) * sizeof(int));
}
ptr->_internal_size = size;
return;
}
__attribute__((overloadable)) void
_vec_int_resize(_VecIntInternal* ptr, const size_t size, const int val,
err_t* err)
{
err_t status = ERR_T_INIT;
__null_check(ptr, &status);
if ((status.flags & ERR_VEC_NULL) != 0)
{
__origin_override(err, "RESIZE");
err->flags |= ERR_VEC_NULL;
return;
}
if (ptr->_internal_size == size)
{
__origin_override(err, "RESIZE");
err->flags |= ERR_OUT_OF_BOUNDS;
return;
}
else if (size > ptr->_internal_max_size)
{
__origin_override(err, "RESIZE");
err->flags |= ERR_SIZE_OVERFLOW;
return;
}
else if ((status.flags & ERR_BUF_NULL) != 0 || ptr->_internal_size == 0)
{
size_t max = ptr->_internal_max_size;
err_t verr = ERR_T_INIT;
_vec_int_reserve(ptr, size, &verr);
if (verr.flags != 0)
{
__origin_override(err, "RESIZE");
err->flags |= verr.flags;
return;
}
if (ptr->_internal_capacity != size)
{
__origin_override(err, "RESIZE");
err->flags |= ERR_ALLOC_FAIL;
return;
}
for (size_t i = 0; i < size; i++)
{
ptr->_internal_arr[i] = val;
}
ptr->_internal_max_size = max;
ptr->_internal_size = size;
return;
}
else if (size > ptr->_internal_capacity)
{
size_t tmpcp = ptr->_internal_capacity;
size_t tmpmx = ptr->_internal_max_size;
err_t verr = ERR_T_INIT;
while (size > tmpcp)
{
tmpcp *= 2;
}
if (tmpcp > ptr->_internal_max_size)
{
tmpcp = size;
}
_vec_int_reserve(ptr, tmpcp, &verr);
if (verr.flags != 0)
{
__origin_override(err, "RESIZE");
err->flags |= verr.flags;
return;
}
ptr->_internal_max_size = tmpmx;
}
if (size < ptr->_internal_size)
{
for (size_t i = size; i < ptr->_internal_size; i++)
{
ptr->_internal_arr[i] = 0;
}
}
if (ptr->_internal_size < size && size <= ptr->_internal_capacity)
{
for (size_t i = ptr->_internal_size; i < size; i++)
{
ptr->_internal_arr[i] = val;
}
}
ptr->_internal_size = size;
return;
}
__attribute__((overloadable)) void
_vec_int_assign(_VecIntInternal* ptr, const _VecIntInternal* iterator,
const size_t iter_start, const size_t iter_end, err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0 ||
__null_check(iterator, &status) != 0)
{
__origin_override(err, "ASSIGN");
err->flags |= status.flags;
return;
}
if (ptr->_internal_arr == iterator->_internal_arr)
{
__origin_override(err, "ASSIGN");
err->flags |= ERR_DOUBLE_BUF;
return;
}
if (iterator->_internal_size < iter_end || iter_end <= iter_start)
{
__origin_override(err, "ASSIGN");
err->flags |= ERR_OUT_OF_BOUNDS;
return;
}
_vec_int_erase(ptr, _vec_int_begin(ptr, &status),
_vec_int_end(ptr, &status) + 1, &status);
if (status.flags != 0)
{
__origin_override(err, "ASSIGN");
err->flags |= status.flags;
return;
}
_vec_int_reserve(ptr, (iter_end - iter_start), &status);
if (status.flags != 0)
{
__origin_override(err, "ASSIGN");
err->flags |= status.flags;
return;
}
for (size_t i = iter_start; i < iter_end; i++)
{
int* res = _vec_int_at(iterator, i, &status);
if (res == nullptr)
{
err->flags |= ERR_OUT_OF_BOUNDS;
return;
}
_vec_int_push_back(ptr, *res, &status);
if (status.flags != 0)
{
__origin_override(err, "ASSIGN");
err->flags |= status.flags;
return;
}
}
return;
}
__attribute__((overloadable)) void
_vec_int_assign(_VecIntInternal* ptr, const size_t amount, const int val,
err_t* err)
{
err_t status = ERR_T_INIT;
if (__null_check(ptr, &status) != 0)
{
__origin_override(err, "ASSIGN");
err->flags |= status.flags;
return;
}
if (amount == 0)
{
__origin_override(err, "ASSIGN");
err->flags |= ERR_SIZE_ZERO;
return;
}
_vec_int_erase(ptr, _vec_int_begin(ptr, &status),
_vec_int_end(ptr, &status) + 1, &status);
if (status.flags != 0)
{
__origin_override(err, "ASSIGN");
err->flags |= status.flags;
return;
}
_vec_int_reserve(ptr, amount, &status);
if (status.flags != 0)
{
__origin_override(err, "ASSIGN");
err->flags |= status.flags;
return;
}
for (size_t i = 0; i < amount; i++)
{
_vec_int_push_back(ptr, val, &status);
if (status.flags != 0)
{
__origin_override(err, "ASSIGN");
err->flags |= status.flags;
return;
}
}
return;
}
__attribute__((overloadable)) void
_vec_int_insert(_VecIntInternal* ptr, const size_t iter, const int val,
err_t* err)
{
err_t status = ERR_T_INIT;
__null_check(ptr, &status);
if ((status.flags & ERR_VEC_NULL) != 0)
{
__origin_override(err, "INSERT");
err->flags |= status.flags;
return;
}
if ((status.flags & ERR_BUF_NULL) != 0)
{
int* res = malloc(1 * sizeof(int));
if (res == nullptr)
{
__origin_override(err, "INSERT");
err->flags |= ERR_BUF_NULL;
return;
}
ptr->_internal_arr = res;
ptr->_internal_capacity = 1;
ptr->_internal_arr[0] = val;
ptr->_internal_size = 1;
return;
}
if (ptr->_internal_max_size < ptr->_internal_size + 1)
{
__origin_override(err, "INSERT");
err->flags |= ERR_SIZE_OVERFLOW;
return;
}
if (iter > ptr->_internal_size)
{
__origin_override(err, "INSERT");
err->flags |= ERR_OUT_OF_BOUNDS;
return;
}
_vec_int_push_back(ptr, 0, &status);
if (status.flags != 0)
{
__origin_override(err, "INSERT");
err->flags |= status.flags;
return;
}
for (size_t i = ptr->_internal_size - 1; i > iter; i--)
{
ptr->_internal_arr[i] = ptr->_internal_arr[i - 1];
}
ptr->_internal_arr[iter] = val;
return;
}
__attribute__((overloadable)) void
_vec_int_insert(_VecIntInternal* ptr, const size_t iter, const size_t amount,
const int val, err_t* err)
{
err_t status = ERR_T_INIT;
__null_check(ptr, &status);
if ((status.flags & (ERR_VEC_NULL | ERR_BUF_NULL)) != 0)
{
__origin_override(err, "INSERT");
err->flags |= status.flags;
return;
}
if (iter > ptr->_internal_size)
{
__origin_override(err, "INSERT");
err->flags |= ERR_OUT_OF_BOUNDS;
return;
}
if (amount == 0)
{
__origin_override(err, "INSERT");
err->flags |= ERR_SIZE_ZERO;
return;
}
for (size_t i = iter; i < iter + amount; i++)
{
_vec_int_insert(ptr, i, val, &status);
if (status.flags != 0)
{
__origin_override(err, "INSERT");
err->flags |= status.flags;
return;
}
}
return;
}
__attribute__((overloadable)) void
_vec_int_insert(_VecIntInternal* ptr, const _VecIntInternal* iterator,
const size_t iter, const size_t iter_start,
const size_t iter_end, err_t* err)
{
err_t status = ERR_T_INIT;
__null_check(ptr, &status);
__null_check(iterator, &status);
if ((status.flags & (ERR_VEC_NULL | ERR_BUF_NULL)) != 0)
{
__origin_override(err, "INSERT");
err->flags |= status.flags;
return;
}
if (iter_end <= iter_start || iter_end > iterator->_internal_size ||
iter > ptr->_internal_size)
{
__origin_override(err, "INSERT");
err->flags |= ERR_OUT_OF_BOUNDS;
return;
}
if (ptr->_internal_arr == iterator->_internal_arr)
{
__origin_override(err, "INSERT");
err->flags |= ERR_DOUBLE_BUF;
return;
}
for (size_t i = iter_start; i < iter_end; i++)
{
_vec_int_insert(ptr, iter + (i - iter_start),
iterator->_internal_arr[i], &status);
if (status.flags != 0)
{
__origin_override(err, "INSERT");
err->flags |= status.flags;
return;
}
}
return;
}
src/lib/.DS_Store
Vendored
BIN
View File
Binary file not shown.
src/lib/char/char.h
-117
View File
@@ -1,117 +0,0 @@
#ifndef CHAR_H
#define CHAR_H
#include <utils/utils.h>
// Will add DOCS later
typedef struct
{
char* _internal_arr;
size_t _internal_size;
size_t _internal_capacity;
size_t _internal_max_size;
} _VecCharInternal;
__attribute__((overloadable)) size_t
__null_check(const _VecCharInternal* ptr, err_t* status);
__attribute__((overloadable)) size_t
__null_check(const char* ptr, err_t* status);
size_t
__origin_override(err_t* status, char* str);
void
_vec_char_print_vec(const _VecCharInternal* ptr, err_t* err);
_VecCharInternal
_vec_char_cpy(const char* src, const size_t src_size, err_t* err);
void
_vec_char_push_back(_VecCharInternal* ptr, const char val, err_t* err);
void
_vec_char_pop_back(_VecCharInternal* ptr, err_t* err);
void
_vec_char_reserve(_VecCharInternal* ptr, const size_t capacity, err_t* err);
void
_vec_char_shrink_to_fit(_VecCharInternal* ptr, err_t* err);
void
_vec_char_swap(_VecCharInternal* ptr_a, _VecCharInternal* ptr_b, err_t* err);
const char*
_vec_char_data(const _VecCharInternal* ptr, err_t* err);
size_t
_vec_char_size(const _VecCharInternal* ptr, err_t* err);
size_t
_vec_char_capacity(const _VecCharInternal* ptr, err_t* err);
size_t
_vec_char_max_size(const _VecCharInternal* ptr, err_t* err);
void
_vec_char_delete(_VecCharInternal* ptr, err_t* err);
void
_vec_char_clear(_VecCharInternal* ptr, err_t* err);
char*
_vec_char_at(const _VecCharInternal* ptr, const size_t idx, err_t* err);
size_t
_vec_char_begin(const _VecCharInternal* ptr, err_t* err);
size_t
_vec_char_end(const _VecCharInternal* ptr, err_t* err);
char
_vec_char_front(const _VecCharInternal* ptr, err_t* err);
char
_vec_char_back(const _VecCharInternal* ptr, err_t* err);
size_t
_vec_char_empty(const _VecCharInternal* ptr, err_t* err);
__attribute__((overloadable)) void
_vec_char_erase(_VecCharInternal* ptr, const size_t iter, err_t* err);
__attribute__((overloadable)) void
_vec_char_erase(_VecCharInternal* ptr, const size_t iter_start,
const size_t iter_end, err_t* err);
__attribute__((overloadable)) void
_vec_char_resize(_VecCharInternal* ptr, const size_t size, err_t* err);
__attribute__((overloadable)) void
_vec_char_resize(_VecCharInternal* ptr, const size_t size, const char val,
err_t* err);
__attribute__((overloadable)) void
_vec_char_assign(_VecCharInternal* ptr, const _VecCharInternal* iterator,
const size_t iter_start, const size_t iter_end, err_t* err);
__attribute__((overloadable)) void
_vec_char_assign(_VecCharInternal* ptr, const size_t amount, const char val,
err_t* err);
__attribute__((overloadable)) void
_vec_char_insert(_VecCharInternal* ptr, const size_t iter, const char val,
err_t* err);
__attribute__((overloadable)) void
_vec_char_insert(_VecCharInternal* ptr, const size_t iter, const size_t amount,
const char val, err_t* err);
__attribute__((overloadable)) void
_vec_char_insert(_VecCharInternal* ptr, const _VecCharInternal* iterator,
const size_t iter, const size_t iter_start,
const size_t iter_end, err_t* err);
#endif
src/lib/utils/utils.h
-67
View File
@@ -1,67 +0,0 @@
#ifndef UTILS_H
#define UTILS_H
#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) \
X(SUCCESS, 0, "No Errors Found") \
X(ERR_ALLOC_FAIL, (1u << 0), "Alloc :- Failed to allocate") \
X(ERR_VEC_NULL, (1u << 1), "Vector :- Given vector is null") \
X(ERR_BUF_NULL, (1u << 2), "Buffer :- NULL") \
X(ERR_SIZE_ZERO, (1u << 3), \
"Size :- Size is or is less than 0 or invalid") \
X(ERR_OUT_OF_BOUNDS, (1u << 4), "Bounds:- Value is out of bounds") \
X(ERR_DOUBLE_BUF, (1u << 5), \
"Buffer :- Both buffers are copies of each other") \
X(ERR_SIZE_OVERFLOW, (1u << 6), \
"Max :- Vector Max value is overloaded") \
X(ERR_ORIGIN_UNALTERABLE, (1u << 7), \
"Origin :- Origin is non-null and cannot be overridden") \
X(ERR_STR_NULL, (1u << 8), "String :- String is null value") \
X(ERR_ERR_T_NULL, (1u << 9), "ERR_T :- Passed error is null")
typedef enum
{
#define X(name, val, desc) name = (val),
ERROR_LIST(X)
#undef X
} ERROR_CODES;
/* NOTE
* Value is the return value for functions like _vec_char_capacity
* Err is the unsigned bit range for all the errors tracked
* origin is a string for where the bug started and IS CHANGED ONLY WHEN NULL
* */
typedef struct
{
unsigned int flags;
char* origin; // Where the main bug started
} err_t;
#define ERR_T_INIT { .flags = 0, .origin = NULL }
#define VEC_INIT \
{ ._internal_arr = NULL, \
._internal_size = 0, \
._internal_capacity = 0, \
._internal_max_size = VEC_MAX }
const char*
vec_get_error_desc(ERROR_CODES err);
void
vec_print_errs(const err_t err);
void
print_bits(unsigned int num);
#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])
#endif
src/libvec.c
-1
View File
@@ -1 +0,0 @@
#include <libvec.h>
src/main.c
+2 -2
View File
@@ -12,13 +12,12 @@
* String 32 Bits with suffix of 's'
*/
#include <libvec/utils.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "lib/utils/utils.h"
void
print_bits(unsigned int num);
@@ -26,6 +25,7 @@ int
main()
{
// TODO:
//
// Fix the error checking because you make a status to hold all local
// errors but then in some cases you or them to the main err handler and
// if the error doesnt need to be there like a good error but one that
src/lib/utils/utils.c → src/utils.c
+1 -1
View File
@@ -1,5 +1,5 @@
#include <libvec/utils.h>
#include <stdio.h>
#include <utils/utils.h>
const char*
vec_get_error_desc(ERROR_CODES err)