?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Revision created by MOE tool push_codebase.
[gae.git] / java / src / main / com / google / appengine / api / search / query / QueryParser.java
bloba3fe16c476aebb7b673c2fabee03a751bd41bee1
1
2
3 package com.google.appengine.api.search.query;
4
5 import org.antlr.runtime.*;
6
7 import org.antlr.runtime.tree.*;
8
9 public class QueryParser extends Parser {
10 public static final String[] tokenNames = new String[] {
11 "<invalid>", "<EOR>", "<DOWN>", "<UP>", "ARGS", "CONJUNCTION", "DISJUNCTION", "EMPTY", "FUNCTION", "FUZZY", "GLOBAL", "LITERAL", "NEGATION", "STRING", "SEQUENCE", "VALUE", "WS", "LE", "LESSTHAN", "GE", "GT", "NE", "EQ", "HAS", "LPAREN", "RPAREN", "AND", "OR", "NOT", "COMMA", "FIX", "REWRITE", "TEXT", "QUOTE", "UNICODE_ESC", "OCTAL_ESC", "ESC", "BACKSLASH", "MINUS", "START_CHAR", "NUMBER_PREFIX", "TEXT_ESC", "MID_CHAR", "DIGIT", "ESCAPED_CHAR", "HEX_DIGIT"
12 };
13 public static final int FUNCTION=8;
14 public static final int FIX=30;
15 public static final int ESC=36;
16 public static final int FUZZY=9;
17 public static final int OCTAL_ESC=35;
18 public static final int NOT=28;
19 public static final int AND=26;
20 public static final int ESCAPED_CHAR=44;
21 public static final int EOF=-1;
22 public static final int LPAREN=24;
23 public static final int HAS=23;
24 public static final int RPAREN=25;
25 public static final int QUOTE=33;
26 public static final int START_CHAR=39;
27 public static final int COMMA=29;
28 public static final int ARGS=4;
29 public static final int DIGIT=43;
30 public static final int EQ=22;
31 public static final int NE=21;
32 public static final int LESSTHAN=18;
33 public static final int GE=19;
34 public static final int TEXT_ESC=41;
35 public static final int CONJUNCTION=5;
36 public static final int UNICODE_ESC=34;
37 public static final int HEX_DIGIT=45;
38 public static final int LITERAL=11;
39 public static final int VALUE=15;
40 public static final int TEXT=32;
41 public static final int MINUS=38;
42 public static final int NUMBER_PREFIX=40;
43 public static final int REWRITE=31;
44 public static final int EMPTY=7;
45 public static final int SEQUENCE=14;
46 public static final int DISJUNCTION=6;
47 public static final int WS=16;
48 public static final int NEGATION=12;
49 public static final int OR=27;
50 public static final int GT=20;
51 public static final int GLOBAL=10;
52 public static final int LE=17;
53 public static final int MID_CHAR=42;
54 public static final int STRING=13;
55 public static final int BACKSLASH=37;
56
57 public QueryParser(TokenStream input) {
58 this(input, new RecognizerSharedState());
59 }
60 public QueryParser(TokenStream input, RecognizerSharedState state) {
61 super(input, state);
62
63 }
64
65 protected TreeAdaptor adaptor = new CommonTreeAdaptor();
66
67 public void setTreeAdaptor(TreeAdaptor adaptor) {
68 this.adaptor = adaptor;
69 }
70 public TreeAdaptor getTreeAdaptor() {
71 return adaptor;
72 }
73
74 public String[] getTokenNames() { return QueryParser.tokenNames; }
75 public String getGrammarFileName() { return ""; }
76
77 @Override
78 public Object recoverFromMismatchedSet(IntStream input,
79 RecognitionException e, BitSet follow) throws RecognitionException {
80 throw e;
81 }
82
83 @Override
84 protected Object recoverFromMismatchedToken(
85 IntStream input, int ttype, BitSet follow) throws RecognitionException {
86 throw new MismatchedTokenException(ttype, input);
87 }
88
89 public static class query_return extends ParserRuleReturnScope {
90 CommonTree tree;
91 public Object getTree() { return tree; }
92 };
93
94 public final QueryParser.query_return query() throws RecognitionException {
95 QueryParser.query_return retval = new QueryParser.query_return();
96 retval.start = input.LT(1);
97
98 CommonTree root_0 = null;
99
100 Token WS1=null;
101 Token EOF2=null;
102 Token WS3=null;
103 Token WS5=null;
104 Token EOF6=null;
105 QueryParser.expression_return expression4 = null;
106
107 CommonTree WS1_tree=null;
108 CommonTree EOF2_tree=null;
109 CommonTree WS3_tree=null;
110 CommonTree WS5_tree=null;
111 CommonTree EOF6_tree=null;
112 RewriteRuleTokenStream stream_WS=new RewriteRuleTokenStream(adaptor,"token WS");
113 RewriteRuleTokenStream stream_EOF=new RewriteRuleTokenStream(adaptor,"token EOF");
114 RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
115 try {
116 int alt4=2;
117 alt4 = dfa4.predict(input);
118 switch (alt4) {
119 case 1 :
120 {
121 loop1:
122 do {
123 int alt1=2;
124 int LA1_0 = input.LA(1);
125
126 if ( (LA1_0==WS) ) {
127 alt1=1;
128 }
129
130 switch (alt1) {
131 case 1 :
132 {
133 WS1=(Token)match(input,WS,FOLLOW_WS_in_query137);
134 stream_WS.add(WS1);
135
136 }
137 break;
138
139 default :
140 break loop1;
141 }
142 } while (true);
143
144 EOF2=(Token)match(input,EOF,FOLLOW_EOF_in_query140);
145 stream_EOF.add(EOF2);
146
147 retval.tree = root_0;
148 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
149
150 root_0 = (CommonTree)adaptor.nil();
151 {
152 {
153 CommonTree root_1 = (CommonTree)adaptor.nil();
154 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(EMPTY, "EMPTY"), root_1);
155
156 adaptor.addChild(root_0, root_1);
157 }
158
159 }
160
161 retval.tree = root_0;
162 }
163 break;
164 case 2 :
165 {
166 loop2:
167 do {
168 int alt2=2;
169 int LA2_0 = input.LA(1);
170
171 if ( (LA2_0==WS) ) {
172 alt2=1;
173 }
174
175 switch (alt2) {
176 case 1 :
177 {
178 WS3=(Token)match(input,WS,FOLLOW_WS_in_query169);
179 stream_WS.add(WS3);
180
181 }
182 break;
183
184 default :
185 break loop2;
186 }
187 } while (true);
188
189 pushFollow(FOLLOW_expression_in_query172);
190 expression4=expression();
191
192 state._fsp--;
193
194 stream_expression.add(expression4.getTree());
195 loop3:
196 do {
197 int alt3=2;
198 int LA3_0 = input.LA(1);
199
200 if ( (LA3_0==WS) ) {
201 alt3=1;
202 }
203
204 switch (alt3) {
205 case 1 :
206 {
207 WS5=(Token)match(input,WS,FOLLOW_WS_in_query174);
208 stream_WS.add(WS5);
209
210 }
211 break;
212
213 default :
214 break loop3;
215 }
216 } while (true);
217
218 EOF6=(Token)match(input,EOF,FOLLOW_EOF_in_query177);
219 stream_EOF.add(EOF6);
220
221 retval.tree = root_0;
222 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
223
224 root_0 = (CommonTree)adaptor.nil();
225 {
226 adaptor.addChild(root_0, stream_expression.nextTree());
227
228 }
229
230 retval.tree = root_0;
231 }
232 break;
233
234 }
235 retval.stop = input.LT(-1);
236
237 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
238 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
239
240 }
241
242 catch (RecognitionException e) {
243 reportError(e);
244 throw e;
245 }
246 finally {
247 }
248 return retval;
249 }
250
251 public static class expression_return extends ParserRuleReturnScope {
252 CommonTree tree;
253 public Object getTree() { return tree; }
254 };
255
256 public final QueryParser.expression_return expression() throws RecognitionException {
257 QueryParser.expression_return retval = new QueryParser.expression_return();
258 retval.start = input.LT(1);
259
260 CommonTree root_0 = null;
261
262 QueryParser.sequence_return sequence7 = null;
263
264 QueryParser.andOp_return andOp8 = null;
265
266 QueryParser.sequence_return sequence9 = null;
267
268 RewriteRuleSubtreeStream stream_sequence=new RewriteRuleSubtreeStream(adaptor,"rule sequence");
269 RewriteRuleSubtreeStream stream_andOp=new RewriteRuleSubtreeStream(adaptor,"rule andOp");
270 try {
271 {
272 pushFollow(FOLLOW_sequence_in_expression200);
273 sequence7=sequence();
274
275 state._fsp--;
276
277 stream_sequence.add(sequence7.getTree());
278 int alt6=2;
279 alt6 = dfa6.predict(input);
280 switch (alt6) {
281 case 1 :
282 {
283
284 retval.tree = root_0;
285 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
286
287 root_0 = (CommonTree)adaptor.nil();
288 {
289 adaptor.addChild(root_0, stream_sequence.nextTree());
290
291 }
292
293 retval.tree = root_0;
294 }
295 break;
296 case 2 :
297 {
298 int cnt5=0;
299 loop5:
300 do {
301 int alt5=2;
302 alt5 = dfa5.predict(input);
303 switch (alt5) {
304 case 1 :
305 {
306 pushFollow(FOLLOW_andOp_in_expression237);
307 andOp8=andOp();
308
309 state._fsp--;
310
311 stream_andOp.add(andOp8.getTree());
312 pushFollow(FOLLOW_sequence_in_expression239);
313 sequence9=sequence();
314
315 state._fsp--;
316
317 stream_sequence.add(sequence9.getTree());
318
319 }
320 break;
321
322 default :
323 if ( cnt5 >= 1 ) break loop5;
324 EarlyExitException eee =
325 new EarlyExitException(5, input);
326 throw eee;
327 }
328 cnt5++;
329 } while (true);
330
331 retval.tree = root_0;
332 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
333
334 root_0 = (CommonTree)adaptor.nil();
335 {
336 {
337 CommonTree root_1 = (CommonTree)adaptor.nil();
338 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(CONJUNCTION, "CONJUNCTION"), root_1);
339
340 if ( !(stream_sequence.hasNext()) ) {
341 throw new RewriteEarlyExitException();
342 }
343 while ( stream_sequence.hasNext() ) {
344 adaptor.addChild(root_1, stream_sequence.nextTree());
345
346 }
347 stream_sequence.reset();
348
349 adaptor.addChild(root_0, root_1);
350 }
351
352 }
353
354 retval.tree = root_0;
355 }
356 break;
357
358 }
359
360 }
361
362 retval.stop = input.LT(-1);
363
364 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
365 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
366
367 }
368
369 catch (RecognitionException e) {
370 reportError(e);
371 throw e;
372 }
373 finally {
374 }
375 return retval;
376 }
377
378 public static class sequence_return extends ParserRuleReturnScope {
379 CommonTree tree;
380 public Object getTree() { return tree; }
381 };
382
383 public final QueryParser.sequence_return sequence() throws RecognitionException {
384 QueryParser.sequence_return retval = new QueryParser.sequence_return();
385 retval.start = input.LT(1);
386
387 CommonTree root_0 = null;
388
389 Token WS11=null;
390 QueryParser.factor_return factor10 = null;
391
392 QueryParser.factor_return factor12 = null;
393
394 CommonTree WS11_tree=null;
395 RewriteRuleTokenStream stream_WS=new RewriteRuleTokenStream(adaptor,"token WS");
396 RewriteRuleSubtreeStream stream_factor=new RewriteRuleSubtreeStream(adaptor,"rule factor");
397 try {
398 {
399 pushFollow(FOLLOW_factor_in_sequence277);
400 factor10=factor();
401
402 state._fsp--;
403
404 stream_factor.add(factor10.getTree());
405 int alt9=2;
406 alt9 = dfa9.predict(input);
407 switch (alt9) {
408 case 1 :
409 {
410
411 retval.tree = root_0;
412 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
413
414 root_0 = (CommonTree)adaptor.nil();
415 {
416 adaptor.addChild(root_0, stream_factor.nextTree());
417
418 }
419
420 retval.tree = root_0;
421 }
422 break;
423 case 2 :
424 {
425 int cnt8=0;
426 loop8:
427 do {
428 int alt8=2;
429 alt8 = dfa8.predict(input);
430 switch (alt8) {
431 case 1 :
432 {
433 int cnt7=0;
434 loop7:
435 do {
436 int alt7=2;
437 int LA7_0 = input.LA(1);
438
439 if ( (LA7_0==WS) ) {
440 alt7=1;
441 }
442
443 switch (alt7) {
444 case 1 :
445 {
446 WS11=(Token)match(input,WS,FOLLOW_WS_in_sequence313);
447 stream_WS.add(WS11);
448
449 }
450 break;
451
452 default :
453 if ( cnt7 >= 1 ) break loop7;
454 EarlyExitException eee =
455 new EarlyExitException(7, input);
456 throw eee;
457 }
458 cnt7++;
459 } while (true);
460
461 pushFollow(FOLLOW_factor_in_sequence316);
462 factor12=factor();
463
464 state._fsp--;
465
466 stream_factor.add(factor12.getTree());
467
468 }
469 break;
470
471 default :
472 if ( cnt8 >= 1 ) break loop8;
473 EarlyExitException eee =
474 new EarlyExitException(8, input);
475 throw eee;
476 }
477 cnt8++;
478 } while (true);
479
480 retval.tree = root_0;
481 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
482
483 root_0 = (CommonTree)adaptor.nil();
484 {
485 {
486 CommonTree root_1 = (CommonTree)adaptor.nil();
487 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(SEQUENCE, "SEQUENCE"), root_1);
488
489 if ( !(stream_factor.hasNext()) ) {
490 throw new RewriteEarlyExitException();
491 }
492 while ( stream_factor.hasNext() ) {
493 adaptor.addChild(root_1, stream_factor.nextTree());
494
495 }
496 stream_factor.reset();
497
498 adaptor.addChild(root_0, root_1);
499 }
500
501 }
502
503 retval.tree = root_0;
504 }
505 break;
506
507 }
508
509 }
510
511 retval.stop = input.LT(-1);
512
513 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
514 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
515
516 }
517
518 catch (RecognitionException e) {
519 reportError(e);
520 throw e;
521 }
522 finally {
523 }
524 return retval;
525 }
526
527 public static class factor_return extends ParserRuleReturnScope {
528 CommonTree tree;
529 public Object getTree() { return tree; }
530 };
531
532 public final QueryParser.factor_return factor() throws RecognitionException {
533 QueryParser.factor_return retval = new QueryParser.factor_return();
534 retval.start = input.LT(1);
535
536 CommonTree root_0 = null;
537
538 QueryParser.term_return term13 = null;
539
540 QueryParser.orOp_return orOp14 = null;
541
542 QueryParser.term_return term15 = null;
543
544 RewriteRuleSubtreeStream stream_orOp=new RewriteRuleSubtreeStream(adaptor,"rule orOp");
545 RewriteRuleSubtreeStream stream_term=new RewriteRuleSubtreeStream(adaptor,"rule term");
546 try {
547 {
548 pushFollow(FOLLOW_term_in_factor357);
549 term13=term();
550
551 state._fsp--;
552
553 stream_term.add(term13.getTree());
554 int alt11=2;
555 alt11 = dfa11.predict(input);
556 switch (alt11) {
557 case 1 :
558 {
559
560 retval.tree = root_0;
561 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
562
563 root_0 = (CommonTree)adaptor.nil();
564 {
565 adaptor.addChild(root_0, stream_term.nextTree());
566
567 }
568
569 retval.tree = root_0;
570 }
571 break;
572 case 2 :
573 {
574 int cnt10=0;
575 loop10:
576 do {
577 int alt10=2;
578 alt10 = dfa10.predict(input);
579 switch (alt10) {
580 case 1 :
581 {
582 pushFollow(FOLLOW_orOp_in_factor389);
583 orOp14=orOp();
584
585 state._fsp--;
586
587 stream_orOp.add(orOp14.getTree());
588 pushFollow(FOLLOW_term_in_factor391);
589 term15=term();
590
591 state._fsp--;
592
593 stream_term.add(term15.getTree());
594
595 }
596 break;
597
598 default :
599 if ( cnt10 >= 1 ) break loop10;
600 EarlyExitException eee =
601 new EarlyExitException(10, input);
602 throw eee;
603 }
604 cnt10++;
605 } while (true);
606
607 retval.tree = root_0;
608 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
609
610 root_0 = (CommonTree)adaptor.nil();
611 {
612 {
613 CommonTree root_1 = (CommonTree)adaptor.nil();
614 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(DISJUNCTION, "DISJUNCTION"), root_1);
615
616 if ( !(stream_term.hasNext()) ) {
617 throw new RewriteEarlyExitException();
618 }
619 while ( stream_term.hasNext() ) {
620 adaptor.addChild(root_1, stream_term.nextTree());
621
622 }
623 stream_term.reset();
624
625 adaptor.addChild(root_0, root_1);
626 }
627
628 }
629
630 retval.tree = root_0;
631 }
632 break;
633
634 }
635
636 }
637
638 retval.stop = input.LT(-1);
639
640 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
641 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
642
643 }
644
645 catch (RecognitionException e) {
646 reportError(e);
647 throw e;
648 }
649 finally {
650 }
651 return retval;
652 }
653
654 public static class term_return extends ParserRuleReturnScope {
655 CommonTree tree;
656 public Object getTree() { return tree; }
657 };
658
659 public final QueryParser.term_return term() throws RecognitionException {
660 QueryParser.term_return retval = new QueryParser.term_return();
661 retval.start = input.LT(1);
662
663 CommonTree root_0 = null;
664
665 QueryParser.primitive_return primitive16 = null;
666
667 QueryParser.notOp_return notOp17 = null;
668
669 QueryParser.primitive_return primitive18 = null;
670
671 RewriteRuleSubtreeStream stream_notOp=new RewriteRuleSubtreeStream(adaptor,"rule notOp");
672 RewriteRuleSubtreeStream stream_primitive=new RewriteRuleSubtreeStream(adaptor,"rule primitive");
673 try {
674 int alt12=2;
675 int LA12_0 = input.LA(1);
676
677 if ( (LA12_0==LPAREN||(LA12_0>=FIX && LA12_0<=QUOTE)) ) {
678 alt12=1;
679 }
680 else if ( (LA12_0==NOT||LA12_0==MINUS) ) {
681 alt12=2;
682 }
683 else {
684 NoViableAltException nvae =
685 new NoViableAltException("", 12, 0, input);
686
687 throw nvae;
688 }
689 switch (alt12) {
690 case 1 :
691 {
692 root_0 = (CommonTree)adaptor.nil();
693
694 pushFollow(FOLLOW_primitive_in_term425);
695 primitive16=primitive();
696
697 state._fsp--;
698
699 adaptor.addChild(root_0, primitive16.getTree());
700
701 }
702 break;
703 case 2 :
704 {
705 pushFollow(FOLLOW_notOp_in_term431);
706 notOp17=notOp();
707
708 state._fsp--;
709
710 stream_notOp.add(notOp17.getTree());
711 pushFollow(FOLLOW_primitive_in_term433);
712 primitive18=primitive();
713
714 state._fsp--;
715
716 stream_primitive.add(primitive18.getTree());
717
718 retval.tree = root_0;
719 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
720
721 root_0 = (CommonTree)adaptor.nil();
722 {
723 {
724 CommonTree root_1 = (CommonTree)adaptor.nil();
725 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(NEGATION, "NEGATION"), root_1);
726
727 adaptor.addChild(root_1, stream_primitive.nextTree());
728
729 adaptor.addChild(root_0, root_1);
730 }
731
732 }
733
734 retval.tree = root_0;
735 }
736 break;
737
738 }
739 retval.stop = input.LT(-1);
740
741 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
742 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
743
744 }
745
746 catch (RecognitionException e) {
747 reportError(e);
748 throw e;
749 }
750 finally {
751 }
752 return retval;
753 }
754
755 public static class primitive_return extends ParserRuleReturnScope {
756 CommonTree tree;
757 public Object getTree() { return tree; }
758 };
759
760 public final QueryParser.primitive_return primitive() throws RecognitionException {
761 QueryParser.primitive_return retval = new QueryParser.primitive_return();
762 retval.start = input.LT(1);
763
764 CommonTree root_0 = null;
765
766 QueryParser.restriction_return restriction19 = null;
767
768 QueryParser.composite_return composite20 = null;
769
770 try {
771 int alt13=2;
772 int LA13_0 = input.LA(1);
773
774 if ( ((LA13_0>=FIX && LA13_0<=QUOTE)) ) {
775 alt13=1;
776 }
777 else if ( (LA13_0==LPAREN) ) {
778 alt13=2;
779 }
780 else {
781 NoViableAltException nvae =
782 new NoViableAltException("", 13, 0, input);
783
784 throw nvae;
785 }
786 switch (alt13) {
787 case 1 :
788 {
789 root_0 = (CommonTree)adaptor.nil();
790
791 pushFollow(FOLLOW_restriction_in_primitive459);
792 restriction19=restriction();
793
794 state._fsp--;
795
796 adaptor.addChild(root_0, restriction19.getTree());
797
798 }
799 break;
800 case 2 :
801 {
802 root_0 = (CommonTree)adaptor.nil();
803
804 pushFollow(FOLLOW_composite_in_primitive465);
805 composite20=composite();
806
807 state._fsp--;
808
809 adaptor.addChild(root_0, composite20.getTree());
810
811 }
812 break;
813
814 }
815 retval.stop = input.LT(-1);
816
817 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
818 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
819
820 }
821
822 catch (RecognitionException e) {
823 reportError(e);
824 throw e;
825 }
826 finally {
827 }
828 return retval;
829 }
830
831 public static class restriction_return extends ParserRuleReturnScope {
832 CommonTree tree;
833 public Object getTree() { return tree; }
834 };
835
836 public final QueryParser.restriction_return restriction() throws RecognitionException {
837 QueryParser.restriction_return retval = new QueryParser.restriction_return();
838 retval.start = input.LT(1);
839
840 CommonTree root_0 = null;
841
842 QueryParser.comparable_return comparable21 = null;
843
844 QueryParser.comparator_return comparator22 = null;
845
846 QueryParser.arg_return arg23 = null;
847
848 RewriteRuleSubtreeStream stream_arg=new RewriteRuleSubtreeStream(adaptor,"rule arg");
849 RewriteRuleSubtreeStream stream_comparable=new RewriteRuleSubtreeStream(adaptor,"rule comparable");
850 RewriteRuleSubtreeStream stream_comparator=new RewriteRuleSubtreeStream(adaptor,"rule comparator");
851 try {
852 {
853 pushFollow(FOLLOW_comparable_in_restriction482);
854 comparable21=comparable();
855
856 state._fsp--;
857
858 stream_comparable.add(comparable21.getTree());
859 int alt14=2;
860 alt14 = dfa14.predict(input);
861 switch (alt14) {
862 case 1 :
863 {
864
865 retval.tree = root_0;
866 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
867
868 root_0 = (CommonTree)adaptor.nil();
869 {
870 {
871 CommonTree root_1 = (CommonTree)adaptor.nil();
872 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(HAS, "HAS"), root_1);
873
874 adaptor.addChild(root_1, (CommonTree)adaptor.create(GLOBAL, "GLOBAL"));
875 adaptor.addChild(root_1, stream_comparable.nextTree());
876
877 adaptor.addChild(root_0, root_1);
878 }
879
880 }
881
882 retval.tree = root_0;
883 }
884 break;
885 case 2 :
886 {
887 pushFollow(FOLLOW_comparator_in_restriction517);
888 comparator22=comparator();
889
890 state._fsp--;
891
892 stream_comparator.add(comparator22.getTree());
893 pushFollow(FOLLOW_arg_in_restriction519);
894 arg23=arg();
895
896 state._fsp--;
897
898 stream_arg.add(arg23.getTree());
899
900 retval.tree = root_0;
901 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
902
903 root_0 = (CommonTree)adaptor.nil();
904 {
905 {
906 CommonTree root_1 = (CommonTree)adaptor.nil();
907 root_1 = (CommonTree)adaptor.becomeRoot(stream_comparator.nextNode(), root_1);
908
909 adaptor.addChild(root_1, stream_comparable.nextTree());
910 adaptor.addChild(root_1, stream_arg.nextTree());
911
912 adaptor.addChild(root_0, root_1);
913 }
914
915 }
916
917 retval.tree = root_0;
918 }
919 break;
920
921 }
922
923 }
924
925 retval.stop = input.LT(-1);
926
927 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
928 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
929
930 }
931
932 catch (RecognitionException e) {
933 reportError(e);
934 throw e;
935 }
936 finally {
937 }
938 return retval;
939 }
940
941 public static class comparator_return extends ParserRuleReturnScope {
942 CommonTree tree;
943 public Object getTree() { return tree; }
944 };
945
946 public final QueryParser.comparator_return comparator() throws RecognitionException {
947 QueryParser.comparator_return retval = new QueryParser.comparator_return();
948 retval.start = input.LT(1);
949
950 CommonTree root_0 = null;
951
952 Token x=null;
953 Token WS24=null;
954 Token WS25=null;
955
956 CommonTree x_tree=null;
957 CommonTree WS24_tree=null;
958 CommonTree WS25_tree=null;
959 RewriteRuleTokenStream stream_HAS=new RewriteRuleTokenStream(adaptor,"token HAS");
960 RewriteRuleTokenStream stream_LESSTHAN=new RewriteRuleTokenStream(adaptor,"token LESSTHAN");
961 RewriteRuleTokenStream stream_GE=new RewriteRuleTokenStream(adaptor,"token GE");
962 RewriteRuleTokenStream stream_GT=new RewriteRuleTokenStream(adaptor,"token GT");
963 RewriteRuleTokenStream stream_WS=new RewriteRuleTokenStream(adaptor,"token WS");
964 RewriteRuleTokenStream stream_EQ=new RewriteRuleTokenStream(adaptor,"token EQ");
965 RewriteRuleTokenStream stream_LE=new RewriteRuleTokenStream(adaptor,"token LE");
966 RewriteRuleTokenStream stream_NE=new RewriteRuleTokenStream(adaptor,"token NE");
967
968 try {
969 {
970 loop15:
971 do {
972 int alt15=2;
973 int LA15_0 = input.LA(1);
974
975 if ( (LA15_0==WS) ) {
976 alt15=1;
977 }
978
979 switch (alt15) {
980 case 1 :
981 {
982 WS24=(Token)match(input,WS,FOLLOW_WS_in_comparator549);
983 stream_WS.add(WS24);
984
985 }
986 break;
987
988 default :
989 break loop15;
990 }
991 } while (true);
992
993 int alt16=7;
994 switch ( input.LA(1) ) {
995 case LE:
996 {
997 alt16=1;
998 }
999 break;
1000 case LESSTHAN:
1001 {
1002 alt16=2;
1003 }
1004 break;
1005 case GE:
1006 {
1007 alt16=3;
1008 }
1009 break;
1010 case GT:
1011 {
1012 alt16=4;
1013 }
1014 break;
1015 case NE:
1016 {
1017 alt16=5;
1018 }
1019 break;
1020 case EQ:
1021 {
1022 alt16=6;
1023 }
1024 break;
1025 case HAS:
1026 {
1027 alt16=7;
1028 }
1029 break;
1030 default:
1031 NoViableAltException nvae =
1032 new NoViableAltException("", 16, 0, input);
1033
1034 throw nvae;
1035 }
1036
1037 switch (alt16) {
1038 case 1 :
1039 {
1040 x=(Token)match(input,LE,FOLLOW_LE_in_comparator555);
1041 stream_LE.add(x);
1042
1043 }
1044 break;
1045 case 2 :
1046 {
1047 x=(Token)match(input,LESSTHAN,FOLLOW_LESSTHAN_in_comparator561);
1048 stream_LESSTHAN.add(x);
1049
1050 }
1051 break;
1052 case 3 :
1053 {
1054 x=(Token)match(input,GE,FOLLOW_GE_in_comparator567);
1055 stream_GE.add(x);
1056
1057 }
1058 break;
1059 case 4 :
1060 {
1061 x=(Token)match(input,GT,FOLLOW_GT_in_comparator573);
1062 stream_GT.add(x);
1063
1064 }
1065 break;
1066 case 5 :
1067 {
1068 x=(Token)match(input,NE,FOLLOW_NE_in_comparator579);
1069 stream_NE.add(x);
1070
1071 }
1072 break;
1073 case 6 :
1074 {
1075 x=(Token)match(input,EQ,FOLLOW_EQ_in_comparator585);
1076 stream_EQ.add(x);
1077
1078 }
1079 break;
1080 case 7 :
1081 {
1082 x=(Token)match(input,HAS,FOLLOW_HAS_in_comparator591);
1083 stream_HAS.add(x);
1084
1085 }
1086 break;
1087
1088 }
1089
1090 loop17:
1091 do {
1092 int alt17=2;
1093 int LA17_0 = input.LA(1);
1094
1095 if ( (LA17_0==WS) ) {
1096 alt17=1;
1097 }
1098
1099 switch (alt17) {
1100 case 1 :
1101 {
1102 WS25=(Token)match(input,WS,FOLLOW_WS_in_comparator594);
1103 stream_WS.add(WS25);
1104
1105 }
1106 break;
1107
1108 default :
1109 break loop17;
1110 }
1111 } while (true);
1112
1113 retval.tree = root_0;
1114 RewriteRuleTokenStream stream_x=new RewriteRuleTokenStream(adaptor,"token x",x);
1115 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
1116
1117 root_0 = (CommonTree)adaptor.nil();
1118 {
1119 adaptor.addChild(root_0, stream_x.nextNode());
1120
1121 }
1122
1123 retval.tree = root_0;
1124 }
1125
1126 retval.stop = input.LT(-1);
1127
1128 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1129 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1130
1131 }
1132
1133 catch (RecognitionException e) {
1134 reportError(e);
1135 throw e;
1136 }
1137 finally {
1138 }
1139 return retval;
1140 }
1141
1142 public static class comparable_return extends ParserRuleReturnScope {
1143 CommonTree tree;
1144 public Object getTree() { return tree; }
1145 };
1146
1147 public final QueryParser.comparable_return comparable() throws RecognitionException {
1148 QueryParser.comparable_return retval = new QueryParser.comparable_return();
1149 retval.start = input.LT(1);
1150
1151 CommonTree root_0 = null;
1152
1153 QueryParser.member_return member26 = null;
1154
1155 QueryParser.function_return function27 = null;
1156
1157 try {
1158 int alt18=2;
1159 int LA18_0 = input.LA(1);
1160
1161 if ( ((LA18_0>=FIX && LA18_0<=REWRITE)||LA18_0==QUOTE) ) {
1162 alt18=1;
1163 }
1164 else if ( (LA18_0==TEXT) ) {
1165 int LA18_2 = input.LA(2);
1166
1167 if ( (LA18_2==EOF||(LA18_2>=WS && LA18_2<=HAS)||LA18_2==RPAREN||LA18_2==COMMA) ) {
1168 alt18=1;
1169 }
1170 else if ( (LA18_2==LPAREN) ) {
1171 alt18=2;
1172 }
1173 else {
1174 NoViableAltException nvae =
1175 new NoViableAltException("", 18, 2, input);
1176
1177 throw nvae;
1178 }
1179 }
1180 else {
1181 NoViableAltException nvae =
1182 new NoViableAltException("", 18, 0, input);
1183
1184 throw nvae;
1185 }
1186 switch (alt18) {
1187 case 1 :
1188 {
1189 root_0 = (CommonTree)adaptor.nil();
1190
1191 pushFollow(FOLLOW_member_in_comparable616);
1192 member26=member();
1193
1194 state._fsp--;
1195
1196 adaptor.addChild(root_0, member26.getTree());
1197
1198 }
1199 break;
1200 case 2 :
1201 {
1202 root_0 = (CommonTree)adaptor.nil();
1203
1204 pushFollow(FOLLOW_function_in_comparable622);
1205 function27=function();
1206
1207 state._fsp--;
1208
1209 adaptor.addChild(root_0, function27.getTree());
1210
1211 }
1212 break;
1213
1214 }
1215 retval.stop = input.LT(-1);
1216
1217 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1218 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1219
1220 }
1221
1222 catch (RecognitionException e) {
1223 reportError(e);
1224 throw e;
1225 }
1226 finally {
1227 }
1228 return retval;
1229 }
1230
1231 public static class member_return extends ParserRuleReturnScope {
1232 CommonTree tree;
1233 public Object getTree() { return tree; }
1234 };
1235
1236 public final QueryParser.member_return member() throws RecognitionException {
1237 QueryParser.member_return retval = new QueryParser.member_return();
1238 retval.start = input.LT(1);
1239
1240 CommonTree root_0 = null;
1241
1242 QueryParser.item_return item28 = null;
1243
1244 try {
1245 {
1246 root_0 = (CommonTree)adaptor.nil();
1247
1248 pushFollow(FOLLOW_item_in_member637);
1249 item28=item();
1250
1251 state._fsp--;
1252
1253 adaptor.addChild(root_0, item28.getTree());
1254
1255 }
1256
1257 retval.stop = input.LT(-1);
1258
1259 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1260 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1261
1262 }
1263
1264 catch (RecognitionException e) {
1265 reportError(e);
1266 throw e;
1267 }
1268 finally {
1269 }
1270 return retval;
1271 }
1272
1273 public static class function_return extends ParserRuleReturnScope {
1274 CommonTree tree;
1275 public Object getTree() { return tree; }
1276 };
1277
1278 public final QueryParser.function_return function() throws RecognitionException {
1279 QueryParser.function_return retval = new QueryParser.function_return();
1280 retval.start = input.LT(1);
1281
1282 CommonTree root_0 = null;
1283
1284 Token LPAREN30=null;
1285 Token RPAREN32=null;
1286 QueryParser.text_return text29 = null;
1287
1288 QueryParser.arglist_return arglist31 = null;
1289
1290 CommonTree LPAREN30_tree=null;
1291 CommonTree RPAREN32_tree=null;
1292 RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
1293 RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
1294 RewriteRuleSubtreeStream stream_arglist=new RewriteRuleSubtreeStream(adaptor,"rule arglist");
1295 RewriteRuleSubtreeStream stream_text=new RewriteRuleSubtreeStream(adaptor,"rule text");
1296 try {
1297 {
1298 pushFollow(FOLLOW_text_in_function654);
1299 text29=text();
1300
1301 state._fsp--;
1302
1303 stream_text.add(text29.getTree());
1304 LPAREN30=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_function656);
1305 stream_LPAREN.add(LPAREN30);
1306
1307 pushFollow(FOLLOW_arglist_in_function658);
1308 arglist31=arglist();
1309
1310 state._fsp--;
1311
1312 stream_arglist.add(arglist31.getTree());
1313 RPAREN32=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_function660);
1314 stream_RPAREN.add(RPAREN32);
1315
1316 retval.tree = root_0;
1317 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
1318
1319 root_0 = (CommonTree)adaptor.nil();
1320 {
1321 {
1322 CommonTree root_1 = (CommonTree)adaptor.nil();
1323 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(FUNCTION, "FUNCTION"), root_1);
1324
1325 adaptor.addChild(root_1, stream_text.nextTree());
1326 {
1327 CommonTree root_2 = (CommonTree)adaptor.nil();
1328 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(ARGS, "ARGS"), root_2);
1329
1330 adaptor.addChild(root_2, stream_arglist.nextTree());
1331
1332 adaptor.addChild(root_1, root_2);
1333 }
1334
1335 adaptor.addChild(root_0, root_1);
1336 }
1337
1338 }
1339
1340 retval.tree = root_0;
1341 }
1342
1343 retval.stop = input.LT(-1);
1344
1345 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1346 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1347
1348 }
1349
1350 catch (RecognitionException e) {
1351 reportError(e);
1352 throw e;
1353 }
1354 finally {
1355 }
1356 return retval;
1357 }
1358
1359 public static class arglist_return extends ParserRuleReturnScope {
1360 CommonTree tree;
1361 public Object getTree() { return tree; }
1362 };
1363
1364 public final QueryParser.arglist_return arglist() throws RecognitionException {
1365 QueryParser.arglist_return retval = new QueryParser.arglist_return();
1366 retval.start = input.LT(1);
1367
1368 CommonTree root_0 = null;
1369
1370 QueryParser.arg_return arg33 = null;
1371
1372 QueryParser.sep_return sep34 = null;
1373
1374 QueryParser.arg_return arg35 = null;
1375
1376 RewriteRuleSubtreeStream stream_arg=new RewriteRuleSubtreeStream(adaptor,"rule arg");
1377 RewriteRuleSubtreeStream stream_sep=new RewriteRuleSubtreeStream(adaptor,"rule sep");
1378 try {
1379 int alt20=2;
1380 int LA20_0 = input.LA(1);
1381
1382 if ( (LA20_0==RPAREN) ) {
1383 alt20=1;
1384 }
1385 else if ( (LA20_0==LPAREN||(LA20_0>=FIX && LA20_0<=QUOTE)) ) {
1386 alt20=2;
1387 }
1388 else {
1389 NoViableAltException nvae =
1390 new NoViableAltException("", 20, 0, input);
1391
1392 throw nvae;
1393 }
1394 switch (alt20) {
1395 case 1 :
1396 {
1397 root_0 = (CommonTree)adaptor.nil();
1398
1399 }
1400 break;
1401 case 2 :
1402 {
1403 pushFollow(FOLLOW_arg_in_arglist695);
1404 arg33=arg();
1405
1406 state._fsp--;
1407
1408 stream_arg.add(arg33.getTree());
1409 loop19:
1410 do {
1411 int alt19=2;
1412 int LA19_0 = input.LA(1);
1413
1414 if ( (LA19_0==WS||LA19_0==COMMA) ) {
1415 alt19=1;
1416 }
1417
1418 switch (alt19) {
1419 case 1 :
1420 {
1421 pushFollow(FOLLOW_sep_in_arglist698);
1422 sep34=sep();
1423
1424 state._fsp--;
1425
1426 stream_sep.add(sep34.getTree());
1427 pushFollow(FOLLOW_arg_in_arglist700);
1428 arg35=arg();
1429
1430 state._fsp--;
1431
1432 stream_arg.add(arg35.getTree());
1433
1434 }
1435 break;
1436
1437 default :
1438 break loop19;
1439 }
1440 } while (true);
1441
1442 retval.tree = root_0;
1443 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
1444
1445 root_0 = (CommonTree)adaptor.nil();
1446 {
1447 while ( stream_arg.hasNext() ) {
1448 adaptor.addChild(root_0, stream_arg.nextTree());
1449
1450 }
1451 stream_arg.reset();
1452
1453 }
1454
1455 retval.tree = root_0;
1456 }
1457 break;
1458
1459 }
1460 retval.stop = input.LT(-1);
1461
1462 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1463 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1464
1465 }
1466
1467 catch (RecognitionException e) {
1468 reportError(e);
1469 throw e;
1470 }
1471 finally {
1472 }
1473 return retval;
1474 }
1475
1476 public static class arg_return extends ParserRuleReturnScope {
1477 CommonTree tree;
1478 public Object getTree() { return tree; }
1479 };
1480
1481 public final QueryParser.arg_return arg() throws RecognitionException {
1482 QueryParser.arg_return retval = new QueryParser.arg_return();
1483 retval.start = input.LT(1);
1484
1485 CommonTree root_0 = null;
1486
1487 QueryParser.comparable_return comparable36 = null;
1488
1489 QueryParser.composite_return composite37 = null;
1490
1491 try {
1492 int alt21=2;
1493 int LA21_0 = input.LA(1);
1494
1495 if ( ((LA21_0>=FIX && LA21_0<=QUOTE)) ) {
1496 alt21=1;
1497 }
1498 else if ( (LA21_0==LPAREN) ) {
1499 alt21=2;
1500 }
1501 else {
1502 NoViableAltException nvae =
1503 new NoViableAltException("", 21, 0, input);
1504
1505 throw nvae;
1506 }
1507 switch (alt21) {
1508 case 1 :
1509 {
1510 root_0 = (CommonTree)adaptor.nil();
1511
1512 pushFollow(FOLLOW_comparable_in_arg721);
1513 comparable36=comparable();
1514
1515 state._fsp--;
1516
1517 adaptor.addChild(root_0, comparable36.getTree());
1518
1519 }
1520 break;
1521 case 2 :
1522 {
1523 root_0 = (CommonTree)adaptor.nil();
1524
1525 pushFollow(FOLLOW_composite_in_arg727);
1526 composite37=composite();
1527
1528 state._fsp--;
1529
1530 adaptor.addChild(root_0, composite37.getTree());
1531
1532 }
1533 break;
1534
1535 }
1536 retval.stop = input.LT(-1);
1537
1538 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1539 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1540
1541 }
1542
1543 catch (RecognitionException e) {
1544 reportError(e);
1545 throw e;
1546 }
1547 finally {
1548 }
1549 return retval;
1550 }
1551
1552 public static class andOp_return extends ParserRuleReturnScope {
1553 CommonTree tree;
1554 public Object getTree() { return tree; }
1555 };
1556
1557 public final QueryParser.andOp_return andOp() throws RecognitionException {
1558 QueryParser.andOp_return retval = new QueryParser.andOp_return();
1559 retval.start = input.LT(1);
1560
1561 CommonTree root_0 = null;
1562
1563 Token WS38=null;
1564 Token AND39=null;
1565 Token WS40=null;
1566
1567 CommonTree WS38_tree=null;
1568 CommonTree AND39_tree=null;
1569 CommonTree WS40_tree=null;
1570
1571 try {
1572 {
1573 root_0 = (CommonTree)adaptor.nil();
1574
1575 int cnt22=0;
1576 loop22:
1577 do {
1578 int alt22=2;
1579 int LA22_0 = input.LA(1);
1580
1581 if ( (LA22_0==WS) ) {
1582 alt22=1;
1583 }
1584
1585 switch (alt22) {
1586 case 1 :
1587 {
1588 WS38=(Token)match(input,WS,FOLLOW_WS_in_andOp741);
1589 WS38_tree = (CommonTree)adaptor.create(WS38);
1590 adaptor.addChild(root_0, WS38_tree);
1591
1592 }
1593 break;
1594
1595 default :
1596 if ( cnt22 >= 1 ) break loop22;
1597 EarlyExitException eee =
1598 new EarlyExitException(22, input);
1599 throw eee;
1600 }
1601 cnt22++;
1602 } while (true);
1603
1604 AND39=(Token)match(input,AND,FOLLOW_AND_in_andOp744);
1605 AND39_tree = (CommonTree)adaptor.create(AND39);
1606 adaptor.addChild(root_0, AND39_tree);
1607
1608 int cnt23=0;
1609 loop23:
1610 do {
1611 int alt23=2;
1612 int LA23_0 = input.LA(1);
1613
1614 if ( (LA23_0==WS) ) {
1615 alt23=1;
1616 }
1617
1618 switch (alt23) {
1619 case 1 :
1620 {
1621 WS40=(Token)match(input,WS,FOLLOW_WS_in_andOp746);
1622 WS40_tree = (CommonTree)adaptor.create(WS40);
1623 adaptor.addChild(root_0, WS40_tree);
1624
1625 }
1626 break;
1627
1628 default :
1629 if ( cnt23 >= 1 ) break loop23;
1630 EarlyExitException eee =
1631 new EarlyExitException(23, input);
1632 throw eee;
1633 }
1634 cnt23++;
1635 } while (true);
1636
1637 }
1638
1639 retval.stop = input.LT(-1);
1640
1641 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1642 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1643
1644 }
1645
1646 catch (RecognitionException e) {
1647 reportError(e);
1648 throw e;
1649 }
1650 finally {
1651 }
1652 return retval;
1653 }
1654
1655 public static class orOp_return extends ParserRuleReturnScope {
1656 CommonTree tree;
1657 public Object getTree() { return tree; }
1658 };
1659
1660 public final QueryParser.orOp_return orOp() throws RecognitionException {
1661 QueryParser.orOp_return retval = new QueryParser.orOp_return();
1662 retval.start = input.LT(1);
1663
1664 CommonTree root_0 = null;
1665
1666 Token WS41=null;
1667 Token OR42=null;
1668 Token WS43=null;
1669
1670 CommonTree WS41_tree=null;
1671 CommonTree OR42_tree=null;
1672 CommonTree WS43_tree=null;
1673
1674 try {
1675 {
1676 root_0 = (CommonTree)adaptor.nil();
1677
1678 int cnt24=0;
1679 loop24:
1680 do {
1681 int alt24=2;
1682 int LA24_0 = input.LA(1);
1683
1684 if ( (LA24_0==WS) ) {
1685 alt24=1;
1686 }
1687
1688 switch (alt24) {
1689 case 1 :
1690 {
1691 WS41=(Token)match(input,WS,FOLLOW_WS_in_orOp761);
1692 WS41_tree = (CommonTree)adaptor.create(WS41);
1693 adaptor.addChild(root_0, WS41_tree);
1694
1695 }
1696 break;
1697
1698 default :
1699 if ( cnt24 >= 1 ) break loop24;
1700 EarlyExitException eee =
1701 new EarlyExitException(24, input);
1702 throw eee;
1703 }
1704 cnt24++;
1705 } while (true);
1706
1707 OR42=(Token)match(input,OR,FOLLOW_OR_in_orOp764);
1708 OR42_tree = (CommonTree)adaptor.create(OR42);
1709 adaptor.addChild(root_0, OR42_tree);
1710
1711 int cnt25=0;
1712 loop25:
1713 do {
1714 int alt25=2;
1715 int LA25_0 = input.LA(1);
1716
1717 if ( (LA25_0==WS) ) {
1718 alt25=1;
1719 }
1720
1721 switch (alt25) {
1722 case 1 :
1723 {
1724 WS43=(Token)match(input,WS,FOLLOW_WS_in_orOp766);
1725 WS43_tree = (CommonTree)adaptor.create(WS43);
1726 adaptor.addChild(root_0, WS43_tree);
1727
1728 }
1729 break;
1730
1731 default :
1732 if ( cnt25 >= 1 ) break loop25;
1733 EarlyExitException eee =
1734 new EarlyExitException(25, input);
1735 throw eee;
1736 }
1737 cnt25++;
1738 } while (true);
1739
1740 }
1741
1742 retval.stop = input.LT(-1);
1743
1744 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1745 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1746
1747 }
1748
1749 catch (RecognitionException e) {
1750 reportError(e);
1751 throw e;
1752 }
1753 finally {
1754 }
1755 return retval;
1756 }
1757
1758 public static class notOp_return extends ParserRuleReturnScope {
1759 CommonTree tree;
1760 public Object getTree() { return tree; }
1761 };
1762
1763 public final QueryParser.notOp_return notOp() throws RecognitionException {
1764 QueryParser.notOp_return retval = new QueryParser.notOp_return();
1765 retval.start = input.LT(1);
1766
1767 CommonTree root_0 = null;
1768
1769 Token char_literal44=null;
1770 Token NOT45=null;
1771 Token WS46=null;
1772
1773 CommonTree char_literal44_tree=null;
1774 CommonTree NOT45_tree=null;
1775 CommonTree WS46_tree=null;
1776
1777 try {
1778 int alt27=2;
1779 int LA27_0 = input.LA(1);
1780
1781 if ( (LA27_0==MINUS) ) {
1782 alt27=1;
1783 }
1784 else if ( (LA27_0==NOT) ) {
1785 alt27=2;
1786 }
1787 else {
1788 NoViableAltException nvae =
1789 new NoViableAltException("", 27, 0, input);
1790
1791 throw nvae;
1792 }
1793 switch (alt27) {
1794 case 1 :
1795 {
1796 root_0 = (CommonTree)adaptor.nil();
1797
1798 char_literal44=(Token)match(input,MINUS,FOLLOW_MINUS_in_notOp781);
1799 char_literal44_tree = (CommonTree)adaptor.create(char_literal44);
1800 adaptor.addChild(root_0, char_literal44_tree);
1801
1802 }
1803 break;
1804 case 2 :
1805 {
1806 root_0 = (CommonTree)adaptor.nil();
1807
1808 NOT45=(Token)match(input,NOT,FOLLOW_NOT_in_notOp787);
1809 NOT45_tree = (CommonTree)adaptor.create(NOT45);
1810 adaptor.addChild(root_0, NOT45_tree);
1811
1812 int cnt26=0;
1813 loop26:
1814 do {
1815 int alt26=2;
1816 int LA26_0 = input.LA(1);
1817
1818 if ( (LA26_0==WS) ) {
1819 alt26=1;
1820 }
1821
1822 switch (alt26) {
1823 case 1 :
1824 {
1825 WS46=(Token)match(input,WS,FOLLOW_WS_in_notOp789);
1826 WS46_tree = (CommonTree)adaptor.create(WS46);
1827 adaptor.addChild(root_0, WS46_tree);
1828
1829 }
1830 break;
1831
1832 default :
1833 if ( cnt26 >= 1 ) break loop26;
1834 EarlyExitException eee =
1835 new EarlyExitException(26, input);
1836 throw eee;
1837 }
1838 cnt26++;
1839 } while (true);
1840
1841 }
1842 break;
1843
1844 }
1845 retval.stop = input.LT(-1);
1846
1847 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1848 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1849
1850 }
1851
1852 catch (RecognitionException e) {
1853 reportError(e);
1854 throw e;
1855 }
1856 finally {
1857 }
1858 return retval;
1859 }
1860
1861 public static class sep_return extends ParserRuleReturnScope {
1862 CommonTree tree;
1863 public Object getTree() { return tree; }
1864 };
1865
1866 public final QueryParser.sep_return sep() throws RecognitionException {
1867 QueryParser.sep_return retval = new QueryParser.sep_return();
1868 retval.start = input.LT(1);
1869
1870 CommonTree root_0 = null;
1871
1872 Token WS47=null;
1873 Token COMMA48=null;
1874 Token WS49=null;
1875
1876 CommonTree WS47_tree=null;
1877 CommonTree COMMA48_tree=null;
1878 CommonTree WS49_tree=null;
1879
1880 try {
1881 {
1882 root_0 = (CommonTree)adaptor.nil();
1883
1884 loop28:
1885 do {
1886 int alt28=2;
1887 int LA28_0 = input.LA(1);
1888
1889 if ( (LA28_0==WS) ) {
1890 alt28=1;
1891 }
1892
1893 switch (alt28) {
1894 case 1 :
1895 {
1896 WS47=(Token)match(input,WS,FOLLOW_WS_in_sep804);
1897 WS47_tree = (CommonTree)adaptor.create(WS47);
1898 adaptor.addChild(root_0, WS47_tree);
1899
1900 }
1901 break;
1902
1903 default :
1904 break loop28;
1905 }
1906 } while (true);
1907
1908 COMMA48=(Token)match(input,COMMA,FOLLOW_COMMA_in_sep807);
1909 COMMA48_tree = (CommonTree)adaptor.create(COMMA48);
1910 adaptor.addChild(root_0, COMMA48_tree);
1911
1912 loop29:
1913 do {
1914 int alt29=2;
1915 int LA29_0 = input.LA(1);
1916
1917 if ( (LA29_0==WS) ) {
1918 alt29=1;
1919 }
1920
1921 switch (alt29) {
1922 case 1 :
1923 {
1924 WS49=(Token)match(input,WS,FOLLOW_WS_in_sep809);
1925 WS49_tree = (CommonTree)adaptor.create(WS49);
1926 adaptor.addChild(root_0, WS49_tree);
1927
1928 }
1929 break;
1930
1931 default :
1932 break loop29;
1933 }
1934 } while (true);
1935
1936 }
1937
1938 retval.stop = input.LT(-1);
1939
1940 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1941 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1942
1943 }
1944
1945 catch (RecognitionException e) {
1946 reportError(e);
1947 throw e;
1948 }
1949 finally {
1950 }
1951 return retval;
1952 }
1953
1954 public static class composite_return extends ParserRuleReturnScope {
1955 CommonTree tree;
1956 public Object getTree() { return tree; }
1957 };
1958
1959 public final QueryParser.composite_return composite() throws RecognitionException {
1960 QueryParser.composite_return retval = new QueryParser.composite_return();
1961 retval.start = input.LT(1);
1962
1963 CommonTree root_0 = null;
1964
1965 Token LPAREN50=null;
1966 Token WS51=null;
1967 Token WS53=null;
1968 Token RPAREN54=null;
1969 QueryParser.expression_return expression52 = null;
1970
1971 CommonTree LPAREN50_tree=null;
1972 CommonTree WS51_tree=null;
1973 CommonTree WS53_tree=null;
1974 CommonTree RPAREN54_tree=null;
1975 RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
1976 RewriteRuleTokenStream stream_WS=new RewriteRuleTokenStream(adaptor,"token WS");
1977 RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
1978 RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
1979 try {
1980 {
1981 LPAREN50=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_composite825);
1982 stream_LPAREN.add(LPAREN50);
1983
1984 loop30:
1985 do {
1986 int alt30=2;
1987 int LA30_0 = input.LA(1);
1988
1989 if ( (LA30_0==WS) ) {
1990 alt30=1;
1991 }
1992
1993 switch (alt30) {
1994 case 1 :
1995 {
1996 WS51=(Token)match(input,WS,FOLLOW_WS_in_composite827);
1997 stream_WS.add(WS51);
1998
1999 }
2000 break;
2001
2002 default :
2003 break loop30;
2004 }
2005 } while (true);
2006
2007 pushFollow(FOLLOW_expression_in_composite830);
2008 expression52=expression();
2009
2010 state._fsp--;
2011
2012 stream_expression.add(expression52.getTree());
2013 loop31:
2014 do {
2015 int alt31=2;
2016 int LA31_0 = input.LA(1);
2017
2018 if ( (LA31_0==WS) ) {
2019 alt31=1;
2020 }
2021
2022 switch (alt31) {
2023 case 1 :
2024 {
2025 WS53=(Token)match(input,WS,FOLLOW_WS_in_composite832);
2026 stream_WS.add(WS53);
2027
2028 }
2029 break;
2030
2031 default :
2032 break loop31;
2033 }
2034 } while (true);
2035
2036 RPAREN54=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_composite835);
2037 stream_RPAREN.add(RPAREN54);
2038
2039 retval.tree = root_0;
2040 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
2041
2042 root_0 = (CommonTree)adaptor.nil();
2043 {
2044 adaptor.addChild(root_0, stream_expression.nextTree());
2045
2046 }
2047
2048 retval.tree = root_0;
2049 }
2050
2051 retval.stop = input.LT(-1);
2052
2053 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
2054 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2055
2056 }
2057
2058 catch (RecognitionException e) {
2059 reportError(e);
2060 throw e;
2061 }
2062 finally {
2063 }
2064 return retval;
2065 }
2066
2067 public static class item_return extends ParserRuleReturnScope {
2068 CommonTree tree;
2069 public Object getTree() { return tree; }
2070 };
2071
2072 public final QueryParser.item_return item() throws RecognitionException {
2073 QueryParser.item_return retval = new QueryParser.item_return();
2074 retval.start = input.LT(1);
2075
2076 CommonTree root_0 = null;
2077
2078 Token FIX55=null;
2079 Token REWRITE57=null;
2080 QueryParser.value_return value56 = null;
2081
2082 QueryParser.value_return value58 = null;
2083
2084 QueryParser.value_return value59 = null;
2085
2086 CommonTree FIX55_tree=null;
2087 CommonTree REWRITE57_tree=null;
2088 RewriteRuleTokenStream stream_FIX=new RewriteRuleTokenStream(adaptor,"token FIX");
2089 RewriteRuleTokenStream stream_REWRITE=new RewriteRuleTokenStream(adaptor,"token REWRITE");
2090 RewriteRuleSubtreeStream stream_value=new RewriteRuleSubtreeStream(adaptor,"rule value");
2091 try {
2092 int alt32=3;
2093 switch ( input.LA(1) ) {
2094 case FIX:
2095 {
2096 alt32=1;
2097 }
2098 break;
2099 case REWRITE:
2100 {
2101 alt32=2;
2102 }
2103 break;
2104 case TEXT:
2105 case QUOTE:
2106 {
2107 alt32=3;
2108 }
2109 break;
2110 default:
2111 NoViableAltException nvae =
2112 new NoViableAltException("", 32, 0, input);
2113
2114 throw nvae;
2115 }
2116
2117 switch (alt32) {
2118 case 1 :
2119 {
2120 FIX55=(Token)match(input,FIX,FOLLOW_FIX_in_item855);
2121 stream_FIX.add(FIX55);
2122
2123 pushFollow(FOLLOW_value_in_item857);
2124 value56=value();
2125
2126 state._fsp--;
2127
2128 stream_value.add(value56.getTree());
2129
2130 retval.tree = root_0;
2131 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
2132
2133 root_0 = (CommonTree)adaptor.nil();
2134 {
2135 {
2136 CommonTree root_1 = (CommonTree)adaptor.nil();
2137 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(LITERAL, "LITERAL"), root_1);
2138
2139 adaptor.addChild(root_1, stream_value.nextTree());
2140
2141 adaptor.addChild(root_0, root_1);
2142 }
2143
2144 }
2145
2146 retval.tree = root_0;
2147 }
2148 break;
2149 case 2 :
2150 {
2151 REWRITE57=(Token)match(input,REWRITE,FOLLOW_REWRITE_in_item871);
2152 stream_REWRITE.add(REWRITE57);
2153
2154 pushFollow(FOLLOW_value_in_item873);
2155 value58=value();
2156
2157 state._fsp--;
2158
2159 stream_value.add(value58.getTree());
2160
2161 retval.tree = root_0;
2162 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
2163
2164 root_0 = (CommonTree)adaptor.nil();
2165 {
2166 {
2167 CommonTree root_1 = (CommonTree)adaptor.nil();
2168 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(FUZZY, "FUZZY"), root_1);
2169
2170 adaptor.addChild(root_1, stream_value.nextTree());
2171
2172 adaptor.addChild(root_0, root_1);
2173 }
2174
2175 }
2176
2177 retval.tree = root_0;
2178 }
2179 break;
2180 case 3 :
2181 {
2182 pushFollow(FOLLOW_value_in_item887);
2183 value59=value();
2184
2185 state._fsp--;
2186
2187 stream_value.add(value59.getTree());
2188
2189 retval.tree = root_0;
2190 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
2191
2192 root_0 = (CommonTree)adaptor.nil();
2193 {
2194 adaptor.addChild(root_0, stream_value.nextTree());
2195
2196 }
2197
2198 retval.tree = root_0;
2199 }
2200 break;
2201
2202 }
2203 retval.stop = input.LT(-1);
2204
2205 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
2206 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2207
2208 }
2209
2210 catch (RecognitionException e) {
2211 reportError(e);
2212 throw e;
2213 }
2214 finally {
2215 }
2216 return retval;
2217 }
2218
2219 public static class value_return extends ParserRuleReturnScope {
2220 CommonTree tree;
2221 public Object getTree() { return tree; }
2222 };
2223
2224 public final QueryParser.value_return value() throws RecognitionException {
2225 QueryParser.value_return retval = new QueryParser.value_return();
2226 retval.start = input.LT(1);
2227
2228 CommonTree root_0 = null;
2229
2230 QueryParser.text_return text60 = null;
2231
2232 QueryParser.phrase_return phrase61 = null;
2233
2234 RewriteRuleSubtreeStream stream_text=new RewriteRuleSubtreeStream(adaptor,"rule text");
2235 RewriteRuleSubtreeStream stream_phrase=new RewriteRuleSubtreeStream(adaptor,"rule phrase");
2236 try {
2237 int alt33=2;
2238 int LA33_0 = input.LA(1);
2239
2240 if ( (LA33_0==TEXT) ) {
2241 alt33=1;
2242 }
2243 else if ( (LA33_0==QUOTE) ) {
2244 alt33=2;
2245 }
2246 else {
2247 NoViableAltException nvae =
2248 new NoViableAltException("", 33, 0, input);
2249
2250 throw nvae;
2251 }
2252 switch (alt33) {
2253 case 1 :
2254 {
2255 pushFollow(FOLLOW_text_in_value905);
2256 text60=text();
2257
2258 state._fsp--;
2259
2260 stream_text.add(text60.getTree());
2261
2262 retval.tree = root_0;
2263 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
2264
2265 root_0 = (CommonTree)adaptor.nil();
2266 {
2267 {
2268 CommonTree root_1 = (CommonTree)adaptor.nil();
2269 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(VALUE, "VALUE"), root_1);
2270
2271 adaptor.addChild(root_1, (CommonTree)adaptor.create(TEXT, "TEXT"));
2272 adaptor.addChild(root_1, stream_text.nextTree());
2273
2274 adaptor.addChild(root_0, root_1);
2275 }
2276
2277 }
2278
2279 retval.tree = root_0;
2280 }
2281 break;
2282 case 2 :
2283 {
2284 pushFollow(FOLLOW_phrase_in_value921);
2285 phrase61=phrase();
2286
2287 state._fsp--;
2288
2289 stream_phrase.add(phrase61.getTree());
2290
2291 retval.tree = root_0;
2292 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
2293
2294 root_0 = (CommonTree)adaptor.nil();
2295 {
2296 {
2297 CommonTree root_1 = (CommonTree)adaptor.nil();
2298 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(VALUE, "VALUE"), root_1);
2299
2300 adaptor.addChild(root_1, (CommonTree)adaptor.create(STRING, "STRING"));
2301 adaptor.addChild(root_1, stream_phrase.nextTree());
2302
2303 adaptor.addChild(root_0, root_1);
2304 }
2305
2306 }
2307
2308 retval.tree = root_0;
2309 }
2310 break;
2311
2312 }
2313 retval.stop = input.LT(-1);
2314
2315 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
2316 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2317
2318 }
2319
2320 catch (RecognitionException e) {
2321 reportError(e);
2322 throw e;
2323 }
2324 finally {
2325 }
2326 return retval;
2327 }
2328
2329 public static class text_return extends ParserRuleReturnScope {
2330 CommonTree tree;
2331 public Object getTree() { return tree; }
2332 };
2333
2334 public final QueryParser.text_return text() throws RecognitionException {
2335 QueryParser.text_return retval = new QueryParser.text_return();
2336 retval.start = input.LT(1);
2337
2338 CommonTree root_0 = null;
2339
2340 Token TEXT62=null;
2341
2342 CommonTree TEXT62_tree=null;
2343
2344 try {
2345 {
2346 root_0 = (CommonTree)adaptor.nil();
2347
2348 TEXT62=(Token)match(input,TEXT,FOLLOW_TEXT_in_text945);
2349 TEXT62_tree = (CommonTree)adaptor.create(TEXT62);
2350 adaptor.addChild(root_0, TEXT62_tree);
2351
2352 }
2353
2354 retval.stop = input.LT(-1);
2355
2356 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
2357 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2358
2359 }
2360
2361 catch (RecognitionException e) {
2362 reportError(e);
2363 throw e;
2364 }
2365 finally {
2366 }
2367 return retval;
2368 }
2369
2370 public static class phrase_return extends ParserRuleReturnScope {
2371 CommonTree tree;
2372 public Object getTree() { return tree; }
2373 };
2374
2375 public final QueryParser.phrase_return phrase() throws RecognitionException {
2376 QueryParser.phrase_return retval = new QueryParser.phrase_return();
2377 retval.start = input.LT(1);
2378
2379 CommonTree root_0 = null;
2380
2381 Token QUOTE63=null;
2382 Token set64=null;
2383 Token QUOTE65=null;
2384
2385 CommonTree QUOTE63_tree=null;
2386 CommonTree set64_tree=null;
2387 CommonTree QUOTE65_tree=null;
2388
2389 try {
2390 {
2391 root_0 = (CommonTree)adaptor.nil();
2392
2393 QUOTE63=(Token)match(input,QUOTE,FOLLOW_QUOTE_in_phrase959);
2394 QUOTE63_tree = (CommonTree)adaptor.create(QUOTE63);
2395 adaptor.addChild(root_0, QUOTE63_tree);
2396
2397 loop34:
2398 do {
2399 int alt34=2;
2400 int LA34_0 = input.LA(1);
2401
2402 if ( ((LA34_0>=ARGS && LA34_0<=TEXT)||(LA34_0>=UNICODE_ESC && LA34_0<=HEX_DIGIT)) ) {
2403 alt34=1;
2404 }
2405
2406 switch (alt34) {
2407 case 1 :
2408 {
2409 set64=(Token)input.LT(1);
2410 if ( (input.LA(1)>=ARGS && input.LA(1)<=TEXT)||(input.LA(1)>=UNICODE_ESC && input.LA(1)<=HEX_DIGIT) ) {
2411 input.consume();
2412 adaptor.addChild(root_0, (CommonTree)adaptor.create(set64));
2413 state.errorRecovery=false;
2414 }
2415 else {
2416 MismatchedSetException mse = new MismatchedSetException(null,input);
2417 throw mse;
2418 }
2419
2420 }
2421 break;
2422
2423 default :
2424 break loop34;
2425 }
2426 } while (true);
2427
2428 QUOTE65=(Token)match(input,QUOTE,FOLLOW_QUOTE_in_phrase965);
2429 QUOTE65_tree = (CommonTree)adaptor.create(QUOTE65);
2430 adaptor.addChild(root_0, QUOTE65_tree);
2431
2432 }
2433
2434 retval.stop = input.LT(-1);
2435
2436 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
2437 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2438
2439 }
2440
2441 catch (RecognitionException e) {
2442 reportError(e);
2443 throw e;
2444 }
2445 finally {
2446 }
2447 return retval;
2448 }
2449
2450 protected DFA4 dfa4 = new DFA4(this);
2451 protected DFA6 dfa6 = new DFA6(this);
2452 protected DFA5 dfa5 = new DFA5(this);
2453 protected DFA9 dfa9 = new DFA9(this);
2454 protected DFA8 dfa8 = new DFA8(this);
2455 protected DFA11 dfa11 = new DFA11(this);
2456 protected DFA10 dfa10 = new DFA10(this);
2457 protected DFA14 dfa14 = new DFA14(this);
2458 static final String DFA4_eotS =
2459 "\4\uffff";
2460 static final String DFA4_eofS =
2461 "\2\2\2\uffff";
2462 static final String DFA4_minS =
2463 "\2\20\2\uffff";
2464 static final String DFA4_maxS =
2465 "\2\46\2\uffff";
2466 static final String DFA4_acceptS =
2467 "\2\uffff\1\1\1\2";
2468 static final String DFA4_specialS =
2469 "\4\uffff}>";
2470 static final String[] DFA4_transitionS = {
2471 "\1\1\7\uffff\1\3\3\uffff\1\3\1\uffff\4\3\4\uffff\1\3",
2472 "\1\1\7\uffff\1\3\3\uffff\1\3\1\uffff\4\3\4\uffff\1\3",
2473 "",
2474 ""
2475 };
2476
2477 static final short[] DFA4_eot = DFA.unpackEncodedString(DFA4_eotS);
2478 static final short[] DFA4_eof = DFA.unpackEncodedString(DFA4_eofS);
2479 static final char[] DFA4_min = DFA.unpackEncodedStringToUnsignedChars(DFA4_minS);
2480 static final char[] DFA4_max = DFA.unpackEncodedStringToUnsignedChars(DFA4_maxS);
2481 static final short[] DFA4_accept = DFA.unpackEncodedString(DFA4_acceptS);
2482 static final short[] DFA4_special = DFA.unpackEncodedString(DFA4_specialS);
2483 static final short[][] DFA4_transition;
2484
2485 static {
2486 int numStates = DFA4_transitionS.length;
2487 DFA4_transition = new short[numStates][];
2488 for (int i=0; i<numStates; i++) {
2489 DFA4_transition[i] = DFA.unpackEncodedString(DFA4_transitionS[i]);
2490 }
2491 }
2492
2493 class DFA4 extends DFA {
2494
2495 public DFA4(BaseRecognizer recognizer) {
2496 this.recognizer = recognizer;
2497 this.decisionNumber = 4;
2498 this.eot = DFA4_eot;
2499 this.eof = DFA4_eof;
2500 this.min = DFA4_min;
2501 this.max = DFA4_max;
2502 this.accept = DFA4_accept;
2503 this.special = DFA4_special;
2504 this.transition = DFA4_transition;
2505 }
2506 public String getDescription() {
2507 return "59:1: query : ( ( WS )* EOF -> ^( EMPTY ) | ( WS )* expression ( WS )* EOF -> expression );";
2508 }
2509 }
2510 static final String DFA6_eotS =
2511 "\4\uffff";
2512 static final String DFA6_eofS =
2513 "\2\2\2\uffff";
2514 static final String DFA6_minS =
2515 "\2\20\2\uffff";
2516 static final String DFA6_maxS =
2517 "\1\31\1\32\2\uffff";
2518 static final String DFA6_acceptS =
2519 "\2\uffff\1\1\1\2";
2520 static final String DFA6_specialS =
2521 "\4\uffff}>";
2522 static final String[] DFA6_transitionS = {
2523 "\1\1\10\uffff\1\2",
2524 "\1\1\10\uffff\1\2\1\3",
2525 "",
2526 ""
2527 };
2528
2529 static final short[] DFA6_eot = DFA.unpackEncodedString(DFA6_eotS);
2530 static final short[] DFA6_eof = DFA.unpackEncodedString(DFA6_eofS);
2531 static final char[] DFA6_min = DFA.unpackEncodedStringToUnsignedChars(DFA6_minS);
2532 static final char[] DFA6_max = DFA.unpackEncodedStringToUnsignedChars(DFA6_maxS);
2533 static final short[] DFA6_accept = DFA.unpackEncodedString(DFA6_acceptS);
2534 static final short[] DFA6_special = DFA.unpackEncodedString(DFA6_specialS);
2535 static final short[][] DFA6_transition;
2536
2537 static {
2538 int numStates = DFA6_transitionS.length;
2539 DFA6_transition = new short[numStates][];
2540 for (int i=0; i<numStates; i++) {
2541 DFA6_transition[i] = DFA.unpackEncodedString(DFA6_transitionS[i]);
2542 }
2543 }
2544
2545 class DFA6 extends DFA {
2546
2547 public DFA6(BaseRecognizer recognizer) {
2548 this.recognizer = recognizer;
2549 this.decisionNumber = 6;
2550 this.eot = DFA6_eot;
2551 this.eof = DFA6_eof;
2552 this.min = DFA6_min;
2553 this.max = DFA6_max;
2554 this.accept = DFA6_accept;
2555 this.special = DFA6_special;
2556 this.transition = DFA6_transition;
2557 }
2558 public String getDescription() {
2559 return "67:16: ( -> sequence | ( andOp sequence )+ -> ^( CONJUNCTION ( sequence )+ ) )";
2560 }
2561 }
2562 static final String DFA5_eotS =
2563 "\4\uffff";
2564 static final String DFA5_eofS =
2565 "\2\2\2\uffff";
2566 static final String DFA5_minS =
2567 "\2\20\2\uffff";
2568 static final String DFA5_maxS =
2569 "\1\31\1\32\2\uffff";
2570 static final String DFA5_acceptS =
2571 "\2\uffff\1\2\1\1";
2572 static final String DFA5_specialS =
2573 "\4\uffff}>";
2574 static final String[] DFA5_transitionS = {
2575 "\1\1\10\uffff\1\2",
2576 "\1\1\10\uffff\1\2\1\3",
2577 "",
2578 ""
2579 };
2580
2581 static final short[] DFA5_eot = DFA.unpackEncodedString(DFA5_eotS);
2582 static final short[] DFA5_eof = DFA.unpackEncodedString(DFA5_eofS);
2583 static final char[] DFA5_min = DFA.unpackEncodedStringToUnsignedChars(DFA5_minS);
2584 static final char[] DFA5_max = DFA.unpackEncodedStringToUnsignedChars(DFA5_maxS);
2585 static final short[] DFA5_accept = DFA.unpackEncodedString(DFA5_acceptS);
2586 static final short[] DFA5_special = DFA.unpackEncodedString(DFA5_specialS);
2587 static final short[][] DFA5_transition;
2588
2589 static {
2590 int numStates = DFA5_transitionS.length;
2591 DFA5_transition = new short[numStates][];
2592 for (int i=0; i<numStates; i++) {
2593 DFA5_transition[i] = DFA.unpackEncodedString(DFA5_transitionS[i]);
2594 }
2595 }
2596
2597 class DFA5 extends DFA {
2598
2599 public DFA5(BaseRecognizer recognizer) {
2600 this.recognizer = recognizer;
2601 this.decisionNumber = 5;
2602 this.eot = DFA5_eot;
2603 this.eof = DFA5_eof;
2604 this.min = DFA5_min;
2605 this.max = DFA5_max;
2606 this.accept = DFA5_accept;
2607 this.special = DFA5_special;
2608 this.transition = DFA5_transition;
2609 }
2610 public String getDescription() {
2611 return "()+ loopback of 69:11: ( andOp sequence )+";
2612 }
2613 }
2614 static final String DFA9_eotS =
2615 "\4\uffff";
2616 static final String DFA9_eofS =
2617 "\2\2\2\uffff";
2618 static final String DFA9_minS =
2619 "\2\20\2\uffff";
2620 static final String DFA9_maxS =
2621 "\1\31\1\46\2\uffff";
2622 static final String DFA9_acceptS =
2623 "\2\uffff\1\1\1\2";
2624 static final String DFA9_specialS =
2625 "\4\uffff}>";
2626 static final String[] DFA9_transitionS = {
2627 "\1\1\10\uffff\1\2",
2628 "\1\1\7\uffff\1\3\2\2\1\uffff\1\3\1\uffff\4\3\4\uffff\1\3",
2629 "",
2630 ""
2631 };
2632
2633 static final short[] DFA9_eot = DFA.unpackEncodedString(DFA9_eotS);
2634 static final short[] DFA9_eof = DFA.unpackEncodedString(DFA9_eofS);
2635 static final char[] DFA9_min = DFA.unpackEncodedStringToUnsignedChars(DFA9_minS);
2636 static final char[] DFA9_max = DFA.unpackEncodedStringToUnsignedChars(DFA9_maxS);
2637 static final short[] DFA9_accept = DFA.unpackEncodedString(DFA9_acceptS);
2638 static final short[] DFA9_special = DFA.unpackEncodedString(DFA9_specialS);
2639 static final short[][] DFA9_transition;
2640
2641 static {
2642 int numStates = DFA9_transitionS.length;
2643 DFA9_transition = new short[numStates][];
2644 for (int i=0; i<numStates; i++) {
2645 DFA9_transition[i] = DFA.unpackEncodedString(DFA9_transitionS[i]);
2646 }
2647 }
2648
2649 class DFA9 extends DFA {
2650
2651 public DFA9(BaseRecognizer recognizer) {
2652 this.recognizer = recognizer;
2653 this.decisionNumber = 9;
2654 this.eot = DFA9_eot;
2655 this.eof = DFA9_eof;
2656 this.min = DFA9_min;
2657 this.max = DFA9_max;
2658 this.accept = DFA9_accept;
2659 this.special = DFA9_special;
2660 this.transition = DFA9_transition;
2661 }
2662 public String getDescription() {
2663 return "76:14: ( -> factor | ( ( WS )+ factor )+ -> ^( SEQUENCE ( factor )+ ) )";
2664 }
2665 }
2666 static final String DFA8_eotS =
2667 "\4\uffff";
2668 static final String DFA8_eofS =
2669 "\2\2\2\uffff";
2670 static final String DFA8_minS =
2671 "\2\20\2\uffff";
2672 static final String DFA8_maxS =
2673 "\1\31\1\46\2\uffff";
2674 static final String DFA8_acceptS =
2675 "\2\uffff\1\2\1\1";
2676 static final String DFA8_specialS =
2677 "\4\uffff}>";
2678 static final String[] DFA8_transitionS = {
2679 "\1\1\10\uffff\1\2",
2680 "\1\1\7\uffff\1\3\2\2\1\uffff\1\3\1\uffff\4\3\4\uffff\1\3",
2681 "",
2682 ""
2683 };
2684
2685 static final short[] DFA8_eot = DFA.unpackEncodedString(DFA8_eotS);
2686 static final short[] DFA8_eof = DFA.unpackEncodedString(DFA8_eofS);
2687 static final char[] DFA8_min = DFA.unpackEncodedStringToUnsignedChars(DFA8_minS);
2688 static final char[] DFA8_max = DFA.unpackEncodedStringToUnsignedChars(DFA8_maxS);
2689 static final short[] DFA8_accept = DFA.unpackEncodedString(DFA8_acceptS);
2690 static final short[] DFA8_special = DFA.unpackEncodedString(DFA8_specialS);
2691 static final short[][] DFA8_transition;
2692
2693 static {
2694 int numStates = DFA8_transitionS.length;
2695 DFA8_transition = new short[numStates][];
2696 for (int i=0; i<numStates; i++) {
2697 DFA8_transition[i] = DFA.unpackEncodedString(DFA8_transitionS[i]);
2698 }
2699 }
2700
2701 class DFA8 extends DFA {
2702
2703 public DFA8(BaseRecognizer recognizer) {
2704 this.recognizer = recognizer;
2705 this.decisionNumber = 8;
2706 this.eot = DFA8_eot;
2707 this.eof = DFA8_eof;
2708 this.min = DFA8_min;
2709 this.max = DFA8_max;
2710 this.accept = DFA8_accept;
2711 this.special = DFA8_special;
2712 this.transition = DFA8_transition;
2713 }
2714 public String getDescription() {
2715 return "()+ loopback of 78:11: ( ( WS )+ factor )+";
2716 }
2717 }
2718 static final String DFA11_eotS =
2719 "\4\uffff";
2720 static final String DFA11_eofS =
2721 "\2\2\2\uffff";
2722 static final String DFA11_minS =
2723 "\2\20\2\uffff";
2724 static final String DFA11_maxS =
2725 "\1\31\1\46\2\uffff";
2726 static final String DFA11_acceptS =
2727 "\2\uffff\1\1\1\2";
2728 static final String DFA11_specialS =
2729 "\4\uffff}>";
2730 static final String[] DFA11_transitionS = {
2731 "\1\1\10\uffff\1\2",
2732 "\1\1\7\uffff\3\2\1\3\1\2\1\uffff\4\2\4\uffff\1\2",
2733 "",
2734 ""
2735 };
2736
2737 static final short[] DFA11_eot = DFA.unpackEncodedString(DFA11_eotS);
2738 static final short[] DFA11_eof = DFA.unpackEncodedString(DFA11_eofS);
2739 static final char[] DFA11_min = DFA.unpackEncodedStringToUnsignedChars(DFA11_minS);
2740 static final char[] DFA11_max = DFA.unpackEncodedStringToUnsignedChars(DFA11_maxS);
2741 static final short[] DFA11_accept = DFA.unpackEncodedString(DFA11_acceptS);
2742 static final short[] DFA11_special = DFA.unpackEncodedString(DFA11_specialS);
2743 static final short[][] DFA11_transition;
2744
2745 static {
2746 int numStates = DFA11_transitionS.length;
2747 DFA11_transition = new short[numStates][];
2748 for (int i=0; i<numStates; i++) {
2749 DFA11_transition[i] = DFA.unpackEncodedString(DFA11_transitionS[i]);
2750 }
2751 }
2752
2753 class DFA11 extends DFA {
2754
2755 public DFA11(BaseRecognizer recognizer) {
2756 this.recognizer = recognizer;
2757 this.decisionNumber = 11;
2758 this.eot = DFA11_eot;
2759 this.eof = DFA11_eof;
2760 this.min = DFA11_min;
2761 this.max = DFA11_max;
2762 this.accept = DFA11_accept;
2763 this.special = DFA11_special;
2764 this.transition = DFA11_transition;
2765 }
2766 public String getDescription() {
2767 return "85:12: ( -> term | ( orOp term )+ -> ^( DISJUNCTION ( term )+ ) )";
2768 }
2769 }
2770 static final String DFA10_eotS =
2771 "\4\uffff";
2772 static final String DFA10_eofS =
2773 "\2\2\2\uffff";
2774 static final String DFA10_minS =
2775 "\2\20\2\uffff";
2776 static final String DFA10_maxS =
2777 "\1\31\1\46\2\uffff";
2778 static final String DFA10_acceptS =
2779 "\2\uffff\1\2\1\1";
2780 static final String DFA10_specialS =
2781 "\4\uffff}>";
2782 static final String[] DFA10_transitionS = {
2783 "\1\1\10\uffff\1\2",
2784 "\1\1\7\uffff\3\2\1\3\1\2\1\uffff\4\2\4\uffff\1\2",
2785 "",
2786 ""
2787 };
2788
2789 static final short[] DFA10_eot = DFA.unpackEncodedString(DFA10_eotS);
2790 static final short[] DFA10_eof = DFA.unpackEncodedString(DFA10_eofS);
2791 static final char[] DFA10_min = DFA.unpackEncodedStringToUnsignedChars(DFA10_minS);
2792 static final char[] DFA10_max = DFA.unpackEncodedStringToUnsignedChars(DFA10_maxS);
2793 static final short[] DFA10_accept = DFA.unpackEncodedString(DFA10_acceptS);
2794 static final short[] DFA10_special = DFA.unpackEncodedString(DFA10_specialS);
2795 static final short[][] DFA10_transition;
2796
2797 static {
2798 int numStates = DFA10_transitionS.length;
2799 DFA10_transition = new short[numStates][];
2800 for (int i=0; i<numStates; i++) {
2801 DFA10_transition[i] = DFA.unpackEncodedString(DFA10_transitionS[i]);
2802 }
2803 }
2804
2805 class DFA10 extends DFA {
2806
2807 public DFA10(BaseRecognizer recognizer) {
2808 this.recognizer = recognizer;
2809 this.decisionNumber = 10;
2810 this.eot = DFA10_eot;
2811 this.eof = DFA10_eof;
2812 this.min = DFA10_min;
2813 this.max = DFA10_max;
2814 this.accept = DFA10_accept;
2815 this.special = DFA10_special;
2816 this.transition = DFA10_transition;
2817 }
2818 public String getDescription() {
2819 return "()+ loopback of 87:11: ( orOp term )+";
2820 }
2821 }
2822 static final String DFA14_eotS =
2823 "\4\uffff";
2824 static final String DFA14_eofS =
2825 "\2\2\2\uffff";
2826 static final String DFA14_minS =
2827 "\2\20\2\uffff";
2828 static final String DFA14_maxS =
2829 "\1\31\1\46\2\uffff";
2830 static final String DFA14_acceptS =
2831 "\2\uffff\1\1\1\2";
2832 static final String DFA14_specialS =
2833 "\4\uffff}>";
2834 static final String[] DFA14_transitionS = {
2835 "\1\1\7\3\1\uffff\1\2",
2836 "\1\1\7\3\5\2\1\uffff\4\2\4\uffff\1\2",
2837 "",
2838 ""
2839 };
2840
2841 static final short[] DFA14_eot = DFA.unpackEncodedString(DFA14_eotS);
2842 static final short[] DFA14_eof = DFA.unpackEncodedString(DFA14_eofS);
2843 static final char[] DFA14_min = DFA.unpackEncodedStringToUnsignedChars(DFA14_minS);
2844 static final char[] DFA14_max = DFA.unpackEncodedStringToUnsignedChars(DFA14_maxS);
2845 static final short[] DFA14_accept = DFA.unpackEncodedString(DFA14_acceptS);
2846 static final short[] DFA14_special = DFA.unpackEncodedString(DFA14_specialS);
2847 static final short[][] DFA14_transition;
2848
2849 static {
2850 int numStates = DFA14_transitionS.length;
2851 DFA14_transition = new short[numStates][];
2852 for (int i=0; i<numStates; i++) {
2853 DFA14_transition[i] = DFA.unpackEncodedString(DFA14_transitionS[i]);
2854 }
2855 }
2856
2857 class DFA14 extends DFA {
2858
2859 public DFA14(BaseRecognizer recognizer) {
2860 this.recognizer = recognizer;
2861 this.decisionNumber = 14;
2862 this.eot = DFA14_eot;
2863 this.eof = DFA14_eof;
2864 this.min = DFA14_min;
2865 this.max = DFA14_max;
2866 this.accept = DFA14_accept;
2867 this.special = DFA14_special;
2868 this.transition = DFA14_transition;
2869 }
2870 public String getDescription() {
2871 return "111:16: ( -> ^( HAS GLOBAL comparable ) | comparator arg -> ^( comparator comparable arg ) )";
2872 }
2873 }
2874
2875 public static final BitSet FOLLOW_WS_in_query137 = new BitSet(new long[]{0x0000000000010000L});
2876 public static final BitSet FOLLOW_EOF_in_query140 = new BitSet(new long[]{0x0000000000000002L});
2877 public static final BitSet FOLLOW_WS_in_query169 = new BitSet(new long[]{0x00000043D1010000L});
2878 public static final BitSet FOLLOW_expression_in_query172 = new BitSet(new long[]{0x0000000000010000L});
2879 public static final BitSet FOLLOW_WS_in_query174 = new BitSet(new long[]{0x0000000000010000L});
2880 public static final BitSet FOLLOW_EOF_in_query177 = new BitSet(new long[]{0x0000000000000002L});
2881 public static final BitSet FOLLOW_sequence_in_expression200 = new BitSet(new long[]{0x0000000000010002L});
2882 public static final BitSet FOLLOW_andOp_in_expression237 = new BitSet(new long[]{0x00000043D1000000L});
2883 public static final BitSet FOLLOW_sequence_in_expression239 = new BitSet(new long[]{0x00000043D1010002L});
2884 public static final BitSet FOLLOW_factor_in_sequence277 = new BitSet(new long[]{0x0000000000010002L});
2885 public static final BitSet FOLLOW_WS_in_sequence313 = new BitSet(new long[]{0x00000043D1010000L});
2886 public static final BitSet FOLLOW_factor_in_sequence316 = new BitSet(new long[]{0x0000000000010002L});
2887 public static final BitSet FOLLOW_term_in_factor357 = new BitSet(new long[]{0x0000000000010002L});
2888 public static final BitSet FOLLOW_orOp_in_factor389 = new BitSet(new long[]{0x00000043D1000000L});
2889 public static final BitSet FOLLOW_term_in_factor391 = new BitSet(new long[]{0x00000043D1010002L});
2890 public static final BitSet FOLLOW_primitive_in_term425 = new BitSet(new long[]{0x0000000000000002L});
2891 public static final BitSet FOLLOW_notOp_in_term431 = new BitSet(new long[]{0x00000003C1000000L});
2892 public static final BitSet FOLLOW_primitive_in_term433 = new BitSet(new long[]{0x0000000000000002L});
2893 public static final BitSet FOLLOW_restriction_in_primitive459 = new BitSet(new long[]{0x0000000000000002L});
2894 public static final BitSet FOLLOW_composite_in_primitive465 = new BitSet(new long[]{0x0000000000000002L});
2895 public static final BitSet FOLLOW_comparable_in_restriction482 = new BitSet(new long[]{0x0000000000FF0002L});
2896 public static final BitSet FOLLOW_comparator_in_restriction517 = new BitSet(new long[]{0x00000003C1000000L});
2897 public static final BitSet FOLLOW_arg_in_restriction519 = new BitSet(new long[]{0x0000000000000002L});
2898 public static final BitSet FOLLOW_WS_in_comparator549 = new BitSet(new long[]{0x0000000000FF0000L});
2899 public static final BitSet FOLLOW_LE_in_comparator555 = new BitSet(new long[]{0x0000000000010002L});
2900 public static final BitSet FOLLOW_LESSTHAN_in_comparator561 = new BitSet(new long[]{0x0000000000010002L});
2901 public static final BitSet FOLLOW_GE_in_comparator567 = new BitSet(new long[]{0x0000000000010002L});
2902 public static final BitSet FOLLOW_GT_in_comparator573 = new BitSet(new long[]{0x0000000000010002L});
2903 public static final BitSet FOLLOW_NE_in_comparator579 = new BitSet(new long[]{0x0000000000010002L});
2904 public static final BitSet FOLLOW_EQ_in_comparator585 = new BitSet(new long[]{0x0000000000010002L});
2905 public static final BitSet FOLLOW_HAS_in_comparator591 = new BitSet(new long[]{0x0000000000010002L});
2906 public static final BitSet FOLLOW_WS_in_comparator594 = new BitSet(new long[]{0x0000000000010002L});
2907 public static final BitSet FOLLOW_member_in_comparable616 = new BitSet(new long[]{0x0000000000000002L});
2908 public static final BitSet FOLLOW_function_in_comparable622 = new BitSet(new long[]{0x0000000000000002L});
2909 public static final BitSet FOLLOW_item_in_member637 = new BitSet(new long[]{0x0000000000000002L});
2910 public static final BitSet FOLLOW_text_in_function654 = new BitSet(new long[]{0x0000000001000000L});
2911 public static final BitSet FOLLOW_LPAREN_in_function656 = new BitSet(new long[]{0x00000003C3000000L});
2912 public static final BitSet FOLLOW_arglist_in_function658 = new BitSet(new long[]{0x0000000002000000L});
2913 public static final BitSet FOLLOW_RPAREN_in_function660 = new BitSet(new long[]{0x0000000000000002L});
2914 public static final BitSet FOLLOW_arg_in_arglist695 = new BitSet(new long[]{0x0000000020010002L});
2915 public static final BitSet FOLLOW_sep_in_arglist698 = new BitSet(new long[]{0x00000003C1000000L});
2916 public static final BitSet FOLLOW_arg_in_arglist700 = new BitSet(new long[]{0x0000000020010002L});
2917 public static final BitSet FOLLOW_comparable_in_arg721 = new BitSet(new long[]{0x0000000000000002L});
2918 public static final BitSet FOLLOW_composite_in_arg727 = new BitSet(new long[]{0x0000000000000002L});
2919 public static final BitSet FOLLOW_WS_in_andOp741 = new BitSet(new long[]{0x0000000004010000L});
2920 public static final BitSet FOLLOW_AND_in_andOp744 = new BitSet(new long[]{0x0000000000010000L});
2921 public static final BitSet FOLLOW_WS_in_andOp746 = new BitSet(new long[]{0x0000000000010002L});
2922 public static final BitSet FOLLOW_WS_in_orOp761 = new BitSet(new long[]{0x0000000008010000L});
2923 public static final BitSet FOLLOW_OR_in_orOp764 = new BitSet(new long[]{0x0000000000010000L});
2924 public static final BitSet FOLLOW_WS_in_orOp766 = new BitSet(new long[]{0x0000000000010002L});
2925 public static final BitSet FOLLOW_MINUS_in_notOp781 = new BitSet(new long[]{0x0000000000000002L});
2926 public static final BitSet FOLLOW_NOT_in_notOp787 = new BitSet(new long[]{0x0000000000010000L});
2927 public static final BitSet FOLLOW_WS_in_notOp789 = new BitSet(new long[]{0x0000000000010002L});
2928 public static final BitSet FOLLOW_WS_in_sep804 = new BitSet(new long[]{0x0000000020010000L});
2929 public static final BitSet FOLLOW_COMMA_in_sep807 = new BitSet(new long[]{0x0000000000010002L});
2930 public static final BitSet FOLLOW_WS_in_sep809 = new BitSet(new long[]{0x0000000000010002L});
2931 public static final BitSet FOLLOW_LPAREN_in_composite825 = new BitSet(new long[]{0x00000043D1010000L});
2932 public static final BitSet FOLLOW_WS_in_composite827 = new BitSet(new long[]{0x00000043D1010000L});
2933 public static final BitSet FOLLOW_expression_in_composite830 = new BitSet(new long[]{0x0000000002010000L});
2934 public static final BitSet FOLLOW_WS_in_composite832 = new BitSet(new long[]{0x0000000002010000L});
2935 public static final BitSet FOLLOW_RPAREN_in_composite835 = new BitSet(new long[]{0x0000000000000002L});
2936 public static final BitSet FOLLOW_FIX_in_item855 = new BitSet(new long[]{0x00000003C0000000L});
2937 public static final BitSet FOLLOW_value_in_item857 = new BitSet(new long[]{0x0000000000000002L});
2938 public static final BitSet FOLLOW_REWRITE_in_item871 = new BitSet(new long[]{0x00000003C0000000L});
2939 public static final BitSet FOLLOW_value_in_item873 = new BitSet(new long[]{0x0000000000000002L});
2940 public static final BitSet FOLLOW_value_in_item887 = new BitSet(new long[]{0x0000000000000002L});
2941 public static final BitSet FOLLOW_text_in_value905 = new BitSet(new long[]{0x0000000000000002L});
2942 public static final BitSet FOLLOW_phrase_in_value921 = new BitSet(new long[]{0x0000000000000002L});
2943 public static final BitSet FOLLOW_TEXT_in_text945 = new BitSet(new long[]{0x0000000000000002L});
2944 public static final BitSet FOLLOW_QUOTE_in_phrase959 = new BitSet(new long[]{0x00003FFFFFFFFFF0L});
2945 public static final BitSet FOLLOW_set_in_phrase961 = new BitSet(new long[]{0x00003FFFFFFFFFF0L});
2946 public static final BitSet FOLLOW_QUOTE_in_phrase965 = new BitSet(new long[]{0x0000000000000002L});
2947
2948 }
google appengine git mirror