diff options
| -rw-r--r-- | src/ast.c | 1312 | ||||
| -rw-r--r-- | src/gen_parser.c | 2206 | ||||
| -rw-r--r-- | src/parser.y | 3 |
3 files changed, 1830 insertions, 1691 deletions
@@ -460,11 +460,6 @@ struct ast_node *gen_type(enum ast_type_kind kind, struct ast_node *id, n->_type.lambda.ret = ret; n->loc = loc_span(expr, ret); break; - - case AST_TYPE_IMPL: - n->_type.impl.id = id; - n->loc = id->loc; - break; } return n; @@ -519,10 +514,6 @@ void destroy_type(struct ast_node *type) DESTROY_LIST(type->_type.sign.params); destroy_ast_node(type->_type.sign.ret); break; - - case AST_TYPE_IMPL: - destroy_ast_node(type->_type.impl.id); - break; } destroy_ast_node(type->_type.next); @@ -827,24 +818,6 @@ void destroy_import(struct ast_node *import) free(import); } -struct ast_node *gen_paste(struct ast_node *id1, struct ast_node *id2) -{ - ALLOC_NODE(n, paste); - n->node_type = AST_PASTE; - n->_paste.id1 = id1; - n->_paste.id2 = id2; - n->loc = loc_span(id1, id2); - return n; -} - -void destroy_paste(struct ast_node *paste) -{ - assert(paste->node_type == AST_PASTE); - destroy_ast_node(paste->_paste.id1); - destroy_ast_node(paste->_paste.id2); - free(paste); -} - struct ast_node *gen_embed(const char *file) { ALLOC_NODE(n, embed); @@ -928,7 +901,6 @@ void destroy_ast_node(struct ast_node *node) case AST_SWITCH: destroy_switch(node); break; case AST_CASE: destroy_case(node); break; case AST_CONST: destroy_const(node); break; - case AST_PASTE: destroy_paste(node); break; case AST_ALIAS: destroy_alias(node); break; case AST_TEMPLATE: destroy_template(node); break; case AST_ID: destroy_id(node); break; @@ -1321,10 +1293,6 @@ static void __dump_ast(int depth, struct ast_node *node) dump_ast(depth + 1, node->_type.sign.params); dump_ast(depth + 1, node->_type.sign.ret); break; - - case AST_TYPE_IMPL: printf(" IMPLS\n"); - dump_ast(depth + 1, node->_type.impl.id); - dump_ast(depth + 1, node->_type.impl.types); } dump_ast(depth + 1, node->_type.next); @@ -1356,17 +1324,6 @@ static void __dump_ast(int depth, struct ast_node *node) printf("}\n"); break; - case AST_PASTE: - dump(depth, "{PASTE:"); - dump_flags(node); - putchar('\n'); - - dump_ast(depth + 1, node->_paste.id1); - dump_ast(depth + 1, node->_paste.id2); - - dump(depth, "}\n"); - break; - case AST_FOR: dump(depth, "{FOR:"); dump_flags(node); @@ -1601,8 +1558,8 @@ struct ast_node *clone_ast_node(struct ast_node *node) 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; @@ -1699,11 +1656,6 @@ struct ast_node *clone_ast_node(struct ast_node *node) clone_ast_node(node->_type.sign.ret)); break; - case AST_TYPE_IMPL: - new = gen_type(AST_TYPE_IMPL, - clone_ast_node(node->_type.impl.id), - clone_ast_node(node->_type.impl.types), - NULL); } new->_type.next = clone_ast_node(node->_type.next); break; @@ -1721,11 +1673,6 @@ struct ast_node *clone_ast_node(struct ast_node *node) new = gen_embed(strdup(node->_import.file)); break; - case AST_PASTE: - new = gen_paste(clone_ast_node(node->_paste.id1), - clone_ast_node(node->_paste.id2)); - break; - case AST_ENUM: new = gen_enum(clone_ast_node(node->_enum.id), clone_ast_node(node->_enum.type), @@ -1833,478 +1780,563 @@ static int identical_scope(void *left, void *right) return left == right; } -/* sort of unfortnate that we can't just do a direct memcmp... */ -int identical_ast_nodes(int exact, struct ast_node *left, struct ast_node *right) +static int identical_union(int exact, struct ast_node *a, struct ast_node *b) { - /* both being NULL counts as identical */ - if (!left && !right) - return 1; - - /* the same node must be the same */ - if (left == right) - return 1; + if (!identical_ast_nodes(exact, a->_union.id, b->_union.id)) + return 0; - /* either one being null means not identical */ - if (!left) + if (!identical_ast_nodes(exact, a->_union.generics, b->_union.generics)) return 0; - if (!right) + if (!identical_ast_nodes(exact, a->_union.body, b->_union.body)) return 0; - if (left->node_type != right->node_type) + return 1; +} + +static int identical_assign(int exact, struct ast_node *a, struct ast_node *b) +{ + if (!identical_ast_nodes(exact, a->_assign.to, a->_assign.to)) return 0; - if (exact && !identical_flags(left->flags, right->flags)) + if (!identical_ast_nodes(exact, b->_assign.from, b->_assign.from)) return 0; - if (exact && !identical_loc(left->loc, right->loc)) + return 1; +} + +static int identical_init(int exact, struct ast_node *a, struct ast_node *b) +{ + return identical_ast_nodes(exact, a->_init.body, b->_init.body); +} + +static int identical_sizeof(int exact, struct ast_node *a, struct ast_node *b) +{ + return identical_ast_nodes(exact, a->_sizeof.expr, b->_sizeof.expr); +} + +static int identical_dot(int exact, struct ast_node *a, struct ast_node *b) +{ + if (!identical_ast_nodes(exact, a->_dot.expr, b->_dot.expr)) return 0; - if (exact && !identical_scope(left->scope, right->scope)) + if (!identical_ast_nodes(exact, a->_dot.id, b->_dot.id)) return 0; - switch (left->node_type) { - case AST_UNION: - if (!identical_ast_nodes(exact, left->_union.id, right->_union.id)) - return 0; + return 1; +} - if (!identical_ast_nodes(exact, left->_union.generics, right->_union.generics)) - return 0; +static int identical_as(int exact, struct ast_node *a, struct ast_node *b) +{ + return identical_ast_nodes(exact, a->_as.type, b->_as.type); +} - if (!identical_ast_nodes(exact, left->_union.body, right->_union.body)) - return 0; +static int identical_goto(int exact, struct ast_node *a, struct ast_node *b) +{ + return identical_ast_nodes(exact, a->_goto.label, b->_goto.label); +} - break; +static int identical_label(int exact, struct ast_node *a, struct ast_node *b) +{ + return identical_ast_nodes(exact, a->_label.id, b->_label.id); +} - case AST_ASSIGN: - if (!identical_ast_nodes(exact, left->_assign.to, right->_assign.to)) - return 0; +static int identical_binop(int exact, struct ast_node *a, struct ast_node *b) +{ + if (a->_binop.op != b->_binop.op) + return 0; - if (!identical_ast_nodes(exact, left->_assign.from, right->_assign.from)) - return 0; - break; + if (!identical_ast_nodes(exact, a->_binop.left, b->_binop.left)) + return 0; - case AST_INIT: - if (!identical_ast_nodes(exact, left->_init.body, right->_init.body)) - return 0; - break; - case AST_SIZEOF: - if (!identical_ast_nodes(exact, left->_sizeof.expr, right->_sizeof.expr)) - return 0; - break; + if (!identical_ast_nodes(exact, a->_binop.right, b->_binop.right)) + return 0; - case AST_DOT: - if (!identical_ast_nodes(exact, left->_dot.expr, right->_dot.expr)) - return 0; + return 1; +} - if (!identical_ast_nodes(exact, left->_dot.id, right->_dot.id)) - return 0; - break; +static int identical_unop(int exact, struct ast_node *a, struct ast_node *b) +{ + if (a->_unop.op != b->_unop.op) + return 0; - case AST_AS: - if (!identical_ast_nodes(exact, left->_as.type, right->_as.type)) - return 0; - break; + if (!identical_ast_nodes(exact, a->_unop.expr, b->_unop.expr)) + return 0; - case AST_GOTO: - if (!identical_ast_nodes(exact, left->_goto.label, right->_goto.label)) - return 0; + return 1; +} - break; +static int identical_call(int exact, struct ast_node *a, struct ast_node *b) +{ + if (!identical_ast_nodes(exact, a->_call.id, b->_call.id)) + return 0; - case AST_LABEL: - if (!identical_ast_nodes(exact, left->_label.id, right->_label.id)) - return 0; + if (!identical_ast_nodes(exact, a->_call.args, b->_call.args)) + return 0; - break; + return 1; +} - case AST_BINOP: - if (left->_binop.op != right->_binop.op) - return 0; +static int identical_cast(int exact, struct ast_node *a, struct ast_node *b) +{ + if (!identical_ast_nodes(exact, a->_cast.expr, b->_cast.expr)) + return 0; - if (!identical_ast_nodes(exact, left->_binop.left, right->_binop.left)) - return 0; + if (!identical_ast_nodes(exact, a->_cast.type, b->_cast.type)) + return 0; - if (!identical_ast_nodes(exact, left->_binop.right, right->_binop.right)) - return 0; + return 1; +} - break; +static int identical_defer(int exact, struct ast_node *a, struct ast_node *b) +{ + return identical_ast_nodes(exact, a->_defer.expr, b->_defer.expr); +} - case AST_UNOP: - if (left->_unop.op != right->_unop.op) - return 0; +static int identical_macro(int exact, struct ast_node *a, struct ast_node *b) +{ + if (!identical_ast_nodes(exact, a->_macro.id, b->_macro.id)) + return 0; - if (!identical_ast_nodes(exact, left->_unop.expr, right->_unop.expr)) - return 0; + if (!identical_ast_nodes(exact, a->_macro.params, b->_macro.params)) + return 0; - break; + if (!identical_ast_nodes(exact, a->_macro.body, b->_macro.body)) + return 0; - case AST_CALL: - if (!identical_ast_nodes(exact, left->_call.id, right->_call.id)) - return 0; + return 1; +} - if (!identical_ast_nodes(exact, left->_call.args, right->_call.args)) - return 0; +static int identical_proc(int exact, struct ast_node *a, struct ast_node *b) +{ + if (!identical_ast_nodes(exact, a->_proc.id, b->_proc.id)) + return 0; - break; + if (!identical_ast_nodes(exact, a->_proc.sign, b->_proc.sign)) + return 0; - case AST_CAST: - if (!identical_ast_nodes(exact, left->_cast.expr, right->_cast.expr)) - return 0; + if (!identical_ast_nodes(exact, a->_proc.body, b->_proc.body)) + return 0; - if (!identical_ast_nodes(exact, left->_cast.type, right->_cast.type)) - return 0; + return 1; +} - break; +static int identical_var(int exact, struct ast_node *a, struct ast_node *b) +{ + if (!identical_ast_nodes(exact, a->_var.id, b->_var.id)) + return 0; - case AST_DEFER: - if (!identical_ast_nodes(exact, left->_defer.expr, right->_defer.expr)) - return 0; + if (!identical_ast_nodes(exact, a->_var.type, b->_var.type)) + return 0; - break; + if (!identical_ast_nodes(exact, a->_var.init, b->_var.init)) + return 0; - case AST_MACRO: - if (!identical_ast_nodes(exact, left->_macro.id, right->_macro.id)) - return 0; + return 1; +} - if (!identical_ast_nodes(exact, left->_macro.params, right->_macro.params)) - return 0; +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)) + return 0; - if (!identical_ast_nodes(exact, left->_macro.body, right->_macro.body)) - return 0; + if (!identical_ast_nodes(exact, a->_lambda.sign, b->_lambda.sign)) + return 0; - break; + if (!identical_ast_nodes(exact, a->_lambda.body, b->_lambda.body)) + return 0; - case AST_PROC: - if (!identical_ast_nodes(exact, left->_proc.id, right->_proc.id)) - return 0; + return 1; +} - if (!identical_ast_nodes(exact, left->_proc.sign, right->_proc.sign)) - return 0; +static int identical_for(int exact, struct ast_node *a, struct ast_node *b) +{ + if (!identical_ast_nodes(exact, a->_for.pre, b->_for.pre)) + return 0; - if (!identical_ast_nodes(exact, left->_proc.body, right->_proc.body)) - return 0; + if (!identical_ast_nodes(exact, a->_for.cond, b->_for.cond)) + return 0; - break; + if (!identical_ast_nodes(exact, a->_for.post, b->_for.post)) + return 0; - case AST_VAR: - if (!identical_ast_nodes(exact, left->_var.id, right->_var.id)) - return 0; + if (!identical_ast_nodes(exact, a->_for.body, b->_for.body)) + return 0; - if (!identical_ast_nodes(exact, left->_var.type, right->_var.type)) - return 0; + return 1; +} - if (!identical_ast_nodes(exact, left->_var.init, right->_var.init)) - return 0; +static int identical_while(int exact, struct ast_node *a, struct ast_node *b) +{ + if (!identical_ast_nodes(exact, a->_while.cond, b->_while.cond)) + return 0; - break; + if (!identical_ast_nodes(exact, a->_while.body, b->_while.body)) + return 0; - case AST_LAMBDA: - if (!identical_ast_nodes(exact, left->_lambda.captures, right->_lambda.captures)) - return 0; + return 1; +} - if (!identical_ast_nodes(exact, left->_lambda.sign, right->_lambda.sign)) - return 0; +static int identical_ctrl(int exact, struct ast_node *a, struct ast_node *b) +{ + (void)(exact); + return a->_ctrl.kind == b->_ctrl.kind; +} - if (!identical_ast_nodes(exact, left->_lambda.body, right->_lambda.body)) - return 0; +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); +} - break; +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)) + return 0; - case AST_FOR: - if (!identical_ast_nodes(exact, left->_for.pre, right->_for.pre)) - return 0; + if (!identical_ast_nodes(exact, a->_type.alias.actual, b->_type.alias.actual)) + return 0; + return 1; +} - if (!identical_ast_nodes(exact, left->_for.cond, right->_for.cond)) - return 0; +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)) + return 0; - if (!identical_ast_nodes(exact, left->_for.post, right->_for.post)) - return 0; + if (!identical_ast_nodes(exact, a->_type.template.actual, b->_type.template.actual)) + return 0; - if (!identical_ast_nodes(exact, left->_for.body, right->_for.body)) - return 0; + return 1; +} - break; +static int identical_type_id(int exact, struct ast_node *a, struct ast_node *b) +{ + return identical_ast_nodes(exact, a->_type.id, b->_type.id); +} - case AST_WHILE: - if (!identical_ast_nodes(exact, left->_while.cond, right->_while.cond)) - return 0; +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); +} - if (!identical_ast_nodes(exact, left->_while.body, right->_while.body)) - return 0; +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); +} - break; +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)) + return 0; - case AST_CTRL: - if (left->_ctrl.kind != right->_ctrl.kind) - return 0; + if (!identical_ast_nodes(exact, a->_type.proc.ret, b->_type.proc.ret)) + return 0; - break; + return 1; +} - case AST_RETURN: - if (!identical_ast_nodes(exact, left->_return.expr, right->_return.expr)) - return 0; +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)) + return 0; - break; + if (!identical_ast_nodes(exact, a->_type.lambda.ret, b->_type.lambda.ret)) + return 0; - case AST_TYPE: - if (left->_type.kind != right->_type.kind) - return 0; + return 1; +} - switch (left->_type.kind) { - case AST_TYPE_ALIAS: - if (!identical_ast_nodes(exact, left->_type.alias.alias, - right->_type.alias.alias)) - return 0; +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)) + return 0; - if (!identical_ast_nodes(exact, left->_type.alias.actual, - right->_type.alias.actual)) - return 0; - break; + if (!identical_ast_nodes(exact, a->_type.sign.ret, b->_type.sign.ret)) + return 0; - case AST_TYPE_TEMPLATE: - if (!identical_ast_nodes(exact, left->_type.template.template, - right->_type.template.template)) - return 0; + return 1; +} - if (!identical_ast_nodes(exact, left->_type.template.actual, - right->_type.template.actual)) - return 0; - break; +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)) + return 0; - case AST_TYPE_ID: - if (!identical_ast_nodes(exact, left->_type.id, - right->_type.id)) - return 0; - break; + if (!identical_ast_nodes(exact, a->_type.struc.impls, b->_type.struc.impls)) + return 0; - case AST_TYPE_ARR: - if (!identical_ast_nodes(exact, left->_type.arr.size, - right->_type.arr.size)) - return 0; - break; + return 1; +} - case AST_TYPE_TYPEOF: - if (!identical_ast_nodes(exact, left->_type.typeo.expr, - right->_type.typeo.expr)) - return 0; - break; +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; - case AST_TYPE_PROC: - if (!identical_ast_nodes(exact, left->_type.proc.params, - right->_type.proc.params)) - return 0; + if (!identical_ast_nodes(exact, a->_type.unio.body, b->_type.unio.body)) + return 0; - if (!identical_ast_nodes(exact, left->_type.proc.ret, - right->_type.proc.ret)) - return 0; - break; + return 1; +} - case AST_TYPE_LAMBDA: - if (!identical_ast_nodes(exact, left->_type.lambda.params, - right->_type.lambda.params)) - return 0; +static int identical_type(int exact, struct ast_node *a, struct ast_node *b) +{ + if (a->_type.kind != b->_type.kind) + return 0; - if (!identical_ast_nodes(exact, left->_type.lambda.ret, - right->_type.lambda.ret)) - return 0; - break; + 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_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; + case AST_TYPE_PROC: ret = identical_type_proc(exact, a, b); break; + case AST_TYPE_LAMBDA: ret = identical_type_lambda(exact, a, b); break; + case AST_TYPE_SIGN: ret = identical_type_sign(exact, a, b); break; + case AST_TYPE_STRUCT: ret = identical_type_struct(exact, a, b); break; + case AST_TYPE_UNION: ret = identical_type_union(exact, a, b); break; + case AST_TYPE_POINTER: break; + } - case AST_TYPE_SIGN: - if (!identical_ast_nodes(exact, left->_type.sign.params, - right->_type.sign.params)) - return 0; + return ret; +} - if (!identical_ast_nodes(exact, left->_type.sign.ret, - right->_type.sign.ret)) - return 0; - break; +static int identical_block(int exact, struct ast_node *a, struct ast_node *b) +{ + return identical_ast_nodes(exact, a->_block.body, b->_block.body); +} - case AST_TYPE_IMPL: - if (!identical_ast_nodes(exact, left->_type.impl.id, - right->_type.impl.id)) - return 0; +static int identical_import(int exact, struct ast_node *a, struct ast_node *b) +{ + (void)(exact); + return strcmp(a->_import.file, b->_import.file) == 0; +} - if (!identical_ast_nodes(exact, left->_type.impl.types, - right->_type.impl.types)) - return 0; - break; +static int identical_embed(int exact, struct ast_node *a, struct ast_node *b) +{ + (void)(exact); + return strcmp(a->_embed.file, b->_embed.file) == 0; +} - case AST_TYPE_STRUCT: - if (!identical_ast_nodes(exact, left->_type.struc.struc, - right->_type.struc.struc)) - return 0; +static int identical_enum(int exact, struct ast_node *a, struct ast_node *b) +{ + if (!identical_ast_nodes(exact, a->_enum.id, b->_enum.id)) + return 0; - if (!identical_ast_nodes(exact, left->_type.struc.impls, - right->_type.struc.impls)) - return 0; - break; + if (!identical_ast_nodes(exact, a->_enum.type, b->_enum.type)) + return 0; - case AST_TYPE_UNION: - if (!identical_ast_nodes(exact, left->_type.unio.id, - right->_type.unio.id)) - return 0; + if (!identical_ast_nodes(exact, a->_enum.body, b->_enum.body)) + return 0; - if (!identical_ast_nodes(exact, left->_type.unio.body, - right->_type.unio.body)) - return 0; - break; + return 1; +} - case AST_TYPE_POINTER: - break; - } +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; - break; + if (!identical_ast_nodes(exact, a->_struct.generics, b->_struct.generics)) + return 0; - case AST_BLOCK: - if (!identical_ast_nodes(exact, left->_block.body, right->_block.body)) - return 0; - break; + if (!identical_ast_nodes(exact, a->_struct.body, b->_struct.body)) + return 0; - case AST_IMPORT: - if (strcmp(left->_import.file, right->_import.file) != 0) - return 0; - break; + return 1; +} - case AST_EMBED: - if (strcmp(left->_embed.file, right->_embed.file) != 0) - return 0; - break; +static int identical_val(int exact, struct ast_node *a, struct ast_node *b) +{ + if (!identical_ast_nodes(exact, a->_val.id, b->_val.id)) + return 0; - case AST_PASTE: - if (!identical_ast_nodes(exact, left->_paste.id1, right->_paste.id1)) - return 0; + if (!identical_ast_nodes(exact, a->_val.val, b->_val.val)) + return 0; - if (!identical_ast_nodes(exact, left->_paste.id2, right->_paste.id2)) - return 0; + return 1; +} - break; +static int identical_switch(int exact, struct ast_node *a, struct ast_node *b) +{ + if (!identical_ast_nodes(exact, a->_switch.cond, b->_switch.cond)) + return 0; - case AST_ENUM: - if (!identical_ast_nodes(exact, left->_enum.id, right->_enum.id)) - return 0; + if (!identical_ast_nodes(exact, a->_switch.cases, b->_switch.cases)) + return 0; - if (!identical_ast_nodes(exact, left->_enum.type, right->_enum.type)) - return 0; + return 1; +} - if (!identical_ast_nodes(exact, left->_enum.body, right->_enum.body)) - return 0; +static int identical_case(int exact, struct ast_node *a, struct ast_node *b) +{ + if (!identical_ast_nodes(exact, a->_case.cond, b->_switch.cond)) + return 0; - break; + if (!identical_ast_nodes(exact, a->_case.body, b->_case.body)) + return 0; - case AST_STRUCT: - if (!identical_ast_nodes(exact, left->_struct.id, right->_struct.id)) - return 0; + return 1; +} - if (!identical_ast_nodes(exact, left->_struct.generics, right->_struct.generics)) - return 0; +static int identical_const(int exact, struct ast_node *a, struct ast_node *b) +{ + (void)(exact); + if (a->_const.kind != b->_const.kind) + return 0; - if (!identical_ast_nodes(exact, left->_struct.body, right->_struct.body)) + /* these could potentially also be broken out to their own + * procedures, but I don't think it's that important */ + switch (a->_const.kind) { + case AST_CONST_INTEGER: + if (a->_const.integer != b->_const.integer) return 0; break; - case AST_VAL: - if (!identical_ast_nodes(exact, left->_val.id, right->_val.id)) - return 0; + case AST_CONST_FLOAT: + /* NaNs aren't comparable */ + if (isnan(a->_const.dbl) && isnan(b->_const.dbl)) + break; - if (!identical_ast_nodes(exact, left->_val.val, right->_val.val)) + if (a->_const.dbl != b->_const.dbl) return 0; break; - case AST_SWITCH: - if (!identical_ast_nodes(exact, left->_switch.cond, right->_switch.cond)) - return 0; - - if (!identical_ast_nodes(exact, left->_switch.cases, right->_switch.cases)) + case AST_CONST_STRING: + if (strcmp(a->_const.str, b->_const.str) != 0) return 0; break; + } - case AST_CASE: - if (!identical_ast_nodes(exact, left->_case.cond, right->_switch.cond)) - return 0; + return 1; +} - if (!identical_ast_nodes(exact, left->_case.body, right->_case.body)) - return 0; +static int identical_id(int exact, struct ast_node *a, struct ast_node *b) +{ + (void)(exact); + return strcmp(a->_id.id, b->_id.id) == 0; +} - break; +static int identical_alias(int exact, struct ast_node *a, struct ast_node *b) +{ + if (!identical_ast_nodes(exact, a->_alias.id, b->_alias.id)) + return 0; - case AST_CONST: - if (left->_const.kind != right->_const.kind) - return 0; + if (!identical_ast_nodes(exact, a->_alias.type, b->_alias.type)) + return 0; - switch (left->_const.kind) { - case AST_CONST_INTEGER: - if (left->_const.integer != right->_const.integer) - return 0; - break; + return 1; +} - case AST_CONST_FLOAT: - /* NaNs aren't comparable */ - if (isnan(left->_const.dbl) && isnan(left->_const.dbl)) - break; +static int identical_template(int exact, struct ast_node *a, struct ast_node *b) +{ + if (!identical_ast_nodes(exact, a->_template.id, b->_template.id)) + return 0; - if (left->_const.dbl != right->_const.dbl) - return 0; - break; + if (!identical_ast_nodes(exact, a->_template.body, b->_template.body)) + return 0; - case AST_CONST_STRING: - if (strcmp(left->_const.str, right->_const.str) != 0) - return 0; - break; - } - break; + return 1; +} - case AST_ID: - if (strcmp(left->_id.id, right->_id.id) != 0) - return 0; - break; +static int identical_if(int exact, struct ast_node *a, struct ast_node *b) +{ + if (!identical_ast_nodes(exact, a->_if.cond, b->_if.cond)) + return 0; - case AST_EMPTY: - break; + if (!identical_ast_nodes(exact, a->_if.body, b->_if.body)) + return 0; - case AST_LAST: - break; + if (!identical_ast_nodes(exact, a->_if.els, b->_if.els)) + return 0; - case AST_ALIAS: - if (!identical_ast_nodes(exact, left->_alias.id, right->_alias.id)) - return 0; + return 1; +} - if (!identical_ast_nodes(exact, left->_alias.type, right->_alias.type)) - return 0; +/* sort of unfortnate that we can't just do a direct memcmp... */ +int identical_ast_nodes(int exact, struct ast_node *a, struct ast_node *b) +{ + /* both being NULL counts as identical */ + if (!a && !b) + return 1; - break; + /* the same node must be the same */ + if (a == b) + return 1; - case AST_TEMPLATE: - if (!identical_ast_nodes(exact, left->_template.id, right->_template.id)) - return 0; + /* either one being null means not identical */ + if (!a) + return 0; - if (!identical_ast_nodes(exact, left->_template.body, right->_template.body)) - return 0; + if (!b) + return 0; - break; + if (a->node_type != b->node_type) + return 0; - case AST_IF: - if (!identical_ast_nodes(exact, left->_if.cond, right->_if.cond)) - return 0; + if (exact && !identical_flags(a->flags, b->flags)) + return 0; - if (!identical_ast_nodes(exact, left->_if.body, right->_if.body)) - return 0; + if (exact && !identical_loc(a->loc, b->loc)) + return 0; - if (!identical_ast_nodes(exact, left->_if.els, right->_if.els)) - return 0; + if (exact && !identical_scope(a->scope, b->scope)) + return 0; - break; + int ret = 0; + switch (a->node_type) { + case AST_UNION: ret = identical_union(exact, a, b); break; + case AST_ASSIGN: ret = identical_assign(exact, a, b); break; + case AST_INIT: ret = identical_init(exact, a, b); break; + case AST_SIZEOF: ret = identical_sizeof(exact, a, b); break; + case AST_DOT: ret = identical_dot(exact, a, b); break; + case AST_AS: ret = identical_as(exact, a, b); break; + case AST_GOTO: ret = identical_goto(exact, a, b); break; + case AST_LABEL: ret = identical_label(exact, a, b); break; + case AST_BINOP: ret = identical_binop(exact, a, b); break; + case AST_UNOP: ret = identical_unop(exact, a, b); break; + case AST_CALL: ret = identical_call(exact, a, b); break; + case AST_CAST: ret = identical_cast(exact, a, b); break; + case AST_DEFER: ret = identical_defer(exact, a, b); break; + case AST_MACRO: ret = identical_macro(exact, a, b); break; + case AST_PROC: ret = identical_proc(exact, a, b); break; + case AST_VAR: ret = identical_var(exact, a, b); break; + case AST_LAMBDA: ret = identical_lambda(exact, a, b); break; + case AST_FOR: ret = identical_for(exact, a, b); break; + case AST_WHILE: ret = identical_while(exact, a, b); break; + case AST_CTRL: ret = identical_ctrl(exact, a, b); break; + case AST_RETURN: ret = identical_return(exact, a, b); break; + case AST_TYPE: ret = identical_type(exact, a, b); break; + case AST_BLOCK: ret = identical_block(exact, a, b); break; + case AST_IMPORT: ret = identical_import(exact, a, b); break; + case AST_EMBED: ret = identical_embed(exact, a, b); break; + case AST_ENUM: ret = identical_enum(exact, a, b); break; + case AST_STRUCT: ret = identical_struct(exact, a, b); break; + case AST_VAL: ret = identical_val(exact, a, b); break; + case AST_SWITCH: ret = identical_switch(exact, a, b); break; + case AST_CASE: ret = identical_case(exact, a, b); break; + case AST_CONST: ret = identical_const(exact, a, b); break; + case AST_ID: ret = identical_id(exact, a, b); break; + case AST_ALIAS: ret = identical_alias(exact, a, b); break; + case AST_TEMPLATE: ret = identical_template(exact, a, b); break; + case AST_IF: ret = identical_if(exact, a, b); break; + case AST_EMPTY: break; + case AST_LAST: break; } + if (ret == 0) + return 0; + /* Unsure if exact should be more of a flag or what, * but at least right now the issue is that the analyzer in some cases * has nodes that follow each other, i.e. next is populated, but we're * only interested in the current node. Calls, mainly. */ if (exact) - return identical_ast_nodes(exact, left->next, right->next); + return identical_ast_nodes(exact, a->next, b->next); return 1; } @@ -2314,252 +2346,364 @@ int ast_flags(struct ast_node *node, enum ast_flag flags) return node->flags & flags; } -/* I guess this works, but it's not exactly optimal as the caller sort of has to - * know when to continue to call on, and when it would cause an infinite loop. - * I.e. a call on an ID that is forwarded results in an infinite loop. - * - * Maybe add in something like ast_continue_call_on() that can check for the - * user if there's any point in continuing? - */ -int ast_call_on(int (*call)(struct ast_node *, void *data), - struct ast_node *node, void *data) +static int call_on_union(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data) { int ret = 0; - if (!node) - return ret; - - switch (node->node_type) { - case AST_UNION: - ret |= call(node->_union.id, data); - ret |= call(node->_union.generics, data); - ret |= call(node->_union.body, data); - break; - - case AST_ASSIGN: - ret |= call(node->_assign.to, data); - ret |= call(node->_assign.from, data); - break; - - case AST_INIT: - ret |= call(node->_init.body, data); - break; - - case AST_SIZEOF: - ret |= call(node->_sizeof.expr, data); - break; - - case AST_DOT: - ret |= call(node->_dot.expr, data); - ret |= call(node->_dot.id, data); - break; - - case AST_AS: - ret |= call(node->_as.type, data); - break; - - case AST_CAST: - ret |= call(node->_cast.expr, data); - ret |= call(node->_cast.type, data); - break; + ret |= call(node->_union.id, data); + ret |= call(node->_union.generics, data); + ret |= call(node->_union.body, data); + return ret; +} - case AST_DEFER: - ret |= call(node->_defer.expr, data); - break; +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); + ret |= call(node->_assign.from, data); + return ret; +} - case AST_LAST: - break; +static int call_on_init(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data) +{ + return call(node->_init.body, data); +} - case AST_VAR: - ret |= call(node->_var.id, data); - ret |= call(node->_var.type, data); - ret |= call(node->_var.init, data); - break; +static int call_on_sizeof(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data) +{ + return call(node->_sizeof.expr, data); +} - case AST_LAMBDA: - ret |= call(node->_lambda.captures, data); - ret |= call(node->_lambda.sign, data); - ret |= call(node->_lambda.body, data); - break; +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); + ret |= call(node->_dot.id, data); + return ret; +} - case AST_PASTE: - ret |= call(node->_paste.id1, data); - ret |= call(node->_paste.id2, data); - break; +static int call_on_as(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data) +{ + return call(node->_as.type, data); +} - case AST_FOR: - ret |= call(node->_for.pre, data); - ret |= call(node->_for.cond, data); - ret |= call(node->_for.post, data); - ret |= call(node->_for.body, data); - break; +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); + ret |= call(node->_cast.type, data); + return ret; +} - case AST_EMBED: - break; +static int call_on_defer(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data) +{ + return call(node->_defer.expr, data); +} - case AST_WHILE: - ret |= call(node->_while.cond, data); - ret |= call(node->_while.body, data); - break; +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); + ret |= call(node->_var.type, data); + ret |= call(node->_var.init, data); + return ret; +} - case AST_CTRL: - break; +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); + ret |= call(node->_lambda.sign, data); + ret |= call(node->_lambda.body, data); + return ret; +} - case AST_RETURN: - ret |= call(node->_return.expr, data); - break; +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); + ret |= call(node->_for.cond, data); + ret |= call(node->_for.post, data); + ret |= call(node->_for.body, data); + return ret; +} - case AST_ALIAS: - ret |= call(node->_alias.id, data); - ret |= call(node->_alias.type, data); - break; +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); + ret |= call(node->_while.body, data); + return ret; +} - case AST_TEMPLATE: - ret |= call(node->_template.id, data); - ret |= call(node->_template.body, data); - break; +static int call_on_return(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data) +{ + return call(node->_return.expr, data); +} - case AST_IF: - ret |= call(node->_if.cond, data); - ret |= call(node->_if.body, data); - ret |= call(node->_if.els, data); - break; +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); + ret |= call(node->_alias.type, data); + return ret; +} - case AST_IMPORT: - break; +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); + ret |= call(node->_template.body, data); + return ret; +} - case AST_ENUM: - ret |= call(node->_enum.id, data); - ret |= call(node->_enum.type, data); - ret |= call(node->_enum.body, data); - break; +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); + ret |= call(node->_if.body, data); + ret |= call(node->_if.els, data); + return ret; +} - case AST_STRUCT: - ret |= call(node->_struct.id, data); - ret |= call(node->_struct.generics, data); - ret |= call(node->_struct.body, data); - break; +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); + ret |= call(node->_enum.type, data); + ret |= call(node->_enum.body, data); + return ret; +} - case AST_VAL: - ret |= call(node->_val.id, data); - ret |= call(node->_val.val, data); - break; +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); + ret |= call(node->_struct.generics, data); + ret |= call(node->_struct.body, data); + return ret; +} - case AST_SWITCH: - ret |= call(node->_switch.cond, data); - ret |= call(node->_switch.cases, data); - break; +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); + ret |= call(node->_val.val, data); + return ret; +} - case AST_CASE: - ret |= call(node->_case.cond, data); - ret |= call(node->_case.body, data); - break; +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); + ret |= call(node->_switch.cases, data); + return ret; +} - case AST_CONST: - break; +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); + ret |= call(node->_case.body, data); + return ret; +} - case AST_ID: - break; +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); + ret |= call(node->_type.alias.actual, data); + return ret; +} - case AST_EMPTY: - break; +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); + ret |= call(node->_type.template.actual, data); + return ret; +} - case AST_TYPE: - switch (node->_type.kind) { - case AST_TYPE_ALIAS: - ret |= call(node->_type.alias.alias, data); - ret |= call(node->_type.alias.actual, data); - break; +static int call_on_type_id(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data) +{ + return call(node->_type.id, data); +} - case AST_TYPE_TEMPLATE: - ret |= call(node->_type.template.template, data); - ret |= call(node->_type.template.actual, data); - break; +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); +} - case AST_TYPE_ID: - ret |= call(node->_type.id, data); - break; +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); +} - case AST_TYPE_ARR: - ret |= call(node->_type.arr.size, data); - break; +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); + ret |= call(node->_type.unio.body, data); + return ret; +} - case AST_TYPE_TYPEOF: - ret |= call(node->_type.typeo.expr, data); - break; +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); + ret |= call(node->_type.struc.impls, data); + return ret; +} - case AST_TYPE_POINTER: - break; +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); + ret |= call(node->_type.proc.params, data); + ret |= call(node->_type.proc.ret, data); + return ret; +} - case AST_TYPE_UNION: - ret |= call(node->_type.unio.id, data); - ret |= call(node->_type.unio.body, data); - break; +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); + ret |= call(node->_type.lambda.ret, data); + return ret; +} - case AST_TYPE_STRUCT: - ret |= call(node->_type.struc.struc, data); - ret |= call(node->_type.struc.impls, data); - break; +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); + ret |= call(node->_type.sign.ret, data); + return ret; +} - case AST_TYPE_PROC: - ret |= call(node->_type.proc.id, data); - ret |= call(node->_type.proc.params, data); - ret |= call(node->_type.proc.ret, data); - break; +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_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_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_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_SIGN: ret = call_on_type_sign(call, node, data); break; + case AST_TYPE_POINTER: break; + } - case AST_TYPE_LAMBDA: - ret |= call(node->_type.lambda.params, data); - ret |= call(node->_type.lambda.ret, data); - break; + return ret; +} - case AST_TYPE_SIGN: - ret |= call(node->_type.sign.params, data); - ret |= call(node->_type.sign.ret, data); - break; +static int call_on_goto(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data) +{ + return call(node->_goto.label, data); +} - case AST_TYPE_IMPL: - ret |= call(node->_type.impl.id, data); - ret |= call(node->_type.impl.types, data); - break; - } - break; +static int call_on_label(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data) +{ + return call(node->_label.id, data); +} - case AST_GOTO: - ret |= call(node->_goto.label, data); - break; +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); + ret |= call(node->_binop.right, data); + return ret; +} - case AST_LABEL: - ret |= call(node->_label.id, data); - break; +static int call_on_unop(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data) +{ + return call(node->_unop.expr, data); +} - case AST_BINOP: - ret |= call(node->_binop.left, data); - ret |= call(node->_binop.right, data); - break; +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); + ret |= call(node->_call.args, data); + return ret; +} - case AST_UNOP: - ret |= call(node->_unop.expr, data); - break; +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); + ret |= call(node->_macro.params, data); + ret |= call(node->_macro.body, data); + return ret; +} - case AST_CALL: - ret |= call(node->_call.id, data); - ret |= call(node->_call.args, data); - break; +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); + ret |= call(node->_proc.sign, data); + ret |= call(node->_proc.body, data); + return ret; +} - case AST_MACRO: - ret |= call(node->_macro.id, data); - ret |= call(node->_macro.params, data); - ret |= call(node->_macro.body, data); - break; +static int call_on_block(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data) +{ + return call(node->_block.body, data); +} - case AST_PROC: - ret |= call(node->_proc.id, data); - ret |= call(node->_proc.sign, data); - ret |= call(node->_proc.body, data); - break; +/* I guess this works, but it's not exactly optimal as the caller sort of has to + * know when to continue to call on, and when it would cause an infinite loop. + * I.e. a call on an ID that is forwarded results in an infinite loop. + * + * Maybe add in something like ast_continue_call_on() that can check for the + * user if there's any point in continuing? + */ +int ast_call_on(int (*call)(struct ast_node *, void *), struct ast_node *node, void *data) +{ + int ret = 0; + if (!node) + return ret; - case AST_BLOCK: - ret |= call(node->_block.body, data); - break; + switch (node->node_type) { + case AST_UNION: ret = call_on_union(call, node, data); break; + case AST_ASSIGN: ret = call_on_assign(call, node, data); break; + case AST_INIT: ret = call_on_init(call, node, data); break; + case AST_SIZEOF: ret = call_on_sizeof(call, node, data); break; + case AST_DOT: ret = call_on_dot(call, node, data); break; + case AST_AS: ret = call_on_as(call, node, data); break; + case AST_CAST: ret = call_on_cast(call, node, data); break; + case AST_DEFER: ret = call_on_defer(call, node, data); break; + case AST_VAR: ret = call_on_var(call, node, data); break; + case AST_LAMBDA: ret = call_on_lambda(call, node, data); break; + case AST_FOR: ret = call_on_for(call, node, data); break; + case AST_WHILE: ret = call_on_while(call, node, data); break; + case AST_RETURN: ret = call_on_return(call, node, data); break; + case AST_ALIAS: ret = call_on_alias(call, node, data); break; + case AST_TEMPLATE: ret = call_on_template(call, node, data); break; + case AST_IF: ret = call_on_if(call, node, data); break; + case AST_ENUM: ret = call_on_enum(call, node, data); break; + case AST_STRUCT: ret = call_on_struct(call, node, data); break; + case AST_VAL: ret = call_on_val(call, node, data); break; + case AST_SWITCH: ret = call_on_switch(call, node, data); break; + case AST_CASE: ret = call_on_case(call, node, data); break; + case AST_TYPE: ret = call_on_type(call, node, data); break; + case AST_GOTO: ret = call_on_goto(call, node, data); break; + case AST_LABEL: ret = call_on_label(call, node, data); break; + case AST_BINOP: ret = call_on_binop(call, node, data); break; + case AST_UNOP: ret = call_on_unop(call, node, data); break; + case AST_CALL: ret = call_on_call(call, node, data); break; + case AST_MACRO: ret = call_on_macro(call, node, data); break; + case AST_PROC: ret = call_on_proc(call, node, data); break; + case AST_BLOCK: ret = call_on_block(call, node, data); break; + case AST_LAST: break; + case AST_EMBED: break; + case AST_CTRL: break; + case AST_IMPORT: break; + case AST_CONST: break; + case AST_ID: break; + case AST_EMPTY: break; } ret |= call(node->next, data); diff --git a/src/gen_parser.c b/src/gen_parser.c index ac53567..caf845e 100644 --- a/src/gen_parser.c +++ b/src/gen_parser.c @@ -583,16 +583,16 @@ union yyalloc /* YYFINAL -- State number of the termination state. */ #define YYFINAL 57 /* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 1987 +#define YYLAST 1993 /* YYNTOKENS -- Number of terminals. */ #define YYNTOKENS 81 /* YYNNTS -- Number of nonterminals. */ #define YYNNTS 63 /* YYNRULES -- Number of rules. */ -#define YYNRULES 216 +#define YYNRULES 215 /* YYNSTATES -- Number of states. */ -#define YYNSTATES 434 +#define YYNSTATES 432 /* YYMAXUTOK -- Last valid token kind. */ #define YYMAXUTOK 335 @@ -655,22 +655,22 @@ static const yytype_int16 yyrline[] = 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, 243, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 261, 264, 270, 272, - 273, 274, 275, 276, 278, 279, 280, 281, 282, 283, + 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, 295, 311, 312, 315, 316, 319, 320, 323, 327, - 334, 340, 341, 344, 345, 351, 352, 355, 358, 359, - 360, 361, 364, 365, 369, 370, 373, 374, 375, 378, - 381, 384, 385, 388, 391, 398, 402, 407, 415, 417, - 421, 424, 426, 428, 430, 434, 435, 442, 443, 447, - 450, 454, 458, 462, 467, 471, 472, 475, 476, 480, - 486, 490, 496, 499, 502, 503, 506, 509, 514, 515, - 516, 519, 522, 529, 530, 531, 532, 535, 536, 539, - 540, 543, 548, 551, 557, 558, 561, 562, 563, 566, - 567, 573, 577, 581, 589, 590, 591, 592, 593, 594, + 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, 607, 622, 623, 626, 627 + 605, 606, 621, 622, 625, 626 }; #endif @@ -719,12 +719,12 @@ yysymbol_name (yysymbol_kind_t yysymbol) } #endif -#define YYPACT_NINF (-255) +#define YYPACT_NINF (-248) #define yypact_value_is_default(Yyn) \ ((Yyn) == YYPACT_NINF) -#define YYTABLE_NINF (-217) +#define YYTABLE_NINF (-216) #define yytable_value_is_error(Yyn) \ 0 @@ -733,50 +733,50 @@ yysymbol_name (yysymbol_kind_t yysymbol) STATE-NUM. */ static const yytype_int16 yypact[] = { - 210, -255, -255, -255, 341, 44, 44, 24, 1, 44, - 44, 44, 411, 46, 54, -255, 64, -255, -255, -255, - 67, -255, -255, 95, -255, 84, 76, 77, -255, -255, - -255, 81, -255, -255, -7, 172, -255, 1110, -255, 27, - 23, 36, 42, 1110, 181, 296, 100, 494, 47, -255, - 59, -255, -255, -255, 976, -255, -255, -255, -255, -255, - -255, 44, 44, 25, -255, -255, -255, -255, 1110, 44, - 1110, 1110, 1110, 1110, 1110, -255, 66, 68, 1110, 44, - 305, 17, -255, -255, -255, -255, -255, -255, 1203, -255, - 100, -255, 305, 44, 15, -255, -255, 57, 976, -255, - 976, -255, -255, 305, 615, 93, 51, -255, 94, 305, - 1267, 305, 746, -255, 1140, 573, 1908, 71, -255, -255, - 305, 98, 80, 527, -255, 144, 82, 44, -255, 332, - 145, -255, 30, 83, 57, -255, 57, 57, 207, 1492, - 57, 1110, 154, 522, 1331, 64, 89, 124, 113, -255, - 44, 898, 1054, 1110, 1110, 1110, 1110, 1110, 1110, 1110, - 1110, 1110, 1110, 1110, 1110, 1110, 1110, 1110, 1110, 1110, - 1110, 1110, 1110, 1110, 1110, 1110, 1110, 1110, 1110, 1110, - 1110, 1110, 221, 305, 44, -21, 103, 183, 157, 117, - 59, 29, -255, -255, 120, 305, 305, 305, 44, -255, - 161, 305, -255, 305, 159, 129, -255, -255, 44, 1140, - 199, 202, 1110, 1008, 1110, 59, 930, -16, -255, 320, - 204, 205, 1395, -255, -255, 208, 670, 153, -255, -255, - -255, -255, -255, -255, -255, 222, -255, -255, 1084, 1908, - 59, 44, 195, 169, -255, 305, -255, 44, 182, 44, - -255, -1, -255, 255, -255, -255, -255, 1459, 194, -255, - -255, 44, 27, -255, 1110, -255, 539, 220, 203, -255, - -255, 1908, -255, -4, -4, -4, 207, 207, 1236, 1436, - 1492, 1428, 1364, 1300, 836, 836, 836, 836, 760, 760, - 235, 235, 1908, 1908, 1908, 1908, 1908, 1908, 1908, 1908, - 1908, 1908, 197, -255, -255, 44, 1110, 44, -255, -255, - 44, 59, -255, -255, 214, -255, 209, -255, -255, 305, - -255, -255, 59, -255, -255, 1523, 265, 1587, 219, -255, - 277, 1110, 44, -255, -255, -255, -255, -255, -255, -255, - -255, -255, -255, 223, 237, 289, 573, -255, -255, -255, - 44, -255, 44, 44, -255, -255, -255, -255, 59, -255, - 1008, -255, 240, 224, 1908, -255, 227, -255, 305, -255, - -255, 243, 244, 1110, -255, 1110, -255, 1587, 297, -255, - -35, 976, -255, 242, 247, 246, -255, -255, -31, -255, - 59, 249, -20, 1110, 244, 248, 1652, 1716, 257, 1110, - -255, -255, -255, -255, 251, -255, 221, -255, -255, -255, - -255, -255, 1780, -255, -255, 1110, -255, -17, 1844, 59, - 44, 253, 822, 1587, -255, -255, 1110, -255, 254, -255, - -255, -255, -255, -255 + 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. @@ -784,73 +784,73 @@ static const yytype_int16 yypact[] = means the default is an error. */ static const yytype_uint8 yydefact[] = { - 0, 212, 2, 194, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 198, 3, 4, 196, 197, - 0, 202, 195, 0, 215, 0, 0, 0, 206, 205, - 204, 0, 209, 203, 0, 0, 6, 0, 199, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 147, 145, - 0, 156, 210, 200, 0, 201, 214, 1, 211, 207, - 208, 0, 0, 0, 181, 61, 62, 63, 0, 0, - 0, 0, 0, 0, 0, 60, 0, 0, 0, 0, - 0, 56, 74, 65, 68, 69, 66, 67, 0, 75, - 0, 161, 0, 0, 0, 148, 150, 153, 0, 154, - 0, 155, 144, 0, 147, 52, 0, 48, 51, 0, - 0, 0, 0, 160, 0, 0, 118, 120, 157, 119, - 0, 170, 0, 0, 163, 0, 0, 0, 183, 0, - 0, 176, 178, 0, 41, 59, 39, 71, 38, 40, - 42, 0, 0, 56, 0, 0, 0, 107, 0, 73, + 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, 0, 184, 188, 0, - 0, 0, 158, 159, 0, 0, 0, 0, 0, 141, - 0, 0, 151, 0, 180, 0, 101, 100, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 105, 56, - 0, 0, 0, 91, 92, 0, 0, 0, 99, 94, - 86, 89, 93, 90, 95, 0, 97, 98, 0, 122, - 0, 0, 116, 0, 113, 0, 168, 0, 0, 165, - 171, 0, 173, 0, 175, 177, 182, 0, 0, 64, - 70, 0, 0, 58, 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, 72, 57, 0, 0, 187, 190, 110, - 0, 0, 143, 50, 0, 142, 0, 49, 152, 0, - 149, 78, 0, 82, 83, 0, 0, 0, 0, 81, - 0, 0, 0, 139, 138, 88, 85, 84, 79, 87, - 102, 104, 96, 0, 0, 0, 0, 117, 121, 169, - 0, 164, 0, 0, 174, 55, 5, 106, 0, 43, - 0, 53, 191, 0, 185, 186, 0, 108, 0, 140, - 179, 126, 0, 0, 76, 0, 80, 0, 0, 123, - 0, 0, 115, 0, 0, 0, 162, 46, 0, 189, - 0, 0, 0, 0, 132, 0, 0, 0, 135, 0, - 124, 125, 114, 172, 0, 166, 0, 193, 109, 146, - 127, 128, 0, 131, 133, 0, 77, 0, 112, 0, - 0, 0, 0, 0, 136, 137, 0, 134, 0, 192, - 130, 129, 111, 167 + 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[] = { - -255, 0, 3, -255, 4, -255, -255, -255, 121, -23, - -255, -62, -255, -255, 293, -255, -255, -255, -255, -223, - -34, -92, 9, -85, -255, -2, 196, -30, 140, -219, - -38, -255, -255, -39, -255, -255, -60, -255, -12, -255, - 440, 20, -63, 355, -255, -255, -216, -255, -255, -222, - 10, -255, 230, 50, 13, 14, -255, -254, 16, -14, - -255, -22, -255 + -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, 267, 268, - 105, 106, 86, 87, 116, 223, 224, 225, 226, 227, - 228, 148, 15, 419, 242, 243, 117, 269, 240, 119, - 230, 231, 394, 395, 232, 333, 334, 233, 49, 50, + 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, 205, 20, 21, 188, 189, 22, 38, + 19, 132, 133, 204, 20, 21, 187, 188, 22, 38, 23, 24, 25 }; @@ -859,408 +859,410 @@ static const yytype_int16 yydefgoto[] = number is the opposite. If YYTABLE_NINF, syntax error. */ static const yytype_int16 yytable[] = { - 12, 56, 191, 340, 12, 34, 35, 26, 27, 39, - 40, 41, 48, 28, 30, 146, 113, 31, 32, 343, - 33, 2, 114, 12, 118, 349, 37, 91, 185, 36, - 95, 2, 150, 351, 92, 48, 2, 209, 310, 112, - 331, 331, 48, 406, 48, 48, 104, 332, 2, 42, - 2, 363, 199, 365, 112, 43, 52, 112, 37, 200, - 198, 120, 123, 129, 53, 61, 108, 62, 192, 135, - 193, 352, 54, 353, 183, 184, 127, 55, 143, 147, - 48, 127, 124, 130, 57, 244, 58, 59, 190, 151, - 104, 60, 48, 187, 147, -213, 1, 93, 145, 90, - 128, 2, 311, 48, 48, 3, 2, 42, 94, 48, - 108, 48, 219, 43, 90, 220, 221, 253, 47, 111, - 48, 229, 234, 48, 199, 235, 236, 251, 237, 48, - 384, 200, 129, 112, 383, 313, 184, 385, 141, 317, - 142, 197, 201, 48, 4, 5, 247, 6, 7, 245, - 263, 266, 130, 248, 249, 254, 309, 250, 256, 258, - 302, 401, 260, 8, 9, 10, 11, 2, 42, 357, - -213, 270, 261, 102, 43, 146, 47, 305, 2, 42, - 103, 328, 12, 48, 304, 43, 330, 2, 42, 98, - 262, 306, 308, 312, 43, 48, 48, 104, 314, 430, - 48, 104, 320, 48, 428, 307, 344, 319, 321, 323, - -216, 1, 324, 266, 336, 337, 2, 108, 339, 48, - 3, 108, 1, 153, 154, 155, 219, 2, 341, 220, - 221, 3, 342, 270, 315, 229, 234, 47, 143, 235, - 236, 345, 237, 346, 347, 48, 63, 120, 47, 123, - 358, 153, 154, 155, 156, 157, 350, 47, 145, 4, - 5, 147, 6, 7, 266, 354, 48, 356, 360, 124, - 4, 5, 362, 6, 7, 373, 361, 367, 8, 9, - 10, 11, 369, 375, 359, 183, 184, 376, 371, 8, - 9, 10, 11, 374, 368, 380, 379, 381, 388, 389, - 390, 392, 2, 42, 100, 187, 393, 187, 399, 43, - 366, 2, 42, 183, 184, 417, 244, 403, 43, 48, - 404, 405, 409, 414, 386, 420, 2, 42, 429, 433, - 88, 335, 378, 43, 326, 150, 97, 387, 2, 42, - 110, 432, 252, 398, 382, 43, 400, 2, 272, 322, - 123, 402, 120, 123, 411, 413, 408, 425, 410, 29, - 266, 134, 255, 136, 137, 138, 139, 140, 48, 370, - 124, 144, 47, 124, 407, 0, 0, 0, 0, 0, - 270, 47, 0, 424, 421, 427, 44, 0, 45, 431, - 0, 5, 151, 6, 7, 0, 47, 0, 195, 0, - 196, 0, 0, 0, 90, 222, 12, 239, 47, 0, - 9, 10, 11, 0, 0, 0, 0, 2, 42, 0, - 123, 0, 219, 0, 43, 220, 221, 0, 0, 0, - 0, 229, 234, 0, 257, 235, 236, 0, 237, 0, - 124, 0, 0, 0, 0, 271, 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, 300, 301, 64, 0, 44, 0, 45, - 0, 0, 96, 46, 99, 101, 107, 47, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 65, 66, 67, - 2, 68, 239, 69, 0, 325, 70, 327, 71, 0, - 0, 0, 0, 72, 0, 0, 0, 73, 0, 222, - 149, 74, 0, 0, 0, 0, 0, 0, 2, 42, - 107, 144, 186, 2, 42, 43, 0, 150, 0, 0, - 43, 75, 0, 194, 0, 2, 42, 0, 76, 202, - 77, 204, 43, 0, 150, 0, 0, 139, 0, 0, - 246, 0, 0, 0, 0, 0, 78, 0, 0, 0, - 79, 109, 80, 0, 0, 0, 65, 66, 67, 2, - 68, 0, 69, 0, 0, 70, 0, 71, 44, 0, - 45, 0, 72, 195, 151, 196, 73, 0, 47, 364, - 74, 0, 0, 47, 0, 195, 0, 196, 0, 0, - 0, 151, 0, 0, 0, 47, 0, 0, 0, 0, - 75, 2, 42, 303, 377, 0, 0, 76, 43, 77, - 114, 0, 0, 0, 0, 99, 101, 107, 0, 0, - 316, 107, 0, 318, 0, 78, 0, 115, 0, 79, - 0, 80, 241, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 396, 0, 397, 0, - 0, 206, 0, 65, 66, 67, 2, 68, 0, 69, - 207, 195, 70, 196, 71, 348, 412, 111, 0, 72, - 0, 47, 418, 73, 0, 0, 0, 74, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 423, 0, - 0, 0, 0, 0, 0, 222, 0, 75, 0, 418, - 5, 0, 6, 7, 76, 208, 77, 209, 0, 210, - 211, 212, -103, 213, 214, 215, 0, 216, 217, 0, - 10, 11, 78, 0, 112, -103, 79, 206, 80, 65, - 66, 67, 2, 68, 0, 69, 207, 0, 70, 204, - 71, 0, 0, 0, 0, 72, 0, 0, 0, 73, - 0, 0, 0, 74, 0, 0, 153, 154, 155, 156, - 157, 0, 159, 160, 161, 0, 0, 0, 164, 165, - 166, 167, 0, 75, 170, 171, 5, 0, 6, 7, - 76, 208, 77, 209, 0, 210, 211, 212, 391, 213, - 214, 215, 0, 216, 217, 0, 10, 11, 78, 0, - 112, 218, 79, 206, 80, 65, 66, 67, 2, 68, - 0, 69, 207, 0, 70, 0, 71, 0, 183, 184, - 0, 72, 0, 0, 0, 73, 0, 0, 0, 74, - 0, 0, 153, 154, 155, 156, 157, 0, 159, 160, - 161, 0, 0, 0, 0, 0, 0, 0, 0, 75, - 170, 171, 5, 0, 6, 7, 76, 208, 77, 209, - 0, 210, 211, 212, 0, 213, 214, 215, 0, 216, - 217, 0, 10, 11, 78, 0, 112, 0, 79, 0, - 80, 65, 66, 67, 2, 68, 0, 69, 0, 0, - 70, 0, 71, 0, 183, 184, 0, 72, 0, 0, - 0, 264, 0, 0, 0, 74, 0, 0, 0, 0, - 0, 0, 0, 65, 66, 67, 2, 68, 0, 69, - 329, 0, 70, 0, 71, 75, 0, 0, 0, 72, - 0, 0, 76, 73, 77, 114, 0, 74, 0, 0, + 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, - 78, 265, 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, 264, 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, + 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, - 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, + 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, 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, 152, 238, 0, 0, 0, 79, 0, 80, 153, - 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, - 0, 164, 165, 166, 167, 168, 169, 170, 171, 172, - 173, 174, 175, 176, 177, 0, 178, 179, 180, 181, - 0, 0, 153, 154, 155, 156, 157, 0, 159, 160, - 161, 162, 163, 0, 164, 165, 166, 167, 168, 169, - 170, 171, 0, 0, 0, 152, 0, 182, 0, 0, - 0, 183, 184, 153, 154, 155, 156, 157, 158, 159, - 160, 161, 162, 163, 0, 164, 165, 166, 167, 168, - 169, 170, 171, 172, 173, 174, 175, 176, 177, 0, - 178, 179, 180, 181, 183, 184, 153, 154, 155, 156, - 157, 0, 159, 160, 161, 162, 0, 0, 164, 165, - 166, 167, 168, 169, 170, 171, 0, 0, 0, 152, - 0, 0, 0, 0, 203, 183, 184, 153, 154, 155, - 156, 157, 158, 159, 160, 161, 162, 163, 0, 164, - 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, - 175, 176, 177, 0, 178, 179, 180, 181, 183, 184, - 153, 154, 155, 156, 157, 0, 159, 160, 161, 0, - 0, 0, 164, 165, 166, 167, 168, 169, 170, 171, - 0, 0, 0, 152, 259, 338, 0, 0, 0, 183, - 184, 153, 154, 155, 156, 157, 158, 159, 160, 161, - 162, 163, 0, 164, 165, 166, 167, 168, 169, 170, - 171, 172, 173, 174, 175, 176, 177, 0, 178, 179, - 180, 181, 183, 184, 153, 154, 155, 156, 157, 0, - 159, 160, 153, 154, 155, 156, 157, 0, 0, 160, - 0, 0, 170, 171, 0, 0, 0, 152, 0, 0, - 170, 171, 0, 183, 184, 153, 154, 155, 156, 157, - 158, 159, 160, 161, 162, 163, 0, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, - 177, 0, 178, 179, 180, 181, 183, 184, 153, 154, - 155, 156, 157, 0, 183, 184, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 170, 171, 0, 0, - 0, 152, 355, 0, 0, 0, 0, 183, 184, 153, - 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, - 0, 164, 165, 166, 167, 168, 169, 170, 171, 172, - 173, 174, 175, 176, 177, 0, 178, 179, 180, 181, - 183, 184, 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, 152, 0, 372, 0, 0, - 0, 183, 184, 153, 154, 155, 156, 157, 158, 159, - 160, 161, 162, 163, 0, 164, 165, 166, 167, 168, - 169, 170, 171, 172, 173, 174, 175, 176, 177, 0, - 178, 179, 180, 181, 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, - 152, 112, 415, 0, 0, 183, 184, 0, 153, 154, - 155, 156, 157, 158, 159, 160, 161, 162, 163, 0, - 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, - 174, 175, 176, 177, 0, 178, 179, 180, 181, 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, 152, 0, 416, 0, 0, 0, - 183, 184, 153, 154, 155, 156, 157, 158, 159, 160, - 161, 162, 163, 0, 164, 165, 166, 167, 168, 169, - 170, 171, 172, 173, 174, 175, 176, 177, 0, 178, - 179, 180, 181, 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, 152, 0, - 0, 422, 0, 0, 183, 184, 153, 154, 155, 156, - 157, 158, 159, 160, 161, 162, 163, 0, 164, 165, - 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, - 176, 177, 0, 178, 179, 180, 181, 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, 152, 0, 0, 0, 0, 0, 183, 184, - 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, - 163, 0, 164, 165, 166, 167, 168, 169, 170, 171, - 172, 173, 174, 175, 176, 177, 0, 178, 179, 180, - 181, 0, 426, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 152, 0, 0, 0, - 0, 0, 183, 184, 153, 154, 155, 156, 157, 158, - 159, 160, 161, 162, 163, 0, 164, 165, 166, 167, - 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, - 0, 178, 179, 180, 181, 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, 0, 0, 0, 0, 183, 184 + 0, 0, 182, 183 }; static const yytype_int16 yycheck[] = { - 0, 23, 94, 226, 4, 5, 6, 4, 4, 9, - 10, 11, 12, 4, 4, 78, 50, 4, 4, 238, - 4, 6, 57, 23, 54, 247, 57, 39, 90, 5, - 42, 6, 15, 249, 11, 35, 6, 57, 9, 74, - 57, 57, 42, 74, 44, 45, 46, 63, 6, 7, - 6, 305, 73, 307, 74, 13, 10, 74, 57, 80, - 9, 61, 62, 63, 10, 72, 46, 74, 98, 69, - 100, 72, 8, 74, 78, 79, 51, 10, 78, 79, - 80, 51, 62, 63, 0, 115, 10, 10, 73, 72, - 90, 10, 92, 93, 94, 0, 1, 74, 78, 72, - 75, 6, 73, 103, 104, 10, 6, 7, 72, 109, - 90, 111, 112, 13, 72, 112, 112, 129, 76, 72, + 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, - 352, 80, 132, 74, 350, 197, 79, 353, 72, 201, - 72, 48, 48, 143, 49, 50, 48, 52, 53, 78, - 150, 151, 132, 73, 10, 10, 190, 75, 75, 5, - 182, 380, 73, 68, 69, 70, 71, 6, 7, 261, - 75, 151, 48, 73, 13, 238, 76, 74, 6, 7, - 80, 215, 182, 183, 184, 13, 216, 6, 7, 8, - 77, 8, 75, 73, 13, 195, 196, 197, 198, 422, - 200, 201, 73, 203, 420, 48, 240, 48, 208, 10, - 0, 1, 10, 213, 10, 10, 6, 197, 10, 219, - 10, 201, 1, 16, 17, 18, 226, 6, 75, 226, - 226, 10, 10, 213, 73, 226, 226, 76, 238, 226, - 226, 241, 226, 48, 75, 245, 74, 247, 76, 249, - 262, 16, 17, 18, 19, 20, 74, 76, 238, 49, - 50, 261, 52, 53, 264, 10, 266, 73, 48, 249, - 49, 50, 75, 52, 53, 10, 73, 311, 68, 69, - 70, 71, 73, 64, 264, 78, 79, 10, 322, 68, - 69, 70, 71, 327, 80, 58, 73, 8, 58, 75, - 73, 58, 6, 7, 8, 305, 62, 307, 11, 13, - 310, 6, 7, 78, 79, 58, 346, 75, 13, 319, - 73, 75, 73, 75, 358, 74, 6, 7, 75, 75, - 37, 11, 332, 13, 213, 15, 43, 360, 6, 7, - 47, 426, 10, 377, 346, 13, 380, 6, 152, 209, - 350, 381, 352, 353, 392, 394, 390, 417, 392, 4, - 360, 68, 132, 70, 71, 72, 73, 74, 368, 319, - 350, 78, 76, 353, 388, -1, -1, -1, -1, -1, - 360, 76, -1, 417, 406, 419, 66, -1, 68, 423, - -1, 50, 72, 52, 53, -1, 76, -1, 66, -1, - 68, -1, -1, -1, 72, 112, 406, 114, 76, -1, - 69, 70, 71, -1, -1, -1, -1, 6, 7, -1, - 420, -1, 422, -1, 13, 422, 422, -1, -1, -1, - -1, 422, 422, -1, 141, 422, 422, -1, 422, -1, - 420, -1, -1, -1, -1, 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, 181, 35, -1, 66, -1, 68, - -1, -1, 42, 72, 44, 45, 46, 76, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 3, 4, 5, - 6, 7, 209, 9, -1, 212, 12, 214, 14, -1, - -1, -1, -1, 19, -1, -1, -1, 23, -1, 226, - 80, 27, -1, -1, -1, -1, -1, -1, 6, 7, - 90, 238, 92, 6, 7, 13, -1, 15, -1, -1, - 13, 47, -1, 103, -1, 6, 7, -1, 54, 109, - 56, 111, 13, -1, 15, -1, -1, 264, -1, -1, - 120, -1, -1, -1, -1, -1, 72, -1, -1, -1, - 76, 77, 78, -1, -1, -1, 3, 4, 5, 6, - 7, -1, 9, -1, -1, 12, -1, 14, 66, -1, - 68, -1, 19, 66, 72, 68, 23, -1, 76, 306, - 27, -1, -1, 76, -1, 66, -1, 68, -1, -1, - -1, 72, -1, -1, -1, 76, -1, -1, -1, -1, - 47, 6, 7, 183, 331, -1, -1, 54, 13, 56, - 57, -1, -1, -1, -1, 195, 196, 197, -1, -1, - 200, 201, -1, 203, -1, 72, -1, 74, -1, 76, - -1, 78, 79, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 373, -1, 375, -1, - -1, 1, -1, 3, 4, 5, 6, 7, -1, 9, - 10, 66, 12, 68, 14, 245, 393, 72, -1, 19, - -1, 76, 399, 23, -1, -1, -1, 27, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 415, -1, - -1, -1, -1, -1, -1, 422, -1, 47, -1, 426, - 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, 3, - 4, 5, 6, 7, -1, 9, 10, -1, 12, 319, - 14, -1, -1, -1, -1, 19, -1, -1, -1, 23, - -1, -1, -1, 27, -1, -1, 16, 17, 18, 19, - 20, -1, 22, 23, 24, -1, -1, -1, 28, 29, - 30, 31, -1, 47, 34, 35, 50, -1, 52, 53, - 54, 55, 56, 57, -1, 59, 60, 61, 368, 63, + 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, 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, + 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, -1, -1, -1, -1, -1, 47, - 34, 35, 50, -1, 52, 53, 54, 55, 56, 57, + 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, -1, 76, -1, - 78, 3, 4, 5, 6, 7, -1, 9, -1, -1, + 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, -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, + -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, - -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, + 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, - -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, + 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, 25, -1, -1, 28, 29, + 20, -1, 22, 23, 24, -1, -1, -1, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, 8, - -1, -1, -1, -1, 77, 78, 79, 16, 17, 18, + 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, 24, -1, - -1, -1, 28, 29, 30, 31, 32, 33, 34, 35, - -1, -1, -1, 8, 73, 10, -1, -1, -1, 78, + 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, - 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, + 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, 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, + 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, - 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, 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, 74, 10, -1, -1, 78, 79, -1, 16, 17, + 8, -1, 10, -1, -1, -1, 78, 79, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, -1, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, -1, 43, 44, 45, 46, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 8, -1, 10, -1, -1, -1, + -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, 11, -1, -1, 78, 79, 16, 17, 18, 19, + -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, + 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, 48, -1, -1, -1, -1, -1, -1, -1, + 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, -1, -1, -1, -1, -1, -1, -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 + -1, -1, 78, 79 }; /* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of @@ -1282,35 +1284,35 @@ static const yytype_uint8 yystos[] = 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, - 15, 72, 8, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 28, 29, 30, 31, 32, 33, - 34, 35, 36, 37, 38, 39, 40, 41, 43, 44, - 45, 46, 74, 78, 79, 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, 82, 23, 73, 82, 89, 90, 108, - 122, 95, 107, 95, 95, 95, 95, 95, 95, 95, + 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, - 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 + 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. */ @@ -1323,21 +1325,21 @@ static const yytype_uint8 yyr1[] = 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, 95, 96, 97, 98, 99, + 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, 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, + 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, 141, 142, 142, 143, 143 + 141, 141, 142, 142, 143, 143 }; /* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM. */ @@ -1348,23 +1350,23 @@ static const yytype_int8 yyr2[] = 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1, 3, 1, 1, 3, - 3, 1, 1, 4, 3, 4, 1, 3, 3, 2, - 1, 1, 1, 1, 3, 1, 1, 1, 1, 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 + 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 }; @@ -1930,391 +1932,391 @@ yydestruct (const char *yymsg, case YYSYMBOL_INT: /* INT */ #line 143 "src/parser.y" {} -#line 1934 "src/gen_parser.c" +#line 1936 "src/gen_parser.c" break; case YYSYMBOL_FLOAT: /* FLOAT */ #line 143 "src/parser.y" {} -#line 1940 "src/gen_parser.c" +#line 1942 "src/gen_parser.c" break; case YYSYMBOL_STRING: /* STRING */ #line 143 "src/parser.y" {} -#line 1946 "src/gen_parser.c" +#line 1948 "src/gen_parser.c" break; case YYSYMBOL_ID: /* ID */ #line 143 "src/parser.y" {} -#line 1952 "src/gen_parser.c" +#line 1954 "src/gen_parser.c" break; case YYSYMBOL_id: /* id */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 1958 "src/gen_parser.c" +#line 1960 "src/gen_parser.c" break; case YYSYMBOL_var: /* var */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 1964 "src/gen_parser.c" +#line 1966 "src/gen_parser.c" break; case YYSYMBOL_embed: /* embed */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 1970 "src/gen_parser.c" +#line 1972 "src/gen_parser.c" break; case YYSYMBOL_import: /* import */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 1976 "src/gen_parser.c" +#line 1978 "src/gen_parser.c" break; case YYSYMBOL_assign: /* assign */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 1982 "src/gen_parser.c" +#line 1984 "src/gen_parser.c" break; case YYSYMBOL_binary_op: /* binary_op */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 1988 "src/gen_parser.c" +#line 1990 "src/gen_parser.c" break; case YYSYMBOL_unary_op: /* unary_op */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 1994 "src/gen_parser.c" +#line 1996 "src/gen_parser.c" break; case YYSYMBOL_arg: /* arg */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2000 "src/gen_parser.c" +#line 2002 "src/gen_parser.c" break; case YYSYMBOL_arg_list: /* arg_list */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2006 "src/gen_parser.c" +#line 2008 "src/gen_parser.c" break; case YYSYMBOL_param_decl: /* param_decl */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2012 "src/gen_parser.c" +#line 2014 "src/gen_parser.c" break; case YYSYMBOL_decl_list: /* decl_list */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2018 "src/gen_parser.c" +#line 2020 "src/gen_parser.c" break; case YYSYMBOL_call: /* call */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2024 "src/gen_parser.c" +#line 2026 "src/gen_parser.c" break; case YYSYMBOL_defer: /* defer */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2030 "src/gen_parser.c" +#line 2032 "src/gen_parser.c" break; case YYSYMBOL_expr: /* expr */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2036 "src/gen_parser.c" +#line 2038 "src/gen_parser.c" break; case YYSYMBOL_while: /* while */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2042 "src/gen_parser.c" +#line 2044 "src/gen_parser.c" break; case YYSYMBOL_do_while: /* do_while */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2048 "src/gen_parser.c" +#line 2050 "src/gen_parser.c" break; case YYSYMBOL_goto: /* goto */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2054 "src/gen_parser.c" +#line 2056 "src/gen_parser.c" break; case YYSYMBOL_statement: /* statement */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2060 "src/gen_parser.c" +#line 2062 "src/gen_parser.c" break; case YYSYMBOL_statement_list: /* statement_list */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2066 "src/gen_parser.c" +#line 2068 "src/gen_parser.c" break; case YYSYMBOL_body: /* body */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2072 "src/gen_parser.c" +#line 2074 "src/gen_parser.c" break; case YYSYMBOL_macro_list: /* macro_list */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2078 "src/gen_parser.c" +#line 2080 "src/gen_parser.c" break; case YYSYMBOL_macro: /* macro */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2084 "src/gen_parser.c" +#line 2086 "src/gen_parser.c" break; case YYSYMBOL_expr_list: /* expr_list */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2090 "src/gen_parser.c" +#line 2092 "src/gen_parser.c" break; case YYSYMBOL_struct_init: /* struct_init */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2096 "src/gen_parser.c" +#line 2098 "src/gen_parser.c" break; case YYSYMBOL_struct_inits: /* struct_inits */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2102 "src/gen_parser.c" +#line 2104 "src/gen_parser.c" break; case YYSYMBOL_struct_construct: /* struct_construct */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2108 "src/gen_parser.c" +#line 2110 "src/gen_parser.c" break; case YYSYMBOL_init_expr: /* init_expr */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2114 "src/gen_parser.c" +#line 2116 "src/gen_parser.c" break; case YYSYMBOL_cond: /* cond */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2120 "src/gen_parser.c" +#line 2122 "src/gen_parser.c" break; case YYSYMBOL_expr_if: /* expr_if */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2126 "src/gen_parser.c" +#line 2128 "src/gen_parser.c" break; case YYSYMBOL_if: /* if */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2132 "src/gen_parser.c" +#line 2134 "src/gen_parser.c" break; case YYSYMBOL_for: /* for */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2138 "src/gen_parser.c" +#line 2140 "src/gen_parser.c" break; case YYSYMBOL_case: /* case */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2144 "src/gen_parser.c" +#line 2146 "src/gen_parser.c" break; case YYSYMBOL_case_list: /* case_list */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2150 "src/gen_parser.c" +#line 2152 "src/gen_parser.c" break; case YYSYMBOL_switch: /* switch */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2156 "src/gen_parser.c" +#line 2158 "src/gen_parser.c" break; case YYSYMBOL_const_for: /* const_for */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2162 "src/gen_parser.c" +#line 2164 "src/gen_parser.c" break; case YYSYMBOL_const_if: /* const_if */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2168 "src/gen_parser.c" +#line 2170 "src/gen_parser.c" break; case YYSYMBOL_const: /* const */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2174 "src/gen_parser.c" +#line 2176 "src/gen_parser.c" break; case YYSYMBOL_func_sign: /* func_sign */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2180 "src/gen_parser.c" +#line 2182 "src/gen_parser.c" break; case YYSYMBOL_variadic_sign: /* variadic_sign */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2186 "src/gen_parser.c" +#line 2188 "src/gen_parser.c" break; case YYSYMBOL_type: /* type */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2192 "src/gen_parser.c" +#line 2194 "src/gen_parser.c" break; case YYSYMBOL_var_decl: /* var_decl */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2198 "src/gen_parser.c" +#line 2200 "src/gen_parser.c" break; case YYSYMBOL_var_init: /* var_init */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2204 "src/gen_parser.c" +#line 2206 "src/gen_parser.c" break; case YYSYMBOL_proc: /* proc */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2210 "src/gen_parser.c" +#line 2212 "src/gen_parser.c" break; case YYSYMBOL_lambda: /* lambda */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2216 "src/gen_parser.c" +#line 2218 "src/gen_parser.c" break; case YYSYMBOL_struct_elem: /* struct_elem */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2222 "src/gen_parser.c" +#line 2224 "src/gen_parser.c" break; case YYSYMBOL_struct_list: /* struct_list */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2228 "src/gen_parser.c" +#line 2230 "src/gen_parser.c" break; case YYSYMBOL_union: /* union */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2234 "src/gen_parser.c" +#line 2236 "src/gen_parser.c" break; case YYSYMBOL_generic: /* generic */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2240 "src/gen_parser.c" +#line 2242 "src/gen_parser.c" break; case YYSYMBOL_generic_list: /* generic_list */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2246 "src/gen_parser.c" +#line 2248 "src/gen_parser.c" break; case YYSYMBOL_struct: /* struct */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2252 "src/gen_parser.c" +#line 2254 "src/gen_parser.c" break; case YYSYMBOL_template_elem: /* template_elem */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2258 "src/gen_parser.c" +#line 2260 "src/gen_parser.c" break; case YYSYMBOL_template_list: /* template_list */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2264 "src/gen_parser.c" +#line 2266 "src/gen_parser.c" break; case YYSYMBOL_type_list: /* type_list */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2270 "src/gen_parser.c" +#line 2272 "src/gen_parser.c" break; case YYSYMBOL_type_alias: /* type_alias */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2276 "src/gen_parser.c" +#line 2278 "src/gen_parser.c" break; case YYSYMBOL_type_template: /* type_template */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2282 "src/gen_parser.c" +#line 2284 "src/gen_parser.c" break; case YYSYMBOL_enum_val: /* enum_val */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2288 "src/gen_parser.c" +#line 2290 "src/gen_parser.c" break; case YYSYMBOL_enum_list: /* enum_list */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2294 "src/gen_parser.c" +#line 2296 "src/gen_parser.c" break; case YYSYMBOL_enum: /* enum */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2300 "src/gen_parser.c" +#line 2302 "src/gen_parser.c" break; case YYSYMBOL_top_if: /* top_if */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2306 "src/gen_parser.c" +#line 2308 "src/gen_parser.c" break; case YYSYMBOL_top: /* top */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2312 "src/gen_parser.c" +#line 2314 "src/gen_parser.c" break; case YYSYMBOL_unit: /* unit */ #line 144 "src/parser.y" { destroy_ast_tree(((*yyvaluep).node)); } -#line 2318 "src/gen_parser.c" +#line 2320 "src/gen_parser.c" break; default: @@ -2623,169 +2625,169 @@ yyreduce: (yyval.node) = gen_id(strdup((yyvsp[0].str))); (yyval.node)->loc = to_src_loc(&yylloc); } -#line 2627 "src/gen_parser.c" +#line 2629 "src/gen_parser.c" break; case 3: /* var: var_decl */ #line 154 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 2633 "src/gen_parser.c" +#line 2635 "src/gen_parser.c" break; case 4: /* var: var_init */ #line 155 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 2639 "src/gen_parser.c" +#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 2645 "src/gen_parser.c" +#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 2651 "src/gen_parser.c" +#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 2657 "src/gen_parser.c" +#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 2663 "src/gen_parser.c" +#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 2669 "src/gen_parser.c" +#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 2675 "src/gen_parser.c" +#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 2681 "src/gen_parser.c" +#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 2687 "src/gen_parser.c" +#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 2693 "src/gen_parser.c" +#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 2699 "src/gen_parser.c" +#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 2705 "src/gen_parser.c" +#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 2711 "src/gen_parser.c" +#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 2717 "src/gen_parser.c" +#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 2723 "src/gen_parser.c" +#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 2729 "src/gen_parser.c" +#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 2735 "src/gen_parser.c" +#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 2741 "src/gen_parser.c" +#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 2747 "src/gen_parser.c" +#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 2753 "src/gen_parser.c" +#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 2759 "src/gen_parser.c" +#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 2765 "src/gen_parser.c" +#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 2771 "src/gen_parser.c" +#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 2777 "src/gen_parser.c" +#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 2783 "src/gen_parser.c" +#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 2789 "src/gen_parser.c" +#line 2791 "src/gen_parser.c" break; case 30: /* binary_op: expr "<<=" expr */ @@ -2793,7 +2795,7 @@ yyreduce: { (yyval.node) = gen_binop(AST_ASSIGN_LSHIFT, (yyvsp[-2].node), (yyvsp[0].node)); } -#line 2797 "src/gen_parser.c" +#line 2799 "src/gen_parser.c" break; case 31: /* binary_op: expr ">>=" expr */ @@ -2801,432 +2803,426 @@ yyreduce: { (yyval.node) = gen_binop(AST_ASSIGN_RSHIFT, (yyvsp[-2].node), (yyvsp[0].node)); } -#line 2805 "src/gen_parser.c" +#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 2811 "src/gen_parser.c" +#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 2817 "src/gen_parser.c" +#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 2823 "src/gen_parser.c" +#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 2829 "src/gen_parser.c" +#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 2835 "src/gen_parser.c" +#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 2841 "src/gen_parser.c" +#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 2847 "src/gen_parser.c" +#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 2853 "src/gen_parser.c" +#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 2859 "src/gen_parser.c" +#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 2865 "src/gen_parser.c" +#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 2871 "src/gen_parser.c" +#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 2877 "src/gen_parser.c" +#line 2879 "src/gen_parser.c" break; case 44: /* arg: var_decl */ #line 211 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 2883 "src/gen_parser.c" +#line 2885 "src/gen_parser.c" break; case 45: /* arg: init_expr */ #line 212 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 2889 "src/gen_parser.c" +#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 2895 "src/gen_parser.c" +#line 2897 "src/gen_parser.c" break; case 47: /* arg_list: arg */ #line 216 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 2901 "src/gen_parser.c" +#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 2907 "src/gen_parser.c" +#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 2913 "src/gen_parser.c" +#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 2919 "src/gen_parser.c" +#line 2921 "src/gen_parser.c" break; case 51: /* decl_list: var_decl */ #line 223 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 2925 "src/gen_parser.c" +#line 2927 "src/gen_parser.c" break; case 52: /* decl_list: param_decl */ #line 224 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 2931 "src/gen_parser.c" +#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 2937 "src/gen_parser.c" +#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 2943 "src/gen_parser.c" +#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 2949 "src/gen_parser.c" +#line 2951 "src/gen_parser.c" break; case 56: /* expr: id */ #line 236 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 2955 "src/gen_parser.c" +#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 2961 "src/gen_parser.c" +#line 2963 "src/gen_parser.c" break; - case 58: /* expr: id "##" id */ + case 58: /* expr: "..." id */ #line 238 "src/parser.y" - { (yyval.node) = gen_paste((yyvsp[-2].node), (yyvsp[0].node)); } -#line 2967 "src/gen_parser.c" - break; - - case 59: /* expr: "..." id */ -#line 239 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 2973 "src/gen_parser.c" +#line 2969 "src/gen_parser.c" break; - case 60: /* expr: "@" */ -#line 240 "src/parser.y" + case 59: /* expr: "@" */ +#line 239 "src/parser.y" { (yyval.node) = gen_last(); } -#line 2979 "src/gen_parser.c" +#line 2975 "src/gen_parser.c" break; - case 61: /* expr: INT */ -#line 241 "src/parser.y" + case 60: /* expr: INT */ +#line 240 "src/parser.y" { (yyval.node) = gen_int((yyvsp[0].integer)); (yyval.node)->loc = to_src_loc(&yylloc); } -#line 2985 "src/gen_parser.c" +#line 2981 "src/gen_parser.c" break; - case 62: /* expr: FLOAT */ -#line 242 "src/parser.y" + case 61: /* expr: FLOAT */ +#line 241 "src/parser.y" { (yyval.node) = gen_float((yyvsp[0].dbl)); (yyval.node)->loc = to_src_loc(&yylloc); } -#line 2991 "src/gen_parser.c" +#line 2987 "src/gen_parser.c" break; - case 63: /* expr: STRING */ -#line 243 "src/parser.y" + 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 3000 "src/gen_parser.c" +#line 2996 "src/gen_parser.c" break; - case 64: /* expr: "(" expr ")" */ -#line 247 "src/parser.y" + case 63: /* expr: "(" expr ")" */ +#line 246 "src/parser.y" { (yyval.node) = (yyvsp[-1].node); } -#line 3006 "src/gen_parser.c" +#line 3002 "src/gen_parser.c" break; - case 65: /* expr: assign */ -#line 248 "src/parser.y" + case 64: /* expr: assign */ +#line 247 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3012 "src/gen_parser.c" +#line 3008 "src/gen_parser.c" break; - case 66: /* expr: call */ -#line 249 "src/parser.y" + case 65: /* expr: call */ +#line 248 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3018 "src/gen_parser.c" +#line 3014 "src/gen_parser.c" break; - case 67: /* expr: defer */ -#line 250 "src/parser.y" + case 66: /* expr: defer */ +#line 249 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3024 "src/gen_parser.c" +#line 3020 "src/gen_parser.c" break; - case 68: /* expr: binary_op */ -#line 251 "src/parser.y" + case 67: /* expr: binary_op */ +#line 250 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3030 "src/gen_parser.c" +#line 3026 "src/gen_parser.c" break; - case 69: /* expr: unary_op */ -#line 252 "src/parser.y" + case 68: /* expr: unary_op */ +#line 251 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3036 "src/gen_parser.c" +#line 3032 "src/gen_parser.c" break; - case 70: /* expr: "(" var_init ")" */ -#line 253 "src/parser.y" + case 69: /* expr: "(" var_init ")" */ +#line 252 "src/parser.y" { (yyval.node) = (yyvsp[-1].node); } -#line 3042 "src/gen_parser.c" +#line 3038 "src/gen_parser.c" break; - case 71: /* expr: "sizeof" expr */ -#line 254 "src/parser.y" + case 70: /* expr: "sizeof" expr */ +#line 253 "src/parser.y" { (yyval.node) = gen_sizeof((yyvsp[0].node)); } -#line 3048 "src/gen_parser.c" +#line 3044 "src/gen_parser.c" break; - case 72: /* expr: expr "as" type */ -#line 255 "src/parser.y" + case 71: /* expr: expr "as" type */ +#line 254 "src/parser.y" { (yyval.node) = gen_cast((yyvsp[-2].node), (yyvsp[0].node)); } -#line 3054 "src/gen_parser.c" +#line 3050 "src/gen_parser.c" break; - case 73: /* expr: "as" type */ -#line 256 "src/parser.y" + case 72: /* expr: "as" type */ +#line 255 "src/parser.y" { (yyval.node) = gen_as((yyvsp[0].node)); } -#line 3060 "src/gen_parser.c" +#line 3056 "src/gen_parser.c" break; - case 74: /* expr: embed */ -#line 257 "src/parser.y" + case 73: /* expr: embed */ +#line 256 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3066 "src/gen_parser.c" +#line 3062 "src/gen_parser.c" break; - case 75: /* expr: lambda */ -#line 258 "src/parser.y" + case 74: /* expr: lambda */ +#line 257 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3072 "src/gen_parser.c" +#line 3068 "src/gen_parser.c" break; - case 76: /* while: "while" expr body */ -#line 261 "src/parser.y" + case 75: /* while: "while" expr body */ +#line 260 "src/parser.y" { (yyval.node) = gen_while((yyvsp[-1].node), (yyvsp[0].node)); } -#line 3078 "src/gen_parser.c" +#line 3074 "src/gen_parser.c" break; - case 77: /* do_while: "do" body "while" expr ";" */ -#line 264 "src/parser.y" + 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 3087 "src/gen_parser.c" +#line 3083 "src/gen_parser.c" break; - case 78: /* goto: "goto" id */ -#line 270 "src/parser.y" + case 77: /* goto: "goto" id */ +#line 269 "src/parser.y" { (yyval.node) = gen_goto(gen_label((yyvsp[0].node))); } -#line 3093 "src/gen_parser.c" +#line 3089 "src/gen_parser.c" break; - case 79: /* statement: expr ";" */ -#line 272 "src/parser.y" + case 78: /* statement: expr ";" */ +#line 271 "src/parser.y" { (yyval.node) = (yyvsp[-1].node); } -#line 3099 "src/gen_parser.c" +#line 3095 "src/gen_parser.c" break; - case 80: /* statement: "return" init_expr ";" */ -#line 273 "src/parser.y" + case 79: /* statement: "return" init_expr ";" */ +#line 272 "src/parser.y" { (yyval.node) = gen_return((yyvsp[-1].node)); } -#line 3105 "src/gen_parser.c" +#line 3101 "src/gen_parser.c" break; - case 81: /* statement: "return" ";" */ -#line 274 "src/parser.y" + case 80: /* statement: "return" ";" */ +#line 273 "src/parser.y" { (yyval.node) = gen_return(NULL); } -#line 3111 "src/gen_parser.c" +#line 3107 "src/gen_parser.c" break; - case 82: /* statement: "break" ";" */ -#line 275 "src/parser.y" + case 81: /* statement: "break" ";" */ +#line 274 "src/parser.y" { (yyval.node) = gen_ctrl(AST_CTRL_BREAK, to_src_loc(&yylloc)); } -#line 3117 "src/gen_parser.c" +#line 3113 "src/gen_parser.c" break; - case 83: /* statement: "continue" ";" */ -#line 276 "src/parser.y" + case 82: /* statement: "continue" ";" */ +#line 275 "src/parser.y" { (yyval.node) = gen_ctrl(AST_CTRL_CONTINUE, to_src_loc(&yylloc)); } -#line 3124 "src/gen_parser.c" +#line 3120 "src/gen_parser.c" break; - case 84: /* statement: import ";" */ -#line 278 "src/parser.y" + case 83: /* statement: import ";" */ +#line 277 "src/parser.y" { (yyval.node) = (yyvsp[-1].node); } -#line 3130 "src/gen_parser.c" +#line 3126 "src/gen_parser.c" break; - case 85: /* statement: var ";" */ -#line 279 "src/parser.y" + case 84: /* statement: var ";" */ +#line 278 "src/parser.y" { (yyval.node) = (yyvsp[-1].node); } -#line 3136 "src/gen_parser.c" +#line 3132 "src/gen_parser.c" break; - case 86: /* statement: if */ -#line 280 "src/parser.y" + case 85: /* statement: if */ +#line 279 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3142 "src/gen_parser.c" +#line 3138 "src/gen_parser.c" break; - case 87: /* statement: goto ";" */ -#line 281 "src/parser.y" + case 86: /* statement: goto ";" */ +#line 280 "src/parser.y" { (yyval.node) = (yyvsp[-1].node); } -#line 3148 "src/gen_parser.c" +#line 3144 "src/gen_parser.c" break; - case 88: /* statement: id ":" */ -#line 282 "src/parser.y" + case 87: /* statement: id ":" */ +#line 281 "src/parser.y" { (yyval.node) = gen_label((yyvsp[-1].node)); } -#line 3154 "src/gen_parser.c" +#line 3150 "src/gen_parser.c" break; - case 89: /* statement: for */ -#line 283 "src/parser.y" + case 88: /* statement: for */ +#line 282 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3160 "src/gen_parser.c" +#line 3156 "src/gen_parser.c" break; - case 90: /* statement: const */ -#line 284 "src/parser.y" + case 89: /* statement: const */ +#line 283 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3166 "src/gen_parser.c" +#line 3162 "src/gen_parser.c" break; - case 91: /* statement: while */ -#line 285 "src/parser.y" + case 90: /* statement: while */ +#line 284 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3172 "src/gen_parser.c" +#line 3168 "src/gen_parser.c" break; - case 92: /* statement: do_while */ -#line 286 "src/parser.y" + case 91: /* statement: do_while */ +#line 285 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3178 "src/gen_parser.c" +#line 3174 "src/gen_parser.c" break; - case 93: /* statement: switch */ -#line 287 "src/parser.y" + case 92: /* statement: switch */ +#line 286 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3184 "src/gen_parser.c" +#line 3180 "src/gen_parser.c" break; - case 94: /* statement: macro */ -#line 288 "src/parser.y" + case 93: /* statement: macro */ +#line 287 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3190 "src/gen_parser.c" +#line 3186 "src/gen_parser.c" break; - case 95: /* statement: struct */ -#line 289 "src/parser.y" + case 94: /* statement: struct */ +#line 288 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3196 "src/gen_parser.c" +#line 3192 "src/gen_parser.c" break; - case 96: /* statement: type_alias ";" */ -#line 290 "src/parser.y" + case 95: /* statement: type_alias ";" */ +#line 289 "src/parser.y" { (yyval.node) = (yyvsp[-1].node); } -#line 3202 "src/gen_parser.c" +#line 3198 "src/gen_parser.c" break; - case 97: /* statement: type_template */ -#line 291 "src/parser.y" + case 96: /* statement: type_template */ +#line 290 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3208 "src/gen_parser.c" +#line 3204 "src/gen_parser.c" break; - case 98: /* statement: enum */ -#line 292 "src/parser.y" + case 97: /* statement: enum */ +#line 291 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3214 "src/gen_parser.c" +#line 3210 "src/gen_parser.c" break; - case 99: /* statement: body */ -#line 293 "src/parser.y" + case 98: /* statement: body */ +#line 292 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3220 "src/gen_parser.c" +#line 3216 "src/gen_parser.c" break; - case 100: /* statement: ";" */ -#line 294 "src/parser.y" + case 99: /* statement: ";" */ +#line 293 "src/parser.y" { (yyval.node) = gen_empty(); } -#line 3226 "src/gen_parser.c" +#line 3222 "src/gen_parser.c" break; - case 101: /* statement: error */ -#line 295 "src/parser.y" + 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 */ @@ -3241,56 +3237,56 @@ yyreduce: yyclearin; yyerrok; } -#line 3245 "src/gen_parser.c" +#line 3241 "src/gen_parser.c" break; - case 102: /* statement_list: statement statement_list */ -#line 311 "src/parser.y" + 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 3251 "src/gen_parser.c" +#line 3247 "src/gen_parser.c" break; - case 103: /* statement_list: statement */ -#line 312 "src/parser.y" + case 102: /* statement_list: statement */ +#line 311 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3257 "src/gen_parser.c" +#line 3253 "src/gen_parser.c" break; - case 104: /* body: "{" statement_list "}" */ -#line 315 "src/parser.y" + case 103: /* body: "{" statement_list "}" */ +#line 314 "src/parser.y" { (yyval.node) = gen_block((yyvsp[-1].node)); } -#line 3263 "src/gen_parser.c" +#line 3259 "src/gen_parser.c" break; - case 105: /* body: "{" "}" */ -#line 316 "src/parser.y" + case 104: /* body: "{" "}" */ +#line 315 "src/parser.y" { (yyval.node) = gen_block(gen_empty()); } -#line 3269 "src/gen_parser.c" +#line 3265 "src/gen_parser.c" break; - case 106: /* macro_list: id "," macro_list */ -#line 319 "src/parser.y" + case 105: /* macro_list: id "," macro_list */ +#line 318 "src/parser.y" { (yyval.node) = (yyvsp[-2].node); (yyval.node)->next = (yyvsp[0].node); } -#line 3275 "src/gen_parser.c" +#line 3271 "src/gen_parser.c" break; - case 107: /* macro_list: id */ -#line 320 "src/parser.y" + case 106: /* macro_list: id */ +#line 319 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3281 "src/gen_parser.c" +#line 3277 "src/gen_parser.c" break; - case 108: /* macro: "define" id "(" macro_list ")" body */ -#line 323 "src/parser.y" + 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 3290 "src/gen_parser.c" +#line 3286 "src/gen_parser.c" break; - case 109: /* macro: "define" id "(" macro_list "..." id ")" body */ -#line 327 "src/parser.y" + 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)); @@ -3298,711 +3294,711 @@ yyreduce: ast_set_flags((yyval.node), AST_FLAG_VARIADIC); ast_set_flags((yyvsp[0].node), AST_FLAG_UNHYGIENIC); } -#line 3302 "src/gen_parser.c" +#line 3298 "src/gen_parser.c" break; - case 110: /* macro: "define" id "(" ")" body */ -#line 334 "src/parser.y" + 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 3311 "src/gen_parser.c" +#line 3307 "src/gen_parser.c" break; - case 111: /* expr_list: expr "," expr_list */ -#line 340 "src/parser.y" + 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 3317 "src/gen_parser.c" +#line 3313 "src/gen_parser.c" break; - case 112: /* expr_list: expr */ -#line 341 "src/parser.y" + case 111: /* expr_list: expr */ +#line 340 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3323 "src/gen_parser.c" +#line 3319 "src/gen_parser.c" break; - case 113: /* struct_init: init_expr */ -#line 344 "src/parser.y" + case 112: /* struct_init: init_expr */ +#line 343 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3329 "src/gen_parser.c" +#line 3325 "src/gen_parser.c" break; - case 114: /* struct_init: "." id "=" init_expr */ -#line 345 "src/parser.y" + 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 3338 "src/gen_parser.c" +#line 3334 "src/gen_parser.c" break; - case 115: /* struct_inits: struct_init "," struct_inits */ -#line 351 "src/parser.y" + 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 3344 "src/gen_parser.c" +#line 3340 "src/gen_parser.c" break; - case 116: /* struct_inits: struct_init */ -#line 352 "src/parser.y" + case 115: /* struct_inits: struct_init */ +#line 351 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3350 "src/gen_parser.c" +#line 3346 "src/gen_parser.c" break; - case 117: /* struct_construct: "{" struct_inits "}" */ -#line 355 "src/parser.y" + case 116: /* struct_construct: "{" struct_inits "}" */ +#line 354 "src/parser.y" { (yyval.node) = gen_init((yyvsp[-1].node)); } -#line 3356 "src/gen_parser.c" +#line 3352 "src/gen_parser.c" break; - case 118: /* init_expr: expr */ -#line 358 "src/parser.y" + case 117: /* init_expr: expr */ +#line 357 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3362 "src/gen_parser.c" +#line 3358 "src/gen_parser.c" break; - case 119: /* init_expr: expr_if */ -#line 359 "src/parser.y" + case 118: /* init_expr: expr_if */ +#line 358 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3368 "src/gen_parser.c" +#line 3364 "src/gen_parser.c" break; - case 120: /* init_expr: struct_construct */ -#line 360 "src/parser.y" + case 119: /* init_expr: struct_construct */ +#line 359 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3374 "src/gen_parser.c" +#line 3370 "src/gen_parser.c" break; - case 121: /* init_expr: struct_construct "as" type */ -#line 361 "src/parser.y" + case 120: /* init_expr: struct_construct "as" type */ +#line 360 "src/parser.y" { (yyval.node) = gen_cast((yyvsp[-2].node), (yyvsp[0].node)); } -#line 3380 "src/gen_parser.c" +#line 3376 "src/gen_parser.c" break; - case 122: /* cond: expr */ -#line 364 "src/parser.y" + case 121: /* cond: expr */ +#line 363 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3386 "src/gen_parser.c" +#line 3382 "src/gen_parser.c" break; - case 123: /* cond: "(" expr_if ")" */ -#line 365 "src/parser.y" + case 122: /* cond: "(" expr_if ")" */ +#line 364 "src/parser.y" { (yyval.node) = (yyvsp[-1].node); } -#line 3392 "src/gen_parser.c" +#line 3388 "src/gen_parser.c" break; - case 124: /* expr_if: "if" cond body "else" body */ -#line 369 "src/parser.y" + 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 3398 "src/gen_parser.c" +#line 3394 "src/gen_parser.c" break; - case 125: /* expr_if: "if" cond body "else" expr_if */ -#line 370 "src/parser.y" + 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 3404 "src/gen_parser.c" +#line 3400 "src/gen_parser.c" break; - case 126: /* if: "if" cond body */ -#line 373 "src/parser.y" + case 125: /* if: "if" cond body */ +#line 372 "src/parser.y" { (yyval.node) = gen_if((yyvsp[-1].node), (yyvsp[0].node), NULL); } -#line 3410 "src/gen_parser.c" +#line 3406 "src/gen_parser.c" break; - case 127: /* if: "if" cond body "else" body */ -#line 374 "src/parser.y" + 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 3416 "src/gen_parser.c" +#line 3412 "src/gen_parser.c" break; - case 128: /* if: "if" cond body "else" if */ -#line 375 "src/parser.y" + 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 3422 "src/gen_parser.c" +#line 3418 "src/gen_parser.c" break; - case 129: /* for: "for" arg ";" expr ";" expr body */ -#line 378 "src/parser.y" + 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 3428 "src/gen_parser.c" +#line 3424 "src/gen_parser.c" break; - case 130: /* case: "case" expr ":" statement_list */ -#line 381 "src/parser.y" + case 129: /* case: "case" expr ":" statement_list */ +#line 380 "src/parser.y" { (yyval.node) = gen_case((yyvsp[-2].node), (yyvsp[0].node)); } -#line 3434 "src/gen_parser.c" +#line 3430 "src/gen_parser.c" break; - case 131: /* case_list: case case_list */ -#line 384 "src/parser.y" + 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 3440 "src/gen_parser.c" +#line 3436 "src/gen_parser.c" break; - case 132: /* case_list: case */ -#line 385 "src/parser.y" + case 131: /* case_list: case */ +#line 384 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3446 "src/gen_parser.c" +#line 3442 "src/gen_parser.c" break; - case 133: /* switch: "switch" expr "{" case_list "}" */ -#line 388 "src/parser.y" + case 132: /* switch: "switch" expr "{" case_list "}" */ +#line 387 "src/parser.y" { (yyval.node) = gen_switch((yyvsp[-3].node), (yyvsp[-1].node)); } -#line 3452 "src/gen_parser.c" +#line 3448 "src/gen_parser.c" break; - case 134: /* const_for: "for" id ":" expr_list body */ -#line 391 "src/parser.y" + 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 3462 "src/gen_parser.c" +#line 3458 "src/gen_parser.c" break; - case 135: /* const_if: "if" expr body */ -#line 398 "src/parser.y" + 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 3471 "src/gen_parser.c" +#line 3467 "src/gen_parser.c" break; - case 136: /* const_if: "if" expr body "else" body */ -#line 402 "src/parser.y" + 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 3481 "src/gen_parser.c" +#line 3477 "src/gen_parser.c" break; - case 137: /* const_if: "if" expr body "else" const_if */ -#line 407 "src/parser.y" + 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 3490 "src/gen_parser.c" +#line 3486 "src/gen_parser.c" break; - case 138: /* const: "const" const_if */ -#line 415 "src/parser.y" + 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 3497 "src/gen_parser.c" +#line 3493 "src/gen_parser.c" break; - case 139: /* const: "const" const_for */ -#line 417 "src/parser.y" + 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 3504 "src/gen_parser.c" +#line 3500 "src/gen_parser.c" break; - case 140: /* func_sign: "(" decl_list "=>" type ")" */ -#line 421 "src/parser.y" + 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 3512 "src/gen_parser.c" +#line 3508 "src/gen_parser.c" break; - case 141: /* func_sign: "(" decl_list ")" */ -#line 424 "src/parser.y" + case 140: /* func_sign: "(" decl_list ")" */ +#line 423 "src/parser.y" { (yyval.node) = gen_type(AST_TYPE_SIGN, NULL, (yyvsp[-1].node), NULL); } -#line 3519 "src/gen_parser.c" +#line 3515 "src/gen_parser.c" break; - case 142: /* func_sign: "(" decl_list "=>" ")" */ -#line 426 "src/parser.y" + case 141: /* func_sign: "(" decl_list "=>" ")" */ +#line 425 "src/parser.y" { (yyval.node) = gen_type(AST_TYPE_SIGN, NULL, (yyvsp[-2].node), NULL); } -#line 3526 "src/gen_parser.c" +#line 3522 "src/gen_parser.c" break; - case 143: /* func_sign: "(" "=>" type ")" */ -#line 428 "src/parser.y" + case 142: /* func_sign: "(" "=>" type ")" */ +#line 427 "src/parser.y" { (yyval.node) = gen_type(AST_TYPE_SIGN, NULL, NULL, (yyvsp[-1].node)); } -#line 3533 "src/gen_parser.c" +#line 3529 "src/gen_parser.c" break; - case 144: /* func_sign: "(" ")" */ -#line 430 "src/parser.y" + case 143: /* func_sign: "(" ")" */ +#line 429 "src/parser.y" { (yyval.node) = gen_type(AST_TYPE_SIGN, NULL, NULL, NULL); } -#line 3540 "src/gen_parser.c" +#line 3536 "src/gen_parser.c" break; - case 145: /* variadic_sign: func_sign */ -#line 434 "src/parser.y" + case 144: /* variadic_sign: func_sign */ +#line 433 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3546 "src/gen_parser.c" +#line 3542 "src/gen_parser.c" break; - case 146: /* variadic_sign: "(" decl_list "..." id "=>" type ")" */ -#line 435 "src/parser.y" + 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 3556 "src/gen_parser.c" +#line 3552 "src/gen_parser.c" break; - case 147: /* type: id */ -#line 442 "src/parser.y" + case 146: /* type: id */ +#line 441 "src/parser.y" { (yyval.node) = gen_type(AST_TYPE_ID, (yyvsp[0].node), NULL, NULL); } -#line 3562 "src/gen_parser.c" +#line 3558 "src/gen_parser.c" break; - case 148: /* type: "'" func_sign */ -#line 443 "src/parser.y" + 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 3571 "src/gen_parser.c" +#line 3567 "src/gen_parser.c" break; - case 149: /* type: id "(" type_list ")" */ -#line 447 "src/parser.y" + 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 3579 "src/gen_parser.c" +#line 3575 "src/gen_parser.c" break; - case 150: /* type: "'" type */ -#line 450 "src/parser.y" + 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 3588 "src/gen_parser.c" +#line 3584 "src/gen_parser.c" break; - case 151: /* type: "[" "]" type */ -#line 454 "src/parser.y" + 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 3597 "src/gen_parser.c" +#line 3593 "src/gen_parser.c" break; - case 152: /* type: "[" expr "]" type */ -#line 458 "src/parser.y" + 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 3606 "src/gen_parser.c" +#line 3602 "src/gen_parser.c" break; - case 153: /* type: "typeof" expr */ -#line 462 "src/parser.y" + case 152: /* type: "typeof" expr */ +#line 461 "src/parser.y" { (yyval.node) = gen_type(AST_TYPE_TYPEOF, NULL, (yyvsp[0].node), NULL); } -#line 3614 "src/gen_parser.c" +#line 3610 "src/gen_parser.c" break; - case 154: /* var_decl: id "mut" type */ -#line 467 "src/parser.y" + 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 3623 "src/gen_parser.c" +#line 3619 "src/gen_parser.c" break; - case 155: /* var_decl: id "const" type */ -#line 471 "src/parser.y" + case 154: /* var_decl: id "const" type */ +#line 470 "src/parser.y" { (yyval.node) = gen_var((yyvsp[-2].node), (yyvsp[0].node), NULL); } -#line 3629 "src/gen_parser.c" +#line 3625 "src/gen_parser.c" break; - case 156: /* var_decl: id type */ -#line 472 "src/parser.y" + case 155: /* var_decl: id type */ +#line 471 "src/parser.y" { (yyval.node) = gen_var((yyvsp[-1].node), (yyvsp[0].node), NULL); } -#line 3635 "src/gen_parser.c" +#line 3631 "src/gen_parser.c" break; - case 157: /* var_init: var_decl "=" init_expr */ -#line 475 "src/parser.y" + 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 3641 "src/gen_parser.c" +#line 3637 "src/gen_parser.c" break; - case 158: /* var_init: id "mut" "=" init_expr */ -#line 476 "src/parser.y" + 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 3650 "src/gen_parser.c" +#line 3646 "src/gen_parser.c" break; - case 159: /* var_init: id "const" "=" init_expr */ -#line 480 "src/parser.y" + 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 3659 "src/gen_parser.c" +#line 3655 "src/gen_parser.c" break; - case 160: /* proc: id variadic_sign body */ -#line 486 "src/parser.y" + 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 3668 "src/gen_parser.c" +#line 3664 "src/gen_parser.c" break; - case 161: /* proc: "extern" id func_sign */ -#line 490 "src/parser.y" + 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 3677 "src/gen_parser.c" +#line 3673 "src/gen_parser.c" break; - case 162: /* lambda: "[" macro_list "]" func_sign body */ -#line 496 "src/parser.y" + 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 3683 "src/gen_parser.c" +#line 3679 "src/gen_parser.c" break; - case 163: /* struct_elem: var_decl */ -#line 499 "src/parser.y" + case 162: /* struct_elem: var_decl */ +#line 498 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3689 "src/gen_parser.c" +#line 3685 "src/gen_parser.c" break; - case 164: /* struct_list: struct_elem ";" struct_list */ -#line 502 "src/parser.y" + 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 3695 "src/gen_parser.c" +#line 3691 "src/gen_parser.c" break; - case 165: /* struct_list: struct_elem ";" */ -#line 503 "src/parser.y" + case 164: /* struct_list: struct_elem ";" */ +#line 502 "src/parser.y" { (yyval.node) = (yyvsp[-1].node); } -#line 3701 "src/gen_parser.c" +#line 3697 "src/gen_parser.c" break; - case 166: /* union: "union" id "{" struct_list "}" */ -#line 506 "src/parser.y" + case 165: /* union: "union" id "{" struct_list "}" */ +#line 505 "src/parser.y" { (yyval.node) = gen_union((yyvsp[-3].node), NULL, (yyvsp[-1].node)); } -#line 3709 "src/gen_parser.c" +#line 3705 "src/gen_parser.c" break; - case 167: /* union: "union" id "(" generic_list ")" "{" struct_list "}" */ -#line 509 "src/parser.y" + 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 3717 "src/gen_parser.c" +#line 3713 "src/gen_parser.c" break; - case 168: /* generic: id type */ -#line 514 "src/parser.y" + case 167: /* generic: id type */ +#line 513 "src/parser.y" { (yyval.node) = gen_alias((yyvsp[-1].node), (yyvsp[0].node)); } -#line 3723 "src/gen_parser.c" +#line 3719 "src/gen_parser.c" break; - case 169: /* generic_list: generic "," generic_list */ -#line 515 "src/parser.y" + case 168: /* generic_list: generic "," generic_list */ +#line 514 "src/parser.y" { (yyval.node) = (yyvsp[-2].node); (yyval.node)->next = (yyvsp[0].node); } -#line 3729 "src/gen_parser.c" +#line 3725 "src/gen_parser.c" break; - case 170: /* generic_list: generic */ -#line 516 "src/parser.y" + case 169: /* generic_list: generic */ +#line 515 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3735 "src/gen_parser.c" +#line 3731 "src/gen_parser.c" break; - case 171: /* struct: "struct" id "{" struct_list "}" */ -#line 519 "src/parser.y" + case 170: /* struct: "struct" id "{" struct_list "}" */ +#line 518 "src/parser.y" { (yyval.node) = gen_struct((yyvsp[-3].node), NULL, (yyvsp[-1].node)); } -#line 3743 "src/gen_parser.c" +#line 3739 "src/gen_parser.c" break; - case 172: /* struct: "struct" id "(" generic_list ")" "{" struct_list "}" */ -#line 522 "src/parser.y" + 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 3751 "src/gen_parser.c" +#line 3747 "src/gen_parser.c" break; - case 173: /* template_elem: id ";" */ -#line 529 "src/parser.y" + case 172: /* template_elem: id ";" */ +#line 528 "src/parser.y" { (yyval.node) = (yyvsp[-1].node); } -#line 3757 "src/gen_parser.c" +#line 3753 "src/gen_parser.c" break; - case 174: /* template_elem: id func_sign ";" */ -#line 530 "src/parser.y" + case 173: /* template_elem: id func_sign ";" */ +#line 529 "src/parser.y" { (yyval.node) = gen_proc((yyvsp[-2].node), (yyvsp[-1].node), NULL); } -#line 3763 "src/gen_parser.c" +#line 3759 "src/gen_parser.c" break; - case 175: /* template_elem: var_decl ";" */ -#line 531 "src/parser.y" + case 174: /* template_elem: var_decl ";" */ +#line 530 "src/parser.y" { (yyval.node) = (yyvsp[-1].node); } -#line 3769 "src/gen_parser.c" +#line 3765 "src/gen_parser.c" break; - case 176: /* template_elem: union */ -#line 532 "src/parser.y" + case 175: /* template_elem: union */ +#line 531 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3775 "src/gen_parser.c" +#line 3771 "src/gen_parser.c" break; - case 177: /* template_list: template_elem template_list */ -#line 535 "src/parser.y" + 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 3781 "src/gen_parser.c" +#line 3777 "src/gen_parser.c" break; - case 178: /* template_list: template_elem */ -#line 536 "src/parser.y" + case 177: /* template_list: template_elem */ +#line 535 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3787 "src/gen_parser.c" +#line 3783 "src/gen_parser.c" break; - case 179: /* type_list: type "," type_list */ -#line 539 "src/parser.y" + 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 3793 "src/gen_parser.c" +#line 3789 "src/gen_parser.c" break; - case 180: /* type_list: type */ -#line 540 "src/parser.y" + case 179: /* type_list: type */ +#line 539 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3799 "src/gen_parser.c" +#line 3795 "src/gen_parser.c" break; - case 181: /* type_alias: "type" id type */ -#line 543 "src/parser.y" + case 180: /* type_alias: "type" id type */ +#line 542 "src/parser.y" { (yyval.node) = gen_alias((yyvsp[-1].node), (yyvsp[0].node)); } -#line 3805 "src/gen_parser.c" +#line 3801 "src/gen_parser.c" break; - case 182: /* type_template: "type" id "{" template_list "}" */ -#line 548 "src/parser.y" + case 181: /* type_template: "type" id "{" template_list "}" */ +#line 547 "src/parser.y" { (yyval.node) = gen_template((yyvsp[-3].node), (yyvsp[-1].node)); } -#line 3813 "src/gen_parser.c" +#line 3809 "src/gen_parser.c" break; - case 183: /* type_template: "type" id "{" "}" */ -#line 551 "src/parser.y" + 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 3822 "src/gen_parser.c" +#line 3818 "src/gen_parser.c" break; - case 184: /* enum_val: id */ -#line 557 "src/parser.y" + case 183: /* enum_val: id */ +#line 556 "src/parser.y" { (yyval.node) = gen_val((yyvsp[0].node), gen_int(0)); } -#line 3828 "src/gen_parser.c" +#line 3824 "src/gen_parser.c" break; - case 185: /* enum_val: id "=" expr */ -#line 558 "src/parser.y" + case 184: /* enum_val: id "=" expr */ +#line 557 "src/parser.y" { (yyval.node) = gen_val((yyvsp[-2].node), (yyvsp[0].node)); } -#line 3834 "src/gen_parser.c" +#line 3830 "src/gen_parser.c" break; - case 186: /* enum_list: enum_val "," enum_list */ -#line 561 "src/parser.y" + 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 3840 "src/gen_parser.c" +#line 3836 "src/gen_parser.c" break; - case 187: /* enum_list: enum_val "," */ -#line 562 "src/parser.y" + case 186: /* enum_list: enum_val "," */ +#line 561 "src/parser.y" { (yyval.node) = (yyvsp[-1].node); } -#line 3846 "src/gen_parser.c" +#line 3842 "src/gen_parser.c" break; - case 188: /* enum_list: enum_val */ -#line 563 "src/parser.y" + case 187: /* enum_list: enum_val */ +#line 562 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3852 "src/gen_parser.c" +#line 3848 "src/gen_parser.c" break; - case 189: /* enum: "enum" id ":" type "{" enum_list "}" */ -#line 566 "src/parser.y" + 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 3858 "src/gen_parser.c" +#line 3854 "src/gen_parser.c" break; - case 190: /* enum: "enum" id "{" enum_list "}" */ -#line 567 "src/parser.y" + 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 3867 "src/gen_parser.c" +#line 3863 "src/gen_parser.c" break; - case 191: /* top_if: "if" expr "{" unit "}" */ -#line 573 "src/parser.y" + 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 3876 "src/gen_parser.c" +#line 3872 "src/gen_parser.c" break; - case 192: /* top_if: "if" expr "{" unit "}" "else" "{" unit "}" */ -#line 577 "src/parser.y" + 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 3885 "src/gen_parser.c" +#line 3881 "src/gen_parser.c" break; - case 193: /* top_if: "if" expr "{" unit "}" "else" top_if */ -#line 581 "src/parser.y" + 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 3894 "src/gen_parser.c" +#line 3890 "src/gen_parser.c" break; - case 194: /* top: ";" */ -#line 589 "src/parser.y" + case 193: /* top: ";" */ +#line 588 "src/parser.y" { (yyval.node) = gen_empty(); } -#line 3900 "src/gen_parser.c" +#line 3896 "src/gen_parser.c" break; - case 195: /* top: enum */ -#line 590 "src/parser.y" + case 194: /* top: enum */ +#line 589 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3906 "src/gen_parser.c" +#line 3902 "src/gen_parser.c" break; - case 196: /* top: proc */ -#line 591 "src/parser.y" + case 195: /* top: proc */ +#line 590 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3912 "src/gen_parser.c" +#line 3908 "src/gen_parser.c" break; - case 197: /* top: struct */ -#line 592 "src/parser.y" + case 196: /* top: struct */ +#line 591 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3918 "src/gen_parser.c" +#line 3914 "src/gen_parser.c" break; - case 198: /* top: macro */ -#line 593 "src/parser.y" + case 197: /* top: macro */ +#line 592 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3924 "src/gen_parser.c" +#line 3920 "src/gen_parser.c" break; - case 199: /* top: "const" top_if */ -#line 594 "src/parser.y" + 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 3930 "src/gen_parser.c" +#line 3926 "src/gen_parser.c" break; - case 200: /* top: import ";" */ -#line 595 "src/parser.y" + case 199: /* top: import ";" */ +#line 594 "src/parser.y" { (yyval.node) = (yyvsp[-1].node); } -#line 3936 "src/gen_parser.c" +#line 3932 "src/gen_parser.c" break; - case 201: /* top: type_alias ";" */ -#line 596 "src/parser.y" + case 200: /* top: type_alias ";" */ +#line 595 "src/parser.y" { (yyval.node) = (yyvsp[-1].node); } -#line 3942 "src/gen_parser.c" +#line 3938 "src/gen_parser.c" break; - case 202: /* top: type_template */ -#line 597 "src/parser.y" + case 201: /* top: type_template */ +#line 596 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 3948 "src/gen_parser.c" +#line 3944 "src/gen_parser.c" break; - case 203: /* top: "pub" enum */ -#line 598 "src/parser.y" + 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 3954 "src/gen_parser.c" +#line 3950 "src/gen_parser.c" break; - case 204: /* top: "pub" struct */ -#line 599 "src/parser.y" + 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 3960 "src/gen_parser.c" +#line 3956 "src/gen_parser.c" break; - case 205: /* top: "pub" proc */ -#line 600 "src/parser.y" + 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 3966 "src/gen_parser.c" +#line 3962 "src/gen_parser.c" break; - case 206: /* top: "pub" macro */ -#line 601 "src/parser.y" + 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 3972 "src/gen_parser.c" +#line 3968 "src/gen_parser.c" break; - case 207: /* top: "pub" import ";" */ -#line 602 "src/parser.y" + 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 3978 "src/gen_parser.c" +#line 3974 "src/gen_parser.c" break; - case 208: /* top: "pub" type_alias ";" */ -#line 603 "src/parser.y" + 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 3984 "src/gen_parser.c" +#line 3980 "src/gen_parser.c" break; - case 209: /* top: "pub" type_template */ -#line 604 "src/parser.y" + 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 3990 "src/gen_parser.c" +#line 3986 "src/gen_parser.c" break; - case 210: /* top: var ";" */ -#line 605 "src/parser.y" + case 209: /* top: var ";" */ +#line 604 "src/parser.y" { (yyval.node) = (yyvsp[-1].node); } -#line 3996 "src/gen_parser.c" +#line 3992 "src/gen_parser.c" break; - case 211: /* top: "pub" var ";" */ -#line 606 "src/parser.y" + 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 4002 "src/gen_parser.c" +#line 3998 "src/gen_parser.c" break; - case 212: /* top: error */ -#line 607 "src/parser.y" + case 211: /* top: error */ +#line 606 "src/parser.y" { (yyval.node) = gen_empty(); parser->failed = true; @@ -4016,29 +4012,29 @@ yyreduce: yyclearin; yyerrok; } -#line 4020 "src/gen_parser.c" +#line 4016 "src/gen_parser.c" break; - case 213: /* unit: top */ -#line 622 "src/parser.y" + case 212: /* unit: top */ +#line 621 "src/parser.y" { (yyval.node) = (yyvsp[0].node); } -#line 4026 "src/gen_parser.c" +#line 4022 "src/gen_parser.c" break; - case 214: /* unit: top unit */ -#line 623 "src/parser.y" + case 213: /* unit: top unit */ +#line 622 "src/parser.y" { (yyval.node) = (yyvsp[-1].node); (yyvsp[-1].node)->next = (yyvsp[0].node); } -#line 4032 "src/gen_parser.c" +#line 4028 "src/gen_parser.c" break; - case 215: /* input: unit */ -#line 626 "src/parser.y" + case 214: /* input: unit */ +#line 625 "src/parser.y" { parser->tree = (yyvsp[0].node); } -#line 4038 "src/gen_parser.c" +#line 4034 "src/gen_parser.c" break; -#line 4042 "src/gen_parser.c" +#line 4038 "src/gen_parser.c" default: break; } @@ -4267,5 +4263,5 @@ yyreturnlab: return yyresult; } -#line 629 "src/parser.y" +#line 628 "src/parser.y" diff --git a/src/parser.y b/src/parser.y index 0132283..665a6a0 100644 --- a/src/parser.y +++ b/src/parser.y @@ -138,7 +138,7 @@ %nterm <node> embed param_decl union struct struct_list struct_elem %nterm <node> top_if const_if const_for defer goto assign %nterm <node> struct_construct struct_inits struct_init cond -%nterm <node> generic generic_list union_struct +%nterm <node> generic generic_list %destructor {} FLOAT INT STRING ID %destructor { destroy_ast_tree($$); } <*> @@ -235,7 +235,6 @@ defer: "defer" "(" expr ")" { $$ = gen_defer($3); } /* TODO: concatenate multiple strings together */ expr: id { $$ = $1; } | expr "." id { $$ = gen_dot($1, $3); } - | id "##" id { $$ = gen_paste($1, $3); } | "..." id { $$ = $2; } | "@" { $$ = gen_last(); } | INT { $$ = gen_int($1); $$->loc = to_src_loc(&yylloc); } |