org.eolang.parser.ProgramParser Maven / Gradle / Ivy
// Generated from org/eolang/parser/Program.g4 by ANTLR 4.8
package org.eolang.parser;
import java.util.LinkedList;
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.8", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
COMMENT=1, META=2, DOTS=3, CONST=4, SLASH=5, COLON=6, ARROW=7, SELF=8,
PLUS=9, MINUS=10, SPACE=11, DOT=12, LSQ=13, RSQ=14, LB=15, RB=16, AT=17,
PARENT=18, HASH=19, EOL=20, BYTES=21, BOOL=22, CHAR=23, STRING=24, INT=25,
FLOAT=26, HEX=27, NAME=28, TAB=29, UNTAB=30;
public static final int
RULE_program = 0, RULE_license = 1, RULE_metas = 2, RULE_objects = 3,
RULE_object = 4, RULE_abstraction = 5, RULE_attribute = 6, RULE_label = 7,
RULE_tail = 8, RULE_suffix = 9, RULE_method = 10, RULE_application = 11,
RULE_htail = 12, RULE_head = 13, RULE_has = 14, RULE_data = 15;
private static String[] makeRuleNames() {
return new String[] {
"program", "license", "metas", "objects", "object", "abstraction", "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, "'...'", "'!'", "'/'", "':'", "'>'", "'$'", "'+'",
"'-'", "' '", "'.'", "'['", "']'", "'('", "')'", "'@'", "'^'", "'#'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
null, "COMMENT", "META", "DOTS", "CONST", "SLASH", "COLON", "ARROW",
"SELF", "PLUS", "MINUS", "SPACE", "DOT", "LSQ", "RSQ", "LB", "RB", "AT",
"PARENT", "HASH", "EOL", "BYTES", "BOOL", "CHAR", "STRING", "INT", "FLOAT",
"HEX", "NAME", "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(33);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
case 1:
{
setState(32);
license();
}
break;
}
setState(36);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==META) {
{
setState(35);
metas();
}
}
setState(38);
objects();
setState(39);
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(43);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(41);
match(COMMENT);
setState(42);
match(EOL);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(45);
_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(49);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(47);
match(META);
setState(48);
match(EOL);
}
}
setState(51);
_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(63);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(57);
_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(53);
match(COMMENT);
setState(54);
match(EOL);
}
}
}
setState(59);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,4,_ctx);
}
setState(60);
object();
setState(61);
match(EOL);
}
}
setState(65);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << COMMENT) | (1L << SELF) | (1L << LSQ) | (1L << LB) | (1L << AT) | (1L << PARENT) | (1L << BYTES) | (1L << BOOL) | (1L << CHAR) | (1L << STRING) | (1L << INT) | (1L << FLOAT) | (1L << HEX) | (1L << NAME))) != 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 TailContext tail() {
return getRuleContext(TailContext.class,0);
}
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 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(69);
_errHandler.sync(this);
switch (_input.LA(1)) {
case COMMENT:
case LSQ:
{
setState(67);
abstraction();
}
break;
case SELF:
case LB:
case AT:
case PARENT:
case BYTES:
case BOOL:
case CHAR:
case STRING:
case INT:
case FLOAT:
case HEX:
case NAME:
{
setState(68);
application(0);
}
break;
default:
throw new NoViableAltException(this);
}
setState(72);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) {
case 1:
{
setState(71);
tail();
}
break;
}
setState(81);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,9,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(74);
match(EOL);
setState(75);
method();
setState(77);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SPACE) {
{
setState(76);
suffix();
}
}
}
}
}
setState(83);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,9,_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 TerminalNode LSQ() { return getToken(ProgramParser.LSQ, 0); }
public TerminalNode RSQ() { return getToken(ProgramParser.RSQ, 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 List attribute() {
return getRuleContexts(AttributeContext.class);
}
public AttributeContext attribute(int i) {
return getRuleContext(AttributeContext.class,i);
}
public SuffixContext suffix() {
return getRuleContext(SuffixContext.class,0);
}
public List SPACE() { return getTokens(ProgramParser.SPACE); }
public TerminalNode SPACE(int i) {
return getToken(ProgramParser.SPACE, i);
}
public TerminalNode SLASH() { return getToken(ProgramParser.SLASH, 0); }
public TerminalNode NAME() { return getToken(ProgramParser.NAME, 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(88);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMENT) {
{
{
setState(84);
match(COMMENT);
setState(85);
match(EOL);
}
}
setState(90);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(91);
match(LSQ);
setState(100);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AT || _la==NAME) {
{
setState(92);
attribute();
setState(97);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SPACE) {
{
{
setState(93);
match(SPACE);
setState(94);
attribute();
}
}
setState(99);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(102);
match(RSQ);
setState(109);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SPACE) {
{
setState(103);
suffix();
setState(107);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SPACE) {
{
setState(104);
match(SPACE);
setState(105);
match(SLASH);
setState(106);
match(NAME);
}
}
}
}
}
}
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, 12, RULE_attribute);
try {
enterOuterAlt(_localctx, 1);
{
setState(111);
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, 14, RULE_label);
try {
setState(118);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AT:
enterOuterAlt(_localctx, 1);
{
setState(113);
match(AT);
}
break;
case NAME:
enterOuterAlt(_localctx, 2);
{
setState(114);
match(NAME);
setState(116);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) {
case 1:
{
setState(115);
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, 16, RULE_tail);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(120);
match(EOL);
setState(121);
match(TAB);
setState(125);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(122);
object();
setState(123);
match(EOL);
}
}
setState(127);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << COMMENT) | (1L << SELF) | (1L << LSQ) | (1L << LB) | (1L << AT) | (1L << PARENT) | (1L << BYTES) | (1L << BOOL) | (1L << CHAR) | (1L << STRING) | (1L << INT) | (1L << FLOAT) | (1L << HEX) | (1L << NAME))) != 0) );
setState(129);
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, 18, RULE_suffix);
try {
enterOuterAlt(_localctx, 1);
{
setState(131);
match(SPACE);
setState(132);
match(ARROW);
setState(133);
match(SPACE);
setState(134);
label();
setState(136);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
case 1:
{
setState(135);
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 TerminalNode DOT() { return getToken(ProgramParser.DOT, 0); }
public TerminalNode NAME() { return getToken(ProgramParser.NAME, 0); }
public TerminalNode PARENT() { return getToken(ProgramParser.PARENT, 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, 20, RULE_method);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(138);
match(DOT);
setState(139);
_la = _input.LA(1);
if ( !(_la==PARENT || _la==NAME) ) {
_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 = 22;
enterRecursionRule(_localctx, 22, RULE_application, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(152);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SELF:
case AT:
case PARENT:
case BYTES:
case BOOL:
case CHAR:
case STRING:
case INT:
case FLOAT:
case HEX:
case NAME:
{
setState(142);
head();
setState(144);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) {
case 1:
{
setState(143);
htail();
}
break;
}
}
break;
case LB:
{
setState(146);
match(LB);
setState(147);
application(0);
setState(148);
match(RB);
setState(150);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) {
case 1:
{
setState(149);
htail();
}
break;
}
}
break;
default:
throw new NoViableAltException(this);
}
_ctx.stop = _input.LT(-1);
setState(171);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,26,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(169);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
case 1:
{
_localctx = new ApplicationContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_application);
setState(154);
if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
setState(155);
method();
setState(157);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) {
case 1:
{
setState(156);
htail();
}
break;
}
}
break;
case 2:
{
_localctx = new ApplicationContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_application);
setState(159);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(160);
has();
setState(162);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,23,_ctx) ) {
case 1:
{
setState(161);
htail();
}
break;
}
}
break;
case 3:
{
_localctx = new ApplicationContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_application);
setState(164);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(165);
suffix();
setState(167);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,24,_ctx) ) {
case 1:
{
setState(166);
htail();
}
break;
}
}
break;
}
}
}
setState(173);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,26,_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 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, 24, RULE_htail);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(193);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
setState(193);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) {
case 1:
{
setState(174);
match(SPACE);
setState(175);
head();
}
break;
case 2:
{
setState(176);
match(SPACE);
setState(177);
application(0);
setState(178);
method();
}
break;
case 3:
{
setState(180);
match(SPACE);
setState(181);
match(LB);
setState(182);
application(0);
setState(183);
match(RB);
}
break;
case 4:
{
setState(185);
match(SPACE);
setState(186);
application(0);
setState(187);
has();
}
break;
case 5:
{
setState(189);
match(SPACE);
setState(190);
application(0);
setState(191);
suffix();
}
break;
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(195);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,28,_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 AT() { return getToken(ProgramParser.AT, 0); }
public TerminalNode PARENT() { return getToken(ProgramParser.PARENT, 0); }
public TerminalNode SELF() { return getToken(ProgramParser.SELF, 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 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, 26, RULE_head);
try {
setState(204);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,29,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(197);
match(AT);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(198);
match(PARENT);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(199);
match(SELF);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(200);
match(NAME);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(201);
match(NAME);
setState(202);
match(DOT);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(203);
data();
}
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, 28, RULE_has);
try {
enterOuterAlt(_localctx, 1);
{
setState(206);
match(COLON);
setState(207);
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 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 TerminalNode CHAR() { return getToken(ProgramParser.CHAR, 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, 30, RULE_data);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(209);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BYTES) | (1L << BOOL) | (1L << CHAR) | (1L << STRING) | (1L << INT) | (1L << FLOAT) | (1L << HEX))) != 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 11:
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 \u00d6\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\3\2\5\2$\n"+
"\2\3\2\5\2\'\n\2\3\2\3\2\3\2\3\3\3\3\6\3.\n\3\r\3\16\3/\3\4\3\4\6\4\64"+
"\n\4\r\4\16\4\65\3\5\3\5\7\5:\n\5\f\5\16\5=\13\5\3\5\3\5\3\5\6\5B\n\5"+
"\r\5\16\5C\3\6\3\6\5\6H\n\6\3\6\5\6K\n\6\3\6\3\6\3\6\5\6P\n\6\7\6R\n\6"+
"\f\6\16\6U\13\6\3\7\3\7\7\7Y\n\7\f\7\16\7\\\13\7\3\7\3\7\3\7\3\7\7\7b"+
"\n\7\f\7\16\7e\13\7\5\7g\n\7\3\7\3\7\3\7\3\7\3\7\5\7n\n\7\5\7p\n\7\3\b"+
"\3\b\3\t\3\t\3\t\5\tw\n\t\5\ty\n\t\3\n\3\n\3\n\3\n\3\n\6\n\u0080\n\n\r"+
"\n\16\n\u0081\3\n\3\n\3\13\3\13\3\13\3\13\3\13\5\13\u008b\n\13\3\f\3\f"+
"\3\f\3\r\3\r\3\r\5\r\u0093\n\r\3\r\3\r\3\r\3\r\5\r\u0099\n\r\5\r\u009b"+
"\n\r\3\r\3\r\3\r\5\r\u00a0\n\r\3\r\3\r\3\r\5\r\u00a5\n\r\3\r\3\r\3\r\5"+
"\r\u00aa\n\r\7\r\u00ac\n\r\f\r\16\r\u00af\13\r\3\16\3\16\3\16\3\16\3\16"+
"\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16"+
"\6\16\u00c4\n\16\r\16\16\16\u00c5\3\17\3\17\3\17\3\17\3\17\3\17\3\17\5"+
"\17\u00cf\n\17\3\20\3\20\3\20\3\21\3\21\3\21\2\3\30\22\2\4\6\b\n\f\16"+
"\20\22\24\26\30\32\34\36 \2\4\4\2\24\24\36\36\3\2\27\35\2\u00eb\2#\3\2"+
"\2\2\4-\3\2\2\2\6\63\3\2\2\2\bA\3\2\2\2\nG\3\2\2\2\fZ\3\2\2\2\16q\3\2"+
"\2\2\20x\3\2\2\2\22z\3\2\2\2\24\u0085\3\2\2\2\26\u008c\3\2\2\2\30\u009a"+
"\3\2\2\2\32\u00c3\3\2\2\2\34\u00ce\3\2\2\2\36\u00d0\3\2\2\2 \u00d3\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,.\7\26\2"+
"\2-+\3\2\2\2./\3\2\2\2/-\3\2\2\2/\60\3\2\2\2\60\5\3\2\2\2\61\62\7\4\2"+
"\2\62\64\7\26\2\2\63\61\3\2\2\2\64\65\3\2\2\2\65\63\3\2\2\2\65\66\3\2"+
"\2\2\66\7\3\2\2\2\678\7\3\2\28:\7\26\2\29\67\3\2\2\2:=\3\2\2\2;9\3\2\2"+
"\2;<\3\2\2\2<>\3\2\2\2=;\3\2\2\2>?\5\n\6\2?@\7\26\2\2@B\3\2\2\2A;\3\2"+
"\2\2BC\3\2\2\2CA\3\2\2\2CD\3\2\2\2D\t\3\2\2\2EH\5\f\7\2FH\5\30\r\2GE\3"+
"\2\2\2GF\3\2\2\2HJ\3\2\2\2IK\5\22\n\2JI\3\2\2\2JK\3\2\2\2KS\3\2\2\2LM"+
"\7\26\2\2MO\5\26\f\2NP\5\24\13\2ON\3\2\2\2OP\3\2\2\2PR\3\2\2\2QL\3\2\2"+
"\2RU\3\2\2\2SQ\3\2\2\2ST\3\2\2\2T\13\3\2\2\2US\3\2\2\2VW\7\3\2\2WY\7\26"+
"\2\2XV\3\2\2\2Y\\\3\2\2\2ZX\3\2\2\2Z[\3\2\2\2[]\3\2\2\2\\Z\3\2\2\2]f\7"+
"\17\2\2^c\5\16\b\2_`\7\r\2\2`b\5\16\b\2a_\3\2\2\2be\3\2\2\2ca\3\2\2\2"+
"cd\3\2\2\2dg\3\2\2\2ec\3\2\2\2f^\3\2\2\2fg\3\2\2\2gh\3\2\2\2ho\7\20\2"+
"\2im\5\24\13\2jk\7\r\2\2kl\7\7\2\2ln\7\36\2\2mj\3\2\2\2mn\3\2\2\2np\3"+
"\2\2\2oi\3\2\2\2op\3\2\2\2p\r\3\2\2\2qr\5\20\t\2r\17\3\2\2\2sy\7\23\2"+
"\2tv\7\36\2\2uw\7\5\2\2vu\3\2\2\2vw\3\2\2\2wy\3\2\2\2xs\3\2\2\2xt\3\2"+
"\2\2y\21\3\2\2\2z{\7\26\2\2{\177\7\37\2\2|}\5\n\6\2}~\7\26\2\2~\u0080"+
"\3\2\2\2\177|\3\2\2\2\u0080\u0081\3\2\2\2\u0081\177\3\2\2\2\u0081\u0082"+
"\3\2\2\2\u0082\u0083\3\2\2\2\u0083\u0084\7 \2\2\u0084\23\3\2\2\2\u0085"+
"\u0086\7\r\2\2\u0086\u0087\7\t\2\2\u0087\u0088\7\r\2\2\u0088\u008a\5\20"+
"\t\2\u0089\u008b\7\6\2\2\u008a\u0089\3\2\2\2\u008a\u008b\3\2\2\2\u008b"+
"\25\3\2\2\2\u008c\u008d\7\16\2\2\u008d\u008e\t\2\2\2\u008e\27\3\2\2\2"+
"\u008f\u0090\b\r\1\2\u0090\u0092\5\34\17\2\u0091\u0093\5\32\16\2\u0092"+
"\u0091\3\2\2\2\u0092\u0093\3\2\2\2\u0093\u009b\3\2\2\2\u0094\u0095\7\21"+
"\2\2\u0095\u0096\5\30\r\2\u0096\u0098\7\22\2\2\u0097\u0099\5\32\16\2\u0098"+
"\u0097\3\2\2\2\u0098\u0099\3\2\2\2\u0099\u009b\3\2\2\2\u009a\u008f\3\2"+
"\2\2\u009a\u0094\3\2\2\2\u009b\u00ad\3\2\2\2\u009c\u009d\f\6\2\2\u009d"+
"\u009f\5\26\f\2\u009e\u00a0\5\32\16\2\u009f\u009e\3\2\2\2\u009f\u00a0"+
"\3\2\2\2\u00a0\u00ac\3\2\2\2\u00a1\u00a2\f\4\2\2\u00a2\u00a4\5\36\20\2"+
"\u00a3\u00a5\5\32\16\2\u00a4\u00a3\3\2\2\2\u00a4\u00a5\3\2\2\2\u00a5\u00ac"+
"\3\2\2\2\u00a6\u00a7\f\3\2\2\u00a7\u00a9\5\24\13\2\u00a8\u00aa\5\32\16"+
"\2\u00a9\u00a8\3\2\2\2\u00a9\u00aa\3\2\2\2\u00aa\u00ac\3\2\2\2\u00ab\u009c"+
"\3\2\2\2\u00ab\u00a1\3\2\2\2\u00ab\u00a6\3\2\2\2\u00ac\u00af\3\2\2\2\u00ad"+
"\u00ab\3\2\2\2\u00ad\u00ae\3\2\2\2\u00ae\31\3\2\2\2\u00af\u00ad\3\2\2"+
"\2\u00b0\u00b1\7\r\2\2\u00b1\u00c4\5\34\17\2\u00b2\u00b3\7\r\2\2\u00b3"+
"\u00b4\5\30\r\2\u00b4\u00b5\5\26\f\2\u00b5\u00c4\3\2\2\2\u00b6\u00b7\7"+
"\r\2\2\u00b7\u00b8\7\21\2\2\u00b8\u00b9\5\30\r\2\u00b9\u00ba\7\22\2\2"+
"\u00ba\u00c4\3\2\2\2\u00bb\u00bc\7\r\2\2\u00bc\u00bd\5\30\r\2\u00bd\u00be"+
"\5\36\20\2\u00be\u00c4\3\2\2\2\u00bf\u00c0\7\r\2\2\u00c0\u00c1\5\30\r"+
"\2\u00c1\u00c2\5\24\13\2\u00c2\u00c4\3\2\2\2\u00c3\u00b0\3\2\2\2\u00c3"+
"\u00b2\3\2\2\2\u00c3\u00b6\3\2\2\2\u00c3\u00bb\3\2\2\2\u00c3\u00bf\3\2"+
"\2\2\u00c4\u00c5\3\2\2\2\u00c5\u00c3\3\2\2\2\u00c5\u00c6\3\2\2\2\u00c6"+
"\33\3\2\2\2\u00c7\u00cf\7\23\2\2\u00c8\u00cf\7\24\2\2\u00c9\u00cf\7\n"+
"\2\2\u00ca\u00cf\7\36\2\2\u00cb\u00cc\7\36\2\2\u00cc\u00cf\7\16\2\2\u00cd"+
"\u00cf\5 \21\2\u00ce\u00c7\3\2\2\2\u00ce\u00c8\3\2\2\2\u00ce\u00c9\3\2"+
"\2\2\u00ce\u00ca\3\2\2\2\u00ce\u00cb\3\2\2\2\u00ce\u00cd\3\2\2\2\u00cf"+
"\35\3\2\2\2\u00d0\u00d1\7\b\2\2\u00d1\u00d2\7\36\2\2\u00d2\37\3\2\2\2"+
"\u00d3\u00d4\t\3\2\2\u00d4!\3\2\2\2 #&/\65;CGJOSZcfmovx\u0081\u008a\u0092"+
"\u0098\u009a\u009f\u00a4\u00a9\u00ab\u00ad\u00c3\u00c5\u00ce";
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