public override void Visit(IAssumeStatement assumeStatement) { if (Process(assumeStatement)) { visitor.Visit(assumeStatement); } base.Visit(assumeStatement); }
public override void TraverseChildren(IAssumeStatement assumeStatement) { this.PrintToken(CSharpToken.Indent); sourceEmitterOutput.Write("CodeContract.Assume("); this.Traverse(assumeStatement.Condition); if (assumeStatement.Description != null) { sourceEmitterOutput.Write(","); this.Traverse(assumeStatement.Description); } sourceEmitterOutput.WriteLine(");"); }
public override void TraverseChildren(IAssumeStatement assumeStatement) { this.PrintToken(VBToken.Indent); sourceEmitterOutput.Write("CodeContract.Assume("); this.Traverse(assumeStatement.Condition); if (assumeStatement.Description != null) { sourceEmitterOutput.Write(","); this.Traverse(assumeStatement.Description); } sourceEmitterOutput.WriteLine(");"); }
public override void TraverseChildren(IAssumeStatement assumeStatement) { Bpl.Expr conditionExpr = ExpressionFor(assumeStatement.Condition); Bpl.Type conditionType = this.sink.CciTypeToBoogie(assumeStatement.Condition.Type); if (conditionType == this.sink.Heap.RefType) { conditionExpr = Bpl.Expr.Binary(Bpl.BinaryOperator.Opcode.Neq, conditionExpr, Bpl.Expr.Ident(this.sink.Heap.NullRef)); } else if (conditionType == Bpl.Type.Int) { conditionExpr = Bpl.Expr.Binary(Bpl.BinaryOperator.Opcode.Neq, conditionExpr, Bpl.Expr.Literal(0)); } else { System.Diagnostics.Debug.Assert(conditionType == Bpl.Type.Bool); } StmtBuilder.Add(new Bpl.AssumeCmd(assumeStatement.Token(), conditionExpr)); }
/// <summary> /// Converts the assume statement into a call to Contract.Assume /// </summary> public override IStatement Rewrite(IAssumeStatement assumeStatement) { var methodCall = new MethodCall { Arguments = new List <IExpression> { Rewrite(assumeStatement.Condition), assumeStatement.Description ?? new CompileTimeConstant { Type = host.PlatformType.SystemString, Value = "Assume" } }, IsStaticCall = true, MethodToCall = AssumeReference, Type = systemVoid, Locations = new List <ILocation>(assumeStatement.Locations) }; var es = new ExpressionStatement { Expression = methodCall }; return(es); }
public void Visit(IAssumeStatement assumeStatement) { this.result = this.copier.Copy(assumeStatement); }
public override void Visit(IAssumeStatement assumeStatement) { if(Process(assumeStatement)){visitor.Visit(assumeStatement);} base.Visit(assumeStatement); }
/// <summary> /// Returns a shallow copy of the given assume statement. /// </summary> /// <param name="assumeStatement"></param> public AssumeStatement Copy(IAssumeStatement assumeStatement) { return new AssumeStatement(assumeStatement); }
/// <summary> /// Performs some computation with the given assume statement. /// </summary> /// <param name="assumeStatement"></param> public virtual void Visit(IAssumeStatement assumeStatement) { this.Visit((IStatement)assumeStatement); }
public void Visit(IAssumeStatement assumeStatement) { Contract.Requires(assumeStatement != null); throw new NotImplementedException(); }
/// <summary> /// Performs some computation with the given assume statement. /// </summary> /// <param name="assumeStatement"></param> public virtual void Visit(IAssumeStatement assumeStatement) { }
/// <summary> /// Traverses the children of the assume statement. /// </summary> public virtual void TraverseChildren(IAssumeStatement assumeStatement) { Contract.Requires(assumeStatement != null); this.TraverseChildren((IStatement)assumeStatement); if (this.StopTraversal) return; this.Traverse(assumeStatement.Condition); if (this.StopTraversal) return; if (assumeStatement.Description != null) this.Traverse(assumeStatement.Description); }
/// <summary> /// Returns a shallow copy of the given assume statement. /// </summary> /// <param name="assumeStatement"></param> public AssumeStatement Copy(IAssumeStatement assumeStatement) { Contract.Requires(assumeStatement != null); Contract.Ensures(Contract.Result<AssumeStatement>() != null); return new AssumeStatement(assumeStatement); }
/// <summary> /// Converts the assume statement into a call to Contract.Assume /// </summary> public override IStatement Rewrite(IAssumeStatement assumeStatement) { var methodCall = new MethodCall() { Arguments = new List<IExpression> { assumeStatement.Condition, }, IsStaticCall = true, MethodToCall = this.contractProvider.ContractMethods.Assume, Type = systemVoid, Locations = new List<ILocation>(assumeStatement.Locations), }; ExpressionStatement es = new ExpressionStatement() { Expression = methodCall }; return es; }
/// <summary> /// Returns a deep copy of the given assume statement. /// </summary> /// <param name="assumeStatement"></param> public AssumeStatement Copy(IAssumeStatement assumeStatement) { Contract.Requires(assumeStatement != null); Contract.Ensures(Contract.Result<AssumeStatement>() != null); var mutableCopy = this.shallowCopier.Copy(assumeStatement); mutableCopy.Condition = this.Copy(mutableCopy.Condition); if (mutableCopy.Description != null) mutableCopy.Description = this.Copy(mutableCopy.Description); return mutableCopy; }
/// <summary> /// Rewrites the given assume statement. /// </summary> /// <param name="assumeStatement"></param> public virtual IStatement Rewrite(IAssumeStatement assumeStatement) { return assumeStatement; }
public override void Visit(IAssumeStatement assumeStatement) { allElements.Add(new InvokInfo(Traverser, "IAssumeStatement", assumeStatement)); }
/// <summary> /// Throws an exception when executed: IAssumeStatement nodes /// must be replaced before converting the Code Model to IL. /// </summary> public override void TraverseChildren(IAssumeStatement assumeStatement) { Contract.Assume(false, "IAssumeStatement nodes must be replaced before trying to convert the Code Model to IL."); }
public virtual void onASTElement(IAssumeStatement assumeStatement) { }
public void Visit(IAssumeStatement assumeStatement) { this.result = this.rewriter.Rewrite(assumeStatement); }
public override void TraverseChildren(IAssumeStatement assumeStatement) { MethodEnter(assumeStatement); base.TraverseChildren(assumeStatement); MethodExit(); }
/// <summary> /// Rewrites the given assume statement. /// </summary> /// <param name="assumeStatement"></param> public virtual IStatement Rewrite(IAssumeStatement assumeStatement) { var mutableAssumeStatement = assumeStatement as AssumeStatement; if (mutableAssumeStatement == null) return assumeStatement; this.RewriteChildren(mutableAssumeStatement); return mutableAssumeStatement; }
/// <summary> /// Traverses the assume statement. /// </summary> public void Traverse(IAssumeStatement assumeStatement) { Contract.Requires(assumeStatement != null); if (this.preorderVisitor != null) this.preorderVisitor.Visit(assumeStatement); if (this.StopTraversal) return; this.TraverseChildren(assumeStatement); if (this.StopTraversal) return; if (this.postorderVisitor != null) this.postorderVisitor.Visit(assumeStatement); }
public void Visit(IAssumeStatement assumeStatement) { this.traverser.Traverse(assumeStatement); }
/// <summary> /// Visits the specified assume statement. /// </summary> /// <param name="assumeStatement">The assume statement.</param> public override void Visit(IAssumeStatement assumeStatement) { AssumeStatement mutableAssumeStatement = assumeStatement as AssumeStatement; if (alwaysMakeACopy || mutableAssumeStatement == null) mutableAssumeStatement = new AssumeStatement(assumeStatement); this.resultStatement = this.myCodeMutator.Visit(mutableAssumeStatement); }
//^ ensures this.path.Count == old(this.path.Count); /// <summary> /// Traverses the given assume statement. /// </summary> /// <param name="assumeStatement"></param> public virtual void Visit(IAssumeStatement assumeStatement) { if (this.stopTraversal) return; //^ int oldCount = this.path.Count; this.path.Push(assumeStatement); this.Visit(assumeStatement.Condition); if (assumeStatement.Description != null) this.Visit(assumeStatement.Description); //^ assume this.path.Count == oldCount+1; //True because all of the virtual methods of this class promise not to decrease this.path.Count. this.path.Pop(); }
/// <summary> /// Returns a deep copy of the given assume statement. /// </summary> /// <param name="assumeStatement"></param> public AssumeStatement Copy(IAssumeStatement assumeStatement) { var mutableCopy = this.shallowCopier.Copy(assumeStatement); mutableCopy.Condition = this.Copy(mutableCopy.Condition); if (mutableCopy.Description != null) mutableCopy.Description = this.Copy(mutableCopy.Description); return mutableCopy; }
public void Visit(IAssumeStatement assumeStatement) { throw new NotImplementedException(); }
/// <summary> /// /// </summary> /// <param name="assumeStatement"></param> public AssumeStatement(IAssumeStatement assumeStatement) : base(assumeStatement) { this.condition = assumeStatement.Condition; this.description = assumeStatement.Description; this.conditionAsText = assumeStatement.OriginalSource; }
/// <summary> /// Visits the specified assume statement. /// </summary> /// <param name="assumeStatement">The assume statement.</param> public override void Visit(IAssumeStatement assumeStatement) { AssumeStatement mutableAssumeStatement = new AssumeStatement(assumeStatement); this.resultStatement = this.myCodeCopier.DeepCopy(mutableAssumeStatement); }
/// <summary> /// Visits the specified assume statement. /// </summary> /// <param name="assumeStatement">The assume statement.</param> public override void Visit(IAssumeStatement assumeStatement) { AssumeStatement mutableAssumeStatement = assumeStatement as AssumeStatement; if (mutableAssumeStatement == null) { this.resultStatement = assumeStatement; return; } this.resultStatement = this.myCodeMutator.Visit(mutableAssumeStatement); }