#include "parse.hpp"


namespace solar {

typedef std::pair<std::string, bool> var_t;
typedef std::vector<var_t> vars_t;
typedef std::pair<std::vector<solar::symbol_t>, vars_t> rhs_t;

}


namespace solar {

typedef union parse_symbol_value {
	parse_token_value_t token;
	std::string *symbol_action;
	bool symbol_consume;
	std::string *symbol_csymbol;
	std::vector<std::string> *symbol_namespace;
	rhs_t *symbol_rhs;
	symbol_t *symbol_symbol;
	symbol_t *symbol_term;
	var_t *symbol_variable;
} parse_symbol_value_t;

typedef struct parse_context_state {
	unsigned state;
	parse_symbol_value_t value;
} parse_context_state_t;

struct parse_context {
	unsigned top;
	parse_context_state_t stack[1024];
};


parse_context_t * parse_alloc(void *(*alloc_func)(size_t)) {
	parse_context_t *parser = (parse_context_t *)alloc_func(sizeof(parse_context_t));
	parser->top = 0;
	parser->stack[0].state = 0;
	return parser;
}

void parse_free(parse_context_t *parser, void (*free_func)(void *)) {
	free_func(parser);
}


static inline void parse_reduce_3(std::string *nonterm, std::string *type, __attribute__((unused)) grammar_t *grammar) {
	grammar->nonterm_types.insert({*nonterm, *type});
}

static inline void parse_reduce_4(symbol_t *term, std::string *type, std::string *name, __attribute__((unused)) grammar_t *grammar) {
	grammar->term_types.insert({*term, {*type, *name}});
}

static inline void parse_reduce_5(symbol_t *sym, std::string *name, __attribute__((unused)) grammar_t *grammar) {
	grammar->destructors.insert({*sym, *name});
}

static inline void parse_reduce_6(std::vector<std::string> *ns, __attribute__((unused)) grammar_t *grammar) {
	grammar->ns = *ns;
}

static inline void parse_reduce_7(std::string *block, __attribute__((unused)) grammar_t *grammar) {
	grammar->source_block = *block;
}

static inline void parse_reduce_8(std::string *block, __attribute__((unused)) grammar_t *grammar) {
	grammar->header_block = *block;
}

static inline void parse_reduce_9(std::string *type, std::string *name, __attribute__((unused)) grammar_t *grammar) {
	grammar->extra_args.emplace_back(*type, *name);
}

static inline void parse_reduce_10(std::string *lhs, rhs_t *rhs, std::string *action, __attribute__((unused)) grammar_t *grammar) {
	grammar->add_rule(item_t(*lhs, rhs->first), rhs->second, *action);
}

static inline void parse_reduce_11(std::string *lhs, unsigned char c1, unsigned char c2, std::string *action, __attribute__((unused)) grammar_t *grammar) {
	for (unsigned int c = c1; c <= c2; c++)
		grammar->add_rule(item_t(*lhs, {symbol_t::make_char(c)}), vars_t(1), *action);
}

static inline rhs_t * parse_reduce_12(__attribute__((unused)) grammar_t *grammar) {return new rhs_t;}

static inline rhs_t * parse_reduce_13(rhs_t *rhs, symbol_t *sym, var_t *var, __attribute__((unused)) grammar_t *grammar) {
	rhs->first.push_back(*sym);
	rhs->second.push_back(*var);

	return rhs;
}

static inline rhs_t * parse_reduce_14(rhs_t *rhs, std::string *str, __attribute__((unused)) grammar_t *grammar) {
	for (char c : *str) {
		rhs->first.push_back(symbol_t::make_char(c));
		rhs->second.emplace_back();
	}

	return rhs;
}

static inline var_t * parse_reduce_15(__attribute__((unused)) grammar_t *grammar) {return new var_t;}

static inline var_t * parse_reduce_16(bool consume, std::string *var, __attribute__((unused)) grammar_t *grammar) {return new var_t(*var, consume);}

static inline bool parse_reduce_17(__attribute__((unused)) grammar_t *grammar) {return false;}

static inline bool parse_reduce_18(__attribute__((unused)) grammar_t *grammar) {return true;}

static inline std::string * parse_reduce_19(__attribute__((unused)) grammar_t *grammar) {return new std::string;}

static inline std::string * parse_reduce_20(std::string *v, __attribute__((unused)) grammar_t *grammar) {return v;}

static inline std::string * parse_reduce_21(std::string *v, __attribute__((unused)) grammar_t *grammar) {return new std::string("return " + *v + ";");}

static inline std::vector<std::string> * parse_reduce_22(std::string *v, __attribute__((unused)) grammar_t *grammar) {return new std::vector<std::string> {*v};}

static inline std::vector<std::string> * parse_reduce_23(std::vector<std::string> *ns, std::string *v, __attribute__((unused)) grammar_t *grammar) {
	ns->push_back(*v);
	return ns;
}

static inline symbol_t * parse_reduce_24(std::string *v, __attribute__((unused)) grammar_t *grammar) {return new symbol_t(symbol_t::make_nonterm(*v));}

static inline symbol_t * parse_reduce_25(symbol_t *v, __attribute__((unused)) grammar_t *grammar) {return v;}

static inline symbol_t * parse_reduce_26(std::string *v, __attribute__((unused)) grammar_t *grammar) {return new symbol_t(symbol_t::make_term(*v));}

static inline symbol_t * parse_reduce_27(unsigned char v, __attribute__((unused)) grammar_t *grammar) {return new symbol_t(symbol_t::make_char(v));}

static inline std::string * parse_reduce_28(std::string *v, __attribute__((unused)) grammar_t *grammar) {return v;}

static inline std::string * parse_reduce_29(std::string *v, __attribute__((unused)) grammar_t *grammar) {return v;}


static int parse_do_push(parse_context_t *parser, int token, __attribute__((unused)) grammar_t *grammar) {
	parse_symbol_value_t result;

	while (1) {
		switch (parser->stack[parser->top].state) {
		case 0:
			switch (token) {
			default:
				parser->stack[++parser->top].state = 1;
			}
			break;

		case 1:
			switch (token) {
			case 0:
				return 0;

			case TOK_SYMBOL:
				parser->stack[++parser->top].state = 3;
				return 1;

			case '%':
				parser->stack[++parser->top].state = 4;
				return 1;

			default:
				return -1;
			}
			break;

		case 2:
			switch (token) {
			default:
				parser->top -= 2;
				parser->stack[++parser->top].state = 1;
			}
			break;

		case 3:
			switch (token) {
			case '|':
				parser->stack[++parser->top].state = 5;
				return 1;

			default:
				return -1;
			}
			break;

		case 4:
			switch (token) {
			case 'd':
				parser->stack[++parser->top].state = 6;
				return 1;

			case 'e':
				parser->stack[++parser->top].state = 7;
				return 1;

			case 'h':
				parser->stack[++parser->top].state = 8;
				return 1;

			case 'n':
				parser->stack[++parser->top].state = 9;
				return 1;

			case 's':
				parser->stack[++parser->top].state = 10;
				return 1;

			case 't':
				parser->stack[++parser->top].state = 11;
				return 1;

			default:
				return -1;
			}
			break;

		case 5:
			switch (token) {
			case '=':
				parser->stack[++parser->top].state = 12;
				return 1;

			default:
				return -1;
			}
			break;

		case 6:
			switch (token) {
			case 'e':
				parser->stack[++parser->top].state = 13;
				return 1;

			default:
				return -1;
			}
			break;

		case 7:
			switch (token) {
			case 'x':
				parser->stack[++parser->top].state = 14;
				return 1;

			default:
				return -1;
			}
			break;

		case 8:
			switch (token) {
			case 'e':
				parser->stack[++parser->top].state = 15;
				return 1;

			default:
				return -1;
			}
			break;

		case 9:
			switch (token) {
			case 'a':
				parser->stack[++parser->top].state = 16;
				return 1;

			default:
				return -1;
			}
			break;

		case 10:
			switch (token) {
			case 'o':
				parser->stack[++parser->top].state = 17;
				return 1;

			default:
				return -1;
			}
			break;

		case 11:
			switch (token) {
			case 'y':
				parser->stack[++parser->top].state = 18;
				return 1;

			default:
				return -1;
			}
			break;

		case 12:
			switch (token) {
			case '(':
				parser->stack[++parser->top].state = 20;
				return 1;

			default:
				result.symbol_rhs = parse_reduce_12(grammar);
				parser->stack[parser->top].value.symbol_rhs = result.symbol_rhs;
				parser->stack[++parser->top].state = 19;
			}
			break;

		case 13:
			switch (token) {
			case 's':
				parser->stack[++parser->top].state = 21;
				return 1;

			default:
				return -1;
			}
			break;

		case 14:
			switch (token) {
			case 't':
				parser->stack[++parser->top].state = 22;
				return 1;

			default:
				return -1;
			}
			break;

		case 15:
			switch (token) {
			case 'a':
				parser->stack[++parser->top].state = 23;
				return 1;

			default:
				return -1;
			}
			break;

		case 16:
			switch (token) {
			case 'm':
				parser->stack[++parser->top].state = 24;
				return 1;

			default:
				return -1;
			}
			break;

		case 17:
			switch (token) {
			case 'u':
				parser->stack[++parser->top].state = 25;
				return 1;

			default:
				return -1;
			}
			break;

		case 18:
			switch (token) {
			case 'p':
				parser->stack[++parser->top].state = 26;
				return 1;

			default:
				return -1;
			}
			break;

		case 19:
			switch (token) {
			case TOK_BLOCK:
				parser->stack[++parser->top].state = 30;
				return 1;

			case TOK_CHAR:
				parser->stack[++parser->top].state = 31;
				return 1;

			case TOK_SQBLOCK:
				parser->stack[++parser->top].state = 32;
				return 1;

			case TOK_STRING:
				parser->stack[++parser->top].state = 33;
				return 1;

			case TOK_SYMBOL:
				parser->stack[++parser->top].state = 34;
				return 1;

			case TOK_SYMBOL_UC:
				parser->stack[++parser->top].state = 35;
				return 1;

			case ';':
				parser->stack[++parser->top].state = 36;
				return 1;

			default:
				return -1;
			}
			break;

		case 20:
			switch (token) {
			case TOK_CHAR:
				parser->stack[++parser->top].state = 37;
				return 1;

			default:
				return -1;
			}
			break;

		case 21:
			switch (token) {
			case 't':
				parser->stack[++parser->top].state = 38;
				return 1;

			default:
				return -1;
			}
			break;

		case 22:
			switch (token) {
			case 'r':
				parser->stack[++parser->top].state = 39;
				return 1;

			default:
				return -1;
			}
			break;

		case 23:
			switch (token) {
			case 'd':
				parser->stack[++parser->top].state = 40;
				return 1;

			default:
				return -1;
			}
			break;

		case 24:
			switch (token) {
			case 'e':
				parser->stack[++parser->top].state = 41;
				return 1;

			default:
				return -1;
			}
			break;

		case 25:
			switch (token) {
			case 'r':
				parser->stack[++parser->top].state = 42;
				return 1;

			default:
				return -1;
			}
			break;

		case 26:
			switch (token) {
			case 'e':
				parser->stack[++parser->top].state = 43;
				return 1;

			default:
				return -1;
			}
			break;

		case 27:
			switch (token) {
			default:
				parser->top -= 5;
				parse_reduce_10(parser->stack[parser->top + 0].value.token.str, parser->stack[parser->top + 3].value.symbol_rhs, parser->stack[parser->top + 4].value.symbol_action, grammar);
				delete(parser->stack[parser->top + 0].value.token.str);
				delete(parser->stack[parser->top + 3].value.symbol_rhs);
				delete(parser->stack[parser->top + 4].value.symbol_action);
				parser->stack[++parser->top].state = 2;
			}
			break;

		case 28:
			switch (token) {
			case '(':
				parser->stack[++parser->top].state = 45;
				return 1;

			default:
				result.symbol_variable = parse_reduce_15(grammar);
				parser->stack[parser->top].value.symbol_variable = result.symbol_variable;
				parser->stack[++parser->top].state = 44;
			}
			break;

		case 29:
			switch (token) {
			default:
				parser->top -= 1;
				result.symbol_symbol = parse_reduce_25(parser->stack[parser->top + 0].value.symbol_term, grammar);
				parser->stack[parser->top].value.symbol_symbol = result.symbol_symbol;
				switch (parser->stack[parser->top].state) {
				case 19:
					parser->stack[++parser->top].state = 28;
					break;

				case 84:
					parser->stack[++parser->top].state = 88;
					break;

				}
			}
			break;

		case 30:
			switch (token) {
			default:
				parser->top -= 1;
				result.symbol_action = parse_reduce_20(parser->stack[parser->top + 0].value.token.str, grammar);
				parser->stack[parser->top].value.symbol_action = result.symbol_action;
				switch (parser->stack[parser->top].state) {
				case 19:
					parser->stack[++parser->top].state = 27;
					break;

				case 79:
					parser->stack[++parser->top].state = 83;
					break;

				}
			}
			break;

		case 31:
			switch (token) {
			default:
				parser->top -= 1;
				result.symbol_term = parse_reduce_27(parser->stack[parser->top + 0].value.token.c, grammar);
				parser->stack[parser->top].value.symbol_term = result.symbol_term;
				switch (parser->stack[parser->top].state) {
				case 19:
				case 84:
					parser->stack[++parser->top].state = 29;
					break;

				case 43:
					parser->stack[++parser->top].state = 52;
					break;

				}
			}
			break;

		case 32:
			switch (token) {
			default:
				parser->top -= 1;
				result.symbol_action = parse_reduce_21(parser->stack[parser->top + 0].value.token.str, grammar);
				delete(parser->stack[parser->top + 0].value.token.str);
				parser->stack[parser->top].value.symbol_action = result.symbol_action;
				switch (parser->stack[parser->top].state) {
				case 19:
					parser->stack[++parser->top].state = 27;
					break;

				case 79:
					parser->stack[++parser->top].state = 83;
					break;

				}
			}
			break;

		case 33:
			switch (token) {
			default:
				parser->top -= 2;
				result.symbol_rhs = parse_reduce_14(parser->stack[parser->top + 0].value.symbol_rhs, parser->stack[parser->top + 1].value.token.str, grammar);
				delete(parser->stack[parser->top + 1].value.token.str);
				parser->stack[parser->top].value.symbol_rhs = result.symbol_rhs;
				parser->stack[++parser->top].state = 19;
			}
			break;

		case 34:
			switch (token) {
			default:
				parser->top -= 1;
				result.symbol_symbol = parse_reduce_24(parser->stack[parser->top + 0].value.token.str, grammar);
				delete(parser->stack[parser->top + 0].value.token.str);
				parser->stack[parser->top].value.symbol_symbol = result.symbol_symbol;
				switch (parser->stack[parser->top].state) {
				case 19:
					parser->stack[++parser->top].state = 28;
					break;

				case 84:
					parser->stack[++parser->top].state = 88;
					break;

				}
			}
			break;

		case 35:
			switch (token) {
			default:
				parser->top -= 1;
				result.symbol_term = parse_reduce_26(parser->stack[parser->top + 0].value.token.str, grammar);
				delete(parser->stack[parser->top + 0].value.token.str);
				parser->stack[parser->top].value.symbol_term = result.symbol_term;
				switch (parser->stack[parser->top].state) {
				case 19:
				case 84:
					parser->stack[++parser->top].state = 29;
					break;

				case 43:
					parser->stack[++parser->top].state = 52;
					break;

				}
			}
			break;

		case 36:
			switch (token) {
			default:
				parser->top -= 1;
				result.symbol_action = parse_reduce_19(grammar);
				parser->stack[parser->top].value.symbol_action = result.symbol_action;
				switch (parser->stack[parser->top].state) {
				case 19:
					parser->stack[++parser->top].state = 27;
					break;

				case 79:
					parser->stack[++parser->top].state = 83;
					break;

				}
			}
			break;

		case 37:
			switch (token) {
			case '.':
				parser->stack[++parser->top].state = 46;
				return 1;

			default:
				return -1;
			}
			break;

		case 38:
			switch (token) {
			case 'r':
				parser->stack[++parser->top].state = 47;
				return 1;

			default:
				return -1;
			}
			break;

		case 39:
			switch (token) {
			case 'a':
				parser->stack[++parser->top].state = 48;
				return 1;

			default:
				return -1;
			}
			break;

		case 40:
			switch (token) {
			case 'e':
				parser->stack[++parser->top].state = 49;
				return 1;

			default:
				return -1;
			}
			break;

		case 41:
			switch (token) {
			case 's':
				parser->stack[++parser->top].state = 50;
				return 1;

			default:
				return -1;
			}
			break;

		case 42:
			switch (token) {
			case 'c':
				parser->stack[++parser->top].state = 51;
				return 1;

			default:
				return -1;
			}
			break;

		case 43:
			switch (token) {
			case TOK_CHAR:
				parser->stack[++parser->top].state = 31;
				return 1;

			case TOK_SYMBOL_UC:
				parser->stack[++parser->top].state = 35;
				return 1;

			case TOK_SYMBOL:
				parser->stack[++parser->top].state = 53;
				return 1;

			default:
				return -1;
			}
			break;

		case 44:
			switch (token) {
			default:
				parser->top -= 3;
				result.symbol_rhs = parse_reduce_13(parser->stack[parser->top + 0].value.symbol_rhs, parser->stack[parser->top + 1].value.symbol_symbol, parser->stack[parser->top + 2].value.symbol_variable, grammar);
				delete(parser->stack[parser->top + 1].value.symbol_symbol);
				delete(parser->stack[parser->top + 2].value.symbol_variable);
				parser->stack[parser->top].value.symbol_rhs = result.symbol_rhs;
				parser->stack[++parser->top].state = 19;
			}
			break;

		case 45:
			switch (token) {
			case '=':
				parser->stack[++parser->top].state = 55;
				return 1;

			default:
				result.symbol_consume = parse_reduce_17(grammar);
				parser->stack[parser->top].value.symbol_consume = result.symbol_consume;
				parser->stack[++parser->top].state = 54;
			}
			break;

		case 46:
			switch (token) {
			case '.':
				parser->stack[++parser->top].state = 56;
				return 1;

			default:
				return -1;
			}
			break;

		case 47:
			switch (token) {
			case 'u':
				parser->stack[++parser->top].state = 57;
				return 1;

			default:
				return -1;
			}
			break;

		case 48:
			switch (token) {
			case '_':
				parser->stack[++parser->top].state = 58;
				return 1;

			default:
				return -1;
			}
			break;

		case 49:
			switch (token) {
			case 'r':
				parser->stack[++parser->top].state = 59;
				return 1;

			default:
				return -1;
			}
			break;

		case 50:
			switch (token) {
			case 'p':
				parser->stack[++parser->top].state = 60;
				return 1;

			default:
				return -1;
			}
			break;

		case 51:
			switch (token) {
			case 'e':
				parser->stack[++parser->top].state = 61;
				return 1;

			default:
				return -1;
			}
			break;

		case 52:
			switch (token) {
			case TOK_BLOCK:
				parser->stack[++parser->top].state = 62;
				return 1;

			default:
				return -1;
			}
			break;

		case 53:
			switch (token) {
			case TOK_BLOCK:
				parser->stack[++parser->top].state = 63;
				return 1;

			default:
				return -1;
			}
			break;

		case 54:
			switch (token) {
			case TOK_SYMBOL:
				parser->stack[++parser->top].state = 65;
				return 1;

			case TOK_SYMBOL_UC:
				parser->stack[++parser->top].state = 66;
				return 1;

			default:
				return -1;
			}
			break;

		case 55:
			switch (token) {
			default:
				parser->top -= 1;
				result.symbol_consume = parse_reduce_18(grammar);
				parser->stack[parser->top].value.symbol_consume = result.symbol_consume;
				parser->stack[++parser->top].state = 54;
			}
			break;

		case 56:
			switch (token) {
			case '.':
				parser->stack[++parser->top].state = 67;
				return 1;

			default:
				return -1;
			}
			break;

		case 57:
			switch (token) {
			case 'c':
				parser->stack[++parser->top].state = 68;
				return 1;

			default:
				return -1;
			}
			break;

		case 58:
			switch (token) {
			case 'a':
				parser->stack[++parser->top].state = 69;
				return 1;

			default:
				return -1;
			}
			break;

		case 59:
			switch (token) {
			case TOK_BLOCK:
				parser->stack[++parser->top].state = 70;
				return 1;

			default:
				return -1;
			}
			break;

		case 60:
			switch (token) {
			case 'a':
				parser->stack[++parser->top].state = 71;
				return 1;

			default:
				return -1;
			}
			break;

		case 61:
			switch (token) {
			case TOK_BLOCK:
				parser->stack[++parser->top].state = 72;
				return 1;

			default:
				return -1;
			}
			break;

		case 62:
			switch (token) {
			case TOK_SYMBOL:
				parser->stack[++parser->top].state = 65;
				return 1;

			case TOK_SYMBOL_UC:
				parser->stack[++parser->top].state = 66;
				return 1;

			default:
				return -1;
			}
			break;

		case 63:
			switch (token) {
			default:
				parser->top -= 7;
				parse_reduce_3(parser->stack[parser->top + 5].value.token.str, parser->stack[parser->top + 6].value.token.str, grammar);
				delete(parser->stack[parser->top + 5].value.token.str);
				delete(parser->stack[parser->top + 6].value.token.str);
				parser->stack[++parser->top].state = 2;
			}
			break;

		case 64:
			switch (token) {
			case ')':
				parser->stack[++parser->top].state = 74;
				return 1;

			default:
				return -1;
			}
			break;

		case 65:
			switch (token) {
			default:
				parser->top -= 1;
				result.symbol_csymbol = parse_reduce_29(parser->stack[parser->top + 0].value.token.str, grammar);
				parser->stack[parser->top].value.symbol_csymbol = result.symbol_csymbol;
				switch (parser->stack[parser->top].state) {
				case 54:
					parser->stack[++parser->top].state = 64;
					break;

				case 62:
					parser->stack[++parser->top].state = 73;
					break;

				case 82:
					parser->stack[++parser->top].state = 86;
					break;

				case 85:
					parser->stack[++parser->top].state = 89;
					break;

				case 88:
					parser->stack[++parser->top].state = 91;
					break;

				case 92:
					parser->stack[++parser->top].state = 93;
					break;

				}
			}
			break;

		case 66:
			switch (token) {
			default:
				parser->top -= 1;
				result.symbol_csymbol = parse_reduce_28(parser->stack[parser->top + 0].value.token.str, grammar);
				parser->stack[parser->top].value.symbol_csymbol = result.symbol_csymbol;
				switch (parser->stack[parser->top].state) {
				case 54:
					parser->stack[++parser->top].state = 64;
					break;

				case 62:
					parser->stack[++parser->top].state = 73;
					break;

				case 82:
					parser->stack[++parser->top].state = 86;
					break;

				case 85:
					parser->stack[++parser->top].state = 89;
					break;

				case 88:
					parser->stack[++parser->top].state = 91;
					break;

				case 92:
					parser->stack[++parser->top].state = 93;
					break;

				}
			}
			break;

		case 67:
			switch (token) {
			case TOK_CHAR:
				parser->stack[++parser->top].state = 75;
				return 1;

			default:
				return -1;
			}
			break;

		case 68:
			switch (token) {
			case 't':
				parser->stack[++parser->top].state = 76;
				return 1;

			default:
				return -1;
			}
			break;

		case 69:
			switch (token) {
			case 'r':
				parser->stack[++parser->top].state = 77;
				return 1;

			default:
				return -1;
			}
			break;

		case 70:
			switch (token) {
			default:
				parser->top -= 8;
				parse_reduce_8(parser->stack[parser->top + 7].value.token.str, grammar);
				delete(parser->stack[parser->top + 7].value.token.str);
				parser->stack[++parser->top].state = 2;
			}
			break;

		case 71:
			switch (token) {
			case 'c':
				parser->stack[++parser->top].state = 78;
				return 1;

			default:
				return -1;
			}
			break;

		case 72:
			switch (token) {
			default:
				parser->top -= 8;
				parse_reduce_7(parser->stack[parser->top + 7].value.token.str, grammar);
				delete(parser->stack[parser->top + 7].value.token.str);
				parser->stack[++parser->top].state = 2;
			}
			break;

		case 73:
			switch (token) {
			default:
				parser->top -= 8;
				parse_reduce_4(parser->stack[parser->top + 5].value.symbol_term, parser->stack[parser->top + 6].value.token.str, parser->stack[parser->top + 7].value.symbol_csymbol, grammar);
				delete(parser->stack[parser->top + 5].value.symbol_term);
				delete(parser->stack[parser->top + 6].value.token.str);
				delete(parser->stack[parser->top + 7].value.symbol_csymbol);
				parser->stack[++parser->top].state = 2;
			}
			break;

		case 74:
			switch (token) {
			default:
				parser->top -= 4;
				result.symbol_variable = parse_reduce_16(parser->stack[parser->top + 1].value.symbol_consume, parser->stack[parser->top + 2].value.symbol_csymbol, grammar);
				delete(parser->stack[parser->top + 2].value.symbol_csymbol);
				parser->stack[parser->top].value.symbol_variable = result.symbol_variable;
				parser->stack[++parser->top].state = 44;
			}
			break;

		case 75:
			switch (token) {
			case ')':
				parser->stack[++parser->top].state = 79;
				return 1;

			default:
				return -1;
			}
			break;

		case 76:
			switch (token) {
			case 'o':
				parser->stack[++parser->top].state = 80;
				return 1;

			default:
				return -1;
			}
			break;

		case 77:
			switch (token) {
			case 'g':
				parser->stack[++parser->top].state = 81;
				return 1;

			default:
				return -1;
			}
			break;

		case 78:
			switch (token) {
			case 'e':
				parser->stack[++parser->top].state = 82;
				return 1;

			default:
				return -1;
			}
			break;

		case 79:
			switch (token) {
			case TOK_BLOCK:
				parser->stack[++parser->top].state = 30;
				return 1;

			case TOK_SQBLOCK:
				parser->stack[++parser->top].state = 32;
				return 1;

			case ';':
				parser->stack[++parser->top].state = 36;
				return 1;

			default:
				return -1;
			}
			break;

		case 80:
			switch (token) {
			case 'r':
				parser->stack[++parser->top].state = 84;
				return 1;

			default:
				return -1;
			}
			break;

		case 81:
			switch (token) {
			case TOK_BLOCK:
				parser->stack[++parser->top].state = 85;
				return 1;

			default:
				return -1;
			}
			break;

		case 82:
			switch (token) {
			case TOK_SYMBOL:
				parser->stack[++parser->top].state = 65;
				return 1;

			case TOK_SYMBOL_UC:
				parser->stack[++parser->top].state = 66;
				return 1;

			default:
				return -1;
			}
			break;

		case 83:
			switch (token) {
			default:
				parser->top -= 11;
				parse_reduce_11(parser->stack[parser->top + 0].value.token.str, parser->stack[parser->top + 4].value.token.c, parser->stack[parser->top + 8].value.token.c, parser->stack[parser->top + 10].value.symbol_action, grammar);
				delete(parser->stack[parser->top + 0].value.token.str);
				delete(parser->stack[parser->top + 10].value.symbol_action);
				parser->stack[++parser->top].state = 2;
			}
			break;

		case 84:
			switch (token) {
			case TOK_CHAR:
				parser->stack[++parser->top].state = 31;
				return 1;

			case TOK_SYMBOL:
				parser->stack[++parser->top].state = 34;
				return 1;

			case TOK_SYMBOL_UC:
				parser->stack[++parser->top].state = 35;
				return 1;

			default:
				return -1;
			}
			break;

		case 85:
			switch (token) {
			case TOK_SYMBOL:
				parser->stack[++parser->top].state = 65;
				return 1;

			case TOK_SYMBOL_UC:
				parser->stack[++parser->top].state = 66;
				return 1;

			default:
				return -1;
			}
			break;

		case 86:
			switch (token) {
			default:
				parser->top -= 1;
				result.symbol_namespace = parse_reduce_22(parser->stack[parser->top + 0].value.symbol_csymbol, grammar);
				delete(parser->stack[parser->top + 0].value.symbol_csymbol);
				parser->stack[parser->top].value.symbol_namespace = result.symbol_namespace;
				parser->stack[++parser->top].state = 87;
			}
			break;

		case 87:
			switch (token) {
			case ':':
				parser->stack[++parser->top].state = 90;
				return 1;

			default:
				parser->top -= 11;
				parse_reduce_6(parser->stack[parser->top + 10].value.symbol_namespace, grammar);
				delete(parser->stack[parser->top + 10].value.symbol_namespace);
				parser->stack[++parser->top].state = 2;
			}
			break;

		case 88:
			switch (token) {
			case TOK_SYMBOL:
				parser->stack[++parser->top].state = 65;
				return 1;

			case TOK_SYMBOL_UC:
				parser->stack[++parser->top].state = 66;
				return 1;

			default:
				return -1;
			}
			break;

		case 89:
			switch (token) {
			default:
				parser->top -= 12;
				parse_reduce_9(parser->stack[parser->top + 10].value.token.str, parser->stack[parser->top + 11].value.symbol_csymbol, grammar);
				delete(parser->stack[parser->top + 10].value.token.str);
				delete(parser->stack[parser->top + 11].value.symbol_csymbol);
				parser->stack[++parser->top].state = 2;
			}
			break;

		case 90:
			switch (token) {
			case ':':
				parser->stack[++parser->top].state = 92;
				return 1;

			default:
				return -1;
			}
			break;

		case 91:
			switch (token) {
			default:
				parser->top -= 13;
				parse_reduce_5(parser->stack[parser->top + 11].value.symbol_symbol, parser->stack[parser->top + 12].value.symbol_csymbol, grammar);
				delete(parser->stack[parser->top + 11].value.symbol_symbol);
				delete(parser->stack[parser->top + 12].value.symbol_csymbol);
				parser->stack[++parser->top].state = 2;
			}
			break;

		case 92:
			switch (token) {
			case TOK_SYMBOL:
				parser->stack[++parser->top].state = 65;
				return 1;

			case TOK_SYMBOL_UC:
				parser->stack[++parser->top].state = 66;
				return 1;

			default:
				return -1;
			}
			break;

		case 93:
			switch (token) {
			default:
				parser->top -= 4;
				result.symbol_namespace = parse_reduce_23(parser->stack[parser->top + 0].value.symbol_namespace, parser->stack[parser->top + 3].value.symbol_csymbol, grammar);
				delete(parser->stack[parser->top + 3].value.symbol_csymbol);
				parser->stack[parser->top].value.symbol_namespace = result.symbol_namespace;
				parser->stack[++parser->top].state = 87;
			}
			break;

		}
	}
}

int parse_push(parse_context_t *parser, int token, const parse_token_value_t *value, __attribute__((unused)) grammar_t *grammar) {
	int ret = parse_do_push(parser, token, grammar);

	if (ret > 0)
		parser->stack[parser->top-1].value.token = *value;

	return ret;
}

}