1 // Generated from BindingExpression.g4 by ANTLR 4.5 2 package android.databinding.parser; 3 import org.antlr.v4.runtime.atn.*; 4 import org.antlr.v4.runtime.dfa.DFA; 5 import org.antlr.v4.runtime.*; 6 import org.antlr.v4.runtime.misc.*; 7 import org.antlr.v4.runtime.tree.*; 8 import java.util.List; 9 import java.util.Iterator; 10 import java.util.ArrayList; 11 12 public class BindingExpressionParser extends Parser { 13 public static final int 14 T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, T__7=8, T__8=9, 15 T__9=10, T__10=11, T__11=12, T__12=13, T__13=14, T__14=15, T__15=16, T__16=17, 16 T__17=18, T__18=19, T__19=20, T__20=21, T__21=22, T__22=23, T__23=24, 17 T__24=25, T__25=26, T__26=27, T__27=28, T__28=29, T__29=30, T__30=31, 18 T__31=32, T__32=33, T__33=34, T__34=35, T__35=36, T__36=37, T__37=38, 19 T__38=39, T__39=40, T__40=41, T__41=42, T__42=43, THIS=44, IntegerLiteral=45, 20 FloatingPointLiteral=46, BooleanLiteral=47, CharacterLiteral=48, SingleQuoteString=49, 21 DoubleQuoteString=50, NullLiteral=51, Identifier=52, WS=53, ResourceReference=54, 22 PackageName=55, ResourceType=56; 23 public static final int 24 RULE_bindingSyntax = 0, RULE_defaults = 1, RULE_constantValue = 2, RULE_expression = 3, 25 RULE_classExtraction = 4, RULE_expressionList = 5, RULE_literal = 6, RULE_identifier = 7, 26 RULE_javaLiteral = 8, RULE_stringLiteral = 9, RULE_explicitGenericInvocation = 10, 27 RULE_typeArguments = 11, RULE_type = 12, RULE_explicitGenericInvocationSuffix = 13, 28 RULE_arguments = 14, RULE_classOrInterfaceType = 15, RULE_primitiveType = 16, 29 RULE_resources = 17, RULE_resourceParameters = 18; 30 public static final String[] ruleNames = { 31 "bindingSyntax", "defaults", "constantValue", "expression", "classExtraction", 32 "expressionList", "literal", "identifier", "javaLiteral", "stringLiteral", 33 "explicitGenericInvocation", "typeArguments", "type", "explicitGenericInvocationSuffix", 34 "arguments", "classOrInterfaceType", "primitiveType", "resources", "resourceParameters" 35 }; 36 37 private static final String[] _LITERAL_NAMES = { 38 null, "','", "'default'", "'='", "'('", "')'", "'.'", "'['", "']'", "'+'", 39 "'-'", "'~'", "'!'", "'*'", "'/'", "'%'", "'<<'", "'>>>'", "'>>'", "'<='", 40 "'>='", "'>'", "'<'", "'instanceof'", "'=='", "'!='", "'&'", "'^'", "'|'", 41 "'&&'", "'||'", "'?'", "':'", "'??'", "'class'", "'void'", "'boolean'", 42 "'char'", "'byte'", "'short'", "'int'", "'long'", "'float'", "'double'", 43 "'this'", null, null, null, null, null, null, "'null'" 44 }; 45 private static final String[] _SYMBOLIC_NAMES = { 46 null, null, null, null, null, null, null, null, null, null, null, null, 47 null, null, null, null, null, null, null, null, null, null, null, null, 48 null, null, null, null, null, null, null, null, null, null, null, null, 49 null, null, null, null, null, null, null, null, "THIS", "IntegerLiteral", 50 "FloatingPointLiteral", "BooleanLiteral", "CharacterLiteral", "SingleQuoteString", 51 "DoubleQuoteString", "NullLiteral", "Identifier", "WS", "ResourceReference", 52 "PackageName", "ResourceType" 53 }; 54 public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); 55 56 /** 57 * @deprecated Use {@link #VOCABULARY} instead. 58 */ 59 @Deprecated 60 public static final String[] tokenNames; 61 static { 62 tokenNames = new String[_SYMBOLIC_NAMES.length]; 63 for (int i = 0; i < tokenNames.length; i++) { 64 tokenNames[i] = VOCABULARY.getLiteralName(i); 65 if (tokenNames[i] == null) { 66 tokenNames[i] = VOCABULARY.getSymbolicName(i); 67 } 68 69 if (tokenNames[i] == null) { 70 tokenNames[i] = "<INVALID>"; 71 } 72 } 73 } 74 75 @Override 76 @Deprecated getTokenNames()77 public String[] getTokenNames() { 78 return tokenNames; 79 } 80 81 @Override 82 @NotNull getVocabulary()83 public Vocabulary getVocabulary() { 84 return VOCABULARY; 85 } 86 87 @Override getGrammarFileName()88 public String getGrammarFileName() { return "BindingExpression.g4"; } 89 90 @Override getRuleNames()91 public String[] getRuleNames() { return ruleNames; } 92 93 @Override getSerializedATN()94 public String getSerializedATN() { return _serializedATN; } 95 BindingExpressionParser(TokenStream input)96 public BindingExpressionParser(TokenStream input) { 97 super(input); 98 _interp = new ParserATNSimulator(this,_ATN); 99 } 100 public static class BindingSyntaxContext extends ParserRuleContext { expression()101 public ExpressionContext expression() { 102 return getRuleContext(ExpressionContext.class,0); 103 } defaults()104 public DefaultsContext defaults() { 105 return getRuleContext(DefaultsContext.class,0); 106 } BindingSyntaxContext(ParserRuleContext parent, int invokingState)107 public BindingSyntaxContext(ParserRuleContext parent, int invokingState) { 108 super(parent, invokingState); 109 } getRuleIndex()110 @Override public int getRuleIndex() { return RULE_bindingSyntax; } 111 @Override enterRule(ParseTreeListener listener)112 public void enterRule(ParseTreeListener listener) { 113 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterBindingSyntax(this); 114 } 115 @Override exitRule(ParseTreeListener listener)116 public void exitRule(ParseTreeListener listener) { 117 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitBindingSyntax(this); 118 } 119 @Override accept(ParseTreeVisitor<? extends Result> visitor)120 public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { 121 if ( visitor instanceof BindingExpressionVisitor<?> ) return ((BindingExpressionVisitor<? extends Result>)visitor).visitBindingSyntax(this); 122 else return visitor.visitChildren(this); 123 } 124 } 125 126 @RuleVersion(0) bindingSyntax()127 public final BindingSyntaxContext bindingSyntax() throws RecognitionException { 128 BindingSyntaxContext _localctx = new BindingSyntaxContext(_ctx, getState()); 129 enterRule(_localctx, 0, RULE_bindingSyntax); 130 int _la; 131 try { 132 enterOuterAlt(_localctx, 1); 133 { 134 setState(38); 135 expression(0); 136 setState(40); 137 _la = _input.LA(1); 138 if (_la==T__0) { 139 { 140 setState(39); 141 defaults(); 142 } 143 } 144 145 } 146 } 147 catch (RecognitionException re) { 148 _localctx.exception = re; 149 _errHandler.reportError(this, re); 150 _errHandler.recover(this, re); 151 } 152 finally { 153 exitRule(); 154 } 155 return _localctx; 156 } 157 158 public static class DefaultsContext extends ParserRuleContext { constantValue()159 public ConstantValueContext constantValue() { 160 return getRuleContext(ConstantValueContext.class,0); 161 } DefaultsContext(ParserRuleContext parent, int invokingState)162 public DefaultsContext(ParserRuleContext parent, int invokingState) { 163 super(parent, invokingState); 164 } getRuleIndex()165 @Override public int getRuleIndex() { return RULE_defaults; } 166 @Override enterRule(ParseTreeListener listener)167 public void enterRule(ParseTreeListener listener) { 168 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterDefaults(this); 169 } 170 @Override exitRule(ParseTreeListener listener)171 public void exitRule(ParseTreeListener listener) { 172 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitDefaults(this); 173 } 174 @Override accept(ParseTreeVisitor<? extends Result> visitor)175 public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { 176 if ( visitor instanceof BindingExpressionVisitor<?> ) return ((BindingExpressionVisitor<? extends Result>)visitor).visitDefaults(this); 177 else return visitor.visitChildren(this); 178 } 179 } 180 181 @RuleVersion(0) defaults()182 public final DefaultsContext defaults() throws RecognitionException { 183 DefaultsContext _localctx = new DefaultsContext(_ctx, getState()); 184 enterRule(_localctx, 2, RULE_defaults); 185 try { 186 enterOuterAlt(_localctx, 1); 187 { 188 setState(42); 189 match(T__0); 190 setState(43); 191 match(T__1); 192 setState(44); 193 match(T__2); 194 setState(45); 195 constantValue(); 196 } 197 } 198 catch (RecognitionException re) { 199 _localctx.exception = re; 200 _errHandler.reportError(this, re); 201 _errHandler.recover(this, re); 202 } 203 finally { 204 exitRule(); 205 } 206 return _localctx; 207 } 208 209 public static class ConstantValueContext extends ParserRuleContext { literal()210 public LiteralContext literal() { 211 return getRuleContext(LiteralContext.class,0); 212 } ResourceReference()213 public TerminalNode ResourceReference() { return getToken(BindingExpressionParser.ResourceReference, 0); } identifier()214 public IdentifierContext identifier() { 215 return getRuleContext(IdentifierContext.class,0); 216 } ConstantValueContext(ParserRuleContext parent, int invokingState)217 public ConstantValueContext(ParserRuleContext parent, int invokingState) { 218 super(parent, invokingState); 219 } getRuleIndex()220 @Override public int getRuleIndex() { return RULE_constantValue; } 221 @Override enterRule(ParseTreeListener listener)222 public void enterRule(ParseTreeListener listener) { 223 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterConstantValue(this); 224 } 225 @Override exitRule(ParseTreeListener listener)226 public void exitRule(ParseTreeListener listener) { 227 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitConstantValue(this); 228 } 229 @Override accept(ParseTreeVisitor<? extends Result> visitor)230 public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { 231 if ( visitor instanceof BindingExpressionVisitor<?> ) return ((BindingExpressionVisitor<? extends Result>)visitor).visitConstantValue(this); 232 else return visitor.visitChildren(this); 233 } 234 } 235 236 @RuleVersion(0) constantValue()237 public final ConstantValueContext constantValue() throws RecognitionException { 238 ConstantValueContext _localctx = new ConstantValueContext(_ctx, getState()); 239 enterRule(_localctx, 4, RULE_constantValue); 240 try { 241 setState(50); 242 switch (_input.LA(1)) { 243 case IntegerLiteral: 244 case FloatingPointLiteral: 245 case BooleanLiteral: 246 case CharacterLiteral: 247 case SingleQuoteString: 248 case DoubleQuoteString: 249 case NullLiteral: 250 enterOuterAlt(_localctx, 1); 251 { 252 setState(47); 253 literal(); 254 } 255 break; 256 case ResourceReference: 257 enterOuterAlt(_localctx, 2); 258 { 259 setState(48); 260 match(ResourceReference); 261 } 262 break; 263 case Identifier: 264 enterOuterAlt(_localctx, 3); 265 { 266 setState(49); 267 identifier(); 268 } 269 break; 270 default: 271 throw new NoViableAltException(this); 272 } 273 } 274 catch (RecognitionException re) { 275 _localctx.exception = re; 276 _errHandler.reportError(this, re); 277 _errHandler.recover(this, re); 278 } 279 finally { 280 exitRule(); 281 } 282 return _localctx; 283 } 284 285 public static class ExpressionContext extends ParserRuleContext { ExpressionContext(ParserRuleContext parent, int invokingState)286 public ExpressionContext(ParserRuleContext parent, int invokingState) { 287 super(parent, invokingState); 288 } getRuleIndex()289 @Override public int getRuleIndex() { return RULE_expression; } 290 ExpressionContext()291 public ExpressionContext() { } copyFrom(ExpressionContext ctx)292 public void copyFrom(ExpressionContext ctx) { 293 super.copyFrom(ctx); 294 } 295 } 296 public static class BracketOpContext extends ExpressionContext { expression()297 public List<? extends ExpressionContext> expression() { 298 return getRuleContexts(ExpressionContext.class); 299 } expression(int i)300 public ExpressionContext expression(int i) { 301 return getRuleContext(ExpressionContext.class,i); 302 } BracketOpContext(ExpressionContext ctx)303 public BracketOpContext(ExpressionContext ctx) { copyFrom(ctx); } 304 @Override enterRule(ParseTreeListener listener)305 public void enterRule(ParseTreeListener listener) { 306 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterBracketOp(this); 307 } 308 @Override exitRule(ParseTreeListener listener)309 public void exitRule(ParseTreeListener listener) { 310 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitBracketOp(this); 311 } 312 @Override accept(ParseTreeVisitor<? extends Result> visitor)313 public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { 314 if ( visitor instanceof BindingExpressionVisitor<?> ) return ((BindingExpressionVisitor<? extends Result>)visitor).visitBracketOp(this); 315 else return visitor.visitChildren(this); 316 } 317 } 318 public static class ResourceContext extends ExpressionContext { resources()319 public ResourcesContext resources() { 320 return getRuleContext(ResourcesContext.class,0); 321 } ResourceContext(ExpressionContext ctx)322 public ResourceContext(ExpressionContext ctx) { copyFrom(ctx); } 323 @Override enterRule(ParseTreeListener listener)324 public void enterRule(ParseTreeListener listener) { 325 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterResource(this); 326 } 327 @Override exitRule(ParseTreeListener listener)328 public void exitRule(ParseTreeListener listener) { 329 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitResource(this); 330 } 331 @Override accept(ParseTreeVisitor<? extends Result> visitor)332 public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { 333 if ( visitor instanceof BindingExpressionVisitor<?> ) return ((BindingExpressionVisitor<? extends Result>)visitor).visitResource(this); 334 else return visitor.visitChildren(this); 335 } 336 } 337 public static class CastOpContext extends ExpressionContext { type()338 public TypeContext type() { 339 return getRuleContext(TypeContext.class,0); 340 } expression()341 public ExpressionContext expression() { 342 return getRuleContext(ExpressionContext.class,0); 343 } CastOpContext(ExpressionContext ctx)344 public CastOpContext(ExpressionContext ctx) { copyFrom(ctx); } 345 @Override enterRule(ParseTreeListener listener)346 public void enterRule(ParseTreeListener listener) { 347 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterCastOp(this); 348 } 349 @Override exitRule(ParseTreeListener listener)350 public void exitRule(ParseTreeListener listener) { 351 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitCastOp(this); 352 } 353 @Override accept(ParseTreeVisitor<? extends Result> visitor)354 public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { 355 if ( visitor instanceof BindingExpressionVisitor<?> ) return ((BindingExpressionVisitor<? extends Result>)visitor).visitCastOp(this); 356 else return visitor.visitChildren(this); 357 } 358 } 359 public static class UnaryOpContext extends ExpressionContext { 360 public Token op; expression()361 public ExpressionContext expression() { 362 return getRuleContext(ExpressionContext.class,0); 363 } UnaryOpContext(ExpressionContext ctx)364 public UnaryOpContext(ExpressionContext ctx) { copyFrom(ctx); } 365 @Override enterRule(ParseTreeListener listener)366 public void enterRule(ParseTreeListener listener) { 367 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterUnaryOp(this); 368 } 369 @Override exitRule(ParseTreeListener listener)370 public void exitRule(ParseTreeListener listener) { 371 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitUnaryOp(this); 372 } 373 @Override accept(ParseTreeVisitor<? extends Result> visitor)374 public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { 375 if ( visitor instanceof BindingExpressionVisitor<?> ) return ((BindingExpressionVisitor<? extends Result>)visitor).visitUnaryOp(this); 376 else return visitor.visitChildren(this); 377 } 378 } 379 public static class AndOrOpContext extends ExpressionContext { 380 public ExpressionContext left; 381 public Token op; 382 public ExpressionContext right; expression()383 public List<? extends ExpressionContext> expression() { 384 return getRuleContexts(ExpressionContext.class); 385 } expression(int i)386 public ExpressionContext expression(int i) { 387 return getRuleContext(ExpressionContext.class,i); 388 } AndOrOpContext(ExpressionContext ctx)389 public AndOrOpContext(ExpressionContext ctx) { copyFrom(ctx); } 390 @Override enterRule(ParseTreeListener listener)391 public void enterRule(ParseTreeListener listener) { 392 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterAndOrOp(this); 393 } 394 @Override exitRule(ParseTreeListener listener)395 public void exitRule(ParseTreeListener listener) { 396 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitAndOrOp(this); 397 } 398 @Override accept(ParseTreeVisitor<? extends Result> visitor)399 public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { 400 if ( visitor instanceof BindingExpressionVisitor<?> ) return ((BindingExpressionVisitor<? extends Result>)visitor).visitAndOrOp(this); 401 else return visitor.visitChildren(this); 402 } 403 } 404 public static class MethodInvocationContext extends ExpressionContext { 405 public ExpressionContext target; 406 public Token methodName; 407 public ExpressionListContext args; expression()408 public ExpressionContext expression() { 409 return getRuleContext(ExpressionContext.class,0); 410 } Identifier()411 public TerminalNode Identifier() { return getToken(BindingExpressionParser.Identifier, 0); } expressionList()412 public ExpressionListContext expressionList() { 413 return getRuleContext(ExpressionListContext.class,0); 414 } MethodInvocationContext(ExpressionContext ctx)415 public MethodInvocationContext(ExpressionContext ctx) { copyFrom(ctx); } 416 @Override enterRule(ParseTreeListener listener)417 public void enterRule(ParseTreeListener listener) { 418 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterMethodInvocation(this); 419 } 420 @Override exitRule(ParseTreeListener listener)421 public void exitRule(ParseTreeListener listener) { 422 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitMethodInvocation(this); 423 } 424 @Override accept(ParseTreeVisitor<? extends Result> visitor)425 public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { 426 if ( visitor instanceof BindingExpressionVisitor<?> ) return ((BindingExpressionVisitor<? extends Result>)visitor).visitMethodInvocation(this); 427 else return visitor.visitChildren(this); 428 } 429 } 430 public static class PrimaryContext extends ExpressionContext { literal()431 public LiteralContext literal() { 432 return getRuleContext(LiteralContext.class,0); 433 } identifier()434 public IdentifierContext identifier() { 435 return getRuleContext(IdentifierContext.class,0); 436 } classExtraction()437 public ClassExtractionContext classExtraction() { 438 return getRuleContext(ClassExtractionContext.class,0); 439 } PrimaryContext(ExpressionContext ctx)440 public PrimaryContext(ExpressionContext ctx) { copyFrom(ctx); } 441 @Override enterRule(ParseTreeListener listener)442 public void enterRule(ParseTreeListener listener) { 443 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterPrimary(this); 444 } 445 @Override exitRule(ParseTreeListener listener)446 public void exitRule(ParseTreeListener listener) { 447 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitPrimary(this); 448 } 449 @Override accept(ParseTreeVisitor<? extends Result> visitor)450 public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { 451 if ( visitor instanceof BindingExpressionVisitor<?> ) return ((BindingExpressionVisitor<? extends Result>)visitor).visitPrimary(this); 452 else return visitor.visitChildren(this); 453 } 454 } 455 public static class GroupingContext extends ExpressionContext { expression()456 public ExpressionContext expression() { 457 return getRuleContext(ExpressionContext.class,0); 458 } GroupingContext(ExpressionContext ctx)459 public GroupingContext(ExpressionContext ctx) { copyFrom(ctx); } 460 @Override enterRule(ParseTreeListener listener)461 public void enterRule(ParseTreeListener listener) { 462 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterGrouping(this); 463 } 464 @Override exitRule(ParseTreeListener listener)465 public void exitRule(ParseTreeListener listener) { 466 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitGrouping(this); 467 } 468 @Override accept(ParseTreeVisitor<? extends Result> visitor)469 public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { 470 if ( visitor instanceof BindingExpressionVisitor<?> ) return ((BindingExpressionVisitor<? extends Result>)visitor).visitGrouping(this); 471 else return visitor.visitChildren(this); 472 } 473 } 474 public static class TernaryOpContext extends ExpressionContext { 475 public ExpressionContext left; 476 public Token op; 477 public ExpressionContext iftrue; 478 public ExpressionContext iffalse; expression()479 public List<? extends ExpressionContext> expression() { 480 return getRuleContexts(ExpressionContext.class); 481 } expression(int i)482 public ExpressionContext expression(int i) { 483 return getRuleContext(ExpressionContext.class,i); 484 } TernaryOpContext(ExpressionContext ctx)485 public TernaryOpContext(ExpressionContext ctx) { copyFrom(ctx); } 486 @Override enterRule(ParseTreeListener listener)487 public void enterRule(ParseTreeListener listener) { 488 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterTernaryOp(this); 489 } 490 @Override exitRule(ParseTreeListener listener)491 public void exitRule(ParseTreeListener listener) { 492 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitTernaryOp(this); 493 } 494 @Override accept(ParseTreeVisitor<? extends Result> visitor)495 public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { 496 if ( visitor instanceof BindingExpressionVisitor<?> ) return ((BindingExpressionVisitor<? extends Result>)visitor).visitTernaryOp(this); 497 else return visitor.visitChildren(this); 498 } 499 } 500 public static class ComparisonOpContext extends ExpressionContext { 501 public ExpressionContext left; 502 public Token op; 503 public ExpressionContext right; expression()504 public List<? extends ExpressionContext> expression() { 505 return getRuleContexts(ExpressionContext.class); 506 } expression(int i)507 public ExpressionContext expression(int i) { 508 return getRuleContext(ExpressionContext.class,i); 509 } ComparisonOpContext(ExpressionContext ctx)510 public ComparisonOpContext(ExpressionContext ctx) { copyFrom(ctx); } 511 @Override enterRule(ParseTreeListener listener)512 public void enterRule(ParseTreeListener listener) { 513 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterComparisonOp(this); 514 } 515 @Override exitRule(ParseTreeListener listener)516 public void exitRule(ParseTreeListener listener) { 517 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitComparisonOp(this); 518 } 519 @Override accept(ParseTreeVisitor<? extends Result> visitor)520 public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { 521 if ( visitor instanceof BindingExpressionVisitor<?> ) return ((BindingExpressionVisitor<? extends Result>)visitor).visitComparisonOp(this); 522 else return visitor.visitChildren(this); 523 } 524 } 525 public static class DotOpContext extends ExpressionContext { expression()526 public ExpressionContext expression() { 527 return getRuleContext(ExpressionContext.class,0); 528 } Identifier()529 public TerminalNode Identifier() { return getToken(BindingExpressionParser.Identifier, 0); } DotOpContext(ExpressionContext ctx)530 public DotOpContext(ExpressionContext ctx) { copyFrom(ctx); } 531 @Override enterRule(ParseTreeListener listener)532 public void enterRule(ParseTreeListener listener) { 533 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterDotOp(this); 534 } 535 @Override exitRule(ParseTreeListener listener)536 public void exitRule(ParseTreeListener listener) { 537 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitDotOp(this); 538 } 539 @Override accept(ParseTreeVisitor<? extends Result> visitor)540 public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { 541 if ( visitor instanceof BindingExpressionVisitor<?> ) return ((BindingExpressionVisitor<? extends Result>)visitor).visitDotOp(this); 542 else return visitor.visitChildren(this); 543 } 544 } 545 public static class MathOpContext extends ExpressionContext { 546 public ExpressionContext left; 547 public Token op; 548 public ExpressionContext right; expression()549 public List<? extends ExpressionContext> expression() { 550 return getRuleContexts(ExpressionContext.class); 551 } expression(int i)552 public ExpressionContext expression(int i) { 553 return getRuleContext(ExpressionContext.class,i); 554 } MathOpContext(ExpressionContext ctx)555 public MathOpContext(ExpressionContext ctx) { copyFrom(ctx); } 556 @Override enterRule(ParseTreeListener listener)557 public void enterRule(ParseTreeListener listener) { 558 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterMathOp(this); 559 } 560 @Override exitRule(ParseTreeListener listener)561 public void exitRule(ParseTreeListener listener) { 562 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitMathOp(this); 563 } 564 @Override accept(ParseTreeVisitor<? extends Result> visitor)565 public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { 566 if ( visitor instanceof BindingExpressionVisitor<?> ) return ((BindingExpressionVisitor<? extends Result>)visitor).visitMathOp(this); 567 else return visitor.visitChildren(this); 568 } 569 } 570 public static class QuestionQuestionOpContext extends ExpressionContext { 571 public ExpressionContext left; 572 public Token op; 573 public ExpressionContext right; expression()574 public List<? extends ExpressionContext> expression() { 575 return getRuleContexts(ExpressionContext.class); 576 } expression(int i)577 public ExpressionContext expression(int i) { 578 return getRuleContext(ExpressionContext.class,i); 579 } QuestionQuestionOpContext(ExpressionContext ctx)580 public QuestionQuestionOpContext(ExpressionContext ctx) { copyFrom(ctx); } 581 @Override enterRule(ParseTreeListener listener)582 public void enterRule(ParseTreeListener listener) { 583 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterQuestionQuestionOp(this); 584 } 585 @Override exitRule(ParseTreeListener listener)586 public void exitRule(ParseTreeListener listener) { 587 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitQuestionQuestionOp(this); 588 } 589 @Override accept(ParseTreeVisitor<? extends Result> visitor)590 public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { 591 if ( visitor instanceof BindingExpressionVisitor<?> ) return ((BindingExpressionVisitor<? extends Result>)visitor).visitQuestionQuestionOp(this); 592 else return visitor.visitChildren(this); 593 } 594 } 595 public static class BitShiftOpContext extends ExpressionContext { 596 public ExpressionContext left; 597 public Token op; 598 public ExpressionContext right; expression()599 public List<? extends ExpressionContext> expression() { 600 return getRuleContexts(ExpressionContext.class); 601 } expression(int i)602 public ExpressionContext expression(int i) { 603 return getRuleContext(ExpressionContext.class,i); 604 } BitShiftOpContext(ExpressionContext ctx)605 public BitShiftOpContext(ExpressionContext ctx) { copyFrom(ctx); } 606 @Override enterRule(ParseTreeListener listener)607 public void enterRule(ParseTreeListener listener) { 608 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterBitShiftOp(this); 609 } 610 @Override exitRule(ParseTreeListener listener)611 public void exitRule(ParseTreeListener listener) { 612 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitBitShiftOp(this); 613 } 614 @Override accept(ParseTreeVisitor<? extends Result> visitor)615 public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { 616 if ( visitor instanceof BindingExpressionVisitor<?> ) return ((BindingExpressionVisitor<? extends Result>)visitor).visitBitShiftOp(this); 617 else return visitor.visitChildren(this); 618 } 619 } 620 public static class InstanceOfOpContext extends ExpressionContext { expression()621 public ExpressionContext expression() { 622 return getRuleContext(ExpressionContext.class,0); 623 } type()624 public TypeContext type() { 625 return getRuleContext(TypeContext.class,0); 626 } InstanceOfOpContext(ExpressionContext ctx)627 public InstanceOfOpContext(ExpressionContext ctx) { copyFrom(ctx); } 628 @Override enterRule(ParseTreeListener listener)629 public void enterRule(ParseTreeListener listener) { 630 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterInstanceOfOp(this); 631 } 632 @Override exitRule(ParseTreeListener listener)633 public void exitRule(ParseTreeListener listener) { 634 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitInstanceOfOp(this); 635 } 636 @Override accept(ParseTreeVisitor<? extends Result> visitor)637 public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { 638 if ( visitor instanceof BindingExpressionVisitor<?> ) return ((BindingExpressionVisitor<? extends Result>)visitor).visitInstanceOfOp(this); 639 else return visitor.visitChildren(this); 640 } 641 } 642 public static class BinaryOpContext extends ExpressionContext { 643 public ExpressionContext left; 644 public Token op; 645 public ExpressionContext right; expression()646 public List<? extends ExpressionContext> expression() { 647 return getRuleContexts(ExpressionContext.class); 648 } expression(int i)649 public ExpressionContext expression(int i) { 650 return getRuleContext(ExpressionContext.class,i); 651 } BinaryOpContext(ExpressionContext ctx)652 public BinaryOpContext(ExpressionContext ctx) { copyFrom(ctx); } 653 @Override enterRule(ParseTreeListener listener)654 public void enterRule(ParseTreeListener listener) { 655 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterBinaryOp(this); 656 } 657 @Override exitRule(ParseTreeListener listener)658 public void exitRule(ParseTreeListener listener) { 659 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitBinaryOp(this); 660 } 661 @Override accept(ParseTreeVisitor<? extends Result> visitor)662 public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { 663 if ( visitor instanceof BindingExpressionVisitor<?> ) return ((BindingExpressionVisitor<? extends Result>)visitor).visitBinaryOp(this); 664 else return visitor.visitChildren(this); 665 } 666 } 667 668 @RuleVersion(0) expression()669 public final ExpressionContext expression() throws RecognitionException { 670 return expression(0); 671 } 672 expression(int _p)673 private ExpressionContext expression(int _p) throws RecognitionException { 674 ParserRuleContext _parentctx = _ctx; 675 int _parentState = getState(); 676 ExpressionContext _localctx = new ExpressionContext(_ctx, _parentState); 677 ExpressionContext _prevctx = _localctx; 678 int _startState = 6; 679 enterRecursionRule(_localctx, 6, RULE_expression, _p); 680 int _la; 681 try { 682 int _alt; 683 enterOuterAlt(_localctx, 1); 684 { 685 setState(70); 686 switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) { 687 case 1: 688 { 689 _localctx = new CastOpContext(_localctx); 690 _ctx = _localctx; 691 _prevctx = _localctx; 692 693 setState(53); 694 match(T__3); 695 setState(54); 696 type(); 697 setState(55); 698 match(T__4); 699 setState(56); 700 expression(16); 701 } 702 break; 703 704 case 2: 705 { 706 _localctx = new UnaryOpContext(_localctx); 707 _ctx = _localctx; 708 _prevctx = _localctx; 709 setState(58); 710 ((UnaryOpContext)_localctx).op = _input.LT(1); 711 _la = _input.LA(1); 712 if ( !(_la==T__8 || _la==T__9) ) { 713 ((UnaryOpContext)_localctx).op = _errHandler.recoverInline(this); 714 } else { 715 consume(); 716 } 717 setState(59); 718 expression(15); 719 } 720 break; 721 722 case 3: 723 { 724 _localctx = new UnaryOpContext(_localctx); 725 _ctx = _localctx; 726 _prevctx = _localctx; 727 setState(60); 728 ((UnaryOpContext)_localctx).op = _input.LT(1); 729 _la = _input.LA(1); 730 if ( !(_la==T__10 || _la==T__11) ) { 731 ((UnaryOpContext)_localctx).op = _errHandler.recoverInline(this); 732 } else { 733 consume(); 734 } 735 setState(61); 736 expression(14); 737 } 738 break; 739 740 case 4: 741 { 742 _localctx = new GroupingContext(_localctx); 743 _ctx = _localctx; 744 _prevctx = _localctx; 745 setState(62); 746 match(T__3); 747 setState(63); 748 expression(0); 749 setState(64); 750 match(T__4); 751 } 752 break; 753 754 case 5: 755 { 756 _localctx = new PrimaryContext(_localctx); 757 _ctx = _localctx; 758 _prevctx = _localctx; 759 setState(66); 760 literal(); 761 } 762 break; 763 764 case 6: 765 { 766 _localctx = new PrimaryContext(_localctx); 767 _ctx = _localctx; 768 _prevctx = _localctx; 769 setState(67); 770 identifier(); 771 } 772 break; 773 774 case 7: 775 { 776 _localctx = new PrimaryContext(_localctx); 777 _ctx = _localctx; 778 _prevctx = _localctx; 779 setState(68); 780 classExtraction(); 781 } 782 break; 783 784 case 8: 785 { 786 _localctx = new ResourceContext(_localctx); 787 _ctx = _localctx; 788 _prevctx = _localctx; 789 setState(69); 790 resources(); 791 } 792 break; 793 } 794 _ctx.stop = _input.LT(-1); 795 setState(132); 796 _errHandler.sync(this); 797 _alt = getInterpreter().adaptivePredict(_input,5,_ctx); 798 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 799 if ( _alt==1 ) { 800 if ( _parseListeners!=null ) triggerExitRuleEvent(); 801 _prevctx = _localctx; 802 { 803 setState(130); 804 switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) { 805 case 1: 806 { 807 _localctx = new MathOpContext(new ExpressionContext(_parentctx, _parentState)); 808 ((MathOpContext)_localctx).left = _prevctx; 809 pushNewRecursionContext(_localctx, _startState, RULE_expression); 810 setState(72); 811 if (!(precpred(_ctx, 13))) throw new FailedPredicateException(this, "precpred(_ctx, 13)"); 812 setState(73); 813 ((MathOpContext)_localctx).op = _input.LT(1); 814 _la = _input.LA(1); 815 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__12) | (1L << T__13) | (1L << T__14))) != 0)) ) { 816 ((MathOpContext)_localctx).op = _errHandler.recoverInline(this); 817 } else { 818 consume(); 819 } 820 setState(74); 821 ((MathOpContext)_localctx).right = expression(14); 822 } 823 break; 824 825 case 2: 826 { 827 _localctx = new MathOpContext(new ExpressionContext(_parentctx, _parentState)); 828 ((MathOpContext)_localctx).left = _prevctx; 829 pushNewRecursionContext(_localctx, _startState, RULE_expression); 830 setState(75); 831 if (!(precpred(_ctx, 12))) throw new FailedPredicateException(this, "precpred(_ctx, 12)"); 832 setState(76); 833 ((MathOpContext)_localctx).op = _input.LT(1); 834 _la = _input.LA(1); 835 if ( !(_la==T__8 || _la==T__9) ) { 836 ((MathOpContext)_localctx).op = _errHandler.recoverInline(this); 837 } else { 838 consume(); 839 } 840 setState(77); 841 ((MathOpContext)_localctx).right = expression(13); 842 } 843 break; 844 845 case 3: 846 { 847 _localctx = new BitShiftOpContext(new ExpressionContext(_parentctx, _parentState)); 848 ((BitShiftOpContext)_localctx).left = _prevctx; 849 pushNewRecursionContext(_localctx, _startState, RULE_expression); 850 setState(78); 851 if (!(precpred(_ctx, 11))) throw new FailedPredicateException(this, "precpred(_ctx, 11)"); 852 setState(79); 853 ((BitShiftOpContext)_localctx).op = _input.LT(1); 854 _la = _input.LA(1); 855 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__15) | (1L << T__16) | (1L << T__17))) != 0)) ) { 856 ((BitShiftOpContext)_localctx).op = _errHandler.recoverInline(this); 857 } else { 858 consume(); 859 } 860 setState(80); 861 ((BitShiftOpContext)_localctx).right = expression(12); 862 } 863 break; 864 865 case 4: 866 { 867 _localctx = new ComparisonOpContext(new ExpressionContext(_parentctx, _parentState)); 868 ((ComparisonOpContext)_localctx).left = _prevctx; 869 pushNewRecursionContext(_localctx, _startState, RULE_expression); 870 setState(81); 871 if (!(precpred(_ctx, 10))) throw new FailedPredicateException(this, "precpred(_ctx, 10)"); 872 setState(82); 873 ((ComparisonOpContext)_localctx).op = _input.LT(1); 874 _la = _input.LA(1); 875 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__18) | (1L << T__19) | (1L << T__20) | (1L << T__21))) != 0)) ) { 876 ((ComparisonOpContext)_localctx).op = _errHandler.recoverInline(this); 877 } else { 878 consume(); 879 } 880 setState(83); 881 ((ComparisonOpContext)_localctx).right = expression(11); 882 } 883 break; 884 885 case 5: 886 { 887 _localctx = new ComparisonOpContext(new ExpressionContext(_parentctx, _parentState)); 888 ((ComparisonOpContext)_localctx).left = _prevctx; 889 pushNewRecursionContext(_localctx, _startState, RULE_expression); 890 setState(84); 891 if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)"); 892 setState(85); 893 ((ComparisonOpContext)_localctx).op = _input.LT(1); 894 _la = _input.LA(1); 895 if ( !(_la==T__23 || _la==T__24) ) { 896 ((ComparisonOpContext)_localctx).op = _errHandler.recoverInline(this); 897 } else { 898 consume(); 899 } 900 setState(86); 901 ((ComparisonOpContext)_localctx).right = expression(9); 902 } 903 break; 904 905 case 6: 906 { 907 _localctx = new BinaryOpContext(new ExpressionContext(_parentctx, _parentState)); 908 ((BinaryOpContext)_localctx).left = _prevctx; 909 pushNewRecursionContext(_localctx, _startState, RULE_expression); 910 setState(87); 911 if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)"); 912 setState(88); 913 ((BinaryOpContext)_localctx).op = match(T__25); 914 setState(89); 915 ((BinaryOpContext)_localctx).right = expression(8); 916 } 917 break; 918 919 case 7: 920 { 921 _localctx = new BinaryOpContext(new ExpressionContext(_parentctx, _parentState)); 922 ((BinaryOpContext)_localctx).left = _prevctx; 923 pushNewRecursionContext(_localctx, _startState, RULE_expression); 924 setState(90); 925 if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)"); 926 setState(91); 927 ((BinaryOpContext)_localctx).op = match(T__26); 928 setState(92); 929 ((BinaryOpContext)_localctx).right = expression(7); 930 } 931 break; 932 933 case 8: 934 { 935 _localctx = new BinaryOpContext(new ExpressionContext(_parentctx, _parentState)); 936 ((BinaryOpContext)_localctx).left = _prevctx; 937 pushNewRecursionContext(_localctx, _startState, RULE_expression); 938 setState(93); 939 if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)"); 940 setState(94); 941 ((BinaryOpContext)_localctx).op = match(T__27); 942 setState(95); 943 ((BinaryOpContext)_localctx).right = expression(6); 944 } 945 break; 946 947 case 9: 948 { 949 _localctx = new AndOrOpContext(new ExpressionContext(_parentctx, _parentState)); 950 ((AndOrOpContext)_localctx).left = _prevctx; 951 pushNewRecursionContext(_localctx, _startState, RULE_expression); 952 setState(96); 953 if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)"); 954 setState(97); 955 ((AndOrOpContext)_localctx).op = match(T__28); 956 setState(98); 957 ((AndOrOpContext)_localctx).right = expression(5); 958 } 959 break; 960 961 case 10: 962 { 963 _localctx = new AndOrOpContext(new ExpressionContext(_parentctx, _parentState)); 964 ((AndOrOpContext)_localctx).left = _prevctx; 965 pushNewRecursionContext(_localctx, _startState, RULE_expression); 966 setState(99); 967 if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)"); 968 setState(100); 969 ((AndOrOpContext)_localctx).op = match(T__29); 970 setState(101); 971 ((AndOrOpContext)_localctx).right = expression(4); 972 } 973 break; 974 975 case 11: 976 { 977 _localctx = new TernaryOpContext(new ExpressionContext(_parentctx, _parentState)); 978 ((TernaryOpContext)_localctx).left = _prevctx; 979 pushNewRecursionContext(_localctx, _startState, RULE_expression); 980 setState(102); 981 if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); 982 setState(103); 983 ((TernaryOpContext)_localctx).op = match(T__30); 984 setState(104); 985 ((TernaryOpContext)_localctx).iftrue = expression(0); 986 setState(105); 987 match(T__31); 988 setState(106); 989 ((TernaryOpContext)_localctx).iffalse = expression(2); 990 } 991 break; 992 993 case 12: 994 { 995 _localctx = new QuestionQuestionOpContext(new ExpressionContext(_parentctx, _parentState)); 996 ((QuestionQuestionOpContext)_localctx).left = _prevctx; 997 pushNewRecursionContext(_localctx, _startState, RULE_expression); 998 setState(108); 999 if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); 1000 setState(109); 1001 ((QuestionQuestionOpContext)_localctx).op = match(T__32); 1002 setState(110); 1003 ((QuestionQuestionOpContext)_localctx).right = expression(2); 1004 } 1005 break; 1006 1007 case 13: 1008 { 1009 _localctx = new DotOpContext(new ExpressionContext(_parentctx, _parentState)); 1010 pushNewRecursionContext(_localctx, _startState, RULE_expression); 1011 setState(111); 1012 if (!(precpred(_ctx, 19))) throw new FailedPredicateException(this, "precpred(_ctx, 19)"); 1013 setState(112); 1014 match(T__5); 1015 setState(113); 1016 match(Identifier); 1017 } 1018 break; 1019 1020 case 14: 1021 { 1022 _localctx = new BracketOpContext(new ExpressionContext(_parentctx, _parentState)); 1023 pushNewRecursionContext(_localctx, _startState, RULE_expression); 1024 setState(114); 1025 if (!(precpred(_ctx, 18))) throw new FailedPredicateException(this, "precpred(_ctx, 18)"); 1026 setState(115); 1027 match(T__6); 1028 setState(116); 1029 expression(0); 1030 setState(117); 1031 match(T__7); 1032 } 1033 break; 1034 1035 case 15: 1036 { 1037 _localctx = new MethodInvocationContext(new ExpressionContext(_parentctx, _parentState)); 1038 ((MethodInvocationContext)_localctx).target = _prevctx; 1039 pushNewRecursionContext(_localctx, _startState, RULE_expression); 1040 setState(119); 1041 if (!(precpred(_ctx, 17))) throw new FailedPredicateException(this, "precpred(_ctx, 17)"); 1042 setState(120); 1043 match(T__5); 1044 setState(121); 1045 ((MethodInvocationContext)_localctx).methodName = match(Identifier); 1046 setState(122); 1047 match(T__3); 1048 setState(124); 1049 _la = _input.LA(1); 1050 if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__3) | (1L << T__8) | (1L << T__9) | (1L << T__10) | (1L << T__11) | (1L << T__34) | (1L << T__35) | (1L << T__36) | (1L << T__37) | (1L << T__38) | (1L << T__39) | (1L << T__40) | (1L << T__41) | (1L << T__42) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << SingleQuoteString) | (1L << DoubleQuoteString) | (1L << NullLiteral) | (1L << Identifier) | (1L << ResourceReference))) != 0)) { 1051 { 1052 setState(123); 1053 ((MethodInvocationContext)_localctx).args = expressionList(); 1054 } 1055 } 1056 1057 setState(126); 1058 match(T__4); 1059 } 1060 break; 1061 1062 case 16: 1063 { 1064 _localctx = new InstanceOfOpContext(new ExpressionContext(_parentctx, _parentState)); 1065 pushNewRecursionContext(_localctx, _startState, RULE_expression); 1066 setState(127); 1067 if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)"); 1068 setState(128); 1069 match(T__22); 1070 setState(129); 1071 type(); 1072 } 1073 break; 1074 } 1075 } 1076 } 1077 setState(134); 1078 _errHandler.sync(this); 1079 _alt = getInterpreter().adaptivePredict(_input,5,_ctx); 1080 } 1081 } 1082 } 1083 catch (RecognitionException re) { 1084 _localctx.exception = re; 1085 _errHandler.reportError(this, re); 1086 _errHandler.recover(this, re); 1087 } 1088 finally { 1089 unrollRecursionContexts(_parentctx); 1090 } 1091 return _localctx; 1092 } 1093 1094 public static class ClassExtractionContext extends ParserRuleContext { type()1095 public TypeContext type() { 1096 return getRuleContext(TypeContext.class,0); 1097 } ClassExtractionContext(ParserRuleContext parent, int invokingState)1098 public ClassExtractionContext(ParserRuleContext parent, int invokingState) { 1099 super(parent, invokingState); 1100 } getRuleIndex()1101 @Override public int getRuleIndex() { return RULE_classExtraction; } 1102 @Override enterRule(ParseTreeListener listener)1103 public void enterRule(ParseTreeListener listener) { 1104 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterClassExtraction(this); 1105 } 1106 @Override exitRule(ParseTreeListener listener)1107 public void exitRule(ParseTreeListener listener) { 1108 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitClassExtraction(this); 1109 } 1110 @Override accept(ParseTreeVisitor<? extends Result> visitor)1111 public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { 1112 if ( visitor instanceof BindingExpressionVisitor<?> ) return ((BindingExpressionVisitor<? extends Result>)visitor).visitClassExtraction(this); 1113 else return visitor.visitChildren(this); 1114 } 1115 } 1116 1117 @RuleVersion(0) classExtraction()1118 public final ClassExtractionContext classExtraction() throws RecognitionException { 1119 ClassExtractionContext _localctx = new ClassExtractionContext(_ctx, getState()); 1120 enterRule(_localctx, 8, RULE_classExtraction); 1121 try { 1122 setState(142); 1123 switch (_input.LA(1)) { 1124 case T__35: 1125 case T__36: 1126 case T__37: 1127 case T__38: 1128 case T__39: 1129 case T__40: 1130 case T__41: 1131 case T__42: 1132 case Identifier: 1133 enterOuterAlt(_localctx, 1); 1134 { 1135 setState(135); 1136 type(); 1137 setState(136); 1138 match(T__5); 1139 setState(137); 1140 match(T__33); 1141 } 1142 break; 1143 case T__34: 1144 enterOuterAlt(_localctx, 2); 1145 { 1146 setState(139); 1147 match(T__34); 1148 setState(140); 1149 match(T__5); 1150 setState(141); 1151 match(T__33); 1152 } 1153 break; 1154 default: 1155 throw new NoViableAltException(this); 1156 } 1157 } 1158 catch (RecognitionException re) { 1159 _localctx.exception = re; 1160 _errHandler.reportError(this, re); 1161 _errHandler.recover(this, re); 1162 } 1163 finally { 1164 exitRule(); 1165 } 1166 return _localctx; 1167 } 1168 1169 public static class ExpressionListContext extends ParserRuleContext { expression()1170 public List<? extends ExpressionContext> expression() { 1171 return getRuleContexts(ExpressionContext.class); 1172 } expression(int i)1173 public ExpressionContext expression(int i) { 1174 return getRuleContext(ExpressionContext.class,i); 1175 } ExpressionListContext(ParserRuleContext parent, int invokingState)1176 public ExpressionListContext(ParserRuleContext parent, int invokingState) { 1177 super(parent, invokingState); 1178 } getRuleIndex()1179 @Override public int getRuleIndex() { return RULE_expressionList; } 1180 @Override enterRule(ParseTreeListener listener)1181 public void enterRule(ParseTreeListener listener) { 1182 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterExpressionList(this); 1183 } 1184 @Override exitRule(ParseTreeListener listener)1185 public void exitRule(ParseTreeListener listener) { 1186 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitExpressionList(this); 1187 } 1188 @Override accept(ParseTreeVisitor<? extends Result> visitor)1189 public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { 1190 if ( visitor instanceof BindingExpressionVisitor<?> ) return ((BindingExpressionVisitor<? extends Result>)visitor).visitExpressionList(this); 1191 else return visitor.visitChildren(this); 1192 } 1193 } 1194 1195 @RuleVersion(0) expressionList()1196 public final ExpressionListContext expressionList() throws RecognitionException { 1197 ExpressionListContext _localctx = new ExpressionListContext(_ctx, getState()); 1198 enterRule(_localctx, 10, RULE_expressionList); 1199 int _la; 1200 try { 1201 enterOuterAlt(_localctx, 1); 1202 { 1203 setState(144); 1204 expression(0); 1205 setState(149); 1206 _errHandler.sync(this); 1207 _la = _input.LA(1); 1208 while (_la==T__0) { 1209 { 1210 { 1211 setState(145); 1212 match(T__0); 1213 setState(146); 1214 expression(0); 1215 } 1216 } 1217 setState(151); 1218 _errHandler.sync(this); 1219 _la = _input.LA(1); 1220 } 1221 } 1222 } 1223 catch (RecognitionException re) { 1224 _localctx.exception = re; 1225 _errHandler.reportError(this, re); 1226 _errHandler.recover(this, re); 1227 } 1228 finally { 1229 exitRule(); 1230 } 1231 return _localctx; 1232 } 1233 1234 public static class LiteralContext extends ParserRuleContext { javaLiteral()1235 public JavaLiteralContext javaLiteral() { 1236 return getRuleContext(JavaLiteralContext.class,0); 1237 } stringLiteral()1238 public StringLiteralContext stringLiteral() { 1239 return getRuleContext(StringLiteralContext.class,0); 1240 } LiteralContext(ParserRuleContext parent, int invokingState)1241 public LiteralContext(ParserRuleContext parent, int invokingState) { 1242 super(parent, invokingState); 1243 } getRuleIndex()1244 @Override public int getRuleIndex() { return RULE_literal; } 1245 @Override enterRule(ParseTreeListener listener)1246 public void enterRule(ParseTreeListener listener) { 1247 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterLiteral(this); 1248 } 1249 @Override exitRule(ParseTreeListener listener)1250 public void exitRule(ParseTreeListener listener) { 1251 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitLiteral(this); 1252 } 1253 @Override accept(ParseTreeVisitor<? extends Result> visitor)1254 public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { 1255 if ( visitor instanceof BindingExpressionVisitor<?> ) return ((BindingExpressionVisitor<? extends Result>)visitor).visitLiteral(this); 1256 else return visitor.visitChildren(this); 1257 } 1258 } 1259 1260 @RuleVersion(0) literal()1261 public final LiteralContext literal() throws RecognitionException { 1262 LiteralContext _localctx = new LiteralContext(_ctx, getState()); 1263 enterRule(_localctx, 12, RULE_literal); 1264 try { 1265 setState(154); 1266 switch (_input.LA(1)) { 1267 case IntegerLiteral: 1268 case FloatingPointLiteral: 1269 case BooleanLiteral: 1270 case CharacterLiteral: 1271 case NullLiteral: 1272 enterOuterAlt(_localctx, 1); 1273 { 1274 setState(152); 1275 javaLiteral(); 1276 } 1277 break; 1278 case SingleQuoteString: 1279 case DoubleQuoteString: 1280 enterOuterAlt(_localctx, 2); 1281 { 1282 setState(153); 1283 stringLiteral(); 1284 } 1285 break; 1286 default: 1287 throw new NoViableAltException(this); 1288 } 1289 } 1290 catch (RecognitionException re) { 1291 _localctx.exception = re; 1292 _errHandler.reportError(this, re); 1293 _errHandler.recover(this, re); 1294 } 1295 finally { 1296 exitRule(); 1297 } 1298 return _localctx; 1299 } 1300 1301 public static class IdentifierContext extends ParserRuleContext { Identifier()1302 public TerminalNode Identifier() { return getToken(BindingExpressionParser.Identifier, 0); } IdentifierContext(ParserRuleContext parent, int invokingState)1303 public IdentifierContext(ParserRuleContext parent, int invokingState) { 1304 super(parent, invokingState); 1305 } getRuleIndex()1306 @Override public int getRuleIndex() { return RULE_identifier; } 1307 @Override enterRule(ParseTreeListener listener)1308 public void enterRule(ParseTreeListener listener) { 1309 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterIdentifier(this); 1310 } 1311 @Override exitRule(ParseTreeListener listener)1312 public void exitRule(ParseTreeListener listener) { 1313 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitIdentifier(this); 1314 } 1315 @Override accept(ParseTreeVisitor<? extends Result> visitor)1316 public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { 1317 if ( visitor instanceof BindingExpressionVisitor<?> ) return ((BindingExpressionVisitor<? extends Result>)visitor).visitIdentifier(this); 1318 else return visitor.visitChildren(this); 1319 } 1320 } 1321 1322 @RuleVersion(0) identifier()1323 public final IdentifierContext identifier() throws RecognitionException { 1324 IdentifierContext _localctx = new IdentifierContext(_ctx, getState()); 1325 enterRule(_localctx, 14, RULE_identifier); 1326 try { 1327 enterOuterAlt(_localctx, 1); 1328 { 1329 setState(156); 1330 match(Identifier); 1331 } 1332 } 1333 catch (RecognitionException re) { 1334 _localctx.exception = re; 1335 _errHandler.reportError(this, re); 1336 _errHandler.recover(this, re); 1337 } 1338 finally { 1339 exitRule(); 1340 } 1341 return _localctx; 1342 } 1343 1344 public static class JavaLiteralContext extends ParserRuleContext { IntegerLiteral()1345 public TerminalNode IntegerLiteral() { return getToken(BindingExpressionParser.IntegerLiteral, 0); } FloatingPointLiteral()1346 public TerminalNode FloatingPointLiteral() { return getToken(BindingExpressionParser.FloatingPointLiteral, 0); } BooleanLiteral()1347 public TerminalNode BooleanLiteral() { return getToken(BindingExpressionParser.BooleanLiteral, 0); } NullLiteral()1348 public TerminalNode NullLiteral() { return getToken(BindingExpressionParser.NullLiteral, 0); } CharacterLiteral()1349 public TerminalNode CharacterLiteral() { return getToken(BindingExpressionParser.CharacterLiteral, 0); } JavaLiteralContext(ParserRuleContext parent, int invokingState)1350 public JavaLiteralContext(ParserRuleContext parent, int invokingState) { 1351 super(parent, invokingState); 1352 } getRuleIndex()1353 @Override public int getRuleIndex() { return RULE_javaLiteral; } 1354 @Override enterRule(ParseTreeListener listener)1355 public void enterRule(ParseTreeListener listener) { 1356 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterJavaLiteral(this); 1357 } 1358 @Override exitRule(ParseTreeListener listener)1359 public void exitRule(ParseTreeListener listener) { 1360 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitJavaLiteral(this); 1361 } 1362 @Override accept(ParseTreeVisitor<? extends Result> visitor)1363 public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { 1364 if ( visitor instanceof BindingExpressionVisitor<?> ) return ((BindingExpressionVisitor<? extends Result>)visitor).visitJavaLiteral(this); 1365 else return visitor.visitChildren(this); 1366 } 1367 } 1368 1369 @RuleVersion(0) javaLiteral()1370 public final JavaLiteralContext javaLiteral() throws RecognitionException { 1371 JavaLiteralContext _localctx = new JavaLiteralContext(_ctx, getState()); 1372 enterRule(_localctx, 16, RULE_javaLiteral); 1373 int _la; 1374 try { 1375 enterOuterAlt(_localctx, 1); 1376 { 1377 setState(158); 1378 _la = _input.LA(1); 1379 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << NullLiteral))) != 0)) ) { 1380 _errHandler.recoverInline(this); 1381 } else { 1382 consume(); 1383 } 1384 } 1385 } 1386 catch (RecognitionException re) { 1387 _localctx.exception = re; 1388 _errHandler.reportError(this, re); 1389 _errHandler.recover(this, re); 1390 } 1391 finally { 1392 exitRule(); 1393 } 1394 return _localctx; 1395 } 1396 1397 public static class StringLiteralContext extends ParserRuleContext { SingleQuoteString()1398 public TerminalNode SingleQuoteString() { return getToken(BindingExpressionParser.SingleQuoteString, 0); } DoubleQuoteString()1399 public TerminalNode DoubleQuoteString() { return getToken(BindingExpressionParser.DoubleQuoteString, 0); } StringLiteralContext(ParserRuleContext parent, int invokingState)1400 public StringLiteralContext(ParserRuleContext parent, int invokingState) { 1401 super(parent, invokingState); 1402 } getRuleIndex()1403 @Override public int getRuleIndex() { return RULE_stringLiteral; } 1404 @Override enterRule(ParseTreeListener listener)1405 public void enterRule(ParseTreeListener listener) { 1406 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterStringLiteral(this); 1407 } 1408 @Override exitRule(ParseTreeListener listener)1409 public void exitRule(ParseTreeListener listener) { 1410 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitStringLiteral(this); 1411 } 1412 @Override accept(ParseTreeVisitor<? extends Result> visitor)1413 public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { 1414 if ( visitor instanceof BindingExpressionVisitor<?> ) return ((BindingExpressionVisitor<? extends Result>)visitor).visitStringLiteral(this); 1415 else return visitor.visitChildren(this); 1416 } 1417 } 1418 1419 @RuleVersion(0) stringLiteral()1420 public final StringLiteralContext stringLiteral() throws RecognitionException { 1421 StringLiteralContext _localctx = new StringLiteralContext(_ctx, getState()); 1422 enterRule(_localctx, 18, RULE_stringLiteral); 1423 int _la; 1424 try { 1425 enterOuterAlt(_localctx, 1); 1426 { 1427 setState(160); 1428 _la = _input.LA(1); 1429 if ( !(_la==SingleQuoteString || _la==DoubleQuoteString) ) { 1430 _errHandler.recoverInline(this); 1431 } else { 1432 consume(); 1433 } 1434 } 1435 } 1436 catch (RecognitionException re) { 1437 _localctx.exception = re; 1438 _errHandler.reportError(this, re); 1439 _errHandler.recover(this, re); 1440 } 1441 finally { 1442 exitRule(); 1443 } 1444 return _localctx; 1445 } 1446 1447 public static class ExplicitGenericInvocationContext extends ParserRuleContext { typeArguments()1448 public TypeArgumentsContext typeArguments() { 1449 return getRuleContext(TypeArgumentsContext.class,0); 1450 } explicitGenericInvocationSuffix()1451 public ExplicitGenericInvocationSuffixContext explicitGenericInvocationSuffix() { 1452 return getRuleContext(ExplicitGenericInvocationSuffixContext.class,0); 1453 } ExplicitGenericInvocationContext(ParserRuleContext parent, int invokingState)1454 public ExplicitGenericInvocationContext(ParserRuleContext parent, int invokingState) { 1455 super(parent, invokingState); 1456 } getRuleIndex()1457 @Override public int getRuleIndex() { return RULE_explicitGenericInvocation; } 1458 @Override enterRule(ParseTreeListener listener)1459 public void enterRule(ParseTreeListener listener) { 1460 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterExplicitGenericInvocation(this); 1461 } 1462 @Override exitRule(ParseTreeListener listener)1463 public void exitRule(ParseTreeListener listener) { 1464 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitExplicitGenericInvocation(this); 1465 } 1466 @Override accept(ParseTreeVisitor<? extends Result> visitor)1467 public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { 1468 if ( visitor instanceof BindingExpressionVisitor<?> ) return ((BindingExpressionVisitor<? extends Result>)visitor).visitExplicitGenericInvocation(this); 1469 else return visitor.visitChildren(this); 1470 } 1471 } 1472 1473 @RuleVersion(0) explicitGenericInvocation()1474 public final ExplicitGenericInvocationContext explicitGenericInvocation() throws RecognitionException { 1475 ExplicitGenericInvocationContext _localctx = new ExplicitGenericInvocationContext(_ctx, getState()); 1476 enterRule(_localctx, 20, RULE_explicitGenericInvocation); 1477 try { 1478 enterOuterAlt(_localctx, 1); 1479 { 1480 setState(162); 1481 typeArguments(); 1482 setState(163); 1483 explicitGenericInvocationSuffix(); 1484 } 1485 } 1486 catch (RecognitionException re) { 1487 _localctx.exception = re; 1488 _errHandler.reportError(this, re); 1489 _errHandler.recover(this, re); 1490 } 1491 finally { 1492 exitRule(); 1493 } 1494 return _localctx; 1495 } 1496 1497 public static class TypeArgumentsContext extends ParserRuleContext { type()1498 public List<? extends TypeContext> type() { 1499 return getRuleContexts(TypeContext.class); 1500 } type(int i)1501 public TypeContext type(int i) { 1502 return getRuleContext(TypeContext.class,i); 1503 } TypeArgumentsContext(ParserRuleContext parent, int invokingState)1504 public TypeArgumentsContext(ParserRuleContext parent, int invokingState) { 1505 super(parent, invokingState); 1506 } getRuleIndex()1507 @Override public int getRuleIndex() { return RULE_typeArguments; } 1508 @Override enterRule(ParseTreeListener listener)1509 public void enterRule(ParseTreeListener listener) { 1510 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterTypeArguments(this); 1511 } 1512 @Override exitRule(ParseTreeListener listener)1513 public void exitRule(ParseTreeListener listener) { 1514 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitTypeArguments(this); 1515 } 1516 @Override accept(ParseTreeVisitor<? extends Result> visitor)1517 public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { 1518 if ( visitor instanceof BindingExpressionVisitor<?> ) return ((BindingExpressionVisitor<? extends Result>)visitor).visitTypeArguments(this); 1519 else return visitor.visitChildren(this); 1520 } 1521 } 1522 1523 @RuleVersion(0) typeArguments()1524 public final TypeArgumentsContext typeArguments() throws RecognitionException { 1525 TypeArgumentsContext _localctx = new TypeArgumentsContext(_ctx, getState()); 1526 enterRule(_localctx, 22, RULE_typeArguments); 1527 int _la; 1528 try { 1529 enterOuterAlt(_localctx, 1); 1530 { 1531 setState(165); 1532 match(T__21); 1533 setState(166); 1534 type(); 1535 setState(171); 1536 _errHandler.sync(this); 1537 _la = _input.LA(1); 1538 while (_la==T__0) { 1539 { 1540 { 1541 setState(167); 1542 match(T__0); 1543 setState(168); 1544 type(); 1545 } 1546 } 1547 setState(173); 1548 _errHandler.sync(this); 1549 _la = _input.LA(1); 1550 } 1551 setState(174); 1552 match(T__20); 1553 } 1554 } 1555 catch (RecognitionException re) { 1556 _localctx.exception = re; 1557 _errHandler.reportError(this, re); 1558 _errHandler.recover(this, re); 1559 } 1560 finally { 1561 exitRule(); 1562 } 1563 return _localctx; 1564 } 1565 1566 public static class TypeContext extends ParserRuleContext { classOrInterfaceType()1567 public ClassOrInterfaceTypeContext classOrInterfaceType() { 1568 return getRuleContext(ClassOrInterfaceTypeContext.class,0); 1569 } primitiveType()1570 public PrimitiveTypeContext primitiveType() { 1571 return getRuleContext(PrimitiveTypeContext.class,0); 1572 } TypeContext(ParserRuleContext parent, int invokingState)1573 public TypeContext(ParserRuleContext parent, int invokingState) { 1574 super(parent, invokingState); 1575 } getRuleIndex()1576 @Override public int getRuleIndex() { return RULE_type; } 1577 @Override enterRule(ParseTreeListener listener)1578 public void enterRule(ParseTreeListener listener) { 1579 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterType(this); 1580 } 1581 @Override exitRule(ParseTreeListener listener)1582 public void exitRule(ParseTreeListener listener) { 1583 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitType(this); 1584 } 1585 @Override accept(ParseTreeVisitor<? extends Result> visitor)1586 public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { 1587 if ( visitor instanceof BindingExpressionVisitor<?> ) return ((BindingExpressionVisitor<? extends Result>)visitor).visitType(this); 1588 else return visitor.visitChildren(this); 1589 } 1590 } 1591 1592 @RuleVersion(0) type()1593 public final TypeContext type() throws RecognitionException { 1594 TypeContext _localctx = new TypeContext(_ctx, getState()); 1595 enterRule(_localctx, 24, RULE_type); 1596 try { 1597 int _alt; 1598 setState(192); 1599 switch (_input.LA(1)) { 1600 case Identifier: 1601 enterOuterAlt(_localctx, 1); 1602 { 1603 setState(176); 1604 classOrInterfaceType(); 1605 setState(181); 1606 _errHandler.sync(this); 1607 _alt = getInterpreter().adaptivePredict(_input,10,_ctx); 1608 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1609 if ( _alt==1 ) { 1610 { 1611 { 1612 setState(177); 1613 match(T__6); 1614 setState(178); 1615 match(T__7); 1616 } 1617 } 1618 } 1619 setState(183); 1620 _errHandler.sync(this); 1621 _alt = getInterpreter().adaptivePredict(_input,10,_ctx); 1622 } 1623 } 1624 break; 1625 case T__35: 1626 case T__36: 1627 case T__37: 1628 case T__38: 1629 case T__39: 1630 case T__40: 1631 case T__41: 1632 case T__42: 1633 enterOuterAlt(_localctx, 2); 1634 { 1635 setState(184); 1636 primitiveType(); 1637 setState(189); 1638 _errHandler.sync(this); 1639 _alt = getInterpreter().adaptivePredict(_input,11,_ctx); 1640 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1641 if ( _alt==1 ) { 1642 { 1643 { 1644 setState(185); 1645 match(T__6); 1646 setState(186); 1647 match(T__7); 1648 } 1649 } 1650 } 1651 setState(191); 1652 _errHandler.sync(this); 1653 _alt = getInterpreter().adaptivePredict(_input,11,_ctx); 1654 } 1655 } 1656 break; 1657 default: 1658 throw new NoViableAltException(this); 1659 } 1660 } 1661 catch (RecognitionException re) { 1662 _localctx.exception = re; 1663 _errHandler.reportError(this, re); 1664 _errHandler.recover(this, re); 1665 } 1666 finally { 1667 exitRule(); 1668 } 1669 return _localctx; 1670 } 1671 1672 public static class ExplicitGenericInvocationSuffixContext extends ParserRuleContext { Identifier()1673 public TerminalNode Identifier() { return getToken(BindingExpressionParser.Identifier, 0); } arguments()1674 public ArgumentsContext arguments() { 1675 return getRuleContext(ArgumentsContext.class,0); 1676 } ExplicitGenericInvocationSuffixContext(ParserRuleContext parent, int invokingState)1677 public ExplicitGenericInvocationSuffixContext(ParserRuleContext parent, int invokingState) { 1678 super(parent, invokingState); 1679 } getRuleIndex()1680 @Override public int getRuleIndex() { return RULE_explicitGenericInvocationSuffix; } 1681 @Override enterRule(ParseTreeListener listener)1682 public void enterRule(ParseTreeListener listener) { 1683 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterExplicitGenericInvocationSuffix(this); 1684 } 1685 @Override exitRule(ParseTreeListener listener)1686 public void exitRule(ParseTreeListener listener) { 1687 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitExplicitGenericInvocationSuffix(this); 1688 } 1689 @Override accept(ParseTreeVisitor<? extends Result> visitor)1690 public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { 1691 if ( visitor instanceof BindingExpressionVisitor<?> ) return ((BindingExpressionVisitor<? extends Result>)visitor).visitExplicitGenericInvocationSuffix(this); 1692 else return visitor.visitChildren(this); 1693 } 1694 } 1695 1696 @RuleVersion(0) explicitGenericInvocationSuffix()1697 public final ExplicitGenericInvocationSuffixContext explicitGenericInvocationSuffix() throws RecognitionException { 1698 ExplicitGenericInvocationSuffixContext _localctx = new ExplicitGenericInvocationSuffixContext(_ctx, getState()); 1699 enterRule(_localctx, 26, RULE_explicitGenericInvocationSuffix); 1700 try { 1701 enterOuterAlt(_localctx, 1); 1702 { 1703 setState(194); 1704 match(Identifier); 1705 setState(195); 1706 arguments(); 1707 } 1708 } 1709 catch (RecognitionException re) { 1710 _localctx.exception = re; 1711 _errHandler.reportError(this, re); 1712 _errHandler.recover(this, re); 1713 } 1714 finally { 1715 exitRule(); 1716 } 1717 return _localctx; 1718 } 1719 1720 public static class ArgumentsContext extends ParserRuleContext { expressionList()1721 public ExpressionListContext expressionList() { 1722 return getRuleContext(ExpressionListContext.class,0); 1723 } ArgumentsContext(ParserRuleContext parent, int invokingState)1724 public ArgumentsContext(ParserRuleContext parent, int invokingState) { 1725 super(parent, invokingState); 1726 } getRuleIndex()1727 @Override public int getRuleIndex() { return RULE_arguments; } 1728 @Override enterRule(ParseTreeListener listener)1729 public void enterRule(ParseTreeListener listener) { 1730 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterArguments(this); 1731 } 1732 @Override exitRule(ParseTreeListener listener)1733 public void exitRule(ParseTreeListener listener) { 1734 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitArguments(this); 1735 } 1736 @Override accept(ParseTreeVisitor<? extends Result> visitor)1737 public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { 1738 if ( visitor instanceof BindingExpressionVisitor<?> ) return ((BindingExpressionVisitor<? extends Result>)visitor).visitArguments(this); 1739 else return visitor.visitChildren(this); 1740 } 1741 } 1742 1743 @RuleVersion(0) arguments()1744 public final ArgumentsContext arguments() throws RecognitionException { 1745 ArgumentsContext _localctx = new ArgumentsContext(_ctx, getState()); 1746 enterRule(_localctx, 28, RULE_arguments); 1747 int _la; 1748 try { 1749 enterOuterAlt(_localctx, 1); 1750 { 1751 setState(197); 1752 match(T__3); 1753 setState(199); 1754 _la = _input.LA(1); 1755 if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__3) | (1L << T__8) | (1L << T__9) | (1L << T__10) | (1L << T__11) | (1L << T__34) | (1L << T__35) | (1L << T__36) | (1L << T__37) | (1L << T__38) | (1L << T__39) | (1L << T__40) | (1L << T__41) | (1L << T__42) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << SingleQuoteString) | (1L << DoubleQuoteString) | (1L << NullLiteral) | (1L << Identifier) | (1L << ResourceReference))) != 0)) { 1756 { 1757 setState(198); 1758 expressionList(); 1759 } 1760 } 1761 1762 setState(201); 1763 match(T__4); 1764 } 1765 } 1766 catch (RecognitionException re) { 1767 _localctx.exception = re; 1768 _errHandler.reportError(this, re); 1769 _errHandler.recover(this, re); 1770 } 1771 finally { 1772 exitRule(); 1773 } 1774 return _localctx; 1775 } 1776 1777 public static class ClassOrInterfaceTypeContext extends ParserRuleContext { identifier()1778 public IdentifierContext identifier() { 1779 return getRuleContext(IdentifierContext.class,0); 1780 } typeArguments()1781 public List<? extends TypeArgumentsContext> typeArguments() { 1782 return getRuleContexts(TypeArgumentsContext.class); 1783 } typeArguments(int i)1784 public TypeArgumentsContext typeArguments(int i) { 1785 return getRuleContext(TypeArgumentsContext.class,i); 1786 } Identifier()1787 public List<? extends TerminalNode> Identifier() { return getTokens(BindingExpressionParser.Identifier); } Identifier(int i)1788 public TerminalNode Identifier(int i) { 1789 return getToken(BindingExpressionParser.Identifier, i); 1790 } ClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState)1791 public ClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) { 1792 super(parent, invokingState); 1793 } getRuleIndex()1794 @Override public int getRuleIndex() { return RULE_classOrInterfaceType; } 1795 @Override enterRule(ParseTreeListener listener)1796 public void enterRule(ParseTreeListener listener) { 1797 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterClassOrInterfaceType(this); 1798 } 1799 @Override exitRule(ParseTreeListener listener)1800 public void exitRule(ParseTreeListener listener) { 1801 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitClassOrInterfaceType(this); 1802 } 1803 @Override accept(ParseTreeVisitor<? extends Result> visitor)1804 public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { 1805 if ( visitor instanceof BindingExpressionVisitor<?> ) return ((BindingExpressionVisitor<? extends Result>)visitor).visitClassOrInterfaceType(this); 1806 else return visitor.visitChildren(this); 1807 } 1808 } 1809 1810 @RuleVersion(0) classOrInterfaceType()1811 public final ClassOrInterfaceTypeContext classOrInterfaceType() throws RecognitionException { 1812 ClassOrInterfaceTypeContext _localctx = new ClassOrInterfaceTypeContext(_ctx, getState()); 1813 enterRule(_localctx, 30, RULE_classOrInterfaceType); 1814 try { 1815 int _alt; 1816 enterOuterAlt(_localctx, 1); 1817 { 1818 setState(203); 1819 identifier(); 1820 setState(205); 1821 switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) { 1822 case 1: 1823 { 1824 setState(204); 1825 typeArguments(); 1826 } 1827 break; 1828 } 1829 setState(214); 1830 _errHandler.sync(this); 1831 _alt = getInterpreter().adaptivePredict(_input,16,_ctx); 1832 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1833 if ( _alt==1 ) { 1834 { 1835 { 1836 setState(207); 1837 match(T__5); 1838 setState(208); 1839 match(Identifier); 1840 setState(210); 1841 switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) { 1842 case 1: 1843 { 1844 setState(209); 1845 typeArguments(); 1846 } 1847 break; 1848 } 1849 } 1850 } 1851 } 1852 setState(216); 1853 _errHandler.sync(this); 1854 _alt = getInterpreter().adaptivePredict(_input,16,_ctx); 1855 } 1856 } 1857 } 1858 catch (RecognitionException re) { 1859 _localctx.exception = re; 1860 _errHandler.reportError(this, re); 1861 _errHandler.recover(this, re); 1862 } 1863 finally { 1864 exitRule(); 1865 } 1866 return _localctx; 1867 } 1868 1869 public static class PrimitiveTypeContext extends ParserRuleContext { PrimitiveTypeContext(ParserRuleContext parent, int invokingState)1870 public PrimitiveTypeContext(ParserRuleContext parent, int invokingState) { 1871 super(parent, invokingState); 1872 } getRuleIndex()1873 @Override public int getRuleIndex() { return RULE_primitiveType; } 1874 @Override enterRule(ParseTreeListener listener)1875 public void enterRule(ParseTreeListener listener) { 1876 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterPrimitiveType(this); 1877 } 1878 @Override exitRule(ParseTreeListener listener)1879 public void exitRule(ParseTreeListener listener) { 1880 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitPrimitiveType(this); 1881 } 1882 @Override accept(ParseTreeVisitor<? extends Result> visitor)1883 public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { 1884 if ( visitor instanceof BindingExpressionVisitor<?> ) return ((BindingExpressionVisitor<? extends Result>)visitor).visitPrimitiveType(this); 1885 else return visitor.visitChildren(this); 1886 } 1887 } 1888 1889 @RuleVersion(0) primitiveType()1890 public final PrimitiveTypeContext primitiveType() throws RecognitionException { 1891 PrimitiveTypeContext _localctx = new PrimitiveTypeContext(_ctx, getState()); 1892 enterRule(_localctx, 32, RULE_primitiveType); 1893 int _la; 1894 try { 1895 enterOuterAlt(_localctx, 1); 1896 { 1897 setState(217); 1898 _la = _input.LA(1); 1899 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__35) | (1L << T__36) | (1L << T__37) | (1L << T__38) | (1L << T__39) | (1L << T__40) | (1L << T__41) | (1L << T__42))) != 0)) ) { 1900 _errHandler.recoverInline(this); 1901 } else { 1902 consume(); 1903 } 1904 } 1905 } 1906 catch (RecognitionException re) { 1907 _localctx.exception = re; 1908 _errHandler.reportError(this, re); 1909 _errHandler.recover(this, re); 1910 } 1911 finally { 1912 exitRule(); 1913 } 1914 return _localctx; 1915 } 1916 1917 public static class ResourcesContext extends ParserRuleContext { ResourceReference()1918 public TerminalNode ResourceReference() { return getToken(BindingExpressionParser.ResourceReference, 0); } resourceParameters()1919 public ResourceParametersContext resourceParameters() { 1920 return getRuleContext(ResourceParametersContext.class,0); 1921 } ResourcesContext(ParserRuleContext parent, int invokingState)1922 public ResourcesContext(ParserRuleContext parent, int invokingState) { 1923 super(parent, invokingState); 1924 } getRuleIndex()1925 @Override public int getRuleIndex() { return RULE_resources; } 1926 @Override enterRule(ParseTreeListener listener)1927 public void enterRule(ParseTreeListener listener) { 1928 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterResources(this); 1929 } 1930 @Override exitRule(ParseTreeListener listener)1931 public void exitRule(ParseTreeListener listener) { 1932 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitResources(this); 1933 } 1934 @Override accept(ParseTreeVisitor<? extends Result> visitor)1935 public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { 1936 if ( visitor instanceof BindingExpressionVisitor<?> ) return ((BindingExpressionVisitor<? extends Result>)visitor).visitResources(this); 1937 else return visitor.visitChildren(this); 1938 } 1939 } 1940 1941 @RuleVersion(0) resources()1942 public final ResourcesContext resources() throws RecognitionException { 1943 ResourcesContext _localctx = new ResourcesContext(_ctx, getState()); 1944 enterRule(_localctx, 34, RULE_resources); 1945 try { 1946 enterOuterAlt(_localctx, 1); 1947 { 1948 setState(219); 1949 match(ResourceReference); 1950 setState(221); 1951 switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) { 1952 case 1: 1953 { 1954 setState(220); 1955 resourceParameters(); 1956 } 1957 break; 1958 } 1959 } 1960 } 1961 catch (RecognitionException re) { 1962 _localctx.exception = re; 1963 _errHandler.reportError(this, re); 1964 _errHandler.recover(this, re); 1965 } 1966 finally { 1967 exitRule(); 1968 } 1969 return _localctx; 1970 } 1971 1972 public static class ResourceParametersContext extends ParserRuleContext { expressionList()1973 public ExpressionListContext expressionList() { 1974 return getRuleContext(ExpressionListContext.class,0); 1975 } ResourceParametersContext(ParserRuleContext parent, int invokingState)1976 public ResourceParametersContext(ParserRuleContext parent, int invokingState) { 1977 super(parent, invokingState); 1978 } getRuleIndex()1979 @Override public int getRuleIndex() { return RULE_resourceParameters; } 1980 @Override enterRule(ParseTreeListener listener)1981 public void enterRule(ParseTreeListener listener) { 1982 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterResourceParameters(this); 1983 } 1984 @Override exitRule(ParseTreeListener listener)1985 public void exitRule(ParseTreeListener listener) { 1986 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitResourceParameters(this); 1987 } 1988 @Override accept(ParseTreeVisitor<? extends Result> visitor)1989 public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { 1990 if ( visitor instanceof BindingExpressionVisitor<?> ) return ((BindingExpressionVisitor<? extends Result>)visitor).visitResourceParameters(this); 1991 else return visitor.visitChildren(this); 1992 } 1993 } 1994 1995 @RuleVersion(0) resourceParameters()1996 public final ResourceParametersContext resourceParameters() throws RecognitionException { 1997 ResourceParametersContext _localctx = new ResourceParametersContext(_ctx, getState()); 1998 enterRule(_localctx, 36, RULE_resourceParameters); 1999 try { 2000 enterOuterAlt(_localctx, 1); 2001 { 2002 setState(223); 2003 match(T__3); 2004 setState(224); 2005 expressionList(); 2006 setState(225); 2007 match(T__4); 2008 } 2009 } 2010 catch (RecognitionException re) { 2011 _localctx.exception = re; 2012 _errHandler.reportError(this, re); 2013 _errHandler.recover(this, re); 2014 } 2015 finally { 2016 exitRule(); 2017 } 2018 return _localctx; 2019 } 2020 sempred(RuleContext _localctx, int ruleIndex, int predIndex)2021 public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { 2022 switch (ruleIndex) { 2023 case 3: 2024 return expression_sempred((ExpressionContext)_localctx, predIndex); 2025 } 2026 return true; 2027 } expression_sempred(ExpressionContext _localctx, int predIndex)2028 private boolean expression_sempred(ExpressionContext _localctx, int predIndex) { 2029 switch (predIndex) { 2030 case 0: 2031 return precpred(_ctx, 13); 2032 2033 case 1: 2034 return precpred(_ctx, 12); 2035 2036 case 2: 2037 return precpred(_ctx, 11); 2038 2039 case 3: 2040 return precpred(_ctx, 10); 2041 2042 case 4: 2043 return precpred(_ctx, 8); 2044 2045 case 5: 2046 return precpred(_ctx, 7); 2047 2048 case 6: 2049 return precpred(_ctx, 6); 2050 2051 case 7: 2052 return precpred(_ctx, 5); 2053 2054 case 8: 2055 return precpred(_ctx, 4); 2056 2057 case 9: 2058 return precpred(_ctx, 3); 2059 2060 case 10: 2061 return precpred(_ctx, 2); 2062 2063 case 11: 2064 return precpred(_ctx, 1); 2065 2066 case 12: 2067 return precpred(_ctx, 19); 2068 2069 case 13: 2070 return precpred(_ctx, 18); 2071 2072 case 14: 2073 return precpred(_ctx, 17); 2074 2075 case 15: 2076 return precpred(_ctx, 9); 2077 } 2078 return true; 2079 } 2080 2081 public static final String _serializedATN = 2082 "\3\uaf6f\u8320\u479d\ub75c\u4880\u1605\u191c\uab37\3:\u00e6\4\2\t\2\4"+ 2083 "\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+ 2084 "\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+ 2085 "\4\23\t\23\4\24\t\24\3\2\3\2\5\2+\n\2\3\3\3\3\3\3\3\3\3\3\3\4\3\4\3\4"+ 2086 "\5\4\65\n\4\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3"+ 2087 "\5\3\5\3\5\3\5\5\5I\n\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3"+ 2088 "\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5"+ 2089 "\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3"+ 2090 "\5\3\5\3\5\3\5\3\5\3\5\5\5\177\n\5\3\5\3\5\3\5\3\5\7\5\u0085\n\5\f\5\16"+ 2091 "\5\u0088\13\5\3\6\3\6\3\6\3\6\3\6\3\6\3\6\5\6\u0091\n\6\3\7\3\7\3\7\7"+ 2092 "\7\u0096\n\7\f\7\16\7\u0099\13\7\3\b\3\b\5\b\u009d\n\b\3\t\3\t\3\n\3\n"+ 2093 "\3\13\3\13\3\f\3\f\3\f\3\r\3\r\3\r\3\r\7\r\u00ac\n\r\f\r\16\r\u00af\13"+ 2094 "\r\3\r\3\r\3\16\3\16\3\16\7\16\u00b6\n\16\f\16\16\16\u00b9\13\16\3\16"+ 2095 "\3\16\3\16\7\16\u00be\n\16\f\16\16\16\u00c1\13\16\5\16\u00c3\n\16\3\17"+ 2096 "\3\17\3\17\3\20\3\20\5\20\u00ca\n\20\3\20\3\20\3\21\3\21\5\21\u00d0\n"+ 2097 "\21\3\21\3\21\3\21\5\21\u00d5\n\21\7\21\u00d7\n\21\f\21\16\21\u00da\13"+ 2098 "\21\3\22\3\22\3\23\3\23\5\23\u00e0\n\23\3\24\3\24\3\24\3\24\3\24\2\2\3"+ 2099 "\b\25\2\2\4\2\6\2\b\2\n\2\f\2\16\2\20\2\22\2\24\2\26\2\30\2\32\2\34\2"+ 2100 "\36\2 \2\"\2$\2&\2\2\13\3\2\13\f\3\2\r\16\3\2\17\21\3\2\22\24\3\2\25\30"+ 2101 "\3\2\32\33\4\2/\62\65\65\3\2\63\64\3\2&-\u00f9\2(\3\2\2\2\4,\3\2\2\2\6"+ 2102 "\64\3\2\2\2\bH\3\2\2\2\n\u0090\3\2\2\2\f\u0092\3\2\2\2\16\u009c\3\2\2"+ 2103 "\2\20\u009e\3\2\2\2\22\u00a0\3\2\2\2\24\u00a2\3\2\2\2\26\u00a4\3\2\2\2"+ 2104 "\30\u00a7\3\2\2\2\32\u00c2\3\2\2\2\34\u00c4\3\2\2\2\36\u00c7\3\2\2\2 "+ 2105 "\u00cd\3\2\2\2\"\u00db\3\2\2\2$\u00dd\3\2\2\2&\u00e1\3\2\2\2(*\5\b\5\2"+ 2106 ")+\5\4\3\2*)\3\2\2\2*+\3\2\2\2+\3\3\2\2\2,-\7\3\2\2-.\7\4\2\2./\7\5\2"+ 2107 "\2/\60\5\6\4\2\60\5\3\2\2\2\61\65\5\16\b\2\62\65\78\2\2\63\65\5\20\t\2"+ 2108 "\64\61\3\2\2\2\64\62\3\2\2\2\64\63\3\2\2\2\65\7\3\2\2\2\66\67\b\5\1\2"+ 2109 "\678\7\6\2\289\5\32\16\29:\7\7\2\2:;\5\b\5\22;I\3\2\2\2<=\t\2\2\2=I\5"+ 2110 "\b\5\21>?\t\3\2\2?I\5\b\5\20@A\7\6\2\2AB\5\b\5\2BC\7\7\2\2CI\3\2\2\2D"+ 2111 "I\5\16\b\2EI\5\20\t\2FI\5\n\6\2GI\5$\23\2H\66\3\2\2\2H<\3\2\2\2H>\3\2"+ 2112 "\2\2H@\3\2\2\2HD\3\2\2\2HE\3\2\2\2HF\3\2\2\2HG\3\2\2\2I\u0086\3\2\2\2"+ 2113 "JK\f\17\2\2KL\t\4\2\2L\u0085\5\b\5\20MN\f\16\2\2NO\t\2\2\2O\u0085\5\b"+ 2114 "\5\17PQ\f\r\2\2QR\t\5\2\2R\u0085\5\b\5\16ST\f\f\2\2TU\t\6\2\2U\u0085\5"+ 2115 "\b\5\rVW\f\n\2\2WX\t\7\2\2X\u0085\5\b\5\13YZ\f\t\2\2Z[\7\34\2\2[\u0085"+ 2116 "\5\b\5\n\\]\f\b\2\2]^\7\35\2\2^\u0085\5\b\5\t_`\f\7\2\2`a\7\36\2\2a\u0085"+ 2117 "\5\b\5\bbc\f\6\2\2cd\7\37\2\2d\u0085\5\b\5\7ef\f\5\2\2fg\7 \2\2g\u0085"+ 2118 "\5\b\5\6hi\f\4\2\2ij\7!\2\2jk\5\b\5\2kl\7\"\2\2lm\5\b\5\4m\u0085\3\2\2"+ 2119 "\2no\f\3\2\2op\7#\2\2p\u0085\5\b\5\4qr\f\25\2\2rs\7\b\2\2s\u0085\7\66"+ 2120 "\2\2tu\f\24\2\2uv\7\t\2\2vw\5\b\5\2wx\7\n\2\2x\u0085\3\2\2\2yz\f\23\2"+ 2121 "\2z{\7\b\2\2{|\7\66\2\2|~\7\6\2\2}\177\5\f\7\2~}\3\2\2\2~\177\3\2\2\2"+ 2122 "\177\u0080\3\2\2\2\u0080\u0085\7\7\2\2\u0081\u0082\f\13\2\2\u0082\u0083"+ 2123 "\7\31\2\2\u0083\u0085\5\32\16\2\u0084J\3\2\2\2\u0084M\3\2\2\2\u0084P\3"+ 2124 "\2\2\2\u0084S\3\2\2\2\u0084V\3\2\2\2\u0084Y\3\2\2\2\u0084\\\3\2\2\2\u0084"+ 2125 "_\3\2\2\2\u0084b\3\2\2\2\u0084e\3\2\2\2\u0084h\3\2\2\2\u0084n\3\2\2\2"+ 2126 "\u0084q\3\2\2\2\u0084t\3\2\2\2\u0084y\3\2\2\2\u0084\u0081\3\2\2\2\u0085"+ 2127 "\u0088\3\2\2\2\u0086\u0084\3\2\2\2\u0086\u0087\3\2\2\2\u0087\t\3\2\2\2"+ 2128 "\u0088\u0086\3\2\2\2\u0089\u008a\5\32\16\2\u008a\u008b\7\b\2\2\u008b\u008c"+ 2129 "\7$\2\2\u008c\u0091\3\2\2\2\u008d\u008e\7%\2\2\u008e\u008f\7\b\2\2\u008f"+ 2130 "\u0091\7$\2\2\u0090\u0089\3\2\2\2\u0090\u008d\3\2\2\2\u0091\13\3\2\2\2"+ 2131 "\u0092\u0097\5\b\5\2\u0093\u0094\7\3\2\2\u0094\u0096\5\b\5\2\u0095\u0093"+ 2132 "\3\2\2\2\u0096\u0099\3\2\2\2\u0097\u0095\3\2\2\2\u0097\u0098\3\2\2\2\u0098"+ 2133 "\r\3\2\2\2\u0099\u0097\3\2\2\2\u009a\u009d\5\22\n\2\u009b\u009d\5\24\13"+ 2134 "\2\u009c\u009a\3\2\2\2\u009c\u009b\3\2\2\2\u009d\17\3\2\2\2\u009e\u009f"+ 2135 "\7\66\2\2\u009f\21\3\2\2\2\u00a0\u00a1\t\b\2\2\u00a1\23\3\2\2\2\u00a2"+ 2136 "\u00a3\t\t\2\2\u00a3\25\3\2\2\2\u00a4\u00a5\5\30\r\2\u00a5\u00a6\5\34"+ 2137 "\17\2\u00a6\27\3\2\2\2\u00a7\u00a8\7\30\2\2\u00a8\u00ad\5\32\16\2\u00a9"+ 2138 "\u00aa\7\3\2\2\u00aa\u00ac\5\32\16\2\u00ab\u00a9\3\2\2\2\u00ac\u00af\3"+ 2139 "\2\2\2\u00ad\u00ab\3\2\2\2\u00ad\u00ae\3\2\2\2\u00ae\u00b0\3\2\2\2\u00af"+ 2140 "\u00ad\3\2\2\2\u00b0\u00b1\7\27\2\2\u00b1\31\3\2\2\2\u00b2\u00b7\5 \21"+ 2141 "\2\u00b3\u00b4\7\t\2\2\u00b4\u00b6\7\n\2\2\u00b5\u00b3\3\2\2\2\u00b6\u00b9"+ 2142 "\3\2\2\2\u00b7\u00b5\3\2\2\2\u00b7\u00b8\3\2\2\2\u00b8\u00c3\3\2\2\2\u00b9"+ 2143 "\u00b7\3\2\2\2\u00ba\u00bf\5\"\22\2\u00bb\u00bc\7\t\2\2\u00bc\u00be\7"+ 2144 "\n\2\2\u00bd\u00bb\3\2\2\2\u00be\u00c1\3\2\2\2\u00bf\u00bd\3\2\2\2\u00bf"+ 2145 "\u00c0\3\2\2\2\u00c0\u00c3\3\2\2\2\u00c1\u00bf\3\2\2\2\u00c2\u00b2\3\2"+ 2146 "\2\2\u00c2\u00ba\3\2\2\2\u00c3\33\3\2\2\2\u00c4\u00c5\7\66\2\2\u00c5\u00c6"+ 2147 "\5\36\20\2\u00c6\35\3\2\2\2\u00c7\u00c9\7\6\2\2\u00c8\u00ca\5\f\7\2\u00c9"+ 2148 "\u00c8\3\2\2\2\u00c9\u00ca\3\2\2\2\u00ca\u00cb\3\2\2\2\u00cb\u00cc\7\7"+ 2149 "\2\2\u00cc\37\3\2\2\2\u00cd\u00cf\5\20\t\2\u00ce\u00d0\5\30\r\2\u00cf"+ 2150 "\u00ce\3\2\2\2\u00cf\u00d0\3\2\2\2\u00d0\u00d8\3\2\2\2\u00d1\u00d2\7\b"+ 2151 "\2\2\u00d2\u00d4\7\66\2\2\u00d3\u00d5\5\30\r\2\u00d4\u00d3\3\2\2\2\u00d4"+ 2152 "\u00d5\3\2\2\2\u00d5\u00d7\3\2\2\2\u00d6\u00d1\3\2\2\2\u00d7\u00da\3\2"+ 2153 "\2\2\u00d8\u00d6\3\2\2\2\u00d8\u00d9\3\2\2\2\u00d9!\3\2\2\2\u00da\u00d8"+ 2154 "\3\2\2\2\u00db\u00dc\t\n\2\2\u00dc#\3\2\2\2\u00dd\u00df\78\2\2\u00de\u00e0"+ 2155 "\5&\24\2\u00df\u00de\3\2\2\2\u00df\u00e0\3\2\2\2\u00e0%\3\2\2\2\u00e1"+ 2156 "\u00e2\7\6\2\2\u00e2\u00e3\5\f\7\2\u00e3\u00e4\7\7\2\2\u00e4\'\3\2\2\2"+ 2157 "\24*\64H~\u0084\u0086\u0090\u0097\u009c\u00ad\u00b7\u00bf\u00c2\u00c9"+ 2158 "\u00cf\u00d4\u00d8\u00df"; 2159 public static final ATN _ATN = 2160 new ATNDeserializer().deserialize(_serializedATN.toCharArray()); 2161 static { 2162 } 2163 }