Expression *DotVarExp::optimize(int result)
{
//printf("DotVarExp::optimize(result = x%x) %s\n", result, toChars());
e1 = e1->optimize(result);
Expression *e = e1;
if (e1->op == TOKvar)
{ VarExp *ve = (VarExp *)e1;
VarDeclaration *v = ve->var->isVarDeclaration();
e = expandVar(result, v);
}
if (e && e->op == TOKstructliteral)
{ StructLiteralExp *sle = (StructLiteralExp *)e;
VarDeclaration *vf = var->isVarDeclaration();
if (vf)
{
Expression *e = sle->getField(type, vf->offset);
if (e && e != EXP_CANT_INTERPRET)
return e;
}
}
return this;
}
Expression *fromConstInitializer(int result, Expression *e1)
{
//printf("fromConstInitializer(result = %x, %s)\n", result, e1->toChars());
//static int xx; if (xx++ == 10) assert(0);
Expression *e = e1;
if (e1->op == TOKvar)
{ VarExp *ve = (VarExp *)e1;
VarDeclaration *v = ve->var->isVarDeclaration();
int fwdref = (v && !v->originalType && v->scope);
e = expandVar(result, v);
if (e)
{
// If it is a comma expression involving a declaration, we mustn't
// perform a copy -- we'd get two declarations of the same variable.
// See bugzilla 4465.
if (e->op == TOKcomma && ((CommaExp *)e)->e1->op == TOKdeclaration)
e = e1;
else
if (e->type != e1->type && e1->type && e1->type->ty != Tident)
{ // Type 'paint' operation
e = e->copy();
e->type = e1->type;
}
e->loc = e1->loc;
}
else
e = e1;
}
return e;
}
Expression *PtrExp::optimize(int result, bool keepLvalue)
{
//printf("PtrExp::optimize(result = x%x) %s\n", result, toChars());
e1 = e1->optimize(result);
// Convert *&ex to ex
if (e1->op == TOKaddress)
{ Expression *e;
Expression *ex;
ex = ((AddrExp *)e1)->e1;
if (type->equals(ex->type))
e = ex;
else
{
e = ex->copy();
e->type = type;
}
return e;
}
if (keepLvalue)
return this;
// Constant fold *(&structliteral + offset)
if (e1->op == TOKadd)
{
Expression *e;
e = Ptr(type, e1);
if (e != EXP_CANT_INTERPRET)
return e;
}
if (e1->op == TOKsymoff)
{ SymOffExp *se = (SymOffExp *)e1;
VarDeclaration *v = se->var->isVarDeclaration();
Expression *e = expandVar(result, v);
if (e && e->op == TOKstructliteral)
{ StructLiteralExp *sle = (StructLiteralExp *)e;
e = sle->getField(type, se->offset);
if (e && e != EXP_CANT_INTERPRET)
return e;
}
}
return this;
}
Expression *fromConstInitializer(int result, Expression *e1)
{
//printf("fromConstInitializer(result = %x, %s)\n", result, e1->toChars());
//static int xx; if (xx++ == 10) assert(0);
Expression *e = e1;
if (e1->op == TOKvar)
{ VarExp *ve = (VarExp *)e1;
VarDeclaration *v = ve->var->isVarDeclaration();
e = expandVar(result, v);
if (e)
{
// If it is a comma expression involving a declaration, we mustn't
// perform a copy -- we'd get two declarations of the same variable.
// See bugzilla 4465.
if (e->op == TOKcomma && ((CommaExp *)e)->e1->op == TOKdeclaration)
e = e1;
else
if (e->type != e1->type && e1->type && e1->type->ty != Tident)
{ // Type 'paint' operation
e = e->copy();
e->type = e1->type;
}
e->loc = e1->loc;
}
else
{
e = e1;
/* If we needed to interpret, generate an error.
* Don't give an error if it's a template parameter
*/
if (v && (result & WANTinterpret) &&
!(v->storage_class & STCtemplateparameter))
{
e1->error("variable %s cannot be read at compile time", v->toChars());
e = e->copy();
e->type = Type::terror;
}
}
}
return e;
}
Expression *fromConstInitializer(int result, Expression *e1)
{
//printf("fromConstInitializer(result = %x, %s)\n", result, e1->toChars());
//static int xx; if (xx++ == 10) assert(0);
Expression *e = e1;
if (e1->op == TOKvar)
{ VarExp *ve = (VarExp *)e1;
VarDeclaration *v = ve->var->isVarDeclaration();
e = expandVar(result, v);
if (e)
{ if (e->type != e1->type)
{ // Type 'paint' operation
e = e->copy();
e->type = e1->type;
}
}
else
e = e1;
}
return e;
}
