public CSharpSyntaxNode Convert(DefaultClause node)
{
SwitchSectionSyntax csSwitchSection = SyntaxFactory.SwitchSection();
csSwitchSection = csSwitchSection.AddLabels(SyntaxFactory.DefaultSwitchLabel());
csSwitchSection = csSwitchSection.AddStatements(node.Statements.ToCsNodes <StatementSyntax>());
return(csSwitchSection);
}
private Location Statement(Seq<Statement> statements, bool isTop)
{
ConsumeCommentStatement(statements);
switch (Current.Tag)
{
case InputElementTag.LBrace:
{
return BlockStatements("block", false, statements);
}
case InputElementTag.Var:
{
var variableDeclarations = new Seq<VariableDeclaration>();
var loc = VariableDeclarations(variableDeclarations);
statements.Add(new VariableStatement(loc, variableDeclarations));
return loc;
}
case InputElementTag.Semicolon:
{
var loc = Current.Loc;
Consume();
return loc;
}
case InputElementTag.If:
{
var loc = Current.Loc;
Consume();
Only("if statement", "'('", InputElementTag.LParen);
var condition = Expression(false);
Only("if statement", "')'", InputElementTag.RParen);
condition = ConsumeCommentExpression(condition);
var thenStatements = new Seq<Statement>();
loc = loc.Union(Statement(thenStatements, false));
if (Current.Tag == InputElementTag.Else)
{
var elseStatements = new Seq<Statement>();
Consume();
loc = loc.Union(Statement(elseStatements, false));
statements.Add(new IfStatement(loc, condition, new Statements(thenStatements), new Statements(elseStatements)));
}
else
statements.Add(new IfStatement(loc, condition, new Statements(thenStatements)));
return loc;
}
case InputElementTag.Do:
{
var loc = Current.Loc;
Consume();
var body = new Seq<Statement>();
Statement(body, false);
Only("do statement", "'while'", InputElementTag.While);
Only("do statement", "'('", InputElementTag.LParen);
var condition = Expression(false);
Only("do statement", "')'", InputElementTag.RParen);
condition = ConsumeCommentExpression(condition);
OptSemicolon("do statement");
loc = loc.Union(condition.Loc);
statements.Add(new DoStatement(loc, new Statements(body), condition));
return loc;
}
case InputElementTag.While:
{
var loc = Current.Loc;
Consume();
Only("while statement", "'('", InputElementTag.LParen);
var condition = Expression(false);
Only("while statement", "')'", InputElementTag.RParen);
condition = ConsumeCommentExpression(condition);
var body = new Seq<Statement>();
loc = loc.Union(Statement(body, false));
statements.Add(new WhileStatement(loc, condition, new Statements(body)));
return loc;
}
case InputElementTag.For:
{
var loc = Current.Loc;
Consume();
var loopClause = LoopClause();
var body = new Seq<Statement>();
loc = loc.Union(Statement(body, false));
statements.Add(new ForStatement(loc, loopClause, new Statements(body)));
return loc;
}
case InputElementTag.Continue:
{
var loc = Current.Loc;
Consume();
// ask for Current to make sure lastLineTerminator is updates
var isid = Current.Tag == InputElementTag.Identifier;
var label = default(Identifier);
if (lastLineTerminator == null)
{
if (isid)
{
label = new Identifier(Current.Loc, Current.Value);
loc = loc.Union(label.Loc);
Consume();
}
OptSemicolon("continue statement");
}
statements.Add(new ContinueStatement(loc, label));
return loc;
}
case InputElementTag.Break:
{
var loc = Current.Loc;
Consume();
// ask for Current to make sure lastLineTerminator is updates
var isid = Current.Tag == InputElementTag.Identifier;
var label = default(Identifier);
if (lastLineTerminator == null)
{
if (isid)
{
label = new Identifier(Current.Loc, Current.Value);
loc = loc.Union(label.Loc);
Consume();
}
OptSemicolon("break statement");
}
statements.Add(new BreakStatement(loc, label));
return loc;
}
case InputElementTag.Return:
{
var loc = Current.Loc;
Consume();
var value = default(Expression);
// ask for Current to make sure lastLineTerminator is updates
var isExpr = IsExpression();
if (lastLineTerminator == null)
{
if (isExpr)
{
value = Expression(false);
loc = loc.Union(value.Loc);
}
OptSemicolon("return statement");
if (value != null)
value = ConsumeCommentExpression(value);
}
statements.Add(new ReturnStatement(loc, value));
return loc;
}
case InputElementTag.With:
{
var loc = Current.Loc;
Consume();
Only("with statement", "'('", InputElementTag.LParen);
var environment = Expression(false);
Only("with statement", "')'", InputElementTag.RParen);
environment = ConsumeCommentExpression(environment);
var body = new Seq<Statement>();
loc = loc.Union(Statement(body, false));
statements.Add(new WithStatement(loc, environment, new Statements(body)));
return loc;
}
case InputElementTag.Identifier:
{
var loc = Current.Loc;
var ie = Current;
Consume();
if (Current.Tag == InputElementTag.Colon)
{
var label = new Identifier(ie.Loc, ie.Value);
Consume();
var body = new Seq<Statement>();
loc = loc.Union(Statement(body, false));
statements.Add(new LabelledStatement(loc, label, new Statements(body)));
}
else
{
Regurgitate(ie);
var expression = Expression(false);
loc = expression.Loc;
OptSemicolon("expression statement");
expression = ConsumeCommentExpression(expression);
statements.Add(new ExpressionStatement(loc, expression));
}
return loc;
}
case InputElementTag.Switch:
{
var loc = Current.Loc;
Consume();
Only("switch statement", "'('", InputElementTag.LParen);
var value = Expression(false);
Only("switch statement", "')'", InputElementTag.RParen);
value = ConsumeCommentExpression(value);
Only("switch statement", "'{'", InputElementTag.LBrace);
var cases = new Seq<CaseClause>();
var defaultc = default(DefaultClause);
while (Current.Tag != InputElementTag.RBrace)
{
if (Current.Tag == InputElementTag.Case)
{
var caseLoc = Current.Loc;
Consume();
var caseValue = Expression(false);
Only("case clause", "':'", InputElementTag.Colon);
var caseBody = new Seq<Statement>();
while (Current.Tag != InputElementTag.Case && Current.Tag != InputElementTag.Default &&
Current.Tag != InputElementTag.RBrace)
caseLoc = caseLoc.Union(Statement(caseBody, false));
ConsumeCommentStatement(caseBody);
cases.Add(new CaseClause(caseLoc, caseValue, new Statements(caseBody)));
}
else if (Current.Tag == InputElementTag.Default)
{
if (defaultc != null)
throw MsgError
("case clause",
String.Format("default clause already present at {0}", defaultc.Loc));
var defaultLoc = Current.Loc;
Consume();
Only("default clause", "':'", InputElementTag.Colon);
var defaultBody = new Seq<Statement>();
while (Current.Tag != InputElementTag.Case && Current.Tag != InputElementTag.Default &&
Current.Tag != InputElementTag.RBrace)
defaultLoc = defaultLoc.Union(Statement(defaultBody, false));
ConsumeCommentStatement(defaultBody);
defaultc = new DefaultClause(defaultLoc, new Statements(defaultBody), cases.Count);
}
else
throw IEError("switch statement", "'case' or 'default' or '}'");
}
loc = loc.Union(Current.Loc);
Consume();
statements.Add(new SwitchStatement(loc, value, cases, defaultc));
return loc;
}
case InputElementTag.Throw:
{
var loc = Current.Loc;
Consume();
// ask for Current to make sure lastLineTerminator is updates
var dummy = Current;
var value = default(Expression);
if (lastLineTerminator == null)
{
value = Expression(false);
OptSemicolon("throw statement");
value = ConsumeCommentExpression(value);
}
else
{
value = Expression(false);
value = ConsumeCommentExpression(value);
}
loc = loc.Union(value.Loc);
statements.Add(new ThrowStatement(loc, value));
return loc;
}
case InputElementTag.Try:
{
var loc = Current.Loc;
Consume();
var tryStatements = new Seq<Statement>();
BlockStatements("try statement", false, tryStatements);
var catchc = default(CatchClause);
var finallyc = default(FinallyClause);
if (Current.Tag == InputElementTag.Catch)
{
var catchLoc = Current.Loc;
Consume();
Only("catch clause", "'('", InputElementTag.LParen);
if (Current.Tag != InputElementTag.Identifier)
throw IEError("catch clasue", "identifier");
var name = new Identifier(Current.Loc, Current.Value);
Consume();
Only("catch clause", "')'", InputElementTag.RParen);
var catchBody = new Seq<Statement>();
catchLoc = catchLoc.Union(BlockStatements("catch clause", false, catchBody));
catchc = new CatchClause(catchLoc, name, new Statements(catchBody));
loc = loc.Union(catchLoc);
}
if (Current.Tag == InputElementTag.Finally)
{
var finallyLoc = Current.Loc;
Consume();
var finallyBody = new Seq<Statement>();
finallyLoc = finallyLoc.Union(BlockStatements("finally clause", false, finallyBody));
finallyc = new FinallyClause(finallyLoc, new Statements(finallyBody));
loc = loc.Union(finallyLoc);
}
else if (catchc == null)
throw IEError("try statement", "'catch' or 'finally'");
statements.Add(new TryStatement(loc, new Statements(tryStatements), catchc, finallyc));
return loc;
}
case InputElementTag.Function:
{
if (lexer.IsStrict && !isTop)
throw MsgError("statement", "function declarations not permitted in nested blocks");
var loc = Current.Loc;
Consume();
if (Current.Tag != InputElementTag.Identifier)
throw IEError("function declaration", "identifier");
var name = new Identifier(Current.Loc, Current.Value);
Consume();
if (Current.Tag != InputElementTag.LParen)
throw IEError("function declaration", "'('");
var parameters = new Seq<Identifier>();
DelimitedList
("function declaration parameters",
"',' or ')'",
InputElementTag.Comma,
InputElementTag.RParen,
() =>
{
if (Current.Tag != InputElementTag.Identifier)
throw IEError("function declaration parameters", "identifier");
parameters.Add(new Identifier(Current.Loc, Current.Value));
Consume();
});
var body = new Seq<Statement>();
loc = loc.Union(BlockStatements("function declaration", true, body));
statements.Add(new FunctionDeclaration(loc, name, parameters, new Statements(body)));
return loc;
}
default:
{
var expression = Expression(false);
var loc = expression.Loc;
OptSemicolon("expression statement");
expression = ConsumeCommentExpression(expression);
statements.Add(new ExpressionStatement(loc, expression));
return loc;
}
}
}
public void TestDefaultClause()
{
DefaultClause node = new DefaultClause(GetStatementList(), DefaultLineInfo);
CheckSerializationRoundTrip(node);
}
/// <nodoc />
public virtual void Visit(DefaultClause defaultClause)
{
}
// $ANTLR start "defaultClause"
// JavaScript.g:184:1: defaultClause : 'default' ( LT )* ':' ( ( 'case' | 'default' | '}' )=> () | ( LT )* statementList ) ;
public JavaScriptParser.defaultClause_return defaultClause() // throws RecognitionException [1]
{
JavaScriptParser.defaultClause_return retval = new JavaScriptParser.defaultClause_return();
retval.Start = input.LT(1);
object root_0 = null;
IToken string_literal203 = null;
IToken LT204 = null;
IToken char_literal205 = null;
IToken LT206 = null;
JavaScriptParser.statementList_return statementList207 = default(JavaScriptParser.statementList_return);
object string_literal203_tree=null;
object LT204_tree=null;
object char_literal205_tree=null;
object LT206_tree=null;
try
{
// JavaScript.g:185:2: ( 'default' ( LT )* ':' ( ( 'case' | 'default' | '}' )=> () | ( LT )* statementList ) )
// JavaScript.g:185:4: 'default' ( LT )* ':' ( ( 'case' | 'default' | '}' )=> () | ( LT )* statementList )
{
root_0 = (object)adaptor.GetNilNode();
string_literal203=(IToken)Match(input,61,FOLLOW_61_in_defaultClause1542); if (state.failed) return retval;
if ( state.backtracking == 0 )
{string_literal203_tree = new DefaultClause(string_literal203) ;
root_0 = (object)adaptor.BecomeRoot(string_literal203_tree, root_0);
}
// JavaScript.g:185:32: ( LT )*
do
{
int alt106 = 2;
int LA106_0 = input.LA(1);
if ( (LA106_0 == LT) )
{
alt106 = 1;
}
switch (alt106)
{
case 1 :
// JavaScript.g:185:32: LT
{
LT204=(IToken)Match(input,LT,FOLLOW_LT_in_defaultClause1548); if (state.failed) return retval;
}
break;
default:
goto loop106;
}
} while (true);
loop106:
; // Stops C# compiler whining that label 'loop106' has no statements
char_literal205=(IToken)Match(input,58,FOLLOW_58_in_defaultClause1552); if (state.failed) return retval;
// JavaScript.g:185:40: ( ( 'case' | 'default' | '}' )=> () | ( LT )* statementList )
int alt108 = 2;
alt108 = dfa108.Predict(input);
switch (alt108)
{
case 1 :
// JavaScript.g:185:41: ( 'case' | 'default' | '}' )=> ()
{
// JavaScript.g:185:65: ()
// JavaScript.g:185:66:
{
}
}
break;
case 2 :
// JavaScript.g:185:69: ( LT )* statementList
{
// JavaScript.g:185:71: ( LT )*
do
{
int alt107 = 2;
int LA107_0 = input.LA(1);
if ( (LA107_0 == LT) )
{
alt107 = 1;
}
switch (alt107)
{
case 1 :
// JavaScript.g:185:71: LT
{
LT206=(IToken)Match(input,LT,FOLLOW_LT_in_defaultClause1568); if (state.failed) return retval;
}
break;
default:
goto loop107;
}
} while (true);
loop107:
; // Stops C# compiler whining that label 'loop107' has no statements
PushFollow(FOLLOW_statementList_in_defaultClause1572);
statementList207 = statementList();
state.followingStackPointer--;
if (state.failed) return retval;
if ( state.backtracking == 0 ) adaptor.AddChild(root_0, statementList207.Tree);
}
break;
}
}
retval.Stop = input.LT(-1);
if ( (state.backtracking==0) )
{ retval.Tree = (object)adaptor.RulePostProcessing(root_0);
adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input,re);
// Conversion of the second argument necessary, but harmless
retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
}
finally
{
}
return retval;
}
