X-Git-Url: https://git.xonotic.org/?a=blobdiff_plain;f=parser.c;h=3bd1073382a5fd006f83c825dfa5dd16c7a9eff2;hb=e695a5919db838a1204c78ff0fbfab75caedb5e4;hp=2e16853217f2110ee8f317257d95779b6c2a3556;hpb=2f9db8972ee0c8cd5f491f47d79a283c8d72c7aa;p=xonotic%2Fgmqcc.git diff --git a/parser.c b/parser.c index 2e16853..3bd1073 100644 --- a/parser.c +++ b/parser.c @@ -31,7 +31,7 @@ /* beginning of locals */ #define PARSER_HT_LOCALS 2 -#define PARSER_HT_SIZE 1024 +#define PARSER_HT_SIZE 128 #define TYPEDEF_HT_SIZE 16 enum parser_pot { POT_PAREN, POT_TERNARY1, POT_TERNARY2 }; @@ -105,7 +105,7 @@ typedef struct { size_t max_param_count; } parser_t; -static const ast_expression *intrinsic_debug_typestring = (ast_expression*)0x10; +static ast_expression * const intrinsic_debug_typestring = (ast_expression*)0x1; static void parser_enterblock(parser_t *parser); static bool parser_leaveblock(parser_t *parser); @@ -119,6 +119,9 @@ 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, bool truthvalue, bool with_labels); static ast_expression* parse_expression(parser_t *parser, bool stopatcomma, bool with_labels); +static ast_value* parser_create_array_setter_proto(parser_t *parser, ast_value *array, const char *funcname); +static ast_value* parser_create_array_getter_proto(parser_t *parser, ast_value *array, const ast_expression *elemtype, const char *funcname); +static ast_value *parse_typename(parser_t *parser, ast_value **storebase, ast_value *cached_typedef); static void parseerror(parser_t *parser, const char *fmt, ...) { @@ -210,12 +213,18 @@ static ast_value* parser_const_float(parser_t *parser, double d) { size_t i; ast_value *out; + lex_ctx ctx; for (i = 0; i < vec_size(parser->imm_float); ++i) { const double compare = parser->imm_float[i]->constval.vfloat; if (memcmp((const void*)&compare, (const void *)&d, sizeof(double)) == 0) return parser->imm_float[i]; } - out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_FLOAT); + if (parser->lex) + ctx = parser_ctx(parser); + else { + memset(&ctx, 0, sizeof(ctx)); + } + out = ast_value_new(ctx, "#IMMEDIATE", TYPE_FLOAT); out->cvq = CV_CONST; out->hasvalue = true; out->constval.vfloat = d; @@ -539,8 +548,8 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) DEBUGSHUNTDO(con_out("apply %s\n", op->op)); if (vec_size(sy->out) < op->operands) { - parseerror(parser, "internal error: not enough operands: %i (operator %s (%i))", vec_size(sy->out), - op->op, (int)op->id); + compile_error(ctx, "internal error: not enough operands: %i (operator %s (%i))", vec_size(sy->out), + op->op, (int)op->id); return false; } @@ -569,7 +578,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) } if (blocks[0] && !vec_size(blocks[0]->exprs) && op->id != opid1(',')) { - parseerror(parser, "internal error: operator cannot be applied on empty blocks"); + compile_error(ctx, "internal error: operator cannot be applied on empty blocks"); return false; } @@ -587,7 +596,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) switch (op->id) { default: - parseerror(parser, "internal error: unhandled operator: %s (%i)", op->op, (int)op->id); + compile_error(ctx, "internal error: unhandled operator: %s (%i)", op->op, (int)op->id); return false; case opid1('.'): @@ -601,23 +610,23 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) 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"); + compile_error(ctx, "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"); + compile_error(ast_ctx(exprs[1]), "type error: right hand of member-operand should be an entity-field"); return false; } out = (ast_expression*)ast_entfield_new(ctx, exprs[0], exprs[1]); } else if (exprs[0]->expression.vtype == TYPE_VECTOR) { - parseerror(parser, "vectors cannot be accessed this way"); + compile_error(ast_ctx(exprs[1]), "vectors cannot be accessed this way"); return false; } else { - parseerror(parser, "type error: member-of operator on something that is not an entity or vector"); + compile_error(ast_ctx(exprs[1]), "type error: member-of operator on something that is not an entity or vector"); return false; } break; @@ -628,12 +637,12 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) exprs[0]->expression.next->expression.vtype == TYPE_ARRAY)) { ast_type_to_string(exprs[0], ty1, sizeof(ty1)); - parseerror(parser, "cannot index value of type %s", ty1); + compile_error(ast_ctx(exprs[0]), "cannot index value of type %s", ty1); return false; } if (exprs[1]->expression.vtype != TYPE_FLOAT) { ast_type_to_string(exprs[0], ty1, sizeof(ty1)); - parseerror(parser, "index must be of type float, not %s", ty1); + compile_error(ast_ctx(exprs[1]), "index must be of type float, not %s", ty1); return false; } out = (ast_expression*)ast_array_index_new(ctx, exprs[0], exprs[1]); @@ -692,8 +701,8 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) exprs[0]); break; default: - parseerror(parser, "invalid types used in expression: cannot negate type %s", - type_name[exprs[0]->expression.vtype]); + compile_error(ctx, "invalid types used in expression: cannot negate type %s", + type_name[exprs[0]->expression.vtype]); return false; } break; @@ -734,8 +743,8 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_FNC, exprs[0]); break; default: - parseerror(parser, "invalid types used in expression: cannot logically negate type %s", - type_name[exprs[0]->expression.vtype]); + compile_error(ctx, "invalid types used in expression: cannot logically negate type %s", + type_name[exprs[0]->expression.vtype]); return false; } break; @@ -744,9 +753,9 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) if (exprs[0]->expression.vtype != exprs[1]->expression.vtype || (exprs[0]->expression.vtype != TYPE_VECTOR && exprs[0]->expression.vtype != TYPE_FLOAT) ) { - parseerror(parser, "invalid types used in expression: cannot add type %s and %s", - type_name[exprs[0]->expression.vtype], - type_name[exprs[1]->expression.vtype]); + compile_error(ctx, "invalid types used in expression: cannot add type %s and %s", + type_name[exprs[0]->expression.vtype], + type_name[exprs[1]->expression.vtype]); return false; } switch (exprs[0]->expression.vtype) { @@ -765,9 +774,9 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) out = (ast_expression*)ast_binary_new(ctx, INSTR_ADD_V, exprs[0], exprs[1]); break; default: - parseerror(parser, "invalid types used in expression: cannot add type %s and %s", - type_name[exprs[0]->expression.vtype], - type_name[exprs[1]->expression.vtype]); + compile_error(ctx, "invalid types used in expression: cannot add type %s and %s", + type_name[exprs[0]->expression.vtype], + type_name[exprs[1]->expression.vtype]); return false; }; break; @@ -775,9 +784,9 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) if (exprs[0]->expression.vtype != exprs[1]->expression.vtype || (exprs[0]->expression.vtype != TYPE_VECTOR && exprs[0]->expression.vtype != TYPE_FLOAT) ) { - parseerror(parser, "invalid types used in expression: cannot subtract type %s from %s", - type_name[exprs[1]->expression.vtype], - type_name[exprs[0]->expression.vtype]); + compile_error(ctx, "invalid types used in expression: cannot subtract type %s from %s", + type_name[exprs[1]->expression.vtype], + type_name[exprs[0]->expression.vtype]); return false; } switch (exprs[0]->expression.vtype) { @@ -794,9 +803,9 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_V, exprs[0], exprs[1]); break; default: - parseerror(parser, "invalid types used in expression: cannot subtract type %s from %s", - type_name[exprs[1]->expression.vtype], - type_name[exprs[0]->expression.vtype]); + compile_error(ctx, "invalid types used in expression: cannot subtract type %s from %s", + type_name[exprs[1]->expression.vtype], + type_name[exprs[0]->expression.vtype]); return false; }; break; @@ -808,9 +817,9 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) exprs[0]->expression.vtype == TYPE_FLOAT) ) { - parseerror(parser, "invalid types used in expression: cannot multiply types %s and %s", - type_name[exprs[1]->expression.vtype], - type_name[exprs[0]->expression.vtype]); + compile_error(ctx, "invalid types used in expression: cannot multiply types %s and %s", + type_name[exprs[1]->expression.vtype], + type_name[exprs[0]->expression.vtype]); return false; } switch (exprs[0]->expression.vtype) { @@ -905,34 +914,61 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) } break; default: - parseerror(parser, "invalid types used in expression: cannot multiply types %s and %s", - type_name[exprs[1]->expression.vtype], - type_name[exprs[0]->expression.vtype]); + compile_error(ctx, "invalid types used in expression: cannot multiply types %s and %s", + type_name[exprs[1]->expression.vtype], + type_name[exprs[0]->expression.vtype]); return false; }; break; case opid1('/'): - if (NotSameType(TYPE_FLOAT)) { - parseerror(parser, "invalid types used in expression: cannot divide types %s and %s", - type_name[exprs[0]->expression.vtype], - type_name[exprs[1]->expression.vtype]); + if (exprs[1]->expression.vtype != TYPE_FLOAT) { + ast_type_to_string(exprs[0], ty1, sizeof(ty1)); + ast_type_to_string(exprs[1], ty2, sizeof(ty2)); + compile_error(ctx, "invalid types used in expression: cannot divide tyeps %s and %s", ty1, ty2); return false; } - if (CanConstFold(exprs[0], exprs[1])) - out = (ast_expression*)parser_const_float(parser, ConstF(0) / ConstF(1)); + if (exprs[0]->expression.vtype == TYPE_FLOAT) { + if (CanConstFold(exprs[0], exprs[1])) + out = (ast_expression*)parser_const_float(parser, ConstF(0) / ConstF(1)); + else + out = (ast_expression*)ast_binary_new(ctx, INSTR_DIV_F, exprs[0], exprs[1]); + } + else if (exprs[0]->expression.vtype == TYPE_VECTOR) { + if (CanConstFold(exprs[0], exprs[1])) + out = (ast_expression*)parser_const_vector(parser, vec3_mulvf(ConstV(0), 1.0/ConstF(1))); + else { + if (CanConstFold1(exprs[1])) { + out = (ast_expression*)parser_const_float(parser, 1.0 / ConstF(1)); + } else { + out = (ast_expression*)ast_binary_new(ctx, INSTR_DIV_F, + (ast_expression*)parser_const_float_1(parser), + exprs[1]); + } + if (!out) { + compile_error(ctx, "internal error: failed to generate division"); + return false; + } + out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_VF, exprs[0], out); + } + } else - out = (ast_expression*)ast_binary_new(ctx, INSTR_DIV_F, exprs[0], exprs[1]); + { + ast_type_to_string(exprs[0], ty1, sizeof(ty1)); + ast_type_to_string(exprs[1], ty2, sizeof(ty2)); + compile_error(ctx, "invalid types used in expression: cannot divide tyeps %s and %s", ty1, ty2); + return false; + } break; case opid1('%'): case opid2('%','='): - parseerror(parser, "qc does not have a modulo operator"); + compile_error(ctx, "qc does not have a modulo operator"); return false; case opid1('|'): case opid1('&'): if (NotSameType(TYPE_FLOAT)) { - parseerror(parser, "invalid types used in expression: cannot perform bit operations between types %s and %s", - type_name[exprs[0]->expression.vtype], - type_name[exprs[1]->expression.vtype]); + compile_error(ctx, "invalid types used in expression: cannot perform bit operations between types %s and %s", + type_name[exprs[0]->expression.vtype], + type_name[exprs[1]->expression.vtype]); return false; } if (CanConstFold(exprs[0], exprs[1])) @@ -966,16 +1002,6 @@ static bool parser_sy_apply_operator(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], - type_name[exprs[1]->expression.vtype]); - parseerror(parser, "TODO: logical ops for arbitrary types using INSTR_NOT"); - parseerror(parser, "TODO: optional early out"); - return false; - } -#endif if (CanConstFold(exprs[0], exprs[1])) { if (OPTS_FLAG(PERL_LOGIC)) { @@ -994,7 +1020,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) if (OPTS_FLAG(PERL_LOGIC) && !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)); - parseerror(parser, "invalid types for logical operation with -fperl-logic: %s and %s", ty1, ty2); + compile_error(ctx, "invalid types for logical operation with -fperl-logic: %s and %s", ty1, ty2); return false; } for (i = 0; i < 2; ++i) { @@ -1027,14 +1053,14 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) case opid2('?',':'): if (vec_last(parser->pot) != POT_TERNARY2) { - parseerror(parser, "mismatched parenthesis/ternary"); + compile_error(ctx, "mismatched parenthesis/ternary"); return false; } vec_pop(parser->pot); if (!ast_compare_type(exprs[1], exprs[2])) { ast_type_to_string(exprs[1], ty1, sizeof(ty1)); ast_type_to_string(exprs[2], ty2, sizeof(ty2)); - parseerror(parser, "operands of ternary expression must have the same type, got %s and %s", ty1, ty2); + compile_error(ctx, "operands of ternary expression must have the same type, got %s and %s", ty1, ty2); return false; } if (CanConstFold1(exprs[0])) @@ -1052,27 +1078,27 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) case opid2('<', '='): generated_op += INSTR_LE; if (NotSameType(TYPE_FLOAT)) { - parseerror(parser, "invalid types used in expression: cannot perform comparison between types %s and %s", - type_name[exprs[0]->expression.vtype], - type_name[exprs[1]->expression.vtype]); + compile_error(ctx, "invalid types used in expression: cannot perform comparison between types %s and %s", + type_name[exprs[0]->expression.vtype], + type_name[exprs[1]->expression.vtype]); return false; } out = (ast_expression*)ast_binary_new(ctx, generated_op, exprs[0], exprs[1]); break; case opid2('!', '='): if (exprs[0]->expression.vtype != exprs[1]->expression.vtype) { - parseerror(parser, "invalid types used in expression: cannot perform comparison between types %s and %s", - type_name[exprs[0]->expression.vtype], - type_name[exprs[1]->expression.vtype]); + compile_error(ctx, "invalid types used in expression: cannot perform comparison between types %s and %s", + type_name[exprs[0]->expression.vtype], + type_name[exprs[1]->expression.vtype]); return false; } out = (ast_expression*)ast_binary_new(ctx, type_ne_instr[exprs[0]->expression.vtype], exprs[0], exprs[1]); break; case opid2('=', '='): if (exprs[0]->expression.vtype != exprs[1]->expression.vtype) { - parseerror(parser, "invalid types used in expression: cannot perform comparison between types %s and %s", - type_name[exprs[0]->expression.vtype], - type_name[exprs[1]->expression.vtype]); + compile_error(ctx, "invalid types used in expression: cannot perform comparison between types %s and %s", + type_name[exprs[0]->expression.vtype], + type_name[exprs[1]->expression.vtype]); return false; } out = (ast_expression*)ast_binary_new(ctx, type_eq_instr[exprs[0]->expression.vtype], exprs[0], exprs[1]); @@ -1097,11 +1123,11 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) field->expression.next->expression.vtype == TYPE_FUNCTION && exprs[1]->expression.vtype == TYPE_FUNCTION) { - (void)!parsewarning(parser, WARN_ASSIGN_FUNCTION_TYPES, - "invalid types in assignment: cannot assign %s to %s", ty2, ty1); + (void)!compile_warning(ctx, WARN_ASSIGN_FUNCTION_TYPES, + "invalid types in assignment: cannot assign %s to %s", ty2, ty1); } else - parseerror(parser, "invalid types in assignment: cannot assign %s to %s", ty2, ty1); + compile_error(ctx, "invalid types in assignment: cannot assign %s to %s", ty2, ty1); } } else @@ -1119,7 +1145,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) if (assignop == AINSTR_END) { ast_type_to_string(exprs[0], ty1, sizeof(ty1)); ast_type_to_string(exprs[1], ty2, sizeof(ty2)); - parseerror(parser, "invalid types in assignment: cannot assign %s to %s", ty2, ty1); + compile_error(ctx, "invalid types in assignment: cannot assign %s to %s", ty2, ty1); } else if (!ast_compare_type(exprs[0], exprs[1])) { @@ -1129,15 +1155,15 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) exprs[0]->expression.vtype == TYPE_FUNCTION && exprs[1]->expression.vtype == TYPE_FUNCTION) { - (void)!parsewarning(parser, WARN_ASSIGN_FUNCTION_TYPES, - "invalid types in assignment: cannot assign %s to %s", ty2, ty1); + (void)!compile_warning(ctx, WARN_ASSIGN_FUNCTION_TYPES, + "invalid types in assignment: cannot assign %s to %s", ty2, ty1); } else - parseerror(parser, "invalid types in assignment: cannot assign %s to %s", ty2, ty1); + compile_error(ctx, "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); + compile_error(ctx, "assignment to constant `%s`", asvalue[0]->name); } out = (ast_expression*)ast_store_new(ctx, assignop, exprs[0], exprs[1]); break; @@ -1146,7 +1172,7 @@ static bool parser_sy_apply_operator(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); + compile_error(ast_ctx(exprs[0]), "invalid type for prefix increment: %s", ty1); return false; } if (op->id == opid3('+','+','P')) @@ -1154,7 +1180,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) 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); + compile_error(ast_ctx(exprs[0]), "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, @@ -1171,7 +1197,7 @@ static bool parser_sy_apply_operator(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 suffix increment: %s", ty1); + compile_error(ast_ctx(exprs[0]), "invalid type for suffix increment: %s", ty1); return false; } if (op->id == opid3('S','+','+')) { @@ -1182,7 +1208,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) 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); + compile_error(ast_ctx(exprs[0]), "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, @@ -1206,12 +1232,12 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) { 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: cannot add or subtract type %s and %s", - ty1, ty2); + compile_error(ctx, "invalid types used in expression: cannot add or subtract type %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); + compile_error(ctx, "assignment to constant `%s`", asvalue[0]->name); } if (ast_istype(exprs[0], ast_entfield)) assignop = type_storep_instr[exprs[0]->expression.vtype]; @@ -1229,9 +1255,9 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) exprs[0], exprs[1]); 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]); + compile_error(ctx, "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; @@ -1243,12 +1269,12 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) { 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); + compile_error(ctx, "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); + compile_error(ctx, "assignment to constant `%s`", asvalue[0]->name); } if (ast_istype(exprs[0], ast_entfield)) assignop = type_storep_instr[exprs[0]->expression.vtype]; @@ -1266,19 +1292,25 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) 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) + if (CanConstFold1(exprs[1])) { + out = (ast_expression*)parser_const_float(parser, 1.0 / ConstF(1)); + } else { + out = (ast_expression*)ast_binary_new(ctx, INSTR_DIV_F, + (ast_expression*)parser_const_float_1(parser), + exprs[1]); + } + if (!out) { + compile_error(ctx, "internal error: failed to generate division"); 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]); + compile_error(ctx, "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; @@ -1287,12 +1319,12 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) 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); + compile_error(ctx, "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); + compile_error(ctx, "assignment to constant `%s`", asvalue[0]->name); } if (ast_istype(exprs[0], ast_entfield)) assignop = type_storep_instr[exprs[0]->expression.vtype]; @@ -1310,8 +1342,8 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) 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); + compile_error(ctx, "invalid types used in expression: %s and %s", + ty1, ty2); return false; } if (ast_istype(exprs[0], ast_entfield)) @@ -1322,7 +1354,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) 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); + compile_error(ctx, "assignment to constant `%s`", asvalue[0]->name); } asbinstore = ast_binstore_new(ctx, assignop, INSTR_SUB_F, exprs[0], out); asbinstore->keep_dest = true; @@ -1332,7 +1364,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) #undef NotSameType if (!out) { - parseerror(parser, "failed to apply operand %s", op->op); + compile_error(ctx, "failed to apply operand %s", op->op); return false; } @@ -1345,6 +1377,7 @@ static bool parser_close_call(parser_t *parser, shunt *sy) { /* was a function call */ ast_expression *fun; + ast_value *funval = NULL; ast_call *call; size_t fid; @@ -1414,6 +1447,20 @@ static bool parser_close_call(parser_t *parser, shunt *sy) return false; } + if (ast_istype(fun, ast_value)) { + funval = (ast_value*)fun; + if ((fun->expression.flags & AST_FLAG_VARIADIC) && + !(/*funval->cvq == CV_CONST && */ funval->hasvalue && funval->constval.vfunc->builtin)) + { + size_t va_count; + if (paramcount < vec_size(fun->expression.params)) + va_count = 0; + else + va_count = paramcount - vec_size(fun->expression.params); + call->va_count = (ast_expression*)parser_const_float(parser, (double)va_count); + } + } + /* overwrite fid, the function, with a call */ sy->out[fid] = syexp(call->expression.node.context, (ast_expression*)call); @@ -1484,16 +1531,21 @@ static bool parser_close_paren(parser_t *parser, shunt *sy, bool functions_only) } */ while (vec_size(sy->ops)) { - if (sy->ops[vec_size(sy->ops)-1].paren == SY_PAREN_FUNC) { + if (vec_last(sy->ops).paren == SY_PAREN_FUNC) { if (!parser_close_call(parser, sy)) return false; break; } - if (sy->ops[vec_size(sy->ops)-1].paren == SY_PAREN_EXPR) { + if (vec_last(sy->ops).paren == SY_PAREN_EXPR) { + if (!vec_size(sy->out)) { + compile_error(vec_last(sy->ops).ctx, "empty paren expression"); + vec_shrinkby(sy->ops, 1); + return false; + } vec_shrinkby(sy->ops, 1); return !functions_only; } - if (sy->ops[vec_size(sy->ops)-1].paren == SY_PAREN_INDEX) { + if (vec_last(sy->ops).paren == SY_PAREN_INDEX) { if (functions_only) return false; /* pop off the parenthesis */ @@ -1503,7 +1555,7 @@ static bool parser_close_paren(parser_t *parser, shunt *sy, bool functions_only) return false; return true; } - if (sy->ops[vec_size(sy->ops)-1].paren == SY_PAREN_TERNARY) { + if (vec_last(sy->ops).paren == SY_PAREN_TERNARY) { if (functions_only) return false; if (vec_last(parser->pot) != POT_TERNARY1) { @@ -1532,10 +1584,107 @@ static void parser_reclassify_token(parser_t *parser) } } +static ast_expression* parse_vararg_do(parser_t *parser) +{ + ast_expression *idx, *out; + ast_value *typevar; + ast_value *funtype = parser->function->vtype; + + lex_ctx ctx = parser_ctx(parser); + + if (!parser_next(parser) || parser->tok != '(') { + parseerror(parser, "expected parameter index and type in parenthesis"); + return NULL; + } + if (!parser_next(parser)) { + parseerror(parser, "error parsing parameter index"); + return NULL; + } + + idx = parse_expression_leave(parser, true, false, false); + if (!idx) + return NULL; + + if (parser->tok != ',') { + ast_unref(idx); + parseerror(parser, "expected comma after parameter index"); + return NULL; + } + + if (!parser_next(parser) || (parser->tok != TOKEN_IDENT && parser->tok != TOKEN_TYPENAME)) { + ast_unref(idx); + parseerror(parser, "expected typename for vararg"); + return NULL; + } + + typevar = parse_typename(parser, NULL, NULL); + if (!typevar) { + ast_unref(idx); + return NULL; + } + + if (parser->tok != ')') { + ast_unref(idx); + ast_delete(typevar); + parseerror(parser, "expected closing paren"); + return NULL; + } + +#if 0 + if (!parser_next(parser)) { + ast_unref(idx); + ast_delete(typevar); + parseerror(parser, "parse error after vararg"); + return NULL; + } +#endif + + if (!parser->function->varargs) { + ast_unref(idx); + ast_delete(typevar); + parseerror(parser, "function has no variable argument list"); + return NULL; + } + + if (funtype->expression.varparam && + !ast_compare_type((ast_expression*)typevar, (ast_expression*)funtype->expression.varparam)) + { + char ty1[1024]; + char ty2[1024]; + ast_type_to_string((ast_expression*)typevar, ty1, sizeof(ty1)); + ast_type_to_string((ast_expression*)funtype->expression.varparam, ty2, sizeof(ty2)); + compile_error(ast_ctx(typevar), + "function was declared to take varargs of type `%s`, requested type is: %s", + ty2, ty1); + } + + out = (ast_expression*)ast_array_index_new(ctx, (ast_expression*)(parser->function->varargs), idx); + ast_type_adopt(out, typevar); + ast_delete(typevar); + return out; +} + +static ast_expression* parse_vararg(parser_t *parser) +{ + bool old_noops = parser->lex->flags.noops; + enum parser_pot *old_pot = parser->pot; + + ast_expression *out; + + parser->pot = NULL; + parser->lex->flags.noops = true; + out = parse_vararg_do(parser); + + parser->pot = old_pot; + parser->lex->flags.noops = old_noops; + return out; +} + static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma, bool truthvalue, bool with_labels) { ast_expression *expr = NULL; shunt sy; + size_t i; bool wantop = 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 @@ -1590,6 +1739,24 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma goto onerr; } } + else if (parser->tok == TOKEN_DOTS) + { + ast_expression *va; + if (!OPTS_FLAG(VARIADIC_ARGS)) { + parseerror(parser, "cannot access varargs (try -fvariadic-args)"); + goto onerr; + } + if (wantop) { + parseerror(parser, "expected operator or end of statement"); + goto onerr; + } + wantop = true; + va = parse_vararg(parser); + if (!va) + goto onerr; + vec_push(sy.out, syexp(parser_ctx(parser), va)); + DEBUGSHUNTDO(con_out("push `...`\n")); + } else if (parser->tok == TOKEN_IDENT) { const char *ctoken = parser_tokval(parser); @@ -1657,7 +1824,7 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma * We should also consider adding correction tables for * other things as well. */ - if (OPTS_FLAG(ENHANCED_DIAGNOSTICS)) { + if (opts.correction) { correction_t corr; correct_init(&corr); @@ -1975,6 +2142,10 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma onerr: parser->lex->flags.noops = true; + for (i = 0; i < vec_size(sy.out); ++i) { + if (sy.out[i].out) + ast_unref(sy.out[i].out); + } vec_free(sy.out); vec_free(sy.ops); return NULL; @@ -3642,9 +3813,9 @@ static bool parse_function_body(parser_t *parser, ast_value *var) return false; } - if (var->expression.flags & AST_FLAG_VARIADIC) { + if (!OPTS_FLAG(VARIADIC_ARGS) && var->expression.flags & AST_FLAG_VARIADIC) { if (parsewarning(parser, WARN_VARIADIC_FUNCTION, - "variadic function with implementation will not be able to access additional parameters")) + "variadic function with implementation will not be able to access additional parameters (try -fvariadic-args)")) { return false; } @@ -3839,6 +4010,14 @@ static bool parse_function_body(parser_t *parser, ast_value *var) } } + func = ast_function_new(ast_ctx(var), var->name, var); + if (!func) { + parseerror(parser, "failed to allocate function for `%s`", var->name); + ast_block_delete(block); + goto enderr; + } + vec_push(parser->functions, func); + parser_enterblock(parser); for (parami = 0; parami < vec_size(var->expression.params); ++parami) { @@ -3855,7 +4034,7 @@ static bool parse_function_body(parser_t *parser, ast_value *var) if (!create_vector_members(param, me)) { ast_block_delete(block); - return false; + goto enderrfn; } for (e = 0; e < 3; ++e) { @@ -3864,13 +4043,32 @@ static bool parse_function_body(parser_t *parser, ast_value *var) } } - func = ast_function_new(ast_ctx(var), var->name, var); - if (!func) { - parseerror(parser, "failed to allocate function for `%s`", var->name); - ast_block_delete(block); - goto enderr; + if (var->argcounter) { + ast_value *argc = ast_value_new(ast_ctx(var), var->argcounter, TYPE_FLOAT); + parser_addlocal(parser, argc->name, (ast_expression*)argc); + func->argc = argc; + } + + if (OPTS_FLAG(VARIADIC_ARGS) && var->expression.flags & AST_FLAG_VARIADIC) { + char name[1024]; + ast_value *varargs = ast_value_new(ast_ctx(var), "reserved:va_args", TYPE_ARRAY); + varargs->expression.flags |= AST_FLAG_IS_VARARG; + varargs->expression.next = (ast_expression*)ast_value_new(ast_ctx(var), NULL, TYPE_VECTOR); + varargs->expression.count = 0; + snprintf(name, sizeof(name), "%s##va##SET", var->name); + if (!parser_create_array_setter_proto(parser, varargs, name)) { + ast_delete(varargs); + ast_block_delete(block); + goto enderrfn; + } + snprintf(name, sizeof(name), "%s##va##GET", var->name); + if (!parser_create_array_getter_proto(parser, varargs, varargs->expression.next, name)) { + ast_delete(varargs); + ast_block_delete(block); + goto enderrfn; + } + func->varargs = varargs; } - vec_push(parser->functions, func); parser->function = func; if (!parse_block_into(parser, block)) { @@ -3895,12 +4093,12 @@ static bool parse_function_body(parser_t *parser, ast_value *var) return retval; enderrfn: + (void)!parser_leaveblock(parser); vec_pop(parser->functions); ast_function_delete(func); var->constval.vfunc = NULL; enderr: - (void)!parser_leaveblock(parser); parser->function = old; return false; } @@ -4030,6 +4228,9 @@ static ast_expression *array_field_setter_node( if (!subscript) return NULL; + subscript->expression.next = ast_type_copy(ast_ctx(subscript), (ast_expression*)subscript); + subscript->expression.vtype = TYPE_FIELD; + entfield = ast_entfield_new_force(ctx, (ast_expression*)entity, (ast_expression*)subscript, @@ -4142,9 +4343,8 @@ static bool parser_create_array_accessor(parser_t *parser, ast_value *array, con return true; } -static bool parser_create_array_setter(parser_t *parser, ast_value *array, const char *funcname) +static ast_value* parser_create_array_setter_proto(parser_t *parser, ast_value *array, const char *funcname) { - ast_expression *root = NULL; ast_value *index = NULL; ast_value *value = NULL; ast_function *func; @@ -4152,11 +4352,11 @@ static bool parser_create_array_setter(parser_t *parser, ast_value *array, const if (!ast_istype(array->expression.next, ast_value)) { parseerror(parser, "internal error: array accessor needs to build an ast_value with a copy of the element type"); - return false; + return NULL; } if (!parser_create_array_accessor(parser, array, funcname, &fval)) - return false; + return NULL; func = fval->constval.vfunc; fval->expression.next = (ast_expression*)ast_value_new(ast_ctx(array), "", TYPE_VOID); @@ -4171,21 +4371,39 @@ static bool parser_create_array_setter(parser_t *parser, ast_value *array, const vec_push(fval->expression.params, index); vec_push(fval->expression.params, value); - root = array_setter_node(parser, array, index, value, 0, array->expression.count); - if (!root) { - parseerror(parser, "failed to build accessor search tree"); - goto cleanup; - } - array->setter = fval; - return ast_block_add_expr(func->blocks[0], root); + return fval; cleanup: if (index) ast_delete(index); if (value) ast_delete(value); - if (root) ast_delete(root); ast_delete(func); ast_delete(fval); - return false; + return NULL; +} + +static bool parser_create_array_setter_impl(parser_t *parser, ast_value *array) +{ + ast_expression *root = NULL; + root = array_setter_node(parser, array, + array->setter->expression.params[0], + array->setter->expression.params[1], + 0, array->expression.count); + if (!root) { + parseerror(parser, "failed to build accessor search tree"); + return false; + } + if (!ast_block_add_expr(array->setter->constval.vfunc->blocks[0], root)) { + ast_delete(root); + return false; + } + return true; +} + +static bool parser_create_array_setter(parser_t *parser, ast_value *array, const char *funcname) +{ + if (!parser_create_array_setter_proto(parser, array, funcname)) + return false; + return parser_create_array_setter_impl(parser, array); } static bool parser_create_array_field_setter(parser_t *parser, ast_value *array, const char *funcname) @@ -4237,9 +4455,8 @@ cleanup: return false; } -static bool parser_create_array_getter(parser_t *parser, ast_value *array, const ast_expression *elemtype, const char *funcname) +static ast_value* parser_create_array_getter_proto(parser_t *parser, ast_value *array, const ast_expression *elemtype, const char *funcname) { - ast_expression *root = NULL; ast_value *index = NULL; ast_value *fval; ast_function *func; @@ -4249,11 +4466,11 @@ static bool parser_create_array_getter(parser_t *parser, ast_value *array, const */ if (!ast_istype(array->expression.next, ast_value)) { parseerror(parser, "internal error: array accessor needs to build an ast_value with a copy of the element type"); - return false; + return NULL; } if (!parser_create_array_accessor(parser, array, funcname, &fval)) - return false; + return NULL; func = fval->constval.vfunc; fval->expression.next = ast_type_copy(ast_ctx(array), elemtype); @@ -4265,20 +4482,36 @@ static bool parser_create_array_getter(parser_t *parser, ast_value *array, const } vec_push(fval->expression.params, index); - root = array_getter_node(parser, array, index, 0, array->expression.count); - if (!root) { - parseerror(parser, "failed to build accessor search tree"); - goto cleanup; - } - array->getter = fval; - return ast_block_add_expr(func->blocks[0], root); + return fval; cleanup: if (index) ast_delete(index); - if (root) ast_delete(root); ast_delete(func); ast_delete(fval); - return false; + return NULL; +} + +static bool parser_create_array_getter_impl(parser_t *parser, ast_value *array) +{ + ast_expression *root = NULL; + + root = array_getter_node(parser, array, array->getter->expression.params[0], 0, array->expression.count); + if (!root) { + parseerror(parser, "failed to build accessor search tree"); + return false; + } + if (!ast_block_add_expr(array->getter->constval.vfunc->blocks[0], root)) { + ast_delete(root); + return false; + } + return true; +} + +static bool parser_create_array_getter(parser_t *parser, ast_value *array, const ast_expression *elemtype, const char *funcname) +{ + if (!parser_create_array_getter_proto(parser, array, elemtype, funcname)) + return false; + return parser_create_array_getter_impl(parser, array); } static ast_value *parse_typename(parser_t *parser, ast_value **storebase, ast_value *cached_typedef); @@ -4291,6 +4524,8 @@ static ast_value *parse_parameter_list(parser_t *parser, ast_value *var) ast_value *fval; bool first = true; bool variadic = false; + ast_value *varparam = NULL; + char *argcounter = NULL; ctx = parser_ctx(parser); @@ -4320,14 +4555,17 @@ static ast_value *parse_parameter_list(parser_t *parser, ast_value *var) if (parser->tok == TOKEN_DOTS) { /* '...' indicates a varargs function */ variadic = true; - if (!parser_next(parser)) { - parseerror(parser, "expected parameter"); - return NULL; - } - if (parser->tok != ')') { + if (!parser_next(parser) || (parser->tok != ')' && parser->tok != TOKEN_IDENT)) { parseerror(parser, "`...` must be the last parameter of a variadic function declaration"); goto on_error; } + if (parser->tok == TOKEN_IDENT) { + argcounter = util_strdup(parser_tokval(parser)); + if (!parser_next(parser) || parser->tok != ')') { + parseerror(parser, "`...` must be the last parameter of a variadic function declaration"); + goto on_error; + } + } } else { @@ -4342,6 +4580,23 @@ static ast_value *parse_parameter_list(parser_t *parser, ast_value *var) parseerror(parser, "type not supported as part of a parameter list: %s", tname); goto on_error; } + /* type-restricted varargs */ + if (parser->tok == TOKEN_DOTS) { + variadic = true; + varparam = vec_last(params); + vec_pop(params); + if (!parser_next(parser) || (parser->tok != ')' && parser->tok != TOKEN_IDENT)) { + parseerror(parser, "`...` must be the last parameter of a variadic function declaration"); + goto on_error; + } + if (parser->tok == TOKEN_IDENT) { + argcounter = util_strdup(parser_tokval(parser)); + if (!parser_next(parser) || parser->tok != ')') { + parseerror(parser, "`...` must be the last parameter of a variadic function declaration"); + goto on_error; + } + } + } } } @@ -4365,12 +4620,16 @@ static ast_value *parse_parameter_list(parser_t *parser, ast_value *var) fval->expression.flags |= AST_FLAG_VARIADIC; var = fval; - var->expression.params = params; + var->expression.params = params; + var->expression.varparam = (ast_expression*)varparam; + var->argcounter = argcounter; params = NULL; return var; on_error: + if (argcounter) + mem_d(argcounter); ast_delete(var); for (i = 0; i < vec_size(params); ++i) ast_delete(params[i]); @@ -4568,7 +4827,6 @@ static ast_value *parse_typename(parser_t *parser, ast_value **storebase, ast_va if (!var) { if (name) mem_d((void*)name); - ast_delete(var); return NULL; } } @@ -4792,7 +5050,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 || opts.standard == COMPILER_FTEQCC) && (old = parser_find_global(parser, var->name))) { parseerror(parser, "cannot declare a field and a global of the same name with -std=qcc"); @@ -5648,13 +5906,31 @@ 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; + /* Build function vararg accessor ast tree now before generating + * immediates, because the accessors may add new immediates + */ + for (i = 0; i < vec_size(parser->functions); ++i) { + ast_function *f = parser->functions[i]; + if (f->varargs) { + if (parser->max_param_count > vec_size(f->vtype->expression.params)) { + f->varargs->expression.count = parser->max_param_count - vec_size(f->vtype->expression.params); + if (!parser_create_array_setter_impl(parser, f->varargs)) { + con_out("failed to generate vararg setter for %s\n", f->name); + ir_builder_delete(ir); + return false; + } + if (!parser_create_array_getter_impl(parser, f->varargs)) { + con_out("failed to generate vararg getter for %s\n", f->name); + ir_builder_delete(ir); + return false; + } + } else { + ast_delete(f->varargs); + f->varargs = NULL; + } + } } + /* Now we can generate immediates */ 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); @@ -5710,9 +5986,17 @@ 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->functions); ++i) { - if (!ast_function_codegen(parser->functions[i], ir)) { - con_out("failed to generate function %s\n", parser->functions[i]->name); + ast_function *f = parser->functions[i]; + if (!ast_function_codegen(f, ir)) { + con_out("failed to generate function %s\n", f->name); ir_builder_delete(ir); return false; }