| // Generated from java-escape by ANTLR 4.11.1 |
| |
| |
| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| // DO NOT EDIT THIS FILE MANUALLY! |
| // SEE build.xml FOR INSTRUCTIONS |
| |
| |
| package org.antlr.parser.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; |
| |
| @SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue"}) |
| public class GoParser extends GoParserBase { |
| static { RuntimeMetaData.checkVersion("4.11.1", RuntimeMetaData.VERSION); } |
| |
| protected static final DFA[] _decisionToDFA; |
| protected static final PredictionContextCache _sharedContextCache = |
| new PredictionContextCache(); |
| public static final int |
| BREAK=1, DEFAULT=2, FUNC=3, INTERFACE=4, SELECT=5, CASE=6, DEFER=7, GO=8, |
| MAP=9, STRUCT=10, CHAN=11, ELSE=12, GOTO=13, PACKAGE=14, SWITCH=15, CONST=16, |
| FALLTHROUGH=17, IF=18, RANGE=19, TYPE=20, CONTINUE=21, FOR=22, IMPORT=23, |
| RETURN=24, VAR=25, NIL_LIT=26, IDENTIFIER=27, L_PAREN=28, R_PAREN=29, |
| L_CURLY=30, R_CURLY=31, L_BRACKET=32, R_BRACKET=33, ASSIGN=34, COMMA=35, |
| SEMI=36, COLON=37, DOT=38, PLUS_PLUS=39, MINUS_MINUS=40, DECLARE_ASSIGN=41, |
| ELLIPSIS=42, LOGICAL_OR=43, LOGICAL_AND=44, EQUALS=45, NOT_EQUALS=46, |
| LESS=47, LESS_OR_EQUALS=48, GREATER=49, GREATER_OR_EQUALS=50, OR=51, DIV=52, |
| MOD=53, LSHIFT=54, RSHIFT=55, BIT_CLEAR=56, EXCLAMATION=57, PLUS=58, MINUS=59, |
| CARET=60, STAR=61, AMPERSAND=62, RECEIVE=63, DECIMAL_LIT=64, BINARY_LIT=65, |
| OCTAL_LIT=66, HEX_LIT=67, FLOAT_LIT=68, DECIMAL_FLOAT_LIT=69, HEX_FLOAT_LIT=70, |
| IMAGINARY_LIT=71, RUNE_LIT=72, BYTE_VALUE=73, OCTAL_BYTE_VALUE=74, HEX_BYTE_VALUE=75, |
| LITTLE_U_VALUE=76, BIG_U_VALUE=77, RAW_STRING_LIT=78, INTERPRETED_STRING_LIT=79, |
| WS=80, COMMENT=81, TERMINATOR=82, LINE_COMMENT=83, WS_NLSEMI=84, COMMENT_NLSEMI=85, |
| LINE_COMMENT_NLSEMI=86, EOS=87, OTHER=88; |
| public static final int |
| RULE_sourceFile = 0, RULE_packageClause = 1, RULE_importDecl = 2, RULE_importSpec = 3, |
| RULE_importPath = 4, RULE_declaration = 5, RULE_constDecl = 6, RULE_constSpec = 7, |
| RULE_identifierList = 8, RULE_expressionList = 9, RULE_typeDecl = 10, |
| RULE_typeSpec = 11, RULE_functionDecl = 12, RULE_methodDecl = 13, RULE_receiver = 14, |
| RULE_varDecl = 15, RULE_varSpec = 16, RULE_block = 17, RULE_statementList = 18, |
| RULE_statement = 19, RULE_simpleStmt = 20, RULE_expressionStmt = 21, RULE_sendStmt = 22, |
| RULE_incDecStmt = 23, RULE_assignment = 24, RULE_assign_op = 25, RULE_shortVarDecl = 26, |
| RULE_emptyStmt = 27, RULE_labeledStmt = 28, RULE_returnStmt = 29, RULE_breakStmt = 30, |
| RULE_continueStmt = 31, RULE_gotoStmt = 32, RULE_fallthroughStmt = 33, |
| RULE_deferStmt = 34, RULE_ifStmt = 35, RULE_switchStmt = 36, RULE_exprSwitchStmt = 37, |
| RULE_exprCaseClause = 38, RULE_exprSwitchCase = 39, RULE_typeSwitchStmt = 40, |
| RULE_typeSwitchGuard = 41, RULE_typeCaseClause = 42, RULE_typeSwitchCase = 43, |
| RULE_typeList = 44, RULE_selectStmt = 45, RULE_commClause = 46, RULE_commCase = 47, |
| RULE_recvStmt = 48, RULE_forStmt = 49, RULE_forClause = 50, RULE_rangeClause = 51, |
| RULE_goStmt = 52, RULE_type_ = 53, RULE_typeName = 54, RULE_typeLit = 55, |
| RULE_arrayType = 56, RULE_arrayLength = 57, RULE_elementType = 58, RULE_pointerType = 59, |
| RULE_interfaceType = 60, RULE_sliceType = 61, RULE_mapType = 62, RULE_channelType = 63, |
| RULE_methodSpec = 64, RULE_functionType = 65, RULE_signature = 66, RULE_result = 67, |
| RULE_parameters = 68, RULE_parameterDecl = 69, RULE_expression = 70, RULE_primaryExpr = 71, |
| RULE_conversion = 72, RULE_nonNamedType = 73, RULE_operand = 74, RULE_literal = 75, |
| RULE_basicLit = 76, RULE_integer = 77, RULE_operandName = 78, RULE_qualifiedIdent = 79, |
| RULE_compositeLit = 80, RULE_literalType = 81, RULE_literalValue = 82, |
| RULE_elementList = 83, RULE_keyedElement = 84, RULE_key = 85, RULE_element = 86, |
| RULE_structType = 87, RULE_fieldDecl = 88, RULE_string_ = 89, RULE_embeddedField = 90, |
| RULE_functionLit = 91, RULE_index = 92, RULE_slice_ = 93, RULE_typeAssertion = 94, |
| RULE_arguments = 95, RULE_methodExpr = 96, RULE_receiverType = 97, RULE_eos = 98; |
| private static String[] makeRuleNames() { |
| return new String[] { |
| "sourceFile", "packageClause", "importDecl", "importSpec", "importPath", |
| "declaration", "constDecl", "constSpec", "identifierList", "expressionList", |
| "typeDecl", "typeSpec", "functionDecl", "methodDecl", "receiver", "varDecl", |
| "varSpec", "block", "statementList", "statement", "simpleStmt", "expressionStmt", |
| "sendStmt", "incDecStmt", "assignment", "assign_op", "shortVarDecl", |
| "emptyStmt", "labeledStmt", "returnStmt", "breakStmt", "continueStmt", |
| "gotoStmt", "fallthroughStmt", "deferStmt", "ifStmt", "switchStmt", "exprSwitchStmt", |
| "exprCaseClause", "exprSwitchCase", "typeSwitchStmt", "typeSwitchGuard", |
| "typeCaseClause", "typeSwitchCase", "typeList", "selectStmt", "commClause", |
| "commCase", "recvStmt", "forStmt", "forClause", "rangeClause", "goStmt", |
| "type_", "typeName", "typeLit", "arrayType", "arrayLength", "elementType", |
| "pointerType", "interfaceType", "sliceType", "mapType", "channelType", |
| "methodSpec", "functionType", "signature", "result", "parameters", "parameterDecl", |
| "expression", "primaryExpr", "conversion", "nonNamedType", "operand", |
| "literal", "basicLit", "integer", "operandName", "qualifiedIdent", "compositeLit", |
| "literalType", "literalValue", "elementList", "keyedElement", "key", |
| "element", "structType", "fieldDecl", "string_", "embeddedField", "functionLit", |
| "index", "slice_", "typeAssertion", "arguments", "methodExpr", "receiverType", |
| "eos" |
| }; |
| } |
| public static final String[] ruleNames = makeRuleNames(); |
| |
| private static String[] makeLiteralNames() { |
| return new String[] { |
| null, "'break'", "'default'", "'func'", "'interface'", "'select'", "'case'", |
| "'defer'", "'go'", "'map'", "'struct'", "'chan'", "'else'", "'goto'", |
| "'package'", "'switch'", "'const'", "'fallthrough'", "'if'", "'range'", |
| "'type'", "'continue'", "'for'", "'import'", "'return'", "'var'", "'nil'", |
| null, "'('", "')'", "'{'", "'}'", "'['", "']'", "'='", "','", "';'", |
| "':'", "'.'", "'++'", "'--'", "':='", "'...'", "'||'", "'&&'", "'=='", |
| "'!='", "'<'", "'<='", "'>'", "'>='", "'|'", "'/'", "'%'", "'<<'", "'>>'", |
| "'&^'", "'!'", "'+'", "'-'", "'^'", "'*'", "'&'", "'<-'" |
| }; |
| } |
| private static final String[] _LITERAL_NAMES = makeLiteralNames(); |
| private static String[] makeSymbolicNames() { |
| return new String[] { |
| null, "BREAK", "DEFAULT", "FUNC", "INTERFACE", "SELECT", "CASE", "DEFER", |
| "GO", "MAP", "STRUCT", "CHAN", "ELSE", "GOTO", "PACKAGE", "SWITCH", "CONST", |
| "FALLTHROUGH", "IF", "RANGE", "TYPE", "CONTINUE", "FOR", "IMPORT", "RETURN", |
| "VAR", "NIL_LIT", "IDENTIFIER", "L_PAREN", "R_PAREN", "L_CURLY", "R_CURLY", |
| "L_BRACKET", "R_BRACKET", "ASSIGN", "COMMA", "SEMI", "COLON", "DOT", |
| "PLUS_PLUS", "MINUS_MINUS", "DECLARE_ASSIGN", "ELLIPSIS", "LOGICAL_OR", |
| "LOGICAL_AND", "EQUALS", "NOT_EQUALS", "LESS", "LESS_OR_EQUALS", "GREATER", |
| "GREATER_OR_EQUALS", "OR", "DIV", "MOD", "LSHIFT", "RSHIFT", "BIT_CLEAR", |
| "EXCLAMATION", "PLUS", "MINUS", "CARET", "STAR", "AMPERSAND", "RECEIVE", |
| "DECIMAL_LIT", "BINARY_LIT", "OCTAL_LIT", "HEX_LIT", "FLOAT_LIT", "DECIMAL_FLOAT_LIT", |
| "HEX_FLOAT_LIT", "IMAGINARY_LIT", "RUNE_LIT", "BYTE_VALUE", "OCTAL_BYTE_VALUE", |
| "HEX_BYTE_VALUE", "LITTLE_U_VALUE", "BIG_U_VALUE", "RAW_STRING_LIT", |
| "INTERPRETED_STRING_LIT", "WS", "COMMENT", "TERMINATOR", "LINE_COMMENT", |
| "WS_NLSEMI", "COMMENT_NLSEMI", "LINE_COMMENT_NLSEMI", "EOS", "OTHER" |
| }; |
| } |
| private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); |
| public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); |
| |
| /** |
| * @deprecated Use {@link #VOCABULARY} instead. |
| */ |
| @Deprecated |
| public static final String[] tokenNames; |
| static { |
| tokenNames = new String[_SYMBOLIC_NAMES.length]; |
| for (int i = 0; i < tokenNames.length; i++) { |
| tokenNames[i] = VOCABULARY.getLiteralName(i); |
| if (tokenNames[i] == null) { |
| tokenNames[i] = VOCABULARY.getSymbolicName(i); |
| } |
| |
| if (tokenNames[i] == null) { |
| tokenNames[i] = "<INVALID>"; |
| } |
| } |
| } |
| |
| @Override |
| @Deprecated |
| public String[] getTokenNames() { |
| return tokenNames; |
| } |
| |
| @Override |
| |
| public Vocabulary getVocabulary() { |
| return VOCABULARY; |
| } |
| |
| @Override |
| public String getGrammarFileName() { return "java-escape"; } |
| |
| @Override |
| public String[] getRuleNames() { return ruleNames; } |
| |
| @Override |
| public String getSerializedATN() { return _serializedATN; } |
| |
| @Override |
| public ATN getATN() { return _ATN; } |
| |
| public GoParser(TokenStream input) { |
| super(input); |
| _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class SourceFileContext extends ParserRuleContext { |
| public PackageClauseContext packageClause() { |
| return getRuleContext(PackageClauseContext.class,0); |
| } |
| public List<EosContext> eos() { |
| return getRuleContexts(EosContext.class); |
| } |
| public EosContext eos(int i) { |
| return getRuleContext(EosContext.class,i); |
| } |
| public TerminalNode EOF() { return getToken(GoParser.EOF, 0); } |
| public List<ImportDeclContext> importDecl() { |
| return getRuleContexts(ImportDeclContext.class); |
| } |
| public ImportDeclContext importDecl(int i) { |
| return getRuleContext(ImportDeclContext.class,i); |
| } |
| public List<FunctionDeclContext> functionDecl() { |
| return getRuleContexts(FunctionDeclContext.class); |
| } |
| public FunctionDeclContext functionDecl(int i) { |
| return getRuleContext(FunctionDeclContext.class,i); |
| } |
| public List<MethodDeclContext> methodDecl() { |
| return getRuleContexts(MethodDeclContext.class); |
| } |
| public MethodDeclContext methodDecl(int i) { |
| return getRuleContext(MethodDeclContext.class,i); |
| } |
| public List<DeclarationContext> declaration() { |
| return getRuleContexts(DeclarationContext.class); |
| } |
| public DeclarationContext declaration(int i) { |
| return getRuleContext(DeclarationContext.class,i); |
| } |
| 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 GoParserListener ) ((GoParserListener)listener).enterSourceFile(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitSourceFile(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitSourceFile(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final SourceFileContext sourceFile() throws RecognitionException { |
| SourceFileContext _localctx = new SourceFileContext(_ctx, getState()); |
| enterRule(_localctx, 0, RULE_sourceFile); |
| int _la; |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(198); |
| packageClause(); |
| setState(199); |
| eos(); |
| setState(205); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| while (_la==IMPORT) { |
| { |
| { |
| setState(200); |
| importDecl(); |
| setState(201); |
| eos(); |
| } |
| } |
| setState(207); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| } |
| setState(217); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| while (((_la) & ~0x3f) == 0 && ((1L << _la) & 34668552L) != 0) { |
| { |
| { |
| setState(211); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,1,_ctx) ) { |
| case 1: |
| { |
| setState(208); |
| functionDecl(); |
| } |
| break; |
| case 2: |
| { |
| setState(209); |
| methodDecl(); |
| } |
| break; |
| case 3: |
| { |
| setState(210); |
| declaration(); |
| } |
| break; |
| } |
| setState(213); |
| eos(); |
| } |
| } |
| setState(219); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| } |
| setState(220); |
| match(EOF); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class PackageClauseContext extends ParserRuleContext { |
| public Token packageName; |
| public TerminalNode PACKAGE() { return getToken(GoParser.PACKAGE, 0); } |
| public TerminalNode IDENTIFIER() { return getToken(GoParser.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 GoParserListener ) ((GoParserListener)listener).enterPackageClause(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitPackageClause(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitPackageClause(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final PackageClauseContext packageClause() throws RecognitionException { |
| PackageClauseContext _localctx = new PackageClauseContext(_ctx, getState()); |
| enterRule(_localctx, 2, RULE_packageClause); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(222); |
| match(PACKAGE); |
| setState(223); |
| ((PackageClauseContext)_localctx).packageName = match(IDENTIFIER); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class ImportDeclContext extends ParserRuleContext { |
| public TerminalNode IMPORT() { return getToken(GoParser.IMPORT, 0); } |
| public List<ImportSpecContext> importSpec() { |
| return getRuleContexts(ImportSpecContext.class); |
| } |
| public ImportSpecContext importSpec(int i) { |
| return getRuleContext(ImportSpecContext.class,i); |
| } |
| public TerminalNode L_PAREN() { return getToken(GoParser.L_PAREN, 0); } |
| public TerminalNode R_PAREN() { return getToken(GoParser.R_PAREN, 0); } |
| public List<EosContext> eos() { |
| return getRuleContexts(EosContext.class); |
| } |
| public EosContext eos(int i) { |
| return getRuleContext(EosContext.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 GoParserListener ) ((GoParserListener)listener).enterImportDecl(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitImportDecl(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitImportDecl(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final ImportDeclContext importDecl() throws RecognitionException { |
| ImportDeclContext _localctx = new ImportDeclContext(_ctx, getState()); |
| enterRule(_localctx, 4, RULE_importDecl); |
| int _la; |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(225); |
| match(IMPORT); |
| setState(237); |
| _errHandler.sync(this); |
| switch (_input.LA(1)) { |
| case IDENTIFIER: |
| case DOT: |
| case RAW_STRING_LIT: |
| case INTERPRETED_STRING_LIT: |
| { |
| setState(226); |
| importSpec(); |
| } |
| break; |
| case L_PAREN: |
| { |
| setState(227); |
| match(L_PAREN); |
| setState(233); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| while ((((_la - 27)) & ~0x3f) == 0 && ((1L << (_la - 27)) & 6755399441057793L) != 0) { |
| { |
| { |
| setState(228); |
| importSpec(); |
| setState(229); |
| eos(); |
| } |
| } |
| setState(235); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| } |
| setState(236); |
| match(R_PAREN); |
| } |
| break; |
| default: |
| throw new NoViableAltException(this); |
| } |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class ImportSpecContext extends ParserRuleContext { |
| public Token alias; |
| public ImportPathContext importPath() { |
| return getRuleContext(ImportPathContext.class,0); |
| } |
| public TerminalNode DOT() { return getToken(GoParser.DOT, 0); } |
| public TerminalNode IDENTIFIER() { return getToken(GoParser.IDENTIFIER, 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 GoParserListener ) ((GoParserListener)listener).enterImportSpec(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitImportSpec(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitImportSpec(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final ImportSpecContext importSpec() throws RecognitionException { |
| ImportSpecContext _localctx = new ImportSpecContext(_ctx, getState()); |
| enterRule(_localctx, 6, RULE_importSpec); |
| int _la; |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(240); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| if (_la==IDENTIFIER || _la==DOT) { |
| { |
| setState(239); |
| ((ImportSpecContext)_localctx).alias = _input.LT(1); |
| _la = _input.LA(1); |
| if ( !(_la==IDENTIFIER || _la==DOT) ) { |
| ((ImportSpecContext)_localctx).alias = (Token)_errHandler.recoverInline(this); |
| } |
| else { |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; |
| _errHandler.reportMatch(this); |
| consume(); |
| } |
| } |
| } |
| |
| setState(242); |
| importPath(); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class ImportPathContext extends ParserRuleContext { |
| public String_Context string_() { |
| return getRuleContext(String_Context.class,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 GoParserListener ) ((GoParserListener)listener).enterImportPath(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitImportPath(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitImportPath(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final ImportPathContext importPath() throws RecognitionException { |
| ImportPathContext _localctx = new ImportPathContext(_ctx, getState()); |
| enterRule(_localctx, 8, RULE_importPath); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(244); |
| string_(); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class DeclarationContext extends ParserRuleContext { |
| public ConstDeclContext constDecl() { |
| return getRuleContext(ConstDeclContext.class,0); |
| } |
| public TypeDeclContext typeDecl() { |
| return getRuleContext(TypeDeclContext.class,0); |
| } |
| public VarDeclContext varDecl() { |
| return getRuleContext(VarDeclContext.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 GoParserListener ) ((GoParserListener)listener).enterDeclaration(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitDeclaration(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitDeclaration(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final DeclarationContext declaration() throws RecognitionException { |
| DeclarationContext _localctx = new DeclarationContext(_ctx, getState()); |
| enterRule(_localctx, 10, RULE_declaration); |
| try { |
| setState(249); |
| _errHandler.sync(this); |
| switch (_input.LA(1)) { |
| case CONST: |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(246); |
| constDecl(); |
| } |
| break; |
| case TYPE: |
| enterOuterAlt(_localctx, 2); |
| { |
| setState(247); |
| typeDecl(); |
| } |
| break; |
| case VAR: |
| enterOuterAlt(_localctx, 3); |
| { |
| setState(248); |
| 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; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class ConstDeclContext extends ParserRuleContext { |
| public TerminalNode CONST() { return getToken(GoParser.CONST, 0); } |
| public List<ConstSpecContext> constSpec() { |
| return getRuleContexts(ConstSpecContext.class); |
| } |
| public ConstSpecContext constSpec(int i) { |
| return getRuleContext(ConstSpecContext.class,i); |
| } |
| public TerminalNode L_PAREN() { return getToken(GoParser.L_PAREN, 0); } |
| public TerminalNode R_PAREN() { return getToken(GoParser.R_PAREN, 0); } |
| public List<EosContext> eos() { |
| return getRuleContexts(EosContext.class); |
| } |
| public EosContext eos(int i) { |
| return getRuleContext(EosContext.class,i); |
| } |
| 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 GoParserListener ) ((GoParserListener)listener).enterConstDecl(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitConstDecl(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitConstDecl(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final ConstDeclContext constDecl() throws RecognitionException { |
| ConstDeclContext _localctx = new ConstDeclContext(_ctx, getState()); |
| enterRule(_localctx, 12, RULE_constDecl); |
| int _la; |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(251); |
| match(CONST); |
| setState(263); |
| _errHandler.sync(this); |
| switch (_input.LA(1)) { |
| case IDENTIFIER: |
| { |
| setState(252); |
| constSpec(); |
| } |
| break; |
| case L_PAREN: |
| { |
| setState(253); |
| match(L_PAREN); |
| setState(259); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| while (_la==IDENTIFIER) { |
| { |
| { |
| setState(254); |
| constSpec(); |
| setState(255); |
| eos(); |
| } |
| } |
| setState(261); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| } |
| setState(262); |
| match(R_PAREN); |
| } |
| break; |
| default: |
| throw new NoViableAltException(this); |
| } |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class ConstSpecContext extends ParserRuleContext { |
| public IdentifierListContext identifierList() { |
| return getRuleContext(IdentifierListContext.class,0); |
| } |
| public TerminalNode ASSIGN() { return getToken(GoParser.ASSIGN, 0); } |
| public ExpressionListContext expressionList() { |
| return getRuleContext(ExpressionListContext.class,0); |
| } |
| public Type_Context type_() { |
| return getRuleContext(Type_Context.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 GoParserListener ) ((GoParserListener)listener).enterConstSpec(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitConstSpec(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitConstSpec(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final ConstSpecContext constSpec() throws RecognitionException { |
| ConstSpecContext _localctx = new ConstSpecContext(_ctx, getState()); |
| enterRule(_localctx, 14, RULE_constSpec); |
| int _la; |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(265); |
| identifierList(); |
| setState(271); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) { |
| case 1: |
| { |
| setState(267); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| if (((_la) & ~0x3f) == 0 && ((1L << _la) & -6917529022943457768L) != 0) { |
| { |
| setState(266); |
| type_(); |
| } |
| } |
| |
| setState(269); |
| match(ASSIGN); |
| setState(270); |
| expressionList(); |
| } |
| break; |
| } |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class IdentifierListContext extends ParserRuleContext { |
| public List<TerminalNode> IDENTIFIER() { return getTokens(GoParser.IDENTIFIER); } |
| public TerminalNode IDENTIFIER(int i) { |
| return getToken(GoParser.IDENTIFIER, i); |
| } |
| public List<TerminalNode> COMMA() { return getTokens(GoParser.COMMA); } |
| public TerminalNode COMMA(int i) { |
| return getToken(GoParser.COMMA, i); |
| } |
| 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 GoParserListener ) ((GoParserListener)listener).enterIdentifierList(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitIdentifierList(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitIdentifierList(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final IdentifierListContext identifierList() throws RecognitionException { |
| IdentifierListContext _localctx = new IdentifierListContext(_ctx, getState()); |
| enterRule(_localctx, 16, RULE_identifierList); |
| try { |
| int _alt; |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(273); |
| match(IDENTIFIER); |
| setState(278); |
| _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(274); |
| match(COMMA); |
| setState(275); |
| match(IDENTIFIER); |
| } |
| } |
| } |
| setState(280); |
| _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; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class ExpressionListContext extends ParserRuleContext { |
| public List<ExpressionContext> expression() { |
| return getRuleContexts(ExpressionContext.class); |
| } |
| public ExpressionContext expression(int i) { |
| return getRuleContext(ExpressionContext.class,i); |
| } |
| public List<TerminalNode> COMMA() { return getTokens(GoParser.COMMA); } |
| public TerminalNode COMMA(int i) { |
| return getToken(GoParser.COMMA, i); |
| } |
| 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 GoParserListener ) ((GoParserListener)listener).enterExpressionList(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitExpressionList(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitExpressionList(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final ExpressionListContext expressionList() throws RecognitionException { |
| ExpressionListContext _localctx = new ExpressionListContext(_ctx, getState()); |
| enterRule(_localctx, 18, RULE_expressionList); |
| try { |
| int _alt; |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(281); |
| expression(0); |
| setState(286); |
| _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(282); |
| match(COMMA); |
| setState(283); |
| expression(0); |
| } |
| } |
| } |
| setState(288); |
| _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; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class TypeDeclContext extends ParserRuleContext { |
| public TerminalNode TYPE() { return getToken(GoParser.TYPE, 0); } |
| public List<TypeSpecContext> typeSpec() { |
| return getRuleContexts(TypeSpecContext.class); |
| } |
| public TypeSpecContext typeSpec(int i) { |
| return getRuleContext(TypeSpecContext.class,i); |
| } |
| public TerminalNode L_PAREN() { return getToken(GoParser.L_PAREN, 0); } |
| public TerminalNode R_PAREN() { return getToken(GoParser.R_PAREN, 0); } |
| public List<EosContext> eos() { |
| return getRuleContexts(EosContext.class); |
| } |
| public EosContext eos(int i) { |
| return getRuleContext(EosContext.class,i); |
| } |
| 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 GoParserListener ) ((GoParserListener)listener).enterTypeDecl(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitTypeDecl(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitTypeDecl(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final TypeDeclContext typeDecl() throws RecognitionException { |
| TypeDeclContext _localctx = new TypeDeclContext(_ctx, getState()); |
| enterRule(_localctx, 20, RULE_typeDecl); |
| int _la; |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(289); |
| match(TYPE); |
| setState(301); |
| _errHandler.sync(this); |
| switch (_input.LA(1)) { |
| case IDENTIFIER: |
| { |
| setState(290); |
| typeSpec(); |
| } |
| break; |
| case L_PAREN: |
| { |
| setState(291); |
| match(L_PAREN); |
| setState(297); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| while (_la==IDENTIFIER) { |
| { |
| { |
| setState(292); |
| typeSpec(); |
| setState(293); |
| eos(); |
| } |
| } |
| setState(299); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| } |
| setState(300); |
| match(R_PAREN); |
| } |
| break; |
| default: |
| throw new NoViableAltException(this); |
| } |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class TypeSpecContext extends ParserRuleContext { |
| public TerminalNode IDENTIFIER() { return getToken(GoParser.IDENTIFIER, 0); } |
| public Type_Context type_() { |
| return getRuleContext(Type_Context.class,0); |
| } |
| public TerminalNode ASSIGN() { return getToken(GoParser.ASSIGN, 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 GoParserListener ) ((GoParserListener)listener).enterTypeSpec(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitTypeSpec(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitTypeSpec(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final TypeSpecContext typeSpec() throws RecognitionException { |
| TypeSpecContext _localctx = new TypeSpecContext(_ctx, getState()); |
| enterRule(_localctx, 22, RULE_typeSpec); |
| int _la; |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(303); |
| match(IDENTIFIER); |
| setState(305); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| if (_la==ASSIGN) { |
| { |
| setState(304); |
| match(ASSIGN); |
| } |
| } |
| |
| setState(307); |
| type_(); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class FunctionDeclContext extends ParserRuleContext { |
| public TerminalNode FUNC() { return getToken(GoParser.FUNC, 0); } |
| public TerminalNode IDENTIFIER() { return getToken(GoParser.IDENTIFIER, 0); } |
| public SignatureContext signature() { |
| return getRuleContext(SignatureContext.class,0); |
| } |
| public BlockContext block() { |
| return getRuleContext(BlockContext.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 GoParserListener ) ((GoParserListener)listener).enterFunctionDecl(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitFunctionDecl(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitFunctionDecl(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final FunctionDeclContext functionDecl() throws RecognitionException { |
| FunctionDeclContext _localctx = new FunctionDeclContext(_ctx, getState()); |
| enterRule(_localctx, 24, RULE_functionDecl); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(309); |
| match(FUNC); |
| setState(310); |
| match(IDENTIFIER); |
| { |
| setState(311); |
| signature(); |
| setState(313); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) { |
| case 1: |
| { |
| setState(312); |
| block(); |
| } |
| break; |
| } |
| } |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class MethodDeclContext extends ParserRuleContext { |
| public TerminalNode FUNC() { return getToken(GoParser.FUNC, 0); } |
| public ReceiverContext receiver() { |
| return getRuleContext(ReceiverContext.class,0); |
| } |
| public TerminalNode IDENTIFIER() { return getToken(GoParser.IDENTIFIER, 0); } |
| public SignatureContext signature() { |
| return getRuleContext(SignatureContext.class,0); |
| } |
| public BlockContext block() { |
| return getRuleContext(BlockContext.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 GoParserListener ) ((GoParserListener)listener).enterMethodDecl(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitMethodDecl(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitMethodDecl(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final MethodDeclContext methodDecl() throws RecognitionException { |
| MethodDeclContext _localctx = new MethodDeclContext(_ctx, getState()); |
| enterRule(_localctx, 26, RULE_methodDecl); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(315); |
| match(FUNC); |
| setState(316); |
| receiver(); |
| setState(317); |
| match(IDENTIFIER); |
| { |
| setState(318); |
| signature(); |
| setState(320); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) { |
| case 1: |
| { |
| setState(319); |
| block(); |
| } |
| break; |
| } |
| } |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| 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 GoParserListener ) ((GoParserListener)listener).enterReceiver(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitReceiver(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitReceiver(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final ReceiverContext receiver() throws RecognitionException { |
| ReceiverContext _localctx = new ReceiverContext(_ctx, getState()); |
| enterRule(_localctx, 28, RULE_receiver); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(322); |
| parameters(); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class VarDeclContext extends ParserRuleContext { |
| public TerminalNode VAR() { return getToken(GoParser.VAR, 0); } |
| public List<VarSpecContext> varSpec() { |
| return getRuleContexts(VarSpecContext.class); |
| } |
| public VarSpecContext varSpec(int i) { |
| return getRuleContext(VarSpecContext.class,i); |
| } |
| public TerminalNode L_PAREN() { return getToken(GoParser.L_PAREN, 0); } |
| public TerminalNode R_PAREN() { return getToken(GoParser.R_PAREN, 0); } |
| public List<EosContext> eos() { |
| return getRuleContexts(EosContext.class); |
| } |
| public EosContext eos(int i) { |
| return getRuleContext(EosContext.class,i); |
| } |
| 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 GoParserListener ) ((GoParserListener)listener).enterVarDecl(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitVarDecl(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitVarDecl(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final VarDeclContext varDecl() throws RecognitionException { |
| VarDeclContext _localctx = new VarDeclContext(_ctx, getState()); |
| enterRule(_localctx, 30, RULE_varDecl); |
| int _la; |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(324); |
| match(VAR); |
| setState(336); |
| _errHandler.sync(this); |
| switch (_input.LA(1)) { |
| case IDENTIFIER: |
| { |
| setState(325); |
| varSpec(); |
| } |
| break; |
| case L_PAREN: |
| { |
| setState(326); |
| match(L_PAREN); |
| setState(332); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| while (_la==IDENTIFIER) { |
| { |
| { |
| setState(327); |
| varSpec(); |
| setState(328); |
| eos(); |
| } |
| } |
| setState(334); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| } |
| setState(335); |
| match(R_PAREN); |
| } |
| break; |
| default: |
| throw new NoViableAltException(this); |
| } |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class VarSpecContext extends ParserRuleContext { |
| public IdentifierListContext identifierList() { |
| return getRuleContext(IdentifierListContext.class,0); |
| } |
| public Type_Context type_() { |
| return getRuleContext(Type_Context.class,0); |
| } |
| public TerminalNode ASSIGN() { return getToken(GoParser.ASSIGN, 0); } |
| public ExpressionListContext expressionList() { |
| return getRuleContext(ExpressionListContext.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 GoParserListener ) ((GoParserListener)listener).enterVarSpec(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitVarSpec(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitVarSpec(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final VarSpecContext varSpec() throws RecognitionException { |
| VarSpecContext _localctx = new VarSpecContext(_ctx, getState()); |
| enterRule(_localctx, 32, RULE_varSpec); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(338); |
| identifierList(); |
| setState(346); |
| _errHandler.sync(this); |
| switch (_input.LA(1)) { |
| case FUNC: |
| case INTERFACE: |
| case MAP: |
| case STRUCT: |
| case CHAN: |
| case IDENTIFIER: |
| case L_PAREN: |
| case L_BRACKET: |
| case STAR: |
| case RECEIVE: |
| { |
| setState(339); |
| type_(); |
| setState(342); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) { |
| case 1: |
| { |
| setState(340); |
| match(ASSIGN); |
| setState(341); |
| expressionList(); |
| } |
| break; |
| } |
| } |
| break; |
| case ASSIGN: |
| { |
| setState(344); |
| match(ASSIGN); |
| setState(345); |
| 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; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class BlockContext extends ParserRuleContext { |
| public TerminalNode L_CURLY() { return getToken(GoParser.L_CURLY, 0); } |
| public TerminalNode R_CURLY() { return getToken(GoParser.R_CURLY, 0); } |
| 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 GoParserListener ) ((GoParserListener)listener).enterBlock(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitBlock(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitBlock(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final BlockContext block() throws RecognitionException { |
| BlockContext _localctx = new BlockContext(_ctx, getState()); |
| enterRule(_localctx, 34, RULE_block); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(348); |
| match(L_CURLY); |
| setState(350); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) { |
| case 1: |
| { |
| setState(349); |
| statementList(); |
| } |
| break; |
| } |
| setState(352); |
| match(R_CURLY); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class StatementListContext extends ParserRuleContext { |
| public List<StatementContext> statement() { |
| return getRuleContexts(StatementContext.class); |
| } |
| public StatementContext statement(int i) { |
| return getRuleContext(StatementContext.class,i); |
| } |
| public List<EosContext> eos() { |
| return getRuleContexts(EosContext.class); |
| } |
| public EosContext eos(int i) { |
| return getRuleContext(EosContext.class,i); |
| } |
| public List<TerminalNode> SEMI() { return getTokens(GoParser.SEMI); } |
| public TerminalNode SEMI(int i) { |
| return getToken(GoParser.SEMI, i); |
| } |
| public List<TerminalNode> EOS() { return getTokens(GoParser.EOS); } |
| public TerminalNode EOS(int i) { |
| return getToken(GoParser.EOS, i); |
| } |
| 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 GoParserListener ) ((GoParserListener)listener).enterStatementList(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitStatementList(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitStatementList(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final StatementListContext statementList() throws RecognitionException { |
| StatementListContext _localctx = new StatementListContext(_ctx, getState()); |
| enterRule(_localctx, 36, RULE_statementList); |
| int _la; |
| try { |
| int _alt; |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(366); |
| _errHandler.sync(this); |
| _alt = 1; |
| do { |
| switch (_alt) { |
| case 1: |
| { |
| { |
| setState(361); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) { |
| case 1: |
| { |
| setState(355); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| if (_la==SEMI) { |
| { |
| setState(354); |
| match(SEMI); |
| } |
| } |
| |
| } |
| break; |
| case 2: |
| { |
| setState(358); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| if (_la==EOS) { |
| { |
| setState(357); |
| match(EOS); |
| } |
| } |
| |
| } |
| break; |
| case 3: |
| { |
| setState(360); |
| if (!(this.closingBracket())) throw new FailedPredicateException(this, "this.closingBracket()"); |
| } |
| break; |
| } |
| setState(363); |
| statement(); |
| setState(364); |
| eos(); |
| } |
| } |
| break; |
| default: |
| throw new NoViableAltException(this); |
| } |
| setState(368); |
| _errHandler.sync(this); |
| _alt = getInterpreter().adaptivePredict(_input,26,_ctx); |
| } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class StatementContext extends ParserRuleContext { |
| public DeclarationContext declaration() { |
| return getRuleContext(DeclarationContext.class,0); |
| } |
| public LabeledStmtContext labeledStmt() { |
| return getRuleContext(LabeledStmtContext.class,0); |
| } |
| public SimpleStmtContext simpleStmt() { |
| return getRuleContext(SimpleStmtContext.class,0); |
| } |
| public GoStmtContext goStmt() { |
| return getRuleContext(GoStmtContext.class,0); |
| } |
| public ReturnStmtContext returnStmt() { |
| return getRuleContext(ReturnStmtContext.class,0); |
| } |
| public BreakStmtContext breakStmt() { |
| return getRuleContext(BreakStmtContext.class,0); |
| } |
| public ContinueStmtContext continueStmt() { |
| return getRuleContext(ContinueStmtContext.class,0); |
| } |
| public GotoStmtContext gotoStmt() { |
| return getRuleContext(GotoStmtContext.class,0); |
| } |
| public FallthroughStmtContext fallthroughStmt() { |
| return getRuleContext(FallthroughStmtContext.class,0); |
| } |
| public BlockContext block() { |
| return getRuleContext(BlockContext.class,0); |
| } |
| public IfStmtContext ifStmt() { |
| return getRuleContext(IfStmtContext.class,0); |
| } |
| public SwitchStmtContext switchStmt() { |
| return getRuleContext(SwitchStmtContext.class,0); |
| } |
| public SelectStmtContext selectStmt() { |
| return getRuleContext(SelectStmtContext.class,0); |
| } |
| public ForStmtContext forStmt() { |
| return getRuleContext(ForStmtContext.class,0); |
| } |
| public DeferStmtContext deferStmt() { |
| return getRuleContext(DeferStmtContext.class,0); |
| } |
| 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 GoParserListener ) ((GoParserListener)listener).enterStatement(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitStatement(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitStatement(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final StatementContext statement() throws RecognitionException { |
| StatementContext _localctx = new StatementContext(_ctx, getState()); |
| enterRule(_localctx, 38, RULE_statement); |
| try { |
| setState(385); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) { |
| case 1: |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(370); |
| declaration(); |
| } |
| break; |
| case 2: |
| enterOuterAlt(_localctx, 2); |
| { |
| setState(371); |
| labeledStmt(); |
| } |
| break; |
| case 3: |
| enterOuterAlt(_localctx, 3); |
| { |
| setState(372); |
| simpleStmt(); |
| } |
| break; |
| case 4: |
| enterOuterAlt(_localctx, 4); |
| { |
| setState(373); |
| goStmt(); |
| } |
| break; |
| case 5: |
| enterOuterAlt(_localctx, 5); |
| { |
| setState(374); |
| returnStmt(); |
| } |
| break; |
| case 6: |
| enterOuterAlt(_localctx, 6); |
| { |
| setState(375); |
| breakStmt(); |
| } |
| break; |
| case 7: |
| enterOuterAlt(_localctx, 7); |
| { |
| setState(376); |
| continueStmt(); |
| } |
| break; |
| case 8: |
| enterOuterAlt(_localctx, 8); |
| { |
| setState(377); |
| gotoStmt(); |
| } |
| break; |
| case 9: |
| enterOuterAlt(_localctx, 9); |
| { |
| setState(378); |
| fallthroughStmt(); |
| } |
| break; |
| case 10: |
| enterOuterAlt(_localctx, 10); |
| { |
| setState(379); |
| block(); |
| } |
| break; |
| case 11: |
| enterOuterAlt(_localctx, 11); |
| { |
| setState(380); |
| ifStmt(); |
| } |
| break; |
| case 12: |
| enterOuterAlt(_localctx, 12); |
| { |
| setState(381); |
| switchStmt(); |
| } |
| break; |
| case 13: |
| enterOuterAlt(_localctx, 13); |
| { |
| setState(382); |
| selectStmt(); |
| } |
| break; |
| case 14: |
| enterOuterAlt(_localctx, 14); |
| { |
| setState(383); |
| forStmt(); |
| } |
| break; |
| case 15: |
| enterOuterAlt(_localctx, 15); |
| { |
| setState(384); |
| deferStmt(); |
| } |
| break; |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class SimpleStmtContext extends ParserRuleContext { |
| public SendStmtContext sendStmt() { |
| return getRuleContext(SendStmtContext.class,0); |
| } |
| public IncDecStmtContext incDecStmt() { |
| return getRuleContext(IncDecStmtContext.class,0); |
| } |
| public AssignmentContext assignment() { |
| return getRuleContext(AssignmentContext.class,0); |
| } |
| public ExpressionStmtContext expressionStmt() { |
| return getRuleContext(ExpressionStmtContext.class,0); |
| } |
| public ShortVarDeclContext shortVarDecl() { |
| return getRuleContext(ShortVarDeclContext.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 GoParserListener ) ((GoParserListener)listener).enterSimpleStmt(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitSimpleStmt(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitSimpleStmt(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final SimpleStmtContext simpleStmt() throws RecognitionException { |
| SimpleStmtContext _localctx = new SimpleStmtContext(_ctx, getState()); |
| enterRule(_localctx, 40, RULE_simpleStmt); |
| try { |
| setState(392); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,28,_ctx) ) { |
| case 1: |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(387); |
| sendStmt(); |
| } |
| break; |
| case 2: |
| enterOuterAlt(_localctx, 2); |
| { |
| setState(388); |
| incDecStmt(); |
| } |
| break; |
| case 3: |
| enterOuterAlt(_localctx, 3); |
| { |
| setState(389); |
| assignment(); |
| } |
| break; |
| case 4: |
| enterOuterAlt(_localctx, 4); |
| { |
| setState(390); |
| expressionStmt(); |
| } |
| break; |
| case 5: |
| enterOuterAlt(_localctx, 5); |
| { |
| setState(391); |
| shortVarDecl(); |
| } |
| break; |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| 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 GoParserListener ) ((GoParserListener)listener).enterExpressionStmt(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitExpressionStmt(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitExpressionStmt(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final ExpressionStmtContext expressionStmt() throws RecognitionException { |
| ExpressionStmtContext _localctx = new ExpressionStmtContext(_ctx, getState()); |
| enterRule(_localctx, 42, RULE_expressionStmt); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(394); |
| expression(0); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class SendStmtContext extends ParserRuleContext { |
| public ExpressionContext channel; |
| public TerminalNode RECEIVE() { return getToken(GoParser.RECEIVE, 0); } |
| public List<ExpressionContext> expression() { |
| return getRuleContexts(ExpressionContext.class); |
| } |
| public ExpressionContext expression(int i) { |
| return getRuleContext(ExpressionContext.class,i); |
| } |
| public SendStmtContext(ParserRuleContext parent, int invokingState) { |
| super(parent, invokingState); |
| } |
| @Override public int getRuleIndex() { return RULE_sendStmt; } |
| @Override |
| public void enterRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).enterSendStmt(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitSendStmt(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitSendStmt(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final SendStmtContext sendStmt() throws RecognitionException { |
| SendStmtContext _localctx = new SendStmtContext(_ctx, getState()); |
| enterRule(_localctx, 44, RULE_sendStmt); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(396); |
| ((SendStmtContext)_localctx).channel = expression(0); |
| setState(397); |
| match(RECEIVE); |
| setState(398); |
| expression(0); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class IncDecStmtContext extends ParserRuleContext { |
| public ExpressionContext expression() { |
| return getRuleContext(ExpressionContext.class,0); |
| } |
| public TerminalNode PLUS_PLUS() { return getToken(GoParser.PLUS_PLUS, 0); } |
| public TerminalNode MINUS_MINUS() { return getToken(GoParser.MINUS_MINUS, 0); } |
| public IncDecStmtContext(ParserRuleContext parent, int invokingState) { |
| super(parent, invokingState); |
| } |
| @Override public int getRuleIndex() { return RULE_incDecStmt; } |
| @Override |
| public void enterRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).enterIncDecStmt(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitIncDecStmt(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitIncDecStmt(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final IncDecStmtContext incDecStmt() throws RecognitionException { |
| IncDecStmtContext _localctx = new IncDecStmtContext(_ctx, getState()); |
| enterRule(_localctx, 46, RULE_incDecStmt); |
| int _la; |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(400); |
| expression(0); |
| setState(401); |
| _la = _input.LA(1); |
| if ( !(_la==PLUS_PLUS || _la==MINUS_MINUS) ) { |
| _errHandler.recoverInline(this); |
| } |
| else { |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; |
| _errHandler.reportMatch(this); |
| consume(); |
| } |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class AssignmentContext extends ParserRuleContext { |
| public List<ExpressionListContext> expressionList() { |
| return getRuleContexts(ExpressionListContext.class); |
| } |
| public ExpressionListContext expressionList(int i) { |
| return getRuleContext(ExpressionListContext.class,i); |
| } |
| public Assign_opContext assign_op() { |
| return getRuleContext(Assign_opContext.class,0); |
| } |
| public AssignmentContext(ParserRuleContext parent, int invokingState) { |
| super(parent, invokingState); |
| } |
| @Override public int getRuleIndex() { return RULE_assignment; } |
| @Override |
| public void enterRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).enterAssignment(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitAssignment(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitAssignment(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final AssignmentContext assignment() throws RecognitionException { |
| AssignmentContext _localctx = new AssignmentContext(_ctx, getState()); |
| enterRule(_localctx, 48, RULE_assignment); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(403); |
| expressionList(); |
| setState(404); |
| assign_op(); |
| setState(405); |
| expressionList(); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class Assign_opContext extends ParserRuleContext { |
| public TerminalNode ASSIGN() { return getToken(GoParser.ASSIGN, 0); } |
| public TerminalNode PLUS() { return getToken(GoParser.PLUS, 0); } |
| public TerminalNode MINUS() { return getToken(GoParser.MINUS, 0); } |
| public TerminalNode OR() { return getToken(GoParser.OR, 0); } |
| public TerminalNode CARET() { return getToken(GoParser.CARET, 0); } |
| public TerminalNode STAR() { return getToken(GoParser.STAR, 0); } |
| public TerminalNode DIV() { return getToken(GoParser.DIV, 0); } |
| public TerminalNode MOD() { return getToken(GoParser.MOD, 0); } |
| public TerminalNode LSHIFT() { return getToken(GoParser.LSHIFT, 0); } |
| public TerminalNode RSHIFT() { return getToken(GoParser.RSHIFT, 0); } |
| public TerminalNode AMPERSAND() { return getToken(GoParser.AMPERSAND, 0); } |
| public TerminalNode BIT_CLEAR() { return getToken(GoParser.BIT_CLEAR, 0); } |
| public Assign_opContext(ParserRuleContext parent, int invokingState) { |
| super(parent, invokingState); |
| } |
| @Override public int getRuleIndex() { return RULE_assign_op; } |
| @Override |
| public void enterRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).enterAssign_op(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitAssign_op(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitAssign_op(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final Assign_opContext assign_op() throws RecognitionException { |
| Assign_opContext _localctx = new Assign_opContext(_ctx, getState()); |
| enterRule(_localctx, 50, RULE_assign_op); |
| int _la; |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(408); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| if (((_la) & ~0x3f) == 0 && ((1L << _la) & 9077005048965234688L) != 0) { |
| { |
| setState(407); |
| _la = _input.LA(1); |
| if ( !(((_la) & ~0x3f) == 0 && ((1L << _la) & 9077005048965234688L) != 0) ) { |
| _errHandler.recoverInline(this); |
| } |
| else { |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; |
| _errHandler.reportMatch(this); |
| consume(); |
| } |
| } |
| } |
| |
| setState(410); |
| match(ASSIGN); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class ShortVarDeclContext extends ParserRuleContext { |
| public IdentifierListContext identifierList() { |
| return getRuleContext(IdentifierListContext.class,0); |
| } |
| public TerminalNode DECLARE_ASSIGN() { return getToken(GoParser.DECLARE_ASSIGN, 0); } |
| public ExpressionListContext expressionList() { |
| return getRuleContext(ExpressionListContext.class,0); |
| } |
| public ShortVarDeclContext(ParserRuleContext parent, int invokingState) { |
| super(parent, invokingState); |
| } |
| @Override public int getRuleIndex() { return RULE_shortVarDecl; } |
| @Override |
| public void enterRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).enterShortVarDecl(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitShortVarDecl(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitShortVarDecl(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final ShortVarDeclContext shortVarDecl() throws RecognitionException { |
| ShortVarDeclContext _localctx = new ShortVarDeclContext(_ctx, getState()); |
| enterRule(_localctx, 52, RULE_shortVarDecl); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(412); |
| identifierList(); |
| setState(413); |
| match(DECLARE_ASSIGN); |
| setState(414); |
| expressionList(); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class EmptyStmtContext extends ParserRuleContext { |
| public TerminalNode EOS() { return getToken(GoParser.EOS, 0); } |
| public TerminalNode SEMI() { return getToken(GoParser.SEMI, 0); } |
| public EmptyStmtContext(ParserRuleContext parent, int invokingState) { |
| super(parent, invokingState); |
| } |
| @Override public int getRuleIndex() { return RULE_emptyStmt; } |
| @Override |
| public void enterRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).enterEmptyStmt(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitEmptyStmt(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitEmptyStmt(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final EmptyStmtContext emptyStmt() throws RecognitionException { |
| EmptyStmtContext _localctx = new EmptyStmtContext(_ctx, getState()); |
| enterRule(_localctx, 54, RULE_emptyStmt); |
| int _la; |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(416); |
| _la = _input.LA(1); |
| if ( !(_la==SEMI || _la==EOS) ) { |
| _errHandler.recoverInline(this); |
| } |
| else { |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; |
| _errHandler.reportMatch(this); |
| consume(); |
| } |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class LabeledStmtContext extends ParserRuleContext { |
| public TerminalNode IDENTIFIER() { return getToken(GoParser.IDENTIFIER, 0); } |
| public TerminalNode COLON() { return getToken(GoParser.COLON, 0); } |
| public StatementContext statement() { |
| return getRuleContext(StatementContext.class,0); |
| } |
| public LabeledStmtContext(ParserRuleContext parent, int invokingState) { |
| super(parent, invokingState); |
| } |
| @Override public int getRuleIndex() { return RULE_labeledStmt; } |
| @Override |
| public void enterRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).enterLabeledStmt(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitLabeledStmt(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitLabeledStmt(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final LabeledStmtContext labeledStmt() throws RecognitionException { |
| LabeledStmtContext _localctx = new LabeledStmtContext(_ctx, getState()); |
| enterRule(_localctx, 56, RULE_labeledStmt); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(418); |
| match(IDENTIFIER); |
| setState(419); |
| match(COLON); |
| setState(421); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) { |
| case 1: |
| { |
| setState(420); |
| statement(); |
| } |
| break; |
| } |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class ReturnStmtContext extends ParserRuleContext { |
| public TerminalNode RETURN() { return getToken(GoParser.RETURN, 0); } |
| public ExpressionListContext expressionList() { |
| return getRuleContext(ExpressionListContext.class,0); |
| } |
| public ReturnStmtContext(ParserRuleContext parent, int invokingState) { |
| super(parent, invokingState); |
| } |
| @Override public int getRuleIndex() { return RULE_returnStmt; } |
| @Override |
| public void enterRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).enterReturnStmt(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitReturnStmt(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitReturnStmt(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final ReturnStmtContext returnStmt() throws RecognitionException { |
| ReturnStmtContext _localctx = new ReturnStmtContext(_ctx, getState()); |
| enterRule(_localctx, 58, RULE_returnStmt); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(423); |
| match(RETURN); |
| setState(425); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,31,_ctx) ) { |
| case 1: |
| { |
| setState(424); |
| expressionList(); |
| } |
| break; |
| } |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class BreakStmtContext extends ParserRuleContext { |
| public TerminalNode BREAK() { return getToken(GoParser.BREAK, 0); } |
| public TerminalNode IDENTIFIER() { return getToken(GoParser.IDENTIFIER, 0); } |
| public BreakStmtContext(ParserRuleContext parent, int invokingState) { |
| super(parent, invokingState); |
| } |
| @Override public int getRuleIndex() { return RULE_breakStmt; } |
| @Override |
| public void enterRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).enterBreakStmt(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitBreakStmt(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitBreakStmt(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final BreakStmtContext breakStmt() throws RecognitionException { |
| BreakStmtContext _localctx = new BreakStmtContext(_ctx, getState()); |
| enterRule(_localctx, 60, RULE_breakStmt); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(427); |
| match(BREAK); |
| setState(429); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,32,_ctx) ) { |
| case 1: |
| { |
| setState(428); |
| match(IDENTIFIER); |
| } |
| break; |
| } |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class ContinueStmtContext extends ParserRuleContext { |
| public TerminalNode CONTINUE() { return getToken(GoParser.CONTINUE, 0); } |
| public TerminalNode IDENTIFIER() { return getToken(GoParser.IDENTIFIER, 0); } |
| public ContinueStmtContext(ParserRuleContext parent, int invokingState) { |
| super(parent, invokingState); |
| } |
| @Override public int getRuleIndex() { return RULE_continueStmt; } |
| @Override |
| public void enterRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).enterContinueStmt(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitContinueStmt(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitContinueStmt(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final ContinueStmtContext continueStmt() throws RecognitionException { |
| ContinueStmtContext _localctx = new ContinueStmtContext(_ctx, getState()); |
| enterRule(_localctx, 62, RULE_continueStmt); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(431); |
| match(CONTINUE); |
| setState(433); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,33,_ctx) ) { |
| case 1: |
| { |
| setState(432); |
| match(IDENTIFIER); |
| } |
| break; |
| } |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class GotoStmtContext extends ParserRuleContext { |
| public TerminalNode GOTO() { return getToken(GoParser.GOTO, 0); } |
| public TerminalNode IDENTIFIER() { return getToken(GoParser.IDENTIFIER, 0); } |
| public GotoStmtContext(ParserRuleContext parent, int invokingState) { |
| super(parent, invokingState); |
| } |
| @Override public int getRuleIndex() { return RULE_gotoStmt; } |
| @Override |
| public void enterRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).enterGotoStmt(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitGotoStmt(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitGotoStmt(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final GotoStmtContext gotoStmt() throws RecognitionException { |
| GotoStmtContext _localctx = new GotoStmtContext(_ctx, getState()); |
| enterRule(_localctx, 64, RULE_gotoStmt); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(435); |
| match(GOTO); |
| setState(436); |
| match(IDENTIFIER); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class FallthroughStmtContext extends ParserRuleContext { |
| public TerminalNode FALLTHROUGH() { return getToken(GoParser.FALLTHROUGH, 0); } |
| public FallthroughStmtContext(ParserRuleContext parent, int invokingState) { |
| super(parent, invokingState); |
| } |
| @Override public int getRuleIndex() { return RULE_fallthroughStmt; } |
| @Override |
| public void enterRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).enterFallthroughStmt(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitFallthroughStmt(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitFallthroughStmt(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final FallthroughStmtContext fallthroughStmt() throws RecognitionException { |
| FallthroughStmtContext _localctx = new FallthroughStmtContext(_ctx, getState()); |
| enterRule(_localctx, 66, RULE_fallthroughStmt); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(438); |
| match(FALLTHROUGH); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class DeferStmtContext extends ParserRuleContext { |
| public TerminalNode DEFER() { return getToken(GoParser.DEFER, 0); } |
| public ExpressionContext expression() { |
| return getRuleContext(ExpressionContext.class,0); |
| } |
| public DeferStmtContext(ParserRuleContext parent, int invokingState) { |
| super(parent, invokingState); |
| } |
| @Override public int getRuleIndex() { return RULE_deferStmt; } |
| @Override |
| public void enterRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).enterDeferStmt(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitDeferStmt(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitDeferStmt(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final DeferStmtContext deferStmt() throws RecognitionException { |
| DeferStmtContext _localctx = new DeferStmtContext(_ctx, getState()); |
| enterRule(_localctx, 68, RULE_deferStmt); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(440); |
| match(DEFER); |
| setState(441); |
| expression(0); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class IfStmtContext extends ParserRuleContext { |
| public TerminalNode IF() { return getToken(GoParser.IF, 0); } |
| public List<BlockContext> block() { |
| return getRuleContexts(BlockContext.class); |
| } |
| public BlockContext block(int i) { |
| return getRuleContext(BlockContext.class,i); |
| } |
| public ExpressionContext expression() { |
| return getRuleContext(ExpressionContext.class,0); |
| } |
| public EosContext eos() { |
| return getRuleContext(EosContext.class,0); |
| } |
| public SimpleStmtContext simpleStmt() { |
| return getRuleContext(SimpleStmtContext.class,0); |
| } |
| public TerminalNode ELSE() { return getToken(GoParser.ELSE, 0); } |
| public IfStmtContext ifStmt() { |
| return getRuleContext(IfStmtContext.class,0); |
| } |
| 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 GoParserListener ) ((GoParserListener)listener).enterIfStmt(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitIfStmt(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitIfStmt(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final IfStmtContext ifStmt() throws RecognitionException { |
| IfStmtContext _localctx = new IfStmtContext(_ctx, getState()); |
| enterRule(_localctx, 70, RULE_ifStmt); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(443); |
| match(IF); |
| setState(452); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,34,_ctx) ) { |
| case 1: |
| { |
| setState(444); |
| expression(0); |
| } |
| break; |
| case 2: |
| { |
| setState(445); |
| eos(); |
| setState(446); |
| expression(0); |
| } |
| break; |
| case 3: |
| { |
| setState(448); |
| simpleStmt(); |
| setState(449); |
| eos(); |
| setState(450); |
| expression(0); |
| } |
| break; |
| } |
| setState(454); |
| block(); |
| setState(460); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,36,_ctx) ) { |
| case 1: |
| { |
| setState(455); |
| match(ELSE); |
| setState(458); |
| _errHandler.sync(this); |
| switch (_input.LA(1)) { |
| case IF: |
| { |
| setState(456); |
| ifStmt(); |
| } |
| break; |
| case L_CURLY: |
| { |
| setState(457); |
| 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; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class SwitchStmtContext extends ParserRuleContext { |
| public ExprSwitchStmtContext exprSwitchStmt() { |
| return getRuleContext(ExprSwitchStmtContext.class,0); |
| } |
| public TypeSwitchStmtContext typeSwitchStmt() { |
| return getRuleContext(TypeSwitchStmtContext.class,0); |
| } |
| public SwitchStmtContext(ParserRuleContext parent, int invokingState) { |
| super(parent, invokingState); |
| } |
| @Override public int getRuleIndex() { return RULE_switchStmt; } |
| @Override |
| public void enterRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).enterSwitchStmt(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitSwitchStmt(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitSwitchStmt(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final SwitchStmtContext switchStmt() throws RecognitionException { |
| SwitchStmtContext _localctx = new SwitchStmtContext(_ctx, getState()); |
| enterRule(_localctx, 72, RULE_switchStmt); |
| try { |
| setState(464); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) { |
| case 1: |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(462); |
| exprSwitchStmt(); |
| } |
| break; |
| case 2: |
| enterOuterAlt(_localctx, 2); |
| { |
| setState(463); |
| typeSwitchStmt(); |
| } |
| break; |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class ExprSwitchStmtContext extends ParserRuleContext { |
| public TerminalNode SWITCH() { return getToken(GoParser.SWITCH, 0); } |
| public TerminalNode L_CURLY() { return getToken(GoParser.L_CURLY, 0); } |
| public TerminalNode R_CURLY() { return getToken(GoParser.R_CURLY, 0); } |
| public EosContext eos() { |
| return getRuleContext(EosContext.class,0); |
| } |
| public List<ExprCaseClauseContext> exprCaseClause() { |
| return getRuleContexts(ExprCaseClauseContext.class); |
| } |
| public ExprCaseClauseContext exprCaseClause(int i) { |
| return getRuleContext(ExprCaseClauseContext.class,i); |
| } |
| public ExpressionContext expression() { |
| return getRuleContext(ExpressionContext.class,0); |
| } |
| public SimpleStmtContext simpleStmt() { |
| return getRuleContext(SimpleStmtContext.class,0); |
| } |
| public ExprSwitchStmtContext(ParserRuleContext parent, int invokingState) { |
| super(parent, invokingState); |
| } |
| @Override public int getRuleIndex() { return RULE_exprSwitchStmt; } |
| @Override |
| public void enterRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).enterExprSwitchStmt(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitExprSwitchStmt(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitExprSwitchStmt(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final ExprSwitchStmtContext exprSwitchStmt() throws RecognitionException { |
| ExprSwitchStmtContext _localctx = new ExprSwitchStmtContext(_ctx, getState()); |
| enterRule(_localctx, 74, RULE_exprSwitchStmt); |
| int _la; |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(466); |
| match(SWITCH); |
| setState(477); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,41,_ctx) ) { |
| case 1: |
| { |
| setState(468); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| if (((_la) & ~0x3f) == 0 && ((1L << _la) & -144115183311122920L) != 0 || (((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 49567L) != 0) { |
| { |
| setState(467); |
| expression(0); |
| } |
| } |
| |
| } |
| break; |
| case 2: |
| { |
| setState(471); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,39,_ctx) ) { |
| case 1: |
| { |
| setState(470); |
| simpleStmt(); |
| } |
| break; |
| } |
| setState(473); |
| eos(); |
| setState(475); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| if (((_la) & ~0x3f) == 0 && ((1L << _la) & -144115183311122920L) != 0 || (((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 49567L) != 0) { |
| { |
| setState(474); |
| expression(0); |
| } |
| } |
| |
| } |
| break; |
| } |
| setState(479); |
| match(L_CURLY); |
| setState(483); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| while (_la==DEFAULT || _la==CASE) { |
| { |
| { |
| setState(480); |
| exprCaseClause(); |
| } |
| } |
| setState(485); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| } |
| setState(486); |
| match(R_CURLY); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class ExprCaseClauseContext extends ParserRuleContext { |
| public ExprSwitchCaseContext exprSwitchCase() { |
| return getRuleContext(ExprSwitchCaseContext.class,0); |
| } |
| public TerminalNode COLON() { return getToken(GoParser.COLON, 0); } |
| public StatementListContext statementList() { |
| return getRuleContext(StatementListContext.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 GoParserListener ) ((GoParserListener)listener).enterExprCaseClause(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitExprCaseClause(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitExprCaseClause(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final ExprCaseClauseContext exprCaseClause() throws RecognitionException { |
| ExprCaseClauseContext _localctx = new ExprCaseClauseContext(_ctx, getState()); |
| enterRule(_localctx, 76, RULE_exprCaseClause); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(488); |
| exprSwitchCase(); |
| setState(489); |
| match(COLON); |
| setState(491); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,43,_ctx) ) { |
| case 1: |
| { |
| setState(490); |
| statementList(); |
| } |
| break; |
| } |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class ExprSwitchCaseContext extends ParserRuleContext { |
| public TerminalNode CASE() { return getToken(GoParser.CASE, 0); } |
| public ExpressionListContext expressionList() { |
| return getRuleContext(ExpressionListContext.class,0); |
| } |
| public TerminalNode DEFAULT() { return getToken(GoParser.DEFAULT, 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 GoParserListener ) ((GoParserListener)listener).enterExprSwitchCase(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitExprSwitchCase(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitExprSwitchCase(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final ExprSwitchCaseContext exprSwitchCase() throws RecognitionException { |
| ExprSwitchCaseContext _localctx = new ExprSwitchCaseContext(_ctx, getState()); |
| enterRule(_localctx, 78, RULE_exprSwitchCase); |
| try { |
| setState(496); |
| _errHandler.sync(this); |
| switch (_input.LA(1)) { |
| case CASE: |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(493); |
| match(CASE); |
| setState(494); |
| expressionList(); |
| } |
| break; |
| case DEFAULT: |
| enterOuterAlt(_localctx, 2); |
| { |
| setState(495); |
| match(DEFAULT); |
| } |
| break; |
| default: |
| throw new NoViableAltException(this); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class TypeSwitchStmtContext extends ParserRuleContext { |
| public TerminalNode SWITCH() { return getToken(GoParser.SWITCH, 0); } |
| public TerminalNode L_CURLY() { return getToken(GoParser.L_CURLY, 0); } |
| public TerminalNode R_CURLY() { return getToken(GoParser.R_CURLY, 0); } |
| public TypeSwitchGuardContext typeSwitchGuard() { |
| return getRuleContext(TypeSwitchGuardContext.class,0); |
| } |
| public EosContext eos() { |
| return getRuleContext(EosContext.class,0); |
| } |
| public SimpleStmtContext simpleStmt() { |
| return getRuleContext(SimpleStmtContext.class,0); |
| } |
| public List<TypeCaseClauseContext> typeCaseClause() { |
| return getRuleContexts(TypeCaseClauseContext.class); |
| } |
| public TypeCaseClauseContext typeCaseClause(int i) { |
| return getRuleContext(TypeCaseClauseContext.class,i); |
| } |
| public TypeSwitchStmtContext(ParserRuleContext parent, int invokingState) { |
| super(parent, invokingState); |
| } |
| @Override public int getRuleIndex() { return RULE_typeSwitchStmt; } |
| @Override |
| public void enterRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).enterTypeSwitchStmt(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitTypeSwitchStmt(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitTypeSwitchStmt(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final TypeSwitchStmtContext typeSwitchStmt() throws RecognitionException { |
| TypeSwitchStmtContext _localctx = new TypeSwitchStmtContext(_ctx, getState()); |
| enterRule(_localctx, 80, RULE_typeSwitchStmt); |
| int _la; |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(498); |
| match(SWITCH); |
| setState(507); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) { |
| case 1: |
| { |
| setState(499); |
| typeSwitchGuard(); |
| } |
| break; |
| case 2: |
| { |
| setState(500); |
| eos(); |
| setState(501); |
| typeSwitchGuard(); |
| } |
| break; |
| case 3: |
| { |
| setState(503); |
| simpleStmt(); |
| setState(504); |
| eos(); |
| setState(505); |
| typeSwitchGuard(); |
| } |
| break; |
| } |
| setState(509); |
| match(L_CURLY); |
| setState(513); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| while (_la==DEFAULT || _la==CASE) { |
| { |
| { |
| setState(510); |
| typeCaseClause(); |
| } |
| } |
| setState(515); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| } |
| setState(516); |
| match(R_CURLY); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class TypeSwitchGuardContext extends ParserRuleContext { |
| public PrimaryExprContext primaryExpr() { |
| return getRuleContext(PrimaryExprContext.class,0); |
| } |
| public TerminalNode DOT() { return getToken(GoParser.DOT, 0); } |
| public TerminalNode L_PAREN() { return getToken(GoParser.L_PAREN, 0); } |
| public TerminalNode TYPE() { return getToken(GoParser.TYPE, 0); } |
| public TerminalNode R_PAREN() { return getToken(GoParser.R_PAREN, 0); } |
| public TerminalNode IDENTIFIER() { return getToken(GoParser.IDENTIFIER, 0); } |
| public TerminalNode DECLARE_ASSIGN() { return getToken(GoParser.DECLARE_ASSIGN, 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 GoParserListener ) ((GoParserListener)listener).enterTypeSwitchGuard(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitTypeSwitchGuard(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitTypeSwitchGuard(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final TypeSwitchGuardContext typeSwitchGuard() throws RecognitionException { |
| TypeSwitchGuardContext _localctx = new TypeSwitchGuardContext(_ctx, getState()); |
| enterRule(_localctx, 82, RULE_typeSwitchGuard); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(520); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,47,_ctx) ) { |
| case 1: |
| { |
| setState(518); |
| match(IDENTIFIER); |
| setState(519); |
| match(DECLARE_ASSIGN); |
| } |
| break; |
| } |
| setState(522); |
| primaryExpr(0); |
| setState(523); |
| match(DOT); |
| setState(524); |
| match(L_PAREN); |
| setState(525); |
| match(TYPE); |
| setState(526); |
| match(R_PAREN); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class TypeCaseClauseContext extends ParserRuleContext { |
| public TypeSwitchCaseContext typeSwitchCase() { |
| return getRuleContext(TypeSwitchCaseContext.class,0); |
| } |
| public TerminalNode COLON() { return getToken(GoParser.COLON, 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 GoParserListener ) ((GoParserListener)listener).enterTypeCaseClause(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitTypeCaseClause(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitTypeCaseClause(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final TypeCaseClauseContext typeCaseClause() throws RecognitionException { |
| TypeCaseClauseContext _localctx = new TypeCaseClauseContext(_ctx, getState()); |
| enterRule(_localctx, 84, RULE_typeCaseClause); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(528); |
| typeSwitchCase(); |
| setState(529); |
| match(COLON); |
| setState(531); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,48,_ctx) ) { |
| case 1: |
| { |
| setState(530); |
| statementList(); |
| } |
| break; |
| } |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class TypeSwitchCaseContext extends ParserRuleContext { |
| public TerminalNode CASE() { return getToken(GoParser.CASE, 0); } |
| public TypeListContext typeList() { |
| return getRuleContext(TypeListContext.class,0); |
| } |
| public TerminalNode DEFAULT() { return getToken(GoParser.DEFAULT, 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 GoParserListener ) ((GoParserListener)listener).enterTypeSwitchCase(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitTypeSwitchCase(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitTypeSwitchCase(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final TypeSwitchCaseContext typeSwitchCase() throws RecognitionException { |
| TypeSwitchCaseContext _localctx = new TypeSwitchCaseContext(_ctx, getState()); |
| enterRule(_localctx, 86, RULE_typeSwitchCase); |
| try { |
| setState(536); |
| _errHandler.sync(this); |
| switch (_input.LA(1)) { |
| case CASE: |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(533); |
| match(CASE); |
| setState(534); |
| typeList(); |
| } |
| break; |
| case DEFAULT: |
| enterOuterAlt(_localctx, 2); |
| { |
| setState(535); |
| match(DEFAULT); |
| } |
| break; |
| default: |
| throw new NoViableAltException(this); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class TypeListContext extends ParserRuleContext { |
| public List<Type_Context> type_() { |
| return getRuleContexts(Type_Context.class); |
| } |
| public Type_Context type_(int i) { |
| return getRuleContext(Type_Context.class,i); |
| } |
| public List<TerminalNode> NIL_LIT() { return getTokens(GoParser.NIL_LIT); } |
| public TerminalNode NIL_LIT(int i) { |
| return getToken(GoParser.NIL_LIT, i); |
| } |
| public List<TerminalNode> COMMA() { return getTokens(GoParser.COMMA); } |
| public TerminalNode COMMA(int i) { |
| return getToken(GoParser.COMMA, i); |
| } |
| 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 GoParserListener ) ((GoParserListener)listener).enterTypeList(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitTypeList(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitTypeList(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final TypeListContext typeList() throws RecognitionException { |
| TypeListContext _localctx = new TypeListContext(_ctx, getState()); |
| enterRule(_localctx, 88, RULE_typeList); |
| int _la; |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(540); |
| _errHandler.sync(this); |
| switch (_input.LA(1)) { |
| case FUNC: |
| case INTERFACE: |
| case MAP: |
| case STRUCT: |
| case CHAN: |
| case IDENTIFIER: |
| case L_PAREN: |
| case L_BRACKET: |
| case STAR: |
| case RECEIVE: |
| { |
| setState(538); |
| type_(); |
| } |
| break; |
| case NIL_LIT: |
| { |
| setState(539); |
| match(NIL_LIT); |
| } |
| break; |
| default: |
| throw new NoViableAltException(this); |
| } |
| setState(549); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| while (_la==COMMA) { |
| { |
| { |
| setState(542); |
| match(COMMA); |
| setState(545); |
| _errHandler.sync(this); |
| switch (_input.LA(1)) { |
| case FUNC: |
| case INTERFACE: |
| case MAP: |
| case STRUCT: |
| case CHAN: |
| case IDENTIFIER: |
| case L_PAREN: |
| case L_BRACKET: |
| case STAR: |
| case RECEIVE: |
| { |
| setState(543); |
| type_(); |
| } |
| break; |
| case NIL_LIT: |
| { |
| setState(544); |
| match(NIL_LIT); |
| } |
| break; |
| default: |
| throw new NoViableAltException(this); |
| } |
| } |
| } |
| setState(551); |
| _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; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class SelectStmtContext extends ParserRuleContext { |
| public TerminalNode SELECT() { return getToken(GoParser.SELECT, 0); } |
| public TerminalNode L_CURLY() { return getToken(GoParser.L_CURLY, 0); } |
| public TerminalNode R_CURLY() { return getToken(GoParser.R_CURLY, 0); } |
| public List<CommClauseContext> commClause() { |
| return getRuleContexts(CommClauseContext.class); |
| } |
| public CommClauseContext commClause(int i) { |
| return getRuleContext(CommClauseContext.class,i); |
| } |
| public SelectStmtContext(ParserRuleContext parent, int invokingState) { |
| super(parent, invokingState); |
| } |
| @Override public int getRuleIndex() { return RULE_selectStmt; } |
| @Override |
| public void enterRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).enterSelectStmt(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitSelectStmt(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitSelectStmt(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final SelectStmtContext selectStmt() throws RecognitionException { |
| SelectStmtContext _localctx = new SelectStmtContext(_ctx, getState()); |
| enterRule(_localctx, 90, RULE_selectStmt); |
| int _la; |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(552); |
| match(SELECT); |
| setState(553); |
| match(L_CURLY); |
| setState(557); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| while (_la==DEFAULT || _la==CASE) { |
| { |
| { |
| setState(554); |
| commClause(); |
| } |
| } |
| setState(559); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| } |
| setState(560); |
| match(R_CURLY); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class CommClauseContext extends ParserRuleContext { |
| public CommCaseContext commCase() { |
| return getRuleContext(CommCaseContext.class,0); |
| } |
| public TerminalNode COLON() { return getToken(GoParser.COLON, 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 GoParserListener ) ((GoParserListener)listener).enterCommClause(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitCommClause(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitCommClause(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final CommClauseContext commClause() throws RecognitionException { |
| CommClauseContext _localctx = new CommClauseContext(_ctx, getState()); |
| enterRule(_localctx, 92, RULE_commClause); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(562); |
| commCase(); |
| setState(563); |
| match(COLON); |
| setState(565); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,54,_ctx) ) { |
| case 1: |
| { |
| setState(564); |
| statementList(); |
| } |
| break; |
| } |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class CommCaseContext extends ParserRuleContext { |
| public TerminalNode CASE() { return getToken(GoParser.CASE, 0); } |
| public SendStmtContext sendStmt() { |
| return getRuleContext(SendStmtContext.class,0); |
| } |
| public RecvStmtContext recvStmt() { |
| return getRuleContext(RecvStmtContext.class,0); |
| } |
| public TerminalNode DEFAULT() { return getToken(GoParser.DEFAULT, 0); } |
| 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 GoParserListener ) ((GoParserListener)listener).enterCommCase(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitCommCase(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitCommCase(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final CommCaseContext commCase() throws RecognitionException { |
| CommCaseContext _localctx = new CommCaseContext(_ctx, getState()); |
| enterRule(_localctx, 94, RULE_commCase); |
| try { |
| setState(573); |
| _errHandler.sync(this); |
| switch (_input.LA(1)) { |
| case CASE: |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(567); |
| match(CASE); |
| setState(570); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) { |
| case 1: |
| { |
| setState(568); |
| sendStmt(); |
| } |
| break; |
| case 2: |
| { |
| setState(569); |
| recvStmt(); |
| } |
| break; |
| } |
| } |
| break; |
| case DEFAULT: |
| enterOuterAlt(_localctx, 2); |
| { |
| setState(572); |
| match(DEFAULT); |
| } |
| break; |
| default: |
| throw new NoViableAltException(this); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class RecvStmtContext extends ParserRuleContext { |
| public ExpressionContext recvExpr; |
| public ExpressionContext expression() { |
| return getRuleContext(ExpressionContext.class,0); |
| } |
| public ExpressionListContext expressionList() { |
| return getRuleContext(ExpressionListContext.class,0); |
| } |
| public TerminalNode ASSIGN() { return getToken(GoParser.ASSIGN, 0); } |
| public IdentifierListContext identifierList() { |
| return getRuleContext(IdentifierListContext.class,0); |
| } |
| public TerminalNode DECLARE_ASSIGN() { return getToken(GoParser.DECLARE_ASSIGN, 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 GoParserListener ) ((GoParserListener)listener).enterRecvStmt(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitRecvStmt(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitRecvStmt(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final RecvStmtContext recvStmt() throws RecognitionException { |
| RecvStmtContext _localctx = new RecvStmtContext(_ctx, getState()); |
| enterRule(_localctx, 96, RULE_recvStmt); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(581); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,57,_ctx) ) { |
| case 1: |
| { |
| setState(575); |
| expressionList(); |
| setState(576); |
| match(ASSIGN); |
| } |
| break; |
| case 2: |
| { |
| setState(578); |
| identifierList(); |
| setState(579); |
| match(DECLARE_ASSIGN); |
| } |
| break; |
| } |
| setState(583); |
| ((RecvStmtContext)_localctx).recvExpr = expression(0); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class ForStmtContext extends ParserRuleContext { |
| public TerminalNode FOR() { return getToken(GoParser.FOR, 0); } |
| public BlockContext block() { |
| return getRuleContext(BlockContext.class,0); |
| } |
| public ForClauseContext forClause() { |
| return getRuleContext(ForClauseContext.class,0); |
| } |
| public ExpressionContext expression() { |
| return getRuleContext(ExpressionContext.class,0); |
| } |
| public RangeClauseContext rangeClause() { |
| return getRuleContext(RangeClauseContext.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 GoParserListener ) ((GoParserListener)listener).enterForStmt(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitForStmt(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitForStmt(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final ForStmtContext forStmt() throws RecognitionException { |
| ForStmtContext _localctx = new ForStmtContext(_ctx, getState()); |
| enterRule(_localctx, 98, RULE_forStmt); |
| int _la; |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(585); |
| match(FOR); |
| setState(593); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) { |
| case 1: |
| { |
| setState(587); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| if (((_la) & ~0x3f) == 0 && ((1L << _la) & -144115183311122920L) != 0 || (((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 49567L) != 0) { |
| { |
| setState(586); |
| expression(0); |
| } |
| } |
| |
| } |
| break; |
| case 2: |
| { |
| setState(589); |
| forClause(); |
| } |
| break; |
| case 3: |
| { |
| setState(591); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| if (((_la) & ~0x3f) == 0 && ((1L << _la) & -144115183310598632L) != 0 || (((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 49567L) != 0) { |
| { |
| setState(590); |
| rangeClause(); |
| } |
| } |
| |
| } |
| break; |
| } |
| setState(595); |
| block(); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class ForClauseContext extends ParserRuleContext { |
| public SimpleStmtContext initStmt; |
| public SimpleStmtContext postStmt; |
| public List<EosContext> eos() { |
| return getRuleContexts(EosContext.class); |
| } |
| public EosContext eos(int i) { |
| return getRuleContext(EosContext.class,i); |
| } |
| public ExpressionContext expression() { |
| return getRuleContext(ExpressionContext.class,0); |
| } |
| public List<SimpleStmtContext> simpleStmt() { |
| return getRuleContexts(SimpleStmtContext.class); |
| } |
| public SimpleStmtContext simpleStmt(int i) { |
| return getRuleContext(SimpleStmtContext.class,i); |
| } |
| 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 GoParserListener ) ((GoParserListener)listener).enterForClause(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitForClause(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitForClause(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final ForClauseContext forClause() throws RecognitionException { |
| ForClauseContext _localctx = new ForClauseContext(_ctx, getState()); |
| enterRule(_localctx, 100, RULE_forClause); |
| int _la; |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(598); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,61,_ctx) ) { |
| case 1: |
| { |
| setState(597); |
| ((ForClauseContext)_localctx).initStmt = simpleStmt(); |
| } |
| break; |
| } |
| setState(600); |
| eos(); |
| setState(602); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,62,_ctx) ) { |
| case 1: |
| { |
| setState(601); |
| expression(0); |
| } |
| break; |
| } |
| setState(604); |
| eos(); |
| setState(606); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| if (((_la) & ~0x3f) == 0 && ((1L << _la) & -144115183311122920L) != 0 || (((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 49567L) != 0) { |
| { |
| setState(605); |
| ((ForClauseContext)_localctx).postStmt = simpleStmt(); |
| } |
| } |
| |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class RangeClauseContext extends ParserRuleContext { |
| public TerminalNode RANGE() { return getToken(GoParser.RANGE, 0); } |
| public ExpressionContext expression() { |
| return getRuleContext(ExpressionContext.class,0); |
| } |
| public ExpressionListContext expressionList() { |
| return getRuleContext(ExpressionListContext.class,0); |
| } |
| public TerminalNode ASSIGN() { return getToken(GoParser.ASSIGN, 0); } |
| public IdentifierListContext identifierList() { |
| return getRuleContext(IdentifierListContext.class,0); |
| } |
| public TerminalNode DECLARE_ASSIGN() { return getToken(GoParser.DECLARE_ASSIGN, 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 GoParserListener ) ((GoParserListener)listener).enterRangeClause(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitRangeClause(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitRangeClause(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final RangeClauseContext rangeClause() throws RecognitionException { |
| RangeClauseContext _localctx = new RangeClauseContext(_ctx, getState()); |
| enterRule(_localctx, 102, RULE_rangeClause); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(614); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,64,_ctx) ) { |
| case 1: |
| { |
| setState(608); |
| expressionList(); |
| setState(609); |
| match(ASSIGN); |
| } |
| break; |
| case 2: |
| { |
| setState(611); |
| identifierList(); |
| setState(612); |
| match(DECLARE_ASSIGN); |
| } |
| break; |
| } |
| setState(616); |
| match(RANGE); |
| setState(617); |
| expression(0); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class GoStmtContext extends ParserRuleContext { |
| public TerminalNode GO() { return getToken(GoParser.GO, 0); } |
| public ExpressionContext expression() { |
| return getRuleContext(ExpressionContext.class,0); |
| } |
| public GoStmtContext(ParserRuleContext parent, int invokingState) { |
| super(parent, invokingState); |
| } |
| @Override public int getRuleIndex() { return RULE_goStmt; } |
| @Override |
| public void enterRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).enterGoStmt(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitGoStmt(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitGoStmt(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final GoStmtContext goStmt() throws RecognitionException { |
| GoStmtContext _localctx = new GoStmtContext(_ctx, getState()); |
| enterRule(_localctx, 104, RULE_goStmt); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(619); |
| match(GO); |
| setState(620); |
| expression(0); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class Type_Context extends ParserRuleContext { |
| public TypeNameContext typeName() { |
| return getRuleContext(TypeNameContext.class,0); |
| } |
| public TypeLitContext typeLit() { |
| return getRuleContext(TypeLitContext.class,0); |
| } |
| public TerminalNode L_PAREN() { return getToken(GoParser.L_PAREN, 0); } |
| public Type_Context type_() { |
| return getRuleContext(Type_Context.class,0); |
| } |
| public TerminalNode R_PAREN() { return getToken(GoParser.R_PAREN, 0); } |
| public Type_Context(ParserRuleContext parent, int invokingState) { |
| super(parent, invokingState); |
| } |
| @Override public int getRuleIndex() { return RULE_type_; } |
| @Override |
| public void enterRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).enterType_(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitType_(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitType_(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final Type_Context type_() throws RecognitionException { |
| Type_Context _localctx = new Type_Context(_ctx, getState()); |
| enterRule(_localctx, 106, RULE_type_); |
| try { |
| setState(628); |
| _errHandler.sync(this); |
| switch (_input.LA(1)) { |
| case IDENTIFIER: |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(622); |
| typeName(); |
| } |
| break; |
| case FUNC: |
| case INTERFACE: |
| case MAP: |
| case STRUCT: |
| case CHAN: |
| case L_BRACKET: |
| case STAR: |
| case RECEIVE: |
| enterOuterAlt(_localctx, 2); |
| { |
| setState(623); |
| typeLit(); |
| } |
| break; |
| case L_PAREN: |
| enterOuterAlt(_localctx, 3); |
| { |
| setState(624); |
| match(L_PAREN); |
| setState(625); |
| type_(); |
| setState(626); |
| match(R_PAREN); |
| } |
| break; |
| default: |
| throw new NoViableAltException(this); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class TypeNameContext extends ParserRuleContext { |
| public QualifiedIdentContext qualifiedIdent() { |
| return getRuleContext(QualifiedIdentContext.class,0); |
| } |
| public TerminalNode IDENTIFIER() { return getToken(GoParser.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 GoParserListener ) ((GoParserListener)listener).enterTypeName(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitTypeName(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitTypeName(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final TypeNameContext typeName() throws RecognitionException { |
| TypeNameContext _localctx = new TypeNameContext(_ctx, getState()); |
| enterRule(_localctx, 108, RULE_typeName); |
| try { |
| setState(632); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,66,_ctx) ) { |
| case 1: |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(630); |
| qualifiedIdent(); |
| } |
| break; |
| case 2: |
| enterOuterAlt(_localctx, 2); |
| { |
| setState(631); |
| match(IDENTIFIER); |
| } |
| break; |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class TypeLitContext extends ParserRuleContext { |
| public ArrayTypeContext arrayType() { |
| return getRuleContext(ArrayTypeContext.class,0); |
| } |
| public StructTypeContext structType() { |
| return getRuleContext(StructTypeContext.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 SliceTypeContext sliceType() { |
| return getRuleContext(SliceTypeContext.class,0); |
| } |
| public MapTypeContext mapType() { |
| return getRuleContext(MapTypeContext.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 GoParserListener ) ((GoParserListener)listener).enterTypeLit(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitTypeLit(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitTypeLit(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final TypeLitContext typeLit() throws RecognitionException { |
| TypeLitContext _localctx = new TypeLitContext(_ctx, getState()); |
| enterRule(_localctx, 110, RULE_typeLit); |
| try { |
| setState(642); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,67,_ctx) ) { |
| case 1: |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(634); |
| arrayType(); |
| } |
| break; |
| case 2: |
| enterOuterAlt(_localctx, 2); |
| { |
| setState(635); |
| structType(); |
| } |
| break; |
| case 3: |
| enterOuterAlt(_localctx, 3); |
| { |
| setState(636); |
| pointerType(); |
| } |
| break; |
| case 4: |
| enterOuterAlt(_localctx, 4); |
| { |
| setState(637); |
| functionType(); |
| } |
| break; |
| case 5: |
| enterOuterAlt(_localctx, 5); |
| { |
| setState(638); |
| interfaceType(); |
| } |
| break; |
| case 6: |
| enterOuterAlt(_localctx, 6); |
| { |
| setState(639); |
| sliceType(); |
| } |
| break; |
| case 7: |
| enterOuterAlt(_localctx, 7); |
| { |
| setState(640); |
| mapType(); |
| } |
| break; |
| case 8: |
| enterOuterAlt(_localctx, 8); |
| { |
| setState(641); |
| channelType(); |
| } |
| break; |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class ArrayTypeContext extends ParserRuleContext { |
| public TerminalNode L_BRACKET() { return getToken(GoParser.L_BRACKET, 0); } |
| public ArrayLengthContext arrayLength() { |
| return getRuleContext(ArrayLengthContext.class,0); |
| } |
| public TerminalNode R_BRACKET() { return getToken(GoParser.R_BRACKET, 0); } |
| public ElementTypeContext elementType() { |
| return getRuleContext(ElementTypeContext.class,0); |
| } |
| public ArrayTypeContext(ParserRuleContext parent, int invokingState) { |
| super(parent, invokingState); |
| } |
| @Override public int getRuleIndex() { return RULE_arrayType; } |
| @Override |
| public void enterRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).enterArrayType(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitArrayType(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitArrayType(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final ArrayTypeContext arrayType() throws RecognitionException { |
| ArrayTypeContext _localctx = new ArrayTypeContext(_ctx, getState()); |
| enterRule(_localctx, 112, RULE_arrayType); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(644); |
| match(L_BRACKET); |
| setState(645); |
| arrayLength(); |
| setState(646); |
| match(R_BRACKET); |
| setState(647); |
| elementType(); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| 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 GoParserListener ) ((GoParserListener)listener).enterArrayLength(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitArrayLength(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitArrayLength(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final ArrayLengthContext arrayLength() throws RecognitionException { |
| ArrayLengthContext _localctx = new ArrayLengthContext(_ctx, getState()); |
| enterRule(_localctx, 114, RULE_arrayLength); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(649); |
| expression(0); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class ElementTypeContext extends ParserRuleContext { |
| public Type_Context type_() { |
| return getRuleContext(Type_Context.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 GoParserListener ) ((GoParserListener)listener).enterElementType(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitElementType(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitElementType(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final ElementTypeContext elementType() throws RecognitionException { |
| ElementTypeContext _localctx = new ElementTypeContext(_ctx, getState()); |
| enterRule(_localctx, 116, RULE_elementType); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(651); |
| type_(); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class PointerTypeContext extends ParserRuleContext { |
| public TerminalNode STAR() { return getToken(GoParser.STAR, 0); } |
| public Type_Context type_() { |
| return getRuleContext(Type_Context.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 GoParserListener ) ((GoParserListener)listener).enterPointerType(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitPointerType(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitPointerType(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final PointerTypeContext pointerType() throws RecognitionException { |
| PointerTypeContext _localctx = new PointerTypeContext(_ctx, getState()); |
| enterRule(_localctx, 118, RULE_pointerType); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(653); |
| match(STAR); |
| setState(654); |
| type_(); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class InterfaceTypeContext extends ParserRuleContext { |
| public TerminalNode INTERFACE() { return getToken(GoParser.INTERFACE, 0); } |
| public TerminalNode L_CURLY() { return getToken(GoParser.L_CURLY, 0); } |
| public TerminalNode R_CURLY() { return getToken(GoParser.R_CURLY, 0); } |
| public List<EosContext> eos() { |
| return getRuleContexts(EosContext.class); |
| } |
| public EosContext eos(int i) { |
| return getRuleContext(EosContext.class,i); |
| } |
| public List<MethodSpecContext> methodSpec() { |
| return getRuleContexts(MethodSpecContext.class); |
| } |
| public MethodSpecContext methodSpec(int i) { |
| return getRuleContext(MethodSpecContext.class,i); |
| } |
| public List<TypeNameContext> typeName() { |
| return getRuleContexts(TypeNameContext.class); |
| } |
| public TypeNameContext typeName(int i) { |
| return getRuleContext(TypeNameContext.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 GoParserListener ) ((GoParserListener)listener).enterInterfaceType(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitInterfaceType(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitInterfaceType(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final InterfaceTypeContext interfaceType() throws RecognitionException { |
| InterfaceTypeContext _localctx = new InterfaceTypeContext(_ctx, getState()); |
| enterRule(_localctx, 120, RULE_interfaceType); |
| int _la; |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(656); |
| match(INTERFACE); |
| setState(657); |
| match(L_CURLY); |
| setState(666); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| while (_la==IDENTIFIER) { |
| { |
| { |
| setState(660); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,68,_ctx) ) { |
| case 1: |
| { |
| setState(658); |
| methodSpec(); |
| } |
| break; |
| case 2: |
| { |
| setState(659); |
| typeName(); |
| } |
| break; |
| } |
| setState(662); |
| eos(); |
| } |
| } |
| setState(668); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| } |
| setState(669); |
| match(R_CURLY); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class SliceTypeContext extends ParserRuleContext { |
| public TerminalNode L_BRACKET() { return getToken(GoParser.L_BRACKET, 0); } |
| public TerminalNode R_BRACKET() { return getToken(GoParser.R_BRACKET, 0); } |
| public ElementTypeContext elementType() { |
| return getRuleContext(ElementTypeContext.class,0); |
| } |
| public SliceTypeContext(ParserRuleContext parent, int invokingState) { |
| super(parent, invokingState); |
| } |
| @Override public int getRuleIndex() { return RULE_sliceType; } |
| @Override |
| public void enterRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).enterSliceType(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitSliceType(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitSliceType(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final SliceTypeContext sliceType() throws RecognitionException { |
| SliceTypeContext _localctx = new SliceTypeContext(_ctx, getState()); |
| enterRule(_localctx, 122, RULE_sliceType); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(671); |
| match(L_BRACKET); |
| setState(672); |
| match(R_BRACKET); |
| setState(673); |
| elementType(); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class MapTypeContext extends ParserRuleContext { |
| public TerminalNode MAP() { return getToken(GoParser.MAP, 0); } |
| public TerminalNode L_BRACKET() { return getToken(GoParser.L_BRACKET, 0); } |
| public Type_Context type_() { |
| return getRuleContext(Type_Context.class,0); |
| } |
| public TerminalNode R_BRACKET() { return getToken(GoParser.R_BRACKET, 0); } |
| public ElementTypeContext elementType() { |
| return getRuleContext(ElementTypeContext.class,0); |
| } |
| public MapTypeContext(ParserRuleContext parent, int invokingState) { |
| super(parent, invokingState); |
| } |
| @Override public int getRuleIndex() { return RULE_mapType; } |
| @Override |
| public void enterRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).enterMapType(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitMapType(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitMapType(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final MapTypeContext mapType() throws RecognitionException { |
| MapTypeContext _localctx = new MapTypeContext(_ctx, getState()); |
| enterRule(_localctx, 124, RULE_mapType); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(675); |
| match(MAP); |
| setState(676); |
| match(L_BRACKET); |
| setState(677); |
| type_(); |
| setState(678); |
| match(R_BRACKET); |
| setState(679); |
| elementType(); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class ChannelTypeContext extends ParserRuleContext { |
| public ElementTypeContext elementType() { |
| return getRuleContext(ElementTypeContext.class,0); |
| } |
| public TerminalNode CHAN() { return getToken(GoParser.CHAN, 0); } |
| public TerminalNode RECEIVE() { return getToken(GoParser.RECEIVE, 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 GoParserListener ) ((GoParserListener)listener).enterChannelType(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitChannelType(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitChannelType(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final ChannelTypeContext channelType() throws RecognitionException { |
| ChannelTypeContext _localctx = new ChannelTypeContext(_ctx, getState()); |
| enterRule(_localctx, 126, RULE_channelType); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(686); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) { |
| case 1: |
| { |
| setState(681); |
| match(CHAN); |
| } |
| break; |
| case 2: |
| { |
| setState(682); |
| match(CHAN); |
| setState(683); |
| match(RECEIVE); |
| } |
| break; |
| case 3: |
| { |
| setState(684); |
| match(RECEIVE); |
| setState(685); |
| match(CHAN); |
| } |
| break; |
| } |
| setState(688); |
| elementType(); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class MethodSpecContext extends ParserRuleContext { |
| public TerminalNode IDENTIFIER() { return getToken(GoParser.IDENTIFIER, 0); } |
| public ParametersContext parameters() { |
| return getRuleContext(ParametersContext.class,0); |
| } |
| public ResultContext result() { |
| return getRuleContext(ResultContext.class,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 GoParserListener ) ((GoParserListener)listener).enterMethodSpec(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitMethodSpec(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitMethodSpec(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final MethodSpecContext methodSpec() throws RecognitionException { |
| MethodSpecContext _localctx = new MethodSpecContext(_ctx, getState()); |
| enterRule(_localctx, 128, RULE_methodSpec); |
| try { |
| setState(696); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,71,_ctx) ) { |
| case 1: |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(690); |
| match(IDENTIFIER); |
| setState(691); |
| parameters(); |
| setState(692); |
| result(); |
| } |
| break; |
| case 2: |
| enterOuterAlt(_localctx, 2); |
| { |
| setState(694); |
| match(IDENTIFIER); |
| setState(695); |
| parameters(); |
| } |
| break; |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class FunctionTypeContext extends ParserRuleContext { |
| public TerminalNode FUNC() { return getToken(GoParser.FUNC, 0); } |
| 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 GoParserListener ) ((GoParserListener)listener).enterFunctionType(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitFunctionType(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitFunctionType(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final FunctionTypeContext functionType() throws RecognitionException { |
| FunctionTypeContext _localctx = new FunctionTypeContext(_ctx, getState()); |
| enterRule(_localctx, 130, RULE_functionType); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(698); |
| match(FUNC); |
| setState(699); |
| signature(); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class SignatureContext extends ParserRuleContext { |
| public ParametersContext parameters() { |
| return getRuleContext(ParametersContext.class,0); |
| } |
| public ResultContext result() { |
| return getRuleContext(ResultContext.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 GoParserListener ) ((GoParserListener)listener).enterSignature(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitSignature(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitSignature(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final SignatureContext signature() throws RecognitionException { |
| SignatureContext _localctx = new SignatureContext(_ctx, getState()); |
| enterRule(_localctx, 132, RULE_signature); |
| try { |
| setState(705); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,72,_ctx) ) { |
| case 1: |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(701); |
| parameters(); |
| setState(702); |
| result(); |
| } |
| break; |
| case 2: |
| enterOuterAlt(_localctx, 2); |
| { |
| setState(704); |
| parameters(); |
| } |
| break; |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class ResultContext extends ParserRuleContext { |
| public ParametersContext parameters() { |
| return getRuleContext(ParametersContext.class,0); |
| } |
| public Type_Context type_() { |
| return getRuleContext(Type_Context.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 GoParserListener ) ((GoParserListener)listener).enterResult(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitResult(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitResult(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final ResultContext result() throws RecognitionException { |
| ResultContext _localctx = new ResultContext(_ctx, getState()); |
| enterRule(_localctx, 134, RULE_result); |
| try { |
| setState(709); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,73,_ctx) ) { |
| case 1: |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(707); |
| parameters(); |
| } |
| break; |
| case 2: |
| enterOuterAlt(_localctx, 2); |
| { |
| setState(708); |
| type_(); |
| } |
| break; |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class ParametersContext extends ParserRuleContext { |
| public TerminalNode L_PAREN() { return getToken(GoParser.L_PAREN, 0); } |
| public TerminalNode R_PAREN() { return getToken(GoParser.R_PAREN, 0); } |
| public List<ParameterDeclContext> parameterDecl() { |
| return getRuleContexts(ParameterDeclContext.class); |
| } |
| public ParameterDeclContext parameterDecl(int i) { |
| return getRuleContext(ParameterDeclContext.class,i); |
| } |
| public List<TerminalNode> COMMA() { return getTokens(GoParser.COMMA); } |
| public TerminalNode COMMA(int i) { |
| return getToken(GoParser.COMMA, i); |
| } |
| 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 GoParserListener ) ((GoParserListener)listener).enterParameters(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitParameters(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitParameters(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final ParametersContext parameters() throws RecognitionException { |
| ParametersContext _localctx = new ParametersContext(_ctx, getState()); |
| enterRule(_localctx, 136, RULE_parameters); |
| int _la; |
| try { |
| int _alt; |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(711); |
| match(L_PAREN); |
| setState(723); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| if (((_la) & ~0x3f) == 0 && ((1L << _la) & -6917524624896946664L) != 0) { |
| { |
| setState(712); |
| parameterDecl(); |
| setState(717); |
| _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(713); |
| match(COMMA); |
| setState(714); |
| parameterDecl(); |
| } |
| } |
| } |
| setState(719); |
| _errHandler.sync(this); |
| _alt = getInterpreter().adaptivePredict(_input,74,_ctx); |
| } |
| setState(721); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| if (_la==COMMA) { |
| { |
| setState(720); |
| match(COMMA); |
| } |
| } |
| |
| } |
| } |
| |
| setState(725); |
| match(R_PAREN); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class ParameterDeclContext extends ParserRuleContext { |
| public Type_Context type_() { |
| return getRuleContext(Type_Context.class,0); |
| } |
| public IdentifierListContext identifierList() { |
| return getRuleContext(IdentifierListContext.class,0); |
| } |
| public TerminalNode ELLIPSIS() { return getToken(GoParser.ELLIPSIS, 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 GoParserListener ) ((GoParserListener)listener).enterParameterDecl(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitParameterDecl(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitParameterDecl(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final ParameterDeclContext parameterDecl() throws RecognitionException { |
| ParameterDeclContext _localctx = new ParameterDeclContext(_ctx, getState()); |
| enterRule(_localctx, 138, RULE_parameterDecl); |
| int _la; |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(728); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,77,_ctx) ) { |
| case 1: |
| { |
| setState(727); |
| identifierList(); |
| } |
| break; |
| } |
| setState(731); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| if (_la==ELLIPSIS) { |
| { |
| setState(730); |
| match(ELLIPSIS); |
| } |
| } |
| |
| setState(733); |
| type_(); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class ExpressionContext extends ParserRuleContext { |
| public Token unary_op; |
| public Token mul_op; |
| public Token add_op; |
| public Token rel_op; |
| public PrimaryExprContext primaryExpr() { |
| return getRuleContext(PrimaryExprContext.class,0); |
| } |
| public List<ExpressionContext> expression() { |
| return getRuleContexts(ExpressionContext.class); |
| } |
| public ExpressionContext expression(int i) { |
| return getRuleContext(ExpressionContext.class,i); |
| } |
| public TerminalNode PLUS() { return getToken(GoParser.PLUS, 0); } |
| public TerminalNode MINUS() { return getToken(GoParser.MINUS, 0); } |
| public TerminalNode EXCLAMATION() { return getToken(GoParser.EXCLAMATION, 0); } |
| public TerminalNode CARET() { return getToken(GoParser.CARET, 0); } |
| public TerminalNode STAR() { return getToken(GoParser.STAR, 0); } |
| public TerminalNode AMPERSAND() { return getToken(GoParser.AMPERSAND, 0); } |
| public TerminalNode RECEIVE() { return getToken(GoParser.RECEIVE, 0); } |
| public TerminalNode DIV() { return getToken(GoParser.DIV, 0); } |
| public TerminalNode MOD() { return getToken(GoParser.MOD, 0); } |
| public TerminalNode LSHIFT() { return getToken(GoParser.LSHIFT, 0); } |
| public TerminalNode RSHIFT() { return getToken(GoParser.RSHIFT, 0); } |
| public TerminalNode BIT_CLEAR() { return getToken(GoParser.BIT_CLEAR, 0); } |
| public TerminalNode OR() { return getToken(GoParser.OR, 0); } |
| public TerminalNode EQUALS() { return getToken(GoParser.EQUALS, 0); } |
| public TerminalNode NOT_EQUALS() { return getToken(GoParser.NOT_EQUALS, 0); } |
| public TerminalNode LESS() { return getToken(GoParser.LESS, 0); } |
| public TerminalNode LESS_OR_EQUALS() { return getToken(GoParser.LESS_OR_EQUALS, 0); } |
| public TerminalNode GREATER() { return getToken(GoParser.GREATER, 0); } |
| public TerminalNode GREATER_OR_EQUALS() { return getToken(GoParser.GREATER_OR_EQUALS, 0); } |
| public TerminalNode LOGICAL_AND() { return getToken(GoParser.LOGICAL_AND, 0); } |
| public TerminalNode LOGICAL_OR() { return getToken(GoParser.LOGICAL_OR, 0); } |
| 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 GoParserListener ) ((GoParserListener)listener).enterExpression(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitExpression(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitExpression(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| 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 = 140; |
| enterRecursionRule(_localctx, 140, RULE_expression, _p); |
| int _la; |
| try { |
| int _alt; |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(739); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,79,_ctx) ) { |
| case 1: |
| { |
| setState(736); |
| primaryExpr(0); |
| } |
| break; |
| case 2: |
| { |
| setState(737); |
| ((ExpressionContext)_localctx).unary_op = _input.LT(1); |
| _la = _input.LA(1); |
| if ( !(((_la) & ~0x3f) == 0 && ((1L << _la) & -144115188075855872L) != 0) ) { |
| ((ExpressionContext)_localctx).unary_op = (Token)_errHandler.recoverInline(this); |
| } |
| else { |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; |
| _errHandler.reportMatch(this); |
| consume(); |
| } |
| setState(738); |
| expression(6); |
| } |
| break; |
| } |
| _ctx.stop = _input.LT(-1); |
| setState(758); |
| _errHandler.sync(this); |
| _alt = getInterpreter().adaptivePredict(_input,81,_ctx); |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { |
| if ( _alt==1 ) { |
| if ( _parseListeners!=null ) triggerExitRuleEvent(); |
| _prevctx = _localctx; |
| { |
| setState(756); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,80,_ctx) ) { |
| case 1: |
| { |
| _localctx = new ExpressionContext(_parentctx, _parentState); |
| pushNewRecursionContext(_localctx, _startState, RULE_expression); |
| setState(741); |
| if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)"); |
| setState(742); |
| ((ExpressionContext)_localctx).mul_op = _input.LT(1); |
| _la = _input.LA(1); |
| if ( !(((_la) & ~0x3f) == 0 && ((1L << _la) & 7057140616089567232L) != 0) ) { |
| ((ExpressionContext)_localctx).mul_op = (Token)_errHandler.recoverInline(this); |
| } |
| else { |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; |
| _errHandler.reportMatch(this); |
| consume(); |
| } |
| setState(743); |
| expression(6); |
| } |
| break; |
| case 2: |
| { |
| _localctx = new ExpressionContext(_parentctx, _parentState); |
| pushNewRecursionContext(_localctx, _startState, RULE_expression); |
| setState(744); |
| if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)"); |
| setState(745); |
| ((ExpressionContext)_localctx).add_op = _input.LT(1); |
| _la = _input.LA(1); |
| if ( !(((_la) & ~0x3f) == 0 && ((1L << _la) & 2019864432875667456L) != 0) ) { |
| ((ExpressionContext)_localctx).add_op = (Token)_errHandler.recoverInline(this); |
| } |
| else { |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; |
| _errHandler.reportMatch(this); |
| consume(); |
| } |
| setState(746); |
| expression(5); |
| } |
| break; |
| case 3: |
| { |
| _localctx = new ExpressionContext(_parentctx, _parentState); |
| pushNewRecursionContext(_localctx, _startState, RULE_expression); |
| setState(747); |
| if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)"); |
| setState(748); |
| ((ExpressionContext)_localctx).rel_op = _input.LT(1); |
| _la = _input.LA(1); |
| if ( !(((_la) & ~0x3f) == 0 && ((1L << _la) & 2216615441596416L) != 0) ) { |
| ((ExpressionContext)_localctx).rel_op = (Token)_errHandler.recoverInline(this); |
| } |
| else { |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; |
| _errHandler.reportMatch(this); |
| consume(); |
| } |
| setState(749); |
| expression(4); |
| } |
| break; |
| case 4: |
| { |
| _localctx = new ExpressionContext(_parentctx, _parentState); |
| pushNewRecursionContext(_localctx, _startState, RULE_expression); |
| setState(750); |
| if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); |
| setState(751); |
| match(LOGICAL_AND); |
| setState(752); |
| expression(3); |
| } |
| break; |
| case 5: |
| { |
| _localctx = new ExpressionContext(_parentctx, _parentState); |
| pushNewRecursionContext(_localctx, _startState, RULE_expression); |
| setState(753); |
| if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); |
| setState(754); |
| match(LOGICAL_OR); |
| setState(755); |
| expression(2); |
| } |
| break; |
| } |
| } |
| } |
| setState(760); |
| _errHandler.sync(this); |
| _alt = getInterpreter().adaptivePredict(_input,81,_ctx); |
| } |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| unrollRecursionContexts(_parentctx); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class PrimaryExprContext extends ParserRuleContext { |
| public OperandContext operand() { |
| return getRuleContext(OperandContext.class,0); |
| } |
| public ConversionContext conversion() { |
| return getRuleContext(ConversionContext.class,0); |
| } |
| public MethodExprContext methodExpr() { |
| return getRuleContext(MethodExprContext.class,0); |
| } |
| public PrimaryExprContext primaryExpr() { |
| return getRuleContext(PrimaryExprContext.class,0); |
| } |
| public IndexContext index() { |
| return getRuleContext(IndexContext.class,0); |
| } |
| public Slice_Context slice_() { |
| return getRuleContext(Slice_Context.class,0); |
| } |
| public TypeAssertionContext typeAssertion() { |
| return getRuleContext(TypeAssertionContext.class,0); |
| } |
| public ArgumentsContext arguments() { |
| return getRuleContext(ArgumentsContext.class,0); |
| } |
| public TerminalNode DOT() { return getToken(GoParser.DOT, 0); } |
| public TerminalNode IDENTIFIER() { return getToken(GoParser.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 GoParserListener ) ((GoParserListener)listener).enterPrimaryExpr(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitPrimaryExpr(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitPrimaryExpr(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| 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 = 142; |
| enterRecursionRule(_localctx, 142, RULE_primaryExpr, _p); |
| try { |
| int _alt; |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(765); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,82,_ctx) ) { |
| case 1: |
| { |
| setState(762); |
| operand(); |
| } |
| break; |
| case 2: |
| { |
| setState(763); |
| conversion(); |
| } |
| break; |
| case 3: |
| { |
| setState(764); |
| methodExpr(); |
| } |
| break; |
| } |
| _ctx.stop = _input.LT(-1); |
| setState(778); |
| _errHandler.sync(this); |
| _alt = getInterpreter().adaptivePredict(_input,84,_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 PrimaryExprContext(_parentctx, _parentState); |
| pushNewRecursionContext(_localctx, _startState, RULE_primaryExpr); |
| setState(767); |
| if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); |
| setState(774); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,83,_ctx) ) { |
| case 1: |
| { |
| { |
| setState(768); |
| match(DOT); |
| setState(769); |
| match(IDENTIFIER); |
| } |
| } |
| break; |
| case 2: |
| { |
| setState(770); |
| index(); |
| } |
| break; |
| case 3: |
| { |
| setState(771); |
| slice_(); |
| } |
| break; |
| case 4: |
| { |
| setState(772); |
| typeAssertion(); |
| } |
| break; |
| case 5: |
| { |
| setState(773); |
| arguments(); |
| } |
| break; |
| } |
| } |
| } |
| } |
| setState(780); |
| _errHandler.sync(this); |
| _alt = getInterpreter().adaptivePredict(_input,84,_ctx); |
| } |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| unrollRecursionContexts(_parentctx); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class ConversionContext extends ParserRuleContext { |
| public NonNamedTypeContext nonNamedType() { |
| return getRuleContext(NonNamedTypeContext.class,0); |
| } |
| public TerminalNode L_PAREN() { return getToken(GoParser.L_PAREN, 0); } |
| public ExpressionContext expression() { |
| return getRuleContext(ExpressionContext.class,0); |
| } |
| public TerminalNode R_PAREN() { return getToken(GoParser.R_PAREN, 0); } |
| public TerminalNode COMMA() { return getToken(GoParser.COMMA, 0); } |
| public ConversionContext(ParserRuleContext parent, int invokingState) { |
| super(parent, invokingState); |
| } |
| @Override public int getRuleIndex() { return RULE_conversion; } |
| @Override |
| public void enterRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).enterConversion(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitConversion(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitConversion(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final ConversionContext conversion() throws RecognitionException { |
| ConversionContext _localctx = new ConversionContext(_ctx, getState()); |
| enterRule(_localctx, 144, RULE_conversion); |
| int _la; |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(781); |
| nonNamedType(); |
| setState(782); |
| match(L_PAREN); |
| setState(783); |
| expression(0); |
| setState(785); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| if (_la==COMMA) { |
| { |
| setState(784); |
| match(COMMA); |
| } |
| } |
| |
| setState(787); |
| match(R_PAREN); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class NonNamedTypeContext extends ParserRuleContext { |
| public TypeLitContext typeLit() { |
| return getRuleContext(TypeLitContext.class,0); |
| } |
| public TerminalNode L_PAREN() { return getToken(GoParser.L_PAREN, 0); } |
| public NonNamedTypeContext nonNamedType() { |
| return getRuleContext(NonNamedTypeContext.class,0); |
| } |
| public TerminalNode R_PAREN() { return getToken(GoParser.R_PAREN, 0); } |
| public NonNamedTypeContext(ParserRuleContext parent, int invokingState) { |
| super(parent, invokingState); |
| } |
| @Override public int getRuleIndex() { return RULE_nonNamedType; } |
| @Override |
| public void enterRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).enterNonNamedType(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitNonNamedType(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitNonNamedType(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final NonNamedTypeContext nonNamedType() throws RecognitionException { |
| NonNamedTypeContext _localctx = new NonNamedTypeContext(_ctx, getState()); |
| enterRule(_localctx, 146, RULE_nonNamedType); |
| try { |
| setState(794); |
| _errHandler.sync(this); |
| switch (_input.LA(1)) { |
| case FUNC: |
| case INTERFACE: |
| case MAP: |
| case STRUCT: |
| case CHAN: |
| case L_BRACKET: |
| case STAR: |
| case RECEIVE: |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(789); |
| typeLit(); |
| } |
| break; |
| case L_PAREN: |
| enterOuterAlt(_localctx, 2); |
| { |
| setState(790); |
| match(L_PAREN); |
| setState(791); |
| nonNamedType(); |
| setState(792); |
| match(R_PAREN); |
| } |
| break; |
| default: |
| throw new NoViableAltException(this); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class OperandContext extends ParserRuleContext { |
| public LiteralContext literal() { |
| return getRuleContext(LiteralContext.class,0); |
| } |
| public OperandNameContext operandName() { |
| return getRuleContext(OperandNameContext.class,0); |
| } |
| public TerminalNode L_PAREN() { return getToken(GoParser.L_PAREN, 0); } |
| public ExpressionContext expression() { |
| return getRuleContext(ExpressionContext.class,0); |
| } |
| public TerminalNode R_PAREN() { return getToken(GoParser.R_PAREN, 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 GoParserListener ) ((GoParserListener)listener).enterOperand(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitOperand(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitOperand(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final OperandContext operand() throws RecognitionException { |
| OperandContext _localctx = new OperandContext(_ctx, getState()); |
| enterRule(_localctx, 148, RULE_operand); |
| try { |
| setState(802); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) { |
| case 1: |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(796); |
| literal(); |
| } |
| break; |
| case 2: |
| enterOuterAlt(_localctx, 2); |
| { |
| setState(797); |
| operandName(); |
| } |
| break; |
| case 3: |
| enterOuterAlt(_localctx, 3); |
| { |
| setState(798); |
| match(L_PAREN); |
| setState(799); |
| expression(0); |
| setState(800); |
| match(R_PAREN); |
| } |
| break; |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class LiteralContext extends ParserRuleContext { |
| public BasicLitContext basicLit() { |
| return getRuleContext(BasicLitContext.class,0); |
| } |
| public CompositeLitContext compositeLit() { |
| return getRuleContext(CompositeLitContext.class,0); |
| } |
| public FunctionLitContext functionLit() { |
| return getRuleContext(FunctionLitContext.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 GoParserListener ) ((GoParserListener)listener).enterLiteral(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitLiteral(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitLiteral(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final LiteralContext literal() throws RecognitionException { |
| LiteralContext _localctx = new LiteralContext(_ctx, getState()); |
| enterRule(_localctx, 150, RULE_literal); |
| try { |
| setState(807); |
| _errHandler.sync(this); |
| switch (_input.LA(1)) { |
| case NIL_LIT: |
| case DECIMAL_LIT: |
| case BINARY_LIT: |
| case OCTAL_LIT: |
| case HEX_LIT: |
| case FLOAT_LIT: |
| case IMAGINARY_LIT: |
| case RUNE_LIT: |
| case RAW_STRING_LIT: |
| case INTERPRETED_STRING_LIT: |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(804); |
| basicLit(); |
| } |
| break; |
| case MAP: |
| case STRUCT: |
| case IDENTIFIER: |
| case L_BRACKET: |
| enterOuterAlt(_localctx, 2); |
| { |
| setState(805); |
| compositeLit(); |
| } |
| break; |
| case FUNC: |
| enterOuterAlt(_localctx, 3); |
| { |
| setState(806); |
| functionLit(); |
| } |
| break; |
| default: |
| throw new NoViableAltException(this); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class BasicLitContext extends ParserRuleContext { |
| public TerminalNode NIL_LIT() { return getToken(GoParser.NIL_LIT, 0); } |
| public IntegerContext integer() { |
| return getRuleContext(IntegerContext.class,0); |
| } |
| public String_Context string_() { |
| return getRuleContext(String_Context.class,0); |
| } |
| public TerminalNode FLOAT_LIT() { return getToken(GoParser.FLOAT_LIT, 0); } |
| public BasicLitContext(ParserRuleContext parent, int invokingState) { |
| super(parent, invokingState); |
| } |
| @Override public int getRuleIndex() { return RULE_basicLit; } |
| @Override |
| public void enterRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).enterBasicLit(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitBasicLit(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitBasicLit(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final BasicLitContext basicLit() throws RecognitionException { |
| BasicLitContext _localctx = new BasicLitContext(_ctx, getState()); |
| enterRule(_localctx, 152, RULE_basicLit); |
| try { |
| setState(813); |
| _errHandler.sync(this); |
| switch (_input.LA(1)) { |
| case NIL_LIT: |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(809); |
| match(NIL_LIT); |
| } |
| break; |
| case DECIMAL_LIT: |
| case BINARY_LIT: |
| case OCTAL_LIT: |
| case HEX_LIT: |
| case IMAGINARY_LIT: |
| case RUNE_LIT: |
| enterOuterAlt(_localctx, 2); |
| { |
| setState(810); |
| integer(); |
| } |
| break; |
| case RAW_STRING_LIT: |
| case INTERPRETED_STRING_LIT: |
| enterOuterAlt(_localctx, 3); |
| { |
| setState(811); |
| string_(); |
| } |
| break; |
| case FLOAT_LIT: |
| enterOuterAlt(_localctx, 4); |
| { |
| setState(812); |
| match(FLOAT_LIT); |
| } |
| break; |
| default: |
| throw new NoViableAltException(this); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class IntegerContext extends ParserRuleContext { |
| public TerminalNode DECIMAL_LIT() { return getToken(GoParser.DECIMAL_LIT, 0); } |
| public TerminalNode BINARY_LIT() { return getToken(GoParser.BINARY_LIT, 0); } |
| public TerminalNode OCTAL_LIT() { return getToken(GoParser.OCTAL_LIT, 0); } |
| public TerminalNode HEX_LIT() { return getToken(GoParser.HEX_LIT, 0); } |
| public TerminalNode IMAGINARY_LIT() { return getToken(GoParser.IMAGINARY_LIT, 0); } |
| public TerminalNode RUNE_LIT() { return getToken(GoParser.RUNE_LIT, 0); } |
| public IntegerContext(ParserRuleContext parent, int invokingState) { |
| super(parent, invokingState); |
| } |
| @Override public int getRuleIndex() { return RULE_integer; } |
| @Override |
| public void enterRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).enterInteger(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitInteger(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitInteger(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final IntegerContext integer() throws RecognitionException { |
| IntegerContext _localctx = new IntegerContext(_ctx, getState()); |
| enterRule(_localctx, 154, RULE_integer); |
| int _la; |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(815); |
| _la = _input.LA(1); |
| if ( !((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 399L) != 0) ) { |
| _errHandler.recoverInline(this); |
| } |
| else { |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; |
| _errHandler.reportMatch(this); |
| consume(); |
| } |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class OperandNameContext extends ParserRuleContext { |
| public TerminalNode IDENTIFIER() { return getToken(GoParser.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 GoParserListener ) ((GoParserListener)listener).enterOperandName(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitOperandName(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitOperandName(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final OperandNameContext operandName() throws RecognitionException { |
| OperandNameContext _localctx = new OperandNameContext(_ctx, getState()); |
| enterRule(_localctx, 156, RULE_operandName); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(817); |
| match(IDENTIFIER); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class QualifiedIdentContext extends ParserRuleContext { |
| public List<TerminalNode> IDENTIFIER() { return getTokens(GoParser.IDENTIFIER); } |
| public TerminalNode IDENTIFIER(int i) { |
| return getToken(GoParser.IDENTIFIER, i); |
| } |
| public TerminalNode DOT() { return getToken(GoParser.DOT, 0); } |
| 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 GoParserListener ) ((GoParserListener)listener).enterQualifiedIdent(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitQualifiedIdent(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitQualifiedIdent(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final QualifiedIdentContext qualifiedIdent() throws RecognitionException { |
| QualifiedIdentContext _localctx = new QualifiedIdentContext(_ctx, getState()); |
| enterRule(_localctx, 158, RULE_qualifiedIdent); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(819); |
| match(IDENTIFIER); |
| setState(820); |
| match(DOT); |
| setState(821); |
| match(IDENTIFIER); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class CompositeLitContext extends ParserRuleContext { |
| public LiteralTypeContext literalType() { |
| return getRuleContext(LiteralTypeContext.class,0); |
| } |
| public LiteralValueContext literalValue() { |
| return getRuleContext(LiteralValueContext.class,0); |
| } |
| public CompositeLitContext(ParserRuleContext parent, int invokingState) { |
| super(parent, invokingState); |
| } |
| @Override public int getRuleIndex() { return RULE_compositeLit; } |
| @Override |
| public void enterRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).enterCompositeLit(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitCompositeLit(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitCompositeLit(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final CompositeLitContext compositeLit() throws RecognitionException { |
| CompositeLitContext _localctx = new CompositeLitContext(_ctx, getState()); |
| enterRule(_localctx, 160, RULE_compositeLit); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(823); |
| literalType(); |
| setState(824); |
| literalValue(); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class LiteralTypeContext extends ParserRuleContext { |
| public StructTypeContext structType() { |
| return getRuleContext(StructTypeContext.class,0); |
| } |
| public ArrayTypeContext arrayType() { |
| return getRuleContext(ArrayTypeContext.class,0); |
| } |
| public TerminalNode L_BRACKET() { return getToken(GoParser.L_BRACKET, 0); } |
| public TerminalNode ELLIPSIS() { return getToken(GoParser.ELLIPSIS, 0); } |
| public TerminalNode R_BRACKET() { return getToken(GoParser.R_BRACKET, 0); } |
| public ElementTypeContext elementType() { |
| return getRuleContext(ElementTypeContext.class,0); |
| } |
| public SliceTypeContext sliceType() { |
| return getRuleContext(SliceTypeContext.class,0); |
| } |
| public MapTypeContext mapType() { |
| return getRuleContext(MapTypeContext.class,0); |
| } |
| public TypeNameContext typeName() { |
| return getRuleContext(TypeNameContext.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 GoParserListener ) ((GoParserListener)listener).enterLiteralType(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitLiteralType(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitLiteralType(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final LiteralTypeContext literalType() throws RecognitionException { |
| LiteralTypeContext _localctx = new LiteralTypeContext(_ctx, getState()); |
| enterRule(_localctx, 162, RULE_literalType); |
| try { |
| setState(835); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) { |
| case 1: |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(826); |
| structType(); |
| } |
| break; |
| case 2: |
| enterOuterAlt(_localctx, 2); |
| { |
| setState(827); |
| arrayType(); |
| } |
| break; |
| case 3: |
| enterOuterAlt(_localctx, 3); |
| { |
| setState(828); |
| match(L_BRACKET); |
| setState(829); |
| match(ELLIPSIS); |
| setState(830); |
| match(R_BRACKET); |
| setState(831); |
| elementType(); |
| } |
| break; |
| case 4: |
| enterOuterAlt(_localctx, 4); |
| { |
| setState(832); |
| sliceType(); |
| } |
| break; |
| case 5: |
| enterOuterAlt(_localctx, 5); |
| { |
| setState(833); |
| mapType(); |
| } |
| break; |
| case 6: |
| enterOuterAlt(_localctx, 6); |
| { |
| setState(834); |
| typeName(); |
| } |
| break; |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class LiteralValueContext extends ParserRuleContext { |
| public TerminalNode L_CURLY() { return getToken(GoParser.L_CURLY, 0); } |
| public TerminalNode R_CURLY() { return getToken(GoParser.R_CURLY, 0); } |
| public ElementListContext elementList() { |
| return getRuleContext(ElementListContext.class,0); |
| } |
| public TerminalNode COMMA() { return getToken(GoParser.COMMA, 0); } |
| public LiteralValueContext(ParserRuleContext parent, int invokingState) { |
| super(parent, invokingState); |
| } |
| @Override public int getRuleIndex() { return RULE_literalValue; } |
| @Override |
| public void enterRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).enterLiteralValue(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitLiteralValue(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitLiteralValue(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final LiteralValueContext literalValue() throws RecognitionException { |
| LiteralValueContext _localctx = new LiteralValueContext(_ctx, getState()); |
| enterRule(_localctx, 164, RULE_literalValue); |
| int _la; |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(837); |
| match(L_CURLY); |
| setState(842); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| if (((_la) & ~0x3f) == 0 && ((1L << _la) & -144115182237381096L) != 0 || (((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 49567L) != 0) { |
| { |
| setState(838); |
| elementList(); |
| setState(840); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| if (_la==COMMA) { |
| { |
| setState(839); |
| match(COMMA); |
| } |
| } |
| |
| } |
| } |
| |
| setState(844); |
| match(R_CURLY); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class ElementListContext extends ParserRuleContext { |
| public List<KeyedElementContext> keyedElement() { |
| return getRuleContexts(KeyedElementContext.class); |
| } |
| public KeyedElementContext keyedElement(int i) { |
| return getRuleContext(KeyedElementContext.class,i); |
| } |
| public List<TerminalNode> COMMA() { return getTokens(GoParser.COMMA); } |
| public TerminalNode COMMA(int i) { |
| return getToken(GoParser.COMMA, i); |
| } |
| public ElementListContext(ParserRuleContext parent, int invokingState) { |
| super(parent, invokingState); |
| } |
| @Override public int getRuleIndex() { return RULE_elementList; } |
| @Override |
| public void enterRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).enterElementList(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitElementList(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitElementList(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final ElementListContext elementList() throws RecognitionException { |
| ElementListContext _localctx = new ElementListContext(_ctx, getState()); |
| enterRule(_localctx, 166, RULE_elementList); |
| try { |
| int _alt; |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(846); |
| keyedElement(); |
| setState(851); |
| _errHandler.sync(this); |
| _alt = getInterpreter().adaptivePredict(_input,93,_ctx); |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { |
| if ( _alt==1 ) { |
| { |
| { |
| setState(847); |
| match(COMMA); |
| setState(848); |
| keyedElement(); |
| } |
| } |
| } |
| setState(853); |
| _errHandler.sync(this); |
| _alt = getInterpreter().adaptivePredict(_input,93,_ctx); |
| } |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class KeyedElementContext extends ParserRuleContext { |
| public ElementContext element() { |
| return getRuleContext(ElementContext.class,0); |
| } |
| public KeyContext key() { |
| return getRuleContext(KeyContext.class,0); |
| } |
| public TerminalNode COLON() { return getToken(GoParser.COLON, 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 GoParserListener ) ((GoParserListener)listener).enterKeyedElement(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitKeyedElement(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitKeyedElement(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final KeyedElementContext keyedElement() throws RecognitionException { |
| KeyedElementContext _localctx = new KeyedElementContext(_ctx, getState()); |
| enterRule(_localctx, 168, RULE_keyedElement); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(857); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,94,_ctx) ) { |
| case 1: |
| { |
| setState(854); |
| key(); |
| setState(855); |
| match(COLON); |
| } |
| break; |
| } |
| setState(859); |
| element(); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class KeyContext extends ParserRuleContext { |
| public ExpressionContext expression() { |
| return getRuleContext(ExpressionContext.class,0); |
| } |
| public LiteralValueContext literalValue() { |
| return getRuleContext(LiteralValueContext.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 GoParserListener ) ((GoParserListener)listener).enterKey(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitKey(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitKey(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final KeyContext key() throws RecognitionException { |
| KeyContext _localctx = new KeyContext(_ctx, getState()); |
| enterRule(_localctx, 170, RULE_key); |
| try { |
| setState(863); |
| _errHandler.sync(this); |
| switch (_input.LA(1)) { |
| case FUNC: |
| case INTERFACE: |
| case MAP: |
| case STRUCT: |
| case CHAN: |
| case NIL_LIT: |
| case IDENTIFIER: |
| case L_PAREN: |
| case L_BRACKET: |
| case EXCLAMATION: |
| case PLUS: |
| case MINUS: |
| case CARET: |
| case STAR: |
| case AMPERSAND: |
| case RECEIVE: |
| case DECIMAL_LIT: |
| case BINARY_LIT: |
| case OCTAL_LIT: |
| case HEX_LIT: |
| case FLOAT_LIT: |
| case IMAGINARY_LIT: |
| case RUNE_LIT: |
| case RAW_STRING_LIT: |
| case INTERPRETED_STRING_LIT: |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(861); |
| expression(0); |
| } |
| break; |
| case L_CURLY: |
| enterOuterAlt(_localctx, 2); |
| { |
| setState(862); |
| literalValue(); |
| } |
| break; |
| default: |
| throw new NoViableAltException(this); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class ElementContext extends ParserRuleContext { |
| public ExpressionContext expression() { |
| return getRuleContext(ExpressionContext.class,0); |
| } |
| public LiteralValueContext literalValue() { |
| return getRuleContext(LiteralValueContext.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 GoParserListener ) ((GoParserListener)listener).enterElement(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitElement(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitElement(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final ElementContext element() throws RecognitionException { |
| ElementContext _localctx = new ElementContext(_ctx, getState()); |
| enterRule(_localctx, 172, RULE_element); |
| try { |
| setState(867); |
| _errHandler.sync(this); |
| switch (_input.LA(1)) { |
| case FUNC: |
| case INTERFACE: |
| case MAP: |
| case STRUCT: |
| case CHAN: |
| case NIL_LIT: |
| case IDENTIFIER: |
| case L_PAREN: |
| case L_BRACKET: |
| case EXCLAMATION: |
| case PLUS: |
| case MINUS: |
| case CARET: |
| case STAR: |
| case AMPERSAND: |
| case RECEIVE: |
| case DECIMAL_LIT: |
| case BINARY_LIT: |
| case OCTAL_LIT: |
| case HEX_LIT: |
| case FLOAT_LIT: |
| case IMAGINARY_LIT: |
| case RUNE_LIT: |
| case RAW_STRING_LIT: |
| case INTERPRETED_STRING_LIT: |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(865); |
| expression(0); |
| } |
| break; |
| case L_CURLY: |
| enterOuterAlt(_localctx, 2); |
| { |
| setState(866); |
| literalValue(); |
| } |
| break; |
| default: |
| throw new NoViableAltException(this); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class StructTypeContext extends ParserRuleContext { |
| public TerminalNode STRUCT() { return getToken(GoParser.STRUCT, 0); } |
| public TerminalNode L_CURLY() { return getToken(GoParser.L_CURLY, 0); } |
| public TerminalNode R_CURLY() { return getToken(GoParser.R_CURLY, 0); } |
| public List<FieldDeclContext> fieldDecl() { |
| return getRuleContexts(FieldDeclContext.class); |
| } |
| public FieldDeclContext fieldDecl(int i) { |
| return getRuleContext(FieldDeclContext.class,i); |
| } |
| public List<EosContext> 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 GoParserListener ) ((GoParserListener)listener).enterStructType(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitStructType(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitStructType(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final StructTypeContext structType() throws RecognitionException { |
| StructTypeContext _localctx = new StructTypeContext(_ctx, getState()); |
| enterRule(_localctx, 174, RULE_structType); |
| int _la; |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(869); |
| match(STRUCT); |
| setState(870); |
| match(L_CURLY); |
| setState(876); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| while (_la==IDENTIFIER || _la==STAR) { |
| { |
| { |
| setState(871); |
| fieldDecl(); |
| setState(872); |
| eos(); |
| } |
| } |
| setState(878); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| } |
| setState(879); |
| match(R_CURLY); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class FieldDeclContext extends ParserRuleContext { |
| public String_Context tag; |
| public IdentifierListContext identifierList() { |
| return getRuleContext(IdentifierListContext.class,0); |
| } |
| public Type_Context type_() { |
| return getRuleContext(Type_Context.class,0); |
| } |
| public EmbeddedFieldContext embeddedField() { |
| return getRuleContext(EmbeddedFieldContext.class,0); |
| } |
| public String_Context string_() { |
| return getRuleContext(String_Context.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 GoParserListener ) ((GoParserListener)listener).enterFieldDecl(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitFieldDecl(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitFieldDecl(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final FieldDeclContext fieldDecl() throws RecognitionException { |
| FieldDeclContext _localctx = new FieldDeclContext(_ctx, getState()); |
| enterRule(_localctx, 176, RULE_fieldDecl); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(885); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,98,_ctx) ) { |
| case 1: |
| { |
| setState(881); |
| identifierList(); |
| setState(882); |
| type_(); |
| } |
| break; |
| case 2: |
| { |
| setState(884); |
| embeddedField(); |
| } |
| break; |
| } |
| setState(888); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,99,_ctx) ) { |
| case 1: |
| { |
| setState(887); |
| ((FieldDeclContext)_localctx).tag = string_(); |
| } |
| break; |
| } |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class String_Context extends ParserRuleContext { |
| public TerminalNode RAW_STRING_LIT() { return getToken(GoParser.RAW_STRING_LIT, 0); } |
| public TerminalNode INTERPRETED_STRING_LIT() { return getToken(GoParser.INTERPRETED_STRING_LIT, 0); } |
| public String_Context(ParserRuleContext parent, int invokingState) { |
| super(parent, invokingState); |
| } |
| @Override public int getRuleIndex() { return RULE_string_; } |
| @Override |
| public void enterRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).enterString_(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitString_(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitString_(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final String_Context string_() throws RecognitionException { |
| String_Context _localctx = new String_Context(_ctx, getState()); |
| enterRule(_localctx, 178, RULE_string_); |
| int _la; |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(890); |
| _la = _input.LA(1); |
| if ( !(_la==RAW_STRING_LIT || _la==INTERPRETED_STRING_LIT) ) { |
| _errHandler.recoverInline(this); |
| } |
| else { |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; |
| _errHandler.reportMatch(this); |
| consume(); |
| } |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class EmbeddedFieldContext extends ParserRuleContext { |
| public TypeNameContext typeName() { |
| return getRuleContext(TypeNameContext.class,0); |
| } |
| public TerminalNode STAR() { return getToken(GoParser.STAR, 0); } |
| public EmbeddedFieldContext(ParserRuleContext parent, int invokingState) { |
| super(parent, invokingState); |
| } |
| @Override public int getRuleIndex() { return RULE_embeddedField; } |
| @Override |
| public void enterRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).enterEmbeddedField(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitEmbeddedField(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitEmbeddedField(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final EmbeddedFieldContext embeddedField() throws RecognitionException { |
| EmbeddedFieldContext _localctx = new EmbeddedFieldContext(_ctx, getState()); |
| enterRule(_localctx, 180, RULE_embeddedField); |
| int _la; |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(893); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| if (_la==STAR) { |
| { |
| setState(892); |
| match(STAR); |
| } |
| } |
| |
| setState(895); |
| typeName(); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class FunctionLitContext extends ParserRuleContext { |
| public TerminalNode FUNC() { return getToken(GoParser.FUNC, 0); } |
| public SignatureContext signature() { |
| return getRuleContext(SignatureContext.class,0); |
| } |
| public BlockContext block() { |
| return getRuleContext(BlockContext.class,0); |
| } |
| public FunctionLitContext(ParserRuleContext parent, int invokingState) { |
| super(parent, invokingState); |
| } |
| @Override public int getRuleIndex() { return RULE_functionLit; } |
| @Override |
| public void enterRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).enterFunctionLit(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitFunctionLit(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitFunctionLit(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final FunctionLitContext functionLit() throws RecognitionException { |
| FunctionLitContext _localctx = new FunctionLitContext(_ctx, getState()); |
| enterRule(_localctx, 182, RULE_functionLit); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(897); |
| match(FUNC); |
| setState(898); |
| signature(); |
| setState(899); |
| block(); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class IndexContext extends ParserRuleContext { |
| public TerminalNode L_BRACKET() { return getToken(GoParser.L_BRACKET, 0); } |
| public ExpressionContext expression() { |
| return getRuleContext(ExpressionContext.class,0); |
| } |
| public TerminalNode R_BRACKET() { return getToken(GoParser.R_BRACKET, 0); } |
| public IndexContext(ParserRuleContext parent, int invokingState) { |
| super(parent, invokingState); |
| } |
| @Override public int getRuleIndex() { return RULE_index; } |
| @Override |
| public void enterRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).enterIndex(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitIndex(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitIndex(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final IndexContext index() throws RecognitionException { |
| IndexContext _localctx = new IndexContext(_ctx, getState()); |
| enterRule(_localctx, 184, RULE_index); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(901); |
| match(L_BRACKET); |
| setState(902); |
| expression(0); |
| setState(903); |
| match(R_BRACKET); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class Slice_Context extends ParserRuleContext { |
| public TerminalNode L_BRACKET() { return getToken(GoParser.L_BRACKET, 0); } |
| public TerminalNode R_BRACKET() { return getToken(GoParser.R_BRACKET, 0); } |
| public List<TerminalNode> COLON() { return getTokens(GoParser.COLON); } |
| public TerminalNode COLON(int i) { |
| return getToken(GoParser.COLON, i); |
| } |
| public List<ExpressionContext> expression() { |
| return getRuleContexts(ExpressionContext.class); |
| } |
| public ExpressionContext expression(int i) { |
| return getRuleContext(ExpressionContext.class,i); |
| } |
| public Slice_Context(ParserRuleContext parent, int invokingState) { |
| super(parent, invokingState); |
| } |
| @Override public int getRuleIndex() { return RULE_slice_; } |
| @Override |
| public void enterRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).enterSlice_(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitSlice_(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitSlice_(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final Slice_Context slice_() throws RecognitionException { |
| Slice_Context _localctx = new Slice_Context(_ctx, getState()); |
| enterRule(_localctx, 186, RULE_slice_); |
| int _la; |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(905); |
| match(L_BRACKET); |
| setState(921); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,104,_ctx) ) { |
| case 1: |
| { |
| setState(907); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| if (((_la) & ~0x3f) == 0 && ((1L << _la) & -144115183311122920L) != 0 || (((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 49567L) != 0) { |
| { |
| setState(906); |
| expression(0); |
| } |
| } |
| |
| setState(909); |
| match(COLON); |
| setState(911); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| if (((_la) & ~0x3f) == 0 && ((1L << _la) & -144115183311122920L) != 0 || (((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 49567L) != 0) { |
| { |
| setState(910); |
| expression(0); |
| } |
| } |
| |
| } |
| break; |
| case 2: |
| { |
| setState(914); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| if (((_la) & ~0x3f) == 0 && ((1L << _la) & -144115183311122920L) != 0 || (((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 49567L) != 0) { |
| { |
| setState(913); |
| expression(0); |
| } |
| } |
| |
| setState(916); |
| match(COLON); |
| setState(917); |
| expression(0); |
| setState(918); |
| match(COLON); |
| setState(919); |
| expression(0); |
| } |
| break; |
| } |
| setState(923); |
| match(R_BRACKET); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class TypeAssertionContext extends ParserRuleContext { |
| public TerminalNode DOT() { return getToken(GoParser.DOT, 0); } |
| public TerminalNode L_PAREN() { return getToken(GoParser.L_PAREN, 0); } |
| public Type_Context type_() { |
| return getRuleContext(Type_Context.class,0); |
| } |
| public TerminalNode R_PAREN() { return getToken(GoParser.R_PAREN, 0); } |
| public TypeAssertionContext(ParserRuleContext parent, int invokingState) { |
| super(parent, invokingState); |
| } |
| @Override public int getRuleIndex() { return RULE_typeAssertion; } |
| @Override |
| public void enterRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).enterTypeAssertion(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitTypeAssertion(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitTypeAssertion(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final TypeAssertionContext typeAssertion() throws RecognitionException { |
| TypeAssertionContext _localctx = new TypeAssertionContext(_ctx, getState()); |
| enterRule(_localctx, 188, RULE_typeAssertion); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(925); |
| match(DOT); |
| setState(926); |
| match(L_PAREN); |
| setState(927); |
| type_(); |
| setState(928); |
| match(R_PAREN); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class ArgumentsContext extends ParserRuleContext { |
| public TerminalNode L_PAREN() { return getToken(GoParser.L_PAREN, 0); } |
| public TerminalNode R_PAREN() { return getToken(GoParser.R_PAREN, 0); } |
| public ExpressionListContext expressionList() { |
| return getRuleContext(ExpressionListContext.class,0); |
| } |
| public NonNamedTypeContext nonNamedType() { |
| return getRuleContext(NonNamedTypeContext.class,0); |
| } |
| public TerminalNode ELLIPSIS() { return getToken(GoParser.ELLIPSIS, 0); } |
| public List<TerminalNode> COMMA() { return getTokens(GoParser.COMMA); } |
| public TerminalNode COMMA(int i) { |
| return getToken(GoParser.COMMA, i); |
| } |
| public ArgumentsContext(ParserRuleContext parent, int invokingState) { |
| super(parent, invokingState); |
| } |
| @Override public int getRuleIndex() { return RULE_arguments; } |
| @Override |
| public void enterRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).enterArguments(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitArguments(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitArguments(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final ArgumentsContext arguments() throws RecognitionException { |
| ArgumentsContext _localctx = new ArgumentsContext(_ctx, getState()); |
| enterRule(_localctx, 190, RULE_arguments); |
| int _la; |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(930); |
| match(L_PAREN); |
| setState(945); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| if (((_la) & ~0x3f) == 0 && ((1L << _la) & -144115183311122920L) != 0 || (((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 49567L) != 0) { |
| { |
| setState(937); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,106,_ctx) ) { |
| case 1: |
| { |
| setState(931); |
| expressionList(); |
| } |
| break; |
| case 2: |
| { |
| setState(932); |
| nonNamedType(); |
| setState(935); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,105,_ctx) ) { |
| case 1: |
| { |
| setState(933); |
| match(COMMA); |
| setState(934); |
| expressionList(); |
| } |
| break; |
| } |
| } |
| break; |
| } |
| setState(940); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| if (_la==ELLIPSIS) { |
| { |
| setState(939); |
| match(ELLIPSIS); |
| } |
| } |
| |
| setState(943); |
| _errHandler.sync(this); |
| _la = _input.LA(1); |
| if (_la==COMMA) { |
| { |
| setState(942); |
| match(COMMA); |
| } |
| } |
| |
| } |
| } |
| |
| setState(947); |
| match(R_PAREN); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class MethodExprContext extends ParserRuleContext { |
| public NonNamedTypeContext nonNamedType() { |
| return getRuleContext(NonNamedTypeContext.class,0); |
| } |
| public TerminalNode DOT() { return getToken(GoParser.DOT, 0); } |
| public TerminalNode IDENTIFIER() { return getToken(GoParser.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 GoParserListener ) ((GoParserListener)listener).enterMethodExpr(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitMethodExpr(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitMethodExpr(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final MethodExprContext methodExpr() throws RecognitionException { |
| MethodExprContext _localctx = new MethodExprContext(_ctx, getState()); |
| enterRule(_localctx, 192, RULE_methodExpr); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(949); |
| nonNamedType(); |
| setState(950); |
| match(DOT); |
| setState(951); |
| match(IDENTIFIER); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class ReceiverTypeContext extends ParserRuleContext { |
| public Type_Context type_() { |
| return getRuleContext(Type_Context.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 GoParserListener ) ((GoParserListener)listener).enterReceiverType(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitReceiverType(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitReceiverType(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final ReceiverTypeContext receiverType() throws RecognitionException { |
| ReceiverTypeContext _localctx = new ReceiverTypeContext(_ctx, getState()); |
| enterRule(_localctx, 194, RULE_receiverType); |
| try { |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(953); |
| type_(); |
| } |
| } |
| catch (RecognitionException re) { |
| _localctx.exception = re; |
| _errHandler.reportError(this, re); |
| _errHandler.recover(this, re); |
| } |
| finally { |
| exitRule(); |
| } |
| return _localctx; |
| } |
| |
| @SuppressWarnings("CheckReturnValue") |
| public static class EosContext extends ParserRuleContext { |
| public TerminalNode SEMI() { return getToken(GoParser.SEMI, 0); } |
| public TerminalNode EOF() { return getToken(GoParser.EOF, 0); } |
| public TerminalNode EOS() { return getToken(GoParser.EOS, 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 GoParserListener ) ((GoParserListener)listener).enterEos(this); |
| } |
| @Override |
| public void exitRule(ParseTreeListener listener) { |
| if ( listener instanceof GoParserListener ) ((GoParserListener)listener).exitEos(this); |
| } |
| @Override |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { |
| if ( visitor instanceof GoParserVisitor ) return ((GoParserVisitor<? extends T>)visitor).visitEos(this); |
| else return visitor.visitChildren(this); |
| } |
| } |
| |
| public final EosContext eos() throws RecognitionException { |
| EosContext _localctx = new EosContext(_ctx, getState()); |
| enterRule(_localctx, 196, RULE_eos); |
| try { |
| setState(959); |
| _errHandler.sync(this); |
| switch ( getInterpreter().adaptivePredict(_input,110,_ctx) ) { |
| case 1: |
| enterOuterAlt(_localctx, 1); |
| { |
| setState(955); |
| match(SEMI); |
| } |
| break; |
| case 2: |
| enterOuterAlt(_localctx, 2); |
| { |
| setState(956); |
| match(EOF); |
| } |
| break; |
| case 3: |
| enterOuterAlt(_localctx, 3); |
| { |
| setState(957); |
| match(EOS); |
| } |
| break; |
| case 4: |
| enterOuterAlt(_localctx, 4); |
| { |
| setState(958); |
| if (!(this.closingBracket())) throw new FailedPredicateException(this, "this.closingBracket()"); |
| } |
| 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 18: |
| return statementList_sempred((StatementListContext)_localctx, predIndex); |
| case 70: |
| return expression_sempred((ExpressionContext)_localctx, predIndex); |
| case 71: |
| return primaryExpr_sempred((PrimaryExprContext)_localctx, predIndex); |
| case 98: |
| return eos_sempred((EosContext)_localctx, predIndex); |
| } |
| return true; |
| } |
| private boolean statementList_sempred(StatementListContext _localctx, int predIndex) { |
| switch (predIndex) { |
| case 0: |
| return this.closingBracket(); |
| } |
| return true; |
| } |
| private boolean expression_sempred(ExpressionContext _localctx, int predIndex) { |
| switch (predIndex) { |
| case 1: |
| return precpred(_ctx, 5); |
| case 2: |
| return precpred(_ctx, 4); |
| case 3: |
| return precpred(_ctx, 3); |
| case 4: |
| return precpred(_ctx, 2); |
| case 5: |
| return precpred(_ctx, 1); |
| } |
| return true; |
| } |
| private boolean primaryExpr_sempred(PrimaryExprContext _localctx, int predIndex) { |
| switch (predIndex) { |
| case 6: |
| return precpred(_ctx, 1); |
| } |
| return true; |
| } |
| private boolean eos_sempred(EosContext _localctx, int predIndex) { |
| switch (predIndex) { |
| case 7: |
| return this.closingBracket(); |
| } |
| return true; |
| } |
| |
| public static final String _serializedATN = |
| "\u0004\u0001X\u03c2\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001\u0002"+ |
| "\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004\u0002"+ |
| "\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007\u0002"+ |
| "\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b\u0002"+ |
| "\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0002\u000f\u0007\u000f"+ |
| "\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011\u0002\u0012\u0007\u0012"+ |
| "\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014\u0002\u0015\u0007\u0015"+ |
| "\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017\u0002\u0018\u0007\u0018"+ |
| "\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a\u0002\u001b\u0007\u001b"+ |
| "\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d\u0002\u001e\u0007\u001e"+ |
| "\u0002\u001f\u0007\u001f\u0002 \u0007 \u0002!\u0007!\u0002\"\u0007\"\u0002"+ |
| "#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002&\u0007&\u0002\'\u0007\'\u0002"+ |
| "(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002+\u0007+\u0002,\u0007,\u0002"+ |
| "-\u0007-\u0002.\u0007.\u0002/\u0007/\u00020\u00070\u00021\u00071\u0002"+ |
| "2\u00072\u00023\u00073\u00024\u00074\u00025\u00075\u00026\u00076\u0002"+ |
| "7\u00077\u00028\u00078\u00029\u00079\u0002:\u0007:\u0002;\u0007;\u0002"+ |
| "<\u0007<\u0002=\u0007=\u0002>\u0007>\u0002?\u0007?\u0002@\u0007@\u0002"+ |
| "A\u0007A\u0002B\u0007B\u0002C\u0007C\u0002D\u0007D\u0002E\u0007E\u0002"+ |
| "F\u0007F\u0002G\u0007G\u0002H\u0007H\u0002I\u0007I\u0002J\u0007J\u0002"+ |
| "K\u0007K\u0002L\u0007L\u0002M\u0007M\u0002N\u0007N\u0002O\u0007O\u0002"+ |
| "P\u0007P\u0002Q\u0007Q\u0002R\u0007R\u0002S\u0007S\u0002T\u0007T\u0002"+ |
| "U\u0007U\u0002V\u0007V\u0002W\u0007W\u0002X\u0007X\u0002Y\u0007Y\u0002"+ |
| "Z\u0007Z\u0002[\u0007[\u0002\\\u0007\\\u0002]\u0007]\u0002^\u0007^\u0002"+ |
| "_\u0007_\u0002`\u0007`\u0002a\u0007a\u0002b\u0007b\u0001\u0000\u0001\u0000"+ |
| "\u0001\u0000\u0001\u0000\u0001\u0000\u0005\u0000\u00cc\b\u0000\n\u0000"+ |
| "\f\u0000\u00cf\t\u0000\u0001\u0000\u0001\u0000\u0001\u0000\u0003\u0000"+ |
| "\u00d4\b\u0000\u0001\u0000\u0001\u0000\u0005\u0000\u00d8\b\u0000\n\u0000"+ |
| "\f\u0000\u00db\t\u0000\u0001\u0000\u0001\u0000\u0001\u0001\u0001\u0001"+ |
| "\u0001\u0001\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002"+ |
| "\u0001\u0002\u0005\u0002\u00e8\b\u0002\n\u0002\f\u0002\u00eb\t\u0002\u0001"+ |
| "\u0002\u0003\u0002\u00ee\b\u0002\u0001\u0003\u0003\u0003\u00f1\b\u0003"+ |
| "\u0001\u0003\u0001\u0003\u0001\u0004\u0001\u0004\u0001\u0005\u0001\u0005"+ |
| "\u0001\u0005\u0003\u0005\u00fa\b\u0005\u0001\u0006\u0001\u0006\u0001\u0006"+ |
| "\u0001\u0006\u0001\u0006\u0001\u0006\u0005\u0006\u0102\b\u0006\n\u0006"+ |
| "\f\u0006\u0105\t\u0006\u0001\u0006\u0003\u0006\u0108\b\u0006\u0001\u0007"+ |
| "\u0001\u0007\u0003\u0007\u010c\b\u0007\u0001\u0007\u0001\u0007\u0003\u0007"+ |
| "\u0110\b\u0007\u0001\b\u0001\b\u0001\b\u0005\b\u0115\b\b\n\b\f\b\u0118"+ |
| "\t\b\u0001\t\u0001\t\u0001\t\u0005\t\u011d\b\t\n\t\f\t\u0120\t\t\u0001"+ |
| "\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0005\n\u0128\b\n\n\n\f\n\u012b"+ |
| "\t\n\u0001\n\u0003\n\u012e\b\n\u0001\u000b\u0001\u000b\u0003\u000b\u0132"+ |
| "\b\u000b\u0001\u000b\u0001\u000b\u0001\f\u0001\f\u0001\f\u0001\f\u0003"+ |
| "\f\u013a\b\f\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0003\r\u0141\b\r"+ |
| "\u0001\u000e\u0001\u000e\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f"+ |
| "\u0001\u000f\u0001\u000f\u0005\u000f\u014b\b\u000f\n\u000f\f\u000f\u014e"+ |
| "\t\u000f\u0001\u000f\u0003\u000f\u0151\b\u000f\u0001\u0010\u0001\u0010"+ |
| "\u0001\u0010\u0001\u0010\u0003\u0010\u0157\b\u0010\u0001\u0010\u0001\u0010"+ |
| "\u0003\u0010\u015b\b\u0010\u0001\u0011\u0001\u0011\u0003\u0011\u015f\b"+ |
| "\u0011\u0001\u0011\u0001\u0011\u0001\u0012\u0003\u0012\u0164\b\u0012\u0001"+ |
| "\u0012\u0003\u0012\u0167\b\u0012\u0001\u0012\u0003\u0012\u016a\b\u0012"+ |
| "\u0001\u0012\u0001\u0012\u0001\u0012\u0004\u0012\u016f\b\u0012\u000b\u0012"+ |
| "\f\u0012\u0170\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013"+ |
| "\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013"+ |
| "\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0003\u0013\u0182\b\u0013"+ |
| "\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0003\u0014"+ |
| "\u0189\b\u0014\u0001\u0015\u0001\u0015\u0001\u0016\u0001\u0016\u0001\u0016"+ |
| "\u0001\u0016\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0018\u0001\u0018"+ |
| "\u0001\u0018\u0001\u0018\u0001\u0019\u0003\u0019\u0199\b\u0019\u0001\u0019"+ |
| "\u0001\u0019\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001b"+ |
| "\u0001\u001b\u0001\u001c\u0001\u001c\u0001\u001c\u0003\u001c\u01a6\b\u001c"+ |
| "\u0001\u001d\u0001\u001d\u0003\u001d\u01aa\b\u001d\u0001\u001e\u0001\u001e"+ |
| "\u0003\u001e\u01ae\b\u001e\u0001\u001f\u0001\u001f\u0003\u001f\u01b2\b"+ |
| "\u001f\u0001 \u0001 \u0001 \u0001!\u0001!\u0001\"\u0001\"\u0001\"\u0001"+ |
| "#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0003#\u01c5"+ |
| "\b#\u0001#\u0001#\u0001#\u0001#\u0003#\u01cb\b#\u0003#\u01cd\b#\u0001"+ |
| "$\u0001$\u0003$\u01d1\b$\u0001%\u0001%\u0003%\u01d5\b%\u0001%\u0003%\u01d8"+ |
| "\b%\u0001%\u0001%\u0003%\u01dc\b%\u0003%\u01de\b%\u0001%\u0001%\u0005"+ |
| "%\u01e2\b%\n%\f%\u01e5\t%\u0001%\u0001%\u0001&\u0001&\u0001&\u0003&\u01ec"+ |
| "\b&\u0001\'\u0001\'\u0001\'\u0003\'\u01f1\b\'\u0001(\u0001(\u0001(\u0001"+ |
| "(\u0001(\u0001(\u0001(\u0001(\u0001(\u0003(\u01fc\b(\u0001(\u0001(\u0005"+ |
| "(\u0200\b(\n(\f(\u0203\t(\u0001(\u0001(\u0001)\u0001)\u0003)\u0209\b)"+ |
| "\u0001)\u0001)\u0001)\u0001)\u0001)\u0001)\u0001*\u0001*\u0001*\u0003"+ |
| "*\u0214\b*\u0001+\u0001+\u0001+\u0003+\u0219\b+\u0001,\u0001,\u0003,\u021d"+ |
| "\b,\u0001,\u0001,\u0001,\u0003,\u0222\b,\u0005,\u0224\b,\n,\f,\u0227\t"+ |
| ",\u0001-\u0001-\u0001-\u0005-\u022c\b-\n-\f-\u022f\t-\u0001-\u0001-\u0001"+ |
| ".\u0001.\u0001.\u0003.\u0236\b.\u0001/\u0001/\u0001/\u0003/\u023b\b/\u0001"+ |
| "/\u0003/\u023e\b/\u00010\u00010\u00010\u00010\u00010\u00010\u00030\u0246"+ |
| "\b0\u00010\u00010\u00011\u00011\u00031\u024c\b1\u00011\u00011\u00031\u0250"+ |
| "\b1\u00031\u0252\b1\u00011\u00011\u00012\u00032\u0257\b2\u00012\u0001"+ |
| "2\u00032\u025b\b2\u00012\u00012\u00032\u025f\b2\u00013\u00013\u00013\u0001"+ |
| "3\u00013\u00013\u00033\u0267\b3\u00013\u00013\u00013\u00014\u00014\u0001"+ |
| "4\u00015\u00015\u00015\u00015\u00015\u00015\u00035\u0275\b5\u00016\u0001"+ |
| "6\u00036\u0279\b6\u00017\u00017\u00017\u00017\u00017\u00017\u00017\u0001"+ |
| "7\u00037\u0283\b7\u00018\u00018\u00018\u00018\u00018\u00019\u00019\u0001"+ |
| ":\u0001:\u0001;\u0001;\u0001;\u0001<\u0001<\u0001<\u0001<\u0003<\u0295"+ |
| "\b<\u0001<\u0001<\u0005<\u0299\b<\n<\f<\u029c\t<\u0001<\u0001<\u0001="+ |
| "\u0001=\u0001=\u0001=\u0001>\u0001>\u0001>\u0001>\u0001>\u0001>\u0001"+ |
| "?\u0001?\u0001?\u0001?\u0001?\u0003?\u02af\b?\u0001?\u0001?\u0001@\u0001"+ |
| "@\u0001@\u0001@\u0001@\u0001@\u0003@\u02b9\b@\u0001A\u0001A\u0001A\u0001"+ |
| "B\u0001B\u0001B\u0001B\u0003B\u02c2\bB\u0001C\u0001C\u0003C\u02c6\bC\u0001"+ |
| "D\u0001D\u0001D\u0001D\u0005D\u02cc\bD\nD\fD\u02cf\tD\u0001D\u0003D\u02d2"+ |
| "\bD\u0003D\u02d4\bD\u0001D\u0001D\u0001E\u0003E\u02d9\bE\u0001E\u0003"+ |
| "E\u02dc\bE\u0001E\u0001E\u0001F\u0001F\u0001F\u0001F\u0003F\u02e4\bF\u0001"+ |
| "F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001"+ |
| "F\u0001F\u0001F\u0001F\u0001F\u0005F\u02f5\bF\nF\fF\u02f8\tF\u0001G\u0001"+ |
| "G\u0001G\u0001G\u0003G\u02fe\bG\u0001G\u0001G\u0001G\u0001G\u0001G\u0001"+ |
| "G\u0001G\u0003G\u0307\bG\u0005G\u0309\bG\nG\fG\u030c\tG\u0001H\u0001H"+ |
| "\u0001H\u0001H\u0003H\u0312\bH\u0001H\u0001H\u0001I\u0001I\u0001I\u0001"+ |
| "I\u0001I\u0003I\u031b\bI\u0001J\u0001J\u0001J\u0001J\u0001J\u0001J\u0003"+ |
| "J\u0323\bJ\u0001K\u0001K\u0001K\u0003K\u0328\bK\u0001L\u0001L\u0001L\u0001"+ |
| "L\u0003L\u032e\bL\u0001M\u0001M\u0001N\u0001N\u0001O\u0001O\u0001O\u0001"+ |
| "O\u0001P\u0001P\u0001P\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001"+ |
| "Q\u0001Q\u0001Q\u0003Q\u0344\bQ\u0001R\u0001R\u0001R\u0003R\u0349\bR\u0003"+ |
| "R\u034b\bR\u0001R\u0001R\u0001S\u0001S\u0001S\u0005S\u0352\bS\nS\fS\u0355"+ |
| "\tS\u0001T\u0001T\u0001T\u0003T\u035a\bT\u0001T\u0001T\u0001U\u0001U\u0003"+ |
| "U\u0360\bU\u0001V\u0001V\u0003V\u0364\bV\u0001W\u0001W\u0001W\u0001W\u0001"+ |
| "W\u0005W\u036b\bW\nW\fW\u036e\tW\u0001W\u0001W\u0001X\u0001X\u0001X\u0001"+ |
| "X\u0003X\u0376\bX\u0001X\u0003X\u0379\bX\u0001Y\u0001Y\u0001Z\u0003Z\u037e"+ |
| "\bZ\u0001Z\u0001Z\u0001[\u0001[\u0001[\u0001[\u0001\\\u0001\\\u0001\\"+ |
| "\u0001\\\u0001]\u0001]\u0003]\u038c\b]\u0001]\u0001]\u0003]\u0390\b]\u0001"+ |
| "]\u0003]\u0393\b]\u0001]\u0001]\u0001]\u0001]\u0001]\u0003]\u039a\b]\u0001"+ |
| "]\u0001]\u0001^\u0001^\u0001^\u0001^\u0001^\u0001_\u0001_\u0001_\u0001"+ |
| "_\u0001_\u0003_\u03a8\b_\u0003_\u03aa\b_\u0001_\u0003_\u03ad\b_\u0001"+ |
| "_\u0003_\u03b0\b_\u0003_\u03b2\b_\u0001_\u0001_\u0001`\u0001`\u0001`\u0001"+ |
| "`\u0001a\u0001a\u0001b\u0001b\u0001b\u0001b\u0003b\u03c0\bb\u0001b\u0000"+ |
| "\u0002\u008c\u008ec\u0000\u0002\u0004\u0006\b\n\f\u000e\u0010\u0012\u0014"+ |
| "\u0016\u0018\u001a\u001c\u001e \"$&(*,.02468:<>@BDFHJLNPRTVXZ\\^`bdfh"+ |
| "jlnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c\u008e\u0090\u0092"+ |
| "\u0094\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa"+ |
| "\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc\u00be\u00c0\u00c2"+ |
| "\u00c4\u0000\n\u0002\u0000\u001b\u001b&&\u0001\u0000\'(\u0002\u000038"+ |
| ":>\u0002\u0000$$WW\u0001\u00009?\u0002\u000048=>\u0002\u000033:<\u0001"+ |
| "\u0000-2\u0002\u0000@CGH\u0001\u0000NO\u03fe\u0000\u00c6\u0001\u0000\u0000"+ |
| "\u0000\u0002\u00de\u0001\u0000\u0000\u0000\u0004\u00e1\u0001\u0000\u0000"+ |
| "\u0000\u0006\u00f0\u0001\u0000\u0000\u0000\b\u00f4\u0001\u0000\u0000\u0000"+ |
| "\n\u00f9\u0001\u0000\u0000\u0000\f\u00fb\u0001\u0000\u0000\u0000\u000e"+ |
| "\u0109\u0001\u0000\u0000\u0000\u0010\u0111\u0001\u0000\u0000\u0000\u0012"+ |
| "\u0119\u0001\u0000\u0000\u0000\u0014\u0121\u0001\u0000\u0000\u0000\u0016"+ |
| "\u012f\u0001\u0000\u0000\u0000\u0018\u0135\u0001\u0000\u0000\u0000\u001a"+ |
| "\u013b\u0001\u0000\u0000\u0000\u001c\u0142\u0001\u0000\u0000\u0000\u001e"+ |
| "\u0144\u0001\u0000\u0000\u0000 \u0152\u0001\u0000\u0000\u0000\"\u015c"+ |
| "\u0001\u0000\u0000\u0000$\u016e\u0001\u0000\u0000\u0000&\u0181\u0001\u0000"+ |
| "\u0000\u0000(\u0188\u0001\u0000\u0000\u0000*\u018a\u0001\u0000\u0000\u0000"+ |
| ",\u018c\u0001\u0000\u0000\u0000.\u0190\u0001\u0000\u0000\u00000\u0193"+ |
| "\u0001\u0000\u0000\u00002\u0198\u0001\u0000\u0000\u00004\u019c\u0001\u0000"+ |
| "\u0000\u00006\u01a0\u0001\u0000\u0000\u00008\u01a2\u0001\u0000\u0000\u0000"+ |
| ":\u01a7\u0001\u0000\u0000\u0000<\u01ab\u0001\u0000\u0000\u0000>\u01af"+ |
| "\u0001\u0000\u0000\u0000@\u01b3\u0001\u0000\u0000\u0000B\u01b6\u0001\u0000"+ |
| "\u0000\u0000D\u01b8\u0001\u0000\u0000\u0000F\u01bb\u0001\u0000\u0000\u0000"+ |
| "H\u01d0\u0001\u0000\u0000\u0000J\u01d2\u0001\u0000\u0000\u0000L\u01e8"+ |
| "\u0001\u0000\u0000\u0000N\u01f0\u0001\u0000\u0000\u0000P\u01f2\u0001\u0000"+ |
| "\u0000\u0000R\u0208\u0001\u0000\u0000\u0000T\u0210\u0001\u0000\u0000\u0000"+ |
| "V\u0218\u0001\u0000\u0000\u0000X\u021c\u0001\u0000\u0000\u0000Z\u0228"+ |
| "\u0001\u0000\u0000\u0000\\\u0232\u0001\u0000\u0000\u0000^\u023d\u0001"+ |
| "\u0000\u0000\u0000`\u0245\u0001\u0000\u0000\u0000b\u0249\u0001\u0000\u0000"+ |
| "\u0000d\u0256\u0001\u0000\u0000\u0000f\u0266\u0001\u0000\u0000\u0000h"+ |
| "\u026b\u0001\u0000\u0000\u0000j\u0274\u0001\u0000\u0000\u0000l\u0278\u0001"+ |
| "\u0000\u0000\u0000n\u0282\u0001\u0000\u0000\u0000p\u0284\u0001\u0000\u0000"+ |
| "\u0000r\u0289\u0001\u0000\u0000\u0000t\u028b\u0001\u0000\u0000\u0000v"+ |
| "\u028d\u0001\u0000\u0000\u0000x\u0290\u0001\u0000\u0000\u0000z\u029f\u0001"+ |
| "\u0000\u0000\u0000|\u02a3\u0001\u0000\u0000\u0000~\u02ae\u0001\u0000\u0000"+ |
| "\u0000\u0080\u02b8\u0001\u0000\u0000\u0000\u0082\u02ba\u0001\u0000\u0000"+ |
| "\u0000\u0084\u02c1\u0001\u0000\u0000\u0000\u0086\u02c5\u0001\u0000\u0000"+ |
| "\u0000\u0088\u02c7\u0001\u0000\u0000\u0000\u008a\u02d8\u0001\u0000\u0000"+ |
| "\u0000\u008c\u02e3\u0001\u0000\u0000\u0000\u008e\u02fd\u0001\u0000\u0000"+ |
| "\u0000\u0090\u030d\u0001\u0000\u0000\u0000\u0092\u031a\u0001\u0000\u0000"+ |
| "\u0000\u0094\u0322\u0001\u0000\u0000\u0000\u0096\u0327\u0001\u0000\u0000"+ |
| "\u0000\u0098\u032d\u0001\u0000\u0000\u0000\u009a\u032f\u0001\u0000\u0000"+ |
| "\u0000\u009c\u0331\u0001\u0000\u0000\u0000\u009e\u0333\u0001\u0000\u0000"+ |
| "\u0000\u00a0\u0337\u0001\u0000\u0000\u0000\u00a2\u0343\u0001\u0000\u0000"+ |
| "\u0000\u00a4\u0345\u0001\u0000\u0000\u0000\u00a6\u034e\u0001\u0000\u0000"+ |
| "\u0000\u00a8\u0359\u0001\u0000\u0000\u0000\u00aa\u035f\u0001\u0000\u0000"+ |
| "\u0000\u00ac\u0363\u0001\u0000\u0000\u0000\u00ae\u0365\u0001\u0000\u0000"+ |
| "\u0000\u00b0\u0375\u0001\u0000\u0000\u0000\u00b2\u037a\u0001\u0000\u0000"+ |
| "\u0000\u00b4\u037d\u0001\u0000\u0000\u0000\u00b6\u0381\u0001\u0000\u0000"+ |
| "\u0000\u00b8\u0385\u0001\u0000\u0000\u0000\u00ba\u0389\u0001\u0000\u0000"+ |
| "\u0000\u00bc\u039d\u0001\u0000\u0000\u0000\u00be\u03a2\u0001\u0000\u0000"+ |
| "\u0000\u00c0\u03b5\u0001\u0000\u0000\u0000\u00c2\u03b9\u0001\u0000\u0000"+ |
| "\u0000\u00c4\u03bf\u0001\u0000\u0000\u0000\u00c6\u00c7\u0003\u0002\u0001"+ |
| "\u0000\u00c7\u00cd\u0003\u00c4b\u0000\u00c8\u00c9\u0003\u0004\u0002\u0000"+ |
| "\u00c9\u00ca\u0003\u00c4b\u0000\u00ca\u00cc\u0001\u0000\u0000\u0000\u00cb"+ |
| "\u00c8\u0001\u0000\u0000\u0000\u00cc\u00cf\u0001\u0000\u0000\u0000\u00cd"+ |
| "\u00cb\u0001\u0000\u0000\u0000\u00cd\u00ce\u0001\u0000\u0000\u0000\u00ce"+ |
| "\u00d9\u0001\u0000\u0000\u0000\u00cf\u00cd\u0001\u0000\u0000\u0000\u00d0"+ |
| "\u00d4\u0003\u0018\f\u0000\u00d1\u00d4\u0003\u001a\r\u0000\u00d2\u00d4"+ |
| "\u0003\n\u0005\u0000\u00d3\u00d0\u0001\u0000\u0000\u0000\u00d3\u00d1\u0001"+ |
| "\u0000\u0000\u0000\u00d3\u00d2\u0001\u0000\u0000\u0000\u00d4\u00d5\u0001"+ |
| "\u0000\u0000\u0000\u00d5\u00d6\u0003\u00c4b\u0000\u00d6\u00d8\u0001\u0000"+ |
| "\u0000\u0000\u00d7\u00d3\u0001\u0000\u0000\u0000\u00d8\u00db\u0001\u0000"+ |
| "\u0000\u0000\u00d9\u00d7\u0001\u0000\u0000\u0000\u00d9\u00da\u0001\u0000"+ |
| "\u0000\u0000\u00da\u00dc\u0001\u0000\u0000\u0000\u00db\u00d9\u0001\u0000"+ |
| "\u0000\u0000\u00dc\u00dd\u0005\u0000\u0000\u0001\u00dd\u0001\u0001\u0000"+ |
| "\u0000\u0000\u00de\u00df\u0005\u000e\u0000\u0000\u00df\u00e0\u0005\u001b"+ |
| "\u0000\u0000\u00e0\u0003\u0001\u0000\u0000\u0000\u00e1\u00ed\u0005\u0017"+ |
| "\u0000\u0000\u00e2\u00ee\u0003\u0006\u0003\u0000\u00e3\u00e9\u0005\u001c"+ |
| "\u0000\u0000\u00e4\u00e5\u0003\u0006\u0003\u0000\u00e5\u00e6\u0003\u00c4"+ |
| "b\u0000\u00e6\u00e8\u0001\u0000\u0000\u0000\u00e7\u00e4\u0001\u0000\u0000"+ |
| "\u0000\u00e8\u00eb\u0001\u0000\u0000\u0000\u00e9\u00e7\u0001\u0000\u0000"+ |
| "\u0000\u00e9\u00ea\u0001\u0000\u0000\u0000\u00ea\u00ec\u0001\u0000\u0000"+ |
| "\u0000\u00eb\u00e9\u0001\u0000\u0000\u0000\u00ec\u00ee\u0005\u001d\u0000"+ |
| "\u0000\u00ed\u00e2\u0001\u0000\u0000\u0000\u00ed\u00e3\u0001\u0000\u0000"+ |
| "\u0000\u00ee\u0005\u0001\u0000\u0000\u0000\u00ef\u00f1\u0007\u0000\u0000"+ |
| "\u0000\u00f0\u00ef\u0001\u0000\u0000\u0000\u00f0\u00f1\u0001\u0000\u0000"+ |
| "\u0000\u00f1\u00f2\u0001\u0000\u0000\u0000\u00f2\u00f3\u0003\b\u0004\u0000"+ |
| "\u00f3\u0007\u0001\u0000\u0000\u0000\u00f4\u00f5\u0003\u00b2Y\u0000\u00f5"+ |
| "\t\u0001\u0000\u0000\u0000\u00f6\u00fa\u0003\f\u0006\u0000\u00f7\u00fa"+ |
| "\u0003\u0014\n\u0000\u00f8\u00fa\u0003\u001e\u000f\u0000\u00f9\u00f6\u0001"+ |
| "\u0000\u0000\u0000\u00f9\u00f7\u0001\u0000\u0000\u0000\u00f9\u00f8\u0001"+ |
| "\u0000\u0000\u0000\u00fa\u000b\u0001\u0000\u0000\u0000\u00fb\u0107\u0005"+ |
| "\u0010\u0000\u0000\u00fc\u0108\u0003\u000e\u0007\u0000\u00fd\u0103\u0005"+ |
| "\u001c\u0000\u0000\u00fe\u00ff\u0003\u000e\u0007\u0000\u00ff\u0100\u0003"+ |
| "\u00c4b\u0000\u0100\u0102\u0001\u0000\u0000\u0000\u0101\u00fe\u0001\u0000"+ |
| "\u0000\u0000\u0102\u0105\u0001\u0000\u0000\u0000\u0103\u0101\u0001\u0000"+ |
| "\u0000\u0000\u0103\u0104\u0001\u0000\u0000\u0000\u0104\u0106\u0001\u0000"+ |
| "\u0000\u0000\u0105\u0103\u0001\u0000\u0000\u0000\u0106\u0108\u0005\u001d"+ |
| "\u0000\u0000\u0107\u00fc\u0001\u0000\u0000\u0000\u0107\u00fd\u0001\u0000"+ |
| "\u0000\u0000\u0108\r\u0001\u0000\u0000\u0000\u0109\u010f\u0003\u0010\b"+ |
| "\u0000\u010a\u010c\u0003j5\u0000\u010b\u010a\u0001\u0000\u0000\u0000\u010b"+ |
| "\u010c\u0001\u0000\u0000\u0000\u010c\u010d\u0001\u0000\u0000\u0000\u010d"+ |
| "\u010e\u0005\"\u0000\u0000\u010e\u0110\u0003\u0012\t\u0000\u010f\u010b"+ |
| "\u0001\u0000\u0000\u0000\u010f\u0110\u0001\u0000\u0000\u0000\u0110\u000f"+ |
| "\u0001\u0000\u0000\u0000\u0111\u0116\u0005\u001b\u0000\u0000\u0112\u0113"+ |
| "\u0005#\u0000\u0000\u0113\u0115\u0005\u001b\u0000\u0000\u0114\u0112\u0001"+ |
| "\u0000\u0000\u0000\u0115\u0118\u0001\u0000\u0000\u0000\u0116\u0114\u0001"+ |
| "\u0000\u0000\u0000\u0116\u0117\u0001\u0000\u0000\u0000\u0117\u0011\u0001"+ |
| "\u0000\u0000\u0000\u0118\u0116\u0001\u0000\u0000\u0000\u0119\u011e\u0003"+ |
| "\u008cF\u0000\u011a\u011b\u0005#\u0000\u0000\u011b\u011d\u0003\u008cF"+ |
| "\u0000\u011c\u011a\u0001\u0000\u0000\u0000\u011d\u0120\u0001\u0000\u0000"+ |
| "\u0000\u011e\u011c\u0001\u0000\u0000\u0000\u011e\u011f\u0001\u0000\u0000"+ |
| "\u0000\u011f\u0013\u0001\u0000\u0000\u0000\u0120\u011e\u0001\u0000\u0000"+ |
| "\u0000\u0121\u012d\u0005\u0014\u0000\u0000\u0122\u012e\u0003\u0016\u000b"+ |
| "\u0000\u0123\u0129\u0005\u001c\u0000\u0000\u0124\u0125\u0003\u0016\u000b"+ |
| "\u0000\u0125\u0126\u0003\u00c4b\u0000\u0126\u0128\u0001\u0000\u0000\u0000"+ |
| "\u0127\u0124\u0001\u0000\u0000\u0000\u0128\u012b\u0001\u0000\u0000\u0000"+ |
| "\u0129\u0127\u0001\u0000\u0000\u0000\u0129\u012a\u0001\u0000\u0000\u0000"+ |
| "\u012a\u012c\u0001\u0000\u0000\u0000\u012b\u0129\u0001\u0000\u0000\u0000"+ |
| "\u012c\u012e\u0005\u001d\u0000\u0000\u012d\u0122\u0001\u0000\u0000\u0000"+ |
| "\u012d\u0123\u0001\u0000\u0000\u0000\u012e\u0015\u0001\u0000\u0000\u0000"+ |
| "\u012f\u0131\u0005\u001b\u0000\u0000\u0130\u0132\u0005\"\u0000\u0000\u0131"+ |
| "\u0130\u0001\u0000\u0000\u0000\u0131\u0132\u0001\u0000\u0000\u0000\u0132"+ |
| "\u0133\u0001\u0000\u0000\u0000\u0133\u0134\u0003j5\u0000\u0134\u0017\u0001"+ |
| "\u0000\u0000\u0000\u0135\u0136\u0005\u0003\u0000\u0000\u0136\u0137\u0005"+ |
| "\u001b\u0000\u0000\u0137\u0139\u0003\u0084B\u0000\u0138\u013a\u0003\""+ |
| "\u0011\u0000\u0139\u0138\u0001\u0000\u0000\u0000\u0139\u013a\u0001\u0000"+ |
| "\u0000\u0000\u013a\u0019\u0001\u0000\u0000\u0000\u013b\u013c\u0005\u0003"+ |
| "\u0000\u0000\u013c\u013d\u0003\u001c\u000e\u0000\u013d\u013e\u0005\u001b"+ |
| "\u0000\u0000\u013e\u0140\u0003\u0084B\u0000\u013f\u0141\u0003\"\u0011"+ |
| "\u0000\u0140\u013f\u0001\u0000\u0000\u0000\u0140\u0141\u0001\u0000\u0000"+ |
| "\u0000\u0141\u001b\u0001\u0000\u0000\u0000\u0142\u0143\u0003\u0088D\u0000"+ |
| "\u0143\u001d\u0001\u0000\u0000\u0000\u0144\u0150\u0005\u0019\u0000\u0000"+ |
| "\u0145\u0151\u0003 \u0010\u0000\u0146\u014c\u0005\u001c\u0000\u0000\u0147"+ |
| "\u0148\u0003 \u0010\u0000\u0148\u0149\u0003\u00c4b\u0000\u0149\u014b\u0001"+ |
| "\u0000\u0000\u0000\u014a\u0147\u0001\u0000\u0000\u0000\u014b\u014e\u0001"+ |
| "\u0000\u0000\u0000\u014c\u014a\u0001\u0000\u0000\u0000\u014c\u014d\u0001"+ |
| "\u0000\u0000\u0000\u014d\u014f\u0001\u0000\u0000\u0000\u014e\u014c\u0001"+ |
| "\u0000\u0000\u0000\u014f\u0151\u0005\u001d\u0000\u0000\u0150\u0145\u0001"+ |
| "\u0000\u0000\u0000\u0150\u0146\u0001\u0000\u0000\u0000\u0151\u001f\u0001"+ |
| "\u0000\u0000\u0000\u0152\u015a\u0003\u0010\b\u0000\u0153\u0156\u0003j"+ |
| "5\u0000\u0154\u0155\u0005\"\u0000\u0000\u0155\u0157\u0003\u0012\t\u0000"+ |
| "\u0156\u0154\u0001\u0000\u0000\u0000\u0156\u0157\u0001\u0000\u0000\u0000"+ |
| "\u0157\u015b\u0001\u0000\u0000\u0000\u0158\u0159\u0005\"\u0000\u0000\u0159"+ |
| "\u015b\u0003\u0012\t\u0000\u015a\u0153\u0001\u0000\u0000\u0000\u015a\u0158"+ |
| "\u0001\u0000\u0000\u0000\u015b!\u0001\u0000\u0000\u0000\u015c\u015e\u0005"+ |
| "\u001e\u0000\u0000\u015d\u015f\u0003$\u0012\u0000\u015e\u015d\u0001\u0000"+ |
| "\u0000\u0000\u015e\u015f\u0001\u0000\u0000\u0000\u015f\u0160\u0001\u0000"+ |
| "\u0000\u0000\u0160\u0161\u0005\u001f\u0000\u0000\u0161#\u0001\u0000\u0000"+ |
| "\u0000\u0162\u0164\u0005$\u0000\u0000\u0163\u0162\u0001\u0000\u0000\u0000"+ |
| "\u0163\u0164\u0001\u0000\u0000\u0000\u0164\u016a\u0001\u0000\u0000\u0000"+ |
| "\u0165\u0167\u0005W\u0000\u0000\u0166\u0165\u0001\u0000\u0000\u0000\u0166"+ |
| "\u0167\u0001\u0000\u0000\u0000\u0167\u016a\u0001\u0000\u0000\u0000\u0168"+ |
| "\u016a\u0004\u0012\u0000\u0000\u0169\u0163\u0001\u0000\u0000\u0000\u0169"+ |
| "\u0166\u0001\u0000\u0000\u0000\u0169\u0168\u0001\u0000\u0000\u0000\u016a"+ |
| "\u016b\u0001\u0000\u0000\u0000\u016b\u016c\u0003&\u0013\u0000\u016c\u016d"+ |
| "\u0003\u00c4b\u0000\u016d\u016f\u0001\u0000\u0000\u0000\u016e\u0169\u0001"+ |
| "\u0000\u0000\u0000\u016f\u0170\u0001\u0000\u0000\u0000\u0170\u016e\u0001"+ |
| "\u0000\u0000\u0000\u0170\u0171\u0001\u0000\u0000\u0000\u0171%\u0001\u0000"+ |
| "\u0000\u0000\u0172\u0182\u0003\n\u0005\u0000\u0173\u0182\u00038\u001c"+ |
| "\u0000\u0174\u0182\u0003(\u0014\u0000\u0175\u0182\u0003h4\u0000\u0176"+ |
| "\u0182\u0003:\u001d\u0000\u0177\u0182\u0003<\u001e\u0000\u0178\u0182\u0003"+ |
| ">\u001f\u0000\u0179\u0182\u0003@ \u0000\u017a\u0182\u0003B!\u0000\u017b"+ |
| "\u0182\u0003\"\u0011\u0000\u017c\u0182\u0003F#\u0000\u017d\u0182\u0003"+ |
| "H$\u0000\u017e\u0182\u0003Z-\u0000\u017f\u0182\u0003b1\u0000\u0180\u0182"+ |
| "\u0003D\"\u0000\u0181\u0172\u0001\u0000\u0000\u0000\u0181\u0173\u0001"+ |
| "\u0000\u0000\u0000\u0181\u0174\u0001\u0000\u0000\u0000\u0181\u0175\u0001"+ |
| "\u0000\u0000\u0000\u0181\u0176\u0001\u0000\u0000\u0000\u0181\u0177\u0001"+ |
| "\u0000\u0000\u0000\u0181\u0178\u0001\u0000\u0000\u0000\u0181\u0179\u0001"+ |
| "\u0000\u0000\u0000\u0181\u017a\u0001\u0000\u0000\u0000\u0181\u017b\u0001"+ |
| "\u0000\u0000\u0000\u0181\u017c\u0001\u0000\u0000\u0000\u0181\u017d\u0001"+ |
| "\u0000\u0000\u0000\u0181\u017e\u0001\u0000\u0000\u0000\u0181\u017f\u0001"+ |
| "\u0000\u0000\u0000\u0181\u0180\u0001\u0000\u0000\u0000\u0182\'\u0001\u0000"+ |
| "\u0000\u0000\u0183\u0189\u0003,\u0016\u0000\u0184\u0189\u0003.\u0017\u0000"+ |
| "\u0185\u0189\u00030\u0018\u0000\u0186\u0189\u0003*\u0015\u0000\u0187\u0189"+ |
| "\u00034\u001a\u0000\u0188\u0183\u0001\u0000\u0000\u0000\u0188\u0184\u0001"+ |
| "\u0000\u0000\u0000\u0188\u0185\u0001\u0000\u0000\u0000\u0188\u0186\u0001"+ |
| "\u0000\u0000\u0000\u0188\u0187\u0001\u0000\u0000\u0000\u0189)\u0001\u0000"+ |
| "\u0000\u0000\u018a\u018b\u0003\u008cF\u0000\u018b+\u0001\u0000\u0000\u0000"+ |
| "\u018c\u018d\u0003\u008cF\u0000\u018d\u018e\u0005?\u0000\u0000\u018e\u018f"+ |
| "\u0003\u008cF\u0000\u018f-\u0001\u0000\u0000\u0000\u0190\u0191\u0003\u008c"+ |
| "F\u0000\u0191\u0192\u0007\u0001\u0000\u0000\u0192/\u0001\u0000\u0000\u0000"+ |
| "\u0193\u0194\u0003\u0012\t\u0000\u0194\u0195\u00032\u0019\u0000\u0195"+ |
| "\u0196\u0003\u0012\t\u0000\u01961\u0001\u0000\u0000\u0000\u0197\u0199"+ |
| "\u0007\u0002\u0000\u0000\u0198\u0197\u0001\u0000\u0000\u0000\u0198\u0199"+ |
| "\u0001\u0000\u0000\u0000\u0199\u019a\u0001\u0000\u0000\u0000\u019a\u019b"+ |
| "\u0005\"\u0000\u0000\u019b3\u0001\u0000\u0000\u0000\u019c\u019d\u0003"+ |
| "\u0010\b\u0000\u019d\u019e\u0005)\u0000\u0000\u019e\u019f\u0003\u0012"+ |
| "\t\u0000\u019f5\u0001\u0000\u0000\u0000\u01a0\u01a1\u0007\u0003\u0000"+ |
| "\u0000\u01a17\u0001\u0000\u0000\u0000\u01a2\u01a3\u0005\u001b\u0000\u0000"+ |
| "\u01a3\u01a5\u0005%\u0000\u0000\u01a4\u01a6\u0003&\u0013\u0000\u01a5\u01a4"+ |
| "\u0001\u0000\u0000\u0000\u01a5\u01a6\u0001\u0000\u0000\u0000\u01a69\u0001"+ |
| "\u0000\u0000\u0000\u01a7\u01a9\u0005\u0018\u0000\u0000\u01a8\u01aa\u0003"+ |
| "\u0012\t\u0000\u01a9\u01a8\u0001\u0000\u0000\u0000\u01a9\u01aa\u0001\u0000"+ |
| "\u0000\u0000\u01aa;\u0001\u0000\u0000\u0000\u01ab\u01ad\u0005\u0001\u0000"+ |
| "\u0000\u01ac\u01ae\u0005\u001b\u0000\u0000\u01ad\u01ac\u0001\u0000\u0000"+ |
| "\u0000\u01ad\u01ae\u0001\u0000\u0000\u0000\u01ae=\u0001\u0000\u0000\u0000"+ |
| "\u01af\u01b1\u0005\u0015\u0000\u0000\u01b0\u01b2\u0005\u001b\u0000\u0000"+ |
| "\u01b1\u01b0\u0001\u0000\u0000\u0000\u01b1\u01b2\u0001\u0000\u0000\u0000"+ |
| "\u01b2?\u0001\u0000\u0000\u0000\u01b3\u01b4\u0005\r\u0000\u0000\u01b4"+ |
| "\u01b5\u0005\u001b\u0000\u0000\u01b5A\u0001\u0000\u0000\u0000\u01b6\u01b7"+ |
| "\u0005\u0011\u0000\u0000\u01b7C\u0001\u0000\u0000\u0000\u01b8\u01b9\u0005"+ |
| "\u0007\u0000\u0000\u01b9\u01ba\u0003\u008cF\u0000\u01baE\u0001\u0000\u0000"+ |
| "\u0000\u01bb\u01c4\u0005\u0012\u0000\u0000\u01bc\u01c5\u0003\u008cF\u0000"+ |
| "\u01bd\u01be\u0003\u00c4b\u0000\u01be\u01bf\u0003\u008cF\u0000\u01bf\u01c5"+ |
| "\u0001\u0000\u0000\u0000\u01c0\u01c1\u0003(\u0014\u0000\u01c1\u01c2\u0003"+ |
| "\u00c4b\u0000\u01c2\u01c3\u0003\u008cF\u0000\u01c3\u01c5\u0001\u0000\u0000"+ |
| "\u0000\u01c4\u01bc\u0001\u0000\u0000\u0000\u01c4\u01bd\u0001\u0000\u0000"+ |
| "\u0000\u01c4\u01c0\u0001\u0000\u0000\u0000\u01c5\u01c6\u0001\u0000\u0000"+ |
| "\u0000\u01c6\u01cc\u0003\"\u0011\u0000\u01c7\u01ca\u0005\f\u0000\u0000"+ |
| "\u01c8\u01cb\u0003F#\u0000\u01c9\u01cb\u0003\"\u0011\u0000\u01ca\u01c8"+ |
| "\u0001\u0000\u0000\u0000\u01ca\u01c9\u0001\u0000\u0000\u0000\u01cb\u01cd"+ |
| "\u0001\u0000\u0000\u0000\u01cc\u01c7\u0001\u0000\u0000\u0000\u01cc\u01cd"+ |
| "\u0001\u0000\u0000\u0000\u01cdG\u0001\u0000\u0000\u0000\u01ce\u01d1\u0003"+ |
| "J%\u0000\u01cf\u01d1\u0003P(\u0000\u01d0\u01ce\u0001\u0000\u0000\u0000"+ |
| "\u01d0\u01cf\u0001\u0000\u0000\u0000\u01d1I\u0001\u0000\u0000\u0000\u01d2"+ |
| "\u01dd\u0005\u000f\u0000\u0000\u01d3\u01d5\u0003\u008cF\u0000\u01d4\u01d3"+ |
| "\u0001\u0000\u0000\u0000\u01d4\u01d5\u0001\u0000\u0000\u0000\u01d5\u01de"+ |
| "\u0001\u0000\u0000\u0000\u01d6\u01d8\u0003(\u0014\u0000\u01d7\u01d6\u0001"+ |
| "\u0000\u0000\u0000\u01d7\u01d8\u0001\u0000\u0000\u0000\u01d8\u01d9\u0001"+ |
| "\u0000\u0000\u0000\u01d9\u01db\u0003\u00c4b\u0000\u01da\u01dc\u0003\u008c"+ |
| "F\u0000\u01db\u01da\u0001\u0000\u0000\u0000\u01db\u01dc\u0001\u0000\u0000"+ |
| "\u0000\u01dc\u01de\u0001\u0000\u0000\u0000\u01dd\u01d4\u0001\u0000\u0000"+ |
| "\u0000\u01dd\u01d7\u0001\u0000\u0000\u0000\u01de\u01df\u0001\u0000\u0000"+ |
| "\u0000\u01df\u01e3\u0005\u001e\u0000\u0000\u01e0\u01e2\u0003L&\u0000\u01e1"+ |
| "\u01e0\u0001\u0000\u0000\u0000\u01e2\u01e5\u0001\u0000\u0000\u0000\u01e3"+ |
| "\u01e1\u0001\u0000\u0000\u0000\u01e3\u01e4\u0001\u0000\u0000\u0000\u01e4"+ |
| "\u01e6\u0001\u0000\u0000\u0000\u01e5\u01e3\u0001\u0000\u0000\u0000\u01e6"+ |
| "\u01e7\u0005\u001f\u0000\u0000\u01e7K\u0001\u0000\u0000\u0000\u01e8\u01e9"+ |
| "\u0003N\'\u0000\u01e9\u01eb\u0005%\u0000\u0000\u01ea\u01ec\u0003$\u0012"+ |
| "\u0000\u01eb\u01ea\u0001\u0000\u0000\u0000\u01eb\u01ec\u0001\u0000\u0000"+ |
| "\u0000\u01ecM\u0001\u0000\u0000\u0000\u01ed\u01ee\u0005\u0006\u0000\u0000"+ |
| "\u01ee\u01f1\u0003\u0012\t\u0000\u01ef\u01f1\u0005\u0002\u0000\u0000\u01f0"+ |
| "\u01ed\u0001\u0000\u0000\u0000\u01f0\u01ef\u0001\u0000\u0000\u0000\u01f1"+ |
| "O\u0001\u0000\u0000\u0000\u01f2\u01fb\u0005\u000f\u0000\u0000\u01f3\u01fc"+ |
| "\u0003R)\u0000\u01f4\u01f5\u0003\u00c4b\u0000\u01f5\u01f6\u0003R)\u0000"+ |
| "\u01f6\u01fc\u0001\u0000\u0000\u0000\u01f7\u01f8\u0003(\u0014\u0000\u01f8"+ |
| "\u01f9\u0003\u00c4b\u0000\u01f9\u01fa\u0003R)\u0000\u01fa\u01fc\u0001"+ |
| "\u0000\u0000\u0000\u01fb\u01f3\u0001\u0000\u0000\u0000\u01fb\u01f4\u0001"+ |
| "\u0000\u0000\u0000\u01fb\u01f7\u0001\u0000\u0000\u0000\u01fc\u01fd\u0001"+ |
| "\u0000\u0000\u0000\u01fd\u0201\u0005\u001e\u0000\u0000\u01fe\u0200\u0003"+ |
| "T*\u0000\u01ff\u01fe\u0001\u0000\u0000\u0000\u0200\u0203\u0001\u0000\u0000"+ |
| "\u0000\u0201\u01ff\u0001\u0000\u0000\u0000\u0201\u0202\u0001\u0000\u0000"+ |
| "\u0000\u0202\u0204\u0001\u0000\u0000\u0000\u0203\u0201\u0001\u0000\u0000"+ |
| "\u0000\u0204\u0205\u0005\u001f\u0000\u0000\u0205Q\u0001\u0000\u0000\u0000"+ |
| "\u0206\u0207\u0005\u001b\u0000\u0000\u0207\u0209\u0005)\u0000\u0000\u0208"+ |
| "\u0206\u0001\u0000\u0000\u0000\u0208\u0209\u0001\u0000\u0000\u0000\u0209"+ |
| "\u020a\u0001\u0000\u0000\u0000\u020a\u020b\u0003\u008eG\u0000\u020b\u020c"+ |
| "\u0005&\u0000\u0000\u020c\u020d\u0005\u001c\u0000\u0000\u020d\u020e\u0005"+ |
| "\u0014\u0000\u0000\u020e\u020f\u0005\u001d\u0000\u0000\u020fS\u0001\u0000"+ |
| "\u0000\u0000\u0210\u0211\u0003V+\u0000\u0211\u0213\u0005%\u0000\u0000"+ |
| "\u0212\u0214\u0003$\u0012\u0000\u0213\u0212\u0001\u0000\u0000\u0000\u0213"+ |
| "\u0214\u0001\u0000\u0000\u0000\u0214U\u0001\u0000\u0000\u0000\u0215\u0216"+ |
| "\u0005\u0006\u0000\u0000\u0216\u0219\u0003X,\u0000\u0217\u0219\u0005\u0002"+ |
| "\u0000\u0000\u0218\u0215\u0001\u0000\u0000\u0000\u0218\u0217\u0001\u0000"+ |
| "\u0000\u0000\u0219W\u0001\u0000\u0000\u0000\u021a\u021d\u0003j5\u0000"+ |
| "\u021b\u021d\u0005\u001a\u0000\u0000\u021c\u021a\u0001\u0000\u0000\u0000"+ |
| "\u021c\u021b\u0001\u0000\u0000\u0000\u021d\u0225\u0001\u0000\u0000\u0000"+ |
| "\u021e\u0221\u0005#\u0000\u0000\u021f\u0222\u0003j5\u0000\u0220\u0222"+ |
| "\u0005\u001a\u0000\u0000\u0221\u021f\u0001\u0000\u0000\u0000\u0221\u0220"+ |
| "\u0001\u0000\u0000\u0000\u0222\u0224\u0001\u0000\u0000\u0000\u0223\u021e"+ |
| "\u0001\u0000\u0000\u0000\u0224\u0227\u0001\u0000\u0000\u0000\u0225\u0223"+ |
| "\u0001\u0000\u0000\u0000\u0225\u0226\u0001\u0000\u0000\u0000\u0226Y\u0001"+ |
| "\u0000\u0000\u0000\u0227\u0225\u0001\u0000\u0000\u0000\u0228\u0229\u0005"+ |
| "\u0005\u0000\u0000\u0229\u022d\u0005\u001e\u0000\u0000\u022a\u022c\u0003"+ |
| "\\.\u0000\u022b\u022a\u0001\u0000\u0000\u0000\u022c\u022f\u0001\u0000"+ |
| "\u0000\u0000\u022d\u022b\u0001\u0000\u0000\u0000\u022d\u022e\u0001\u0000"+ |
| "\u0000\u0000\u022e\u0230\u0001\u0000\u0000\u0000\u022f\u022d\u0001\u0000"+ |
| "\u0000\u0000\u0230\u0231\u0005\u001f\u0000\u0000\u0231[\u0001\u0000\u0000"+ |
| "\u0000\u0232\u0233\u0003^/\u0000\u0233\u0235\u0005%\u0000\u0000\u0234"+ |
| "\u0236\u0003$\u0012\u0000\u0235\u0234\u0001\u0000\u0000\u0000\u0235\u0236"+ |
| "\u0001\u0000\u0000\u0000\u0236]\u0001\u0000\u0000\u0000\u0237\u023a\u0005"+ |
| "\u0006\u0000\u0000\u0238\u023b\u0003,\u0016\u0000\u0239\u023b\u0003`0"+ |
| "\u0000\u023a\u0238\u0001\u0000\u0000\u0000\u023a\u0239\u0001\u0000\u0000"+ |
| "\u0000\u023b\u023e\u0001\u0000\u0000\u0000\u023c\u023e\u0005\u0002\u0000"+ |
| "\u0000\u023d\u0237\u0001\u0000\u0000\u0000\u023d\u023c\u0001\u0000\u0000"+ |
| "\u0000\u023e_\u0001\u0000\u0000\u0000\u023f\u0240\u0003\u0012\t\u0000"+ |
| "\u0240\u0241\u0005\"\u0000\u0000\u0241\u0246\u0001\u0000\u0000\u0000\u0242"+ |
| "\u0243\u0003\u0010\b\u0000\u0243\u0244\u0005)\u0000\u0000\u0244\u0246"+ |
| "\u0001\u0000\u0000\u0000\u0245\u023f\u0001\u0000\u0000\u0000\u0245\u0242"+ |
| "\u0001\u0000\u0000\u0000\u0245\u0246\u0001\u0000\u0000\u0000\u0246\u0247"+ |
| "\u0001\u0000\u0000\u0000\u0247\u0248\u0003\u008cF\u0000\u0248a\u0001\u0000"+ |
| "\u0000\u0000\u0249\u0251\u0005\u0016\u0000\u0000\u024a\u024c\u0003\u008c"+ |
| "F\u0000\u024b\u024a\u0001\u0000\u0000\u0000\u024b\u024c\u0001\u0000\u0000"+ |
| "\u0000\u024c\u0252\u0001\u0000\u0000\u0000\u024d\u0252\u0003d2\u0000\u024e"+ |
| "\u0250\u0003f3\u0000\u024f\u024e\u0001\u0000\u0000\u0000\u024f\u0250\u0001"+ |
| "\u0000\u0000\u0000\u0250\u0252\u0001\u0000\u0000\u0000\u0251\u024b\u0001"+ |
| "\u0000\u0000\u0000\u0251\u024d\u0001\u0000\u0000\u0000\u0251\u024f\u0001"+ |
| "\u0000\u0000\u0000\u0252\u0253\u0001\u0000\u0000\u0000\u0253\u0254\u0003"+ |
| "\"\u0011\u0000\u0254c\u0001\u0000\u0000\u0000\u0255\u0257\u0003(\u0014"+ |
| "\u0000\u0256\u0255\u0001\u0000\u0000\u0000\u0256\u0257\u0001\u0000\u0000"+ |
| "\u0000\u0257\u0258\u0001\u0000\u0000\u0000\u0258\u025a\u0003\u00c4b\u0000"+ |
| "\u0259\u025b\u0003\u008cF\u0000\u025a\u0259\u0001\u0000\u0000\u0000\u025a"+ |
| "\u025b\u0001\u0000\u0000\u0000\u025b\u025c\u0001\u0000\u0000\u0000\u025c"+ |
| "\u025e\u0003\u00c4b\u0000\u025d\u025f\u0003(\u0014\u0000\u025e\u025d\u0001"+ |
| "\u0000\u0000\u0000\u025e\u025f\u0001\u0000\u0000\u0000\u025fe\u0001\u0000"+ |
| "\u0000\u0000\u0260\u0261\u0003\u0012\t\u0000\u0261\u0262\u0005\"\u0000"+ |
| "\u0000\u0262\u0267\u0001\u0000\u0000\u0000\u0263\u0264\u0003\u0010\b\u0000"+ |
| "\u0264\u0265\u0005)\u0000\u0000\u0265\u0267\u0001\u0000\u0000\u0000\u0266"+ |
| "\u0260\u0001\u0000\u0000\u0000\u0266\u0263\u0001\u0000\u0000\u0000\u0266"+ |
| "\u0267\u0001\u0000\u0000\u0000\u0267\u0268\u0001\u0000\u0000\u0000\u0268"+ |
| "\u0269\u0005\u0013\u0000\u0000\u0269\u026a\u0003\u008cF\u0000\u026ag\u0001"+ |
| "\u0000\u0000\u0000\u026b\u026c\u0005\b\u0000\u0000\u026c\u026d\u0003\u008c"+ |
| "F\u0000\u026di\u0001\u0000\u0000\u0000\u026e\u0275\u0003l6\u0000\u026f"+ |
| "\u0275\u0003n7\u0000\u0270\u0271\u0005\u001c\u0000\u0000\u0271\u0272\u0003"+ |
| "j5\u0000\u0272\u0273\u0005\u001d\u0000\u0000\u0273\u0275\u0001\u0000\u0000"+ |
| "\u0000\u0274\u026e\u0001\u0000\u0000\u0000\u0274\u026f\u0001\u0000\u0000"+ |
| "\u0000\u0274\u0270\u0001\u0000\u0000\u0000\u0275k\u0001\u0000\u0000\u0000"+ |
| "\u0276\u0279\u0003\u009eO\u0000\u0277\u0279\u0005\u001b\u0000\u0000\u0278"+ |
| "\u0276\u0001\u0000\u0000\u0000\u0278\u0277\u0001\u0000\u0000\u0000\u0279"+ |
| "m\u0001\u0000\u0000\u0000\u027a\u0283\u0003p8\u0000\u027b\u0283\u0003"+ |
| "\u00aeW\u0000\u027c\u0283\u0003v;\u0000\u027d\u0283\u0003\u0082A\u0000"+ |
| "\u027e\u0283\u0003x<\u0000\u027f\u0283\u0003z=\u0000\u0280\u0283\u0003"+ |
| "|>\u0000\u0281\u0283\u0003~?\u0000\u0282\u027a\u0001\u0000\u0000\u0000"+ |
| "\u0282\u027b\u0001\u0000\u0000\u0000\u0282\u027c\u0001\u0000\u0000\u0000"+ |
| "\u0282\u027d\u0001\u0000\u0000\u0000\u0282\u027e\u0001\u0000\u0000\u0000"+ |
| "\u0282\u027f\u0001\u0000\u0000\u0000\u0282\u0280\u0001\u0000\u0000\u0000"+ |
| "\u0282\u0281\u0001\u0000\u0000\u0000\u0283o\u0001\u0000\u0000\u0000\u0284"+ |
| "\u0285\u0005 \u0000\u0000\u0285\u0286\u0003r9\u0000\u0286\u0287\u0005"+ |
| "!\u0000\u0000\u0287\u0288\u0003t:\u0000\u0288q\u0001\u0000\u0000\u0000"+ |
| "\u0289\u028a\u0003\u008cF\u0000\u028as\u0001\u0000\u0000\u0000\u028b\u028c"+ |
| "\u0003j5\u0000\u028cu\u0001\u0000\u0000\u0000\u028d\u028e\u0005=\u0000"+ |
| "\u0000\u028e\u028f\u0003j5\u0000\u028fw\u0001\u0000\u0000\u0000\u0290"+ |
| "\u0291\u0005\u0004\u0000\u0000\u0291\u029a\u0005\u001e\u0000\u0000\u0292"+ |
| "\u0295\u0003\u0080@\u0000\u0293\u0295\u0003l6\u0000\u0294\u0292\u0001"+ |
| "\u0000\u0000\u0000\u0294\u0293\u0001\u0000\u0000\u0000\u0295\u0296\u0001"+ |
| "\u0000\u0000\u0000\u0296\u0297\u0003\u00c4b\u0000\u0297\u0299\u0001\u0000"+ |
| "\u0000\u0000\u0298\u0294\u0001\u0000\u0000\u0000\u0299\u029c\u0001\u0000"+ |
| "\u0000\u0000\u029a\u0298\u0001\u0000\u0000\u0000\u029a\u029b\u0001\u0000"+ |
| "\u0000\u0000\u029b\u029d\u0001\u0000\u0000\u0000\u029c\u029a\u0001\u0000"+ |
| "\u0000\u0000\u029d\u029e\u0005\u001f\u0000\u0000\u029ey\u0001\u0000\u0000"+ |
| "\u0000\u029f\u02a0\u0005 \u0000\u0000\u02a0\u02a1\u0005!\u0000\u0000\u02a1"+ |
| "\u02a2\u0003t:\u0000\u02a2{\u0001\u0000\u0000\u0000\u02a3\u02a4\u0005"+ |
| "\t\u0000\u0000\u02a4\u02a5\u0005 \u0000\u0000\u02a5\u02a6\u0003j5\u0000"+ |
| "\u02a6\u02a7\u0005!\u0000\u0000\u02a7\u02a8\u0003t:\u0000\u02a8}\u0001"+ |
| "\u0000\u0000\u0000\u02a9\u02af\u0005\u000b\u0000\u0000\u02aa\u02ab\u0005"+ |
| "\u000b\u0000\u0000\u02ab\u02af\u0005?\u0000\u0000\u02ac\u02ad\u0005?\u0000"+ |
| "\u0000\u02ad\u02af\u0005\u000b\u0000\u0000\u02ae\u02a9\u0001\u0000\u0000"+ |
| "\u0000\u02ae\u02aa\u0001\u0000\u0000\u0000\u02ae\u02ac\u0001\u0000\u0000"+ |
| "\u0000\u02af\u02b0\u0001\u0000\u0000\u0000\u02b0\u02b1\u0003t:\u0000\u02b1"+ |
| "\u007f\u0001\u0000\u0000\u0000\u02b2\u02b3\u0005\u001b\u0000\u0000\u02b3"+ |
| "\u02b4\u0003\u0088D\u0000\u02b4\u02b5\u0003\u0086C\u0000\u02b5\u02b9\u0001"+ |
| "\u0000\u0000\u0000\u02b6\u02b7\u0005\u001b\u0000\u0000\u02b7\u02b9\u0003"+ |
| "\u0088D\u0000\u02b8\u02b2\u0001\u0000\u0000\u0000\u02b8\u02b6\u0001\u0000"+ |
| "\u0000\u0000\u02b9\u0081\u0001\u0000\u0000\u0000\u02ba\u02bb\u0005\u0003"+ |
| "\u0000\u0000\u02bb\u02bc\u0003\u0084B\u0000\u02bc\u0083\u0001\u0000\u0000"+ |
| "\u0000\u02bd\u02be\u0003\u0088D\u0000\u02be\u02bf\u0003\u0086C\u0000\u02bf"+ |
| "\u02c2\u0001\u0000\u0000\u0000\u02c0\u02c2\u0003\u0088D\u0000\u02c1\u02bd"+ |
| "\u0001\u0000\u0000\u0000\u02c1\u02c0\u0001\u0000\u0000\u0000\u02c2\u0085"+ |
| "\u0001\u0000\u0000\u0000\u02c3\u02c6\u0003\u0088D\u0000\u02c4\u02c6\u0003"+ |
| "j5\u0000\u02c5\u02c3\u0001\u0000\u0000\u0000\u02c5\u02c4\u0001\u0000\u0000"+ |
| "\u0000\u02c6\u0087\u0001\u0000\u0000\u0000\u02c7\u02d3\u0005\u001c\u0000"+ |
| "\u0000\u02c8\u02cd\u0003\u008aE\u0000\u02c9\u02ca\u0005#\u0000\u0000\u02ca"+ |
| "\u02cc\u0003\u008aE\u0000\u02cb\u02c9\u0001\u0000\u0000\u0000\u02cc\u02cf"+ |
| "\u0001\u0000\u0000\u0000\u02cd\u02cb\u0001\u0000\u0000\u0000\u02cd\u02ce"+ |
| "\u0001\u0000\u0000\u0000\u02ce\u02d1\u0001\u0000\u0000\u0000\u02cf\u02cd"+ |
| "\u0001\u0000\u0000\u0000\u02d0\u02d2\u0005#\u0000\u0000\u02d1\u02d0\u0001"+ |
| "\u0000\u0000\u0000\u02d1\u02d2\u0001\u0000\u0000\u0000\u02d2\u02d4\u0001"+ |
| "\u0000\u0000\u0000\u02d3\u02c8\u0001\u0000\u0000\u0000\u02d3\u02d4\u0001"+ |
| "\u0000\u0000\u0000\u02d4\u02d5\u0001\u0000\u0000\u0000\u02d5\u02d6\u0005"+ |
| "\u001d\u0000\u0000\u02d6\u0089\u0001\u0000\u0000\u0000\u02d7\u02d9\u0003"+ |
| "\u0010\b\u0000\u02d8\u02d7\u0001\u0000\u0000\u0000\u02d8\u02d9\u0001\u0000"+ |
| "\u0000\u0000\u02d9\u02db\u0001\u0000\u0000\u0000\u02da\u02dc\u0005*\u0000"+ |
| "\u0000\u02db\u02da\u0001\u0000\u0000\u0000\u02db\u02dc\u0001\u0000\u0000"+ |
| "\u0000\u02dc\u02dd\u0001\u0000\u0000\u0000\u02dd\u02de\u0003j5\u0000\u02de"+ |
| "\u008b\u0001\u0000\u0000\u0000\u02df\u02e0\u0006F\uffff\uffff\u0000\u02e0"+ |
| "\u02e4\u0003\u008eG\u0000\u02e1\u02e2\u0007\u0004\u0000\u0000\u02e2\u02e4"+ |
| "\u0003\u008cF\u0006\u02e3\u02df\u0001\u0000\u0000\u0000\u02e3\u02e1\u0001"+ |
| "\u0000\u0000\u0000\u02e4\u02f6\u0001\u0000\u0000\u0000\u02e5\u02e6\n\u0005"+ |
| "\u0000\u0000\u02e6\u02e7\u0007\u0005\u0000\u0000\u02e7\u02f5\u0003\u008c"+ |
| "F\u0006\u02e8\u02e9\n\u0004\u0000\u0000\u02e9\u02ea\u0007\u0006\u0000"+ |
| "\u0000\u02ea\u02f5\u0003\u008cF\u0005\u02eb\u02ec\n\u0003\u0000\u0000"+ |
| "\u02ec\u02ed\u0007\u0007\u0000\u0000\u02ed\u02f5\u0003\u008cF\u0004\u02ee"+ |
| "\u02ef\n\u0002\u0000\u0000\u02ef\u02f0\u0005,\u0000\u0000\u02f0\u02f5"+ |
| "\u0003\u008cF\u0003\u02f1\u02f2\n\u0001\u0000\u0000\u02f2\u02f3\u0005"+ |
| "+\u0000\u0000\u02f3\u02f5\u0003\u008cF\u0002\u02f4\u02e5\u0001\u0000\u0000"+ |
| "\u0000\u02f4\u02e8\u0001\u0000\u0000\u0000\u02f4\u02eb\u0001\u0000\u0000"+ |
| "\u0000\u02f4\u02ee\u0001\u0000\u0000\u0000\u02f4\u02f1\u0001\u0000\u0000"+ |
| "\u0000\u02f5\u02f8\u0001\u0000\u0000\u0000\u02f6\u02f4\u0001\u0000\u0000"+ |
| "\u0000\u02f6\u02f7\u0001\u0000\u0000\u0000\u02f7\u008d\u0001\u0000\u0000"+ |
| "\u0000\u02f8\u02f6\u0001\u0000\u0000\u0000\u02f9\u02fa\u0006G\uffff\uffff"+ |
| "\u0000\u02fa\u02fe\u0003\u0094J\u0000\u02fb\u02fe\u0003\u0090H\u0000\u02fc"+ |
| "\u02fe\u0003\u00c0`\u0000\u02fd\u02f9\u0001\u0000\u0000\u0000\u02fd\u02fb"+ |
| "\u0001\u0000\u0000\u0000\u02fd\u02fc\u0001\u0000\u0000\u0000\u02fe\u030a"+ |
| "\u0001\u0000\u0000\u0000\u02ff\u0306\n\u0001\u0000\u0000\u0300\u0301\u0005"+ |
| "&\u0000\u0000\u0301\u0307\u0005\u001b\u0000\u0000\u0302\u0307\u0003\u00b8"+ |
| "\\\u0000\u0303\u0307\u0003\u00ba]\u0000\u0304\u0307\u0003\u00bc^\u0000"+ |
| "\u0305\u0307\u0003\u00be_\u0000\u0306\u0300\u0001\u0000\u0000\u0000\u0306"+ |
| "\u0302\u0001\u0000\u0000\u0000\u0306\u0303\u0001\u0000\u0000\u0000\u0306"+ |
| "\u0304\u0001\u0000\u0000\u0000\u0306\u0305\u0001\u0000\u0000\u0000\u0307"+ |
| "\u0309\u0001\u0000\u0000\u0000\u0308\u02ff\u0001\u0000\u0000\u0000\u0309"+ |
| "\u030c\u0001\u0000\u0000\u0000\u030a\u0308\u0001\u0000\u0000\u0000\u030a"+ |
| "\u030b\u0001\u0000\u0000\u0000\u030b\u008f\u0001\u0000\u0000\u0000\u030c"+ |
| "\u030a\u0001\u0000\u0000\u0000\u030d\u030e\u0003\u0092I\u0000\u030e\u030f"+ |
| "\u0005\u001c\u0000\u0000\u030f\u0311\u0003\u008cF\u0000\u0310\u0312\u0005"+ |
| "#\u0000\u0000\u0311\u0310\u0001\u0000\u0000\u0000\u0311\u0312\u0001\u0000"+ |
| "\u0000\u0000\u0312\u0313\u0001\u0000\u0000\u0000\u0313\u0314\u0005\u001d"+ |
| "\u0000\u0000\u0314\u0091\u0001\u0000\u0000\u0000\u0315\u031b\u0003n7\u0000"+ |
| "\u0316\u0317\u0005\u001c\u0000\u0000\u0317\u0318\u0003\u0092I\u0000\u0318"+ |
| "\u0319\u0005\u001d\u0000\u0000\u0319\u031b\u0001\u0000\u0000\u0000\u031a"+ |
| "\u0315\u0001\u0000\u0000\u0000\u031a\u0316\u0001\u0000\u0000\u0000\u031b"+ |
| "\u0093\u0001\u0000\u0000\u0000\u031c\u0323\u0003\u0096K\u0000\u031d\u0323"+ |
| "\u0003\u009cN\u0000\u031e\u031f\u0005\u001c\u0000\u0000\u031f\u0320\u0003"+ |
| "\u008cF\u0000\u0320\u0321\u0005\u001d\u0000\u0000\u0321\u0323\u0001\u0000"+ |
| "\u0000\u0000\u0322\u031c\u0001\u0000\u0000\u0000\u0322\u031d\u0001\u0000"+ |
| "\u0000\u0000\u0322\u031e\u0001\u0000\u0000\u0000\u0323\u0095\u0001\u0000"+ |
| "\u0000\u0000\u0324\u0328\u0003\u0098L\u0000\u0325\u0328\u0003\u00a0P\u0000"+ |
| "\u0326\u0328\u0003\u00b6[\u0000\u0327\u0324\u0001\u0000\u0000\u0000\u0327"+ |
| "\u0325\u0001\u0000\u0000\u0000\u0327\u0326\u0001\u0000\u0000\u0000\u0328"+ |
| "\u0097\u0001\u0000\u0000\u0000\u0329\u032e\u0005\u001a\u0000\u0000\u032a"+ |
| "\u032e\u0003\u009aM\u0000\u032b\u032e\u0003\u00b2Y\u0000\u032c\u032e\u0005"+ |
| "D\u0000\u0000\u032d\u0329\u0001\u0000\u0000\u0000\u032d\u032a\u0001\u0000"+ |
| "\u0000\u0000\u032d\u032b\u0001\u0000\u0000\u0000\u032d\u032c\u0001\u0000"+ |
| "\u0000\u0000\u032e\u0099\u0001\u0000\u0000\u0000\u032f\u0330\u0007\b\u0000"+ |
| "\u0000\u0330\u009b\u0001\u0000\u0000\u0000\u0331\u0332\u0005\u001b\u0000"+ |
| "\u0000\u0332\u009d\u0001\u0000\u0000\u0000\u0333\u0334\u0005\u001b\u0000"+ |
| "\u0000\u0334\u0335\u0005&\u0000\u0000\u0335\u0336\u0005\u001b\u0000\u0000"+ |
| "\u0336\u009f\u0001\u0000\u0000\u0000\u0337\u0338\u0003\u00a2Q\u0000\u0338"+ |
| "\u0339\u0003\u00a4R\u0000\u0339\u00a1\u0001\u0000\u0000\u0000\u033a\u0344"+ |
| "\u0003\u00aeW\u0000\u033b\u0344\u0003p8\u0000\u033c\u033d\u0005 \u0000"+ |
| "\u0000\u033d\u033e\u0005*\u0000\u0000\u033e\u033f\u0005!\u0000\u0000\u033f"+ |
| "\u0344\u0003t:\u0000\u0340\u0344\u0003z=\u0000\u0341\u0344\u0003|>\u0000"+ |
| "\u0342\u0344\u0003l6\u0000\u0343\u033a\u0001\u0000\u0000\u0000\u0343\u033b"+ |
| "\u0001\u0000\u0000\u0000\u0343\u033c\u0001\u0000\u0000\u0000\u0343\u0340"+ |
| "\u0001\u0000\u0000\u0000\u0343\u0341\u0001\u0000\u0000\u0000\u0343\u0342"+ |
| "\u0001\u0000\u0000\u0000\u0344\u00a3\u0001\u0000\u0000\u0000\u0345\u034a"+ |
| "\u0005\u001e\u0000\u0000\u0346\u0348\u0003\u00a6S\u0000\u0347\u0349\u0005"+ |
| "#\u0000\u0000\u0348\u0347\u0001\u0000\u0000\u0000\u0348\u0349\u0001\u0000"+ |
| "\u0000\u0000\u0349\u034b\u0001\u0000\u0000\u0000\u034a\u0346\u0001\u0000"+ |
| "\u0000\u0000\u034a\u034b\u0001\u0000\u0000\u0000\u034b\u034c\u0001\u0000"+ |
| "\u0000\u0000\u034c\u034d\u0005\u001f\u0000\u0000\u034d\u00a5\u0001\u0000"+ |
| "\u0000\u0000\u034e\u0353\u0003\u00a8T\u0000\u034f\u0350\u0005#\u0000\u0000"+ |
| "\u0350\u0352\u0003\u00a8T\u0000\u0351\u034f\u0001\u0000\u0000\u0000\u0352"+ |
| "\u0355\u0001\u0000\u0000\u0000\u0353\u0351\u0001\u0000\u0000\u0000\u0353"+ |
| "\u0354\u0001\u0000\u0000\u0000\u0354\u00a7\u0001\u0000\u0000\u0000\u0355"+ |
| "\u0353\u0001\u0000\u0000\u0000\u0356\u0357\u0003\u00aaU\u0000\u0357\u0358"+ |
| "\u0005%\u0000\u0000\u0358\u035a\u0001\u0000\u0000\u0000\u0359\u0356\u0001"+ |
| "\u0000\u0000\u0000\u0359\u035a\u0001\u0000\u0000\u0000\u035a\u035b\u0001"+ |
| "\u0000\u0000\u0000\u035b\u035c\u0003\u00acV\u0000\u035c\u00a9\u0001\u0000"+ |
| "\u0000\u0000\u035d\u0360\u0003\u008cF\u0000\u035e\u0360\u0003\u00a4R\u0000"+ |
| "\u035f\u035d\u0001\u0000\u0000\u0000\u035f\u035e\u0001\u0000\u0000\u0000"+ |
| "\u0360\u00ab\u0001\u0000\u0000\u0000\u0361\u0364\u0003\u008cF\u0000\u0362"+ |
| "\u0364\u0003\u00a4R\u0000\u0363\u0361\u0001\u0000\u0000\u0000\u0363\u0362"+ |
| "\u0001\u0000\u0000\u0000\u0364\u00ad\u0001\u0000\u0000\u0000\u0365\u0366"+ |
| "\u0005\n\u0000\u0000\u0366\u036c\u0005\u001e\u0000\u0000\u0367\u0368\u0003"+ |
| "\u00b0X\u0000\u0368\u0369\u0003\u00c4b\u0000\u0369\u036b\u0001\u0000\u0000"+ |
| "\u0000\u036a\u0367\u0001\u0000\u0000\u0000\u036b\u036e\u0001\u0000\u0000"+ |
| "\u0000\u036c\u036a\u0001\u0000\u0000\u0000\u036c\u036d\u0001\u0000\u0000"+ |
| "\u0000\u036d\u036f\u0001\u0000\u0000\u0000\u036e\u036c\u0001\u0000\u0000"+ |
| "\u0000\u036f\u0370\u0005\u001f\u0000\u0000\u0370\u00af\u0001\u0000\u0000"+ |
| "\u0000\u0371\u0372\u0003\u0010\b\u0000\u0372\u0373\u0003j5\u0000\u0373"+ |
| "\u0376\u0001\u0000\u0000\u0000\u0374\u0376\u0003\u00b4Z\u0000\u0375\u0371"+ |
| "\u0001\u0000\u0000\u0000\u0375\u0374\u0001\u0000\u0000\u0000\u0376\u0378"+ |
| "\u0001\u0000\u0000\u0000\u0377\u0379\u0003\u00b2Y\u0000\u0378\u0377\u0001"+ |
| "\u0000\u0000\u0000\u0378\u0379\u0001\u0000\u0000\u0000\u0379\u00b1\u0001"+ |
| "\u0000\u0000\u0000\u037a\u037b\u0007\t\u0000\u0000\u037b\u00b3\u0001\u0000"+ |
| "\u0000\u0000\u037c\u037e\u0005=\u0000\u0000\u037d\u037c\u0001\u0000\u0000"+ |
| "\u0000\u037d\u037e\u0001\u0000\u0000\u0000\u037e\u037f\u0001\u0000\u0000"+ |
| "\u0000\u037f\u0380\u0003l6\u0000\u0380\u00b5\u0001\u0000\u0000\u0000\u0381"+ |
| "\u0382\u0005\u0003\u0000\u0000\u0382\u0383\u0003\u0084B\u0000\u0383\u0384"+ |
| "\u0003\"\u0011\u0000\u0384\u00b7\u0001\u0000\u0000\u0000\u0385\u0386\u0005"+ |
| " \u0000\u0000\u0386\u0387\u0003\u008cF\u0000\u0387\u0388\u0005!\u0000"+ |
| "\u0000\u0388\u00b9\u0001\u0000\u0000\u0000\u0389\u0399\u0005 \u0000\u0000"+ |
| "\u038a\u038c\u0003\u008cF\u0000\u038b\u038a\u0001\u0000\u0000\u0000\u038b"+ |
| "\u038c\u0001\u0000\u0000\u0000\u038c\u038d\u0001\u0000\u0000\u0000\u038d"+ |
| "\u038f\u0005%\u0000\u0000\u038e\u0390\u0003\u008cF\u0000\u038f\u038e\u0001"+ |
| "\u0000\u0000\u0000\u038f\u0390\u0001\u0000\u0000\u0000\u0390\u039a\u0001"+ |
| "\u0000\u0000\u0000\u0391\u0393\u0003\u008cF\u0000\u0392\u0391\u0001\u0000"+ |
| "\u0000\u0000\u0392\u0393\u0001\u0000\u0000\u0000\u0393\u0394\u0001\u0000"+ |
| "\u0000\u0000\u0394\u0395\u0005%\u0000\u0000\u0395\u0396\u0003\u008cF\u0000"+ |
| "\u0396\u0397\u0005%\u0000\u0000\u0397\u0398\u0003\u008cF\u0000\u0398\u039a"+ |
| "\u0001\u0000\u0000\u0000\u0399\u038b\u0001\u0000\u0000\u0000\u0399\u0392"+ |
| "\u0001\u0000\u0000\u0000\u039a\u039b\u0001\u0000\u0000\u0000\u039b\u039c"+ |
| "\u0005!\u0000\u0000\u039c\u00bb\u0001\u0000\u0000\u0000\u039d\u039e\u0005"+ |
| "&\u0000\u0000\u039e\u039f\u0005\u001c\u0000\u0000\u039f\u03a0\u0003j5"+ |
| "\u0000\u03a0\u03a1\u0005\u001d\u0000\u0000\u03a1\u00bd\u0001\u0000\u0000"+ |
| "\u0000\u03a2\u03b1\u0005\u001c\u0000\u0000\u03a3\u03aa\u0003\u0012\t\u0000"+ |
| "\u03a4\u03a7\u0003\u0092I\u0000\u03a5\u03a6\u0005#\u0000\u0000\u03a6\u03a8"+ |
| "\u0003\u0012\t\u0000\u03a7\u03a5\u0001\u0000\u0000\u0000\u03a7\u03a8\u0001"+ |
| "\u0000\u0000\u0000\u03a8\u03aa\u0001\u0000\u0000\u0000\u03a9\u03a3\u0001"+ |
| "\u0000\u0000\u0000\u03a9\u03a4\u0001\u0000\u0000\u0000\u03aa\u03ac\u0001"+ |
| "\u0000\u0000\u0000\u03ab\u03ad\u0005*\u0000\u0000\u03ac\u03ab\u0001\u0000"+ |
| "\u0000\u0000\u03ac\u03ad\u0001\u0000\u0000\u0000\u03ad\u03af\u0001\u0000"+ |
| "\u0000\u0000\u03ae\u03b0\u0005#\u0000\u0000\u03af\u03ae\u0001\u0000\u0000"+ |
| "\u0000\u03af\u03b0\u0001\u0000\u0000\u0000\u03b0\u03b2\u0001\u0000\u0000"+ |
| "\u0000\u03b1\u03a9\u0001\u0000\u0000\u0000\u03b1\u03b2\u0001\u0000\u0000"+ |
| "\u0000\u03b2\u03b3\u0001\u0000\u0000\u0000\u03b3\u03b4\u0005\u001d\u0000"+ |
| "\u0000\u03b4\u00bf\u0001\u0000\u0000\u0000\u03b5\u03b6\u0003\u0092I\u0000"+ |
| "\u03b6\u03b7\u0005&\u0000\u0000\u03b7\u03b8\u0005\u001b\u0000\u0000\u03b8"+ |
| "\u00c1\u0001\u0000\u0000\u0000\u03b9\u03ba\u0003j5\u0000\u03ba\u00c3\u0001"+ |
| "\u0000\u0000\u0000\u03bb\u03c0\u0005$\u0000\u0000\u03bc\u03c0\u0005\u0000"+ |
| "\u0000\u0001\u03bd\u03c0\u0005W\u0000\u0000\u03be\u03c0\u0004b\u0007\u0000"+ |
| "\u03bf\u03bb\u0001\u0000\u0000\u0000\u03bf\u03bc\u0001\u0000\u0000\u0000"+ |
| "\u03bf\u03bd\u0001\u0000\u0000\u0000\u03bf\u03be\u0001\u0000\u0000\u0000"+ |
| "\u03c0\u00c5\u0001\u0000\u0000\u0000o\u00cd\u00d3\u00d9\u00e9\u00ed\u00f0"+ |
| "\u00f9\u0103\u0107\u010b\u010f\u0116\u011e\u0129\u012d\u0131\u0139\u0140"+ |
| "\u014c\u0150\u0156\u015a\u015e\u0163\u0166\u0169\u0170\u0181\u0188\u0198"+ |
| "\u01a5\u01a9\u01ad\u01b1\u01c4\u01ca\u01cc\u01d0\u01d4\u01d7\u01db\u01dd"+ |
| "\u01e3\u01eb\u01f0\u01fb\u0201\u0208\u0213\u0218\u021c\u0221\u0225\u022d"+ |
| "\u0235\u023a\u023d\u0245\u024b\u024f\u0251\u0256\u025a\u025e\u0266\u0274"+ |
| "\u0278\u0282\u0294\u029a\u02ae\u02b8\u02c1\u02c5\u02cd\u02d1\u02d3\u02d8"+ |
| "\u02db\u02e3\u02f4\u02f6\u02fd\u0306\u030a\u0311\u031a\u0322\u0327\u032d"+ |
| "\u0343\u0348\u034a\u0353\u0359\u035f\u0363\u036c\u0375\u0378\u037d\u038b"+ |
| "\u038f\u0392\u0399\u03a7\u03a9\u03ac\u03af\u03b1\u03bf"; |
| public static final ATN _ATN = |
| new ATNDeserializer().deserialize(_serializedATN.toCharArray()); |
| static { |
| _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; |
| for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { |
| _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); |
| } |
| } |
| } |