X-Git-Url: https://git.xonotic.org/?a=blobdiff_plain;f=parser.c;h=f11684bb3bb139325a598b8114374db641a0444b;hb=04dca17cffcf250a6f561b8624fe053b96e37f86;hp=892ef2f3c829c5f8efeb4c0d32efdc623689f437;hpb=45388202c418539dc8826d190a14d211136e32a0;p=xonotic%2Fgmqcc.git diff --git a/parser.c b/parser.c index 892ef2f..f11684b 100644 --- a/parser.c +++ b/parser.c @@ -45,12 +45,12 @@ MEM_VEC_FUNCTIONS(parser_t, varentry_t, locals) MEM_VEC_FUNCTIONS(parser_t, ast_function*, functions) static bool GMQCC_WARN parser_pop_local(parser_t *parser); -static bool parser_variable(parser_t *parser, ast_block *localblock); -static ast_block* parser_parse_block(parser_t *parser, bool warnreturn); -static bool parser_parse_block_into(parser_t *parser, ast_block *block, bool warnreturn); -static ast_expression* parser_parse_statement_or_block(parser_t *parser); -static ast_expression* parser_expression_leave(parser_t *parser, bool stopatcomma); -static ast_expression* parser_expression(parser_t *parser, bool stopatcomma); +static bool parse_variable(parser_t *parser, ast_block *localblock); +static ast_block* parse_block(parser_t *parser, bool warnreturn); +static bool parse_block_into(parser_t *parser, ast_block *block, bool warnreturn); +static ast_expression* parse_statement_or_block(parser_t *parser); +static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma); +static ast_expression* parse_expression(parser_t *parser, bool stopatcomma); static void parseerror(parser_t *parser, const char *fmt, ...) { @@ -59,7 +59,7 @@ static void parseerror(parser_t *parser, const char *fmt, ...) parser->errors++; va_start(ap, fmt); - vprintmsg(LVL_ERROR, parser->lex->tok->ctx.file, parser->lex->tok->ctx.line, "parse error", fmt, ap); + vprintmsg(LVL_ERROR, parser->lex->tok.ctx.file, parser->lex->tok.ctx.line, "parse error", fmt, ap); va_end(ap); } @@ -78,7 +78,7 @@ static bool GMQCC_WARN parsewarning(parser_t *parser, int warntype, const char * } va_start(ap, fmt); - vprintmsg(lvl, parser->lex->tok->ctx.file, parser->lex->tok->ctx.line, "warning", fmt, ap); + vprintmsg(lvl, parser->lex->tok.ctx.file, parser->lex->tok.ctx.line, "warning", fmt, ap); va_end(ap); return opts_werror; @@ -155,19 +155,11 @@ bool parser_next(parser_t *parser) return true; } -/* lift a token out of the parser so it's not destroyed by parser_next */ -token *parser_lift(parser_t *parser) -{ - token *tok = parser->lex->tok; - parser->lex->tok = NULL; - return tok; -} - -#define parser_tokval(p) (p->lex->tok->value) -#define parser_token(p) (p->lex->tok) -#define parser_ctx(p) (p->lex->tok->ctx) +#define parser_tokval(p) ((p)->lex->tok.value) +#define parser_token(p) (&((p)->lex->tok)) +#define parser_ctx(p) ((p)->lex->tok.ctx) -ast_value* parser_const_float(parser_t *parser, double d) +static ast_value* parser_const_float(parser_t *parser, double d) { size_t i; ast_value *out; @@ -185,7 +177,7 @@ ast_value* parser_const_float(parser_t *parser, double d) return out; } -ast_value* parser_const_float_0(parser_t *parser) +static ast_value* parser_const_float_0(parser_t *parser) { if (!parser->imm_float_zero) parser->imm_float_zero = parser_const_float(parser, 0); @@ -203,7 +195,7 @@ static char *parser_strdup(const char *str) return util_strdup(str); } -ast_value* parser_const_string(parser_t *parser, const char *str) +static ast_value* parser_const_string(parser_t *parser, const char *str) { size_t i; ast_value *out; @@ -221,7 +213,7 @@ ast_value* parser_const_string(parser_t *parser, const char *str) return out; } -ast_value* parser_const_vector(parser_t *parser, vector v) +static ast_value* parser_const_vector(parser_t *parser, vector v) { size_t i; ast_value *out; @@ -239,7 +231,7 @@ ast_value* parser_const_vector(parser_t *parser, vector v) return out; } -ast_value* parser_const_vector_f(parser_t *parser, float x, float y, float z) +static ast_value* parser_const_vector_f(parser_t *parser, float x, float y, float z) { vector v; v.x = x; @@ -248,14 +240,14 @@ ast_value* parser_const_vector_f(parser_t *parser, float x, float y, float z) return parser_const_vector(parser, v); } -ast_value* parser_const_vector_0(parser_t *parser) +static ast_value* parser_const_vector_0(parser_t *parser) { if (!parser->imm_vector_zero) parser->imm_vector_zero = parser_const_vector_f(parser, 0, 0, 0); return parser->imm_vector_zero; } -ast_expression* parser_find_field(parser_t *parser, const char *name) +static ast_expression* parser_find_field(parser_t *parser, const char *name) { size_t i; for (i = 0; i < parser->fields_count; ++i) { @@ -265,7 +257,7 @@ ast_expression* parser_find_field(parser_t *parser, const char *name) return NULL; } -ast_expression* parser_find_global(parser_t *parser, const char *name) +static ast_expression* parser_find_global(parser_t *parser, const char *name) { size_t i; for (i = 0; i < parser->globals_count; ++i) { @@ -275,7 +267,7 @@ ast_expression* parser_find_global(parser_t *parser, const char *name) return NULL; } -ast_expression* parser_find_param(parser_t *parser, const char *name) +static ast_expression* parser_find_param(parser_t *parser, const char *name) { size_t i; ast_value *fun; @@ -289,7 +281,7 @@ ast_expression* parser_find_param(parser_t *parser, const char *name) return NULL; } -ast_expression* parser_find_local(parser_t *parser, const char *name, size_t upto, bool *isparam) +static ast_expression* parser_find_local(parser_t *parser, const char *name, size_t upto, bool *isparam) { size_t i; *isparam = false; @@ -302,7 +294,7 @@ ast_expression* parser_find_local(parser_t *parser, const char *name, size_t upt return parser_find_param(parser, name); } -ast_expression* parser_find_var(parser_t *parser, const char *name) +static ast_expression* parser_find_var(parser_t *parser, const char *name) { bool dummy; ast_expression *v; @@ -316,7 +308,7 @@ typedef struct { } paramlist_t; MEM_VEC_FUNCTIONS(paramlist_t, ast_value*, p) -static ast_value *parser_parse_type(parser_t *parser, int basetype, bool *isfunc) +static ast_value *parse_type(parser_t *parser, int basetype, bool *isfunc) { paramlist_t params; ast_value *var; @@ -372,7 +364,7 @@ static ast_value *parser_parse_type(parser_t *parser, int basetype, bool *isfunc if (!parser_next(parser)) goto on_error; - param = parser_parse_type(parser, temptype, &isfuncparam); + param = parse_type(parser, temptype, &isfuncparam); if (!param) goto on_error; @@ -1071,7 +1063,7 @@ static void parser_reclassify_token(parser_t *parser) } } -static ast_expression* parser_expression_leave(parser_t *parser, bool stopatcomma) +static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma) { ast_expression *expr = NULL; shunt sy; @@ -1359,9 +1351,9 @@ onerr: return NULL; } -static ast_expression* parser_expression(parser_t *parser, bool stopatcomma) +static ast_expression* parse_expression(parser_t *parser, bool stopatcomma) { - ast_expression *e = parser_expression_leave(parser, stopatcomma); + ast_expression *e = parse_expression_leave(parser, stopatcomma); if (!e) return NULL; if (!parser_next(parser)) { @@ -1371,7 +1363,7 @@ static ast_expression* parser_expression(parser_t *parser, bool stopatcomma) return e; } -static bool parser_parse_if(parser_t *parser, ast_block *block, ast_expression **out) +static bool parse_if(parser_t *parser, ast_block *block, ast_expression **out) { ast_ifthen *ifthen; ast_expression *cond, *ontrue, *onfalse = NULL; @@ -1389,7 +1381,7 @@ static bool parser_parse_if(parser_t *parser, ast_block *block, ast_expression * return false; } /* parse the condition */ - cond = parser_expression_leave(parser, false); + cond = parse_expression_leave(parser, false); if (!cond) return false; /* closing paren */ @@ -1404,7 +1396,7 @@ static bool parser_parse_if(parser_t *parser, ast_block *block, ast_expression * ast_delete(cond); return false; } - ontrue = parser_parse_statement_or_block(parser); + ontrue = parse_statement_or_block(parser); if (!ontrue) { ast_delete(cond); return false; @@ -1418,7 +1410,7 @@ static bool parser_parse_if(parser_t *parser, ast_block *block, ast_expression * ast_delete(cond); return false; } - onfalse = parser_parse_statement_or_block(parser); + onfalse = parse_statement_or_block(parser); if (!onfalse) { ast_delete(ontrue); ast_delete(cond); @@ -1431,7 +1423,7 @@ static bool parser_parse_if(parser_t *parser, ast_block *block, ast_expression * return true; } -static bool parser_parse_while(parser_t *parser, ast_block *block, ast_expression **out) +static bool parse_while(parser_t *parser, ast_block *block, ast_expression **out) { ast_loop *aloop; ast_expression *cond, *ontrue; @@ -1449,7 +1441,7 @@ static bool parser_parse_while(parser_t *parser, ast_block *block, ast_expressio return false; } /* parse the condition */ - cond = parser_expression_leave(parser, false); + cond = parse_expression_leave(parser, false); if (!cond) return false; /* closing paren */ @@ -1464,7 +1456,7 @@ static bool parser_parse_while(parser_t *parser, ast_block *block, ast_expressio ast_delete(cond); return false; } - ontrue = parser_parse_statement_or_block(parser); + ontrue = parse_statement_or_block(parser); if (!ontrue) { ast_delete(cond); return false; @@ -1475,7 +1467,7 @@ static bool parser_parse_while(parser_t *parser, ast_block *block, ast_expressio return true; } -static bool parser_parse_dowhile(parser_t *parser, ast_block *block, ast_expression **out) +static bool parse_dowhile(parser_t *parser, ast_block *block, ast_expression **out) { ast_loop *aloop; ast_expression *cond, *ontrue; @@ -1487,7 +1479,7 @@ static bool parser_parse_dowhile(parser_t *parser, ast_block *block, ast_express parseerror(parser, "expected loop body"); return false; } - ontrue = parser_parse_statement_or_block(parser); + ontrue = parse_statement_or_block(parser); if (!ontrue) return false; @@ -1513,7 +1505,7 @@ static bool parser_parse_dowhile(parser_t *parser, ast_block *block, ast_express return false; } /* parse the condition */ - cond = parser_expression_leave(parser, false); + cond = parse_expression_leave(parser, false); if (!cond) return false; /* closing paren */ @@ -1543,7 +1535,7 @@ static bool parser_parse_dowhile(parser_t *parser, ast_block *block, ast_express return true; } -static bool parser_parse_for(parser_t *parser, ast_block *block, ast_expression **out) +static bool parse_for(parser_t *parser, ast_block *block, ast_expression **out) { ast_loop *aloop; ast_expression *initexpr, *cond, *increment, *ontrue; @@ -1580,12 +1572,12 @@ static bool parser_parse_for(parser_t *parser, ast_block *block, ast_expression parseerror(parser, "TODO: assignment of new variables to be non-const"); goto onerr; - if (!parser_variable(parser, block)) + if (!parse_variable(parser, block)) goto onerr; } else if (parser->tok != ';') { - initexpr = parser_expression_leave(parser, false); + initexpr = parse_expression_leave(parser, false); if (!initexpr) goto onerr; } @@ -1602,7 +1594,7 @@ static bool parser_parse_for(parser_t *parser, ast_block *block, ast_expression /* parse the condition */ if (parser->tok != ';') { - cond = parser_expression_leave(parser, false); + cond = parse_expression_leave(parser, false); if (!cond) goto onerr; } @@ -1619,9 +1611,16 @@ static bool parser_parse_for(parser_t *parser, ast_block *block, ast_expression /* parse the incrementor */ if (parser->tok != ')') { - increment = parser_expression_leave(parser, false); + increment = parse_expression_leave(parser, false); if (!increment) goto onerr; + if (!ast_istype(increment, ast_store) && + !ast_istype(increment, ast_call) && + !ast_istype(increment, ast_binstore)) + { + if (genwarning(ast_ctx(increment), WARN_EFFECTLESS_STATEMENT, "statement has no effect")) + goto onerr; + } } /* closing paren */ @@ -1634,7 +1633,7 @@ static bool parser_parse_for(parser_t *parser, ast_block *block, ast_expression parseerror(parser, "expected for-loop body"); goto onerr; } - ontrue = parser_parse_statement_or_block(parser); + ontrue = parse_statement_or_block(parser); if (!ontrue) { goto onerr; } @@ -1656,7 +1655,7 @@ onerr: return false; } -static bool parser_parse_statement(parser_t *parser, ast_block *block, ast_expression **out) +static bool parse_statement(parser_t *parser, ast_block *block, ast_expression **out) { if (parser->tok == TOKEN_TYPENAME) { @@ -1669,7 +1668,7 @@ static bool parser_parse_statement(parser_t *parser, ast_block *block, ast_expre if (parsewarning(parser, WARN_EXTENSIONS, "missing 'local' keyword when declaring a local variable")) return false; } - if (!parser_variable(parser, block)) + if (!parse_variable(parser, block)) return false; *out = NULL; return true; @@ -1686,7 +1685,7 @@ static bool parser_parse_statement(parser_t *parser, ast_block *block, ast_expre parseerror(parser, "expected variable declaration"); return false; } - if (!parser_variable(parser, block)) + if (!parse_variable(parser, block)) return false; *out = NULL; return true; @@ -1703,7 +1702,7 @@ static bool parser_parse_statement(parser_t *parser, ast_block *block, ast_expre } if (parser->tok != ';') { - exp = parser_expression(parser, false); + exp = parse_expression(parser, false); if (!exp) return false; @@ -1732,15 +1731,15 @@ static bool parser_parse_statement(parser_t *parser, ast_block *block, ast_expre } else if (!strcmp(parser_tokval(parser), "if")) { - return parser_parse_if(parser, block, out); + return parse_if(parser, block, out); } else if (!strcmp(parser_tokval(parser), "while")) { - return parser_parse_while(parser, block, out); + return parse_while(parser, block, out); } else if (!strcmp(parser_tokval(parser), "do")) { - return parser_parse_dowhile(parser, block, out); + return parse_dowhile(parser, block, out); } else if (!strcmp(parser_tokval(parser), "for")) { @@ -1748,7 +1747,7 @@ static bool parser_parse_statement(parser_t *parser, ast_block *block, ast_expre if (parsewarning(parser, WARN_EXTENSIONS, "for loops are not recognized in the original Quake C standard, to enable try an alternate standard --std=?")) return false; } - return parser_parse_for(parser, block, out); + return parse_for(parser, block, out); } parseerror(parser, "Unexpected keyword"); return false; @@ -1756,7 +1755,7 @@ static bool parser_parse_statement(parser_t *parser, ast_block *block, ast_expre else if (parser->tok == '{') { ast_block *inner; - inner = parser_parse_block(parser, false); + inner = parse_block(parser, false); if (!inner) return false; *out = (ast_expression*)inner; @@ -1764,7 +1763,7 @@ static bool parser_parse_statement(parser_t *parser, ast_block *block, ast_expre } else { - ast_expression *exp = parser_expression(parser, false); + ast_expression *exp = parse_expression(parser, false); if (!exp) return false; *out = exp; @@ -1772,7 +1771,7 @@ static bool parser_parse_statement(parser_t *parser, ast_block *block, ast_expre !ast_istype(exp, ast_call) && !ast_istype(exp, ast_binstore)) { - if (parsewarning(parser, WARN_EFFECTLESS_STATEMENT, "statement has no effect")) + if (genwarning(ast_ctx(exp), WARN_EFFECTLESS_STATEMENT, "statement has no effect")) return false; } return true; @@ -1793,7 +1792,7 @@ static bool GMQCC_WARN parser_pop_local(parser_t *parser) return true; } -static bool parser_parse_block_into(parser_t *parser, ast_block *block, bool warnreturn) +static bool parse_block_into(parser_t *parser, ast_block *block, bool warnreturn) { size_t oldblocklocal; bool retval = true; @@ -1812,7 +1811,7 @@ static bool parser_parse_block_into(parser_t *parser, ast_block *block, bool war if (parser->tok == '}') break; - if (!parser_parse_statement(parser, block, &expr)) { + if (!parse_statement(parser, block, &expr)) { parseerror(parser, "parse error"); block = NULL; goto cleanup; @@ -1850,105 +1849,404 @@ cleanup: return !!block; } -static ast_block* parser_parse_block(parser_t *parser, bool warnreturn) +static ast_block* parse_block(parser_t *parser, bool warnreturn) { ast_block *block; block = ast_block_new(parser_ctx(parser)); if (!block) return NULL; - if (!parser_parse_block_into(parser, block, warnreturn)) { + if (!parse_block_into(parser, block, warnreturn)) { ast_block_delete(block); return NULL; } return block; } -static ast_expression* parser_parse_statement_or_block(parser_t *parser) +static ast_expression* parse_statement_or_block(parser_t *parser) { ast_expression *expr = NULL; if (parser->tok == '{') - return (ast_expression*)parser_parse_block(parser, false); - if (!parser_parse_statement(parser, NULL, &expr)) + return (ast_expression*)parse_block(parser, false); + if (!parse_statement(parser, NULL, &expr)) return NULL; return expr; } -static bool create_vector_members(parser_t *parser, ast_value *var, - varentry_t *vx, varentry_t *vy, varentry_t *vz) +/* loop method */ +static bool create_vector_members(parser_t *parser, ast_value *var, varentry_t *ve) { + size_t i; size_t len = strlen(var->name); - vx->var = (ast_expression*)ast_member_new(ast_ctx(var), (ast_expression*)var, 0); - if (!vx->var) { - parseerror(parser, "failed to create vector members (out of memory)"); - return false; + + for (i = 0; i < 3; ++i) { + ve[i].var = (ast_expression*)ast_member_new(ast_ctx(var), (ast_expression*)var, i); + if (!ve[i].var) + break; + + ve[i].name = (char*)mem_a(len+3); + if (!ve[i].name) { + ast_delete(ve[i].var); + break; + } + + memcpy(ve[i].name, var->name, len); + ve[i].name[len] = '_'; + ve[i].name[len+1] = 'x'+i; + ve[i].name[len+2] = 0; } + if (i == 3) + return true; - vy->var = (ast_expression*)ast_member_new(ast_ctx(var), (ast_expression*)var, 1); - if (!vy->var) { - ast_delete(vx->var); - parseerror(parser, "failed to create vector members (out of memory)"); - return false; + /* unroll */ + do { + --i; + mem_d(ve[i].name); + ast_delete(ve[i].var); + ve[i].name = NULL; + ve[i].var = NULL; + } while (i); + return false; +} + +static bool parse_function_body(parser_t *parser, ast_value *var) +{ + ast_block *block = NULL; + ast_function *func; + ast_function *old; + size_t parami; + + ast_expression *framenum = NULL; + ast_expression *nextthink = NULL; + /* None of the following have to be deleted */ + ast_expression *fld_think, *fld_nextthink, *fld_frame; + ast_expression *gbl_time, *gbl_self; + bool has_frame_think; + + bool retval = true; + + has_frame_think = false; + old = parser->function; + + if (var->expression.variadic) { + if (parsewarning(parser, WARN_VARIADIC_FUNCTION, + "variadic function with implementation will not be able to access additional parameters")) + { + return false; + } } - vz->var = (ast_expression*)ast_member_new(ast_ctx(var), (ast_expression*)var, 2); - if (!vz->var) { - ast_delete(vy->var); - ast_delete(vx->var); - parseerror(parser, "failed to create vector members (out of memory)"); - return false; + if (parser->tok == '[') { + /* got a frame definition: [ framenum, nextthink ] + * this translates to: + * self.frame = framenum; + * self.nextthink = time + 0.1; + * self.think = nextthink; + */ + nextthink = NULL; + + fld_think = parser_find_field(parser, "think"); + fld_nextthink = parser_find_field(parser, "nextthink"); + fld_frame = parser_find_field(parser, "frame"); + if (!fld_think || !fld_nextthink || !fld_frame) { + parseerror(parser, "cannot use [frame,think] notation without the required fields"); + parseerror(parser, "please declare the following entityfields: `frame`, `think`, `nextthink`"); + return false; + } + gbl_time = parser_find_global(parser, "time"); + gbl_self = parser_find_global(parser, "self"); + if (!gbl_time || !gbl_self) { + parseerror(parser, "cannot use [frame,think] notation without the required globals"); + parseerror(parser, "please declare the following globals: `time`, `self`"); + return false; + } + + if (!parser_next(parser)) + return false; + + framenum = parse_expression_leave(parser, true); + if (!framenum) { + parseerror(parser, "expected a framenumber constant in[frame,think] notation"); + return false; + } + if (!ast_istype(framenum, ast_value) || !( (ast_value*)framenum )->isconst) { + ast_unref(framenum); + parseerror(parser, "framenumber in [frame,think] notation must be a constant"); + return false; + } + + if (parser->tok != ',') { + ast_unref(framenum); + parseerror(parser, "expected comma after frame number in [frame,think] notation"); + parseerror(parser, "Got a %i\n", parser->tok); + return false; + } + + if (!parser_next(parser)) { + ast_unref(framenum); + return false; + } + + if (parser->tok == TOKEN_IDENT && !parser_find_var(parser, parser_tokval(parser))) + { + /* qc allows the use of not-yet-declared functions here + * - this automatically creates a prototype */ + varentry_t varent; + ast_value *thinkfunc; + ast_expression *functype = fld_think->expression.next; + + thinkfunc = ast_value_new(parser_ctx(parser), parser_tokval(parser), functype->expression.vtype); + if (!thinkfunc || !ast_type_adopt(thinkfunc, functype)) { + ast_unref(framenum); + parseerror(parser, "failed to create implicit prototype for `%s`", parser_tokval(parser)); + return false; + } + + if (!parser_next(parser)) { + ast_unref(framenum); + ast_delete(thinkfunc); + return false; + } + + varent.var = (ast_expression*)thinkfunc; + varent.name = util_strdup(thinkfunc->name); + if (!parser_t_globals_add(parser, varent)) { + ast_unref(framenum); + ast_delete(thinkfunc); + return false; + } + nextthink = (ast_expression*)thinkfunc; + + } else { + nextthink = parse_expression_leave(parser, true); + if (!nextthink) { + ast_unref(framenum); + parseerror(parser, "expected a think-function in [frame,think] notation"); + return false; + } + } + + if (!ast_istype(nextthink, ast_value)) { + parseerror(parser, "think-function in [frame,think] notation must be a constant"); + retval = false; + } + + if (retval && parser->tok != ']') { + parseerror(parser, "expected closing `]` for [frame,think] notation"); + retval = false; + } + + if (retval && !parser_next(parser)) { + retval = false; + } + + if (retval && parser->tok != '{') { + parseerror(parser, "a function body has to be declared after a [frame,think] declaration"); + retval = false; + } + + if (!retval) { + ast_unref(nextthink); + ast_unref(framenum); + return false; + } + + has_frame_think = true; } - if ( !(vx->name = (char*)mem_a(len+3)) ) { - ast_delete(vz->var); - ast_delete(vy->var); - ast_delete(vx->var); - parseerror(parser, "failed to create vector members (out of memory)"); + block = ast_block_new(parser_ctx(parser)); + if (!block) { + parseerror(parser, "failed to allocate block"); + if (has_frame_think) { + ast_unref(nextthink); + ast_unref(framenum); + } return false; } - if ( !(vy->name = (char*)mem_a(len+3)) ) { - mem_d(vx->name); - ast_delete(vz->var); - ast_delete(vy->var); - ast_delete(vx->var); - parseerror(parser, "failed to create vector members (out of memory)"); - return false; + + if (has_frame_think) { + lex_ctx ctx; + ast_expression *self_frame; + ast_expression *self_nextthink; + ast_expression *self_think; + ast_expression *time_plus_1; + ast_store *store_frame; + ast_store *store_nextthink; + ast_store *store_think; + + ctx = parser_ctx(parser); + self_frame = (ast_expression*)ast_entfield_new(ctx, gbl_self, fld_frame); + self_nextthink = (ast_expression*)ast_entfield_new(ctx, gbl_self, fld_nextthink); + self_think = (ast_expression*)ast_entfield_new(ctx, gbl_self, fld_think); + + time_plus_1 = (ast_expression*)ast_binary_new(ctx, INSTR_ADD_F, + gbl_time, (ast_expression*)parser_const_float(parser, 0.1)); + + if (!self_frame || !self_nextthink || !self_think || !time_plus_1) { + if (self_frame) ast_delete(self_frame); + if (self_nextthink) ast_delete(self_nextthink); + if (self_think) ast_delete(self_think); + if (time_plus_1) ast_delete(time_plus_1); + retval = false; + } + + if (retval) + { + store_frame = ast_store_new(ctx, INSTR_STOREP_F, self_frame, framenum); + store_nextthink = ast_store_new(ctx, INSTR_STOREP_F, self_nextthink, time_plus_1); + store_think = ast_store_new(ctx, INSTR_STOREP_FNC, self_think, nextthink); + + if (!store_frame) { + ast_delete(self_frame); + retval = false; + } + if (!store_nextthink) { + ast_delete(self_nextthink); + retval = false; + } + if (!store_think) { + ast_delete(self_think); + retval = false; + } + if (!retval) { + if (store_frame) ast_delete(store_frame); + if (store_nextthink) ast_delete(store_nextthink); + if (store_think) ast_delete(store_think); + retval = false; + } + if (retval && !ast_block_exprs_add(block, (ast_expression*)store_frame)) { + ast_delete(store_frame); + ast_delete(store_nextthink); + ast_delete(store_think); + retval = false; + } + + if (retval && !ast_block_exprs_add(block, (ast_expression*)store_nextthink)) { + ast_delete(store_nextthink); + ast_delete(store_think); + retval = false; + } + + if (retval && !ast_block_exprs_add(block, (ast_expression*)store_think) ) + { + ast_delete(store_think); + retval = false; + } + } + + if (!retval) { + parseerror(parser, "failed to generate code for [frame,think]"); + ast_unref(nextthink); + ast_unref(framenum); + ast_delete(block); + return false; + } } - if ( !(vz->name = (char*)mem_a(len+3)) ) { - mem_d(vy->name); - mem_d(vx->name); - ast_delete(vz->var); - ast_delete(vy->var); - ast_delete(vx->var); - parseerror(parser, "failed to create vector members (out of memory)"); - return false; + + for (parami = 0; parami < var->expression.params_count; ++parami) { + size_t e; + varentry_t ve[3]; + ast_value *param = var->expression.params[parami]; + + if (param->expression.vtype != TYPE_VECTOR && + (param->expression.vtype != TYPE_FIELD || + param->expression.next->expression.vtype != TYPE_VECTOR)) + { + continue; + } + + if (!create_vector_members(parser, param, ve)) { + ast_block_delete(block); + return false; + } + + for (e = 0; e < 3; ++e) { + if (!parser_t_locals_add(parser, ve[e])) + break; + if (!ast_block_collect(block, ve[e].var)) { + parser->locals_count--; + break; + } + ve[e].var = NULL; /* collected */ + } + if (e != e) { + parser->locals -= e; + do { + mem_d(ve[e].name); + --e; + } while (e); + ast_block_delete(block); + return false; + } } - memcpy(vx->name, var->name, len); - memcpy(vy->name, var->name, len); - memcpy(vz->name, var->name, len); - vx->name[len] = vy->name[len] = vz->name[len] = '_'; - vx->name[len+1] = 'x'; - vy->name[len+1] = 'y'; - vz->name[len+1] = 'z'; - vx->name[len+2] = vy->name[len+2] = vz->name[len+2] = 0; - return true; + func = ast_function_new(ast_ctx(var), var->name, var); + if (!func) { + parseerror(parser, "failed to allocate function for `%s`", var->name); + ast_block_delete(block); + goto enderr; + } + if (!parser_t_functions_add(parser, func)) { + parseerror(parser, "failed to allocate slot for function `%s`", var->name); + ast_block_delete(block); + goto enderrfn; + } + + parser->function = func; + if (!parse_block_into(parser, block, true)) { + ast_block_delete(block); + goto enderrfn; + } + + if (!ast_function_blocks_add(func, block)) { + ast_block_delete(block); + goto enderrfn; + } + + parser->function = old; + while (parser->locals_count) + retval = retval && parser_pop_local(parser); + + if (parser->tok == ';') + return parser_next(parser); + else if (opts_standard == COMPILER_QCC) + parseerror(parser, "missing semicolon after function body (mandatory with -std=qcc)"); + return retval; + +enderrfn: + ast_function_delete(func); + var->constval.vfunc = NULL; + +enderr: + while (parser->locals_count) { + parser->locals_count--; + mem_d(parser->locals[parser->locals_count].name); + } + parser->function = old; + return false; } -static bool parser_variable(parser_t *parser, ast_block *localblock) +static bool parse_variable(parser_t *parser, ast_block *localblock) { - bool isfunc = false; - lex_ctx ctx; - ast_value *var; - varentry_t varent; + bool isfunc = false; + lex_ctx ctx; + + ast_value *var = NULL; + bool cleanvar = false; + + varentry_t varent; + varentry_t ve[3]; + ast_expression *olddecl; - ast_value *typevar; + ast_value *typevar; bool hadproto; bool isparam; bool retval = true; + /* go */ + int basetype = parser_token(parser)->constval.t; if (!parser_next(parser)) { @@ -1956,39 +2254,42 @@ static bool parser_variable(parser_t *parser, ast_block *localblock) return false; } - typevar = parser_parse_type(parser, basetype, &isfunc); + typevar = parse_type(parser, basetype, &isfunc); if (!typevar) return false; while (true) { - hadproto = false; - olddecl = NULL; - isparam = false; + hadproto = false; + olddecl = NULL; + isparam = false; + varent.name = NULL; + + ve[0].name = ve[1].name = ve[2].name = NULL; + ve[0].var = ve[1].var = ve[2].var = NULL; ctx = parser_ctx(parser); var = ast_value_copy(typevar); + cleanvar = true; if (!var) { - ast_delete(typevar); parseerror(parser, "failed to create variable"); - return false; + retval = false; + goto cleanup; } if (parser->tok != TOKEN_IDENT) { parseerror(parser, "expected variable name"); - ast_value_delete(typevar); - ast_value_delete(var); - return false; + retval = false; + goto cleanup; } if (!isfunc) { if (!localblock && (olddecl = parser_find_global(parser, parser_tokval(parser)))) { - ast_value_delete(typevar); - ast_value_delete(var); parseerror(parser, "global `%s` already declared here: %s:%i", parser_tokval(parser), ast_ctx(olddecl).file, (int)ast_ctx(olddecl).line); - return false; + retval = false; + goto cleanup; } if (localblock) { @@ -1998,24 +2299,24 @@ static bool parser_variable(parser_t *parser, ast_block *localblock) if (olddecl) { if (!isparam) { - ast_value_delete(typevar); - ast_value_delete(var); parseerror(parser, "local `%s` already declared here: %s:%i", parser_tokval(parser), ast_ctx(olddecl).file, (int)ast_ctx(olddecl).line); - return false; + retval = false; + goto cleanup; } } - if( (!isparam && olddecl) || (olddecl = parser_find_local(parser, parser_tokval(parser), 0, &isparam)) ) + if( (!isparam && olddecl) || + (olddecl = parser_find_local(parser, parser_tokval(parser), 0, &isparam)) + ) { if (parsewarning(parser, WARN_LOCAL_SHADOWS, "local `%s` is shadowing a parameter", parser_tokval(parser))) { - ast_value_delete(typevar); - ast_value_delete(var); parseerror(parser, "local `%s` already declared here: %s:%i", parser_tokval(parser), ast_ctx(olddecl).file, (int)ast_ctx(olddecl).line); - return false; + retval = false; + goto cleanup; } } } @@ -2024,21 +2325,20 @@ static bool parser_variable(parser_t *parser, ast_block *localblock) if (olddecl) { ast_value_delete(var); + var = NULL; if (isparam && parsewarning(parser, WARN_LOCAL_SHADOWS, "a parameter is shadowing local `%s`", parser_tokval(parser))) { - ast_value_delete(typevar); - ast_value_delete(var); - return false; + retval = false; + goto cleanup; } else if (!isparam) { parseerror(parser, "local `%s` already declared here: %s:%i", parser_tokval(parser), ast_ctx(olddecl).file, (int)ast_ctx(olddecl).line); - ast_value_delete(typevar); - ast_value_delete(var); - return false; + retval = false; + goto cleanup; } goto nextvar; } @@ -2048,9 +2348,8 @@ static bool parser_variable(parser_t *parser, ast_block *localblock) if (!ast_value_set_name(var, parser_tokval(parser))) { parseerror(parser, "failed to set variable name\n"); - ast_value_delete(typevar); - ast_value_delete(var); - return false; + retval = false; + goto cleanup; } if (isfunc) { @@ -2067,16 +2366,13 @@ static bool parser_variable(parser_t *parser, ast_block *localblock) if (olddecl) { /* we had a prototype */ if (!ast_istype(olddecl, ast_value)) { - /* theoretically not possible you think? - * well: - * vector v; + /* vector v; * void() v_x = {} - * got it? */ parseerror(parser, "cannot declare a function with the same name as a vector's member: %s", parser_tokval(parser)); - ast_value_delete(var); - return false; + retval = false; + goto cleanup; } proto = (ast_value*)olddecl; @@ -2087,15 +2383,14 @@ static bool parser_variable(parser_t *parser, ast_block *localblock) */ fval = ast_value_new(ctx, var->name, TYPE_FUNCTION); if (!fval) { - ast_value_delete(var); - ast_value_delete(typevar); - if (fval) ast_value_delete(fval); - return false; + retval = false; + goto cleanup; } fval->expression.next = (ast_expression*)var; MEM_VECTOR_MOVE(&var->expression, params, &fval->expression, params); fval->expression.variadic = var->expression.variadic; + var = NULL; /* we compare the type late here, but it's easier than * messing with the parameter-vector etc. earlier @@ -2107,8 +2402,8 @@ static bool parser_variable(parser_t *parser, ast_block *localblock) proto->name, ast_ctx(proto).file, ast_ctx(proto).line); ast_value_delete(fval); - ast_value_delete(typevar); - return false; + retval = false; + goto cleanup; } /* copy over the parameter names */ for (param = 0; param < fval->expression.params_count; ++param) @@ -2128,82 +2423,76 @@ static bool parser_variable(parser_t *parser, ast_block *localblock) if (!hadproto) { varent.name = util_strdup(var->name); varent.var = (ast_expression*)var; + + if (!localblock) { + if (!(retval = parser_t_globals_add(parser, varent))) + goto cleanup; + } else { + if (!(retval = parser_t_locals_add(parser, varent))) + goto cleanup; + if (!(retval = ast_block_locals_add(localblock, var))) { + parser->locals_count--; + goto cleanup; + } + } + if (var->expression.vtype == TYPE_VECTOR) { - varentry_t vx, vy, vz; - if (!create_vector_members(parser, var, &vx, &vy, &vz)) { - ast_delete(var); - ast_value_delete(typevar); - return false; + size_t e; + if (!create_vector_members(parser, var, ve)) { + retval = false; + goto cleanup; } if (!localblock) { - (void)!parser_t_globals_add(parser, varent); - (void)!parser_t_globals_add(parser, vx); - (void)!parser_t_globals_add(parser, vy); - (void)!parser_t_globals_add(parser, vz); + for (e = 0; e < 3; ++e) { + if (!(retval = parser_t_globals_add(parser, ve[e]))) + break; + } + if (!retval) { + parser->globals_count -= e+1; + goto cleanup; + } } else { - (void)!parser_t_locals_add(parser, varent); - (void)!parser_t_locals_add(parser, vx); - (void)!parser_t_locals_add(parser, vy); - (void)!parser_t_locals_add(parser, vz); - if (!ast_block_locals_add(localblock, var) || - !ast_block_collect(localblock, vx.var) || - !ast_block_collect(localblock, vy.var) || - !ast_block_collect(localblock, vz.var)) - { - (void)!parser_pop_local(parser); - (void)!parser_pop_local(parser); - (void)!parser_pop_local(parser); - (void)!parser_pop_local(parser); - ast_value_delete(var); - ast_value_delete(typevar); - return false; + for (e = 0; e < 3; ++e) { + if (!(retval = parser_t_locals_add(parser, ve[e]))) + break; + if (!(retval = ast_block_collect(localblock, ve[e].var))) + break; + ve[e].var = NULL; /* from here it's being collected in the block */ + } + if (!retval) { + parser->locals_count -= e+1; + localblock->locals_count--; + goto cleanup; } } + ve[0].name = ve[1].name = ve[2].name = NULL; + ve[0].var = ve[1].var = ve[2].var = NULL; } - else - { - if ( (!localblock && !parser_t_globals_add(parser, varent)) || - ( localblock && !parser_t_locals_add(parser, varent)) ) - { - ast_value_delete(var); - ast_value_delete(typevar); - return false; - } - if (localblock && !ast_block_locals_add(localblock, var)) - { - (void)!parser_pop_local(parser); - ast_value_delete(var); - ast_value_delete(typevar); - return false; - } - } + cleanvar = false; + varent.name = NULL; } nextvar: - if (!parser_next(parser)) { - ast_value_delete(typevar); - ast_value_delete(var); - return false; - } + if (!(retval = parser_next(parser))) + goto cleanup; if (parser->tok == ';') { ast_value_delete(typevar); - if (!parser_next(parser)) - return false; - return true; + return parser_next(parser); } if (parser->tok == ',') { /* another var */ - if (!parser_next(parser)) { - ast_delete(typevar); - return false; - } + if (!(retval = parser_next(parser))) + goto cleanup; continue; } + /* NOTE: only 'typevar' needs to be deleted from here on, so 'cleanup' won't be used + * to avoid having too many gotos + */ if (localblock && opts_standard == COMPILER_QCC) { if (parsewarning(parser, WARN_LOCAL_CONSTANTS, "initializing expression turns variable `%s` into a constant in this standard", @@ -2215,8 +2504,11 @@ nextvar: } if (parser->tok != '=') { + if (opts_standard == COMPILER_QCC) + parseerror(parser, "missing semicolon"); + else + parseerror(parser, "missing semicolon or initializer"); ast_value_delete(typevar); - parseerror(parser, "expected '=' or ';'"); return false; } @@ -2274,288 +2566,24 @@ nextvar: ast_value_delete(typevar); return false; } - } else if (parser->tok == '{' || parser->tok == '[') { - /* function body */ - ast_function *func; - ast_function *old; - ast_block *block; - size_t parami; - - ast_expression *fld_think, *fld_nextthink, *fld_frame; - ast_expression *gbl_time, *gbl_self; - ast_expression *framenum, *nextthink; - bool has_frame_think; - - has_frame_think = false; - old = parser->function; - - if (var->expression.variadic) { - if (parsewarning(parser, WARN_VARIADIC_FUNCTION, - "variadic function with implementation will not be able to access additional parameters")) - { - ast_value_delete(typevar); - return false; - } - } - + } + else if (parser->tok == '{' || parser->tok == '[') + { + ast_value_delete(typevar); if (localblock) { parseerror(parser, "cannot declare functions within functions"); - ast_value_delete(typevar); - return false; - } - - if (parser->tok == '[') { - /* got a frame definition: [ framenum, nextthink ] - * this translates to: - * self.frame = framenum; - * self.nextthink = time + 0.1; - * self.think = nextthink; - */ - nextthink = NULL; - - fld_think = parser_find_field(parser, "think"); - fld_nextthink = parser_find_field(parser, "nextthink"); - fld_frame = parser_find_field(parser, "frame"); - if (!fld_think || !fld_nextthink || !fld_frame) { - parseerror(parser, "cannot use [frame,think] notation without the required fields"); - parseerror(parser, "please declare the following entityfields: `frame`, `think`, `nextthink`"); - ast_value_delete(typevar); - return false; - } - gbl_time = parser_find_global(parser, "time"); - gbl_self = parser_find_global(parser, "self"); - if (!gbl_time || !gbl_self) { - parseerror(parser, "cannot use [frame,think] notation without the required globals"); - parseerror(parser, "please declare the following globals: `time`, `self`"); - ast_value_delete(typevar); - return false; - } - - if (!parser_next(parser)) { - ast_value_delete(typevar); - return false; - } - - framenum = parser_expression_leave(parser, true); - if (!framenum) { - parseerror(parser, "expected a framenumber constant in[frame,think] notation"); - ast_value_delete(typevar); - return false; - } - if (!ast_istype(framenum, ast_value) || !( (ast_value*)framenum )->isconst) { - ast_unref(framenum); - parseerror(parser, "framenumber in [frame,think] notation must be a constant"); - } - - if (parser->tok != ',') { - ast_unref(framenum); - parseerror(parser, "expected comma after frame number in [frame,think] notation"); - parseerror(parser, "Got a %i\n", parser->tok); - ast_value_delete(typevar); - return false; - } - - if (!parser_next(parser)) { - ast_unref(framenum); - ast_value_delete(typevar); - return false; - } - - if (parser->tok == TOKEN_IDENT && !parser_find_var(parser, parser_tokval(parser))) - { - /* qc allows the use of not-yet-declared functions here - * - this automatically creates a prototype */ - varentry_t varent; - ast_value *thinkfunc; - ast_expression *functype = fld_think->expression.next; - - thinkfunc = ast_value_new(parser_ctx(parser), parser_tokval(parser), functype->expression.vtype); - if (!thinkfunc || !ast_type_adopt(thinkfunc, functype)) { - ast_unref(framenum); - parseerror(parser, "failed to create implicit prototype for `%s`", parser_tokval(parser)); - ast_value_delete(typevar); - return false; - } - - if (!parser_next(parser)) { - ast_unref(framenum); - ast_value_delete(typevar); - return false; - } - - varent.var = (ast_expression*)thinkfunc; - varent.name = util_strdup(thinkfunc->name); - (void)!parser_t_globals_add(parser, varent); - nextthink = (ast_expression*)thinkfunc; - - } else { - nextthink = parser_expression_leave(parser, true); - if (!nextthink) { - ast_unref(framenum); - parseerror(parser, "expected a think-function in [frame,think] notation"); - ast_value_delete(typevar); - return false; - } - } - - if (!ast_istype(nextthink, ast_value)) { - ast_unref(nextthink); - ast_unref(framenum); - parseerror(parser, "think-function in [frame,think] notation must be a constant"); - } - - if (parser->tok != ']') { - parseerror(parser, "expected closing `]` for [frame,think] notation"); - ast_unref(nextthink); - ast_unref(framenum); - ast_value_delete(typevar); - return false; - } - - if (!parser_next(parser)) { - ast_unref(nextthink); - ast_unref(framenum); - ast_value_delete(typevar); - return false; - } - - if (parser->tok != '{') { - parseerror(parser, "a function body has to be declared after a [frame,think] declaration"); - ast_unref(nextthink); - ast_unref(framenum); - ast_value_delete(typevar); - return false; - } - - has_frame_think = true; - } - - block = ast_block_new(parser_ctx(parser)); - if (!block) { - parseerror(parser, "failed to allocate block"); - ast_value_delete(typevar); return false; } - if (has_frame_think) { - lex_ctx ctx; - ast_expression *self_frame; - ast_expression *self_nextthink; - ast_expression *self_think; - ast_expression *time_plus_1; - ast_store *store_frame; - ast_store *store_nextthink; - ast_store *store_think; - - ctx = parser_ctx(parser); - self_frame = (ast_expression*)ast_entfield_new(ctx, gbl_self, fld_frame); - self_nextthink = (ast_expression*)ast_entfield_new(ctx, gbl_self, fld_nextthink); - self_think = (ast_expression*)ast_entfield_new(ctx, gbl_self, fld_think); - - time_plus_1 = (ast_expression*)ast_binary_new(ctx, INSTR_ADD_F, - gbl_time, (ast_expression*)parser_const_float(parser, 0.1)); - - store_frame = ast_store_new(ctx, INSTR_STOREP_F, self_frame, framenum); - store_nextthink = ast_store_new(ctx, INSTR_STOREP_F, self_nextthink, time_plus_1); - store_think = ast_store_new(ctx, INSTR_STOREP_FNC, self_think, nextthink); - - if (!ast_block_exprs_add(block, (ast_expression*)store_frame) || - !ast_block_exprs_add(block, (ast_expression*)store_nextthink) || - !ast_block_exprs_add(block, (ast_expression*)store_think) ) - { - parseerror(parser, "failed to generate code for [frame,think]"); - ast_block_delete(block); - ast_value_delete(typevar); - return false; - } - } - - for (parami = 0; parami < var->expression.params_count; ++parami) { - ast_value *param = var->expression.params[parami]; - varentry_t vx, vy, vz; - - if (param->expression.vtype != TYPE_VECTOR && - (param->expression.vtype != TYPE_FIELD || - param->expression.next->expression.vtype != TYPE_VECTOR)) - { - continue; - } - - if (!create_vector_members(parser, param, &vx, &vy, &vz)) { - ast_block_delete(block); - ast_value_delete(typevar); - return false; - } - - (void)!parser_t_locals_add(parser, vx); - (void)!parser_t_locals_add(parser, vy); - (void)!parser_t_locals_add(parser, vz); - if (!ast_block_collect(block, vx.var) || - !ast_block_collect(block, vy.var) || - !ast_block_collect(block, vz.var) ) - { - (void)!parser_pop_local(parser); - (void)!parser_pop_local(parser); - (void)!parser_pop_local(parser); - ast_block_delete(block); - ast_value_delete(typevar); - return false; - } - } - - func = ast_function_new(ast_ctx(var), var->name, var); - if (!func) { - parseerror(parser, "failed to allocate function for `%s`", var->name); - ast_block_delete(block); - parser->function = old; - ast_value_delete(typevar); + if (!parse_function_body(parser, var)) { return false; } - if (!parser_t_functions_add(parser, func)) { - parseerror(parser, "failed to allocate slot for function `%s`", var->name); - ast_function_delete(func); - var->constval.vfunc = NULL; - ast_value_delete(typevar); - ast_block_delete(block); - parser->function = old; - return false; - } - - parser->function = func; - if (!parser_parse_block_into(parser, block, true)) { - ast_block_delete(block); - parser->function = old; - ast_value_delete(typevar); - return false; - } - parser->function = old; - while (parser->locals_count) - retval = retval && parser_pop_local(parser); - - if (!block) { - ast_value_delete(typevar); - return false; - } - - if (!ast_function_blocks_add(func, block)) { - ast_block_delete(block); - ast_value_delete(typevar); - return false; - } - - if (parser->tok == ';') { - ast_value_delete(typevar); - return parser_next(parser) || parser->tok == TOKEN_EOF; - } - else if (opts_standard == COMPILER_QCC) - parseerror(parser, "missing semicolon after function body (mandatory with -std=qcc)"); - ast_value_delete(typevar); - return retval; + return true; } else { ast_expression *cexp; ast_value *cval; - cexp = parser_expression_leave(parser, true); + cexp = parse_expression_leave(parser, true); if (!cexp) { ast_value_delete(typevar); return false; @@ -2591,13 +2619,26 @@ nextvar: ast_value_delete(typevar); return true; } + +cleanup: + ast_delete(typevar); + if (var && cleanvar) ast_delete(var); + if (varent.name) mem_d(varent.name); + if (ve[0].name) mem_d(ve[0].name); + if (ve[1].name) mem_d(ve[1].name); + if (ve[2].name) mem_d(ve[2].name); + if (ve[0].var) mem_d(ve[0].var); + if (ve[1].var) mem_d(ve[1].var); + if (ve[2].var) mem_d(ve[2].var); + + return retval; } -static bool parser_do(parser_t *parser) +static bool parser_global_statement(parser_t *parser) { if (parser->tok == TOKEN_TYPENAME) { - return parser_variable(parser, NULL); + return parse_variable(parser, NULL); } else if (parser->tok == TOKEN_KEYWORD) { @@ -2631,7 +2672,7 @@ static bool parser_do(parser_t *parser) } /* parse the field type fully */ - typevar = var = parser_parse_type(parser, basetype, &isfunc); + typevar = var = parse_type(parser, basetype, &isfunc); if (!var) return false; @@ -2712,14 +2753,14 @@ static bool parser_do(parser_t *parser) if (var->expression.vtype == TYPE_VECTOR) { /* create _x, _y and _z fields as well */ - varentry_t vx, vy, vz; - if (!create_vector_members(parser, fld, &vx, &vy, &vz)) { + varentry_t ve[3]; + if (!create_vector_members(parser, fld, ve)) { ast_delete(fld); return false; } - (void)!parser_t_fields_add(parser, vx); - (void)!parser_t_fields_add(parser, vy); - (void)!parser_t_fields_add(parser, vz); + (void)!parser_t_fields_add(parser, ve[0]); + (void)!parser_t_fields_add(parser, ve[1]); + (void)!parser_t_fields_add(parser, ve[2]); } nextfield: @@ -2751,7 +2792,7 @@ nextfield: } else { - parseerror(parser, "unexpected token: %s", parser->lex->tok->value); + parseerror(parser, "unexpected token: %s", parser->lex->tok.value); return false; } return true; @@ -2784,7 +2825,7 @@ bool parser_compile(const char *filename) { while (parser->tok != TOKEN_EOF && parser->tok < TOKEN_ERROR) { - if (!parser_do(parser)) { + if (!parser_global_statement(parser)) { if (parser->tok == TOKEN_EOF) parseerror(parser, "unexpected eof"); else if (!parser->errors)