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

REFACTOR: Resize is completely refactored and bug free

Browse Source
This commit is contained in:
DarthMooMancer
2026-09-25 12:57:12 -04:00
parent 8a52f22b8a
commit 924c45e223
2 changed files with 765 additions and 50 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/char.c
+136 -50
View File
@@ -28,9 +28,21 @@ Vec8_t
create(const char* buf, const size_t len)
{
Vec8_t dst = { NULL, 0, CAPACITY, VEC_MAX };
if (len > dst.capacity)
if (len >= dst.max_size)
{
while (len > dst.capacity) dst.capacity *= 2;
LOGERROR(ERR_MAX_PASSED);
LOG("If you need more memory to start, create a blank and "
"reserve.");
return dst;
}
if (dst.capacity < len && len < dst.max_size)
{
while (dst.capacity < len && dst.capacity * 2 < dst.max_size)
dst.capacity *= 2;
}
if (dst.capacity * 2 > dst.max_size && len < dst.max_size)
{
dst.capacity = len;
}
if (len > 0)
{
@@ -121,17 +133,11 @@ pop_back(Vec8_t* ptr)
return dst;
}
/*
* reallocf failure wipes the buffer — push_back (char.c:89-94), reserve
* (char.c:140-147). On alloc failure it frees ptr->arr, then returns arr ==
* NULL; caller keeps a dangling pointer. Silent heap corruption.
*
* */
Vec8_t
reserve(const Vec8_t* ptr, const size_t max_size)
reserve(const Vec8_t* ptr, const size_t capacity)
{
Vec8_t ret = create(nullptr, 0);
if (max_size == 0)
if (capacity == 0)
{
LOGERROR(ERR_SIZE_ZERO);
return ret;
@@ -143,11 +149,17 @@ reserve(const Vec8_t* ptr, const size_t max_size)
ret.arr = ptr->arr;
if (is_valid(&ret) == ERR_BUF_NULL)
{
ret.arr = calloc(max_size, sizeof(char));
ret.arr = calloc(capacity, sizeof(char));
if (!ret.arr)
{
LOGERROR(ERR_ALLOC_FAIL);
ret = *ptr;
return ret;
}
}
else if (is_valid(ptr) == SUCCESS)
{
ret.arr = realloc(ret.arr, max_size * sizeof(char));
ret.arr = realloc(ret.arr, capacity * sizeof(char));
if (!ret.arr)
{
LOGERROR(ERR_ALLOC_FAIL);
@@ -155,17 +167,17 @@ reserve(const Vec8_t* ptr, const size_t max_size)
return ret;
}
ret.size = ptr->size;
if (ret.size > max_size)
if (ret.size > capacity)
{
for (size_t i = max_size; i < ret.size; i++)
for (size_t i = capacity; i < ret.size; i++)
{
ret.arr[i] = 0;
}
ret.size = max_size;
ret.size = capacity;
}
}
ret.capacity = max_size;
ret.max_size = max_size;
ret.capacity = capacity;
ret.max_size = capacity;
return ret;
}
@@ -390,6 +402,7 @@ resize(const Vec8_t* ptr, const size_t size)
Vec8_t dst = create(nullptr, 0);
if (is_valid(ptr) == ERR_VECTOR_NULL || is_valid(ptr) == ERR_BUF_NULL)
return dst;
dst = *ptr;
if (ptr->size == size)
{
LOG("ERR :- Ptr size and size are the same");
@@ -397,43 +410,62 @@ resize(const Vec8_t* ptr, const size_t size)
return dst;
}
else if (ptr->size == 0)
{
dst = reserve(&dst, size);
}
else if (size > ptr->max_size)
{
LOGERROR(ERR_MAX_PASSED);
dst = *ptr;
return dst;
}
else if (size > ptr->capacity)
else if (ptr->size == 0)
{
size_t tmp = ptr->capacity;
while (size > tmp)
size_t max = dst.max_size;
dst = reserve(&dst, size);
if (dst.capacity != size)
{
tmp *= 2;
}
dst = reserve(ptr, tmp);
if (!dst.arr)
{
LOGERROR(ERR_BUF_NULL);
LOGERROR(ERR_ALLOC_FAIL);
dst = *ptr;
return dst;
}
for (size_t i = 0; i < size; i++)
{
dst.arr[i] = '\0';
}
dst.max_size = max;
dst.size = size;
return dst;
}
else if (size > ptr->capacity)
{
size_t tmpcp = ptr->capacity;
size_t tmpmx = ptr->max_size;
while (size > tmpcp)
{
tmpcp *= 2;
}
if (tmpcp > ptr->max_size)
{
tmpcp = size;
}
dst = reserve(ptr, tmpcp);
if (dst.capacity != tmpcp)
{
LOGERROR(ERR_ALLOC_FAIL);
dst = *ptr;
return dst;
}
dst.max_size = tmpmx;
}
if (size < ptr->size)
{
dst = *ptr;
for (size_t i = ptr->size; i > size; i--)
for (size_t i = size; i < dst.size; i++)
{
dst.arr[i] = '\0';
}
}
if (ptr->size < size)
if (dst.size < size && size <= dst.capacity)
{
for (size_t i = ptr->size; i < size; i++)
for (size_t i = dst.size; i < size; i++)
{
dst.arr[i] = '\0';
}
@@ -443,33 +475,75 @@ resize(const Vec8_t* ptr, const size_t size)
}
__attribute__((overloadable)) Vec8_t
resize(Vec8_t* ptr, const size_t size, const char val)
resize(const Vec8_t* ptr, const size_t size, const char val)
{
Vec8_t dst = create(nullptr, 0);
dst = *ptr;
if (is_valid(ptr) == ERR_VECTOR_NULL || is_valid(ptr) == ERR_BUF_NULL)
return dst;
dst = *ptr;
if (ptr->size == size)
{
LOG("ERR :- Ptr size and size are the same");
dst = *ptr;
return dst;
}
if ((0 < size && size != dst.size && size < dst.size) ||
is_valid(ptr) == ERR_SIZE_ZERO)
else if (size > ptr->max_size)
{
LOGERROR(ERR_SIZE_ZERO);
LOGERROR(ERR_MAX_PASSED);
dst = *ptr;
return dst;
}
if ((0 < size && size < dst.size) || is_valid(ptr) == ERR_SIZE_ZERO)
{
LOGERROR(ERR_SIZE_ZERO);
return dst;
}
if (size >= dst.capacity)
else if (ptr->size == 0)
{
size_t max = dst.max_size;
dst = reserve(&dst, size);
if (dst.capacity != size)
{
LOGERROR(ERR_ALLOC_FAIL);
dst = *ptr;
return dst;
}
for (size_t i = 0; i < size; i++)
{
dst.arr[i] = val;
}
dst.max_size = max;
dst.size = size;
return dst;
}
dst.size = ptr->size + (size - ptr->size);
for (size_t i = ptr->size; i < dst.size; i++)
else if (size > ptr->capacity)
{
if (at(&dst, i) >= 0)
size_t tmpcp = ptr->capacity;
size_t tmpmx = ptr->max_size;
while (size > tmpcp)
{
tmpcp *= 2;
}
if (tmpcp > ptr->max_size)
{
tmpcp = size;
}
dst = reserve(ptr, tmpcp);
if (dst.capacity != tmpcp)
{
LOGERROR(ERR_ALLOC_FAIL);
dst = *ptr;
return dst;
}
dst.max_size = tmpmx;
}
if (size < ptr->size)
{
for (size_t i = size; i < dst.size; i++)
{
dst.arr[i] = val;
}
}
if (dst.size < size && size <= dst.capacity)
{
for (size_t i = dst.size; i < size; i++)
{
dst.arr[i] = val;
}
@@ -488,6 +562,13 @@ assign(const Vec8_t* ptr, const Vec8_t* iterator, const size_t iter_start,
if (is_valid(iterator) == ERR_VECTOR_NULL ||
is_valid(iterator) == ERR_BUF_NULL)
return dst;
if (ptr->arr == iterator->arr)
{
LOGERROR(ERR_DOUBLE_BUF);
dst = *ptr;
return dst;
}
if (iterator->size < iter_end || iter_end <= iter_start)
{
LOGERROR(ERR_OUT_OF_BOUNDS);
@@ -510,6 +591,11 @@ assign(const Vec8_t* ptr, const size_t amount, const char val)
if (is_valid(ptr) == ERR_VECTOR_NULL || is_valid(ptr) == ERR_BUF_NULL)
return create(nullptr, 0);
dst = *ptr;
if (amount == 0)
{
LOGERROR(ERR_SIZE_ZERO);
return dst;
}
dst = erase(&dst, begin(&dst), end(&dst) + 1);
dst = reserve(&dst, amount);
for (size_t i = 0; i < amount; i++)