cloud.orbit.dsl.OrbitParser Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of orbit-codegen-dsl Show documentation
Show all versions of orbit-codegen-dsl Show documentation
The Orbit project is a collection of JVM libraries that makes it easier to build distributed and scalable online services.
The newest version!
// Generated from cloud/orbit/dsl/Orbit.g4 by ANTLR 4.7.1
package cloud.orbit.dsl;
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 OrbitParser extends Parser {
static { RuntimeMetaData.checkVersion("4.7.1", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
DATA=1, ENUM=2, ACTOR=3, ID=4, INT=5, COMMA=6, EQUAL=7, L_PAREN=8, LC_BRACE=9,
L_ANGLE=10, R_PAREN=11, RC_BRACE=12, R_ANGLE=13, SEMI_COLON=14, COMMENT=15,
IGNORE=16;
public static final int
RULE_file = 0, RULE_declaration = 1, RULE_enumDeclaration = 2, RULE_enumMember = 3,
RULE_actorDeclaration = 4, RULE_actorMethod = 5, RULE_methodParam = 6,
RULE_dataDeclaration = 7, RULE_dataField = 8, RULE_type = 9;
public static final String[] ruleNames = {
"file", "declaration", "enumDeclaration", "enumMember", "actorDeclaration",
"actorMethod", "methodParam", "dataDeclaration", "dataField", "type"
};
private static final String[] _LITERAL_NAMES = {
null, "'data'", "'enum'", "'actor'", null, null, "','", "'='", "'('",
"'{'", "'<'", "')'", "'}'", "'>'", "';'"
};
private static final String[] _SYMBOLIC_NAMES = {
null, "DATA", "ENUM", "ACTOR", "ID", "INT", "COMMA", "EQUAL", "L_PAREN",
"LC_BRACE", "L_ANGLE", "R_PAREN", "RC_BRACE", "R_ANGLE", "SEMI_COLON",
"COMMENT", "IGNORE"
};
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 "Orbit.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public OrbitParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class FileContext extends ParserRuleContext {
public TerminalNode EOF() { return getToken(OrbitParser.EOF, 0); }
public List declaration() {
return getRuleContexts(DeclarationContext.class);
}
public DeclarationContext declaration(int i) {
return getRuleContext(DeclarationContext.class,i);
}
public FileContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_file; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof OrbitListener ) ((OrbitListener)listener).enterFile(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof OrbitListener ) ((OrbitListener)listener).exitFile(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OrbitVisitor ) return ((OrbitVisitor)visitor).visitFile(this);
else return visitor.visitChildren(this);
}
}
public final FileContext file() throws RecognitionException {
FileContext _localctx = new FileContext(_ctx, getState());
enterRule(_localctx, 0, RULE_file);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(21);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(20);
declaration();
}
}
setState(23);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << DATA) | (1L << ENUM) | (1L << ACTOR))) != 0) );
setState(25);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DeclarationContext extends ParserRuleContext {
public EnumDeclarationContext enumDeclaration() {
return getRuleContext(EnumDeclarationContext.class,0);
}
public ActorDeclarationContext actorDeclaration() {
return getRuleContext(ActorDeclarationContext.class,0);
}
public DataDeclarationContext dataDeclaration() {
return getRuleContext(DataDeclarationContext.class,0);
}
public DeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_declaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof OrbitListener ) ((OrbitListener)listener).enterDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof OrbitListener ) ((OrbitListener)listener).exitDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OrbitVisitor ) return ((OrbitVisitor)visitor).visitDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final DeclarationContext declaration() throws RecognitionException {
DeclarationContext _localctx = new DeclarationContext(_ctx, getState());
enterRule(_localctx, 2, RULE_declaration);
try {
setState(30);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ENUM:
enterOuterAlt(_localctx, 1);
{
setState(27);
enumDeclaration();
}
break;
case ACTOR:
enterOuterAlt(_localctx, 2);
{
setState(28);
actorDeclaration();
}
break;
case DATA:
enterOuterAlt(_localctx, 3);
{
setState(29);
dataDeclaration();
}
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 EnumDeclarationContext extends ParserRuleContext {
public Token name;
public EnumMemberContext members;
public TerminalNode ENUM() { return getToken(OrbitParser.ENUM, 0); }
public TerminalNode LC_BRACE() { return getToken(OrbitParser.LC_BRACE, 0); }
public TerminalNode RC_BRACE() { return getToken(OrbitParser.RC_BRACE, 0); }
public TerminalNode ID() { return getToken(OrbitParser.ID, 0); }
public List enumMember() {
return getRuleContexts(EnumMemberContext.class);
}
public EnumMemberContext enumMember(int i) {
return getRuleContext(EnumMemberContext.class,i);
}
public EnumDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof OrbitListener ) ((OrbitListener)listener).enterEnumDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof OrbitListener ) ((OrbitListener)listener).exitEnumDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OrbitVisitor ) return ((OrbitVisitor)visitor).visitEnumDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final EnumDeclarationContext enumDeclaration() throws RecognitionException {
EnumDeclarationContext _localctx = new EnumDeclarationContext(_ctx, getState());
enterRule(_localctx, 4, RULE_enumDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(32);
match(ENUM);
setState(33);
((EnumDeclarationContext)_localctx).name = match(ID);
setState(34);
match(LC_BRACE);
setState(38);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==ID) {
{
{
setState(35);
((EnumDeclarationContext)_localctx).members = enumMember();
}
}
setState(40);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(41);
match(RC_BRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnumMemberContext extends ParserRuleContext {
public Token name;
public Token index;
public TerminalNode EQUAL() { return getToken(OrbitParser.EQUAL, 0); }
public TerminalNode SEMI_COLON() { return getToken(OrbitParser.SEMI_COLON, 0); }
public TerminalNode ID() { return getToken(OrbitParser.ID, 0); }
public TerminalNode INT() { return getToken(OrbitParser.INT, 0); }
public EnumMemberContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumMember; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof OrbitListener ) ((OrbitListener)listener).enterEnumMember(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof OrbitListener ) ((OrbitListener)listener).exitEnumMember(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OrbitVisitor ) return ((OrbitVisitor)visitor).visitEnumMember(this);
else return visitor.visitChildren(this);
}
}
public final EnumMemberContext enumMember() throws RecognitionException {
EnumMemberContext _localctx = new EnumMemberContext(_ctx, getState());
enterRule(_localctx, 6, RULE_enumMember);
try {
enterOuterAlt(_localctx, 1);
{
setState(43);
((EnumMemberContext)_localctx).name = match(ID);
setState(44);
match(EQUAL);
setState(45);
((EnumMemberContext)_localctx).index = match(INT);
setState(46);
match(SEMI_COLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ActorDeclarationContext extends ParserRuleContext {
public Token name;
public ActorMethodContext methods;
public TerminalNode ACTOR() { return getToken(OrbitParser.ACTOR, 0); }
public TerminalNode LC_BRACE() { return getToken(OrbitParser.LC_BRACE, 0); }
public TerminalNode RC_BRACE() { return getToken(OrbitParser.RC_BRACE, 0); }
public TerminalNode ID() { return getToken(OrbitParser.ID, 0); }
public List actorMethod() {
return getRuleContexts(ActorMethodContext.class);
}
public ActorMethodContext actorMethod(int i) {
return getRuleContext(ActorMethodContext.class,i);
}
public ActorDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_actorDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof OrbitListener ) ((OrbitListener)listener).enterActorDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof OrbitListener ) ((OrbitListener)listener).exitActorDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OrbitVisitor ) return ((OrbitVisitor)visitor).visitActorDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final ActorDeclarationContext actorDeclaration() throws RecognitionException {
ActorDeclarationContext _localctx = new ActorDeclarationContext(_ctx, getState());
enterRule(_localctx, 8, RULE_actorDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(48);
match(ACTOR);
setState(49);
((ActorDeclarationContext)_localctx).name = match(ID);
setState(50);
match(LC_BRACE);
setState(54);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==ID) {
{
{
setState(51);
((ActorDeclarationContext)_localctx).methods = actorMethod();
}
}
setState(56);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(57);
match(RC_BRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ActorMethodContext extends ParserRuleContext {
public TypeContext returnType;
public Token name;
public MethodParamContext args;
public TerminalNode L_PAREN() { return getToken(OrbitParser.L_PAREN, 0); }
public TerminalNode R_PAREN() { return getToken(OrbitParser.R_PAREN, 0); }
public TerminalNode SEMI_COLON() { return getToken(OrbitParser.SEMI_COLON, 0); }
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public TerminalNode ID() { return getToken(OrbitParser.ID, 0); }
public List methodParam() {
return getRuleContexts(MethodParamContext.class);
}
public MethodParamContext methodParam(int i) {
return getRuleContext(MethodParamContext.class,i);
}
public List COMMA() { return getTokens(OrbitParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(OrbitParser.COMMA, i);
}
public ActorMethodContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_actorMethod; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof OrbitListener ) ((OrbitListener)listener).enterActorMethod(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof OrbitListener ) ((OrbitListener)listener).exitActorMethod(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OrbitVisitor ) return ((OrbitVisitor)visitor).visitActorMethod(this);
else return visitor.visitChildren(this);
}
}
public final ActorMethodContext actorMethod() throws RecognitionException {
ActorMethodContext _localctx = new ActorMethodContext(_ctx, getState());
enterRule(_localctx, 10, RULE_actorMethod);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(59);
((ActorMethodContext)_localctx).returnType = type();
setState(60);
((ActorMethodContext)_localctx).name = match(ID);
setState(61);
match(L_PAREN);
setState(70);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ID) {
{
setState(62);
((ActorMethodContext)_localctx).args = methodParam();
setState(67);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(63);
match(COMMA);
setState(64);
((ActorMethodContext)_localctx).args = methodParam();
}
}
setState(69);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(72);
match(R_PAREN);
setState(73);
match(SEMI_COLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MethodParamContext extends ParserRuleContext {
public Token name;
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public TerminalNode ID() { return getToken(OrbitParser.ID, 0); }
public MethodParamContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_methodParam; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof OrbitListener ) ((OrbitListener)listener).enterMethodParam(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof OrbitListener ) ((OrbitListener)listener).exitMethodParam(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OrbitVisitor ) return ((OrbitVisitor)visitor).visitMethodParam(this);
else return visitor.visitChildren(this);
}
}
public final MethodParamContext methodParam() throws RecognitionException {
MethodParamContext _localctx = new MethodParamContext(_ctx, getState());
enterRule(_localctx, 12, RULE_methodParam);
try {
enterOuterAlt(_localctx, 1);
{
setState(75);
type();
setState(76);
((MethodParamContext)_localctx).name = match(ID);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DataDeclarationContext extends ParserRuleContext {
public Token name;
public DataFieldContext fields;
public TerminalNode DATA() { return getToken(OrbitParser.DATA, 0); }
public TerminalNode LC_BRACE() { return getToken(OrbitParser.LC_BRACE, 0); }
public TerminalNode RC_BRACE() { return getToken(OrbitParser.RC_BRACE, 0); }
public TerminalNode ID() { return getToken(OrbitParser.ID, 0); }
public List dataField() {
return getRuleContexts(DataFieldContext.class);
}
public DataFieldContext dataField(int i) {
return getRuleContext(DataFieldContext.class,i);
}
public DataDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dataDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof OrbitListener ) ((OrbitListener)listener).enterDataDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof OrbitListener ) ((OrbitListener)listener).exitDataDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OrbitVisitor ) return ((OrbitVisitor)visitor).visitDataDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final DataDeclarationContext dataDeclaration() throws RecognitionException {
DataDeclarationContext _localctx = new DataDeclarationContext(_ctx, getState());
enterRule(_localctx, 14, RULE_dataDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(78);
match(DATA);
setState(79);
((DataDeclarationContext)_localctx).name = match(ID);
setState(80);
match(LC_BRACE);
setState(84);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==ID) {
{
{
setState(81);
((DataDeclarationContext)_localctx).fields = dataField();
}
}
setState(86);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(87);
match(RC_BRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DataFieldContext extends ParserRuleContext {
public Token name;
public Token index;
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public TerminalNode EQUAL() { return getToken(OrbitParser.EQUAL, 0); }
public TerminalNode SEMI_COLON() { return getToken(OrbitParser.SEMI_COLON, 0); }
public TerminalNode ID() { return getToken(OrbitParser.ID, 0); }
public TerminalNode INT() { return getToken(OrbitParser.INT, 0); }
public DataFieldContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dataField; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof OrbitListener ) ((OrbitListener)listener).enterDataField(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof OrbitListener ) ((OrbitListener)listener).exitDataField(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OrbitVisitor ) return ((OrbitVisitor)visitor).visitDataField(this);
else return visitor.visitChildren(this);
}
}
public final DataFieldContext dataField() throws RecognitionException {
DataFieldContext _localctx = new DataFieldContext(_ctx, getState());
enterRule(_localctx, 16, RULE_dataField);
try {
enterOuterAlt(_localctx, 1);
{
setState(89);
type();
setState(90);
((DataFieldContext)_localctx).name = match(ID);
setState(91);
match(EQUAL);
setState(92);
((DataFieldContext)_localctx).index = match(INT);
setState(93);
match(SEMI_COLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeContext extends ParserRuleContext {
public Token name;
public TypeContext of;
public TerminalNode ID() { return getToken(OrbitParser.ID, 0); }
public TerminalNode L_ANGLE() { return getToken(OrbitParser.L_ANGLE, 0); }
public TerminalNode R_ANGLE() { return getToken(OrbitParser.R_ANGLE, 0); }
public List type() {
return getRuleContexts(TypeContext.class);
}
public TypeContext type(int i) {
return getRuleContext(TypeContext.class,i);
}
public List COMMA() { return getTokens(OrbitParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(OrbitParser.COMMA, i);
}
public TypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_type; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof OrbitListener ) ((OrbitListener)listener).enterType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof OrbitListener ) ((OrbitListener)listener).exitType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OrbitVisitor ) return ((OrbitVisitor)visitor).visitType(this);
else return visitor.visitChildren(this);
}
}
public final TypeContext type() throws RecognitionException {
TypeContext _localctx = new TypeContext(_ctx, getState());
enterRule(_localctx, 18, RULE_type);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(95);
((TypeContext)_localctx).name = match(ID);
setState(107);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==L_ANGLE) {
{
setState(96);
match(L_ANGLE);
setState(97);
((TypeContext)_localctx).of = type();
setState(102);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(98);
match(COMMA);
setState(99);
((TypeContext)_localctx).of = type();
}
}
setState(104);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(105);
match(R_ANGLE);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static final String _serializedATN =
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\22p\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\3"+
"\2\6\2\30\n\2\r\2\16\2\31\3\2\3\2\3\3\3\3\3\3\5\3!\n\3\3\4\3\4\3\4\3\4"+
"\7\4\'\n\4\f\4\16\4*\13\4\3\4\3\4\3\5\3\5\3\5\3\5\3\5\3\6\3\6\3\6\3\6"+
"\7\6\67\n\6\f\6\16\6:\13\6\3\6\3\6\3\7\3\7\3\7\3\7\3\7\3\7\7\7D\n\7\f"+
"\7\16\7G\13\7\5\7I\n\7\3\7\3\7\3\7\3\b\3\b\3\b\3\t\3\t\3\t\3\t\7\tU\n"+
"\t\f\t\16\tX\13\t\3\t\3\t\3\n\3\n\3\n\3\n\3\n\3\n\3\13\3\13\3\13\3\13"+
"\3\13\7\13g\n\13\f\13\16\13j\13\13\3\13\3\13\5\13n\n\13\3\13\2\2\f\2\4"+
"\6\b\n\f\16\20\22\24\2\2\2o\2\27\3\2\2\2\4 \3\2\2\2\6\"\3\2\2\2\b-\3\2"+
"\2\2\n\62\3\2\2\2\f=\3\2\2\2\16M\3\2\2\2\20P\3\2\2\2\22[\3\2\2\2\24a\3"+
"\2\2\2\26\30\5\4\3\2\27\26\3\2\2\2\30\31\3\2\2\2\31\27\3\2\2\2\31\32\3"+
"\2\2\2\32\33\3\2\2\2\33\34\7\2\2\3\34\3\3\2\2\2\35!\5\6\4\2\36!\5\n\6"+
"\2\37!\5\20\t\2 \35\3\2\2\2 \36\3\2\2\2 \37\3\2\2\2!\5\3\2\2\2\"#\7\4"+
"\2\2#$\7\6\2\2$(\7\13\2\2%\'\5\b\5\2&%\3\2\2\2\'*\3\2\2\2(&\3\2\2\2()"+
"\3\2\2\2)+\3\2\2\2*(\3\2\2\2+,\7\16\2\2,\7\3\2\2\2-.\7\6\2\2./\7\t\2\2"+
"/\60\7\7\2\2\60\61\7\20\2\2\61\t\3\2\2\2\62\63\7\5\2\2\63\64\7\6\2\2\64"+
"8\7\13\2\2\65\67\5\f\7\2\66\65\3\2\2\2\67:\3\2\2\28\66\3\2\2\289\3\2\2"+
"\29;\3\2\2\2:8\3\2\2\2;<\7\16\2\2<\13\3\2\2\2=>\5\24\13\2>?\7\6\2\2?H"+
"\7\n\2\2@E\5\16\b\2AB\7\b\2\2BD\5\16\b\2CA\3\2\2\2DG\3\2\2\2EC\3\2\2\2"+
"EF\3\2\2\2FI\3\2\2\2GE\3\2\2\2H@\3\2\2\2HI\3\2\2\2IJ\3\2\2\2JK\7\r\2\2"+
"KL\7\20\2\2L\r\3\2\2\2MN\5\24\13\2NO\7\6\2\2O\17\3\2\2\2PQ\7\3\2\2QR\7"+
"\6\2\2RV\7\13\2\2SU\5\22\n\2TS\3\2\2\2UX\3\2\2\2VT\3\2\2\2VW\3\2\2\2W"+
"Y\3\2\2\2XV\3\2\2\2YZ\7\16\2\2Z\21\3\2\2\2[\\\5\24\13\2\\]\7\6\2\2]^\7"+
"\t\2\2^_\7\7\2\2_`\7\20\2\2`\23\3\2\2\2am\7\6\2\2bc\7\f\2\2ch\5\24\13"+
"\2de\7\b\2\2eg\5\24\13\2fd\3\2\2\2gj\3\2\2\2hf\3\2\2\2hi\3\2\2\2ik\3\2"+
"\2\2jh\3\2\2\2kl\7\17\2\2ln\3\2\2\2mb\3\2\2\2mn\3\2\2\2n\25\3\2\2\2\13"+
"\31 (8EHVhm";
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