public virtual SwitchCase VisitSwitchCase(SwitchCase switchCase)
{
if (switchCase == null) return null;
switchCase.Label = this.VisitExpression(switchCase.Label);
switchCase.Body = this.VisitBlock(switchCase.Body);
return switchCase;
}
public override SwitchCase VisitSwitchCase(SwitchCase switchCase)
{
if (switchCase == null) return null;
return base.VisitSwitchCase((SwitchCase)switchCase.Clone());
}
private Cci.Switch ParseSwitch(TokenSet followers){
Cci.Switch Switch = new Cci.Switch();
Switch.SourceContext = this.scanner.CurrentSourceContext;
Debug.Assert(this.currentToken == Token.Switch);
this.GetNextToken();
Switch.Expression = this.ParseParenthesizedExpression(followers|Token.LeftBrace);
Switch.Cases = new SwitchCaseList();
Switch.SourceContext.EndPos = this.scanner.endPos;
this.Skip(Token.LeftBrace);
TokenSet followersOrCaseOrColonOrDefaultOrRightBrace = followers|Parser.CaseOrColonOrDefaultOrRightBrace;
TokenSet followersOrCaseOrDefaultOrRightBrace = followers|Parser.CaseOrDefaultOrRightBrace;
SwitchCase scase = new SwitchCase();
scase.SourceContext = this.scanner.CurrentSourceContext;
for(;;){
switch(this.currentToken){
case Token.Case:
this.GetNextToken();
if (this.currentToken == Token.Colon)
this.HandleError(Error.ConstantExpected);
else
scase.Label = this.ParseExpression(followersOrCaseOrColonOrDefaultOrRightBrace);
break;
case Token.Default: //Parse these as many times as they occur. Checker will report the error.
this.GetNextToken();
scase.Label = null;
break;
default:
if (Parser.StatementStart[this.currentToken]){
this.HandleError(Error.StmtNotInCase);
this.ParseStatement(followersOrCaseOrColonOrDefaultOrRightBrace);
continue;
}
goto done;
}
this.Skip(Token.Colon);
scase.Body = this.ParseSwitchCaseStatementBlock(followersOrCaseOrDefaultOrRightBrace);
if (scase.Body != null && scase.Body.Statements != null && scase.Body.Statements.Count > 0) {
Statement swbottom = new Statement(NodeType.SwitchCaseBottom);
swbottom.SourceContext = scase.SourceContext;
scase.Body.Statements.Add(swbottom);
}
Switch.Cases.Add(scase);
scase = new SwitchCase();
scase.SourceContext = this.scanner.CurrentSourceContext;
}
done:
if (Switch.Cases.Count == 0) {
this.HandleError(Error.EmptySwitch);
}
else {
// add SwitchCaseBottom to last case if it happened to have no statements.
SwitchCase lastCase = Switch.Cases[Switch.Cases.Count-1];
if (lastCase != null && lastCase.Body.Statements.Count == 0) {
Statement swbottom = new Statement(NodeType.SwitchCaseBottom);
swbottom.SourceContext = lastCase.SourceContext;
lastCase.Body.Statements.Add(swbottom);
}
}
SourceContext sctx = Switch.SourceContext;
Switch.SourceContext.EndPos = this.scanner.CurrentSourceContext.EndPos;
this.ParseBracket(Switch.SourceContext, Token.RightBrace, followers, Error.ExpectedRightBrace);
return Switch;
}
private void PatchSourceContextProperty(ZMethod zMethod, Class methodClass, List<BasicBlock> basicBlocks)
{
Property contextProperty = (Property)Templates.GetMemberByName(methodClass.Members, "Context");
Method contextMethod = contextProperty.Getter;
Debug.Assert(contextMethod.Body.Statements[0] is System.Compiler.Switch);
System.Compiler.Switch switchStmt = (System.Compiler.Switch)contextMethod.Body.Statements[0];
foreach (BasicBlock block in basicBlocks)
{
SourceContext ctxt = new SourceContext(null, 0, 0);
//ctxt.Document = null;
//ctxt.StartPos = 0;
//ctxt.EndPos = 0;
if (block.SourceContext.StartPos != 0 || block.SourceContext.EndPos != 0)
{
// If the block says something explicit about its context, take that
// as final.
ctxt = block.SourceContext;
}
else
{
// The block doesn't say anything, so figure it out from the statements
// inside the block.
BasicBlock effectiveBlock = block;
//
// If we only fall through to another BB without any executable code,
// conditional branching, interleaving, or return - then consider our
// source context to be the next "real" thing that happens.
//
while ((effectiveBlock.Statement == null || effectiveBlock.SkipNormalizer) &&
effectiveBlock.ConditionalExpression == null &&
effectiveBlock.SourceContext.SourceText == null &&
effectiveBlock.MiddleOfTransition &&
!effectiveBlock.IsReturn && !effectiveBlock.PropagatesException)
{
effectiveBlock = effectiveBlock.UnconditionalTarget;
}
// See which source context is the most appropriate for this block.
if (effectiveBlock.Statement != null)
{
if (effectiveBlock.Statement.SourceContext.SourceText != null)
ctxt = effectiveBlock.Statement.SourceContext;
else
{
Block b = effectiveBlock.Statement as Block;
if (b != null)
{
for (int i = 0, n = b.Statements.Count; i < n; i++)
{
if (b.Statements[i] != null)
{
ctxt = b.Statements[i].SourceContext;
break;
}
}
}
}
}
else if (effectiveBlock.ConditionalExpression != null)
ctxt = effectiveBlock.ConditionalExpression.SourceContext;
else if (effectiveBlock.SourceContext.SourceText != null)
ctxt = effectiveBlock.SourceContext;
else
{
// For "return" blocks, show the closing brace as the source context.
ctxt.Document = zMethod.SourceContext.Document;
ctxt.EndPos = zMethod.SourceContext.EndPos;
ctxt.StartPos = ctxt.EndPos - 1;
}
}
if (ctxt.StartPos < 0)
ctxt.StartPos = 0;
SwitchCase newCase = new SwitchCase(
new QualifiedIdentifier(Identifier.For("Blocks"), Identifier.For(block.Name)),
new Block(new StatementList(
new Return(SourceContextConstructor(ctxt))))
);
switchStmt.Cases.Add(newCase);
}
}
public override SwitchCase VisitSwitchCase(SwitchCase switchCase)
{
if (switchCase.Label != null)
{
WriteStart("case ");
this.VisitExpression(switchCase.Label);
WriteFinish(":");
}
else
WriteLine("default:");
this.VisitBlock(switchCase.Body);
return switchCase;
}
public EventingVisitor(Action<SwitchCase> visitSwitchCase) { VisitedSwitchCase += visitSwitchCase; } public event Action<SwitchCase> VisitedSwitchCase; public override SwitchCase VisitSwitchCase(SwitchCase switchCase) { if (VisitedSwitchCase != null) VisitedSwitchCase(switchCase); return base.VisitSwitchCase(switchCase); }
