19 files changed, 14156 insertions, 282 deletions

diff --git a/src/actualize.c b/src/actualize.c
new file mode 100644
index 0000000..0148569
--- /dev/null
+++ b/src/actualize.c
@@ -0,0 +1,1797 @@
+#include <assert.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <cu/actualize.h>
+#include <cu/compiler.h>
+#include <cu/debug.h>
+
+#define UNUSED(x) do { (void)(x); } while (0)
+
+struct act_stack {
+	struct ast_node *node;
+	struct act_stack *next;
+};
+
+enum act_flags {
+	ACT_IN_LOOP = (1 << 0),
+	ACT_IN_SWITCH = (1 << 1),
+	ACT_ONLY_TYPES = (1 << 2),
+	ACT_HAS_RETURN = (1 << 3),
+};
+
+struct act_state {
+	enum act_flags flags;
+
+	struct ast_node *last_var;
+	struct ast_node *cur_template;
+	struct ast_node *cur_proc;
+	struct act_stack *defer_stack;
+	struct act_stack *goto_stack;
+	struct act_stack *label_stack;
+};
+
+static void act_set_flags(struct act_state *state, enum act_flags flags)
+{
+	state->flags |= flags;
+}
+
+static enum act_flags act_flags(struct act_state *state, enum act_flags flags)
+{
+	return state->flags & flags;
+}
+
+/* TODO: this could be improved if we get a global void thing */
+static int is_void(struct ast_node *type)
+{
+	assert(type->node_type == AST_TYPE);
+	if (type->_type.kind != AST_TYPE_ID)
+		return 0;
+
+	struct ast_node *id = type->_type.id;
+	if (strcmp(id->_id.id, "void") != 0)
+		return 0;
+
+	return 1;
+}
+
+static struct ast_node *void_type()
+{
+	char *void_str = strdup("void");
+	if (!void_str) {
+		internal_error("couldn't allocate void string");
+		return NULL;
+	}
+
+	struct ast_node *void_id = gen_id(void_str);
+	if (!void_id) {
+		internal_error("couldn't allocate void id");
+		free(void_str);
+		return NULL;
+	}
+
+	struct ast_node *void_type = gen_type(AST_TYPE_ID, void_id, NULL, NULL);
+	if (!void_type) {
+		internal_error("couldn't allocate void type");
+		destroy_ast_node(void_id);
+		return NULL;
+	}
+
+	void_type->type = void_type;
+	return void_type;
+}
+
+static int push_defer(struct act_state *state, struct ast_node *expr)
+{
+	struct act_stack *new = calloc(1, sizeof(struct act_stack));
+	if (!new) {
+		internal_error("failed allocating defer");
+		return -1;
+	}
+
+	new->node = expr;
+	new->next = state->defer_stack;
+	state->defer_stack = new;
+	return 0;
+}
+
+static int push_label(struct act_state *state, struct ast_node *label)
+{
+	struct act_stack *new = calloc(1, sizeof(struct act_stack));
+	if (!new) {
+		internal_error("failed allocating label");
+		return -1;
+	}
+
+	new->node = label;
+	new->next = state->label_stack;
+	state->label_stack = new;
+	return 0;
+}
+
+static struct ast_node *find_label(struct act_state *state, struct ast_node *label)
+{
+	assert(label->node_type == AST_LABEL);
+	struct act_stack *prev = state->label_stack, *cur;
+	if (prev)
+		do {
+			cur = prev->next;
+			if (identical_ast_nodes(0, prev->node, label))
+				return prev->node;
+		} while ((prev = cur));
+
+	return NULL;
+}
+
+static int push_goto(struct act_state *state, struct ast_node *got)
+{
+	struct act_stack *new = calloc(1, sizeof(struct act_stack));
+	if (!new) {
+		internal_error("failed allocating goto");
+		return -1;
+	}
+
+	new->node = got;
+	new->next = state->goto_stack;
+	state->goto_stack = new;
+	return 0;
+}
+
+static struct ast_node *clone_defers(struct act_state *state, struct act_stack *to)
+{
+	struct act_stack *from = state->defer_stack;
+
+	/* maintain reverse order */
+	struct ast_node *defers = NULL, *prev = NULL;
+	while (from != to) {
+		struct ast_node *defer = clone_ast_node(from->node);
+		if (prev)
+			prev->next = defer;
+
+		if (!defers)
+			defers = defer;
+
+		prev = defer;
+		from = from->next;
+	}
+
+	return defers;
+}
+
+static void clear_stack(struct act_stack *from, struct act_stack *to)
+{
+	while (from != to) {
+		struct act_stack *next = from->next;
+		free(from);
+		from = next;
+	}
+}
+
+static void clear_defers(struct act_state *state, struct act_stack *to)
+{
+	struct act_stack *from = state->defer_stack;
+	clear_stack(from, to);
+	state->defer_stack = to;
+}
+
+static void clear_gotos(struct act_state *state, struct act_stack *to)
+{
+	struct act_stack *from = state->goto_stack;
+	clear_stack(from, to);
+	state->goto_stack = to;
+}
+
+static void clear_labels(struct act_state *state, struct act_stack *to)
+{
+	struct act_stack *from = state->label_stack;
+	clear_stack(from, to);
+	state->label_stack = to;
+}
+
+static void destroy_act_state(struct act_state *state)
+{
+	/* clears all defers */
+	clear_defers(state, NULL);
+	clear_labels(state, NULL);
+	clear_gotos(state, NULL);
+}
+
+static int actualize(struct act_state *state, struct scope *scope, struct ast_node *node);
+static int analyze(struct scope *scope, struct ast_node *tree);
+
+static int eval_const_if(struct scope *scope, struct ast_node *node)
+{
+	assert(node
+			&& node->node_type == AST_IF
+			&& ast_flags(node, AST_FLAG_CONST));
+
+	int eval = 0;
+	struct ast_node *cond = node->_if.cond;
+	struct ast_node *next = node->next;
+
+	switch (cond->node_type) {
+		/* for now just check if the variable exists, might change in
+		 * the future */
+	case AST_ID: eval = file_scope_find_var(scope, cond) != NULL;
+		     break;
+	default: semantic_error(scope->fctx, node,
+				 "const if conditional at file scope unimplemented");
+		 return -1;
+	}
+
+	destroy_ast_tree(cond);
+
+	if (eval) {
+		/* condition evaluated true, so keep the if block */
+		struct ast_node *body = node->_if.body;
+		ast_last_node(body)->next = node->next;
+
+		/* an if must have a body, otherwise the parser messed up */
+		assert(body);
+
+		destroy_ast_tree(node->_if.els);
+
+		*node = *body;
+		free(body);
+		return 0;
+	}
+
+	destroy_ast_tree(node->_if.body);
+
+	struct ast_node *els = node->_if.els;
+	if (els) {
+		*node = *els;
+		ast_last_node(els)->next = next;
+		free(els);
+		return 0;
+	}
+
+	if (next) {
+		/* copy the next node into our place */
+		*node = *next;
+		free(next);
+		return 0;
+	}
+
+	free(node);
+	return 0;
+}
+
+static int analyze_file_visibility(struct scope *scope, struct ast_node *node)
+{
+	assert(scope_flags(scope, SCOPE_FILE));
+
+	if (!node)
+		return 0;
+
+	int ret = 0;
+	node->scope = scope;
+
+	/* TODO: add error checking */
+	switch (node->node_type) {
+	case AST_PROC: {
+		ret |= scope_add_proc(scope, node);
+		break;
+	}
+
+	case AST_VAR: {
+		ret |= scope_add_var(scope, node);
+		break;
+	}
+
+	case AST_IMPORT: {
+		const char *file = node->_import.file;
+		ret |= process_file(&scope, ast_flags(node, AST_FLAG_PUBLIC), file);
+		destroy_ast_tree(node);
+		break;
+	}
+
+	case AST_IF: {
+		assert(ast_flags(node, AST_FLAG_CONST));
+		ret |= eval_const_if(scope, node);
+		if (ret)
+			return -1;
+
+		/* since a const if likely replaced the current node with
+		 * something else, we have to analyze the replacement */
+		ret = analyze(scope, node);
+		break;
+	}
+
+	case AST_STRUCT: {
+		/* TODO: should structs be their own 'thing'? */
+		ret |= scope_add_type(scope, node);
+		break;
+	}
+
+	case AST_ENUM: {
+		ret |= scope_add_type(scope, node);
+		break;
+	}
+
+	case AST_ALIAS: {
+		ret |= scope_add_alias(scope, node);
+		break;
+	}
+
+	case AST_TEMPLATE: {
+		ret |= scope_add_type(scope, node);
+		break;
+	}
+
+	case AST_MACRO: {
+		ret |= scope_add_macro(scope, node);
+		break;
+	}
+
+	case AST_EMPTY: {
+		destroy_ast_tree(node);
+		break;
+	}
+
+	case AST_BLOCK: {
+		/* a block might be inserted by something, in which case jump
+		 * down into it */
+		assert(ast_flags(node, AST_FLAG_UNHYGIENIC));
+		ret = analyze(scope, node->_block.body);
+		break;
+	}
+
+	default:
+		ret = -1;
+		semantic_error(scope->fctx, node, "unknown top element\n");
+		break;
+	};
+
+	return ret;
+}
+
+static int analyze(struct scope *scope, struct ast_node *tree)
+{
+	struct ast_node *node = tree, *next;
+	while (node) {
+		next = node->next;
+		node->next = NULL;
+		if (analyze_file_visibility(scope, node))
+			return -1;
+
+		node = next;
+	}
+
+	return 0;
+}
+
+/* I would be more happy with a system where proc signatures are actualized
+ * on demand, but the current scope implementation doesn't work that well for it.
+ * Relatively straight forward to implement some kind of actualization
+ * forwarding, the main issue is detecting duplicates. */
+static int analyze_procs(struct scope *scope)
+{
+	struct act_state state = {0};
+	act_set_flags(&state, ACT_ONLY_TYPES);
+	struct visible *procs = scope->procs;
+	if (procs)
+		do {
+			if (procs->owner != scope)
+				goto skip_actualize;
+
+			struct ast_node *proc = procs->node;
+			if (actualize(&state, scope, proc))
+				return -1;
+
+skip_actualize:
+			procs = procs->next;
+		} while (procs);
+
+	/* reinsert procs with actualized signatures, should make sure we don't
+	 * have duplicates after all aliases etc. have been eliminated */
+	procs = scope->procs;
+	scope->procs = NULL;
+	if (procs)
+		do {
+			struct visible *next = procs->next;
+			if (procs->owner != scope) {
+				/* this is a reference, ignore it */
+				free(procs);
+				goto skip_add;
+			}
+			if (scope_add_existing_proc(scope, procs)) {
+				destroy_visible(scope, procs);
+				return -1;
+			}
+
+skip_add:
+			procs = next;
+		} while (procs);
+
+	/* repeat for all child scopes */
+	struct scope *child = scope->children;
+	while (child) {
+		if (analyze_procs(child))
+			return -1;
+
+		child = child->next;
+	}
+
+	return 0;
+}
+
+int analyze_root(struct scope *scope, struct ast_node *tree)
+{
+	scope_add_defaults(scope);
+	if (analyze(scope, tree))
+		return -1;
+
+	if (analyze_procs(scope))
+		return -1;
+
+	return 0;
+}
+
+int template_match(struct ast_node *a, struct ast_node *b)
+{
+	struct ast_node *a_act = NULL, *b_act = NULL;
+	if (a->_type.kind == AST_TYPE_TEMPLATE)
+		a_act = a->_type.template.actual;
+	else
+		a_act = a;
+
+
+	if (b->_type.kind == AST_TYPE_TEMPLATE)
+		b_act = b->_type.template.actual;
+	else
+		b_act = b;
+
+	return types_match(a_act, b_act);
+}
+
+int alias_match(struct ast_node *a, struct ast_node *b)
+{
+	struct ast_node *a_act = NULL, *b_act = NULL;
+	if (a->_type.kind == AST_TYPE_ALIAS)
+		a_act = a->_type.alias.actual;
+	else
+		a_act = a;
+
+
+	if (b->_type.kind == AST_TYPE_ALIAS)
+		b_act = b->_type.alias.actual;
+	else
+		b_act = b;
+
+	return types_match(a_act, b_act);
+}
+
+int types_match(struct ast_node *a, struct ast_node *b)
+{
+	if (!a && !b)
+		return 1;
+
+	if (!a)
+		return 0;
+
+	if (!b)
+		return 0;
+
+	assert(a->node_type == AST_TYPE);
+	assert(b->node_type == AST_TYPE);
+
+	/* handle special cases that should match even with different type kinds */
+	if (a->_type.kind == AST_TYPE_TEMPLATE || b->_type.kind == AST_TYPE_TEMPLATE) {
+		if (template_match(a, b))
+			return 1;
+		return 0;
+	}
+
+	if (a->_type.kind == AST_TYPE_ALIAS || b->_type.kind == AST_TYPE_ALIAS) {
+		if (alias_match(a, b))
+			return 1;
+		return 0;
+	}
+
+	if (a->_type.kind != b->_type.kind)
+		return 0;
+
+	/* from here on, we know that both types are identical */
+	if (!identical_ast_nodes(0, a, b))
+		return 0;
+
+	/* TODO: maybe implement some kind of recursion flag? */
+	return 1; // types_match(a->_type.next, b->_type.next);
+}
+
+static int _replace_id(struct ast_node *node, void *data)
+{
+	if (!node)
+		return 0;
+
+	if (node->node_type != AST_ID)
+		return ast_call_on(_replace_id, node, data);
+
+	struct ast_node **pair = data;
+	struct ast_node *id = pair[0];
+	struct ast_node *expr = pair[1];
+
+	if (!identical_ast_nodes(0, node, id))
+		return ast_call_on(_replace_id, node, data);
+
+	struct ast_node *clone = clone_ast_node(expr);
+	if (!clone) {
+		internal_error("failed cloning replacement expr");
+		return -1;
+	}
+
+	clone->next = node->next;
+	clone->scope = node->scope;
+	/* we know this is an ID node, so we know exactly what to free */
+	free((void *)node->_id.id);
+
+	*node = *clone;
+	free(clone);
+
+	/* a succesful replacement needs no futher replacements, I think */
+	return 0;
+}
+static int replace_id(struct ast_node *body, struct ast_node *id, struct ast_node *expr)
+{
+	struct ast_node *pair[2] = {id, expr};
+	return ast_call_on(_replace_id, body, pair);
+}
+
+static int actualize_macro(struct act_state *state,
+		struct scope *scope, struct ast_node *macro)
+{
+	UNUSED(state);
+	/* macro bodies, arguments, etc aren't expanded upon until the macro is
+	 * called, so just try to add it to the local scope */
+	assert(macro && macro->node_type == AST_MACRO);
+	return scope_add_macro(scope, macro);
+}
+
+struct ast_node *extract_template(struct ast_node *type)
+{
+	if (!type)
+		return 0;
+
+	assert(type->node_type == AST_TYPE);
+	if (type->_type.kind == AST_TYPE_TEMPLATE)
+		return type;
+
+	return extract_template(type->_type.next);
+}
+
+struct ast_node *extract_base(struct ast_node *type)
+{
+	if (!type)
+		return 0;
+
+	assert(type->node_type == AST_TYPE);
+	if (is_templateable(type))
+		return type;
+
+	return extract_base(type->_type.next);
+}
+
+static void actualize_template_types(struct ast_node *params, struct ast_node *args)
+{
+	/* replace parameter types with argument types */
+	if (args)
+		do {
+			assert(params->type);
+			struct ast_node *template = extract_template(params->type);
+			if (template) {
+				/* at this point we know that the types will
+				 * match, otherwise match_proc and friends
+				 * fucked up */
+				struct ast_node *type = params->type;
+				struct ast_node *base = args->type;
+				while (type != template) {
+					type = type->_type.next;
+					base = base->_type.next;
+					assert(type);
+					assert(base);
+				}
+
+				template->_type.template.actual = base;
+			}
+			params = params->next;
+			args = args->next;
+		} while (args && params);
+
+	/* TODO: this might not hold in variadic functions... */
+	assert(!args && !params);
+}
+
+static int actualize_proc_call(struct act_state *state,
+		struct scope *scope, struct ast_node *call, struct ast_node *proc)
+{
+	/* proc has already been actualized, so we don't have to do anything  */
+	if (ast_flags(proc, AST_FLAG_ACTUAL)) {
+		/* call node type is the return type */
+		struct ast_node *sign = proc->type;
+		assert(sign->node_type == AST_TYPE);
+
+		call->type = sign->_type.sign.ret;
+		return 0;
+	}
+
+	if (ast_flags(proc, AST_FLAG_VARIADIC)) {
+		semantic_error(scope->fctx, proc, "variadic procs not yet implemented");
+		return -1;
+	}
+
+	if (act_flags(state, ACT_ONLY_TYPES)) {
+		/* TODO: better cleanup */
+		/* at this point we're really only interested in the return
+		 * type, but if it's a typeof expression we need to actualize
+		 * the arguments as well, unfortunately */
+		struct ast_node *sign = clone_ast_node(proc->_proc.sign);
+		if (!sign) {
+			internal_error("failed cloning proc signature");
+			return -1;
+		}
+
+		if (scope_add_scratch(scope, sign)) {
+			internal_error("failed adding signature to scratch");
+			return -1;
+		}
+
+		struct scope *tmp = create_scope();
+		if (!tmp) {
+			internal_error("failed creating temporary signature scope");
+			return -1;
+		}
+
+		/* if the function is in some completely different file for
+		 * example, we want to use that file's scope */
+		scope_add_scope(proc->scope, tmp);
+
+		struct ast_node *params = sign->_type.sign.params;
+		struct ast_node *args = call->_call.args;
+		actualize_template_types(params, args);
+
+		if (actualize(state, tmp, sign))
+			return -1;
+
+		call->type = sign->_type.sign.ret;
+		return 0;
+	}
+
+	/* clone procedure definition to
+	 * replace template types with actual types and actualize it */
+	struct ast_node *def = clone_ast_node(proc);
+	if (!def) {
+		/* internal error */
+		internal_error("failed allocating actualization");
+		return -1;
+	}
+
+	struct ast_node *sign = def->_proc.sign;
+	struct ast_node *params = sign->_type.sign.params;
+	struct ast_node *args = call->_call.args;
+	actualize_template_types(params, args);
+
+	if (actualize(state, def->scope, def))
+		return -1;
+
+	call->type = sign->_type.sign.ret;
+	return 0;
+}
+
+static int actualize_macro_call(struct act_state *state,
+		struct scope *scope, struct ast_node *call,
+		struct ast_node *macro)
+{
+	assert(call->node_type == AST_CALL && macro->node_type == AST_MACRO);
+	if (ast_flags(macro, AST_FLAG_VARIADIC)) {
+		semantic_error(scope->fctx, macro, "variadic macros not yet implemented");
+		return -1;
+	}
+
+	struct ast_node *body = clone_ast_node(macro->_macro.body);
+	if (!body) {
+		internal_error("failed allocating body for macro call");
+		return -1;
+	}
+
+	body->scope = call->scope;
+	body->next = call->next;
+
+	struct ast_node *param = macro->_macro.params;
+	struct ast_node *arg = call->_call.args;
+
+	/* TODO: actual replacements */
+	while (param && arg) {
+		/* feels slightly hacky, but essentially replace each individual
+		 * component in the arg list by breaking it out of the list
+		 * temporarily. After the replacement, insert it back into the
+		 * list so the cleanup is easier. */
+		struct ast_node *next_arg = arg->next;
+		arg->next = NULL;
+
+		if (replace_id(body, param, arg)) {
+			semantic_error(scope->fctx, call,
+					"failed replacing params with args");
+			destroy_ast_tree(body);
+			arg->next = next_arg;
+			return -1;
+		}
+
+		param = param->next;
+		arg = arg->next = next_arg;
+	}
+
+	/* variadic macros could just replace this bit with with replacing the
+	 * rest of the list with the parameter? */
+	if (param || arg) {
+		/* TODO: internal error more like */
+		semantic_error(scope->fctx, call, "uneven number of arguments");
+		destroy_ast_tree(body);
+		return -1;
+	}
+
+	destroy_ast_tree(call->_call.id);
+	destroy_ast_tree(call->_call.args);
+	*call = *body;
+	free(body);
+	/* actualize the new content */
+	return actualize(state, scope, call);
+}
+
+static int actualize_call(struct act_state *state,
+		struct scope *scope, struct ast_node *call)
+{
+	assert(call && call->node_type == AST_CALL);
+
+	/* check that arguments exist, make sure they have types etc. */
+	int ret = actualize(state, scope, call->_call.args);
+	if (ret)
+		return ret;
+
+	/* this label implements a kind of on demand signature actualization,
+	 * might work? */
+	/* if it does, I might flesh this out into its own procedure that
+	 * reinserts the found proc after actualization, see if maybe that way
+	 * we get rid of duplicates? */
+get_callable:
+	struct ast_node *callable = file_scope_resolve_call(scope, call);
+	if (!callable) {
+		char *str = call_str(call);
+		semantic_error(scope->fctx, call, "no such callable: %s", str);
+		free(str);
+		return -1;
+	}
+
+	if (act_flags(state, ACT_ONLY_TYPES)) {
+		if (callable->node_type == AST_PROC
+				&& !ast_flags(callable->_proc.sign, AST_FLAG_ACTUAL)) {
+			/* since we're in types only mode, this should be fine */
+			if (actualize(state, scope, callable))
+				return -1;
+
+			goto get_callable;
+		}
+	}
+
+	if (callable->node_type == AST_PROC)
+		return actualize_proc_call(state, scope, call, callable);
+
+	if (callable->node_type == AST_MACRO)
+		return actualize_macro_call(state, scope, call, callable);
+
+	/* TODO: add lambdas and arrays */
+	semantic_error(scope->fctx, call,
+			"currently only procedures and macros are callable");
+	return -1;
+}
+
+static void warn_unused_labels(struct act_state *state, struct scope *scope)
+{
+	struct act_stack *labels = state->label_stack;
+	if (labels)
+		do {
+			struct ast_node *label = labels->node;
+			if (!ast_flags(label, AST_FLAG_ACTUAL))
+				semantic_warn(scope->fctx, label, "unused label");
+
+		} while ((labels = labels->next));
+}
+
+static int undefined_gotos(struct act_state *state, struct scope *scope)
+{
+	int ret = 0;
+	struct act_stack *gotos = state->goto_stack;
+	if (gotos)
+		do {
+			struct ast_node *got = gotos->node;
+			if (!ast_flags(got, AST_FLAG_ACTUAL)) {
+				semantic_warn(scope->fctx, got, "undefined label");
+				ret = -1;
+			}
+
+		} while ((gotos = gotos->next));
+
+	return ret;
+}
+
+/* TODO: add in some kind of subsystem for keeping track of which procedure
+ * we're in, what the last defined var is, possibly more? */
+static int actualize_proc(struct act_state *state,
+		struct scope *scope, struct ast_node *proc)
+{
+	/* actualize_proc is called on template procs as well, but I believe
+	 * that's fine? */
+	assert(proc && proc->node_type == AST_PROC);
+	int ret = 0;
+	/* mark the function as initialized, assume previously allocated for us */
+	struct ast_node *actual = proc;
+	ast_set_flags(actual, AST_FLAG_INIT);
+	if (!act_flags(state, ACT_ONLY_TYPES)) {
+		ret = scope_add_actual(scope, actual);
+		if (ret) {
+			destroy_ast_tree(actual);
+			return ret;
+		}
+	}
+
+	struct ast_node *sign = actual->_proc.sign;
+	if (act_flags(state, ACT_ONLY_TYPES)) {
+		struct scope *param_scope = create_scope();
+		scope_add_scope(scope, param_scope);
+
+		/* procedure type is the signature */
+		sign->scope = param_scope;
+		actual->type = sign;
+
+		/* TODO: if we're actualizing the types here, how can we avoid
+		 * duplicates in the scope proc list? Or can we at all? */
+
+		/* actualize types in signature */
+		/* note to self: this could likely be made more explicit, but
+		 * essentially we only want to actualize the signature when
+		 * we're in the analysis phase. After that, the call to the proc
+		 * will initialize the types for us, so this step would
+		 * overwrite the type info. I think, at least. */
+		return actualize(state, param_scope, sign);
+	}
+
+	/*
+	   struct ast_node *params = sign->_type.sign.params;
+	   while (params) {
+	   if (params->_var.id)
+	   if (scope_add_var(param_scope, params))
+	   return -1;
+
+	   params = params->next;
+	   }
+	   */
+
+	/* we don't have to maintain the same flags as the parent state, I don't
+	 * think */
+	struct act_state new_state = {0};
+	new_state.cur_proc = actual;
+	/* actualize body */
+	ret |= actualize(&new_state, sign->scope, actual->_proc.body);
+	if (!act_flags(&new_state, ACT_HAS_RETURN)) {
+		if (!is_void(sign->_type.sign.ret)) {
+			semantic_error(scope->fctx, actual,
+					"no return with non-void return type");
+			ret = -1;
+		}
+	}
+	else if (ast_block_last(actual->_proc.body)->node_type != AST_RETURN) {
+		/* TODO: something more sophisticated than this */
+		semantic_warn(scope->fctx, actual,
+				"unable to determine explicit return for all branches");
+	}
+
+	warn_unused_labels(&new_state, scope);
+	if (undefined_gotos(&new_state, scope))
+		ret = -1;
+
+	destroy_act_state(&new_state);
+
+	/* TODO: should ret be checked between each stage? */
+	if (ret)
+		return ret;
+
+	printf("Actualized func:\n");
+	dump_ast(0, actual);
+
+	ast_set_flags(actual, AST_FLAG_ACTUAL);
+	/* we have successfully actualized the procedure */
+	return 0;
+}
+
+static int actualize_binop(struct act_state *state,
+		struct scope *scope, struct ast_node *binop)
+{
+	assert(binop && binop->node_type == AST_BINOP);
+
+	struct ast_node *left = binop->_binop.left;
+	struct ast_node *right = binop->_binop.right;
+
+	int ret = 0;
+	ret |= actualize(state, scope, left);
+	ret |= actualize(state, scope, right);
+	if (ret)
+		return ret;
+
+	if (!left->type) {
+		semantic_error(scope->fctx, binop, "unable to detect lefthand type");
+		return -1;
+	}
+
+	if (!right->type) {
+		semantic_error(scope->fctx, binop, "unable to detect righthand type");
+		return -1;
+	}
+
+	/* TODO: slightly unsure how I'll handle aliases, maybe the types should
+	 * be actualized to the aliased values as well? */
+	if (!types_match(left->type, right->type)) {
+		char *left_type = type_str(left);
+		char *right_type = type_str(right);
+		semantic_error(scope->fctx, binop,
+				"type mismatch (%s vs %s)", left_type, right_type);
+		free(left_type);
+		free(right_type);
+		return -1;
+	}
+
+	/* TODO: also check template types, just because two templates collapse
+	 * to the same actual type doesn't mean that the two template types
+	 * should be allowed to operate on eachother */
+
+	/* types are the same, so the type of this expression is whichever */
+	binop->type = left->type;
+
+	return 0;
+}
+
+
+static int actualize_block(struct act_state *state,
+		struct scope *scope, struct ast_node *node)
+{
+	struct scope *block_scope = scope;
+	if (!ast_flags(node, AST_FLAG_UNHYGIENIC)) {
+		if (!(block_scope = create_scope())) {
+			/* internal error */
+			internal_error("failed to allocate block scope");
+			return -1;
+		}
+
+		scope_add_scope(scope, block_scope);
+	}
+
+	struct act_stack *defers = state->defer_stack;
+	if (actualize(state, block_scope, node->_block.body))
+		return -1;
+
+	/* the block type is the last statement in the block's type */
+	node->type = ast_last_node(node->_block.body)->type;
+	if (!node->type) {
+		semantic_error(scope->fctx, node, "unable to detect block type");
+		return -1;
+	}
+
+	/* TODO: currently defers are sort of duplicated after a return, unsure
+	 * if they should be handled here or somewhere else */
+	if (state->defer_stack) {
+		node->_block.defers = clone_defers(state, defers);
+		if (!node->_block.defers) {
+			internal_error("failed cloning defers");
+			return -1;
+		}
+
+		clear_defers(state, defers);
+	}
+
+	return 0;
+}
+
+static int actualize_id(struct act_state *state,
+		struct scope *scope, struct ast_node *id)
+{
+	UNUSED(state);
+	assert(id && id->node_type == AST_ID);
+	struct ast_node *decl = file_scope_find(scope, id);
+	if (!decl) {
+		semantic_error(scope->fctx, id, "no such object");
+		return -1;
+	}
+
+	if (!decl->type) {
+		semantic_error(scope->fctx, id, "no type associated with object");
+		return -1;
+	}
+
+	id->type = decl->type;
+	return 0;
+}
+
+static int actualize_var(struct act_state *state,
+		struct scope *scope, struct ast_node *var)
+{
+	assert(var && var->node_type == AST_VAR);
+	struct ast_node *init = var->_var.init;
+	struct ast_node *type = var->_var.type;
+	/* one of these must be defined, otherwise the parser fucked up */
+	assert(type || init);
+
+	int ret = 0;
+	if (init)
+		ret |= actualize(state, scope, init);
+
+	if (type)
+		ret |= actualize(state, scope, type);
+
+
+	if (init && type) {
+		/* make sure the asked type and the actualized types match */
+		if (!types_match(init->type, type->type)) {
+			char *init_type = type_str(init);
+			char *req_type = type_str(type);
+			semantic_error(scope->fctx, var, "type mismatch (%s vs %s)",
+					req_type, init_type);
+			free(init_type);
+			free(req_type);
+			return -1;
+		}
+	}
+
+	if (init)
+		/* infer */
+		var->type = init->type;
+
+	if (type)
+		/* TODO: should there be some default value? */
+		/* declare */
+		var->type = type;
+
+	/* an unnamed var is a var in a signature that should not produce a
+	 * warning on not being used (if I ever get around to adding those kinds
+	 * of warnings) */
+	if (var->_var.id)
+		return scope_add_var(scope, var);
+
+	return 0;
+}
+
+#define ENTER_ACT()\
+enum act_flags old_flags = state->flags;\
+struct ast_node *old_template = state->cur_template;
+
+#define EXIT_ACT(r)\
+do {\
+	state->cur_template = old_template;\
+	state->flags = old_flags;\
+	return r;\
+} while (0);
+
+static int actualize_type(struct act_state *state,
+		struct scope *scope, struct ast_node *type)
+{
+	/* TODO: there's gotta be a better way to handle flags. Maybe macros
+	 * like ENTER_ACTUALIZE and EXIT_ACTUALIZE? */
+	/* TODO: get rid of aliases, expand implements, fill out structures,
+	 * etc. */
+	assert(type->node_type == AST_TYPE);
+	ENTER_ACT();
+	act_set_flags(state, ACT_ONLY_TYPES);
+
+	if (ast_flags(type, AST_FLAG_INIT) && !ast_flags(type, AST_FLAG_ACTUAL)) {
+		semantic_error(scope->fctx, type, "detected type loop");
+		EXIT_ACT(-1);
+	}
+
+	/* mark type initialize. We can detect type loops if this is set but
+	 * AST_FLAG_ACTUAL isn't. */
+	ast_set_flags(type, AST_FLAG_INIT);
+	if (actualize(state, scope, type->_type.next)) {
+		EXIT_ACT(-1);
+	}
+
+	switch (type->_type.kind) {
+	case AST_TYPE_ID: {
+		/* type IDs can really only be aliases to something else, or if
+		 * they're missing, void */
+		struct ast_node *id = type->_type.id;
+		if (!id)
+			/* no ID means void */
+			type->_type.id = gen_id(strdup("void"));
+
+		type->loc = id->loc;
+
+		struct ast_node *exists = file_scope_resolve_type(scope, type);
+		if (!exists) {
+			semantic_error(scope->fctx, type, "no such type");
+			EXIT_ACT(-1);
+		}
+
+		/* nothing to do, except maybe check that types are actually
+		 * identical? */
+		if (exists->node_type == AST_TYPE)
+			break;
+
+		assert(exists->node_type == AST_ALIAS
+				|| exists->node_type == AST_TEMPLATE
+				|| exists->node_type == AST_STRUCT
+				|| exists->node_type == AST_ENUM);
+		/* actualize whatever type we have on demand, either alias or
+		 * template */
+		if (!ast_flags(exists, AST_FLAG_ACTUAL))
+			if (actualize(state, scope, exists))
+				EXIT_ACT(-1);
+
+		if (exists->node_type == AST_ALIAS) {
+			/* TODO: check if this is good enough */
+			destroy_ast_node(type->_type.id);
+			assert(type->_type.next == NULL);
+			type->_type.kind = AST_TYPE_ALIAS;
+			type->_type.alias.alias = exists;
+			type->_type.alias.actual = exists->_alias.type;
+		}
+		else if (exists->node_type == AST_TEMPLATE) {
+			destroy_ast_node(type->_type.id);
+			assert(type->_type.next == NULL);
+			type->_type.kind = AST_TYPE_TEMPLATE;
+			type->_type.template.template = exists;
+			/* this should be populated later */
+			type->_type.template.actual = NULL;
+		}
+		else if (exists->node_type == AST_STRUCT) {
+			/* I think, will still have to TODO: check */
+			destroy_ast_node(type->_type.id);
+			assert(type->_type.next == NULL);
+			type->_type.kind = AST_TYPE_STRUCT;
+			type->_type.struc.struc = exists;
+			type->_type.struc.impls
+				= clone_ast_node(exists->_struct.generics);
+		}
+		break;
+	}
+
+	case AST_TYPE_ARR:
+		/* TODO: expression should be expandable to integer constant */
+		break;
+
+	case AST_TYPE_TYPEOF: {
+		struct ast_node *expr = type->_type.typeo.expr;
+		/* TODO: expressions in top-level type declarations should
+		 * probably be checked for, as we might not want to accidentally
+		 * actualize procedure calls? */
+		if (actualize(state, scope, expr))
+			EXIT_ACT(-1);
+
+		/* I suspect there are more ways than this that we can fail, but
+		 * this is a decent starting point */
+		if (expr->type->_type.kind == AST_TYPE_TYPEOF) {
+			semantic_error(scope->fctx, type,
+					"couldn't actualize type expression\n");
+			EXIT_ACT(-1);
+		}
+
+		assert(type->_type.next == NULL);
+		/* clone node to make sure we don't accidentally step on
+		 * anyone's toes and double free anything */
+		struct ast_node *clone = clone_ast_node(expr->type);
+		*type = *clone;
+		free(clone);
+		destroy_ast_node(expr);
+		break;
+	}
+
+	case AST_TYPE_POINTER:
+		assert(type->_type.next);
+		type->loc = type->_type.next->loc;
+		break;
+
+	case AST_TYPE_SIGN: {
+		struct ast_node *params = type->_type.sign.params;
+		struct ast_node *ret = type->_type.sign.ret;
+
+		if (actualize(state, scope, params))
+			EXIT_ACT(-1);
+
+		if (!ret)
+			ret = type->_type.sign.ret = void_type();
+
+		if (actualize(state, scope, ret))
+			EXIT_ACT(-1);
+
+		break;
+	}
+
+	}
+
+	ast_set_flags(type, AST_FLAG_ACTUAL);
+
+	if (type->_type.kind == AST_TYPE_TYPEOF) {
+		semantic_error(scope->fctx, type, "couldn't convert expression to type");
+		EXIT_ACT(-1);
+	}
+
+	/* generally speaking */
+	EXIT_ACT(0);
+}
+
+static int actualize_empty(struct act_state *state,
+		struct scope *scope, struct ast_node *node)
+{
+	UNUSED(state);
+	/* TODO: converting to void is common enough that it might be worth
+	 * creating a function for */
+	struct ast_node *void_id = gen_id(strdup("void"));
+	if (!void_id) {
+		internal_error("couldn't allocate type id for empty statement\n");
+		return -1;
+	}
+
+	node->type = gen_type(AST_TYPE_ID, void_id, NULL, NULL);
+	if (!node->type) {
+		scope_add_scratch(scope, void_id);
+		internal_error("couldn't allocate type for empty statement\n");
+		return -1;
+	}
+
+	scope_add_scratch(scope, node->type);
+	return 0;
+}
+
+static int integral_type(struct ast_node *type)
+{
+	assert(type->node_type == AST_TYPE);
+	if (type->_type.kind == AST_TYPE_ALIAS)
+		return integral_type(type->_type.alias.actual);
+
+	if (type->_type.kind != AST_TYPE_ID)
+		return 0;
+
+	/* here would be awesome with an enum of our base types */
+	const char *type_str = type->_type.id->_id.id;
+	if (strcmp(type_str, "u8"))
+		return 1;
+
+	if (strcmp(type_str, "u16"))
+		return 1;
+
+	if (strcmp(type_str, "u32"))
+		return 1;
+
+	if (strcmp(type_str, "u64"))
+		return 1;
+
+	if (strcmp(type_str, "i8"))
+		return 1;
+
+	if (strcmp(type_str, "i16"))
+		return 1;
+
+	if (strcmp(type_str, "i32"))
+		return 1;
+
+	if (strcmp(type_str, "i64"))
+		return 1;
+
+	if (strcmp(type_str, "usize"))
+		return 1;
+
+	if (strcmp(type_str, "isize"))
+		return 1;
+
+	if (strcmp(type_str, "f32"))
+		return 1;
+
+	if (strcmp(type_str, "f64"))
+		return 1;
+
+	return 0;
+}
+
+static int pointer_type(struct ast_node *type)
+{
+	assert(type->node_type == AST_TYPE);
+	return type->_type.kind == AST_TYPE_POINTER;
+}
+
+static int pointer_conversion(struct ast_node *a, struct ast_node *b)
+{
+	assert(a->node_type == AST_TYPE);
+	assert(b->node_type == AST_TYPE);
+	if (pointer_type(a)) {
+		if (b->_type.kind != AST_TYPE_ID)
+			return 0;
+
+		struct ast_node *id = b->_type.id;
+		if (strcmp(id->_id.id, "usize") == 0)
+			return 1;
+	}
+
+	return 0;
+}
+
+static int actualize_cast(struct act_state *state,
+		struct scope *scope, struct ast_node *cast)
+{
+	assert(cast->node_type == AST_CAST);
+
+	struct ast_node *expr = cast->_cast.expr;
+	if (actualize(state, scope, expr))
+		return -1;
+
+	struct ast_node *type = cast->_cast.type;
+	if (actualize(state, scope, type))
+		return -1;
+
+	if (types_match(expr->type, type)) {
+		cast->type = type;
+		return 0;
+	}
+
+	if (integral_type(expr->type) && integral_type(type)) {
+		cast->type = type;
+		return 0;
+	}
+
+	if (pointer_type(expr->type) && pointer_type(type)) {
+		cast->type = type;
+		return 0;
+	}
+
+	if (pointer_conversion(expr->type, type)
+			|| pointer_conversion(type, expr->type)) {
+		cast->type = type;
+		return 0;
+	}
+
+	/* TODO: arrays? lambdas? */
+
+	char *left_type = type_str(expr);
+	char *right_type = type_str(type);
+	semantic_error(scope->fctx, cast, "illegal cast (%s vs %s)",
+			left_type, right_type);
+	free(left_type);
+	free(right_type);
+	return -1;
+}
+
+static int actualize_const(struct act_state *state, struct scope *scope,
+		struct ast_node *cons)
+{
+	UNUSED(state);
+	assert(cons->node_type == AST_CONST);
+	if (cons->_const.kind == AST_CONST_INTEGER) {
+		/* error checking would be doog */
+		cons->type = gen_type(AST_TYPE_ID, gen_id(strdup("i64")),
+				NULL, NULL);
+		scope_add_scratch(scope, cons->type);
+		return 0;
+	}
+
+	semantic_error(scope->fctx, cons, "unimplemented constant");
+	return 0;
+}
+
+static int actualize_alias(struct act_state *state, struct scope *scope,
+		struct ast_node *alias)
+{
+	/* I shall have to think about things, as currently very deeply nested
+	 * aliases might be a bit cumbersome to work with. Still, this works
+	 * well enough I suppose. */
+	assert(alias->node_type == AST_ALIAS);
+	ast_set_flags(alias, AST_FLAG_INIT);
+	/* TODO: alias loops? */
+	if (actualize(state, scope, alias->_alias.type)) {
+		/* usually we don't want to output errors upon errors, but this
+		 * is likely a useful message as it might show where a loop is
+		 * occuring */
+		semantic_error(scope->fctx, alias, "failed actualizing alias");
+		return -1;
+	}
+
+	ast_set_flags(alias, AST_FLAG_ACTUAL);
+	return 0;
+}
+
+static int actualize_template(struct act_state *state, struct scope *scope,
+		struct ast_node *template)
+{
+	assert(template->node_type == AST_TEMPLATE);
+	ast_set_flags(template, AST_FLAG_ACTUAL);
+	ENTER_ACT();
+	state->cur_template = template;
+
+	/* will still have to figure out how I want to inform the actualizer
+	 * that a some_type in a some_type just means whichever type we're
+	 * testing for */
+	act_set_flags(state, ACT_ONLY_TYPES);
+	if (actualize(state, template->scope, template->_template.body)) {
+		semantic_error(scope->fctx, template, "failed actualizing template");
+		EXIT_ACT(-1);
+	}
+
+	/* TODO: check that all procs in the template have something to do with
+	 * the type, either as an argument or as a return type or something */
+
+	/* TODO: implement supertemplates, i.e. adding some previous template to
+	 * this template */
+
+	/* TODO: make sure that the template itself doesn't have duplicates */
+
+	template->type = template;
+	EXIT_ACT(0);
+}
+
+static int actualize_defer(struct act_state *state,
+		struct scope *scope, struct ast_node *node)
+{
+	struct ast_node *expr = node->_defer.expr;
+	/* TODO: should the actualization only happen when the defers are
+	 * called? */
+	if (actualize(state, scope, expr))
+		return -1;
+
+	if (push_defer(state, expr))
+		return -1;
+
+	node->type = void_type();
+	scope_add_scratch(scope, node->type);
+	return 0;
+}
+
+static int actualize_return(struct act_state *state, struct scope *scope,
+		struct ast_node *node)
+{
+	act_set_flags(state, ACT_HAS_RETURN);
+	struct ast_node *expr = node->_return.expr;
+	if (expr) {
+		if (actualize(state, scope, expr))
+			return -1;
+
+		node->type = expr->type;
+	}
+	else {
+		node->type = void_type();
+		if (scope_add_scratch(scope, node->type))
+			return -1;
+	}
+
+	assert(state->cur_proc);
+	struct ast_node *cur_proc = state->cur_proc;
+	struct ast_node *ret = cur_proc->_proc.sign->_type.sign.ret;
+	if (!types_match(node->type, ret)) {
+		char *rt = type_str(ret);
+		char *et = type_str(node);
+		semantic_error(scope->fctx, node, "return type mismatch: %s vs %s",
+				rt, et);
+		free(rt);
+		free(et);
+		return -1;
+	}
+
+	if (state->defer_stack) {
+		node->_return.defers = clone_defers(state, NULL);
+		if (!node->_return.defers) {
+			internal_error("failed cloning return defers");
+			return -1;
+		}
+	}
+	return 0;
+}
+
+/* Still slightly unsure if this works in all cases, but a good start
+ * nonetheless. */
+static void actualize_goto_defer(struct ast_node *got, struct ast_node *label)
+{
+	struct ast_node *goto_defers = got->_goto.defers;
+	struct ast_node *label_defers = label->_label.defers;
+	/* since we're dealing with singly linked lists, keep a reference to one
+	 * node before the current goto defer. */
+	struct ast_node *prev_defer = NULL;
+
+	/* this goto has a defined label */
+	ast_set_flags(got, AST_FLAG_ACTUAL);
+	ast_set_flags(label, AST_FLAG_ACTUAL);
+
+	size_t goto_len = ast_list_len(goto_defers);
+	size_t label_len = ast_list_len(label_defers);
+
+	/* find first common defer statement */
+	while (goto_len > label_len) {
+		prev_defer = goto_defers;
+		goto_defers = goto_defers->next;
+		goto_len--;
+	}
+
+	while (label_len > goto_len) {
+		label_defers = label_defers->next;
+		label_len--;
+	}
+
+	/* TODO: possible optimisation could be maintaining references to the
+	 * defer statements themselves, building up a sort of tree, allowing us
+	 * to directly compare pointers, likely being a bit quicker. Still,
+	 * unlikely that goto stuff would be a major bottleneck. */
+	while (!identical_ast_nodes(1, goto_defers, label_defers)) {
+		prev_defer = goto_defers;
+		label_defers = label_defers->next;
+		goto_defers = goto_defers->next;
+	}
+
+	/* only the defers below the common defer should be executed by the goto */
+	if (goto_defers) {
+		/* fuck, I actually need the one previous to this */
+		assert(prev_defer->next == goto_defers);
+		prev_defer->next = NULL;
+		destroy_ast_node(goto_defers);
+	}
+
+	/* nothing to do */
+}
+
+
+static int actualize_goto(struct act_state *state, struct scope *scope,
+		struct ast_node *node)
+{
+	assert(node->node_type == AST_GOTO);
+	push_goto(state, node);
+
+	/* clone all defers as we don't know where the label might be */
+	node->_goto.defers = clone_defers(state, NULL);
+	node->type = void_type();
+	scope_add_scratch(scope, node->type);
+
+	struct ast_node *label = find_label(state, node->_goto.label);
+	/* this is a jump backwards, i.e. we can already do it */
+	if (label)
+		actualize_goto_defer(node, label);
+
+	/* forward jump, handle stuff when we run into the corresponding label */
+	return 0;
+}
+
+static void actualize_goto_defers(struct act_state *state, struct ast_node *label)
+{
+	struct act_stack *prev = state->goto_stack, *cur;
+	if (prev)
+		do {
+			cur = prev->next;
+			struct ast_node *got = prev->node;
+			if (identical_ast_nodes(0, got->_goto.label, label))
+				actualize_goto_defer(got, label);
+
+		} while ((prev = cur));
+}
+
+static int actualize_label(struct act_state *state, struct scope *scope,
+		struct ast_node *node)
+{
+	assert(node->node_type == AST_LABEL);
+	struct ast_node *prev = find_label(state, node);
+	if (prev) {
+		semantic_error(scope->fctx, node, "label redefined");
+		semantic_info(scope->fctx, prev, "previous definition");
+		return -1;
+	}
+
+	push_label(state, node);
+	/* clone all defers */
+	node->_label.defers = clone_defers(state, NULL);
+	node->type = void_type();
+	scope_add_scratch(scope, node->type);
+
+	actualize_goto_defers(state, node);
+	return 0;
+}
+
+static int actualize_unop(struct act_state *state,
+		struct scope *scope, struct ast_node *node)
+{
+	assert(node->node_type == AST_UNOP);
+	struct ast_node *expr = node->_unop.expr;
+	if (actualize(state, scope, expr))
+		return -1;
+
+	/* generally speaking */
+	node->type = expr->type;
+
+	switch (node->_unop.op) {
+	case AST_DEREF: {
+		struct ast_node *type = expr->type;
+		if (type->_type.kind != AST_TYPE_POINTER) {
+			/* TODO: or array */
+			semantic_error(scope->fctx, expr,
+					"trying to dereference something that's not a pointer");
+			return -1;
+		}
+
+		node->type = type->_type.next;
+		assert(node->type);
+		break;
+	}
+
+	default: semantic_error(scope->fctx, node, "unimplemented unary operation");
+		 return -1;
+	}
+
+	return 0;
+}
+
+static int actualize_as(struct act_state *state,
+		struct scope *scope, struct ast_node *as)
+{
+	assert(as->node_type == AST_AS);
+	if (!act_flags(state, ACT_ONLY_TYPES)) {
+		semantic_error(scope->fctx, as, "as used outside of type context");
+		return -1;
+	}
+
+	struct ast_node *type = as->_as.type;
+	if (actualize(state, scope, type))
+		return -1;
+
+	as->type = type;
+	return 0;
+}
+
+static int actualize_struct(struct act_state *state,
+		struct scope *scope, struct ast_node *node)
+{
+	assert(node->node_type == AST_STRUCT);
+	struct ast_node *generics = node->_struct.generics;
+	/* TODO: some IDs should be handles as just placeholders, I think? */
+	if (actualize(state, scope, generics))
+		return -1;
+
+	struct ast_node *body = node->_struct.body;
+	if (actualize(state, scope, body))
+		return -1;
+
+	node->type = node;
+	return 0;
+}
+
+/* could maybe be renamed, but essentially dot in copper works as either
+ * -> or . in C, so allow structures or templates and single lever pointers to
+ *  structures or templates. */
+static int has_members(struct ast_node *type)
+{
+	if (type->_type.kind == AST_TYPE_ALIAS)
+		return has_members(type->_type.alias.actual);
+
+	if (type->_type.kind == AST_TYPE_POINTER)
+		type = type->_type.next;
+
+	/* most likely */
+	if (type->_type.kind == AST_TYPE_STRUCT)
+		return 1;
+
+	if (type->_type.kind == AST_TYPE_TEMPLATE)
+		return 1;
+
+	return 0;
+}
+
+static int actualize_dot(struct act_state *state,
+		struct scope *scope, struct ast_node *node)
+{
+	assert(node->node_type == AST_DOT);
+	struct ast_node *expr = node->_dot.expr;
+	if (actualize(state, scope, expr))
+		return -1;
+
+	struct ast_node *id = node->_dot.id;
+	if (!has_members(expr->type)) {
+		char *tstr = type_str(expr->type);
+		semantic_error(scope->fctx, node, "%s does not have member %s",
+				tstr, id->_id.id);
+		free(tstr);
+		return -1;
+	}
+
+	/* TODO: actually look through stuff */
+	/* TODO: figure out how to match templated structures to actual */
+	return 0;
+}
+
+static int actualize(struct act_state *state, struct scope *scope, struct ast_node *node)
+{
+	int ret = 0;
+	if (!node)
+		return ret;
+
+	if (!node->scope)
+		node->scope = scope;
+
+	switch (node->node_type) {
+	case AST_PROC:
+		/* procedure definitions only allowed at file scope */
+		assert(scope_flags(scope, SCOPE_FILE));
+		ret |= actualize_proc(state, scope, node);
+		break;
+
+	case AST_TEMPLATE: ret |= actualize_template(state, scope, node); break;
+	case AST_ALIAS: ret |= actualize_alias(state, scope, node); break;
+	case AST_MACRO: ret |= actualize_macro(state, scope, node); break;
+	case AST_CALL: ret |= actualize_call(state, scope, node); break;
+	case AST_BINOP: ret |= actualize_binop(state, scope, node); break;
+	case AST_BLOCK: ret |= actualize_block(state, scope, node); break;
+	case AST_ID: ret |= actualize_id(state, scope, node); break;
+	case AST_VAR: ret |= actualize_var(state, scope, node); break;
+	case AST_TYPE: ret |= actualize_type(state, scope, node); break;
+	case AST_EMPTY: ret |= actualize_empty(state, scope, node); break;
+	case AST_CAST: ret |= actualize_cast(state, scope, node); break;
+	case AST_CONST: ret |= actualize_const(state, scope, node); break;
+	case AST_DEFER: ret |= actualize_defer(state, scope, node); break;
+	case AST_RETURN: ret |= actualize_return(state, scope, node); break;
+	case AST_GOTO: ret |= actualize_goto(state, scope, node); break;
+	case AST_LABEL: ret |= actualize_label(state, scope, node); break;
+	case AST_UNOP: ret |= actualize_unop(state, scope, node); break;
+	case AST_AS: ret |= actualize_as(state, scope, node); break;
+	case AST_STRUCT: ret |= actualize_struct(state, scope, node); break;
+	case AST_DOT: ret |= actualize_dot(state, scope, node); break;
+
+	default:
+		      /* more like internal_error, maybe? */
+		      semantic_error(scope->fctx, node, "unimplemented actualization");
+		      break;
+	}
+
+	/* should it automatically handle next nodes or should it be saved to
+	 * actualize_block or something? */
+	ret |= actualize(state, scope, node->next);
+	return ret;
+}
+
+int actualize_main(struct scope *root)
+{
+	/* should maybe try and figure out a shorthand for this */
+	/* especially if I try to find procs by signature as well */
+	struct ast_node main_id = {0};
+	main_id.node_type = AST_ID;
+	main_id._id.id = "main";
+
+	struct act_state state = {0};
+
+	/* skip checking signature for now */
+	struct ast_node *main = file_scope_find_override(root, &main_id);
+	if (!main) {
+		/* libraries are not really compilable... */
+		error("no main");
+		return -1;
+	}
+	int ret = actualize(&state, root, clone_ast_node(main));
+	destroy_act_state(&state);
+	return ret;
+}
+
+void replace_type(struct ast_node *type, struct ast_node *from, struct ast_node *to)
+{
+	if (!type)
+		return;
+
+	assert(type->node_type == AST_TYPE);
+	assert(from->node_type == AST_TYPE);
+	assert(to->node_type == AST_TYPE);
+
+	/* TODO: cleanup? */
+	if (types_match(type, from)) {
+		assert(type->_type.next == NULL);
+		struct ast_node *clone = clone_ast_node(to);
+		*type = *clone;
+		free(clone);
+	}
+
+	replace_type(type->_type.next, from, to);
+}
+
+void replace_param_types(struct ast_node *param, struct ast_node *param_type,
+		struct ast_node *arg_type)
+{
+	while (param) {
+		replace_type(param->type, param_type, arg_type);
+		param = param->next;
+	}
+}
diff --git a/src/ast.c b/src/ast.c
new file mode 100644
index 0000000..e8118aa
--- /dev/null
+++ b/src/ast.c
@@ -0,0 +1,2447 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <math.h>
+
+#include <cu/ast.h>
+#include <cu/scope.h>
+
+#define ALLOC_NODE(n, type)						\
+	struct ast_node *n = calloc(1, sizeof(struct ast_node));	\
+	if (!n) {							\
+		fprintf(stderr, "failed allocating" #type "\n");	\
+		return NULL;						\
+	}
+
+#define DESTROY_LIST(x) \
+	{\
+		struct ast_node *prev = x, *cur;\
+		if (prev)\
+		do {\
+			cur = prev->next;\
+			destroy_ast_node(prev);\
+		} while ((prev = cur));\
+	}
+
+static struct src_loc loc_span(struct ast_node *left, struct ast_node *right)
+{
+	struct src_loc loc = {0};
+	if (!left || !right)
+		return loc;
+
+	/* this might eventually be a good thing to do,
+	 * but right now I'm still having issues with initializing all nodes
+	 * with some kind of even slightly accurate location
+	 assert(left->loc.first_line);
+	 assert(left->loc.first_col);
+	 assert(right->loc.last_line);
+	 assert(right->loc.last_col);
+	 */
+
+	loc.first_line = left->loc.first_line;
+	loc.first_col = left->loc.first_col;
+	loc.last_line = right->loc.last_line;
+	loc.last_col = right->loc.last_col;
+	return loc;
+}
+
+struct ast_node *gen_binop(int op, struct ast_node *left, struct ast_node *right)
+{
+	ALLOC_NODE(n, binop);
+	n->node_type = AST_BINOP;
+	n->_binop.op = op;
+	n->_binop.left = left;
+	n->_binop.right = right;
+	n->loc = loc_span(left, right);
+	return n;
+}
+
+void destroy_binop(struct ast_node *binop)
+{
+	assert(binop->node_type == AST_BINOP);
+	destroy_ast_node(binop->_binop.left);
+	destroy_ast_node(binop->_binop.right);
+	free(binop);
+}
+
+struct ast_node *gen_unop(int op, struct ast_node *expr)
+{
+	ALLOC_NODE(n, unop);
+	n->node_type = AST_UNOP;
+	n->_unop.op = op;
+	n->_unop.expr = expr;
+	n->loc = expr->loc;
+	return n;
+}
+
+void destroy_unop(struct ast_node *unop)
+{
+	assert(unop->node_type == AST_UNOP);
+	destroy_ast_node(unop->_unop.expr);
+	free(unop);
+}
+
+struct ast_node *gen_call(struct ast_node *id, struct ast_node *args)
+{
+	ALLOC_NODE(n, call);
+	n->node_type = AST_CALL;
+	n->_call.id = id;
+	n->_call.args = args;
+	n->loc = id->loc;
+	return n;
+}
+
+void destroy_call(struct ast_node *call)
+{
+	assert(call->node_type == AST_CALL);
+	destroy_ast_node(call->_call.id);
+	DESTROY_LIST(call->_call.args);
+	free(call);
+}
+
+struct ast_node *gen_id(const char *id)
+{
+	ALLOC_NODE(n, id);
+	n->node_type = AST_ID;
+	n->_id.id = id;
+	/* assume the parser populates location data */
+	return n;
+}
+
+void destroy_id(struct ast_node *id)
+{
+	assert(id->node_type == AST_ID);
+	free((void *)id->_id.id);
+	free(id);
+}
+
+struct ast_node *gen_int(long long integer)
+{
+	ALLOC_NODE(n, int);
+	n->node_type = AST_CONST;
+	n->_const.kind = AST_CONST_INTEGER;
+	n->_const.integer = integer;
+	return n;
+}
+
+struct ast_node *gen_string(const char *str)
+{
+	ALLOC_NODE(n, string);
+	n->node_type = AST_CONST;
+	n->_const.kind = AST_CONST_STRING;
+	n->_const.str = str;
+	return n;
+}
+
+struct ast_node *gen_float(double dbl)
+{
+	ALLOC_NODE(n, float);
+	n->node_type = AST_CONST;
+	n->_const.kind = AST_CONST_FLOAT;
+	n->_const.dbl = dbl;
+	return n;
+}
+
+void destroy_const(struct ast_node *cons)
+{
+	assert(cons->node_type == AST_CONST);
+	if (cons->_const.kind == AST_CONST_STRING)
+		free((void *)cons->_const.str);
+
+	free(cons);
+}
+
+struct ast_node *gen_while(struct ast_node *cond, struct ast_node *body)
+{
+	ALLOC_NODE(n, while);
+	n->node_type = AST_WHILE;
+	n->_while.cond = cond;
+	n->_while.body = body;
+	return n;
+}
+
+void destroy_while(struct ast_node *whil)
+{
+	assert(whil->node_type == AST_WHILE);
+	destroy_ast_node(whil->_while.cond);
+	DESTROY_LIST(whil->_while.body);
+	free(whil);
+}
+
+struct ast_node *gen_for(struct ast_node *pre, struct ast_node *cond,
+		struct ast_node *post, struct ast_node *body)
+{
+	ALLOC_NODE(n, for);
+	n->node_type = AST_FOR;
+	n->_for.pre = pre;
+	n->_for.cond = cond;
+	n->_for.post = post;
+	n->_for.body = body;
+	return n;
+}
+
+void destroy_for(struct ast_node *fo)
+{
+	assert(fo->node_type == AST_FOR);
+	destroy_ast_node(fo->_for.pre);
+	destroy_ast_node(fo->_for.cond);
+	destroy_ast_node(fo->_for.post);
+	DESTROY_LIST(fo->_for.body);
+	free(fo);
+}
+
+struct ast_node *gen_return(struct ast_node *expr)
+{
+	ALLOC_NODE(n, return);
+	n->node_type = AST_RETURN;
+	n->_return.expr = expr;
+	if (expr)
+		n->loc = expr->loc;
+	return n;
+}
+
+void destroy_return(struct ast_node *retur)
+{
+	assert(retur->node_type == AST_RETURN);
+	destroy_ast_node(retur->_return.expr);
+	DESTROY_LIST(retur->_return.defers);
+	free(retur);
+}
+
+struct ast_node *gen_goto(struct ast_node *label)
+{
+	ALLOC_NODE(n, goto);
+	n->node_type = AST_GOTO;
+	n->_goto.label = label;
+	n->loc = label->loc;
+	return n;
+}
+
+void destroy_goto(struct ast_node *got)
+{
+	assert(got->node_type == AST_GOTO);
+	destroy_ast_node(got->_goto.label);
+	free(got);
+}
+
+struct ast_node *gen_dot(struct ast_node *expr, struct ast_node *id)
+{
+	ALLOC_NODE(n, dot);
+	n->node_type = AST_DOT;
+	n->_dot.expr = expr;
+	n->_dot.id = id;
+	return n;
+}
+
+void destroy_dot(struct ast_node *dot)
+{
+	assert(dot->node_type == AST_DOT);
+	destroy_ast_node(dot->_dot.expr);
+	destroy_ast_node(dot->_dot.id);
+	free(dot);
+}
+
+struct ast_node *gen_label(struct ast_node *id)
+{
+	ALLOC_NODE(n, label);
+	n->node_type = AST_LABEL;
+	n->_label.id = id;
+	n->loc = id->loc;
+	return n;
+}
+
+void destroy_label(struct ast_node *label)
+{
+	assert(label->node_type == AST_LABEL);
+	destroy_ast_node(label->_label.id);
+	free(label);
+}
+
+struct ast_node *gen_ctrl(enum ast_ctrl_kind kind, struct src_loc loc)
+{
+	ALLOC_NODE(n, ctrl);
+	n->node_type = AST_CTRL;
+	n->loc = loc;
+	n->_ctrl.kind = kind;
+	return n;
+}
+
+void destroy_ctrl(struct ast_node *ctrl)
+{
+	free(ctrl);
+}
+
+struct ast_node *gen_macro(struct ast_node *id, struct ast_node *params,
+		struct ast_node *body)
+{
+	ALLOC_NODE(n, body);
+	n->node_type = AST_MACRO;
+	n->_macro.id = id;
+	n->_macro.params = params;
+	n->_macro.body = body;
+	n->loc = id->loc;
+	return n;
+}
+
+void destroy_macro(struct ast_node *macro)
+{
+	assert(macro->node_type == AST_MACRO);
+	destroy_ast_node(macro->_macro.id);
+	DESTROY_LIST(macro->_macro.params);
+	DESTROY_LIST(macro->_macro.body);
+	free(macro);
+}
+
+struct ast_node *gen_if(struct ast_node *cond, struct ast_node *body,
+		struct ast_node *els)
+{
+	ALLOC_NODE(n, if);
+	n->node_type = AST_IF;
+	n->_if.cond = cond;
+	n->_if.body = body;
+	n->_if.els = els;
+	n->loc = loc_span(cond, els);
+	return n;
+}
+
+void destroy_if(struct ast_node *i)
+{
+	assert(i->node_type == AST_IF);
+	destroy_ast_node(i->_if.cond);
+	DESTROY_LIST(i->_if.body);
+	destroy_ast_node(i->_if.els);
+	free(i);
+}
+
+struct ast_node *gen_switch(struct ast_node *cond, struct ast_node *cases)
+{
+	ALLOC_NODE(n, switch);
+	n->node_type = AST_SWITCH;
+	n->_switch.cond = cond;
+	n->_switch.cases = cases;
+	n->loc = cond->loc;
+	return n;
+}
+
+void destroy_switch(struct ast_node *switc)
+{
+	assert(switc->node_type == AST_SWITCH);
+	destroy_ast_node(switc->_switch.cond);
+	DESTROY_LIST(switc->_switch.cases);
+	free(switc);
+}
+
+struct ast_node *gen_case(struct ast_node *cond, struct ast_node *body)
+{
+	ALLOC_NODE(n, case);
+	/* TODO: a macro to map proc name to node type would make sure I don't
+	 * make any dumb mixups... */
+	n->node_type = AST_CASE;
+	n->_case.cond = cond;
+	n->_case.body = body;
+	/* TODO: where should I check the fallthrough flag? In the
+	 * actualization stage, I guess */
+	n->loc = cond->loc;
+	return n;
+}
+
+void destroy_case(struct ast_node *cas)
+{
+	assert(cas->node_type == AST_CASE);
+	destroy_ast_node(cas->_case.cond);
+	DESTROY_LIST(cas->_case.body);
+	free(cas);
+}
+
+struct ast_node *gen_type(enum ast_type_kind kind, struct ast_node *id,
+		struct ast_node *expr, struct ast_node *ret)
+{
+	ALLOC_NODE(n, type);
+	n->node_type = AST_TYPE;
+	n->_type.kind = kind;
+	switch (kind) {
+	case AST_TYPE_ALIAS:
+		n->_type.alias.alias = expr;
+		n->_type.alias.actual = ret;
+		n->loc = expr->loc;
+		break;
+
+	case AST_TYPE_TEMPLATE:
+		n->_type.template.template = expr;
+		n->_type.template.actual = ret;
+		n->loc = expr->loc;
+		break;
+
+	case AST_TYPE_ID:
+		n->_type.id = id;
+		n->loc = id->loc;
+		break;
+
+	case AST_TYPE_ARR:
+		n->_type.arr.size = expr;
+		n->loc = expr->loc;
+		break;
+
+	case AST_TYPE_TYPEOF:
+		n->_type.typeo.expr = expr;
+		n->loc = expr->loc;
+		break;
+
+	case AST_TYPE_POINTER:
+		break;
+
+	case AST_TYPE_PROC:
+		n->_type.proc.params = expr;
+		n->_type.proc.ret = ret;
+		n->loc = loc_span(expr, ret);
+		break;
+
+	case AST_TYPE_UNION:
+		n->_type.unio.id = id;
+		n->_type.unio.body = expr;
+		n->loc = id->loc;
+		break;
+
+	case AST_TYPE_STRUCT:
+		n->_type.struc.struc = expr;
+		n->_type.struc.impls = ret;
+		n->loc = expr->loc;
+		break;
+
+	case AST_TYPE_SIGN:
+		n->_type.sign.params = expr;
+		n->_type.sign.ret = ret;
+		n->loc = loc_span(expr, ret);
+		break;
+
+	case AST_TYPE_LAMBDA:
+		n->_type.lambda.params = expr;
+		n->_type.lambda.ret = ret;
+		n->loc = loc_span(expr, ret);
+		break;
+
+	case AST_TYPE_IMPL:
+		n->_type.impl.id = id;
+		n->loc = id->loc;
+		break;
+	}
+
+	return n;
+}
+
+void destroy_type(struct ast_node *type)
+{
+	assert(type->node_type == AST_TYPE);
+	switch (type->_type.kind) {
+	case AST_TYPE_ALIAS:
+		break;
+
+	case AST_TYPE_TEMPLATE:
+		break;
+
+	case AST_TYPE_ID:
+		destroy_ast_node(type->_type.id);
+		break;
+
+	case AST_TYPE_ARR:
+		destroy_ast_node(type->_type.arr.size);
+		break;
+
+	case AST_TYPE_TYPEOF:
+		destroy_ast_node(type->_type.typeo.expr);
+		break;
+
+	case AST_TYPE_POINTER:
+		break;
+
+	case AST_TYPE_PROC:
+		DESTROY_LIST(type->_type.proc.params);
+		destroy_ast_node(type->_type.proc.ret);
+		break;
+
+	case AST_TYPE_LAMBDA:
+		DESTROY_LIST(type->_type.lambda.params);
+		destroy_ast_node(type->_type.lambda.ret);
+		break;
+
+	case AST_TYPE_STRUCT:
+		/* struc is reference, I think, so don't free it */
+		/* TODO: should structure types clone the whole body for each
+		 * node, or maybe for each implementation of generics one
+		 * instance shared between all of the same type? hmm */
+		DESTROY_LIST(type->_type.struc.impls);
+		break;
+
+	case AST_TYPE_UNION:
+		DESTROY_LIST(type->_type.unio.body);
+		destroy_ast_node(type->_type.unio.id);
+		break;
+
+	case AST_TYPE_SIGN:
+		DESTROY_LIST(type->_type.sign.params);
+		destroy_ast_node(type->_type.sign.ret);
+		break;
+
+	case AST_TYPE_IMPL:
+		destroy_ast_node(type->_type.impl.id);
+		break;
+	}
+
+	destroy_ast_node(type->_type.next);
+	free(type);
+}
+
+struct ast_node *gen_block(struct ast_node *body)
+{
+	ALLOC_NODE(n, block);
+	n->node_type = AST_BLOCK;
+	n->_block.body = body;
+
+	struct ast_node *first = body;
+	struct ast_node *last = ast_last_node(body);
+	n->loc = loc_span(first, last);
+	return n;
+}
+
+void destroy_block(struct ast_node *block)
+{
+	assert(block->node_type == AST_BLOCK);
+	DESTROY_LIST(block->_block.body);
+	DESTROY_LIST(block->_block.defers);
+	free(block);
+}
+
+struct ast_node *gen_sizeof(struct ast_node *expr)
+{
+	ALLOC_NODE(n, sizeof);
+	n->node_type = AST_SIZEOF;
+	n->_sizeof.expr = expr;
+	n->loc = expr->loc;
+	return n;
+}
+
+void destroy_sizeof(struct ast_node *sizeo)
+{
+	assert(sizeo->node_type == AST_SIZEOF);
+	destroy_ast_node(sizeo->_sizeof.expr);
+	free(sizeo);
+}
+struct ast_node *gen_as(struct ast_node *type)
+{
+	ALLOC_NODE(n, as);
+	n->node_type = AST_AS;
+	n->_as.type = type;
+	n->loc = type->loc;
+	return n;
+}
+
+void destroy_as(struct ast_node *as)
+{
+	assert(as->node_type == AST_AS);
+	destroy_ast_node(as->_as.type);
+	free(as);
+}
+
+struct ast_node *gen_defer(struct ast_node *expr)
+{
+	ALLOC_NODE(n, defer);
+	n->node_type = AST_DEFER;
+	n->_defer.expr = expr;
+	n->loc = expr->loc;
+	return n;
+}
+
+void destroy_defer(struct ast_node *defer)
+{
+	assert(defer->node_type == AST_DEFER);
+	destroy_ast_node(defer->_defer.expr);
+	free(defer);
+}
+
+struct ast_node *gen_var(struct ast_node *id, struct ast_node *type,
+		struct ast_node *init)
+{
+	ALLOC_NODE(n, var);
+	n->node_type = AST_VAR;
+	n->_var.id = id;
+	n->_var.type = type;
+	n->_var.init = init;
+	if (id)
+		n->loc = id->loc;
+	else
+		n->loc = type->loc;
+	return n;
+}
+
+void destroy_var(struct ast_node *var)
+{
+	assert(var->node_type == AST_VAR);
+	destroy_ast_node(var->_var.id);
+	destroy_ast_node(var->_var.type);
+	destroy_ast_node(var->_var.init);
+	free(var);
+}
+
+struct ast_node *gen_lambda(struct ast_node *captures,
+		struct ast_node *type, struct ast_node *body)
+{
+	ALLOC_NODE(n, lambda);
+	n->node_type = AST_LAMBDA;
+	n->_lambda.captures = captures;
+	n->_lambda.sign = type;
+	n->_lambda.body = body;
+	n->loc = type->loc;
+	return n;
+}
+
+void destroy_lambda(struct ast_node *lambda)
+{
+	assert(lambda->node_type == AST_LAMBDA);
+	destroy_ast_node(lambda->_lambda.sign);
+	DESTROY_LIST(lambda->_lambda.captures);
+	DESTROY_LIST(lambda->_lambda.body);
+	free(lambda);
+}
+
+struct ast_node *gen_proc(struct ast_node *id, struct ast_node *sign,
+		struct ast_node *body)
+{
+	ALLOC_NODE(n, proc);
+	n->node_type = AST_PROC;
+	n->_proc.id = id;
+	n->_proc.sign = sign;
+	n->_proc.body = body;
+	n->loc = id->loc;
+	return n;
+}
+
+void destroy_proc(struct ast_node *proc)
+{
+	assert(proc->node_type == AST_PROC);
+	destroy_ast_node(proc->_proc.id);
+	DESTROY_LIST(proc->_proc.sign);
+	DESTROY_LIST(proc->_proc.body);
+	free(proc);
+}
+
+struct ast_node *gen_struct(struct ast_node *id,
+		struct ast_node *generics, struct ast_node *body)
+{
+	ALLOC_NODE(n, struct);
+	n->node_type = AST_STRUCT;
+	n->_struct.id = id;
+	n->_struct.generics = generics;
+	n->_struct.body = body;
+	n->loc = id->loc;
+	return n;
+}
+
+void destroy_struct(struct ast_node *struc)
+{
+	assert(struc->node_type == AST_STRUCT);
+	destroy_ast_node(struc->_struct.id);
+	DESTROY_LIST(struc->_struct.generics);
+	DESTROY_LIST(struc->_struct.body);
+	free(struc);
+}
+
+struct ast_node *gen_enum(struct ast_node *id, struct ast_node *type,
+		struct ast_node *body)
+{
+	ALLOC_NODE(n, enum);
+	n->node_type = AST_ENUM;
+	n->_enum.id = id;
+	n->_enum.type = type;
+	n->_enum.body = body;
+	if (id)
+		n->loc = id->loc;
+	return n;
+}
+
+void destroy_enum(struct ast_node *enu)
+{
+	assert(enu->node_type == AST_ENUM);
+	destroy_ast_node(enu->_enum.id);
+	destroy_ast_node(enu->_enum.type);
+	DESTROY_LIST(enu->_enum.body);
+	free(enu);
+}
+
+struct ast_node *gen_cast(struct ast_node *expr, struct ast_node *type)
+{
+	ALLOC_NODE(n, cast);
+	n->node_type = AST_CAST;
+	n->_cast.expr = expr;
+	n->_cast.type = type;
+	n->loc = loc_span(expr, type);
+	return n;
+}
+
+void destroy_cast(struct ast_node *cast)
+{
+	assert(cast->node_type == AST_CAST);
+	destroy_ast_node(cast->_cast.expr);
+	destroy_ast_node(cast->_cast.type);
+	free(cast);
+}
+
+struct ast_node *gen_val(struct ast_node *id, struct ast_node *val)
+{
+	ALLOC_NODE(n, val);
+	n->node_type = AST_VAL;
+	n->_val.id = id;
+	n->_val.val = val;
+	n->loc = id->loc;
+	return n;
+}
+
+void destroy_val(struct ast_node *val)
+{
+	assert(val->node_type == AST_VAL);
+	destroy_ast_node(val->_val.id);
+	destroy_ast_node(val->_val.val);
+	free(val);
+}
+
+struct ast_node *gen_alias(struct ast_node *id, struct ast_node *type)
+{
+	ALLOC_NODE(n, alias);
+	n->node_type = AST_ALIAS;
+	n->_alias.id = id;
+	n->_alias.type = type;
+	n->loc = id->loc;
+	return n;
+}
+
+void destroy_alias(struct ast_node *alias)
+{
+	assert(alias->node_type == AST_ALIAS);
+	destroy_ast_node(alias->_alias.id);
+	destroy_ast_node(alias->_alias.type);
+	free(alias);
+}
+
+struct ast_node *gen_template(struct ast_node *id, struct ast_node *body)
+{
+	ALLOC_NODE(n, template);
+	n->node_type = AST_TEMPLATE;
+	n->_template.id = id;
+	n->_template.body = body;
+	n->loc = id->loc;
+	return n;
+}
+
+void destroy_template(struct ast_node *template)
+{
+	assert(template->node_type == AST_TEMPLATE);
+	destroy_ast_node(template->_template.id);
+	DESTROY_LIST(template->_template.body);
+
+	struct template_implemented *prev = template->_template.impl_by, *cur;
+	if (prev)
+		do {
+			cur = prev->next;
+			free(prev);
+		} while ((prev = cur));
+	free(template);
+}
+
+struct ast_node *gen_import(const char *file)
+{
+	ALLOC_NODE(n, import);
+	n->node_type = AST_IMPORT;
+	n->_import.file = file;
+	/* TODO: where to get location */
+	return n;
+}
+
+void destroy_import(struct ast_node *import)
+{
+	assert(import->node_type == AST_IMPORT);
+	free((void *)import->_import.file);
+	free(import);
+}
+
+struct ast_node *gen_paste(struct ast_node *id1, struct ast_node *id2)
+{
+	ALLOC_NODE(n, paste);
+	n->node_type = AST_PASTE;
+	n->_paste.id1 = id1;
+	n->_paste.id2 = id2;
+	n->loc = loc_span(id1, id2);
+	return n;
+}
+
+void destroy_paste(struct ast_node *paste)
+{
+	assert(paste->node_type == AST_PASTE);
+	destroy_ast_node(paste->_paste.id1);
+	destroy_ast_node(paste->_paste.id2);
+	free(paste);
+}
+
+struct ast_node *gen_embed(const char *file)
+{
+	ALLOC_NODE(n, embed);
+	n->node_type = AST_EMBED;
+	n->_embed.file = file;
+	/* TODO: location */
+	return n;
+}
+
+void destroy_embed(struct ast_node *embed)
+{
+	assert(embed->node_type == AST_EMBED);
+	free((void *)embed->_embed.file);
+	free(embed);
+}
+
+struct ast_node *gen_empty()
+{
+	ALLOC_NODE(n, empty);
+	n->node_type = AST_EMPTY;
+	/* TODO: location */
+	return n;
+}
+
+void destroy_empty(struct ast_node *empty)
+{
+	assert(empty->node_type == AST_EMPTY);
+	free(empty);
+}
+
+struct ast_node *gen_last()
+{
+	ALLOC_NODE(n, last);
+	n->node_type = AST_LAST;
+	/* TODO: location */
+	return n;
+}
+
+void destroy_last(struct ast_node *last)
+{
+	assert(last->node_type == AST_LAST);
+	free(last);
+}
+
+void destroy_ast_node(struct ast_node *node)
+{
+	if (!node)
+		return;
+
+	assert(node->node_type);
+
+	switch (node->node_type) {
+	case AST_SIZEOF: destroy_sizeof(node); break;
+	case AST_DOT: destroy_dot(node); break;
+	case AST_BINOP: destroy_binop(node); break;
+	case AST_UNOP: destroy_unop(node); break;
+	case AST_CALL: destroy_call(node); break;
+	case AST_CAST: destroy_cast(node); break;
+	case AST_MACRO: destroy_macro(node); break;
+	case AST_PROC: destroy_proc(node); break;
+	case AST_GOTO: destroy_goto(node); break;
+	case AST_LABEL: destroy_label(node); break;
+	case AST_VAR: destroy_var(node); break;
+	case AST_LAMBDA: destroy_lambda(node); break;
+	case AST_IF: destroy_if(node); break;
+	case AST_FOR: destroy_for(node); break;
+	case AST_WHILE: destroy_while(node); break;
+	case AST_CTRL: destroy_ctrl(node); break;
+	case AST_RETURN: destroy_return(node); break;
+	case AST_TYPE: destroy_type(node); break;
+	case AST_BLOCK: destroy_block(node); break;
+	case AST_IMPORT: destroy_import(node); break;
+	case AST_DEFER: destroy_defer(node); break;
+	case AST_EMBED: destroy_embed(node); break;
+	case AST_ENUM: destroy_enum(node); break;
+	case AST_STRUCT: destroy_struct(node); break;
+	case AST_VAL: destroy_val(node); break;
+	case AST_SWITCH: destroy_switch(node); break;
+	case AST_CASE: destroy_case(node); break;
+	case AST_CONST: destroy_const(node); break;
+	case AST_PASTE: destroy_paste(node); break;
+	case AST_ALIAS: destroy_alias(node); break;
+	case AST_TEMPLATE: destroy_template(node); break;
+	case AST_ID: destroy_id(node); break;
+	case AST_AS: destroy_as(node); break;
+	case AST_EMPTY: destroy_empty(node); break;
+	case AST_LAST: destroy_last(node); break;
+	}
+}
+
+void destroy_ast_tree(struct ast_node *root)
+{
+	DESTROY_LIST(root);
+}
+
+void ast_set_flags(struct ast_node *node, enum ast_flag flags)
+{
+	node->flags |= flags;
+}
+
+void ast_append(struct ast_node *list, struct ast_node *elem)
+{
+	struct ast_node *cur = list;
+	while (cur->next)
+		cur = cur->next;
+
+	cur->next = elem;
+}
+
+
+static const char *binop_symbol(int op)
+{
+	switch (op) {
+	case AST_ASSIGN: return "=";
+	case AST_ADD: return "+";
+	case AST_SUB: return "-";
+	case AST_MUL: return "*";
+	case AST_DIV: return "/";
+	case AST_REM: return "%";
+	case AST_XOR: return "^";
+	case AST_POW: return "^^";
+	case AST_AND: return "&";
+	case AST_OR: return "|";
+	case AST_LOR: return "||";
+	case AST_LAND: return "&&";
+	case AST_LSHIFT: return "<<";
+	case AST_RSHIFT: return ">>";
+	case AST_ASSIGN_ADD: return "+=";
+	case AST_ASSIGN_SUB: return "-=";
+	case AST_ASSIGN_MUL: return "*=";
+	case AST_ASSIGN_DIV: return "/=";
+	case AST_ASSIGN_REM: return "%=";
+	case AST_ASSIGN_AND: return "&=";
+	case AST_ASSIGN_OR: return "|=";
+	case AST_ASSIGN_XOR: return "^=";
+	case AST_ASSIGN_LSHIFT: return "<<=";
+	case AST_ASSIGN_RSHIFT: return ">>=";
+	case AST_LT: return "<";
+	case AST_GT: return ">";
+	case AST_LE: return "<=";
+	case AST_GE: return ">=";
+	case AST_NE: return "!=";
+	case AST_EQ: return "==";
+	}
+
+	return "UNKNOWN";
+}
+
+static const char *unop_symbol(int op)
+{
+	switch (op) {
+	case AST_NEG: return "-";
+	case AST_LNOT: return "!";
+	case AST_REF: return "&";
+	case AST_DEREF: return "'";
+	case AST_NOT: return "~";
+	}
+
+	return "UNKNOWN";
+}
+
+static void dump(int depth, const char *fmt, ...)
+{
+	va_list args;
+	va_start(args, fmt);
+	for (int i = 0; i < depth; ++i)
+		putchar('\t');
+
+	vprintf(fmt, args);
+
+	va_end(args);
+}
+
+static void dump_flags(struct ast_node *node)
+{
+	if (node->scope)
+		printf(" %zu:", node->scope->number);
+
+	enum ast_flag flags = node->flags;
+	if (flags & AST_FLAG_MUTABLE)
+		printf(" MUT");
+
+	if (flags & AST_FLAG_CONST)
+		printf(" CONST");
+
+	if (flags & AST_FLAG_EXTERN)
+		printf(" EXTERN");
+
+	if (flags & AST_FLAG_VARIADIC)
+		printf(" VARIADIC");
+
+	if (flags & AST_FLAG_DELAYED)
+		printf(" DELAYED");
+
+	if (flags & AST_FLAG_PUBLIC)
+		printf(" PUB");
+
+	if (flags & AST_FLAG_UNTYPED)
+		printf(" UNTYPED");
+
+	if (flags & AST_FLAG_FALLTHROUGH)
+		printf(" FALLTHROUGH");
+}
+
+static void __dump_ast(int depth, struct ast_node *node)
+{
+	switch (node->node_type) {
+	case AST_SIZEOF:
+		dump(depth, "{SIZEOF:");
+		dump_flags(node);
+		putchar('\n');
+
+		dump_ast(depth + 1, node->_sizeof.expr);
+
+		dump(depth, "}\n");
+		break;
+
+	case AST_DOT:
+		dump(depth, "{DOT:");
+		dump_flags(node);
+		putchar('\n');
+
+		dump_ast(depth + 1, node->_dot.expr);
+		dump_ast(depth + 1, node->_dot.id);
+
+		dump(depth, "}\n");
+		break;
+
+	case AST_GOTO:
+		dump(depth, "{GOTO:");
+		dump_flags(node);
+		putchar('\n');
+
+		dump_ast(depth + 1, node->_goto.defers);
+		dump_ast(depth + 1, node->_goto.label);
+
+		dump(depth, "}\n");
+		break;
+
+	case AST_LABEL:
+		dump(depth, "{LABEL:");
+		dump_flags(node);
+		putchar('\n');
+
+		dump_ast(depth + 1, node->_label.id);
+
+		dump(depth, "}\n");
+		break;
+
+	case AST_BINOP:
+		dump(depth, "{BINOP:");
+		dump_flags(node);
+		printf(" %s\n", binop_symbol(node->_binop.op));
+
+		dump_ast(depth + 1, node->_binop.left);
+		dump_ast(depth + 1, node->_binop.right);
+
+		dump(depth, "}\n");
+		break;
+
+	case AST_UNOP:
+		dump(depth, "{UNOP:");
+		dump_flags(node);
+		printf(" %s\n", unop_symbol(node->_unop.op));
+
+		dump_ast(depth + 1, node->_unop.expr);
+
+		dump(depth, "}\n");
+		break;
+
+	case AST_CALL:
+		dump(depth, "{CALL:");
+		dump_flags(node);
+		putchar('\n');
+
+		dump_ast(depth + 1, node->_call.id);
+		dump_ast(depth + 1, node->_call.args);
+
+		dump(depth, "}\n");
+		break;
+
+	case AST_DEFER:
+		dump(depth, "{DEFER:");
+		dump_flags(node);
+		putchar('\n');
+
+		dump_ast(depth + 1, node->_defer.expr);
+
+		dump(depth, "}\n");
+		break;
+
+	case AST_CAST:
+		dump(depth, "{CAST:");
+		dump_flags(node);
+		putchar('\n');
+
+		dump_ast(depth + 1, node->_cast.expr);
+		dump_ast(depth + 1, node->_cast.type);
+
+		dump(depth, "}\n");
+		break;
+
+	case AST_MACRO:
+		dump(depth, "{MACRO:");
+		dump_flags(node);
+		putchar('\n');
+
+		dump_ast(depth + 1, node->_macro.id);
+		dump_ast(depth + 1, node->_macro.params);
+		dump_ast(depth + 1, node->_macro.body);
+
+		dump(depth, "}\n");
+		break;
+
+	case AST_PROC:
+		dump(depth, "{PROC:");
+		dump_flags(node);
+		putchar('\n');
+
+		dump_ast(depth + 1, node->_proc.id);
+		dump_ast(depth + 1, node->_proc.sign);
+		dump_ast(depth + 1, node->_proc.body);
+
+		dump(depth, "}\n");
+		break;
+
+	case AST_VAR:
+		dump(depth, "{VAR:");
+		dump_flags(node);
+		putchar('\n');
+
+		dump_ast(depth + 1, node->_var.id);
+		dump_ast(depth + 1, node->_var.type);
+		dump_ast(depth + 1, node->_var.init);
+
+		dump(depth, "}\n");
+		break;
+
+	case AST_ID:
+		dump(depth, "{ID:");
+		dump_flags(node);
+		printf(" %s}\n", node->_id.id);
+		break;
+
+	case AST_AS:
+		dump(depth, "{AS:");
+		dump_flags(node);
+		putchar('\n');
+
+		dump_ast(depth + 1, node->_as.type);
+		dump(depth, "}\n");
+		break;
+
+	case AST_BLOCK:
+		dump(depth, "{BLOCK:");
+		dump_flags(node);
+		putchar('\n');
+
+		dump_ast(depth + 1, node->_block.body);
+		dump_ast(depth + 1, node->_block.defers);
+
+		dump(depth, "}\n");
+		break;
+
+	case AST_RETURN:
+		dump(depth, "{RETURN:");
+		dump_flags(node);
+		putchar('\n');
+
+		dump_ast(depth + 1, node->_return.defers);
+		dump_ast(depth + 1, node->_return.expr);
+
+		dump(depth, "}\n");
+		break;
+
+	case AST_TYPE:
+		dump(depth, "{TYPE:");
+		dump_flags(node);
+
+		switch (node->_type.kind) {
+		case AST_TYPE_ALIAS:
+			printf(" ALIAS\n");
+			dump_ast(depth + 1, node->_type.alias.alias->_alias.id);
+			dump_ast(depth + 1, node->_type.alias.actual);
+			break;
+
+		case AST_TYPE_TEMPLATE:
+			printf(" TEMPLATE\n");
+			dump_ast(depth + 1, node->_type.template.template->_template.id);
+			dump_ast(depth + 1, node->_type.template.actual);
+			break;
+
+		case AST_TYPE_ID:
+			printf(" ID\n");
+			dump_ast(depth + 1, node->_type.id);
+			break;
+
+		case AST_TYPE_ARR:
+			printf(" ARR\n");
+			dump_ast(depth + 1, node->_type.arr.size);
+			break;
+
+		case AST_TYPE_POINTER:
+			printf(" PTR\n");
+			break;
+
+		case AST_TYPE_TYPEOF:
+			printf(" TYPEOF\n");
+			dump_ast(depth + 1, node->_type.typeo.expr);
+			break;
+
+		case AST_TYPE_PROC:
+			printf(" PROC\n");
+			dump_ast(depth + 1, node->_type.proc.params);
+			dump_ast(depth + 1, node->_type.proc.ret);
+			break;
+
+		case AST_TYPE_LAMBDA:
+			printf(" LAMBDA\n");
+			dump_ast(depth + 1, node->_type.lambda.params);
+			dump_ast(depth + 1, node->_type.lambda.ret);
+			break;
+
+		case AST_TYPE_STRUCT:
+			printf(" STRUCT\n");
+			dump_ast(depth + 1, node->_type.struc.struc->_struct.id);
+			dump_ast(depth + 1, node->_type.struc.impls);
+			break;
+
+		case AST_TYPE_UNION:
+			printf(" UNION\n");
+			dump_ast(depth + 1, node->_type.unio.id);
+			dump_ast(depth + 1, node->_type.unio.body);
+			break;
+
+		case AST_TYPE_SIGN: printf(" SIGN\n");
+				    dump_ast(depth + 1, node->_type.sign.params);
+				    dump_ast(depth + 1, node->_type.sign.ret);
+				    break;
+
+		case AST_TYPE_IMPL: printf(" IMPLS\n");
+				    dump_ast(depth + 1, node->_type.impl.id);
+				    dump_ast(depth + 1, node->_type.impl.types);
+		}
+
+		dump_ast(depth + 1, node->_type.next);
+
+		dump(depth, "}\n");
+		break;
+
+	case AST_LAMBDA:
+		dump(depth, "{LAMBDA:\n");
+		dump_flags(node);
+		putchar('\n');
+
+		dump_ast(depth + 1, node->_lambda.captures);
+		dump_ast(depth + 1, node->_lambda.sign);
+		dump_ast(depth + 1, node->_lambda.body);
+
+		dump(depth, "}\n");
+		break;
+
+	case AST_LAST:
+		dump(depth, "{LAST:");
+		dump_flags(node);
+		printf("}\n");
+		break;
+
+	case AST_EMPTY:
+		dump(depth, "{EMPTY:");
+		dump_flags(node);
+		printf("}\n");
+		break;
+
+	case AST_PASTE:
+		dump(depth, "{PASTE:");
+		dump_flags(node);
+		putchar('\n');
+
+		dump_ast(depth + 1, node->_paste.id1);
+		dump_ast(depth + 1, node->_paste.id2);
+
+		dump(depth, "}\n");
+		break;
+
+	case AST_FOR:
+		dump(depth, "{FOR:");
+		dump_flags(node);
+		putchar('\n');
+
+		dump_ast(depth + 1, node->_for.pre);
+		dump_ast(depth + 1, node->_for.cond);
+		dump_ast(depth + 1, node->_for.post);
+		dump_ast(depth + 1, node->_for.body);
+
+		dump(depth, "}\n");
+		break;
+
+	case AST_WHILE:
+		dump(depth, "{WHILE:");
+		dump_flags(node);
+		putchar('\n');
+
+		dump_ast(depth + 1, node->_while.cond);
+		dump_ast(depth + 1, node->_while.body);
+
+		dump(depth, "}\n");
+		break;
+
+	case AST_CTRL:
+		dump(depth, "{CTRL:");
+		dump_flags(node);
+		switch(node->_ctrl.kind) {
+		case AST_CTRL_BREAK: printf(" BREAK"); break;
+		case AST_CTRL_CONTINUE: printf(" CONTINUE"); break;
+		}
+		printf("}\n");
+		break;
+
+	case AST_IF:
+		dump(depth, "{IF:");
+		dump_flags(node);
+		putchar('\n');
+
+		dump_ast(depth + 1, node->_if.cond);
+		dump_ast(depth + 1, node->_if.body);
+		dump_ast(depth + 1, node->_if.els);
+
+		dump(depth, "}\n");
+		break;
+
+	case AST_IMPORT:
+		dump(depth, "{IMPORT:");
+		dump_flags(node);
+		printf(" %s}\n", node->_import.file);
+		break;
+
+	case AST_EMBED:
+		dump(depth, "{EMBED:");
+		dump_flags(node);
+		printf(" %s}\n", node->_import.file);
+		break;
+
+	case AST_ENUM:
+		dump(depth, "{ENUM:");
+		dump_flags(node);
+		putchar('\n');
+
+		dump_ast(depth + 1, node->_enum.id);
+		dump_ast(depth + 1, node->_enum.type);
+		dump_ast(depth + 1, node->_enum.body);
+
+		dump(depth, "}\n");
+		break;
+
+	case AST_STRUCT:
+		dump(depth, "{STRUCT:");
+		dump_flags(node);
+		putchar('\n');
+
+		dump_ast(depth + 1, node->_struct.id);
+		dump_ast(depth + 1, node->_struct.generics);
+		dump_ast(depth + 1, node->_struct.body);
+
+		dump(depth, "}\n");
+		break;
+
+	case AST_VAL:
+		dump(depth, "{VAL:");
+		dump_flags(node);
+		putchar('\n');
+
+		dump_ast(depth + 1, node->_val.id);
+		dump_ast(depth + 1, node->_val.val);
+
+		dump(depth, "}\n");
+		break;
+
+	case AST_SWITCH:
+		dump(depth, "{SWITCH:");
+		dump_flags(node);
+		putchar('\n');
+
+		dump_ast(depth + 1, node->_switch.cond);
+		dump_ast(depth + 1, node->_switch.cases);
+
+		dump(depth, "}\n");
+		break;
+
+	case AST_CASE:
+		dump(depth, "{CASE:");
+		dump_flags(node);
+		putchar('\n');
+
+		dump_ast(depth + 1, node->_case.cond);
+		dump_ast(depth + 1, node->_case.body);
+
+		dump(depth, "}\n");
+		break;
+
+	case AST_CONST:
+		dump(depth, "{CONST:");
+		dump_flags(node);
+		switch (node->_const.kind) {
+		case AST_CONST_INTEGER: printf("%lli", node->_const.integer); break;
+		case AST_CONST_STRING: printf("\"%s\"", node->_const.str); break;
+		case AST_CONST_FLOAT: printf("%lf", node->_const.dbl); break;
+		}
+		printf("}\n");
+		break;
+
+	case AST_ALIAS:
+		dump(depth, "{ALIAS:");
+		dump_flags(node);
+		putchar('\n');
+
+		dump_ast(depth + 1, node->_alias.id);
+		dump_ast(depth + 1, node->_alias.type);
+
+		dump(depth, "}\n");
+		break;
+
+	case AST_TEMPLATE:
+		dump(depth, "{TEMPLATE:");
+		dump_flags(node);
+		putchar('\n');
+
+		dump_ast(depth + 1, node->_template.id);
+		dump_ast(depth + 1, node->_template.body);
+
+		dump(depth, "}\n");
+		break;
+	}
+}
+
+void dump_ast(int depth, struct ast_node *root)
+{
+	if (!root) {
+		dump(depth, "{NULL}\n");
+		return;
+	}
+
+	struct ast_node *n = root;
+	do {
+		__dump_ast(depth, n);
+	} while ((n = n->next));
+}
+
+struct ast_node *clone_ast_node(struct ast_node *node)
+{
+	if (!node)
+		return NULL;
+
+	assert(node->node_type);
+	struct ast_node *new = NULL;
+	switch (node->node_type) {
+	case AST_SIZEOF: new = gen_sizeof(clone_ast_node(node->_sizeof.expr));
+			 break;
+
+	case AST_DOT: new = gen_dot(clone_ast_node(node->_dot.expr),
+				      clone_ast_node(node->_dot.id));
+		      break;
+
+	case AST_AS: new = gen_as(clone_ast_node(node->_as.type));
+		     break;
+
+	case AST_GOTO: new = gen_goto(clone_ast_node(node->_goto.label));
+		       break;
+
+	case AST_LABEL: new = gen_label(clone_ast_node(node->_label.id));
+			break;
+
+	case AST_BINOP: new = gen_binop(node->_binop.op,
+					clone_ast_node(node->_binop.left),
+					clone_ast_node(node->_binop.right));
+			break;
+
+	case AST_UNOP: new = gen_unop(node->_unop.op,
+				       clone_ast_node(node->_unop.expr));
+		       break;
+
+	case AST_CALL: new = gen_call(clone_ast_node(node->_call.id),
+				       clone_ast_node(node->_call.args));
+		       break;
+
+	case AST_DEFER: new = gen_defer(clone_ast_node(node->_defer.expr));
+			break;
+
+	case AST_MACRO: new = gen_macro(clone_ast_node(node->_macro.id),
+					clone_ast_node(node->_macro.params),
+					clone_ast_node(node->_macro.body));
+			break;
+
+	case AST_CAST: new = gen_cast(clone_ast_node(node->_cast.expr),
+				       clone_ast_node(node->_cast.type));
+		       break;
+
+	case AST_PROC: new = gen_proc(clone_ast_node(node->_proc.id),
+				       clone_ast_node(node->_proc.sign),
+				       clone_ast_node(node->_proc.body));
+		       break;
+
+	case AST_VAR: {
+		struct ast_node *type = clone_ast_node(node->_var.type);
+		new = gen_var(clone_ast_node(node->_var.id),
+				      type,
+				      clone_ast_node(node->_var.init));
+		/* vars always reference the type associated with them? */
+		new->type = type;
+		break;
+	}
+
+	case AST_LAMBDA: new = gen_lambda(clone_ast_node(node->_lambda.captures),
+					 clone_ast_node(node->_lambda.sign),
+					 clone_ast_node(node->_lambda.body));
+			 break;
+
+	case AST_FOR: new = gen_for(clone_ast_node(node->_for.pre),
+				      clone_ast_node(node->_for.cond),
+				      clone_ast_node(node->_for.post),
+				      clone_ast_node(node->_for.body));
+		      break;
+
+	case AST_WHILE: new = gen_while(clone_ast_node(node->_while.cond),
+					clone_ast_node(node->_while.body));
+			break;
+
+	case AST_CTRL: new = gen_ctrl(node->_ctrl.kind, node->loc);
+		       break;
+
+	case AST_RETURN: new = gen_return(clone_ast_node(node->_return.expr));
+			 break;
+
+	case AST_TYPE:
+			 /* oh, if a node has a ->type it probably isn't cloned
+			  * correctly... */
+			 switch (node->_type.kind) {
+			 case AST_TYPE_ALIAS:
+				 new = gen_type(AST_TYPE_ALIAS, NULL,
+						 node->_type.alias.alias,
+						 node->_type.alias.actual);
+				 break;
+
+			 case AST_TYPE_TEMPLATE:
+				 new = gen_type(AST_TYPE_TEMPLATE, NULL,
+						 node->_type.template.template,
+						 /* should actual be cloned? */
+						 node->_type.template.actual);
+				 break;
+			 case AST_TYPE_ID:
+				 new = gen_type(AST_TYPE_ID,
+						 clone_ast_node(node->_type.id),
+						 NULL, NULL);
+				 break;
+
+			 case AST_TYPE_ARR:
+				 new = gen_type(AST_TYPE_ARR, NULL,
+						 clone_ast_node(node->_type.arr.size),
+						 NULL);
+				 break;
+
+			 case AST_TYPE_TYPEOF:
+				 new = gen_type(AST_TYPE_TYPEOF, NULL,
+						 clone_ast_node(node->_type.typeo.expr),
+						 NULL);
+				 break;
+
+			 case AST_TYPE_POINTER:
+				 new = gen_type(AST_TYPE_POINTER, NULL, NULL, NULL);
+				 break;
+
+			 case AST_TYPE_STRUCT:
+				 new = gen_type(AST_TYPE_STRUCT, NULL,
+						 /* reference */
+						 node->_type.struc.struc,
+						 clone_ast_node(node->_type.struc.impls)
+						 );
+				 break;
+
+			 case AST_TYPE_UNION:
+				 new = gen_type(AST_TYPE_UNION,
+						 clone_ast_node(node->_type.unio.id),
+						 clone_ast_node(node->_type.unio.body),
+						 NULL);
+				 break;
+
+			 case AST_TYPE_PROC:
+				 new = gen_type(AST_TYPE_PROC, NULL,
+						 clone_ast_node(node->_type.proc.params),
+						 clone_ast_node(node->_type.proc.ret));
+				 break;
+
+			 case AST_TYPE_LAMBDA:
+				 new = gen_type(AST_TYPE_LAMBDA, NULL,
+						 clone_ast_node(node->_type.lambda.params),
+						 clone_ast_node(node->_type.lambda.ret));
+				 break;
+
+			 case AST_TYPE_SIGN:
+				 new = gen_type(AST_TYPE_SIGN, NULL,
+						 clone_ast_node(node->_type.sign.params),
+						 clone_ast_node(node->_type.sign.ret));
+				 break;
+
+			 case AST_TYPE_IMPL:
+				 new = gen_type(AST_TYPE_IMPL,
+						 clone_ast_node(node->_type.impl.id),
+						 clone_ast_node(node->_type.impl.types),
+						 NULL);
+			 }
+			 new->_type.next = clone_ast_node(node->_type.next);
+			 break;
+
+	case AST_BLOCK:
+			 /* TODO: should defers also be cloned? Probably? */
+			 new = gen_block(clone_ast_node(node->_block.body));
+			 break;
+
+	case AST_IMPORT:
+			 new = gen_import(strdup(node->_import.file));
+			 break;
+
+	case AST_EMBED:
+			 new = gen_embed(strdup(node->_import.file));
+			 break;
+
+	case AST_PASTE:
+			 new = gen_paste(clone_ast_node(node->_paste.id1),
+					 clone_ast_node(node->_paste.id2));
+			 break;
+
+	case AST_ENUM:
+			 new = gen_enum(clone_ast_node(node->_enum.id),
+					 clone_ast_node(node->_enum.type),
+					 clone_ast_node(node->_enum.body));
+			 break;
+
+	case AST_STRUCT:
+			 new = gen_struct(clone_ast_node(node->_struct.id),
+					 clone_ast_node(node->_struct.generics),
+					 clone_ast_node(node->_struct.body));
+			 break;
+
+	case AST_VAL:
+			 new = gen_val(clone_ast_node(node->_val.id),
+					 clone_ast_node(node->_val.val));
+			 break;
+
+	case AST_SWITCH:
+			 new = gen_switch(clone_ast_node(node->_switch.cond),
+					 clone_ast_node(node->_switch.cases));
+			 break;
+
+	case AST_CASE:
+			 new = gen_case(clone_ast_node(node->_case.cond),
+					 clone_ast_node(node->_case.body));
+			 break;
+
+	case AST_CONST:
+			 switch (node->_const.kind) {
+			 case AST_CONST_INTEGER:
+				 new = gen_int(node->_const.integer);
+				 break;
+
+			 case AST_CONST_STRING:
+				 new = gen_string(strdup(node->_const.str));
+				 break;
+
+			 case AST_CONST_FLOAT:
+				 new = gen_float(node->_const.dbl);
+				 break;
+			 }
+			 break;
+
+	case AST_ID:
+			 new = gen_id(strdup(node->_id.id));
+			 break;
+
+	case AST_EMPTY:
+			 new = gen_empty();
+			 break;
+
+	case AST_LAST:
+			 new = gen_last();
+			 break;
+
+	case AST_ALIAS:
+			 new = gen_alias(clone_ast_node(node->_alias.id),
+					 clone_ast_node(node->_alias.type));
+			 break;
+
+	case AST_TEMPLATE:
+			 new = gen_template(clone_ast_node(node->_template.id),
+					 clone_ast_node(node->_template.body));
+			 break;
+
+	case AST_IF:
+			 new = gen_if(clone_ast_node(node->_if.cond),
+					 clone_ast_node(node->_if.body),
+					 clone_ast_node(node->_if.els));
+			 break;
+	}
+
+	/* if we run out of memory, this assert is likely a bit dumb... */
+	assert(new);
+	new->scope = node->scope;
+	new->flags = node->flags;
+	new->loc = node->loc;
+	new->next = clone_ast_node(node->next);
+
+	/* some special case handled type references for us */
+	if (!new->type)
+		new->type = node->type;
+
+	return new;
+}
+
+/* here we could do a memcmp... */
+static int identical_loc(struct src_loc left, struct src_loc right)
+{
+	return left.first_line == right.first_line
+		&& left.last_line == right.last_line
+		&& left.first_col == right.first_col
+		&& left.last_col == right.last_col;
+}
+
+static int identical_flags(enum ast_flag left, enum ast_flag right)
+{
+	return left == right;
+}
+
+/* TODO: remember to update this if I decide to not mess aroung with this void*
+ * nonsense */
+static int identical_scope(void *left, void *right)
+{
+	return left == right;
+}
+
+/* sort of unfortnate that we can't just do a direct memcmp... */
+int identical_ast_nodes(int exact, struct ast_node *left, struct ast_node *right)
+{
+	/* both being NULL counts as identical */
+	if (!left && !right)
+		return 1;
+
+	/* the same node must be the same */
+	if (left == right)
+		return 1;
+
+	/* either one being null means not identical */
+	if (!left)
+		return 0;
+
+	if (!right)
+		return 0;
+
+	if (left->node_type != right->node_type)
+		return 0;
+
+	if (exact && !identical_flags(left->flags, right->flags))
+		return 0;
+
+	if (exact && !identical_loc(left->loc, right->loc))
+		return 0;
+
+	if (exact && !identical_scope(left->scope, right->scope))
+		return 0;
+
+	switch (left->node_type) {
+	case AST_SIZEOF:
+		if (!identical_ast_nodes(exact, left->_sizeof.expr, right->_sizeof.expr))
+			return 0;
+		break;
+
+	case AST_DOT:
+		if (!identical_ast_nodes(exact, left->_dot.expr, right->_dot.expr))
+			return 0;
+
+		if (!identical_ast_nodes(exact, left->_dot.id, right->_dot.id))
+			return 0;
+		break;
+
+	case AST_AS:
+		if (!identical_ast_nodes(exact, left->_as.type, right->_as.type))
+			return 0;
+		break;
+
+	case AST_GOTO:
+		if (!identical_ast_nodes(exact, left->_goto.label, right->_goto.label))
+			return 0;
+
+		break;
+
+	case AST_LABEL:
+		if (!identical_ast_nodes(exact, left->_label.id, right->_label.id))
+			return 0;
+
+		break;
+
+	case AST_BINOP:
+		if (left->_binop.op != right->_binop.op)
+			return 0;
+
+		if (!identical_ast_nodes(exact, left->_binop.left, right->_binop.left))
+			return 0;
+
+		if (!identical_ast_nodes(exact, left->_binop.right, right->_binop.right))
+			return 0;
+
+		break;
+
+	case AST_UNOP:
+		if (left->_unop.op != right->_unop.op)
+			return 0;
+
+		if (!identical_ast_nodes(exact, left->_unop.expr, right->_unop.expr))
+			return 0;
+
+		break;
+
+	case AST_CALL:
+		if (!identical_ast_nodes(exact, left->_call.id, right->_call.id))
+			return 0;
+
+		if (!identical_ast_nodes(exact, left->_call.args, right->_call.args))
+			return 0;
+
+		break;
+
+	case AST_CAST:
+		if (!identical_ast_nodes(exact, left->_cast.expr, right->_cast.expr))
+			return 0;
+
+		if (!identical_ast_nodes(exact, left->_cast.type, right->_cast.type))
+			return 0;
+
+		break;
+
+	case AST_DEFER:
+		if (!identical_ast_nodes(exact, left->_defer.expr, right->_defer.expr))
+			return 0;
+
+		break;
+
+	case AST_MACRO:
+		if (!identical_ast_nodes(exact, left->_macro.id, right->_macro.id))
+			return 0;
+
+		if (!identical_ast_nodes(exact, left->_macro.params, right->_macro.params))
+			return 0;
+
+		if (!identical_ast_nodes(exact, left->_macro.body, right->_macro.body))
+			return 0;
+
+		break;
+
+	case AST_PROC:
+		if (!identical_ast_nodes(exact, left->_proc.id, right->_proc.id))
+			return 0;
+
+		if (!identical_ast_nodes(exact, left->_proc.sign, right->_proc.sign))
+			return 0;
+
+		if (!identical_ast_nodes(exact, left->_proc.body, right->_proc.body))
+			return 0;
+
+		break;
+
+	case AST_VAR:
+		if (!identical_ast_nodes(exact, left->_var.id, right->_var.id))
+			return 0;
+
+		if (!identical_ast_nodes(exact, left->_var.type, right->_var.type))
+			return 0;
+
+		if (!identical_ast_nodes(exact, left->_var.init, right->_var.init))
+			return 0;
+
+		break;
+
+	case AST_LAMBDA:
+		if (!identical_ast_nodes(exact, left->_lambda.captures, right->_lambda.captures))
+			return 0;
+
+		if (!identical_ast_nodes(exact, left->_lambda.sign, right->_lambda.sign))
+			return 0;
+
+		if (!identical_ast_nodes(exact, left->_lambda.body, right->_lambda.body))
+			return 0;
+
+		break;
+
+	case AST_FOR:
+		if (!identical_ast_nodes(exact, left->_for.pre, right->_for.pre))
+			return 0;
+
+		if (!identical_ast_nodes(exact, left->_for.cond, right->_for.cond))
+			return 0;
+
+		if (!identical_ast_nodes(exact, left->_for.post, right->_for.post))
+			return 0;
+
+		if (!identical_ast_nodes(exact, left->_for.body, right->_for.body))
+			return 0;
+
+		break;
+
+	case AST_WHILE:
+		if (!identical_ast_nodes(exact, left->_while.cond, right->_while.cond))
+			return 0;
+
+		if (!identical_ast_nodes(exact, left->_while.body, right->_while.body))
+			return 0;
+
+		break;
+
+	case AST_CTRL:
+		if (left->_ctrl.kind != right->_ctrl.kind)
+			return 0;
+
+		break;
+
+	case AST_RETURN:
+		if (!identical_ast_nodes(exact, left->_return.expr, right->_return.expr))
+			return 0;
+
+		break;
+
+	case AST_TYPE:
+		if (left->_type.kind != right->_type.kind)
+			return 0;
+
+		switch (left->_type.kind) {
+		case AST_TYPE_ALIAS:
+			if (!identical_ast_nodes(exact, left->_type.alias.alias,
+						right->_type.alias.alias))
+				return 0;
+
+			if (!identical_ast_nodes(exact, left->_type.alias.actual,
+						right->_type.alias.actual))
+				return 0;
+			break;
+
+		case AST_TYPE_TEMPLATE:
+			if (!identical_ast_nodes(exact, left->_type.template.template,
+						right->_type.template.template))
+				return 0;
+
+			if (!identical_ast_nodes(exact, left->_type.template.actual,
+						right->_type.template.actual))
+				return 0;
+			break;
+
+		case AST_TYPE_ID:
+			if (!identical_ast_nodes(exact, left->_type.id,
+						right->_type.id))
+				return 0;
+			break;
+
+		case AST_TYPE_ARR:
+			if (!identical_ast_nodes(exact, left->_type.arr.size,
+						right->_type.arr.size))
+				return 0;
+			break;
+
+		case AST_TYPE_TYPEOF:
+			if (!identical_ast_nodes(exact, left->_type.typeo.expr,
+						right->_type.typeo.expr))
+				return 0;
+			break;
+
+		case AST_TYPE_PROC:
+			if (!identical_ast_nodes(exact, left->_type.proc.params,
+						right->_type.proc.params))
+				return 0;
+
+			if (!identical_ast_nodes(exact, left->_type.proc.ret,
+						right->_type.proc.ret))
+				return 0;
+			break;
+
+		case AST_TYPE_LAMBDA:
+			if (!identical_ast_nodes(exact, left->_type.lambda.params,
+						right->_type.lambda.params))
+				return 0;
+
+			if (!identical_ast_nodes(exact, left->_type.lambda.ret,
+						right->_type.lambda.ret))
+				return 0;
+			break;
+
+		case AST_TYPE_SIGN:
+			if (!identical_ast_nodes(exact, left->_type.sign.params,
+						right->_type.sign.params))
+				return 0;
+
+			if (!identical_ast_nodes(exact, left->_type.sign.ret,
+						right->_type.sign.ret))
+				return 0;
+			break;
+
+		case AST_TYPE_IMPL:
+			if (!identical_ast_nodes(exact, left->_type.impl.id,
+						right->_type.impl.id))
+				return 0;
+
+			if (!identical_ast_nodes(exact, left->_type.impl.types,
+						right->_type.impl.types))
+				return 0;
+			break;
+
+		case AST_TYPE_STRUCT:
+			if (!identical_ast_nodes(exact, left->_type.struc.struc,
+						right->_type.struc.struc))
+				return 0;
+
+			if (!identical_ast_nodes(exact, left->_type.struc.impls,
+						right->_type.struc.impls))
+				return 0;
+			break;
+
+		case AST_TYPE_UNION:
+			if (!identical_ast_nodes(exact, left->_type.unio.id,
+						right->_type.unio.id))
+				return 0;
+
+			if (!identical_ast_nodes(exact, left->_type.unio.body,
+						right->_type.unio.body))
+				return 0;
+			break;
+
+		case AST_TYPE_POINTER:
+			break;
+		}
+
+		break;
+
+	case AST_BLOCK:
+		if (!identical_ast_nodes(exact, left->_block.body, right->_block.body))
+			return 0;
+		break;
+
+	case AST_IMPORT:
+		if (strcmp(left->_import.file, right->_import.file) != 0)
+			return 0;
+		break;
+
+	case AST_EMBED:
+		if (strcmp(left->_embed.file, right->_embed.file) != 0)
+			return 0;
+		break;
+
+	case AST_PASTE:
+		if (!identical_ast_nodes(exact, left->_paste.id1, right->_paste.id1))
+			return 0;
+
+		if (!identical_ast_nodes(exact, left->_paste.id2, right->_paste.id2))
+			return 0;
+
+		break;
+
+	case AST_ENUM:
+		if (!identical_ast_nodes(exact, left->_enum.id, right->_enum.id))
+			return 0;
+
+		if (!identical_ast_nodes(exact, left->_enum.type, right->_enum.type))
+			return 0;
+
+		if (!identical_ast_nodes(exact, left->_enum.body, right->_enum.body))
+			return 0;
+
+		break;
+
+	case AST_STRUCT:
+		if (!identical_ast_nodes(exact, left->_struct.id, right->_struct.id))
+			return 0;
+
+		if (!identical_ast_nodes(exact, left->_struct.generics, right->_struct.generics))
+			return 0;
+
+		if (!identical_ast_nodes(exact, left->_struct.body, right->_struct.body))
+			return 0;
+
+		break;
+
+	case AST_VAL:
+		if (!identical_ast_nodes(exact, left->_val.id, right->_val.id))
+			return 0;
+
+		if (!identical_ast_nodes(exact, left->_val.val, right->_val.val))
+			return 0;
+
+		break;
+
+	case AST_SWITCH:
+		if (!identical_ast_nodes(exact, left->_switch.cond, right->_switch.cond))
+			return 0;
+
+		if (!identical_ast_nodes(exact, left->_switch.cases, right->_switch.cases))
+			return 0;
+
+		break;
+
+	case AST_CASE:
+		if (!identical_ast_nodes(exact, left->_case.cond, right->_switch.cond))
+			return 0;
+
+		if (!identical_ast_nodes(exact, left->_case.body, right->_case.body))
+			return 0;
+
+		break;
+
+	case AST_CONST:
+		if (left->_const.kind != right->_const.kind)
+			return 0;
+
+		switch (left->_const.kind) {
+		case AST_CONST_INTEGER:
+			if (left->_const.integer != right->_const.integer)
+				return 0;
+			break;
+
+		case AST_CONST_FLOAT:
+			/* NaNs aren't comparable */
+			if (isnan(left->_const.dbl) && isnan(left->_const.dbl))
+				break;
+
+			if (left->_const.dbl != right->_const.dbl)
+				return 0;
+			break;
+
+		case AST_CONST_STRING:
+			if (strcmp(left->_const.str, right->_const.str) != 0)
+				return 0;
+			break;
+		}
+		break;
+
+	case AST_ID:
+		if (strcmp(left->_id.id, right->_id.id) != 0)
+			return 0;
+		break;
+
+	case AST_EMPTY:
+		break;
+
+	case AST_LAST:
+		break;
+
+	case AST_ALIAS:
+		if (!identical_ast_nodes(exact, left->_alias.id, right->_alias.id))
+			return 0;
+
+		if (!identical_ast_nodes(exact, left->_alias.type, right->_alias.type))
+			return 0;
+
+		break;
+
+	case AST_TEMPLATE:
+		if (!identical_ast_nodes(exact, left->_template.id, right->_template.id))
+			return 0;
+
+		if (!identical_ast_nodes(exact, left->_template.body, right->_template.body))
+			return 0;
+
+		break;
+
+	case AST_IF:
+		if (!identical_ast_nodes(exact, left->_if.cond, right->_if.cond))
+			return 0;
+
+		if (!identical_ast_nodes(exact, left->_if.body, right->_if.body))
+			return 0;
+
+		if (!identical_ast_nodes(exact, left->_if.els, right->_if.els))
+			return 0;
+
+		break;
+	}
+
+	/* Unsure if exact should be more of a flag or what,
+	 * but at least right now the issue is that the analyzer in some cases
+	 * has nodes that follow each other, i.e. next is populated, but we're
+	 * only interested in the current node. Calls, mainly. */
+	if (exact)
+		return identical_ast_nodes(exact, left->next, right->next);
+
+	return 1;
+}
+
+int ast_flags(struct ast_node *node, enum ast_flag flags)
+{
+	return node->flags & flags;
+}
+
+/* I guess this works, but it's not exactly optimal as the caller sort of has to
+ * know when to continue to call on, and when it would cause an infinite loop.
+ * I.e. a call on an ID that is forwarded results in an infinite loop.
+ *
+ * Maybe add in something like ast_continue_call_on() that can check for the
+ * user if there's any point in continuing?
+ */
+int ast_call_on(int (*call)(struct ast_node *, void *data),
+		struct ast_node *node, void *data)
+{
+	int ret = 0;
+	if (!node)
+		return ret;
+
+	switch (node->node_type) {
+	case AST_SIZEOF:
+		ret |= call(node->_sizeof.expr, data);
+		break;
+
+	case AST_DOT:
+		ret |= call(node->_dot.expr, data);
+		ret |= call(node->_dot.id, data);
+		break;
+
+	case AST_AS:
+		ret |= call(node->_as.type, data);
+		break;
+
+	case AST_CAST:
+		ret |= call(node->_cast.expr, data);
+		ret |= call(node->_cast.type, data);
+		break;
+
+	case AST_DEFER:
+		ret |= call(node->_defer.expr, data);
+		break;
+
+	case AST_LAST:
+		break;
+
+	case AST_VAR:
+		ret |= call(node->_var.id, data);
+		ret |= call(node->_var.type, data);
+		ret |= call(node->_var.init, data);
+		break;
+
+	case AST_LAMBDA:
+		ret |= call(node->_lambda.captures, data);
+		ret |= call(node->_lambda.sign, data);
+		ret |= call(node->_lambda.body, data);
+		break;
+
+	case AST_PASTE:
+		ret |= call(node->_paste.id1, data);
+		ret |= call(node->_paste.id2, data);
+		break;
+
+	case AST_FOR:
+		ret |= call(node->_for.pre, data);
+		ret |= call(node->_for.cond, data);
+		ret |= call(node->_for.post, data);
+		ret |= call(node->_for.body, data);
+		break;
+
+	case AST_EMBED:
+		break;
+
+	case AST_WHILE:
+		ret |= call(node->_while.cond, data);
+		ret |= call(node->_while.body, data);
+		break;
+
+	case AST_CTRL:
+		break;
+
+	case AST_RETURN:
+		ret |= call(node->_return.expr, data);
+		break;
+
+	case AST_ALIAS:
+		ret |= call(node->_alias.id, data);
+		ret |= call(node->_alias.type, data);
+		break;
+
+	case AST_TEMPLATE:
+		ret |= call(node->_template.id, data);
+		ret |= call(node->_template.body, data);
+		break;
+
+	case AST_IF:
+		ret |= call(node->_if.cond, data);
+		ret |= call(node->_if.body, data);
+		ret |= call(node->_if.els, data);
+		break;
+
+	case AST_IMPORT:
+		break;
+
+	case AST_ENUM:
+		ret |= call(node->_enum.id, data);
+		ret |= call(node->_enum.type, data);
+		ret |= call(node->_enum.body, data);
+		break;
+
+	case AST_STRUCT:
+		ret |= call(node->_struct.id, data);
+		ret |= call(node->_struct.generics, data);
+		ret |= call(node->_struct.body, data);
+		break;
+
+	case AST_VAL:
+		ret |= call(node->_val.id, data);
+		ret |= call(node->_val.val, data);
+		break;
+
+	case AST_SWITCH:
+		ret |= call(node->_switch.cond, data);
+		ret |= call(node->_switch.cases, data);
+		break;
+
+	case AST_CASE:
+		ret |= call(node->_case.cond, data);
+		ret |= call(node->_case.body, data);
+		break;
+
+	case AST_CONST:
+		break;
+
+	case AST_ID:
+		break;
+
+	case AST_EMPTY:
+		break;
+
+	case AST_TYPE:
+		switch (node->_type.kind) {
+		case AST_TYPE_ALIAS:
+			ret |= call(node->_type.alias.alias, data);
+			ret |= call(node->_type.alias.actual, data);
+			break;
+
+		case AST_TYPE_TEMPLATE:
+			ret |= call(node->_type.template.template, data);
+			ret |= call(node->_type.template.actual, data);
+			break;
+
+		case AST_TYPE_ID:
+			ret |= call(node->_type.id, data);
+			break;
+
+		case AST_TYPE_ARR:
+			ret |= call(node->_type.arr.size, data);
+			break;
+
+		case AST_TYPE_TYPEOF:
+			ret |= call(node->_type.typeo.expr, data);
+			break;
+
+		case AST_TYPE_POINTER:
+			break;
+
+		case AST_TYPE_UNION:
+			ret |= call(node->_type.unio.id, data);
+			ret |= call(node->_type.unio.body, data);
+			break;
+
+		case AST_TYPE_STRUCT:
+			ret |= call(node->_type.struc.struc, data);
+			ret |= call(node->_type.struc.impls, data);
+			break;
+
+		case AST_TYPE_PROC:
+			ret |= call(node->_type.proc.id, data);
+			ret |= call(node->_type.proc.params, data);
+			ret |= call(node->_type.proc.ret, data);
+			break;
+
+		case AST_TYPE_LAMBDA:
+			ret |= call(node->_type.lambda.params, data);
+			ret |= call(node->_type.lambda.ret, data);
+			break;
+
+		case AST_TYPE_SIGN:
+			ret |= call(node->_type.sign.params, data);
+			ret |= call(node->_type.sign.ret, data);
+			break;
+
+		case AST_TYPE_IMPL:
+			ret |= call(node->_type.impl.id, data);
+			ret |= call(node->_type.impl.types, data);
+			break;
+		}
+		break;
+
+	case AST_GOTO:
+		ret |= call(node->_goto.label, data);
+		break;
+
+	case AST_LABEL:
+		ret |= call(node->_label.id, data);
+		break;
+
+	case AST_BINOP:
+		ret |= call(node->_binop.left, data);
+		ret |= call(node->_binop.right, data);
+		break;
+
+	case AST_UNOP:
+		ret |= call(node->_unop.expr, data);
+		break;
+
+	case AST_CALL:
+		ret |= call(node->_call.id, data);
+		ret |= call(node->_call.args, data);
+		break;
+
+	case AST_MACRO:
+		ret |= call(node->_macro.id, data);
+		ret |= call(node->_macro.params, data);
+		ret |= call(node->_macro.body, data);
+		break;
+
+	case AST_PROC:
+		ret |= call(node->_proc.id, data);
+		ret |= call(node->_proc.sign, data);
+		ret |= call(node->_proc.body, data);
+		break;
+
+	case AST_BLOCK:
+		ret |= call(node->_block.body, data);
+		break;
+	}
+
+	ret |= call(node->next, data);
+	return ret;
+}
+
+size_t ast_list_len(struct ast_node *node)
+{
+	size_t count = 1;
+	while (node) {
+		count++;
+		node = node->next;
+	}
+
+	return count;
+}
+
+struct ast_node *ast_last_node(struct ast_node *n)
+{
+	if (!n)
+		return NULL;
+
+	while (n->next)
+		n = n->next;
+
+	return n;
+}
+
+struct ast_node *ast_block_last(struct ast_node *n)
+{
+	struct ast_node *b = ast_last_node(n);
+	if (b && b->node_type == AST_BLOCK)
+		return ast_block_last(b->_block.body);
+
+	return b;
+}
+
diff --git a/src/compiler.c b/src/compiler.c
index b222c2e..782001f 100644
--- a/src/compiler.c
+++ b/src/compiler.c
@@ -3,284 +3,116 @@
 #include <unistd.h>
 #include <ctype.h>
 #include <stdlib.h>
-#include <regex.h>
+#include <limits.h>
 #include <errno.h>
 
-#include <ct/compiler.h>
-#include <ct/string.h>
-#include <ct/debug.h>
-#include <ct/path.h>
-#include <ct/res.h>
+#include <cu/actualize.h>
+#include <cu/compiler.h>
+#include <cu/string.h>
+#include <cu/parser.h>
+#include <cu/debug.h>
+#include <cu/scope.h>
+#include <cu/path.h>
+#include <cu/res.h>
 
-const char *import_regex =
-"^[[:space:]]*(pub[[:space:]]+)?"
-"import[[:space:]]+"
-"([[:alnum:]/.]+)"
-"[[:space:]]*;"
-"[[:space:]]*$";
-
-const char *define_regex =
-"^[[:space:]]*(pub[[:space:]]+)?"
-"define[[:space:]]+"
-"([[:alnum:]]+)[[:space:]]*"
-"\\((.*)\\)"
-"[[:space:]]*"
-"\\{(.*)\\}"
-"[[:space:]]*$";
-
-regex_t import_re;
-regex_t define_re;
-
-/* this could maybe be moved to a utility file or something */
-static char *get_regerror(int errcode, regex_t *compiled)
-{
-	size_t len = regerror(errcode, compiled, NULL, 0);
-	char *buf = malloc(len);
-	regerror(errcode, compiled, buf, len);
-	return buf;
-}
-
-static int read_element(FILE *f, struct string *element)
+static char *read_file(const char *file, FILE *f)
 {
-	if (feof(f))
-		return -1;
-
-	str_clear(element);
-
-	char c = fgetc(f);
-	str_append(element, c);
-	if (!isalnum(c))
-		return 0;
-
-	while ((c = fgetc(f))) {
-		if (isalnum(c)) {
-			str_append(element, c);
-		} else {
-			ungetc(c, f);
-			break;
-		}
-	}
-
-	return 0;
-}
-
-static struct string *read_block(FILE *f, size_t *lines)
-{
-	size_t depth = 0;
-	bool maybe_statement = true;
-	struct string *block = new_string(NULL);
-	if (!block)
-		return NULL;
-
-	struct string *elem = new_string(NULL);
-	if (!elem) {
-		destroy_string(block);
+	fseek(f, 0, SEEK_END);
+	/* TODO: check how well standardized this actually is */
+	long s = ftell(f);
+	if (s == LONG_MAX) {
+		error("%s might be a directory", file);
 		return NULL;
 	}
 
-	size_t newlines = 0;
-	while (1) {
-		if (read_element(f, elem)) {
-			destroy_string(elem);
-			destroy_string(block);
-			return NULL;
-		}
-
-		if (maybe_statement && str_compare(elem, ";")) {
-			str_add(block, elem);
-			break;
-		}
-
-		if (str_compare(elem, "{")) {
-			maybe_statement = false;
-			depth += 1;
-		}
-
-		if (str_compare(elem, "}"))
-			depth -= 1;
-
-		str_add(block, elem);
-
-		if (str_compare(elem, "\n"))
-			newlines++;
-
-		if (!maybe_statement && depth == 0)
-			break;
-	}
-
-	if (lines)
-		*lines += newlines;
-
-	destroy_string(elem);
-	return block;
-}
-
-static bool detect_pub(struct string *block, regmatch_t rm)
-{
-	const char *start = block->buf + rm.rm_so;
-	const size_t len = rm.rm_eo - rm.rm_so;
-	const size_t min = len < 3 ? len : 3;
-	return strncmp(start, "pub", min);
-}
+	fseek(f, 0, SEEK_SET);
 
-static char *extract_match(struct string *block, regmatch_t rm)
-{
-	const char *start = block->buf + rm.rm_so;
-	const size_t len = rm.rm_eo - rm.rm_so;
-	char *match = strndup(start, len);
-	if (!match)
-		error("couldn't extract match: %s\n", strerror(errno));
+	char *buf = malloc(s + 1);
+	if (!buf)
+		return NULL;
 
-	return match;
+	fread(buf, s + 1, 1, f);
+	/* remember terminating null */
+	buf[s] = 0;
+	return buf;
 }
 
-static bool detect_import(struct string *block, bool *pub, char **file)
+static int process(struct scope **parent, int public, const char *file)
 {
-	int ret = 0;
-	const size_t captures = 3;
-	regmatch_t rm[captures];
-	ret = regexec(&import_re, block->buf, captures, rm, 0);
-
-	switch (ret) {
-	case REG_ESPACE: error("import regex ran out of memory: %s\n",
-					 strerror(errno));
-			 /* fallthrough */
-	case REG_NOMATCH: return false;
+	FILE *f = fopen(file, "rb");
+	if (!f) {
+		error("failed opening %s: %s\n", file, strerror(errno));
+		return -1;
 	}
 
-	*pub = detect_pub(block, rm[1]);
-	*file = extract_match(block, rm[2]);
-	return true;
-}
-
-static bool detect_define(struct string *block, bool *pub,
-		char **name, char **args, char **content)
-{
-	int ret = 0;
-	const size_t captures = 5;
-	regmatch_t rm[captures];
-	ret = regexec(&define_re, block->buf, captures, rm, 0);
-
-	switch (ret) {
-	case REG_ESPACE: error("define regex ran out of memory: %s\n",
-					 strerror(errno));
-			 /* fallthrough */
-	case REG_NOMATCH: return false;
-	}
+	const char *buf = read_file(file, f);
+	fclose(f);
 
-	*pub = detect_pub(block, rm[1]);
-	*name = extract_match(block, rm[2]);
-	*args = extract_match(block, rm[3]);
-	*content = extract_match(block, rm[4]);
-	return true;
-}
+	if (!buf)
+		return -1;
 
-static void process_file(const char *file);
+	struct parser *p = create_parser();
+	if (!p)
+		return -1;
+	parse(p, file, buf);
 
-static int process(const char *file)
-{
-	FILE *f = fopen(file, "r");
-	if (!f) {
-		error("failed opening %s: %s\n", file, strerror(errno));
+	struct scope *scope = create_scope();
+	if (!scope)
 		return -1;
-	}
 
-	size_t lines = 1, prev_lines = 1;
-	struct string *block;
-	while ((block = read_block(f, &lines))) {
-		debug("block: (%zu - %zu, %zu)\n%s\n", prev_lines, lines,
-				lines - prev_lines, block->buf);
-		prev_lines = lines + 1;
+	if (public)
+		scope_set_flags(scope, SCOPE_PUBLIC);
 
-		bool pub = false;
-		char *file = NULL;
-		if (detect_import(block, &pub, &file)) {
-			debug("detected %s import block for file (%s)\n",
-					pub ? "public" : "private",
-					file);
-			process_file(file);
-			free(file);
-			goto next;
-		}
+	scope->fctx.fbuf = buf;
+	scope->fctx.fname = strdup(file);
+	scope->actuals = create_actuals();
+	scope_set_flags(scope, SCOPE_FILE);
 
-		char *name = NULL, *args = NULL, *content = NULL;
-		if (detect_define(block, &pub, &name, &args, &content)) {
-			debug("detected %s define block %s (%s) {%s}\n",
-					pub ? "public" : "private",
-					name, args, content);
-			free(name);
-			free(args);
-			free(content);
-			goto next;
-		}
+	if (*parent)
+		scope_add_scope(*parent, scope);
+	else
+		*parent = scope;
 
-		/* with each block,
-		 * A) Detect if it is an import block and what kind,
-		 * in which case process the file that it refers to.
-		 *
-		 * B) Detect if it is a macro block and what kind, in which case
-		 * parse it and add it to the macro subsystem.
-		 *
-		 * C) Run the preprocessor on the block.
-		 *
-		 * D) Actually lex/parse/generate AST for the block.
-		 *
-		 * E) Run semantic checks on the block.
-		 *
-		 * With all of these parts checked, I'm pretty sure we can
-		 * directly generate code for each block. Possibly something
-		 * like one C file per CT file, will have to look into what
-		 * might be easiest. Also, some internal duplicate checking, so
-		 * that we don't accidentally generate the same generic function
-		 * in two different files or something like that.
-		 *
-		 * Same duplicate checking could be useful for the interpreted
-		 * approach.
-		 *
-		 * Step D) could potentially be done on request, maybe fitting
-		 * for the interpreted approach, I guess it depends on how fast the
-		 * lexing/parsing/AST generation for each block is. Semantic
-		 * checking is what I suspect will be the slowest part.
-		 *
-		 * Oh yeah, need some way to push result of some lower file
-		 * processing upwards. And probably detecting a main block as
-		 * well?
-		 */
-next:
-		destroy_string(block);
-	}
+	if (analyze_root(scope, p->tree))
+		return -1;
+
+	destroy_parser(p);
 
-	fclose(f);
 	return 0;
 }
 
-void process_file(const char *file)
+int process_file(struct scope **scope, int public, const char *file)
 {
+	int res = -1;
+	/* TODO: report failure allocating stuff maybe? */
 	struct res *r = res_create();
+	if (!r)
+		return -1;
 
-	const char *base = ct_basename(file);
+	const char *base = cu_basename(file);
 	res_add(r, (void *)base);
 	if (!base)
 		goto out;
 
-	const char *dir = ct_dirname(file);
+	const char *dir = cu_dirname(file);
 	res_add(r, (void *)dir);
 	if (!dir)
 		goto out;
 
-	const char *cwd = ct_cwdname();
+	/* TODO: iterate through include paths */
+	const char *cwd = cu_cwdname();
 	res_add(r, (void *)cwd);
 	if (!cwd)
 		goto out;
 
-	debug("(cwd:%s)(dir:%s)(base:%s)\n", cwd, dir, base);
+	debug("(cwd:%s)(dir:%s)(base:%s)", cwd, dir, base);
 
 	if (*dir != 0 && chdir(dir)) {
-		error("couldn't change to directory %s: %s\n", dir, strerror(errno));
+		error("couldn't change to directory %s: %s", dir, strerror(errno));
 		goto out;
 	}
 
-	if (process(base))
+	if (process(scope, public, base))
 		goto out;
 
 	if (chdir(cwd)) {
@@ -288,30 +120,22 @@ void process_file(const char *file)
 		goto out;
 	}
 
+	res = 0;
 out:
 	res_destroy(r);
+	return res;
 }
 
-void compile(const char *file) {
-	int err = 0;
-	if ((err = regcomp(&import_re, import_regex, REG_EXTENDED)) != 0) {
-		char *err_str = get_regerror(err, &import_re);
-		error("failed compiling import regex: %s\n", err_str);
-		free(err_str);
-		goto out;
+int compile(const char *file) {
+	int ret = -1;
+	struct scope *root = NULL;
+	if (process_file(&root, 0, file)) {
+		error("compilation of %s stopped due to errors", file);
+		return ret;
 	}
 
-	if ((err = regcomp(&define_re, define_regex, REG_EXTENDED)) != 0) {
-		char *err_str = get_regerror(err, &define_re);
-		error("failed compiling define regex: %s\n", err_str);
-		free(err_str);
-		goto define_out;
-	}
-
-	process_file(file);
-
-	regfree(&define_re);
-define_out:
-	regfree(&import_re);
-out:
+	ret = actualize_main(root);
+	/* TODO: backend */
+	destroy_scope(root);
+	return ret;
 }
diff --git a/src/ctpp.c b/src/ctpp.c
deleted file mode 100644
index f0759d0..0000000
--- a/src/ctpp.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <ct/ctpp.h>
-#include <ct/debug.h>
-
-void add_predefined_variable(const char *var)
-{
-	debug("adding predefined variable '%s'...\n", var);
-}
diff --git a/src/debug.c b/src/debug.c
new file mode 100644
index 0000000..e18ae70
--- /dev/null
+++ b/src/debug.c
@@ -0,0 +1,246 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdarg.h>
+
+#include <cu/debug.h>
+
+const char *issue_level_str(enum issue_level level)
+{
+	switch (level) {
+	case SRC_INFO: return "info";
+	case SRC_WARN: return "warn";
+	case SRC_ERROR: return "error";
+	}
+
+	return "unknown";
+}
+
+static const char *find_lineno(const char *buf, size_t no)
+{
+	if (no == 1)
+		return buf;
+
+	char c;
+	while ((c = *buf)) {
+		buf++;
+
+		if (c == '\n')
+			no--;
+
+		if (no == 1)
+			break;
+	}
+
+	return buf;
+}
+
+static void _issue(struct src_issue issue, const char *fmt, va_list args)
+{
+	/* get start and end of current line in buffer */
+	const char *line_start = find_lineno(issue.fctx.fbuf, issue.loc.first_line);
+	const char *line_end = strchr(line_start, '\n');
+	if (!line_end)
+		line_end = strchr(line_start, 0);
+
+	const int line_len = line_end - line_start;
+
+	fprintf(stderr, "%s:%i:%i: %s: ", issue.fctx.fname,
+			issue.loc.first_line,
+			issue.loc.first_col,
+			issue_level_str(issue.level));
+
+	vfprintf(stderr, fmt, args);
+	fputc('\n', stderr);
+
+	int lineno_len = snprintf(NULL, 0, "%i", issue.loc.first_line);
+	fputc(' ', stderr);
+	fprintf(stderr, "%i | ", issue.loc.first_line);
+
+	fprintf(stderr, "%.*s\n", line_len, line_start);
+
+	for (int i = 0; i < lineno_len + 2; ++i)
+		fputc(' ', stderr);
+
+	fprintf(stderr, "| ");
+
+	for (int i = 0; i < issue.loc.first_col - 1; ++i)
+		fputc(line_start[i] == '\t' ? '\t' : ' ', stderr);
+
+	for (int i = issue.loc.first_col; i < issue.loc.last_col; ++i) {
+		if (i == issue.loc.first_col)
+			fputc('^', stderr);
+		else
+			fputc('~', stderr);
+	}
+
+	fputc('\n', stderr);
+}
+
+void src_issue(struct src_issue issue, const char *err_msg, ...)
+{
+	va_list args;
+	va_start(args, err_msg);
+	_issue(issue, err_msg, args);
+	va_end(args);
+}
+
+/* TODO: should really implement these better, the bad error messages are
+ * starting to play a role in debugging */
+void semantic_error(struct file_ctx fctx, struct ast_node *node, const char *fmt, ...)
+{
+	va_list args;
+	va_start(args, fmt);
+	struct src_issue issue;
+	issue.level = SRC_ERROR;
+	issue.loc = node->loc;
+	issue.fctx = fctx;
+	_issue(issue, fmt, args);
+	va_end(args);
+}
+
+void semantic_warn(struct file_ctx fctx, struct ast_node *node, const char *fmt, ...)
+{
+	va_list args;
+	va_start(args, fmt);
+	struct src_issue issue;
+	issue.level = SRC_WARN;
+	issue.loc = node->loc;
+	issue.fctx = fctx;
+	_issue(issue, fmt, args);
+	va_end(args);
+}
+
+void semantic_info(struct file_ctx fctx, struct ast_node *node, const char *fmt, ...)
+{
+	va_list args;
+	va_start(args, fmt);
+	struct src_issue issue;
+	issue.level = SRC_INFO;
+	issue.loc = node->loc;
+	issue.fctx = fctx;
+	_issue(issue, fmt, args);
+	va_end(args);
+}
+
+void internal_error(const char *fmt, ...)
+{
+	va_list args;
+	va_start(args, fmt);
+	fprintf(stderr, "internal error: ");
+	vfprintf(stderr, fmt, args);
+	fprintf(stderr, "\n");
+	va_end(args);
+}
+
+static void _type_str(FILE *fp, struct ast_node *type)
+{
+	if (!type)
+		return;
+
+	assert(type->node_type == AST_TYPE);
+
+	switch (type->_type.kind) {
+	case AST_TYPE_POINTER:
+		fputc('\'', fp);
+		break;
+
+	case AST_TYPE_ID: {
+		struct ast_node *id = type->_type.id;
+		fprintf(fp, "%s", id->_id.id);
+		break;
+	}
+
+	case AST_TYPE_TEMPLATE: {
+		struct ast_node *template = type->_type.template.template;
+		assert(template);
+
+		struct ast_node *template_id = template->_template.id;
+		struct ast_node *template_act = type->_type.template.actual;
+		if (template_act) {
+			fprintf(fp, "%s as ", template_id->_id.id);
+			_type_str(fp, template_act);
+		}
+		else {
+			fprintf(fp, "%s", template_id->_id.id);
+		}
+		break;
+	}
+
+	case AST_TYPE_ALIAS: {
+		struct ast_node *alias = type->_type.alias.alias;
+		assert(alias);
+
+		struct ast_node *alias_id = alias->_alias.id;
+		struct ast_node *alias_act = type->_type.alias.actual;
+		if (alias_act) {
+			/* deeply nested aliases look pretty funny here */
+			fprintf(fp, "%s aka ", alias_id->_id.id);
+			_type_str(fp, alias_act);
+		}
+		else {
+			fprintf(fp, "%s", alias_id->_id.id);
+		}
+		break;
+	}
+	}
+
+	_type_str(fp, type->_type.next);
+}
+
+char *type_str(struct ast_node *node)
+{
+	/* maybe hacky? */
+	if (!node)
+		return strdup("void");
+
+	char *buf = NULL; size_t size = 0;
+	FILE *memstream = open_memstream(&buf, &size);
+
+	/* TODO: improve template detection */
+	/* we were given a plain type, pass it directly along to _type_str */
+	if (node->node_type == AST_TYPE)
+		_type_str(memstream, node);
+	else
+		/* otherwise, try to fish out the type of the node */
+		_type_str(memstream, node->type);
+
+	fclose(memstream);
+	return buf;
+}
+
+static void _call_str(FILE *f, struct ast_node *call)
+{
+	struct ast_node *id = call->_call.id;
+	const char *id_str = id->_id.id;
+	fprintf(f, "%s", id_str);
+
+	struct ast_node *args = call->_call.args;
+	fprintf(f, "(");
+
+	while (args) {
+		char *type = type_str(args);
+		fprintf(f, "%s", type);
+		free(type);
+
+		args = args->next;
+		if (args)
+			fprintf(f, ", ");
+		else
+			break;
+	}
+
+	fprintf(f, ")");
+}
+
+char *call_str(struct ast_node *call)
+{
+	assert(call->node_type == AST_CALL);
+	char *buf = NULL; size_t size = 0;
+	FILE *memstream = open_memstream(&buf, &size);
+	_call_str(memstream, call);
+	fclose(memstream);
+	return buf;
+}
diff --git a/src/gen_lexer.c b/src/gen_lexer.c
new file mode 100644
index 0000000..6852640
--- /dev/null
+++ b/src/gen_lexer.c
@@ -0,0 +1,2589 @@
+#line 2 "src/gen_lexer.c"
+
+#line 4 "src/gen_lexer.c"
+
+#define  YY_INT_ALIGNED short int
+
+/* A lexical scanner generated by flex */
+
+#define FLEX_SCANNER
+#define YY_FLEX_MAJOR_VERSION 2
+#define YY_FLEX_MINOR_VERSION 6
+#define YY_FLEX_SUBMINOR_VERSION 4
+#if YY_FLEX_SUBMINOR_VERSION > 0
+#define FLEX_BETA
+#endif
+
+/* First, we deal with  platform-specific or compiler-specific issues. */
+
+/* begin standard C headers. */
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <stdlib.h>
+
+/* end standard C headers. */
+
+/* flex integer type definitions */
+
+#ifndef FLEXINT_H
+#define FLEXINT_H
+
+/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
+
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+
+/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
+ * if you want the limit (max/min) macros for int types. 
+ */
+#ifndef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS 1
+#endif
+
+#include <inttypes.h>
+typedef int8_t flex_int8_t;
+typedef uint8_t flex_uint8_t;
+typedef int16_t flex_int16_t;
+typedef uint16_t flex_uint16_t;
+typedef int32_t flex_int32_t;
+typedef uint32_t flex_uint32_t;
+#else
+typedef signed char flex_int8_t;
+typedef short int flex_int16_t;
+typedef int flex_int32_t;
+typedef unsigned char flex_uint8_t; 
+typedef unsigned short int flex_uint16_t;
+typedef unsigned int flex_uint32_t;
+
+/* Limits of integral types. */
+#ifndef INT8_MIN
+#define INT8_MIN               (-128)
+#endif
+#ifndef INT16_MIN
+#define INT16_MIN              (-32767-1)
+#endif
+#ifndef INT32_MIN
+#define INT32_MIN              (-2147483647-1)
+#endif
+#ifndef INT8_MAX
+#define INT8_MAX               (127)
+#endif
+#ifndef INT16_MAX
+#define INT16_MAX              (32767)
+#endif
+#ifndef INT32_MAX
+#define INT32_MAX              (2147483647)
+#endif
+#ifndef UINT8_MAX
+#define UINT8_MAX              (255U)
+#endif
+#ifndef UINT16_MAX
+#define UINT16_MAX             (65535U)
+#endif
+#ifndef UINT32_MAX
+#define UINT32_MAX             (4294967295U)
+#endif
+
+#ifndef SIZE_MAX
+#define SIZE_MAX               (~(size_t)0)
+#endif
+
+#endif /* ! C99 */
+
+#endif /* ! FLEXINT_H */
+
+/* begin standard C++ headers. */
+
+/* TODO: this is always defined, so inline it */
+#define yyconst const
+
+#if defined(__GNUC__) && __GNUC__ >= 3
+#define yynoreturn __attribute__((__noreturn__))
+#else
+#define yynoreturn
+#endif
+
+/* Returned upon end-of-file. */
+#define YY_NULL 0
+
+/* Promotes a possibly negative, possibly signed char to an
+ *   integer in range [0..255] for use as an array index.
+ */
+#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
+
+/* An opaque pointer. */
+#ifndef YY_TYPEDEF_YY_SCANNER_T
+#define YY_TYPEDEF_YY_SCANNER_T
+typedef void* yyscan_t;
+#endif
+
+/* For convenience, these vars (plus the bison vars far below)
+   are macros in the reentrant scanner. */
+#define yyin yyg->yyin_r
+#define yyout yyg->yyout_r
+#define yyextra yyg->yyextra_r
+#define yyleng yyg->yyleng_r
+#define yytext yyg->yytext_r
+#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
+#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
+#define yy_flex_debug yyg->yy_flex_debug_r
+
+/* Enter a start condition.  This macro really ought to take a parameter,
+ * but we do it the disgusting crufty way forced on us by the ()-less
+ * definition of BEGIN.
+ */
+#define BEGIN yyg->yy_start = 1 + 2 *
+/* Translate the current start state into a value that can be later handed
+ * to BEGIN to return to the state.  The YYSTATE alias is for lex
+ * compatibility.
+ */
+#define YY_START ((yyg->yy_start - 1) / 2)
+#define YYSTATE YY_START
+/* Action number for EOF rule of a given start state. */
+#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
+/* Special action meaning "start processing a new file". */
+#define YY_NEW_FILE yyrestart( yyin , yyscanner )
+#define YY_END_OF_BUFFER_CHAR 0
+
+/* Size of default input buffer. */
+#ifndef YY_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k.
+ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
+ * Ditto for the __ia64__ case accordingly.
+ */
+#define YY_BUF_SIZE 32768
+#else
+#define YY_BUF_SIZE 16384
+#endif /* __ia64__ */
+#endif
+
+/* The state buf must be large enough to hold one state per character in the main buffer.
+ */
+#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
+
+#ifndef YY_TYPEDEF_YY_BUFFER_STATE
+#define YY_TYPEDEF_YY_BUFFER_STATE
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+#endif
+
+#ifndef YY_TYPEDEF_YY_SIZE_T
+#define YY_TYPEDEF_YY_SIZE_T
+typedef size_t yy_size_t;
+#endif
+
+#define EOB_ACT_CONTINUE_SCAN 0
+#define EOB_ACT_END_OF_FILE 1
+#define EOB_ACT_LAST_MATCH 2
+    
+    #define YY_LESS_LINENO(n)
+    #define YY_LINENO_REWIND_TO(ptr)
+    
+/* Return all but the first "n" matched characters back to the input stream. */
+#define yyless(n) \
+	do \
+		{ \
+		/* Undo effects of setting up yytext. */ \
+        int yyless_macro_arg = (n); \
+        YY_LESS_LINENO(yyless_macro_arg);\
+		*yy_cp = yyg->yy_hold_char; \
+		YY_RESTORE_YY_MORE_OFFSET \
+		yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
+		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
+		} \
+	while ( 0 )
+#define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
+
+#ifndef YY_STRUCT_YY_BUFFER_STATE
+#define YY_STRUCT_YY_BUFFER_STATE
+struct yy_buffer_state
+	{
+	FILE *yy_input_file;
+
+	char *yy_ch_buf;		/* input buffer */
+	char *yy_buf_pos;		/* current position in input buffer */
+
+	/* Size of input buffer in bytes, not including room for EOB
+	 * characters.
+	 */
+	int yy_buf_size;
+
+	/* Number of characters read into yy_ch_buf, not including EOB
+	 * characters.
+	 */
+	int yy_n_chars;
+
+	/* Whether we "own" the buffer - i.e., we know we created it,
+	 * and can realloc() it to grow it, and should free() it to
+	 * delete it.
+	 */
+	int yy_is_our_buffer;
+
+	/* Whether this is an "interactive" input source; if so, and
+	 * if we're using stdio for input, then we want to use getc()
+	 * instead of fread(), to make sure we stop fetching input after
+	 * each newline.
+	 */
+	int yy_is_interactive;
+
+	/* Whether we're considered to be at the beginning of a line.
+	 * If so, '^' rules will be active on the next match, otherwise
+	 * not.
+	 */
+	int yy_at_bol;
+
+    int yy_bs_lineno; /**< The line count. */
+    int yy_bs_column; /**< The column count. */
+
+	/* Whether to try to fill the input buffer when we reach the
+	 * end of it.
+	 */
+	int yy_fill_buffer;
+
+	int yy_buffer_status;
+
+#define YY_BUFFER_NEW 0
+#define YY_BUFFER_NORMAL 1
+	/* When an EOF's been seen but there's still some text to process
+	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
+	 * shouldn't try reading from the input source any more.  We might
+	 * still have a bunch of tokens to match, though, because of
+	 * possible backing-up.
+	 *
+	 * When we actually see the EOF, we change the status to "new"
+	 * (via yyrestart()), so that the user can continue scanning by
+	 * just pointing yyin at a new input file.
+	 */
+#define YY_BUFFER_EOF_PENDING 2
+
+	};
+#endif /* !YY_STRUCT_YY_BUFFER_STATE */
+
+/* We provide macros for accessing buffer states in case in the
+ * future we want to put the buffer states in a more general
+ * "scanner state".
+ *
+ * Returns the top of the stack, or NULL.
+ */
+#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
+                          ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
+                          : NULL)
+/* Same as previous macro, but useful when we know that the buffer stack is not
+ * NULL or when we need an lvalue. For internal use only.
+ */
+#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
+
+void yyrestart ( FILE *input_file , yyscan_t yyscanner );
+void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
+void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
+void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
+void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
+void yypop_buffer_state ( yyscan_t yyscanner );
+
+static void yyensure_buffer_stack ( yyscan_t yyscanner );
+static void yy_load_buffer_state ( yyscan_t yyscanner );
+static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file , yyscan_t yyscanner );
+#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER , yyscanner)
+
+YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner );
+
+void *yyalloc ( yy_size_t , yyscan_t yyscanner );
+void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
+void yyfree ( void * , yyscan_t yyscanner );
+
+#define yy_new_buffer yy_create_buffer
+#define yy_set_interactive(is_interactive) \
+	{ \
+	if ( ! YY_CURRENT_BUFFER ){ \
+        yyensure_buffer_stack (yyscanner); \
+		YY_CURRENT_BUFFER_LVALUE =    \
+            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
+	} \
+	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
+	}
+#define yy_set_bol(at_bol) \
+	{ \
+	if ( ! YY_CURRENT_BUFFER ){\
+        yyensure_buffer_stack (yyscanner); \
+		YY_CURRENT_BUFFER_LVALUE =    \
+            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
+	} \
+	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
+	}
+#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
+
+/* Begin user sect3 */
+
+#define yywrap(yyscanner) (/*CONSTCOND*/1)
+#define YY_SKIP_YYWRAP
+typedef flex_uint8_t YY_CHAR;
+
+typedef int yy_state_type;
+
+#define yytext_ptr yytext_r
+
+static yy_state_type yy_get_previous_state ( yyscan_t yyscanner );
+static yy_state_type yy_try_NUL_trans ( yy_state_type current_state  , yyscan_t yyscanner);
+static int yy_get_next_buffer ( yyscan_t yyscanner );
+static void yynoreturn yy_fatal_error ( const char* msg , yyscan_t yyscanner );
+
+/* Done after the current pattern has been matched and before the
+ * corresponding action - sets up yytext.
+ */
+#define YY_DO_BEFORE_ACTION \
+	yyg->yytext_ptr = yy_bp; \
+	yyleng = (int) (yy_cp - yy_bp); \
+	yyg->yy_hold_char = *yy_cp; \
+	*yy_cp = '\0'; \
+	yyg->yy_c_buf_p = yy_cp;
+#define YY_NUM_RULES 93
+#define YY_END_OF_BUFFER 94
+/* This struct is not used in this scanner,
+   but its presence is necessary. */
+struct yy_trans_info
+	{
+	flex_int32_t yy_verify;
+	flex_int32_t yy_nxt;
+	};
+static const flex_int16_t yy_accept[220] =
+    {   0,
+        0,    0,    0,    0,   94,   92,   91,   91,   19,   92,
+       92,   26,   35,   34,    9,   10,   24,   22,   16,   23,
+       15,   25,   88,   88,   18,   17,   41,   40,   42,   21,
+       90,   13,   14,   27,   90,   90,   90,   90,   90,   90,
+       90,   90,   90,   90,   90,   90,   90,   90,   90,   90,
+       11,   37,   12,   39,    6,    8,    5,    7,   91,   45,
+        0,   87,    0,   20,   53,   36,   56,    0,    0,    0,
+        0,   50,   88,   88,   51,    0,    2,    1,   52,   89,
+       88,    0,    0,   48,   43,   46,   47,   44,   49,   90,
+       54,   28,   61,   90,   90,   90,   90,   78,   90,   90,
+
+       90,   90,   90,   90,   71,   90,   90,   90,   90,   90,
+       90,   90,   90,   90,   90,   90,   90,   57,   38,    6,
+        5,    4,    3,   29,    0,    0,    0,    0,    0,   60,
+        1,    0,   89,    0,   89,   88,   88,   58,   59,   55,
+       90,   90,   90,   90,   90,   90,   90,   90,   76,   90,
+       90,   89,   79,   62,   90,   90,   90,   90,   90,   90,
+       90,   33,   31,    0,    0,    0,    0,    0,   90,   75,
+       90,   90,   90,   90,   73,   90,   83,   90,   72,   90,
+       90,   90,   90,   90,   66,   90,   90,   31,   32,   30,
+        0,   89,   85,   80,   90,   63,   90,   70,   90,   90,
+
+       90,   90,   90,   90,   90,   64,   77,   90,   84,   82,
+       67,   81,   69,   65,   74,   68,   90,   86,    0
+    } ;
+
+static const YY_CHAR yy_ec[256] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
+        2,    2,    2,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    2,    4,    5,    6,    1,    7,    8,    9,   10,
+       11,   12,   13,   14,   15,   16,   17,   18,   19,   20,
+       20,   20,   20,   20,   20,   20,   21,   22,   23,   24,
+       25,   26,    1,   27,   28,   28,   28,   28,   29,   30,
+       31,   31,   31,   31,   31,   31,   31,   31,   31,   32,
+       31,   31,   31,   31,   31,   31,   31,   33,   31,   31,
+       34,   35,   36,   37,   31,    1,   38,   39,   40,   41,
+
+       42,   43,   44,   45,   46,   31,   47,   48,   49,   50,
+       51,   52,   31,   53,   54,   55,   56,   31,   57,   58,
+       59,   60,   61,   62,   63,   64,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1
+    } ;
+
+static const YY_CHAR yy_meta[65] =
+    {   0,
+        1,    1,    2,    1,    1,    1,    1,    1,    3,    1,
+        1,    4,    1,    1,    1,    1,    4,    5,    5,    5,
+        5,    1,    1,    1,    1,    1,    1,    5,    5,    5,
+        6,    6,    6,    1,    1,    1,    1,    5,    5,    5,
+        5,    5,    5,    6,    6,    6,    6,    6,    6,    6,
+        6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
+        1,    1,    1,    1
+    } ;
+
+static const flex_int16_t yy_base[230] =
+    {   0,
+        0,    0,   62,   63,  363,  364,   65,   67,  337,   66,
+      355,  335,   64,  324,  364,  364,  364,   63,  364,   72,
+      342,   61,   84,   90,  364,  364,   52,   69,   73,  364,
+        0,  364,  364,   82,  303,  303,   74,   45,   66,  304,
+      303,   77,  297,  314,  295,  308,   75,  290,  298,  302,
+      364,   60,  364,  364,    0,  364,  101,  334,  126,  364,
+      126,  364,  342,  364,  364,  364,  364,  335,  115,  120,
+      127,  364,  139,  146,  364,  327,  364,    0,  364,  185,
+      161,    0,  131,  317,  364,  364,  364,  364,  316,    0,
+      364,  315,    0,  297,  284,  287,  293,    0,  281,  295,
+
+      277,  277,  278,  275,    0,  277,  285,  272,  276,  286,
+      269,  263,  269,  275,  268,  273,  272,  364,  364,    0,
+      139,  364,  364,  364,  308,  165,  177,  307,    0,  364,
+        0,  150,  169,  198,  364,  169,  157,  364,  364,  364,
+      277,  272,  137,  178,  271,  270,  262,  268,    0,  258,
+      257,    0,    0,    0,  251,  264,  249,  249,  261,  251,
+      253,  364,  364,  213,  216,  291,  177,  223,  252,    0,
+      243,  251,  243,  245,    0,  253,    0,  239,    0,  233,
+      227,  225,  234,  227,  189,  189,  195,  364,  364,  364,
+      227,  231,    0,    0,  180,    0,  184,    0,  173,  155,
+
+      158,  164,  147,  149,  150,    0,    0,  107,    0,    0,
+        0,    0,    0,    0,    0,    0,  110,    0,  364,  252,
+      258,  264,  266,  272,  278,  284,  139,  288,  132
+    } ;
+
+static const flex_int16_t yy_def[230] =
+    {   0,
+      219,    1,  220,  220,  219,  219,  219,  219,  219,  221,
+      219,  219,  219,  222,  219,  219,  219,  219,  219,  219,
+      219,  219,  219,  219,  219,  219,  219,  219,  219,  219,
+      223,  219,  219,  219,  223,  223,  223,  223,  223,  223,
+      223,  223,  223,  223,  223,  223,  223,  223,  223,  223,
+      219,  219,  219,  219,  224,  219,  219,  219,  219,  219,
+      221,  219,  221,  219,  219,  219,  219,  219,  225,  219,
+      219,  219,  219,  219,  219,  219,  219,  226,  219,  219,
+      219,  227,  219,  219,  219,  219,  219,  219,  219,  223,
+      219,  219,  223,  223,  223,  223,  223,  223,  223,  223,
+
+      223,  223,  223,  223,  223,  223,  223,  223,  223,  223,
+      223,  223,  223,  223,  223,  223,  223,  219,  219,  224,
+      219,  219,  219,  219,  219,  219,  219,  228,  229,  219,
+      226,  219,  219,  219,  219,  227,  219,  219,  219,  219,
+      223,  223,  223,  223,  223,  223,  223,  223,  223,  223,
+      223,  223,  223,  223,  223,  223,  223,  223,  223,  223,
+      223,  219,  219,  219,  219,  228,  229,  219,  223,  223,
+      223,  223,  223,  223,  223,  223,  223,  223,  223,  223,
+      223,  223,  223,  223,  223,  223,  223,  219,  219,  219,
+      219,  219,  223,  223,  223,  223,  223,  223,  223,  223,
+
+      223,  223,  223,  223,  223,  223,  223,  223,  223,  223,
+      223,  223,  223,  223,  223,  223,  223,  223,    0,  219,
+      219,  219,  219,  219,  219,  219,  219,  219,  219
+    } ;
+
+static const flex_int16_t yy_nxt[429] =
+    {   0,
+        6,    7,    8,    9,   10,   11,   12,   13,   14,   15,
+       16,   17,   18,   19,   20,   21,   22,   23,   24,   24,
+       24,   25,   26,   27,   28,   29,   30,   31,   31,   31,
+       31,   31,   31,   32,    6,   33,   34,   35,   36,   37,
+       38,   39,   40,   41,   31,   42,   31,   31,   43,   44,
+       31,   45,   46,   47,   48,   49,   50,   31,   31,   31,
+       51,   52,   53,   54,   56,   56,   59,   59,   59,   59,
+       62,   66,   77,   57,   57,   84,   85,   78,   58,   58,
+       70,   71,   71,   71,  118,   79,   97,   72,   67,   73,
+       74,   74,   74,   86,   87,   98,   75,   88,   89,   80,
+
+       63,   81,   81,   81,   74,   80,   91,   74,   74,   74,
+       74,   95,  121,   99,  100,  101,   82,  122,   92,  105,
+      112,  119,   83,  102,   96,  106,  107,   59,   59,  113,
+       62,  114,  126,  126,  126,   80,  167,   71,   71,   71,
+       71,   82,   80,  136,   71,   71,   71,   71,  137,  137,
+      121,  218,  129,  127,   80,  122,   74,   74,   74,   74,
+       63,   80,  217,   74,   74,   74,   74,  133,  133,  133,
+      133,  129,  128,  163,  137,  137,   80,  129,   81,   81,
+       81,   74,  164,  164,  164,  162,  133,  133,  133,  133,
+      171,  172,  216,  215,  165,  165,  129,  132,  135,  132,
+
+      168,  214,  133,  133,  133,  133,  213,  212,  168,  211,
+      132,  135,  132,  134,  135,  133,  133,  133,  133,  173,
+      168,  188,  210,  174,  189,  209,  134,  135,  168,  208,
+      164,  164,  164,  165,  165,  191,  207,  191,  206,  205,
+      192,  192,  192,  192,  192,  192,  192,  192,  192,  192,
+      192,  192,   55,   55,   55,   55,   55,   55,   61,   61,
+       61,   61,   61,   61,   68,   68,  204,   68,   68,   68,
+       90,   90,  120,  203,  120,  202,  120,  120,  125,  201,
+      125,  125,  125,  125,  131,  200,  131,  131,  131,  131,
+      166,  199,  166,  198,  197,  196,  195,  194,  193,  190,
+
+      187,  186,  185,  184,  183,  182,  181,  180,  179,  178,
+      177,  176,  175,  170,  169,  162,  162,  161,  160,  159,
+      158,  157,  156,  155,  154,  152,  153,  152,  151,  150,
+      149,  148,  147,  146,  145,  144,  143,  142,  141,  140,
+      139,  138,  130,  124,  219,  123,  117,  116,  115,  111,
+      110,  109,  108,  104,  103,   94,   93,   76,   69,   65,
+       64,   60,  219,    5,  219,  219,  219,  219,  219,  219,
+      219,  219,  219,  219,  219,  219,  219,  219,  219,  219,
+      219,  219,  219,  219,  219,  219,  219,  219,  219,  219,
+      219,  219,  219,  219,  219,  219,  219,  219,  219,  219,
+
+      219,  219,  219,  219,  219,  219,  219,  219,  219,  219,
+      219,  219,  219,  219,  219,  219,  219,  219,  219,  219,
+      219,  219,  219,  219,  219,  219,  219,  219
+    } ;
+
+static const flex_int16_t yy_chk[429] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    3,    4,    7,    7,    8,    8,
+       10,   13,   22,    3,    4,   27,   27,   22,    3,    4,
+       18,   18,   18,   18,   52,   22,   38,   18,   13,   20,
+       20,   20,   20,   28,   28,   38,   20,   29,   29,   23,
+
+       10,   23,   23,   23,   23,   24,   34,   24,   24,   24,
+       24,   37,   57,   39,   39,   39,   23,   57,   34,   42,
+       47,   52,   23,   39,   37,   42,   42,   59,   59,   47,
+       61,   47,   69,   69,   69,   70,  229,   70,   70,   70,
+       70,   23,   71,  227,   71,   71,   71,   71,   83,   83,
+      121,  217,   70,   69,   73,  121,   73,   73,   73,   73,
+       61,   74,  208,   74,   74,   74,   74,  132,  132,  132,
+      132,   73,   69,  126,  137,  137,   81,   70,   81,   81,
+       81,   81,  126,  126,  126,  127,  133,  133,  133,  133,
+      143,  143,  205,  204,  127,  127,   73,   80,  133,   80,
+
+      136,  203,   80,   80,   80,   80,  202,  201,  167,  200,
+      134,  133,  134,   80,   80,  134,  134,  134,  134,  144,
+      136,  164,  199,  144,  165,  197,   80,   80,  167,  195,
+      164,  164,  164,  165,  165,  168,  187,  168,  186,  185,
+      168,  168,  168,  168,  191,  191,  191,  191,  192,  192,
+      192,  192,  220,  220,  220,  220,  220,  220,  221,  221,
+      221,  221,  221,  221,  222,  222,  184,  222,  222,  222,
+      223,  223,  224,  183,  224,  182,  224,  224,  225,  181,
+      225,  225,  225,  225,  226,  180,  226,  226,  226,  226,
+      228,  178,  228,  176,  174,  173,  172,  171,  169,  166,
+
+      161,  160,  159,  158,  157,  156,  155,  151,  150,  148,
+      147,  146,  145,  142,  141,  128,  125,  117,  116,  115,
+      114,  113,  112,  111,  110,  109,  108,  107,  106,  104,
+      103,  102,  101,  100,   99,   97,   96,   95,   94,   92,
+       89,   84,   76,   68,   63,   58,   50,   49,   48,   46,
+       45,   44,   43,   41,   40,   36,   35,   21,   14,   12,
+       11,    9,    5,  219,  219,  219,  219,  219,  219,  219,
+      219,  219,  219,  219,  219,  219,  219,  219,  219,  219,
+      219,  219,  219,  219,  219,  219,  219,  219,  219,  219,
+      219,  219,  219,  219,  219,  219,  219,  219,  219,  219,
+
+      219,  219,  219,  219,  219,  219,  219,  219,  219,  219,
+      219,  219,  219,  219,  219,  219,  219,  219,  219,  219,
+      219,  219,  219,  219,  219,  219,  219,  219
+    } ;
+
+/* The intent behind this definition is that it'll catch
+ * any uses of REJECT which flex missed.
+ */
+#define REJECT reject_used_but_not_detected
+#define yymore() yymore_used_but_not_detected
+#define YY_MORE_ADJ 0
+#define YY_RESTORE_YY_MORE_OFFSET
+#line 1 "src/lexer.l"
+#define YY_NO_INPUT 1
+#line 3 "src/lexer.l"
+#define FROM_LEXER
+#include <cu/parser.h>
+#include <cu/debug.h>
+
+static void update_yylloc(struct parser *parser, YYLTYPE *lloc, const char *text)
+{
+	lloc->first_line = lloc->last_line;
+	lloc->first_column = lloc->last_column;
+
+	for (size_t i = 0; text[i] != 0; ++i) {
+		parser->buf_offset++;
+		if (text[i] == '\n') {
+			lloc->last_line++;
+			/* flex uses 1 based indexing */
+			lloc->last_column = 1;
+		} else {
+			lloc->last_column++;
+		}
+	}
+}
+
+#define YY_USER_ACTION update_yylloc(parser, yylloc, yytext);
+#line 615 "src/gen_lexer.c"
+
+#line 617 "src/gen_lexer.c"
+
+#define INITIAL 0
+#define SC_COMMENT 1
+
+#ifndef YY_NO_UNISTD_H
+/* Special case for "unistd.h", since it is non-ANSI. We include it way
+ * down here because we want the user's section 1 to have been scanned first.
+ * The user has a chance to override it with an option.
+ */
+#include <unistd.h>
+#endif
+
+#ifndef YY_EXTRA_TYPE
+#define YY_EXTRA_TYPE void *
+#endif
+
+/* Holds the entire state of the reentrant scanner. */
+struct yyguts_t
+    {
+
+    /* User-defined. Not touched by flex. */
+    YY_EXTRA_TYPE yyextra_r;
+
+    /* The rest are the same as the globals declared in the non-reentrant scanner. */
+    FILE *yyin_r, *yyout_r;
+    size_t yy_buffer_stack_top; /**< index of top of stack. */
+    size_t yy_buffer_stack_max; /**< capacity of stack. */
+    YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
+    char yy_hold_char;
+    int yy_n_chars;
+    int yyleng_r;
+    char *yy_c_buf_p;
+    int yy_init;
+    int yy_start;
+    int yy_did_buffer_switch_on_eof;
+    int yy_start_stack_ptr;
+    int yy_start_stack_depth;
+    int *yy_start_stack;
+    yy_state_type yy_last_accepting_state;
+    char* yy_last_accepting_cpos;
+
+    int yylineno_r;
+    int yy_flex_debug_r;
+
+    char *yytext_r;
+    int yy_more_flag;
+    int yy_more_len;
+
+    }; /* end struct yyguts_t */
+
+static int yy_init_globals ( yyscan_t yyscanner );
+
+int yylex_init (yyscan_t* scanner);
+
+int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);
+
+/* Accessor methods to globals.
+   These are made visible to non-reentrant scanners for convenience. */
+
+int yylex_destroy ( yyscan_t yyscanner );
+
+int yyget_debug ( yyscan_t yyscanner );
+
+void yyset_debug ( int debug_flag , yyscan_t yyscanner );
+
+YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );
+
+void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );
+
+FILE *yyget_in ( yyscan_t yyscanner );
+
+void yyset_in  ( FILE * _in_str , yyscan_t yyscanner );
+
+FILE *yyget_out ( yyscan_t yyscanner );
+
+void yyset_out  ( FILE * _out_str , yyscan_t yyscanner );
+
+			int yyget_leng ( yyscan_t yyscanner );
+
+char *yyget_text ( yyscan_t yyscanner );
+
+int yyget_lineno ( yyscan_t yyscanner );
+
+void yyset_lineno ( int _line_number , yyscan_t yyscanner );
+
+int yyget_column  ( yyscan_t yyscanner );
+
+void yyset_column ( int _column_no , yyscan_t yyscanner );
+
+/* Macros after this point can all be overridden by user definitions in
+ * section 1.
+ */
+
+#ifndef YY_SKIP_YYWRAP
+#ifdef __cplusplus
+extern "C" int yywrap ( yyscan_t yyscanner );
+#else
+extern int yywrap ( yyscan_t yyscanner );
+#endif
+#endif
+
+#ifndef YY_NO_UNPUT
+    
+#endif
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
+#endif
+
+#ifndef YY_NO_INPUT
+#ifdef __cplusplus
+static int yyinput ( yyscan_t yyscanner );
+#else
+static int input ( yyscan_t yyscanner );
+#endif
+
+#endif
+
+/* Amount of stuff to slurp up with each read. */
+#ifndef YY_READ_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k */
+#define YY_READ_BUF_SIZE 16384
+#else
+#define YY_READ_BUF_SIZE 8192
+#endif /* __ia64__ */
+#endif
+
+/* Copy whatever the last rule matched to the standard output. */
+#ifndef ECHO
+/* This used to be an fputs(), but since the string might contain NUL's,
+ * we now use fwrite().
+ */
+#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
+#endif
+
+/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
+ * is returned in "result".
+ */
+#ifndef YY_INPUT
+#define YY_INPUT(buf,result,max_size) \
+	if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
+		{ \
+		int c = '*'; \
+		int n; \
+		for ( n = 0; n < max_size && \
+			     (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
+			buf[n] = (char) c; \
+		if ( c == '\n' ) \
+			buf[n++] = (char) c; \
+		if ( c == EOF && ferror( yyin ) ) \
+			YY_FATAL_ERROR( "input in flex scanner failed" ); \
+		result = n; \
+		} \
+	else \
+		{ \
+		errno=0; \
+		while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
+			{ \
+			if( errno != EINTR) \
+				{ \
+				YY_FATAL_ERROR( "input in flex scanner failed" ); \
+				break; \
+				} \
+			errno=0; \
+			clearerr(yyin); \
+			} \
+		}\
+\
+
+#endif
+
+/* No semi-colon after return; correct usage is to write "yyterminate();" -
+ * we don't want an extra ';' after the "return" because that will cause
+ * some compilers to complain about unreachable statements.
+ */
+#ifndef yyterminate
+#define yyterminate() return YY_NULL
+#endif
+
+/* Number of entries by which start-condition stack grows. */
+#ifndef YY_START_STACK_INCR
+#define YY_START_STACK_INCR 25
+#endif
+
+/* Report a fatal error. */
+#ifndef YY_FATAL_ERROR
+#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
+#endif
+
+/* end tables serialization structures and prototypes */
+
+/* Default declaration of generated scanner - a define so the user can
+ * easily add parameters.
+ */
+#ifndef YY_DECL
+#define YY_DECL_IS_OURS 1
+
+extern int yylex (yyscan_t yyscanner);
+
+#define YY_DECL int yylex (yyscan_t yyscanner)
+#endif /* !YY_DECL */
+
+/* Code executed at the beginning of each rule, after yytext and yyleng
+ * have been set up.
+ */
+#ifndef YY_USER_ACTION
+#define YY_USER_ACTION
+#endif
+
+/* Code executed at the end of each rule. */
+#ifndef YY_BREAK
+#define YY_BREAK /*LINTED*/break;
+#endif
+
+#define YY_RULE_SETUP \
+	YY_USER_ACTION
+
+/** The main scanner function which does all the work.
+ */
+YY_DECL
+{
+	yy_state_type yy_current_state;
+	char *yy_cp, *yy_bp;
+	int yy_act;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	if ( !yyg->yy_init )
+		{
+		yyg->yy_init = 1;
+
+#ifdef YY_USER_INIT
+		YY_USER_INIT;
+#endif
+
+		if ( ! yyg->yy_start )
+			yyg->yy_start = 1;	/* first start state */
+
+		if ( ! yyin )
+			yyin = stdin;
+
+		if ( ! yyout )
+			yyout = stdout;
+
+		if ( ! YY_CURRENT_BUFFER ) {
+			yyensure_buffer_stack (yyscanner);
+			YY_CURRENT_BUFFER_LVALUE =
+				yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
+		}
+
+		yy_load_buffer_state( yyscanner );
+		}
+
+	{
+#line 44 "src/lexer.l"
+
+#line 878 "src/gen_lexer.c"
+
+	while ( /*CONSTCOND*/1 )		/* loops until end-of-file is reached */
+		{
+		yy_cp = yyg->yy_c_buf_p;
+
+		/* Support of yytext. */
+		*yy_cp = yyg->yy_hold_char;
+
+		/* yy_bp points to the position in yy_ch_buf of the start of
+		 * the current run.
+		 */
+		yy_bp = yy_cp;
+
+		yy_current_state = yyg->yy_start;
+yy_match:
+		do
+			{
+			YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
+			if ( yy_accept[yy_current_state] )
+				{
+				yyg->yy_last_accepting_state = yy_current_state;
+				yyg->yy_last_accepting_cpos = yy_cp;
+				}
+			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+				{
+				yy_current_state = (int) yy_def[yy_current_state];
+				if ( yy_current_state >= 220 )
+					yy_c = yy_meta[yy_c];
+				}
+			yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+			++yy_cp;
+			}
+		while ( yy_base[yy_current_state] != 364 );
+
+yy_find_action:
+		yy_act = yy_accept[yy_current_state];
+		if ( yy_act == 0 )
+			{ /* have to back up */
+			yy_cp = yyg->yy_last_accepting_cpos;
+			yy_current_state = yyg->yy_last_accepting_state;
+			yy_act = yy_accept[yy_current_state];
+			}
+
+		YY_DO_BEFORE_ACTION;
+
+do_action:	/* This label is used only to access EOF actions. */
+
+		switch ( yy_act )
+	{ /* beginning of action switch */
+			case 0: /* must back up */
+			/* undo the effects of YY_DO_BEFORE_ACTION */
+			*yy_cp = yyg->yy_hold_char;
+			yy_cp = yyg->yy_last_accepting_cpos;
+			yy_current_state = yyg->yy_last_accepting_state;
+			goto yy_find_action;
+
+case 1:
+YY_RULE_SETUP
+#line 45 "src/lexer.l"
+{/* skip line comments */}
+	YY_BREAK
+case 2:
+YY_RULE_SETUP
+#line 47 "src/lexer.l"
+{BEGIN(SC_COMMENT);}
+	YY_BREAK
+
+case 3:
+YY_RULE_SETUP
+#line 49 "src/lexer.l"
+{++parser->comment_nesting;}
+	YY_BREAK
+case 4:
+YY_RULE_SETUP
+#line 50 "src/lexer.l"
+{
+		if (parser->comment_nesting)
+			--parser->comment_nesting;
+		else
+			BEGIN(INITIAL);
+	}
+	YY_BREAK
+case 5:
+YY_RULE_SETUP
+#line 57 "src/lexer.l"
+{}
+	YY_BREAK
+case 6:
+YY_RULE_SETUP
+#line 58 "src/lexer.l"
+{}
+	YY_BREAK
+case 7:
+YY_RULE_SETUP
+#line 59 "src/lexer.l"
+{}
+	YY_BREAK
+case 8:
+/* rule 8 can match eol */
+YY_RULE_SETUP
+#line 60 "src/lexer.l"
+{}
+	YY_BREAK
+
+case 9:
+YY_RULE_SETUP
+#line 63 "src/lexer.l"
+{return LPAREN;}
+	YY_BREAK
+case 10:
+YY_RULE_SETUP
+#line 64 "src/lexer.l"
+{return RPAREN;}
+	YY_BREAK
+case 11:
+YY_RULE_SETUP
+#line 65 "src/lexer.l"
+{return LBRACE;}
+	YY_BREAK
+case 12:
+YY_RULE_SETUP
+#line 66 "src/lexer.l"
+{return RBRACE;}
+	YY_BREAK
+case 13:
+YY_RULE_SETUP
+#line 67 "src/lexer.l"
+{return LBRACKET;}
+	YY_BREAK
+case 14:
+YY_RULE_SETUP
+#line 68 "src/lexer.l"
+{return RBRACKET;}
+	YY_BREAK
+case 15:
+YY_RULE_SETUP
+#line 69 "src/lexer.l"
+{return DOT;}
+	YY_BREAK
+case 16:
+YY_RULE_SETUP
+#line 70 "src/lexer.l"
+{return COMMA;}
+	YY_BREAK
+case 17:
+YY_RULE_SETUP
+#line 71 "src/lexer.l"
+{return SEMICOLON;}
+	YY_BREAK
+case 18:
+YY_RULE_SETUP
+#line 72 "src/lexer.l"
+{return COLON;}
+	YY_BREAK
+case 19:
+YY_RULE_SETUP
+#line 73 "src/lexer.l"
+{return BANG;}
+	YY_BREAK
+case 20:
+YY_RULE_SETUP
+#line 74 "src/lexer.l"
+{return PASTE;}
+	YY_BREAK
+case 21:
+YY_RULE_SETUP
+#line 75 "src/lexer.l"
+{return AT;}
+	YY_BREAK
+case 22:
+YY_RULE_SETUP
+#line 77 "src/lexer.l"
+{return PLUS;}
+	YY_BREAK
+case 23:
+YY_RULE_SETUP
+#line 78 "src/lexer.l"
+{return MINUS;}
+	YY_BREAK
+case 24:
+YY_RULE_SETUP
+#line 79 "src/lexer.l"
+{return STAR;}
+	YY_BREAK
+case 25:
+YY_RULE_SETUP
+#line 80 "src/lexer.l"
+{return DIV;}
+	YY_BREAK
+case 26:
+YY_RULE_SETUP
+#line 81 "src/lexer.l"
+{return REM;}
+	YY_BREAK
+case 27:
+YY_RULE_SETUP
+#line 82 "src/lexer.l"
+{return XOR;}
+	YY_BREAK
+case 28:
+YY_RULE_SETUP
+#line 83 "src/lexer.l"
+{return POW;}
+	YY_BREAK
+case 29:
+/* rule 29 can match eol */
+YY_RULE_SETUP
+#line 85 "src/lexer.l"
+{
+	/* regular character constant, 'a' */
+	yylval->integer = yytext[1];
+	return INT;
+}
+	YY_BREAK
+case 30:
+YY_RULE_SETUP
+#line 91 "src/lexer.l"
+{
+	/* hex character constant, '\xef' */
+	/* handling is slightly different from C, here it's more or less just
+	 * another way to specify a hex integer */
+	yylval->integer = strtoll(yytext + 3, NULL, 16);
+	return INT;
+}
+	YY_BREAK
+case 31:
+YY_RULE_SETUP
+#line 99 "src/lexer.l"
+{
+	/* octal character constant, '\033' */
+	yylval->integer = strtoll(yytext + 2, NULL, 8);
+	return INT;
+}
+	YY_BREAK
+case 32:
+YY_RULE_SETUP
+#line 105 "src/lexer.l"
+{
+	/* binary character constant, '\b101' */
+	yylval->integer = strtoll(yytext + 3, NULL, 2);
+	return INT;
+}
+	YY_BREAK
+case 33:
+YY_RULE_SETUP
+#line 111 "src/lexer.l"
+{
+	/* escaped character constant */
+	yylval->integer = match_escape(yytext[2]);
+	return INT;
+}
+	YY_BREAK
+case 34:
+YY_RULE_SETUP
+#line 117 "src/lexer.l"
+{return SQUOTE;}
+	YY_BREAK
+case 35:
+YY_RULE_SETUP
+#line 119 "src/lexer.l"
+{return AND;}
+	YY_BREAK
+case 36:
+YY_RULE_SETUP
+#line 120 "src/lexer.l"
+{return LAND;}
+	YY_BREAK
+case 37:
+YY_RULE_SETUP
+#line 121 "src/lexer.l"
+{return OR;}
+	YY_BREAK
+case 38:
+YY_RULE_SETUP
+#line 122 "src/lexer.l"
+{return LOR;}
+	YY_BREAK
+case 39:
+YY_RULE_SETUP
+#line 124 "src/lexer.l"
+{return TILDE;}
+	YY_BREAK
+case 40:
+YY_RULE_SETUP
+#line 125 "src/lexer.l"
+{return TO;}
+	YY_BREAK
+case 41:
+YY_RULE_SETUP
+#line 126 "src/lexer.l"
+{return LT;}
+	YY_BREAK
+case 42:
+YY_RULE_SETUP
+#line 127 "src/lexer.l"
+{return GT;}
+	YY_BREAK
+case 43:
+YY_RULE_SETUP
+#line 128 "src/lexer.l"
+{return LE;}
+	YY_BREAK
+case 44:
+YY_RULE_SETUP
+#line 129 "src/lexer.l"
+{return GE;}
+	YY_BREAK
+case 45:
+YY_RULE_SETUP
+#line 130 "src/lexer.l"
+{return NE;}
+	YY_BREAK
+case 46:
+YY_RULE_SETUP
+#line 131 "src/lexer.l"
+{return EQ;}
+	YY_BREAK
+case 47:
+YY_RULE_SETUP
+#line 133 "src/lexer.l"
+{return FATARROW;}
+	YY_BREAK
+case 48:
+YY_RULE_SETUP
+#line 135 "src/lexer.l"
+{return LSHIFT;}
+	YY_BREAK
+case 49:
+YY_RULE_SETUP
+#line 136 "src/lexer.l"
+{return RSHIFT;}
+	YY_BREAK
+case 50:
+YY_RULE_SETUP
+#line 138 "src/lexer.l"
+{return PLUSSELF;}
+	YY_BREAK
+case 51:
+YY_RULE_SETUP
+#line 139 "src/lexer.l"
+{return MINUSSELF;}
+	YY_BREAK
+case 52:
+YY_RULE_SETUP
+#line 140 "src/lexer.l"
+{return DIVSELF;}
+	YY_BREAK
+case 53:
+YY_RULE_SETUP
+#line 141 "src/lexer.l"
+{return REMSELF;}
+	YY_BREAK
+case 54:
+YY_RULE_SETUP
+#line 142 "src/lexer.l"
+{return XORSELF;}
+	YY_BREAK
+case 55:
+YY_RULE_SETUP
+#line 143 "src/lexer.l"
+{return POWSELF;}
+	YY_BREAK
+case 56:
+YY_RULE_SETUP
+#line 144 "src/lexer.l"
+{return ORSELF;}
+	YY_BREAK
+case 57:
+YY_RULE_SETUP
+#line 145 "src/lexer.l"
+{return ORSELF;}
+	YY_BREAK
+case 58:
+YY_RULE_SETUP
+#line 146 "src/lexer.l"
+{return LSHIFTSELF;}
+	YY_BREAK
+case 59:
+YY_RULE_SETUP
+#line 147 "src/lexer.l"
+{return RSHIFTSELF;}
+	YY_BREAK
+case 60:
+YY_RULE_SETUP
+#line 148 "src/lexer.l"
+{return ELLIPSIS;}
+	YY_BREAK
+case 61:
+YY_RULE_SETUP
+#line 150 "src/lexer.l"
+{return AS;}
+	YY_BREAK
+case 62:
+YY_RULE_SETUP
+#line 151 "src/lexer.l"
+{return PUB;}
+	YY_BREAK
+case 63:
+YY_RULE_SETUP
+#line 152 "src/lexer.l"
+{return DEFER;}
+	YY_BREAK
+case 64:
+YY_RULE_SETUP
+#line 153 "src/lexer.l"
+{return UNION;}
+	YY_BREAK
+case 65:
+YY_RULE_SETUP
+#line 154 "src/lexer.l"
+{return STRUCT;}
+	YY_BREAK
+case 66:
+YY_RULE_SETUP
+#line 155 "src/lexer.l"
+{return TYPEDEF;}
+	YY_BREAK
+case 67:
+YY_RULE_SETUP
+#line 156 "src/lexer.l"
+{return IMPORT;}
+	YY_BREAK
+case 68:
+YY_RULE_SETUP
+#line 157 "src/lexer.l"
+{return TYPEOF;}
+	YY_BREAK
+case 69:
+YY_RULE_SETUP
+#line 158 "src/lexer.l"
+{return SIZEOF;}
+	YY_BREAK
+case 70:
+YY_RULE_SETUP
+#line 159 "src/lexer.l"
+{return EMBED;}
+	YY_BREAK
+case 71:
+YY_RULE_SETUP
+#line 160 "src/lexer.l"
+{return IF;}
+	YY_BREAK
+case 72:
+YY_RULE_SETUP
+#line 161 "src/lexer.l"
+{return GOTO;}
+	YY_BREAK
+case 73:
+YY_RULE_SETUP
+#line 162 "src/lexer.l"
+{return ELSE;}
+	YY_BREAK
+case 74:
+YY_RULE_SETUP
+#line 163 "src/lexer.l"
+{return SWITCH;}
+	YY_BREAK
+case 75:
+YY_RULE_SETUP
+#line 164 "src/lexer.l"
+{return CASE;}
+	YY_BREAK
+case 76:
+YY_RULE_SETUP
+#line 165 "src/lexer.l"
+{return FOR;}
+	YY_BREAK
+case 77:
+YY_RULE_SETUP
+#line 166 "src/lexer.l"
+{return WHILE;}
+	YY_BREAK
+case 78:
+YY_RULE_SETUP
+#line 167 "src/lexer.l"
+{return DO;}
+	YY_BREAK
+case 79:
+YY_RULE_SETUP
+#line 168 "src/lexer.l"
+{return MUT;}
+	YY_BREAK
+case 80:
+YY_RULE_SETUP
+#line 169 "src/lexer.l"
+{return CONST;}
+	YY_BREAK
+case 81:
+YY_RULE_SETUP
+#line 170 "src/lexer.l"
+{return RETURN;}
+	YY_BREAK
+case 82:
+YY_RULE_SETUP
+#line 171 "src/lexer.l"
+{return EXTERN;}
+	YY_BREAK
+case 83:
+YY_RULE_SETUP
+#line 172 "src/lexer.l"
+{return ENUM;}
+	YY_BREAK
+case 84:
+YY_RULE_SETUP
+#line 173 "src/lexer.l"
+{return DEFINE;}
+	YY_BREAK
+case 85:
+YY_RULE_SETUP
+#line 174 "src/lexer.l"
+{return BREAK;}
+	YY_BREAK
+case 86:
+YY_RULE_SETUP
+#line 175 "src/lexer.l"
+{return CONTINUE;}
+	YY_BREAK
+case 87:
+/* rule 87 can match eol */
+YY_RULE_SETUP
+#line 177 "src/lexer.l"
+{
+	/* seems risky, I know, but letting the parser choose when to allocate a
+	 * new string seems to help with syntax error cleanup */
+	yylval->str = yytext;
+	return STRING;
+}
+	YY_BREAK
+case 88:
+YY_RULE_SETUP
+#line 184 "src/lexer.l"
+{
+	yylval->integer = strtoll(yytext, 0, 0);
+	return INT;
+}
+	YY_BREAK
+case 89:
+YY_RULE_SETUP
+#line 189 "src/lexer.l"
+{
+	yylval->dbl = strtod(yytext, 0);
+	return FLOAT;
+}
+	YY_BREAK
+case 90:
+YY_RULE_SETUP
+#line 194 "src/lexer.l"
+{
+	yylval->str = yytext;
+	return ID;
+}
+	YY_BREAK
+case 91:
+/* rule 91 can match eol */
+YY_RULE_SETUP
+#line 200 "src/lexer.l"
+{/* skip whitespace */}
+	YY_BREAK
+case 92:
+YY_RULE_SETUP
+#line 202 "src/lexer.l"
+{
+	struct src_issue issue;
+	issue.level = SRC_ERROR;
+	issue.loc = to_src_loc(yylloc);
+	issue.fctx.fbuf = parser->buf;
+	issue.fctx.fname = parser->fname;
+	issue.offset = parser->buf_offset;
+	src_issue(issue, "Unexpected token: %s", yytext);
+	parser->failed = true;
+}
+	YY_BREAK
+case 93:
+YY_RULE_SETUP
+#line 212 "src/lexer.l"
+YY_FATAL_ERROR( "flex scanner jammed" );
+	YY_BREAK
+#line 1456 "src/gen_lexer.c"
+case YY_STATE_EOF(INITIAL):
+case YY_STATE_EOF(SC_COMMENT):
+	yyterminate();
+
+	case YY_END_OF_BUFFER:
+		{
+		/* Amount of text matched not including the EOB char. */
+		int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
+
+		/* Undo the effects of YY_DO_BEFORE_ACTION. */
+		*yy_cp = yyg->yy_hold_char;
+		YY_RESTORE_YY_MORE_OFFSET
+
+		if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
+			{
+			/* We're scanning a new file or input source.  It's
+			 * possible that this happened because the user
+			 * just pointed yyin at a new source and called
+			 * yylex().  If so, then we have to assure
+			 * consistency between YY_CURRENT_BUFFER and our
+			 * globals.  Here is the right place to do so, because
+			 * this is the first action (other than possibly a
+			 * back-up) that will match for the new input source.
+			 */
+			yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+			YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
+			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
+			}
+
+		/* Note that here we test for yy_c_buf_p "<=" to the position
+		 * of the first EOB in the buffer, since yy_c_buf_p will
+		 * already have been incremented past the NUL character
+		 * (since all states make transitions on EOB to the
+		 * end-of-buffer state).  Contrast this with the test
+		 * in input().
+		 */
+		if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
+			{ /* This was really a NUL. */
+			yy_state_type yy_next_state;
+
+			yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
+
+			yy_current_state = yy_get_previous_state( yyscanner );
+
+			/* Okay, we're now positioned to make the NUL
+			 * transition.  We couldn't have
+			 * yy_get_previous_state() go ahead and do it
+			 * for us because it doesn't know how to deal
+			 * with the possibility of jamming (and we don't
+			 * want to build jamming into it because then it
+			 * will run more slowly).
+			 */
+
+			yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
+
+			yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
+
+			if ( yy_next_state )
+				{
+				/* Consume the NUL. */
+				yy_cp = ++yyg->yy_c_buf_p;
+				yy_current_state = yy_next_state;
+				goto yy_match;
+				}
+
+			else
+				{
+				yy_cp = yyg->yy_c_buf_p;
+				goto yy_find_action;
+				}
+			}
+
+		else switch ( yy_get_next_buffer( yyscanner ) )
+			{
+			case EOB_ACT_END_OF_FILE:
+				{
+				yyg->yy_did_buffer_switch_on_eof = 0;
+
+				if ( yywrap( yyscanner ) )
+					{
+					/* Note: because we've taken care in
+					 * yy_get_next_buffer() to have set up
+					 * yytext, we can now set up
+					 * yy_c_buf_p so that if some total
+					 * hoser (like flex itself) wants to
+					 * call the scanner after we return the
+					 * YY_NULL, it'll still work - another
+					 * YY_NULL will get returned.
+					 */
+					yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
+
+					yy_act = YY_STATE_EOF(YY_START);
+					goto do_action;
+					}
+
+				else
+					{
+					if ( ! yyg->yy_did_buffer_switch_on_eof )
+						YY_NEW_FILE;
+					}
+				break;
+				}
+
+			case EOB_ACT_CONTINUE_SCAN:
+				yyg->yy_c_buf_p =
+					yyg->yytext_ptr + yy_amount_of_matched_text;
+
+				yy_current_state = yy_get_previous_state( yyscanner );
+
+				yy_cp = yyg->yy_c_buf_p;
+				yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
+				goto yy_match;
+
+			case EOB_ACT_LAST_MATCH:
+				yyg->yy_c_buf_p =
+				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
+
+				yy_current_state = yy_get_previous_state( yyscanner );
+
+				yy_cp = yyg->yy_c_buf_p;
+				yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
+				goto yy_find_action;
+			}
+		break;
+		}
+
+	default:
+		YY_FATAL_ERROR(
+			"fatal flex scanner internal error--no action found" );
+	} /* end of action switch */
+		} /* end of scanning one token */
+	} /* end of user's declarations */
+} /* end of yylex */
+
+/* yy_get_next_buffer - try to read in a new buffer
+ *
+ * Returns a code representing an action:
+ *	EOB_ACT_LAST_MATCH -
+ *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
+ *	EOB_ACT_END_OF_FILE - end of file
+ */
+static int yy_get_next_buffer (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
+	char *source = yyg->yytext_ptr;
+	int number_to_move, i;
+	int ret_val;
+
+	if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
+		YY_FATAL_ERROR(
+		"fatal flex scanner internal error--end of buffer missed" );
+
+	if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
+		{ /* Don't try to fill the buffer, so this is an EOF. */
+		if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
+			{
+			/* We matched a single character, the EOB, so
+			 * treat this as a final EOF.
+			 */
+			return EOB_ACT_END_OF_FILE;
+			}
+
+		else
+			{
+			/* We matched some text prior to the EOB, first
+			 * process it.
+			 */
+			return EOB_ACT_LAST_MATCH;
+			}
+		}
+
+	/* Try to read more data. */
+
+	/* First move last chars to start of buffer. */
+	number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1);
+
+	for ( i = 0; i < number_to_move; ++i )
+		*(dest++) = *(source++);
+
+	if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
+		/* don't do the read, it's not guaranteed to return an EOF,
+		 * just force an EOF
+		 */
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
+
+	else
+		{
+			int num_to_read =
+			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
+
+		while ( num_to_read <= 0 )
+			{ /* Not enough room in the buffer - grow it. */
+
+			/* just a shorter name for the current buffer */
+			YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
+
+			int yy_c_buf_p_offset =
+				(int) (yyg->yy_c_buf_p - b->yy_ch_buf);
+
+			if ( b->yy_is_our_buffer )
+				{
+				int new_size = b->yy_buf_size * 2;
+
+				if ( new_size <= 0 )
+					b->yy_buf_size += b->yy_buf_size / 8;
+				else
+					b->yy_buf_size *= 2;
+
+				b->yy_ch_buf = (char *)
+					/* Include room in for 2 EOB chars. */
+					yyrealloc( (void *) b->yy_ch_buf,
+							 (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
+				}
+			else
+				/* Can't grow it, we don't own it. */
+				b->yy_ch_buf = NULL;
+
+			if ( ! b->yy_ch_buf )
+				YY_FATAL_ERROR(
+				"fatal error - scanner input buffer overflow" );
+
+			yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
+
+			num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
+						number_to_move - 1;
+
+			}
+
+		if ( num_to_read > YY_READ_BUF_SIZE )
+			num_to_read = YY_READ_BUF_SIZE;
+
+		/* Read in more data. */
+		YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
+			yyg->yy_n_chars, num_to_read );
+
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
+		}
+
+	if ( yyg->yy_n_chars == 0 )
+		{
+		if ( number_to_move == YY_MORE_ADJ )
+			{
+			ret_val = EOB_ACT_END_OF_FILE;
+			yyrestart( yyin  , yyscanner);
+			}
+
+		else
+			{
+			ret_val = EOB_ACT_LAST_MATCH;
+			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
+				YY_BUFFER_EOF_PENDING;
+			}
+		}
+
+	else
+		ret_val = EOB_ACT_CONTINUE_SCAN;
+
+	if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
+		/* Extend the array by 50%, plus the number we really need. */
+		int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
+		YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
+			(void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner );
+		if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
+			YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
+		/* "- 2" to take care of EOB's */
+		YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
+	}
+
+	yyg->yy_n_chars += number_to_move;
+	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
+	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
+
+	yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
+
+	return ret_val;
+}
+
+/* yy_get_previous_state - get the state just before the EOB char was reached */
+
+    static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
+{
+	yy_state_type yy_current_state;
+	char *yy_cp;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	yy_current_state = yyg->yy_start;
+
+	for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
+		{
+		YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
+		if ( yy_accept[yy_current_state] )
+			{
+			yyg->yy_last_accepting_state = yy_current_state;
+			yyg->yy_last_accepting_cpos = yy_cp;
+			}
+		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+			{
+			yy_current_state = (int) yy_def[yy_current_state];
+			if ( yy_current_state >= 220 )
+				yy_c = yy_meta[yy_c];
+			}
+		yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+		}
+
+	return yy_current_state;
+}
+
+/* yy_try_NUL_trans - try to make a transition on the NUL character
+ *
+ * synopsis
+ *	next_state = yy_try_NUL_trans( current_state );
+ */
+    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state , yyscan_t yyscanner)
+{
+	int yy_is_jam;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
+	char *yy_cp = yyg->yy_c_buf_p;
+
+	YY_CHAR yy_c = 1;
+	if ( yy_accept[yy_current_state] )
+		{
+		yyg->yy_last_accepting_state = yy_current_state;
+		yyg->yy_last_accepting_cpos = yy_cp;
+		}
+	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+		{
+		yy_current_state = (int) yy_def[yy_current_state];
+		if ( yy_current_state >= 220 )
+			yy_c = yy_meta[yy_c];
+		}
+	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+	yy_is_jam = (yy_current_state == 219);
+
+	(void)yyg;
+	return yy_is_jam ? 0 : yy_current_state;
+}
+
+#ifndef YY_NO_UNPUT
+
+#endif
+
+#ifndef YY_NO_INPUT
+#ifdef __cplusplus
+    static int yyinput (yyscan_t yyscanner)
+#else
+    static int input  (yyscan_t yyscanner)
+#endif
+
+{
+	int c;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	*yyg->yy_c_buf_p = yyg->yy_hold_char;
+
+	if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
+		{
+		/* yy_c_buf_p now points to the character we want to return.
+		 * If this occurs *before* the EOB characters, then it's a
+		 * valid NUL; if not, then we've hit the end of the buffer.
+		 */
+		if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
+			/* This was really a NUL. */
+			*yyg->yy_c_buf_p = '\0';
+
+		else
+			{ /* need more input */
+			int offset = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr);
+			++yyg->yy_c_buf_p;
+
+			switch ( yy_get_next_buffer( yyscanner ) )
+				{
+				case EOB_ACT_LAST_MATCH:
+					/* This happens because yy_g_n_b()
+					 * sees that we've accumulated a
+					 * token and flags that we need to
+					 * try matching the token before
+					 * proceeding.  But for input(),
+					 * there's no matching to consider.
+					 * So convert the EOB_ACT_LAST_MATCH
+					 * to EOB_ACT_END_OF_FILE.
+					 */
+
+					/* Reset buffer status. */
+					yyrestart( yyin , yyscanner);
+
+					/*FALLTHROUGH*/
+
+				case EOB_ACT_END_OF_FILE:
+					{
+					if ( yywrap( yyscanner ) )
+						return 0;
+
+					if ( ! yyg->yy_did_buffer_switch_on_eof )
+						YY_NEW_FILE;
+#ifdef __cplusplus
+					return yyinput(yyscanner);
+#else
+					return input(yyscanner);
+#endif
+					}
+
+				case EOB_ACT_CONTINUE_SCAN:
+					yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
+					break;
+				}
+			}
+		}
+
+	c = *(unsigned char *) yyg->yy_c_buf_p;	/* cast for 8-bit char's */
+	*yyg->yy_c_buf_p = '\0';	/* preserve yytext */
+	yyg->yy_hold_char = *++yyg->yy_c_buf_p;
+
+	return c;
+}
+#endif	/* ifndef YY_NO_INPUT */
+
+/** Immediately switch to a different input stream.
+ * @param input_file A readable stream.
+ * @param yyscanner The scanner object.
+ * @note This function does not reset the start condition to @c INITIAL .
+ */
+    void yyrestart  (FILE * input_file , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	if ( ! YY_CURRENT_BUFFER ){
+        yyensure_buffer_stack (yyscanner);
+		YY_CURRENT_BUFFER_LVALUE =
+            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
+	}
+
+	yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
+	yy_load_buffer_state( yyscanner );
+}
+
+/** Switch to a different input buffer.
+ * @param new_buffer The new input buffer.
+ * @param yyscanner The scanner object.
+ */
+    void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	/* TODO. We should be able to replace this entire function body
+	 * with
+	 *		yypop_buffer_state();
+	 *		yypush_buffer_state(new_buffer);
+     */
+	yyensure_buffer_stack (yyscanner);
+	if ( YY_CURRENT_BUFFER == new_buffer )
+		return;
+
+	if ( YY_CURRENT_BUFFER )
+		{
+		/* Flush out information for old buffer. */
+		*yyg->yy_c_buf_p = yyg->yy_hold_char;
+		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
+		}
+
+	YY_CURRENT_BUFFER_LVALUE = new_buffer;
+	yy_load_buffer_state( yyscanner );
+
+	/* We don't actually know whether we did this switch during
+	 * EOF (yywrap()) processing, but the only time this flag
+	 * is looked at is after yywrap() is called, so it's safe
+	 * to go ahead and always set it.
+	 */
+	yyg->yy_did_buffer_switch_on_eof = 1;
+}
+
+static void yy_load_buffer_state  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+	yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
+	yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
+	yyg->yy_hold_char = *yyg->yy_c_buf_p;
+}
+
+/** Allocate and initialize an input buffer state.
+ * @param file A readable stream.
+ * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
+ * @param yyscanner The scanner object.
+ * @return the allocated buffer state.
+ */
+    YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size , yyscan_t yyscanner)
+{
+	YY_BUFFER_STATE b;
+    
+	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
+	if ( ! b )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+	b->yy_buf_size = size;
+
+	/* yy_ch_buf has to be 2 characters longer than the size given because
+	 * we need to put in 2 end-of-buffer characters.
+	 */
+	b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
+	if ( ! b->yy_ch_buf )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+	b->yy_is_our_buffer = 1;
+
+	yy_init_buffer( b, file , yyscanner);
+
+	return b;
+}
+
+/** Destroy the buffer.
+ * @param b a buffer created with yy_create_buffer()
+ * @param yyscanner The scanner object.
+ */
+    void yy_delete_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	if ( ! b )
+		return;
+
+	if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
+		YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
+
+	if ( b->yy_is_our_buffer )
+		yyfree( (void *) b->yy_ch_buf , yyscanner );
+
+	yyfree( (void *) b , yyscanner );
+}
+
+/* Initializes or reinitializes a buffer.
+ * This function is sometimes called more than once on the same buffer,
+ * such as during a yyrestart() or at EOF.
+ */
+    static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file , yyscan_t yyscanner)
+
+{
+	int oerrno = errno;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	yy_flush_buffer( b , yyscanner);
+
+	b->yy_input_file = file;
+	b->yy_fill_buffer = 1;
+
+    /* If b is the current buffer, then yy_init_buffer was _probably_
+     * called from yyrestart() or through yy_get_next_buffer.
+     * In that case, we don't want to reset the lineno or column.
+     */
+    if (b != YY_CURRENT_BUFFER){
+        b->yy_bs_lineno = 1;
+        b->yy_bs_column = 0;
+    }
+
+        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
+    
+	errno = oerrno;
+}
+
+/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
+ * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
+ * @param yyscanner The scanner object.
+ */
+    void yy_flush_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	if ( ! b )
+		return;
+
+	b->yy_n_chars = 0;
+
+	/* We always need two end-of-buffer characters.  The first causes
+	 * a transition to the end-of-buffer state.  The second causes
+	 * a jam in that state.
+	 */
+	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
+	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
+
+	b->yy_buf_pos = &b->yy_ch_buf[0];
+
+	b->yy_at_bol = 1;
+	b->yy_buffer_status = YY_BUFFER_NEW;
+
+	if ( b == YY_CURRENT_BUFFER )
+		yy_load_buffer_state( yyscanner );
+}
+
+/** Pushes the new state onto the stack. The new state becomes
+ *  the current state. This function will allocate the stack
+ *  if necessary.
+ *  @param new_buffer The new state.
+ *  @param yyscanner The scanner object.
+ */
+void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	if (new_buffer == NULL)
+		return;
+
+	yyensure_buffer_stack(yyscanner);
+
+	/* This block is copied from yy_switch_to_buffer. */
+	if ( YY_CURRENT_BUFFER )
+		{
+		/* Flush out information for old buffer. */
+		*yyg->yy_c_buf_p = yyg->yy_hold_char;
+		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
+		}
+
+	/* Only push if top exists. Otherwise, replace top. */
+	if (YY_CURRENT_BUFFER)
+		yyg->yy_buffer_stack_top++;
+	YY_CURRENT_BUFFER_LVALUE = new_buffer;
+
+	/* copied from yy_switch_to_buffer. */
+	yy_load_buffer_state( yyscanner );
+	yyg->yy_did_buffer_switch_on_eof = 1;
+}
+
+/** Removes and deletes the top of the stack, if present.
+ *  The next element becomes the new top.
+ *  @param yyscanner The scanner object.
+ */
+void yypop_buffer_state (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	if (!YY_CURRENT_BUFFER)
+		return;
+
+	yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner);
+	YY_CURRENT_BUFFER_LVALUE = NULL;
+	if (yyg->yy_buffer_stack_top > 0)
+		--yyg->yy_buffer_stack_top;
+
+	if (YY_CURRENT_BUFFER) {
+		yy_load_buffer_state( yyscanner );
+		yyg->yy_did_buffer_switch_on_eof = 1;
+	}
+}
+
+/* Allocates the stack if it does not exist.
+ *  Guarantees space for at least one push.
+ */
+static void yyensure_buffer_stack (yyscan_t yyscanner)
+{
+	yy_size_t num_to_alloc;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	if (!yyg->yy_buffer_stack) {
+
+		/* First allocation is just for 2 elements, since we don't know if this
+		 * scanner will even need a stack. We use 2 instead of 1 to avoid an
+		 * immediate realloc on the next call.
+         */
+      num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
+		yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
+								(num_to_alloc * sizeof(struct yy_buffer_state*)
+								, yyscanner);
+		if ( ! yyg->yy_buffer_stack )
+			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
+
+		memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
+
+		yyg->yy_buffer_stack_max = num_to_alloc;
+		yyg->yy_buffer_stack_top = 0;
+		return;
+	}
+
+	if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
+
+		/* Increase the buffer to prepare for a possible push. */
+		yy_size_t grow_size = 8 /* arbitrary grow size */;
+
+		num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
+		yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc
+								(yyg->yy_buffer_stack,
+								num_to_alloc * sizeof(struct yy_buffer_state*)
+								, yyscanner);
+		if ( ! yyg->yy_buffer_stack )
+			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
+
+		/* zero only the new slots.*/
+		memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
+		yyg->yy_buffer_stack_max = num_to_alloc;
+	}
+}
+
+/** Setup the input buffer state to scan directly from a user-specified character buffer.
+ * @param base the character buffer
+ * @param size the size in bytes of the character buffer
+ * @param yyscanner The scanner object.
+ * @return the newly allocated buffer state object.
+ */
+YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscanner)
+{
+	YY_BUFFER_STATE b;
+    
+	if ( size < 2 ||
+	     base[size-2] != YY_END_OF_BUFFER_CHAR ||
+	     base[size-1] != YY_END_OF_BUFFER_CHAR )
+		/* They forgot to leave room for the EOB's. */
+		return NULL;
+
+	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
+	if ( ! b )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
+
+	b->yy_buf_size = (int) (size - 2);	/* "- 2" to take care of EOB's */
+	b->yy_buf_pos = b->yy_ch_buf = base;
+	b->yy_is_our_buffer = 0;
+	b->yy_input_file = NULL;
+	b->yy_n_chars = b->yy_buf_size;
+	b->yy_is_interactive = 0;
+	b->yy_at_bol = 1;
+	b->yy_fill_buffer = 0;
+	b->yy_buffer_status = YY_BUFFER_NEW;
+
+	yy_switch_to_buffer( b , yyscanner );
+
+	return b;
+}
+
+/** Setup the input buffer state to scan a string. The next call to yylex() will
+ * scan from a @e copy of @a str.
+ * @param yystr a NUL-terminated string to scan
+ * @param yyscanner The scanner object.
+ * @return the newly allocated buffer state object.
+ * @note If you want to scan bytes that may contain NUL values, then use
+ *       yy_scan_bytes() instead.
+ */
+YY_BUFFER_STATE yy_scan_string (const char * yystr , yyscan_t yyscanner)
+{
+    
+	return yy_scan_bytes( yystr, (int) strlen(yystr) , yyscanner);
+}
+
+/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
+ * scan from a @e copy of @a bytes.
+ * @param yybytes the byte buffer to scan
+ * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
+ * @param yyscanner The scanner object.
+ * @return the newly allocated buffer state object.
+ */
+YY_BUFFER_STATE yy_scan_bytes  (const char * yybytes, int  _yybytes_len , yyscan_t yyscanner)
+{
+	YY_BUFFER_STATE b;
+	char *buf;
+	yy_size_t n;
+	int i;
+    
+	/* Get memory for full buffer, including space for trailing EOB's. */
+	n = (yy_size_t) (_yybytes_len + 2);
+	buf = (char *) yyalloc( n , yyscanner );
+	if ( ! buf )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
+
+	for ( i = 0; i < _yybytes_len; ++i )
+		buf[i] = yybytes[i];
+
+	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
+
+	b = yy_scan_buffer( buf, n , yyscanner);
+	if ( ! b )
+		YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
+
+	/* It's okay to grow etc. this buffer, and we should throw it
+	 * away when we're done.
+	 */
+	b->yy_is_our_buffer = 1;
+
+	return b;
+}
+
+#ifndef YY_EXIT_FAILURE
+#define YY_EXIT_FAILURE 2
+#endif
+
+static void yynoreturn yy_fatal_error (const char* msg , yyscan_t yyscanner)
+{
+	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	(void)yyg;
+	fprintf( stderr, "%s\n", msg );
+	exit( YY_EXIT_FAILURE );
+}
+
+/* Redefine yyless() so it works in section 3 code. */
+
+#undef yyless
+#define yyless(n) \
+	do \
+		{ \
+		/* Undo effects of setting up yytext. */ \
+        int yyless_macro_arg = (n); \
+        YY_LESS_LINENO(yyless_macro_arg);\
+		yytext[yyleng] = yyg->yy_hold_char; \
+		yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
+		yyg->yy_hold_char = *yyg->yy_c_buf_p; \
+		*yyg->yy_c_buf_p = '\0'; \
+		yyleng = yyless_macro_arg; \
+		} \
+	while ( 0 )
+
+/* Accessor  methods (get/set functions) to struct members. */
+
+/** Get the user-defined data for this scanner.
+ * @param yyscanner The scanner object.
+ */
+YY_EXTRA_TYPE yyget_extra  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yyextra;
+}
+
+/** Get the current line number.
+ * @param yyscanner The scanner object.
+ */
+int yyget_lineno  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+        if (! YY_CURRENT_BUFFER)
+            return 0;
+    
+    return yylineno;
+}
+
+/** Get the current column number.
+ * @param yyscanner The scanner object.
+ */
+int yyget_column  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+        if (! YY_CURRENT_BUFFER)
+            return 0;
+    
+    return yycolumn;
+}
+
+/** Get the input stream.
+ * @param yyscanner The scanner object.
+ */
+FILE *yyget_in  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yyin;
+}
+
+/** Get the output stream.
+ * @param yyscanner The scanner object.
+ */
+FILE *yyget_out  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yyout;
+}
+
+/** Get the length of the current token.
+ * @param yyscanner The scanner object.
+ */
+int yyget_leng  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yyleng;
+}
+
+/** Get the current token.
+ * @param yyscanner The scanner object.
+ */
+
+char *yyget_text  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yytext;
+}
+
+/** Set the user-defined data. This data is never touched by the scanner.
+ * @param user_defined The data to be associated with this scanner.
+ * @param yyscanner The scanner object.
+ */
+void yyset_extra (YY_EXTRA_TYPE  user_defined , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    yyextra = user_defined ;
+}
+
+/** Set the current line number.
+ * @param _line_number line number
+ * @param yyscanner The scanner object.
+ */
+void yyset_lineno (int  _line_number , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+        /* lineno is only valid if an input buffer exists. */
+        if (! YY_CURRENT_BUFFER )
+           YY_FATAL_ERROR( "yyset_lineno called with no buffer" );
+    
+    yylineno = _line_number;
+}
+
+/** Set the current column.
+ * @param _column_no column number
+ * @param yyscanner The scanner object.
+ */
+void yyset_column (int  _column_no , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+        /* column is only valid if an input buffer exists. */
+        if (! YY_CURRENT_BUFFER )
+           YY_FATAL_ERROR( "yyset_column called with no buffer" );
+    
+    yycolumn = _column_no;
+}
+
+/** Set the input stream. This does not discard the current
+ * input buffer.
+ * @param _in_str A readable stream.
+ * @param yyscanner The scanner object.
+ * @see yy_switch_to_buffer
+ */
+void yyset_in (FILE *  _in_str , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    yyin = _in_str ;
+}
+
+void yyset_out (FILE *  _out_str , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    yyout = _out_str ;
+}
+
+int yyget_debug  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yy_flex_debug;
+}
+
+void yyset_debug (int  _bdebug , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    yy_flex_debug = _bdebug ;
+}
+
+/* Accessor methods for yylval and yylloc */
+
+/* User-visible API */
+
+/* yylex_init is special because it creates the scanner itself, so it is
+ * the ONLY reentrant function that doesn't take the scanner as the last argument.
+ * That's why we explicitly handle the declaration, instead of using our macros.
+ */
+int yylex_init(yyscan_t* ptr_yy_globals)
+{
+    if (ptr_yy_globals == NULL){
+        errno = EINVAL;
+        return 1;
+    }
+
+    *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );
+
+    if (*ptr_yy_globals == NULL){
+        errno = ENOMEM;
+        return 1;
+    }
+
+    /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
+    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
+
+    return yy_init_globals ( *ptr_yy_globals );
+}
+
+/* yylex_init_extra has the same functionality as yylex_init, but follows the
+ * convention of taking the scanner as the last argument. Note however, that
+ * this is a *pointer* to a scanner, as it will be allocated by this call (and
+ * is the reason, too, why this function also must handle its own declaration).
+ * The user defined value in the first argument will be available to yyalloc in
+ * the yyextra field.
+ */
+int yylex_init_extra( YY_EXTRA_TYPE yy_user_defined, yyscan_t* ptr_yy_globals )
+{
+    struct yyguts_t dummy_yyguts;
+
+    yyset_extra (yy_user_defined, &dummy_yyguts);
+
+    if (ptr_yy_globals == NULL){
+        errno = EINVAL;
+        return 1;
+    }
+
+    *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
+
+    if (*ptr_yy_globals == NULL){
+        errno = ENOMEM;
+        return 1;
+    }
+
+    /* By setting to 0xAA, we expose bugs in
+    yy_init_globals. Leave at 0x00 for releases. */
+    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
+
+    yyset_extra (yy_user_defined, *ptr_yy_globals);
+
+    return yy_init_globals ( *ptr_yy_globals );
+}
+
+static int yy_init_globals (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    /* Initialization is the same as for the non-reentrant scanner.
+     * This function is called from yylex_destroy(), so don't allocate here.
+     */
+
+    yyg->yy_buffer_stack = NULL;
+    yyg->yy_buffer_stack_top = 0;
+    yyg->yy_buffer_stack_max = 0;
+    yyg->yy_c_buf_p = NULL;
+    yyg->yy_init = 0;
+    yyg->yy_start = 0;
+
+    yyg->yy_start_stack_ptr = 0;
+    yyg->yy_start_stack_depth = 0;
+    yyg->yy_start_stack =  NULL;
+
+/* Defined in main.c */
+#ifdef YY_STDINIT
+    yyin = stdin;
+    yyout = stdout;
+#else
+    yyin = NULL;
+    yyout = NULL;
+#endif
+
+    /* For future reference: Set errno on error, since we are called by
+     * yylex_init()
+     */
+    return 0;
+}
+
+/* yylex_destroy is for both reentrant and non-reentrant scanners. */
+int yylex_destroy  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+    /* Pop the buffer stack, destroying each element. */
+	while(YY_CURRENT_BUFFER){
+		yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
+		YY_CURRENT_BUFFER_LVALUE = NULL;
+		yypop_buffer_state(yyscanner);
+	}
+
+	/* Destroy the stack itself. */
+	yyfree(yyg->yy_buffer_stack , yyscanner);
+	yyg->yy_buffer_stack = NULL;
+
+    /* Destroy the start condition stack. */
+        yyfree( yyg->yy_start_stack , yyscanner );
+        yyg->yy_start_stack = NULL;
+
+    /* Reset the globals. This is important in a non-reentrant scanner so the next time
+     * yylex() is called, initialization will occur. */
+    yy_init_globals( yyscanner);
+
+    /* Destroy the main struct (reentrant only). */
+    yyfree ( yyscanner , yyscanner );
+    yyscanner = NULL;
+    return 0;
+}
+
+/*
+ * Internal utility routines.
+ */
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy (char* s1, const char * s2, int n , yyscan_t yyscanner)
+{
+	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	(void)yyg;
+
+	int i;
+	for ( i = 0; i < n; ++i )
+		s1[i] = s2[i];
+}
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen (const char * s , yyscan_t yyscanner)
+{
+	int n;
+	for ( n = 0; s[n]; ++n )
+		;
+
+	return n;
+}
+#endif
+
+void *yyalloc (yy_size_t  size , yyscan_t yyscanner)
+{
+	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	(void)yyg;
+	return malloc(size);
+}
+
+void *yyrealloc  (void * ptr, yy_size_t  size , yyscan_t yyscanner)
+{
+	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	(void)yyg;
+
+	/* The cast to (char *) in the following accommodates both
+	 * implementations that use char* generic pointers, and those
+	 * that use void* generic pointers.  It works with the latter
+	 * because both ANSI C and C++ allow castless assignment from
+	 * any pointer type to void*, and deal with argument conversions
+	 * as though doing an assignment.
+	 */
+	return realloc(ptr, size);
+}
+
+void yyfree (void * ptr , yyscan_t yyscanner)
+{
+	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	(void)yyg;
+	free( (char *) ptr );	/* see yyrealloc() for (char *) cast */
+}
+
+#define YYTABLES_NAME "yytables"
+
+#line 212 "src/lexer.l"
+
+
diff --git a/src/gen_lexer.h b/src/gen_lexer.h
new file mode 100644
index 0000000..e9288de
--- /dev/null
+++ b/src/gen_lexer.h
@@ -0,0 +1,493 @@
+#ifndef yyHEADER_H
+#define yyHEADER_H 1
+#define yyIN_HEADER 1
+
+#line 6 "src/gen_lexer.h"
+
+#line 8 "src/gen_lexer.h"
+
+#define  YY_INT_ALIGNED short int
+
+/* A lexical scanner generated by flex */
+
+#define FLEX_SCANNER
+#define YY_FLEX_MAJOR_VERSION 2
+#define YY_FLEX_MINOR_VERSION 6
+#define YY_FLEX_SUBMINOR_VERSION 4
+#if YY_FLEX_SUBMINOR_VERSION > 0
+#define FLEX_BETA
+#endif
+
+/* First, we deal with  platform-specific or compiler-specific issues. */
+
+/* begin standard C headers. */
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <stdlib.h>
+
+/* end standard C headers. */
+
+/* flex integer type definitions */
+
+#ifndef FLEXINT_H
+#define FLEXINT_H
+
+/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
+
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+
+/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
+ * if you want the limit (max/min) macros for int types. 
+ */
+#ifndef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS 1
+#endif
+
+#include <inttypes.h>
+typedef int8_t flex_int8_t;
+typedef uint8_t flex_uint8_t;
+typedef int16_t flex_int16_t;
+typedef uint16_t flex_uint16_t;
+typedef int32_t flex_int32_t;
+typedef uint32_t flex_uint32_t;
+#else
+typedef signed char flex_int8_t;
+typedef short int flex_int16_t;
+typedef int flex_int32_t;
+typedef unsigned char flex_uint8_t; 
+typedef unsigned short int flex_uint16_t;
+typedef unsigned int flex_uint32_t;
+
+/* Limits of integral types. */
+#ifndef INT8_MIN
+#define INT8_MIN               (-128)
+#endif
+#ifndef INT16_MIN
+#define INT16_MIN              (-32767-1)
+#endif
+#ifndef INT32_MIN
+#define INT32_MIN              (-2147483647-1)
+#endif
+#ifndef INT8_MAX
+#define INT8_MAX               (127)
+#endif
+#ifndef INT16_MAX
+#define INT16_MAX              (32767)
+#endif
+#ifndef INT32_MAX
+#define INT32_MAX              (2147483647)
+#endif
+#ifndef UINT8_MAX
+#define UINT8_MAX              (255U)
+#endif
+#ifndef UINT16_MAX
+#define UINT16_MAX             (65535U)
+#endif
+#ifndef UINT32_MAX
+#define UINT32_MAX             (4294967295U)
+#endif
+
+#ifndef SIZE_MAX
+#define SIZE_MAX               (~(size_t)0)
+#endif
+
+#endif /* ! C99 */
+
+#endif /* ! FLEXINT_H */
+
+/* begin standard C++ headers. */
+
+/* TODO: this is always defined, so inline it */
+#define yyconst const
+
+#if defined(__GNUC__) && __GNUC__ >= 3
+#define yynoreturn __attribute__((__noreturn__))
+#else
+#define yynoreturn
+#endif
+
+/* An opaque pointer. */
+#ifndef YY_TYPEDEF_YY_SCANNER_T
+#define YY_TYPEDEF_YY_SCANNER_T
+typedef void* yyscan_t;
+#endif
+
+/* For convenience, these vars (plus the bison vars far below)
+   are macros in the reentrant scanner. */
+#define yyin yyg->yyin_r
+#define yyout yyg->yyout_r
+#define yyextra yyg->yyextra_r
+#define yyleng yyg->yyleng_r
+#define yytext yyg->yytext_r
+#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
+#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
+#define yy_flex_debug yyg->yy_flex_debug_r
+
+/* Size of default input buffer. */
+#ifndef YY_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k.
+ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
+ * Ditto for the __ia64__ case accordingly.
+ */
+#define YY_BUF_SIZE 32768
+#else
+#define YY_BUF_SIZE 16384
+#endif /* __ia64__ */
+#endif
+
+#ifndef YY_TYPEDEF_YY_BUFFER_STATE
+#define YY_TYPEDEF_YY_BUFFER_STATE
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+#endif
+
+#ifndef YY_TYPEDEF_YY_SIZE_T
+#define YY_TYPEDEF_YY_SIZE_T
+typedef size_t yy_size_t;
+#endif
+
+#ifndef YY_STRUCT_YY_BUFFER_STATE
+#define YY_STRUCT_YY_BUFFER_STATE
+struct yy_buffer_state
+	{
+	FILE *yy_input_file;
+
+	char *yy_ch_buf;		/* input buffer */
+	char *yy_buf_pos;		/* current position in input buffer */
+
+	/* Size of input buffer in bytes, not including room for EOB
+	 * characters.
+	 */
+	int yy_buf_size;
+
+	/* Number of characters read into yy_ch_buf, not including EOB
+	 * characters.
+	 */
+	int yy_n_chars;
+
+	/* Whether we "own" the buffer - i.e., we know we created it,
+	 * and can realloc() it to grow it, and should free() it to
+	 * delete it.
+	 */
+	int yy_is_our_buffer;
+
+	/* Whether this is an "interactive" input source; if so, and
+	 * if we're using stdio for input, then we want to use getc()
+	 * instead of fread(), to make sure we stop fetching input after
+	 * each newline.
+	 */
+	int yy_is_interactive;
+
+	/* Whether we're considered to be at the beginning of a line.
+	 * If so, '^' rules will be active on the next match, otherwise
+	 * not.
+	 */
+	int yy_at_bol;
+
+    int yy_bs_lineno; /**< The line count. */
+    int yy_bs_column; /**< The column count. */
+
+	/* Whether to try to fill the input buffer when we reach the
+	 * end of it.
+	 */
+	int yy_fill_buffer;
+
+	int yy_buffer_status;
+
+	};
+#endif /* !YY_STRUCT_YY_BUFFER_STATE */
+
+void yyrestart ( FILE *input_file , yyscan_t yyscanner );
+void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
+void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
+void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
+void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
+void yypop_buffer_state ( yyscan_t yyscanner );
+
+YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner );
+
+void *yyalloc ( yy_size_t , yyscan_t yyscanner );
+void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
+void yyfree ( void * , yyscan_t yyscanner );
+
+/* Begin user sect3 */
+
+#define yywrap(yyscanner) (/*CONSTCOND*/1)
+#define YY_SKIP_YYWRAP
+
+#define yytext_ptr yytext_r
+
+#ifdef YY_HEADER_EXPORT_START_CONDITIONS
+#define INITIAL 0
+#define SC_COMMENT 1
+
+#endif
+
+#ifndef YY_NO_UNISTD_H
+/* Special case for "unistd.h", since it is non-ANSI. We include it way
+ * down here because we want the user's section 1 to have been scanned first.
+ * The user has a chance to override it with an option.
+ */
+#include <unistd.h>
+#endif
+
+#ifndef YY_EXTRA_TYPE
+#define YY_EXTRA_TYPE void *
+#endif
+
+int yylex_init (yyscan_t* scanner);
+
+int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);
+
+/* Accessor methods to globals.
+   These are made visible to non-reentrant scanners for convenience. */
+
+int yylex_destroy ( yyscan_t yyscanner );
+
+int yyget_debug ( yyscan_t yyscanner );
+
+void yyset_debug ( int debug_flag , yyscan_t yyscanner );
+
+YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );
+
+void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );
+
+FILE *yyget_in ( yyscan_t yyscanner );
+
+void yyset_in  ( FILE * _in_str , yyscan_t yyscanner );
+
+FILE *yyget_out ( yyscan_t yyscanner );
+
+void yyset_out  ( FILE * _out_str , yyscan_t yyscanner );
+
+			int yyget_leng ( yyscan_t yyscanner );
+
+char *yyget_text ( yyscan_t yyscanner );
+
+int yyget_lineno ( yyscan_t yyscanner );
+
+void yyset_lineno ( int _line_number , yyscan_t yyscanner );
+
+int yyget_column  ( yyscan_t yyscanner );
+
+void yyset_column ( int _column_no , yyscan_t yyscanner );
+
+/* Macros after this point can all be overridden by user definitions in
+ * section 1.
+ */
+
+#ifndef YY_SKIP_YYWRAP
+#ifdef __cplusplus
+extern "C" int yywrap ( yyscan_t yyscanner );
+#else
+extern int yywrap ( yyscan_t yyscanner );
+#endif
+#endif
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
+#endif
+
+#ifndef YY_NO_INPUT
+
+#endif
+
+/* Amount of stuff to slurp up with each read. */
+#ifndef YY_READ_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k */
+#define YY_READ_BUF_SIZE 16384
+#else
+#define YY_READ_BUF_SIZE 8192
+#endif /* __ia64__ */
+#endif
+
+/* Number of entries by which start-condition stack grows. */
+#ifndef YY_START_STACK_INCR
+#define YY_START_STACK_INCR 25
+#endif
+
+/* Default declaration of generated scanner - a define so the user can
+ * easily add parameters.
+ */
+#ifndef YY_DECL
+#define YY_DECL_IS_OURS 1
+
+extern int yylex (yyscan_t yyscanner);
+
+#define YY_DECL int yylex (yyscan_t yyscanner)
+#endif /* !YY_DECL */
+
+/* yy_get_previous_state - get the state just before the EOB char was reached */
+
+#undef YY_NEW_FILE
+#undef YY_FLUSH_BUFFER
+#undef yy_set_bol
+#undef yy_new_buffer
+#undef yy_set_interactive
+#undef YY_DO_BEFORE_ACTION
+
+#ifdef YY_DECL_IS_OURS
+#undef YY_DECL_IS_OURS
+#undef YY_DECL
+#endif
+
+#ifndef yy_create_buffer_ALREADY_DEFINED
+#undef yy_create_buffer
+#endif
+#ifndef yy_delete_buffer_ALREADY_DEFINED
+#undef yy_delete_buffer
+#endif
+#ifndef yy_scan_buffer_ALREADY_DEFINED
+#undef yy_scan_buffer
+#endif
+#ifndef yy_scan_string_ALREADY_DEFINED
+#undef yy_scan_string
+#endif
+#ifndef yy_scan_bytes_ALREADY_DEFINED
+#undef yy_scan_bytes
+#endif
+#ifndef yy_init_buffer_ALREADY_DEFINED
+#undef yy_init_buffer
+#endif
+#ifndef yy_flush_buffer_ALREADY_DEFINED
+#undef yy_flush_buffer
+#endif
+#ifndef yy_load_buffer_state_ALREADY_DEFINED
+#undef yy_load_buffer_state
+#endif
+#ifndef yy_switch_to_buffer_ALREADY_DEFINED
+#undef yy_switch_to_buffer
+#endif
+#ifndef yypush_buffer_state_ALREADY_DEFINED
+#undef yypush_buffer_state
+#endif
+#ifndef yypop_buffer_state_ALREADY_DEFINED
+#undef yypop_buffer_state
+#endif
+#ifndef yyensure_buffer_stack_ALREADY_DEFINED
+#undef yyensure_buffer_stack
+#endif
+#ifndef yylex_ALREADY_DEFINED
+#undef yylex
+#endif
+#ifndef yyrestart_ALREADY_DEFINED
+#undef yyrestart
+#endif
+#ifndef yylex_init_ALREADY_DEFINED
+#undef yylex_init
+#endif
+#ifndef yylex_init_extra_ALREADY_DEFINED
+#undef yylex_init_extra
+#endif
+#ifndef yylex_destroy_ALREADY_DEFINED
+#undef yylex_destroy
+#endif
+#ifndef yyget_debug_ALREADY_DEFINED
+#undef yyget_debug
+#endif
+#ifndef yyset_debug_ALREADY_DEFINED
+#undef yyset_debug
+#endif
+#ifndef yyget_extra_ALREADY_DEFINED
+#undef yyget_extra
+#endif
+#ifndef yyset_extra_ALREADY_DEFINED
+#undef yyset_extra
+#endif
+#ifndef yyget_in_ALREADY_DEFINED
+#undef yyget_in
+#endif
+#ifndef yyset_in_ALREADY_DEFINED
+#undef yyset_in
+#endif
+#ifndef yyget_out_ALREADY_DEFINED
+#undef yyget_out
+#endif
+#ifndef yyset_out_ALREADY_DEFINED
+#undef yyset_out
+#endif
+#ifndef yyget_leng_ALREADY_DEFINED
+#undef yyget_leng
+#endif
+#ifndef yyget_text_ALREADY_DEFINED
+#undef yyget_text
+#endif
+#ifndef yyget_lineno_ALREADY_DEFINED
+#undef yyget_lineno
+#endif
+#ifndef yyset_lineno_ALREADY_DEFINED
+#undef yyset_lineno
+#endif
+#ifndef yyget_column_ALREADY_DEFINED
+#undef yyget_column
+#endif
+#ifndef yyset_column_ALREADY_DEFINED
+#undef yyset_column
+#endif
+#ifndef yywrap_ALREADY_DEFINED
+#undef yywrap
+#endif
+#ifndef yyget_lval_ALREADY_DEFINED
+#undef yyget_lval
+#endif
+#ifndef yyset_lval_ALREADY_DEFINED
+#undef yyset_lval
+#endif
+#ifndef yyget_lloc_ALREADY_DEFINED
+#undef yyget_lloc
+#endif
+#ifndef yyset_lloc_ALREADY_DEFINED
+#undef yyset_lloc
+#endif
+#ifndef yyalloc_ALREADY_DEFINED
+#undef yyalloc
+#endif
+#ifndef yyrealloc_ALREADY_DEFINED
+#undef yyrealloc
+#endif
+#ifndef yyfree_ALREADY_DEFINED
+#undef yyfree
+#endif
+#ifndef yytext_ALREADY_DEFINED
+#undef yytext
+#endif
+#ifndef yyleng_ALREADY_DEFINED
+#undef yyleng
+#endif
+#ifndef yyin_ALREADY_DEFINED
+#undef yyin
+#endif
+#ifndef yyout_ALREADY_DEFINED
+#undef yyout
+#endif
+#ifndef yy_flex_debug_ALREADY_DEFINED
+#undef yy_flex_debug
+#endif
+#ifndef yylineno_ALREADY_DEFINED
+#undef yylineno
+#endif
+#ifndef yytables_fload_ALREADY_DEFINED
+#undef yytables_fload
+#endif
+#ifndef yytables_destroy_ALREADY_DEFINED
+#undef yytables_destroy
+#endif
+#ifndef yyTABLES_NAME_ALREADY_DEFINED
+#undef yyTABLES_NAME
+#endif
+
+#line 212 "src/lexer.l"
+
+
+#line 492 "src/gen_lexer.h"
+#undef yyIN_HEADER
+#endif /* yyHEADER_H */
diff --git a/src/gen_parser.c b/src/gen_parser.c
new file mode 100644
index 0000000..7cf33ac
--- /dev/null
+++ b/src/gen_parser.c
@@ -0,0 +1,4191 @@
+/* A Bison parser, made by GNU Bison 3.8.2.  */
+
+/* Bison implementation for Yacc-like parsers in C
+
+   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation,
+   Inc.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
+
+/* As a special exception, you may create a larger work that contains
+   part or all of the Bison parser skeleton and distribute that work
+   under terms of your choice, so long as that work isn't itself a
+   parser generator using the skeleton or a modified version thereof
+   as a parser skeleton.  Alternatively, if you modify or redistribute
+   the parser skeleton itself, you may (at your option) remove this
+   special exception, which will cause the skeleton and the resulting
+   Bison output files to be licensed under the GNU General Public
+   License without this special exception.
+
+   This special exception was added by the Free Software Foundation in
+   version 2.2 of Bison.  */
+
+/* C LALR(1) parser skeleton written by Richard Stallman, by
+   simplifying the original so-called "semantic" parser.  */
+
+/* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual,
+   especially those whose name start with YY_ or yy_.  They are
+   private implementation details that can be changed or removed.  */
+
+/* All symbols defined below should begin with yy or YY, to avoid
+   infringing on user name space.  This should be done even for local
+   variables, as they might otherwise be expanded by user macros.
+   There are some unavoidable exceptions within include files to
+   define necessary library symbols; they are noted "INFRINGES ON
+   USER NAME SPACE" below.  */
+
+/* Identify Bison output, and Bison version.  */
+#define YYBISON 30802
+
+/* Bison version string.  */
+#define YYBISON_VERSION "3.8.2"
+
+/* Skeleton name.  */
+#define YYSKELETON_NAME "yacc.c"
+
+/* Pure parsers.  */
+#define YYPURE 2
+
+/* Push parsers.  */
+#define YYPUSH 0
+
+/* Pull parsers.  */
+#define YYPULL 1
+
+
+
+
+/* First part of user prologue.  */
+#line 1 "src/parser.y"
+
+
+/* TODO: clean up this mess and I guess fix location tracking, it works for the
+ * parser but each ast node should also get some location data
+ * I'm trying something over in ast.c, but I'm not sure about it
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <cu/parser.h>
+#include <cu/ast.h>
+
+
+#line 85 "src/gen_parser.c"
+
+# ifndef YY_CAST
+#  ifdef __cplusplus
+#   define YY_CAST(Type, Val) static_cast<Type> (Val)
+#   define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
+#  else
+#   define YY_CAST(Type, Val) ((Type) (Val))
+#   define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
+#  endif
+# endif
+# ifndef YY_NULLPTR
+#  if defined __cplusplus
+#   if 201103L <= __cplusplus
+#    define YY_NULLPTR nullptr
+#   else
+#    define YY_NULLPTR 0
+#   endif
+#  else
+#   define YY_NULLPTR ((void*)0)
+#  endif
+# endif
+
+#include "gen_parser.h"
+/* Symbol kind.  */
+enum yysymbol_kind_t
+{
+  YYSYMBOL_YYEMPTY = -2,
+  YYSYMBOL_YYEOF = 0,                      /* "end of file"  */
+  YYSYMBOL_YYerror = 1,                    /* error  */
+  YYSYMBOL_YYUNDEF = 2,                    /* "invalid token"  */
+  YYSYMBOL_INT = 3,                        /* INT  */
+  YYSYMBOL_FLOAT = 4,                      /* FLOAT  */
+  YYSYMBOL_STRING = 5,                     /* STRING  */
+  YYSYMBOL_ID = 6,                         /* ID  */
+  YYSYMBOL_SQUOTE = 7,                     /* "'"  */
+  YYSYMBOL_TO = 8,                         /* "="  */
+  YYSYMBOL_ELLIPSIS = 9,                   /* "..."  */
+  YYSYMBOL_SEMICOLON = 10,                 /* ";"  */
+  YYSYMBOL_COLON = 11,                     /* ":"  */
+  YYSYMBOL_BANG = 12,                      /* "!"  */
+  YYSYMBOL_TYPEOF = 13,                    /* "typeof"  */
+  YYSYMBOL_SIZEOF = 14,                    /* "sizeof"  */
+  YYSYMBOL_PASTE = 15,                     /* "##"  */
+  YYSYMBOL_STAR = 16,                      /* "*"  */
+  YYSYMBOL_DIV = 17,                       /* "/"  */
+  YYSYMBOL_REM = 18,                       /* "%"  */
+  YYSYMBOL_MINUS = 19,                     /* "-"  */
+  YYSYMBOL_PLUS = 20,                      /* "+"  */
+  YYSYMBOL_POW = 21,                       /* "^^"  */
+  YYSYMBOL_XOR = 22,                       /* "^"  */
+  YYSYMBOL_AND = 23,                       /* "&"  */
+  YYSYMBOL_OR = 24,                        /* "|"  */
+  YYSYMBOL_LAND = 25,                      /* "&&"  */
+  YYSYMBOL_LOR = 26,                       /* "||"  */
+  YYSYMBOL_TILDE = 27,                     /* "~"  */
+  YYSYMBOL_LT = 28,                        /* "<"  */
+  YYSYMBOL_GT = 29,                        /* ">"  */
+  YYSYMBOL_LE = 30,                        /* "<="  */
+  YYSYMBOL_GE = 31,                        /* ">="  */
+  YYSYMBOL_NE = 32,                        /* "!="  */
+  YYSYMBOL_EQ = 33,                        /* "=="  */
+  YYSYMBOL_LSHIFT = 34,                    /* "<<"  */
+  YYSYMBOL_RSHIFT = 35,                    /* ">>"  */
+  YYSYMBOL_PLUSSELF = 36,                  /* "+="  */
+  YYSYMBOL_MINUSSELF = 37,                 /* "-="  */
+  YYSYMBOL_STARSELF = 38,                  /* "*="  */
+  YYSYMBOL_DIVSELF = 39,                   /* "/="  */
+  YYSYMBOL_REMSELF = 40,                   /* "%="  */
+  YYSYMBOL_XORSELF = 41,                   /* "^="  */
+  YYSYMBOL_POWSELF = 42,                   /* "^^="  */
+  YYSYMBOL_ANDSELF = 43,                   /* "&="  */
+  YYSYMBOL_ORSELF = 44,                    /* "|="  */
+  YYSYMBOL_LSHIFTSELF = 45,                /* "<<="  */
+  YYSYMBOL_RSHIFTSELF = 46,                /* ">>="  */
+  YYSYMBOL_AT = 47,                        /* "@"  */
+  YYSYMBOL_COMMA = 48,                     /* ","  */
+  YYSYMBOL_PUB = 49,                       /* "pub"  */
+  YYSYMBOL_STRUCT = 50,                    /* "struct"  */
+  YYSYMBOL_UNION = 51,                     /* "union"  */
+  YYSYMBOL_TYPEDEF = 52,                   /* "type"  */
+  YYSYMBOL_IMPORT = 53,                    /* "import"  */
+  YYSYMBOL_DEFER = 54,                     /* "defer"  */
+  YYSYMBOL_GOTO = 55,                      /* "goto"  */
+  YYSYMBOL_EMBED = 56,                     /* "embed"  */
+  YYSYMBOL_IF = 57,                        /* "if"  */
+  YYSYMBOL_ELSE = 58,                      /* "else"  */
+  YYSYMBOL_BREAK = 59,                     /* "break"  */
+  YYSYMBOL_CONTINUE = 60,                  /* "continue"  */
+  YYSYMBOL_SWITCH = 61,                    /* "switch"  */
+  YYSYMBOL_CASE = 62,                      /* "case"  */
+  YYSYMBOL_FOR = 63,                       /* "for"  */
+  YYSYMBOL_WHILE = 64,                     /* "while"  */
+  YYSYMBOL_DO = 65,                        /* "do"  */
+  YYSYMBOL_MUT = 66,                       /* "mut"  */
+  YYSYMBOL_RETURN = 67,                    /* "return"  */
+  YYSYMBOL_CONST = 68,                     /* "const"  */
+  YYSYMBOL_EXTERN = 69,                    /* "extern"  */
+  YYSYMBOL_ENUM = 70,                      /* "enum"  */
+  YYSYMBOL_DEFINE = 71,                    /* "define"  */
+  YYSYMBOL_LPAREN = 72,                    /* "("  */
+  YYSYMBOL_RPAREN = 73,                    /* ")"  */
+  YYSYMBOL_LBRACE = 74,                    /* "{"  */
+  YYSYMBOL_RBRACE = 75,                    /* "}"  */
+  YYSYMBOL_LBRACKET = 76,                  /* "["  */
+  YYSYMBOL_RBRACKET = 77,                  /* "]"  */
+  YYSYMBOL_AS = 78,                        /* "as"  */
+  YYSYMBOL_DOT = 79,                       /* "."  */
+  YYSYMBOL_FATARROW = 80,                  /* "=>"  */
+  YYSYMBOL_YYACCEPT = 81,                  /* $accept  */
+  YYSYMBOL_id = 82,                        /* id  */
+  YYSYMBOL_var = 83,                       /* var  */
+  YYSYMBOL_embed = 84,                     /* embed  */
+  YYSYMBOL_import = 85,                    /* import  */
+  YYSYMBOL_binary_op = 86,                 /* binary_op  */
+  YYSYMBOL_unary_op = 87,                  /* unary_op  */
+  YYSYMBOL_arg = 88,                       /* arg  */
+  YYSYMBOL_arg_list = 89,                  /* arg_list  */
+  YYSYMBOL_param_decl = 90,                /* param_decl  */
+  YYSYMBOL_decl_list = 91,                 /* decl_list  */
+  YYSYMBOL_call = 92,                      /* call  */
+  YYSYMBOL_defer = 93,                     /* defer  */
+  YYSYMBOL_expr = 94,                      /* expr  */
+  YYSYMBOL_while = 95,                     /* while  */
+  YYSYMBOL_do_while = 96,                  /* do_while  */
+  YYSYMBOL_goto = 97,                      /* goto  */
+  YYSYMBOL_statement = 98,                 /* statement  */
+  YYSYMBOL_statement_list = 99,            /* statement_list  */
+  YYSYMBOL_body = 100,                     /* body  */
+  YYSYMBOL_macro_list = 101,               /* macro_list  */
+  YYSYMBOL_macro = 102,                    /* macro  */
+  YYSYMBOL_expr_list = 103,                /* expr_list  */
+  YYSYMBOL_init_expr = 104,                /* init_expr  */
+  YYSYMBOL_expr_if = 105,                  /* expr_if  */
+  YYSYMBOL_if = 106,                       /* if  */
+  YYSYMBOL_for = 107,                      /* for  */
+  YYSYMBOL_case = 108,                     /* case  */
+  YYSYMBOL_case_list = 109,                /* case_list  */
+  YYSYMBOL_switch = 110,                   /* switch  */
+  YYSYMBOL_const_for = 111,                /* const_for  */
+  YYSYMBOL_const_if = 112,                 /* const_if  */
+  YYSYMBOL_const = 113,                    /* const  */
+  YYSYMBOL_func_sign = 114,                /* func_sign  */
+  YYSYMBOL_variadic_sign = 115,            /* variadic_sign  */
+  YYSYMBOL_impl = 116,                     /* impl  */
+  YYSYMBOL_impl_list = 117,                /* impl_list  */
+  YYSYMBOL_type = 118,                     /* type  */
+  YYSYMBOL_var_decl = 119,                 /* var_decl  */
+  YYSYMBOL_var_init = 120,                 /* var_init  */
+  YYSYMBOL_proc = 121,                     /* proc  */
+  YYSYMBOL_lambda = 122,                   /* lambda  */
+  YYSYMBOL_union_elem = 123,               /* union_elem  */
+  YYSYMBOL_union_list = 124,               /* union_list  */
+  YYSYMBOL_union = 125,                    /* union  */
+  YYSYMBOL_struct_list = 126,              /* struct_list  */
+  YYSYMBOL_struct = 127,                   /* struct  */
+  YYSYMBOL_template_elem = 128,            /* template_elem  */
+  YYSYMBOL_template_list = 129,            /* template_list  */
+  YYSYMBOL_type_list = 130,                /* type_list  */
+  YYSYMBOL_type_alias = 131,               /* type_alias  */
+  YYSYMBOL_type_template = 132,            /* type_template  */
+  YYSYMBOL_enum_val = 133,                 /* enum_val  */
+  YYSYMBOL_enum_list = 134,                /* enum_list  */
+  YYSYMBOL_enum = 135,                     /* enum  */
+  YYSYMBOL_top_if = 136,                   /* top_if  */
+  YYSYMBOL_top = 137,                      /* top  */
+  YYSYMBOL_unit = 138,                     /* unit  */
+  YYSYMBOL_input = 139                     /* input  */
+};
+typedef enum yysymbol_kind_t yysymbol_kind_t;
+
+
+
+
+#ifdef short
+# undef short
+#endif
+
+/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
+   <limits.h> and (if available) <stdint.h> are included
+   so that the code can choose integer types of a good width.  */
+
+#ifndef __PTRDIFF_MAX__
+# include <limits.h> /* INFRINGES ON USER NAME SPACE */
+# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
+#  include <stdint.h> /* INFRINGES ON USER NAME SPACE */
+#  define YY_STDINT_H
+# endif
+#endif
+
+/* Narrow types that promote to a signed type and that can represent a
+   signed or unsigned integer of at least N bits.  In tables they can
+   save space and decrease cache pressure.  Promoting to a signed type
+   helps avoid bugs in integer arithmetic.  */
+
+#ifdef __INT_LEAST8_MAX__
+typedef __INT_LEAST8_TYPE__ yytype_int8;
+#elif defined YY_STDINT_H
+typedef int_least8_t yytype_int8;
+#else
+typedef signed char yytype_int8;
+#endif
+
+#ifdef __INT_LEAST16_MAX__
+typedef __INT_LEAST16_TYPE__ yytype_int16;
+#elif defined YY_STDINT_H
+typedef int_least16_t yytype_int16;
+#else
+typedef short yytype_int16;
+#endif
+
+/* Work around bug in HP-UX 11.23, which defines these macros
+   incorrectly for preprocessor constants.  This workaround can likely
+   be removed in 2023, as HPE has promised support for HP-UX 11.23
+   (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of
+   <https://h20195.www2.hpe.com/V2/getpdf.aspx/4AA4-7673ENW.pdf>.  */
+#ifdef __hpux
+# undef UINT_LEAST8_MAX
+# undef UINT_LEAST16_MAX
+# define UINT_LEAST8_MAX 255
+# define UINT_LEAST16_MAX 65535
+#endif
+
+#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
+typedef __UINT_LEAST8_TYPE__ yytype_uint8;
+#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
+       && UINT_LEAST8_MAX <= INT_MAX)
+typedef uint_least8_t yytype_uint8;
+#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
+typedef unsigned char yytype_uint8;
+#else
+typedef short yytype_uint8;
+#endif
+
+#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
+typedef __UINT_LEAST16_TYPE__ yytype_uint16;
+#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
+       && UINT_LEAST16_MAX <= INT_MAX)
+typedef uint_least16_t yytype_uint16;
+#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
+typedef unsigned short yytype_uint16;
+#else
+typedef int yytype_uint16;
+#endif
+
+#ifndef YYPTRDIFF_T
+# if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
+#  define YYPTRDIFF_T __PTRDIFF_TYPE__
+#  define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
+# elif defined PTRDIFF_MAX
+#  ifndef ptrdiff_t
+#   include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+#  endif
+#  define YYPTRDIFF_T ptrdiff_t
+#  define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
+# else
+#  define YYPTRDIFF_T long
+#  define YYPTRDIFF_MAXIMUM LONG_MAX
+# endif
+#endif
+
+#ifndef YYSIZE_T
+# ifdef __SIZE_TYPE__
+#  define YYSIZE_T __SIZE_TYPE__
+# elif defined size_t
+#  define YYSIZE_T size_t
+# elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
+#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+#  define YYSIZE_T size_t
+# else
+#  define YYSIZE_T unsigned
+# endif
+#endif
+
+#define YYSIZE_MAXIMUM                                  \
+  YY_CAST (YYPTRDIFF_T,                                 \
+           (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1)  \
+            ? YYPTRDIFF_MAXIMUM                         \
+            : YY_CAST (YYSIZE_T, -1)))
+
+#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
+
+
+/* Stored state numbers (used for stacks). */
+typedef yytype_int16 yy_state_t;
+
+/* State numbers in computations.  */
+typedef int yy_state_fast_t;
+
+#ifndef YY_
+# if defined YYENABLE_NLS && YYENABLE_NLS
+#  if ENABLE_NLS
+#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
+#   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
+#  endif
+# endif
+# ifndef YY_
+#  define YY_(Msgid) Msgid
+# endif
+#endif
+
+
+#ifndef YY_ATTRIBUTE_PURE
+# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
+#  define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
+# else
+#  define YY_ATTRIBUTE_PURE
+# endif
+#endif
+
+#ifndef YY_ATTRIBUTE_UNUSED
+# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
+#  define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
+# else
+#  define YY_ATTRIBUTE_UNUSED
+# endif
+#endif
+
+/* Suppress unused-variable warnings by "using" E.  */
+#if ! defined lint || defined __GNUC__
+# define YY_USE(E) ((void) (E))
+#else
+# define YY_USE(E) /* empty */
+#endif
+
+/* Suppress an incorrect diagnostic about yylval being uninitialized.  */
+#if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__
+# if __GNUC__ * 100 + __GNUC_MINOR__ < 407
+#  define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN                           \
+    _Pragma ("GCC diagnostic push")                                     \
+    _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")
+# else
+#  define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN                           \
+    _Pragma ("GCC diagnostic push")                                     \
+    _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")              \
+    _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
+# endif
+# define YY_IGNORE_MAYBE_UNINITIALIZED_END      \
+    _Pragma ("GCC diagnostic pop")
+#else
+# define YY_INITIAL_VALUE(Value) Value
+#endif
+#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+# define YY_IGNORE_MAYBE_UNINITIALIZED_END
+#endif
+#ifndef YY_INITIAL_VALUE
+# define YY_INITIAL_VALUE(Value) /* Nothing. */
+#endif
+
+#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
+# define YY_IGNORE_USELESS_CAST_BEGIN                          \
+    _Pragma ("GCC diagnostic push")                            \
+    _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
+# define YY_IGNORE_USELESS_CAST_END            \
+    _Pragma ("GCC diagnostic pop")
+#endif
+#ifndef YY_IGNORE_USELESS_CAST_BEGIN
+# define YY_IGNORE_USELESS_CAST_BEGIN
+# define YY_IGNORE_USELESS_CAST_END
+#endif
+
+
+#define YY_ASSERT(E) ((void) (0 && (E)))
+
+#if 1
+
+/* The parser invokes alloca or malloc; define the necessary symbols.  */
+
+# ifdef YYSTACK_USE_ALLOCA
+#  if YYSTACK_USE_ALLOCA
+#   ifdef __GNUC__
+#    define YYSTACK_ALLOC __builtin_alloca
+#   elif defined __BUILTIN_VA_ARG_INCR
+#    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
+#   elif defined _AIX
+#    define YYSTACK_ALLOC __alloca
+#   elif defined _MSC_VER
+#    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
+#    define alloca _alloca
+#   else
+#    define YYSTACK_ALLOC alloca
+#    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
+#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+      /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
+#     ifndef EXIT_SUCCESS
+#      define EXIT_SUCCESS 0
+#     endif
+#    endif
+#   endif
+#  endif
+# endif
+
+# ifdef YYSTACK_ALLOC
+   /* Pacify GCC's 'empty if-body' warning.  */
+#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+    /* The OS might guarantee only one guard page at the bottom of the stack,
+       and a page size can be as small as 4096 bytes.  So we cannot safely
+       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
+       to allow for a few compiler-allocated temporary stack slots.  */
+#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
+#  endif
+# else
+#  define YYSTACK_ALLOC YYMALLOC
+#  define YYSTACK_FREE YYFREE
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
+#  endif
+#  if (defined __cplusplus && ! defined EXIT_SUCCESS \
+       && ! ((defined YYMALLOC || defined malloc) \
+             && (defined YYFREE || defined free)))
+#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+#   ifndef EXIT_SUCCESS
+#    define EXIT_SUCCESS 0
+#   endif
+#  endif
+#  ifndef YYMALLOC
+#   define YYMALLOC malloc
+#   if ! defined malloc && ! defined EXIT_SUCCESS
+void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+#  ifndef YYFREE
+#   define YYFREE free
+#   if ! defined free && ! defined EXIT_SUCCESS
+void free (void *); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+# endif
+#endif /* 1 */
+
+#if (! defined yyoverflow \
+     && (! defined __cplusplus \
+         || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
+             && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
+
+/* A type that is properly aligned for any stack member.  */
+union yyalloc
+{
+  yy_state_t yyss_alloc;
+  YYSTYPE yyvs_alloc;
+  YYLTYPE yyls_alloc;
+};
+
+/* The size of the maximum gap between one aligned stack and the next.  */
+# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
+
+/* The size of an array large to enough to hold all stacks, each with
+   N elements.  */
+# define YYSTACK_BYTES(N) \
+     ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE) \
+             + YYSIZEOF (YYLTYPE)) \
+      + 2 * YYSTACK_GAP_MAXIMUM)
+
+# define YYCOPY_NEEDED 1
+
+/* Relocate STACK from its old location to the new one.  The
+   local variables YYSIZE and YYSTACKSIZE give the old and new number of
+   elements in the stack, and YYPTR gives the new location of the
+   stack.  Advance YYPTR to a properly aligned location for the next
+   stack.  */
+# define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
+    do                                                                  \
+      {                                                                 \
+        YYPTRDIFF_T yynewbytes;                                         \
+        YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
+        Stack = &yyptr->Stack_alloc;                                    \
+        yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
+        yyptr += yynewbytes / YYSIZEOF (*yyptr);                        \
+      }                                                                 \
+    while (0)
+
+#endif
+
+#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
+/* Copy COUNT objects from SRC to DST.  The source and destination do
+   not overlap.  */
+# ifndef YYCOPY
+#  if defined __GNUC__ && 1 < __GNUC__
+#   define YYCOPY(Dst, Src, Count) \
+      __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
+#  else
+#   define YYCOPY(Dst, Src, Count)              \
+      do                                        \
+        {                                       \
+          YYPTRDIFF_T yyi;                      \
+          for (yyi = 0; yyi < (Count); yyi++)   \
+            (Dst)[yyi] = (Src)[yyi];            \
+        }                                       \
+      while (0)
+#  endif
+# endif
+#endif /* !YYCOPY_NEEDED */
+
+/* YYFINAL -- State number of the termination state.  */
+#define YYFINAL  57
+/* YYLAST -- Last index in YYTABLE.  */
+#define YYLAST   1950
+
+/* YYNTOKENS -- Number of terminals.  */
+#define YYNTOKENS  81
+/* YYNNTS -- Number of nonterminals.  */
+#define YYNNTS  59
+/* YYNRULES -- Number of rules.  */
+#define YYNRULES  210
+/* YYNSTATES -- Number of states.  */
+#define YYNSTATES  418
+
+/* YYMAXUTOK -- Last valid token kind.  */
+#define YYMAXUTOK   335
+
+
+/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
+   as returned by yylex, with out-of-bounds checking.  */
+#define YYTRANSLATE(YYX)                                \
+  (0 <= (YYX) && (YYX) <= YYMAXUTOK                     \
+   ? YY_CAST (yysymbol_kind_t, yytranslate[YYX])        \
+   : YYSYMBOL_YYUNDEF)
+
+/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
+   as returned by yylex.  */
+static const yytype_int8 yytranslate[] =
+{
+       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
+       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
+      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
+      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
+      45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
+      55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
+      65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
+      75,    76,    77,    78,    79,    80
+};
+
+#if YYDEBUG
+/* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
+static const yytype_int16 yyrline[] =
+{
+       0,   146,   146,   152,   153,   156,   159,   162,   163,   164,
+     165,   166,   167,   168,   169,   170,   171,   172,   173,   174,
+     175,   176,   177,   178,   179,   180,   181,   182,   183,   184,
+     187,   190,   191,   192,   193,   194,   195,   198,   199,   200,
+     201,   202,   205,   206,   207,   210,   211,   214,   216,   217,
+     218,   219,   223,   224,   227,   231,   232,   233,   234,   235,
+     236,   237,   238,   242,   243,   244,   245,   246,   247,   248,
+     249,   250,   251,   252,   255,   258,   264,   266,   267,   268,
+     269,   270,   272,   273,   274,   275,   276,   277,   278,   279,
+     280,   281,   282,   283,   284,   285,   286,   287,   288,   289,
+     305,   306,   309,   310,   313,   314,   317,   321,   328,   334,
+     335,   338,   339,   340,   341,   344,   345,   348,   349,   350,
+     353,   357,   360,   361,   364,   367,   374,   378,   383,   391,
+     393,   397,   400,   402,   404,   406,   410,   411,   418,   420,
+     423,   424,   427,   428,   432,   435,   439,   443,   447,   452,
+     456,   457,   460,   461,   465,   471,   475,   481,   485,   486,
+     489,   490,   493,   496,   501,   504,   507,   512,   513,   514,
+     515,   518,   519,   522,   523,   526,   531,   534,   540,   541,
+     544,   545,   546,   549,   550,   556,   560,   564,   572,   573,
+     574,   575,   576,   577,   578,   579,   580,   581,   582,   583,
+     584,   585,   586,   587,   588,   589,   590,   605,   606,   609,
+     610
+};
+#endif
+
+/** Accessing symbol of state STATE.  */
+#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State])
+
+#if 1
+/* The user-facing name of the symbol whose (internal) number is
+   YYSYMBOL.  No bounds checking.  */
+static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED;
+
+/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
+   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
+static const char *const yytname[] =
+{
+  "\"end of file\"", "error", "\"invalid token\"", "INT", "FLOAT",
+  "STRING", "ID", "\"'\"", "\"=\"", "\"...\"", "\";\"", "\":\"", "\"!\"",
+  "\"typeof\"", "\"sizeof\"", "\"##\"", "\"*\"", "\"/\"", "\"%\"", "\"-\"",
+  "\"+\"", "\"^^\"", "\"^\"", "\"&\"", "\"|\"", "\"&&\"", "\"||\"",
+  "\"~\"", "\"<\"", "\">\"", "\"<=\"", "\">=\"", "\"!=\"", "\"==\"",
+  "\"<<\"", "\">>\"", "\"+=\"", "\"-=\"", "\"*=\"", "\"/=\"", "\"%=\"",
+  "\"^=\"", "\"^^=\"", "\"&=\"", "\"|=\"", "\"<<=\"", "\">>=\"", "\"@\"",
+  "\",\"", "\"pub\"", "\"struct\"", "\"union\"", "\"type\"", "\"import\"",
+  "\"defer\"", "\"goto\"", "\"embed\"", "\"if\"", "\"else\"", "\"break\"",
+  "\"continue\"", "\"switch\"", "\"case\"", "\"for\"", "\"while\"",
+  "\"do\"", "\"mut\"", "\"return\"", "\"const\"", "\"extern\"", "\"enum\"",
+  "\"define\"", "\"(\"", "\")\"", "\"{\"", "\"}\"", "\"[\"", "\"]\"",
+  "\"as\"", "\".\"", "\"=>\"", "$accept", "id", "var", "embed", "import",
+  "binary_op", "unary_op", "arg", "arg_list", "param_decl", "decl_list",
+  "call", "defer", "expr", "while", "do_while", "goto", "statement",
+  "statement_list", "body", "macro_list", "macro", "expr_list",
+  "init_expr", "expr_if", "if", "for", "case", "case_list", "switch",
+  "const_for", "const_if", "const", "func_sign", "variadic_sign", "impl",
+  "impl_list", "type", "var_decl", "var_init", "proc", "lambda",
+  "union_elem", "union_list", "union", "struct_list", "struct",
+  "template_elem", "template_list", "type_list", "type_alias",
+  "type_template", "enum_val", "enum_list", "enum", "top_if", "top",
+  "unit", "input", YY_NULLPTR
+};
+
+static const char *
+yysymbol_name (yysymbol_kind_t yysymbol)
+{
+  return yytname[yysymbol];
+}
+#endif
+
+#define YYPACT_NINF (-225)
+
+#define yypact_value_is_default(Yyn) \
+  ((Yyn) == YYPACT_NINF)
+
+#define YYTABLE_NINF (-211)
+
+#define yytable_value_is_error(Yyn) \
+  0
+
+/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
+   STATE-NUM.  */
+static const yytype_int16 yypact[] =
+{
+     482,  -225,  -225,  -225,   246,    42,    42,    50,   -30,    42,
+      42,    42,   408,    61,    62,  -225,    74,  -225,  -225,  -225,
+      75,  -225,  -225,  1028,  -225,   107,   120,   128,  -225,  -225,
+    -225,   131,  -225,  -225,    65,    30,  -225,  1039,  -225,    77,
+      27,    83,   141,  1039,   227,   284,    70,   153,    97,  -225,
+      68,  -225,  -225,  -225,   915,  -225,  -225,  -225,  -225,  -225,
+    -225,   127,    33,    23,  -225,  -225,  -225,  -225,  1039,    42,
+    1039,  1039,  1039,  1039,  1039,  -225,    98,    99,  1039,    42,
+     127,    53,  -225,  -225,  -225,  -225,  -225,  1102,  -225,    70,
+    -225,   127,    42,    22,  -225,  -225,  1871,   915,  -225,   915,
+    -225,  -225,   127,   429,   118,     8,  -225,   125,   127,  1166,
+      42,   731,  -225,  1039,   915,   280,  1871,  -225,  -225,    74,
+    -225,   126,   102,    12,    51,  -225,   167,  -225,  -225,   103,
+    -225,   438,   169,   172,  -225,    33,   114,   111,  -225,   111,
+    1871,   176,  1327,   111,  1039,   186,  1230,   122,   158,   135,
+    -225,    42,   883,  1039,  1039,  1039,  1039,  1039,  1039,  1039,
+    1039,  1039,  1039,  1039,  1039,  1039,  1039,  1039,  1039,  1039,
+    1039,  1039,  1039,  1039,  1039,  1039,  1039,  1039,  1039,  1039,
+    1039,  1039,  1039,   567,   127,    42,   -40,   134,   208,   170,
+     144,    68,    56,  -225,  -225,   147,   127,   127,   127,    42,
+    -225,   253,   127,  -225,   127,   148,   175,   151,  -225,  -225,
+      42,   915,   217,   222,  1039,   961,  1039,    68,   993,   -16,
+    -225,   256,   226,   231,  1294,  -225,  -225,   240,   649,   181,
+    -225,  -225,  -225,  -225,  -225,  -225,  -225,   241,  -225,  -225,
+    -225,    68,   127,   190,    33,   191,    33,  -225,   127,   258,
+    -225,  -225,  -225,  -225,  1358,   197,  -225,  -225,    42,    77,
+    -225,  1039,  -225,   224,   201,  -225,    74,  1871,   -19,   -19,
+     -19,   176,   176,  1135,  1071,  1327,   745,  1263,  1199,   562,
+     562,   562,   562,   821,   821,   437,   437,  1871,  1871,  1871,
+    1871,  1871,  1871,  1871,  1871,  1871,  1871,   200,  -225,  -225,
+      42,  1039,    42,  -225,  -225,    42,    68,  -225,  -225,   196,
+    -225,   204,  -225,  -225,    42,  -225,  -225,    68,  -225,  -225,
+    1422,   269,  1486,   225,  -225,  1551,  1039,    42,  -225,  -225,
+    -225,  -225,  -225,  -225,  -225,  -225,  -225,  -225,   236,  -225,
+      33,   232,    33,  -225,   233,  -225,  -225,  -225,  -225,    68,
+      74,   961,  -225,   243,   234,  1871,  -225,   237,  -225,   127,
+    -225,  -225,   248,   250,  1039,  -225,  1039,  -225,  1486,   302,
+     -25,   244,  -225,   245,  -225,  -225,  -225,   -23,  -225,    68,
+     252,    13,  1039,   250,   255,  1615,  1679,   260,  1039,  -225,
+    -225,  -225,  -225,   567,  -225,  -225,  -225,  -225,  -225,  1743,
+    -225,  -225,  1039,  -225,    79,  1807,    68,   259,   807,  1486,
+    -225,  -225,  1039,  -225,  -225,  -225,  -225,  -225
+};
+
+/* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
+   Performed when YYTABLE does not specify something else to do.  Zero
+   means the default is an error.  */
+static const yytype_uint8 yydefact[] =
+{
+       0,   206,     2,   188,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   192,     3,     4,   190,   191,
+       0,   196,   189,     0,   209,     0,     0,     0,   200,   199,
+     198,     0,   203,   197,     0,     0,     6,     0,   193,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   142,   136,
+       0,   151,   204,   194,     0,   195,   208,     1,   205,   201,
+     202,     0,     0,     0,   175,    60,    61,    62,     0,     0,
+       0,     0,     0,     0,     0,    59,     0,     0,     0,     0,
+       0,    55,    72,    66,    67,    64,    65,     0,    73,     0,
+     156,     0,     0,     0,   143,   145,   148,     0,   149,     0,
+     150,   135,     0,   142,    51,     0,    47,    50,     0,     0,
+       0,     0,   155,     0,     0,    55,   111,   152,   114,     0,
+     112,   174,     0,     0,     0,   159,     0,   164,   158,     0,
+     177,   139,     0,     0,   170,   172,     0,    40,    58,    38,
+      69,    37,    39,    41,     0,     0,     0,     0,   105,     0,
+      71,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   178,   182,
+       0,     0,     0,   153,   154,     0,     0,     0,     0,     0,
+     132,     0,     0,   146,     0,   139,   141,     0,    99,    98,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     103,    55,     0,     0,     0,    89,    90,     0,     0,     0,
+      97,    92,    84,    87,    91,    88,    93,     0,    95,    96,
+     113,     0,     0,     0,     0,     0,   161,   165,     0,     0,
+     167,   169,   171,   176,     0,     0,    63,    68,     0,     0,
+      57,     0,    53,    46,     0,    44,    43,     7,    10,    11,
+      12,     9,     8,    14,    13,    15,    17,    16,    18,    31,
+      32,    33,    34,    35,    36,    19,    20,    21,    22,    23,
+      24,    25,    28,    26,    27,    29,    30,     0,    70,    56,
+       0,     0,   181,   184,   108,     0,     0,   134,    49,     0,
+     133,     0,    48,   147,     0,   144,    76,     0,    80,    81,
+       0,     0,     0,     0,    79,     0,     0,     0,   130,   129,
+      86,    83,    82,    77,    85,   100,   102,    94,     0,   173,
+       0,     0,     0,   160,     0,   168,    54,     5,   104,     0,
+      42,     0,    52,   185,     0,   179,   180,     0,   106,     0,
+     131,   140,   117,     0,     0,    74,     0,    78,     0,     0,
+       0,     0,   163,     0,   138,   157,    45,     0,   183,     0,
+       0,     0,     0,   123,     0,     0,     0,   126,     0,   115,
+     116,   166,   162,     0,   187,   107,   137,   118,   119,     0,
+     122,   124,     0,    75,     0,   110,     0,     0,     0,     0,
+     127,   128,     0,   125,   186,   121,   120,   109
+};
+
+/* YYPGOTO[NTERM-NUM].  */
+static const yytype_int16 yypgoto[] =
+{
+    -225,     0,    -2,  -225,     9,  -225,  -225,   116,   -18,  -225,
+     -86,  -225,  -225,   210,  -225,  -225,  -225,  -225,  -220,    94,
+     -77,    10,   -76,   -24,   -33,   -43,  -225,  -225,   -44,  -225,
+    -225,   -63,  -225,    14,  -225,  -109,    29,   359,   431,   -47,
+     340,  -225,  -225,  -224,   -39,     5,    11,  -225,   212,  -148,
+      15,    17,  -225,  -139,    21,   -28,  -225,     3,  -225
+};
+
+/* YYDEFGOTO[NTERM-NUM].  */
+static const yytype_int16 yydefgoto[] =
+{
+       0,    81,    13,    82,    14,    83,    84,   263,   264,   104,
+     105,    85,    86,   116,   225,   226,   227,   228,   229,   230,
+     149,    15,   406,   265,   118,   232,   233,   383,   384,   234,
+     328,   329,   235,    49,    50,   132,   207,    51,    16,    17,
+      18,    88,   126,   127,   128,   129,    19,   135,   136,   122,
+      20,    21,   189,   190,    22,    38,    23,    24,    25
+};
+
+/* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
+   positive, shift that token.  If negative, reduce the rule whose
+   number is the opposite.  If YYTABLE_NINF, syntax error.  */
+static const yytype_int16 yytable[] =
+{
+      12,   206,    26,   186,    12,    34,    35,   120,   335,    39,
+      40,    41,    48,    27,    28,    30,   192,   199,     2,    31,
+     341,    32,   343,    12,   134,    33,    56,    37,     2,     2,
+     117,   147,   114,   200,    37,    48,     2,    42,    91,     2,
+     201,   326,    48,    43,    48,    48,   103,   327,     2,   111,
+     120,   393,   120,    90,   115,    36,    94,     2,    42,   184,
+     185,    48,   124,   131,    43,   305,   240,   120,   151,   138,
+     211,    52,    53,   193,   123,   194,     2,    42,   115,   148,
+      48,   200,    54,    43,   123,    55,   244,   111,   201,   103,
+     241,    48,   188,   148,   339,   191,   134,   115,   130,   115,
+     344,    92,    48,    48,    63,   120,    47,    57,    48,   222,
+     205,   221,   308,   115,   115,    48,   312,   196,   373,   197,
+     223,   231,   236,   245,    48,   152,   237,    47,   238,   306,
+      58,    48,   239,     2,    42,   131,   326,    61,    59,    62,
+      43,    60,   111,   101,   112,   249,    47,     2,    42,    89,
+     102,   260,   115,   111,    43,    93,    65,    66,    67,     2,
+      68,   354,    69,   356,   120,    70,   198,    71,   120,   110,
+     144,   145,    72,   202,   242,   243,    73,   246,   247,   250,
+      74,   348,   251,    12,    48,   299,   297,   317,   415,   253,
+     185,   255,   154,   155,   156,   257,    48,    48,   103,   309,
+      75,    48,   103,    47,    48,   206,   258,    76,   300,    77,
+     316,   115,   259,    89,   240,   115,   301,    47,   302,   303,
+     307,    48,   248,   314,   315,    78,   222,   318,   221,    79,
+     108,    80,   319,     2,    42,    97,   331,   223,   231,   236,
+      43,   332,    48,   237,   124,   238,   124,    87,    48,   239,
+     334,   337,     2,    96,   184,   185,   336,   109,   148,     2,
+      42,   115,     2,    42,   340,   342,    43,   330,   345,    43,
+     347,   151,   351,   349,   352,   353,   359,   360,   137,   364,
+     139,   140,   141,   142,   143,   304,     2,    42,   146,   366,
+       2,    42,    99,    43,   370,   151,     5,    43,     6,     7,
+     188,   377,   188,    47,   120,   357,   381,   372,   374,   378,
+     379,   323,   382,   388,   205,     9,    10,    11,   404,   391,
+     392,   224,    44,   142,    45,   396,   310,   369,   152,    47,
+     401,   321,    47,   376,   414,   338,   417,   390,   398,   400,
+     124,   411,   124,   361,    29,   371,    44,   252,    45,   394,
+       0,   115,   152,     0,   254,     0,    47,     0,     0,    48,
+      47,     0,     0,   267,   268,   269,   270,   271,   272,   273,
+     274,   275,   276,   277,   278,   279,   280,   281,   282,   283,
+     284,   285,   286,   287,   288,   289,   290,   291,   292,   293,
+     294,   295,   296,    12,    64,     0,   407,     0,     0,     0,
+     358,    95,     0,    98,   100,   106,   222,     0,   221,     0,
+       0,   362,     0,     0,     2,    42,   365,   223,   231,   236,
+     121,    43,     0,   237,   320,   238,   322,     0,   325,   239,
+       0,     0,     0,     0,     0,     2,    42,     0,   224,   150,
+       0,     0,    43,   375,     2,    42,     0,     0,   106,     0,
+     187,    43,     0,   154,   155,   156,   157,   158,     0,     0,
+       0,   195,   387,     0,   389,     0,     0,   203,     0,     0,
+       0,   142,     0,   395,    44,   397,    45,   107,     0,     0,
+      46,     0,  -210,     1,    47,   119,     0,     0,     2,     0,
+       0,     0,     3,   125,   133,   196,     0,   197,   410,     0,
+     413,   110,     0,   416,   196,    47,   197,     0,     0,   119,
+      89,   355,   248,     0,    47,   184,   185,     0,     0,     0,
+     107,     0,     0,     0,     0,     0,     0,     0,   119,     0,
+     119,     4,     5,     0,     6,     7,   368,     0,     0,     0,
+       0,     0,     0,   298,   119,   119,     0,     0,     0,     0,
+       8,     9,    10,    11,     0,    98,   100,   106,     0,     0,
+     311,   106,     0,   313,     0,     0,   133,     0,     1,     0,
+       0,     0,     0,     2,   385,     0,   386,     3,   154,   155,
+     156,   157,   158,   266,   160,   161,   162,     0,     0,     0,
+       0,     0,   399,     0,     0,     0,   171,   172,   405,     0,
+       0,   121,     0,     0,     0,     0,     0,   121,     0,     0,
+       0,     0,   409,     0,     0,     0,     4,     5,   224,     6,
+       7,     0,   405,     0,     0,     0,     0,     0,     0,   107,
+       0,     0,     0,   107,     0,     8,     9,    10,    11,     0,
+     184,   185,   119,     0,     0,     0,   266,     0,     0,     0,
+     208,     0,    65,    66,    67,     2,    68,     0,    69,   209,
+       0,    70,     0,    71,     0,     0,     0,     0,    72,     0,
+       0,     0,    73,     0,     0,   125,    74,   125,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   350,     0,     0,     0,    75,     0,     0,     5,
+       0,     6,     7,    76,   210,    77,   211,     0,   212,   213,
+     214,  -101,   215,   216,   217,     0,   218,   219,   380,    10,
+      11,    78,     0,   111,  -101,    79,     0,    80,     0,     0,
+       0,     0,   208,     0,    65,    66,    67,     2,    68,     0,
+      69,   209,     0,    70,     0,    71,     0,     0,     0,     0,
+      72,     0,     0,     0,    73,     0,     0,     0,    74,     0,
+       0,   154,   155,   156,   157,   158,     0,   160,   161,     0,
+       0,   125,     0,   125,     0,     0,     0,     0,    75,   171,
+     172,     5,   266,     6,     7,    76,   210,    77,   211,     0,
+     212,   213,   214,     0,   215,   216,   217,     0,   218,   219,
+       0,    10,    11,    78,     0,   111,   220,    79,   208,    80,
+      65,    66,    67,     2,    68,     0,    69,   209,     0,    70,
+       0,    71,     0,   184,   185,     0,    72,     0,     0,     0,
+      73,     0,     0,     0,    74,     0,     0,   154,   155,   156,
+     157,   158,     0,   160,   161,   162,     0,     0,     0,   165,
+     166,   167,   168,     0,    75,   171,   172,     5,     0,     6,
+       7,    76,   210,    77,   211,     0,   212,   213,   214,     0,
+     215,   216,   217,     0,   218,   219,     0,    10,    11,    78,
+       0,   111,     0,    79,     0,    80,    65,    66,    67,     2,
+      68,     0,    69,     0,     0,    70,     0,    71,     0,   184,
+     185,     0,    72,     0,     0,     0,   261,     0,     0,     0,
+      74,     0,     0,     0,     0,     0,     0,     0,    65,    66,
+      67,     2,    68,     0,    69,     0,     0,    70,     0,    71,
+      75,     0,     0,     0,    72,     0,     0,    76,   113,    77,
+     114,     0,    74,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,    78,   262,     0,     0,    79,
+       0,    80,    75,     0,    65,    66,    67,     2,    68,    76,
+      69,    77,   114,    70,     0,    71,     0,     0,     0,     0,
+      72,     0,     0,     0,   261,     0,     0,    78,    74,     0,
+       0,    79,     0,    80,     0,     0,    65,    66,    67,     2,
+      68,     0,    69,   324,     0,    70,     0,    71,    75,     0,
+       0,     0,    72,     0,     0,    76,    73,    77,   114,     0,
+      74,     0,     0,     0,     0,     0,     0,     0,  -207,     1,
+       0,     0,     0,    78,     2,     0,     0,    79,     3,    80,
+      75,     0,    65,    66,    67,     2,    68,    76,    69,    77,
+       0,    70,     0,    71,     0,     0,     0,     0,    72,     0,
+       0,     0,    73,     0,     0,    78,    74,     0,     0,    79,
+       0,    80,     0,     0,     0,     0,     0,     4,     5,     0,
+       6,     7,     0,     0,     0,     0,    75,   154,   155,   156,
+     157,   158,     0,    76,   161,    77,     8,     9,    10,    11,
+       0,     0,     0,  -207,     0,   171,   172,     0,     0,     0,
+     153,    78,     0,     0,     0,    79,     0,    80,   154,   155,
+     156,   157,   158,   159,   160,   161,   162,   163,   164,     0,
+     165,   166,   167,   168,   169,   170,   171,   172,   173,   174,
+     175,   176,   177,   178,     0,   179,   180,   181,   182,   184,
+     185,   154,   155,   156,   157,   158,     0,   160,   161,   162,
+     163,   164,     0,   165,   166,   167,   168,   169,   170,   171,
+     172,     0,     0,     0,   153,     0,   183,     0,     0,     0,
+     184,   185,   154,   155,   156,   157,   158,   159,   160,   161,
+     162,   163,   164,     0,   165,   166,   167,   168,   169,   170,
+     171,   172,   173,   174,   175,   176,   177,   178,     0,   179,
+     180,   181,   182,   184,   185,   154,   155,   156,   157,   158,
+       0,   160,   161,   162,   163,     0,     0,   165,   166,   167,
+     168,   169,   170,   171,   172,     0,     0,     0,   153,     0,
+       0,     0,     0,   204,   184,   185,   154,   155,   156,   157,
+     158,   159,   160,   161,   162,   163,   164,     0,   165,   166,
+     167,   168,   169,   170,   171,   172,   173,   174,   175,   176,
+     177,   178,     0,   179,   180,   181,   182,   184,   185,   154,
+     155,   156,   157,   158,     0,   160,   161,   162,     0,     0,
+       0,   165,   166,   167,   168,   169,   170,   171,   172,     0,
+       0,     0,   153,   256,   333,     0,     0,     0,   184,   185,
+     154,   155,   156,   157,   158,   159,   160,   161,   162,   163,
+     164,     0,   165,   166,   167,   168,   169,   170,   171,   172,
+     173,   174,   175,   176,   177,   178,     0,   179,   180,   181,
+     182,   184,   185,   154,   155,   156,   157,   158,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,   171,   172,     0,     0,     0,   153,     0,     0,     0,
+       0,     0,   184,   185,   154,   155,   156,   157,   158,   159,
+     160,   161,   162,   163,   164,     0,   165,   166,   167,   168,
+     169,   170,   171,   172,   173,   174,   175,   176,   177,   178,
+       0,   179,   180,   181,   182,   184,   185,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     153,   346,     0,     0,     0,     0,   184,   185,   154,   155,
+     156,   157,   158,   159,   160,   161,   162,   163,   164,     0,
+     165,   166,   167,   168,   169,   170,   171,   172,   173,   174,
+     175,   176,   177,   178,     0,   179,   180,   181,   182,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   153,     0,   363,     0,     0,     0,
+     184,   185,   154,   155,   156,   157,   158,   159,   160,   161,
+     162,   163,   164,     0,   165,   166,   167,   168,   169,   170,
+     171,   172,   173,   174,   175,   176,   177,   178,     0,   179,
+     180,   181,   182,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   153,
+     111,   367,     0,     0,   184,   185,     0,   154,   155,   156,
+     157,   158,   159,   160,   161,   162,   163,   164,     0,   165,
+     166,   167,   168,   169,   170,   171,   172,   173,   174,   175,
+     176,   177,   178,     0,   179,   180,   181,   182,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   153,     0,   402,     0,     0,     0,   184,
+     185,   154,   155,   156,   157,   158,   159,   160,   161,   162,
+     163,   164,     0,   165,   166,   167,   168,   169,   170,   171,
+     172,   173,   174,   175,   176,   177,   178,     0,   179,   180,
+     181,   182,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   153,     0,   403,
+       0,     0,     0,   184,   185,   154,   155,   156,   157,   158,
+     159,   160,   161,   162,   163,   164,     0,   165,   166,   167,
+     168,   169,   170,   171,   172,   173,   174,   175,   176,   177,
+     178,     0,   179,   180,   181,   182,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,   153,     0,     0,   408,     0,     0,   184,   185,   154,
+     155,   156,   157,   158,   159,   160,   161,   162,   163,   164,
+       0,   165,   166,   167,   168,   169,   170,   171,   172,   173,
+     174,   175,   176,   177,   178,     0,   179,   180,   181,   182,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   153,     0,     0,     0,     0,
+       0,   184,   185,   154,   155,   156,   157,   158,   159,   160,
+     161,   162,   163,   164,     0,   165,   166,   167,   168,   169,
+     170,   171,   172,   173,   174,   175,   176,   177,   178,     0,
+     179,   180,   181,   182,     0,   412,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   153,
+       0,     0,     0,     0,     0,   184,   185,   154,   155,   156,
+     157,   158,   159,   160,   161,   162,   163,   164,     0,   165,
+     166,   167,   168,   169,   170,   171,   172,   173,   174,   175,
+     176,   177,   178,     0,   179,   180,   181,   182,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   184,
+     185
+};
+
+static const yytype_int16 yycheck[] =
+{
+       0,   110,     4,    89,     4,     5,     6,    54,   228,     9,
+      10,    11,    12,     4,     4,     4,    93,     9,     6,     4,
+     244,     4,   246,    23,    63,     4,    23,    57,     6,     6,
+      54,    78,    57,    73,    57,    35,     6,     7,    11,     6,
+      80,    57,    42,    13,    44,    45,    46,    63,     6,    74,
+      97,    74,    99,    39,    54,     5,    42,     6,     7,    78,
+      79,    61,    62,    63,    13,     9,   113,   114,    15,    69,
+      57,    10,    10,    97,    51,    99,     6,     7,    78,    79,
+      80,    73,     8,    13,    51,    10,    74,    74,    80,    89,
+     114,    91,    92,    93,   242,    73,   135,    97,    75,    99,
+     248,    74,   102,   103,    74,   152,    76,     0,   108,   111,
+     110,   111,   198,   113,   114,   115,   202,    66,   342,    68,
+     111,   111,   111,   123,   124,    72,   111,    76,   111,    73,
+      10,   131,   111,     6,     7,   135,    57,    72,    10,    74,
+      13,    10,    74,    73,    50,   131,    76,     6,     7,    72,
+      80,   151,   152,    74,    13,    72,     3,     4,     5,     6,
+       7,   300,     9,   302,   211,    12,    48,    14,   215,    72,
+      72,    72,    19,    48,    48,    73,    23,    10,    75,    10,
+      27,   258,    10,   183,   184,   185,   183,   211,   408,    75,
+      79,     5,    16,    17,    18,    73,   196,   197,   198,   199,
+      47,   201,   202,    76,   204,   314,    48,    54,    74,    56,
+     210,   211,    77,    72,   261,   215,     8,    76,    48,    75,
+      73,   221,    74,    48,    73,    72,   228,    10,   228,    76,
+      77,    78,    10,     6,     7,     8,    10,   228,   228,   228,
+      13,    10,   242,   228,   244,   228,   246,    37,   248,   228,
+      10,    10,     6,    43,    78,    79,    75,    47,   258,     6,
+       7,   261,     6,     7,    74,    74,    13,    11,    10,    13,
+      73,    15,    48,   259,    73,    75,    80,    73,    68,    10,
+      70,    71,    72,    73,    74,   191,     6,     7,    78,    64,
+       6,     7,     8,    13,    58,    15,    50,    13,    52,    53,
+     300,    58,   302,    76,   351,   305,    58,    75,    75,    75,
+      73,   217,    62,    11,   314,    69,    70,    71,    58,    75,
+      75,   111,    66,   113,    68,    73,    73,   327,    72,    76,
+      75,   215,    76,   351,    75,   241,   412,   370,   381,   383,
+     340,   404,   342,   314,     4,   340,    66,   135,    68,   377,
+      -1,   351,    72,    -1,   144,    -1,    76,    -1,    -1,   359,
+      76,    -1,    -1,   153,   154,   155,   156,   157,   158,   159,
+     160,   161,   162,   163,   164,   165,   166,   167,   168,   169,
+     170,   171,   172,   173,   174,   175,   176,   177,   178,   179,
+     180,   181,   182,   393,    35,    -1,   393,    -1,    -1,    -1,
+     306,    42,    -1,    44,    45,    46,   408,    -1,   408,    -1,
+      -1,   317,    -1,    -1,     6,     7,   322,   408,   408,   408,
+      61,    13,    -1,   408,   214,   408,   216,    -1,   218,   408,
+      -1,    -1,    -1,    -1,    -1,     6,     7,    -1,   228,    80,
+      -1,    -1,    13,   349,     6,     7,    -1,    -1,    89,    -1,
+      91,    13,    -1,    16,    17,    18,    19,    20,    -1,    -1,
+      -1,   102,   368,    -1,   370,    -1,    -1,   108,    -1,    -1,
+      -1,   261,    -1,   379,    66,   381,    68,    46,    -1,    -1,
+      72,    -1,     0,     1,    76,    54,    -1,    -1,     6,    -1,
+      -1,    -1,    10,    62,    63,    66,    -1,    68,   404,    -1,
+     406,    72,    -1,   409,    66,    76,    68,    -1,    -1,    78,
+      72,   301,    74,    -1,    76,    78,    79,    -1,    -1,    -1,
+      89,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    97,    -1,
+      99,    49,    50,    -1,    52,    53,   326,    -1,    -1,    -1,
+      -1,    -1,    -1,   184,   113,   114,    -1,    -1,    -1,    -1,
+      68,    69,    70,    71,    -1,   196,   197,   198,    -1,    -1,
+     201,   202,    -1,   204,    -1,    -1,   135,    -1,     1,    -1,
+      -1,    -1,    -1,     6,   364,    -1,   366,    10,    16,    17,
+      18,    19,    20,   152,    22,    23,    24,    -1,    -1,    -1,
+      -1,    -1,   382,    -1,    -1,    -1,    34,    35,   388,    -1,
+      -1,   242,    -1,    -1,    -1,    -1,    -1,   248,    -1,    -1,
+      -1,    -1,   402,    -1,    -1,    -1,    49,    50,   408,    52,
+      53,    -1,   412,    -1,    -1,    -1,    -1,    -1,    -1,   198,
+      -1,    -1,    -1,   202,    -1,    68,    69,    70,    71,    -1,
+      78,    79,   211,    -1,    -1,    -1,   215,    -1,    -1,    -1,
+       1,    -1,     3,     4,     5,     6,     7,    -1,     9,    10,
+      -1,    12,    -1,    14,    -1,    -1,    -1,    -1,    19,    -1,
+      -1,    -1,    23,    -1,    -1,   244,    27,   246,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   261,    -1,    -1,    -1,    47,    -1,    -1,    50,
+      -1,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
+      61,    62,    63,    64,    65,    -1,    67,    68,   359,    70,
+      71,    72,    -1,    74,    75,    76,    -1,    78,    -1,    -1,
+      -1,    -1,     1,    -1,     3,     4,     5,     6,     7,    -1,
+       9,    10,    -1,    12,    -1,    14,    -1,    -1,    -1,    -1,
+      19,    -1,    -1,    -1,    23,    -1,    -1,    -1,    27,    -1,
+      -1,    16,    17,    18,    19,    20,    -1,    22,    23,    -1,
+      -1,   340,    -1,   342,    -1,    -1,    -1,    -1,    47,    34,
+      35,    50,   351,    52,    53,    54,    55,    56,    57,    -1,
+      59,    60,    61,    -1,    63,    64,    65,    -1,    67,    68,
+      -1,    70,    71,    72,    -1,    74,    75,    76,     1,    78,
+       3,     4,     5,     6,     7,    -1,     9,    10,    -1,    12,
+      -1,    14,    -1,    78,    79,    -1,    19,    -1,    -1,    -1,
+      23,    -1,    -1,    -1,    27,    -1,    -1,    16,    17,    18,
+      19,    20,    -1,    22,    23,    24,    -1,    -1,    -1,    28,
+      29,    30,    31,    -1,    47,    34,    35,    50,    -1,    52,
+      53,    54,    55,    56,    57,    -1,    59,    60,    61,    -1,
+      63,    64,    65,    -1,    67,    68,    -1,    70,    71,    72,
+      -1,    74,    -1,    76,    -1,    78,     3,     4,     5,     6,
+       7,    -1,     9,    -1,    -1,    12,    -1,    14,    -1,    78,
+      79,    -1,    19,    -1,    -1,    -1,    23,    -1,    -1,    -1,
+      27,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,
+       5,     6,     7,    -1,     9,    -1,    -1,    12,    -1,    14,
+      47,    -1,    -1,    -1,    19,    -1,    -1,    54,    23,    56,
+      57,    -1,    27,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    72,    73,    -1,    -1,    76,
+      -1,    78,    47,    -1,     3,     4,     5,     6,     7,    54,
+       9,    56,    57,    12,    -1,    14,    -1,    -1,    -1,    -1,
+      19,    -1,    -1,    -1,    23,    -1,    -1,    72,    27,    -1,
+      -1,    76,    -1,    78,    -1,    -1,     3,     4,     5,     6,
+       7,    -1,     9,    10,    -1,    12,    -1,    14,    47,    -1,
+      -1,    -1,    19,    -1,    -1,    54,    23,    56,    57,    -1,
+      27,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     0,     1,
+      -1,    -1,    -1,    72,     6,    -1,    -1,    76,    10,    78,
+      47,    -1,     3,     4,     5,     6,     7,    54,     9,    56,
+      -1,    12,    -1,    14,    -1,    -1,    -1,    -1,    19,    -1,
+      -1,    -1,    23,    -1,    -1,    72,    27,    -1,    -1,    76,
+      -1,    78,    -1,    -1,    -1,    -1,    -1,    49,    50,    -1,
+      52,    53,    -1,    -1,    -1,    -1,    47,    16,    17,    18,
+      19,    20,    -1,    54,    23,    56,    68,    69,    70,    71,
+      -1,    -1,    -1,    75,    -1,    34,    35,    -1,    -1,    -1,
+       8,    72,    -1,    -1,    -1,    76,    -1,    78,    16,    17,
+      18,    19,    20,    21,    22,    23,    24,    25,    26,    -1,
+      28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
+      38,    39,    40,    41,    -1,    43,    44,    45,    46,    78,
+      79,    16,    17,    18,    19,    20,    -1,    22,    23,    24,
+      25,    26,    -1,    28,    29,    30,    31,    32,    33,    34,
+      35,    -1,    -1,    -1,     8,    -1,    74,    -1,    -1,    -1,
+      78,    79,    16,    17,    18,    19,    20,    21,    22,    23,
+      24,    25,    26,    -1,    28,    29,    30,    31,    32,    33,
+      34,    35,    36,    37,    38,    39,    40,    41,    -1,    43,
+      44,    45,    46,    78,    79,    16,    17,    18,    19,    20,
+      -1,    22,    23,    24,    25,    -1,    -1,    28,    29,    30,
+      31,    32,    33,    34,    35,    -1,    -1,    -1,     8,    -1,
+      -1,    -1,    -1,    77,    78,    79,    16,    17,    18,    19,
+      20,    21,    22,    23,    24,    25,    26,    -1,    28,    29,
+      30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
+      40,    41,    -1,    43,    44,    45,    46,    78,    79,    16,
+      17,    18,    19,    20,    -1,    22,    23,    24,    -1,    -1,
+      -1,    28,    29,    30,    31,    32,    33,    34,    35,    -1,
+      -1,    -1,     8,    73,    10,    -1,    -1,    -1,    78,    79,
+      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+      26,    -1,    28,    29,    30,    31,    32,    33,    34,    35,
+      36,    37,    38,    39,    40,    41,    -1,    43,    44,    45,
+      46,    78,    79,    16,    17,    18,    19,    20,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    34,    35,    -1,    -1,    -1,     8,    -1,    -1,    -1,
+      -1,    -1,    78,    79,    16,    17,    18,    19,    20,    21,
+      22,    23,    24,    25,    26,    -1,    28,    29,    30,    31,
+      32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
+      -1,    43,    44,    45,    46,    78,    79,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+       8,    73,    -1,    -1,    -1,    -1,    78,    79,    16,    17,
+      18,    19,    20,    21,    22,    23,    24,    25,    26,    -1,
+      28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
+      38,    39,    40,    41,    -1,    43,    44,    45,    46,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,     8,    -1,    74,    -1,    -1,    -1,
+      78,    79,    16,    17,    18,    19,    20,    21,    22,    23,
+      24,    25,    26,    -1,    28,    29,    30,    31,    32,    33,
+      34,    35,    36,    37,    38,    39,    40,    41,    -1,    43,
+      44,    45,    46,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     8,
+      74,    10,    -1,    -1,    78,    79,    -1,    16,    17,    18,
+      19,    20,    21,    22,    23,    24,    25,    26,    -1,    28,
+      29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
+      39,    40,    41,    -1,    43,    44,    45,    46,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,     8,    -1,    10,    -1,    -1,    -1,    78,
+      79,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+      25,    26,    -1,    28,    29,    30,    31,    32,    33,    34,
+      35,    36,    37,    38,    39,    40,    41,    -1,    43,    44,
+      45,    46,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,     8,    -1,    10,
+      -1,    -1,    -1,    78,    79,    16,    17,    18,    19,    20,
+      21,    22,    23,    24,    25,    26,    -1,    28,    29,    30,
+      31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
+      41,    -1,    43,    44,    45,    46,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,     8,    -1,    -1,    11,    -1,    -1,    78,    79,    16,
+      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+      -1,    28,    29,    30,    31,    32,    33,    34,    35,    36,
+      37,    38,    39,    40,    41,    -1,    43,    44,    45,    46,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,     8,    -1,    -1,    -1,    -1,
+      -1,    78,    79,    16,    17,    18,    19,    20,    21,    22,
+      23,    24,    25,    26,    -1,    28,    29,    30,    31,    32,
+      33,    34,    35,    36,    37,    38,    39,    40,    41,    -1,
+      43,    44,    45,    46,    -1,    48,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     8,
+      -1,    -1,    -1,    -1,    -1,    78,    79,    16,    17,    18,
+      19,    20,    21,    22,    23,    24,    25,    26,    -1,    28,
+      29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
+      39,    40,    41,    -1,    43,    44,    45,    46,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    78,
+      79
+};
+
+/* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of
+   state STATE-NUM.  */
+static const yytype_uint8 yystos[] =
+{
+       0,     1,     6,    10,    49,    50,    52,    53,    68,    69,
+      70,    71,    82,    83,    85,   102,   119,   120,   121,   127,
+     131,   132,   135,   137,   138,   139,    83,    85,   102,   121,
+     127,   131,   132,   135,    82,    82,     5,    57,   136,    82,
+      82,    82,     7,    13,    66,    68,    72,    76,    82,   114,
+     115,   118,    10,    10,     8,    10,   138,     0,    10,    10,
+      10,    72,    74,    74,   118,     3,     4,     5,     7,     9,
+      12,    14,    19,    23,    27,    47,    54,    56,    72,    76,
+      78,    82,    84,    86,    87,    92,    93,    94,   122,    72,
+     114,    11,    74,    72,   114,   118,    94,     8,   118,     8,
+     118,    73,    80,    82,    90,    91,   118,   119,    77,    94,
+      72,    74,   100,    23,    57,    82,    94,   104,   105,   119,
+     120,   118,   130,    51,    82,   119,   123,   124,   125,   126,
+      75,    82,   116,   119,   125,   128,   129,    94,    82,    94,
+      94,    94,    94,    94,    72,    72,    94,   120,    82,   101,
+     118,    15,    72,     8,    16,    17,    18,    19,    20,    21,
+      22,    23,    24,    25,    26,    28,    29,    30,    31,    32,
+      33,    34,    35,    36,    37,    38,    39,    40,    41,    43,
+      44,    45,    46,    74,    78,    79,    91,   118,    82,   133,
+     134,    73,   101,   104,   104,   118,    66,    68,    48,     9,
+      73,    80,    48,   118,    77,    82,   116,   117,     1,    10,
+      55,    57,    59,    60,    61,    63,    64,    65,    67,    68,
+      75,    82,    83,    85,    94,    95,    96,    97,    98,    99,
+     100,   102,   106,   107,   110,   113,   127,   131,   132,   135,
+     120,   104,    48,    73,    74,    82,    10,    75,    74,   114,
+      10,    10,   129,    75,    94,     5,    73,    73,    48,    77,
+      82,    23,    73,    88,    89,   104,   119,    94,    94,    94,
+      94,    94,    94,    94,    94,    94,    94,    94,    94,    94,
+      94,    94,    94,    94,    94,    94,    94,    94,    94,    94,
+      94,    94,    94,    94,    94,    94,    94,   138,   118,    82,
+      74,     8,    48,    75,   100,     9,    73,    73,    91,    82,
+      73,   118,    91,   118,    48,    73,    82,   104,    10,    10,
+      94,    88,    94,   100,    10,    94,    57,    63,   111,   112,
+      11,    10,    10,    10,    10,    99,    75,    10,   100,   130,
+      74,   124,    74,   124,   130,    10,    73,    73,   101,   114,
+     119,    48,    73,    75,   134,    94,   134,    82,   100,    80,
+      73,   117,   100,    74,    10,   100,    64,    10,    94,    82,
+      58,   126,    75,   124,    75,   100,    89,    58,    75,    73,
+     118,    58,    62,   108,   109,    94,    94,   100,    11,   100,
+     105,    75,    75,    74,   136,   100,    73,   100,   106,    94,
+     109,    75,    10,    10,    58,    94,   103,   138,    11,    94,
+     100,   112,    48,   100,    75,    99,   100,   103
+};
+
+/* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM.  */
+static const yytype_uint8 yyr1[] =
+{
+       0,    81,    82,    83,    83,    84,    85,    86,    86,    86,
+      86,    86,    86,    86,    86,    86,    86,    86,    86,    86,
+      86,    86,    86,    86,    86,    86,    86,    86,    86,    86,
+      86,    86,    86,    86,    86,    86,    86,    87,    87,    87,
+      87,    87,    88,    88,    88,    89,    89,    90,    91,    91,
+      91,    91,    92,    92,    93,    94,    94,    94,    94,    94,
+      94,    94,    94,    94,    94,    94,    94,    94,    94,    94,
+      94,    94,    94,    94,    95,    96,    97,    98,    98,    98,
+      98,    98,    98,    98,    98,    98,    98,    98,    98,    98,
+      98,    98,    98,    98,    98,    98,    98,    98,    98,    98,
+      99,    99,   100,   100,   101,   101,   102,   102,   102,   103,
+     103,   104,   104,   104,   104,   105,   105,   106,   106,   106,
+     107,   108,   109,   109,   110,   111,   112,   112,   112,   113,
+     113,   114,   114,   114,   114,   114,   115,   115,   116,   116,
+     117,   117,   118,   118,   118,   118,   118,   118,   118,   119,
+     119,   119,   120,   120,   120,   121,   121,   122,   123,   123,
+     124,   124,   125,   125,   126,   127,   127,   128,   128,   128,
+     128,   129,   129,   130,   130,   131,   132,   132,   133,   133,
+     134,   134,   134,   135,   135,   136,   136,   136,   137,   137,
+     137,   137,   137,   137,   137,   137,   137,   137,   137,   137,
+     137,   137,   137,   137,   137,   137,   137,   138,   138,   139,
+     139
+};
+
+/* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM.  */
+static const yytype_int8 yyr2[] =
+{
+       0,     2,     1,     1,     1,     4,     2,     3,     3,     3,
+       3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
+       3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
+       3,     3,     3,     3,     3,     3,     3,     2,     2,     2,
+       2,     2,     2,     1,     1,     3,     1,     1,     3,     3,
+       1,     1,     4,     3,     4,     1,     3,     3,     2,     1,
+       1,     1,     1,     3,     1,     1,     1,     1,     3,     2,
+       3,     2,     1,     1,     3,     5,     2,     2,     3,     2,
+       2,     2,     2,     2,     1,     2,     2,     1,     1,     1,
+       1,     1,     1,     1,     2,     1,     1,     1,     1,     1,
+       2,     1,     3,     2,     3,     1,     6,     8,     5,     3,
+       1,     1,     1,     2,     1,     5,     5,     3,     5,     5,
+       7,     4,     2,     1,     5,     5,     3,     5,     5,     2,
+       2,     5,     3,     4,     4,     2,     1,     7,     4,     1,
+       3,     1,     1,     2,     4,     2,     3,     4,     2,     3,
+       3,     2,     3,     4,     4,     3,     3,     5,     1,     1,
+       3,     2,     5,     4,     1,     5,     8,     2,     3,     2,
+       1,     2,     1,     3,     1,     3,     5,     4,     1,     3,
+       3,     2,     1,     7,     5,     5,     9,     7,     1,     1,
+       1,     1,     1,     2,     2,     2,     1,     2,     2,     2,
+       2,     3,     3,     2,     2,     3,     1,     1,     2,     1,
+       0
+};
+
+
+enum { YYENOMEM = -2 };
+
+#define yyerrok         (yyerrstatus = 0)
+#define yyclearin       (yychar = YYEMPTY)
+
+#define YYACCEPT        goto yyacceptlab
+#define YYABORT         goto yyabortlab
+#define YYERROR         goto yyerrorlab
+#define YYNOMEM         goto yyexhaustedlab
+
+
+#define YYRECOVERING()  (!!yyerrstatus)
+
+#define YYBACKUP(Token, Value)                                    \
+  do                                                              \
+    if (yychar == YYEMPTY)                                        \
+      {                                                           \
+        yychar = (Token);                                         \
+        yylval = (Value);                                         \
+        YYPOPSTACK (yylen);                                       \
+        yystate = *yyssp;                                         \
+        goto yybackup;                                            \
+      }                                                           \
+    else                                                          \
+      {                                                           \
+        yyerror (&yylloc, scanner, parser, YY_("syntax error: cannot back up")); \
+        YYERROR;                                                  \
+      }                                                           \
+  while (0)
+
+/* Backward compatibility with an undocumented macro.
+   Use YYerror or YYUNDEF. */
+#define YYERRCODE YYUNDEF
+
+/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
+   If N is 0, then set CURRENT to the empty location which ends
+   the previous symbol: RHS[0] (always defined).  */
+
+#ifndef YYLLOC_DEFAULT
+# define YYLLOC_DEFAULT(Current, Rhs, N)                                \
+    do                                                                  \
+      if (N)                                                            \
+        {                                                               \
+          (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
+          (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
+          (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
+          (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
+        }                                                               \
+      else                                                              \
+        {                                                               \
+          (Current).first_line   = (Current).last_line   =              \
+            YYRHSLOC (Rhs, 0).last_line;                                \
+          (Current).first_column = (Current).last_column =              \
+            YYRHSLOC (Rhs, 0).last_column;                              \
+        }                                                               \
+    while (0)
+#endif
+
+#define YYRHSLOC(Rhs, K) ((Rhs)[K])
+
+
+/* Enable debugging if requested.  */
+#if YYDEBUG
+
+# ifndef YYFPRINTF
+#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
+#  define YYFPRINTF fprintf
+# endif
+
+# define YYDPRINTF(Args)                        \
+do {                                            \
+  if (yydebug)                                  \
+    YYFPRINTF Args;                             \
+} while (0)
+
+
+/* YYLOCATION_PRINT -- Print the location on the stream.
+   This macro was not mandated originally: define only if we know
+   we won't break user code: when these are the locations we know.  */
+
+# ifndef YYLOCATION_PRINT
+
+#  if defined YY_LOCATION_PRINT
+
+   /* Temporary convenience wrapper in case some people defined the
+      undocumented and private YY_LOCATION_PRINT macros.  */
+#   define YYLOCATION_PRINT(File, Loc)  YY_LOCATION_PRINT(File, *(Loc))
+
+#  elif defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
+
+/* Print *YYLOCP on YYO.  Private, do not rely on its existence. */
+
+YY_ATTRIBUTE_UNUSED
+static int
+yy_location_print_ (FILE *yyo, YYLTYPE const * const yylocp)
+{
+  int res = 0;
+  int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0;
+  if (0 <= yylocp->first_line)
+    {
+      res += YYFPRINTF (yyo, "%d", yylocp->first_line);
+      if (0 <= yylocp->first_column)
+        res += YYFPRINTF (yyo, ".%d", yylocp->first_column);
+    }
+  if (0 <= yylocp->last_line)
+    {
+      if (yylocp->first_line < yylocp->last_line)
+        {
+          res += YYFPRINTF (yyo, "-%d", yylocp->last_line);
+          if (0 <= end_col)
+            res += YYFPRINTF (yyo, ".%d", end_col);
+        }
+      else if (0 <= end_col && yylocp->first_column < end_col)
+        res += YYFPRINTF (yyo, "-%d", end_col);
+    }
+  return res;
+}
+
+#   define YYLOCATION_PRINT  yy_location_print_
+
+    /* Temporary convenience wrapper in case some people defined the
+       undocumented and private YY_LOCATION_PRINT macros.  */
+#   define YY_LOCATION_PRINT(File, Loc)  YYLOCATION_PRINT(File, &(Loc))
+
+#  else
+
+#   define YYLOCATION_PRINT(File, Loc) ((void) 0)
+    /* Temporary convenience wrapper in case some people defined the
+       undocumented and private YY_LOCATION_PRINT macros.  */
+#   define YY_LOCATION_PRINT  YYLOCATION_PRINT
+
+#  endif
+# endif /* !defined YYLOCATION_PRINT */
+
+
+# define YY_SYMBOL_PRINT(Title, Kind, Value, Location)                    \
+do {                                                                      \
+  if (yydebug)                                                            \
+    {                                                                     \
+      YYFPRINTF (stderr, "%s ", Title);                                   \
+      yy_symbol_print (stderr,                                            \
+                  Kind, Value, Location, scanner, parser); \
+      YYFPRINTF (stderr, "\n");                                           \
+    }                                                                     \
+} while (0)
+
+
+/*-----------------------------------.
+| Print this symbol's value on YYO.  |
+`-----------------------------------*/
+
+static void
+yy_symbol_value_print (FILE *yyo,
+                       yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, void *scanner, struct parser* parser)
+{
+  FILE *yyoutput = yyo;
+  YY_USE (yyoutput);
+  YY_USE (yylocationp);
+  YY_USE (scanner);
+  YY_USE (parser);
+  if (!yyvaluep)
+    return;
+  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+  YY_USE (yykind);
+  YY_IGNORE_MAYBE_UNINITIALIZED_END
+}
+
+
+/*---------------------------.
+| Print this symbol on YYO.  |
+`---------------------------*/
+
+static void
+yy_symbol_print (FILE *yyo,
+                 yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, void *scanner, struct parser* parser)
+{
+  YYFPRINTF (yyo, "%s %s (",
+             yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind));
+
+  YYLOCATION_PRINT (yyo, yylocationp);
+  YYFPRINTF (yyo, ": ");
+  yy_symbol_value_print (yyo, yykind, yyvaluep, yylocationp, scanner, parser);
+  YYFPRINTF (yyo, ")");
+}
+
+/*------------------------------------------------------------------.
+| yy_stack_print -- Print the state stack from its BOTTOM up to its |
+| TOP (included).                                                   |
+`------------------------------------------------------------------*/
+
+static void
+yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
+{
+  YYFPRINTF (stderr, "Stack now");
+  for (; yybottom <= yytop; yybottom++)
+    {
+      int yybot = *yybottom;
+      YYFPRINTF (stderr, " %d", yybot);
+    }
+  YYFPRINTF (stderr, "\n");
+}
+
+# define YY_STACK_PRINT(Bottom, Top)                            \
+do {                                                            \
+  if (yydebug)                                                  \
+    yy_stack_print ((Bottom), (Top));                           \
+} while (0)
+
+
+/*------------------------------------------------.
+| Report that the YYRULE is going to be reduced.  |
+`------------------------------------------------*/
+
+static void
+yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, YYLTYPE *yylsp,
+                 int yyrule, void *scanner, struct parser* parser)
+{
+  int yylno = yyrline[yyrule];
+  int yynrhs = yyr2[yyrule];
+  int yyi;
+  YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
+             yyrule - 1, yylno);
+  /* The symbols being reduced.  */
+  for (yyi = 0; yyi < yynrhs; yyi++)
+    {
+      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
+      yy_symbol_print (stderr,
+                       YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]),
+                       &yyvsp[(yyi + 1) - (yynrhs)],
+                       &(yylsp[(yyi + 1) - (yynrhs)]), scanner, parser);
+      YYFPRINTF (stderr, "\n");
+    }
+}
+
+# define YY_REDUCE_PRINT(Rule)          \
+do {                                    \
+  if (yydebug)                          \
+    yy_reduce_print (yyssp, yyvsp, yylsp, Rule, scanner, parser); \
+} while (0)
+
+/* Nonzero means print parse trace.  It is left uninitialized so that
+   multiple parsers can coexist.  */
+int yydebug;
+#else /* !YYDEBUG */
+# define YYDPRINTF(Args) ((void) 0)
+# define YY_SYMBOL_PRINT(Title, Kind, Value, Location)
+# define YY_STACK_PRINT(Bottom, Top)
+# define YY_REDUCE_PRINT(Rule)
+#endif /* !YYDEBUG */
+
+
+/* YYINITDEPTH -- initial size of the parser's stacks.  */
+#ifndef YYINITDEPTH
+# define YYINITDEPTH 200
+#endif
+
+/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
+   if the built-in stack extension method is used).
+
+   Do not make this value too large; the results are undefined if
+   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
+   evaluated with infinite-precision integer arithmetic.  */
+
+#ifndef YYMAXDEPTH
+# define YYMAXDEPTH 10000
+#endif
+
+
+/* Context of a parse error.  */
+typedef struct
+{
+  yy_state_t *yyssp;
+  yysymbol_kind_t yytoken;
+  YYLTYPE *yylloc;
+} yypcontext_t;
+
+/* Put in YYARG at most YYARGN of the expected tokens given the
+   current YYCTX, and return the number of tokens stored in YYARG.  If
+   YYARG is null, return the number of expected tokens (guaranteed to
+   be less than YYNTOKENS).  Return YYENOMEM on memory exhaustion.
+   Return 0 if there are more than YYARGN expected tokens, yet fill
+   YYARG up to YYARGN. */
+static int
+yypcontext_expected_tokens (const yypcontext_t *yyctx,
+                            yysymbol_kind_t yyarg[], int yyargn)
+{
+  /* Actual size of YYARG. */
+  int yycount = 0;
+  int yyn = yypact[+*yyctx->yyssp];
+  if (!yypact_value_is_default (yyn))
+    {
+      /* Start YYX at -YYN if negative to avoid negative indexes in
+         YYCHECK.  In other words, skip the first -YYN actions for
+         this state because they are default actions.  */
+      int yyxbegin = yyn < 0 ? -yyn : 0;
+      /* Stay within bounds of both yycheck and yytname.  */
+      int yychecklim = YYLAST - yyn + 1;
+      int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
+      int yyx;
+      for (yyx = yyxbegin; yyx < yyxend; ++yyx)
+        if (yycheck[yyx + yyn] == yyx && yyx != YYSYMBOL_YYerror
+            && !yytable_value_is_error (yytable[yyx + yyn]))
+          {
+            if (!yyarg)
+              ++yycount;
+            else if (yycount == yyargn)
+              return 0;
+            else
+              yyarg[yycount++] = YY_CAST (yysymbol_kind_t, yyx);
+          }
+    }
+  if (yyarg && yycount == 0 && 0 < yyargn)
+    yyarg[0] = YYSYMBOL_YYEMPTY;
+  return yycount;
+}
+
+
+
+
+#ifndef yystrlen
+# if defined __GLIBC__ && defined _STRING_H
+#  define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S)))
+# else
+/* Return the length of YYSTR.  */
+static YYPTRDIFF_T
+yystrlen (const char *yystr)
+{
+  YYPTRDIFF_T yylen;
+  for (yylen = 0; yystr[yylen]; yylen++)
+    continue;
+  return yylen;
+}
+# endif
+#endif
+
+#ifndef yystpcpy
+# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
+#  define yystpcpy stpcpy
+# else
+/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
+   YYDEST.  */
+static char *
+yystpcpy (char *yydest, const char *yysrc)
+{
+  char *yyd = yydest;
+  const char *yys = yysrc;
+
+  while ((*yyd++ = *yys++) != '\0')
+    continue;
+
+  return yyd - 1;
+}
+# endif
+#endif
+
+#ifndef yytnamerr
+/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
+   quotes and backslashes, so that it's suitable for yyerror.  The
+   heuristic is that double-quoting is unnecessary unless the string
+   contains an apostrophe, a comma, or backslash (other than
+   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
+   null, do not copy; instead, return the length of what the result
+   would have been.  */
+static YYPTRDIFF_T
+yytnamerr (char *yyres, const char *yystr)
+{
+  if (*yystr == '"')
+    {
+      YYPTRDIFF_T yyn = 0;
+      char const *yyp = yystr;
+      for (;;)
+        switch (*++yyp)
+          {
+          case '\'':
+          case ',':
+            goto do_not_strip_quotes;
+
+          case '\\':
+            if (*++yyp != '\\')
+              goto do_not_strip_quotes;
+            else
+              goto append;
+
+          append:
+          default:
+            if (yyres)
+              yyres[yyn] = *yyp;
+            yyn++;
+            break;
+
+          case '"':
+            if (yyres)
+              yyres[yyn] = '\0';
+            return yyn;
+          }
+    do_not_strip_quotes: ;
+    }
+
+  if (yyres)
+    return yystpcpy (yyres, yystr) - yyres;
+  else
+    return yystrlen (yystr);
+}
+#endif
+
+
+static int
+yy_syntax_error_arguments (const yypcontext_t *yyctx,
+                           yysymbol_kind_t yyarg[], int yyargn)
+{
+  /* Actual size of YYARG. */
+  int yycount = 0;
+  /* There are many possibilities here to consider:
+     - If this state is a consistent state with a default action, then
+       the only way this function was invoked is if the default action
+       is an error action.  In that case, don't check for expected
+       tokens because there are none.
+     - The only way there can be no lookahead present (in yychar) is if
+       this state is a consistent state with a default action.  Thus,
+       detecting the absence of a lookahead is sufficient to determine
+       that there is no unexpected or expected token to report.  In that
+       case, just report a simple "syntax error".
+     - Don't assume there isn't a lookahead just because this state is a
+       consistent state with a default action.  There might have been a
+       previous inconsistent state, consistent state with a non-default
+       action, or user semantic action that manipulated yychar.
+     - Of course, the expected token list depends on states to have
+       correct lookahead information, and it depends on the parser not
+       to perform extra reductions after fetching a lookahead from the
+       scanner and before detecting a syntax error.  Thus, state merging
+       (from LALR or IELR) and default reductions corrupt the expected
+       token list.  However, the list is correct for canonical LR with
+       one exception: it will still contain any token that will not be
+       accepted due to an error action in a later state.
+  */
+  if (yyctx->yytoken != YYSYMBOL_YYEMPTY)
+    {
+      int yyn;
+      if (yyarg)
+        yyarg[yycount] = yyctx->yytoken;
+      ++yycount;
+      yyn = yypcontext_expected_tokens (yyctx,
+                                        yyarg ? yyarg + 1 : yyarg, yyargn - 1);
+      if (yyn == YYENOMEM)
+        return YYENOMEM;
+      else
+        yycount += yyn;
+    }
+  return yycount;
+}
+
+/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
+   about the unexpected token YYTOKEN for the state stack whose top is
+   YYSSP.
+
+   Return 0 if *YYMSG was successfully written.  Return -1 if *YYMSG is
+   not large enough to hold the message.  In that case, also set
+   *YYMSG_ALLOC to the required number of bytes.  Return YYENOMEM if the
+   required number of bytes is too large to store.  */
+static int
+yysyntax_error (YYPTRDIFF_T *yymsg_alloc, char **yymsg,
+                const yypcontext_t *yyctx)
+{
+  enum { YYARGS_MAX = 5 };
+  /* Internationalized format string. */
+  const char *yyformat = YY_NULLPTR;
+  /* Arguments of yyformat: reported tokens (one for the "unexpected",
+     one per "expected"). */
+  yysymbol_kind_t yyarg[YYARGS_MAX];
+  /* Cumulated lengths of YYARG.  */
+  YYPTRDIFF_T yysize = 0;
+
+  /* Actual size of YYARG. */
+  int yycount = yy_syntax_error_arguments (yyctx, yyarg, YYARGS_MAX);
+  if (yycount == YYENOMEM)
+    return YYENOMEM;
+
+  switch (yycount)
+    {
+#define YYCASE_(N, S)                       \
+      case N:                               \
+        yyformat = S;                       \
+        break
+    default: /* Avoid compiler warnings. */
+      YYCASE_(0, YY_("syntax error"));
+      YYCASE_(1, YY_("syntax error, unexpected %s"));
+      YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
+      YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
+      YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
+      YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
+#undef YYCASE_
+    }
+
+  /* Compute error message size.  Don't count the "%s"s, but reserve
+     room for the terminator.  */
+  yysize = yystrlen (yyformat) - 2 * yycount + 1;
+  {
+    int yyi;
+    for (yyi = 0; yyi < yycount; ++yyi)
+      {
+        YYPTRDIFF_T yysize1
+          = yysize + yytnamerr (YY_NULLPTR, yytname[yyarg[yyi]]);
+        if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
+          yysize = yysize1;
+        else
+          return YYENOMEM;
+      }
+  }
+
+  if (*yymsg_alloc < yysize)
+    {
+      *yymsg_alloc = 2 * yysize;
+      if (! (yysize <= *yymsg_alloc
+             && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
+        *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
+      return -1;
+    }
+
+  /* Avoid sprintf, as that infringes on the user's name space.
+     Don't have undefined behavior even if the translation
+     produced a string with the wrong number of "%s"s.  */
+  {
+    char *yyp = *yymsg;
+    int yyi = 0;
+    while ((*yyp = *yyformat) != '\0')
+      if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
+        {
+          yyp += yytnamerr (yyp, yytname[yyarg[yyi++]]);
+          yyformat += 2;
+        }
+      else
+        {
+          ++yyp;
+          ++yyformat;
+        }
+  }
+  return 0;
+}
+
+
+/*-----------------------------------------------.
+| Release the memory associated to this symbol.  |
+`-----------------------------------------------*/
+
+static void
+yydestruct (const char *yymsg,
+            yysymbol_kind_t yykind, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, void *scanner, struct parser* parser)
+{
+  YY_USE (yyvaluep);
+  YY_USE (yylocationp);
+  YY_USE (scanner);
+  YY_USE (parser);
+  if (!yymsg)
+    yymsg = "Deleting";
+  YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp);
+
+  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+  switch (yykind)
+    {
+    case YYSYMBOL_INT: /* INT  */
+#line 141 "src/parser.y"
+            {}
+#line 1915 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_FLOAT: /* FLOAT  */
+#line 141 "src/parser.y"
+            {}
+#line 1921 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_STRING: /* STRING  */
+#line 141 "src/parser.y"
+            {}
+#line 1927 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_ID: /* ID  */
+#line 141 "src/parser.y"
+            {}
+#line 1933 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_id: /* id  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 1939 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_var: /* var  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 1945 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_embed: /* embed  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 1951 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_import: /* import  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 1957 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_binary_op: /* binary_op  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 1963 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_unary_op: /* unary_op  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 1969 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_arg: /* arg  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 1975 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_arg_list: /* arg_list  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 1981 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_param_decl: /* param_decl  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 1987 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_decl_list: /* decl_list  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 1993 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_call: /* call  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 1999 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_defer: /* defer  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2005 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_expr: /* expr  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2011 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_while: /* while  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2017 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_do_while: /* do_while  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2023 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_goto: /* goto  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2029 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_statement: /* statement  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2035 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_statement_list: /* statement_list  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2041 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_body: /* body  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2047 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_macro_list: /* macro_list  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2053 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_macro: /* macro  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2059 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_expr_list: /* expr_list  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2065 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_init_expr: /* init_expr  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2071 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_expr_if: /* expr_if  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2077 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_if: /* if  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2083 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_for: /* for  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2089 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_case: /* case  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2095 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_case_list: /* case_list  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2101 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_switch: /* switch  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2107 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_const_for: /* const_for  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2113 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_const_if: /* const_if  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2119 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_const: /* const  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2125 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_func_sign: /* func_sign  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2131 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_variadic_sign: /* variadic_sign  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2137 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_impl: /* impl  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2143 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_impl_list: /* impl_list  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2149 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_type: /* type  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2155 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_var_decl: /* var_decl  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2161 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_var_init: /* var_init  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2167 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_proc: /* proc  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2173 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_lambda: /* lambda  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2179 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_union_elem: /* union_elem  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2185 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_union_list: /* union_list  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2191 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_union: /* union  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2197 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_struct_list: /* struct_list  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2203 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_struct: /* struct  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2209 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_template_elem: /* template_elem  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2215 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_template_list: /* template_list  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2221 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_type_list: /* type_list  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2227 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_type_alias: /* type_alias  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2233 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_type_template: /* type_template  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2239 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_enum_val: /* enum_val  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2245 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_enum_list: /* enum_list  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2251 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_enum: /* enum  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2257 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_top_if: /* top_if  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2263 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_top: /* top  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2269 "src/gen_parser.c"
+        break;
+
+    case YYSYMBOL_unit: /* unit  */
+#line 142 "src/parser.y"
+            { destroy_ast_tree(((*yyvaluep).node)); }
+#line 2275 "src/gen_parser.c"
+        break;
+
+      default:
+        break;
+    }
+  YY_IGNORE_MAYBE_UNINITIALIZED_END
+}
+
+
+
+
+
+
+/*----------.
+| yyparse.  |
+`----------*/
+
+int
+yyparse (void *scanner, struct parser* parser)
+{
+/* Lookahead token kind.  */
+int yychar;
+
+
+/* The semantic value of the lookahead symbol.  */
+/* Default value used for initialization, for pacifying older GCCs
+   or non-GCC compilers.  */
+YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
+YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
+
+/* Location data for the lookahead symbol.  */
+static YYLTYPE yyloc_default
+# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
+  = { 1, 1, 1, 1 }
+# endif
+;
+YYLTYPE yylloc = yyloc_default;
+
+    /* Number of syntax errors so far.  */
+    int yynerrs = 0;
+
+    yy_state_fast_t yystate = 0;
+    /* Number of tokens to shift before error messages enabled.  */
+    int yyerrstatus = 0;
+
+    /* Refer to the stacks through separate pointers, to allow yyoverflow
+       to reallocate them elsewhere.  */
+
+    /* Their size.  */
+    YYPTRDIFF_T yystacksize = YYINITDEPTH;
+
+    /* The state stack: array, bottom, top.  */
+    yy_state_t yyssa[YYINITDEPTH];
+    yy_state_t *yyss = yyssa;
+    yy_state_t *yyssp = yyss;
+
+    /* The semantic value stack: array, bottom, top.  */
+    YYSTYPE yyvsa[YYINITDEPTH];
+    YYSTYPE *yyvs = yyvsa;
+    YYSTYPE *yyvsp = yyvs;
+
+    /* The location stack: array, bottom, top.  */
+    YYLTYPE yylsa[YYINITDEPTH];
+    YYLTYPE *yyls = yylsa;
+    YYLTYPE *yylsp = yyls;
+
+  int yyn;
+  /* The return value of yyparse.  */
+  int yyresult;
+  /* Lookahead symbol kind.  */
+  yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY;
+  /* The variables used to return semantic value and location from the
+     action routines.  */
+  YYSTYPE yyval;
+  YYLTYPE yyloc;
+
+  /* The locations where the error started and ended.  */
+  YYLTYPE yyerror_range[3];
+
+  /* Buffer for error messages, and its allocated size.  */
+  char yymsgbuf[128];
+  char *yymsg = yymsgbuf;
+  YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf;
+
+#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
+
+  /* The number of symbols on the RHS of the reduced rule.
+     Keep to zero when no symbol should be popped.  */
+  int yylen = 0;
+
+  YYDPRINTF ((stderr, "Starting parse\n"));
+
+  yychar = YYEMPTY; /* Cause a token to be read.  */
+
+  yylsp[0] = yylloc;
+  goto yysetstate;
+
+
+/*------------------------------------------------------------.
+| yynewstate -- push a new state, which is found in yystate.  |
+`------------------------------------------------------------*/
+yynewstate:
+  /* In all cases, when you get here, the value and location stacks
+     have just been pushed.  So pushing a state here evens the stacks.  */
+  yyssp++;
+
+
+/*--------------------------------------------------------------------.
+| yysetstate -- set current state (the top of the stack) to yystate.  |
+`--------------------------------------------------------------------*/
+yysetstate:
+  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
+  YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
+  YY_IGNORE_USELESS_CAST_BEGIN
+  *yyssp = YY_CAST (yy_state_t, yystate);
+  YY_IGNORE_USELESS_CAST_END
+  YY_STACK_PRINT (yyss, yyssp);
+
+  if (yyss + yystacksize - 1 <= yyssp)
+#if !defined yyoverflow && !defined YYSTACK_RELOCATE
+    YYNOMEM;
+#else
+    {
+      /* Get the current used size of the three stacks, in elements.  */
+      YYPTRDIFF_T yysize = yyssp - yyss + 1;
+
+# if defined yyoverflow
+      {
+        /* Give user a chance to reallocate the stack.  Use copies of
+           these so that the &'s don't force the real ones into
+           memory.  */
+        yy_state_t *yyss1 = yyss;
+        YYSTYPE *yyvs1 = yyvs;
+        YYLTYPE *yyls1 = yyls;
+
+        /* Each stack pointer address is followed by the size of the
+           data in use in that stack, in bytes.  This used to be a
+           conditional around just the two extra args, but that might
+           be undefined if yyoverflow is a macro.  */
+        yyoverflow (YY_("memory exhausted"),
+                    &yyss1, yysize * YYSIZEOF (*yyssp),
+                    &yyvs1, yysize * YYSIZEOF (*yyvsp),
+                    &yyls1, yysize * YYSIZEOF (*yylsp),
+                    &yystacksize);
+        yyss = yyss1;
+        yyvs = yyvs1;
+        yyls = yyls1;
+      }
+# else /* defined YYSTACK_RELOCATE */
+      /* Extend the stack our own way.  */
+      if (YYMAXDEPTH <= yystacksize)
+        YYNOMEM;
+      yystacksize *= 2;
+      if (YYMAXDEPTH < yystacksize)
+        yystacksize = YYMAXDEPTH;
+
+      {
+        yy_state_t *yyss1 = yyss;
+        union yyalloc *yyptr =
+          YY_CAST (union yyalloc *,
+                   YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
+        if (! yyptr)
+          YYNOMEM;
+        YYSTACK_RELOCATE (yyss_alloc, yyss);
+        YYSTACK_RELOCATE (yyvs_alloc, yyvs);
+        YYSTACK_RELOCATE (yyls_alloc, yyls);
+#  undef YYSTACK_RELOCATE
+        if (yyss1 != yyssa)
+          YYSTACK_FREE (yyss1);
+      }
+# endif
+
+      yyssp = yyss + yysize - 1;
+      yyvsp = yyvs + yysize - 1;
+      yylsp = yyls + yysize - 1;
+
+      YY_IGNORE_USELESS_CAST_BEGIN
+      YYDPRINTF ((stderr, "Stack size increased to %ld\n",
+                  YY_CAST (long, yystacksize)));
+      YY_IGNORE_USELESS_CAST_END
+
+      if (yyss + yystacksize - 1 <= yyssp)
+        YYABORT;
+    }
+#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
+
+
+  if (yystate == YYFINAL)
+    YYACCEPT;
+
+  goto yybackup;
+
+
+/*-----------.
+| yybackup.  |
+`-----------*/
+yybackup:
+  /* Do appropriate processing given the current state.  Read a
+     lookahead token if we need one and don't already have one.  */
+
+  /* First try to decide what to do without reference to lookahead token.  */
+  yyn = yypact[yystate];
+  if (yypact_value_is_default (yyn))
+    goto yydefault;
+
+  /* Not known => get a lookahead token if don't already have one.  */
+
+  /* YYCHAR is either empty, or end-of-input, or a valid lookahead.  */
+  if (yychar == YYEMPTY)
+    {
+      YYDPRINTF ((stderr, "Reading a token\n"));
+      yychar = yylex (&yylval, &yylloc, scanner, parser);
+    }
+
+  if (yychar <= YYEOF)
+    {
+      yychar = YYEOF;
+      yytoken = YYSYMBOL_YYEOF;
+      YYDPRINTF ((stderr, "Now at end of input.\n"));
+    }
+  else if (yychar == YYerror)
+    {
+      /* The scanner already issued an error message, process directly
+         to error recovery.  But do not keep the error token as
+         lookahead, it is too special and may lead us to an endless
+         loop in error recovery. */
+      yychar = YYUNDEF;
+      yytoken = YYSYMBOL_YYerror;
+      yyerror_range[1] = yylloc;
+      goto yyerrlab1;
+    }
+  else
+    {
+      yytoken = YYTRANSLATE (yychar);
+      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
+    }
+
+  /* If the proper action on seeing token YYTOKEN is to reduce or to
+     detect an error, take that action.  */
+  yyn += yytoken;
+  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
+    goto yydefault;
+  yyn = yytable[yyn];
+  if (yyn <= 0)
+    {
+      if (yytable_value_is_error (yyn))
+        goto yyerrlab;
+      yyn = -yyn;
+      goto yyreduce;
+    }
+
+  /* Count tokens shifted since error; after three, turn off error
+     status.  */
+  if (yyerrstatus)
+    yyerrstatus--;
+
+  /* Shift the lookahead token.  */
+  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
+  yystate = yyn;
+  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+  *++yyvsp = yylval;
+  YY_IGNORE_MAYBE_UNINITIALIZED_END
+  *++yylsp = yylloc;
+
+  /* Discard the shifted token.  */
+  yychar = YYEMPTY;
+  goto yynewstate;
+
+
+/*-----------------------------------------------------------.
+| yydefault -- do the default action for the current state.  |
+`-----------------------------------------------------------*/
+yydefault:
+  yyn = yydefact[yystate];
+  if (yyn == 0)
+    goto yyerrlab;
+  goto yyreduce;
+
+
+/*-----------------------------.
+| yyreduce -- do a reduction.  |
+`-----------------------------*/
+yyreduce:
+  /* yyn is the number of a rule to reduce with.  */
+  yylen = yyr2[yyn];
+
+  /* If YYLEN is nonzero, implement the default value of the action:
+     '$$ = $1'.
+
+     Otherwise, the following line sets YYVAL to garbage.
+     This behavior is undocumented and Bison
+     users should not rely upon it.  Assigning to YYVAL
+     unconditionally makes the parser a bit smaller, and it avoids a
+     GCC warning that YYVAL may be used uninitialized.  */
+  yyval = yyvsp[1-yylen];
+
+  /* Default location. */
+  YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
+  yyerror_range[1] = yyloc;
+  YY_REDUCE_PRINT (yyn);
+  switch (yyn)
+    {
+  case 2: /* id: ID  */
+#line 146 "src/parser.y"
+       {
+		(yyval.node) = gen_id(strdup((yyvsp[0].str)));
+		(yyval.node)->loc = to_src_loc(&yylloc);
+	}
+#line 2584 "src/gen_parser.c"
+    break;
+
+  case 3: /* var: var_decl  */
+#line 152 "src/parser.y"
+              { (yyval.node) = (yyvsp[0].node); }
+#line 2590 "src/gen_parser.c"
+    break;
+
+  case 4: /* var: var_init  */
+#line 153 "src/parser.y"
+                   { (yyval.node) = (yyvsp[0].node); }
+#line 2596 "src/gen_parser.c"
+    break;
+
+  case 5: /* embed: "embed" "(" STRING ")"  */
+#line 156 "src/parser.y"
+                              { (yyval.node) = gen_embed(clone_string((yyvsp[-1].str)));  }
+#line 2602 "src/gen_parser.c"
+    break;
+
+  case 6: /* import: "import" STRING  */
+#line 159 "src/parser.y"
+                        { (yyval.node) = gen_import(clone_string((yyvsp[0].str)));  }
+#line 2608 "src/gen_parser.c"
+    break;
+
+  case 7: /* binary_op: expr "=" expr  */
+#line 162 "src/parser.y"
+                         { (yyval.node) = gen_binop(AST_ASSIGN, (yyvsp[-2].node), (yyvsp[0].node)); }
+#line 2614 "src/gen_parser.c"
+    break;
+
+  case 8: /* binary_op: expr "+" expr  */
+#line 163 "src/parser.y"
+                        { (yyval.node) = gen_binop(AST_ADD, (yyvsp[-2].node), (yyvsp[0].node));  }
+#line 2620 "src/gen_parser.c"
+    break;
+
+  case 9: /* binary_op: expr "-" expr  */
+#line 164 "src/parser.y"
+                        { (yyval.node) = gen_binop(AST_SUB, (yyvsp[-2].node), (yyvsp[0].node));  }
+#line 2626 "src/gen_parser.c"
+    break;
+
+  case 10: /* binary_op: expr "*" expr  */
+#line 165 "src/parser.y"
+                        { (yyval.node) = gen_binop(AST_MUL, (yyvsp[-2].node), (yyvsp[0].node));  }
+#line 2632 "src/gen_parser.c"
+    break;
+
+  case 11: /* binary_op: expr "/" expr  */
+#line 166 "src/parser.y"
+                        { (yyval.node) = gen_binop(AST_DIV, (yyvsp[-2].node), (yyvsp[0].node));  }
+#line 2638 "src/gen_parser.c"
+    break;
+
+  case 12: /* binary_op: expr "%" expr  */
+#line 167 "src/parser.y"
+                        { (yyval.node) = gen_binop(AST_REM, (yyvsp[-2].node), (yyvsp[0].node));  }
+#line 2644 "src/gen_parser.c"
+    break;
+
+  case 13: /* binary_op: expr "^" expr  */
+#line 168 "src/parser.y"
+                        { (yyval.node) = gen_binop(AST_XOR, (yyvsp[-2].node), (yyvsp[0].node));  }
+#line 2650 "src/gen_parser.c"
+    break;
+
+  case 14: /* binary_op: expr "^^" expr  */
+#line 169 "src/parser.y"
+                         { (yyval.node) = gen_binop(AST_POW, (yyvsp[-2].node), (yyvsp[0].node));  }
+#line 2656 "src/gen_parser.c"
+    break;
+
+  case 15: /* binary_op: expr "&" expr  */
+#line 170 "src/parser.y"
+                        { (yyval.node) = gen_binop(AST_AND, (yyvsp[-2].node), (yyvsp[0].node));  }
+#line 2662 "src/gen_parser.c"
+    break;
+
+  case 16: /* binary_op: expr "&&" expr  */
+#line 171 "src/parser.y"
+                         { (yyval.node) = gen_binop(AST_LAND, (yyvsp[-2].node), (yyvsp[0].node));  }
+#line 2668 "src/gen_parser.c"
+    break;
+
+  case 17: /* binary_op: expr "|" expr  */
+#line 172 "src/parser.y"
+                        { (yyval.node) = gen_binop(AST_OR, (yyvsp[-2].node), (yyvsp[0].node));  }
+#line 2674 "src/gen_parser.c"
+    break;
+
+  case 18: /* binary_op: expr "||" expr  */
+#line 173 "src/parser.y"
+                         { (yyval.node) = gen_binop(AST_LOR, (yyvsp[-2].node), (yyvsp[0].node));  }
+#line 2680 "src/gen_parser.c"
+    break;
+
+  case 19: /* binary_op: expr "<<" expr  */
+#line 174 "src/parser.y"
+                         { (yyval.node) = gen_binop(AST_LSHIFT, (yyvsp[-2].node), (yyvsp[0].node));  }
+#line 2686 "src/gen_parser.c"
+    break;
+
+  case 20: /* binary_op: expr ">>" expr  */
+#line 175 "src/parser.y"
+                         { (yyval.node) = gen_binop(AST_RSHIFT, (yyvsp[-2].node), (yyvsp[0].node));  }
+#line 2692 "src/gen_parser.c"
+    break;
+
+  case 21: /* binary_op: expr "+=" expr  */
+#line 176 "src/parser.y"
+                         { (yyval.node) = gen_binop(AST_ASSIGN_ADD, (yyvsp[-2].node), (yyvsp[0].node));  }
+#line 2698 "src/gen_parser.c"
+    break;
+
+  case 22: /* binary_op: expr "-=" expr  */
+#line 177 "src/parser.y"
+                         { (yyval.node) = gen_binop(AST_ASSIGN_SUB, (yyvsp[-2].node), (yyvsp[0].node));  }
+#line 2704 "src/gen_parser.c"
+    break;
+
+  case 23: /* binary_op: expr "*=" expr  */
+#line 178 "src/parser.y"
+                         { (yyval.node) = gen_binop(AST_ASSIGN_MUL, (yyvsp[-2].node), (yyvsp[0].node));  }
+#line 2710 "src/gen_parser.c"
+    break;
+
+  case 24: /* binary_op: expr "/=" expr  */
+#line 179 "src/parser.y"
+                         { (yyval.node) = gen_binop(AST_ASSIGN_DIV, (yyvsp[-2].node), (yyvsp[0].node));  }
+#line 2716 "src/gen_parser.c"
+    break;
+
+  case 25: /* binary_op: expr "%=" expr  */
+#line 180 "src/parser.y"
+                         { (yyval.node) = gen_binop(AST_ASSIGN_REM, (yyvsp[-2].node), (yyvsp[0].node));  }
+#line 2722 "src/gen_parser.c"
+    break;
+
+  case 26: /* binary_op: expr "&=" expr  */
+#line 181 "src/parser.y"
+                         { (yyval.node) = gen_binop(AST_ASSIGN_AND, (yyvsp[-2].node), (yyvsp[0].node));  }
+#line 2728 "src/gen_parser.c"
+    break;
+
+  case 27: /* binary_op: expr "|=" expr  */
+#line 182 "src/parser.y"
+                         { (yyval.node) = gen_binop(AST_ASSIGN_OR, (yyvsp[-2].node), (yyvsp[0].node));  }
+#line 2734 "src/gen_parser.c"
+    break;
+
+  case 28: /* binary_op: expr "^=" expr  */
+#line 183 "src/parser.y"
+                         { (yyval.node) = gen_binop(AST_ASSIGN_XOR, (yyvsp[-2].node), (yyvsp[0].node));  }
+#line 2740 "src/gen_parser.c"
+    break;
+
+  case 29: /* binary_op: expr "<<=" expr  */
+#line 184 "src/parser.y"
+                          {
+		(yyval.node) = gen_binop(AST_ASSIGN_LSHIFT, (yyvsp[-2].node), (yyvsp[0].node));
+	}
+#line 2748 "src/gen_parser.c"
+    break;
+
+  case 30: /* binary_op: expr ">>=" expr  */
+#line 187 "src/parser.y"
+                          {
+		(yyval.node) = gen_binop(AST_ASSIGN_RSHIFT, (yyvsp[-2].node), (yyvsp[0].node));
+	}
+#line 2756 "src/gen_parser.c"
+    break;
+
+  case 31: /* binary_op: expr "<" expr  */
+#line 190 "src/parser.y"
+                        { (yyval.node) = gen_binop(AST_LT, (yyvsp[-2].node), (yyvsp[0].node));  }
+#line 2762 "src/gen_parser.c"
+    break;
+
+  case 32: /* binary_op: expr ">" expr  */
+#line 191 "src/parser.y"
+                        { (yyval.node) = gen_binop(AST_GT, (yyvsp[-2].node), (yyvsp[0].node));  }
+#line 2768 "src/gen_parser.c"
+    break;
+
+  case 33: /* binary_op: expr "<=" expr  */
+#line 192 "src/parser.y"
+                         { (yyval.node) = gen_binop(AST_LE, (yyvsp[-2].node), (yyvsp[0].node));  }
+#line 2774 "src/gen_parser.c"
+    break;
+
+  case 34: /* binary_op: expr ">=" expr  */
+#line 193 "src/parser.y"
+                         { (yyval.node) = gen_binop(AST_GE, (yyvsp[-2].node), (yyvsp[0].node));  }
+#line 2780 "src/gen_parser.c"
+    break;
+
+  case 35: /* binary_op: expr "!=" expr  */
+#line 194 "src/parser.y"
+                         { (yyval.node) = gen_binop(AST_NE, (yyvsp[-2].node), (yyvsp[0].node));  }
+#line 2786 "src/gen_parser.c"
+    break;
+
+  case 36: /* binary_op: expr "==" expr  */
+#line 195 "src/parser.y"
+                         { (yyval.node) = gen_binop(AST_EQ, (yyvsp[-2].node), (yyvsp[0].node));  }
+#line 2792 "src/gen_parser.c"
+    break;
+
+  case 37: /* unary_op: "-" expr  */
+#line 198 "src/parser.y"
+                   { (yyval.node) = gen_unop(AST_NEG, (yyvsp[0].node));  }
+#line 2798 "src/gen_parser.c"
+    break;
+
+  case 38: /* unary_op: "!" expr  */
+#line 199 "src/parser.y"
+                   { (yyval.node) = gen_unop(AST_LNOT, (yyvsp[0].node));  }
+#line 2804 "src/gen_parser.c"
+    break;
+
+  case 39: /* unary_op: "&" expr  */
+#line 200 "src/parser.y"
+                   { (yyval.node) = gen_unop(AST_REF, (yyvsp[0].node));  }
+#line 2810 "src/gen_parser.c"
+    break;
+
+  case 40: /* unary_op: "'" expr  */
+#line 201 "src/parser.y"
+                   { (yyval.node) = gen_unop(AST_DEREF, (yyvsp[0].node));  }
+#line 2816 "src/gen_parser.c"
+    break;
+
+  case 41: /* unary_op: "~" expr  */
+#line 202 "src/parser.y"
+                   { (yyval.node) = gen_unop(AST_NOT, (yyvsp[0].node));  }
+#line 2822 "src/gen_parser.c"
+    break;
+
+  case 42: /* arg: "&" var_decl  */
+#line 205 "src/parser.y"
+                  { (yyval.node) = gen_unop(SQUOTE, (yyvsp[0].node));  }
+#line 2828 "src/gen_parser.c"
+    break;
+
+  case 43: /* arg: var_decl  */
+#line 206 "src/parser.y"
+                   { (yyval.node) = (yyvsp[0].node); }
+#line 2834 "src/gen_parser.c"
+    break;
+
+  case 44: /* arg: init_expr  */
+#line 207 "src/parser.y"
+                    { (yyval.node) = (yyvsp[0].node); }
+#line 2840 "src/gen_parser.c"
+    break;
+
+  case 45: /* arg_list: arg "," arg_list  */
+#line 210 "src/parser.y"
+                           { (yyval.node) = (yyvsp[-2].node); (yyvsp[-2].node)->next = (yyvsp[0].node); }
+#line 2846 "src/gen_parser.c"
+    break;
+
+  case 46: /* arg_list: arg  */
+#line 211 "src/parser.y"
+              { (yyval.node) = (yyvsp[0].node); }
+#line 2852 "src/gen_parser.c"
+    break;
+
+  case 47: /* param_decl: type  */
+#line 214 "src/parser.y"
+                 { (yyval.node) = gen_var(NULL, (yyvsp[0].node), NULL);  }
+#line 2858 "src/gen_parser.c"
+    break;
+
+  case 48: /* decl_list: var_decl "," decl_list  */
+#line 216 "src/parser.y"
+                                  { (yyval.node) = (yyvsp[-2].node); (yyvsp[-2].node)->next = (yyvsp[0].node); }
+#line 2864 "src/gen_parser.c"
+    break;
+
+  case 49: /* decl_list: param_decl "," decl_list  */
+#line 217 "src/parser.y"
+                                   { (yyval.node) = (yyvsp[-2].node); (yyvsp[-2].node)->next = (yyvsp[0].node); }
+#line 2870 "src/gen_parser.c"
+    break;
+
+  case 50: /* decl_list: var_decl  */
+#line 218 "src/parser.y"
+                   { (yyval.node) = (yyvsp[0].node); }
+#line 2876 "src/gen_parser.c"
+    break;
+
+  case 51: /* decl_list: param_decl  */
+#line 219 "src/parser.y"
+                     { (yyval.node) = (yyvsp[0].node); }
+#line 2882 "src/gen_parser.c"
+    break;
+
+  case 52: /* call: id "(" arg_list ")"  */
+#line 223 "src/parser.y"
+                          { (yyval.node) = gen_call((yyvsp[-3].node), (yyvsp[-1].node));  }
+#line 2888 "src/gen_parser.c"
+    break;
+
+  case 53: /* call: id "(" ")"  */
+#line 224 "src/parser.y"
+                     { (yyval.node) = gen_call((yyvsp[-2].node), NULL);  }
+#line 2894 "src/gen_parser.c"
+    break;
+
+  case 54: /* defer: "defer" "(" expr ")"  */
+#line 227 "src/parser.y"
+                            { (yyval.node) = gen_defer((yyvsp[-1].node));  }
+#line 2900 "src/gen_parser.c"
+    break;
+
+  case 55: /* expr: id  */
+#line 231 "src/parser.y"
+         { (yyval.node) = (yyvsp[0].node); }
+#line 2906 "src/gen_parser.c"
+    break;
+
+  case 56: /* expr: expr "." id  */
+#line 232 "src/parser.y"
+                      { (yyval.node) = gen_dot((yyvsp[-2].node), (yyvsp[0].node)); }
+#line 2912 "src/gen_parser.c"
+    break;
+
+  case 57: /* expr: id "##" id  */
+#line 233 "src/parser.y"
+                     { (yyval.node) = gen_paste((yyvsp[-2].node), (yyvsp[0].node));  }
+#line 2918 "src/gen_parser.c"
+    break;
+
+  case 58: /* expr: "..." id  */
+#line 234 "src/parser.y"
+                   { (yyval.node) = (yyvsp[0].node); }
+#line 2924 "src/gen_parser.c"
+    break;
+
+  case 59: /* expr: "@"  */
+#line 235 "src/parser.y"
+              { (yyval.node) = gen_last();  }
+#line 2930 "src/gen_parser.c"
+    break;
+
+  case 60: /* expr: INT  */
+#line 236 "src/parser.y"
+              { (yyval.node) = gen_int((yyvsp[0].integer)); (yyval.node)->loc = to_src_loc(&yylloc); }
+#line 2936 "src/gen_parser.c"
+    break;
+
+  case 61: /* expr: FLOAT  */
+#line 237 "src/parser.y"
+                { (yyval.node) = gen_float((yyvsp[0].dbl)); (yyval.node)->loc = to_src_loc(&yylloc);  }
+#line 2942 "src/gen_parser.c"
+    break;
+
+  case 62: /* expr: STRING  */
+#line 238 "src/parser.y"
+                 {
+		(yyval.node) = gen_string(clone_string((yyvsp[0].str)));
+		(yyval.node)->loc = to_src_loc(&yylloc);
+	}
+#line 2951 "src/gen_parser.c"
+    break;
+
+  case 63: /* expr: "(" expr ")"  */
+#line 242 "src/parser.y"
+                       { (yyval.node) = (yyvsp[-1].node); }
+#line 2957 "src/gen_parser.c"
+    break;
+
+  case 64: /* expr: call  */
+#line 243 "src/parser.y"
+               { (yyval.node) = (yyvsp[0].node); }
+#line 2963 "src/gen_parser.c"
+    break;
+
+  case 65: /* expr: defer  */
+#line 244 "src/parser.y"
+                { (yyval.node) = (yyvsp[0].node); }
+#line 2969 "src/gen_parser.c"
+    break;
+
+  case 66: /* expr: binary_op  */
+#line 245 "src/parser.y"
+                    { (yyval.node) = (yyvsp[0].node); }
+#line 2975 "src/gen_parser.c"
+    break;
+
+  case 67: /* expr: unary_op  */
+#line 246 "src/parser.y"
+                   { (yyval.node) = (yyvsp[0].node); }
+#line 2981 "src/gen_parser.c"
+    break;
+
+  case 68: /* expr: "(" var_init ")"  */
+#line 247 "src/parser.y"
+                           { (yyval.node) = (yyvsp[-1].node); }
+#line 2987 "src/gen_parser.c"
+    break;
+
+  case 69: /* expr: "sizeof" expr  */
+#line 248 "src/parser.y"
+                        { (yyval.node) = gen_sizeof((yyvsp[0].node)); }
+#line 2993 "src/gen_parser.c"
+    break;
+
+  case 70: /* expr: expr "as" type  */
+#line 249 "src/parser.y"
+                         { (yyval.node) = gen_cast((yyvsp[-2].node), (yyvsp[0].node));  }
+#line 2999 "src/gen_parser.c"
+    break;
+
+  case 71: /* expr: "as" type  */
+#line 250 "src/parser.y"
+                    { (yyval.node) = gen_as((yyvsp[0].node)); }
+#line 3005 "src/gen_parser.c"
+    break;
+
+  case 72: /* expr: embed  */
+#line 251 "src/parser.y"
+                { (yyval.node) = (yyvsp[0].node); }
+#line 3011 "src/gen_parser.c"
+    break;
+
+  case 73: /* expr: lambda  */
+#line 252 "src/parser.y"
+                 { (yyval.node) = (yyvsp[0].node); }
+#line 3017 "src/gen_parser.c"
+    break;
+
+  case 74: /* while: "while" expr body  */
+#line 255 "src/parser.y"
+                         { (yyval.node) = gen_while((yyvsp[-1].node), (yyvsp[0].node));  }
+#line 3023 "src/gen_parser.c"
+    break;
+
+  case 75: /* do_while: "do" body "while" expr ";"  */
+#line 258 "src/parser.y"
+                                     {
+		(yyval.node) = gen_while((yyvsp[-3].node), (yyvsp[-1].node));
+		ast_set_flags((yyval.node), AST_FLAG_DELAYED);
+	}
+#line 3032 "src/gen_parser.c"
+    break;
+
+  case 76: /* goto: "goto" id  */
+#line 264 "src/parser.y"
+                { (yyval.node) = gen_goto(gen_label((yyvsp[0].node)));  }
+#line 3038 "src/gen_parser.c"
+    break;
+
+  case 77: /* statement: expr ";"  */
+#line 266 "src/parser.y"
+                    { (yyval.node) = (yyvsp[-1].node); }
+#line 3044 "src/gen_parser.c"
+    break;
+
+  case 78: /* statement: "return" expr ";"  */
+#line 267 "src/parser.y"
+                            { (yyval.node) = gen_return((yyvsp[-1].node));  }
+#line 3050 "src/gen_parser.c"
+    break;
+
+  case 79: /* statement: "return" ";"  */
+#line 268 "src/parser.y"
+                       { (yyval.node) = gen_return(NULL); }
+#line 3056 "src/gen_parser.c"
+    break;
+
+  case 80: /* statement: "break" ";"  */
+#line 269 "src/parser.y"
+                      { (yyval.node) = gen_ctrl(AST_CTRL_BREAK, to_src_loc(&yylloc)); }
+#line 3062 "src/gen_parser.c"
+    break;
+
+  case 81: /* statement: "continue" ";"  */
+#line 270 "src/parser.y"
+                         { (yyval.node) = gen_ctrl(AST_CTRL_CONTINUE,
+	to_src_loc(&yylloc));  }
+#line 3069 "src/gen_parser.c"
+    break;
+
+  case 82: /* statement: import ";"  */
+#line 272 "src/parser.y"
+                     { (yyval.node) = (yyvsp[-1].node); }
+#line 3075 "src/gen_parser.c"
+    break;
+
+  case 83: /* statement: var ";"  */
+#line 273 "src/parser.y"
+                  { (yyval.node) = (yyvsp[-1].node); }
+#line 3081 "src/gen_parser.c"
+    break;
+
+  case 84: /* statement: if  */
+#line 274 "src/parser.y"
+             { (yyval.node) = (yyvsp[0].node); }
+#line 3087 "src/gen_parser.c"
+    break;
+
+  case 85: /* statement: goto ";"  */
+#line 275 "src/parser.y"
+                  { (yyval.node) = (yyvsp[-1].node); }
+#line 3093 "src/gen_parser.c"
+    break;
+
+  case 86: /* statement: id ":"  */
+#line 276 "src/parser.y"
+                 { (yyval.node) = gen_label((yyvsp[-1].node));  }
+#line 3099 "src/gen_parser.c"
+    break;
+
+  case 87: /* statement: for  */
+#line 277 "src/parser.y"
+              { (yyval.node) = (yyvsp[0].node); }
+#line 3105 "src/gen_parser.c"
+    break;
+
+  case 88: /* statement: const  */
+#line 278 "src/parser.y"
+                { (yyval.node) = (yyvsp[0].node); }
+#line 3111 "src/gen_parser.c"
+    break;
+
+  case 89: /* statement: while  */
+#line 279 "src/parser.y"
+                { (yyval.node) = (yyvsp[0].node); }
+#line 3117 "src/gen_parser.c"
+    break;
+
+  case 90: /* statement: do_while  */
+#line 280 "src/parser.y"
+                   { (yyval.node) = (yyvsp[0].node); }
+#line 3123 "src/gen_parser.c"
+    break;
+
+  case 91: /* statement: switch  */
+#line 281 "src/parser.y"
+                 { (yyval.node) = (yyvsp[0].node); }
+#line 3129 "src/gen_parser.c"
+    break;
+
+  case 92: /* statement: macro  */
+#line 282 "src/parser.y"
+                { (yyval.node) = (yyvsp[0].node); }
+#line 3135 "src/gen_parser.c"
+    break;
+
+  case 93: /* statement: struct  */
+#line 283 "src/parser.y"
+                 { (yyval.node) = (yyvsp[0].node); }
+#line 3141 "src/gen_parser.c"
+    break;
+
+  case 94: /* statement: type_alias ";"  */
+#line 284 "src/parser.y"
+                         { (yyval.node) = (yyvsp[-1].node); }
+#line 3147 "src/gen_parser.c"
+    break;
+
+  case 95: /* statement: type_template  */
+#line 285 "src/parser.y"
+                        { (yyval.node) = (yyvsp[0].node); }
+#line 3153 "src/gen_parser.c"
+    break;
+
+  case 96: /* statement: enum  */
+#line 286 "src/parser.y"
+               { (yyval.node) = (yyvsp[0].node); }
+#line 3159 "src/gen_parser.c"
+    break;
+
+  case 97: /* statement: body  */
+#line 287 "src/parser.y"
+               { (yyval.node) = (yyvsp[0].node); }
+#line 3165 "src/gen_parser.c"
+    break;
+
+  case 98: /* statement: ";"  */
+#line 288 "src/parser.y"
+              { (yyval.node) = gen_empty();  }
+#line 3171 "src/gen_parser.c"
+    break;
+
+  case 99: /* statement: error  */
+#line 289 "src/parser.y"
+                {
+	    /* TODO: figure out how to destroy any and all possible ast nodes we
+	     * may have generated up until the error */
+	    (yyval.node) = gen_empty();
+	    parser->failed = true;
+	    /* If we're failing to parse a statement in a block, continue by trying to
+	     * parse the next statement in the block */
+	    if (next_interesting_feature(&yylval, &yylloc, scanner, parser)) {
+		destroy_ast_node((yyval.node));
+		YYABORT;
+	    }
+	    yyclearin;
+	    yyerrok;
+	    }
+#line 3190 "src/gen_parser.c"
+    break;
+
+  case 100: /* statement_list: statement statement_list  */
+#line 305 "src/parser.y"
+                                         { (yyval.node) = (yyvsp[-1].node); (yyvsp[-1].node)->next = (yyvsp[0].node); }
+#line 3196 "src/gen_parser.c"
+    break;
+
+  case 101: /* statement_list: statement  */
+#line 306 "src/parser.y"
+                    { (yyval.node) = (yyvsp[0].node); }
+#line 3202 "src/gen_parser.c"
+    break;
+
+  case 102: /* body: "{" statement_list "}"  */
+#line 309 "src/parser.y"
+                             { (yyval.node) = gen_block((yyvsp[-1].node));  }
+#line 3208 "src/gen_parser.c"
+    break;
+
+  case 103: /* body: "{" "}"  */
+#line 310 "src/parser.y"
+                  { (yyval.node) = gen_block(gen_empty());  }
+#line 3214 "src/gen_parser.c"
+    break;
+
+  case 104: /* macro_list: id "," macro_list  */
+#line 313 "src/parser.y"
+                              { (yyval.node) = (yyvsp[-2].node); (yyval.node)->next = (yyvsp[0].node); }
+#line 3220 "src/gen_parser.c"
+    break;
+
+  case 105: /* macro_list: id  */
+#line 314 "src/parser.y"
+             { (yyval.node) = (yyvsp[0].node); }
+#line 3226 "src/gen_parser.c"
+    break;
+
+  case 106: /* macro: "define" id "(" macro_list ")" body  */
+#line 317 "src/parser.y"
+                                           {
+		(yyval.node) = gen_macro((yyvsp[-4].node), (yyvsp[-2].node), (yyvsp[0].node));
+		ast_set_flags((yyvsp[0].node), AST_FLAG_UNHYGIENIC);
+	}
+#line 3235 "src/gen_parser.c"
+    break;
+
+  case 107: /* macro: "define" id "(" macro_list "..." id ")" body  */
+#line 321 "src/parser.y"
+                                                       {
+		/* TODO: the location data of the variadic ID is way off */
+		ast_append((yyvsp[-4].node), (yyvsp[-2].node));
+		(yyval.node) = gen_macro((yyvsp[-6].node), (yyvsp[-4].node), (yyvsp[0].node));
+		ast_set_flags((yyval.node), AST_FLAG_VARIADIC);
+		ast_set_flags((yyvsp[0].node), AST_FLAG_UNHYGIENIC);
+	}
+#line 3247 "src/gen_parser.c"
+    break;
+
+  case 108: /* macro: "define" id "(" ")" body  */
+#line 328 "src/parser.y"
+                                   {
+		(yyval.node) = gen_macro((yyvsp[-3].node), NULL, (yyvsp[0].node));
+		ast_set_flags((yyvsp[0].node), AST_FLAG_UNHYGIENIC);
+	}
+#line 3256 "src/gen_parser.c"
+    break;
+
+  case 109: /* expr_list: expr "," expr_list  */
+#line 334 "src/parser.y"
+                              { (yyval.node) = (yyvsp[-2].node); (yyvsp[-2].node)->next = (yyvsp[0].node); }
+#line 3262 "src/gen_parser.c"
+    break;
+
+  case 110: /* expr_list: expr  */
+#line 335 "src/parser.y"
+               { (yyval.node) = (yyvsp[0].node); }
+#line 3268 "src/gen_parser.c"
+    break;
+
+  case 111: /* init_expr: expr  */
+#line 338 "src/parser.y"
+                { (yyval.node) = (yyvsp[0].node); }
+#line 3274 "src/gen_parser.c"
+    break;
+
+  case 112: /* init_expr: var_init  */
+#line 339 "src/parser.y"
+                   { (yyval.node) = (yyvsp[0].node); }
+#line 3280 "src/gen_parser.c"
+    break;
+
+  case 113: /* init_expr: "&" var_init  */
+#line 340 "src/parser.y"
+                       { (yyval.node) = gen_unop(AND, (yyvsp[0].node));  }
+#line 3286 "src/gen_parser.c"
+    break;
+
+  case 114: /* init_expr: expr_if  */
+#line 341 "src/parser.y"
+                  { (yyval.node) = (yyvsp[0].node); }
+#line 3292 "src/gen_parser.c"
+    break;
+
+  case 115: /* expr_if: "if" init_expr body "else" body  */
+#line 344 "src/parser.y"
+                                         { (yyval.node) = gen_if((yyvsp[-3].node), (yyvsp[-2].node), (yyvsp[0].node));  }
+#line 3298 "src/gen_parser.c"
+    break;
+
+  case 116: /* expr_if: "if" init_expr body "else" expr_if  */
+#line 345 "src/parser.y"
+                                            { (yyval.node) = gen_if((yyvsp[-3].node), (yyvsp[-2].node), (yyvsp[0].node));  }
+#line 3304 "src/gen_parser.c"
+    break;
+
+  case 117: /* if: "if" init_expr body  */
+#line 348 "src/parser.y"
+                        { (yyval.node) = gen_if((yyvsp[-1].node), (yyvsp[0].node), NULL);  }
+#line 3310 "src/gen_parser.c"
+    break;
+
+  case 118: /* if: "if" init_expr body "else" body  */
+#line 349 "src/parser.y"
+                                          { (yyval.node) = gen_if((yyvsp[-3].node), (yyvsp[-2].node), (yyvsp[0].node));  }
+#line 3316 "src/gen_parser.c"
+    break;
+
+  case 119: /* if: "if" init_expr body "else" if  */
+#line 350 "src/parser.y"
+                                        { (yyval.node) = gen_if((yyvsp[-3].node), (yyvsp[-2].node), (yyvsp[0].node));  }
+#line 3322 "src/gen_parser.c"
+    break;
+
+  case 120: /* for: "for" arg ";" expr ";" expr body  */
+#line 353 "src/parser.y"
+                                      { (yyval.node) = gen_for((yyvsp[-5].node), (yyvsp[-3].node), (yyvsp[-1].node), (yyvsp[0].node));
+    }
+#line 3329 "src/gen_parser.c"
+    break;
+
+  case 121: /* case: "case" expr ":" statement_list  */
+#line 357 "src/parser.y"
+                                     { (yyval.node) = gen_case((yyvsp[-2].node), (yyvsp[0].node));  }
+#line 3335 "src/gen_parser.c"
+    break;
+
+  case 122: /* case_list: case case_list  */
+#line 360 "src/parser.y"
+                          { (yyval.node) = (yyvsp[-1].node); (yyvsp[-1].node)->next = (yyvsp[0].node); }
+#line 3341 "src/gen_parser.c"
+    break;
+
+  case 123: /* case_list: case  */
+#line 361 "src/parser.y"
+               { (yyval.node) = (yyvsp[0].node); }
+#line 3347 "src/gen_parser.c"
+    break;
+
+  case 124: /* switch: "switch" expr "{" case_list "}"  */
+#line 364 "src/parser.y"
+                                        { (yyval.node) = gen_switch((yyvsp[-3].node), (yyvsp[-1].node));  }
+#line 3353 "src/gen_parser.c"
+    break;
+
+  case 125: /* const_for: "for" id ":" expr_list body  */
+#line 367 "src/parser.y"
+                                       {
+		/* TODO: should id be a separate rule? */
+		(yyval.node) = gen_for((yyvsp[-3].node), NULL, (yyvsp[-1].node), (yyvsp[0].node));
+		ast_set_flags((yyvsp[0].node), AST_FLAG_UNHYGIENIC);
+	}
+#line 3363 "src/gen_parser.c"
+    break;
+
+  case 126: /* const_if: "if" expr body  */
+#line 374 "src/parser.y"
+                         {
+		(yyval.node) = gen_if((yyvsp[-1].node), (yyvsp[0].node), NULL);
+		ast_set_flags((yyvsp[0].node), AST_FLAG_UNHYGIENIC);
+	}
+#line 3372 "src/gen_parser.c"
+    break;
+
+  case 127: /* const_if: "if" expr body "else" body  */
+#line 378 "src/parser.y"
+                                     {
+		(yyval.node) = gen_if((yyvsp[-3].node), (yyvsp[-2].node), (yyvsp[0].node));
+		ast_set_flags((yyvsp[-2].node), AST_FLAG_UNHYGIENIC);
+		ast_set_flags((yyvsp[0].node), AST_FLAG_UNHYGIENIC);
+	}
+#line 3382 "src/gen_parser.c"
+    break;
+
+  case 128: /* const_if: "if" expr body "else" const_if  */
+#line 383 "src/parser.y"
+                                         {
+		(yyval.node) = gen_if((yyvsp[-3].node), (yyvsp[-2].node), (yyvsp[0].node));
+		ast_set_flags((yyvsp[-2].node), AST_FLAG_UNHYGIENIC);
+	}
+#line 3391 "src/gen_parser.c"
+    break;
+
+  case 129: /* const: "const" const_if  */
+#line 391 "src/parser.y"
+                        { (yyval.node) = (yyvsp[0].node); ast_set_flags((yyval.node), AST_FLAG_CONST);
+      }
+#line 3398 "src/gen_parser.c"
+    break;
+
+  case 130: /* const: "const" const_for  */
+#line 393 "src/parser.y"
+                            { (yyval.node) = (yyvsp[0].node); ast_set_flags((yyval.node), AST_FLAG_CONST);
+	 }
+#line 3405 "src/gen_parser.c"
+    break;
+
+  case 131: /* func_sign: "(" decl_list "=>" type ")"  */
+#line 397 "src/parser.y"
+                                       {
+		(yyval.node) = gen_type(AST_TYPE_SIGN, NULL, (yyvsp[-3].node), (yyvsp[-1].node));
+	}
+#line 3413 "src/gen_parser.c"
+    break;
+
+  case 132: /* func_sign: "(" decl_list ")"  */
+#line 400 "src/parser.y"
+                            { (yyval.node) = gen_type(AST_TYPE_SIGN, NULL, (yyvsp[-1].node), NULL);
+	 }
+#line 3420 "src/gen_parser.c"
+    break;
+
+  case 133: /* func_sign: "(" decl_list "=>" ")"  */
+#line 402 "src/parser.y"
+                                 { (yyval.node) = gen_type(AST_TYPE_SIGN, NULL, (yyvsp[-2].node), NULL);
+	 }
+#line 3427 "src/gen_parser.c"
+    break;
+
+  case 134: /* func_sign: "(" "=>" type ")"  */
+#line 404 "src/parser.y"
+                            { (yyval.node) = gen_type(AST_TYPE_SIGN, NULL, NULL, (yyvsp[-1].node));
+	 }
+#line 3434 "src/gen_parser.c"
+    break;
+
+  case 135: /* func_sign: "(" ")"  */
+#line 406 "src/parser.y"
+                  { (yyval.node) = gen_type(AST_TYPE_SIGN, NULL, NULL, NULL);
+	 }
+#line 3441 "src/gen_parser.c"
+    break;
+
+  case 136: /* variadic_sign: func_sign  */
+#line 410 "src/parser.y"
+                         { (yyval.node) = (yyvsp[0].node); }
+#line 3447 "src/gen_parser.c"
+    break;
+
+  case 137: /* variadic_sign: "(" decl_list "..." id "=>" type ")"  */
+#line 411 "src/parser.y"
+                                               {
+		ast_append((yyvsp[-5].node), (yyvsp[-3].node));
+		(yyval.node) = gen_type(AST_TYPE_SIGN, NULL, (yyvsp[-5].node), (yyvsp[-1].node));
+		ast_set_flags((yyval.node), AST_FLAG_VARIADIC);
+	}
+#line 3457 "src/gen_parser.c"
+    break;
+
+  case 138: /* impl: id "{" type_list "}"  */
+#line 418 "src/parser.y"
+                           { (yyval.node) = gen_type(AST_TYPE_IMPL, (yyvsp[-3].node), (yyvsp[-1].node), NULL);
+     }
+#line 3464 "src/gen_parser.c"
+    break;
+
+  case 139: /* impl: id  */
+#line 420 "src/parser.y"
+             { (yyval.node) = gen_type(AST_TYPE_IMPL, (yyvsp[0].node), NULL, NULL);  }
+#line 3470 "src/gen_parser.c"
+    break;
+
+  case 140: /* impl_list: impl "," impl_list  */
+#line 423 "src/parser.y"
+                              { (yyval.node) = (yyvsp[-2].node); (yyvsp[-2].node)->next = (yyvsp[0].node);}
+#line 3476 "src/gen_parser.c"
+    break;
+
+  case 141: /* impl_list: impl  */
+#line 424 "src/parser.y"
+               { (yyval.node) = (yyvsp[0].node); }
+#line 3482 "src/gen_parser.c"
+    break;
+
+  case 142: /* type: id  */
+#line 427 "src/parser.y"
+         { (yyval.node) = gen_type(AST_TYPE_ID, (yyvsp[0].node), NULL, NULL); }
+#line 3488 "src/gen_parser.c"
+    break;
+
+  case 143: /* type: "'" func_sign  */
+#line 428 "src/parser.y"
+                        {
+		(yyval.node) = gen_type(AST_TYPE_POINTER, NULL, NULL, NULL);
+		(yyval.node)->next = (yyvsp[0].node);
+	}
+#line 3497 "src/gen_parser.c"
+    break;
+
+  case 144: /* type: id "(" impl_list ")"  */
+#line 432 "src/parser.y"
+                               {
+		(yyval.node) = gen_type(AST_TYPE_STRUCT, (yyvsp[-3].node), (yyvsp[-1].node), NULL);
+	}
+#line 3505 "src/gen_parser.c"
+    break;
+
+  case 145: /* type: "'" type  */
+#line 435 "src/parser.y"
+                   {
+		(yyval.node) = gen_type(AST_TYPE_POINTER, NULL, NULL, NULL);
+		(yyval.node)->_type.next = (yyvsp[0].node);
+	}
+#line 3514 "src/gen_parser.c"
+    break;
+
+  case 146: /* type: "[" "]" type  */
+#line 439 "src/parser.y"
+                       {
+		(yyval.node) = gen_type(AST_TYPE_ARR, NULL, NULL, NULL);
+		(yyval.node)->_type.next = (yyvsp[0].node);
+	}
+#line 3523 "src/gen_parser.c"
+    break;
+
+  case 147: /* type: "[" expr "]" type  */
+#line 443 "src/parser.y"
+                            {
+		(yyval.node) = gen_type(AST_TYPE_ARR, NULL, (yyvsp[-2].node), NULL);
+		(yyval.node)->_type.next = (yyvsp[0].node);
+	}
+#line 3532 "src/gen_parser.c"
+    break;
+
+  case 148: /* type: "typeof" expr  */
+#line 447 "src/parser.y"
+                        {
+		(yyval.node) = gen_type(AST_TYPE_TYPEOF, NULL, (yyvsp[0].node), NULL);
+	}
+#line 3540 "src/gen_parser.c"
+    break;
+
+  case 149: /* var_decl: id "mut" type  */
+#line 452 "src/parser.y"
+                        {
+		(yyval.node) = gen_var((yyvsp[-2].node), (yyvsp[0].node), NULL);
+		ast_set_flags((yyval.node), AST_FLAG_MUTABLE);
+	}
+#line 3549 "src/gen_parser.c"
+    break;
+
+  case 150: /* var_decl: id "const" type  */
+#line 456 "src/parser.y"
+                          { (yyval.node) = gen_var((yyvsp[-2].node), (yyvsp[0].node), NULL);  }
+#line 3555 "src/gen_parser.c"
+    break;
+
+  case 151: /* var_decl: id type  */
+#line 457 "src/parser.y"
+                  { (yyval.node) = gen_var((yyvsp[-1].node), (yyvsp[0].node), NULL);  }
+#line 3561 "src/gen_parser.c"
+    break;
+
+  case 152: /* var_init: var_decl "=" init_expr  */
+#line 460 "src/parser.y"
+                                 { (yyval.node) = (yyvsp[-2].node); (yyvsp[-2].node)->_var.init = (yyvsp[0].node); }
+#line 3567 "src/gen_parser.c"
+    break;
+
+  case 153: /* var_init: id "mut" "=" init_expr  */
+#line 461 "src/parser.y"
+                                 {
+		(yyval.node) = gen_var((yyvsp[-3].node), NULL, (yyvsp[0].node));
+		ast_set_flags((yyval.node), AST_FLAG_UNTYPED | AST_FLAG_MUTABLE);
+	}
+#line 3576 "src/gen_parser.c"
+    break;
+
+  case 154: /* var_init: id "const" "=" init_expr  */
+#line 465 "src/parser.y"
+                                   {
+		(yyval.node) = gen_var((yyvsp[-3].node), NULL, (yyvsp[0].node));
+		ast_set_flags((yyval.node), AST_FLAG_UNTYPED);
+	}
+#line 3585 "src/gen_parser.c"
+    break;
+
+  case 155: /* proc: id variadic_sign body  */
+#line 471 "src/parser.y"
+                            {
+		(yyval.node) = gen_proc((yyvsp[-2].node), (yyvsp[-1].node), (yyvsp[0].node));
+		ast_set_flags((yyval.node), (yyvsp[-1].node)->flags);
+	}
+#line 3594 "src/gen_parser.c"
+    break;
+
+  case 156: /* proc: "extern" id func_sign  */
+#line 475 "src/parser.y"
+                                {
+		(yyval.node) = gen_proc((yyvsp[-1].node), (yyvsp[0].node), NULL);
+		ast_set_flags((yyval.node), AST_FLAG_EXTERN);
+	}
+#line 3603 "src/gen_parser.c"
+    break;
+
+  case 157: /* lambda: "[" macro_list "]" func_sign body  */
+#line 481 "src/parser.y"
+                                          { (yyval.node) = gen_lambda((yyvsp[-3].node), (yyvsp[-1].node), (yyvsp[0].node));
+       }
+#line 3610 "src/gen_parser.c"
+    break;
+
+  case 158: /* union_elem: union  */
+#line 485 "src/parser.y"
+                  { (yyval.node) = (yyvsp[0].node); }
+#line 3616 "src/gen_parser.c"
+    break;
+
+  case 159: /* union_elem: var_decl  */
+#line 486 "src/parser.y"
+                   { (yyval.node) = (yyvsp[0].node); }
+#line 3622 "src/gen_parser.c"
+    break;
+
+  case 160: /* union_list: union_elem ";" union_list  */
+#line 489 "src/parser.y"
+                                      { (yyval.node) = (yyvsp[-2].node); (yyvsp[-2].node)->next = (yyvsp[0].node); }
+#line 3628 "src/gen_parser.c"
+    break;
+
+  case 161: /* union_list: union_elem ";"  */
+#line 490 "src/parser.y"
+                         { (yyval.node) = (yyvsp[-1].node); }
+#line 3634 "src/gen_parser.c"
+    break;
+
+  case 162: /* union: "union" id "{" union_list "}"  */
+#line 493 "src/parser.y"
+                                     {
+		(yyval.node) = gen_type(AST_TYPE_UNION, (yyvsp[-3].node), (yyvsp[-1].node), NULL);
+	}
+#line 3642 "src/gen_parser.c"
+    break;
+
+  case 163: /* union: "union" "{" union_list "}"  */
+#line 496 "src/parser.y"
+                                     {
+		(yyval.node) = gen_type(AST_TYPE_UNION, NULL, (yyvsp[-1].node), NULL);  }
+#line 3649 "src/gen_parser.c"
+    break;
+
+  case 164: /* struct_list: union_list  */
+#line 501 "src/parser.y"
+                        { (yyval.node) = (yyvsp[0].node); }
+#line 3655 "src/gen_parser.c"
+    break;
+
+  case 165: /* struct: "struct" id "{" struct_list "}"  */
+#line 504 "src/parser.y"
+                                        {
+		(yyval.node) = gen_struct((yyvsp[-3].node), NULL, (yyvsp[-1].node));
+	}
+#line 3663 "src/gen_parser.c"
+    break;
+
+  case 166: /* struct: "struct" id "(" type_list ")" "{" struct_list "}"  */
+#line 507 "src/parser.y"
+                                                            {
+		(yyval.node) = gen_struct((yyvsp[-6].node), (yyvsp[-4].node), (yyvsp[-1].node));
+	}
+#line 3671 "src/gen_parser.c"
+    break;
+
+  case 167: /* template_elem: impl ";"  */
+#line 512 "src/parser.y"
+                        { (yyval.node) = (yyvsp[-1].node); }
+#line 3677 "src/gen_parser.c"
+    break;
+
+  case 168: /* template_elem: id func_sign ";"  */
+#line 513 "src/parser.y"
+                           { (yyval.node) = gen_proc((yyvsp[-2].node), (yyvsp[-1].node), NULL);  }
+#line 3683 "src/gen_parser.c"
+    break;
+
+  case 169: /* template_elem: var_decl ";"  */
+#line 514 "src/parser.y"
+                       { (yyval.node) = (yyvsp[-1].node); }
+#line 3689 "src/gen_parser.c"
+    break;
+
+  case 170: /* template_elem: union  */
+#line 515 "src/parser.y"
+                { (yyval.node) = (yyvsp[0].node); }
+#line 3695 "src/gen_parser.c"
+    break;
+
+  case 171: /* template_list: template_elem template_list  */
+#line 518 "src/parser.y"
+                                           { (yyval.node) = (yyvsp[-1].node); (yyvsp[-1].node)->next = (yyvsp[0].node); }
+#line 3701 "src/gen_parser.c"
+    break;
+
+  case 172: /* template_list: template_elem  */
+#line 519 "src/parser.y"
+                         { (yyval.node) = (yyvsp[0].node); }
+#line 3707 "src/gen_parser.c"
+    break;
+
+  case 173: /* type_list: type "," type_list  */
+#line 522 "src/parser.y"
+                              { (yyval.node) = (yyvsp[-2].node); (yyvsp[-2].node)->next = (yyvsp[0].node); }
+#line 3713 "src/gen_parser.c"
+    break;
+
+  case 174: /* type_list: type  */
+#line 523 "src/parser.y"
+               { (yyval.node) = (yyvsp[0].node); }
+#line 3719 "src/gen_parser.c"
+    break;
+
+  case 175: /* type_alias: "type" id type  */
+#line 526 "src/parser.y"
+                           { (yyval.node) = gen_alias((yyvsp[-1].node), (yyvsp[0].node));  }
+#line 3725 "src/gen_parser.c"
+    break;
+
+  case 176: /* type_template: "type" id "{" template_list "}"  */
+#line 531 "src/parser.y"
+                                               {
+		(yyval.node) = gen_template((yyvsp[-3].node), (yyvsp[-1].node));
+	}
+#line 3733 "src/gen_parser.c"
+    break;
+
+  case 177: /* type_template: "type" id "{" "}"  */
+#line 534 "src/parser.y"
+                            {
+		/* should match anything, but doesn't implement anything */
+		(yyval.node) = gen_template((yyvsp[-2].node), NULL);
+	}
+#line 3742 "src/gen_parser.c"
+    break;
+
+  case 178: /* enum_val: id  */
+#line 540 "src/parser.y"
+             { (yyval.node) = gen_val((yyvsp[0].node), gen_int(0));  }
+#line 3748 "src/gen_parser.c"
+    break;
+
+  case 179: /* enum_val: id "=" expr  */
+#line 541 "src/parser.y"
+                      { (yyval.node) = gen_val((yyvsp[-2].node), (yyvsp[0].node));  }
+#line 3754 "src/gen_parser.c"
+    break;
+
+  case 180: /* enum_list: enum_val "," enum_list  */
+#line 544 "src/parser.y"
+                                  { (yyval.node) = (yyvsp[-2].node); (yyvsp[-2].node)->next = (yyvsp[0].node); }
+#line 3760 "src/gen_parser.c"
+    break;
+
+  case 181: /* enum_list: enum_val ","  */
+#line 545 "src/parser.y"
+                       { (yyval.node) = (yyvsp[-1].node); }
+#line 3766 "src/gen_parser.c"
+    break;
+
+  case 182: /* enum_list: enum_val  */
+#line 546 "src/parser.y"
+                   { (yyval.node) = (yyvsp[0].node); }
+#line 3772 "src/gen_parser.c"
+    break;
+
+  case 183: /* enum: "enum" id ":" type "{" enum_list "}"  */
+#line 549 "src/parser.y"
+                                           { (yyval.node) = gen_enum((yyvsp[-5].node), (yyvsp[-3].node), (yyvsp[-1].node)); }
+#line 3778 "src/gen_parser.c"
+    break;
+
+  case 184: /* enum: "enum" id "{" enum_list "}"  */
+#line 550 "src/parser.y"
+                                      {
+		(yyval.node) = gen_enum((yyvsp[-3].node), NULL, (yyvsp[-1].node));
+		ast_set_flags((yyval.node), AST_FLAG_UNTYPED);
+	}
+#line 3787 "src/gen_parser.c"
+    break;
+
+  case 185: /* top_if: "if" expr "{" unit "}"  */
+#line 556 "src/parser.y"
+                               {
+		(yyval.node) = gen_if((yyvsp[-3].node), (yyvsp[-1].node), NULL);
+		ast_set_flags((yyval.node), AST_FLAG_UNHYGIENIC);
+	}
+#line 3796 "src/gen_parser.c"
+    break;
+
+  case 186: /* top_if: "if" expr "{" unit "}" "else" "{" unit "}"  */
+#line 560 "src/parser.y"
+                                                     {
+		(yyval.node) = gen_if((yyvsp[-7].node), (yyvsp[-5].node), (yyvsp[-1].node));
+		ast_set_flags((yyval.node), AST_FLAG_UNHYGIENIC);
+	}
+#line 3805 "src/gen_parser.c"
+    break;
+
+  case 187: /* top_if: "if" expr "{" unit "}" "else" top_if  */
+#line 564 "src/parser.y"
+                                               {
+		(yyval.node) = gen_if((yyvsp[-5].node), (yyvsp[-3].node), (yyvsp[0].node));
+		ast_set_flags((yyval.node), AST_FLAG_UNHYGIENIC);
+	}
+#line 3814 "src/gen_parser.c"
+    break;
+
+  case 188: /* top: ";"  */
+#line 572 "src/parser.y"
+         { (yyval.node) = gen_empty(); }
+#line 3820 "src/gen_parser.c"
+    break;
+
+  case 189: /* top: enum  */
+#line 573 "src/parser.y"
+               { (yyval.node) = (yyvsp[0].node); }
+#line 3826 "src/gen_parser.c"
+    break;
+
+  case 190: /* top: proc  */
+#line 574 "src/parser.y"
+               { (yyval.node) = (yyvsp[0].node); }
+#line 3832 "src/gen_parser.c"
+    break;
+
+  case 191: /* top: struct  */
+#line 575 "src/parser.y"
+                 { (yyval.node) = (yyvsp[0].node); }
+#line 3838 "src/gen_parser.c"
+    break;
+
+  case 192: /* top: macro  */
+#line 576 "src/parser.y"
+                { (yyval.node) = (yyvsp[0].node); }
+#line 3844 "src/gen_parser.c"
+    break;
+
+  case 193: /* top: "const" top_if  */
+#line 577 "src/parser.y"
+                         { (yyval.node) = (yyvsp[0].node); ast_set_flags((yyval.node), AST_FLAG_CONST); }
+#line 3850 "src/gen_parser.c"
+    break;
+
+  case 194: /* top: import ";"  */
+#line 578 "src/parser.y"
+                     { (yyval.node) = (yyvsp[-1].node); }
+#line 3856 "src/gen_parser.c"
+    break;
+
+  case 195: /* top: type_alias ";"  */
+#line 579 "src/parser.y"
+                         { (yyval.node) = (yyvsp[-1].node); }
+#line 3862 "src/gen_parser.c"
+    break;
+
+  case 196: /* top: type_template  */
+#line 580 "src/parser.y"
+                        { (yyval.node) = (yyvsp[0].node); }
+#line 3868 "src/gen_parser.c"
+    break;
+
+  case 197: /* top: "pub" enum  */
+#line 581 "src/parser.y"
+                     { (yyval.node) = (yyvsp[0].node); ast_set_flags((yyvsp[0].node), AST_FLAG_PUBLIC); }
+#line 3874 "src/gen_parser.c"
+    break;
+
+  case 198: /* top: "pub" struct  */
+#line 582 "src/parser.y"
+                       { (yyval.node) = (yyvsp[0].node); ast_set_flags((yyvsp[0].node), AST_FLAG_PUBLIC); }
+#line 3880 "src/gen_parser.c"
+    break;
+
+  case 199: /* top: "pub" proc  */
+#line 583 "src/parser.y"
+                     { (yyval.node) = (yyvsp[0].node); ast_set_flags((yyvsp[0].node), AST_FLAG_PUBLIC); }
+#line 3886 "src/gen_parser.c"
+    break;
+
+  case 200: /* top: "pub" macro  */
+#line 584 "src/parser.y"
+                      { (yyval.node) = (yyvsp[0].node); ast_set_flags((yyvsp[0].node), AST_FLAG_PUBLIC); }
+#line 3892 "src/gen_parser.c"
+    break;
+
+  case 201: /* top: "pub" import ";"  */
+#line 585 "src/parser.y"
+                           { (yyval.node) = (yyvsp[-1].node); ast_set_flags((yyvsp[-1].node), AST_FLAG_PUBLIC); }
+#line 3898 "src/gen_parser.c"
+    break;
+
+  case 202: /* top: "pub" type_alias ";"  */
+#line 586 "src/parser.y"
+                               { (yyval.node) = (yyvsp[-1].node); ast_set_flags((yyvsp[-1].node), AST_FLAG_PUBLIC); }
+#line 3904 "src/gen_parser.c"
+    break;
+
+  case 203: /* top: "pub" type_template  */
+#line 587 "src/parser.y"
+                              { (yyval.node) = (yyvsp[0].node); ast_set_flags((yyvsp[0].node), AST_FLAG_PUBLIC); }
+#line 3910 "src/gen_parser.c"
+    break;
+
+  case 204: /* top: var ";"  */
+#line 588 "src/parser.y"
+                  { (yyval.node) = (yyvsp[-1].node); }
+#line 3916 "src/gen_parser.c"
+    break;
+
+  case 205: /* top: "pub" var ";"  */
+#line 589 "src/parser.y"
+                        { (yyval.node) = (yyvsp[-1].node); ast_set_flags((yyvsp[-1].node), AST_FLAG_PUBLIC); }
+#line 3922 "src/gen_parser.c"
+    break;
+
+  case 206: /* top: error  */
+#line 590 "src/parser.y"
+                {
+	    (yyval.node) = gen_empty();
+	    parser->failed = true;
+	    /* ignore any content inside a top level thing and just move onto
+	     * the next one */
+	    if (next_interesting_feature(&yylval, &yylloc, scanner, parser)) {
+		/* remove previously allocated node if we're out of input */
+		destroy_ast_node((yyval.node));
+		YYABORT;
+	    }
+	    yyclearin;
+	    yyerrok;
+	    }
+#line 3940 "src/gen_parser.c"
+    break;
+
+  case 207: /* unit: top  */
+#line 605 "src/parser.y"
+          { (yyval.node) = (yyvsp[0].node); }
+#line 3946 "src/gen_parser.c"
+    break;
+
+  case 208: /* unit: top unit  */
+#line 606 "src/parser.y"
+                   { (yyval.node) = (yyvsp[-1].node); (yyvsp[-1].node)->next = (yyvsp[0].node); }
+#line 3952 "src/gen_parser.c"
+    break;
+
+  case 209: /* input: unit  */
+#line 609 "src/parser.y"
+            { parser->tree = (yyvsp[0].node); }
+#line 3958 "src/gen_parser.c"
+    break;
+
+
+#line 3962 "src/gen_parser.c"
+
+      default: break;
+    }
+  /* User semantic actions sometimes alter yychar, and that requires
+     that yytoken be updated with the new translation.  We take the
+     approach of translating immediately before every use of yytoken.
+     One alternative is translating here after every semantic action,
+     but that translation would be missed if the semantic action invokes
+     YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
+     if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
+     incorrect destructor might then be invoked immediately.  In the
+     case of YYERROR or YYBACKUP, subsequent parser actions might lead
+     to an incorrect destructor call or verbose syntax error message
+     before the lookahead is translated.  */
+  YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc);
+
+  YYPOPSTACK (yylen);
+  yylen = 0;
+
+  *++yyvsp = yyval;
+  *++yylsp = yyloc;
+
+  /* Now 'shift' the result of the reduction.  Determine what state
+     that goes to, based on the state we popped back to and the rule
+     number reduced by.  */
+  {
+    const int yylhs = yyr1[yyn] - YYNTOKENS;
+    const int yyi = yypgoto[yylhs] + *yyssp;
+    yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
+               ? yytable[yyi]
+               : yydefgoto[yylhs]);
+  }
+
+  goto yynewstate;
+
+
+/*--------------------------------------.
+| yyerrlab -- here on detecting error.  |
+`--------------------------------------*/
+yyerrlab:
+  /* Make sure we have latest lookahead translation.  See comments at
+     user semantic actions for why this is necessary.  */
+  yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar);
+  /* If not already recovering from an error, report this error.  */
+  if (!yyerrstatus)
+    {
+      ++yynerrs;
+      {
+        yypcontext_t yyctx
+          = {yyssp, yytoken, &yylloc};
+        char const *yymsgp = YY_("syntax error");
+        int yysyntax_error_status;
+        yysyntax_error_status = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx);
+        if (yysyntax_error_status == 0)
+          yymsgp = yymsg;
+        else if (yysyntax_error_status == -1)
+          {
+            if (yymsg != yymsgbuf)
+              YYSTACK_FREE (yymsg);
+            yymsg = YY_CAST (char *,
+                             YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc)));
+            if (yymsg)
+              {
+                yysyntax_error_status
+                  = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx);
+                yymsgp = yymsg;
+              }
+            else
+              {
+                yymsg = yymsgbuf;
+                yymsg_alloc = sizeof yymsgbuf;
+                yysyntax_error_status = YYENOMEM;
+              }
+          }
+        yyerror (&yylloc, scanner, parser, yymsgp);
+        if (yysyntax_error_status == YYENOMEM)
+          YYNOMEM;
+      }
+    }
+
+  yyerror_range[1] = yylloc;
+  if (yyerrstatus == 3)
+    {
+      /* If just tried and failed to reuse lookahead token after an
+         error, discard it.  */
+
+      if (yychar <= YYEOF)
+        {
+          /* Return failure if at end of input.  */
+          if (yychar == YYEOF)
+            YYABORT;
+        }
+      else
+        {
+          yydestruct ("Error: discarding",
+                      yytoken, &yylval, &yylloc, scanner, parser);
+          yychar = YYEMPTY;
+        }
+    }
+
+  /* Else will try to reuse lookahead token after shifting the error
+     token.  */
+  goto yyerrlab1;
+
+
+/*---------------------------------------------------.
+| yyerrorlab -- error raised explicitly by YYERROR.  |
+`---------------------------------------------------*/
+yyerrorlab:
+  /* Pacify compilers when the user code never invokes YYERROR and the
+     label yyerrorlab therefore never appears in user code.  */
+  if (0)
+    YYERROR;
+  ++yynerrs;
+
+  /* Do not reclaim the symbols of the rule whose action triggered
+     this YYERROR.  */
+  YYPOPSTACK (yylen);
+  yylen = 0;
+  YY_STACK_PRINT (yyss, yyssp);
+  yystate = *yyssp;
+  goto yyerrlab1;
+
+
+/*-------------------------------------------------------------.
+| yyerrlab1 -- common code for both syntax error and YYERROR.  |
+`-------------------------------------------------------------*/
+yyerrlab1:
+  yyerrstatus = 3;      /* Each real token shifted decrements this.  */
+
+  /* Pop stack until we find a state that shifts the error token.  */
+  for (;;)
+    {
+      yyn = yypact[yystate];
+      if (!yypact_value_is_default (yyn))
+        {
+          yyn += YYSYMBOL_YYerror;
+          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror)
+            {
+              yyn = yytable[yyn];
+              if (0 < yyn)
+                break;
+            }
+        }
+
+      /* Pop the current state because it cannot handle the error token.  */
+      if (yyssp == yyss)
+        YYABORT;
+
+      yyerror_range[1] = *yylsp;
+      yydestruct ("Error: popping",
+                  YY_ACCESSING_SYMBOL (yystate), yyvsp, yylsp, scanner, parser);
+      YYPOPSTACK (1);
+      yystate = *yyssp;
+      YY_STACK_PRINT (yyss, yyssp);
+    }
+
+  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+  *++yyvsp = yylval;
+  YY_IGNORE_MAYBE_UNINITIALIZED_END
+
+  yyerror_range[2] = yylloc;
+  ++yylsp;
+  YYLLOC_DEFAULT (*yylsp, yyerror_range, 2);
+
+  /* Shift the error token.  */
+  YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp);
+
+  yystate = yyn;
+  goto yynewstate;
+
+
+/*-------------------------------------.
+| yyacceptlab -- YYACCEPT comes here.  |
+`-------------------------------------*/
+yyacceptlab:
+  yyresult = 0;
+  goto yyreturnlab;
+
+
+/*-----------------------------------.
+| yyabortlab -- YYABORT comes here.  |
+`-----------------------------------*/
+yyabortlab:
+  yyresult = 1;
+  goto yyreturnlab;
+
+
+/*-----------------------------------------------------------.
+| yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here.  |
+`-----------------------------------------------------------*/
+yyexhaustedlab:
+  yyerror (&yylloc, scanner, parser, YY_("memory exhausted"));
+  yyresult = 2;
+  goto yyreturnlab;
+
+
+/*----------------------------------------------------------.
+| yyreturnlab -- parsing is finished, clean up and return.  |
+`----------------------------------------------------------*/
+yyreturnlab:
+  if (yychar != YYEMPTY)
+    {
+      /* Make sure we have latest lookahead translation.  See comments at
+         user semantic actions for why this is necessary.  */
+      yytoken = YYTRANSLATE (yychar);
+      yydestruct ("Cleanup: discarding lookahead",
+                  yytoken, &yylval, &yylloc, scanner, parser);
+    }
+  /* Do not reclaim the symbols of the rule whose action triggered
+     this YYABORT or YYACCEPT.  */
+  YYPOPSTACK (yylen);
+  YY_STACK_PRINT (yyss, yyssp);
+  while (yyssp != yyss)
+    {
+      yydestruct ("Cleanup: popping",
+                  YY_ACCESSING_SYMBOL (+*yyssp), yyvsp, yylsp, scanner, parser);
+      YYPOPSTACK (1);
+    }
+#ifndef yyoverflow
+  if (yyss != yyssa)
+    YYSTACK_FREE (yyss);
+#endif
+  if (yymsg != yymsgbuf)
+    YYSTACK_FREE (yymsg);
+  return yyresult;
+}
+
+#line 612 "src/parser.y"
+
diff --git a/src/gen_parser.h b/src/gen_parser.h
new file mode 100644
index 0000000..85d4b3f
--- /dev/null
+++ b/src/gen_parser.h
@@ -0,0 +1,178 @@
+/* A Bison parser, made by GNU Bison 3.8.2.  */
+
+/* Bison interface for Yacc-like parsers in C
+
+   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation,
+   Inc.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
+
+/* As a special exception, you may create a larger work that contains
+   part or all of the Bison parser skeleton and distribute that work
+   under terms of your choice, so long as that work isn't itself a
+   parser generator using the skeleton or a modified version thereof
+   as a parser skeleton.  Alternatively, if you modify or redistribute
+   the parser skeleton itself, you may (at your option) remove this
+   special exception, which will cause the skeleton and the resulting
+   Bison output files to be licensed under the GNU General Public
+   License without this special exception.
+
+   This special exception was added by the Free Software Foundation in
+   version 2.2 of Bison.  */
+
+/* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual,
+   especially those whose name start with YY_ or yy_.  They are
+   private implementation details that can be changed or removed.  */
+
+#ifndef YY_YY_SRC_GEN_PARSER_H_INCLUDED
+# define YY_YY_SRC_GEN_PARSER_H_INCLUDED
+/* Debug traces.  */
+#ifndef YYDEBUG
+# define YYDEBUG 1
+#endif
+#if YYDEBUG
+extern int yydebug;
+#endif
+
+/* Token kinds.  */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+  enum yytokentype
+  {
+    YYEMPTY = -2,
+    YYEOF = 0,                     /* "end of file"  */
+    YYerror = 256,                 /* error  */
+    YYUNDEF = 257,                 /* "invalid token"  */
+    INT = 258,                     /* INT  */
+    FLOAT = 259,                   /* FLOAT  */
+    STRING = 260,                  /* STRING  */
+    ID = 261,                      /* ID  */
+    SQUOTE = 262,                  /* "'"  */
+    TO = 263,                      /* "="  */
+    ELLIPSIS = 264,                /* "..."  */
+    SEMICOLON = 265,               /* ";"  */
+    COLON = 266,                   /* ":"  */
+    BANG = 267,                    /* "!"  */
+    TYPEOF = 268,                  /* "typeof"  */
+    SIZEOF = 269,                  /* "sizeof"  */
+    PASTE = 270,                   /* "##"  */
+    STAR = 271,                    /* "*"  */
+    DIV = 272,                     /* "/"  */
+    REM = 273,                     /* "%"  */
+    MINUS = 274,                   /* "-"  */
+    PLUS = 275,                    /* "+"  */
+    POW = 276,                     /* "^^"  */
+    XOR = 277,                     /* "^"  */
+    AND = 278,                     /* "&"  */
+    OR = 279,                      /* "|"  */
+    LAND = 280,                    /* "&&"  */
+    LOR = 281,                     /* "||"  */
+    TILDE = 282,                   /* "~"  */
+    LT = 283,                      /* "<"  */
+    GT = 284,                      /* ">"  */
+    LE = 285,                      /* "<="  */
+    GE = 286,                      /* ">="  */
+    NE = 287,                      /* "!="  */
+    EQ = 288,                      /* "=="  */
+    LSHIFT = 289,                  /* "<<"  */
+    RSHIFT = 290,                  /* ">>"  */
+    PLUSSELF = 291,                /* "+="  */
+    MINUSSELF = 292,               /* "-="  */
+    STARSELF = 293,                /* "*="  */
+    DIVSELF = 294,                 /* "/="  */
+    REMSELF = 295,                 /* "%="  */
+    XORSELF = 296,                 /* "^="  */
+    POWSELF = 297,                 /* "^^="  */
+    ANDSELF = 298,                 /* "&="  */
+    ORSELF = 299,                  /* "|="  */
+    LSHIFTSELF = 300,              /* "<<="  */
+    RSHIFTSELF = 301,              /* ">>="  */
+    AT = 302,                      /* "@"  */
+    COMMA = 303,                   /* ","  */
+    PUB = 304,                     /* "pub"  */
+    STRUCT = 305,                  /* "struct"  */
+    UNION = 306,                   /* "union"  */
+    TYPEDEF = 307,                 /* "type"  */
+    IMPORT = 308,                  /* "import"  */
+    DEFER = 309,                   /* "defer"  */
+    GOTO = 310,                    /* "goto"  */
+    EMBED = 311,                   /* "embed"  */
+    IF = 312,                      /* "if"  */
+    ELSE = 313,                    /* "else"  */
+    BREAK = 314,                   /* "break"  */
+    CONTINUE = 315,                /* "continue"  */
+    SWITCH = 316,                  /* "switch"  */
+    CASE = 317,                    /* "case"  */
+    FOR = 318,                     /* "for"  */
+    WHILE = 319,                   /* "while"  */
+    DO = 320,                      /* "do"  */
+    MUT = 321,                     /* "mut"  */
+    RETURN = 322,                  /* "return"  */
+    CONST = 323,                   /* "const"  */
+    EXTERN = 324,                  /* "extern"  */
+    ENUM = 325,                    /* "enum"  */
+    DEFINE = 326,                  /* "define"  */
+    LPAREN = 327,                  /* "("  */
+    RPAREN = 328,                  /* ")"  */
+    LBRACE = 329,                  /* "{"  */
+    RBRACE = 330,                  /* "}"  */
+    LBRACKET = 331,                /* "["  */
+    RBRACKET = 332,                /* "]"  */
+    AS = 333,                      /* "as"  */
+    DOT = 334,                     /* "."  */
+    FATARROW = 335                 /* "=>"  */
+  };
+  typedef enum yytokentype yytoken_kind_t;
+#endif
+
+/* Value type.  */
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+union YYSTYPE
+{
+#line 24 "src/parser.y"
+
+	struct ast_node *node;
+	long long integer;
+	double dbl;
+	char *str;
+
+#line 151 "src/gen_parser.h"
+
+};
+typedef union YYSTYPE YYSTYPE;
+# define YYSTYPE_IS_TRIVIAL 1
+# define YYSTYPE_IS_DECLARED 1
+#endif
+
+/* Location type.  */
+#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
+typedef struct YYLTYPE YYLTYPE;
+struct YYLTYPE
+{
+  int first_line;
+  int first_column;
+  int last_line;
+  int last_column;
+};
+# define YYLTYPE_IS_DECLARED 1
+# define YYLTYPE_IS_TRIVIAL 1
+#endif
+
+
+
+
+int yyparse (void *scanner, struct parser* parser);
+
+
+#endif /* !YY_YY_SRC_GEN_PARSER_H_INCLUDED  */
diff --git a/src/imports.c b/src/imports.c
index e4d6aa7..b7dc8c1 100644
--- a/src/imports.c
+++ b/src/imports.c
@@ -1,5 +1,5 @@
-#include <ct/imports.h>
-#include <ct/debug.h>
+#include <cu/imports.h>
+#include <cu/debug.h>
 
 void add_import_path(const char *dir)
 {
diff --git a/src/lexer.l b/src/lexer.l
new file mode 100644
index 0000000..dd08ba1
--- /dev/null
+++ b/src/lexer.l
@@ -0,0 +1,212 @@
+%option reentrant noyywrap nounput noinput nodefault
+%{
+#define FROM_LEXER
+#include <cu/parser.h>
+#include <cu/debug.h>
+
+static void update_yylloc(struct parser *parser, YYLTYPE *lloc, const char *text)
+{
+	lloc->first_line = lloc->last_line;
+	lloc->first_column = lloc->last_column;
+
+	for (size_t i = 0; text[i] != 0; ++i) {
+		parser->buf_offset++;
+		if (text[i] == '\n') {
+			lloc->last_line++;
+			/* flex uses 1 based indexing */
+			lloc->last_column = 1;
+		} else {
+			lloc->last_column++;
+		}
+	}
+}
+
+#define YY_USER_ACTION update_yylloc(parser, yylloc, yytext);
+%}
+
+HEX		0[xX][0-9a-fA-F]+
+DEC		-?[0-9]+
+OCT		0[0-8]+
+BIN		0b[0-1]+
+
+INT		{HEX}|{DEC}|{OCT}|{BIN}
+
+HEXF		[+-]?0[xX][0-9a-fA-F]+([pP][+-]?[0-9]+)
+DECF		[+-]?[0-9]+[.]([eE]?[+-]?[0-9]+)?[fF]?
+FLOAT		{HEXF}|{DECF}|inf|nan
+
+ID		[_a-zA-Z][_a-zA-Z0-9]*
+
+STRING		\"(\\.|[^"\\])*\"
+
+%x SC_COMMENT
+
+%%
+"//".* {/* skip line comments */}
+
+"/*"	{BEGIN(SC_COMMENT);}
+<SC_COMMENT>{
+	"/*"	{++parser->comment_nesting;}
+	"*"+"/"	{
+		if (parser->comment_nesting)
+			--parser->comment_nesting;
+		else
+			BEGIN(INITIAL);
+	}
+
+	"*"+ {}
+	[^/*\n]+ {}
+	    [/] {}
+	    \n {}
+}
+
+"("		{return LPAREN;}
+")"		{return RPAREN;}
+"{"		{return LBRACE;}
+"}"		{return RBRACE;}
+"["		{return LBRACKET;}
+"]"		{return RBRACKET;}
+"."		{return DOT;}
+","		{return COMMA;}
+";"		{return SEMICOLON;}
+":"		{return COLON;}
+"!"		{return BANG;}
+"##"		{return PASTE;}
+"@"		{return AT;}
+
+"+"		{return PLUS;}
+"-"		{return MINUS;}
+"*"		{return STAR;}
+"/"		{return DIV;}
+"%"		{return REM;}
+"^"		{return XOR;}
+"^^"		{return POW;}
+
+'[^'\\]'	{
+	/* regular character constant, 'a' */
+	yylval->integer = yytext[1];
+	return INT;
+}
+
+'\\x[0-9a-fA-F]+' {
+	/* hex character constant, '\xef' */
+	/* handling is slightly different from C, here it's more or less just
+	 * another way to specify a hex integer */
+	yylval->integer = strtoll(yytext + 3, NULL, 16);
+	return INT;
+}
+
+'\\[0-8]+' {
+	/* octal character constant, '\033' */
+	yylval->integer = strtoll(yytext + 2, NULL, 8);
+	return INT;
+}
+
+'\\b[01]+' {
+	/* binary character constant, '\b101' */
+	yylval->integer = strtoll(yytext + 3, NULL, 2);
+	return INT;
+}
+
+'\\.' {
+	/* escaped character constant */
+	yylval->integer = match_escape(yytext[2]);
+	return INT;
+}
+
+"'"		{return SQUOTE;}
+
+"&"		{return AND;}
+"&&"		{return LAND;}
+"|"		{return OR;}
+"||"		{return LOR;}
+
+"~"		{return TILDE;}
+"="		{return TO;}
+"<"		{return LT;}
+">"		{return GT;}
+"<="		{return LE;}
+">="		{return GE;}
+"!="		{return NE;}
+"=="		{return EQ;}
+
+"=>"		{return FATARROW;}
+
+"<<"		{return LSHIFT;}
+">>"		{return RSHIFT;}
+
+"+="		{return PLUSSELF;}
+"-="		{return MINUSSELF;}
+"/="		{return DIVSELF;}
+"%="		{return REMSELF;}
+"^="		{return XORSELF;}
+"^^="		{return POWSELF;}
+"&="		{return ORSELF;}
+"|="		{return ORSELF;}
+"<<="		{return LSHIFTSELF;}
+">>="		{return RSHIFTSELF;}
+"..."		{return ELLIPSIS;}
+
+"as"		{return AS;}
+"pub"		{return PUB;}
+"defer"		{return DEFER;}
+"union"		{return UNION;}
+"struct"	{return STRUCT;}
+"type"		{return TYPEDEF;}
+"import"	{return IMPORT;}
+"typeof"	{return TYPEOF;}
+"sizeof"	{return SIZEOF;}
+"embed"		{return EMBED;}
+"if"		{return IF;}
+"goto"		{return GOTO;}
+"else"		{return ELSE;}
+"switch"	{return SWITCH;}
+"case"		{return CASE;}
+"for"		{return FOR;}
+"while"		{return WHILE;}
+"do"		{return DO;}
+"mut"		{return MUT;}
+"const"		{return CONST;}
+"return"	{return RETURN;}
+"extern"	{return EXTERN;}
+"enum"		{return ENUM;}
+"define"	{return DEFINE;}
+"break"		{return BREAK;}
+"continue"	{return CONTINUE;}
+
+{STRING} {
+	/* seems risky, I know, but letting the parser choose when to allocate a
+	 * new string seems to help with syntax error cleanup */
+	yylval->str = yytext;
+	return STRING;
+}
+
+{INT} {
+	yylval->integer = strtoll(yytext, 0, 0);
+	return INT;
+}
+
+{FLOAT}	{
+	yylval->dbl = strtod(yytext, 0);
+	return FLOAT;
+}
+
+{ID} {
+	yylval->str = yytext;
+	return ID;
+}
+
+
+[[:space:]]+	{/* skip whitespace */}
+
+. {
+	struct src_issue issue;
+	issue.level = SRC_ERROR;
+	issue.loc = to_src_loc(yylloc);
+	issue.fctx.fbuf = parser->buf;
+	issue.fctx.fname = parser->fname;
+	issue.offset = parser->buf_offset;
+	src_issue(issue, "Unexpected token: %s", yytext);
+	parser->failed = true;
+}
+%%
diff --git a/src/main.c b/src/main.c
index 93b9dfa..c63c042 100644
--- a/src/main.c
+++ b/src/main.c
@@ -2,18 +2,18 @@
 #include <stdio.h>
 #include <unistd.h>
 
-#include <ct/ctpp.h>
-#include <ct/debug.h>
-#include <ct/imports.h>
-#include <ct/compiler.h>
+#include <cu/debug.h>
+#include <cu/imports.h>
+#include <cu/compiler.h>
 
 static const char *cmdline_usage =
-"C with traits compiler usage:\n"
-" ct [-I <dir>...] [-D <var>...] infile...\n"
+"Copper compiler usage:\n"
+" cu [-I <dir>...] [-D <var>...] infile...\n"
 "	-h       Show usage (this)\n"
 "	-I <dir> Add directory to import path\n"
 "	-D <var> Add predefined variable\n"
-"	infile   Top file to compile\n"
+"	-o       Name of output\n"
+"	infile   Top file(s) to compile\n"
 ;
 
 static void usage()
@@ -24,14 +24,19 @@ static void usage()
 int main(int argc, char *argv[])
 {
 	int opt;
-	while ((opt = getopt(argc, argv, "hI:D:")) != -1) {
+	while ((opt = getopt(argc, argv, "hI:D:o:")) != -1) {
 		switch (opt) {
+		case 'o':
+			error("not yet implemented");
+			break;
+
 		case 'I':
 			add_import_path(optarg);
 			break;
 
 		case 'D':
-			add_predefined_variable(optarg);
+			/* TODO */
+			error("not yet implemented");
 			break;
 
 		case 'h':
@@ -44,13 +49,15 @@ int main(int argc, char *argv[])
 	}
 
 	if (optind >= argc) {
-		error("no input files\n");
+		error("no input files");
+		usage();
 		exit(EXIT_FAILURE);
 	}
 
 	for (int i = optind; i < argc; ++i) {
-		debug("starting compilation of '%s'\n", argv[i]);
-		compile(argv[i]);
+		debug("starting compilation of '%s'", argv[i]);
+		if (compile(argv[i]))
+			return -1;
 	}
 
 	return 0;
diff --git a/src/parser.y b/src/parser.y
new file mode 100644
index 0000000..8242c2a
--- /dev/null
+++ b/src/parser.y
@@ -0,0 +1,612 @@
+%{
+
+/* TODO: clean up this mess and I guess fix location tracking, it works for the
+ * parser but each ast node should also get some location data
+ * I'm trying something over in ast.c, but I'm not sure about it
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <cu/parser.h>
+#include <cu/ast.h>
+
+%}
+
+%locations
+
+%define parse.trace
+%define parse.error verbose
+%define api.pure full
+
+%lex-param {void *scanner} {struct parser *parser}
+%parse-param {void *scanner} {struct parser* parser}
+
+%union {
+	struct ast_node *node;
+	long long integer;
+	double dbl;
+	char *str;
+};
+
+%token <integer> INT
+%token <dbl> FLOAT
+%token <str> STRING
+%token <str> ID
+
+%token SQUOTE "'"
+%token TO "="
+%token ELLIPSIS "..."
+%token SEMICOLON ";"
+%token COLON ":"
+%token BANG "!"
+/* still not sure if this should be just typeof, would be slower to type I guess */
+%token TYPEOF "typeof"
+/* typeof does sort of fit into sizeof, hmmm */
+%token SIZEOF "sizeof"
+%token PASTE "##"
+%token STAR "*"
+%token DIV "/"
+%token REM "%"
+%token MINUS "-"
+%token PLUS "+"
+%token POW "^^"
+%token XOR "^"
+%token AND "&"
+%token OR "|"
+%token LAND "&&"
+%token LOR "||"
+%token TILDE "~"
+%token LT "<"
+%token GT ">"
+%token LE "<="
+%token GE ">="
+%token NE "!="
+%token EQ "=="
+%token LSHIFT "<<"
+%token RSHIFT ">>"
+%token PLUSSELF "+="
+%token MINUSSELF "-="
+%token STARSELF "*="
+%token DIVSELF "/="
+%token REMSELF "%="
+%token XORSELF "^="
+%token POWSELF "^^="
+%token ANDSELF "&="
+%token ORSELF "|="
+%token LSHIFTSELF "<<="
+%token RSHIFTSELF ">>="
+%token AT "@"
+%token COMMA ","
+%token PUB "pub"
+%token STRUCT "struct"
+%token UNION "union"
+%token TYPEDEF "type"
+%token IMPORT "import"
+%token DEFER "defer"
+%token GOTO "goto"
+%token EMBED "embed"
+%token IF "if"
+%token ELSE "else"
+%token BREAK "break"
+%token CONTINUE "continue"
+%token SWITCH "switch"
+%token CASE "case"
+%token FOR "for"
+%token WHILE "while"
+%token DO "do"
+%token MUT "mut"
+%token RETURN "return"
+%token CONST "const"
+%token EXTERN "extern"
+%token ENUM "enum"
+%token DEFINE "define"
+%token LPAREN "("
+%token RPAREN ")"
+%token LBRACE "{"
+%token RBRACE "}"
+%token LBRACKET "["
+%token RBRACKET "]"
+%token AS "as"
+%token DOT "."
+%token FATARROW "=>"
+
+/* precedence */
+%left "," "typeof" "sizeof"
+%right "=" "+=" "-=" "*=" "/=" "%=" "<<=" ">>=" "&=" "^=" "|=" "^^="
+%left "^^"
+%left "||"
+%left "&&"
+%left "==" "!="
+%left "<" ">" "<=" ">="
+%left "|"
+%left "^"
+%left "&"
+%left "<<" ">>"
+%left "+" "-"
+%left "*" "/" "%"
+%left "as"
+%right "'" "!" "~"
+%left "." "=>" "(" ")"
+
+/* why doesn't bison allow <*> for %nterm? would be so much easier */
+%nterm <node> import binary_op unary_op arg arg_list decl_list call expr
+%nterm <node> while do_while statement statement_list body macro_list macro
+%nterm <node> expr_list init_expr expr_if if for case case_list switch const
+%nterm <node> func_sign variadic_sign impl impl_list type var_decl var
+%nterm <node> var_init proc lambda template_elem template_list type_list
+%nterm <node> type_alias type_template enum_val enum_list enum top unit id
+%nterm <node> embed param_decl union union_list union_elem struct struct_list
+%nterm <node> top_if const_if const_for defer goto
+
+%destructor {} FLOAT INT STRING ID
+%destructor { destroy_ast_tree($$); } <*>
+
+%start input;
+%%
+id: ID {
+		$$ = gen_id(strdup($1));
+		$$->loc = to_src_loc(&yylloc);
+	}
+	;
+
+var: var_decl { $$ = $1; }
+	| var_init { $$ = $1; }
+	;
+
+embed: "embed" "(" STRING ")" { $$ = gen_embed(clone_string($3));  }
+	;
+
+import: "import" STRING { $$ = gen_import(clone_string($2));  }
+	;
+
+binary_op: expr "=" expr { $$ = gen_binop(AST_ASSIGN, $1, $3); }
+	| expr "+" expr { $$ = gen_binop(AST_ADD, $1, $3);  }
+	| expr "-" expr { $$ = gen_binop(AST_SUB, $1, $3);  }
+	| expr "*" expr { $$ = gen_binop(AST_MUL, $1, $3);  }
+	| expr "/" expr { $$ = gen_binop(AST_DIV, $1, $3);  }
+	| expr "%" expr { $$ = gen_binop(AST_REM, $1, $3);  }
+	| expr "^" expr { $$ = gen_binop(AST_XOR, $1, $3);  }
+	| expr "^^" expr { $$ = gen_binop(AST_POW, $1, $3);  }
+	| expr "&" expr { $$ = gen_binop(AST_AND, $1, $3);  }
+	| expr "&&" expr { $$ = gen_binop(AST_LAND, $1, $3);  }
+	| expr "|" expr { $$ = gen_binop(AST_OR, $1, $3);  }
+	| expr "||" expr { $$ = gen_binop(AST_LOR, $1, $3);  }
+	| expr "<<" expr { $$ = gen_binop(AST_LSHIFT, $1, $3);  }
+	| expr ">>" expr { $$ = gen_binop(AST_RSHIFT, $1, $3);  }
+	| expr "+=" expr { $$ = gen_binop(AST_ASSIGN_ADD, $1, $3);  }
+	| expr "-=" expr { $$ = gen_binop(AST_ASSIGN_SUB, $1, $3);  }
+	| expr "*=" expr { $$ = gen_binop(AST_ASSIGN_MUL, $1, $3);  }
+	| expr "/=" expr { $$ = gen_binop(AST_ASSIGN_DIV, $1, $3);  }
+	| expr "%=" expr { $$ = gen_binop(AST_ASSIGN_REM, $1, $3);  }
+	| expr "&=" expr { $$ = gen_binop(AST_ASSIGN_AND, $1, $3);  }
+	| expr "|=" expr { $$ = gen_binop(AST_ASSIGN_OR, $1, $3);  }
+	| expr "^=" expr { $$ = gen_binop(AST_ASSIGN_XOR, $1, $3);  }
+	| expr "<<=" expr {
+		$$ = gen_binop(AST_ASSIGN_LSHIFT, $1, $3);
+	}
+	| expr ">>=" expr {
+		$$ = gen_binop(AST_ASSIGN_RSHIFT, $1, $3);
+	}
+	| expr "<" expr { $$ = gen_binop(AST_LT, $1, $3);  }
+	| expr ">" expr { $$ = gen_binop(AST_GT, $1, $3);  }
+	| expr "<=" expr { $$ = gen_binop(AST_LE, $1, $3);  }
+	| expr ">=" expr { $$ = gen_binop(AST_GE, $1, $3);  }
+	| expr "!=" expr { $$ = gen_binop(AST_NE, $1, $3);  }
+	| expr "==" expr { $$ = gen_binop(AST_EQ, $1, $3);  }
+	;
+
+unary_op: "-" expr { $$ = gen_unop(AST_NEG, $2);  }
+	| "!" expr { $$ = gen_unop(AST_LNOT, $2);  }
+	| "&" expr { $$ = gen_unop(AST_REF, $2);  }
+	| "'" expr { $$ = gen_unop(AST_DEREF, $2);  }
+	| "~" expr { $$ = gen_unop(AST_NOT, $2);  }
+	;
+
+arg: "&" var_decl { $$ = gen_unop(SQUOTE, $2);  }
+	| var_decl { $$ = $1; }
+	| init_expr { $$ = $1; }
+	;
+
+arg_list: arg "," arg_list { $$ = $1; $1->next = $3; }
+	| arg { $$ = $1; }
+	;
+
+param_decl: type { $$ = gen_var(NULL, $1, NULL);  }
+
+decl_list: var_decl "," decl_list { $$ = $1; $1->next = $3; }
+	| param_decl "," decl_list { $$ = $1; $1->next = $3; }
+	| var_decl { $$ = $1; }
+	| param_decl { $$ = $1; }
+	;
+
+/* call also works for arrays in this case */
+call: id "(" arg_list ")" { $$ = gen_call($1, $3);  }
+	| id "(" ")" { $$ = gen_call($1, NULL);  }
+	;
+
+defer: "defer" "(" expr ")" { $$ = gen_defer($3);  }
+	;
+
+/* TODO: concatenate multiple strings together */
+expr: id { $$ = $1; }
+	| expr "." id { $$ = gen_dot($1, $3); }
+	| id "##" id { $$ = gen_paste($1, $3);  }
+	| "..." id { $$ = $2; }
+	| "@" { $$ = gen_last();  }
+	| INT { $$ = gen_int($1); $$->loc = to_src_loc(&yylloc); }
+	| FLOAT { $$ = gen_float($1); $$->loc = to_src_loc(&yylloc);  }
+	| STRING {
+		$$ = gen_string(clone_string($1));
+		$$->loc = to_src_loc(&yylloc);
+	}
+	| "(" expr ")" { $$ = $2; }
+	| call { $$ = $1; }
+	| defer { $$ = $1; }
+	| binary_op { $$ = $1; }
+	| unary_op { $$ = $1; }
+	| "(" var_init ")" { $$ = $2; }
+	| "sizeof" expr { $$ = gen_sizeof($2); }
+	| expr "as" type { $$ = gen_cast($1, $3);  }
+	| "as" type { $$ = gen_as($2); }
+	| embed { $$ = $1; }
+	| lambda { $$ = $1; }
+	;
+
+while: "while" expr body { $$ = gen_while($2, $3);  }
+	;
+
+do_while: "do" body "while" expr ";" {
+		$$ = gen_while($2, $4);
+		ast_set_flags($$, AST_FLAG_DELAYED);
+	}
+	;
+
+goto: "goto" id { $$ = gen_goto(gen_label($2));  }
+
+statement: expr ";" { $$ = $1; }
+	| "return" expr ";" { $$ = gen_return($2);  }
+	| "return" ";" { $$ = gen_return(NULL); }
+	| "break" ";" { $$ = gen_ctrl(AST_CTRL_BREAK, to_src_loc(&yylloc)); }
+	| "continue" ";" { $$ = gen_ctrl(AST_CTRL_CONTINUE,
+	to_src_loc(&yylloc));  }
+	| import ";" { $$ = $1; }
+	| var ";" { $$ = $1; }
+	| if { $$ = $1; }
+	| goto ";"{ $$ = $1; }
+	| id ":" { $$ = gen_label($1);  }
+	| for { $$ = $1; }
+	| const { $$ = $1; }
+	| while { $$ = $1; }
+	| do_while { $$ = $1; }
+	| switch { $$ = $1; }
+	| macro { $$ = $1; }
+	| struct { $$ = $1; }
+	| type_alias ";" { $$ = $1; }
+	| type_template { $$ = $1; }
+	| enum { $$ = $1; }
+	| body { $$ = $1; }
+	| ";" { $$ = gen_empty();  }
+	| error {
+	    /* TODO: figure out how to destroy any and all possible ast nodes we
+	     * may have generated up until the error */
+	    $$ = gen_empty();
+	    parser->failed = true;
+	    /* If we're failing to parse a statement in a block, continue by trying to
+	     * parse the next statement in the block */
+	    if (next_interesting_feature(&yylval, &yylloc, scanner, parser)) {
+		destroy_ast_node($$);
+		YYABORT;
+	    }
+	    yyclearin;
+	    yyerrok;
+	    }
+	 ;
+
+statement_list: statement statement_list { $$ = $1; $1->next = $2; }
+	| statement { $$ = $1; }
+	;
+
+body: "{" statement_list "}" { $$ = gen_block($2);  }
+	| "{" "}" { $$ = gen_block(gen_empty());  }
+	;
+
+macro_list: id "," macro_list { $$ = $1; $$->next = $3; }
+	| id { $$ = $1; }
+	;
+
+macro: "define" id "(" macro_list ")" body {
+		$$ = gen_macro($2, $4, $6);
+		ast_set_flags($6, AST_FLAG_UNHYGIENIC);
+	}
+	| "define" id "(" macro_list "..." id ")" body {
+		/* TODO: the location data of the variadic ID is way off */
+		ast_append($4, $6);
+		$$ = gen_macro($2, $4, $8);
+		ast_set_flags($$, AST_FLAG_VARIADIC);
+		ast_set_flags($8, AST_FLAG_UNHYGIENIC);
+	}
+	| "define" id "(" ")" body {
+		$$ = gen_macro($2, NULL, $5);
+		ast_set_flags($5, AST_FLAG_UNHYGIENIC);
+	}
+	;
+
+expr_list: expr "," expr_list { $$ = $1; $1->next = $3; }
+	| expr { $$ = $1; }
+	;
+
+init_expr: expr { $$ = $1; }
+	| var_init { $$ = $1; }
+	| "&" var_init { $$ = gen_unop(AND, $2);  }
+	| expr_if { $$ = $1; }
+	;
+
+expr_if: "if" init_expr body "else" body { $$ = gen_if($2, $3, $5);  }
+       | "if" init_expr body "else" expr_if { $$ = gen_if($2, $3, $5);  }
+       ;
+
+if: "if" init_expr body { $$ = gen_if($2, $3, NULL);  }
+	| "if" init_expr body "else" body { $$ = gen_if($2, $3, $5);  }
+	| "if" init_expr body "else" if { $$ = gen_if($2, $3, $5);  }
+	;
+
+for: "for" arg ";" expr ";" expr body { $$ = gen_for($2, $4, $6, $7);
+    }
+	;
+
+case: "case" expr ":" statement_list { $$ = gen_case($2, $4);  }
+	;
+
+case_list: case case_list { $$ = $1; $1->next = $2; }
+	| case { $$ = $1; }
+	;
+
+switch: "switch" expr "{" case_list "}" { $$ = gen_switch($2, $4);  }
+	;
+
+const_for: "for" id ":" expr_list body {
+		/* TODO: should id be a separate rule? */
+		$$ = gen_for($2, NULL, $4, $5);
+		ast_set_flags($5, AST_FLAG_UNHYGIENIC);
+	}
+	;
+
+const_if: "if" expr body {
+		$$ = gen_if($2, $3, NULL);
+		ast_set_flags($3, AST_FLAG_UNHYGIENIC);
+	}
+	| "if" expr body "else" body {
+		$$ = gen_if($2, $3, $5);
+		ast_set_flags($3, AST_FLAG_UNHYGIENIC);
+		ast_set_flags($5, AST_FLAG_UNHYGIENIC);
+	}
+	| "if" expr body "else" const_if {
+		$$ = gen_if($2, $3, $5);
+		ast_set_flags($3, AST_FLAG_UNHYGIENIC);
+	}
+	;
+
+/* maybe I should add a separate gen_iter_for or something and just support
+ * iterator for? */
+const: "const" const_if { $$ = $2; ast_set_flags($$, AST_FLAG_CONST);
+      }
+	| "const" const_for { $$ = $2; ast_set_flags($$, AST_FLAG_CONST);
+	 }
+	;
+
+func_sign: "(" decl_list "=>" type ")" {
+		$$ = gen_type(AST_TYPE_SIGN, NULL, $2, $4);
+	}
+	| "(" decl_list ")" { $$ = gen_type(AST_TYPE_SIGN, NULL, $2, NULL);
+	 }
+	| "(" decl_list "=>" ")" { $$ = gen_type(AST_TYPE_SIGN, NULL, $2, NULL);
+	 }
+	| "(" "=>" type ")" { $$ = gen_type(AST_TYPE_SIGN, NULL, NULL, $3);
+	 }
+	| "(" ")" { $$ = gen_type(AST_TYPE_SIGN, NULL, NULL, NULL);
+	 }
+	;
+
+variadic_sign: func_sign { $$ = $1; }
+	| "(" decl_list "..." id "=>" type ")" {
+		ast_append($2, $4);
+		$$ = gen_type(AST_TYPE_SIGN, NULL, $2, $6);
+		ast_set_flags($$, AST_FLAG_VARIADIC);
+	}
+	;
+
+impl: id "{" type_list "}" { $$ = gen_type(AST_TYPE_IMPL, $1, $3, NULL);
+     }
+	| id { $$ = gen_type(AST_TYPE_IMPL, $1, NULL, NULL);  }
+	;
+
+impl_list: impl "," impl_list { $$ = $1; $1->next = $3;}
+	| impl { $$ = $1; }
+	;
+
+type: id { $$ = gen_type(AST_TYPE_ID, $1, NULL, NULL); }
+	| "'" func_sign {
+		$$ = gen_type(AST_TYPE_POINTER, NULL, NULL, NULL);
+		$$->next = $2;
+	}
+	| id "(" impl_list ")" {
+		$$ = gen_type(AST_TYPE_STRUCT, $1, $3, NULL);
+	}
+	| "'" type {
+		$$ = gen_type(AST_TYPE_POINTER, NULL, NULL, NULL);
+		$$->_type.next = $2;
+	}
+	| "[" "]" type {
+		$$ = gen_type(AST_TYPE_ARR, NULL, NULL, NULL);
+		$$->_type.next = $3;
+	}
+	| "[" expr "]" type {
+		$$ = gen_type(AST_TYPE_ARR, NULL, $2, NULL);
+		$$->_type.next = $4;
+	}
+	| "typeof" expr {
+		$$ = gen_type(AST_TYPE_TYPEOF, NULL, $2, NULL);
+	}
+	;
+
+var_decl: id "mut" type {
+		$$ = gen_var($1, $3, NULL);
+		ast_set_flags($$, AST_FLAG_MUTABLE);
+	}
+	| id "const" type { $$ = gen_var($1, $3, NULL);  }
+	| id type { $$ = gen_var($1, $2, NULL);  }
+	;
+
+var_init: var_decl "=" init_expr { $$ = $1; $1->_var.init = $3; }
+	| id "mut" "=" init_expr {
+		$$ = gen_var($1, NULL, $4);
+		ast_set_flags($$, AST_FLAG_UNTYPED | AST_FLAG_MUTABLE);
+	}
+	| id "const" "=" init_expr {
+		$$ = gen_var($1, NULL, $4);
+		ast_set_flags($$, AST_FLAG_UNTYPED);
+	}
+	;
+
+proc: id variadic_sign body {
+		$$ = gen_proc($1, $2, $3);
+		ast_set_flags($$, $2->flags);
+	}
+	| "extern" id func_sign {
+		$$ = gen_proc($2, $3, NULL);
+		ast_set_flags($$, AST_FLAG_EXTERN);
+	}
+	;
+
+lambda: "[" macro_list "]" func_sign body { $$ = gen_lambda($2, $4, $5);
+       }
+	;
+
+union_elem: union { $$ = $1; }
+	| var_decl { $$ = $1; }
+	;
+
+union_list: union_elem ";" union_list { $$ = $1; $1->next = $3; }
+	| union_elem ";" { $$ = $1; }
+	;
+
+union: "union" id "{" union_list "}" {
+		$$ = gen_type(AST_TYPE_UNION, $2, $4, NULL);
+	}
+	| "union" "{" union_list "}" {
+		$$ = gen_type(AST_TYPE_UNION, NULL, $3, NULL);  }
+	;
+
+/* alias I guess, might try and name things better */
+struct_list: union_list { $$ = $1; }
+	;
+
+struct: "struct" id "{" struct_list "}" {
+		$$ = gen_struct($2, NULL, $4);
+	}
+	| "struct" id "(" type_list ")" "{" struct_list "}" {
+		$$ = gen_struct($2, $4, $7);
+	}
+	;
+
+template_elem: impl ";" { $$ = $1; }
+	| id func_sign ";" { $$ = gen_proc($1, $2, NULL);  }
+	| var_decl ";" { $$ = $1; }
+	| union { $$ = $1; }
+	;
+
+template_list: template_elem template_list { $$ = $1; $1->next = $2; }
+	 | template_elem { $$ = $1; }
+	 ;
+
+type_list: type "," type_list { $$ = $1; $1->next = $3; }
+	| type { $$ = $1; }
+	;
+
+type_alias: "type" id type { $$ = gen_alias($2, $3);  }
+	;
+
+/* we'll parse the arg list later in the AST and check that each node is of some
+ * specific type */
+type_template: "type" id "{" template_list "}" {
+		$$ = gen_template($2, $4);
+	}
+	| "type" id "{" "}" {
+		/* should match anything, but doesn't implement anything */
+		$$ = gen_template($2, NULL);
+	}
+	;
+
+enum_val: id { $$ = gen_val($1, gen_int(0));  }
+	| id "=" expr { $$ = gen_val($1, $3);  }
+	;
+
+enum_list: enum_val "," enum_list { $$ = $1; $1->next = $3; }
+	| enum_val "," { $$ = $1; }
+	| enum_val { $$ = $1; }
+	;
+
+enum: "enum" id ":" type "{" enum_list "}" { $$ = gen_enum($2, $4, $6); }
+	| "enum" id "{" enum_list "}" {
+		$$ = gen_enum($2, NULL, $4);
+		ast_set_flags($$, AST_FLAG_UNTYPED);
+	}
+	;
+
+top_if: "if" expr "{" unit "}" {
+		$$ = gen_if($2, $4, NULL);
+		ast_set_flags($$, AST_FLAG_UNHYGIENIC);
+	}
+	| "if" expr "{" unit "}" "else" "{" unit "}" {
+		$$ = gen_if($2, $4, $8);
+		ast_set_flags($$, AST_FLAG_UNHYGIENIC);
+	}
+	| "if" expr "{" unit "}" "else" top_if {
+		$$ = gen_if($2, $4, $7);
+		ast_set_flags($$, AST_FLAG_UNHYGIENIC);
+	}
+	;
+
+/* slightly silly to allow stray semicolons at a top level, but seems to help
+ * with recovering from certain syntax errors */
+top: ";" { $$ = gen_empty(); }
+	| enum { $$ = $1; }
+	| proc { $$ = $1; }
+	| struct { $$ = $1; }
+	| macro { $$ = $1; }
+	| "const" top_if { $$ = $2; ast_set_flags($$, AST_FLAG_CONST); }
+	| import ";" { $$ = $1; }
+	| type_alias ";" { $$ = $1; }
+	| type_template { $$ = $1; }
+	| "pub" enum { $$ = $2; ast_set_flags($2, AST_FLAG_PUBLIC); }
+	| "pub" struct { $$ = $2; ast_set_flags($2, AST_FLAG_PUBLIC); }
+	| "pub" proc { $$ = $2; ast_set_flags($2, AST_FLAG_PUBLIC); }
+	| "pub" macro { $$ = $2; ast_set_flags($2, AST_FLAG_PUBLIC); }
+	| "pub" import ";" { $$ = $2; ast_set_flags($2, AST_FLAG_PUBLIC); }
+	| "pub" type_alias ";" { $$ = $2; ast_set_flags($2, AST_FLAG_PUBLIC); }
+	| "pub" type_template { $$ = $2; ast_set_flags($2, AST_FLAG_PUBLIC); }
+	| var ";" { $$ = $1; }
+	| "pub" var ";" { $$ = $2; ast_set_flags($2, AST_FLAG_PUBLIC); }
+	| error {
+	    $$ = gen_empty();
+	    parser->failed = true;
+	    /* ignore any content inside a top level thing and just move onto
+	     * the next one */
+	    if (next_interesting_feature(&yylval, &yylloc, scanner, parser)) {
+		/* remove previously allocated node if we're out of input */
+		destroy_ast_node($$);
+		YYABORT;
+	    }
+	    yyclearin;
+	    yyerrok;
+	    }
+	;
+
+unit: top { $$ = $1; }
+	| top unit { $$ = $1; $1->next = $2; }
+	;
+
+input: unit { parser->tree = $1; }
+	| /* empty */
+	;
+%%
diff --git a/src/parser_helper.c b/src/parser_helper.c
new file mode 100644
index 0000000..2501f47
--- /dev/null
+++ b/src/parser_helper.c
@@ -0,0 +1,125 @@
+#include <stdarg.h>
+
+#include <cu/parser.h>
+#include <cu/debug.h>
+
+struct parser *create_parser()
+{
+	return calloc(1, sizeof(struct parser));
+}
+
+void destroy_parser(struct parser *p)
+{
+	yylex_destroy(p->lexer);
+	free(p);
+}
+
+void parse(struct parser *p, const char *fname, const char *buf)
+{
+	p->fname = fname;
+	p->buf = buf;
+
+	p->buf_offset = 0;
+	p->comment_nesting = 0;
+
+	p->failed = false;
+
+	yylex_init(&p->lexer);
+	yy_scan_string(buf, p->lexer);
+	yyparse(p->lexer, p);
+}
+
+/* I'm not convinced this is foolproof quite yet, more testing would be nice. */
+int next_interesting_feature(YYSTYPE *yylval, YYLTYPE *yylloc, void *scanner,
+		struct parser *parser)
+{
+	size_t depth = 0;
+	while (1) {
+		int ret = yylex(yylval, yylloc, scanner, parser);
+		if (ret == LBRACE) {
+			depth++;
+			continue;
+		}
+
+		if (ret == RBRACE && depth > 0)
+			depth--;
+
+		if (ret == RBRACE && depth == 0)
+			return 0;
+
+		if (ret == SEMICOLON && depth == 0)
+			return 0;
+
+		/* return fatal error and parser should abort */
+		if (ret == YYEOF)
+			/* some error for unmatched braces would be cool I think */
+			return 1;
+	}
+}
+
+
+struct src_loc to_src_loc(YYLTYPE *yylloc)
+{
+	struct src_loc loc;
+	loc.first_line = yylloc->first_line;
+	loc.last_line = yylloc->last_line;
+	loc.first_col = yylloc->first_column;
+	loc.last_col = yylloc->last_column;
+	return loc;
+}
+
+void yyerror(YYLTYPE *yylloc, void *lexer, struct parser *parser, const char *msg)
+{
+	(void)lexer;
+
+	struct src_issue issue;
+	issue.level = SRC_ERROR;
+	issue.loc = to_src_loc(yylloc);
+	issue.fctx.fbuf = parser->buf;
+	issue.fctx.fname = parser->fname;
+	issue.offset = parser->buf_offset;
+	src_issue(issue, msg);
+}
+
+long long match_escape(char c)
+{
+	switch (c) {
+	case '\'': return '\'';
+	case '\\': return '\\';
+	case 'a': return '\a';
+	case 'b': return '\b';
+	case 'f': return '\f';
+	case 'n': return '\n';
+	case 'r': return '\r';
+	case 't': return '\t';
+	case 'v': return '\v';
+	}
+
+	return c;
+}
+
+const char *clone_string(const char *str)
+{
+	const size_t len = strlen(str) + 1;
+	char *buf = malloc(len);
+	if (!buf) {
+		/* should probably try to handle the error in some way... */
+		internal_error("failed allocating buffer for string clone");
+		return NULL;
+	}
+
+	/* skip quotation marks */
+	size_t j = 0;
+	for (size_t i = 1; i < len - 2; ++i) {
+		char c = str[i];
+
+		if (c == '\\')
+			c = match_escape(str[++i]);
+
+		buf[j++] = c;
+	}
+
+	buf[j] = 0;
+	return buf;
+
+}
diff --git a/src/path.c b/src/path.c
index 090727d..1de8740 100644
--- a/src/path.c
+++ b/src/path.c
@@ -4,10 +4,10 @@
 #include <stdlib.h>
 #include <errno.h>
 
-#include <ct/path.h>
-#include <ct/debug.h>
+#include <cu/path.h>
+#include <cu/debug.h>
 
-char *ct_basename(const char *file)
+char *cu_basename(const char *file)
 {
 	size_t l = strlen(file);
 	size_t n = l - 1;
@@ -22,7 +22,7 @@ char *ct_basename(const char *file)
 	return strndup(file + n + 1, l - n);
 }
 
-char *ct_dirname(const char *file)
+char *cu_dirname(const char *file)
 {
 	size_t l = strlen(file);
 	size_t n = l - 1;
@@ -34,7 +34,7 @@ char *ct_dirname(const char *file)
 	return strndup(file, n);
 }
 
-char *ct_cwdname()
+char *cu_cwdname()
 {
 	size_t size;
 	long path_max = pathconf(".", _PC_PATH_MAX);
diff --git a/src/res.c b/src/res.c
index 787f50a..33718fb 100644
--- a/src/res.c
+++ b/src/res.c
@@ -8,7 +8,7 @@
 #include <stdint.h>
 #include <stdlib.h>
 
-#include <ct/res.h>
+#include <cu/res.h>
 
 /**
  * Grow resource manager buffer.
diff --git a/src/scope.c b/src/scope.c
new file mode 100644
index 0000000..2091fc4
--- /dev/null
+++ b/src/scope.c
@@ -0,0 +1,1153 @@
+#include <stddef.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <assert.h>
+
+#include <cu/debug.h>
+#include <cu/scope.h>
+#include <cu/actualize.h>
+
+/* if I ever try making the parser multithreaded, this should be atomic. */
+static size_t counter = 0;
+struct scope *create_scope()
+{
+	/* TODO: add in a scope counter, might make things easier to see in the
+	 * AST dump */
+	struct scope *scope = calloc(1, sizeof(struct scope));
+	if (!scope) {
+		internal_error("ran out of memory allocating scope");
+		return NULL;
+	}
+
+	scope->number = counter++;
+	return scope;
+}
+
+struct actual *create_actuals()
+{
+	struct actual *actuals = calloc(1, sizeof(struct actual));
+	if (!actuals) {
+		internal_error("ran out of memory allocating actuals");
+		return NULL;
+	}
+
+	return actuals;
+}
+
+void destroy_visible(struct scope *scope, struct visible *visible)
+{
+	struct visible *prev = visible, *cur;
+	if (prev)
+		do {
+			cur = prev->next;
+			/* file scope actually owns all the AST nodes, so don't
+			 * try to destroy them in lower level scopes */
+			if (scope_flags(scope, SCOPE_FILE))
+				if (prev->owner == scope)
+					destroy_ast_node(prev->node);
+			free(prev);
+		} while ((prev = cur));
+}
+
+static void destroy_scratch(struct scratch *scratch)
+{
+	struct scratch *prev = scratch, *cur;
+	if (prev)
+		do {
+			cur = prev->next;
+			destroy_ast_node(prev->node);
+			free(prev);
+		} while ((prev = cur));
+}
+
+void destroy_actuals(struct actual *actuals)
+{
+	struct actual *prev = actuals, *cur;
+	if (prev)
+		do {
+			cur = prev->next;
+			destroy_ast_node(prev->node);
+			free(prev);
+		} while ((prev = cur));
+}
+
+void destroy_scope(struct scope *scope)
+{
+	if (!scope)
+		return;
+
+	if (scope_flags(scope, SCOPE_FILE)) {
+		destroy_actuals(scope->actuals);
+		free((void *)scope->fctx.fbuf);
+		free((void *)scope->fctx.fname);
+	}
+
+	destroy_scratch(scope->scratch);
+
+	destroy_visible(scope, scope->vars);
+	destroy_visible(scope, scope->procs);
+	destroy_visible(scope, scope->macros);
+	destroy_visible(scope, scope->builtins);
+	destroy_visible(scope, scope->overrides);
+
+	destroy_visible(scope, scope->enums);
+	destroy_visible(scope, scope->structs);
+	destroy_visible(scope, scope->aliases);
+	destroy_visible(scope, scope->templates);
+
+	struct scope *prev = scope->children, *cur;
+	if (prev)
+		do {
+			cur = prev->next;
+			destroy_scope(prev);
+		} while ((prev = cur));
+
+	free(scope);
+}
+
+void scope_set_flags(struct scope *scope, enum scope_flags flags)
+{
+	assert(scope);
+	scope->flags |= flags;
+}
+
+int scope_flags(struct scope *scope, enum scope_flags flags)
+{
+	assert(scope);
+	return scope->flags & flags;
+}
+
+static struct visible *create_visible(struct scope *owner, struct ast_node *node)
+{
+	struct visible *visible = calloc(1, sizeof(struct visible));
+	visible->node = node;
+	visible->owner = owner;
+	return visible;
+}
+
+static struct scratch *create_scratch(struct ast_node *scratch)
+{
+	struct scratch *new = calloc(1, sizeof(struct scratch));
+	new->node = scratch;
+	return new;
+}
+
+/* set newest member as head of linked list */
+#define CREATE_VISIBLE(name, type, ast_type)\
+static struct visible *name(struct scope *owner, struct ast_node *node)\
+{\
+	assert(node->node_type == ast_type);\
+	struct visible *visible = create_visible(owner, node);\
+	visible->next = owner->type;\
+	owner->type = visible;\
+	return visible;\
+}
+
+CREATE_VISIBLE(create_var, vars, AST_VAR);
+CREATE_VISIBLE(create_proc, procs, AST_PROC);
+CREATE_VISIBLE(create_macro, macros, AST_MACRO);
+
+CREATE_VISIBLE(create_enum, enums, AST_ENUM);
+CREATE_VISIBLE(create_alias, aliases, AST_ALIAS);
+CREATE_VISIBLE(create_struct, structs, AST_STRUCT);
+CREATE_VISIBLE(create_builtin, builtins, AST_TYPE);
+CREATE_VISIBLE(create_template, templates, AST_TEMPLATE);
+
+/* TODO: check for identical names in the scope? */
+#define REFERENCE_VISIBLE(name, list, ast_type)\
+static int name(int public, struct scope *scope, struct visible *obj)\
+{\
+	if (!scope)\
+		return 0;\
+	assert(obj->node->node_type == ast_type);\
+	struct visible *ref = create_visible(obj->owner, obj->node);\
+	ref->next = scope->list;\
+	scope->list = ref;\
+	if (scope_flags(scope, SCOPE_FILE) && public)\
+		name(scope_flags(scope, SCOPE_PUBLIC), scope->parent, obj);\
+	return 0;\
+}
+
+REFERENCE_VISIBLE(reference_var, vars, AST_VAR);
+REFERENCE_VISIBLE(reference_proc, procs, AST_PROC);
+REFERENCE_VISIBLE(reference_macro, macros, AST_MACRO);
+REFERENCE_VISIBLE(reference_override, overrides, AST_PROC);
+
+REFERENCE_VISIBLE(reference_enum, enums, AST_ENUM);
+REFERENCE_VISIBLE(reference_alias, aliases, AST_ALIAS);
+REFERENCE_VISIBLE(reference_struct, structs, AST_STRUCT);
+REFERENCE_VISIBLE(reference_builtin, builtins, AST_TYPE);
+REFERENCE_VISIBLE(reference_template, templates, AST_TEMPLATE);
+
+/* does NOT walk the scope tree upward if it doesn't find the var in the scope
+ * */
+#define FIND_VISIBLE(name, list, ast_type, ast_name)\
+struct ast_node *name(struct scope *scope, struct ast_node *id)\
+{\
+	assert(id->node_type == AST_ID);\
+	struct visible *prev = scope->list, *cur;\
+	if (prev)\
+		do {\
+			cur = prev->next;\
+			if (identical_ast_nodes(0, prev->node->ast_name.id, id))\
+				return prev->node;\
+		} while ((prev = cur));\
+	return NULL;\
+}
+
+FIND_VISIBLE(scope_find_enum, enums, AST_ENUM, _enum);
+FIND_VISIBLE(scope_find_alias, aliases, AST_ALIAS, _alias);
+FIND_VISIBLE(scope_find_builtin, builtins, AST_TYPE, _type);
+FIND_VISIBLE(scope_find_struct, structs, AST_STRUCT, _struct);
+FIND_VISIBLE(scope_find_template, templates, AST_TEMPLATE, _template);
+/* note that these return the first match for the ID, and as such might not be
+ * what should be called. */
+FIND_VISIBLE(scope_find_var, vars, AST_VAR, _var);
+FIND_VISIBLE(scope_find_proc, procs, AST_PROC, _proc);
+FIND_VISIBLE(scope_find_override, overrides, AST_PROC, _proc);
+FIND_VISIBLE(scope_find_macro, macros, AST_MACRO, _macro);
+
+struct ast_node *scope_find(struct scope *scope, struct ast_node *id)
+{
+	assert(id->node_type == AST_ID);
+
+	struct ast_node *found = scope_find_var(scope, id);
+	if (found)
+		return found;
+
+	found = scope_find_proc(scope, id);
+	if (found)
+		return found;
+
+	found = scope_find_macro(scope, id);
+	if (found)
+		return found;
+
+	found = scope_find_alias(scope, id);
+	if (found)
+		return found;
+
+	found = scope_find_template(scope, id);
+	if (found)
+		return found;
+
+	return NULL;
+}
+
+/* procedure adding requires a bit of tweaking, as a different number of
+ * arguments effectively means different functions, not just the name */
+#define ADD_VISIBLE(name, obj_type, ast_type, ast_name)\
+int name(struct scope *scope, struct ast_node *node)\
+{\
+	assert(node->node_type == ast_type);\
+	struct ast_node *shadow = file_scope_find(scope, node->ast_name.id);\
+	if (shadow) {\
+		semantic_error(scope->fctx, node, "shadowing is not allowed");\
+		semantic_info(scope->fctx, shadow, "previous declaration was here");\
+		return -1;\
+	}\
+	int public = scope_flags(scope, SCOPE_PUBLIC);\
+	struct visible *visible = create_##obj_type(scope, node);\
+	if (scope_flags(scope, SCOPE_FILE) && ast_flags(node, AST_FLAG_PUBLIC))\
+		return reference_##obj_type(public, scope->parent, visible);\
+	return 0;\
+}
+
+struct visible *create_type(struct scope *scope, struct ast_node *type)
+{
+	switch (type->node_type) {
+	case AST_TYPE: return create_builtin(scope, type);
+	case AST_ALIAS: return create_alias(scope, type);
+	case AST_TEMPLATE: return create_template(scope, type);
+	case AST_ENUM: return create_enum(scope, type);
+	case AST_STRUCT: return create_struct(scope, type);
+	default:
+			 semantic_error(scope->fctx, type, "unknown type");
+			 return NULL;
+	}
+}
+
+int reference_type(int public, struct scope *scope, struct visible *visible)
+{
+	switch (visible->node->node_type) {
+	case AST_TYPE: return reference_builtin(public, scope, visible);
+	case AST_ALIAS: return reference_alias(public, scope, visible);
+	case AST_TEMPLATE: return reference_template(public, scope, visible);
+	case AST_ENUM: return reference_enum(public, scope, visible);
+	case AST_STRUCT: return reference_struct(public, scope, visible);
+	default:
+			 semantic_error(scope->fctx, visible->node, "unknown type");
+			 return 1;
+	}
+}
+
+int scope_add_type(struct scope *scope, struct ast_node *type)
+{
+	struct ast_node *exists = file_scope_resolve_type(scope, type);
+
+	/* redefining a type to itself is allowed, and might be necessary for
+	 * some generics operations. I'll have to double check this later,
+	 * though */
+	/* e.g. struct (vec{t}) or something, all instances of this 'type'
+	 * detected anywhere should be allowed to be 'added' */
+	if (exists)
+		return 0;
+
+	int public = scope_flags(scope, SCOPE_PUBLIC);
+	/* during a redefine, if it's redefined to public should it be
+	 * propagated upward? Probably not, but dunno for sure yet */
+	struct visible *visible = create_type(scope, type);
+	if (scope_flags(scope, SCOPE_FILE) && ast_flags(type, AST_FLAG_PUBLIC))
+		return reference_type(public, scope->parent, visible);
+
+	return 0;
+}
+
+struct ast_node *scope_find_type(struct scope *scope, struct ast_node *id)
+{
+	assert(id->node_type == AST_ID);
+
+	struct ast_node *found = scope_find_builtin(scope, id);
+	if (found)
+		return found;
+
+	found = scope_find_enum(scope, id);
+	if (found)
+		return found;
+
+	found = scope_find_struct(scope, id);
+	if (found)
+		return found;
+
+	found = scope_find_alias(scope, id);
+	if (found)
+		return found;
+
+	found = scope_find_template(scope, id);
+	if (found)
+		return found;
+
+	return NULL;
+}
+
+ADD_VISIBLE(scope_add_var, var, AST_VAR, _var);
+ADD_VISIBLE(scope_add_alias, alias, AST_ALIAS, _alias);
+ADD_VISIBLE(scope_add_template, template, AST_TEMPLATE, _template);
+
+static int add_implementation(struct ast_node *template, struct ast_node *type)
+{
+	assert(template->node_type == AST_TEMPLATE && type->node_type == AST_TYPE);
+	struct template_implemented *by = calloc(1, sizeof(*type));
+	if (!by) {
+		internal_error("failed allocating memory for implementation");
+		return 1;
+	}
+
+	by->type = type;
+	by->next = template->_template.impl_by;
+	template->_template.impl_by = by;
+	return 0;
+}
+
+static void remove_implementation(struct ast_node *template, struct ast_node *type)
+{
+	assert(template->node_type == AST_TEMPLATE);
+	struct template_implemented *prev = template->_template.impl_by, *cur;
+	if (prev)
+		do {
+			cur = prev->next;
+			if (!cur)
+				break;
+
+			if (identical_ast_nodes(0, cur->type, type)) {
+				struct template_implemented *next = cur->next;
+				prev->next = next;
+				free(cur);
+				return;
+			}
+		} while ((prev = cur));
+}
+
+static int find_implementation(struct ast_node *template, struct ast_node *type)
+{
+	assert(template->node_type == AST_TEMPLATE);
+	struct template_implemented *prev = template->_template.impl_by, *cur;
+	if (prev)
+		do {
+			cur = prev->next;
+			if (identical_ast_nodes(0, prev->type, type)) {
+				return 1;
+			}
+		} while ((prev = cur));
+
+	return 0;
+}
+
+static struct ast_node *match_macro(int global, struct scope *scope,
+		struct ast_node *id, struct ast_node *args)
+{
+	const size_t arg_count = ast_list_len(args);
+	struct visible *prev = scope->macros, *cur;
+	if (prev)
+		do {
+			cur = prev->next;
+			struct ast_node *macro = prev->node;
+			/* must have identical IDs */
+			if (!identical_ast_nodes(0, macro->_macro.id, id))
+				continue;
+
+			const size_t param_count = ast_list_len(macro->_macro.params);
+
+			/* if macros have the same number of arguments, they
+			 * match */
+			if (param_count == arg_count)
+				return macro;
+
+			/* if we have a variadic macro, a longer list of args is
+			 * a match */
+			if (ast_flags(macro, AST_FLAG_VARIADIC)
+					&& param_count < arg_count)
+				return macro;
+
+		} while ((prev = cur));
+
+	if (global && !scope_flags(scope, SCOPE_FILE))
+		return match_macro(global, scope->parent, id, args);
+
+	return NULL;
+}
+
+static int implements(struct scope *scope,
+		struct ast_node *arg_type, struct ast_node *param_type);
+
+static struct ast_node *match_proc(int global, struct scope *scope,
+		struct ast_node *id, struct ast_node *args);
+
+static int implements_proc(struct scope *scope, struct ast_node *arg_type,
+		struct ast_node *param_type, struct ast_node *proc)
+{
+	assert(proc->node_type == AST_PROC);
+	/* temp */
+	struct ast_node *id = proc->_proc.id;
+	/* this removes type info, bit of an issue */
+	struct ast_node *sign = clone_ast_node(proc->_proc.sign);
+	struct ast_node *params = sign->_type.sign.params;
+	struct ast_node *ret = sign->_type.sign.ret;
+
+	replace_param_types(params, param_type, arg_type);
+	replace_param_types(ret, param_type, arg_type);
+
+	struct ast_node *impl = match_proc(1, scope, id, params);
+	if (!impl)
+		goto out;
+
+	struct ast_node *impl_ret = impl->_proc.sign->_type.sign.ret;
+	/* note important distinction between when to use ->type and when to not
+	 * in short: ->type can be a template or alias, not using it is the type
+	 * before being resolved.
+	 */
+	/* TODO: detect loops, such as when two template return params rely on
+	 * eachother */
+	if (!implements(scope, impl_ret, ret)) {
+		char *irt = type_str(impl_ret);
+		char *prt = type_str(ret);
+		semantic_error(scope->fctx, proc, "return type mismatch");
+		semantic_info(scope->fctx, impl, "found return type %s, expected %s",
+				irt, prt);
+		free(irt);
+		free(prt);
+		impl = NULL;
+	}
+
+out:
+	destroy_ast_node(sign);
+	return impl != NULL;
+}
+
+static int implements_var(struct scope *scope, struct ast_node *arg_type,
+		struct ast_node *param_type, struct ast_node *var)
+{
+	assert(var->node_type == AST_VAR);
+	/* temp */
+	return 0;
+}
+
+static int implements_template(struct scope *scope, struct ast_node *arg_type,
+		struct ast_node *param_type)
+{
+	assert(param_type->_type.kind == AST_TYPE_TEMPLATE);
+	struct ast_node *template = param_type->_type.template.template;
+	/* if we already know we implement this template, nothing to do */
+	if (find_implementation(template, arg_type))
+		return 1;
+
+	/* optimistically assume we implement type template */
+	/* TODO: this optimism might be questionable, as some template might rely
+	 * on another template being implemented by the same type.
+	 * The other type will return an error message, and the compilation will
+	 * fail, but the error messages generated might be misleading. Look into
+	 * it at some point. */
+	add_implementation(template, arg_type);
+
+	struct ast_node *body = template->_template.body;
+
+	/* if the body is empty, match */
+	struct ast_node *elem = body;
+	if (elem)
+		do {
+			if (elem->node_type == AST_VAR) {
+				if (implements_var(scope, arg_type, param_type, elem))
+					continue;
+
+				char *type = type_str(arg_type);
+				struct ast_node *id = elem->_proc.id;
+				semantic_error(scope->fctx, elem,
+						"%s does not have member %s",
+						type, id->_id.id);
+				free(type);
+				goto not_implemented;
+			}
+
+			else if (elem->node_type == AST_PROC) {
+				if (implements_proc(scope, arg_type, param_type, elem))
+					continue;
+
+				char *type = type_str(arg_type);
+				struct ast_node *id = elem->_proc.id;
+				semantic_error(scope->fctx, elem,
+						"%s does not implement %s",
+						type, id->_id.id);
+				free(type);
+				goto not_implemented;
+			}
+
+			else {
+				semantic_error(scope->fctx, elem,
+						"illegal template element");
+				goto not_implemented;
+			}
+		} while ((elem = elem->next));
+
+	return 1;
+
+not_implemented:
+	remove_implementation(template, arg_type);
+	return 0;
+}
+
+static int implements(struct scope *scope,
+		struct ast_node *arg_type, struct ast_node *param_type)
+{
+	/* if both types are null, they are uninitialized and we'll assume they
+	 * don't implement eachother. This essentially means that during the
+	 * analysis phase everything is added to the procs */
+	if (!arg_type && !param_type)
+		return 0;
+
+	/* only the variadic argument in parameters has no type, so any actual
+	 * type implements it */
+	/* slight hack: macro arguments also don't have a type, so they will
+	 * also 'implement' type */
+	if (!param_type)
+		return 1;
+
+	/* at this point, we should always have some type for the argument */
+	assert(arg_type);
+
+	/* TODO: do aliases and templates have to be converted to types? Are
+	 * there any situations where a template will have to be followed by
+	 * some other type? */
+	/* if the parameter type is not a template, it's an actual type and therefore the
+	 * argument type must be identical to it */
+	if (param_type->_type.kind == AST_TYPE_TEMPLATE) {
+		/* the argument type must at this point be templateable, i.e.
+		 * 'i64 does not implement some_type, but would implement
+		 * 'some_type
+		if (!is_templateable(arg_type))
+			return 0;
+		*/
+
+		return implements_template(scope, arg_type, param_type);
+	}
+
+	if (!types_match(arg_type, param_type))
+		return 0;
+
+	/* if both types have next elements in them, analyze them as well */
+	if (arg_type->_type.next && param_type->_type.next)
+		return implements(scope, arg_type->_type.next, param_type->_type.next);
+
+	/* if this is the last type element in both types, they match */
+	if (!arg_type->_type.next && !param_type->_type.next)
+		return 1;
+
+	/* otherwise, no match */
+	return 0;
+}
+
+static int match_args(struct scope *scope, int variadic,
+		const struct ast_node *args, const struct ast_node *params)
+{
+	/* no arguments matches to no parameters */
+	if (!params && !args)
+		return 1;
+
+	while (params && args) {
+		if (!implements(scope, args->type, params->type))
+			return 0;
+
+		params = params->next;
+		args = args->next;
+	}
+
+	if (args) {
+		/* if we have arguments left over and the proc is variadic, we
+		 * match. The last argument is replaced with the trailing list
+		 * of arguments beyond the parameter list. */
+		if (variadic)
+			return 1;
+
+		return 0;
+	}
+
+	/* we have more parameters compared to arguments, so there's no way we
+	 * match */
+	if (params)
+		return 0;
+
+	/* we have the same number of arguments and they all implement the
+	 * parameters, so we match */
+	return 1;
+}
+
+static struct ast_node *iter_procs(struct scope *scope, struct visible *first,
+		struct ast_node *id, struct ast_node *args)
+{
+	struct visible *prev = first, *cur;
+	if (prev)
+		do {
+			cur = prev->next;
+			struct ast_node *proc = prev->node;
+			/* must have identical IDs */
+			if (!identical_ast_nodes(0, proc->_proc.id, id))
+				continue;
+
+			const int variadic = ast_flags(proc, AST_FLAG_VARIADIC);
+			const struct ast_node *sign = proc->_proc.sign;
+			const struct ast_node *params = sign->_type.sign.params;
+			if (match_args(scope, variadic, args, params))
+				return proc;
+
+		} while ((prev = cur));
+
+	return NULL;
+}
+
+static struct ast_node *match_proc(int global, struct scope *scope,
+		struct ast_node *id, struct ast_node *args)
+{
+	struct ast_node *override = iter_procs(scope, scope->overrides, id, args);
+	if (override)
+		return override;
+
+	struct ast_node *proc = iter_procs(scope, scope->procs, id, args);
+	if (proc)
+		return proc;
+
+	if (global && !scope_flags(scope, SCOPE_FILE))
+		return match_proc(global, scope->parent, id, args);
+
+	return NULL;
+}
+
+int scope_add_macro(struct scope *scope, struct ast_node *macro)
+{
+	assert(macro->node_type == AST_MACRO);
+
+	/* TODO: separate between arrays and macros? */
+	struct ast_node *id = macro->_macro.id;
+	struct ast_node *params = macro->_macro.params;
+
+	int macro_exists = match_macro(0, scope, id, params) != NULL;
+	int proc_exists = match_proc(0, scope, id, params) != NULL;
+
+	if (macro_exists || proc_exists) {
+		semantic_error(scope->fctx, macro, "macro redefined");
+		return -1;
+	}
+
+	struct visible *new = create_macro(scope, macro);
+	if (!new)
+		return -1;
+
+	int public = scope_flags(scope, SCOPE_PUBLIC);
+	if (scope_flags(scope, SCOPE_FILE) && ast_flags(macro, AST_FLAG_PUBLIC))
+		return reference_macro(public, scope->parent, new);
+
+	return 0;
+}
+
+/* would be useful with scope_remove_proc which also removed all references? */
+int scope_add_proc(struct scope *scope, struct ast_node *proc)
+{
+	assert(proc->node_type == AST_PROC);
+
+	struct ast_node *id = proc->_proc.id;
+	struct ast_node *sign = proc->_proc.sign;
+	struct ast_node *params = sign->_type.sign.params;
+
+	int macro_exists = match_macro(0, scope, id, params) != NULL;
+	int proc_exists = match_proc(0, scope, id, params) != NULL;
+
+	if (macro_exists || proc_exists) {
+		semantic_error(scope->fctx, proc, "proc redefined");
+		return -1;
+	}
+
+	struct visible *new = create_proc(scope, proc);
+	if (!new)
+		return -1;
+
+	int public = scope_flags(scope, SCOPE_PUBLIC);
+	if (scope_flags(scope, SCOPE_FILE) && ast_flags(proc, AST_FLAG_PUBLIC))
+		return reference_proc(public, scope->parent, new);
+
+	return 0;
+}
+
+int scope_add_existing_var(struct scope *scope, struct visible *visible)
+{
+	struct ast_node *node = visible->node;
+	assert(node->node_type == AST_VAR);
+	struct ast_node *shadow = file_scope_find(scope, node->_var.id);
+	if (shadow) {
+		semantic_error(scope->fctx, node, "shadowing is not allowed\n");
+		semantic_info(scope->fctx, shadow, "previous declaration was here\n");
+		return -1;
+	}
+
+	visible->next = scope->vars;
+	scope->vars = visible;
+
+	int public = scope_flags(scope, SCOPE_PUBLIC);
+	if (scope_flags(scope, SCOPE_FILE) && ast_flags(node, AST_FLAG_PUBLIC))
+		return reference_proc(public, scope->parent, visible);
+
+	return 0;
+}
+
+int scope_add_existing_proc(struct scope *scope, struct visible *visible)
+{
+	struct ast_node *proc = visible->node;
+	assert(proc->node_type == AST_PROC);
+
+	struct ast_node *id = proc->_proc.id;
+	struct ast_node *sign = proc->_proc.sign;
+	struct ast_node *params = sign->_type.sign.params;
+
+	int macro_exists = match_macro(0, scope, id, params) != NULL;
+	int proc_exists = match_proc(0, scope, id, params) != NULL;
+
+	if (macro_exists || proc_exists) {
+		semantic_error(scope->fctx, proc, "proc redefined");
+		return -1;
+	}
+
+	struct ast_node *template = NULL;
+	while (params) {
+		if ((template = extract_template(params->type)))
+			break;
+
+		params = params->next;
+	}
+
+	if (template) {
+		visible->next = scope->procs;
+		scope->procs = visible;
+	}
+	else {
+		/* override is maybe a bit misleading, but essentially any
+		 * procedure with no templates */
+		visible->next = scope->overrides;
+		scope->overrides = visible;
+	}
+
+	int public = scope_flags(scope, SCOPE_PUBLIC);
+	if (scope_flags(scope, SCOPE_FILE) && ast_flags(proc, AST_FLAG_PUBLIC)) {
+		if (template)
+			return reference_proc(public, scope->parent, visible);
+
+		return reference_override(public, scope->parent, visible);
+	}
+
+	return 0;
+}
+
+#define FIND_FILE_VISIBLE(name, obj_type)\
+struct ast_node *name(struct scope *scope, struct ast_node *id)\
+{\
+	assert(id->node_type == AST_ID);\
+	struct ast_node *found = scope_find_##obj_type(scope, id);\
+	if (found)\
+		return found;\
+	if (!scope_flags(scope, SCOPE_FILE))\
+		return file_scope_find_##obj_type(scope->parent, id);\
+	return NULL;\
+}
+
+struct ast_node *file_scope_find_type(struct scope *scope, struct ast_node *type)
+{
+	assert(type->node_type == AST_ID);
+	struct ast_node *found = scope_find_type(scope, type);
+	if (found)
+		return found;
+
+	if (!found && !scope_flags(scope, SCOPE_FILE))
+		return file_scope_find_type(scope->parent, type);
+
+	return NULL;
+}
+
+FIND_FILE_VISIBLE(file_scope_find_var, var);
+FIND_FILE_VISIBLE(file_scope_find_proc, proc);
+FIND_FILE_VISIBLE(file_scope_find_override, override);
+FIND_FILE_VISIBLE(file_scope_find_macro, macro);
+FIND_FILE_VISIBLE(file_scope_find_alias, alias);
+FIND_FILE_VISIBLE(file_scope_find_template, template);
+
+struct ast_node *file_scope_find(struct scope *scope, struct ast_node *id)
+{
+	/* TODO: should probably check for incoming search and filter out params
+	 * etc */
+	assert(id->node_type == AST_ID);
+
+	struct ast_node *found = file_scope_find_var(scope, id);
+	if (found)
+		return found;
+
+	found = file_scope_find_proc(scope, id);
+	if (found)
+		return found;
+
+	found = file_scope_find_macro(scope, id);
+	if (found)
+		return found;
+
+	found = file_scope_find_alias(scope, id);
+	if (found)
+		return found;
+
+	found = file_scope_find_template(scope, id);
+	if (found)
+		return found;
+
+	return NULL;
+}
+
+struct ast_node *scope_resolve_macro(struct scope *scope, struct ast_node *call)
+{
+	assert(call->node_type == AST_CALL);
+	struct ast_node *id = call->_call.id;
+	struct ast_node *args = call->_call.args;
+	return match_macro(0, scope, id, args);
+}
+
+static int template_contains_proc(struct scope *scope, struct ast_node *template,
+		struct ast_node *id, struct ast_node *args)
+{
+	assert(template->_type.kind == AST_TYPE_TEMPLATE);
+	template = template->_type.template.template;
+
+	struct ast_node *elem = template->_template.body;
+	if (elem)
+		do {
+			if (elem->node_type != AST_PROC)
+				continue;
+
+			if (!identical_ast_nodes(0, elem->_proc.id, id))
+				continue;
+
+			/* TODO: should I check for return type here as well? */
+			int variadic = ast_flags(elem, AST_FLAG_VARIADIC);
+			struct ast_node *sign = elem->_proc.sign;
+			struct ast_node *params = sign->_type.sign.params;
+			if (match_args(scope, variadic, args, params))
+				return 1;
+
+		} while ((elem = elem->next));
+
+	return 0;
+}
+
+struct ast_node *scope_resolve_proc(struct scope *scope, struct ast_node *call)
+{
+	/* TODO: we should prefer specialized procs over generic ones.
+	 * i.e. do_stuff(a u32){} should be preferred over do_stuff(a some_type){},
+	 * when u32 implements some_type. */
+	assert(call->node_type == AST_CALL);
+	struct ast_node *id = call->_call.id;
+	struct ast_node *args = call->_call.args;
+
+	/* TODO: this prints out an error for each scope we run through, figure
+	 * out where we should check for this stuff so only a single error is
+	 * printed */
+	/* loop over arguments, if any of them are templated check that the
+	 * found proc can be found in the template */
+	struct ast_node *arg = args;
+	while (arg) {
+		struct ast_node *template = extract_template(arg->type);
+		if (!template)
+			goto next;
+
+		if (!template_contains_proc(scope, template, id, args)) {
+			char *cstr = call_str(call);
+			char *tstr = type_str(arg);
+			semantic_error(scope->fctx, arg, "%s not associated with %s",
+					cstr,
+					tstr);
+			free(cstr);
+			free(tstr);
+			return NULL;
+		}
+
+next:
+		arg = arg->next;
+	}
+
+	struct ast_node *proc = match_proc(0, scope, id, args);
+	if (!proc)
+		return NULL;
+
+	return proc;
+}
+
+struct ast_node *scope_resolve_actual(struct scope *scope, struct ast_node *call)
+{
+	assert(call->node_type == AST_CALL);
+	struct actual *prev = scope->actuals, *cur;
+
+	if (prev)
+		do {
+			cur = prev->next;
+			struct ast_node *actual = prev->node;
+			if (!actual)
+				continue;
+
+			if (!identical_ast_nodes(0, actual->_proc.id, call->_call.id))
+				continue;
+
+			assert(!ast_flags(actual, AST_FLAG_VARIADIC));
+			/* could also check that arguments aren't templates */
+			const struct ast_node *args = call->_call.args;
+			const struct ast_node *sign = actual->_proc.sign;
+			const struct ast_node *params = sign->_type.sign.params;
+			if (match_args(scope, 0, args, params))
+				return actual;
+
+		} while ((prev = cur));
+
+	return NULL;
+}
+
+struct ast_node *scope_resolve_arr(struct scope *scope, struct ast_node *call)
+{
+	assert(call->node_type == AST_CALL);
+	/* could implement arrays in multiple dimensions, though that might make
+	 * other things complicated so disallow it for now */
+	if (ast_list_len(call->_call.args) != 1)
+		return NULL;
+
+	struct ast_node *arg = call->_call.args;
+	struct ast_node *var = scope_find_var(scope, call->_call.id);
+	if (!var)
+		return NULL;
+
+	/* TODO: actualize has types_match, should it be generalized into ast.c
+	 * or something? */
+	if (!identical_ast_nodes(0, var->type, arg->type))
+		return NULL;
+
+	return var;
+}
+
+struct ast_node *scope_resolve_call(struct scope *scope, struct ast_node *call)
+{
+	assert(call->node_type == AST_CALL);
+	/* TODO: should make sure we're getting an array at some point */
+	struct ast_node *found = scope_resolve_arr(scope, call);
+	if (found)
+		return found;
+
+	found = scope_resolve_macro(scope, call);
+	if (found)
+		return found;
+
+	found = scope_resolve_actual(scope, call);
+	if (found)
+		return found;
+
+	found = scope_resolve_proc(scope, call);
+	if (found)
+		return found;
+
+	return NULL;
+}
+
+struct ast_node *file_scope_resolve_call(struct scope *scope, struct ast_node *call)
+{
+	struct ast_node *found = scope_resolve_call(scope, call);
+	if (found)
+		return found;
+
+	if (!scope_flags(scope, SCOPE_FILE))
+		return file_scope_resolve_call(scope->parent, call);
+
+	return NULL;
+}
+
+struct ast_node *scope_resolve_type(struct scope *scope, struct ast_node *type)
+{
+	struct ast_node *id = NULL;
+	switch (type->node_type) {
+	case AST_ID: id = type; break;
+	case AST_TYPE:
+		     assert(type->_type.kind == AST_TYPE_ID);
+		     id = type->_type.id;
+		     break;
+
+	case AST_ALIAS:
+		     id = type->_alias.id;
+		     break;
+
+	case AST_TEMPLATE:
+		     id = type->_template.id;
+		     break;
+
+	case AST_STRUCT:
+		     id = type->_struct.id;
+		     break;
+
+	case AST_ENUM:
+		     id = type->_enum.id;
+		     break;
+
+	default:
+		     semantic_error(scope->fctx, type, "unknown type");
+		     return NULL;
+	}
+
+	return scope_find_type(scope, id);
+}
+
+struct ast_node *file_scope_resolve_type(struct scope *scope, struct ast_node *type)
+{
+	struct ast_node *found = scope_resolve_type(scope, type);
+	if (found)
+		return found;
+
+	if (!scope_flags(scope, SCOPE_FILE))
+		return file_scope_resolve_type(scope->parent, type);
+
+	return NULL;
+}
+
+/* this might be useful somewhere else as well */
+static const char *default_types[] = {"u8", "u16", "u32", "u64",
+	"i8" "i16", "i32", "i64",
+	"usize", "isize", "f32", "f64", "void"};
+
+/* TODO: add error checking */
+int scope_add_defaults(struct scope *root)
+{
+	for (size_t i = 0; i < sizeof(default_types) / sizeof(default_types[0]); ++i) {
+		const char *type = default_types[i];
+		struct ast_node *n = gen_id(strdup(type));
+		if (!n)
+			return -1;
+
+		struct ast_node *a = gen_type(AST_TYPE_ID, n, NULL, NULL);
+		if (!a)
+			return -1;
+
+		scope_add_type(root, a);
+	}
+
+	return 0;
+}
+
+void scope_destroy_defaults(struct scope *scope)
+{
+	/* just enough data to get through to the actual default aliases */
+	struct ast_node type = {0};
+	type.node_type = AST_ID;
+
+	for (size_t i = 0; i < sizeof(default_types) / sizeof(default_types[0]); ++i) {
+		type._id.id = default_types[i];
+		struct ast_node *n = scope_find_alias(scope, &type);
+		/* something is afoot, but at least try to free the rest */
+		if (!n)
+			continue;
+
+		destroy_ast_node(n);
+	}
+}
+
+void scope_add_scope(struct scope *parent, struct scope *child)
+{
+	assert(parent);
+	assert(child);
+
+	if (!scope_flags(child, SCOPE_FILE)) {
+		child->actuals = parent->actuals;
+		child->fctx = parent->fctx;
+	}
+
+	child->parent = parent;
+	child->next = parent->children;
+	parent->children = child;
+}
+
+static int add_actual(struct actual *actuals, struct ast_node *node)
+{
+	/* TODO: check that there isn't already an actual like ours */
+	struct actual *actual = calloc(1, sizeof(struct actual));
+	if (!actual)
+		return -1;
+
+	actual->next = actuals->next;
+	actual->node = node;
+	actuals->next = actual;
+	return 0;
+}
+
+int scope_add_actual(struct scope *scope, struct ast_node *node)
+{
+	return add_actual(scope->actuals, node);
+}
+
+static struct ast_node *find_actual(struct actual *actuals, struct ast_node *node)
+{
+	/* TODO */
+	internal_error("finding actuals not yet implemented");
+	return NULL;
+}
+
+struct ast_node *scope_find_actual(struct scope *scope, struct ast_node *node)
+{
+	return find_actual(scope->actuals, node);
+}
+
+int scope_add_scratch(struct scope *scope, struct ast_node *scratch)
+{
+	struct scratch *new = create_scratch(scratch);
+	if (!new) {
+		internal_error("failed allocating scratch node");
+		return -1;
+	}
+
+	new->next = scope->scratch;
+	scope->scratch = new;
+	return 0;
+}
diff --git a/src/source.mk b/src/source.mk
index fd4a8e6..3e01ba6 100644
--- a/src/source.mk
+++ b/src/source.mk
@@ -1,2 +1,10 @@
 SRC_LOCAL != echo src/*.c
 SOURCES += $(SRC_LOCAL)
+
+src/gen_parser.c: src/parser.y
+	bison -Wcounterexamples -H -o $@ $<
+
+src/gen_lexer.c: src/lexer.l
+	flex --header-file=src/gen_lexer.h -o $@ $<
+
+include/cu/parser.h: src/gen_lexer.c src/gen_parser.c
diff --git a/src/string.c b/src/string.c
index 5cce400..d51f1cf 100644
--- a/src/string.c
+++ b/src/string.c
@@ -1,9 +1,8 @@
 #include <errno.h>
 #include <stdlib.h>
 
-#include <ct/debug.h>
-#include <ct/string.h>
-
+#include <cu/debug.h>
+#include <cu/string.h>
 
 struct string *new_string(const char *s)
 {