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,
NAME=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_optionEntry = 5, RULE_enumBlock = 6, RULE_enumConstant = 7,
RULE_extendBlock = 8, RULE_extendBlockEntry = 9, RULE_serviceBlock = 10,
RULE_rpcMethod = 11, RULE_rpcType = 12, RULE_messageBlock = 13, RULE_oneof = 14,
RULE_oneofField = 15, RULE_oneofGroup = 16, RULE_map = 17, RULE_mapKey = 18,
RULE_mapValue = 19, RULE_tag = 20, RULE_groupBlock = 21, RULE_extensions = 22,
RULE_ranges = 23, RULE_range = 24, RULE_reserved = 25, RULE_fieldNames = 26,
RULE_fieldName = 27, RULE_field = 28, RULE_fieldModifier = 29, RULE_typeReference = 30,
RULE_fieldOptions = 31, RULE_option = 32, RULE_optionName = 33, RULE_optionValue = 34,
RULE_textFormat = 35, RULE_textFormatOptionName = 36, RULE_textFormatEntry = 37,
RULE_textFormatOptionValue = 38, RULE_name = 39;
public static final String[] ruleNames = {
"proto", "syntax", "packageStatement", "packageName", "importStatement",
"optionEntry", "enumBlock", "enumConstant", "extendBlock", "extendBlockEntry",
"serviceBlock", "rpcMethod", "rpcType", "messageBlock", "oneof", "oneofField",
"oneofGroup", "map", "mapKey", "mapValue", "tag", "groupBlock", "extensions",
"ranges", "range", "reserved", "fieldNames", "fieldName", "field", "fieldModifier",
"typeReference", "fieldOptions", "option", "optionName", "optionValue",
"textFormat", "textFormatOptionName", "textFormatEntry", "textFormatOptionValue",
"name"
};
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", "NAME", "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(81);
_la = _input.LA(1);
if (_la==SYNTAX) {
{
setState(80);
syntax();
}
}
setState(92);
_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(90);
switch (_input.LA(1)) {
case PACKAGE:
{
setState(83);
packageStatement();
}
break;
case IMPORT:
{
setState(84);
importStatement();
}
break;
case OPTION:
{
setState(85);
optionEntry();
}
break;
case ENUM:
{
setState(86);
enumBlock();
}
break;
case MESSAGE:
{
setState(87);
messageBlock();
}
break;
case EXTEND:
{
setState(88);
extendBlock();
}
break;
case SERVICE:
{
setState(89);
serviceBlock();
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(94);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(95);
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(97);
match(SYNTAX);
setState(98);
match(ASSIGN);
setState(99);
match(STRING_VALUE);
setState(100);
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(102);
match(PACKAGE);
setState(103);
packageName();
setState(104);
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 List name() {
return getRuleContexts(NameContext.class);
}
public NameContext name(int i) {
return getRuleContext(NameContext.class,i);
}
public List DOT() { return getTokens(ProtoParser.DOT); }
public TerminalNode DOT(int i) {
return getToken(ProtoParser.DOT, i);
}
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);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(106);
name();
setState(111);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DOT) {
{
{
setState(107);
match(DOT);
setState(108);
name();
}
}
setState(113);
_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 ImportStatementContext extends ParserRuleContext {
public TerminalNode IMPORT() { return getToken(ProtoParser.IMPORT, 0); }
public TerminalNode STRING_VALUE() { return getToken(ProtoParser.STRING_VALUE, 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(114);
match(IMPORT);
setState(116);
_la = _input.LA(1);
if (_la==PUBLIC) {
{
setState(115);
match(PUBLIC);
}
}
setState(118);
match(STRING_VALUE);
setState(119);
match(SEMICOLON);
}
}
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, 10, RULE_optionEntry);
try {
enterOuterAlt(_localctx, 1);
{
setState(121);
match(OPTION);
setState(122);
option();
setState(123);
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 NameContext name() {
return getRuleContext(NameContext.class,0);
}
public TerminalNode LCURLY() { return getToken(ProtoParser.LCURLY, 0); }
public TerminalNode RCURLY() { return getToken(ProtoParser.RCURLY, 0); }
public List enumConstant() {
return getRuleContexts(EnumConstantContext.class);
}
public EnumConstantContext enumConstant(int i) {
return getRuleContext(EnumConstantContext.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, 12, RULE_enumBlock);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(125);
match(ENUM);
setState(126);
name();
setState(127);
match(LCURLY);
setState(132);
_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 << NAME))) != 0)) {
{
setState(130);
switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
case 1:
{
setState(128);
enumConstant();
}
break;
case 2:
{
setState(129);
optionEntry();
}
break;
}
}
setState(134);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(135);
match(RCURLY);
setState(137);
_la = _input.LA(1);
if (_la==SEMICOLON) {
{
setState(136);
match(SEMICOLON);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnumConstantContext extends ParserRuleContext {
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public TerminalNode ASSIGN() { return getToken(ProtoParser.ASSIGN, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(ProtoParser.INTEGER_VALUE, 0); }
public TerminalNode SEMICOLON() { return getToken(ProtoParser.SEMICOLON, 0); }
public FieldOptionsContext fieldOptions() {
return getRuleContext(FieldOptionsContext.class,0);
}
public EnumConstantContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumConstant; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterEnumConstant(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitEnumConstant(this);
}
}
public final EnumConstantContext enumConstant() throws RecognitionException {
EnumConstantContext _localctx = new EnumConstantContext(_ctx, getState());
enterRule(_localctx, 14, RULE_enumConstant);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(139);
name();
setState(140);
match(ASSIGN);
setState(141);
match(INTEGER_VALUE);
setState(143);
_la = _input.LA(1);
if (_la==LSQUARE) {
{
setState(142);
fieldOptions();
}
}
setState(145);
match(SEMICOLON);
}
}
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, 16, RULE_extendBlock);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(147);
match(EXTEND);
setState(148);
typeReference();
setState(149);
match(LCURLY);
setState(153);
_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 << NAME))) != 0)) {
{
{
setState(150);
extendBlockEntry();
}
}
setState(155);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(156);
match(RCURLY);
setState(158);
_la = _input.LA(1);
if (_la==SEMICOLON) {
{
setState(157);
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, 18, RULE_extendBlockEntry);
try {
setState(162);
switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(160);
field();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(161);
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 NameContext name() {
return getRuleContext(NameContext.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, 20, RULE_serviceBlock);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(164);
match(SERVICE);
setState(165);
name();
setState(166);
match(LCURLY);
setState(171);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==OPTION || _la==RPC) {
{
setState(169);
switch (_input.LA(1)) {
case RPC:
{
setState(167);
rpcMethod();
}
break;
case OPTION:
{
setState(168);
optionEntry();
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(173);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(174);
match(RCURLY);
setState(176);
_la = _input.LA(1);
if (_la==SEMICOLON) {
{
setState(175);
match(SEMICOLON);
}
}
}
}
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 NameContext name() {
return getRuleContext(NameContext.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, 22, RULE_rpcMethod);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(178);
match(RPC);
setState(179);
name();
setState(180);
match(LPAREN);
setState(181);
rpcType();
setState(182);
match(RPAREN);
setState(183);
match(RETURNS);
setState(184);
match(LPAREN);
setState(185);
rpcType();
setState(186);
match(RPAREN);
setState(195);
_la = _input.LA(1);
if (_la==LCURLY) {
{
setState(187);
match(LCURLY);
setState(191);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==OPTION) {
{
{
setState(188);
optionEntry();
}
}
setState(193);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(194);
match(RCURLY);
}
}
setState(198);
_la = _input.LA(1);
if (_la==SEMICOLON) {
{
setState(197);
match(SEMICOLON);
}
}
}
}
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, 24, RULE_rpcType);
try {
enterOuterAlt(_localctx, 1);
{
setState(201);
switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
case 1:
{
setState(200);
match(STREAM);
}
break;
}
setState(203);
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 NameContext name() {
return getRuleContext(NameContext.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 reserved() {
return getRuleContexts(ReservedContext.class);
}
public ReservedContext reserved(int i) {
return getRuleContext(ReservedContext.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, 26, RULE_messageBlock);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(205);
match(MESSAGE);
setState(206);
name();
setState(207);
match(LCURLY);
setState(220);
_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 << NAME))) != 0)) {
{
setState(218);
switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) {
case 1:
{
setState(208);
field();
}
break;
case 2:
{
setState(209);
optionEntry();
}
break;
case 3:
{
setState(210);
messageBlock();
}
break;
case 4:
{
setState(211);
enumBlock();
}
break;
case 5:
{
setState(212);
extensions();
}
break;
case 6:
{
setState(213);
extendBlock();
}
break;
case 7:
{
setState(214);
groupBlock();
}
break;
case 8:
{
setState(215);
oneof();
}
break;
case 9:
{
setState(216);
map();
}
break;
case 10:
{
setState(217);
reserved();
}
break;
}
}
setState(222);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(223);
match(RCURLY);
setState(225);
_la = _input.LA(1);
if (_la==SEMICOLON) {
{
setState(224);
match(SEMICOLON);
}
}
}
}
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 NameContext name() {
return getRuleContext(NameContext.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, 28, RULE_oneof);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(227);
match(ONEOF);
setState(228);
name();
setState(229);
match(LCURLY);
setState(234);
_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 << NAME))) != 0)) {
{
setState(232);
switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) {
case 1:
{
setState(230);
oneofField();
}
break;
case 2:
{
setState(231);
oneofGroup();
}
break;
}
}
setState(236);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(237);
match(RCURLY);
setState(239);
_la = _input.LA(1);
if (_la==SEMICOLON) {
{
setState(238);
match(SEMICOLON);
}
}
}
}
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 NameContext name() {
return getRuleContext(NameContext.class,0);
}
public TerminalNode ASSIGN() { return getToken(ProtoParser.ASSIGN, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(ProtoParser.INTEGER_VALUE, 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, 30, RULE_oneofField);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(241);
typeReference();
setState(242);
name();
setState(243);
match(ASSIGN);
setState(244);
match(INTEGER_VALUE);
setState(246);
_la = _input.LA(1);
if (_la==LSQUARE) {
{
setState(245);
fieldOptions();
}
}
setState(248);
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 NameContext name() {
return getRuleContext(NameContext.class,0);
}
public TerminalNode ASSIGN() { return getToken(ProtoParser.ASSIGN, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(ProtoParser.INTEGER_VALUE, 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, 32, RULE_oneofGroup);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(250);
match(GROUP);
setState(251);
name();
setState(252);
match(ASSIGN);
setState(253);
match(INTEGER_VALUE);
setState(254);
match(LCURLY);
setState(264);
_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 << NAME))) != 0)) {
{
setState(262);
switch ( getInterpreter().adaptivePredict(_input,26,_ctx) ) {
case 1:
{
setState(255);
field();
}
break;
case 2:
{
setState(256);
optionEntry();
}
break;
case 3:
{
setState(257);
messageBlock();
}
break;
case 4:
{
setState(258);
enumBlock();
}
break;
case 5:
{
setState(259);
extensions();
}
break;
case 6:
{
setState(260);
extendBlock();
}
break;
case 7:
{
setState(261);
groupBlock();
}
break;
}
}
setState(266);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(267);
match(RCURLY);
setState(269);
_la = _input.LA(1);
if (_la==SEMICOLON) {
{
setState(268);
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 NameContext name() {
return getRuleContext(NameContext.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, 34, RULE_map);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(271);
match(MAP);
setState(272);
match(LT);
setState(273);
mapKey();
setState(274);
match(COMMA);
setState(275);
mapValue();
setState(276);
match(GT);
setState(277);
name();
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 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, 36, RULE_mapKey);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(285);
_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, 38, RULE_mapValue);
try {
enterOuterAlt(_localctx, 1);
{
setState(287);
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, 40, RULE_tag);
try {
enterOuterAlt(_localctx, 1);
{
setState(289);
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 NameContext name() {
return getRuleContext(NameContext.class,0);
}
public TerminalNode ASSIGN() { return getToken(ProtoParser.ASSIGN, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(ProtoParser.INTEGER_VALUE, 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, 42, RULE_groupBlock);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(291);
fieldModifier();
setState(292);
match(GROUP);
setState(293);
name();
setState(294);
match(ASSIGN);
setState(295);
match(INTEGER_VALUE);
setState(296);
match(LCURLY);
setState(306);
_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 << NAME))) != 0)) {
{
setState(304);
switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) {
case 1:
{
setState(297);
field();
}
break;
case 2:
{
setState(298);
optionEntry();
}
break;
case 3:
{
setState(299);
messageBlock();
}
break;
case 4:
{
setState(300);
enumBlock();
}
break;
case 5:
{
setState(301);
extensions();
}
break;
case 6:
{
setState(302);
extendBlock();
}
break;
case 7:
{
setState(303);
groupBlock();
}
break;
}
}
setState(308);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(309);
match(RCURLY);
setState(311);
_la = _input.LA(1);
if (_la==SEMICOLON) {
{
setState(310);
match(SEMICOLON);
}
}
}
}
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 RangesContext ranges() {
return getRuleContext(RangesContext.class,0);
}
public TerminalNode SEMICOLON() { return getToken(ProtoParser.SEMICOLON, 0); }
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, 44, RULE_extensions);
try {
enterOuterAlt(_localctx, 1);
{
setState(313);
match(EXTENSIONS);
setState(314);
ranges();
setState(315);
match(SEMICOLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RangesContext extends ParserRuleContext {
public List range() {
return getRuleContexts(RangeContext.class);
}
public RangeContext range(int i) {
return getRuleContext(RangeContext.class,i);
}
public List COMMA() { return getTokens(ProtoParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(ProtoParser.COMMA, i);
}
public RangesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ranges; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterRanges(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitRanges(this);
}
}
public final RangesContext ranges() throws RecognitionException {
RangesContext _localctx = new RangesContext(_ctx, getState());
enterRule(_localctx, 46, RULE_ranges);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(317);
range();
setState(322);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(318);
match(COMMA);
setState(319);
range();
}
}
setState(324);
_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 RangeContext extends ParserRuleContext {
public List INTEGER_VALUE() { return getTokens(ProtoParser.INTEGER_VALUE); }
public TerminalNode INTEGER_VALUE(int i) {
return getToken(ProtoParser.INTEGER_VALUE, i);
}
public TerminalNode TO() { return getToken(ProtoParser.TO, 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, 48, RULE_range);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(325);
match(INTEGER_VALUE);
setState(328);
_la = _input.LA(1);
if (_la==TO) {
{
setState(326);
match(TO);
setState(327);
_la = _input.LA(1);
if ( !(_la==MAX || _la==INTEGER_VALUE) ) {
_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 ReservedContext extends ParserRuleContext {
public TerminalNode RESERVED() { return getToken(ProtoParser.RESERVED, 0); }
public TerminalNode SEMICOLON() { return getToken(ProtoParser.SEMICOLON, 0); }
public RangesContext ranges() {
return getRuleContext(RangesContext.class,0);
}
public FieldNamesContext fieldNames() {
return getRuleContext(FieldNamesContext.class,0);
}
public ReservedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_reserved; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterReserved(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitReserved(this);
}
}
public final ReservedContext reserved() throws RecognitionException {
ReservedContext _localctx = new ReservedContext(_ctx, getState());
enterRule(_localctx, 50, RULE_reserved);
try {
enterOuterAlt(_localctx, 1);
{
setState(330);
match(RESERVED);
setState(333);
switch (_input.LA(1)) {
case INTEGER_VALUE:
{
setState(331);
ranges();
}
break;
case STRING_VALUE:
{
setState(332);
fieldNames();
}
break;
default:
throw new NoViableAltException(this);
}
setState(335);
match(SEMICOLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FieldNamesContext extends ParserRuleContext {
public List fieldName() {
return getRuleContexts(FieldNameContext.class);
}
public FieldNameContext fieldName(int i) {
return getRuleContext(FieldNameContext.class,i);
}
public List COMMA() { return getTokens(ProtoParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(ProtoParser.COMMA, i);
}
public FieldNamesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fieldNames; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterFieldNames(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitFieldNames(this);
}
}
public final FieldNamesContext fieldNames() throws RecognitionException {
FieldNamesContext _localctx = new FieldNamesContext(_ctx, getState());
enterRule(_localctx, 52, RULE_fieldNames);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(337);
fieldName();
setState(342);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(338);
match(COMMA);
setState(339);
fieldName();
}
}
setState(344);
_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 FieldNameContext extends ParserRuleContext {
public TerminalNode STRING_VALUE() { return getToken(ProtoParser.STRING_VALUE, 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, 54, RULE_fieldName);
try {
enterOuterAlt(_localctx, 1);
{
setState(345);
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 NameContext name() {
return getRuleContext(NameContext.class,0);
}
public TerminalNode ASSIGN() { return getToken(ProtoParser.ASSIGN, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(ProtoParser.INTEGER_VALUE, 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, 56, RULE_field);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(348);
switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) {
case 1:
{
setState(347);
fieldModifier();
}
break;
}
setState(350);
typeReference();
setState(351);
name();
setState(352);
match(ASSIGN);
setState(353);
match(INTEGER_VALUE);
setState(355);
_la = _input.LA(1);
if (_la==LSQUARE) {
{
setState(354);
fieldOptions();
}
}
setState(357);
match(SEMICOLON);
}
}
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, 58, RULE_fieldModifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(359);
_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 name() {
return getRuleContexts(NameContext.class);
}
public NameContext name(int i) {
return getRuleContext(NameContext.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, 60, RULE_typeReference);
int _la;
try {
setState(387);
switch ( getInterpreter().adaptivePredict(_input,41,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(361);
match(DOUBLE);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(362);
match(FLOAT);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(363);
match(INT32);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(364);
match(INT64);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(365);
match(UINT32);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(366);
match(UINT64);
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(367);
match(SINT32);
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(368);
match(SINT64);
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(369);
match(FIXED32);
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(370);
match(FIXED64);
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(371);
match(SFIXED32);
}
break;
case 12:
enterOuterAlt(_localctx, 12);
{
setState(372);
match(SFIXED64);
}
break;
case 13:
enterOuterAlt(_localctx, 13);
{
setState(373);
match(BOOL);
}
break;
case 14:
enterOuterAlt(_localctx, 14);
{
setState(374);
match(STRING);
}
break;
case 15:
enterOuterAlt(_localctx, 15);
{
setState(375);
match(BYTES);
}
break;
case 16:
enterOuterAlt(_localctx, 16);
{
setState(377);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(376);
match(DOT);
}
}
setState(379);
name();
setState(384);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DOT) {
{
{
setState(380);
match(DOT);
setState(381);
name();
}
}
setState(386);
_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, 62, RULE_fieldOptions);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(389);
match(LSQUARE);
setState(398);
_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 << NAME))) != 0)) {
{
setState(390);
option();
setState(395);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(391);
match(COMMA);
setState(392);
option();
}
}
setState(397);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(400);
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, 64, RULE_option);
try {
enterOuterAlt(_localctx, 1);
{
setState(402);
optionName();
setState(403);
match(ASSIGN);
setState(404);
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 name() {
return getRuleContexts(NameContext.class);
}
public NameContext name(int i) {
return getRuleContext(NameContext.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, 66, RULE_optionName);
try {
int _alt;
setState(424);
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 NAME:
enterOuterAlt(_localctx, 1);
{
setState(406);
name();
setState(411);
_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(407);
match(DOT);
setState(408);
name();
}
}
}
setState(413);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,44,_ctx);
}
}
break;
case LPAREN:
enterOuterAlt(_localctx, 2);
{
setState(414);
match(LPAREN);
setState(415);
typeReference();
setState(416);
match(RPAREN);
setState(421);
_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(417);
match(DOT);
setState(418);
optionName();
}
}
}
setState(423);
_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 NAME() { return getToken(ProtoParser.NAME, 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, 68, RULE_optionValue);
try {
setState(432);
switch (_input.LA(1)) {
case INTEGER_VALUE:
enterOuterAlt(_localctx, 1);
{
setState(426);
match(INTEGER_VALUE);
}
break;
case FLOAT_VALUE:
enterOuterAlt(_localctx, 2);
{
setState(427);
match(FLOAT_VALUE);
}
break;
case BOOLEAN_VALUE:
enterOuterAlt(_localctx, 3);
{
setState(428);
match(BOOLEAN_VALUE);
}
break;
case STRING_VALUE:
enterOuterAlt(_localctx, 4);
{
setState(429);
match(STRING_VALUE);
}
break;
case NAME:
enterOuterAlt(_localctx, 5);
{
setState(430);
match(NAME);
}
break;
case LCURLY:
enterOuterAlt(_localctx, 6);
{
setState(431);
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, 70, RULE_textFormat);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(434);
match(LCURLY);
setState(438);
_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 << NAME))) != 0)) {
{
{
setState(435);
textFormatEntry();
}
}
setState(440);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(441);
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 NameContext name() {
return getRuleContext(NameContext.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, 72, RULE_textFormatOptionName);
try {
setState(448);
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 NAME:
enterOuterAlt(_localctx, 1);
{
setState(443);
name();
}
break;
case LSQUARE:
enterOuterAlt(_localctx, 2);
{
setState(444);
match(LSQUARE);
setState(445);
typeReference();
setState(446);
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, 74, RULE_textFormatEntry);
try {
setState(457);
switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(450);
textFormatOptionName();
setState(451);
match(COLON);
setState(452);
textFormatOptionValue();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(454);
textFormatOptionName();
setState(455);
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 NAME() { return getToken(ProtoParser.NAME, 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, 76, RULE_textFormatOptionValue);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(459);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN_VALUE) | (1L << NAME) | (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 NameContext extends ParserRuleContext {
public TerminalNode NAME() { return getToken(ProtoParser.NAME, 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 NameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).enterName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ProtoParserListener ) ((ProtoParserListener)listener).exitName(this);
}
}
public final NameContext name() throws RecognitionException {
NameContext _localctx = new NameContext(_ctx, getState());
enterRule(_localctx, 78, RULE_name);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(461);
_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 << NAME))) != 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>\u01d2\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)\3\2\5\2T\n\2\3"+
"\2\3\2\3\2\3\2\3\2\3\2\3\2\7\2]\n\2\f\2\16\2`\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\5\7\5p\n\5\f\5\16\5s\13\5\3\6\3\6\5"+
"\6w\n\6\3\6\3\6\3\6\3\7\3\7\3\7\3\7\3\b\3\b\3\b\3\b\3\b\7\b\u0085\n\b"+
"\f\b\16\b\u0088\13\b\3\b\3\b\5\b\u008c\n\b\3\t\3\t\3\t\3\t\5\t\u0092\n"+
"\t\3\t\3\t\3\n\3\n\3\n\3\n\7\n\u009a\n\n\f\n\16\n\u009d\13\n\3\n\3\n\5"+
"\n\u00a1\n\n\3\13\3\13\5\13\u00a5\n\13\3\f\3\f\3\f\3\f\3\f\7\f\u00ac\n"+
"\f\f\f\16\f\u00af\13\f\3\f\3\f\5\f\u00b3\n\f\3\r\3\r\3\r\3\r\3\r\3\r\3"+
"\r\3\r\3\r\3\r\3\r\7\r\u00c0\n\r\f\r\16\r\u00c3\13\r\3\r\5\r\u00c6\n\r"+
"\3\r\5\r\u00c9\n\r\3\16\5\16\u00cc\n\16\3\16\3\16\3\17\3\17\3\17\3\17"+
"\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\7\17\u00dd\n\17\f\17\16"+
"\17\u00e0\13\17\3\17\3\17\5\17\u00e4\n\17\3\20\3\20\3\20\3\20\3\20\7\20"+
"\u00eb\n\20\f\20\16\20\u00ee\13\20\3\20\3\20\5\20\u00f2\n\20\3\21\3\21"+
"\3\21\3\21\3\21\5\21\u00f9\n\21\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\3\22\7\22\u0109\n\22\f\22\16\22\u010c\13\22"+
"\3\22\3\22\5\22\u0110\n\22\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23"+
"\3\23\5\23\u011c\n\23\3\23\3\23\3\24\3\24\3\25\3\25\3\26\3\26\3\27\3\27"+
"\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\7\27\u0133\n\27"+
"\f\27\16\27\u0136\13\27\3\27\3\27\5\27\u013a\n\27\3\30\3\30\3\30\3\30"+
"\3\31\3\31\3\31\7\31\u0143\n\31\f\31\16\31\u0146\13\31\3\32\3\32\3\32"+
"\5\32\u014b\n\32\3\33\3\33\3\33\5\33\u0150\n\33\3\33\3\33\3\34\3\34\3"+
"\34\7\34\u0157\n\34\f\34\16\34\u015a\13\34\3\35\3\35\3\36\5\36\u015f\n"+
"\36\3\36\3\36\3\36\3\36\3\36\5\36\u0166\n\36\3\36\3\36\3\37\3\37\3 \3"+
" \3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \5 \u017c\n \3 \3 \3 \7 \u0181"+
"\n \f \16 \u0184\13 \5 \u0186\n \3!\3!\3!\3!\7!\u018c\n!\f!\16!\u018f"+
"\13!\5!\u0191\n!\3!\3!\3\"\3\"\3\"\3\"\3#\3#\3#\7#\u019c\n#\f#\16#\u019f"+
"\13#\3#\3#\3#\3#\3#\7#\u01a6\n#\f#\16#\u01a9\13#\5#\u01ab\n#\3$\3$\3$"+
"\3$\3$\3$\5$\u01b3\n$\3%\3%\7%\u01b7\n%\f%\16%\u01ba\13%\3%\3%\3&\3&\3"+
"&\3&\3&\5&\u01c3\n&\3\'\3\'\3\'\3\'\3\'\3\'\3\'\5\'\u01cc\n\'\3(\3(\3"+
")\3)\3)\2\2*\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64"+
"\668:<>@BDFHJLNP\2\7\3\2\34\'\4\2\21\21<<\3\2\n\f\4\2\31\31:=\4\2\3(:"+
":\u0205\2S\3\2\2\2\4c\3\2\2\2\6h\3\2\2\2\bl\3\2\2\2\nt\3\2\2\2\f{\3\2"+
"\2\2\16\177\3\2\2\2\20\u008d\3\2\2\2\22\u0095\3\2\2\2\24\u00a4\3\2\2\2"+
"\26\u00a6\3\2\2\2\30\u00b4\3\2\2\2\32\u00cb\3\2\2\2\34\u00cf\3\2\2\2\36"+
"\u00e5\3\2\2\2 \u00f3\3\2\2\2\"\u00fc\3\2\2\2$\u0111\3\2\2\2&\u011f\3"+
"\2\2\2(\u0121\3\2\2\2*\u0123\3\2\2\2,\u0125\3\2\2\2.\u013b\3\2\2\2\60"+
"\u013f\3\2\2\2\62\u0147\3\2\2\2\64\u014c\3\2\2\2\66\u0153\3\2\2\28\u015b"+
"\3\2\2\2:\u015e\3\2\2\2<\u0169\3\2\2\2>\u0185\3\2\2\2@\u0187\3\2\2\2B"+
"\u0194\3\2\2\2D\u01aa\3\2\2\2F\u01b2\3\2\2\2H\u01b4\3\2\2\2J\u01c2\3\2"+
"\2\2L\u01cb\3\2\2\2N\u01cd\3\2\2\2P\u01cf\3\2\2\2RT\5\4\3\2SR\3\2\2\2"+
"ST\3\2\2\2T^\3\2\2\2U]\5\6\4\2V]\5\n\6\2W]\5\f\7\2X]\5\16\b\2Y]\5\34\17"+
"\2Z]\5\22\n\2[]\5\26\f\2\\U\3\2\2\2\\V\3\2\2\2\\W\3\2\2\2\\X\3\2\2\2\\"+
"Y\3\2\2\2\\Z\3\2\2\2\\[\3\2\2\2]`\3\2\2\2^\\\3\2\2\2^_\3\2\2\2_a\3\2\2"+
"\2`^\3\2\2\2ab\7\2\2\3b\3\3\2\2\2cd\7\4\2\2de\79\2\2ef\7;\2\2fg\78\2\2"+
"g\5\3\2\2\2hi\7\3\2\2ij\5\b\5\2jk\78\2\2k\7\3\2\2\2lq\5P)\2mn\7\66\2\2"+
"np\5P)\2om\3\2\2\2ps\3\2\2\2qo\3\2\2\2qr\3\2\2\2r\t\3\2\2\2sq\3\2\2\2"+
"tv\7\5\2\2uw\7\6\2\2vu\3\2\2\2vw\3\2\2\2wx\3\2\2\2xy\7;\2\2yz\78\2\2z"+
"\13\3\2\2\2{|\7\7\2\2|}\5B\"\2}~\78\2\2~\r\3\2\2\2\177\u0080\7\23\2\2"+
"\u0080\u0081\5P)\2\u0081\u0086\7-\2\2\u0082\u0085\5\20\t\2\u0083\u0085"+
"\5\f\7\2\u0084\u0082\3\2\2\2\u0084\u0083\3\2\2\2\u0085\u0088\3\2\2\2\u0086"+
"\u0084\3\2\2\2\u0086\u0087\3\2\2\2\u0087\u0089\3\2\2\2\u0088\u0086\3\2"+
"\2\2\u0089\u008b\7.\2\2\u008a\u008c\78\2\2\u008b\u008a\3\2\2\2\u008b\u008c"+
"\3\2\2\2\u008c\17\3\2\2\2\u008d\u008e\5P)\2\u008e\u008f\79\2\2\u008f\u0091"+
"\7<\2\2\u0090\u0092\5@!\2\u0091\u0090\3\2\2\2\u0091\u0092\3\2\2\2\u0092"+
"\u0093\3\2\2\2\u0093\u0094\78\2\2\u0094\21\3\2\2\2\u0095\u0096\7\16\2"+
"\2\u0096\u0097\5> \2\u0097\u009b\7-\2\2\u0098\u009a\5\24\13\2\u0099\u0098"+
"\3\2\2\2\u009a\u009d\3\2\2\2\u009b\u0099\3\2\2\2\u009b\u009c\3\2\2\2\u009c"+
"\u009e\3\2\2\2\u009d\u009b\3\2\2\2\u009e\u00a0\7.\2\2\u009f\u00a1\78\2"+
"\2\u00a0\u009f\3\2\2\2\u00a0\u00a1\3\2\2\2\u00a1\23\3\2\2\2\u00a2\u00a5"+
"\5:\36\2\u00a3\u00a5\5,\27\2\u00a4\u00a2\3\2\2\2\u00a4\u00a3\3\2\2\2\u00a5"+
"\25\3\2\2\2\u00a6\u00a7\7\24\2\2\u00a7\u00a8\5P)\2\u00a8\u00ad\7-\2\2"+
"\u00a9\u00ac\5\30\r\2\u00aa\u00ac\5\f\7\2\u00ab\u00a9\3\2\2\2\u00ab\u00aa"+
"\3\2\2\2\u00ac\u00af\3\2\2\2\u00ad\u00ab\3\2\2\2\u00ad\u00ae\3\2\2\2\u00ae"+
"\u00b0\3\2\2\2\u00af\u00ad\3\2\2\2\u00b0\u00b2\7.\2\2\u00b1\u00b3\78\2"+
"\2\u00b2\u00b1\3\2\2\2\u00b2\u00b3\3\2\2\2\u00b3\27\3\2\2\2\u00b4\u00b5"+
"\7\25\2\2\u00b5\u00b6\5P)\2\u00b6\u00b7\7/\2\2\u00b7\u00b8\5\32\16\2\u00b8"+
"\u00b9\7\60\2\2\u00b9\u00ba\7\26\2\2\u00ba\u00bb\7/\2\2\u00bb\u00bc\5"+
"\32\16\2\u00bc\u00c5\7\60\2\2\u00bd\u00c1\7-\2\2\u00be\u00c0\5\f\7\2\u00bf"+
"\u00be\3\2\2\2\u00c0\u00c3\3\2\2\2\u00c1\u00bf\3\2\2\2\u00c1\u00c2\3\2"+
"\2\2\u00c2\u00c4\3\2\2\2\u00c3\u00c1\3\2\2\2\u00c4\u00c6\7.\2\2\u00c5"+
"\u00bd\3\2\2\2\u00c5\u00c6\3\2\2\2\u00c6\u00c8\3\2\2\2\u00c7\u00c9\78"+
"\2\2\u00c8\u00c7\3\2\2\2\u00c8\u00c9\3\2\2\2\u00c9\31\3\2\2\2\u00ca\u00cc"+
"\7\27\2\2\u00cb\u00ca\3\2\2\2\u00cb\u00cc\3\2\2\2\u00cc\u00cd\3\2\2\2"+
"\u00cd\u00ce\5> \2\u00ce\33\3\2\2\2\u00cf\u00d0\7\b\2\2\u00d0\u00d1\5"+
"P)\2\u00d1\u00de\7-\2\2\u00d2\u00dd\5:\36\2\u00d3\u00dd\5\f\7\2\u00d4"+
"\u00dd\5\34\17\2\u00d5\u00dd\5\16\b\2\u00d6\u00dd\5.\30\2\u00d7\u00dd"+
"\5\22\n\2\u00d8\u00dd\5,\27\2\u00d9\u00dd\5\36\20\2\u00da\u00dd\5$\23"+
"\2\u00db\u00dd\5\64\33\2\u00dc\u00d2\3\2\2\2\u00dc\u00d3\3\2\2\2\u00dc"+
"\u00d4\3\2\2\2\u00dc\u00d5\3\2\2\2\u00dc\u00d6\3\2\2\2\u00dc\u00d7\3\2"+
"\2\2\u00dc\u00d8\3\2\2\2\u00dc\u00d9\3\2\2\2\u00dc\u00da\3\2\2\2\u00dc"+
"\u00db\3\2\2\2\u00dd\u00e0\3\2\2\2\u00de\u00dc\3\2\2\2\u00de\u00df\3\2"+
"\2\2\u00df\u00e1\3\2\2\2\u00e0\u00de\3\2\2\2\u00e1\u00e3\7.\2\2\u00e2"+
"\u00e4\78\2\2\u00e3\u00e2\3\2\2\2\u00e3\u00e4\3\2\2\2\u00e4\35\3\2\2\2"+
"\u00e5\u00e6\7\r\2\2\u00e6\u00e7\5P)\2\u00e7\u00ec\7-\2\2\u00e8\u00eb"+
"\5 \21\2\u00e9\u00eb\5\"\22\2\u00ea\u00e8\3\2\2\2\u00ea\u00e9\3\2\2\2"+
"\u00eb\u00ee\3\2\2\2\u00ec\u00ea\3\2\2\2\u00ec\u00ed\3\2\2\2\u00ed\u00ef"+
"\3\2\2\2\u00ee\u00ec\3\2\2\2\u00ef\u00f1\7.\2\2\u00f0\u00f2\78\2\2\u00f1"+
"\u00f0\3\2\2\2\u00f1\u00f2\3\2\2\2\u00f2\37\3\2\2\2\u00f3\u00f4\5> \2"+
"\u00f4\u00f5\5P)\2\u00f5\u00f6\79\2\2\u00f6\u00f8\7<\2\2\u00f7\u00f9\5"+
"@!\2\u00f8\u00f7\3\2\2\2\u00f8\u00f9\3\2\2\2\u00f9\u00fa\3\2\2\2\u00fa"+
"\u00fb\78\2\2\u00fb!\3\2\2\2\u00fc\u00fd\7\t\2\2\u00fd\u00fe\5P)\2\u00fe"+
"\u00ff\79\2\2\u00ff\u0100\7<\2\2\u0100\u010a\7-\2\2\u0101\u0109\5:\36"+
"\2\u0102\u0109\5\f\7\2\u0103\u0109\5\34\17\2\u0104\u0109\5\16\b\2\u0105"+
"\u0109\5.\30\2\u0106\u0109\5\22\n\2\u0107\u0109\5,\27\2\u0108\u0101\3"+
"\2\2\2\u0108\u0102\3\2\2\2\u0108\u0103\3\2\2\2\u0108\u0104\3\2\2\2\u0108"+
"\u0105\3\2\2\2\u0108\u0106\3\2\2\2\u0108\u0107\3\2\2\2\u0109\u010c\3\2"+
"\2\2\u010a\u0108\3\2\2\2\u010a\u010b\3\2\2\2\u010b\u010d\3\2\2\2\u010c"+
"\u010a\3\2\2\2\u010d\u010f\7.\2\2\u010e\u0110\78\2\2\u010f\u010e\3\2\2"+
"\2\u010f\u0110\3\2\2\2\u0110#\3\2\2\2\u0111\u0112\7\30\2\2\u0112\u0113"+
"\7\63\2\2\u0113\u0114\5&\24\2\u0114\u0115\7\65\2\2\u0115\u0116\5(\25\2"+
"\u0116\u0117\7\64\2\2\u0117\u0118\5P)\2\u0118\u0119\79\2\2\u0119\u011b"+
"\5*\26\2\u011a\u011c\5@!\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%\3\2\2\2\u011f\u0120\t\2\2\2\u0120"+
"\'\3\2\2\2\u0121\u0122\5> \2\u0122)\3\2\2\2\u0123\u0124\7<\2\2\u0124+"+
"\3\2\2\2\u0125\u0126\5<\37\2\u0126\u0127\7\t\2\2\u0127\u0128\5P)\2\u0128"+
"\u0129\79\2\2\u0129\u012a\7<\2\2\u012a\u0134\7-\2\2\u012b\u0133\5:\36"+
"\2\u012c\u0133\5\f\7\2\u012d\u0133\5\34\17\2\u012e\u0133\5\16\b\2\u012f"+
"\u0133\5.\30\2\u0130\u0133\5\22\n\2\u0131\u0133\5,\27\2\u0132\u012b\3"+
"\2\2\2\u0132\u012c\3\2\2\2\u0132\u012d\3\2\2\2\u0132\u012e\3\2\2\2\u0132"+
"\u012f\3\2\2\2\u0132\u0130\3\2\2\2\u0132\u0131\3\2\2\2\u0133\u0136\3\2"+
"\2\2\u0134\u0132\3\2\2\2\u0134\u0135\3\2\2\2\u0135\u0137\3\2\2\2\u0136"+
"\u0134\3\2\2\2\u0137\u0139\7.\2\2\u0138\u013a\78\2\2\u0139\u0138\3\2\2"+
"\2\u0139\u013a\3\2\2\2\u013a-\3\2\2\2\u013b\u013c\7\17\2\2\u013c\u013d"+
"\5\60\31\2\u013d\u013e\78\2\2\u013e/\3\2\2\2\u013f\u0144\5\62\32\2\u0140"+
"\u0141\7\65\2\2\u0141\u0143\5\62\32\2\u0142\u0140\3\2\2\2\u0143\u0146"+
"\3\2\2\2\u0144\u0142\3\2\2\2\u0144\u0145\3\2\2\2\u0145\61\3\2\2\2\u0146"+
"\u0144\3\2\2\2\u0147\u014a\7<\2\2\u0148\u0149\7\20\2\2\u0149\u014b\t\3"+
"\2\2\u014a\u0148\3\2\2\2\u014a\u014b\3\2\2\2\u014b\63\3\2\2\2\u014c\u014f"+
"\7\22\2\2\u014d\u0150\5\60\31\2\u014e\u0150\5\66\34\2\u014f\u014d\3\2"+
"\2\2\u014f\u014e\3\2\2\2\u0150\u0151\3\2\2\2\u0151\u0152\78\2\2\u0152"+
"\65\3\2\2\2\u0153\u0158\58\35\2\u0154\u0155\7\65\2\2\u0155\u0157\58\35"+
"\2\u0156\u0154\3\2\2\2\u0157\u015a\3\2\2\2\u0158\u0156\3\2\2\2\u0158\u0159"+
"\3\2\2\2\u0159\67\3\2\2\2\u015a\u0158\3\2\2\2\u015b\u015c\7;\2\2\u015c"+
"9\3\2\2\2\u015d\u015f\5<\37\2\u015e\u015d\3\2\2\2\u015e\u015f\3\2\2\2"+
"\u015f\u0160\3\2\2\2\u0160\u0161\5> \2\u0161\u0162\5P)\2\u0162\u0163\7"+
"9\2\2\u0163\u0165\7<\2\2\u0164\u0166\5@!\2\u0165\u0164\3\2\2\2\u0165\u0166"+
"\3\2\2\2\u0166\u0167\3\2\2\2\u0167\u0168\78\2\2\u0168;\3\2\2\2\u0169\u016a"+
"\t\4\2\2\u016a=\3\2\2\2\u016b\u0186\7\32\2\2\u016c\u0186\7\33\2\2\u016d"+
"\u0186\7\34\2\2\u016e\u0186\7\35\2\2\u016f\u0186\7\36\2\2\u0170\u0186"+
"\7\37\2\2\u0171\u0186\7 \2\2\u0172\u0186\7!\2\2\u0173\u0186\7\"\2\2\u0174"+
"\u0186\7#\2\2\u0175\u0186\7$\2\2\u0176\u0186\7%\2\2\u0177\u0186\7&\2\2"+
"\u0178\u0186\7\'\2\2\u0179\u0186\7(\2\2\u017a\u017c\7\66\2\2\u017b\u017a"+
"\3\2\2\2\u017b\u017c\3\2\2\2\u017c\u017d\3\2\2\2\u017d\u0182\5P)\2\u017e"+
"\u017f\7\66\2\2\u017f\u0181\5P)\2\u0180\u017e\3\2\2\2\u0181\u0184\3\2"+
"\2\2\u0182\u0180\3\2\2\2\u0182\u0183\3\2\2\2\u0183\u0186\3\2\2\2\u0184"+
"\u0182\3\2\2\2\u0185\u016b\3\2\2\2\u0185\u016c\3\2\2\2\u0185\u016d\3\2"+
"\2\2\u0185\u016e\3\2\2\2\u0185\u016f\3\2\2\2\u0185\u0170\3\2\2\2\u0185"+
"\u0171\3\2\2\2\u0185\u0172\3\2\2\2\u0185\u0173\3\2\2\2\u0185\u0174\3\2"+
"\2\2\u0185\u0175\3\2\2\2\u0185\u0176\3\2\2\2\u0185\u0177\3\2\2\2\u0185"+
"\u0178\3\2\2\2\u0185\u0179\3\2\2\2\u0185\u017b\3\2\2\2\u0186?\3\2\2\2"+
"\u0187\u0190\7\61\2\2\u0188\u018d\5B\"\2\u0189\u018a\7\65\2\2\u018a\u018c"+
"\5B\"\2\u018b\u0189\3\2\2\2\u018c\u018f\3\2\2\2\u018d\u018b\3\2\2\2\u018d"+
"\u018e\3\2\2\2\u018e\u0191\3\2\2\2\u018f\u018d\3\2\2\2\u0190\u0188\3\2"+
"\2\2\u0190\u0191\3\2\2\2\u0191\u0192\3\2\2\2\u0192\u0193\7\62\2\2\u0193"+
"A\3\2\2\2\u0194\u0195\5D#\2\u0195\u0196\79\2\2\u0196\u0197\5F$\2\u0197"+
"C\3\2\2\2\u0198\u019d\5P)\2\u0199\u019a\7\66\2\2\u019a\u019c\5P)\2\u019b"+
"\u0199\3\2\2\2\u019c\u019f\3\2\2\2\u019d\u019b\3\2\2\2\u019d\u019e\3\2"+
"\2\2\u019e\u01ab\3\2\2\2\u019f\u019d\3\2\2\2\u01a0\u01a1\7/\2\2\u01a1"+
"\u01a2\5> \2\u01a2\u01a7\7\60\2\2\u01a3\u01a4\7\66\2\2\u01a4\u01a6\5D"+
"#\2\u01a5\u01a3\3\2\2\2\u01a6\u01a9\3\2\2\2\u01a7\u01a5\3\2\2\2\u01a7"+
"\u01a8\3\2\2\2\u01a8\u01ab\3\2\2\2\u01a9\u01a7\3\2\2\2\u01aa\u0198\3\2"+
"\2\2\u01aa\u01a0\3\2\2\2\u01abE\3\2\2\2\u01ac\u01b3\7<\2\2\u01ad\u01b3"+
"\7=\2\2\u01ae\u01b3\7\31\2\2\u01af\u01b3\7;\2\2\u01b0\u01b3\7:\2\2\u01b1"+
"\u01b3\5H%\2\u01b2\u01ac\3\2\2\2\u01b2\u01ad\3\2\2\2\u01b2\u01ae\3\2\2"+
"\2\u01b2\u01af\3\2\2\2\u01b2\u01b0\3\2\2\2\u01b2\u01b1\3\2\2\2\u01b3G"+
"\3\2\2\2\u01b4\u01b8\7-\2\2\u01b5\u01b7\5L\'\2\u01b6\u01b5\3\2\2\2\u01b7"+
"\u01ba\3\2\2\2\u01b8\u01b6\3\2\2\2\u01b8\u01b9\3\2\2\2\u01b9\u01bb\3\2"+
"\2\2\u01ba\u01b8\3\2\2\2\u01bb\u01bc\7.\2\2\u01bcI\3\2\2\2\u01bd\u01c3"+
"\5P)\2\u01be\u01bf\7\61\2\2\u01bf\u01c0\5> \2\u01c0\u01c1\7\62\2\2\u01c1"+
"\u01c3\3\2\2\2\u01c2\u01bd\3\2\2\2\u01c2\u01be\3\2\2\2\u01c3K\3\2\2\2"+
"\u01c4\u01c5\5J&\2\u01c5\u01c6\7\67\2\2\u01c6\u01c7\5N(\2\u01c7\u01cc"+
"\3\2\2\2\u01c8\u01c9\5J&\2\u01c9\u01ca\5H%\2\u01ca\u01cc\3\2\2\2\u01cb"+
"\u01c4\3\2\2\2\u01cb\u01c8\3\2\2\2\u01ccM\3\2\2\2\u01cd\u01ce\t\5\2\2"+
"\u01ceO\3\2\2\2\u01cf\u01d0\t\6\2\2\u01d0Q\3\2\2\2\65S\\^qv\u0084\u0086"+
"\u008b\u0091\u009b\u00a0\u00a4\u00ab\u00ad\u00b2\u00c1\u00c5\u00c8\u00cb"+
"\u00dc\u00de\u00e3\u00ea\u00ec\u00f1\u00f8\u0108\u010a\u010f\u011b\u0132"+
"\u0134\u0139\u0144\u014a\u014f\u0158\u015e\u0165\u017b\u0182\u0185\u018d"+
"\u0190\u019d\u01a7\u01aa\u01b2\u01b8\u01c2\u01cb";
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