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