FEAT: Implemented a more streamlined error handler.

REFACTOR: Completely rewrote insert and cleaned up names and redundant code.

include/char.h

@@ -23,6 +23,9 @@ typedef struct
 	size_t max_size;
 } Vec8_t;
 
+int
+is_valid(const Vec8_t* vec);
+
 Vec8_t
 create(const char* buf, const int len);
 
@@ -30,10 +33,10 @@ Vec8_t
 push_back(Vec8_t* vec, const char val);
 
 Vec8_t
-pop_back(Vec8_t* vec);
+pop_back(Vec8_t* ptr);
 
 Vec8_t
-reserve(Vec8_t* ptr, const size_t max_size);
+reserve(const Vec8_t* ptr, const size_t max_size);
 
 Vec8_t
 shrink_to_fit(Vec8_t* ptr);
@@ -58,12 +61,6 @@ clear(const Vec8_t* vec);
 char
 at(const Vec8_t* vec, int idx);
 
-__attribute__((overloadable)) Vec8_t*
-erase(Vec8_t* vec, size_t iter);
-
-__attribute__((overloadable)) Vec8_t*
-erase(Vec8_t* vec, size_t iter_start, size_t iter_end);
-
 void
 print_vec(const Vec8_t* vec);
 
@@ -83,25 +80,33 @@ int
 empty(const Vec8_t* vec);
 
 __attribute__((overloadable)) Vec8_t
-resize(Vec8_t* vec, size_t size);
+erase(const Vec8_t* vec, const size_t iter);
 
 __attribute__((overloadable)) Vec8_t
-resize(Vec8_t* vec, size_t size, char val);
+erase(const Vec8_t* vec, const size_t iter_start, const size_t iter_end);
 
 __attribute__((overloadable)) Vec8_t
-assign(Vec8_t* vec, const Vec8_t* iterator, size_t iter_start, size_t iter_end);
+resize(const Vec8_t* vec, const size_t size);
 
 __attribute__((overloadable)) Vec8_t
-assign(Vec8_t* vec, const size_t amount, char val);
+resize(Vec8_t* vec, const size_t size, const char val);
 
 __attribute__((overloadable)) Vec8_t
-insert(Vec8_t* vec, size_t iter, char val);
+assign(const Vec8_t* vec, const Vec8_t* iterator, const size_t iter_start,
+       const size_t iter_end);
 
 __attribute__((overloadable)) Vec8_t
-insert(Vec8_t* vec, size_t iter, size_t amount, char val);
+assign(const Vec8_t* vec, const size_t amount, const char val);
 
 __attribute__((overloadable)) Vec8_t
-insert(Vec8_t* dst_vec, size_t iter, Vec8_t* src_vec, size_t iter_start,
-       size_t iter_end);
+insert(const Vec8_t* vec, const size_t iter, const char val);
+
+__attribute__((overloadable)) Vec8_t
+insert(const Vec8_t* vec, const size_t iter, const size_t amount,
+       const char val);
+
+__attribute__((overloadable)) Vec8_t
+insert(const Vec8_t* dst_vec, const Vec8_t* src_vec, const size_t iter,
+       const size_t iter_start, const size_t iter_end);
 
 #endif

include/utils.h

@@ -3,6 +3,7 @@
 
 #include <stddef.h>
 #include <stdint.h>
+
 #define CAPACITY 1024
 #define SUCCESS 0
 
@@ -10,9 +11,10 @@
 #define ERR_ALLOC_FAIL 20
 #define ERR_BUF_NULL 21
 #define ERR_BAD_TYPE 22
-#define ERR_INVALID_SIZE 23
+#define ERR_SIZE_ZERO 23
 #define ERR_VECTOR_NULL 24
 #define ERR_MAX_PASSED 25
+#define ERR_OUT_OF_BOUNDS 26
 
 extern const char* error_messages[];
 
@@ -22,6 +24,7 @@ extern const char* error_messages[];
 	       error_messages[error_code]) /**< Print log error message*/
 
 #define find_len(arr) sizeof(arr) / sizeof(arr[0])
