public void LabelProducesLabel()
{
var label = new LabelStatement("exit", JS.Return());
Assert.AreEqual("exit", label.Name);
Assert.AreEqual("return;", label.Statement.ToString());
Assert.AreEqual("exit:return;", label.ToString());
label.Name = "loop";
label.Statement = JS.For();
Assert.AreEqual("loop", label.Name);
Assert.AreEqual("for(;;);", label.Statement.ToString());
Assert.AreEqual("loop:for(;;);", label.ToString());
}
override public void LeaveLabelStatement(LabelStatement node)
{
CheckName(node, node.Name);
}
public override object Visit(LabeledStatement labeledStatement)
{
var result = new LabelStatement();
result.AddChild(Identifier.Create(labeledStatement.Name, Convert(labeledStatement.loc)), Roles.Identifier);
var location = LocationsBag.GetLocations(labeledStatement);
if (location != null)
result.AddChild(new CSharpTokenNode(Convert(location [0]), Roles.Colon), Roles.Colon);
return result;
}
public void Visit(LabelStatement expression)
{
if (!string.IsNullOrEmpty(expression.Name))
outStream.Write("{0}: ", expression.Name);
Visit(expression.Target);
}
public void VisitLabelStatement(LabelStatement statement)
{
Formatter.StartNode(statement);
Formatter.WriteIdentifier(statement.Label);
Formatter.WriteToken(":");
Formatter.EndNode();
}
public override void VisitLabelStatement(LabelStatement labelStatement) {
new LabelBlock(this, labelStatement).Emit();
}
public virtual void VisitLabelStatement(LabelStatement labelStatement)
{
DebugExpression(labelStatement);
StartNode(labelStatement);
WriteIdentifier(labelStatement.GetChildByRole(Roles.Identifier), BoxedTextColor.Label);
WriteToken(Roles.Colon, BoxedTextColor.Punctuation);
bool foundLabelledStatement = false;
for (AstNode tmp = labelStatement.NextSibling; tmp != null; tmp = tmp.NextSibling) {
if (tmp.Role == labelStatement.Role) {
foundLabelledStatement = true;
}
}
if (!foundLabelledStatement) {
// introduce an EmptyStatement so that the output becomes syntactically valid
WriteToken(Roles.Semicolon, BoxedTextColor.Punctuation);
}
NewLine();
EndNode(labelStatement);
}
public override bool Visit(LabelStatement node)
{
Visit((Statement)node);
traverse(node.stmt);
return(true);
}
private bool IsMatch(LabelStatement left, LabelStatement right)
{
return(left.Label == right.Label);
}
public StringBuilder VisitLabelStatement(LabelStatement labelStatement, int data)
{
throw new ASLException("ASL does not support labels.");
}
public override AstNode VisitLabelStatement(LabelStatement labelStatement, ICecilArgumentsResolver argumentsResolver)
{
return(labelStatement);
}
public void VBNetLabelStatementTest()
{
LabelStatement labelStmt = ParseUtilVBNet.ParseStatement <LabelStatement>("myLabel: Console.WriteLine()");
Assert.AreEqual("myLabel", labelStmt.Label);
}
public RedILNode VisitLabelStatement(LabelStatement labelStatement, State data)
{
throw new System.NotImplementedException();
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
internal void SetupDecoratedMode(IMutableOperand returnValueLocal, LabelStatement leaveLabel)
{
m_Mode |= MethodWriterModes.Decorated;
m_ReturnValueLocal = returnValueLocal;
m_LeaveLabel = leaveLabel;
}
public override bool Visit(LabelStatement node)
{
Visit((Statement)node);
TraverseSetParent(node, node.stmt);
return(true);
}
public virtual T Visit(LabelStatement node)
{
Visit((Statement)node);
return(traverse(node.stmt));
}
public override void Visit(LabelStatement node)
{
VisitNode(node.Target);
}
public override void Visit(LabelStatement node)
{
throw new NotImplementedException();
}
//Label is used like a block statement (with begin and end)
protected override void VisitLabelStatement(LabelStatement statement)
{
throw new NotImplementedException();
}
public override object VisitLabelStatement(LabelStatement labelStatement, object data)
{
// TODO
return(VisitChildren(labelStatement, data));
}
public override void VisitLabelStatement(LabelStatement labelStatement)
{
_result.Add(new JsLabelStatement(labelStatement.Label));
}
public override void LeaveLabelStatement(LabelStatement node)
{
OnStatement(node);
}
public LabelBlock(IEmitter emitter, LabelStatement labelStatement) : base(emitter, labelStatement) {
labelStatement_ = labelStatement;
}
public object VisitLabelStatement(LabelStatement labelStatement, object data)
{
throw new NotImplementedException();
}
public override void Visit(LabelStatement node) { this.action(node); }
public virtual S VisitLabelStatement(LabelStatement labelStatement, T data)
{
return(VisitChildren(labelStatement, data));
}
public override void VisitLabelStatement(LabelStatement labelStatement) {
throw new InvalidOperationException("Visited a LabelStatement in the statement compiler, this should have been taken care of in parent.");
}
override public void OnLabelStatement(LabelStatement node)
{
base.OnLabelStatement(node);
CheckName(node, node.Name);
}
public override object Visit (LabeledStatement labeledStatement)
{
var result = new LabelStatement ();
result.AddChild (new Identifier (labeledStatement.Name, Convert (labeledStatement.loc)), LabelStatement.Roles.Identifier);
return result;
}
public override void VisitLabelStatement (LabelStatement labelStatement)
{
base.VisitLabelStatement (labelStatement);
var ifs = labelStatement.NextSibling as IfElseStatement;
if (ifs == null || !ifs.FalseStatement.IsNull)
return;
var b = ifs.TrueStatement as BlockStatement;
if (b == null || b.Statements.Count == 0)
return;
var gt = b.Statements.Last () as GotoStatement;
if (gt == null || gt.Label != labelStatement.Label)
return;
if (labelStatement.GetParent<MethodDeclaration> ().Descendants.OfType<GotoStatement> ().Count () != 1)
return;
gt.Remove ();
b.Remove ();
var wh = new WhileStatement {
Condition = ifs.Condition.Clone (),
EmbeddedStatement = b,
};
ifs.ReplaceWith (wh);
labelStatement.Remove ();
}
string DoStatement(Statement s)
{
if (s is AssignmentStatement && !(s is AugmentedAssignmentStatement))
{
AssignmentStatement a = s as AssignmentStatement;
StringBuilder sb = new StringBuilder();
if (a.IsLocal)
{
sb.Append("local ");
}
for (int i = 0; i < a.Lhs.Count; i++)
{
sb.Append(DoExpr(a.Lhs[i]));
if (i != a.Lhs.Count - 1)
{
sb.Append(", ");
}
}
if (a.Rhs.Count > 0)
{
sb.Append(" = ");
for (int i = 0; i < a.Rhs.Count; i++)
{
sb.Append(DoExpr(a.Rhs[i]));
if (i != a.Rhs.Count - 1)
{
sb.Append(", ");
}
}
}
return(sb.ToString());
}
else if (s is AugmentedAssignmentStatement)
{
AugmentedAssignmentStatement a = s as AugmentedAssignmentStatement;
StringBuilder sb = new StringBuilder();
//sb.Append(DoExpr(a.Lhs[0]));
if (a.IsLocal)
{
sb.Append("local ");
}
sb.Append(DoExpr(a.Lhs[0]));
sb.Append(" = ");
sb.Append(DoExpr(a.Lhs[0]));
sb.Append(" " + ((BinOpExpr)a.Rhs[0]).Op + " ");
Expression assignment = ((BinOpExpr)a.Rhs[0]).Rhs;
//sb.Append(DoExpr((((BinOpExpr)a.Rhs[0]).Lhs)));
//sb.Append(((BinOpExpr)a.Rhs[0]).Op);
// it might mess up Order of Operations, so we need parens.
// x *= 6 + 2 != x = x * 6 + 2
sb.Append("(" + DoExpr(assignment) + ")");
return(sb.ToString());
}
else if (s is BreakStatement)
{
// HAHAHA this is incredibly simple...
return("break");
}
else if (s is CallStatement)
{
// Also incredibly simple...
CallStatement c = s as CallStatement;
return(DoExpr(c.Expression));
}
else if (s is DoStatement)
{
DoStatement d = s as DoStatement;
StringBuilder sb = new StringBuilder();
sb.Append("do" + EOL);
indent++;
sb.Append(DoChunk(d.Body));
sb.Append(nldedent() + "end");
return(sb.ToString());
}
else if (s is GenericForStatement)
{
GenericForStatement g = s as GenericForStatement;
StringBuilder sb = new StringBuilder();
sb.Append("for ");
for (int i = 0; i < g.VariableList.Count; i++)
{
sb.Append(g.VariableList[i].Name);
if (i != g.VariableList.Count - 1)
{
sb.Append(", ");
}
}
sb.Append(" in ");
for (int i = 0; i < g.Generators.Count; i++)
{
sb.Append(DoExpr(g.Generators[i]));
if (i != g.Generators.Count - 1)
{
sb.Append(", ");
}
}
sb.Append(" do" + EOL);
indent++;
sb.Append(DoChunk(g.Body));
sb.Append(nldedent() + "end");
return(sb.ToString());
}
else if (s is NumericForStatement)
{
NumericForStatement n = s as NumericForStatement;
StringBuilder sb = new StringBuilder();
sb.Append("for ");
sb.Append(n.Variable.Name);
sb.Append(" = ");
sb.Append(DoExpr(n.Start));
sb.Append(", ");
sb.Append(DoExpr(n.End));
if (n.Step != null)
{
sb.Append(", ");
sb.Append(DoExpr(n.Step));
}
sb.Append(" do" + EOL);
indent++;
sb.Append(DoChunk(n.Body));
sb.Append(nldedent() + "end");
return(sb.ToString());
}
else if (s is FunctionStatement)
{
FunctionStatement f = s as FunctionStatement;
StringBuilder sb = new StringBuilder();
sb.Append("function " + DoExpr(f.Name) + "(");
for (int i = 0; i < f.Arguments.Count; i++)
{
sb.Append(f.Arguments[i].Name);
if (i != f.Arguments.Count - 1 || f.IsVararg)
{
sb.Append(", ");
}
}
if (f.IsVararg)
{
sb.Append("...");
}
sb.Append(")");
if (f.Body.Count > 1)
{
sb.Append(EOL);
indent++;
sb.Append(DoChunk(f.Body));
sb.Append(nldedent());
sb.Append("end");
}
else if (f.Body.Count == 0)
{
sb.Append(" end");
}
else
{
sb.Append(" " + DoStatement(f.Body[0]));
sb.Append(" end");
}
return(sb.ToString());
}
else if (s is GotoStatement)
{
GotoStatement g = s as GotoStatement;
return("goto " + g.Label);
}
else if (s is IfStmt)
{
IfStmt i = s as IfStmt;
StringBuilder sb = new StringBuilder();
for (int x = 0; x < i.Clauses.Count; x++)
{
string ind = writeIndent();
indent++;
string ss = DoStatement(i.Clauses[x]);
if (x == 0)
{
sb.Append(ind + "if ");
sb.Append(ss);
}
else if (i.Clauses[x] is ElseStmt)
{
sb.Append(ind + "else" + EOL);
sb.Append(ss);
}
else
{
sb.Append(ind + "elseif " + ss);
}
if (x != i.Clauses.Count - 1)
{
sb.Append(EOL);
}
indent--;
}
sb.Append(EOL + writeIndent() + "end");
return(sb.ToString());
}
else if (s is LabelStatement)
{
LabelStatement l = s as LabelStatement;
return("::" + l.Label + "::");
}
else if (s is RepeatStatement)
{
RepeatStatement r = s as RepeatStatement;
StringBuilder sb = new StringBuilder();
sb.Append("repeat");
if (r.Body.Count == 1)
{
sb.Append(" " + DoStatement(r.Body[0]) + " ");
}
else
{
sb.Append(EOL);
indent++;
sb.Append(DoChunk(r.Body));
indent--;
}
sb.Append("until " + DoExpr(r.Condition));
return(sb.ToString());
}
else if (s is ReturnStatement)
{
ReturnStatement r = s as ReturnStatement;
StringBuilder sb = new StringBuilder();
sb.Append("return ");
for (int i = 0; i < r.Arguments.Count; i++)
{
sb.Append(DoExpr(r.Arguments[i]));
if (i != r.Arguments.Count - 1)
{
sb.Append(", ");
}
}
return(sb.ToString());
}
else if (s is UsingStatement)
{
UsingStatement u = s as UsingStatement;
StringBuilder sb = new StringBuilder();
sb.Append("do" + EOL);
indent++;
sb.Append(writeIndent() + "local ");
sb.Append(DoStatement(u.Vars));
sb.Append(EOL);
sb.Append(DoChunk(u.Body));
indent--;
sb.Append(EOL + writeIndent() + "end");
return(sb.ToString());
}
else if (s is WhileStatement)
{
WhileStatement w = s as WhileStatement;
StringBuilder sb = new StringBuilder();
sb.Append("while ");
sb.Append(DoExpr(w.Condition));
sb.Append(" do");
if (w.Body.Count == 1)
{
sb.Append(" " + DoStatement(w.Body[0]) + " ");
}
else
{
indent++;
sb.Append(DoChunk(w.Body));
indent--;
sb.Append(EOL);
}
sb.Append(writeIndent() + "end");
return(sb.ToString());
}
else if (s is ElseIfStmt)
{
ElseIfStmt e = s as ElseIfStmt;
string s2 = DoExpr(e.Condition) + " then" + EOL;
s2 += DoChunk(e.Body);
return(s2);
}
else if (s is ElseStmt)
{
return(DoChunk(((ElseStmt)s).Body));
}
throw new NotImplementedException(s.GetType().Name + " is not implemented");
}
public override void VisitLabelStatement (LabelStatement labelStatement)
{
base.VisitLabelStatement (labelStatement);
var t = labelStatement.GetParent <TryCatchStatement> ();
if (t == null)
return;
if (t.TryBlock.Statements.First () == labelStatement) {
labelStatement.Remove ();
t.Parent.InsertChildBefore (t, labelStatement, (Role<Statement>)t.Role);
}
}
public LabelDescriptor(LabelStatement labelStatement)
{
this.LabelStatement.Add(labelStatement);
}
public override void VisitMethodDeclaration (MethodDeclaration methodDeclaration)
{
base.VisitMethodDeclaration (methodDeclaration);
var gotos = methodDeclaration.Body.Descendants.OfType<GotoStatement> ().ToList ();
if (gotos.Count == 0)
return;
var loop = new WhileStatement {
Condition = new PrimitiveExpression (true),
};
var loopBlock = new BlockStatement ();
var loopSwitch = new SwitchStatement {
Expression = new IdentifierExpression ("_goto"),
};
var loopLabel = new LabelStatement {
Label = "_GOTO_LOOP",
};
loopBlock.Statements.Add (loopSwitch);
loop.EmbeddedStatement = loopBlock;
var firstLabel = methodDeclaration.Body.Descendants.First (x => /*(x is GotoStatement) ||*/ (x is LabelStatement && HasGoto ((LabelStatement)x)));
var stmtRole = (Role<Statement>)firstLabel.Role;
var block = firstLabel.Parent;
var labels = new List<Tuple<LabelStatement, List<AstNode>>> ();
labels.Add (new Tuple<LabelStatement, List<AstNode>> (null, new List<AstNode> ()));
var n = firstLabel.Parent.FirstChild;
while (n != null && !n.IsNull) {
var l = n as LabelStatement;
if (l != null && gotos.Any (x => x.Label == l.Label)) {
labels.Add (new Tuple<LabelStatement, List<AstNode>> (l, new List<AstNode> ()));
} else {
labels.Last ().Item2.Add (n);
}
var s = n.NextSibling;
n.Remove ();
n = s;
}
for (int i = 0; i < labels.Count; i++) {
var ls = labels [i];
var sec = new SwitchSection ();
sec.CaseLabels.Add (ls.Item1 != null ? new CaseLabel (new PrimitiveExpression (i)) : new CaseLabel ());
if (ls.Item2.Count == 0 || !StatementIsBranch (ls.Item2.Last ())) {
if (i + 1 < labels.Count) {
ls.Item2.Add (new GotoStatement (labels [i + 1].Item1.Label));
} else {
var br = new BreakStatement ();
br.AddAnnotation (new LabelStatement { Label = "_GOTO_LOOP" });
ls.Item2.Add (br);
}
}
sec.Statements.AddRange (ls.Item2.OfType<Statement> ());
loopSwitch.SwitchSections.Add (sec);
if (ls.Item1 != null) {
block.AddChild (
new VariableDeclarationStatement (new PrimitiveType ("number"), ls.Item1.Label, new PrimitiveExpression (i)),
stmtRole);
}
}
block.AddChild (
new VariableDeclarationStatement (new PrimitiveType ("number"), "_goto", new PrimitiveExpression (0)),
stmtRole);
block.AddChild (loopLabel, stmtRole);
block.AddChild (loop, stmtRole);
}
override public void OnLabelStatement(LabelStatement node)
{
WriteIndented(":");
WriteLine(node.Name);
}
public override void VisitLabelStatement (LabelStatement labelStatement)
{
base.VisitLabelStatement (labelStatement);
var safes = GetSafesToEnd (labelStatement);
if (safes.Count < 1)
return;
if (StatementIsBranch (safes.Last ()))
return;
var n = StatementGetNextStatement ((Statement)safes.Last ()) as LabelStatement;
if (n == null)
return;
labelStatement.Parent.InsertChildAfter (safes.Last (), new GotoStatement (n.Label), (Role<Statement>)labelStatement.Role);
}
public UnifiedElement VisitLabelStatement(
LabelStatement label, object data)
{
return(UnifiedLabelIdentifier.Create(label.Label));
}
public override void VisitLabelStatement (LabelStatement labelStatement)
{
base.VisitLabelStatement (labelStatement);
if (HasGoto (labelStatement) || HasBreakto (labelStatement)) {
return;
}
labelStatement.Remove ();
}
public void CSharpLabel2StatementTest()
{
LabelStatement labelStmt = ParseUtilCSharp.ParseStatement <LabelStatement>("yield: ; ");
Assert.AreEqual("yield", labelStmt.Label);
}
static bool HasGoto (LabelStatement label)
{
var m = label.GetParent<MethodDeclaration> ();
if (m == null)
return false;
return m.Descendants.OfType<GotoStatement> ().Any (x => x.Label == label.Label);
}
// Do the real work
protected void ParseStatementOrLocal_Helper(out Statement s, out LocalVarDecl v)
{
s = null;
v = null;
// For each statement, we know which type based off the first token.
// Expect for an identifier, in which case it could be a few things.
Token t = m_lexer.PeekNextToken();
#if false
// Skip past any ';' (as empty statements)
while(t.TokenType == Token.Type.cSemi)
{
ConsumeNextToken();
t = m_lexer.PeekNextToken();
}
#endif
if (IsStartOfExp(t))
{
FileRange f = BeginRange();
// This could be either an expression or a type
Exp e = ParseExp();
t = m_lexer.PeekNextToken();
// Case 1 - Var declaration:
// If an identifier follows, then we just read a type and this is
// a var declaration:
// Type id ';'
// Type id '=' exp ';'
if (t.TokenType == Token.Type.cId)
{
TypeSig tSig = this.ConvertExpToType(e);
Identifier id = ReadExpectedIdentifier();
v = new LocalVarDecl(id, tSig);
// Check for optional assignment (if there's an '=' after the name)
Token t3 = m_lexer.PeekNextToken();
if (t3.TokenType == Token.Type.cAssign)
{
ConsumeNextToken(); // '='
Exp eRHS = ParseExp(); // exp
ReadExpectedToken(Token.Type.cSemi); // ';'
SimpleObjExp oleft = new SimpleObjExp(id);
StatementExp se = new AssignStmtExp(oleft, eRHS);
s = new ExpStatement(se);
se.SetLocation(EndRange(f));
} else {
ReadExpectedToken(Token.Type.cSemi); // ';'
}
return;
} // end decl case
// Case 2 - label declaration
else if (t.TokenType == Token.Type.cColon)
{
SimpleObjExp o2 = e as SimpleObjExp;
if (o2 != null)
{
ConsumeNextToken(); // ':'
s = new LabelStatement(o2.Name);
return; // skip reading a ';'
}
ThrowError(new ParserErrorException(Code.cBadLabelDef, t.Location,
"Bad label definition (labels must be a single identifier)"));
} // end case for label decls
// Expect a StatementExp
else if (t.TokenType == Token.Type.cSemi) {
ReadExpectedToken(Token.Type.cSemi);
// Else we must be a StatementExp
StatementExp se = e as StatementExp;
if (se == null)
//this.ThrowError_ExpectedStatementExp(e.Location);
ThrowError(E_ExpectedStatementExp(e.Location));
se.SetLocation(EndRange(f));
s = new ExpStatement(se);
return;
}
ThrowError(E_UnexpectedToken(t));
} // end start of expressions
switch(t.TokenType)
{
// Empty statement
case Token.Type.cSemi:
ConsumeNextToken();
s = new EmptyStatement();
break;
// Return -> 'return' ';'
// | 'return' exp ';'
case Token.Type.cReturn:
{
ConsumeNextToken();
t = m_lexer.PeekNextToken();
Exp e = null;
if (t.TokenType != Token.Type.cSemi)
{
e = ParseExp();
}
ReadExpectedToken(Token.Type.cSemi);
s = new ReturnStatement(e);
}
break;
// Note that the semi colons are included inthe stmt
// IfSmt -> 'if' '(' exp ')' stmt:then
// IfSmt -> 'if' '(' exp ')' stmt:then 'else' stmt:else
case Token.Type.cIf:
{
ConsumeNextToken(); // 'if'
ReadExpectedToken(Token.Type.cLParen);
Exp exp = ParseExp();
ReadExpectedToken(Token.Type.cRParen);
Statement sThen = ParseStatement();
Statement sElse = null;
Token t2 = m_lexer.PeekNextToken();
if (t2.TokenType == Token.Type.cElse)
{
ConsumeNextToken(); // 'else'
sElse = ParseStatement();
}
s = new IfStatement(exp, sThen, sElse);
}
break;
case Token.Type.cSwitch:
s = ParseSwitchStatement();
break;
// Throw an expression
// ThrowStmt -> 'throw' objexp
case Token.Type.cThrow:
{
ConsumeNextToken(); // 'throw'
Exp oe = null;
if (m_lexer.PeekNextToken().TokenType != Token.Type.cSemi)
{
oe = ParseExp();
}
ReadExpectedToken(Token.Type.cSemi);
s = new ThrowStatement(oe);
}
break;
// try-catch-finally
case Token.Type.cTry:
s = ParseTryCatchFinallyStatement();
break;
// while loop
// 'while' '(' exp ')' stmt
case Token.Type.cWhile:
{
ConsumeNextToken(); // 'while'
ReadExpectedToken(Token.Type.cLParen);
Exp e = ParseExp();
ReadExpectedToken(Token.Type.cRParen);
Statement body = ParseStatement();
s = new WhileStatement(e, body);
}
break;
// do loop
// 'do' stmt 'while' '(' exp ')' ';'
case Token.Type.cDo:
{
ConsumeNextToken(); // 'do'
Statement body = ParseStatement();
ReadExpectedToken(Token.Type.cWhile);
ReadExpectedToken(Token.Type.cLParen);
Exp e = ParseExp();
ReadExpectedToken(Token.Type.cRParen);
ReadExpectedToken(Token.Type.cSemi);
s = new DoStatement(e, body);
}
break;
// goto
// 'goto' id:label ';'
case Token.Type.cGoto:
{
ConsumeNextToken(); // 'goto'
Identifier id = ReadExpectedIdentifier(); // id:label
ReadExpectedToken(Token.Type.cSemi); // ';'
s = new GotoStatement(id);
}
break;
// break
// 'break' ';'
case Token.Type.cBreak:
ConsumeNextToken();
ReadExpectedToken(Token.Type.cSemi);
s = new BreakStatement();
break;
// Continue
// 'continue' ';'
case Token.Type.cContinue:
ConsumeNextToken();
ReadExpectedToken(Token.Type.cSemi);
s = new ContinueStatement();
break;
// For-loop
case Token.Type.cFor:
s = ParseForStatement();
break;
// For-each
// -> 'foreach' '(' Type id 'in' exp:collection ')' stmt
case Token.Type.cForEach:
s = ParseForeachStatement();
break;
// BlockStatement - can be nested inside each other
// start with a '{', no terminating semicolon
case Token.Type.cLCurly:
{
s = ParseStatementBlock();
}
break;
default:
ThrowError(E_UnexpectedToken(t)); // unrecognized statement
break;
} // end switch
// Must have come up with something
Debug.Assert(s != null || v != null);
}
static bool HasBreakto (LabelStatement label)
{
var m = label.GetParent<MethodDeclaration> ();
if (m == null)
return false;
return m.Descendants.OfType<BreakStatement> ().Any (x => {
var l = x.Annotation<LabelStatement> ();
if (l == null)
return false;
return l.Label == label.Label;
});
}
public override void ExplicitVisit(LabelStatement fragment)
{
_fragments.Add(fragment);
}
public void VisitLabelStatement(LabelStatement labelStatement)
{
JsonObject statement = CreateJsonStatement(labelStatement);
statement.AddJsonValue("identifier", GetIdentifier(labelStatement.GetChildByRole(Roles.Identifier)));
Push(statement);
}
public virtual void Visit(LabelStatement node)
{
DefaultVisit(node);
}
protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
{
LabelStatement o = other as LabelStatement;
return(o != null && MatchString(this.Label, o.Label));
}
public override void VisitLabelStatement(LabelStatement labelStatement)
{
base.VisitLabelStatement(labelStatement);
CheckNamedResolveResult(null, labelStatement, AffectedEntity.Label, labelStatement.LabelToken, Modifiers.None);
}
public object VisitLabelStatement(LabelStatement labelStatement, object data)
{
return new B.LabelStatement(GetLexicalInfo(labelStatement), labelStatement.Label);
}
public StringBuilder VisitLabelStatement(LabelStatement labelStatement, int data)
{
throw new SLSharpException("SL# does not support labels.");
}
public void VisitLabelStatement(LabelStatement labelStatement)
{
throw new NotImplementedException();
}
public override void VisitLabelStatement(LabelStatement labelStatement)
{
// TODO
VisitChildren(labelStatement);
}
public virtual object VisitLabelStatement(LabelStatement labelStatement, object data) {
Debug.Assert((labelStatement != null));
return null;
}
public virtual void VisitLabelStatement(LabelStatement labelStatement)
{
if (this.ThrowException)
{
throw (Exception)this.CreateException(labelStatement);
}
}
public override void VisitLabelStatement(LabelStatement labelStatement)
{
Add(labelStatement);
base.VisitLabelStatement(labelStatement);
}
public override void VisitLabelStatement(LabelStatement labelStatement)
{
base.VisitLabelStatement(labelStatement);
CheckNamedResolveResult(null, labelStatement, AffectedEntity.Label, labelStatement.LabelToken, Modifiers.None);
}
public virtual object VisitLabelStatement(LabelStatement labelStatement, object data)
{
throw new global::System.NotImplementedException("LabelStatement");
}
public virtual void VisitLabelStatement (LabelStatement labelStatement)
{
VisitChildren (labelStatement);
}
public Node VisitLabelStatement(LabelStatement labelStatement)
{
return(CreateDummy(labelStatement));
}
public void VisitLabelStatement(LabelStatement labelStatement)
{
StartNode(labelStatement);
WriteIdentifier(labelStatement.Label);
WriteToken(Roles.Colon);
bool foundLabelledStatement = false;
for (AstNode tmp = labelStatement.NextSibling; tmp != null; tmp = tmp.NextSibling) {
if (tmp.Role == labelStatement.Role) {
foundLabelledStatement = true;
}
}
if (!foundLabelledStatement) {
// introduce an EmptyStatement so that the output becomes syntactically valid
WriteToken(Roles.Semicolon);
}
NewLine();
EndNode(labelStatement);
}
public override void VisitLabelStatement(LabelStatement labelStatement)
{
new LabelBlock(this, labelStatement).Emit();
}
