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(); }