+
 static const size_t VEC_MAX = SIZE_MAX / sizeof(int);
 
 #endif

src/char.c

@@ -8,20 +8,35 @@
 
 #include "utils.h"
 
+int
+is_valid(const Vec8_t* vec)
+{
+	if (vec == nullptr)
+	{
+		LOGERROR(ERR_VECTOR_NULL);
+		return ERR_VECTOR_NULL;
+	}
+	else if (vec->arr == nullptr)
+	{
+		LOGERROR(ERR_BUF_NULL);
+		return ERR_BUF_NULL;
+	}
+	return SUCCESS;
+}
+
 // If -1 for len, returns a blank Vector with no allocated memory
 Vec8_t
 create(const char* buf, const int len)
 {
 	Vec8_t dst = { NULL, 0, CAPACITY, VEC_MAX };
-	if (len > -1)
+	if (len > 0)
 	{
 		char* dst_buf = calloc(CAPACITY, sizeof(char));
 		dst.arr = dst_buf;
 	}
-	if (!dst.arr)
+	if (len == -1)
 	{
-		LOG("Warning! Buffer not allocated, be careful if this was "
-		    "intentional");
+		// LOG("Warning! Buffer was forcibly not allocated.");
 		return dst;
 	}
 	if (buf)
@@ -36,39 +51,37 @@ create(const char* buf, const int len)
 }
 
 Vec8_t
