1367 lines
28 KiB
C++
1367 lines
28 KiB
C++
#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(std::make_pair(*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(std::make_pair(*term, std::make_pair(*type, *name)));
|
|
}
|
|
|
|
static inline void parse_reduce_5(symbol_t *sym, std::string *name, __attribute__((unused)) grammar_t *grammar) {
|
|
grammar->destructors.insert(std::make_pair(*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.push_back(std::make_pair(*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, __attribute__((unused)) grammar_t *grammar) {
|
|
vars_t vars(1);
|
|
|
|
for (unsigned int c = c1; c <= c2; c++)
|
|
grammar->add_rule({item_t(*lhs, {symbol_t::make_char(c)}), vars, std::string()});
|
|
}
|
|
|
|
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;
|
|
parser->stack[++parser->top].state = 27;
|
|
}
|
|
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;
|
|
parser->stack[++parser->top].state = 27;
|
|
}
|
|
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;
|
|
parser->stack[++parser->top].state = 27;
|
|
}
|
|
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 ';':
|
|
parser->stack[++parser->top].state = 83;
|
|
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, grammar);
|
|
delete(parser->stack[parser->top + 0].value.token.str);
|
|
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;
|
|
}
|
|
|
|
}
|