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