-push_back(Vec8_t* vec, const char val)
+push_back(Vec8_t* ptr, const char val)
 {
-	if (!vec)
+	if (is_valid(ptr) == ERR_VECTOR_NULL)
 	{
-		LOGERROR(ERR_VECTOR_NULL);
 		return create(nullptr, -1);
 	}
-	Vec8_t dst = { NULL, vec->size, CAPACITY, vec->max_size };
+	Vec8_t dst = { NULL, ptr->size, CAPACITY, ptr->max_size };
 
-	if (!vec->arr)
+	if (is_valid(ptr) == ERR_BUF_NULL)
 	{
-		LOGERROR(ERR_BUF_NULL);
 		LOG("If you think this is wrong, reserve memory first");
 		return dst;
 	}
-	if (vec->size + 1 > vec->max_size)
+	if (ptr->size + 1 > ptr->max_size)
 	{
 		LOGERROR(ERR_MAX_PASSED);
-		dst = *vec;
+		dst = *ptr;
 		return dst;
 	}
 
 	char* dst_buf;
-	if (vec->size + 1 > vec->capacity)
+	if (ptr->size + 1 > ptr->capacity)
 	{
-		if (vec->capacity * 2 > vec->max_size)
+		if (ptr->capacity * 2 > ptr->max_size)
 		{
 			LOGERROR(ERR_MAX_PASSED);
-			dst = *vec;
+			dst = *ptr;
 			return dst;
 		}
-		dst.capacity = vec->capacity * 2;
-		dst_buf = reallocf(vec->arr, dst.capacity * sizeof(char));
+		dst.capacity = ptr->capacity * 2;
+		dst_buf = reallocf(ptr->arr, dst.capacity * sizeof(char));
 		if (!dst_buf)
 		{
 			LOGERROR(ERR_ALLOC_FAIL);
@@ -77,7 +90,7 @@ push_back(Vec8_t* vec, const char val)
 	}
 	else
 	{
-		dst_buf = vec->arr;
+		dst_buf = ptr->arr;
 	}
 	dst.arr = dst_buf;
 	dst.arr[dst.size] = val;
@@ -86,46 +99,40 @@ push_back(Vec8_t* vec, const char val)
 }
 
 Vec8_t
-pop_back(Vec8_t* vec)
+pop_back(Vec8_t* ptr)
 {
 	Vec8_t err = create(nullptr, -1);
-	if (!vec)
+	if (is_valid(ptr) != SUCCESS)
 	{
-		LOGERROR(ERR_VECTOR_NULL);
 		return err;
 	}
-	if (!vec->arr)
+	if (ptr->size < 1)
 	{
-		LOGERROR(ERR_BUF_NULL);
+		LOGERROR(ERR_SIZE_ZERO);
 		return err;
 	}
-	if (vec->size < 1)
-	{
-		LOGERROR(ERR_INVALID_SIZE);
-		return err;
-	}
-	Vec8_t dst = { NULL, vec->size - 1, vec->capacity, vec->max_size };
-	dst.arr = vec->arr;
+	Vec8_t dst = { NULL, ptr->size - 1, ptr->capacity, ptr->max_size };
+	dst.arr = ptr->arr;
 	dst.arr[dst.size] = 0;
 	return dst;
 }
 
 Vec8_t
-reserve(Vec8_t* ptr, const size_t max_size)
+reserve(const Vec8_t* ptr, const size_t max_size)
 {
 	Vec8_t ret = create(nullptr, -1);
-	if (!ptr)
+	ret.arr = ptr->arr;
+	if (is_valid(ptr) == ERR_VECTOR_NULL)
 	{
-		LOGERROR(ERR_VECTOR_NULL);
 		return ret;
 	}
-	if (!ptr->arr)
+	if (is_valid(ptr) == ERR_BUF_NULL)
 	{
 		ret.arr = calloc(max_size, sizeof(char));
 	}
-	if (ptr->arr)
+	if (is_valid(ptr) == SUCCESS)
 	{
-		ret.arr = reallocf(ptr->arr, max_size * sizeof(char));
+		ret.arr = reallocf(ret.arr, max_size * sizeof(char));
 		ret.size = ptr->size;
 		if (ret.size > max_size)
 		{
@@ -148,35 +155,37 @@ shrink_to_fit(Vec8_t* ptr)
 }
 
 int
-swap(Vec8_t* ptr, Vec8_t* ptr_other)
+swap(Vec8_t* ptr1, Vec8_t* ptr2)
 {
 	Vec8_t empty = create(nullptr, -1);
-	if (ptr == nullptr || ptr_other == nullptr || ptr->arr == nullptr ||
-	    ptr_other->arr == nullptr)
-		return 0;
-	empty.arr = ptr->arr;
-	ptr->arr = ptr_other->arr;
-	ptr_other->arr = empty.arr;
-	if (ptr != nullptr && ptr_other != nullptr)
+	if (is_valid(ptr1) == ERR_VECTOR_NULL ||
+	    is_valid(ptr2) == ERR_VECTOR_NULL)
 	{
-		empty.capacity = ptr->capacity;
-		ptr->capacity = ptr_other->capacity;
-		empty.size = ptr->size;
-		ptr->size = ptr_other->size;
-
-		ptr_other->capacity = empty.capacity;
-		ptr_other->size = empty.size;
-		return 1;
+		return ERR_VECTOR_NULL;
 	}
-	free(ptr);
-	free(ptr_other);
+	if (is_valid(ptr1) == ERR_BUF_NULL || is_valid(ptr2) == ERR_BUF_NULL)
+	{
+		return ERR_BUF_NULL;
+	}
+	empty.arr = ptr1->arr;
+	ptr1->arr = ptr2->arr;
+	ptr2->arr = empty.arr;
+
+	empty.capacity = ptr1->capacity;
+	empty.size = ptr1->size;
+	ptr1->capacity = ptr2->capacity;
+	ptr1->size = ptr2->size;
+
+	ptr2->capacity = empty.capacity;
+	ptr2->size = empty.size;
 	return 0;
 }
 
 char*
 data(const Vec8_t* ptr)
 {
-	if (ptr == nullptr || ptr->arr == nullptr) return nullptr;
+	if (is_valid(ptr) == ERR_BUF_NULL || is_valid(ptr) == ERR_VECTOR_NULL)
+		return nullptr;
 	return &ptr->arr[0];
 }
 
@@ -193,26 +202,26 @@ max_size(const Vec8_t* ptr)
 }
 
 void
-delete(const Vec8_t* vec)
+delete(const Vec8_t* ptr)
 {
-	if (vec->arr != nullptr)
+	if (is_valid(ptr) == SUCCESS)
 	{
-		free((void*)vec->arr);
+		free((void*)ptr->arr);
 	}
 }
 
 Vec8_t
-clear(const Vec8_t* vec)
+clear(const Vec8_t* ptr)
 {
 	Vec8_t dst = create(nullptr, -1);
-	if (!vec && !vec->arr)
+	if (is_valid(ptr) == ERR_VECTOR_NULL || is_valid(ptr) == ERR_BUF_NULL)
 	{
 		return dst;
 	}
-	dst.arr = vec->arr;
-	if (vec->size > 0)
+	dst.arr = ptr->arr;
+	if (ptr->size > 0)
 	{
-		for (int i = 0; i < vec->size; i++)
+		for (int i = 0; i < ptr->size; i++)
 		{
 			dst.arr[i] = 0;
 		}
@@ -222,299 +231,262 @@ clear(const Vec8_t* vec)
 }
 
 char
-at(const Vec8_t* vec, const int idx)
+at(const Vec8_t* ptr, const int idx)
 {
-	if (vec == nullptr)
+	if (is_valid(ptr) == ERR_VECTOR_NULL)
 	{
-		LOGERROR(ERR_VECTOR_NULL);
 		return ERR_VECTOR_NULL;
 	}
-	if (vec->arr == nullptr)
+	if (is_valid(ptr) == ERR_BUF_NULL)
 	{
-		LOGERROR(ERR_BUF_NULL);
 		return ERR_BUF_NULL;
 	}
-	if (vec->size <= idx)
+	if (ptr->size <= idx)
 	{
 		fprintf(stderr,
 			"At Index: [%i] is out of bounds for size: [%zu]", idx,
-			vec->size);
+			ptr->size);
 		exit(-4);
-		// return -4;
+		return ERR_OUT_OF_BOUNDS;
 	}
-	return vec->arr[idx];
-}
-
-__attribute__((overloadable)) Vec8_t*
-erase(Vec8_t* vec, const size_t iter)
-{
-	if (vec == nullptr) return nullptr;
-	if (vec->arr == nullptr) return nullptr;
-	if (iter >= vec->size) return nullptr;
-	memmove(&vec->arr[iter], &vec->arr[iter + 1],
-		(vec->size - iter - 1) * sizeof(char));
-	vec->arr[vec->size - 1] = 0;
-	vec->size--;
-	return vec;
-}
-
-__attribute__((overloadable)) Vec8_t*
-erase(Vec8_t* vec, const size_t iter_start, const size_t iter_end)
-{
-	if (vec == nullptr) return nullptr;
-	if (vec->arr == nullptr) return nullptr;
-	if (iter_start < 0 || iter_end > vec->size) return nullptr;
-	if (iter_start >= iter_end) return nullptr;
-	size_t diff = iter_end - iter_start;
-	memmove(&vec->arr[iter_start], &vec->arr[iter_end],
-		(vec->size - iter_end) * sizeof(char));
-	for (size_t i = vec->size - diff; i < vec->size; i++)
-	{
-		vec->arr[i] = 0;
-	}
-	vec->size -= diff;
-	return vec;
+	return ptr->arr[idx];
 }
 
 void
-print_vec(const Vec8_t* vec)
+print_vec(const Vec8_t* ptr)
 {
-	if (!vec)
-	{
-		LOGERROR(ERR_VECTOR_NULL);
+	if (is_valid(ptr) == ERR_VECTOR_NULL || is_valid(ptr) == ERR_BUF_NULL)
 		return;
-	}
-	for (int i = 0; i < vec->size; i++)
-	{
-		if (vec->arr[i])
-		{
-			printf("%c ", at(vec, i));
-		}
-		else
-		{
-			LOGERROR(ERR_INVALID_SIZE);
-		}
-	}
+	for (int i = 0; i < ptr->size; i++) printf("%c ", at(ptr, i));
 	printf("\n");
 }
 
 int
-begin(const Vec8_t* vec)
+begin(const Vec8_t* ptr)
 {
-	if (vec != nullptr && vec->arr != nullptr && vec->size > 0)
-	{
-		return 0;
-	}
-	return -1;
+	if (is_valid(ptr) == SUCCESS) return 0;
+	return FAILURE;
 }
 
 int
-end(const Vec8_t* vec)
+end(const Vec8_t* ptr)
 {
-	if (vec != nullptr && vec->arr != nullptr && vec->size > 0)
-	{
-		return (int)(vec->size - 1);
-	}
-	return -1;
+	if (is_valid(ptr) == SUCCESS) return (int)(ptr->size - 1);
+	return FAILURE;
 }
 
 char
-front(const Vec8_t* vec)
+front(const Vec8_t* ptr)
 {
-	return at(vec, 0);
+	return at(ptr, 0);
 }
 
 char
-back(const Vec8_t* vec)
+back(const Vec8_t* ptr)
 {
-	if (vec)
-	{
-		return at(vec, (int)vec->size - 1);
-	}
-	return -1;
+	if (is_valid(ptr) == ERR_VECTOR_NULL)
+		return at(ptr, (int)ptr->size - 1);
+	return FAILURE;
 }
 
 int
-empty(const Vec8_t* vec)
+empty(const Vec8_t* ptr)
 {
-	if (vec->size > 0)
-	{
-		return 1;
-	}
-	return 0;
+	if (is_valid(ptr) == ERR_VECTOR_NULL || is_valid(ptr) == ERR_BUF_NULL)
+		return FAILURE;
+	if (ptr->size <= 0) return SUCCESS;
+	return FAILURE;
 }
 
 __attribute__((overloadable)) Vec8_t
-resize(Vec8_t* vec, size_t size)
+erase(const Vec8_t* ptr, const size_t iter)
 {
-	Vec8_t nvec = create(nullptr, 0);
-	if (vec == nullptr || vec->arr == nullptr) return nvec;
-	if (size <= 0 || vec->size <= 0)
-	{
-		fprintf(stderr,
-			"Size or Vector Size is at or below 0 and is invalid");
-		return nvec;
-	}
-	for (size_t i = size; i < vec->size; i++)
-	{
-		vec->arr[i] = '\0';
-	}
-	return *vec;
+	Vec8_t dst = create(nullptr, -1);
+	if (is_valid(ptr) == ERR_VECTOR_NULL) return dst;
+	if (is_valid(ptr) == ERR_BUF_NULL) return dst;
+	if (iter >= ptr->size) return dst;
+	dst = *ptr;
+	memmove(&dst.arr[iter], &dst.arr[iter + 1],
+		(dst.size - iter - 1) * sizeof(char));
+	dst.arr[dst.size - 1] = 0;
+	dst.size--;
+	return dst;
 }
 
 __attribute__((overloadable)) Vec8_t
-resize(Vec8_t* vec, size_t size, char val)
+erase(const Vec8_t* ptr, const size_t iter_start, const size_t iter_end)
 {
-	Vec8_t nvec = create(nullptr, 0);
-	if (vec == nullptr || vec->arr == nullptr) return nvec;
-	if (size <= 0 || vec->size <= 0)
+	Vec8_t dst = create(nullptr, -1);
+	if (is_valid(ptr) == ERR_VECTOR_NULL) return dst;
+	if (is_valid(ptr) == ERR_BUF_NULL) return dst;
+	if (iter_start < 0 || iter_end > ptr->size) return dst;
+	if (iter_start >= iter_end) return dst;
+	dst = *ptr;
+	size_t diff = iter_end - iter_start;
+	memmove(&dst.arr[iter_start], &dst.arr[iter_end],
+		(dst.size - iter_end) * sizeof(char));
+	for (size_t i = dst.size - diff; i < dst.size; i++)
 	{
-		fprintf(stderr,
-			"Size or Vector Size is at or below 0 and is invalid");
-		return nvec;
+		dst.arr[i] = 0;
 	}
-	if (size == vec->size)
-	{
-		fprintf(stderr,
-			"Size and Vector Size are equal to each other and is "
-			"invalid");
-		return nvec;
+	dst.size -= diff;
+	return dst;
 }
-	if (size < vec->size)
-	{
-		fprintf(stderr, "Size is below Vector Size is invalid");
-		return nvec;
-	}
-	if (size >= vec->capacity)
-	{
-		nvec = reserve(vec, size);
-	}
-	size_t ret = vec->size;
-	vec->size = vec->size + (size - vec->size);
 
-	for (size_t i = ret; i < vec->size; i++)
+// TODO: Redo resize entirely
+__attribute__((overloadable)) Vec8_t
+resize(const Vec8_t* ptr, const size_t size)
 {
-		if (at(vec, (int)i) >= 0)
+	Vec8_t dst = create(nullptr, -1);
+	if (is_valid(ptr) == ERR_VECTOR_NULL || is_valid(ptr) == ERR_BUF_NULL)
+		return dst;
+	dst = *ptr;
+	if ((0 < size && size != ptr->size && size < ptr->size) ||
+	    is_valid(ptr) == ERR_SIZE_ZERO)
 	{
-			vec->arr[i] = val;
+		LOGERROR(ERR_SIZE_ZERO);
+		return dst;
 	}
+	for (size_t i = size - 1; i < ptr->size; i++)
+	{
+		dst.arr[i] = '\0';
 	}
-	return *vec;
+	dst.size = size;
+	return dst;
 }
 
 __attribute__((overloadable)) Vec8_t
-assign(Vec8_t* vec, const Vec8_t* iterator, size_t iter_start, size_t iter_end)
+resize(Vec8_t* ptr, const size_t size, const char val)
 {
-	Vec8_t ret = create(nullptr, 0);
-	if (vec == nullptr || vec->arr == nullptr) return ret;
-	if (iterator == nullptr || iterator->arr == nullptr) return ret;
-	if (iter_end <= iter_start) return ret;
-	vec = erase(vec, begin(vec), end(vec) + 1);
-	size_t res = iter_end - iter_start;
-	*vec = reserve(vec, res);
+	Vec8_t dst = create(nullptr, -1);
+	dst = *ptr;
+	if (is_valid(ptr) == ERR_VECTOR_NULL || is_valid(ptr) == ERR_BUF_NULL)
+		return dst;
+
+	if ((0 < size && size != dst.size && size < dst.size) ||
+	    is_valid(ptr) == ERR_SIZE_ZERO)
+	{
+		LOGERROR(ERR_SIZE_ZERO);
+		return dst;
+	}
+	if ((0 < size && size < dst.size) || is_valid(ptr) == ERR_SIZE_ZERO)
+	{
+		LOGERROR(ERR_SIZE_ZERO);
+		return dst;
+	}
+	if (size >= dst.capacity)
+	{
+		dst = reserve(&dst, size);
+	}
+	dst.size = ptr->size + (size - ptr->size);
+
+	for (size_t i = ptr->size; i < dst.size; i++)
+	{
+		if (at(&dst, (int)i) >= 0)
+		{
+			dst.arr[i] = val;
+		}
+	}
+	dst.size = size;
+	return dst;
+}
+
+__attribute__((overloadable)) Vec8_t
+assign(const Vec8_t* ptr, const Vec8_t* iterator, const size_t iter_start,
+       const size_t iter_end)
+{
+	Vec8_t dst = create(nullptr, -1);
+	if (is_valid(ptr) == ERR_VECTOR_NULL || is_valid(ptr) == ERR_BUF_NULL)
+		return dst;
+	if (is_valid(iterator) == ERR_VECTOR_NULL ||
+	    is_valid(iterator) == ERR_BUF_NULL)
+		return dst;
+	if (iter_end <= iter_start) return dst;
+	dst = erase(ptr, begin(ptr), end(ptr) + 1);
+	dst = reserve(&dst, (iter_end - iter_start));
 	for (size_t i = iter_start; i < iter_end; i++)
 	{
-		*vec = push_back(vec, at(iterator, (int)i));
+		dst = push_back(&dst, at(iterator, (int)i));
 	}
-	return *vec;
+	return dst;
 }
 
 __attribute__((overloadable)) Vec8_t
-assign(Vec8_t* vec, const size_t amount, char val)
+assign(const Vec8_t* ptr, const size_t amount, const char val)
 {
-	if (vec == nullptr || vec->arr == nullptr) return create(nullptr, 0);
-	vec = erase(vec, begin(vec), end(vec) + 1);
-	*vec = reserve(vec, amount);
+	Vec8_t dst = create(nullptr, -1);
+	if (is_valid(ptr) == ERR_VECTOR_NULL || is_valid(ptr) == ERR_BUF_NULL)
+		return create(nullptr, -1);
+	dst = erase(&dst, begin(&dst), end(&dst) + 1);
+	dst = reserve(&dst, amount);
 	for (int i = 0; i < amount; i++)
 	{
-		*vec = push_back(vec, val);
+		dst = push_back(&dst, val);
 	}
-	return *vec;
+	return dst;
 }
 
-// TODO: Add error checking and null checking
-// Follows array style
 __attribute__((overloadable)) Vec8_t
-insert(Vec8_t* vec, size_t iter, char val)
+insert(const Vec8_t* ptr, const size_t iter, const char val)
 {
-	size_t last = vec->size;
-	*vec = push_back(vec, 0);
-	for (size_t i = vec->size - 1; i > iter; i--)
+	Vec8_t dst = create(nullptr, -1);
+	if (is_valid(ptr) == ERR_VECTOR_NULL || is_valid(ptr) == ERR_BUF_NULL)
 	{
-		vec->arr[i] = vec->arr[i - 1];
+		return dst;
 	}
-	vec->arr[iter] = val;
+	if (iter < 0)
+	{
+		LOGERROR(ERR_SIZE_ZERO);
+		return dst;
+	}
+	dst = *ptr;
+	dst = push_back(&dst, 0);
+	for (size_t i = dst.size - 1; i > iter; i--)
+	{
+		dst.arr[i] = dst.arr[i - 1];
+	}
+	dst.arr[iter] = val;
 
-	return *vec;
+	return dst;
 }
 
-// TODO: Add error checking and null checking
-// Follows array style
 __attribute__((overloadable)) Vec8_t
-insert(Vec8_t* vec, size_t iter, size_t amount, char val)
+insert(const Vec8_t* ptr, const size_t iter, const size_t amount,
+       const char val)
 {
-	size_t last = vec->size;
-	char cpy[vec->size - (iter)];
-	size_t cpy_size = (vec->size - (iter));
-	int k = 0;
-	for (size_t i = iter; i < vec->size; i++)
+	Vec8_t dst = create(nullptr, -1);
+	if (is_valid(ptr) == ERR_VECTOR_NULL || is_valid(ptr) == ERR_BUF_NULL)
 	{
-		cpy[k] = vec->arr[i];
-		k++;
+		return dst;
 	}
-	for (int i = 0; i < amount; i++)
+	if (iter < 0 || amount <= 0)
 	{
-		*vec = push_back(vec, 0);
+		LOGERROR(ERR_SIZE_ZERO);
+		return dst;
+	}
+	dst = *ptr;
+	for (size_t i = iter; i < iter + amount; i++)
+	{
+		dst = insert(&dst, i, val);
+	}
+	return dst;
 }
 
-	if ((iter - 1) + amount <= last)
-	{
-		for (int i = iter; i < vec->size; i++)
-		{
-			vec->arr[i] = 0;
-		}
-		size_t j = iter - 1 + amount;
-		for (int i = 0; i < cpy_size; i++)
-		{
-			vec->arr[j + i] = cpy[i];
-		}
-		for (int i = iter; i < iter + amount - 1; i++)
-		{
-			vec->arr[i] = val;
-		}
-	}
-	else
-	{
-		return *vec;
-	}
-
-	return *vec;
-}
-
-// TODO: Add error checking and null checking
-// NOTE: It might be a good idea to move the iter ahead of the src_vec
 __attribute__((overloadable)) Vec8_t
-insert(Vec8_t* dst_vec, size_t iter, Vec8_t* src_vec, size_t iter_start,
-       size_t iter_end)
+insert(const Vec8_t* dst_vec, const Vec8_t* src_vec, const size_t iter,
+       const size_t iter_start, const size_t iter_end)
 {
-	size_t cpy_size = iter_end - iter_start;
-	char cpy[cpy_size];
-	int j = 0;
-	for (int i = iter_start; i < iter_end; i++)
+	Vec8_t dst = create(nullptr, -1);
+	if (is_valid(dst_vec) == ERR_VECTOR_NULL ||
+	    is_valid(dst_vec) == ERR_BUF_NULL)
+		return dst;
+	if (is_valid(src_vec) == ERR_VECTOR_NULL ||
+	    is_valid(src_vec) == ERR_BUF_NULL)
+		return dst;
+	dst = *dst_vec;
+	for (size_t i = iter_start; i < iter_end; i++)
 	{
-		cpy[j] = src_vec->arr[i];
-		j++;
+		dst = insert(&dst, iter + (i - iter_start), src_vec->arr[i]);
 	}
-	for (int i = 0; i < cpy_size; i++)
-	{
-		printf("%c ", cpy[i]);
-	}
-	printf("\n");
-	for (int i = 0; i < iter_end - iter_start; i++)
-	{
-		insert(dst_vec, (iter_start - 1) + i, cpy[i]);
-	}
-	return *dst_vec;
-
-	// Inserts over an iteration, [0, 5]
+	return dst;
 }

src/main.c

@@ -22,18 +22,25 @@
 int
 main()
 {
-	char arr[] = { '1', '2', '3', '4' };
-	Vec8_t v1 = create(arr, find_len(arr));
-	Vec8_t v2 = create((char[]) { 'a', 'b', 'c', 'd' }, 4);
-
+	char ar1[] = { '1', '2', '3', '4' };
+	char ar2[] = { 'a', 'b', 'c', 'd' };
+	Vec8_t v1 = create(ar1, find_len(ar1));
+	Vec8_t v2 = create(ar2, find_len(ar2));
+	// print_vec(&v1);
+	// printf("Hello\n");
+	// v1 = assign(&v1, &v2, 0, 1);
+	v1 = insert(&v1, 1, 5, 'a');
+	// printf("RESERVED SIZE: %zu", v1.max_size);
 	print_vec(&v1);
-	print_vec(&v2);
+	// v2 = resize(&v2, 3);
 
-	if (swap(&v1, &v2))
-	{
-		print_vec(&v1);
-		print_vec(&v2);
-	}
+	// print_vec(&v2);
+
+	// if (swap(&v1, &v2))
+	// {
+	// 	print_vec(&v1);
+	// 	print_vec(&v2);
+	// }
 	// Vec8_t v1 = create(nullptr, 0);
 	// v1 = reserve(&v1, 10);
 	// v1 = pop_back(&v1);

src/utils.c

@@ -4,9 +4,11 @@ const char* error_messages[] = {
 	[ERR_ALLOC_FAIL] = "Calloc :- Failed to allocate",
 	[ERR_BUF_NULL] = "Buffer :- NULL",
 	[ERR_BAD_TYPE] = "Type :- Does not match vector type",
-	[ERR_INVALID_SIZE] = "Size :- Size is 0 or invalid",
+	[ERR_SIZE_ZERO] = "Size :- Size is or is less than 0 or invalid",
 	[ERR_VECTOR_NULL] = "Vector :- Given vector is null",
 	[ERR_MAX_PASSED] = "Max :- Vector Max value is overloaded",
+	[ERR_OUT_OF_BOUNDS] = "Bounds:- Value is out of bounds",
+
 	// [ERR_CREATION_FAIL] = "Buffer creation failed",
 	// [ERR_MALLOC_NULL] = "Malloc Failed to allocate",
 };