X-Git-Url: https://git.xonotic.org/?a=blobdiff_plain;f=parser.c;h=c771dd6d6fb3d5223b663c3a854cd28d38771db4;hb=2ec0a96a2120f803fc408b747312bd450963ecb7;hp=6ccd5e2b3b1458e30d532b73c3ba1774b922450b;hpb=66317aaef958cc2c7d210a5793b137e1b61fe5ef;p=xonotic%2Fgmqcc.git diff --git a/parser.c b/parser.c index 6ccd5e2..c771dd6 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; @@ -82,11 +88,15 @@ typedef struct { qcint memberof; } parser_t; +#define CV_NONE 0 +#define CV_CONST 1 +#define CV_VAR -1 + 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, bool is_const, ast_value *cached_typedef); +static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofields, int is_const_var, ast_value *cached_typedef); 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); @@ -211,7 +221,8 @@ static ast_value* parser_const_float(parser_t *parser, double d) return parser->imm_float[i]; } out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_FLOAT); - out->isconst = true; + out->constant = true; + out->hasvalue = true; out->constval.vfloat = d; vec_push(parser->imm_float, out); return out; @@ -256,7 +267,8 @@ static ast_value* parser_const_string(parser_t *parser, const char *str, bool do out = ast_value_new(parser_ctx(parser), name, TYPE_STRING); } else out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_STRING); - out->isconst = true; + out->constant = true; + out->hasvalue = true; out->constval.vstring = parser_strdup(str); vec_push(parser->imm_string, out); return out; @@ -271,7 +283,8 @@ static ast_value* parser_const_vector(parser_t *parser, vector v) return parser->imm_vector[i]; } out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_VECTOR); - out->isconst = true; + out->constant = true; + out->hasvalue = true; out->constval.vvec = v; vec_push(parser->imm_vector, out); return out; @@ -472,6 +485,7 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) ast_expression *exprs[3]; ast_block *blocks[3]; ast_value *asvalue[3]; + ast_binstore *asbinstore; size_t i, assignop, addop, subop; qcint generated_op = 0; @@ -517,7 +531,7 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) (exprs[0]->expression.vtype != exprs[1]->expression.vtype || \ exprs[0]->expression.vtype != T) #define CanConstFold1(A) \ - (ast_istype((A), ast_value) && ((ast_value*)(A))->isconst) + (ast_istype((A), ast_value) && ((ast_value*)(A))->hasvalue && ((ast_value*)(A))->constant) #define CanConstFold(A, B) \ (CanConstFold1(A) && CanConstFold1(B)) #define ConstV(i) (asvalue[(i)]->constval.vvec) @@ -575,11 +589,11 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) case opid1(','): if (blocks[0]) { - vec_push(blocks[0]->exprs, exprs[1]); + ast_block_add_expr(blocks[0], exprs[1]); } else { blocks[0] = ast_block_new(ctx); - vec_push(blocks[0]->exprs, exprs[0]); - vec_push(blocks[0]->exprs, exprs[1]); + ast_block_add_expr(blocks[0], exprs[0]); + ast_block_add_expr(blocks[0], exprs[1]); } if (!ast_block_set_type(blocks[0], exprs[1])) return false; @@ -587,6 +601,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: @@ -808,6 +825,7 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) generated_op += 1; /* INSTR_OR */ case opid2('&','&'): generated_op += INSTR_AND; +#if 0 if (NotSameType(TYPE_FLOAT)) { parseerror(parser, "invalid types used in expression: cannot perform logical operations between types %s and %s", type_name[exprs[0]->expression.vtype], @@ -816,6 +834,7 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) parseerror(parser, "TODO: optional early out"); return false; } +#endif if (opts_standard == COMPILER_GMQCC) con_out("TODO: early out logic\n"); if (CanConstFold(exprs[0], exprs[1])) @@ -829,7 +848,7 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) if (exprs[1]->expression.vtype != exprs[2]->expression.vtype) { ast_type_to_string(exprs[1], ty1, sizeof(ty1)); ast_type_to_string(exprs[2], ty2, sizeof(ty2)); - parseerror(parser, "iperands of ternary expression must have the same type, got %s and %s", ty1, ty2); + parseerror(parser, "operands of ternary expression must have the same type, got %s and %s", ty1, ty2); return false; } if (CanConstFold1(exprs[0])) @@ -887,7 +906,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) { @@ -921,7 +940,7 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) 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 && + if (OPTS_FLAG(ASSIGN_FUNCTION_TYPES) && exprs[0]->expression.vtype == TYPE_FUNCTION && exprs[1]->expression.vtype == TYPE_FUNCTION) { @@ -935,6 +954,9 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) parseerror(parser, "invalid types in assignment: cannot assign %s to %s", ty2, ty1); } } + if (ast_istype(exprs[0], ast_value) && asvalue[0]->constant) { + parseerror(parser, "assignment to constant `%s`", asvalue[0]->name); + } out = (ast_expression*)ast_store_new(ctx, assignop, exprs[0], exprs[1]); break; case opid3('+','+','P'): @@ -949,6 +971,9 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) addop = INSTR_ADD_F; else addop = INSTR_SUB_F; + if (ast_istype(exprs[0], ast_value) && asvalue[0]->constant) { + parseerror(parser, "assignment to constant `%s`", asvalue[0]->name); + } if (ast_istype(exprs[0], ast_entfield)) { out = (ast_expression*)ast_binstore_new(ctx, INSTR_STOREP_F, addop, exprs[0], @@ -974,6 +999,9 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) addop = INSTR_SUB_F; subop = INSTR_ADD_F; } + if (ast_istype(exprs[0], ast_value) && asvalue[0]->constant) { + parseerror(parser, "assignment to constant `%s`", asvalue[0]->name); + } if (ast_istype(exprs[0], ast_entfield)) { out = (ast_expression*)ast_binstore_new(ctx, INSTR_STOREP_F, addop, exprs[0], @@ -1000,6 +1028,9 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) ty1, ty2); return false; } + if (ast_istype(exprs[0], ast_value) && asvalue[0]->constant) { + parseerror(parser, "assignment to constant `%s`", asvalue[0]->name); + } if (ast_istype(exprs[0], ast_entfield)) assignop = type_storep_instr[exprs[0]->expression.vtype]; else @@ -1034,6 +1065,9 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) ty1, ty2); return false; } + if (ast_istype(exprs[0], ast_value) && asvalue[0]->constant) { + parseerror(parser, "assignment to constant `%s`", asvalue[0]->name); + } if (ast_istype(exprs[0], ast_entfield)) assignop = type_storep_instr[exprs[0]->expression.vtype]; else @@ -1075,6 +1109,9 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) ty1, ty2); return false; } + if (ast_istype(exprs[0], ast_value) && asvalue[0]->constant) { + parseerror(parser, "assignment to constant `%s`", asvalue[0]->name); + } if (ast_istype(exprs[0], ast_entfield)) assignop = type_storep_instr[exprs[0]->expression.vtype]; else @@ -1102,7 +1139,12 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) out = (ast_expression*)ast_binary_new(ctx, INSTR_BITAND, exprs[0], exprs[1]); if (!out) return false; - out = (ast_expression*)ast_binstore_new(ctx, assignop, INSTR_SUB_F, exprs[0], out); + if (ast_istype(exprs[0], ast_value) && asvalue[0]->constant) { + parseerror(parser, "assignment to constant `%s`", asvalue[0]->name); + } + asbinstore = ast_binstore_new(ctx, assignop, INSTR_SUB_F, exprs[0], out); + asbinstore->keep_dest = true; + out = (ast_expression*)asbinstore; break; } #undef NotSameType @@ -1304,7 +1346,9 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma else parser->memberof = 0; - if (parser->tok == TOKEN_IDENT && !strcmp(parser_tokval(parser), "_")) { + if (OPTS_FLAG(TRANSLATABLE_STRINGS) && + parser->tok == TOKEN_IDENT && !strcmp(parser_tokval(parser), "_")) + { /* a translatable string */ ast_value *val; @@ -1390,7 +1434,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"); @@ -1697,7 +1741,7 @@ static bool parse_if(parser_t *parser, ast_block *block, ast_expression **out) parseerror(parser, "expected condition or 'not'"); return false; } - if (parser->tok == TOKEN_KEYWORD && !strcmp(parser_tokval(parser), "not")) { + if (parser->tok == TOKEN_IDENT && !strcmp(parser_tokval(parser), "not")) { ifnot = true; if (!parser_next(parser)) { parseerror(parser, "expected condition in parenthesis"); @@ -1912,10 +1956,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; } - - parseerror(parser, "TODO: assignment of new variables to be non-const"); - goto onerr; - if (!parse_variable(parser, block, true, false, typevar)) + if (!parse_variable(parser, block, true, CV_VAR, typevar)) goto onerr; } else if (parser->tok != ';') @@ -1957,10 +1998,7 @@ static bool parse_for(parser_t *parser, ast_block *block, ast_expression **out) increment = parse_expression_leave(parser, false); if (!increment) goto onerr; - if (!ast_istype(increment, ast_store) && - !ast_istype(increment, ast_call) && - !ast_istype(increment, ast_binstore)) - { + if (!ast_side_effects(increment)) { if (genwarning(ast_ctx(increment), WARN_EFFECTLESS_STATEMENT, "statement has no effect")) goto onerr; } @@ -2065,6 +2103,7 @@ static bool parse_switch(parser_t *parser, ast_block *block, ast_expression **ou lex_ctx ctx = parser_ctx(parser); (void)block; /* not touching */ + (void)opval; /* parse over the opening paren */ if (!parser_next(parser) || parser->tok != '(') { @@ -2082,15 +2121,6 @@ static bool parse_switch(parser_t *parser, ast_block *block, ast_expression **ou if (!operand) return false; - if (!OPTS_FLAG(RELAXED_SWITCH)) { - opval = (ast_value*)operand; - if (!ast_istype(operand, ast_value) || !opval->isconst) { - parseerror(parser, "case on non-constant values need to be explicitly enabled via -frelaxed-switch"); - ast_unref(operand); - return false; - } - } - switchnode = ast_switch_new(ctx, operand); /* closing paren */ @@ -2134,6 +2164,14 @@ static bool parse_switch(parser_t *parser, ast_block *block, ast_expression **ou parseerror(parser, "expected expression for case"); return false; } + if (!OPTS_FLAG(RELAXED_SWITCH)) { + opval = (ast_value*)swcase.value; + 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; + } + } } else if (!strcmp(parser_tokval(parser), "default")) { swcase.value = NULL; @@ -2183,7 +2221,7 @@ static bool parse_switch(parser_t *parser, ast_block *block, ast_expression **ou } if (!expr) continue; - vec_push(caseblock->exprs, expr); + ast_block_add_expr(caseblock, expr); } } @@ -2202,9 +2240,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); @@ -2219,15 +2294,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, false, 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; @@ -2236,11 +2325,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, true, 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); @@ -2286,6 +2408,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)) { @@ -2306,16 +2432,51 @@ 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)) { + parseerror(parser, "parse error after empty statement"); + return false; + } + return true; + } else { ast_expression *exp = parse_expression(parser, false); if (!exp) return false; *out = exp; - if (!ast_istype(exp, ast_store) && - !ast_istype(exp, ast_call) && - !ast_istype(exp, ast_binstore)) - { + if (!ast_side_effects(exp)) { if (genwarning(ast_ctx(exp), WARN_EFFECTLESS_STATEMENT, "statement has no effect")) return false; } @@ -2347,7 +2508,7 @@ static bool parse_block_into(parser_t *parser, ast_block *block, bool warnreturn } if (!expr) continue; - vec_push(block->exprs, expr); + ast_block_add_expr(block, expr); } if (parser->tok != '}') { @@ -2439,6 +2600,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")) @@ -2480,7 +2646,7 @@ static bool parse_function_body(parser_t *parser, ast_value *var) parseerror(parser, "expected a framenumber constant in[frame,think] notation"); return false; } - if (!ast_istype(framenum, ast_value) || !( (ast_value*)framenum )->isconst) { + if (!ast_istype(framenum, ast_value) || !( (ast_value*)framenum )->hasvalue) { ast_unref(framenum); parseerror(parser, "framenumber in [frame,think] notation must be a constant"); return false; @@ -2619,9 +2785,9 @@ static bool parse_function_body(parser_t *parser, ast_value *var) if (store_think) ast_delete(store_think); retval = false; } - vec_push(block->exprs, (ast_expression*)store_frame); - vec_push(block->exprs, (ast_expression*)store_nextthink); - vec_push(block->exprs, (ast_expression*)store_think); + 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 (!retval) { @@ -2770,7 +2936,7 @@ static ast_expression *array_setter_node(parser_t *parser, ast_value *array, ast return NULL; } - vec_push(block->exprs, (ast_expression*)st); + ast_block_add_expr(block, (ast_expression*)st); ret = ast_return_new(ctx, NULL); if (!ret) { @@ -2778,7 +2944,7 @@ static ast_expression *array_setter_node(parser_t *parser, ast_value *array, ast return NULL; } - vec_push(block->exprs, (ast_expression*)ret); + ast_block_add_expr(block, (ast_expression*)ret); return (ast_expression*)block; } else { @@ -2839,7 +3005,7 @@ static ast_expression *array_field_setter_node( return NULL; } - vec_push(block->exprs, (ast_expression*)st); + ast_block_add_expr(block, (ast_expression*)st); ret = ast_return_new(ctx, NULL); if (!ret) { @@ -2847,7 +3013,7 @@ static ast_expression *array_field_setter_node( return NULL; } - vec_push(block->exprs, (ast_expression*)ret); + ast_block_add_expr(block, (ast_expression*)ret); return (ast_expression*)block; } else { @@ -2959,7 +3125,7 @@ static bool parser_create_array_setter(parser_t *parser, ast_value *array, const goto cleanup; } - vec_push(func->blocks[0]->exprs, root); + ast_block_add_expr(func->blocks[0], root); array->setter = fval; return true; cleanup: @@ -3008,7 +3174,7 @@ static bool parser_create_array_field_setter(parser_t *parser, ast_value *array, goto cleanup; } - vec_push(func->blocks[0]->exprs, root); + ast_block_add_expr(func->blocks[0], root); array->setter = fval; return true; cleanup: @@ -3055,7 +3221,7 @@ static bool parser_create_array_getter(parser_t *parser, ast_value *array, const goto cleanup; } - vec_push(func->blocks[0]->exprs, root); + ast_block_add_expr(func->blocks[0], root); array->getter = fval; return true; cleanup: @@ -3130,6 +3296,9 @@ static ast_value *parse_parameter_list(parser_t *parser, ast_value *var) } } + if (vec_size(params) == 1 && params[0]->expression.vtype == TYPE_VOID) + vec_free(params); + /* sanity check */ if (vec_size(params) > 8 && opts_standard == COMPILER_QCC) (void)!parsewarning(parser, WARN_EXTENSIONS, "more than 8 parameters are not supported by this standard"); @@ -3258,13 +3427,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 */ @@ -3409,7 +3577,7 @@ static bool parse_typedef(parser_t *parser) return true; } -static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofields, bool is_const, ast_value *cached_typedef) +static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofields, int is_const_var, ast_value *cached_typedef) { ast_value *var; ast_value *proto; @@ -3472,6 +3640,9 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield } } + if (is_const_var == CV_CONST) + var->constant = true; + /* 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 @@ -3572,6 +3743,15 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield retval = false; goto cleanup; } + proto = (ast_value*)old; + if (!ast_istype(old, ast_value)) { + parseerror(parser, "internal error: not an ast_value"); + retval = false; + proto = NULL; + goto cleanup; + } + ast_delete(var); + var = proto; } } if (opts_standard == COMPILER_QCC && @@ -3613,9 +3793,6 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield } } - if (is_const) - var->isconst = true; - /* Part 2: * Create the global/local, and deal with vector types. */ @@ -3776,7 +3953,7 @@ skipvar: break; } - if (var->isconst) { + if (var->hasvalue) { (void)!parsewarning(parser, WARN_DOUBLE_DECLARATION, "builtin `%s` has already been defined\n" " -> previous declaration here: %s:%i", @@ -3804,6 +3981,7 @@ skipvar: } else if (parser->tok == '{' || parser->tok == '[') { + size_t i; if (localblock) { parseerror(parser, "cannot declare functions within functions"); break; @@ -3812,6 +3990,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; @@ -3823,11 +4005,17 @@ skipvar: if (!localblock) { cval = (ast_value*)cexp; - if (!ast_istype(cval, ast_value) || !cval->isconst) + if (!ast_istype(cval, ast_value) || !cval->hasvalue || !cval->constant) parseerror(parser, "cannot initialize a global constant variable with a non-constant expression"); else { - var->isconst = true; + if (opts_standard != COMPILER_GMQCC && + !OPTS_FLAG(INITIALIZED_NONCONSTANTS) && + is_const_var != CV_VAR) + { + var->constant = true; + } + var->hasvalue = true; if (cval->expression.vtype == TYPE_STRING) var->constval.vstring = parser_strdup(cval->constval.vstring); else @@ -3835,7 +4023,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)); @@ -3844,10 +4035,11 @@ skipvar: else { if (vec_size(sy.out) != 1 && vec_size(sy.ops) != 0) parseerror(parser, "internal error: leaked operands"); - vec_push(localblock->exprs, (ast_expression*)sy.out[0].out); + ast_block_add_expr(localblock, (ast_expression*)sy.out[0].out); } vec_free(sy.out); vec_free(sy.ops); + var->constant = cvq; } } @@ -3909,7 +4101,7 @@ static bool parser_global_statement(parser_t *parser) if (istype || parser->tok == TOKEN_TYPENAME || parser->tok == '.') { - return parse_variable(parser, NULL, false, false, istype); + return parse_variable(parser, NULL, false, CV_NONE, istype); } else if (parser->tok == TOKEN_IDENT && !strcmp(parser_tokval(parser), "var")) { @@ -3918,7 +4110,7 @@ static bool parser_global_statement(parser_t *parser) parseerror(parser, "expected variable declaration after 'var'"); return false; } - return parse_variable(parser, NULL, true, false, NULL); + return parse_variable(parser, NULL, true, CV_VAR, NULL); } } else if (parser->tok == TOKEN_KEYWORD) @@ -3935,7 +4127,7 @@ static bool parser_global_statement(parser_t *parser) return false; } } - return parse_variable(parser, NULL, true, true, NULL); + return parse_variable(parser, NULL, true, CV_CONST, NULL); } else if (!strcmp(parser_tokval(parser), "typedef")) { if (!parser_next(parser)) { @@ -4179,6 +4371,9 @@ void parser_cleanup() vec_free(parser->typedefs); vec_free(parser->_blocktypedefs); + vec_free(parser->labels); + vec_free(parser->gotos); + mem_d(parser); } @@ -4198,21 +4393,21 @@ bool parser_finish(const char *output) for (i = 0; i < vec_size(parser->fields); ++i) { ast_value *field; - bool isconst; + bool hasvalue; if (!ast_istype(parser->fields[i], ast_value)) continue; field = (ast_value*)parser->fields[i]; - isconst = field->isconst; - field->isconst = false; + hasvalue = field->hasvalue; + field->hasvalue = false; if (!ast_global_codegen((ast_value*)field, ir, true)) { con_out("failed to generate field %s\n", field->name); ir_builder_delete(ir); return false; } - if (isconst) { + if (hasvalue) { ir_value *ifld; ast_expression *subtype; - field->isconst = true; + field->hasvalue = true; subtype = field->expression.next; ifld = ir_builder_create_field(ir, field->name, subtype->expression.vtype); if (subtype->expression.vtype == TYPE_FIELD) @@ -4227,7 +4422,7 @@ bool parser_finish(const char *output) if (!ast_istype(parser->globals[i], ast_value)) continue; asvalue = (ast_value*)(parser->globals[i]); - if (!asvalue->uses && !asvalue->isconst && asvalue->expression.vtype != TYPE_FUNCTION) { + if (!asvalue->uses && !asvalue->hasvalue && asvalue->expression.vtype != TYPE_FUNCTION) { if (strcmp(asvalue->name, "end_sys_globals") && strcmp(asvalue->name, "end_sys_fields")) {