use type-specific vectors instead of generic ones

+ An attempt at speeding up function calls in the interpreted mode

1 files changed, 42 insertions, 41 deletions

diff --git a/src/vec.h b/src/vec.h
index 7e6b5be..37f29f6 100644
--- a/src/vec.h
+++ b/src/vec.h
@@ -1,99 +1,99 @@
-#ifndef VEC_H
-#define VEC_H
+#ifndef VEC_TYPE
+#error "Need vector type"
+#endif
+
+#ifndef VEC_NAME
+#error "Need vector name"
+#endif
 
 #include <stddef.h>
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
 
-struct vec {
+#define UNDERSCORE2(a, b) a##_##b
+#define UNDERSCORE(a, b) UNDERSCORE2(a, b)
+#define VEC(n) UNDERSCORE(VEC_NAME, n)
+
+
+#define VEC_STRUCT VEC_NAME
+struct VEC_STRUCT {
 	size_t n;
 	size_t s;
-	size_t ns;
-	void *buf;
+	VEC_TYPE *buf;
 };
 
-#define foreach_vec(iter, v) \
-	for (size_t iter = 0; iter < vec_len(&v); ++iter)
-
-#define vect_at(type, v, i) \
-	*(type *)vec_at(&v, i)
-
-#define vect_append(type, v, e) \
-	vec_append(&v, (type *)(e))
-
-#define vect_back(type, v) \
-	*(type *)vec_back(&v)
+#ifndef VEC_H
+#define VEC_H
 
-#define vect_pop(type, v) \
-	*(type *)vec_pop(&v)
+#define foreach_vec(iter, v) \
+	for (size_t iter = 0; iter < (v).n; ++iter)
 
 #define vec_uninit(v) \
 	(v.buf == NULL)
+#endif
 
-static inline struct vec vec_create(size_t ns)
+static inline struct VEC_STRUCT VEC(create)()
 {
 	const size_t s = 8;
-	return (struct vec) {
+	return (struct VEC_STRUCT) {
 		       .n = 0,
 		       .s = s,
-		       .ns = ns,
-		       .buf = malloc(s * ns),
+		       .buf = malloc(s * sizeof(VEC_TYPE)),
 	};
 }
 
-static inline size_t vec_len(struct vec *v)
+static inline size_t VEC(len)(struct VEC_STRUCT *v)
 {
 	return v->n;
 }
 
-static inline void *vec_at(struct vec *v, size_t i)
+static inline VEC_TYPE *VEC(at)(struct VEC_STRUCT *v, size_t i)
 {
 	assert(i < v->n && "out of vector bounds");
-	return v->buf + i * v->ns;
+	return &v->buf[i];
 }
 
-static inline void *vec_back(struct vec *v)
+static inline VEC_TYPE *VEC(back)(struct VEC_STRUCT *v)
 {
 	assert(v->n);
-	return v->buf + (v->n - 1) * v->ns;
+	return &v->buf[v->n - 1];
 }
 
-static inline void *vec_pop(struct vec *v)
+static inline VEC_TYPE *VEC(pop)(struct VEC_STRUCT *v)
 {
 	assert(v->n && "attempting to pop empty vector");
 	v->n--;
-	return v->buf + v->n * v->ns;
+	return &v->buf[v->n];
 }
 
-static inline void vec_append(struct vec *v, void *n)
+static inline void VEC(append)(struct VEC_STRUCT *v, VEC_TYPE n)
 {
 	v->n++;
 	if (v->n >= v->s) {
 		v->s *= 2;
-		v->buf = realloc(v->buf, v->s * v->ns);
+		v->buf = realloc(v->buf, v->s * sizeof(VEC_TYPE));
 	}
 
-	void *p = vec_at(v, v->n - 1);
-	memcpy(p, n, v->ns);
+	v->buf[v->n - 1] = n;
 }
 
-static inline void vec_reset(struct vec *v)
+static inline void VEC(reset)(struct VEC_STRUCT *v)
 {
 	v->n = 0;
 }
 
-static inline void vec_destroy(struct vec *v) {
+static inline void VEC(destroy)(struct VEC_STRUCT *v) {
 	free(v->buf);
 }
 
 typedef int (*vec_comp_t)(void *a, void *b);
-static inline void vec_sort(struct vec *v, vec_comp_t comp)
+static inline void VEC(sort)(struct VEC_STRUCT *v, vec_comp_t comp)
 {
-	qsort(v->buf, v->n, v->ns, (__compar_fn_t)comp);
+	qsort(v->buf, v->n, sizeof(VEC_TYPE), (__compar_fn_t)comp);
 }
 
-static inline void vec_reserve(struct vec *v, size_t n)
+static inline void VEC(reserve)(struct VEC_STRUCT *v, size_t n)
 {
 	if (v->n >= n)
 		return;
@@ -101,14 +101,15 @@ static inline void vec_reserve(struct vec *v, size_t n)
 	v->n = n;
 	if (v->s < v->n) {
 		v->s *= 2;
-		v->buf = realloc(v->buf, v->s * v->ns);
+		v->buf = realloc(v->buf, v->s * sizeof(VEC_TYPE));
 	}
 }
 
-static inline void vec_shrink(struct vec *v, size_t n)
+static inline void VEC(shrink)(struct VEC_STRUCT *v, size_t n)
 {
 	assert(v->n >= n);
 	v->n = n;
 }
 
-#endif /* VEC_H */
+#undef VEC_TYPE
+#undef VEC_NAME