Skip to content

Commit

Permalink
Merge pull request #3258 from yebblies/voidinitliteral
Browse files Browse the repository at this point in the history 
[DDMD] [refactor] Move voidInitLiteral into a free function
  • Loading branch information
@AndrejMitrovic
AndrejMitrovic committed Feb 14, 2014
2 parents e1b18fd + 242b703 commit 38509fb
Show file tree
Hide file tree
Showing 4 changed files with 44 additions and 41 deletions.
2 changes: 2 additions & 0 deletions src/ctfe.h
View file
Expand Up @@ -71,6 +71,8 @@ class VoidInitExp : public Expression
void accept(Visitor *v) { v->visit(this); }
};

// Create an appropriate void initializer
Expression *voidInitLiteral(Type *t, VarDeclaration *var);

/** Fake class which holds the thrown exception.
Used for implementing exception handling.
Expand Down
72 changes: 38 additions & 34 deletions src/ctfeexpr.c
View file
Expand Up @@ -267,7 +267,7 @@ Expression *copyLiteral(Expression *e)
VarDeclaration *v = sd->fields[i];
// If it is a void assignment, use the default initializer
if (!m)
m = v->type->voidInitLiteral(v);
m = voidInitLiteral(v->type, v);
if (m->op == TOKslice)
m = resolveSlice(m);
if ((v->type->ty != m->type->ty) && v->type->ty == Tsarray)
Expand Down Expand Up @@ -2182,43 +2182,47 @@ void showCtfeExpr(Expression *e, int level)

/*************************** Void initialization ***************************/

Expression *Type::voidInitLiteral(VarDeclaration *var)
Expression *voidInitLiteral(Type *t, VarDeclaration *var)
{
return new VoidInitExp(var, this);
}

Expression *TypeSArray::voidInitLiteral(VarDeclaration *var)
{
Expression *elem = next->voidInitLiteral(var);
if (t->ty == Tsarray)
{
TypeSArray *tsa = (TypeSArray *)t;
Expression *elem = voidInitLiteral(tsa->next, var);

// For aggregate value types (structs, static arrays) we must
// create an a separate copy for each element.
bool mustCopy = (elem->op == TOKarrayliteral || elem->op == TOKstructliteral);
// For aggregate value types (structs, static arrays) we must
// create an a separate copy for each element.
bool mustCopy = (elem->op == TOKarrayliteral || elem->op == TOKstructliteral);

Expressions *elements = new Expressions();
size_t d = (size_t)dim->toInteger();
elements->setDim(d);
for (size_t i = 0; i < d; i++)
{ if (mustCopy && i > 0)
elem = copyLiteral(elem);
(*elements)[i] = elem;
Expressions *elements = new Expressions();
size_t d = (size_t)tsa->dim->toInteger();
elements->setDim(d);
for (size_t i = 0; i < d; i++)
{
if (mustCopy && i > 0)
elem = copyLiteral(elem);
(*elements)[i] = elem;
}
ArrayLiteralExp *ae = new ArrayLiteralExp(var->loc, elements);
ae->type = tsa;
ae->ownedByCtfe = true;
return ae;
}
ArrayLiteralExp *ae = new ArrayLiteralExp(var->loc, elements);
ae->type = this;
ae->ownedByCtfe = true;
return ae;
}

Expression *TypeStruct::voidInitLiteral(VarDeclaration *var)
{
Expressions *exps = new Expressions();
exps->setDim(sym->fields.dim);
for (size_t i = 0; i < sym->fields.dim; i++)
else if (t->ty == Tstruct)
{
(*exps)[i] = sym->fields[i]->type->voidInitLiteral(sym->fields[i]);
TypeStruct *ts = (TypeStruct *)t;
Expressions *exps = new Expressions();
exps->setDim(ts->sym->fields.dim);
for (size_t i = 0; i < ts->sym->fields.dim; i++)
{
(*exps)[i] = voidInitLiteral(ts->sym->fields[i]->type, ts->sym->fields[i]);
}
StructLiteralExp *se = new StructLiteralExp(var->loc, ts->sym, exps);
se->type = ts;
se->ownedByCtfe = true;
return se;
}
else
{
return new VoidInitExp(var, t);
}
StructLiteralExp *se = new StructLiteralExp(var->loc, sym, exps);
se->type = this;
se->ownedByCtfe = true;
return se;
}
8 changes: 4 additions & 4 deletions src/interpret.c
View file
Expand Up @@ -2589,7 +2589,7 @@ class Interpreter : public Visitor
result = ie->exp->interpret(istate, goal);
else if (v->init->isVoidInitializer())
{
result = v->type->voidInitLiteral(v);
result = voidInitLiteral(v->type, v);
// There is no AssignExp for void initializers,
// so set it here.
v->setValue(result);
Expand Down Expand Up @@ -2921,7 +2921,7 @@ class Interpreter : public Visitor
* leave CTFE, causing another memory allocation if we use this
* same struct literal again.
*
* ex = sd->fields[i]->type->voidInitLiteral(sd->fields[i]);
* ex = voidInitLiteral(sd->fields[i]->type, sd->fields[i]);
*/
ex = NULL;
}
Expand Down Expand Up @@ -3061,7 +3061,7 @@ class Interpreter : public Visitor
if (v->init)
{
if (v->init->isVoidInitializer())
m = v->type->voidInitLiteral(v);
m = voidInitLiteral(v->type, v);
else
m = v->getConstInitializer(true);
}
Expand Down Expand Up @@ -4021,7 +4021,7 @@ class Interpreter : public Visitor
continue;
Expression **exp = &(*se->elements)[i];
if ((*exp)->op != TOKvoid)
*exp = (*exp)->type->voidInitLiteral(member);
*exp = voidInitLiteral((*exp)->type, member);
}
}

Expand Down
3 changes: 0 additions & 3 deletions src/mtype.h
View file
Expand Up @@ -320,7 +320,6 @@ class Type : public RootObject
Expression *noMember(Scope *sc, Expression *e, Identifier *ident, int flag);
virtual Expression *defaultInit(Loc loc = Loc());
virtual Expression *defaultInitLiteral(Loc loc);
virtual Expression *voidInitLiteral(VarDeclaration *var);
virtual int isZeroInit(Loc loc = Loc()); // if initializer is 0
Identifier *getTypeInfoIdent(int internal);
virtual MATCH deduceType(Scope *sc, Type *tparam, TemplateParameters *parameters, Objects *dedtypes, unsigned *wm = NULL);
Expand Down Expand Up @@ -487,7 +486,6 @@ class TypeSArray : public TypeArray
MATCH implicitConvTo(Type *to);
Expression *defaultInit(Loc loc);
Expression *defaultInitLiteral(Loc loc);
Expression *voidInitLiteral(VarDeclaration *var);
MATCH deduceType(Scope *sc, Type *tparam, TemplateParameters *parameters, Objects *dedtypes, unsigned *wm = NULL);
TypeInfoDeclaration *getTypeInfoDeclaration();
Expression *toExpression();
Expand Down Expand Up @@ -796,7 +794,6 @@ class TypeStruct : public Type
structalign_t alignment();
Expression *defaultInit(Loc loc);
Expression *defaultInitLiteral(Loc loc);
Expression *voidInitLiteral(VarDeclaration *var);
int isZeroInit(Loc loc);
int isAssignable();
int checkBoolean();
Expand Down

0 comments on commit 38509fb

Please sign in to comment.