public override void Visit(IAddressOf addressOf)
{
if (Process(addressOf))
{
visitor.Visit(addressOf);
}
base.Visit(addressOf);
}
public override void TraverseChildren(IAddressOf addressOf)
{
base.TraverseChildren(addressOf);
ITypeReference targetType = addressOf.Expression.Type;
if (targetType == Dummy.TypeReference) {
IMethodReference/*?*/ method = addressOf.Expression.Definition as IMethodReference;
if (method != null) {
((AddressOf)addressOf).Type = new Immutable.FunctionPointerType(method.CallingConvention, method.ReturnValueIsByRef, method.Type,
method.ReturnValueIsModified ? method.ReturnValueCustomModifiers : null, method.Parameters, null, this.host.InternFactory);
return;
}
}
((AddressOf)addressOf).Type = Immutable.ManagedPointerType.GetManagedPointerType(targetType, this.host.InternFactory);
}
public override void TraverseChildren(IAddressOf addressOf)
{
base.TraverseChildren(addressOf);
ITypeReference targetType = addressOf.Expression.Type;
if (targetType is Dummy)
{
IMethodReference /*?*/ method = addressOf.Expression.Definition as IMethodReference;
if (method != null)
{
((AddressOf)addressOf).Type = new Immutable.FunctionPointerType(method.CallingConvention, method.ReturnValueIsByRef, method.Type,
method.ReturnValueIsModified ? method.ReturnValueCustomModifiers : null, method.Parameters, null, this.host.InternFactory);
return;
}
}
((AddressOf)addressOf).Type = Immutable.ManagedPointerType.GetManagedPointerType(targetType, this.host.InternFactory);
}
/// <summary>
///
/// </summary>
/// <param name="addressOf"></param>
public AddressOf(IAddressOf addressOf)
: base(addressOf)
{
this.expression = addressOf.Expression;
}
/// <summary>
/// Performs some computation with the given AddressOf expression.
/// </summary>
/// <param name="addressOf"></param>
public virtual void Visit(IAddressOf addressOf)
{
this.Visit((IExpression)addressOf);
}
public void Visit(IAddressOf addressOf)
{
throw new NotImplementedException();
}
/// <summary>
/// Traverses the AddressOf expression.
/// </summary>
public void Traverse(IAddressOf addressOf)
{
Contract.Requires(addressOf != null);
if (this.preorderVisitor != null) this.preorderVisitor.Visit(addressOf);
if (this.StopTraversal) return;
this.TraverseChildren(addressOf);
if (this.StopTraversal) return;
if (this.postorderVisitor != null) this.postorderVisitor.Visit(addressOf);
}
public void Visit(IAddressOf addressOf)
{
this.traverser.Traverse(addressOf);
}
/// <summary>
/// If the expression's type is a generic parameter (either method or type),
/// then this returns a "unboxed" expression, i.e., the value as a ref.
/// Otherwise it just translates the underlying expression and boxes it.
/// </summary>
public override void TraverseChildren(IAddressOf addressOf) {
var t = addressOf.Expression.Type;
var boogieT = this.sink.CciTypeToBoogie(t);
object container = addressOf.Expression.Definition;
IExpression/*?*/ instance = addressOf.Expression.Instance;
this.LoadAddressOf(container, instance);
if (t is IGenericParameterReference && boogieT == this.sink.Heap.UnionType) {
// then the expression will be represented by something of type Box
// but the address of it must be a ref, so do the conversion
var e = this.TranslatedExpressions.Pop();
Bpl.Variable a = this.sink.CreateFreshLocal(this.sink.Heap.RefType);
this.StmtTraverser.StmtBuilder.Add(new Bpl.CallCmd(Bpl.Token.NoToken, this.sink.Heap.BoxFromUnion.Name, new List<Bpl.Expr>(new Bpl.Expr[] {e}), new List<Bpl.IdentifierExpr>(new Bpl.IdentifierExpr[] {Bpl.Expr.Ident(a)})));
TranslatedExpressions.Push(Bpl.Expr.Ident(a));
}
return;
}
public override void TraverseChildren(IAddressOf addressOf)
{ MethodEnter(addressOf);
base.TraverseChildren(addressOf);
MethodExit(); }
public virtual void onASTElement(IAddressOf addressOf) { }
/// <summary>
/// Returns a shallow copy of the given AddressOf expression.
/// </summary>
/// <param name="addressOf"></param>
public AddressOf Copy(IAddressOf addressOf)
{
return new AddressOf(addressOf);
}
/// <summary>
/// Generates IL for the specified address of.
/// </summary>
/// <param name="addressOf">The address of.</param>
public override void TraverseChildren(IAddressOf addressOf)
{
object container = addressOf.Expression.Definition;
IExpression/*?*/ instance = addressOf.Expression.Instance;
this.LoadAddressOf(container, instance, addressOf.ObjectControlsMutability);
this.StackSize++;
}
public void Visit(IAddressOf addressOf)
{
this.result = this.rewriter.Rewrite(addressOf);
}
public override void Visit(IAddressOf addressOf)
{
if(Process(addressOf)){visitor.Visit(addressOf);}
base.Visit(addressOf);
}
private HLLocation ProcessAddressOfExpression(IAddressOf pExpression)
{
return(ProcessExpression(pExpression.Expression).AddressOf());
}
private HLLocation ProcessAddressOfExpression(IAddressOf pExpression)
{
return ProcessExpression(pExpression.Expression).AddressOf();
}
/// <summary>
/// Rewrites the given AddressOf expression.
/// </summary>
/// <param name="addressOf"></param>
public virtual IExpression Rewrite(IAddressOf addressOf)
{
var mutableAddressOf = addressOf as AddressOf;
if (mutableAddressOf == null) return addressOf;
this.RewriteChildren(mutableAddressOf);
return mutableAddressOf;
}
/// <summary>
///
/// </summary>
/// <param name="addressOf"></param>
public AddressOf(IAddressOf addressOf)
: base(addressOf) {
this.expression = addressOf.Expression;
this.objectControlsMutability = addressOf.ObjectControlsMutability;
}
public void Visit(IAddressOf addressOf)
{
this.result = this.copier.Copy(addressOf);
}
public override void Visit(IAddressOf addressOf)
{
allElements.Add(new InvokInfo(Traverser, "IAddressOf", addressOf));
}
public virtual void onASTElement(IAddressOf addressOf)
{
}
public override void Visit(IAddressOf addressOf)
{
NewLineAddIndent();
AppendElementType(addressOf);
base.Visit(addressOf);
}
/// <summary>
/// Performs some computation with the given AddressOf expression.
/// </summary>
/// <param name="addressOf"></param>
public virtual void Visit(IAddressOf addressOf)
{
}
/// <summary>
/// Rewrites the given AddressOf expression.
/// </summary>
/// <param name="addressOf"></param>
public virtual IExpression Rewrite(IAddressOf addressOf)
{
return addressOf;
}
/// <summary>
/// Traverses the children of the AddressOf expression.
/// </summary>
public virtual void TraverseChildren(IAddressOf addressOf)
{
Contract.Requires(addressOf != null);
this.TraverseChildren((IExpression)addressOf);
if (this.StopTraversal) return;
this.Traverse(addressOf.Expression);
}
/// <summary>
/// Returns a deep copy of the given AddressOf expression.
/// </summary>
/// <param name="addressOf"></param>
public AddressOf Copy(IAddressOf addressOf) {
Contract.Requires(addressOf != null);
Contract.Ensures(Contract.Result<AddressOf>() != null);
var mutableCopy = this.shallowCopier.Copy(addressOf);
this.CopyChildren((Expression)mutableCopy);
mutableCopy.Expression = this.Copy(mutableCopy.Expression);
return mutableCopy;
}
//^ ensures this.path.Count == old(this.path.Count);
/// <summary>
/// Traverses the given AddressOf expression.
/// </summary>
/// <param name="addressOf"></param>
public virtual void Visit(IAddressOf addressOf)
{
if (this.stopTraversal) return;
//^ int oldCount = this.path.Count;
this.path.Push(addressOf);
this.Visit(addressOf.Expression);
//^ assume this.path.Count == oldCount+1; //True because all of the virtual methods of this class promise not decrease this.path.Count.
this.path.Pop();
}
/// <summary>
/// Returns a shallow copy of the given AddressOf expression.
/// </summary>
/// <param name="addressOf"></param>
public AddressOf Copy(IAddressOf addressOf) {
Contract.Requires(addressOf != null);
Contract.Ensures(Contract.Result<AddressOf>() != null);
return new AddressOf(addressOf);
}
public void Visit(IAddressOf addressOf)
{
Contract.Requires(addressOf != null);
throw new NotImplementedException();
}
/// <summary>
/// Performs some computation with the given AddressOf expression.
/// </summary>
/// <param name="addressOf"></param>
public virtual void Visit(IAddressOf addressOf)
{
}
/// <summary>
///
/// </summary>
/// <param name="addressOf"></param>
/// <remarks>Since we are doing Copy-In,Copy-Out for function calls we can ignore it.
/// But will this work for the general case?</remarks>
public override void Visit(IAddressOf addressOf) {
Visit(addressOf.Expression);
}
/// <summary>
/// Visits the specified address of.
/// </summary>
/// <param name="addressOf">The address of.</param>
public override void Visit(IAddressOf addressOf)
{
AddressOf mutableAddressOf = new AddressOf(addressOf);
this.resultExpression = this.myCodeCopier.DeepCopy(mutableAddressOf);
}
public override void TraverseChildren(IAddressOf addressOf) {
this.sourceEmitterOutput.Write("&");
this.Traverse(addressOf.Expression);
}
/// <summary>
/// Returns a deep copy of the given AddressOf expression.
/// </summary>
/// <param name="addressOf"></param>
public AddressOf Copy(IAddressOf addressOf)
{
var mutableCopy = this.shallowCopier.Copy(addressOf);
this.CopyChildren((Expression)mutableCopy);
mutableCopy.Expression = this.Copy(mutableCopy.Expression);
return mutableCopy;
}
public override void TraverseChildren(IAddressOf addressOf)
{
MethodEnter(addressOf);
base.TraverseChildren(addressOf);
MethodExit();
}
/// <summary>
/// Visits the specified address of.
/// </summary>
/// <param name="addressOf">The address of.</param>
public override void Visit(IAddressOf addressOf)
{
AddressOf mutableAddressOf = addressOf as AddressOf;
if (alwaysMakeACopy || mutableAddressOf == null) mutableAddressOf = new AddressOf(addressOf);
this.resultExpression = this.myCodeMutator.Visit(mutableAddressOf);
}
