REFACTOR: Error handling

src/main.c

@@ -15,11 +15,152 @@
 #include <libvec.h>
 #include <stddef.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 
+#include "lib/utils/utils.h"
+
+void
+print_bits(unsigned int num);
+
+typedef struct
+{
+	char* _internal_arr;
+	size_t _internal_size;
+	size_t _internal_capacity;
+	size_t _internal_max_size;
+} _VecCharInternal;
+
+/* 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 err;
+	size_t value;
+	char* origin;  // Where the main bug started
+} _err_t;
+
+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;
+}
+
+unsigned int
+_vec_char_raise_err(const _VecCharInternal* ptr, unsigned int mask)
+
+{
+	unsigned int res = SUCCESS;
+	res |= mask;
+	if (ptr == nullptr) res |= ERR_VEC_NULL;
+	if (ptr->_internal_arr == nullptr) res |= ERR_BUF_NULL;
+
+	return res;
+}
+
+_VecCharInternal
+_vec_char_create(const char* src, const size_t size)
+{
+	unsigned int err = 0;
+	_VecCharInternal self = {
+		._internal_arr = NULL,
+		._internal_size = 0,
+		._internal_capacity = CAPACITY,
+		._internal_max_size = VEC_MAX,
+	};
+	if (size >= self._internal_max_size)
+	{
+		LOG("If you need more memory to start, create a blank and "
+		    "reserve.");
+		return self;
+	}
+	if (self._internal_capacity < size)
+	{
+		size_t dst_cap = self._internal_capacity;
+		while (dst_cap < size && dst_cap * 2 < self._internal_max_size)
+			dst_cap *= 2;
+		self._internal_capacity = (dst_cap < size) ? size : dst_cap;
+	}
+	if (size > 0)
+	{
+		self._internal_arr =
+		    calloc(self._internal_capacity, sizeof(char));
+		err = _vec_char_raise_err(&self, err);
+		if ((err & SUCCESS) == 1)
+		{
+			self._internal_arr = NULL;
+			vec_print_errs(err);
+			free(self._internal_arr);
+			return self;
+		}
+	}
+	if (!src) err |= ERR_BUF_NULL;
+	else
+	{
+		for (size_t i = 0; i < size; i++)
+		{
+			self._internal_arr[i] = src[i];
+			self._internal_size++;
+		}
+	}
+	vec_print_errs(err);
+	return self;
+}
+
+void
+print_bits(unsigned int num)
+{
+	// Determine the number of bits in an unsigned int (usually 32)
+	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--)
+	{
+		// Shift a 1 to the i-th position and check if that bit is set
+		int bit = (num >> i) & 1;
+		printf("%d", bit);
+
+		// Optional: Add a space every 4 or 8 bits for readability
+		if (i % 8 == 0)
+		{
+			printf(" ");
+		}
+	}
+	printf("\n");
+}
+
 int
 main()
 {
+	char res[4] = { 'a', 'b', 'c', 'd' };
+	_VecCharInternal v1 = _vec_char_create(nullptr, 3);
+	unsigned int mark = 1 << 0;
+	_err_t err = { 0, 0, "Te" };
+	_vec_update_origin(&err, "Test");
+	printf("%s", err.origin);
+	// for (int i = 0; i < VEC_FAULT_BITS; i++)
+	// {
+	// 	print_bits(mark);
+	// 	mark <<= 1;
+	// }
+	// const char* str = vec_get_error_desc(ERR_ALLOC_FAIL);
+	// const unsigned int error = ERR_BUF_NULL;
+	// if (!(ERR_ALLOC_FAIL & SUCCESS))
+	// {
+	// 	printf("Hello\n");
+	// }
+	// printf("%s", str);
 	// char ar1[] = { '1', '2', '3', '4' };
 	// char ar2[] = { 'a', 'b', 'c', 'd' };
 	// Vec8_t v1 = create(ar2, find_len(ar2));