java/src/main/com/google/appengine/api/search/query/ExpressionParser.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 ExpressionParser extends Parser {
  10     public static final String[] tokenNames = new String[] {
  11         "<invalid>", "<EOR>", "<DOWN>", "<UP>", "NEG", "INDEX", "COND", "AND", "OR", "XOR", "NOT", "LT", "LE", "GT", "GE", "EQ", "NE", "PLUS", "MINUS", "TIMES", "DIV", "LPAREN", "RPAREN", "LSQUARE", "INT", "RSQUARE", "NAME", "TEXT", "HTML", "ATOM", "DATE", "NUMBER", "GEO", "GEOPOINT", "FLOAT", "PHRASE", "COMMA", "ABS", "COUNT", "DISTANCE", "LOG", "MAX", "MIN", "POW", "SNIPPET", "SWITCH", "DIGIT", "QUOTE", "ESC_SEQ", "EXPONENT", "NAME_START", "WS", "ASCII_LETTER", "UNDERSCORE", "DOLLAR", "HEX_DIGIT", "UNICODE_ESC", "OCTAL_ESC", "'.'"
  12     };
  13     public static final int UNDERSCORE=53;
  14     public static final int GEOPOINT=33;
  15     public static final int UNICODE_ESC=56;
  16     public static final int LT=11;
  17     public static final int TEXT=27;
  18     public static final int HTML=28;
  19     public static final int MINUS=18;
  20     public static final int RSQUARE=25;
  21     public static final int SNIPPET=44;
  22     public static final int PHRASE=35;
  23     public static final int T__58=58;
  24     public static final int INDEX=5;
  25     public static final int OCTAL_ESC=57;
  26     public static final int NUMBER=31;
  27     public static final int DISTANCE=39;
  28     public static final int LOG=40;
  29     public static final int LPAREN=21;
  30     public static final int RPAREN=22;
  31     public static final int EQ=15;
  32     public static final int NAME=26;
  33     public static final int GEO=32;
  34     public static final int DATE=30;
  35     public static final int NOT=10;
  36     public static final int MIN=42;
  37     public static final int ASCII_LETTER=52;
  38     public static final int AND=7;
  39     public static final int NE=16;
  40     public static final int POW=43;
  41     public static final int XOR=9;
  42     public static final int COUNT=38;
  43     public static final int SWITCH=45;
  44     public static final int DOLLAR=54;
  45     public static final int COND=6;
  46     public static final int PLUS=17;
  47     public static final int QUOTE=47;
  48     public static final int FLOAT=34;
  49     public static final int MAX=41;
  50     public static final int INT=24;
  51     public static final int ATOM=29;
  52     public static final int NAME_START=50;
  53     public static final int ABS=37;
  54     public static final int HEX_DIGIT=55;
  55     public static final int ESC_SEQ=48;
  56     public static final int WS=51;
  57     public static final int EOF=-1;
  58     public static final int GE=14;
  59     public static final int COMMA=36;
  60     public static final int OR=8;
  61     public static final int TIMES=19;
  62     public static final int GT=13;
  63     public static final int DIGIT=46;
  64     public static final int DIV=20;
  65     public static final int NEG=4;
  66     public static final int LSQUARE=23;
  67     public static final int LE=12;
  68     public static final int EXPONENT=49;
  69
  70         public ExpressionParser(TokenStream input) {
  71             this(input, new RecognizerSharedState());
  72         }
  73         public ExpressionParser(TokenStream input, RecognizerSharedState state) {
  74             super(input, state);
  75
  76         }
  77
  78     protected TreeAdaptor adaptor = new CommonTreeAdaptor();
  79
  80     public void setTreeAdaptor(TreeAdaptor adaptor) {
  81         this.adaptor = adaptor;
  82     }
  83     public TreeAdaptor getTreeAdaptor() {
  84         return adaptor;
  85     }
  86
  87     public String[] getTokenNames() { return ExpressionParser.tokenNames; }
  88     public String getGrammarFileName() { return ""; }
  89
  90       @Override
  91       public Object recoverFromMismatchedSet(IntStream input,
  92           RecognitionException e, BitSet follow) throws RecognitionException {
  93         throw e;
  94       }
  95
  96       @Override
  97       protected Object recoverFromMismatchedToken(
  98           IntStream input, int ttype, BitSet follow) throws RecognitionException {
  99         throw new MismatchedTokenException(ttype, input);
 100       }
 101
 102     public static class expression_return extends ParserRuleReturnScope {
 103         CommonTree tree;
 104         public Object getTree() { return tree; }
 105     };
 106
 107     public final ExpressionParser.expression_return expression() throws RecognitionException {
 108         ExpressionParser.expression_return retval = new ExpressionParser.expression_return();
 109         retval.start = input.LT(1);
 110
 111         CommonTree root_0 = null;
 112
 113         Token EOF2=null;
 114         ExpressionParser.conjunction_return conjunction1 = null;
 115
 116         CommonTree EOF2_tree=null;
 117
 118         try {
 119             {
 120             root_0 = (CommonTree)adaptor.nil();
 121
 122             pushFollow(FOLLOW_conjunction_in_expression84);
 123             conjunction1=conjunction();
 124
 125             state._fsp--;
 126
 127             adaptor.addChild(root_0, conjunction1.getTree());
 128             EOF2=(Token)match(input,EOF,FOLLOW_EOF_in_expression86);
 129             EOF2_tree = (CommonTree)adaptor.create(EOF2);
 130             adaptor.addChild(root_0, EOF2_tree);
 131
 132             }
 133
 134             retval.stop = input.LT(-1);
 135
 136             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 137             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 138
 139         }
 140
 141           catch (RecognitionException e) {
 142             reportError(e);
 143             throw e;
 144           }
 145         finally {
 146         }
 147         return retval;
 148     }
 149
 150     public static class condExpr_return extends ParserRuleReturnScope {
 151         CommonTree tree;
 152         public Object getTree() { return tree; }
 153     };
 154
 155     public final ExpressionParser.condExpr_return condExpr() throws RecognitionException {
 156         ExpressionParser.condExpr_return retval = new ExpressionParser.condExpr_return();
 157         retval.start = input.LT(1);
 158
 159         CommonTree root_0 = null;
 160
 161         Token COND4=null;
 162         ExpressionParser.conjunction_return conjunction3 = null;
 163
 164         ExpressionParser.addExpr_return addExpr5 = null;
 165
 166         CommonTree COND4_tree=null;
 167
 168         try {
 169             {
 170             root_0 = (CommonTree)adaptor.nil();
 171
 172             pushFollow(FOLLOW_conjunction_in_condExpr99);
 173             conjunction3=conjunction();
 174
 175             state._fsp--;
 176
 177             adaptor.addChild(root_0, conjunction3.getTree());
 178             int alt1=2;
 179             int LA1_0 = input.LA(1);
 180
 181             if ( (LA1_0==COND) ) {
 182                 alt1=1;
 183             }
 184             switch (alt1) {
 185                 case 1 :
 186                     {
 187                     COND4=(Token)match(input,COND,FOLLOW_COND_in_condExpr102);
 188                     COND4_tree = (CommonTree)adaptor.create(COND4);
 189                     root_0 = (CommonTree)adaptor.becomeRoot(COND4_tree, root_0);
 190
 191                     pushFollow(FOLLOW_addExpr_in_condExpr105);
 192                     addExpr5=addExpr();
 193
 194                     state._fsp--;
 195
 196                     adaptor.addChild(root_0, addExpr5.getTree());
 197
 198                     }
 199                     break;
 200
 201             }
 202
 203             }
 204
 205             retval.stop = input.LT(-1);
 206
 207             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 208             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 209
 210         }
 211
 212           catch (RecognitionException e) {
 213             reportError(e);
 214             throw e;
 215           }
 216         finally {
 217         }
 218         return retval;
 219     }
 220
 221     public static class conjunction_return extends ParserRuleReturnScope {
 222         CommonTree tree;
 223         public Object getTree() { return tree; }
 224     };
 225
 226     public final ExpressionParser.conjunction_return conjunction() throws RecognitionException {
 227         ExpressionParser.conjunction_return retval = new ExpressionParser.conjunction_return();
 228         retval.start = input.LT(1);
 229
 230         CommonTree root_0 = null;
 231
 232         Token AND7=null;
 233         ExpressionParser.disjunction_return disjunction6 = null;
 234
 235         ExpressionParser.disjunction_return disjunction8 = null;
 236
 237         CommonTree AND7_tree=null;
 238
 239         try {
 240             {
 241             root_0 = (CommonTree)adaptor.nil();
 242
 243             pushFollow(FOLLOW_disjunction_in_conjunction120);
 244             disjunction6=disjunction();
 245
 246             state._fsp--;
 247
 248             adaptor.addChild(root_0, disjunction6.getTree());
 249             loop2:
 250             do {
 251                 int alt2=2;
 252                 int LA2_0 = input.LA(1);
 253
 254                 if ( (LA2_0==AND) ) {
 255                     alt2=1;
 256                 }
 257
 258                 switch (alt2) {
 259                 case 1 :
 260                     {
 261                     AND7=(Token)match(input,AND,FOLLOW_AND_in_conjunction123);
 262                     AND7_tree = (CommonTree)adaptor.create(AND7);
 263                     root_0 = (CommonTree)adaptor.becomeRoot(AND7_tree, root_0);
 264
 265                     pushFollow(FOLLOW_disjunction_in_conjunction126);
 266                     disjunction8=disjunction();
 267
 268                     state._fsp--;
 269
 270                     adaptor.addChild(root_0, disjunction8.getTree());
 271
 272                     }
 273                     break;
 274
 275                 default :
 276                     break loop2;
 277                 }
 278             } while (true);
 279
 280             }
 281
 282             retval.stop = input.LT(-1);
 283
 284             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 285             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 286
 287         }
 288
 289           catch (RecognitionException e) {
 290             reportError(e);
 291             throw e;
 292           }
 293         finally {
 294         }
 295         return retval;
 296     }
 297
 298     public static class disjunction_return extends ParserRuleReturnScope {
 299         CommonTree tree;
 300         public Object getTree() { return tree; }
 301     };
 302
 303     public final ExpressionParser.disjunction_return disjunction() throws RecognitionException {
 304         ExpressionParser.disjunction_return retval = new ExpressionParser.disjunction_return();
 305         retval.start = input.LT(1);
 306
 307         CommonTree root_0 = null;
 308
 309         Token set10=null;
 310         ExpressionParser.negation_return negation9 = null;
 311
 312         ExpressionParser.negation_return negation11 = null;
 313
 314         CommonTree set10_tree=null;
 315
 316         try {
 317             {
 318             root_0 = (CommonTree)adaptor.nil();
 319
 320             pushFollow(FOLLOW_negation_in_disjunction141);
 321             negation9=negation();
 322
 323             state._fsp--;
 324
 325             adaptor.addChild(root_0, negation9.getTree());
 326             loop3:
 327             do {
 328                 int alt3=2;
 329                 int LA3_0 = input.LA(1);
 330
 331                 if ( ((LA3_0>=OR && LA3_0<=XOR)) ) {
 332                     alt3=1;
 333                 }
 334
 335                 switch (alt3) {
 336                 case 1 :
 337                     {
 338                     set10=(Token)input.LT(1);
 339                     set10=(Token)input.LT(1);
 340                     if ( (input.LA(1)>=OR && input.LA(1)<=XOR) ) {
 341                         input.consume();
 342                         root_0 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(set10), root_0);
 343                         state.errorRecovery=false;
 344                     }
 345                     else {
 346                         MismatchedSetException mse = new MismatchedSetException(null,input);
 347                         throw mse;
 348                     }
 349
 350                     pushFollow(FOLLOW_negation_in_disjunction153);
 351                     negation11=negation();
 352
 353                     state._fsp--;
 354
 355                     adaptor.addChild(root_0, negation11.getTree());
 356
 357                     }
 358                     break;
 359
 360                 default :
 361                     break loop3;
 362                 }
 363             } while (true);
 364
 365             }
 366
 367             retval.stop = input.LT(-1);
 368
 369             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 370             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 371
 372         }
 373
 374           catch (RecognitionException e) {
 375             reportError(e);
 376             throw e;
 377           }
 378         finally {
 379         }
 380         return retval;
 381     }
 382
 383     public static class negation_return extends ParserRuleReturnScope {
 384         CommonTree tree;
 385         public Object getTree() { return tree; }
 386     };
 387
 388     public final ExpressionParser.negation_return negation() throws RecognitionException {
 389         ExpressionParser.negation_return retval = new ExpressionParser.negation_return();
 390         retval.start = input.LT(1);
 391
 392         CommonTree root_0 = null;
 393
 394         Token NOT13=null;
 395         ExpressionParser.cmpExpr_return cmpExpr12 = null;
 396
 397         ExpressionParser.cmpExpr_return cmpExpr14 = null;
 398
 399         CommonTree NOT13_tree=null;
 400
 401         try {
 402             int alt4=2;
 403             int LA4_0 = input.LA(1);
 404
 405             if ( (LA4_0==MINUS||LA4_0==LPAREN||LA4_0==INT||(LA4_0>=NAME && LA4_0<=PHRASE)||(LA4_0>=ABS && LA4_0<=SWITCH)) ) {
 406                 alt4=1;
 407             }
 408             else if ( (LA4_0==NOT) ) {
 409                 alt4=2;
 410             }
 411             else {
 412                 NoViableAltException nvae =
 413                     new NoViableAltException("", 4, 0, input);
 414
 415                 throw nvae;
 416             }
 417             switch (alt4) {
 418                 case 1 :
 419                     {
 420                     root_0 = (CommonTree)adaptor.nil();
 421
 422                     pushFollow(FOLLOW_cmpExpr_in_negation168);
 423                     cmpExpr12=cmpExpr();
 424
 425                     state._fsp--;
 426
 427                     adaptor.addChild(root_0, cmpExpr12.getTree());
 428
 429                     }
 430                     break;
 431                 case 2 :
 432                     {
 433                     root_0 = (CommonTree)adaptor.nil();
 434
 435                     NOT13=(Token)match(input,NOT,FOLLOW_NOT_in_negation174);
 436                     NOT13_tree = (CommonTree)adaptor.create(NOT13);
 437                     root_0 = (CommonTree)adaptor.becomeRoot(NOT13_tree, root_0);
 438
 439                     pushFollow(FOLLOW_cmpExpr_in_negation177);
 440                     cmpExpr14=cmpExpr();
 441
 442                     state._fsp--;
 443
 444                     adaptor.addChild(root_0, cmpExpr14.getTree());
 445
 446                     }
 447                     break;
 448
 449             }
 450             retval.stop = input.LT(-1);
 451
 452             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 453             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 454
 455         }
 456
 457           catch (RecognitionException e) {
 458             reportError(e);
 459             throw e;
 460           }
 461         finally {
 462         }
 463         return retval;
 464     }
 465
 466     public static class cmpExpr_return extends ParserRuleReturnScope {
 467         CommonTree tree;
 468         public Object getTree() { return tree; }
 469     };
 470
 471     public final ExpressionParser.cmpExpr_return cmpExpr() throws RecognitionException {
 472         ExpressionParser.cmpExpr_return retval = new ExpressionParser.cmpExpr_return();
 473         retval.start = input.LT(1);
 474
 475         CommonTree root_0 = null;
 476
 477         ExpressionParser.addExpr_return addExpr15 = null;
 478
 479         ExpressionParser.cmpOp_return cmpOp16 = null;
 480
 481         ExpressionParser.addExpr_return addExpr17 = null;
 482
 483         try {
 484             {
 485             root_0 = (CommonTree)adaptor.nil();
 486
 487             pushFollow(FOLLOW_addExpr_in_cmpExpr190);
 488             addExpr15=addExpr();
 489
 490             state._fsp--;
 491
 492             adaptor.addChild(root_0, addExpr15.getTree());
 493             int alt5=2;
 494             int LA5_0 = input.LA(1);
 495
 496             if ( ((LA5_0>=LT && LA5_0<=NE)) ) {
 497                 alt5=1;
 498             }
 499             switch (alt5) {
 500                 case 1 :
 501                     {
 502                     pushFollow(FOLLOW_cmpOp_in_cmpExpr193);
 503                     cmpOp16=cmpOp();
 504
 505                     state._fsp--;
 506
 507                     root_0 = (CommonTree)adaptor.becomeRoot(cmpOp16.getTree(), root_0);
 508                     pushFollow(FOLLOW_addExpr_in_cmpExpr196);
 509                     addExpr17=addExpr();
 510
 511                     state._fsp--;
 512
 513                     adaptor.addChild(root_0, addExpr17.getTree());
 514
 515                     }
 516                     break;
 517
 518             }
 519
 520             }
 521
 522             retval.stop = input.LT(-1);
 523
 524             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 525             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 526
 527         }
 528
 529           catch (RecognitionException e) {
 530             reportError(e);
 531             throw e;
 532           }
 533         finally {
 534         }
 535         return retval;
 536     }
 537
 538     public static class cmpOp_return extends ParserRuleReturnScope {
 539         CommonTree tree;
 540         public Object getTree() { return tree; }
 541     };
 542
 543     public final ExpressionParser.cmpOp_return cmpOp() throws RecognitionException {
 544         ExpressionParser.cmpOp_return retval = new ExpressionParser.cmpOp_return();
 545         retval.start = input.LT(1);
 546
 547         CommonTree root_0 = null;
 548
 549         Token set18=null;
 550
 551         CommonTree set18_tree=null;
 552
 553         try {
 554             {
 555             root_0 = (CommonTree)adaptor.nil();
 556
 557             set18=(Token)input.LT(1);
 558             if ( (input.LA(1)>=LT && input.LA(1)<=NE) ) {
 559                 input.consume();
 560                 adaptor.addChild(root_0, (CommonTree)adaptor.create(set18));
 561                 state.errorRecovery=false;
 562             }
 563             else {
 564                 MismatchedSetException mse = new MismatchedSetException(null,input);
 565                 throw mse;
 566             }
 567
 568             }
 569
 570             retval.stop = input.LT(-1);
 571
 572             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 573             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 574
 575         }
 576
 577           catch (RecognitionException e) {
 578             reportError(e);
 579             throw e;
 580           }
 581         finally {
 582         }
 583         return retval;
 584     }
 585
 586     public static class addExpr_return extends ParserRuleReturnScope {
 587         CommonTree tree;
 588         public Object getTree() { return tree; }
 589     };
 590
 591     public final ExpressionParser.addExpr_return addExpr() throws RecognitionException {
 592         ExpressionParser.addExpr_return retval = new ExpressionParser.addExpr_return();
 593         retval.start = input.LT(1);
 594
 595         CommonTree root_0 = null;
 596
 597         ExpressionParser.multExpr_return multExpr19 = null;
 598
 599         ExpressionParser.addOp_return addOp20 = null;
 600
 601         ExpressionParser.multExpr_return multExpr21 = null;
 602
 603         try {
 604             {
 605             root_0 = (CommonTree)adaptor.nil();
 606
 607             pushFollow(FOLLOW_multExpr_in_addExpr254);
 608             multExpr19=multExpr();
 609
 610             state._fsp--;
 611
 612             adaptor.addChild(root_0, multExpr19.getTree());
 613             loop6:
 614             do {
 615                 int alt6=2;
 616                 int LA6_0 = input.LA(1);
 617
 618                 if ( ((LA6_0>=PLUS && LA6_0<=MINUS)) ) {
 619                     alt6=1;
 620                 }
 621
 622                 switch (alt6) {
 623                 case 1 :
 624                     {
 625                     pushFollow(FOLLOW_addOp_in_addExpr257);
 626                     addOp20=addOp();
 627
 628                     state._fsp--;
 629
 630                     root_0 = (CommonTree)adaptor.becomeRoot(addOp20.getTree(), root_0);
 631                     pushFollow(FOLLOW_multExpr_in_addExpr260);
 632                     multExpr21=multExpr();
 633
 634                     state._fsp--;
 635
 636                     adaptor.addChild(root_0, multExpr21.getTree());
 637
 638                     }
 639                     break;
 640
 641                 default :
 642                     break loop6;
 643                 }
 644             } while (true);
 645
 646             }
 647
 648             retval.stop = input.LT(-1);
 649
 650             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 651             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 652
 653         }
 654
 655           catch (RecognitionException e) {
 656             reportError(e);
 657             throw e;
 658           }
 659         finally {
 660         }
 661         return retval;
 662     }
 663
 664     public static class addOp_return extends ParserRuleReturnScope {
 665         CommonTree tree;
 666         public Object getTree() { return tree; }
 667     };
 668
 669     public final ExpressionParser.addOp_return addOp() throws RecognitionException {
 670         ExpressionParser.addOp_return retval = new ExpressionParser.addOp_return();
 671         retval.start = input.LT(1);
 672
 673         CommonTree root_0 = null;
 674
 675         Token set22=null;
 676
 677         CommonTree set22_tree=null;
 678
 679         try {
 680             {
 681             root_0 = (CommonTree)adaptor.nil();
 682
 683             set22=(Token)input.LT(1);
 684             if ( (input.LA(1)>=PLUS && input.LA(1)<=MINUS) ) {
 685                 input.consume();
 686                 adaptor.addChild(root_0, (CommonTree)adaptor.create(set22));
 687                 state.errorRecovery=false;
 688             }
 689             else {
 690                 MismatchedSetException mse = new MismatchedSetException(null,input);
 691                 throw mse;
 692             }
 693
 694             }
 695
 696             retval.stop = input.LT(-1);
 697
 698             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 699             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 700
 701         }
 702
 703           catch (RecognitionException e) {
 704             reportError(e);
 705             throw e;
 706           }
 707         finally {
 708         }
 709         return retval;
 710     }
 711
 712     public static class multExpr_return extends ParserRuleReturnScope {
 713         CommonTree tree;
 714         public Object getTree() { return tree; }
 715     };
 716
 717     public final ExpressionParser.multExpr_return multExpr() throws RecognitionException {
 718         ExpressionParser.multExpr_return retval = new ExpressionParser.multExpr_return();
 719         retval.start = input.LT(1);
 720
 721         CommonTree root_0 = null;
 722
 723         ExpressionParser.unary_return unary23 = null;
 724
 725         ExpressionParser.multOp_return multOp24 = null;
 726
 727         ExpressionParser.unary_return unary25 = null;
 728
 729         try {
 730             {
 731             root_0 = (CommonTree)adaptor.nil();
 732
 733             pushFollow(FOLLOW_unary_in_multExpr294);
 734             unary23=unary();
 735
 736             state._fsp--;
 737
 738             adaptor.addChild(root_0, unary23.getTree());
 739             loop7:
 740             do {
 741                 int alt7=2;
 742                 int LA7_0 = input.LA(1);
 743
 744                 if ( ((LA7_0>=TIMES && LA7_0<=DIV)) ) {
 745                     alt7=1;
 746                 }
 747
 748                 switch (alt7) {
 749                 case 1 :
 750                     {
 751                     pushFollow(FOLLOW_multOp_in_multExpr297);
 752                     multOp24=multOp();
 753
 754                     state._fsp--;
 755
 756                     root_0 = (CommonTree)adaptor.becomeRoot(multOp24.getTree(), root_0);
 757                     pushFollow(FOLLOW_unary_in_multExpr300);
 758                     unary25=unary();
 759
 760                     state._fsp--;
 761
 762                     adaptor.addChild(root_0, unary25.getTree());
 763
 764                     }
 765                     break;
 766
 767                 default :
 768                     break loop7;
 769                 }
 770             } while (true);
 771
 772             }
 773
 774             retval.stop = input.LT(-1);
 775
 776             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 777             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 778
 779         }
 780
 781           catch (RecognitionException e) {
 782             reportError(e);
 783             throw e;
 784           }
 785         finally {
 786         }
 787         return retval;
 788     }
 789
 790     public static class multOp_return extends ParserRuleReturnScope {
 791         CommonTree tree;
 792         public Object getTree() { return tree; }
 793     };
 794
 795     public final ExpressionParser.multOp_return multOp() throws RecognitionException {
 796         ExpressionParser.multOp_return retval = new ExpressionParser.multOp_return();
 797         retval.start = input.LT(1);
 798
 799         CommonTree root_0 = null;
 800
 801         Token set26=null;
 802
 803         CommonTree set26_tree=null;
 804
 805         try {
 806             {
 807             root_0 = (CommonTree)adaptor.nil();
 808
 809             set26=(Token)input.LT(1);
 810             if ( (input.LA(1)>=TIMES && input.LA(1)<=DIV) ) {
 811                 input.consume();
 812                 adaptor.addChild(root_0, (CommonTree)adaptor.create(set26));
 813                 state.errorRecovery=false;
 814             }
 815             else {
 816                 MismatchedSetException mse = new MismatchedSetException(null,input);
 817                 throw mse;
 818             }
 819
 820             }
 821
 822             retval.stop = input.LT(-1);
 823
 824             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 825             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 826
 827         }
 828
 829           catch (RecognitionException e) {
 830             reportError(e);
 831             throw e;
 832           }
 833         finally {
 834         }
 835         return retval;
 836     }
 837
 838     public static class unary_return extends ParserRuleReturnScope {
 839         CommonTree tree;
 840         public Object getTree() { return tree; }
 841     };
 842
 843     public final ExpressionParser.unary_return unary() throws RecognitionException {
 844         ExpressionParser.unary_return retval = new ExpressionParser.unary_return();
 845         retval.start = input.LT(1);
 846
 847         CommonTree root_0 = null;
 848
 849         Token MINUS27=null;
 850         ExpressionParser.atom_return atom28 = null;
 851
 852         ExpressionParser.atom_return atom29 = null;
 853
 854         CommonTree MINUS27_tree=null;
 855         RewriteRuleTokenStream stream_MINUS=new RewriteRuleTokenStream(adaptor,"token MINUS");
 856         RewriteRuleSubtreeStream stream_atom=new RewriteRuleSubtreeStream(adaptor,"rule atom");
 857         try {
 858             int alt8=2;
 859             int LA8_0 = input.LA(1);
 860
 861             if ( (LA8_0==MINUS) ) {
 862                 alt8=1;
 863             }
 864             else if ( (LA8_0==LPAREN||LA8_0==INT||(LA8_0>=NAME && LA8_0<=PHRASE)||(LA8_0>=ABS && LA8_0<=SWITCH)) ) {
 865                 alt8=2;
 866             }
 867             else {
 868                 NoViableAltException nvae =
 869                     new NoViableAltException("", 8, 0, input);
 870
 871                 throw nvae;
 872             }
 873             switch (alt8) {
 874                 case 1 :
 875                     {
 876                     MINUS27=(Token)match(input,MINUS,FOLLOW_MINUS_in_unary334);
 877                     stream_MINUS.add(MINUS27);
 878
 879                     pushFollow(FOLLOW_atom_in_unary336);
 880                     atom28=atom();
 881
 882                     state._fsp--;
 883
 884                     stream_atom.add(atom28.getTree());
 885
 886                     retval.tree = root_0;
 887                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 888
 889                     root_0 = (CommonTree)adaptor.nil();
 890                     {
 891                         {
 892                         CommonTree root_1 = (CommonTree)adaptor.nil();
 893                         root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(NEG, "-"), root_1);
 894
 895                         adaptor.addChild(root_1, stream_atom.nextTree());
 896
 897                         adaptor.addChild(root_0, root_1);
 898                         }
 899
 900                     }
 901
 902                     retval.tree = root_0;
 903                     }
 904                     break;
 905                 case 2 :
 906                     {
 907                     root_0 = (CommonTree)adaptor.nil();
 908
 909                     pushFollow(FOLLOW_atom_in_unary351);
 910                     atom29=atom();
 911
 912                     state._fsp--;
 913
 914                     adaptor.addChild(root_0, atom29.getTree());
 915
 916                     }
 917                     break;
 918
 919             }
 920             retval.stop = input.LT(-1);
 921
 922             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 923             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 924
 925         }
 926
 927           catch (RecognitionException e) {
 928             reportError(e);
 929             throw e;
 930           }
 931         finally {
 932         }
 933         return retval;
 934     }
 935
 936     public static class atom_return extends ParserRuleReturnScope {
 937         CommonTree tree;
 938         public Object getTree() { return tree; }
 939     };
 940
 941     public final ExpressionParser.atom_return atom() throws RecognitionException {
 942         ExpressionParser.atom_return retval = new ExpressionParser.atom_return();
 943         retval.start = input.LT(1);
 944
 945         CommonTree root_0 = null;
 946
 947         Token LPAREN34=null;
 948         Token RPAREN36=null;
 949         ExpressionParser.var_return var30 = null;
 950
 951         ExpressionParser.num_return num31 = null;
 952
 953         ExpressionParser.str_return str32 = null;
 954
 955         ExpressionParser.fn_return fn33 = null;
 956
 957         ExpressionParser.conjunction_return conjunction35 = null;
 958
 959         CommonTree LPAREN34_tree=null;
 960         CommonTree RPAREN36_tree=null;
 961         RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
 962         RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
 963         RewriteRuleSubtreeStream stream_conjunction=new RewriteRuleSubtreeStream(adaptor,"rule conjunction");
 964         try {
 965             int alt9=5;
 966             alt9 = dfa9.predict(input);
 967             switch (alt9) {
 968                 case 1 :
 969                     {
 970                     root_0 = (CommonTree)adaptor.nil();
 971
 972                     pushFollow(FOLLOW_var_in_atom364);
 973                     var30=var();
 974
 975                     state._fsp--;
 976
 977                     adaptor.addChild(root_0, var30.getTree());
 978
 979                     }
 980                     break;
 981                 case 2 :
 982                     {
 983                     root_0 = (CommonTree)adaptor.nil();
 984
 985                     pushFollow(FOLLOW_num_in_atom370);
 986                     num31=num();
 987
 988                     state._fsp--;
 989
 990                     adaptor.addChild(root_0, num31.getTree());
 991
 992                     }
 993                     break;
 994                 case 3 :
 995                     {
 996                     root_0 = (CommonTree)adaptor.nil();
 997
 998                     pushFollow(FOLLOW_str_in_atom376);
 999                     str32=str();
1000
1001                     state._fsp--;
1002
1003                     adaptor.addChild(root_0, str32.getTree());
1004
1005                     }
1006                     break;
1007                 case 4 :
1008                     {
1009                     root_0 = (CommonTree)adaptor.nil();
1010
1011                     pushFollow(FOLLOW_fn_in_atom382);
1012                     fn33=fn();
1013
1014                     state._fsp--;
1015
1016                     adaptor.addChild(root_0, fn33.getTree());
1017
1018                     }
1019                     break;
1020                 case 5 :
1021                     {
1022                     LPAREN34=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_atom388);
1023                     stream_LPAREN.add(LPAREN34);
1024
1025                     pushFollow(FOLLOW_conjunction_in_atom390);
1026                     conjunction35=conjunction();
1027
1028                     state._fsp--;
1029
1030                     stream_conjunction.add(conjunction35.getTree());
1031                     RPAREN36=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_atom392);
1032                     stream_RPAREN.add(RPAREN36);
1033
1034                     retval.tree = root_0;
1035                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
1036
1037                     root_0 = (CommonTree)adaptor.nil();
1038                     {
1039                         adaptor.addChild(root_0, stream_conjunction.nextTree());
1040
1041                     }
1042
1043                     retval.tree = root_0;
1044                     }
1045                     break;
1046
1047             }
1048             retval.stop = input.LT(-1);
1049
1050             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1051             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1052
1053         }
1054
1055           catch (RecognitionException e) {
1056             reportError(e);
1057             throw e;
1058           }
1059         finally {
1060         }
1061         return retval;
1062     }
1063
1064     public static class var_return extends ParserRuleReturnScope {
1065         CommonTree tree;
1066         public Object getTree() { return tree; }
1067     };
1068
1069     public final ExpressionParser.var_return var() throws RecognitionException {
1070         ExpressionParser.var_return retval = new ExpressionParser.var_return();
1071         retval.start = input.LT(1);
1072
1073         CommonTree root_0 = null;
1074
1075         ExpressionParser.name_return name37 = null;
1076
1077         ExpressionParser.name_return name38 = null;
1078
1079         ExpressionParser.index_return index39 = null;
1080
1081         RewriteRuleSubtreeStream stream_name=new RewriteRuleSubtreeStream(adaptor,"rule name");
1082         RewriteRuleSubtreeStream stream_index=new RewriteRuleSubtreeStream(adaptor,"rule index");
1083         try {
1084             int alt10=2;
1085             alt10 = dfa10.predict(input);
1086             switch (alt10) {
1087                 case 1 :
1088                     {
1089                     root_0 = (CommonTree)adaptor.nil();
1090
1091                     pushFollow(FOLLOW_name_in_var409);
1092                     name37=name();
1093
1094                     state._fsp--;
1095
1096                     adaptor.addChild(root_0, name37.getTree());
1097
1098                     }
1099                     break;
1100                 case 2 :
1101                     {
1102                     pushFollow(FOLLOW_name_in_var415);
1103                     name38=name();
1104
1105                     state._fsp--;
1106
1107                     stream_name.add(name38.getTree());
1108                     pushFollow(FOLLOW_index_in_var417);
1109                     index39=index();
1110
1111                     state._fsp--;
1112
1113                     stream_index.add(index39.getTree());
1114
1115                     retval.tree = root_0;
1116                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
1117
1118                     root_0 = (CommonTree)adaptor.nil();
1119                     {
1120                         {
1121                         CommonTree root_1 = (CommonTree)adaptor.nil();
1122                         root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(INDEX, (index39!=null?input.toString(index39.start,index39.stop):null)), root_1);
1123
1124                         adaptor.addChild(root_1, stream_name.nextTree());
1125
1126                         adaptor.addChild(root_0, root_1);
1127                         }
1128
1129                     }
1130
1131                     retval.tree = root_0;
1132                     }
1133                     break;
1134
1135             }
1136             retval.stop = input.LT(-1);
1137
1138             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1139             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1140
1141         }
1142
1143           catch (RecognitionException e) {
1144             reportError(e);
1145             throw e;
1146           }
1147         finally {
1148         }
1149         return retval;
1150     }
1151
1152     public static class index_return extends ParserRuleReturnScope {
1153         CommonTree tree;
1154         public Object getTree() { return tree; }
1155     };
1156
1157     public final ExpressionParser.index_return index() throws RecognitionException {
1158         ExpressionParser.index_return retval = new ExpressionParser.index_return();
1159         retval.start = input.LT(1);
1160
1161         CommonTree root_0 = null;
1162
1163         Token x=null;
1164         Token LSQUARE40=null;
1165         Token RSQUARE41=null;
1166
1167         CommonTree x_tree=null;
1168         CommonTree LSQUARE40_tree=null;
1169         CommonTree RSQUARE41_tree=null;
1170         RewriteRuleTokenStream stream_LSQUARE=new RewriteRuleTokenStream(adaptor,"token LSQUARE");
1171         RewriteRuleTokenStream stream_RSQUARE=new RewriteRuleTokenStream(adaptor,"token RSQUARE");
1172         RewriteRuleTokenStream stream_INT=new RewriteRuleTokenStream(adaptor,"token INT");
1173
1174         try {
1175             {
1176             LSQUARE40=(Token)match(input,LSQUARE,FOLLOW_LSQUARE_in_index439);
1177             stream_LSQUARE.add(LSQUARE40);
1178
1179             x=(Token)match(input,INT,FOLLOW_INT_in_index443);
1180             stream_INT.add(x);
1181
1182             RSQUARE41=(Token)match(input,RSQUARE,FOLLOW_RSQUARE_in_index445);
1183             stream_RSQUARE.add(RSQUARE41);
1184
1185             retval.tree = root_0;
1186             RewriteRuleTokenStream stream_x=new RewriteRuleTokenStream(adaptor,"token x",x);
1187             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
1188
1189             root_0 = (CommonTree)adaptor.nil();
1190             {
1191                 adaptor.addChild(root_0, stream_x.nextNode());
1192
1193             }
1194
1195             retval.tree = root_0;
1196             }
1197
1198             retval.stop = input.LT(-1);
1199
1200             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1201             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1202
1203         }
1204
1205           catch (RecognitionException e) {
1206             reportError(e);
1207             throw e;
1208           }
1209         finally {
1210         }
1211         return retval;
1212     }
1213
1214     public static class name_return extends ParserRuleReturnScope {
1215         CommonTree tree;
1216         public Object getTree() { return tree; }
1217     };
1218
1219     public final ExpressionParser.name_return name() throws RecognitionException {
1220         ExpressionParser.name_return retval = new ExpressionParser.name_return();
1221         retval.start = input.LT(1);
1222
1223         CommonTree root_0 = null;
1224
1225         Token t=null;
1226         Token NAME42=null;
1227         Token char_literal43=null;
1228         Token NAME44=null;
1229
1230         CommonTree t_tree=null;
1231         CommonTree NAME42_tree=null;
1232         CommonTree char_literal43_tree=null;
1233         CommonTree NAME44_tree=null;
1234         RewriteRuleTokenStream stream_GEO=new RewriteRuleTokenStream(adaptor,"token GEO");
1235         RewriteRuleTokenStream stream_DATE=new RewriteRuleTokenStream(adaptor,"token DATE");
1236         RewriteRuleTokenStream stream_NUMBER=new RewriteRuleTokenStream(adaptor,"token NUMBER");
1237         RewriteRuleTokenStream stream_GEOPOINT=new RewriteRuleTokenStream(adaptor,"token GEOPOINT");
1238         RewriteRuleTokenStream stream_TEXT=new RewriteRuleTokenStream(adaptor,"token TEXT");
1239         RewriteRuleTokenStream stream_HTML=new RewriteRuleTokenStream(adaptor,"token HTML");
1240         RewriteRuleTokenStream stream_ATOM=new RewriteRuleTokenStream(adaptor,"token ATOM");
1241
1242         try {
1243             int alt12=8;
1244             switch ( input.LA(1) ) {
1245             case NAME:
1246                 {
1247                 alt12=1;
1248                 }
1249                 break;
1250             case TEXT:
1251                 {
1252                 alt12=2;
1253                 }
1254                 break;
1255             case HTML:
1256                 {
1257                 alt12=3;
1258                 }
1259                 break;
1260             case ATOM:
1261                 {
1262                 alt12=4;
1263                 }
1264                 break;
1265             case DATE:
1266                 {
1267                 alt12=5;
1268                 }
1269                 break;
1270             case NUMBER:
1271                 {
1272                 alt12=6;
1273                 }
1274                 break;
1275             case GEO:
1276                 {
1277                 alt12=7;
1278                 }
1279                 break;
1280             case GEOPOINT:
1281                 {
1282                 alt12=8;
1283                 }
1284                 break;
1285             default:
1286                 NoViableAltException nvae =
1287                     new NoViableAltException("", 12, 0, input);
1288
1289                 throw nvae;
1290             }
1291
1292             switch (alt12) {
1293                 case 1 :
1294                     {
1295                     root_0 = (CommonTree)adaptor.nil();
1296
1297                     NAME42=(Token)match(input,NAME,FOLLOW_NAME_in_name463);
1298                     NAME42_tree = (CommonTree)adaptor.create(NAME42);
1299                     adaptor.addChild(root_0, NAME42_tree);
1300
1301                     loop11:
1302                     do {
1303                         int alt11=2;
1304                         int LA11_0 = input.LA(1);
1305
1306                         if ( (LA11_0==58) ) {
1307                             alt11=1;
1308                         }
1309
1310                         switch (alt11) {
1311                         case 1 :
1312                             {
1313                             char_literal43=(Token)match(input,58,FOLLOW_58_in_name466);
1314                             char_literal43_tree = (CommonTree)adaptor.create(char_literal43);
1315                             root_0 = (CommonTree)adaptor.becomeRoot(char_literal43_tree, root_0);
1316
1317                             NAME44=(Token)match(input,NAME,FOLLOW_NAME_in_name469);
1318                             NAME44_tree = (CommonTree)adaptor.create(NAME44);
1319                             adaptor.addChild(root_0, NAME44_tree);
1320
1321                             }
1322                             break;
1323
1324                         default :
1325                             break loop11;
1326                         }
1327                     } while (true);
1328
1329                     }
1330                     break;
1331                 case 2 :
1332                     {
1333                     t=(Token)match(input,TEXT,FOLLOW_TEXT_in_name485);
1334                     stream_TEXT.add(t);
1335
1336                     retval.tree = root_0;
1337                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
1338
1339                     root_0 = (CommonTree)adaptor.nil();
1340                     {
1341                         adaptor.addChild(root_0, (CommonTree)adaptor.create(NAME, t));
1342
1343                     }
1344
1345                     retval.tree = root_0;
1346                     }
1347                     break;
1348                 case 3 :
1349                     {
1350                     t=(Token)match(input,HTML,FOLLOW_HTML_in_name498);
1351                     stream_HTML.add(t);
1352
1353                     retval.tree = root_0;
1354                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
1355
1356                     root_0 = (CommonTree)adaptor.nil();
1357                     {
1358                         adaptor.addChild(root_0, (CommonTree)adaptor.create(NAME, t));
1359
1360                     }
1361
1362                     retval.tree = root_0;
1363                     }
1364                     break;
1365                 case 4 :
1366                     {
1367                     t=(Token)match(input,ATOM,FOLLOW_ATOM_in_name511);
1368                     stream_ATOM.add(t);
1369
1370                     retval.tree = root_0;
1371                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
1372
1373                     root_0 = (CommonTree)adaptor.nil();
1374                     {
1375                         adaptor.addChild(root_0, (CommonTree)adaptor.create(NAME, t));
1376
1377                     }
1378
1379                     retval.tree = root_0;
1380                     }
1381                     break;
1382                 case 5 :
1383                     {
1384                     t=(Token)match(input,DATE,FOLLOW_DATE_in_name524);
1385                     stream_DATE.add(t);
1386
1387                     retval.tree = root_0;
1388                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
1389
1390                     root_0 = (CommonTree)adaptor.nil();
1391                     {
1392                         adaptor.addChild(root_0, (CommonTree)adaptor.create(NAME, t));
1393
1394                     }
1395
1396                     retval.tree = root_0;
1397                     }
1398                     break;
1399                 case 6 :
1400                     {
1401                     t=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_name537);
1402                     stream_NUMBER.add(t);
1403
1404                     retval.tree = root_0;
1405                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
1406
1407                     root_0 = (CommonTree)adaptor.nil();
1408                     {
1409                         adaptor.addChild(root_0, (CommonTree)adaptor.create(NAME, t));
1410
1411                     }
1412
1413                     retval.tree = root_0;
1414                     }
1415                     break;
1416                 case 7 :
1417                     {
1418                     t=(Token)match(input,GEO,FOLLOW_GEO_in_name550);
1419                     stream_GEO.add(t);
1420
1421                     retval.tree = root_0;
1422                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
1423
1424                     root_0 = (CommonTree)adaptor.nil();
1425                     {
1426                         adaptor.addChild(root_0, (CommonTree)adaptor.create(NAME, t));
1427
1428                     }
1429
1430                     retval.tree = root_0;
1431                     }
1432                     break;
1433                 case 8 :
1434                     {
1435                     t=(Token)match(input,GEOPOINT,FOLLOW_GEOPOINT_in_name563);
1436                     stream_GEOPOINT.add(t);
1437
1438                     retval.tree = root_0;
1439                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
1440
1441                     root_0 = (CommonTree)adaptor.nil();
1442                     {
1443                         adaptor.addChild(root_0, (CommonTree)adaptor.create(NAME, t));
1444
1445                     }
1446
1447                     retval.tree = root_0;
1448                     }
1449                     break;
1450
1451             }
1452             retval.stop = input.LT(-1);
1453
1454             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1455             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1456
1457         }
1458
1459           catch (RecognitionException e) {
1460             reportError(e);
1461             throw e;
1462           }
1463         finally {
1464         }
1465         return retval;
1466     }
1467
1468     public static class num_return extends ParserRuleReturnScope {
1469         CommonTree tree;
1470         public Object getTree() { return tree; }
1471     };
1472
1473     public final ExpressionParser.num_return num() throws RecognitionException {
1474         ExpressionParser.num_return retval = new ExpressionParser.num_return();
1475         retval.start = input.LT(1);
1476
1477         CommonTree root_0 = null;
1478
1479         Token set45=null;
1480
1481         CommonTree set45_tree=null;
1482
1483         try {
1484             {
1485             root_0 = (CommonTree)adaptor.nil();
1486
1487             set45=(Token)input.LT(1);
1488             if ( input.LA(1)==INT||input.LA(1)==FLOAT ) {
1489                 input.consume();
1490                 adaptor.addChild(root_0, (CommonTree)adaptor.create(set45));
1491                 state.errorRecovery=false;
1492             }
1493             else {
1494                 MismatchedSetException mse = new MismatchedSetException(null,input);
1495                 throw mse;
1496             }
1497
1498             }
1499
1500             retval.stop = input.LT(-1);
1501
1502             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1503             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1504
1505         }
1506
1507           catch (RecognitionException e) {
1508             reportError(e);
1509             throw e;
1510           }
1511         finally {
1512         }
1513         return retval;
1514     }
1515
1516     public static class str_return extends ParserRuleReturnScope {
1517         CommonTree tree;
1518         public Object getTree() { return tree; }
1519     };
1520
1521     public final ExpressionParser.str_return str() throws RecognitionException {
1522         ExpressionParser.str_return retval = new ExpressionParser.str_return();
1523         retval.start = input.LT(1);
1524
1525         CommonTree root_0 = null;
1526
1527         Token PHRASE46=null;
1528
1529         CommonTree PHRASE46_tree=null;
1530
1531         try {
1532             {
1533             root_0 = (CommonTree)adaptor.nil();
1534
1535             PHRASE46=(Token)match(input,PHRASE,FOLLOW_PHRASE_in_str600);
1536             PHRASE46_tree = (CommonTree)adaptor.create(PHRASE46);
1537             adaptor.addChild(root_0, PHRASE46_tree);
1538
1539             }
1540
1541             retval.stop = input.LT(-1);
1542
1543             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1544             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1545
1546         }
1547
1548           catch (RecognitionException e) {
1549             reportError(e);
1550             throw e;
1551           }
1552         finally {
1553         }
1554         return retval;
1555     }
1556
1557     public static class fn_return extends ParserRuleReturnScope {
1558         CommonTree tree;
1559         public Object getTree() { return tree; }
1560     };
1561
1562     public final ExpressionParser.fn_return fn() throws RecognitionException {
1563         ExpressionParser.fn_return retval = new ExpressionParser.fn_return();
1564         retval.start = input.LT(1);
1565
1566         CommonTree root_0 = null;
1567
1568         Token LPAREN48=null;
1569         Token COMMA50=null;
1570         Token RPAREN52=null;
1571         ExpressionParser.fnName_return fnName47 = null;
1572
1573         ExpressionParser.condExpr_return condExpr49 = null;
1574
1575         ExpressionParser.condExpr_return condExpr51 = null;
1576
1577         CommonTree LPAREN48_tree=null;
1578         CommonTree COMMA50_tree=null;
1579         CommonTree RPAREN52_tree=null;
1580         RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
1581         RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
1582         RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
1583         RewriteRuleSubtreeStream stream_fnName=new RewriteRuleSubtreeStream(adaptor,"rule fnName");
1584         RewriteRuleSubtreeStream stream_condExpr=new RewriteRuleSubtreeStream(adaptor,"rule condExpr");
1585         try {
1586             {
1587             pushFollow(FOLLOW_fnName_in_fn613);
1588             fnName47=fnName();
1589
1590             state._fsp--;
1591
1592             stream_fnName.add(fnName47.getTree());
1593             LPAREN48=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_fn615);
1594             stream_LPAREN.add(LPAREN48);
1595
1596             pushFollow(FOLLOW_condExpr_in_fn617);
1597             condExpr49=condExpr();
1598
1599             state._fsp--;
1600
1601             stream_condExpr.add(condExpr49.getTree());
1602             loop13:
1603             do {
1604                 int alt13=2;
1605                 int LA13_0 = input.LA(1);
1606
1607                 if ( (LA13_0==COMMA) ) {
1608                     alt13=1;
1609                 }
1610
1611                 switch (alt13) {
1612                 case 1 :
1613                     {
1614                     COMMA50=(Token)match(input,COMMA,FOLLOW_COMMA_in_fn620);
1615                     stream_COMMA.add(COMMA50);
1616
1617                     pushFollow(FOLLOW_condExpr_in_fn622);
1618                     condExpr51=condExpr();
1619
1620                     state._fsp--;
1621
1622                     stream_condExpr.add(condExpr51.getTree());
1623
1624                     }
1625                     break;
1626
1627                 default :
1628                     break loop13;
1629                 }
1630             } while (true);
1631
1632             RPAREN52=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_fn626);
1633             stream_RPAREN.add(RPAREN52);
1634
1635             retval.tree = root_0;
1636             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
1637
1638             root_0 = (CommonTree)adaptor.nil();
1639             {
1640                 {
1641                 CommonTree root_1 = (CommonTree)adaptor.nil();
1642                 root_1 = (CommonTree)adaptor.becomeRoot(stream_fnName.nextNode(), root_1);
1643
1644                 if ( !(stream_condExpr.hasNext()) ) {
1645                     throw new RewriteEarlyExitException();
1646                 }
1647                 while ( stream_condExpr.hasNext() ) {
1648                     adaptor.addChild(root_1, stream_condExpr.nextTree());
1649
1650                 }
1651                 stream_condExpr.reset();
1652
1653                 adaptor.addChild(root_0, root_1);
1654                 }
1655
1656             }
1657
1658             retval.tree = root_0;
1659             }
1660
1661             retval.stop = input.LT(-1);
1662
1663             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1664             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1665
1666         }
1667
1668           catch (RecognitionException e) {
1669             reportError(e);
1670             throw e;
1671           }
1672         finally {
1673         }
1674         return retval;
1675     }
1676
1677     public static class fnName_return extends ParserRuleReturnScope {
1678         CommonTree tree;
1679         public Object getTree() { return tree; }
1680     };
1681
1682     public final ExpressionParser.fnName_return fnName() throws RecognitionException {
1683         ExpressionParser.fnName_return retval = new ExpressionParser.fnName_return();
1684         retval.start = input.LT(1);
1685
1686         CommonTree root_0 = null;
1687
1688         Token set53=null;
1689
1690         CommonTree set53_tree=null;
1691
1692         try {
1693             {
1694             root_0 = (CommonTree)adaptor.nil();
1695
1696             set53=(Token)input.LT(1);
1697             if ( (input.LA(1)>=TEXT && input.LA(1)<=GEOPOINT)||(input.LA(1)>=ABS && input.LA(1)<=SWITCH) ) {
1698                 input.consume();
1699                 adaptor.addChild(root_0, (CommonTree)adaptor.create(set53));
1700                 state.errorRecovery=false;
1701             }
1702             else {
1703                 MismatchedSetException mse = new MismatchedSetException(null,input);
1704                 throw mse;
1705             }
1706
1707             }
1708
1709             retval.stop = input.LT(-1);
1710
1711             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1712             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1713
1714         }
1715
1716           catch (RecognitionException e) {
1717             reportError(e);
1718             throw e;
1719           }
1720         finally {
1721         }
1722         return retval;
1723     }
1724
1725     protected DFA9 dfa9 = new DFA9(this);
1726     protected DFA10 dfa10 = new DFA10(this);
1727     static final String DFA9_eotS =
1728         "\15\uffff";
1729     static final String DFA9_eofS =
1730         "\2\uffff\7\1\4\uffff";
1731     static final String DFA9_minS =
1732         "\1\25\1\uffff\7\6\4\uffff";
1733     static final String DFA9_maxS =
1734         "\1\55\1\uffff\7\44\4\uffff";
1735     static final String DFA9_acceptS =
1736         "\1\uffff\1\1\7\uffff\1\2\1\3\1\4\1\5";
1737     static final String DFA9_specialS =
1738         "\15\uffff}>";
1739     static final String[] DFA9_transitionS = {
1740             "\1\14\2\uffff\1\11\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10"+
1741             "\1\11\1\12\1\uffff\11\13",
1742             "",
1743             "\4\1\1\uffff\12\1\1\13\2\1\14\uffff\1\1",
1744             "\4\1\1\uffff\12\1\1\13\2\1\14\uffff\1\1",
1745             "\4\1\1\uffff\12\1\1\13\2\1\14\uffff\1\1",
1746             "\4\1\1\uffff\12\1\1\13\2\1\14\uffff\1\1",
1747             "\4\1\1\uffff\12\1\1\13\2\1\14\uffff\1\1",
1748             "\4\1\1\uffff\12\1\1\13\2\1\14\uffff\1\1",
1749             "\4\1\1\uffff\12\1\1\13\2\1\14\uffff\1\1",
1750             "",
1751             "",
1752             "",
1753             ""
1754     };
1755
1756     static final short[] DFA9_eot = DFA.unpackEncodedString(DFA9_eotS);
1757     static final short[] DFA9_eof = DFA.unpackEncodedString(DFA9_eofS);
1758     static final char[] DFA9_min = DFA.unpackEncodedStringToUnsignedChars(DFA9_minS);
1759     static final char[] DFA9_max = DFA.unpackEncodedStringToUnsignedChars(DFA9_maxS);
1760     static final short[] DFA9_accept = DFA.unpackEncodedString(DFA9_acceptS);
1761     static final short[] DFA9_special = DFA.unpackEncodedString(DFA9_specialS);
1762     static final short[][] DFA9_transition;
1763
1764     static {
1765         int numStates = DFA9_transitionS.length;
1766         DFA9_transition = new short[numStates][];
1767         for (int i=0; i<numStates; i++) {
1768             DFA9_transition[i] = DFA.unpackEncodedString(DFA9_transitionS[i]);
1769         }
1770     }
1771
1772     class DFA9 extends DFA {
1773
1774         public DFA9(BaseRecognizer recognizer) {
1775             this.recognizer = recognizer;
1776             this.decisionNumber = 9;
1777             this.eot = DFA9_eot;
1778             this.eof = DFA9_eof;
1779             this.min = DFA9_min;
1780             this.max = DFA9_max;
1781             this.accept = DFA9_accept;
1782             this.special = DFA9_special;
1783             this.transition = DFA9_transition;
1784         }
1785         public String getDescription() {
1786             return "110:1: atom : ( var | num | str | fn | LPAREN conjunction RPAREN -> conjunction );";
1787         }
1788     }
1789     static final String DFA10_eotS =
1790         "\15\uffff";
1791     static final String DFA10_eofS =
1792         "\1\uffff\10\12\3\uffff\1\12";
1793     static final String DFA10_minS =
1794         "\1\32\10\6\1\32\2\uffff\1\6";
1795     static final String DFA10_maxS =
1796         "\1\41\1\72\7\44\1\32\2\uffff\1\72";
1797     static final String DFA10_acceptS =
1798         "\12\uffff\1\1\1\2\1\uffff";
1799     static final String DFA10_specialS =
1800         "\15\uffff}>";
1801     static final String[] DFA10_transitionS = {
1802             "\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10",
1803             "\4\12\1\uffff\12\12\1\uffff\1\12\1\13\14\uffff\1\12\25\uffff"+
1804             "\1\11",
1805             "\4\12\1\uffff\12\12\1\uffff\1\12\1\13\14\uffff\1\12",
1806             "\4\12\1\uffff\12\12\1\uffff\1\12\1\13\14\uffff\1\12",
1807             "\4\12\1\uffff\12\12\1\uffff\1\12\1\13\14\uffff\1\12",
1808             "\4\12\1\uffff\12\12\1\uffff\1\12\1\13\14\uffff\1\12",
1809             "\4\12\1\uffff\12\12\1\uffff\1\12\1\13\14\uffff\1\12",
1810             "\4\12\1\uffff\12\12\1\uffff\1\12\1\13\14\uffff\1\12",
1811             "\4\12\1\uffff\12\12\1\uffff\1\12\1\13\14\uffff\1\12",
1812             "\1\14",
1813             "",
1814             "",
1815             "\4\12\1\uffff\12\12\1\uffff\1\12\1\13\14\uffff\1\12\25\uffff"+
1816             "\1\11"
1817     };
1818
1819     static final short[] DFA10_eot = DFA.unpackEncodedString(DFA10_eotS);
1820     static final short[] DFA10_eof = DFA.unpackEncodedString(DFA10_eofS);
1821     static final char[] DFA10_min = DFA.unpackEncodedStringToUnsignedChars(DFA10_minS);
1822     static final char[] DFA10_max = DFA.unpackEncodedStringToUnsignedChars(DFA10_maxS);
1823     static final short[] DFA10_accept = DFA.unpackEncodedString(DFA10_acceptS);
1824     static final short[] DFA10_special = DFA.unpackEncodedString(DFA10_specialS);
1825     static final short[][] DFA10_transition;
1826
1827     static {
1828         int numStates = DFA10_transitionS.length;
1829         DFA10_transition = new short[numStates][];
1830         for (int i=0; i<numStates; i++) {
1831             DFA10_transition[i] = DFA.unpackEncodedString(DFA10_transitionS[i]);
1832         }
1833     }
1834
1835     class DFA10 extends DFA {
1836
1837         public DFA10(BaseRecognizer recognizer) {
1838             this.recognizer = recognizer;
1839             this.decisionNumber = 10;
1840             this.eot = DFA10_eot;
1841             this.eof = DFA10_eof;
1842             this.min = DFA10_min;
1843             this.max = DFA10_max;
1844             this.accept = DFA10_accept;
1845             this.special = DFA10_special;
1846             this.transition = DFA10_transition;
1847         }
1848         public String getDescription() {
1849             return "118:1: var : ( name | name index -> ^( INDEX[$index.text] name ) );";
1850         }
1851     }
1852
1853     public static final BitSet FOLLOW_conjunction_in_expression84 = new BitSet(new long[]{0x0000000000000000L});
1854     public static final BitSet FOLLOW_EOF_in_expression86 = new BitSet(new long[]{0x0000000000000002L});
1855     public static final BitSet FOLLOW_conjunction_in_condExpr99 = new BitSet(new long[]{0x0000000000000042L});
1856     public static final BitSet FOLLOW_COND_in_condExpr102 = new BitSet(new long[]{0x00003FEFFD240000L});
1857     public static final BitSet FOLLOW_addExpr_in_condExpr105 = new BitSet(new long[]{0x0000000000000002L});
1858     public static final BitSet FOLLOW_disjunction_in_conjunction120 = new BitSet(new long[]{0x0000000000000082L});
1859     public static final BitSet FOLLOW_AND_in_conjunction123 = new BitSet(new long[]{0x00003FEFFD240400L});
1860     public static final BitSet FOLLOW_disjunction_in_conjunction126 = new BitSet(new long[]{0x0000000000000082L});
1861     public static final BitSet FOLLOW_negation_in_disjunction141 = new BitSet(new long[]{0x0000000000000302L});
1862     public static final BitSet FOLLOW_set_in_disjunction144 = new BitSet(new long[]{0x00003FEFFD240400L});
1863     public static final BitSet FOLLOW_negation_in_disjunction153 = new BitSet(new long[]{0x0000000000000302L});
1864     public static final BitSet FOLLOW_cmpExpr_in_negation168 = new BitSet(new long[]{0x0000000000000002L});
1865     public static final BitSet FOLLOW_NOT_in_negation174 = new BitSet(new long[]{0x00003FEFFD240000L});
1866     public static final BitSet FOLLOW_cmpExpr_in_negation177 = new BitSet(new long[]{0x0000000000000002L});
1867     public static final BitSet FOLLOW_addExpr_in_cmpExpr190 = new BitSet(new long[]{0x000000000001F802L});
1868     public static final BitSet FOLLOW_cmpOp_in_cmpExpr193 = new BitSet(new long[]{0x00003FEFFD240000L});
1869     public static final BitSet FOLLOW_addExpr_in_cmpExpr196 = new BitSet(new long[]{0x0000000000000002L});
1870     public static final BitSet FOLLOW_set_in_cmpOp0 = new BitSet(new long[]{0x0000000000000002L});
1871     public static final BitSet FOLLOW_multExpr_in_addExpr254 = new BitSet(new long[]{0x0000000000060002L});
1872     public static final BitSet FOLLOW_addOp_in_addExpr257 = new BitSet(new long[]{0x00003FEFFD240000L});
1873     public static final BitSet FOLLOW_multExpr_in_addExpr260 = new BitSet(new long[]{0x0000000000060002L});
1874     public static final BitSet FOLLOW_set_in_addOp0 = new BitSet(new long[]{0x0000000000000002L});
1875     public static final BitSet FOLLOW_unary_in_multExpr294 = new BitSet(new long[]{0x0000000000180002L});
1876     public static final BitSet FOLLOW_multOp_in_multExpr297 = new BitSet(new long[]{0x00003FEFFD240000L});
1877     public static final BitSet FOLLOW_unary_in_multExpr300 = new BitSet(new long[]{0x0000000000180002L});
1878     public static final BitSet FOLLOW_set_in_multOp0 = new BitSet(new long[]{0x0000000000000002L});
1879     public static final BitSet FOLLOW_MINUS_in_unary334 = new BitSet(new long[]{0x00003FEFFD240000L});
1880     public static final BitSet FOLLOW_atom_in_unary336 = new BitSet(new long[]{0x0000000000000002L});
1881     public static final BitSet FOLLOW_atom_in_unary351 = new BitSet(new long[]{0x0000000000000002L});
1882     public static final BitSet FOLLOW_var_in_atom364 = new BitSet(new long[]{0x0000000000000002L});
1883     public static final BitSet FOLLOW_num_in_atom370 = new BitSet(new long[]{0x0000000000000002L});
1884     public static final BitSet FOLLOW_str_in_atom376 = new BitSet(new long[]{0x0000000000000002L});
1885     public static final BitSet FOLLOW_fn_in_atom382 = new BitSet(new long[]{0x0000000000000002L});
1886     public static final BitSet FOLLOW_LPAREN_in_atom388 = new BitSet(new long[]{0x00003FEFFD240400L});
1887     public static final BitSet FOLLOW_conjunction_in_atom390 = new BitSet(new long[]{0x0000000000400000L});
1888     public static final BitSet FOLLOW_RPAREN_in_atom392 = new BitSet(new long[]{0x0000000000000002L});
1889     public static final BitSet FOLLOW_name_in_var409 = new BitSet(new long[]{0x0000000000000002L});
1890     public static final BitSet FOLLOW_name_in_var415 = new BitSet(new long[]{0x0000000000800000L});
1891     public static final BitSet FOLLOW_index_in_var417 = new BitSet(new long[]{0x0000000000000002L});
1892     public static final BitSet FOLLOW_LSQUARE_in_index439 = new BitSet(new long[]{0x0000000001000000L});
1893     public static final BitSet FOLLOW_INT_in_index443 = new BitSet(new long[]{0x0000000002000000L});
1894     public static final BitSet FOLLOW_RSQUARE_in_index445 = new BitSet(new long[]{0x0000000000000002L});
1895     public static final BitSet FOLLOW_NAME_in_name463 = new BitSet(new long[]{0x0400000000000002L});
1896     public static final BitSet FOLLOW_58_in_name466 = new BitSet(new long[]{0x0000000004000000L});
1897     public static final BitSet FOLLOW_NAME_in_name469 = new BitSet(new long[]{0x0400000000000002L});
1898     public static final BitSet FOLLOW_TEXT_in_name485 = new BitSet(new long[]{0x0000000000000002L});
1899     public static final BitSet FOLLOW_HTML_in_name498 = new BitSet(new long[]{0x0000000000000002L});
1900     public static final BitSet FOLLOW_ATOM_in_name511 = new BitSet(new long[]{0x0000000000000002L});
1901     public static final BitSet FOLLOW_DATE_in_name524 = new BitSet(new long[]{0x0000000000000002L});
1902     public static final BitSet FOLLOW_NUMBER_in_name537 = new BitSet(new long[]{0x0000000000000002L});
1903     public static final BitSet FOLLOW_GEO_in_name550 = new BitSet(new long[]{0x0000000000000002L});
1904     public static final BitSet FOLLOW_GEOPOINT_in_name563 = new BitSet(new long[]{0x0000000000000002L});
1905     public static final BitSet FOLLOW_set_in_num0 = new BitSet(new long[]{0x0000000000000002L});
1906     public static final BitSet FOLLOW_PHRASE_in_str600 = new BitSet(new long[]{0x0000000000000002L});
1907     public static final BitSet FOLLOW_fnName_in_fn613 = new BitSet(new long[]{0x0000000000200000L});
1908     public static final BitSet FOLLOW_LPAREN_in_fn615 = new BitSet(new long[]{0x00003FEFFD240400L});
1909     public static final BitSet FOLLOW_condExpr_in_fn617 = new BitSet(new long[]{0x0000001000400000L});
1910     public static final BitSet FOLLOW_COMMA_in_fn620 = new BitSet(new long[]{0x00003FEFFD240400L});
1911     public static final BitSet FOLLOW_condExpr_in_fn622 = new BitSet(new long[]{0x0000001000400000L});
1912     public static final BitSet FOLLOW_RPAREN_in_fn626 = new BitSet(new long[]{0x0000000000000002L});
1913     public static final BitSet FOLLOW_set_in_fnName0 = new BitSet(new long[]{0x0000000000000002L});
1914
1915 }