Debian Codegraph @

compilerCommon/src/main/grammar-gen/android/databinding/parser/BindingExpressionParser.java

raw
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
85 public String[] getTokenNames() {
86 return tokenNames;
87 }
88
89 @Override
90
91 public Vocabulary getVocabulary() {
92 return VOCABULARY;
93 }
94
95 @Override
96 public String getGrammarFileName() { return "BindingExpression.g4"; }
97
98 @Override
99 public String[] getRuleNames() { return ruleNames; }
100
101 @Override
102 public String getSerializedATN() { return _serializedATN; }
103
104 @Override
105 public ATN getATN() { return _ATN; }
106
107 public BindingExpressionParser(TokenStream input) {
108 super(input);
109 _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
110 }
111 public static class BindingSyntaxContext extends ParserRuleContext {
112 public BindingSyntaxContext(ParserRuleContext parent, int invokingState) {
113 super(parent, invokingState);
114 }
115 @Override public int getRuleIndex() { return RULE_bindingSyntax; }
116
117 public BindingSyntaxContext() { }
118 public void copyFrom(BindingSyntaxContext ctx) {
119 super.copyFrom(ctx);
120 }
121 }
122 public static class RootExprContext extends BindingSyntaxContext {
123 public ExpressionContext expression() {
124 return getRuleContext(ExpressionContext.class,0);
125 }
126 public DefaultsContext defaults() {
127 return getRuleContext(DefaultsContext.class,0);
128 }
129 public RootExprContext(BindingSyntaxContext ctx) { copyFrom(ctx); }
130 @Override
131 public void enterRule(ParseTreeListener listener) {
132 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterRootExpr(this);
133 }
134 @Override
135 public void exitRule(ParseTreeListener listener) {
136 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitRootExpr(this);
137 }
138 @Override
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 {
145 public LambdaExpressionContext lambdaExpression() {
146 return getRuleContext(LambdaExpressionContext.class,0);
147 }
148 public RootLambdaContext(BindingSyntaxContext ctx) { copyFrom(ctx); }
149 @Override
150 public void enterRule(ParseTreeListener listener) {
151 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterRootLambda(this);
152 }
153 @Override
154 public void exitRule(ParseTreeListener listener) {
155 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitRootLambda(this);
156 }
157 @Override
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
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 {
211 public ConstantValueContext constantValue() {
212 return getRuleContext(ConstantValueContext.class,0);
213 }
214 public DefaultsContext(ParserRuleContext parent, int invokingState) {
215 super(parent, invokingState);
216 }
217 @Override public int getRuleIndex() { return RULE_defaults; }
218 @Override
219 public void enterRule(ParseTreeListener listener) {
220 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterDefaults(this);
221 }
222 @Override
223 public void exitRule(ParseTreeListener listener) {
224 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitDefaults(this);
225 }
226 @Override
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
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 {
261 public LiteralContext literal() {
262 return getRuleContext(LiteralContext.class,0);
263 }
264 public TerminalNode ResourceReference() { return getToken(BindingExpressionParser.ResourceReference, 0); }
265 public IdentifierContext identifier() {
266 return getRuleContext(IdentifierContext.class,0);
267 }
268 public ConstantValueContext(ParserRuleContext parent, int invokingState) {
269 super(parent, invokingState);
270 }
271 @Override public int getRuleIndex() { return RULE_constantValue; }
272 @Override
273 public void enterRule(ParseTreeListener listener) {
274 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterConstantValue(this);
275 }
276 @Override
277 public void exitRule(ParseTreeListener listener) {
278 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitConstantValue(this);
279 }
280 @Override
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
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;
338 public LambdaParametersContext lambdaParameters() {
339 return getRuleContext(LambdaParametersContext.class,0);
340 }
341 public ExpressionContext expression() {
342 return getRuleContext(ExpressionContext.class,0);
343 }
344 public LambdaExpressionContext(ParserRuleContext parent, int invokingState) {
345 super(parent, invokingState);
346 }
347 @Override public int getRuleIndex() { return RULE_lambdaExpression; }
348 @Override
349 public void enterRule(ParseTreeListener listener) {
350 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterLambdaExpression(this);
351 }
352 @Override
353 public void exitRule(ParseTreeListener listener) {
354 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitLambdaExpression(this);
355 }
356 @Override
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
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 {
389 public LambdaParametersContext(ParserRuleContext parent, int invokingState) {
390 super(parent, invokingState);
391 }
392 @Override public int getRuleIndex() { return RULE_lambdaParameters; }
393
394 public LambdaParametersContext() { }
395 public void copyFrom(LambdaParametersContext ctx) {
396 super.copyFrom(ctx);
397 }
398 }
399 public static class SingleLambdaParameterContext extends LambdaParametersContext {
400 public TerminalNode Identifier() { return getToken(BindingExpressionParser.Identifier, 0); }
401 public SingleLambdaParameterContext(LambdaParametersContext ctx) { copyFrom(ctx); }
402 @Override
403 public void enterRule(ParseTreeListener listener) {
404 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterSingleLambdaParameter(this);
405 }
406 @Override
407 public void exitRule(ParseTreeListener listener) {
408 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitSingleLambdaParameter(this);
409 }
410 @Override
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;
418 public InferredFormalParameterListContext inferredFormalParameterList() {
419 return getRuleContext(InferredFormalParameterListContext.class,0);
420 }
421 public LambdaParameterListContext(LambdaParametersContext ctx) { copyFrom(ctx); }
422 @Override
423 public void enterRule(ParseTreeListener listener) {
424 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterLambdaParameterList(this);
425 }
426 @Override
427 public void exitRule(ParseTreeListener listener) {
428 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitLambdaParameterList(this);
429 }
430 @Override
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
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 {
487 public List<TerminalNode> Identifier() { return getTokens(BindingExpressionParser.Identifier); }
488 public TerminalNode Identifier(int i) {
489 return getToken(BindingExpressionParser.Identifier, i);
490 }
491 public InferredFormalParameterListContext(ParserRuleContext parent, int invokingState) {
492 super(parent, invokingState);
493 }
494 @Override public int getRuleIndex() { return RULE_inferredFormalParameterList; }
495 @Override
496 public void enterRule(ParseTreeListener listener) {
497 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterInferredFormalParameterList(this);
498 }
499 @Override
500 public void exitRule(ParseTreeListener listener) {
501 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitInferredFormalParameterList(this);
502 }
503 @Override
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
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 {
549 public ExpressionContext(ParserRuleContext parent, int invokingState) {
550 super(parent, invokingState);
551 }
552 @Override public int getRuleIndex() { return RULE_expression; }
553
554 public ExpressionContext() { }
555 public void copyFrom(ExpressionContext ctx) {
556 super.copyFrom(ctx);
557 }
558 }
559 public static class CastOpContext extends ExpressionContext {
560 public TypeContext type() {
561 return getRuleContext(TypeContext.class,0);
562 }
563 public ExpressionContext expression() {
564 return getRuleContext(ExpressionContext.class,0);
565 }
566 public CastOpContext(ExpressionContext ctx) { copyFrom(ctx); }
567 @Override
568 public void enterRule(ParseTreeListener listener) {
569 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterCastOp(this);
570 }
571 @Override
572 public void exitRule(ParseTreeListener listener) {
573 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitCastOp(this);
574 }
575 @Override
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;
585 public List<ExpressionContext> expression() {
586 return getRuleContexts(ExpressionContext.class);
587 }
588 public ExpressionContext expression(int i) {
589 return getRuleContext(ExpressionContext.class,i);
590 }
591 public ComparisonOpContext(ExpressionContext ctx) { copyFrom(ctx); }
592 @Override
593 public void enterRule(ParseTreeListener listener) {
594 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterComparisonOp(this);
595 }
596 @Override
597 public void exitRule(ParseTreeListener listener) {
598 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitComparisonOp(this);
599 }
600 @Override
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;
608 public ExpressionContext expression() {
609 return getRuleContext(ExpressionContext.class,0);
610 }
611 public UnaryOpContext(ExpressionContext ctx) { copyFrom(ctx); }
612 @Override
613 public void enterRule(ParseTreeListener listener) {
614 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterUnaryOp(this);
615 }
616 @Override
617 public void exitRule(ParseTreeListener listener) {
618 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitUnaryOp(this);
619 }
620 @Override
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 {
627 public List<ExpressionContext> expression() {
628 return getRuleContexts(ExpressionContext.class);
629 }
630 public ExpressionContext expression(int i) {
631 return getRuleContext(ExpressionContext.class,i);
632 }
633 public BracketOpContext(ExpressionContext ctx) { copyFrom(ctx); }
634 @Override
635 public void enterRule(ParseTreeListener listener) {
636 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterBracketOp(this);
637 }
638 @Override
639 public void exitRule(ParseTreeListener listener) {
640 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitBracketOp(this);
641 }
642 @Override
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 {
649 public ResourcesContext resources() {
650 return getRuleContext(ResourcesContext.class,0);
651 }
652 public ResourceContext(ExpressionContext ctx) { copyFrom(ctx); }
653 @Override
654 public void enterRule(ParseTreeListener listener) {
655 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterResource(this);
656 }
657 @Override
658 public void exitRule(ParseTreeListener listener) {
659 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitResource(this);
660 }
661 @Override
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;
671 public List<ExpressionContext> expression() {
672 return getRuleContexts(ExpressionContext.class);
673 }
674 public ExpressionContext expression(int i) {
675 return getRuleContext(ExpressionContext.class,i);
676 }
677 public QuestionQuestionOpContext(ExpressionContext ctx) { copyFrom(ctx); }
678 @Override
679 public void enterRule(ParseTreeListener listener) {
680 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterQuestionQuestionOp(this);
681 }
682 @Override
683 public void exitRule(ParseTreeListener listener) {
684 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitQuestionQuestionOp(this);
685 }
686 @Override
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 {
693 public ExpressionContext expression() {
694 return getRuleContext(ExpressionContext.class,0);
695 }
696 public GroupingContext(ExpressionContext ctx) { copyFrom(ctx); }
697 @Override
698 public void enterRule(ParseTreeListener listener) {
699 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterGrouping(this);
700 }
701 @Override
702 public void exitRule(ParseTreeListener listener) {
703 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitGrouping(this);
704 }
705 @Override
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;
715 public ExpressionContext expression() {
716 return getRuleContext(ExpressionContext.class,0);
717 }
718 public TerminalNode Identifier() { return getToken(BindingExpressionParser.Identifier, 0); }
719 public ExpressionListContext expressionList() {
720 return getRuleContext(ExpressionListContext.class,0);
721 }
722 public MethodInvocationContext(ExpressionContext ctx) { copyFrom(ctx); }
723 @Override
724 public void enterRule(ParseTreeListener listener) {
725 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterMethodInvocation(this);
726 }
727 @Override
728 public void exitRule(ParseTreeListener listener) {
729 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitMethodInvocation(this);
730 }
731 @Override
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;
741 public List<ExpressionContext> expression() {
742 return getRuleContexts(ExpressionContext.class);
743 }
744 public ExpressionContext expression(int i) {
745 return getRuleContext(ExpressionContext.class,i);
746 }
747 public BitShiftOpContext(ExpressionContext ctx) { copyFrom(ctx); }
748 @Override
749 public void enterRule(ParseTreeListener listener) {
750 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterBitShiftOp(this);
751 }
752 @Override
753 public void exitRule(ParseTreeListener listener) {
754 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitBitShiftOp(this);
755 }
756 @Override
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;
766 public List<ExpressionContext> expression() {
767 return getRuleContexts(ExpressionContext.class);
768 }
769 public ExpressionContext expression(int i) {
770 return getRuleContext(ExpressionContext.class,i);
771 }
772 public AndOrOpContext(ExpressionContext ctx) { copyFrom(ctx); }
773 @Override
774 public void enterRule(ParseTreeListener listener) {
775 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterAndOrOp(this);
776 }
777 @Override
778 public void exitRule(ParseTreeListener listener) {
779 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitAndOrOp(this);
780 }
781 @Override
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;
792 public List<ExpressionContext> expression() {
793 return getRuleContexts(ExpressionContext.class);
794 }
795 public ExpressionContext expression(int i) {
796 return getRuleContext(ExpressionContext.class,i);
797 }
798 public TernaryOpContext(ExpressionContext ctx) { copyFrom(ctx); }
799 @Override
800 public void enterRule(ParseTreeListener listener) {
801 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterTernaryOp(this);
802 }
803 @Override
804 public void exitRule(ParseTreeListener listener) {
805 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitTernaryOp(this);
806 }
807 @Override
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 {
814 public LiteralContext literal() {
815 return getRuleContext(LiteralContext.class,0);
816 }
817 public TerminalNode VoidLiteral() { return getToken(BindingExpressionParser.VoidLiteral, 0); }
818 public IdentifierContext identifier() {
819 return getRuleContext(IdentifierContext.class,0);
820 }
821 public ClassExtractionContext classExtraction() {
822 return getRuleContext(ClassExtractionContext.class,0);
823 }
824 public PrimaryContext(ExpressionContext ctx) { copyFrom(ctx); }
825 @Override
826 public void enterRule(ParseTreeListener listener) {
827 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterPrimary(this);
828 }
829 @Override
830 public void exitRule(ParseTreeListener listener) {
831 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitPrimary(this);
832 }
833 @Override
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 {
840 public ExpressionContext expression() {
841 return getRuleContext(ExpressionContext.class,0);
842 }
843 public TerminalNode Identifier() { return getToken(BindingExpressionParser.Identifier, 0); }
844 public DotOpContext(ExpressionContext ctx) { copyFrom(ctx); }
845 @Override
846 public void enterRule(ParseTreeListener listener) {
847 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterDotOp(this);
848 }
849 @Override
850 public void exitRule(ParseTreeListener listener) {
851 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitDotOp(this);
852 }
853 @Override
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;
863 public List<ExpressionContext> expression() {
864 return getRuleContexts(ExpressionContext.class);
865 }
866 public ExpressionContext expression(int i) {
867 return getRuleContext(ExpressionContext.class,i);
868 }
869 public MathOpContext(ExpressionContext ctx) { copyFrom(ctx); }
870 @Override
871 public void enterRule(ParseTreeListener listener) {
872 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterMathOp(this);
873 }
874 @Override
875 public void exitRule(ParseTreeListener listener) {
876 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitMathOp(this);
877 }
878 @Override
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 {
885 public ExpressionContext expression() {
886 return getRuleContext(ExpressionContext.class,0);
887 }
888 public TypeContext type() {
889 return getRuleContext(TypeContext.class,0);
890 }
891 public InstanceOfOpContext(ExpressionContext ctx) { copyFrom(ctx); }
892 @Override
893 public void enterRule(ParseTreeListener listener) {
894 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterInstanceOfOp(this);
895 }
896 @Override
897 public void exitRule(ParseTreeListener listener) {
898 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitInstanceOfOp(this);
899 }
900 @Override
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;
910 public List<ExpressionContext> expression() {
911 return getRuleContexts(ExpressionContext.class);
912 }
913 public ExpressionContext expression(int i) {
914 return getRuleContext(ExpressionContext.class,i);
915 }
916 public BinaryOpContext(ExpressionContext ctx) { copyFrom(ctx); }
917 @Override
918 public void enterRule(ParseTreeListener listener) {
919 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterBinaryOp(this);
920 }
921 @Override
922 public void exitRule(ParseTreeListener listener) {
923 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitBinaryOp(this);
924 }
925 @Override
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 {
932 public ExpressionContext expression() {
933 return getRuleContext(ExpressionContext.class,0);
934 }
935 public TerminalNode Identifier() { return getToken(BindingExpressionParser.Identifier, 0); }
936 public FunctionRefContext(ExpressionContext ctx) { copyFrom(ctx); }
937 @Override
938 public void enterRule(ParseTreeListener listener) {
939 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterFunctionRef(this);
940 }
941 @Override
942 public void exitRule(ParseTreeListener listener) {
943 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitFunctionRef(this);
944 }
945 @Override
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
952 public final ExpressionContext expression() throws RecognitionException {
953 return expression(0);
954 }
955
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 {
1379 public TypeContext type() {
1380 return getRuleContext(TypeContext.class,0);
1381 }
1382 public ClassExtractionContext(ParserRuleContext parent, int invokingState) {
1383 super(parent, invokingState);
1384 }
1385 @Override public int getRuleIndex() { return RULE_classExtraction; }
1386 @Override
1387 public void enterRule(ParseTreeListener listener) {
1388 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterClassExtraction(this);
1389 }
1390 @Override
1391 public void exitRule(ParseTreeListener listener) {
1392 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitClassExtraction(this);
1393 }
1394 @Override
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
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 {
1427 public List<ExpressionContext> expression() {
1428 return getRuleContexts(ExpressionContext.class);
1429 }
1430 public ExpressionContext expression(int i) {
1431 return getRuleContext(ExpressionContext.class,i);
1432 }
1433 public ExpressionListContext(ParserRuleContext parent, int invokingState) {
1434 super(parent, invokingState);
1435 }
1436 @Override public int getRuleIndex() { return RULE_expressionList; }
1437 @Override
1438 public void enterRule(ParseTreeListener listener) {
1439 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterExpressionList(this);
1440 }
1441 @Override
1442 public void exitRule(ParseTreeListener listener) {
1443 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitExpressionList(this);
1444 }
1445 @Override
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
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 {
1491 public JavaLiteralContext javaLiteral() {
1492 return getRuleContext(JavaLiteralContext.class,0);
1493 }
1494 public StringLiteralContext stringLiteral() {
1495 return getRuleContext(StringLiteralContext.class,0);
1496 }
1497 public LiteralContext(ParserRuleContext parent, int invokingState) {
1498 super(parent, invokingState);
1499 }
1500 @Override public int getRuleIndex() { return RULE_literal; }
1501 @Override
1502 public void enterRule(ParseTreeListener listener) {
1503 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterLiteral(this);
1504 }
1505 @Override
1506 public void exitRule(ParseTreeListener listener) {
1507 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitLiteral(this);
1508 }
1509 @Override
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
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 {
1557 public TerminalNode Identifier() { return getToken(BindingExpressionParser.Identifier, 0); }
1558 public IdentifierContext(ParserRuleContext parent, int invokingState) {
1559 super(parent, invokingState);
1560 }
1561 @Override public int getRuleIndex() { return RULE_identifier; }
1562 @Override
1563 public void enterRule(ParseTreeListener listener) {
1564 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterIdentifier(this);
1565 }
1566 @Override
1567 public void exitRule(ParseTreeListener listener) {
1568 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitIdentifier(this);
1569 }
1570 @Override
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
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 {
1599 public TerminalNode IntegerLiteral() { return getToken(BindingExpressionParser.IntegerLiteral, 0); }
1600 public TerminalNode FloatingPointLiteral() { return getToken(BindingExpressionParser.FloatingPointLiteral, 0); }
1601 public TerminalNode BooleanLiteral() { return getToken(BindingExpressionParser.BooleanLiteral, 0); }
1602 public TerminalNode NullLiteral() { return getToken(BindingExpressionParser.NullLiteral, 0); }
1603 public TerminalNode CharacterLiteral() { return getToken(BindingExpressionParser.CharacterLiteral, 0); }
1604 public JavaLiteralContext(ParserRuleContext parent, int invokingState) {
1605 super(parent, invokingState);
1606 }
1607 @Override public int getRuleIndex() { return RULE_javaLiteral; }
1608 @Override
1609 public void enterRule(ParseTreeListener listener) {
1610 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterJavaLiteral(this);
1611 }
1612 @Override
1613 public void exitRule(ParseTreeListener listener) {
1614 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitJavaLiteral(this);
1615 }
1616 @Override
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
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 {
1651 public TerminalNode SingleQuoteString() { return getToken(BindingExpressionParser.SingleQuoteString, 0); }
1652 public TerminalNode DoubleQuoteString() { return getToken(BindingExpressionParser.DoubleQuoteString, 0); }
1653 public StringLiteralContext(ParserRuleContext parent, int invokingState) {
1654 super(parent, invokingState);
1655 }
1656 @Override public int getRuleIndex() { return RULE_stringLiteral; }
1657 @Override
1658 public void enterRule(ParseTreeListener listener) {
1659 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterStringLiteral(this);
1660 }
1661 @Override
1662 public void exitRule(ParseTreeListener listener) {
1663 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitStringLiteral(this);
1664 }
1665 @Override
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
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 {
1700 public TypeArgumentsContext typeArguments() {
1701 return getRuleContext(TypeArgumentsContext.class,0);
1702 }
1703 public ExplicitGenericInvocationSuffixContext explicitGenericInvocationSuffix() {
1704 return getRuleContext(ExplicitGenericInvocationSuffixContext.class,0);
1705 }
1706 public ExplicitGenericInvocationContext(ParserRuleContext parent, int invokingState) {
1707 super(parent, invokingState);
1708 }
1709 @Override public int getRuleIndex() { return RULE_explicitGenericInvocation; }
1710 @Override
1711 public void enterRule(ParseTreeListener listener) {
1712 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterExplicitGenericInvocation(this);
1713 }
1714 @Override
1715 public void exitRule(ParseTreeListener listener) {
1716 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitExplicitGenericInvocation(this);
1717 }
1718 @Override
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
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 {
1749 public List<TypeContext> type() {
1750 return getRuleContexts(TypeContext.class);
1751 }
1752 public TypeContext type(int i) {
1753 return getRuleContext(TypeContext.class,i);
1754 }
1755 public TypeArgumentsContext(ParserRuleContext parent, int invokingState) {
1756 super(parent, invokingState);
1757 }
1758 @Override public int getRuleIndex() { return RULE_typeArguments; }
1759 @Override
1760 public void enterRule(ParseTreeListener listener) {
1761 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterTypeArguments(this);
1762 }
1763 @Override
1764 public void exitRule(ParseTreeListener listener) {
1765 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitTypeArguments(this);
1766 }
1767 @Override
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
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 {
1817 public ClassOrInterfaceTypeContext classOrInterfaceType() {
1818 return getRuleContext(ClassOrInterfaceTypeContext.class,0);
1819 }
1820 public PrimitiveTypeContext primitiveType() {
1821 return getRuleContext(PrimitiveTypeContext.class,0);
1822 }
1823 public TypeContext(ParserRuleContext parent, int invokingState) {
1824 super(parent, invokingState);
1825 }
1826 @Override public int getRuleIndex() { return RULE_type; }
1827 @Override
1828 public void enterRule(ParseTreeListener listener) {
1829 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterType(this);
1830 }
1831 @Override
1832 public void exitRule(ParseTreeListener listener) {
1833 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitType(this);
1834 }
1835 @Override
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
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 {
1922 public TerminalNode Identifier() { return getToken(BindingExpressionParser.Identifier, 0); }
1923 public ArgumentsContext arguments() {
1924 return getRuleContext(ArgumentsContext.class,0);
1925 }
1926 public ExplicitGenericInvocationSuffixContext(ParserRuleContext parent, int invokingState) {
1927 super(parent, invokingState);
1928 }
1929 @Override public int getRuleIndex() { return RULE_explicitGenericInvocationSuffix; }
1930 @Override
1931 public void enterRule(ParseTreeListener listener) {
1932 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterExplicitGenericInvocationSuffix(this);
1933 }
1934 @Override
1935 public void exitRule(ParseTreeListener listener) {
1936 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitExplicitGenericInvocationSuffix(this);
1937 }
1938 @Override
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
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 {
1969 public ExpressionListContext expressionList() {
1970 return getRuleContext(ExpressionListContext.class,0);
1971 }
1972 public ArgumentsContext(ParserRuleContext parent, int invokingState) {
1973 super(parent, invokingState);
1974 }
1975 @Override public int getRuleIndex() { return RULE_arguments; }
1976 @Override
1977 public void enterRule(ParseTreeListener listener) {
1978 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterArguments(this);
1979 }
1980 @Override
1981 public void exitRule(ParseTreeListener listener) {
1982 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitArguments(this);
1983 }
1984 @Override
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
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 {
2025 public IdentifierContext identifier() {
2026 return getRuleContext(IdentifierContext.class,0);
2027 }
2028 public List<TypeArgumentsContext> typeArguments() {
2029 return getRuleContexts(TypeArgumentsContext.class);
2030 }
2031 public TypeArgumentsContext typeArguments(int i) {
2032 return getRuleContext(TypeArgumentsContext.class,i);
2033 }
2034 public List<TerminalNode> Identifier() { return getTokens(BindingExpressionParser.Identifier); }
2035 public TerminalNode Identifier(int i) {
2036 return getToken(BindingExpressionParser.Identifier, i);
2037 }
2038 public ClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
2039 super(parent, invokingState);
2040 }
2041 @Override public int getRuleIndex() { return RULE_classOrInterfaceType; }
2042 @Override
2043 public void enterRule(ParseTreeListener listener) {
2044 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterClassOrInterfaceType(this);
2045 }
2046 @Override
2047 public void exitRule(ParseTreeListener listener) {
2048 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitClassOrInterfaceType(this);
2049 }
2050 @Override
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
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 {
2118 public PrimitiveTypeContext(ParserRuleContext parent, int invokingState) {
2119 super(parent, invokingState);
2120 }
2121 @Override public int getRuleIndex() { return RULE_primitiveType; }
2122 @Override
2123 public void enterRule(ParseTreeListener listener) {
2124 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterPrimitiveType(this);
2125 }
2126 @Override
2127 public void exitRule(ParseTreeListener listener) {
2128 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitPrimitiveType(this);
2129 }
2130 @Override
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
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 {
2165 public TerminalNode ResourceReference() { return getToken(BindingExpressionParser.ResourceReference, 0); }
2166 public ResourceParametersContext resourceParameters() {
2167 return getRuleContext(ResourceParametersContext.class,0);
2168 }
2169 public ResourcesContext(ParserRuleContext parent, int invokingState) {
2170 super(parent, invokingState);
2171 }
2172 @Override public int getRuleIndex() { return RULE_resources; }
2173 @Override
2174 public void enterRule(ParseTreeListener listener) {
2175 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterResources(this);
2176 }
2177 @Override
2178 public void exitRule(ParseTreeListener listener) {
2179 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitResources(this);
2180 }
2181 @Override
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
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 {
2220 public ExpressionListContext expressionList() {
2221 return getRuleContext(ExpressionListContext.class,0);
2222 }
2223 public ResourceParametersContext(ParserRuleContext parent, int invokingState) {
2224 super(parent, invokingState);
2225 }
2226 @Override public int getRuleIndex() { return RULE_resourceParameters; }
2227 @Override
2228 public void enterRule(ParseTreeListener listener) {
2229 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).enterResourceParameters(this);
2230 }
2231 @Override
2232 public void exitRule(ParseTreeListener listener) {
2233 if ( listener instanceof BindingExpressionListener ) ((BindingExpressionListener)listener).exitResourceParameters(this);
2234 }
2235 @Override
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
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
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 }
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 }