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