REFACTOR: Made everything public and new name scheme

2026-10-14 10:20:19 -04:00
parent 813390b6ac
commit 4d96592a1e
9 changed files with 713 additions and 853 deletions
@@ -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
@@ -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
@@ -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
@@ -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