io.protostuff.compiler.parser.ProtoParser Maven / Gradle / Ivy
// Generated from io/protostuff/compiler/parser/ProtoParser.g4 by ANTLR 4.5
package io.protostuff.compiler.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 ProtoParser extends Parser {
static { RuntimeMetaData.checkVersion("4.5", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
PACKAGE=1, SYNTAX=2, IMPORT=3, PUBLIC=4, OPTION=5, MESSAGE=6, GROUP=7,
OPTIONAL=8, REQUIRED=9, REPEATED=10, ONEOF=11, EXTEND=12, EXTENSIONS=13,
TO=14, MAX=15, RESERVED=16, ENUM=17, SERVICE=18, RPC=19, RETURNS=20, STREAM=21,
MAP=22, BOOLEAN_VALUE=23, DOUBLE=24, FLOAT=25, INT32=26, INT64=27, UINT32=28,
UINT64=29, SINT32=30, SINT64=31, FIXED32=32, FIXED64=33, SFIXED32=34,
SFIXED64=35, BOOL=36, STRING=37, BYTES=38, COMMENT=39, LINE_COMMENT=40,
NL=41, WS=42, LCURLY=43, RCURLY=44, LPAREN=45, RPAREN=46, LSQUARE=47,
RSQUARE=48, LT=49, GT=50, COMMA=51, DOT=52, COLON=53, SEMICOLON=54, ASSIGN=55,
IDENT=56, STRING_VALUE=57, INTEGER_VALUE=58, FLOAT_VALUE=59, ERRCHAR=60;
public static final int
RULE_proto = 0, RULE_syntax = 1, RULE_packageStatement = 2, RULE_packageName = 3,
RULE_importStatement = 4, RULE_fileReference = 5, RULE_optionEntry = 6,
RULE_enumBlock = 7, RULE_enumName = 8, RULE_enumField = 9, RULE_enumFieldName = 10,
RULE_enumFieldValue = 11, RULE_extendBlock = 12, RULE_extendBlockEntry = 13,
RULE_serviceBlock = 14, RULE_serviceName = 15, RULE_rpcMethod = 16, RULE_rpcName = 17,
RULE_rpcType = 18, RULE_messageBlock = 19, RULE_messageName = 20, RULE_oneof = 21,
RULE_oneofName = 22, RULE_oneofField = 23, RULE_oneofGroup = 24, RULE_map = 25,
RULE_mapKey = 26, RULE_mapValue = 27, RULE_tag = 28, RULE_groupBlock = 29,
RULE_groupName = 30, RULE_extensions = 31, RULE_range = 32, RULE_rangeFrom = 33,
RULE_rangeTo = 34, RULE_reservedFieldRanges = 35, RULE_reservedFieldNames = 36,
RULE_reservedFieldName = 37, RULE_field = 38, RULE_fieldName = 39, RULE_fieldModifier = 40,
RULE_typeReference = 41, RULE_fieldOptions = 42, RULE_option = 43, RULE_optionName = 44,
RULE_optionValue = 45, RULE_textFormat = 46, RULE_textFormatOptionName = 47,
RULE_textFormatEntry = 48, RULE_textFormatOptionValue = 49, RULE_fullIdent = 50,
RULE_ident = 51;
public static final String[] ruleNames = {
"proto", "syntax", "packageStatement", "packageName", "importStatement",
"fileReference", "optionEntry", "enumBlock", "enumName", "enumField",
"enumFieldName", "enumFieldValue", "extendBlock", "extendBlockEntry",
"serviceBlock", "serviceName", "rpcMethod", "rpcName", "rpcType", "messageBlock",
"messageName", "oneof", "oneofName", "oneofField", "oneofGroup", "map",
"mapKey", "mapValue", "tag", "groupBlock", "groupName", "extensions",
"range", "rangeFrom", "rangeTo", "reservedFieldRanges", "reservedFieldNames",
"reservedFieldName", "field", "fieldName", "fieldModifier", "typeReference",
"fieldOptions", "option", "optionName", "optionValue", "textFormat", "textFormatOptionName",
"textFormatEntry", "textFormatOptionValue", "fullIdent", "ident"
};
private static final String[] _LITERAL_NAMES = {
null, "'package'", "'syntax'", "'import'", "'public'", "'option'", "'message'",
"'group'", "'optional'", "'required'", "'repeated'", "'oneof'", "'extend'",
"'extensions'", "'to'", "'max'", "'reserved'", "'enum'", "'service'",
"'rpc'", "'returns'", "'stream'", "'map'", null, "'double'", "'float'",
"'int32'", "'int64'", "'uint32'", "'uint64'", "'sint32'", "'sint64'",
"'fixed32'", "'fixed64'", "'sfixed32'", "'sfixed64'", "'bool'", "'string'",
"'bytes'", null, null, null, null, "'{'", "'}'", "'('", "')'", "'['",
"']'", "'<'", "'>'", "','", "'.'", "':'", "';'", "'='"
};
private static final String[] _SYMBOLIC_NAMES = {
null, "PACKAGE", "SYNTAX", "IMPORT", "PUBLIC", "OPTION", "MESSAGE", "GROUP",
"OPTIONAL", "REQUIRED", "REPEATED", "ONEOF", "EXTEND", "EXTENSIONS", "TO",
"MAX", "RESERVED", "ENUM", "SERVICE", "RPC", "RETURNS", "STREAM", "MAP",
"BOOLEAN_VALUE", "DOUBLE", "FLOAT", "INT32", "INT64", "UINT32", "UINT64",
"SINT32", "SINT64", "FIXED32", "FIXED64", "SFIXED32", "SFIXED64", "BOOL",
"STRING", "BYTES", "COMMENT", "LINE_COMMENT", "NL", "WS", "LCURLY", "RCURLY",
"LPAREN", "RPAREN", "LSQUARE", "RSQUARE", "LT", "GT", "COMMA", "DOT",
"COLON", "SEMICOLON", "ASSIGN", "IDENT", "STRING_VALUE", "INTEGER_VALUE",
"FLOAT_VALUE", "ERRCHAR"
};
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 "ProtoParser.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public ProtoParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class ProtoContext extends ParserRuleContext {
public TerminalNode EOF() { return getToken(ProtoParser.EOF, 0); }
public SyntaxContext syntax() {
return getRuleContext(SyntaxContext.class,0);
}
public List packageStatement() {
return getRuleContexts(PackageStatementContext.class);
}
public PackageStatementContext packageStatement(int i) {
return getRuleContext(PackageStatementContext.class,i);
}
public List importStatement() {
return getRuleContexts(ImportStatementContext.class);
}
public ImportStatementContext importStatement(int i) {
return getRuleContext(ImportStatementContext.class,i);
}
public List optionEntry() {
return getRuleContexts(OptionEntryContext.class);
}
public OptionEntryContext optionEntry(int i) {
return getRuleContext(OptionEntryContext.class,i);
}
public List enumBlock() {
return getRuleContexts(EnumBlockContext.class);
}
public EnumBlockContext enumBlock(int i) {
return getRuleContext(EnumBlockContext.class,i);
}
public List messageBlock() {
return getRuleContexts(MessageBlockContext.class);
}
public MessageBlockContext messageBlock(int i) {
return getRuleContext(MessageBlockContext.class,i);
}
public List extendBlock() {
return getRuleContexts(ExtendBlockContext.class);
}
public ExtendBlockContext extendBlock(int i) {
return getRuleContext(ExtendBlockContext.class,i);
}
public List serviceBlock() {
return getRuleContexts(ServiceBlockContext.class);
}
public ServiceBlockContext serviceBlock(int i) {
return getRuleContext(ServiceBlockContext.class,i);
}
public ProtoContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_proto; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterProto(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitProto(this);
}
}
public final ProtoContext proto() throws RecognitionException {
ProtoContext _localctx = new ProtoContext(_ctx, getState());
enterRule(_localctx, 0, RULE_proto);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(105);
_la = _input.LA(1);
if (_la==SYNTAX) {
{
setState(104);
syntax();
}
}
setState(116);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PACKAGE) | (1L << IMPORT) | (1L << OPTION) | (1L << MESSAGE) | (1L << EXTEND) | (1L << ENUM) | (1L << SERVICE))) != 0)) {
{
setState(114);
switch (_input.LA(1)) {
case PACKAGE:
{
setState(107);
packageStatement();
}
break;
case IMPORT:
{
setState(108);
importStatement();
}
break;
case OPTION:
{
setState(109);
optionEntry();
}
break;
case ENUM:
{
setState(110);
enumBlock();
}
break;
case MESSAGE:
{
setState(111);
messageBlock();
}
break;
case EXTEND:
{
setState(112);
extendBlock();
}
break;
case SERVICE:
{
setState(113);
serviceBlock();
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(118);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(119);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SyntaxContext extends ParserRuleContext {
public TerminalNode SYNTAX() { return getToken(ProtoParser.SYNTAX, 0); }
public TerminalNode ASSIGN() { return getToken(ProtoParser.ASSIGN, 0); }
public TerminalNode STRING_VALUE() { return getToken(ProtoParser.STRING_VALUE, 0); }
public TerminalNode SEMICOLON() { return getToken(ProtoParser.SEMICOLON, 0); }
public SyntaxContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_syntax; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterSyntax(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitSyntax(this);
}
}
public final SyntaxContext syntax() throws RecognitionException {
SyntaxContext _localctx = new SyntaxContext(_ctx, getState());
enterRule(_localctx, 2, RULE_syntax);
try {
enterOuterAlt(_localctx, 1);
{
setState(121);
match(SYNTAX);
setState(122);
match(ASSIGN);
setState(123);
match(STRING_VALUE);
setState(124);
match(SEMICOLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PackageStatementContext extends ParserRuleContext {
public TerminalNode PACKAGE() { return getToken(ProtoParser.PACKAGE, 0); }
public PackageNameContext packageName() {
return getRuleContext(PackageNameContext.class,0);
}
public TerminalNode SEMICOLON() { return getToken(ProtoParser.SEMICOLON, 0); }
public PackageStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_packageStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterPackageStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitPackageStatement(this);
}
}
public final PackageStatementContext packageStatement() throws RecognitionException {
PackageStatementContext _localctx = new PackageStatementContext(_ctx, getState());
enterRule(_localctx, 4, RULE_packageStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(126);
match(PACKAGE);
setState(127);
packageName();
setState(128);
match(SEMICOLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PackageNameContext extends ParserRuleContext {
public FullIdentContext fullIdent() {
return getRuleContext(FullIdentContext.class,0);
}
public PackageNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_packageName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterPackageName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitPackageName(this);
}
}
public final PackageNameContext packageName() throws RecognitionException {
PackageNameContext _localctx = new PackageNameContext(_ctx, getState());
enterRule(_localctx, 6, RULE_packageName);
try {
enterOuterAlt(_localctx, 1);
{
setState(130);
fullIdent();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ImportStatementContext extends ParserRuleContext {
public TerminalNode IMPORT() { return getToken(ProtoParser.IMPORT, 0); }
public FileReferenceContext fileReference() {
return getRuleContext(FileReferenceContext.class,0);
}
public TerminalNode SEMICOLON() { return getToken(ProtoParser.SEMICOLON, 0); }
public TerminalNode PUBLIC() { return getToken(ProtoParser.PUBLIC, 0); }
public ImportStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_importStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterImportStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitImportStatement(this);
}
}
public final ImportStatementContext importStatement() throws RecognitionException {
ImportStatementContext _localctx = new ImportStatementContext(_ctx, getState());
enterRule(_localctx, 8, RULE_importStatement);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(132);
match(IMPORT);
setState(134);
_la = _input.LA(1);
if (_la==PUBLIC) {
{
setState(133);
match(PUBLIC);
}
}
setState(136);
fileReference();
setState(137);
match(SEMICOLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FileReferenceContext extends ParserRuleContext {
public TerminalNode STRING_VALUE() { return getToken(ProtoParser.STRING_VALUE, 0); }
public FileReferenceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fileReference; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterFileReference(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitFileReference(this);
}
}
public final FileReferenceContext fileReference() throws RecognitionException {
FileReferenceContext _localctx = new FileReferenceContext(_ctx, getState());
enterRule(_localctx, 10, RULE_fileReference);
try {
enterOuterAlt(_localctx, 1);
{
setState(139);
match(STRING_VALUE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OptionEntryContext extends ParserRuleContext {
public TerminalNode OPTION() { return getToken(ProtoParser.OPTION, 0); }
public OptionContext option() {
return getRuleContext(OptionContext.class,0);
}
public TerminalNode SEMICOLON() { return getToken(ProtoParser.SEMICOLON, 0); }
public OptionEntryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_optionEntry; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterOptionEntry(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitOptionEntry(this);
}
}
public final OptionEntryContext optionEntry() throws RecognitionException {
OptionEntryContext _localctx = new OptionEntryContext(_ctx, getState());
enterRule(_localctx, 12, RULE_optionEntry);
try {
enterOuterAlt(_localctx, 1);
{
setState(141);
match(OPTION);
setState(142);
option();
setState(143);
match(SEMICOLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnumBlockContext extends ParserRuleContext {
public TerminalNode ENUM() { return getToken(ProtoParser.ENUM, 0); }
public EnumNameContext enumName() {
return getRuleContext(EnumNameContext.class,0);
}
public TerminalNode LCURLY() { return getToken(ProtoParser.LCURLY, 0); }
public TerminalNode RCURLY() { return getToken(ProtoParser.RCURLY, 0); }
public List enumField() {
return getRuleContexts(EnumFieldContext.class);
}
public EnumFieldContext enumField(int i) {
return getRuleContext(EnumFieldContext.class,i);
}
public List optionEntry() {
return getRuleContexts(OptionEntryContext.class);
}
public OptionEntryContext optionEntry(int i) {
return getRuleContext(OptionEntryContext.class,i);
}
public TerminalNode SEMICOLON() { return getToken(ProtoParser.SEMICOLON, 0); }
public EnumBlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumBlock; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterEnumBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitEnumBlock(this);
}
}
public final EnumBlockContext enumBlock() throws RecognitionException {
EnumBlockContext _localctx = new EnumBlockContext(_ctx, getState());
enterRule(_localctx, 14, RULE_enumBlock);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(145);
match(ENUM);
setState(146);
enumName();
setState(147);
match(LCURLY);
setState(152);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PACKAGE) | (1L << SYNTAX) | (1L << IMPORT) | (1L << PUBLIC) | (1L << OPTION) | (1L << MESSAGE) | (1L << GROUP) | (1L << OPTIONAL) | (1L << REQUIRED) | (1L << REPEATED) | (1L << ONEOF) | (1L << EXTEND) | (1L << EXTENSIONS) | (1L << TO) | (1L << MAX) | (1L << RESERVED) | (1L << ENUM) | (1L << SERVICE) | (1L << RPC) | (1L << RETURNS) | (1L << STREAM) | (1L << MAP) | (1L << BOOLEAN_VALUE) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT32) | (1L << INT64) | (1L << UINT32) | (1L << UINT64) | (1L << SINT32) | (1L << SINT64) | (1L << FIXED32) | (1L << FIXED64) | (1L << SFIXED32) | (1L << SFIXED64) | (1L << BOOL) | (1L << STRING) | (1L << BYTES) | (1L << IDENT))) != 0)) {
{
setState(150);
switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
case 1:
{
setState(148);
enumField();
}
break;
case 2:
{
setState(149);
optionEntry();
}
break;
}
}
setState(154);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(155);
match(RCURLY);
setState(157);
_la = _input.LA(1);
if (_la==SEMICOLON) {
{
setState(156);
match(SEMICOLON);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnumNameContext extends ParserRuleContext {
public IdentContext ident() {
return getRuleContext(IdentContext.class,0);
}
public EnumNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterEnumName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitEnumName(this);
}
}
public final EnumNameContext enumName() throws RecognitionException {
EnumNameContext _localctx = new EnumNameContext(_ctx, getState());
enterRule(_localctx, 16, RULE_enumName);
try {
enterOuterAlt(_localctx, 1);
{
setState(159);
ident();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnumFieldContext extends ParserRuleContext {
public EnumFieldNameContext enumFieldName() {
return getRuleContext(EnumFieldNameContext.class,0);
}
public TerminalNode ASSIGN() { return getToken(ProtoParser.ASSIGN, 0); }
public EnumFieldValueContext enumFieldValue() {
return getRuleContext(EnumFieldValueContext.class,0);
}
public TerminalNode SEMICOLON() { return getToken(ProtoParser.SEMICOLON, 0); }
public FieldOptionsContext fieldOptions() {
return getRuleContext(FieldOptionsContext.class,0);
}
public EnumFieldContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumField; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterEnumField(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitEnumField(this);
}
}
public final EnumFieldContext enumField() throws RecognitionException {
EnumFieldContext _localctx = new EnumFieldContext(_ctx, getState());
enterRule(_localctx, 18, RULE_enumField);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(161);
enumFieldName();
setState(162);
match(ASSIGN);
setState(163);
enumFieldValue();
setState(165);
_la = _input.LA(1);
if (_la==LSQUARE) {
{
setState(164);
fieldOptions();
}
}
setState(167);
match(SEMICOLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnumFieldNameContext extends ParserRuleContext {
public IdentContext ident() {
return getRuleContext(IdentContext.class,0);
}
public EnumFieldNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumFieldName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterEnumFieldName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitEnumFieldName(this);
}
}
public final EnumFieldNameContext enumFieldName() throws RecognitionException {
EnumFieldNameContext _localctx = new EnumFieldNameContext(_ctx, getState());
enterRule(_localctx, 20, RULE_enumFieldName);
try {
enterOuterAlt(_localctx, 1);
{
setState(169);
ident();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnumFieldValueContext extends ParserRuleContext {
public TerminalNode INTEGER_VALUE() { return getToken(ProtoParser.INTEGER_VALUE, 0); }
public EnumFieldValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumFieldValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterEnumFieldValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitEnumFieldValue(this);
}
}
public final EnumFieldValueContext enumFieldValue() throws RecognitionException {
EnumFieldValueContext _localctx = new EnumFieldValueContext(_ctx, getState());
enterRule(_localctx, 22, RULE_enumFieldValue);
try {
enterOuterAlt(_localctx, 1);
{
setState(171);
match(INTEGER_VALUE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExtendBlockContext extends ParserRuleContext {
public TerminalNode EXTEND() { return getToken(ProtoParser.EXTEND, 0); }
public TypeReferenceContext typeReference() {
return getRuleContext(TypeReferenceContext.class,0);
}
public TerminalNode LCURLY() { return getToken(ProtoParser.LCURLY, 0); }
public TerminalNode RCURLY() { return getToken(ProtoParser.RCURLY, 0); }
public List extendBlockEntry() {
return getRuleContexts(ExtendBlockEntryContext.class);
}
public ExtendBlockEntryContext extendBlockEntry(int i) {
return getRuleContext(ExtendBlockEntryContext.class,i);
}
public TerminalNode SEMICOLON() { return getToken(ProtoParser.SEMICOLON, 0); }
public ExtendBlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_extendBlock; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterExtendBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitExtendBlock(this);
}
}
public final ExtendBlockContext extendBlock() throws RecognitionException {
ExtendBlockContext _localctx = new ExtendBlockContext(_ctx, getState());
enterRule(_localctx, 24, RULE_extendBlock);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(173);
match(EXTEND);
setState(174);
typeReference();
setState(175);
match(LCURLY);
setState(179);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PACKAGE) | (1L << SYNTAX) | (1L << IMPORT) | (1L << PUBLIC) | (1L << OPTION) | (1L << MESSAGE) | (1L << GROUP) | (1L << OPTIONAL) | (1L << REQUIRED) | (1L << REPEATED) | (1L << ONEOF) | (1L << EXTEND) | (1L << EXTENSIONS) | (1L << TO) | (1L << MAX) | (1L << RESERVED) | (1L << ENUM) | (1L << SERVICE) | (1L << RPC) | (1L << RETURNS) | (1L << STREAM) | (1L << MAP) | (1L << BOOLEAN_VALUE) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT32) | (1L << INT64) | (1L << UINT32) | (1L << UINT64) | (1L << SINT32) | (1L << SINT64) | (1L << FIXED32) | (1L << FIXED64) | (1L << SFIXED32) | (1L << SFIXED64) | (1L << BOOL) | (1L << STRING) | (1L << BYTES) | (1L << DOT) | (1L << IDENT))) != 0)) {
{
{
setState(176);
extendBlockEntry();
}
}
setState(181);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(182);
match(RCURLY);
setState(184);
_la = _input.LA(1);
if (_la==SEMICOLON) {
{
setState(183);
match(SEMICOLON);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExtendBlockEntryContext extends ParserRuleContext {
public FieldContext field() {
return getRuleContext(FieldContext.class,0);
}
public GroupBlockContext groupBlock() {
return getRuleContext(GroupBlockContext.class,0);
}
public ExtendBlockEntryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_extendBlockEntry; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterExtendBlockEntry(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitExtendBlockEntry(this);
}
}
public final ExtendBlockEntryContext extendBlockEntry() throws RecognitionException {
ExtendBlockEntryContext _localctx = new ExtendBlockEntryContext(_ctx, getState());
enterRule(_localctx, 26, RULE_extendBlockEntry);
try {
setState(188);
switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(186);
field();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(187);
groupBlock();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ServiceBlockContext extends ParserRuleContext {
public TerminalNode SERVICE() { return getToken(ProtoParser.SERVICE, 0); }
public ServiceNameContext serviceName() {
return getRuleContext(ServiceNameContext.class,0);
}
public TerminalNode LCURLY() { return getToken(ProtoParser.LCURLY, 0); }
public TerminalNode RCURLY() { return getToken(ProtoParser.RCURLY, 0); }
public List rpcMethod() {
return getRuleContexts(RpcMethodContext.class);
}
public RpcMethodContext rpcMethod(int i) {
return getRuleContext(RpcMethodContext.class,i);
}
public List optionEntry() {
return getRuleContexts(OptionEntryContext.class);
}
public OptionEntryContext optionEntry(int i) {
return getRuleContext(OptionEntryContext.class,i);
}
public TerminalNode SEMICOLON() { return getToken(ProtoParser.SEMICOLON, 0); }
public ServiceBlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_serviceBlock; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterServiceBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitServiceBlock(this);
}
}
public final ServiceBlockContext serviceBlock() throws RecognitionException {
ServiceBlockContext _localctx = new ServiceBlockContext(_ctx, getState());
enterRule(_localctx, 28, RULE_serviceBlock);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(190);
match(SERVICE);
setState(191);
serviceName();
setState(192);
match(LCURLY);
setState(197);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==OPTION || _la==RPC) {
{
setState(195);
switch (_input.LA(1)) {
case RPC:
{
setState(193);
rpcMethod();
}
break;
case OPTION:
{
setState(194);
optionEntry();
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(199);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(200);
match(RCURLY);
setState(202);
_la = _input.LA(1);
if (_la==SEMICOLON) {
{
setState(201);
match(SEMICOLON);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ServiceNameContext extends ParserRuleContext {
public IdentContext ident() {
return getRuleContext(IdentContext.class,0);
}
public ServiceNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_serviceName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterServiceName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitServiceName(this);
}
}
public final ServiceNameContext serviceName() throws RecognitionException {
ServiceNameContext _localctx = new ServiceNameContext(_ctx, getState());
enterRule(_localctx, 30, RULE_serviceName);
try {
enterOuterAlt(_localctx, 1);
{
setState(204);
ident();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RpcMethodContext extends ParserRuleContext {
public TerminalNode RPC() { return getToken(ProtoParser.RPC, 0); }
public RpcNameContext rpcName() {
return getRuleContext(RpcNameContext.class,0);
}
public List LPAREN() { return getTokens(ProtoParser.LPAREN); }
public TerminalNode LPAREN(int i) {
return getToken(ProtoParser.LPAREN, i);
}
public List rpcType() {
return getRuleContexts(RpcTypeContext.class);
}
public RpcTypeContext rpcType(int i) {
return getRuleContext(RpcTypeContext.class,i);
}
public List RPAREN() { return getTokens(ProtoParser.RPAREN); }
public TerminalNode RPAREN(int i) {
return getToken(ProtoParser.RPAREN, i);
}
public TerminalNode RETURNS() { return getToken(ProtoParser.RETURNS, 0); }
public TerminalNode LCURLY() { return getToken(ProtoParser.LCURLY, 0); }
public TerminalNode RCURLY() { return getToken(ProtoParser.RCURLY, 0); }
public TerminalNode SEMICOLON() { return getToken(ProtoParser.SEMICOLON, 0); }
public List optionEntry() {
return getRuleContexts(OptionEntryContext.class);
}
public OptionEntryContext optionEntry(int i) {
return getRuleContext(OptionEntryContext.class,i);
}
public RpcMethodContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_rpcMethod; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterRpcMethod(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitRpcMethod(this);
}
}
public final RpcMethodContext rpcMethod() throws RecognitionException {
RpcMethodContext _localctx = new RpcMethodContext(_ctx, getState());
enterRule(_localctx, 32, RULE_rpcMethod);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(206);
match(RPC);
setState(207);
rpcName();
setState(208);
match(LPAREN);
setState(209);
rpcType();
setState(210);
match(RPAREN);
setState(211);
match(RETURNS);
setState(212);
match(LPAREN);
setState(213);
rpcType();
setState(214);
match(RPAREN);
setState(223);
_la = _input.LA(1);
if (_la==LCURLY) {
{
setState(215);
match(LCURLY);
setState(219);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==OPTION) {
{
{
setState(216);
optionEntry();
}
}
setState(221);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(222);
match(RCURLY);
}
}
setState(226);
_la = _input.LA(1);
if (_la==SEMICOLON) {
{
setState(225);
match(SEMICOLON);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RpcNameContext extends ParserRuleContext {
public IdentContext ident() {
return getRuleContext(IdentContext.class,0);
}
public RpcNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_rpcName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterRpcName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitRpcName(this);
}
}
public final RpcNameContext rpcName() throws RecognitionException {
RpcNameContext _localctx = new RpcNameContext(_ctx, getState());
enterRule(_localctx, 34, RULE_rpcName);
try {
enterOuterAlt(_localctx, 1);
{
setState(228);
ident();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RpcTypeContext extends ParserRuleContext {
public TypeReferenceContext typeReference() {
return getRuleContext(TypeReferenceContext.class,0);
}
public TerminalNode STREAM() { return getToken(ProtoParser.STREAM, 0); }
public RpcTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_rpcType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterRpcType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitRpcType(this);
}
}
public final RpcTypeContext rpcType() throws RecognitionException {
RpcTypeContext _localctx = new RpcTypeContext(_ctx, getState());
enterRule(_localctx, 36, RULE_rpcType);
try {
enterOuterAlt(_localctx, 1);
{
setState(231);
switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
case 1:
{
setState(230);
match(STREAM);
}
break;
}
setState(233);
typeReference();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MessageBlockContext extends ParserRuleContext {
public TerminalNode MESSAGE() { return getToken(ProtoParser.MESSAGE, 0); }
public MessageNameContext messageName() {
return getRuleContext(MessageNameContext.class,0);
}
public TerminalNode LCURLY() { return getToken(ProtoParser.LCURLY, 0); }
public TerminalNode RCURLY() { return getToken(ProtoParser.RCURLY, 0); }
public List field() {
return getRuleContexts(FieldContext.class);
}
public FieldContext field(int i) {
return getRuleContext(FieldContext.class,i);
}
public List optionEntry() {
return getRuleContexts(OptionEntryContext.class);
}
public OptionEntryContext optionEntry(int i) {
return getRuleContext(OptionEntryContext.class,i);
}
public List messageBlock() {
return getRuleContexts(MessageBlockContext.class);
}
public MessageBlockContext messageBlock(int i) {
return getRuleContext(MessageBlockContext.class,i);
}
public List enumBlock() {
return getRuleContexts(EnumBlockContext.class);
}
public EnumBlockContext enumBlock(int i) {
return getRuleContext(EnumBlockContext.class,i);
}
public List extensions() {
return getRuleContexts(ExtensionsContext.class);
}
public ExtensionsContext extensions(int i) {
return getRuleContext(ExtensionsContext.class,i);
}
public List extendBlock() {
return getRuleContexts(ExtendBlockContext.class);
}
public ExtendBlockContext extendBlock(int i) {
return getRuleContext(ExtendBlockContext.class,i);
}
public List groupBlock() {
return getRuleContexts(GroupBlockContext.class);
}
public GroupBlockContext groupBlock(int i) {
return getRuleContext(GroupBlockContext.class,i);
}
public List oneof() {
return getRuleContexts(OneofContext.class);
}
public OneofContext oneof(int i) {
return getRuleContext(OneofContext.class,i);
}
public List map() {
return getRuleContexts(MapContext.class);
}
public MapContext map(int i) {
return getRuleContext(MapContext.class,i);
}
public List reservedFieldRanges() {
return getRuleContexts(ReservedFieldRangesContext.class);
}
public ReservedFieldRangesContext reservedFieldRanges(int i) {
return getRuleContext(ReservedFieldRangesContext.class,i);
}
public List reservedFieldNames() {
return getRuleContexts(ReservedFieldNamesContext.class);
}
public ReservedFieldNamesContext reservedFieldNames(int i) {
return getRuleContext(ReservedFieldNamesContext.class,i);
}
public TerminalNode SEMICOLON() { return getToken(ProtoParser.SEMICOLON, 0); }
public MessageBlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_messageBlock; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterMessageBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitMessageBlock(this);
}
}
public final MessageBlockContext messageBlock() throws RecognitionException {
MessageBlockContext _localctx = new MessageBlockContext(_ctx, getState());
enterRule(_localctx, 38, RULE_messageBlock);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(235);
match(MESSAGE);
setState(236);
messageName();
setState(237);
match(LCURLY);
setState(251);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PACKAGE) | (1L << SYNTAX) | (1L << IMPORT) | (1L << PUBLIC) | (1L << OPTION) | (1L << MESSAGE) | (1L << GROUP) | (1L << OPTIONAL) | (1L << REQUIRED) | (1L << REPEATED) | (1L << ONEOF) | (1L << EXTEND) | (1L << EXTENSIONS) | (1L << TO) | (1L << MAX) | (1L << RESERVED) | (1L << ENUM) | (1L << SERVICE) | (1L << RPC) | (1L << RETURNS) | (1L << STREAM) | (1L << MAP) | (1L << BOOLEAN_VALUE) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT32) | (1L << INT64) | (1L << UINT32) | (1L << UINT64) | (1L << SINT32) | (1L << SINT64) | (1L << FIXED32) | (1L << FIXED64) | (1L << SFIXED32) | (1L << SFIXED64) | (1L << BOOL) | (1L << STRING) | (1L << BYTES) | (1L << DOT) | (1L << IDENT))) != 0)) {
{
setState(249);
switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
case 1:
{
setState(238);
field();
}
break;
case 2:
{
setState(239);
optionEntry();
}
break;
case 3:
{
setState(240);
messageBlock();
}
break;
case 4:
{
setState(241);
enumBlock();
}
break;
case 5:
{
setState(242);
extensions();
}
break;
case 6:
{
setState(243);
extendBlock();
}
break;
case 7:
{
setState(244);
groupBlock();
}
break;
case 8:
{
setState(245);
oneof();
}
break;
case 9:
{
setState(246);
map();
}
break;
case 10:
{
setState(247);
reservedFieldRanges();
}
break;
case 11:
{
setState(248);
reservedFieldNames();
}
break;
}
}
setState(253);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(254);
match(RCURLY);
setState(256);
_la = _input.LA(1);
if (_la==SEMICOLON) {
{
setState(255);
match(SEMICOLON);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MessageNameContext extends ParserRuleContext {
public IdentContext ident() {
return getRuleContext(IdentContext.class,0);
}
public MessageNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_messageName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterMessageName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitMessageName(this);
}
}
public final MessageNameContext messageName() throws RecognitionException {
MessageNameContext _localctx = new MessageNameContext(_ctx, getState());
enterRule(_localctx, 40, RULE_messageName);
try {
enterOuterAlt(_localctx, 1);
{
setState(258);
ident();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OneofContext extends ParserRuleContext {
public TerminalNode ONEOF() { return getToken(ProtoParser.ONEOF, 0); }
public OneofNameContext oneofName() {
return getRuleContext(OneofNameContext.class,0);
}
public TerminalNode LCURLY() { return getToken(ProtoParser.LCURLY, 0); }
public TerminalNode RCURLY() { return getToken(ProtoParser.RCURLY, 0); }
public List oneofField() {
return getRuleContexts(OneofFieldContext.class);
}
public OneofFieldContext oneofField(int i) {
return getRuleContext(OneofFieldContext.class,i);
}
public List oneofGroup() {
return getRuleContexts(OneofGroupContext.class);
}
public OneofGroupContext oneofGroup(int i) {
return getRuleContext(OneofGroupContext.class,i);
}
public TerminalNode SEMICOLON() { return getToken(ProtoParser.SEMICOLON, 0); }
public OneofContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_oneof; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterOneof(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitOneof(this);
}
}
public final OneofContext oneof() throws RecognitionException {
OneofContext _localctx = new OneofContext(_ctx, getState());
enterRule(_localctx, 42, RULE_oneof);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(260);
match(ONEOF);
setState(261);
oneofName();
setState(262);
match(LCURLY);
setState(267);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PACKAGE) | (1L << SYNTAX) | (1L << IMPORT) | (1L << PUBLIC) | (1L << OPTION) | (1L << MESSAGE) | (1L << GROUP) | (1L << OPTIONAL) | (1L << REQUIRED) | (1L << REPEATED) | (1L << ONEOF) | (1L << EXTEND) | (1L << EXTENSIONS) | (1L << TO) | (1L << MAX) | (1L << RESERVED) | (1L << ENUM) | (1L << SERVICE) | (1L << RPC) | (1L << RETURNS) | (1L << STREAM) | (1L << MAP) | (1L << BOOLEAN_VALUE) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT32) | (1L << INT64) | (1L << UINT32) | (1L << UINT64) | (1L << SINT32) | (1L << SINT64) | (1L << FIXED32) | (1L << FIXED64) | (1L << SFIXED32) | (1L << SFIXED64) | (1L << BOOL) | (1L << STRING) | (1L << BYTES) | (1L << DOT) | (1L << IDENT))) != 0)) {
{
setState(265);
switch ( getInterpreter().adaptivePredict(_input,21,_ctx) ) {
case 1:
{
setState(263);
oneofField();
}
break;
case 2:
{
setState(264);
oneofGroup();
}
break;
}
}
setState(269);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(270);
match(RCURLY);
setState(272);
_la = _input.LA(1);
if (_la==SEMICOLON) {
{
setState(271);
match(SEMICOLON);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OneofNameContext extends ParserRuleContext {
public IdentContext ident() {
return getRuleContext(IdentContext.class,0);
}
public OneofNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_oneofName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterOneofName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitOneofName(this);
}
}
public final OneofNameContext oneofName() throws RecognitionException {
OneofNameContext _localctx = new OneofNameContext(_ctx, getState());
enterRule(_localctx, 44, RULE_oneofName);
try {
enterOuterAlt(_localctx, 1);
{
setState(274);
ident();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OneofFieldContext extends ParserRuleContext {
public TypeReferenceContext typeReference() {
return getRuleContext(TypeReferenceContext.class,0);
}
public FieldNameContext fieldName() {
return getRuleContext(FieldNameContext.class,0);
}
public TerminalNode ASSIGN() { return getToken(ProtoParser.ASSIGN, 0); }
public TagContext tag() {
return getRuleContext(TagContext.class,0);
}
public TerminalNode SEMICOLON() { return getToken(ProtoParser.SEMICOLON, 0); }
public FieldOptionsContext fieldOptions() {
return getRuleContext(FieldOptionsContext.class,0);
}
public OneofFieldContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_oneofField; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterOneofField(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitOneofField(this);
}
}
public final OneofFieldContext oneofField() throws RecognitionException {
OneofFieldContext _localctx = new OneofFieldContext(_ctx, getState());
enterRule(_localctx, 46, RULE_oneofField);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(276);
typeReference();
setState(277);
fieldName();
setState(278);
match(ASSIGN);
setState(279);
tag();
setState(281);
_la = _input.LA(1);
if (_la==LSQUARE) {
{
setState(280);
fieldOptions();
}
}
setState(283);
match(SEMICOLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OneofGroupContext extends ParserRuleContext {
public TerminalNode GROUP() { return getToken(ProtoParser.GROUP, 0); }
public FieldNameContext fieldName() {
return getRuleContext(FieldNameContext.class,0);
}
public TerminalNode ASSIGN() { return getToken(ProtoParser.ASSIGN, 0); }
public TagContext tag() {
return getRuleContext(TagContext.class,0);
}
public TerminalNode LCURLY() { return getToken(ProtoParser.LCURLY, 0); }
public TerminalNode RCURLY() { return getToken(ProtoParser.RCURLY, 0); }
public List field() {
return getRuleContexts(FieldContext.class);
}
public FieldContext field(int i) {
return getRuleContext(FieldContext.class,i);
}
public List optionEntry() {
return getRuleContexts(OptionEntryContext.class);
}
public OptionEntryContext optionEntry(int i) {
return getRuleContext(OptionEntryContext.class,i);
}
public List messageBlock() {
return getRuleContexts(MessageBlockContext.class);
}
public MessageBlockContext messageBlock(int i) {
return getRuleContext(MessageBlockContext.class,i);
}
public List enumBlock() {
return getRuleContexts(EnumBlockContext.class);
}
public EnumBlockContext enumBlock(int i) {
return getRuleContext(EnumBlockContext.class,i);
}
public List extensions() {
return getRuleContexts(ExtensionsContext.class);
}
public ExtensionsContext extensions(int i) {
return getRuleContext(ExtensionsContext.class,i);
}
public List extendBlock() {
return getRuleContexts(ExtendBlockContext.class);
}
public ExtendBlockContext extendBlock(int i) {
return getRuleContext(ExtendBlockContext.class,i);
}
public List groupBlock() {
return getRuleContexts(GroupBlockContext.class);
}
public GroupBlockContext groupBlock(int i) {
return getRuleContext(GroupBlockContext.class,i);
}
public TerminalNode SEMICOLON() { return getToken(ProtoParser.SEMICOLON, 0); }
public OneofGroupContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_oneofGroup; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterOneofGroup(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitOneofGroup(this);
}
}
public final OneofGroupContext oneofGroup() throws RecognitionException {
OneofGroupContext _localctx = new OneofGroupContext(_ctx, getState());
enterRule(_localctx, 48, RULE_oneofGroup);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(285);
match(GROUP);
setState(286);
fieldName();
setState(287);
match(ASSIGN);
setState(288);
tag();
setState(289);
match(LCURLY);
setState(299);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PACKAGE) | (1L << SYNTAX) | (1L << IMPORT) | (1L << PUBLIC) | (1L << OPTION) | (1L << MESSAGE) | (1L << GROUP) | (1L << OPTIONAL) | (1L << REQUIRED) | (1L << REPEATED) | (1L << ONEOF) | (1L << EXTEND) | (1L << EXTENSIONS) | (1L << TO) | (1L << MAX) | (1L << RESERVED) | (1L << ENUM) | (1L << SERVICE) | (1L << RPC) | (1L << RETURNS) | (1L << STREAM) | (1L << MAP) | (1L << BOOLEAN_VALUE) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT32) | (1L << INT64) | (1L << UINT32) | (1L << UINT64) | (1L << SINT32) | (1L << SINT64) | (1L << FIXED32) | (1L << FIXED64) | (1L << SFIXED32) | (1L << SFIXED64) | (1L << BOOL) | (1L << STRING) | (1L << BYTES) | (1L << DOT) | (1L << IDENT))) != 0)) {
{
setState(297);
switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
case 1:
{
setState(290);
field();
}
break;
case 2:
{
setState(291);
optionEntry();
}
break;
case 3:
{
setState(292);
messageBlock();
}
break;
case 4:
{
setState(293);
enumBlock();
}
break;
case 5:
{
setState(294);
extensions();
}
break;
case 6:
{
setState(295);
extendBlock();
}
break;
case 7:
{
setState(296);
groupBlock();
}
break;
}
}
setState(301);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(302);
match(RCURLY);
setState(304);
_la = _input.LA(1);
if (_la==SEMICOLON) {
{
setState(303);
match(SEMICOLON);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MapContext extends ParserRuleContext {
public TerminalNode MAP() { return getToken(ProtoParser.MAP, 0); }
public TerminalNode LT() { return getToken(ProtoParser.LT, 0); }
public MapKeyContext mapKey() {
return getRuleContext(MapKeyContext.class,0);
}
public TerminalNode COMMA() { return getToken(ProtoParser.COMMA, 0); }
public MapValueContext mapValue() {
return getRuleContext(MapValueContext.class,0);
}
public TerminalNode GT() { return getToken(ProtoParser.GT, 0); }
public FieldNameContext fieldName() {
return getRuleContext(FieldNameContext.class,0);
}
public TerminalNode ASSIGN() { return getToken(ProtoParser.ASSIGN, 0); }
public TagContext tag() {
return getRuleContext(TagContext.class,0);
}
public TerminalNode SEMICOLON() { return getToken(ProtoParser.SEMICOLON, 0); }
public FieldOptionsContext fieldOptions() {
return getRuleContext(FieldOptionsContext.class,0);
}
public MapContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_map; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterMap(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitMap(this);
}
}
public final MapContext map() throws RecognitionException {
MapContext _localctx = new MapContext(_ctx, getState());
enterRule(_localctx, 50, RULE_map);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(306);
match(MAP);
setState(307);
match(LT);
setState(308);
mapKey();
setState(309);
match(COMMA);
setState(310);
mapValue();
setState(311);
match(GT);
setState(312);
fieldName();
setState(313);
match(ASSIGN);
setState(314);
tag();
setState(316);
_la = _input.LA(1);
if (_la==LSQUARE) {
{
setState(315);
fieldOptions();
}
}
setState(318);
match(SEMICOLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MapKeyContext extends ParserRuleContext {
public TerminalNode INT32() { return getToken(ProtoParser.INT32, 0); }
public TerminalNode INT64() { return getToken(ProtoParser.INT64, 0); }
public TerminalNode UINT32() { return getToken(ProtoParser.UINT32, 0); }
public TerminalNode UINT64() { return getToken(ProtoParser.UINT64, 0); }
public TerminalNode SINT32() { return getToken(ProtoParser.SINT32, 0); }
public TerminalNode SINT64() { return getToken(ProtoParser.SINT64, 0); }
public TerminalNode FIXED32() { return getToken(ProtoParser.FIXED32, 0); }
public TerminalNode FIXED64() { return getToken(ProtoParser.FIXED64, 0); }
public TerminalNode SFIXED32() { return getToken(ProtoParser.SFIXED32, 0); }
public TerminalNode SFIXED64() { return getToken(ProtoParser.SFIXED64, 0); }
public TerminalNode BOOL() { return getToken(ProtoParser.BOOL, 0); }
public TerminalNode STRING() { return getToken(ProtoParser.STRING, 0); }
public MapKeyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_mapKey; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterMapKey(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitMapKey(this);
}
}
public final MapKeyContext mapKey() throws RecognitionException {
MapKeyContext _localctx = new MapKeyContext(_ctx, getState());
enterRule(_localctx, 52, RULE_mapKey);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(320);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << INT32) | (1L << INT64) | (1L << UINT32) | (1L << UINT64) | (1L << SINT32) | (1L << SINT64) | (1L << FIXED32) | (1L << FIXED64) | (1L << SFIXED32) | (1L << SFIXED64) | (1L << BOOL) | (1L << STRING))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MapValueContext extends ParserRuleContext {
public TypeReferenceContext typeReference() {
return getRuleContext(TypeReferenceContext.class,0);
}
public MapValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_mapValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterMapValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitMapValue(this);
}
}
public final MapValueContext mapValue() throws RecognitionException {
MapValueContext _localctx = new MapValueContext(_ctx, getState());
enterRule(_localctx, 54, RULE_mapValue);
try {
enterOuterAlt(_localctx, 1);
{
setState(322);
typeReference();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TagContext extends ParserRuleContext {
public TerminalNode INTEGER_VALUE() { return getToken(ProtoParser.INTEGER_VALUE, 0); }
public TagContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tag; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterTag(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitTag(this);
}
}
public final TagContext tag() throws RecognitionException {
TagContext _localctx = new TagContext(_ctx, getState());
enterRule(_localctx, 56, RULE_tag);
try {
enterOuterAlt(_localctx, 1);
{
setState(324);
match(INTEGER_VALUE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GroupBlockContext extends ParserRuleContext {
public FieldModifierContext fieldModifier() {
return getRuleContext(FieldModifierContext.class,0);
}
public TerminalNode GROUP() { return getToken(ProtoParser.GROUP, 0); }
public GroupNameContext groupName() {
return getRuleContext(GroupNameContext.class,0);
}
public TerminalNode ASSIGN() { return getToken(ProtoParser.ASSIGN, 0); }
public TagContext tag() {
return getRuleContext(TagContext.class,0);
}
public TerminalNode LCURLY() { return getToken(ProtoParser.LCURLY, 0); }
public TerminalNode RCURLY() { return getToken(ProtoParser.RCURLY, 0); }
public List field() {
return getRuleContexts(FieldContext.class);
}
public FieldContext field(int i) {
return getRuleContext(FieldContext.class,i);
}
public List optionEntry() {
return getRuleContexts(OptionEntryContext.class);
}
public OptionEntryContext optionEntry(int i) {
return getRuleContext(OptionEntryContext.class,i);
}
public List messageBlock() {
return getRuleContexts(MessageBlockContext.class);
}
public MessageBlockContext messageBlock(int i) {
return getRuleContext(MessageBlockContext.class,i);
}
public List enumBlock() {
return getRuleContexts(EnumBlockContext.class);
}
public EnumBlockContext enumBlock(int i) {
return getRuleContext(EnumBlockContext.class,i);
}
public List extensions() {
return getRuleContexts(ExtensionsContext.class);
}
public ExtensionsContext extensions(int i) {
return getRuleContext(ExtensionsContext.class,i);
}
public List extendBlock() {
return getRuleContexts(ExtendBlockContext.class);
}
public ExtendBlockContext extendBlock(int i) {
return getRuleContext(ExtendBlockContext.class,i);
}
public List groupBlock() {
return getRuleContexts(GroupBlockContext.class);
}
public GroupBlockContext groupBlock(int i) {
return getRuleContext(GroupBlockContext.class,i);
}
public TerminalNode SEMICOLON() { return getToken(ProtoParser.SEMICOLON, 0); }
public GroupBlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_groupBlock; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterGroupBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitGroupBlock(this);
}
}
public final GroupBlockContext groupBlock() throws RecognitionException {
GroupBlockContext _localctx = new GroupBlockContext(_ctx, getState());
enterRule(_localctx, 58, RULE_groupBlock);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(326);
fieldModifier();
setState(327);
match(GROUP);
setState(328);
groupName();
setState(329);
match(ASSIGN);
setState(330);
tag();
setState(331);
match(LCURLY);
setState(341);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PACKAGE) | (1L << SYNTAX) | (1L << IMPORT) | (1L << PUBLIC) | (1L << OPTION) | (1L << MESSAGE) | (1L << GROUP) | (1L << OPTIONAL) | (1L << REQUIRED) | (1L << REPEATED) | (1L << ONEOF) | (1L << EXTEND) | (1L << EXTENSIONS) | (1L << TO) | (1L << MAX) | (1L << RESERVED) | (1L << ENUM) | (1L << SERVICE) | (1L << RPC) | (1L << RETURNS) | (1L << STREAM) | (1L << MAP) | (1L << BOOLEAN_VALUE) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT32) | (1L << INT64) | (1L << UINT32) | (1L << UINT64) | (1L << SINT32) | (1L << SINT64) | (1L << FIXED32) | (1L << FIXED64) | (1L << SFIXED32) | (1L << SFIXED64) | (1L << BOOL) | (1L << STRING) | (1L << BYTES) | (1L << DOT) | (1L << IDENT))) != 0)) {
{
setState(339);
switch ( getInterpreter().adaptivePredict(_input,29,_ctx) ) {
case 1:
{
setState(332);
field();
}
break;
case 2:
{
setState(333);
optionEntry();
}
break;
case 3:
{
setState(334);
messageBlock();
}
break;
case 4:
{
setState(335);
enumBlock();
}
break;
case 5:
{
setState(336);
extensions();
}
break;
case 6:
{
setState(337);
extendBlock();
}
break;
case 7:
{
setState(338);
groupBlock();
}
break;
}
}
setState(343);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(344);
match(RCURLY);
setState(346);
_la = _input.LA(1);
if (_la==SEMICOLON) {
{
setState(345);
match(SEMICOLON);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GroupNameContext extends ParserRuleContext {
public IdentContext ident() {
return getRuleContext(IdentContext.class,0);
}
public GroupNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_groupName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterGroupName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitGroupName(this);
}
}
public final GroupNameContext groupName() throws RecognitionException {
GroupNameContext _localctx = new GroupNameContext(_ctx, getState());
enterRule(_localctx, 60, RULE_groupName);
try {
enterOuterAlt(_localctx, 1);
{
setState(348);
ident();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExtensionsContext extends ParserRuleContext {
public TerminalNode EXTENSIONS() { return getToken(ProtoParser.EXTENSIONS, 0); }
public List range() {
return getRuleContexts(RangeContext.class);
}
public RangeContext range(int i) {
return getRuleContext(RangeContext.class,i);
}
public TerminalNode SEMICOLON() { return getToken(ProtoParser.SEMICOLON, 0); }
public List COMMA() { return getTokens(ProtoParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(ProtoParser.COMMA, i);
}
public ExtensionsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_extensions; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterExtensions(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitExtensions(this);
}
}
public final ExtensionsContext extensions() throws RecognitionException {
ExtensionsContext _localctx = new ExtensionsContext(_ctx, getState());
enterRule(_localctx, 62, RULE_extensions);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(350);
match(EXTENSIONS);
setState(351);
range();
setState(356);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(352);
match(COMMA);
setState(353);
range();
}
}
setState(358);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(359);
match(SEMICOLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RangeContext extends ParserRuleContext {
public RangeFromContext rangeFrom() {
return getRuleContext(RangeFromContext.class,0);
}
public TerminalNode TO() { return getToken(ProtoParser.TO, 0); }
public RangeToContext rangeTo() {
return getRuleContext(RangeToContext.class,0);
}
public TerminalNode MAX() { return getToken(ProtoParser.MAX, 0); }
public RangeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_range; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterRange(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitRange(this);
}
}
public final RangeContext range() throws RecognitionException {
RangeContext _localctx = new RangeContext(_ctx, getState());
enterRule(_localctx, 64, RULE_range);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(361);
rangeFrom();
setState(367);
_la = _input.LA(1);
if (_la==TO) {
{
setState(362);
match(TO);
setState(365);
switch (_input.LA(1)) {
case INTEGER_VALUE:
{
setState(363);
rangeTo();
}
break;
case MAX:
{
setState(364);
match(MAX);
}
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 RangeFromContext extends ParserRuleContext {
public TerminalNode INTEGER_VALUE() { return getToken(ProtoParser.INTEGER_VALUE, 0); }
public RangeFromContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_rangeFrom; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterRangeFrom(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitRangeFrom(this);
}
}
public final RangeFromContext rangeFrom() throws RecognitionException {
RangeFromContext _localctx = new RangeFromContext(_ctx, getState());
enterRule(_localctx, 66, RULE_rangeFrom);
try {
enterOuterAlt(_localctx, 1);
{
setState(369);
match(INTEGER_VALUE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RangeToContext extends ParserRuleContext {
public TerminalNode INTEGER_VALUE() { return getToken(ProtoParser.INTEGER_VALUE, 0); }
public RangeToContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_rangeTo; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterRangeTo(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitRangeTo(this);
}
}
public final RangeToContext rangeTo() throws RecognitionException {
RangeToContext _localctx = new RangeToContext(_ctx, getState());
enterRule(_localctx, 68, RULE_rangeTo);
try {
enterOuterAlt(_localctx, 1);
{
setState(371);
match(INTEGER_VALUE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ReservedFieldRangesContext extends ParserRuleContext {
public TerminalNode RESERVED() { return getToken(ProtoParser.RESERVED, 0); }
public List range() {
return getRuleContexts(RangeContext.class);
}
public RangeContext range(int i) {
return getRuleContext(RangeContext.class,i);
}
public TerminalNode SEMICOLON() { return getToken(ProtoParser.SEMICOLON, 0); }
public List COMMA() { return getTokens(ProtoParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(ProtoParser.COMMA, i);
}
public ReservedFieldRangesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_reservedFieldRanges; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterReservedFieldRanges(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitReservedFieldRanges(this);
}
}
public final ReservedFieldRangesContext reservedFieldRanges() throws RecognitionException {
ReservedFieldRangesContext _localctx = new ReservedFieldRangesContext(_ctx, getState());
enterRule(_localctx, 70, RULE_reservedFieldRanges);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(373);
match(RESERVED);
setState(374);
range();
setState(379);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(375);
match(COMMA);
setState(376);
range();
}
}
setState(381);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(382);
match(SEMICOLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ReservedFieldNamesContext extends ParserRuleContext {
public TerminalNode RESERVED() { return getToken(ProtoParser.RESERVED, 0); }
public List reservedFieldName() {
return getRuleContexts(ReservedFieldNameContext.class);
}
public ReservedFieldNameContext reservedFieldName(int i) {
return getRuleContext(ReservedFieldNameContext.class,i);
}
public TerminalNode SEMICOLON() { return getToken(ProtoParser.SEMICOLON, 0); }
public List COMMA() { return getTokens(ProtoParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(ProtoParser.COMMA, i);
}
public ReservedFieldNamesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_reservedFieldNames; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterReservedFieldNames(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitReservedFieldNames(this);
}
}
public final ReservedFieldNamesContext reservedFieldNames() throws RecognitionException {
ReservedFieldNamesContext _localctx = new ReservedFieldNamesContext(_ctx, getState());
enterRule(_localctx, 72, RULE_reservedFieldNames);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(384);
match(RESERVED);
setState(385);
reservedFieldName();
setState(390);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(386);
match(COMMA);
setState(387);
reservedFieldName();
}
}
setState(392);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(393);
match(SEMICOLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ReservedFieldNameContext extends ParserRuleContext {
public TerminalNode STRING_VALUE() { return getToken(ProtoParser.STRING_VALUE, 0); }
public ReservedFieldNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_reservedFieldName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterReservedFieldName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitReservedFieldName(this);
}
}
public final ReservedFieldNameContext reservedFieldName() throws RecognitionException {
ReservedFieldNameContext _localctx = new ReservedFieldNameContext(_ctx, getState());
enterRule(_localctx, 74, RULE_reservedFieldName);
try {
enterOuterAlt(_localctx, 1);
{
setState(395);
match(STRING_VALUE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FieldContext extends ParserRuleContext {
public TypeReferenceContext typeReference() {
return getRuleContext(TypeReferenceContext.class,0);
}
public FieldNameContext fieldName() {
return getRuleContext(FieldNameContext.class,0);
}
public TerminalNode ASSIGN() { return getToken(ProtoParser.ASSIGN, 0); }
public TagContext tag() {
return getRuleContext(TagContext.class,0);
}
public TerminalNode SEMICOLON() { return getToken(ProtoParser.SEMICOLON, 0); }
public FieldModifierContext fieldModifier() {
return getRuleContext(FieldModifierContext.class,0);
}
public FieldOptionsContext fieldOptions() {
return getRuleContext(FieldOptionsContext.class,0);
}
public FieldContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_field; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterField(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitField(this);
}
}
public final FieldContext field() throws RecognitionException {
FieldContext _localctx = new FieldContext(_ctx, getState());
enterRule(_localctx, 76, RULE_field);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(398);
switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) {
case 1:
{
setState(397);
fieldModifier();
}
break;
}
setState(400);
typeReference();
setState(401);
fieldName();
setState(402);
match(ASSIGN);
setState(403);
tag();
setState(405);
_la = _input.LA(1);
if (_la==LSQUARE) {
{
setState(404);
fieldOptions();
}
}
setState(407);
match(SEMICOLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FieldNameContext extends ParserRuleContext {
public IdentContext ident() {
return getRuleContext(IdentContext.class,0);
}
public FieldNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fieldName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterFieldName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitFieldName(this);
}
}
public final FieldNameContext fieldName() throws RecognitionException {
FieldNameContext _localctx = new FieldNameContext(_ctx, getState());
enterRule(_localctx, 78, RULE_fieldName);
try {
enterOuterAlt(_localctx, 1);
{
setState(409);
ident();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FieldModifierContext extends ParserRuleContext {
public TerminalNode OPTIONAL() { return getToken(ProtoParser.OPTIONAL, 0); }
public TerminalNode REQUIRED() { return getToken(ProtoParser.REQUIRED, 0); }
public TerminalNode REPEATED() { return getToken(ProtoParser.REPEATED, 0); }
public FieldModifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fieldModifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterFieldModifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitFieldModifier(this);
}
}
public final FieldModifierContext fieldModifier() throws RecognitionException {
FieldModifierContext _localctx = new FieldModifierContext(_ctx, getState());
enterRule(_localctx, 80, RULE_fieldModifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(411);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << OPTIONAL) | (1L << REQUIRED) | (1L << REPEATED))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeReferenceContext extends ParserRuleContext {
public TerminalNode DOUBLE() { return getToken(ProtoParser.DOUBLE, 0); }
public TerminalNode FLOAT() { return getToken(ProtoParser.FLOAT, 0); }
public TerminalNode INT32() { return getToken(ProtoParser.INT32, 0); }
public TerminalNode INT64() { return getToken(ProtoParser.INT64, 0); }
public TerminalNode UINT32() { return getToken(ProtoParser.UINT32, 0); }
public TerminalNode UINT64() { return getToken(ProtoParser.UINT64, 0); }
public TerminalNode SINT32() { return getToken(ProtoParser.SINT32, 0); }
public TerminalNode SINT64() { return getToken(ProtoParser.SINT64, 0); }
public TerminalNode FIXED32() { return getToken(ProtoParser.FIXED32, 0); }
public TerminalNode FIXED64() { return getToken(ProtoParser.FIXED64, 0); }
public TerminalNode SFIXED32() { return getToken(ProtoParser.SFIXED32, 0); }
public TerminalNode SFIXED64() { return getToken(ProtoParser.SFIXED64, 0); }
public TerminalNode BOOL() { return getToken(ProtoParser.BOOL, 0); }
public TerminalNode STRING() { return getToken(ProtoParser.STRING, 0); }
public TerminalNode BYTES() { return getToken(ProtoParser.BYTES, 0); }
public List ident() {
return getRuleContexts(IdentContext.class);
}
public IdentContext ident(int i) {
return getRuleContext(IdentContext.class,i);
}
public List DOT() { return getTokens(ProtoParser.DOT); }
public TerminalNode DOT(int i) {
return getToken(ProtoParser.DOT, i);
}
public TypeReferenceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeReference; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterTypeReference(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitTypeReference(this);
}
}
public final TypeReferenceContext typeReference() throws RecognitionException {
TypeReferenceContext _localctx = new TypeReferenceContext(_ctx, getState());
enterRule(_localctx, 82, RULE_typeReference);
int _la;
try {
setState(439);
switch ( getInterpreter().adaptivePredict(_input,41,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(413);
match(DOUBLE);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(414);
match(FLOAT);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(415);
match(INT32);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(416);
match(INT64);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(417);
match(UINT32);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(418);
match(UINT64);
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(419);
match(SINT32);
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(420);
match(SINT64);
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(421);
match(FIXED32);
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(422);
match(FIXED64);
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(423);
match(SFIXED32);
}
break;
case 12:
enterOuterAlt(_localctx, 12);
{
setState(424);
match(SFIXED64);
}
break;
case 13:
enterOuterAlt(_localctx, 13);
{
setState(425);
match(BOOL);
}
break;
case 14:
enterOuterAlt(_localctx, 14);
{
setState(426);
match(STRING);
}
break;
case 15:
enterOuterAlt(_localctx, 15);
{
setState(427);
match(BYTES);
}
break;
case 16:
enterOuterAlt(_localctx, 16);
{
setState(429);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(428);
match(DOT);
}
}
setState(431);
ident();
setState(436);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DOT) {
{
{
setState(432);
match(DOT);
setState(433);
ident();
}
}
setState(438);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FieldOptionsContext extends ParserRuleContext {
public TerminalNode LSQUARE() { return getToken(ProtoParser.LSQUARE, 0); }
public TerminalNode RSQUARE() { return getToken(ProtoParser.RSQUARE, 0); }
public List option() {
return getRuleContexts(OptionContext.class);
}
public OptionContext option(int i) {
return getRuleContext(OptionContext.class,i);
}
public List COMMA() { return getTokens(ProtoParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(ProtoParser.COMMA, i);
}
public FieldOptionsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fieldOptions; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterFieldOptions(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitFieldOptions(this);
}
}
public final FieldOptionsContext fieldOptions() throws RecognitionException {
FieldOptionsContext _localctx = new FieldOptionsContext(_ctx, getState());
enterRule(_localctx, 84, RULE_fieldOptions);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(441);
match(LSQUARE);
setState(450);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PACKAGE) | (1L << SYNTAX) | (1L << IMPORT) | (1L << PUBLIC) | (1L << OPTION) | (1L << MESSAGE) | (1L << GROUP) | (1L << OPTIONAL) | (1L << REQUIRED) | (1L << REPEATED) | (1L << ONEOF) | (1L << EXTEND) | (1L << EXTENSIONS) | (1L << TO) | (1L << MAX) | (1L << RESERVED) | (1L << ENUM) | (1L << SERVICE) | (1L << RPC) | (1L << RETURNS) | (1L << STREAM) | (1L << MAP) | (1L << BOOLEAN_VALUE) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT32) | (1L << INT64) | (1L << UINT32) | (1L << UINT64) | (1L << SINT32) | (1L << SINT64) | (1L << FIXED32) | (1L << FIXED64) | (1L << SFIXED32) | (1L << SFIXED64) | (1L << BOOL) | (1L << STRING) | (1L << BYTES) | (1L << LPAREN) | (1L << IDENT))) != 0)) {
{
setState(442);
option();
setState(447);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(443);
match(COMMA);
setState(444);
option();
}
}
setState(449);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(452);
match(RSQUARE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OptionContext extends ParserRuleContext {
public OptionNameContext optionName() {
return getRuleContext(OptionNameContext.class,0);
}
public TerminalNode ASSIGN() { return getToken(ProtoParser.ASSIGN, 0); }
public OptionValueContext optionValue() {
return getRuleContext(OptionValueContext.class,0);
}
public OptionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_option; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterOption(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitOption(this);
}
}
public final OptionContext option() throws RecognitionException {
OptionContext _localctx = new OptionContext(_ctx, getState());
enterRule(_localctx, 86, RULE_option);
try {
enterOuterAlt(_localctx, 1);
{
setState(454);
optionName();
setState(455);
match(ASSIGN);
setState(456);
optionValue();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OptionNameContext extends ParserRuleContext {
public List ident() {
return getRuleContexts(IdentContext.class);
}
public IdentContext ident(int i) {
return getRuleContext(IdentContext.class,i);
}
public List DOT() { return getTokens(ProtoParser.DOT); }
public TerminalNode DOT(int i) {
return getToken(ProtoParser.DOT, i);
}
public TerminalNode LPAREN() { return getToken(ProtoParser.LPAREN, 0); }
public TypeReferenceContext typeReference() {
return getRuleContext(TypeReferenceContext.class,0);
}
public TerminalNode RPAREN() { return getToken(ProtoParser.RPAREN, 0); }
public List optionName() {
return getRuleContexts(OptionNameContext.class);
}
public OptionNameContext optionName(int i) {
return getRuleContext(OptionNameContext.class,i);
}
public OptionNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_optionName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterOptionName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitOptionName(this);
}
}
public final OptionNameContext optionName() throws RecognitionException {
OptionNameContext _localctx = new OptionNameContext(_ctx, getState());
enterRule(_localctx, 88, RULE_optionName);
try {
int _alt;
setState(476);
switch (_input.LA(1)) {
case PACKAGE:
case SYNTAX:
case IMPORT:
case PUBLIC:
case OPTION:
case MESSAGE:
case GROUP:
case OPTIONAL:
case REQUIRED:
case REPEATED:
case ONEOF:
case EXTEND:
case EXTENSIONS:
case TO:
case MAX:
case RESERVED:
case ENUM:
case SERVICE:
case RPC:
case RETURNS:
case STREAM:
case MAP:
case BOOLEAN_VALUE:
case DOUBLE:
case FLOAT:
case INT32:
case INT64:
case UINT32:
case UINT64:
case SINT32:
case SINT64:
case FIXED32:
case FIXED64:
case SFIXED32:
case SFIXED64:
case BOOL:
case STRING:
case BYTES:
case IDENT:
enterOuterAlt(_localctx, 1);
{
setState(458);
ident();
setState(463);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,44,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(459);
match(DOT);
setState(460);
ident();
}
}
}
setState(465);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,44,_ctx);
}
}
break;
case LPAREN:
enterOuterAlt(_localctx, 2);
{
setState(466);
match(LPAREN);
setState(467);
typeReference();
setState(468);
match(RPAREN);
setState(473);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,45,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(469);
match(DOT);
setState(470);
optionName();
}
}
}
setState(475);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,45,_ctx);
}
}
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 OptionValueContext extends ParserRuleContext {
public TerminalNode INTEGER_VALUE() { return getToken(ProtoParser.INTEGER_VALUE, 0); }
public TerminalNode FLOAT_VALUE() { return getToken(ProtoParser.FLOAT_VALUE, 0); }
public TerminalNode BOOLEAN_VALUE() { return getToken(ProtoParser.BOOLEAN_VALUE, 0); }
public TerminalNode STRING_VALUE() { return getToken(ProtoParser.STRING_VALUE, 0); }
public TerminalNode IDENT() { return getToken(ProtoParser.IDENT, 0); }
public TextFormatContext textFormat() {
return getRuleContext(TextFormatContext.class,0);
}
public OptionValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_optionValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterOptionValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitOptionValue(this);
}
}
public final OptionValueContext optionValue() throws RecognitionException {
OptionValueContext _localctx = new OptionValueContext(_ctx, getState());
enterRule(_localctx, 90, RULE_optionValue);
try {
setState(484);
switch (_input.LA(1)) {
case INTEGER_VALUE:
enterOuterAlt(_localctx, 1);
{
setState(478);
match(INTEGER_VALUE);
}
break;
case FLOAT_VALUE:
enterOuterAlt(_localctx, 2);
{
setState(479);
match(FLOAT_VALUE);
}
break;
case BOOLEAN_VALUE:
enterOuterAlt(_localctx, 3);
{
setState(480);
match(BOOLEAN_VALUE);
}
break;
case STRING_VALUE:
enterOuterAlt(_localctx, 4);
{
setState(481);
match(STRING_VALUE);
}
break;
case IDENT:
enterOuterAlt(_localctx, 5);
{
setState(482);
match(IDENT);
}
break;
case LCURLY:
enterOuterAlt(_localctx, 6);
{
setState(483);
textFormat();
}
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 TextFormatContext extends ParserRuleContext {
public TerminalNode LCURLY() { return getToken(ProtoParser.LCURLY, 0); }
public TerminalNode RCURLY() { return getToken(ProtoParser.RCURLY, 0); }
public List textFormatEntry() {
return getRuleContexts(TextFormatEntryContext.class);
}
public TextFormatEntryContext textFormatEntry(int i) {
return getRuleContext(TextFormatEntryContext.class,i);
}
public TextFormatContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_textFormat; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterTextFormat(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitTextFormat(this);
}
}
public final TextFormatContext textFormat() throws RecognitionException {
TextFormatContext _localctx = new TextFormatContext(_ctx, getState());
enterRule(_localctx, 92, RULE_textFormat);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(486);
match(LCURLY);
setState(490);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PACKAGE) | (1L << SYNTAX) | (1L << IMPORT) | (1L << PUBLIC) | (1L << OPTION) | (1L << MESSAGE) | (1L << GROUP) | (1L << OPTIONAL) | (1L << REQUIRED) | (1L << REPEATED) | (1L << ONEOF) | (1L << EXTEND) | (1L << EXTENSIONS) | (1L << TO) | (1L << MAX) | (1L << RESERVED) | (1L << ENUM) | (1L << SERVICE) | (1L << RPC) | (1L << RETURNS) | (1L << STREAM) | (1L << MAP) | (1L << BOOLEAN_VALUE) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT32) | (1L << INT64) | (1L << UINT32) | (1L << UINT64) | (1L << SINT32) | (1L << SINT64) | (1L << FIXED32) | (1L << FIXED64) | (1L << SFIXED32) | (1L << SFIXED64) | (1L << BOOL) | (1L << STRING) | (1L << BYTES) | (1L << LSQUARE) | (1L << IDENT))) != 0)) {
{
{
setState(487);
textFormatEntry();
}
}
setState(492);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(493);
match(RCURLY);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TextFormatOptionNameContext extends ParserRuleContext {
public IdentContext ident() {
return getRuleContext(IdentContext.class,0);
}
public TerminalNode LSQUARE() { return getToken(ProtoParser.LSQUARE, 0); }
public TypeReferenceContext typeReference() {
return getRuleContext(TypeReferenceContext.class,0);
}
public TerminalNode RSQUARE() { return getToken(ProtoParser.RSQUARE, 0); }
public TextFormatOptionNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_textFormatOptionName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterTextFormatOptionName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitTextFormatOptionName(this);
}
}
public final TextFormatOptionNameContext textFormatOptionName() throws RecognitionException {
TextFormatOptionNameContext _localctx = new TextFormatOptionNameContext(_ctx, getState());
enterRule(_localctx, 94, RULE_textFormatOptionName);
try {
setState(500);
switch (_input.LA(1)) {
case PACKAGE:
case SYNTAX:
case IMPORT:
case PUBLIC:
case OPTION:
case MESSAGE:
case GROUP:
case OPTIONAL:
case REQUIRED:
case REPEATED:
case ONEOF:
case EXTEND:
case EXTENSIONS:
case TO:
case MAX:
case RESERVED:
case ENUM:
case SERVICE:
case RPC:
case RETURNS:
case STREAM:
case MAP:
case BOOLEAN_VALUE:
case DOUBLE:
case FLOAT:
case INT32:
case INT64:
case UINT32:
case UINT64:
case SINT32:
case SINT64:
case FIXED32:
case FIXED64:
case SFIXED32:
case SFIXED64:
case BOOL:
case STRING:
case BYTES:
case IDENT:
enterOuterAlt(_localctx, 1);
{
setState(495);
ident();
}
break;
case LSQUARE:
enterOuterAlt(_localctx, 2);
{
setState(496);
match(LSQUARE);
setState(497);
typeReference();
setState(498);
match(RSQUARE);
}
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 TextFormatEntryContext extends ParserRuleContext {
public TextFormatOptionNameContext textFormatOptionName() {
return getRuleContext(TextFormatOptionNameContext.class,0);
}
public TerminalNode COLON() { return getToken(ProtoParser.COLON, 0); }
public TextFormatOptionValueContext textFormatOptionValue() {
return getRuleContext(TextFormatOptionValueContext.class,0);
}
public TextFormatContext textFormat() {
return getRuleContext(TextFormatContext.class,0);
}
public TextFormatEntryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_textFormatEntry; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterTextFormatEntry(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitTextFormatEntry(this);
}
}
public final TextFormatEntryContext textFormatEntry() throws RecognitionException {
TextFormatEntryContext _localctx = new TextFormatEntryContext(_ctx, getState());
enterRule(_localctx, 96, RULE_textFormatEntry);
try {
setState(509);
switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(502);
textFormatOptionName();
setState(503);
match(COLON);
setState(504);
textFormatOptionValue();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(506);
textFormatOptionName();
setState(507);
textFormat();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TextFormatOptionValueContext extends ParserRuleContext {
public TerminalNode INTEGER_VALUE() { return getToken(ProtoParser.INTEGER_VALUE, 0); }
public TerminalNode FLOAT_VALUE() { return getToken(ProtoParser.FLOAT_VALUE, 0); }
public TerminalNode BOOLEAN_VALUE() { return getToken(ProtoParser.BOOLEAN_VALUE, 0); }
public TerminalNode STRING_VALUE() { return getToken(ProtoParser.STRING_VALUE, 0); }
public TerminalNode IDENT() { return getToken(ProtoParser.IDENT, 0); }
public TextFormatOptionValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_textFormatOptionValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterTextFormatOptionValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitTextFormatOptionValue(this);
}
}
public final TextFormatOptionValueContext textFormatOptionValue() throws RecognitionException {
TextFormatOptionValueContext _localctx = new TextFormatOptionValueContext(_ctx, getState());
enterRule(_localctx, 98, RULE_textFormatOptionValue);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(511);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN_VALUE) | (1L << IDENT) | (1L << STRING_VALUE) | (1L << INTEGER_VALUE) | (1L << FLOAT_VALUE))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FullIdentContext extends ParserRuleContext {
public List ident() {
return getRuleContexts(IdentContext.class);
}
public IdentContext ident(int i) {
return getRuleContext(IdentContext.class,i);
}
public List DOT() { return getTokens(ProtoParser.DOT); }
public TerminalNode DOT(int i) {
return getToken(ProtoParser.DOT, i);
}
public FullIdentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fullIdent; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterFullIdent(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitFullIdent(this);
}
}
public final FullIdentContext fullIdent() throws RecognitionException {
FullIdentContext _localctx = new FullIdentContext(_ctx, getState());
enterRule(_localctx, 100, RULE_fullIdent);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(513);
ident();
setState(518);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DOT) {
{
{
setState(514);
match(DOT);
setState(515);
ident();
}
}
setState(520);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IdentContext extends ParserRuleContext {
public TerminalNode IDENT() { return getToken(ProtoParser.IDENT, 0); }
public TerminalNode PACKAGE() { return getToken(ProtoParser.PACKAGE, 0); }
public TerminalNode SYNTAX() { return getToken(ProtoParser.SYNTAX, 0); }
public TerminalNode IMPORT() { return getToken(ProtoParser.IMPORT, 0); }
public TerminalNode PUBLIC() { return getToken(ProtoParser.PUBLIC, 0); }
public TerminalNode OPTION() { return getToken(ProtoParser.OPTION, 0); }
public TerminalNode MESSAGE() { return getToken(ProtoParser.MESSAGE, 0); }
public TerminalNode GROUP() { return getToken(ProtoParser.GROUP, 0); }
public TerminalNode OPTIONAL() { return getToken(ProtoParser.OPTIONAL, 0); }
public TerminalNode REQUIRED() { return getToken(ProtoParser.REQUIRED, 0); }
public TerminalNode REPEATED() { return getToken(ProtoParser.REPEATED, 0); }
public TerminalNode ONEOF() { return getToken(ProtoParser.ONEOF, 0); }
public TerminalNode EXTEND() { return getToken(ProtoParser.EXTEND, 0); }
public TerminalNode EXTENSIONS() { return getToken(ProtoParser.EXTENSIONS, 0); }
public TerminalNode TO() { return getToken(ProtoParser.TO, 0); }
public TerminalNode MAX() { return getToken(ProtoParser.MAX, 0); }
public TerminalNode RESERVED() { return getToken(ProtoParser.RESERVED, 0); }
public TerminalNode ENUM() { return getToken(ProtoParser.ENUM, 0); }
public TerminalNode SERVICE() { return getToken(ProtoParser.SERVICE, 0); }
public TerminalNode RPC() { return getToken(ProtoParser.RPC, 0); }
public TerminalNode RETURNS() { return getToken(ProtoParser.RETURNS, 0); }
public TerminalNode STREAM() { return getToken(ProtoParser.STREAM, 0); }
public TerminalNode MAP() { return getToken(ProtoParser.MAP, 0); }
public TerminalNode BOOLEAN_VALUE() { return getToken(ProtoParser.BOOLEAN_VALUE, 0); }
public TerminalNode DOUBLE() { return getToken(ProtoParser.DOUBLE, 0); }
public TerminalNode FLOAT() { return getToken(ProtoParser.FLOAT, 0); }
public TerminalNode INT32() { return getToken(ProtoParser.INT32, 0); }
public TerminalNode INT64() { return getToken(ProtoParser.INT64, 0); }
public TerminalNode UINT32() { return getToken(ProtoParser.UINT32, 0); }
public TerminalNode UINT64() { return getToken(ProtoParser.UINT64, 0); }
public TerminalNode SINT32() { return getToken(ProtoParser.SINT32, 0); }
public TerminalNode SINT64() { return getToken(ProtoParser.SINT64, 0); }
public TerminalNode FIXED32() { return getToken(ProtoParser.FIXED32, 0); }
public TerminalNode FIXED64() { return getToken(ProtoParser.FIXED64, 0); }
public TerminalNode SFIXED32() { return getToken(ProtoParser.SFIXED32, 0); }
public TerminalNode SFIXED64() { return getToken(ProtoParser.SFIXED64, 0); }
public TerminalNode BOOL() { return getToken(ProtoParser.BOOL, 0); }
public TerminalNode STRING() { return getToken(ProtoParser.STRING, 0); }
public TerminalNode BYTES() { return getToken(ProtoParser.BYTES, 0); }
public IdentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ident; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterIdent(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitIdent(this);
}
}
public final IdentContext ident() throws RecognitionException {
IdentContext _localctx = new IdentContext(_ctx, getState());
enterRule(_localctx, 102, RULE_ident);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(521);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PACKAGE) | (1L << SYNTAX) | (1L << IMPORT) | (1L << PUBLIC) | (1L << OPTION) | (1L << MESSAGE) | (1L << GROUP) | (1L << OPTIONAL) | (1L << REQUIRED) | (1L << REPEATED) | (1L << ONEOF) | (1L << EXTEND) | (1L << EXTENSIONS) | (1L << TO) | (1L << MAX) | (1L << RESERVED) | (1L << ENUM) | (1L << SERVICE) | (1L << RPC) | (1L << RETURNS) | (1L << STREAM) | (1L << MAP) | (1L << BOOLEAN_VALUE) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT32) | (1L << INT64) | (1L << UINT32) | (1L << UINT64) | (1L << SINT32) | (1L << SINT64) | (1L << FIXED32) | (1L << FIXED64) | (1L << SFIXED32) | (1L << SFIXED64) | (1L << BOOL) | (1L << STRING) | (1L << BYTES) | (1L << IDENT))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static final String _serializedATN =
"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3>\u020e\4\2\t\2\4"+
"\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
"\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+
"\64\4\65\t\65\3\2\5\2l\n\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\7\2u\n\2\f\2\16"+
"\2x\13\2\3\2\3\2\3\3\3\3\3\3\3\3\3\3\3\4\3\4\3\4\3\4\3\5\3\5\3\6\3\6\5"+
"\6\u0089\n\6\3\6\3\6\3\6\3\7\3\7\3\b\3\b\3\b\3\b\3\t\3\t\3\t\3\t\3\t\7"+
"\t\u0099\n\t\f\t\16\t\u009c\13\t\3\t\3\t\5\t\u00a0\n\t\3\n\3\n\3\13\3"+
"\13\3\13\3\13\5\13\u00a8\n\13\3\13\3\13\3\f\3\f\3\r\3\r\3\16\3\16\3\16"+
"\3\16\7\16\u00b4\n\16\f\16\16\16\u00b7\13\16\3\16\3\16\5\16\u00bb\n\16"+
"\3\17\3\17\5\17\u00bf\n\17\3\20\3\20\3\20\3\20\3\20\7\20\u00c6\n\20\f"+
"\20\16\20\u00c9\13\20\3\20\3\20\5\20\u00cd\n\20\3\21\3\21\3\22\3\22\3"+
"\22\3\22\3\22\3\22\3\22\3\22\3\22\3\22\3\22\7\22\u00dc\n\22\f\22\16\22"+
"\u00df\13\22\3\22\5\22\u00e2\n\22\3\22\5\22\u00e5\n\22\3\23\3\23\3\24"+
"\5\24\u00ea\n\24\3\24\3\24\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25"+
"\3\25\3\25\3\25\3\25\3\25\7\25\u00fc\n\25\f\25\16\25\u00ff\13\25\3\25"+
"\3\25\5\25\u0103\n\25\3\26\3\26\3\27\3\27\3\27\3\27\3\27\7\27\u010c\n"+
"\27\f\27\16\27\u010f\13\27\3\27\3\27\5\27\u0113\n\27\3\30\3\30\3\31\3"+
"\31\3\31\3\31\3\31\5\31\u011c\n\31\3\31\3\31\3\32\3\32\3\32\3\32\3\32"+
"\3\32\3\32\3\32\3\32\3\32\3\32\3\32\7\32\u012c\n\32\f\32\16\32\u012f\13"+
"\32\3\32\3\32\5\32\u0133\n\32\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33"+
"\3\33\3\33\5\33\u013f\n\33\3\33\3\33\3\34\3\34\3\35\3\35\3\36\3\36\3\37"+
"\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\7\37\u0156"+
"\n\37\f\37\16\37\u0159\13\37\3\37\3\37\5\37\u015d\n\37\3 \3 \3!\3!\3!"+
"\3!\7!\u0165\n!\f!\16!\u0168\13!\3!\3!\3\"\3\"\3\"\3\"\5\"\u0170\n\"\5"+
"\"\u0172\n\"\3#\3#\3$\3$\3%\3%\3%\3%\7%\u017c\n%\f%\16%\u017f\13%\3%\3"+
"%\3&\3&\3&\3&\7&\u0187\n&\f&\16&\u018a\13&\3&\3&\3\'\3\'\3(\5(\u0191\n"+
"(\3(\3(\3(\3(\3(\5(\u0198\n(\3(\3(\3)\3)\3*\3*\3+\3+\3+\3+\3+\3+\3+\3"+
"+\3+\3+\3+\3+\3+\3+\3+\3+\5+\u01b0\n+\3+\3+\3+\7+\u01b5\n+\f+\16+\u01b8"+
"\13+\5+\u01ba\n+\3,\3,\3,\3,\7,\u01c0\n,\f,\16,\u01c3\13,\5,\u01c5\n,"+
"\3,\3,\3-\3-\3-\3-\3.\3.\3.\7.\u01d0\n.\f.\16.\u01d3\13.\3.\3.\3.\3.\3"+
".\7.\u01da\n.\f.\16.\u01dd\13.\5.\u01df\n.\3/\3/\3/\3/\3/\3/\5/\u01e7"+
"\n/\3\60\3\60\7\60\u01eb\n\60\f\60\16\60\u01ee\13\60\3\60\3\60\3\61\3"+
"\61\3\61\3\61\3\61\5\61\u01f7\n\61\3\62\3\62\3\62\3\62\3\62\3\62\3\62"+
"\5\62\u0200\n\62\3\63\3\63\3\64\3\64\3\64\7\64\u0207\n\64\f\64\16\64\u020a"+
"\13\64\3\65\3\65\3\65\2\2\66\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \""+
"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfh\2\6\3\2\34\'\3\2\n\f\4\2"+
"\31\31:=\4\2\3(::\u0237\2k\3\2\2\2\4{\3\2\2\2\6\u0080\3\2\2\2\b\u0084"+
"\3\2\2\2\n\u0086\3\2\2\2\f\u008d\3\2\2\2\16\u008f\3\2\2\2\20\u0093\3\2"+
"\2\2\22\u00a1\3\2\2\2\24\u00a3\3\2\2\2\26\u00ab\3\2\2\2\30\u00ad\3\2\2"+
"\2\32\u00af\3\2\2\2\34\u00be\3\2\2\2\36\u00c0\3\2\2\2 \u00ce\3\2\2\2\""+
"\u00d0\3\2\2\2$\u00e6\3\2\2\2&\u00e9\3\2\2\2(\u00ed\3\2\2\2*\u0104\3\2"+
"\2\2,\u0106\3\2\2\2.\u0114\3\2\2\2\60\u0116\3\2\2\2\62\u011f\3\2\2\2\64"+
"\u0134\3\2\2\2\66\u0142\3\2\2\28\u0144\3\2\2\2:\u0146\3\2\2\2<\u0148\3"+
"\2\2\2>\u015e\3\2\2\2@\u0160\3\2\2\2B\u016b\3\2\2\2D\u0173\3\2\2\2F\u0175"+
"\3\2\2\2H\u0177\3\2\2\2J\u0182\3\2\2\2L\u018d\3\2\2\2N\u0190\3\2\2\2P"+
"\u019b\3\2\2\2R\u019d\3\2\2\2T\u01b9\3\2\2\2V\u01bb\3\2\2\2X\u01c8\3\2"+
"\2\2Z\u01de\3\2\2\2\\\u01e6\3\2\2\2^\u01e8\3\2\2\2`\u01f6\3\2\2\2b\u01ff"+
"\3\2\2\2d\u0201\3\2\2\2f\u0203\3\2\2\2h\u020b\3\2\2\2jl\5\4\3\2kj\3\2"+
"\2\2kl\3\2\2\2lv\3\2\2\2mu\5\6\4\2nu\5\n\6\2ou\5\16\b\2pu\5\20\t\2qu\5"+
"(\25\2ru\5\32\16\2su\5\36\20\2tm\3\2\2\2tn\3\2\2\2to\3\2\2\2tp\3\2\2\2"+
"tq\3\2\2\2tr\3\2\2\2ts\3\2\2\2ux\3\2\2\2vt\3\2\2\2vw\3\2\2\2wy\3\2\2\2"+
"xv\3\2\2\2yz\7\2\2\3z\3\3\2\2\2{|\7\4\2\2|}\79\2\2}~\7;\2\2~\177\78\2"+
"\2\177\5\3\2\2\2\u0080\u0081\7\3\2\2\u0081\u0082\5\b\5\2\u0082\u0083\7"+
"8\2\2\u0083\7\3\2\2\2\u0084\u0085\5f\64\2\u0085\t\3\2\2\2\u0086\u0088"+
"\7\5\2\2\u0087\u0089\7\6\2\2\u0088\u0087\3\2\2\2\u0088\u0089\3\2\2\2\u0089"+
"\u008a\3\2\2\2\u008a\u008b\5\f\7\2\u008b\u008c\78\2\2\u008c\13\3\2\2\2"+
"\u008d\u008e\7;\2\2\u008e\r\3\2\2\2\u008f\u0090\7\7\2\2\u0090\u0091\5"+
"X-\2\u0091\u0092\78\2\2\u0092\17\3\2\2\2\u0093\u0094\7\23\2\2\u0094\u0095"+
"\5\22\n\2\u0095\u009a\7-\2\2\u0096\u0099\5\24\13\2\u0097\u0099\5\16\b"+
"\2\u0098\u0096\3\2\2\2\u0098\u0097\3\2\2\2\u0099\u009c\3\2\2\2\u009a\u0098"+
"\3\2\2\2\u009a\u009b\3\2\2\2\u009b\u009d\3\2\2\2\u009c\u009a\3\2\2\2\u009d"+
"\u009f\7.\2\2\u009e\u00a0\78\2\2\u009f\u009e\3\2\2\2\u009f\u00a0\3\2\2"+
"\2\u00a0\21\3\2\2\2\u00a1\u00a2\5h\65\2\u00a2\23\3\2\2\2\u00a3\u00a4\5"+
"\26\f\2\u00a4\u00a5\79\2\2\u00a5\u00a7\5\30\r\2\u00a6\u00a8\5V,\2\u00a7"+
"\u00a6\3\2\2\2\u00a7\u00a8\3\2\2\2\u00a8\u00a9\3\2\2\2\u00a9\u00aa\78"+
"\2\2\u00aa\25\3\2\2\2\u00ab\u00ac\5h\65\2\u00ac\27\3\2\2\2\u00ad\u00ae"+
"\7<\2\2\u00ae\31\3\2\2\2\u00af\u00b0\7\16\2\2\u00b0\u00b1\5T+\2\u00b1"+
"\u00b5\7-\2\2\u00b2\u00b4\5\34\17\2\u00b3\u00b2\3\2\2\2\u00b4\u00b7\3"+
"\2\2\2\u00b5\u00b3\3\2\2\2\u00b5\u00b6\3\2\2\2\u00b6\u00b8\3\2\2\2\u00b7"+
"\u00b5\3\2\2\2\u00b8\u00ba\7.\2\2\u00b9\u00bb\78\2\2\u00ba\u00b9\3\2\2"+
"\2\u00ba\u00bb\3\2\2\2\u00bb\33\3\2\2\2\u00bc\u00bf\5N(\2\u00bd\u00bf"+
"\5<\37\2\u00be\u00bc\3\2\2\2\u00be\u00bd\3\2\2\2\u00bf\35\3\2\2\2\u00c0"+
"\u00c1\7\24\2\2\u00c1\u00c2\5 \21\2\u00c2\u00c7\7-\2\2\u00c3\u00c6\5\""+
"\22\2\u00c4\u00c6\5\16\b\2\u00c5\u00c3\3\2\2\2\u00c5\u00c4\3\2\2\2\u00c6"+
"\u00c9\3\2\2\2\u00c7\u00c5\3\2\2\2\u00c7\u00c8\3\2\2\2\u00c8\u00ca\3\2"+
"\2\2\u00c9\u00c7\3\2\2\2\u00ca\u00cc\7.\2\2\u00cb\u00cd\78\2\2\u00cc\u00cb"+
"\3\2\2\2\u00cc\u00cd\3\2\2\2\u00cd\37\3\2\2\2\u00ce\u00cf\5h\65\2\u00cf"+
"!\3\2\2\2\u00d0\u00d1\7\25\2\2\u00d1\u00d2\5$\23\2\u00d2\u00d3\7/\2\2"+
"\u00d3\u00d4\5&\24\2\u00d4\u00d5\7\60\2\2\u00d5\u00d6\7\26\2\2\u00d6\u00d7"+
"\7/\2\2\u00d7\u00d8\5&\24\2\u00d8\u00e1\7\60\2\2\u00d9\u00dd\7-\2\2\u00da"+
"\u00dc\5\16\b\2\u00db\u00da\3\2\2\2\u00dc\u00df\3\2\2\2\u00dd\u00db\3"+
"\2\2\2\u00dd\u00de\3\2\2\2\u00de\u00e0\3\2\2\2\u00df\u00dd\3\2\2\2\u00e0"+
"\u00e2\7.\2\2\u00e1\u00d9\3\2\2\2\u00e1\u00e2\3\2\2\2\u00e2\u00e4\3\2"+
"\2\2\u00e3\u00e5\78\2\2\u00e4\u00e3\3\2\2\2\u00e4\u00e5\3\2\2\2\u00e5"+
"#\3\2\2\2\u00e6\u00e7\5h\65\2\u00e7%\3\2\2\2\u00e8\u00ea\7\27\2\2\u00e9"+
"\u00e8\3\2\2\2\u00e9\u00ea\3\2\2\2\u00ea\u00eb\3\2\2\2\u00eb\u00ec\5T"+
"+\2\u00ec\'\3\2\2\2\u00ed\u00ee\7\b\2\2\u00ee\u00ef\5*\26\2\u00ef\u00fd"+
"\7-\2\2\u00f0\u00fc\5N(\2\u00f1\u00fc\5\16\b\2\u00f2\u00fc\5(\25\2\u00f3"+
"\u00fc\5\20\t\2\u00f4\u00fc\5@!\2\u00f5\u00fc\5\32\16\2\u00f6\u00fc\5"+
"<\37\2\u00f7\u00fc\5,\27\2\u00f8\u00fc\5\64\33\2\u00f9\u00fc\5H%\2\u00fa"+
"\u00fc\5J&\2\u00fb\u00f0\3\2\2\2\u00fb\u00f1\3\2\2\2\u00fb\u00f2\3\2\2"+
"\2\u00fb\u00f3\3\2\2\2\u00fb\u00f4\3\2\2\2\u00fb\u00f5\3\2\2\2\u00fb\u00f6"+
"\3\2\2\2\u00fb\u00f7\3\2\2\2\u00fb\u00f8\3\2\2\2\u00fb\u00f9\3\2\2\2\u00fb"+
"\u00fa\3\2\2\2\u00fc\u00ff\3\2\2\2\u00fd\u00fb\3\2\2\2\u00fd\u00fe\3\2"+
"\2\2\u00fe\u0100\3\2\2\2\u00ff\u00fd\3\2\2\2\u0100\u0102\7.\2\2\u0101"+
"\u0103\78\2\2\u0102\u0101\3\2\2\2\u0102\u0103\3\2\2\2\u0103)\3\2\2\2\u0104"+
"\u0105\5h\65\2\u0105+\3\2\2\2\u0106\u0107\7\r\2\2\u0107\u0108\5.\30\2"+
"\u0108\u010d\7-\2\2\u0109\u010c\5\60\31\2\u010a\u010c\5\62\32\2\u010b"+
"\u0109\3\2\2\2\u010b\u010a\3\2\2\2\u010c\u010f\3\2\2\2\u010d\u010b\3\2"+
"\2\2\u010d\u010e\3\2\2\2\u010e\u0110\3\2\2\2\u010f\u010d\3\2\2\2\u0110"+
"\u0112\7.\2\2\u0111\u0113\78\2\2\u0112\u0111\3\2\2\2\u0112\u0113\3\2\2"+
"\2\u0113-\3\2\2\2\u0114\u0115\5h\65\2\u0115/\3\2\2\2\u0116\u0117\5T+\2"+
"\u0117\u0118\5P)\2\u0118\u0119\79\2\2\u0119\u011b\5:\36\2\u011a\u011c"+
"\5V,\2\u011b\u011a\3\2\2\2\u011b\u011c\3\2\2\2\u011c\u011d\3\2\2\2\u011d"+
"\u011e\78\2\2\u011e\61\3\2\2\2\u011f\u0120\7\t\2\2\u0120\u0121\5P)\2\u0121"+
"\u0122\79\2\2\u0122\u0123\5:\36\2\u0123\u012d\7-\2\2\u0124\u012c\5N(\2"+
"\u0125\u012c\5\16\b\2\u0126\u012c\5(\25\2\u0127\u012c\5\20\t\2\u0128\u012c"+
"\5@!\2\u0129\u012c\5\32\16\2\u012a\u012c\5<\37\2\u012b\u0124\3\2\2\2\u012b"+
"\u0125\3\2\2\2\u012b\u0126\3\2\2\2\u012b\u0127\3\2\2\2\u012b\u0128\3\2"+
"\2\2\u012b\u0129\3\2\2\2\u012b\u012a\3\2\2\2\u012c\u012f\3\2\2\2\u012d"+
"\u012b\3\2\2\2\u012d\u012e\3\2\2\2\u012e\u0130\3\2\2\2\u012f\u012d\3\2"+
"\2\2\u0130\u0132\7.\2\2\u0131\u0133\78\2\2\u0132\u0131\3\2\2\2\u0132\u0133"+
"\3\2\2\2\u0133\63\3\2\2\2\u0134\u0135\7\30\2\2\u0135\u0136\7\63\2\2\u0136"+
"\u0137\5\66\34\2\u0137\u0138\7\65\2\2\u0138\u0139\58\35\2\u0139\u013a"+
"\7\64\2\2\u013a\u013b\5P)\2\u013b\u013c\79\2\2\u013c\u013e\5:\36\2\u013d"+
"\u013f\5V,\2\u013e\u013d\3\2\2\2\u013e\u013f\3\2\2\2\u013f\u0140\3\2\2"+
"\2\u0140\u0141\78\2\2\u0141\65\3\2\2\2\u0142\u0143\t\2\2\2\u0143\67\3"+
"\2\2\2\u0144\u0145\5T+\2\u01459\3\2\2\2\u0146\u0147\7<\2\2\u0147;\3\2"+
"\2\2\u0148\u0149\5R*\2\u0149\u014a\7\t\2\2\u014a\u014b\5> \2\u014b\u014c"+
"\79\2\2\u014c\u014d\5:\36\2\u014d\u0157\7-\2\2\u014e\u0156\5N(\2\u014f"+
"\u0156\5\16\b\2\u0150\u0156\5(\25\2\u0151\u0156\5\20\t\2\u0152\u0156\5"+
"@!\2\u0153\u0156\5\32\16\2\u0154\u0156\5<\37\2\u0155\u014e\3\2\2\2\u0155"+
"\u014f\3\2\2\2\u0155\u0150\3\2\2\2\u0155\u0151\3\2\2\2\u0155\u0152\3\2"+
"\2\2\u0155\u0153\3\2\2\2\u0155\u0154\3\2\2\2\u0156\u0159\3\2\2\2\u0157"+
"\u0155\3\2\2\2\u0157\u0158\3\2\2\2\u0158\u015a\3\2\2\2\u0159\u0157\3\2"+
"\2\2\u015a\u015c\7.\2\2\u015b\u015d\78\2\2\u015c\u015b\3\2\2\2\u015c\u015d"+
"\3\2\2\2\u015d=\3\2\2\2\u015e\u015f\5h\65\2\u015f?\3\2\2\2\u0160\u0161"+
"\7\17\2\2\u0161\u0166\5B\"\2\u0162\u0163\7\65\2\2\u0163\u0165\5B\"\2\u0164"+
"\u0162\3\2\2\2\u0165\u0168\3\2\2\2\u0166\u0164\3\2\2\2\u0166\u0167\3\2"+
"\2\2\u0167\u0169\3\2\2\2\u0168\u0166\3\2\2\2\u0169\u016a\78\2\2\u016a"+
"A\3\2\2\2\u016b\u0171\5D#\2\u016c\u016f\7\20\2\2\u016d\u0170\5F$\2\u016e"+
"\u0170\7\21\2\2\u016f\u016d\3\2\2\2\u016f\u016e\3\2\2\2\u0170\u0172\3"+
"\2\2\2\u0171\u016c\3\2\2\2\u0171\u0172\3\2\2\2\u0172C\3\2\2\2\u0173\u0174"+
"\7<\2\2\u0174E\3\2\2\2\u0175\u0176\7<\2\2\u0176G\3\2\2\2\u0177\u0178\7"+
"\22\2\2\u0178\u017d\5B\"\2\u0179\u017a\7\65\2\2\u017a\u017c\5B\"\2\u017b"+
"\u0179\3\2\2\2\u017c\u017f\3\2\2\2\u017d\u017b\3\2\2\2\u017d\u017e\3\2"+
"\2\2\u017e\u0180\3\2\2\2\u017f\u017d\3\2\2\2\u0180\u0181\78\2\2\u0181"+
"I\3\2\2\2\u0182\u0183\7\22\2\2\u0183\u0188\5L\'\2\u0184\u0185\7\65\2\2"+
"\u0185\u0187\5L\'\2\u0186\u0184\3\2\2\2\u0187\u018a\3\2\2\2\u0188\u0186"+
"\3\2\2\2\u0188\u0189\3\2\2\2\u0189\u018b\3\2\2\2\u018a\u0188\3\2\2\2\u018b"+
"\u018c\78\2\2\u018cK\3\2\2\2\u018d\u018e\7;\2\2\u018eM\3\2\2\2\u018f\u0191"+
"\5R*\2\u0190\u018f\3\2\2\2\u0190\u0191\3\2\2\2\u0191\u0192\3\2\2\2\u0192"+
"\u0193\5T+\2\u0193\u0194\5P)\2\u0194\u0195\79\2\2\u0195\u0197\5:\36\2"+
"\u0196\u0198\5V,\2\u0197\u0196\3\2\2\2\u0197\u0198\3\2\2\2\u0198\u0199"+
"\3\2\2\2\u0199\u019a\78\2\2\u019aO\3\2\2\2\u019b\u019c\5h\65\2\u019cQ"+
"\3\2\2\2\u019d\u019e\t\3\2\2\u019eS\3\2\2\2\u019f\u01ba\7\32\2\2\u01a0"+
"\u01ba\7\33\2\2\u01a1\u01ba\7\34\2\2\u01a2\u01ba\7\35\2\2\u01a3\u01ba"+
"\7\36\2\2\u01a4\u01ba\7\37\2\2\u01a5\u01ba\7 \2\2\u01a6\u01ba\7!\2\2\u01a7"+
"\u01ba\7\"\2\2\u01a8\u01ba\7#\2\2\u01a9\u01ba\7$\2\2\u01aa\u01ba\7%\2"+
"\2\u01ab\u01ba\7&\2\2\u01ac\u01ba\7\'\2\2\u01ad\u01ba\7(\2\2\u01ae\u01b0"+
"\7\66\2\2\u01af\u01ae\3\2\2\2\u01af\u01b0\3\2\2\2\u01b0\u01b1\3\2\2\2"+
"\u01b1\u01b6\5h\65\2\u01b2\u01b3\7\66\2\2\u01b3\u01b5\5h\65\2\u01b4\u01b2"+
"\3\2\2\2\u01b5\u01b8\3\2\2\2\u01b6\u01b4\3\2\2\2\u01b6\u01b7\3\2\2\2\u01b7"+
"\u01ba\3\2\2\2\u01b8\u01b6\3\2\2\2\u01b9\u019f\3\2\2\2\u01b9\u01a0\3\2"+
"\2\2\u01b9\u01a1\3\2\2\2\u01b9\u01a2\3\2\2\2\u01b9\u01a3\3\2\2\2\u01b9"+
"\u01a4\3\2\2\2\u01b9\u01a5\3\2\2\2\u01b9\u01a6\3\2\2\2\u01b9\u01a7\3\2"+
"\2\2\u01b9\u01a8\3\2\2\2\u01b9\u01a9\3\2\2\2\u01b9\u01aa\3\2\2\2\u01b9"+
"\u01ab\3\2\2\2\u01b9\u01ac\3\2\2\2\u01b9\u01ad\3\2\2\2\u01b9\u01af\3\2"+
"\2\2\u01baU\3\2\2\2\u01bb\u01c4\7\61\2\2\u01bc\u01c1\5X-\2\u01bd\u01be"+
"\7\65\2\2\u01be\u01c0\5X-\2\u01bf\u01bd\3\2\2\2\u01c0\u01c3\3\2\2\2\u01c1"+
"\u01bf\3\2\2\2\u01c1\u01c2\3\2\2\2\u01c2\u01c5\3\2\2\2\u01c3\u01c1\3\2"+
"\2\2\u01c4\u01bc\3\2\2\2\u01c4\u01c5\3\2\2\2\u01c5\u01c6\3\2\2\2\u01c6"+
"\u01c7\7\62\2\2\u01c7W\3\2\2\2\u01c8\u01c9\5Z.\2\u01c9\u01ca\79\2\2\u01ca"+
"\u01cb\5\\/\2\u01cbY\3\2\2\2\u01cc\u01d1\5h\65\2\u01cd\u01ce\7\66\2\2"+
"\u01ce\u01d0\5h\65\2\u01cf\u01cd\3\2\2\2\u01d0\u01d3\3\2\2\2\u01d1\u01cf"+
"\3\2\2\2\u01d1\u01d2\3\2\2\2\u01d2\u01df\3\2\2\2\u01d3\u01d1\3\2\2\2\u01d4"+
"\u01d5\7/\2\2\u01d5\u01d6\5T+\2\u01d6\u01db\7\60\2\2\u01d7\u01d8\7\66"+
"\2\2\u01d8\u01da\5Z.\2\u01d9\u01d7\3\2\2\2\u01da\u01dd\3\2\2\2\u01db\u01d9"+
"\3\2\2\2\u01db\u01dc\3\2\2\2\u01dc\u01df\3\2\2\2\u01dd\u01db\3\2\2\2\u01de"+
"\u01cc\3\2\2\2\u01de\u01d4\3\2\2\2\u01df[\3\2\2\2\u01e0\u01e7\7<\2\2\u01e1"+
"\u01e7\7=\2\2\u01e2\u01e7\7\31\2\2\u01e3\u01e7\7;\2\2\u01e4\u01e7\7:\2"+
"\2\u01e5\u01e7\5^\60\2\u01e6\u01e0\3\2\2\2\u01e6\u01e1\3\2\2\2\u01e6\u01e2"+
"\3\2\2\2\u01e6\u01e3\3\2\2\2\u01e6\u01e4\3\2\2\2\u01e6\u01e5\3\2\2\2\u01e7"+
"]\3\2\2\2\u01e8\u01ec\7-\2\2\u01e9\u01eb\5b\62\2\u01ea\u01e9\3\2\2\2\u01eb"+
"\u01ee\3\2\2\2\u01ec\u01ea\3\2\2\2\u01ec\u01ed\3\2\2\2\u01ed\u01ef\3\2"+
"\2\2\u01ee\u01ec\3\2\2\2\u01ef\u01f0\7.\2\2\u01f0_\3\2\2\2\u01f1\u01f7"+
"\5h\65\2\u01f2\u01f3\7\61\2\2\u01f3\u01f4\5T+\2\u01f4\u01f5\7\62\2\2\u01f5"+
"\u01f7\3\2\2\2\u01f6\u01f1\3\2\2\2\u01f6\u01f2\3\2\2\2\u01f7a\3\2\2\2"+
"\u01f8\u01f9\5`\61\2\u01f9\u01fa\7\67\2\2\u01fa\u01fb\5d\63\2\u01fb\u0200"+
"\3\2\2\2\u01fc\u01fd\5`\61\2\u01fd\u01fe\5^\60\2\u01fe\u0200\3\2\2\2\u01ff"+
"\u01f8\3\2\2\2\u01ff\u01fc\3\2\2\2\u0200c\3\2\2\2\u0201\u0202\t\4\2\2"+
"\u0202e\3\2\2\2\u0203\u0208\5h\65\2\u0204\u0205\7\66\2\2\u0205\u0207\5"+
"h\65\2\u0206\u0204\3\2\2\2\u0207\u020a\3\2\2\2\u0208\u0206\3\2\2\2\u0208"+
"\u0209\3\2\2\2\u0209g\3\2\2\2\u020a\u0208\3\2\2\2\u020b\u020c\t\5\2\2"+
"\u020ci\3\2\2\2\66ktv\u0088\u0098\u009a\u009f\u00a7\u00b5\u00ba\u00be"+
"\u00c5\u00c7\u00cc\u00dd\u00e1\u00e4\u00e9\u00fb\u00fd\u0102\u010b\u010d"+
"\u0112\u011b\u012b\u012d\u0132\u013e\u0155\u0157\u015c\u0166\u016f\u0171"+
"\u017d\u0188\u0190\u0197\u01af\u01b6\u01b9\u01c1\u01c4\u01d1\u01db\u01de"+
"\u01e6\u01ec\u01f6\u01ff\u0208";
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