Remove typeof dependency

Signed-off-by: Slendi <slendi@socopon.com>

CMakeLists.txt

@@ -4,7 +4,7 @@ project(DCFG C)
 
 set(CMAKE_C_STANDARD 99)
 set(CMAKE_C_STANDARD_REQUIRED ON)
-set(CMAKE_C_EXTENSIONS ON)  # Would've done OFF but I need typeof (for now)
+set(CMAKE_C_EXTENSIONS OFF)
 
 option(DCFG_PTHREAD_SUPPORT "Enable pthreads support" ON)
 option(DCFG_POSIX_SUPPORT   "Enable POSIX support"    ON)

build.sh

@@ -4,7 +4,7 @@ set -e
 
 BUILD_DIR="BUILD"
 INSTALL_DIR="$(pwd)/install"
-CFLAGS="-std=gnu99 -Wall -Wextra -pedantic -Werror -Wno-newline-eof -Wno-language-extension-token"
+CFLAGS="-std=c99 -Wall -Wextra -pedantic -Werror -Wno-newline-eof -Wno-language-extension-token"
 BUILD_SHARED=1
 PTHREAD_SUPPORT=1
 POSIX_SUPPORT=1

src/dcfg.c

@@ -788,7 +788,7 @@ AST *parser_parse_dot_access(Parser *parser, StringView *current)
 		return NULL;
 	}
 	if (current) {
-		vector_add(&accessv, *current);
+		vector_add(&accessv, StringView, *current);
 	}
 
 	SourceLocation loc = parser->cur.location;
@@ -800,7 +800,7 @@ AST *parser_parse_dot_access(Parser *parser, StringView *current)
 		}
 
 		last_loc = parser->cur.location;
-		vector_add(&accessv, parser->cur.v.s);
+		vector_add(&accessv, StringView, parser->cur.v.s);
 
 		if (!Parser_next(parser)) {
 			strcpy(parser->instance->last_error,
@@ -881,7 +881,7 @@ AST *parser_parse_value(Parser *parser)
 						return NULL;
 					}
 
-					vector_add(&ast->v.f.argv, parser->cur.v.s);
+					vector_add(&ast->v.f.argv, StringView, parser->cur.v.s);
 					if (!Parser_next(parser)) {
 						vector_free(ast->v.f.argv);
 						FREE(ast);
@@ -933,7 +933,7 @@ AST *parser_parse_value(Parser *parser)
 				FREE(ast);
 				return NULL;
 			}
-			vector_add(&ast->v.a.childv, value);
+			vector_add(&ast->v.a.childv, AST *, value);
 		}
 		ast->location.range.end = rbracket_loc.range.end;
 		return ast;
@@ -991,7 +991,7 @@ AST *parser_parse_value(Parser *parser)
 				.k = key,
 				.v = value,
 			};
-			vector_add(&ast->v.bl.entryv, entry);
+			vector_add(&ast->v.bl.entryv, ASTBlock_Entry, entry);
 		}
 		return ast;
 	} else if (Parser_accept(parser, TokenType_LParen, NULL)) {
@@ -1020,7 +1020,7 @@ AST *parser_parse_value(Parser *parser)
 				return NULL;
 			}
 
-			vector_add(&ast->v.fc.argv, value);
+			vector_add(&ast->v.fc.argv, AST *, value);
 		}
 
 		ast->location.range.end = rparen_loc.range.end;
@@ -1069,7 +1069,7 @@ static Value *ensure_child_obj(Instance *inst, Value *parent, StringView key)
 	child->v.o.entryv = vector_create();
 
 	ValueObjectEntry e = { .k = key, .v = child };
-	vector_add(&obj->entryv, e);
+	vector_add(&obj->entryv, ValueObjectEntry, e);
 	return child;
 }
 
@@ -1150,7 +1150,7 @@ Value *ast_to_value(dcfg_Instance *instance, AST *root)
 
 			if (!replaced) {
 				ValueObjectEntry new_e = { .k = field, .v = rhs };
-				vector_add(&obj->entryv, new_e);
+				vector_add(&obj->entryv, ValueObjectEntry, new_e);
 			}
 		}
 	} else if (root->kind == ASTKind_Array) {
@@ -1166,14 +1166,14 @@ Value *ast_to_value(dcfg_Instance *instance, AST *root)
 				FREE(value);
 				return NULL;
 			}
