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 virtual void VisitLabeledStatement(ILabeledStatement value) { VisitStatement(value.Statement); }
/// <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); }
/// <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); }
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; }
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 }); }