X-Git-Url: https://git.xonotic.org/?p=xonotic%2Fgmqcc.git;a=blobdiff_plain;f=parser.c;h=3c5d237e17500ed86acd2e66ad80f937e55e552b;hp=2d3dda9452247d6004a865af49142176314c2d55;hb=4079835c7e75bb2b6a20ebb1f1e91e4c8c362c99;hpb=d5b95f04126ed8f30d86e0d4c7c3fdc82f74bb3f diff --git a/parser.c b/parser.c index 2d3dda9..3c5d237 100644 --- a/parser.c +++ b/parser.c @@ -13,12 +13,15 @@ typedef struct { lex_file *lex; int tok; - MEM_VECTOR_MAKE(varentry_t, globals); - MEM_VECTOR_MAKE(varentry_t, fields); - MEM_VECTOR_MAKE(ast_function*, functions); - MEM_VECTOR_MAKE(ast_value*, imm_float); - MEM_VECTOR_MAKE(ast_value*, imm_string); - MEM_VECTOR_MAKE(ast_value*, imm_vector); + varentry_t *globals; + varentry_t *fields; + ast_function **functions; + ast_value **imm_float; + ast_value **imm_string; + ast_value **imm_vector; + + /* must be deleted first, they reference immediates and values */ + ast_value **accessors; ast_value *imm_float_zero; ast_value *imm_vector_zero; @@ -27,7 +30,7 @@ typedef struct { size_t crc_fields; ast_function *function; - MEM_VECTOR_MAKE(varentry_t, locals); + varentry_t *locals; size_t blocklocal; size_t errors; @@ -42,19 +45,13 @@ typedef struct { qcint memberof; } parser_t; -MEM_VEC_FUNCTIONS(parser_t, varentry_t, globals) -MEM_VEC_FUNCTIONS(parser_t, varentry_t, fields) -MEM_VEC_FUNCTIONS(parser_t, ast_value*, imm_float) -MEM_VEC_FUNCTIONS(parser_t, ast_value*, imm_string) -MEM_VEC_FUNCTIONS(parser_t, ast_value*, imm_vector) -MEM_VEC_FUNCTIONS(parser_t, varentry_t, locals) -MEM_VEC_FUNCTIONS(parser_t, ast_function*, functions) static bool GMQCC_WARN parser_pop_local(parser_t *parser); static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofields); static ast_block* parse_block(parser_t *parser, bool warnreturn); static bool parse_block_into(parser_t *parser, ast_block *block, bool warnreturn); static ast_expression* parse_statement_or_block(parser_t *parser); +static bool parse_statement(parser_t *parser, ast_block *block, ast_expression **out, bool allow_cases); static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma); static ast_expression* parse_expression(parser_t *parser, bool stopatcomma); @@ -65,7 +62,7 @@ static void parseerror(parser_t *parser, const char *fmt, ...) parser->errors++; va_start(ap, fmt); - vprintmsg(LVL_ERROR, parser->lex->tok.ctx.file, parser->lex->tok.ctx.line, "parse error", fmt, ap); + con_vprintmsg(LVL_ERROR, parser->lex->tok.ctx.file, parser->lex->tok.ctx.line, "parse error", fmt, ap); va_end(ap); } @@ -84,7 +81,7 @@ static bool GMQCC_WARN parsewarning(parser_t *parser, int warntype, const char * } va_start(ap, fmt); - vprintmsg(lvl, parser->lex->tok.ctx.file, parser->lex->tok.ctx.line, "warning", fmt, ap); + con_vprintmsg(lvl, parser->lex->tok.ctx.file, parser->lex->tok.ctx.line, "warning", fmt, ap); va_end(ap); return opts_werror; @@ -102,7 +99,7 @@ static bool GMQCC_WARN genwarning(lex_ctx ctx, int warntype, const char *fmt, .. lvl = LVL_ERROR; va_start(ap, fmt); - vprintmsg(lvl, ctx.file, ctx.line, "warning", fmt, ap); + con_vprintmsg(lvl, ctx.file, ctx.line, "warning", fmt, ap); va_end(ap); return opts_werror; @@ -169,17 +166,15 @@ static ast_value* parser_const_float(parser_t *parser, double d) { size_t i; ast_value *out; - for (i = 0; i < parser->imm_float_count; ++i) { - if (parser->imm_float[i]->constval.vfloat == d) + 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); out->isconst = true; out->constval.vfloat = d; - if (!parser_t_imm_float_add(parser, out)) { - ast_value_delete(out); - return NULL; - } + vec_push(parser->imm_float, out); return out; } @@ -205,17 +200,14 @@ static ast_value* parser_const_string(parser_t *parser, const char *str) { size_t i; ast_value *out; - for (i = 0; i < parser->imm_string_count; ++i) { + for (i = 0; i < vec_size(parser->imm_string); ++i) { if (!strcmp(parser->imm_string[i]->constval.vstring, str)) return parser->imm_string[i]; } out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_STRING); out->isconst = true; out->constval.vstring = parser_strdup(str); - if (!parser_t_imm_string_add(parser, out)) { - ast_value_delete(out); - return NULL; - } + vec_push(parser->imm_string, out); return out; } @@ -223,17 +215,14 @@ static ast_value* parser_const_vector(parser_t *parser, vector v) { size_t i; ast_value *out; - for (i = 0; i < parser->imm_vector_count; ++i) { + for (i = 0; i < vec_size(parser->imm_vector); ++i) { if (!memcmp(&parser->imm_vector[i]->constval.vvec, &v, sizeof(v))) return parser->imm_vector[i]; } out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_VECTOR); out->isconst = true; out->constval.vvec = v; - if (!parser_t_imm_vector_add(parser, out)) { - ast_value_delete(out); - return NULL; - } + vec_push(parser->imm_vector, out); return out; } @@ -256,7 +245,7 @@ static ast_value* parser_const_vector_0(parser_t *parser) static ast_expression* parser_find_field(parser_t *parser, const char *name) { size_t i; - for (i = 0; i < parser->fields_count; ++i) { + for (i = 0; i < vec_size(parser->fields); ++i) { if (!strcmp(parser->fields[i].name, name)) return parser->fields[i].var; } @@ -266,7 +255,7 @@ static ast_expression* parser_find_field(parser_t *parser, const char *name) static ast_expression* parser_find_global(parser_t *parser, const char *name) { size_t i; - for (i = 0; i < parser->globals_count; ++i) { + for (i = 0; i < vec_size(parser->globals); ++i) { if (!strcmp(parser->globals[i].name, name)) return parser->globals[i].var; } @@ -280,7 +269,7 @@ static ast_expression* parser_find_param(parser_t *parser, const char *name) if (!parser->function) return NULL; fun = parser->function->vtype; - for (i = 0; i < fun->expression.params_count; ++i) { + for (i = 0; i < vec_size(fun->expression.params); ++i) { if (!strcmp(fun->expression.params[i]->name, name)) return (ast_expression*)(fun->expression.params[i]); } @@ -291,7 +280,7 @@ static ast_expression* parser_find_local(parser_t *parser, const char *name, siz { size_t i; *isparam = false; - for (i = parser->locals_count; i > upto;) { + for (i = vec_size(parser->locals); i > upto;) { --i; if (!strcmp(parser->locals[i].name, name)) return parser->locals[i].var; @@ -320,11 +309,9 @@ typedef struct } sy_elem; typedef struct { - MEM_VECTOR_MAKE(sy_elem, out); - MEM_VECTOR_MAKE(sy_elem, ops); + sy_elem *out; + sy_elem *ops; } shunt; -MEM_VEC_FUNCTIONS(shunt, sy_elem, out) -MEM_VEC_FUNCTIONS(shunt, sy_elem, ops) #define SY_PAREN_EXPR '(' #define SY_PAREN_FUNC 'f' @@ -380,6 +367,44 @@ static sy_elem syparen(lex_ctx ctx, int p, size_t off) { # 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]). + */ +static bool rotate_entfield_array_index_nodes(ast_expression **out) +{ + ast_array_index *index; + ast_entfield *entfield; + + ast_value *field; + ast_expression *sub; + ast_expression *entity; + + lex_ctx ctx = ast_ctx(*out); + + if (!ast_istype(*out, ast_array_index)) + return false; + index = (ast_array_index*)*out; + + if (!ast_istype(index->array, ast_entfield)) + return false; + entfield = (ast_entfield*)index->array; + + if (!ast_istype(entfield->field, ast_value)) + return false; + field = (ast_value*)entfield->field; + + sub = index->index; + entity = entfield->entity; + + ast_delete(index); + + index = ast_array_index_new(ctx, (ast_expression*)field, sub); + entfield = ast_entfield_new(ctx, entity, (ast_expression*)index); + *out = (ast_expression*)entfield; + + return true; +} + static bool parser_sy_pop(parser_t *parser, shunt *sy) { const oper_info *op; @@ -388,43 +413,43 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) ast_expression *exprs[3]; ast_block *blocks[3]; ast_value *asvalue[3]; - size_t i, assignop; + size_t i, assignop, addop; qcint generated_op = 0; char ty1[1024]; char ty2[1024]; - if (!sy->ops_count) { + if (!vec_size(sy->ops)) { parseerror(parser, "internal error: missing operator"); return false; } - if (sy->ops[sy->ops_count-1].paren) { + if (vec_last(sy->ops).paren) { parseerror(parser, "unmatched parenthesis"); return false; } - op = &operators[sy->ops[sy->ops_count-1].etype - 1]; - ctx = sy->ops[sy->ops_count-1].ctx; + op = &operators[vec_last(sy->ops).etype - 1]; + ctx = vec_last(sy->ops).ctx; - DEBUGSHUNTDO(printf("apply %s\n", op->op)); + DEBUGSHUNTDO(con_out("apply %s\n", op->op)); - if (sy->out_count < op->operands) { - parseerror(parser, "internal error: not enough operands: %i (operator %s (%i))", sy->out_count, + 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); return false; } - sy->ops_count--; + vec_shrinkby(sy->ops, 1); - sy->out_count -= op->operands; + vec_shrinkby(sy->out, op->operands); for (i = 0; i < op->operands; ++i) { - exprs[i] = sy->out[sy->out_count+i].out; - blocks[i] = sy->out[sy->out_count+i].block; + exprs[i] = sy->out[vec_size(sy->out)+i].out; + blocks[i] = sy->out[vec_size(sy->out)+i].block; asvalue[i] = (ast_value*)exprs[i]; } - if (blocks[0] && !blocks[0]->exprs_count && op->id != opid1(',')) { + if (blocks[0] && !vec_size(blocks[0]->exprs) && op->id != opid1(',')) { parseerror(parser, "internal error: operator cannot be applied on empty blocks"); return false; } @@ -463,22 +488,44 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) } break; + case opid1('['): + if (exprs[0]->expression.vtype != TYPE_ARRAY && + !(exprs[0]->expression.vtype == TYPE_FIELD && + 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); + 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); + return false; + } + out = (ast_expression*)ast_array_index_new(ctx, exprs[0], exprs[1]); + if (rotate_entfield_array_index_nodes(&out)) + { + if (opts_standard != COMPILER_GMQCC) { + /* this error doesn't need to make us bail out */ + (void)!parsewarning(parser, WARN_EXTENSIONS, + "accessing array-field members of an entity without parenthesis\n" + " -> this is an extension from -std=gmqcc"); + } + } + break; + case opid1(','): if (blocks[0]) { - if (!ast_block_exprs_add(blocks[0], exprs[1])) - return false; + vec_push(blocks[0]->exprs, exprs[1]); } else { blocks[0] = ast_block_new(ctx); - if (!ast_block_exprs_add(blocks[0], exprs[0]) || - !ast_block_exprs_add(blocks[0], exprs[1])) - { - return false; - } + vec_push(blocks[0]->exprs, exprs[0]); + vec_push(blocks[0]->exprs, exprs[1]); } if (!ast_block_set_type(blocks[0], exprs[1])) return false; - sy->out[sy->out_count++] = syblock(ctx, blocks[0]); + vec_push(sy->out, syblock(ctx, blocks[0])); return true; case opid2('-','P'): @@ -711,7 +758,7 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) return false; } if (opts_standard == COMPILER_GMQCC) - printf("TODO: early out logic\n"); + con_out("TODO: early out logic\n"); if (CanConstFold(exprs[0], exprs[1])) out = (ast_expression*)parser_const_float(parser, (generated_op == INSTR_OR ? (ConstF(0) || ConstF(1)) : (ConstF(0) && ConstF(1)))); @@ -719,6 +766,19 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) out = (ast_expression*)ast_binary_new(ctx, generated_op, exprs[0], exprs[1]); break; + case opid2('?',':'): + if (exprs[1]->expression.vtype != exprs[2]->expression.vtype) { + ast_type_to_string(exprs[1], ty1, sizeof(ty1)); + ast_type_to_string(exprs[2], ty2, sizeof(ty2)); + parseerror(parser, "iperands of ternary expression must have the same type, got %s and %s", ty1, ty2); + return false; + } + if (CanConstFold1(exprs[0])) + out = (ConstF(0) ? exprs[1] : exprs[2]); + else + out = (ast_expression*)ast_ternary_new(ctx, exprs[0], exprs[1], exprs[2]); + break; + case opid1('>'): generated_op += 1; /* INSTR_GT */ case opid1('<'): @@ -818,14 +878,59 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) } out = (ast_expression*)ast_store_new(ctx, assignop, exprs[0], exprs[1]); break; + case opid3('+','+','P'): + case opid3('-','-','P'): + /* 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); + return false; + } + if (op->id == opid3('+','+','P')) + addop = INSTR_ADD_F; + else + addop = INSTR_SUB_F; + if (ast_istype(exprs[0], ast_entfield)) { + out = (ast_expression*)ast_binstore_new(ctx, INSTR_STOREP_F, addop, + exprs[0], + (ast_expression*)parser_const_float(parser, 1)); + } else { + out = (ast_expression*)ast_binstore_new(ctx, INSTR_STORE_F, addop, + exprs[0], + (ast_expression*)parser_const_float(parser, 1)); + } + break; + case opid3('S','+','+'): + case opid3('S','-','-'): + /* 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); + return false; + } + if (op->id == opid3('+','+','P')) + addop = INSTR_ADD_F; + else + addop = INSTR_SUB_F; + if (ast_istype(exprs[0], ast_entfield)) { + out = (ast_expression*)ast_binstore_new(ctx, INSTR_STOREP_F, addop, + exprs[0], + (ast_expression*)parser_const_float(parser, 1)); + } else { + out = (ast_expression*)ast_binstore_new(ctx, INSTR_STORE_F, addop, + exprs[0], + (ast_expression*)parser_const_float(parser, 1)); + } + break; case opid2('+','='): case opid2('-','='): if (exprs[0]->expression.vtype != exprs[1]->expression.vtype || (exprs[0]->expression.vtype != TYPE_VECTOR && exprs[0]->expression.vtype != 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: cannot add or subtract type %s and %s", - type_name[exprs[0]->expression.vtype], - type_name[exprs[1]->expression.vtype]); + ty1, ty2); return false; } if (ast_istype(exprs[0], ast_entfield)) @@ -858,8 +963,8 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) return false; } - DEBUGSHUNTDO(printf("applied %s\n", op->op)); - sy->out[sy->out_count++] = syexp(ctx, out); + DEBUGSHUNTDO(con_out("applied %s\n", op->op)); + vec_push(sy->out, syexp(ctx, out)); return true; } @@ -872,8 +977,8 @@ static bool parser_close_call(parser_t *parser, shunt *sy) size_t fid; size_t paramcount; - sy->ops_count--; - fid = sy->ops[sy->ops_count].off; + vec_shrinkby(sy->ops, 1); + fid = sy->ops[vec_size(sy->ops)].off; /* out[fid] is the function * everything above is parameters... @@ -882,37 +987,34 @@ static bool parser_close_call(parser_t *parser, shunt *sy) * more = ast_block */ - if (sy->out_count < 1 || sy->out_count <= fid) { + if (vec_size(sy->out) < 1 || vec_size(sy->out) <= fid) { parseerror(parser, "internal error: function call needs function and parameter list..."); return false; } fun = sy->out[fid].out; - call = ast_call_new(sy->ops[sy->ops_count].ctx, fun); + call = ast_call_new(sy->ops[vec_size(sy->ops)].ctx, fun); if (!call) { parseerror(parser, "out of memory"); return false; } - if (fid+1 == sy->out_count) { + if (fid+1 == vec_size(sy->out)) { /* no arguments */ paramcount = 0; - } else if (fid+2 == sy->out_count) { + } else if (fid+2 == vec_size(sy->out)) { ast_block *params; - sy->out_count--; - params = sy->out[sy->out_count].block; + vec_shrinkby(sy->out, 1); + params = sy->out[vec_size(sy->out)].block; if (!params) { /* 1 param */ paramcount = 1; - if (!ast_call_params_add(call, sy->out[sy->out_count].out)) { - ast_delete(sy->out[sy->out_count].out); - parseerror(parser, "out of memory"); - return false; - } + vec_push(call->params, sy->out[vec_size(sy->out)].out); } else { - paramcount = params->exprs_count; - MEM_VECTOR_MOVE(params, exprs, call, params); + paramcount = vec_size(params->exprs); + call->params = params->exprs; + params->exprs = NULL; ast_delete(params); } if (!ast_call_check_types(call)) @@ -934,12 +1036,12 @@ static bool parser_close_call(parser_t *parser, shunt *sy) parseerror(parser, "could not determine function return type"); return false; } else { - if (fun->expression.params_count != paramcount && + if (vec_size(fun->expression.params) != paramcount && !(fun->expression.variadic && - fun->expression.params_count < paramcount)) + vec_size(fun->expression.params) < paramcount)) { ast_value *fval; - const char *fewmany = (fun->expression.params_count > paramcount) ? "few" : "many"; + const char *fewmany = (vec_size(fun->expression.params) > paramcount) ? "few" : "many"; fval = (ast_istype(fun, ast_value) ? ((ast_value*)fun) : NULL); if (opts_standard == COMPILER_GMQCC) @@ -947,12 +1049,12 @@ static bool parser_close_call(parser_t *parser, shunt *sy) if (fval) parseerror(parser, "too %s parameters for call to %s: expected %i, got %i\n" " -> `%s` has been declared here: %s:%i", - fewmany, fval->name, (int)fun->expression.params_count, (int)paramcount, + fewmany, fval->name, (int)vec_size(fun->expression.params), (int)paramcount, fval->name, ast_ctx(fun).file, (int)ast_ctx(fun).line); else parseerror(parser, "too %s parameters for function call: expected %i, got %i\n" " -> `%s` has been declared here: %s:%i", - fewmany, fval->name, (int)fun->expression.params_count, (int)paramcount, + fewmany, fval->name, (int)vec_size(fun->expression.params), (int)paramcount, fval->name, ast_ctx(fun).file, (int)ast_ctx(fun).line); return false; } @@ -962,13 +1064,13 @@ static bool parser_close_call(parser_t *parser, shunt *sy) return !parsewarning(parser, WARN_TOO_FEW_PARAMETERS, "too %s parameters for call to %s: expected %i, got %i\n" " -> `%s` has been declared here: %s:%i", - fewmany, fval->name, (int)fun->expression.params_count, (int)paramcount, + fewmany, fval->name, (int)vec_size(fun->expression.params), (int)paramcount, fval->name, ast_ctx(fun).file, (int)ast_ctx(fun).line); else return !parsewarning(parser, WARN_TOO_FEW_PARAMETERS, "too %s parameters for function call: expected %i, got %i\n" " -> `%s` has been declared here: %s:%i", - fewmany, fval->name, (int)fun->expression.params_count, (int)paramcount, + fewmany, fval->name, (int)vec_size(fun->expression.params), (int)paramcount, fval->name, ast_ctx(fun).file, (int)ast_ctx(fun).line); } } @@ -979,31 +1081,31 @@ static bool parser_close_call(parser_t *parser, shunt *sy) static bool parser_close_paren(parser_t *parser, shunt *sy, bool functions_only) { - if (!sy->ops_count) { + 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[sy->ops_count-1].paren == 1) { + if (sy->ops[vec_size(sy->ops)-1].paren == 1) { parseerror(parser, "empty parenthesis expression"); return false; } */ - while (sy->ops_count) { - if (sy->ops[sy->ops_count-1].paren == SY_PAREN_FUNC) { + 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[sy->ops_count-1].paren == SY_PAREN_EXPR) { - sy->ops_count--; + if (sy->ops[vec_size(sy->ops)-1].paren == SY_PAREN_EXPR) { + vec_shrinkby(sy->ops, 1); return !functions_only; } - if (sy->ops[sy->ops_count-1].paren == SY_PAREN_INDEX) { + if (sy->ops[vec_size(sy->ops)-1].paren == SY_PAREN_INDEX) { if (functions_only) return false; /* pop off the parenthesis */ - sy->ops_count--; + vec_shrinkby(sy->ops, 1); /* then apply the index operator */ if (!parser_sy_pop(parser, sy)) return false; @@ -1037,9 +1139,10 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma * end of a condition is an unmatched closing paren */ int parens = 0; + int ternaries = 0; - MEM_VECTOR_INIT(&sy, out); - MEM_VECTOR_INIT(&sy, ops); + sy.out = NULL; + sy.ops = NULL; parser->lex->flags.noops = false; @@ -1091,11 +1194,8 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma } if (ast_istype(var, ast_value)) ((ast_value*)var)->uses++; - if (!shunt_out_add(&sy, syexp(parser_ctx(parser), var))) { - parseerror(parser, "out of memory"); - goto onerr; - } - DEBUGSHUNTDO(printf("push %s\n", parser_tokval(parser))); + vec_push(sy.out, syexp(parser_ctx(parser), var)); + DEBUGSHUNTDO(con_out("push %s\n", parser_tokval(parser))); } else if (parser->tok == TOKEN_FLOATCONST) { ast_value *val; @@ -1107,11 +1207,8 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma val = parser_const_float(parser, (parser_token(parser)->constval.f)); if (!val) return false; - if (!shunt_out_add(&sy, syexp(parser_ctx(parser), (ast_expression*)val))) { - parseerror(parser, "out of memory"); - goto onerr; - } - DEBUGSHUNTDO(printf("push %g\n", parser_token(parser)->constval.f)); + vec_push(sy.out, syexp(parser_ctx(parser), (ast_expression*)val)); + DEBUGSHUNTDO(con_out("push %g\n", parser_token(parser)->constval.f)); } else if (parser->tok == TOKEN_INTCONST) { ast_value *val; @@ -1123,11 +1220,8 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma val = parser_const_float(parser, (double)(parser_token(parser)->constval.i)); if (!val) return false; - if (!shunt_out_add(&sy, syexp(parser_ctx(parser), (ast_expression*)val))) { - parseerror(parser, "out of memory"); - goto onerr; - } - DEBUGSHUNTDO(printf("push %i\n", parser_token(parser)->constval.i)); + vec_push(sy.out, syexp(parser_ctx(parser), (ast_expression*)val)); + DEBUGSHUNTDO(con_out("push %i\n", parser_token(parser)->constval.i)); } else if (parser->tok == TOKEN_STRINGCONST) { ast_value *val; @@ -1139,11 +1233,8 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma val = parser_const_string(parser, parser_tokval(parser)); if (!val) return false; - if (!shunt_out_add(&sy, syexp(parser_ctx(parser), (ast_expression*)val))) { - parseerror(parser, "out of memory"); - goto onerr; - } - DEBUGSHUNTDO(printf("push string\n")); + vec_push(sy.out, syexp(parser_ctx(parser), (ast_expression*)val)); + DEBUGSHUNTDO(con_out("push string\n")); } else if (parser->tok == TOKEN_VECTORCONST) { ast_value *val; @@ -1155,11 +1246,8 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma val = parser_const_vector(parser, parser_token(parser)->constval.v); if (!val) return false; - if (!shunt_out_add(&sy, syexp(parser_ctx(parser), (ast_expression*)val))) { - parseerror(parser, "out of memory"); - goto onerr; - } - DEBUGSHUNTDO(printf("push '%g %g %g'\n", + 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)); @@ -1174,7 +1262,7 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma } else if (parser->tok == ')') { if (wantop) { - DEBUGSHUNTDO(printf("do[op] )\n")); + DEBUGSHUNTDO(con_out("do[op] )\n")); --parens; if (parens < 0) break; @@ -1183,7 +1271,7 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma if (!parser_close_paren(parser, &sy, false)) goto onerr; } else { - DEBUGSHUNTDO(printf("do[nop] )\n")); + DEBUGSHUNTDO(con_out("do[nop] )\n")); --parens; if (parens < 0) break; @@ -1213,13 +1301,12 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma else { /* classify the operator */ - /* TODO: suffix operators */ const oper_info *op; const oper_info *olast = NULL; size_t o; for (o = 0; o < operator_count; ++o) { if ((!(operators[o].flags & OP_PREFIX) == wantop) && - !(operators[o].flags & OP_SUFFIX) && /* remove this */ + /* !(operators[o].flags & OP_SUFFIX) && / * remove this */ !strcmp(parser_tokval(parser), operators[o].op)) { break; @@ -1239,8 +1326,14 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma break; } - if (sy.ops_count && !sy.ops[sy.ops_count-1].paren) - olast = &operators[sy.ops[sy.ops_count-1].etype-1]; + /* a colon without a pervious question mark cannot be a ternary */ + if (!ternaries && op->id == opid2(':','?')) { + parser->tok = ':'; + break; + } + + if (vec_size(sy.ops) && !vec_last(sy.ops).paren) + olast = &operators[vec_last(sy.ops).etype-1]; while (olast && ( (op->prec < olast->prec) || @@ -1248,15 +1341,15 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma { if (!parser_sy_pop(parser, &sy)) goto onerr; - if (sy.ops_count && !sy.ops[sy.ops_count-1].paren) - olast = &operators[sy.ops[sy.ops_count-1].etype-1]; + if (vec_size(sy.ops) && !vec_last(sy.ops).paren) + 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 = sy.out[sy.out_count-1].out; + ast_expression *prevex = vec_last(sy.out).out; if (!prevex) { parseerror(parser, "unexpected member operator"); goto onerr; @@ -1274,20 +1367,15 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma if (op->id == opid1('(')) { if (wantop) { - DEBUGSHUNTDO(printf("push [op] (\n")); + size_t sycount = vec_size(sy.out); + DEBUGSHUNTDO(con_out("push [op] (\n")); ++parens; /* we expected an operator, this is the function-call operator */ - if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), SY_PAREN_FUNC, sy.out_count-1))) { - parseerror(parser, "out of memory"); - goto onerr; - } + vec_push(sy.ops, syparen(parser_ctx(parser), SY_PAREN_FUNC, sycount-1)); } else { ++parens; - if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), SY_PAREN_EXPR, 0))) { - parseerror(parser, "out of memory"); - goto onerr; - } - DEBUGSHUNTDO(printf("push [nop] (\n")); + vec_push(sy.ops, syparen(parser_ctx(parser), SY_PAREN_EXPR, 0)); + DEBUGSHUNTDO(con_out("push [nop] (\n")); } wantop = false; } else if (op->id == opid1('[')) { @@ -1297,46 +1385,54 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma } ++parens; /* push both the operator and the paren, this makes life easier */ - if (!shunt_ops_add(&sy, syop(parser_ctx(parser), op))) - goto onerr; - if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), SY_PAREN_INDEX, 0))) - goto onerr; + vec_push(sy.ops, syop(parser_ctx(parser), op)); + vec_push(sy.ops, syparen(parser_ctx(parser), SY_PAREN_INDEX, 0)); wantop = false; - } else { - DEBUGSHUNTDO(printf("push operator %s\n", op->op)); - if (!shunt_ops_add(&sy, syop(parser_ctx(parser), op))) - goto onerr; + } else if (op->id == opid2('?',':')) { + wantop = false; + vec_push(sy.ops, syop(parser_ctx(parser), op)); + wantop = false; + --ternaries; + } else if (op->id == opid2(':','?')) { + /* we don't push this operator */ 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); } } if (!parser_next(parser)) { goto onerr; } - if (parser->tok == ';' || (!parens && parser->tok == ']')) { + if (parser->tok == ';' || + (!parens && parser->tok == ']')) + { break; } } - while (sy.ops_count) { + while (vec_size(sy.ops)) { if (!parser_sy_pop(parser, &sy)) goto onerr; } parser->lex->flags.noops = true; - if (!sy.out_count) { + if (!vec_size(sy.out)) { parseerror(parser, "empty expression"); expr = NULL; } else expr = sy.out[0].out; - MEM_VECTOR_CLEAR(&sy, out); - MEM_VECTOR_CLEAR(&sy, ops); - DEBUGSHUNTDO(printf("shunt done\n")); + vec_free(sy.out); + vec_free(sy.ops); + DEBUGSHUNTDO(con_out("shunt done\n")); return expr; onerr: parser->lex->flags.noops = true; - MEM_VECTOR_CLEAR(&sy, out); - MEM_VECTOR_CLEAR(&sy, ops); + vec_free(sy.out); + vec_free(sy.ops); return NULL; } @@ -1356,11 +1452,25 @@ static bool parse_if(parser_t *parser, ast_block *block, ast_expression **out) { ast_ifthen *ifthen; ast_expression *cond, *ontrue, *onfalse = NULL; + bool ifnot = false; lex_ctx ctx = parser_ctx(parser); - /* skip the 'if' and check for opening paren */ - if (!parser_next(parser) || parser->tok != '(') { + (void)block; /* not touching */ + + /* skip the 'if', parse an optional 'not' and check for an opening paren */ + if (!parser_next(parser)) { + parseerror(parser, "expected condition or 'not'"); + return false; + } + if (parser->tok == TOKEN_KEYWORD && !strcmp(parser_tokval(parser), "not")) { + ifnot = true; + if (!parser_next(parser)) { + parseerror(parser, "expected condition in parenthesis"); + return false; + } + } + if (parser->tok != '(') { parseerror(parser, "expected 'if' condition in parenthesis"); return false; } @@ -1407,7 +1517,10 @@ static bool parse_if(parser_t *parser, ast_block *block, ast_expression **out) } } - ifthen = ast_ifthen_new(ctx, cond, ontrue, onfalse); + if (ifnot) + ifthen = ast_ifthen_new(ctx, cond, onfalse, ontrue); + else + ifthen = ast_ifthen_new(ctx, cond, ontrue, onfalse); *out = (ast_expression*)ifthen; return true; } @@ -1419,6 +1532,8 @@ static bool parse_while(parser_t *parser, ast_block *block, ast_expression **out lex_ctx ctx = parser_ctx(parser); + (void)block; /* not touching */ + /* skip the 'while' and check for opening paren */ if (!parser_next(parser) || parser->tok != '(') { parseerror(parser, "expected 'while' condition in parenthesis"); @@ -1463,6 +1578,8 @@ static bool parse_dowhile(parser_t *parser, ast_block *block, ast_expression **o lex_ctx ctx = parser_ctx(parser); + (void)block; /* not touching */ + /* skip the 'do' and get the body */ if (!parser_next(parser)) { parseerror(parser, "expected loop body"); @@ -1534,7 +1651,7 @@ static bool parse_for(parser_t *parser, ast_block *block, ast_expression **out) lex_ctx ctx = parser_ctx(parser); oldblocklocal = parser->blocklocal; - parser->blocklocal = parser->locals_count; + parser->blocklocal = vec_size(parser->locals); initexpr = NULL; cond = NULL; @@ -1630,7 +1747,7 @@ static bool parse_for(parser_t *parser, ast_block *block, ast_expression **out) aloop = ast_loop_new(ctx, initexpr, cond, NULL, increment, ontrue); *out = (ast_expression*)aloop; - while (parser->locals_count > parser->blocklocal) + while (vec_size(parser->locals) > parser->blocklocal) retval = retval && parser_pop_local(parser); parser->blocklocal = oldblocklocal; return retval; @@ -1638,13 +1755,220 @@ onerr: if (initexpr) ast_delete(initexpr); if (cond) ast_delete(cond); if (increment) ast_delete(increment); - while (parser->locals_count > parser->blocklocal) + while (vec_size(parser->locals) > parser->blocklocal) (void)!parser_pop_local(parser); parser->blocklocal = oldblocklocal; return false; } -static bool parse_statement(parser_t *parser, ast_block *block, ast_expression **out) +static bool parse_return(parser_t *parser, ast_block *block, ast_expression **out) +{ + ast_expression *exp = NULL; + ast_return *ret = NULL; + ast_value *expected = parser->function->vtype; + + (void)block; /* not touching */ + + if (!parser_next(parser)) { + parseerror(parser, "expected return expression"); + return false; + } + + if (parser->tok != ';') { + exp = parse_expression(parser, false); + if (!exp) + return false; + + if (exp->expression.vtype != expected->expression.next->expression.vtype) { + parseerror(parser, "return with invalid expression"); + } + + ret = ast_return_new(exp->expression.node.context, exp); + if (!ret) { + ast_delete(exp); + return false; + } + } else { + if (!parser_next(parser)) + parseerror(parser, "parse error"); + if (expected->expression.next->expression.vtype != TYPE_VOID) { + if (opts_standard != COMPILER_GMQCC) + (void)!parsewarning(parser, WARN_MISSING_RETURN_VALUES, "return without value"); + else + parseerror(parser, "return without value"); + } + ret = ast_return_new(parser_ctx(parser), NULL); + } + *out = (ast_expression*)ret; + return true; +} + +static bool parse_break_continue(parser_t *parser, ast_block *block, ast_expression **out, bool is_continue) +{ + lex_ctx ctx = parser_ctx(parser); + + (void)block; /* not touching */ + + if (!parser_next(parser) || parser->tok != ';') { + parseerror(parser, "expected semicolon"); + return false; + } + + if (!parser_next(parser)) + parseerror(parser, "parse error"); + + *out = (ast_expression*)ast_breakcont_new(ctx, is_continue); + return true; +} + +static bool parse_switch(parser_t *parser, ast_block *block, ast_expression **out) +{ + ast_expression *operand; + ast_value *opval; + ast_switch *switchnode; + ast_switch_case swcase; + + lex_ctx ctx = parser_ctx(parser); + + (void)block; /* not touching */ + + /* parse over the opening paren */ + if (!parser_next(parser) || parser->tok != '(') { + parseerror(parser, "expected switch operand in parenthesis"); + return false; + } + + /* parse into the expression */ + if (!parser_next(parser)) { + parseerror(parser, "expected switch operand"); + return false; + } + /* parse the operand */ + operand = parse_expression_leave(parser, false); + if (!operand) + return false; + + if (!OPTS_FLAG(RELAXED_SWITCH)) { + opval = (ast_value*)operand; + if (!ast_istype(operand, ast_value) || !opval->isconst) { + parseerror(parser, "case on non-constant values need to be explicitly enabled via -frelaxed-switch"); + ast_unref(operand); + return false; + } + } + + switchnode = ast_switch_new(ctx, operand); + + /* closing paren */ + if (parser->tok != ')') { + ast_delete(switchnode); + parseerror(parser, "expected closing paren after 'switch' operand"); + return false; + } + + /* parse over the opening paren */ + if (!parser_next(parser) || parser->tok != '{') { + ast_delete(switchnode); + parseerror(parser, "expected list of cases"); + return false; + } + + if (!parser_next(parser)) { + ast_delete(switchnode); + parseerror(parser, "expected 'case' or 'default'"); + return false; + } + + /* case list! */ + while (parser->tok != '}') { + ast_block *caseblock; + + if (parser->tok != TOKEN_KEYWORD) { + ast_delete(switchnode); + parseerror(parser, "expected 'case' or 'default'"); + return false; + } + if (!strcmp(parser_tokval(parser), "case")) { + if (!parser_next(parser)) { + ast_delete(switchnode); + parseerror(parser, "expected expression for case"); + return false; + } + swcase.value = parse_expression_leave(parser, false); + if (!swcase.value) { + ast_delete(switchnode); + parseerror(parser, "expected expression for case"); + return false; + } + } + else if (!strcmp(parser_tokval(parser), "default")) { + swcase.value = NULL; + if (!parser_next(parser)) { + ast_delete(switchnode); + parseerror(parser, "expected colon"); + return false; + } + } + + /* Now the colon and body */ + if (parser->tok != ':') { + if (swcase.value) ast_unref(swcase.value); + ast_delete(switchnode); + parseerror(parser, "expected colon"); + return false; + } + + if (!parser_next(parser)) { + if (swcase.value) ast_unref(swcase.value); + ast_delete(switchnode); + parseerror(parser, "expected statements or case"); + return false; + } + caseblock = ast_block_new(parser_ctx(parser)); + if (!caseblock) { + if (swcase.value) ast_unref(swcase.value); + ast_delete(switchnode); + return false; + } + swcase.code = (ast_expression*)caseblock; + vec_push(switchnode->cases, swcase); + while (true) { + ast_expression *expr; + if (parser->tok == '}') + break; + if (parser->tok == TOKEN_KEYWORD) { + if (!strcmp(parser_tokval(parser), "case") || + !strcmp(parser_tokval(parser), "default")) + { + break; + } + } + if (!parse_statement(parser, caseblock, &expr, true)) { + ast_delete(switchnode); + return false; + } + if (!expr) + continue; + vec_push(caseblock->exprs, expr); + } + } + + /* closing paren */ + if (parser->tok != '}') { + ast_delete(switchnode); + parseerror(parser, "expected closing paren of case list"); + return false; + } + if (!parser_next(parser)) { + ast_delete(switchnode); + parseerror(parser, "parse error after switch"); + return false; + } + *out = (ast_expression*)switchnode; + return true; +} + +static bool parse_statement(parser_t *parser, ast_block *block, ast_expression **out, bool allow_cases) { if (parser->tok == TOKEN_TYPENAME || parser->tok == '.') { @@ -1681,42 +2005,7 @@ static bool parse_statement(parser_t *parser, ast_block *block, ast_expression * } else if (!strcmp(parser_tokval(parser), "return")) { - ast_expression *exp = NULL; - ast_return *ret = NULL; - ast_value *expected = parser->function->vtype; - - if (!parser_next(parser)) { - parseerror(parser, "expected return expression"); - return false; - } - - if (parser->tok != ';') { - exp = parse_expression(parser, false); - if (!exp) - return false; - - if (exp->expression.vtype != expected->expression.next->expression.vtype) { - parseerror(parser, "return with invalid expression"); - } - - ret = ast_return_new(exp->expression.node.context, exp); - if (!ret) { - ast_delete(exp); - return false; - } - } else { - if (!parser_next(parser)) - parseerror(parser, "parse error"); - if (expected->expression.next->expression.vtype != TYPE_VOID) { - if (opts_standard != COMPILER_GMQCC) - (void)!parsewarning(parser, WARN_MISSING_RETURN_VALUES, "return without value"); - else - parseerror(parser, "return without value"); - } - ret = ast_return_new(parser_ctx(parser), NULL); - } - *out = (ast_expression*)ret; - return true; + return parse_return(parser, block, out); } else if (!strcmp(parser_tokval(parser), "if")) { @@ -1738,6 +2027,27 @@ static bool parse_statement(parser_t *parser, ast_block *block, ast_expression * } return parse_for(parser, block, out); } + else if (!strcmp(parser_tokval(parser), "break")) + { + return parse_break_continue(parser, block, out, false); + } + else if (!strcmp(parser_tokval(parser), "continue")) + { + return parse_break_continue(parser, block, out, true); + } + else if (!strcmp(parser_tokval(parser), "switch")) + { + return parse_switch(parser, block, out); + } + else if (!strcmp(parser_tokval(parser), "case") || + !strcmp(parser_tokval(parser), "default")) + { + if (!allow_cases) { + parseerror(parser, "unexpected 'case' label"); + return false; + } + return true; + } parseerror(parser, "Unexpected keyword"); return false; } @@ -1769,16 +2079,19 @@ static bool parse_statement(parser_t *parser, ast_block *block, ast_expression * static bool GMQCC_WARN parser_pop_local(parser_t *parser) { + bool rv = true; varentry_t *ve; - parser->locals_count--; - ve = &parser->locals[parser->locals_count]; - if (ast_istype(ve->var, ast_value) && !(((ast_value*)(ve->var))->uses)) { - if (parsewarning(parser, WARN_UNUSED_VARIABLE, "unused variable: `%s`", ve->name)) - return false; + ve = &vec_last(parser->locals); + if (!parser->errors) { + if (ast_istype(ve->var, ast_value) && !(((ast_value*)(ve->var))->uses)) { + if (parsewarning(parser, WARN_UNUSED_VARIABLE, "unused variable: `%s`", ve->name)) + rv = false; + } } - mem_d(parser->locals[parser->locals_count].name); - return true; + mem_d(ve->name); + vec_pop(parser->locals); + return rv; } static bool parse_block_into(parser_t *parser, ast_block *block, bool warnreturn) @@ -1787,7 +2100,7 @@ static bool parse_block_into(parser_t *parser, ast_block *block, bool warnreturn bool retval = true; oldblocklocal = parser->blocklocal; - parser->blocklocal = parser->locals_count; + parser->blocklocal = vec_size(parser->locals); if (!parser_next(parser)) { /* skip the '{' */ parseerror(parser, "expected function body"); @@ -1800,18 +2113,14 @@ static bool parse_block_into(parser_t *parser, ast_block *block, bool warnreturn if (parser->tok == '}') break; - if (!parse_statement(parser, block, &expr)) { + if (!parse_statement(parser, block, &expr, false)) { /* parseerror(parser, "parse error"); */ block = NULL; goto cleanup; } if (!expr) continue; - if (!ast_block_exprs_add(block, expr)) { - ast_delete(expr); - block = NULL; - goto cleanup; - } + vec_push(block->exprs, expr); } if (parser->tok != '}') { @@ -1819,8 +2128,8 @@ static bool parse_block_into(parser_t *parser, ast_block *block, bool warnreturn } else { if (warnreturn && parser->function->vtype->expression.next->expression.vtype != TYPE_VOID) { - if (!block->exprs_count || - !ast_istype(block->exprs[block->exprs_count-1], ast_return)) + if (!vec_size(block->exprs) || + !ast_istype(vec_last(block->exprs), ast_return)) { if (parsewarning(parser, WARN_MISSING_RETURN_VALUES, "control reaches end of non-void function")) { block = NULL; @@ -1832,7 +2141,7 @@ static bool parse_block_into(parser_t *parser, ast_block *block, bool warnreturn } cleanup: - while (parser->locals_count > parser->blocklocal) + while (vec_size(parser->locals) > parser->blocklocal) retval = retval && parser_pop_local(parser); parser->blocklocal = oldblocklocal; return !!block; @@ -1856,13 +2165,13 @@ static ast_expression* parse_statement_or_block(parser_t *parser) ast_expression *expr = NULL; if (parser->tok == '{') return (ast_expression*)parse_block(parser, false); - if (!parse_statement(parser, NULL, &expr)) + if (!parse_statement(parser, NULL, &expr, false)) return NULL; return expr; } /* loop method */ -static bool create_vector_members(parser_t *parser, ast_value *var, varentry_t *ve) +static bool create_vector_members(ast_value *var, varentry_t *ve) { size_t i; size_t len = strlen(var->name); @@ -1998,11 +2307,7 @@ static bool parse_function_body(parser_t *parser, ast_value *var) varent.var = (ast_expression*)thinkfunc; varent.name = util_strdup(thinkfunc->name); - if (!parser_t_globals_add(parser, varent)) { - ast_unref(framenum); - ast_delete(thinkfunc); - return false; - } + vec_push(parser->globals, varent); nextthink = (ast_expression*)thinkfunc; } else { @@ -2102,25 +2407,10 @@ static bool parse_function_body(parser_t *parser, ast_value *var) if (store_think) ast_delete(store_think); retval = false; } - if (retval && !ast_block_exprs_add(block, (ast_expression*)store_frame)) { - ast_delete(store_frame); - ast_delete(store_nextthink); - ast_delete(store_think); - retval = false; - } - - if (retval && !ast_block_exprs_add(block, (ast_expression*)store_nextthink)) { - ast_delete(store_nextthink); - ast_delete(store_think); - retval = false; - } - - if (retval && !ast_block_exprs_add(block, (ast_expression*)store_think) ) - { - ast_delete(store_think); - retval = false; - } - } + vec_push(block->exprs, (ast_expression*)store_frame); + vec_push(block->exprs, (ast_expression*)store_nextthink); + vec_push(block->exprs, (ast_expression*)store_think); + } if (!retval) { parseerror(parser, "failed to generate code for [frame,think]"); @@ -2131,7 +2421,7 @@ static bool parse_function_body(parser_t *parser, ast_value *var) } } - for (parami = 0; parami < var->expression.params_count; ++parami) { + for (parami = 0; parami < vec_size(var->expression.params); ++parami) { size_t e; varentry_t ve[3]; ast_value *param = var->expression.params[parami]; @@ -2143,29 +2433,16 @@ static bool parse_function_body(parser_t *parser, ast_value *var) continue; } - if (!create_vector_members(parser, param, ve)) { + if (!create_vector_members(param, ve)) { ast_block_delete(block); return false; } for (e = 0; e < 3; ++e) { - if (!parser_t_locals_add(parser, ve[e])) - break; - if (!ast_block_collect(block, ve[e].var)) { - parser->locals_count--; - break; - } + vec_push(parser->locals, ve[e]); + ast_block_collect(block, ve[e].var); ve[e].var = NULL; /* collected */ } - if (e != 3) { - parser->locals -= e; - do { - mem_d(ve[e].name); - --e; - } while (e); - ast_block_delete(block); - return false; - } } func = ast_function_new(ast_ctx(var), var->name, var); @@ -2174,25 +2451,18 @@ static bool parse_function_body(parser_t *parser, ast_value *var) ast_block_delete(block); goto enderr; } - if (!parser_t_functions_add(parser, func)) { - parseerror(parser, "failed to allocate slot for function `%s`", var->name); - ast_block_delete(block); - goto enderrfn; - } + vec_push(parser->functions, func); parser->function = func; if (!parse_block_into(parser, block, true)) { ast_block_delete(block); - goto enderrfn2; + goto enderrfn; } - if (!ast_function_blocks_add(func, block)) { - ast_block_delete(block); - goto enderrfn2; - } + vec_push(func->blocks, block); parser->function = old; - while (parser->locals_count) + while (vec_size(parser->locals)) retval = retval && parser_pop_local(parser); if (parser->tok == ';') @@ -2201,30 +2471,70 @@ static bool parse_function_body(parser_t *parser, ast_value *var) parseerror(parser, "missing semicolon after function body (mandatory with -std=qcc)"); return retval; -enderrfn2: - parser->functions_count--; enderrfn: + vec_pop(parser->functions); ast_function_delete(func); var->constval.vfunc = NULL; enderr: - while (parser->locals_count) { - parser->locals_count--; - mem_d(parser->locals[parser->locals_count].name); + while (vec_size(parser->locals)) { + mem_d(vec_last(parser->locals).name); + vec_pop(parser->locals); } parser->function = old; return false; } +static ast_expression *array_accessor_split( + parser_t *parser, + ast_value *array, + ast_value *index, + size_t middle, + ast_expression *left, + ast_expression *right + ) +{ + ast_ifthen *ifthen; + ast_binary *cmp; + + lex_ctx ctx = ast_ctx(array); + + if (!left || !right) { + if (left) ast_delete(left); + if (right) ast_delete(right); + return NULL; + } + + cmp = ast_binary_new(ctx, INSTR_LT, + (ast_expression*)index, + (ast_expression*)parser_const_float(parser, middle)); + if (!cmp) { + ast_delete(left); + ast_delete(right); + parseerror(parser, "internal error: failed to create comparison for array setter"); + return NULL; + } + + ifthen = ast_ifthen_new(ctx, (ast_expression*)cmp, left, right); + if (!ifthen) { + ast_delete(cmp); /* will delete left and right */ + parseerror(parser, "internal error: failed to create conditional jump for array setter"); + return NULL; + } + + return (ast_expression*)ifthen; +} + static ast_expression *array_setter_node(parser_t *parser, ast_value *array, ast_value *index, ast_value *value, size_t from, size_t afterend) { lex_ctx ctx = ast_ctx(array); if (from+1 == afterend) { - // set this value + /* set this value */ ast_block *block; ast_return *ret; ast_array_index *subscript; + ast_store *st; int assignop = type_store_instr[value->expression.vtype]; if (value->expression.vtype == TYPE_FIELD && value->expression.next->expression.vtype == TYPE_VECTOR) @@ -2234,7 +2544,7 @@ static ast_expression *array_setter_node(parser_t *parser, ast_value *array, ast if (!subscript) return NULL; - ast_store *st = ast_store_new(ctx, assignop, (ast_expression*)subscript, (ast_expression*)value); + st = ast_store_new(ctx, assignop, (ast_expression*)subscript, (ast_expression*)value); if (!st) { ast_delete(subscript); return NULL; @@ -2246,10 +2556,7 @@ static ast_expression *array_setter_node(parser_t *parser, ast_value *array, ast return NULL; } - if (!ast_block_exprs_add(block, (ast_expression*)st)) { - ast_delete(block); - return NULL; - } + vec_push(block->exprs, (ast_expression*)st); ret = ast_return_new(ctx, NULL); if (!ret) { @@ -2257,46 +2564,85 @@ static ast_expression *array_setter_node(parser_t *parser, ast_value *array, ast return NULL; } - if (!ast_block_exprs_add(block, (ast_expression*)ret)) { - ast_delete(block); - return NULL; - } + vec_push(block->exprs, (ast_expression*)ret); return (ast_expression*)block; } else { - ast_ifthen *ifthen; ast_expression *left, *right; - ast_binary *cmp; - size_t diff = afterend - from; size_t middle = from + diff/2; - left = array_setter_node(parser, array, index, value, from, middle); right = array_setter_node(parser, array, index, value, middle, afterend); - if (!left || !right) { - if (left) ast_delete(left); - if (right) ast_delete(right); + return array_accessor_split(parser, array, index, middle, left, right); + } +} + +static ast_expression *array_field_setter_node( + parser_t *parser, + ast_value *array, + ast_value *entity, + ast_value *index, + ast_value *value, + size_t from, + size_t afterend) +{ + lex_ctx ctx = ast_ctx(array); + + if (from+1 == afterend) { + /* set this value */ + ast_block *block; + ast_return *ret; + ast_entfield *entfield; + ast_array_index *subscript; + ast_store *st; + int assignop = type_storep_instr[value->expression.vtype]; + + if (value->expression.vtype == TYPE_FIELD && value->expression.next->expression.vtype == TYPE_VECTOR) + assignop = INSTR_STOREP_V; + + subscript = ast_array_index_new(ctx, (ast_expression*)array, (ast_expression*)parser_const_float(parser, from)); + if (!subscript) + return NULL; + + entfield = ast_entfield_new_force(ctx, + (ast_expression*)entity, + (ast_expression*)subscript, + (ast_expression*)subscript); + if (!entfield) { + ast_delete(subscript); return NULL; } - cmp = ast_binary_new(ctx, INSTR_LT, - (ast_expression*)index, - (ast_expression*)parser_const_float(parser, from + diff/2)); - if (!cmp) { - ast_delete(left); - ast_delete(right); - parseerror(parser, "internal error: failed to create comparison for array setter"); + st = ast_store_new(ctx, assignop, (ast_expression*)entfield, (ast_expression*)value); + if (!st) { + ast_delete(entfield); return NULL; } - ifthen = ast_ifthen_new(ctx, (ast_expression*)cmp, left, right); - if (!ifthen) { - ast_delete(cmp); /* will delete left and right */ - parseerror(parser, "internal error: failed to create conditional jump for array setter"); + block = ast_block_new(ctx); + if (!block) { + ast_delete(st); return NULL; } - return (ast_expression*)ifthen; + vec_push(block->exprs, (ast_expression*)st); + + ret = ast_return_new(ctx, NULL); + if (!ret) { + ast_delete(block); + return NULL; + } + + vec_push(block->exprs, (ast_expression*)ret); + + return (ast_expression*)block; + } else { + ast_expression *left, *right; + size_t diff = afterend - from; + size_t middle = from + diff/2; + left = array_field_setter_node(parser, array, entity, index, value, from, middle); + right = array_field_setter_node(parser, array, entity, index, value, middle, afterend); + return array_accessor_split(parser, array, index, middle, left, right); } } @@ -2320,71 +2666,78 @@ static ast_expression *array_getter_node(parser_t *parser, ast_value *array, ast return (ast_expression*)ret; } else { - ast_ifthen *ifthen; ast_expression *left, *right; - ast_binary *cmp; - size_t diff = afterend - from; size_t middle = from + diff/2; - left = array_getter_node(parser, array, index, from, middle); right = array_getter_node(parser, array, index, middle, afterend); - if (!left || !right) { - if (left) ast_delete(left); - if (right) ast_delete(right); - return NULL; - } + return array_accessor_split(parser, array, index, middle, left, right); + } +} - cmp = ast_binary_new(ctx, INSTR_LT, - (ast_expression*)index, - (ast_expression*)parser_const_float(parser, from + diff/2)); - if (!cmp) { - ast_delete(left); - ast_delete(right); - parseerror(parser, "internal error: failed to create comparison for array setter"); - return NULL; - } +static bool parser_create_array_accessor(parser_t *parser, ast_value *array, const char *funcname, ast_value **out) +{ + ast_function *func = NULL; + ast_value *fval = NULL; + ast_block *body = NULL; - ifthen = ast_ifthen_new(ctx, (ast_expression*)cmp, left, right); - if (!ifthen) { - ast_delete(cmp); /* will delete left and right */ - parseerror(parser, "internal error: failed to create conditional jump for array setter"); - return NULL; - } + fval = ast_value_new(ast_ctx(array), funcname, TYPE_FUNCTION); + if (!fval) { + parseerror(parser, "failed to create accessor function value"); + return false; + } + + func = ast_function_new(ast_ctx(array), funcname, fval); + if (!func) { + ast_delete(fval); + parseerror(parser, "failed to create accessor function node"); + return false; + } - return (ast_expression*)ifthen; + body = ast_block_new(ast_ctx(array)); + if (!body) { + parseerror(parser, "failed to create block for array accessor"); + ast_delete(fval); + ast_delete(func); + return false; } + + vec_push(func->blocks, body); + *out = fval; + + vec_push(parser->accessors, fval); + + return true; } static bool parser_create_array_setter(parser_t *parser, ast_value *array, const char *funcname) { ast_expression *root = NULL; - ast_function *func = NULL; - ast_value *fval = NULL; - ast_block *body; - ast_value *index, *value; + ast_value *index = NULL; + ast_value *value = NULL; + ast_function *func; + ast_value *fval; 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; } - body = ast_block_new(ast_ctx(array)); - if (!body) { - parseerror(parser, "failed to create block for array accessor"); + if (!parser_create_array_accessor(parser, array, funcname, &fval)) return false; - } + func = fval->constval.vfunc; + fval->expression.next = (ast_expression*)ast_value_new(ast_ctx(array), "", TYPE_VOID); index = ast_value_new(ast_ctx(array), "index", TYPE_FLOAT); value = ast_value_copy((ast_value*)array->expression.next); if (!index || !value) { - ast_delete(body); - if (index) ast_delete(index); - if (value) ast_delete(value); parseerror(parser, "failed to create locals for array accessor"); - return false; + goto cleanup; } + (void)!ast_value_set_name(value, "value"); /* not important */ + 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) { @@ -2392,79 +2745,95 @@ static bool parser_create_array_setter(parser_t *parser, ast_value *array, const goto cleanup; } - if (!ast_block_exprs_add(body, root)) { - parseerror(parser, "failed to build accessor search block"); - goto cleanup; - } + vec_push(func->blocks[0]->exprs, root); + array->setter = fval; + return true; +cleanup: + if (index) ast_delete(index); + if (value) ast_delete(value); + if (root) ast_delete(root); + ast_delete(func); + ast_delete(fval); + return false; +} - fval = ast_value_new(ast_ctx(array), funcname, TYPE_FUNCTION); - if (!fval) { - parseerror(parser, "failed to create accessor function value"); - goto cleanup; +static bool parser_create_array_field_setter(parser_t *parser, ast_value *array, const char *funcname) +{ + ast_expression *root = NULL; + ast_value *entity = NULL; + ast_value *index = NULL; + ast_value *value = NULL; + ast_function *func; + ast_value *fval; + + 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; } + + if (!parser_create_array_accessor(parser, array, funcname, &fval)) + return false; + func = fval->constval.vfunc; fval->expression.next = (ast_expression*)ast_value_new(ast_ctx(array), "", TYPE_VOID); - (void)!ast_value_set_name(value, "value"); /* not important */ - if (!ast_expression_common_params_add(&fval->expression, index)) { - parseerror(parser, "failed to build array setter"); + entity = ast_value_new(ast_ctx(array), "entity", TYPE_ENTITY); + index = ast_value_new(ast_ctx(array), "index", TYPE_FLOAT); + value = ast_value_copy((ast_value*)array->expression.next); + if (!entity || !index || !value) { + parseerror(parser, "failed to create locals for array accessor"); goto cleanup; } - if (!ast_expression_common_params_add(&fval->expression, value)) { - ast_delete(index); - parseerror(parser, "failed to build array setter"); - goto cleanup2; - } + (void)!ast_value_set_name(value, "value"); /* not important */ + vec_push(fval->expression.params, entity); + vec_push(fval->expression.params, index); + vec_push(fval->expression.params, value); - func = ast_function_new(ast_ctx(array), funcname, fval); - if (!func) { - parseerror(parser, "failed to create accessor function node"); - goto cleanup2; + root = array_field_setter_node(parser, array, entity, index, value, 0, array->expression.count); + if (!root) { + parseerror(parser, "failed to build accessor search tree"); + goto cleanup; } - if (!ast_function_blocks_add(func, body)) - goto cleanup2; - + vec_push(func->blocks[0]->exprs, root); array->setter = fval; - return true; cleanup: - ast_delete(index); - ast_delete(value); -cleanup2: - ast_delete(body); - if (root) ast_delete(root); - if (func) ast_delete(func); - if (fval) ast_delete(fval); + if (entity) ast_delete(entity); + if (index) ast_delete(index); + if (value) ast_delete(value); + if (root) ast_delete(root); + ast_delete(func); + ast_delete(fval); return false; } -static bool parser_create_array_getter(parser_t *parser, ast_value *array, const char *funcname) +static bool parser_create_array_getter(parser_t *parser, ast_value *array, const ast_expression *elemtype, const char *funcname) { ast_expression *root = NULL; - ast_function *func = NULL; - ast_value *fval = NULL; - ast_block *body; - ast_value *index; + ast_value *index = NULL; + ast_value *fval; + ast_function *func; + /* NOTE: checking array->expression.next rather than elemtype since + * for fields elemtype is a temporary fieldtype. + */ 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; } - body = ast_block_new(ast_ctx(array)); - if (!body) { - parseerror(parser, "failed to create block for array accessor"); + if (!parser_create_array_accessor(parser, array, funcname, &fval)) return false; - } + func = fval->constval.vfunc; + fval->expression.next = ast_type_copy(ast_ctx(array), elemtype); index = ast_value_new(ast_ctx(array), "index", TYPE_FLOAT); if (!index) { - ast_delete(body); - if (index) ast_delete(index); parseerror(parser, "failed to create locals for array accessor"); - return false; + goto cleanup; } + vec_push(fval->expression.params, index); root = array_getter_node(parser, array, index, 0, array->expression.count); if (!root) { @@ -2472,56 +2841,23 @@ static bool parser_create_array_getter(parser_t *parser, ast_value *array, const goto cleanup; } - if (!ast_block_exprs_add(body, root)) { - parseerror(parser, "failed to build accessor search block"); - goto cleanup; - } - - fval = ast_value_new(ast_ctx(array), funcname, TYPE_FUNCTION); - if (!fval) { - parseerror(parser, "failed to create accessor function value"); - goto cleanup; - } - fval->expression.next = ast_type_copy(ast_ctx(array), array->expression.next); - - if (!ast_expression_common_params_add(&fval->expression, index)) { - parseerror(parser, "failed to build array setter"); - goto cleanup; - } - - func = ast_function_new(ast_ctx(array), funcname, fval); - if (!func) { - parseerror(parser, "failed to create accessor function node"); - goto cleanup2; - } - - if (!ast_function_blocks_add(func, body)) - goto cleanup2; - + vec_push(func->blocks[0]->exprs, root); array->getter = fval; - return true; cleanup: - ast_delete(index); -cleanup2: - ast_delete(body); - if (root) ast_delete(root); - if (func) ast_delete(func); - if (fval) ast_delete(fval); + if (index) ast_delete(index); + if (root) ast_delete(root); + ast_delete(func); + ast_delete(fval); return false; } -typedef struct { - MEM_VECTOR_MAKE(ast_value*, p); -} paramlist_t; -MEM_VEC_FUNCTIONS(paramlist_t, ast_value*, p) - static ast_value *parse_typename(parser_t *parser, ast_value **storebase); static ast_value *parse_parameter_list(parser_t *parser, ast_value *var) { lex_ctx ctx; size_t i; - paramlist_t params; + ast_value **params; ast_value *param; ast_value *fval; bool first = true; @@ -2535,7 +2871,7 @@ static ast_value *parse_parameter_list(parser_t *parser, ast_value *var) return NULL; } - MEM_VECTOR_INIT(¶ms, p); + params = NULL; /* parse variables until we hit a closing paren */ while (parser->tok != ')') { @@ -2570,10 +2906,7 @@ static ast_value *parse_parameter_list(parser_t *parser, ast_value *var) param = parse_typename(parser, NULL); if (!param) goto on_error; - if (!paramlist_t_p_add(¶ms, param)) { - ast_delete(param); - goto on_error; - } + vec_push(params, param); if (param->expression.vtype >= TYPE_VARIANT) { char typename[1024]; ast_type_to_string((ast_expression*)param, typename, sizeof(typename)); @@ -2584,8 +2917,8 @@ static ast_value *parse_parameter_list(parser_t *parser, ast_value *var) } /* sanity check */ - if (params.p_count > 8) - parseerror(parser, "more than 8 parameters are currently not supported"); + if (vec_size(params) > 8 && opts_standard == COMPILER_QCC) + (void)!parsewarning(parser, WARN_EXTENSIONS, "more than 8 parameters are not supported by this standard"); /* parse-out */ if (!parser_next(parser)) { @@ -2599,15 +2932,16 @@ static ast_value *parse_parameter_list(parser_t *parser, ast_value *var) fval->expression.variadic = variadic; var = fval; - MEM_VECTOR_MOVE(¶ms, p, &var->expression, params); + var->expression.params = params; + params = NULL; return var; on_error: ast_delete(var); - for (i = 0; i < params.p_count; ++i) - ast_delete(params.p[i]); - MEM_VECTOR_CLEAR(¶ms, p); + for (i = 0; i < vec_size(params); ++i) + ast_delete(params[i]); + vec_free(params); return NULL; } @@ -2870,11 +3204,11 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield /* Deal with end_sys_ vars */ was_end = false; if (!strcmp(var->name, "end_sys_globals")) { - parser->crc_globals = parser->globals_count; + parser->crc_globals = vec_size(parser->globals); was_end = true; } else if (!strcmp(var->name, "end_sys_fields")) { - parser->crc_fields = parser->fields_count; + parser->crc_fields = vec_size(parser->fields); was_end = true; } if (was_end && var->expression.vtype == TYPE_FIELD) { @@ -2939,7 +3273,7 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield goto cleanup; } /* we need the new parameter-names */ - for (i = 0; i < proto->expression.params_count; ++i) + for (i = 0; i < vec_size(proto->expression.params); ++i) ast_value_set_name(proto->expression.params[i], var->expression.params[i]->name); ast_delete(var); var = proto; @@ -3003,7 +3337,7 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield isvector = true; if (isvector) { - if (!create_vector_members(parser, var, ve)) { + if (!create_vector_members(var, ve)) { retval = false; goto cleanup; } @@ -3015,53 +3349,28 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield if (!localblock) { /* deal with global variables, fields, functions */ if (!nofields && var->expression.vtype == TYPE_FIELD) { - if (!(retval = parser_t_fields_add(parser, varent))) - goto cleanup; + vec_push(parser->fields, varent); if (isvector) { - for (i = 0; i < 3; ++i) { - if (!(retval = parser_t_fields_add(parser, ve[i]))) - break; - } - if (!retval) { - parser->fields_count -= i+1; - goto cleanup; - } + for (i = 0; i < 3; ++i) + vec_push(parser->fields, ve[i]); } } else { - if (!(retval = parser_t_globals_add(parser, varent))) - goto cleanup; + vec_push(parser->globals, varent); if (isvector) { - for (i = 0; i < 3; ++i) { - if (!(retval = parser_t_globals_add(parser, ve[i]))) - break; - } - if (!retval) { - parser->globals_count -= i+1; - goto cleanup; - } + for (i = 0; i < 3; ++i) + vec_push(parser->globals, ve[i]); } } } else { - if (!(retval = parser_t_locals_add(parser, varent))) - goto cleanup; - if (!(retval = ast_block_locals_add(localblock, var))) { - parser->locals_count--; - goto cleanup; - } + vec_push(parser->locals, varent); + vec_push(localblock->locals, var); if (isvector) { for (i = 0; i < 3; ++i) { - if (!(retval = parser_t_locals_add(parser, ve[i]))) - break; - if (!(retval = ast_block_collect(localblock, ve[i].var))) - break; + vec_push(parser->locals, ve[i]); + ast_block_collect(localblock, ve[i].var); ve[i].var = NULL; /* from here it's being collected in the block */ } - if (!retval) { - parser->locals_count -= i+1; - localblock->locals_count--; - goto cleanup; - } } } @@ -3074,14 +3383,42 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield * deal with arrays */ if (var->expression.vtype == TYPE_ARRAY) { - char name[1024]; - snprintf(name, sizeof(name), "%s::SET", var->name); + char name[1024]; + snprintf(name, sizeof(name), "%s##SET", var->name); if (!parser_create_array_setter(parser, var, name)) goto cleanup; - snprintf(name, sizeof(name), "%s::GET", var->name); - if (!parser_create_array_getter(parser, var, name)) + snprintf(name, sizeof(name), "%s##GET", var->name); + if (!parser_create_array_getter(parser, var, var->expression.next, name)) goto cleanup; } + else if (!localblock && !nofields && + var->expression.vtype == TYPE_FIELD && + var->expression.next->expression.vtype == TYPE_ARRAY) + { + char name[1024]; + ast_expression *telem; + ast_value *tfield; + ast_value *array = (ast_value*)var->expression.next; + + if (!ast_istype(var->expression.next, ast_value)) { + parseerror(parser, "internal error: field element type must be an ast_value"); + goto cleanup; + } + + snprintf(name, sizeof(name), "%s##SETF", var->name); + if (!parser_create_array_field_setter(parser, array, name)) + goto cleanup; + + telem = ast_type_copy(ast_ctx(var), array->expression.next); + tfield = ast_value_new(ast_ctx(var), "<.type>", TYPE_FIELD); + tfield->expression.next = telem; + snprintf(name, sizeof(name), "%s##GETFP", var->name); + if (!parser_create_array_getter(parser, array, (ast_expression*)tfield, name)) { + ast_delete(tfield); + goto cleanup; + } + ast_delete(tfield); + } skipvar: if (parser->tok == ';') { @@ -3154,12 +3491,7 @@ skipvar: parseerror(parser, "failed to allocate function for `%s`", var->name); break; } - if (!parser_t_functions_add(parser, func)) { - parseerror(parser, "failed to allocate slot for function `%s`", var->name); - ast_function_delete(func); - var->constval.vfunc = NULL; - break; - } + vec_push(parser->functions, func); func->builtin = -parser_token(parser)->constval.i; @@ -3203,29 +3535,19 @@ skipvar: ast_unref(cval); } } else { - shunt sy; - MEM_VECTOR_INIT(&sy, out); - MEM_VECTOR_INIT(&sy, ops); - if (!shunt_out_add(&sy, syexp(ast_ctx(var), (ast_expression*)var)) || - !shunt_out_add(&sy, syexp(ast_ctx(cexp), (ast_expression*)cexp)) || - !shunt_ops_add(&sy, syop(ast_ctx(var), parser->assign_op))) - { - parseerror(parser, "internal error: failed to prepare initializer"); - ast_unref(cexp); - } - else if (!parser_sy_pop(parser, &sy)) + shunt sy = { NULL, NULL }; + vec_push(sy.out, syexp(ast_ctx(var), (ast_expression*)var)); + vec_push(sy.out, syexp(ast_ctx(cexp), (ast_expression*)cexp)); + vec_push(sy.ops, syop(ast_ctx(var), parser->assign_op)); + if (!parser_sy_pop(parser, &sy)) ast_unref(cexp); else { - if (sy.out_count != 1 && sy.ops_count != 0) + if (vec_size(sy.out) != 1 && vec_size(sy.ops) != 0) parseerror(parser, "internal error: leaked operands"); - else if (!ast_block_exprs_add(localblock, (ast_expression*)sy.out[0].out)) { - parseerror(parser, "failed to create intializing expression"); - ast_unref(sy.out[0].out); - ast_unref(cexp); - } + vec_push(localblock->exprs, (ast_expression*)sy.out[0].out); } - MEM_VECTOR_CLEAR(&sy, out); - MEM_VECTOR_CLEAR(&sy, ops); + vec_free(sy.out); + vec_free(sy.ops); } } @@ -3316,6 +3638,79 @@ static bool parser_global_statement(parser_t *parser) return true; } +static uint16_t progdefs_crc_sum(uint16_t old, const char *str) +{ + return util_crc16(old, str, strlen(str)); +} + +static void progdefs_crc_file(const char *str) +{ + /* write to progdefs.h here */ + (void)str; +} + +static uint16_t progdefs_crc_both(uint16_t old, const char *str) +{ + old = progdefs_crc_sum(old, str); + progdefs_crc_file(str); + return old; +} + +static void generate_checksum(parser_t *parser) +{ + uint16_t crc = 0xFFFF; + size_t i; + + crc = progdefs_crc_both(crc, "\n/* file generated by qcc, do not modify */\n\ntypedef struct\n{"); + crc = progdefs_crc_sum(crc, "\tint\tpad[28];\n"); + /* + progdefs_crc_file("\tint\tpad;\n"); + progdefs_crc_file("\tint\tofs_return[3];\n"); + progdefs_crc_file("\tint\tofs_parm0[3];\n"); + progdefs_crc_file("\tint\tofs_parm1[3];\n"); + progdefs_crc_file("\tint\tofs_parm2[3];\n"); + progdefs_crc_file("\tint\tofs_parm3[3];\n"); + progdefs_crc_file("\tint\tofs_parm4[3];\n"); + progdefs_crc_file("\tint\tofs_parm5[3];\n"); + progdefs_crc_file("\tint\tofs_parm6[3];\n"); + progdefs_crc_file("\tint\tofs_parm7[3];\n"); + */ + for (i = 0; i < parser->crc_globals; ++i) { + if (!ast_istype(parser->globals[i].var, ast_value)) + continue; + switch (parser->globals[i].var->expression.vtype) { + case TYPE_FLOAT: crc = progdefs_crc_both(crc, "\tfloat\t"); break; + case TYPE_VECTOR: crc = progdefs_crc_both(crc, "\tvec3_t\t"); break; + case TYPE_STRING: crc = progdefs_crc_both(crc, "\tstring_t\t"); break; + case TYPE_FUNCTION: crc = progdefs_crc_both(crc, "\tfunc_t\t"); break; + default: + crc = progdefs_crc_both(crc, "\tint\t"); + break; + } + crc = progdefs_crc_both(crc, parser->globals[i].name); + crc = progdefs_crc_both(crc, ";\n"); + } + crc = progdefs_crc_both(crc, "} globalvars_t;\n\ntypedef struct\n{\n"); + for (i = 0; i < parser->crc_fields; ++i) { + if (!ast_istype(parser->fields[i].var, ast_value)) + continue; + switch (parser->fields[i].var->expression.next->expression.vtype) { + case TYPE_FLOAT: crc = progdefs_crc_both(crc, "\tfloat\t"); break; + case TYPE_VECTOR: crc = progdefs_crc_both(crc, "\tvec3_t\t"); break; + case TYPE_STRING: crc = progdefs_crc_both(crc, "\tstring_t\t"); break; + case TYPE_FUNCTION: crc = progdefs_crc_both(crc, "\tfunc_t\t"); break; + default: + crc = progdefs_crc_both(crc, "\tint\t"); + break; + } + crc = progdefs_crc_both(crc, parser->fields[i].name); + crc = progdefs_crc_both(crc, ";\n"); + } + crc = progdefs_crc_both(crc, "} entvars_t;\n\n"); + + code_crc = crc; +} + static parser_t *parser; bool parser_init() @@ -3341,14 +3736,8 @@ bool parser_init() return true; } -bool parser_compile(const char *filename) +bool parser_compile() { - parser->lex = lex_open(filename); - if (!parser->lex) { - printf("failed to open file \"%s\"\n", filename); - return false; - } - /* initial lexer/parser state */ parser->lex->flags.noops = true; @@ -3379,112 +3768,76 @@ bool parser_compile(const char *filename) return !parser->errors; } +bool parser_compile_file(const char *filename) +{ + parser->lex = lex_open(filename); + if (!parser->lex) { + con_err("failed to open file \"%s\"\n", filename); + return false; + } + return parser_compile(); +} + +bool parser_compile_string_len(const char *name, const char *str, size_t len) +{ + parser->lex = lex_open_string(str, len, name); + if (!parser->lex) { + con_err("failed to create lexer for string \"%s\"\n", name); + return false; + } + return parser_compile(); +} + +bool parser_compile_string(const char *name, const char *str) +{ + parser->lex = lex_open_string(str, strlen(str), name); + if (!parser->lex) { + con_err("failed to create lexer for string \"%s\"\n", name); + return false; + } + return parser_compile(); +} + void parser_cleanup() { size_t i; - for (i = 0; i < parser->functions_count; ++i) { + for (i = 0; i < vec_size(parser->accessors); ++i) { + ast_delete(parser->accessors[i]->constval.vfunc); + parser->accessors[i]->constval.vfunc = NULL; + ast_delete(parser->accessors[i]); + } + for (i = 0; i < vec_size(parser->functions); ++i) { ast_delete(parser->functions[i]); } - for (i = 0; i < parser->imm_vector_count; ++i) { + for (i = 0; i < vec_size(parser->imm_vector); ++i) { ast_delete(parser->imm_vector[i]); } - for (i = 0; i < parser->imm_string_count; ++i) { + for (i = 0; i < vec_size(parser->imm_string); ++i) { ast_delete(parser->imm_string[i]); } - for (i = 0; i < parser->imm_float_count; ++i) { + for (i = 0; i < vec_size(parser->imm_float); ++i) { ast_delete(parser->imm_float[i]); } - for (i = 0; i < parser->fields_count; ++i) { + for (i = 0; i < vec_size(parser->fields); ++i) { ast_delete(parser->fields[i].var); mem_d(parser->fields[i].name); } - for (i = 0; i < parser->globals_count; ++i) { + for (i = 0; i < vec_size(parser->globals); ++i) { ast_delete(parser->globals[i].var); mem_d(parser->globals[i].name); } - MEM_VECTOR_CLEAR(parser, functions); - MEM_VECTOR_CLEAR(parser, imm_vector); - MEM_VECTOR_CLEAR(parser, imm_string); - MEM_VECTOR_CLEAR(parser, imm_float); - MEM_VECTOR_CLEAR(parser, globals); - MEM_VECTOR_CLEAR(parser, fields); - MEM_VECTOR_CLEAR(parser, locals); + vec_free(parser->accessors); + vec_free(parser->functions); + vec_free(parser->imm_vector); + vec_free(parser->imm_string); + vec_free(parser->imm_float); + vec_free(parser->globals); + vec_free(parser->fields); + vec_free(parser->locals); mem_d(parser); } -static uint16_t progdefs_crc_sum(uint16_t old, const char *str) -{ - return util_crc16(old, str, strlen(str)); -} - -static void progdefs_crc_file(const char *str) -{ - /* write to progdefs.h here */ -} - -static uint16_t progdefs_crc_both(uint16_t old, const char *str) -{ - old = progdefs_crc_sum(old, str); - progdefs_crc_file(str); - return old; -} - -static void generate_checksum(parser_t *parser) -{ - uint16_t crc = 0xFFFF; - size_t i; - - crc = progdefs_crc_both(crc, "\n/* file generated by qcc, do not modify */\n\ntypedef struct\n{"); - crc = progdefs_crc_sum(crc, "\tint\tpad[28];\n"); - /* - progdefs_crc_file("\tint\tpad;\n"); - progdefs_crc_file("\tint\tofs_return[3];\n"); - progdefs_crc_file("\tint\tofs_parm0[3];\n"); - progdefs_crc_file("\tint\tofs_parm1[3];\n"); - progdefs_crc_file("\tint\tofs_parm2[3];\n"); - progdefs_crc_file("\tint\tofs_parm3[3];\n"); - progdefs_crc_file("\tint\tofs_parm4[3];\n"); - progdefs_crc_file("\tint\tofs_parm5[3];\n"); - progdefs_crc_file("\tint\tofs_parm6[3];\n"); - progdefs_crc_file("\tint\tofs_parm7[3];\n"); - */ - for (i = 0; i < parser->crc_globals; ++i) { - if (!ast_istype(parser->globals[i].var, ast_value)) - continue; - switch (parser->globals[i].var->expression.vtype) { - case TYPE_FLOAT: crc = progdefs_crc_both(crc, "\tfloat\t"); break; - case TYPE_VECTOR: crc = progdefs_crc_both(crc, "\tvec3_t\t"); break; - case TYPE_STRING: crc = progdefs_crc_both(crc, "\tstring_t\t"); break; - case TYPE_FUNCTION: crc = progdefs_crc_both(crc, "\tfunc_t\t"); break; - default: - crc = progdefs_crc_both(crc, "\tint\t"); - break; - } - crc = progdefs_crc_both(crc, parser->globals[i].name); - crc = progdefs_crc_both(crc, ";\n"); - } - crc = progdefs_crc_both(crc, "} globalvars_t;\n\ntypedef struct\n{\n"); - for (i = 0; i < parser->crc_fields; ++i) { - if (!ast_istype(parser->fields[i].var, ast_value)) - continue; - switch (parser->fields[i].var->expression.next->expression.vtype) { - case TYPE_FLOAT: crc = progdefs_crc_both(crc, "\tfloat\t"); break; - case TYPE_VECTOR: crc = progdefs_crc_both(crc, "\tvec3_t\t"); break; - case TYPE_STRING: crc = progdefs_crc_both(crc, "\tstring_t\t"); break; - case TYPE_FUNCTION: crc = progdefs_crc_both(crc, "\tfunc_t\t"); break; - default: - crc = progdefs_crc_both(crc, "\tint\t"); - break; - } - crc = progdefs_crc_both(crc, parser->fields[i].name); - crc = progdefs_crc_both(crc, ";\n"); - } - crc = progdefs_crc_both(crc, "} entvars_t;\n\n"); - - code_crc = crc; -} - bool parser_finish(const char *output) { size_t i; @@ -3495,11 +3848,11 @@ bool parser_finish(const char *output) { ir = ir_builder_new("gmqcc_out"); if (!ir) { - printf("failed to allocate builder\n"); + con_out("failed to allocate builder\n"); return false; } - for (i = 0; i < parser->fields_count; ++i) { + for (i = 0; i < vec_size(parser->fields); ++i) { ast_value *field; bool isconst; if (!ast_istype(parser->fields[i].var, ast_value)) @@ -3508,7 +3861,7 @@ bool parser_finish(const char *output) isconst = field->isconst; field->isconst = false; if (!ast_global_codegen((ast_value*)field, ir, true)) { - printf("failed to generate field %s\n", field->name); + con_out("failed to generate field %s\n", field->name); ir_builder_delete(ir); return false; } @@ -3525,7 +3878,7 @@ bool parser_finish(const char *output) (void)!ir_value_set_field(field->ir_v, ifld); } } - for (i = 0; i < parser->globals_count; ++i) { + for (i = 0; i < vec_size(parser->globals); ++i) { ast_value *asvalue; if (!ast_istype(parser->globals[i].var, ast_value)) continue; @@ -3539,40 +3892,41 @@ bool parser_finish(const char *output) } } if (!ast_global_codegen(asvalue, ir, false)) { - printf("failed to generate global %s\n", parser->globals[i].name); + con_out("failed to generate global %s\n", parser->globals[i].name); ir_builder_delete(ir); return false; } } - for (i = 0; i < parser->imm_float_count; ++i) { + for (i = 0; i < vec_size(parser->imm_float); ++i) { if (!ast_global_codegen(parser->imm_float[i], ir, false)) { - printf("failed to generate global %s\n", parser->imm_float[i]->name); + con_out("failed to generate global %s\n", parser->imm_float[i]->name); ir_builder_delete(ir); return false; } } - for (i = 0; i < parser->imm_string_count; ++i) { + for (i = 0; i < vec_size(parser->imm_string); ++i) { if (!ast_global_codegen(parser->imm_string[i], ir, false)) { - printf("failed to generate global %s\n", parser->imm_string[i]->name); + con_out("failed to generate global %s\n", parser->imm_string[i]->name); ir_builder_delete(ir); return false; } } - for (i = 0; i < parser->imm_vector_count; ++i) { + for (i = 0; i < vec_size(parser->imm_vector); ++i) { if (!ast_global_codegen(parser->imm_vector[i], ir, false)) { - printf("failed to generate global %s\n", parser->imm_vector[i]->name); + con_out("failed to generate global %s\n", parser->imm_vector[i]->name); ir_builder_delete(ir); return false; } } - for (i = 0; i < parser->globals_count; ++i) { + for (i = 0; i < vec_size(parser->globals); ++i) { ast_value *asvalue; if (!ast_istype(parser->globals[i].var, ast_value)) continue; asvalue = (ast_value*)(parser->globals[i].var); if (asvalue->setter) { if (!ast_global_codegen(asvalue->setter, ir, false) || - !ast_function_codegen(asvalue->setter->constval.vfunc, ir)) + !ast_function_codegen(asvalue->setter->constval.vfunc, ir) || + !ir_function_finalize(asvalue->setter->constval.vfunc->ir_func)) { printf("failed to generate setter for %s\n", parser->globals[i].name); ir_builder_delete(ir); @@ -3581,7 +3935,8 @@ bool parser_finish(const char *output) } if (asvalue->getter) { if (!ast_global_codegen(asvalue->getter, ir, false) || - !ast_function_codegen(asvalue->getter->constval.vfunc, ir)) + !ast_function_codegen(asvalue->getter->constval.vfunc, ir) || + !ir_function_finalize(asvalue->getter->constval.vfunc->ir_func)) { printf("failed to generate getter for %s\n", parser->globals[i].name); ir_builder_delete(ir); @@ -3589,27 +3944,60 @@ bool parser_finish(const char *output) } } } - for (i = 0; i < parser->functions_count; ++i) { + for (i = 0; i < vec_size(parser->fields); ++i) { + ast_value *asvalue; + asvalue = (ast_value*)(parser->fields[i].var->expression.next); + + if (!ast_istype((ast_expression*)asvalue, ast_value)) + continue; + if (asvalue->expression.vtype != TYPE_ARRAY) + continue; + if (asvalue->setter) { + if (!ast_global_codegen(asvalue->setter, ir, false) || + !ast_function_codegen(asvalue->setter->constval.vfunc, ir) || + !ir_function_finalize(asvalue->setter->constval.vfunc->ir_func)) + { + printf("failed to generate setter for %s\n", parser->fields[i].name); + ir_builder_delete(ir); + return false; + } + } + if (asvalue->getter) { + if (!ast_global_codegen(asvalue->getter, ir, false) || + !ast_function_codegen(asvalue->getter->constval.vfunc, ir) || + !ir_function_finalize(asvalue->getter->constval.vfunc->ir_func)) + { + printf("failed to generate getter for %s\n", parser->fields[i].name); + ir_builder_delete(ir); + return false; + } + } + } + for (i = 0; i < vec_size(parser->functions); ++i) { if (!ast_function_codegen(parser->functions[i], ir)) { - printf("failed to generate function %s\n", parser->functions[i]->name); + con_out("failed to generate function %s\n", parser->functions[i]->name); ir_builder_delete(ir); return false; } + } + if (opts_dump) + ir_builder_dump(ir, con_out); + for (i = 0; i < vec_size(parser->functions); ++i) { if (!ir_function_finalize(parser->functions[i]->ir_func)) { - printf("failed to finalize function %s\n", parser->functions[i]->name); + con_out("failed to finalize function %s\n", parser->functions[i]->name); ir_builder_delete(ir); return false; } } if (retval) { - if (opts_dump) - ir_builder_dump(ir, printf); + if (opts_dumpfin) + ir_builder_dump(ir, con_out); generate_checksum(parser); if (!ir_builder_generate(ir, output)) { - printf("*** failed to generate output file\n"); + con_out("*** failed to generate output file\n"); ir_builder_delete(ir); return false; } @@ -3619,6 +4007,6 @@ bool parser_finish(const char *output) return retval; } - printf("*** there were compile errors\n"); + con_out("*** there were compile errors\n"); return false; }