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>
/// Performs some computation with the given assume statement.
/// </summary>
/// <param name="assumeStatement"></param>
public virtual void Visit(IAssumeStatement 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 virtual void onASTElement(IAssumeStatement 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();
}
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>
///
/// </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);
}
public override void TraverseChildren(IAssumeStatement assumeStatement)
{
MethodEnter(assumeStatement);
base.TraverseChildren(assumeStatement);
MethodExit();
}
/// <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);
}
