Centralise engine access, add Portal FOV changer

- A bunch of stuff is now defined in one header, engineapi.h
- engineapi.c is responsible for setting up any interfaces/stuff that's
  used in more than one place
- mkgamedata is pretty much rewritten and now supports nested
  conditionals
- gamedata variables no longer have the gamedata_ prefix because it was
  just annoyingly long all the time
- vcall macros are somewhat revamped and support dynamic (gamedata)
  indices
- Portal 1 FOV can be set anywhere from 75-120 using fov_desired -
  tested in both the main versions currently used by runners
- A few typos were also fixed ("intput," "writeable," "indexes")

2 files changed, 225 insertions, 129 deletions

diff --git a/src/build/mkgamedata.c b/src/build/mkgamedata.c
index c5f6820..d17d7df 100644
--- a/src/build/mkgamedata.c
+++ b/src/build/mkgamedata.c
@@ -14,6 +14,7 @@
  * PERFORMANCE OF THIS SOFTWARE.
  */
 
+#include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -22,6 +23,7 @@
 #include "../kv.h"
 #include "../noreturn.h"
 #include "../os.h"
+#include "vec.h"
 
 #ifdef _WIN32
 #define fS "S"
@@ -35,10 +37,18 @@ static noreturn die(const char *s) {
 }
 
 /*
- * We keep the gamedata KV format as simple and flat as possible:
+ * We keep the gamedata KV format as simple as possible. Default values are
+ * specified as direct key-value pairs:
  *
  *   <varname> <expr>
+ *
+ * Game- or engine-specific values are set using blocks:
+ *
  *   <varname> { <gametype> <expr> <gametype> <expr> ... [default <expr>] }
+ *
+ * The most complicated it can get is if conditionals are nested, which
+ * basically translates directly into nested ifs:
+ *   <varname> { <gametype> { <gametype> <expr> <gametype> <expr> } }
  *   [however many entries...]
  *
  * If that doesn't make sense, just look at one of the existing data files and
@@ -47,35 +57,21 @@ static noreturn die(const char *s) {
  * Note: if `default` isn't given in a conditional block, that piece of gamedata
  * is considered unavailable and modules that use it won't get initialised/used.
  */
