static ast_expression* parser_find_label(parser_t *parser, const char *name)
{
- size_t i;
- for(i = 0; i < vec_size(parser->labels); i++)
- if (!strcmp(parser->labels[i]->name, name))
- return (ast_expression*)parser->labels[i];
- return NULL;
+ for (auto &it : parser->labels)
+ if (!strcmp(it->name, name))
+ return (ast_expression*)it;
+ return nullptr;
}
ast_expression* parser_find_global(parser_t *parser, const char *name)
static ast_expression* parser_find_param(parser_t *parser, const char *name)
{
- size_t i;
ast_value *fun;
if (!parser->function)
return NULL;
fun = parser->function->vtype;
- 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]);
+ for (auto &it : fun->expression.params) {
+ if (!strcmp(it->name, name))
+ return (ast_expression*)it;
}
return NULL;
}
return NULL;
}
-typedef struct
-{
+struct sy_elem {
size_t etype; /* 0 = expression, others are operators */
- bool isparen;
- size_t off;
+ bool isparen;
+ size_t off;
ast_expression *out;
- ast_block *block; /* for commas and function calls */
+ ast_block *block; /* for commas and function calls */
lex_ctx_t ctx;
-} sy_elem;
+};
enum {
PAREN_EXPR,
PAREN_TERNARY1,
PAREN_TERNARY2
};
-typedef struct
-{
- sy_elem *out;
- sy_elem *ops;
- size_t *argc;
- unsigned int *paren;
-} shunt;
+
+struct shunt {
+ std::vector<sy_elem> out;
+ std::vector<sy_elem> ops;
+ std::vector<size_t> argc;
+ std::vector<unsigned int> paren;
+};
static sy_elem syexp(lex_ctx_t ctx, ast_expression *v) {
sy_elem e;
char ty1[1024];
char ty2[1024];
- if (!vec_size(sy->ops)) {
+ if (sy->ops.empty()) {
parseerror(parser, "internal error: missing operator");
return false;
}
- if (vec_last(sy->ops).isparen) {
+ if (sy->ops.back().isparen) {
parseerror(parser, "unmatched parenthesis");
return false;
}
- op = &operators[vec_last(sy->ops).etype - 1];
- ctx = vec_last(sy->ops).ctx;
+ op = &operators[sy->ops.back().etype - 1];
+ ctx = sy->ops.back().ctx;
- if (vec_size(sy->out) < op->operands) {
+ if (sy->out.size() < op->operands) {
if (op->flags & OP_PREFIX)
compile_error(ctx, "expected expression after unary operator `%s`", op->op, (int)op->id);
else /* this should have errored previously already */
return false;
}
- vec_shrinkby(sy->ops, 1);
+ sy->ops.pop_back();
/* op(:?) has no input and no output */
if (!op->operands)
return true;
- vec_shrinkby(sy->out, op->operands);
+ sy->out.erase(sy->out.end() - op->operands, sy->out.end());
for (i = 0; i < op->operands; ++i) {
- exprs[i] = sy->out[vec_size(sy->out)+i].out;
- blocks[i] = sy->out[vec_size(sy->out)+i].block;
+ exprs[i] = sy->out[sy->out.size()+i].out;
+ blocks[i] = sy->out[sy->out.size()+i].block;
if (exprs[i]->vtype == TYPE_NOEXPR &&
!(i != 0 && op->id == opid2('?',':')) &&
}
}
- if (blocks[0] && !vec_size(blocks[0]->exprs) && op->id != opid1(',')) {
+ if (blocks[0] && blocks[0]->exprs.empty() && op->id != opid1(',')) {
compile_error(ctx, "internal error: operator cannot be applied on empty blocks");
return false;
}
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)++;
+ if (sy->paren.size() && sy->paren.back() == PAREN_FUNC) {
+ sy->out.push_back(syexp(ctx, exprs[0]));
+ sy->out.push_back(syexp(ctx, exprs[1]));
+ sy->argc.back()++;
return true;
}
if (blocks[0]) {
}
ast_block_set_type(blocks[0], exprs[1]);
- vec_push(sy->out, syblock(ctx, blocks[0]));
+ sy->out.push_back(syblock(ctx, blocks[0]));
return true;
case opid2('+','P'):
if (!mod) return false; /* can return null for missing floor */
call = ast_call_new(parser_ctx(parser), mod);
- vec_push(call->params, exprs[0]);
- vec_push(call->params, exprs[1]);
+ call->params.push_back(exprs[0]);
+ call->params.push_back(exprs[1]);
out = (ast_expression*)call;
}
if (!(out = fold_op(parser->fold, op, exprs))) {
ast_expression *shift = intrin_func(parser->intrin, (op->id == opid2('<','<')) ? "__builtin_lshift" : "__builtin_rshift");
ast_call *call = ast_call_new(parser_ctx(parser), shift);
- vec_push(call->params, exprs[0]);
- vec_push(call->params, exprs[1]);
+ call->params.push_back(exprs[0]);
+ call->params.push_back(exprs[1]);
out = (ast_expression*)call;
}
break;
if(!(out = fold_op(parser->fold, op, exprs))) {
ast_expression *shift = intrin_func(parser->intrin, (op->id == opid3('<','<','=')) ? "__builtin_lshift" : "__builtin_rshift");
ast_call *call = ast_call_new(parser_ctx(parser), shift);
- vec_push(call->params, exprs[0]);
- vec_push(call->params, exprs[1]);
+ call->params.push_back(exprs[0]);
+ call->params.push_back(exprs[1]);
out = (ast_expression*)ast_store_new(
parser_ctx(parser),
INSTR_STORE_F,
break;
case opid2('?',':'):
- if (vec_last(sy->paren) != PAREN_TERNARY2) {
+ if (sy->paren.back() != PAREN_TERNARY2) {
compile_error(ctx, "mismatched parenthesis/ternary");
return false;
}
- vec_pop(sy->paren);
+ sy->paren.pop_back();
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));
if (!(out = fold_op(parser->fold, op, exprs))) {
ast_call *gencall = ast_call_new(parser_ctx(parser), intrin_func(parser->intrin, "pow"));
- vec_push(gencall->params, exprs[0]);
- vec_push(gencall->params, exprs[1]);
+ gencall->params.push_back(exprs[0]);
+ gencall->params.push_back(exprs[1]);
out = (ast_expression*)gencall;
}
break;
return false;
}
- vec_push(sy->out, syexp(ctx, out));
+ sy->out.push_back(syexp(ctx, out));
return true;
}
size_t paramcount, i;
bool fold = true;
- fid = vec_last(sy->ops).off;
- vec_shrinkby(sy->ops, 1);
+ fid = sy->ops.back().off;
+ sy->ops.pop_back();
/* out[fid] is the function
* everything above is parameters...
*/
- if (!vec_size(sy->argc)) {
+ if (sy->argc.empty()) {
parseerror(parser, "internal error: no argument counter available");
return false;
}
- paramcount = vec_last(sy->argc);
- vec_pop(sy->argc);
+ paramcount = sy->argc.back();
+ sy->argc.pop_back();
- 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);
+ if (sy->out.size() < fid) {
+ parseerror(parser, "internal error: broken function call %zu < %zu+%zu\n",
+ sy->out.size(),
+ fid,
+ paramcount);
return false;
}
*/
if ((fun = sy->out[fid].out) == intrin_debug_typestring(parser->intrin)) {
char ty[1024];
- if (fid+2 != vec_size(sy->out) ||
- vec_last(sy->out).block)
- {
+ if (fid+2 != sy->out.size() || sy->out.back().block) {
parseerror(parser, "intrinsic __builtin_debug_typestring requires exactly 1 parameter");
return false;
}
- ast_type_to_string(vec_last(sy->out).out, ty, sizeof(ty));
- ast_unref(vec_last(sy->out).out);
- sy->out[fid] = syexp(ast_ctx(vec_last(sy->out).out),
+ ast_type_to_string(sy->out.back().out, ty, sizeof(ty));
+ ast_unref(sy->out.back().out);
+ sy->out[fid] = syexp(ast_ctx(sy->out.back().out),
(ast_expression*)fold_constgen_string(parser->fold, ty, false));
- vec_shrinkby(sy->out, 1);
+ sy->out.pop_back();
return true;
}
(ast_istype(((ast_expression*)(X)), ast_value) && (X)->hasvalue && ((X)->cvq == CV_CONST) && \
((ast_expression*)(X))->vtype != TYPE_FUNCTION)
- if (fid + 1 < vec_size(sy->out))
+ if (fid + 1 < sy->out.size())
++paramcount;
for (i = 0; i < paramcount; ++i) {
* sy->out should I be doing here?
*/
sy->out[fid] = syexp(foldval->node.context, foldval);
- vec_shrinkby(sy->out, paramcount);
+ sy->out.erase(sy->out.end() - paramcount, sy->out.end());
vec_free(exprs);
return true;
}
fold_leave:
- call = ast_call_new(sy->ops[vec_size(sy->ops)].ctx, fun);
+ call = ast_call_new(sy->ops[sy->ops.size()].ctx, fun);
if (!call)
return false;
- 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));
+ if (fid+1 + paramcount != sy->out.size()) {
+ parseerror(parser, "internal error: parameter count mismatch: (%zu+1+%zu), %zu",
+ fid,
+ paramcount,
+ sy->out.size());
return false;
}
for (i = 0; i < paramcount; ++i)
- vec_push(call->params, sy->out[fid+1 + i].out);
- vec_shrinkby(sy->out, paramcount);
+ call->params.push_back(sy->out[fid+1 + i].out);
+ sy->out.erase(sy->out.end() - paramcount, sy->out.end());
(void)!ast_call_check_types(call, parser->function->vtype->expression.varparam);
if (parser->max_param_count < paramcount)
parser->max_param_count = paramcount;
ast_ctx(fun).line);
}
- if (vec_size(fun->params) != paramcount &&
+ if (fun->params.size() != paramcount &&
!((fun->flags & AST_FLAG_VARIADIC) &&
- vec_size(fun->params) < paramcount))
+ fun->params.size() < paramcount))
{
- const char *fewmany = (vec_size(fun->params) > paramcount) ? "few" : "many";
+ const char *fewmany = (fun->params.size() > paramcount) ? "few" : "many";
if (fval)
return !parsewarning(parser, WARN_INVALID_PARAMETER_COUNT,
"too %s parameters for call to %s: expected %i, got %i\n"
" -> `%s` has been declared here: %s:%i",
- fewmany, fval->name, (int)vec_size(fun->params), (int)paramcount,
+ fewmany, fval->name, (int)fun->params.size(), (int)paramcount,
fval->name, ast_ctx(fun).file, (int)ast_ctx(fun).line);
else
return !parsewarning(parser, WARN_INVALID_PARAMETER_COUNT,
"too %s parameters for function call: expected %i, got %i\n"
" -> it has been declared here: %s:%i",
- fewmany, (int)vec_size(fun->params), (int)paramcount,
+ fewmany, (int)fun->params.size(), (int)paramcount,
ast_ctx(fun).file, (int)ast_ctx(fun).line);
}
}
static bool parser_close_paren(parser_t *parser, shunt *sy)
{
- if (!vec_size(sy->ops)) {
+ if (sy->ops.empty()) {
parseerror(parser, "unmatched closing paren");
return false;
}
- while (vec_size(sy->ops)) {
- if (vec_last(sy->ops).isparen) {
- if (vec_last(sy->paren) == PAREN_FUNC) {
- vec_pop(sy->paren);
+ while (sy->ops.size()) {
+ if (sy->ops.back().isparen) {
+ if (sy->paren.back() == PAREN_FUNC) {
+ sy->paren.pop_back();
if (!parser_close_call(parser, sy))
return false;
break;
}
- 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);
+ if (sy->paren.back() == PAREN_EXPR) {
+ sy->paren.pop_back();
+ if (sy->out.empty()) {
+ compile_error(sy->ops.back().ctx, "empty paren expression");
+ sy->ops.pop_back();
return false;
}
- vec_shrinkby(sy->ops, 1);
+ sy->ops.pop_back();
break;
}
- if (vec_last(sy->paren) == PAREN_INDEX) {
- vec_pop(sy->paren);
- /* pop off the parenthesis */
- vec_shrinkby(sy->ops, 1);
+ if (sy->paren.back() == PAREN_INDEX) {
+ sy->paren.pop_back();
+ // pop off the parenthesis
+ sy->ops.pop_back();
/* 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);
+ if (sy->paren.back() == PAREN_TERNARY1) {
+ sy->paren.back() = PAREN_TERNARY2;
+ // pop off the parenthesis
+ sy->ops.pop_back();
break;
}
- compile_error(vec_last(sy->ops).ctx, "invalid parenthesis");
+ compile_error(sy->ops.back().ctx, "invalid parenthesis");
return false;
}
if (!parser_sy_apply_operator(parser, sy))
val = (ast_value*)fold_constgen_string(parser->fold, parser_tokval(parser), true);
if (!val)
return false;
- vec_push(sy->out, syexp(parser_ctx(parser), (ast_expression*)val));
+ sy->out.push_back(syexp(parser_ctx(parser), (ast_expression*)val));
if (!parser_next(parser) || parser->tok != ')') {
parseerror(parser, "expected closing paren after translatable string");
va = parse_vararg(parser);
if (!va)
return false;
- vec_push(sy->out, syexp(parser_ctx(parser), va));
+ sy->out.push_back(syexp(parser_ctx(parser), va));
return true;
}
else if (parser->tok == TOKEN_FLOATCONST) {
ast_expression *val = fold_constgen_float(parser->fold, (parser_token(parser)->constval.f), false);
if (!val)
return false;
- vec_push(sy->out, syexp(parser_ctx(parser), val));
+ sy->out.push_back(syexp(parser_ctx(parser), val));
return true;
}
else if (parser->tok == TOKEN_INTCONST || parser->tok == TOKEN_CHARCONST) {
ast_expression *val = fold_constgen_float(parser->fold, (qcfloat_t)(parser_token(parser)->constval.i), false);
if (!val)
return false;
- vec_push(sy->out, syexp(parser_ctx(parser), val));
+ sy->out.push_back(syexp(parser_ctx(parser), val));
return true;
}
else if (parser->tok == TOKEN_STRINGCONST) {
ast_expression *val = fold_constgen_string(parser->fold, parser_tokval(parser), false);
if (!val)
return false;
- vec_push(sy->out, syexp(parser_ctx(parser), val));
+ sy->out.push_back(syexp(parser_ctx(parser), val));
return true;
}
else if (parser->tok == TOKEN_VECTORCONST) {
ast_expression *val = fold_constgen_vector(parser->fold, parser_token(parser)->constval.v);
if (!val)
return false;
- vec_push(sy->out, syexp(parser_ctx(parser), val));
+ sy->out.push_back(syexp(parser_ctx(parser), 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 *prev = sy->out.size() ? sy->out.back().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('.'))
+ if (sy->ops.empty() ||
+ !sy->ops.back().etype ||
+ operators[sy->ops.back().etype-1].id != opid1('.'))
{
/* When adding more intrinsics, fix the above condition */
prev = NULL;
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);
+ parser->labels.push_back(lbl);
}
}
if (!var && !strcmp(parser_tokval(parser), "__FUNC__"))
((ast_value*)(mem->owner))->uses++;
}
}
- vec_push(sy->out, syexp(parser_ctx(parser), var));
+ sy->out.push_back(syexp(parser_ctx(parser), var));
return true;
}
parseerror(parser, "unexpected token `%s`", parser_tokval(parser));
{
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
op = &operators[o];
/* when declaring variables, a comma starts a new variable */
- if (op->id == opid1(',') && !vec_size(sy.paren) && stopatcomma) {
+ if (op->id == opid1(',') && sy.paren.empty() && stopatcomma) {
/* fixup the token */
parser->tok = ',';
break;
}
if (op->id == opid1(',')) {
- if (vec_size(sy.paren) && vec_last(sy.paren) == PAREN_TERNARY2) {
+ if (sy.paren.size() && sy.paren.back() == PAREN_TERNARY2) {
(void)!parsewarning(parser, WARN_TERNARY_PRECEDENCE, "suggesting parenthesis around ternary expression");
}
}
- if (vec_size(sy.ops) && !vec_last(sy.ops).isparen)
- olast = &operators[vec_last(sy.ops).etype-1];
+ if (sy.ops.size() && !sy.ops.back().isparen)
+ olast = &operators[sy.ops.back().etype-1];
/* first only apply higher precedences, assoc_left+equal comes after we warn about precedence rules */
while (olast && op->prec < olast->prec)
{
if (!parser_sy_apply_operator(parser, &sy))
goto onerr;
- if (vec_size(sy.ops) && !vec_last(sy.ops).isparen)
- olast = &operators[vec_last(sy.ops).etype-1];
+ if (sy.ops.size() && !sy.ops.back().isparen)
+ olast = &operators[sy.ops.back().etype-1];
else
olast = NULL;
}
if (warn_parenthesis) {
if ( (olast && IsAssignOp(olast->id) && (op->id == opid2('&','&') || op->id == opid2('|','|'))) ||
(olast && IsAssignOp(op->id) && (olast->id == opid2('&','&') || olast->id == opid2('|','|'))) ||
- (truthvalue && !vec_size(sy.paren) && IsAssignOp(op->id))
+ (truthvalue && sy.paren.empty() && IsAssignOp(op->id))
)
{
(void)!parsewarning(parser, WARN_PARENTHESIS, "suggesting parenthesis around assignment used as truth value");
{
if (!parser_sy_apply_operator(parser, &sy))
goto onerr;
- if (vec_size(sy.ops) && !vec_last(sy.ops).isparen)
- olast = &operators[vec_last(sy.ops).etype-1];
+ if (sy.ops.size() && !sy.ops.back().isparen)
+ olast = &operators[sy.ops.back().etype-1];
else
olast = NULL;
}
if (op->id == opid1('(')) {
if (wantop) {
- size_t sycount = vec_size(sy.out);
+ size_t sycount = sy.out.size();
/* we expected an operator, this is the function-call operator */
- vec_push(sy.paren, PAREN_FUNC);
- vec_push(sy.ops, syparen(parser_ctx(parser), sycount-1));
- vec_push(sy.argc, 0);
+ sy.paren.push_back(PAREN_FUNC);
+ sy.ops.push_back(syparen(parser_ctx(parser), sycount-1));
+ sy.argc.push_back(0);
} else {
- vec_push(sy.paren, PAREN_EXPR);
- vec_push(sy.ops, syparen(parser_ctx(parser), 0));
+ sy.paren.push_back(PAREN_EXPR);
+ sy.ops.push_back(syparen(parser_ctx(parser), 0));
}
wantop = false;
} else if (op->id == opid1('[')) {
parseerror(parser, "unexpected array subscript");
goto onerr;
}
- vec_push(sy.paren, PAREN_INDEX);
+ sy.paren.push_back(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), 0));
+ sy.ops.push_back(syop(parser_ctx(parser), op));
+ sy.ops.push_back(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), 0));
+ sy.ops.push_back(syop(parser_ctx(parser), op));
+ sy.ops.push_back(syparen(parser_ctx(parser), 0));
wantop = false;
++ternaries;
- vec_push(sy.paren, PAREN_TERNARY1);
+ sy.paren.push_back(PAREN_TERNARY1);
} else if (op->id == opid2(':','?')) {
- if (!vec_size(sy.paren)) {
+ if (sy.paren.empty()) {
parseerror(parser, "unexpected colon outside ternary expression (missing parenthesis?)");
goto onerr;
}
- if (vec_last(sy.paren) != PAREN_TERNARY1) {
+ if (sy.paren.back() != PAREN_TERNARY1) {
parseerror(parser, "unexpected colon outside ternary expression (missing parenthesis?)");
goto onerr;
}
if (!parser_close_paren(parser, &sy))
goto onerr;
- vec_push(sy.ops, syop(parser_ctx(parser), op));
+ sy.ops.push_back(syop(parser_ctx(parser), op));
wantop = false;
--ternaries;
} else {
- vec_push(sy.ops, syop(parser_ctx(parser), op));
+ sy.ops.push_back(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) {
+ while (sy.paren.size() && sy.paren.back() == PAREN_TERNARY2) {
if (!parser_sy_apply_operator(parser, &sy))
goto onerr;
}
- if (!vec_size(sy.paren))
+ if (sy.paren.empty())
break;
if (wantop) {
- if (vec_last(sy.paren) == PAREN_TERNARY1) {
+ if (sy.paren.back() == PAREN_TERNARY1) {
parseerror(parser, "mismatched parentheses (closing paren in ternary expression?)");
goto onerr;
}
goto onerr;
} else {
/* must be a function call without parameters */
- if (vec_last(sy.paren) != PAREN_FUNC) {
+ if (sy.paren.back() != PAREN_FUNC) {
parseerror(parser, "closing paren in invalid position");
goto onerr;
}
goto onerr;
}
else if (parser->tok == ']') {
- while (vec_size(sy.paren) && vec_last(sy.paren) == PAREN_TERNARY2) {
+ while (sy.paren.size() && sy.paren.back() == PAREN_TERNARY2) {
if (!parser_sy_apply_operator(parser, &sy))
goto onerr;
}
- if (!vec_size(sy.paren))
+ if (sy.paren.empty())
break;
- if (vec_last(sy.paren) != PAREN_INDEX) {
+ if (sy.paren.back() != PAREN_INDEX) {
parseerror(parser, "mismatched parentheses, unexpected ']'");
goto onerr;
}
else {
/* in this case we might want to allow constant string concatenation */
bool concatenated = false;
- if (parser->tok == TOKEN_STRINGCONST && vec_size(sy.out)) {
- ast_expression *lexpr = vec_last(sy.out).out;
+ if (parser->tok == TOKEN_STRINGCONST && sy.out.size()) {
+ ast_expression *lexpr = sy.out.back().out;
if (ast_istype(lexpr, ast_value)) {
ast_value *last = (ast_value*)lexpr;
if (last->isimm == true && last->cvq == CV_CONST &&
{
char *newstr = NULL;
util_asprintf(&newstr, "%s%s", last->constval.vstring, parser_tokval(parser));
- vec_last(sy.out).out = (ast_expression*)fold_constgen_string(parser->fold, newstr, false);
+ sy.out.back().out = (ast_expression*)fold_constgen_string(parser->fold, newstr, false);
mem_d(newstr);
concatenated = true;
}
goto onerr;
}
if (parser->tok == ';' ||
- ((!vec_size(sy.paren) || (vec_size(sy.paren) == 1 && vec_last(sy.paren) == PAREN_TERNARY2)) &&
+ ((sy.paren.empty() || (sy.paren.size() == 1 && sy.paren.back() == PAREN_TERNARY2)) &&
(parser->tok == ']' || parser->tok == ')' || parser->tok == '}')))
{
break;
}
}
- while (vec_size(sy.ops)) {
+ while (sy.ops.size()) {
if (!parser_sy_apply_operator(parser, &sy))
goto onerr;
}
parser->lex->flags.noops = true;
- if (vec_size(sy.out) != 1) {
+ if (sy.out.size() != 1) {
parseerror(parser, "expression expected");
expr = NULL;
} else
expr = sy.out[0].out;
- vec_free(sy.out);
- vec_free(sy.ops);
- if (vec_size(sy.paren)) {
- parseerror(parser, "internal error: vec_size(sy.paren) = %lu", (unsigned long)vec_size(sy.paren));
+ if (sy.paren.size()) {
+ parseerror(parser, "internal error: sy.paren.size() = %zu", sy.paren.size());
return NULL;
}
- 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);
+ for (auto &it : sy.out)
+ if (it.out) ast_unref(it.out);
return NULL;
}
static void parser_addglobal(parser_t *parser, const char *name, ast_expression *e)
{
- vec_push(parser->globals, e);
+ parser->globals.push_back(e);
util_htset(parser->htglobals, name, e);
}
return false;
}
- vec_push(parser->breaks, label);
- vec_push(parser->continues, label);
+ parser->breaks.push_back(label);
+ parser->continues.push_back(label);
rv = parse_while_go(parser, block, out);
if (label)
mem_d(label);
- if (vec_last(parser->breaks) != label || vec_last(parser->continues) != label) {
+ if (parser->breaks.back() != label || parser->continues.back() != label) {
parseerror(parser, "internal error: label stack corrupted");
rv = false;
ast_delete(*out);
*out = NULL;
}
else {
- vec_pop(parser->breaks);
- vec_pop(parser->continues);
+ parser->breaks.pop_back();
+ parser->continues.pop_back();
}
return rv;
}
}
}
- vec_push(parser->breaks, label);
- vec_push(parser->continues, label);
+ parser->breaks.push_back(label);
+ parser->continues.push_back(label);
rv = parse_dowhile_go(parser, block, out);
if (label)
mem_d(label);
- if (vec_last(parser->breaks) != label || vec_last(parser->continues) != label) {
+ if (parser->breaks.back() != label || parser->continues.back() != label) {
parseerror(parser, "internal error: label stack corrupted");
rv = false;
/*
*out = NULL;
}
else {
- vec_pop(parser->breaks);
- vec_pop(parser->continues);
+ parser->breaks.pop_back();
+ parser->continues.pop_back();
}
return rv;
}
return false;
}
- vec_push(parser->breaks, label);
- vec_push(parser->continues, label);
+ parser->breaks.push_back(label);
+ parser->continues.push_back(label);
rv = parse_for_go(parser, block, out);
if (label)
mem_d(label);
- if (vec_last(parser->breaks) != label || vec_last(parser->continues) != label) {
+ if (parser->breaks.back() != label || parser->continues.back() != label) {
parseerror(parser, "internal error: label stack corrupted");
rv = false;
ast_delete(*out);
*out = NULL;
}
else {
- vec_pop(parser->breaks);
- vec_pop(parser->continues);
+ parser->breaks.pop_back();
+ parser->continues.pop_back();
}
return rv;
}
static bool parse_break_continue(parser_t *parser, ast_block *block, ast_expression **out, bool is_continue)
{
- size_t i;
+ size_t i;
unsigned int levels = 0;
- lex_ctx_t ctx = parser_ctx(parser);
- const char **loops = (is_continue ? parser->continues : parser->breaks);
+ lex_ctx_t ctx = parser_ctx(parser);
+ auto &loops = (is_continue ? parser->continues : parser->breaks);
(void)block; /* not touching */
if (!parser_next(parser)) {
return false;
}
- if (!vec_size(loops)) {
+ if (loops.empty()) {
if (is_continue)
parseerror(parser, "`continue` can only be used inside loops");
else
if (parser->tok == TOKEN_IDENT) {
if (!OPTS_FLAG(LOOP_LABELS))
parseerror(parser, "labeled loops not activated, try using -floop-labels");
- i = vec_size(loops);
+ i = loops.size();
while (i--) {
if (loops[i] && !strcmp(loops[i], parser_tokval(parser)))
break;
/* returns true when it was a variable qualifier, false otherwise!
* on error, cvq is set to CV_WRONG
*/
-typedef struct {
+struct attribute_t {
const char *name;
size_t flag;
-} attribute_t;
+};
static bool parse_qualifiers(parser_t *parser, bool with_local, int *cvq, bool *noref, bool *is_static, uint32_t *_flags, char **message)
{
return false;
}
- vec_push(parser->breaks, label);
+ parser->breaks.push_back(label);
rv = parse_switch_go(parser, block, out);
if (label)
mem_d(label);
- if (vec_last(parser->breaks) != label) {
+ if (parser->breaks.back() != label) {
parseerror(parser, "internal error: label stack corrupted");
rv = false;
ast_delete(*out);
*out = NULL;
}
else {
- vec_pop(parser->breaks);
+ parser->breaks.pop_back();
}
return rv;
}
return false;
}
swcase.code = (ast_expression*)caseblock;
- vec_push(switchnode->cases, swcase);
+ switchnode->cases.push_back(swcase);
while (true) {
ast_expression *expr;
if (parser->tok == '}')
ast_goto_set_label(gt, (ast_label*)lbl);
}
else
- vec_push(parser->gotos, gt);
+ parser->gotos.push_back(gt);
if (!parser_next(parser) || parser->tok != ';') {
parseerror(parser, "semicolon expected after goto label");
}
else {
label = ast_label_new(parser_ctx(parser), parser_tokval(parser), false);
- vec_push(parser->labels, label);
+ parser->labels.push_back(label);
}
*out = (ast_expression*)label;
if (!parser_next(parser)) {
parseerror(parser, "parse error after label");
return false;
}
- for (i = 0; i < vec_size(parser->gotos); ++i) {
+ for (i = 0; i < parser->gotos.size(); ++i) {
if (!strcmp(parser->gotos[i]->name, label->name)) {
ast_goto_set_label(parser->gotos[i], label);
- vec_remove(parser->gotos, i, 1);
+ parser->gotos.erase(parser->gotos.begin() + i);
--i;
}
}
static bool parse_function_body(parser_t *parser, ast_value *var)
{
- ast_block *block = NULL;
- ast_function *func;
- ast_function *old;
- size_t parami;
+ ast_block *block = NULL;
+ ast_function *func;
+ ast_function *old;
ast_expression *framenum = NULL;
ast_expression *nextthink = NULL;
/* None of the following have to be deleted */
ast_expression *fld_think = NULL, *fld_nextthink = NULL, *fld_frame = NULL;
ast_expression *gbl_time = NULL, *gbl_self = NULL;
- bool has_frame_think;
+ bool has_frame_think;
bool retval = true;
return false;
}
- if (vec_size(parser->gotos) || vec_size(parser->labels)) {
+ if (parser->gotos.size() || parser->labels.size()) {
parseerror(parser, "gotos/labels leaking");
return false;
}
ast_block_delete(block);
goto enderr;
}
- vec_push(parser->functions, func);
+ parser->functions.push_back(func);
}
parser_enterblock(parser);
- for (parami = 0; parami < vec_size(var->expression.params); ++parami) {
- size_t e;
- ast_value *param = var->expression.params[parami];
+ for (auto &it : var->expression.params) {
+ size_t e;
ast_member *me[3];
- if (param->expression.vtype != TYPE_VECTOR &&
- (param->expression.vtype != TYPE_FIELD ||
- param->expression.next->vtype != TYPE_VECTOR))
+ if (it->expression.vtype != TYPE_VECTOR &&
+ (it->expression.vtype != TYPE_FIELD ||
+ it->expression.next->vtype != TYPE_VECTOR))
{
continue;
}
- if (!create_vector_members(param, me)) {
+ if (!create_vector_members(it, me)) {
ast_block_delete(block);
goto enderrfn;
}
goto enderrfn;
}
func->varargs = varargs;
- func->fixedparams = (ast_value*)fold_constgen_float(parser->fold, vec_size(var->expression.params), false);
+ func->fixedparams = (ast_value*)fold_constgen_float(parser->fold, var->expression.params.size(), false);
}
parser->function = func;
goto enderrfn;
}
- vec_push(func->blocks, block);
+ func->blocks.push_back(block);
parser->function = old;
if (!parser_leaveblock(parser))
enderrfn:
(void)!parser_leaveblock(parser);
- vec_pop(parser->functions);
+ parser->functions.pop_back();
ast_function_delete(func);
var->constval.vfunc = NULL;
return false;
}
- vec_push(func->blocks, body);
+ func->blocks.push_back(body);
*out = fval;
- vec_push(parser->accessors, fval);
+ parser->accessors.push_back(fval);
return true;
}
goto cleanup;
}
(void)!ast_value_set_name(value, "value"); /* not important */
- vec_push(fval->expression.params, index);
- vec_push(fval->expression.params, value);
+ fval->expression.params.push_back(index);
+ fval->expression.params.push_back(value);
array->setter = fval;
return fval;
goto cleanup;
}
(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);
+ fval->expression.params.push_back(entity);
+ fval->expression.params.push_back(index);
+ fval->expression.params.push_back(value);
root = array_field_setter_node(parser, array, entity, index, value, 0, array->expression.count);
if (!root) {
parseerror(parser, "failed to create locals for array accessor");
goto cleanup;
}
- vec_push(fval->expression.params, index);
+ fval->expression.params.push_back(index);
array->getter = fval;
return fval;
static ast_value *parse_parameter_list(parser_t *parser, ast_value *var)
{
- lex_ctx_t ctx;
- size_t i;
- ast_value **params;
- ast_value *param;
- ast_value *fval;
- bool first = true;
- bool variadic = false;
- ast_value *varparam = NULL;
- char *argcounter = NULL;
-
- ctx = parser_ctx(parser);
+ lex_ctx_t ctx = parser_ctx(parser);
+ std::vector<ast_value *> params;
+ ast_value *fval;
+ bool first = true;
+ bool variadic = false;
+ ast_value *varparam = NULL;
+ char *argcounter = NULL;
/* for the sake of less code we parse-in in this function */
if (!parser_next(parser)) {
return NULL;
}
- params = NULL;
-
/* parse variables until we hit a closing paren */
while (parser->tok != ')') {
bool is_varargs = false;
}
first = false;
- param = parse_typename(parser, NULL, NULL, &is_varargs);
+ ast_value *param = parse_typename(parser, NULL, NULL, &is_varargs);
if (!param && !is_varargs)
goto on_error;
if (is_varargs) {
}
}
} else {
- vec_push(params, param);
+ params.push_back(param);
if (param->expression.vtype >= TYPE_VARIANT) {
char tname[1024]; /* typename is reserved in C++ */
ast_type_to_string((ast_expression*)param, tname, sizeof(tname));
/* type-restricted varargs */
if (parser->tok == TOKEN_DOTS) {
variadic = true;
- varparam = vec_last(params);
- vec_pop(params);
+ varparam = params.back();
+ params.pop_back();
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 (vec_size(params) == 1 && params[0]->expression.vtype == TYPE_VOID)
- vec_free(params);
+ if (params.size() == 1 && params[0]->expression.vtype == TYPE_VOID)
+ params.clear();
/* sanity check */
- if (vec_size(params) > 8 && OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_QCC)
+ if (params.size() > 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 */
/* now turn 'var' into a function type */
fval = ast_value_new(ctx, "<type()>", TYPE_FUNCTION);
- fval->expression.next = (ast_expression*)var;
+ fval->expression.next = (ast_expression*)var;
if (variadic)
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;
+ var->argcounter = argcounter;
return var;
if (varparam)
ast_delete(varparam);
ast_delete(var);
- for (i = 0; i < vec_size(params); ++i)
- ast_delete(params[i]);
- vec_free(params);
+ for (auto &it : params)
+ ast_delete(it);
return NULL;
}
static bool parse_array(parser_t *parser, ast_value *array)
{
size_t i;
- if (array->initlist) {
+ if (array->initlist.size()) {
parseerror(parser, "array already initialized elsewhere");
return false;
}
parseerror(parser, "initializing element must be a compile time constant");
return false;
}
- vec_push(array->initlist, v->constval);
+ array->initlist.push_back(v->constval);
if (v->expression.vtype == TYPE_STRING) {
array->initlist[i].vstring = util_strdupe(array->initlist[i].vstring);
++i;
parseerror(parser, "array `%s' has already been initialized with %u elements",
array->name, (unsigned)array->expression.count);
}
- array->expression.count = vec_size(array->initlist);
+ array->expression.count = array->initlist.size();
if (!create_array_accessors(parser, array))
return false;
}
was_end = false;
if (!strcmp(var->name, "end_sys_globals")) {
var->uses++;
- parser->crc_globals = vec_size(parser->globals);
+ parser->crc_globals = parser->globals.size();
was_end = true;
}
else if (!strcmp(var->name, "end_sys_fields")) {
var->uses++;
- parser->crc_fields = vec_size(parser->fields);
+ parser->crc_fields = parser->fields.size();
was_end = true;
}
if (was_end && var->expression.vtype == TYPE_FIELD) {
goto cleanup;
}
/* we need the new parameter-names */
- for (i = 0; i < vec_size(proto->expression.params); ++i)
+ for (i = 0; i < proto->expression.params.size(); ++i)
ast_value_set_name(proto->expression.params[i], var->expression.params[i]->name);
if (!parser_check_qualifiers(parser, var, proto)) {
retval = false;
/* deal with global variables, fields, functions */
if (!nofields && var->expression.vtype == TYPE_FIELD && parser->tok != '=') {
var->isfield = true;
- vec_push(parser->fields, (ast_expression*)var);
+ parser->fields.push_back((ast_expression*)var);
util_htset(parser->htfields, var->name, var);
if (isvector) {
for (i = 0; i < 3; ++i) {
- vec_push(parser->fields, (ast_expression*)me[i]);
+ parser->fields.push_back((ast_expression*)me[i]);
util_htset(parser->htfields, me[i]->name, me[i]);
}
}
ast_value_set_name(var, defname);
/* push it to the to-be-generated globals */
- vec_push(parser->globals, (ast_expression*)var);
+ parser->globals.push_back((ast_expression*)var);
/* same game for the vector members */
if (isvector) {
vec_append(defname, ln, me[i]->name);
ast_member_set_name(me[i], defname);
- vec_push(parser->globals, (ast_expression*)me[i]);
+ parser->globals.push_back((ast_expression*)me[i]);
}
}
vec_free(defname);
} else {
- vec_push(localblock->locals, var);
+ localblock->locals.push_back(var);
parser_addlocal(parser, var->name, (ast_expression*)var);
if (isvector) {
for (i = 0; i < 3; ++i) {
parseerror(parser, "failed to allocate function for `%s`", var->name);
break;
}
- vec_push(parser->functions, func);
+ parser->functions.push_back(func);
func->builtin = -builtin_num-1;
}
if (!parse_function_body(parser, var))
break;
ast_delete(basetype);
- for (i = 0; i < vec_size(parser->gotos); ++i)
- parseerror(parser, "undefined label: `%s`", parser->gotos[i]->name);
- vec_free(parser->gotos);
- vec_free(parser->labels);
+ for (auto &it : parser->gotos)
+ parseerror(parser, "undefined label: `%s`", it->name);
return true;
} else {
ast_expression *cexp;
if (isvector) {
for (i = 0; i < 3; ++i) {
vec_pop(parser->_locals);
- vec_pop(localblock->collect);
+ localblock->collect.pop_back();
}
}
/* do sanity checking, this function really needs refactoring */
parseerror(parser, "internal error: unexpected change in local variable handling");
else
vec_pop(parser->_locals);
- if (vec_last(localblock->locals) != var)
+ if (localblock->locals.back() != var)
parseerror(parser, "internal error: unexpected change in local variable handling (2)");
else
- vec_pop(localblock->locals);
+ localblock->locals.pop_back();
/* push it to the to-be-generated globals */
- vec_push(parser->globals, (ast_expression*)var);
+ parser->globals.push_back((ast_expression*)var);
if (isvector)
for (i = 0; i < 3; ++i)
- vec_push(parser->globals, (ast_expression*)last_me[i]);
+ parser->globals.push_back((ast_expression*)last_me[i]);
folded_const = true;
}
}
} else {
int cvq;
- shunt sy = { NULL, NULL, NULL, NULL };
+ shunt sy;
cvq = var->cvq;
var->cvq = CV_NONE;
- 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));
+ sy.out.push_back(syexp(ast_ctx(var), (ast_expression*)var));
+ sy.out.push_back(syexp(ast_ctx(cexp), (ast_expression*)cexp));
+ sy.ops.push_back(syop(ast_ctx(var), parser->assign_op));
if (!parser_sy_apply_operator(parser, &sy))
ast_unref(cexp);
else {
- if (vec_size(sy.out) != 1 && vec_size(sy.ops) != 0)
+ if (sy.out.size() != 1 && sy.ops.size() != 0)
parseerror(parser, "internal error: leaked operands");
if (!ast_block_add_expr(localblock, (ast_expression*)sy.out[0].out))
break;
}
- vec_free(sy.out);
- vec_free(sy.ops);
- vec_free(sy.argc);
var->cvq = cvq;
}
/* a constant initialized to an inexact value should be marked inexact:
memset(parser, 0, sizeof(*parser));
+ // TODO: remove
+ new (parser) parser_t();
+
for (i = 0; i < operator_count; ++i) {
if (operators[i].id == opid1('=')) {
parser->assign_op = operators+i;
if (parser->ast_cleaned)
return;
parser->ast_cleaned = true;
- 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 (auto &it : parser->accessors) {
+ ast_delete(it->constval.vfunc);
+ it->constval.vfunc = nullptr;
+ ast_delete(it);
}
- for (i = 0; i < vec_size(parser->fields); ++i) {
- ast_delete(parser->fields[i]);
- }
- for (i = 0; i < vec_size(parser->globals); ++i) {
- ast_delete(parser->globals[i]);
- }
- vec_free(parser->accessors);
- vec_free(parser->functions);
- vec_free(parser->globals);
- vec_free(parser->fields);
+ for (auto &it : parser->functions) ast_delete(it);
+ for (auto &it : parser->globals) ast_delete(it);
+ for (auto &it : parser->fields) ast_delete(it);
for (i = 0; i < vec_size(parser->variables); ++i)
util_htdel(parser->variables[i]);
vec_free(parser->_block_ctx);
- vec_free(parser->labels);
- vec_free(parser->gotos);
- vec_free(parser->breaks);
- vec_free(parser->continues);
-
ast_value_delete(parser->nil);
ast_value_delete(parser->const_vec[0]);
}
static bool parser_set_coverage_func(parser_t *parser, ir_builder *ir) {
- size_t i;
ast_expression *expr;
ast_value *cov;
ast_function *func;
if (!OPTS_OPTION_BOOL(OPTION_COVERAGE))
return true;
- func = NULL;
- for (i = 0; i != vec_size(parser->functions); ++i) {
- if (!strcmp(parser->functions[i]->name, "coverage")) {
- func = parser->functions[i];
+ func = nullptr;
+ for (auto &it : parser->functions) {
+ if (!strcmp(it->name, "coverage")) {
+ func = it;
break;
}
}
cov = func->vtype;
expr = (ast_expression*)cov;
- if (expr->vtype != TYPE_FUNCTION || vec_size(expr->params) != 0) {
+ if (expr->vtype != TYPE_FUNCTION || expr->params.size()) {
char ty[1024];
ast_type_to_string(expr, ty, sizeof(ty));
con_out("invalid type for coverage(): %s\n", ty);
bool parser_finish(parser_t *parser, const char *output)
{
- size_t i;
- ir_builder *ir;
- bool retval = true;
+ ir_builder *ir;
+ bool retval = true;
if (compile_errors) {
con_out("*** there were compile errors\n");
return false;
}
- for (i = 0; i < vec_size(parser->fields); ++i) {
- ast_value *field;
+ for (auto &it : parser->fields) {
bool hasvalue;
- if (!ast_istype(parser->fields[i], ast_value))
+ if (!ast_istype(it, ast_value))
continue;
- field = (ast_value*)parser->fields[i];
+ ast_value *field = (ast_value*)it;
hasvalue = field->hasvalue;
field->hasvalue = false;
if (!ast_global_codegen((ast_value*)field, ir, true)) {
(void)!ir_value_set_field(field->ir_v, ifld);
}
}
- for (i = 0; i < vec_size(parser->globals); ++i) {
+ for (auto &it : parser->globals) {
ast_value *asvalue;
- if (!ast_istype(parser->globals[i], ast_value))
+ if (!ast_istype(it, ast_value))
continue;
- asvalue = (ast_value*)(parser->globals[i]);
+ asvalue = (ast_value*)it;
if (!asvalue->uses && !asvalue->hasvalue && asvalue->expression.vtype != TYPE_FUNCTION) {
retval = retval && !compile_warning(ast_ctx(asvalue), WARN_UNUSED_VARIABLE,
"unused global: `%s`", asvalue->name);
/* 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];
+ for (auto &f : parser->functions) {
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->max_param_count > f->vtype->expression.params.size()) {
+ f->varargs->expression.count = parser->max_param_count - f->vtype->expression.params.size();
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);
/* before generating any functions we need to set the coverage_func */
if (!parser_set_coverage_func(parser, ir))
return false;
-
- for (i = 0; i < vec_size(parser->globals); ++i) {
- ast_value *asvalue;
- if (!ast_istype(parser->globals[i], ast_value))
+ for (auto &it : parser->globals) {
+ if (!ast_istype(it, ast_value))
continue;
- asvalue = (ast_value*)(parser->globals[i]);
+ ast_value *asvalue = (ast_value*)it;
if (!(asvalue->expression.flags & AST_FLAG_INITIALIZED))
{
if (asvalue->cvq == CV_CONST && !asvalue->hasvalue)
return false;
}
}
- for (i = 0; i < vec_size(parser->fields); ++i) {
- ast_value *asvalue;
- asvalue = (ast_value*)(parser->fields[i]->next);
-
+ for (auto &it : parser->fields) {
+ ast_value *asvalue = (ast_value*)it->next;
if (!ast_istype((ast_expression*)asvalue, ast_value))
continue;
if (asvalue->expression.vtype != TYPE_ARRAY)
ir_builder_delete(ir);
return false;
}
- for (i = 0; i < vec_size(parser->functions); ++i) {
- ast_function *f = parser->functions[i];
+ for (auto &f : parser->functions) {
if (!ast_function_codegen(f, ir)) {
con_out("failed to generate function %s\n", f->name);
ir_builder_delete(ir);
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)) {
- con_out("failed to finalize function %s\n", parser->functions[i]->name);
+ for (auto &it : parser->functions) {
+ if (!ir_function_finalize(it->ir_func)) {
+ con_out("failed to finalize function %s\n", it->name);
ir_builder_delete(ir);
return false;
}
projects / xonotic / gmqcc.git / blobdiff