X-Git-Url: https://git.xonotic.org/?a=blobdiff_plain;f=parser.c;h=5fa0d899f201d9948e2f971eb3126a8c33841582;hb=3436fa7d8937c0281a18396071a1072964f33f62;hp=8090be4206c9b6e17a9bb2de23072626060b6f73;hpb=a468d0b4786675482610bc6eac5d04c8d1a779c0;p=xonotic%2Fgmqcc.git diff --git a/parser.c b/parser.c index 8090be4..5fa0d89 100644 --- a/parser.c +++ b/parser.c @@ -54,6 +54,7 @@ typedef struct { ast_value *imm_float_one; ast_value *imm_vector_zero; ast_value *nil; + ast_value *reserved_version; size_t crc_globals; size_t crc_fields; @@ -88,18 +89,15 @@ typedef struct { /* we store the '=' operator info */ const oper_info *assign_op; - /* TYPE_FIELD -> parser_find_fields is used instead of find_var - * TODO: TYPE_VECTOR -> x, y and z are accepted in the gmqcc standard - * anything else: type error - */ - qcint memberof; - /* 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 parser_pot *pot; + /* magic values */ + ast_value *const_vec[3]; + /* pragma flags */ bool noref; } parser_t; @@ -556,7 +554,8 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) asvalue[i] = (ast_value*)exprs[i]; if (exprs[i]->expression.vtype == TYPE_NOEXPR && - !(i != 0 && op->id == opid2('?',':'))) + !(i != 0 && op->id == opid2('?',':')) && + !(i == 1 && op->id == opid1('.'))) { if (ast_istype(exprs[i], ast_label)) compile_error(ast_ctx(exprs[i]), "expected expression, got an unknown identifier"); @@ -589,7 +588,21 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) return false; case opid1('.'): - if (exprs[0]->expression.vtype == TYPE_ENTITY) { + if (exprs[0]->expression.vtype == TYPE_VECTOR && + exprs[1]->expression.vtype == TYPE_NOEXPR) + { + if (exprs[1] == (ast_expression*)parser->const_vec[0]) + out = (ast_expression*)ast_member_new(ctx, exprs[0], 0, NULL); + else if (exprs[1] == (ast_expression*)parser->const_vec[1]) + out = (ast_expression*)ast_member_new(ctx, exprs[0], 1, NULL); + else if (exprs[1] == (ast_expression*)parser->const_vec[2]) + out = (ast_expression*)ast_member_new(ctx, exprs[0], 2, NULL); + else { + parseerror(parser, "access to invalid vector component"); + return false; + } + } + else if (exprs[0]->expression.vtype == TYPE_ENTITY) { if (exprs[1]->expression.vtype != TYPE_FIELD) { parseerror(parser, "type error: right hand of member-operand should be an entity-field"); return false; @@ -597,7 +610,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) out = (ast_expression*)ast_entfield_new(ctx, exprs[0], exprs[1]); } else if (exprs[0]->expression.vtype == TYPE_VECTOR) { - parseerror(parser, "internal error: vector access is not supposed to be handled at this point"); + parseerror(parser, "vectors cannot be accessed this way"); return false; } else { @@ -1519,7 +1532,6 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma ast_expression *expr = NULL; shunt sy; bool wantop = false; - bool gotmemberof = false; /* only warn once about an assignment in a truth value because the current code * would trigger twice on: if(a = b && ...), once for the if-truth-value, once for the && part */ @@ -1540,11 +1552,6 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma while (true) { - if (gotmemberof) - gotmemberof = false; - else - parser->memberof = 0; - if (OPTS_FLAG(TRANSLATABLE_STRINGS) && parser->tok == TOKEN_IDENT && !strcmp(parser_tokval(parser), "_")) { @@ -1580,32 +1587,27 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma } else if (parser->tok == TOKEN_IDENT) { + const char *ctoken = parser_tokval(parser); + ast_expression *prev = vec_size(sy.out) ? vec_last(sy.out).out : NULL; ast_expression *var; if (wantop) { parseerror(parser, "expected operator or end of statement"); goto onerr; } wantop = true; - /* variable */ - if (opts.standard == COMPILER_GMQCC) + /* a_vector.{x,y,z} */ + if (!vec_size(sy.ops) || + !vec_last(sy.ops).etype || + operators[vec_last(sy.ops).etype-1].id != opid1('.') || + (prev >= intrinsic_debug_typestring && + prev <= intrinsic_debug_typestring)) { - if (parser->memberof == TYPE_ENTITY) { - /* still get vars first since there could be a fieldpointer */ - var = parser_find_var(parser, parser_tokval(parser)); - if (!var) - var = parser_find_field(parser, parser_tokval(parser)); - } - else if (parser->memberof == TYPE_VECTOR) - { - parseerror(parser, "TODO: implement effective vector member access"); - goto onerr; - } - else if (parser->memberof) { - parseerror(parser, "namespace for member not found"); - goto onerr; - } - else - var = parser_find_var(parser, parser_tokval(parser)); + /* When adding more intrinsics, fix the above condition */ + prev = NULL; + } + if (prev && prev->expression.vtype == TYPE_VECTOR && ctoken[0] >= 'x' && ctoken[0] <= 'z' && !ctoken[1]) + { + var = (ast_expression*)parser->const_vec[ctoken[0]-'x']; } else { var = parser_find_var(parser, parser_tokval(parser)); if (!var) @@ -1886,24 +1888,6 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma olast = NULL; } - 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) { - parseerror(parser, "unexpected member operator"); - goto onerr; - } - if (prevex->expression.vtype == TYPE_ENTITY) - parser->memberof = TYPE_ENTITY; - else if (prevex->expression.vtype == TYPE_VECTOR) - parser->memberof = TYPE_VECTOR; - else { - parseerror(parser, "type error: type has no members"); - goto onerr; - } - gotmemberof = true; - } - if (op->id == opid1('(')) { if (wantop) { size_t sycount = vec_size(sy.out); @@ -1957,7 +1941,7 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma goto onerr; } if (parser->tok == ';' || - (!parens && (parser->tok == ']' || parser->tok == ')'))) + (!parens && (parser->tok == ']' || parser->tok == ')' || parser->tok == '}'))) { break; } @@ -3504,10 +3488,17 @@ static bool parse_enum(parser_t *parser) old = parse_expression_leave(parser, true, false, false); asvalue = (ast_value*)old; if (!ast_istype(old, ast_value) || asvalue->cvq != CV_CONST || !asvalue->hasvalue) { - parseerror(parser, "enumeration value for must be a constant"); + compile_error(ast_ctx(var), "constant value or expression expected"); goto onerror; } num = (var->constval.vfloat = asvalue->constval.vfloat) + 1; + + if (parser->tok == '}') + break; + if (parser->tok != ',') { + parseerror(parser, "expected `}` or comma after expression"); + goto onerror; + } } if (parser->tok != '}') { @@ -5453,6 +5444,20 @@ bool parser_init() parser->nil->cvq = CV_CONST; if (OPTS_FLAG(UNTYPED_NIL)) util_htset(parser->htglobals, "nil", (void*)parser->nil); + + parser->const_vec[0] = ast_value_new(empty_ctx, "", TYPE_NOEXPR); + parser->const_vec[1] = ast_value_new(empty_ctx, "", TYPE_NOEXPR); + parser->const_vec[2] = ast_value_new(empty_ctx, "", TYPE_NOEXPR); + + if (opts.add_info) { + parser->reserved_version = ast_value_new(empty_ctx, "reserved:version", TYPE_STRING); + parser->reserved_version->cvq = CV_CONST; + parser->reserved_version->hasvalue = true; + parser->reserved_version->expression.flags |= AST_FLAG_INCLUDE_DEF; + parser->reserved_version->constval.vstring = util_strdup(GMQCC_FULL_VERSION_STRING); + } else { + parser->reserved_version = NULL; + } return true; } @@ -5573,6 +5578,10 @@ void parser_cleanup() ast_value_delete(parser->nil); + ast_value_delete(parser->const_vec[0]); + ast_value_delete(parser->const_vec[1]); + ast_value_delete(parser->const_vec[2]); + mem_d(parser); } @@ -5634,6 +5643,13 @@ bool parser_finish(const char *output) return false; } } + if (parser->reserved_version && + !ast_global_codegen(parser->reserved_version, ir, false)) + { + con_out("failed to generate reserved::version"); + ir_builder_delete(ir); + return false; + } for (i = 0; i < vec_size(parser->imm_float); ++i) { if (!ast_global_codegen(parser->imm_float[i], ir, false)) { con_out("failed to generate global %s\n", parser->imm_float[i]->name);