-			vector_add(&value->v.a.valuev, v);
+			vector_add(&value->v.a.valuev, Value *, v);
 		}
 	} else if (root->kind == ASTKind_Function) {
 		value->type = dcfg_ValueType_Function;
 		value->v.f.is_builtin = false;
 		value->v.f.v.f.argv = vector_create();
 		for (size_t i = 0; i < vector_size(root->v.f.argv); i++) {
-			vector_add(&value->v.f.v.f.argv, root->v.f.argv[i]);
+			vector_add(&value->v.f.v.f.argv, StringView, root->v.f.argv[i]);
 		}
 		Value *v = ast_to_value(instance, root->v.f.body);
 		if (!v) {
@@ -1206,7 +1206,7 @@ Value *ast_to_value(dcfg_Instance *instance, AST *root)
 				FREE(value);
 				return NULL;
 			}
-			vector_add(&value->v.c.argv, arg);
+			vector_add(&value->v.c.argv, Value *, arg);
 		}
 	}
 	return value;
@@ -1313,10 +1313,10 @@ dcfg_Value *dcfg_parse(dcfg_Instance *instance, dcfg_StringView const file_path)
 	}
 	instance->last_error[0] = '\0';
 
-	vector_add(&instance->sourcev, str);
+	vector_add(&instance->sourcev, StringView, str);
 	v->i_sourcev_idx = vector_size(instance->sourcev) - 1;
 
-	vector_add(&instance->source_pathv, abs_sv);
+	vector_add(&instance->source_pathv, StringView, abs_sv);
 	v->i_source_pathv_idx = vector_size(instance->source_pathv) - 1;
 
 	return v;

src/vendor/vec.c

@@ -33,18 +33,20 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "vec.h"
 #include <string.h>
 
