X-Git-Url: https://git.xonotic.org/?a=blobdiff_plain;f=parser.c;h=10ddbdcb606c4b96b54ff32733f420b2a26317ba;hb=0ba8455f6a972499ff71648ac65325be091bab33;hp=c8c6fb33beb067050b77ac6365d44d90c2a3830e;hpb=2b468cb0ee3d8c3d98190149004e26f941a639ea;p=xonotic%2Fgmqcc.git diff --git a/parser.c b/parser.c index c8c6fb3..10ddbdc 100644 --- a/parser.c +++ b/parser.c @@ -1,7 +1,8 @@ /* - * Copyright (C) 2012 + * Copyright (C) 2012, 2013 * Wolfgang Bumiller - * + * Dale Weiler + * * 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 @@ -25,11 +26,12 @@ #include "gmqcc.h" #include "lexer.h" +#include "ast.h" /* 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 }; @@ -51,6 +53,8 @@ typedef struct { ast_value *imm_float_zero; 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; @@ -60,8 +64,10 @@ typedef struct { /* All the labels the function defined... * Should they be in ast_function instead? */ - ast_label **labels; - ast_goto **gotos; + ast_label **labels; + ast_goto **gotos; + const char **breaks; + const char **continues; /* A list of hashtables for each scope */ ht *variables; @@ -69,6 +75,10 @@ typedef struct { ht htglobals; ht *typedefs; + /* same as above but for the spelling corrector */ + correct_trie_t **correct_variables; + size_t ***correct_variables_score; /* vector of vector of size_t* */ + /* not to be used directly, we use the hash table */ ast_expression **_locals; size_t *_blocklocals; @@ -76,49 +86,48 @@ typedef struct { size_t *_blocktypedefs; lex_ctx *_block_ctx; - size_t errors; - /* 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; + + /* collected information */ + 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); static void parser_addlocal(parser_t *parser, const char *name, ast_expression *e); +static void parser_addglobal(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, bool noreturn, bool is_static); +static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofields, int qualifier, ast_value *cached_typedef, bool noref, bool is_static, uint32_t qflags, char *vstring); 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); +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, ...) { va_list ap; - - parser->errors++; - va_start(ap, fmt); - con_vprintmsg(LVL_ERROR, parser->lex->tok.ctx.file, parser->lex->tok.ctx.line, "parse error", fmt, ap); + vcompile_error(parser->lex->tok.ctx, fmt, ap); va_end(ap); } @@ -204,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; @@ -300,6 +315,15 @@ static ast_expression* parser_find_field(parser_t *parser, const char *name) return ( ast_expression*)util_htget(parser->htfields, name); } +static ast_expression* parser_find_label(parser_t *parser, const char *name) +{ + size_t i; + for(i = 0; i < vec_size(parser->labels); i++) + if (!strcmp(parser->labels[i]->name, name)) + return (ast_expression*)parser->labels[i]; + return NULL; +} + static ast_expression* parser_find_global(parser_t *parser, const char *name) { return (ast_expression*)util_htget(parser->htglobals, name); @@ -524,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; } @@ -540,10 +564,21 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) exprs[i] = sy->out[vec_size(sy->out)+i].out; blocks[i] = sy->out[vec_size(sy->out)+i].block; asvalue[i] = (ast_value*)exprs[i]; + + if (exprs[i]->expression.vtype == TYPE_NOEXPR && + !(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"); + else + compile_error(ast_ctx(exprs[i]), "not an expression"); + (void)!compile_warning(ast_ctx(exprs[i]), WARN_DEBUG, "expression %u\n", (unsigned int)i); + } } 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; } @@ -561,23 +596,37 @@ 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('.'): - 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 { + 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, "internal error: vector access is not supposed to be handled at this point"); + 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; @@ -588,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]); @@ -652,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; @@ -694,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; @@ -704,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) { @@ -725,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; @@ -735,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) { @@ -754,22 +803,23 @@ 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; case opid1('*'): if (exprs[0]->expression.vtype != exprs[1]->expression.vtype && - exprs[0]->expression.vtype != TYPE_VECTOR && - exprs[0]->expression.vtype != TYPE_FLOAT && - exprs[1]->expression.vtype != TYPE_VECTOR && - exprs[1]->expression.vtype != TYPE_FLOAT) + !(exprs[0]->expression.vtype == TYPE_VECTOR && + exprs[1]->expression.vtype == TYPE_FLOAT) && + !(exprs[1]->expression.vtype == TYPE_VECTOR && + 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) { @@ -801,39 +851,124 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) { if (CanConstFold(exprs[0], exprs[1])) out = (ast_expression*)parser_const_float(parser, vec3_mulvv(ConstV(0), ConstV(1))); + else if (OPTS_OPTIMIZATION(OPTIM_VECTOR_COMPONENTS) && CanConstFold1(exprs[0])) { + vector vec = ConstV(0); + if (!vec.y && !vec.z) { /* 'n 0 0' * v */ + ++opts_optimizationcount[OPTIM_VECTOR_COMPONENTS]; + out = (ast_expression*)ast_member_new(ctx, exprs[1], 0, NULL); + out->expression.node.keep = false; + ((ast_member*)out)->rvalue = true; + if (vec.x != 1) + out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_F, (ast_expression*)parser_const_float(parser, vec.x), out); + } + else if (!vec.x && !vec.z) { /* '0 n 0' * v */ + ++opts_optimizationcount[OPTIM_VECTOR_COMPONENTS]; + out = (ast_expression*)ast_member_new(ctx, exprs[1], 1, NULL); + out->expression.node.keep = false; + ((ast_member*)out)->rvalue = true; + if (vec.y != 1) + out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_F, (ast_expression*)parser_const_float(parser, vec.y), out); + } + else if (!vec.x && !vec.y) { /* '0 n 0' * v */ + ++opts_optimizationcount[OPTIM_VECTOR_COMPONENTS]; + out = (ast_expression*)ast_member_new(ctx, exprs[1], 2, NULL); + out->expression.node.keep = false; + ((ast_member*)out)->rvalue = true; + if (vec.z != 1) + out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_F, (ast_expression*)parser_const_float(parser, vec.z), out); + } + else + out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_V, exprs[0], exprs[1]); + } + else if (OPTS_OPTIMIZATION(OPTIM_VECTOR_COMPONENTS) && CanConstFold1(exprs[1])) { + vector vec = ConstV(1); + if (!vec.y && !vec.z) { /* v * 'n 0 0' */ + ++opts_optimizationcount[OPTIM_VECTOR_COMPONENTS]; + out = (ast_expression*)ast_member_new(ctx, exprs[0], 0, NULL); + out->expression.node.keep = false; + ((ast_member*)out)->rvalue = true; + if (vec.x != 1) + out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_F, out, (ast_expression*)parser_const_float(parser, vec.x)); + } + else if (!vec.x && !vec.z) { /* v * '0 n 0' */ + ++opts_optimizationcount[OPTIM_VECTOR_COMPONENTS]; + out = (ast_expression*)ast_member_new(ctx, exprs[0], 1, NULL); + out->expression.node.keep = false; + ((ast_member*)out)->rvalue = true; + if (vec.y != 1) + out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_F, out, (ast_expression*)parser_const_float(parser, vec.y)); + } + else if (!vec.x && !vec.y) { /* v * '0 n 0' */ + ++opts_optimizationcount[OPTIM_VECTOR_COMPONENTS]; + out = (ast_expression*)ast_member_new(ctx, exprs[0], 2, NULL); + out->expression.node.keep = false; + ((ast_member*)out)->rvalue = true; + if (vec.z != 1) + out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_F, out, (ast_expression*)parser_const_float(parser, vec.z)); + } + else + out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_V, exprs[0], exprs[1]); + } else out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_V, exprs[0], exprs[1]); } 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])) @@ -846,30 +981,27 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) exprs[0], exprs[1]); break; case opid1('^'): - parseerror(parser, "TODO: bitxor"); + compile_error(ast_ctx(exprs[0]), "Not Yet Implemented: bit-xor via ^"); return false; case opid2('<','<'): case opid2('>','>'): + if (CanConstFold(exprs[0], exprs[1]) && ! NotSameType(TYPE_FLOAT)) { + if (op->id == opid2('<','<')) + out = (ast_expression*)parser_const_float(parser, (double)((int)(ConstF(0)) << (int)(ConstF(1)))); + else + out = (ast_expression*)parser_const_float(parser, (double)((int)(ConstF(0)) >> (int)(ConstF(1)))); + break; + } case opid3('<','<','='): case opid3('>','>','='): - parseerror(parser, "TODO: shifts"); + compile_error(ast_ctx(exprs[0]), "Not Yet Implemented: bit-shifts"); return false; case opid2('|','|'): 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)) { @@ -881,14 +1013,14 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) ( (generated_op == INSTR_OR) ? (immediate_is_true(ctx, asvalue[0]) || immediate_is_true(ctx, asvalue[1])) : (immediate_is_true(ctx, asvalue[0]) && immediate_is_true(ctx, asvalue[1])) ) - ? 0 : 1); + ? 1 : 0); } else { 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) { @@ -921,18 +1053,18 @@ 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 (exprs[1]->expression.vtype != exprs[2]->expression.vtype) { + 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])) - out = (ConstF(0) ? exprs[1] : exprs[2]); + out = (immediate_is_true(ctx, asvalue[0]) ? exprs[1] : exprs[2]); else out = (ast_expression*)ast_ternary_new(ctx, exprs[0], exprs[1], exprs[2]); break; @@ -946,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]); @@ -983,8 +1115,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) } else assignop = type_storep_instr[exprs[0]->expression.vtype]; - if (assignop == AINSTR_END || - !ast_compare_type(field->expression.next, exprs[1])) + if (assignop == AINSTR_END || !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)); @@ -992,14 +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) { - if (parsewarning(parser, WARN_ASSIGN_FUNCTION_TYPES, - "invalid types in assignment: cannot assign %s to %s", ty2, ty1)) - { - parser->errors++; - } + (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 @@ -1017,27 +1145,25 @@ 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])) { + 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_FLAG(ASSIGN_FUNCTION_TYPES) && exprs[0]->expression.vtype == TYPE_FUNCTION && exprs[1]->expression.vtype == TYPE_FUNCTION) { - if (parsewarning(parser, WARN_ASSIGN_FUNCTION_TYPES, - "invalid types in assignment: cannot assign %s to %s", ty2, ty1)) - { - parser->errors++; - } + (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; @@ -1046,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')) @@ -1054,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, @@ -1071,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','+','+')) { @@ -1082,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, @@ -1106,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]; @@ -1129,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; @@ -1143,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]; @@ -1166,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; @@ -1187,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]; @@ -1210,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)) @@ -1222,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; @@ -1232,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; } @@ -1245,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; @@ -1306,13 +1439,28 @@ static bool parser_close_call(parser_t *parser, shunt *sy) params->exprs = NULL; ast_delete(params); } - if (!ast_call_check_types(call)) - parser->errors++; + if (parser->max_param_count < paramcount) + parser->max_param_count = paramcount; + (void)!ast_call_check_types(call); } else { parseerror(parser, "invalid function call"); 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); @@ -1325,43 +1473,45 @@ static bool parser_close_call(parser_t *parser, shunt *sy) parseerror(parser, "could not determine function return type"); return false; } else { + ast_value *fval = (ast_istype(fun, ast_value) ? ((ast_value*)fun) : NULL); + + if (fun->expression.flags & AST_FLAG_DEPRECATED) { + if (!fval) { + return !parsewarning(parser, WARN_DEPRECATED, + "call to function (which is marked deprecated)\n", + "-> it has been declared here: %s:%i", + ast_ctx(fun).file, ast_ctx(fun).line); + } + if (!fval->desc) { + return !parsewarning(parser, WARN_DEPRECATED, + "call to `%s` (which is marked deprecated)\n" + "-> `%s` declared here: %s:%i", + fval->name, fval->name, ast_ctx(fun).file, ast_ctx(fun).line); + } + return !parsewarning(parser, WARN_DEPRECATED, + "call to `%s` (deprecated: %s)\n" + "-> `%s` declared here: %s:%i", + fval->name, fval->desc, fval->name, ast_ctx(fun).file, + ast_ctx(fun).line); + } + if (vec_size(fun->expression.params) != paramcount && !((fun->expression.flags & AST_FLAG_VARIADIC) && vec_size(fun->expression.params) < paramcount)) { - ast_value *fval; const char *fewmany = (vec_size(fun->expression.params) > paramcount) ? "few" : "many"; - - fval = (ast_istype(fun, ast_value) ? ((ast_value*)fun) : NULL); - if (opts.standard == COMPILER_GMQCC) - { - if (fval) - parseerror(parser, "too %s parameters for call to %s: expected %i, got %i\n" - " -> `%s` has been declared here: %s:%i", - fewmany, fval->name, (int)vec_size(fun->expression.params), (int)paramcount, - fval->name, ast_ctx(fun).file, (int)ast_ctx(fun).line); - else - parseerror(parser, "too %s parameters for function call: expected %i, got %i\n" - " -> it has been declared here: %s:%i", - fewmany, (int)vec_size(fun->expression.params), (int)paramcount, - ast_ctx(fun).file, (int)ast_ctx(fun).line); - return false; - } + if (fval) + return !parsewarning(parser, WARN_INVALID_PARAMETER_COUNT, + "too %s parameters for call to %s: expected %i, got %i\n" + " -> `%s` has been declared here: %s:%i", + fewmany, fval->name, (int)vec_size(fun->expression.params), (int)paramcount, + fval->name, ast_ctx(fun).file, (int)ast_ctx(fun).line); else - { - if (fval) - return !parsewarning(parser, WARN_TOO_FEW_PARAMETERS, - "too %s parameters for call to %s: expected %i, got %i\n" - " -> `%s` has been declared here: %s:%i", - fewmany, fval->name, (int)vec_size(fun->expression.params), (int)paramcount, - fval->name, ast_ctx(fun).file, (int)ast_ctx(fun).line); - else - return !parsewarning(parser, WARN_TOO_FEW_PARAMETERS, - "too %s parameters for function call: expected %i, got %i\n" - " -> it has been declared here: %s:%i", - fewmany, (int)vec_size(fun->expression.params), (int)paramcount, - ast_ctx(fun).file, (int)ast_ctx(fun).line); - } + return !parsewarning(parser, WARN_INVALID_PARAMETER_COUNT, + "too %s parameters for function call: expected %i, got %i\n" + " -> it has been declared here: %s:%i", + fewmany, (int)vec_size(fun->expression.params), (int)paramcount, + ast_ctx(fun).file, (int)ast_ctx(fun).line); } } @@ -1381,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 */ @@ -1400,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) { @@ -1429,12 +1584,112 @@ static void parser_reclassify_token(parser_t *parser) } } -static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma) +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; - 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 + */ + bool warn_truthvalue = true; /* count the parens because an if starts with one, so the * end of a condition is an unmatched closing paren @@ -1451,11 +1706,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), "_")) { @@ -1489,47 +1739,112 @@ 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); + 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) var = parser_find_field(parser, parser_tokval(parser)); } + if (!var && with_labels) { + var = (ast_expression*)parser_find_label(parser, parser_tokval(parser)); + if (!with_labels) { + ast_label *lbl = ast_label_new(parser_ctx(parser), parser_tokval(parser), true); + var = (ast_expression*)lbl; + vec_push(parser->labels, lbl); + } + } if (!var) { /* intrinsics */ if (!strcmp(parser_tokval(parser), "__builtin_debug_typestring")) { var = (ast_expression*)intrinsic_debug_typestring; - } else { + size_t i; + char *correct = NULL; + + /* + * sometimes people use preprocessing predefs without enabling them + * i've done this thousands of times already myself. Lets check for + * it in the predef table. And diagnose it better :) + */ + if (!OPTS_FLAG(FTEPP_PREDEFS)) { + for (i = 0; i < sizeof(ftepp_predefs)/sizeof(*ftepp_predefs); i++) { + if (!strcmp(ftepp_predefs[i].name, parser_tokval(parser))) { + parseerror(parser, "unexpected ident: %s (use -fftepp-predef to enable pre-defined macros)", parser_tokval(parser)); + goto onerr; + } + } + } + + /* + * TODO: determine the best score for the identifier: be it + * a variable, a field. + * + * We should also consider adding correction tables for + * other things as well. + */ + if (opts.correction) { + correction_t corr; + correct_init(&corr); + + for (i = 0; i < vec_size(parser->correct_variables); i++) { + correct = correct_str(&corr, parser->correct_variables[i], parser_tokval(parser)); + if (strcmp(correct, parser_tokval(parser))) { + break; + } else if (correct) { + mem_d(correct); + correct = NULL; + } + } + correct_free(&corr); + + if (correct) { + parseerror(parser, "unexpected ident: %s (did you mean %s?)", parser_tokval(parser), correct); + mem_d(correct); + goto onerr; + } + } parseerror(parser, "unexpected ident: %s", parser_tokval(parser)); goto onerr; } @@ -1675,7 +1990,7 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma const oper_info *olast = NULL; size_t o; for (o = 0; o < operator_count; ++o) { - if ((!(operators[o].flags & OP_PREFIX) == wantop) && + if (((!(operators[o].flags & OP_PREFIX) == !!wantop)) && /* !(operators[o].flags & OP_SUFFIX) && / * remove this */ !strcmp(parser_tokval(parser), operators[o].op)) { @@ -1711,6 +2026,28 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma if (vec_size(sy.ops) && !vec_last(sy.ops).paren) olast = &operators[vec_last(sy.ops).etype-1]; +#define IsAssignOp(x) (\ + (x) == opid1('=') || \ + (x) == opid2('+','=') || \ + (x) == opid2('-','=') || \ + (x) == opid2('*','=') || \ + (x) == opid2('/','=') || \ + (x) == opid2('%','=') || \ + (x) == opid2('&','=') || \ + (x) == opid2('|','=') || \ + (x) == opid3('&','~','=') \ + ) + if (warn_truthvalue) { + if ( (olast && IsAssignOp(olast->id) && (op->id == opid2('&','&') || op->id == opid2('|','|'))) || + (olast && IsAssignOp(op->id) && (olast->id == opid2('&','&') || olast->id == opid2('|','|'))) || + (truthvalue && !vec_size(parser->pot) && IsAssignOp(op->id)) + ) + { + (void)!parsewarning(parser, WARN_PARENTHESIS, "suggesting parenthesis around assignment used as truth value"); + warn_truthvalue = false; + } + } + while (olast && ( (op->prec < olast->prec) || (op->assoc == ASSOC_LEFT && op->prec <= olast->prec) ) ) @@ -1723,24 +2060,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); @@ -1794,7 +2113,7 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma goto onerr; } if (parser->tok == ';' || - (!parens && parser->tok == ']')) + (!parens && (parser->tok == ']' || parser->tok == ')' || parser->tok == '}'))) { break; } @@ -1823,18 +2142,27 @@ 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; } -static ast_expression* parse_expression(parser_t *parser, bool stopatcomma) +static ast_expression* parse_expression(parser_t *parser, bool stopatcomma, bool with_labels) { - ast_expression *e = parse_expression_leave(parser, stopatcomma); + ast_expression *e = parse_expression_leave(parser, stopatcomma, false, with_labels); if (!e) return NULL; + if (parser->tok != ';') { + parseerror(parser, "semicolon expected after expression"); + ast_unref(e); + return NULL; + } if (!parser_next(parser)) { - ast_delete(e); + ast_unref(e); return NULL; } return e; @@ -1847,6 +2175,10 @@ static void parser_enterblock(parser_t *parser) 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)); + + /* corrector */ + vec_push(parser->correct_variables, correct_trie_new()); + vec_push(parser->correct_variables_score, NULL); } static bool parser_leaveblock(parser_t *parser) @@ -1860,7 +2192,11 @@ static bool parser_leaveblock(parser_t *parser) } util_htdel(vec_last(parser->variables)); + correct_del(vec_last(parser->correct_variables), vec_last(parser->correct_variables_score)); + vec_pop(parser->variables); + vec_pop(parser->correct_variables); + vec_pop(parser->correct_variables_score); if (!vec_size(parser->_blocklocals)) { parseerror(parser, "internal error: parser_leaveblock with no block (2)"); return false; @@ -1873,10 +2209,8 @@ static bool parser_leaveblock(parser_t *parser) ast_value *v = (ast_value*)e; vec_pop(parser->_locals); if (ast_istype(e, ast_value) && !v->uses) { - if (compile_warning(ast_ctx(v), WARN_UNUSED_VARIABLE, "unused variable: `%s`", v->name)) { - parser->errors++; + if (compile_warning(ast_ctx(v), WARN_UNUSED_VARIABLE, "unused variable: `%s`", v->name)) rv = false; - } } } @@ -1889,6 +2223,7 @@ static bool parser_leaveblock(parser_t *parser) vec_pop(parser->typedefs); vec_pop(parser->_block_ctx); + return rv; } @@ -1896,6 +2231,26 @@ static void parser_addlocal(parser_t *parser, const char *name, ast_expression * { vec_push(parser->_locals, e); util_htset(vec_last(parser->variables), name, (void*)e); + + /* corrector */ + correct_add ( + vec_last(parser->correct_variables), + &vec_last(parser->correct_variables_score), + name + ); +} + +static void parser_addglobal(parser_t *parser, const char *name, ast_expression *e) +{ + vec_push(parser->globals, e); + util_htset(parser->htglobals, name, e); + + /* corrector */ + correct_add ( + parser->correct_variables[0], + &parser->correct_variables_score[0], + name + ); } static ast_expression* process_condition(parser_t *parser, ast_expression *cond, bool *_ifnot) @@ -1982,7 +2337,7 @@ static bool parse_if(parser_t *parser, ast_block *block, ast_expression **out) return false; } /* parse the condition */ - cond = parse_expression_leave(parser, false); + cond = parse_expression_leave(parser, false, true, false); if (!cond) return false; /* closing paren */ @@ -2001,6 +2356,8 @@ static bool parse_if(parser_t *parser, ast_block *block, ast_expression **out) ast_delete(cond); return false; } + if (!ontrue) + ontrue = (ast_expression*)ast_block_new(parser_ctx(parser)); /* check for an else */ if (!strcmp(parser_tokval(parser), "else")) { /* parse into the 'else' branch */ @@ -2032,7 +2389,61 @@ static bool parse_if(parser_t *parser, ast_block *block, ast_expression **out) return true; } +static bool parse_while_go(parser_t *parser, ast_block *block, ast_expression **out); static bool parse_while(parser_t *parser, ast_block *block, ast_expression **out) +{ + bool rv; + char *label = NULL; + + /* skip the 'while' and get the body */ + if (!parser_next(parser)) { + if (OPTS_FLAG(LOOP_LABELS)) + parseerror(parser, "expected loop label or 'while' condition in parenthesis"); + else + parseerror(parser, "expected 'while' condition in parenthesis"); + return false; + } + + if (parser->tok == ':') { + if (!OPTS_FLAG(LOOP_LABELS)) + parseerror(parser, "labeled loops not activated, try using -floop-labels"); + if (!parser_next(parser) || parser->tok != TOKEN_IDENT) { + parseerror(parser, "expected loop label"); + return false; + } + label = util_strdup(parser_tokval(parser)); + if (!parser_next(parser)) { + mem_d(label); + parseerror(parser, "expected 'while' condition in parenthesis"); + return false; + } + } + + if (parser->tok != '(') { + parseerror(parser, "expected 'while' condition in parenthesis"); + return false; + } + + vec_push(parser->breaks, label); + vec_push(parser->continues, label); + + rv = parse_while_go(parser, block, out); + if (label) + mem_d(label); + if (vec_last(parser->breaks) != label || vec_last(parser->continues) != label) { + parseerror(parser, "internal error: label stack corrupted"); + rv = false; + ast_delete(*out); + *out = NULL; + } + else { + vec_pop(parser->breaks); + vec_pop(parser->continues); + } + return rv; +} + +static bool parse_while_go(parser_t *parser, ast_block *block, ast_expression **out) { ast_loop *aloop; ast_expression *cond, *ontrue; @@ -2043,18 +2454,13 @@ static bool parse_while(parser_t *parser, ast_block *block, ast_expression **out (void)block; /* not touching */ - /* skip the 'while' and check for opening paren */ - if (!parser_next(parser) || parser->tok != '(') { - parseerror(parser, "expected 'while' condition in parenthesis"); - return false; - } /* parse into the expression */ if (!parser_next(parser)) { parseerror(parser, "expected 'while' condition after opening paren"); return false; } /* parse the condition */ - cond = parse_expression_leave(parser, false); + cond = parse_expression_leave(parser, false, true, false); if (!cond) return false; /* closing paren */ @@ -2084,7 +2490,56 @@ static bool parse_while(parser_t *parser, ast_block *block, ast_expression **out return true; } +static bool parse_dowhile_go(parser_t *parser, ast_block *block, ast_expression **out); static bool parse_dowhile(parser_t *parser, ast_block *block, ast_expression **out) +{ + bool rv; + char *label = NULL; + + /* skip the 'do' and get the body */ + if (!parser_next(parser)) { + if (OPTS_FLAG(LOOP_LABELS)) + parseerror(parser, "expected loop label or body"); + else + parseerror(parser, "expected loop body"); + return false; + } + + if (parser->tok == ':') { + if (!OPTS_FLAG(LOOP_LABELS)) + parseerror(parser, "labeled loops not activated, try using -floop-labels"); + if (!parser_next(parser) || parser->tok != TOKEN_IDENT) { + parseerror(parser, "expected loop label"); + return false; + } + label = util_strdup(parser_tokval(parser)); + if (!parser_next(parser)) { + mem_d(label); + parseerror(parser, "expected loop body"); + return false; + } + } + + vec_push(parser->breaks, label); + vec_push(parser->continues, label); + + rv = parse_dowhile_go(parser, block, out); + if (label) + mem_d(label); + if (vec_last(parser->breaks) != label || vec_last(parser->continues) != label) { + parseerror(parser, "internal error: label stack corrupted"); + rv = false; + ast_delete(*out); + *out = NULL; + } + else { + vec_pop(parser->breaks); + vec_pop(parser->continues); + } + return rv; +} + +static bool parse_dowhile_go(parser_t *parser, ast_block *block, ast_expression **out) { ast_loop *aloop; ast_expression *cond, *ontrue; @@ -2095,11 +2550,6 @@ static bool parse_dowhile(parser_t *parser, ast_block *block, ast_expression **o (void)block; /* not touching */ - /* skip the 'do' and get the body */ - if (!parser_next(parser)) { - parseerror(parser, "expected loop body"); - return false; - } if (!parse_statement_or_block(parser, &ontrue)) return false; @@ -2125,7 +2575,7 @@ static bool parse_dowhile(parser_t *parser, ast_block *block, ast_expression **o return false; } /* parse the condition */ - cond = parse_expression_leave(parser, false); + cond = parse_expression_leave(parser, false, true, false); if (!cond) return false; /* closing paren */ @@ -2160,7 +2610,60 @@ static bool parse_dowhile(parser_t *parser, ast_block *block, ast_expression **o return true; } +static bool parse_for_go(parser_t *parser, ast_block *block, ast_expression **out); static bool parse_for(parser_t *parser, ast_block *block, ast_expression **out) +{ + bool rv; + char *label = NULL; + + /* skip the 'for' and check for opening paren */ + if (!parser_next(parser)) { + if (OPTS_FLAG(LOOP_LABELS)) + parseerror(parser, "expected loop label or 'for' expressions in parenthesis"); + else + parseerror(parser, "expected 'for' expressions in parenthesis"); + return false; + } + + if (parser->tok == ':') { + if (!OPTS_FLAG(LOOP_LABELS)) + parseerror(parser, "labeled loops not activated, try using -floop-labels"); + if (!parser_next(parser) || parser->tok != TOKEN_IDENT) { + parseerror(parser, "expected loop label"); + return false; + } + label = util_strdup(parser_tokval(parser)); + if (!parser_next(parser)) { + mem_d(label); + parseerror(parser, "expected 'for' expressions in parenthesis"); + return false; + } + } + + if (parser->tok != '(') { + parseerror(parser, "expected 'for' expressions in parenthesis"); + return false; + } + + vec_push(parser->breaks, label); + vec_push(parser->continues, label); + + rv = parse_for_go(parser, block, out); + if (label) + mem_d(label); + if (vec_last(parser->breaks) != label || vec_last(parser->continues) != label) { + parseerror(parser, "internal error: label stack corrupted"); + rv = false; + ast_delete(*out); + *out = NULL; + } + else { + vec_pop(parser->breaks); + vec_pop(parser->continues); + } + return rv; +} +static bool parse_for_go(parser_t *parser, ast_block *block, ast_expression **out) { ast_loop *aloop; ast_expression *initexpr, *cond, *increment, *ontrue; @@ -2178,11 +2681,6 @@ static bool parse_for(parser_t *parser, ast_block *block, ast_expression **out) increment = NULL; ontrue = NULL; - /* skip the 'while' and check for opening paren */ - if (!parser_next(parser) || parser->tok != '(') { - parseerror(parser, "expected 'for' expressions in parenthesis"); - goto onerr; - } /* parse into the expression */ if (!parser_next(parser)) { parseerror(parser, "expected 'for' initializer after opening paren"); @@ -2194,17 +2692,19 @@ static bool parse_for(parser_t *parser, ast_block *block, ast_expression **out) typevar = parser_find_typedef(parser, parser_tokval(parser), 0); if (typevar || parser->tok == TOKEN_TYPENAME) { +#if 0 if (opts.standard != COMPILER_GMQCC) { if (parsewarning(parser, WARN_EXTENSIONS, "current standard does not allow variable declarations in for-loop initializers")) goto onerr; } - if (!parse_variable(parser, block, true, CV_VAR, typevar, false, false, false)) +#endif + if (!parse_variable(parser, block, true, CV_VAR, typevar, false, false, 0, NULL)) goto onerr; } else if (parser->tok != ';') { - initexpr = parse_expression_leave(parser, false); + initexpr = parse_expression_leave(parser, false, false, false); if (!initexpr) goto onerr; } @@ -2221,7 +2721,7 @@ static bool parse_for(parser_t *parser, ast_block *block, ast_expression **out) /* parse the condition */ if (parser->tok != ';') { - cond = parse_expression_leave(parser, false); + cond = parse_expression_leave(parser, false, true, false); if (!cond) goto onerr; } @@ -2238,7 +2738,7 @@ static bool parse_for(parser_t *parser, ast_block *block, ast_expression **out) /* parse the incrementor */ if (parser->tok != ')') { - increment = parse_expression_leave(parser, false); + increment = parse_expression_leave(parser, false, false, false); if (!increment) goto onerr; if (!ast_side_effects(increment)) { @@ -2295,11 +2795,13 @@ static bool parse_return(parser_t *parser, ast_block *block, ast_expression **ou } if (parser->tok != ';') { - exp = parse_expression(parser, false); + exp = parse_expression(parser, false, false); if (!exp) return false; - if (exp->expression.vtype != expected->expression.next->expression.vtype) { + if (exp->expression.vtype != TYPE_NIL && + exp->expression.vtype != expected->expression.next->expression.vtype) + { parseerror(parser, "return with invalid expression"); } @@ -2312,10 +2814,7 @@ static bool parse_return(parser_t *parser, ast_block *block, ast_expression **ou if (!parser_next(parser)) parseerror(parser, "parse error"); if (expected->expression.next->expression.vtype != TYPE_VOID) { - if (opts.standard != COMPILER_GMQCC) - (void)!parsewarning(parser, WARN_MISSING_RETURN_VALUES, "return without value"); - else - parseerror(parser, "return without value"); + (void)!parsewarning(parser, WARN_MISSING_RETURN_VALUES, "return without value"); } ret = ast_return_new(ctx, NULL); } @@ -2325,11 +2824,46 @@ static bool parse_return(parser_t *parser, ast_block *block, ast_expression **ou static bool parse_break_continue(parser_t *parser, ast_block *block, ast_expression **out, bool is_continue) { - lex_ctx ctx = parser_ctx(parser); + size_t i; + unsigned int levels = 0; + lex_ctx ctx = parser_ctx(parser); + const char **loops = (is_continue ? parser->continues : parser->breaks); (void)block; /* not touching */ + if (!parser_next(parser)) { + parseerror(parser, "expected semicolon or loop label"); + return false; + } - if (!parser_next(parser) || parser->tok != ';') { + if (!vec_size(loops)) { + if (is_continue) + parseerror(parser, "`continue` can only be used inside loops"); + else + parseerror(parser, "`break` can only be used inside loops or switches"); + } + + if (parser->tok == TOKEN_IDENT) { + if (!OPTS_FLAG(LOOP_LABELS)) + parseerror(parser, "labeled loops not activated, try using -floop-labels"); + i = vec_size(loops); + while (i--) { + if (loops[i] && !strcmp(loops[i], parser_tokval(parser))) + break; + if (!i) { + parseerror(parser, "no such loop to %s: `%s`", + (is_continue ? "continue" : "break out of"), + parser_tokval(parser)); + return false; + } + ++levels; + } + if (!parser_next(parser)) { + parseerror(parser, "expected semicolon"); + return false; + } + } + + if (parser->tok != ';') { parseerror(parser, "expected semicolon"); return false; } @@ -2337,21 +2871,21 @@ static bool parse_break_continue(parser_t *parser, ast_block *block, ast_express if (!parser_next(parser)) parseerror(parser, "parse error"); - *out = (ast_expression*)ast_breakcont_new(ctx, is_continue); + *out = (ast_expression*)ast_breakcont_new(ctx, is_continue, levels); 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 *noreturn, bool *is_static) +static bool parse_qualifiers(parser_t *parser, bool with_local, int *cvq, bool *noref, bool *is_static, uint32_t *_flags, char **message) { bool had_const = false; bool had_var = false; bool had_noref = false; - bool had_noreturn = false; bool had_attrib = false; bool had_static = false; + uint32_t flags = 0; *cvq = CV_NONE; for (;;) { @@ -2364,7 +2898,7 @@ static bool parse_var_qualifiers(parser_t *parser, bool with_local, int *cvq, bo return false; } if (!strcmp(parser_tokval(parser), "noreturn")) { - had_noreturn = true; + flags |= AST_FLAG_NORETURN; if (!parser_next(parser) || parser->tok != TOKEN_ATTRIBUTE_CLOSE) { parseerror(parser, "`noreturn` attribute has no parameters, expected `]]`"); *cvq = CV_WRONG; @@ -2379,6 +2913,59 @@ static bool parse_var_qualifiers(parser_t *parser, bool with_local, int *cvq, bo return false; } } + else if (!strcmp(parser_tokval(parser), "inline")) { + flags |= AST_FLAG_INLINE; + if (!parser_next(parser) || parser->tok != TOKEN_ATTRIBUTE_CLOSE) { + parseerror(parser, "`noref` attribute has no parameters, expected `]]`"); + *cvq = CV_WRONG; + return false; + } + } + + + else if (!strcmp(parser_tokval(parser), "deprecated") && !(flags & AST_FLAG_DEPRECATED)) { + flags |= AST_FLAG_DEPRECATED; + *message = NULL; + + if (!parser_next(parser)) { + parseerror(parser, "parse error in attribute"); + goto argerr; + } + + if (parser->tok == '(') { + if (!parser_next(parser) || parser->tok != TOKEN_STRINGCONST) { + parseerror(parser, "`deprecated` attribute missing parameter"); + goto argerr; + } + + *message = util_strdup(parser_tokval(parser)); + + if (!parser_next(parser)) { + parseerror(parser, "parse error in attribute"); + goto argerr; + } + + if(parser->tok != ')') { + parseerror(parser, "`deprecated` attribute expected `)` after parameter"); + goto argerr; + } + + if (!parser_next(parser)) { + parseerror(parser, "parse error in attribute"); + goto argerr; + } + } + /* no message */ + if (parser->tok != TOKEN_ATTRIBUTE_CLOSE) { + parseerror(parser, "`deprecated` attribute expected `]]`"); + + argerr: /* ugly */ + if (*message) mem_d(*message); + *message = NULL; + *cvq = CV_WRONG; + return false; + } + } else { /* Skip tokens until we hit a ]] */ @@ -2392,7 +2979,7 @@ static bool parse_var_qualifiers(parser_t *parser, bool with_local, int *cvq, bo } } } - else if (!strcmp(parser_tokval(parser), "static")) + else if (with_local && !strcmp(parser_tokval(parser), "static")) had_static = true; else if (!strcmp(parser_tokval(parser), "const")) had_const = true; @@ -2402,7 +2989,7 @@ static bool parse_var_qualifiers(parser_t *parser, bool with_local, int *cvq, bo had_var = true; else if (!strcmp(parser_tokval(parser), "noref")) had_noref = true; - else if (!had_const && !had_var && !had_noref && !had_noreturn && !had_attrib && !had_static) { + else if (!had_const && !had_var && !had_noref && !had_attrib && !had_static && !flags) { return false; } else @@ -2417,8 +3004,8 @@ static bool parse_var_qualifiers(parser_t *parser, bool with_local, int *cvq, bo else *cvq = CV_NONE; *noref = had_noref; - *noreturn = had_noreturn; *is_static = had_static; + *_flags = flags; return true; onerr: parseerror(parser, "parse error after variable qualifier"); @@ -2426,7 +3013,59 @@ onerr: return true; } +static bool parse_switch_go(parser_t *parser, ast_block *block, ast_expression **out); static bool parse_switch(parser_t *parser, ast_block *block, ast_expression **out) +{ + bool rv; + char *label = NULL; + + /* skip the 'while' and get the body */ + if (!parser_next(parser)) { + if (OPTS_FLAG(LOOP_LABELS)) + parseerror(parser, "expected loop label or 'switch' operand in parenthesis"); + else + parseerror(parser, "expected 'switch' operand in parenthesis"); + return false; + } + + if (parser->tok == ':') { + if (!OPTS_FLAG(LOOP_LABELS)) + parseerror(parser, "labeled loops not activated, try using -floop-labels"); + if (!parser_next(parser) || parser->tok != TOKEN_IDENT) { + parseerror(parser, "expected loop label"); + return false; + } + label = util_strdup(parser_tokval(parser)); + if (!parser_next(parser)) { + mem_d(label); + parseerror(parser, "expected 'switch' operand in parenthesis"); + return false; + } + } + + if (parser->tok != '(') { + parseerror(parser, "expected 'switch' operand in parenthesis"); + return false; + } + + vec_push(parser->breaks, label); + + rv = parse_switch_go(parser, block, out); + if (label) + mem_d(label); + if (vec_last(parser->breaks) != label) { + parseerror(parser, "internal error: label stack corrupted"); + rv = false; + ast_delete(*out); + *out = NULL; + } + else { + vec_pop(parser->breaks); + } + return rv; +} + +static bool parse_switch_go(parser_t *parser, ast_block *block, ast_expression **out) { ast_expression *operand; ast_value *opval; @@ -2435,26 +3074,21 @@ static bool parse_switch(parser_t *parser, ast_block *block, ast_expression **ou ast_switch_case swcase; int cvq; - bool noref, noreturn, is_static; + bool noref, is_static; + uint32_t qflags = 0; lex_ctx ctx = parser_ctx(parser); (void)block; /* not touching */ (void)opval; - /* parse over the opening paren */ - if (!parser_next(parser) || parser->tok != '(') { - parseerror(parser, "expected switch operand in parenthesis"); - return false; - } - /* parse into the expression */ if (!parser_next(parser)) { parseerror(parser, "expected switch operand"); return false; } /* parse the operand */ - operand = parse_expression_leave(parser, false); + operand = parse_expression_leave(parser, false, false, false); if (!operand) return false; @@ -2487,19 +3121,19 @@ static bool parse_switch(parser_t *parser, ast_block *block, ast_expression **ou 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, false, false)) { + if (!parse_variable(parser, block, false, CV_NONE, typevar, false, false, 0, NULL)) { ast_delete(switchnode); return false; } continue; } - if (parse_var_qualifiers(parser, true, &cvq, &noref, &noreturn, &is_static)) + if (parse_qualifiers(parser, true, &cvq, &noref, &is_static, &qflags, NULL)) { if (cvq == CV_WRONG) { ast_delete(switchnode); return false; } - if (!parse_variable(parser, block, false, cvq, NULL, noref, noreturn, is_static)) { + if (!parse_variable(parser, block, false, cvq, NULL, noref, is_static, qflags, NULL)) { ast_delete(switchnode); return false; } @@ -2512,18 +3146,13 @@ static bool parse_switch(parser_t *parser, ast_block *block, ast_expression **ou while (parser->tok != '}') { ast_block *caseblock; - if (parser->tok != TOKEN_KEYWORD) { - ast_delete(switchnode); - parseerror(parser, "expected 'case' or 'default'"); - return false; - } if (!strcmp(parser_tokval(parser), "case")) { if (!parser_next(parser)) { ast_delete(switchnode); parseerror(parser, "expected expression for case"); return false; } - swcase.value = parse_expression_leave(parser, false); + swcase.value = parse_expression_leave(parser, false, false, false); if (!swcase.value) { ast_delete(switchnode); parseerror(parser, "expected expression for case"); @@ -2545,6 +3174,11 @@ static bool parse_switch(parser_t *parser, ast_block *block, ast_expression **ou return false; } } + else { + ast_delete(switchnode); + parseerror(parser, "expected 'case' or 'default'"); + return false; + } /* Now the colon and body */ if (parser->tok != ':') { @@ -2609,25 +3243,81 @@ static bool parse_switch(parser_t *parser, ast_block *block, ast_expression **ou return true; } +/* parse computed goto sides */ +static ast_expression *parse_goto_computed(parser_t *parser, ast_expression **side) { + ast_expression *on_true; + ast_expression *on_false; + ast_expression *cond; + + if (!*side) + return NULL; + + if (ast_istype(*side, ast_ternary)) { + ast_ternary *tern = (ast_ternary*)*side; + on_true = parse_goto_computed(parser, &tern->on_true); + on_false = parse_goto_computed(parser, &tern->on_false); + + if (!on_true || !on_false) { + parseerror(parser, "expected label or expression in ternary"); + if (on_true) ast_unref(on_true); + if (on_false) ast_unref(on_false); + return NULL; + } + + cond = tern->cond; + tern->cond = NULL; + ast_delete(tern); + *side = NULL; + return (ast_expression*)ast_ifthen_new(parser_ctx(parser), cond, on_true, on_false); + } else if (ast_istype(*side, ast_label)) { + ast_goto *gt = ast_goto_new(parser_ctx(parser), ((ast_label*)*side)->name); + ast_goto_set_label(gt, ((ast_label*)*side)); + *side = NULL; + return (ast_expression*)gt; + } + return NULL; +} + static bool parse_goto(parser_t *parser, ast_expression **out) { - size_t i; - ast_goto *gt; + ast_goto *gt = NULL; + ast_expression *lbl; - if (!parser_next(parser) || parser->tok != TOKEN_IDENT) { - parseerror(parser, "expected label name after `goto`"); + if (!parser_next(parser)) return false; + + if (parser->tok != TOKEN_IDENT) { + ast_expression *expression; + + /* could be an expression i.e computed goto :-) */ + if (parser->tok != '(') { + parseerror(parser, "expected label name after `goto`"); + return false; + } + + /* failed to parse expression for goto */ + if (!(expression = parse_expression(parser, false, true)) || + !(*out = parse_goto_computed(parser, &expression))) { + parseerror(parser, "invalid goto expression"); + ast_unref(expression); + return false; + } + + return true; } + /* not computed goto */ 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; + lbl = parser_find_label(parser, gt->name); + if (lbl) { + if (!ast_istype(lbl, ast_label)) { + parseerror(parser, "internal error: label is not an ast_label"); + ast_delete(gt); + return false; } + ast_goto_set_label(gt, (ast_label*)lbl); } - if (i == vec_size(parser->labels)) + else vec_push(parser->gotos, gt); if (!parser_next(parser) || parser->tok != ';') { @@ -2714,9 +3404,11 @@ static bool parse_pragma(parser_t *parser) static bool parse_statement(parser_t *parser, ast_block *block, ast_expression **out, bool allow_cases) { - bool noref, noreturn, is_static; - int cvq = CV_NONE; + bool noref, is_static; + int cvq = CV_NONE; + uint32_t qflags = 0; ast_value *typevar = NULL; + char *vstring = NULL; *out = NULL; @@ -2734,15 +3426,15 @@ 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, CV_NONE, typevar, false, false, false)) + if (!parse_variable(parser, block, false, CV_NONE, typevar, false, false, 0, NULL)) return false; return true; } - else if (parse_var_qualifiers(parser, !!block, &cvq, &noref, &noreturn, &is_static)) + else if (parse_qualifiers(parser, !!block, &cvq, &noref, &is_static, &qflags, &vstring)) { if (cvq == CV_WRONG) return false; - return parse_variable(parser, block, true, cvq, NULL, noref, noreturn, is_static); + return parse_variable(parser, block, true, cvq, NULL, noref, is_static, qflags, vstring); } else if (parser->tok == TOKEN_KEYWORD) { @@ -2860,10 +3552,18 @@ static bool parse_statement(parser_t *parser, ast_block *block, ast_expression * 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); + label = (ast_label*)parser_find_label(parser, parser_tokval(parser)); + if (label) { + if (!label->undefined) { + parseerror(parser, "label `%s` already defined", label->name); + return false; + } + label->undefined = false; + } + else { + label = ast_label_new(parser_ctx(parser), parser_tokval(parser), false); + vec_push(parser->labels, label); + } *out = (ast_expression*)label; if (!parser_next(parser)) { parseerror(parser, "parse error after label"); @@ -2888,7 +3588,7 @@ static bool parse_statement(parser_t *parser, ast_block *block, ast_expression * } else { - ast_expression *exp = parse_expression(parser, false); + ast_expression *exp = parse_expression(parser, false, false); if (!exp) return false; *out = exp; @@ -2896,8 +3596,108 @@ static bool parse_statement(parser_t *parser, ast_block *block, ast_expression * if (genwarning(ast_ctx(exp), WARN_EFFECTLESS_STATEMENT, "statement has no effect")) return false; } - return true; + return true; + } +} + +static bool parse_enum(parser_t *parser) +{ + qcfloat num = 0; + ast_value **values = NULL; + ast_value *var = NULL; + ast_value *asvalue; + + ast_expression *old; + + if (!parser_next(parser) || parser->tok != '{') { + parseerror(parser, "expected `{` after `enum` keyword"); + return false; + } + + while (true) { + if (!parser_next(parser) || parser->tok != TOKEN_IDENT) { + if (parser->tok == '}') { + /* allow an empty enum */ + break; + } + parseerror(parser, "expected identifier or `}`"); + goto onerror; + } + + old = parser_find_field(parser, parser_tokval(parser)); + if (!old) + old = parser_find_global(parser, parser_tokval(parser)); + if (old) { + parseerror(parser, "value `%s` has already been declared here: %s:%i", + parser_tokval(parser), ast_ctx(old).file, ast_ctx(old).line); + goto onerror; + } + + var = ast_value_new(parser_ctx(parser), parser_tokval(parser), TYPE_FLOAT); + vec_push(values, var); + var->cvq = CV_CONST; + var->hasvalue = true; + var->constval.vfloat = num++; + + parser_addglobal(parser, var->name, (ast_expression*)var); + + if (!parser_next(parser)) { + parseerror(parser, "expected `=`, `}` or comma after identifier"); + goto onerror; + } + + if (parser->tok == ',') + continue; + if (parser->tok == '}') + break; + if (parser->tok != '=') { + parseerror(parser, "expected `=`, `}` or comma after identifier"); + goto onerror; + } + + if (!parser_next(parser)) { + parseerror(parser, "expected expression after `=`"); + goto onerror; + } + + /* We got a value! */ + old = parse_expression_leave(parser, true, false, false); + asvalue = (ast_value*)old; + if (!ast_istype(old, ast_value) || asvalue->cvq != CV_CONST || !asvalue->hasvalue) { + 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 != '}') { + parseerror(parser, "internal error: breaking without `}`"); + goto onerror; + } + + if (!parser_next(parser) || parser->tok != ';') { + parseerror(parser, "expected semicolon after enumeration"); + goto onerror; + } + + if (!parser_next(parser)) { + parseerror(parser, "parse error after enumeration"); + goto onerror; } + + vec_free(values); + return true; + +onerror: + vec_free(values); + return false; } static bool parse_block_into(parser_t *parser, ast_block *block) @@ -3013,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; } @@ -3049,7 +3849,7 @@ static bool parse_function_body(parser_t *parser, ast_value *var) if (!parser_next(parser)) return false; - framenum = parse_expression_leave(parser, true); + framenum = parse_expression_leave(parser, true, false, false); if (!framenum) { parseerror(parser, "expected a framenumber constant in[frame,think] notation"); return false; @@ -3092,12 +3892,12 @@ static bool parse_function_body(parser_t *parser, ast_value *var) return false; } - vec_push(parser->globals, (ast_expression*)thinkfunc); - util_htset(parser->htglobals, thinkfunc->name, thinkfunc); + parser_addglobal(parser, thinkfunc->name, (ast_expression*)thinkfunc); + nextthink = (ast_expression*)thinkfunc; } else { - nextthink = parse_expression_leave(parser, true); + nextthink = parse_expression_leave(parser, true, false, false); if (!nextthink) { ast_unref(framenum); parseerror(parser, "expected a think-function in [frame,think] notation"); @@ -3210,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) { @@ -3226,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) { @@ -3235,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)) { @@ -3266,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; } @@ -3401,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, @@ -3513,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; @@ -3523,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); @@ -3542,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) @@ -3608,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; @@ -3620,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); @@ -3636,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); @@ -3662,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); @@ -3691,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 { @@ -3713,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; + } + } + } } } @@ -3736,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]); @@ -3763,7 +4651,7 @@ static ast_value *parse_arraysize(parser_t *parser, ast_value *var) return NULL; } - cexp = parse_expression_leave(parser, true); + cexp = parse_expression_leave(parser, true, false, false); if (!cexp || !ast_istype(cexp, ast_value)) { if (cexp) @@ -3939,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; } } @@ -3998,7 +4885,45 @@ static bool parse_typedef(parser_t *parser) return true; } -static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofields, int qualifier, ast_value *cached_typedef, bool noref, bool noreturn, bool is_static) +static const char *cvq_to_str(int cvq) { + switch (cvq) { + case CV_NONE: return "none"; + case CV_VAR: return "`var`"; + case CV_CONST: return "`const`"; + default: return ""; + } +} + +static bool parser_check_qualifiers(parser_t *parser, const ast_value *var, const ast_value *proto) +{ + bool av, ao; + if (proto->cvq != var->cvq) { + if (!(proto->cvq == CV_CONST && var->cvq == CV_NONE && + !OPTS_FLAG(INITIALIZED_NONCONSTANTS) && + parser->tok == '=')) + { + return !parsewarning(parser, WARN_DIFFERENT_QUALIFIERS, + "`%s` declared with different qualifiers: %s\n" + " -> previous declaration here: %s:%i uses %s", + var->name, cvq_to_str(var->cvq), + ast_ctx(proto).file, ast_ctx(proto).line, + cvq_to_str(proto->cvq)); + } + } + av = (var ->expression.flags & AST_FLAG_NORETURN); + ao = (proto->expression.flags & AST_FLAG_NORETURN); + if (!av != !ao) { + return !parsewarning(parser, WARN_DIFFERENT_ATTRIBUTES, + "`%s` declared with different attributes%s\n" + " -> previous declaration here: %s:%i", + var->name, (av ? ": noreturn" : ""), + ast_ctx(proto).file, ast_ctx(proto).line, + (ao ? ": noreturn" : "")); + } + return true; +} + +static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofields, int qualifier, ast_value *cached_typedef, bool noref, bool is_static, uint32_t qflags, char *vstring) { ast_value *var; ast_value *proto; @@ -4015,6 +4940,9 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield ast_member *me[3]; + if (!localblock && is_static) + parseerror(parser, "`static` qualifier is not supported in global scope"); + /* get the first complete variable */ var = parse_typename(parser, &basetype, cached_typedef); if (!var) { @@ -4062,17 +4990,22 @@ 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++; - if (noreturn) - var->expression.flags |= AST_FLAG_NORETURN; + var->expression.flags |= qflags; + if (var->expression.flags & AST_FLAG_DEPRECATED) + var->desc = vstring; /* 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 * is then filled with the previous definition and the parameter-names replaced. */ + if (!strcmp(var->name, "nil")) { + if (OPTS_FLAG(UNTYPED_NIL)) { + if (!localblock || !OPTS_FLAG(PERMISSIVE)) + parseerror(parser, "name `nil` not allowed (try -fpermissive)"); + } else + (void)!parsewarning(parser, WARN_RESERVED_NAMES, "variable name `nil` is reserved"); + } if (!localblock) { /* Deal with end_sys_ vars */ was_end = false; @@ -4117,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"); @@ -4140,6 +5073,7 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield goto cleanup; } proto = (ast_value*)old; + proto->desc = var->desc; if (!ast_compare_type((ast_expression*)proto, (ast_expression*)var)) { parseerror(parser, "conflicting types for `%s`, previous declaration was here: %s:%i", proto->name, @@ -4150,6 +5084,14 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield /* we need the new parameter-names */ for (i = 0; i < vec_size(proto->expression.params); ++i) ast_value_set_name(proto->expression.params[i], var->expression.params[i]->name); + if (!parser_check_qualifiers(parser, var, proto)) { + retval = false; + if (proto->desc) + mem_d(proto->desc); + proto = NULL; + goto cleanup; + } + proto->expression.flags |= var->expression.flags; ast_delete(var); var = proto; } @@ -4157,29 +5099,28 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield { /* other globals */ if (old) { - if (opts.standard == COMPILER_GMQCC) { - parseerror(parser, "global `%s` already declared here: %s:%i", - var->name, ast_ctx(old).file, ast_ctx(old).line); + 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; - } 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; } + proto = (ast_value*)old; + if (!ast_istype(old, ast_value)) { + parseerror(parser, "internal error: not an ast_value"); + retval = false; + proto = NULL; + goto cleanup; + } + if (!parser_check_qualifiers(parser, var, proto)) { + retval = false; + proto = NULL; + goto cleanup; + } + proto->expression.flags |= var->expression.flags; + ast_delete(var); + var = proto; } if (opts.standard == COMPILER_QCC && (old = parser_find_field(parser, var->name))) @@ -4220,6 +5161,10 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield } } + /* in a noref section we simply bump the usecount */ + if (noref || parser->noref) + var->uses++; + /* Part 2: * Create the global/local, and deal with vector types. */ @@ -4251,12 +5196,10 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield } } else { - vec_push(parser->globals, (ast_expression*)var); - util_htset(parser->htglobals, var->name, var); + parser_addglobal(parser, var->name, (ast_expression*)var); if (isvector) { for (i = 0; i < 3; ++i) { - vec_push(parser->globals, (ast_expression*)me[i]); - util_htset(parser->htglobals, me[i]->name, me[i]); + parser_addglobal(parser, me[i]->name, (ast_expression*)me[i]); } } } @@ -4277,6 +5220,14 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield /* Add it to the local scope */ util_htset(vec_last(parser->variables), var->name, (void*)var); + + /* corrector */ + correct_add ( + vec_last(parser->correct_variables), + &vec_last(parser->correct_variables_score), + var->name + ); + /* now rename the global */ ln = strlen(var->name); vec_append(defname, ln, var->name); @@ -4290,6 +5241,13 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield for (i = 0; i < 3; ++i) { util_htset(vec_last(parser->variables), me[i]->name, (void*)(me[i])); + /* corrector */ + correct_add( + vec_last(parser->correct_variables), + &vec_last(parser->correct_variables_score), + me[i]->name + ); + vec_shrinkto(defname, prefix_len); ln = strlen(me[i]->name); vec_append(defname, ln, me[i]->name); @@ -4471,33 +5429,41 @@ skipvar: ast_expression *cexp; ast_value *cval; - cexp = parse_expression_leave(parser, true); + cexp = parse_expression_leave(parser, true, false, false); if (!cexp) break; if (!localblock) { cval = (ast_value*)cexp; - if (!ast_istype(cval, ast_value) || ((!cval->hasvalue || cval->cvq != CV_CONST) && !cval->isfield)) + if (cval != parser->nil && + (!ast_istype(cval, ast_value) || ((!cval->hasvalue || cval->cvq != CV_CONST) && !cval->isfield)) + ) + { parseerror(parser, "cannot initialize a global constant variable with a non-constant expression"); + } else { - if (opts.standard != COMPILER_GMQCC && - !OPTS_FLAG(INITIALIZED_NONCONSTANTS) && + if (!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; + if (cval == parser->nil) + var->expression.flags |= AST_FLAG_INITIALIZED; else - memcpy(&var->constval, &cval->constval, sizeof(var->constval)); - ast_unref(cval); + { + 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; + int cvq; shunt sy = { NULL, NULL }; cvq = var->cvq; var->cvq = CV_NONE; @@ -4572,22 +5538,27 @@ static bool parser_global_statement(parser_t *parser) { int cvq = CV_WRONG; bool noref = false; - bool noreturn = false; bool is_static = false; + uint32_t qflags = 0; ast_value *istype = NULL; + char *vstring = NULL; if (parser->tok == TOKEN_IDENT) istype = parser_find_typedef(parser, parser_tokval(parser), 0); if (istype || parser->tok == TOKEN_TYPENAME || parser->tok == '.') { - return parse_variable(parser, NULL, false, CV_NONE, istype, false, false, false); + return parse_variable(parser, NULL, false, CV_NONE, istype, false, false, 0, NULL); } - else if (parse_var_qualifiers(parser, false, &cvq, &noref, &noreturn, &is_static)) + else if (parse_qualifiers(parser, false, &cvq, &noref, &is_static, &qflags, &vstring)) { if (cvq == CV_WRONG) return false; - return parse_variable(parser, NULL, true, cvq, NULL, noref, noreturn, is_static); + return parse_variable(parser, NULL, true, cvq, NULL, noref, is_static, qflags, vstring); + } + else if (parser->tok == TOKEN_IDENT && !strcmp(parser_tokval(parser), "enum")) + { + return parse_enum(parser); } else if (parser->tok == TOKEN_KEYWORD) { @@ -4700,6 +5671,7 @@ static parser_t *parser; bool parser_init() { + lex_ctx empty_ctx; size_t i; parser = (parser_t*)mem_a(sizeof(parser_t)); @@ -4724,6 +5696,33 @@ bool parser_init() 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); + + /* corrector */ + vec_push(parser->correct_variables, correct_trie_new()); + vec_push(parser->correct_variables_score, NULL); + + empty_ctx.file = ""; + empty_ctx.line = 0; + parser->nil = ast_value_new(empty_ctx, "nil", TYPE_NIL); + parser->nil->cvq = CV_CONST; + if (OPTS_FLAG(UNTYPED_NIL)) + util_htset(parser->htglobals, "nil", (void*)parser->nil); + + parser->max_param_count = 1; + + 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; } @@ -4739,7 +5738,7 @@ bool parser_compile() if (!parser_global_statement(parser)) { if (parser->tok == TOKEN_EOF) parseerror(parser, "unexpected eof"); - else if (!parser->errors) + else if (compile_errors) parseerror(parser, "there have been errors, bailing out"); lex_close(parser->lex); parser->lex = NULL; @@ -4756,7 +5755,7 @@ bool parser_compile() lex_close(parser->lex); parser->lex = NULL; - return !parser->errors; + return !compile_errors; } bool parser_compile_file(const char *filename) @@ -4819,6 +5818,14 @@ void parser_cleanup() vec_free(parser->_blocklocals); vec_free(parser->_locals); + /* corrector */ + for (i = 0; i < vec_size(parser->correct_variables); ++i) { + correct_del(parser->correct_variables[i], parser->correct_variables_score[i]); + } + vec_free(parser->correct_variables); + vec_free(parser->correct_variables_score); + + for (i = 0; i < vec_size(parser->_typedefs); ++i) ast_delete(parser->_typedefs[i]); vec_free(parser->_typedefs); @@ -4831,6 +5838,14 @@ void parser_cleanup() vec_free(parser->labels); vec_free(parser->gotos); + vec_free(parser->breaks); + vec_free(parser->continues); + + 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); } @@ -4841,133 +5856,182 @@ bool parser_finish(const char *output) ir_builder *ir; bool retval = true; - if (!parser->errors) - { - ir = ir_builder_new("gmqcc_out"); - if (!ir) { - con_out("failed to allocate builder\n"); + if (compile_errors) { + con_out("*** there were compile errors\n"); + return false; + } + + ir = ir_builder_new("gmqcc_out"); + if (!ir) { + con_out("failed to allocate builder\n"); + return false; + } + + for (i = 0; i < vec_size(parser->fields); ++i) { + ast_value *field; + bool hasvalue; + if (!ast_istype(parser->fields[i], ast_value)) + continue; + 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; } - - for (i = 0; i < vec_size(parser->fields); ++i) { - ast_value *field; - bool hasvalue; - if (!ast_istype(parser->fields[i], ast_value)) - continue; - 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 (hasvalue) { - ir_value *ifld; - ast_expression *subtype; - field->hasvalue = true; - subtype = field->expression.next; - ifld = ir_builder_create_field(ir, field->name, subtype->expression.vtype); - if (subtype->expression.vtype == TYPE_FIELD) - ifld->fieldtype = subtype->expression.next->expression.vtype; - else if (subtype->expression.vtype == TYPE_FUNCTION) - ifld->outtype = subtype->expression.next->expression.vtype; - (void)!ir_value_set_field(field->ir_v, ifld); - } - } - for (i = 0; i < vec_size(parser->globals); ++i) { - ast_value *asvalue; - if (!ast_istype(parser->globals[i], ast_value)) - continue; - 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", asvalue->name); - ir_builder_delete(ir); - return false; - } + if (hasvalue) { + ir_value *ifld; + ast_expression *subtype; + field->hasvalue = true; + subtype = field->expression.next; + ifld = ir_builder_create_field(ir, field->name, subtype->expression.vtype); + if (subtype->expression.vtype == TYPE_FIELD) + ifld->fieldtype = subtype->expression.next->expression.vtype; + else if (subtype->expression.vtype == TYPE_FUNCTION) + ifld->outtype = subtype->expression.next->expression.vtype; + (void)!ir_value_set_field(field->ir_v, ifld); } - 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); - ir_builder_delete(ir); - return false; - } + } + for (i = 0; i < vec_size(parser->globals); ++i) { + ast_value *asvalue; + if (!ast_istype(parser->globals[i], ast_value)) + continue; + 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", asvalue->name); + ir_builder_delete(ir); + return false; } - for (i = 0; i < vec_size(parser->imm_string); ++i) { - if (!ast_global_codegen(parser->imm_string[i], ir, false)) { - con_out("failed to generate global %s\n", parser->imm_string[i]->name); - 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; } } - for (i = 0; i < vec_size(parser->imm_vector); ++i) { - if (!ast_global_codegen(parser->imm_vector[i], ir, false)) { - con_out("failed to generate global %s\n", parser->imm_vector[i]->name); - ir_builder_delete(ir); - return false; - } + } + /* 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); + ir_builder_delete(ir); + return false; } - for (i = 0; i < vec_size(parser->globals); ++i) { - ast_value *asvalue; - if (!ast_istype(parser->globals[i], ast_value)) - continue; - 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->imm_string); ++i) { + if (!ast_global_codegen(parser->imm_string[i], ir, false)) { + con_out("failed to generate global %s\n", parser->imm_string[i]->name); + ir_builder_delete(ir); + return false; + } + } + for (i = 0; i < vec_size(parser->imm_vector); ++i) { + if (!ast_global_codegen(parser->imm_vector[i], ir, false)) { + con_out("failed to generate global %s\n", parser->imm_vector[i]->name); + ir_builder_delete(ir); + return false; + } + } + for (i = 0; i < vec_size(parser->globals); ++i) { + ast_value *asvalue; + if (!ast_istype(parser->globals[i], ast_value)) + continue; + asvalue = (ast_value*)(parser->globals[i]); + if (!(asvalue->expression.flags & AST_FLAG_INITIALIZED)) + { + if (asvalue->cvq == CV_CONST && !asvalue->hasvalue) + (void)!compile_warning(ast_ctx(asvalue), WARN_UNINITIALIZED_CONSTANT, + "uninitialized constant: `%s`", + asvalue->name); + else if ((asvalue->cvq == CV_NONE || asvalue->cvq == CV_CONST) && !asvalue->hasvalue) + (void)!compile_warning(ast_ctx(asvalue), WARN_UNINITIALIZED_GLOBAL, + "uninitialized global: `%s`", + asvalue->name); + } + 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]->expression.next); + } + for (i = 0; i < vec_size(parser->fields); ++i) { + ast_value *asvalue; + 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 (!ast_generate_accessors(asvalue, ir)) { - ir_builder_delete(ir); - return false; - } + if (!ast_istype((ast_expression*)asvalue, ast_value)) + continue; + if (asvalue->expression.vtype != TYPE_ARRAY) + continue; + if (!ast_generate_accessors(asvalue, ir)) { + 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); - ir_builder_delete(ir); - 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) { + 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; } - if (opts.dump) - ir_builder_dump(ir, con_out); - for (i = 0; i < vec_size(parser->functions); ++i) { - if (!ir_function_finalize(parser->functions[i]->ir_func)) { - con_out("failed to finalize function %s\n", parser->functions[i]->name); - ir_builder_delete(ir); - return false; - } + } + if (opts.dump) + ir_builder_dump(ir, con_out); + for (i = 0; i < vec_size(parser->functions); ++i) { + if (!ir_function_finalize(parser->functions[i]->ir_func)) { + con_out("failed to finalize function %s\n", parser->functions[i]->name); + ir_builder_delete(ir); + return false; } + } + + if (compile_Werrors) { + con_out("*** there were warnings treated as errors\n"); + compile_show_werrors(); + retval = false; + } - if (retval) { - if (opts.dumpfin) - ir_builder_dump(ir, con_out); + if (retval) { + if (opts.dumpfin) + ir_builder_dump(ir, con_out); - generate_checksum(parser); + generate_checksum(parser); - if (!ir_builder_generate(ir, output)) { - con_out("*** failed to generate output file\n"); - ir_builder_delete(ir); - return false; - } + if (!ir_builder_generate(ir, output)) { + con_out("*** failed to generate output file\n"); + ir_builder_delete(ir); + return false; } - - ir_builder_delete(ir); - return retval; } - con_out("*** there were compile errors\n"); - return false; + ir_builder_delete(ir); + return retval; }