public ReturnRewriter(IMetadataHost host, ILabeledStatement target, ILocalDeclarationStatement local)
: base(host)
{
Contract.Requires(host != null && target != null);
this.target = target;
this.local = local;
}
private static void WriteLabeled(LanguageWriter w, ILabeledStatement state)
{
w.__WriteLabel(state.Name);
if (state.Statement != null)
{
WriteStatement(w, state.Statement);
}
}
public override void TraverseChildren(ILabeledStatement labeledStatement)
{
if (currStatement != null)
{
mostNestedTryStatement.Add(labeledStatement.Label, currStatement);
}
base.TraverseChildren(labeledStatement);
}
public override void TraverseChildren(ILabeledStatement labeledStatement)
{
this.sourceEmitterOutput.DecreaseIndent();
this.sourceEmitterOutput.Write(labeledStatement.Label.Value, true);
this.sourceEmitterOutput.WriteLine(":");
this.sourceEmitterOutput.IncreaseIndent();
this.Traverse(labeledStatement.Statement);
}
public override void Visit(ILabeledStatement labeledStatement)
{
if (Process(labeledStatement))
{
visitor.Visit(labeledStatement);
}
base.Visit(labeledStatement);
}
private ConditionalStatement/*?*/ LookForCondition(List<IStatement> statements, int i, ILabeledStatement potentialLabel) {
Contract.Requires(statements != null);
Contract.Requires(i >= 0);
Contract.Requires(potentialLabel != null);
for (; i < statements.Count-1; i++) {
if (statements[i] != potentialLabel) continue;
return statements[i+1] as ConditionalStatement;
}
return null;
}
internal void Visit(BasicBlock block)
{
this.block = block;
this.operandStack = new StackOfLocals(this.body);
this.codePointsToAnalyze.Enqueue(new CodePoint()
{
statements = block.Statements, index = 0, operandStack = this.operandStack
});
while (this.codePointsToAnalyze.Count > 0)
{
CodePoint codePoint = this.codePointsToAnalyze.Dequeue();
if (codePoint.operandStack == null)
{
//Can only get here for a code point with a label and labels are only created if there a branches to them.
//Sooner or later the branch must be encountered and then this code point will get an operand stack from the branch.
if (this.codePointsToAnalyze.Count == 0)
{
//But if we get here, there are NO other code blocks, so we'll loop forever if we just put codePoint back on the queue with an empty stack.
//Start with an empty stack and just carry on.
codePoint.operandStack = new StackOfLocals(this.body);
}
else
{
this.codePointsToAnalyze.Enqueue(codePoint); //keep looking for the branch.
continue;
}
}
this.operandStack = codePoint.operandStack.Clone(this.block);
List <IStatement> statements = codePoint.statements;
for (int i = codePoint.index; i < statements.Count; i++)
{
statements[i] = this.Visit(statements[i]);
if (this.visitedUnconditionalBranch)
{
this.visitedUnconditionalBranch = false;
if (i + 1 < statements.Count)
{
ILabeledStatement /*?*/ label = statements[i + 1] as ILabeledStatement;
if (label == null)
{
continue; //Unreachable code. Need to carry on though, since it may contain the only branch to a label.
}
this.codePointsToAnalyze.Enqueue(new CodePoint()
{
statements = statements, index = i + 1
});
}
break;
}
}
}
}
private void ProcessLabeledStatement(ILabeledStatement pStatement)
{
HLLabel labelTarget = null;
if (!mRemappedLabels.TryGetValue(pStatement.Label.Value, out labelTarget))
{
labelTarget = CreateLabel();
mRemappedLabels.Add(pStatement.Label.Value, labelTarget);
}
mCurrentBlock.Terminate(labelTarget);
mCurrentBlock = CreateBlock(labelTarget);
ProcessStatement(pStatement.Statement);
}
/// <summary>
/// Visits the specified block statement.
/// </summary>
/// <param name="blockStatement">The block statement.</param>
/// <returns></returns>
public override IBlockStatement Visit(BlockStatement blockStatement)
{
var savedBlock = this.block;
BasicBlock /*?*/ b = blockStatement as BasicBlock;
for (; ;)
{
if (b != null)
{
this.block = b;
int statementCount = b.Statements.Count;
BasicBlock /*?*/ bnext = null;
if (statementCount > 1 && b.Statements[statementCount - 2] is IGotoStatement)
{
bnext = b.Statements[--statementCount] as BasicBlock;
if (bnext != null)
{
b.Statements.RemoveAt(statementCount);
}
}
b.Statements = this.Visit(b.Statements);
if (bnext == null || bnext.Statements.Count == 0)
{
break;
}
ILabeledStatement labeledStatement = bnext.Statements[0] as ILabeledStatement;
if (labeledStatement != null)
{
StackOfLocals newStack = null;
if (this.stackFor.TryGetValue(labeledStatement, out newStack))
{
this.operandStack.TransferTo(newStack, b.Statements);
this.operandStack = newStack;
this.stackFor.Remove(labeledStatement);
}
}
b.Statements.Add(bnext);
b = bnext;
}
else
{
blockStatement.Statements = Visit(blockStatement.Statements);
break;
}
}
this.block = savedBlock;
return(blockStatement);
}
private void DecompileTryBody(BasicBlock b, BasicBlock firstHandler, TryCatchFinallyStatement tryStatement)
{
tryStatement.TryBody = GetBasicBlockUpto(b, firstHandler.StartOffset);
BasicBlock tryBody = tryStatement.TryBody as BasicBlock;
int startPoint = 0;
if (tryBody != null && tryBody.Statements.Count > 0)
{
ILabeledStatement labeledStatement = tryBody.Statements[0] as ILabeledStatement;
if (labeledStatement != null)
{
tryBody.Statements.RemoveAt(0);
b.Statements.Insert(startPoint, labeledStatement);
startPoint++;
}
}
b.Statements.Insert(startPoint, tryStatement);
}
public override void TraverseChildren(ILabeledStatement labeledStatement)
{
if (this.loopHeader == null)
{
List <IGotoStatement> predecessors;
if (this.predecessors.TryGetValue(labeledStatement, out predecessors))
{
if (predecessors.Count == 1 && !this.gotosAlreadyTraversed.Contains(predecessors[0]))
{
this.blockContainingLoopHeader = this.currentBlock;
this.loopHeader = labeledStatement;
this.backwardsBranch = predecessors[0];
this.ifContainingBackwardsBranch = null;
}
}
}
base.TraverseChildren(labeledStatement);
}
private IStatement/*?*/ ExtractBlock(List<IStatement> statements, int first, ILabeledStatement labelOfSubsequentCode, bool removeLabel) {
Contract.Requires(statements != null);
Contract.Requires(first > 0);
var last = first;
var n = statements.Count;
if (first == n-1) {
var lastBlock = statements[first] as BlockStatement;
if (lastBlock != null && labelOfSubsequentCode == this.labelImmediatelyFollowingCurrentBlock) {
statements.RemoveAt(first);
return lastBlock;
}
}
while (last < n) {
var statement = statements[last];
if (statement == labelOfSubsequentCode) {
if (removeLabel) statements.RemoveAt(last);
break;
}
var block = statement as DecompiledBlock;
if (block != null && block.FirstExecutableStatementIs(labelOfSubsequentCode)) {
if (removeLabel) block.RemoveAndReturnInitialLabel();
break;
}
last++;
}
if (last == n) {
if (labelOfSubsequentCode != this.labelImmediatelyFollowingCurrentBlock) return null;
Contract.Assert(n == statements.Count); //any modification to statements will terminate the while loop before last == n.
}
if (first == last) return new EmptyStatement();
if (first == last-1) {
var firstBlock = statements[first] as BlockStatement;
if (firstBlock != null) {
statements.RemoveAt(first);
return firstBlock;
}
}
var newStatements = statements.GetRange(first, last-first);
statements.RemoveRange(first, last-first);
return new BlockStatement() { Statements = newStatements };
}
private static bool IsOrContainsAsFirstStatement(IStatement statement, ILabeledStatement labeledStatement) {
if (statement == labeledStatement) return true;
var block = statement as BlockStatement;
while (block != null) {
var statements = block.Statements;
var n = statements.Count;
if (n == 0) return false;
for (int i = 0; i < n; i++) {
var s = statements[i];
var locDecl = s as LocalDeclarationStatement;
if (locDecl != null) {
if (locDecl.InitialValue == null) continue;
return false;
}
if (s == labeledStatement) return true;
block = s as BlockStatement;
}
}
return false;
}
public static IExpression GetExpression(IStatement statement, out string label)
{
ILabeledStatement labeled = statement as ILabeledStatement;
if (labeled != null)
{
label = labeled.Name;
statement = labeled.Statement;
}
else
{
label = null;
}
IExpressionStatement state_exp = statement as IExpressionStatement;
if (state_exp != null)
{
return(state_exp.Expression);
}
return(null);
}
private static bool IsOrContainsAsFirstStatement(IStatement statement, ILabeledStatement labeledStatement)
{
if (statement == labeledStatement)
{
return(true);
}
var block = statement as BlockStatement;
while (block != null)
{
var statements = block.Statements;
var n = statements.Count;
if (n == 0)
{
return(false);
}
for (int i = 0; i < n; i++)
{
var s = statements[i];
var locDecl = s as LocalDeclarationStatement;
if (locDecl != null)
{
if (locDecl.InitialValue == null)
{
continue;
}
return(false);
}
if (s == labeledStatement)
{
return(true);
}
block = s as BlockStatement;
}
}
return(false);
}
public override List <IStatement> Visit(List <IStatement> statements)
{
List <IStatement> newList = new List <IStatement>();
foreach (var statement in statements)
{
BasicBlock bb = statement as BasicBlock;
if (bb != null && bb.Statements.Count > 0)
{
ILabeledStatement labeledStatement = bb.Statements[0] as ILabeledStatement;
if (labeledStatement != null)
{
StackOfLocals newStack = null;
if (this.stackFor.TryGetValue(labeledStatement, out newStack))
{
this.operandStack.TransferTo(newStack, newList);
this.operandStack = newStack;
this.stackFor.Remove(labeledStatement);
}
}
}
IStatement newStatement;
newStatement = this.Visit(statement);
if (newStatement is IBlockStatement && !(statement is IBlockStatement))
{
newList.AddRange(((IBlockStatement)newStatement).Statements);
}
else
{
newList.Add(newStatement);
}
}
return(newList);
}
private static bool DetectLocalRefVariable(string var_disposable, IStatement next, IStatement next2, out LocalRefVariableStatement ret_lrv)
{
ret_lrv = new LocalRefVariableStatement();
//-------------------------------------------------------
// 第二文
//-------------------------------------------------------
// try{
// ... // null-declarations
// var_name=var_disposable;
// ...
// }fault{
// var_name->Dispose();
// }
ITryCatchFinallyStatement state_next = next as ITryCatchFinallyStatement;
if (state_next == null ||
state_next.Try == null || state_next.Try.Statements.Count == 0 ||
state_next.Fault == null || state_next.Fault.Statements.Count != 1
)
{
return(false);
}
//
// null-declarations を飛ばす
//
int i_assign = 0;
IStatementCollection try_states = state_next.Try.Statements;
while (IsNullDeclaration(try_states[i_assign]))
{
if (++i_assign >= try_states.Count)
{
return(false);
}
}
//
// var_name=var_disposable の var_name を取得
//
IAssignExpression exp_assign = GetAssignExpression(state_next.Try.Statements[i_assign]);
if (exp_assign == null || var_disposable != GetVariableName(exp_assign.Expression))
{
return(false);
}
ret_lrv.var_name = GetVariableName(exp_assign.Target);
if (ret_lrv.var_name == null)
{
return(false);
}
//
// fault 内の形式の確認
//
{
// **->**();
IMethodInvokeExpression exp_inv = GetInvokeExpression(state_next.Fault.Statements[0]);
if (exp_inv == null || exp_inv.Arguments.Count != 0)
{
return(false);
}
// **->Dispose();
IMethodReferenceExpression method = exp_inv.Method as IMethodReferenceExpression;
if (method == null || method.Method == null || method.Method.Name != "Dispose")
{
return(false);
}
// disposable->Dispose();
if (ret_lrv.var_name != GetVariableName(method.Target))
{
return(false);
}
}
//-------------------------------------------------------
// 第三文
//-------------------------------------------------------
// "Label:"?
// var_name->Dispose();
//
ILabeledStatement labeled = next2 as ILabeledStatement;
if (labeled != null)
{
ret_lrv.labelname = labeled.Name;
next2 = labeled.Statement;
}
{
// **->**();
IMethodInvokeExpression exp_inv = GetInvokeExpression(next2);
if (exp_inv == null || exp_inv.Arguments.Count != 0)
{
return(false);
}
// **->Dispose();
IMethodReferenceExpression method = exp_inv.Method as IMethodReferenceExpression;
if (method == null || method.Method == null || method.Method.Name != "Dispose")
{
return(false);
}
// disposable->Dispose();
if (ret_lrv.var_name != GetVariableName(method.Target))
{
return(false);
}
}
ret_lrv.block = state_next.Try;
ret_lrv.block.Statements.RemoveAt(i_assign);
return(true);
}
/// <summary>
/// Performs some computation with the given labeled statement.
/// </summary>
/// <param name="labeledStatement"></param>
public virtual void Visit(ILabeledStatement labeledStatement)
{
this.Visit((IStatement)labeledStatement);
}
public void Visit(ILabeledStatement labeledStatement)
{
throw new NotImplementedException();
}
/// <summary>
/// Performs some computation with the given labeled statement.
/// </summary>
/// <param name="labeledStatement"></param>
public virtual void Visit(ILabeledStatement labeledStatement)
{
}
/// <summary>
/// Traverses the children of the labeled statement.
/// </summary>
public virtual void TraverseChildren(ILabeledStatement labeledStatement)
{
Contract.Requires(labeledStatement != null);
this.TraverseChildren((IStatement)labeledStatement);
if (this.StopTraversal) return;
this.Traverse(labeledStatement.Statement);
}
/// <summary>
///
/// </summary>
/// <param name="labeledStatement"></param>
public LabeledStatement(ILabeledStatement labeledStatement)
: base(labeledStatement) {
this.labelName = labeledStatement.Label;
this.statement = labeledStatement.Statement;
}
public override IStatement Visit(IStatement statement)
{
IGotoStatement gotoStatement = statement as IGotoStatement;
if (gotoStatement != null)
{
this.visitedUnconditionalBranch = true;
foreach (object ob in this.path)
{
if (ob is IConditionalStatement)
{
this.visitedUnconditionalBranch = false;
}
}
StackOfLocals newStack = null;
if (this.stackFor.TryGetValue(gotoStatement.TargetStatement, out newStack))
{
return(this.TransferStack(gotoStatement, newStack));
}
this.stackFor.Add(gotoStatement.TargetStatement, this.operandStack.Clone(this.block));
return(gotoStatement);
}
ILabeledStatement labeledStatement = statement as ILabeledStatement;
if (labeledStatement != null)
{
StackOfLocals newStack = null;
if (this.stackFor.TryGetValue(labeledStatement, out newStack))
{
return(this.TransferStack(labeledStatement, newStack));
}
this.stackFor.Add(labeledStatement, this.operandStack.Clone(this.block));
return(labeledStatement);
}
PushStatement /*?*/ push = statement as PushStatement;
if (push != null)
{
push.ValueToPush = this.Visit(push.ValueToPush);
this.tempCounter = this.body.localVariablesAndTemporaries.Count;
var temp = new TempVariable()
{
Name = this.body.host.NameTable.GetNameFor("__temp_" + this.tempCounter++)
};
temp.Type = push.ValueToPush.Type;
this.operandStack.Push(temp);
this.body.numberOfReferences.Add(temp, 0);
var ctc = push.ValueToPush as ICompileTimeConstant;
// "push null" doesn't tell us enough to know what type it really is
if (ctc != null && ctc.Value == null) // REVIEW: need to make sure the type is a reference type?
{
temp.isPolymorphic = true;
}
var be = push.ValueToPush as IBoundExpression;
if (be != null)
{
var sourceLocal = be.Definition as TempVariable;
if (sourceLocal != null && sourceLocal.isPolymorphic)
{
temp.isPolymorphic = true;
}
}
if (push.ValueToPush.Type is IManagedPointerTypeReference)
{
temp.turnIntoPopValueExpression = true;
return(statement);
}
this.body.localVariablesAndTemporaries.Add(temp);
if (this.block.LocalVariables == null)
{
this.block.LocalVariables = new List <ILocalDefinition>();
}
this.block.LocalVariables.Add(temp);
this.body.numberOfAssignments.Add(temp, 1);
return(new ExpressionStatement()
{
Expression = new Assignment()
{
Target = new TargetExpression()
{
Definition = temp
}, Source = push.ValueToPush
},
Locations = push.Locations
});
}
if (statement is EndFilter || statement is EndFinally)
{
this.visitedUnconditionalBranch = true;
return(statement);
}
if (statement is SwitchInstruction)
{
return(statement);
}
return(base.Visit(statement));
}
/// <summary>
///
/// </summary>
/// <param name="gotoStatement"></param>
public GotoStatement(IGotoStatement gotoStatement)
: base(gotoStatement)
{
this.targetStatement = gotoStatement.TargetStatement;
}
public override void TraverseChildren(ILabeledStatement labeledStatement) {
this.sourceEmitterOutput.DecreaseIndent();
this.sourceEmitterOutput.Write(labeledStatement.Label.Value, true);
this.sourceEmitterOutput.WriteLine(":");
this.sourceEmitterOutput.IncreaseIndent();
this.Traverse(labeledStatement.Statement);
}
public virtual void VisitLabeledStatement(ILabeledStatement value)
{
VisitStatement(value.Statement);
}
/// <summary>
/// Performs some computation with the given labeled statement.
/// </summary>
/// <param name="labeledStatement"></param>
public virtual void Visit(ILabeledStatement labeledStatement)
{
}
private IStatement/*?*/ ExtractBlock(List<IStatement> statements, int first, ILabeledStatement labelOfSubsequentCode, bool removeLabel) {
Contract.Requires(statements != null);
Contract.Requires(first > 0);
var last = first;
var n = statements.Count;
if (first == n-1) {
var lastBlock = statements[first] as BlockStatement;
if (lastBlock != null && labelOfSubsequentCode == this.labelImmediatelyFollowingCurrentBlock) {
statements.RemoveAt(first);
return lastBlock;
}
}
while (last < n) {
var statement = statements[last];
if (statement == labelOfSubsequentCode) {
if (removeLabel) statements.RemoveAt(last);
break;
}
var block = statement as DecompiledBlock;
if (block != null && block.FirstExecutableStatementIs(labelOfSubsequentCode)) {
if (removeLabel) block.RemoveAndReturnInitialLabel();
break;
}
last++;
}
if (last == n) {
if (labelOfSubsequentCode != this.labelImmediatelyFollowingCurrentBlock) return null;
Contract.Assert(n == statements.Count); //any modification to statements will terminate the while loop before last == n.
}
if (first == last) return new EmptyStatement();
if (first == last-1) {
var firstBlock = statements[first] as BlockStatement;
if (firstBlock != null) {
statements.RemoveAt(first);
return firstBlock;
}
}
var newStatements = statements.GetRange(first, last-first);
statements.RemoveRange(first, last-first);
return new BlockStatement() { Statements = newStatements };
}
/// <summary>
/// Returns a shallow copy of the given labeled statement.
/// </summary>
/// <param name="labeledStatement"></param>
public LabeledStatement Copy(ILabeledStatement labeledStatement) {
Contract.Requires(labeledStatement != null);
Contract.Ensures(Contract.Result<LabeledStatement>() != null);
return new LabeledStatement(labeledStatement);
}
/// <summary>
/// Returns a deep copy of the given labeled statement.
/// </summary>
/// <param name="labeledStatement"></param>
public LabeledStatement Copy(ILabeledStatement labeledStatement) {
Contract.Requires(labeledStatement != null);
Contract.Ensures(Contract.Result<LabeledStatement>() != null);
var mutableCopy = this.shallowCopier.Copy(labeledStatement);
return mutableCopy;
}
public virtual void VisitLabeledStatement(ILabeledStatement operation)
{
DefaultVisit(operation);
}
/// <summary>
/// Visits the specified labeled statement.
/// </summary>
/// <param name="labeledStatement">The labeled statement.</param>
public override void Visit(ILabeledStatement labeledStatement)
{
LabeledStatement mutableLabeledStatement = new LabeledStatement(labeledStatement);
this.resultStatement = this.myCodeCopier.DeepCopy(mutableLabeledStatement);
}
public virtual void VisitLabeledStatement(ILabeledStatement operation)
{
DefaultVisit(operation);
}
/// <summary>
/// Returns a deep copy of the given labeled statement.
/// </summary>
/// <param name="labeledStatement"></param>
public LabeledStatement Copy(ILabeledStatement labeledStatement)
{
var mutableCopy = this.shallowCopier.Copy(labeledStatement);
return mutableCopy;
}
public virtual void onASTElement(ILabeledStatement labeledStatement) { }
/// <summary>
/// Returns a shallow copy of the given labeled statement.
/// </summary>
/// <param name="labeledStatement"></param>
public LabeledStatement Copy(ILabeledStatement labeledStatement)
{
return new LabeledStatement(labeledStatement);
}
public override IOperation VisitLabeledStatement(ILabeledStatement operation, object argument)
{
return(new LabeledStatement(operation.Label, Visit(operation.Statement), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit));
}
public void Visit(ILabeledStatement labeledStatement)
{
this.result = this.copier.Copy(labeledStatement);
}
/// <summary>
/// Traverses the labeled statement.
/// </summary>
public void Traverse(ILabeledStatement labeledStatement)
{
Contract.Requires(labeledStatement != null);
if (this.preorderVisitor != null) this.preorderVisitor.Visit(labeledStatement);
if (this.StopTraversal) return;
this.TraverseChildren(labeledStatement);
if (this.StopTraversal) return;
if (this.postorderVisitor != null) this.postorderVisitor.Visit(labeledStatement);
}
/// <summary>
///
/// </summary>
public GotoStatement()
{
this.targetStatement = CodeDummy.LabeledStatement;
}
public void Visit(ILabeledStatement labeledStatement)
{
this.traverser.Traverse(labeledStatement);
}
/// <summary>
///
/// </summary>
/// <remarks> (mschaef) not sure if there is more work to do</remarks>
/// <param name="labeledStatement"></param>
public override void TraverseChildren(ILabeledStatement labeledStatement)
{
StmtBuilder.AddLabelCmd(labeledStatement.Label.Value);
base.Traverse(labeledStatement.Statement);
}
public void Visit(ILabeledStatement labeledStatement)
{
Contract.Requires(labeledStatement != null);
throw new NotImplementedException();
}
/// <summary>
/// Rewrites the given labeled statement.
/// </summary>
/// <param name="labeledStatement"></param>
public virtual IStatement Rewrite(ILabeledStatement labeledStatement)
{
return labeledStatement;
}
/// <summary>
/// Generates IL for the specified labeled statement.
/// </summary>
/// <param name="labeledStatement">The labeled statement.</param>
public override void TraverseChildren(ILabeledStatement labeledStatement)
{
ILGeneratorLabel targetLabel;
if (!this.labelFor.TryGetValue(labeledStatement.Label.UniqueKey, out targetLabel)) {
targetLabel = new ILGeneratorLabel();
this.labelFor.Add(labeledStatement.Label.UniqueKey, targetLabel);
}
this.generator.MarkLabel(targetLabel);
this.Traverse(labeledStatement.Statement);
}
public virtual void onASTElement(ILabeledStatement labeledStatement)
{
}
private static IStatement ExtractBlock(List<IStatement> statements, int first, ILabeledStatement labelOfSubsequentCode) {
Contract.Requires(statements != null);
Contract.Requires(first > 0);
Contract.Ensures(Contract.Result<IStatement>() != null);
var last = first;
var n = statements.Count;
while (last < n) {
var statement = statements[last];
if (statement == labelOfSubsequentCode) {
statements.RemoveRange(last, 2);
break;
}
last++;
}
if (last == n) return new EmptyStatement();
Contract.Assume(last <= statements.Count);
if (first == last) return new EmptyStatement();
if (first == last-1) {
var firstBlock = statements[first] as BlockStatement;
if (firstBlock != null) {
statements.RemoveAt(first);
return firstBlock;
}
}
var newStatements = statements.GetRange(first, last-first);
statements.RemoveRange(first, last-first);
return new BlockStatement() { Statements = newStatements };
}
public override void TraverseChildren(ILabeledStatement labeledStatement)
{ MethodEnter(labeledStatement);
base.TraverseChildren(labeledStatement);
MethodExit(); }
public override void VisitLabeledStatement(ILabeledStatement operation)
{
var label = operation.Label;
base.VisitLabeledStatement(operation);
}
public override void Visit(ILabeledStatement labeledStatement)
{
allElements.Add(new InvokInfo(Traverser, "ILabeledStatement", labeledStatement));
}
public override void Visit(ILabeledStatement labeledStatement)
{
if(Process(labeledStatement)){visitor.Visit(labeledStatement);}
base.Visit(labeledStatement);
}
public override void VisitLabeledStatement(ILabeledStatement operation)
{
Visit(operation.Labeled);
}
public virtual void VisitLabeledStatement(ILabeledStatement s)
{
}
public override void TraverseChildren(ILabeledStatement labeledStatement)
{
if (this.currentTryCatch != null)
this.mostNestedTryCatchFor.Add(labeledStatement, this.currentTryCatch);
base.TraverseChildren(labeledStatement);
}
private void WriteLabeledStatement(ILabeledStatement statement, IFormatter formatter)
{
if (statement.Statement != null)
{
this.WriteStatementSeparator(formatter);
}
formatter.WriteLine();
formatter.WriteOutdent();
this.WriteDeclaration(statement.Name, formatter);
formatter.Write(":");
formatter.WriteLine();
formatter.WriteIndent();
this.firstStmt = true;
if (statement.Statement != null)
{
this.WriteStatement(statement.Statement, formatter);
}
}
//^ ensures this.path.Count == old(this.path.Count);
/// <summary>
/// Traverses the given labeled statement.
/// </summary>
/// <param name="labeledStatement"></param>
public virtual void Visit(ILabeledStatement labeledStatement)
{
if (this.stopTraversal) return;
//^ int oldCount = this.path.Count;
this.path.Push(labeledStatement);
this.Visit(labeledStatement.Statement);
//^ 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();
}
private ConditionalStatement /*?*/ LookForCondition(List <IStatement> statements, int i, ILabeledStatement potentialLabel)
{
Contract.Requires(statements != null);
Contract.Requires(i >= 0);
Contract.Requires(potentialLabel != null);
for (; i < statements.Count - 1; i++)
{
if (statements[i] != potentialLabel)
{
continue;
}
return(statements[i + 1] as ConditionalStatement);
}
return(null);
}
public GotoStatement(ILabeledStatement label)
{
Label = label;
}
public override void TraverseChildren(ILabeledStatement labeledStatement)
{
MethodEnter(labeledStatement);
base.TraverseChildren(labeledStatement);
MethodExit();
}
private static IStatement ExtractBlock(List <IStatement> statements, int first, ILabeledStatement labelOfSubsequentCode)
{
Contract.Requires(statements != null);
Contract.Requires(first > 0);
Contract.Ensures(Contract.Result <IStatement>() != null);
var last = first;
var n = statements.Count;
while (last < n)
{
var statement = statements[last];
if (statement == labelOfSubsequentCode)
{
statements.RemoveRange(last, 2);
break;
}
last++;
}
if (last == n)
{
return(new EmptyStatement());
}
Contract.Assume(last <= statements.Count);
if (first == last)
{
return(new EmptyStatement());
}
if (first == last - 1)
{
var firstBlock = statements[first] as BlockStatement;
if (firstBlock != null)
{
statements.RemoveAt(first);
return(firstBlock);
}
}
var newStatements = statements.GetRange(first, last - first);
statements.RemoveRange(first, last - first);
return(new BlockStatement()
{
Statements = newStatements
});
}
