self->inexact = false;
self->uses = 0;
memset(&self->constval, 0, sizeof(self->constval));
- self->initlist = NULL;
self->ir_v = NULL;
self->ir_values = NULL;
if (self->desc)
mem_d(self->desc);
- if (self->initlist) {
- if (self->expression.next->vtype == TYPE_STRING) {
- /* strings are allocated, free them */
- size_t i, len = vec_size(self->initlist);
- /* in theory, len should be expression.count
- * but let's not take any chances */
- for (i = 0; i < len; ++i) {
- if (self->initlist[i].vstring)
- mem_d(self->initlist[i].vstring);
- }
- }
- vec_free(self->initlist);
+ // initlist imples an array which implies .next in the expression exists.
+ if (self->initlist.size() && self->expression.next->vtype == TYPE_STRING) {
+ for (auto &it : self->initlist)
+ if (it.vstring)
+ mem_d(it.vstring);
}
ast_expression_delete((ast_expression*)self);
ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_switch_codegen);
self->operand = op;
- self->cases = NULL;
ast_propagate_effects(self, op);
void ast_switch_delete(ast_switch *self)
{
- size_t i;
ast_unref(self->operand);
- for (i = 0; i < vec_size(self->cases); ++i) {
- if (self->cases[i].value)
- ast_unref(self->cases[i].value);
- ast_unref(self->cases[i].code);
+ for (auto &it : self->cases) {
+ if (it.value)
+ ast_unref(it.value);
+ ast_unref(it.code);
}
- vec_free(self->cases);
ast_expression_delete((ast_expression*)self);
mem_d(self);
ast_side_effects(self) = true;
- self->params = NULL;
self->func = funcexpr;
self->va_count = NULL;
void ast_call_delete(ast_call *self)
{
- size_t i;
- for (i = 0; i < vec_size(self->params); ++i)
- ast_unref(self->params[i]);
- vec_free(self->params);
+ for (auto &it : self->params)
+ ast_unref(it);
if (self->func)
ast_unref(self->func);
size_t i;
bool retval = true;
const ast_expression *func = self->func;
- size_t count = vec_size(self->params);
+ size_t count = self->params.size();
if (count > func->params.size())
count = func->params.size();
retval = false;
}
}
- count = vec_size(self->params);
+ count = self->params.size();
if (count > func->params.size() && func->varparam) {
for (; i < count; ++i) {
if (ast_istype(self->params[i], ast_argpipe)) {
self->vtype = vtype;
self->name = name ? util_strdup(name) : NULL;
- self->blocks = NULL;
self->labelcount = 0;
self->builtin = 0;
for (i = 0; i < vec_size(self->static_names); ++i)
mem_d(self->static_names[i]);
vec_free(self->static_names);
- for (i = 0; i < vec_size(self->blocks); ++i)
- ast_delete(self->blocks[i]);
- vec_free(self->blocks);
+ for (auto &it : self->blocks)
+ ast_delete(it);
vec_free(self->breakblocks);
vec_free(self->continueblocks);
if (self->varargs)
static bool ast_global_array_set(ast_value *self)
{
- size_t count = vec_size(self->initlist);
+ size_t count = self->initlist.size();
size_t i;
if (count > self->expression.count) {
static bool check_array(ast_value *self, ast_value *array)
{
- if (array->expression.flags & AST_FLAG_ARRAY_INIT && !array->initlist) {
+ if (array->expression.flags & AST_FLAG_ARRAY_INIT && array->initlist.empty()) {
compile_error(ast_ctx(self), "array without size: %s", self->name);
return false;
}
ast_expression *ec;
ast_expression_codegen *cgen;
- size_t i;
-
(void)ir;
irf = self->ir_func;
return false;
}
- if (!vec_size(self->blocks)) {
+ if (self->blocks.empty()) {
compile_error(ast_ctx(self), "function `%s` has no body", self->name);
return false;
}
}
}
- for (i = 0; i < vec_size(self->blocks); ++i) {
- cgen = self->blocks[i]->expression.codegen;
- if (!(*cgen)((ast_expression*)self->blocks[i], self, false, &dummy))
+ for (auto &it : self->blocks) {
+ cgen = it->expression.codegen;
+ if (!(*cgen)((ast_expression*)it, self, false, &dummy))
return false;
}
ir_block *bout = NULL;
ir_block *bfall = NULL;
size_t bout_id;
- size_t c;
char typestr[1024];
uint16_t cmpinstr;
if (!(*cgen)((ast_expression*)(self->operand), func, false, &irop))
return false;
- if (!vec_size(self->cases))
+ if (self->cases.empty())
return true;
cmpinstr = type_eq_instr[irop->vtype];
vec_push(func->breakblocks, bout);
/* Now create all cases */
- for (c = 0; c < vec_size(self->cases); ++c) {
+ for (auto &it : self->cases) {
ir_value *cond, *val;
ir_block *bcase, *bnot;
size_t bnot_id;
- ast_switch_case *swcase = &self->cases[c];
+ ast_switch_case *swcase = ⁢
if (swcase->value) {
/* A regular case */
params = NULL;
/* parameters */
- for (i = 0; i < vec_size(self->params); ++i)
- {
+ for (auto &it : self->params) {
ir_value *param;
- ast_expression *expr = self->params[i];
-
- cgen = expr->codegen;
- if (!(*cgen)(expr, func, false, ¶m))
+ cgen = it->codegen;
+ if (!(*cgen)(it, func, false, ¶m))
goto error;
if (!param)
goto error;