public override Statement Clone()
        {
            BlockStatement clonedBody = Body != null?body.Clone() as BlockStatement : null;

            ForEachStatement result = new ForEachStatement(Variable.Clone() as VariableDeclarationExpression, Collection.Clone(), clonedBody, mappedConditionInstructions, mappedFinallyInstructions);

            CopyParentAndLabel(result);
            return(result);
        }
        public override Statement CloneStatementOnly()
        {
            BlockStatement clonedBody = Body != null?body.CloneStatementOnly() as BlockStatement : null;

            ForEachStatement result = new ForEachStatement(Variable.CloneExpressionOnly() as VariableDeclarationExpression,
                                                           Collection.CloneExpressionOnly(), clonedBody, null, null);

            CopyParentAndLabel(result);
            return(result);
        }
示例#3
0
 public override Statement CloneStatementOnly()
 {
     if (this.get_Body() != null)
     {
         stackVariable5 = this.body.CloneStatementOnly() as BlockStatement;
     }
     else
     {
         stackVariable5 = null;
     }
     V_0 = stackVariable5;
     V_1 = new ForEachStatement(this.get_Variable().CloneExpressionOnly() as VariableDeclarationExpression, this.get_Collection().CloneExpressionOnly(), V_0, null, null);
     this.CopyParentAndLabel(V_1);
     return(V_1);
 }
示例#4
0
 public override Statement Clone()
 {
     if (this.get_Body() != null)
     {
         stackVariable5 = this.body.Clone() as BlockStatement;
     }
     else
     {
         stackVariable5 = null;
     }
     V_0 = stackVariable5;
     V_1 = new ForEachStatement(this.get_Variable().Clone() as VariableDeclarationExpression, this.get_Collection().Clone(), V_0, this.mappedConditionInstructions, this.mappedFinallyInstructions);
     this.CopyParentAndLabel(V_1);
     return(V_1);
 }
        private void GenerateForeachStatement()
        {
            if (foreachVariable == null)
            {
                foreachVariable = new VariableDefinition(foreachVariableType);
                foreachVariableInstructions.Clear();
                this.methodContext.VariablesToRename.Add(foreachVariable);
            }
            VariableDeclarationExpression vd = new VariableDeclarationExpression(foreachVariable, foreachVariableInstructions);

            Expression foreachCollectionExpression = foreachCollection.CloneAndAttachInstructions(foreachCollectionInstructions);
            if (foreachCollectionExpression is BaseReferenceExpression)
            {
                foreachCollectionExpression = new ThisReferenceExpression(this.methodContext.Method.DeclaringType, foreachCollectionExpression.UnderlyingSameMethodInstructions);
            }

            @foreach = new ForEachStatement(vd, foreachCollectionExpression, foreachBody, foreachConditionInstructions, theTry.Finally.UnderlyingSameMethodInstructions);
            GetCurrentFixer gcf = new GetCurrentFixer(theEnumerator, foreachVariable);
            gcf.Visit(@foreach);

            IsEnumeratorUsedVisitor enumeratorUsedVisitor = new IsEnumeratorUsedVisitor(theEnumerator);
            enumeratorUsedVisitor.Visit(@foreach);
            isEnumeratorUsedInsideForEach = enumeratorUsedVisitor.IsEnumeratorUsed;
        }
 private void ClearState()
 {
     insideTry = false;
     foundEnumeratorAssignment = false;
     foundWhile = false;
     foreachCollection = null;
     foreachVariable = null;
     foreachVariableInstructions.Clear();
     foreachCollectionInstructions.Clear();
     foreachBody = new BlockStatement();
     theEnumerator = null;
     theTry = null;
     @foreach = null;
     enumeratorAssignmentStatement = null;
     foreachVariableType = null;
     isEnumeratorUsedInsideForEach = false;
     foreachConditionInstructions = null;
 }
 public override void VisitForEachStatement(ForEachStatement node)
 {
     return;
 }
 public override ICodeNode VisitForEachStatement(ForEachStatement node)
 {
     codeNodeTypes.Push(CodeNodeType.BinaryExpression);
     node.Variable = (VariableDeclarationExpression)Visit(node.Variable);
     codeNodeTypes.Pop();
     node.Collection = (Telerik.JustDecompiler.Ast.Expressions.Expression)Visit(node.Collection);
     node.Body = (BlockStatement)Visit(node.Body);
     return node;
 }
 public override void VisitForEachStatement(ForEachStatement node)
 {
     loopStates.Push(StatementState.ForEach);
     WriteKeyword(KeyWordWriter.ForEach);
     WriteSpace();
     loopStates.Push(StatementState.ForEachInitializer);
     Visit(node.Variable);
     loopStates.Pop();
     WriteSpace();
     WriteKeyword(KeyWordWriter.In);
     WriteSpace();
     Visit(node.Collection);
     WriteLine();
     Visit(node.Body);
     WriteKeyword(KeyWordWriter.Next);
     loopStates.Pop();
 }
 public override void VisitForEachStatement(ForEachStatement node)
 {
     expressions.Push(ExpressionKind.ForEachVariable);
     Visit(node.Variable);
     expressions.Pop();
     expressions.Push(ExpressionKind.ForEachExpression);
     Visit(node.Collection);
     expressions.Pop();
     ClearPendingForSuggestion();
     Visit(node.Body);
 }
 public override Statement CloneStatementOnly()
 {
     BlockStatement clonedBody = Body != null ? body.CloneStatementOnly() as BlockStatement : null;
     ForEachStatement result = new ForEachStatement(Variable.CloneExpressionOnly() as VariableDeclarationExpression,
         Collection.CloneExpressionOnly(), clonedBody, null, null);
     CopyParentAndLabel(result);
     return result;
 }
		public override Statement Clone()
		{
            BlockStatement clonedBody = Body != null ? body.Clone() as BlockStatement : null;
			ForEachStatement result = new ForEachStatement(Variable.Clone() as VariableDeclarationExpression, Collection.Clone(), clonedBody, mappedConditionInstructions, mappedFinallyInstructions);
			CopyParentAndLabel(result);
            return result;
        }
 public override void VisitForEachStatement(ForEachStatement node)
 {
     WriteKeyword(KeyWordWriter.ForEach);
     WriteSpace();
     WriteToken("(");
     Visit(node.Variable);
     WriteSpace();
     WriteKeyword(KeyWordWriter.In);
     WriteSpace();
     Visit(node.Collection);
     WriteToken(")");
     WriteLine();
     Visit(node.Body);
 }
 public virtual void VisitForEachStatement(ForEachStatement node)
 {
     Visit(node.Variable);
     Visit(node.Collection);
     Visit(node.Body);
 }
 public YieldStateMachineCodeRemover(ForEachStatement @foreach, VariableReference enumeratorVariable)
 {
     this.@foreach = @foreach;
     this.enumeratorVariable = enumeratorVariable;
 }