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

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