com.github.jknack.handlebars.internal.HbsParser Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of handlebars Show documentation
Show all versions of handlebars Show documentation
Logic-less and semantic templates with Java
// Generated from com/github/jknack/handlebars/internal/HbsParser.g4 by ANTLR 4.1
package com.github.jknack.handlebars.internal;
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 HbsParser extends Parser {
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
START_DELIM=7, END_DELIM=13, ELSE=25, DOUBLE_STRING=20, WS_PATH=17, SINGLE_STRING=21,
INT=23, START_PARTIAL=8, TEXT=1, WS_DELIM=14, DELIM=15, SPACE=11, END_T=18,
START_AMP=3, QID=26, WS=27, BOOLEAN=24, END_BLOCK=9, START_T=4, START_BLOCK=6,
PATH=16, START=10, NL=12, EQ=22, COMMENT=2, END=19, UNLESS=5;
public static final String[] tokenNames = {
"", "TEXT", "COMMENT", "START_AMP", "START_T", "UNLESS", "START_BLOCK",
"START_DELIM", "START_PARTIAL", "END_BLOCK", "START", "SPACE", "NL", "END_DELIM",
"WS_DELIM", "DELIM", "PATH", "WS_PATH", "END_T", "END", "DOUBLE_STRING",
"SINGLE_STRING", "'='", "INT", "BOOLEAN", "'else'", "QID", "WS"
};
public static final int
RULE_template = 0, RULE_body = 1, RULE_statement = 2, RULE_text = 3, RULE_spaces = 4,
RULE_newline = 5, RULE_block = 6, RULE_unless = 7, RULE_tvar = 8, RULE_ampvar = 9,
RULE_var = 10, RULE_delimiters = 11, RULE_partial = 12, RULE_param = 13,
RULE_hash = 14, RULE_hashValue = 15, RULE_comment = 16;
public static final String[] ruleNames = {
"template", "body", "statement", "text", "spaces", "newline", "block",
"unless", "tvar", "ampvar", "var", "delimiters", "partial", "param", "hash",
"hashValue", "comment"
};
@Override
public String getGrammarFileName() { return "HbsParser.g4"; }
@Override
public String[] getTokenNames() { return tokenNames; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public ATN getATN() { return _ATN; }
void setStart(String start) {
}
void setEnd(String end) {
}
private String join(List tokens) {
StringBuilder text = new StringBuilder();
for(Token token: tokens) {
text.append(token.getText());
}
return text.toString();
}
public HbsParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class TemplateContext extends ParserRuleContext {
public TerminalNode EOF() { return getToken(HbsParser.EOF, 0); }
public BodyContext body() {
return getRuleContext(BodyContext.class,0);
}
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 HbsParserListener ) ((HbsParserListener)listener).enterTemplate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).exitTemplate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HbsParserVisitor ) return ((HbsParserVisitor)visitor).visitTemplate(this);
else return visitor.visitChildren(this);
}
}
public final TemplateContext template() throws RecognitionException {
TemplateContext _localctx = new TemplateContext(_ctx, getState());
enterRule(_localctx, 0, RULE_template);
try {
enterOuterAlt(_localctx, 1);
{
setState(34); body();
setState(35); match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BodyContext extends ParserRuleContext {
public List statement() {
return getRuleContexts(StatementContext.class);
}
public StatementContext statement(int i) {
return getRuleContext(StatementContext.class,i);
}
public BodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_body; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).enterBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).exitBody(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HbsParserVisitor ) return ((HbsParserVisitor)visitor).visitBody(this);
else return visitor.visitChildren(this);
}
}
public final BodyContext body() throws RecognitionException {
BodyContext _localctx = new BodyContext(_ctx, getState());
enterRule(_localctx, 2, RULE_body);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(40);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,0,_ctx);
while ( _alt!=2 && _alt!=-1 ) {
if ( _alt==1 ) {
{
{
setState(37); statement();
}
}
}
setState(42);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,0,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StatementContext extends ParserRuleContext {
public TextContext text() {
return getRuleContext(TextContext.class,0);
}
public CommentContext comment() {
return getRuleContext(CommentContext.class,0);
}
public PartialContext partial() {
return getRuleContext(PartialContext.class,0);
}
public SpacesContext spaces() {
return getRuleContext(SpacesContext.class,0);
}
public TvarContext tvar() {
return getRuleContext(TvarContext.class,0);
}
public UnlessContext unless() {
return getRuleContext(UnlessContext.class,0);
}
public AmpvarContext ampvar() {
return getRuleContext(AmpvarContext.class,0);
}
public NewlineContext newline() {
return getRuleContext(NewlineContext.class,0);
}
public VarContext var() {
return getRuleContext(VarContext.class,0);
}
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public DelimitersContext delimiters() {
return getRuleContext(DelimitersContext.class,0);
}
public StatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_statement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).enterStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).exitStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HbsParserVisitor ) return ((HbsParserVisitor)visitor).visitStatement(this);
else return visitor.visitChildren(this);
}
}
public final StatementContext statement() throws RecognitionException {
StatementContext _localctx = new StatementContext(_ctx, getState());
enterRule(_localctx, 4, RULE_statement);
try {
setState(54);
switch (_input.LA(1)) {
case SPACE:
enterOuterAlt(_localctx, 1);
{
setState(43); spaces();
}
break;
case NL:
enterOuterAlt(_localctx, 2);
{
setState(44); newline();
}
break;
case TEXT:
enterOuterAlt(_localctx, 3);
{
setState(45); text();
}
break;
case START_BLOCK:
enterOuterAlt(_localctx, 4);
{
setState(46); block();
}
break;
case START:
enterOuterAlt(_localctx, 5);
{
setState(47); var();
}
break;
case START_T:
enterOuterAlt(_localctx, 6);
{
setState(48); tvar();
}
break;
case START_AMP:
enterOuterAlt(_localctx, 7);
{
setState(49); ampvar();
}
break;
case UNLESS:
enterOuterAlt(_localctx, 8);
{
setState(50); unless();
}
break;
case START_PARTIAL:
enterOuterAlt(_localctx, 9);
{
setState(51); partial();
}
break;
case COMMENT:
enterOuterAlt(_localctx, 10);
{
setState(52); comment();
}
break;
case START_DELIM:
enterOuterAlt(_localctx, 11);
{
setState(53); delimiters();
}
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 TextContext extends ParserRuleContext {
public TerminalNode TEXT() { return getToken(HbsParser.TEXT, 0); }
public TextContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_text; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).enterText(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).exitText(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HbsParserVisitor ) return ((HbsParserVisitor)visitor).visitText(this);
else return visitor.visitChildren(this);
}
}
public final TextContext text() throws RecognitionException {
TextContext _localctx = new TextContext(_ctx, getState());
enterRule(_localctx, 6, RULE_text);
try {
enterOuterAlt(_localctx, 1);
{
setState(56); match(TEXT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SpacesContext extends ParserRuleContext {
public TerminalNode SPACE() { return getToken(HbsParser.SPACE, 0); }
public SpacesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_spaces; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).enterSpaces(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).exitSpaces(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HbsParserVisitor ) return ((HbsParserVisitor)visitor).visitSpaces(this);
else return visitor.visitChildren(this);
}
}
public final SpacesContext spaces() throws RecognitionException {
SpacesContext _localctx = new SpacesContext(_ctx, getState());
enterRule(_localctx, 8, RULE_spaces);
try {
enterOuterAlt(_localctx, 1);
{
setState(58); match(SPACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NewlineContext extends ParserRuleContext {
public TerminalNode NL() { return getToken(HbsParser.NL, 0); }
public NewlineContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_newline; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).enterNewline(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).exitNewline(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HbsParserVisitor ) return ((HbsParserVisitor)visitor).visitNewline(this);
else return visitor.visitChildren(this);
}
}
public final NewlineContext newline() throws RecognitionException {
NewlineContext _localctx = new NewlineContext(_ctx, getState());
enterRule(_localctx, 10, RULE_newline);
try {
enterOuterAlt(_localctx, 1);
{
setState(60); match(NL);
}
}
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 Token nameStart;
public BodyContext thenBody;
public Token inverseToken;
public BodyContext unlessBody;
public Token nameEnd;
public TerminalNode UNLESS() { return getToken(HbsParser.UNLESS, 0); }
public List body() {
return getRuleContexts(BodyContext.class);
}
public List param() {
return getRuleContexts(ParamContext.class);
}
public TerminalNode QID(int i) {
return getToken(HbsParser.QID, i);
}
public TerminalNode END(int i) {
return getToken(HbsParser.END, i);
}
public List QID() { return getTokens(HbsParser.QID); }
public TerminalNode START_BLOCK() { return getToken(HbsParser.START_BLOCK, 0); }
public ParamContext param(int i) {
return getRuleContext(ParamContext.class,i);
}
public TerminalNode START() { return getToken(HbsParser.START, 0); }
public TerminalNode ELSE() { return getToken(HbsParser.ELSE, 0); }
public TerminalNode END_BLOCK() { return getToken(HbsParser.END_BLOCK, 0); }
public List hash() {
return getRuleContexts(HashContext.class);
}
public HashContext hash(int i) {
return getRuleContext(HashContext.class,i);
}
public BodyContext body(int i) {
return getRuleContext(BodyContext.class,i);
}
public List END() { return getTokens(HbsParser.END); }
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 HbsParserListener ) ((HbsParserListener)listener).enterBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).exitBlock(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HbsParserVisitor ) return ((HbsParserVisitor)visitor).visitBlock(this);
else return visitor.visitChildren(this);
}
}
public final BlockContext block() throws RecognitionException {
BlockContext _localctx = new BlockContext(_ctx, getState());
enterRule(_localctx, 12, RULE_block);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(62); match(START_BLOCK);
setState(63); ((BlockContext)_localctx).nameStart = match(QID);
setState(67);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,2,_ctx);
while ( _alt!=2 && _alt!=-1 ) {
if ( _alt==1 ) {
{
{
setState(64); param();
}
}
}
setState(69);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,2,_ctx);
}
setState(73);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==QID) {
{
{
setState(70); hash();
}
}
setState(75);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(76); match(END);
setState(77); ((BlockContext)_localctx).thenBody = body();
setState(85);
_la = _input.LA(1);
if (_la==UNLESS || _la==START) {
{
setState(81);
switch (_input.LA(1)) {
case UNLESS:
{
setState(78); ((BlockContext)_localctx).inverseToken = match(UNLESS);
}
break;
case START:
{
setState(79); match(START);
setState(80); ((BlockContext)_localctx).inverseToken = match(ELSE);
}
break;
default:
throw new NoViableAltException(this);
}
setState(83); match(END);
setState(84); ((BlockContext)_localctx).unlessBody = body();
}
}
setState(87); match(END_BLOCK);
setState(88); ((BlockContext)_localctx).nameEnd = match(QID);
setState(89); match(END);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UnlessContext extends ParserRuleContext {
public Token nameStart;
public Token nameEnd;
public TerminalNode UNLESS() { return getToken(HbsParser.UNLESS, 0); }
public TerminalNode END_BLOCK() { return getToken(HbsParser.END_BLOCK, 0); }
public BodyContext body() {
return getRuleContext(BodyContext.class,0);
}
public TerminalNode QID(int i) {
return getToken(HbsParser.QID, i);
}
public TerminalNode END(int i) {
return getToken(HbsParser.END, i);
}
public List QID() { return getTokens(HbsParser.QID); }
public List END() { return getTokens(HbsParser.END); }
public UnlessContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unless; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).enterUnless(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).exitUnless(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HbsParserVisitor ) return ((HbsParserVisitor)visitor).visitUnless(this);
else return visitor.visitChildren(this);
}
}
public final UnlessContext unless() throws RecognitionException {
UnlessContext _localctx = new UnlessContext(_ctx, getState());
enterRule(_localctx, 14, RULE_unless);
try {
enterOuterAlt(_localctx, 1);
{
setState(91); match(UNLESS);
setState(92); ((UnlessContext)_localctx).nameStart = match(QID);
setState(93); match(END);
setState(94); body();
setState(95); match(END_BLOCK);
setState(96); ((UnlessContext)_localctx).nameEnd = match(QID);
setState(97); match(END);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TvarContext extends ParserRuleContext {
public List hash() {
return getRuleContexts(HashContext.class);
}
public HashContext hash(int i) {
return getRuleContext(HashContext.class,i);
}
public List param() {
return getRuleContexts(ParamContext.class);
}
public TerminalNode START_T() { return getToken(HbsParser.START_T, 0); }
public TerminalNode QID() { return getToken(HbsParser.QID, 0); }
public ParamContext param(int i) {
return getRuleContext(ParamContext.class,i);
}
public TerminalNode END_T() { return getToken(HbsParser.END_T, 0); }
public TvarContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tvar; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).enterTvar(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).exitTvar(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HbsParserVisitor ) return ((HbsParserVisitor)visitor).visitTvar(this);
else return visitor.visitChildren(this);
}
}
public final TvarContext tvar() throws RecognitionException {
TvarContext _localctx = new TvarContext(_ctx, getState());
enterRule(_localctx, 16, RULE_tvar);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(99); match(START_T);
setState(100); match(QID);
setState(104);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,6,_ctx);
while ( _alt!=2 && _alt!=-1 ) {
if ( _alt==1 ) {
{
{
setState(101); param();
}
}
}
setState(106);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,6,_ctx);
}
setState(110);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==QID) {
{
{
setState(107); hash();
}
}
setState(112);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(113); match(END_T);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AmpvarContext extends ParserRuleContext {
public List hash() {
return getRuleContexts(HashContext.class);
}
public HashContext hash(int i) {
return getRuleContext(HashContext.class,i);
}
public List param() {
return getRuleContexts(ParamContext.class);
}
public TerminalNode QID() { return getToken(HbsParser.QID, 0); }
public TerminalNode START_AMP() { return getToken(HbsParser.START_AMP, 0); }
public ParamContext param(int i) {
return getRuleContext(ParamContext.class,i);
}
public TerminalNode END() { return getToken(HbsParser.END, 0); }
public AmpvarContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ampvar; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).enterAmpvar(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).exitAmpvar(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HbsParserVisitor ) return ((HbsParserVisitor)visitor).visitAmpvar(this);
else return visitor.visitChildren(this);
}
}
public final AmpvarContext ampvar() throws RecognitionException {
AmpvarContext _localctx = new AmpvarContext(_ctx, getState());
enterRule(_localctx, 18, RULE_ampvar);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(115); match(START_AMP);
setState(116); match(QID);
setState(120);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,8,_ctx);
while ( _alt!=2 && _alt!=-1 ) {
if ( _alt==1 ) {
{
{
setState(117); param();
}
}
}
setState(122);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,8,_ctx);
}
setState(126);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==QID) {
{
{
setState(123); hash();
}
}
setState(128);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(129); match(END);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VarContext extends ParserRuleContext {
public TerminalNode START() { return getToken(HbsParser.START, 0); }
public List hash() {
return getRuleContexts(HashContext.class);
}
public HashContext hash(int i) {
return getRuleContext(HashContext.class,i);
}
public List param() {
return getRuleContexts(ParamContext.class);
}
public TerminalNode QID() { return getToken(HbsParser.QID, 0); }
public ParamContext param(int i) {
return getRuleContext(ParamContext.class,i);
}
public TerminalNode END() { return getToken(HbsParser.END, 0); }
public VarContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_var; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).enterVar(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).exitVar(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HbsParserVisitor ) return ((HbsParserVisitor)visitor).visitVar(this);
else return visitor.visitChildren(this);
}
}
public final VarContext var() throws RecognitionException {
VarContext _localctx = new VarContext(_ctx, getState());
enterRule(_localctx, 20, RULE_var);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(131); match(START);
setState(132); match(QID);
setState(136);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,10,_ctx);
while ( _alt!=2 && _alt!=-1 ) {
if ( _alt==1 ) {
{
{
setState(133); param();
}
}
}
setState(138);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,10,_ctx);
}
setState(142);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==QID) {
{
{
setState(139); hash();
}
}
setState(144);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(145); match(END);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DelimitersContext extends ParserRuleContext {
public Token DELIM;
public List startDelim = new ArrayList();
public List endDelim = new ArrayList();
public TerminalNode END_DELIM() { return getToken(HbsParser.END_DELIM, 0); }
public TerminalNode WS_DELIM(int i) {
return getToken(HbsParser.WS_DELIM, i);
}
public TerminalNode START_DELIM() { return getToken(HbsParser.START_DELIM, 0); }
public TerminalNode DELIM(int i) {
return getToken(HbsParser.DELIM, i);
}
public List DELIM() { return getTokens(HbsParser.DELIM); }
public List WS_DELIM() { return getTokens(HbsParser.WS_DELIM); }
public DelimitersContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_delimiters; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).enterDelimiters(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).exitDelimiters(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HbsParserVisitor ) return ((HbsParserVisitor)visitor).visitDelimiters(this);
else return visitor.visitChildren(this);
}
}
public final DelimitersContext delimiters() throws RecognitionException {
DelimitersContext _localctx = new DelimitersContext(_ctx, getState());
enterRule(_localctx, 22, RULE_delimiters);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(147); match(START_DELIM);
setState(151);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==WS_DELIM) {
{
{
setState(148); match(WS_DELIM);
}
}
setState(153);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(155);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(154); ((DelimitersContext)_localctx).DELIM = match(DELIM);
((DelimitersContext)_localctx).startDelim.add(((DelimitersContext)_localctx).DELIM);
}
}
setState(157);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==DELIM );
setStart(join(((DelimitersContext)_localctx).startDelim));
setState(161);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(160); match(WS_DELIM);
}
}
setState(163);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==WS_DELIM );
setState(166);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(165); ((DelimitersContext)_localctx).DELIM = match(DELIM);
((DelimitersContext)_localctx).endDelim.add(((DelimitersContext)_localctx).DELIM);
}
}
setState(168);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==DELIM );
setState(173);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==WS_DELIM) {
{
{
setState(170); match(WS_DELIM);
}
}
setState(175);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(176); match(END_DELIM);
setEnd(join(((DelimitersContext)_localctx).endDelim));
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PartialContext extends ParserRuleContext {
public TerminalNode QID() { return getToken(HbsParser.QID, 0); }
public TerminalNode PATH() { return getToken(HbsParser.PATH, 0); }
public TerminalNode START_PARTIAL() { return getToken(HbsParser.START_PARTIAL, 0); }
public TerminalNode END() { return getToken(HbsParser.END, 0); }
public PartialContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_partial; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).enterPartial(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).exitPartial(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HbsParserVisitor ) return ((HbsParserVisitor)visitor).visitPartial(this);
else return visitor.visitChildren(this);
}
}
public final PartialContext partial() throws RecognitionException {
PartialContext _localctx = new PartialContext(_ctx, getState());
enterRule(_localctx, 24, RULE_partial);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(179); match(START_PARTIAL);
setState(180); match(PATH);
setState(182);
_la = _input.LA(1);
if (_la==QID) {
{
setState(181); match(QID);
}
}
setState(184); match(END);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ParamContext extends ParserRuleContext {
public ParamContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_param; }
public ParamContext() { }
public void copyFrom(ParamContext ctx) {
super.copyFrom(ctx);
}
}
public static class BoolParamContext extends ParamContext {
public TerminalNode BOOLEAN() { return getToken(HbsParser.BOOLEAN, 0); }
public BoolParamContext(ParamContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).enterBoolParam(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).exitBoolParam(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HbsParserVisitor ) return ((HbsParserVisitor)visitor).visitBoolParam(this);
else return visitor.visitChildren(this);
}
}
public static class RefPramContext extends ParamContext {
public TerminalNode QID() { return getToken(HbsParser.QID, 0); }
public RefPramContext(ParamContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).enterRefPram(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).exitRefPram(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HbsParserVisitor ) return ((HbsParserVisitor)visitor).visitRefPram(this);
else return visitor.visitChildren(this);
}
}
public static class StringParamContext extends ParamContext {
public TerminalNode DOUBLE_STRING() { return getToken(HbsParser.DOUBLE_STRING, 0); }
public StringParamContext(ParamContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).enterStringParam(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).exitStringParam(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HbsParserVisitor ) return ((HbsParserVisitor)visitor).visitStringParam(this);
else return visitor.visitChildren(this);
}
}
public static class IntParamContext extends ParamContext {
public TerminalNode INT() { return getToken(HbsParser.INT, 0); }
public IntParamContext(ParamContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).enterIntParam(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).exitIntParam(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HbsParserVisitor ) return ((HbsParserVisitor)visitor).visitIntParam(this);
else return visitor.visitChildren(this);
}
}
public final ParamContext param() throws RecognitionException {
ParamContext _localctx = new ParamContext(_ctx, getState());
enterRule(_localctx, 26, RULE_param);
try {
setState(190);
switch (_input.LA(1)) {
case DOUBLE_STRING:
_localctx = new StringParamContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(186); match(DOUBLE_STRING);
}
break;
case INT:
_localctx = new IntParamContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(187); match(INT);
}
break;
case BOOLEAN:
_localctx = new BoolParamContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(188); match(BOOLEAN);
}
break;
case QID:
_localctx = new RefPramContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(189); match(QID);
}
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 HashContext extends ParserRuleContext {
public HashValueContext hashValue() {
return getRuleContext(HashValueContext.class,0);
}
public TerminalNode QID() { return getToken(HbsParser.QID, 0); }
public TerminalNode EQ() { return getToken(HbsParser.EQ, 0); }
public HashContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_hash; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).enterHash(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).exitHash(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HbsParserVisitor ) return ((HbsParserVisitor)visitor).visitHash(this);
else return visitor.visitChildren(this);
}
}
public final HashContext hash() throws RecognitionException {
HashContext _localctx = new HashContext(_ctx, getState());
enterRule(_localctx, 28, RULE_hash);
try {
enterOuterAlt(_localctx, 1);
{
setState(192); match(QID);
setState(193); match(EQ);
setState(194); hashValue();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HashValueContext extends ParserRuleContext {
public HashValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_hashValue; }
public HashValueContext() { }
public void copyFrom(HashValueContext ctx) {
super.copyFrom(ctx);
}
}
public static class IntHashContext extends HashValueContext {
public TerminalNode INT() { return getToken(HbsParser.INT, 0); }
public IntHashContext(HashValueContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).enterIntHash(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).exitIntHash(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HbsParserVisitor ) return ((HbsParserVisitor)visitor).visitIntHash(this);
else return visitor.visitChildren(this);
}
}
public static class BoolHashContext extends HashValueContext {
public TerminalNode BOOLEAN() { return getToken(HbsParser.BOOLEAN, 0); }
public BoolHashContext(HashValueContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).enterBoolHash(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).exitBoolHash(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HbsParserVisitor ) return ((HbsParserVisitor)visitor).visitBoolHash(this);
else return visitor.visitChildren(this);
}
}
public static class RefHashContext extends HashValueContext {
public TerminalNode QID() { return getToken(HbsParser.QID, 0); }
public RefHashContext(HashValueContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).enterRefHash(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).exitRefHash(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HbsParserVisitor ) return ((HbsParserVisitor)visitor).visitRefHash(this);
else return visitor.visitChildren(this);
}
}
public static class StringHashContext extends HashValueContext {
public TerminalNode DOUBLE_STRING() { return getToken(HbsParser.DOUBLE_STRING, 0); }
public StringHashContext(HashValueContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).enterStringHash(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).exitStringHash(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HbsParserVisitor ) return ((HbsParserVisitor)visitor).visitStringHash(this);
else return visitor.visitChildren(this);
}
}
public static class CharsHashContext extends HashValueContext {
public TerminalNode SINGLE_STRING() { return getToken(HbsParser.SINGLE_STRING, 0); }
public CharsHashContext(HashValueContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).enterCharsHash(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).exitCharsHash(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HbsParserVisitor ) return ((HbsParserVisitor)visitor).visitCharsHash(this);
else return visitor.visitChildren(this);
}
}
public final HashValueContext hashValue() throws RecognitionException {
HashValueContext _localctx = new HashValueContext(_ctx, getState());
enterRule(_localctx, 30, RULE_hashValue);
try {
setState(201);
switch (_input.LA(1)) {
case DOUBLE_STRING:
_localctx = new StringHashContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(196); match(DOUBLE_STRING);
}
break;
case SINGLE_STRING:
_localctx = new CharsHashContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(197); match(SINGLE_STRING);
}
break;
case INT:
_localctx = new IntHashContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(198); match(INT);
}
break;
case BOOLEAN:
_localctx = new BoolHashContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(199); match(BOOLEAN);
}
break;
case QID:
_localctx = new RefHashContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(200); match(QID);
}
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 CommentContext extends ParserRuleContext {
public TerminalNode COMMENT() { return getToken(HbsParser.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 HbsParserListener ) ((HbsParserListener)listener).enterComment(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HbsParserListener ) ((HbsParserListener)listener).exitComment(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HbsParserVisitor ) return ((HbsParserVisitor)visitor).visitComment(this);
else return visitor.visitChildren(this);
}
}
public final CommentContext comment() throws RecognitionException {
CommentContext _localctx = new CommentContext(_ctx, getState());
enterRule(_localctx, 32, RULE_comment);
try {
enterOuterAlt(_localctx, 1);
{
setState(203); match(COMMENT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static final String _serializedATN =
"\3\uacf5\uee8c\u4f5d\u8b0d\u4a45\u78bd\u1b2f\u3378\3\35\u00d0\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"+
"\3\2\3\2\3\2\3\3\7\3)\n\3\f\3\16\3,\13\3\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3"+
"\4\3\4\3\4\3\4\5\49\n\4\3\5\3\5\3\6\3\6\3\7\3\7\3\b\3\b\3\b\7\bD\n\b\f"+
"\b\16\bG\13\b\3\b\7\bJ\n\b\f\b\16\bM\13\b\3\b\3\b\3\b\3\b\3\b\5\bT\n\b"+
"\3\b\3\b\5\bX\n\b\3\b\3\b\3\b\3\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\n"+
"\3\n\3\n\7\ni\n\n\f\n\16\nl\13\n\3\n\7\no\n\n\f\n\16\nr\13\n\3\n\3\n\3"+
"\13\3\13\3\13\7\13y\n\13\f\13\16\13|\13\13\3\13\7\13\177\n\13\f\13\16"+
"\13\u0082\13\13\3\13\3\13\3\f\3\f\3\f\7\f\u0089\n\f\f\f\16\f\u008c\13"+
"\f\3\f\7\f\u008f\n\f\f\f\16\f\u0092\13\f\3\f\3\f\3\r\3\r\7\r\u0098\n\r"+
"\f\r\16\r\u009b\13\r\3\r\6\r\u009e\n\r\r\r\16\r\u009f\3\r\3\r\6\r\u00a4"+
"\n\r\r\r\16\r\u00a5\3\r\6\r\u00a9\n\r\r\r\16\r\u00aa\3\r\7\r\u00ae\n\r"+
"\f\r\16\r\u00b1\13\r\3\r\3\r\3\r\3\16\3\16\3\16\5\16\u00b9\n\16\3\16\3"+
"\16\3\17\3\17\3\17\3\17\5\17\u00c1\n\17\3\20\3\20\3\20\3\20\3\21\3\21"+
"\3\21\3\21\3\21\5\21\u00cc\n\21\3\22\3\22\3\22\2\23\2\4\6\b\n\f\16\20"+
"\22\24\26\30\32\34\36 \"\2\2\u00e0\2$\3\2\2\2\4*\3\2\2\2\68\3\2\2\2\b"+
":\3\2\2\2\n<\3\2\2\2\f>\3\2\2\2\16@\3\2\2\2\20]\3\2\2\2\22e\3\2\2\2\24"+
"u\3\2\2\2\26\u0085\3\2\2\2\30\u0095\3\2\2\2\32\u00b5\3\2\2\2\34\u00c0"+
"\3\2\2\2\36\u00c2\3\2\2\2 \u00cb\3\2\2\2\"\u00cd\3\2\2\2$%\5\4\3\2%&\7"+
"\2\2\3&\3\3\2\2\2\')\5\6\4\2(\'\3\2\2\2),\3\2\2\2*(\3\2\2\2*+\3\2\2\2"+
"+\5\3\2\2\2,*\3\2\2\2-9\5\n\6\2.9\5\f\7\2/9\5\b\5\2\609\5\16\b\2\619\5"+
"\26\f\2\629\5\22\n\2\639\5\24\13\2\649\5\20\t\2\659\5\32\16\2\669\5\""+
"\22\2\679\5\30\r\28-\3\2\2\28.\3\2\2\28/\3\2\2\28\60\3\2\2\28\61\3\2\2"+
"\28\62\3\2\2\28\63\3\2\2\28\64\3\2\2\28\65\3\2\2\28\66\3\2\2\28\67\3\2"+
"\2\29\7\3\2\2\2:;\7\3\2\2;\t\3\2\2\2<=\7\r\2\2=\13\3\2\2\2>?\7\16\2\2"+
"?\r\3\2\2\2@A\7\b\2\2AE\7\34\2\2BD\5\34\17\2CB\3\2\2\2DG\3\2\2\2EC\3\2"+
"\2\2EF\3\2\2\2FK\3\2\2\2GE\3\2\2\2HJ\5\36\20\2IH\3\2\2\2JM\3\2\2\2KI\3"+
"\2\2\2KL\3\2\2\2LN\3\2\2\2MK\3\2\2\2NO\7\25\2\2OW\5\4\3\2PT\7\7\2\2QR"+
"\7\f\2\2RT\7\33\2\2SP\3\2\2\2SQ\3\2\2\2TU\3\2\2\2UV\7\25\2\2VX\5\4\3\2"+
"WS\3\2\2\2WX\3\2\2\2XY\3\2\2\2YZ\7\13\2\2Z[\7\34\2\2[\\\7\25\2\2\\\17"+
"\3\2\2\2]^\7\7\2\2^_\7\34\2\2_`\7\25\2\2`a\5\4\3\2ab\7\13\2\2bc\7\34\2"+
"\2cd\7\25\2\2d\21\3\2\2\2ef\7\6\2\2fj\7\34\2\2gi\5\34\17\2hg\3\2\2\2i"+
"l\3\2\2\2jh\3\2\2\2jk\3\2\2\2kp\3\2\2\2lj\3\2\2\2mo\5\36\20\2nm\3\2\2"+
"\2or\3\2\2\2pn\3\2\2\2pq\3\2\2\2qs\3\2\2\2rp\3\2\2\2st\7\24\2\2t\23\3"+
"\2\2\2uv\7\5\2\2vz\7\34\2\2wy\5\34\17\2xw\3\2\2\2y|\3\2\2\2zx\3\2\2\2"+
"z{\3\2\2\2{\u0080\3\2\2\2|z\3\2\2\2}\177\5\36\20\2~}\3\2\2\2\177\u0082"+
"\3\2\2\2\u0080~\3\2\2\2\u0080\u0081\3\2\2\2\u0081\u0083\3\2\2\2\u0082"+
"\u0080\3\2\2\2\u0083\u0084\7\25\2\2\u0084\25\3\2\2\2\u0085\u0086\7\f\2"+
"\2\u0086\u008a\7\34\2\2\u0087\u0089\5\34\17\2\u0088\u0087\3\2\2\2\u0089"+
"\u008c\3\2\2\2\u008a\u0088\3\2\2\2\u008a\u008b\3\2\2\2\u008b\u0090\3\2"+
"\2\2\u008c\u008a\3\2\2\2\u008d\u008f\5\36\20\2\u008e\u008d\3\2\2\2\u008f"+
"\u0092\3\2\2\2\u0090\u008e\3\2\2\2\u0090\u0091\3\2\2\2\u0091\u0093\3\2"+
"\2\2\u0092\u0090\3\2\2\2\u0093\u0094\7\25\2\2\u0094\27\3\2\2\2\u0095\u0099"+
"\7\t\2\2\u0096\u0098\7\20\2\2\u0097\u0096\3\2\2\2\u0098\u009b\3\2\2\2"+
"\u0099\u0097\3\2\2\2\u0099\u009a\3\2\2\2\u009a\u009d\3\2\2\2\u009b\u0099"+
"\3\2\2\2\u009c\u009e\7\21\2\2\u009d\u009c\3\2\2\2\u009e\u009f\3\2\2\2"+
"\u009f\u009d\3\2\2\2\u009f\u00a0\3\2\2\2\u00a0\u00a1\3\2\2\2\u00a1\u00a3"+
"\b\r\1\2\u00a2\u00a4\7\20\2\2\u00a3\u00a2\3\2\2\2\u00a4\u00a5\3\2\2\2"+
"\u00a5\u00a3\3\2\2\2\u00a5\u00a6\3\2\2\2\u00a6\u00a8\3\2\2\2\u00a7\u00a9"+
"\7\21\2\2\u00a8\u00a7\3\2\2\2\u00a9\u00aa\3\2\2\2\u00aa\u00a8\3\2\2\2"+
"\u00aa\u00ab\3\2\2\2\u00ab\u00af\3\2\2\2\u00ac\u00ae\7\20\2\2\u00ad\u00ac"+
"\3\2\2\2\u00ae\u00b1\3\2\2\2\u00af\u00ad\3\2\2\2\u00af\u00b0\3\2\2\2\u00b0"+
"\u00b2\3\2\2\2\u00b1\u00af\3\2\2\2\u00b2\u00b3\7\17\2\2\u00b3\u00b4\b"+
"\r\1\2\u00b4\31\3\2\2\2\u00b5\u00b6\7\n\2\2\u00b6\u00b8\7\22\2\2\u00b7"+
"\u00b9\7\34\2\2\u00b8\u00b7\3\2\2\2\u00b8\u00b9\3\2\2\2\u00b9\u00ba\3"+
"\2\2\2\u00ba\u00bb\7\25\2\2\u00bb\33\3\2\2\2\u00bc\u00c1\7\26\2\2\u00bd"+
"\u00c1\7\31\2\2\u00be\u00c1\7\32\2\2\u00bf\u00c1\7\34\2\2\u00c0\u00bc"+
"\3\2\2\2\u00c0\u00bd\3\2\2\2\u00c0\u00be\3\2\2\2\u00c0\u00bf\3\2\2\2\u00c1"+
"\35\3\2\2\2\u00c2\u00c3\7\34\2\2\u00c3\u00c4\7\30\2\2\u00c4\u00c5\5 \21"+
"\2\u00c5\37\3\2\2\2\u00c6\u00cc\7\26\2\2\u00c7\u00cc\7\27\2\2\u00c8\u00cc"+
"\7\31\2\2\u00c9\u00cc\7\32\2\2\u00ca\u00cc\7\34\2\2\u00cb\u00c6\3\2\2"+
"\2\u00cb\u00c7\3\2\2\2\u00cb\u00c8\3\2\2\2\u00cb\u00c9\3\2\2\2\u00cb\u00ca"+
"\3\2\2\2\u00cc!\3\2\2\2\u00cd\u00ce\7\4\2\2\u00ce#\3\2\2\2\26*8EKSWjp"+
"z\u0080\u008a\u0090\u0099\u009f\u00a5\u00aa\u00af\u00b8\u00c0\u00cb";
public static final ATN _ATN =
ATNSimulator.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 - 2025 Weber Informatics LLC | Privacy Policy