com.hadii.antlr.golang.GolangParser Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of clarpse Show documentation
Show all versions of clarpse Show documentation
Clarpse is a lightweight polyglot source code analysis tool.
// Generated from com/hadii/antlr/golang/Golang.g4 by ANTLR 4.4
package com.hadii.antlr.golang;
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;
public class GolangParser extends Parser {
public static final int
T__60=1, T__59=2, T__58=3, T__57=4, T__56=5, T__55=6, T__54=7, T__53=8,
T__52=9, T__51=10, T__50=11, T__49=12, T__48=13, T__47=14, T__46=15, T__45=16,
T__44=17, T__43=18, T__42=19, T__41=20, T__40=21, T__39=22, T__38=23,
T__37=24, T__36=25, T__35=26, T__34=27, T__33=28, T__32=29, T__31=30,
T__30=31, T__29=32, T__28=33, T__27=34, T__26=35, T__25=36, T__24=37,
T__23=38, T__22=39, T__21=40, T__20=41, T__19=42, T__18=43, T__17=44,
T__16=45, T__15=46, T__14=47, T__13=48, T__12=49, T__11=50, T__10=51,
T__9=52, T__8=53, T__7=54, T__6=55, T__5=56, T__4=57, T__3=58, T__2=59,
T__1=60, T__0=61, IDENTIFIER=62, KEYWORD=63, BINARY_OP=64, INT_LIT=65,
FLOAT_LIT=66, IMAGINARY_LIT=67, RUNE_LIT=68, LITTLE_U_VALUE=69, BIG_U_VALUE=70,
STRING_LIT=71, WS=72, COMMENT=73, TERMINATOR=74, LINE_COMMENT=75;
public static final String[] tokenNames = {
"", "'chan'", "'default'", "'func'", "'interface'", "'!='", "'{'",
"'&&'", "'>>'", "'='", "'^'", "'for'", "'('", "'package'", "','", "'<-'",
"'var'", "'const'", "'range'", "'>='", "'<'", "'++'", "']'", "'type'",
"'+'", "'struct'", "'/'", "'continue'", "'&^'", "'return'", "'||'", "';'",
"'<<'", "'goto'", "'}'", "'if'", "':='", "'<='", "'break'", "'go'", "'map'",
"'defer'", "'&'", "'switch'", "'*'", "'.'", "'case'", "'...'", "':'",
"'['", "'=='", "'|'", "'--'", "'select'", "'>'", "'fallthrough'", "'!'",
"'%'", "'else'", "')'", "'-'", "'import'", "IDENTIFIER", "KEYWORD", "BINARY_OP",
"INT_LIT", "FLOAT_LIT", "IMAGINARY_LIT", "RUNE_LIT", "LITTLE_U_VALUE",
"BIG_U_VALUE", "STRING_LIT", "WS", "COMMENT", "TERMINATOR", "LINE_COMMENT"
};
public static final int
RULE_sourceFile = 0, RULE_packageClause = 1, RULE_importDecl = 2, RULE_importSpec = 3,
RULE_importPath = 4, RULE_topLevelDecl = 5, RULE_declaration = 6, RULE_constDecl = 7,
RULE_constSpec = 8, RULE_identifierList = 9, RULE_expressionList = 10,
RULE_typeDecl = 11, RULE_typeSpec = 12, RULE_functionDecl = 13, RULE_function = 14,
RULE_methodDecl = 15, RULE_receiver = 16, RULE_varDecl = 17, RULE_varSpec = 18,
RULE_block = 19, RULE_statementList = 20, RULE_statement = 21, RULE_forStmt = 22,
RULE_simpleStmt = 23, RULE_expressionStmt = 24, RULE_ifStmt = 25, RULE_exprCaseClause = 26,
RULE_exprSwitchCase = 27, RULE_typeSwitchGuard = 28, RULE_typeCaseClause = 29,
RULE_typeSwitchCase = 30, RULE_typeList = 31, RULE_commClause = 32, RULE_commCase = 33,
RULE_recvStmt = 34, RULE_forClause = 35, RULE_rangeClause = 36, RULE_type = 37,
RULE_typeName = 38, RULE_typeLit = 39, RULE_arrayLength = 40, RULE_elementType = 41,
RULE_pointerType = 42, RULE_interfaceType = 43, RULE_channelType = 44,
RULE_methodSpec = 45, RULE_functionType = 46, RULE_signature = 47, RULE_result = 48,
RULE_parameters = 49, RULE_parameterList = 50, RULE_parameterDecl = 51,
RULE_operand = 52, RULE_literal = 53, RULE_operandName = 54, RULE_qualifiedIdent = 55,
RULE_literalType = 56, RULE_keyedElement = 57, RULE_key = 58, RULE_element = 59,
RULE_structType = 60, RULE_fieldDecl = 61, RULE_anonymousField = 62, RULE_primaryExpr = 63,
RULE_methodExpr = 64, RULE_receiverType = 65, RULE_expression = 66, RULE_unaryExpr = 67,
RULE_eos = 68;
public static final String[] ruleNames = {
"sourceFile", "packageClause", "importDecl", "importSpec", "importPath",
"topLevelDecl", "declaration", "constDecl", "constSpec", "identifierList",
"expressionList", "typeDecl", "typeSpec", "functionDecl", "function",
"methodDecl", "receiver", "varDecl", "varSpec", "block", "statementList",
"statement", "forStmt", "simpleStmt", "expressionStmt", "ifStmt", "exprCaseClause",
"exprSwitchCase", "typeSwitchGuard", "typeCaseClause", "typeSwitchCase",
"typeList", "commClause", "commCase", "recvStmt", "forClause", "rangeClause",
"type", "typeName", "typeLit", "arrayLength", "elementType", "pointerType",
"interfaceType", "channelType", "methodSpec", "functionType", "signature",
"result", "parameters", "parameterList", "parameterDecl", "operand", "literal",
"operandName", "qualifiedIdent", "literalType", "keyedElement", "key",
"element", "structType", "fieldDecl", "anonymousField", "primaryExpr",
"methodExpr", "receiverType", "expression", "unaryExpr", "eos"
};
@Override
public String getGrammarFileName() { return "Golang.g4"; }
@Override
public String[] getTokenNames() { return tokenNames; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
/**
* Returns {@code true} iff on the current index of the parser's
* token stream a token exists on the {@code HIDDEN} channel which
* either is a line terminator, or is a multi line comment that
* contains a line terminator.
*
* @return {@code true} iff on the current index of the parser's
* token stream a token exists on the {@code HIDDEN} channel which
* either is a line terminator, or is a multi line comment that
* contains a line terminator.
*/
private boolean lineTerminatorAhead() {
// Get the token ahead of the current index.
int possibleIndexEosToken = this.getCurrentToken().getTokenIndex() - 1;
Token ahead = _input.get(possibleIndexEosToken);
if (ahead.getChannel() != Lexer.HIDDEN) {
// We're only interested in tokens on the HIDDEN channel.
return false;
}
if (ahead.getType() == TERMINATOR) {
// There is definitely a line terminator ahead.
return true;
}
if (ahead.getType() == WS) {
// Get the token ahead of the current whitespaces.
possibleIndexEosToken = this.getCurrentToken().getTokenIndex() - 2;
ahead = _input.get(possibleIndexEosToken);
}
// Get the token's text and type.
String text = ahead.getText();
int type = ahead.getType();
// Check if the token is, or contains a line terminator.
return (type == COMMENT && (text.contains("\r") || text.contains("\n"))) ||
(type == TERMINATOR);
}
public GolangParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN);
}
public static class SourceFileContext extends ParserRuleContext {
public ImportDeclContext importDecl(int i) {
return getRuleContext(ImportDeclContext.class,i);
}
public PackageClauseContext packageClause() {
return getRuleContext(PackageClauseContext.class,0);
}
public List eos() {
return getRuleContexts(EosContext.class);
}
public EosContext eos(int i) {
return getRuleContext(EosContext.class,i);
}
public List topLevelDecl() {
return getRuleContexts(TopLevelDeclContext.class);
}
public TopLevelDeclContext topLevelDecl(int i) {
return getRuleContext(TopLevelDeclContext.class,i);
}
public List importDecl() {
return getRuleContexts(ImportDeclContext.class);
}
public SourceFileContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sourceFile; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterSourceFile(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitSourceFile(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitSourceFile(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final SourceFileContext sourceFile() throws RecognitionException {
SourceFileContext _localctx = new SourceFileContext(_ctx, getState());
enterRule(_localctx, 0, RULE_sourceFile);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(138); packageClause();
setState(139); eos();
setState(145);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__0) {
{
{
setState(140); importDecl();
setState(141); eos();
}
}
setState(147);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(153);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__58) | (1L << T__45) | (1L << T__44) | (1L << T__38))) != 0)) {
{
{
setState(148); topLevelDecl();
setState(149); eos();
}
}
setState(155);
_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 PackageClauseContext extends ParserRuleContext {
public TerminalNode IDENTIFIER() { return getToken(GolangParser.IDENTIFIER, 0); }
public PackageClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_packageClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterPackageClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitPackageClause(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitPackageClause(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final PackageClauseContext packageClause() throws RecognitionException {
PackageClauseContext _localctx = new PackageClauseContext(_ctx, getState());
enterRule(_localctx, 2, RULE_packageClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(156); match(T__48);
setState(157); match(IDENTIFIER);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ImportDeclContext extends ParserRuleContext {
public List importSpec() {
return getRuleContexts(ImportSpecContext.class);
}
public List eos() {
return getRuleContexts(EosContext.class);
}
public EosContext eos(int i) {
return getRuleContext(EosContext.class,i);
}
public ImportSpecContext importSpec(int i) {
return getRuleContext(ImportSpecContext.class,i);
}
public ImportDeclContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_importDecl; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterImportDecl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitImportDecl(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitImportDecl(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final ImportDeclContext importDecl() throws RecognitionException {
ImportDeclContext _localctx = new ImportDeclContext(_ctx, getState());
enterRule(_localctx, 4, RULE_importDecl);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(159); match(T__0);
setState(171);
switch (_input.LA(1)) {
case T__16:
case IDENTIFIER:
case STRING_LIT:
{
setState(160); importSpec();
}
break;
case T__49:
{
setState(161); match(T__49);
setState(167);
_errHandler.sync(this);
_la = _input.LA(1);
while (((((_la - 45)) & ~0x3f) == 0 && ((1L << (_la - 45)) & ((1L << (T__16 - 45)) | (1L << (IDENTIFIER - 45)) | (1L << (STRING_LIT - 45)))) != 0)) {
{
{
setState(162); importSpec();
setState(163); eos();
}
}
setState(169);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(170); match(T__2);
}
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 ImportSpecContext extends ParserRuleContext {
public TerminalNode IDENTIFIER() { return getToken(GolangParser.IDENTIFIER, 0); }
public ImportPathContext importPath() {
return getRuleContext(ImportPathContext.class,0);
}
public ImportSpecContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_importSpec; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterImportSpec(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitImportSpec(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitImportSpec(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final ImportSpecContext importSpec() throws RecognitionException {
ImportSpecContext _localctx = new ImportSpecContext(_ctx, getState());
enterRule(_localctx, 6, RULE_importSpec);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(174);
_la = _input.LA(1);
if (_la==T__16 || _la==IDENTIFIER) {
{
setState(173);
_la = _input.LA(1);
if ( !(_la==T__16 || _la==IDENTIFIER) ) {
_errHandler.recoverInline(this);
}
consume();
}
}
setState(176); importPath();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ImportPathContext extends ParserRuleContext {
public TerminalNode STRING_LIT() { return getToken(GolangParser.STRING_LIT, 0); }
public ImportPathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_importPath; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterImportPath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitImportPath(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitImportPath(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final ImportPathContext importPath() throws RecognitionException {
ImportPathContext _localctx = new ImportPathContext(_ctx, getState());
enterRule(_localctx, 8, RULE_importPath);
try {
enterOuterAlt(_localctx, 1);
{
setState(178); match(STRING_LIT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TopLevelDeclContext extends ParserRuleContext {
public MethodDeclContext methodDecl() {
return getRuleContext(MethodDeclContext.class,0);
}
public FunctionDeclContext functionDecl() {
return getRuleContext(FunctionDeclContext.class,0);
}
public DeclarationContext declaration() {
return getRuleContext(DeclarationContext.class,0);
}
public TopLevelDeclContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_topLevelDecl; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterTopLevelDecl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitTopLevelDecl(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitTopLevelDecl(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final TopLevelDeclContext topLevelDecl() throws RecognitionException {
TopLevelDeclContext _localctx = new TopLevelDeclContext(_ctx, getState());
enterRule(_localctx, 10, RULE_topLevelDecl);
try {
setState(183);
switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(180); declaration();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(181); functionDecl();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(182); methodDecl();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DeclarationContext extends ParserRuleContext {
public ConstDeclContext constDecl() {
return getRuleContext(ConstDeclContext.class,0);
}
public VarDeclContext varDecl() {
return getRuleContext(VarDeclContext.class,0);
}
public TypeDeclContext typeDecl() {
return getRuleContext(TypeDeclContext.class,0);
}
public DeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_declaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitDeclaration(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitDeclaration(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final DeclarationContext declaration() throws RecognitionException {
DeclarationContext _localctx = new DeclarationContext(_ctx, getState());
enterRule(_localctx, 12, RULE_declaration);
try {
setState(188);
switch (_input.LA(1)) {
case T__44:
enterOuterAlt(_localctx, 1);
{
setState(185); constDecl();
}
break;
case T__38:
enterOuterAlt(_localctx, 2);
{
setState(186); typeDecl();
}
break;
case T__45:
enterOuterAlt(_localctx, 3);
{
setState(187); varDecl();
}
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 ConstDeclContext extends ParserRuleContext {
public ConstSpecContext constSpec(int i) {
return getRuleContext(ConstSpecContext.class,i);
}
public List eos() {
return getRuleContexts(EosContext.class);
}
public EosContext eos(int i) {
return getRuleContext(EosContext.class,i);
}
public List constSpec() {
return getRuleContexts(ConstSpecContext.class);
}
public ConstDeclContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constDecl; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterConstDecl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitConstDecl(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitConstDecl(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final ConstDeclContext constDecl() throws RecognitionException {
ConstDeclContext _localctx = new ConstDeclContext(_ctx, getState());
enterRule(_localctx, 14, RULE_constDecl);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(190); match(T__44);
setState(202);
switch (_input.LA(1)) {
case IDENTIFIER:
{
setState(191); constSpec();
}
break;
case T__49:
{
setState(192); match(T__49);
setState(198);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==IDENTIFIER) {
{
{
setState(193); constSpec();
setState(194); eos();
}
}
setState(200);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(201); match(T__2);
}
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 ConstSpecContext extends ParserRuleContext {
public IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.class,0);
}
public ExpressionListContext expressionList() {
return getRuleContext(ExpressionListContext.class,0);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public ConstSpecContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constSpec; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterConstSpec(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitConstSpec(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitConstSpec(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final ConstSpecContext constSpec() throws RecognitionException {
ConstSpecContext _localctx = new ConstSpecContext(_ctx, getState());
enterRule(_localctx, 16, RULE_constSpec);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(204); identifierList();
setState(210);
switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
case 1:
{
setState(206);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__60) | (1L << T__58) | (1L << T__57) | (1L << T__49) | (1L << T__46) | (1L << T__36) | (1L << T__21) | (1L << T__17) | (1L << T__12) | (1L << IDENTIFIER))) != 0)) {
{
setState(205); type();
}
}
setState(208); match(T__52);
setState(209); expressionList();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IdentifierListContext extends ParserRuleContext {
public TerminalNode IDENTIFIER(int i) {
return getToken(GolangParser.IDENTIFIER, i);
}
public List IDENTIFIER() { return getTokens(GolangParser.IDENTIFIER); }
public IdentifierListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identifierList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterIdentifierList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitIdentifierList(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitIdentifierList(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final IdentifierListContext identifierList() throws RecognitionException {
IdentifierListContext _localctx = new IdentifierListContext(_ctx, getState());
enterRule(_localctx, 18, RULE_identifierList);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(212); match(IDENTIFIER);
setState(217);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,11,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(213); match(T__47);
setState(214); match(IDENTIFIER);
}
}
}
setState(219);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,11,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionListContext extends ParserRuleContext {
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressionList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterExpressionList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitExpressionList(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitExpressionList(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final ExpressionListContext expressionList() throws RecognitionException {
ExpressionListContext _localctx = new ExpressionListContext(_ctx, getState());
enterRule(_localctx, 20, RULE_expressionList);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(220); expression(0);
setState(225);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,12,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(221); match(T__47);
setState(222); expression(0);
}
}
}
setState(227);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,12,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeDeclContext extends ParserRuleContext {
public TypeSpecContext typeSpec(int i) {
return getRuleContext(TypeSpecContext.class,i);
}
public List typeSpec() {
return getRuleContexts(TypeSpecContext.class);
}
public TypeDeclContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeDecl; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterTypeDecl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitTypeDecl(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitTypeDecl(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final TypeDeclContext typeDecl() throws RecognitionException {
TypeDeclContext _localctx = new TypeDeclContext(_ctx, getState());
enterRule(_localctx, 22, RULE_typeDecl);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(228); match(T__38);
setState(240);
switch (_input.LA(1)) {
case IDENTIFIER:
{
setState(229); typeSpec();
}
break;
case T__49:
{
setState(230); match(T__49);
setState(236);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==IDENTIFIER) {
{
{
setState(231); typeSpec();
setState(232); match(T__30);
}
}
setState(238);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(239); match(T__2);
}
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 TypeSpecContext extends ParserRuleContext {
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public TerminalNode IDENTIFIER() { return getToken(GolangParser.IDENTIFIER, 0); }
public TypeSpecContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeSpec; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterTypeSpec(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitTypeSpec(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitTypeSpec(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final TypeSpecContext typeSpec() throws RecognitionException {
TypeSpecContext _localctx = new TypeSpecContext(_ctx, getState());
enterRule(_localctx, 24, RULE_typeSpec);
try {
enterOuterAlt(_localctx, 1);
{
setState(242); match(IDENTIFIER);
setState(243); type();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FunctionDeclContext extends ParserRuleContext {
public SignatureContext signature() {
return getRuleContext(SignatureContext.class,0);
}
public TerminalNode IDENTIFIER() { return getToken(GolangParser.IDENTIFIER, 0); }
public FunctionContext function() {
return getRuleContext(FunctionContext.class,0);
}
public FunctionDeclContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_functionDecl; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterFunctionDecl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitFunctionDecl(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitFunctionDecl(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final FunctionDeclContext functionDecl() throws RecognitionException {
FunctionDeclContext _localctx = new FunctionDeclContext(_ctx, getState());
enterRule(_localctx, 26, RULE_functionDecl);
try {
enterOuterAlt(_localctx, 1);
{
setState(245); match(T__58);
setState(246); match(IDENTIFIER);
setState(249);
switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) {
case 1:
{
setState(247); function();
}
break;
case 2:
{
setState(248); signature();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FunctionContext extends ParserRuleContext {
public SignatureContext signature() {
return getRuleContext(SignatureContext.class,0);
}
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public FunctionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_function; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitFunction(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitFunction(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final FunctionContext function() throws RecognitionException {
FunctionContext _localctx = new FunctionContext(_ctx, getState());
enterRule(_localctx, 28, RULE_function);
try {
enterOuterAlt(_localctx, 1);
{
setState(251); signature();
setState(252); block();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MethodDeclContext extends ParserRuleContext {
public ReceiverContext receiver() {
return getRuleContext(ReceiverContext.class,0);
}
public SignatureContext signature() {
return getRuleContext(SignatureContext.class,0);
}
public TerminalNode IDENTIFIER() { return getToken(GolangParser.IDENTIFIER, 0); }
public FunctionContext function() {
return getRuleContext(FunctionContext.class,0);
}
public MethodDeclContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_methodDecl; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterMethodDecl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitMethodDecl(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitMethodDecl(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final MethodDeclContext methodDecl() throws RecognitionException {
MethodDeclContext _localctx = new MethodDeclContext(_ctx, getState());
enterRule(_localctx, 30, RULE_methodDecl);
try {
enterOuterAlt(_localctx, 1);
{
setState(254); match(T__58);
setState(255); receiver();
setState(256); match(IDENTIFIER);
setState(259);
switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) {
case 1:
{
setState(257); function();
}
break;
case 2:
{
setState(258); signature();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ReceiverContext extends ParserRuleContext {
public ParametersContext parameters() {
return getRuleContext(ParametersContext.class,0);
}
public ReceiverContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_receiver; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterReceiver(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitReceiver(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitReceiver(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final ReceiverContext receiver() throws RecognitionException {
ReceiverContext _localctx = new ReceiverContext(_ctx, getState());
enterRule(_localctx, 32, RULE_receiver);
try {
enterOuterAlt(_localctx, 1);
{
setState(261); parameters();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VarDeclContext extends ParserRuleContext {
public VarSpecContext varSpec(int i) {
return getRuleContext(VarSpecContext.class,i);
}
public List eos() {
return getRuleContexts(EosContext.class);
}
public EosContext eos(int i) {
return getRuleContext(EosContext.class,i);
}
public List varSpec() {
return getRuleContexts(VarSpecContext.class);
}
public VarDeclContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_varDecl; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterVarDecl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitVarDecl(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitVarDecl(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final VarDeclContext varDecl() throws RecognitionException {
VarDeclContext _localctx = new VarDeclContext(_ctx, getState());
enterRule(_localctx, 34, RULE_varDecl);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(263); match(T__45);
setState(275);
switch (_input.LA(1)) {
case IDENTIFIER:
{
setState(264); varSpec();
}
break;
case T__49:
{
setState(265); match(T__49);
setState(271);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==IDENTIFIER) {
{
{
setState(266); varSpec();
setState(267); eos();
}
}
setState(273);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(274); match(T__2);
}
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 VarSpecContext extends ParserRuleContext {
public IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.class,0);
}
public ExpressionListContext expressionList() {
return getRuleContext(ExpressionListContext.class,0);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public VarSpecContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_varSpec; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterVarSpec(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitVarSpec(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitVarSpec(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final VarSpecContext varSpec() throws RecognitionException {
VarSpecContext _localctx = new VarSpecContext(_ctx, getState());
enterRule(_localctx, 36, RULE_varSpec);
try {
enterOuterAlt(_localctx, 1);
{
setState(277); identifierList();
setState(285);
switch (_input.LA(1)) {
case T__60:
case T__58:
case T__57:
case T__49:
case T__46:
case T__36:
case T__21:
case T__17:
case T__12:
case IDENTIFIER:
{
setState(278); type();
setState(281);
switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) {
case 1:
{
setState(279); match(T__52);
setState(280); expressionList();
}
break;
}
}
break;
case T__52:
{
setState(283); match(T__52);
setState(284); expressionList();
}
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 BlockContext extends ParserRuleContext {
public StatementListContext statementList() {
return getRuleContext(StatementListContext.class,0);
}
public BlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_block; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitBlock(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitBlock(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final BlockContext block() throws RecognitionException {
BlockContext _localctx = new BlockContext(_ctx, getState());
enterRule(_localctx, 38, RULE_block);
try {
enterOuterAlt(_localctx, 1);
{
setState(287); match(T__55);
setState(288); statementList();
setState(289); match(T__27);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StatementListContext extends ParserRuleContext {
public List eos() {
return getRuleContexts(EosContext.class);
}
public EosContext eos(int i) {
return getRuleContext(EosContext.class,i);
}
public StatementContext statement(int i) {
return getRuleContext(StatementContext.class,i);
}
public List statement() {
return getRuleContexts(StatementContext.class);
}
public StatementListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_statementList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterStatementList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitStatementList(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitStatementList(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final StatementListContext statementList() throws RecognitionException {
StatementListContext _localctx = new StatementListContext(_ctx, getState());
enterRule(_localctx, 40, RULE_statementList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(296);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__60) | (1L << T__58) | (1L << T__57) | (1L << T__55) | (1L << T__51) | (1L << T__50) | (1L << T__49) | (1L << T__46) | (1L << T__45) | (1L << T__44) | (1L << T__38) | (1L << T__37) | (1L << T__36) | (1L << T__34) | (1L << T__32) | (1L << T__30) | (1L << T__28) | (1L << T__26) | (1L << T__23) | (1L << T__22) | (1L << T__21) | (1L << T__20) | (1L << T__19) | (1L << T__18) | (1L << T__17) | (1L << T__12) | (1L << T__8) | (1L << T__6) | (1L << T__5) | (1L << T__1) | (1L << IDENTIFIER))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (INT_LIT - 65)) | (1L << (FLOAT_LIT - 65)) | (1L << (IMAGINARY_LIT - 65)) | (1L << (RUNE_LIT - 65)) | (1L << (STRING_LIT - 65)))) != 0)) {
{
{
setState(291); statement();
setState(292); eos();
}
}
setState(298);
_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 StatementContext extends ParserRuleContext {
public List commClause() {
return getRuleContexts(CommClauseContext.class);
}
public ExprCaseClauseContext exprCaseClause(int i) {
return getRuleContext(ExprCaseClauseContext.class,i);
}
public TypeSwitchGuardContext typeSwitchGuard() {
return getRuleContext(TypeSwitchGuardContext.class,0);
}
public SimpleStmtContext simpleStmt() {
return getRuleContext(SimpleStmtContext.class,0);
}
public ForStmtContext forStmt() {
return getRuleContext(ForStmtContext.class,0);
}
public List exprCaseClause() {
return getRuleContexts(ExprCaseClauseContext.class);
}
public ExpressionListContext expressionList() {
return getRuleContext(ExpressionListContext.class,0);
}
public IfStmtContext ifStmt() {
return getRuleContext(IfStmtContext.class,0);
}
public CommClauseContext commClause(int i) {
return getRuleContext(CommClauseContext.class,i);
}
public DeclarationContext declaration() {
return getRuleContext(DeclarationContext.class,0);
}
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public TerminalNode IDENTIFIER() { return getToken(GolangParser.IDENTIFIER, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public List typeCaseClause() {
return getRuleContexts(TypeCaseClauseContext.class);
}
public TypeCaseClauseContext typeCaseClause(int i) {
return getRuleContext(TypeCaseClauseContext.class,i);
}
public StatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_statement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitStatement(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitStatement(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final StatementContext statement() throws RecognitionException {
StatementContext _localctx = new StatementContext(_ctx, getState());
enterRule(_localctx, 42, RULE_statement);
int _la;
try {
setState(368);
switch ( getInterpreter().adaptivePredict(_input,31,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(299); declaration();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(300); match(IDENTIFIER);
setState(301); match(T__13);
setState(302); statement();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(303); simpleStmt();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(304); match(T__22);
setState(305); expression(0);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(306); match(T__32);
setState(308);
switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) {
case 1:
{
setState(307); expressionList();
}
break;
}
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(310); match(T__23);
setState(312);
switch ( getInterpreter().adaptivePredict(_input,23,_ctx) ) {
case 1:
{
setState(311); match(IDENTIFIER);
}
break;
}
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(314); match(T__34);
setState(316);
switch ( getInterpreter().adaptivePredict(_input,24,_ctx) ) {
case 1:
{
setState(315); match(IDENTIFIER);
}
break;
}
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(318); match(T__28);
setState(319); match(IDENTIFIER);
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(320); match(T__6);
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(321); block();
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(322); ifStmt();
}
break;
case 12:
enterOuterAlt(_localctx, 12);
{
setState(323); forStmt();
}
break;
case 13:
enterOuterAlt(_localctx, 13);
{
setState(324); match(T__18);
setState(328);
switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
case 1:
{
setState(325); simpleStmt();
setState(326); match(T__30);
}
break;
}
setState(331);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__60) | (1L << T__58) | (1L << T__57) | (1L << T__51) | (1L << T__49) | (1L << T__46) | (1L << T__37) | (1L << T__36) | (1L << T__21) | (1L << T__19) | (1L << T__17) | (1L << T__12) | (1L << T__5) | (1L << T__1) | (1L << IDENTIFIER))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (INT_LIT - 65)) | (1L << (FLOAT_LIT - 65)) | (1L << (IMAGINARY_LIT - 65)) | (1L << (RUNE_LIT - 65)) | (1L << (STRING_LIT - 65)))) != 0)) {
{
setState(330); expression(0);
}
}
setState(333); match(T__55);
setState(337);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__59 || _la==T__15) {
{
{
setState(334); exprCaseClause();
}
}
setState(339);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(340); match(T__27);
}
break;
case 14:
enterOuterAlt(_localctx, 14);
{
setState(341); match(T__18);
setState(345);
switch ( getInterpreter().adaptivePredict(_input,28,_ctx) ) {
case 1:
{
setState(342); simpleStmt();
setState(343); match(T__30);
}
break;
}
setState(347); typeSwitchGuard();
setState(348); match(T__55);
setState(352);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__59 || _la==T__15) {
{
{
setState(349); typeCaseClause();
}
}
setState(354);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(355); match(T__27);
}
break;
case 15:
enterOuterAlt(_localctx, 15);
{
setState(357); match(T__8);
setState(358); match(T__55);
setState(362);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__59 || _la==T__15) {
{
{
setState(359); commClause();
}
}
setState(364);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(365); match(T__27);
}
break;
case 16:
enterOuterAlt(_localctx, 16);
{
setState(366); match(T__20);
setState(367); expression(0);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ForStmtContext extends ParserRuleContext {
public RangeClauseContext rangeClause() {
return getRuleContext(RangeClauseContext.class,0);
}
public ForClauseContext forClause() {
return getRuleContext(ForClauseContext.class,0);
}
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ForStmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forStmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterForStmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitForStmt(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitForStmt(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final ForStmtContext forStmt() throws RecognitionException {
ForStmtContext _localctx = new ForStmtContext(_ctx, getState());
enterRule(_localctx, 44, RULE_forStmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(370); match(T__50);
setState(374);
switch ( getInterpreter().adaptivePredict(_input,32,_ctx) ) {
case 1:
{
setState(371); expression(0);
}
break;
case 2:
{
setState(372); forClause();
}
break;
case 3:
{
setState(373); rangeClause();
}
break;
}
setState(376); block();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SimpleStmtContext extends ParserRuleContext {
public List expressionList() {
return getRuleContexts(ExpressionListContext.class);
}
public IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.class,0);
}
public ExpressionListContext expressionList(int i) {
return getRuleContext(ExpressionListContext.class,i);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionStmtContext expressionStmt() {
return getRuleContext(ExpressionStmtContext.class,0);
}
public SimpleStmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simpleStmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterSimpleStmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitSimpleStmt(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitSimpleStmt(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final SimpleStmtContext simpleStmt() throws RecognitionException {
SimpleStmtContext _localctx = new SimpleStmtContext(_ctx, getState());
enterRule(_localctx, 46, RULE_simpleStmt);
int _la;
try {
setState(398);
switch ( getInterpreter().adaptivePredict(_input,34,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(378); expression(0);
setState(379); match(T__46);
setState(380); expression(0);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(382); expressionStmt();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(383); expression(0);
setState(384);
_la = _input.LA(1);
if ( !(_la==T__40 || _la==T__9) ) {
_errHandler.recoverInline(this);
}
consume();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(386); expressionList();
setState(388);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__53) | (1L << T__51) | (1L << T__37) | (1L << T__35) | (1L << T__33) | (1L << T__29) | (1L << T__19) | (1L << T__17) | (1L << T__10) | (1L << T__4) | (1L << T__1))) != 0)) {
{
setState(387);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__53) | (1L << T__51) | (1L << T__37) | (1L << T__35) | (1L << T__33) | (1L << T__29) | (1L << T__19) | (1L << T__17) | (1L << T__10) | (1L << T__4) | (1L << T__1))) != 0)) ) {
_errHandler.recoverInline(this);
}
consume();
}
}
setState(390); match(T__52);
setState(391); expressionList();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(393); identifierList();
setState(394); match(T__25);
setState(395); expressionList();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(397); match(T__30);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionStmtContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ExpressionStmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressionStmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterExpressionStmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitExpressionStmt(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitExpressionStmt(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final ExpressionStmtContext expressionStmt() throws RecognitionException {
ExpressionStmtContext _localctx = new ExpressionStmtContext(_ctx, getState());
enterRule(_localctx, 48, RULE_expressionStmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(400); expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IfStmtContext extends ParserRuleContext {
public SimpleStmtContext simpleStmt() {
return getRuleContext(SimpleStmtContext.class,0);
}
public BlockContext block(int i) {
return getRuleContext(BlockContext.class,i);
}
public IfStmtContext ifStmt() {
return getRuleContext(IfStmtContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public List block() {
return getRuleContexts(BlockContext.class);
}
public IfStmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ifStmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterIfStmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitIfStmt(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitIfStmt(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final IfStmtContext ifStmt() throws RecognitionException {
IfStmtContext _localctx = new IfStmtContext(_ctx, getState());
enterRule(_localctx, 50, RULE_ifStmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(402); match(T__26);
setState(406);
switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) {
case 1:
{
setState(403); simpleStmt();
setState(404); match(T__30);
}
break;
}
setState(408); expression(0);
setState(409); block();
setState(415);
switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) {
case 1:
{
setState(410); match(T__3);
setState(413);
switch (_input.LA(1)) {
case T__26:
{
setState(411); ifStmt();
}
break;
case T__55:
{
setState(412); block();
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExprCaseClauseContext extends ParserRuleContext {
public StatementListContext statementList() {
return getRuleContext(StatementListContext.class,0);
}
public ExprSwitchCaseContext exprSwitchCase() {
return getRuleContext(ExprSwitchCaseContext.class,0);
}
public ExprCaseClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_exprCaseClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterExprCaseClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitExprCaseClause(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitExprCaseClause(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final ExprCaseClauseContext exprCaseClause() throws RecognitionException {
ExprCaseClauseContext _localctx = new ExprCaseClauseContext(_ctx, getState());
enterRule(_localctx, 52, RULE_exprCaseClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(417); exprSwitchCase();
setState(418); match(T__13);
setState(419); statementList();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExprSwitchCaseContext extends ParserRuleContext {
public ExpressionListContext expressionList() {
return getRuleContext(ExpressionListContext.class,0);
}
public ExprSwitchCaseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_exprSwitchCase; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterExprSwitchCase(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitExprSwitchCase(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitExprSwitchCase(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final ExprSwitchCaseContext exprSwitchCase() throws RecognitionException {
ExprSwitchCaseContext _localctx = new ExprSwitchCaseContext(_ctx, getState());
enterRule(_localctx, 54, RULE_exprSwitchCase);
try {
setState(424);
switch (_input.LA(1)) {
case T__15:
enterOuterAlt(_localctx, 1);
{
setState(421); match(T__15);
setState(422); expressionList();
}
break;
case T__59:
enterOuterAlt(_localctx, 2);
{
setState(423); match(T__59);
}
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 TypeSwitchGuardContext extends ParserRuleContext {
public PrimaryExprContext primaryExpr() {
return getRuleContext(PrimaryExprContext.class,0);
}
public TerminalNode IDENTIFIER() { return getToken(GolangParser.IDENTIFIER, 0); }
public TypeSwitchGuardContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeSwitchGuard; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterTypeSwitchGuard(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitTypeSwitchGuard(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitTypeSwitchGuard(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final TypeSwitchGuardContext typeSwitchGuard() throws RecognitionException {
TypeSwitchGuardContext _localctx = new TypeSwitchGuardContext(_ctx, getState());
enterRule(_localctx, 56, RULE_typeSwitchGuard);
try {
enterOuterAlt(_localctx, 1);
{
setState(428);
switch ( getInterpreter().adaptivePredict(_input,39,_ctx) ) {
case 1:
{
setState(426); match(IDENTIFIER);
setState(427); match(T__25);
}
break;
}
setState(430); primaryExpr(0);
setState(431); match(T__16);
setState(432); match(T__49);
setState(433); match(T__38);
setState(434); match(T__2);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeCaseClauseContext extends ParserRuleContext {
public TypeSwitchCaseContext typeSwitchCase() {
return getRuleContext(TypeSwitchCaseContext.class,0);
}
public StatementListContext statementList() {
return getRuleContext(StatementListContext.class,0);
}
public TypeCaseClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeCaseClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterTypeCaseClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitTypeCaseClause(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitTypeCaseClause(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final TypeCaseClauseContext typeCaseClause() throws RecognitionException {
TypeCaseClauseContext _localctx = new TypeCaseClauseContext(_ctx, getState());
enterRule(_localctx, 58, RULE_typeCaseClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(436); typeSwitchCase();
setState(437); match(T__13);
setState(438); statementList();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeSwitchCaseContext extends ParserRuleContext {
public TypeListContext typeList() {
return getRuleContext(TypeListContext.class,0);
}
public TypeSwitchCaseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeSwitchCase; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterTypeSwitchCase(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitTypeSwitchCase(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitTypeSwitchCase(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final TypeSwitchCaseContext typeSwitchCase() throws RecognitionException {
TypeSwitchCaseContext _localctx = new TypeSwitchCaseContext(_ctx, getState());
enterRule(_localctx, 60, RULE_typeSwitchCase);
try {
setState(443);
switch (_input.LA(1)) {
case T__15:
enterOuterAlt(_localctx, 1);
{
setState(440); match(T__15);
setState(441); typeList();
}
break;
case T__59:
enterOuterAlt(_localctx, 2);
{
setState(442); match(T__59);
}
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 TypeListContext extends ParserRuleContext {
public TypeContext type(int i) {
return getRuleContext(TypeContext.class,i);
}
public List type() {
return getRuleContexts(TypeContext.class);
}
public TypeListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterTypeList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitTypeList(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitTypeList(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final TypeListContext typeList() throws RecognitionException {
TypeListContext _localctx = new TypeListContext(_ctx, getState());
enterRule(_localctx, 62, RULE_typeList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(445); type();
setState(450);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__47) {
{
{
setState(446); match(T__47);
setState(447); type();
}
}
setState(452);
_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 CommClauseContext extends ParserRuleContext {
public CommCaseContext commCase() {
return getRuleContext(CommCaseContext.class,0);
}
public StatementListContext statementList() {
return getRuleContext(StatementListContext.class,0);
}
public CommClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_commClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterCommClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitCommClause(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitCommClause(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final CommClauseContext commClause() throws RecognitionException {
CommClauseContext _localctx = new CommClauseContext(_ctx, getState());
enterRule(_localctx, 64, RULE_commClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(453); commCase();
setState(454); match(T__13);
setState(455); statementList();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CommCaseContext extends ParserRuleContext {
public RecvStmtContext recvStmt() {
return getRuleContext(RecvStmtContext.class,0);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public CommCaseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_commCase; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterCommCase(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitCommCase(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitCommCase(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final CommCaseContext commCase() throws RecognitionException {
CommCaseContext _localctx = new CommCaseContext(_ctx, getState());
enterRule(_localctx, 66, RULE_commCase);
try {
setState(466);
switch (_input.LA(1)) {
case T__15:
enterOuterAlt(_localctx, 1);
{
setState(457); match(T__15);
setState(463);
switch ( getInterpreter().adaptivePredict(_input,42,_ctx) ) {
case 1:
{
setState(458); expression(0);
setState(459); match(T__46);
setState(460); expression(0);
}
break;
case 2:
{
setState(462); recvStmt();
}
break;
}
}
break;
case T__59:
enterOuterAlt(_localctx, 2);
{
setState(465); match(T__59);
}
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 RecvStmtContext extends ParserRuleContext {
public ExpressionListContext expressionList() {
return getRuleContext(ExpressionListContext.class,0);
}
public IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public RecvStmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_recvStmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterRecvStmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitRecvStmt(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitRecvStmt(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final RecvStmtContext recvStmt() throws RecognitionException {
RecvStmtContext _localctx = new RecvStmtContext(_ctx, getState());
enterRule(_localctx, 68, RULE_recvStmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(474);
switch ( getInterpreter().adaptivePredict(_input,44,_ctx) ) {
case 1:
{
setState(468); expressionList();
setState(469); match(T__52);
}
break;
case 2:
{
setState(471); identifierList();
setState(472); match(T__25);
}
break;
}
setState(476); expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ForClauseContext extends ParserRuleContext {
public List simpleStmt() {
return getRuleContexts(SimpleStmtContext.class);
}
public SimpleStmtContext simpleStmt(int i) {
return getRuleContext(SimpleStmtContext.class,i);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ForClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterForClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitForClause(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitForClause(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final ForClauseContext forClause() throws RecognitionException {
ForClauseContext _localctx = new ForClauseContext(_ctx, getState());
enterRule(_localctx, 70, RULE_forClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(479);
switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) {
case 1:
{
setState(478); simpleStmt();
}
break;
}
setState(481); match(T__30);
setState(483);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__60) | (1L << T__58) | (1L << T__57) | (1L << T__51) | (1L << T__49) | (1L << T__46) | (1L << T__37) | (1L << T__36) | (1L << T__21) | (1L << T__19) | (1L << T__17) | (1L << T__12) | (1L << T__5) | (1L << T__1) | (1L << IDENTIFIER))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (INT_LIT - 65)) | (1L << (FLOAT_LIT - 65)) | (1L << (IMAGINARY_LIT - 65)) | (1L << (RUNE_LIT - 65)) | (1L << (STRING_LIT - 65)))) != 0)) {
{
setState(482); expression(0);
}
}
setState(485); match(T__30);
setState(487);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__60) | (1L << T__58) | (1L << T__57) | (1L << T__51) | (1L << T__49) | (1L << T__46) | (1L << T__37) | (1L << T__36) | (1L << T__30) | (1L << T__21) | (1L << T__19) | (1L << T__17) | (1L << T__12) | (1L << T__5) | (1L << T__1) | (1L << IDENTIFIER))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (INT_LIT - 65)) | (1L << (FLOAT_LIT - 65)) | (1L << (IMAGINARY_LIT - 65)) | (1L << (RUNE_LIT - 65)) | (1L << (STRING_LIT - 65)))) != 0)) {
{
setState(486); simpleStmt();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RangeClauseContext extends ParserRuleContext {
public ExpressionListContext expressionList() {
return getRuleContext(ExpressionListContext.class,0);
}
public IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public RangeClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_rangeClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterRangeClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitRangeClause(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitRangeClause(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final RangeClauseContext rangeClause() throws RecognitionException {
RangeClauseContext _localctx = new RangeClauseContext(_ctx, getState());
enterRule(_localctx, 72, RULE_rangeClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(495);
switch ( getInterpreter().adaptivePredict(_input,48,_ctx) ) {
case 1:
{
setState(489); expressionList();
setState(490); match(T__52);
}
break;
case 2:
{
setState(492); identifierList();
setState(493); match(T__25);
}
break;
}
setState(497); match(T__43);
setState(498); expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeContext extends ParserRuleContext {
public TypeNameContext typeName() {
return getRuleContext(TypeNameContext.class,0);
}
public TypeLitContext typeLit() {
return getRuleContext(TypeLitContext.class,0);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public TypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_type; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitType(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitType(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final TypeContext type() throws RecognitionException {
TypeContext _localctx = new TypeContext(_ctx, getState());
enterRule(_localctx, 74, RULE_type);
try {
setState(506);
switch (_input.LA(1)) {
case IDENTIFIER:
enterOuterAlt(_localctx, 1);
{
setState(500); typeName();
}
break;
case T__60:
case T__58:
case T__57:
case T__46:
case T__36:
case T__21:
case T__17:
case T__12:
enterOuterAlt(_localctx, 2);
{
setState(501); typeLit();
}
break;
case T__49:
enterOuterAlt(_localctx, 3);
{
setState(502); match(T__49);
setState(503); type();
setState(504); match(T__2);
}
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 TypeNameContext extends ParserRuleContext {
public QualifiedIdentContext qualifiedIdent() {
return getRuleContext(QualifiedIdentContext.class,0);
}
public TerminalNode IDENTIFIER() { return getToken(GolangParser.IDENTIFIER, 0); }
public TypeNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterTypeName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitTypeName(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitTypeName(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final TypeNameContext typeName() throws RecognitionException {
TypeNameContext _localctx = new TypeNameContext(_ctx, getState());
enterRule(_localctx, 76, RULE_typeName);
try {
setState(510);
switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(508); match(IDENTIFIER);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(509); qualifiedIdent();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeLitContext extends ParserRuleContext {
public ArrayLengthContext arrayLength() {
return getRuleContext(ArrayLengthContext.class,0);
}
public PointerTypeContext pointerType() {
return getRuleContext(PointerTypeContext.class,0);
}
public FunctionTypeContext functionType() {
return getRuleContext(FunctionTypeContext.class,0);
}
public InterfaceTypeContext interfaceType() {
return getRuleContext(InterfaceTypeContext.class,0);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public ElementTypeContext elementType() {
return getRuleContext(ElementTypeContext.class,0);
}
public StructTypeContext structType() {
return getRuleContext(StructTypeContext.class,0);
}
public ChannelTypeContext channelType() {
return getRuleContext(ChannelTypeContext.class,0);
}
public TypeLitContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeLit; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterTypeLit(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitTypeLit(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitTypeLit(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final TypeLitContext typeLit() throws RecognitionException {
TypeLitContext _localctx = new TypeLitContext(_ctx, getState());
enterRule(_localctx, 78, RULE_typeLit);
try {
setState(531);
switch ( getInterpreter().adaptivePredict(_input,51,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(512); match(T__12);
setState(513); arrayLength();
setState(514); match(T__39);
setState(515); elementType();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(517); structType();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(518); pointerType();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(519); functionType();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(520); interfaceType();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(521); match(T__12);
setState(522); match(T__39);
setState(523); elementType();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(524); match(T__21);
setState(525); match(T__12);
setState(526); type();
setState(527); match(T__39);
setState(528); elementType();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(530); channelType();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArrayLengthContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ArrayLengthContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_arrayLength; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterArrayLength(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitArrayLength(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitArrayLength(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final ArrayLengthContext arrayLength() throws RecognitionException {
ArrayLengthContext _localctx = new ArrayLengthContext(_ctx, getState());
enterRule(_localctx, 80, RULE_arrayLength);
try {
enterOuterAlt(_localctx, 1);
{
setState(533); expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ElementTypeContext extends ParserRuleContext {
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public ElementTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_elementType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterElementType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitElementType(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitElementType(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final ElementTypeContext elementType() throws RecognitionException {
ElementTypeContext _localctx = new ElementTypeContext(_ctx, getState());
enterRule(_localctx, 82, RULE_elementType);
try {
enterOuterAlt(_localctx, 1);
{
setState(535); type();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PointerTypeContext extends ParserRuleContext {
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public PointerTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pointerType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterPointerType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitPointerType(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitPointerType(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final PointerTypeContext pointerType() throws RecognitionException {
PointerTypeContext _localctx = new PointerTypeContext(_ctx, getState());
enterRule(_localctx, 84, RULE_pointerType);
try {
enterOuterAlt(_localctx, 1);
{
setState(537); match(T__17);
setState(538); type();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InterfaceTypeContext extends ParserRuleContext {
public List eos() {
return getRuleContexts(EosContext.class);
}
public EosContext eos(int i) {
return getRuleContext(EosContext.class,i);
}
public List methodSpec() {
return getRuleContexts(MethodSpecContext.class);
}
public MethodSpecContext methodSpec(int i) {
return getRuleContext(MethodSpecContext.class,i);
}
public InterfaceTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_interfaceType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterInterfaceType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitInterfaceType(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitInterfaceType(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final InterfaceTypeContext interfaceType() throws RecognitionException {
InterfaceTypeContext _localctx = new InterfaceTypeContext(_ctx, getState());
enterRule(_localctx, 86, RULE_interfaceType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(540); match(T__57);
setState(541); match(T__55);
setState(547);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==IDENTIFIER) {
{
{
setState(542); methodSpec();
setState(543); eos();
}
}
setState(549);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(550); match(T__27);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ChannelTypeContext extends ParserRuleContext {
public ElementTypeContext elementType() {
return getRuleContext(ElementTypeContext.class,0);
}
public ChannelTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_channelType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterChannelType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitChannelType(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitChannelType(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final ChannelTypeContext channelType() throws RecognitionException {
ChannelTypeContext _localctx = new ChannelTypeContext(_ctx, getState());
enterRule(_localctx, 88, RULE_channelType);
try {
enterOuterAlt(_localctx, 1);
{
setState(557);
switch ( getInterpreter().adaptivePredict(_input,53,_ctx) ) {
case 1:
{
setState(552); match(T__60);
}
break;
case 2:
{
setState(553); match(T__60);
setState(554); match(T__46);
}
break;
case 3:
{
setState(555); match(T__46);
setState(556); match(T__60);
}
break;
}
setState(559); elementType();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MethodSpecContext extends ParserRuleContext {
public TypeNameContext typeName() {
return getRuleContext(TypeNameContext.class,0);
}
public SignatureContext signature() {
return getRuleContext(SignatureContext.class,0);
}
public TerminalNode IDENTIFIER() { return getToken(GolangParser.IDENTIFIER, 0); }
public MethodSpecContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_methodSpec; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterMethodSpec(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitMethodSpec(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitMethodSpec(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final MethodSpecContext methodSpec() throws RecognitionException {
MethodSpecContext _localctx = new MethodSpecContext(_ctx, getState());
enterRule(_localctx, 90, RULE_methodSpec);
try {
setState(564);
switch ( getInterpreter().adaptivePredict(_input,54,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(561); match(IDENTIFIER);
setState(562); signature();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(563); typeName();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FunctionTypeContext extends ParserRuleContext {
public SignatureContext signature() {
return getRuleContext(SignatureContext.class,0);
}
public FunctionTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_functionType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterFunctionType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitFunctionType(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitFunctionType(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final FunctionTypeContext functionType() throws RecognitionException {
FunctionTypeContext _localctx = new FunctionTypeContext(_ctx, getState());
enterRule(_localctx, 92, RULE_functionType);
try {
enterOuterAlt(_localctx, 1);
{
setState(566); match(T__58);
setState(567); signature();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SignatureContext extends ParserRuleContext {
public ResultContext result() {
return getRuleContext(ResultContext.class,0);
}
public ParametersContext parameters() {
return getRuleContext(ParametersContext.class,0);
}
public SignatureContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_signature; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterSignature(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitSignature(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitSignature(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final SignatureContext signature() throws RecognitionException {
SignatureContext _localctx = new SignatureContext(_ctx, getState());
enterRule(_localctx, 94, RULE_signature);
try {
enterOuterAlt(_localctx, 1);
{
setState(569); parameters();
setState(571);
switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) {
case 1:
{
setState(570); result();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ResultContext extends ParserRuleContext {
public ParametersContext parameters() {
return getRuleContext(ParametersContext.class,0);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public ResultContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_result; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterResult(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitResult(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitResult(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final ResultContext result() throws RecognitionException {
ResultContext _localctx = new ResultContext(_ctx, getState());
enterRule(_localctx, 96, RULE_result);
try {
setState(575);
switch ( getInterpreter().adaptivePredict(_input,56,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(573); parameters();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(574); type();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ParametersContext extends ParserRuleContext {
public ParameterListContext parameterList() {
return getRuleContext(ParameterListContext.class,0);
}
public ParametersContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parameters; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterParameters(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitParameters(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitParameters(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final ParametersContext parameters() throws RecognitionException {
ParametersContext _localctx = new ParametersContext(_ctx, getState());
enterRule(_localctx, 98, RULE_parameters);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(577); match(T__49);
setState(582);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__60) | (1L << T__58) | (1L << T__57) | (1L << T__49) | (1L << T__46) | (1L << T__36) | (1L << T__21) | (1L << T__17) | (1L << T__14) | (1L << T__12) | (1L << IDENTIFIER))) != 0)) {
{
setState(578); parameterList();
setState(580);
_la = _input.LA(1);
if (_la==T__47) {
{
setState(579); match(T__47);
}
}
}
}
setState(584); match(T__2);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ParameterListContext extends ParserRuleContext {
public ParameterDeclContext parameterDecl(int i) {
return getRuleContext(ParameterDeclContext.class,i);
}
public List parameterDecl() {
return getRuleContexts(ParameterDeclContext.class);
}
public ParameterListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parameterList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterParameterList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitParameterList(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitParameterList(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final ParameterListContext parameterList() throws RecognitionException {
ParameterListContext _localctx = new ParameterListContext(_ctx, getState());
enterRule(_localctx, 100, RULE_parameterList);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(586); parameterDecl();
setState(591);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,59,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(587); match(T__47);
setState(588); parameterDecl();
}
}
}
setState(593);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,59,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ParameterDeclContext extends ParserRuleContext {
public IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.class,0);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public ParameterDeclContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parameterDecl; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterParameterDecl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitParameterDecl(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitParameterDecl(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final ParameterDeclContext parameterDecl() throws RecognitionException {
ParameterDeclContext _localctx = new ParameterDeclContext(_ctx, getState());
enterRule(_localctx, 102, RULE_parameterDecl);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(595);
switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) {
case 1:
{
setState(594); identifierList();
}
break;
}
setState(598);
_la = _input.LA(1);
if (_la==T__14) {
{
setState(597); match(T__14);
}
}
setState(600); type();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OperandContext extends ParserRuleContext {
public MethodExprContext methodExpr() {
return getRuleContext(MethodExprContext.class,0);
}
public LiteralContext literal() {
return getRuleContext(LiteralContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public OperandNameContext operandName() {
return getRuleContext(OperandNameContext.class,0);
}
public OperandContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_operand; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterOperand(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitOperand(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitOperand(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final OperandContext operand() throws RecognitionException {
OperandContext _localctx = new OperandContext(_ctx, getState());
enterRule(_localctx, 104, RULE_operand);
try {
setState(609);
switch ( getInterpreter().adaptivePredict(_input,62,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(602); literal();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(603); operandName();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(604); methodExpr();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(605); match(T__49);
setState(606); expression(0);
setState(607); match(T__2);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LiteralContext extends ParserRuleContext {
public TerminalNode INT_LIT() { return getToken(GolangParser.INT_LIT, 0); }
public TerminalNode IMAGINARY_LIT() { return getToken(GolangParser.IMAGINARY_LIT, 0); }
public LiteralTypeContext literalType() {
return getRuleContext(LiteralTypeContext.class,0);
}
public List keyedElement() {
return getRuleContexts(KeyedElementContext.class);
}
public KeyedElementContext keyedElement(int i) {
return getRuleContext(KeyedElementContext.class,i);
}
public TerminalNode STRING_LIT() { return getToken(GolangParser.STRING_LIT, 0); }
public TerminalNode RUNE_LIT() { return getToken(GolangParser.RUNE_LIT, 0); }
public TerminalNode FLOAT_LIT() { return getToken(GolangParser.FLOAT_LIT, 0); }
public FunctionContext function() {
return getRuleContext(FunctionContext.class,0);
}
public LiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_literal; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitLiteral(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitLiteral(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final LiteralContext literal() throws RecognitionException {
LiteralContext _localctx = new LiteralContext(_ctx, getState());
enterRule(_localctx, 106, RULE_literal);
int _la;
try {
int _alt;
setState(631);
switch (_input.LA(1)) {
case INT_LIT:
case FLOAT_LIT:
case IMAGINARY_LIT:
case RUNE_LIT:
case STRING_LIT:
enterOuterAlt(_localctx, 1);
{
setState(611);
_la = _input.LA(1);
if ( !(((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (INT_LIT - 65)) | (1L << (FLOAT_LIT - 65)) | (1L << (IMAGINARY_LIT - 65)) | (1L << (RUNE_LIT - 65)) | (1L << (STRING_LIT - 65)))) != 0)) ) {
_errHandler.recoverInline(this);
}
consume();
}
break;
case T__36:
case T__21:
case T__12:
case IDENTIFIER:
enterOuterAlt(_localctx, 2);
{
setState(612); literalType();
setState(613); match(T__55);
setState(625);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__60) | (1L << T__58) | (1L << T__57) | (1L << T__55) | (1L << T__51) | (1L << T__49) | (1L << T__46) | (1L << T__37) | (1L << T__36) | (1L << T__21) | (1L << T__19) | (1L << T__17) | (1L << T__12) | (1L << T__5) | (1L << T__1) | (1L << IDENTIFIER))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (INT_LIT - 65)) | (1L << (FLOAT_LIT - 65)) | (1L << (IMAGINARY_LIT - 65)) | (1L << (RUNE_LIT - 65)) | (1L << (STRING_LIT - 65)))) != 0)) {
{
setState(614); keyedElement();
setState(619);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,63,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(615); match(T__47);
setState(616); keyedElement();
}
}
}
setState(621);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,63,_ctx);
}
setState(623);
_la = _input.LA(1);
if (_la==T__47) {
{
setState(622); match(T__47);
}
}
}
}
setState(627); match(T__27);
}
break;
case T__58:
enterOuterAlt(_localctx, 3);
{
setState(629); match(T__58);
setState(630); function();
}
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 OperandNameContext extends ParserRuleContext {
public QualifiedIdentContext qualifiedIdent() {
return getRuleContext(QualifiedIdentContext.class,0);
}
public TerminalNode IDENTIFIER() { return getToken(GolangParser.IDENTIFIER, 0); }
public OperandNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_operandName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterOperandName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitOperandName(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitOperandName(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final OperandNameContext operandName() throws RecognitionException {
OperandNameContext _localctx = new OperandNameContext(_ctx, getState());
enterRule(_localctx, 108, RULE_operandName);
try {
setState(635);
switch ( getInterpreter().adaptivePredict(_input,67,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(633); match(IDENTIFIER);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(634); qualifiedIdent();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class QualifiedIdentContext extends ParserRuleContext {
public TerminalNode IDENTIFIER(int i) {
return getToken(GolangParser.IDENTIFIER, i);
}
public List IDENTIFIER() { return getTokens(GolangParser.IDENTIFIER); }
public QualifiedIdentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_qualifiedIdent; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterQualifiedIdent(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitQualifiedIdent(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitQualifiedIdent(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final QualifiedIdentContext qualifiedIdent() throws RecognitionException {
QualifiedIdentContext _localctx = new QualifiedIdentContext(_ctx, getState());
enterRule(_localctx, 110, RULE_qualifiedIdent);
try {
enterOuterAlt(_localctx, 1);
{
setState(637); match(IDENTIFIER);
setState(638); match(T__16);
setState(639); match(IDENTIFIER);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LiteralTypeContext extends ParserRuleContext {
public ArrayLengthContext arrayLength() {
return getRuleContext(ArrayLengthContext.class,0);
}
public TypeNameContext typeName() {
return getRuleContext(TypeNameContext.class,0);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public StructTypeContext structType() {
return getRuleContext(StructTypeContext.class,0);
}
public ElementTypeContext elementType() {
return getRuleContext(ElementTypeContext.class,0);
}
public LiteralTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_literalType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterLiteralType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitLiteralType(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitLiteralType(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final LiteralTypeContext literalType() throws RecognitionException {
LiteralTypeContext _localctx = new LiteralTypeContext(_ctx, getState());
enterRule(_localctx, 112, RULE_literalType);
try {
setState(661);
switch ( getInterpreter().adaptivePredict(_input,68,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(641); structType();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(642); match(T__12);
setState(643); arrayLength();
setState(644); match(T__39);
setState(645); elementType();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(647); match(T__12);
setState(648); match(T__14);
setState(649); match(T__39);
setState(650); elementType();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(651); match(T__12);
setState(652); match(T__39);
setState(653); elementType();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(654); match(T__21);
setState(655); match(T__12);
setState(656); type();
setState(657); match(T__39);
setState(658); elementType();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(660); typeName();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class KeyedElementContext extends ParserRuleContext {
public ElementContext element() {
return getRuleContext(ElementContext.class,0);
}
public KeyContext key() {
return getRuleContext(KeyContext.class,0);
}
public KeyedElementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_keyedElement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterKeyedElement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitKeyedElement(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitKeyedElement(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final KeyedElementContext keyedElement() throws RecognitionException {
KeyedElementContext _localctx = new KeyedElementContext(_ctx, getState());
enterRule(_localctx, 114, RULE_keyedElement);
try {
enterOuterAlt(_localctx, 1);
{
setState(666);
switch ( getInterpreter().adaptivePredict(_input,69,_ctx) ) {
case 1:
{
setState(663); key();
setState(664); match(T__13);
}
break;
}
setState(668); element();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class KeyContext extends ParserRuleContext {
public List keyedElement() {
return getRuleContexts(KeyedElementContext.class);
}
public KeyedElementContext keyedElement(int i) {
return getRuleContext(KeyedElementContext.class,i);
}
public TerminalNode IDENTIFIER() { return getToken(GolangParser.IDENTIFIER, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public KeyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_key; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterKey(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitKey(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitKey(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final KeyContext key() throws RecognitionException {
KeyContext _localctx = new KeyContext(_ctx, getState());
enterRule(_localctx, 116, RULE_key);
int _la;
try {
int _alt;
setState(687);
switch ( getInterpreter().adaptivePredict(_input,73,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(670); match(IDENTIFIER);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(671); expression(0);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(672); match(T__55);
setState(684);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__60) | (1L << T__58) | (1L << T__57) | (1L << T__55) | (1L << T__51) | (1L << T__49) | (1L << T__46) | (1L << T__37) | (1L << T__36) | (1L << T__21) | (1L << T__19) | (1L << T__17) | (1L << T__12) | (1L << T__5) | (1L << T__1) | (1L << IDENTIFIER))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (INT_LIT - 65)) | (1L << (FLOAT_LIT - 65)) | (1L << (IMAGINARY_LIT - 65)) | (1L << (RUNE_LIT - 65)) | (1L << (STRING_LIT - 65)))) != 0)) {
{
setState(673); keyedElement();
setState(678);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,70,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(674); match(T__47);
setState(675); keyedElement();
}
}
}
setState(680);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,70,_ctx);
}
setState(682);
_la = _input.LA(1);
if (_la==T__47) {
{
setState(681); match(T__47);
}
}
}
}
setState(686); match(T__27);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ElementContext extends ParserRuleContext {
public List keyedElement() {
return getRuleContexts(KeyedElementContext.class);
}
public KeyedElementContext keyedElement(int i) {
return getRuleContext(KeyedElementContext.class,i);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ElementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_element; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterElement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitElement(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitElement(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final ElementContext element() throws RecognitionException {
ElementContext _localctx = new ElementContext(_ctx, getState());
enterRule(_localctx, 118, RULE_element);
int _la;
try {
int _alt;
setState(705);
switch (_input.LA(1)) {
case T__60:
case T__58:
case T__57:
case T__51:
case T__49:
case T__46:
case T__37:
case T__36:
case T__21:
case T__19:
case T__17:
case T__12:
case T__5:
case T__1:
case IDENTIFIER:
case INT_LIT:
case FLOAT_LIT:
case IMAGINARY_LIT:
case RUNE_LIT:
case STRING_LIT:
enterOuterAlt(_localctx, 1);
{
setState(689); expression(0);
}
break;
case T__55:
enterOuterAlt(_localctx, 2);
{
setState(690); match(T__55);
setState(702);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__60) | (1L << T__58) | (1L << T__57) | (1L << T__55) | (1L << T__51) | (1L << T__49) | (1L << T__46) | (1L << T__37) | (1L << T__36) | (1L << T__21) | (1L << T__19) | (1L << T__17) | (1L << T__12) | (1L << T__5) | (1L << T__1) | (1L << IDENTIFIER))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (INT_LIT - 65)) | (1L << (FLOAT_LIT - 65)) | (1L << (IMAGINARY_LIT - 65)) | (1L << (RUNE_LIT - 65)) | (1L << (STRING_LIT - 65)))) != 0)) {
{
setState(691); keyedElement();
setState(696);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,74,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(692); match(T__47);
setState(693); keyedElement();
}
}
}
setState(698);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,74,_ctx);
}
setState(700);
_la = _input.LA(1);
if (_la==T__47) {
{
setState(699); match(T__47);
}
}
}
}
setState(704); match(T__27);
}
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 StructTypeContext extends ParserRuleContext {
public List fieldDecl() {
return getRuleContexts(FieldDeclContext.class);
}
public FieldDeclContext fieldDecl(int i) {
return getRuleContext(FieldDeclContext.class,i);
}
public List eos() {
return getRuleContexts(EosContext.class);
}
public EosContext eos(int i) {
return getRuleContext(EosContext.class,i);
}
public StructTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_structType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterStructType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitStructType(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitStructType(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final StructTypeContext structType() throws RecognitionException {
StructTypeContext _localctx = new StructTypeContext(_ctx, getState());
enterRule(_localctx, 120, RULE_structType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(707); match(T__36);
setState(708); match(T__55);
setState(714);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__17 || _la==IDENTIFIER) {
{
{
setState(709); fieldDecl();
setState(710); eos();
}
}
setState(716);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(717); match(T__27);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FieldDeclContext extends ParserRuleContext {
public IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.class,0);
}
public AnonymousFieldContext anonymousField() {
return getRuleContext(AnonymousFieldContext.class,0);
}
public TerminalNode STRING_LIT() { return getToken(GolangParser.STRING_LIT, 0); }
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public FieldDeclContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fieldDecl; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterFieldDecl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitFieldDecl(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitFieldDecl(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final FieldDeclContext fieldDecl() throws RecognitionException {
FieldDeclContext _localctx = new FieldDeclContext(_ctx, getState());
enterRule(_localctx, 122, RULE_fieldDecl);
try {
enterOuterAlt(_localctx, 1);
{
setState(723);
switch ( getInterpreter().adaptivePredict(_input,79,_ctx) ) {
case 1:
{
setState(719); identifierList();
setState(720); type();
}
break;
case 2:
{
setState(722); anonymousField();
}
break;
}
setState(726);
switch ( getInterpreter().adaptivePredict(_input,80,_ctx) ) {
case 1:
{
setState(725); match(STRING_LIT);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AnonymousFieldContext extends ParserRuleContext {
public TypeNameContext typeName() {
return getRuleContext(TypeNameContext.class,0);
}
public AnonymousFieldContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_anonymousField; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterAnonymousField(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitAnonymousField(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitAnonymousField(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final AnonymousFieldContext anonymousField() throws RecognitionException {
AnonymousFieldContext _localctx = new AnonymousFieldContext(_ctx, getState());
enterRule(_localctx, 124, RULE_anonymousField);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(729);
_la = _input.LA(1);
if (_la==T__17) {
{
setState(728); match(T__17);
}
}
setState(731); typeName();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PrimaryExprContext extends ParserRuleContext {
public PrimaryExprContext primaryExpr() {
return getRuleContext(PrimaryExprContext.class,0);
}
public ExpressionListContext expressionList() {
return getRuleContext(ExpressionListContext.class,0);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public OperandContext operand() {
return getRuleContext(OperandContext.class,0);
}
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public TerminalNode IDENTIFIER() { return getToken(GolangParser.IDENTIFIER, 0); }
public PrimaryExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primaryExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterPrimaryExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitPrimaryExpr(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitPrimaryExpr(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final PrimaryExprContext primaryExpr() throws RecognitionException {
return primaryExpr(0);
}
private PrimaryExprContext primaryExpr(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
PrimaryExprContext _localctx = new PrimaryExprContext(_ctx, _parentState);
PrimaryExprContext _prevctx = _localctx;
int _startState = 126;
enterRecursionRule(_localctx, 126, RULE_primaryExpr, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(743);
switch ( getInterpreter().adaptivePredict(_input,83,_ctx) ) {
case 1:
{
setState(734); operand();
}
break;
case 2:
{
setState(735); type();
setState(736); match(T__49);
setState(737); expression(0);
setState(739);
_la = _input.LA(1);
if (_la==T__47) {
{
setState(738); match(T__47);
}
}
setState(741); match(T__2);
}
break;
}
_ctx.stop = _input.LT(-1);
setState(800);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,94,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(798);
switch ( getInterpreter().adaptivePredict(_input,93,_ctx) ) {
case 1:
{
_localctx = new PrimaryExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_primaryExpr);
setState(745);
if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
setState(746); match(T__16);
setState(747); match(IDENTIFIER);
}
break;
case 2:
{
_localctx = new PrimaryExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_primaryExpr);
setState(748);
if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
setState(749); match(T__12);
setState(750); expression(0);
setState(751); match(T__39);
}
break;
case 3:
{
_localctx = new PrimaryExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_primaryExpr);
setState(753);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(754); match(T__12);
setState(770);
switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) {
case 1:
{
{
setState(756);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__60) | (1L << T__58) | (1L << T__57) | (1L << T__51) | (1L << T__49) | (1L << T__46) | (1L << T__37) | (1L << T__36) | (1L << T__21) | (1L << T__19) | (1L << T__17) | (1L << T__12) | (1L << T__5) | (1L << T__1) | (1L << IDENTIFIER))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (INT_LIT - 65)) | (1L << (FLOAT_LIT - 65)) | (1L << (IMAGINARY_LIT - 65)) | (1L << (RUNE_LIT - 65)) | (1L << (STRING_LIT - 65)))) != 0)) {
{
setState(755); expression(0);
}
}
setState(758); match(T__13);
setState(760);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__60) | (1L << T__58) | (1L << T__57) | (1L << T__51) | (1L << T__49) | (1L << T__46) | (1L << T__37) | (1L << T__36) | (1L << T__21) | (1L << T__19) | (1L << T__17) | (1L << T__12) | (1L << T__5) | (1L << T__1) | (1L << IDENTIFIER))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (INT_LIT - 65)) | (1L << (FLOAT_LIT - 65)) | (1L << (IMAGINARY_LIT - 65)) | (1L << (RUNE_LIT - 65)) | (1L << (STRING_LIT - 65)))) != 0)) {
{
setState(759); expression(0);
}
}
}
}
break;
case 2:
{
{
setState(763);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__60) | (1L << T__58) | (1L << T__57) | (1L << T__51) | (1L << T__49) | (1L << T__46) | (1L << T__37) | (1L << T__36) | (1L << T__21) | (1L << T__19) | (1L << T__17) | (1L << T__12) | (1L << T__5) | (1L << T__1) | (1L << IDENTIFIER))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (INT_LIT - 65)) | (1L << (FLOAT_LIT - 65)) | (1L << (IMAGINARY_LIT - 65)) | (1L << (RUNE_LIT - 65)) | (1L << (STRING_LIT - 65)))) != 0)) {
{
setState(762); expression(0);
}
}
setState(765); match(T__13);
setState(766); expression(0);
setState(767); match(T__13);
setState(768); expression(0);
}
}
break;
}
setState(772); match(T__39);
}
break;
case 4:
{
_localctx = new PrimaryExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_primaryExpr);
setState(773);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(774); match(T__16);
setState(775); match(T__49);
setState(776); type();
setState(777); match(T__2);
}
break;
case 5:
{
_localctx = new PrimaryExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_primaryExpr);
setState(779);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(780); match(T__49);
setState(795);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__60) | (1L << T__58) | (1L << T__57) | (1L << T__51) | (1L << T__49) | (1L << T__46) | (1L << T__37) | (1L << T__36) | (1L << T__21) | (1L << T__19) | (1L << T__17) | (1L << T__12) | (1L << T__5) | (1L << T__1) | (1L << IDENTIFIER))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (INT_LIT - 65)) | (1L << (FLOAT_LIT - 65)) | (1L << (IMAGINARY_LIT - 65)) | (1L << (RUNE_LIT - 65)) | (1L << (STRING_LIT - 65)))) != 0)) {
{
setState(787);
switch ( getInterpreter().adaptivePredict(_input,89,_ctx) ) {
case 1:
{
setState(781); expressionList();
}
break;
case 2:
{
setState(782); type();
setState(785);
switch ( getInterpreter().adaptivePredict(_input,88,_ctx) ) {
case 1:
{
setState(783); match(T__47);
setState(784); expressionList();
}
break;
}
}
break;
}
setState(790);
_la = _input.LA(1);
if (_la==T__14) {
{
setState(789); match(T__14);
}
}
setState(793);
_la = _input.LA(1);
if (_la==T__47) {
{
setState(792); match(T__47);
}
}
}
}
setState(797); match(T__2);
}
break;
}
}
}
setState(802);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,94,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class MethodExprContext extends ParserRuleContext {
public ReceiverTypeContext receiverType() {
return getRuleContext(ReceiverTypeContext.class,0);
}
public TerminalNode IDENTIFIER() { return getToken(GolangParser.IDENTIFIER, 0); }
public MethodExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_methodExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterMethodExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitMethodExpr(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitMethodExpr(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final MethodExprContext methodExpr() throws RecognitionException {
MethodExprContext _localctx = new MethodExprContext(_ctx, getState());
enterRule(_localctx, 128, RULE_methodExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(803); receiverType();
setState(804); match(T__16);
setState(805); match(IDENTIFIER);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ReceiverTypeContext extends ParserRuleContext {
public ReceiverTypeContext receiverType() {
return getRuleContext(ReceiverTypeContext.class,0);
}
public TypeNameContext typeName() {
return getRuleContext(TypeNameContext.class,0);
}
public ReceiverTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_receiverType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterReceiverType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitReceiverType(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitReceiverType(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final ReceiverTypeContext receiverType() throws RecognitionException {
ReceiverTypeContext _localctx = new ReceiverTypeContext(_ctx, getState());
enterRule(_localctx, 130, RULE_receiverType);
try {
setState(817);
switch ( getInterpreter().adaptivePredict(_input,95,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(807); typeName();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(808); match(T__49);
setState(809); match(T__17);
setState(810); typeName();
setState(811); match(T__2);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(813); match(T__49);
setState(814); receiverType();
setState(815); match(T__2);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionContext extends ParserRuleContext {
public UnaryExprContext unaryExpr() {
return getRuleContext(UnaryExprContext.class,0);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitExpression(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitExpression(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final ExpressionContext expression() throws RecognitionException {
return expression(0);
}
private ExpressionContext expression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ExpressionContext _localctx = new ExpressionContext(_ctx, _parentState);
ExpressionContext _prevctx = _localctx;
int _startState = 132;
enterRecursionRule(_localctx, 132, RULE_expression, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(820); unaryExpr();
}
_ctx.stop = _input.LT(-1);
setState(827);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,96,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(822);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(823);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__56) | (1L << T__54) | (1L << T__53) | (1L << T__51) | (1L << T__42) | (1L << T__41) | (1L << T__37) | (1L << T__35) | (1L << T__33) | (1L << T__31) | (1L << T__29) | (1L << T__24) | (1L << T__19) | (1L << T__17) | (1L << T__11) | (1L << T__10) | (1L << T__7) | (1L << T__4) | (1L << T__1))) != 0)) ) {
_errHandler.recoverInline(this);
}
consume();
setState(824); expression(2);
}
}
}
setState(829);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,96,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class UnaryExprContext extends ParserRuleContext {
public UnaryExprContext unaryExpr() {
return getRuleContext(UnaryExprContext.class,0);
}
public PrimaryExprContext primaryExpr() {
return getRuleContext(PrimaryExprContext.class,0);
}
public UnaryExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unaryExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterUnaryExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitUnaryExpr(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitUnaryExpr(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final UnaryExprContext unaryExpr() throws RecognitionException {
UnaryExprContext _localctx = new UnaryExprContext(_ctx, getState());
enterRule(_localctx, 134, RULE_unaryExpr);
int _la;
try {
setState(833);
switch ( getInterpreter().adaptivePredict(_input,97,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(830); primaryExpr(0);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(831);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__51) | (1L << T__46) | (1L << T__37) | (1L << T__19) | (1L << T__17) | (1L << T__5) | (1L << T__1))) != 0)) ) {
_errHandler.recoverInline(this);
}
consume();
setState(832); unaryExpr();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EosContext extends ParserRuleContext {
public TerminalNode EOF() { return getToken(GolangParser.EOF, 0); }
public EosContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_eos; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).enterEos(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof GolangListener ) ((GolangListener)listener).exitEos(this);
}
@Override
public Result accept(ParseTreeVisitor visitor) {
if ( visitor instanceof GolangVisitor ) return ((GolangVisitor)visitor).visitEos(this);
else return visitor.visitChildren(this);
}
}
@RuleVersion(0)
public final EosContext eos() throws RecognitionException {
EosContext _localctx = new EosContext(_ctx, getState());
enterRule(_localctx, 136, RULE_eos);
try {
setState(839);
switch ( getInterpreter().adaptivePredict(_input,98,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(835); match(T__30);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(836); match(EOF);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(837);
if (!(lineTerminatorAhead())) throw new FailedPredicateException(this, "lineTerminatorAhead()");
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(838);
if (!(_input.LT(1).getText().equals("}") )) throw new FailedPredicateException(this, "_input.LT(1).getText().equals(\"}\") ");
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
switch (ruleIndex) {
case 63: return primaryExpr_sempred((PrimaryExprContext)_localctx, predIndex);
case 66: return expression_sempred((ExpressionContext)_localctx, predIndex);
case 68: return eos_sempred((EosContext)_localctx, predIndex);
}
return true;
}
private boolean expression_sempred(ExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 5: return precpred(_ctx, 1);
}
return true;
}
private boolean primaryExpr_sempred(PrimaryExprContext _localctx, int predIndex) {
switch (predIndex) {
case 0: return precpred(_ctx, 5);
case 1: return precpred(_ctx, 4);
case 2: return precpred(_ctx, 3);
case 3: return precpred(_ctx, 2);
case 4: return precpred(_ctx, 1);
}
return true;
}
private boolean eos_sempred(EosContext _localctx, int predIndex) {
switch (predIndex) {
case 6: return lineTerminatorAhead();
case 7: return _input.LT(1).getText().equals("}") ;
}
return true;
}
public static final String _serializedATN =
"\3\uaf6f\u8320\u479d\ub75c\u4880\u1605\u191c\uab37\3M\u034c\4\2\t\2\4"+
"\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
"\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+
"\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+
"\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\3\2\3\2\3\2\3\2"+
"\3\2\7\2\u0092\n\2\f\2\16\2\u0095\13\2\3\2\3\2\3\2\7\2\u009a\n\2\f\2\16"+
"\2\u009d\13\2\3\3\3\3\3\3\3\4\3\4\3\4\3\4\3\4\3\4\7\4\u00a8\n\4\f\4\16"+
"\4\u00ab\13\4\3\4\5\4\u00ae\n\4\3\5\5\5\u00b1\n\5\3\5\3\5\3\6\3\6\3\7"+
"\3\7\3\7\5\7\u00ba\n\7\3\b\3\b\3\b\5\b\u00bf\n\b\3\t\3\t\3\t\3\t\3\t\3"+
"\t\7\t\u00c7\n\t\f\t\16\t\u00ca\13\t\3\t\5\t\u00cd\n\t\3\n\3\n\5\n\u00d1"+
"\n\n\3\n\3\n\5\n\u00d5\n\n\3\13\3\13\3\13\7\13\u00da\n\13\f\13\16\13\u00dd"+
"\13\13\3\f\3\f\3\f\7\f\u00e2\n\f\f\f\16\f\u00e5\13\f\3\r\3\r\3\r\3\r\3"+
"\r\3\r\7\r\u00ed\n\r\f\r\16\r\u00f0\13\r\3\r\5\r\u00f3\n\r\3\16\3\16\3"+
"\16\3\17\3\17\3\17\3\17\5\17\u00fc\n\17\3\20\3\20\3\20\3\21\3\21\3\21"+
"\3\21\3\21\5\21\u0106\n\21\3\22\3\22\3\23\3\23\3\23\3\23\3\23\3\23\7\23"+
"\u0110\n\23\f\23\16\23\u0113\13\23\3\23\5\23\u0116\n\23\3\24\3\24\3\24"+
"\3\24\5\24\u011c\n\24\3\24\3\24\5\24\u0120\n\24\3\25\3\25\3\25\3\25\3"+
"\26\3\26\3\26\7\26\u0129\n\26\f\26\16\26\u012c\13\26\3\27\3\27\3\27\3"+
"\27\3\27\3\27\3\27\3\27\3\27\5\27\u0137\n\27\3\27\3\27\5\27\u013b\n\27"+
"\3\27\3\27\5\27\u013f\n\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27"+
"\3\27\5\27\u014b\n\27\3\27\5\27\u014e\n\27\3\27\3\27\7\27\u0152\n\27\f"+
"\27\16\27\u0155\13\27\3\27\3\27\3\27\3\27\3\27\5\27\u015c\n\27\3\27\3"+
"\27\3\27\7\27\u0161\n\27\f\27\16\27\u0164\13\27\3\27\3\27\3\27\3\27\3"+
"\27\7\27\u016b\n\27\f\27\16\27\u016e\13\27\3\27\3\27\3\27\5\27\u0173\n"+
"\27\3\30\3\30\3\30\3\30\5\30\u0179\n\30\3\30\3\30\3\31\3\31\3\31\3\31"+
"\3\31\3\31\3\31\3\31\3\31\3\31\5\31\u0187\n\31\3\31\3\31\3\31\3\31\3\31"+
"\3\31\3\31\3\31\5\31\u0191\n\31\3\32\3\32\3\33\3\33\3\33\3\33\5\33\u0199"+
"\n\33\3\33\3\33\3\33\3\33\3\33\5\33\u01a0\n\33\5\33\u01a2\n\33\3\34\3"+
"\34\3\34\3\34\3\35\3\35\3\35\5\35\u01ab\n\35\3\36\3\36\5\36\u01af\n\36"+
"\3\36\3\36\3\36\3\36\3\36\3\36\3\37\3\37\3\37\3\37\3 \3 \3 \5 \u01be\n"+
" \3!\3!\3!\7!\u01c3\n!\f!\16!\u01c6\13!\3\"\3\"\3\"\3\"\3#\3#\3#\3#\3"+
"#\3#\5#\u01d2\n#\3#\5#\u01d5\n#\3$\3$\3$\3$\3$\3$\5$\u01dd\n$\3$\3$\3"+
"%\5%\u01e2\n%\3%\3%\5%\u01e6\n%\3%\3%\5%\u01ea\n%\3&\3&\3&\3&\3&\3&\5"+
"&\u01f2\n&\3&\3&\3&\3\'\3\'\3\'\3\'\3\'\3\'\5\'\u01fd\n\'\3(\3(\5(\u0201"+
"\n(\3)\3)\3)\3)\3)\3)\3)\3)\3)\3)\3)\3)\3)\3)\3)\3)\3)\3)\3)\5)\u0216"+
"\n)\3*\3*\3+\3+\3,\3,\3,\3-\3-\3-\3-\3-\7-\u0224\n-\f-\16-\u0227\13-\3"+
"-\3-\3.\3.\3.\3.\3.\5.\u0230\n.\3.\3.\3/\3/\3/\5/\u0237\n/\3\60\3\60\3"+
"\60\3\61\3\61\5\61\u023e\n\61\3\62\3\62\5\62\u0242\n\62\3\63\3\63\3\63"+
"\5\63\u0247\n\63\5\63\u0249\n\63\3\63\3\63\3\64\3\64\3\64\7\64\u0250\n"+
"\64\f\64\16\64\u0253\13\64\3\65\5\65\u0256\n\65\3\65\5\65\u0259\n\65\3"+
"\65\3\65\3\66\3\66\3\66\3\66\3\66\3\66\3\66\5\66\u0264\n\66\3\67\3\67"+
"\3\67\3\67\3\67\3\67\7\67\u026c\n\67\f\67\16\67\u026f\13\67\3\67\5\67"+
"\u0272\n\67\5\67\u0274\n\67\3\67\3\67\3\67\3\67\5\67\u027a\n\67\38\38"+
"\58\u027e\n8\39\39\39\39\3:\3:\3:\3:\3:\3:\3:\3:\3:\3:\3:\3:\3:\3:\3:"+
"\3:\3:\3:\3:\3:\5:\u0298\n:\3;\3;\3;\5;\u029d\n;\3;\3;\3<\3<\3<\3<\3<"+
"\3<\7<\u02a7\n<\f<\16<\u02aa\13<\3<\5<\u02ad\n<\5<\u02af\n<\3<\5<\u02b2"+
"\n<\3=\3=\3=\3=\3=\7=\u02b9\n=\f=\16=\u02bc\13=\3=\5=\u02bf\n=\5=\u02c1"+
"\n=\3=\5=\u02c4\n=\3>\3>\3>\3>\3>\7>\u02cb\n>\f>\16>\u02ce\13>\3>\3>\3"+
"?\3?\3?\3?\5?\u02d6\n?\3?\5?\u02d9\n?\3@\5@\u02dc\n@\3@\3@\3A\3A\3A\3"+
"A\3A\3A\5A\u02e6\nA\3A\3A\5A\u02ea\nA\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3"+
"A\5A\u02f7\nA\3A\3A\5A\u02fb\nA\3A\5A\u02fe\nA\3A\3A\3A\3A\3A\5A\u0305"+
"\nA\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\5A\u0314\nA\5A\u0316\nA\3A"+
"\5A\u0319\nA\3A\5A\u031c\nA\5A\u031e\nA\3A\7A\u0321\nA\fA\16A\u0324\13"+
"A\3B\3B\3B\3B\3C\3C\3C\3C\3C\3C\3C\3C\3C\3C\5C\u0334\nC\3D\3D\3D\3D\3"+
"D\3D\7D\u033c\nD\fD\16D\u033f\13D\3E\3E\3E\5E\u0344\nE\3F\3F\3F\3F\5F"+
"\u034a\nF\3F\2\2\4\u0080\u0086G\2\2\4\2\6\2\b\2\n\2\f\2\16\2\20\2\22\2"+
"\24\2\26\2\30\2\32\2\34\2\36\2 \2\"\2$\2&\2(\2*\2,\2.\2\60\2\62\2\64\2"+
"\66\28\2:\2<\2>\2@\2B\2D\2F\2H\2J\2L\2N\2P\2R\2T\2V\2X\2Z\2\\\2^\2`\2"+
"b\2d\2f\2h\2j\2l\2n\2p\2r\2t\2v\2x\2z\2|\2~\2\u0080\2\u0082\2\u0084\2"+
"\u0086\2\u0088\2\u008a\2\2\b\4\2//@@\4\2\27\27\66\66\r\2\n\n\f\f\32\32"+
"\34\34\36\36\"\",,..\65\65;;>>\4\2CFII\22\2\7\7\t\n\f\f\25\26\32\32\34"+
"\34\36\36 \"\"\'\',,..\64\6588;;>>\t\2\f\f\21\21\32\32,,..::>>\u0397"+
"\2\u008c\3\2\2\2\4\u009e\3\2\2\2\6\u00a1\3\2\2\2\b\u00b0\3\2\2\2\n\u00b4"+
"\3\2\2\2\f\u00b9\3\2\2\2\16\u00be\3\2\2\2\20\u00c0\3\2\2\2\22\u00ce\3"+
"\2\2\2\24\u00d6\3\2\2\2\26\u00de\3\2\2\2\30\u00e6\3\2\2\2\32\u00f4\3\2"+
"\2\2\34\u00f7\3\2\2\2\36\u00fd\3\2\2\2 \u0100\3\2\2\2\"\u0107\3\2\2\2"+
"$\u0109\3\2\2\2&\u0117\3\2\2\2(\u0121\3\2\2\2*\u012a\3\2\2\2,\u0172\3"+
"\2\2\2.\u0174\3\2\2\2\60\u0190\3\2\2\2\62\u0192\3\2\2\2\64\u0194\3\2\2"+
"\2\66\u01a3\3\2\2\28\u01aa\3\2\2\2:\u01ae\3\2\2\2<\u01b6\3\2\2\2>\u01bd"+
"\3\2\2\2@\u01bf\3\2\2\2B\u01c7\3\2\2\2D\u01d4\3\2\2\2F\u01dc\3\2\2\2H"+
"\u01e1\3\2\2\2J\u01f1\3\2\2\2L\u01fc\3\2\2\2N\u0200\3\2\2\2P\u0215\3\2"+
"\2\2R\u0217\3\2\2\2T\u0219\3\2\2\2V\u021b\3\2\2\2X\u021e\3\2\2\2Z\u022f"+
"\3\2\2\2\\\u0236\3\2\2\2^\u0238\3\2\2\2`\u023b\3\2\2\2b\u0241\3\2\2\2"+
"d\u0243\3\2\2\2f\u024c\3\2\2\2h\u0255\3\2\2\2j\u0263\3\2\2\2l\u0279\3"+
"\2\2\2n\u027d\3\2\2\2p\u027f\3\2\2\2r\u0297\3\2\2\2t\u029c\3\2\2\2v\u02b1"+
"\3\2\2\2x\u02c3\3\2\2\2z\u02c5\3\2\2\2|\u02d5\3\2\2\2~\u02db\3\2\2\2\u0080"+
"\u02e9\3\2\2\2\u0082\u0325\3\2\2\2\u0084\u0333\3\2\2\2\u0086\u0335\3\2"+
"\2\2\u0088\u0343\3\2\2\2\u008a\u0349\3\2\2\2\u008c\u008d\5\4\3\2\u008d"+
"\u0093\5\u008aF\2\u008e\u008f\5\6\4\2\u008f\u0090\5\u008aF\2\u0090\u0092"+
"\3\2\2\2\u0091\u008e\3\2\2\2\u0092\u0095\3\2\2\2\u0093\u0091\3\2\2\2\u0093"+
"\u0094\3\2\2\2\u0094\u009b\3\2\2\2\u0095\u0093\3\2\2\2\u0096\u0097\5\f"+
"\7\2\u0097\u0098\5\u008aF\2\u0098\u009a\3\2\2\2\u0099\u0096\3\2\2\2\u009a"+
"\u009d\3\2\2\2\u009b\u0099\3\2\2\2\u009b\u009c\3\2\2\2\u009c\3\3\2\2\2"+
"\u009d\u009b\3\2\2\2\u009e\u009f\7\17\2\2\u009f\u00a0\7@\2\2\u00a0\5\3"+
"\2\2\2\u00a1\u00ad\7?\2\2\u00a2\u00ae\5\b\5\2\u00a3\u00a9\7\16\2\2\u00a4"+
"\u00a5\5\b\5\2\u00a5\u00a6\5\u008aF\2\u00a6\u00a8\3\2\2\2\u00a7\u00a4"+
"\3\2\2\2\u00a8\u00ab\3\2\2\2\u00a9\u00a7\3\2\2\2\u00a9\u00aa\3\2\2\2\u00aa"+
"\u00ac\3\2\2\2\u00ab\u00a9\3\2\2\2\u00ac\u00ae\7=\2\2\u00ad\u00a2\3\2"+
"\2\2\u00ad\u00a3\3\2\2\2\u00ae\7\3\2\2\2\u00af\u00b1\t\2\2\2\u00b0\u00af"+
"\3\2\2\2\u00b0\u00b1\3\2\2\2\u00b1\u00b2\3\2\2\2\u00b2\u00b3\5\n\6\2\u00b3"+
"\t\3\2\2\2\u00b4\u00b5\7I\2\2\u00b5\13\3\2\2\2\u00b6\u00ba\5\16\b\2\u00b7"+
"\u00ba\5\34\17\2\u00b8\u00ba\5 \21\2\u00b9\u00b6\3\2\2\2\u00b9\u00b7\3"+
"\2\2\2\u00b9\u00b8\3\2\2\2\u00ba\r\3\2\2\2\u00bb\u00bf\5\20\t\2\u00bc"+
"\u00bf\5\30\r\2\u00bd\u00bf\5$\23\2\u00be\u00bb\3\2\2\2\u00be\u00bc\3"+
"\2\2\2\u00be\u00bd\3\2\2\2\u00bf\17\3\2\2\2\u00c0\u00cc\7\23\2\2\u00c1"+
"\u00cd\5\22\n\2\u00c2\u00c8\7\16\2\2\u00c3\u00c4\5\22\n\2\u00c4\u00c5"+
"\5\u008aF\2\u00c5\u00c7\3\2\2\2\u00c6\u00c3\3\2\2\2\u00c7\u00ca\3\2\2"+
"\2\u00c8\u00c6\3\2\2\2\u00c8\u00c9\3\2\2\2\u00c9\u00cb\3\2\2\2\u00ca\u00c8"+
"\3\2\2\2\u00cb\u00cd\7=\2\2\u00cc\u00c1\3\2\2\2\u00cc\u00c2\3\2\2\2\u00cd"+
"\21\3\2\2\2\u00ce\u00d4\5\24\13\2\u00cf\u00d1\5L\'\2\u00d0\u00cf\3\2\2"+
"\2\u00d0\u00d1\3\2\2\2\u00d1\u00d2\3\2\2\2\u00d2\u00d3\7\13\2\2\u00d3"+
"\u00d5\5\26\f\2\u00d4\u00d0\3\2\2\2\u00d4\u00d5\3\2\2\2\u00d5\23\3\2\2"+
"\2\u00d6\u00db\7@\2\2\u00d7\u00d8\7\20\2\2\u00d8\u00da\7@\2\2\u00d9\u00d7"+
"\3\2\2\2\u00da\u00dd\3\2\2\2\u00db\u00d9\3\2\2\2\u00db\u00dc\3\2\2\2\u00dc"+
"\25\3\2\2\2\u00dd\u00db\3\2\2\2\u00de\u00e3\5\u0086D\2\u00df\u00e0\7\20"+
"\2\2\u00e0\u00e2\5\u0086D\2\u00e1\u00df\3\2\2\2\u00e2\u00e5\3\2\2\2\u00e3"+
"\u00e1\3\2\2\2\u00e3\u00e4\3\2\2\2\u00e4\27\3\2\2\2\u00e5\u00e3\3\2\2"+
"\2\u00e6\u00f2\7\31\2\2\u00e7\u00f3\5\32\16\2\u00e8\u00ee\7\16\2\2\u00e9"+
"\u00ea\5\32\16\2\u00ea\u00eb\7!\2\2\u00eb\u00ed\3\2\2\2\u00ec\u00e9\3"+
"\2\2\2\u00ed\u00f0\3\2\2\2\u00ee\u00ec\3\2\2\2\u00ee\u00ef\3\2\2\2\u00ef"+
"\u00f1\3\2\2\2\u00f0\u00ee\3\2\2\2\u00f1\u00f3\7=\2\2\u00f2\u00e7\3\2"+
"\2\2\u00f2\u00e8\3\2\2\2\u00f3\31\3\2\2\2\u00f4\u00f5\7@\2\2\u00f5\u00f6"+
"\5L\'\2\u00f6\33\3\2\2\2\u00f7\u00f8\7\5\2\2\u00f8\u00fb\7@\2\2\u00f9"+
"\u00fc\5\36\20\2\u00fa\u00fc\5`\61\2\u00fb\u00f9\3\2\2\2\u00fb\u00fa\3"+
"\2\2\2\u00fc\35\3\2\2\2\u00fd\u00fe\5`\61\2\u00fe\u00ff\5(\25\2\u00ff"+
"\37\3\2\2\2\u0100\u0101\7\5\2\2\u0101\u0102\5\"\22\2\u0102\u0105\7@\2"+
"\2\u0103\u0106\5\36\20\2\u0104\u0106\5`\61\2\u0105\u0103\3\2\2\2\u0105"+
"\u0104\3\2\2\2\u0106!\3\2\2\2\u0107\u0108\5d\63\2\u0108#\3\2\2\2\u0109"+
"\u0115\7\22\2\2\u010a\u0116\5&\24\2\u010b\u0111\7\16\2\2\u010c\u010d\5"+
"&\24\2\u010d\u010e\5\u008aF\2\u010e\u0110\3\2\2\2\u010f\u010c\3\2\2\2"+
"\u0110\u0113\3\2\2\2\u0111\u010f\3\2\2\2\u0111\u0112\3\2\2\2\u0112\u0114"+
"\3\2\2\2\u0113\u0111\3\2\2\2\u0114\u0116\7=\2\2\u0115\u010a\3\2\2\2\u0115"+
"\u010b\3\2\2\2\u0116%\3\2\2\2\u0117\u011f\5\24\13\2\u0118\u011b\5L\'\2"+
"\u0119\u011a\7\13\2\2\u011a\u011c\5\26\f\2\u011b\u0119\3\2\2\2\u011b\u011c"+
"\3\2\2\2\u011c\u0120\3\2\2\2\u011d\u011e\7\13\2\2\u011e\u0120\5\26\f\2"+
"\u011f\u0118\3\2\2\2\u011f\u011d\3\2\2\2\u0120\'\3\2\2\2\u0121\u0122\7"+
"\b\2\2\u0122\u0123\5*\26\2\u0123\u0124\7$\2\2\u0124)\3\2\2\2\u0125\u0126"+
"\5,\27\2\u0126\u0127\5\u008aF\2\u0127\u0129\3\2\2\2\u0128\u0125\3\2\2"+
"\2\u0129\u012c\3\2\2\2\u012a\u0128\3\2\2\2\u012a\u012b\3\2\2\2\u012b+"+
"\3\2\2\2\u012c\u012a\3\2\2\2\u012d\u0173\5\16\b\2\u012e\u012f\7@\2\2\u012f"+
"\u0130\7\62\2\2\u0130\u0173\5,\27\2\u0131\u0173\5\60\31\2\u0132\u0133"+
"\7)\2\2\u0133\u0173\5\u0086D\2\u0134\u0136\7\37\2\2\u0135\u0137\5\26\f"+
"\2\u0136\u0135\3\2\2\2\u0136\u0137\3\2\2\2\u0137\u0173\3\2\2\2\u0138\u013a"+
"\7(\2\2\u0139\u013b\7@\2\2\u013a\u0139\3\2\2\2\u013a\u013b\3\2\2\2\u013b"+
"\u0173\3\2\2\2\u013c\u013e\7\35\2\2\u013d\u013f\7@\2\2\u013e\u013d\3\2"+
"\2\2\u013e\u013f\3\2\2\2\u013f\u0173\3\2\2\2\u0140\u0141\7#\2\2\u0141"+
"\u0173\7@\2\2\u0142\u0173\79\2\2\u0143\u0173\5(\25\2\u0144\u0173\5\64"+
"\33\2\u0145\u0173\5.\30\2\u0146\u014a\7-\2\2\u0147\u0148\5\60\31\2\u0148"+
"\u0149\7!\2\2\u0149\u014b\3\2\2\2\u014a\u0147\3\2\2\2\u014a\u014b\3\2"+
"\2\2\u014b\u014d\3\2\2\2\u014c\u014e\5\u0086D\2\u014d\u014c\3\2\2\2\u014d"+
"\u014e\3\2\2\2\u014e\u014f\3\2\2\2\u014f\u0153\7\b\2\2\u0150\u0152\5\66"+
"\34\2\u0151\u0150\3\2\2\2\u0152\u0155\3\2\2\2\u0153\u0151\3\2\2\2\u0153"+
"\u0154\3\2\2\2\u0154\u0156\3\2\2\2\u0155\u0153\3\2\2\2\u0156\u0173\7$"+
"\2\2\u0157\u015b\7-\2\2\u0158\u0159\5\60\31\2\u0159\u015a\7!\2\2\u015a"+
"\u015c\3\2\2\2\u015b\u0158\3\2\2\2\u015b\u015c\3\2\2\2\u015c\u015d\3\2"+
"\2\2\u015d\u015e\5:\36\2\u015e\u0162\7\b\2\2\u015f\u0161\5<\37\2\u0160"+
"\u015f\3\2\2\2\u0161\u0164\3\2\2\2\u0162\u0160\3\2\2\2\u0162\u0163\3\2"+
"\2\2\u0163\u0165\3\2\2\2\u0164\u0162\3\2\2\2\u0165\u0166\7$\2\2\u0166"+
"\u0173\3\2\2\2\u0167\u0168\7\67\2\2\u0168\u016c\7\b\2\2\u0169\u016b\5"+
"B\"\2\u016a\u0169\3\2\2\2\u016b\u016e\3\2\2\2\u016c\u016a\3\2\2\2\u016c"+
"\u016d\3\2\2\2\u016d\u016f\3\2\2\2\u016e\u016c\3\2\2\2\u016f\u0173\7$"+
"\2\2\u0170\u0171\7+\2\2\u0171\u0173\5\u0086D\2\u0172\u012d\3\2\2\2\u0172"+
"\u012e\3\2\2\2\u0172\u0131\3\2\2\2\u0172\u0132\3\2\2\2\u0172\u0134\3\2"+
"\2\2\u0172\u0138\3\2\2\2\u0172\u013c\3\2\2\2\u0172\u0140\3\2\2\2\u0172"+
"\u0142\3\2\2\2\u0172\u0143\3\2\2\2\u0172\u0144\3\2\2\2\u0172\u0145\3\2"+
"\2\2\u0172\u0146\3\2\2\2\u0172\u0157\3\2\2\2\u0172\u0167\3\2\2\2\u0172"+
"\u0170\3\2\2\2\u0173-\3\2\2\2\u0174\u0178\7\r\2\2\u0175\u0179\5\u0086"+
"D\2\u0176\u0179\5H%\2\u0177\u0179\5J&\2\u0178\u0175\3\2\2\2\u0178\u0176"+
"\3\2\2\2\u0178\u0177\3\2\2\2\u0178\u0179\3\2\2\2\u0179\u017a\3\2\2\2\u017a"+
"\u017b\5(\25\2\u017b/\3\2\2\2\u017c\u017d\5\u0086D\2\u017d\u017e\7\21"+
"\2\2\u017e\u017f\5\u0086D\2\u017f\u0191\3\2\2\2\u0180\u0191\5\62\32\2"+
"\u0181\u0182\5\u0086D\2\u0182\u0183\t\3\2\2\u0183\u0191\3\2\2\2\u0184"+
"\u0186\5\26\f\2\u0185\u0187\t\4\2\2\u0186\u0185\3\2\2\2\u0186\u0187\3"+
"\2\2\2\u0187\u0188\3\2\2\2\u0188\u0189\7\13\2\2\u0189\u018a\5\26\f\2\u018a"+
"\u0191\3\2\2\2\u018b\u018c\5\24\13\2\u018c\u018d\7&\2\2\u018d\u018e\5"+
"\26\f\2\u018e\u0191\3\2\2\2\u018f\u0191\7!\2\2\u0190\u017c\3\2\2\2\u0190"+
"\u0180\3\2\2\2\u0190\u0181\3\2\2\2\u0190\u0184\3\2\2\2\u0190\u018b\3\2"+
"\2\2\u0190\u018f\3\2\2\2\u0191\61\3\2\2\2\u0192\u0193\5\u0086D\2\u0193"+
"\63\3\2\2\2\u0194\u0198\7%\2\2\u0195\u0196\5\60\31\2\u0196\u0197\7!\2"+
"\2\u0197\u0199\3\2\2\2\u0198\u0195\3\2\2\2\u0198\u0199\3\2\2\2\u0199\u019a"+
"\3\2\2\2\u019a\u019b\5\u0086D\2\u019b\u01a1\5(\25\2\u019c\u019f\7<\2\2"+
"\u019d\u01a0\5\64\33\2\u019e\u01a0\5(\25\2\u019f\u019d\3\2\2\2\u019f\u019e"+
"\3\2\2\2\u01a0\u01a2\3\2\2\2\u01a1\u019c\3\2\2\2\u01a1\u01a2\3\2\2\2\u01a2"+
"\65\3\2\2\2\u01a3\u01a4\58\35\2\u01a4\u01a5\7\62\2\2\u01a5\u01a6\5*\26"+
"\2\u01a6\67\3\2\2\2\u01a7\u01a8\7\60\2\2\u01a8\u01ab\5\26\f\2\u01a9\u01ab"+
"\7\4\2\2\u01aa\u01a7\3\2\2\2\u01aa\u01a9\3\2\2\2\u01ab9\3\2\2\2\u01ac"+
"\u01ad\7@\2\2\u01ad\u01af\7&\2\2\u01ae\u01ac\3\2\2\2\u01ae\u01af\3\2\2"+
"\2\u01af\u01b0\3\2\2\2\u01b0\u01b1\5\u0080A\2\u01b1\u01b2\7/\2\2\u01b2"+
"\u01b3\7\16\2\2\u01b3\u01b4\7\31\2\2\u01b4\u01b5\7=\2\2\u01b5;\3\2\2\2"+
"\u01b6\u01b7\5> \2\u01b7\u01b8\7\62\2\2\u01b8\u01b9\5*\26\2\u01b9=\3\2"+
"\2\2\u01ba\u01bb\7\60\2\2\u01bb\u01be\5@!\2\u01bc\u01be\7\4\2\2\u01bd"+
"\u01ba\3\2\2\2\u01bd\u01bc\3\2\2\2\u01be?\3\2\2\2\u01bf\u01c4\5L\'\2\u01c0"+
"\u01c1\7\20\2\2\u01c1\u01c3\5L\'\2\u01c2\u01c0\3\2\2\2\u01c3\u01c6\3\2"+
"\2\2\u01c4\u01c2\3\2\2\2\u01c4\u01c5\3\2\2\2\u01c5A\3\2\2\2\u01c6\u01c4"+
"\3\2\2\2\u01c7\u01c8\5D#\2\u01c8\u01c9\7\62\2\2\u01c9\u01ca\5*\26\2\u01ca"+
"C\3\2\2\2\u01cb\u01d1\7\60\2\2\u01cc\u01cd\5\u0086D\2\u01cd\u01ce\7\21"+
"\2\2\u01ce\u01cf\5\u0086D\2\u01cf\u01d2\3\2\2\2\u01d0\u01d2\5F$\2\u01d1"+
"\u01cc\3\2\2\2\u01d1\u01d0\3\2\2\2\u01d2\u01d5\3\2\2\2\u01d3\u01d5\7\4"+
"\2\2\u01d4\u01cb\3\2\2\2\u01d4\u01d3\3\2\2\2\u01d5E\3\2\2\2\u01d6\u01d7"+
"\5\26\f\2\u01d7\u01d8\7\13\2\2\u01d8\u01dd\3\2\2\2\u01d9\u01da\5\24\13"+
"\2\u01da\u01db\7&\2\2\u01db\u01dd\3\2\2\2\u01dc\u01d6\3\2\2\2\u01dc\u01d9"+
"\3\2\2\2\u01dc\u01dd\3\2\2\2\u01dd\u01de\3\2\2\2\u01de\u01df\5\u0086D"+
"\2\u01dfG\3\2\2\2\u01e0\u01e2\5\60\31\2\u01e1\u01e0\3\2\2\2\u01e1\u01e2"+
"\3\2\2\2\u01e2\u01e3\3\2\2\2\u01e3\u01e5\7!\2\2\u01e4\u01e6\5\u0086D\2"+
"\u01e5\u01e4\3\2\2\2\u01e5\u01e6\3\2\2\2\u01e6\u01e7\3\2\2\2\u01e7\u01e9"+
"\7!\2\2\u01e8\u01ea\5\60\31\2\u01e9\u01e8\3\2\2\2\u01e9\u01ea\3\2\2\2"+
"\u01eaI\3\2\2\2\u01eb\u01ec\5\26\f\2\u01ec\u01ed\7\13\2\2\u01ed\u01f2"+
"\3\2\2\2\u01ee\u01ef\5\24\13\2\u01ef\u01f0\7&\2\2\u01f0\u01f2\3\2\2\2"+
"\u01f1\u01eb\3\2\2\2\u01f1\u01ee\3\2\2\2\u01f1\u01f2\3\2\2\2\u01f2\u01f3"+
"\3\2\2\2\u01f3\u01f4\7\24\2\2\u01f4\u01f5\5\u0086D\2\u01f5K\3\2\2\2\u01f6"+
"\u01fd\5N(\2\u01f7\u01fd\5P)\2\u01f8\u01f9\7\16\2\2\u01f9\u01fa\5L\'\2"+
"\u01fa\u01fb\7=\2\2\u01fb\u01fd\3\2\2\2\u01fc\u01f6\3\2\2\2\u01fc\u01f7"+
"\3\2\2\2\u01fc\u01f8\3\2\2\2\u01fdM\3\2\2\2\u01fe\u0201\7@\2\2\u01ff\u0201"+
"\5p9\2\u0200\u01fe\3\2\2\2\u0200\u01ff\3\2\2\2\u0201O\3\2\2\2\u0202\u0203"+
"\7\63\2\2\u0203\u0204\5R*\2\u0204\u0205\7\30\2\2\u0205\u0206\5T+\2\u0206"+
"\u0216\3\2\2\2\u0207\u0216\5z>\2\u0208\u0216\5V,\2\u0209\u0216\5^\60\2"+
"\u020a\u0216\5X-\2\u020b\u020c\7\63\2\2\u020c\u020d\7\30\2\2\u020d\u0216"+
"\5T+\2\u020e\u020f\7*\2\2\u020f\u0210\7\63\2\2\u0210\u0211\5L\'\2\u0211"+
"\u0212\7\30\2\2\u0212\u0213\5T+\2\u0213\u0216\3\2\2\2\u0214\u0216\5Z."+
"\2\u0215\u0202\3\2\2\2\u0215\u0207\3\2\2\2\u0215\u0208\3\2\2\2\u0215\u0209"+
"\3\2\2\2\u0215\u020a\3\2\2\2\u0215\u020b\3\2\2\2\u0215\u020e\3\2\2\2\u0215"+
"\u0214\3\2\2\2\u0216Q\3\2\2\2\u0217\u0218\5\u0086D\2\u0218S\3\2\2\2\u0219"+
"\u021a\5L\'\2\u021aU\3\2\2\2\u021b\u021c\7.\2\2\u021c\u021d\5L\'\2\u021d"+
"W\3\2\2\2\u021e\u021f\7\6\2\2\u021f\u0225\7\b\2\2\u0220\u0221\5\\/\2\u0221"+
"\u0222\5\u008aF\2\u0222\u0224\3\2\2\2\u0223\u0220\3\2\2\2\u0224\u0227"+
"\3\2\2\2\u0225\u0223\3\2\2\2\u0225\u0226\3\2\2\2\u0226\u0228\3\2\2\2\u0227"+
"\u0225\3\2\2\2\u0228\u0229\7$\2\2\u0229Y\3\2\2\2\u022a\u0230\7\3\2\2\u022b"+
"\u022c\7\3\2\2\u022c\u0230\7\21\2\2\u022d\u022e\7\21\2\2\u022e\u0230\7"+
"\3\2\2\u022f\u022a\3\2\2\2\u022f\u022b\3\2\2\2\u022f\u022d\3\2\2\2\u0230"+
"\u0231\3\2\2\2\u0231\u0232\5T+\2\u0232[\3\2\2\2\u0233\u0234\7@\2\2\u0234"+
"\u0237\5`\61\2\u0235\u0237\5N(\2\u0236\u0233\3\2\2\2\u0236\u0235\3\2\2"+
"\2\u0237]\3\2\2\2\u0238\u0239\7\5\2\2\u0239\u023a\5`\61\2\u023a_\3\2\2"+
"\2\u023b\u023d\5d\63\2\u023c\u023e\5b\62\2\u023d\u023c\3\2\2\2\u023d\u023e"+
"\3\2\2\2\u023ea\3\2\2\2\u023f\u0242\5d\63\2\u0240\u0242\5L\'\2\u0241\u023f"+
"\3\2\2\2\u0241\u0240\3\2\2\2\u0242c\3\2\2\2\u0243\u0248\7\16\2\2\u0244"+
"\u0246\5f\64\2\u0245\u0247\7\20\2\2\u0246\u0245\3\2\2\2\u0246\u0247\3"+
"\2\2\2\u0247\u0249\3\2\2\2\u0248\u0244\3\2\2\2\u0248\u0249\3\2\2\2\u0249"+
"\u024a\3\2\2\2\u024a\u024b\7=\2\2\u024be\3\2\2\2\u024c\u0251\5h\65\2\u024d"+
"\u024e\7\20\2\2\u024e\u0250\5h\65\2\u024f\u024d\3\2\2\2\u0250\u0253\3"+
"\2\2\2\u0251\u024f\3\2\2\2\u0251\u0252\3\2\2\2\u0252g\3\2\2\2\u0253\u0251"+
"\3\2\2\2\u0254\u0256\5\24\13\2\u0255\u0254\3\2\2\2\u0255\u0256\3\2\2\2"+
"\u0256\u0258\3\2\2\2\u0257\u0259\7\61\2\2\u0258\u0257\3\2\2\2\u0258\u0259"+
"\3\2\2\2\u0259\u025a\3\2\2\2\u025a\u025b\5L\'\2\u025bi\3\2\2\2\u025c\u0264"+
"\5l\67\2\u025d\u0264\5n8\2\u025e\u0264\5\u0082B\2\u025f\u0260\7\16\2\2"+
"\u0260\u0261\5\u0086D\2\u0261\u0262\7=\2\2\u0262\u0264\3\2\2\2\u0263\u025c"+
"\3\2\2\2\u0263\u025d\3\2\2\2\u0263\u025e\3\2\2\2\u0263\u025f\3\2\2\2\u0264"+
"k\3\2\2\2\u0265\u027a\t\5\2\2\u0266\u0267\5r:\2\u0267\u0273\7\b\2\2\u0268"+
"\u026d\5t;\2\u0269\u026a\7\20\2\2\u026a\u026c\5t;\2\u026b\u0269\3\2\2"+
"\2\u026c\u026f\3\2\2\2\u026d\u026b\3\2\2\2\u026d\u026e\3\2\2\2\u026e\u0271"+
"\3\2\2\2\u026f\u026d\3\2\2\2\u0270\u0272\7\20\2\2\u0271\u0270\3\2\2\2"+
"\u0271\u0272\3\2\2\2\u0272\u0274\3\2\2\2\u0273\u0268\3\2\2\2\u0273\u0274"+
"\3\2\2\2\u0274\u0275\3\2\2\2\u0275\u0276\7$\2\2\u0276\u027a\3\2\2\2\u0277"+
"\u0278\7\5\2\2\u0278\u027a\5\36\20\2\u0279\u0265\3\2\2\2\u0279\u0266\3"+
"\2\2\2\u0279\u0277\3\2\2\2\u027am\3\2\2\2\u027b\u027e\7@\2\2\u027c\u027e"+
"\5p9\2\u027d\u027b\3\2\2\2\u027d\u027c\3\2\2\2\u027eo\3\2\2\2\u027f\u0280"+
"\7@\2\2\u0280\u0281\7/\2\2\u0281\u0282\7@\2\2\u0282q\3\2\2\2\u0283\u0298"+
"\5z>\2\u0284\u0285\7\63\2\2\u0285\u0286\5R*\2\u0286\u0287\7\30\2\2\u0287"+
"\u0288\5T+\2\u0288\u0298\3\2\2\2\u0289\u028a\7\63\2\2\u028a\u028b\7\61"+
"\2\2\u028b\u028c\7\30\2\2\u028c\u0298\5T+\2\u028d\u028e\7\63\2\2\u028e"+
"\u028f\7\30\2\2\u028f\u0298\5T+\2\u0290\u0291\7*\2\2\u0291\u0292\7\63"+
"\2\2\u0292\u0293\5L\'\2\u0293\u0294\7\30\2\2\u0294\u0295\5T+\2\u0295\u0298"+
"\3\2\2\2\u0296\u0298\5N(\2\u0297\u0283\3\2\2\2\u0297\u0284\3\2\2\2\u0297"+
"\u0289\3\2\2\2\u0297\u028d\3\2\2\2\u0297\u0290\3\2\2\2\u0297\u0296\3\2"+
"\2\2\u0298s\3\2\2\2\u0299\u029a\5v<\2\u029a\u029b\7\62\2\2\u029b\u029d"+
"\3\2\2\2\u029c\u0299\3\2\2\2\u029c\u029d\3\2\2\2\u029d\u029e\3\2\2\2\u029e"+
"\u029f\5x=\2\u029fu\3\2\2\2\u02a0\u02b2\7@\2\2\u02a1\u02b2\5\u0086D\2"+
"\u02a2\u02ae\7\b\2\2\u02a3\u02a8\5t;\2\u02a4\u02a5\7\20\2\2\u02a5\u02a7"+
"\5t;\2\u02a6\u02a4\3\2\2\2\u02a7\u02aa\3\2\2\2\u02a8\u02a6\3\2\2\2\u02a8"+
"\u02a9\3\2\2\2\u02a9\u02ac\3\2\2\2\u02aa\u02a8\3\2\2\2\u02ab\u02ad\7\20"+
"\2\2\u02ac\u02ab\3\2\2\2\u02ac\u02ad\3\2\2\2\u02ad\u02af\3\2\2\2\u02ae"+
"\u02a3\3\2\2\2\u02ae\u02af\3\2\2\2\u02af\u02b0\3\2\2\2\u02b0\u02b2\7$"+
"\2\2\u02b1\u02a0\3\2\2\2\u02b1\u02a1\3\2\2\2\u02b1\u02a2\3\2\2\2\u02b2"+
"w\3\2\2\2\u02b3\u02c4\5\u0086D\2\u02b4\u02c0\7\b\2\2\u02b5\u02ba\5t;\2"+
"\u02b6\u02b7\7\20\2\2\u02b7\u02b9\5t;\2\u02b8\u02b6\3\2\2\2\u02b9\u02bc"+
"\3\2\2\2\u02ba\u02b8\3\2\2\2\u02ba\u02bb\3\2\2\2\u02bb\u02be\3\2\2\2\u02bc"+
"\u02ba\3\2\2\2\u02bd\u02bf\7\20\2\2\u02be\u02bd\3\2\2\2\u02be\u02bf\3"+
"\2\2\2\u02bf\u02c1\3\2\2\2\u02c0\u02b5\3\2\2\2\u02c0\u02c1\3\2\2\2\u02c1"+
"\u02c2\3\2\2\2\u02c2\u02c4\7$\2\2\u02c3\u02b3\3\2\2\2\u02c3\u02b4\3\2"+
"\2\2\u02c4y\3\2\2\2\u02c5\u02c6\7\33\2\2\u02c6\u02cc\7\b\2\2\u02c7\u02c8"+
"\5|?\2\u02c8\u02c9\5\u008aF\2\u02c9\u02cb\3\2\2\2\u02ca\u02c7\3\2\2\2"+
"\u02cb\u02ce\3\2\2\2\u02cc\u02ca\3\2\2\2\u02cc\u02cd\3\2\2\2\u02cd\u02cf"+
"\3\2\2\2\u02ce\u02cc\3\2\2\2\u02cf\u02d0\7$\2\2\u02d0{\3\2\2\2\u02d1\u02d2"+
"\5\24\13\2\u02d2\u02d3\5L\'\2\u02d3\u02d6\3\2\2\2\u02d4\u02d6\5~@\2\u02d5"+
"\u02d1\3\2\2\2\u02d5\u02d4\3\2\2\2\u02d6\u02d8\3\2\2\2\u02d7\u02d9\7I"+
"\2\2\u02d8\u02d7\3\2\2\2\u02d8\u02d9\3\2\2\2\u02d9}\3\2\2\2\u02da\u02dc"+
"\7.\2\2\u02db\u02da\3\2\2\2\u02db\u02dc\3\2\2\2\u02dc\u02dd\3\2\2\2\u02dd"+
"\u02de\5N(\2\u02de\177\3\2\2\2\u02df\u02e0\bA\1\2\u02e0\u02ea\5j\66\2"+
"\u02e1\u02e2\5L\'\2\u02e2\u02e3\7\16\2\2\u02e3\u02e5\5\u0086D\2\u02e4"+
"\u02e6\7\20\2\2\u02e5\u02e4\3\2\2\2\u02e5\u02e6\3\2\2\2\u02e6\u02e7\3"+
"\2\2\2\u02e7\u02e8\7=\2\2\u02e8\u02ea\3\2\2\2\u02e9\u02df\3\2\2\2\u02e9"+
"\u02e1\3\2\2\2\u02ea\u0322\3\2\2\2\u02eb\u02ec\f\7\2\2\u02ec\u02ed\7/"+
"\2\2\u02ed\u0321\7@\2\2\u02ee\u02ef\f\6\2\2\u02ef\u02f0\7\63\2\2\u02f0"+
"\u02f1\5\u0086D\2\u02f1\u02f2\7\30\2\2\u02f2\u0321\3\2\2\2\u02f3\u02f4"+
"\f\5\2\2\u02f4\u0304\7\63\2\2\u02f5\u02f7\5\u0086D\2\u02f6\u02f5\3\2\2"+
"\2\u02f6\u02f7\3\2\2\2\u02f7\u02f8\3\2\2\2\u02f8\u02fa\7\62\2\2\u02f9"+
"\u02fb\5\u0086D\2\u02fa\u02f9\3\2\2\2\u02fa\u02fb\3\2\2\2\u02fb\u0305"+
"\3\2\2\2\u02fc\u02fe\5\u0086D\2\u02fd\u02fc\3\2\2\2\u02fd\u02fe\3\2\2"+
"\2\u02fe\u02ff\3\2\2\2\u02ff\u0300\7\62\2\2\u0300\u0301\5\u0086D\2\u0301"+
"\u0302\7\62\2\2\u0302\u0303\5\u0086D\2\u0303\u0305\3\2\2\2\u0304\u02f6"+
"\3\2\2\2\u0304\u02fd\3\2\2\2\u0305\u0306\3\2\2\2\u0306\u0321\7\30\2\2"+
"\u0307\u0308\f\4\2\2\u0308\u0309\7/\2\2\u0309\u030a\7\16\2\2\u030a\u030b"+
"\5L\'\2\u030b\u030c\7=\2\2\u030c\u0321\3\2\2\2\u030d\u030e\f\3\2\2\u030e"+
"\u031d\7\16\2\2\u030f\u0316\5\26\f\2\u0310\u0313\5L\'\2\u0311\u0312\7"+
"\20\2\2\u0312\u0314\5\26\f\2\u0313\u0311\3\2\2\2\u0313\u0314\3\2\2\2\u0314"+
"\u0316\3\2\2\2\u0315\u030f\3\2\2\2\u0315\u0310\3\2\2\2\u0316\u0318\3\2"+
"\2\2\u0317\u0319\7\61\2\2\u0318\u0317\3\2\2\2\u0318\u0319\3\2\2\2\u0319"+
"\u031b\3\2\2\2\u031a\u031c\7\20\2\2\u031b\u031a\3\2\2\2\u031b\u031c\3"+
"\2\2\2\u031c\u031e\3\2\2\2\u031d\u0315\3\2\2\2\u031d\u031e\3\2\2\2\u031e"+
"\u031f\3\2\2\2\u031f\u0321\7=\2\2\u0320\u02eb\3\2\2\2\u0320\u02ee\3\2"+
"\2\2\u0320\u02f3\3\2\2\2\u0320\u0307\3\2\2\2\u0320\u030d\3\2\2\2\u0321"+
"\u0324\3\2\2\2\u0322\u0320\3\2\2\2\u0322\u0323\3\2\2\2\u0323\u0081\3\2"+
"\2\2\u0324\u0322\3\2\2\2\u0325\u0326\5\u0084C\2\u0326\u0327\7/\2\2\u0327"+
"\u0328\7@\2\2\u0328\u0083\3\2\2\2\u0329\u0334\5N(\2\u032a\u032b\7\16\2"+
"\2\u032b\u032c\7.\2\2\u032c\u032d\5N(\2\u032d\u032e\7=\2\2\u032e\u0334"+
"\3\2\2\2\u032f\u0330\7\16\2\2\u0330\u0331\5\u0084C\2\u0331\u0332\7=\2"+
"\2\u0332\u0334\3\2\2\2\u0333\u0329\3\2\2\2\u0333\u032a\3\2\2\2\u0333\u032f"+
"\3\2\2\2\u0334\u0085\3\2\2\2\u0335\u0336\bD\1\2\u0336\u0337\5\u0088E\2"+
"\u0337\u033d\3\2\2\2\u0338\u0339\f\3\2\2\u0339\u033a\t\6\2\2\u033a\u033c"+
"\5\u0086D\4\u033b\u0338\3\2\2\2\u033c\u033f\3\2\2\2\u033d\u033b\3\2\2"+
"\2\u033d\u033e\3\2\2\2\u033e\u0087\3\2\2\2\u033f\u033d\3\2\2\2\u0340\u0344"+
"\5\u0080A\2\u0341\u0342\t\7\2\2\u0342\u0344\5\u0088E\2\u0343\u0340\3\2"+
"\2\2\u0343\u0341\3\2\2\2\u0344\u0089\3\2\2\2\u0345\u034a\7!\2\2\u0346"+
"\u034a\7\2\2\3\u0347\u034a\6F\b\2\u0348\u034a\6F\t\2\u0349\u0345\3\2\2"+
"\2\u0349\u0346\3\2\2\2\u0349\u0347\3\2\2\2\u0349\u0348\3\2\2\2\u034a\u008b"+
"\3\2\2\2e\u0093\u009b\u00a9\u00ad\u00b0\u00b9\u00be\u00c8\u00cc\u00d0"+
"\u00d4\u00db\u00e3\u00ee\u00f2\u00fb\u0105\u0111\u0115\u011b\u011f\u012a"+
"\u0136\u013a\u013e\u014a\u014d\u0153\u015b\u0162\u016c\u0172\u0178\u0186"+
"\u0190\u0198\u019f\u01a1\u01aa\u01ae\u01bd\u01c4\u01d1\u01d4\u01dc\u01e1"+
"\u01e5\u01e9\u01f1\u01fc\u0200\u0215\u0225\u022f\u0236\u023d\u0241\u0246"+
"\u0248\u0251\u0255\u0258\u0263\u026d\u0271\u0273\u0279\u027d\u0297\u029c"+
"\u02a8\u02ac\u02ae\u02b1\u02ba\u02be\u02c0\u02c3\u02cc\u02d5\u02d8\u02db"+
"\u02e5\u02e9\u02f6\u02fa\u02fd\u0304\u0313\u0315\u0318\u031b\u031d\u0320"+
"\u0322\u0333\u033d\u0343\u0349";
public static final ATN _ATN =
new ATNDeserializer().deserialize(_serializedATN.toCharArray());
static {
}
} © 2015 - 2025 Weber Informatics LLC | Privacy Policy