X-Git-Url: https://de.git.xonotic.org/?p=xonotic%2Fgmqcc.git;a=blobdiff_plain;f=parser.c;h=5bb7652627f9a4ff248accc82aab60cc86379550;hp=a191c535c4ddf94d8dd3a036526466c1f9a93198;hb=d8254cede0368482090009c21e7e49c7257a783e;hpb=921877e8a4d7b5221762490d3f6e3b3666e4381b diff --git a/parser.c b/parser.c index a191c53..5bb7652 100644 --- a/parser.c +++ b/parser.c @@ -1,7 +1,8 @@ /* * Copyright (C) 2012 * Wolfgang Bumiller - * + * Dale Weiler + * * Permission is hereby granted, free of charge, to any person obtaining a copy of * this software and associated documentation files (the "Software"), to deal in * the Software without restriction, including without limitation the rights to @@ -104,12 +105,12 @@ static void parser_enterblock(parser_t *parser); static bool parser_leaveblock(parser_t *parser); static void parser_addlocal(parser_t *parser, const char *name, ast_expression *e); static bool parse_typedef(parser_t *parser); -static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofields, int qualifier, ast_value *cached_typedef, bool noref, bool is_static, uint32_t qflags); +static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofields, int qualifier, ast_value *cached_typedef, bool noref, bool is_static, uint32_t qflags, char *vstring); static ast_block* parse_block(parser_t *parser); static bool parse_block_into(parser_t *parser, ast_block *block); static bool parse_statement_or_block(parser_t *parser, ast_expression **out); static bool parse_statement(parser_t *parser, ast_block *block, ast_expression **out, bool allow_cases); -static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma); +static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma, bool truthvalue); static ast_expression* parse_expression(parser_t *parser, bool stopatcomma); static void parseerror(parser_t *parser, const char *fmt, ...) @@ -938,7 +939,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) ( (generated_op == INSTR_OR) ? (immediate_is_true(ctx, asvalue[0]) || immediate_is_true(ctx, asvalue[1])) : (immediate_is_true(ctx, asvalue[0]) && immediate_is_true(ctx, asvalue[1])) ) - ? 0 : 1); + ? 1 : 0); } else { @@ -982,14 +983,14 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) return false; } vec_pop(parser->pot); - if (exprs[1]->expression.vtype != exprs[2]->expression.vtype) { + if (!ast_compare_type(exprs[1], exprs[2])) { ast_type_to_string(exprs[1], ty1, sizeof(ty1)); ast_type_to_string(exprs[2], ty2, sizeof(ty2)); parseerror(parser, "operands of ternary expression must have the same type, got %s and %s", ty1, ty2); return false; } if (CanConstFold1(exprs[0])) - out = (ConstF(0) ? exprs[1] : exprs[2]); + out = (immediate_is_true(ctx, asvalue[0]) ? exprs[1] : exprs[2]); else out = (ast_expression*)ast_ternary_new(ctx, exprs[0], exprs[1], exprs[2]); break; @@ -1040,8 +1041,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) } else assignop = type_storep_instr[exprs[0]->expression.vtype]; - if (assignop == AINSTR_END || - !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)); @@ -1073,8 +1073,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) ast_type_to_string(exprs[1], ty2, sizeof(ty2)); parseerror(parser, "invalid types in assignment: cannot assign %s to %s", ty2, ty1); } - else if (exprs[1]->expression.vtype != TYPE_NIL && - !ast_compare_type(exprs[0], exprs[1])) + 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)); @@ -1373,7 +1372,6 @@ static bool parser_close_call(parser_t *parser, shunt *sy) return false; } - if (!fun->expression.next) { parseerror(parser, "could not determine function return type"); return false; @@ -1381,14 +1379,23 @@ static bool parser_close_call(parser_t *parser, shunt *sy) ast_value *fval = (ast_istype(fun, ast_value) ? ((ast_value*)fun) : NULL); if (fun->expression.flags & AST_FLAG_DEPRECATED) { - if (!fval) - return !parsewarning(parser, WARN_DEPRECATED, "call to function (which is marked deprecated)\n" - "-> it has been declared here: %s:%i", - ast_ctx(fun).file, ast_ctx(fun).line); - else - return !parsewarning(parser, WARN_DEPRECATED, "call to `%s` (which is marked deprecated)\n" - "-> `%s` declared here: %s:%i", - fval->name, fval->name, ast_ctx(fun).file, ast_ctx(fun).line); + if (!fval) { + return !parsewarning(parser, WARN_DEPRECATED, + "call to function (which is marked deprecated)\n", + "-> it has been declared here: %s:%i", + ast_ctx(fun).file, ast_ctx(fun).line); + } + if (!fval->desc) { + return !parsewarning(parser, WARN_DEPRECATED, + "call to `%s` (which is marked deprecated)\n" + "-> `%s` declared here: %s:%i", + fval->name, fval->name, ast_ctx(fun).file, ast_ctx(fun).line); + } + return !parsewarning(parser, WARN_DEPRECATED, + "call to `%s` (deprecated: %s)\n" + "-> `%s` declared here: %s:%i", + fval->name, fval->desc, fval->name, ast_ctx(fun).file, + ast_ctx(fun).line); } if (vec_size(fun->expression.params) != paramcount && @@ -1396,35 +1403,18 @@ static bool parser_close_call(parser_t *parser, shunt *sy) vec_size(fun->expression.params) < paramcount)) { const char *fewmany = (vec_size(fun->expression.params) > paramcount) ? "few" : "many"; - if (opts.standard == COMPILER_GMQCC) - { - if (fval) - parseerror(parser, "too %s parameters for call to %s: expected %i, got %i\n" - " -> `%s` has been declared here: %s:%i", - fewmany, fval->name, (int)vec_size(fun->expression.params), (int)paramcount, - fval->name, ast_ctx(fun).file, (int)ast_ctx(fun).line); - else - parseerror(parser, "too %s parameters for function call: expected %i, got %i\n" - " -> it has been declared here: %s:%i", - fewmany, (int)vec_size(fun->expression.params), (int)paramcount, - ast_ctx(fun).file, (int)ast_ctx(fun).line); - return false; - } + if (fval) + return !parsewarning(parser, WARN_INVALID_PARAMETER_COUNT, + "too %s parameters for call to %s: expected %i, got %i\n" + " -> `%s` has been declared here: %s:%i", + fewmany, fval->name, (int)vec_size(fun->expression.params), (int)paramcount, + fval->name, ast_ctx(fun).file, (int)ast_ctx(fun).line); else - { - if (fval) - return !parsewarning(parser, WARN_TOO_FEW_PARAMETERS, - "too %s parameters for call to %s: expected %i, got %i\n" - " -> `%s` has been declared here: %s:%i", - fewmany, fval->name, (int)vec_size(fun->expression.params), (int)paramcount, - fval->name, ast_ctx(fun).file, (int)ast_ctx(fun).line); - else - return !parsewarning(parser, WARN_TOO_FEW_PARAMETERS, - "too %s parameters for function call: expected %i, got %i\n" - " -> it has been declared here: %s:%i", - fewmany, (int)vec_size(fun->expression.params), (int)paramcount, - ast_ctx(fun).file, (int)ast_ctx(fun).line); - } + return !parsewarning(parser, WARN_INVALID_PARAMETER_COUNT, + "too %s parameters for function call: expected %i, got %i\n" + " -> it has been declared here: %s:%i", + fewmany, (int)vec_size(fun->expression.params), (int)paramcount, + ast_ctx(fun).file, (int)ast_ctx(fun).line); } } @@ -1492,12 +1482,16 @@ static void parser_reclassify_token(parser_t *parser) } } -static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma) +static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma, bool truthvalue) { ast_expression *expr = NULL; shunt sy; bool wantop = false; bool gotmemberof = false; + /* only warn once about an assignment in a truth value because the current code + * would trigger twice on: if(a = b && ...), once for the if-truth-value, once for the && part + */ + bool warn_truthvalue = true; /* count the parens because an if starts with one, so the * end of a condition is an unmatched closing paren @@ -1774,6 +1768,28 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma if (vec_size(sy.ops) && !vec_last(sy.ops).paren) olast = &operators[vec_last(sy.ops).etype-1]; +#define IsAssignOp(x) (\ + (x) == opid1('=') || \ + (x) == opid2('+','=') || \ + (x) == opid2('-','=') || \ + (x) == opid2('*','=') || \ + (x) == opid2('/','=') || \ + (x) == opid2('%','=') || \ + (x) == opid2('&','=') || \ + (x) == opid2('|','=') || \ + (x) == opid3('&','~','=') \ + ) + if (warn_truthvalue) { + if ( (olast && IsAssignOp(olast->id) && (op->id == opid2('&','&') || op->id == opid2('|','|'))) || + (olast && IsAssignOp(op->id) && (olast->id == opid2('&','&') || olast->id == opid2('|','|'))) || + (truthvalue && !vec_size(parser->pot) && IsAssignOp(op->id)) + ) + { + (void)!parsewarning(parser, WARN_PARENTHESIS, "suggesting parenthesis around assignment used as truth value"); + warn_truthvalue = false; + } + } + while (olast && ( (op->prec < olast->prec) || (op->assoc == ASSOC_LEFT && op->prec <= olast->prec) ) ) @@ -1893,7 +1909,7 @@ onerr: static ast_expression* parse_expression(parser_t *parser, bool stopatcomma) { - ast_expression *e = parse_expression_leave(parser, stopatcomma); + ast_expression *e = parse_expression_leave(parser, stopatcomma, false); if (!e) return NULL; if (!parser_next(parser)) { @@ -2043,7 +2059,7 @@ static bool parse_if(parser_t *parser, ast_block *block, ast_expression **out) return false; } /* parse the condition */ - cond = parse_expression_leave(parser, false); + cond = parse_expression_leave(parser, false, true); if (!cond) return false; /* closing paren */ @@ -2164,7 +2180,7 @@ static bool parse_while_go(parser_t *parser, ast_block *block, ast_expression ** return false; } /* parse the condition */ - cond = parse_expression_leave(parser, false); + cond = parse_expression_leave(parser, false, true); if (!cond) return false; /* closing paren */ @@ -2279,7 +2295,7 @@ static bool parse_dowhile_go(parser_t *parser, ast_block *block, ast_expression return false; } /* parse the condition */ - cond = parse_expression_leave(parser, false); + cond = parse_expression_leave(parser, false, true); if (!cond) return false; /* closing paren */ @@ -2396,17 +2412,19 @@ static bool parse_for_go(parser_t *parser, ast_block *block, ast_expression **ou typevar = parser_find_typedef(parser, parser_tokval(parser), 0); if (typevar || parser->tok == TOKEN_TYPENAME) { +#if 0 if (opts.standard != COMPILER_GMQCC) { if (parsewarning(parser, WARN_EXTENSIONS, "current standard does not allow variable declarations in for-loop initializers")) goto onerr; } - if (!parse_variable(parser, block, true, CV_VAR, typevar, false, false, 0)) +#endif + if (!parse_variable(parser, block, true, CV_VAR, typevar, false, false, 0, NULL)) goto onerr; } else if (parser->tok != ';') { - initexpr = parse_expression_leave(parser, false); + initexpr = parse_expression_leave(parser, false, false); if (!initexpr) goto onerr; } @@ -2423,7 +2441,7 @@ static bool parse_for_go(parser_t *parser, ast_block *block, ast_expression **ou /* parse the condition */ if (parser->tok != ';') { - cond = parse_expression_leave(parser, false); + cond = parse_expression_leave(parser, false, true); if (!cond) goto onerr; } @@ -2440,7 +2458,7 @@ static bool parse_for_go(parser_t *parser, ast_block *block, ast_expression **ou /* parse the incrementor */ if (parser->tok != ')') { - increment = parse_expression_leave(parser, false); + increment = parse_expression_leave(parser, false, false); if (!increment) goto onerr; if (!ast_side_effects(increment)) { @@ -2501,7 +2519,9 @@ static bool parse_return(parser_t *parser, ast_block *block, ast_expression **ou if (!exp) return false; - if (exp->expression.vtype != expected->expression.next->expression.vtype) { + if (exp->expression.vtype != TYPE_NIL && + exp->expression.vtype != expected->expression.next->expression.vtype) + { parseerror(parser, "return with invalid expression"); } @@ -2514,10 +2534,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) - (void)!parsewarning(parser, WARN_MISSING_RETURN_VALUES, "return without value"); - else - parseerror(parser, "return without value"); + (void)!parsewarning(parser, WARN_MISSING_RETURN_VALUES, "return without value"); } ret = ast_return_new(ctx, NULL); } @@ -2574,7 +2591,7 @@ static bool parse_break_continue(parser_t *parser, ast_block *block, ast_express /* returns true when it was a variable qualifier, false otherwise! * on error, cvq is set to CV_WRONG */ -static bool parse_qualifiers(parser_t *parser, bool with_local, int *cvq, bool *noref, bool *is_static, uint32_t *_flags) +static bool parse_qualifiers(parser_t *parser, bool with_local, int *cvq, bool *noref, bool *is_static, uint32_t *_flags, char **message) { bool had_const = false; bool had_var = false; @@ -2617,11 +2634,48 @@ static bool parse_qualifiers(parser_t *parser, bool with_local, int *cvq, bool * return false; } } - else if (!strcmp(parser_tokval(parser), "deprecated")) { - flags |= AST_FLAG_DEPRECATED; - if (!parser_next(parser) || parser->tok != TOKEN_ATTRIBUTE_CLOSE) { - parseerror(parser, "`deprecated` attribute has no parameters, expected `]]`"); - *cvq = CV_WRONG; + + + else if (!strcmp(parser_tokval(parser), "deprecated") && !(flags & AST_FLAG_DEPRECATED)) { + flags |= AST_FLAG_DEPRECATED; + *message = NULL; + + if (!parser_next(parser)) { + parseerror(parser, "parse error in attribute"); + goto argerr; + } + + if (parser->tok == '(') { + if (!parser_next(parser) || parser->tok != TOKEN_STRINGCONST) { + parseerror(parser, "`deprecated` attribute missing parameter"); + goto argerr; + } + + *message = util_strdup(parser_tokval(parser)); + + if (!parser_next(parser)) { + parseerror(parser, "parse error in attribute"); + goto argerr; + } + + if(parser->tok != ')') { + parseerror(parser, "`deprecated` attribute expected `)` after parameter"); + goto argerr; + } + + if (!parser_next(parser)) { + parseerror(parser, "parse error in attribute"); + goto argerr; + } + } + /* no message */ + if (parser->tok != TOKEN_ATTRIBUTE_CLOSE) { + parseerror(parser, "`deprecated` attribute expected `]]`"); + + argerr: /* ugly */ + if (*message) mem_d(*message); + *message = NULL; + *cvq = CV_WRONG; return false; } } @@ -2747,7 +2801,7 @@ static bool parse_switch_go(parser_t *parser, ast_block *block, ast_expression * return false; } /* parse the operand */ - operand = parse_expression_leave(parser, false); + operand = parse_expression_leave(parser, false, false); if (!operand) return false; @@ -2780,19 +2834,19 @@ static bool parse_switch_go(parser_t *parser, ast_block *block, ast_expression * if (parser->tok == TOKEN_IDENT) typevar = parser_find_typedef(parser, parser_tokval(parser), 0); if (typevar || parser->tok == TOKEN_TYPENAME) { - if (!parse_variable(parser, block, false, CV_NONE, typevar, false, false, 0)) { + if (!parse_variable(parser, block, false, CV_NONE, typevar, false, false, 0, NULL)) { ast_delete(switchnode); return false; } continue; } - if (parse_qualifiers(parser, true, &cvq, &noref, &is_static, &qflags)) + if (parse_qualifiers(parser, true, &cvq, &noref, &is_static, &qflags, NULL)) { if (cvq == CV_WRONG) { ast_delete(switchnode); return false; } - if (!parse_variable(parser, block, false, cvq, NULL, noref, is_static, qflags)) { + if (!parse_variable(parser, block, false, cvq, NULL, noref, is_static, qflags, NULL)) { ast_delete(switchnode); return false; } @@ -2811,7 +2865,7 @@ static bool parse_switch_go(parser_t *parser, ast_block *block, ast_expression * parseerror(parser, "expected expression for case"); return false; } - swcase.value = parse_expression_leave(parser, false); + swcase.value = parse_expression_leave(parser, false, false); if (!swcase.value) { ast_delete(switchnode); parseerror(parser, "expected expression for case"); @@ -3008,9 +3062,10 @@ static bool parse_pragma(parser_t *parser) static bool parse_statement(parser_t *parser, ast_block *block, ast_expression **out, bool allow_cases) { bool noref, is_static; - int cvq = CV_NONE; - uint32_t qflags = 0; + int cvq = CV_NONE; + uint32_t qflags = 0; ast_value *typevar = NULL; + char *vstring = NULL; *out = NULL; @@ -3028,15 +3083,15 @@ static bool parse_statement(parser_t *parser, ast_block *block, ast_expression * if (parsewarning(parser, WARN_EXTENSIONS, "missing 'local' keyword when declaring a local variable")) return false; } - if (!parse_variable(parser, block, false, CV_NONE, typevar, false, false, 0)) + if (!parse_variable(parser, block, false, CV_NONE, typevar, false, false, 0, NULL)) return false; return true; } - else if (parse_qualifiers(parser, !!block, &cvq, &noref, &is_static, &qflags)) + else if (parse_qualifiers(parser, !!block, &cvq, &noref, &is_static, &qflags, &vstring)) { if (cvq == CV_WRONG) return false; - return parse_variable(parser, block, true, cvq, NULL, noref, is_static, qflags); + return parse_variable(parser, block, true, cvq, NULL, noref, is_static, qflags, vstring); } else if (parser->tok == TOKEN_KEYWORD) { @@ -3343,7 +3398,7 @@ static bool parse_function_body(parser_t *parser, ast_value *var) if (!parser_next(parser)) return false; - framenum = parse_expression_leave(parser, true); + framenum = parse_expression_leave(parser, true, false); if (!framenum) { parseerror(parser, "expected a framenumber constant in[frame,think] notation"); return false; @@ -3391,7 +3446,7 @@ static bool parse_function_body(parser_t *parser, ast_value *var) nextthink = (ast_expression*)thinkfunc; } else { - nextthink = parse_expression_leave(parser, true); + nextthink = parse_expression_leave(parser, true, false); if (!nextthink) { ast_unref(framenum); parseerror(parser, "expected a think-function in [frame,think] notation"); @@ -4057,7 +4112,7 @@ static ast_value *parse_arraysize(parser_t *parser, ast_value *var) return NULL; } - cexp = parse_expression_leave(parser, true); + cexp = parse_expression_leave(parser, true, false); if (!cexp || !ast_istype(cexp, ast_value)) { if (cexp) @@ -4319,7 +4374,7 @@ static bool parser_check_qualifiers(parser_t *parser, const ast_value *var, cons } av = (var ->expression.flags & AST_FLAG_NORETURN); ao = (proto->expression.flags & AST_FLAG_NORETURN); - if (av != ao) { + if (!av != !ao) { return !parsewarning(parser, WARN_DIFFERENT_ATTRIBUTES, "`%s` declared with different attributes%s\n" " -> previous declaration here: %s:%i", @@ -4330,7 +4385,7 @@ static bool parser_check_qualifiers(parser_t *parser, const ast_value *var, cons return true; } -static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofields, int qualifier, ast_value *cached_typedef, bool noref, bool is_static, uint32_t qflags) +static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofields, int qualifier, ast_value *cached_typedef, bool noref, bool is_static, uint32_t qflags, char *vstring) { ast_value *var; ast_value *proto; @@ -4398,6 +4453,8 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield var->cvq = qualifier; var->expression.flags |= qflags; + if (var->expression.flags & AST_FLAG_DEPRECATED) + var->desc = vstring; /* Part 1: * check for validity: (end_sys_..., multiple-definitions, prototypes, ...) @@ -4478,6 +4535,7 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield goto cleanup; } proto = (ast_value*)old; + proto->desc = var->desc; if (!ast_compare_type((ast_expression*)proto, (ast_expression*)var)) { parseerror(parser, "conflicting types for `%s`, previous declaration was here: %s:%i", proto->name, @@ -4490,6 +4548,8 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield ast_value_set_name(proto->expression.params[i], var->expression.params[i]->name); if (!parser_check_qualifiers(parser, var, proto)) { retval = false; + if (proto->desc) + mem_d(proto->desc); proto = NULL; goto cleanup; } @@ -4825,7 +4885,7 @@ skipvar: ast_expression *cexp; ast_value *cval; - cexp = parse_expression_leave(parser, true); + cexp = parse_expression_leave(parser, true, false); if (!cexp) break; @@ -4938,19 +4998,20 @@ static bool parser_global_statement(parser_t *parser) bool is_static = false; uint32_t qflags = 0; ast_value *istype = NULL; + char *vstring = NULL; if (parser->tok == TOKEN_IDENT) istype = parser_find_typedef(parser, parser_tokval(parser), 0); if (istype || parser->tok == TOKEN_TYPENAME || parser->tok == '.') { - return parse_variable(parser, NULL, false, CV_NONE, istype, false, false, 0); + return parse_variable(parser, NULL, false, CV_NONE, istype, false, false, 0, NULL); } - else if (parse_qualifiers(parser, false, &cvq, &noref, &is_static, &qflags)) + else if (parse_qualifiers(parser, false, &cvq, &noref, &is_static, &qflags, &vstring)) { if (cvq == CV_WRONG) return false; - return parse_variable(parser, NULL, true, cvq, NULL, noref, is_static, qflags); + return parse_variable(parser, NULL, true, cvq, NULL, noref, is_static, qflags, vstring); } else if (parser->tok == TOKEN_KEYWORD) { @@ -5205,6 +5266,8 @@ void parser_cleanup() vec_free(parser->breaks); vec_free(parser->continues); + ast_value_delete(parser->nil); + mem_d(parser); }