java/src/main/com/google/appengine/api/search/query/QueryParser.java

   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", "FUNCTION", "FUZZY", "GLOBAL", "LITERAL", "NEGATION", "STRING", "SEQUENCE", "VALUE", "WS", "LE", "LT", "GE", "GT", "NE", "EQ", "HAS", "LPAREN", "RPAREN", "AND", "OR", "NOT", "DISTANCE_FN", "GEO_POINT_FN", "FIX", "REWRITE", "TEXT", "QUOTE", "ESC", "UNICODE_ESC", "OCTAL_ESC", "CHAR_SEQ", "DIGIT", "MID_CHAR", "ESCAPED_CHAR", "START_CHAR", "HEX_DIGIT", "'-'", "','", "'\\\\'"
  12     };
  13     public static final int FUNCTION=7;
  14     public static final int LT=17;
  15     public static final int GEO_POINT_FN=29;
  16     public static final int FIX=30;
  17     public static final int ESC=34;
  18     public static final int FUZZY=8;
  19     public static final int OCTAL_ESC=36;
  20     public static final int NOT=27;
  21     public static final int AND=25;
  22     public static final int DISTANCE_FN=28;
  23     public static final int EOF=-1;
  24     public static final int ESCAPED_CHAR=40;
  25     public static final int LPAREN=23;
  26     public static final int HAS=22;
  27     public static final int RPAREN=24;
  28     public static final int QUOTE=33;
  29     public static final int CHAR_SEQ=37;
  30     public static final int START_CHAR=41;
  31     public static final int ARGS=4;
  32     public static final int DIGIT=38;
  33     public static final int EQ=21;
  34     public static final int NE=20;
  35     public static final int T__43=43;
  36     public static final int GE=18;
  37     public static final int T__44=44;
  38     public static final int T__45=45;
  39     public static final int CONJUNCTION=5;
  40     public static final int UNICODE_ESC=35;
  41     public static final int HEX_DIGIT=42;
  42     public static final int LITERAL=10;
  43     public static final int VALUE=14;
  44     public static final int TEXT=32;
  45     public static final int REWRITE=31;
  46     public static final int SEQUENCE=13;
  47     public static final int DISJUNCTION=6;
  48     public static final int WS=15;
  49     public static final int NEGATION=11;
  50     public static final int OR=26;
  51     public static final int GT=19;
  52     public static final int GLOBAL=9;
  53     public static final int LE=16;
  54     public static final int MID_CHAR=39;
  55     public static final int STRING=12;
  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 "java/com/google/appengine/api/search/query/Query.g"; }
  76
  77     public static class query_return extends ParserRuleReturnScope {
  78         CommonTree tree;
  79         public Object getTree() { return tree; }
  80     };
  81
  82     public final QueryParser.query_return query() throws RecognitionException {
  83         QueryParser.query_return retval = new QueryParser.query_return();
  84         retval.start = input.LT(1);
  85
  86         CommonTree root_0 = null;
  87
  88         Token WS1=null;
  89         Token WS3=null;
  90         Token EOF4=null;
  91         QueryParser.expression_return expression2 = null;
  92
  93         CommonTree WS1_tree=null;
  94         CommonTree WS3_tree=null;
  95         CommonTree EOF4_tree=null;
  96         RewriteRuleTokenStream stream_WS=new RewriteRuleTokenStream(adaptor,"token WS");
  97         RewriteRuleTokenStream stream_EOF=new RewriteRuleTokenStream(adaptor,"token EOF");
  98         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
  99         try {
 100             {
 101             loop1:
 102             do {
 103                 int alt1=2;
 104                 int LA1_0 = input.LA(1);
 105
 106                 if ( (LA1_0==WS) ) {
 107                     alt1=1;
 108                 }
 109
 110                 switch (alt1) {
 111                 case 1 :
 112                     {
 113                     WS1=(Token)match(input,WS,FOLLOW_WS_in_query121);
 114                     stream_WS.add(WS1);
 115
 116                     }
 117                     break;
 118
 119                 default :
 120                     break loop1;
 121                 }
 122             } while (true);
 123
 124             pushFollow(FOLLOW_expression_in_query124);
 125             expression2=expression();
 126
 127             state._fsp--;
 128
 129             stream_expression.add(expression2.getTree());
 130             loop2:
 131             do {
 132                 int alt2=2;
 133                 int LA2_0 = input.LA(1);
 134
 135                 if ( (LA2_0==WS) ) {
 136                     alt2=1;
 137                 }
 138
 139                 switch (alt2) {
 140                 case 1 :
 141                     {
 142                     WS3=(Token)match(input,WS,FOLLOW_WS_in_query126);
 143                     stream_WS.add(WS3);
 144
 145                     }
 146                     break;
 147
 148                 default :
 149                     break loop2;
 150                 }
 151             } while (true);
 152
 153             EOF4=(Token)match(input,EOF,FOLLOW_EOF_in_query129);
 154             stream_EOF.add(EOF4);
 155
 156             retval.tree = root_0;
 157             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 158
 159             root_0 = (CommonTree)adaptor.nil();
 160             {
 161                 adaptor.addChild(root_0, stream_expression.nextTree());
 162
 163             }
 164
 165             retval.tree = root_0;
 166             }
 167
 168             retval.stop = input.LT(-1);
 169
 170             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 171             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 172
 173         }
 174
 175           catch (RecognitionException e) {
 176             reportError(e);
 177             throw e;
 178           }
 179         finally {
 180         }
 181         return retval;
 182     }
 183
 184     public static class expression_return extends ParserRuleReturnScope {
 185         CommonTree tree;
 186         public Object getTree() { return tree; }
 187     };
 188
 189     public final QueryParser.expression_return expression() throws RecognitionException {
 190         QueryParser.expression_return retval = new QueryParser.expression_return();
 191         retval.start = input.LT(1);
 192
 193         CommonTree root_0 = null;
 194
 195         QueryParser.sequence_return sequence5 = null;
 196
 197         QueryParser.andOp_return andOp6 = null;
 198
 199         QueryParser.sequence_return sequence7 = null;
 200
 201         RewriteRuleSubtreeStream stream_sequence=new RewriteRuleSubtreeStream(adaptor,"rule sequence");
 202         RewriteRuleSubtreeStream stream_andOp=new RewriteRuleSubtreeStream(adaptor,"rule andOp");
 203         try {
 204             {
 205             pushFollow(FOLLOW_sequence_in_expression148);
 206             sequence5=sequence();
 207
 208             state._fsp--;
 209
 210             stream_sequence.add(sequence5.getTree());
 211             loop3:
 212             do {
 213                 int alt3=2;
 214                 alt3 = dfa3.predict(input);
 215                 switch (alt3) {
 216                 case 1 :
 217                     {
 218                     pushFollow(FOLLOW_andOp_in_expression151);
 219                     andOp6=andOp();
 220
 221                     state._fsp--;
 222
 223                     stream_andOp.add(andOp6.getTree());
 224                     pushFollow(FOLLOW_sequence_in_expression153);
 225                     sequence7=sequence();
 226
 227                     state._fsp--;
 228
 229                     stream_sequence.add(sequence7.getTree());
 230
 231                     }
 232                     break;
 233
 234                 default :
 235                     break loop3;
 236                 }
 237             } while (true);
 238
 239             retval.tree = root_0;
 240             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 241
 242             root_0 = (CommonTree)adaptor.nil();
 243             {
 244                 {
 245                 CommonTree root_1 = (CommonTree)adaptor.nil();
 246                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(CONJUNCTION, "CONJUNCTION"), root_1);
 247
 248                 if ( !(stream_sequence.hasNext()) ) {
 249                     throw new RewriteEarlyExitException();
 250                 }
 251                 while ( stream_sequence.hasNext() ) {
 252                     adaptor.addChild(root_1, stream_sequence.nextTree());
 253
 254                 }
 255                 stream_sequence.reset();
 256
 257                 adaptor.addChild(root_0, root_1);
 258                 }
 259
 260             }
 261
 262             retval.tree = root_0;
 263             }
 264
 265             retval.stop = input.LT(-1);
 266
 267             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 268             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 269
 270         }
 271
 272           catch (RecognitionException e) {
 273             reportError(e);
 274             throw e;
 275           }
 276         finally {
 277         }
 278         return retval;
 279     }
 280
 281     public static class sequence_return extends ParserRuleReturnScope {
 282         CommonTree tree;
 283         public Object getTree() { return tree; }
 284     };
 285
 286     public final QueryParser.sequence_return sequence() throws RecognitionException {
 287         QueryParser.sequence_return retval = new QueryParser.sequence_return();
 288         retval.start = input.LT(1);
 289
 290         CommonTree root_0 = null;
 291
 292         Token WS9=null;
 293         QueryParser.factor_return factor8 = null;
 294
 295         QueryParser.factor_return factor10 = null;
 296
 297         CommonTree WS9_tree=null;
 298         RewriteRuleTokenStream stream_WS=new RewriteRuleTokenStream(adaptor,"token WS");
 299         RewriteRuleSubtreeStream stream_factor=new RewriteRuleSubtreeStream(adaptor,"rule factor");
 300         try {
 301             {
 302             pushFollow(FOLLOW_factor_in_sequence179);
 303             factor8=factor();
 304
 305             state._fsp--;
 306
 307             stream_factor.add(factor8.getTree());
 308             loop5:
 309             do {
 310                 int alt5=2;
 311                 alt5 = dfa5.predict(input);
 312                 switch (alt5) {
 313                 case 1 :
 314                     {
 315                     int cnt4=0;
 316                     loop4:
 317                     do {
 318                         int alt4=2;
 319                         int LA4_0 = input.LA(1);
 320
 321                         if ( (LA4_0==WS) ) {
 322                             alt4=1;
 323                         }
 324
 325                         switch (alt4) {
 326                         case 1 :
 327                             {
 328                             WS9=(Token)match(input,WS,FOLLOW_WS_in_sequence182);
 329                             stream_WS.add(WS9);
 330
 331                             }
 332                             break;
 333
 334                         default :
 335                             if ( cnt4 >= 1 ) break loop4;
 336                                 EarlyExitException eee =
 337                                     new EarlyExitException(4, input);
 338                                 throw eee;
 339                         }
 340                         cnt4++;
 341                     } while (true);
 342
 343                     pushFollow(FOLLOW_factor_in_sequence185);
 344                     factor10=factor();
 345
 346                     state._fsp--;
 347
 348                     stream_factor.add(factor10.getTree());
 349
 350                     }
 351                     break;
 352
 353                 default :
 354                     break loop5;
 355                 }
 356             } while (true);
 357
 358             retval.tree = root_0;
 359             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 360
 361             root_0 = (CommonTree)adaptor.nil();
 362             {
 363                 {
 364                 CommonTree root_1 = (CommonTree)adaptor.nil();
 365                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(SEQUENCE, "SEQUENCE"), root_1);
 366
 367                 if ( !(stream_factor.hasNext()) ) {
 368                     throw new RewriteEarlyExitException();
 369                 }
 370                 while ( stream_factor.hasNext() ) {
 371                     adaptor.addChild(root_1, stream_factor.nextTree());
 372
 373                 }
 374                 stream_factor.reset();
 375
 376                 adaptor.addChild(root_0, root_1);
 377                 }
 378
 379             }
 380
 381             retval.tree = root_0;
 382             }
 383
 384             retval.stop = input.LT(-1);
 385
 386             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 387             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 388
 389         }
 390
 391           catch (RecognitionException e) {
 392             reportError(e);
 393             throw e;
 394           }
 395         finally {
 396         }
 397         return retval;
 398     }
 399
 400     public static class factor_return extends ParserRuleReturnScope {
 401         CommonTree tree;
 402         public Object getTree() { return tree; }
 403     };
 404
 405     public final QueryParser.factor_return factor() throws RecognitionException {
 406         QueryParser.factor_return retval = new QueryParser.factor_return();
 407         retval.start = input.LT(1);
 408
 409         CommonTree root_0 = null;
 410
 411         QueryParser.term_return term11 = null;
 412
 413         QueryParser.orOp_return orOp12 = null;
 414
 415         QueryParser.term_return term13 = null;
 416
 417         RewriteRuleSubtreeStream stream_orOp=new RewriteRuleSubtreeStream(adaptor,"rule orOp");
 418         RewriteRuleSubtreeStream stream_term=new RewriteRuleSubtreeStream(adaptor,"rule term");
 419         try {
 420             {
 421             pushFollow(FOLLOW_term_in_factor211);
 422             term11=term();
 423
 424             state._fsp--;
 425
 426             stream_term.add(term11.getTree());
 427             loop6:
 428             do {
 429                 int alt6=2;
 430                 alt6 = dfa6.predict(input);
 431                 switch (alt6) {
 432                 case 1 :
 433                     {
 434                     pushFollow(FOLLOW_orOp_in_factor214);
 435                     orOp12=orOp();
 436
 437                     state._fsp--;
 438
 439                     stream_orOp.add(orOp12.getTree());
 440                     pushFollow(FOLLOW_term_in_factor216);
 441                     term13=term();
 442
 443                     state._fsp--;
 444
 445                     stream_term.add(term13.getTree());
 446
 447                     }
 448                     break;
 449
 450                 default :
 451                     break loop6;
 452                 }
 453             } while (true);
 454
 455             retval.tree = root_0;
 456             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 457
 458             root_0 = (CommonTree)adaptor.nil();
 459             {
 460                 {
 461                 CommonTree root_1 = (CommonTree)adaptor.nil();
 462                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(DISJUNCTION, "DISJUNCTION"), root_1);
 463
 464                 if ( !(stream_term.hasNext()) ) {
 465                     throw new RewriteEarlyExitException();
 466                 }
 467                 while ( stream_term.hasNext() ) {
 468                     adaptor.addChild(root_1, stream_term.nextTree());
 469
 470                 }
 471                 stream_term.reset();
 472
 473                 adaptor.addChild(root_0, root_1);
 474                 }
 475
 476             }
 477
 478             retval.tree = root_0;
 479             }
 480
 481             retval.stop = input.LT(-1);
 482
 483             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 484             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 485
 486         }
 487
 488           catch (RecognitionException e) {
 489             reportError(e);
 490             throw e;
 491           }
 492         finally {
 493         }
 494         return retval;
 495     }
 496
 497     public static class term_return extends ParserRuleReturnScope {
 498         CommonTree tree;
 499         public Object getTree() { return tree; }
 500     };
 501
 502     public final QueryParser.term_return term() throws RecognitionException {
 503         QueryParser.term_return retval = new QueryParser.term_return();
 504         retval.start = input.LT(1);
 505
 506         CommonTree root_0 = null;
 507
 508         QueryParser.notOp_return notOp14 = null;
 509
 510         QueryParser.primitive_return primitive15 = null;
 511
 512         QueryParser.primitive_return primitive16 = null;
 513
 514         RewriteRuleSubtreeStream stream_notOp=new RewriteRuleSubtreeStream(adaptor,"rule notOp");
 515         RewriteRuleSubtreeStream stream_primitive=new RewriteRuleSubtreeStream(adaptor,"rule primitive");
 516         try {
 517             int alt7=2;
 518             int LA7_0 = input.LA(1);
 519
 520             if ( (LA7_0==NOT||LA7_0==43) ) {
 521                 alt7=1;
 522             }
 523             else if ( (LA7_0==LPAREN||(LA7_0>=DISTANCE_FN && LA7_0<=QUOTE)) ) {
 524                 alt7=2;
 525             }
 526             else {
 527                 NoViableAltException nvae =
 528                     new NoViableAltException("", 7, 0, input);
 529
 530                 throw nvae;
 531             }
 532             switch (alt7) {
 533                 case 1 :
 534                     {
 535                     pushFollow(FOLLOW_notOp_in_term240);
 536                     notOp14=notOp();
 537
 538                     state._fsp--;
 539
 540                     stream_notOp.add(notOp14.getTree());
 541                     pushFollow(FOLLOW_primitive_in_term242);
 542                     primitive15=primitive();
 543
 544                     state._fsp--;
 545
 546                     stream_primitive.add(primitive15.getTree());
 547
 548                     retval.tree = root_0;
 549                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 550
 551                     root_0 = (CommonTree)adaptor.nil();
 552                     {
 553                         {
 554                         CommonTree root_1 = (CommonTree)adaptor.nil();
 555                         root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(NEGATION, "NEGATION"), root_1);
 556
 557                         adaptor.addChild(root_1, stream_primitive.nextTree());
 558
 559                         adaptor.addChild(root_0, root_1);
 560                         }
 561
 562                     }
 563
 564                     retval.tree = root_0;
 565                     }
 566                     break;
 567                 case 2 :
 568                     {
 569                     root_0 = (CommonTree)adaptor.nil();
 570
 571                     pushFollow(FOLLOW_primitive_in_term256);
 572                     primitive16=primitive();
 573
 574                     state._fsp--;
 575
 576                     adaptor.addChild(root_0, primitive16.getTree());
 577
 578                     }
 579                     break;
 580
 581             }
 582             retval.stop = input.LT(-1);
 583
 584             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 585             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 586
 587         }
 588
 589           catch (RecognitionException e) {
 590             reportError(e);
 591             throw e;
 592           }
 593         finally {
 594         }
 595         return retval;
 596     }
 597
 598     public static class primitive_return extends ParserRuleReturnScope {
 599         CommonTree tree;
 600         public Object getTree() { return tree; }
 601     };
 602
 603     public final QueryParser.primitive_return primitive() throws RecognitionException {
 604         QueryParser.primitive_return retval = new QueryParser.primitive_return();
 605         retval.start = input.LT(1);
 606
 607         CommonTree root_0 = null;
 608
 609         QueryParser.restrict_return restrict17 = null;
 610
 611         QueryParser.composite_return composite18 = null;
 612
 613         QueryParser.item_return item19 = null;
 614
 615         RewriteRuleSubtreeStream stream_item=new RewriteRuleSubtreeStream(adaptor,"rule item");
 616         try {
 617             int alt8=3;
 618             alt8 = dfa8.predict(input);
 619             switch (alt8) {
 620                 case 1 :
 621                     {
 622                     root_0 = (CommonTree)adaptor.nil();
 623
 624                     pushFollow(FOLLOW_restrict_in_primitive272);
 625                     restrict17=restrict();
 626
 627                     state._fsp--;
 628
 629                     adaptor.addChild(root_0, restrict17.getTree());
 630
 631                     }
 632                     break;
 633                 case 2 :
 634                     {
 635                     root_0 = (CommonTree)adaptor.nil();
 636
 637                     pushFollow(FOLLOW_composite_in_primitive278);
 638                     composite18=composite();
 639
 640                     state._fsp--;
 641
 642                     adaptor.addChild(root_0, composite18.getTree());
 643
 644                     }
 645                     break;
 646                 case 3 :
 647                     {
 648                     pushFollow(FOLLOW_item_in_primitive284);
 649                     item19=item();
 650
 651                     state._fsp--;
 652
 653                     stream_item.add(item19.getTree());
 654
 655                     retval.tree = root_0;
 656                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 657
 658                     root_0 = (CommonTree)adaptor.nil();
 659                     {
 660                         {
 661                         CommonTree root_1 = (CommonTree)adaptor.nil();
 662                         root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(HAS, "HAS"), root_1);
 663
 664                         adaptor.addChild(root_1, (CommonTree)adaptor.create(GLOBAL, "GLOBAL"));
 665                         adaptor.addChild(root_1, stream_item.nextTree());
 666
 667                         adaptor.addChild(root_0, root_1);
 668                         }
 669
 670                     }
 671
 672                     retval.tree = root_0;
 673                     }
 674                     break;
 675
 676             }
 677             retval.stop = input.LT(-1);
 678
 679             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 680             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 681
 682         }
 683
 684           catch (RecognitionException e) {
 685             reportError(e);
 686             throw e;
 687           }
 688         finally {
 689         }
 690         return retval;
 691     }
 692
 693     public static class restrict_return extends ParserRuleReturnScope {
 694         CommonTree tree;
 695         public Object getTree() { return tree; }
 696     };
 697
 698     public final QueryParser.restrict_return restrict() throws RecognitionException {
 699         QueryParser.restrict_return retval = new QueryParser.restrict_return();
 700         retval.start = input.LT(1);
 701
 702         CommonTree root_0 = null;
 703
 704         QueryParser.comparable_return comparable20 = null;
 705
 706         QueryParser.comparator_return comparator21 = null;
 707
 708         QueryParser.arg_return arg22 = null;
 709
 710         RewriteRuleSubtreeStream stream_arg=new RewriteRuleSubtreeStream(adaptor,"rule arg");
 711         RewriteRuleSubtreeStream stream_comparable=new RewriteRuleSubtreeStream(adaptor,"rule comparable");
 712         RewriteRuleSubtreeStream stream_comparator=new RewriteRuleSubtreeStream(adaptor,"rule comparator");
 713         try {
 714             {
 715             pushFollow(FOLLOW_comparable_in_restrict310);
 716             comparable20=comparable();
 717
 718             state._fsp--;
 719
 720             stream_comparable.add(comparable20.getTree());
 721             pushFollow(FOLLOW_comparator_in_restrict312);
 722             comparator21=comparator();
 723
 724             state._fsp--;
 725
 726             stream_comparator.add(comparator21.getTree());
 727             pushFollow(FOLLOW_arg_in_restrict314);
 728             arg22=arg();
 729
 730             state._fsp--;
 731
 732             stream_arg.add(arg22.getTree());
 733
 734             retval.tree = root_0;
 735             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 736
 737             root_0 = (CommonTree)adaptor.nil();
 738             {
 739                 {
 740                 CommonTree root_1 = (CommonTree)adaptor.nil();
 741                 root_1 = (CommonTree)adaptor.becomeRoot(stream_comparator.nextNode(), root_1);
 742
 743                 adaptor.addChild(root_1, stream_comparable.nextTree());
 744                 adaptor.addChild(root_1, stream_arg.nextTree());
 745
 746                 adaptor.addChild(root_0, root_1);
 747                 }
 748
 749             }
 750
 751             retval.tree = root_0;
 752             }
 753
 754             retval.stop = input.LT(-1);
 755
 756             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 757             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 758
 759         }
 760
 761           catch (RecognitionException e) {
 762             reportError(e);
 763             throw e;
 764           }
 765         finally {
 766         }
 767         return retval;
 768     }
 769
 770     public static class comparator_return extends ParserRuleReturnScope {
 771         CommonTree tree;
 772         public Object getTree() { return tree; }
 773     };
 774
 775     public final QueryParser.comparator_return comparator() throws RecognitionException {
 776         QueryParser.comparator_return retval = new QueryParser.comparator_return();
 777         retval.start = input.LT(1);
 778
 779         CommonTree root_0 = null;
 780
 781         Token x=null;
 782         Token WS23=null;
 783         Token WS24=null;
 784
 785         CommonTree x_tree=null;
 786         CommonTree WS23_tree=null;
 787         CommonTree WS24_tree=null;
 788         RewriteRuleTokenStream stream_HAS=new RewriteRuleTokenStream(adaptor,"token HAS");
 789         RewriteRuleTokenStream stream_GE=new RewriteRuleTokenStream(adaptor,"token GE");
 790         RewriteRuleTokenStream stream_GT=new RewriteRuleTokenStream(adaptor,"token GT");
 791         RewriteRuleTokenStream stream_LT=new RewriteRuleTokenStream(adaptor,"token LT");
 792         RewriteRuleTokenStream stream_WS=new RewriteRuleTokenStream(adaptor,"token WS");
 793         RewriteRuleTokenStream stream_EQ=new RewriteRuleTokenStream(adaptor,"token EQ");
 794         RewriteRuleTokenStream stream_LE=new RewriteRuleTokenStream(adaptor,"token LE");
 795         RewriteRuleTokenStream stream_NE=new RewriteRuleTokenStream(adaptor,"token NE");
 796
 797         try {
 798             {
 799             loop9:
 800             do {
 801                 int alt9=2;
 802                 int LA9_0 = input.LA(1);
 803
 804                 if ( (LA9_0==WS) ) {
 805                     alt9=1;
 806                 }
 807
 808                 switch (alt9) {
 809                 case 1 :
 810                     {
 811                     WS23=(Token)match(input,WS,FOLLOW_WS_in_comparator338);
 812                     stream_WS.add(WS23);
 813
 814                     }
 815                     break;
 816
 817                 default :
 818                     break loop9;
 819                 }
 820             } while (true);
 821
 822             int alt10=7;
 823             switch ( input.LA(1) ) {
 824             case LE:
 825                 {
 826                 alt10=1;
 827                 }
 828                 break;
 829             case LT:
 830                 {
 831                 alt10=2;
 832                 }
 833                 break;
 834             case GE:
 835                 {
 836                 alt10=3;
 837                 }
 838                 break;
 839             case GT:
 840                 {
 841                 alt10=4;
 842                 }
 843                 break;
 844             case NE:
 845                 {
 846                 alt10=5;
 847                 }
 848                 break;
 849             case EQ:
 850                 {
 851                 alt10=6;
 852                 }
 853                 break;
 854             case HAS:
 855                 {
 856                 alt10=7;
 857                 }
 858                 break;
 859             default:
 860                 NoViableAltException nvae =
 861                     new NoViableAltException("", 10, 0, input);
 862
 863                 throw nvae;
 864             }
 865
 866             switch (alt10) {
 867                 case 1 :
 868                     {
 869                     x=(Token)match(input,LE,FOLLOW_LE_in_comparator344);
 870                     stream_LE.add(x);
 871
 872                     }
 873                     break;
 874                 case 2 :
 875                     {
 876                     x=(Token)match(input,LT,FOLLOW_LT_in_comparator350);
 877                     stream_LT.add(x);
 878
 879                     }
 880                     break;
 881                 case 3 :
 882                     {
 883                     x=(Token)match(input,GE,FOLLOW_GE_in_comparator356);
 884                     stream_GE.add(x);
 885
 886                     }
 887                     break;
 888                 case 4 :
 889                     {
 890                     x=(Token)match(input,GT,FOLLOW_GT_in_comparator362);
 891                     stream_GT.add(x);
 892
 893                     }
 894                     break;
 895                 case 5 :
 896                     {
 897                     x=(Token)match(input,NE,FOLLOW_NE_in_comparator368);
 898                     stream_NE.add(x);
 899
 900                     }
 901                     break;
 902                 case 6 :
 903                     {
 904                     x=(Token)match(input,EQ,FOLLOW_EQ_in_comparator374);
 905                     stream_EQ.add(x);
 906
 907                     }
 908                     break;
 909                 case 7 :
 910                     {
 911                     x=(Token)match(input,HAS,FOLLOW_HAS_in_comparator380);
 912                     stream_HAS.add(x);
 913
 914                     }
 915                     break;
 916
 917             }
 918
 919             loop11:
 920             do {
 921                 int alt11=2;
 922                 int LA11_0 = input.LA(1);
 923
 924                 if ( (LA11_0==WS) ) {
 925                     alt11=1;
 926                 }
 927
 928                 switch (alt11) {
 929                 case 1 :
 930                     {
 931                     WS24=(Token)match(input,WS,FOLLOW_WS_in_comparator383);
 932                     stream_WS.add(WS24);
 933
 934                     }
 935                     break;
 936
 937                 default :
 938                     break loop11;
 939                 }
 940             } while (true);
 941
 942             retval.tree = root_0;
 943             RewriteRuleTokenStream stream_x=new RewriteRuleTokenStream(adaptor,"token x",x);
 944             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 945
 946             root_0 = (CommonTree)adaptor.nil();
 947             {
 948                 adaptor.addChild(root_0, stream_x.nextNode());
 949
 950             }
 951
 952             retval.tree = root_0;
 953             }
 954
 955             retval.stop = input.LT(-1);
 956
 957             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 958             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 959
 960         }
 961
 962           catch (RecognitionException e) {
 963             reportError(e);
 964             throw e;
 965           }
 966         finally {
 967         }
 968         return retval;
 969     }
 970
 971     public static class comparable_return extends ParserRuleReturnScope {
 972         CommonTree tree;
 973         public Object getTree() { return tree; }
 974     };
 975
 976     public final QueryParser.comparable_return comparable() throws RecognitionException {
 977         QueryParser.comparable_return retval = new QueryParser.comparable_return();
 978         retval.start = input.LT(1);
 979
 980         CommonTree root_0 = null;
 981
 982         QueryParser.item_return item25 = null;
 983
 984         QueryParser.function_return function26 = null;
 985
 986         try {
 987             int alt12=2;
 988             int LA12_0 = input.LA(1);
 989
 990             if ( ((LA12_0>=FIX && LA12_0<=QUOTE)) ) {
 991                 alt12=1;
 992             }
 993             else if ( ((LA12_0>=DISTANCE_FN && LA12_0<=GEO_POINT_FN)) ) {
 994                 int LA12_2 = input.LA(2);
 995
 996                 if ( ((LA12_2>=WS && LA12_2<=HAS)) ) {
 997                     alt12=1;
 998                 }
 999                 else if ( (LA12_2==LPAREN) ) {
1000                     alt12=2;
1001                 }
1002                 else {
1003                     NoViableAltException nvae =
1004                         new NoViableAltException("", 12, 2, input);
1005
1006                     throw nvae;
1007                 }
1008             }
1009             else {
1010                 NoViableAltException nvae =
1011                     new NoViableAltException("", 12, 0, input);
1012
1013                 throw nvae;
1014             }
1015             switch (alt12) {
1016                 case 1 :
1017                     {
1018                     root_0 = (CommonTree)adaptor.nil();
1019
1020                     pushFollow(FOLLOW_item_in_comparable405);
1021                     item25=item();
1022
1023                     state._fsp--;
1024
1025                     adaptor.addChild(root_0, item25.getTree());
1026
1027                     }
1028                     break;
1029                 case 2 :
1030                     {
1031                     root_0 = (CommonTree)adaptor.nil();
1032
1033                     pushFollow(FOLLOW_function_in_comparable411);
1034                     function26=function();
1035
1036                     state._fsp--;
1037
1038                     adaptor.addChild(root_0, function26.getTree());
1039
1040                     }
1041                     break;
1042
1043             }
1044             retval.stop = input.LT(-1);
1045
1046             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1047             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1048
1049         }
1050
1051           catch (RecognitionException e) {
1052             reportError(e);
1053             throw e;
1054           }
1055         finally {
1056         }
1057         return retval;
1058     }
1059
1060     public static class function_return extends ParserRuleReturnScope {
1061         CommonTree tree;
1062         public Object getTree() { return tree; }
1063     };
1064
1065     public final QueryParser.function_return function() throws RecognitionException {
1066         QueryParser.function_return retval = new QueryParser.function_return();
1067         retval.start = input.LT(1);
1068
1069         CommonTree root_0 = null;
1070
1071         Token LPAREN28=null;
1072         Token RPAREN30=null;
1073         QueryParser.fnname_return fnname27 = null;
1074
1075         QueryParser.arglist_return arglist29 = null;
1076
1077         CommonTree LPAREN28_tree=null;
1078         CommonTree RPAREN30_tree=null;
1079         RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
1080         RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
1081         RewriteRuleSubtreeStream stream_arglist=new RewriteRuleSubtreeStream(adaptor,"rule arglist");
1082         RewriteRuleSubtreeStream stream_fnname=new RewriteRuleSubtreeStream(adaptor,"rule fnname");
1083         try {
1084             {
1085             pushFollow(FOLLOW_fnname_in_function426);
1086             fnname27=fnname();
1087
1088             state._fsp--;
1089
1090             stream_fnname.add(fnname27.getTree());
1091             LPAREN28=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_function428);
1092             stream_LPAREN.add(LPAREN28);
1093
1094             pushFollow(FOLLOW_arglist_in_function430);
1095             arglist29=arglist();
1096
1097             state._fsp--;
1098
1099             stream_arglist.add(arglist29.getTree());
1100             RPAREN30=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_function432);
1101             stream_RPAREN.add(RPAREN30);
1102
1103             retval.tree = root_0;
1104             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
1105
1106             root_0 = (CommonTree)adaptor.nil();
1107             {
1108                 {
1109                 CommonTree root_1 = (CommonTree)adaptor.nil();
1110                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(FUNCTION, "FUNCTION"), root_1);
1111
1112                 adaptor.addChild(root_1, stream_fnname.nextTree());
1113                 {
1114                 CommonTree root_2 = (CommonTree)adaptor.nil();
1115                 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(ARGS, "ARGS"), root_2);
1116
1117                 adaptor.addChild(root_2, stream_arglist.nextTree());
1118
1119                 adaptor.addChild(root_1, root_2);
1120                 }
1121
1122                 adaptor.addChild(root_0, root_1);
1123                 }
1124
1125             }
1126
1127             retval.tree = root_0;
1128             }
1129
1130             retval.stop = input.LT(-1);
1131
1132             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1133             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1134
1135         }
1136
1137           catch (RecognitionException e) {
1138             reportError(e);
1139             throw e;
1140           }
1141         finally {
1142         }
1143         return retval;
1144     }
1145
1146     public static class arglist_return extends ParserRuleReturnScope {
1147         CommonTree tree;
1148         public Object getTree() { return tree; }
1149     };
1150
1151     public final QueryParser.arglist_return arglist() throws RecognitionException {
1152         QueryParser.arglist_return retval = new QueryParser.arglist_return();
1153         retval.start = input.LT(1);
1154
1155         CommonTree root_0 = null;
1156
1157         QueryParser.arg_return arg31 = null;
1158
1159         QueryParser.sep_return sep32 = null;
1160
1161         QueryParser.arg_return arg33 = null;
1162
1163         RewriteRuleSubtreeStream stream_arg=new RewriteRuleSubtreeStream(adaptor,"rule arg");
1164         RewriteRuleSubtreeStream stream_sep=new RewriteRuleSubtreeStream(adaptor,"rule sep");
1165         try {
1166             int alt14=2;
1167             int LA14_0 = input.LA(1);
1168
1169             if ( (LA14_0==LPAREN||(LA14_0>=DISTANCE_FN && LA14_0<=QUOTE)) ) {
1170                 alt14=1;
1171             }
1172             else if ( (LA14_0==RPAREN) ) {
1173                 alt14=2;
1174             }
1175             else {
1176                 NoViableAltException nvae =
1177                     new NoViableAltException("", 14, 0, input);
1178
1179                 throw nvae;
1180             }
1181             switch (alt14) {
1182                 case 1 :
1183                     {
1184                     pushFollow(FOLLOW_arg_in_arglist461);
1185                     arg31=arg();
1186
1187                     state._fsp--;
1188
1189                     stream_arg.add(arg31.getTree());
1190                     loop13:
1191                     do {
1192                         int alt13=2;
1193                         int LA13_0 = input.LA(1);
1194
1195                         if ( (LA13_0==WS||LA13_0==44) ) {
1196                             alt13=1;
1197                         }
1198
1199                         switch (alt13) {
1200                         case 1 :
1201                             {
1202                             pushFollow(FOLLOW_sep_in_arglist464);
1203                             sep32=sep();
1204
1205                             state._fsp--;
1206
1207                             stream_sep.add(sep32.getTree());
1208                             pushFollow(FOLLOW_arg_in_arglist466);
1209                             arg33=arg();
1210
1211                             state._fsp--;
1212
1213                             stream_arg.add(arg33.getTree());
1214
1215                             }
1216                             break;
1217
1218                         default :
1219                             break loop13;
1220                         }
1221                     } while (true);
1222
1223                     retval.tree = root_0;
1224                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
1225
1226                     root_0 = (CommonTree)adaptor.nil();
1227                     {
1228                         while ( stream_arg.hasNext() ) {
1229                             adaptor.addChild(root_0, stream_arg.nextTree());
1230
1231                         }
1232                         stream_arg.reset();
1233
1234                     }
1235
1236                     retval.tree = root_0;
1237                     }
1238                     break;
1239                 case 2 :
1240                     {
1241                     root_0 = (CommonTree)adaptor.nil();
1242
1243                     }
1244                     break;
1245
1246             }
1247             retval.stop = input.LT(-1);
1248
1249             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1250             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1251
1252         }
1253
1254           catch (RecognitionException e) {
1255             reportError(e);
1256             throw e;
1257           }
1258         finally {
1259         }
1260         return retval;
1261     }
1262
1263     public static class arg_return extends ParserRuleReturnScope {
1264         CommonTree tree;
1265         public Object getTree() { return tree; }
1266     };
1267
1268     public final QueryParser.arg_return arg() throws RecognitionException {
1269         QueryParser.arg_return retval = new QueryParser.arg_return();
1270         retval.start = input.LT(1);
1271
1272         CommonTree root_0 = null;
1273
1274         QueryParser.item_return item34 = null;
1275
1276         QueryParser.composite_return composite35 = null;
1277
1278         QueryParser.function_return function36 = null;
1279
1280         try {
1281             int alt15=3;
1282             switch ( input.LA(1) ) {
1283             case FIX:
1284             case REWRITE:
1285             case TEXT:
1286             case QUOTE:
1287                 {
1288                 alt15=1;
1289                 }
1290                 break;
1291             case DISTANCE_FN:
1292             case GEO_POINT_FN:
1293                 {
1294                 int LA15_2 = input.LA(2);
1295
1296                 if ( (LA15_2==EOF||LA15_2==WS||LA15_2==RPAREN||LA15_2==44) ) {
1297                     alt15=1;
1298                 }
1299                 else if ( (LA15_2==LPAREN) ) {
1300                     alt15=3;
1301                 }
1302                 else {
1303                     NoViableAltException nvae =
1304                         new NoViableAltException("", 15, 2, input);
1305
1306                     throw nvae;
1307                 }
1308                 }
1309                 break;
1310             case LPAREN:
1311                 {
1312                 alt15=2;
1313                 }
1314                 break;
1315             default:
1316                 NoViableAltException nvae =
1317                     new NoViableAltException("", 15, 0, input);
1318
1319                 throw nvae;
1320             }
1321
1322             switch (alt15) {
1323                 case 1 :
1324                     {
1325                     root_0 = (CommonTree)adaptor.nil();
1326
1327                     pushFollow(FOLLOW_item_in_arg491);
1328                     item34=item();
1329
1330                     state._fsp--;
1331
1332                     adaptor.addChild(root_0, item34.getTree());
1333
1334                     }
1335                     break;
1336                 case 2 :
1337                     {
1338                     root_0 = (CommonTree)adaptor.nil();
1339
1340                     pushFollow(FOLLOW_composite_in_arg497);
1341                     composite35=composite();
1342
1343                     state._fsp--;
1344
1345                     adaptor.addChild(root_0, composite35.getTree());
1346
1347                     }
1348                     break;
1349                 case 3 :
1350                     {
1351                     root_0 = (CommonTree)adaptor.nil();
1352
1353                     pushFollow(FOLLOW_function_in_arg503);
1354                     function36=function();
1355
1356                     state._fsp--;
1357
1358                     adaptor.addChild(root_0, function36.getTree());
1359
1360                     }
1361                     break;
1362
1363             }
1364             retval.stop = input.LT(-1);
1365
1366             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1367             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1368
1369         }
1370
1371           catch (RecognitionException e) {
1372             reportError(e);
1373             throw e;
1374           }
1375         finally {
1376         }
1377         return retval;
1378     }
1379
1380     public static class andOp_return extends ParserRuleReturnScope {
1381         CommonTree tree;
1382         public Object getTree() { return tree; }
1383     };
1384
1385     public final QueryParser.andOp_return andOp() throws RecognitionException {
1386         QueryParser.andOp_return retval = new QueryParser.andOp_return();
1387         retval.start = input.LT(1);
1388
1389         CommonTree root_0 = null;
1390
1391         Token WS37=null;
1392         Token AND38=null;
1393         Token WS39=null;
1394
1395         CommonTree WS37_tree=null;
1396         CommonTree AND38_tree=null;
1397         CommonTree WS39_tree=null;
1398
1399         try {
1400             {
1401             root_0 = (CommonTree)adaptor.nil();
1402
1403             int cnt16=0;
1404             loop16:
1405             do {
1406                 int alt16=2;
1407                 int LA16_0 = input.LA(1);
1408
1409                 if ( (LA16_0==WS) ) {
1410                     alt16=1;
1411                 }
1412
1413                 switch (alt16) {
1414                 case 1 :
1415                     {
1416                     WS37=(Token)match(input,WS,FOLLOW_WS_in_andOp517);
1417                     WS37_tree = (CommonTree)adaptor.create(WS37);
1418                     adaptor.addChild(root_0, WS37_tree);
1419
1420                     }
1421                     break;
1422
1423                 default :
1424                     if ( cnt16 >= 1 ) break loop16;
1425                         EarlyExitException eee =
1426                             new EarlyExitException(16, input);
1427                         throw eee;
1428                 }
1429                 cnt16++;
1430             } while (true);
1431
1432             AND38=(Token)match(input,AND,FOLLOW_AND_in_andOp520);
1433             AND38_tree = (CommonTree)adaptor.create(AND38);
1434             adaptor.addChild(root_0, AND38_tree);
1435
1436             int cnt17=0;
1437             loop17:
1438             do {
1439                 int alt17=2;
1440                 int LA17_0 = input.LA(1);
1441
1442                 if ( (LA17_0==WS) ) {
1443                     alt17=1;
1444                 }
1445
1446                 switch (alt17) {
1447                 case 1 :
1448                     {
1449                     WS39=(Token)match(input,WS,FOLLOW_WS_in_andOp522);
1450                     WS39_tree = (CommonTree)adaptor.create(WS39);
1451                     adaptor.addChild(root_0, WS39_tree);
1452
1453                     }
1454                     break;
1455
1456                 default :
1457                     if ( cnt17 >= 1 ) break loop17;
1458                         EarlyExitException eee =
1459                             new EarlyExitException(17, input);
1460                         throw eee;
1461                 }
1462                 cnt17++;
1463             } while (true);
1464
1465             }
1466
1467             retval.stop = input.LT(-1);
1468
1469             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1470             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1471
1472         }
1473
1474           catch (RecognitionException e) {
1475             reportError(e);
1476             throw e;
1477           }
1478         finally {
1479         }
1480         return retval;
1481     }
1482
1483     public static class orOp_return extends ParserRuleReturnScope {
1484         CommonTree tree;
1485         public Object getTree() { return tree; }
1486     };
1487
1488     public final QueryParser.orOp_return orOp() throws RecognitionException {
1489         QueryParser.orOp_return retval = new QueryParser.orOp_return();
1490         retval.start = input.LT(1);
1491
1492         CommonTree root_0 = null;
1493
1494         Token WS40=null;
1495         Token OR41=null;
1496         Token WS42=null;
1497
1498         CommonTree WS40_tree=null;
1499         CommonTree OR41_tree=null;
1500         CommonTree WS42_tree=null;
1501
1502         try {
1503             {
1504             root_0 = (CommonTree)adaptor.nil();
1505
1506             int cnt18=0;
1507             loop18:
1508             do {
1509                 int alt18=2;
1510                 int LA18_0 = input.LA(1);
1511
1512                 if ( (LA18_0==WS) ) {
1513                     alt18=1;
1514                 }
1515
1516                 switch (alt18) {
1517                 case 1 :
1518                     {
1519                     WS40=(Token)match(input,WS,FOLLOW_WS_in_orOp537);
1520                     WS40_tree = (CommonTree)adaptor.create(WS40);
1521                     adaptor.addChild(root_0, WS40_tree);
1522
1523                     }
1524                     break;
1525
1526                 default :
1527                     if ( cnt18 >= 1 ) break loop18;
1528                         EarlyExitException eee =
1529                             new EarlyExitException(18, input);
1530                         throw eee;
1531                 }
1532                 cnt18++;
1533             } while (true);
1534
1535             OR41=(Token)match(input,OR,FOLLOW_OR_in_orOp540);
1536             OR41_tree = (CommonTree)adaptor.create(OR41);
1537             adaptor.addChild(root_0, OR41_tree);
1538
1539             int cnt19=0;
1540             loop19:
1541             do {
1542                 int alt19=2;
1543                 int LA19_0 = input.LA(1);
1544
1545                 if ( (LA19_0==WS) ) {
1546                     alt19=1;
1547                 }
1548
1549                 switch (alt19) {
1550                 case 1 :
1551                     {
1552                     WS42=(Token)match(input,WS,FOLLOW_WS_in_orOp542);
1553                     WS42_tree = (CommonTree)adaptor.create(WS42);
1554                     adaptor.addChild(root_0, WS42_tree);
1555
1556                     }
1557                     break;
1558
1559                 default :
1560                     if ( cnt19 >= 1 ) break loop19;
1561                         EarlyExitException eee =
1562                             new EarlyExitException(19, input);
1563                         throw eee;
1564                 }
1565                 cnt19++;
1566             } while (true);
1567
1568             }
1569
1570             retval.stop = input.LT(-1);
1571
1572             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1573             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1574
1575         }
1576
1577           catch (RecognitionException e) {
1578             reportError(e);
1579             throw e;
1580           }
1581         finally {
1582         }
1583         return retval;
1584     }
1585
1586     public static class notOp_return extends ParserRuleReturnScope {
1587         CommonTree tree;
1588         public Object getTree() { return tree; }
1589     };
1590
1591     public final QueryParser.notOp_return notOp() throws RecognitionException {
1592         QueryParser.notOp_return retval = new QueryParser.notOp_return();
1593         retval.start = input.LT(1);
1594
1595         CommonTree root_0 = null;
1596
1597         Token char_literal43=null;
1598         Token NOT44=null;
1599         Token WS45=null;
1600
1601         CommonTree char_literal43_tree=null;
1602         CommonTree NOT44_tree=null;
1603         CommonTree WS45_tree=null;
1604
1605         try {
1606             int alt21=2;
1607             int LA21_0 = input.LA(1);
1608
1609             if ( (LA21_0==43) ) {
1610                 alt21=1;
1611             }
1612             else if ( (LA21_0==NOT) ) {
1613                 alt21=2;
1614             }
1615             else {
1616                 NoViableAltException nvae =
1617                     new NoViableAltException("", 21, 0, input);
1618
1619                 throw nvae;
1620             }
1621             switch (alt21) {
1622                 case 1 :
1623                     {
1624                     root_0 = (CommonTree)adaptor.nil();
1625
1626                     char_literal43=(Token)match(input,43,FOLLOW_43_in_notOp557);
1627                     char_literal43_tree = (CommonTree)adaptor.create(char_literal43);
1628                     adaptor.addChild(root_0, char_literal43_tree);
1629
1630                     }
1631                     break;
1632                 case 2 :
1633                     {
1634                     root_0 = (CommonTree)adaptor.nil();
1635
1636                     NOT44=(Token)match(input,NOT,FOLLOW_NOT_in_notOp563);
1637                     NOT44_tree = (CommonTree)adaptor.create(NOT44);
1638                     adaptor.addChild(root_0, NOT44_tree);
1639
1640                     int cnt20=0;
1641                     loop20:
1642                     do {
1643                         int alt20=2;
1644                         int LA20_0 = input.LA(1);
1645
1646                         if ( (LA20_0==WS) ) {
1647                             alt20=1;
1648                         }
1649
1650                         switch (alt20) {
1651                         case 1 :
1652                             {
1653                             WS45=(Token)match(input,WS,FOLLOW_WS_in_notOp565);
1654                             WS45_tree = (CommonTree)adaptor.create(WS45);
1655                             adaptor.addChild(root_0, WS45_tree);
1656
1657                             }
1658                             break;
1659
1660                         default :
1661                             if ( cnt20 >= 1 ) break loop20;
1662                                 EarlyExitException eee =
1663                                     new EarlyExitException(20, input);
1664                                 throw eee;
1665                         }
1666                         cnt20++;
1667                     } while (true);
1668
1669                     }
1670                     break;
1671
1672             }
1673             retval.stop = input.LT(-1);
1674
1675             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1676             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1677
1678         }
1679
1680           catch (RecognitionException e) {
1681             reportError(e);
1682             throw e;
1683           }
1684         finally {
1685         }
1686         return retval;
1687     }
1688
1689     public static class sep_return extends ParserRuleReturnScope {
1690         CommonTree tree;
1691         public Object getTree() { return tree; }
1692     };
1693
1694     public final QueryParser.sep_return sep() throws RecognitionException {
1695         QueryParser.sep_return retval = new QueryParser.sep_return();
1696         retval.start = input.LT(1);
1697
1698         CommonTree root_0 = null;
1699
1700         Token WS46=null;
1701         Token char_literal47=null;
1702         Token WS48=null;
1703
1704         CommonTree WS46_tree=null;
1705         CommonTree char_literal47_tree=null;
1706         CommonTree WS48_tree=null;
1707
1708         try {
1709             {
1710             root_0 = (CommonTree)adaptor.nil();
1711
1712             loop22:
1713             do {
1714                 int alt22=2;
1715                 int LA22_0 = input.LA(1);
1716
1717                 if ( (LA22_0==WS) ) {
1718                     alt22=1;
1719                 }
1720
1721                 switch (alt22) {
1722                 case 1 :
1723                     {
1724                     WS46=(Token)match(input,WS,FOLLOW_WS_in_sep580);
1725                     WS46_tree = (CommonTree)adaptor.create(WS46);
1726                     adaptor.addChild(root_0, WS46_tree);
1727
1728                     }
1729                     break;
1730
1731                 default :
1732                     break loop22;
1733                 }
1734             } while (true);
1735
1736             char_literal47=(Token)match(input,44,FOLLOW_44_in_sep583);
1737             char_literal47_tree = (CommonTree)adaptor.create(char_literal47);
1738             adaptor.addChild(root_0, char_literal47_tree);
1739
1740             loop23:
1741             do {
1742                 int alt23=2;
1743                 int LA23_0 = input.LA(1);
1744
1745                 if ( (LA23_0==WS) ) {
1746                     alt23=1;
1747                 }
1748
1749                 switch (alt23) {
1750                 case 1 :
1751                     {
1752                     WS48=(Token)match(input,WS,FOLLOW_WS_in_sep585);
1753                     WS48_tree = (CommonTree)adaptor.create(WS48);
1754                     adaptor.addChild(root_0, WS48_tree);
1755
1756                     }
1757                     break;
1758
1759                 default :
1760                     break loop23;
1761                 }
1762             } while (true);
1763
1764             }
1765
1766             retval.stop = input.LT(-1);
1767
1768             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1769             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1770
1771         }
1772
1773           catch (RecognitionException e) {
1774             reportError(e);
1775             throw e;
1776           }
1777         finally {
1778         }
1779         return retval;
1780     }
1781
1782     public static class fnname_return extends ParserRuleReturnScope {
1783         CommonTree tree;
1784         public Object getTree() { return tree; }
1785     };
1786
1787     public final QueryParser.fnname_return fnname() throws RecognitionException {
1788         QueryParser.fnname_return retval = new QueryParser.fnname_return();
1789         retval.start = input.LT(1);
1790
1791         CommonTree root_0 = null;
1792
1793         Token set49=null;
1794
1795         CommonTree set49_tree=null;
1796
1797         try {
1798             {
1799             root_0 = (CommonTree)adaptor.nil();
1800
1801             set49=(Token)input.LT(1);
1802             if ( (input.LA(1)>=DISTANCE_FN && input.LA(1)<=GEO_POINT_FN) ) {
1803                 input.consume();
1804                 adaptor.addChild(root_0, (CommonTree)adaptor.create(set49));
1805                 state.errorRecovery=false;
1806             }
1807             else {
1808                 MismatchedSetException mse = new MismatchedSetException(null,input);
1809                 throw mse;
1810             }
1811
1812             }
1813
1814             retval.stop = input.LT(-1);
1815
1816             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1817             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1818
1819         }
1820
1821           catch (RecognitionException e) {
1822             reportError(e);
1823             throw e;
1824           }
1825         finally {
1826         }
1827         return retval;
1828     }
1829
1830     public static class composite_return extends ParserRuleReturnScope {
1831         CommonTree tree;
1832         public Object getTree() { return tree; }
1833     };
1834
1835     public final QueryParser.composite_return composite() throws RecognitionException {
1836         QueryParser.composite_return retval = new QueryParser.composite_return();
1837         retval.start = input.LT(1);
1838
1839         CommonTree root_0 = null;
1840
1841         Token LPAREN50=null;
1842         Token WS51=null;
1843         Token WS53=null;
1844         Token RPAREN54=null;
1845         QueryParser.expression_return expression52 = null;
1846
1847         CommonTree LPAREN50_tree=null;
1848         CommonTree WS51_tree=null;
1849         CommonTree WS53_tree=null;
1850         CommonTree RPAREN54_tree=null;
1851         RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
1852         RewriteRuleTokenStream stream_WS=new RewriteRuleTokenStream(adaptor,"token WS");
1853         RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
1854         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
1855         try {
1856             {
1857             LPAREN50=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_composite621);
1858             stream_LPAREN.add(LPAREN50);
1859
1860             loop24:
1861             do {
1862                 int alt24=2;
1863                 int LA24_0 = input.LA(1);
1864
1865                 if ( (LA24_0==WS) ) {
1866                     alt24=1;
1867                 }
1868
1869                 switch (alt24) {
1870                 case 1 :
1871                     {
1872                     WS51=(Token)match(input,WS,FOLLOW_WS_in_composite623);
1873                     stream_WS.add(WS51);
1874
1875                     }
1876                     break;
1877
1878                 default :
1879                     break loop24;
1880                 }
1881             } while (true);
1882
1883             pushFollow(FOLLOW_expression_in_composite626);
1884             expression52=expression();
1885
1886             state._fsp--;
1887
1888             stream_expression.add(expression52.getTree());
1889             loop25:
1890             do {
1891                 int alt25=2;
1892                 int LA25_0 = input.LA(1);
1893
1894                 if ( (LA25_0==WS) ) {
1895                     alt25=1;
1896                 }
1897
1898                 switch (alt25) {
1899                 case 1 :
1900                     {
1901                     WS53=(Token)match(input,WS,FOLLOW_WS_in_composite628);
1902                     stream_WS.add(WS53);
1903
1904                     }
1905                     break;
1906
1907                 default :
1908                     break loop25;
1909                 }
1910             } while (true);
1911
1912             RPAREN54=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_composite631);
1913             stream_RPAREN.add(RPAREN54);
1914
1915             retval.tree = root_0;
1916             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
1917
1918             root_0 = (CommonTree)adaptor.nil();
1919             {
1920                 adaptor.addChild(root_0, stream_expression.nextTree());
1921
1922             }
1923
1924             retval.tree = root_0;
1925             }
1926
1927             retval.stop = input.LT(-1);
1928
1929             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1930             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1931
1932         }
1933
1934           catch (RecognitionException e) {
1935             reportError(e);
1936             throw e;
1937           }
1938         finally {
1939         }
1940         return retval;
1941     }
1942
1943     public static class item_return extends ParserRuleReturnScope {
1944         CommonTree tree;
1945         public Object getTree() { return tree; }
1946     };
1947
1948     public final QueryParser.item_return item() throws RecognitionException {
1949         QueryParser.item_return retval = new QueryParser.item_return();
1950         retval.start = input.LT(1);
1951
1952         CommonTree root_0 = null;
1953
1954         Token FIX55=null;
1955         Token REWRITE57=null;
1956         QueryParser.value_return value56 = null;
1957
1958         QueryParser.value_return value58 = null;
1959
1960         QueryParser.value_return value59 = null;
1961
1962         CommonTree FIX55_tree=null;
1963         CommonTree REWRITE57_tree=null;
1964         RewriteRuleTokenStream stream_FIX=new RewriteRuleTokenStream(adaptor,"token FIX");
1965         RewriteRuleTokenStream stream_REWRITE=new RewriteRuleTokenStream(adaptor,"token REWRITE");
1966         RewriteRuleSubtreeStream stream_value=new RewriteRuleSubtreeStream(adaptor,"rule value");
1967         try {
1968             int alt26=3;
1969             switch ( input.LA(1) ) {
1970             case FIX:
1971                 {
1972                 alt26=1;
1973                 }
1974                 break;
1975             case REWRITE:
1976                 {
1977                 alt26=2;
1978                 }
1979                 break;
1980             case DISTANCE_FN:
1981             case GEO_POINT_FN:
1982             case TEXT:
1983             case QUOTE:
1984                 {
1985                 alt26=3;
1986                 }
1987                 break;
1988             default:
1989                 NoViableAltException nvae =
1990                     new NoViableAltException("", 26, 0, input);
1991
1992                 throw nvae;
1993             }
1994
1995             switch (alt26) {
1996                 case 1 :
1997                     {
1998                     FIX55=(Token)match(input,FIX,FOLLOW_FIX_in_item651);
1999                     stream_FIX.add(FIX55);
2000
2001                     pushFollow(FOLLOW_value_in_item653);
2002                     value56=value();
2003
2004                     state._fsp--;
2005
2006                     stream_value.add(value56.getTree());
2007
2008                     retval.tree = root_0;
2009                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
2010
2011                     root_0 = (CommonTree)adaptor.nil();
2012                     {
2013                         {
2014                         CommonTree root_1 = (CommonTree)adaptor.nil();
2015                         root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(LITERAL, "LITERAL"), root_1);
2016
2017                         adaptor.addChild(root_1, stream_value.nextTree());
2018
2019                         adaptor.addChild(root_0, root_1);
2020                         }
2021
2022                     }
2023
2024                     retval.tree = root_0;
2025                     }
2026                     break;
2027                 case 2 :
2028                     {
2029                     REWRITE57=(Token)match(input,REWRITE,FOLLOW_REWRITE_in_item667);
2030                     stream_REWRITE.add(REWRITE57);
2031
2032                     pushFollow(FOLLOW_value_in_item669);
2033                     value58=value();
2034
2035                     state._fsp--;
2036
2037                     stream_value.add(value58.getTree());
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                         {
2045                         CommonTree root_1 = (CommonTree)adaptor.nil();
2046                         root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(FUZZY, "FUZZY"), root_1);
2047
2048                         adaptor.addChild(root_1, stream_value.nextTree());
2049
2050                         adaptor.addChild(root_0, root_1);
2051                         }
2052
2053                     }
2054
2055                     retval.tree = root_0;
2056                     }
2057                     break;
2058                 case 3 :
2059                     {
2060                     pushFollow(FOLLOW_value_in_item683);
2061                     value59=value();
2062
2063                     state._fsp--;
2064
2065                     stream_value.add(value59.getTree());
2066
2067                     retval.tree = root_0;
2068                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
2069
2070                     root_0 = (CommonTree)adaptor.nil();
2071                     {
2072                         adaptor.addChild(root_0, stream_value.nextTree());
2073
2074                     }
2075
2076                     retval.tree = root_0;
2077                     }
2078                     break;
2079
2080             }
2081             retval.stop = input.LT(-1);
2082
2083             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
2084             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2085
2086         }
2087
2088           catch (RecognitionException e) {
2089             reportError(e);
2090             throw e;
2091           }
2092         finally {
2093         }
2094         return retval;
2095     }
2096
2097     public static class value_return extends ParserRuleReturnScope {
2098         CommonTree tree;
2099         public Object getTree() { return tree; }
2100     };
2101
2102     public final QueryParser.value_return value() throws RecognitionException {
2103         QueryParser.value_return retval = new QueryParser.value_return();
2104         retval.start = input.LT(1);
2105
2106         CommonTree root_0 = null;
2107
2108         QueryParser.text_return text60 = null;
2109
2110         QueryParser.phrase_return phrase61 = null;
2111
2112         RewriteRuleSubtreeStream stream_text=new RewriteRuleSubtreeStream(adaptor,"rule text");
2113         RewriteRuleSubtreeStream stream_phrase=new RewriteRuleSubtreeStream(adaptor,"rule phrase");
2114         try {
2115             int alt27=2;
2116             int LA27_0 = input.LA(1);
2117
2118             if ( ((LA27_0>=DISTANCE_FN && LA27_0<=GEO_POINT_FN)||LA27_0==TEXT) ) {
2119                 alt27=1;
2120             }
2121             else if ( (LA27_0==QUOTE) ) {
2122                 alt27=2;
2123             }
2124             else {
2125                 NoViableAltException nvae =
2126                     new NoViableAltException("", 27, 0, input);
2127
2128                 throw nvae;
2129             }
2130             switch (alt27) {
2131                 case 1 :
2132                     {
2133                     pushFollow(FOLLOW_text_in_value701);
2134                     text60=text();
2135
2136                     state._fsp--;
2137
2138                     stream_text.add(text60.getTree());
2139
2140                     retval.tree = root_0;
2141                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
2142
2143                     root_0 = (CommonTree)adaptor.nil();
2144                     {
2145                         {
2146                         CommonTree root_1 = (CommonTree)adaptor.nil();
2147                         root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(VALUE, "VALUE"), root_1);
2148
2149                         adaptor.addChild(root_1, (CommonTree)adaptor.create(TEXT, "TEXT"));
2150                         adaptor.addChild(root_1, stream_text.nextTree());
2151
2152                         adaptor.addChild(root_0, root_1);
2153                         }
2154
2155                     }
2156
2157                     retval.tree = root_0;
2158                     }
2159                     break;
2160                 case 2 :
2161                     {
2162                     pushFollow(FOLLOW_phrase_in_value717);
2163                     phrase61=phrase();
2164
2165                     state._fsp--;
2166
2167                     stream_phrase.add(phrase61.getTree());
2168
2169                     retval.tree = root_0;
2170                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
2171
2172                     root_0 = (CommonTree)adaptor.nil();
2173                     {
2174                         {
2175                         CommonTree root_1 = (CommonTree)adaptor.nil();
2176                         root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(VALUE, "VALUE"), root_1);
2177
2178                         adaptor.addChild(root_1, (CommonTree)adaptor.create(STRING, "STRING"));
2179                         adaptor.addChild(root_1, stream_phrase.nextTree());
2180
2181                         adaptor.addChild(root_0, root_1);
2182                         }
2183
2184                     }
2185
2186                     retval.tree = root_0;
2187                     }
2188                     break;
2189
2190             }
2191             retval.stop = input.LT(-1);
2192
2193             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
2194             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2195
2196         }
2197
2198           catch (RecognitionException e) {
2199             reportError(e);
2200             throw e;
2201           }
2202         finally {
2203         }
2204         return retval;
2205     }
2206
2207     public static class text_return extends ParserRuleReturnScope {
2208         CommonTree tree;
2209         public Object getTree() { return tree; }
2210     };
2211
2212     public final QueryParser.text_return text() throws RecognitionException {
2213         QueryParser.text_return retval = new QueryParser.text_return();
2214         retval.start = input.LT(1);
2215
2216         CommonTree root_0 = null;
2217
2218         Token set62=null;
2219
2220         CommonTree set62_tree=null;
2221
2222         try {
2223             {
2224             root_0 = (CommonTree)adaptor.nil();
2225
2226             set62=(Token)input.LT(1);
2227             if ( (input.LA(1)>=DISTANCE_FN && input.LA(1)<=GEO_POINT_FN)||input.LA(1)==TEXT ) {
2228                 input.consume();
2229                 adaptor.addChild(root_0, (CommonTree)adaptor.create(set62));
2230                 state.errorRecovery=false;
2231             }
2232             else {
2233                 MismatchedSetException mse = new MismatchedSetException(null,input);
2234                 throw mse;
2235             }
2236
2237             }
2238
2239             retval.stop = input.LT(-1);
2240
2241             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
2242             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2243
2244         }
2245
2246           catch (RecognitionException e) {
2247             reportError(e);
2248             throw e;
2249           }
2250         finally {
2251         }
2252         return retval;
2253     }
2254
2255     public static class phrase_return extends ParserRuleReturnScope {
2256         CommonTree tree;
2257         public Object getTree() { return tree; }
2258     };
2259
2260     public final QueryParser.phrase_return phrase() throws RecognitionException {
2261         QueryParser.phrase_return retval = new QueryParser.phrase_return();
2262         retval.start = input.LT(1);
2263
2264         CommonTree root_0 = null;
2265
2266         Token QUOTE63=null;
2267         Token set64=null;
2268         Token QUOTE65=null;
2269
2270         CommonTree QUOTE63_tree=null;
2271         CommonTree set64_tree=null;
2272         CommonTree QUOTE65_tree=null;
2273
2274         try {
2275             {
2276             root_0 = (CommonTree)adaptor.nil();
2277
2278             QUOTE63=(Token)match(input,QUOTE,FOLLOW_QUOTE_in_phrase767);
2279             QUOTE63_tree = (CommonTree)adaptor.create(QUOTE63);
2280             adaptor.addChild(root_0, QUOTE63_tree);
2281
2282             loop28:
2283             do {
2284                 int alt28=2;
2285                 int LA28_0 = input.LA(1);
2286
2287                 if ( ((LA28_0>=ARGS && LA28_0<=TEXT)||(LA28_0>=ESC && LA28_0<=44)) ) {
2288                     alt28=1;
2289                 }
2290
2291                 switch (alt28) {
2292                 case 1 :
2293                     {
2294                     set64=(Token)input.LT(1);
2295                     if ( (input.LA(1)>=ARGS && input.LA(1)<=TEXT)||(input.LA(1)>=ESC && input.LA(1)<=44) ) {
2296                         input.consume();
2297                         adaptor.addChild(root_0, (CommonTree)adaptor.create(set64));
2298                         state.errorRecovery=false;
2299                     }
2300                     else {
2301                         MismatchedSetException mse = new MismatchedSetException(null,input);
2302                         throw mse;
2303                     }
2304
2305                     }
2306                     break;
2307
2308                 default :
2309                     break loop28;
2310                 }
2311             } while (true);
2312
2313             QUOTE65=(Token)match(input,QUOTE,FOLLOW_QUOTE_in_phrase785);
2314             QUOTE65_tree = (CommonTree)adaptor.create(QUOTE65);
2315             adaptor.addChild(root_0, QUOTE65_tree);
2316
2317             }
2318
2319             retval.stop = input.LT(-1);
2320
2321             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
2322             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2323
2324         }
2325
2326           catch (RecognitionException e) {
2327             reportError(e);
2328             throw e;
2329           }
2330         finally {
2331         }
2332         return retval;
2333     }
2334
2335     protected DFA3 dfa3 = new DFA3(this);
2336     protected DFA5 dfa5 = new DFA5(this);
2337     protected DFA6 dfa6 = new DFA6(this);
2338     protected DFA8 dfa8 = new DFA8(this);
2339     static final String DFA3_eotS =
2340         "\4\uffff";
2341     static final String DFA3_eofS =
2342         "\2\2\2\uffff";
2343     static final String DFA3_minS =
2344         "\2\17\2\uffff";
2345     static final String DFA3_maxS =
2346         "\1\30\1\31\2\uffff";
2347     static final String DFA3_acceptS =
2348         "\2\uffff\1\2\1\1";
2349     static final String DFA3_specialS =
2350         "\4\uffff}>";
2351     static final String[] DFA3_transitionS = {
2352             "\1\1\10\uffff\1\2",
2353             "\1\1\10\uffff\1\2\1\3",
2354             "",
2355             ""
2356     };
2357
2358     static final short[] DFA3_eot = DFA.unpackEncodedString(DFA3_eotS);
2359     static final short[] DFA3_eof = DFA.unpackEncodedString(DFA3_eofS);
2360     static final char[] DFA3_min = DFA.unpackEncodedStringToUnsignedChars(DFA3_minS);
2361     static final char[] DFA3_max = DFA.unpackEncodedStringToUnsignedChars(DFA3_maxS);
2362     static final short[] DFA3_accept = DFA.unpackEncodedString(DFA3_acceptS);
2363     static final short[] DFA3_special = DFA.unpackEncodedString(DFA3_specialS);
2364     static final short[][] DFA3_transition;
2365
2366     static {
2367         int numStates = DFA3_transitionS.length;
2368         DFA3_transition = new short[numStates][];
2369         for (int i=0; i<numStates; i++) {
2370             DFA3_transition[i] = DFA.unpackEncodedString(DFA3_transitionS[i]);
2371         }
2372     }
2373
2374     class DFA3 extends DFA {
2375
2376         public DFA3(BaseRecognizer recognizer) {
2377             this.recognizer = recognizer;
2378             this.decisionNumber = 3;
2379             this.eot = DFA3_eot;
2380             this.eof = DFA3_eof;
2381             this.min = DFA3_min;
2382             this.max = DFA3_max;
2383             this.accept = DFA3_accept;
2384             this.special = DFA3_special;
2385             this.transition = DFA3_transition;
2386         }
2387         public String getDescription() {
2388             return "()* loopback of 51:14: ( andOp sequence )*";
2389         }
2390     }
2391     static final String DFA5_eotS =
2392         "\4\uffff";
2393     static final String DFA5_eofS =
2394         "\2\2\2\uffff";
2395     static final String DFA5_minS =
2396         "\2\17\2\uffff";
2397     static final String DFA5_maxS =
2398         "\1\30\1\53\2\uffff";
2399     static final String DFA5_acceptS =
2400         "\2\uffff\1\2\1\1";
2401     static final String DFA5_specialS =
2402         "\4\uffff}>";
2403     static final String[] DFA5_transitionS = {
2404             "\1\1\10\uffff\1\2",
2405             "\1\1\7\uffff\1\3\2\2\1\uffff\7\3\11\uffff\1\3",
2406             "",
2407             ""
2408     };
2409
2410     static final short[] DFA5_eot = DFA.unpackEncodedString(DFA5_eotS);
2411     static final short[] DFA5_eof = DFA.unpackEncodedString(DFA5_eofS);
2412     static final char[] DFA5_min = DFA.unpackEncodedStringToUnsignedChars(DFA5_minS);
2413     static final char[] DFA5_max = DFA.unpackEncodedStringToUnsignedChars(DFA5_maxS);
2414     static final short[] DFA5_accept = DFA.unpackEncodedString(DFA5_acceptS);
2415     static final short[] DFA5_special = DFA.unpackEncodedString(DFA5_specialS);
2416     static final short[][] DFA5_transition;
2417
2418     static {
2419         int numStates = DFA5_transitionS.length;
2420         DFA5_transition = new short[numStates][];
2421         for (int i=0; i<numStates; i++) {
2422             DFA5_transition[i] = DFA.unpackEncodedString(DFA5_transitionS[i]);
2423         }
2424     }
2425
2426     class DFA5 extends DFA {
2427
2428         public DFA5(BaseRecognizer recognizer) {
2429             this.recognizer = recognizer;
2430             this.decisionNumber = 5;
2431             this.eot = DFA5_eot;
2432             this.eof = DFA5_eof;
2433             this.min = DFA5_min;
2434             this.max = DFA5_max;
2435             this.accept = DFA5_accept;
2436             this.special = DFA5_special;
2437             this.transition = DFA5_transition;
2438         }
2439         public String getDescription() {
2440             return "()* loopback of 57:12: ( ( WS )+ factor )*";
2441         }
2442     }
2443     static final String DFA6_eotS =
2444         "\4\uffff";
2445     static final String DFA6_eofS =
2446         "\2\2\2\uffff";
2447     static final String DFA6_minS =
2448         "\2\17\2\uffff";
2449     static final String DFA6_maxS =
2450         "\1\30\1\53\2\uffff";
2451     static final String DFA6_acceptS =
2452         "\2\uffff\1\2\1\1";
2453     static final String DFA6_specialS =
2454         "\4\uffff}>";
2455     static final String[] DFA6_transitionS = {
2456             "\1\1\10\uffff\1\2",
2457             "\1\1\7\uffff\3\2\1\3\7\2\11\uffff\1\2",
2458             "",
2459             ""
2460     };
2461
2462     static final short[] DFA6_eot = DFA.unpackEncodedString(DFA6_eotS);
2463     static final short[] DFA6_eof = DFA.unpackEncodedString(DFA6_eofS);
2464     static final char[] DFA6_min = DFA.unpackEncodedStringToUnsignedChars(DFA6_minS);
2465     static final char[] DFA6_max = DFA.unpackEncodedStringToUnsignedChars(DFA6_maxS);
2466     static final short[] DFA6_accept = DFA.unpackEncodedString(DFA6_acceptS);
2467     static final short[] DFA6_special = DFA.unpackEncodedString(DFA6_specialS);
2468     static final short[][] DFA6_transition;
2469
2470     static {
2471         int numStates = DFA6_transitionS.length;
2472         DFA6_transition = new short[numStates][];
2473         for (int i=0; i<numStates; i++) {
2474             DFA6_transition[i] = DFA.unpackEncodedString(DFA6_transitionS[i]);
2475         }
2476     }
2477
2478     class DFA6 extends DFA {
2479
2480         public DFA6(BaseRecognizer recognizer) {
2481             this.recognizer = recognizer;
2482             this.decisionNumber = 6;
2483             this.eot = DFA6_eot;
2484             this.eof = DFA6_eof;
2485             this.min = DFA6_min;
2486             this.max = DFA6_max;
2487             this.accept = DFA6_accept;
2488             this.special = DFA6_special;
2489             this.transition = DFA6_transition;
2490         }
2491         public String getDescription() {
2492             return "()* loopback of 63:10: ( orOp term )*";
2493         }
2494     }
2495     static final String DFA8_eotS =
2496         "\24\uffff";
2497     static final String DFA8_eofS =
2498         "\3\uffff\1\15\1\uffff\1\15\1\uffff\1\15\1\uffff\1\15\1\uffff\1\15"+
2499         "\3\uffff\1\15\1\uffff\1\15\1\uffff\1\15";
2500     static final String DFA8_minS =
2501         "\1\27\2\34\1\17\1\4\1\17\1\uffff\1\17\1\4\1\17\1\4\1\17\2\uffff"+
2502         "\1\4\1\17\1\4\1\17\1\4\1\17";
2503     static final String DFA8_maxS =
2504         "\3\41\1\30\1\54\1\30\1\uffff\1\30\1\54\1\30\1\54\1\53\2\uffff\1"+
2505         "\54\1\30\1\54\1\30\1\54\1\30";
2506     static final String DFA8_acceptS =
2507         "\6\uffff\1\2\5\uffff\1\1\1\3\6\uffff";
2508     static final String DFA8_specialS =
2509         "\24\uffff}>";
2510     static final String[] DFA8_transitionS = {
2511             "\1\6\4\uffff\2\3\1\1\1\2\1\5\1\4",
2512             "\2\7\2\uffff\1\7\1\10",
2513             "\2\11\2\uffff\1\11\1\12",
2514             "\1\13\10\14\1\15",
2515             "\35\16\1\17\13\16",
2516             "\1\13\7\14\1\uffff\1\15",
2517             "",
2518             "\1\13\7\14\1\uffff\1\15",
2519             "\35\20\1\21\13\20",
2520             "\1\13\7\14\1\uffff\1\15",
2521             "\35\22\1\23\13\22",
2522             "\1\13\7\14\13\15\11\uffff\1\15",
2523             "",
2524             "",
2525             "\35\16\1\17\13\16",
2526             "\1\13\7\14\1\uffff\1\15",
2527             "\35\20\1\21\13\20",
2528             "\1\13\7\14\1\uffff\1\15",
2529             "\35\22\1\23\13\22",
2530             "\1\13\7\14\1\uffff\1\15"
2531     };
2532
2533     static final short[] DFA8_eot = DFA.unpackEncodedString(DFA8_eotS);
2534     static final short[] DFA8_eof = DFA.unpackEncodedString(DFA8_eofS);
2535     static final char[] DFA8_min = DFA.unpackEncodedStringToUnsignedChars(DFA8_minS);
2536     static final char[] DFA8_max = DFA.unpackEncodedStringToUnsignedChars(DFA8_maxS);
2537     static final short[] DFA8_accept = DFA.unpackEncodedString(DFA8_acceptS);
2538     static final short[] DFA8_special = DFA.unpackEncodedString(DFA8_specialS);
2539     static final short[][] DFA8_transition;
2540
2541     static {
2542         int numStates = DFA8_transitionS.length;
2543         DFA8_transition = new short[numStates][];
2544         for (int i=0; i<numStates; i++) {
2545             DFA8_transition[i] = DFA.unpackEncodedString(DFA8_transitionS[i]);
2546         }
2547     }
2548
2549     class DFA8 extends DFA {
2550
2551         public DFA8(BaseRecognizer recognizer) {
2552             this.recognizer = recognizer;
2553             this.decisionNumber = 8;
2554             this.eot = DFA8_eot;
2555             this.eof = DFA8_eof;
2556             this.min = DFA8_min;
2557             this.max = DFA8_max;
2558             this.accept = DFA8_accept;
2559             this.special = DFA8_special;
2560             this.transition = DFA8_transition;
2561         }
2562         public String getDescription() {
2563             return "74:1: primitive : ( restrict | composite | item -> ^( HAS GLOBAL item ) );";
2564         }
2565     }
2566
2567     public static final BitSet FOLLOW_WS_in_query121 = new BitSet(new long[]{0x00000803F8808000L});
2568     public static final BitSet FOLLOW_expression_in_query124 = new BitSet(new long[]{0x0000000000008000L});
2569     public static final BitSet FOLLOW_WS_in_query126 = new BitSet(new long[]{0x0000000000008000L});
2570     public static final BitSet FOLLOW_EOF_in_query129 = new BitSet(new long[]{0x0000000000000002L});
2571     public static final BitSet FOLLOW_sequence_in_expression148 = new BitSet(new long[]{0x0000000000008002L});
2572     public static final BitSet FOLLOW_andOp_in_expression151 = new BitSet(new long[]{0x00000803F8800000L});
2573     public static final BitSet FOLLOW_sequence_in_expression153 = new BitSet(new long[]{0x0000000000008002L});
2574     public static final BitSet FOLLOW_factor_in_sequence179 = new BitSet(new long[]{0x0000000000008002L});
2575     public static final BitSet FOLLOW_WS_in_sequence182 = new BitSet(new long[]{0x00000803F8808000L});
2576     public static final BitSet FOLLOW_factor_in_sequence185 = new BitSet(new long[]{0x0000000000008002L});
2577     public static final BitSet FOLLOW_term_in_factor211 = new BitSet(new long[]{0x0000000000008002L});
2578     public static final BitSet FOLLOW_orOp_in_factor214 = new BitSet(new long[]{0x00000803F8800000L});
2579     public static final BitSet FOLLOW_term_in_factor216 = new BitSet(new long[]{0x0000000000008002L});
2580     public static final BitSet FOLLOW_notOp_in_term240 = new BitSet(new long[]{0x00000803F8800000L});
2581     public static final BitSet FOLLOW_primitive_in_term242 = new BitSet(new long[]{0x0000000000000002L});
2582     public static final BitSet FOLLOW_primitive_in_term256 = new BitSet(new long[]{0x0000000000000002L});
2583     public static final BitSet FOLLOW_restrict_in_primitive272 = new BitSet(new long[]{0x0000000000000002L});
2584     public static final BitSet FOLLOW_composite_in_primitive278 = new BitSet(new long[]{0x0000000000000002L});
2585     public static final BitSet FOLLOW_item_in_primitive284 = new BitSet(new long[]{0x0000000000000002L});
2586     public static final BitSet FOLLOW_comparable_in_restrict310 = new BitSet(new long[]{0x00000000007F8000L});
2587     public static final BitSet FOLLOW_comparator_in_restrict312 = new BitSet(new long[]{0x00000003F0800000L});
2588     public static final BitSet FOLLOW_arg_in_restrict314 = new BitSet(new long[]{0x0000000000000002L});
2589     public static final BitSet FOLLOW_WS_in_comparator338 = new BitSet(new long[]{0x00000000007F8000L});
2590     public static final BitSet FOLLOW_LE_in_comparator344 = new BitSet(new long[]{0x0000000000008002L});
2591     public static final BitSet FOLLOW_LT_in_comparator350 = new BitSet(new long[]{0x0000000000008002L});
2592     public static final BitSet FOLLOW_GE_in_comparator356 = new BitSet(new long[]{0x0000000000008002L});
2593     public static final BitSet FOLLOW_GT_in_comparator362 = new BitSet(new long[]{0x0000000000008002L});
2594     public static final BitSet FOLLOW_NE_in_comparator368 = new BitSet(new long[]{0x0000000000008002L});
2595     public static final BitSet FOLLOW_EQ_in_comparator374 = new BitSet(new long[]{0x0000000000008002L});
2596     public static final BitSet FOLLOW_HAS_in_comparator380 = new BitSet(new long[]{0x0000000000008002L});
2597     public static final BitSet FOLLOW_WS_in_comparator383 = new BitSet(new long[]{0x0000000000008002L});
2598     public static final BitSet FOLLOW_item_in_comparable405 = new BitSet(new long[]{0x0000000000000002L});
2599     public static final BitSet FOLLOW_function_in_comparable411 = new BitSet(new long[]{0x0000000000000002L});
2600     public static final BitSet FOLLOW_fnname_in_function426 = new BitSet(new long[]{0x0000000000800000L});
2601     public static final BitSet FOLLOW_LPAREN_in_function428 = new BitSet(new long[]{0x00000003F1800000L});
2602     public static final BitSet FOLLOW_arglist_in_function430 = new BitSet(new long[]{0x0000000001000000L});
2603     public static final BitSet FOLLOW_RPAREN_in_function432 = new BitSet(new long[]{0x0000000000000002L});
2604     public static final BitSet FOLLOW_arg_in_arglist461 = new BitSet(new long[]{0x0000100000008002L});
2605     public static final BitSet FOLLOW_sep_in_arglist464 = new BitSet(new long[]{0x00000003F0800000L});
2606     public static final BitSet FOLLOW_arg_in_arglist466 = new BitSet(new long[]{0x0000100000008002L});
2607     public static final BitSet FOLLOW_item_in_arg491 = new BitSet(new long[]{0x0000000000000002L});
2608     public static final BitSet FOLLOW_composite_in_arg497 = new BitSet(new long[]{0x0000000000000002L});
2609     public static final BitSet FOLLOW_function_in_arg503 = new BitSet(new long[]{0x0000000000000002L});
2610     public static final BitSet FOLLOW_WS_in_andOp517 = new BitSet(new long[]{0x0000000002008000L});
2611     public static final BitSet FOLLOW_AND_in_andOp520 = new BitSet(new long[]{0x0000000000008000L});
2612     public static final BitSet FOLLOW_WS_in_andOp522 = new BitSet(new long[]{0x0000000000008002L});
2613     public static final BitSet FOLLOW_WS_in_orOp537 = new BitSet(new long[]{0x0000000004008000L});
2614     public static final BitSet FOLLOW_OR_in_orOp540 = new BitSet(new long[]{0x0000000000008000L});
2615     public static final BitSet FOLLOW_WS_in_orOp542 = new BitSet(new long[]{0x0000000000008002L});
2616     public static final BitSet FOLLOW_43_in_notOp557 = new BitSet(new long[]{0x0000000000000002L});
2617     public static final BitSet FOLLOW_NOT_in_notOp563 = new BitSet(new long[]{0x0000000000008000L});
2618     public static final BitSet FOLLOW_WS_in_notOp565 = new BitSet(new long[]{0x0000000000008002L});
2619     public static final BitSet FOLLOW_WS_in_sep580 = new BitSet(new long[]{0x0000100000008000L});
2620     public static final BitSet FOLLOW_44_in_sep583 = new BitSet(new long[]{0x0000000000008002L});
2621     public static final BitSet FOLLOW_WS_in_sep585 = new BitSet(new long[]{0x0000000000008002L});
2622     public static final BitSet FOLLOW_set_in_fnname0 = new BitSet(new long[]{0x0000000000000002L});
2623     public static final BitSet FOLLOW_LPAREN_in_composite621 = new BitSet(new long[]{0x00000803F8808000L});
2624     public static final BitSet FOLLOW_WS_in_composite623 = new BitSet(new long[]{0x00000803F8808000L});
2625     public static final BitSet FOLLOW_expression_in_composite626 = new BitSet(new long[]{0x0000000001008000L});
2626     public static final BitSet FOLLOW_WS_in_composite628 = new BitSet(new long[]{0x0000000001008000L});
2627     public static final BitSet FOLLOW_RPAREN_in_composite631 = new BitSet(new long[]{0x0000000000000002L});
2628     public static final BitSet FOLLOW_FIX_in_item651 = new BitSet(new long[]{0x00000003F0000000L});
2629     public static final BitSet FOLLOW_value_in_item653 = new BitSet(new long[]{0x0000000000000002L});
2630     public static final BitSet FOLLOW_REWRITE_in_item667 = new BitSet(new long[]{0x00000003F0000000L});
2631     public static final BitSet FOLLOW_value_in_item669 = new BitSet(new long[]{0x0000000000000002L});
2632     public static final BitSet FOLLOW_value_in_item683 = new BitSet(new long[]{0x0000000000000002L});
2633     public static final BitSet FOLLOW_text_in_value701 = new BitSet(new long[]{0x0000000000000002L});
2634     public static final BitSet FOLLOW_phrase_in_value717 = new BitSet(new long[]{0x0000000000000002L});
2635     public static final BitSet FOLLOW_set_in_text0 = new BitSet(new long[]{0x0000000000000002L});
2636     public static final BitSet FOLLOW_QUOTE_in_phrase767 = new BitSet(new long[]{0x00001FFFFFFFFFF0L});
2637     public static final BitSet FOLLOW_set_in_phrase769 = new BitSet(new long[]{0x00001FFFFFFFFFF0L});
2638     public static final BitSet FOLLOW_QUOTE_in_phrase785 = new BitSet(new long[]{0x0000000000000002L});
2639
2640 }