X-Git-Url: https://git.xonotic.org/?a=blobdiff_plain;f=parser.c;h=ee4718519ece62aae2edf5b6c65ab6b66320fd9e;hb=52b4c9f0c10267fbba0c81336de56265ed0c6f4d;hp=8001ffaa39a3c63eafa7e3e541216ad7d870cdd6;hpb=0e4e81d94f0ad27b9f5d3f105495c45ef0aae8f4;p=xonotic%2Fgmqcc.git diff --git a/parser.c b/parser.c index 8001ffa..ee47185 100644 --- a/parser.c +++ b/parser.c @@ -124,40 +124,22 @@ static void parseerror(parser_t *parser, const char *fmt, ...) /* returns true if it counts as an error */ static bool GMQCC_WARN parsewarning(parser_t *parser, int warntype, const char *fmt, ...) { + bool r; va_list ap; - int lvl = LVL_WARNING; - - if (!OPTS_WARN(warntype)) - return false; - - if (opts_werror) { - parser->errors++; - lvl = LVL_ERROR; - } - va_start(ap, fmt); - con_vprintmsg(lvl, parser->lex->tok.ctx.file, parser->lex->tok.ctx.line, "warning", fmt, ap); + r = vcompile_warning(parser->lex->tok.ctx, warntype, fmt, ap); va_end(ap); - - return opts_werror; + return r; } static bool GMQCC_WARN genwarning(lex_ctx ctx, int warntype, const char *fmt, ...) { + bool r; va_list ap; - int lvl = LVL_WARNING; - - if (!OPTS_WARN(warntype)) - return false; - - if (opts_werror) - lvl = LVL_ERROR; - va_start(ap, fmt); - con_vprintmsg(lvl, ctx.file, ctx.line, "warning", fmt, ap); + r = vcompile_warning(ctx, warntype, fmt, ap); va_end(ap); - - return opts_werror; + return r; } /********************************************************************** @@ -484,7 +466,7 @@ static bool rotate_entfield_array_index_nodes(ast_expression **out) return true; } -static bool parser_sy_pop(parser_t *parser, shunt *sy) +static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) { const oper_info *op; lex_ctx ctx; @@ -591,7 +573,7 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) { #if 0 /* This is not broken in fteqcc anymore */ - if (opts_standard != COMPILER_GMQCC) { + if (opts.standard != COMPILER_GMQCC) { /* this error doesn't need to make us bail out */ (void)!parsewarning(parser, WARN_EXTENSIONS, "accessing array-field members of an entity without parenthesis\n" @@ -603,11 +585,15 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) case opid1(','): if (blocks[0]) { - ast_block_add_expr(blocks[0], exprs[1]); + if (!ast_block_add_expr(blocks[0], exprs[1])) + return false; } else { blocks[0] = ast_block_new(ctx); - ast_block_add_expr(blocks[0], exprs[0]); - ast_block_add_expr(blocks[0], exprs[1]); + if (!ast_block_add_expr(blocks[0], exprs[0]) || + !ast_block_add_expr(blocks[0], exprs[1])) + { + return false; + } } if (!ast_block_set_type(blocks[0], exprs[1])) return false; @@ -849,7 +835,7 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) return false; } #endif - if (opts_standard == COMPILER_GMQCC) + if (opts.standard == COMPILER_GMQCC) con_out("TODO: early out logic\n"); if (CanConstFold(exprs[0], exprs[1])) out = (ast_expression*)parser_const_float(parser, @@ -922,7 +908,9 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) } else assignop = type_storep_instr[exprs[0]->expression.vtype]; - if (!ast_compare_type(field->expression.next, exprs[1])) { + if (assignop == AINSTR_END || + !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_FLAG(ASSIGN_FUNCTION_TYPES) && @@ -1254,7 +1242,7 @@ static bool parser_close_call(parser_t *parser, shunt *sy) const char *fewmany = (vec_size(fun->expression.params) > paramcount) ? "few" : "many"; fval = (ast_istype(fun, ast_value) ? ((ast_value*)fun) : NULL); - if (opts_standard == COMPILER_GMQCC) + if (opts.standard == COMPILER_GMQCC) { if (fval) parseerror(parser, "too %s parameters for call to %s: expected %i, got %i\n" @@ -1317,7 +1305,7 @@ static bool parser_close_paren(parser_t *parser, shunt *sy, bool functions_only) /* pop off the parenthesis */ vec_shrinkby(sy->ops, 1); /* then apply the index operator */ - if (!parser_sy_pop(parser, sy)) + if (!parser_sy_apply_operator(parser, sy)) return false; return true; } @@ -1333,7 +1321,7 @@ static bool parser_close_paren(parser_t *parser, shunt *sy, bool functions_only) vec_shrinkby(sy->ops, 1); return true; } - if (!parser_sy_pop(parser, sy)) + if (!parser_sy_apply_operator(parser, sy)) return false; } return true; @@ -1419,7 +1407,7 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma } wantop = true; /* variable */ - if (opts_standard == COMPILER_GMQCC) + if (opts.standard == COMPILER_GMQCC) { if (parser->memberof == TYPE_ENTITY) { /* still get vars first since there could be a fieldpointer */ @@ -1567,6 +1555,10 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma vec_pop(parser->pot); wantop = true; } + else if (parser->tok == TOKEN_TYPENAME) { + parseerror(parser, "unexpected typename"); + goto onerr; + } else if (parser->tok != TOKEN_OPERATOR) { if (wantop) { parseerror(parser, "expected operator or end of statement"); @@ -1621,7 +1613,7 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma (op->prec < olast->prec) || (op->assoc == ASSOC_LEFT && op->prec <= olast->prec) ) ) { - if (!parser_sy_pop(parser, &sy)) + if (!parser_sy_apply_operator(parser, &sy)) goto onerr; if (vec_size(sy.ops) && !vec_last(sy.ops).paren) olast = &operators[vec_last(sy.ops).etype-1]; @@ -1629,7 +1621,7 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma olast = NULL; } - if (op->id == opid1('.') && opts_standard == COMPILER_GMQCC) { + if (op->id == opid1('.') && opts.standard == COMPILER_GMQCC) { /* for gmqcc standard: open up the namespace of the previous type */ ast_expression *prevex = vec_last(sy.out).out; if (!prevex) { @@ -1708,7 +1700,7 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma } while (vec_size(sy.ops)) { - if (!parser_sy_pop(parser, &sy)) + if (!parser_sy_apply_operator(parser, &sy)) goto onerr; } @@ -2026,7 +2018,7 @@ static bool parse_for(parser_t *parser, ast_block *block, ast_expression **out) typevar = parser_find_typedef(parser, parser_tokval(parser), 0); if (typevar || parser->tok == TOKEN_TYPENAME) { - if (opts_standard != COMPILER_GMQCC) { + if (opts.standard != COMPILER_GMQCC) { if (parsewarning(parser, WARN_EXTENSIONS, "current standard does not allow variable declarations in for-loop initializers")) goto onerr; @@ -2139,7 +2131,7 @@ static bool parse_return(parser_t *parser, ast_block *block, ast_expression **ou if (!parser_next(parser)) parseerror(parser, "parse error"); if (expected->expression.next->expression.vtype != TYPE_VOID) { - if (opts_standard != COMPILER_GMQCC) + if (opts.standard != COMPILER_GMQCC) (void)!parsewarning(parser, WARN_MISSING_RETURN_VALUES, "return without value"); else parseerror(parser, "return without value"); @@ -2368,7 +2360,10 @@ static bool parse_switch(parser_t *parser, ast_block *block, ast_expression **ou } if (!expr) continue; - ast_block_add_expr(caseblock, expr); + if (!ast_block_add_expr(caseblock, expr)) { + ast_delete(switchnode); + return false; + } } } @@ -2466,7 +2461,7 @@ static bool parse_pragma_do(parser_t *parser) } else { - parseerror(parser, "unrecognized hash-keyword: `%s`", parser_tokval(parser)); + (void)!parsewarning(parser, WARN_UNKNOWN_PRAGMAS, "ignoring #pragma %s", parser_tokval(parser)); return false; } @@ -2510,7 +2505,7 @@ static bool parse_statement(parser_t *parser, ast_block *block, ast_expression * parseerror(parser, "cannot declare a variable from here"); return false; } - if (opts_standard == COMPILER_QCC) { + if (opts.standard == COMPILER_QCC) { if (parsewarning(parser, WARN_EXTENSIONS, "missing 'local' keyword when declaring a local variable")) return false; } @@ -2577,7 +2572,7 @@ static bool parse_statement(parser_t *parser, ast_block *block, ast_expression * } else if (!strcmp(parser_tokval(parser), "for")) { - if (opts_standard == COMPILER_QCC) { + if (opts.standard == COMPILER_QCC) { 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; } @@ -2704,7 +2699,11 @@ static bool parse_block_into(parser_t *parser, ast_block *block) } if (!expr) continue; - ast_block_add_expr(block, expr); + if (!ast_block_add_expr(block, expr)) { + ast_delete(block); + block = NULL; + goto cleanup; + } } if (parser->tok != '}') { @@ -2969,9 +2968,12 @@ static bool parse_function_body(parser_t *parser, ast_value *var) if (store_think) ast_delete(store_think); retval = false; } - ast_block_add_expr(block, (ast_expression*)store_frame); - ast_block_add_expr(block, (ast_expression*)store_nextthink); - ast_block_add_expr(block, (ast_expression*)store_think); + if (!ast_block_add_expr(block, (ast_expression*)store_frame) || + !ast_block_add_expr(block, (ast_expression*)store_nextthink) || + !ast_block_add_expr(block, (ast_expression*)store_think)) + { + retval = false; + } } if (!retval) { @@ -3034,7 +3036,7 @@ static bool parse_function_body(parser_t *parser, ast_value *var) if (parser->tok == ';') return parser_next(parser); - else if (opts_standard == COMPILER_QCC) + else if (opts.standard == COMPILER_QCC) parseerror(parser, "missing semicolon after function body (mandatory with -std=qcc)"); return retval; @@ -3120,7 +3122,10 @@ static ast_expression *array_setter_node(parser_t *parser, ast_value *array, ast return NULL; } - ast_block_add_expr(block, (ast_expression*)st); + if (!ast_block_add_expr(block, (ast_expression*)st)) { + ast_delete(block); + return NULL; + } ret = ast_return_new(ctx, NULL); if (!ret) { @@ -3128,7 +3133,10 @@ static ast_expression *array_setter_node(parser_t *parser, ast_value *array, ast return NULL; } - ast_block_add_expr(block, (ast_expression*)ret); + if (!ast_block_add_expr(block, (ast_expression*)ret)) { + ast_delete(block); + return NULL; + } return (ast_expression*)block; } else { @@ -3189,7 +3197,10 @@ static ast_expression *array_field_setter_node( return NULL; } - ast_block_add_expr(block, (ast_expression*)st); + if (!ast_block_add_expr(block, (ast_expression*)st)) { + ast_delete(block); + return NULL; + } ret = ast_return_new(ctx, NULL); if (!ret) { @@ -3197,7 +3208,10 @@ static ast_expression *array_field_setter_node( return NULL; } - ast_block_add_expr(block, (ast_expression*)ret); + if (!ast_block_add_expr(block, (ast_expression*)ret)) { + ast_delete(block); + return NULL; + } return (ast_expression*)block; } else { @@ -3309,9 +3323,8 @@ static bool parser_create_array_setter(parser_t *parser, ast_value *array, const goto cleanup; } - ast_block_add_expr(func->blocks[0], root); array->setter = fval; - return true; + return ast_block_add_expr(func->blocks[0], root); cleanup: if (index) ast_delete(index); if (value) ast_delete(value); @@ -3358,9 +3371,8 @@ static bool parser_create_array_field_setter(parser_t *parser, ast_value *array, goto cleanup; } - ast_block_add_expr(func->blocks[0], root); array->setter = fval; - return true; + return ast_block_add_expr(func->blocks[0], root); cleanup: if (entity) ast_delete(entity); if (index) ast_delete(index); @@ -3405,9 +3417,8 @@ static bool parser_create_array_getter(parser_t *parser, ast_value *array, const goto cleanup; } - ast_block_add_expr(func->blocks[0], root); array->getter = fval; - return true; + return ast_block_add_expr(func->blocks[0], root); cleanup: if (index) ast_delete(index); if (root) ast_delete(root); @@ -3484,7 +3495,7 @@ static ast_value *parse_parameter_list(parser_t *parser, ast_value *var) vec_free(params); /* sanity check */ - if (vec_size(params) > 8 && opts_standard == COMPILER_QCC) + if (vec_size(params) > 8 && opts.standard == COMPILER_QCC) (void)!parsewarning(parser, WARN_EXTENSIONS, "more than 8 parameters are not supported by this standard"); /* parse-out */ @@ -3693,7 +3704,7 @@ static ast_value *parse_typename(parser_t *parser, ast_value **storebase, ast_va } /* now there may be function parens again */ - if (parser->tok == '(' && opts_standard == COMPILER_QCC) + 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"); @@ -3792,7 +3803,7 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield /* Part 0: finish the type */ if (parser->tok == '(') { - if (opts_standard == COMPILER_QCC) + 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) { @@ -3815,7 +3826,7 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield } /* for functions returning functions */ while (parser->tok == '(') { - if (opts_standard == COMPILER_QCC) + 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) { @@ -3878,7 +3889,7 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield goto cleanup; */ } - if (opts_standard == COMPILER_QCC && + 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"); @@ -3918,7 +3929,7 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield { /* other globals */ if (old) { - if (opts_standard == COMPILER_GMQCC) { + if (opts.standard == COMPILER_GMQCC) { parseerror(parser, "global `%s` already declared here: %s:%i", var->name, ast_ctx(old).file, ast_ctx(old).line); retval = false; @@ -3942,7 +3953,7 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield var = proto; } } - if (opts_standard == COMPILER_QCC && + 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"); @@ -3973,7 +3984,7 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield retval = false; goto cleanup; } - if (opts_standard != COMPILER_GMQCC) { + if (opts.standard != COMPILER_GMQCC) { ast_delete(var); var = NULL; goto skipvar; @@ -4097,7 +4108,7 @@ skipvar: break; } - if (localblock && opts_standard == COMPILER_QCC) { + 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) ) @@ -4117,7 +4128,7 @@ skipvar: break; } } - else if (opts_standard == COMPILER_QCC) { + else if (opts.standard == COMPILER_QCC) { parseerror(parser, "expected '=' before function body in this standard"); } @@ -4204,7 +4215,7 @@ skipvar: parseerror(parser, "cannot initialize a global constant variable with a non-constant expression"); else { - if (opts_standard != COMPILER_GMQCC && + if (opts.standard != COMPILER_GMQCC && !OPTS_FLAG(INITIALIZED_NONCONSTANTS) && qualifier != CV_VAR) { @@ -4227,12 +4238,13 @@ skipvar: vec_push(sy.out, syexp(ast_ctx(var), (ast_expression*)var)); vec_push(sy.out, syexp(ast_ctx(cexp), (ast_expression*)cexp)); vec_push(sy.ops, syop(ast_ctx(var), parser->assign_op)); - if (!parser_sy_pop(parser, &sy)) + if (!parser_sy_apply_operator(parser, &sy)) ast_unref(cexp); else { if (vec_size(sy.out) != 1 && vec_size(sy.ops) != 0) parseerror(parser, "internal error: leaked operands"); - ast_block_add_expr(localblock, (ast_expression*)sy.out[0].out); + if (!ast_block_add_expr(localblock, (ast_expression*)sy.out[0].out)) + break; } vec_free(sy.out); vec_free(sy.ops); @@ -4671,7 +4683,7 @@ bool parser_finish(const char *output) return false; } } - if (opts_dump) + if (opts.dump) ir_builder_dump(ir, con_out); for (i = 0; i < vec_size(parser->functions); ++i) { if (!ir_function_finalize(parser->functions[i]->ir_func)) { @@ -4682,7 +4694,7 @@ bool parser_finish(const char *output) } if (retval) { - if (opts_dumpfin) + if (opts.dumpfin) ir_builder_dump(ir, con_out); generate_checksum(parser);