X-Git-Url: https://git.xonotic.org/?a=blobdiff_plain;f=parser.c;h=33eba59f7960d774ad03dbb4a8bc72dc1f77d741;hb=c84830bdee1bc4b36d55fdfd320b301f59a1e361;hp=aa470f1e59deedcb8f0e72f085d356e95f24a3eb;hpb=28891c5a37620605201221d2e9ac7bf2cbf38da7;p=xonotic%2Fgmqcc.git diff --git a/parser.c b/parser.c index aa470f1..33eba59 100644 --- a/parser.c +++ b/parser.c @@ -44,9 +44,10 @@ MEM_VEC_FUNCTIONS(parser_t, ast_value*, imm_vector) MEM_VEC_FUNCTIONS(parser_t, varentry_t, locals) MEM_VEC_FUNCTIONS(parser_t, ast_function*, functions) -static void parser_pop_local(parser_t *parser); +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); +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); @@ -127,8 +128,12 @@ bool parser_next(parser_t *parser) { /* lex_do kills the previous token */ parser->tok = lex_do(parser->lex); - if (parser->tok == TOKEN_EOF || parser->tok >= TOKEN_ERROR) + if (parser->tok == TOKEN_EOF) + return true; + if (parser->tok >= TOKEN_ERROR) { + parseerror(parser, "lex error"); return false; + } return true; } @@ -169,7 +174,7 @@ ast_value* parser_const_float_0(parser_t *parser) return parser->imm_float_zero; } -char *parser_strdup(const char *str) +static char *parser_strdup(const char *str) { if (str && !*str) { /* actually dup empty strings */ @@ -252,15 +257,10 @@ ast_expression* parser_find_global(parser_t *parser, const char *name) return NULL; } -ast_expression* parser_find_local(parser_t *parser, const char *name, size_t upto) +ast_expression* parser_find_param(parser_t *parser, const char *name) { size_t i; ast_value *fun; - for (i = parser->locals_count; i > upto;) { - --i; - if (!strcmp(parser->locals[i].name, name)) - return parser->locals[i].var; - } if (!parser->function) return NULL; fun = parser->function->vtype; @@ -271,10 +271,24 @@ ast_expression* parser_find_local(parser_t *parser, const char *name, size_t upt return NULL; } +ast_expression* parser_find_local(parser_t *parser, const char *name, size_t upto, bool *isparam) +{ + size_t i; + *isparam = false; + for (i = parser->locals_count; i > upto;) { + --i; + if (!strcmp(parser->locals[i].name, name)) + return parser->locals[i].var; + } + *isparam = true; + return parser_find_param(parser, name); +} + ast_expression* parser_find_var(parser_t *parser, const char *name) { + bool dummy; ast_expression *v; - v = parser_find_local(parser, name, 0); + v = parser_find_local(parser, name, 0, &dummy); if (!v) v = parser_find_global(parser, name); return v; } @@ -292,6 +306,7 @@ static ast_value *parser_parse_type(parser_t *parser, int basetype, bool *isfunc int vtype = basetype; int temptype; size_t i; + bool variadic = false; MEM_VECTOR_INIT(¶ms, p); @@ -303,7 +318,7 @@ static ast_value *parser_parse_type(parser_t *parser, int basetype, bool *isfunc ast_value *param; ast_value *fld; bool isfield = false; - bool dummy; + bool isfuncparam = false; if (!parser_next(parser)) goto on_error; @@ -319,12 +334,27 @@ static ast_value *parser_parse_type(parser_t *parser, int basetype, bool *isfunc } } + 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, &dummy); - (void)dummy; + param = parser_parse_type(parser, temptype, &isfuncparam); if (!param) goto on_error; @@ -337,6 +367,19 @@ static ast_value *parser_parse_type(parser_t *parser, int basetype, bool *isfunc 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; @@ -362,6 +405,7 @@ static ast_value *parser_parse_type(parser_t *parser, int basetype, bool *isfunc 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: @@ -927,16 +971,21 @@ static bool parser_close_call(parser_t *parser, shunt *sy) parseerror(parser, "could not determine function return type"); return false; } else { - if (fun->expression.params_count != paramcount) { + if (fun->expression.params_count != paramcount && + !(fun->expression.variadic && + fun->expression.params_count < paramcount)) + { ast_value *fval; + const char *fewmany = (fun->expression.params_count > paramcount) ? "few" : "many"; + fval = (ast_istype(fun, ast_value) ? ((ast_value*)fun) : NULL); if (opts_standard == COMPILER_GMQCC) { if (fval) - parseerror(parser, "too few parameters for call to %s: expected %i, got %i", + parseerror(parser, "too %s parameters for call to %s: expected %i, got %i", fewmany, fval->name, (int)fun->expression.params_count, paramcount); else - parseerror(parser, "too few parameters for function call: expected %i, got %i", + parseerror(parser, "too %s parameters for function call: expected %i, got %i", fewmany, (int)fun->expression.params_count, paramcount); return false; } @@ -944,11 +993,11 @@ static bool parser_close_call(parser_t *parser, shunt *sy) { if (fval) return !parsewarning(parser, WARN_TOO_FEW_PARAMETERS, - "too few parameters for call to %s: expected %i, got %i", + "too %s parameters for call to %s: expected %i, got %i", fewmany, fval->name, (int)fun->expression.params_count, paramcount); else return !parsewarning(parser, WARN_TOO_FEW_PARAMETERS, - "too few parameters for function call: expected %i, got %i", + "too %s parameters for function call: expected %i, got %i", fewmany, (int)fun->expression.params_count, paramcount); } } @@ -963,10 +1012,12 @@ static bool parser_close_paren(parser_t *parser, shunt *sy, bool functions_only) parseerror(parser, "unmatched closing paren"); return false; } + /* this would for bit a + (x) because there are no operators inside (x) if (sy->ops[sy->ops_count-1].paren == 1) { parseerror(parser, "empty parenthesis expression"); return false; } + */ while (sy->ops_count) { if (sy->ops[sy->ops_count-1].paren == 'f') { if (!parser_close_call(parser, sy)) @@ -1057,6 +1108,8 @@ static ast_expression* parser_expression_leave(parser_t *parser, bool stopatcomm parseerror(parser, "unexpected ident: %s", parser_tokval(parser)); goto onerr; } + if (ast_istype(var, ast_value)) + ((ast_value*)var)->uses++; if (!shunt_out_add(&sy, syexp(parser_ctx(parser), var))) { parseerror(parser, "out of memory"); goto onerr; @@ -1185,8 +1238,11 @@ static ast_expression* parser_expression_leave(parser_t *parser, bool stopatcomm op = &operators[o]; /* when declaring variables, a comma starts a new variable */ - if (op->id == opid1(',') && !parens && stopatcomma) + if (op->id == opid1(',') && !parens && stopatcomma) { + /* fixup the token */ + parser->tok = ','; break; + } if (sy.ops_count && !sy.ops[sy.ops_count-1].paren) olast = &operators[sy.ops[sy.ops_count-1].etype-1]; @@ -1223,7 +1279,7 @@ static ast_expression* parser_expression_leave(parser_t *parser, bool stopatcomm if (op->id == opid1('(')) { if (wantop) { - DEBUGSHUNTDO(printf("push (\n")); + 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))) { @@ -1236,7 +1292,7 @@ static ast_expression* parser_expression_leave(parser_t *parser, bool stopatcomm parseerror(parser, "out of memory"); goto onerr; } - DEBUGSHUNTDO(printf("push (\n")); + DEBUGSHUNTDO(printf("push [nop] (\n")); } wantop = false; } else { @@ -1249,7 +1305,7 @@ static ast_expression* parser_expression_leave(parser_t *parser, bool stopatcomm if (!parser_next(parser)) { goto onerr; } - if (parser->tok == ';') { + if (parser->tok == ';' || parser->tok == ']') { break; } } @@ -1466,6 +1522,7 @@ static bool parser_parse_for(parser_t *parser, ast_block *block, ast_expression ast_loop *aloop; ast_expression *initexpr, *cond, *increment, *ontrue; size_t oldblocklocal; + bool retval = true; lex_ctx ctx = parser_ctx(parser); @@ -1560,15 +1617,15 @@ static bool parser_parse_for(parser_t *parser, ast_block *block, ast_expression *out = (ast_expression*)aloop; while (parser->locals_count > parser->blocklocal) - parser_pop_local(parser); + retval = retval && parser_pop_local(parser); parser->blocklocal = oldblocklocal; - return true; + return retval; onerr: if (initexpr) ast_delete(initexpr); if (cond) ast_delete(cond); if (increment) ast_delete(increment); while (parser->locals_count > parser->blocklocal) - parser_pop_local(parser); + (void)!parser_pop_local(parser); parser->blocklocal = oldblocklocal; return false; } @@ -1673,7 +1730,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); + inner = parser_parse_block(parser, false); if (!inner) return false; *out = (ast_expression*)inner; @@ -1689,16 +1746,24 @@ static bool parser_parse_statement(parser_t *parser, ast_block *block, ast_expre } } -static void parser_pop_local(parser_t *parser) +static bool GMQCC_WARN parser_pop_local(parser_t *parser) { + varentry_t *ve; parser->locals_count--; + + ve = &parser->locals[parser->locals_count]; + if (ast_istype(ve->var, ast_value) && !(((ast_value*)(ve->var))->uses)) { + if (parsewarning(parser, WARN_UNUSED_VARIABLE, "unused variable: `%s`", ve->name)) + return false; + } mem_d(parser->locals[parser->locals_count].name); + return true; } -static ast_block* parser_parse_block(parser_t *parser) +static bool parser_parse_block_into(parser_t *parser, ast_block *block, bool warnreturn) { size_t oldblocklocal; - ast_block *block = NULL; + bool retval = true; oldblocklocal = parser->blocklocal; parser->blocklocal = parser->locals_count; @@ -1708,8 +1773,6 @@ static ast_block* parser_parse_block(parser_t *parser) goto cleanup; } - block = ast_block_new(parser_ctx(parser)); - while (parser->tok != TOKEN_EOF && parser->tok < TOKEN_ERROR) { ast_expression *expr; @@ -1718,7 +1781,6 @@ static ast_block* parser_parse_block(parser_t *parser) if (!parser_parse_statement(parser, block, &expr)) { parseerror(parser, "parse error"); - ast_block_delete(block); block = NULL; goto cleanup; } @@ -1726,24 +1788,45 @@ static ast_block* parser_parse_block(parser_t *parser) continue; if (!ast_block_exprs_add(block, expr)) { ast_delete(expr); - ast_block_delete(block); block = NULL; goto cleanup; } } if (parser->tok != '}') { - ast_block_delete(block); block = NULL; } else { + if (warnreturn && parser->function->vtype->expression.next->expression.vtype != TYPE_VOID) + { + if (!block->exprs_count || + !ast_istype(block->exprs[block->exprs_count-1], ast_return)) + { + if (parsewarning(parser, WARN_MISSING_RETURN_VALUES, "control reaches end of non-void function")) { + block = NULL; + goto cleanup; + } + } + } (void)parser_next(parser); } cleanup: while (parser->locals_count > parser->blocklocal) - parser_pop_local(parser); + retval = retval && parser_pop_local(parser); parser->blocklocal = oldblocklocal; - /* unroll the local vector */ + return !!block; +} + +static ast_block* parser_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)) { + ast_block_delete(block); + return NULL; + } return block; } @@ -1751,66 +1834,188 @@ static ast_expression* parser_parse_statement_or_block(parser_t *parser) { ast_expression *expr = NULL; if (parser->tok == '{') - return (ast_expression*)parser_parse_block(parser); + return (ast_expression*)parser_parse_block(parser, false); if (!parser_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) +{ + 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; + } + + 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; + } + + 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 ( !(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)"); + 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 ( !(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; + } + + 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; +} + static bool parser_variable(parser_t *parser, ast_block *localblock) { bool isfunc = false; - ast_function *func = NULL; lex_ctx ctx; ast_value *var; varentry_t varent; ast_expression *olddecl; + ast_value *typevar; + bool hadproto; + bool isparam; + + bool retval = true; int basetype = parser_token(parser)->constval.t; + if (!parser_next(parser)) { + parseerror(parser, "expected variable definition"); + return false; + } + + typevar = parser_parse_type(parser, basetype, &isfunc); + if (!typevar) + return false; + while (true) { hadproto = false; - - if (!parser_next(parser)) { /* skip basetype or comma */ - parseerror(parser, "expected variable declaration"); - return false; - } - olddecl = NULL; - isfunc = false; - func = NULL; + isparam = false; + ctx = parser_ctx(parser); - var = parser_parse_type(parser, basetype, &isfunc); + var = ast_value_copy(typevar); - if (!var) + if (!var) { + ast_delete(typevar); + parseerror(parser, "failed to create variable"); return false; + } if (parser->tok != TOKEN_IDENT) { - parseerror(parser, "expected variable name\n"); + parseerror(parser, "expected variable name"); + ast_value_delete(typevar); + ast_value_delete(var); 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))) { - 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 (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( (!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; + } + } } } 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; } @@ -1819,11 +2024,12 @@ static bool parser_variable(parser_t *parser, ast_block *localblock) /* a function was defined */ ast_value *fval; ast_value *proto = NULL; + bool dummy; if (!localblock) olddecl = parser_find_global(parser, parser_tokval(parser)); else - olddecl = parser_find_local(parser, parser_tokval(parser), parser->blocklocal); + olddecl = parser_find_local(parser, parser_tokval(parser), parser->blocklocal, &dummy); if (olddecl) { /* we had a prototype */ @@ -1847,16 +2053,16 @@ static bool parser_variable(parser_t *parser, ast_block *localblock) * as return type */ fval = ast_value_new(ctx, var->name, TYPE_FUNCTION); - func = ast_function_new(ctx, var->name, fval); - if (!fval || !func) { + if (!fval) { ast_value_delete(var); + ast_value_delete(typevar); if (fval) ast_value_delete(fval); - if (func) ast_function_delete(func); 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 @@ -1867,29 +2073,21 @@ static bool parser_variable(parser_t *parser, ast_block *localblock) parseerror(parser, "conflicting types for `%s`, previous declaration was here: %s:%i", proto->name, ast_ctx(proto).file, ast_ctx(proto).line); - ast_function_delete(func); 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_function_delete(func); ast_value_delete(fval); fval = proto; - func = proto->constval.vfunc; hadproto = true; } - else - { - if (!parser_t_functions_add(parser, func)) { - ast_function_delete(func); - ast_value_delete(fval); - return false; - } - } var = fval; } @@ -1899,22 +2097,12 @@ static bool parser_variable(parser_t *parser, ast_block *localblock) varent.var = (ast_expression*)var; if (var->expression.vtype == TYPE_VECTOR) { - size_t len = strlen(varent.name); varentry_t vx, vy, vz; - vx.var = (ast_expression*)ast_member_new(var->expression.node.context, (ast_expression*)var, 0); - vy.var = (ast_expression*)ast_member_new(var->expression.node.context, (ast_expression*)var, 1); - vz.var = (ast_expression*)ast_member_new(var->expression.node.context, (ast_expression*)var, 2); - vx.name = (char*)mem_a(len+3); - vy.name = (char*)mem_a(len+3); - vz.name = (char*)mem_a(len+3); - memcpy(vx.name, varent.name, len); - memcpy(vy.name, varent.name, len); - memcpy(vz.name, varent.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; + if (!create_vector_members(parser, var, &vx, &vy, &vz)) { + ast_delete(var); + ast_value_delete(typevar); + return false; + } if (!localblock) { (void)!parser_t_globals_add(parser, varent); @@ -1931,11 +2119,12 @@ static bool parser_variable(parser_t *parser, ast_block *localblock) !ast_block_collect(localblock, vy.var) || !ast_block_collect(localblock, vz.var)) { - parser_pop_local(parser); - parser_pop_local(parser); - parser_pop_local(parser); - parser_pop_local(parser); + (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; } } @@ -1946,107 +2135,409 @@ static bool parser_variable(parser_t *parser, ast_block *localblock) ( 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)) { - parser_pop_local(parser); + (void)!parser_pop_local(parser); ast_value_delete(var); + ast_value_delete(typevar); return false; } } } +nextvar: if (!parser_next(parser)) { + ast_value_delete(typevar); ast_value_delete(var); return false; } if (parser->tok == ';') { + ast_value_delete(typevar); if (!parser_next(parser)) - return parser->tok == TOKEN_EOF; + return false; return true; } if (parser->tok == ',') { /* another var */ + if (!parser_next(parser)) { + ast_delete(typevar); + return false; + } continue; } + 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 (parser->tok != '=') { + ast_value_delete(typevar); parseerror(parser, "expected '=' or ';'"); return false; } - if (!parser_next(parser)) + if (!parser_next(parser)) { + ast_value_delete(typevar); return false; + } if (parser->tok == '#') { + ast_function *func; + if (localblock) { parseerror(parser, "cannot declare builtins within functions"); + ast_value_delete(typevar); return false; } - if (!isfunc || !func) { + if (!isfunc) { parseerror(parser, "unexpected builtin number, '%s' is not a function", var->name); + ast_value_delete(typevar); return false; } if (!parser_next(parser)) { parseerror(parser, "expected builtin number"); + ast_value_delete(typevar); return false; } if (parser->tok != TOKEN_INTCONST) { parseerror(parser, "builtin number must be an integer constant"); + ast_value_delete(typevar); return 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; + } + + 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 (!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)) + if (!parser_next(parser)) { + ast_value_delete(typevar); return false; - } else if (parser->tok == '{') { + } + } else if (parser->tok == '{' || parser->tok == '[') { /* function body */ + ast_function *func; + ast_function *old; ast_block *block; - ast_function *old = parser->function; + 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; + } + } 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); + 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; - block = parser_parse_block(parser); + 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) + 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 == ';') + 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)"); - return true; + ast_value_delete(typevar); + return retval; } else { ast_expression *cexp; ast_value *cval; cexp = parser_expression_leave(parser, true); + if (!cexp) { + ast_value_delete(typevar); + return false; + } + 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; - memcpy(&var->constval, &cval->constval, sizeof(var->constval)); - memset(&cval->constval, 0, sizeof(cval->constval)); + 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); } } @@ -2058,11 +2549,13 @@ static bool parser_variable(parser_t *parser, ast_block *localblock) if (parser->tok != ';') { parseerror(parser, "missing semicolon"); + ast_value_delete(typevar); return false; } (void)parser_next(parser); + ast_value_delete(typevar); return true; } } @@ -2100,7 +2593,7 @@ static bool parser_do(parser_t *parser) /* parse into the declaration */ if (!parser_next(parser)) { - parseerror(parser, "expected field def"); + parseerror(parser, "expected field definition"); return false; } @@ -2139,6 +2632,7 @@ static bool parser_do(parser_t *parser) } fval->expression.next = (ast_expression*)var; MEM_VECTOR_MOVE(&var->expression, params, &fval->expression, params); + fval->expression.variadic = var->expression.variadic; var = fval; } @@ -2166,7 +2660,7 @@ static bool parser_do(parser_t *parser) ast_delete(fld); return false; } else { - if (parsewarning(parser, WARN_FIELD_REDECLARED, "field %s has already been declared here: %s:%i", + 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); @@ -2185,24 +2679,11 @@ static bool parser_do(parser_t *parser) if (var->expression.vtype == TYPE_VECTOR) { /* create _x, _y and _z fields as well */ - size_t len; varentry_t vx, vy, vz; - - len = strlen(varent.name); - vx.var = (ast_expression*)ast_member_new(ast_ctx(fld), (ast_expression*)fld, 0); - vy.var = (ast_expression*)ast_member_new(ast_ctx(fld), (ast_expression*)fld, 1); - vz.var = (ast_expression*)ast_member_new(ast_ctx(fld), (ast_expression*)fld, 2); - vx.name = (char*)mem_a(len+3); - vy.name = (char*)mem_a(len+3); - vz.name = (char*)mem_a(len+3); - memcpy(vx.name, varent.name, len); - memcpy(vy.name, varent.name, len); - memcpy(vz.name, varent.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; + if (!create_vector_members(parser, fld, &vx, &vy, &vz)) { + 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); @@ -2274,12 +2755,17 @@ bool parser_compile(const char *filename) if (parser->tok == TOKEN_EOF) parseerror(parser, "unexpected eof"); else if (!parser->errors) - parseerror(parser, "parse error\n"); + parseerror(parser, "parse error"); lex_close(parser->lex); parser->lex = NULL; return false; } } + } else { + parseerror(parser, "parse error"); + lex_close(parser->lex); + parser->lex = NULL; + return false; } lex_close(parser->lex); @@ -2335,27 +2821,6 @@ bool parser_finish(const char *output) return false; } - for (i = 0; i < parser->imm_float_count; ++i) { - if (!ast_global_codegen(parser->imm_float[i], ir)) { - 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)) { - 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)) { - printf("failed to generate global %s\n", parser->imm_vector[i]->name); - ir_builder_delete(ir); - return false; - } - } for (i = 0; i < parser->fields_count; ++i) { ast_value *field; bool isconst; @@ -2391,6 +2856,27 @@ bool parser_finish(const char *output) return false; } } + for (i = 0; i < parser->imm_float_count; ++i) { + if (!ast_global_codegen(parser->imm_float[i], ir)) { + 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)) { + 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)) { + printf("failed to generate global %s\n", parser->imm_vector[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);