X-Git-Url: https://git.xonotic.org/?a=blobdiff_plain;f=parser.c;h=12241cb7083aff4b61106ca364445d7ccbda0e6e;hb=2994d308a04bfcca8d94cada14c20cc00403d960;hp=08294a60db85811d38c0cac48b4fb0547a7c1681;hpb=50e76a56c5b462a68339038be207b3907fc55216;p=xonotic%2Fgmqcc.git diff --git a/parser.c b/parser.c index 08294a6..12241cb 100644 --- a/parser.c +++ b/parser.c @@ -23,12 +23,18 @@ typedef struct { ast_value *imm_float_zero; ast_value *imm_vector_zero; + size_t crc_globals; + size_t crc_fields; + ast_function *function; MEM_VECTOR_MAKE(varentry_t, locals); size_t blocklocal; size_t errors; + /* we store the '=' operator info */ + const oper_info *assign_op; + /* TYPE_FIELD -> parser_find_fields is used instead of find_var * TODO: TYPE_VECTOR -> x, y and z are accepted in the gmqcc standard * anything else: type error @@ -45,12 +51,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, bool nofields); +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 +65,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 +84,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,17 +161,9 @@ 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) static ast_value* parser_const_float(parser_t *parser, double d) { @@ -311,128 +309,6 @@ static ast_expression* parser_find_var(parser_t *parser, const char *name) return v; } -typedef struct { - MEM_VECTOR_MAKE(ast_value*, p); -} paramlist_t; -MEM_VEC_FUNCTIONS(paramlist_t, ast_value*, p) - -static ast_value *parser_parse_type(parser_t *parser, int basetype, bool *isfunc) -{ - paramlist_t params; - ast_value *var; - lex_ctx ctx = parser_ctx(parser); - int vtype = basetype; - int temptype; - size_t i; - bool variadic = false; - - MEM_VECTOR_INIT(¶ms, p); - - *isfunc = false; - - if (parser->tok == '(') { - *isfunc = true; - while (true) { - ast_value *param; - ast_value *fld; - bool isfield = false; - bool isfuncparam = false; - - if (!parser_next(parser)) - goto on_error; - - if (parser->tok == ')') - break; - - if (parser->tok == '.') { - isfield = true; - if (!parser_next(parser)) { - parseerror(parser, "expected field parameter type"); - goto on_error; - } - } - - if (parser->tok == TOKEN_DOTS) { - /* variadic args */ - variadic = true; - if (!parser_next(parser)) - goto on_error; - if (parser->tok != ')') { - parseerror(parser, "`...` must be the last parameter of a variadic function declaration"); - goto on_error; - } - if (opts_standard == COMPILER_QCC) { - if (parsewarning(parser, WARN_EXTENSIONS, "variadic functions are not available in this standard")) - goto on_error; - } - break; - } - - temptype = parser_token(parser)->constval.t; - if (!parser_next(parser)) - goto on_error; - - param = parser_parse_type(parser, temptype, &isfuncparam); - - if (!param) - goto on_error; - - if (parser->tok == TOKEN_IDENT) { - /* named parameter */ - if (!ast_value_set_name(param, parser_tokval(parser))) - goto on_error; - if (!parser_next(parser)) - goto on_error; - } - - /* This comes before the isfield part! */ - if (isfuncparam) { - ast_value *fval = ast_value_new(ast_ctx(param), param->name, TYPE_FUNCTION); - if (!fval) { - ast_delete(param); - goto on_error; - } - fval->expression.next = (ast_expression*)param; - MEM_VECTOR_MOVE(¶m->expression, params, &fval->expression, params); - fval->expression.variadic = param->expression.variadic; - param = fval; - } - - if (isfield) { - fld = ast_value_new(ctx, param->name, TYPE_FIELD); - fld->expression.next = (ast_expression*)param; - param = fld; - } - - if (!paramlist_t_p_add(¶ms, param)) { - parseerror(parser, "Out of memory while parsing typename"); - goto on_error; - } - - if (parser->tok == ',') - continue; - if (parser->tok == ')') - break; - parseerror(parser, "Unexpected token"); - goto on_error; - } - if (!parser_next(parser)) - goto on_error; - } - - var = ast_value_new(ctx, "", vtype); - if (!var) - goto on_error; - var->expression.variadic = variadic; - MEM_VECTOR_MOVE(¶ms, p, &var->expression, params); - return var; -on_error: - for (i = 0; i < params.p_count; ++i) - ast_value_delete(params.p[i]); - MEM_VECTOR_CLEAR(¶ms, p); - return NULL; -} - typedef struct { size_t etype; /* 0 = expression, others are operators */ @@ -450,9 +326,14 @@ typedef struct MEM_VEC_FUNCTIONS(shunt, sy_elem, out) MEM_VEC_FUNCTIONS(shunt, sy_elem, ops) +#define SY_PAREN_EXPR '(' +#define SY_PAREN_FUNC 'f' +#define SY_PAREN_INDEX '[' + static sy_elem syexp(lex_ctx ctx, ast_expression *v) { sy_elem e; e.etype = 0; + e.off = 0; e.out = v; e.block = NULL; e.ctx = ctx; @@ -463,6 +344,7 @@ static sy_elem syexp(lex_ctx ctx, ast_expression *v) { static sy_elem syblock(lex_ctx ctx, ast_block *v) { sy_elem e; e.etype = 0; + e.off = 0; e.out = (ast_expression*)v; e.block = v; e.ctx = ctx; @@ -473,6 +355,7 @@ static sy_elem syblock(lex_ctx ctx, ast_block *v) { static sy_elem syop(lex_ctx ctx, const oper_info *op) { sy_elem e; e.etype = 1 + (op - operators); + e.off = 0; e.out = NULL; e.block = NULL; e.ctx = ctx; @@ -508,6 +391,9 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) size_t i, assignop; qcint generated_op = 0; + char ty1[1024]; + char ty2[1024]; + if (!sy->ops_count) { parseerror(parser, "internal error: missing operator"); return false; @@ -869,10 +755,67 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) break; case opid1('='): - if (ast_istype(exprs[0], ast_entfield)) - assignop = type_storep_instr[exprs[0]->expression.vtype]; + if (ast_istype(exprs[0], ast_entfield)) { + ast_expression *field = ((ast_entfield*)exprs[0])->field; + if (OPTS_FLAG(ADJUST_VECTOR_FIELDS) && + exprs[0]->expression.vtype == TYPE_FIELD && + exprs[0]->expression.next->expression.vtype == TYPE_VECTOR) + { + assignop = type_storep_instr[TYPE_VECTOR]; + } + else + assignop = type_storep_instr[exprs[0]->expression.vtype]; + if (!ast_compare_type(field->expression.next, exprs[1])) { + ast_type_to_string(field->expression.next, ty1, sizeof(ty1)); + ast_type_to_string(exprs[1], ty2, sizeof(ty2)); + if (opts_standard == COMPILER_QCC && + field->expression.next->expression.vtype == TYPE_FUNCTION && + exprs[1]->expression.vtype == TYPE_FUNCTION) + { + if (parsewarning(parser, WARN_ASSIGN_FUNCTION_TYPES, + "invalid types in assignment: cannot assign %s to %s", ty2, ty1)) + { + parser->errors++; + } + } + else + parseerror(parser, "invalid types in assignment: cannot assign %s to %s", ty2, ty1); + } + } else - assignop = type_store_instr[exprs[0]->expression.vtype]; + { + if (OPTS_FLAG(ADJUST_VECTOR_FIELDS) && + exprs[0]->expression.vtype == TYPE_FIELD && + exprs[0]->expression.next->expression.vtype == TYPE_VECTOR) + { + assignop = type_store_instr[TYPE_VECTOR]; + } + else { + assignop = type_store_instr[exprs[0]->expression.vtype]; + } + + if (assignop == AINSTR_END) { + ast_type_to_string(exprs[0], ty1, sizeof(ty1)); + ast_type_to_string(exprs[1], ty2, sizeof(ty2)); + parseerror(parser, "invalid types in assignment: cannot assign %s to %s", ty2, ty1); + } + else if (!ast_compare_type(exprs[0], exprs[1])) { + ast_type_to_string(exprs[0], ty1, sizeof(ty1)); + ast_type_to_string(exprs[1], ty2, sizeof(ty2)); + if (opts_standard == COMPILER_QCC && + exprs[0]->expression.vtype == TYPE_FUNCTION && + exprs[1]->expression.vtype == TYPE_FUNCTION) + { + if (parsewarning(parser, WARN_ASSIGN_FUNCTION_TYPES, + "invalid types in assignment: cannot assign %s to %s", ty2, ty1)) + { + parser->errors++; + } + } + else + parseerror(parser, "invalid types in assignment: cannot assign %s to %s", ty2, ty1); + } + } out = (ast_expression*)ast_store_new(ctx, assignop, exprs[0], exprs[1]); break; case opid2('+','='): @@ -972,6 +915,8 @@ static bool parser_close_call(parser_t *parser, shunt *sy) MEM_VECTOR_MOVE(params, exprs, call, params); ast_delete(params); } + if (!ast_call_check_types(call)) + parser->errors++; } else { parseerror(parser, "invalid function call"); return false; @@ -1045,15 +990,19 @@ static bool parser_close_paren(parser_t *parser, shunt *sy, bool functions_only) } */ while (sy->ops_count) { - if (sy->ops[sy->ops_count-1].paren == 'f') { + if (sy->ops[sy->ops_count-1].paren == SY_PAREN_FUNC) { if (!parser_close_call(parser, sy)) return false; break; } - if (sy->ops[sy->ops_count-1].paren == 1) { + if (sy->ops[sy->ops_count-1].paren == SY_PAREN_EXPR) { sy->ops_count--; return !functions_only; } + if (sy->ops[sy->ops_count-1].paren == SY_PAREN_INDEX) { + sy->ops_count--; + return true; + } if (!parser_sy_pop(parser, sy)) return false; } @@ -1071,7 +1020,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; @@ -1213,6 +1162,10 @@ static ast_expression* parser_expression_leave(parser_t *parser, bool stopatcomm parseerror(parser, "internal error: '(' should be classified as operator"); goto onerr; } + else if (parser->tok == '[') { + parseerror(parser, "internal error: '[' should be classified as operator"); + goto onerr; + } else if (parser->tok == ')') { if (wantop) { DEBUGSHUNTDO(printf("do[op] )\n")); @@ -1234,6 +1187,16 @@ static ast_expression* parser_expression_leave(parser_t *parser, bool stopatcomm } wantop = true; } + else if (parser->tok == ']') { + if (!wantop) + parseerror(parser, "operand expected"); + --parens; + if (parens < 0) + break; + if (!parser_close_paren(parser, &sy, false)) + goto onerr; + wantop = true; + } else if (parser->tok != TOKEN_OPERATOR) { if (wantop) { parseerror(parser, "expected operator or end of statement"); @@ -1308,19 +1271,29 @@ static ast_expression* parser_expression_leave(parser_t *parser, bool stopatcomm DEBUGSHUNTDO(printf("push [op] (\n")); ++parens; /* we expected an operator, this is the function-call operator */ - if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), 'f', sy.out_count-1))) { + if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), SY_PAREN_FUNC, sy.out_count-1))) { parseerror(parser, "out of memory"); goto onerr; } } else { ++parens; - if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), 1, 0))) { + if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), SY_PAREN_EXPR, 0))) { parseerror(parser, "out of memory"); goto onerr; } DEBUGSHUNTDO(printf("push [nop] (\n")); } wantop = false; + } else if (op->id == opid1('[')) { + if (!wantop) { + parseerror(parser, "unexpected array subscript"); + goto onerr; + } + ++parens; + if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), SY_PAREN_INDEX, 0))) { + parseerror(parser, "out of memory"); + goto onerr; + } } else { DEBUGSHUNTDO(printf("push operator %s\n", op->op)); if (!shunt_ops_add(&sy, syop(parser_ctx(parser), op))) @@ -1359,9 +1332,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 +1344,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 +1362,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 +1377,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 +1391,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 +1404,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 +1422,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 +1437,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 +1448,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 +1460,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 +1486,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 +1516,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 +1553,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, true)) goto onerr; } else if (parser->tok != ';') { - initexpr = parser_expression_leave(parser, false); + initexpr = parse_expression_leave(parser, false); if (!initexpr) goto onerr; } @@ -1602,7 +1575,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,7 +1592,7 @@ 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) && @@ -1641,7 +1614,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; } @@ -1663,9 +1636,9 @@ 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) + if (parser->tok == TOKEN_TYPENAME || parser->tok == '.') { /* local variable */ if (!block) { @@ -1676,7 +1649,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, false)) return false; *out = NULL; return true; @@ -1693,7 +1666,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, true)) return false; *out = NULL; return true; @@ -1710,7 +1683,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; @@ -1739,15 +1712,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")) { @@ -1755,7 +1728,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; @@ -1763,7 +1736,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; @@ -1771,7 +1744,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; @@ -1800,7 +1773,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; @@ -1819,8 +1792,8 @@ 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)) { - parseerror(parser, "parse error"); + if (!parse_statement(parser, block, &expr)) { + /* parseerror(parser, "parse error"); */ block = NULL; goto cleanup; } @@ -1857,25 +1830,25 @@ 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; } @@ -1910,817 +1883,1415 @@ static bool create_vector_members(parser_t *parser, ast_value *var, varentry_t * --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 parser_variable(parser_t *parser, ast_block *localblock) +static bool parse_function_body(parser_t *parser, ast_value *var) { - bool isfunc = false; - lex_ctx ctx; - ast_value *var; - varentry_t varent; - ast_expression *olddecl; - - ast_value *typevar; - - bool hadproto; - bool isparam; + 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 = NULL, *fld_nextthink = NULL, *fld_frame = NULL; + ast_expression *gbl_time = NULL, *gbl_self = NULL; + bool has_frame_think; bool retval = true; - int basetype = parser_token(parser)->constval.t; + has_frame_think = false; + old = parser->function; - if (!parser_next(parser)) { - parseerror(parser, "expected variable definition"); - return false; + if (var->expression.variadic) { + if (parsewarning(parser, WARN_VARIADIC_FUNCTION, + "variadic function with implementation will not be able to access additional parameters")) + { + return false; + } } - typevar = parser_parse_type(parser, basetype, &isfunc); - if (!typevar) - return false; - - while (true) - { - hadproto = false; - olddecl = NULL; - isparam = false; - - ctx = parser_ctx(parser); - var = ast_value_copy(typevar); - - if (!var) { - ast_delete(typevar); - parseerror(parser, "failed to create variable"); + 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; } - - if (parser->tok != TOKEN_IDENT) { - parseerror(parser, "expected variable name"); - ast_value_delete(typevar); - ast_value_delete(var); + 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 (!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; - } - - if (localblock) { - olddecl = parser_find_local(parser, parser_tokval(parser), parser->blocklocal, &isparam); - if (opts_standard == COMPILER_GMQCC) - { - 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; - } - } + if (!parser_next(parser)) + return false; - 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; - } - } - } - else - { - if (olddecl) - { - ast_value_delete(var); - 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; - } - 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; - } - goto nextvar; - } - } - } + framenum = parse_expression_leave(parser, true); + if (!framenum) { + parseerror(parser, "expected a framenumber constant in[frame,think] notation"); + return false; } - - 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); + 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 (isfunc) { - /* a function was defined */ - ast_value *fval; - ast_value *proto = NULL; - bool dummy; + 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 (!localblock) - olddecl = parser_find_global(parser, parser_tokval(parser)); - else - olddecl = parser_find_local(parser, parser_tokval(parser), parser->blocklocal, &dummy); - - if (olddecl) { - /* we had a prototype */ - if (!ast_istype(olddecl, ast_value)) { - /* theoretically not possible you think? - * well: - * 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; - } + if (!parser_next(parser)) { + ast_unref(framenum); + return false; + } - proto = (ast_value*)olddecl; + 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; } - /* turn var into a value of TYPE_FUNCTION, with the old var - * as return type - */ - 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); + if (!parser_next(parser)) { + ast_unref(framenum); + ast_delete(thinkfunc); return false; } - fval->expression.next = (ast_expression*)var; - MEM_VECTOR_MOVE(&var->expression, params, &fval->expression, params); - fval->expression.variadic = var->expression.variadic; - - /* we compare the type late here, but it's easier than - * messing with the parameter-vector etc. earlier - */ - if (proto) { - size_t param; - if (!ast_compare_type((ast_expression*)proto, (ast_expression*)fval)) { - parseerror(parser, "conflicting types for `%s`, previous declaration was here: %s:%i", - proto->name, - ast_ctx(proto).file, ast_ctx(proto).line); - ast_value_delete(fval); - ast_value_delete(typevar); - return false; - } - /* copy over the parameter names */ - for (param = 0; param < fval->expression.params_count; ++param) - ast_value_set_name(proto->expression.params[param], fval->expression.params[param]->name); - /* copy the new context */ - ast_ctx(proto) = ast_ctx(fval); - - /* now ditch the rest of the new data */ - ast_value_delete(fval); - fval = proto; - hadproto = true; + 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; - var = fval; - } - - if (!hadproto) { - varent.name = util_strdup(var->name); - varent.var = (ast_expression*)var; - if (var->expression.vtype == TYPE_VECTOR) - { - varentry_t ve[3]; - if (!create_vector_members(parser, var, ve)) { - ast_delete(var); - ast_value_delete(typevar); - return false; - } - - if (!localblock) { - (void)!parser_t_globals_add(parser, varent); - (void)!parser_t_globals_add(parser, ve[0]); - (void)!parser_t_globals_add(parser, ve[1]); - (void)!parser_t_globals_add(parser, ve[2]); - } else { - (void)!parser_t_locals_add(parser, varent); - (void)!parser_t_locals_add(parser, ve[0]); - (void)!parser_t_locals_add(parser, ve[1]); - (void)!parser_t_locals_add(parser, ve[2]); - if (!ast_block_locals_add(localblock, var) || - !ast_block_collect(localblock, ve[0].var) || - !ast_block_collect(localblock, ve[1].var) || - !ast_block_collect(localblock, ve[2].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; - } - } - } - 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; - } + } else { + nextthink = parse_expression_leave(parser, true); + if (!nextthink) { + ast_unref(framenum); + parseerror(parser, "expected a think-function in [frame,think] notation"); + return false; } } -nextvar: - if (!parser_next(parser)) { - ast_value_delete(typevar); - ast_value_delete(var); - return false; + if (!ast_istype(nextthink, ast_value)) { + parseerror(parser, "think-function in [frame,think] notation must be a constant"); + retval = false; } - if (parser->tok == ';') { - ast_value_delete(typevar); - if (!parser_next(parser)) - return false; - return true; + if (retval && parser->tok != ']') { + parseerror(parser, "expected closing `]` for [frame,think] notation"); + retval = false; } - if (parser->tok == ',') { - /* another var */ - if (!parser_next(parser)) { - ast_delete(typevar); - return false; - } - continue; + if (retval && !parser_next(parser)) { + retval = false; } - if (localblock && opts_standard == COMPILER_QCC) { - if (parsewarning(parser, WARN_LOCAL_CONSTANTS, - "initializing expression turns variable `%s` into a constant in this standard", - var->name) ) - { - ast_value_delete(typevar); - return false; - } + if (retval && parser->tok != '{') { + parseerror(parser, "a function body has to be declared after a [frame,think] declaration"); + retval = false; } - if (parser->tok != '=') { - ast_value_delete(typevar); - parseerror(parser, "expected '=' or ';'"); + if (!retval) { + ast_unref(nextthink); + ast_unref(framenum); return false; } - if (!parser_next(parser)) { - 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"); + if (has_frame_think) { + ast_unref(nextthink); + ast_unref(framenum); } + return false; + } - if (parser->tok == '#') { - ast_function *func; + 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; - if (localblock) { - parseerror(parser, "cannot declare builtins within functions"); - ast_value_delete(typevar); - return false; + 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 (!isfunc) { - parseerror(parser, "unexpected builtin number, '%s' is not a function", var->name); - ast_value_delete(typevar); - return false; + if (!store_nextthink) { + ast_delete(self_nextthink); + retval = false; } - if (!parser_next(parser)) { - parseerror(parser, "expected builtin number"); - ast_value_delete(typevar); - return false; + if (!store_think) { + ast_delete(self_think); + retval = false; } - if (parser->tok != TOKEN_INTCONST) { - parseerror(parser, "builtin number must be an integer constant"); - ast_value_delete(typevar); - return 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 (parser_token(parser)->constval.i <= 0) { - parseerror(parser, "builtin number must be positive integer greater than zero"); - ast_value_delete(typevar); - return 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; } - func = ast_function_new(ast_ctx(var), var->name, var); - if (!func) { - parseerror(parser, "failed to allocate function for `%s`", var->name); - ast_value_delete(typevar); - return false; + if (retval && !ast_block_exprs_add(block, (ast_expression*)store_nextthink)) { + ast_delete(store_nextthink); + ast_delete(store_think); + retval = 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); - return false; - } - - func->builtin = -parser_token(parser)->constval.i; - if (!parser_next(parser)) { - ast_value_delete(typevar); - return false; + if (retval && !ast_block_exprs_add(block, (ast_expression*)store_think) ) + { + ast_delete(store_think); + retval = 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; + if (!retval) { + parseerror(parser, "failed to generate code for [frame,think]"); + ast_unref(nextthink); + ast_unref(framenum); + ast_delete(block); + return false; + } + } - has_frame_think = false; - old = parser->function; + for (parami = 0; parami < var->expression.params_count; ++parami) { + size_t e; + varentry_t ve[3]; + ast_value *param = var->expression.params[parami]; - 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; - } + 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 != 3) { + parser->locals -= e; + do { + mem_d(ve[e].name); + --e; + } while (e); + ast_block_delete(block); + return false; + } + } - if (localblock) { - parseerror(parser, "cannot declare functions within functions"); - 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); + 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 enderrfn2; + } + + if (!ast_function_blocks_add(func, block)) { + ast_block_delete(block); + goto enderrfn2; + } + + 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; + +enderrfn2: + parser->functions_count--; +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 ast_expression *array_setter_node(parser_t *parser, ast_value *array, ast_value *index, ast_value *value, size_t from, size_t afterend) +{ + lex_ctx ctx = ast_ctx(array); + + if (from+1 == afterend) { + // set this value + ast_block *block; + ast_return *ret; + ast_array_index *subscript; + int assignop = type_store_instr[value->expression.vtype]; + + if (value->expression.vtype == TYPE_FIELD && value->expression.next->expression.vtype == TYPE_VECTOR) + assignop = INSTR_STORE_V; + + subscript = ast_array_index_new(ctx, (ast_expression*)array, (ast_expression*)parser_const_float(parser, from)); + if (!subscript) + return NULL; + + ast_store *st = ast_store_new(ctx, assignop, (ast_expression*)subscript, (ast_expression*)value); + if (!st) { + ast_delete(subscript); + return NULL; + } + + block = ast_block_new(ctx); + if (!block) { + ast_delete(st); + return NULL; + } + + if (!ast_block_exprs_add(block, (ast_expression*)st)) { + ast_delete(block); + return NULL; + } + + ret = ast_return_new(ctx, NULL); + if (!ret) { + ast_delete(block); + return NULL; + } + + if (!ast_block_exprs_add(block, (ast_expression*)ret)) { + ast_delete(block); + return NULL; + } + + return (ast_expression*)block; + } else { + ast_ifthen *ifthen; + ast_expression *left, *right; + ast_binary *cmp; + + size_t diff = afterend - from; + size_t middle = from + diff/2; + + left = array_setter_node(parser, array, index, value, from, middle); + right = array_setter_node(parser, array, index, value, middle, afterend); + if (!left || !right) { + if (left) ast_delete(left); + if (right) ast_delete(right); + return NULL; + } + + cmp = ast_binary_new(ctx, INSTR_LT, + (ast_expression*)index, + (ast_expression*)parser_const_float(parser, from + diff/2)); + if (!cmp) { + ast_delete(left); + ast_delete(right); + parseerror(parser, "internal error: failed to create comparison for array setter"); + return NULL; + } + + ifthen = ast_ifthen_new(ctx, (ast_expression*)cmp, left, right); + if (!ifthen) { + ast_delete(cmp); /* will delete left and right */ + parseerror(parser, "internal error: failed to create conditional jump for array setter"); + return NULL; + } + + return (ast_expression*)ifthen; + } +} + +static ast_expression *array_getter_node(parser_t *parser, ast_value *array, ast_value *index, size_t from, size_t afterend) +{ + lex_ctx ctx = ast_ctx(array); + + if (from+1 == afterend) { + ast_return *ret; + ast_array_index *subscript; + + subscript = ast_array_index_new(ctx, (ast_expression*)array, (ast_expression*)parser_const_float(parser, from)); + if (!subscript) + return NULL; + + ret = ast_return_new(ctx, (ast_expression*)subscript); + if (!ret) { + ast_delete(subscript); + return NULL; + } + + return (ast_expression*)ret; + } else { + ast_ifthen *ifthen; + ast_expression *left, *right; + ast_binary *cmp; + + size_t diff = afterend - from; + size_t middle = from + diff/2; + + left = array_getter_node(parser, array, index, from, middle); + right = array_getter_node(parser, array, index, middle, afterend); + if (!left || !right) { + if (left) ast_delete(left); + if (right) ast_delete(right); + return NULL; + } + + cmp = ast_binary_new(ctx, INSTR_LT, + (ast_expression*)index, + (ast_expression*)parser_const_float(parser, from + diff/2)); + if (!cmp) { + ast_delete(left); + ast_delete(right); + parseerror(parser, "internal error: failed to create comparison for array setter"); + return NULL; + } + + ifthen = ast_ifthen_new(ctx, (ast_expression*)cmp, left, right); + if (!ifthen) { + ast_delete(cmp); /* will delete left and right */ + parseerror(parser, "internal error: failed to create conditional jump for array setter"); + return NULL; + } + + return (ast_expression*)ifthen; + } +} + +static bool parser_create_array_setter(parser_t *parser, ast_value *array, const char *funcname) +{ + ast_expression *root = NULL; + ast_function *func = NULL; + ast_value *fval = NULL; + ast_block *body; + ast_value *index, *value; + + if (!ast_istype(array->expression.next, ast_value)) { + parseerror(parser, "internal error: array accessor needs to build an ast_value with a copy of the element type"); + return false; + } + + body = ast_block_new(ast_ctx(array)); + if (!body) { + parseerror(parser, "failed to create block for array accessor"); + return false; + } + + index = ast_value_new(ast_ctx(array), "index", TYPE_FLOAT); + value = ast_value_copy((ast_value*)array->expression.next); + + if (!index || !value) { + ast_delete(body); + if (index) ast_delete(index); + if (value) ast_delete(value); + parseerror(parser, "failed to create locals for array accessor"); + return false; + } + + root = array_setter_node(parser, array, index, value, 0, array->expression.count); + if (!root) { + parseerror(parser, "failed to build accessor search tree"); + goto cleanup; + } + + if (!ast_block_exprs_add(body, root)) { + parseerror(parser, "failed to build accessor search block"); + goto cleanup; + } + + fval = ast_value_new(ast_ctx(array), funcname, TYPE_FUNCTION); + if (!fval) { + parseerror(parser, "failed to create accessor function value"); + goto cleanup; + } + fval->expression.next = (ast_expression*)ast_value_new(ast_ctx(array), "", TYPE_VOID); + + (void)!ast_value_set_name(value, "value"); /* not important */ + if (!ast_expression_common_params_add(&fval->expression, index)) { + parseerror(parser, "failed to build array setter"); + goto cleanup; + } + if (!ast_expression_common_params_add(&fval->expression, value)) { + ast_delete(index); + parseerror(parser, "failed to build array setter"); + goto cleanup2; + } + + func = ast_function_new(ast_ctx(array), funcname, fval); + if (!func) { + parseerror(parser, "failed to create accessor function node"); + goto cleanup2; + } + + if (!ast_function_blocks_add(func, body)) + goto cleanup2; + + array->setter = fval; + + return true; +cleanup: + ast_delete(index); + ast_delete(value); +cleanup2: + ast_delete(body); + if (root) ast_delete(root); + if (func) ast_delete(func); + if (fval) ast_delete(fval); + return false; +} + +static bool parser_create_array_getter(parser_t *parser, ast_value *array, const char *funcname) +{ + ast_expression *root = NULL; + ast_function *func = NULL; + ast_value *fval = NULL; + ast_block *body; + ast_value *index; + + if (!ast_istype(array->expression.next, ast_value)) { + parseerror(parser, "internal error: array accessor needs to build an ast_value with a copy of the element type"); + return false; + } + + body = ast_block_new(ast_ctx(array)); + if (!body) { + parseerror(parser, "failed to create block for array accessor"); + return false; + } + + index = ast_value_new(ast_ctx(array), "index", TYPE_FLOAT); + + if (!index) { + ast_delete(body); + if (index) ast_delete(index); + parseerror(parser, "failed to create locals for array accessor"); + return false; + } + + root = array_getter_node(parser, array, index, 0, array->expression.count); + if (!root) { + parseerror(parser, "failed to build accessor search tree"); + goto cleanup; + } + + if (!ast_block_exprs_add(body, root)) { + parseerror(parser, "failed to build accessor search block"); + goto cleanup; + } + + fval = ast_value_new(ast_ctx(array), funcname, TYPE_FUNCTION); + if (!fval) { + parseerror(parser, "failed to create accessor function value"); + goto cleanup; + } + fval->expression.next = ast_type_copy(ast_ctx(array), array->expression.next); + + if (!ast_expression_common_params_add(&fval->expression, index)) { + parseerror(parser, "failed to build array setter"); + goto cleanup; + } + + func = ast_function_new(ast_ctx(array), funcname, fval); + if (!func) { + parseerror(parser, "failed to create accessor function node"); + goto cleanup2; + } + + if (!ast_function_blocks_add(func, body)) + goto cleanup2; + + array->getter = fval; + + return true; +cleanup: + ast_delete(index); +cleanup2: + ast_delete(body); + if (root) ast_delete(root); + if (func) ast_delete(func); + if (fval) ast_delete(fval); + return false; +} + +typedef struct { + MEM_VECTOR_MAKE(ast_value*, p); +} paramlist_t; +MEM_VEC_FUNCTIONS(paramlist_t, ast_value*, p) + +static ast_value *parse_typename(parser_t *parser, ast_value **storebase); +static ast_value *parse_parameter_list(parser_t *parser, ast_value *var) +{ + lex_ctx ctx; + size_t i; + paramlist_t params; + ast_value *param; + ast_value *fval; + bool first = true; + bool variadic = false; + + ctx = parser_ctx(parser); + + /* for the sake of less code we parse-in in this function */ + if (!parser_next(parser)) { + parseerror(parser, "expected parameter list"); + return NULL; + } + + MEM_VECTOR_INIT(¶ms, p); + + /* parse variables until we hit a closing paren */ + while (parser->tok != ')') { + if (!first) { + /* there must be commas between them */ + if (parser->tok != ',') { + parseerror(parser, "expected comma or end of parameter list"); + goto on_error; + } + if (!parser_next(parser)) { + parseerror(parser, "expected parameter"); + goto on_error; } + } + first = 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->tok == TOKEN_DOTS) { + /* '...' indicates a varargs function */ + variadic = true; + if (!parser_next(parser)) { + parseerror(parser, "expected parameter"); + return NULL; + } + if (parser->tok != ')') { + parseerror(parser, "`...` must be the last parameter of a variadic function declaration"); + goto on_error; + } + } + else + { + /* for anything else just parse a typename */ + param = parse_typename(parser, NULL); + if (!param) + goto on_error; + if (!paramlist_t_p_add(¶ms, param)) { + ast_delete(param); + goto on_error; + } + if (param->expression.vtype >= TYPE_VARIANT) { + char typename[1024]; + ast_type_to_string((ast_expression*)param, typename, sizeof(typename)); + parseerror(parser, "type not supported as part of a parameter list: %s", typename); + goto on_error; + } + } + } - if (!parser_next(parser)) { - ast_value_delete(typevar); - return false; - } + /* sanity check */ + if (params.p_count > 8) + parseerror(parser, "more than 8 parameters are currently not supported"); - 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"); - } + /* parse-out */ + if (!parser_next(parser)) { + parseerror(parser, "parse error after typename"); + goto on_error; + } - 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; + /* now turn 'var' into a function type */ + fval = ast_value_new(ctx, "", TYPE_FUNCTION); + fval->expression.next = (ast_expression*)var; + fval->expression.variadic = variadic; + var = fval; + + MEM_VECTOR_MOVE(¶ms, p, &var->expression, params); + + return var; + +on_error: + ast_delete(var); + for (i = 0; i < params.p_count; ++i) + ast_delete(params.p[i]); + MEM_VECTOR_CLEAR(¶ms, p); + return NULL; +} + +static ast_value *parse_arraysize(parser_t *parser, ast_value *var) +{ + ast_expression *cexp; + ast_value *cval, *tmp; + lex_ctx ctx; + + ctx = parser_ctx(parser); + + if (!parser_next(parser)) { + ast_delete(var); + parseerror(parser, "expected array-size"); + return NULL; + } + + cexp = parse_expression_leave(parser, true); + + if (!cexp || !ast_istype(cexp, ast_value)) { + if (cexp) + ast_unref(cexp); + ast_delete(var); + parseerror(parser, "expected array-size as constant positive integer"); + return NULL; + } + cval = (ast_value*)cexp; + + tmp = ast_value_new(ctx, "", TYPE_ARRAY); + tmp->expression.next = (ast_expression*)var; + var = tmp; + + if (cval->expression.vtype == TYPE_INTEGER) + tmp->expression.count = cval->constval.vint; + else if (cval->expression.vtype == TYPE_FLOAT) + tmp->expression.count = cval->constval.vfloat; + else { + ast_unref(cexp); + ast_delete(var); + parseerror(parser, "array-size must be a positive integer constant"); + return NULL; + } + ast_unref(cexp); + + if (parser->tok != ']') { + ast_delete(var); + parseerror(parser, "expected ']' after array-size"); + return NULL; + } + if (!parser_next(parser)) { + ast_delete(var); + parseerror(parser, "error after parsing array size"); + return NULL; + } + return var; +} + +/* Parse a complete typename. + * for single-variables (ie. function parameters or typedefs) storebase should be NULL + * but when parsing variables separated by comma + * 'storebase' should point to where the base-type should be kept. + * The base type makes up every bit of type information which comes *before* the + * variable name. + * + * The following will be parsed in its entirety: + * void() foo() + * The 'basetype' in this case is 'void()' + * and if there's a comma after it, say: + * void() foo(), bar + * then the type-information 'void()' can be stored in 'storebase' + */ +static ast_value *parse_typename(parser_t *parser, ast_value **storebase) +{ + ast_value *var, *tmp; + lex_ctx ctx; + + const char *name = NULL; + bool isfield = false; + bool wasarray = false; + + ctx = parser_ctx(parser); + + /* types may start with a dot */ + if (parser->tok == '.') { + isfield = true; + /* if we parsed a dot we need a typename now */ + if (!parser_next(parser)) { + parseerror(parser, "expected typename for field definition"); + return NULL; + } + if (parser->tok != TOKEN_TYPENAME) { + parseerror(parser, "expected typename"); + return NULL; + } + } + + /* generate the basic type value */ + var = ast_value_new(ctx, "", parser_token(parser)->constval.t); + /* do not yet turn into a field - remember: + * .void() foo; is a field too + * .void()() foo; is a function + */ + + /* parse on */ + if (!parser_next(parser)) { + ast_delete(var); + parseerror(parser, "parse error after typename"); + return NULL; + } + + /* an opening paren now starts the parameter-list of a function + * this is where original-QC has parameter lists. + * We allow a single parameter list here. + * Much like fteqcc we don't allow `float()() x` + */ + if (parser->tok == '(') { + var = parse_parameter_list(parser, var); + if (!var) + return NULL; + } + + /* store the base if requested */ + if (storebase) { + *storebase = ast_value_copy(var); + if (isfield) { + tmp = ast_value_new(ctx, "", TYPE_FIELD); + tmp->expression.next = (ast_expression*)*storebase; + *storebase = tmp; + } + } + + /* there may be a name now */ + if (parser->tok == TOKEN_IDENT) { + name = util_strdup(parser_tokval(parser)); + /* parse on */ + if (!parser_next(parser)) { + ast_delete(var); + parseerror(parser, "error after variable or field declaration"); + return NULL; + } + } + + /* now this may be an array */ + if (parser->tok == '[') { + wasarray = true; + var = parse_arraysize(parser, var); + if (!var) + return NULL; + } + + /* This is the point where we can turn it into a field */ + if (isfield) { + /* turn it into a field if desired */ + tmp = ast_value_new(ctx, "", TYPE_FIELD); + tmp->expression.next = (ast_expression*)var; + var = tmp; + } + + /* now there may be function parens again */ + if (parser->tok == '(' && opts_standard == COMPILER_QCC) + parseerror(parser, "C-style function syntax is not allowed in -std=qcc"); + if (parser->tok == '(' && wasarray) + parseerror(parser, "arrays as part of a return type is not supported"); + while (parser->tok == '(') { + var = parse_parameter_list(parser, var); + if (!var) { + if (name) + mem_d((void*)name); + ast_delete(var); + return NULL; + } + } + + /* finally name it */ + if (name) { + if (!ast_value_set_name(var, name)) { + ast_delete(var); + parseerror(parser, "internal error: failed to set name"); + return NULL; + } + /* free the name, ast_value_set_name duplicates */ + mem_d((void*)name); + } + + return var; +} + +static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofields) +{ + ast_value *var; + ast_value *proto; + ast_expression *old; + bool was_end; + size_t i; + + ast_value *basetype = NULL; + bool retval = true; + bool isparam = false; + bool isvector = false; + bool cleanvar = true; + bool wasarray = false; + + varentry_t varent, ve[3]; + + /* get the first complete variable */ + var = parse_typename(parser, &basetype); + if (!var) { + if (basetype) + ast_delete(basetype); + return false; + } + + memset(&varent, 0, sizeof(varent)); + memset(&ve, 0, sizeof(ve)); + + while (true) { + proto = NULL; + wasarray = false; + + /* Part 0: finish the type */ + if (parser->tok == '(') { + if (opts_standard == COMPILER_QCC) + parseerror(parser, "C-style function syntax is not allowed in -std=qcc"); + var = parse_parameter_list(parser, var); + if (!var) { + retval = false; + goto cleanup; + } + } + /* we only allow 1-dimensional arrays */ + if (parser->tok == '[') { + wasarray = true; + var = parse_arraysize(parser, var); + if (!var) { + retval = false; + goto cleanup; + } + } + if (parser->tok == '(' && wasarray) { + parseerror(parser, "arrays as part of a return type is not supported"); + /* we'll still parse the type completely for now */ + } + /* for functions returning functions */ + while (parser->tok == '(') { + if (opts_standard == COMPILER_QCC) + parseerror(parser, "C-style function syntax is not allowed in -std=qcc"); + var = parse_parameter_list(parser, var); + if (!var) { + retval = false; + goto cleanup; + } + } + + /* Part 1: + * check for validity: (end_sys_..., multiple-definitions, prototypes, ...) + * Also: if there was a prototype, `var` will be deleted and set to `proto` which + * is then filled with the previous definition and the parameter-names replaced. + */ + if (!localblock) { + /* Deal with end_sys_ vars */ + was_end = false; + if (!strcmp(var->name, "end_sys_globals")) { + parser->crc_globals = parser->globals_count; + was_end = true; + } + else if (!strcmp(var->name, "end_sys_fields")) { + parser->crc_fields = parser->fields_count; + was_end = true; + } + if (was_end && var->expression.vtype == TYPE_FIELD) { + if (parsewarning(parser, WARN_END_SYS_FIELDS, + "global '%s' hint should not be a field", + parser_tokval(parser))) + { + retval = false; + goto cleanup; } + } - if (!parser_next(parser)) { - ast_unref(framenum); - ast_value_delete(typevar); - return false; + if (!nofields && var->expression.vtype == TYPE_FIELD) + { + /* deal with field declarations */ + old = parser_find_field(parser, var->name); + if (old) { + if (parsewarning(parser, WARN_FIELD_REDECLARED, "field `%s` already declared here: %s:%i", + var->name, ast_ctx(old).file, (int)ast_ctx(old).line)) + { + retval = false; + goto cleanup; + } + ast_delete(var); + var = NULL; + goto skipvar; + /* + parseerror(parser, "field `%s` already declared here: %s:%i", + var->name, ast_ctx(old).file, ast_ctx(old).line); + retval = false; + goto cleanup; + */ + } + if (opts_standard == COMPILER_QCC && + (old = parser_find_global(parser, var->name))) + { + parseerror(parser, "cannot declare a field and a global of the same name with -std=qcc"); + parseerror(parser, "field `%s` already declared here: %s:%i", + var->name, ast_ctx(old).file, ast_ctx(old).line); + retval = false; + goto cleanup; + } + } + else + { + /* deal with other globals */ + old = parser_find_global(parser, var->name); + if (old && var->expression.vtype == TYPE_FUNCTION && old->expression.vtype == TYPE_FUNCTION) + { + /* This is a function which had a prototype */ + if (!ast_istype(old, ast_value)) { + parseerror(parser, "internal error: prototype is not an ast_value"); + retval = false; + goto cleanup; + } + proto = (ast_value*)old; + if (!ast_compare_type((ast_expression*)proto, (ast_expression*)var)) { + parseerror(parser, "conflicting types for `%s`, previous declaration was here: %s:%i", + proto->name, + ast_ctx(proto).file, ast_ctx(proto).line); + retval = false; + goto cleanup; + } + /* we need the new parameter-names */ + for (i = 0; i < proto->expression.params_count; ++i) + ast_value_set_name(proto->expression.params[i], var->expression.params[i]->name); + ast_delete(var); + var = proto; } - - if (parser->tok == TOKEN_IDENT && !parser_find_var(parser, parser_tokval(parser))) + else { - /* 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; + /* other globals */ + if (old) { + parseerror(parser, "global `%s` already declared here: %s:%i", + var->name, ast_ctx(old).file, ast_ctx(old).line); + retval = false; + goto cleanup; } - - if (!parser_next(parser)) { - ast_unref(framenum); - ast_value_delete(typevar); - return false; + if (opts_standard == COMPILER_QCC && + (old = parser_find_field(parser, var->name))) + { + parseerror(parser, "cannot declare a field and a global of the same name with -std=qcc"); + parseerror(parser, "global `%s` already declared here: %s:%i", + var->name, ast_ctx(old).file, ast_ctx(old).line); + retval = false; + goto cleanup; } + } + } + } + else /* it's not a global */ + { + old = parser_find_local(parser, var->name, parser->blocklocal, &isparam); + if (old && !isparam) { + parseerror(parser, "local `%s` already declared here: %s:%i", + var->name, ast_ctx(old).file, (int)ast_ctx(old).line); + retval = false; + goto cleanup; + } + old = parser_find_local(parser, var->name, 0, &isparam); + if (old && isparam) { + if (parsewarning(parser, WARN_LOCAL_SHADOWS, + "local `%s` is shadowing a parameter", var->name)) + { + parseerror(parser, "local `%s` already declared here: %s:%i", + var->name, ast_ctx(old).file, (int)ast_ctx(old).line); + retval = false; + goto cleanup; + } + if (opts_standard != COMPILER_GMQCC) { + ast_delete(var); + var = NULL; + goto skipvar; + } + } + } - varent.var = (ast_expression*)thinkfunc; - varent.name = util_strdup(thinkfunc->name); - (void)!parser_t_globals_add(parser, varent); - nextthink = (ast_expression*)thinkfunc; + /* Part 2: + * Create the global/local, and deal with vector types. + */ + if (!proto) { + if (var->expression.vtype == TYPE_VECTOR) + isvector = true; + else if (var->expression.vtype == TYPE_FIELD && + var->expression.next->expression.vtype == TYPE_VECTOR) + isvector = true; - } 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 (isvector) { + if (!create_vector_members(parser, var, ve)) { + retval = false; + goto cleanup; } + } - if (!ast_istype(nextthink, ast_value)) { - ast_unref(nextthink); - ast_unref(framenum); - parseerror(parser, "think-function in [frame,think] notation must be a constant"); + varent.name = util_strdup(var->name); + varent.var = (ast_expression*)var; + + if (!localblock) { + /* deal with global variables, fields, functions */ + if (!nofields && var->expression.vtype == TYPE_FIELD) { + if (!(retval = parser_t_fields_add(parser, varent))) + goto cleanup; + if (isvector) { + for (i = 0; i < 3; ++i) { + if (!(retval = parser_t_fields_add(parser, ve[i]))) + break; + } + if (!retval) { + parser->fields_count -= i+1; + goto cleanup; + } + } } - - if (parser->tok != ']') { - parseerror(parser, "expected closing `]` for [frame,think] notation"); - ast_unref(nextthink); - ast_unref(framenum); - ast_value_delete(typevar); - return false; + else { + if (!(retval = parser_t_globals_add(parser, varent))) + goto cleanup; + if (isvector) { + for (i = 0; i < 3; ++i) { + if (!(retval = parser_t_globals_add(parser, ve[i]))) + break; + } + if (!retval) { + parser->globals_count -= i+1; + goto cleanup; + } + } } - - if (!parser_next(parser)) { - ast_unref(nextthink); - ast_unref(framenum); - ast_value_delete(typevar); - return false; + } 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 (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; + if (isvector) { + for (i = 0; i < 3; ++i) { + if (!(retval = parser_t_locals_add(parser, ve[i]))) + break; + if (!(retval = ast_block_collect(localblock, ve[i].var))) + break; + ve[i].var = NULL; /* from here it's being collected in the block */ + } + if (!retval) { + parser->locals_count -= i+1; + localblock->locals_count--; + goto cleanup; + } } - - has_frame_think = true; } - block = ast_block_new(parser_ctx(parser)); - if (!block) { - parseerror(parser, "failed to allocate block"); - ast_value_delete(typevar); + varent.name = NULL; + ve[0].name = ve[1].name = ve[2].name = NULL; + ve[0].var = ve[1].var = ve[2].var = NULL; + cleanvar = false; + } + /* Part 2.2 + * deal with arrays + */ + if (var->expression.vtype == TYPE_ARRAY) { + char name[1024]; + snprintf(name, sizeof(name), "%s::SET", var->name); + if (!parser_create_array_setter(parser, var, name)) + goto cleanup; + snprintf(name, sizeof(name), "%s::GET", var->name); + if (!parser_create_array_getter(parser, var, name)) + goto cleanup; + } + +skipvar: + if (parser->tok == ';') { + ast_delete(basetype); + if (!parser_next(parser)) { + parseerror(parser, "error after variable declaration"); return false; } + return true; + } - 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 (parser->tok == ',') + goto another; - 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 (!var || (!localblock && !nofields && basetype->expression.vtype == TYPE_FIELD)) { + parseerror(parser, "missing comma or semicolon while parsing variables"); + break; + } - 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; - } + if (localblock && opts_standard == COMPILER_QCC) { + if (parsewarning(parser, WARN_LOCAL_CONSTANTS, + "initializing expression turns variable `%s` into a constant in this standard", + var->name) ) + { + break; } + } - for (parami = 0; parami < var->expression.params_count; ++parami) { - ast_value *param = var->expression.params[parami]; - varentry_t ve[3]; + if (parser->tok != '{') { + if (parser->tok != '=') { + parseerror(parser, "missing semicolon or initializer"); + break; + } - if (param->expression.vtype != TYPE_VECTOR && - (param->expression.vtype != TYPE_FIELD || - param->expression.next->expression.vtype != TYPE_VECTOR)) - { - continue; - } + if (!parser_next(parser)) { + parseerror(parser, "error parsing initializer"); + break; + } + } + else if (opts_standard == COMPILER_QCC) { + parseerror(parser, "expected '=' before function body in this standard"); + } - if (!create_vector_members(parser, param, ve)) { - ast_block_delete(block); - ast_value_delete(typevar); - return false; - } + if (parser->tok == '#') { + ast_function *func; - (void)!parser_t_locals_add(parser, ve[0]); - (void)!parser_t_locals_add(parser, ve[1]); - (void)!parser_t_locals_add(parser, ve[2]); - if (!ast_block_collect(block, ve[0].var) || - !ast_block_collect(block, ve[1].var) || - !ast_block_collect(block, ve[2].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; - } + if (localblock) { + parseerror(parser, "cannot declare builtins within functions"); + break; + } + if (var->expression.vtype != TYPE_FUNCTION) { + parseerror(parser, "unexpected builtin number, '%s' is not a function", var->name); + break; + } + if (!parser_next(parser)) { + parseerror(parser, "expected builtin number"); + break; + } + if (parser->tok != TOKEN_INTCONST) { + parseerror(parser, "builtin number must be an integer constant"); + break; + } + if (parser_token(parser)->constval.i <= 0) { + parseerror(parser, "builtin number must be an integer greater than zero"); + break; } 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); - return false; + break; } 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; + break; } - 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); + func->builtin = -parser_token(parser)->constval.i; - if (!block) { - ast_value_delete(typevar); - return false; + if (!parser_next(parser)) { + parseerror(parser, "expected comma or semicolon"); + ast_function_delete(func); + var->constval.vfunc = NULL; + break; } - - if (!ast_function_blocks_add(func, block)) { - ast_block_delete(block); - ast_value_delete(typevar); - return false; + } + else if (parser->tok == '{' || parser->tok == '[') + { + if (localblock) { + parseerror(parser, "cannot declare functions within functions"); + break; } - 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; + if (!parse_function_body(parser, var)) + break; + ast_delete(basetype); + return true; } else { ast_expression *cexp; ast_value *cval; - cexp = parser_expression_leave(parser, true); - if (!cexp) { - ast_value_delete(typevar); - return false; - } + cexp = parse_expression_leave(parser, true); + if (!cexp) + break; - cval = (ast_value*)cexp; - if (!ast_istype(cval, ast_value) || !cval->isconst) - parseerror(parser, "cannot initialize a global constant variable with a non-constant expression"); - else - { - var->isconst = true; - if (cval->expression.vtype == TYPE_STRING) - var->constval.vstring = parser_strdup(cval->constval.vstring); + if (!localblock) { + cval = (ast_value*)cexp; + if (!ast_istype(cval, ast_value) || !cval->isconst) + parseerror(parser, "cannot initialize a global constant variable with a non-constant expression"); else - memcpy(&var->constval, &cval->constval, sizeof(var->constval)); - ast_unref(cval); + { + var->isconst = true; + if (cval->expression.vtype == TYPE_STRING) + var->constval.vstring = parser_strdup(cval->constval.vstring); + else + memcpy(&var->constval, &cval->constval, sizeof(var->constval)); + ast_unref(cval); + } + } else { + shunt sy; + MEM_VECTOR_INIT(&sy, out); + MEM_VECTOR_INIT(&sy, ops); + if (!shunt_out_add(&sy, syexp(ast_ctx(var), (ast_expression*)var)) || + !shunt_out_add(&sy, syexp(ast_ctx(cexp), (ast_expression*)cexp)) || + !shunt_ops_add(&sy, syop(ast_ctx(var), parser->assign_op))) + { + parseerror(parser, "internal error: failed to prepare initializer"); + ast_unref(cexp); + } + else if (!parser_sy_pop(parser, &sy)) + ast_unref(cexp); + else { + if (sy.out_count != 1 && sy.ops_count != 0) + parseerror(parser, "internal error: leaked operands"); + else if (!ast_block_exprs_add(localblock, (ast_expression*)sy.out[0].out)) { + parseerror(parser, "failed to create intializing expression"); + ast_unref(sy.out[0].out); + ast_unref(cexp); + } + } + MEM_VECTOR_CLEAR(&sy, out); + MEM_VECTOR_CLEAR(&sy, ops); } } +another: if (parser->tok == ',') { - /* another */ + if (!parser_next(parser)) { + parseerror(parser, "expected another variable"); + break; + } + + if (parser->tok != TOKEN_IDENT) { + parseerror(parser, "expected another variable"); + break; + } + var = ast_value_copy(basetype); + cleanvar = true; + ast_value_set_name(var, parser_tokval(parser)); + if (!parser_next(parser)) { + parseerror(parser, "error parsing variable declaration"); + break; + } continue; } if (parser->tok != ';') { - parseerror(parser, "missing semicolon"); - ast_value_delete(typevar); - return false; + parseerror(parser, "missing semicolon after variables"); + break; } - (void)parser_next(parser); + if (!parser_next(parser)) { + parseerror(parser, "parse error after variable declaration"); + break; + } - ast_value_delete(typevar); + ast_delete(basetype); return true; } + + if (cleanvar && var) + ast_delete(var); + ast_delete(basetype); + return false; + +cleanup: + ast_delete(basetype); + if (cleanvar && var) + 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) + if (parser->tok == TOKEN_TYPENAME || parser->tok == '.') { - return parser_variable(parser, NULL); + return parse_variable(parser, NULL, false); } else if (parser->tok == TOKEN_KEYWORD) { /* handle 'var' and 'const' */ - return false; - } - else if (parser->tok == '.') - { - ast_value *var; - ast_value *typevar; - ast_value *fld; - ast_expression *oldex; - bool isfunc = false; - int basetype; - lex_ctx ctx = parser_ctx(parser); - varentry_t varent; - - /* entity-member declaration */ - if (!parser_next(parser) || parser->tok != TOKEN_TYPENAME) { - parseerror(parser, "expected member variable definition"); - return false; - } - - /* remember the base/return type */ - basetype = parser_token(parser)->constval.t; - - /* parse into the declaration */ - if (!parser_next(parser)) { - parseerror(parser, "expected field definition"); - return false; - } - - /* parse the field type fully */ - typevar = var = parser_parse_type(parser, basetype, &isfunc); - if (!var) - return false; - - while (true) { - var = ast_value_copy(typevar); - /* now the field name */ - if (parser->tok != TOKEN_IDENT) { - parseerror(parser, "expected field name"); - ast_delete(var); - return false; - } - - /* check for an existing field - * in original qc we also have to check for an existing - * global named like the field - */ - if (opts_standard == COMPILER_QCC) { - if (parser_find_global(parser, parser_tokval(parser))) { - parseerror(parser, "cannot declare a field and a global of the same name with -std=qcc"); - ast_delete(var); - return false; - } - } - - if (isfunc) { - ast_value *fval; - fval = ast_value_new(ctx, var->name, TYPE_FUNCTION); - if (!fval) { - ast_value_delete(var); - return false; - } - fval->expression.next = (ast_expression*)var; - MEM_VECTOR_MOVE(&var->expression, params, &fval->expression, params); - fval->expression.variadic = var->expression.variadic; - var = fval; - } - - /* turn it into a field */ - fld = ast_value_new(ctx, parser_tokval(parser), TYPE_FIELD); - fld->expression.next = (ast_expression*)var; - - if ( (oldex = parser_find_field(parser, parser_tokval(parser)))) { - if (ast_istype(oldex, ast_member)) { - parseerror(parser, "cannot declare a field with the same name as a vector component, component %s has been declared here: %s:%i", - parser_tokval(parser), ast_ctx(oldex).file, (int)ast_ctx(oldex).line); - ast_delete(fld); - return false; - } - if (!ast_istype(oldex, ast_value)) { - /* not possible / sanity check */ - parseerror(parser, "internal error: %s is not an ast_value", parser_tokval(parser)); - ast_delete(fld); - return false; - } - - if (!ast_compare_type(oldex, (ast_expression*)fld)) { - parseerror(parser, "field %s has previously been declared with a different type here: %s:%i", - parser_tokval(parser), ast_ctx(oldex).file, (int)ast_ctx(oldex).line); - ast_delete(fld); - return false; - } else { - if (parsewarning(parser, WARN_FIELD_REDECLARED, "field `%s` has already been declared here: %s:%i", - parser_tokval(parser), ast_ctx(oldex).file, (int)ast_ctx(oldex).line)) - { - ast_delete(fld); - return false; - } - } - - ast_delete(fld); - goto nextfield; - } - - varent.var = (ast_expression*)fld; - varent.name = util_strdup(fld->name); - (void)!parser_t_fields_add(parser, varent); - - if (var->expression.vtype == TYPE_VECTOR) - { - /* create _x, _y and _z fields as well */ - varentry_t ve[3]; - if (!create_vector_members(parser, fld, ve)) { - ast_delete(fld); - return false; - } - (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: + if (!strcmp(parser_tokval(parser), "var")) { if (!parser_next(parser)) { - parseerror(parser, "expected semicolon or another field name"); - return false; - } - if (parser->tok == ';') - break; - if (parser->tok != ',' || !parser_next(parser)) { - parseerror(parser, "expected semicolon or another field name"); + parseerror(parser, "expected variable declaration after 'var'"); return false; } + return parse_variable(parser, NULL, true); } - ast_delete(typevar); - - /* skip the semicolon */ - if (!parser_next(parser)) - return parser->tok == TOKEN_EOF; - - return true; + return false; } else if (parser->tok == '$') { @@ -2731,7 +3302,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; @@ -2741,11 +3312,24 @@ static parser_t *parser; bool parser_init() { + size_t i; parser = (parser_t*)mem_a(sizeof(parser_t)); if (!parser) return false; memset(parser, 0, sizeof(*parser)); + + for (i = 0; i < operator_count; ++i) { + if (operators[i].id == opid1('=')) { + parser->assign_op = operators+i; + break; + } + } + if (!parser->assign_op) { + printf("internal error: initializing parser: failed to find assign operator\n"); + mem_d(parser); + return false; + } return true; } @@ -2764,11 +3348,11 @@ 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) - parseerror(parser, "parse error"); + parseerror(parser, "there have been errors, bailing out"); lex_close(parser->lex); parser->lex = NULL; return false; @@ -2821,6 +3405,78 @@ void parser_cleanup() mem_d(parser); } +static uint16_t progdefs_crc_sum(uint16_t old, const char *str) +{ + return util_crc16(old, str, strlen(str)); +} + +static void progdefs_crc_file(const char *str) +{ + /* write to progdefs.h here */ +} + +static uint16_t progdefs_crc_both(uint16_t old, const char *str) +{ + old = progdefs_crc_sum(old, str); + progdefs_crc_file(str); + return old; +} + +static void generate_checksum(parser_t *parser) +{ + uint16_t crc = 0xFFFF; + size_t i; + + crc = progdefs_crc_both(crc, "\n/* file generated by qcc, do not modify */\n\ntypedef struct\n{"); + crc = progdefs_crc_sum(crc, "\tint\tpad[28];\n"); + /* + progdefs_crc_file("\tint\tpad;\n"); + progdefs_crc_file("\tint\tofs_return[3];\n"); + progdefs_crc_file("\tint\tofs_parm0[3];\n"); + progdefs_crc_file("\tint\tofs_parm1[3];\n"); + progdefs_crc_file("\tint\tofs_parm2[3];\n"); + progdefs_crc_file("\tint\tofs_parm3[3];\n"); + progdefs_crc_file("\tint\tofs_parm4[3];\n"); + progdefs_crc_file("\tint\tofs_parm5[3];\n"); + progdefs_crc_file("\tint\tofs_parm6[3];\n"); + progdefs_crc_file("\tint\tofs_parm7[3];\n"); + */ + for (i = 0; i < parser->crc_globals; ++i) { + if (!ast_istype(parser->globals[i].var, ast_value)) + continue; + switch (parser->globals[i].var->expression.vtype) { + case TYPE_FLOAT: crc = progdefs_crc_both(crc, "\tfloat\t"); break; + case TYPE_VECTOR: crc = progdefs_crc_both(crc, "\tvec3_t\t"); break; + case TYPE_STRING: crc = progdefs_crc_both(crc, "\tstring_t\t"); break; + case TYPE_FUNCTION: crc = progdefs_crc_both(crc, "\tfunc_t\t"); break; + default: + crc = progdefs_crc_both(crc, "\tint\t"); + break; + } + crc = progdefs_crc_both(crc, parser->globals[i].name); + crc = progdefs_crc_both(crc, ";\n"); + } + crc = progdefs_crc_both(crc, "} globalvars_t;\n\ntypedef struct\n{\n"); + for (i = 0; i < parser->crc_fields; ++i) { + if (!ast_istype(parser->fields[i].var, ast_value)) + continue; + switch (parser->fields[i].var->expression.next->expression.vtype) { + case TYPE_FLOAT: crc = progdefs_crc_both(crc, "\tfloat\t"); break; + case TYPE_VECTOR: crc = progdefs_crc_both(crc, "\tvec3_t\t"); break; + case TYPE_STRING: crc = progdefs_crc_both(crc, "\tstring_t\t"); break; + case TYPE_FUNCTION: crc = progdefs_crc_both(crc, "\tfunc_t\t"); break; + default: + crc = progdefs_crc_both(crc, "\tint\t"); + break; + } + crc = progdefs_crc_both(crc, parser->fields[i].name); + crc = progdefs_crc_both(crc, ";\n"); + } + crc = progdefs_crc_both(crc, "} entvars_t;\n\n"); + + code_crc = crc; +} + bool parser_finish(const char *output) { size_t i; @@ -2843,7 +3499,7 @@ bool parser_finish(const char *output) field = (ast_value*)parser->fields[i].var; isconst = field->isconst; field->isconst = false; - if (!ast_global_codegen((ast_value*)field, ir)) { + if (!ast_global_codegen((ast_value*)field, ir, true)) { printf("failed to generate field %s\n", field->name); ir_builder_delete(ir); return false; @@ -2867,36 +3523,64 @@ bool parser_finish(const char *output) continue; asvalue = (ast_value*)(parser->globals[i].var); if (!asvalue->uses && !asvalue->isconst && asvalue->expression.vtype != TYPE_FUNCTION) { - retval = retval && !genwarning(ast_ctx(asvalue), WARN_UNUSED_VARIABLE, - "unused global: `%s`", asvalue->name); + if (strcmp(asvalue->name, "end_sys_globals") && + strcmp(asvalue->name, "end_sys_fields")) + { + retval = retval && !genwarning(ast_ctx(asvalue), WARN_UNUSED_VARIABLE, + "unused global: `%s`", asvalue->name); + } } - if (!ast_global_codegen(asvalue, ir)) { + if (!ast_global_codegen(asvalue, ir, false)) { printf("failed to generate global %s\n", parser->globals[i].name); ir_builder_delete(ir); return false; } } for (i = 0; i < parser->imm_float_count; ++i) { - if (!ast_global_codegen(parser->imm_float[i], ir)) { + if (!ast_global_codegen(parser->imm_float[i], ir, false)) { printf("failed to generate global %s\n", parser->imm_float[i]->name); ir_builder_delete(ir); return false; } } for (i = 0; i < parser->imm_string_count; ++i) { - if (!ast_global_codegen(parser->imm_string[i], ir)) { + if (!ast_global_codegen(parser->imm_string[i], ir, false)) { printf("failed to generate global %s\n", parser->imm_string[i]->name); ir_builder_delete(ir); return false; } } for (i = 0; i < parser->imm_vector_count; ++i) { - if (!ast_global_codegen(parser->imm_vector[i], ir)) { + if (!ast_global_codegen(parser->imm_vector[i], ir, false)) { printf("failed to generate global %s\n", parser->imm_vector[i]->name); ir_builder_delete(ir); return false; } } + for (i = 0; i < parser->globals_count; ++i) { + ast_value *asvalue; + if (!ast_istype(parser->globals[i].var, ast_value)) + continue; + asvalue = (ast_value*)(parser->globals[i].var); + if (asvalue->setter) { + if (!ast_global_codegen(asvalue->setter, ir, false) || + !ast_function_codegen(asvalue->setter->constval.vfunc, ir)) + { + printf("failed to generate setter for %s\n", parser->globals[i].name); + ir_builder_delete(ir); + return false; + } + } + if (asvalue->getter) { + if (!ast_global_codegen(asvalue->getter, ir, false) || + !ast_function_codegen(asvalue->getter->constval.vfunc, ir)) + { + printf("failed to generate getter for %s\n", parser->globals[i].name); + ir_builder_delete(ir); + return false; + } + } + } for (i = 0; i < parser->functions_count; ++i) { if (!ast_function_codegen(parser->functions[i], ir)) { printf("failed to generate function %s\n", parser->functions[i]->name); @@ -2914,6 +3598,8 @@ bool parser_finish(const char *output) if (opts_dump) ir_builder_dump(ir, printf); + generate_checksum(parser); + if (!ir_builder_generate(ir, output)) { printf("*** failed to generate output file\n"); ir_builder_delete(ir);