public override void VisitBreakStatement(BreakStatementSyntax node)
{
base.VisitBreakStatement(node);
StatementsAnalyzer statementsAnalyzer = this;
statementsAnalyzer.counter = checked (statementsAnalyzer.counter + 1);
}
void ExportStatement(BreakStatementSyntax ss)
{
var node = new ULStatementBreak();
node.Parent = currentBlock;
currentBlock.statements.Add(node);
}
private Doc PrintBreakStatementSyntax(BreakStatementSyntax node)
{
return(Concat(
this.PrintSyntaxToken(node.BreakKeyword),
this.PrintSyntaxToken(node.SemicolonToken)
));
}
public override void VisitBreakStatement(BreakStatementSyntax node)
{
if (m_InLoop <= 0 && m_InSwitch <= 0)
{
m_ExistBreak = true;
}
}
public override void VisitBreakStatement(BreakStatementSyntax node)
{
if (this.breakLocation != default(FlowLocation))
{
this.BranchToLocation(this.breakLocation, this.lexicalState);
}
}
public override SyntaxNode VisitBreakStatement(BreakStatementSyntax node)
{
SyntaxNode newNode = base.VisitBreakStatement(node);
newNode = AddTab(newNode);
return(newNode);
}
public override void VisitBreakStatement(BreakStatementSyntax node)
{
if (m_ContinueInfoStack.Count > 0)
{
var ci = m_ContinueInfoStack.Peek();
if (ci.IsIgnoreBreak)
{
return;
}
if (ci.HaveContinue)
{
CodeBuilder.AppendFormat("{0}{1} = true;", GetIndentString(), ci.BreakFlagVarName);
CodeBuilder.AppendLine();
}
bool isLastNode = IsLastNodeOfFor(node);
if (isLastNode)
{
CodeBuilder.AppendFormat("{0}do", GetIndentString());
CodeBuilder.AppendLine();
}
CodeBuilder.AppendFormat("{0}break;", GetIndentString());
CodeBuilder.AppendLine();
if (isLastNode)
{
CodeBuilder.AppendFormat("{0}end;", GetIndentString());
CodeBuilder.AppendLine();
}
}
}
public override void VisitBreakStatement(BreakStatementSyntax node)
{
if (m_InSwitch <= 0)
{
++m_BreakCount;
}
}
/// <summary>
/// 8.9.1
/// </summary>
public override void VisitBreakStatement(BreakStatementSyntax node)
{
var controlFlowTarget = this.controlFlowStack.Peek();
LLVM.BuildBr(this.builder, controlFlowTarget.End);
LLVM.PositionBuilderAtEnd(this.builder, LLVM.AppendBasicBlock(this.function, "UnreachableBreak"));
}
ULNode ExportStatement(BreakStatementSyntax ss)
{
var node = ULNode.NewControlNode(ULNode.name_break);
graph.Nodes.Add(node);
return(node);
}
public override IEnumerable <Instruction> VisitBreakStatement(BreakStatementSyntax node)
{
if (_enclosingLoop == null)
{
throw new UnsupportedSyntaxException($"no loop to attach the break statement to");
}
return(_CreateEnumerable(new Jump(_enclosingLoop.BreakLabel)));
}
public override SyntaxNode VisitBreakStatement(BreakStatementSyntax node)
{
if (RemoveTestTriviaAnnotation(node.GetLeadingTrivia()))
{
return(null);
}
return(base.VisitBreakStatement(node));
}
internal bool HasNonTrailingBreaks(SyntaxNode node, BreakStatementSyntax trailing)
{
//if our trailing 'break' is actually return, then /any/ break is non-trailing
if (node is BreakStatementSyntax && (trailing == null || !node.GetLocation().Equals(trailing.GetLocation())))
{
return(true);
}
return(node.DescendantNodes().Any(n => HasNonTrailingBreaks(n, trailing)));
}
public override SyntaxNode VisitBreakStatement(BreakStatementSyntax node)
{
if (currentForNode == null)
{
return(node);
}
breakStatements[currentForNode].Add(node);
return(node);
}
public override void VisitBreakStatement(BreakStatementSyntax node)
{
if (currentState.NextState.BreakState == null)
{
throw new Exception();
}
CloseTo(currentState, currentState.NextState.BreakState);
}
public override void VisitBreakStatement(BreakStatementSyntax node)
{
if (entryPoint.IsMethodLevel() && node.IsParent <AnonymousFunctionExpressionSyntax>())
{
return;
}
noscounter++;
base.VisitBreakStatement(node);
}
public override void VisitBreakStatement(BreakStatementSyntax node)
{
SyntaxNode c = node;
if (!IsSwitchBreak(c))
{
IndentWriteLine("break");
}
}
public void AnalyzeNode(SyntaxNode node, SemanticModel semanticModel, Action <Diagnostic> addDiagnostic, AnalyzerOptions options, CancellationToken cancellationToken)
{
BreakStatementSyntax breakNode = (BreakStatementSyntax)node;
if (!IsInSwitch(breakNode))
{
addDiagnostic(Diagnostic.Create(Rule, node.GetLocation()));
}
}
public override void VisitBreakStatement(BreakStatementSyntax node)
{
if (breakTargets.Count > 0)
{
var target = breakTargets.Peek();
Connect(curNode, target, ControlFlowEdgeType.Jump);
curNode = target;
}
curNode = builder.CreateEndNode(node);
}
public BoundBreakStatement BindBreak(BreakStatementSyntax node)
{
var target = this.context.GetBreakLabel();
if (target == null)
{
Error(ErrorCode.ERR_NoBreakOrCont, node);
return BoundBreakStatement.AsError(node, null);
}
return new BoundBreakStatement(node, target);
}
public override void VisitBreakStatement(BreakStatementSyntax node)
{
MethodInfo mi = m_MethodInfoStack.Peek();
if (m_ContinueInfoStack.Count > 0)
{
var ci = m_ContinueInfoStack.Peek();
if (ci.IsIgnoreBreak)
{
return;
}
if (ci.HaveContinue)
{
CodeBuilder.AppendFormat("{0}{1} = true;", GetIndentString(), ci.BreakFlagVarName);
CodeBuilder.AppendLine();
}
bool isLastNode = IsLastNodeOfFor(node);
if (!isLastNode)
{
CodeBuilder.AppendFormat("{0}block{{", GetIndentString());
CodeBuilder.AppendLine();
}
if (mi.TryUsingLayer > 0 && mi.TryCatchUsingOrLoopSwitchStack.Peek())
{
var returnAnalysis = mi.TempReturnAnalysisStack.Peek();
if (returnAnalysis.ExistReturnInLoopOrSwitch || null == returnAnalysis.RetValVar)
{
//return(3)代表是tryusing块里的break语句
CodeBuilder.AppendFormat("{0}return(3);", GetIndentString());
CodeBuilder.AppendLine();
}
else
{
//可以不使用函数对象实现的try块，不能使用return语句，换成变量赋值与break
CodeBuilder.AppendFormat("{0}{1} = 3;", GetIndentString(), returnAnalysis.RetValVar);
CodeBuilder.AppendLine();
CodeBuilder.AppendFormat("{0}break;", GetIndentString());
CodeBuilder.AppendLine();
}
}
else
{
CodeBuilder.AppendFormat("{0}break;", GetIndentString());
CodeBuilder.AppendLine();
}
if (!isLastNode)
{
CodeBuilder.AppendFormat("{0}}};", GetIndentString());
CodeBuilder.AppendLine();
}
}
}
public override void VisitBreakStatement(BreakStatementSyntax node)
{
var remainderBlock = new BasicBlock(_currentBlock.Terminator);
if (_breakBlock == null)
{
throw new SyntaxErrorException("Break without enclosing loop or switch encountered");
}
_currentBlock.Terminator = new JumpTerminator(_breakBlock);
_currentBlock = remainderBlock;
}
public override void VisitBreakStatement(BreakStatementSyntax node)
{
if (!PreVisit(node))
{
return;
}
base.VisitBreakStatement(node);
PostVisit(node);
}
private static bool IsInSwitch(BreakStatementSyntax node)
{
SyntaxNode ancestor = node.FirstAncestorOrSelf <SyntaxNode>(e =>
e.IsKind(SyntaxKind.SwitchStatement) ||
e.IsKind(SyntaxKind.WhileStatement) ||
e.IsKind(SyntaxKind.DoStatement) ||
e.IsKind(SyntaxKind.ForStatement) ||
e.IsKind(SyntaxKind.ForEachStatement));
return(ancestor != null && ancestor.IsKind(SyntaxKind.SwitchStatement));
}
private Block BuildBreakStatement(BreakStatementSyntax breakStatement, Block currentBlock)
{
if (BreakTarget.Count == 0)
{
throw new InvalidOperationException("break; outside a loop");
}
var target = BreakTarget.Peek();
return(CreateJumpBlock(breakStatement, target, currentBlock));
}
public BoundBreakStatement BindBreak(BreakStatementSyntax node)
{
var target = this.context.GetBreakLabel();
if (target == null)
{
Error(ErrorCode.ERR_NoBreakOrCont, node);
return(BoundBreakStatement.AsError(node, null));
}
return(new BoundBreakStatement(node, target));
}
public override void VisitBreakStatement(BreakStatementSyntax node)
{
if (entryNode is AnonymousFunctionExpressionSyntax && embeddedNode is AnonymousFunctionExpressionSyntax)
{
return;
}
if (_weComeFromMethod && _weInAnonymousMethod)
{
return;
}
InsertLLOCMap(node.GetLocation());
base.VisitBreakStatement(node);
}
public override void Initialize(AnalysisContext context)
{
context.RegisterSyntaxNodeAction(
c =>
{
BreakStatementSyntax breakNode = (BreakStatementSyntax)c.Node;
if (!IsInSwitch(breakNode))
{
c.ReportDiagnostic(Diagnostic.Create(Rule, breakNode.GetLocation()));
}
},
SyntaxKind.BreakStatement);
}
public static void Go(ScalaWriter writer, BreakStatementSyntax statement)
{
//Traverse up to figure out what we're breaking from. If we're breaking from a loop, it's fine. However, if we're breaking from a switch statement, throw an error as we don't allow this except directly inside of a case block.
var breakingFrom = statement.Parent;
while (!(breakingFrom is WhileStatementSyntax || breakingFrom is ForStatementSyntax || breakingFrom is DoStatementSyntax || breakingFrom is ForEachStatementSyntax))
{
if (breakingFrom is SwitchStatementSyntax)
{
throw new Exception("Cannot \"break\" from within a switch statement except directly inside of a case statement. " + Utility.Descriptor(statement));
}
breakingFrom = breakingFrom.Parent;
}
writer.WriteLine("CsScala.csbreak.break;");
}
public override SyntaxNode VisitBreakStatement(BreakStatementSyntax node)
{
node = (BreakStatementSyntax)base.VisitBreakStatement(node);
if (node == null)
{
return(node);
}
bool inSwitch = IsSwitchParent(node);
if (inSwitch)
{
return(null);
}
return(node);
}
public override void VisitBreakStatement(BreakStatementSyntax node)
{
MethodInfo mi = m_MethodInfoStack.Peek();
if (m_ContinueInfoStack.Count > 0)
{
var ci = m_ContinueInfoStack.Peek();
if (ci.IsIgnoreBreak)
{
return;
}
if (ci.HaveContinue)
{
CodeBuilder.AppendFormat("{0}{1} = true;", GetIndentString(), ci.BreakFlagVarName);
CodeBuilder.AppendLine();
}
bool isLastNode = IsLastNodeOfFor(node);
if (isLastNode)
{
CodeBuilder.AppendFormat("{0}block{{", GetIndentString());
CodeBuilder.AppendLine();
}
if (mi.TryCatchUsingLayer > 0 && mi.TryCatchUsingOrLoopSwitchStack.Peek())
{
CodeBuilder.AppendFormat("{0}return(3);", GetIndentString());
CodeBuilder.AppendLine();
}
else
{
CodeBuilder.AppendFormat("{0}break;", GetIndentString());
CodeBuilder.AppendLine();
}
if (isLastNode)
{
CodeBuilder.AppendFormat("{0}}};", GetIndentString());
CodeBuilder.AppendLine();
}
}
}
internal bool HasNonTrailingBreaks(SyntaxNode node, BreakStatementSyntax trailing)
{
//if our trailing 'break' is actually return, then /any/ break is non-trailing
if (node is BreakStatementSyntax && (trailing == null || !node.GetLocation().Equals(trailing.GetLocation())))
return true;
return node.DescendantNodes().Any(n => HasNonTrailingBreaks(n, trailing));
}
public BoundBreakStatement(BreakStatementSyntax syntax)
: base(BoundNodeKind.BreakStatement, syntax)
{
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitBreakStatement(BreakStatementSyntax node)
{
this.OnNodeVisited(node, this.type.IsInstanceOfType(node));
base.VisitBreakStatement(node);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitBreakStatement(BreakStatementSyntax node)
{
this.OnNodeVisited(node);
if (!this.traverseRootOnly) base.VisitBreakStatement(node);
}
private static bool IsInSwitch(BreakStatementSyntax node)
{
var ancestor = node.FirstAncestorOrSelf<SyntaxNode>(e => LoopOrSwitch.Contains(e.Kind()));
return ancestor != null && ancestor.IsKind(SyntaxKind.SwitchStatement);
}
public override SyntaxNode VisitBreakStatement(BreakStatementSyntax node)
{
_output.WriteLine(node.BreakKeyword, "break;");
return node;
}
public BoundStatement BindBreak(BreakStatementSyntax node, DiagnosticBag diagnostics)
{
var target = this.BreakLabel;
if ((object)target == null)
{
Error(diagnostics, ErrorCode.ERR_NoBreakOrCont, node);
return new BoundBadStatement(node, ImmutableArray<BoundNode>.Empty, hasErrors: true);
}
return new BoundBreakStatement(node, target);
}
public static void Go(OutputWriter writer, BreakStatementSyntax statement)
{
writer.WriteLine("break;");
}
public virtual void VisitBreakStatement(BreakStatementSyntax node)
{
DefaultVisit(node);
}
public override SyntaxNode VisitBreakStatement(BreakStatementSyntax node)
{
return SyntaxFactory.EmptyStatement();
}
public void Flatten(BreakStatementSyntax node, List<FlatStatement> instructions)
{
if (string.IsNullOrEmpty(this.CurrentBreakLabel))
{
throw new NotSupportedException("break without context");
}
instructions.Add(FlatStatement.JMP(FlatOperand.LabelRef(CurrentBreakLabel)));
}
public void VisitBreakStatement(BreakStatementSyntax node)
{
if (node == null)
throw new ArgumentNullException("node");
node.Validate();
WriteLeadingTrivia(node);
_writer.WriteIndent();
_writer.WriteKeyword(PrinterKeyword.Break);
_writer.EndStatement();
WriteTrailingTrivia(node);
}
public BoundDiscardStatement(BreakStatementSyntax syntax)
: base(BoundNodeKind.DiscardStatement, syntax)
{
}
public override void VisitBreakStatement(BreakStatementSyntax node)
{
if (breakTargets.Count > 0)
{
var target = breakTargets.Peek();
Connect(curNode, target, ControlFlowEdgeType.Jump);
curNode = target;
}
curNode = builder.CreateEndNode(node);
}
public BreakStatementTranslation(BreakStatementSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
{
}
public override void VisitBreakStatement(BreakStatementSyntax node)
{
Fail = true;
}
private BoundStatement BindBreakStatement(BreakStatementSyntax syntax)
{
return new BoundBreakStatement();
}
public override void VisitBreakStatement(BreakStatementSyntax node)
{
if (currentState.NextState.BreakState == null)
throw new Exception();
CloseTo(currentState, currentState.NextState.BreakState);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
/// <remarks>
/// Statements will cause an AST walker to be created, thus we don't need to go further deeper in the
/// tree by visiting the node.
/// </remarks>
public override void VisitBreakStatement(BreakStatementSyntax node)
{
this.VisitStatement(node);
}
public static BreakStatementSyntax BreakStatement()
{
var result = new BreakStatementSyntax();
return result;
}
public override void VisitBreakStatement(BreakStatementSyntax node)
{
this.Logic.Add(this.nodeFactory.CreateBreak());
}
