com.fizzed.rocker.antlr4.RockerParser Maven / Gradle / Ivy
The newest version!
// Generated from com/fizzed/rocker/antlr4/RockerParser.g4 by ANTLR 4.5.3
package com.fizzed.rocker.antlr4;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class RockerParser extends Parser {
static { RuntimeMetaData.checkVersion("4.5.3", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
ELSE_IF=1, ELSE=2, CASE=3, CASE_EXPRESSION=4, DEFAULT=5, DEFAULT_EXPRESSION=6,
LCURLY=7, RCURLY=8, COMMENT=9, PLAIN=10, AT=11, MV_IMPORT=12, MV_OPTION=13,
MV_ARGS=14, MV_IF=15, MV_SWITCH=16, MV_FOR=17, MV_WITH=18, MV_CONTENT_CLOSURE=19,
MV_VALUE_CLOSURE=20, MV_EVAL=21, MV_NULL_TERNARY_LH=22, MV_VALUE=23, MV_NULL_TERNARY_RH=24;
public static final int
RULE_template = 0, RULE_plain = 1, RULE_plainBlock = 2, RULE_plainElseIfBlock = 3,
RULE_plainElseBlock = 4, RULE_comment = 5, RULE_importDeclaration = 6,
RULE_importStatement = 7, RULE_optionDeclaration = 8, RULE_optionStatement = 9,
RULE_argumentsDeclaration = 10, RULE_argumentsStatement = 11, RULE_templateContent = 12,
RULE_block = 13, RULE_ifBlock = 14, RULE_ifElseIfBlock = 15, RULE_ifElseBlock = 16,
RULE_forBlock = 17, RULE_withBlock = 18, RULE_withElseBlock = 19, RULE_contentClosure = 20,
RULE_contentClosureExpression = 21, RULE_valueClosure = 22, RULE_valueClosureExpression = 23,
RULE_value = 24, RULE_valueExpression = 25, RULE_nullTernary = 26, RULE_nullTernaryExpression = 27,
RULE_eval = 28, RULE_evalExpression = 29, RULE_switchBlock = 30, RULE_switchCase = 31,
RULE_switchDefault = 32, RULE_switchExpressionBlock = 33, RULE_switchExpressionCase = 34,
RULE_switchExpressionDefault = 35;
public static final String[] ruleNames = {
"template", "plain", "plainBlock", "plainElseIfBlock", "plainElseBlock",
"comment", "importDeclaration", "importStatement", "optionDeclaration",
"optionStatement", "argumentsDeclaration", "argumentsStatement", "templateContent",
"block", "ifBlock", "ifElseIfBlock", "ifElseBlock", "forBlock", "withBlock",
"withElseBlock", "contentClosure", "contentClosureExpression", "valueClosure",
"valueClosureExpression", "value", "valueExpression", "nullTernary", "nullTernaryExpression",
"eval", "evalExpression", "switchBlock", "switchCase", "switchDefault",
"switchExpressionBlock", "switchExpressionCase", "switchExpressionDefault"
};
private static final String[] _LITERAL_NAMES = {
null, null, null, null, null, null, null, "'{'", "'}'", null, null, "'@'"
};
private static final String[] _SYMBOLIC_NAMES = {
null, "ELSE_IF", "ELSE", "CASE", "CASE_EXPRESSION", "DEFAULT", "DEFAULT_EXPRESSION",
"LCURLY", "RCURLY", "COMMENT", "PLAIN", "AT", "MV_IMPORT", "MV_OPTION",
"MV_ARGS", "MV_IF", "MV_SWITCH", "MV_FOR", "MV_WITH", "MV_CONTENT_CLOSURE",
"MV_VALUE_CLOSURE", "MV_EVAL", "MV_NULL_TERNARY_LH", "MV_VALUE", "MV_NULL_TERNARY_RH"
};
public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
/**
* @deprecated Use {@link #VOCABULARY} instead.
*/
@Deprecated
public static final String[] tokenNames;
static {
tokenNames = new String[_SYMBOLIC_NAMES.length];
for (int i = 0; i < tokenNames.length; i++) {
tokenNames[i] = VOCABULARY.getLiteralName(i);
if (tokenNames[i] == null) {
tokenNames[i] = VOCABULARY.getSymbolicName(i);
}
if (tokenNames[i] == null) {
tokenNames[i] = "";
}
}
}
@Override
@Deprecated
public String[] getTokenNames() {
return tokenNames;
}
@Override
public Vocabulary getVocabulary() {
return VOCABULARY;
}
@Override
public String getGrammarFileName() { return "RockerParser.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public RockerParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class TemplateContext extends ParserRuleContext {
public List plain() {
return getRuleContexts(PlainContext.class);
}
public PlainContext plain(int i) {
return getRuleContext(PlainContext.class,i);
}
public List comment() {
return getRuleContexts(CommentContext.class);
}
public CommentContext comment(int i) {
return getRuleContext(CommentContext.class,i);
}
public List importDeclaration() {
return getRuleContexts(ImportDeclarationContext.class);
}
public ImportDeclarationContext importDeclaration(int i) {
return getRuleContext(ImportDeclarationContext.class,i);
}
public List optionDeclaration() {
return getRuleContexts(OptionDeclarationContext.class);
}
public OptionDeclarationContext optionDeclaration(int i) {
return getRuleContext(OptionDeclarationContext.class,i);
}
public ArgumentsDeclarationContext argumentsDeclaration() {
return getRuleContext(ArgumentsDeclarationContext.class,0);
}
public List templateContent() {
return getRuleContexts(TemplateContentContext.class);
}
public TemplateContentContext templateContent(int i) {
return getRuleContext(TemplateContentContext.class,i);
}
public TemplateContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_template; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).enterTemplate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).exitTemplate(this);
}
}
public final TemplateContext template() throws RecognitionException {
TemplateContext _localctx = new TemplateContext(_ctx, getState());
enterRule(_localctx, 0, RULE_template);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(78);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,1,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
setState(76);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
case 1:
{
setState(72);
plain();
}
break;
case 2:
{
setState(73);
comment();
}
break;
case 3:
{
setState(74);
importDeclaration();
}
break;
case 4:
{
setState(75);
optionDeclaration();
}
break;
}
}
}
setState(80);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,1,_ctx);
}
setState(82);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) {
case 1:
{
setState(81);
argumentsDeclaration();
}
break;
}
setState(87);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LCURLY) | (1L << COMMENT) | (1L << PLAIN) | (1L << AT))) != 0)) {
{
{
setState(84);
templateContent();
}
}
setState(89);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PlainContext extends ParserRuleContext {
public TerminalNode PLAIN() { return getToken(RockerParser.PLAIN, 0); }
public PlainBlockContext plainBlock() {
return getRuleContext(PlainBlockContext.class,0);
}
public PlainContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_plain; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).enterPlain(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).exitPlain(this);
}
}
public final PlainContext plain() throws RecognitionException {
PlainContext _localctx = new PlainContext(_ctx, getState());
enterRule(_localctx, 2, RULE_plain);
try {
enterOuterAlt(_localctx, 1);
{
setState(92);
switch (_input.LA(1)) {
case PLAIN:
{
setState(90);
match(PLAIN);
}
break;
case LCURLY:
{
setState(91);
plainBlock();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PlainBlockContext extends ParserRuleContext {
public TerminalNode LCURLY() { return getToken(RockerParser.LCURLY, 0); }
public TerminalNode RCURLY() { return getToken(RockerParser.RCURLY, 0); }
public PlainElseBlockContext plainElseBlock() {
return getRuleContext(PlainElseBlockContext.class,0);
}
public List templateContent() {
return getRuleContexts(TemplateContentContext.class);
}
public TemplateContentContext templateContent(int i) {
return getRuleContext(TemplateContentContext.class,i);
}
public List plainElseIfBlock() {
return getRuleContexts(PlainElseIfBlockContext.class);
}
public PlainElseIfBlockContext plainElseIfBlock(int i) {
return getRuleContext(PlainElseIfBlockContext.class,i);
}
public PlainBlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_plainBlock; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).enterPlainBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).exitPlainBlock(this);
}
}
public final PlainBlockContext plainBlock() throws RecognitionException {
PlainBlockContext _localctx = new PlainBlockContext(_ctx, getState());
enterRule(_localctx, 4, RULE_plainBlock);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(94);
match(LCURLY);
setState(98);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LCURLY) | (1L << COMMENT) | (1L << PLAIN) | (1L << AT))) != 0)) {
{
{
setState(95);
templateContent();
}
}
setState(100);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(104);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==ELSE_IF) {
{
{
setState(101);
plainElseIfBlock();
}
}
setState(106);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(109);
switch (_input.LA(1)) {
case RCURLY:
{
setState(107);
match(RCURLY);
}
break;
case ELSE:
{
setState(108);
plainElseBlock();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PlainElseIfBlockContext extends ParserRuleContext {
public TerminalNode ELSE_IF() { return getToken(RockerParser.ELSE_IF, 0); }
public List templateContent() {
return getRuleContexts(TemplateContentContext.class);
}
public TemplateContentContext templateContent(int i) {
return getRuleContext(TemplateContentContext.class,i);
}
public PlainElseIfBlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_plainElseIfBlock; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).enterPlainElseIfBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).exitPlainElseIfBlock(this);
}
}
public final PlainElseIfBlockContext plainElseIfBlock() throws RecognitionException {
PlainElseIfBlockContext _localctx = new PlainElseIfBlockContext(_ctx, getState());
enterRule(_localctx, 6, RULE_plainElseIfBlock);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(111);
match(ELSE_IF);
setState(115);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LCURLY) | (1L << COMMENT) | (1L << PLAIN) | (1L << AT))) != 0)) {
{
{
setState(112);
templateContent();
}
}
setState(117);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PlainElseBlockContext extends ParserRuleContext {
public TerminalNode ELSE() { return getToken(RockerParser.ELSE, 0); }
public TerminalNode RCURLY() { return getToken(RockerParser.RCURLY, 0); }
public List templateContent() {
return getRuleContexts(TemplateContentContext.class);
}
public TemplateContentContext templateContent(int i) {
return getRuleContext(TemplateContentContext.class,i);
}
public PlainElseBlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_plainElseBlock; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).enterPlainElseBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).exitPlainElseBlock(this);
}
}
public final PlainElseBlockContext plainElseBlock() throws RecognitionException {
PlainElseBlockContext _localctx = new PlainElseBlockContext(_ctx, getState());
enterRule(_localctx, 8, RULE_plainElseBlock);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(118);
match(ELSE);
setState(122);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LCURLY) | (1L << COMMENT) | (1L << PLAIN) | (1L << AT))) != 0)) {
{
{
setState(119);
templateContent();
}
}
setState(124);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(125);
match(RCURLY);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CommentContext extends ParserRuleContext {
public TerminalNode COMMENT() { return getToken(RockerParser.COMMENT, 0); }
public CommentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_comment; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).enterComment(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).exitComment(this);
}
}
public final CommentContext comment() throws RecognitionException {
CommentContext _localctx = new CommentContext(_ctx, getState());
enterRule(_localctx, 10, RULE_comment);
try {
enterOuterAlt(_localctx, 1);
{
setState(127);
match(COMMENT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ImportDeclarationContext extends ParserRuleContext {
public TerminalNode AT() { return getToken(RockerParser.AT, 0); }
public ImportStatementContext importStatement() {
return getRuleContext(ImportStatementContext.class,0);
}
public ImportDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_importDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).enterImportDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).exitImportDeclaration(this);
}
}
public final ImportDeclarationContext importDeclaration() throws RecognitionException {
ImportDeclarationContext _localctx = new ImportDeclarationContext(_ctx, getState());
enterRule(_localctx, 12, RULE_importDeclaration);
try {
enterOuterAlt(_localctx, 1);
{
setState(129);
match(AT);
setState(130);
importStatement();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ImportStatementContext extends ParserRuleContext {
public TerminalNode MV_IMPORT() { return getToken(RockerParser.MV_IMPORT, 0); }
public ImportStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_importStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).enterImportStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).exitImportStatement(this);
}
}
public final ImportStatementContext importStatement() throws RecognitionException {
ImportStatementContext _localctx = new ImportStatementContext(_ctx, getState());
enterRule(_localctx, 14, RULE_importStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(132);
match(MV_IMPORT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OptionDeclarationContext extends ParserRuleContext {
public TerminalNode AT() { return getToken(RockerParser.AT, 0); }
public OptionStatementContext optionStatement() {
return getRuleContext(OptionStatementContext.class,0);
}
public OptionDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_optionDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).enterOptionDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).exitOptionDeclaration(this);
}
}
public final OptionDeclarationContext optionDeclaration() throws RecognitionException {
OptionDeclarationContext _localctx = new OptionDeclarationContext(_ctx, getState());
enterRule(_localctx, 16, RULE_optionDeclaration);
try {
enterOuterAlt(_localctx, 1);
{
setState(134);
match(AT);
setState(135);
optionStatement();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OptionStatementContext extends ParserRuleContext {
public TerminalNode MV_OPTION() { return getToken(RockerParser.MV_OPTION, 0); }
public OptionStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_optionStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).enterOptionStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).exitOptionStatement(this);
}
}
public final OptionStatementContext optionStatement() throws RecognitionException {
OptionStatementContext _localctx = new OptionStatementContext(_ctx, getState());
enterRule(_localctx, 18, RULE_optionStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(137);
match(MV_OPTION);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArgumentsDeclarationContext extends ParserRuleContext {
public TerminalNode AT() { return getToken(RockerParser.AT, 0); }
public ArgumentsStatementContext argumentsStatement() {
return getRuleContext(ArgumentsStatementContext.class,0);
}
public ArgumentsDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_argumentsDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).enterArgumentsDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).exitArgumentsDeclaration(this);
}
}
public final ArgumentsDeclarationContext argumentsDeclaration() throws RecognitionException {
ArgumentsDeclarationContext _localctx = new ArgumentsDeclarationContext(_ctx, getState());
enterRule(_localctx, 20, RULE_argumentsDeclaration);
try {
enterOuterAlt(_localctx, 1);
{
setState(139);
match(AT);
setState(140);
argumentsStatement();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArgumentsStatementContext extends ParserRuleContext {
public TerminalNode MV_ARGS() { return getToken(RockerParser.MV_ARGS, 0); }
public ArgumentsStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_argumentsStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).enterArgumentsStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).exitArgumentsStatement(this);
}
}
public final ArgumentsStatementContext argumentsStatement() throws RecognitionException {
ArgumentsStatementContext _localctx = new ArgumentsStatementContext(_ctx, getState());
enterRule(_localctx, 22, RULE_argumentsStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(142);
match(MV_ARGS);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TemplateContentContext extends ParserRuleContext {
public CommentContext comment() {
return getRuleContext(CommentContext.class,0);
}
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public PlainContext plain() {
return getRuleContext(PlainContext.class,0);
}
public ContentClosureContext contentClosure() {
return getRuleContext(ContentClosureContext.class,0);
}
public ValueClosureContext valueClosure() {
return getRuleContext(ValueClosureContext.class,0);
}
public ValueContext value() {
return getRuleContext(ValueContext.class,0);
}
public NullTernaryContext nullTernary() {
return getRuleContext(NullTernaryContext.class,0);
}
public EvalContext eval() {
return getRuleContext(EvalContext.class,0);
}
public TemplateContentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_templateContent; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).enterTemplateContent(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).exitTemplateContent(this);
}
}
public final TemplateContentContext templateContent() throws RecognitionException {
TemplateContentContext _localctx = new TemplateContentContext(_ctx, getState());
enterRule(_localctx, 24, RULE_templateContent);
try {
enterOuterAlt(_localctx, 1);
{
setState(152);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
case 1:
{
setState(144);
comment();
}
break;
case 2:
{
setState(145);
block();
}
break;
case 3:
{
setState(146);
plain();
}
break;
case 4:
{
setState(147);
contentClosure();
}
break;
case 5:
{
setState(148);
valueClosure();
}
break;
case 6:
{
setState(149);
value();
}
break;
case 7:
{
setState(150);
nullTernary();
}
break;
case 8:
{
setState(151);
eval();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BlockContext extends ParserRuleContext {
public IfBlockContext ifBlock() {
return getRuleContext(IfBlockContext.class,0);
}
public ForBlockContext forBlock() {
return getRuleContext(ForBlockContext.class,0);
}
public WithBlockContext withBlock() {
return getRuleContext(WithBlockContext.class,0);
}
public SwitchBlockContext switchBlock() {
return getRuleContext(SwitchBlockContext.class,0);
}
public SwitchExpressionBlockContext switchExpressionBlock() {
return getRuleContext(SwitchExpressionBlockContext.class,0);
}
public BlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_block; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).enterBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).exitBlock(this);
}
}
public final BlockContext block() throws RecognitionException {
BlockContext _localctx = new BlockContext(_ctx, getState());
enterRule(_localctx, 26, RULE_block);
try {
enterOuterAlt(_localctx, 1);
{
setState(159);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) {
case 1:
{
setState(154);
ifBlock();
}
break;
case 2:
{
setState(155);
forBlock();
}
break;
case 3:
{
setState(156);
withBlock();
}
break;
case 4:
{
setState(157);
switchBlock();
}
break;
case 5:
{
setState(158);
switchExpressionBlock();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IfBlockContext extends ParserRuleContext {
public TerminalNode AT() { return getToken(RockerParser.AT, 0); }
public TerminalNode MV_IF() { return getToken(RockerParser.MV_IF, 0); }
public TerminalNode RCURLY() { return getToken(RockerParser.RCURLY, 0); }
public IfElseIfBlockContext ifElseIfBlock() {
return getRuleContext(IfElseIfBlockContext.class,0);
}
public IfElseBlockContext ifElseBlock() {
return getRuleContext(IfElseBlockContext.class,0);
}
public List templateContent() {
return getRuleContexts(TemplateContentContext.class);
}
public TemplateContentContext templateContent(int i) {
return getRuleContext(TemplateContentContext.class,i);
}
public IfBlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ifBlock; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).enterIfBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).exitIfBlock(this);
}
}
public final IfBlockContext ifBlock() throws RecognitionException {
IfBlockContext _localctx = new IfBlockContext(_ctx, getState());
enterRule(_localctx, 28, RULE_ifBlock);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(161);
match(AT);
setState(162);
match(MV_IF);
setState(166);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LCURLY) | (1L << COMMENT) | (1L << PLAIN) | (1L << AT))) != 0)) {
{
{
setState(163);
templateContent();
}
}
setState(168);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(172);
switch (_input.LA(1)) {
case RCURLY:
{
setState(169);
match(RCURLY);
}
break;
case ELSE_IF:
{
setState(170);
ifElseIfBlock();
}
break;
case ELSE:
{
setState(171);
ifElseBlock();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IfElseIfBlockContext extends ParserRuleContext {
public TerminalNode ELSE_IF() { return getToken(RockerParser.ELSE_IF, 0); }
public TerminalNode RCURLY() { return getToken(RockerParser.RCURLY, 0); }
public IfElseIfBlockContext ifElseIfBlock() {
return getRuleContext(IfElseIfBlockContext.class,0);
}
public IfElseBlockContext ifElseBlock() {
return getRuleContext(IfElseBlockContext.class,0);
}
public List templateContent() {
return getRuleContexts(TemplateContentContext.class);
}
public TemplateContentContext templateContent(int i) {
return getRuleContext(TemplateContentContext.class,i);
}
public IfElseIfBlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ifElseIfBlock; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).enterIfElseIfBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).exitIfElseIfBlock(this);
}
}
public final IfElseIfBlockContext ifElseIfBlock() throws RecognitionException {
IfElseIfBlockContext _localctx = new IfElseIfBlockContext(_ctx, getState());
enterRule(_localctx, 30, RULE_ifElseIfBlock);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(174);
match(ELSE_IF);
setState(178);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LCURLY) | (1L << COMMENT) | (1L << PLAIN) | (1L << AT))) != 0)) {
{
{
setState(175);
templateContent();
}
}
setState(180);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(184);
switch (_input.LA(1)) {
case RCURLY:
{
setState(181);
match(RCURLY);
}
break;
case ELSE_IF:
{
setState(182);
ifElseIfBlock();
}
break;
case ELSE:
{
setState(183);
ifElseBlock();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IfElseBlockContext extends ParserRuleContext {
public TerminalNode ELSE() { return getToken(RockerParser.ELSE, 0); }
public TerminalNode RCURLY() { return getToken(RockerParser.RCURLY, 0); }
public List templateContent() {
return getRuleContexts(TemplateContentContext.class);
}
public TemplateContentContext templateContent(int i) {
return getRuleContext(TemplateContentContext.class,i);
}
public IfElseBlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ifElseBlock; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).enterIfElseBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).exitIfElseBlock(this);
}
}
public final IfElseBlockContext ifElseBlock() throws RecognitionException {
IfElseBlockContext _localctx = new IfElseBlockContext(_ctx, getState());
enterRule(_localctx, 32, RULE_ifElseBlock);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(186);
match(ELSE);
setState(190);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LCURLY) | (1L << COMMENT) | (1L << PLAIN) | (1L << AT))) != 0)) {
{
{
setState(187);
templateContent();
}
}
setState(192);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(193);
match(RCURLY);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ForBlockContext extends ParserRuleContext {
public TerminalNode AT() { return getToken(RockerParser.AT, 0); }
public TerminalNode MV_FOR() { return getToken(RockerParser.MV_FOR, 0); }
public TerminalNode RCURLY() { return getToken(RockerParser.RCURLY, 0); }
public List templateContent() {
return getRuleContexts(TemplateContentContext.class);
}
public TemplateContentContext templateContent(int i) {
return getRuleContext(TemplateContentContext.class,i);
}
public ForBlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forBlock; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).enterForBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).exitForBlock(this);
}
}
public final ForBlockContext forBlock() throws RecognitionException {
ForBlockContext _localctx = new ForBlockContext(_ctx, getState());
enterRule(_localctx, 34, RULE_forBlock);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(195);
match(AT);
setState(196);
match(MV_FOR);
setState(200);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LCURLY) | (1L << COMMENT) | (1L << PLAIN) | (1L << AT))) != 0)) {
{
{
setState(197);
templateContent();
}
}
setState(202);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(203);
match(RCURLY);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WithBlockContext extends ParserRuleContext {
public TerminalNode AT() { return getToken(RockerParser.AT, 0); }
public TerminalNode MV_WITH() { return getToken(RockerParser.MV_WITH, 0); }
public TerminalNode RCURLY() { return getToken(RockerParser.RCURLY, 0); }
public WithElseBlockContext withElseBlock() {
return getRuleContext(WithElseBlockContext.class,0);
}
public List templateContent() {
return getRuleContexts(TemplateContentContext.class);
}
public TemplateContentContext templateContent(int i) {
return getRuleContext(TemplateContentContext.class,i);
}
public WithBlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_withBlock; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).enterWithBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).exitWithBlock(this);
}
}
public final WithBlockContext withBlock() throws RecognitionException {
WithBlockContext _localctx = new WithBlockContext(_ctx, getState());
enterRule(_localctx, 36, RULE_withBlock);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(205);
match(AT);
setState(206);
match(MV_WITH);
setState(210);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LCURLY) | (1L << COMMENT) | (1L << PLAIN) | (1L << AT))) != 0)) {
{
{
setState(207);
templateContent();
}
}
setState(212);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(215);
switch (_input.LA(1)) {
case RCURLY:
{
setState(213);
match(RCURLY);
}
break;
case ELSE:
{
setState(214);
withElseBlock();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WithElseBlockContext extends ParserRuleContext {
public TerminalNode ELSE() { return getToken(RockerParser.ELSE, 0); }
public TerminalNode RCURLY() { return getToken(RockerParser.RCURLY, 0); }
public List templateContent() {
return getRuleContexts(TemplateContentContext.class);
}
public TemplateContentContext templateContent(int i) {
return getRuleContext(TemplateContentContext.class,i);
}
public WithElseBlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_withElseBlock; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).enterWithElseBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).exitWithElseBlock(this);
}
}
public final WithElseBlockContext withElseBlock() throws RecognitionException {
WithElseBlockContext _localctx = new WithElseBlockContext(_ctx, getState());
enterRule(_localctx, 38, RULE_withElseBlock);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(217);
match(ELSE);
setState(221);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LCURLY) | (1L << COMMENT) | (1L << PLAIN) | (1L << AT))) != 0)) {
{
{
setState(218);
templateContent();
}
}
setState(223);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(224);
match(RCURLY);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ContentClosureContext extends ParserRuleContext {
public TerminalNode AT() { return getToken(RockerParser.AT, 0); }
public ContentClosureExpressionContext contentClosureExpression() {
return getRuleContext(ContentClosureExpressionContext.class,0);
}
public TerminalNode RCURLY() { return getToken(RockerParser.RCURLY, 0); }
public List templateContent() {
return getRuleContexts(TemplateContentContext.class);
}
public TemplateContentContext templateContent(int i) {
return getRuleContext(TemplateContentContext.class,i);
}
public ContentClosureContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_contentClosure; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).enterContentClosure(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).exitContentClosure(this);
}
}
public final ContentClosureContext contentClosure() throws RecognitionException {
ContentClosureContext _localctx = new ContentClosureContext(_ctx, getState());
enterRule(_localctx, 40, RULE_contentClosure);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(226);
match(AT);
setState(227);
contentClosureExpression();
setState(231);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LCURLY) | (1L << COMMENT) | (1L << PLAIN) | (1L << AT))) != 0)) {
{
{
setState(228);
templateContent();
}
}
setState(233);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(234);
match(RCURLY);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ContentClosureExpressionContext extends ParserRuleContext {
public TerminalNode MV_CONTENT_CLOSURE() { return getToken(RockerParser.MV_CONTENT_CLOSURE, 0); }
public ContentClosureExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_contentClosureExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).enterContentClosureExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).exitContentClosureExpression(this);
}
}
public final ContentClosureExpressionContext contentClosureExpression() throws RecognitionException {
ContentClosureExpressionContext _localctx = new ContentClosureExpressionContext(_ctx, getState());
enterRule(_localctx, 42, RULE_contentClosureExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(236);
match(MV_CONTENT_CLOSURE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ValueClosureContext extends ParserRuleContext {
public TerminalNode AT() { return getToken(RockerParser.AT, 0); }
public ValueClosureExpressionContext valueClosureExpression() {
return getRuleContext(ValueClosureExpressionContext.class,0);
}
public TerminalNode RCURLY() { return getToken(RockerParser.RCURLY, 0); }
public List templateContent() {
return getRuleContexts(TemplateContentContext.class);
}
public TemplateContentContext templateContent(int i) {
return getRuleContext(TemplateContentContext.class,i);
}
public ValueClosureContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_valueClosure; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).enterValueClosure(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).exitValueClosure(this);
}
}
public final ValueClosureContext valueClosure() throws RecognitionException {
ValueClosureContext _localctx = new ValueClosureContext(_ctx, getState());
enterRule(_localctx, 44, RULE_valueClosure);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(238);
match(AT);
setState(239);
valueClosureExpression();
setState(243);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LCURLY) | (1L << COMMENT) | (1L << PLAIN) | (1L << AT))) != 0)) {
{
{
setState(240);
templateContent();
}
}
setState(245);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(246);
match(RCURLY);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ValueClosureExpressionContext extends ParserRuleContext {
public TerminalNode MV_VALUE_CLOSURE() { return getToken(RockerParser.MV_VALUE_CLOSURE, 0); }
public ValueClosureExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_valueClosureExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).enterValueClosureExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).exitValueClosureExpression(this);
}
}
public final ValueClosureExpressionContext valueClosureExpression() throws RecognitionException {
ValueClosureExpressionContext _localctx = new ValueClosureExpressionContext(_ctx, getState());
enterRule(_localctx, 46, RULE_valueClosureExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(248);
match(MV_VALUE_CLOSURE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ValueContext extends ParserRuleContext {
public TerminalNode AT() { return getToken(RockerParser.AT, 0); }
public ValueExpressionContext valueExpression() {
return getRuleContext(ValueExpressionContext.class,0);
}
public ValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_value; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).enterValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).exitValue(this);
}
}
public final ValueContext value() throws RecognitionException {
ValueContext _localctx = new ValueContext(_ctx, getState());
enterRule(_localctx, 48, RULE_value);
try {
enterOuterAlt(_localctx, 1);
{
setState(250);
match(AT);
setState(251);
valueExpression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ValueExpressionContext extends ParserRuleContext {
public TerminalNode MV_VALUE() { return getToken(RockerParser.MV_VALUE, 0); }
public ValueExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_valueExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).enterValueExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).exitValueExpression(this);
}
}
public final ValueExpressionContext valueExpression() throws RecognitionException {
ValueExpressionContext _localctx = new ValueExpressionContext(_ctx, getState());
enterRule(_localctx, 50, RULE_valueExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(253);
match(MV_VALUE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NullTernaryContext extends ParserRuleContext {
public TerminalNode AT() { return getToken(RockerParser.AT, 0); }
public NullTernaryExpressionContext nullTernaryExpression() {
return getRuleContext(NullTernaryExpressionContext.class,0);
}
public NullTernaryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_nullTernary; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).enterNullTernary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).exitNullTernary(this);
}
}
public final NullTernaryContext nullTernary() throws RecognitionException {
NullTernaryContext _localctx = new NullTernaryContext(_ctx, getState());
enterRule(_localctx, 52, RULE_nullTernary);
try {
enterOuterAlt(_localctx, 1);
{
setState(255);
match(AT);
setState(256);
nullTernaryExpression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NullTernaryExpressionContext extends ParserRuleContext {
public TerminalNode MV_NULL_TERNARY_LH() { return getToken(RockerParser.MV_NULL_TERNARY_LH, 0); }
public TerminalNode MV_NULL_TERNARY_RH() { return getToken(RockerParser.MV_NULL_TERNARY_RH, 0); }
public NullTernaryExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_nullTernaryExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).enterNullTernaryExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).exitNullTernaryExpression(this);
}
}
public final NullTernaryExpressionContext nullTernaryExpression() throws RecognitionException {
NullTernaryExpressionContext _localctx = new NullTernaryExpressionContext(_ctx, getState());
enterRule(_localctx, 54, RULE_nullTernaryExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(258);
match(MV_NULL_TERNARY_LH);
setState(259);
match(MV_NULL_TERNARY_RH);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EvalContext extends ParserRuleContext {
public TerminalNode AT() { return getToken(RockerParser.AT, 0); }
public EvalExpressionContext evalExpression() {
return getRuleContext(EvalExpressionContext.class,0);
}
public EvalContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_eval; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).enterEval(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).exitEval(this);
}
}
public final EvalContext eval() throws RecognitionException {
EvalContext _localctx = new EvalContext(_ctx, getState());
enterRule(_localctx, 56, RULE_eval);
try {
enterOuterAlt(_localctx, 1);
{
setState(261);
match(AT);
setState(262);
evalExpression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EvalExpressionContext extends ParserRuleContext {
public TerminalNode MV_EVAL() { return getToken(RockerParser.MV_EVAL, 0); }
public EvalExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_evalExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).enterEvalExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).exitEvalExpression(this);
}
}
public final EvalExpressionContext evalExpression() throws RecognitionException {
EvalExpressionContext _localctx = new EvalExpressionContext(_ctx, getState());
enterRule(_localctx, 58, RULE_evalExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(264);
match(MV_EVAL);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SwitchBlockContext extends ParserRuleContext {
public TerminalNode AT() { return getToken(RockerParser.AT, 0); }
public TerminalNode MV_SWITCH() { return getToken(RockerParser.MV_SWITCH, 0); }
public TerminalNode RCURLY() { return getToken(RockerParser.RCURLY, 0); }
public List switchCase() {
return getRuleContexts(SwitchCaseContext.class);
}
public SwitchCaseContext switchCase(int i) {
return getRuleContext(SwitchCaseContext.class,i);
}
public List switchDefault() {
return getRuleContexts(SwitchDefaultContext.class);
}
public SwitchDefaultContext switchDefault(int i) {
return getRuleContext(SwitchDefaultContext.class,i);
}
public List plain() {
return getRuleContexts(PlainContext.class);
}
public PlainContext plain(int i) {
return getRuleContext(PlainContext.class,i);
}
public List comment() {
return getRuleContexts(CommentContext.class);
}
public CommentContext comment(int i) {
return getRuleContext(CommentContext.class,i);
}
public SwitchBlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_switchBlock; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).enterSwitchBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).exitSwitchBlock(this);
}
}
public final SwitchBlockContext switchBlock() throws RecognitionException {
SwitchBlockContext _localctx = new SwitchBlockContext(_ctx, getState());
enterRule(_localctx, 60, RULE_switchBlock);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(266);
match(AT);
setState(267);
match(MV_SWITCH);
setState(274);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << CASE) | (1L << DEFAULT) | (1L << LCURLY) | (1L << COMMENT) | (1L << PLAIN))) != 0)) {
{
setState(272);
switch (_input.LA(1)) {
case CASE:
{
setState(268);
switchCase();
}
break;
case DEFAULT:
{
setState(269);
switchDefault();
}
break;
case LCURLY:
case PLAIN:
{
setState(270);
plain();
}
break;
case COMMENT:
{
setState(271);
comment();
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(276);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(277);
match(RCURLY);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SwitchCaseContext extends ParserRuleContext {
public TerminalNode CASE() { return getToken(RockerParser.CASE, 0); }
public TerminalNode RCURLY() { return getToken(RockerParser.RCURLY, 0); }
public List templateContent() {
return getRuleContexts(TemplateContentContext.class);
}
public TemplateContentContext templateContent(int i) {
return getRuleContext(TemplateContentContext.class,i);
}
public SwitchCaseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_switchCase; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).enterSwitchCase(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).exitSwitchCase(this);
}
}
public final SwitchCaseContext switchCase() throws RecognitionException {
SwitchCaseContext _localctx = new SwitchCaseContext(_ctx, getState());
enterRule(_localctx, 62, RULE_switchCase);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(279);
match(CASE);
setState(283);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LCURLY) | (1L << COMMENT) | (1L << PLAIN) | (1L << AT))) != 0)) {
{
{
setState(280);
templateContent();
}
}
setState(285);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(286);
match(RCURLY);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SwitchDefaultContext extends ParserRuleContext {
public TerminalNode DEFAULT() { return getToken(RockerParser.DEFAULT, 0); }
public TerminalNode RCURLY() { return getToken(RockerParser.RCURLY, 0); }
public List templateContent() {
return getRuleContexts(TemplateContentContext.class);
}
public TemplateContentContext templateContent(int i) {
return getRuleContext(TemplateContentContext.class,i);
}
public SwitchDefaultContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_switchDefault; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).enterSwitchDefault(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).exitSwitchDefault(this);
}
}
public final SwitchDefaultContext switchDefault() throws RecognitionException {
SwitchDefaultContext _localctx = new SwitchDefaultContext(_ctx, getState());
enterRule(_localctx, 64, RULE_switchDefault);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(288);
match(DEFAULT);
setState(292);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LCURLY) | (1L << COMMENT) | (1L << PLAIN) | (1L << AT))) != 0)) {
{
{
setState(289);
templateContent();
}
}
setState(294);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(295);
match(RCURLY);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SwitchExpressionBlockContext extends ParserRuleContext {
public TerminalNode AT() { return getToken(RockerParser.AT, 0); }
public TerminalNode MV_SWITCH() { return getToken(RockerParser.MV_SWITCH, 0); }
public TerminalNode RCURLY() { return getToken(RockerParser.RCURLY, 0); }
public List switchExpressionCase() {
return getRuleContexts(SwitchExpressionCaseContext.class);
}
public SwitchExpressionCaseContext switchExpressionCase(int i) {
return getRuleContext(SwitchExpressionCaseContext.class,i);
}
public List switchExpressionDefault() {
return getRuleContexts(SwitchExpressionDefaultContext.class);
}
public SwitchExpressionDefaultContext switchExpressionDefault(int i) {
return getRuleContext(SwitchExpressionDefaultContext.class,i);
}
public List plain() {
return getRuleContexts(PlainContext.class);
}
public PlainContext plain(int i) {
return getRuleContext(PlainContext.class,i);
}
public List comment() {
return getRuleContexts(CommentContext.class);
}
public CommentContext comment(int i) {
return getRuleContext(CommentContext.class,i);
}
public SwitchExpressionBlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_switchExpressionBlock; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).enterSwitchExpressionBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).exitSwitchExpressionBlock(this);
}
}
public final SwitchExpressionBlockContext switchExpressionBlock() throws RecognitionException {
SwitchExpressionBlockContext _localctx = new SwitchExpressionBlockContext(_ctx, getState());
enterRule(_localctx, 66, RULE_switchExpressionBlock);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(297);
match(AT);
setState(298);
match(MV_SWITCH);
setState(305);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << CASE_EXPRESSION) | (1L << DEFAULT_EXPRESSION) | (1L << LCURLY) | (1L << COMMENT) | (1L << PLAIN))) != 0)) {
{
setState(303);
switch (_input.LA(1)) {
case CASE_EXPRESSION:
{
setState(299);
switchExpressionCase();
}
break;
case DEFAULT_EXPRESSION:
{
setState(300);
switchExpressionDefault();
}
break;
case LCURLY:
case PLAIN:
{
setState(301);
plain();
}
break;
case COMMENT:
{
setState(302);
comment();
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(307);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(308);
match(RCURLY);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SwitchExpressionCaseContext extends ParserRuleContext {
public TerminalNode CASE_EXPRESSION() { return getToken(RockerParser.CASE_EXPRESSION, 0); }
public TerminalNode RCURLY() { return getToken(RockerParser.RCURLY, 0); }
public List templateContent() {
return getRuleContexts(TemplateContentContext.class);
}
public TemplateContentContext templateContent(int i) {
return getRuleContext(TemplateContentContext.class,i);
}
public SwitchExpressionCaseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_switchExpressionCase; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).enterSwitchExpressionCase(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).exitSwitchExpressionCase(this);
}
}
public final SwitchExpressionCaseContext switchExpressionCase() throws RecognitionException {
SwitchExpressionCaseContext _localctx = new SwitchExpressionCaseContext(_ctx, getState());
enterRule(_localctx, 68, RULE_switchExpressionCase);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(310);
match(CASE_EXPRESSION);
setState(314);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LCURLY) | (1L << COMMENT) | (1L << PLAIN) | (1L << AT))) != 0)) {
{
{
setState(311);
templateContent();
}
}
setState(316);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(317);
match(RCURLY);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SwitchExpressionDefaultContext extends ParserRuleContext {
public TerminalNode DEFAULT_EXPRESSION() { return getToken(RockerParser.DEFAULT_EXPRESSION, 0); }
public TerminalNode RCURLY() { return getToken(RockerParser.RCURLY, 0); }
public List templateContent() {
return getRuleContexts(TemplateContentContext.class);
}
public TemplateContentContext templateContent(int i) {
return getRuleContext(TemplateContentContext.class,i);
}
public SwitchExpressionDefaultContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_switchExpressionDefault; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).enterSwitchExpressionDefault(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RockerParserListener ) ((RockerParserListener)listener).exitSwitchExpressionDefault(this);
}
}
public final SwitchExpressionDefaultContext switchExpressionDefault() throws RecognitionException {
SwitchExpressionDefaultContext _localctx = new SwitchExpressionDefaultContext(_ctx, getState());
enterRule(_localctx, 70, RULE_switchExpressionDefault);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(319);
match(DEFAULT_EXPRESSION);
setState(323);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LCURLY) | (1L << COMMENT) | (1L << PLAIN) | (1L << AT))) != 0)) {
{
{
setState(320);
templateContent();
}
}
setState(325);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(326);
match(RCURLY);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static final String _serializedATN =
"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3\32\u014b\4\2\t\2"+
"\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"+
"\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\3\2\3\2\3\2\3\2\7\2O\n\2\f\2\16\2R\13\2"+
"\3\2\5\2U\n\2\3\2\7\2X\n\2\f\2\16\2[\13\2\3\3\3\3\5\3_\n\3\3\4\3\4\7\4"+
"c\n\4\f\4\16\4f\13\4\3\4\7\4i\n\4\f\4\16\4l\13\4\3\4\3\4\5\4p\n\4\3\5"+
"\3\5\7\5t\n\5\f\5\16\5w\13\5\3\6\3\6\7\6{\n\6\f\6\16\6~\13\6\3\6\3\6\3"+
"\7\3\7\3\b\3\b\3\b\3\t\3\t\3\n\3\n\3\n\3\13\3\13\3\f\3\f\3\f\3\r\3\r\3"+
"\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\5\16\u009b\n\16\3\17\3\17\3\17"+
"\3\17\3\17\5\17\u00a2\n\17\3\20\3\20\3\20\7\20\u00a7\n\20\f\20\16\20\u00aa"+
"\13\20\3\20\3\20\3\20\5\20\u00af\n\20\3\21\3\21\7\21\u00b3\n\21\f\21\16"+
"\21\u00b6\13\21\3\21\3\21\3\21\5\21\u00bb\n\21\3\22\3\22\7\22\u00bf\n"+
"\22\f\22\16\22\u00c2\13\22\3\22\3\22\3\23\3\23\3\23\7\23\u00c9\n\23\f"+
"\23\16\23\u00cc\13\23\3\23\3\23\3\24\3\24\3\24\7\24\u00d3\n\24\f\24\16"+
"\24\u00d6\13\24\3\24\3\24\5\24\u00da\n\24\3\25\3\25\7\25\u00de\n\25\f"+
"\25\16\25\u00e1\13\25\3\25\3\25\3\26\3\26\3\26\7\26\u00e8\n\26\f\26\16"+
"\26\u00eb\13\26\3\26\3\26\3\27\3\27\3\30\3\30\3\30\7\30\u00f4\n\30\f\30"+
"\16\30\u00f7\13\30\3\30\3\30\3\31\3\31\3\32\3\32\3\32\3\33\3\33\3\34\3"+
"\34\3\34\3\35\3\35\3\35\3\36\3\36\3\36\3\37\3\37\3 \3 \3 \3 \3 \3 \7 "+
"\u0113\n \f \16 \u0116\13 \3 \3 \3!\3!\7!\u011c\n!\f!\16!\u011f\13!\3"+
"!\3!\3\"\3\"\7\"\u0125\n\"\f\"\16\"\u0128\13\"\3\"\3\"\3#\3#\3#\3#\3#"+
"\3#\7#\u0132\n#\f#\16#\u0135\13#\3#\3#\3$\3$\7$\u013b\n$\f$\16$\u013e"+
"\13$\3$\3$\3%\3%\7%\u0144\n%\f%\16%\u0147\13%\3%\3%\3%\2\2&\2\4\6\b\n"+
"\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFH\2\2\u0156"+
"\2P\3\2\2\2\4^\3\2\2\2\6`\3\2\2\2\bq\3\2\2\2\nx\3\2\2\2\f\u0081\3\2\2"+
"\2\16\u0083\3\2\2\2\20\u0086\3\2\2\2\22\u0088\3\2\2\2\24\u008b\3\2\2\2"+
"\26\u008d\3\2\2\2\30\u0090\3\2\2\2\32\u009a\3\2\2\2\34\u00a1\3\2\2\2\36"+
"\u00a3\3\2\2\2 \u00b0\3\2\2\2\"\u00bc\3\2\2\2$\u00c5\3\2\2\2&\u00cf\3"+
"\2\2\2(\u00db\3\2\2\2*\u00e4\3\2\2\2,\u00ee\3\2\2\2.\u00f0\3\2\2\2\60"+
"\u00fa\3\2\2\2\62\u00fc\3\2\2\2\64\u00ff\3\2\2\2\66\u0101\3\2\2\28\u0104"+
"\3\2\2\2:\u0107\3\2\2\2<\u010a\3\2\2\2>\u010c\3\2\2\2@\u0119\3\2\2\2B"+
"\u0122\3\2\2\2D\u012b\3\2\2\2F\u0138\3\2\2\2H\u0141\3\2\2\2JO\5\4\3\2"+
"KO\5\f\7\2LO\5\16\b\2MO\5\22\n\2NJ\3\2\2\2NK\3\2\2\2NL\3\2\2\2NM\3\2\2"+
"\2OR\3\2\2\2PN\3\2\2\2PQ\3\2\2\2QT\3\2\2\2RP\3\2\2\2SU\5\26\f\2TS\3\2"+
"\2\2TU\3\2\2\2UY\3\2\2\2VX\5\32\16\2WV\3\2\2\2X[\3\2\2\2YW\3\2\2\2YZ\3"+
"\2\2\2Z\3\3\2\2\2[Y\3\2\2\2\\_\7\f\2\2]_\5\6\4\2^\\\3\2\2\2^]\3\2\2\2"+
"_\5\3\2\2\2`d\7\t\2\2ac\5\32\16\2ba\3\2\2\2cf\3\2\2\2db\3\2\2\2de\3\2"+
"\2\2ej\3\2\2\2fd\3\2\2\2gi\5\b\5\2hg\3\2\2\2il\3\2\2\2jh\3\2\2\2jk\3\2"+
"\2\2ko\3\2\2\2lj\3\2\2\2mp\7\n\2\2np\5\n\6\2om\3\2\2\2on\3\2\2\2p\7\3"+
"\2\2\2qu\7\3\2\2rt\5\32\16\2sr\3\2\2\2tw\3\2\2\2us\3\2\2\2uv\3\2\2\2v"+
"\t\3\2\2\2wu\3\2\2\2x|\7\4\2\2y{\5\32\16\2zy\3\2\2\2{~\3\2\2\2|z\3\2\2"+
"\2|}\3\2\2\2}\177\3\2\2\2~|\3\2\2\2\177\u0080\7\n\2\2\u0080\13\3\2\2\2"+
"\u0081\u0082\7\13\2\2\u0082\r\3\2\2\2\u0083\u0084\7\r\2\2\u0084\u0085"+
"\5\20\t\2\u0085\17\3\2\2\2\u0086\u0087\7\16\2\2\u0087\21\3\2\2\2\u0088"+
"\u0089\7\r\2\2\u0089\u008a\5\24\13\2\u008a\23\3\2\2\2\u008b\u008c\7\17"+
"\2\2\u008c\25\3\2\2\2\u008d\u008e\7\r\2\2\u008e\u008f\5\30\r\2\u008f\27"+
"\3\2\2\2\u0090\u0091\7\20\2\2\u0091\31\3\2\2\2\u0092\u009b\5\f\7\2\u0093"+
"\u009b\5\34\17\2\u0094\u009b\5\4\3\2\u0095\u009b\5*\26\2\u0096\u009b\5"+
".\30\2\u0097\u009b\5\62\32\2\u0098\u009b\5\66\34\2\u0099\u009b\5:\36\2"+
"\u009a\u0092\3\2\2\2\u009a\u0093\3\2\2\2\u009a\u0094\3\2\2\2\u009a\u0095"+
"\3\2\2\2\u009a\u0096\3\2\2\2\u009a\u0097\3\2\2\2\u009a\u0098\3\2\2\2\u009a"+
"\u0099\3\2\2\2\u009b\33\3\2\2\2\u009c\u00a2\5\36\20\2\u009d\u00a2\5$\23"+
"\2\u009e\u00a2\5&\24\2\u009f\u00a2\5> \2\u00a0\u00a2\5D#\2\u00a1\u009c"+
"\3\2\2\2\u00a1\u009d\3\2\2\2\u00a1\u009e\3\2\2\2\u00a1\u009f\3\2\2\2\u00a1"+
"\u00a0\3\2\2\2\u00a2\35\3\2\2\2\u00a3\u00a4\7\r\2\2\u00a4\u00a8\7\21\2"+
"\2\u00a5\u00a7\5\32\16\2\u00a6\u00a5\3\2\2\2\u00a7\u00aa\3\2\2\2\u00a8"+
"\u00a6\3\2\2\2\u00a8\u00a9\3\2\2\2\u00a9\u00ae\3\2\2\2\u00aa\u00a8\3\2"+
"\2\2\u00ab\u00af\7\n\2\2\u00ac\u00af\5 \21\2\u00ad\u00af\5\"\22\2\u00ae"+
"\u00ab\3\2\2\2\u00ae\u00ac\3\2\2\2\u00ae\u00ad\3\2\2\2\u00af\37\3\2\2"+
"\2\u00b0\u00b4\7\3\2\2\u00b1\u00b3\5\32\16\2\u00b2\u00b1\3\2\2\2\u00b3"+
"\u00b6\3\2\2\2\u00b4\u00b2\3\2\2\2\u00b4\u00b5\3\2\2\2\u00b5\u00ba\3\2"+
"\2\2\u00b6\u00b4\3\2\2\2\u00b7\u00bb\7\n\2\2\u00b8\u00bb\5 \21\2\u00b9"+
"\u00bb\5\"\22\2\u00ba\u00b7\3\2\2\2\u00ba\u00b8\3\2\2\2\u00ba\u00b9\3"+
"\2\2\2\u00bb!\3\2\2\2\u00bc\u00c0\7\4\2\2\u00bd\u00bf\5\32\16\2\u00be"+
"\u00bd\3\2\2\2\u00bf\u00c2\3\2\2\2\u00c0\u00be\3\2\2\2\u00c0\u00c1\3\2"+
"\2\2\u00c1\u00c3\3\2\2\2\u00c2\u00c0\3\2\2\2\u00c3\u00c4\7\n\2\2\u00c4"+
"#\3\2\2\2\u00c5\u00c6\7\r\2\2\u00c6\u00ca\7\23\2\2\u00c7\u00c9\5\32\16"+
"\2\u00c8\u00c7\3\2\2\2\u00c9\u00cc\3\2\2\2\u00ca\u00c8\3\2\2\2\u00ca\u00cb"+
"\3\2\2\2\u00cb\u00cd\3\2\2\2\u00cc\u00ca\3\2\2\2\u00cd\u00ce\7\n\2\2\u00ce"+
"%\3\2\2\2\u00cf\u00d0\7\r\2\2\u00d0\u00d4\7\24\2\2\u00d1\u00d3\5\32\16"+
"\2\u00d2\u00d1\3\2\2\2\u00d3\u00d6\3\2\2\2\u00d4\u00d2\3\2\2\2\u00d4\u00d5"+
"\3\2\2\2\u00d5\u00d9\3\2\2\2\u00d6\u00d4\3\2\2\2\u00d7\u00da\7\n\2\2\u00d8"+
"\u00da\5(\25\2\u00d9\u00d7\3\2\2\2\u00d9\u00d8\3\2\2\2\u00da\'\3\2\2\2"+
"\u00db\u00df\7\4\2\2\u00dc\u00de\5\32\16\2\u00dd\u00dc\3\2\2\2\u00de\u00e1"+
"\3\2\2\2\u00df\u00dd\3\2\2\2\u00df\u00e0\3\2\2\2\u00e0\u00e2\3\2\2\2\u00e1"+
"\u00df\3\2\2\2\u00e2\u00e3\7\n\2\2\u00e3)\3\2\2\2\u00e4\u00e5\7\r\2\2"+
"\u00e5\u00e9\5,\27\2\u00e6\u00e8\5\32\16\2\u00e7\u00e6\3\2\2\2\u00e8\u00eb"+
"\3\2\2\2\u00e9\u00e7\3\2\2\2\u00e9\u00ea\3\2\2\2\u00ea\u00ec\3\2\2\2\u00eb"+
"\u00e9\3\2\2\2\u00ec\u00ed\7\n\2\2\u00ed+\3\2\2\2\u00ee\u00ef\7\25\2\2"+
"\u00ef-\3\2\2\2\u00f0\u00f1\7\r\2\2\u00f1\u00f5\5\60\31\2\u00f2\u00f4"+
"\5\32\16\2\u00f3\u00f2\3\2\2\2\u00f4\u00f7\3\2\2\2\u00f5\u00f3\3\2\2\2"+
"\u00f5\u00f6\3\2\2\2\u00f6\u00f8\3\2\2\2\u00f7\u00f5\3\2\2\2\u00f8\u00f9"+
"\7\n\2\2\u00f9/\3\2\2\2\u00fa\u00fb\7\26\2\2\u00fb\61\3\2\2\2\u00fc\u00fd"+
"\7\r\2\2\u00fd\u00fe\5\64\33\2\u00fe\63\3\2\2\2\u00ff\u0100\7\31\2\2\u0100"+
"\65\3\2\2\2\u0101\u0102\7\r\2\2\u0102\u0103\58\35\2\u0103\67\3\2\2\2\u0104"+
"\u0105\7\30\2\2\u0105\u0106\7\32\2\2\u01069\3\2\2\2\u0107\u0108\7\r\2"+
"\2\u0108\u0109\5<\37\2\u0109;\3\2\2\2\u010a\u010b\7\27\2\2\u010b=\3\2"+
"\2\2\u010c\u010d\7\r\2\2\u010d\u0114\7\22\2\2\u010e\u0113\5@!\2\u010f"+
"\u0113\5B\"\2\u0110\u0113\5\4\3\2\u0111\u0113\5\f\7\2\u0112\u010e\3\2"+
"\2\2\u0112\u010f\3\2\2\2\u0112\u0110\3\2\2\2\u0112\u0111\3\2\2\2\u0113"+
"\u0116\3\2\2\2\u0114\u0112\3\2\2\2\u0114\u0115\3\2\2\2\u0115\u0117\3\2"+
"\2\2\u0116\u0114\3\2\2\2\u0117\u0118\7\n\2\2\u0118?\3\2\2\2\u0119\u011d"+
"\7\5\2\2\u011a\u011c\5\32\16\2\u011b\u011a\3\2\2\2\u011c\u011f\3\2\2\2"+
"\u011d\u011b\3\2\2\2\u011d\u011e\3\2\2\2\u011e\u0120\3\2\2\2\u011f\u011d"+
"\3\2\2\2\u0120\u0121\7\n\2\2\u0121A\3\2\2\2\u0122\u0126\7\7\2\2\u0123"+
"\u0125\5\32\16\2\u0124\u0123\3\2\2\2\u0125\u0128\3\2\2\2\u0126\u0124\3"+
"\2\2\2\u0126\u0127\3\2\2\2\u0127\u0129\3\2\2\2\u0128\u0126\3\2\2\2\u0129"+
"\u012a\7\n\2\2\u012aC\3\2\2\2\u012b\u012c\7\r\2\2\u012c\u0133\7\22\2\2"+
"\u012d\u0132\5F$\2\u012e\u0132\5H%\2\u012f\u0132\5\4\3\2\u0130\u0132\5"+
"\f\7\2\u0131\u012d\3\2\2\2\u0131\u012e\3\2\2\2\u0131\u012f\3\2\2\2\u0131"+
"\u0130\3\2\2\2\u0132\u0135\3\2\2\2\u0133\u0131\3\2\2\2\u0133\u0134\3\2"+
"\2\2\u0134\u0136\3\2\2\2\u0135\u0133\3\2\2\2\u0136\u0137\7\n\2\2\u0137"+
"E\3\2\2\2\u0138\u013c\7\6\2\2\u0139\u013b\5\32\16\2\u013a\u0139\3\2\2"+
"\2\u013b\u013e\3\2\2\2\u013c\u013a\3\2\2\2\u013c\u013d\3\2\2\2\u013d\u013f"+
"\3\2\2\2\u013e\u013c\3\2\2\2\u013f\u0140\7\n\2\2\u0140G\3\2\2\2\u0141"+
"\u0145\7\b\2\2\u0142\u0144\5\32\16\2\u0143\u0142\3\2\2\2\u0144\u0147\3"+
"\2\2\2\u0145\u0143\3\2\2\2\u0145\u0146\3\2\2\2\u0146\u0148\3\2\2\2\u0147"+
"\u0145\3\2\2\2\u0148\u0149\7\n\2\2\u0149I\3\2\2\2!NPTY^djou|\u009a\u00a1"+
"\u00a8\u00ae\u00b4\u00ba\u00c0\u00ca\u00d4\u00d9\u00df\u00e9\u00f5\u0112"+
"\u0114\u011d\u0126\u0131\u0133\u013c\u0145";
public static final ATN _ATN =
new ATNDeserializer().deserialize(_serializedATN.toCharArray());
static {
_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
}
}
} © 2015 - 2024 Weber Informatics LLC | Privacy Policy