private HLLocation ProcessTargetExpression(ITargetExpression pExpression) { if (pExpression.Definition is ILocalDefinition) { return(HLLocalLocation.Create(HLDomain.GetLocal(pExpression.Definition as ILocalDefinition))); } else if (pExpression.Definition is IParameterDefinition) { HLParameter parameter = HLDomain.GetParameter(pExpression.Definition as IParameterDefinition); parameter.RequiresAddressing = true; return(HLParameterLocation.Create(parameter)); } else if (pExpression.Definition is IFieldDefinition || pExpression.Definition is IFieldReference) { IFieldDefinition definition = pExpression.Definition is IFieldDefinition ? (IFieldDefinition)pExpression.Definition : ((IFieldReference)pExpression.Definition).ResolvedField; HLType typeFieldContainer = HLDomain.GetOrCreateType(definition.Container); HLField field = HLDomain.GetField(definition); if (field.IsStatic) { return(HLStaticFieldLocation.Create(field)); } HLLocation instance = ProcessExpression(pExpression.Instance); return(HLFieldLocation.Create(instance, field)); } else if (pExpression.Definition is IAddressDereference) { IAddressDereference definition = pExpression.Definition as IAddressDereference; HLLocation locationAddress = ProcessExpression(definition.Address); return(HLIndirectAddressLocation.Create(locationAddress, HLDomain.GetOrCreateType(pExpression.Type))); } throw new NotSupportedException(); }
public override void Visit(ITargetExpression targetExpression) { if (Process(targetExpression)) { visitor.Visit(targetExpression); } base.Visit(targetExpression); }
public override void TraverseChildren(ITargetExpression targetExpression) { base.TraverseChildren(targetExpression); ITypeReference type = Dummy.TypeReference; ILocalDefinition /*?*/ local = targetExpression.Definition as ILocalDefinition; if (local != null) { if (local.IsReference) { if (local.IsPinned) { type = Immutable.PointerType.GetPointerType(local.Type, this.host.InternFactory); } else { type = Immutable.ManagedPointerType.GetManagedPointerType(local.Type, this.host.InternFactory); } } else { type = local.Type; } } else { IParameterDefinition /*?*/ parameter = targetExpression.Definition as IParameterDefinition; if (parameter != null) { type = parameter.Type; } else { IFieldReference /*?*/ field = targetExpression.Definition as IFieldReference; if (field != null) { type = field.Type; } else { IPropertyDefinition /*?*/ property = targetExpression.Definition as IPropertyDefinition; if (property != null) { type = property.Type; } else { IExpression /*?*/ expression = targetExpression.Definition as IExpression; if (expression != null) { type = expression.Type; } } } } } ((TargetExpression)targetExpression).Type = type; }
public override void TraverseChildren(ITargetExpression targetExpression) { base.TraverseChildren(targetExpression); var local = targetExpression.Definition as ILocalDefinition; if (local != null && this.firstReferenceToLocal[local] == null) { this.firstReferenceToLocal[local] = targetExpression; } }
public override void TraverseChildren(ITargetExpression targetExpression) { base.TraverseChildren(targetExpression); var local = targetExpression.Definition as ILocalDefinition; if (local == null) { return; } this.numberOfAssignmentsToLocal[local]++; }
public override ITargetExpression Rewrite(ITargetExpression targetExpression) { var result = base.Rewrite(targetExpression); var field = targetExpression.Definition as IFieldReference; if (field == null) { var capturedLocal = targetExpression.Definition as CapturedLocalDefinition; if (capturedLocal != null) { field = capturedLocal.capturingField; } } if (field != null) { var locOrPar = this.closureFieldToLocalOrParameterMap.Find(field.InternedKey); if (locOrPar != null) { object definition = locOrPar; var boundExpression = locOrPar as IBoundExpression; if (boundExpression != null) { definition = boundExpression.Definition; } Contract.Assume(definition is ILocalDefinition || definition is IParameterDefinition || definition is IFieldReference || definition is IArrayIndexer || definition is IAddressDereference || definition is IPropertyDefinition); if (definition is LocalDefinition) { this.numberOfAssignmentsToLocal[definition]++; } return(new TargetExpression() { Definition = definition, Type = field.Type }); } } return(result); }
public virtual void onASTElement(ITargetExpression targetExpression) { }
public override void TraverseChildren(ITargetExpression targetExpression) { IArrayIndexer/*?*/ indexer = targetExpression.Definition as IArrayIndexer; if (indexer != null) { this.Traverse(indexer); return; } IAddressDereference/*?*/ deref = targetExpression.Definition as IAddressDereference; if (deref != null) { IAddressOf/*?*/ addressOf = deref.Address as IAddressOf; if (addressOf != null) { this.Traverse(addressOf.Expression); return; } if (targetExpression.Instance != null) { this.Traverse(targetExpression.Instance); this.sourceEmitterOutput.Write("->"); } else if (deref.Address.Type is IPointerTypeReference || deref.Address.Type.TypeCode == PrimitiveTypeCode.IntPtr) this.sourceEmitterOutput.Write("*"); this.Traverse(deref.Address); return; } else { if (targetExpression.Instance != null) { IAddressOf/*?*/ addressOf = targetExpression.Instance as IAddressOf; if (addressOf != null) this.Traverse(addressOf.Expression); else this.Traverse(targetExpression.Instance); this.sourceEmitterOutput.Write("."); } } ILocalDefinition/*?*/ local = targetExpression.Definition as ILocalDefinition; if (local != null) this.PrintLocalName(local); else { IFieldReference/*?*/ field = targetExpression.Definition as IFieldReference; if (field != null) { if (field.IsStatic) { this.PrintTypeReference(field.ContainingType); this.sourceEmitterOutput.Write("."); } this.sourceEmitterOutput.Write(field.Name.Value); } else { INamedEntity/*?*/ ne = targetExpression.Definition as INamedEntity; if (ne != null) this.sourceEmitterOutput.Write(ne.Name.Value); } } }
/// <summary> /// /// </summary> /// <param name="assignment"></param> public Assignment(IAssignment assignment) : base(assignment) { this.source = assignment.Source; this.target = assignment.Target; }
/// <summary> /// /// </summary> /// <param name="targetExpression"></param> public TargetExpression(ITargetExpression targetExpression) : base(targetExpression) { this.definition = targetExpression.Definition; this.instance = targetExpression.Instance; if (targetExpression.IsUnaligned) this.alignment = targetExpression.Alignment; else this.alignment = 0; this.isVolatile = targetExpression.IsVolatile; }
public override void Visit(ITargetExpression targetExpression) { allElements.Add(new InvokInfo(Traverser, "ITargetExpression", targetExpression)); }
/// <summary> /// Performs some computation with the given target expression. /// </summary> /// <param name="targetExpression"></param> public virtual void Visit(ITargetExpression targetExpression) { }
public override void Visit(ITargetExpression target) { HandleComposite(target, target.Instance); }
/// <summary> /// Traverses the children of the target expression. /// </summary> public virtual void TraverseChildren(ITargetExpression targetExpression) { Contract.Requires(targetExpression != null); this.TraverseChildren((IExpression)targetExpression); if (this.StopTraversal) return; var local = targetExpression.Definition as ILocalDefinition; if (local != null) this.Traverse(local); else { var parameter = targetExpression.Definition as IParameterDefinition; if (parameter != null) this.Traverse(parameter); else { var fieldReference = targetExpression.Definition as IFieldReference; if (fieldReference != null) this.Traverse(fieldReference); else { var arrayIndexer = targetExpression.Definition as IArrayIndexer; if (arrayIndexer != null) { this.Traverse(arrayIndexer); return; //do not visit the instance again } else { var addressDereference = targetExpression.Definition as IAddressDereference; if (addressDereference != null) this.Traverse(addressDereference); else { var propertyDefinition = targetExpression.Definition as IPropertyDefinition; if (propertyDefinition != null) this.Traverse(propertyDefinition); else this.Traverse((IThisReference)targetExpression.Definition); } } } } } if (this.StopTraversal) return; if (targetExpression.Instance != null) this.Traverse(targetExpression.Instance); }
/// <summary> /// Returns a shallow copy of the given target expression. /// </summary> /// <param name="targetExpression"></param> public TargetExpression Copy(ITargetExpression targetExpression) { Contract.Requires(targetExpression != null); Contract.Ensures(Contract.Result<TargetExpression>() != null); return new TargetExpression(targetExpression); }
public override void TraverseChildren(ITargetExpression targetExpression) { base.TraverseChildren(targetExpression); ITypeReference type = Dummy.TypeReference; ILocalDefinition/*?*/ local = targetExpression.Definition as ILocalDefinition; if (local != null) { if (local.IsReference) { if (local.IsPinned) type = Immutable.PointerType.GetPointerType(local.Type, this.host.InternFactory); else type = Immutable.ManagedPointerType.GetManagedPointerType(local.Type, this.host.InternFactory); } else type = local.Type; } else { IParameterDefinition/*?*/ parameter = targetExpression.Definition as IParameterDefinition; if (parameter != null) type = parameter.Type; else { IFieldReference/*?*/ field = targetExpression.Definition as IFieldReference; if (field != null) type = field.Type; else { IPropertyDefinition/*?*/ property = targetExpression.Definition as IPropertyDefinition; if (property != null) type = property.Type; else { IExpression/*?*/ expression = targetExpression.Definition as IExpression; if (expression != null) type = expression.Type; } } } } ((TargetExpression)targetExpression).Type = type; }
public override void TraverseChildren(ITargetExpression targetExpression) { if (targetExpression.Definition == this.local) { this.localCanBeReplaced = false; this.StopTraversal = true; return; } base.TraverseChildren(targetExpression); }
/// <summary> /// Rewrites the given target expression. /// </summary> /// <param name="targetExpression"></param> public virtual ITargetExpression Rewrite(ITargetExpression targetExpression) { return targetExpression; }
/*?*/ private ILocalDefinition TargetExpressionAsLocal(ITargetExpression targetExpression) { if (targetExpression.Instance != null) return null; return targetExpression.Definition as ILocalDefinition; }
public override void TraverseChildren(ITargetExpression targetExpression) { base.TraverseChildren(targetExpression); this.UpdateDeclaringBlock(targetExpression.Definition as IFieldReference); }
public override void TraverseChildren(ITargetExpression targetExpression) { MethodEnter(targetExpression); base.TraverseChildren(targetExpression); MethodExit(); }
/// <summary> /// Performs some computation with the given target expression. /// </summary> /// <param name="targetExpression"></param> public virtual void Visit(ITargetExpression targetExpression) { this.Visit((IExpression)targetExpression); }
//^ ensures this.path.Count == old(this.path.Count); /// <summary> /// Traverses the given target expression. /// </summary> /// <param name="targetExpression"></param> public virtual void Visit(ITargetExpression targetExpression) { if (this.stopTraversal) return; //^ int oldCount = this.path.Count; object def = targetExpression.Definition; var loc = def as ILocalDefinition; if (loc != null) this.VisitReference(loc); else { var par = def as IParameterDefinition; if (par != null) this.VisitReference(par); else { var fieldReference = def as IFieldReference; if (fieldReference != null) this.Visit(fieldReference); else { var indexer = def as IArrayIndexer; if (indexer != null) { this.Visit(indexer); return; //do not visit the instance again } else { var adr = def as IAddressDereference; if (adr != null) this.Visit(adr); else { var meth = def as IMethodReference; if (meth != null) this.Visit(meth); else { var propertyReference = (IPropertyDefinition)def; this.VisitReference(propertyReference); } } } } } } if (targetExpression.Instance != null) this.Visit(targetExpression.Instance); //^ assume this.path.Count == oldCount; //True because all of the virtual methods of this class promise not decrease this.path.Count. }
public void Visit(ITargetExpression targetExpression) { throw new NotImplementedException(); }
/// <summary> /// Traverses the target expression. /// </summary> public void Traverse(ITargetExpression targetExpression) { Contract.Requires(targetExpression != null); if (this.preorderVisitor != null) this.preorderVisitor.Visit(targetExpression); if (this.StopTraversal) return; this.TraverseChildren(targetExpression); if (this.StopTraversal) return; if (this.postorderVisitor != null) this.postorderVisitor.Visit(targetExpression); }
/// <summary> /// /// </summary> public OutArgument() { this.expression = CodeDummy.TargetExpression; }
public void Visit(ITargetExpression targetExpression) { this.traverser.Traverse(targetExpression); }
/// <summary> /// Visits the specified target expression. /// </summary> /// <param name="targetExpression">The target expression.</param> public override void Visit(ITargetExpression targetExpression) { TargetExpression mutableTargetExpression = new TargetExpression(targetExpression); this.resultExpression = this.myCodeCopier.DeepCopy(mutableTargetExpression); }
public void Visit(ITargetExpression targetExpression) { Contract.Requires(targetExpression != null); throw new NotImplementedException(); }
/// <summary> /// Returns a deep copy of the given target expression. /// </summary> /// <param name="targetExpression"></param> public TargetExpression Copy(ITargetExpression targetExpression) { var mutableCopy = this.shallowCopier.Copy(targetExpression); this.CopyChildren((Expression)mutableCopy); if (mutableCopy.Instance != null) { mutableCopy.Instance = this.Copy(mutableCopy.Instance); } var local = mutableCopy.Definition as ILocalDefinition; if (local != null) mutableCopy.Definition = this.GetExistingCopyIfInsideCone(local); else { var parameter = mutableCopy.Definition as IParameterDefinition; if (parameter != null) mutableCopy.Definition = this.GetExistingCopyIfInsideCone(parameter); else { var fieldReference = mutableCopy.Definition as IFieldReference; if (fieldReference != null) mutableCopy.Definition = this.Copy(fieldReference); else { var arrayIndexer = mutableCopy.Definition as IArrayIndexer; if (arrayIndexer != null) mutableCopy.Definition = this.Copy(arrayIndexer); else { var addressDereference = mutableCopy.Definition as IAddressDereference; if (addressDereference != null) mutableCopy.Definition = this.Copy(addressDereference); else { var propertyDefinition = (IPropertyDefinition)mutableCopy.Definition; mutableCopy.Definition = this.GetExistingCopyIfInsideCone(propertyDefinition); } } } } } return mutableCopy; }
public override void Visit(ITargetExpression targetExpression) { #region ArrayIndexer IArrayIndexer/*?*/ indexer = targetExpression.Definition as IArrayIndexer; if (indexer != null) { this.Visit(indexer); return; } #endregion #region AddressDereference IAddressDereference/*?*/ deref = targetExpression.Definition as IAddressDereference; if (deref != null) { IAddressOf/*?*/ addressOf = deref.Address as IAddressOf; if (addressOf != null) { this.Visit(addressOf.Expression); return; } IConversion/*?*/ conversion = deref.Address as IConversion; if (conversion != null) { IBoundExpression be = conversion.ValueToConvert as IBoundExpression; if (be != null) { IParameterDefinition pd = be.Definition as IParameterDefinition; if (pd != null) { var pv = this.sink.FindParameterVariable(pd); TranslatedExpressions.Push(Bpl.Expr.Ident(pv)); return; } } } if (targetExpression.Instance != null) { // TODO throw new NotImplementedException("targetExpr->AddrDeRef->InstanceNull"); } else if (deref.Address.Type is IPointerTypeReference) throw new NotImplementedException("targetExpr->AddrDeRef->Pointertype"); this.Visit(deref.Address); return; } #endregion #region LocalDefinition ILocalDefinition/*?*/ local = targetExpression.Definition as ILocalDefinition; if (local != null) { TranslatedExpressions.Push(Bpl.Expr.Ident(this.sink.FindOrCreateLocalVariable(local))); return; } #endregion #region ParameterDefenition IParameterDefinition param = targetExpression.Definition as IParameterDefinition; if (param != null) { TranslatedExpressions.Push(Bpl.Expr.Ident(this.sink.FindParameterVariable(param))); return; } #endregion #region FieldReference IFieldReference field = targetExpression.Definition as IFieldReference; if (field != null) { ProcessFieldVariable(field, targetExpression.Instance, false); return; } #endregion #region PropertyDefiniton IPropertyDefinition prop = targetExpression.Definition as IPropertyDefinition; if (prop != null) { throw new NotImplementedException("targetExpr->Property"); } #endregion }
/// <summary> /// Returns a shallow copy of the given target expression. /// </summary> /// <param name="targetExpression"></param> public TargetExpression Copy(ITargetExpression targetExpression) { return new TargetExpression(targetExpression); }
/// <summary> /// /// </summary> /// <param name="outArgument"></param> public OutArgument(IOutArgument outArgument) : base(outArgument) { this.expression = outArgument.Expression; }
public void Visit(ITargetExpression targetExpression) { this.result = this.copier.Copy(targetExpression); }
/// <summary> /// Initializes a new instance of the <see cref="Assignment"/> class. /// </summary> public Assignment() { this.source = CodeDummy.Expression; this.target = CodeDummy.TargetExpression; }
private void VisitAssignment(ITargetExpression target, IExpression source, SourceTraverser sourceTraverser, bool treatAsStatement, bool pushTargetRValue, bool resultIsInitialTargetRValue) { Contract.Requires(target != null); Contract.Requires(source != null); Contract.Requires(sourceTraverser != null); Contract.Requires(!resultIsInitialTargetRValue || pushTargetRValue); Contract.Requires(!pushTargetRValue || source is IBinaryOperation); var tok = source.Token(); var typ = source.Type; var structCopy = TranslationHelper.IsStruct(typ) && !(source is IDefaultValue); // then a struct value of type S is being assigned: "lhs := s" // model this as the statement "call lhs := S..#copy_ctor(s)" that does the bit-wise copying Bpl.DeclWithFormals proc = null; if (structCopy) { proc = this.sink.FindOrCreateProcedureForStructCopy(typ); } object container = target.Definition; Top: ILocalDefinition/*?*/ local = container as ILocalDefinition; if (local != null) { if (source is IDefaultValue && !local.Type.ResolvedType.IsReferenceType) { // this.LoadAddressOf(local, null); // this.generator.Emit(OperationCode.Initobj, local.Type); // if (!treatAsStatement) this.LoadLocal(local); } else { Bpl.IdentifierExpr temp = null; var bplLocal = Bpl.Expr.Ident(this.sink.FindOrCreateLocalVariable(local)); if (pushTargetRValue) { this.TranslatedExpressions.Push(bplLocal); if (!treatAsStatement && resultIsInitialTargetRValue) { var loc = this.sink.CreateFreshLocal(source.Type); temp = Bpl.Expr.Ident(loc); var e3 = this.TranslatedExpressions.Pop(); var cmd3 = Bpl.Cmd.SimpleAssign(tok, temp, e3); this.StmtTraverser.StmtBuilder.Add(cmd3); this.TranslatedExpressions.Push(temp); } } sourceTraverser(source); var e = this.TranslatedExpressions.Pop(); if (temp != null) this.TranslatedExpressions.Push(temp); Bpl.Cmd cmd; if (structCopy) { cmd = new Bpl.CallCmd(tok, proc.Name, new List<Bpl.Expr> { e, }, new List<Bpl.IdentifierExpr> { bplLocal, }); } else { cmd = Bpl.Cmd.SimpleAssign(tok, bplLocal, e); } StmtTraverser.StmtBuilder.Add(cmd); if (!treatAsStatement && !resultIsInitialTargetRValue) { this.TranslatedExpressions.Push(bplLocal); } } return; } IParameterDefinition/*?*/ parameter = container as IParameterDefinition; if (parameter != null) { if (source is IDefaultValue && !parameter.Type.ResolvedType.IsReferenceType) { //this.LoadAddressOf(parameter, null); //this.generator.Emit(OperationCode.Initobj, parameter.Type); //if (!treatAsStatement) this.LoadParameter(parameter); } else { Bpl.IdentifierExpr temp = null; if (pushTargetRValue) { this.LoadParameter(parameter); if (!treatAsStatement && resultIsInitialTargetRValue) { var loc = this.sink.CreateFreshLocal(source.Type); temp = Bpl.Expr.Ident(loc); var e3 = this.TranslatedExpressions.Pop(); var cmd3 = Bpl.Cmd.SimpleAssign(tok, temp, e3); this.StmtTraverser.StmtBuilder.Add(cmd3); this.TranslatedExpressions.Push(temp); } } sourceTraverser(source); var e = this.TranslatedExpressions.Pop(); if (temp != null) this.TranslatedExpressions.Push(temp); var bplParam = Bpl.Expr.Ident(this.sink.FindParameterVariable(parameter, this.contractContext)); Bpl.Cmd cmd; if (structCopy) { cmd = new Bpl.CallCmd(tok, proc.Name, new List<Bpl.Expr> { e, bplParam, }, new List<Bpl.IdentifierExpr>()); } else { cmd = Bpl.Cmd.SimpleAssign(tok, bplParam, e); } StmtTraverser.StmtBuilder.Add(cmd); if (!treatAsStatement && !resultIsInitialTargetRValue) { this.LoadParameter(parameter); } } return; } IFieldReference/*?*/ field = container as IFieldReference; if (field != null) { var f = Bpl.Expr.Ident(this.sink.FindOrCreateFieldVariable(field)); var boogieTypeOfField = sink.CciTypeToBoogie(field.Type); if (source is IDefaultValue && !field.Type.ResolvedType.IsReferenceType) { //this.LoadAddressOf(field, target.Instance); //if (!treatAsStatement) { // this.generator.Emit(OperationCode.Dup); // this.StackSize++; //} //this.generator.Emit(OperationCode.Initobj, field.Type); //if (!treatAsStatement) // this.generator.Emit(OperationCode.Ldobj, field.Type); //else // this.StackSize--; } else { Bpl.Expr x = null; Bpl.IdentifierExpr temp = null; if (pushTargetRValue) { if (target.Instance != null) { this.Traverse(target.Instance); x = this.TranslatedExpressions.Pop(); AssertOrAssumeNonNull(tok, x); var e2 = this.sink.Heap.ReadHeap(x, f, TranslationHelper.IsStruct(field.ContainingType) ? AccessType.Struct : AccessType.Heap, boogieTypeOfField); this.TranslatedExpressions.Push(e2); } else { TranslatedExpressions.Push(f); } if (!treatAsStatement && resultIsInitialTargetRValue) { var loc = this.sink.CreateFreshLocal(source.Type); temp = Bpl.Expr.Ident(loc); var e3 = this.TranslatedExpressions.Pop(); var cmd = Bpl.Cmd.SimpleAssign(tok, temp, e3); this.StmtTraverser.StmtBuilder.Add(cmd); this.TranslatedExpressions.Push(temp); } } sourceTraverser(source); if (!treatAsStatement && !resultIsInitialTargetRValue) { var loc = this.sink.CreateFreshLocal(source.Type); temp = Bpl.Expr.Ident(loc); var e3 = this.TranslatedExpressions.Pop(); var cmd = Bpl.Cmd.SimpleAssign(tok, temp, e3); this.StmtTraverser.StmtBuilder.Add(cmd); this.TranslatedExpressions.Push(temp); } var e = this.TranslatedExpressions.Pop(); if (temp != null) this.TranslatedExpressions.Push(temp); if (target.Instance == null) { // static fields are not kept in the heap StmtTraverser.StmtBuilder.Add(Bpl.Cmd.SimpleAssign(tok, f, e)); } else { this.sink.Heap.WriteHeap(tok, x, f, e, field.ResolvedField.ContainingType.ResolvedType.IsStruct ? AccessType.Struct : AccessType.Heap, boogieTypeOfField, StmtTraverser.StmtBuilder); } } return; } VisitArrayIndexer: IArrayIndexer/*?*/ arrayIndexer = container as IArrayIndexer; if (arrayIndexer != null) { Contract.Assume(arrayIndexer.Indices.Count() == 1); // BUG: deal with multi-dimensional arrays if (source is IDefaultValue && !arrayIndexer.Type.ResolvedType.IsReferenceType) { // this.LoadAddressOf(arrayIndexer, target.Instance); // if (!treatAsStatement) { // this.generator.Emit(OperationCode.Dup); // this.StackSize++; // } // this.generator.Emit(OperationCode.Initobj, arrayIndexer.Type); // if (!treatAsStatement) // this.generator.Emit(OperationCode.Ldobj, arrayIndexer.Type); // else // this.StackSize--; } else { Bpl.IdentifierExpr/*?*/ temp = null; this.Traverse(arrayIndexer.IndexedObject); var arrayExpr = this.TranslatedExpressions.Peek(); this.Traverse(arrayIndexer.Indices); var indexExpr = this.TranslatedExpressions.Peek(); if (pushTargetRValue) { AssertOrAssumeNonNull(tok, arrayExpr); var e2 = this.sink.Heap.ReadHeap(arrayExpr, indexExpr, AccessType.Array, this.sink.CciTypeToBoogie(arrayIndexer.Type)); this.TranslatedExpressions.Push(e2); if (!treatAsStatement && resultIsInitialTargetRValue) { var loc = this.sink.CreateFreshLocal(source.Type); temp = Bpl.Expr.Ident(loc); var e3 = this.TranslatedExpressions.Pop(); var cmd = Bpl.Cmd.SimpleAssign(tok, temp, e3); this.StmtTraverser.StmtBuilder.Add(cmd); this.TranslatedExpressions.Push(temp); } } sourceTraverser(source); var e = this.TranslatedExpressions.Pop(); var indices_prime = this.TranslatedExpressions.Pop(); var x = this.TranslatedExpressions.Pop(); sink.Heap.WriteHeap(Bpl.Token.NoToken, x, indices_prime, e, AccessType.Array, sink.CciTypeToBoogie(arrayIndexer.Type), StmtTraverser.StmtBuilder); if (!treatAsStatement && !resultIsInitialTargetRValue) { AssertOrAssumeNonNull(tok, arrayExpr); var e2 = this.sink.Heap.ReadHeap(arrayExpr, indexExpr, AccessType.Array, this.sink.CciTypeToBoogie(arrayIndexer.Type)); this.TranslatedExpressions.Push(e2); } else { if (temp != null) this.TranslatedExpressions.Push(temp); } } return; } IAddressDereference/*?*/ addressDereference = container as IAddressDereference; if (addressDereference != null) { var addrOf = addressDereference.Address as IAddressOf; if (addrOf != null) { var arrayIndexer2 = addrOf.Expression.Definition as IArrayIndexer; if (arrayIndexer2 != null) { container = arrayIndexer2; goto VisitArrayIndexer; } } var be = addressDereference.Address as IBoundExpression; if (be != null) { container = be.Definition; goto Top; } this.Traverse(addressDereference.Address); if (source is IDefaultValue && !addressDereference.Type.ResolvedType.IsReferenceType) { //if (!treatAsStatement) { // this.generator.Emit(OperationCode.Dup); // this.StackSize++; //} //this.generator.Emit(OperationCode.Initobj, addressDereference.Type); //if (!treatAsStatement) // this.generator.Emit(OperationCode.Ldobj, addressDereference.Type); //else // this.StackSize--; } else if (source is IAddressDereference) { //if (!treatAsStatement) { // this.generator.Emit(OperationCode.Dup); // this.StackSize++; //} //this.Traverse(((IAddressDereference)source).Address); //this.generator.Emit(OperationCode.Cpobj, addressDereference.Type); //this.StackSize -= 2; //if (!treatAsStatement) // this.generator.Emit(OperationCode.Ldobj, addressDereference.Type); } else { Bpl.IdentifierExpr/*?*/ temp = null; if (pushTargetRValue) { this.TranslatedExpressions.Push(this.TranslatedExpressions.Peek()); if (!treatAsStatement && resultIsInitialTargetRValue) { this.TranslatedExpressions.Push(this.TranslatedExpressions.Peek()); var loc = this.sink.CreateFreshLocal(source.Type); temp = Bpl.Expr.Ident(loc); var e3 = this.TranslatedExpressions.Pop(); var cmd = Bpl.Cmd.SimpleAssign(tok, temp, e3); this.StmtTraverser.StmtBuilder.Add(cmd); this.TranslatedExpressions.Push(temp); } } sourceTraverser(source); if (!treatAsStatement && !resultIsInitialTargetRValue) { this.TranslatedExpressions.Push(this.TranslatedExpressions.Peek()); var loc = this.sink.CreateFreshLocal(source.Type); temp = Bpl.Expr.Ident(loc); var e3 = this.TranslatedExpressions.Pop(); var cmd = Bpl.Cmd.SimpleAssign(tok, temp, e3); this.StmtTraverser.StmtBuilder.Add(cmd); this.TranslatedExpressions.Push(temp); } //this.VisitAssignmentTo(addressDereference); if (temp != null) this.TranslatedExpressions.Push(temp); } return; } IPropertyDefinition/*?*/ propertyDefinition = container as IPropertyDefinition; if (propertyDefinition != null) { Contract.Assume(propertyDefinition.Getter != null && propertyDefinition.Setter != null); if (!propertyDefinition.IsStatic) { this.Traverse(target.Instance); } Bpl.IdentifierExpr temp = null; var token = Bpl.Token.NoToken; if (pushTargetRValue) { List<Bpl.Expr> inexpr; List<Bpl.IdentifierExpr> outvars; Bpl.IdentifierExpr thisExpr; Dictionary<Bpl.IdentifierExpr, Tuple<Bpl.IdentifierExpr, bool>> toBoxed; var proc2 = TranslateArgumentsAndReturnProcedure(token, propertyDefinition.Getter, propertyDefinition.Getter.ResolvedMethod, target.Instance, Enumerable<IExpression>.Empty, out inexpr, out outvars, out thisExpr, out toBoxed); EmitLineDirective(token); this.StmtTraverser.StmtBuilder.Add(new Bpl.CallCmd(token, proc2.Name, inexpr, outvars)); if (!treatAsStatement && resultIsInitialTargetRValue) { //var //this.generator.Emit(OperationCode.Dup); //this.StackSize++; //temp = new TemporaryVariable(source.Type, this.method); //this.VisitAssignmentTo(temp); } } sourceTraverser(source); if (!treatAsStatement && !resultIsInitialTargetRValue) { var e3 = this.TranslatedExpressions.Pop(); var loc = this.sink.CreateFreshLocal(source.Type); temp = Bpl.Expr.Ident(loc); var cmd = Bpl.Cmd.SimpleAssign(tok, temp, e3); this.StmtTraverser.StmtBuilder.Add(cmd); this.TranslatedExpressions.Push(temp); } var setterArgs = new List<Bpl.Expr>(); var setterArg = this.TranslatedExpressions.Pop(); if (!propertyDefinition.IsStatic) setterArgs.Add(this.TranslatedExpressions.Pop()); setterArgs.Add(setterArg); var setterProc = this.sink.FindOrCreateProcedure(propertyDefinition.Setter.ResolvedMethod); EmitLineDirective(token); this.StmtTraverser.StmtBuilder.Add(new Bpl.CallCmd(token, setterProc.Decl.Name, setterArgs, new List<Bpl.IdentifierExpr>())); if (temp != null) this.TranslatedExpressions.Push(temp); return; } Contract.Assume(false); }
public override void TraverseChildren(ITargetExpression targetExpression) { this.LookForCapturedDefinition(targetExpression.Definition); base.TraverseChildren(targetExpression); }
public override void TraverseChildren(ITargetExpression targetExpression) { Contract.Assume(false, "The expression containing this as a subexpression should never allow a call to this routine."); }
public override ITargetExpression Rewrite(ITargetExpression targetExpression) { Contract.Assume(false, "The expression containing this as a subexpression should never allow a call to this routine."); return null; }
public override void Visit(ITargetExpression bounded) { HandleBundle(bounded, bounded.Definition, bounded.Instance); }