public virtual object VisitForStatement(ForStatement forStatement, object data) { throw CreateException(forStatement); }
public override object VisitForStatement (ForStatement node, object data) { if (node.Initializers.Count > 1) throw CreateException (node, "Too many initializers"); PushLocals (); EnableSemicolon = false; Write ("for("); foreach (var item in node.Initializers) { if (item != node.Initializers[0]) WriteComma (); item.AcceptVisitor (this, null); } Write ("; "); node.Condition.AcceptVisitor (this, null); Write ("; "); foreach (var item in node.Iterator) { if (item != node.Iterator[0]) WriteComma (); item.AcceptVisitor (this, null); } Write (")"); EnableSemicolon = true; EmitBlockOrIndentedLine (node.EmbeddedStatement); PopLocals (); return null; }
public virtual object VisitForStatement(ForStatement forStatement, object data) { Debug.Assert((forStatement != null)); Debug.Assert((forStatement.Initializers != null)); Debug.Assert((forStatement.Condition != null)); Debug.Assert((forStatement.Iterator != null)); Debug.Assert((forStatement.EmbeddedStatement != null)); for (int i = 0; i < forStatement.Initializers.Count; i++) { Statement o = forStatement.Initializers[i]; Debug.Assert(o != null); nodeStack.Push(o); o.AcceptVisitor(this, data); o = (Statement)nodeStack.Pop(); if (o == null) forStatement.Initializers.RemoveAt(i--); else forStatement.Initializers[i] = o; } nodeStack.Push(forStatement.Condition); forStatement.Condition.AcceptVisitor(this, data); forStatement.Condition = ((Expression)(nodeStack.Pop())); for (int i = 0; i < forStatement.Iterator.Count; i++) { Statement o = forStatement.Iterator[i]; Debug.Assert(o != null); nodeStack.Push(o); o.AcceptVisitor(this, data); o = (Statement)nodeStack.Pop(); if (o == null) forStatement.Iterator.RemoveAt(i--); else forStatement.Iterator[i] = o; } nodeStack.Push(forStatement.EmbeddedStatement); forStatement.EmbeddedStatement.AcceptVisitor(this, data); forStatement.EmbeddedStatement = ((Statement)(nodeStack.Pop())); return null; }
public virtual object VisitForStatement(ForStatement forStatement, object data) { throw new global::System.NotImplementedException("ForStatement"); }
public sealed override object VisitForStatement(ForStatement forStatement, object data) { this.BeginVisit(forStatement); object result = this.TrackedVisitForStatement(forStatement, data); this.EndVisit(forStatement); return result; }
public override object VisitForStatement(ForStatement forStatement, object data) { base.VisitForStatement(forStatement, data); ConvertForStatement(forStatement); return null; }
void EmbeddedStatement( #line 1555 "cs.ATG" out Statement statement) { #line 1557 "cs.ATG" TypeReference type = null; Expression expr = null; Statement embeddedStatement = null; BlockStatement block = null; statement = null; #line 1564 "cs.ATG" Location startLocation = la.Location; if (la.kind == 16) { Block( #line 1566 "cs.ATG" out block); #line 1566 "cs.ATG" statement = block; } else if (la.kind == 11) { lexer.NextToken(); #line 1569 "cs.ATG" statement = new EmptyStatement(); } else if ( #line 1572 "cs.ATG" UnCheckedAndLBrace()) { #line 1572 "cs.ATG" bool isChecked = true; if (la.kind == 58) { lexer.NextToken(); } else if (la.kind == 118) { lexer.NextToken(); #line 1573 "cs.ATG" isChecked = false; } else SynErr(198); Block( #line 1574 "cs.ATG" out block); #line 1574 "cs.ATG" statement = isChecked ? (Statement)new CheckedStatement(block) : (Statement)new UncheckedStatement(block); } else if (la.kind == 79) { IfStatement( #line 1577 "cs.ATG" out statement); } else if (la.kind == 110) { lexer.NextToken(); #line 1579 "cs.ATG" List<SwitchSection> switchSections = new List<SwitchSection>(); Expect(20); Expr( #line 1580 "cs.ATG" out expr); Expect(21); Expect(16); SwitchSections( #line 1581 "cs.ATG" switchSections); Expect(17); #line 1583 "cs.ATG" statement = new SwitchStatement(expr, switchSections); } else if (la.kind == 125) { lexer.NextToken(); Expect(20); Expr( #line 1586 "cs.ATG" out expr); Expect(21); EmbeddedStatement( #line 1587 "cs.ATG" out embeddedStatement); #line 1588 "cs.ATG" statement = new DoLoopStatement(expr, embeddedStatement, ConditionType.While, ConditionPosition.Start); } else if (la.kind == 65) { lexer.NextToken(); EmbeddedStatement( #line 1590 "cs.ATG" out embeddedStatement); Expect(125); Expect(20); Expr( #line 1591 "cs.ATG" out expr); Expect(21); Expect(11); #line 1592 "cs.ATG" statement = new DoLoopStatement(expr, embeddedStatement, ConditionType.While, ConditionPosition.End); } else if (la.kind == 76) { lexer.NextToken(); #line 1594 "cs.ATG" List<Statement> initializer = null; List<Statement> iterator = null; Expect(20); if (StartOf(6)) { ForInitializer( #line 1595 "cs.ATG" out initializer); } Expect(11); if (StartOf(6)) { Expr( #line 1596 "cs.ATG" out expr); } Expect(11); if (StartOf(6)) { ForIterator( #line 1597 "cs.ATG" out iterator); } Expect(21); EmbeddedStatement( #line 1598 "cs.ATG" out embeddedStatement); #line 1599 "cs.ATG" statement = new ForStatement(initializer, expr, iterator, embeddedStatement); } else if (la.kind == 77) { lexer.NextToken(); Expect(20); Type( #line 1601 "cs.ATG" out type); Identifier(); #line 1601 "cs.ATG" string varName = t.val; Expect(81); Expr( #line 1602 "cs.ATG" out expr); Expect(21); EmbeddedStatement( #line 1603 "cs.ATG" out embeddedStatement); #line 1604 "cs.ATG" statement = new ForeachStatement(type, varName , expr, embeddedStatement); } else if (la.kind == 53) { lexer.NextToken(); Expect(11); #line 1607 "cs.ATG" statement = new BreakStatement(); } else if (la.kind == 61) { lexer.NextToken(); Expect(11); #line 1608 "cs.ATG" statement = new ContinueStatement(); } else if (la.kind == 78) { GotoStatement( #line 1609 "cs.ATG" out statement); } else if ( #line 1611 "cs.ATG" IsYieldStatement()) { Expect(132); if (la.kind == 101) { lexer.NextToken(); Expr( #line 1612 "cs.ATG" out expr); #line 1612 "cs.ATG" statement = new YieldStatement(new ReturnStatement(expr)); } else if (la.kind == 53) { lexer.NextToken(); #line 1613 "cs.ATG" statement = new YieldStatement(new BreakStatement()); } else SynErr(199); Expect(11); } else if (la.kind == 101) { lexer.NextToken(); if (StartOf(6)) { Expr( #line 1616 "cs.ATG" out expr); } Expect(11); #line 1616 "cs.ATG" statement = new ReturnStatement(expr); } else if (la.kind == 112) { lexer.NextToken(); if (StartOf(6)) { Expr( #line 1617 "cs.ATG" out expr); } Expect(11); #line 1617 "cs.ATG" statement = new ThrowStatement(expr); } else if (StartOf(6)) { StatementExpr( #line 1620 "cs.ATG" out statement); while (!(la.kind == 0 || la.kind == 11)) {SynErr(200); lexer.NextToken(); } Expect(11); } else if (la.kind == 114) { TryStatement( #line 1623 "cs.ATG" out statement); } else if (la.kind == 86) { lexer.NextToken(); Expect(20); Expr( #line 1626 "cs.ATG" out expr); Expect(21); EmbeddedStatement( #line 1627 "cs.ATG" out embeddedStatement); #line 1627 "cs.ATG" statement = new LockStatement(expr, embeddedStatement); } else if (la.kind == 121) { #line 1630 "cs.ATG" Statement resourceAcquisitionStmt = null; lexer.NextToken(); Expect(20); ResourceAcquisition( #line 1632 "cs.ATG" out resourceAcquisitionStmt); Expect(21); EmbeddedStatement( #line 1633 "cs.ATG" out embeddedStatement); #line 1633 "cs.ATG" statement = new UsingStatement(resourceAcquisitionStmt, embeddedStatement); } else if (la.kind == 119) { lexer.NextToken(); Block( #line 1636 "cs.ATG" out block); #line 1636 "cs.ATG" statement = new UnsafeStatement(block); } else if (la.kind == 74) { #line 1638 "cs.ATG" Statement pointerDeclarationStmt = null; lexer.NextToken(); Expect(20); ResourceAcquisition( #line 1640 "cs.ATG" out pointerDeclarationStmt); Expect(21); EmbeddedStatement( #line 1641 "cs.ATG" out embeddedStatement); #line 1641 "cs.ATG" statement = new FixedStatement(pointerDeclarationStmt, embeddedStatement); } else SynErr(201); #line 1643 "cs.ATG" if (statement != null) { statement.StartLocation = startLocation; statement.EndLocation = t.EndLocation; } }
public override object VisitForStatement(ForStatement forStatement, object data) { UnlockWith(forStatement); return base.VisitForStatement(forStatement, data); }
public override object VisitForStatement(ForStatement forStatement, object data) { base.VisitForStatement(forStatement, data); // Restore loop initializer if (forStatement.Initializers.Count == 0) { LocalVariableDeclaration varDeclr = forStatement.Previous() as LocalVariableDeclaration; if (varDeclr != null) { varDeclr.ReplaceWith(Statement.Null); forStatement.Initializers.Add(varDeclr); } } // Restore loop condition if (forStatement.Condition.IsNull && forStatement.EmbeddedStatement.Children.Count >= 3) { IfElseStatement condition = forStatement.EmbeddedStatement.Children[0] as IfElseStatement; BreakStatement breakStmt = forStatement.EmbeddedStatement.Children[1] as BreakStatement; LabelStatement label = forStatement.EmbeddedStatement.Children[2] as LabelStatement; if (condition != null && breakStmt != null && label != null && condition.TrueStatement.Count == 1) { GotoStatement gotoStmt = condition.TrueStatement[0] as GotoStatement; if (gotoStmt != null && gotoStmt.Label == label.Label) { condition.Remove(); breakStmt.Remove(); forStatement.Condition = condition.Condition; } } } // Restore loop condition (version 2) if (forStatement.Condition.IsNull) { IfElseStatement condition = forStatement.EmbeddedStatement.Children.First as IfElseStatement; if (condition != null && condition.TrueStatement.Count == 1 && condition.TrueStatement[0] is BlockStatement && condition.TrueStatement[0].Children.Count == 1 && condition.TrueStatement[0].Children.First is BreakStatement && condition.FalseStatement.Count == 1 && condition.FalseStatement[0] is BlockStatement && condition.FalseStatement[0].Children.Count == 0) { condition.Remove(); forStatement.Condition = new UnaryOperatorExpression(condition.Condition, UnaryOperatorType.Not); } } // Restore loop iterator if (forStatement.EmbeddedStatement.Children.Count > 0 && forStatement.Iterator.Count == 0) { ExpressionStatement lastStmt = forStatement.EmbeddedStatement.Children.Last as ExpressionStatement; if (lastStmt != null && (lastStmt.Expression is AssignmentExpression || lastStmt.Expression is UnaryOperatorExpression)) { lastStmt.Remove(); forStatement.Iterator.Add(lastStmt); } } return null; }
public override object VisitForStatement(ForStatement forStatement, object data) { forStatement.Condition.Parent = forStatement; forStatement.EmbeddedStatement.Parent = forStatement; foreach (Statement statement in forStatement.Initializers) statement.Parent = forStatement; foreach (Statement iterator in forStatement.Iterator) iterator.Parent = forStatement; return base.VisitForStatement(forStatement, data); }
private bool IsMatch(ForStatement left, ForStatement data) { return true; }
public override object VisitForStatement(ForStatement forStatement, object data) { enteredLoops.Push(forStatement); base.VisitForStatement(forStatement, data); enteredLoops.Pop(); return null; }
public override object VisitForStatement(ForStatement forStatement, object data) { CodeIterationStatement forLoop = new CodeIterationStatement(); if (forStatement.Initializers.Count > 0) { if (forStatement.Initializers.Count > 1) { throw new NotSupportedException("CodeDom does not support Multiple For-Loop Initializer Statements"); } foreach (object o in forStatement.Initializers) { if (o is Expression) { forLoop.InitStatement = new CodeExpressionStatement((CodeExpression)((Expression)o).AcceptVisitor(this,data)); } if (o is Statement) { codeStack.Push(NullStmtCollection); forLoop.InitStatement = (CodeStatement)((Statement)o).AcceptVisitor(this, data); codeStack.Pop(); } } } if (forStatement.Condition == null) { forLoop.TestExpression = new CodePrimitiveExpression(true); } else { forLoop.TestExpression = (CodeExpression)forStatement.Condition.AcceptVisitor(this, data); } codeStack.Push(forLoop.Statements); forStatement.EmbeddedStatement.AcceptVisitor(this, data); codeStack.Pop(); if (forStatement.Iterator.Count > 0) { if (forStatement.Initializers.Count > 1) { throw new NotSupportedException("CodeDom does not support Multiple For-Loop Iterator Statements"); } foreach (Statement stmt in forStatement.Iterator) { forLoop.IncrementStatement = (CodeStatement)stmt.AcceptVisitor(this, data); } } AddStmt(forLoop); return forLoop; }
public override object VisitForStatement(ForStatement forStatement, object data) { forStatement.Condition = Deparenthesize(forStatement.Condition); return base.VisitForStatement(forStatement, data); }
/// <summary> /// Converts from an NRefactory for loop: /// /// for (int i = 0; i < 5; i = i + 1) /// /// to Python's: /// /// i = 0 /// while i < 5: /// </summary> public override object TrackedVisitForStatement(ForStatement forStatement, object data) { // Convert the for loop's initializers. foreach (Statement statement in forStatement.Initializers) { statement.AcceptVisitor(this, data); } // Convert the for loop's test expression. AppendIndented("while "); forStatement.Condition.AcceptVisitor(this, data); Append(":"); AppendLine(); // Visit the for loop's body. IncreaseIndent(); forStatement.EmbeddedStatement.AcceptVisitor(this, data); // Convert the for loop's increment statement. foreach (Statement statement in forStatement.Iterator) { statement.AcceptVisitor(this, data); } DecreaseIndent(); return null; }
public override object VisitForStatement(ForStatement forStatement, object data) { return base.VisitForStatement(forStatement, true); }
void ConvertForStatement(ForStatement forStatement) { // ForStatement -> ForNextStatement when for-loop is simple // only the following forms of the for-statement are allowed: // for (TypeReference name = start; name < oneAfterEnd; name += step) // for (name = start; name < oneAfterEnd; name += step) // for (TypeReference name = start; name <= end; name += step) // for (name = start; name <= end; name += step) // for (TypeReference name = start; name > oneAfterEnd; name -= step) // for (name = start; name > oneAfterEnd; name -= step) // for (TypeReference name = start; name >= end; name -= step) // for (name = start; name >= end; name -= step) // check if the form is valid and collect TypeReference, name, start, end and step if (forStatement.Initializers.Count != 1) return; if (forStatement.Iterator.Count != 1) return; ExpressionStatement statement = forStatement.Iterator[0] as ExpressionStatement; if (statement == null) return; AssignmentExpression iterator = statement.Expression as AssignmentExpression; if (iterator == null || (iterator.Op != AssignmentOperatorType.Add && iterator.Op != AssignmentOperatorType.Subtract)) return; IdentifierExpression iteratorIdentifier = iterator.Left as IdentifierExpression; if (iteratorIdentifier == null) return; PrimitiveExpression stepExpression = iterator.Right as PrimitiveExpression; if (stepExpression == null || !(stepExpression.Value is int)) return; int step = (int)stepExpression.Value; if (iterator.Op == AssignmentOperatorType.Subtract) step = -step; BinaryOperatorExpression condition = forStatement.Condition as BinaryOperatorExpression; if (condition == null || !(condition.Left is IdentifierExpression)) return; if ((condition.Left as IdentifierExpression).Identifier != iteratorIdentifier.Identifier) return; Expression end; if (iterator.Op == AssignmentOperatorType.Subtract) { if (condition.Op == BinaryOperatorType.GreaterThanOrEqual) { end = condition.Right; } else if (condition.Op == BinaryOperatorType.GreaterThan) { end = Expression.AddInteger(condition.Right, 1); } else { return; } } else { if (condition.Op == BinaryOperatorType.LessThanOrEqual) { end = condition.Right; } else if (condition.Op == BinaryOperatorType.LessThan) { end = Expression.AddInteger(condition.Right, -1); } else { return; } } Expression start; TypeReference typeReference = null; LocalVariableDeclaration varDecl = forStatement.Initializers[0] as LocalVariableDeclaration; if (varDecl != null) { if (varDecl.Variables.Count != 1 || varDecl.Variables[0].Name != iteratorIdentifier.Identifier || varDecl.Variables[0].Initializer == null) return; typeReference = varDecl.GetTypeForVariable(0); start = varDecl.Variables[0].Initializer; } else { statement = forStatement.Initializers[0] as ExpressionStatement; if (statement == null) return; AssignmentExpression assign = statement.Expression as AssignmentExpression; if (assign == null || assign.Op != AssignmentOperatorType.Assign) return; if (!(assign.Left is IdentifierExpression)) return; if ((assign.Left as IdentifierExpression).Identifier != iteratorIdentifier.Identifier) return; start = assign.Right; } ReplaceCurrentNode( new ForNextStatement { TypeReference = typeReference, VariableName = iteratorIdentifier.Identifier, Start = start, End = end, Step = (step == 1) ? null : new PrimitiveExpression(step, step.ToString(System.Globalization.NumberFormatInfo.InvariantInfo)), EmbeddedStatement = forStatement.EmbeddedStatement }); }
public virtual bool VisitForStatement(ForStatement forStatement, object d) { if ((forStatement == null)) { return SetFailure(); } if ((d == null)) { return SetFailure(); } if ((forStatement.Initializers == null)) { return SetFailure(); } if ((forStatement.Condition == null)) { return SetFailure(); } if ((forStatement.Iterator == null)) { return SetFailure(); } if ((forStatement.EmbeddedStatement == null)) { return SetFailure(); } if(forStatement.GetType() != d.GetType()) {return SetFailure();} var data = (ForStatement)d; if (!IsMatch(forStatement, data)) { return SetFailure(); } if (forStatement.Initializers.Count == data.Initializers.Count) { for (int i=0; i<forStatement.Initializers.Count;i++) { Statement o = forStatement.Initializers[i]; if(o == null){return SetFailure();} if((bool)o.AcceptVisitor(this, data.Initializers[i]) == false) return SetFailure(); } } else { return SetFailure(); } forStatement.Condition.AcceptVisitor(this, data.Condition); if (forStatement.Iterator.Count == data.Iterator.Count) { for (int i=0; i<forStatement.Iterator.Count;i++) { Statement o = forStatement.Iterator[i]; if(o == null){return SetFailure();} if((bool)o.AcceptVisitor(this, data.Iterator[i]) == false) return SetFailure(); } } else { return SetFailure(); } return forStatement.EmbeddedStatement.AcceptVisitor(this, data.EmbeddedStatement); }
public override object VisitForStatement(ForStatement forStatement, object data) { CodeIterationStatement forLoop = new CodeIterationStatement(); breakableStack.Push(new Breakable()); codeStack.Push(NullStmtCollection); if (forStatement.Initializers.Count > 0) { if (forStatement.Initializers.Count > 1) { throw new NotSupportedException("CodeDom does not support Multiple For-Loop Initializer Statements"); } foreach (object o in forStatement.Initializers) { if (o is Expression) { forLoop.InitStatement = new CodeExpressionStatement((CodeExpression)((Expression)o).AcceptVisitor(this, data)); } if (o is Statement) { forLoop.InitStatement = (CodeStatement)((Statement)o).AcceptVisitor(this, data); } } } else { // RG: need to handle empty InitStatement forLoop.InitStatement = new CodeExpressionStatement(new CodeSnippetExpression()); } if (forStatement.Condition == null) { forLoop.TestExpression = new CodePrimitiveExpression(true); } else { forLoop.TestExpression = (CodeExpression)forStatement.Condition.AcceptVisitor(this, data); } codeStack.Push(forLoop.Statements); forStatement.EmbeddedStatement.AcceptVisitor(this, data); codeStack.Pop(); if (forStatement.Iterator.Count > 0) { if (forStatement.Initializers.Count > 1) { throw new NotSupportedException("CodeDom does not support Multiple For-Loop Iterator Statements"); } foreach (Statement stmt in forStatement.Iterator) { forLoop.IncrementStatement = (CodeStatement)stmt.AcceptVisitor(this, data); } } else { // RG: need to handle empty IncrementStatement forLoop.IncrementStatement = new CodeExpressionStatement(new CodeSnippetExpression()); } codeStack.Pop(); Breakable breakable = breakableStack.Pop(); if (breakable.IsContinue) { forLoop.Statements.Add(new CodeSnippetStatement()); forLoop.Statements.Add(new CodeLabeledStatement("continue" + breakable.Id, new CodeExpressionStatement(new CodeSnippetExpression()))); } AddStmt(forLoop); if (breakable.IsBreak) { AddStmt(new CodeLabeledStatement("break" + breakable.Id, new CodeExpressionStatement(new CodeSnippetExpression()))); } return forLoop; }
public void VisitStatement (ForStatement statement, MethodProperties meth) { meth.CyclometricComplexity++; VisitExpression(statement.Condition, meth); foreach(var innerStatement in ((ForStatement)statement).EmbeddedStatement.Children) VisitStatement(innerStatement, meth); }
public override object VisitForStatement(ForStatement forStatement, object data) { // uses LocalVariableDeclaration, we just have to put the end location on the stack if (forStatement.EmbeddedStatement.EndLocation.IsEmpty) { return base.VisitForStatement(forStatement, data); } else { endLocationStack.Push(forStatement.EmbeddedStatement.EndLocation); base.VisitForStatement(forStatement, data); endLocationStack.Pop(); return null; } }
public object VisitForStatement(ForStatement forStatement, object data) { throw new NotImplementedException (); }
public virtual object TrackedVisitForStatement(ForStatement forStatement, object data) { return base.VisitForStatement(forStatement, data); }
public virtual object VisitForStatement(ForStatement forStatement, object data) { Debug.Assert((forStatement != null)); Debug.Assert((forStatement.Initializers != null)); Debug.Assert((forStatement.Condition != null)); Debug.Assert((forStatement.Iterator != null)); Debug.Assert((forStatement.EmbeddedStatement != null)); foreach (Statement o in forStatement.Initializers) { Debug.Assert(o != null); o.AcceptVisitor(this, data); } forStatement.Condition.AcceptVisitor(this, data); foreach (Statement o in forStatement.Iterator) { Debug.Assert(o != null); o.AcceptVisitor(this, data); } return forStatement.EmbeddedStatement.AcceptVisitor(this, data); }
public override object TrackedVisitForStatement(ForStatement forStatement, object data) { foreach (Statement initializer in forStatement.Initializers) { initializer.AcceptVisitor(this, data); } this.AppendIndented("while "); forStatement.Condition.AcceptVisitor(this, data); this.Append(":"); this.AppendLine(); this.IncreaseIndent(); forStatement.EmbeddedStatement.AcceptVisitor(this, data); foreach (Statement iterator in forStatement.Iterator) { iterator.AcceptVisitor(this, data); } this.DecreaseIndent(); return null; }
void EmbeddedStatement( #line 1473 "cs.ATG" out Statement statement) { #line 1475 "cs.ATG" TypeReference type = null; Expression expr = null; Statement embeddedStatement = null; statement = null; #line 1481 "cs.ATG" Location startLocation = la.Location; if (la.kind == 16) { Block( #line 1483 "cs.ATG" out statement); } else if (la.kind == 11) { lexer.NextToken(); #line 1486 "cs.ATG" statement = new EmptyStatement(); } else if ( #line 1489 "cs.ATG" UnCheckedAndLBrace()) { #line 1489 "cs.ATG" Statement block; bool isChecked = true; if (la.kind == 58) { lexer.NextToken(); } else if (la.kind == 118) { lexer.NextToken(); #line 1490 "cs.ATG" isChecked = false; } else SynErr(196); Block( #line 1491 "cs.ATG" out block); #line 1491 "cs.ATG" statement = isChecked ? (Statement)new CheckedStatement(block) : (Statement)new UncheckedStatement(block); } else if (la.kind == 79) { IfStatement( #line 1494 "cs.ATG" out statement); } else if (la.kind == 110) { lexer.NextToken(); #line 1496 "cs.ATG" List<SwitchSection> switchSections = new List<SwitchSection>(); Expect(20); Expr( #line 1497 "cs.ATG" out expr); Expect(21); Expect(16); SwitchSections( #line 1498 "cs.ATG" switchSections); Expect(17); #line 1499 "cs.ATG" statement = new SwitchStatement(expr, switchSections); } else if (la.kind == 125) { lexer.NextToken(); Expect(20); Expr( #line 1502 "cs.ATG" out expr); Expect(21); EmbeddedStatement( #line 1503 "cs.ATG" out embeddedStatement); #line 1504 "cs.ATG" statement = new DoLoopStatement(expr, embeddedStatement, ConditionType.While, ConditionPosition.Start); } else if (la.kind == 65) { lexer.NextToken(); EmbeddedStatement( #line 1506 "cs.ATG" out embeddedStatement); Expect(125); Expect(20); Expr( #line 1507 "cs.ATG" out expr); Expect(21); Expect(11); #line 1508 "cs.ATG" statement = new DoLoopStatement(expr, embeddedStatement, ConditionType.While, ConditionPosition.End); } else if (la.kind == 76) { lexer.NextToken(); #line 1510 "cs.ATG" List<Statement> initializer = null; List<Statement> iterator = null; Expect(20); if (StartOf(6)) { ForInitializer( #line 1511 "cs.ATG" out initializer); } Expect(11); if (StartOf(6)) { Expr( #line 1512 "cs.ATG" out expr); } Expect(11); if (StartOf(6)) { ForIterator( #line 1513 "cs.ATG" out iterator); } Expect(21); EmbeddedStatement( #line 1514 "cs.ATG" out embeddedStatement); #line 1514 "cs.ATG" statement = new ForStatement(initializer, expr, iterator, embeddedStatement); } else if (la.kind == 77) { lexer.NextToken(); Expect(20); Type( #line 1516 "cs.ATG" out type); Identifier(); #line 1516 "cs.ATG" string varName = t.val; Expect(81); Expr( #line 1517 "cs.ATG" out expr); Expect(21); EmbeddedStatement( #line 1518 "cs.ATG" out embeddedStatement); #line 1519 "cs.ATG" statement = new ForeachStatement(type, varName , expr, embeddedStatement); } else if (la.kind == 53) { lexer.NextToken(); Expect(11); #line 1522 "cs.ATG" statement = new BreakStatement(); } else if (la.kind == 61) { lexer.NextToken(); Expect(11); #line 1523 "cs.ATG" statement = new ContinueStatement(); } else if (la.kind == 78) { GotoStatement( #line 1524 "cs.ATG" out statement); } else if ( #line 1526 "cs.ATG" IsYieldStatement()) { Expect(132); if (la.kind == 101) { lexer.NextToken(); Expr( #line 1527 "cs.ATG" out expr); #line 1527 "cs.ATG" statement = new YieldStatement(new ReturnStatement(expr)); } else if (la.kind == 53) { lexer.NextToken(); #line 1528 "cs.ATG" statement = new YieldStatement(new BreakStatement()); } else SynErr(197); Expect(11); } else if (la.kind == 101) { lexer.NextToken(); if (StartOf(6)) { Expr( #line 1531 "cs.ATG" out expr); } Expect(11); #line 1531 "cs.ATG" statement = new ReturnStatement(expr); } else if (la.kind == 112) { lexer.NextToken(); if (StartOf(6)) { Expr( #line 1532 "cs.ATG" out expr); } Expect(11); #line 1532 "cs.ATG" statement = new ThrowStatement(expr); } else if (StartOf(6)) { StatementExpr( #line 1535 "cs.ATG" out statement); while (!(la.kind == 0 || la.kind == 11)) {SynErr(198); lexer.NextToken(); } Expect(11); } else if (la.kind == 114) { TryStatement( #line 1538 "cs.ATG" out statement); } else if (la.kind == 86) { lexer.NextToken(); Expect(20); Expr( #line 1541 "cs.ATG" out expr); Expect(21); EmbeddedStatement( #line 1542 "cs.ATG" out embeddedStatement); #line 1542 "cs.ATG" statement = new LockStatement(expr, embeddedStatement); } else if (la.kind == 121) { #line 1545 "cs.ATG" Statement resourceAcquisitionStmt = null; lexer.NextToken(); Expect(20); ResourceAcquisition( #line 1547 "cs.ATG" out resourceAcquisitionStmt); Expect(21); EmbeddedStatement( #line 1548 "cs.ATG" out embeddedStatement); #line 1548 "cs.ATG" statement = new UsingStatement(resourceAcquisitionStmt, embeddedStatement); } else if (la.kind == 119) { lexer.NextToken(); Block( #line 1551 "cs.ATG" out embeddedStatement); #line 1551 "cs.ATG" statement = new UnsafeStatement(embeddedStatement); } else if (la.kind == 74) { lexer.NextToken(); Expect(20); Type( #line 1554 "cs.ATG" out type); #line 1554 "cs.ATG" if (type == null || type.PointerNestingLevel == 0) Error("can only fix pointer types"); List<VariableDeclaration> pointerDeclarators = new List<VariableDeclaration>(1); Identifier(); #line 1557 "cs.ATG" string identifier = t.val; Expect(3); Expr( #line 1558 "cs.ATG" out expr); #line 1558 "cs.ATG" pointerDeclarators.Add(new VariableDeclaration(identifier, expr)); while (la.kind == 14) { lexer.NextToken(); Identifier(); #line 1560 "cs.ATG" identifier = t.val; Expect(3); Expr( #line 1561 "cs.ATG" out expr); #line 1561 "cs.ATG" pointerDeclarators.Add(new VariableDeclaration(identifier, expr)); } Expect(21); EmbeddedStatement( #line 1563 "cs.ATG" out embeddedStatement); #line 1563 "cs.ATG" statement = new FixedStatement(type, pointerDeclarators, embeddedStatement); } else SynErr(199); #line 1565 "cs.ATG" if (statement != null) { statement.StartLocation = startLocation; statement.EndLocation = t.EndLocation; } }