add formatter

15 files changed, 751 insertions, 7622 deletions

diff --git a/src/actualize.c b/src/actualize.c
index 6018aad..363b9ee 100644
--- a/src/actualize.c
+++ b/src/actualize.c
@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later */
+
 #include <assert.h>
 #include <string.h>
 #include <stdlib.h>
@@ -110,7 +112,8 @@ static int push_label(struct act_state *state, struct ast_node *label)
 	return 0;
 }
 
-static struct ast_node *find_label(struct act_state *state, struct ast_node *label)
+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;
@@ -138,7 +141,8 @@ static int push_goto(struct act_state *state, struct ast_node *got)
 	return 0;
 }
 
-static struct ast_node *clone_defers(struct act_state *state, struct act_stack *to)
+static struct ast_node *clone_defers(struct act_state *state,
+                                     struct act_stack *to)
 {
 	struct act_stack *from = state->defer_stack;
 
@@ -197,27 +201,28 @@ static void destroy_act_state(struct act_state *state)
 	clear_gotos(state, NULL);
 }
 
-static int actualize(struct act_state *state, struct scope *scope, struct ast_node *node);
+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));
+	       && 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 */
+	/* 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;
+		break;
 	default: semantic_error(scope->fctx, node,
-				 "const if conditional at file scope unimplemented");
-		 return -1;
+		                "const if conditional at file scope unimplemented");
+		return -1;
 	}
 
 	destroy_ast_tree(cond);
@@ -282,7 +287,8 @@ static int analyze_file_visibility(struct scope *scope, struct ast_node *node)
 
 	case AST_IMPORT: {
 		const char *file = node->_import.file;
-		ret |= process_file(&scope, ast_flags(node, AST_FLAG_PUBLIC), file);
+		ret |= process_file(&scope, ast_flags(node,
+		                                      AST_FLAG_PUBLIC), file);
 		destroy_ast_tree(node);
 		break;
 	}
@@ -478,13 +484,15 @@ int types_match(struct ast_node *a, struct ast_node *b)
 	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 (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 (a->_type.kind == AST_TYPE_ALIAS ||
+	    b->_type.kind == AST_TYPE_ALIAS) {
 		if (alias_match(a, b))
 			return 1;
 		return 0;
@@ -533,14 +541,15 @@ static int _replace_id(struct ast_node *node, void *data)
 	/* 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)
+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)
+                           struct scope *scope, struct ast_node *macro)
 {
 	UNUSED(state);
 	/* macro bodies, arguments, etc aren't expanded upon until the macro is
@@ -573,13 +582,15 @@ struct ast_node *extract_base(struct ast_node *type)
 	return extract_base(type->_type.next);
 }
 
-static void actualize_template_types(struct ast_node *params, struct ast_node *args)
+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);
+			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
@@ -604,7 +615,8 @@ static void actualize_template_types(struct ast_node *params, struct ast_node *a
 }
 
 static int actualize_proc_call(struct act_state *state,
-		struct scope *scope, struct ast_node *call, struct ast_node *proc)
+                               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)) {
@@ -617,7 +629,8 @@ static int actualize_proc_call(struct act_state *state,
 	}
 
 	if (ast_flags(proc, AST_FLAG_VARIADIC)) {
-		semantic_error(scope->fctx, proc, "variadic procs not yet implemented");
+		semantic_error(scope->fctx, proc,
+		               "variadic procs not yet implemented");
 		return -1;
 	}
 
@@ -639,7 +652,8 @@ static int actualize_proc_call(struct act_state *state,
 
 		struct scope *tmp = create_scope();
 		if (!tmp) {
-			internal_error("failed creating temporary signature scope");
+			internal_error(
+				"failed creating temporary signature scope");
 			return -1;
 		}
 
@@ -680,12 +694,13 @@ static int actualize_proc_call(struct act_state *state,
 }
 
 static int actualize_macro_call(struct act_state *state,
-		struct scope *scope, struct ast_node *call,
-		struct ast_node *macro)
+                                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");
+		semantic_error(scope->fctx, macro,
+		               "variadic macros not yet implemented");
 		return -1;
 	}
 
@@ -712,7 +727,7 @@ static int actualize_macro_call(struct act_state *state,
 
 		if (replace_id(body, param, arg)) {
 			semantic_error(scope->fctx, call,
-					"failed replacing params with args");
+			               "failed replacing params with args");
 			destroy_ast_tree(body);
 			arg->next = next_arg;
 			return -1;
@@ -740,7 +755,7 @@ static int actualize_macro_call(struct act_state *state,
 }
 
 static int actualize_call(struct act_state *state,
-		struct scope *scope, struct ast_node *call)
+                          struct scope *scope, struct ast_node *call)
 {
 	assert(call && call->node_type == AST_CALL);
 
@@ -765,7 +780,7 @@ get_callable:
 
 	if (act_flags(state, ACT_ONLY_TYPES)) {
 		if (callable->node_type == AST_PROC
-				&& !ast_flags(callable->_proc.sign, AST_FLAG_ACTUAL)) {
+		    && !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;
@@ -782,7 +797,7 @@ get_callable:
 
 	/* TODO: add lambdas and arrays */
 	semantic_error(scope->fctx, call,
-			"currently only procedures and macros are callable");
+	               "currently only procedures and macros are callable");
 	return -1;
 }
 
@@ -793,7 +808,8 @@ static void warn_unused_labels(struct act_state *state, struct scope *scope)
 		do {
 			struct ast_node *label = labels->node;
 			if (!ast_flags(label, AST_FLAG_ACTUAL))
-				semantic_warn(scope->fctx, label, "unused label");
+				semantic_warn(scope->fctx, label,
+				              "unused label");
 
 		} while ((labels = labels->next));
 }
@@ -806,7 +822,8 @@ static int undefined_gotos(struct act_state *state, struct scope *scope)
 		do {
 			struct ast_node *got = gotos->node;
 			if (!ast_flags(got, AST_FLAG_ACTUAL)) {
-				semantic_warn(scope->fctx, got, "undefined label");
+				semantic_warn(scope->fctx, got,
+				              "undefined label");
 				ret = -1;
 			}
 
@@ -818,7 +835,7 @@ static int undefined_gotos(struct act_state *state, struct scope *scope)
 /* 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)
+                          struct scope *scope, struct ast_node *proc)
 {
 	/* actualize_proc is called on template procs as well, but I believe
 	 * that's fine? */
@@ -865,7 +882,7 @@ static int actualize_proc(struct act_state *state,
 
 	   params = params->next;
 	   }
-	   */
+	 */
 
 	/* we don't have to maintain the same flags as the parent state, I don't
 	 * think */
@@ -876,14 +893,14 @@ static int actualize_proc(struct act_state *state,
 	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");
+			               "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");
+		              "unable to determine explicit return for all branches");
 	}
 
 	warn_unused_labels(&new_state, scope);
@@ -905,7 +922,7 @@ static int actualize_proc(struct act_state *state,
 }
 
 static int actualize_binop(struct act_state *state,
-		struct scope *scope, struct ast_node *binop)
+                           struct scope *scope, struct ast_node *binop)
 {
 	assert(binop && binop->node_type == AST_BINOP);
 
@@ -919,12 +936,14 @@ static int actualize_binop(struct act_state *state,
 		return ret;
 
 	if (!left->type) {
-		semantic_error(scope->fctx, binop, "unable to detect lefthand 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");
+		semantic_error(scope->fctx, binop,
+		               "unable to detect righthand type");
 		return -1;
 	}
 
@@ -934,7 +953,8 @@ static int actualize_binop(struct act_state *state,
 		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);
+		               "type mismatch (%s vs %s)", left_type,
+		               right_type);
 		free(left_type);
 		free(right_type);
 		return -1;
@@ -952,7 +972,7 @@ static int actualize_binop(struct act_state *state,
 
 
 static int actualize_block(struct act_state *state,
-		struct scope *scope, struct ast_node *node)
+                           struct scope *scope, struct ast_node *node)
 {
 	struct scope *block_scope = scope;
 	if (!ast_flags(node, AST_FLAG_UNHYGIENIC)) {
@@ -972,7 +992,8 @@ static int actualize_block(struct act_state *state,
 	/* 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");
+		semantic_error(scope->fctx, node,
+		               "unable to detect block type");
 		return -1;
 	}
 
@@ -992,7 +1013,7 @@ static int actualize_block(struct act_state *state,
 }
 
 static int actualize_id(struct act_state *state,
-		struct scope *scope, struct ast_node *id)
+                        struct scope *scope, struct ast_node *id)
 {
 	UNUSED(state);
 	assert(id && id->node_type == AST_ID);
@@ -1003,7 +1024,8 @@ static int actualize_id(struct act_state *state,
 	}
 
 	if (!decl->type) {
-		semantic_error(scope->fctx, id, "no type associated with object");
+		semantic_error(scope->fctx, id,
+		               "no type associated with object");
 		return -1;
 	}
 
@@ -1012,7 +1034,7 @@ static int actualize_id(struct act_state *state,
 }
 
 static int actualize_var(struct act_state *state,
-		struct scope *scope, struct ast_node *var)
+                         struct scope *scope, struct ast_node *var)
 {
 	assert(var && var->node_type == AST_VAR);
 	struct ast_node *init = var->_var.init;
@@ -1039,8 +1061,9 @@ static int actualize_var(struct act_state *state,
 		if (!types_match(init->type, type)) {
 			char *init_type = type_str(init->type);
 			char *req_type = type_str(type);
-			semantic_error(scope->fctx, var, "type mismatch (%s vs %s)",
-					req_type, init_type);
+			semantic_error(scope->fctx, var,
+			               "type mismatch (%s vs %s)",
+			               req_type, init_type);
 			free(init_type);
 			free(req_type);
 			return -1;
@@ -1065,19 +1088,19 @@ static int actualize_var(struct act_state *state,
 	return 0;
 }
 
-#define ENTER_ACT()\
-enum act_flags old_flags = state->flags;\
-struct ast_node *old_template = state->cur_template;
+#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);
+#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)
+                          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? */
@@ -1087,7 +1110,8 @@ static int actualize_type(struct act_state *state,
 	ENTER_ACT();
 	act_set_flags(state, ACT_ONLY_TYPES);
 
-	if (ast_flags(type, AST_FLAG_INIT) && !ast_flags(type, AST_FLAG_ACTUAL)) {
+	if (ast_flags(type,
+	              AST_FLAG_INIT) && !ast_flags(type, AST_FLAG_ACTUAL)) {
 		semantic_error(scope->fctx, type, "detected type loop");
 		EXIT_ACT(-1);
 	}
@@ -1122,9 +1146,9 @@ static int actualize_type(struct act_state *state,
 			break;
 
 		assert(exists->node_type == AST_ALIAS
-				|| exists->node_type == AST_TEMPLATE
-				|| exists->node_type == AST_STRUCT
-				|| exists->node_type == AST_ENUM);
+		       || 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))
@@ -1152,7 +1176,8 @@ static int actualize_type(struct act_state *state,
 			destroy_ast_node(type->_type.id);
 			assert(type->_type.next == NULL);
 			type->_type.kind = AST_TYPE_STRUCT;
-			type->_type.struc.struc = clone_ast_node(exists->_struct.id);
+			type->_type.struc.struc = clone_ast_node(
+				exists->_struct.id);
 			/* should be populated later */
 			type->_type.struc.impls = NULL;
 		}
@@ -1177,7 +1202,7 @@ static int actualize_type(struct act_state *state,
 		 * 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");
+			               "couldn't actualize type expression\n");
 			EXIT_ACT(-1);
 		}
 
@@ -1235,7 +1260,8 @@ static int actualize_type(struct act_state *state,
 	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");
+		semantic_error(scope->fctx, type,
+		               "couldn't convert expression to type");
 		EXIT_ACT(-1);
 	}
 
@@ -1244,7 +1270,7 @@ static int actualize_type(struct act_state *state,
 }
 
 static int actualize_empty(struct act_state *state,
-		struct scope *scope, struct ast_node *node)
+                           struct scope *scope, struct ast_node *node)
 {
 	UNUSED(state);
 	/* TODO: converting to void is common enough that it might be worth
@@ -1339,7 +1365,7 @@ static int pointer_conversion(struct ast_node *a, struct ast_node *b)
 }
 
 static int check_impls(struct scope *scope, struct ast_node *target,
-		struct ast_node *exists)
+                       struct ast_node *exists)
 {
 	struct ast_node *args = target->_type.struc.impls;
 	struct ast_node *params = exists->_struct.generics;
@@ -1351,8 +1377,9 @@ static int check_impls(struct scope *scope, struct ast_node *target,
 		if (!implements(scope, args, alias_actual)) {
 			char *astr = type_str(args);
 			char *pstr = type_str(params->type);
-			semantic_error(scope->fctx, args, "%s does not implement %s",
-					astr, pstr);
+			semantic_error(scope->fctx, args,
+			               "%s does not implement %s",
+			               astr, pstr);
 			free(astr);
 			free(pstr);
 			return -1;
@@ -1363,7 +1390,8 @@ static int check_impls(struct scope *scope, struct ast_node *target,
 	}
 
 	if (args || params) {
-		semantic_error(scope->fctx, target, "wrong number of type arguments");
+		semantic_error(scope->fctx, target,
+		               "wrong number of type arguments");
 		return -1;
 	}
 
@@ -1371,7 +1399,7 @@ static int check_impls(struct scope *scope, struct ast_node *target,
 }
 
 static int actualize_init_cast(struct act_state *state,
-		struct scope *scope, struct ast_node *cast)
+                               struct scope *scope, struct ast_node *cast)
 {
 	struct ast_node *target = cast->_cast.type;
 	if (actualize(state, scope, target))
@@ -1402,7 +1430,7 @@ static int actualize_init_cast(struct act_state *state,
 }
 
 static int actualize_cast(struct act_state *state,
-		struct scope *scope, struct ast_node *cast)
+                          struct scope *scope, struct ast_node *cast)
 {
 	assert(cast->node_type == AST_CAST);
 	struct ast_node *expr = cast->_cast.expr;
@@ -1432,7 +1460,7 @@ static int actualize_cast(struct act_state *state,
 	}
 
 	if (pointer_conversion(expr->type, type)
-			|| pointer_conversion(type, expr->type)) {
+	    || pointer_conversion(type, expr->type)) {
 		cast->type = type;
 		return 0;
 	}
@@ -1442,21 +1470,21 @@ static int actualize_cast(struct act_state *state,
 	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);
+	               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)
+                           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);
+		                      NULL, NULL);
 		scope_add_scratch(scope, cons->type);
 		return 0;
 	}
@@ -1466,7 +1494,7 @@ static int actualize_const(struct act_state *state, struct scope *scope,
 }
 
 static int actualize_alias(struct act_state *state, struct scope *scope,
-		struct ast_node *alias)
+                           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
@@ -1490,13 +1518,13 @@ static int actualize_alias(struct act_state *state, struct scope *scope,
 
 	ast_set_flags(alias, AST_FLAG_ACTUAL);
 	alias->type = gen_type(AST_TYPE_ALIAS, NULL,
-			alias->_alias.id, alias->_alias.type);
+	                       alias->_alias.id, alias->_alias.type);
 	scope_add_scratch(scope, alias->type);
 	return 0;
 }
 
 static int actualize_template(struct act_state *state, struct scope *scope,
-		struct ast_node *template)
+                              struct ast_node *template)
 {
 	assert(template->node_type == AST_TEMPLATE);
 	ast_set_flags(template, AST_FLAG_ACTUAL);
@@ -1508,7 +1536,8 @@ static int actualize_template(struct act_state *state, struct scope *scope,
 	 * 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");
+		semantic_error(scope->fctx, template,
+		               "failed actualizing template");
 		EXIT_ACT(-1);
 	}
 
@@ -1525,7 +1554,7 @@ static int actualize_template(struct act_state *state, struct scope *scope,
 }
 
 static int actualize_defer(struct act_state *state,
-		struct scope *scope, struct ast_node *node)
+                           struct scope *scope, struct ast_node *node)
 {
 	struct ast_node *expr = node->_defer.expr;
 	/* TODO: should the actualization only happen when the defers are
@@ -1542,7 +1571,7 @@ static int actualize_defer(struct act_state *state,
 }
 
 static int actualize_return(struct act_state *state, struct scope *scope,
-		struct ast_node *node)
+                            struct ast_node *node)
 {
 	act_set_flags(state, ACT_HAS_RETURN);
 	struct ast_node *expr = node->_return.expr;
@@ -1564,8 +1593,9 @@ static int actualize_return(struct act_state *state, struct scope *scope,
 	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);
+		semantic_error(scope->fctx, node,
+		               "return type mismatch: %s vs %s",
+		               rt, et);
 		free(rt);
 		free(et);
 		return -1;
@@ -1633,7 +1663,7 @@ static void actualize_goto_defer(struct ast_node *got, struct ast_node *label)
 
 
 static int actualize_goto(struct act_state *state, struct scope *scope,
-		struct ast_node *node)
+                          struct ast_node *node)
 {
 	assert(node->node_type == AST_GOTO);
 	push_goto(state, node);
@@ -1652,7 +1682,8 @@ static int actualize_goto(struct act_state *state, struct scope *scope,
 	return 0;
 }
 
-static void actualize_goto_defers(struct act_state *state, struct ast_node *label)
+static void actualize_goto_defers(struct act_state *state,
+                                  struct ast_node *label)
 {
 	struct act_stack *prev = state->goto_stack, *cur;
 	if (prev)
@@ -1666,7 +1697,7 @@ static void actualize_goto_defers(struct act_state *state, struct ast_node *labe
 }
 
 static int actualize_label(struct act_state *state, struct scope *scope,
-		struct ast_node *node)
+                           struct ast_node *node)
 {
 	assert(node->node_type == AST_LABEL);
 	struct ast_node *prev = find_label(state, node);
@@ -1687,7 +1718,7 @@ static int actualize_label(struct act_state *state, struct scope *scope,
 }
 
 static int actualize_unop(struct act_state *state,
-		struct scope *scope, struct ast_node *node)
+                          struct scope *scope, struct ast_node *node)
 {
 	assert(node->node_type == AST_UNOP);
 	struct ast_node *expr = node->_unop.expr;
@@ -1703,7 +1734,7 @@ static int actualize_unop(struct act_state *state,
 		if (type->_type.kind != AST_TYPE_POINTER) {
 			/* TODO: or array */
 			semantic_error(scope->fctx, expr,
-					"trying to dereference something that's not a pointer");
+			               "trying to dereference something that's not a pointer");
 			return -1;
 		}
 
@@ -1712,19 +1743,21 @@ static int actualize_unop(struct act_state *state,
 		break;
 	}
 
-	default: semantic_error(scope->fctx, node, "unimplemented unary operation");
-		 return -1;
+	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)
+                        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");
+		semantic_error(scope->fctx, as,
+		               "as used outside of type context");
 		return -1;
 	}
 
@@ -1737,7 +1770,7 @@ static int actualize_as(struct act_state *state,
 }
 
 static int actualize_struct(struct act_state *state,
-		struct scope *scope, struct ast_node *node)
+                            struct scope *scope, struct ast_node *node)
 {
 	assert(node->node_type == AST_STRUCT);
 	ast_set_flags(node, AST_FLAG_INIT);
@@ -1783,7 +1816,7 @@ static int has_members(struct ast_node *type)
 }
 
 static int actualize_dot(struct act_state *state,
-		struct scope *scope, struct ast_node *node)
+                         struct scope *scope, struct ast_node *node)
 {
 	assert(node->node_type == AST_DOT);
 	struct ast_node *expr = node->_dot.expr;
@@ -1794,7 +1827,7 @@ static int actualize_dot(struct act_state *state,
 	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);
+		               tstr, id->_id.id);
 		free(tstr);
 		return -1;
 	}
