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;
}
}
}
- 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;
}
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);
}
}
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__"))
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;
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;
}
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;
}
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 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;
}
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;
}
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) {
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);
if (isvector)
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;
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]);
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);
for (i = 0; i < vec_size(parser->functions); ++i) {
ast_function *f = parser->functions[i];
if (f->varargs) {
- if (parser->max_param_count > vec_size(f->vtype->expression.params)) {
- f->varargs->expression.count = parser->max_param_count - vec_size(f->vtype->expression.params);
+ if (parser->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);