X-Git-Url: https://git.xonotic.org/?a=blobdiff_plain;f=parser.c;h=769cced2b2f13783029b313a97055a0bad2f662b;hb=f140251e85c41477280e9eb787ecb4195c3d3ac9;hp=3c5d237e17500ed86acd2e66ad80f937e55e552b;hpb=4079835c7e75bb2b6a20ebb1f1e91e4c8c362c99;p=xonotic%2Fgmqcc.git diff --git a/parser.c b/parser.c index 3c5d237..769cced 100644 --- a/parser.c +++ b/parser.c @@ -1,37 +1,81 @@ +/* + * Copyright (C) 2012 + * Wolfgang Bumiller + * + * 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 + * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is furnished to do + * so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ #include #include #include "gmqcc.h" #include "lexer.h" -typedef struct { - char *name; - ast_expression *var; -} varentry_t; +#define PARSER_HT_FIELDS 0 +#define PARSER_HT_GLOBALS 1 +/* beginning of locals */ +#define PARSER_HT_LOCALS 2 + +#define PARSER_HT_SIZE 1024 +#define TYPEDEF_HT_SIZE 16 typedef struct { lex_file *lex; int tok; - varentry_t *globals; - varentry_t *fields; + ast_expression **globals; + ast_expression **fields; ast_function **functions; ast_value **imm_float; ast_value **imm_string; ast_value **imm_vector; + size_t translated; /* must be deleted first, they reference immediates and values */ ast_value **accessors; ast_value *imm_float_zero; + ast_value *imm_float_one; ast_value *imm_vector_zero; size_t crc_globals; size_t crc_fields; ast_function *function; - varentry_t *locals; - size_t blocklocal; + + /* 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; + ht htglobals; + ht *typedefs; + + /* not to be used directly, we use the hash table */ + ast_expression **_locals; + size_t *_blocklocals; + ast_value **_typedefs; + size_t *_blocktypedefs; + lex_ctx *_block_ctx; size_t errors; @@ -43,14 +87,25 @@ typedef struct { * anything else: type error */ qcint memberof; -} parser_t; + /* 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 bool GMQCC_WARN parser_pop_local(parser_t *parser); -static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofields); -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 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); +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); @@ -81,7 +136,7 @@ static bool GMQCC_WARN parsewarning(parser_t *parser, int warntype, const char * } 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; @@ -99,7 +154,7 @@ static bool GMQCC_WARN genwarning(lex_ctx ctx, int warntype, const char *fmt, .. 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; @@ -172,7 +227,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->cvq = CV_CONST; + out->hasvalue = true; out->constval.vfloat = d; vec_push(parser->imm_float, out); return out; @@ -185,6 +241,13 @@ static ast_value* parser_const_float_0(parser_t *parser) return parser->imm_float_zero; } +static ast_value* parser_const_float_1(parser_t *parser) +{ + if (!parser->imm_float_one) + parser->imm_float_one = parser_const_float(parser, 1); + return parser->imm_float_one; +} + static char *parser_strdup(const char *str) { if (str && !*str) { @@ -196,7 +259,7 @@ static char *parser_strdup(const char *str) return util_strdup(str); } -static ast_value* parser_const_string(parser_t *parser, const char *str) +static ast_value* parser_const_string(parser_t *parser, const char *str, bool dotranslate) { size_t i; ast_value *out; @@ -204,8 +267,14 @@ static ast_value* parser_const_string(parser_t *parser, const char *str) if (!strcmp(parser->imm_string[i]->constval.vstring, str)) return parser->imm_string[i]; } - out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_STRING); - out->isconst = true; + if (dotranslate) { + char name[32]; + snprintf(name, sizeof(name), "dotranslate_%lu", (unsigned long)(parser->translated++)); + out = ast_value_new(parser_ctx(parser), name, TYPE_STRING); + } else + out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_STRING); + out->cvq = CV_CONST; + out->hasvalue = true; out->constval.vstring = parser_strdup(str); vec_push(parser->imm_string, out); return out; @@ -220,7 +289,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->cvq = CV_CONST; + out->hasvalue = true; out->constval.vvec = v; vec_push(parser->imm_vector, out); return out; @@ -244,22 +314,12 @@ static ast_value* parser_const_vector_0(parser_t *parser) static ast_expression* parser_find_field(parser_t *parser, const char *name) { - size_t i; - for (i = 0; i < vec_size(parser->fields); ++i) { - if (!strcmp(parser->fields[i].name, name)) - return parser->fields[i].var; - } - return NULL; + return util_htget(parser->htfields, name); } static ast_expression* parser_find_global(parser_t *parser, const char *name) { - size_t i; - for (i = 0; i < vec_size(parser->globals); ++i) { - if (!strcmp(parser->globals[i].name, name)) - return parser->globals[i].var; - } - return NULL; + return util_htget(parser->htglobals, name); } static ast_expression* parser_find_param(parser_t *parser, const char *name) @@ -278,12 +338,16 @@ static ast_expression* parser_find_param(parser_t *parser, const char *name) static ast_expression* parser_find_local(parser_t *parser, const char *name, size_t upto, bool *isparam) { - size_t i; + size_t i, hash; + ast_expression *e; + + hash = util_hthash(parser->htglobals, name); + *isparam = false; - for (i = vec_size(parser->locals); i > upto;) { + for (i = vec_size(parser->variables); i > upto;) { --i; - if (!strcmp(parser->locals[i].name, name)) - return parser->locals[i].var; + if ( (e = util_htgeth(parser->variables[i], name, hash)) ) + return e; } *isparam = true; return parser_find_param(parser, name); @@ -298,6 +362,20 @@ static ast_expression* parser_find_var(parser_t *parser, const char *name) return v; } +static ast_value* parser_find_typedef(parser_t *parser, const char *name, size_t upto) +{ + size_t i, hash; + ast_value *e; + hash = util_hthash(parser->typedefs[0], name); + + for (i = vec_size(parser->typedefs); i > upto;) { + --i; + if ( (e = (ast_value*)util_htgeth(parser->typedefs[i], name, hash)) ) + return e; + } + return NULL; +} + typedef struct { size_t etype; /* 0 = expression, others are operators */ @@ -316,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; @@ -405,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; @@ -413,7 +492,8 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) ast_expression *exprs[3]; ast_block *blocks[3]; ast_value *asvalue[3]; - size_t i, assignop, addop; + ast_binstore *asbinstore; + size_t i, assignop, addop, subop; qcint generated_op = 0; char ty1[1024]; @@ -442,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; @@ -458,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))->isconst) + (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) @@ -505,22 +589,25 @@ 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 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]) { - 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; @@ -528,6 +615,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: @@ -749,6 +839,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], @@ -757,6 +848,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])) @@ -767,10 +859,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])) @@ -828,7 +925,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) { @@ -862,7 +959,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) { @@ -876,6 +973,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]->cvq == CV_CONST) { + 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'): @@ -890,14 +990,17 @@ 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]->cvq == CV_CONST) { + 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], - (ast_expression*)parser_const_float(parser, 1)); + (ast_expression*)parser_const_float_1(parser)); } else { out = (ast_expression*)ast_binstore_new(ctx, INSTR_STORE_F, addop, exprs[0], - (ast_expression*)parser_const_float(parser, 1)); + (ast_expression*)parser_const_float_1(parser)); } break; case opid3('S','+','+'): @@ -905,22 +1008,33 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) /* prefix ++ */ if (exprs[0]->expression.vtype != TYPE_FLOAT) { ast_type_to_string(exprs[0], ty1, sizeof(ty1)); - parseerror(parser, "invalid type for prefix increment: %s", ty1); + parseerror(parser, "invalid type for suffix increment: %s", ty1); return false; } - if (op->id == opid3('+','+','P')) + if (op->id == opid3('S','+','+')) { addop = INSTR_ADD_F; - else + subop = INSTR_SUB_F; + } else { addop = INSTR_SUB_F; + subop = INSTR_ADD_F; + } + 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)) { out = (ast_expression*)ast_binstore_new(ctx, INSTR_STOREP_F, addop, exprs[0], - (ast_expression*)parser_const_float(parser, 1)); + (ast_expression*)parser_const_float_1(parser)); } else { out = (ast_expression*)ast_binstore_new(ctx, INSTR_STORE_F, addop, exprs[0], - (ast_expression*)parser_const_float(parser, 1)); + (ast_expression*)parser_const_float_1(parser)); } + if (!out) + return false; + out = (ast_expression*)ast_binary_new(ctx, subop, + out, + (ast_expression*)parser_const_float_1(parser)); break; case opid2('+','='): case opid2('-','='): @@ -933,6 +1047,9 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) ty1, ty2); return false; } + 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)) assignop = type_storep_instr[exprs[0]->expression.vtype]; else @@ -955,6 +1072,99 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) return false; }; break; + case opid2('*','='): + case opid2('/','='): + if (exprs[1]->expression.vtype != TYPE_FLOAT || + !(exprs[0]->expression.vtype == TYPE_FLOAT || + exprs[0]->expression.vtype == TYPE_VECTOR)) + { + ast_type_to_string(exprs[0], ty1, sizeof(ty1)); + ast_type_to_string(exprs[1], ty2, sizeof(ty2)); + parseerror(parser, "invalid types used in expression: %s and %s", + ty1, ty2); + return false; + } + 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)) + assignop = type_storep_instr[exprs[0]->expression.vtype]; + else + assignop = type_store_instr[exprs[0]->expression.vtype]; + switch (exprs[0]->expression.vtype) { + case TYPE_FLOAT: + out = (ast_expression*)ast_binstore_new(ctx, assignop, + (op->id == opid2('*','=') ? INSTR_MUL_F : INSTR_DIV_F), + exprs[0], exprs[1]); + break; + case TYPE_VECTOR: + if (op->id == opid2('*','=')) { + out = (ast_expression*)ast_binstore_new(ctx, assignop, INSTR_MUL_VF, + exprs[0], exprs[1]); + } else { + /* there's no DIV_VF */ + out = (ast_expression*)ast_binary_new(ctx, INSTR_DIV_F, + (ast_expression*)parser_const_float_1(parser), + exprs[1]); + if (!out) + return false; + out = (ast_expression*)ast_binstore_new(ctx, assignop, INSTR_MUL_VF, + exprs[0], out); + } + break; + default: + parseerror(parser, "invalid types used in expression: cannot add or subtract type %s and %s", + type_name[exprs[0]->expression.vtype], + type_name[exprs[1]->expression.vtype]); + return false; + }; + break; + case opid2('&','='): + case opid2('|','='): + if (NotSameType(TYPE_FLOAT)) { + ast_type_to_string(exprs[0], ty1, sizeof(ty1)); + ast_type_to_string(exprs[1], ty2, sizeof(ty2)); + parseerror(parser, "invalid types used in expression: %s and %s", + ty1, ty2); + return false; + } + 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)) + assignop = type_storep_instr[exprs[0]->expression.vtype]; + else + assignop = type_store_instr[exprs[0]->expression.vtype]; + out = (ast_expression*)ast_binstore_new(ctx, assignop, + (op->id == opid2('&','=') ? INSTR_BITAND : INSTR_BITOR), + exprs[0], exprs[1]); + break; + case opid3('&','~','='): + /* This is like: a &= ~(b); + * But QC has no bitwise-not, so we implement it as + * a -= a & (b); + */ + if (NotSameType(TYPE_FLOAT)) { + ast_type_to_string(exprs[0], ty1, sizeof(ty1)); + ast_type_to_string(exprs[1], ty2, sizeof(ty2)); + parseerror(parser, "invalid types used in expression: %s and %s", + ty1, ty2); + return false; + } + if (ast_istype(exprs[0], ast_entfield)) + assignop = type_storep_instr[exprs[0]->expression.vtype]; + else + assignop = type_store_instr[exprs[0]->expression.vtype]; + 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]->cvq == CV_CONST) { + 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 @@ -1107,11 +1317,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 (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_pop(parser, sy)) + if (!parser_sy_apply_operator(parser, sy)) return false; } return true; @@ -1155,7 +1377,40 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma else parser->memberof = 0; - if (parser->tok == TOKEN_IDENT) + if (OPTS_FLAG(TRANSLATABLE_STRINGS) && + parser->tok == TOKEN_IDENT && !strcmp(parser_tokval(parser), "_")) + { + /* a translatable string */ + ast_value *val; + + if (wantop) { + parseerror(parser, "expected operator or end of statement, got constant"); + goto onerr; + } + + parser->lex->flags.noops = true; + if (!parser_next(parser) || parser->tok != '(') { + parseerror(parser, "use _(\"string\") to create a translatable string constant"); + goto onerr; + } + parser->lex->flags.noops = false; + if (!parser_next(parser) || parser->tok != TOKEN_STRINGCONST) { + parseerror(parser, "expected a constant string in translatable-string extension"); + goto onerr; + } + val = parser_const_string(parser, parser_tokval(parser), true); + wantop = true; + if (!val) + return false; + vec_push(sy.out, syexp(parser_ctx(parser), (ast_expression*)val)); + DEBUGSHUNTDO(con_out("push string\n")); + + if (!parser_next(parser) || parser->tok != ')') { + parseerror(parser, "expected closing paren after translatable string"); + goto onerr; + } + } + else if (parser->tok == TOKEN_IDENT) { ast_expression *var; if (wantop) { @@ -1192,8 +1447,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))); } @@ -1210,7 +1471,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"); @@ -1230,7 +1491,7 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma goto onerr; } wantop = true; - val = parser_const_string(parser, parser_tokval(parser)); + val = parser_const_string(parser, parser_tokval(parser), false); if (!val) return false; vec_push(sy.out, syexp(parser_ctx(parser), (ast_expression*)val)); @@ -1270,6 +1531,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; @@ -1278,6 +1544,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; } @@ -1289,6 +1560,11 @@ 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_OPERATOR) { @@ -1332,6 +1608,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]; @@ -1339,7 +1621,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]; @@ -1369,11 +1651,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")); } @@ -1383,7 +1665,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)); @@ -1391,12 +1673,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)); @@ -1414,7 +1708,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; } @@ -1427,6 +1721,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: @@ -1448,6 +1747,64 @@ static ast_expression* parse_expression(parser_t *parser, bool stopatcomma) return e; } +static void parser_enterblock(parser_t *parser) +{ + vec_push(parser->variables, util_htnew(PARSER_HT_SIZE)); + 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) +{ + bool rv = true; + size_t locals, typedefs; + + if (vec_size(parser->variables) <= PARSER_HT_LOCALS) { + parseerror(parser, "internal error: parser_leaveblock with no block"); + return false; + } + + util_htdel(vec_last(parser->variables)); + vec_pop(parser->variables); + if (!vec_size(parser->_blocklocals)) { + parseerror(parser, "internal error: parser_leaveblock with no block (2)"); + return false; + } + + locals = vec_last(parser->_blocklocals); + vec_pop(parser->_blocklocals); + while (vec_size(parser->_locals) != locals) { + ast_expression *e = vec_last(parser->_locals); + ast_value *v = (ast_value*)e; + vec_pop(parser->_locals); + if (ast_istype(e, ast_value) && !v->uses) { + if (compile_warning(ast_ctx(v), WARN_UNUSED_VARIABLE, "unused variable: `%s`", v->name)) { + parser->errors++; + rv = false; + } + } + } + + typedefs = vec_last(parser->_blocktypedefs); + while (vec_size(parser->_typedefs) != typedefs) { + ast_delete(vec_last(parser->_typedefs)); + vec_pop(parser->_typedefs); + } + util_htdel(vec_last(parser->typedefs)); + vec_pop(parser->typedefs); + + vec_pop(parser->_block_ctx); + return rv; +} + +static void parser_addlocal(parser_t *parser, const char *name, ast_expression *e) +{ + vec_push(parser->_locals, e); + util_htset(vec_last(parser->variables), name, (void*)e); +} + static bool parse_if(parser_t *parser, ast_block *block, ast_expression **out) { ast_ifthen *ifthen; @@ -1463,7 +1820,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"); @@ -1495,8 +1852,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; } @@ -1509,8 +1865,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; @@ -1560,8 +1915,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; } @@ -1585,8 +1939,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" */ @@ -1643,15 +1996,14 @@ static bool parse_dowhile(parser_t *parser, ast_block *block, ast_expression **o static bool parse_for(parser_t *parser, ast_block *block, ast_expression **out) { - ast_loop *aloop; + ast_loop *aloop; ast_expression *initexpr, *cond, *increment, *ontrue; - size_t oldblocklocal; + ast_value *typevar; bool retval = true; lex_ctx ctx = parser_ctx(parser); - oldblocklocal = parser->blocklocal; - parser->blocklocal = vec_size(parser->locals); + parser_enterblock(parser); initexpr = NULL; cond = NULL; @@ -1669,16 +2021,17 @@ static bool parse_for(parser_t *parser, ast_block *block, ast_expression **out) goto onerr; } - if (parser->tok == TOKEN_TYPENAME) { + typevar = NULL; + if (parser->tok == TOKEN_IDENT) + typevar = parser_find_typedef(parser, parser_tokval(parser), 0); + + if (typevar || parser->tok == TOKEN_TYPENAME) { if (opts_standard != COMPILER_GMQCC) { if (parsewarning(parser, WARN_EXTENSIONS, "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)) + if (!parse_variable(parser, block, true, CV_VAR, typevar, false)) goto onerr; } else if (parser->tok != ';') @@ -1720,10 +2073,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; } @@ -1739,25 +2089,20 @@ 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; - while (vec_size(parser->locals) > parser->blocklocal) - retval = retval && parser_pop_local(parser); - parser->blocklocal = oldblocklocal; + if (!parser_leaveblock(parser)) + retval = false; return retval; onerr: if (initexpr) ast_delete(initexpr); if (cond) ast_delete(cond); if (increment) ast_delete(increment); - while (vec_size(parser->locals) > parser->blocklocal) - (void)!parser_pop_local(parser); - parser->blocklocal = oldblocklocal; + (void)!parser_leaveblock(parser); return false; } @@ -1767,6 +2112,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)) { @@ -1797,7 +2144,7 @@ static bool parse_return(parser_t *parser, ast_block *block, ast_expression **ou 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; @@ -1821,16 +2168,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 != '(') { @@ -1848,15 +2240,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 */ @@ -1879,6 +2262,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; @@ -1900,6 +2311,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->cvq != CV_CONST) { */ + 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; @@ -1949,10 +2368,12 @@ 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); } } + parser_leaveblock(parser); + /* closing paren */ if (parser->tok != '}') { ast_delete(switchnode); @@ -1968,9 +2389,121 @@ 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) { - if (parser->tok == TOKEN_TYPENAME || parser->tok == '.') + 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); + + if (typevar || parser->tok == TOKEN_TYPENAME || parser->tok == '.') { /* local variable */ if (!block) { @@ -1981,26 +2514,49 @@ 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)) + 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)) - 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")) @@ -2048,28 +2604,75 @@ 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)) { + parseerror(parser, "expected type definition after 'typedef'"); + return false; + } + return parse_typedef(parser); + } parseerror(parser, "Unexpected keyword"); return false; } 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)) { + 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; } @@ -2077,30 +2680,11 @@ static bool parse_statement(parser_t *parser, ast_block *block, ast_expression * } } -static bool GMQCC_WARN parser_pop_local(parser_t *parser) -{ - bool rv = true; - varentry_t *ve; - - ve = &vec_last(parser->locals); - if (!parser->errors) { - if (ast_istype(ve->var, ast_value) && !(((ast_value*)(ve->var))->uses)) { - if (parsewarning(parser, WARN_UNUSED_VARIABLE, "unused variable: `%s`", ve->name)) - rv = false; - } - } - mem_d(ve->name); - vec_pop(parser->locals); - return rv; -} - -static bool parse_block_into(parser_t *parser, ast_block *block, bool warnreturn) +static bool parse_block_into(parser_t *parser, ast_block *block) { - size_t oldblocklocal; bool retval = true; - oldblocklocal = parser->blocklocal; - parser->blocklocal = vec_size(parser->locals); + parser_enterblock(parser); if (!parser_next(parser)) { /* skip the '{' */ parseerror(parser, "expected function body"); @@ -2109,7 +2693,7 @@ static bool parse_block_into(parser_t *parser, ast_block *block, bool warnreturn while (parser->tok != TOKEN_EOF && parser->tok < TOKEN_ERROR) { - ast_expression *expr; + ast_expression *expr = NULL; if (parser->tok == '}') break; @@ -2120,89 +2704,64 @@ 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 != '}') { 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); } cleanup: - while (vec_size(parser->locals) > parser->blocklocal) - retval = retval && parser_pop_local(parser); - parser->blocklocal = oldblocklocal; - return !!block; + if (!parser_leaveblock(parser)) + retval = false; + 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); } -/* loop method */ -static bool create_vector_members(ast_value *var, varentry_t *ve) +static bool create_vector_members(ast_value *var, ast_member **me) { size_t i; size_t len = strlen(var->name); for (i = 0; i < 3; ++i) { - ve[i].var = (ast_expression*)ast_member_new(ast_ctx(var), (ast_expression*)var, i); - if (!ve[i].var) - break; - - ve[i].name = (char*)mem_a(len+3); - if (!ve[i].name) { - ast_delete(ve[i].var); + char *name = mem_a(len+3); + memcpy(name, var->name, len); + name[len+0] = '_'; + name[len+1] = 'x'+i; + name[len+2] = 0; + me[i] = ast_member_new(ast_ctx(var), (ast_expression*)var, i, name); + mem_d(name); + if (!me[i]) break; - } - - memcpy(ve[i].name, var->name, len); - ve[i].name[len] = '_'; - ve[i].name[len+1] = 'x'+i; - ve[i].name[len+2] = 0; } if (i == 3) return true; /* unroll */ - do { - --i; - mem_d(ve[i].name); - ast_delete(ve[i].var); - ve[i].name = NULL; - ve[i].var = NULL; - } while (i); + do { ast_member_delete(me[--i]); } while(i); return false; } @@ -2225,6 +2784,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")) @@ -2266,7 +2830,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; @@ -2288,7 +2852,6 @@ static bool parse_function_body(parser_t *parser, ast_value *var) { /* qc allows the use of not-yet-declared functions here * - this automatically creates a prototype */ - varentry_t varent; ast_value *thinkfunc; ast_expression *functype = fld_think->expression.next; @@ -2305,9 +2868,8 @@ static bool parse_function_body(parser_t *parser, ast_value *var) return false; } - varent.var = (ast_expression*)thinkfunc; - varent.name = util_strdup(thinkfunc->name); - vec_push(parser->globals, varent); + vec_push(parser->globals, (ast_expression*)thinkfunc); + util_htset(parser->htglobals, thinkfunc->name, thinkfunc); nextthink = (ast_expression*)thinkfunc; } else { @@ -2407,9 +2969,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) { @@ -2421,10 +2983,12 @@ static bool parse_function_body(parser_t *parser, ast_value *var) } } + parser_enterblock(parser); + for (parami = 0; parami < vec_size(var->expression.params); ++parami) { size_t e; - varentry_t ve[3]; ast_value *param = var->expression.params[parami]; + ast_member *me[3]; if (param->expression.vtype != TYPE_VECTOR && (param->expression.vtype != TYPE_FIELD || @@ -2433,15 +2997,14 @@ static bool parse_function_body(parser_t *parser, ast_value *var) continue; } - if (!create_vector_members(param, ve)) { + if (!create_vector_members(param, me)) { ast_block_delete(block); return false; } for (e = 0; e < 3; ++e) { - vec_push(parser->locals, ve[e]); - ast_block_collect(block, ve[e].var); - ve[e].var = NULL; /* collected */ + parser_addlocal(parser, me[e]->name, (ast_expression*)me[e]); + ast_block_collect(block, (ast_expression*)me[e]); } } @@ -2454,7 +3017,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; } @@ -2462,8 +3025,12 @@ static bool parse_function_body(parser_t *parser, ast_value *var) vec_push(func->blocks, block); parser->function = old; - while (vec_size(parser->locals)) - retval = retval && parser_pop_local(parser); + if (!parser_leaveblock(parser)) + retval = false; + if (vec_size(parser->variables) != PARSER_HT_LOCALS) { + parseerror(parser, "internal error: local scopes left"); + retval = false; + } if (parser->tok == ';') return parser_next(parser); @@ -2477,10 +3044,7 @@ enderrfn: var->constval.vfunc = NULL; enderr: - while (vec_size(parser->locals)) { - mem_d(vec_last(parser->locals).name); - vec_pop(parser->locals); - } + (void)!parser_leaveblock(parser); parser->function = old; return false; } @@ -2556,7 +3120,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) { @@ -2564,7 +3128,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 { @@ -2625,7 +3189,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) { @@ -2633,7 +3197,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 { @@ -2745,7 +3309,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: @@ -2794,7 +3358,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: @@ -2841,7 +3405,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: @@ -2852,7 +3416,7 @@ cleanup: return false; } -static ast_value *parse_typename(parser_t *parser, ast_value **storebase); +static ast_value *parse_typename(parser_t *parser, ast_value **storebase, ast_value *cached_typedef); static ast_value *parse_parameter_list(parser_t *parser, ast_value *var) { lex_ctx ctx; @@ -2903,7 +3467,7 @@ static ast_value *parse_parameter_list(parser_t *parser, ast_value *var) else { /* for anything else just parse a typename */ - param = parse_typename(parser, NULL); + param = parse_typename(parser, NULL, NULL); if (!param) goto on_error; vec_push(params, param); @@ -2916,6 +3480,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"); @@ -3013,7 +3580,7 @@ static ast_value *parse_arraysize(parser_t *parser, ast_value *var) * void() foo(), bar * then the type-information 'void()' can be stored in 'storebase' */ -static ast_value *parse_typename(parser_t *parser, ast_value **storebase) +static ast_value *parse_typename(parser_t *parser, ast_value **storebase, ast_value *cached_typedef) { ast_value *var, *tmp; lex_ctx ctx; @@ -3021,6 +3588,7 @@ static ast_value *parse_typename(parser_t *parser, ast_value **storebase) const char *name = NULL; bool isfield = false; bool wasarray = false; + size_t morefields = 0; ctx = parser_ctx(parser); @@ -3032,14 +3600,38 @@ static ast_value *parse_typename(parser_t *parser, ast_value **storebase) parseerror(parser, "expected typename for field definition"); return NULL; } - if (parser->tok != TOKEN_TYPENAME) { - parseerror(parser, "expected typename"); - return NULL; + + /* Further dots are handled seperately because they won't be part of the + * basetype + */ + while (parser->tok == '.') { + ++morefields; + if (!parser_next(parser)) { + parseerror(parser, "expected typename for field definition"); + 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 */ - var = ast_value_new(ctx, "", parser_token(parser)->constval.t); + if (cached_typedef) { + var = ast_value_copy(cached_typedef); + ast_value_set_name(var, ""); + } else + var = ast_value_new(ctx, "", parser_token(parser)->constval.t); + + for (; morefields; --morefields) { + tmp = ast_value_new(ctx, "<.type>", TYPE_FIELD); + tmp->expression.next = (ast_expression*)var; + var = tmp; + } + /* do not yet turn into a field - remember: * .void() foo; is a field too * .void()() foo; is a function @@ -3129,7 +3721,47 @@ static ast_value *parse_typename(parser_t *parser, ast_value **storebase) return var; } -static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofields) +static bool parse_typedef(parser_t *parser) +{ + ast_value *typevar, *oldtype; + ast_expression *old; + + typevar = parse_typename(parser, NULL, NULL); + + if (!typevar) + return false; + + if ( (old = parser_find_var(parser, typevar->name)) ) { + parseerror(parser, "cannot define a type with the same name as a variable: %s\n" + " -> `%s` has been declared here: %s:%i", + typevar->name, ast_ctx(old).file, ast_ctx(old).line); + ast_delete(typevar); + return false; + } + + if ( (oldtype = parser_find_typedef(parser, typevar->name, vec_last(parser->_blocktypedefs))) ) { + parseerror(parser, "type `%s` has already been declared here: %s:%i", + typevar->name, ast_ctx(oldtype).file, ast_ctx(oldtype).line); + ast_delete(typevar); + return false; + } + + vec_push(parser->_typedefs, typevar); + util_htset(vec_last(parser->typedefs), typevar->name, typevar); + + if (parser->tok != ';') { + parseerror(parser, "expected semicolon after typedef"); + return false; + } + if (!parser_next(parser)) { + parseerror(parser, "parse error after typedef"); + return false; + } + + return true; +} + +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; @@ -3144,19 +3776,16 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield bool cleanvar = true; bool wasarray = false; - varentry_t varent, ve[3]; + ast_member *me[3]; /* get the first complete variable */ - var = parse_typename(parser, &basetype); + var = parse_typename(parser, &basetype, cached_typedef); if (!var) { if (basetype) ast_delete(basetype); return false; } - memset(&varent, 0, sizeof(varent)); - memset(&ve, 0, sizeof(ve)); - while (true) { proto = NULL; wasarray = false; @@ -3195,6 +3824,11 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield } } + 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, ...) * Also: if there was a prototype, `var` will be deleted and set to `proto` which @@ -3204,10 +3838,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; } @@ -3282,10 +3918,29 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield { /* other globals */ if (old) { - parseerror(parser, "global `%s` already declared here: %s:%i", - var->name, ast_ctx(old).file, ast_ctx(old).line); - retval = false; - goto cleanup; + 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; + goto cleanup; + } else { + if (parsewarning(parser, WARN_DOUBLE_DECLARATION, + "global `%s` already declared here: %s:%i", + var->name, ast_ctx(old).file, ast_ctx(old).line)) + { + 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 && (old = parser_find_field(parser, var->name))) @@ -3301,7 +3956,7 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield } else /* it's not a global */ { - old = parser_find_local(parser, var->name, parser->blocklocal, &isparam); + old = parser_find_local(parser, var->name, vec_size(parser->variables)-1, &isparam); if (old && !isparam) { parseerror(parser, "local `%s` already declared here: %s:%i", var->name, ast_ctx(old).file, (int)ast_ctx(old).line); @@ -3337,48 +3992,49 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield isvector = true; if (isvector) { - if (!create_vector_members(var, ve)) { + if (!create_vector_members(var, me)) { retval = false; goto cleanup; } } - varent.name = util_strdup(var->name); - varent.var = (ast_expression*)var; - if (!localblock) { /* deal with global variables, fields, functions */ - if (!nofields && var->expression.vtype == TYPE_FIELD) { - vec_push(parser->fields, varent); + 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) { - for (i = 0; i < 3; ++i) - vec_push(parser->fields, ve[i]); + for (i = 0; i < 3; ++i) { + vec_push(parser->fields, (ast_expression*)me[i]); + util_htset(parser->htfields, me[i]->name, me[i]); + } } } else { - vec_push(parser->globals, varent); + vec_push(parser->globals, (ast_expression*)var); + util_htset(parser->htglobals, var->name, var); if (isvector) { - for (i = 0; i < 3; ++i) - vec_push(parser->globals, ve[i]); + for (i = 0; i < 3; ++i) { + vec_push(parser->globals, (ast_expression*)me[i]); + util_htset(parser->htglobals, me[i]->name, me[i]); + } } } } else { - vec_push(parser->locals, varent); vec_push(localblock->locals, var); + parser_addlocal(parser, var->name, (ast_expression*)var); if (isvector) { for (i = 0; i < 3; ++i) { - vec_push(parser->locals, ve[i]); - ast_block_collect(localblock, ve[i].var); - ve[i].var = NULL; /* from here it's being collected in the block */ + parser_addlocal(parser, me[i]->name, (ast_expression*)me[i]); + ast_block_collect(localblock, (ast_expression*)me[i]); } } } - varent.name = NULL; - ve[0].name = ve[1].name = ve[2].name = NULL; - ve[0].var = ve[1].var = ve[2].var = NULL; - cleanvar = false; } + me[0] = me[1] = me[2] = NULL; + cleanvar = false; /* Part 2.2 * deal with arrays */ @@ -3433,7 +4089,10 @@ 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; } @@ -3449,7 +4108,7 @@ skipvar: if (parser->tok != '{') { if (parser->tok != '=') { - parseerror(parser, "missing semicolon or initializer"); + parseerror(parser, "missing semicolon or initializer, got: `%s`", parser_tokval(parser)); break; } @@ -3463,7 +4122,7 @@ skipvar: } if (parser->tok == '#') { - ast_function *func; + ast_function *func = NULL; if (localblock) { parseerror(parser, "cannot declare builtins within functions"); @@ -3481,37 +4140,55 @@ 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; } - func = ast_function_new(ast_ctx(var), var->name, var); - if (!func) { - parseerror(parser, "failed to allocate function for `%s`", var->name); - break; + if (var->hasvalue) { + (void)!parsewarning(parser, WARN_DOUBLE_DECLARATION, + "builtin `%s` has already been defined\n" + " -> previous declaration here: %s:%i", + var->name, ast_ctx(var).file, (int)ast_ctx(var).line); } - vec_push(parser->functions, func); + else + { + func = ast_function_new(ast_ctx(var), var->name, var); + if (!func) { + parseerror(parser, "failed to allocate function for `%s`", var->name); + break; + } + vec_push(parser->functions, func); - func->builtin = -parser_token(parser)->constval.i; + func->builtin = -parser_token(parser)->constval.i-1; + } if (!parser_next(parser)) { parseerror(parser, "expected comma or semicolon"); - ast_function_delete(func); + if (func) + ast_function_delete(func); var->constval.vfunc = NULL; break; } } 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; @@ -3523,31 +4200,43 @@ skipvar: if (!localblock) { cval = (ast_value*)cexp; - if (!ast_istype(cval, ast_value) || !cval->isconst) + 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 { - var->isconst = true; + if (opts_standard != COMPILER_GMQCC && + !OPTS_FLAG(INITIALIZED_NONCONSTANTS) && + qualifier != CV_VAR) + { + 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"); - 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->cvq = cvq; } } @@ -3595,34 +4284,47 @@ cleanup: ast_delete(basetype); if (cleanvar && var) ast_delete(var); - if (varent.name) mem_d(varent.name); - if (ve[0].name) mem_d(ve[0].name); - if (ve[1].name) mem_d(ve[1].name); - if (ve[2].name) mem_d(ve[2].name); - if (ve[0].var) mem_d(ve[0].var); - if (ve[1].var) mem_d(ve[1].var); - if (ve[2].var) mem_d(ve[2].var); + if (me[0]) ast_member_delete(me[0]); + if (me[1]) ast_member_delete(me[1]); + if (me[2]) ast_member_delete(me[2]); return retval; } static bool parser_global_statement(parser_t *parser) { - if (parser->tok == TOKEN_TYPENAME || parser->tok == '.') + 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); + return parse_variable(parser, NULL, false, CV_NONE, istype, false); + } + else if (parse_var_qualifiers(parser, false, &cvq, &noref)) + { + if (cvq == CV_WRONG) + return false; + return parse_variable(parser, NULL, true, cvq, NULL, noref); } else if (parser->tok == TOKEN_KEYWORD) { - /* handle 'var' and 'const' */ - if (!strcmp(parser_tokval(parser), "var")) { + if (!strcmp(parser_tokval(parser), "typedef")) { if (!parser_next(parser)) { - parseerror(parser, "expected variable declaration after 'var'"); + parseerror(parser, "expected type definition after 'typedef'"); return false; } - return parse_variable(parser, NULL, true); + return parse_typedef(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)) { @@ -3658,8 +4360,9 @@ static uint16_t progdefs_crc_both(uint16_t old, const char *str) static void generate_checksum(parser_t *parser) { - uint16_t crc = 0xFFFF; - size_t i; + uint16_t crc = 0xFFFF; + size_t i; + ast_value *value; crc = progdefs_crc_both(crc, "\n/* file generated by qcc, do not modify */\n\ntypedef struct\n{"); crc = progdefs_crc_sum(crc, "\tint\tpad[28];\n"); @@ -3676,9 +4379,10 @@ static void generate_checksum(parser_t *parser) progdefs_crc_file("\tint\tofs_parm7[3];\n"); */ for (i = 0; i < parser->crc_globals; ++i) { - if (!ast_istype(parser->globals[i].var, ast_value)) + if (!ast_istype(parser->globals[i], ast_value)) continue; - switch (parser->globals[i].var->expression.vtype) { + value = (ast_value*)(parser->globals[i]); + switch (value->expression.vtype) { case TYPE_FLOAT: crc = progdefs_crc_both(crc, "\tfloat\t"); break; case TYPE_VECTOR: crc = progdefs_crc_both(crc, "\tvec3_t\t"); break; case TYPE_STRING: crc = progdefs_crc_both(crc, "\tstring_t\t"); break; @@ -3687,14 +4391,15 @@ static void generate_checksum(parser_t *parser) crc = progdefs_crc_both(crc, "\tint\t"); break; } - crc = progdefs_crc_both(crc, parser->globals[i].name); + crc = progdefs_crc_both(crc, value->name); crc = progdefs_crc_both(crc, ";\n"); } crc = progdefs_crc_both(crc, "} globalvars_t;\n\ntypedef struct\n{\n"); for (i = 0; i < parser->crc_fields; ++i) { - if (!ast_istype(parser->fields[i].var, ast_value)) + if (!ast_istype(parser->fields[i], ast_value)) continue; - switch (parser->fields[i].var->expression.next->expression.vtype) { + value = (ast_value*)(parser->fields[i]); + switch (value->expression.next->expression.vtype) { case TYPE_FLOAT: crc = progdefs_crc_both(crc, "\tfloat\t"); break; case TYPE_VECTOR: crc = progdefs_crc_both(crc, "\tvec3_t\t"); break; case TYPE_STRING: crc = progdefs_crc_both(crc, "\tstring_t\t"); break; @@ -3703,7 +4408,7 @@ static void generate_checksum(parser_t *parser) crc = progdefs_crc_both(crc, "\tint\t"); break; } - crc = progdefs_crc_both(crc, parser->fields[i].name); + crc = progdefs_crc_both(crc, value->name); crc = progdefs_crc_both(crc, ";\n"); } crc = progdefs_crc_both(crc, "} entvars_t;\n\n"); @@ -3716,6 +4421,7 @@ static parser_t *parser; bool parser_init() { size_t i; + parser = (parser_t*)mem_a(sizeof(parser_t)); if (!parser) return false; @@ -3733,6 +4439,11 @@ bool parser_init() mem_d(parser); return false; } + + vec_push(parser->variables, parser->htfields = util_htnew(PARSER_HT_SIZE)); + vec_push(parser->variables, parser->htglobals = util_htnew(PARSER_HT_SIZE)); + vec_push(parser->typedefs, util_htnew(TYPEDEF_HT_SIZE)); + vec_push(parser->_blocktypedefs, 0); return true; } @@ -3819,12 +4530,10 @@ void parser_cleanup() ast_delete(parser->imm_float[i]); } for (i = 0; i < vec_size(parser->fields); ++i) { - ast_delete(parser->fields[i].var); - mem_d(parser->fields[i].name); + ast_delete(parser->fields[i]); } for (i = 0; i < vec_size(parser->globals); ++i) { - ast_delete(parser->globals[i].var); - mem_d(parser->globals[i].name); + ast_delete(parser->globals[i]); } vec_free(parser->accessors); vec_free(parser->functions); @@ -3833,7 +4542,25 @@ void parser_cleanup() vec_free(parser->imm_float); vec_free(parser->globals); vec_free(parser->fields); - vec_free(parser->locals); + + for (i = 0; i < vec_size(parser->variables); ++i) + util_htdel(parser->variables[i]); + vec_free(parser->variables); + vec_free(parser->_blocklocals); + vec_free(parser->_locals); + + for (i = 0; i < vec_size(parser->_typedefs); ++i) + ast_delete(parser->_typedefs[i]); + vec_free(parser->_typedefs); + for (i = 0; i < vec_size(parser->typedefs); ++i) + util_htdel(parser->typedefs[i]); + vec_free(parser->typedefs); + vec_free(parser->_blocktypedefs); + + vec_free(parser->_block_ctx); + + vec_free(parser->labels); + vec_free(parser->gotos); mem_d(parser); } @@ -3854,21 +4581,21 @@ bool parser_finish(const char *output) for (i = 0; i < vec_size(parser->fields); ++i) { ast_value *field; - bool isconst; - if (!ast_istype(parser->fields[i].var, ast_value)) + bool hasvalue; + if (!ast_istype(parser->fields[i], ast_value)) continue; - field = (ast_value*)parser->fields[i].var; - isconst = field->isconst; - field->isconst = false; + field = (ast_value*)parser->fields[i]; + 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) @@ -3880,19 +4607,15 @@ bool parser_finish(const char *output) } for (i = 0; i < vec_size(parser->globals); ++i) { ast_value *asvalue; - if (!ast_istype(parser->globals[i].var, ast_value)) + if (!ast_istype(parser->globals[i], ast_value)) continue; - asvalue = (ast_value*)(parser->globals[i].var); - if (!asvalue->uses && !asvalue->isconst && 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); - } + asvalue = (ast_value*)(parser->globals[i]); + if (!asvalue->uses && !asvalue->hasvalue && asvalue->expression.vtype != TYPE_FUNCTION) { + 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", parser->globals[i].name); + con_out("failed to generate global %s\n", asvalue->name); ir_builder_delete(ir); return false; } @@ -3920,57 +4643,25 @@ bool parser_finish(const char *output) } for (i = 0; i < vec_size(parser->globals); ++i) { ast_value *asvalue; - if (!ast_istype(parser->globals[i].var, ast_value)) + if (!ast_istype(parser->globals[i], ast_value)) continue; - asvalue = (ast_value*)(parser->globals[i].var); - 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", parser->globals[i].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", parser->globals[i].name); - ir_builder_delete(ir); - return false; - } + asvalue = (ast_value*)(parser->globals[i]); + if (!ast_generate_accessors(asvalue, ir)) { + ir_builder_delete(ir); + return false; } } for (i = 0; i < vec_size(parser->fields); ++i) { ast_value *asvalue; - asvalue = (ast_value*)(parser->fields[i].var->expression.next); + asvalue = (ast_value*)(parser->fields[i]->expression.next); if (!ast_istype((ast_expression*)asvalue, ast_value)) 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", parser->fields[i].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", parser->fields[i].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) {