X-Git-Url: https://git.xonotic.org/?p=xonotic%2Fgmqcc.git;a=blobdiff_plain;f=parser.c;h=84413fd934d59cffc5494d01c20b8a16251eec0c;hp=8be7e3001e5c22dcd295d0b1a1d2d86df512b3aa;hb=f9b1d057b5247f2ecbaa7259ed1b7bcb56e45922;hpb=4513fc4d0b87823749f9d7ffc584086794138f99 diff --git a/parser.c b/parser.c index 8be7e30..84413fd 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; @@ -69,6 +75,7 @@ typedef struct { size_t *_blocklocals; ast_value **_typedefs; size_t *_blocktypedefs; + lex_ctx *_block_ctx; size_t errors; @@ -80,20 +87,25 @@ typedef struct { * anything else: type error */ qcint memberof; -} parser_t; -#define CV_NONE 0 -#define CV_CONST 1 -#define CV_VAR -1 + /* Keep track of our ternary vs parenthesis nesting state. + * If we reach a 'comma' operator in a ternary without a paren, + * we shall trigger -Wternary-precedence. + */ + enum { POT_PAREN, POT_TERNARY1, POT_TERNARY2 } *pot; + + /* pragma flags */ + bool noref; +} parser_t; 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 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); +static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofields, int qualifier, ast_value *cached_typedef, bool noref); +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(parser_t *parser, bool stopatcomma); @@ -118,16 +130,16 @@ static bool GMQCC_WARN parsewarning(parser_t *parser, int warntype, const char * if (!OPTS_WARN(warntype)) return false; - if (opts_werror) { + 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); + con_vprintmsg(lvl, parser->lex->tok.ctx.file, parser->lex->tok.ctx.line, (opts.werror ? "error" : "warning"), fmt, ap); va_end(ap); - return opts_werror; + return opts.werror; } static bool GMQCC_WARN genwarning(lex_ctx ctx, int warntype, const char *fmt, ...) @@ -138,14 +150,14 @@ static bool GMQCC_WARN genwarning(lex_ctx ctx, int warntype, const char *fmt, .. if (!OPTS_WARN(warntype)) return false; - if (opts_werror) + if (opts.werror) lvl = LVL_ERROR; va_start(ap, fmt); - con_vprintmsg(lvl, ctx.file, ctx.line, "warning", fmt, ap); + con_vprintmsg(lvl, ctx.file, ctx.line, (opts.werror ? "error" : "warning"), fmt, ap); va_end(ap); - return opts_werror; + return opts.werror; } /********************************************************************** @@ -215,7 +227,7 @@ 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->constant = true; + out->cvq = CV_CONST; out->hasvalue = true; out->constval.vfloat = d; vec_push(parser->imm_float, out); @@ -261,7 +273,7 @@ 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->constant = true; + out->cvq = CV_CONST; out->hasvalue = true; out->constval.vstring = parser_strdup(str); vec_push(parser->imm_string, out); @@ -277,7 +289,7 @@ 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->constant = true; + out->cvq = CV_CONST; out->hasvalue = true; out->constval.vvec = v; vec_push(parser->imm_vector, out); @@ -382,6 +394,7 @@ typedef struct #define SY_PAREN_EXPR '(' #define SY_PAREN_FUNC 'f' #define SY_PAREN_INDEX '[' +#define SY_PAREN_TERNARY '?' static sy_elem syexp(lex_ctx ctx, ast_expression *v) { sy_elem e; @@ -471,7 +484,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; @@ -479,6 +492,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; @@ -508,6 +522,10 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) vec_shrinkby(sy->ops, 1); + /* op(:?) has no input and no output */ + if (!op->operands) + return true; + vec_shrinkby(sy->out, op->operands); for (i = 0; i < op->operands; ++i) { exprs[i] = sy->out[vec_size(sy->out)+i].out; @@ -524,7 +542,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))->hasvalue && ((ast_value*)(A))->constant) + (ast_istype((A), ast_value) && ((ast_value*)(A))->hasvalue && (((ast_value*)(A))->cvq == CV_CONST)) #define CanConstFold(A, B) \ (CanConstFold1(A) && CanConstFold1(B)) #define ConstV(i) (asvalue[(i)]->constval.vvec) @@ -571,22 +589,29 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) out = (ast_expression*)ast_array_index_new(ctx, exprs[0], exprs[1]); if (rotate_entfield_array_index_nodes(&out)) { - if (opts_standard != COMPILER_GMQCC) { +#if 0 + /* This is not broken in fteqcc anymore */ + 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" " -> this is an extension from -std=gmqcc"); } +#endif } break; 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; @@ -594,6 +619,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: @@ -825,7 +853,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, @@ -835,10 +863,15 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) break; case opid2('?',':'): + if (vec_last(parser->pot) != POT_TERNARY2) { + parseerror(parser, "mismatched parenthesis/ternary"); + return false; + } + vec_pop(parser->pot); 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])) @@ -896,7 +929,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) { @@ -930,7 +963,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) { @@ -944,7 +977,7 @@ 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) { + if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) { parseerror(parser, "assignment to constant `%s`", asvalue[0]->name); } out = (ast_expression*)ast_store_new(ctx, assignop, exprs[0], exprs[1]); @@ -961,7 +994,7 @@ 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) { + if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) { parseerror(parser, "assignment to constant `%s`", asvalue[0]->name); } if (ast_istype(exprs[0], ast_entfield)) { @@ -989,7 +1022,7 @@ 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) { + if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) { parseerror(parser, "assignment to constant `%s`", asvalue[0]->name); } if (ast_istype(exprs[0], ast_entfield)) { @@ -1018,7 +1051,7 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) ty1, ty2); return false; } - if (ast_istype(exprs[0], ast_value) && asvalue[0]->constant) { + if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) { parseerror(parser, "assignment to constant `%s`", asvalue[0]->name); } if (ast_istype(exprs[0], ast_entfield)) @@ -1055,7 +1088,7 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) ty1, ty2); return false; } - if (ast_istype(exprs[0], ast_value) && asvalue[0]->constant) { + if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) { parseerror(parser, "assignment to constant `%s`", asvalue[0]->name); } if (ast_istype(exprs[0], ast_entfield)) @@ -1099,7 +1132,7 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) ty1, ty2); return false; } - if (ast_istype(exprs[0], ast_value) && asvalue[0]->constant) { + if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) { parseerror(parser, "assignment to constant `%s`", asvalue[0]->name); } if (ast_istype(exprs[0], ast_entfield)) @@ -1129,10 +1162,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; - if (ast_istype(exprs[0], ast_value) && asvalue[0]->constant) { + if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) { parseerror(parser, "assignment to constant `%s`", asvalue[0]->name); } - out = (ast_expression*)ast_binstore_new(ctx, assignop, INSTR_SUB_F, exprs[0], out); + asbinstore = ast_binstore_new(ctx, assignop, INSTR_SUB_F, exprs[0], out); + asbinstore->keep_dest = true; + out = (ast_expression*)asbinstore; break; } #undef NotSameType @@ -1223,7 +1258,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" @@ -1286,11 +1321,23 @@ 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; } - if (!parser_sy_pop(parser, sy)) + if (sy->ops[vec_size(sy->ops)-1].paren == SY_PAREN_TERNARY) { + if (functions_only) + return false; + if (vec_last(parser->pot) != POT_TERNARY1) { + parseerror(parser, "mismatched colon in ternary expression (missing closing paren?)"); + return false; + } + vec_last(parser->pot) = POT_TERNARY2; + /* pop off the parenthesis */ + vec_shrinkby(sy->ops, 1); + return true; + } + if (!parser_sy_apply_operator(parser, sy)) return false; } return true; @@ -1376,7 +1423,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 */ @@ -1404,8 +1451,14 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma parseerror(parser, "unexpected ident: %s", parser_tokval(parser)); goto onerr; } - if (ast_istype(var, ast_value)) + if (ast_istype(var, ast_value)) { ((ast_value*)var)->uses++; + } + else if (ast_istype(var, ast_member)) { + ast_member *mem = (ast_member*)var; + if (ast_istype(mem->owner, ast_value)) + ((ast_value*)(mem->owner))->uses++; + } vec_push(sy.out, syexp(parser_ctx(parser), var)); DEBUGSHUNTDO(con_out("push %s\n", parser_tokval(parser))); } @@ -1422,7 +1475,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"); @@ -1482,6 +1535,11 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma /* closing an opening paren */ if (!parser_close_paren(parser, &sy, false)) goto onerr; + if (vec_last(parser->pot) != POT_PAREN) { + parseerror(parser, "mismatched parentheses (closing paren during ternary expression?)"); + goto onerr; + } + vec_pop(parser->pot); } else { DEBUGSHUNTDO(con_out("do[nop] )\n")); --parens; @@ -1490,6 +1548,11 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma /* allowed for function calls */ if (!parser_close_paren(parser, &sy, true)) goto onerr; + if (vec_last(parser->pot) != POT_PAREN) { + parseerror(parser, "mismatched parentheses (closing paren during ternary expression?)"); + goto onerr; + } + vec_pop(parser->pot); } wantop = true; } @@ -1501,8 +1564,17 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma break; if (!parser_close_paren(parser, &sy, false)) goto onerr; + if (vec_last(parser->pot) != POT_PAREN) { + parseerror(parser, "mismatched parentheses (closing paren during ternary expression?)"); + goto onerr; + } + 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"); @@ -1544,6 +1616,12 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma break; } + if (op->id == opid1(',')) { + if (vec_size(parser->pot) && vec_last(parser->pot) == POT_TERNARY2) { + (void)!parsewarning(parser, WARN_TERNARY_PRECEDENCE, "suggesting parenthesis around ternary expression"); + } + } + if (vec_size(sy.ops) && !vec_last(sy.ops).paren) olast = &operators[vec_last(sy.ops).etype-1]; @@ -1551,7 +1629,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]; @@ -1559,7 +1637,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) { @@ -1581,11 +1659,11 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma if (wantop) { size_t sycount = vec_size(sy.out); DEBUGSHUNTDO(con_out("push [op] (\n")); - ++parens; + ++parens; vec_push(parser->pot, POT_PAREN); /* we expected an operator, this is the function-call operator */ vec_push(sy.ops, syparen(parser_ctx(parser), SY_PAREN_FUNC, sycount-1)); } else { - ++parens; + ++parens; vec_push(parser->pot, POT_PAREN); vec_push(sy.ops, syparen(parser_ctx(parser), SY_PAREN_EXPR, 0)); DEBUGSHUNTDO(con_out("push [nop] (\n")); } @@ -1595,7 +1673,7 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma parseerror(parser, "unexpected array subscript"); goto onerr; } - ++parens; + ++parens; vec_push(parser->pot, POT_PAREN); /* push both the operator and the paren, this makes life easier */ vec_push(sy.ops, syop(parser_ctx(parser), op)); vec_push(sy.ops, syparen(parser_ctx(parser), SY_PAREN_INDEX, 0)); @@ -1603,12 +1681,24 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma } else if (op->id == opid2('?',':')) { wantop = false; vec_push(sy.ops, syop(parser_ctx(parser), op)); + vec_push(sy.ops, syparen(parser_ctx(parser), SY_PAREN_TERNARY, 0)); wantop = false; - --ternaries; + ++ternaries; + vec_push(parser->pot, POT_TERNARY1); } else if (op->id == opid2(':','?')) { - /* we don't push this operator */ + if (!vec_size(parser->pot)) { + parseerror(parser, "unexpected colon outside ternary expression (missing parenthesis?)"); + goto onerr; + } + if (vec_last(parser->pot) != POT_TERNARY1) { + parseerror(parser, "unexpected colon outside ternary expression (missing parenthesis?)"); + goto onerr; + } + if (!parser_close_paren(parser, &sy, false)) + goto onerr; + vec_push(sy.ops, syop(parser_ctx(parser), op)); wantop = false; - ++ternaries; + --ternaries; } else { DEBUGSHUNTDO(con_out("push operator %s\n", op->op)); vec_push(sy.ops, syop(parser_ctx(parser), op)); @@ -1626,7 +1716,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; } @@ -1639,6 +1729,11 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma vec_free(sy.out); vec_free(sy.ops); DEBUGSHUNTDO(con_out("shunt done\n")); + if (vec_size(parser->pot)) { + parseerror(parser, "internal error: vec_size(parser->pot) = %lu", (unsigned long)vec_size(parser->pot)); + return NULL; + } + vec_free(parser->pot); return expr; onerr: @@ -1666,6 +1761,7 @@ static void parser_enterblock(parser_t *parser) vec_push(parser->_blocklocals, vec_size(parser->_locals)); vec_push(parser->typedefs, util_htnew(TYPEDEF_HT_SIZE)); vec_push(parser->_blocktypedefs, vec_size(parser->_typedefs)); + vec_push(parser->_block_ctx, parser_ctx(parser)); } static bool parser_leaveblock(parser_t *parser) @@ -1692,8 +1788,10 @@ static bool parser_leaveblock(parser_t *parser) ast_value *v = (ast_value*)e; vec_pop(parser->_locals); if (ast_istype(e, ast_value) && !v->uses) { - if (parsewarning(parser, WARN_UNUSED_VARIABLE, "unused variable: `%s`", v->name)) + if (compile_warning(ast_ctx(v), WARN_UNUSED_VARIABLE, "unused variable: `%s`", v->name)) { + parser->errors++; rv = false; + } } } @@ -1705,6 +1803,7 @@ static bool parser_leaveblock(parser_t *parser) util_htdel(vec_last(parser->typedefs)); vec_pop(parser->typedefs); + vec_pop(parser->_block_ctx); return rv; } @@ -1761,8 +1860,7 @@ static bool parse_if(parser_t *parser, ast_block *block, ast_expression **out) ast_delete(cond); return false; } - ontrue = parse_statement_or_block(parser); - if (!ontrue) { + if (!parse_statement_or_block(parser, &ontrue)) { ast_delete(cond); return false; } @@ -1775,8 +1873,7 @@ static bool parse_if(parser_t *parser, ast_block *block, ast_expression **out) ast_delete(cond); return false; } - onfalse = parse_statement_or_block(parser); - if (!onfalse) { + if (!parse_statement_or_block(parser, &onfalse)) { ast_delete(ontrue); ast_delete(cond); return false; @@ -1826,8 +1923,7 @@ static bool parse_while(parser_t *parser, ast_block *block, ast_expression **out ast_delete(cond); return false; } - ontrue = parse_statement_or_block(parser); - if (!ontrue) { + if (!parse_statement_or_block(parser, &ontrue)) { ast_delete(cond); return false; } @@ -1851,8 +1947,7 @@ static bool parse_dowhile(parser_t *parser, ast_block *block, ast_expression **o parseerror(parser, "expected loop body"); return false; } - ontrue = parse_statement_or_block(parser); - if (!ontrue) + if (!parse_statement_or_block(parser, &ontrue)) return false; /* expect the "while" */ @@ -1939,12 +2034,12 @@ 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; } - if (!parse_variable(parser, block, true, CV_VAR, typevar)) + if (!parse_variable(parser, block, true, CV_VAR, typevar, false)) goto onerr; } else if (parser->tok != ';') @@ -2002,10 +2097,8 @@ static bool parse_for(parser_t *parser, ast_block *block, ast_expression **out) parseerror(parser, "expected for-loop body"); goto onerr; } - ontrue = parse_statement_or_block(parser); - if (!ontrue) { + if (!parse_statement_or_block(parser, &ontrue)) goto onerr; - } aloop = ast_loop_new(ctx, initexpr, cond, NULL, increment, ontrue); *out = (ast_expression*)aloop; @@ -2027,6 +2120,8 @@ static bool parse_return(parser_t *parser, ast_block *block, ast_expression **ou ast_return *ret = NULL; ast_value *expected = parser->function->vtype; + lex_ctx ctx = parser_ctx(parser); + (void)block; /* not touching */ if (!parser_next(parser)) { @@ -2052,12 +2147,12 @@ 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"); } - ret = ast_return_new(parser_ctx(parser), NULL); + ret = ast_return_new(ctx, NULL); } *out = (ast_expression*)ret; return true; @@ -2081,16 +2176,61 @@ static bool parse_break_continue(parser_t *parser, ast_block *block, ast_express return true; } +/* returns true when it was a variable qualifier, false otherwise! + * on error, cvq is set to CV_WRONG + */ +static bool parse_var_qualifiers(parser_t *parser, bool with_local, int *cvq, bool *noref) +{ + bool had_const = false; + bool had_var = false; + bool had_noref = false; + + for (;;) { + if (!strcmp(parser_tokval(parser), "const")) + had_const = true; + else if (!strcmp(parser_tokval(parser), "var")) + had_var = true; + else if (with_local && !strcmp(parser_tokval(parser), "local")) + had_var = true; + else if (!strcmp(parser_tokval(parser), "noref")) + had_noref = true; + else if (!had_const && !had_var && !had_noref) { + return false; + } + else + break; + if (!parser_next(parser)) + goto onerr; + } + if (had_const) + *cvq = CV_CONST; + else if (had_var) + *cvq = CV_VAR; + else + *cvq = CV_NONE; + *noref = had_noref; + return true; +onerr: + parseerror(parser, "parse error after variable qualifier"); + *cvq = CV_WRONG; + return true; +} + static bool parse_switch(parser_t *parser, ast_block *block, ast_expression **out) { ast_expression *operand; ast_value *opval; + ast_value *typevar; ast_switch *switchnode; ast_switch_case swcase; + int cvq; + bool noref; + lex_ctx ctx = parser_ctx(parser); (void)block; /* not touching */ + (void)opval; /* parse over the opening paren */ if (!parser_next(parser) || parser->tok != '(') { @@ -2130,6 +2270,34 @@ static bool parse_switch(parser_t *parser, ast_block *block, ast_expression **ou return false; } + /* new block; allow some variables to be declared here */ + parser_enterblock(parser); + while (true) { + typevar = NULL; + 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)) { + ast_delete(switchnode); + return false; + } + continue; + } + if (parse_var_qualifiers(parser, true, &cvq, &noref)) + { + if (cvq == CV_WRONG) { + ast_delete(switchnode); + return false; + } + if (!parse_variable(parser, block, false, cvq, NULL, noref)) { + ast_delete(switchnode); + return false; + } + continue; + } + break; + } + /* case list! */ while (parser->tok != '}') { ast_block *caseblock; @@ -2153,7 +2321,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->cvq != CV_CONST) { */ parseerror(parser, "case on non-constant values need to be explicitly enabled via -frelaxed-switch"); ast_unref(operand); return false; @@ -2208,10 +2376,15 @@ 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; + } } } + parser_leaveblock(parser); + /* closing paren */ if (parser->tok != '}') { ast_delete(switchnode); @@ -2227,9 +2400,117 @@ 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_skipwhite(parser_t *parser) +{ + do { + if (!parser_next(parser)) + return false; + } while (parser->tok == TOKEN_WHITE && parser->tok < TOKEN_ERROR); + return parser->tok < TOKEN_ERROR; +} + +static bool parse_eol(parser_t *parser) +{ + if (!parse_skipwhite(parser)) + return false; + return parser->tok == TOKEN_EOL; +} + +static bool parse_pragma_do(parser_t *parser) +{ + if (!parser_next(parser) || + parser->tok != TOKEN_IDENT || + strcmp(parser_tokval(parser), "pragma")) + { + parseerror(parser, "expected `pragma` keyword after `#`, got `%s`", parser_tokval(parser)); + return false; + } + if (!parse_skipwhite(parser) || parser->tok != TOKEN_IDENT) { + parseerror(parser, "expected pragma, got `%s`", parser_tokval(parser)); + return false; + } + + if (!strcmp(parser_tokval(parser), "noref")) { + if (!parse_skipwhite(parser) || parser->tok != TOKEN_INTCONST) { + parseerror(parser, "`noref` pragma requires an argument: 0 or 1"); + return false; + } + parser->noref = !!parser_token(parser)->constval.i; + if (!parse_eol(parser)) { + parseerror(parser, "parse error after `noref` pragma"); + return false; + } + } + else + { + parseerror(parser, "unrecognized hash-keyword: `%s`", parser_tokval(parser)); + return false; + } + + return true; +} + +static bool parse_pragma(parser_t *parser) +{ + bool rv; + parser->lex->flags.preprocessing = true; + parser->lex->flags.mergelines = true; + rv = parse_pragma_do(parser); + if (parser->tok != TOKEN_EOL) { + parseerror(parser, "junk after pragma"); + rv = false; + } + parser->lex->flags.preprocessing = false; + parser->lex->flags.mergelines = false; + if (!parser_next(parser)) { + parseerror(parser, "parse error after pragma"); + rv = false; + } + return rv; +} + static bool parse_statement(parser_t *parser, ast_block *block, ast_expression **out, bool allow_cases) { + bool noref; + int cvq = CV_NONE; ast_value *typevar = NULL; + + *out = NULL; + if (parser->tok == TOKEN_IDENT) typevar = parser_find_typedef(parser, parser_tokval(parser), 0); @@ -2240,30 +2521,53 @@ 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; } - if (!parse_variable(parser, block, false, CV_NONE, typevar)) + if (!parse_variable(parser, block, false, CV_NONE, typevar, false)) return false; - *out = NULL; return true; } + else if (parse_var_qualifiers(parser, !!block, &cvq, &noref)) + { + if (cvq == CV_WRONG) + return false; + return parse_variable(parser, block, true, cvq, NULL, noref); + } else if (parser->tok == TOKEN_KEYWORD) { - if (!strcmp(parser_tokval(parser), "local")) + if (!strcmp(parser_tokval(parser), "__builtin_debug_printtype")) { - if (!block) { - parseerror(parser, "cannot declare a local variable here"); - return false; - } + char ty[1024]; + ast_value *tdef; + if (!parser_next(parser)) { - parseerror(parser, "expected variable declaration"); + parseerror(parser, "parse error after __builtin_debug_printtype"); return false; } - if (!parse_variable(parser, block, true, CV_VAR, NULL)) - return false; - *out = NULL; + + 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")) @@ -2284,7 +2588,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; } @@ -2311,6 +2615,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)) { @@ -2325,12 +2633,42 @@ static bool parse_statement(parser_t *parser, ast_block *block, ast_expression * else if (parser->tok == '{') { ast_block *inner; - inner = parse_block(parser, false); + inner = parse_block(parser); if (!inner) return false; *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)) { @@ -2353,7 +2691,7 @@ static bool parse_statement(parser_t *parser, ast_block *block, ast_expression * } } -static bool parse_block_into(parser_t *parser, ast_block *block, bool warnreturn) +static bool parse_block_into(parser_t *parser, ast_block *block) { bool retval = true; @@ -2377,23 +2715,16 @@ static bool parse_block_into(parser_t *parser, ast_block *block, bool warnreturn } 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 != '}') { block = NULL; } else { - if (warnreturn && parser->function->vtype->expression.next->expression.vtype != TYPE_VOID) - { - if (!vec_size(block->exprs) || - !ast_istype(vec_last(block->exprs), ast_return)) - { - if (parsewarning(parser, WARN_MISSING_RETURN_VALUES, "control reaches end of non-void function")) { - block = NULL; - goto cleanup; - } - } - } (void)parser_next(parser); } @@ -2403,27 +2734,26 @@ cleanup: return retval && !!block; } -static ast_block* parse_block(parser_t *parser, bool warnreturn) +static ast_block* parse_block(parser_t *parser) { ast_block *block; block = ast_block_new(parser_ctx(parser)); if (!block) return NULL; - if (!parse_block_into(parser, block, warnreturn)) { + if (!parse_block_into(parser, block)) { ast_block_delete(block); return NULL; } return block; } -static ast_expression* parse_statement_or_block(parser_t *parser) +static bool parse_statement_or_block(parser_t *parser, ast_expression **out) { - ast_expression *expr = NULL; - if (parser->tok == '{') - return (ast_expression*)parse_block(parser, false); - if (!parse_statement(parser, NULL, &expr, false)) - return NULL; - return expr; + if (parser->tok == '{') { + *out = (ast_expression*)parse_block(parser); + return !!*out; + } + return parse_statement(parser, NULL, out, false); } static bool create_vector_members(ast_value *var, ast_member **me) @@ -2469,6 +2799,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")) @@ -2649,9 +2984,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) { @@ -2697,7 +3035,7 @@ static bool parse_function_body(parser_t *parser, ast_value *var) vec_push(parser->functions, func); parser->function = func; - if (!parse_block_into(parser, block, true)) { + if (!parse_block_into(parser, block)) { ast_block_delete(block); goto enderrfn; } @@ -2714,7 +3052,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; @@ -2800,7 +3138,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) { @@ -2808,7 +3149,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 { @@ -2869,7 +3213,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) { @@ -2877,7 +3224,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 { @@ -2989,9 +3339,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); @@ -3038,9 +3387,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); @@ -3085,9 +3433,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); @@ -3164,7 +3511,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 */ @@ -3291,13 +3638,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 */ @@ -3374,7 +3720,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"); @@ -3442,7 +3788,7 @@ static bool parse_typedef(parser_t *parser) return true; } -static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofields, int is_const_var, ast_value *cached_typedef) +static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofields, int qualifier, ast_value *cached_typedef, bool noref) { ast_value *var; ast_value *proto; @@ -3473,7 +3819,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) { @@ -3496,7 +3842,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) { @@ -3505,8 +3851,10 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield } } - if (is_const_var == CV_CONST) - var->constant = true; + var->cvq = qualifier; + /* in a noref section we simply bump the usecount */ + if (noref || parser->noref) + var->uses++; /* Part 1: * check for validity: (end_sys_..., multiple-definitions, prototypes, ...) @@ -3517,10 +3865,12 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield /* Deal with end_sys_ vars */ was_end = false; if (!strcmp(var->name, "end_sys_globals")) { + var->uses++; parser->crc_globals = vec_size(parser->globals); was_end = true; } else if (!strcmp(var->name, "end_sys_fields")) { + var->uses++; parser->crc_fields = vec_size(parser->fields); was_end = true; } @@ -3555,7 +3905,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"); @@ -3595,7 +3945,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; @@ -3608,9 +3958,18 @@ 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 && + 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"); @@ -3641,7 +4000,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; @@ -3668,7 +4027,8 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield if (!localblock) { /* deal with global variables, fields, functions */ - if (!nofields && var->expression.vtype == TYPE_FIELD) { + if (!nofields && var->expression.vtype == TYPE_FIELD && parser->tok != '=') { + var->isfield = true; vec_push(parser->fields, (ast_expression*)var); util_htset(parser->htfields, var->name, var); if (isvector) { @@ -3756,12 +4116,15 @@ skipvar: if (parser->tok == ',') goto another; + /* if (!var || (!localblock && !nofields && basetype->expression.vtype == TYPE_FIELD)) { + */ + if (!var) { parseerror(parser, "missing comma or semicolon while parsing variables"); 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) ) @@ -3781,7 +4144,7 @@ skipvar: break; } } - else if (opts_standard == COMPILER_QCC) { + else if (opts.standard == COMPILER_QCC) { parseerror(parser, "expected '=' before function body in this standard"); } @@ -3804,7 +4167,7 @@ skipvar: parseerror(parser, "builtin number must be an integer constant"); break; } - if (parser_token(parser)->constval.i <= 0) { + if (parser_token(parser)->constval.i < 0) { parseerror(parser, "builtin number must be an integer greater than zero"); break; } @@ -3824,7 +4187,7 @@ skipvar: } vec_push(parser->functions, func); - func->builtin = -parser_token(parser)->constval.i; + func->builtin = -parser_token(parser)->constval.i-1; } if (!parser_next(parser)) { @@ -3837,14 +4200,22 @@ skipvar: } else if (parser->tok == '{' || parser->tok == '[') { + size_t i; if (localblock) { parseerror(parser, "cannot declare functions within functions"); break; } + if (proto) + ast_ctx(proto) = parser_ctx(parser); + 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; @@ -3856,37 +4227,44 @@ skipvar: if (!localblock) { cval = (ast_value*)cexp; - if (!ast_istype(cval, ast_value) || !cval->hasvalue || !cval->constant) + if (!ast_istype(cval, ast_value) || ((!cval->hasvalue || cval->cvq != CV_CONST) && !cval->isfield)) 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) && - is_const_var != CV_VAR) + qualifier != CV_VAR) { - var->constant = true; + var->cvq = CV_CONST; } var->hasvalue = true; if (cval->expression.vtype == TYPE_STRING) var->constval.vstring = parser_strdup(cval->constval.vstring); + else if (cval->expression.vtype == TYPE_FIELD) + var->constval.vfield = cval; else memcpy(&var->constval, &cval->constval, sizeof(var->constval)); ast_unref(cval); } } else { + bool cvq; shunt sy = { NULL, NULL }; + cvq = var->cvq; + var->cvq = CV_NONE; 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); + var->cvq = cvq; } } @@ -3942,41 +4320,26 @@ cleanup: static bool parser_global_statement(parser_t *parser) { + int cvq = CV_WRONG; + bool noref = false; ast_value *istype = 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); + return parse_variable(parser, NULL, false, CV_NONE, istype, false); } - else if (parser->tok == TOKEN_IDENT && !strcmp(parser_tokval(parser), "var")) + else if (parse_var_qualifiers(parser, false, &cvq, &noref)) { - if (!strcmp(parser_tokval(parser), "var")) { - if (!parser_next(parser)) { - parseerror(parser, "expected variable declaration after 'var'"); - return false; - } - return parse_variable(parser, NULL, true, CV_VAR, NULL); - } + if (cvq == CV_WRONG) + return false; + return parse_variable(parser, NULL, true, cvq, NULL, noref); } else if (parser->tok == TOKEN_KEYWORD) { - if (!strcmp(parser_tokval(parser), "const")) { - if (!parser_next(parser)) { - parseerror(parser, "expected variable declaration after 'const'"); - return false; - } - if (parser->tok == TOKEN_IDENT && !strcmp(parser_tokval(parser), "var")) { - (void)!parsewarning(parser, WARN_CONST_VAR, "ignoring `var` after const qualifier"); - if (!parser_next(parser)) { - parseerror(parser, "expected variable declaration after 'const var'"); - return false; - } - } - return parse_variable(parser, NULL, true, CV_CONST, NULL); - } - else if (!strcmp(parser_tokval(parser), "typedef")) { + if (!strcmp(parser_tokval(parser), "typedef")) { if (!parser_next(parser)) { parseerror(parser, "expected type definition after 'typedef'"); return false; @@ -3986,6 +4349,10 @@ static bool parser_global_statement(parser_t *parser) parseerror(parser, "unrecognized keyword `%s`", parser_tokval(parser)); return false; } + else if (parser->tok == '#') + { + return parse_pragma(parser); + } else if (parser->tok == '$') { if (!parser_next(parser)) { @@ -4218,6 +4585,11 @@ void parser_cleanup() vec_free(parser->typedefs); vec_free(parser->_blocktypedefs); + vec_free(parser->_block_ctx); + + vec_free(parser->labels); + vec_free(parser->gotos); + mem_d(parser); } @@ -4267,12 +4639,8 @@ bool parser_finish(const char *output) continue; asvalue = (ast_value*)(parser->globals[i]); if (!asvalue->uses && !asvalue->hasvalue && asvalue->expression.vtype != TYPE_FUNCTION) { - if (strcmp(asvalue->name, "end_sys_globals") && - strcmp(asvalue->name, "end_sys_fields")) - { - retval = retval && !genwarning(ast_ctx(asvalue), WARN_UNUSED_VARIABLE, - "unused global: `%s`", asvalue->name); - } + retval = retval && !genwarning(ast_ctx(asvalue), WARN_UNUSED_VARIABLE, + "unused global: `%s`", asvalue->name); } if (!ast_global_codegen(asvalue, ir, false)) { con_out("failed to generate global %s\n", asvalue->name); @@ -4306,25 +4674,9 @@ bool parser_finish(const char *output) if (!ast_istype(parser->globals[i], ast_value)) continue; asvalue = (ast_value*)(parser->globals[i]); - if (asvalue->setter) { - if (!ast_global_codegen(asvalue->setter, ir, false) || - !ast_function_codegen(asvalue->setter->constval.vfunc, ir) || - !ir_function_finalize(asvalue->setter->constval.vfunc->ir_func)) - { - printf("failed to generate setter for %s\n", asvalue->name); - ir_builder_delete(ir); - return false; - } - } - if (asvalue->getter) { - if (!ast_global_codegen(asvalue->getter, ir, false) || - !ast_function_codegen(asvalue->getter->constval.vfunc, ir) || - !ir_function_finalize(asvalue->getter->constval.vfunc->ir_func)) - { - printf("failed to generate getter for %s\n", asvalue->name); - ir_builder_delete(ir); - return false; - } + if (!ast_generate_accessors(asvalue, ir)) { + ir_builder_delete(ir); + return false; } } for (i = 0; i < vec_size(parser->fields); ++i) { @@ -4335,25 +4687,9 @@ bool parser_finish(const char *output) continue; if (asvalue->expression.vtype != TYPE_ARRAY) continue; - if (asvalue->setter) { - if (!ast_global_codegen(asvalue->setter, ir, false) || - !ast_function_codegen(asvalue->setter->constval.vfunc, ir) || - !ir_function_finalize(asvalue->setter->constval.vfunc->ir_func)) - { - printf("failed to generate setter for %s\n", asvalue->name); - ir_builder_delete(ir); - return false; - } - } - if (asvalue->getter) { - if (!ast_global_codegen(asvalue->getter, ir, false) || - !ast_function_codegen(asvalue->getter->constval.vfunc, ir) || - !ir_function_finalize(asvalue->getter->constval.vfunc->ir_func)) - { - printf("failed to generate getter for %s\n", asvalue->name); - ir_builder_delete(ir); - return false; - } + if (!ast_generate_accessors(asvalue, ir)) { + ir_builder_delete(ir); + return false; } } for (i = 0; i < vec_size(parser->functions); ++i) { @@ -4363,7 +4699,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)) { @@ -4374,7 +4710,7 @@ bool parser_finish(const char *output) } if (retval) { - if (opts_dumpfin) + if (opts.dumpfin) ir_builder_dump(ir, con_out); generate_checksum(parser);