-typedef struct
+typedef struct {
-{
 	vec_size_t size;
 	vec_size_t capacity;
-	unsigned char data[]; 
+	unsigned char data[];
 } vector_header;
 
-vector_header* vector_get_header(vector vec) { return &((vector_header*)vec)[-1]; }
+vector_header *vector_get_header(vector vec)
+{
+	return &((vector_header *)vec)[-1];
+}
 
 vector vector_create(void)
 {
-	vector_header* h = (vector_header*)malloc(sizeof(vector_header));
+	vector_header *h = (vector_header *)malloc(sizeof(vector_header));
 	h->capacity = 0;
 	h->size = 0;
 
@@ -55,28 +57,28 @@ void vector_free(vector vec) { free(vector_get_header(vec)); }
 
 vec_size_t vector_size(vector vec) { return vector_get_header(vec)->size; }
 
-vec_size_t vector_capacity(vector vec) { return vector_get_header(vec)->capacity; }
+vec_size_t vector_capacity(vector vec)
+{
+	return vector_get_header(vec)->capacity;
+}
 
-vector_header* vector_realloc(vector_header* h, vec_type_t type_size)
+vector_header *vector_realloc(vector_header *h, vec_type_t type_size)
 {
 	vec_size_t new_capacity = (h->capacity == 0) ? 1 : h->capacity * 2;
-	vector_header* new_h = (vector_header*)realloc(h, sizeof(vector_header) + new_capacity * type_size);
+	vector_header *new_h = (vector_header *)realloc(
+	    h, sizeof(vector_header) + new_capacity * type_size);
 	new_h->capacity = new_capacity;
 
 	return new_h;
 }
 
-bool vector_has_space(vector_header* h)
+bool vector_has_space(vector_header *h) { return h->capacity - h->size > 0; }
-{
-	return h->capacity - h->size > 0;
-}
 
-void* _vector_add_dst(vector* vec_addr, vec_type_t type_size)
+void *_vector_add_dst(vector *vec_addr, vec_type_t type_size)
 {
-	vector_header* h = vector_get_header(*vec_addr);
+	vector_header *h = vector_get_header(*vec_addr);
 
-	if (!vector_has_space(h))
+	if (!vector_has_space(h)) {
-	{
 		h = vector_realloc(h, type_size);
 		*vec_addr = h->data;
 	}
@@ -84,34 +86,32 @@ void* _vector_add_dst(vector* vec_addr, vec_type_t type_size)
 	return &h->data[type_size * h->size++];
 }
 
-void* _vector_insert_dst(vector* vec_addr, vec_type_t type_size, vec_size_t pos)
+void *_vector_insert_dst(vector *vec_addr, vec_type_t type_size, vec_size_t pos)
 {
-	vector_header* h = vector_get_header(*vec_addr);
+	vector_header *h = vector_get_header(*vec_addr);
 
 	vec_size_t new_length = h->size + 1;
 
 	// make sure there is enough room for the new element
-	if (!vector_has_space(h))
+	if (!vector_has_space(h)) {
-	{
 		h = vector_realloc(h, type_size);
 		*vec_addr = h->data;
 	}
 	// move trailing elements
-	memmove(&h->data[(pos + 1) * type_size],
+	memmove(&h->data[(pos + 1) * type_size], &h->data[pos * type_size],
-		&h->data[pos * type_size],
+	    (h->size - pos) * type_size);
-		(h->size - pos) * type_size);
 
 	h->size = new_length;
 
 	return &h->data[pos * type_size];
 }
 
-void _vector_erase(vector vec, vec_type_t type_size, vec_size_t pos, vec_size_t len)
+void _vector_erase(
+    vector vec, vec_type_t type_size, vec_size_t pos, vec_size_t len)
 {
-	vector_header* h = vector_get_header(vec);
+	vector_header *h = vector_get_header(vec);
-	memmove(&h->data[pos * type_size],
+	memmove(&h->data[pos * type_size], &h->data[(pos + len) * type_size],
-		&h->data[(pos + len) * type_size],
+	    (h->size - pos - len) * type_size);
-		(h->size - pos - len) * type_size);
 
 	h->size -= len;
 }
@@ -123,26 +123,28 @@ void _vector_remove(vector vec, vec_type_t type_size, vec_size_t pos)
 
 void vector_pop(vector vec) { --vector_get_header(vec)->size; }
 
-void _vector_reserve(vector* vec_addr, vec_type_t type_size, vec_size_t capacity)
+void _vector_reserve(
+    vector *vec_addr, vec_type_t type_size, vec_size_t capacity)
 {
-	vector_header* h = vector_get_header(*vec_addr);
+	vector_header *h = vector_get_header(*vec_addr);
-	if (h->capacity >= capacity)
+	if (h->capacity >= capacity) {
-	{
 		return;
 	}
 
-	h = (vector_header*)realloc(h, sizeof(vector_header) + capacity * type_size);
+	h = (vector_header *)realloc(
+	    h, sizeof(vector_header) + capacity * type_size);
 	h->capacity = capacity;
 	*vec_addr = &h->data;
 }
 
 vector _vector_copy(vector vec, vec_type_t type_size)
 {
-	vector_header* h = vector_get_header(vec);
+	vector_header *h = vector_get_header(vec);
 	size_t alloc_size = sizeof(vector_header) + h->size * type_size;
-	vector_header* copy_h = (vector_header*)malloc(alloc_size);
+	vector_header *copy_h = (vector_header *)malloc(alloc_size);
 	memcpy(copy_h, h, alloc_size);
 	copy_h->capacity = copy_h->size;
 
 	return &copy_h->data;
-}
+}
+

src/vendor/vec.h

@@ -33,11 +33,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef vec_h
 #define vec_h
 
-#ifdef __cpp_decltype
-#include <type_traits>
-#define typeof(T) std::remove_reference<std::add_lvalue_reference<decltype(T)>::type>::type
-#endif
-
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -46,72 +41,50 @@ extern "C" {
 #include <stdlib.h>
 
 // generic type for internal use
-typedef void* vector;
+typedef void *vector;
 // number of elements in a vector
 typedef size_t vec_size_t;
 // number of bytes for a type
 typedef size_t vec_type_t;
 
-// TODO: more rigorous check for typeof support with different compilers
+#define vector_add_dst(vec_addr, type) \
-#if _MSC_VER == 0 || __STDC_VERSION__ >= 202311L || defined __cpp_decltype
+	((type *)_vector_add_dst((vector *)vec_addr, sizeof(type)))
+#define vector_insert_dst(vec_addr, type, pos) \
+	((type *)_vector_insert_dst((vector *)vec_addr, sizeof(type), pos))
 
-// shortcut defines
+#define vector_add(vec_addr, type, value) \
-
-// vec_addr is a vector* (aka type**)
-#define vector_add_dst(vec_addr)\
-	((typeof(*vec_addr))(\
-	    _vector_add_dst((vector*)vec_addr, sizeof(**vec_addr))\
-	))
-#define vector_insert_dst(vec_addr, pos)\
-	((typeof(*vec_addr))(\
-	    _vector_insert_dst((vector*)vec_addr, sizeof(**vec_addr), pos)))
-
-#define vector_add(vec_addr, value)\
-	(*vector_add_dst(vec_addr) = value)
-#define vector_insert(vec_addr, pos, value)\
-	(*vector_insert_dst(vec_addr, pos) = value)
-
-#else
-
-#define vector_add_dst(vec_addr, type)\
-	((type*)_vector_add_dst((vector*)vec_addr, sizeof(type)))
-#define vector_insert_dst(vec_addr, type, pos)\
-	((type*)_vector_insert_dst((vector*)vec_addr, sizeof(type), pos))
-
-#define vector_add(vec_addr, type, value)\
 	(*vector_add_dst(vec_addr, type) = value)
-#define vector_insert(vec_addr, type, pos, value)\
+#define vector_insert(vec_addr, type, pos, value) \
 	(*vector_insert_dst(vec_addr, type, pos) = value)
 
-#endif
-
 // vec is a vector (aka type*)
-#define vector_erase(vec, pos, len)\
+#define vector_erase(vec, pos, len) \
 	(_vector_erase((vector)vec, sizeof(*vec), pos, len))
-#define vector_remove(vec, pos)\
+#define vector_remove(vec, pos) (_vector_remove((vector)vec, sizeof(*vec), pos))
-	(_vector_remove((vector)vec, sizeof(*vec), pos))
 
-#define vector_reserve(vec_addr, capacity)\
+#define vector_reserve(vec_addr, capacity) \
-	(_vector_reserve((vector*)vec_addr, sizeof(**vec_addr), capacity))
+	(_vector_reserve((vector *)vec_addr, sizeof(**vec_addr), capacity))
 
-#define vector_copy(vec)\
+#define vector_copy(vec) (_vector_copy((vector)vec, sizeof(*vec)))
-	(_vector_copy((vector)vec, sizeof(*vec)))
 
 vector vector_create(void);
 
 void vector_free(vector vec);
 
-void* _vector_add_dst(vector* vec_addr, vec_type_t type_size);
+void *_vector_add_dst(vector *vec_addr, vec_type_t type_size);
 
-void* _vector_insert_dst(vector* vec_addr, vec_type_t type_size, vec_size_t pos);
+void *_vector_insert_dst(
+    vector *vec_addr, vec_type_t type_size, vec_size_t pos);
 
-void _vector_erase(vector vec_addr, vec_type_t type_size, vec_size_t pos, vec_size_t len);
+void _vector_erase(
+    vector vec_addr, vec_type_t type_size, vec_size_t pos, vec_size_t len);
 
 void _vector_remove(vector vec_addr, vec_type_t type_size, vec_size_t pos);
 
 void vector_pop(vector vec);
 
-void _vector_reserve(vector* vec_addr, vec_type_t type_size, vec_size_t capacity);
+void _vector_reserve(
+    vector *vec_addr, vec_type_t type_size, vec_size_t capacity);
 
 vector _vector_copy(vector vec, vec_type_t type_size);