C# DoWhileStatement类代码示例

		public override void VisitDoWhileStatement(DoWhileStatement doWhileStatement)
		{
            var token = CreateBlock(string.Format("while ({0})", doWhileStatement.Condition.GetText()), SDNodeRole.DoWhileLoop);
            _tokenList.Add(token);

            VisitChildren(token.Statements, doWhileStatement.EmbeddedStatement);
		}

		static void ConvertToWhileLoop(Script script, DoWhileStatement originalStatement)
		{
			script.Replace(originalStatement, new WhileStatement {
				Condition = originalStatement.Condition.Clone(),
				EmbeddedStatement = originalStatement.EmbeddedStatement.Clone()
			});
		}

		void ApplyAction(Script script, WhileStatement statement) {
			var doWhile = new DoWhileStatement {
				Condition = statement.Condition.Clone(),
				EmbeddedStatement = statement.EmbeddedStatement.Clone()
			};

			script.Replace(statement, doWhile);
		}

 public override void VisitDoWhileStatement(DoWhileStatement doWhileStatement)
 {
     bool oldIsInsideLoop = _isInsideLoop;
     try {
         _isInsideLoop = true;
         base.VisitDoWhileStatement(doWhileStatement);
     }
     finally {
         _isInsideLoop = oldIsInsideLoop;
     }
 }

 public override object VisitDoWhileStatement(DoWhileStatement doWhileStatement, object data)
 {
     if (doWhileStatement.EmbeddedStatement is BlockStatement)
     {
         foreach (Statement innerstatement in (BlockStatement)doWhileStatement.EmbeddedStatement)
         {
             if (innerstatement is WhileStatement || innerstatement is DoWhileStatement)
                 UnlockWith(doWhileStatement);
         }
     }
     return base.VisitDoWhileStatement(doWhileStatement, data);
 }

        static BlockStatement ReplaceJump(JumpStatement jump, BlockStatement block)
        {
            if (jump.StartOffset < block.StartOffset)
                throw new ArgumentOutOfRangeException("jump", "jump should be inside the given block");
            if (jump.JumpOffset > block.EndOffset)
                throw new ArgumentOutOfRangeException("jump", "jump should be inside the given block");

            var newBlock = new BlockStatement();
            var doWhileStatement = new DoWhileStatement(jump.Condition, new BlockStatement()){ StartOffset = jump.StartOffset, EndOffset = jump.JumpOffset };
            var inside = false;
            foreach (var statement in block)
            {
                if (statement.StartOffset == jump.JumpOffset)
                {                    
                    ((BlockStatement)doWhileStatement.Statement).AddStatement(statement);
                    inside = true;
                }
                else if (statement.StartOffset == jump.StartOffset)
                {
                    if (doWhileStatement == null)
                        throw new InvalidOperationException("DoWhileStatement can't be null");
                    newBlock.AddStatement(doWhileStatement);
                    doWhileStatement = null;
                    inside = false;
                }
                else if (inside)
                {
                    ((BlockStatement)doWhileStatement.Statement).AddStatement(statement);
                }
                else
                {
                    var lastStatement = newBlock.LastOrDefault();
                    if (lastStatement != null && lastStatement.EndOffset > statement.StartOffset)
                    {
                        throw new NotSupportedException("invalid Statement");
                    }
                    newBlock.AddStatement(statement);
                }
            }
            return newBlock;
        }

 public void Visit(DoWhileStatement expression)
 {
     outStream.WriteLine("do {");
     expression.Statement.Accept(this);
     outStream.WriteLine();
     outStream.Write("} while (");
     expression.Condition.Accept(this);
     outStream.Write(")");
 }

 private Statement ParseDoWhile(TokenSet followers)
   //^ requires this.currentToken == Token.Do;
   //^ ensures followers[this.currentToken] || this.currentToken == Token.EndOfFile;
 {
   SourceLocationBuilder slb = new SourceLocationBuilder(this.scanner.SourceLocationOfLastScannedToken);
   this.GetNextToken();
   Statement body = this.ParseStatement(followers|Token.While);
   if (body is EmptyStatement)
     this.HandleError(body.SourceLocation, Error.PossibleMistakenNullStatement);
   this.Skip(Token.While);
   Expression condition = this.ParseParenthesizedExpression(false, followers|Token.Semicolon);
   DoWhileStatement result = new DoWhileStatement(body, condition, slb);
   this.SkipSemiColon(followers);
   return result;
 }

		public override void VisitDoWhileStatement(DoWhileStatement doWhileStatement)
		{
			PlaceOnNewLine(policy.PlaceWhileOnNewLine, doWhileStatement.WhileToken);
			FixEmbeddedStatment(policy.StatementBraceStyle, policy.WhileBraceForcement, doWhileStatement.EmbeddedStatement);
		}

 public override void VisitDoWhileStatement(DoWhileStatement doWhileStatement)
 {
     if (findReturn)
     {
         base.VisitDoWhileStatement(doWhileStatement);
     }
 }

 public void VisitDoWhileStatement(DoWhileStatement doWhileStatement)
 {
     VisitExpression(doWhileStatement.Condition);
     VisitStatement(doWhileStatement.Body);
 }

 public override void VisitDoWhileStatement(DoWhileStatement doWhileStatement)
 {
     new DoWhileBlock(this, doWhileStatement).Emit();
 }

			public override void VisitDoWhileStatement (DoWhileStatement doWhileStatement)
			{
				base.VisitDoWhileStatement (doWhileStatement);

				CheckCondition (doWhileStatement.Condition);
			}

		public override void VisitDoWhileStatement(DoWhileStatement doWhileStatement) {
			var body = CreateInnerCompiler().Compile(doWhileStatement.EmbeddedStatement);
			var compiledCondition = CompileExpression(doWhileStatement.Condition, CompileExpressionFlags.ReturnValueIsImportant);
			if (compiledCondition.AdditionalStatements.Count > 0)
				body = JsStatement.Block(body.Statements.Concat(compiledCondition.AdditionalStatements));
			_result.Add(JsStatement.DoWhile(compiledCondition.Expression, body));
		}

		public virtual void VisitDoWhileStatement (DoWhileStatement doWhileStatement)
		{
			VisitChildren (doWhileStatement);
		}