org.eolang.parser.ProgramParser Maven / Gradle / Ivy
// Generated from org/eolang/parser/Program.g4 by ANTLR 4.9.2
package org.eolang.parser;
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 ProgramParser extends Parser {
static { RuntimeMetaData.checkVersion("4.9.2", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
COMMENT=1, META=2, ROOT=3, HOME=4, STAR=5, DOTS=6, CONST=7, SLASH=8, COLON=9,
COPY=10, ARROW=11, VERTEX=12, SIGMA=13, XI=14, PLUS=15, MINUS=16, QUESTION=17,
SPACE=18, DOT=19, LSQ=20, RSQ=21, LB=22, RB=23, AT=24, RHO=25, HASH=26,
EOL=27, BYTES=28, BOOL=29, STRING=30, INT=31, FLOAT=32, HEX=33, NAME=34,
TEXT=35, TAB=36, UNTAB=37;
public static final int
RULE_program = 0, RULE_license = 1, RULE_metas = 2, RULE_objects = 3,
RULE_object = 4, RULE_abstraction = 5, RULE_attributes = 6, RULE_attribute = 7,
RULE_label = 8, RULE_tail = 9, RULE_suffix = 10, RULE_method = 11, RULE_application = 12,
RULE_htail = 13, RULE_head = 14, RULE_has = 15, RULE_data = 16;
private static String[] makeRuleNames() {
return new String[] {
"program", "license", "metas", "objects", "object", "abstraction", "attributes",
"attribute", "label", "tail", "suffix", "method", "application", "htail",
"head", "has", "data"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, null, null, "'Q'", "'QQ'", "'*'", "'...'", "'!'", "'/'", "':'",
"'''", "'>'", "'<'", "'&'", "'$'", "'+'", "'-'", "'?'", "' '", "'.'",
"'['", "']'", "'('", "')'", "'@'", "'^'", "'#'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
null, "COMMENT", "META", "ROOT", "HOME", "STAR", "DOTS", "CONST", "SLASH",
"COLON", "COPY", "ARROW", "VERTEX", "SIGMA", "XI", "PLUS", "MINUS", "QUESTION",
"SPACE", "DOT", "LSQ", "RSQ", "LB", "RB", "AT", "RHO", "HASH", "EOL",
"BYTES", "BOOL", "STRING", "INT", "FLOAT", "HEX", "NAME", "TEXT", "TAB",
"UNTAB"
};
}
private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
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 "Program.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public ProgramParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class ProgramContext extends ParserRuleContext {
public ObjectsContext objects() {
return getRuleContext(ObjectsContext.class,0);
}
public TerminalNode EOF() { return getToken(ProgramParser.EOF, 0); }
public LicenseContext license() {
return getRuleContext(LicenseContext.class,0);
}
public MetasContext metas() {
return getRuleContext(MetasContext.class,0);
}
public ProgramContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_program; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProgramListener ) ((ProgramListener)listener).enterProgram(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProgramListener ) ((ProgramListener)listener).exitProgram(this);
}
}
public final ProgramContext program() throws RecognitionException {
ProgramContext _localctx = new ProgramContext(_ctx, getState());
enterRule(_localctx, 0, RULE_program);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(35);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
case 1:
{
setState(34);
license();
}
break;
}
setState(38);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==META) {
{
setState(37);
metas();
}
}
setState(40);
objects();
setState(41);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LicenseContext extends ParserRuleContext {
public List COMMENT() { return getTokens(ProgramParser.COMMENT); }
public TerminalNode COMMENT(int i) {
return getToken(ProgramParser.COMMENT, i);
}
public List EOL() { return getTokens(ProgramParser.EOL); }
public TerminalNode EOL(int i) {
return getToken(ProgramParser.EOL, i);
}
public LicenseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_license; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProgramListener ) ((ProgramListener)listener).enterLicense(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProgramListener ) ((ProgramListener)listener).exitLicense(this);
}
}
public final LicenseContext license() throws RecognitionException {
LicenseContext _localctx = new LicenseContext(_ctx, getState());
enterRule(_localctx, 2, RULE_license);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(45);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(43);
match(COMMENT);
setState(44);
match(EOL);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(47);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,2,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MetasContext extends ParserRuleContext {
public List META() { return getTokens(ProgramParser.META); }
public TerminalNode META(int i) {
return getToken(ProgramParser.META, i);
}
public List EOL() { return getTokens(ProgramParser.EOL); }
public TerminalNode EOL(int i) {
return getToken(ProgramParser.EOL, i);
}
public MetasContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_metas; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProgramListener ) ((ProgramListener)listener).enterMetas(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProgramListener ) ((ProgramListener)listener).exitMetas(this);
}
}
public final MetasContext metas() throws RecognitionException {
MetasContext _localctx = new MetasContext(_ctx, getState());
enterRule(_localctx, 4, RULE_metas);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(51);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(49);
match(META);
setState(50);
match(EOL);
}
}
setState(53);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==META );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ObjectsContext extends ParserRuleContext {
public List object() {
return getRuleContexts(ObjectContext.class);
}
public ObjectContext object(int i) {
return getRuleContext(ObjectContext.class,i);
}
public List EOL() { return getTokens(ProgramParser.EOL); }
public TerminalNode EOL(int i) {
return getToken(ProgramParser.EOL, i);
}
public List COMMENT() { return getTokens(ProgramParser.COMMENT); }
public TerminalNode COMMENT(int i) {
return getToken(ProgramParser.COMMENT, i);
}
public ObjectsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_objects; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProgramListener ) ((ProgramListener)listener).enterObjects(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProgramListener ) ((ProgramListener)listener).exitObjects(this);
}
}
public final ObjectsContext objects() throws RecognitionException {
ObjectsContext _localctx = new ObjectsContext(_ctx, getState());
enterRule(_localctx, 6, RULE_objects);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(65);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(59);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,4,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(55);
match(COMMENT);
setState(56);
match(EOL);
}
}
}
setState(61);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,4,_ctx);
}
setState(62);
object();
setState(63);
match(EOL);
}
}
setState(67);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << COMMENT) | (1L << ROOT) | (1L << HOME) | (1L << STAR) | (1L << DOTS) | (1L << SIGMA) | (1L << XI) | (1L << LSQ) | (1L << LB) | (1L << AT) | (1L << RHO) | (1L << BYTES) | (1L << BOOL) | (1L << STRING) | (1L << INT) | (1L << FLOAT) | (1L << HEX) | (1L << NAME) | (1L << TEXT))) != 0) );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ObjectContext extends ParserRuleContext {
public AbstractionContext abstraction() {
return getRuleContext(AbstractionContext.class,0);
}
public ApplicationContext application() {
return getRuleContext(ApplicationContext.class,0);
}
public List tail() {
return getRuleContexts(TailContext.class);
}
public TailContext tail(int i) {
return getRuleContext(TailContext.class,i);
}
public List EOL() { return getTokens(ProgramParser.EOL); }
public TerminalNode EOL(int i) {
return getToken(ProgramParser.EOL, i);
}
public List method() {
return getRuleContexts(MethodContext.class);
}
public MethodContext method(int i) {
return getRuleContext(MethodContext.class,i);
}
public List htail() {
return getRuleContexts(HtailContext.class);
}
public HtailContext htail(int i) {
return getRuleContext(HtailContext.class,i);
}
public List suffix() {
return getRuleContexts(SuffixContext.class);
}
public SuffixContext suffix(int i) {
return getRuleContext(SuffixContext.class,i);
}
public ObjectContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_object; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProgramListener ) ((ProgramListener)listener).enterObject(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProgramListener ) ((ProgramListener)listener).exitObject(this);
}
}
public final ObjectContext object() throws RecognitionException {
ObjectContext _localctx = new ObjectContext(_ctx, getState());
enterRule(_localctx, 8, RULE_object);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(71);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) {
case 1:
{
setState(69);
abstraction();
}
break;
case 2:
{
setState(70);
application(0);
}
break;
}
setState(74);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) {
case 1:
{
setState(73);
tail();
}
break;
}
setState(89);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,11,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(76);
match(EOL);
setState(77);
method();
setState(79);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,8,_ctx) ) {
case 1:
{
setState(78);
htail();
}
break;
}
setState(82);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SPACE) {
{
setState(81);
suffix();
}
}
setState(85);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
case 1:
{
setState(84);
tail();
}
break;
}
}
}
}
setState(91);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,11,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AbstractionContext extends ParserRuleContext {
public AttributesContext attributes() {
return getRuleContext(AttributesContext.class,0);
}
public List COMMENT() { return getTokens(ProgramParser.COMMENT); }
public TerminalNode COMMENT(int i) {
return getToken(ProgramParser.COMMENT, i);
}
public List EOL() { return getTokens(ProgramParser.EOL); }
public TerminalNode EOL(int i) {
return getToken(ProgramParser.EOL, i);
}
public HtailContext htail() {
return getRuleContext(HtailContext.class,0);
}
public SuffixContext suffix() {
return getRuleContext(SuffixContext.class,0);
}
public TerminalNode SPACE() { return getToken(ProgramParser.SPACE, 0); }
public TerminalNode SLASH() { return getToken(ProgramParser.SLASH, 0); }
public TerminalNode NAME() { return getToken(ProgramParser.NAME, 0); }
public TerminalNode QUESTION() { return getToken(ProgramParser.QUESTION, 0); }
public AbstractionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_abstraction; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProgramListener ) ((ProgramListener)listener).enterAbstraction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProgramListener ) ((ProgramListener)listener).exitAbstraction(this);
}
}
public final AbstractionContext abstraction() throws RecognitionException {
AbstractionContext _localctx = new AbstractionContext(_ctx, getState());
enterRule(_localctx, 10, RULE_abstraction);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(96);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMENT) {
{
{
setState(92);
match(COMMENT);
setState(93);
match(EOL);
}
}
setState(98);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(99);
attributes();
setState(107);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
case 1:
{
{
setState(100);
suffix();
setState(104);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) {
case 1:
{
setState(101);
match(SPACE);
setState(102);
match(SLASH);
setState(103);
_la = _input.LA(1);
if ( !(_la==QUESTION || _la==NAME) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
}
}
break;
case 2:
{
setState(106);
htail();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AttributesContext extends ParserRuleContext {
public TerminalNode LSQ() { return getToken(ProgramParser.LSQ, 0); }
public TerminalNode RSQ() { return getToken(ProgramParser.RSQ, 0); }
public List attribute() {
return getRuleContexts(AttributeContext.class);
}
public AttributeContext attribute(int i) {
return getRuleContext(AttributeContext.class,i);
}
public List SPACE() { return getTokens(ProgramParser.SPACE); }
public TerminalNode SPACE(int i) {
return getToken(ProgramParser.SPACE, i);
}
public AttributesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_attributes; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProgramListener ) ((ProgramListener)listener).enterAttributes(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProgramListener ) ((ProgramListener)listener).exitAttributes(this);
}
}
public final AttributesContext attributes() throws RecognitionException {
AttributesContext _localctx = new AttributesContext(_ctx, getState());
enterRule(_localctx, 12, RULE_attributes);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(109);
match(LSQ);
setState(118);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AT || _la==NAME) {
{
setState(110);
attribute();
setState(115);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SPACE) {
{
{
setState(111);
match(SPACE);
setState(112);
attribute();
}
}
setState(117);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(120);
match(RSQ);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AttributeContext extends ParserRuleContext {
public LabelContext label() {
return getRuleContext(LabelContext.class,0);
}
public AttributeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_attribute; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProgramListener ) ((ProgramListener)listener).enterAttribute(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProgramListener ) ((ProgramListener)listener).exitAttribute(this);
}
}
public final AttributeContext attribute() throws RecognitionException {
AttributeContext _localctx = new AttributeContext(_ctx, getState());
enterRule(_localctx, 14, RULE_attribute);
try {
enterOuterAlt(_localctx, 1);
{
setState(122);
label();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LabelContext extends ParserRuleContext {
public TerminalNode AT() { return getToken(ProgramParser.AT, 0); }
public TerminalNode NAME() { return getToken(ProgramParser.NAME, 0); }
public TerminalNode DOTS() { return getToken(ProgramParser.DOTS, 0); }
public LabelContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_label; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProgramListener ) ((ProgramListener)listener).enterLabel(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProgramListener ) ((ProgramListener)listener).exitLabel(this);
}
}
public final LabelContext label() throws RecognitionException {
LabelContext _localctx = new LabelContext(_ctx, getState());
enterRule(_localctx, 16, RULE_label);
try {
setState(129);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AT:
enterOuterAlt(_localctx, 1);
{
setState(124);
match(AT);
}
break;
case NAME:
enterOuterAlt(_localctx, 2);
{
setState(125);
match(NAME);
setState(127);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
case 1:
{
setState(126);
match(DOTS);
}
break;
}
}
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 TailContext extends ParserRuleContext {
public List EOL() { return getTokens(ProgramParser.EOL); }
public TerminalNode EOL(int i) {
return getToken(ProgramParser.EOL, i);
}
public TerminalNode TAB() { return getToken(ProgramParser.TAB, 0); }
public TerminalNode UNTAB() { return getToken(ProgramParser.UNTAB, 0); }
public List object() {
return getRuleContexts(ObjectContext.class);
}
public ObjectContext object(int i) {
return getRuleContext(ObjectContext.class,i);
}
public TailContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tail; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProgramListener ) ((ProgramListener)listener).enterTail(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProgramListener ) ((ProgramListener)listener).exitTail(this);
}
}
public final TailContext tail() throws RecognitionException {
TailContext _localctx = new TailContext(_ctx, getState());
enterRule(_localctx, 18, RULE_tail);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(131);
match(EOL);
setState(132);
match(TAB);
setState(136);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(133);
object();
setState(134);
match(EOL);
}
}
setState(138);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << COMMENT) | (1L << ROOT) | (1L << HOME) | (1L << STAR) | (1L << DOTS) | (1L << SIGMA) | (1L << XI) | (1L << LSQ) | (1L << LB) | (1L << AT) | (1L << RHO) | (1L << BYTES) | (1L << BOOL) | (1L << STRING) | (1L << INT) | (1L << FLOAT) | (1L << HEX) | (1L << NAME) | (1L << TEXT))) != 0) );
setState(140);
match(UNTAB);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SuffixContext extends ParserRuleContext {
public List SPACE() { return getTokens(ProgramParser.SPACE); }
public TerminalNode SPACE(int i) {
return getToken(ProgramParser.SPACE, i);
}
public TerminalNode ARROW() { return getToken(ProgramParser.ARROW, 0); }
public LabelContext label() {
return getRuleContext(LabelContext.class,0);
}
public TerminalNode CONST() { return getToken(ProgramParser.CONST, 0); }
public SuffixContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_suffix; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProgramListener ) ((ProgramListener)listener).enterSuffix(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProgramListener ) ((ProgramListener)listener).exitSuffix(this);
}
}
public final SuffixContext suffix() throws RecognitionException {
SuffixContext _localctx = new SuffixContext(_ctx, getState());
enterRule(_localctx, 20, RULE_suffix);
try {
enterOuterAlt(_localctx, 1);
{
setState(142);
match(SPACE);
setState(143);
match(ARROW);
setState(144);
match(SPACE);
setState(145);
label();
setState(147);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) {
case 1:
{
setState(146);
match(CONST);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MethodContext extends ParserRuleContext {
public Token mtd;
public TerminalNode DOT() { return getToken(ProgramParser.DOT, 0); }
public TerminalNode NAME() { return getToken(ProgramParser.NAME, 0); }
public TerminalNode RHO() { return getToken(ProgramParser.RHO, 0); }
public TerminalNode AT() { return getToken(ProgramParser.AT, 0); }
public TerminalNode VERTEX() { return getToken(ProgramParser.VERTEX, 0); }
public MethodContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_method; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProgramListener ) ((ProgramListener)listener).enterMethod(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProgramListener ) ((ProgramListener)listener).exitMethod(this);
}
}
public final MethodContext method() throws RecognitionException {
MethodContext _localctx = new MethodContext(_ctx, getState());
enterRule(_localctx, 22, RULE_method);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(149);
match(DOT);
setState(150);
((MethodContext)_localctx).mtd = _input.LT(1);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << VERTEX) | (1L << AT) | (1L << RHO) | (1L << NAME))) != 0)) ) {
((MethodContext)_localctx).mtd = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ApplicationContext extends ParserRuleContext {
public HeadContext head() {
return getRuleContext(HeadContext.class,0);
}
public HtailContext htail() {
return getRuleContext(HtailContext.class,0);
}
public TerminalNode LB() { return getToken(ProgramParser.LB, 0); }
public ApplicationContext application() {
return getRuleContext(ApplicationContext.class,0);
}
public TerminalNode RB() { return getToken(ProgramParser.RB, 0); }
public MethodContext method() {
return getRuleContext(MethodContext.class,0);
}
public HasContext has() {
return getRuleContext(HasContext.class,0);
}
public SuffixContext suffix() {
return getRuleContext(SuffixContext.class,0);
}
public ApplicationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_application; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProgramListener ) ((ProgramListener)listener).enterApplication(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProgramListener ) ((ProgramListener)listener).exitApplication(this);
}
}
public final ApplicationContext application() throws RecognitionException {
return application(0);
}
private ApplicationContext application(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ApplicationContext _localctx = new ApplicationContext(_ctx, _parentState);
ApplicationContext _prevctx = _localctx;
int _startState = 24;
enterRecursionRule(_localctx, 24, RULE_application, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(163);
_errHandler.sync(this);
switch (_input.LA(1)) {
case COMMENT:
case ROOT:
case HOME:
case STAR:
case DOTS:
case SIGMA:
case XI:
case LSQ:
case AT:
case RHO:
case BYTES:
case BOOL:
case STRING:
case INT:
case FLOAT:
case HEX:
case NAME:
case TEXT:
{
setState(153);
head();
setState(155);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,21,_ctx) ) {
case 1:
{
setState(154);
htail();
}
break;
}
}
break;
case LB:
{
setState(157);
match(LB);
setState(158);
application(0);
setState(159);
match(RB);
setState(161);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) {
case 1:
{
setState(160);
htail();
}
break;
}
}
break;
default:
throw new NoViableAltException(this);
}
_ctx.stop = _input.LT(-1);
setState(182);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,28,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(180);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) {
case 1:
{
_localctx = new ApplicationContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_application);
setState(165);
if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
setState(166);
method();
setState(168);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,24,_ctx) ) {
case 1:
{
setState(167);
htail();
}
break;
}
}
break;
case 2:
{
_localctx = new ApplicationContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_application);
setState(170);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(171);
has();
setState(173);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
case 1:
{
setState(172);
htail();
}
break;
}
}
break;
case 3:
{
_localctx = new ApplicationContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_application);
setState(175);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(176);
suffix();
setState(178);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,26,_ctx) ) {
case 1:
{
setState(177);
htail();
}
break;
}
}
break;
}
}
}
setState(184);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,28,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class HtailContext extends ParserRuleContext {
public List SPACE() { return getTokens(ProgramParser.SPACE); }
public TerminalNode SPACE(int i) {
return getToken(ProgramParser.SPACE, i);
}
public List head() {
return getRuleContexts(HeadContext.class);
}
public HeadContext head(int i) {
return getRuleContext(HeadContext.class,i);
}
public List application() {
return getRuleContexts(ApplicationContext.class);
}
public ApplicationContext application(int i) {
return getRuleContext(ApplicationContext.class,i);
}
public List method() {
return getRuleContexts(MethodContext.class);
}
public MethodContext method(int i) {
return getRuleContext(MethodContext.class,i);
}
public List LB() { return getTokens(ProgramParser.LB); }
public TerminalNode LB(int i) {
return getToken(ProgramParser.LB, i);
}
public List RB() { return getTokens(ProgramParser.RB); }
public TerminalNode RB(int i) {
return getToken(ProgramParser.RB, i);
}
public List has() {
return getRuleContexts(HasContext.class);
}
public HasContext has(int i) {
return getRuleContext(HasContext.class,i);
}
public List suffix() {
return getRuleContexts(SuffixContext.class);
}
public SuffixContext suffix(int i) {
return getRuleContext(SuffixContext.class,i);
}
public List abstraction() {
return getRuleContexts(AbstractionContext.class);
}
public AbstractionContext abstraction(int i) {
return getRuleContext(AbstractionContext.class,i);
}
public HtailContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_htail; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProgramListener ) ((ProgramListener)listener).enterHtail(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProgramListener ) ((ProgramListener)listener).exitHtail(this);
}
}
public final HtailContext htail() throws RecognitionException {
HtailContext _localctx = new HtailContext(_ctx, getState());
enterRule(_localctx, 26, RULE_htail);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(206);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
setState(206);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,29,_ctx) ) {
case 1:
{
setState(185);
match(SPACE);
setState(186);
head();
}
break;
case 2:
{
setState(187);
match(SPACE);
setState(188);
application(0);
setState(189);
method();
}
break;
case 3:
{
setState(191);
match(SPACE);
setState(192);
match(LB);
setState(193);
application(0);
setState(194);
match(RB);
}
break;
case 4:
{
setState(196);
match(SPACE);
setState(197);
application(0);
setState(198);
has();
}
break;
case 5:
{
setState(200);
match(SPACE);
setState(201);
application(0);
setState(202);
suffix();
}
break;
case 6:
{
setState(204);
match(SPACE);
setState(205);
abstraction();
}
break;
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(208);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,30,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HeadContext extends ParserRuleContext {
public TerminalNode ROOT() { return getToken(ProgramParser.ROOT, 0); }
public TerminalNode HOME() { return getToken(ProgramParser.HOME, 0); }
public TerminalNode AT() { return getToken(ProgramParser.AT, 0); }
public TerminalNode RHO() { return getToken(ProgramParser.RHO, 0); }
public TerminalNode XI() { return getToken(ProgramParser.XI, 0); }
public TerminalNode SIGMA() { return getToken(ProgramParser.SIGMA, 0); }
public TerminalNode STAR() { return getToken(ProgramParser.STAR, 0); }
public TerminalNode NAME() { return getToken(ProgramParser.NAME, 0); }
public TerminalNode DOT() { return getToken(ProgramParser.DOT, 0); }
public DataContext data() {
return getRuleContext(DataContext.class,0);
}
public AbstractionContext abstraction() {
return getRuleContext(AbstractionContext.class,0);
}
public TerminalNode DOTS() { return getToken(ProgramParser.DOTS, 0); }
public TerminalNode COPY() { return getToken(ProgramParser.COPY, 0); }
public HeadContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_head; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProgramListener ) ((ProgramListener)listener).enterHead(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProgramListener ) ((ProgramListener)listener).exitHead(this);
}
}
public final HeadContext head() throws RecognitionException {
HeadContext _localctx = new HeadContext(_ctx, getState());
enterRule(_localctx, 28, RULE_head);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(211);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DOTS) {
{
setState(210);
match(DOTS);
}
}
setState(228);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,33,_ctx) ) {
case 1:
{
setState(213);
match(ROOT);
}
break;
case 2:
{
setState(214);
match(HOME);
}
break;
case 3:
{
setState(215);
match(AT);
}
break;
case 4:
{
setState(216);
match(RHO);
}
break;
case 5:
{
setState(217);
match(XI);
}
break;
case 6:
{
setState(218);
match(SIGMA);
}
break;
case 7:
{
setState(219);
match(STAR);
}
break;
case 8:
{
setState(220);
match(NAME);
setState(222);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,32,_ctx) ) {
case 1:
{
setState(221);
match(COPY);
}
break;
}
}
break;
case 9:
{
setState(224);
match(NAME);
setState(225);
match(DOT);
}
break;
case 10:
{
setState(226);
data();
}
break;
case 11:
{
setState(227);
abstraction();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HasContext extends ParserRuleContext {
public TerminalNode COLON() { return getToken(ProgramParser.COLON, 0); }
public TerminalNode NAME() { return getToken(ProgramParser.NAME, 0); }
public HasContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_has; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProgramListener ) ((ProgramListener)listener).enterHas(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProgramListener ) ((ProgramListener)listener).exitHas(this);
}
}
public final HasContext has() throws RecognitionException {
HasContext _localctx = new HasContext(_ctx, getState());
enterRule(_localctx, 30, RULE_has);
try {
enterOuterAlt(_localctx, 1);
{
setState(230);
match(COLON);
setState(231);
match(NAME);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DataContext extends ParserRuleContext {
public TerminalNode BYTES() { return getToken(ProgramParser.BYTES, 0); }
public TerminalNode BOOL() { return getToken(ProgramParser.BOOL, 0); }
public TerminalNode TEXT() { return getToken(ProgramParser.TEXT, 0); }
public TerminalNode STRING() { return getToken(ProgramParser.STRING, 0); }
public TerminalNode INT() { return getToken(ProgramParser.INT, 0); }
public TerminalNode FLOAT() { return getToken(ProgramParser.FLOAT, 0); }
public TerminalNode HEX() { return getToken(ProgramParser.HEX, 0); }
public DataContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_data; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProgramListener ) ((ProgramListener)listener).enterData(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProgramListener ) ((ProgramListener)listener).exitData(this);
}
}
public final DataContext data() throws RecognitionException {
DataContext _localctx = new DataContext(_ctx, getState());
enterRule(_localctx, 32, RULE_data);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(233);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BYTES) | (1L << BOOL) | (1L << STRING) | (1L << INT) | (1L << FLOAT) | (1L << HEX) | (1L << TEXT))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
switch (ruleIndex) {
case 12:
return application_sempred((ApplicationContext)_localctx, predIndex);
}
return true;
}
private boolean application_sempred(ApplicationContext _localctx, int predIndex) {
switch (predIndex) {
case 0:
return precpred(_ctx, 4);
case 1:
return precpred(_ctx, 2);
case 2:
return precpred(_ctx, 1);
}
return true;
}
public static final String _serializedATN =
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\'\u00ee\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\5\2&\n\2\3\2\5\2)\n\2\3\2\3\2\3\2\3\3\3\3\6\3\60\n\3\r\3\16\3\61"+
"\3\4\3\4\6\4\66\n\4\r\4\16\4\67\3\5\3\5\7\5<\n\5\f\5\16\5?\13\5\3\5\3"+
"\5\3\5\6\5D\n\5\r\5\16\5E\3\6\3\6\5\6J\n\6\3\6\5\6M\n\6\3\6\3\6\3\6\5"+
"\6R\n\6\3\6\5\6U\n\6\3\6\5\6X\n\6\7\6Z\n\6\f\6\16\6]\13\6\3\7\3\7\7\7"+
"a\n\7\f\7\16\7d\13\7\3\7\3\7\3\7\3\7\3\7\5\7k\n\7\3\7\5\7n\n\7\3\b\3\b"+
"\3\b\3\b\7\bt\n\b\f\b\16\bw\13\b\5\by\n\b\3\b\3\b\3\t\3\t\3\n\3\n\3\n"+
"\5\n\u0082\n\n\5\n\u0084\n\n\3\13\3\13\3\13\3\13\3\13\6\13\u008b\n\13"+
"\r\13\16\13\u008c\3\13\3\13\3\f\3\f\3\f\3\f\3\f\5\f\u0096\n\f\3\r\3\r"+
"\3\r\3\16\3\16\3\16\5\16\u009e\n\16\3\16\3\16\3\16\3\16\5\16\u00a4\n\16"+
"\5\16\u00a6\n\16\3\16\3\16\3\16\5\16\u00ab\n\16\3\16\3\16\3\16\5\16\u00b0"+
"\n\16\3\16\3\16\3\16\5\16\u00b5\n\16\7\16\u00b7\n\16\f\16\16\16\u00ba"+
"\13\16\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17"+
"\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\6\17\u00d1\n\17\r\17\16\17\u00d2"+
"\3\20\5\20\u00d6\n\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\5\20"+
"\u00e1\n\20\3\20\3\20\3\20\3\20\5\20\u00e7\n\20\3\21\3\21\3\21\3\22\3"+
"\22\3\22\2\3\32\23\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"\2\5\4\2\23"+
"\23$$\5\2\16\16\32\33$$\4\2\36#%%\2\u010d\2%\3\2\2\2\4/\3\2\2\2\6\65\3"+
"\2\2\2\bC\3\2\2\2\nI\3\2\2\2\fb\3\2\2\2\16o\3\2\2\2\20|\3\2\2\2\22\u0083"+
"\3\2\2\2\24\u0085\3\2\2\2\26\u0090\3\2\2\2\30\u0097\3\2\2\2\32\u00a5\3"+
"\2\2\2\34\u00d0\3\2\2\2\36\u00d5\3\2\2\2 \u00e8\3\2\2\2\"\u00eb\3\2\2"+
"\2$&\5\4\3\2%$\3\2\2\2%&\3\2\2\2&(\3\2\2\2\')\5\6\4\2(\'\3\2\2\2()\3\2"+
"\2\2)*\3\2\2\2*+\5\b\5\2+,\7\2\2\3,\3\3\2\2\2-.\7\3\2\2.\60\7\35\2\2/"+
"-\3\2\2\2\60\61\3\2\2\2\61/\3\2\2\2\61\62\3\2\2\2\62\5\3\2\2\2\63\64\7"+
"\4\2\2\64\66\7\35\2\2\65\63\3\2\2\2\66\67\3\2\2\2\67\65\3\2\2\2\678\3"+
"\2\2\28\7\3\2\2\29:\7\3\2\2:<\7\35\2\2;9\3\2\2\2\3\2\2\2>@\3\2\2\2?=\3\2\2\2@A\5\n\6\2AB\7\35\2\2BD\3\2\2\2C=\3\2\2\2"+
"DE\3\2\2\2EC\3\2\2\2EF\3\2\2\2F\t\3\2\2\2GJ\5\f\7\2HJ\5\32\16\2IG\3\2"+
"\2\2IH\3\2\2\2JL\3\2\2\2KM\5\24\13\2LK\3\2\2\2LM\3\2\2\2M[\3\2\2\2NO\7"+
"\35\2\2OQ\5\30\r\2PR\5\34\17\2QP\3\2\2\2QR\3\2\2\2RT\3\2\2\2SU\5\26\f"+
"\2TS\3\2\2\2TU\3\2\2\2UW\3\2\2\2VX\5\24\13\2WV\3\2\2\2WX\3\2\2\2XZ\3\2"+
"\2\2YN\3\2\2\2Z]\3\2\2\2[Y\3\2\2\2[\\\3\2\2\2\\\13\3\2\2\2][\3\2\2\2^"+
"_\7\3\2\2_a\7\35\2\2`^\3\2\2\2ad\3\2\2\2b`\3\2\2\2bc\3\2\2\2ce\3\2\2\2"+
"db\3\2\2\2em\5\16\b\2fj\5\26\f\2gh\7\24\2\2hi\7\n\2\2ik\t\2\2\2jg\3\2"+
"\2\2jk\3\2\2\2kn\3\2\2\2ln\5\34\17\2mf\3\2\2\2ml\3\2\2\2mn\3\2\2\2n\r"+
"\3\2\2\2ox\7\26\2\2pu\5\20\t\2qr\7\24\2\2rt\5\20\t\2sq\3\2\2\2tw\3\2\2"+
"\2us\3\2\2\2uv\3\2\2\2vy\3\2\2\2wu\3\2\2\2xp\3\2\2\2xy\3\2\2\2yz\3\2\2"+
"\2z{\7\27\2\2{\17\3\2\2\2|}\5\22\n\2}\21\3\2\2\2~\u0084\7\32\2\2\177\u0081"+
"\7$\2\2\u0080\u0082\7\b\2\2\u0081\u0080\3\2\2\2\u0081\u0082\3\2\2\2\u0082"+
"\u0084\3\2\2\2\u0083~\3\2\2\2\u0083\177\3\2\2\2\u0084\23\3\2\2\2\u0085"+
"\u0086\7\35\2\2\u0086\u008a\7&\2\2\u0087\u0088\5\n\6\2\u0088\u0089\7\35"+
"\2\2\u0089\u008b\3\2\2\2\u008a\u0087\3\2\2\2\u008b\u008c\3\2\2\2\u008c"+
"\u008a\3\2\2\2\u008c\u008d\3\2\2\2\u008d\u008e\3\2\2\2\u008e\u008f\7\'"+
"\2\2\u008f\25\3\2\2\2\u0090\u0091\7\24\2\2\u0091\u0092\7\r\2\2\u0092\u0093"+
"\7\24\2\2\u0093\u0095\5\22\n\2\u0094\u0096\7\t\2\2\u0095\u0094\3\2\2\2"+
"\u0095\u0096\3\2\2\2\u0096\27\3\2\2\2\u0097\u0098\7\25\2\2\u0098\u0099"+
"\t\3\2\2\u0099\31\3\2\2\2\u009a\u009b\b\16\1\2\u009b\u009d\5\36\20\2\u009c"+
"\u009e\5\34\17\2\u009d\u009c\3\2\2\2\u009d\u009e\3\2\2\2\u009e\u00a6\3"+
"\2\2\2\u009f\u00a0\7\30\2\2\u00a0\u00a1\5\32\16\2\u00a1\u00a3\7\31\2\2"+
"\u00a2\u00a4\5\34\17\2\u00a3\u00a2\3\2\2\2\u00a3\u00a4\3\2\2\2\u00a4\u00a6"+
"\3\2\2\2\u00a5\u009a\3\2\2\2\u00a5\u009f\3\2\2\2\u00a6\u00b8\3\2\2\2\u00a7"+
"\u00a8\f\6\2\2\u00a8\u00aa\5\30\r\2\u00a9\u00ab\5\34\17\2\u00aa\u00a9"+
"\3\2\2\2\u00aa\u00ab\3\2\2\2\u00ab\u00b7\3\2\2\2\u00ac\u00ad\f\4\2\2\u00ad"+
"\u00af\5 \21\2\u00ae\u00b0\5\34\17\2\u00af\u00ae\3\2\2\2\u00af\u00b0\3"+
"\2\2\2\u00b0\u00b7\3\2\2\2\u00b1\u00b2\f\3\2\2\u00b2\u00b4\5\26\f\2\u00b3"+
"\u00b5\5\34\17\2\u00b4\u00b3\3\2\2\2\u00b4\u00b5\3\2\2\2\u00b5\u00b7\3"+
"\2\2\2\u00b6\u00a7\3\2\2\2\u00b6\u00ac\3\2\2\2\u00b6\u00b1\3\2\2\2\u00b7"+
"\u00ba\3\2\2\2\u00b8\u00b6\3\2\2\2\u00b8\u00b9\3\2\2\2\u00b9\33\3\2\2"+
"\2\u00ba\u00b8\3\2\2\2\u00bb\u00bc\7\24\2\2\u00bc\u00d1\5\36\20\2\u00bd"+
"\u00be\7\24\2\2\u00be\u00bf\5\32\16\2\u00bf\u00c0\5\30\r\2\u00c0\u00d1"+
"\3\2\2\2\u00c1\u00c2\7\24\2\2\u00c2\u00c3\7\30\2\2\u00c3\u00c4\5\32\16"+
"\2\u00c4\u00c5\7\31\2\2\u00c5\u00d1\3\2\2\2\u00c6\u00c7\7\24\2\2\u00c7"+
"\u00c8\5\32\16\2\u00c8\u00c9\5 \21\2\u00c9\u00d1\3\2\2\2\u00ca\u00cb\7"+
"\24\2\2\u00cb\u00cc\5\32\16\2\u00cc\u00cd\5\26\f\2\u00cd\u00d1\3\2\2\2"+
"\u00ce\u00cf\7\24\2\2\u00cf\u00d1\5\f\7\2\u00d0\u00bb\3\2\2\2\u00d0\u00bd"+
"\3\2\2\2\u00d0\u00c1\3\2\2\2\u00d0\u00c6\3\2\2\2\u00d0\u00ca\3\2\2\2\u00d0"+
"\u00ce\3\2\2\2\u00d1\u00d2\3\2\2\2\u00d2\u00d0\3\2\2\2\u00d2\u00d3\3\2"+
"\2\2\u00d3\35\3\2\2\2\u00d4\u00d6\7\b\2\2\u00d5\u00d4\3\2\2\2\u00d5\u00d6"+
"\3\2\2\2\u00d6\u00e6\3\2\2\2\u00d7\u00e7\7\5\2\2\u00d8\u00e7\7\6\2\2\u00d9"+
"\u00e7\7\32\2\2\u00da\u00e7\7\33\2\2\u00db\u00e7\7\20\2\2\u00dc\u00e7"+
"\7\17\2\2\u00dd\u00e7\7\7\2\2\u00de\u00e0\7$\2\2\u00df\u00e1\7\f\2\2\u00e0"+
"\u00df\3\2\2\2\u00e0\u00e1\3\2\2\2\u00e1\u00e7\3\2\2\2\u00e2\u00e3\7$"+
"\2\2\u00e3\u00e7\7\25\2\2\u00e4\u00e7\5\"\22\2\u00e5\u00e7\5\f\7\2\u00e6"+
"\u00d7\3\2\2\2\u00e6\u00d8\3\2\2\2\u00e6\u00d9\3\2\2\2\u00e6\u00da\3\2"+
"\2\2\u00e6\u00db\3\2\2\2\u00e6\u00dc\3\2\2\2\u00e6\u00dd\3\2\2\2\u00e6"+
"\u00de\3\2\2\2\u00e6\u00e2\3\2\2\2\u00e6\u00e4\3\2\2\2\u00e6\u00e5\3\2"+
"\2\2\u00e7\37\3\2\2\2\u00e8\u00e9\7\13\2\2\u00e9\u00ea\7$\2\2\u00ea!\3"+
"\2\2\2\u00eb\u00ec\t\4\2\2\u00ec#\3\2\2\2$%(\61\67=EILQTW[bjmux\u0081"+
"\u0083\u008c\u0095\u009d\u00a3\u00a5\u00aa\u00af\u00b4\u00b6\u00b8\u00d0"+
"\u00d2\u00d5\u00e0\u00e6";
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 - 2025 Weber Informatics LLC | Privacy Policy