/***************************************
* This works by transforming a struct initializer into
* a struct literal. In the future, the two should be the
* same thing.
*/
Expression *StructInitializer::toExpression()
{ Expression *e;
//printf("StructInitializer::toExpression() %s\n", toChars());
if (!ad) // if fwd referenced
{
return NULL;
}
StructDeclaration *sd = ad->isStructDeclaration();
if (!sd)
return NULL;
Expressions *elements = new Expressions();
for (size_t i = 0; i < value.dim; i++)
{
if (field.data[i])
goto Lno;
Initializer *iz = (Initializer *)value.data[i];
if (!iz)
goto Lno;
Expression *ex = iz->toExpression();
if (!ex)
goto Lno;
elements->push(ex);
}
e = new StructLiteralExp(loc, sd, elements);
e->type = sd->type;
return e;
Lno:
delete elements;
//error(loc, "struct initializers as expressions are not allowed");
return NULL;
}
Expression *ArrayInitializer::toExpression()
{ Expressions *elements;
Expression *e;
//printf("ArrayInitializer::toExpression()\n");
//static int i; if (++i == 2) halt();
elements = new Expressions();
for (size_t i = 0; i < value.dim; i++)
{
if (index.data[i])
goto Lno;
Initializer *iz = (Initializer *)value.data[i];
if (!iz)
goto Lno;
Expression *ex = iz->toExpression();
if (!ex)
goto Lno;
elements->push(ex);
}
e = new ArrayLiteralExp(loc, elements);
e->type = type;
return e;
Lno:
delete elements;
//error(loc, "array initializers as expressions are not allowed");
return NULL;
}
Expressions *UserAttributeDeclaration::getAttributes()
{
if (scope)
{
Scope *sc = scope;
scope = NULL;
arrayExpressionSemantic(atts, sc);
}
Expressions *exps = new Expressions();
if (userAttribDecl)
exps->push(new TupleExp(Loc(), userAttribDecl->getAttributes()));
if (atts && atts->dim)
exps->push(new TupleExp(Loc(), atts));
return exps;
}
FuncDeclaration *AggregateDeclaration::hasIdentityOpAssign(Scope *sc, Dsymbol *assign)
{
if (assign)
{
/* check identity opAssign exists
*/
Expression *er = new NullExp(loc, type); // dummy rvalue
Expression *el = new IdentifierExp(loc, Id::p); // dummy lvalue
el->type = type;
Expressions ar; ar.push(er);
Expressions al; al.push(el);
FuncDeclaration *f = NULL;
unsigned errors = global.startGagging(); // Do not report errors, even if the
unsigned oldspec = global.speculativeGag; // template opAssign fbody makes it.
global.speculativeGag = global.gag;
sc = sc->push();
sc->speculative = true;
f = resolveFuncCall(loc, sc, assign, NULL, er, &ar, 1);
if (!f) f = resolveFuncCall(loc, sc, assign, NULL, er, &al, 1);
sc = sc->pop();
global.speculativeGag = oldspec;
global.endGagging(errors);
if (f)
{
int varargs;
Parameters *fparams = f->getParameters(&varargs);
if (fparams->dim >= 1)
{
Parameter *arg0 = Parameter::getNth(fparams, 0);
if (arg0->type->toDsymbol(NULL) != this)
f = NULL;
}
}
// BUGS: This detection mechanism cannot find some opAssign-s like follows:
// struct S { void opAssign(ref immutable S) const; }
return f;
}
return NULL;
}
void visit(SliceExp *e)
{
Identifier *id = Identifier::generateId("p", fparams->dim);
Parameter *param = new Parameter(STCconst, e->type, id, NULL);
fparams->shift(param);
Expression *ie = new IdentifierExp(Loc(), id);
Expressions *arguments = new Expressions();
Expression *index = new IdentifierExp(Loc(), Id::p);
arguments->push(index);
result = new ArrayExp(Loc(), ie, arguments);
}
Expression *SliceExp::buildArrayLoop(Parameters *fparams)
{
Identifier *id = Identifier::generateId("p", fparams->dim);
Parameter *param = new Parameter(STCconst, type, id, NULL);
fparams->shift(param);
Expression *e = new IdentifierExp(0, id);
Expressions *arguments = new Expressions();
Expression *index = new IdentifierExp(0, Id::p);
arguments->push(index);
e = new ArrayExp(0, e, arguments);
return e;
}
void UserAttributeDeclaration::setScope(Scope *sc)
{
//printf("UserAttributeDeclaration::setScope() %p\n", this);
if (decl)
{
Scope *newsc = sc;
#if 1
if (atts && atts->dim)
{
// create new one for changes
newsc = new Scope(*sc);
newsc->flags &= ~SCOPEfree;
// Append new atts to old one
if (!newsc->userAttributes || newsc->userAttributes->dim == 0)
newsc->userAttributes = atts;
else
{
// Create a tuple that combines them
Expressions *exps = new Expressions();
exps->push(new TupleExp(Loc(), newsc->userAttributes));
exps->push(new TupleExp(Loc(), atts));
newsc->userAttributes = exps;
}
}
#endif
for (size_t i = 0; i < decl->dim; i++)
{ Dsymbol *s = (*decl)[i];
s->setScope(newsc); // yes, the only difference from semantic()
}
if (newsc != sc)
{
sc->offset = newsc->offset;
newsc->pop();
}
}
}
Expressions *UserAttributeDeclaration::concat(Expressions *udas1, Expressions *udas2)
{
Expressions *udas;
if (!udas1 || udas1->dim == 0)
udas = udas2;
else if (!udas2 || udas2->dim == 0)
udas = udas1;
else
{
/* Create a new tuple that combines them
* (do not append to left operand, as this is a copy-on-write operation)
*/
udas = new Expressions();
udas->push(new TupleExp(Loc(), udas1));
udas->push(new TupleExp(Loc(), udas2));
}
return udas;
}
/***********************************
* Parse list of extended asm clobbers.
* Grammar:
* | Clobbers:
* | StringLiteral
* | StringLiteral , Clobbers
* Params:
* p = parser state
* Returns:
* array of parsed clobber expressions
*/
static Expressions *parseExtAsmClobbers(Parser *p)
{
Expressions *clobbers = NULL;
while (1)
{
Expression *clobber;
switch (p->token.value)
{
case TOKsemicolon:
case TOKcolon:
case TOKeof:
return clobbers;
case TOKstring:
clobber = p->parsePrimaryExp();
if (!clobbers)
clobbers = new Expressions();
clobbers->push(clobber);
if (p->token.value == TOKcomma)
p->nextToken();
break;
default:
p->error("expected constant string constraint for clobber name, not `%s`",
p->token.toChars());
goto Lerror;
}
}
Lerror:
while (p->token.value != TOKrcurly &&
p->token.value != TOKsemicolon &&
p->token.value != TOKeof)
p->nextToken();
return clobbers;
}
void FuncDeclaration_toObjFile(FuncDeclaration *fd, bool multiobj)
{
ClassDeclaration *cd = fd->parent->isClassDeclaration();
//printf("FuncDeclaration::toObjFile(%p, %s.%s)\n", fd, fd->parent->toChars(), fd->toChars());
//if (type) printf("type = %s\n", type->toChars());
#if 0
//printf("line = %d\n", getWhere() / LINEINC);
EEcontext *ee = env->getEEcontext();
if (ee->EEcompile == 2)
{
if (ee->EElinnum < (getWhere() / LINEINC) ||
ee->EElinnum > (endwhere / LINEINC)
)
return; // don't compile this function
ee->EEfunc = toSymbol(this);
}
#endif
if (fd->semanticRun >= PASSobj) // if toObjFile() already run
return;
if (fd->type && fd->type->ty == Tfunction && ((TypeFunction *)fd->type)->next == NULL)
return;
// If errors occurred compiling it, such as bugzilla 6118
if (fd->type && fd->type->ty == Tfunction && ((TypeFunction *)fd->type)->next->ty == Terror)
return;
if (global.errors)
return;
if (!fd->fbody)
return;
UnitTestDeclaration *ud = fd->isUnitTestDeclaration();
if (ud && !global.params.useUnitTests)
return;
if (multiobj && !fd->isStaticDtorDeclaration() && !fd->isStaticCtorDeclaration())
{
obj_append(fd);
return;
}
if (fd->semanticRun == PASSsemanticdone)
{
/* What happened is this function failed semantic3() with errors,
* but the errors were gagged.
* Try to reproduce those errors, and then fail.
*/
fd->error("errors compiling the function");
return;
}
assert(fd->semanticRun == PASSsemantic3done);
assert(fd->ident != Id::empty);
for (FuncDeclaration *fd2 = fd; fd2; )
{
if (fd2->inNonRoot())
return;
if (fd2->isNested())
fd2 = fd2->toParent2()->isFuncDeclaration();
else
break;
}
FuncDeclaration *fdp = fd->toParent2()->isFuncDeclaration();
if (fd->isNested())
{
if (fdp && fdp->semanticRun < PASSobj)
{
if (fdp->semantic3Errors)
return;
/* Can't do unittest's out of order, they are order dependent in that their
* execution is done in lexical order.
*/
if (UnitTestDeclaration *udp = fdp->isUnitTestDeclaration())
{
udp->deferredNested.push(fd);
return;
}
}
}
if (fd->isArrayOp && isDruntimeArrayOp(fd->ident))
{
// Implementation is in druntime
return;
}
// start code generation
fd->semanticRun = PASSobj;
if (global.params.verbose)
fprintf(global.stdmsg, "function %s\n", fd->toPrettyChars());
Symbol *s = toSymbol(fd);
func_t *f = s->Sfunc;
// tunnel type of "this" to debug info generation
if (AggregateDeclaration* ad = fd->parent->isAggregateDeclaration())
{
::type* t = Type_toCtype(ad->getType());
if (cd)
t = t->Tnext; // skip reference
f->Fclass = (Classsym *)t;
}
#if TARGET_WINDOS
/* This is done so that the 'this' pointer on the stack is the same
* distance away from the function parameters, so that an overriding
* function can call the nested fdensure or fdrequire of its overridden function
* and the stack offsets are the same.
*/
if (fd->isVirtual() && (fd->fensure || fd->frequire))
f->Fflags3 |= Ffakeeh;
#endif
#if TARGET_OSX
s->Sclass = SCcomdat;
#else
s->Sclass = SCglobal;
#endif
for (Dsymbol *p = fd->parent; p; p = p->parent)
{
if (p->isTemplateInstance())
{
s->Sclass = SCcomdat;
break;
}
}
/* Vector operations should be comdat's
*/
if (fd->isArrayOp)
s->Sclass = SCcomdat;
if (fd->isNested())
{
//if (!(config.flags3 & CFG3pic))
// s->Sclass = SCstatic;
f->Fflags3 |= Fnested;
/* The enclosing function must have its code generated first,
* in order to calculate correct frame pointer offset.
*/
if (fdp && fdp->semanticRun < PASSobj)
{
toObjFile(fdp, multiobj);
}
}
else
{
const char *libname = (global.params.symdebug)
? global.params.debuglibname
: global.params.defaultlibname;
// Pull in RTL startup code (but only once)
if (fd->isMain() && onlyOneMain(fd->loc))
{
#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS
objmod->external_def("_main");
objmod->ehsections(); // initialize exception handling sections
#endif
#if TARGET_WINDOS
if (global.params.mscoff)
{
objmod->external_def("main");
objmod->ehsections(); // initialize exception handling sections
}
else
{
objmod->external_def("_main");
objmod->external_def("__acrtused_con");
}
#endif
objmod->includelib(libname);
s->Sclass = SCglobal;
}
else if (strcmp(s->Sident, "main") == 0 && fd->linkage == LINKc)
{
#if TARGET_WINDOS
if (global.params.mscoff)
{
objmod->includelib("LIBCMT");
objmod->includelib("OLDNAMES");
}
else
{
objmod->external_def("__acrtused_con"); // bring in C startup code
objmod->includelib("snn.lib"); // bring in C runtime library
}
#endif
s->Sclass = SCglobal;
}
#if TARGET_WINDOS
else if (fd->isWinMain() && onlyOneMain(fd->loc))
{
if (global.params.mscoff)
{
objmod->includelib("uuid");
objmod->includelib("LIBCMT");
objmod->includelib("OLDNAMES");
objmod->ehsections(); // initialize exception handling sections
}
else
{
objmod->external_def("__acrtused");
}
objmod->includelib(libname);
s->Sclass = SCglobal;
}
// Pull in RTL startup code
else if (fd->isDllMain() && onlyOneMain(fd->loc))
{
if (global.params.mscoff)
{
objmod->includelib("uuid");
objmod->includelib("LIBCMT");
objmod->includelib("OLDNAMES");
objmod->ehsections(); // initialize exception handling sections
}
else
{
objmod->external_def("__acrtused_dll");
}
objmod->includelib(libname);
s->Sclass = SCglobal;
}
#endif
}
symtab_t *symtabsave = cstate.CSpsymtab;
cstate.CSpsymtab = &f->Flocsym;
// Find module m for this function
Module *m = NULL;
for (Dsymbol *p = fd->parent; p; p = p->parent)
{
m = p->isModule();
if (m)
break;
}
IRState irs(m, fd);
Dsymbols deferToObj; // write these to OBJ file later
irs.deferToObj = &deferToObj;
symbol *shidden = NULL;
Symbol *sthis = NULL;
tym_t tyf = tybasic(s->Stype->Tty);
//printf("linkage = %d, tyf = x%x\n", linkage, tyf);
int reverse = tyrevfunc(s->Stype->Tty);
assert(fd->type->ty == Tfunction);
TypeFunction *tf = (TypeFunction *)fd->type;
RET retmethod = retStyle(tf);
if (retmethod == RETstack)
{
// If function returns a struct, put a pointer to that
// as the first argument
::type *thidden = Type_toCtype(tf->next->pointerTo());
char hiddenparam[5+4+1];
static int hiddenparami; // how many we've generated so far
sprintf(hiddenparam,"__HID%d",++hiddenparami);
shidden = symbol_name(hiddenparam,SCparameter,thidden);
shidden->Sflags |= SFLtrue | SFLfree;
if (fd->nrvo_can && fd->nrvo_var && fd->nrvo_var->nestedrefs.dim)
type_setcv(&shidden->Stype, shidden->Stype->Tty | mTYvolatile);
irs.shidden = shidden;
fd->shidden = shidden;
}
else
{
// Register return style cannot make nrvo.
// Auto functions keep the nrvo_can flag up to here,
// so we should eliminate it before entering backend.
fd->nrvo_can = 0;
}
if (fd->vthis)
{
assert(!fd->vthis->csym);
sthis = toSymbol(fd->vthis);
irs.sthis = sthis;
if (!(f->Fflags3 & Fnested))
f->Fflags3 |= Fmember;
}
// Estimate number of parameters, pi
size_t pi = (fd->v_arguments != NULL);
if (fd->parameters)
pi += fd->parameters->dim;
// Create a temporary buffer, params[], to hold function parameters
Symbol *paramsbuf[10];
Symbol **params = paramsbuf; // allocate on stack if possible
if (pi + 2 > 10) // allow extra 2 for sthis and shidden
{
params = (Symbol **)malloc((pi + 2) * sizeof(Symbol *));
assert(params);
}
// Get the actual number of parameters, pi, and fill in the params[]
pi = 0;
if (fd->v_arguments)
{
params[pi] = toSymbol(fd->v_arguments);
pi += 1;
}
if (fd->parameters)
{
for (size_t i = 0; i < fd->parameters->dim; i++)
{
VarDeclaration *v = (*fd->parameters)[i];
//printf("param[%d] = %p, %s\n", i, v, v->toChars());
assert(!v->csym);
params[pi + i] = toSymbol(v);
}
pi += fd->parameters->dim;
}
if (reverse)
{
// Reverse params[] entries
for (size_t i = 0; i < pi/2; i++)
{
Symbol *sptmp = params[i];
params[i] = params[pi - 1 - i];
params[pi - 1 - i] = sptmp;
}
}
if (shidden)
{
#if 0
// shidden becomes last parameter
params[pi] = shidden;
#else
// shidden becomes first parameter
memmove(params + 1, params, pi * sizeof(params[0]));
params[0] = shidden;
#endif
pi++;
}
if (sthis)
{
#if 0
// sthis becomes last parameter
params[pi] = sthis;
#else
// sthis becomes first parameter
memmove(params + 1, params, pi * sizeof(params[0]));
params[0] = sthis;
#endif
pi++;
}
if ((global.params.isLinux || global.params.isOSX || global.params.isFreeBSD || global.params.isSolaris) &&
fd->linkage != LINKd && shidden && sthis)
{
/* swap shidden and sthis
*/
Symbol *sp = params[0];
params[0] = params[1];
params[1] = sp;
}
for (size_t i = 0; i < pi; i++)
{
Symbol *sp = params[i];
sp->Sclass = SCparameter;
sp->Sflags &= ~SFLspill;
sp->Sfl = FLpara;
symbol_add(sp);
}
// Determine register assignments
if (pi)
{
FuncParamRegs fpr(tyf);
for (size_t i = 0; i < pi; i++)
{
Symbol *sp = params[i];
if (fpr.alloc(sp->Stype, sp->Stype->Tty, &sp->Spreg, &sp->Spreg2))
{
sp->Sclass = (config.exe == EX_WIN64) ? SCshadowreg : SCfastpar;
sp->Sfl = (sp->Sclass == SCshadowreg) ? FLpara : FLfast;
}
}
}
// Done with params
if (params != paramsbuf)
free(params);
params = NULL;
if (fd->fbody)
{
localgot = NULL;
Statement *sbody = fd->fbody;
Blockx bx;
memset(&bx,0,sizeof(bx));
bx.startblock = block_calloc();
bx.curblock = bx.startblock;
bx.funcsym = s;
bx.scope_index = -1;
bx.classdec = cd;
bx.member = fd;
bx.module = fd->getModule();
irs.blx = &bx;
/* Doing this in semantic3() caused all kinds of problems:
* 1. couldn't reliably get the final mangling of the function name due to fwd refs
* 2. impact on function inlining
* 3. what to do when writing out .di files, or other pretty printing
*/
if (global.params.trace && !fd->isCMain())
{
/* The profiler requires TLS, and TLS may not be set up yet when C main()
* gets control (i.e. OSX), leading to a crash.
*/
/* Wrap the entire function body in:
* trace_pro("funcname");
* try
* body;
* finally
* _c_trace_epi();
*/
StringExp *se = StringExp::create(Loc(), s->Sident);
se->type = Type::tstring;
se->type = se->type->semantic(Loc(), NULL);
Expressions *exps = Expressions_create();
exps->push(se);
FuncDeclaration *fdpro = FuncDeclaration::genCfunc(NULL, Type::tvoid, "trace_pro");
Expression *ec = VarExp::create(Loc(), fdpro);
Expression *e = CallExp::create(Loc(), ec, exps);
e->type = Type::tvoid;
Statement *sp = ExpStatement::create(fd->loc, e);
FuncDeclaration *fdepi = FuncDeclaration::genCfunc(NULL, Type::tvoid, "_c_trace_epi");
ec = VarExp::create(Loc(), fdepi);
e = CallExp::create(Loc(), ec);
e->type = Type::tvoid;
Statement *sf = ExpStatement::create(fd->loc, e);
Statement *stf;
if (sbody->blockExit(fd, false) == BEfallthru)
stf = CompoundStatement::create(Loc(), sbody, sf);
else
stf = TryFinallyStatement::create(Loc(), sbody, sf);
sbody = CompoundStatement::create(Loc(), sp, stf);
}
buildClosure(fd, &irs);
#if TARGET_WINDOS
if (fd->isSynchronized() && cd && config.flags2 & CFG2seh &&
!fd->isStatic() && !sbody->usesEH() && !global.params.trace)
{
/* The "jmonitor" hack uses an optimized exception handling frame
* which is a little shorter than the more general EH frame.
*/
s->Sfunc->Fflags3 |= Fjmonitor;
}
#endif
Statement_toIR(sbody, &irs);
bx.curblock->BC = BCret;
f->Fstartblock = bx.startblock;
// einit = el_combine(einit,bx.init);
if (fd->isCtorDeclaration())
{
assert(sthis);
for (block *b = f->Fstartblock; b; b = b->Bnext)
{
if (b->BC == BCret)
{
b->BC = BCretexp;
b->Belem = el_combine(b->Belem, el_var(sthis));
}
}
}
}
// If static constructor
if (fd->isSharedStaticCtorDeclaration()) // must come first because it derives from StaticCtorDeclaration
{
ssharedctors.push(s);
}
else if (fd->isStaticCtorDeclaration())
{
sctors.push(s);
}
// If static destructor
if (fd->isSharedStaticDtorDeclaration()) // must come first because it derives from StaticDtorDeclaration
{
SharedStaticDtorDeclaration *f = fd->isSharedStaticDtorDeclaration();
assert(f);
if (f->vgate)
{
/* Increment destructor's vgate at construction time
*/
esharedctorgates.push(f);
}
sshareddtors.shift(s);
}
else if (fd->isStaticDtorDeclaration())
{
StaticDtorDeclaration *f = fd->isStaticDtorDeclaration();
assert(f);
if (f->vgate)
{
/* Increment destructor's vgate at construction time
*/
ectorgates.push(f);
}
sdtors.shift(s);
}
// If unit test
if (ud)
{
stests.push(s);
}
if (global.errors)
{
// Restore symbol table
cstate.CSpsymtab = symtabsave;
return;
}
writefunc(s);
// Restore symbol table
cstate.CSpsymtab = symtabsave;
if (fd->isExport())
objmod->export_symbol(s, Para.offset);
for (size_t i = 0; i < irs.deferToObj->dim; i++)
{
Dsymbol *s = (*irs.deferToObj)[i];
toObjFile(s, false);
}
if (ud)
{
for (size_t i = 0; i < ud->deferredNested.dim; i++)
{
FuncDeclaration *fd = ud->deferredNested[i];
toObjFile(fd, false);
}
}
#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS
// A hack to get a pointer to this function put in the .dtors segment
if (fd->ident && memcmp(fd->ident->toChars(), "_STD", 4) == 0)
objmod->staticdtor(s);
#endif
if (irs.startaddress)
{
//printf("Setting start address\n");
objmod->startaddress(irs.startaddress);
}
}
void ClassDeclaration::semantic(Scope *sc)
{
//printf("ClassDeclaration::semantic(%s), type = %p, sizeok = %d, this = %p\n", toChars(), type, sizeok, this);
//printf("\tparent = %p, '%s'\n", sc->parent, sc->parent ? sc->parent->toChars() : "");
//printf("sc->stc = %x\n", sc->stc);
//{ static int n; if (++n == 20) *(char*)0=0; }
if (!ident) // if anonymous class
{ const char *id = "__anonclass";
ident = Identifier::generateId(id);
}
if (!sc)
sc = scope;
if (!parent && sc->parent && !sc->parent->isModule())
parent = sc->parent;
type = type->semantic(loc, sc);
handle = type;
if (!members) // if forward reference
{ //printf("\tclass '%s' is forward referenced\n", toChars());
return;
}
if (symtab)
{ if (sizeok == SIZEOKdone || !scope)
{ //printf("\tsemantic for '%s' is already completed\n", toChars());
return; // semantic() already completed
}
}
else
symtab = new DsymbolTable();
Scope *scx = NULL;
if (scope)
{ sc = scope;
scx = scope; // save so we don't make redundant copies
scope = NULL;
}
unsigned dprogress_save = Module::dprogress;
int errors = global.gaggedErrors;
if (sc->stc & STCdeprecated)
{
isdeprecated = true;
}
userAttributes = sc->userAttributes;
if (sc->linkage == LINKcpp)
error("cannot create C++ classes");
// Expand any tuples in baseclasses[]
for (size_t i = 0; i < baseclasses->dim; )
{ BaseClass *b = (*baseclasses)[i];
b->type = b->type->semantic(loc, sc);
Type *tb = b->type->toBasetype();
if (tb->ty == Ttuple)
{ TypeTuple *tup = (TypeTuple *)tb;
enum PROT protection = b->protection;
baseclasses->remove(i);
size_t dim = Parameter::dim(tup->arguments);
for (size_t j = 0; j < dim; j++)
{ Parameter *arg = Parameter::getNth(tup->arguments, j);
b = new BaseClass(arg->type, protection);
baseclasses->insert(i + j, b);
}
}
else
i++;
}
// See if there's a base class as first in baseclasses[]
if (baseclasses->dim)
{ TypeClass *tc;
BaseClass *b;
Type *tb;
b = (*baseclasses)[0];
//b->type = b->type->semantic(loc, sc);
tb = b->type->toBasetype();
if (tb->ty != Tclass)
{ if (b->type != Type::terror)
error("base type must be class or interface, not %s", b->type->toChars());
baseclasses->remove(0);
}
else
{
tc = (TypeClass *)(tb);
if (tc->sym->isDeprecated())
{
if (!isDeprecated())
{
// Deriving from deprecated class makes this one deprecated too
isdeprecated = true;
tc->checkDeprecated(loc, sc);
}
}
if (tc->sym->isInterfaceDeclaration())
;
else
{
for (ClassDeclaration *cdb = tc->sym; cdb; cdb = cdb->baseClass)
{
if (cdb == this)
{
error("circular inheritance");
baseclasses->remove(0);
goto L7;
}
}
if (!tc->sym->symtab || tc->sym->sizeok == SIZEOKnone)
{ // Try to resolve forward reference
if (/*sc->mustsemantic &&*/ tc->sym->scope)
tc->sym->semantic(NULL);
}
if (!tc->sym->symtab || tc->sym->scope || tc->sym->sizeok == SIZEOKnone)
{
//printf("%s: forward reference of base class %s\n", toChars(), tc->sym->toChars());
//error("forward reference of base class %s", baseClass->toChars());
// Forward reference of base class, try again later
//printf("\ttry later, forward reference of base class %s\n", tc->sym->toChars());
scope = scx ? scx : new Scope(*sc);
scope->setNoFree();
if (tc->sym->scope)
tc->sym->scope->module->addDeferredSemantic(tc->sym);
scope->module->addDeferredSemantic(this);
return;
}
else
{ baseClass = tc->sym;
b->base = baseClass;
}
L7: ;
}
}
}
// Treat the remaining entries in baseclasses as interfaces
// Check for errors, handle forward references
for (size_t i = (baseClass ? 1 : 0); i < baseclasses->dim; )
{ TypeClass *tc;
BaseClass *b;
Type *tb;
b = (*baseclasses)[i];
b->type = b->type->semantic(loc, sc);
tb = b->type->toBasetype();
if (tb->ty == Tclass)
tc = (TypeClass *)tb;
else
tc = NULL;
if (!tc || !tc->sym->isInterfaceDeclaration())
{ if (b->type != Type::terror)
error("base type must be interface, not %s", b->type->toChars());
baseclasses->remove(i);
continue;
}
else
{
if (tc->sym->isDeprecated())
{
if (!isDeprecated())
{
// Deriving from deprecated class makes this one deprecated too
isdeprecated = true;
tc->checkDeprecated(loc, sc);
}
}
// Check for duplicate interfaces
for (size_t j = (baseClass ? 1 : 0); j < i; j++)
{
BaseClass *b2 = (*baseclasses)[j];
if (b2->base == tc->sym)
error("inherits from duplicate interface %s", b2->base->toChars());
}
if (!tc->sym->symtab)
{ // Try to resolve forward reference
if (/*sc->mustsemantic &&*/ tc->sym->scope)
tc->sym->semantic(NULL);
}
b->base = tc->sym;
if (!b->base->symtab || b->base->scope)
{
//error("forward reference of base class %s", baseClass->toChars());
// Forward reference of base, try again later
//printf("\ttry later, forward reference of base %s\n", baseClass->toChars());
scope = scx ? scx : new Scope(*sc);
scope->setNoFree();
if (tc->sym->scope)
tc->sym->scope->module->addDeferredSemantic(tc->sym);
scope->module->addDeferredSemantic(this);
return;
}
}
i++;
}
// If no base class, and this is not an Object, use Object as base class
if (!baseClass && ident != Id::Object)
{
if (!object)
{
error("missing or corrupt object.d");
fatal();
}
Type *t = object->type;
t = t->semantic(loc, sc)->toBasetype();
assert(t->ty == Tclass);
TypeClass *tc = (TypeClass *)t;
BaseClass *b = new BaseClass(tc, PROTpublic);
baseclasses->shift(b);
baseClass = tc->sym;
assert(!baseClass->isInterfaceDeclaration());
b->base = baseClass;
}
interfaces_dim = baseclasses->dim;
interfaces = baseclasses->tdata();
if (baseClass)
{
if (baseClass->storage_class & STCfinal)
error("cannot inherit from final class %s", baseClass->toChars());
interfaces_dim--;
interfaces++;
// Copy vtbl[] from base class
vtbl.setDim(baseClass->vtbl.dim);
memcpy(vtbl.tdata(), baseClass->vtbl.tdata(), sizeof(void *) * vtbl.dim);
// Inherit properties from base class
com = baseClass->isCOMclass();
isscope = baseClass->isscope;
vthis = baseClass->vthis;
storage_class |= baseClass->storage_class & STC_TYPECTOR;
}
else
{
// No base class, so this is the root of the class hierarchy
vtbl.setDim(0);
vtbl.push(this); // leave room for classinfo as first member
}
protection = sc->protection;
storage_class |= sc->stc;
if (sizeok == SIZEOKnone)
{
interfaceSemantic(sc);
for (size_t i = 0; i < members->dim; i++)
{
Dsymbol *s = (*members)[i];
s->addMember(sc, this, 1);
}
/* If this is a nested class, add the hidden 'this'
* member which is a pointer to the enclosing scope.
*/
if (vthis) // if inheriting from nested class
{ // Use the base class's 'this' member
isnested = true;
if (storage_class & STCstatic)
error("static class cannot inherit from nested class %s", baseClass->toChars());
if (toParent2() != baseClass->toParent2() &&
(!toParent2() ||
!baseClass->toParent2()->getType() ||
!baseClass->toParent2()->getType()->isBaseOf(toParent2()->getType(), NULL)))
{
if (toParent2())
{
error("is nested within %s, but super class %s is nested within %s",
toParent2()->toChars(),
baseClass->toChars(),
baseClass->toParent2()->toChars());
}
else
{
error("is not nested, but super class %s is nested within %s",
baseClass->toChars(),
baseClass->toParent2()->toChars());
}
isnested = false;
}
}
else if (!(storage_class & STCstatic))
{ Dsymbol *s = toParent2();
if (s)
{
AggregateDeclaration *ad = s->isClassDeclaration();
FuncDeclaration *fd = s->isFuncDeclaration();
if (ad || fd)
{ isnested = true;
Type *t;
if (ad)
t = ad->handle;
else if (fd)
{ AggregateDeclaration *ad2 = fd->isMember2();
if (ad2)
t = ad2->handle;
else
{
t = Type::tvoidptr;
}
}
else
assert(0);
if (t->ty == Tstruct) // ref to struct
t = Type::tvoidptr;
assert(!vthis);
vthis = new ThisDeclaration(loc, t);
members->push(vthis);
}
}
}
}
if (storage_class & STCauto)
error("storage class 'auto' is invalid when declaring a class, did you mean to use 'scope'?");
if (storage_class & STCscope)
isscope = 1;
if (storage_class & STCabstract)
isabstract = 1;
sc = sc->push(this);
//sc->stc &= ~(STCfinal | STCauto | STCscope | STCstatic | STCabstract | STCdeprecated | STC_TYPECTOR | STCtls | STCgshared);
//sc->stc |= storage_class & STC_TYPECTOR;
sc->stc &= STCsafe | STCtrusted | STCsystem;
sc->parent = this;
sc->inunion = 0;
if (isCOMclass())
{
#if _WIN32
sc->linkage = LINKwindows;
#else
/* This enables us to use COM objects under Linux and
* work with things like XPCOM
*/
sc->linkage = LINKc;
#endif
}
sc->protection = PROTpublic;
sc->explicitProtection = 0;
sc->structalign = STRUCTALIGN_DEFAULT;
if (baseClass)
{ sc->offset = baseClass->structsize;
alignsize = baseClass->alignsize;
// if (isnested)
// sc->offset += PTRSIZE; // room for uplevel context pointer
}
else
{ sc->offset = PTRSIZE * 2; // allow room for __vptr and __monitor
alignsize = PTRSIZE;
}
sc->userAttributes = NULL;
structsize = sc->offset;
Scope scsave = *sc;
size_t members_dim = members->dim;
sizeok = SIZEOKnone;
/* Set scope so if there are forward references, we still might be able to
* resolve individual members like enums.
*/
for (size_t i = 0; i < members_dim; i++)
{ Dsymbol *s = (*members)[i];
/* There are problems doing this in the general case because
* Scope keeps track of things like 'offset'
*/
if (s->isEnumDeclaration() ||
(s->isAggregateDeclaration() && s->ident) ||
s->isTemplateMixin() ||
s->isAttribDeclaration() ||
s->isAliasDeclaration())
{
//printf("[%d] setScope %s %s, sc = %p\n", i, s->kind(), s->toChars(), sc);
s->setScope(sc);
}
}
for (size_t i = 0; i < members_dim; i++)
{ Dsymbol *s = (*members)[i];
s->semantic(sc);
}
// Set the offsets of the fields and determine the size of the class
unsigned offset = structsize;
bool isunion = isUnionDeclaration() != NULL;
for (size_t i = 0; i < members->dim; i++)
{ Dsymbol *s = (*members)[i];
s->setFieldOffset(this, &offset, false);
}
sc->offset = structsize;
if (global.gag && global.gaggedErrors != errors)
{ // The type is no good, yet the error messages were gagged.
type = Type::terror;
}
if (sizeok == SIZEOKfwd) // failed due to forward references
{ // semantic() failed due to forward references
// Unwind what we did, and defer it for later
for (size_t i = 0; i < fields.dim; i++)
{ Dsymbol *s = fields[i];
VarDeclaration *vd = s->isVarDeclaration();
if (vd)
vd->offset = 0;
}
fields.setDim(0);
structsize = 0;
alignsize = 0;
// structalign = 0;
sc = sc->pop();
scope = scx ? scx : new Scope(*sc);
scope->setNoFree();
scope->module->addDeferredSemantic(this);
Module::dprogress = dprogress_save;
//printf("\tsemantic('%s') failed due to forward references\n", toChars());
return;
}
//printf("\tsemantic('%s') successful\n", toChars());
//members->print();
/* Look for special member functions.
* They must be in this class, not in a base class.
*/
ctor = search(0, Id::ctor, 0);
#if DMDV1
if (ctor && (ctor->toParent() != this || !ctor->isCtorDeclaration()))
ctor = NULL;
#else
if (ctor && (ctor->toParent() != this || !(ctor->isCtorDeclaration() || ctor->isTemplateDeclaration())))
ctor = NULL; // search() looks through ancestor classes
#endif
// dtor = (DtorDeclaration *)search(Id::dtor, 0);
// if (dtor && dtor->toParent() != this)
// dtor = NULL;
// inv = (InvariantDeclaration *)search(Id::classInvariant, 0);
// if (inv && inv->toParent() != this)
// inv = NULL;
// Can be in base class
aggNew = (NewDeclaration *)search(0, Id::classNew, 0);
aggDelete = (DeleteDeclaration *)search(0, Id::classDelete, 0);
// If this class has no constructor, but base class does, create
// a constructor:
// this() { }
if (!ctor && baseClass && baseClass->ctor)
{
//printf("Creating default this(){} for class %s\n", toChars());
Type *tf = new TypeFunction(NULL, NULL, 0, LINKd, 0);
CtorDeclaration *ctor = new CtorDeclaration(loc, 0, 0, tf);
ctor->fbody = new CompoundStatement(0, new Statements());
members->push(ctor);
ctor->addMember(sc, this, 1);
*sc = scsave; // why? What about sc->nofree?
ctor->semantic(sc);
this->ctor = ctor;
defaultCtor = ctor;
}
#if 0
if (baseClass)
{ if (!aggDelete)
aggDelete = baseClass->aggDelete;
if (!aggNew)
aggNew = baseClass->aggNew;
}
#endif
// Allocate instance of each new interface
sc->offset = structsize;
for (size_t i = 0; i < vtblInterfaces->dim; i++)
{
BaseClass *b = (*vtblInterfaces)[i];
unsigned thissize = PTRSIZE;
alignmember(STRUCTALIGN_DEFAULT, thissize, &sc->offset);
assert(b->offset == 0);
b->offset = sc->offset;
// Take care of single inheritance offsets
while (b->baseInterfaces_dim)
{
b = &b->baseInterfaces[0];
b->offset = sc->offset;
}
sc->offset += thissize;
if (alignsize < thissize)
alignsize = thissize;
}
structsize = sc->offset;
sizeok = SIZEOKdone;
Module::dprogress++;
dtor = buildDtor(sc);
if (Dsymbol *assign = search_function(this, Id::assign))
{
Expression *e = new NullExp(loc, type); // dummy rvalue
Expressions *arguments = new Expressions();
arguments->push(e);
// check identity opAssign exists
FuncDeclaration *fd = assign->isFuncDeclaration();
if (fd)
{ fd = fd->overloadResolve(loc, e, arguments, 1);
if (fd && !(fd->storage_class & STCdisable))
goto Lassignerr;
}
if (TemplateDeclaration *td = assign->isTemplateDeclaration())
{ fd = td->deduceFunctionTemplate(sc, loc, NULL, e, arguments, 1+2);
if (fd && !(fd->storage_class & STCdisable))
goto Lassignerr;
}
Lassignerr:
if (fd && !(fd->storage_class & STCdisable))
error("identity assignment operator overload is illegal");
}
sc->pop();
#if 0 // Do not call until toObjfile() because of forward references
// Fill in base class vtbl[]s
for (i = 0; i < vtblInterfaces->dim; i++)
{
BaseClass *b = (*vtblInterfaces)[i];
//b->fillVtbl(this, &b->vtbl, 1);
}
#endif
//printf("-ClassDeclaration::semantic(%s), type = %p\n", toChars(), type);
if (deferred && !global.gag)
{
deferred->semantic2(sc);
deferred->semantic3(sc);
}
}
/*********************************
* Operator overloading for op=
*/
Expression *BinAssignExp::op_overload(Scope *sc)
{
//printf("BinAssignExp::op_overload() (%s)\n", toChars());
#if DMDV2
if (e1->op == TOKarray)
{
ArrayExp *ae = (ArrayExp *)e1;
ae->e1 = ae->e1->semantic(sc);
ae->e1 = resolveProperties(sc, ae->e1);
AggregateDeclaration *ad = isAggregate(ae->e1->type);
if (ad)
{
/* Rewrite a[args]+=e2 as:
* a.opIndexOpAssign!("+")(e2, args);
*/
Dsymbol *fd = search_function(ad, Id::opIndexOpAssign);
if (fd)
{
Expressions *a = new Expressions();
a->push(e2);
for (size_t i = 0; i < ae->arguments->dim; i++)
a->push(ae->arguments->tdata()[i]);
Objects *targsi = opToArg(sc, op);
Expression *e = new DotTemplateInstanceExp(loc, ae->e1, fd->ident, targsi);
e = new CallExp(loc, e, a);
e = e->semantic(sc);
return e;
}
// Didn't find it. Forward to aliasthis
if (ad->aliasthis)
{
/* Rewrite a[arguments] op= e2 as:
* a.aliasthis[arguments] op= e2
*/
Expression *e1 = ae->copy();
((ArrayExp *)e1)->e1 = new DotIdExp(loc, ae->e1, ad->aliasthis->ident);
Expression *e = copy();
((UnaExp *)e)->e1 = e1;
e = e->trySemantic(sc);
return e;
}
}
}
else if (e1->op == TOKslice)
{
SliceExp *se = (SliceExp *)e1;
se->e1 = se->e1->semantic(sc);
se->e1 = resolveProperties(sc, se->e1);
AggregateDeclaration *ad = isAggregate(se->e1->type);
if (ad)
{
/* Rewrite a[lwr..upr]+=e2 as:
* a.opSliceOpAssign!("+")(e2, lwr, upr);
*/
Dsymbol *fd = search_function(ad, Id::opSliceOpAssign);
if (fd)
{
Expressions *a = new Expressions();
a->push(e2);
if (se->lwr)
{ a->push(se->lwr);
a->push(se->upr);
}
Objects *targsi = opToArg(sc, op);
Expression *e = new DotTemplateInstanceExp(loc, se->e1, fd->ident, targsi);
e = new CallExp(loc, e, a);
e = e->semantic(sc);
return e;
}
// Didn't find it. Forward to aliasthis
if (ad->aliasthis)
{
/* Rewrite a[lwr..upr] op= e2 as:
* a.aliasthis[lwr..upr] op= e2
*/
Expression *e1 = se->copy();
((SliceExp *)e1)->e1 = new DotIdExp(loc, se->e1, ad->aliasthis->ident);
Expression *e = copy();
((UnaExp *)e)->e1 = e1;
e = e->trySemantic(sc);
return e;
}
}
}
#endif
BinExp::semantic(sc);
e1 = resolveProperties(sc, e1);
e2 = resolveProperties(sc, e2);
Identifier *id = opId();
Expressions args2;
AggregateDeclaration *ad1 = isAggregate(e1->type);
Dsymbol *s = NULL;
#if 1 // the old D1 scheme
if (ad1 && id)
{
s = search_function(ad1, id);
}
#endif
Objects *targsi = NULL;
#if DMDV2
if (!s)
{ /* Try the new D2 scheme, opOpAssign
*/
if (ad1)
s = search_function(ad1, Id::opOpAssign);
// Set targsi, the template argument list, which will be the operator string
if (s)
{
id = Id::opOpAssign;
targsi = opToArg(sc, op);
}
}
#endif
if (s)
{
/* Try:
* a.opOpAssign(b)
*/
args2.setDim(1);
args2.tdata()[0] = e2;
Match m;
memset(&m, 0, sizeof(m));
m.last = MATCHnomatch;
if (s)
{
FuncDeclaration *fd = s->isFuncDeclaration();
if (fd)
{
overloadResolveX(&m, fd, NULL, &args2, sc->module);
}
else
{ TemplateDeclaration *td = s->isTemplateDeclaration();
templateResolve(&m, td, sc, loc, targsi, e1, &args2);
}
}
if (m.count > 1)
{
// Error, ambiguous
error("overloads %s and %s both match argument list for %s",
m.lastf->type->toChars(),
m.nextf->type->toChars(),
m.lastf->toChars());
}
else if (m.last == MATCHnomatch)
{
m.lastf = m.anyf;
if (targsi)
goto L1;
}
// Rewrite (e1 op e2) as e1.opOpAssign(e2)
return build_overload(loc, sc, e1, e2, m.lastf ? m.lastf : s);
}
L1:
#if DMDV2
// Try alias this on first operand
if (ad1 && ad1->aliasthis)
{
/* Rewrite (e1 op e2) as:
* (e1.aliasthis op e2)
*/
Expression *e1 = new DotIdExp(loc, this->e1, ad1->aliasthis->ident);
Expression *e = copy();
((BinExp *)e)->e1 = e1;
e = e->trySemantic(sc);
return e;
}
// Try alias this on second operand
AggregateDeclaration *ad2 = isAggregate(e2->type);
if (ad2 && ad2->aliasthis)
{
/* Rewrite (e1 op e2) as:
* (e1 op e2.aliasthis)
*/
Expression *e2 = new DotIdExp(loc, this->e2, ad2->aliasthis->ident);
Expression *e = copy();
((BinExp *)e)->e2 = e2;
e = e->trySemantic(sc);
return e;
}
#endif
return NULL;
}
Expression *UnaExp::op_overload(Scope *sc)
{
//printf("UnaExp::op_overload() (%s)\n", toChars());
#if DMDV2
if (e1->op == TOKarray)
{
ArrayExp *ae = (ArrayExp *)e1;
ae->e1 = ae->e1->semantic(sc);
ae->e1 = resolveProperties(sc, ae->e1);
AggregateDeclaration *ad = isAggregate(ae->e1->type);
if (ad)
{
/* Rewrite as:
* a.opIndexUnary!("+")(args);
*/
Dsymbol *fd = search_function(ad, Id::opIndexUnary);
if (fd)
{
Objects *targsi = opToArg(sc, op);
Expression *e = new DotTemplateInstanceExp(loc, ae->e1, fd->ident, targsi);
e = new CallExp(loc, e, ae->arguments);
e = e->semantic(sc);
return e;
}
// Didn't find it. Forward to aliasthis
if (ad->aliasthis)
{
/* Rewrite op(a[arguments]) as:
* op(a.aliasthis[arguments])
*/
Expression *e1 = ae->copy();
((ArrayExp *)e1)->e1 = new DotIdExp(loc, ae->e1, ad->aliasthis->ident);
Expression *e = copy();
((UnaExp *)e)->e1 = e1;
e = e->trySemantic(sc);
return e;
}
}
}
else if (e1->op == TOKslice)
{
SliceExp *se = (SliceExp *)e1;
se->e1 = se->e1->semantic(sc);
se->e1 = resolveProperties(sc, se->e1);
AggregateDeclaration *ad = isAggregate(se->e1->type);
if (ad)
{
/* Rewrite as:
* a.opSliceUnary!("+")(lwr, upr);
*/
Dsymbol *fd = search_function(ad, Id::opSliceUnary);
if (fd)
{
Expressions *a = new Expressions();
if (se->lwr)
{ a->push(se->lwr);
a->push(se->upr);
}
Objects *targsi = opToArg(sc, op);
Expression *e = new DotTemplateInstanceExp(loc, se->e1, fd->ident, targsi);
e = new CallExp(loc, e, a);
e = e->semantic(sc);
return e;
}
// Didn't find it. Forward to aliasthis
if (ad->aliasthis)
{
/* Rewrite op(a[lwr..upr]) as:
* op(a.aliasthis[lwr..upr])
*/
Expression *e1 = se->copy();
((SliceExp *)e1)->e1 = new DotIdExp(loc, se->e1, ad->aliasthis->ident);
Expression *e = copy();
((UnaExp *)e)->e1 = e1;
e = e->trySemantic(sc);
return e;
}
}
}
#endif
e1 = e1->semantic(sc);
e1 = resolveProperties(sc, e1);
AggregateDeclaration *ad = isAggregate(e1->type);
if (ad)
{
Dsymbol *fd = NULL;
#if 1 // Old way, kept for compatibility with D1
if (op != TOKpreplusplus && op != TOKpreminusminus)
{ fd = search_function(ad, opId());
if (fd)
{
if (op == TOKarray)
{
/* Rewrite op e1[arguments] as:
* e1.fd(arguments)
*/
Expression *e = new DotIdExp(loc, e1, fd->ident);
ArrayExp *ae = (ArrayExp *)this;
e = new CallExp(loc, e, ae->arguments);
e = e->semantic(sc);
return e;
}
else
{
// Rewrite +e1 as e1.add()
return build_overload(loc, sc, e1, NULL, fd);
}
}
}
#endif
#if DMDV2
/* Rewrite as:
* e1.opUnary!("+")();
*/
fd = search_function(ad, Id::opUnary);
if (fd)
{
Objects *targsi = opToArg(sc, op);
Expression *e = new DotTemplateInstanceExp(loc, e1, fd->ident, targsi);
e = new CallExp(loc, e);
e = e->semantic(sc);
return e;
}
// Didn't find it. Forward to aliasthis
if (ad->aliasthis)
{
/* Rewrite op(e1) as:
* op(e1.aliasthis)
*/
Expression *e1 = new DotIdExp(loc, this->e1, ad->aliasthis->ident);
Expression *e = copy();
((UnaExp *)e)->e1 = e1;
e = e->trySemantic(sc);
return e;
}
#endif
}
return NULL;
}
/*********************************
* Operator overloading for op=
*/
Expression *BinAssignExp::op_overload(Scope *sc)
{
//printf("BinAssignExp::op_overload() (%s)\n", toChars());
#if DMDV2
if (e1->op == TOKarray)
{
ArrayExp *ae = (ArrayExp *)e1;
ae->e1 = ae->e1->semantic(sc);
ae->e1 = resolveProperties(sc, ae->e1);
AggregateDeclaration *ad = isAggregate(ae->e1->type);
if (ad)
{
/* Rewrite a[args]+=e2 as:
* a.opIndexOpAssign!("+")(e2, args);
*/
Dsymbol *fd = search_function(ad, Id::opIndexOpAssign);
if (fd)
{
ae = resolveOpDollar(sc, ae);
Expressions *a = (Expressions *)ae->arguments->copy();
a->insert(0, e2);
Objects *tiargs = opToArg(sc, op);
Expression *e = new DotTemplateInstanceExp(loc, ae->e1, fd->ident, tiargs);
e = new CallExp(loc, e, a);
e = e->semantic(sc);
return e;
}
// Didn't find it. Forward to aliasthis
if (ad->aliasthis && ae->e1->type != att1)
{
/* Rewrite a[arguments] op= e2 as:
* a.aliasthis[arguments] op= e2
*/
Expression *e1 = ae->copy();
((ArrayExp *)e1)->e1 = new DotIdExp(loc, ae->e1, ad->aliasthis->ident);
BinExp *be = (BinExp *)copy();
if (!be->att1 && ae->e1->type->checkAliasThisRec())
be->att1 = ae->e1->type;
be->e1 = e1;
if (Expression *e = be->trySemantic(sc))
return e;
}
att1 = NULL;
}
}
else if (e1->op == TOKslice)
{
SliceExp *se = (SliceExp *)e1;
se->e1 = se->e1->semantic(sc);
se->e1 = resolveProperties(sc, se->e1);
AggregateDeclaration *ad = isAggregate(se->e1->type);
if (ad)
{
/* Rewrite a[lwr..upr]+=e2 as:
* a.opSliceOpAssign!("+")(e2, lwr, upr);
*/
Dsymbol *fd = search_function(ad, Id::opSliceOpAssign);
if (fd)
{
se = resolveOpDollar(sc, se);
Expressions *a = new Expressions();
a->push(e2);
assert(!se->lwr || se->upr);
if (se->lwr)
{ a->push(se->lwr);
a->push(se->upr);
}
Objects *tiargs = opToArg(sc, op);
Expression *e = new DotTemplateInstanceExp(loc, se->e1, fd->ident, tiargs);
e = new CallExp(loc, e, a);
e = e->semantic(sc);
return e;
}
// Didn't find it. Forward to aliasthis
if (ad->aliasthis && se->e1->type != att1)
{
/* Rewrite a[lwr..upr] op= e2 as:
* a.aliasthis[lwr..upr] op= e2
*/
Expression *e1 = se->copy();
((SliceExp *)e1)->e1 = new DotIdExp(loc, se->e1, ad->aliasthis->ident);
BinExp *be = (BinExp *)copy();
if (!be->att1 && se->e1->type->checkAliasThisRec())
be->att1 = se->e1->type;
be->e1 = e1;
if (Expression *e = be->trySemantic(sc))
return e;
}
att1 = NULL;
}
}
#endif
BinExp::semantic(sc);
e1 = resolveProperties(sc, e1);
e2 = resolveProperties(sc, e2);
// Don't attempt 'alias this' if an error occured
if (e1->type->ty == Terror || e2->type->ty == Terror)
return new ErrorExp();
Identifier *id = opId();
Expressions args2;
AggregateDeclaration *ad1 = isAggregate(e1->type);
Dsymbol *s = NULL;
#if 1 // the old D1 scheme
if (ad1 && id)
{
s = search_function(ad1, id);
}
#endif
Objects *tiargs = NULL;
#if DMDV2
if (!s)
{ /* Try the new D2 scheme, opOpAssign
*/
if (ad1)
{
s = search_function(ad1, Id::opOpAssign);
if (s && !s->isTemplateDeclaration())
{ error("%s.opOpAssign isn't a template", e1->toChars());
return new ErrorExp();
}
}
// Set tiargs, the template argument list, which will be the operator string
if (s)
{
id = Id::opOpAssign;
tiargs = opToArg(sc, op);
}
}
#endif
if (s)
{
/* Try:
* a.opOpAssign(b)
*/
args2.setDim(1);
args2[0] = e2;
Match m;
memset(&m, 0, sizeof(m));
m.last = MATCHnomatch;
if (s)
{
FuncDeclaration *fd = s->isFuncDeclaration();
if (fd)
{
overloadResolveX(&m, fd, NULL, &args2);
}
else
{ TemplateDeclaration *td = s->isTemplateDeclaration();
templateResolve(&m, td, loc, sc, tiargs, e1, &args2);
}
}
if (m.count > 1)
{
// Error, ambiguous
error("overloads %s and %s both match argument list for %s",
m.lastf->type->toChars(),
m.nextf->type->toChars(),
m.lastf->toChars());
}
else if (m.last == MATCHnomatch)
{
m.lastf = m.anyf;
if (tiargs)
goto L1;
}
// Rewrite (e1 op e2) as e1.opOpAssign(e2)
return build_overload(loc, sc, e1, e2, m.lastf ? m.lastf : s);
}
L1:
#if DMDV2
// Try alias this on first operand
if (ad1 && ad1->aliasthis)
{
/* Rewrite (e1 op e2) as:
* (e1.aliasthis op e2)
*/
if (att1 && this->e1->type == att1)
return NULL;
//printf("att %s e1 = %s\n", Token::toChars(op), this->e1->type->toChars());
Expression *e1 = new DotIdExp(loc, this->e1, ad1->aliasthis->ident);
BinExp *be = (BinExp *)copy();
if (!be->att1 && this->e1->type->checkAliasThisRec())
be->att1 = this->e1->type;
be->e1 = e1;
return be->trySemantic(sc);
}
// Try alias this on second operand
AggregateDeclaration *ad2 = isAggregate(e2->type);
if (ad2 && ad2->aliasthis)
{
/* Rewrite (e1 op e2) as:
* (e1 op e2.aliasthis)
*/
if (att2 && this->e2->type == att2)
return NULL;
//printf("att %s e2 = %s\n", Token::toChars(op), this->e2->type->toChars());
Expression *e2 = new DotIdExp(loc, this->e2, ad2->aliasthis->ident);
BinExp *be = (BinExp *)copy();
if (!be->att2 && this->e2->type->checkAliasThisRec())
be->att2 = this->e2->type;
be->e2 = e2;
return be->trySemantic(sc);
}
#endif
return NULL;
}
void StructDeclaration::semantic(Scope *sc)
{ int i;
Scope *sc2;
//printf("+StructDeclaration::semantic(this=%p, '%s')\n", this, toChars());
//static int count; if (++count == 20) *(char*)0=0;
assert(type);
if (!members) // if forward reference
return;
if (symtab)
{ if (!scope)
return; // semantic() already completed
}
else
symtab = new DsymbolTable();
Scope *scx = NULL;
if (scope)
{ sc = scope;
scx = scope; // save so we don't make redundant copies
scope = NULL;
}
parent = sc->parent;
handle = type->pointerTo();
structalign = sc->structalign;
protection = sc->protection;
storage_class |= sc->stc;
assert(!isAnonymous());
if (sc->stc & STCabstract)
error("structs, unions cannot be abstract");
if (storage_class & STCinvariant)
type = type->invariantOf();
else if (storage_class & STCconst)
type = type->constOf();
if (sizeok == 0) // if not already done the addMember step
{
for (i = 0; i < members->dim; i++)
{
Dsymbol *s = (Dsymbol *)members->data[i];
//printf("adding member '%s' to '%s'\n", s->toChars(), this->toChars());
s->addMember(sc, this, 1);
}
}
sizeok = 0;
sc2 = sc->push(this);
sc2->stc &= storage_class & (STCconst | STCinvariant);
sc2->parent = this;
if (isUnionDeclaration())
sc2->inunion = 1;
sc2->protection = PROTpublic;
sc2->explicitProtection = 0;
int members_dim = members->dim;
for (i = 0; i < members_dim; i++)
{
Dsymbol *s = (Dsymbol *)members->data[i];
s->semantic(sc2);
if (isUnionDeclaration())
sc2->offset = 0;
#if 0
if (sizeok == 2)
{ //printf("forward reference\n");
break;
}
#endif
}
/* The TypeInfo_Struct is expecting an opEquals and opCmp with
* a parameter that is a pointer to the struct. But if there
* isn't one, but is an opEquals or opCmp with a value, write
* another that is a shell around the value:
* int opCmp(struct *p) { return opCmp(*p); }
*/
TypeFunction *tfeqptr;
{
Arguments *arguments = new Arguments;
Argument *arg = new Argument(STCin, handle, Id::p, NULL);
arguments->push(arg);
tfeqptr = new TypeFunction(arguments, Type::tint32, 0, LINKd);
tfeqptr = (TypeFunction *)tfeqptr->semantic(0, sc);
}
TypeFunction *tfeq;
{
Arguments *arguments = new Arguments;
Argument *arg = new Argument(STCin, type, NULL, NULL);
arguments->push(arg);
tfeq = new TypeFunction(arguments, Type::tint32, 0, LINKd);
tfeq = (TypeFunction *)tfeq->semantic(0, sc);
}
Identifier *id = Id::eq;
for (int i = 0; i < 2; i++)
{
Dsymbol *s = search_function(this, id);
FuncDeclaration *fdx = s ? s->isFuncDeclaration() : NULL;
if (fdx)
{ FuncDeclaration *fd = fdx->overloadExactMatch(tfeqptr);
if (!fd)
{ fd = fdx->overloadExactMatch(tfeq);
if (fd)
{ // Create the thunk, fdptr
FuncDeclaration *fdptr = new FuncDeclaration(loc, loc, fdx->ident, STCundefined, tfeqptr);
Expression *e = new IdentifierExp(loc, Id::p);
e = new PtrExp(loc, e);
Expressions *args = new Expressions();
args->push(e);
e = new IdentifierExp(loc, id);
e = new CallExp(loc, e, args);
fdptr->fbody = new ReturnStatement(loc, e);
ScopeDsymbol *s = fdx->parent->isScopeDsymbol();
assert(s);
s->members->push(fdptr);
fdptr->addMember(sc, s, 1);
fdptr->semantic(sc2);
}
}
}
id = Id::cmp;
}
dtor = buildDtor(sc2);
postblit = buildPostBlit(sc2);
cpctor = buildCpCtor(sc2);
buildOpAssign(sc2);
sc2->pop();
if (sizeok == 2)
{ // semantic() failed because of forward references.
// Unwind what we did, and defer it for later
fields.setDim(0);
structsize = 0;
alignsize = 0;
structalign = 0;
scope = scx ? scx : new Scope(*sc);
scope->setNoFree();
scope->module->addDeferredSemantic(this);
//printf("\tdeferring %s\n", toChars());
return;
}
// 0 sized struct's are set to 1 byte
if (structsize == 0)
{
structsize = 1;
alignsize = 1;
}
// Round struct size up to next alignsize boundary.
// This will ensure that arrays of structs will get their internals
// aligned properly.
structsize = (structsize + alignsize - 1) & ~(alignsize - 1);
sizeok = 1;
Module::dprogress++;
//printf("-StructDeclaration::semantic(this=%p, '%s')\n", this, toChars());
// Determine if struct is all zeros or not
zeroInit = 1;
for (i = 0; i < fields.dim; i++)
{
Dsymbol *s = (Dsymbol *)fields.data[i];
VarDeclaration *vd = s->isVarDeclaration();
if (vd && !vd->isDataseg())
{
if (vd->init)
{
// Should examine init to see if it is really all 0's
zeroInit = 0;
break;
}
else
{
if (!vd->type->isZeroInit())
{
zeroInit = 0;
break;
}
}
}
}
/* Look for special member functions.
*/
inv = (InvariantDeclaration *)search(0, Id::classInvariant, 0);
aggNew = (NewDeclaration *)search(0, Id::classNew, 0);
aggDelete = (DeleteDeclaration *)search(0, Id::classDelete, 0);
if (sc->func)
{
semantic2(sc);
semantic3(sc);
}
}
FuncDeclaration *StructDeclaration::buildOpEquals(Scope *sc)
{
Dsymbol *eq = search_function(this, Id::eq);
if (eq)
{
/* check identity opEquals exists
*/
Type *tthis = type->constOf();
Expression *er = new NullExp(loc, tthis); // dummy rvalue
Expression *el = new IdentifierExp(loc, Id::p); // dummy lvalue
el->type = tthis;
Expressions ar; ar.push(er);
Expressions al; al.push(el);
FuncDeclaration *f = NULL;
unsigned errors = global.startGagging(); // Do not report errors, even if the
unsigned oldspec = global.speculativeGag; // template opAssign fbody makes it.
global.speculativeGag = global.gag;
sc = sc->push();
sc->speculative = true;
f = resolveFuncCall(loc, sc, eq, NULL, er, &ar, 1);
if (!f) f = resolveFuncCall(loc, sc, eq, NULL, er, &al, 1);
sc = sc->pop();
global.speculativeGag = oldspec;
global.endGagging(errors);
if (f)
return (f->storage_class & STCdisable) ? NULL : f;
return NULL;
}
if (!needOpEquals())
return NULL;
//printf("StructDeclaration::buildOpEquals() %s\n", toChars());
Parameters *parameters = new Parameters;
parameters->push(new Parameter(STCin, type, Id::p, NULL));
TypeFunction *tf = new TypeFunction(parameters, Type::tbool, 0, LINKd);
tf->mod = MODconst;
tf = (TypeFunction *)tf->semantic(loc, sc);
FuncDeclaration *fop = new FuncDeclaration(loc, 0, Id::eq, STCundefined, tf);
Expression *e = NULL;
/* Do memberwise compare
*/
//printf("\tmemberwise compare\n");
for (size_t i = 0; i < fields.dim; i++)
{
Dsymbol *s = fields[i];
VarDeclaration *v = s->isVarDeclaration();
assert(v && v->isField());
if (v->storage_class & STCref)
assert(0); // what should we do with this?
// this.v == s.v;
EqualExp *ec = new EqualExp(TOKequal, loc,
new DotVarExp(loc, new ThisExp(loc), v, 0),
new DotVarExp(loc, new IdentifierExp(loc, Id::p), v, 0));
if (e)
e = new AndAndExp(loc, e, ec);
else
e = ec;
}
if (!e)
e = new IntegerExp(loc, 1, Type::tbool);
fop->fbody = new ReturnStatement(loc, e);
members->push(fop);
fop->addMember(sc, this, 1);
sc = sc->push();
sc->stc = 0;
sc->linkage = LINKd;
fop->semantic(sc);
sc->pop();
//printf("-StructDeclaration::buildOpEquals() %s\n", toChars());
return fop;
}
/**
* get an array of size_t values that indicate possible pointer words in memory
* if interpreted as the type given as argument
* the first array element is the size of the type for independent interpretation
* of the array
* following elements bits represent one word (4/8 bytes depending on the target
* architecture). If set the corresponding memory might contain a pointer/reference.
*
* [T.sizeof, pointerbit0-31/63, pointerbit32/64-63/128, ...]
*/
Expression *pointerBitmap(TraitsExp *e)
{
int result = 0;
if (!e->args || e->args->dim != 1)
{
error(e->loc, "a single type expected for trait pointerBitmap");
return new ErrorExp();
}
Type *t = getType((*e->args)[0]);
if (!t)
{
error(e->loc, "%s is not a type", (*e->args)[0]->toChars());
return new ErrorExp();
}
d_uns64 sz = t->size(e->loc);
if (t->ty == Tclass && !((TypeClass*)t)->sym->isInterfaceDeclaration())
sz = ((TypeClass*)t)->sym->AggregateDeclaration::size(e->loc);
d_uns64 sz_size_t = Type::tsize_t->size(e->loc);
d_uns64 bitsPerWord = sz_size_t * 8;
d_uns64 cntptr = (sz + sz_size_t - 1) / sz_size_t;
d_uns64 cntdata = (cntptr + bitsPerWord - 1) / bitsPerWord;
Array<d_uns64> data;
data.setDim((size_t)cntdata);
data.zero();
class PointerBitmapVisitor : public Visitor
{
public:
PointerBitmapVisitor(Array<d_uns64>* _data, d_uns64 _sz_size_t)
: data(_data), offset(0), sz_size_t(_sz_size_t)
{}
void setpointer(d_uns64 off)
{
d_uns64 ptroff = off / sz_size_t;
(*data)[(size_t)(ptroff / (8 * sz_size_t))] |= 1LL << (ptroff % (8 * sz_size_t));
}
virtual void visit(Type *t)
{
Type *tb = t->toBasetype();
if (tb != t)
tb->accept(this);
}
virtual void visit(TypeError *t) { visit((Type *)t); }
virtual void visit(TypeNext *t) { assert(0); }
virtual void visit(TypeBasic *t)
{
if (t->ty == Tvoid)
setpointer(offset);
}
virtual void visit(TypeVector *t) { }
virtual void visit(TypeArray *t) { assert(0); }
virtual void visit(TypeSArray *t)
{
d_uns64 arrayoff = offset;
d_uns64 nextsize = t->next->size();
d_uns64 dim = t->dim->toInteger();
for (d_uns64 i = 0; i < dim; i++)
{
offset = arrayoff + i * nextsize;
t->next->accept(this);
}
offset = arrayoff;
}
virtual void visit(TypeDArray *t) { setpointer(offset + sz_size_t); } // dynamic array is {length,ptr}
virtual void visit(TypeAArray *t) { setpointer(offset); }
virtual void visit(TypePointer *t)
{
if (t->nextOf()->ty != Tfunction) // don't mark function pointers
setpointer(offset);
}
virtual void visit(TypeReference *t) { setpointer(offset); }
virtual void visit(TypeClass *t) { setpointer(offset); }
virtual void visit(TypeFunction *t) { }
virtual void visit(TypeDelegate *t) { setpointer(offset); } // delegate is {context, function}
virtual void visit(TypeQualified *t) { assert(0); } // assume resolved
virtual void visit(TypeIdentifier *t) { assert(0); }
virtual void visit(TypeInstance *t) { assert(0); }
virtual void visit(TypeTypeof *t) { assert(0); }
virtual void visit(TypeReturn *t) { assert(0); }
virtual void visit(TypeEnum *t) { visit((Type *)t); }
virtual void visit(TypeTuple *t) { visit((Type *)t); }
virtual void visit(TypeSlice *t) { assert(0); }
virtual void visit(TypeNull *t) { assert(0); }
virtual void visit(TypeStruct *t)
{
d_uns64 structoff = offset;
for (size_t i = 0; i < t->sym->fields.dim; i++)
{
VarDeclaration *v = t->sym->fields[i];
offset = structoff + v->offset;
if (v->type->ty == Tclass)
setpointer(offset);
else
v->type->accept(this);
}
offset = structoff;
}
// a "toplevel" class is treated as an instance, while TypeClass fields are treated as references
void visitClass(TypeClass* t)
{
d_uns64 classoff = offset;
// skip vtable-ptr and monitor
if (t->sym->baseClass)
visitClass((TypeClass*)t->sym->baseClass->type);
for (size_t i = 0; i < t->sym->fields.dim; i++)
{
VarDeclaration *v = t->sym->fields[i];
offset = classoff + v->offset;
v->type->accept(this);
}
offset = classoff;
}
Array<d_uns64>* data;
d_uns64 offset;
d_uns64 sz_size_t;
};
PointerBitmapVisitor pbv(&data, sz_size_t);
if (t->ty == Tclass)
pbv.visitClass((TypeClass*)t);
else
t->accept(&pbv);
Expressions* exps = new Expressions;
exps->push(new IntegerExp(e->loc, sz, Type::tsize_t));
for (d_uns64 i = 0; i < cntdata; i++)
exps->push(new IntegerExp(e->loc, data[(size_t)i], Type::tsize_t));
ArrayLiteralExp* ale = new ArrayLiteralExp(e->loc, exps);
ale->type = Type::tsize_t->sarrayOf(cntdata + 1);
return ale;
}
FuncDeclaration *StructDeclaration::buildOpEquals(Scope *sc)
{
Dsymbol *eq = search_function(this, Id::eq);
if (eq)
{
for (size_t i = 0; i <= 1; i++)
{
Expression *e =
i == 0 ? new NullExp(loc, type->constOf()) // dummy rvalue
: type->constOf()->defaultInit(); // dummy lvalue
Expressions *arguments = new Expressions();
arguments->push(e);
// check identity opEquals exists
FuncDeclaration *fd = eq->isFuncDeclaration();
if (fd)
{ fd = fd->overloadResolve(loc, e, arguments, 1);
if (fd && !(fd->storage_class & STCdisable))
return fd;
}
TemplateDeclaration *td = eq->isTemplateDeclaration();
if (td)
{ fd = td->deduceFunctionTemplate(sc, loc, NULL, e, arguments, 1);
if (fd && !(fd->storage_class & STCdisable))
return fd;
}
}
return NULL;
}
if (!needOpEquals())
return NULL;
//printf("StructDeclaration::buildOpEquals() %s\n", toChars());
Parameters *parameters = new Parameters;
parameters->push(new Parameter(STCin, type, Id::p, NULL));
TypeFunction *tf = new TypeFunction(parameters, Type::tbool, 0, LINKd);
tf->mod = MODconst;
tf = (TypeFunction *)tf->semantic(loc, sc);
FuncDeclaration *fop = new FuncDeclaration(loc, 0, Id::eq, STCundefined, tf);
Expression *e = NULL;
/* Do memberwise compare
*/
//printf("\tmemberwise compare\n");
for (size_t i = 0; i < fields.dim; i++)
{
Dsymbol *s = fields[i];
VarDeclaration *v = s->isVarDeclaration();
assert(v && v->storage_class & STCfield);
if (v->storage_class & STCref)
assert(0); // what should we do with this?
// this.v == s.v;
EqualExp *ec = new EqualExp(TOKequal, loc,
new DotVarExp(loc, new ThisExp(loc), v, 0),
new DotVarExp(loc, new IdentifierExp(loc, Id::p), v, 0));
if (e)
e = new AndAndExp(loc, e, ec);
else
e = ec;
}
if (!e)
e = new IntegerExp(loc, 1, Type::tbool);
fop->fbody = new ReturnStatement(loc, e);
members->push(fop);
fop->addMember(sc, this, 1);
sc = sc->push();
sc->stc = 0;
sc->linkage = LINKd;
fop->semantic(sc);
sc->pop();
//printf("-StructDeclaration::buildOpEquals() %s\n", toChars());
return fop;
}
Expression *TraitsExp::semantic(Scope *sc)
{
#if LOGSEMANTIC
printf("TraitsExp::semantic() %s\n", toChars());
#endif
if (ident != Id::compiles && ident != Id::isSame)
TemplateInstance::semanticTiargs(loc, sc, args, 1);
size_t dim = args ? args->dim : 0;
Object *o;
FuncDeclaration *f;
#define ISTYPE(cond) \
for (size_t i = 0; i < dim; i++) \
{ Type *t = getType((Object *)args->data[i]); \
if (!t) \
goto Lfalse; \
if (!(cond)) \
goto Lfalse; \
} \
if (!dim) \
goto Lfalse; \
goto Ltrue;
#define ISDSYMBOL(cond) \
for (size_t i = 0; i < dim; i++) \
{ Dsymbol *s = getDsymbol((Object *)args->data[i]); \
if (!s) \
goto Lfalse; \
if (!(cond)) \
goto Lfalse; \
} \
if (!dim) \
goto Lfalse; \
goto Ltrue;
if (ident == Id::isArithmetic)
{
ISTYPE(t->isintegral() || t->isfloating())
}
else if (ident == Id::isFloating)
{
ISTYPE(t->isfloating())
}
else if (ident == Id::isIntegral)
{
ISTYPE(t->isintegral())
}
else if (ident == Id::isScalar)
{
ISTYPE(t->isscalar())
}
else if (ident == Id::isUnsigned)
{
ISTYPE(t->isunsigned())
}
else if (ident == Id::isAssociativeArray)
{
ISTYPE(t->toBasetype()->ty == Taarray)
}
else if (ident == Id::isStaticArray)
{
ISTYPE(t->toBasetype()->ty == Tsarray)
}
else if (ident == Id::isAbstractClass)
{
ISTYPE(t->toBasetype()->ty == Tclass && ((TypeClass *)t->toBasetype())->sym->isAbstract())
}
else if (ident == Id::isFinalClass)
{
ISTYPE(t->toBasetype()->ty == Tclass && ((TypeClass *)t->toBasetype())->sym->storage_class & STCfinal)
}
else if (ident == Id::isAbstractFunction)
{
ISDSYMBOL((f = s->isFuncDeclaration()) != NULL && f->isAbstract())
}
else if (ident == Id::isVirtualFunction)
{
ISDSYMBOL((f = s->isFuncDeclaration()) != NULL && f->isVirtual())
}
else if (ident == Id::isFinalFunction)
{
ISDSYMBOL((f = s->isFuncDeclaration()) != NULL && f->isFinal())
}
else if (ident == Id::hasMember ||
ident == Id::getMember ||
ident == Id::getVirtualFunctions)
{
if (dim != 2)
goto Ldimerror;
Object *o = (Object *)args->data[0];
Expression *e = isExpression((Object *)args->data[1]);
if (!e)
{ // error("expression expected as second argument of __traits %s", ident->toChars());
goto Lfalse;
}
e = e->optimize(WANTvalue | WANTinterpret);
if (e->op != TOKstring)
{ // error("string expected as second argument of __traits %s instead of %s", ident->toChars(), e->toChars());
goto Lfalse;
}
StringExp *se = (StringExp *)e;
se = se->toUTF8(sc);
if (se->sz != 1)
{ // error("string must be chars");
goto Lfalse;
}
Identifier *id = Lexer::idPool((char *)se->string);
Type *t = isType(o);
e = isExpression(o);
Dsymbol *s = isDsymbol(o);
if (t)
e = new TypeDotIdExp(loc, t, id);
else if (e)
e = new DotIdExp(loc, e, id);
else if (s)
{ e = new DsymbolExp(loc, s);
e = new DotIdExp(loc, e, id);
}
else
{ // error("invalid first argument");
goto Lfalse;
}
if (ident == Id::hasMember)
{ /* Take any errors as meaning it wasn't found
*/
unsigned errors = global.errors;
global.gag++;
e = e->semantic(sc);
global.gag--;
if (errors != global.errors)
{ if (global.gag == 0)
global.errors = errors;
goto Lfalse;
}
else
goto Ltrue;
}
else if (ident == Id::getMember)
{
e = e->semantic(sc);
return e;
}
else if (ident == Id::getVirtualFunctions)
{
unsigned errors = global.errors;
Expression *ex = e;
e = e->semantic(sc);
/* if (errors < global.errors)
error("%s cannot be resolved", ex->toChars()); */
/* Create tuple of virtual function overloads of e
*/
//e->dump(0);
Expressions *exps = new Expressions();
FuncDeclaration *f;
if (e->op == TOKvar)
{ VarExp *ve = (VarExp *)e;
f = ve->var->isFuncDeclaration();
}
else if (e->op == TOKdotvar)
{ DotVarExp *dve = (DotVarExp *)e;
f = dve->var->isFuncDeclaration();
}
else
f = NULL;
Pvirtuals p;
p.exps = exps;
p.e1 = e;
overloadApply(f, fpvirtuals, &p);
TupleExp *tup = new TupleExp(loc, exps);
return tup->semantic(sc);
}
else
assert(0);
}
else if (ident == Id::classInstanceSize)
{
if (dim != 1)
goto Ldimerror;
Object *o = (Object *)args->data[0];
Dsymbol *s = getDsymbol(o);
ClassDeclaration *cd;
if (!s || (cd = s->isClassDeclaration()) == NULL)
{
// error("first argument is not a class");
goto Lfalse;
}
return new IntegerExp(loc, cd->structsize, Type::tsize_t);
}
else if (ident == Id::allMembers || ident == Id::derivedMembers)
{
if (dim != 1)
goto Ldimerror;
Object *o = (Object *)args->data[0];
Dsymbol *s = getDsymbol(o);
ScopeDsymbol *sd;
if (!s)
{
// error("argument has no members");
goto Lfalse;
}
if ((sd = s->isScopeDsymbol()) == NULL)
{
// error("%s %s has no members", s->kind(), s->toChars());
goto Lfalse;
}
Expressions *exps = new Expressions;
while (1)
{ size_t dim = ScopeDsymbol::dim(sd->members);
for (size_t i = 0; i < dim; i++)
{
Dsymbol *sm = ScopeDsymbol::getNth(sd->members, i);
//printf("\t[%i] %s %s\n", i, sm->kind(), sm->toChars());
if (sm->ident)
{
//printf("\t%s\n", sm->ident->toChars());
char *str = sm->ident->toChars();
/* Skip if already present in exps[]
*/
for (size_t j = 0; j < exps->dim; j++)
{ StringExp *se2 = (StringExp *)exps->data[j];
if (strcmp(str, (char *)se2->string) == 0)
goto Lnext;
}
StringExp *se = new StringExp(loc, str);
exps->push(se);
}
Lnext:
;
}
ClassDeclaration *cd = sd->isClassDeclaration();
if (cd && cd->baseClass && ident == Id::allMembers)
sd = cd->baseClass; // do again with base class
else
break;
}
Expression *e = new ArrayLiteralExp(loc, exps);
e = e->semantic(sc);
return e;
}
else if (ident == Id::compiles)
{
/* Determine if all the objects - types, expressions, or symbols -
* compile without error
*/
if (!dim)
goto Lfalse;
for (size_t i = 0; i < dim; i++)
{ Object *o = (Object *)args->data[i];
Type *t;
Expression *e;
Dsymbol *s;
unsigned errors = global.errors;
global.gag++;
t = isType(o);
if (t)
{ t->resolve(loc, sc, &e, &t, &s);
if (t)
t->semantic(loc, sc);
else if (e)
e->semantic(sc);
}
else
{ e = isExpression(o);
if (e)
e->semantic(sc);
}
global.gag--;
if (errors != global.errors)
{ if (global.gag == 0)
global.errors = errors;
goto Lfalse;
}
}
goto Ltrue;
}
else if (ident == Id::isSame)
{ /* Determine if two symbols are the same
*/
if (dim != 2)
goto Ldimerror;
TemplateInstance::semanticTiargs(loc, sc, args, 0);
Object *o1 = (Object *)args->data[0];
Object *o2 = (Object *)args->data[1];
Dsymbol *s1 = getDsymbol(o1);
Dsymbol *s2 = getDsymbol(o2);
#if 0
printf("o1: %p\n", o1);
printf("o2: %p\n", o2);
if (!s1)
{ Expression *ea = isExpression(o1);
if (ea)
printf("%s\n", ea->toChars());
Type *ta = isType(o1);
if (ta)
printf("%s\n", ta->toChars());
goto Lfalse;
}
else
printf("%s %s\n", s1->kind(), s1->toChars());
#endif
if (!s1 && !s2)
{ Expression *ea1 = isExpression(o1);
Expression *ea2 = isExpression(o2);
if (ea1 && ea2 && ea1->equals(ea2))
goto Ltrue;
}
if (!s1 || !s2)
goto Lfalse;
s1 = s1->toAlias();
s2 = s2->toAlias();
if (s1 == s2)
goto Ltrue;
else
goto Lfalse;
}
else
{ // error("unrecognized trait %s", ident->toChars());
goto Lfalse;
}
return NULL;
Lnottype:
// error("%s is not a type", o->toChars());
goto Lfalse;
Ldimerror:
// error("wrong number of arguments %d", dim);
goto Lfalse;
Lfalse:
return new IntegerExp(loc, 0, Type::tbool);
Ltrue:
return new IntegerExp(loc, 1, Type::tbool);
}
Expression *semanticTraits(TraitsExp *e, Scope *sc)
{
#if LOGSEMANTIC
printf("TraitsExp::semantic() %s\n", e->toChars());
#endif
if (e->ident != Id::compiles && e->ident != Id::isSame &&
e->ident != Id::identifier && e->ident != Id::getProtection)
{
if (!TemplateInstance::semanticTiargs(e->loc, sc, e->args, 1))
return new ErrorExp();
}
size_t dim = e->args ? e->args->dim : 0;
if (e->ident == Id::isArithmetic)
{
return isTypeX(e, &isTypeArithmetic);
}
else if (e->ident == Id::isFloating)
{
return isTypeX(e, &isTypeFloating);
}
else if (e->ident == Id::isIntegral)
{
return isTypeX(e, &isTypeIntegral);
}
else if (e->ident == Id::isScalar)
{
return isTypeX(e, &isTypeScalar);
}
else if (e->ident == Id::isUnsigned)
{
return isTypeX(e, &isTypeUnsigned);
}
else if (e->ident == Id::isAssociativeArray)
{
return isTypeX(e, &isTypeAssociativeArray);
}
else if (e->ident == Id::isStaticArray)
{
return isTypeX(e, &isTypeStaticArray);
}
else if (e->ident == Id::isAbstractClass)
{
return isTypeX(e, &isTypeAbstractClass);
}
else if (e->ident == Id::isFinalClass)
{
return isTypeX(e, &isTypeFinalClass);
}
else if (e->ident == Id::isPOD)
{
if (dim != 1)
goto Ldimerror;
RootObject *o = (*e->args)[0];
Type *t = isType(o);
StructDeclaration *sd;
if (!t)
{
e->error("type expected as second argument of __traits %s instead of %s", e->ident->toChars(), o->toChars());
goto Lfalse;
}
Type *tb = t->baseElemOf();
if (tb->ty == Tstruct
&& ((sd = (StructDeclaration *)(((TypeStruct *)tb)->sym)) != NULL))
{
if (sd->isPOD())
goto Ltrue;
else
goto Lfalse;
}
goto Ltrue;
}
else if (e->ident == Id::isNested)
{
if (dim != 1)
goto Ldimerror;
RootObject *o = (*e->args)[0];
Dsymbol *s = getDsymbol(o);
AggregateDeclaration *a;
FuncDeclaration *f;
if (!s) { }
else if ((a = s->isAggregateDeclaration()) != NULL)
{
if (a->isNested())
goto Ltrue;
else
goto Lfalse;
}
else if ((f = s->isFuncDeclaration()) != NULL)
{
if (f->isNested())
goto Ltrue;
else
goto Lfalse;
}
e->error("aggregate or function expected instead of '%s'", o->toChars());
goto Lfalse;
}
else if (e->ident == Id::isAbstractFunction)
{
return isFuncX(e, &isFuncAbstractFunction);
}
else if (e->ident == Id::isVirtualFunction)
{
return isFuncX(e, &isFuncVirtualFunction);
}
else if (e->ident == Id::isVirtualMethod)
{
return isFuncX(e, &isFuncVirtualMethod);
}
else if (e->ident == Id::isFinalFunction)
{
return isFuncX(e, &isFuncFinalFunction);
}
else if (e->ident == Id::isOverrideFunction)
{
return isFuncX(e, &isFuncOverrideFunction);
}
else if (e->ident == Id::isStaticFunction)
{
return isFuncX(e, &isFuncStaticFunction);
}
else if (e->ident == Id::isRef)
{
return isDeclX(e, &isDeclRef);
}
else if (e->ident == Id::isOut)
{
return isDeclX(e, &isDeclOut);
}
else if (e->ident == Id::isLazy)
{
return isDeclX(e, &isDeclLazy);
}
else if (e->ident == Id::identifier)
{
// Get identifier for symbol as a string literal
/* Specify 0 for bit 0 of the flags argument to semanticTiargs() so that
* a symbol should not be folded to a constant.
* Bit 1 means don't convert Parameter to Type if Parameter has an identifier
*/
if (!TemplateInstance::semanticTiargs(e->loc, sc, e->args, 2))
return new ErrorExp();
if (dim != 1)
goto Ldimerror;
RootObject *o = (*e->args)[0];
Parameter *po = isParameter(o);
Identifier *id;
if (po)
{
id = po->ident;
assert(id);
}
else
{
Dsymbol *s = getDsymbol(o);
if (!s || !s->ident)
{
e->error("argument %s has no identifier", o->toChars());
goto Lfalse;
}
id = s->ident;
}
StringExp *se = new StringExp(e->loc, id->toChars());
return se->semantic(sc);
}
else if (e->ident == Id::getProtection)
{
if (dim != 1)
goto Ldimerror;
Scope *sc2 = sc->push();
sc2->flags = sc->flags | SCOPEnoaccesscheck;
bool ok = TemplateInstance::semanticTiargs(e->loc, sc2, e->args, 1);
sc2->pop();
if (!ok)
return new ErrorExp();
RootObject *o = (*e->args)[0];
Dsymbol *s = getDsymbol(o);
if (!s)
{
if (!isError(o))
e->error("argument %s has no protection", o->toChars());
goto Lfalse;
}
if (s->scope)
s->semantic(s->scope);
PROT protection = s->prot();
const char *protName = Pprotectionnames[protection];
assert(protName);
StringExp *se = new StringExp(e->loc, (char *) protName);
return se->semantic(sc);
}
else if (e->ident == Id::parent)
{
if (dim != 1)
goto Ldimerror;
RootObject *o = (*e->args)[0];
Dsymbol *s = getDsymbol(o);
if (s)
{
if (FuncDeclaration *fd = s->isFuncDeclaration()) // Bugzilla 8943
s = fd->toAliasFunc();
if (!s->isImport()) // Bugzilla 8922
s = s->toParent();
}
if (!s || s->isImport())
{
e->error("argument %s has no parent", o->toChars());
goto Lfalse;
}
if (FuncDeclaration *f = s->isFuncDeclaration())
{
if (TemplateDeclaration *td = getFuncTemplateDecl(f))
{
if (td->overroot) // if not start of overloaded list of TemplateDeclaration's
td = td->overroot; // then get the start
Expression *ex = new TemplateExp(e->loc, td, f);
ex = ex->semantic(sc);
return ex;
}
if (FuncLiteralDeclaration *fld = f->isFuncLiteralDeclaration())
{
// Directly translate to VarExp instead of FuncExp
Expression *ex = new VarExp(e->loc, fld, 1);
return ex->semantic(sc);
}
}
return (new DsymbolExp(e->loc, s))->semantic(sc);
}
else if (e->ident == Id::hasMember ||
e->ident == Id::getMember ||
e->ident == Id::getOverloads ||
e->ident == Id::getVirtualMethods ||
e->ident == Id::getVirtualFunctions)
{
if (dim != 2)
goto Ldimerror;
RootObject *o = (*e->args)[0];
Expression *ex = isExpression((*e->args)[1]);
if (!ex)
{
e->error("expression expected as second argument of __traits %s", e->ident->toChars());
goto Lfalse;
}
ex = ex->ctfeInterpret();
StringExp *se = ex->toStringExp();
if (!se || se->length() == 0)
{
e->error("string expected as second argument of __traits %s instead of %s", e->ident->toChars(), ex->toChars());
goto Lfalse;
}
se = se->toUTF8(sc);
if (se->sz != 1)
{
e->error("string must be chars");
goto Lfalse;
}
Identifier *id = Lexer::idPool((char *)se->string);
/* Prefer dsymbol, because it might need some runtime contexts.
*/
Dsymbol *sym = getDsymbol(o);
if (sym)
{
ex = new DsymbolExp(e->loc, sym);
ex = new DotIdExp(e->loc, ex, id);
}
else if (Type *t = isType(o))
ex = typeDotIdExp(e->loc, t, id);
else if (Expression *ex2 = isExpression(o))
ex = new DotIdExp(e->loc, ex2, id);
else
{
e->error("invalid first argument");
goto Lfalse;
}
if (e->ident == Id::hasMember)
{
if (sym)
{
Dsymbol *sm = sym->search(e->loc, id);
if (sm)
goto Ltrue;
}
/* Take any errors as meaning it wasn't found
*/
Scope *sc2 = sc->push();
ex = ex->trySemantic(sc2);
sc2->pop();
if (!ex)
goto Lfalse;
else
goto Ltrue;
}
else if (e->ident == Id::getMember)
{
ex = ex->semantic(sc);
return ex;
}
else if (e->ident == Id::getVirtualFunctions ||
e->ident == Id::getVirtualMethods ||
e->ident == Id::getOverloads)
{
unsigned errors = global.errors;
Expression *eorig = ex;
ex = ex->semantic(sc);
if (errors < global.errors)
e->error("%s cannot be resolved", eorig->toChars());
/* Create tuple of functions of ex
*/
//ex->print();
Expressions *exps = new Expressions();
FuncDeclaration *f;
if (ex->op == TOKvar)
{
VarExp *ve = (VarExp *)ex;
f = ve->var->isFuncDeclaration();
ex = NULL;
}
else if (ex->op == TOKdotvar)
{
DotVarExp *dve = (DotVarExp *)ex;
f = dve->var->isFuncDeclaration();
if (dve->e1->op == TOKdottype || dve->e1->op == TOKthis)
ex = NULL;
else
ex = dve->e1;
}
else
f = NULL;
Ptrait p;
p.exps = exps;
p.e1 = ex;
p.ident = e->ident;
overloadApply(f, &p, &fptraits);
TupleExp *tup = new TupleExp(e->loc, exps);
return tup->semantic(sc);
}
else
assert(0);
}
else if (e->ident == Id::classInstanceSize)
{
if (dim != 1)
goto Ldimerror;
RootObject *o = (*e->args)[0];
Dsymbol *s = getDsymbol(o);
ClassDeclaration *cd;
if (!s || (cd = s->isClassDeclaration()) == NULL)
{
e->error("first argument is not a class");
goto Lfalse;
}
if (cd->sizeok == SIZEOKnone)
{
if (cd->scope)
cd->semantic(cd->scope);
}
if (cd->sizeok != SIZEOKdone)
{
e->error("%s %s is forward referenced", cd->kind(), cd->toChars());
goto Lfalse;
}
return new IntegerExp(e->loc, cd->structsize, Type::tsize_t);
}
else if (e->ident == Id::getAliasThis)
{
if (dim != 1)
goto Ldimerror;
RootObject *o = (*e->args)[0];
Dsymbol *s = getDsymbol(o);
AggregateDeclaration *ad;
if (!s || (ad = s->isAggregateDeclaration()) == NULL)
{
e->error("argument is not an aggregate type");
goto Lfalse;
}
Expressions *exps = new Expressions();
if (ad->aliasthis)
exps->push(new StringExp(e->loc, ad->aliasthis->ident->toChars()));
Expression *ex = new TupleExp(e->loc, exps);
ex = ex->semantic(sc);
return ex;
}
else if (e->ident == Id::getAttributes)
{
if (dim != 1)
goto Ldimerror;
RootObject *o = (*e->args)[0];
Dsymbol *s = getDsymbol(o);
if (!s)
{
#if 0
Expression *x = isExpression(o);
Type *t = isType(o);
if (x) printf("e = %s %s\n", Token::toChars(x->op), x->toChars());
if (t) printf("t = %d %s\n", t->ty, t->toChars());
#endif
e->error("first argument is not a symbol");
goto Lfalse;
}
//printf("getAttributes %s, attrs = %p, scope = %p\n", s->toChars(), s->userAttributes, s->userAttributesScope);
UserAttributeDeclaration *udad = s->userAttribDecl;
TupleExp *tup = new TupleExp(e->loc, udad ? udad->getAttributes() : new Expressions());
return tup->semantic(sc);
}
else if (e->ident == Id::getFunctionAttributes)
{
/// extract all function attributes as a tuple (const/shared/inout/pure/nothrow/etc) except UDAs.
if (dim != 1)
goto Ldimerror;
RootObject *o = (*e->args)[0];
Dsymbol *s = getDsymbol(o);
Type *t = isType(o);
TypeFunction *tf = NULL;
if (s)
{
if (FuncDeclaration *f = s->isFuncDeclaration())
t = f->type;
else if (VarDeclaration *v = s->isVarDeclaration())
t = v->type;
}
if (t)
{
if (t->ty == Tfunction)
tf = (TypeFunction *)t;
else if (t->ty == Tdelegate)
tf = (TypeFunction *)t->nextOf();
else if (t->ty == Tpointer && t->nextOf()->ty == Tfunction)
tf = (TypeFunction *)t->nextOf();
}
if (!tf)
{
e->error("first argument is not a function");
goto Lfalse;
}
Expressions *mods = new Expressions();
PushAttributes pa;
pa.mods = mods;
tf->modifiersApply(&pa, &PushAttributes::fp);
tf->attributesApply(&pa, &PushAttributes::fp, TRUSTformatSystem);
TupleExp *tup = new TupleExp(e->loc, mods);
return tup->semantic(sc);
}
else if (e->ident == Id::allMembers || e->ident == Id::derivedMembers)
{
if (dim != 1)
goto Ldimerror;
RootObject *o = (*e->args)[0];
Dsymbol *s = getDsymbol(o);
ScopeDsymbol *sds;
if (!s)
{
e->error("argument has no members");
goto Lfalse;
}
Import *import;
if ((import = s->isImport()) != NULL)
{
// Bugzilla 9692
sds = import->mod;
}
else if ((sds = s->isScopeDsymbol()) == NULL)
{
e->error("%s %s has no members", s->kind(), s->toChars());
goto Lfalse;
}
// use a struct as local function
struct PushIdentsDg
{
static int dg(void *ctx, size_t n, Dsymbol *sm)
{
if (!sm)
return 1;
//printf("\t[%i] %s %s\n", i, sm->kind(), sm->toChars());
if (sm->ident)
{
if (sm->ident != Id::ctor &&
sm->ident != Id::dtor &&
sm->ident != Id::_postblit &&
memcmp(sm->ident->string, "__", 2) == 0)
{
return 0;
}
//printf("\t%s\n", sm->ident->toChars());
Identifiers *idents = (Identifiers *)ctx;
/* Skip if already present in idents[]
*/
for (size_t j = 0; j < idents->dim; j++)
{ Identifier *id = (*idents)[j];
if (id == sm->ident)
return 0;
#ifdef DEBUG
// Avoid using strcmp in the first place due to the performance impact in an O(N^2) loop.
assert(strcmp(id->toChars(), sm->ident->toChars()) != 0);
#endif
}
idents->push(sm->ident);
}
else
{
EnumDeclaration *ed = sm->isEnumDeclaration();
if (ed)
{
ScopeDsymbol::foreach(NULL, ed->members, &PushIdentsDg::dg, (Identifiers *)ctx);
}
}
return 0;
}
};
Identifiers *idents = new Identifiers;
ScopeDsymbol::foreach(sc, sds->members, &PushIdentsDg::dg, idents);
ClassDeclaration *cd = sds->isClassDeclaration();
if (cd && e->ident == Id::allMembers)
{
struct PushBaseMembers
{
static void dg(ClassDeclaration *cd, Identifiers *idents)
{
for (size_t i = 0; i < cd->baseclasses->dim; i++)
{
ClassDeclaration *cb = (*cd->baseclasses)[i]->base;
ScopeDsymbol::foreach(NULL, cb->members, &PushIdentsDg::dg, idents);
if (cb->baseclasses->dim)
dg(cb, idents);
}
}
};
PushBaseMembers::dg(cd, idents);
}
// Turn Identifiers into StringExps reusing the allocated array
assert(sizeof(Expressions) == sizeof(Identifiers));
Expressions *exps = (Expressions *)idents;
for (size_t i = 0; i < idents->dim; i++)
{
Identifier *id = (*idents)[i];
StringExp *se = new StringExp(e->loc, id->toChars());
(*exps)[i] = se;
}
/* Making this a tuple is more flexible, as it can be statically unrolled.
* To make an array literal, enclose __traits in [ ]:
* [ __traits(allMembers, ...) ]
*/
Expression *ex = new TupleExp(e->loc, exps);
ex = ex->semantic(sc);
return ex;
}
else if (e->ident == Id::compiles)
{
/* Determine if all the objects - types, expressions, or symbols -
* compile without error
*/
if (!dim)
goto Lfalse;
for (size_t i = 0; i < dim; i++)
{
unsigned errors = global.startGagging();
unsigned oldspec = global.speculativeGag;
global.speculativeGag = global.gag;
Scope *sc2 = sc->push();
sc2->speculative = true;
sc2->flags = sc->flags & ~SCOPEctfe | SCOPEcompile;
bool err = false;
RootObject *o = (*e->args)[i];
Type *t = isType(o);
Expression *ex = t ? t->toExpression() : isExpression(o);
if (!ex && t)
{
Dsymbol *s;
t->resolve(e->loc, sc2, &ex, &t, &s);
if (t)
{
t->semantic(e->loc, sc2);
if (t->ty == Terror)
err = true;
}
else if (s && s->errors)
err = true;
}
if (ex)
{
ex = ex->semantic(sc2);
ex = resolvePropertiesOnly(sc2, ex);
ex = ex->optimize(WANTvalue);
ex = checkGC(sc2, ex);
if (ex->op == TOKerror)
err = true;
}
sc2->pop();
global.speculativeGag = oldspec;
if (global.endGagging(errors) || err)
{
goto Lfalse;
}
}
goto Ltrue;
}
else if (e->ident == Id::isSame)
{
/* Determine if two symbols are the same
*/
if (dim != 2)
goto Ldimerror;
if (!TemplateInstance::semanticTiargs(e->loc, sc, e->args, 0))
return new ErrorExp();
RootObject *o1 = (*e->args)[0];
RootObject *o2 = (*e->args)[1];
Dsymbol *s1 = getDsymbol(o1);
Dsymbol *s2 = getDsymbol(o2);
//printf("isSame: %s, %s\n", o1->toChars(), o2->toChars());
#if 0
printf("o1: %p\n", o1);
printf("o2: %p\n", o2);
if (!s1)
{
Expression *ea = isExpression(o1);
if (ea)
printf("%s\n", ea->toChars());
Type *ta = isType(o1);
if (ta)
printf("%s\n", ta->toChars());
goto Lfalse;
}
else
printf("%s %s\n", s1->kind(), s1->toChars());
#endif
if (!s1 && !s2)
{
Expression *ea1 = isExpression(o1);
Expression *ea2 = isExpression(o2);
if (ea1 && ea2)
{
if (ea1->equals(ea2))
goto Ltrue;
}
}
if (!s1 || !s2)
goto Lfalse;
s1 = s1->toAlias();
s2 = s2->toAlias();
if (s1->isFuncAliasDeclaration())
s1 = ((FuncAliasDeclaration *)s1)->toAliasFunc();
if (s2->isFuncAliasDeclaration())
s2 = ((FuncAliasDeclaration *)s2)->toAliasFunc();
if (s1 == s2)
goto Ltrue;
else
goto Lfalse;
}
else if (e->ident == Id::getUnitTests)
{
if (dim != 1)
goto Ldimerror;
RootObject *o = (*e->args)[0];
Dsymbol *s = getDsymbol(o);
if (!s)
{
e->error("argument %s to __traits(getUnitTests) must be a module or aggregate", o->toChars());
goto Lfalse;
}
Import *imp = s->isImport();
if (imp) // Bugzilla 10990
s = imp->mod;
ScopeDsymbol* scope = s->isScopeDsymbol();
if (!scope)
{
e->error("argument %s to __traits(getUnitTests) must be a module or aggregate, not a %s", s->toChars(), s->kind());
goto Lfalse;
}
Expressions* unitTests = new Expressions();
Dsymbols* symbols = scope->members;
if (global.params.useUnitTests && symbols)
{
// Should actually be a set
AA* uniqueUnitTests = NULL;
collectUnitTests(symbols, uniqueUnitTests, unitTests);
}
TupleExp *tup = new TupleExp(e->loc, unitTests);
return tup->semantic(sc);
}
else if(e->ident == Id::getVirtualIndex)
{
if (dim != 1)
goto Ldimerror;
RootObject *o = (*e->args)[0];
Dsymbol *s = getDsymbol(o);
FuncDeclaration *fd;
if (!s || (fd = s->isFuncDeclaration()) == NULL)
{
e->error("first argument to __traits(getVirtualIndex) must be a function");
goto Lfalse;
}
fd = fd->toAliasFunc(); // Neccessary to support multiple overloads.
return new IntegerExp(e->loc, fd->vtblIndex, Type::tptrdiff_t);
}
else
{
if (const char *sub = (const char *)speller(e->ident->toChars(), &trait_search_fp, NULL, idchars))
e->error("unrecognized trait '%s', did you mean '%s'?", e->ident->toChars(), sub);
else
e->error("unrecognized trait '%s'", e->ident->toChars());
goto Lfalse;
}
return NULL;
Ldimerror:
e->error("wrong number of arguments %d", (int)dim);
goto Lfalse;
Lfalse:
return new IntegerExp(e->loc, 0, Type::tbool);
Ltrue:
return new IntegerExp(e->loc, 1, Type::tbool);
}
void StructDeclaration::semantic(Scope *sc)
{
Scope *sc2;
//printf("+StructDeclaration::semantic(this=%p, '%s', sizeok = %d)\n", this, toChars(), sizeok);
//static int count; if (++count == 20) halt();
assert(type);
if (!members) // if forward reference
return;
if (symtab)
{ if (sizeok == 1 || !scope)
{ //printf("already completed\n");
scope = NULL;
return; // semantic() already completed
}
}
else
symtab = new DsymbolTable();
Scope *scx = NULL;
if (scope)
{ sc = scope;
scx = scope; // save so we don't make redundant copies
scope = NULL;
}
unsigned dprogress_save = Module::dprogress;
#ifdef IN_GCC
methods.setDim(0);
#endif
parent = sc->parent;
type = type->semantic(loc, sc);
#if STRUCTTHISREF
handle = type;
#else
handle = type->pointerTo();
#endif
structalign = sc->structalign;
protection = sc->protection;
if (sc->stc & STCdeprecated)
isdeprecated = 1;
assert(!isAnonymous());
if (sc->stc & STCabstract)
error("structs, unions cannot be abstract");
#if DMDV2
if (storage_class & STCimmutable)
type = type->invariantOf();
else if (storage_class & STCconst)
type = type->constOf();
#endif
#if IN_GCC
if (attributes)
attributes->append(sc->attributes);
else
attributes = sc->attributes;
#endif
if (sizeok == 0) // if not already done the addMember step
{
for (size_t i = 0; i < members->dim; i++)
{
Dsymbol *s = (Dsymbol *)members->data[i];
//printf("adding member '%s' to '%s'\n", s->toChars(), this->toChars());
s->addMember(sc, this, 1);
}
}
sizeok = 0;
sc2 = sc->push(this);
sc2->stc = 0;
#if IN_GCC
sc2->attributes = NULL;
#endif
sc2->parent = this;
if (isUnionDeclaration())
sc2->inunion = 1;
sc2->protection = PROTpublic;
sc2->explicitProtection = 0;
size_t members_dim = members->dim;
/* Set scope so if there are forward references, we still might be able to
* resolve individual members like enums.
*/
for (size_t i = 0; i < members_dim; i++)
{ Dsymbol *s = (Dsymbol *)members->data[i];
/* There are problems doing this in the general case because
* Scope keeps track of things like 'offset'
*/
if (s->isEnumDeclaration() || (s->isAggregateDeclaration() && s->ident))
{
//printf("setScope %s %s\n", s->kind(), s->toChars());
s->setScope(sc2);
}
}
for (size_t i = 0; i < members_dim; i++)
{
Dsymbol *s = (Dsymbol *)members->data[i];
s->semantic(sc2);
#if 0
if (sizeok == 2)
{ //printf("forward reference\n");
break;
}
#endif
}
#if DMDV1
/* This doesn't work for DMDV2 because (ref S) and (S) parameter
* lists will overload the same.
*/
/* The TypeInfo_Struct is expecting an opEquals and opCmp with
* a parameter that is a pointer to the struct. But if there
* isn't one, but is an opEquals or opCmp with a value, write
* another that is a shell around the value:
* int opCmp(struct *p) { return opCmp(*p); }
*/
TypeFunction *tfeqptr;
{
Parameters *arguments = new Parameters;
Parameter *arg = new Parameter(STCin, handle, Id::p, NULL);
arguments->push(arg);
tfeqptr = new TypeFunction(arguments, Type::tint32, 0, LINKd);
tfeqptr = (TypeFunction *)tfeqptr->semantic(0, sc);
}
TypeFunction *tfeq;
{
Parameters *arguments = new Parameters;
Parameter *arg = new Parameter(STCin, type, NULL, NULL);
arguments->push(arg);
tfeq = new TypeFunction(arguments, Type::tint32, 0, LINKd);
tfeq = (TypeFunction *)tfeq->semantic(0, sc);
}
Identifier *id = Id::eq;
for (int i = 0; i < 2; i++)
{
Dsymbol *s = search_function(this, id);
FuncDeclaration *fdx = s ? s->isFuncDeclaration() : NULL;
if (fdx)
{ FuncDeclaration *fd = fdx->overloadExactMatch(tfeqptr);
if (!fd)
{ fd = fdx->overloadExactMatch(tfeq);
if (fd)
{ // Create the thunk, fdptr
FuncDeclaration *fdptr = new FuncDeclaration(loc, loc, fdx->ident, STCundefined, tfeqptr);
Expression *e = new IdentifierExp(loc, Id::p);
e = new PtrExp(loc, e);
Expressions *args = new Expressions();
args->push(e);
e = new IdentifierExp(loc, id);
e = new CallExp(loc, e, args);
fdptr->fbody = new ReturnStatement(loc, e);
ScopeDsymbol *s = fdx->parent->isScopeDsymbol();
assert(s);
s->members->push(fdptr);
fdptr->addMember(sc, s, 1);
fdptr->semantic(sc2);
}
}
}
id = Id::cmp;
}
#endif
#if DMDV2
/* Try to find the opEquals function. Build it if necessary.
*/
TypeFunction *tfeqptr;
{ // bool opEquals(const T*) const;
Parameters *parameters = new Parameters;
#if STRUCTTHISREF
// bool opEquals(ref const T) const;
Parameter *param = new Parameter(STCref, type->constOf(), NULL, NULL);
#else
// bool opEquals(const T*) const;
Parameter *param = new Parameter(STCin, type->pointerTo(), NULL, NULL);
#endif
parameters->push(param);
tfeqptr = new TypeFunction(parameters, Type::tbool, 0, LINKd);
tfeqptr->mod = MODconst;
tfeqptr = (TypeFunction *)tfeqptr->semantic(0, sc2);
Dsymbol *s = search_function(this, Id::eq);
FuncDeclaration *fdx = s ? s->isFuncDeclaration() : NULL;
if (fdx)
{
eq = fdx->overloadExactMatch(tfeqptr);
if (!eq)
fdx->error("type signature should be %s not %s", tfeqptr->toChars(), fdx->type->toChars());
}
TemplateDeclaration *td = s ? s->isTemplateDeclaration() : NULL;
// BUG: should also check that td is a function template, not just a template
if (!eq && !td)
eq = buildOpEquals(sc2);
}
dtor = buildDtor(sc2);
postblit = buildPostBlit(sc2);
cpctor = buildCpCtor(sc2);
buildOpAssign(sc2);
#endif
sc2->pop();
if (sizeok == 2)
{ // semantic() failed because of forward references.
// Unwind what we did, and defer it for later
fields.setDim(0);
structsize = 0;
alignsize = 0;
structalign = 0;
scope = scx ? scx : new Scope(*sc);
scope->setNoFree();
scope->module->addDeferredSemantic(this);
Module::dprogress = dprogress_save;
//printf("\tdeferring %s\n", toChars());
return;
}
// 0 sized struct's are set to 1 byte
if (structsize == 0)
{
structsize = 1;
alignsize = 1;
}
// Round struct size up to next alignsize boundary.
// This will ensure that arrays of structs will get their internals
// aligned properly.
structsize = (structsize + alignsize - 1) & ~(alignsize - 1);
sizeok = 1;
Module::dprogress++;
//printf("-StructDeclaration::semantic(this=%p, '%s')\n", this, toChars());
// Determine if struct is all zeros or not
zeroInit = 1;
for (size_t i = 0; i < fields.dim; i++)
{
Dsymbol *s = (Dsymbol *)fields.data[i];
VarDeclaration *vd = s->isVarDeclaration();
if (vd && !vd->isDataseg())
{
if (vd->init)
{
// Should examine init to see if it is really all 0's
zeroInit = 0;
break;
}
else
{
if (!vd->type->isZeroInit(loc))
{
zeroInit = 0;
break;
}
}
}
}
/* Look for special member functions.
*/
#if DMDV2
ctor = search(0, Id::ctor, 0);
#endif
inv = (InvariantDeclaration *)search(0, Id::classInvariant, 0);
aggNew = (NewDeclaration *)search(0, Id::classNew, 0);
aggDelete = (DeleteDeclaration *)search(0, Id::classDelete, 0);
if (sc->func)
{
semantic2(sc);
semantic3(sc);
}
}
void PragmaDeclaration::semantic(Scope *sc)
{ // Should be merged with PragmaStatement
Scope sc_save;
//printf("\tPragmaDeclaration::semantic '%s'\n",toChars());
if (ident == Id::msg)
{
if (args)
{
for (size_t i = 0; i < args->dim; i++)
{
Expression *e = args->tdata()[i];
e = e->semantic(sc);
e = e->optimize(WANTvalue | WANTinterpret);
StringExp *se = e->toString();
if (se)
{
fprintf(stdmsg, "%.*s", (int)se->len, (char *)se->string);
}
else
fprintf(stdmsg, "%s", e->toChars());
}
fprintf(stdmsg, "\n");
}
goto Lnodecl;
}
else if (ident == Id::lib)
{
if (!args || args->dim != 1)
error("string expected for library name");
else
{
Expression *e = args->tdata()[0];
e = e->semantic(sc);
e = e->optimize(WANTvalue | WANTinterpret);
args->tdata()[0] = e;
if (e->op == TOKerror)
goto Lnodecl;
StringExp *se = e->toString();
if (!se)
error("string expected for library name, not '%s'", e->toChars());
else if (global.params.verbose)
{
char *name = (char *)mem.malloc(se->len + 1);
memcpy(name, se->string, se->len);
name[se->len] = 0;
printf("library %s\n", name);
mem.free(name);
}
}
goto Lnodecl;
}
#if IN_GCC
else if (ident == Id::GNU_asm)
{
if (! args || args->dim != 2)
error("identifier and string expected for asm name");
else
{
Expression *e;
Declaration *d = NULL;
StringExp *s = NULL;
e = (Expression *)args->data[0];
e = e->semantic(sc);
if (e->op == TOKvar)
{
d = ((VarExp *)e)->var;
if (! d->isFuncDeclaration() && ! d->isVarDeclaration())
d = NULL;
}
if (!d)
error("first argument of GNU_asm must be a function or variable declaration");
e = args->tdata()[1];
e = e->semantic(sc);
e = e->optimize(WANTvalue);
e = e->toString();
if (e && ((StringExp *)e)->sz == 1)
s = ((StringExp *)e);
else
error("second argument of GNU_asm must be a character string");
if (d && s)
d->c_ident = Lexer::idPool((char*) s->string);
}
goto Lnodecl;
}
else if (ident == Id::GNU_attribute || ident == Id::_GNU_attribute)
{
if (!global.params.useDeprecated && ident == Id::_GNU_attribute)
error("pragma(GNU_attribute) is deprecated, use pragma(attribute) instead");
sc_save = *sc;
// An empty list is allowed.
if (args && args->dim)
{
Expressions * a;
if (sc->attributes)
a = (Expressions *) sc->attributes->copy();
else
a = new Expressions;
sc->attributes = a;
for (unsigned i = 0; i < args->dim; i++)
{
Expression * e = args->tdata()[i];
//e = e->semantic(sc);
if (e->op == TOKidentifier)
; // ok
else if (e->op == TOKcall)
{
CallExp * c = (CallExp *) e;
if (c->e1->op != TOKidentifier)
error("identifier or call expression expected for attribute");
if (c->arguments)
for (int unsigned ai = 0; ai < c->arguments->dim; ai++)
{
Expression * ea = c->arguments->tdata()[ai];
ea = ea->semantic(sc);
ea = ea->optimize(WANTvalue | WANTinterpret);
c->arguments->tdata()[ai] = ea;
}
}
else
{
error("identifier or call expression expected for attribute");
continue;
}
a->push(e);
}
}
}
else if (ident == Id::GNU_set_attribute || ident == Id::_GNU_set_attribute)
{
if (!global.params.useDeprecated && ident == Id::_GNU_set_attribute)
error("pragma(GNU_set_attribute) is deprecated, use pragma(set_attribute) instead");
if (!args || args->dim < 1)
error("declaration expected for setting attributes");
else
{
Expressions ** p_attributes = NULL; // list of existing attributes
{
Expression * e = args->tdata()[0];
e = e->semantic(sc);
if (e->op == TOKvar)
{
Declaration * d = ((VarExp *)e)->var;
if (d->isFuncDeclaration() || d->isVarDeclaration())
p_attributes = & d->attributes;
}
else if (e->op == TOKtype)
{
Type * t = ((TypeExp *)e)->type;
if (t->ty == Ttypedef)
p_attributes = & ((TypeTypedef *) t)->sym->attributes;
else if (t->ty == Tenum)
p_attributes = & ((TypeEnum *) t)->sym->attributes;
else if (t->ty == Tstruct)
p_attributes = & ((TypeStruct *) t)->sym->attributes;
else if (t->ty == Tclass)
p_attributes = & ((TypeClass *) t)->sym->attributes;
}
if (p_attributes == NULL)
error("first argument must be a function, variable, or type declaration");
}
Expressions * new_attrs = new Expressions;
for (unsigned i = 1; i < args->dim; i++)
{
Expression * e = args->tdata()[i];
//e = e->semantic(sc);
if (e->op == TOKidentifier)
; // ok
else if (e->op == TOKcall)
{
CallExp * c = (CallExp *) e;
if (c->e1->op != TOKidentifier)
error("identifier or call expression expected for attribute");
if (c->arguments)
for (int unsigned ai = 0; ai < c->arguments->dim; ai++)
{
Expression * ea = c->arguments->tdata()[ai];
ea = ea->semantic(sc);
ea = ea->optimize(WANTvalue | WANTinterpret);
c->arguments->tdata()[ai] = ea;
}
}
else
{
error("identifier or call expression expected for attribute");
continue;
}
new_attrs->push(e);
}
if (p_attributes)
{
if (*p_attributes)
{
*p_attributes = (Expressions *) (*p_attributes)->copy();
(*p_attributes)->append(new_attrs);
}
else
*p_attributes = new_attrs;
}
}
goto Lnodecl;
}
#endif
#if DMDV2
else if (ident == Id::startaddress)
{
if (!args || args->dim != 1)
error("function name expected for start address");
else
{
Expression *e = (Expression *)args->data[0];
e = e->semantic(sc);
e = e->optimize(WANTvalue | WANTinterpret);
args->data[0] = (void *)e;
Dsymbol *sa = getDsymbol(e);
if (!sa || !sa->isFuncDeclaration())
error("function name expected for start address, not '%s'", e->toChars());
}
goto Lnodecl;
}
#endif
#if TARGET_NET
else if (ident == Lexer::idPool("assembly"))
{
}
#endif // TARGET_NET
else if (global.params.ignoreUnsupportedPragmas)
{
if (global.params.verbose)
{
/* Print unrecognized pragmas
*/
printf("pragma %s", ident->toChars());
if (args)
{
for (size_t i = 0; i < args->dim; i++)
{
Expression *e = (Expression *)args->data[i];
e = e->semantic(sc);
e = e->optimize(WANTvalue | WANTinterpret);
if (i == 0)
printf(" (");
else
printf(",");
printf("%s", e->toChars());
}
if (args->dim)
printf(")");
}
printf("\n");
}
goto Lnodecl;
}
else
error("unrecognized pragma(%s)", ident->toChars());
if (decl)
{
for (unsigned i = 0; i < decl->dim; i++)
{
Dsymbol *s = decl->tdata()[i];
s->semantic(sc);
}
}
#if IN_GCC
if (decl)
if (ident == Id::GNU_attribute || ident == Id::_GNU_attribute)
*sc = sc_save;
#endif
return;
Lnodecl:
if (decl)
error("pragma is missing closing ';'");
}
void StructDeclaration::semantic(Scope *sc)
{
Scope *sc2;
//printf("+StructDeclaration::semantic(this=%p, %s '%s', sizeok = %d)\n", this, parent->toChars(), toChars(), sizeok);
//static int count; if (++count == 20) halt();
assert(type);
if (!members) // if opaque declaration
{
return;
}
if (symtab)
{ if (sizeok == SIZEOKdone || !scope)
{ //printf("already completed\n");
scope = NULL;
return; // semantic() already completed
}
}
else
symtab = new DsymbolTable();
Scope *scx = NULL;
if (scope)
{ sc = scope;
scx = scope; // save so we don't make redundant copies
scope = NULL;
}
int errors = global.errors;
unsigned dprogress_save = Module::dprogress;
parent = sc->parent;
type = type->semantic(loc, sc);
handle = type;
protection = sc->protection;
alignment = sc->structalign;
storage_class |= sc->stc;
if (sc->stc & STCdeprecated)
isdeprecated = true;
assert(!isAnonymous());
if (sc->stc & STCabstract)
error("structs, unions cannot be abstract");
userAttributes = sc->userAttributes;
if (sizeok == SIZEOKnone) // if not already done the addMember step
{
for (size_t i = 0; i < members->dim; i++)
{
Dsymbol *s = (*members)[i];
//printf("adding member '%s' to '%s'\n", s->toChars(), this->toChars());
s->addMember(sc, this, 1);
}
}
sizeok = SIZEOKnone;
sc2 = sc->push(this);
sc2->stc &= STCsafe | STCtrusted | STCsystem;
sc2->parent = this;
if (isUnionDeclaration())
sc2->inunion = 1;
sc2->protection = PROTpublic;
sc2->explicitProtection = 0;
sc2->structalign = STRUCTALIGN_DEFAULT;
sc2->userAttributes = NULL;
/* Set scope so if there are forward references, we still might be able to
* resolve individual members like enums.
*/
for (size_t i = 0; i < members->dim; i++)
{ Dsymbol *s = (*members)[i];
/* There are problems doing this in the general case because
* Scope keeps track of things like 'offset'
*/
//if (s->isEnumDeclaration() || (s->isAggregateDeclaration() && s->ident))
{
//printf("struct: setScope %s %s\n", s->kind(), s->toChars());
s->setScope(sc2);
}
}
for (size_t i = 0; i < members->dim; i++)
{
Dsymbol *s = (*members)[i];
/* If this is the last member, see if we can finish setting the size.
* This could be much better - finish setting the size after the last
* field was processed. The problem is the chicken-and-egg determination
* of when that is. See Bugzilla 7426 for more info.
*/
if (i + 1 == members->dim)
{
if (sizeok == SIZEOKnone && s->isAliasDeclaration())
finalizeSize(sc2);
}
// Ungag errors when not speculative
unsigned oldgag = global.gag;
if (global.isSpeculativeGagging() && !isSpeculative())
{
global.gag = 0;
}
s->semantic(sc2);
global.gag = oldgag;
}
finalizeSize(sc2);
if (sizeok == SIZEOKfwd)
{ // semantic() failed because of forward references.
// Unwind what we did, and defer it for later
for (size_t i = 0; i < fields.dim; i++)
{ Dsymbol *s = fields[i];
VarDeclaration *vd = s->isVarDeclaration();
if (vd)
vd->offset = 0;
}
fields.setDim(0);
structsize = 0;
alignsize = 0;
// structalign = 0;
scope = scx ? scx : new Scope(*sc);
scope->setNoFree();
scope->module->addDeferredSemantic(this);
Module::dprogress = dprogress_save;
//printf("\tdeferring %s\n", toChars());
return;
}
Module::dprogress++;
//printf("-StructDeclaration::semantic(this=%p, '%s')\n", this, toChars());
// Determine if struct is all zeros or not
zeroInit = 1;
for (size_t i = 0; i < fields.dim; i++)
{
Dsymbol *s = fields[i];
VarDeclaration *vd = s->isVarDeclaration();
if (vd && !vd->isDataseg())
{
if (vd->init)
{
// Should examine init to see if it is really all 0's
zeroInit = 0;
break;
}
else
{
if (!vd->type->isZeroInit(loc))
{
zeroInit = 0;
break;
}
}
}
}
#if DMDV1
/* This doesn't work for DMDV2 because (ref S) and (S) parameter
* lists will overload the same.
*/
/* The TypeInfo_Struct is expecting an opEquals and opCmp with
* a parameter that is a pointer to the struct. But if there
* isn't one, but is an opEquals or opCmp with a value, write
* another that is a shell around the value:
* int opCmp(struct *p) { return opCmp(*p); }
*/
TypeFunction *tfeqptr;
{
Parameters *arguments = new Parameters;
Parameter *arg = new Parameter(STCin, handle, Id::p, NULL);
arguments->push(arg);
tfeqptr = new TypeFunction(arguments, Type::tint32, 0, LINKd);
tfeqptr = (TypeFunction *)tfeqptr->semantic(Loc(), sc);
}
TypeFunction *tfeq;
{
Parameters *arguments = new Parameters;
Parameter *arg = new Parameter(STCin, type, NULL, NULL);
arguments->push(arg);
tfeq = new TypeFunction(arguments, Type::tint32, 0, LINKd);
tfeq = (TypeFunction *)tfeq->semantic(Loc(), sc);
}
Identifier *id = Id::eq;
for (int i = 0; i < 2; i++)
{
Dsymbol *s = search_function(this, id);
FuncDeclaration *fdx = s ? s->isFuncDeclaration() : NULL;
if (fdx)
{ FuncDeclaration *fd = fdx->overloadExactMatch(tfeqptr);
if (!fd)
{ fd = fdx->overloadExactMatch(tfeq);
if (fd)
{ // Create the thunk, fdptr
FuncDeclaration *fdptr = new FuncDeclaration(loc, loc, fdx->ident, STCundefined, tfeqptr);
Expression *e = new IdentifierExp(loc, Id::p);
e = new PtrExp(loc, e);
Expressions *args = new Expressions();
args->push(e);
e = new IdentifierExp(loc, id);
e = new CallExp(loc, e, args);
fdptr->fbody = new ReturnStatement(loc, e);
ScopeDsymbol *s = fdx->parent->isScopeDsymbol();
assert(s);
s->members->push(fdptr);
fdptr->addMember(sc, s, 1);
fdptr->semantic(sc2);
}
}
}
id = Id::cmp;
}
#endif
#if DMDV2
dtor = buildDtor(sc2);
postblit = buildPostBlit(sc2);
cpctor = buildCpCtor(sc2);
buildOpAssign(sc2);
buildOpEquals(sc2);
#endif
inv = buildInv(sc2);
sc2->pop();
/* Look for special member functions.
*/
#if DMDV2
ctor = search(Loc(), Id::ctor, 0);
#endif
aggNew = (NewDeclaration *)search(Loc(), Id::classNew, 0);
aggDelete = (DeleteDeclaration *)search(Loc(), Id::classDelete, 0);
TypeTuple *tup = type->toArgTypes();
size_t dim = tup->arguments->dim;
if (dim >= 1)
{ assert(dim <= 2);
arg1type = (*tup->arguments)[0]->type;
if (dim == 2)
arg2type = (*tup->arguments)[1]->type;
}
if (sc->func)
{
semantic2(sc);
semantic3(sc);
}
if (global.errors != errors)
{ // The type is no good.
type = Type::terror;
}
if (deferred && !global.gag)
{
deferred->semantic2(sc);
deferred->semantic3(sc);
}
#if 0
if (type->ty == Tstruct && ((TypeStruct *)type)->sym != this)
{
printf("this = %p %s\n", this, this->toChars());
printf("type = %d sym = %p\n", type->ty, ((TypeStruct *)type)->sym);
}
#endif
assert(type->ty != Tstruct || ((TypeStruct *)type)->sym == this);
}
void StructDeclaration::semantic(Scope *sc)
{
Scope *sc2;
//printf("+StructDeclaration::semantic(this=%p, %s '%s', sizeok = %d)\n", this, parent->toChars(), toChars(), sizeok);
//static int count; if (++count == 20) halt();
assert(type);
if (!members) // if forward reference
return;
if (symtab)
{ if (sizeok == 1 || !scope)
{ //printf("already completed\n");
scope = NULL;
return; // semantic() already completed
}
}
else
symtab = new DsymbolTable();
Scope *scx = NULL;
if (scope)
{ sc = scope;
scx = scope; // save so we don't make redundant copies
scope = NULL;
}
int errors = global.gaggedErrors;
unsigned dprogress_save = Module::dprogress;
parent = sc->parent;
type = type->semantic(loc, sc);
#if STRUCTTHISREF
handle = type;
#else
handle = type->pointerTo();
#endif
structalign = sc->structalign;
protection = sc->protection;
storage_class |= sc->stc;
if (sc->stc & STCdeprecated)
isdeprecated = true;
assert(!isAnonymous());
if (sc->stc & STCabstract)
error("structs, unions cannot be abstract");
#if DMDV2
if (storage_class & STCimmutable)
type = type->addMod(MODimmutable);
if (storage_class & STCconst)
type = type->addMod(MODconst);
if (storage_class & STCshared)
type = type->addMod(MODshared);
#endif
if (sizeok == 0) // if not already done the addMember step
{
int hasfunctions = 0;
for (size_t i = 0; i < members->dim; i++)
{
Dsymbol *s = members->tdata()[i];
//printf("adding member '%s' to '%s'\n", s->toChars(), this->toChars());
s->addMember(sc, this, 1);
if (s->isFuncDeclaration())
hasfunctions = 1;
}
// If nested struct, add in hidden 'this' pointer to outer scope
if (hasfunctions && !(storage_class & STCstatic))
{ Dsymbol *s = toParent2();
if (s)
{
AggregateDeclaration *ad = s->isAggregateDeclaration();
FuncDeclaration *fd = s->isFuncDeclaration();
TemplateInstance *ti;
if (ad && (ti = ad->parent->isTemplateInstance()) != NULL && ti->isnested || fd)
{ isnested = 1;
Type *t;
if (ad)
t = ad->handle;
else if (fd)
{ AggregateDeclaration *ad = fd->isMember2();
if (ad)
t = ad->handle;
else
t = Type::tvoidptr;
}
else
assert(0);
if (t->ty == Tstruct)
t = Type::tvoidptr; // t should not be a ref type
assert(!vthis);
vthis = new ThisDeclaration(loc, t);
//vthis->storage_class |= STCref;
members->push(vthis);
}
}
}
}
sizeok = 0;
sc2 = sc->push(this);
sc2->stc &= STCsafe | STCtrusted | STCsystem;
sc2->parent = this;
if (isUnionDeclaration())
sc2->inunion = 1;
sc2->protection = PROTpublic;
sc2->explicitProtection = 0;
size_t members_dim = members->dim;
/* Set scope so if there are forward references, we still might be able to
* resolve individual members like enums.
*/
for (size_t i = 0; i < members_dim; i++)
{ Dsymbol *s = (*members)[i];
/* There are problems doing this in the general case because
* Scope keeps track of things like 'offset'
*/
if (s->isEnumDeclaration() || (s->isAggregateDeclaration() && s->ident))
{
//printf("setScope %s %s\n", s->kind(), s->toChars());
s->setScope(sc2);
}
}
for (size_t i = 0; i < members_dim; i++)
{
Dsymbol *s = (*members)[i];
/* If this is the last member, see if we can finish setting the size.
* This could be much better - finish setting the size after the last
* field was processed. The problem is the chicken-and-egg determination
* of when that is. See Bugzilla 7426 for more info.
*/
if (i + 1 == members_dim)
{
if (sizeok == 0 && s->isAliasDeclaration())
finalizeSize();
}
// Ungag errors when not speculative
unsigned oldgag = global.gag;
if (global.isSpeculativeGagging() && !isSpeculative())
global.gag = 0;
s->semantic(sc2);
global.gag = oldgag;
}
if (sizeok == 2)
{ // semantic() failed because of forward references.
// Unwind what we did, and defer it for later
fields.setDim(0);
structsize = 0;
alignsize = 0;
structalign = 0;
scope = scx ? scx : new Scope(*sc);
scope->setNoFree();
scope->module->addDeferredSemantic(this);
Module::dprogress = dprogress_save;
//printf("\tdeferring %s\n", toChars());
return;
}
finalizeSize();
Module::dprogress++;
//printf("-StructDeclaration::semantic(this=%p, '%s')\n", this, toChars());
// Determine if struct is all zeros or not
zeroInit = 1;
for (size_t i = 0; i < fields.dim; i++)
{
Dsymbol *s = fields.tdata()[i];
VarDeclaration *vd = s->isVarDeclaration();
if (vd && !vd->isDataseg())
{
if (vd->init)
{
// Should examine init to see if it is really all 0's
zeroInit = 0;
break;
}
else
{
if (!vd->type->isZeroInit(loc))
{
zeroInit = 0;
break;
}
}
}
}
#if DMDV1
/* This doesn't work for DMDV2 because (ref S) and (S) parameter
* lists will overload the same.
*/
/* The TypeInfo_Struct is expecting an opEquals and opCmp with
* a parameter that is a pointer to the struct. But if there
* isn't one, but is an opEquals or opCmp with a value, write
* another that is a shell around the value:
* int opCmp(struct *p) { return opCmp(*p); }
*/
TypeFunction *tfeqptr;
{
Parameters *arguments = new Parameters;
Parameter *arg = new Parameter(STCin, handle, Id::p, NULL);
arguments->push(arg);
tfeqptr = new TypeFunction(arguments, Type::tint32, 0, LINKd);
tfeqptr = (TypeFunction *)tfeqptr->semantic(0, sc);
}
TypeFunction *tfeq;
{
Parameters *arguments = new Parameters;
Parameter *arg = new Parameter(STCin, type, NULL, NULL);
arguments->push(arg);
tfeq = new TypeFunction(arguments, Type::tint32, 0, LINKd);
tfeq = (TypeFunction *)tfeq->semantic(0, sc);
}
Identifier *id = Id::eq;
for (int i = 0; i < 2; i++)
{
Dsymbol *s = search_function(this, id);
FuncDeclaration *fdx = s ? s->isFuncDeclaration() : NULL;
if (fdx)
{ FuncDeclaration *fd = fdx->overloadExactMatch(tfeqptr);
if (!fd)
{ fd = fdx->overloadExactMatch(tfeq);
if (fd)
{ // Create the thunk, fdptr
FuncDeclaration *fdptr = new FuncDeclaration(loc, loc, fdx->ident, STCundefined, tfeqptr);
Expression *e = new IdentifierExp(loc, Id::p);
e = new PtrExp(loc, e);
Expressions *args = new Expressions();
args->push(e);
e = new IdentifierExp(loc, id);
e = new CallExp(loc, e, args);
fdptr->fbody = new ReturnStatement(loc, e);
ScopeDsymbol *s = fdx->parent->isScopeDsymbol();
assert(s);
s->members->push(fdptr);
fdptr->addMember(sc, s, 1);
fdptr->semantic(sc2);
}
}
}
id = Id::cmp;
}
#endif
#if DMDV2
dtor = buildDtor(sc2);
postblit = buildPostBlit(sc2);
cpctor = buildCpCtor(sc2);
buildOpAssign(sc2);
hasIdentityEquals = (buildOpEquals(sc2) != NULL);
xeq = buildXopEquals(sc2);
#endif
sc2->pop();
/* Look for special member functions.
*/
#if DMDV2
ctor = search(0, Id::ctor, 0);
#endif
inv = (InvariantDeclaration *)search(0, Id::classInvariant, 0);
aggNew = (NewDeclaration *)search(0, Id::classNew, 0);
aggDelete = (DeleteDeclaration *)search(0, Id::classDelete, 0);
if (sc->func)
{
semantic2(sc);
semantic3(sc);
}
if (global.gag && global.gaggedErrors != errors)
{ // The type is no good, yet the error messages were gagged.
type = Type::terror;
}
if (deferred && !global.gag)
{
deferred->semantic2(sc);
deferred->semantic3(sc);
}
}