@@ -1805,7 +1838,7 @@ static int actualize_dot(struct act_state *state,
 }
 
 static int actualize_init(struct act_state *state,
-		struct scope *scope, struct ast_node *node)
+                          struct scope *scope, struct ast_node *node)
 {
 	assert(node->node_type == AST_INIT);
 	/* for now just do the types, the named stuff will be checked later */
@@ -1819,7 +1852,7 @@ static int actualize_init(struct act_state *state,
 }
 
 static int actualize_assign(struct act_state *state, struct scope *scope,
-		struct ast_node *node)
+                            struct ast_node *node)
 {
 	assert(node->node_type == AST_ASSIGN);
 	struct ast_node *to = node->_assign.to;
@@ -1840,7 +1873,7 @@ static int actualize_assign(struct act_state *state, struct scope *scope,
 		char *tostr = type_str(to->type);
 		char *fromstr = type_str(from->type);
 		semantic_error(scope->fctx, node, "type mismatch (%s vs %s)",
-				tostr, fromstr);
+		               tostr, fromstr);
 		free(tostr);
 		free(fromstr);
 		return -1;
@@ -1850,7 +1883,8 @@ static int actualize_assign(struct act_state *state, struct scope *scope,
 	return 0;
 }
 
-static int actualize(struct act_state *state, struct scope *scope, struct ast_node *node)
+static int actualize(struct act_state *state, struct scope *scope,
+                     struct ast_node *node)
 {
 	int ret = 0;
 	if (!node)
@@ -1890,9 +1924,10 @@ static int actualize(struct act_state *state, struct scope *scope, struct ast_no
 	case AST_ASSIGN: ret |= actualize_assign(state, scope, node); break;
 
 	default:
-		      /* more like internal_error, maybe? */
-		      semantic_error(scope->fctx, node, "unimplemented actualization");
-		      break;
+		/* 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
@@ -1923,7 +1958,8 @@ int actualize_main(struct scope *root)
 	return ret;
 }
 
-void replace_type(struct ast_node *type, struct ast_node *from, struct ast_node *to)
+void replace_type(struct ast_node *type, struct ast_node *from,
+                  struct ast_node *to)
 {
 	if (!type)
 		return;
@@ -1944,7 +1980,7 @@ void replace_type(struct ast_node *type, struct ast_node *from, struct ast_node
 }
 
 void replace_param_types(struct ast_node *param, struct ast_node *param_type,
-		struct ast_node *arg_type)
+                         struct ast_node *arg_type)
 {
 	while (param) {
 		replace_type(param->type, param_type, arg_type);
diff --git a/src/ast.c b/src/ast.c
index fbbd983..50cf268 100644
--- a/src/ast.c
+++ b/src/ast.c
@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later */
+
 #include <stdio.h>
 #include <string.h>
 #include <stdarg.h>
@@ -8,21 +10,21 @@
 #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 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));\
+#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)
@@ -34,10 +36,10 @@ static struct src_loc loc_span(struct ast_node *left, struct ast_node *right)
 	/* 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);
+	   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;
@@ -48,9 +50,9 @@ static struct src_loc loc_span(struct ast_node *left, struct ast_node *right)
 }
 
 struct ast_node *gen_binop(enum ast_binops op,
-		struct ast_node *left, struct ast_node *right)
+                           struct ast_node *left, struct ast_node *right)
 {
-	ALLOC_NODE(n, binop);
+	ALLOC_NODE(n, "binop");
 	n->node_type = AST_BINOP;
 	n->_binop.op = op;
 	n->_binop.left = left;
@@ -69,7 +71,7 @@ void destroy_binop(struct ast_node *binop)
 
 struct ast_node *gen_unop(enum ast_unops op, struct ast_node *expr)
 {
-	ALLOC_NODE(n, unop);
+	ALLOC_NODE(n, "unop");
 	n->node_type = AST_UNOP;
 	n->_unop.op = op;
 	n->_unop.expr = expr;
@@ -86,7 +88,7 @@ void destroy_unop(struct ast_node *unop)
 
 struct ast_node *gen_call(struct ast_node *id, struct ast_node *args)
 {
-	ALLOC_NODE(n, call);
+	ALLOC_NODE(n, "call");
 	n->node_type = AST_CALL;
 	n->_call.id = id;
 	n->_call.args = args;
@@ -104,7 +106,7 @@ void destroy_call(struct ast_node *call)
 
 struct ast_node *gen_id(const char *id)
 {
-	ALLOC_NODE(n, id);
+	ALLOC_NODE(n, "id");
 	n->node_type = AST_ID;
 	n->_id.id = id;
 	/* assume the parser populates location data */
@@ -120,7 +122,7 @@ void destroy_id(struct ast_node *id)
 
 struct ast_node *gen_assign(struct ast_node *to, struct ast_node *from)
 {
-	ALLOC_NODE(n, assign);
+	ALLOC_NODE(n, "assign");
 	n->node_type = AST_ASSIGN;
 	n->_assign.to = to;
 	n->_assign.from = from;
@@ -138,7 +140,7 @@ static void destroy_assign(struct ast_node *assign)
 
 struct ast_node *gen_init(struct ast_node *body)
 {
-	ALLOC_NODE(n, struct init);
+	ALLOC_NODE(n, "struct init");
 	n->node_type = AST_INIT;
 	n->_init.body = body;
 	n->loc = body->loc;
@@ -154,7 +156,7 @@ static void destroy_init(struct ast_node *init)
 
 struct ast_node *gen_int(long long integer)
 {
-	ALLOC_NODE(n, int);
+	ALLOC_NODE(n, "int");
 	n->node_type = AST_CONST;
 	n->_const.kind = AST_CONST_INTEGER;
 	n->_const.integer = integer;
@@ -163,7 +165,7 @@ struct ast_node *gen_int(long long integer)
 
 struct ast_node *gen_string(const char *str)
 {
-	ALLOC_NODE(n, string);
+	ALLOC_NODE(n, "string");
 	n->node_type = AST_CONST;
 	n->_const.kind = AST_CONST_STRING;
 	n->_const.str = str;
@@ -172,7 +174,7 @@ struct ast_node *gen_string(const char *str)
 
 struct ast_node *gen_float(double dbl)
 {
-	ALLOC_NODE(n, float);
+	ALLOC_NODE(n, "float");
 	n->node_type = AST_CONST;
 	n->_const.kind = AST_CONST_FLOAT;
 	n->_const.dbl = dbl;
@@ -190,7 +192,7 @@ void destroy_const(struct ast_node *cons)
 
 struct ast_node *gen_while(struct ast_node *cond, struct ast_node *body)
 {
-	ALLOC_NODE(n, while);
+	ALLOC_NODE(n, "while");
 	n->node_type = AST_WHILE;
 	n->_while.cond = cond;
 	n->_while.body = body;
@@ -206,9 +208,9 @@ void destroy_while(struct ast_node *whil)
 }
 
 struct ast_node *gen_for(struct ast_node *pre, struct ast_node *cond,
-		struct ast_node *post, struct ast_node *body)
+                         struct ast_node *post, struct ast_node *body)
 {
-	ALLOC_NODE(n, for);
+	ALLOC_NODE(n, "for");
 	n->node_type = AST_FOR;
 	n->_for.pre = pre;
 	n->_for.cond = cond;
@@ -229,7 +231,7 @@ void destroy_for(struct ast_node *fo)
 
 struct ast_node *gen_return(struct ast_node *expr)
 {
-	ALLOC_NODE(n, return);
+	ALLOC_NODE(n, "return");
 	n->node_type = AST_RETURN;
 	n->_return.expr = expr;
 	if (expr)
@@ -247,7 +249,7 @@ void destroy_return(struct ast_node *retur)
 
 struct ast_node *gen_goto(struct ast_node *label)
 {
-	ALLOC_NODE(n, goto);
+	ALLOC_NODE(n, "goto");
 	n->node_type = AST_GOTO;
 	n->_goto.label = label;
 	n->loc = label->loc;
@@ -263,7 +265,7 @@ void destroy_goto(struct ast_node *got)
 
 struct ast_node *gen_dot(struct ast_node *expr, struct ast_node *id)
 {
-	ALLOC_NODE(n, dot);
+	ALLOC_NODE(n, "dot");
 	n->node_type = AST_DOT;
 	n->_dot.expr = expr;
 	n->_dot.id = id;
@@ -280,7 +282,7 @@ void destroy_dot(struct ast_node *dot)
 
 struct ast_node *gen_label(struct ast_node *id)
 {
-	ALLOC_NODE(n, label);
+	ALLOC_NODE(n, "label");
 	n->node_type = AST_LABEL;
 	n->_label.id = id;
 	n->loc = id->loc;
@@ -296,7 +298,7 @@ void destroy_label(struct ast_node *label)
 
 struct ast_node *gen_ctrl(enum ast_ctrl_kind kind, struct src_loc loc)
 {
-	ALLOC_NODE(n, ctrl);
+	ALLOC_NODE(n, "ctrl");
 	n->node_type = AST_CTRL;
 	n->loc = loc;
 	n->_ctrl.kind = kind;
@@ -309,9 +311,9 @@ void destroy_ctrl(struct ast_node *ctrl)
 }
 
 struct ast_node *gen_macro(struct ast_node *id, struct ast_node *params,
-		struct ast_node *body)
+                           struct ast_node *body)
 {
-	ALLOC_NODE(n, body);
+	ALLOC_NODE(n, "body");
 	n->node_type = AST_MACRO;
 	n->_macro.id = id;
 	n->_macro.params = params;
@@ -330,9 +332,9 @@ void destroy_macro(struct ast_node *macro)
 }
 
 struct ast_node *gen_if(struct ast_node *cond, struct ast_node *body,
-		struct ast_node *els)
+                        struct ast_node *els)
 {
-	ALLOC_NODE(n, if);
+	ALLOC_NODE(n, "if");
 	n->node_type = AST_IF;
 	n->_if.cond = cond;
 	n->_if.body = body;
@@ -352,7 +354,7 @@ void destroy_if(struct ast_node *i)
 
 struct ast_node *gen_switch(struct ast_node *cond, struct ast_node *cases)
 {
-	ALLOC_NODE(n, switch);
+	ALLOC_NODE(n, "switch");
 	n->node_type = AST_SWITCH;
 	n->_switch.cond = cond;
 	n->_switch.cases = cases;
@@ -370,7 +372,7 @@ void destroy_switch(struct ast_node *switc)
 
 struct ast_node *gen_case(struct ast_node *cond, struct ast_node *body)
 {
-	ALLOC_NODE(n, case);
+	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;
@@ -391,9 +393,9 @@ void destroy_case(struct ast_node *cas)
 }
 
 struct ast_node *gen_type(enum ast_type_kind kind, struct ast_node *id,
-		struct ast_node *expr, struct ast_node *ret)
+                          struct ast_node *expr, struct ast_node *ret)
 {
-	ALLOC_NODE(n, type);
+	ALLOC_NODE(n, "type");
 	n->node_type = AST_TYPE;
 	n->_type.kind = kind;
 	switch (kind) {
@@ -522,7 +524,7 @@ void destroy_type(struct ast_node *type)
 
 struct ast_node *gen_block(struct ast_node *body)
 {
-	ALLOC_NODE(n, block);
+	ALLOC_NODE(n, "block");
 	n->node_type = AST_BLOCK;
 	n->_block.body = body;
 
@@ -542,7 +544,7 @@ void destroy_block(struct ast_node *block)
 
 struct ast_node *gen_sizeof(struct ast_node *expr)
 {
-	ALLOC_NODE(n, sizeof);
+	ALLOC_NODE(n, "sizeof");
 	n->node_type = AST_SIZEOF;
 	n->_sizeof.expr = expr;
 	n->loc = expr->loc;
@@ -557,7 +559,7 @@ void destroy_sizeof(struct ast_node *sizeo)
 }
 struct ast_node *gen_as(struct ast_node *type)
 {
-	ALLOC_NODE(n, as);
+	ALLOC_NODE(n, "as");
 	n->node_type = AST_AS;
 	n->_as.type = type;
 	n->loc = type->loc;
@@ -573,7 +575,7 @@ void destroy_as(struct ast_node *as)
 
 struct ast_node *gen_defer(struct ast_node *expr)
 {
-	ALLOC_NODE(n, defer);
+	ALLOC_NODE(n, "defer");
 	n->node_type = AST_DEFER;
 	n->_defer.expr = expr;
 	n->loc = expr->loc;
@@ -588,9 +590,9 @@ void destroy_defer(struct ast_node *defer)
 }
 
 struct ast_node *gen_var(struct ast_node *id, struct ast_node *type,
-		struct ast_node *init)
+                         struct ast_node *init)
 {
-	ALLOC_NODE(n, var);
+	ALLOC_NODE(n, "var");
 	n->node_type = AST_VAR;
 	n->_var.id = id;
 	n->_var.type = type;
@@ -612,9 +614,9 @@ void destroy_var(struct ast_node *var)
 }
 
 struct ast_node *gen_lambda(struct ast_node *captures,
-		struct ast_node *type, struct ast_node *body)
+                            struct ast_node *type, struct ast_node *body)
 {
-	ALLOC_NODE(n, lambda);
+	ALLOC_NODE(n, "lambda");
 	n->node_type = AST_LAMBDA;
 	n->_lambda.captures = captures;
 	n->_lambda.sign = type;
@@ -633,9 +635,9 @@ void destroy_lambda(struct ast_node *lambda)
 }
 
 struct ast_node *gen_proc(struct ast_node *id, struct ast_node *sign,
-		struct ast_node *body)
+                          struct ast_node *body)
 {
-	ALLOC_NODE(n, proc);
+	ALLOC_NODE(n, "proc");
 	n->node_type = AST_PROC;
 	n->_proc.id = id;
 	n->_proc.sign = sign;
@@ -654,9 +656,9 @@ void destroy_proc(struct ast_node *proc)
 }
 
 struct ast_node *gen_struct(struct ast_node *id,
-		struct ast_node *generics, struct ast_node *body)
+                            struct ast_node *generics, struct ast_node *body)
 {
-	ALLOC_NODE(n, struct);
+	ALLOC_NODE(n, "struct");
 	n->node_type = AST_STRUCT;
 	n->_struct.id = id;
 	n->_struct.generics = generics;
@@ -678,9 +680,9 @@ void destroy_struct(struct ast_node *struc)
 }
 
 struct ast_node *gen_union(struct ast_node *id,
-		struct ast_node *generics, struct ast_node *body)
+                           struct ast_node *generics, struct ast_node *body)
 {
-	ALLOC_NODE(n, struct);
+	ALLOC_NODE(n, "union");
 	n->node_type = AST_UNION;
 	n->_union.id = id;
 	n->_union.generics = generics;
@@ -702,9 +704,9 @@ void destroy_union(struct ast_node *unio)
 }
 
 struct ast_node *gen_enum(struct ast_node *id, struct ast_node *type,
-		struct ast_node *body)
+                          struct ast_node *body)
 {
-	ALLOC_NODE(n, enum);
+	ALLOC_NODE(n, "enum");
 	n->node_type = AST_ENUM;
 	n->_enum.id = id;
 	n->_enum.type = type;
@@ -725,7 +727,7 @@ void destroy_enum(struct ast_node *enu)
 
 struct ast_node *gen_cast(struct ast_node *expr, struct ast_node *type)
 {
-	ALLOC_NODE(n, cast);
+	ALLOC_NODE(n, "cast");
 	n->node_type = AST_CAST;
 	n->_cast.expr = expr;
 	n->_cast.type = type;
@@ -743,7 +745,7 @@ void destroy_cast(struct ast_node *cast)
 
 struct ast_node *gen_val(struct ast_node *id, struct ast_node *val)
 {
-	ALLOC_NODE(n, val);
+	ALLOC_NODE(n, "val");
 	n->node_type = AST_VAL;
 	n->_val.id = id;
 	n->_val.val = val;
@@ -761,7 +763,7 @@ void destroy_val(struct ast_node *val)
 
 struct ast_node *gen_alias(struct ast_node *id, struct ast_node *type)
 {
-	ALLOC_NODE(n, alias);
+	ALLOC_NODE(n, "alias");
 	n->node_type = AST_ALIAS;
 	n->_alias.id = id;
 	n->_alias.type = type;
@@ -779,7 +781,7 @@ void destroy_alias(struct ast_node *alias)
 
 struct ast_node *gen_template(struct ast_node *id, struct ast_node *body)
 {
-	ALLOC_NODE(n, template);
+	ALLOC_NODE(n, "template");
 	n->node_type = AST_TEMPLATE;
 	n->_template.id = id;
 	n->_template.body = body;
@@ -804,7 +806,7 @@ void destroy_template(struct ast_node *template)
 
 struct ast_node *gen_import(const char *file)
 {
-	ALLOC_NODE(n, import);
+	ALLOC_NODE(n, "import");
 	n->node_type = AST_IMPORT;
 	n->_import.file = file;
 	/* TODO: where to get location */
@@ -820,7 +822,7 @@ void destroy_import(struct ast_node *import)
 
 struct ast_node *gen_embed(const char *file)
 {
-	ALLOC_NODE(n, embed);
+	ALLOC_NODE(n, "embed");
 	n->node_type = AST_EMBED;
 	n->_embed.file = file;
 	/* TODO: location */
@@ -836,7 +838,7 @@ void destroy_embed(struct ast_node *embed)
 
 struct ast_node *gen_empty()
 {
-	ALLOC_NODE(n, empty);
+	ALLOC_NODE(n, "empty");
 	n->node_type = AST_EMPTY;
 	/* TODO: location */
 	return n;
@@ -850,7 +852,7 @@ void destroy_empty(struct ast_node *empty)
 
 struct ast_node *gen_last()
 {
-	ALLOC_NODE(n, last);
+	ALLOC_NODE(n, "last");
 	n->node_type = AST_LAST;
 	/* TODO: location */
 	return n;
@@ -1240,7 +1242,8 @@ static void __dump_ast(int depth, struct ast_node *node)
 
 		case AST_TYPE_TEMPLATE:
 			printf(" TEMPLATE\n");
-			dump_ast(depth + 1, node->_type.template.template->_template.id);
+			dump_ast(depth + 1,
+			         node->_type.template.template->_template.id);
 			dump_ast(depth + 1, node->_type.template.actual);
 			break;
 
@@ -1290,9 +1293,9 @@ static void __dump_ast(int depth, struct ast_node *node)
 			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;
+			dump_ast(depth + 1, node->_type.sign.params);
+			dump_ast(depth + 1, node->_type.sign.ret);
+			break;
 		}
 
 		dump_ast(depth + 1, node->_type.next);
@@ -1443,8 +1446,10 @@ static void __dump_ast(int depth, struct ast_node *node)
 		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_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");
@@ -1497,252 +1502,254 @@ struct ast_node *clone_ast_node(struct ast_node *node)
 	switch (node->node_type) {
 	case AST_UNION:
 		new = gen_union(clone_ast_node(node->_union.id),
-				clone_ast_node(node->_union.generics),
-				clone_ast_node(node->_union.body));
+		                clone_ast_node(node->_union.generics),
+		                clone_ast_node(node->_union.body));
 		break;
 
 	case AST_ASSIGN:
 		new = gen_assign(clone_ast_node(node->_assign.to),
-				clone_ast_node(node->_assign.from));
+		                 clone_ast_node(node->_assign.from));
 		break;
 
 	case AST_INIT: new = gen_init(clone_ast_node(node->_init.body));
-		       break;
+		break;
 
 	case AST_SIZEOF: new = gen_sizeof(clone_ast_node(node->_sizeof.expr));
-			 break;
+		break;
 
 	case AST_DOT: new = gen_dot(clone_ast_node(node->_dot.expr),
-				      clone_ast_node(node->_dot.id));
-		      break;
+		                    clone_ast_node(node->_dot.id));
+		break;
 
 	case AST_AS: new = gen_as(clone_ast_node(node->_as.type));
-		     break;
+		break;
 
 	case AST_GOTO: new = gen_goto(clone_ast_node(node->_goto.label));
-		       break;
+		break;
 
 	case AST_LABEL: new = gen_label(clone_ast_node(node->_label.id));
-			break;
+		break;
 
 	case AST_BINOP: new = gen_binop(node->_binop.op,
-					clone_ast_node(node->_binop.left),
-					clone_ast_node(node->_binop.right));
-			break;
+		                        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;
+		                      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;
+		                      clone_ast_node(node->_call.args));
+		break;
 
 	case AST_DEFER: new = gen_defer(clone_ast_node(node->_defer.expr));
-			break;
+		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;
+		                        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;
+		                      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;
+		                      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));
+		              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_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;
+		                    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;
+		                        clone_ast_node(node->_while.body));
+		break;
 
 	case AST_CTRL: new = gen_ctrl(node->_ctrl.kind, node->loc);
-		       break;
+		break;
 
 	case AST_RETURN: new = gen_return(clone_ast_node(node->_return.expr));
-			 break;
+		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;
+		/* 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_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_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_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_POINTER:
+			new = gen_type(AST_TYPE_POINTER, NULL, NULL, NULL);
+			break;
 
-			 case AST_TYPE_STRUCT:
-				 new = gen_type(AST_TYPE_STRUCT,
-						 clone_ast_node(node->_type.struc.struc),
-						 clone_ast_node(node->_type.struc.impls),
-						 NULL);
-				 break;
+		case AST_TYPE_STRUCT:
+			new = gen_type(AST_TYPE_STRUCT,
+			               clone_ast_node(node->_type.struc.struc),
+			               clone_ast_node(node->_type.struc.impls),
+			               NULL);
+			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_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_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_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_SIGN:
+			new = gen_type(AST_TYPE_SIGN, NULL,
+			               clone_ast_node(node->_type.sign.params),
+			               clone_ast_node(node->_type.sign.ret));
+			break;
 
-			 }
-			 new->_type.next = clone_ast_node(node->_type.next);
-			 break;
+		}
+		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;
+		/* 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;
+		new = gen_import(strdup(node->_import.file));
+		break;
 
 	case AST_EMBED:
-			 new = gen_embed(strdup(node->_import.file));
-			 break;
+		new = gen_embed(strdup(node->_import.file));
+		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;
+		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;
+		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;
+		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;
+		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;
+		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;
+		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_STRING:
+			new = gen_string(strdup(node->_const.str));
+			break;
 
-			 case AST_CONST_FLOAT:
-				 new = gen_float(node->_const.dbl);
-				 break;
-			 }
-			 break;
+		case AST_CONST_FLOAT:
+			new = gen_float(node->_const.dbl);
+			break;
+		}
+		break;
 
 	case AST_ID:
-			 new = gen_id(strdup(node->_id.id));
-			 break;
+		new = gen_id(strdup(node->_id.id));
+		break;
 
 	case AST_EMPTY:
-			 new = gen_empty();
-			 break;
+		new = gen_empty();
+		break;
 
 	case AST_LAST:
-			 new = gen_last();
-			 break;
+		new = gen_last();
+		break;
 
 	case AST_ALIAS:
-			 new = gen_alias(clone_ast_node(node->_alias.id),
-					 clone_ast_node(node->_alias.type));
-			 break;
+		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;
+		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;
+		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... */
@@ -1763,9 +1770,9 @@ struct ast_node *clone_ast_node(struct ast_node *node)
 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;
+	       && 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)
@@ -1937,7 +1944,8 @@ static int identical_var(int exact, struct ast_node *a, struct ast_node *b)
 
 static int identical_lambda(int exact, struct ast_node *a, struct ast_node *b)
 {
-	if (!identical_ast_nodes(exact, a->_lambda.captures, b->_lambda.captures))
+	if (!identical_ast_nodes(exact, a->_lambda.captures,
+	                         b->_lambda.captures))
 		return 0;
 
 	if (!identical_ast_nodes(exact, a->_lambda.sign, b->_lambda.sign))
@@ -1988,22 +1996,28 @@ static int identical_return(int exact, struct ast_node *a, struct ast_node *b)
 	return identical_ast_nodes(exact, a->_return.expr, b->_return.expr);
 }
 
-static int identical_type_alias(int exact, struct ast_node *a, struct ast_node *b)
+static int identical_type_alias(int exact, struct ast_node *a,
+                                struct ast_node *b)
 {
-	if (!identical_ast_nodes(exact, a->_type.alias.alias, b->_type.alias.alias))
+	if (!identical_ast_nodes(exact, a->_type.alias.alias,
+	                         b->_type.alias.alias))
 		return 0;
 
-	if (!identical_ast_nodes(exact, a->_type.alias.actual, b->_type.alias.actual))
+	if (!identical_ast_nodes(exact, a->_type.alias.actual,
+	                         b->_type.alias.actual))
 		return 0;
 	return 1;
 }
 
-static int identical_type_template(int exact, struct ast_node *a, struct ast_node *b)
+static int identical_type_template(int exact, struct ast_node *a,
+                                   struct ast_node *b)
 {
-	if (!identical_ast_nodes(exact, a->_type.template.template, b->_type.template.template))
+	if (!identical_ast_nodes(exact, a->_type.template.template,
+	                         b->_type.template.template))
 		return 0;
 
-	if (!identical_ast_nodes(exact, a->_type.template.actual, b->_type.template.actual))
+	if (!identical_ast_nodes(exact, a->_type.template.actual,
+	                         b->_type.template.actual))
 		return 0;
 
 	return 1;
@@ -2019,14 +2033,18 @@ static int identical_type_arr(int exact, struct ast_node *a, struct ast_node *b)
 	return identical_ast_nodes(exact, a->_type.arr.size, b->_type.arr.size);
 }
 
-static int identical_type_typeof(int exact, struct ast_node *a, struct ast_node *b)
+static int identical_type_typeof(int exact, struct ast_node *a,
+                                 struct ast_node *b)
 {
-	return identical_ast_nodes(exact, a->_type.typeo.expr, b->_type.typeo.expr);
+	return identical_ast_nodes(exact, a->_type.typeo.expr,
+	                           b->_type.typeo.expr);
 }
 
-static int identical_type_proc(int exact, struct ast_node *a, struct ast_node *b)
+static int identical_type_proc(int exact, struct ast_node *a,
+                               struct ast_node *b)
 {
-	if (!identical_ast_nodes(exact, a->_type.proc.params, b->_type.proc.params))
+	if (!identical_ast_nodes(exact, a->_type.proc.params,
+	                         b->_type.proc.params))
 		return 0;
 
 	if (!identical_ast_nodes(exact, a->_type.proc.ret, b->_type.proc.ret))
@@ -2035,20 +2053,25 @@ static int identical_type_proc(int exact, struct ast_node *a, struct ast_node *b
 	return 1;
 }
 
-static int identical_type_lambda(int exact, struct ast_node *a, struct ast_node *b)
+static int identical_type_lambda(int exact, struct ast_node *a,
+                                 struct ast_node *b)
 {
-	if (!identical_ast_nodes(exact, a->_type.lambda.params, b->_type.lambda.params))
+	if (!identical_ast_nodes(exact, a->_type.lambda.params,
+	                         b->_type.lambda.params))
 		return 0;
 
-	if (!identical_ast_nodes(exact, a->_type.lambda.ret, b->_type.lambda.ret))
+	if (!identical_ast_nodes(exact, a->_type.lambda.ret,
+	                         b->_type.lambda.ret))
 		return 0;
 
 	return 1;
 }
 
-static int identical_type_sign(int exact, struct ast_node *a, struct ast_node *b)
+static int identical_type_sign(int exact, struct ast_node *a,
+                               struct ast_node *b)
 {
-	if (!identical_ast_nodes(exact, a->_type.sign.params, b->_type.sign.params))
+	if (!identical_ast_nodes(exact, a->_type.sign.params,
+	                         b->_type.sign.params))
 		return 0;
 
 	if (!identical_ast_nodes(exact, a->_type.sign.ret, b->_type.sign.ret))
@@ -2057,18 +2080,22 @@ static int identical_type_sign(int exact, struct ast_node *a, struct ast_node *b
 	return 1;
 }
 
-static int identical_type_struct(int exact, struct ast_node *a, struct ast_node *b)
+static int identical_type_struct(int exact, struct ast_node *a,
+                                 struct ast_node *b)
 {
-	if (!identical_ast_nodes(exact, a->_type.struc.struc, b->_type.struc.struc))
+	if (!identical_ast_nodes(exact, a->_type.struc.struc,
+	                         b->_type.struc.struc))
 		return 0;
 
-	if (!identical_ast_nodes(exact, a->_type.struc.impls, b->_type.struc.impls))
+	if (!identical_ast_nodes(exact, a->_type.struc.impls,
+	                         b->_type.struc.impls))
 		return 0;
 
 	return 1;
 }
 
-static int identical_type_union(int exact, struct ast_node *a, struct ast_node *b)
+static int identical_type_union(int exact, struct ast_node *a,
+                                struct ast_node *b)
 {
 	if (!identical_ast_nodes(exact, a->_type.unio.id, b->_type.unio.id))
 		return 0;
@@ -2087,7 +2114,8 @@ static int identical_type(int exact, struct ast_node *a, struct ast_node *b)
 	int ret = 0;
 	switch (a->_type.kind) {
 	case AST_TYPE_ALIAS: ret = identical_type_alias(exact, a, b); break;
-	case AST_TYPE_TEMPLATE: ret = identical_type_template(exact, a, b); break;
+	case AST_TYPE_TEMPLATE: ret = identical_type_template(exact, a, b);
+		break;
 	case AST_TYPE_ID: ret = identical_type_id(exact, a, b); break;
 	case AST_TYPE_ARR: ret = identical_type_arr(exact, a, b); break;
 	case AST_TYPE_TYPEOF: ret = identical_type_typeof(exact, a, b); break;
@@ -2138,7 +2166,8 @@ static int identical_struct(int exact, struct ast_node *a, struct ast_node *b)
 	if (!identical_ast_nodes(exact, a->_struct.id, b->_struct.id))
 		return 0;
 
-	if (!identical_ast_nodes(exact, a->_struct.generics, b->_struct.generics))
+	if (!identical_ast_nodes(exact, a->_struct.generics,
+	                         b->_struct.generics))
 		return 0;
 
 	if (!identical_ast_nodes(exact, a->_struct.body, b->_struct.body))
@@ -2346,7 +2375,8 @@ int ast_flags(struct ast_node *node, enum ast_flag flags)
 	return node->flags & flags;
 }
 
-static int call_on_union(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_union(int (*call)(struct ast_node *,
+                                     void *), struct ast_node *node, void *data)
 {
 	int ret = 0;
 	ret |= call(node->_union.id, data);
@@ -2355,7 +2385,8 @@ static int call_on_union(int (*call)(struct ast_node *, void *), struct ast_node
 	return ret;
 }
 
-static int call_on_assign(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_assign(int (*call)(struct ast_node *,
+                                      void *), struct ast_node *node, void *data)
 {
 	int ret = 0;
 	ret |= call(node->_assign.to, data);
@@ -2363,17 +2394,20 @@ static int call_on_assign(int (*call)(struct ast_node *, void *), struct ast_nod
 	return ret;
 }
 
-static int call_on_init(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_init(int (*call)(struct ast_node *,
+                                    void *), struct ast_node *node, void *data)
 {
 	return call(node->_init.body, data);
 }
 
-static int call_on_sizeof(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_sizeof(int (*call)(struct ast_node *,
+                                      void *), struct ast_node *node, void *data)
 {
 	return call(node->_sizeof.expr, data);
 }
 
-static int call_on_dot(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_dot(int (*call)(struct ast_node *,
+                                   void *), struct ast_node *node, void *data)
 {
 	int ret = 0;
 	ret |= call(node->_dot.expr, data);
@@ -2381,12 +2415,14 @@ static int call_on_dot(int (*call)(struct ast_node *, void *), struct ast_node *
 	return ret;
 }
 
-static int call_on_as(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_as(int (*call)(struct ast_node *,
+                                  void *), struct ast_node *node, void *data)
 {
 	return call(node->_as.type, data);
 }
 
-static int call_on_cast(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_cast(int (*call)(struct ast_node *,
+                                    void *), struct ast_node *node, void *data)
 {
 	int ret = 0;
 	ret |= call(node->_cast.expr, data);
@@ -2394,12 +2430,14 @@ static int call_on_cast(int (*call)(struct ast_node *, void *), struct ast_node
 	return ret;
 }
 
-static int call_on_defer(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_defer(int (*call)(struct ast_node *,
+                                     void *), struct ast_node *node, void *data)
 {
 	return call(node->_defer.expr, data);
 }
 
-static int call_on_var(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_var(int (*call)(struct ast_node *,
+                                   void *), struct ast_node *node, void *data)
 {
 	int ret = 0;
 	ret |= call(node->_var.id, data);
@@ -2408,7 +2446,8 @@ static int call_on_var(int (*call)(struct ast_node *, void *), struct ast_node *
 	return ret;
 }
 
-static int call_on_lambda(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_lambda(int (*call)(struct ast_node *,
+                                      void *), struct ast_node *node, void *data)
 {
 	int ret = 0;
 	ret |= call(node->_lambda.captures, data);
@@ -2417,7 +2456,8 @@ static int call_on_lambda(int (*call)(struct ast_node *, void *), struct ast_nod
 	return ret;
 }
 
-static int call_on_for(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_for(int (*call)(struct ast_node *,
+                                   void *), struct ast_node *node, void *data)
 {
 	int ret = 0;
 	ret |= call(node->_for.pre, data);
@@ -2427,7 +2467,8 @@ static int call_on_for(int (*call)(struct ast_node *, void *), struct ast_node *
 	return ret;
 }
 
-static int call_on_while(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_while(int (*call)(struct ast_node *,
+                                     void *), struct ast_node *node, void *data)
 {
 	int ret = 0;
 	ret |= call(node->_while.cond, data);
@@ -2435,12 +2476,14 @@ static int call_on_while(int (*call)(struct ast_node *, void *), struct ast_node
 	return ret;
 }
 
-static int call_on_return(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_return(int (*call)(struct ast_node *,
+                                      void *), struct ast_node *node, void *data)
 {
 	return call(node->_return.expr, data);
 }
 
-static int call_on_alias(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_alias(int (*call)(struct ast_node *,
+                                     void *), struct ast_node *node, void *data)
 {
 	int ret = 0;
 	ret |= call(node->_alias.id, data);
@@ -2448,7 +2491,8 @@ static int call_on_alias(int (*call)(struct ast_node *, void *), struct ast_node
 	return ret;
 }
 
-static int call_on_template(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_template(int (*call)(struct ast_node *,
+                                        void *), struct ast_node *node, void *data)
 {
 	int ret = 0;
 	ret |= call(node->_template.id, data);
@@ -2456,7 +2500,8 @@ static int call_on_template(int (*call)(struct ast_node *, void *), struct ast_n
 	return ret;
 }
 
-static int call_on_if(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_if(int (*call)(struct ast_node *,
+                                  void *), struct ast_node *node, void *data)
 {
 	int ret = 0;
 	ret |= call(node->_if.cond, data);
@@ -2465,7 +2510,8 @@ static int call_on_if(int (*call)(struct ast_node *, void *), struct ast_node *n
 	return ret;
 }
 
-static int call_on_enum(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_enum(int (*call)(struct ast_node *,
+                                    void *), struct ast_node *node, void *data)
 {
 	int ret = 0;
 	ret |= call(node->_enum.id, data);
@@ -2474,7 +2520,8 @@ static int call_on_enum(int (*call)(struct ast_node *, void *), struct ast_node
 	return ret;
 }
 
-static int call_on_struct(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_struct(int (*call)(struct ast_node *,
+                                      void *), struct ast_node *node, void *data)
 {
 	int ret = 0;
 	ret |= call(node->_struct.id, data);
@@ -2483,7 +2530,8 @@ static int call_on_struct(int (*call)(struct ast_node *, void *), struct ast_nod
 	return ret;
 }
 
-static int call_on_val(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_val(int (*call)(struct ast_node *,
+                                   void *), struct ast_node *node, void *data)
 {
 	int ret = 0;
 	ret |= call(node->_val.id, data);
@@ -2491,7 +2539,8 @@ static int call_on_val(int (*call)(struct ast_node *, void *), struct ast_node *
 	return ret;
 }
 
-static int call_on_switch(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_switch(int (*call)(struct ast_node *,
+                                      void *), struct ast_node *node, void *data)
 {
 	int ret = 0;
 	ret |= call(node->_switch.cond, data);
@@ -2499,7 +2548,8 @@ static int call_on_switch(int (*call)(struct ast_node *, void *), struct ast_nod
 	return ret;
 }
 
-static int call_on_case(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_case(int (*call)(struct ast_node *,
+                                    void *), struct ast_node *node, void *data)
 {
 	int ret = 0;
 	ret |= call(node->_case.cond, data);
@@ -2507,7 +2557,8 @@ static int call_on_case(int (*call)(struct ast_node *, void *), struct ast_node
 	return ret;
 }
 
-static int call_on_type_alias(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_type_alias(int (*call)(struct ast_node *,
+                                          void *), struct ast_node *node, void *data)
 {
 	int ret = 0;
 	ret |= call(node->_type.alias.alias, data);
@@ -2515,7 +2566,8 @@ static int call_on_type_alias(int (*call)(struct ast_node *, void *), struct ast
 	return ret;
 }
 
-static int call_on_type_template(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_type_template(int (*call)(struct ast_node *,
+                                             void *), struct ast_node *node, void *data)
 {
 	int ret = 0;
 	ret |= call(node->_type.template.template, data);
@@ -2523,22 +2575,26 @@ static int call_on_type_template(int (*call)(struct ast_node *, void *), struct
 	return ret;
 }
 
-static int call_on_type_id(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_type_id(int (*call)(struct ast_node *,
+                                       void *), struct ast_node *node, void *data)
 {
 	return call(node->_type.id, data);
 }
 
-static int call_on_type_arr(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_type_arr(int (*call)(struct ast_node *,
+                                        void *), struct ast_node *node, void *data)
 {
 	return call(node->_type.arr.size, data);
 }
 
-static int call_on_type_typeof(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_type_typeof(int (*call)(struct ast_node *,
+                                           void *), struct ast_node *node, void *data)
 {
 	return call(node->_type.typeo.expr, data);
 }
 
-static int call_on_type_union(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_type_union(int (*call)(struct ast_node *,
+                                          void *), struct ast_node *node, void *data)
 {
 	int ret = 0;
 	ret |= call(node->_type.unio.id, data);
@@ -2546,7 +2602,8 @@ static int call_on_type_union(int (*call)(struct ast_node *, void *), struct ast
 	return ret;
 }
 
-static int call_on_type_struct(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_type_struct(int (*call)(struct ast_node *,
+                                           void *), struct ast_node *node, void *data)
 {
 	int ret = 0;
 	ret |= call(node->_type.struc.struc, data);
@@ -2554,7 +2611,8 @@ static int call_on_type_struct(int (*call)(struct ast_node *, void *), struct as
 	return ret;
 }
 
-static int call_on_type_proc(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_type_proc(int (*call)(struct ast_node *,
+                                         void *), struct ast_node *node, void *data)
 {
 	int ret = 0;
 	ret |= call(node->_type.proc.id, data);
@@ -2563,7 +2621,8 @@ static int call_on_type_proc(int (*call)(struct ast_node *, void *), struct ast_
 	return ret;
 }
 
-static int call_on_type_lambda(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_type_lambda(int (*call)(struct ast_node *,
+                                           void *), struct ast_node *node, void *data)
 {
 	int ret = 0;
 	ret |= call(node->_type.lambda.params, data);
@@ -2571,7 +2630,8 @@ static int call_on_type_lambda(int (*call)(struct ast_node *, void *), struct as
 	return ret;
 }
 
-static int call_on_type_sign(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_type_sign(int (*call)(struct ast_node *,
+                                         void *), struct ast_node *node, void *data)
 {
 	int ret = 0;
 	ret |= call(node->_type.sign.params, data);
@@ -2579,19 +2639,24 @@ static int call_on_type_sign(int (*call)(struct ast_node *, void *), struct ast_
 	return ret;
 }
 
-static int call_on_type(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_type(int (*call)(struct ast_node *,
+                                    void *), struct ast_node *node, void *data)
 {
 	int ret = 0;
 	switch (node->_type.kind) {
 	case AST_TYPE_ALIAS: ret = call_on_type_alias(call, node, data); break;
-	case AST_TYPE_TEMPLATE: ret = call_on_type_template(call, node, data); break;
+	case AST_TYPE_TEMPLATE: ret = call_on_type_template(call, node, data);
+		break;
 	case AST_TYPE_ID: ret = call_on_type_id(call, node, data); break;
 	case AST_TYPE_ARR: ret = call_on_type_arr(call, node, data); break;
-	case AST_TYPE_TYPEOF: ret = call_on_type_typeof(call, node, data); break;
+	case AST_TYPE_TYPEOF: ret = call_on_type_typeof(call, node, data);
+		break;
 	case AST_TYPE_UNION: ret = call_on_type_union(call, node, data); break;
-	case AST_TYPE_STRUCT: ret = call_on_type_struct(call, node, data); break;
+	case AST_TYPE_STRUCT: ret = call_on_type_struct(call, node, data);
+		break;
 	case AST_TYPE_PROC: ret = call_on_type_proc(call, node, data); break;
-	case AST_TYPE_LAMBDA: ret = call_on_type_lambda(call, node, data); break;
+	case AST_TYPE_LAMBDA: ret = call_on_type_lambda(call, node, data);
+		break;
 	case AST_TYPE_SIGN: ret = call_on_type_sign(call, node, data); break;
 	case AST_TYPE_POINTER: break;
 	}
@@ -2599,17 +2664,20 @@ static int call_on_type(int (*call)(struct ast_node *, void *), struct ast_node
 	return ret;
 }
 
-static int call_on_goto(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_goto(int (*call)(struct ast_node *,
+                                    void *), struct ast_node *node, void *data)
 {
 	return call(node->_goto.label, data);
 }
 
-static int call_on_label(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_label(int (*call)(struct ast_node *,
+                                     void *), struct ast_node *node, void *data)
 {
 	return call(node->_label.id, data);
 }
 
-static int call_on_binop(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_binop(int (*call)(struct ast_node *,
+                                     void *), struct ast_node *node, void *data)
 {
 	int ret = 0;
 	ret |= call(node->_binop.left, data);
@@ -2617,12 +2685,14 @@ static int call_on_binop(int (*call)(struct ast_node *, void *), struct ast_node
 	return ret;
 }
 
-static int call_on_unop(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_unop(int (*call)(struct ast_node *,
+                                    void *), struct ast_node *node, void *data)
 {
 	return call(node->_unop.expr, data);
 }
 
-static int call_on_call(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_call(int (*call)(struct ast_node *,
+                                    void *), struct ast_node *node, void *data)
 {
 	int ret = 0;
 	ret |= call(node->_call.id, data);
@@ -2630,7 +2700,8 @@ static int call_on_call(int (*call)(struct ast_node *, void *), struct ast_node
 	return ret;
 }
 
-static int call_on_macro(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_macro(int (*call)(struct ast_node *,
+                                     void *), struct ast_node *node, void *data)
 {
 	int ret = 0;
 	ret |= call(node->_macro.id, data);
@@ -2639,7 +2710,8 @@ static int call_on_macro(int (*call)(struct ast_node *, void *), struct ast_node
 	return ret;
 }
 
-static int call_on_proc(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_proc(int (*call)(struct ast_node *,
+                                    void *), struct ast_node *node, void *data)
 {
 	int ret = 0;
 	ret |= call(node->_proc.id, data);
@@ -2648,7 +2720,8 @@ static int call_on_proc(int (*call)(struct ast_node *, void *), struct ast_node
 	return ret;
 }
 
-static int call_on_block(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data)
+static int call_on_block(int (*call)(struct ast_node *,
+                                     void *), struct ast_node *node, void *data)
 {
 	return call(node->_block.body, data);
 }
@@ -2660,7 +2733,8 @@ static int call_on_block(int (*call)(struct ast_node *, void *), struct ast_node
  * 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 *), struct ast_node *node, void *data)
+int ast_call_on(int (*call)(struct ast_node *,
+                            void *), struct ast_node *node, void *data)
 {
 	int ret = 0;
 	if (!node)
diff --git a/src/compiler.c b/src/compiler.c
index 22c5f81..a1a5c92 100644
--- a/src/compiler.c
+++ b/src/compiler.c
@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later */
+
 #include <stdbool.h>
 #include <string.h>
 #include <unistd.h>
@@ -114,7 +116,8 @@ int process_file(struct scope **scope, int public, const char *file)
 	debug("(cwd:%s)(dir:%s)(base:%s)", cwd, dir, base);
 
 	if (*dir != 0 && chdir(dir)) {
-		error("couldn't change to directory %s: %s", dir, strerror(errno));
+		error("couldn't change to directory %s: %s", dir, strerror(
+			      errno));
 		goto out;
 	}
 
@@ -122,7 +125,8 @@ int process_file(struct scope **scope, int public, const char *file)
 		goto out;
 
 	if (chdir(cwd)) {
-		error("couldn't change back to directory %s: %s\n", cwd, strerror(errno));
+		error("couldn't change back to directory %s: %s\n", cwd, strerror(
+			      errno));
 		goto out;
 	}
 
diff --git a/src/debug.c b/src/debug.c
index e18ae70..2bb4af4 100644
--- a/src/debug.c
+++ b/src/debug.c
@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later */
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <assert.h>
@@ -40,7 +42,8 @@ static const char *find_lineno(const char *buf, size_t no)
 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_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);
@@ -48,9 +51,9 @@ static void _issue(struct src_issue issue, const char *fmt, va_list args)
 	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));
+	        issue.loc.first_line,
+	        issue.loc.first_col,
+	        issue_level_str(issue.level));
 
 	vfprintf(stderr, fmt, args);
 	fputc('\n', stderr);
@@ -89,7 +92,8 @@ void src_issue(struct src_issue issue, const char *err_msg, ...)
 
 /* 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, ...)
+void semantic_error(struct file_ctx fctx, struct ast_node *node,
+                    const char *fmt, ...)
 {
 	va_list args;
 	va_start(args, fmt);
@@ -101,7 +105,8 @@ void semantic_error(struct file_ctx fctx, struct ast_node *node, const char *fmt
 	va_end(args);
 }
 
-void semantic_warn(struct file_ctx fctx, struct ast_node *node, const char *fmt, ...)
+void semantic_warn(struct file_ctx fctx, struct ast_node *node, const char *fmt,
+                   ...)
 {
 	va_list args;
 	va_start(args, fmt);
@@ -113,7 +118,8 @@ void semantic_warn(struct file_ctx fctx, struct ast_node *node, const char *fmt,
 	va_end(args);
 }
 
-void semantic_info(struct file_ctx fctx, struct ast_node *node, const char *fmt, ...)
+void semantic_info(struct file_ctx fctx, struct ast_node *node, const char *fmt,
+                   ...)
 {
 	va_list args;
 	va_start(args, fmt);
diff --git a/src/gen_lexer.c b/src/gen_lexer.c
deleted file mode 100644
index 8297712..0000000
--- a/src/gen_lexer.c
+++ /dev/null
@@ -1,2594 +0,0 @@
-#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[223] =
-    {   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,   90,   90,   90,   31,   32,   30,
-        0,   89,   85,   80,   90,   63,   90,   70,   90,   90,
-
-       90,   90,   90,   90,   90,   90,   64,   77,   90,   84,
-       82,   67,   81,   69,   65,   74,   90,   68,   90,   66,
-       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[233] =
-    {   0,
-        0,    0,   62,   63,  366,  367,   65,   67,  340,   66,
-      358,  338,   64,  327,  367,  367,  367,   63,  367,   72,
-      345,   61,   84,   90,  367,  367,   52,   69,   73,  367,
-        0,  367,  367,   82,  306,  306,   74,   45,   66,  307,
-      306,   77,  300,  317,  298,  311,   75,  293,  301,  305,
-      367,   60,  367,  367,    0,  367,  101,  337,  126,  367,
-      126,  367,  345,  367,  367,  367,  367,  338,  115,  120,
-      127,  367,  139,  146,  367,  330,  367,    0,  367,  185,
-      161,    0,  131,  320,  367,  367,  367,  367,  319,    0,
-      367,  318,    0,  300,  287,  290,  296,    0,  284,  298,
-
-      280,  280,  281,  278,    0,  280,  288,  275,  279,  289,
-      272,  266,  272,  278,  271,  276,  275,  367,  367,    0,
-      139,  367,  367,  367,  311,  165,  177,  310,    0,  367,
-        0,  150,  169,  198,  367,  169,  157,  367,  367,  367,
-      280,  275,  137,  178,  274,  273,  265,  271,    0,  261,
-      260,    0,    0,    0,  254,  267,  252,  252,  264,  254,
-      256,  367,  367,  213,  216,  294,  177,  223,  255,    0,
-      246,  254,  246,  248,    0,  256,    0,  243,    0,  242,
-      241,  241,  246,  240,  189,  226,  232,  367,  367,  367,
-      227,  231,    0,    0,  217,    0,  197,    0,  187,  171,
-
-      173,  167,  153,  162,  160,  151,    0,    0,  137,    0,
-        0,    0,    0,    0,    0,    0,  120,    0,  110,    0,
-        0,  367,  252,  258,  264,  266,  272,  278,  284,  139,
-      288,  132
-    } ;
-
-static const flex_int16_t yy_def[233] =
-    {   0,
-      222,    1,  223,  223,  222,  222,  222,  222,  222,  224,
-      222,  222,  222,  225,  222,  222,  222,  222,  222,  222,
-      222,  222,  222,  222,  222,  222,  222,  222,  222,  222,
-      226,  222,  222,  222,  226,  226,  226,  226,  226,  226,
-      226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
-      222,  222,  222,  222,  227,  222,  222,  222,  222,  222,
-      224,  222,  224,  222,  222,  222,  222,  222,  228,  222,
-      222,  222,  222,  222,  222,  222,  222,  229,  222,  222,
-      222,  230,  222,  222,  222,  222,  222,  222,  222,  226,
-      222,  222,  226,  226,  226,  226,  226,  226,  226,  226,
-
-      226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
-      226,  226,  226,  226,  226,  226,  226,  222,  222,  227,
-      222,  222,  222,  222,  222,  222,  222,  231,  232,  222,
-      229,  222,  222,  222,  222,  230,  222,  222,  222,  222,
-      226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
-      226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
-      226,  222,  222,  222,  222,  231,  232,  222,  226,  226,
-      226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
-      226,  226,  226,  226,  226,  226,  226,  222,  222,  222,
-      222,  222,  226,  226,  226,  226,  226,  226,  226,  226,
-
-      226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
-      226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
-      226,    0,  222,  222,  222,  222,  222,  222,  222,  222,
-      222,  222
-    } ;
-
-static const flex_int16_t yy_nxt[432] =
-    {   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,  221,  129,  127,   80,  122,   74,   74,   74,   74,
-       63,   80,  220,   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,  219,  218,  165,  165,  129,  132,  135,  132,
-
-      168,  217,  133,  133,  133,  133,  216,  215,  168,  214,
-      132,  135,  132,  134,  135,  133,  133,  133,  133,  173,
-      168,  188,  213,  174,  189,  212,  134,  135,  168,  205,
-      164,  164,  164,  165,  165,  191,  211,  191,  210,  206,
-      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,  209,   68,   68,   68,
-       90,   90,  120,  208,  120,  207,  120,  120,  125,  204,
-      125,  125,  125,  125,  131,  203,  131,  131,  131,  131,
-      166,  202,  166,  201,  200,  199,  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,  222,  123,  117,
-      116,  115,  111,  110,  109,  108,  104,  103,   94,   93,
-       76,   69,   65,   64,   60,  222,    5,  222,  222,  222,
-      222,  222,  222,  222,  222,  222,  222,  222,  222,  222,
-      222,  222,  222,  222,  222,  222,  222,  222,  222,  222,
-      222,  222,  222,  222,  222,  222,  222,  222,  222,  222,
-
-      222,  222,  222,  222,  222,  222,  222,  222,  222,  222,
-      222,  222,  222,  222,  222,  222,  222,  222,  222,  222,
-      222,  222,  222,  222,  222,  222,  222,  222,  222,  222,
-      222
-    } ;
-
-static const flex_int16_t yy_chk[432] =
-    {   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,  232,   70,   70,   70,
-       70,   23,   71,  230,   71,   71,   71,   71,   83,   83,
-      121,  219,   70,   69,   73,  121,   73,   73,   73,   73,
-       61,   74,  217,   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,  209,  206,  127,  127,   73,   80,  133,   80,
-
-      136,  205,   80,   80,   80,   80,  204,  203,  167,  202,
-      134,  133,  134,   80,   80,  134,  134,  134,  134,  144,
-      136,  164,  201,  144,  165,  200,   80,   80,  167,  185,
-      164,  164,  164,  165,  165,  168,  199,  168,  197,  185,
-      168,  168,  168,  168,  191,  191,  191,  191,  192,  192,
-      192,  192,  223,  223,  223,  223,  223,  223,  224,  224,
-      224,  224,  224,  224,  225,  225,  195,  225,  225,  225,
-      226,  226,  227,  187,  227,  186,  227,  227,  228,  184,
-      228,  228,  228,  228,  229,  183,  229,  229,  229,  229,
-      231,  182,  231,  181,  180,  178,  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,  222,  222,  222,  222,
-      222,  222,  222,  222,  222,  222,  222,  222,  222,  222,
-      222,  222,  222,  222,  222,  222,  222,  222,  222,  222,
-      222,  222,  222,  222,  222,  222,  222,  222,  222,  222,
-
-      222,  222,  222,  222,  222,  222,  222,  222,  222,  222,
-      222,  222,  222,  222,  222,  222,  222,  222,  222,  222,
-      222,  222,  222,  222,  222,  222,  222,  222,  222,  222,
-      222
-    } ;
-
-/* 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 620 "src/gen_lexer.c"
-
-#line 622 "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 883 "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 >= 223 )
-					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] != 367 );
-
-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 1461 "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 >= 223 )
-				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 >= 223 )
-			yy_c = yy_meta[yy_c];
-		}
-	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
-	yy_is_jam = (yy_current_state == 222);
-
-	(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
index e9288de..7fd7f5c 100644
--- a/src/gen_lexer.h
+++ b/src/gen_lexer.h
@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later */
+
 #ifndef yyHEADER_H
 #define yyHEADER_H 1
 #define yyIN_HEADER 1
@@ -38,7 +40,7 @@
 #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. 
+ * if you want the limit (max/min) macros for int types.
  */
 #ifndef __STDC_LIMIT_MACROS
 #define __STDC_LIMIT_MACROS 1
@@ -55,41 +57,41 @@ typedef uint32_t flex_uint32_t;
 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 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)
+#define INT8_MIN (-128)
 #endif
 #ifndef INT16_MIN
-#define INT16_MIN              (-32767-1)
+#define INT16_MIN (-32767-1)
 #endif
 #ifndef INT32_MIN
-#define INT32_MIN              (-2147483647-1)
+#define INT32_MIN (-2147483647-1)
 #endif
 #ifndef INT8_MAX
-#define INT8_MAX               (127)
+#define INT8_MAX (127)
 #endif
 #ifndef INT16_MAX
-#define INT16_MAX              (32767)
+#define INT16_MAX (32767)
 #endif
 #ifndef INT32_MAX
-#define INT32_MAX              (2147483647)
+#define INT32_MAX (2147483647)
 #endif
 #ifndef UINT8_MAX
-#define UINT8_MAX              (255U)
+#define UINT8_MAX (255U)
 #endif
 #ifndef UINT16_MAX
-#define UINT16_MAX             (65535U)
+#define UINT16_MAX (65535U)
 #endif
 #ifndef UINT32_MAX
-#define UINT32_MAX             (4294967295U)
+#define UINT32_MAX (4294967295U)
 #endif
 
 #ifndef SIZE_MAX
-#define SIZE_MAX               (~(size_t)0)
+#define SIZE_MAX (~(size_t)0)
 #endif
 
 #endif /* ! C99 */
@@ -150,11 +152,11 @@ typedef size_t yy_size_t;
 #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 */
+	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.
@@ -185,8 +187,8 @@ struct yy_buffer_state
 	 */
 	int yy_at_bol;
 
-    int yy_bs_lineno; /**< The line count. */
-    int yy_bs_column; /**< The column count. */
+	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.
@@ -195,28 +197,30 @@ struct yy_buffer_state
 
 	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 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 );
+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 );
+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 yywrap(yyscanner) (/*CONSTCOND*/ 1)
 #define YY_SKIP_YYWRAP
 
 #define yytext_ptr yytext_r
@@ -250,31 +254,31 @@ int yylex_destroy ( yyscan_t yyscanner );
 
 int yyget_debug ( yyscan_t yyscanner );
 
-void yyset_debug ( int debug_flag , 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 );
+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 );
+void yyset_in  ( FILE * _in_str, yyscan_t yyscanner );
 
 FILE *yyget_out ( yyscan_t yyscanner );
 
-void yyset_out  ( FILE * _out_str , yyscan_t yyscanner );
+void yyset_out  ( FILE * _out_str, yyscan_t yyscanner );
 
-			int yyget_leng ( 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 );
+void yyset_lineno ( int _line_number, yyscan_t yyscanner );
 
 int yyget_column  ( yyscan_t yyscanner );
 
-void yyset_column ( int _column_no , 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.
@@ -289,11 +293,11 @@ extern int yywrap ( yyscan_t yyscanner );
 #endif
 
 #ifndef yytext_ptr
-static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
+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);
+static int yy_flex_strlen ( const char *, yyscan_t yyscanner);
 #endif
 
 #ifndef YY_NO_INPUT
diff --git a/src/gen_parser.c b/src/gen_parser.c
deleted file mode 100644
index caf845e..0000000
--- a/src/gen_parser.c
+++ /dev/null
@@ -1,4267 +0,0 @@
-/* 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_assign = 86,                    /* assign  */
-  YYSYMBOL_binary_op = 87,                 /* binary_op  */
-  YYSYMBOL_unary_op = 88,                  /* unary_op  */
-  YYSYMBOL_arg = 89,                       /* arg  */
-  YYSYMBOL_arg_list = 90,                  /* arg_list  */
-  YYSYMBOL_param_decl = 91,                /* param_decl  */
-  YYSYMBOL_decl_list = 92,                 /* decl_list  */
-  YYSYMBOL_call = 93,                      /* call  */
-  YYSYMBOL_defer = 94,                     /* defer  */
-  YYSYMBOL_expr = 95,                      /* expr  */
-  YYSYMBOL_while = 96,                     /* while  */
-  YYSYMBOL_do_while = 97,                  /* do_while  */
-  YYSYMBOL_goto = 98,                      /* goto  */
-  YYSYMBOL_statement = 99,                 /* statement  */
-  YYSYMBOL_statement_list = 100,           /* statement_list  */
-  YYSYMBOL_body = 101,                     /* body  */
-  YYSYMBOL_macro_list = 102,               /* macro_list  */
-  YYSYMBOL_macro = 103,                    /* macro  */
-  YYSYMBOL_expr_list = 104,                /* expr_list  */
-  YYSYMBOL_struct_init = 105,              /* struct_init  */
-  YYSYMBOL_struct_inits = 106,             /* struct_inits  */
-  YYSYMBOL_struct_construct = 107,         /* struct_construct  */
-  YYSYMBOL_init_expr = 108,                /* init_expr  */
-  YYSYMBOL_cond = 109,                     /* cond  */
-  YYSYMBOL_expr_if = 110,                  /* expr_if  */
-  YYSYMBOL_if = 111,                       /* if  */
-  YYSYMBOL_for = 112,                      /* for  */
-  YYSYMBOL_case = 113,                     /* case  */
-  YYSYMBOL_case_list = 114,                /* case_list  */
-  YYSYMBOL_switch = 115,                   /* switch  */
-  YYSYMBOL_const_for = 116,                /* const_for  */
-  YYSYMBOL_const_if = 117,                 /* const_if  */
-  YYSYMBOL_const = 118,                    /* const  */
-  YYSYMBOL_func_sign = 119,                /* func_sign  */
-  YYSYMBOL_variadic_sign = 120,            /* variadic_sign  */
-  YYSYMBOL_type = 121,                     /* type  */
-  YYSYMBOL_var_decl = 122,                 /* var_decl  */
-  YYSYMBOL_var_init = 123,                 /* var_init  */
-  YYSYMBOL_proc = 124,                     /* proc  */
-  YYSYMBOL_lambda = 125,                   /* lambda  */
-  YYSYMBOL_struct_elem = 126,              /* struct_elem  */
-  YYSYMBOL_struct_list = 127,              /* struct_list  */
-  YYSYMBOL_union = 128,                    /* union  */
-  YYSYMBOL_generic = 129,                  /* generic  */
-  YYSYMBOL_generic_list = 130,             /* generic_list  */
-  YYSYMBOL_struct = 131,                   /* struct  */
-  YYSYMBOL_template_elem = 132,            /* template_elem  */
-  YYSYMBOL_template_list = 133,            /* template_list  */
-  YYSYMBOL_type_list = 134,                /* type_list  */
-  YYSYMBOL_type_alias = 135,               /* type_alias  */
-  YYSYMBOL_type_template = 136,            /* type_template  */
-  YYSYMBOL_enum_val = 137,                 /* enum_val  */
-  YYSYMBOL_enum_list = 138,                /* enum_list  */
-  YYSYMBOL_enum = 139,                     /* enum  */
-  YYSYMBOL_top_if = 140,                   /* top_if  */
-  YYSYMBOL_top = 141,                      /* top  */
-  YYSYMBOL_unit = 142,                     /* unit  */
-  YYSYMBOL_input = 143                     /* 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   1993
-
-/* YYNTOKENS -- Number of terminals.  */
-#define YYNTOKENS  81
-/* YYNNTS -- Number of nonterminals.  */
-#define YYNNTS  63
-/* YYNRULES -- Number of rules.  */
-#define YYNRULES  215
-/* YYNSTATES -- Number of states.  */
-#define YYNSTATES  432
-
-/* 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,   148,   148,   154,   155,   158,   161,   164,   165,   168,
-     169,   170,   171,   172,   173,   174,   175,   176,   177,   178,
-     179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
-     189,   192,   195,   196,   197,   198,   199,   200,   203,   204,
-     205,   206,   207,   210,   211,   212,   215,   216,   219,   221,
-     222,   223,   224,   228,   229,   232,   236,   237,   238,   239,
-     240,   241,   242,   246,   247,   248,   249,   250,   251,   252,
-     253,   254,   255,   256,   257,   260,   263,   269,   271,   272,
-     273,   274,   275,   277,   278,   279,   280,   281,   282,   283,
-     284,   285,   286,   287,   288,   289,   290,   291,   292,   293,
-     294,   310,   311,   314,   315,   318,   319,   322,   326,   333,
-     339,   340,   343,   344,   350,   351,   354,   357,   358,   359,
-     360,   363,   364,   368,   369,   372,   373,   374,   377,   380,
-     383,   384,   387,   390,   397,   401,   406,   414,   416,   420,
-     423,   425,   427,   429,   433,   434,   441,   442,   446,   449,
-     453,   457,   461,   466,   470,   471,   474,   475,   479,   485,
-     489,   495,   498,   501,   502,   505,   508,   513,   514,   515,
-     518,   521,   528,   529,   530,   531,   534,   535,   538,   539,
-     542,   547,   550,   556,   557,   560,   561,   562,   565,   566,
-     572,   576,   580,   588,   589,   590,   591,   592,   593,   594,
-     595,   596,   597,   598,   599,   600,   601,   602,   603,   604,
-     605,   606,   621,   622,   625,   626
-};
-#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",
-  "assign", "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", "struct_init", "struct_inits", "struct_construct",
-  "init_expr", "cond", "expr_if", "if", "for", "case", "case_list",
-  "switch", "const_for", "const_if", "const", "func_sign", "variadic_sign",
-  "type", "var_decl", "var_init", "proc", "lambda", "struct_elem",
-  "struct_list", "union", "generic", "generic_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 (-248)
-
-#define yypact_value_is_default(Yyn) \
-  ((Yyn) == YYPACT_NINF)
-
-#define YYTABLE_NINF (-216)
-
-#define yytable_value_is_error(Yyn) \
-  0
-
-/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
-   STATE-NUM.  */
-static const yytype_int16 yypact[] =
-{
-     323,  -248,  -248,  -248,   227,    47,    47,    17,    29,    47,
-      47,    47,   330,    57,    62,  -248,    80,  -248,  -248,  -248,
-      81,  -248,  -248,   203,  -248,    95,    98,   103,  -248,  -248,
-    -248,   109,  -248,  -248,    15,    25,  -248,  1116,  -248,    61,
-      32,    64,    42,  1116,   132,   160,    68,   491,    65,  -248,
-      72,  -248,  -248,  -248,   982,  -248,  -248,  -248,  -248,  -248,
-    -248,    47,    47,    22,  -248,  -248,  -248,  -248,  1116,    47,
-    1116,  1116,  1116,  1116,  1116,  -248,    70,    79,  1116,    47,
-      58,    82,  -248,  -248,  -248,  -248,  -248,  -248,  1209,  -248,
-      68,  -248,    58,    47,    23,  -248,  -248,    74,   982,  -248,
-     982,  -248,  -248,    58,   518,   108,    27,  -248,   114,    58,
-    1273,    58,   752,  -248,  1146,   569,  1914,    85,  -248,  -248,
-      58,   117,    96,   333,  -248,   161,   100,    47,  -248,   151,
-     166,  -248,    33,   102,    74,  -248,    74,    74,   409,  1498,
-      74,  1116,   173,   536,  1337,    80,   106,   136,   116,  -248,
-     904,  1060,  1116,  1116,  1116,  1116,  1116,  1116,  1116,  1116,
-    1116,  1116,  1116,  1116,  1116,  1116,  1116,  1116,  1116,  1116,
-    1116,  1116,  1116,  1116,  1116,  1116,  1116,  1116,  1116,  1116,
-    1116,   699,    58,    47,   -21,   112,   193,   158,   135,    72,
-      51,  -248,  -248,   138,    58,    58,    58,    47,  -248,   208,
-      58,  -248,    58,   174,   153,  -248,  -248,    47,  1146,   214,
-     220,  1116,  1014,  1116,    72,   936,   -16,  -248,   408,   221,
-     232,  1401,  -248,  -248,   233,   666,   170,  -248,  -248,  -248,
-    -248,  -248,  -248,  -248,   237,  -248,  -248,  1090,  1914,    72,
-      47,   206,   183,  -248,    58,  -248,    47,   185,    47,  -248,
-      75,  -248,   251,  -248,  -248,  -248,  1465,   190,  -248,  -248,
-      47,    61,  1116,  -248,   545,   217,   194,  -248,  -248,  1914,
-    -248,    -2,    -2,    -2,   409,   409,  1242,  1442,  1498,  1434,
-    1370,  1306,   842,   842,   842,   842,   766,   766,   172,   172,
-    1914,  1914,  1914,  1914,  1914,  1914,  1914,  1914,  1914,  1914,
-     191,  -248,  -248,    47,  1116,    47,  -248,  -248,    47,    72,
-    -248,  -248,   189,  -248,   197,  -248,  -248,    58,  -248,  -248,
-      72,  -248,  -248,  1529,   266,  1593,   219,  -248,   275,  1116,
-      47,  -248,  -248,  -248,  -248,  -248,  -248,  -248,  -248,  -248,
-    -248,   215,   229,   281,   569,  -248,  -248,  -248,    47,  -248,
-      47,    47,  -248,  -248,  -248,  -248,    72,  -248,  1014,  -248,
-     234,   218,  1914,  -248,   222,  -248,    58,  -248,  -248,   236,
-     228,  1116,  -248,  1116,  -248,  1593,   288,  -248,   -24,   982,
-    -248,   225,   231,   226,  -248,  -248,   -23,  -248,    72,   238,
-     -20,  1116,   228,   235,  1658,  1722,   244,  1116,  -248,  -248,
-    -248,  -248,   239,  -248,   699,  -248,  -248,  -248,  -248,  -248,
-    1786,  -248,  -248,  1116,  -248,   -17,  1850,    72,    47,   240,
-     828,  1593,  -248,  -248,  1116,  -248,   241,  -248,  -248,  -248,
-    -248,  -248
-};
-
-/* 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,   211,     2,   193,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   197,     3,     4,   195,   196,
-       0,   201,   194,     0,   214,     0,     0,     0,   205,   204,
-     203,     0,   208,   202,     0,     0,     6,     0,   198,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   146,   144,
-       0,   155,   209,   199,     0,   200,   213,     1,   210,   206,
-     207,     0,     0,     0,   180,    60,    61,    62,     0,     0,
-       0,     0,     0,     0,     0,    59,     0,     0,     0,     0,
-       0,    56,    73,    64,    67,    68,    65,    66,     0,    74,
-       0,   160,     0,     0,     0,   147,   149,   152,     0,   153,
-       0,   154,   143,     0,   146,    52,     0,    48,    51,     0,
-       0,     0,     0,   159,     0,     0,   117,   119,   156,   118,
-       0,   169,     0,     0,   162,     0,     0,     0,   182,     0,
-       0,   175,   177,     0,    41,    58,    39,    70,    38,    40,
-      42,     0,     0,    56,     0,     0,     0,   106,     0,    72,
-       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,   183,   187,     0,     0,
-       0,   157,   158,     0,     0,     0,     0,     0,   140,     0,
-       0,   150,     0,   179,     0,   100,    99,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   104,    56,     0,
-       0,     0,    90,    91,     0,     0,     0,    98,    93,    85,
-      88,    92,    89,    94,     0,    96,    97,     0,   121,     0,
-       0,   115,     0,   112,     0,   167,     0,     0,   164,   170,
-       0,   172,     0,   174,   176,   181,     0,     0,    63,    69,
-       0,     0,     0,    54,    56,    47,     0,    45,    44,     7,
-       8,    11,    12,    13,    10,     9,    15,    14,    16,    18,
-      17,    19,    32,    33,    34,    35,    36,    37,    20,    21,
-      22,    23,    24,    25,    26,    29,    27,    28,    30,    31,
-       0,    71,    57,     0,     0,   186,   189,   109,     0,     0,
-     142,    50,     0,   141,     0,    49,   151,     0,   148,    77,
-       0,    81,    82,     0,     0,     0,     0,    80,     0,     0,
-       0,   138,   137,    87,    84,    83,    78,    86,   101,   103,
-      95,     0,     0,     0,     0,   116,   120,   168,     0,   163,
-       0,     0,   173,    55,     5,   105,     0,    43,     0,    53,
-     190,     0,   184,   185,     0,   107,     0,   139,   178,   125,
-       0,     0,    75,     0,    79,     0,     0,   122,     0,     0,
-     114,     0,     0,     0,   161,    46,     0,   188,     0,     0,
-       0,     0,   131,     0,     0,     0,   134,     0,   123,   124,
-     113,   171,     0,   165,     0,   192,   108,   145,   126,   127,
-       0,   130,   132,     0,    76,     0,   111,     0,     0,     0,
-       0,     0,   135,   136,     0,   133,     0,   191,   129,   128,
-     110,   166
-};
-
-/* YYPGOTO[NTERM-NUM].  */
-static const yytype_int16 yypgoto[] =
-{
-    -248,     0,     3,  -248,     4,  -248,  -248,  -248,    94,   -51,
-    -248,   -65,  -248,  -248,   291,  -248,  -248,  -248,  -248,  -222,
-     -34,   -73,     9,  -115,  -248,   -32,   167,   -30,   111,  -218,
-     -70,  -248,  -248,   -71,  -248,  -248,   -90,  -248,   -12,  -248,
-     437,    20,   -63,   322,  -248,  -248,  -246,  -248,  -248,  -220,
-      10,  -248,   195,    18,    13,    14,  -248,  -247,    16,   -55,
-    -248,   -22,  -248
-};
-
-/* YYDEFGOTO[NTERM-NUM].  */
-static const yytype_int16 yydefgoto[] =
-{
-       0,    81,    13,    82,    14,    83,    84,    85,   265,   266,
-     105,   106,    86,    87,   116,   222,   223,   224,   225,   226,
-     227,   148,    15,   417,   241,   242,   117,   267,   239,   119,
-     229,   230,   392,   393,   231,   331,   332,   232,    49,    50,
-      51,    16,    17,    18,    89,   125,   126,   131,   121,   122,
-      19,   132,   133,   204,    20,    21,   187,   188,    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,    56,   349,   338,    12,    34,    35,    26,    27,    39,
-      40,    41,    48,    28,    30,   146,   113,    31,    32,   341,
-      33,   190,    36,    12,   118,   184,   347,    91,     2,     2,
-      95,     2,    42,   114,    37,    48,   197,   208,    43,     2,
-     329,   329,    48,    92,    48,    48,   104,   330,     2,    42,
-     112,   404,   198,     2,   112,    43,   361,   112,   363,   199,
-     308,   120,   123,   129,     2,    42,   108,    52,   191,   135,
-     192,    43,    53,   127,     2,    42,   182,   183,   143,   147,
-      48,    43,   124,   130,   127,   243,    37,    61,    54,    62,
-     104,    55,    48,   186,   147,    57,   189,   128,   145,    63,
-     198,    47,   381,    48,    48,   383,    93,   199,    58,    48,
-     108,    48,   218,    59,    90,   219,   220,   252,    47,    60,
-      48,   228,   233,    48,   309,   234,   235,   250,   236,    48,
-     382,   311,   129,    90,    47,   315,    94,   111,     2,    42,
-      98,   102,   141,    48,    47,    43,   112,   350,   103,   351,
-     264,   142,   130,   183,   150,   307,   196,     2,    42,   300,
-     399,   251,   200,   244,    43,   246,     2,    42,   100,   247,
-     268,   248,   426,    43,   146,   249,   253,   255,   257,   259,
-     326,    12,    48,   302,   260,   328,   303,   355,   152,   153,
-     154,   155,   156,   261,    48,    48,   104,   312,   428,    48,
-     104,   304,    48,  -212,     1,   342,   305,   319,    47,     2,
-     306,   310,   264,     3,     2,    42,   108,   194,    48,   195,
-     108,    43,   317,    90,   321,   218,   318,    47,   219,   220,
-     322,   334,   268,     2,   228,   233,    47,   143,   234,   235,
-     343,   236,   335,   337,    48,   339,   120,   340,   123,   356,
-     182,   183,     4,     5,   344,     6,     7,   145,   345,   348,
-     147,   352,   264,   354,    48,   358,   360,   359,   124,   366,
-     367,     8,     9,    10,    11,   365,   371,     5,  -212,     6,
-       7,   313,   357,   373,    47,   374,   369,   378,   377,   379,
-     391,   372,   386,   387,   390,   388,     9,    10,    11,   397,
-     401,   403,   415,   186,   402,   186,   324,   385,   364,   430,
-     412,   407,   380,   418,   243,   427,   431,    48,   270,   320,
-     409,   411,   384,  -215,     1,   423,    29,   254,    88,     2,
-     376,   405,     0,     3,    97,   368,     2,    42,   110,     2,
-      42,   396,     0,    43,   398,     0,    43,     0,   123,   400,
-     120,   123,     0,     0,   406,     0,   408,     0,   264,   134,
-       0,   136,   137,   138,   139,   140,    48,     0,   124,   144,
-       0,   124,     4,     5,     0,     6,     7,     0,   268,     0,
-       0,   422,   419,   425,     0,     0,     0,   429,     0,     0,
-       0,     8,     9,    10,    11,     0,    44,     0,    45,   194,
-       0,   195,    46,   221,    12,   238,    47,     0,     0,    47,
-       0,     0,     0,     0,     2,    42,     0,     0,   123,   333,
-     218,    43,     0,   219,   220,   152,   153,   154,     0,   228,
-     233,     0,   256,   234,   235,     0,   236,     0,   124,     0,
-       0,     0,   269,   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,   297,
-     298,   299,    64,     0,    44,     0,    45,     0,     0,    96,
-     150,    99,   101,   107,    47,     0,     0,   182,   183,     0,
-       0,     0,     0,     0,    65,    66,    67,     2,    68,   238,
-      69,     0,   323,    70,   325,    71,     0,     0,     0,     0,
-      72,     0,     0,     0,    73,     0,   221,   149,    74,     0,
-       0,     0,     0,     0,     2,    42,     0,   107,   144,   185,
-       0,    43,     0,     0,     0,     0,     0,     0,    75,     0,
-     193,     0,     2,    42,     0,    76,   201,    77,   203,    43,
-       0,     2,    42,   139,     0,     0,     0,   245,    43,     0,
-       0,     0,     0,    78,     0,     0,     0,    79,   109,    80,
-       0,     0,    65,    66,    67,     2,    68,     0,    69,     0,
-       0,    70,     0,    71,   194,     0,   195,     0,    72,     0,
-     111,     0,    73,     0,    47,   362,    74,     0,     0,     0,
-       0,     0,    44,     0,    45,     0,     0,     0,   150,     0,
-       0,   194,    47,   195,     0,     0,    75,   150,     0,   301,
-     375,    47,     0,    76,     0,    77,   114,     0,     0,     0,
-       0,    99,   101,   107,     0,     0,   314,   107,     0,   316,
-       0,    78,     0,   115,     0,    79,     0,    80,   240,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   394,     0,   395,     0,     0,   205,     0,    65,
-      66,    67,     2,    68,     0,    69,   206,     0,    70,     0,
-      71,   346,   410,     0,     0,    72,     0,     0,   416,    73,
-       0,     0,     0,    74,     0,     0,     0,     0,     0,     0,
-       1,     0,     0,     0,   421,     2,     0,     0,     0,     3,
-       0,   221,     0,    75,     0,   416,     5,     0,     6,     7,
-      76,   207,    77,   208,     0,   209,   210,   211,  -102,   212,
-     213,   214,     0,   215,   216,     0,    10,    11,    78,     0,
-     112,  -102,    79,     0,    80,     0,     0,     0,     4,     5,
-       0,     6,     7,   205,   203,    65,    66,    67,     2,    68,
-       0,    69,   206,     0,    70,     0,    71,     8,     9,    10,
-      11,    72,     0,     0,     0,    73,     0,     0,     0,    74,
-       0,     0,   152,   153,   154,   155,   156,     0,   158,   159,
-     160,     0,     0,     0,   163,   164,   165,   166,     0,    75,
-     169,   170,     5,   389,     6,     7,    76,   207,    77,   208,
-       0,   209,   210,   211,     0,   212,   213,   214,     0,   215,
-     216,     0,    10,    11,    78,     0,   112,   217,    79,   205,
-      80,    65,    66,    67,     2,    68,     0,    69,   206,     0,
-      70,     0,    71,     0,   182,   183,     0,    72,     0,     0,
-       0,    73,     0,     0,     0,    74,     0,     0,   152,   153,
-     154,   155,   156,     0,   158,   159,   160,     0,     0,     0,
-       0,     0,     0,     0,     0,    75,   169,   170,     5,     0,
-       6,     7,    76,   207,    77,   208,     0,   209,   210,   211,
-       0,   212,   213,   214,     0,   215,   216,     0,    10,    11,
-      78,     0,   112,     0,    79,     0,    80,    65,    66,    67,
-       2,    68,     0,    69,     0,     0,    70,     0,    71,     0,
-     182,   183,     0,    72,     0,     0,     0,   262,     0,     0,
-       0,    74,     0,     0,     0,     0,     0,     0,     0,    65,
-      66,    67,     2,    68,     0,    69,   327,     0,    70,     0,
-      71,    75,     0,     0,     0,    72,     0,     0,    76,    73,
-      77,   114,     0,    74,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,    78,   263,   115,     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,    73,     0,     0,    78,    74,
-     115,     0,    79,     0,    80,     0,     0,    65,    66,    67,
-       2,    68,     0,    69,     0,     0,    70,     0,    71,    75,
-       0,     0,     0,    72,     0,     0,    76,   262,    77,   114,
-       0,    74,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,    78,     0,   115,     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,    73,     0,     0,    78,    74,   115,     0,
-      79,     0,    80,    65,    66,    67,     2,    68,     0,    69,
-       0,     0,    70,     0,    71,     0,     0,    75,     0,    72,
-       0,     0,     0,    73,    76,     0,    77,    74,     0,    65,
-      66,    67,     2,    68,     0,    69,     0,     0,    70,     0,
-      71,     0,    78,     0,   115,    72,    79,    75,    80,    73,
-       0,     0,     0,    74,    76,     0,    77,   114,     0,    65,
-      66,    67,     2,    68,     0,    69,     0,     0,    70,     0,
-      71,     0,    78,    75,     0,    72,    79,     0,    80,    73,
-      76,     0,    77,    74,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,    78,     0,
-       0,     0,    79,    75,    80,     0,     0,     0,     0,     0,
-      76,     0,    77,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   151,   237,     0,
-       0,     0,    79,     0,    80,   152,   153,   154,   155,   156,
-     157,   158,   159,   160,   161,   162,     0,   163,   164,   165,
-     166,   167,   168,   169,   170,   171,   172,   173,   174,   175,
-     176,     0,   177,   178,   179,   180,     0,     0,   152,   153,
-     154,   155,   156,     0,   158,   159,   160,   161,   162,     0,
-     163,   164,   165,   166,   167,   168,   169,   170,     0,     0,
-       0,   151,     0,   181,     0,     0,     0,   182,   183,   152,
-     153,   154,   155,   156,   157,   158,   159,   160,   161,   162,
-       0,   163,   164,   165,   166,   167,   168,   169,   170,   171,
-     172,   173,   174,   175,   176,     0,   177,   178,   179,   180,
-     182,   183,   152,   153,   154,   155,   156,     0,   158,   159,
-     160,   161,     0,     0,   163,   164,   165,   166,   167,   168,
-     169,   170,     0,     0,     0,   151,     0,     0,     0,     0,
-     202,   182,   183,   152,   153,   154,   155,   156,   157,   158,
-     159,   160,   161,   162,     0,   163,   164,   165,   166,   167,
-     168,   169,   170,   171,   172,   173,   174,   175,   176,     0,
-     177,   178,   179,   180,   182,   183,   152,   153,   154,   155,
-     156,     0,   158,   159,   160,     0,     0,     0,   163,   164,
-     165,   166,   167,   168,   169,   170,     0,     0,     0,   151,
-     258,   336,     0,     0,     0,   182,   183,   152,   153,   154,
-     155,   156,   157,   158,   159,   160,   161,   162,     0,   163,
-     164,   165,   166,   167,   168,   169,   170,   171,   172,   173,
-     174,   175,   176,     0,   177,   178,   179,   180,   182,   183,
-     152,   153,   154,   155,   156,     0,   158,   159,   152,   153,
-     154,   155,   156,     0,     0,   159,     0,     0,   169,   170,
-       0,     0,     0,   151,     0,     0,   169,   170,     0,   182,
-     183,   152,   153,   154,   155,   156,   157,   158,   159,   160,
-     161,   162,     0,   163,   164,   165,   166,   167,   168,   169,
-     170,   171,   172,   173,   174,   175,   176,     0,   177,   178,
-     179,   180,   182,   183,   152,   153,   154,   155,   156,     0,
-     182,   183,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   169,   170,     0,     0,     0,   151,   353,     0,
-       0,     0,     0,   182,   183,   152,   153,   154,   155,   156,
-     157,   158,   159,   160,   161,   162,     0,   163,   164,   165,
-     166,   167,   168,   169,   170,   171,   172,   173,   174,   175,
-     176,     0,   177,   178,   179,   180,   182,   183,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   151,     0,   370,     0,     0,     0,   182,   183,   152,
-     153,   154,   155,   156,   157,   158,   159,   160,   161,   162,
-       0,   163,   164,   165,   166,   167,   168,   169,   170,   171,
-     172,   173,   174,   175,   176,     0,   177,   178,   179,   180,
-       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,   151,   112,   413,     0,
-       0,   182,   183,     0,   152,   153,   154,   155,   156,   157,
-     158,   159,   160,   161,   162,     0,   163,   164,   165,   166,
-     167,   168,   169,   170,   171,   172,   173,   174,   175,   176,
-       0,   177,   178,   179,   180,     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,
-     151,     0,   414,     0,     0,     0,   182,   183,   152,   153,
-     154,   155,   156,   157,   158,   159,   160,   161,   162,     0,
-     163,   164,   165,   166,   167,   168,   169,   170,   171,   172,
-     173,   174,   175,   176,     0,   177,   178,   179,   180,     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,   151,     0,     0,   420,     0,     0,
-     182,   183,   152,   153,   154,   155,   156,   157,   158,   159,
-     160,   161,   162,     0,   163,   164,   165,   166,   167,   168,
-     169,   170,   171,   172,   173,   174,   175,   176,     0,   177,
-     178,   179,   180,     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,   151,     0,
-       0,     0,     0,     0,   182,   183,   152,   153,   154,   155,
-     156,   157,   158,   159,   160,   161,   162,     0,   163,   164,
-     165,   166,   167,   168,   169,   170,   171,   172,   173,   174,
-     175,   176,     0,   177,   178,   179,   180,     0,   424,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   151,     0,     0,     0,     0,     0,   182,   183,
-     152,   153,   154,   155,   156,   157,   158,   159,   160,   161,
-     162,     0,   163,   164,   165,   166,   167,   168,   169,   170,
-     171,   172,   173,   174,   175,   176,     0,   177,   178,   179,
-     180,     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,   182,   183
-};
-
-static const yytype_int16 yycheck[] =
-{
-       0,    23,   248,   225,     4,     5,     6,     4,     4,     9,
-      10,    11,    12,     4,     4,    78,    50,     4,     4,   237,
-       4,    94,     5,    23,    54,    90,   246,    39,     6,     6,
-      42,     6,     7,    57,    57,    35,     9,    57,    13,     6,
-      57,    57,    42,    11,    44,    45,    46,    63,     6,     7,
-      74,    74,    73,     6,    74,    13,   303,    74,   305,    80,
-       9,    61,    62,    63,     6,     7,    46,    10,    98,    69,
-     100,    13,    10,    51,     6,     7,    78,    79,    78,    79,
-      80,    13,    62,    63,    51,   115,    57,    72,     8,    74,
-      90,    10,    92,    93,    94,     0,    73,    75,    78,    74,
-      73,    76,   348,   103,   104,   351,    74,    80,    10,   109,
-      90,   111,   112,    10,    72,   112,   112,   129,    76,    10,
-     120,   112,   112,   123,    73,   112,   112,   127,   112,   129,
-     350,   196,   132,    72,    76,   200,    72,    72,     6,     7,
-       8,    73,    72,   143,    76,    13,    74,    72,    80,    74,
-     150,    72,   132,    79,    72,   189,    48,     6,     7,   181,
-     378,    10,    48,    78,    13,    48,     6,     7,     8,    73,
-     150,    10,   418,    13,   237,    75,    10,    75,     5,    73,
-     214,   181,   182,   183,    48,   215,    74,   260,    16,    17,
-      18,    19,    20,    77,   194,   195,   196,   197,   420,   199,
-     200,     8,   202,     0,     1,   239,    48,   207,    76,     6,
-      75,    73,   212,    10,     6,     7,   196,    66,   218,    68,
-     200,    13,    48,    72,    10,   225,    73,    76,   225,   225,
-      10,    10,   212,     6,   225,   225,    76,   237,   225,   225,
-     240,   225,    10,    10,   244,    75,   246,    10,   248,   261,
-      78,    79,    49,    50,    48,    52,    53,   237,    75,    74,
-     260,    10,   262,    73,   264,    48,    75,    73,   248,    80,
-      73,    68,    69,    70,    71,   309,    10,    50,    75,    52,
-      53,    73,   262,    64,    76,    10,   320,    58,    73,     8,
-      62,   325,    58,    75,    58,    73,    69,    70,    71,    11,
-      75,    75,    58,   303,    73,   305,   212,   358,   308,   424,
-      75,    73,   344,    74,   344,    75,    75,   317,   151,   208,
-     390,   392,   356,     0,     1,   415,     4,   132,    37,     6,
-     330,   386,    -1,    10,    43,   317,     6,     7,    47,     6,
-       7,   375,    -1,    13,   378,    -1,    13,    -1,   348,   379,
-     350,   351,    -1,    -1,   388,    -1,   390,    -1,   358,    68,
-      -1,    70,    71,    72,    73,    74,   366,    -1,   348,    78,
-      -1,   351,    49,    50,    -1,    52,    53,    -1,   358,    -1,
-      -1,   415,   404,   417,    -1,    -1,    -1,   421,    -1,    -1,
-      -1,    68,    69,    70,    71,    -1,    66,    -1,    68,    66,
-      -1,    68,    72,   112,   404,   114,    76,    -1,    -1,    76,
-      -1,    -1,    -1,    -1,     6,     7,    -1,    -1,   418,    11,
-     420,    13,    -1,   420,   420,    16,    17,    18,    -1,   420,
-     420,    -1,   141,   420,   420,    -1,   420,    -1,   418,    -1,
-      -1,    -1,   151,   152,   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,    35,    -1,    66,    -1,    68,    -1,    -1,    42,
-      72,    44,    45,    46,    76,    -1,    -1,    78,    79,    -1,
-      -1,    -1,    -1,    -1,     3,     4,     5,     6,     7,   208,
-       9,    -1,   211,    12,   213,    14,    -1,    -1,    -1,    -1,
-      19,    -1,    -1,    -1,    23,    -1,   225,    80,    27,    -1,
-      -1,    -1,    -1,    -1,     6,     7,    -1,    90,   237,    92,
-      -1,    13,    -1,    -1,    -1,    -1,    -1,    -1,    47,    -1,
-     103,    -1,     6,     7,    -1,    54,   109,    56,   111,    13,
-      -1,     6,     7,   262,    -1,    -1,    -1,   120,    13,    -1,
-      -1,    -1,    -1,    72,    -1,    -1,    -1,    76,    77,    78,
-      -1,    -1,     3,     4,     5,     6,     7,    -1,     9,    -1,
-      -1,    12,    -1,    14,    66,    -1,    68,    -1,    19,    -1,
-      72,    -1,    23,    -1,    76,   304,    27,    -1,    -1,    -1,
-      -1,    -1,    66,    -1,    68,    -1,    -1,    -1,    72,    -1,
-      -1,    66,    76,    68,    -1,    -1,    47,    72,    -1,   182,
-     329,    76,    -1,    54,    -1,    56,    57,    -1,    -1,    -1,
-      -1,   194,   195,   196,    -1,    -1,   199,   200,    -1,   202,
-      -1,    72,    -1,    74,    -1,    76,    -1,    78,    79,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   371,    -1,   373,    -1,    -1,     1,    -1,     3,
-       4,     5,     6,     7,    -1,     9,    10,    -1,    12,    -1,
-      14,   244,   391,    -1,    -1,    19,    -1,    -1,   397,    23,
-      -1,    -1,    -1,    27,    -1,    -1,    -1,    -1,    -1,    -1,
-       1,    -1,    -1,    -1,   413,     6,    -1,    -1,    -1,    10,
-      -1,   420,    -1,    47,    -1,   424,    50,    -1,    52,    53,
-      54,    55,    56,    57,    -1,    59,    60,    61,    62,    63,
-      64,    65,    -1,    67,    68,    -1,    70,    71,    72,    -1,
-      74,    75,    76,    -1,    78,    -1,    -1,    -1,    49,    50,
-      -1,    52,    53,     1,   317,     3,     4,     5,     6,     7,
-      -1,     9,    10,    -1,    12,    -1,    14,    68,    69,    70,
-      71,    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,   366,    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,
-      -1,    -1,    -1,    -1,    -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,    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,    -1,    -1,    -1,    -1,    -1,    72,    73,    74,    -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,
-      74,    -1,    76,    -1,    78,    -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,    -1,    74,    -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,    74,    -1,
-      76,    -1,    78,     3,     4,     5,     6,     7,    -1,     9,
-      -1,    -1,    12,    -1,    14,    -1,    -1,    47,    -1,    19,
-      -1,    -1,    -1,    23,    54,    -1,    56,    27,    -1,     3,
-       4,     5,     6,     7,    -1,     9,    -1,    -1,    12,    -1,
-      14,    -1,    72,    -1,    74,    19,    76,    47,    78,    23,
-      -1,    -1,    -1,    27,    54,    -1,    56,    57,    -1,     3,
-       4,     5,     6,     7,    -1,     9,    -1,    -1,    12,    -1,
-      14,    -1,    72,    47,    -1,    19,    76,    -1,    78,    23,
-      54,    -1,    56,    27,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    72,    -1,
-      -1,    -1,    76,    47,    78,    -1,    -1,    -1,    -1,    -1,
-      54,    -1,    56,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -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,    -1,    -1,    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,    22,    23,    16,    17,
-      18,    19,    20,    -1,    -1,    23,    -1,    -1,    34,    35,
-      -1,    -1,    -1,     8,    -1,    -1,    34,    35,    -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,
-      78,    79,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    34,    35,    -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,    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,    -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,    -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,   103,   122,   123,   124,   131,
-     135,   136,   139,   141,   142,   143,    83,    85,   103,   124,
-     131,   135,   136,   139,    82,    82,     5,    57,   140,    82,
-      82,    82,     7,    13,    66,    68,    72,    76,    82,   119,
-     120,   121,    10,    10,     8,    10,   142,     0,    10,    10,
-      10,    72,    74,    74,   121,     3,     4,     5,     7,     9,
-      12,    14,    19,    23,    27,    47,    54,    56,    72,    76,
-      78,    82,    84,    86,    87,    88,    93,    94,    95,   125,
-      72,   119,    11,    74,    72,   119,   121,    95,     8,   121,
-       8,   121,    73,    80,    82,    91,    92,   121,   122,    77,
-      95,    72,    74,   101,    57,    74,    95,   107,   108,   110,
-      82,   129,   130,    82,   122,   126,   127,    51,    75,    82,
-     122,   128,   132,   133,    95,    82,    95,    95,    95,    95,
-      95,    72,    72,    82,    95,   122,   123,    82,   102,   121,
-      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,    92,   121,    82,   137,   138,    73,
-     102,   108,   108,   121,    66,    68,    48,     9,    73,    80,
-      48,   121,    77,   121,   134,     1,    10,    55,    57,    59,
-      60,    61,    63,    64,    65,    67,    68,    75,    82,    83,
-      85,    95,    96,    97,    98,    99,   100,   101,   103,   111,
-     112,   115,   118,   131,   135,   136,   139,    72,    95,   109,
-      79,   105,   106,   108,    78,   121,    48,    73,    10,    75,
-      82,    10,   119,    10,   133,    75,    95,     5,    73,    73,
-      48,    77,    23,    73,    82,    89,    90,   108,   122,    95,
-     107,    95,    95,    95,    95,    95,    95,    95,    95,    95,
-      95,    95,    95,    95,    95,    95,    95,    95,    95,    95,
-      95,    95,    95,    95,    95,    95,    95,    95,    95,    95,
-     142,   121,    82,    74,     8,    48,    75,   101,     9,    73,
-      73,    92,    82,    73,   121,    92,   121,    48,    73,    82,
-     109,    10,    10,    95,    89,    95,   101,    10,   108,    57,
-      63,   116,   117,    11,    10,    10,    10,    10,   100,    75,
-      10,   110,   101,    82,    48,    75,   121,   130,    74,   127,
-      72,    74,    10,    73,    73,   102,   119,   122,    48,    73,
-      75,   138,    95,   138,    82,   101,    80,    73,   134,   101,
-      74,    10,   101,    64,    10,    95,    82,    73,    58,     8,
-     106,   127,   130,   127,   101,    90,    58,    75,    73,   121,
-      58,    62,   113,   114,    95,    95,   101,    11,   101,   110,
-     108,    75,    73,    75,    74,   140,   101,    73,   101,   111,
-      95,   114,    75,    10,    10,    58,    95,   104,    74,   142,
-      11,    95,   101,   117,    48,   101,   127,    75,   100,   101,
-     104,    75
-};
-
-/* 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,    87,
-      87,    87,    87,    87,    87,    87,    87,    87,    87,    87,
-      87,    87,    87,    87,    87,    87,    87,    87,    87,    87,
-      87,    87,    87,    87,    87,    87,    87,    87,    88,    88,
-      88,    88,    88,    89,    89,    89,    90,    90,    91,    92,
-      92,    92,    92,    93,    93,    94,    95,    95,    95,    95,
-      95,    95,    95,    95,    95,    95,    95,    95,    95,    95,
-      95,    95,    95,    95,    95,    96,    97,    98,    99,    99,
-      99,    99,    99,    99,    99,    99,    99,    99,    99,    99,
-      99,    99,    99,    99,    99,    99,    99,    99,    99,    99,
-      99,   100,   100,   101,   101,   102,   102,   103,   103,   103,
-     104,   104,   105,   105,   106,   106,   107,   108,   108,   108,
-     108,   109,   109,   110,   110,   111,   111,   111,   112,   113,
-     114,   114,   115,   116,   117,   117,   117,   118,   118,   119,
-     119,   119,   119,   119,   120,   120,   121,   121,   121,   121,
-     121,   121,   121,   122,   122,   122,   123,   123,   123,   124,
-     124,   125,   126,   127,   127,   128,   128,   129,   130,   130,
-     131,   131,   132,   132,   132,   132,   133,   133,   134,   134,
-     135,   136,   136,   137,   137,   138,   138,   138,   139,   139,
-     140,   140,   140,   141,   141,   141,   141,   141,   141,   141,
-     141,   141,   141,   141,   141,   141,   141,   141,   141,   141,
-     141,   141,   142,   142,   143,   143
-};
-
-/* 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,     3,     2,     2,
-       2,     2,     2,     2,     1,     1,     3,     1,     1,     3,
-       3,     1,     1,     4,     3,     4,     1,     3,     2,     1,
-       1,     1,     1,     3,     1,     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,     4,     3,     1,     3,     1,     1,     1,
-       3,     1,     3,     5,     5,     3,     5,     5,     7,     4,
-       2,     1,     5,     5,     3,     5,     5,     2,     2,     5,
-       3,     4,     4,     2,     1,     7,     1,     2,     4,     2,
-       3,     4,     2,     3,     3,     2,     3,     4,     4,     3,
-       3,     5,     1,     3,     2,     5,     8,     2,     3,     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 143 "src/parser.y"
-            {}
-#line 1936 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_FLOAT: /* FLOAT  */
-#line 143 "src/parser.y"
-            {}
-#line 1942 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_STRING: /* STRING  */
-#line 143 "src/parser.y"
-            {}
-#line 1948 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_ID: /* ID  */
-#line 143 "src/parser.y"
-            {}
-#line 1954 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_id: /* id  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 1960 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_var: /* var  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 1966 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_embed: /* embed  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 1972 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_import: /* import  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 1978 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_assign: /* assign  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 1984 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_binary_op: /* binary_op  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 1990 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_unary_op: /* unary_op  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 1996 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_arg: /* arg  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2002 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_arg_list: /* arg_list  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2008 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_param_decl: /* param_decl  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2014 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_decl_list: /* decl_list  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2020 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_call: /* call  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2026 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_defer: /* defer  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2032 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_expr: /* expr  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2038 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_while: /* while  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2044 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_do_while: /* do_while  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2050 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_goto: /* goto  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2056 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_statement: /* statement  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2062 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_statement_list: /* statement_list  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2068 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_body: /* body  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2074 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_macro_list: /* macro_list  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2080 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_macro: /* macro  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2086 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_expr_list: /* expr_list  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2092 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_struct_init: /* struct_init  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2098 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_struct_inits: /* struct_inits  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2104 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_struct_construct: /* struct_construct  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2110 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_init_expr: /* init_expr  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2116 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_cond: /* cond  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2122 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_expr_if: /* expr_if  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2128 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_if: /* if  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2134 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_for: /* for  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2140 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_case: /* case  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2146 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_case_list: /* case_list  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2152 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_switch: /* switch  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2158 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_const_for: /* const_for  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2164 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_const_if: /* const_if  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2170 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_const: /* const  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2176 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_func_sign: /* func_sign  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2182 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_variadic_sign: /* variadic_sign  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2188 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_type: /* type  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2194 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_var_decl: /* var_decl  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2200 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_var_init: /* var_init  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2206 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_proc: /* proc  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2212 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_lambda: /* lambda  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2218 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_struct_elem: /* struct_elem  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2224 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_struct_list: /* struct_list  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2230 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_union: /* union  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2236 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_generic: /* generic  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2242 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_generic_list: /* generic_list  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2248 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_struct: /* struct  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2254 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_template_elem: /* template_elem  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2260 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_template_list: /* template_list  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2266 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_type_list: /* type_list  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2272 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_type_alias: /* type_alias  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2278 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_type_template: /* type_template  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2284 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_enum_val: /* enum_val  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2290 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_enum_list: /* enum_list  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2296 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_enum: /* enum  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2302 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_top_if: /* top_if  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2308 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_top: /* top  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2314 "src/gen_parser.c"
-        break;
-
-    case YYSYMBOL_unit: /* unit  */
-#line 144 "src/parser.y"
-            { destroy_ast_tree(((*yyvaluep).node)); }
-#line 2320 "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 148 "src/parser.y"
-       {
-		(yyval.node) = gen_id(strdup((yyvsp[0].str)));
-		(yyval.node)->loc = to_src_loc(&yylloc);
-	}
-#line 2629 "src/gen_parser.c"
-    break;
-
-  case 3: /* var: var_decl  */
-#line 154 "src/parser.y"
-              { (yyval.node) = (yyvsp[0].node); }
-#line 2635 "src/gen_parser.c"
-    break;
-
-  case 4: /* var: var_init  */
-#line 155 "src/parser.y"
-                   { (yyval.node) = (yyvsp[0].node); }
-#line 2641 "src/gen_parser.c"
-    break;
-
-  case 5: /* embed: "embed" "(" STRING ")"  */
-#line 158 "src/parser.y"
-                              { (yyval.node) = gen_embed(clone_string((yyvsp[-1].str)));  }
-#line 2647 "src/gen_parser.c"
-    break;
-
-  case 6: /* import: "import" STRING  */
-#line 161 "src/parser.y"
-                        { (yyval.node) = gen_import(clone_string((yyvsp[0].str)));  }
-#line 2653 "src/gen_parser.c"
-    break;
-
-  case 7: /* assign: expr "=" expr  */
-#line 164 "src/parser.y"
-                      { (yyval.node) = gen_assign((yyvsp[-2].node), (yyvsp[0].node)); }
-#line 2659 "src/gen_parser.c"
-    break;
-
-  case 8: /* assign: expr "=" struct_construct  */
-#line 165 "src/parser.y"
-                                    { (yyval.node) = gen_assign((yyvsp[-2].node), (yyvsp[0].node)); }
-#line 2665 "src/gen_parser.c"
-    break;
-
-  case 9: /* binary_op: expr "+" expr  */
-#line 168 "src/parser.y"
-                         { (yyval.node) = gen_binop(AST_ADD, (yyvsp[-2].node), (yyvsp[0].node));  }
-#line 2671 "src/gen_parser.c"
-    break;
-
-  case 10: /* binary_op: expr "-" expr  */
-#line 169 "src/parser.y"
-                        { (yyval.node) = gen_binop(AST_SUB, (yyvsp[-2].node), (yyvsp[0].node));  }
-#line 2677 "src/gen_parser.c"
-    break;
-
-  case 11: /* binary_op: expr "*" expr  */
-#line 170 "src/parser.y"
-                        { (yyval.node) = gen_binop(AST_MUL, (yyvsp[-2].node), (yyvsp[0].node));  }
-#line 2683 "src/gen_parser.c"
-    break;
-
-  case 12: /* binary_op: expr "/" expr  */
-#line 171 "src/parser.y"
-                        { (yyval.node) = gen_binop(AST_DIV, (yyvsp[-2].node), (yyvsp[0].node));  }
-#line 2689 "src/gen_parser.c"
-    break;
-
-  case 13: /* binary_op: expr "%" expr  */
-#line 172 "src/parser.y"
-                        { (yyval.node) = gen_binop(AST_REM, (yyvsp[-2].node), (yyvsp[0].node));  }
-#line 2695 "src/gen_parser.c"
-    break;
-
-  case 14: /* binary_op: expr "^" expr  */
-#line 173 "src/parser.y"
-                        { (yyval.node) = gen_binop(AST_XOR, (yyvsp[-2].node), (yyvsp[0].node));  }
-#line 2701 "src/gen_parser.c"
-    break;
-
-  case 15: /* binary_op: expr "^^" expr  */
-#line 174 "src/parser.y"
-                         { (yyval.node) = gen_binop(AST_POW, (yyvsp[-2].node), (yyvsp[0].node));  }
-#line 2707 "src/gen_parser.c"
-    break;
-
-  case 16: /* binary_op: expr "&" expr  */
-#line 175 "src/parser.y"
-                        { (yyval.node) = gen_binop(AST_AND, (yyvsp[-2].node), (yyvsp[0].node));  }
-#line 2713 "src/gen_parser.c"
-    break;
-
-  case 17: /* binary_op: expr "&&" expr  */
-#line 176 "src/parser.y"
-                         { (yyval.node) = gen_binop(AST_LAND, (yyvsp[-2].node), (yyvsp[0].node));  }
-#line 2719 "src/gen_parser.c"
-    break;
-
-  case 18: /* binary_op: expr "|" expr  */
-#line 177 "src/parser.y"
-                        { (yyval.node) = gen_binop(AST_OR, (yyvsp[-2].node), (yyvsp[0].node));  }
-#line 2725 "src/gen_parser.c"
-    break;
-
-  case 19: /* binary_op: expr "||" expr  */
-#line 178 "src/parser.y"
-                         { (yyval.node) = gen_binop(AST_LOR, (yyvsp[-2].node), (yyvsp[0].node));  }
-#line 2731 "src/gen_parser.c"
-    break;
-
-  case 20: /* binary_op: expr "<<" expr  */
-#line 179 "src/parser.y"
-                         { (yyval.node) = gen_binop(AST_LSHIFT, (yyvsp[-2].node), (yyvsp[0].node));  }
-#line 2737 "src/gen_parser.c"
-    break;
-
-  case 21: /* binary_op: expr ">>" expr  */
-#line 180 "src/parser.y"
-                         { (yyval.node) = gen_binop(AST_RSHIFT, (yyvsp[-2].node), (yyvsp[0].node));  }
-#line 2743 "src/gen_parser.c"
-    break;
-
-  case 22: /* binary_op: expr "+=" expr  */
-#line 181 "src/parser.y"
-                         { (yyval.node) = gen_binop(AST_ASSIGN_ADD, (yyvsp[-2].node), (yyvsp[0].node));  }
-#line 2749 "src/gen_parser.c"
-    break;
-
-  case 23: /* binary_op: expr "-=" expr  */
-#line 182 "src/parser.y"
-                         { (yyval.node) = gen_binop(AST_ASSIGN_SUB, (yyvsp[-2].node), (yyvsp[0].node));  }
-#line 2755 "src/gen_parser.c"
-    break;
-
-  case 24: /* binary_op: expr "*=" expr  */
-#line 183 "src/parser.y"
-                         { (yyval.node) = gen_binop(AST_ASSIGN_MUL, (yyvsp[-2].node), (yyvsp[0].node));  }
-#line 2761 "src/gen_parser.c"
-    break;
-
-  case 25: /* binary_op: expr "/=" expr  */
-#line 184 "src/parser.y"
-                         { (yyval.node) = gen_binop(AST_ASSIGN_DIV, (yyvsp[-2].node), (yyvsp[0].node));  }
-#line 2767 "src/gen_parser.c"
-    break;
-
-  case 26: /* binary_op: expr "%=" expr  */
-#line 185 "src/parser.y"
-                         { (yyval.node) = gen_binop(AST_ASSIGN_REM, (yyvsp[-2].node), (yyvsp[0].node));  }
-#line 2773 "src/gen_parser.c"
-    break;
-
-  case 27: /* binary_op: expr "&=" expr  */
-#line 186 "src/parser.y"
-                         { (yyval.node) = gen_binop(AST_ASSIGN_AND, (yyvsp[-2].node), (yyvsp[0].node));  }
-#line 2779 "src/gen_parser.c"
-    break;
-
-  case 28: /* binary_op: expr "|=" expr  */
-#line 187 "src/parser.y"
-                         { (yyval.node) = gen_binop(AST_ASSIGN_OR, (yyvsp[-2].node), (yyvsp[0].node));  }
-#line 2785 "src/gen_parser.c"
-    break;
-
-  case 29: /* binary_op: expr "^=" expr  */
-#line 188 "src/parser.y"
-                         { (yyval.node) = gen_binop(AST_ASSIGN_XOR, (yyvsp[-2].node), (yyvsp[0].node));  }
-#line 2791 "src/gen_parser.c"
-    break;
-
-  case 30: /* binary_op: expr "<<=" expr  */
-#line 189 "src/parser.y"
-                          {
-		(yyval.node) = gen_binop(AST_ASSIGN_LSHIFT, (yyvsp[-2].node), (yyvsp[0].node));
-	}
-#line 2799 "src/gen_parser.c"
-    break;
-
-  case 31: /* binary_op: expr ">>=" expr  */
-#line 192 "src/parser.y"
-                          {
-		(yyval.node) = gen_binop(AST_ASSIGN_RSHIFT, (yyvsp[-2].node), (yyvsp[0].node));
-	}
-#line 2807 "src/gen_parser.c"
-    break;
-
-  case 32: /* binary_op: expr "<" expr  */
-#line 195 "src/parser.y"
-                        { (yyval.node) = gen_binop(AST_LT, (yyvsp[-2].node), (yyvsp[0].node));  }
-#line 2813 "src/gen_parser.c"
-    break;
-
-  case 33: /* binary_op: expr ">" expr  */
-#line 196 "src/parser.y"
-                        { (yyval.node) = gen_binop(AST_GT, (yyvsp[-2].node), (yyvsp[0].node));  }
-#line 2819 "src/gen_parser.c"
-    break;
-
-  case 34: /* binary_op: expr "<=" expr  */
-#line 197 "src/parser.y"
-                         { (yyval.node) = gen_binop(AST_LE, (yyvsp[-2].node), (yyvsp[0].node));  }
-#line 2825 "src/gen_parser.c"
-    break;
-
-  case 35: /* binary_op: expr ">=" expr  */
-#line 198 "src/parser.y"
-                         { (yyval.node) = gen_binop(AST_GE, (yyvsp[-2].node), (yyvsp[0].node));  }
-#line 2831 "src/gen_parser.c"
-    break;
-
-  case 36: /* binary_op: expr "!=" expr  */
-#line 199 "src/parser.y"
-                         { (yyval.node) = gen_binop(AST_NE, (yyvsp[-2].node), (yyvsp[0].node));  }
-#line 2837 "src/gen_parser.c"
-    break;
-
-  case 37: /* binary_op: expr "==" expr  */
-#line 200 "src/parser.y"
-                         { (yyval.node) = gen_binop(AST_EQ, (yyvsp[-2].node), (yyvsp[0].node));  }
-#line 2843 "src/gen_parser.c"
-    break;
-
-  case 38: /* unary_op: "-" expr  */
-#line 203 "src/parser.y"
-                   { (yyval.node) = gen_unop(AST_NEG, (yyvsp[0].node));  }
-#line 2849 "src/gen_parser.c"
-    break;
-
-  case 39: /* unary_op: "!" expr  */
-#line 204 "src/parser.y"
-                   { (yyval.node) = gen_unop(AST_LNOT, (yyvsp[0].node));  }
-#line 2855 "src/gen_parser.c"
-    break;
-
-  case 40: /* unary_op: "&" expr  */
-#line 205 "src/parser.y"
-                   { (yyval.node) = gen_unop(AST_REF, (yyvsp[0].node));  }
-#line 2861 "src/gen_parser.c"
-    break;
-
-  case 41: /* unary_op: "'" expr  */
-#line 206 "src/parser.y"
-                   { (yyval.node) = gen_unop(AST_DEREF, (yyvsp[0].node));  }
-#line 2867 "src/gen_parser.c"
-    break;
-
-  case 42: /* unary_op: "~" expr  */
-#line 207 "src/parser.y"
-                   { (yyval.node) = gen_unop(AST_NOT, (yyvsp[0].node));  }
-#line 2873 "src/gen_parser.c"
-    break;
-
-  case 43: /* arg: "&" var_decl  */
-#line 210 "src/parser.y"
-                  { (yyval.node) = gen_unop(AST_REF, (yyvsp[0].node));  }
-#line 2879 "src/gen_parser.c"
-    break;
-
-  case 44: /* arg: var_decl  */
-#line 211 "src/parser.y"
-                   { (yyval.node) = (yyvsp[0].node); }
-#line 2885 "src/gen_parser.c"
-    break;
-
-  case 45: /* arg: init_expr  */
-#line 212 "src/parser.y"
-                    { (yyval.node) = (yyvsp[0].node); }
-#line 2891 "src/gen_parser.c"
-    break;
-
-  case 46: /* arg_list: arg "," arg_list  */
-#line 215 "src/parser.y"
-                           { (yyval.node) = (yyvsp[-2].node); (yyvsp[-2].node)->next = (yyvsp[0].node); }
-#line 2897 "src/gen_parser.c"
-    break;
-
-  case 47: /* arg_list: arg  */
-#line 216 "src/parser.y"
-              { (yyval.node) = (yyvsp[0].node); }
-#line 2903 "src/gen_parser.c"
-    break;
-
-  case 48: /* param_decl: type  */
-#line 219 "src/parser.y"
-                 { (yyval.node) = gen_var(NULL, (yyvsp[0].node), NULL);  }
-#line 2909 "src/gen_parser.c"
-    break;
-
-  case 49: /* decl_list: var_decl "," decl_list  */
-#line 221 "src/parser.y"
-                                  { (yyval.node) = (yyvsp[-2].node); (yyvsp[-2].node)->next = (yyvsp[0].node); }
-#line 2915 "src/gen_parser.c"
-    break;
-
-  case 50: /* decl_list: param_decl "," decl_list  */
-#line 222 "src/parser.y"
-                                   { (yyval.node) = (yyvsp[-2].node); (yyvsp[-2].node)->next = (yyvsp[0].node); }
-#line 2921 "src/gen_parser.c"
-    break;
-
-  case 51: /* decl_list: var_decl  */
-#line 223 "src/parser.y"
-                   { (yyval.node) = (yyvsp[0].node); }
-#line 2927 "src/gen_parser.c"
-    break;
-
-  case 52: /* decl_list: param_decl  */
-#line 224 "src/parser.y"
-                     { (yyval.node) = (yyvsp[0].node); }
-#line 2933 "src/gen_parser.c"
-    break;
-
-  case 53: /* call: id "(" arg_list ")"  */
-#line 228 "src/parser.y"
-                          { (yyval.node) = gen_call((yyvsp[-3].node), (yyvsp[-1].node));  }
-#line 2939 "src/gen_parser.c"
-    break;
-
-  case 54: /* call: id "(" ")"  */
-#line 229 "src/parser.y"
-                     { (yyval.node) = gen_call((yyvsp[-2].node), NULL);  }
-#line 2945 "src/gen_parser.c"
-    break;
-
-  case 55: /* defer: "defer" "(" expr ")"  */
-#line 232 "src/parser.y"
-                            { (yyval.node) = gen_defer((yyvsp[-1].node));  }
-#line 2951 "src/gen_parser.c"
-    break;
-
-  case 56: /* expr: id  */
-#line 236 "src/parser.y"
-         { (yyval.node) = (yyvsp[0].node); }
-#line 2957 "src/gen_parser.c"
-    break;
-
-  case 57: /* expr: expr "." id  */
-#line 237 "src/parser.y"
-                      { (yyval.node) = gen_dot((yyvsp[-2].node), (yyvsp[0].node)); }
-#line 2963 "src/gen_parser.c"
-    break;
-
-  case 58: /* expr: "..." id  */
-#line 238 "src/parser.y"
-                   { (yyval.node) = (yyvsp[0].node); }
-#line 2969 "src/gen_parser.c"
-    break;
-
-  case 59: /* expr: "@"  */
-#line 239 "src/parser.y"
-              { (yyval.node) = gen_last();  }
-#line 2975 "src/gen_parser.c"
-    break;
-
-  case 60: /* expr: INT  */
-#line 240 "src/parser.y"
-              { (yyval.node) = gen_int((yyvsp[0].integer)); (yyval.node)->loc = to_src_loc(&yylloc); }
-#line 2981 "src/gen_parser.c"
-    break;
-
-  case 61: /* expr: FLOAT  */
-#line 241 "src/parser.y"
-                { (yyval.node) = gen_float((yyvsp[0].dbl)); (yyval.node)->loc = to_src_loc(&yylloc);  }
-#line 2987 "src/gen_parser.c"
-    break;
-
-  case 62: /* expr: STRING  */
-#line 242 "src/parser.y"
-                 {
-		(yyval.node) = gen_string(clone_string((yyvsp[0].str)));
-		(yyval.node)->loc = to_src_loc(&yylloc);
-	}
-#line 2996 "src/gen_parser.c"
-    break;
-
-  case 63: /* expr: "(" expr ")"  */
-#line 246 "src/parser.y"
-                       { (yyval.node) = (yyvsp[-1].node); }
-#line 3002 "src/gen_parser.c"
-    break;
-
-  case 64: /* expr: assign  */
-#line 247 "src/parser.y"
-                 { (yyval.node) = (yyvsp[0].node); }
-#line 3008 "src/gen_parser.c"
-    break;
-
-  case 65: /* expr: call  */
-#line 248 "src/parser.y"
-               { (yyval.node) = (yyvsp[0].node); }
-#line 3014 "src/gen_parser.c"
-    break;
-
-  case 66: /* expr: defer  */
-#line 249 "src/parser.y"
-                { (yyval.node) = (yyvsp[0].node); }
-#line 3020 "src/gen_parser.c"
-    break;
-
-  case 67: /* expr: binary_op  */
-#line 250 "src/parser.y"
-                    { (yyval.node) = (yyvsp[0].node); }
-#line 3026 "src/gen_parser.c"
-    break;
-
-  case 68: /* expr: unary_op  */
-#line 251 "src/parser.y"
-                   { (yyval.node) = (yyvsp[0].node); }
-#line 3032 "src/gen_parser.c"
-    break;
-
-  case 69: /* expr: "(" var_init ")"  */
-#line 252 "src/parser.y"
-                           { (yyval.node) = (yyvsp[-1].node); }
-#line 3038 "src/gen_parser.c"
-    break;
-
-  case 70: /* expr: "sizeof" expr  */
-#line 253 "src/parser.y"
-                        { (yyval.node) = gen_sizeof((yyvsp[0].node)); }
-#line 3044 "src/gen_parser.c"
-    break;
-
-  case 71: /* expr: expr "as" type  */
-#line 254 "src/parser.y"
-                         { (yyval.node) = gen_cast((yyvsp[-2].node), (yyvsp[0].node));  }
-#line 3050 "src/gen_parser.c"
-    break;
-
-  case 72: /* expr: "as" type  */
-#line 255 "src/parser.y"
-                    { (yyval.node) = gen_as((yyvsp[0].node)); }
-#line 3056 "src/gen_parser.c"
-    break;
-
-  case 73: /* expr: embed  */
-#line 256 "src/parser.y"
-                { (yyval.node) = (yyvsp[0].node); }
-#line 3062 "src/gen_parser.c"
-    break;
-
-  case 74: /* expr: lambda  */
-#line 257 "src/parser.y"
-                 { (yyval.node) = (yyvsp[0].node); }
-#line 3068 "src/gen_parser.c"
-    break;
-
-  case 75: /* while: "while" expr body  */
-#line 260 "src/parser.y"
-                         { (yyval.node) = gen_while((yyvsp[-1].node), (yyvsp[0].node));  }
-#line 3074 "src/gen_parser.c"
-    break;
-
-  case 76: /* do_while: "do" body "while" expr ";"  */
-#line 263 "src/parser.y"
-                                     {
-		(yyval.node) = gen_while((yyvsp[-3].node), (yyvsp[-1].node));
-		ast_set_flags((yyval.node), AST_FLAG_DELAYED);
-	}
-#line 3083 "src/gen_parser.c"
-    break;
-
-  case 77: /* goto: "goto" id  */
-#line 269 "src/parser.y"
-                { (yyval.node) = gen_goto(gen_label((yyvsp[0].node)));  }
-#line 3089 "src/gen_parser.c"
-    break;
-
-  case 78: /* statement: expr ";"  */
-#line 271 "src/parser.y"
-                    { (yyval.node) = (yyvsp[-1].node); }
-#line 3095 "src/gen_parser.c"
-    break;
-
-  case 79: /* statement: "return" init_expr ";"  */
-#line 272 "src/parser.y"
-                                 { (yyval.node) = gen_return((yyvsp[-1].node));  }
-#line 3101 "src/gen_parser.c"
-    break;
-
-  case 80: /* statement: "return" ";"  */
-#line 273 "src/parser.y"
-                       { (yyval.node) = gen_return(NULL); }
-#line 3107 "src/gen_parser.c"
-    break;
-
-  case 81: /* statement: "break" ";"  */
-#line 274 "src/parser.y"
-                      { (yyval.node) = gen_ctrl(AST_CTRL_BREAK, to_src_loc(&yylloc)); }
-#line 3113 "src/gen_parser.c"
-    break;
-
-  case 82: /* statement: "continue" ";"  */
-#line 275 "src/parser.y"
-                         { (yyval.node) = gen_ctrl(AST_CTRL_CONTINUE,
-	to_src_loc(&yylloc));  }
-#line 3120 "src/gen_parser.c"
-    break;
-
-  case 83: /* statement: import ";"  */
-#line 277 "src/parser.y"
-                     { (yyval.node) = (yyvsp[-1].node); }
-#line 3126 "src/gen_parser.c"
-    break;
-
-  case 84: /* statement: var ";"  */
-#line 278 "src/parser.y"
-                  { (yyval.node) = (yyvsp[-1].node); }
-#line 3132 "src/gen_parser.c"
-    break;
-
-  case 85: /* statement: if  */
-#line 279 "src/parser.y"
-             { (yyval.node) = (yyvsp[0].node); }
-#line 3138 "src/gen_parser.c"
-    break;
-
-  case 86: /* statement: goto ";"  */
-#line 280 "src/parser.y"
-                  { (yyval.node) = (yyvsp[-1].node); }
-#line 3144 "src/gen_parser.c"
-    break;
-
-  case 87: /* statement: id ":"  */
-#line 281 "src/parser.y"
-                 { (yyval.node) = gen_label((yyvsp[-1].node));  }
-#line 3150 "src/gen_parser.c"
-    break;
-
-  case 88: /* statement: for  */
-#line 282 "src/parser.y"
-              { (yyval.node) = (yyvsp[0].node); }
-#line 3156 "src/gen_parser.c"
-    break;
-
-  case 89: /* statement: const  */
-#line 283 "src/parser.y"
-                { (yyval.node) = (yyvsp[0].node); }
-#line 3162 "src/gen_parser.c"
-    break;
-
-  case 90: /* statement: while  */
-#line 284 "src/parser.y"
-                { (yyval.node) = (yyvsp[0].node); }
-#line 3168 "src/gen_parser.c"
-    break;
-
-  case 91: /* statement: do_while  */
-#line 285 "src/parser.y"
-                   { (yyval.node) = (yyvsp[0].node); }
-#line 3174 "src/gen_parser.c"
-    break;
-
-  case 92: /* statement: switch  */
-#line 286 "src/parser.y"
-                 { (yyval.node) = (yyvsp[0].node); }
-#line 3180 "src/gen_parser.c"
-    break;
-
-  case 93: /* statement: macro  */
-#line 287 "src/parser.y"
-                { (yyval.node) = (yyvsp[0].node); }
-#line 3186 "src/gen_parser.c"
-    break;
-
-  case 94: /* statement: struct  */
-#line 288 "src/parser.y"
-                 { (yyval.node) = (yyvsp[0].node); }
-#line 3192 "src/gen_parser.c"
-    break;
-
-  case 95: /* statement: type_alias ";"  */
-#line 289 "src/parser.y"
-                         { (yyval.node) = (yyvsp[-1].node); }
-#line 3198 "src/gen_parser.c"
-    break;
-
-  case 96: /* statement: type_template  */
-#line 290 "src/parser.y"
-                        { (yyval.node) = (yyvsp[0].node); }
-#line 3204 "src/gen_parser.c"
-    break;
-
-  case 97: /* statement: enum  */
-#line 291 "src/parser.y"
-               { (yyval.node) = (yyvsp[0].node); }
-#line 3210 "src/gen_parser.c"
-    break;
-
-  case 98: /* statement: body  */
-#line 292 "src/parser.y"
-               { (yyval.node) = (yyvsp[0].node); }
-#line 3216 "src/gen_parser.c"
-    break;
-
-  case 99: /* statement: ";"  */
-#line 293 "src/parser.y"
-              { (yyval.node) = gen_empty();  }
-#line 3222 "src/gen_parser.c"
-    break;
-
-  case 100: /* statement: error  */
-#line 294 "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 3241 "src/gen_parser.c"
-    break;
-
-  case 101: /* statement_list: statement statement_list  */
-#line 310 "src/parser.y"
-                                         { (yyval.node) = (yyvsp[-1].node); (yyvsp[-1].node)->next = (yyvsp[0].node); }
-#line 3247 "src/gen_parser.c"
-    break;
-
-  case 102: /* statement_list: statement  */
-#line 311 "src/parser.y"
-                    { (yyval.node) = (yyvsp[0].node); }
-#line 3253 "src/gen_parser.c"
-    break;
-
-  case 103: /* body: "{" statement_list "}"  */
-#line 314 "src/parser.y"
-                             { (yyval.node) = gen_block((yyvsp[-1].node));  }
-#line 3259 "src/gen_parser.c"
-    break;
-
-  case 104: /* body: "{" "}"  */
-#line 315 "src/parser.y"
-                  { (yyval.node) = gen_block(gen_empty());  }
-#line 3265 "src/gen_parser.c"
-    break;
-
-  case 105: /* macro_list: id "," macro_list  */
-#line 318 "src/parser.y"
-                              { (yyval.node) = (yyvsp[-2].node); (yyval.node)->next = (yyvsp[0].node); }
-#line 3271 "src/gen_parser.c"
-    break;
-
-  case 106: /* macro_list: id  */
-#line 319 "src/parser.y"
-             { (yyval.node) = (yyvsp[0].node); }
-#line 3277 "src/gen_parser.c"
-    break;
-
-  case 107: /* macro: "define" id "(" macro_list ")" body  */
-#line 322 "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 3286 "src/gen_parser.c"
-    break;
-
-  case 108: /* macro: "define" id "(" macro_list "..." id ")" body  */
-#line 326 "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 3298 "src/gen_parser.c"
-    break;
-
-  case 109: /* macro: "define" id "(" ")" body  */
-#line 333 "src/parser.y"
-                                   {
-		(yyval.node) = gen_macro((yyvsp[-3].node), NULL, (yyvsp[0].node));
-		ast_set_flags((yyvsp[0].node), AST_FLAG_UNHYGIENIC);
-	}
-#line 3307 "src/gen_parser.c"
-    break;
-
-  case 110: /* expr_list: expr "," expr_list  */
-#line 339 "src/parser.y"
-                              { (yyval.node) = (yyvsp[-2].node); (yyvsp[-2].node)->next = (yyvsp[0].node); }
-#line 3313 "src/gen_parser.c"
-    break;
-
-  case 111: /* expr_list: expr  */
-#line 340 "src/parser.y"
-               { (yyval.node) = (yyvsp[0].node); }
-#line 3319 "src/gen_parser.c"
-    break;
-
-  case 112: /* struct_init: init_expr  */
-#line 343 "src/parser.y"
-                       { (yyval.node) = (yyvsp[0].node); }
-#line 3325 "src/gen_parser.c"
-    break;
-
-  case 113: /* struct_init: "." id "=" init_expr  */
-#line 344 "src/parser.y"
-                               {
-		(yyval.node) = gen_var((yyvsp[-2].node), NULL, (yyvsp[0].node));
-		ast_set_flags((yyval.node), AST_FLAG_MEMBER);
-	}
-#line 3334 "src/gen_parser.c"
-    break;
-
-  case 114: /* struct_inits: struct_init "," struct_inits  */
-#line 350 "src/parser.y"
-                                           { (yyval.node) = (yyvsp[-2].node); (yyvsp[-2].node)->next = (yyvsp[0].node); }
-#line 3340 "src/gen_parser.c"
-    break;
-
-  case 115: /* struct_inits: struct_init  */
-#line 351 "src/parser.y"
-                      { (yyval.node) = (yyvsp[0].node); }
-#line 3346 "src/gen_parser.c"
-    break;
-
-  case 116: /* struct_construct: "{" struct_inits "}"  */
-#line 354 "src/parser.y"
-                                       { (yyval.node) = gen_init((yyvsp[-1].node)); }
-#line 3352 "src/gen_parser.c"
-    break;
-
-  case 117: /* init_expr: expr  */
-#line 357 "src/parser.y"
-                { (yyval.node) = (yyvsp[0].node); }
-#line 3358 "src/gen_parser.c"
-    break;
-
-  case 118: /* init_expr: expr_if  */
-#line 358 "src/parser.y"
-                  { (yyval.node) = (yyvsp[0].node); }
-#line 3364 "src/gen_parser.c"
-    break;
-
-  case 119: /* init_expr: struct_construct  */
-#line 359 "src/parser.y"
-                           { (yyval.node) = (yyvsp[0].node); }
-#line 3370 "src/gen_parser.c"
-    break;
-
-  case 120: /* init_expr: struct_construct "as" type  */
-#line 360 "src/parser.y"
-                                     { (yyval.node) = gen_cast((yyvsp[-2].node), (yyvsp[0].node)); }
-#line 3376 "src/gen_parser.c"
-    break;
-
-  case 121: /* cond: expr  */
-#line 363 "src/parser.y"
-           { (yyval.node) = (yyvsp[0].node); }
-#line 3382 "src/gen_parser.c"
-    break;
-
-  case 122: /* cond: "(" expr_if ")"  */
-#line 364 "src/parser.y"
-                          { (yyval.node) = (yyvsp[-1].node); }
-#line 3388 "src/gen_parser.c"
-    break;
-
-  case 123: /* expr_if: "if" cond body "else" body  */
-#line 368 "src/parser.y"
-                                    { (yyval.node) = gen_if((yyvsp[-3].node), (yyvsp[-2].node), (yyvsp[0].node));  }
-#line 3394 "src/gen_parser.c"
-    break;
-
-  case 124: /* expr_if: "if" cond body "else" expr_if  */
-#line 369 "src/parser.y"
-                                        { (yyval.node) = gen_if((yyvsp[-3].node), (yyvsp[-2].node), (yyvsp[0].node));  }
-#line 3400 "src/gen_parser.c"
-    break;
-
-  case 125: /* if: "if" cond body  */
-#line 372 "src/parser.y"
-                   { (yyval.node) = gen_if((yyvsp[-1].node), (yyvsp[0].node), NULL);  }
-#line 3406 "src/gen_parser.c"
-    break;
-
-  case 126: /* if: "if" cond body "else" body  */
-#line 373 "src/parser.y"
-                                     { (yyval.node) = gen_if((yyvsp[-3].node), (yyvsp[-2].node), (yyvsp[0].node));  }
-#line 3412 "src/gen_parser.c"
-    break;
-
-  case 127: /* if: "if" cond body "else" if  */
-#line 374 "src/parser.y"
-                                   { (yyval.node) = gen_if((yyvsp[-3].node), (yyvsp[-2].node), (yyvsp[0].node));  }
-#line 3418 "src/gen_parser.c"
-    break;
-
-  case 128: /* for: "for" arg ";" expr ";" expr body  */
-#line 377 "src/parser.y"
-                                      { (yyval.node) = gen_for((yyvsp[-5].node), (yyvsp[-3].node), (yyvsp[-1].node), (yyvsp[0].node)); }
-#line 3424 "src/gen_parser.c"
-    break;
-
-  case 129: /* case: "case" expr ":" statement_list  */
-#line 380 "src/parser.y"
-                                     { (yyval.node) = gen_case((yyvsp[-2].node), (yyvsp[0].node));  }
-#line 3430 "src/gen_parser.c"
-    break;
-
-  case 130: /* case_list: case case_list  */
-#line 383 "src/parser.y"
-                          { (yyval.node) = (yyvsp[-1].node); (yyvsp[-1].node)->next = (yyvsp[0].node); }
-#line 3436 "src/gen_parser.c"
-    break;
-
-  case 131: /* case_list: case  */
-#line 384 "src/parser.y"
-               { (yyval.node) = (yyvsp[0].node); }
-#line 3442 "src/gen_parser.c"
-    break;
-
-  case 132: /* switch: "switch" expr "{" case_list "}"  */
-#line 387 "src/parser.y"
-                                        { (yyval.node) = gen_switch((yyvsp[-3].node), (yyvsp[-1].node));  }
-#line 3448 "src/gen_parser.c"
-    break;
-
-  case 133: /* const_for: "for" id ":" expr_list body  */
-#line 390 "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 3458 "src/gen_parser.c"
-    break;
-
-  case 134: /* const_if: "if" expr body  */
-#line 397 "src/parser.y"
-                         {
-		(yyval.node) = gen_if((yyvsp[-1].node), (yyvsp[0].node), NULL);
-		ast_set_flags((yyvsp[0].node), AST_FLAG_UNHYGIENIC);
-	}
-#line 3467 "src/gen_parser.c"
-    break;
-
-  case 135: /* const_if: "if" expr body "else" body  */
-#line 401 "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 3477 "src/gen_parser.c"
-    break;
-
-  case 136: /* const_if: "if" expr body "else" const_if  */
-#line 406 "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 3486 "src/gen_parser.c"
-    break;
-
-  case 137: /* const: "const" const_if  */
-#line 414 "src/parser.y"
-                        { (yyval.node) = (yyvsp[0].node); ast_set_flags((yyval.node), AST_FLAG_CONST);
-      }
-#line 3493 "src/gen_parser.c"
-    break;
-
-  case 138: /* const: "const" const_for  */
-#line 416 "src/parser.y"
-                            { (yyval.node) = (yyvsp[0].node); ast_set_flags((yyval.node), AST_FLAG_CONST);
-	 }
-#line 3500 "src/gen_parser.c"
-    break;
-
-  case 139: /* func_sign: "(" decl_list "=>" type ")"  */
-#line 420 "src/parser.y"
-                                       {
-		(yyval.node) = gen_type(AST_TYPE_SIGN, NULL, (yyvsp[-3].node), (yyvsp[-1].node));
-	}
-#line 3508 "src/gen_parser.c"
-    break;
-
-  case 140: /* func_sign: "(" decl_list ")"  */
-#line 423 "src/parser.y"
-                            { (yyval.node) = gen_type(AST_TYPE_SIGN, NULL, (yyvsp[-1].node), NULL);
-	 }
-#line 3515 "src/gen_parser.c"
-    break;
-
-  case 141: /* func_sign: "(" decl_list "=>" ")"  */
-#line 425 "src/parser.y"
-                                 { (yyval.node) = gen_type(AST_TYPE_SIGN, NULL, (yyvsp[-2].node), NULL);
-	 }
-#line 3522 "src/gen_parser.c"
-    break;
-
-  case 142: /* func_sign: "(" "=>" type ")"  */
-#line 427 "src/parser.y"
-                            { (yyval.node) = gen_type(AST_TYPE_SIGN, NULL, NULL, (yyvsp[-1].node));
-	 }
-#line 3529 "src/gen_parser.c"
-    break;
-
-  case 143: /* func_sign: "(" ")"  */
-#line 429 "src/parser.y"
-                  { (yyval.node) = gen_type(AST_TYPE_SIGN, NULL, NULL, NULL);
-	 }
-#line 3536 "src/gen_parser.c"
-    break;
-
-  case 144: /* variadic_sign: func_sign  */
-#line 433 "src/parser.y"
-                         { (yyval.node) = (yyvsp[0].node); }
-#line 3542 "src/gen_parser.c"
-    break;
-
-  case 145: /* variadic_sign: "(" decl_list "..." id "=>" type ")"  */
-#line 434 "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 3552 "src/gen_parser.c"
-    break;
-
-  case 146: /* type: id  */
-#line 441 "src/parser.y"
-         { (yyval.node) = gen_type(AST_TYPE_ID, (yyvsp[0].node), NULL, NULL); }
-#line 3558 "src/gen_parser.c"
-    break;
-
-  case 147: /* type: "'" func_sign  */
-#line 442 "src/parser.y"
-                        {
-		(yyval.node) = gen_type(AST_TYPE_POINTER, NULL, NULL, NULL);
-		(yyval.node)->next = (yyvsp[0].node);
-	}
-#line 3567 "src/gen_parser.c"
-    break;
-
-  case 148: /* type: id "(" type_list ")"  */
-#line 446 "src/parser.y"
-                               {
-		(yyval.node) = gen_type(AST_TYPE_STRUCT, (yyvsp[-3].node), (yyvsp[-1].node), NULL);
-	}
-#line 3575 "src/gen_parser.c"
-    break;
-
-  case 149: /* type: "'" type  */
-#line 449 "src/parser.y"
-                   {
-		(yyval.node) = gen_type(AST_TYPE_POINTER, NULL, NULL, NULL);
-		(yyval.node)->_type.next = (yyvsp[0].node);
-	}
-#line 3584 "src/gen_parser.c"
-    break;
-
-  case 150: /* type: "[" "]" type  */
-#line 453 "src/parser.y"
-                       {
-		(yyval.node) = gen_type(AST_TYPE_ARR, NULL, NULL, NULL);
-		(yyval.node)->_type.next = (yyvsp[0].node);
-	}
-#line 3593 "src/gen_parser.c"
-    break;
-
-  case 151: /* type: "[" expr "]" type  */
-#line 457 "src/parser.y"
-                            {
-		(yyval.node) = gen_type(AST_TYPE_ARR, NULL, (yyvsp[-2].node), NULL);
-		(yyval.node)->_type.next = (yyvsp[0].node);
-	}
-#line 3602 "src/gen_parser.c"
-    break;
-
-  case 152: /* type: "typeof" expr  */
-#line 461 "src/parser.y"
-                        {
-		(yyval.node) = gen_type(AST_TYPE_TYPEOF, NULL, (yyvsp[0].node), NULL);
-	}
-#line 3610 "src/gen_parser.c"
-    break;
-
-  case 153: /* var_decl: id "mut" type  */
-#line 466 "src/parser.y"
-                        {
-		(yyval.node) = gen_var((yyvsp[-2].node), (yyvsp[0].node), NULL);
-		ast_set_flags((yyval.node), AST_FLAG_MUTABLE);
-	}
-#line 3619 "src/gen_parser.c"
-    break;
-
-  case 154: /* var_decl: id "const" type  */
-#line 470 "src/parser.y"
-                          { (yyval.node) = gen_var((yyvsp[-2].node), (yyvsp[0].node), NULL);  }
-#line 3625 "src/gen_parser.c"
-    break;
-
-  case 155: /* var_decl: id type  */
-#line 471 "src/parser.y"
-                  { (yyval.node) = gen_var((yyvsp[-1].node), (yyvsp[0].node), NULL);  }
-#line 3631 "src/gen_parser.c"
-    break;
-
-  case 156: /* var_init: var_decl "=" init_expr  */
-#line 474 "src/parser.y"
-                                 { (yyval.node) = (yyvsp[-2].node); (yyvsp[-2].node)->_var.init = (yyvsp[0].node); }
-#line 3637 "src/gen_parser.c"
-    break;
-
-  case 157: /* var_init: id "mut" "=" init_expr  */
-#line 475 "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 3646 "src/gen_parser.c"
-    break;
-
-  case 158: /* var_init: id "const" "=" init_expr  */
-#line 479 "src/parser.y"
-                                   {
-		(yyval.node) = gen_var((yyvsp[-3].node), NULL, (yyvsp[0].node));
-		ast_set_flags((yyval.node), AST_FLAG_UNTYPED);
-	}
-#line 3655 "src/gen_parser.c"
-    break;
-
-  case 159: /* proc: id variadic_sign body  */
-#line 485 "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 3664 "src/gen_parser.c"
-    break;
-
-  case 160: /* proc: "extern" id func_sign  */
-#line 489 "src/parser.y"
-                                {
-		(yyval.node) = gen_proc((yyvsp[-1].node), (yyvsp[0].node), NULL);
-		ast_set_flags((yyval.node), AST_FLAG_EXTERN);
-	}
-#line 3673 "src/gen_parser.c"
-    break;
-
-  case 161: /* lambda: "[" macro_list "]" func_sign body  */
-#line 495 "src/parser.y"
-                                          { (yyval.node) = gen_lambda((yyvsp[-3].node), (yyvsp[-1].node), (yyvsp[0].node)); }
-#line 3679 "src/gen_parser.c"
-    break;
-
-  case 162: /* struct_elem: var_decl  */
-#line 498 "src/parser.y"
-                      { (yyval.node) = (yyvsp[0].node); }
-#line 3685 "src/gen_parser.c"
-    break;
-
-  case 163: /* struct_list: struct_elem ";" struct_list  */
-#line 501 "src/parser.y"
-                                         { (yyval.node) = (yyvsp[-2].node); (yyvsp[-2].node)->next = (yyvsp[0].node); }
-#line 3691 "src/gen_parser.c"
-    break;
-
-  case 164: /* struct_list: struct_elem ";"  */
-#line 502 "src/parser.y"
-                          { (yyval.node) = (yyvsp[-1].node); }
-#line 3697 "src/gen_parser.c"
-    break;
-
-  case 165: /* union: "union" id "{" struct_list "}"  */
-#line 505 "src/parser.y"
-                                      {
-		(yyval.node) = gen_union((yyvsp[-3].node), NULL, (yyvsp[-1].node));
-	}
-#line 3705 "src/gen_parser.c"
-    break;
-
-  case 166: /* union: "union" id "(" generic_list ")" "{" struct_list "}"  */
-#line 508 "src/parser.y"
-                                                              {
-		(yyval.node) = gen_union((yyvsp[-6].node), (yyvsp[-4].node), (yyvsp[-1].node));
-	}
-#line 3713 "src/gen_parser.c"
-    break;
-
-  case 167: /* generic: id type  */
-#line 513 "src/parser.y"
-                 { (yyval.node) = gen_alias((yyvsp[-1].node), (yyvsp[0].node)); }
-#line 3719 "src/gen_parser.c"
-    break;
-
-  case 168: /* generic_list: generic "," generic_list  */
-#line 514 "src/parser.y"
-                                       { (yyval.node) = (yyvsp[-2].node); (yyval.node)->next = (yyvsp[0].node); }
-#line 3725 "src/gen_parser.c"
-    break;
-
-  case 169: /* generic_list: generic  */
-#line 515 "src/parser.y"
-                  { (yyval.node) = (yyvsp[0].node); }
-#line 3731 "src/gen_parser.c"
-    break;
-
-  case 170: /* struct: "struct" id "{" struct_list "}"  */
-#line 518 "src/parser.y"
-                                        {
-		(yyval.node) = gen_struct((yyvsp[-3].node), NULL, (yyvsp[-1].node));
-	}
-#line 3739 "src/gen_parser.c"
-    break;
-
-  case 171: /* struct: "struct" id "(" generic_list ")" "{" struct_list "}"  */
-#line 521 "src/parser.y"
-                                                               {
-		(yyval.node) = gen_struct((yyvsp[-6].node), (yyvsp[-4].node), (yyvsp[-1].node));
-	}
-#line 3747 "src/gen_parser.c"
-    break;
-
-  case 172: /* template_elem: id ";"  */
-#line 528 "src/parser.y"
-                      { (yyval.node) = (yyvsp[-1].node); }
-#line 3753 "src/gen_parser.c"
-    break;
-
-  case 173: /* template_elem: id func_sign ";"  */
-#line 529 "src/parser.y"
-                           { (yyval.node) = gen_proc((yyvsp[-2].node), (yyvsp[-1].node), NULL);  }
-#line 3759 "src/gen_parser.c"
-    break;
-
-  case 174: /* template_elem: var_decl ";"  */
-#line 530 "src/parser.y"
-                       { (yyval.node) = (yyvsp[-1].node); }
-#line 3765 "src/gen_parser.c"
-    break;
-
-  case 175: /* template_elem: union  */
-#line 531 "src/parser.y"
-                { (yyval.node) = (yyvsp[0].node); }
-#line 3771 "src/gen_parser.c"
-    break;
-
-  case 176: /* template_list: template_elem template_list  */
-#line 534 "src/parser.y"
-                                           { (yyval.node) = (yyvsp[-1].node); (yyvsp[-1].node)->next = (yyvsp[0].node); }
-#line 3777 "src/gen_parser.c"
-    break;
-
-  case 177: /* template_list: template_elem  */
-#line 535 "src/parser.y"
-                         { (yyval.node) = (yyvsp[0].node); }
-#line 3783 "src/gen_parser.c"
-    break;
-
-  case 178: /* type_list: type "," type_list  */
-#line 538 "src/parser.y"
-                              { (yyval.node) = (yyvsp[-2].node); (yyvsp[-2].node)->next = (yyvsp[0].node); }
-#line 3789 "src/gen_parser.c"
-    break;
-
-  case 179: /* type_list: type  */
-#line 539 "src/parser.y"
-               { (yyval.node) = (yyvsp[0].node); }
-#line 3795 "src/gen_parser.c"
-    break;
-
-  case 180: /* type_alias: "type" id type  */
-#line 542 "src/parser.y"
-                           { (yyval.node) = gen_alias((yyvsp[-1].node), (yyvsp[0].node));  }
-#line 3801 "src/gen_parser.c"
-    break;
-
-  case 181: /* type_template: "type" id "{" template_list "}"  */
-#line 547 "src/parser.y"
-                                               {
-		(yyval.node) = gen_template((yyvsp[-3].node), (yyvsp[-1].node));
-	}
-#line 3809 "src/gen_parser.c"
-    break;
-
-  case 182: /* type_template: "type" id "{" "}"  */
-#line 550 "src/parser.y"
-                            {
-		/* should match anything, but doesn't implement anything */
-		(yyval.node) = gen_template((yyvsp[-2].node), NULL);
-	}
-#line 3818 "src/gen_parser.c"
-    break;
-
-  case 183: /* enum_val: id  */
-#line 556 "src/parser.y"
-             { (yyval.node) = gen_val((yyvsp[0].node), gen_int(0));  }
-#line 3824 "src/gen_parser.c"
-    break;
-
-  case 184: /* enum_val: id "=" expr  */
-#line 557 "src/parser.y"
-                      { (yyval.node) = gen_val((yyvsp[-2].node), (yyvsp[0].node));  }
-#line 3830 "src/gen_parser.c"
-    break;
-
-  case 185: /* enum_list: enum_val "," enum_list  */
-#line 560 "src/parser.y"
-                                  { (yyval.node) = (yyvsp[-2].node); (yyvsp[-2].node)->next = (yyvsp[0].node); }
-#line 3836 "src/gen_parser.c"
-    break;
-
-  case 186: /* enum_list: enum_val ","  */
-#line 561 "src/parser.y"
-                       { (yyval.node) = (yyvsp[-1].node); }
-#line 3842 "src/gen_parser.c"
-    break;
-
-  case 187: /* enum_list: enum_val  */
-#line 562 "src/parser.y"
-                   { (yyval.node) = (yyvsp[0].node); }
-#line 3848 "src/gen_parser.c"
-    break;
-
-  case 188: /* enum: "enum" id ":" type "{" enum_list "}"  */
-#line 565 "src/parser.y"
-                                           { (yyval.node) = gen_enum((yyvsp[-5].node), (yyvsp[-3].node), (yyvsp[-1].node)); }
-#line 3854 "src/gen_parser.c"
-    break;
-
-  case 189: /* enum: "enum" id "{" enum_list "}"  */
-#line 566 "src/parser.y"
-                                      {
-		(yyval.node) = gen_enum((yyvsp[-3].node), NULL, (yyvsp[-1].node));
-		ast_set_flags((yyval.node), AST_FLAG_UNTYPED);
-	}
-#line 3863 "src/gen_parser.c"
-    break;
-
-  case 190: /* top_if: "if" expr "{" unit "}"  */
-#line 572 "src/parser.y"
-                               {
-		(yyval.node) = gen_if((yyvsp[-3].node), (yyvsp[-1].node), NULL);
-		ast_set_flags((yyval.node), AST_FLAG_UNHYGIENIC);
-	}
-#line 3872 "src/gen_parser.c"
-    break;
-
-  case 191: /* top_if: "if" expr "{" unit "}" "else" "{" unit "}"  */
-#line 576 "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 3881 "src/gen_parser.c"
-    break;
-
-  case 192: /* top_if: "if" expr "{" unit "}" "else" top_if  */
-#line 580 "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 3890 "src/gen_parser.c"
-    break;
-
-  case 193: /* top: ";"  */
-#line 588 "src/parser.y"
-         { (yyval.node) = gen_empty(); }
-#line 3896 "src/gen_parser.c"
-    break;
-
-  case 194: /* top: enum  */
-#line 589 "src/parser.y"
-               { (yyval.node) = (yyvsp[0].node); }
-#line 3902 "src/gen_parser.c"
-    break;
-
-  case 195: /* top: proc  */
-#line 590 "src/parser.y"
-               { (yyval.node) = (yyvsp[0].node); }
-#line 3908 "src/gen_parser.c"
-    break;
-
-  case 196: /* top: struct  */
-#line 591 "src/parser.y"
-                 { (yyval.node) = (yyvsp[0].node); }
-#line 3914 "src/gen_parser.c"
-    break;
-
-  case 197: /* top: macro  */
-#line 592 "src/parser.y"
-                { (yyval.node) = (yyvsp[0].node); }
-#line 3920 "src/gen_parser.c"
-    break;
-
-  case 198: /* top: "const" top_if  */
-#line 593 "src/parser.y"
-                         { (yyval.node) = (yyvsp[0].node); ast_set_flags((yyval.node), AST_FLAG_CONST); }
-#line 3926 "src/gen_parser.c"
-    break;
-
-  case 199: /* top: import ";"  */
-#line 594 "src/parser.y"
-                     { (yyval.node) = (yyvsp[-1].node); }
-#line 3932 "src/gen_parser.c"
-    break;
-
-  case 200: /* top: type_alias ";"  */
-#line 595 "src/parser.y"
-                         { (yyval.node) = (yyvsp[-1].node); }
-#line 3938 "src/gen_parser.c"
-    break;
-
-  case 201: /* top: type_template  */
-#line 596 "src/parser.y"
-                        { (yyval.node) = (yyvsp[0].node); }
-#line 3944 "src/gen_parser.c"
-    break;
-
-  case 202: /* top: "pub" enum  */
-#line 597 "src/parser.y"
-                     { (yyval.node) = (yyvsp[0].node); ast_set_flags((yyvsp[0].node), AST_FLAG_PUBLIC); }
-#line 3950 "src/gen_parser.c"
-    break;
-
-  case 203: /* top: "pub" struct  */
-#line 598 "src/parser.y"
-                       { (yyval.node) = (yyvsp[0].node); ast_set_flags((yyvsp[0].node), AST_FLAG_PUBLIC); }
-#line 3956 "src/gen_parser.c"
-    break;
-
-  case 204: /* top: "pub" proc  */
-#line 599 "src/parser.y"
-                     { (yyval.node) = (yyvsp[0].node); ast_set_flags((yyvsp[0].node), AST_FLAG_PUBLIC); }
-#line 3962 "src/gen_parser.c"
-    break;
-
-  case 205: /* top: "pub" macro  */
-#line 600 "src/parser.y"
-                      { (yyval.node) = (yyvsp[0].node); ast_set_flags((yyvsp[0].node), AST_FLAG_PUBLIC); }
-#line 3968 "src/gen_parser.c"
-    break;
-
-  case 206: /* top: "pub" import ";"  */
-#line 601 "src/parser.y"
-                           { (yyval.node) = (yyvsp[-1].node); ast_set_flags((yyvsp[-1].node), AST_FLAG_PUBLIC); }
-#line 3974 "src/gen_parser.c"
-    break;
-
-  case 207: /* top: "pub" type_alias ";"  */
-#line 602 "src/parser.y"
-                               { (yyval.node) = (yyvsp[-1].node); ast_set_flags((yyvsp[-1].node), AST_FLAG_PUBLIC); }
-#line 3980 "src/gen_parser.c"
-    break;
-
-  case 208: /* top: "pub" type_template  */
-#line 603 "src/parser.y"
-                              { (yyval.node) = (yyvsp[0].node); ast_set_flags((yyvsp[0].node), AST_FLAG_PUBLIC); }
-#line 3986 "src/gen_parser.c"
-    break;
-
-  case 209: /* top: var ";"  */
-#line 604 "src/parser.y"
-                  { (yyval.node) = (yyvsp[-1].node); }
-#line 3992 "src/gen_parser.c"
-    break;
-
-  case 210: /* top: "pub" var ";"  */
-#line 605 "src/parser.y"
-                        { (yyval.node) = (yyvsp[-1].node); ast_set_flags((yyvsp[-1].node), AST_FLAG_PUBLIC); }
-#line 3998 "src/gen_parser.c"
-    break;
-
-  case 211: /* top: error  */
-#line 606 "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 4016 "src/gen_parser.c"
-    break;
-
-  case 212: /* unit: top  */
-#line 621 "src/parser.y"
-          { (yyval.node) = (yyvsp[0].node); }
-#line 4022 "src/gen_parser.c"
-    break;
-
-  case 213: /* unit: top unit  */
-#line 622 "src/parser.y"
-                   { (yyval.node) = (yyvsp[-1].node); (yyvsp[-1].node)->next = (yyvsp[0].node); }
-#line 4028 "src/gen_parser.c"
-    break;
-
-  case 214: /* input: unit  */
-#line 625 "src/parser.y"
-            { parser->tree = (yyvsp[0].node); }
-#line 4034 "src/gen_parser.c"
-    break;
-
-
-#line 4038 "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 628 "src/parser.y"
-
diff --git a/src/gen_parser.h b/src/gen_parser.h
deleted file mode 100644
index 85d4b3f..0000000
--- a/src/gen_parser.h
+++ /dev/null
@@ -1,178 +0,0 @@
-/* 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 b7dc8c1..9d88056 100644
--- a/src/imports.c
+++ b/src/imports.c
@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later */
+
 #include <cu/imports.h>
 #include <cu/debug.h>
 
diff --git a/src/main.c b/src/main.c
index c63c042..b4643bb 100644
--- a/src/main.c
+++ b/src/main.c
@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later */
+
 #include <stdlib.h>
 #include <stdio.h>
 #include <unistd.h>
@@ -7,13 +9,13 @@
 #include <cu/compiler.h>
 
 static const char *cmdline_usage =
-"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"
-"	-o       Name of output\n"
-"	infile   Top file(s) to compile\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"
+	"	-o       Name of output\n"
+	"	infile   Top file(s) to compile\n"
 ;
 
 static void usage()
diff --git a/src/parser_helper.c b/src/parser_helper.c
index 2501f47..c382fca 100644
--- a/src/parser_helper.c
+++ b/src/parser_helper.c
@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later */
+
 #include <stdarg.h>
 
 #include <cu/parser.h>
@@ -31,7 +33,7 @@ void parse(struct parser *p, const char *fname, const char *buf)
 
 /* 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)
+                             struct parser *parser)
 {
 	size_t depth = 0;
 	while (1) {
@@ -68,7 +70,8 @@ struct src_loc to_src_loc(YYLTYPE *yylloc)
 	return loc;
 }
 
-void yyerror(YYLTYPE *yylloc, void *lexer, struct parser *parser, const char *msg)
+void yyerror(YYLTYPE *yylloc, void *lexer, struct parser *parser,
+             const char *msg)
 {
 	(void)lexer;
 
diff --git a/src/path.c b/src/path.c
index 1de8740..a90001d 100644
--- a/src/path.c
+++ b/src/path.c
@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later */
+
 #include <stddef.h>
 #include <string.h>
 #include <unistd.h>
diff --git a/src/scope.c b/src/scope.c
index 7346b40..f422b9f 100644
--- a/src/scope.c
+++ b/src/scope.c
@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later */
+
 #include <stddef.h>
 #include <string.h>
 #include <stdio.h>
@@ -119,7 +121,8 @@ int scope_flags(struct scope *scope, enum scope_flags flags)
 	return scope->flags & flags;
 }
 
-static struct visible *create_visible(struct scope *owner, struct ast_node *node)
+static struct visible *create_visible(struct scope *owner,
+                                      struct ast_node *node)
 {
 	struct visible *visible = calloc(1, sizeof(struct visible));
 	visible->node = node;
@@ -135,15 +138,15 @@ static struct scratch *create_scratch(struct ast_node *scratch)
 }
 
 /* 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;\
-}
+#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);
@@ -156,19 +159,19 @@ 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;\
-}
+#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);
@@ -183,19 +186,23 @@ 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;\
-}
+#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);
@@ -238,22 +245,26 @@ struct ast_node *scope_find(struct scope *scope, struct ast_node *id)
 
 /* 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;\
-}
+#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)
 {
@@ -264,8 +275,8 @@ struct visible *create_type(struct scope *scope, struct ast_node *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;
+		semantic_error(scope->fctx, type, "unknown type");
+		return NULL;
 	}
 }
 
@@ -278,8 +289,8 @@ int reference_type(int public, struct scope *scope, struct visible *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;
+		semantic_error(scope->fctx, visible->node, "unknown type");
+		return 1;
 	}
 }
 
@@ -338,7 +349,9 @@ 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);
+	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");
@@ -351,7 +364,8 @@ static int add_implementation(struct ast_node *template, struct ast_node *type)
 	return 0;
 }
 
-static void remove_implementation(struct ast_node *template, struct ast_node *type)
+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;
@@ -386,7 +400,7 @@ static int find_implementation(struct ast_node *template, struct ast_node *type)
 }
 
 static struct ast_node *match_macro(int global, struct scope *scope,
-		struct ast_node *id, struct ast_node *args)
+                                    struct ast_node *id, struct ast_node *args)
 {
 	const size_t arg_count = ast_list_len(args);
 	struct visible *prev = scope->macros, *cur;
@@ -398,7 +412,8 @@ static struct ast_node *match_macro(int global, struct scope *scope,
 			if (!identical_ast_nodes(0, macro->_macro.id, id))
 				continue;
 
-			const size_t param_count = ast_list_len(macro->_macro.params);
+			const size_t param_count = ast_list_len(
+				macro->_macro.params);
 
 			/* if macros have the same number of arguments, they
 			 * match */
@@ -408,7 +423,7 @@ static struct ast_node *match_macro(int global, struct scope *scope,
 			/* 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)
+			    && param_count < arg_count)
 				return macro;
 
 		} while ((prev = cur));
@@ -420,10 +435,10 @@ static struct ast_node *match_macro(int global, struct scope *scope,
 }
 
 static struct ast_node *match_proc(int global, struct scope *scope,
-		struct ast_node *id, struct ast_node *args);
+                                   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)
+                           struct ast_node *param_type, struct ast_node *proc)
 {
 	assert(proc->node_type == AST_PROC);
 	/* temp */
@@ -451,8 +466,9 @@ static int implements_proc(struct scope *scope, struct ast_node *arg_type,
 		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);
+		semantic_info(scope->fctx, impl,
+		              "found return type %s, expected %s",
+		              irt, prt);
 		free(irt);
 		free(prt);
 		impl = NULL;
@@ -464,7 +480,7 @@ out:
 }
 
 static int implements_var(struct scope *scope, struct ast_node *arg_type,
-		struct ast_node *param_type, struct ast_node *var)
+                          struct ast_node *param_type, struct ast_node *var)
 {
 	assert(var->node_type == AST_VAR);
 	/* temp */
@@ -472,7 +488,7 @@ static int implements_var(struct scope *scope, struct ast_node *arg_type,
 }
 
 static int implements_template(struct scope *scope, struct ast_node *arg_type,
-		struct ast_node *param_type)
+                               struct ast_node *param_type)
 {
 	assert(param_type->_type.kind == AST_TYPE_TEMPLATE);
 	struct ast_node *template = param_type->_type.template.template;
@@ -495,34 +511,36 @@ static int implements_template(struct scope *scope, struct ast_node *arg_type,
 	if (elem)
 		do {
 			if (elem->node_type == AST_VAR) {
-				if (implements_var(scope, arg_type, param_type, elem))
+				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);
+				               "%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))
+				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);
+				               "%s does not implement %s",
+				               type, id->_id.id);
 				free(type);
 				goto not_implemented;
 			}
 
 			else {
 				semantic_error(scope->fctx, elem,
-						"illegal template element");
+				               "illegal template element");
 				goto not_implemented;
 			}
 		} while ((elem = elem->next));
@@ -535,7 +553,7 @@ not_implemented:
 }
 
 int implements(struct scope *scope,
-		struct ast_node *arg_type, struct ast_node *param_type)
+               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
@@ -572,9 +590,9 @@ int implements(struct scope *scope,
 		/* 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;
-		*/
+		   if (!is_templateable(arg_type))
+		        return 0;
+		 */
 
 		return implements_template(scope, arg_type, param_type);
 	}
@@ -584,7 +602,8 @@ int implements(struct scope *scope,
 
 	/* 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);
+		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)
@@ -595,7 +614,8 @@ int implements(struct scope *scope,
 }
 
 static int match_args(struct scope *scope, int variadic,
-		const struct ast_node *args, const struct ast_node *params)
+                      const struct ast_node *args,
+                      const struct ast_node *params)
 {
 	/* no arguments matches to no parameters */
 	if (!params && !args)
@@ -630,7 +650,7 @@ static int match_args(struct scope *scope, int variadic,
 }
 
 static struct ast_node *iter_procs(struct scope *scope, struct visible *first,
-		struct ast_node *id, struct ast_node *args)
+                                   struct ast_node *id, struct ast_node *args)
 {
 	struct visible *prev = first, *cur;
 	if (prev)
@@ -653,9 +673,10 @@ static struct ast_node *iter_procs(struct scope *scope, struct visible *first,
 }
 
 static struct ast_node *match_proc(int global, struct scope *scope,
-		struct ast_node *id, struct ast_node *args)
+                                   struct ast_node *id, struct ast_node *args)
 {
-	struct ast_node *override = iter_procs(scope, scope->overrides, id, args);
+	struct ast_node *override =
+		iter_procs(scope, scope->overrides, id, args);
 	if (override)
 		return override;
 
@@ -731,7 +752,8 @@ int scope_add_existing_var(struct scope *scope, struct visible *visible)
 	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");
+		semantic_info(scope->fctx, shadow,
+		              "previous declaration was here\n");
 		return -1;
 	}
 
@@ -782,7 +804,8 @@ int scope_add_existing_proc(struct scope *scope, struct visible *visible)
 	}
 
 	int public = scope_flags(scope, SCOPE_PUBLIC);
-	if (scope_flags(scope, SCOPE_FILE) && ast_flags(proc, AST_FLAG_PUBLIC)) {
+	if (scope_flags(scope,
+	                SCOPE_FILE) && ast_flags(proc, AST_FLAG_PUBLIC)) {
 		if (template)
 			return reference_proc(public, scope->parent, visible);
 
@@ -792,19 +815,20 @@ int scope_add_existing_proc(struct scope *scope, struct visible *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;\
-}
+#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)
+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);
@@ -861,8 +885,9 @@ struct ast_node *scope_resolve_macro(struct scope *scope, struct ast_node *call)
 	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)
+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;
@@ -911,9 +936,10 @@ struct ast_node *scope_resolve_proc(struct scope *scope, struct ast_node *call)
 		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);
+			semantic_error(scope->fctx, arg,
+			               "%s not associated with %s",
+			               cstr,
+			               tstr);
 			free(cstr);
 			free(tstr);
 			return NULL;
@@ -930,7 +956,8 @@ next:
 	return proc;
 }
 
-struct ast_node *scope_resolve_actual(struct scope *scope, struct ast_node *call)
+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;
@@ -942,7 +969,8 @@ struct ast_node *scope_resolve_actual(struct scope *scope, struct ast_node *call
 			if (!actual)
 				continue;
 
-			if (!identical_ast_nodes(0, actual->_proc.id, call->_call.id))
+			if (!identical_ast_nodes(0, actual->_proc.id,
+			                         call->_call.id))
 				continue;
 
 			assert(!ast_flags(actual, AST_FLAG_VARIADIC));
@@ -1002,7 +1030,8 @@ struct ast_node *scope_resolve_call(struct scope *scope, struct ast_node *call)
 	return NULL;
 }
 
-struct ast_node *file_scope_resolve_call(struct scope *scope, struct ast_node *call)
+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)
@@ -1020,35 +1049,36 @@ struct ast_node *scope_resolve_type(struct scope *scope, struct ast_node *type)
 	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;
+		assert(type->_type.kind == AST_TYPE_ID);
+		id = type->_type.id;
+		break;
 
 	case AST_ALIAS:
-		     id = type->_alias.id;
-		     break;
+		id = type->_alias.id;
+		break;
 
 	case AST_TEMPLATE:
-		     id = type->_template.id;
-		     break;
+		id = type->_template.id;
+		break;
 
 	case AST_STRUCT:
-		     id = type->_struct.id;
-		     break;
+		id = type->_struct.id;
+		break;
 
 	case AST_ENUM:
-		     id = type->_enum.id;
-		     break;
+		id = type->_enum.id;
+		break;
 
 	default:
-		     semantic_error(scope->fctx, type, "unknown type");
-		     return NULL;
+		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 *file_scope_resolve_type(struct scope *scope,
+                                         struct ast_node *type)
 {
 	struct ast_node *found = scope_resolve_type(scope, type);
 	if (found)
@@ -1062,13 +1092,14 @@ struct ast_node *file_scope_resolve_type(struct scope *scope, struct ast_node *t
 
 /* 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"};
+	                              "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) {
+	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)
@@ -1090,7 +1121,8 @@ void scope_destroy_defaults(struct scope *scope)
 	struct ast_node type = {0};
 	type.node_type = AST_ID;
 
-	for (size_t i = 0; i < sizeof(default_types) / sizeof(default_types[0]); ++i) {
+	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 */
@@ -1134,7 +1166,8 @@ 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)
+static struct ast_node *find_actual(struct actual *actuals,
+                                    struct ast_node *node)
 {
 	/* TODO */
 	internal_error("finding actuals not yet implemented");
diff --git a/src/source.mk b/src/source.mk
index 3e01ba6..5b3d2ae 100644
--- a/src/source.mk
+++ b/src/source.mk
@@ -1,10 +1,10 @@
 SRC_LOCAL != echo src/*.c
 SOURCES += $(SRC_LOCAL)
 
-src/gen_parser.c: src/parser.y
+gen/gen_parser.c: src/parser.y
 	bison -Wcounterexamples -H -o $@ $<
 
-src/gen_lexer.c: src/lexer.l
+gen/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
+include/cu/parser.h: gen/gen_lexer.c gen/gen_parser.c
diff --git a/src/string.c b/src/string.c
index d51f1cf..9dcbe05 100644
--- a/src/string.c
+++ b/src/string.c
@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later */
+
 #include <errno.h>
 #include <stdlib.h>