X-Git-Url: https://git.xonotic.org/?a=blobdiff_plain;f=parser.c;h=2af798bb837a4bd496efa605ec8676f136033dc5;hb=0d3896ca54d6eb4878277e2fa7dac32b94a896cc;hp=6e440cd4c1c638a73173f0309219694c84a989d1;hpb=1b72cb264a0cf180e0b491cc4a7f77b14beca525;p=xonotic%2Fgmqcc.git diff --git a/parser.c b/parser.c index 6e440cd..2af798b 100644 --- a/parser.c +++ b/parser.c @@ -58,6 +58,12 @@ typedef struct { ast_function *function; + /* All the labels the function defined... + * Should they be in ast_function instead? + */ + ast_label **labels; + ast_goto **gotos; + /* A list of hashtables for each scope */ ht *variables; ht htfields; @@ -594,6 +600,9 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) vec_push(sy->out, syblock(ctx, blocks[0])); return true; + case opid2('+','P'): + out = exprs[0]; + break; case opid2('-','P'): switch (exprs[0]->expression.vtype) { case TYPE_FLOAT: @@ -896,7 +905,7 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) 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 && + if (OPTS_FLAG(ASSIGN_FUNCTION_TYPES) && field->expression.next->expression.vtype == TYPE_FUNCTION && exprs[1]->expression.vtype == TYPE_FUNCTION) { @@ -1422,7 +1431,7 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma vec_push(sy.out, syexp(parser_ctx(parser), (ast_expression*)val)); DEBUGSHUNTDO(con_out("push %g\n", parser_token(parser)->constval.f)); } - else if (parser->tok == TOKEN_INTCONST) { + else if (parser->tok == TOKEN_INTCONST || parser->tok == TOKEN_CHARCONST) { ast_value *val; if (wantop) { parseerror(parser, "expected operator or end of statement, got constant"); @@ -1944,7 +1953,7 @@ static bool parse_for(parser_t *parser, ast_block *block, ast_expression **out) "current standard does not allow variable declarations in for-loop initializers")) goto onerr; } - if (!parse_variable(parser, block, CV_VAR, false, typevar)) + if (!parse_variable(parser, block, true, CV_VAR, typevar)) goto onerr; } else if (parser->tok != ';') @@ -2153,7 +2162,7 @@ static bool parse_switch(parser_t *parser, ast_block *block, ast_expression **ou } if (!OPTS_FLAG(RELAXED_SWITCH)) { opval = (ast_value*)swcase.value; - if (!ast_istype(swcase.value, ast_value) || !opval->constant) { + if (!ast_istype(swcase.value, ast_value)) { /* || !opval->constant) { */ parseerror(parser, "case on non-constant values need to be explicitly enabled via -frelaxed-switch"); ast_unref(operand); return false; @@ -2227,9 +2236,46 @@ static bool parse_switch(parser_t *parser, ast_block *block, ast_expression **ou return true; } +static bool parse_goto(parser_t *parser, ast_expression **out) +{ + size_t i; + ast_goto *gt; + + if (!parser_next(parser) || parser->tok != TOKEN_IDENT) { + parseerror(parser, "expected label name after `goto`"); + return false; + } + + gt = ast_goto_new(parser_ctx(parser), parser_tokval(parser)); + + for (i = 0; i < vec_size(parser->labels); ++i) { + if (!strcmp(parser->labels[i]->name, parser_tokval(parser))) { + ast_goto_set_label(gt, parser->labels[i]); + break; + } + } + if (i == vec_size(parser->labels)) + vec_push(parser->gotos, gt); + + if (!parser_next(parser) || parser->tok != ';') { + parseerror(parser, "semicolon expected after goto label"); + return false; + } + if (!parser_next(parser)) { + parseerror(parser, "parse error after goto"); + return false; + } + + *out = (ast_expression*)gt; + return true; +} + static bool parse_statement(parser_t *parser, ast_block *block, ast_expression **out, bool allow_cases) { + int cvq; ast_value *typevar = NULL; + *out = NULL; + if (parser->tok == TOKEN_IDENT) typevar = parser_find_typedef(parser, parser_tokval(parser), 0); @@ -2244,15 +2290,29 @@ 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, CV_NONE, false, typevar)) + if (!parse_variable(parser, block, false, CV_NONE, typevar)) return false; *out = NULL; return true; } + else if (parser->tok == TOKEN_IDENT && !strcmp(parser_tokval(parser), "var")) + { + goto ident_var; + } else if (parser->tok == TOKEN_KEYWORD) { - if (!strcmp(parser_tokval(parser), "local")) + if (!strcmp(parser_tokval(parser), "local") || + !strcmp(parser_tokval(parser), "const") || + !strcmp(parser_tokval(parser), "var")) { +ident_var: + if (parser_tokval(parser)[0] == 'c') + cvq = CV_CONST; + else if (parser_tokval(parser)[0] == 'v') + cvq = CV_VAR; + else + cvq = CV_NONE; + if (!block) { parseerror(parser, "cannot declare a local variable here"); return false; @@ -2261,11 +2321,44 @@ static bool parse_statement(parser_t *parser, ast_block *block, ast_expression * parseerror(parser, "expected variable declaration"); return false; } - if (!parse_variable(parser, block, CV_VAR, false, NULL)) + if (!parse_variable(parser, block, true, cvq, NULL)) return false; *out = NULL; return true; } + else if (!strcmp(parser_tokval(parser), "__builtin_debug_printtype")) + { + char ty[1024]; + ast_value *tdef; + + if (!parser_next(parser)) { + parseerror(parser, "parse error after __builtin_debug_printtype"); + return false; + } + + if (parser->tok == TOKEN_IDENT && (tdef = parser_find_typedef(parser, parser_tokval(parser), 0))) + { + ast_type_to_string((ast_expression*)tdef, ty, sizeof(ty)); + con_out("__builtin_debug_printtype: `%s`=`%s`\n", tdef->name, ty); + if (!parser_next(parser)) { + parseerror(parser, "parse error after __builtin_debug_printtype typename argument"); + return false; + } + } + else + { + if (!parse_statement(parser, block, out, allow_cases)) + return false; + if (!*out) + con_out("__builtin_debug_printtype: got no output node\n"); + else + { + ast_type_to_string(*out, ty, sizeof(ty)); + con_out("__builtin_debug_printtype: `%s`\n", ty); + } + } + return true; + } else if (!strcmp(parser_tokval(parser), "return")) { return parse_return(parser, block, out); @@ -2311,6 +2404,10 @@ static bool parse_statement(parser_t *parser, ast_block *block, ast_expression * } return true; } + else if (!strcmp(parser_tokval(parser), "goto")) + { + return parse_goto(parser, out); + } else if (!strcmp(parser_tokval(parser), "typedef")) { if (!parser_next(parser)) { @@ -2331,6 +2428,36 @@ static bool parse_statement(parser_t *parser, ast_block *block, ast_expression * *out = (ast_expression*)inner; return true; } + else if (parser->tok == ':') + { + size_t i; + ast_label *label; + if (!parser_next(parser)) { + parseerror(parser, "expected label name"); + return false; + } + if (parser->tok != TOKEN_IDENT) { + parseerror(parser, "label must be an identifier"); + return false; + } + label = ast_label_new(parser_ctx(parser), parser_tokval(parser)); + if (!label) + return false; + vec_push(parser->labels, label); + *out = (ast_expression*)label; + if (!parser_next(parser)) { + parseerror(parser, "parse error after label"); + return false; + } + for (i = 0; i < vec_size(parser->gotos); ++i) { + if (!strcmp(parser->gotos[i]->name, label->name)) { + ast_goto_set_label(parser->gotos[i], label); + vec_remove(parser->gotos, i, 1); + --i; + } + } + return true; + } else if (parser->tok == ';') { if (!parser_next(parser)) { @@ -2469,6 +2596,11 @@ static bool parse_function_body(parser_t *parser, ast_value *var) has_frame_think = false; old = parser->function; + if (vec_size(parser->gotos) || vec_size(parser->labels)) { + parseerror(parser, "gotos/labels leaking"); + return false; + } + if (var->expression.variadic) { if (parsewarning(parser, WARN_VARIADIC_FUNCTION, "variadic function with implementation will not be able to access additional parameters")) @@ -3291,13 +3423,12 @@ static ast_value *parse_typename(parser_t *parser, ast_value **storebase, ast_va return NULL; } } - - if (parser->tok == TOKEN_IDENT) - cached_typedef = parser_find_typedef(parser, parser_tokval(parser), 0); - if (!cached_typedef && parser->tok != TOKEN_TYPENAME) { - parseerror(parser, "expected typename"); - return NULL; - } + } + if (parser->tok == TOKEN_IDENT) + cached_typedef = parser_find_typedef(parser, parser_tokval(parser), 0); + if (!cached_typedef && parser->tok != TOKEN_TYPENAME) { + parseerror(parser, "expected typename"); + return NULL; } /* generate the basic type value */ @@ -3837,6 +3968,7 @@ skipvar: } else if (parser->tok == '{' || parser->tok == '[') { + size_t i; if (localblock) { parseerror(parser, "cannot declare functions within functions"); break; @@ -3845,6 +3977,10 @@ skipvar: if (!parse_function_body(parser, var)) break; ast_delete(basetype); + for (i = 0; i < vec_size(parser->gotos); ++i) + parseerror(parser, "undefined label: `%s`", parser->gotos[i]->name); + vec_free(parser->gotos); + vec_free(parser->labels); return true; } else { ast_expression *cexp; @@ -3860,7 +3996,8 @@ skipvar: parseerror(parser, "cannot initialize a global constant variable with a non-constant expression"); else { - if (opts_standard != COMPILER_GMQCC && !OPTS_FLAG(INITIALIZED_NONCONSTANTS) && + if (opts_standard != COMPILER_GMQCC && + !OPTS_FLAG(INITIALIZED_NONCONSTANTS) && is_const_var != CV_VAR) { var->constant = true; @@ -3873,7 +4010,10 @@ skipvar: ast_unref(cval); } } else { + bool cvq; shunt sy = { NULL, NULL }; + cvq = var->constant; + var->constant = false; 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)); @@ -3886,6 +4026,7 @@ skipvar: } vec_free(sy.out); vec_free(sy.ops); + var->constant = cvq; } } @@ -3947,7 +4088,7 @@ static bool parser_global_statement(parser_t *parser) if (istype || parser->tok == TOKEN_TYPENAME || parser->tok == '.') { - return parse_variable(parser, NULL, CV_NONE, false, istype); + return parse_variable(parser, NULL, false, CV_NONE, istype); } else if (parser->tok == TOKEN_IDENT && !strcmp(parser_tokval(parser), "var")) { @@ -3956,7 +4097,7 @@ static bool parser_global_statement(parser_t *parser) parseerror(parser, "expected variable declaration after 'var'"); return false; } - return parse_variable(parser, NULL, CV_VAR, false, NULL); + return parse_variable(parser, NULL, true, CV_VAR, NULL); } } else if (parser->tok == TOKEN_KEYWORD) @@ -3973,7 +4114,7 @@ static bool parser_global_statement(parser_t *parser) return false; } } - return parse_variable(parser, NULL, CV_CONST, true, NULL); + return parse_variable(parser, NULL, true, CV_CONST, NULL); } else if (!strcmp(parser_tokval(parser), "typedef")) { if (!parser_next(parser)) { @@ -4217,6 +4358,9 @@ void parser_cleanup() vec_free(parser->typedefs); vec_free(parser->_blocktypedefs); + vec_free(parser->labels); + vec_free(parser->gotos); + mem_d(parser); }