+struct vec_ent VEC(struct ent *);
 struct ent {
-	const char *name;
-	// normally I'd be inclined to do some pointer bitpacking meme but that's
-	// annoying and doesn't matter here so here's an bool and 7 bytes of padding
-	bool iscond;
-	union {
-		struct {
-			struct ent_cond {
-				const char *name;
-				// note: can be any old C expression; just plopped in
-				const char *expr;
-				struct ent_cond *next;
-			} *cond;
-			// store user-specified defaults in a special place to make the
-			// actual codegen logic easier
-			const char *defval;
-		};
-		const char *expr;
-	};
-	struct ent *next;
-} *ents_head, **ents_tail = &ents_head;
-const char **curdefval; // dumb hacky afterthought, woopsy
+	const char *name; // (or condition tag, in a child node)
+	const char *defexpr;
+	struct vec_ent subents;
+	struct ent *parent; // to back up a level during parse
+};
+// root only contains subents list but it's easier to use the same struct
+static struct ent root = {0};
 
 struct parsestate {
 	const os_char *filename;
 	struct kv_parser *parser;
-	const char *lastkey;
-	struct ent_cond **nextcond;
-	bool incond;
+	struct ent *curent; // current ent lol
+	bool haddefault; // blegh;
 };
 
 static noreturn badparse(struct parsestate *state, const char *e) {
@@ -88,67 +84,52 @@ static void kv_cb(enum kv_token type, const char *p, uint len, void *ctxt) {
 	struct parsestate *state = ctxt;
 	switch (type) {
 		case KV_IDENT: case KV_IDENT_QUOTED:;
+			if (len == 7 && !memcmp(p, "default", 7)) { // special case!
+				if (state->curent == &root) {
+					badparse(state, "unexpected default keyword at top level");
+				}
+				struct ent *e = state->curent;
+				if (e->defexpr) {
+					badparse(state, "multiple default keywords");
+				}
+				state->haddefault = true;
+				break;
+			}
+			state->haddefault = false;
 			char *k = malloc(len + 1);
 			if (!k) die("couldn't allocate key string");
-			memcpy(k, p, len);
-			k[len] = '\0';
-			state->lastkey = k;
-			break; 
-		case KV_NEST_START:
-			if (state->incond) badparse(state, "unexpected nested object");
-			state->incond = true;
+			// FIXME(?): should check and prevent duplicate keys probably!
+			// need table.h or something to avoid O(n^2) :)
+			memcpy(k, p, len); k[len] = '\0';
 			struct ent *e = malloc(sizeof(*e));
 			if (!e) die("couldn't allocate memory");
-			e->name = state->lastkey;
-			e->iscond = true;
-			e->cond = 0;
-			e->defval = 0;
-			state->nextcond = &e->cond;
-			e->next = 0;
-			*ents_tail = e;
-			ents_tail = &e->next;
-			curdefval = &e->defval; // dumb hacky afterthought part 2
+			e->name = k;
+			e->defexpr = 0;
+			e->subents = (struct vec_ent){0};
+			if (!vec_push(&state->curent->subents, e)) {
+				die("couldn't append to array");
+			}
+			e->parent = state->curent;
+			state->curent = e;
+			break;
+		case KV_NEST_START:
+			if (state->haddefault) badparse(state, "default cannot be a block");
 			break;
 		case KV_NEST_END:
-			state->incond = false;
+			if (!state->curent->parent) {
+				badparse(state, "unexpected closing brace");
+			}
+			state->curent = state->curent->parent;
 			break;
 		case KV_VAL: case KV_VAL_QUOTED:
-			if (state->incond) {
-				// continuation of dumb hackiness
-				if (!strcmp(state->lastkey, "default")) {
-					char *s = malloc(len + 1);
-					if (!s) die("couldn't allocate default value string");
-					memcpy(s, p, len);
-					s[len] = '\0';
-					*curdefval = s;
-					break;
-				}
-				struct ent_cond *c = malloc(sizeof(*c));
-				if (!c) die("couldn't allocate memory");
-				c->name = state->lastkey;
-				char *expr = malloc(len + 1);
-				if (!expr) die("couldn't allocate value/expression string");
-				memcpy(expr, p, len);
-				expr[len] = '\0';
-				c->expr = expr;
-				c->next = 0;
-				*(state->nextcond) = c;
-				state->nextcond = &c->next;
-			}
-			else {
-				// also kind of dumb but whatever
-				struct ent *e = malloc(sizeof(*e));
-				if (!e) die("couldn't allocate memory");
-				e->name = state->lastkey;
-				e->iscond = false;
-				char *expr = malloc(len + 1);
-				if (!expr) die("couldn't allocate value/expression string");
-				memcpy(expr, p, len);
-				expr[len] = '\0';
-				e->expr = expr;
-				e->next = 0;
-				*ents_tail = e;
-				ents_tail = &e->next;
+			char *s = malloc(len + 1);
+			if (!s) die("couldn't allocate value string");
+			memcpy(s, p, len); s[len] = '\0';
+			state->curent->defexpr = s;
+			if (!state->haddefault) {
+				// a non-default value is just a node that itself only has a
+				// default value.
+				state->curent = state->curent->parent;
 			}
 			break;
 		case KV_COND_PREFIX: case KV_COND_SUFFIX:
@@ -156,20 +137,85 @@ static void kv_cb(enum kv_token type, const char *p, uint len, void *ctxt) {
 	}
 }
 
+static inline noreturn diewrite(void) { die("couldn't write to file"); }
+
+#define _doindent \
+	for (int _indent = 0; _indent < indent; ++_indent) { \
+		if (fputs("\t", out) == -1) diewrite(); \
+	}
 #define _(x) \
-	if (fprintf(out, "%s\n", x) < 0) die("couldn't write to file");
+	if (fprintf(out, "%s\n", x) < 0) diewrite();
+#define _i(x) _doindent _(x)
 #define F(f, ...) \
-	if (fprintf(out, f "\n", __VA_ARGS__) < 0) die("couldn't write to file");
+	if (fprintf(out, f "\n", __VA_ARGS__) < 0) diewrite();
+#define Fi(...) _doindent F(__VA_ARGS__)
 #define H() \
 _( "/* This file is autogenerated by src/build/mkgamedata.c. DO NOT EDIT! */") \
 _( "")
 
+static void decls(FILE *out) {
+	for (struct ent *const *pp = root.subents.data;
+			pp - root.subents.data < root.subents.sz; ++pp) {
+		if ((*pp)->defexpr) {
+F( "#define has_%s true", (*pp)->name)
+			if ((*pp)->subents.sz) {
+F( "extern int %s;", (*pp)->name)
+			}
+			else {
+F( "enum { %s = %s };", (*pp)->name, (*pp)->defexpr)
+			}
+		}
+		else {
+F( "extern bool has_%s;", (*pp)->name)
+F( "extern int %s;", (*pp)->name)
+		}
+	}
+}
+
+static void inits(FILE *out, const char *var, struct vec_ent *v, bool needhas,
+		int indent) {
+	for (struct ent *const *pp = v->data; pp - v->data < v->sz; ++pp) {
+Fi("if (GAMETYPE_MATCHES(%s)) {", (*pp)->name)
+		bool has = needhas && (*pp)->defexpr;
+		if (has) {
+Fi("	has_%s = true;", var);
+		}
+		if ((*pp)->defexpr) {
+Fi("	%s = %s;", var, (*pp)->defexpr);
+		}
+		inits(out, var, &(*pp)->subents, !has, indent + 1);
+_i("}")
+	}
+}
+
+static void defs(FILE *out) {
+	for (struct ent *const *pp = root.subents.data;
+			pp - root.subents.data < root.subents.sz; ++pp) {
+		if ((*pp)->defexpr) {
+			if ((*pp)->subents.sz) {
+F( "int %s = %s;", (*pp)->name, (*pp)->defexpr);
+			}
+		}
+		else {
+F( "int %s;", (*pp)->name);
+F( "bool has_%s = false;", (*pp)->name);
+		}
+	}
+_( "")
+_( "void gamedata_init(void) {")
+	for (struct ent *const *pp = root.subents.data;
+			pp - root.subents.data < root.subents.sz; ++pp) {
+		inits(out, (*pp)->name, &(*pp)->subents, !(*pp)->defexpr, 1);
+	}
+_( "}")
+}
+
 int OS_MAIN(int argc, os_char *argv[]) {
 	for (++argv; *argv; ++argv) {
 		int fd = os_open(*argv, O_RDONLY);
 		if (fd == -1) die("couldn't open file");
 		struct kv_parser kv = {0};
-		struct parsestate state = {*argv, &kv};
+		struct parsestate state = {*argv, &kv, &root};
 		char buf[1024];
 		int nread;
 		while (nread = read(fd, buf, sizeof(buf))) {
@@ -187,58 +233,12 @@ ep:			fprintf(stderr, "mkgamedata: %" fS ":%d:%d: bad syntax: %s\n",
 	FILE *out = fopen(".build/include/gamedata.gen.h", "wb");
 	if (!out) die("couldn't open gamedata.gen.h");
 	H();
-	for (struct ent *e = ents_head; e; e = e->next) {
-		if (e->iscond) {
-F( "extern int gamedata_%s;", e->name)
-			if (e->defval) {
-F( "#define gamedata_has_%s true", e->name)
-			}
-			else {
-F( "extern bool gamedata_has_%s;", e->name)
-			}
-		}
-		else {
-F( "enum { gamedata_%s = %s };", e->name, e->expr)
-F( "#define gamedata_has_%s true", e->name)
-		}
-	}
+	decls(out);
 
 	out = fopen(".build/include/gamedatainit.gen.h", "wb");
 	if (!out) die("couldn't open gamedatainit.gen.h");
 	H();
-	for (struct ent *e = ents_head; e; e = e->next) {
-		if (e->iscond) {
-			if (e->defval) {
-F( "int gamedata_%s = %s;", e->name, e->defval);
-			}
-			else {
-F( "int gamedata_%s;", e->name);
-F( "bool gamedata_has_%s = false;", e->name);
-			}
-		}
-	}
-_( "")
-_( "void gamedata_init(void) {")
-	for (struct ent *e = ents_head; e; e = e->next) {
-		if (e->iscond) {
-			for (struct ent_cond *c = e->cond; c; c = c->next) {
-				if (e->defval) {
-F( "	if (GAMETYPE_MATCHES(%s)) gamedata_%s = %s;", c->name, e->name, c->expr)
-				}
-				else {
-					// XXX: not bothering to generate `else`s. technically this
-					// has different semantics; we hope that the compiler can
-					// just do the right thing either way.
-F( "	if (GAMETYPE_MATCHES(%s)) {", c->name)
-F( "		gamedata_%s = %s;", e->name, c->expr)
-F( "		gamedata_has_%s = true;", e->name)
-_( "	}")
-				}
-			}
-		}
-	}
-_( "}")
-
+	defs(out);
 	return 0;
 }
 
diff --git a/src/build/vec.h b/src/build/vec.h
new file mode 100644
index 0000000..50b0a3b
--- /dev/null
+++ b/src/build/vec.h
@@ -0,0 +1,96 @@
+/* This file is dedicated to the public domain. */
+
+#ifndef INC_VEC_H
+#define INC_VEC_H
+
+#include <errno.h>
+#include <stdbool.h>
+#include <stdlib.h>
+
+#include "../intdefs.h"
+
+struct _vec {
+	uint sz;
+	uint max;
+	void *data;
+};
+
+/*
+ * A dynamic array with push, pop and concatenate operations.
+ *
+ * Usage: struct VEC(my_type) myvec = {0};
+ * Or: struct myvec VEC(my_type);
+ * Or: typedef struct VEC(my_type) myvec;
+ */
+#define VEC(type) { \
+	uint sz; \
+	uint max; \
+	type *data; \
+}
+
+#if defined(__GNUC__) || defined(__clang__)
+__attribute__((unused)) // heck off gcc
+#endif
+static bool _vec_ensure(struct _vec *v, uint tsize, uint newmax) {
+	// FIXME: potential overflow at least on 32-bit hosts (if any!?).
+	// should use reallocarray or something but didn't feel like porting right
+	// now. consider doing later.
+	void *new = realloc(v->data, tsize * newmax);
+	if (new) { v->data = new; v->max = newmax; }
+	return !!new;
+}
+
+#if defined(__GNUC__) || defined(__clang__)
+__attribute__((unused)) // heck off gcc 2
+#endif
+static bool _vec_make_room(struct _vec *v, uint tsize, uint addcnt) {
+	// this overflow check is probably unnecessary, but just in case
+	u64 chk = v->max + addcnt;
+	if (chk > 1u << 30) { errno = ENOMEM; return false; }
+	u32 x = chk;
+	if (x < 16) {
+		x = 16;
+	}
+	else {
+		// round up to next 2*n
+		--x;
+		x |= x >> 1; x |= x >> 2; x |= x >> 4; x |= x >> 8; x |= x >> 16;
+		x++;
+	}
+	return _vec_ensure(v, tsize, x);
+}
+
+// internal: for reuse by vec0
+#define _vec_push(v, val, slack) ( \
+	((v)->sz + (slack) < (v)->max || \
+			_vec_make_room((struct _vec *)(v), sizeof(val), 1)) && \
+	((v)->data[(v)->sz++ - slack] = (val), true) \
+)
+
+#define _vec_pushall(v, vals, n, slack) ( \
+	((v)->sz + (n) + (slack) <= (v)->max || \
+			_vec_make_room((struct _vec *)(v), sizeof(*(vals)), (n))) && \
+	(memcpy((v)->data + (v)->sz - (slack), (vals), (n) * sizeof(*(vals))), \
+			(v)->sz += (n), true) \
+)
+
+/*
+ * Appends an item to the end of a vector. Gives true on success and false if
+ * memory allocation fails.
+ */
+#define vec_push(v, val) _vec_push(v, val, 0)
+
+/*
+ * Appends n items from an array to the end of a vector. Gives true on success
+ * and false if memory allocation fails.
+ */
+#define vec_pushall(v, vals, n) _vec_pushall(v, vals, n, 0)
+
+/*
+ * Removes an item from the end of a vector and gives that item.
+ */
+#define vec_pop(v) ((v)->data[--(v)->sz])
+
+#endif
+
+// vi: sw=4 ts=4 noet tw=80 cc=80