void visit(CompileStatement *) { }
void visit(CompoundStatement *s)
{
- if (s->statements && s->statements->dim)
+ if (s->statements && s->statements->length)
{
- for (size_t i = 0; i < s->statements->dim; i++)
+ for (size_t i = 0; i < s->statements->length; i++)
{
if ((*s->statements)[i])
visitStmt((*s->statements)[i]);
void visit(CompoundDeclarationStatement *s) { visit((CompoundStatement *)s); }
void visit(UnrolledLoopStatement *s)
{
- if (s->statements && s->statements->dim)
+ if (s->statements && s->statements->length)
{
- for (size_t i = 0; i < s->statements->dim; i++)
+ for (size_t i = 0; i < s->statements->length; i++)
{
if ((*s->statements)[i])
visitStmt((*s->statements)[i]);
{
if (s->_body)
visitStmt(s->_body);
- if (s->catches && s->catches->dim)
+ if (s->catches && s->catches->length)
{
- for (size_t i = 0; i < s->catches->dim; i++)
+ for (size_t i = 0; i < s->catches->length; i++)
{
Catch *c = (*s->catches)[i];
if (c && c->handler)
goto Ldone;
bool may_override = false;
- for (size_t i = 0; i < cd->baseclasses->dim; i++)
+ for (size_t i = 0; i < cd->baseclasses->length; i++)
{
BaseClass *b = (*cd->baseclasses)[i];
ClassDeclaration *cbd = b->type->toBasetype()->isClassHandle();
if (!cbd)
continue;
- for (size_t j = 0; j < cbd->vtbl.dim; j++)
+ for (size_t j = 0; j < cbd->vtbl.length; j++)
{
FuncDeclaration *f2 = cbd->vtbl[j]->isFuncDeclaration();
if (!f2 || f2->ident != ident)
/* Find index of existing function in base class's vtbl[] to override
* (the index will be the same as in cd's current vtbl[])
*/
- int vi = cd->baseClass ? findVtblIndex((Dsymbols*)&cd->baseClass->vtbl, (int)cd->baseClass->vtbl.dim)
+ int vi = cd->baseClass ? findVtblIndex((Dsymbols*)&cd->baseClass->vtbl, (int)cd->baseClass->vtbl.length)
: -1;
bool doesoverride = false;
/* These quirky conditions mimic what VC++ appears to do
*/
if (global.params.mscoff && cd->isCPPclass() &&
- cd->baseClass && cd->baseClass->vtbl.dim)
+ cd->baseClass && cd->baseClass->vtbl.length)
{
/* if overriding an interface function, then this is not
* introducing and don't put it in the class vtbl[]
if (cd->isCPPclass() && Target::reverseCppOverloads)
{
// with dmc, overloaded functions are grouped and in reverse order
- vtblIndex = (int)cd->vtbl.dim;
- for (int i = 0; i < (int)cd->vtbl.dim; i++)
+ vtblIndex = (int)cd->vtbl.length;
+ for (int i = 0; i < (int)cd->vtbl.length; i++)
{
if (cd->vtbl[i]->ident == ident && cd->vtbl[i]->parent == parent)
{
}
}
// shift all existing functions back
- for (int i = (int)cd->vtbl.dim; i > vtblIndex; i--)
+ for (int i = (int)cd->vtbl.length; i > vtblIndex; i--)
{
FuncDeclaration *fd = cd->vtbl[i-1]->isFuncDeclaration();
assert(fd);
else
{
// Append to end of vtbl[]
- vi = (int)cd->vtbl.dim;
+ vi = (int)cd->vtbl.length;
cd->vtbl.push(this);
vtblIndex = vi;
}
}
else
{
- int vi2 = findVtblIndex(&cd->baseClass->vtbl, (int)cd->baseClass->vtbl.dim, false);
+ int vi2 = findVtblIndex(&cd->baseClass->vtbl, (int)cd->baseClass->vtbl.length, false);
if (vi2 < 0)
// https://issues.dlang.org/show_bug.cgi?id=17349
::deprecation(loc, "cannot implicitly override base class method `%s` with `%s`; add `override` attribute",
for (size_t i = 0; i < cd->interfaces.length; i++)
{
BaseClass *b = cd->interfaces.ptr[i];
- vi = findVtblIndex((Dsymbols *)&b->sym->vtbl, (int)b->sym->vtbl.dim);
+ vi = findVtblIndex((Dsymbols *)&b->sym->vtbl, (int)b->sym->vtbl.length);
switch (vi)
{
case -1:
{
BaseClass *bc = NULL;
Dsymbol *s = NULL;
- for (size_t i = 0; i < cd->baseclasses->dim; i++)
+ for (size_t i = 0; i < cd->baseclasses->length; i++)
{
bc = (*cd->baseclasses)[i];
s = bc->sym->search_correct(ident);
if (fd->fensure)
return true;
- for (size_t i = 0; i < fd->foverrides.dim; i++)
+ for (size_t i = 0; i < fd->foverrides.length; i++)
{
FuncDeclaration *fdv = fd->foverrides[i];
if (frequire)
{
- for (size_t i = 0; i < foverrides.dim; i++)
+ for (size_t i = 0; i < foverrides.length; i++)
{
FuncDeclaration *fdv = foverrides[i];
// but not in parameters[].
if (f->parameters)
{
- for (size_t i = 0; i < f->parameters->dim; i++)
+ for (size_t i = 0; i < f->parameters->length; i++)
{
Parameter *fparam = (*f->parameters)[i];
*/
if (ad2 && isCtorDeclaration())
{
- allocFieldinit(sc2, ad2->fields.dim);
- for (size_t i = 0; i < ad2->fields.dim; i++)
+ allocFieldinit(sc2, ad2->fields.length);
+ for (size_t i = 0; i < ad2->fields.length; i++)
{
VarDeclaration *v = ad2->fields[i];
v->ctorinit = 0;
if (returns && !fbody->isErrorStatement())
{
- for (size_t i = 0; i < returns->dim; )
+ for (size_t i = 0; i < returns->length; )
{
Expression *exp = (*returns)[i]->exp;
if (exp->op == TOKvar && ((VarExp *)exp)->var == vresult)
* ctor consts were initialized.
*/
ScopeDsymbol *pd = toParent()->isScopeDsymbol();
- for (size_t i = 0; i < pd->members->dim; i++)
+ for (size_t i = 0; i < pd->members->length; i++)
{
Dsymbol *s = (*pd->members)[i];
s->checkCtorConstInit();
// Verify that all the ctorinit fields got initialized
if (!(sc2->callSuper & CSXthis_ctor))
{
- for (size_t i = 0; i < ad2->fields.dim; i++)
+ for (size_t i = 0; i < ad2->fields.length; i++)
{
VarDeclaration *v = ad2->fields[i];
if (v->isThisDeclaration())
/* Cannot move this loop into NrvoWalker, because
* returns[i] may be in the nested delegate for foreach-body.
*/
- for (size_t i = 0; i < returns->dim; i++)
+ for (size_t i = 0; i < returns->length; i++)
{
ReturnStatement *rs = (*returns)[i];
Expression *exp = rs->exp;
// Merge in initialization of 'out' parameters
if (parameters)
{
- for (size_t i = 0; i < parameters->dim; i++)
+ for (size_t i = 0; i < parameters->length; i++)
{
VarDeclaration *v = (*parameters)[i];
if (v->storage_class & STCout)
*/
if (parameters)
{
- for (size_t i = 0; i < parameters->dim; i++)
+ for (size_t i = 0; i < parameters->length; i++)
{
VarDeclaration *v = (*parameters)[i];
// Fix up forward-referenced gotos
if (gotos)
{
- for (size_t i = 0; i < gotos->dim; ++i)
+ for (size_t i = 0; i < gotos->length; ++i)
{
(*gotos)[i]->checkLabel();
}
if (parameters)
{
size_t nfparams = Parameter::dim(f->parameters);
- assert(nfparams == parameters->dim);
- for (size_t u = 0; u < parameters->dim; u++)
+ assert(nfparams == parameters->length);
+ for (size_t u = 0; u < parameters->length; u++)
{
VarDeclaration *v = (*parameters)[u];
if (v->storage_class & STCmaybescope)
* a stack local, allocate that local immediately following the exception
* handler block, so it is always at the same offset from EBP.
*/
- for (size_t i = 0; i < foverrides.dim; i++)
+ for (size_t i = 0; i < foverrides.length; i++)
{
FuncDeclaration *fdv = foverrides[i];
* list for the 'this' pointer, something that would need an unknown amount
* of tweaking of various parts of the compiler that I'd rather leave alone.
*/
- for (size_t i = 0; i < foverrides.dim; i++)
+ for (size_t i = 0; i < foverrides.length; i++)
{
FuncDeclaration *fdv = foverrides[i];
}
/*************************************************
- * Find index of function in vtbl[0..dim] that
+ * Find index of function in vtbl[0..length] that
* this function overrides.
* Prefer an exact match to a covariant one.
* Params:
for (size_t i = 0; i < cd->interfaces.length; i++)
{
BaseClass *b = cd->interfaces.ptr[i];
- int v = findVtblIndex((Dsymbols *)&b->sym->vtbl, (int)b->sym->vtbl.dim);
+ int v = findVtblIndex((Dsymbols *)&b->sym->vtbl, (int)b->sym->vtbl.length);
if (v >= 0)
return b;
}
if (!isVirtual())
return false;
// If it's a final method, and does not override anything, then it is not virtual
- if (isFinalFunc() && foverrides.dim == 0)
+ if (isFinalFunc() && foverrides.length == 0)
{
return false;
}
c.type = tb;
AggregateDeclaration *sym = tb->toDsymbol(NULL)->isAggregateDeclaration();
- for (size_t i = 0; i < sym->fields.dim; i++)
+ for (size_t i = 0; i < sym->fields.length; i++)
{
VarDeclaration *v = sym->fields[i];
Type *tprmi = v->type->addMod(tb->mod);
if (fdthis != this)
{
bool found = false;
- for (size_t i = 0; i < siblingCallers.dim; ++i)
+ for (size_t i = 0; i < siblingCallers.length; ++i)
{
if (siblingCallers[i] == fdthis)
found = true;
for (Dsymbol *sx = f; sx && sx != outerFunc; sx = sx->parent)
{
FuncDeclaration *fy = sx->isFuncDeclaration();
- if (fy && fy->closureVars.dim)
+ if (fy && fy->closureVars.length)
{
/* fy needs a closure if it has closureVars[],
* because the frame pointer in the closure will be accessed.
//printf("checkEscapingSiblings(f = %s, outerfunc = %s)\n", f->toChars(), outerFunc->toChars());
bool bAnyClosures = false;
- for (size_t i = 0; i < f->siblingCallers.dim; ++i)
+ for (size_t i = 0; i < f->siblingCallers.length; ++i)
{
FuncDeclaration *g = f->siblingCallers[i];
if (g->isThis() || g->tookAddressOf)
if (requiresClosure)
goto Lyes;
- for (size_t i = 0; i < closureVars.dim; i++)
+ for (size_t i = 0; i < closureVars.length; i++)
{
VarDeclaration *v = closureVars[i];
//printf("\tv = %s\n", v->toChars());
- for (size_t j = 0; j < v->nestedrefs.dim; j++)
+ for (size_t j = 0; j < v->nestedrefs.length; j++)
{
FuncDeclaration *f = v->nestedrefs[j];
assert(f != this);
}
FuncDeclarations a;
- for (size_t i = 0; i < closureVars.dim; i++)
+ for (size_t i = 0; i < closureVars.length; i++)
{
VarDeclaration *v = closureVars[i];
- for (size_t j = 0; j < v->nestedrefs.dim; j++)
+ for (size_t j = 0; j < v->nestedrefs.length; j++)
{
FuncDeclaration *f = v->nestedrefs[j];
assert(f != this);
Lfound:
for (size_t k = 0; ; k++)
{
- if (k == a.dim)
+ if (k == a.length)
{
a.push(f);
::errorSupplemental(f->loc, "%s closes over variable %s at %s",
bool FuncDeclaration::hasNestedFrameRefs()
{
- if (closureVars.dim)
+ if (closureVars.length)
return true;
/* If a virtual function has contracts, assume its variables are referenced
if (fdrequire || fdensure)
return true;
- if (foverrides.dim && isVirtualMethod())
+ if (foverrides.length && isVirtualMethod())
{
- for (size_t i = 0; i < foverrides.dim; i++)
+ for (size_t i = 0; i < foverrides.length; i++)
{
FuncDeclaration *fdv = foverrides[i];
if (fdv->hasNestedFrameRefs())
projects / thirdparty / gcc.git / blobdiff