public override void TraverseChildren(IBoundExpression boundExpression)
{
//if (boundExpression.Instance != null && !IsAtomicInstance(boundExpression.Instance)) {
// // Simplify the BE so that all nested dereferences and method calls are broken up into separate assignments to locals.
// var se = ExpressionSimplifier.Simplify(this.sink, boundExpression);
// this.Traverse(se);
// return;
//}
if (boundExpression.Instance != null) {
this.Traverse(boundExpression.Instance);
var nestedBE = boundExpression.Instance as IBoundExpression;
if (nestedBE != null) {
var l = this.sink.CreateFreshLocal(nestedBE.Type);
var e = this.TranslatedExpressions.Pop();
var lhs = Bpl.Expr.Ident(l);
var cmd = Bpl.Cmd.SimpleAssign(boundExpression.Token(), lhs, e);
this.StmtTraverser.StmtBuilder.Add(cmd);
this.TranslatedExpressions.Push(lhs);
}
}
#region Local
ILocalDefinition local = boundExpression.Definition as ILocalDefinition;
if (local != null)
{
TranslatedExpressions.Push(Bpl.Expr.Ident(this.sink.FindOrCreateLocalVariable(local)));
return;
}
#endregion
#region Parameter
IParameterDefinition param = boundExpression.Definition as IParameterDefinition;
if (param != null)
{
this.LoadParameter(param);
return;
}
#endregion
#region Field
IFieldReference field = boundExpression.Definition as IFieldReference;
if (field != null) {
var f = Bpl.Expr.Ident(this.sink.FindOrCreateFieldVariable(field.ResolvedField));
var instance = boundExpression.Instance;
if (instance == null) {
TranslatedExpressions.Push(f);
} else {
// this.Traverse(instance);
Bpl.Expr instanceExpr = TranslatedExpressions.Pop();
var bplType = this.sink.CciTypeToBoogie(field.Type);
var e = this.sink.Heap.ReadHeap(instanceExpr, f, field.ContainingType.ResolvedType.IsStruct ? AccessType.Struct : AccessType.Heap, bplType);
AssertOrAssumeNonNull(boundExpression.Token(), instanceExpr);
this.TranslatedExpressions.Push(e);
}
return;
}
#endregion
#region ArrayIndexer
IArrayIndexer/*?*/ indexer = boundExpression.Definition as IArrayIndexer;
if (indexer != null)
{
this.Traverse(indexer);
return;
}
#endregion
#region AddressDereference
IAddressDereference/*?*/ deref = boundExpression.Definition as IAddressDereference;
if (deref != null)
{
IAddressOf/*?*/ addressOf = deref.Address as IAddressOf;
if (addressOf != null)
{
this.Traverse(addressOf.Expression);
return;
}
if (boundExpression.Instance != null)
{
// TODO
this.Traverse(boundExpression.Instance);
Console.Write("->");
}
else if (deref.Address.Type is IPointerTypeReference)
Console.Write("*");
this.Traverse(deref.Address);
return;
}
else
{
if (boundExpression.Instance != null)
{
throw new NotImplementedException("Addr DeRef without instance.");
}
}
#endregion
}
