X-Git-Url: https://git.xonotic.org/?p=xonotic%2Fgmqcc.git;a=blobdiff_plain;f=parser.c;h=a54094a841f32beb80f736f756f7b00fee1226f8;hp=cb02e742b5a117acc87bf7dc5d5e084fbb7cb477;hb=36c5722273f1ea87603621c6ee20b7178a7a641b;hpb=7d14fdf530e49cb04b13572a790178c4c4bf75dc diff --git a/parser.c b/parser.c index cb02e74..a54094a 100644 --- a/parser.c +++ b/parser.c @@ -31,10 +31,9 @@ /* 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 }; typedef struct { lex_file *lex; int tok; @@ -54,6 +53,7 @@ typedef struct { ast_value *imm_float_one; ast_value *imm_vector_zero; ast_value *nil; + ast_value *reserved_version; size_t crc_globals; size_t crc_fields; @@ -74,6 +74,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; @@ -84,27 +88,22 @@ typedef struct { /* we store the '=' operator info */ const oper_info *assign_op; - /* TYPE_FIELD -> parser_find_fields is used instead of find_var - * TODO: TYPE_VECTOR -> x, y and z are accepted in the gmqcc standard - * anything else: type error - */ - qcint memberof; - - /* Keep track of our ternary vs parenthesis nesting state. - * If we reach a 'comma' operator in a ternary without a paren, - * we shall trigger -Wternary-precedence. - */ - enum parser_pot *pot; + /* magic values */ + ast_value *const_vec[3]; /* pragma flags */ bool noref; + + /* 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 is_static, uint32_t qflags, char *vstring); static ast_block* parse_block(parser_t *parser); @@ -113,6 +112,9 @@ static bool parse_statement_or_block(parser_t *parser, ast_expression **out); static bool parse_statement(parser_t *parser, ast_block *block, ast_expression **out, bool allow_cases); static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma, bool truthvalue, bool with_labels); static ast_expression* parse_expression(parser_t *parser, bool stopatcomma, bool with_labels); +static ast_value* parser_create_array_setter_proto(parser_t *parser, ast_value *array, const char *funcname); +static ast_value* parser_create_array_getter_proto(parser_t *parser, ast_value *array, const ast_expression *elemtype, const char *funcname); +static ast_value *parse_typename(parser_t *parser, ast_value **storebase, ast_value *cached_typedef); static void parseerror(parser_t *parser, const char *fmt, ...) { @@ -133,16 +135,6 @@ static bool GMQCC_WARN parsewarning(parser_t *parser, int warntype, const char * return r; } -static bool GMQCC_WARN genwarning(lex_ctx ctx, int warntype, const char *fmt, ...) -{ - bool r; - va_list ap; - va_start(ap, fmt); - r = vcompile_warning(ctx, warntype, fmt, ap); - va_end(ap); - return r; -} - /********************************************************************** * some maths used for constant folding */ @@ -204,12 +196,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; @@ -371,23 +369,28 @@ static ast_value* parser_find_typedef(parser_t *parser, const char *name, size_t typedef struct { size_t etype; /* 0 = expression, others are operators */ - int paren; + bool isparen; size_t off; ast_expression *out; ast_block *block; /* for commas and function calls */ lex_ctx ctx; } sy_elem; + +enum { + PAREN_EXPR, + PAREN_FUNC, + PAREN_INDEX, + PAREN_TERNARY1, + PAREN_TERNARY2 +}; typedef struct { - sy_elem *out; - sy_elem *ops; + sy_elem *out; + sy_elem *ops; + size_t *argc; + unsigned int *paren; } shunt; -#define SY_PAREN_EXPR '(' -#define SY_PAREN_FUNC 'f' -#define SY_PAREN_INDEX '[' -#define SY_PAREN_TERNARY '?' - static sy_elem syexp(lex_ctx ctx, ast_expression *v) { sy_elem e; e.etype = 0; @@ -395,7 +398,7 @@ static sy_elem syexp(lex_ctx ctx, ast_expression *v) { e.out = v; e.block = NULL; e.ctx = ctx; - e.paren = 0; + e.isparen = false; return e; } @@ -406,7 +409,7 @@ static sy_elem syblock(lex_ctx ctx, ast_block *v) { e.out = (ast_expression*)v; e.block = v; e.ctx = ctx; - e.paren = 0; + e.isparen = false; return e; } @@ -417,27 +420,21 @@ static sy_elem syop(lex_ctx ctx, const oper_info *op) { e.out = NULL; e.block = NULL; e.ctx = ctx; - e.paren = 0; + e.isparen = false; return e; } -static sy_elem syparen(lex_ctx ctx, int p, size_t off) { +static sy_elem syparen(lex_ctx ctx, size_t off) { sy_elem e; e.etype = 0; e.off = off; e.out = NULL; e.block = NULL; e.ctx = ctx; - e.paren = p; + e.isparen = true; return e; } -#ifdef DEBUGSHUNT -# define DEBUGSHUNTDO(x) x -#else -# define DEBUGSHUNTDO(x) -#endif - /* With regular precedence rules, ent.foo[n] is the same as (ent.foo)[n], * so we need to rotate it to become ent.(foo[n]). */ @@ -522,7 +519,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) return false; } - if (vec_last(sy->ops).paren) { + if (vec_last(sy->ops).isparen) { parseerror(parser, "unmatched parenthesis"); return false; } @@ -530,11 +527,9 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) op = &operators[vec_last(sy->ops).etype - 1]; ctx = vec_last(sy->ops).ctx; - 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; } @@ -551,7 +546,8 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) asvalue[i] = (ast_value*)exprs[i]; if (exprs[i]->expression.vtype == TYPE_NOEXPR && - !(i != 0 && op->id == opid2('?',':'))) + !(i != 0 && op->id == opid2('?',':')) && + !(i == 1 && op->id == opid1('.'))) { if (ast_istype(exprs[i], ast_label)) compile_error(ast_ctx(exprs[i]), "expected expression, got an unknown identifier"); @@ -562,7 +558,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) } if (blocks[0] && !vec_size(blocks[0]->exprs) && op->id != opid1(',')) { - parseerror(parser, "internal error: operator cannot be applied on empty blocks"); + compile_error(ctx, "internal error: operator cannot be applied on empty blocks"); return false; } @@ -580,23 +576,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; @@ -607,12 +617,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]); @@ -620,7 +630,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) { #if 0 /* This is not broken in fteqcc anymore */ - if (opts.standard != COMPILER_GMQCC) { + if (OPTS_OPTION_U32(OPTION_STANDARD) != COMPILER_GMQCC) { /* this error doesn't need to make us bail out */ (void)!parsewarning(parser, WARN_EXTENSIONS, "accessing array-field members of an entity without parenthesis\n" @@ -631,6 +641,12 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) break; case opid1(','): + if (vec_size(sy->paren) && vec_last(sy->paren) == PAREN_FUNC) { + vec_push(sy->out, syexp(ctx, exprs[0])); + vec_push(sy->out, syexp(ctx, exprs[1])); + vec_last(sy->argc)++; + return true; + } if (blocks[0]) { if (!ast_block_add_expr(blocks[0], exprs[1])) return false; @@ -671,8 +687,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; @@ -713,8 +729,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; @@ -723,9 +739,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) { @@ -744,9 +760,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; @@ -754,9 +770,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) { @@ -773,9 +789,9 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_V, exprs[0], exprs[1]); break; default: - parseerror(parser, "invalid types used in expression: cannot subtract type %s from %s", - type_name[exprs[1]->expression.vtype], - type_name[exprs[0]->expression.vtype]); + compile_error(ctx, "invalid types used in expression: cannot subtract type %s from %s", + type_name[exprs[1]->expression.vtype], + type_name[exprs[0]->expression.vtype]); return false; }; break; @@ -787,9 +803,9 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) exprs[0]->expression.vtype == TYPE_FLOAT) ) { - parseerror(parser, "invalid types used in expression: cannot multiply types %s and %s", - type_name[exprs[1]->expression.vtype], - type_name[exprs[0]->expression.vtype]); + compile_error(ctx, "invalid types used in expression: cannot multiply types %s and %s", + type_name[exprs[1]->expression.vtype], + type_name[exprs[0]->expression.vtype]); return false; } switch (exprs[0]->expression.vtype) { @@ -884,34 +900,61 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) } break; default: - parseerror(parser, "invalid types used in expression: cannot multiply types %s and %s", - type_name[exprs[1]->expression.vtype], - type_name[exprs[0]->expression.vtype]); + compile_error(ctx, "invalid types used in expression: cannot multiply types %s and %s", + type_name[exprs[1]->expression.vtype], + type_name[exprs[0]->expression.vtype]); return false; }; break; case opid1('/'): - if (NotSameType(TYPE_FLOAT)) { - parseerror(parser, "invalid types used in expression: cannot divide types %s and %s", - type_name[exprs[0]->expression.vtype], - type_name[exprs[1]->expression.vtype]); + if (exprs[1]->expression.vtype != TYPE_FLOAT) { + ast_type_to_string(exprs[0], ty1, sizeof(ty1)); + ast_type_to_string(exprs[1], ty2, sizeof(ty2)); + compile_error(ctx, "invalid types used in expression: cannot divide tyeps %s and %s", ty1, ty2); return false; } - if (CanConstFold(exprs[0], exprs[1])) - out = (ast_expression*)parser_const_float(parser, ConstF(0) / ConstF(1)); + if (exprs[0]->expression.vtype == TYPE_FLOAT) { + if (CanConstFold(exprs[0], exprs[1])) + out = (ast_expression*)parser_const_float(parser, ConstF(0) / ConstF(1)); + else + out = (ast_expression*)ast_binary_new(ctx, INSTR_DIV_F, exprs[0], exprs[1]); + } + else if (exprs[0]->expression.vtype == TYPE_VECTOR) { + if (CanConstFold(exprs[0], exprs[1])) + out = (ast_expression*)parser_const_vector(parser, vec3_mulvf(ConstV(0), 1.0/ConstF(1))); + else { + if (CanConstFold1(exprs[1])) { + out = (ast_expression*)parser_const_float(parser, 1.0 / ConstF(1)); + } else { + out = (ast_expression*)ast_binary_new(ctx, INSTR_DIV_F, + (ast_expression*)parser_const_float_1(parser), + exprs[1]); + } + if (!out) { + compile_error(ctx, "internal error: failed to generate division"); + return false; + } + out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_VF, exprs[0], out); + } + } else - out = (ast_expression*)ast_binary_new(ctx, INSTR_DIV_F, exprs[0], exprs[1]); + { + ast_type_to_string(exprs[0], ty1, sizeof(ty1)); + ast_type_to_string(exprs[1], ty2, sizeof(ty2)); + compile_error(ctx, "invalid types used in expression: cannot divide tyeps %s and %s", ty1, ty2); + return false; + } break; case opid1('%'): case opid2('%','='): - parseerror(parser, "qc does not have a modulo operator"); + compile_error(ctx, "qc does not have a modulo operator"); return false; case opid1('|'): case opid1('&'): if (NotSameType(TYPE_FLOAT)) { - parseerror(parser, "invalid types used in expression: cannot perform bit operations between types %s and %s", - type_name[exprs[0]->expression.vtype], - type_name[exprs[1]->expression.vtype]); + compile_error(ctx, "invalid types used in expression: cannot perform bit operations between types %s and %s", + type_name[exprs[0]->expression.vtype], + type_name[exprs[1]->expression.vtype]); return false; } if (CanConstFold(exprs[0], exprs[1])) @@ -924,30 +967,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)) { @@ -966,7 +1006,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) if (OPTS_FLAG(PERL_LOGIC) && !ast_compare_type(exprs[0], exprs[1])) { ast_type_to_string(exprs[0], ty1, sizeof(ty1)); ast_type_to_string(exprs[1], ty2, sizeof(ty2)); - parseerror(parser, "invalid types for logical operation with -fperl-logic: %s and %s", ty1, ty2); + compile_error(ctx, "invalid types for logical operation with -fperl-logic: %s and %s", ty1, ty2); return false; } for (i = 0; i < 2; ++i) { @@ -998,15 +1038,15 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) break; case opid2('?',':'): - if (vec_last(parser->pot) != POT_TERNARY2) { - parseerror(parser, "mismatched parenthesis/ternary"); + if (vec_last(sy->paren) != PAREN_TERNARY2) { + compile_error(ctx, "mismatched parenthesis/ternary"); return false; } - vec_pop(parser->pot); + vec_pop(sy->paren); 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])) @@ -1024,27 +1064,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]); @@ -1069,11 +1109,11 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) field->expression.next->expression.vtype == TYPE_FUNCTION && exprs[1]->expression.vtype == TYPE_FUNCTION) { - (void)!parsewarning(parser, WARN_ASSIGN_FUNCTION_TYPES, - "invalid types in assignment: cannot assign %s to %s", ty2, ty1); + (void)!compile_warning(ctx, WARN_ASSIGN_FUNCTION_TYPES, + "invalid types in assignment: cannot assign %s to %s", ty2, ty1); } else - parseerror(parser, "invalid types in assignment: cannot assign %s to %s", ty2, ty1); + compile_error(ctx, "invalid types in assignment: cannot assign %s to %s", ty2, ty1); } } else @@ -1091,7 +1131,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) if (assignop == AINSTR_END) { ast_type_to_string(exprs[0], ty1, sizeof(ty1)); ast_type_to_string(exprs[1], ty2, sizeof(ty2)); - parseerror(parser, "invalid types in assignment: cannot assign %s to %s", ty2, ty1); + compile_error(ctx, "invalid types in assignment: cannot assign %s to %s", ty2, ty1); } else if (!ast_compare_type(exprs[0], exprs[1])) { @@ -1101,15 +1141,15 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) exprs[0]->expression.vtype == TYPE_FUNCTION && exprs[1]->expression.vtype == TYPE_FUNCTION) { - (void)!parsewarning(parser, WARN_ASSIGN_FUNCTION_TYPES, - "invalid types in assignment: cannot assign %s to %s", ty2, ty1); + (void)!compile_warning(ctx, WARN_ASSIGN_FUNCTION_TYPES, + "invalid types in assignment: cannot assign %s to %s", ty2, ty1); } else - parseerror(parser, "invalid types in assignment: cannot assign %s to %s", ty2, ty1); + compile_error(ctx, "invalid types in assignment: cannot assign %s to %s", ty2, ty1); } } if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) { - parseerror(parser, "assignment to constant `%s`", asvalue[0]->name); + compile_error(ctx, "assignment to constant `%s`", asvalue[0]->name); } out = (ast_expression*)ast_store_new(ctx, assignop, exprs[0], exprs[1]); break; @@ -1118,7 +1158,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')) @@ -1126,7 +1166,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, @@ -1143,7 +1183,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','+','+')) { @@ -1154,7 +1194,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, @@ -1178,12 +1218,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]; @@ -1201,9 +1241,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; @@ -1215,12 +1255,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]; @@ -1238,19 +1278,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; @@ -1259,12 +1305,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]; @@ -1282,8 +1328,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)) @@ -1294,7 +1340,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; @@ -1304,11 +1350,10 @@ 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 operator %s", op->op); return false; } - DEBUGSHUNTDO(con_out("applied %s\n", op->op)); vec_push(sy->out, syexp(ctx, out)); return true; } @@ -1317,23 +1362,31 @@ 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; - size_t paramcount; + size_t paramcount, i; + fid = vec_last(sy->ops).off; vec_shrinkby(sy->ops, 1); - fid = sy->ops[vec_size(sy->ops)].off; /* out[fid] is the function * everything above is parameters... - * 0 params = nothing - * 1 params = ast_expression - * more = ast_block */ + if (!vec_size(sy->argc)) { + parseerror(parser, "internal error: no argument counter available"); + return false; + } - if (vec_size(sy->out) < 1 || vec_size(sy->out) <= fid) { - parseerror(parser, "internal error: function call needs function and parameter list..."); + paramcount = vec_last(sy->argc); + vec_pop(sy->argc); + + if (vec_size(sy->out) < fid) { + parseerror(parser, "internal error: broken function call%lu < %lu+%lu\n", + (unsigned long)vec_size(sy->out), + (unsigned long)fid, + (unsigned long)paramcount); return false; } @@ -1356,32 +1409,32 @@ static bool parser_close_call(parser_t *parser, shunt *sy) } call = ast_call_new(sy->ops[vec_size(sy->ops)].ctx, fun); - if (!call) { - parseerror(parser, "internal error: failed to create ast_call node"); + if (!call) + return false; + + if (fid+1 < vec_size(sy->out)) + ++paramcount; + + if (fid+1 + paramcount != vec_size(sy->out)) { + parseerror(parser, "internal error: parameter count mismatch: (%lu+1+%lu), %lu", + (unsigned long)fid, (unsigned long)paramcount, (unsigned long)vec_size(sy->out)); return false; } - if (fid+1 == vec_size(sy->out)) { - /* no arguments */ - paramcount = 0; - } else if (fid+2 == vec_size(sy->out)) { - ast_block *params; - vec_shrinkby(sy->out, 1); - params = sy->out[vec_size(sy->out)].block; - if (!params) { - /* 1 param */ - paramcount = 1; - vec_push(call->params, sy->out[vec_size(sy->out)].out); - } else { - paramcount = vec_size(params->exprs); - call->params = params->exprs; - params->exprs = NULL; - ast_delete(params); + for (i = 0; i < paramcount; ++i) + vec_push(call->params, sy->out[fid+1 + i].out); + vec_shrinkby(sy->out, paramcount); + (void)!ast_call_check_types(call); + if (parser->max_param_count < paramcount) + parser->max_param_count = paramcount; + + 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)) + { + call->va_count = (ast_expression*)parser_const_float(parser, (double)paramcount); } - (void)!ast_call_check_types(call); - } else { - parseerror(parser, "invalid function call"); - return false; } /* overwrite fid, the function, with a call */ @@ -1441,49 +1494,48 @@ static bool parser_close_call(parser_t *parser, shunt *sy) return true; } -static bool parser_close_paren(parser_t *parser, shunt *sy, bool functions_only) +static bool parser_close_paren(parser_t *parser, shunt *sy) { if (!vec_size(sy->ops)) { parseerror(parser, "unmatched closing paren"); return false; } - /* this would for bit a + (x) because there are no operators inside (x) - if (sy->ops[vec_size(sy->ops)-1].paren == 1) { - parseerror(parser, "empty parenthesis expression"); - return false; - } - */ + while (vec_size(sy->ops)) { - if (sy->ops[vec_size(sy->ops)-1].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) { - vec_shrinkby(sy->ops, 1); - return !functions_only; - } - if (sy->ops[vec_size(sy->ops)-1].paren == SY_PAREN_INDEX) { - if (functions_only) - return false; - /* pop off the parenthesis */ - vec_shrinkby(sy->ops, 1); - /* then apply the index operator */ - if (!parser_sy_apply_operator(parser, sy)) - return false; - return true; - } - if (sy->ops[vec_size(sy->ops)-1].paren == SY_PAREN_TERNARY) { - if (functions_only) - return false; - if (vec_last(parser->pot) != POT_TERNARY1) { - parseerror(parser, "mismatched colon in ternary expression (missing closing paren?)"); - return false; + if (vec_last(sy->ops).isparen) { + if (vec_last(sy->paren) == PAREN_FUNC) { + vec_pop(sy->paren); + if (!parser_close_call(parser, sy)) + return false; + break; } - vec_last(parser->pot) = POT_TERNARY2; - /* pop off the parenthesis */ - vec_shrinkby(sy->ops, 1); - return true; + if (vec_last(sy->paren) == PAREN_EXPR) { + vec_pop(sy->paren); + 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); + break; + } + if (vec_last(sy->paren) == PAREN_INDEX) { + vec_pop(sy->paren); + /* pop off the parenthesis */ + vec_shrinkby(sy->ops, 1); + /* then apply the index operator */ + if (!parser_sy_apply_operator(parser, sy)) + return false; + break; + } + if (vec_last(sy->paren) == PAREN_TERNARY1) { + vec_last(sy->paren) = PAREN_TERNARY2; + /* pop off the parenthesis */ + vec_shrinkby(sy->ops, 1); + break; + } + compile_error(vec_last(sy->ops).ctx, "invalid parenthesis"); + return false; } if (!parser_sy_apply_operator(parser, sy)) return false; @@ -1502,272 +1554,309 @@ static void parser_reclassify_token(parser_t *parser) } } -static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma, bool truthvalue, bool with_labels) +static ast_expression* parse_vararg_do(parser_t *parser) { - ast_expression *expr = NULL; - shunt sy; - bool wantop = false; - bool gotmemberof = false; - /* only warn once about an assignment in a truth value because the current code - * would trigger twice on: if(a = b && ...), once for the if-truth-value, once for the && part - */ - bool warn_truthvalue = true; + ast_expression *idx, *out; + ast_value *typevar; + ast_value *funtype = parser->function->vtype; - /* count the parens because an if starts with one, so the - * end of a condition is an unmatched closing paren - */ - int parens = 0; - int ternaries = 0; + lex_ctx ctx = parser_ctx(parser); - sy.out = NULL; - sy.ops = NULL; + 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; + } - parser->lex->flags.noops = false; + idx = parse_expression_leave(parser, true, false, false); + if (!idx) + return NULL; - parser_reclassify_token(parser); + if (parser->tok != ',') { + ast_unref(idx); + parseerror(parser, "expected comma after parameter index"); + return NULL; + } - while (true) + 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)) { - if (gotmemberof) - gotmemberof = false; - else - parser->memberof = 0; + 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; +} - if (OPTS_FLAG(TRANSLATABLE_STRINGS) && - parser->tok == TOKEN_IDENT && !strcmp(parser_tokval(parser), "_")) - { - /* a translatable string */ - ast_value *val; +static ast_expression* parse_vararg(parser_t *parser) +{ + bool old_noops = parser->lex->flags.noops; - if (wantop) { - parseerror(parser, "expected operator or end of statement, got constant"); - goto onerr; - } + ast_expression *out; - parser->lex->flags.noops = true; - if (!parser_next(parser) || parser->tok != '(') { - parseerror(parser, "use _(\"string\") to create a translatable string constant"); - goto onerr; - } - parser->lex->flags.noops = false; - if (!parser_next(parser) || parser->tok != TOKEN_STRINGCONST) { - parseerror(parser, "expected a constant string in translatable-string extension"); - goto onerr; - } - val = parser_const_string(parser, parser_tokval(parser), true); - wantop = true; - if (!val) - return NULL; - vec_push(sy.out, syexp(parser_ctx(parser), (ast_expression*)val)); - DEBUGSHUNTDO(con_out("push string\n")); + parser->lex->flags.noops = true; + out = parse_vararg_do(parser); - if (!parser_next(parser) || parser->tok != ')') { - parseerror(parser, "expected closing paren after translatable string"); - goto onerr; - } - } - else if (parser->tok == TOKEN_IDENT) - { - ast_expression *var; - if (wantop) { - parseerror(parser, "expected operator or end of statement"); - goto onerr; - } - wantop = true; - /* variable */ - if (opts.standard == COMPILER_GMQCC) - { - 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)); - } 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 - { - /* - * 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)) { - size_t i; - 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; - } - } - } + parser->lex->flags.noops = old_noops; + return out; +} - parseerror(parser, "unexpected ident: %s", parser_tokval(parser)); - goto onerr; - } - } - else - { - if (ast_istype(var, ast_value)) { - ((ast_value*)var)->uses++; - } - else if (ast_istype(var, ast_member)) { - ast_member *mem = (ast_member*)var; - if (ast_istype(mem->owner, ast_value)) - ((ast_value*)(mem->owner))->uses++; - } - } - vec_push(sy.out, syexp(parser_ctx(parser), var)); - DEBUGSHUNTDO(con_out("push %s\n", parser_tokval(parser))); +static bool parse_sya_operand(parser_t *parser, shunt *sy, bool with_labels) +{ + if (OPTS_FLAG(TRANSLATABLE_STRINGS) && + parser->tok == TOKEN_IDENT && + !strcmp(parser_tokval(parser), "_")) + { + /* a translatable string */ + ast_value *val; + + parser->lex->flags.noops = true; + if (!parser_next(parser) || parser->tok != '(') { + parseerror(parser, "use _(\"string\") to create a translatable string constant"); + return false; } - else if (parser->tok == TOKEN_FLOATCONST) { - ast_value *val; - if (wantop) { - parseerror(parser, "expected operator or end of statement, got constant"); - goto onerr; - } - wantop = true; - val = parser_const_float(parser, (parser_token(parser)->constval.f)); - if (!val) - return NULL; - vec_push(sy.out, syexp(parser_ctx(parser), (ast_expression*)val)); - DEBUGSHUNTDO(con_out("push %g\n", parser_token(parser)->constval.f)); + parser->lex->flags.noops = false; + if (!parser_next(parser) || parser->tok != TOKEN_STRINGCONST) { + parseerror(parser, "expected a constant string in translatable-string extension"); + return false; } - else if (parser->tok == TOKEN_INTCONST || parser->tok == TOKEN_CHARCONST) { - ast_value *val; - if (wantop) { - parseerror(parser, "expected operator or end of statement, got constant"); - goto onerr; - } - wantop = true; - val = parser_const_float(parser, (double)(parser_token(parser)->constval.i)); - if (!val) - return NULL; - vec_push(sy.out, syexp(parser_ctx(parser), (ast_expression*)val)); - DEBUGSHUNTDO(con_out("push %i\n", parser_token(parser)->constval.i)); + val = parser_const_string(parser, parser_tokval(parser), true); + if (!val) + return false; + vec_push(sy->out, syexp(parser_ctx(parser), (ast_expression*)val)); + + if (!parser_next(parser) || parser->tok != ')') { + parseerror(parser, "expected closing paren after translatable string"); + return false; } - else if (parser->tok == TOKEN_STRINGCONST) { - ast_value *val; - if (wantop) { - parseerror(parser, "expected operator or end of statement, got constant"); - goto onerr; - } - wantop = true; - val = parser_const_string(parser, parser_tokval(parser), false); - if (!val) - return NULL; - vec_push(sy.out, syexp(parser_ctx(parser), (ast_expression*)val)); - DEBUGSHUNTDO(con_out("push string\n")); + return true; + } + else if (parser->tok == TOKEN_DOTS) + { + ast_expression *va; + if (!OPTS_FLAG(VARIADIC_ARGS)) { + parseerror(parser, "cannot access varargs (try -fvariadic-args)"); + return false; } - else if (parser->tok == TOKEN_VECTORCONST) { - ast_value *val; - if (wantop) { - parseerror(parser, "expected operator or end of statement, got constant"); - goto onerr; - } - wantop = true; - val = parser_const_vector(parser, parser_token(parser)->constval.v); - if (!val) - return NULL; - vec_push(sy.out, syexp(parser_ctx(parser), (ast_expression*)val)); - DEBUGSHUNTDO(con_out("push '%g %g %g'\n", - parser_token(parser)->constval.v.x, - parser_token(parser)->constval.v.y, - parser_token(parser)->constval.v.z)); + va = parse_vararg(parser); + if (!va) + return false; + vec_push(sy->out, syexp(parser_ctx(parser), va)); + return true; + } + else if (parser->tok == TOKEN_FLOATCONST) { + ast_value *val; + val = parser_const_float(parser, (parser_token(parser)->constval.f)); + if (!val) + return false; + vec_push(sy->out, syexp(parser_ctx(parser), (ast_expression*)val)); + return true; + } + else if (parser->tok == TOKEN_INTCONST || parser->tok == TOKEN_CHARCONST) { + ast_value *val; + val = parser_const_float(parser, (double)(parser_token(parser)->constval.i)); + if (!val) + return false; + vec_push(sy->out, syexp(parser_ctx(parser), (ast_expression*)val)); + return true; + } + else if (parser->tok == TOKEN_STRINGCONST) { + ast_value *val; + val = parser_const_string(parser, parser_tokval(parser), false); + if (!val) + return false; + vec_push(sy->out, syexp(parser_ctx(parser), (ast_expression*)val)); + return true; + } + else if (parser->tok == TOKEN_VECTORCONST) { + ast_value *val; + val = parser_const_vector(parser, parser_token(parser)->constval.v); + if (!val) + return false; + vec_push(sy->out, syexp(parser_ctx(parser), (ast_expression*)val)); + return true; + } + 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; + /* 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)) + { + /* When adding more intrinsics, fix the above condition */ + prev = NULL; } - else if (parser->tok == '(') { - parseerror(parser, "internal error: '(' should be classified as operator"); - goto onerr; + 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)); } - else if (parser->tok == '[') { - parseerror(parser, "internal error: '[' should be classified as operator"); - goto onerr; + 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); + } } - else if (parser->tok == ')') { - if (wantop) { - DEBUGSHUNTDO(con_out("do[op] )\n")); - --parens; - if (parens < 0) - break; - /* we do expect an operator next */ - /* closing an opening paren */ - if (!parser_close_paren(parser, &sy, false)) - goto onerr; - if (vec_last(parser->pot) != POT_PAREN) { - parseerror(parser, "mismatched parentheses (closing paren during ternary expression?)"); - goto onerr; + if (!var) { + /* intrinsics */ + if (!strcmp(parser_tokval(parser), "__builtin_debug_typestring")) { + var = (ast_expression*)intrinsic_debug_typestring; + } + else + { + char *correct = NULL; + size_t i; + + /* + * 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)); + return false; + } + } } - vec_pop(parser->pot); - } else { - DEBUGSHUNTDO(con_out("do[nop] )\n")); - --parens; - if (parens < 0) - break; - /* allowed for function calls */ - if (!parser_close_paren(parser, &sy, true)) - goto onerr; - if (vec_last(parser->pot) != POT_PAREN) { - parseerror(parser, "mismatched parentheses (closing paren during ternary expression?)"); - goto onerr; + + /* + * 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_OPTION_BOOL(OPTION_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); + return false; + } } - vec_pop(parser->pot); + parseerror(parser, "unexpected ident: %s", parser_tokval(parser)); + return false; } - wantop = true; } - else if (parser->tok == ']') { - if (!wantop) - parseerror(parser, "operand expected"); - --parens; - if (parens < 0) - break; - if (!parser_close_paren(parser, &sy, false)) - goto onerr; - if (vec_last(parser->pot) != POT_PAREN) { - parseerror(parser, "mismatched parentheses (closing paren during ternary expression?)"); - goto onerr; + else + { + if (ast_istype(var, ast_value)) { + ((ast_value*)var)->uses++; + } + else if (ast_istype(var, ast_member)) { + ast_member *mem = (ast_member*)var; + if (ast_istype(mem->owner, ast_value)) + ((ast_value*)(mem->owner))->uses++; } - vec_pop(parser->pot); - wantop = true; } - else if (parser->tok == TOKEN_TYPENAME) { + vec_push(sy->out, syexp(parser_ctx(parser), var)); + return true; + } + parseerror(parser, "unexpected token `%s`", parser_tokval(parser)); + return false; +} + +static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma, bool truthvalue, bool with_labels) +{ + ast_expression *expr = NULL; + shunt sy; + size_t i; + bool wantop = false; + /* only warn once about an assignment in a truth value because the current code + * would trigger twice on: if(a = b && ...), once for the if-truth-value, once for the && part + */ + bool warn_truthvalue = true; + + /* count the parens because an if starts with one, so the + * end of a condition is an unmatched closing paren + */ + int ternaries = 0; + + memset(&sy, 0, sizeof(sy)); + + parser->lex->flags.noops = false; + + parser_reclassify_token(parser); + + while (true) + { + if (parser->tok == TOKEN_TYPENAME) { parseerror(parser, "unexpected typename"); goto onerr; } - else if (parser->tok != TOKEN_OPERATOR) { - if (wantop) { - parseerror(parser, "expected operator or end of statement"); - goto onerr; - } - break; - } - else + + if (parser->tok == TOKEN_OPERATOR) { /* classify the operator */ const oper_info *op; @@ -1789,7 +1878,7 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma op = &operators[o]; /* when declaring variables, a comma starts a new variable */ - if (op->id == opid1(',') && !parens && stopatcomma) { + if (op->id == opid1(',') && !vec_size(sy.paren) && stopatcomma) { /* fixup the token */ parser->tok = ','; break; @@ -1802,12 +1891,12 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma } if (op->id == opid1(',')) { - if (vec_size(parser->pot) && vec_last(parser->pot) == POT_TERNARY2) { + if (vec_size(sy.paren) && vec_last(sy.paren) == PAREN_TERNARY2) { (void)!parsewarning(parser, WARN_TERNARY_PRECEDENCE, "suggesting parenthesis around ternary expression"); } } - if (vec_size(sy.ops) && !vec_last(sy.ops).paren) + if (vec_size(sy.ops) && !vec_last(sy.ops).isparen) olast = &operators[vec_last(sy.ops).etype-1]; #define IsAssignOp(x) (\ @@ -1824,7 +1913,7 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma 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)) + (truthvalue && !vec_size(sy.paren) && IsAssignOp(op->id)) ) { (void)!parsewarning(parser, WARN_PARENTHESIS, "suggesting parenthesis around assignment used as truth value"); @@ -1838,41 +1927,22 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma { if (!parser_sy_apply_operator(parser, &sy)) goto onerr; - if (vec_size(sy.ops) && !vec_last(sy.ops).paren) + if (vec_size(sy.ops) && !vec_last(sy.ops).isparen) olast = &operators[vec_last(sy.ops).etype-1]; else 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); - DEBUGSHUNTDO(con_out("push [op] (\n")); - ++parens; vec_push(parser->pot, POT_PAREN); /* we expected an operator, this is the function-call operator */ - vec_push(sy.ops, syparen(parser_ctx(parser), SY_PAREN_FUNC, sycount-1)); + vec_push(sy.paren, PAREN_FUNC); + vec_push(sy.ops, syparen(parser_ctx(parser), sycount-1)); + vec_push(sy.argc, 0); } else { - ++parens; vec_push(parser->pot, POT_PAREN); - vec_push(sy.ops, syparen(parser_ctx(parser), SY_PAREN_EXPR, 0)); - DEBUGSHUNTDO(con_out("push [nop] (\n")); + vec_push(sy.paren, PAREN_EXPR); + vec_push(sy.ops, syparen(parser_ctx(parser), 0)); } wantop = false; } else if (op->id == opid1('[')) { @@ -1880,42 +1950,104 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma parseerror(parser, "unexpected array subscript"); goto onerr; } - ++parens; vec_push(parser->pot, POT_PAREN); + vec_push(sy.paren, PAREN_INDEX); /* push both the operator and the paren, this makes life easier */ vec_push(sy.ops, syop(parser_ctx(parser), op)); - vec_push(sy.ops, syparen(parser_ctx(parser), SY_PAREN_INDEX, 0)); + vec_push(sy.ops, syparen(parser_ctx(parser), 0)); wantop = false; } else if (op->id == opid2('?',':')) { vec_push(sy.ops, syop(parser_ctx(parser), op)); - vec_push(sy.ops, syparen(parser_ctx(parser), SY_PAREN_TERNARY, 0)); + vec_push(sy.ops, syparen(parser_ctx(parser), 0)); wantop = false; ++ternaries; - vec_push(parser->pot, POT_TERNARY1); + vec_push(sy.paren, PAREN_TERNARY1); } else if (op->id == opid2(':','?')) { - if (!vec_size(parser->pot)) { + if (!vec_size(sy.paren)) { parseerror(parser, "unexpected colon outside ternary expression (missing parenthesis?)"); goto onerr; } - if (vec_last(parser->pot) != POT_TERNARY1) { + if (vec_last(sy.paren) != PAREN_TERNARY1) { parseerror(parser, "unexpected colon outside ternary expression (missing parenthesis?)"); goto onerr; } - if (!parser_close_paren(parser, &sy, false)) + if (!parser_close_paren(parser, &sy)) goto onerr; vec_push(sy.ops, syop(parser_ctx(parser), op)); wantop = false; --ternaries; } else { - DEBUGSHUNTDO(con_out("push operator %s\n", op->op)); vec_push(sy.ops, syop(parser_ctx(parser), op)); wantop = !!(op->flags & OP_SUFFIX); } } + else if (parser->tok == ')') { + while (vec_size(sy.paren) && vec_last(sy.paren) == PAREN_TERNARY2) { + if (!parser_sy_apply_operator(parser, &sy)) + goto onerr; + } + if (!vec_size(sy.paren)) + break; + if (wantop) { + if (vec_last(sy.paren) == PAREN_TERNARY1) { + parseerror(parser, "mismatched parentheses (closing paren in ternary expression?)"); + goto onerr; + } + if (!parser_close_paren(parser, &sy)) + goto onerr; + } else { + /* must be a function call without parameters */ + if (vec_last(sy.paren) != PAREN_FUNC) { + parseerror(parser, "closing paren in invalid position"); + goto onerr; + } + if (!parser_close_paren(parser, &sy)) + goto onerr; + } + wantop = true; + } + else if (parser->tok == '(') { + parseerror(parser, "internal error: '(' should be classified as operator"); + goto onerr; + } + else if (parser->tok == '[') { + parseerror(parser, "internal error: '[' should be classified as operator"); + goto onerr; + } + else if (parser->tok == ']') { + while (vec_size(sy.paren) && vec_last(sy.paren) == PAREN_TERNARY2) { + if (!parser_sy_apply_operator(parser, &sy)) + goto onerr; + } + if (!vec_size(sy.paren)) + break; + if (vec_last(sy.paren) != PAREN_INDEX) { + parseerror(parser, "mismatched parentheses, unexpected ']'"); + goto onerr; + } + if (!parser_close_paren(parser, &sy)) + goto onerr; + wantop = true; + } + else if (!wantop) { + if (!parse_sya_operand(parser, &sy, with_labels)) + goto onerr; +#if 0 + if (vec_size(sy.paren) && vec_last(sy.ops).isparen && vec_last(sy.paren) == PAREN_FUNC) + vec_last(sy.argc)++; +#endif + wantop = true; + } + else { + parseerror(parser, "expected operator or end of statement"); + goto onerr; + } + if (!parser_next(parser)) { goto onerr; } if (parser->tok == ';' || - (!parens && parser->tok == ']')) + ((!vec_size(sy.paren) || (vec_size(sy.paren) == 1 && vec_last(sy.paren) == PAREN_TERNARY2)) && + (parser->tok == ']' || parser->tok == ')' || parser->tok == '}'))) { break; } @@ -1934,18 +2066,24 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma expr = sy.out[0].out; vec_free(sy.out); vec_free(sy.ops); - DEBUGSHUNTDO(con_out("shunt done\n")); - if (vec_size(parser->pot)) { - parseerror(parser, "internal error: vec_size(parser->pot) = %lu", (unsigned long)vec_size(parser->pot)); + if (vec_size(sy.paren)) { + parseerror(parser, "internal error: vec_size(sy.paren) = %lu", (unsigned long)vec_size(sy.paren)); return NULL; } - vec_free(parser->pot); + vec_free(sy.paren); + vec_free(sy.argc); return expr; 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); + vec_free(sy.paren); + vec_free(sy.argc); return NULL; } @@ -1954,8 +2092,13 @@ static ast_expression* parse_expression(parser_t *parser, bool stopatcomma, bool 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; @@ -1968,6 +2111,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) @@ -1981,7 +2128,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; @@ -2008,6 +2159,7 @@ static bool parser_leaveblock(parser_t *parser) vec_pop(parser->typedefs); vec_pop(parser->_block_ctx); + return rv; } @@ -2015,6 +2167,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) @@ -2023,6 +2195,12 @@ static ast_expression* process_condition(parser_t *parser, ast_expression *cond, ast_unary *unary; ast_expression *prev; + if (cond->expression.vtype == TYPE_VOID || cond->expression.vtype >= TYPE_VARIANT) { + char ty[1024]; + ast_type_to_string(cond, ty, sizeof(ty)); + compile_error(ast_ctx(cond), "invalid type for if() condition: %s", ty); + } + if (OPTS_FLAG(FALSE_EMPTY_STRINGS) && cond->expression.vtype == TYPE_STRING) { prev = cond; @@ -2120,6 +2298,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 */ @@ -2455,7 +2635,7 @@ static bool parse_for_go(parser_t *parser, ast_block *block, ast_expression **ou if (typevar || parser->tok == TOKEN_TYPENAME) { #if 0 - if (opts.standard != COMPILER_GMQCC) { + if (OPTS_OPTION_U32(OPTION_STANDARD) != COMPILER_GMQCC) { if (parsewarning(parser, WARN_EXTENSIONS, "current standard does not allow variable declarations in for-loop initializers")) goto onerr; @@ -2500,11 +2680,12 @@ static bool parse_for_go(parser_t *parser, ast_block *block, ast_expression **ou /* parse the incrementor */ if (parser->tok != ')') { + lex_ctx condctx = parser_ctx(parser); increment = parse_expression_leave(parser, false, false, false); if (!increment) goto onerr; if (!ast_side_effects(increment)) { - if (genwarning(ast_ctx(increment), WARN_EFFECTLESS_STATEMENT, "statement has no effect")) + if (compile_warning(condctx, WARN_EFFECTLESS_STATEMENT, "statement has no effect")) goto onerr; } } @@ -2597,6 +2778,13 @@ static bool parse_break_continue(parser_t *parser, ast_block *block, ast_express return false; } + 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"); @@ -2681,7 +2869,7 @@ static bool parse_qualifiers(parser_t *parser, bool with_local, int *cvq, bool * 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; @@ -2734,7 +2922,7 @@ static bool parse_qualifiers(parser_t *parser, bool with_local, int *cvq, bool * } } } - 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; @@ -2999,28 +3187,35 @@ static bool parse_switch_go(parser_t *parser, ast_block *block, ast_expression * } /* parse computed goto sides */ -static ast_expression *parse_goto_computed(parser_t *parser, ast_expression *side) { +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) + if (!*side) return NULL; - if (ast_istype(side, ast_ternary)) { - on_true = parse_goto_computed(parser, ((ast_ternary*)side)->on_true); - on_false = parse_goto_computed(parser, ((ast_ternary*)side)->on_false); + 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 (((ast_ternary*)side)->on_false) ast_unref(((ast_ternary*)side)->on_false); - if (((ast_ternary*)side)->on_true) ast_unref(((ast_ternary*)side)->on_true); + if (on_true) ast_unref(on_true); + if (on_false) ast_unref(on_false); return NULL; } - return (ast_expression*)ast_ifthen_new(parser_ctx(parser), ((ast_ternary*)side)->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)); + 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; @@ -3045,7 +3240,7 @@ static bool parse_goto(parser_t *parser, ast_expression **out) /* failed to parse expression for goto */ if (!(expression = parse_expression(parser, false, true)) || - !(*out = parse_goto_computed(parser, expression))) { + !(*out = parse_goto_computed(parser, &expression))) { parseerror(parser, "invalid goto expression"); ast_unref(expression); return false; @@ -3097,15 +3292,26 @@ static bool parse_eol(parser_t *parser) return parser->tok == TOKEN_EOL; } -static bool parse_pragma_do(parser_t *parser) -{ - if (!parser_next(parser) || - parser->tok != TOKEN_IDENT || - strcmp(parser_tokval(parser), "pragma")) - { - parseerror(parser, "expected `pragma` keyword after `#`, got `%s`", parser_tokval(parser)); - return false; - } +/* + * Traditionally you'd implement warning, error, and message + * directives in the preprocessor. However, like #pragma, these + * shouldn't depend on -fftepp to utilize. So they're instead + * implemented here. + */ +enum { + PARSE_DIRECTIVE_ERROR, + PARSE_DIRECTIVE_MESSAGE, + PARSE_DIRECTIVE_WARNING, + PARSE_DIRECTIVE_COUNT +}; + +static const char *parser_directives[PARSE_DIRECTIVE_COUNT] = { + "error", + "message", + "warning" +}; + +static bool parse_pragma_do(parser_t *parser) { if (!parse_skipwhite(parser) || parser->tok != TOKEN_IDENT) { parseerror(parser, "expected pragma, got `%s`", parser_tokval(parser)); return false; @@ -3116,35 +3322,99 @@ static bool parse_pragma_do(parser_t *parser) parseerror(parser, "`noref` pragma requires an argument: 0 or 1"); return false; } + parser->noref = !!parser_token(parser)->constval.i; + if (!parse_eol(parser)) { parseerror(parser, "parse error after `noref` pragma"); return false; } - } - else - { + } else { (void)!parsewarning(parser, WARN_UNKNOWN_PRAGMAS, "ignoring #pragma %s", parser_tokval(parser)); return false; } - return true; } -static bool parse_pragma(parser_t *parser) +static bool parse_directive_or_pragma_do(parser_t *parser, bool *pragma) { + + size_t type = PARSE_DIRECTIVE_COUNT; + + if (!parser_next(parser) || parser->tok != TOKEN_IDENT) { + parseerror(parser, "expected `pragma, error, message, warning` after `#`, got `%s`", + parser_tokval(parser)); + + return false; + } + + if (!strcmp(parser_tokval(parser), "pragma" )) { + *pragma = true; + + return parse_pragma_do(parser); + } + + if (!strcmp(parser_tokval(parser), "error" )) type = PARSE_DIRECTIVE_ERROR; + if (!strcmp(parser_tokval(parser), "message")) type = PARSE_DIRECTIVE_MESSAGE; + if (!strcmp(parser_tokval(parser), "warning")) type = PARSE_DIRECTIVE_WARNING; + + switch (type) { + case PARSE_DIRECTIVE_ERROR: + case PARSE_DIRECTIVE_MESSAGE: + case PARSE_DIRECTIVE_WARNING: + *pragma = false; + + if (!parse_skipwhite(parser) || parser->tok != TOKEN_STRINGCONST) { + parseerror(parser, "expected %s, got `%`", parser_directives[type], parser_tokval(parser)); + return false; + } + + switch (type) { + case PARSE_DIRECTIVE_ERROR: + con_cprintmsg(&parser->lex->tok.ctx, LVL_ERROR, "error", parser_tokval(parser)); + compile_errors ++; /* hack */ + break; + /*break;*/ + + case PARSE_DIRECTIVE_MESSAGE: + con_cprintmsg(&parser->lex->tok.ctx, LVL_MSG, "message", parser_tokval(parser)); + break; + + case PARSE_DIRECTIVE_WARNING: + con_cprintmsg(&parser->lex->tok.ctx, LVL_WARNING, "warning", parser_tokval(parser)); + break; + } + + if (!parse_eol(parser)) { + parseerror(parser, "parse error after `%` directive", parser_directives[type]); + return false; + } + + return (type != PARSE_DIRECTIVE_ERROR); + } + + parseerror(parser, "invalid directive `%s`", parser_tokval(parser)); + return false; +} + +static bool parse_directive_or_pragma(parser_t *parser) { bool rv; + bool pragma; /* true when parsing pragma */ + parser->lex->flags.preprocessing = true; - parser->lex->flags.mergelines = true; - rv = parse_pragma_do(parser); + parser->lex->flags.mergelines = true; + + rv = parse_directive_or_pragma_do(parser, &pragma); + if (parser->tok != TOKEN_EOL) { - parseerror(parser, "junk after pragma"); + parseerror(parser, "junk after %s", (pragma) ? "pragma" : "directive"); rv = false; } parser->lex->flags.preprocessing = false; - parser->lex->flags.mergelines = false; + parser->lex->flags.mergelines = false; + if (!parser_next(parser)) { - parseerror(parser, "parse error after pragma"); + parseerror(parser, "parse error after %s", (pragma) ? "pragma" : "directive"); rv = false; } return rv; @@ -3170,7 +3440,7 @@ static bool parse_statement(parser_t *parser, ast_block *block, ast_expression * parseerror(parser, "cannot declare a variable from here"); return false; } - if (opts.standard == COMPILER_QCC) { + if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_QCC) { if (parsewarning(parser, WARN_EXTENSIONS, "missing 'local' keyword when declaring a local variable")) return false; } @@ -3237,7 +3507,7 @@ static bool parse_statement(parser_t *parser, ast_block *block, ast_expression * } else if (!strcmp(parser_tokval(parser), "for")) { - if (opts.standard == COMPILER_QCC) { + if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_QCC) { if (parsewarning(parser, WARN_EXTENSIONS, "for loops are not recognized in the original Quake C standard, to enable try an alternate standard --std=?")) return false; } @@ -3336,18 +3606,119 @@ static bool parse_statement(parser_t *parser, ast_block *block, ast_expression * } else { + lex_ctx ctx = parser_ctx(parser); ast_expression *exp = parse_expression(parser, false, false); if (!exp) return false; *out = exp; if (!ast_side_effects(exp)) { - if (genwarning(ast_ctx(exp), WARN_EFFECTLESS_STATEMENT, "statement has no effect")) + if (compile_warning(ctx, WARN_EFFECTLESS_STATEMENT, "statement has no effect")) return false; } 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) { bool retval = true; @@ -3461,9 +3832,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; } @@ -3540,8 +3911,8 @@ 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 { @@ -3658,6 +4029,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) { @@ -3674,7 +4053,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) { @@ -3683,13 +4062,34 @@ 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; + + func->fixedparams = parser_const_float(parser, vec_size(var->expression.params)); } - vec_push(parser->functions, func); parser->function = func; if (!parse_block_into(parser, block)) { @@ -3709,17 +4109,17 @@ static bool parse_function_body(parser_t *parser, ast_value *var) if (parser->tok == ';') return parser_next(parser); - else if (opts.standard == COMPILER_QCC) + else if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_QCC) parseerror(parser, "missing semicolon after function body (mandatory with -std=qcc)"); 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; } @@ -3849,6 +4249,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, @@ -3961,9 +4364,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; @@ -3971,11 +4373,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); @@ -3990,21 +4392,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) @@ -4056,9 +4476,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; @@ -4068,11 +4487,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); @@ -4084,20 +4503,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); @@ -4110,6 +4545,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); @@ -4139,14 +4576,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 { @@ -4161,6 +4601,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; + } + } + } } } @@ -4168,7 +4625,7 @@ static ast_value *parse_parameter_list(parser_t *parser, ast_value *var) vec_free(params); /* sanity check */ - if (vec_size(params) > 8 && opts.standard == COMPILER_QCC) + if (vec_size(params) > 8 && OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_QCC) (void)!parsewarning(parser, WARN_EXTENSIONS, "more than 8 parameters are not supported by this standard"); /* parse-out */ @@ -4184,12 +4641,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]); @@ -4378,7 +4839,7 @@ static ast_value *parse_typename(parser_t *parser, ast_value **storebase, ast_va } /* now there may be function parens again */ - if (parser->tok == '(' && opts.standard == COMPILER_QCC) + if (parser->tok == '(' && OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_QCC) parseerror(parser, "C-style function syntax is not allowed in -std=qcc"); if (parser->tok == '(' && wasarray) parseerror(parser, "arrays as part of a return type is not supported"); @@ -4387,7 +4848,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; } } @@ -4518,7 +4978,7 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield /* Part 0: finish the type */ if (parser->tok == '(') { - if (opts.standard == COMPILER_QCC) + if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_QCC) parseerror(parser, "C-style function syntax is not allowed in -std=qcc"); var = parse_parameter_list(parser, var); if (!var) { @@ -4541,7 +5001,7 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield } /* for functions returning functions */ while (parser->tok == '(') { - if (opts.standard == COMPILER_QCC) + if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_QCC) parseerror(parser, "C-style function syntax is not allowed in -std=qcc"); var = parse_parameter_list(parser, var); if (!var) { @@ -4611,7 +5071,7 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield goto cleanup; */ } - if (opts.standard == COMPILER_QCC && + if ((OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_QCC || OPTS_OPTION_U32(OPTION_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"); @@ -4683,7 +5143,7 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield ast_delete(var); var = proto; } - if (opts.standard == COMPILER_QCC && + if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_QCC && (old = parser_find_field(parser, var->name))) { parseerror(parser, "cannot declare a field and a global of the same name with -std=qcc"); @@ -4714,7 +5174,7 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield retval = false; goto cleanup; } - if (opts.standard != COMPILER_GMQCC) { + if (OPTS_OPTION_U32(OPTION_STANDARD) != COMPILER_GMQCC) { ast_delete(var); var = NULL; goto skipvar; @@ -4757,12 +5217,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]); } } } @@ -4783,6 +5241,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); @@ -4796,6 +5262,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); @@ -4881,7 +5354,7 @@ skipvar: break; } - if (localblock && opts.standard == COMPILER_QCC) { + if (localblock && OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_QCC) { if (parsewarning(parser, WARN_LOCAL_CONSTANTS, "initializing expression turns variable `%s` into a constant in this standard", var->name) ) @@ -4901,7 +5374,7 @@ skipvar: break; } } - else if (opts.standard == COMPILER_QCC) { + else if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_QCC) { parseerror(parser, "expected '=' before function body in this standard"); } @@ -5012,7 +5485,7 @@ skipvar: } } else { int cvq; - shunt sy = { NULL, NULL }; + shunt sy = { NULL, NULL, NULL, NULL }; cvq = var->cvq; var->cvq = CV_NONE; vec_push(sy.out, syexp(ast_ctx(var), (ast_expression*)var)); @@ -5104,6 +5577,10 @@ static bool parser_global_statement(parser_t *parser) return false; 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) { if (!strcmp(parser_tokval(parser), "typedef")) { @@ -5118,7 +5595,7 @@ static bool parser_global_statement(parser_t *parser) } else if (parser->tok == '#') { - return parse_pragma(parser); + return parse_directive_or_pragma(parser); } else if (parser->tok == '$') { @@ -5241,12 +5718,32 @@ bool parser_init() 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_OPTION_BOOL(OPTION_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; } @@ -5342,6 +5839,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); @@ -5359,6 +5864,10 @@ void parser_cleanup() ast_value_delete(parser->nil); + ast_value_delete(parser->const_vec[0]); + ast_value_delete(parser->const_vec[1]); + ast_value_delete(parser->const_vec[2]); + mem_d(parser); } @@ -5411,8 +5920,8 @@ bool parser_finish(const char *output) 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); + retval = retval && !compile_warning(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); @@ -5420,6 +5929,31 @@ bool parser_finish(const char *output) return false; } } + /* Build function vararg accessor ast tree now before generating + * immediates, because the accessors may add new immediates + */ + for (i = 0; i < vec_size(parser->functions); ++i) { + ast_function *f = parser->functions[i]; + if (f->varargs) { + if (parser->max_param_count > vec_size(f->vtype->expression.params)) { + f->varargs->expression.count = parser->max_param_count - vec_size(f->vtype->expression.params); + if (!parser_create_array_setter_impl(parser, f->varargs)) { + con_out("failed to generate vararg setter for %s\n", f->name); + ir_builder_delete(ir); + return false; + } + if (!parser_create_array_getter_impl(parser, f->varargs)) { + con_out("failed to generate vararg getter for %s\n", f->name); + ir_builder_delete(ir); + return false; + } + } else { + ast_delete(f->varargs); + f->varargs = NULL; + } + } + } + /* Now we can generate immediates */ for (i = 0; i < vec_size(parser->imm_float); ++i) { if (!ast_global_codegen(parser->imm_float[i], ir, false)) { con_out("failed to generate global %s\n", parser->imm_float[i]->name); @@ -5475,14 +6009,22 @@ bool parser_finish(const char *output) return false; } } + if (parser->reserved_version && + !ast_global_codegen(parser->reserved_version, ir, false)) + { + con_out("failed to generate reserved::version"); + ir_builder_delete(ir); + return false; + } for (i = 0; i < vec_size(parser->functions); ++i) { - if (!ast_function_codegen(parser->functions[i], ir)) { - con_out("failed to generate function %s\n", parser->functions[i]->name); + ast_function *f = parser->functions[i]; + if (!ast_function_codegen(f, ir)) { + con_out("failed to generate function %s\n", f->name); ir_builder_delete(ir); return false; } } - if (opts.dump) + if (OPTS_OPTION_BOOL(OPTION_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)) { @@ -5499,7 +6041,7 @@ bool parser_finish(const char *output) } if (retval) { - if (opts.dumpfin) + if (OPTS_OPTION_BOOL(OPTION_DUMPFIN)) ir_builder_dump(ir, con_out); generate_checksum(parser);