override public void OnYieldStatement(YieldStatement node)
{
if (_state.CurrentTryBlockDepth > 0)
{
Error(CompilerErrorFactory.YieldInsideTryBlock(node));
}
}
public void YieldReturnStatementTest()
{
YieldStatement yieldStmt = ParseUtilCSharp.ParseStatement <YieldStatement>("yield return \"Foo\";");
PrimitiveExpression expr = (PrimitiveExpression)yieldStmt.Expression;
Assert.AreEqual("Foo", expr.Value);
}
public override void OnYieldStatement(YieldStatement node)
{
noReturnStatement = false;
IProjectContent pc = context != null ? context.ProjectContent : ParserService.CurrentProjectContent;
IReturnType enumerable = new GetClassReturnType(pc, "System.Collections.Generic.IEnumerable", 1);
// Prevent creating an infinite number of InferredReturnTypes in inferring cycles
parentReturnType.expression = new NullLiteralExpression();
IReturnType returnType;
if (node.Expression == null)
{
returnType = ConvertVisitor.GetDefaultReturnType(pc);
}
else
{
returnType = new BooResolver().GetTypeOfExpression(node.Expression, context);
}
if (returnType != null)
{
returnType.GetUnderlyingClass(); // force to infer type
}
if (parentReturnType.expression == null)
{
// inferrence cycle with parentReturnType
returnType = new GetClassReturnType(pc, "?", 0);
}
parentReturnType.expression = null;
result = new ConstructedReturnType(enumerable, new IReturnType[] { returnType });
}
public void AddYieldStatement(YieldStatement stmt)
{
if (null == _yieldStatements)
{
_yieldStatements = new List();
}
_yieldStatements.Add(stmt);
}
public override void Switch(IAstTransformer transformer, out Node resultingNode)
{
YieldStatement thisNode = (YieldStatement)this;
Statement resultingTypedNode = thisNode;
transformer.OnYieldStatement(thisNode, ref resultingTypedNode);
resultingNode = resultingTypedNode;
}
public override void LeaveYieldStatement(YieldStatement node)
{
if (null == node.Expression)
{
return;
}
CheckExpressionType(node.Expression);
}
override public void OnYieldStatement(YieldStatement node)
{
WriteIndented();
WriteKeyword("yield ");
Visit(node.Expression);
Visit(node.Modifier);
WriteLine();
}
public override void LeaveYieldStatement(YieldStatement node)
{
if (node.Expression == null)
{
return;
}
TryToReify(node.Expression, GeneratorItemTypeFrom(_currentMethod.ReturnType) ?? TypeSystemServices.ObjectArrayType);
}
public override void visit_yield_statement(YieldStatement stmt)
{
if (unreachable(stmt))
{
return;
}
stmt.accept_children(this);
}
public object VisitYieldStatement(YieldStatement yieldStatement, object data)
{
ReturnStatement rs = yieldStatement.Statement as ReturnStatement;
if (rs == null)
{
return(new B.ReturnStatement(GetLexicalInfo(yieldStatement)));
}
return(new B.YieldStatement(GetLexicalInfo(yieldStatement), ConvertExpression(rs.Expression)));
}
public void ParseYieldStatementTest()
{
//Create parser
StatementParser statementParser = new StatementParser(Init("yield;"));
YieldStatement parsedYield = statementParser.ParseYieldStatement();
//Test yield instance
Assert.AreEqual(typeof(YieldStatement), parsedYield.GetType());
Assert.AreEqual("yield;", parsedYield.ToString());
}
public DataType VisitYield(YieldStatement y)
{
if (y.Expression != null)
{
return(analyzer.TypeFactory.CreateList(y.Expression.Accept(this)));
}
else
{
return(DataType.None);
}
}
public void TestYieldStmt1()
{
Boo.Lang.Compiler.Ast.Module module = ParseTestCase("yield_stmt_1.boo");
Method m = (Method)module.Members[0];
ForStatement fs = (ForStatement)m.Body.Statements[0];
YieldStatement ys = (YieldStatement)fs.Block.Statements[0];
Assert.AreEqual("i", ((ReferenceExpression)ys.Expression).Name);
Assert.AreEqual(StatementModifierType.If, ys.Modifier.Type);
}
private void TryInferMethodReturnType(YieldStatement node)
{
var methodNode = node.GetAncestor <Method>();
var method = methodNode.Entity as InternalMethod;
if (method == null || (method.ReturnType != TypeSystemServices.VoidType && method.ReturnType != null))
{
return;
}
methodNode.ReturnType = new SimpleTypeReference(TypeSystemServices.IEnumeratorType.Name);
}
override public void LeaveYieldStatement(YieldStatement node)
{
Block block = new Block();
block.Add(
new ReturnStatement(
node.LexicalInfo,
CreateYieldInvocation(node.Expression),
null));
block.Add(CreateLabel(node));
ReplaceCurrentNode(block);
}
public override void OnYieldStatement(YieldStatement node)
{
Write(Indent());
Write("yield return ");
if (node.Expression == null)
{
Write("null");
}
else
{
Visit(node.Expression);
}
WriteLine(";");
}
public void Visit(YieldStatement astLeaf)
{
state.SetCursor(astLeaf);
Context yieldContext;
if (astLeaf.Expr.TryEvaluate(state, out yieldContext))
{
state.PushStatement(SyntaxHelper.AppendMember(
yieldContext.FullPath,
yieldContext.Symbol.IsString(),
astLeaf.Type == TokenType.Encoded)
);
} else
{
//Unknown Member could also be a HelperCall with implied this as Parameter
if (astLeaf.Expr is MemberExpression)
astLeaf.TransformToHelperCall().Accept(this);
}
}
public override void visit_yield_statement(YieldStatement stmt)
{
if (!is_in_coroutine())
{
return;
}
if (stmt.yield_expression == null)
{
int state = emit_context.next_coroutine_state++;
ccode.add_assignment(CCodeMemberAccess.pointer(new CCodeIdentifier("_data_"), "_state_"), new CCodeConstant(state.ToString()));
ccode.add_return(new CCodeConstant("FALSE"));
ccode.add_label("_state_%d".printf(state));
ccode.add_statement(new CCodeEmptyStatement());
return;
}
if (stmt.yield_expression.error)
{
stmt.error = true;
return;
}
ccode.add_expression(get_cvalue(stmt.yield_expression));
if (stmt.tree_can_fail && stmt.yield_expression.tree_can_fail)
{
// simple case, no node breakdown necessary
add_simple_check(stmt.yield_expression);
}
/* free temporary objects */
foreach (var value in temp_ref_values)
{
ccode.add_expression(destroy_value(value));
}
temp_ref_values.Clear();
}
override public void OnYieldStatement(YieldStatement node)
{
if (_state.TryBlockDepth == _state.ProtectedBlockDepth)
{
// we are currently only in the protected blocks, not in any "except" or "ensure" blocks.
foreach (TryStatement tryBlock in _state.TryBlocks)
{
// only allow yield in the try part of try-ensure blocks, fail if it is a try-except block
if (tryBlock.FailureBlock != null || tryBlock.ExceptionHandlers.Count > 0)
{
Error(CompilerErrorFactory.YieldInsideTryExceptOrEnsureBlock(node));
break;
}
}
}
else
{
Error(CompilerErrorFactory.YieldInsideTryExceptOrEnsureBlock(node));
}
}
/// <summary>
/// Interpret YieldStatement
/// </summary>
/// <param name="statement">YieldStatement to interpret</param>
public override void Visit(YieldStatement statement)
{
if (YieldStack.Count == 0)
{
return;
}
//Pop from YieldStack and lets interpet it
YieldElement yieldElement = YieldStack.Pop();
if (yieldElement != null && yieldElement.GetRootElement() != null)
{
//Let's copy yieldstack, because there are possible yields in the yield.
Stack <YieldElement> tempYieldStack = new Stack <YieldElement>();
List <YieldElement> yieldList = YieldStack.ToList();
foreach (YieldElement yieldNode in yieldList)
{
tempYieldStack.Push(yieldNode);
}
//Lets interpret it with specific symboltable
SymbolTable temp = (SymbolTable)SymbolTable.Clone();
SymbolTable = yieldElement.GetSymbolTable();
yieldElement.GetRootElement().AcceptVisitor(this);
//Add some content when node is an expression or embedding
if (yieldElement.GetRootElement() is Expression || yieldElement.GetRootElement() is Embedding)
{
XHTMLElement element = new XHTMLElement(TextValue, Current);
element.SetTagState(false);
AddElement(element);
}
//Restore symboltable
SymbolTable = temp;
//Restore YieldStack in original shape before interpreting
YieldStack = tempYieldStack;
}
}
public void Visit(YieldStatement astLeaf)
{
state.SetCursor(astLeaf);
Context yieldContext;
if (astLeaf.Expr.TryEvaluate(state, out yieldContext))
{
state.PushStatement(SyntaxHelper.AppendMember(
yieldContext.FullPath,
yieldContext.Symbol.IsString(),
astLeaf.Type == TokenType.Encoded)
);
}
else
{
//Unknown Member could also be a HelperCall with implied this as Parameter
if (astLeaf.Expr is MemberExpression)
{
astLeaf.TransformToHelperCall().Accept(this);
}
}
}
override public void LeaveYieldStatement(YieldStatement node)
{
TryStatementInfo currentTry = (_tryStatementStack.Count > 0) ? _tryStatementStack.Peek() : null;
if (currentTry != null)
{
ConvertTryStatement(currentTry);
}
Block block = new Block();
block.Add(
new ReturnStatement(
node.LexicalInfo,
CreateYieldInvocation(node.LexicalInfo, _labels.Count, node.Expression),
null));
block.Add(CreateLabel(node));
// setting the state back to the "running" state not required, as that state has the same ensure blocks
// as the state we are currently in.
// if (currentTry != null) {
// block.Add(SetStateTo(currentTry._stateNumber));
// }
ReplaceCurrentNode(block);
}
public override object Visit (Yield yieldStatement)
{
var result = new YieldStatement ();
var location = LocationsBag.GetLocations (yieldStatement);
result.AddChild (new CSharpTokenNode (Convert (yieldStatement.loc), "yield".Length), YieldStatement.YieldKeywordRole);
if (location != null)
result.AddChild (new CSharpTokenNode (Convert (location[0]), "return".Length), YieldStatement.ReturnKeywordRole);
if (yieldStatement.Expr != null)
result.AddChild ((INode)yieldStatement.Expr.Accept (this), YieldStatement.Roles.Expression);
if (location != null)
result.AddChild (new CSharpTokenNode (Convert (location[1]), ";".Length), YieldStatement.Roles.Semicolon);
return result;
}
public sealed override object VisitYieldStatement(YieldStatement yieldStatement, object data) {
BeginVisit(yieldStatement);
object result = TrackedVisitYieldStatement(yieldStatement, data);
EndVisit(yieldStatement);
return result;
}
protected internal virtual void PostWalk(YieldStatement node) { }
public virtual object VisitYieldStatement(YieldStatement yieldStatement, object data) {
Debug.Assert((yieldStatement != null));
Debug.Assert((yieldStatement.Statement != null));
nodeStack.Push(yieldStatement.Statement);
yieldStatement.Statement.AcceptVisitor(this, data);
yieldStatement.Statement = ((Statement)(nodeStack.Pop()));
return null;
}
private void Process_Yield_Statement(StringBuilder sb, YieldStatement statement)
{
sb.Append("yield ");
if (statement.Expression == null)
{
sb.Append("break;");
}
else
{
sb.Append("return ").Append(FormatExpression(statement.Expression)).Append(";");
}
}
// YieldStatement
public override bool Walk(YieldStatement node)
{
return false;
}
public override ControlFlowNode VisitYieldStatement(YieldStatement yieldStatement, ControlFlowNode data)
{
return(CreateConnectedEndNode(yieldStatement, data));
}
public virtual object VisitYieldStatement(YieldStatement yieldStatement, object data) {
throw new global::System.NotImplementedException("YieldStatement");
}
public void VisitYieldStatement(YieldStatement yieldStmt)
{
}
public virtual object TrackedVisitYieldStatement(YieldStatement yieldStatement, object data) {
return base.VisitYieldStatement(yieldStatement, data);
}
void EmbeddedStatement(
#line 1528 "cs.ATG"
out Statement statement) {
#line 1530 "cs.ATG"
TypeReference type = null;
Expression expr = null;
Statement embeddedStatement = null;
statement = null;
#line 1536 "cs.ATG"
Location startLocation = la.Location;
if (la.kind == 16) {
Block(
#line 1538 "cs.ATG"
out statement);
} else if (la.kind == 11) {
lexer.NextToken();
#line 1541 "cs.ATG"
statement = new EmptyStatement();
} else if (
#line 1544 "cs.ATG"
UnCheckedAndLBrace()) {
#line 1544 "cs.ATG"
Statement block; bool isChecked = true;
if (la.kind == 58) {
lexer.NextToken();
} else if (la.kind == 118) {
lexer.NextToken();
#line 1545 "cs.ATG"
isChecked = false;
} else SynErr(197);
Block(
#line 1546 "cs.ATG"
out block);
#line 1546 "cs.ATG"
statement = isChecked ? (Statement)new CheckedStatement(block) : (Statement)new UncheckedStatement(block);
} else if (la.kind == 79) {
IfStatement(
#line 1549 "cs.ATG"
out statement);
} else if (la.kind == 110) {
lexer.NextToken();
#line 1551 "cs.ATG"
List<SwitchSection> switchSections = new List<SwitchSection>();
Expect(20);
Expr(
#line 1552 "cs.ATG"
out expr);
Expect(21);
Expect(16);
SwitchSections(
#line 1553 "cs.ATG"
switchSections);
Expect(17);
#line 1555 "cs.ATG"
statement = new SwitchStatement(expr, switchSections);
} else if (la.kind == 125) {
lexer.NextToken();
Expect(20);
Expr(
#line 1558 "cs.ATG"
out expr);
Expect(21);
EmbeddedStatement(
#line 1559 "cs.ATG"
out embeddedStatement);
#line 1560 "cs.ATG"
statement = new DoLoopStatement(expr, embeddedStatement, ConditionType.While, ConditionPosition.Start);
} else if (la.kind == 65) {
lexer.NextToken();
EmbeddedStatement(
#line 1562 "cs.ATG"
out embeddedStatement);
Expect(125);
Expect(20);
Expr(
#line 1563 "cs.ATG"
out expr);
Expect(21);
Expect(11);
#line 1564 "cs.ATG"
statement = new DoLoopStatement(expr, embeddedStatement, ConditionType.While, ConditionPosition.End);
} else if (la.kind == 76) {
lexer.NextToken();
#line 1566 "cs.ATG"
List<Statement> initializer = null; List<Statement> iterator = null;
Expect(20);
if (StartOf(6)) {
ForInitializer(
#line 1567 "cs.ATG"
out initializer);
}
Expect(11);
if (StartOf(6)) {
Expr(
#line 1568 "cs.ATG"
out expr);
}
Expect(11);
if (StartOf(6)) {
ForIterator(
#line 1569 "cs.ATG"
out iterator);
}
Expect(21);
EmbeddedStatement(
#line 1570 "cs.ATG"
out embeddedStatement);
#line 1571 "cs.ATG"
statement = new ForStatement(initializer, expr, iterator, embeddedStatement);
} else if (la.kind == 77) {
lexer.NextToken();
Expect(20);
Type(
#line 1573 "cs.ATG"
out type);
Identifier();
#line 1573 "cs.ATG"
string varName = t.val;
Expect(81);
Expr(
#line 1574 "cs.ATG"
out expr);
Expect(21);
EmbeddedStatement(
#line 1575 "cs.ATG"
out embeddedStatement);
#line 1576 "cs.ATG"
statement = new ForeachStatement(type, varName , expr, embeddedStatement);
} else if (la.kind == 53) {
lexer.NextToken();
Expect(11);
#line 1579 "cs.ATG"
statement = new BreakStatement();
} else if (la.kind == 61) {
lexer.NextToken();
Expect(11);
#line 1580 "cs.ATG"
statement = new ContinueStatement();
} else if (la.kind == 78) {
GotoStatement(
#line 1581 "cs.ATG"
out statement);
} else if (
#line 1583 "cs.ATG"
IsYieldStatement()) {
Expect(132);
if (la.kind == 101) {
lexer.NextToken();
Expr(
#line 1584 "cs.ATG"
out expr);
#line 1584 "cs.ATG"
statement = new YieldStatement(new ReturnStatement(expr));
} else if (la.kind == 53) {
lexer.NextToken();
#line 1585 "cs.ATG"
statement = new YieldStatement(new BreakStatement());
} else SynErr(198);
Expect(11);
} else if (la.kind == 101) {
lexer.NextToken();
if (StartOf(6)) {
Expr(
#line 1588 "cs.ATG"
out expr);
}
Expect(11);
#line 1588 "cs.ATG"
statement = new ReturnStatement(expr);
} else if (la.kind == 112) {
lexer.NextToken();
if (StartOf(6)) {
Expr(
#line 1589 "cs.ATG"
out expr);
}
Expect(11);
#line 1589 "cs.ATG"
statement = new ThrowStatement(expr);
} else if (StartOf(6)) {
StatementExpr(
#line 1592 "cs.ATG"
out statement);
while (!(la.kind == 0 || la.kind == 11)) {SynErr(199); lexer.NextToken(); }
Expect(11);
} else if (la.kind == 114) {
TryStatement(
#line 1595 "cs.ATG"
out statement);
} else if (la.kind == 86) {
lexer.NextToken();
Expect(20);
Expr(
#line 1598 "cs.ATG"
out expr);
Expect(21);
EmbeddedStatement(
#line 1599 "cs.ATG"
out embeddedStatement);
#line 1599 "cs.ATG"
statement = new LockStatement(expr, embeddedStatement);
} else if (la.kind == 121) {
#line 1602 "cs.ATG"
Statement resourceAcquisitionStmt = null;
lexer.NextToken();
Expect(20);
ResourceAcquisition(
#line 1604 "cs.ATG"
out resourceAcquisitionStmt);
Expect(21);
EmbeddedStatement(
#line 1605 "cs.ATG"
out embeddedStatement);
#line 1605 "cs.ATG"
statement = new UsingStatement(resourceAcquisitionStmt, embeddedStatement);
} else if (la.kind == 119) {
lexer.NextToken();
Block(
#line 1608 "cs.ATG"
out embeddedStatement);
#line 1608 "cs.ATG"
statement = new UnsafeStatement(embeddedStatement);
} else if (la.kind == 74) {
#line 1610 "cs.ATG"
Statement pointerDeclarationStmt = null;
lexer.NextToken();
Expect(20);
ResourceAcquisition(
#line 1612 "cs.ATG"
out pointerDeclarationStmt);
Expect(21);
EmbeddedStatement(
#line 1613 "cs.ATG"
out embeddedStatement);
#line 1613 "cs.ATG"
statement = new FixedStatement(pointerDeclarationStmt, embeddedStatement);
} else SynErr(200);
#line 1615 "cs.ATG"
if (statement != null) {
statement.StartLocation = startLocation;
statement.EndLocation = t.EndLocation;
}
}
public virtual void Visit(YieldStatement statement)
{
VisitSubNodes(statement);
}
public StringBuilder VisitYieldStatement(YieldStatement yieldStatement, int data)
{
throw new SLSharpException("SL# does not have iterators.");
}
public override void OnYieldStatement(YieldStatement node)
{
throw new NotImplementedException();
}
public void YieldBreakStatementTest()
{
YieldStatement yieldStmt = ParseUtilCSharp.ParseStatement <YieldStatement>("yield break;");
Assert.IsTrue(yieldStmt.IsYieldBreak);
}
public void VisitYield(YieldStatement y)
{
gen.Yield(y.Expression.Accept(xlat));
}
public override void PostWalk(YieldStatement node)
{
}
public void VisitYield(YieldStatement y)
{
this.w.Write("yield");
this.w.Write(" ");
y.Expression.Write(writer);
}
public override void Accept(YieldStatement yieldStmt)
{
yieldStmt.VisitChildren(this);
methodBuilder.Generator = true;
methodBuilder.EmitInstruction(yieldStmt.Location, Opcode.Yield);
}
public void VisitYield(YieldStatement y)
{
gen.Yield(y.Expression.Accept(xlat));
}
/// <summary>
/// Reads the next yield-statement from the file and returns it.
/// </summary>
/// <param name="parentProxy">Represents the parent item.</param>
/// <param name="unsafeCode">Indicates whether the code being parsed resides in an unsafe code block.</param>
/// <returns>Returns the statement.</returns>
private YieldStatement GetYieldStatement(CodeUnitProxy parentProxy, bool unsafeCode)
{
Param.AssertNotNull(parentProxy, "parentProxy");
Param.Ignore(unsafeCode);
var statementProxy = new CodeUnitProxy(this.document);
// Move past the yield keyword.
this.GetToken(statementProxy, TokenType.Yield, SymbolType.Other);
// Get the next word, which must either be break or return.
Symbol symbol = this.PeekNextSymbol();
YieldStatement.Type yieldType;
Expression returnValue = null;
if (symbol.SymbolType == SymbolType.Return)
{
yieldType = YieldStatement.Type.Return;
this.GetToken(statementProxy, TokenType.Return, SymbolType.Return);
// Get the expression to return.
returnValue = this.GetNextExpression(statementProxy, ExpressionPrecedence.None, unsafeCode);
if (returnValue == null)
{
throw this.CreateSyntaxException();
}
}
else if (symbol.SymbolType == SymbolType.Break)
{
yieldType = YieldStatement.Type.Break;
this.GetToken(statementProxy, TokenType.Break, SymbolType.Break);
}
else
{
throw this.CreateSyntaxException();
}
// Get the closing semicolon.
this.GetToken(statementProxy, TokenType.Semicolon, SymbolType.Semicolon);
// Create and return the statement.
var statement = new YieldStatement(statementProxy, yieldType, returnValue);
parentProxy.Children.Add(statement);
return statement;
}
// YieldStatement
public virtual bool Walk(YieldStatement node)
{
return true;
}
public virtual object VisitYieldStatement(YieldStatement yieldStatement, object data) {
Debug.Assert((yieldStatement != null));
Debug.Assert((yieldStatement.Statement != null));
return yieldStatement.Statement.AcceptVisitor(this, data);
}
public virtual void PostWalk(YieldStatement node)
{
}
public virtual object VisitYieldStatement(YieldStatement yieldStatement, object data)
{
throw new global::System.NotImplementedException("YieldStatement");
}
// YieldStatement
protected internal virtual bool Walk(YieldStatement node) { return true; }
public object VisitYieldStatement(YieldStatement yieldStatement, object data)
{
ReturnStatement rs = yieldStatement.Statement as ReturnStatement;
if (rs == null)
return new B.ReturnStatement(GetLexicalInfo(yieldStatement));
return new B.YieldStatement(GetLexicalInfo(yieldStatement), ConvertExpression(rs.Expression));
}
private void EmbeddedStatement(out ICSharpCode.NRefactory.Parser.AST.Statement statement)
{
TypeReference type = null;
Expression expr = null;
ICSharpCode.NRefactory.Parser.AST.Statement statement2 = null;
statement = null;
if (this.la.kind == 0x10)
{
this.Block(out statement);
}
else if (this.la.kind == 11)
{
base.lexer.NextToken();
statement = new EmptyStatement();
}
else if (this.UnCheckedAndLBrace())
{
ICSharpCode.NRefactory.Parser.AST.Statement statement3;
bool flag = true;
if (this.la.kind == 0x39)
{
base.lexer.NextToken();
}
else if (this.la.kind == 0x75)
{
base.lexer.NextToken();
flag = false;
}
else
{
base.SynErr(170);
}
this.Block(out statement3);
statement = flag ? ((ICSharpCode.NRefactory.Parser.AST.Statement) new CheckedStatement(statement3)) : ((ICSharpCode.NRefactory.Parser.AST.Statement) new UncheckedStatement(statement3));
}
else if (this.la.kind == 0x4e)
{
base.lexer.NextToken();
ICSharpCode.NRefactory.Parser.AST.Statement statement4 = null;
base.Expect(20);
this.Expr(out expr);
base.Expect(0x15);
this.EmbeddedStatement(out statement2);
if (this.la.kind == 0x42)
{
base.lexer.NextToken();
this.EmbeddedStatement(out statement4);
}
statement = (statement4 != null) ? new IfElseStatement(expr, statement2, statement4) : new IfElseStatement(expr, statement2);
if ((statement4 is IfElseStatement) && ((statement4 as IfElseStatement).TrueStatement.Count == 1))
{
(statement as IfElseStatement).ElseIfSections.Add(new ElseIfSection((statement4 as IfElseStatement).Condition, (statement4 as IfElseStatement).TrueStatement[0]));
(statement as IfElseStatement).ElseIfSections.AddRange((statement4 as IfElseStatement).ElseIfSections);
(statement as IfElseStatement).FalseStatement = (statement4 as IfElseStatement).FalseStatement;
}
}
else if (this.la.kind == 0x6d)
{
base.lexer.NextToken();
List<ICSharpCode.NRefactory.Parser.AST.SwitchSection> switchSections = new List<ICSharpCode.NRefactory.Parser.AST.SwitchSection>();
base.Expect(20);
this.Expr(out expr);
base.Expect(0x15);
base.Expect(0x10);
while ((this.la.kind == 0x36) || (this.la.kind == 0x3e))
{
ICSharpCode.NRefactory.Parser.AST.SwitchSection section;
this.SwitchSection(out section);
switchSections.Add(section);
}
base.Expect(0x11);
statement = new SwitchStatement(expr, switchSections);
}
else if (this.la.kind == 0x7c)
{
base.lexer.NextToken();
base.Expect(20);
this.Expr(out expr);
base.Expect(0x15);
this.EmbeddedStatement(out statement2);
statement = new DoLoopStatement(expr, statement2, ConditionType.While, ConditionPosition.Start);
}
else if (this.la.kind == 0x40)
{
base.lexer.NextToken();
this.EmbeddedStatement(out statement2);
base.Expect(0x7c);
base.Expect(20);
this.Expr(out expr);
base.Expect(0x15);
base.Expect(11);
statement = new DoLoopStatement(expr, statement2, ConditionType.While, ConditionPosition.End);
}
else if (this.la.kind == 0x4b)
{
base.lexer.NextToken();
List<ICSharpCode.NRefactory.Parser.AST.Statement> initializer = null;
List<ICSharpCode.NRefactory.Parser.AST.Statement> iterator = null;
base.Expect(20);
if (this.StartOf(5))
{
this.ForInitializer(out initializer);
}
base.Expect(11);
if (this.StartOf(5))
{
this.Expr(out expr);
}
base.Expect(11);
if (this.StartOf(5))
{
this.ForIterator(out iterator);
}
base.Expect(0x15);
this.EmbeddedStatement(out statement2);
statement = new ForStatement(initializer, expr, iterator, statement2);
}
else if (this.la.kind == 0x4c)
{
base.lexer.NextToken();
base.Expect(20);
this.Type(out type);
base.Expect(1);
string val = this.t.val;
Point location = this.t.Location;
base.Expect(80);
this.Expr(out expr);
base.Expect(0x15);
this.EmbeddedStatement(out statement2);
statement = new ForeachStatement(type, val, expr, statement2);
statement.EndLocation = this.t.EndLocation;
}
else if (this.la.kind == 0x34)
{
base.lexer.NextToken();
base.Expect(11);
statement = new BreakStatement();
}
else if (this.la.kind == 60)
{
base.lexer.NextToken();
base.Expect(11);
statement = new ContinueStatement();
}
else if (this.la.kind == 0x4d)
{
this.GotoStatement(out statement);
}
else if (this.IsYieldStatement())
{
base.Expect(1);
if (this.la.kind == 100)
{
base.lexer.NextToken();
this.Expr(out expr);
statement = new YieldStatement(new ReturnStatement(expr));
}
else if (this.la.kind == 0x34)
{
base.lexer.NextToken();
statement = new YieldStatement(new BreakStatement());
}
else
{
base.SynErr(0xab);
}
base.Expect(11);
}
else if (this.la.kind == 100)
{
base.lexer.NextToken();
if (this.StartOf(5))
{
this.Expr(out expr);
}
base.Expect(11);
statement = new ReturnStatement(expr);
}
else if (this.la.kind == 0x6f)
{
base.lexer.NextToken();
if (this.StartOf(5))
{
this.Expr(out expr);
}
base.Expect(11);
statement = new ThrowStatement(expr);
}
else if (this.StartOf(5))
{
this.StatementExpr(out statement);
base.Expect(11);
}
else if (this.la.kind == 0x71)
{
this.TryStatement(out statement);
}
else if (this.la.kind == 0x55)
{
base.lexer.NextToken();
base.Expect(20);
this.Expr(out expr);
base.Expect(0x15);
this.EmbeddedStatement(out statement2);
statement = new LockStatement(expr, statement2);
}
else if (this.la.kind == 120)
{
ICSharpCode.NRefactory.Parser.AST.Statement stmt = null;
base.lexer.NextToken();
base.Expect(20);
this.ResourceAcquisition(out stmt);
base.Expect(0x15);
this.EmbeddedStatement(out statement2);
statement = new UsingStatement(stmt, statement2);
}
else if (this.la.kind == 0x76)
{
base.lexer.NextToken();
this.Block(out statement2);
statement = new UnsafeStatement(statement2);
}
else if (this.la.kind == 0x49)
{
base.lexer.NextToken();
base.Expect(20);
this.Type(out type);
if (type.PointerNestingLevel == 0)
{
this.Error("can only fix pointer types");
}
List<VariableDeclaration> pointerDeclarators = new List<VariableDeclaration>(1);
base.Expect(1);
string name = this.t.val;
base.Expect(3);
this.Expr(out expr);
pointerDeclarators.Add(new VariableDeclaration(name, expr));
while (this.la.kind == 14)
{
base.lexer.NextToken();
base.Expect(1);
name = this.t.val;
base.Expect(3);
this.Expr(out expr);
pointerDeclarators.Add(new VariableDeclaration(name, expr));
}
base.Expect(0x15);
this.EmbeddedStatement(out statement2);
statement = new FixedStatement(type, pointerDeclarators, statement2);
}
else
{
base.SynErr(0xac);
}
}
// YieldStatement
public bool Walk(YieldStatement node)
{
return(Process(node));
}
public void VisitYieldStatement(YieldStatement yieldStmt)
{
yieldStmt.Expression.AcceptWalker(this);
}
public void PostWalk(YieldStatement node)
{
PostProcess(node);
}
public override object Visit (YieldBreak yieldBreakStatement)
{
var result = new YieldStatement ();
var location = LocationsBag.GetLocations (yieldBreakStatement);
result.AddChild (new CSharpTokenNode (Convert (yieldBreakStatement.loc), "yield".Length), YieldStatement.YieldKeywordRole);
if (location != null) {
result.AddChild (new CSharpTokenNode (Convert (location[0]), "break".Length), YieldStatement.BreakKeywordRole);
result.AddChild (new CSharpTokenNode (Convert (location[1]), ";".Length), YieldStatement.Roles.Semicolon);
}
return result;
}
override public void LeaveYieldStatement(YieldStatement node)
{
LeaveStatement(node);
}
private Statement ParseYieldStatement()
{
FunctionDefinition current = CurrentFunction;
if (current == null)
{
ReportSyntaxError(Resources.MisplacedYield);
return null;
}
_isGenerator = true;
current.IsGenerator = true;
if (_return)
{
ReportSyntaxError(Resources.ReturnInGenerator);
return null;
}
if (_isAsync)
{
ReportSyntaxError(Resources.YieldInAsyncFunction);
return null;
}
Eat(TokenKind.KeywordYield);
var start = GetStart();
YieldStatement s;
if (PeekToken(TokenKind.Semicolon))
s = new YieldStatement(null);
else
s = new YieldStatement(ParseExpression());
Eat(TokenKind.Semicolon);
s.SetLoc(_globalParent, start, GetEnd());
return s;
}
public override bool Walk(YieldStatement node)
{
node.Parent = _currentScope;
return base.Walk(node);
}
