src/main/java/org/xerial/lens/relation/query/impl/LensQueryParser.java

   1 // $ANTLR 3.1.3 Mar 17, 2009 19:23:44 LensQuery.g 2009-10-13 14:02:52\r
   2 \r
   3 /*--------------------------------------------------------------------------\r
   4  *  Copyright 2009 Taro L. Saito\r
   5  *\r
   6  *  Licensed under the Apache License, Version 2.0 (the "License");\r
   7  *  you may not use this file except in compliance with the License.\r
   8  *  You may obtain a copy of the License at\r
   9  *\r
  10  *     http://www.apache.org/licenses/LICENSE-2.0\r
  11  *\r
  12  *  Unless required by applicable law or agreed to in writing, software\r
  13  *  distributed under the License is distributed on an "AS IS" BASIS,\r
  14  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  15  *  See the License for the specific language governing permissions and\r
  16  *  limitations under the License.\r
  17  *--------------------------------------------------------------------------*/\r
  18 //--------------------------------------\r
  19 // XerialJ\r
  20 //\r
  21 // LensQueryParser.g\r
  22 // Since: Aug 6, 2009 08:30:02 AM\r
  23 //\r
  24 //--------------------------------------\r
  25 package org.xerial.lens.relation.query.impl;\r
  26 \r
  27 \r
  28 \r
  29 import org.antlr.runtime.*;\r
  30 import java.util.Stack;\r
  31 import java.util.List;\r
  32 import java.util.ArrayList;\r
  33 \r
  34 \r
  35 import org.antlr.runtime.tree.*;\r
  36 \r
  37 public class LensQueryParser extends Parser {\r
  38     public static final String[] tokenNames = new String[] {\r
  39         "<invalid>", "<EOR>", "<DOWN>", "<UP>", "QUERY", "RELATION", "COMPARE", "OPERATOR", "OPERAND", "PATTERNMATCH", "NODE", "ALIAS", "NODEVALUE", "NAME", "VALUE", "LineBreakChar", "LineComment", "LineBreak", "Digit", "Letter", "HexDigit", "UnicodeChar", "EscapeSequence", "StringChar", "StringChar_s", "String", "Integer", "Frac", "Exp", "Double", "True", "False", "Null", "Lt", "Gt", "Leq", "Geq", "Eq", "Neq", "Match", "Regex", "Dot", "Comma", "Colon", "As", "LParen", "RParen", "Star", "UnsafeUnicodeChar", "SafeFirstLetter", "SafeLetter", "WhiteSpace", "QNameChar", "QName", "WhiteSpaces"\r
  40     };\r
  41     public static final int PATTERNMATCH=9;\r
  42     public static final int Match=39;\r
  43     public static final int Regex=40;\r
  44     public static final int Digit=18;\r
  45     public static final int Frac=27;\r
  46     public static final int HexDigit=20;\r
  47     public static final int QUERY=4;\r
  48     public static final int ALIAS=11;\r
  49     public static final int VALUE=14;\r
  50     public static final int Letter=19;\r
  51     public static final int Comma=42;\r
  52     public static final int Dot=41;\r
  53     public static final int EscapeSequence=22;\r
  54     public static final int Integer=26;\r
  55     public static final int WhiteSpace=51;\r
  56     public static final int OPERATOR=7;\r
  57     public static final int False=31;\r
  58     public static final int LineComment=16;\r
  59     public static final int Colon=43;\r
  60     public static final int NODEVALUE=12;\r
  61     public static final int As=44;\r
  62     public static final int SafeFirstLetter=49;\r
  63     public static final int Null=32;\r
  64     public static final int Star=47;\r
  65     public static final int Eq=37;\r
  66     public static final int Exp=28;\r
  67     public static final int QNameChar=52;\r
  68     public static final int RELATION=5;\r
  69     public static final int Gt=34;\r
  70     public static final int RParen=46;\r
  71     public static final int UnicodeChar=21;\r
  72     public static final int StringChar=23;\r
  73     public static final int True=30;\r
  74     public static final int OPERAND=8;\r
  75     public static final int LineBreak=17;\r
  76     public static final int LParen=45;\r
  77     public static final int String=25;\r
  78     public static final int SafeLetter=50;\r
  79     public static final int LineBreakChar=15;\r
  80     public static final int COMPARE=6;\r
  81     public static final int QName=53;\r
  82     public static final int EOF=-1;\r
  83     public static final int Geq=36;\r
  84     public static final int NODE=10;\r
  85     public static final int StringChar_s=24;\r
  86     public static final int Neq=38;\r
  87     public static final int UnsafeUnicodeChar=48;\r
  88     public static final int Double=29;\r
  89     public static final int Lt=33;\r
  90     public static final int NAME=13;\r
  91     public static final int Leq=35;\r
  92     public static final int WhiteSpaces=54;\r
  93 \r
  94     // delegates\r
  95     // delegators\r
  96 \r
  97 \r
  98         public LensQueryParser(TokenStream input) {\r
  99             this(input, new RecognizerSharedState());\r
 100         }\r
 101         public LensQueryParser(TokenStream input, RecognizerSharedState state) {\r
 102             super(input, state);\r
 103              \r
 104         }\r
 105         \r
 106     protected TreeAdaptor adaptor = new CommonTreeAdaptor();\r
 107 \r
 108     public void setTreeAdaptor(TreeAdaptor adaptor) {\r
 109         this.adaptor = adaptor;\r
 110     }\r
 111     public TreeAdaptor getTreeAdaptor() {\r
 112         return adaptor;\r
 113     }\r
 114 \r
 115     public String[] getTokenNames() { return LensQueryParser.tokenNames; }\r
 116     public String getGrammarFileName() { return "LensQuery.g"; }\r
 117 \r
 118 \r
 119 \r
 120 \r
 121     public static class expr_return extends ParserRuleReturnScope {\r
 122         Object tree;\r
 123         public Object getTree() { return tree; }\r
 124     };\r
 125 \r
 126     // $ANTLR start "expr"\r
 127     // LensQuery.g:185:1: expr : relation ;\r
 128     public final LensQueryParser.expr_return expr() throws RecognitionException {\r
 129         LensQueryParser.expr_return retval = new LensQueryParser.expr_return();\r
 130         retval.start = input.LT(1);\r
 131 \r
 132         Object root_0 = null;\r
 133 \r
 134         LensQueryParser.relation_return relation1 = null;\r
 135 \r
 136 \r
 137 \r
 138         try {\r
 139             // LensQuery.g:185:5: ( relation )\r
 140             // LensQuery.g:186:3: relation\r
 141             {\r
 142             root_0 = (Object)adaptor.nil();\r
 143 \r
 144             pushFollow(FOLLOW_relation_in_expr774);\r
 145             relation1=relation();\r
 146 \r
 147             state._fsp--;\r
 148 \r
 149             adaptor.addChild(root_0, relation1.getTree());\r
 150 \r
 151             }\r
 152 \r
 153             retval.stop = input.LT(-1);\r
 154 \r
 155             retval.tree = (Object)adaptor.rulePostProcessing(root_0);\r
 156             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);\r
 157 \r
 158         }\r
 159         catch (RecognitionException re) {\r
 160             reportError(re);\r
 161             recover(input,re);\r
 162         retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);\r
 163 \r
 164         }\r
 165         finally {\r
 166         }\r
 167         return retval;\r
 168     }\r
 169     // $ANTLR end "expr"\r
 170 \r
 171     public static class relation_return extends ParserRuleReturnScope {\r
 172         Object tree;\r
 173         public Object getTree() { return tree; }\r
 174     };\r
 175 \r
 176     // $ANTLR start "relation"\r
 177     // LensQuery.g:189:1: relation : relation_i -> ^( RELATION relation_i ) ;\r
 178     public final LensQueryParser.relation_return relation() throws RecognitionException {\r
 179         LensQueryParser.relation_return retval = new LensQueryParser.relation_return();\r
 180         retval.start = input.LT(1);\r
 181 \r
 182         Object root_0 = null;\r
 183 \r
 184         LensQueryParser.relation_i_return relation_i2 = null;\r
 185 \r
 186 \r
 187         RewriteRuleSubtreeStream stream_relation_i=new RewriteRuleSubtreeStream(adaptor,"rule relation_i");\r
 188         try {\r
 189             // LensQuery.g:190:4: ( relation_i -> ^( RELATION relation_i ) )\r
 190             // LensQuery.g:190:6: relation_i\r
 191             {\r
 192             pushFollow(FOLLOW_relation_i_in_relation792);\r
 193             relation_i2=relation_i();\r
 194 \r
 195             state._fsp--;\r
 196 \r
 197             stream_relation_i.add(relation_i2.getTree());\r
 198 \r
 199 \r
 200             // AST REWRITE\r
 201             // elements: relation_i\r
 202             // token labels: \r
 203             // rule labels: retval\r
 204             // token list labels: \r
 205             // rule list labels: \r
 206             // wildcard labels: \r
 207             retval.tree = root_0;\r
 208             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);\r
 209 \r
 210             root_0 = (Object)adaptor.nil();\r
 211             // 190:17: -> ^( RELATION relation_i )\r
 212             {\r
 213                 // LensQuery.g:190:20: ^( RELATION relation_i )\r
 214                 {\r
 215                 Object root_1 = (Object)adaptor.nil();\r
 216                 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(RELATION, "RELATION"), root_1);\r
 217 \r
 218                 adaptor.addChild(root_1, stream_relation_i.nextTree());\r
 219 \r
 220                 adaptor.addChild(root_0, root_1);\r
 221                 }\r
 222 \r
 223             }\r
 224 \r
 225             retval.tree = root_0;\r
 226             }\r
 227 \r
 228             retval.stop = input.LT(-1);\r
 229 \r
 230             retval.tree = (Object)adaptor.rulePostProcessing(root_0);\r
 231             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);\r
 232 \r
 233         }\r
 234         catch (RecognitionException re) {\r
 235             reportError(re);\r
 236             recover(input,re);\r
 237         retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);\r
 238 \r
 239         }\r
 240         finally {\r
 241         }\r
 242         return retval;\r
 243     }\r
 244     // $ANTLR end "relation"\r
 245 \r
 246     public static class relation_i_return extends ParserRuleReturnScope {\r
 247         Object tree;\r
 248         public Object getTree() { return tree; }\r
 249     };\r
 250 \r
 251     // $ANTLR start "relation_i"\r
 252     // LensQuery.g:193:1: relation_i : nodeName ( alias )? LParen nodeItem ( Comma nodeItem )* RParen ;\r
 253     public final LensQueryParser.relation_i_return relation_i() throws RecognitionException {\r
 254         LensQueryParser.relation_i_return retval = new LensQueryParser.relation_i_return();\r
 255         retval.start = input.LT(1);\r
 256 \r
 257         Object root_0 = null;\r
 258 \r
 259         Token LParen5=null;\r
 260         Token Comma7=null;\r
 261         Token RParen9=null;\r
 262         LensQueryParser.nodeName_return nodeName3 = null;\r
 263 \r
 264         LensQueryParser.alias_return alias4 = null;\r
 265 \r
 266         LensQueryParser.nodeItem_return nodeItem6 = null;\r
 267 \r
 268         LensQueryParser.nodeItem_return nodeItem8 = null;\r
 269 \r
 270 \r
 271         Object LParen5_tree=null;\r
 272         Object Comma7_tree=null;\r
 273         Object RParen9_tree=null;\r
 274 \r
 275         try {\r
 276             // LensQuery.g:193:11: ( nodeName ( alias )? LParen nodeItem ( Comma nodeItem )* RParen )\r
 277             // LensQuery.g:193:13: nodeName ( alias )? LParen nodeItem ( Comma nodeItem )* RParen\r
 278             {\r
 279             root_0 = (Object)adaptor.nil();\r
 280 \r
 281             pushFollow(FOLLOW_nodeName_in_relation_i808);\r
 282             nodeName3=nodeName();\r
 283 \r
 284             state._fsp--;\r
 285 \r
 286             adaptor.addChild(root_0, nodeName3.getTree());\r
 287             // LensQuery.g:193:22: ( alias )?\r
 288             int alt1=2;\r
 289             int LA1_0 = input.LA(1);\r
 290 \r
 291             if ( (LA1_0==As) ) {\r
 292                 alt1=1;\r
 293             }\r
 294             switch (alt1) {\r
 295                 case 1 :\r
 296                     // LensQuery.g:193:22: alias\r
 297                     {\r
 298                     pushFollow(FOLLOW_alias_in_relation_i810);\r
 299                     alias4=alias();\r
 300 \r
 301                     state._fsp--;\r
 302 \r
 303                     adaptor.addChild(root_0, alias4.getTree());\r
 304 \r
 305                     }\r
 306                     break;\r
 307 \r
 308             }\r
 309 \r
 310             LParen5=(Token)match(input,LParen,FOLLOW_LParen_in_relation_i813); \r
 311             pushFollow(FOLLOW_nodeItem_in_relation_i816);\r
 312             nodeItem6=nodeItem();\r
 313 \r
 314             state._fsp--;\r
 315 \r
 316             adaptor.addChild(root_0, nodeItem6.getTree());\r
 317             // LensQuery.g:193:46: ( Comma nodeItem )*\r
 318             loop2:\r
 319             do {\r
 320                 int alt2=2;\r
 321                 int LA2_0 = input.LA(1);\r
 322 \r
 323                 if ( (LA2_0==Comma) ) {\r
 324                     alt2=1;\r
 325                 }\r
 326 \r
 327 \r
 328                 switch (alt2) {\r
 329                 case 1 :\r
 330                     // LensQuery.g:193:47: Comma nodeItem\r
 331                     {\r
 332                     Comma7=(Token)match(input,Comma,FOLLOW_Comma_in_relation_i819); \r
 333                     pushFollow(FOLLOW_nodeItem_in_relation_i822);\r
 334                     nodeItem8=nodeItem();\r
 335 \r
 336                     state._fsp--;\r
 337 \r
 338                     adaptor.addChild(root_0, nodeItem8.getTree());\r
 339 \r
 340                     }\r
 341                     break;\r
 342 \r
 343                 default :\r
 344                     break loop2;\r
 345                 }\r
 346             } while (true);\r
 347 \r
 348             RParen9=(Token)match(input,RParen,FOLLOW_RParen_in_relation_i826); \r
 349 \r
 350             }\r
 351 \r
 352             retval.stop = input.LT(-1);\r
 353 \r
 354             retval.tree = (Object)adaptor.rulePostProcessing(root_0);\r
 355             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);\r
 356 \r
 357         }\r
 358         catch (RecognitionException re) {\r
 359             reportError(re);\r
 360             recover(input,re);\r
 361         retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);\r
 362 \r
 363         }\r
 364         finally {\r
 365         }\r
 366         return retval;\r
 367     }\r
 368     // $ANTLR end "relation_i"\r
 369 \r
 370     public static class nodeName_return extends ParserRuleReturnScope {\r
 371         Object tree;\r
 372         public Object getTree() { return tree; }\r
 373     };\r
 374 \r
 375     // $ANTLR start "nodeName"\r
 376     // LensQuery.g:196:1: fragment nodeName : ( QName -> NAME[$QName.text] | String -> NAME[$String.text] );\r
 377     public final LensQueryParser.nodeName_return nodeName() throws RecognitionException {\r
 378         LensQueryParser.nodeName_return retval = new LensQueryParser.nodeName_return();\r
 379         retval.start = input.LT(1);\r
 380 \r
 381         Object root_0 = null;\r
 382 \r
 383         Token QName10=null;\r
 384         Token String11=null;\r
 385 \r
 386         Object QName10_tree=null;\r
 387         Object String11_tree=null;\r
 388         RewriteRuleTokenStream stream_String=new RewriteRuleTokenStream(adaptor,"token String");\r
 389         RewriteRuleTokenStream stream_QName=new RewriteRuleTokenStream(adaptor,"token QName");\r
 390 \r
 391         try {\r
 392             // LensQuery.g:198:3: ( QName -> NAME[$QName.text] | String -> NAME[$String.text] )\r
 393             int alt3=2;\r
 394             int LA3_0 = input.LA(1);\r
 395 \r
 396             if ( (LA3_0==QName) ) {\r
 397                 alt3=1;\r
 398             }\r
 399             else if ( (LA3_0==String) ) {\r
 400                 alt3=2;\r
 401             }\r
 402             else {\r
 403                 NoViableAltException nvae =\r
 404                     new NoViableAltException("", 3, 0, input);\r
 405 \r
 406                 throw nvae;\r
 407             }\r
 408             switch (alt3) {\r
 409                 case 1 :\r
 410                     // LensQuery.g:198:5: QName\r
 411                     {\r
 412                     QName10=(Token)match(input,QName,FOLLOW_QName_in_nodeName840);  \r
 413                     stream_QName.add(QName10);\r
 414 \r
 415 \r
 416 \r
 417                     // AST REWRITE\r
 418                     // elements: \r
 419                     // token labels: \r
 420                     // rule labels: retval\r
 421                     // token list labels: \r
 422                     // rule list labels: \r
 423                     // wildcard labels: \r
 424                     retval.tree = root_0;\r
 425                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);\r
 426 \r
 427                     root_0 = (Object)adaptor.nil();\r
 428                     // 198:11: -> NAME[$QName.text]\r
 429                     {\r
 430                         adaptor.addChild(root_0, (Object)adaptor.create(NAME, (QName10!=null?QName10.getText():null)));\r
 431 \r
 432                     }\r
 433 \r
 434                     retval.tree = root_0;\r
 435                     }\r
 436                     break;\r
 437                 case 2 :\r
 438                     // LensQuery.g:199:5: String\r
 439                     {\r
 440                     String11=(Token)match(input,String,FOLLOW_String_in_nodeName851);  \r
 441                     stream_String.add(String11);\r
 442 \r
 443 \r
 444 \r
 445                     // AST REWRITE\r
 446                     // elements: \r
 447                     // token labels: \r
 448                     // rule labels: retval\r
 449                     // token list labels: \r
 450                     // rule list labels: \r
 451                     // wildcard labels: \r
 452                     retval.tree = root_0;\r
 453                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);\r
 454 \r
 455                     root_0 = (Object)adaptor.nil();\r
 456                     // 199:12: -> NAME[$String.text]\r
 457                     {\r
 458                         adaptor.addChild(root_0, (Object)adaptor.create(NAME, (String11!=null?String11.getText():null)));\r
 459 \r
 460                     }\r
 461 \r
 462                     retval.tree = root_0;\r
 463                     }\r
 464                     break;\r
 465 \r
 466             }\r
 467             retval.stop = input.LT(-1);\r
 468 \r
 469             retval.tree = (Object)adaptor.rulePostProcessing(root_0);\r
 470             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);\r
 471 \r
 472         }\r
 473         catch (RecognitionException re) {\r
 474             reportError(re);\r
 475             recover(input,re);\r
 476         retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);\r
 477 \r
 478         }\r
 479         finally {\r
 480         }\r
 481         return retval;\r
 482     }\r
 483     // $ANTLR end "nodeName"\r
 484 \r
 485     public static class alias_return extends ParserRuleReturnScope {\r
 486         Object tree;\r
 487         public Object getTree() { return tree; }\r
 488     };\r
 489 \r
 490     // $ANTLR start "alias"\r
 491     // LensQuery.g:202:1: fragment alias : As QName -> ALIAS[$QName.text] ;\r
 492     public final LensQueryParser.alias_return alias() throws RecognitionException {\r
 493         LensQueryParser.alias_return retval = new LensQueryParser.alias_return();\r
 494         retval.start = input.LT(1);\r
 495 \r
 496         Object root_0 = null;\r
 497 \r
 498         Token As12=null;\r
 499         Token QName13=null;\r
 500 \r
 501         Object As12_tree=null;\r
 502         Object QName13_tree=null;\r
 503         RewriteRuleTokenStream stream_As=new RewriteRuleTokenStream(adaptor,"token As");\r
 504         RewriteRuleTokenStream stream_QName=new RewriteRuleTokenStream(adaptor,"token QName");\r
 505 \r
 506         try {\r
 507             // LensQuery.g:203:6: ( As QName -> ALIAS[$QName.text] )\r
 508             // LensQuery.g:203:8: As QName\r
 509             {\r
 510             As12=(Token)match(input,As,FOLLOW_As_in_alias868);  \r
 511             stream_As.add(As12);\r
 512 \r
 513             QName13=(Token)match(input,QName,FOLLOW_QName_in_alias870);  \r
 514             stream_QName.add(QName13);\r
 515 \r
 516 \r
 517 \r
 518             // AST REWRITE\r
 519             // elements: \r
 520             // token labels: \r
 521             // rule labels: retval\r
 522             // token list labels: \r
 523             // rule list labels: \r
 524             // wildcard labels: \r
 525             retval.tree = root_0;\r
 526             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);\r
 527 \r
 528             root_0 = (Object)adaptor.nil();\r
 529             // 203:17: -> ALIAS[$QName.text]\r
 530             {\r
 531                 adaptor.addChild(root_0, (Object)adaptor.create(ALIAS, (QName13!=null?QName13.getText():null)));\r
 532 \r
 533             }\r
 534 \r
 535             retval.tree = root_0;\r
 536             }\r
 537 \r
 538             retval.stop = input.LT(-1);\r
 539 \r
 540             retval.tree = (Object)adaptor.rulePostProcessing(root_0);\r
 541             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);\r
 542 \r
 543         }\r
 544         catch (RecognitionException re) {\r
 545             reportError(re);\r
 546             recover(input,re);\r
 547         retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);\r
 548 \r
 549         }\r
 550         finally {\r
 551         }\r
 552         return retval;\r
 553     }\r
 554     // $ANTLR end "alias"\r
 555 \r
 556     public static class nodeItem_return extends ParserRuleReturnScope {\r
 557         Object tree;\r
 558         public Object getTree() { return tree; }\r
 559     };\r
 560 \r
 561     // $ANTLR start "nodeItem"\r
 562     // LensQuery.g:206:1: fragment nodeItem : ( nodeName ( alias )? ( nodeValue )? -> ^( NODE nodeName ( alias )? ( nodeValue )? ) | relation );\r
 563     public final LensQueryParser.nodeItem_return nodeItem() throws RecognitionException {\r
 564         LensQueryParser.nodeItem_return retval = new LensQueryParser.nodeItem_return();\r
 565         retval.start = input.LT(1);\r
 566 \r
 567         Object root_0 = null;\r
 568 \r
 569         LensQueryParser.nodeName_return nodeName14 = null;\r
 570 \r
 571         LensQueryParser.alias_return alias15 = null;\r
 572 \r
 573         LensQueryParser.nodeValue_return nodeValue16 = null;\r
 574 \r
 575         LensQueryParser.relation_return relation17 = null;\r
 576 \r
 577 \r
 578         RewriteRuleSubtreeStream stream_nodeName=new RewriteRuleSubtreeStream(adaptor,"rule nodeName");\r
 579         RewriteRuleSubtreeStream stream_nodeValue=new RewriteRuleSubtreeStream(adaptor,"rule nodeValue");\r
 580         RewriteRuleSubtreeStream stream_alias=new RewriteRuleSubtreeStream(adaptor,"rule alias");\r
 581         try {\r
 582             // LensQuery.g:208:3: ( nodeName ( alias )? ( nodeValue )? -> ^( NODE nodeName ( alias )? ( nodeValue )? ) | relation )\r
 583             int alt6=2;\r
 584             int LA6_0 = input.LA(1);\r
 585 \r
 586             if ( (LA6_0==QName) ) {\r
 587                 switch ( input.LA(2) ) {\r
 588                 case As:\r
 589                     {\r
 590                     int LA6_3 = input.LA(3);\r
 591 \r
 592                     if ( (LA6_3==QName) ) {\r
 593                         int LA6_6 = input.LA(4);\r
 594 \r
 595                         if ( ((LA6_6>=Lt && LA6_6<=Match)||(LA6_6>=Comma && LA6_6<=Colon)||LA6_6==RParen) ) {\r
 596                             alt6=1;\r
 597                         }\r
 598                         else if ( (LA6_6==LParen) ) {\r
 599                             alt6=2;\r
 600                         }\r
 601                         else {\r
 602                             NoViableAltException nvae =\r
 603                                 new NoViableAltException("", 6, 6, input);\r
 604 \r
 605                             throw nvae;\r
 606                         }\r
 607                     }\r
 608                     else {\r
 609                         NoViableAltException nvae =\r
 610                             new NoViableAltException("", 6, 3, input);\r
 611 \r
 612                         throw nvae;\r
 613                     }\r
 614                     }\r
 615                     break;\r
 616                 case Lt:\r
 617                 case Gt:\r
 618                 case Leq:\r
 619                 case Geq:\r
 620                 case Eq:\r
 621                 case Neq:\r
 622                 case Match:\r
 623                 case Comma:\r
 624                 case Colon:\r
 625                 case RParen:\r
 626                     {\r
 627                     alt6=1;\r
 628                     }\r
 629                     break;\r
 630                 case LParen:\r
 631                     {\r
 632                     alt6=2;\r
 633                     }\r
 634                     break;\r
 635                 default:\r
 636                     NoViableAltException nvae =\r
 637                         new NoViableAltException("", 6, 1, input);\r
 638 \r
 639                     throw nvae;\r
 640                 }\r
 641 \r
 642             }\r
 643             else if ( (LA6_0==String) ) {\r
 644                 switch ( input.LA(2) ) {\r
 645                 case As:\r
 646                     {\r
 647                     int LA6_3 = input.LA(3);\r
 648 \r
 649                     if ( (LA6_3==QName) ) {\r
 650                         int LA6_6 = input.LA(4);\r
 651 \r
 652                         if ( ((LA6_6>=Lt && LA6_6<=Match)||(LA6_6>=Comma && LA6_6<=Colon)||LA6_6==RParen) ) {\r
 653                             alt6=1;\r
 654                         }\r
 655                         else if ( (LA6_6==LParen) ) {\r
 656                             alt6=2;\r
 657                         }\r
 658                         else {\r
 659                             NoViableAltException nvae =\r
 660                                 new NoViableAltException("", 6, 6, input);\r
 661 \r
 662                             throw nvae;\r
 663                         }\r
 664                     }\r
 665                     else {\r
 666                         NoViableAltException nvae =\r
 667                             new NoViableAltException("", 6, 3, input);\r
 668 \r
 669                         throw nvae;\r
 670                     }\r
 671                     }\r
 672                     break;\r
 673                 case LParen:\r
 674                     {\r
 675                     alt6=2;\r
 676                     }\r
 677                     break;\r
 678                 case Lt:\r
 679                 case Gt:\r
 680                 case Leq:\r
 681                 case Geq:\r
 682                 case Eq:\r
 683                 case Neq:\r
 684                 case Match:\r
 685                 case Comma:\r
 686                 case Colon:\r
 687                 case RParen:\r
 688                     {\r
 689                     alt6=1;\r
 690                     }\r
 691                     break;\r
 692                 default:\r
 693                     NoViableAltException nvae =\r
 694                         new NoViableAltException("", 6, 2, input);\r
 695 \r
 696                     throw nvae;\r
 697                 }\r
 698 \r
 699             }\r
 700             else {\r
 701                 NoViableAltException nvae =\r
 702                     new NoViableAltException("", 6, 0, input);\r
 703 \r
 704                 throw nvae;\r
 705             }\r
 706             switch (alt6) {\r
 707                 case 1 :\r
 708                     // LensQuery.g:208:5: nodeName ( alias )? ( nodeValue )?\r
 709                     {\r
 710                     pushFollow(FOLLOW_nodeName_in_nodeItem890);\r
 711                     nodeName14=nodeName();\r
 712 \r
 713                     state._fsp--;\r
 714 \r
 715                     stream_nodeName.add(nodeName14.getTree());\r
 716                     // LensQuery.g:208:14: ( alias )?\r
 717                     int alt4=2;\r
 718                     int LA4_0 = input.LA(1);\r
 719 \r
 720                     if ( (LA4_0==As) ) {\r
 721                         alt4=1;\r
 722                     }\r
 723                     switch (alt4) {\r
 724                         case 1 :\r
 725                             // LensQuery.g:208:14: alias\r
 726                             {\r
 727                             pushFollow(FOLLOW_alias_in_nodeItem892);\r
 728                             alias15=alias();\r
 729 \r
 730                             state._fsp--;\r
 731 \r
 732                             stream_alias.add(alias15.getTree());\r
 733 \r
 734                             }\r
 735                             break;\r
 736 \r
 737                     }\r
 738 \r
 739                     // LensQuery.g:208:21: ( nodeValue )?\r
 740                     int alt5=2;\r
 741                     int LA5_0 = input.LA(1);\r
 742 \r
 743                     if ( ((LA5_0>=Lt && LA5_0<=Match)||LA5_0==Colon) ) {\r
 744                         alt5=1;\r
 745                     }\r
 746                     switch (alt5) {\r
 747                         case 1 :\r
 748                             // LensQuery.g:208:21: nodeValue\r
 749                             {\r
 750                             pushFollow(FOLLOW_nodeValue_in_nodeItem895);\r
 751                             nodeValue16=nodeValue();\r
 752 \r
 753                             state._fsp--;\r
 754 \r
 755                             stream_nodeValue.add(nodeValue16.getTree());\r
 756 \r
 757                             }\r
 758                             break;\r
 759 \r
 760                     }\r
 761 \r
 762 \r
 763 \r
 764                     // AST REWRITE\r
 765                     // elements: nodeName, alias, nodeValue\r
 766                     // token labels: \r
 767                     // rule labels: retval\r
 768                     // token list labels: \r
 769                     // rule list labels: \r
 770                     // wildcard labels: \r
 771                     retval.tree = root_0;\r
 772                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);\r
 773 \r
 774                     root_0 = (Object)adaptor.nil();\r
 775                     // 209:5: -> ^( NODE nodeName ( alias )? ( nodeValue )? )\r
 776                     {\r
 777                         // LensQuery.g:209:8: ^( NODE nodeName ( alias )? ( nodeValue )? )\r
 778                         {\r
 779                         Object root_1 = (Object)adaptor.nil();\r
 780                         root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(NODE, "NODE"), root_1);\r
 781 \r
 782                         adaptor.addChild(root_1, stream_nodeName.nextTree());\r
 783                         // LensQuery.g:209:24: ( alias )?\r
 784                         if ( stream_alias.hasNext() ) {\r
 785                             adaptor.addChild(root_1, stream_alias.nextTree());\r
 786 \r
 787                         }\r
 788                         stream_alias.reset();\r
 789                         // LensQuery.g:209:31: ( nodeValue )?\r
 790                         if ( stream_nodeValue.hasNext() ) {\r
 791                             adaptor.addChild(root_1, stream_nodeValue.nextTree());\r
 792 \r
 793                         }\r
 794                         stream_nodeValue.reset();\r
 795 \r
 796                         adaptor.addChild(root_0, root_1);\r
 797                         }\r
 798 \r
 799                     }\r
 800 \r
 801                     retval.tree = root_0;\r
 802                     }\r
 803                     break;\r
 804                 case 2 :\r
 805                     // LensQuery.g:210:5: relation\r
 806                     {\r
 807                     root_0 = (Object)adaptor.nil();\r
 808 \r
 809                     pushFollow(FOLLOW_relation_in_nodeItem921);\r
 810                     relation17=relation();\r
 811 \r
 812                     state._fsp--;\r
 813 \r
 814                     adaptor.addChild(root_0, relation17.getTree());\r
 815 \r
 816                     }\r
 817                     break;\r
 818 \r
 819             }\r
 820             retval.stop = input.LT(-1);\r
 821 \r
 822             retval.tree = (Object)adaptor.rulePostProcessing(root_0);\r
 823             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);\r
 824 \r
 825         }\r
 826         catch (RecognitionException re) {\r
 827             reportError(re);\r
 828             recover(input,re);\r
 829         retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);\r
 830 \r
 831         }\r
 832         finally {\r
 833         }\r
 834         return retval;\r
 835     }\r
 836     // $ANTLR end "nodeItem"\r
 837 \r
 838     public static class value_return extends ParserRuleReturnScope {\r
 839         Object tree;\r
 840         public Object getTree() { return tree; }\r
 841     };\r
 842 \r
 843     // $ANTLR start "value"\r
 844     // LensQuery.g:213:1: fragment value : ( String | Integer | Double | QName );\r
 845     public final LensQueryParser.value_return value() throws RecognitionException {\r
 846         LensQueryParser.value_return retval = new LensQueryParser.value_return();\r
 847         retval.start = input.LT(1);\r
 848 \r
 849         Object root_0 = null;\r
 850 \r
 851         Token set18=null;\r
 852 \r
 853         Object set18_tree=null;\r
 854 \r
 855         try {\r
 856             // LensQuery.g:215:3: ( String | Integer | Double | QName )\r
 857             // LensQuery.g:\r
 858             {\r
 859             root_0 = (Object)adaptor.nil();\r
 860 \r
 861             set18=(Token)input.LT(1);\r
 862             if ( (input.LA(1)>=String && input.LA(1)<=Integer)||input.LA(1)==Double||input.LA(1)==QName ) {\r
 863                 input.consume();\r
 864                 adaptor.addChild(root_0, (Object)adaptor.create(set18));\r
 865                 state.errorRecovery=false;\r
 866             }\r
 867             else {\r
 868                 MismatchedSetException mse = new MismatchedSetException(null,input);\r
 869                 throw mse;\r
 870             }\r
 871 \r
 872 \r
 873             }\r
 874 \r
 875             retval.stop = input.LT(-1);\r
 876 \r
 877             retval.tree = (Object)adaptor.rulePostProcessing(root_0);\r
 878             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);\r
 879 \r
 880         }\r
 881         catch (RecognitionException re) {\r
 882             reportError(re);\r
 883             recover(input,re);\r
 884         retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);\r
 885 \r
 886         }\r
 887         finally {\r
 888         }\r
 889         return retval;\r
 890     }\r
 891     // $ANTLR end "value"\r
 892 \r
 893     public static class nodeValue_return extends ParserRuleReturnScope {\r
 894         Object tree;\r
 895         public Object getTree() { return tree; }\r
 896     };\r
 897 \r
 898     // $ANTLR start "nodeValue"\r
 899     // LensQuery.g:218:1: fragment nodeValue : ( Colon value -> NODEVALUE[$value.text] | nodeCmp );\r
 900     public final LensQueryParser.nodeValue_return nodeValue() throws RecognitionException {\r
 901         LensQueryParser.nodeValue_return retval = new LensQueryParser.nodeValue_return();\r
 902         retval.start = input.LT(1);\r
 903 \r
 904         Object root_0 = null;\r
 905 \r
 906         Token Colon19=null;\r
 907         LensQueryParser.value_return value20 = null;\r
 908 \r
 909         LensQueryParser.nodeCmp_return nodeCmp21 = null;\r
 910 \r
 911 \r
 912         Object Colon19_tree=null;\r
 913         RewriteRuleTokenStream stream_Colon=new RewriteRuleTokenStream(adaptor,"token Colon");\r
 914         RewriteRuleSubtreeStream stream_value=new RewriteRuleSubtreeStream(adaptor,"rule value");\r
 915         try {\r
 916             // LensQuery.g:220:3: ( Colon value -> NODEVALUE[$value.text] | nodeCmp )\r
 917             int alt7=2;\r
 918             int LA7_0 = input.LA(1);\r
 919 \r
 920             if ( (LA7_0==Colon) ) {\r
 921                 alt7=1;\r
 922             }\r
 923             else if ( ((LA7_0>=Lt && LA7_0<=Match)) ) {\r
 924                 alt7=2;\r
 925             }\r
 926             else {\r
 927                 NoViableAltException nvae =\r
 928                     new NoViableAltException("", 7, 0, input);\r
 929 \r
 930                 throw nvae;\r
 931             }\r
 932             switch (alt7) {\r
 933                 case 1 :\r
 934                     // LensQuery.g:220:5: Colon value\r
 935                     {\r
 936                     Colon19=(Token)match(input,Colon,FOLLOW_Colon_in_nodeValue970);  \r
 937                     stream_Colon.add(Colon19);\r
 938 \r
 939                     pushFollow(FOLLOW_value_in_nodeValue972);\r
 940                     value20=value();\r
 941 \r
 942                     state._fsp--;\r
 943 \r
 944                     stream_value.add(value20.getTree());\r
 945 \r
 946 \r
 947                     // AST REWRITE\r
 948                     // elements: \r
 949                     // token labels: \r
 950                     // rule labels: retval\r
 951                     // token list labels: \r
 952                     // rule list labels: \r
 953                     // wildcard labels: \r
 954                     retval.tree = root_0;\r
 955                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);\r
 956 \r
 957                     root_0 = (Object)adaptor.nil();\r
 958                     // 220:17: -> NODEVALUE[$value.text]\r
 959                     {\r
 960                         adaptor.addChild(root_0, (Object)adaptor.create(NODEVALUE, (value20!=null?input.toString(value20.start,value20.stop):null)));\r
 961 \r
 962                     }\r
 963 \r
 964                     retval.tree = root_0;\r
 965                     }\r
 966                     break;\r
 967                 case 2 :\r
 968                     // LensQuery.g:221:5: nodeCmp\r
 969                     {\r
 970                     root_0 = (Object)adaptor.nil();\r
 971 \r
 972                     pushFollow(FOLLOW_nodeCmp_in_nodeValue983);\r
 973                     nodeCmp21=nodeCmp();\r
 974 \r
 975                     state._fsp--;\r
 976 \r
 977                     adaptor.addChild(root_0, nodeCmp21.getTree());\r
 978 \r
 979                     }\r
 980                     break;\r
 981 \r
 982             }\r
 983             retval.stop = input.LT(-1);\r
 984 \r
 985             retval.tree = (Object)adaptor.rulePostProcessing(root_0);\r
 986             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);\r
 987 \r
 988         }\r
 989         catch (RecognitionException re) {\r
 990             reportError(re);\r
 991             recover(input,re);\r
 992         retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);\r
 993 \r
 994         }\r
 995         finally {\r
 996         }\r
 997         return retval;\r
 998     }\r
 999     // $ANTLR end "nodeValue"\r
1000 \r
1001     public static class nodeCmp_return extends ParserRuleReturnScope {\r
1002         Object tree;\r
1003         public Object getTree() { return tree; }\r
1004     };\r
1005 \r
1006     // $ANTLR start "nodeCmp"\r
1007     // LensQuery.g:224:1: fragment nodeCmp : ( cmpOp value -> ^( COMPARE OPERATOR[$cmpOp.text] OPERAND[$value.text] ) | Match Regex -> ^( PATTERNMATCH OPERAND[$Regex.text] ) );\r
1008     public final LensQueryParser.nodeCmp_return nodeCmp() throws RecognitionException {\r
1009         LensQueryParser.nodeCmp_return retval = new LensQueryParser.nodeCmp_return();\r
1010         retval.start = input.LT(1);\r
1011 \r
1012         Object root_0 = null;\r
1013 \r
1014         Token Match24=null;\r
1015         Token Regex25=null;\r
1016         LensQueryParser.cmpOp_return cmpOp22 = null;\r
1017 \r
1018         LensQueryParser.value_return value23 = null;\r
1019 \r
1020 \r
1021         Object Match24_tree=null;\r
1022         Object Regex25_tree=null;\r
1023         RewriteRuleTokenStream stream_Match=new RewriteRuleTokenStream(adaptor,"token Match");\r
1024         RewriteRuleTokenStream stream_Regex=new RewriteRuleTokenStream(adaptor,"token Regex");\r
1025         RewriteRuleSubtreeStream stream_value=new RewriteRuleSubtreeStream(adaptor,"rule value");\r
1026         RewriteRuleSubtreeStream stream_cmpOp=new RewriteRuleSubtreeStream(adaptor,"rule cmpOp");\r
1027         try {\r
1028             // LensQuery.g:226:3: ( cmpOp value -> ^( COMPARE OPERATOR[$cmpOp.text] OPERAND[$value.text] ) | Match Regex -> ^( PATTERNMATCH OPERAND[$Regex.text] ) )\r
1029             int alt8=2;\r
1030             int LA8_0 = input.LA(1);\r
1031 \r
1032             if ( ((LA8_0>=Lt && LA8_0<=Neq)) ) {\r
1033                 alt8=1;\r
1034             }\r
1035             else if ( (LA8_0==Match) ) {\r
1036                 alt8=2;\r
1037             }\r
1038             else {\r
1039                 NoViableAltException nvae =\r
1040                     new NoViableAltException("", 8, 0, input);\r
1041 \r
1042                 throw nvae;\r
1043             }\r
1044             switch (alt8) {\r
1045                 case 1 :\r
1046                     // LensQuery.g:226:5: cmpOp value\r
1047                     {\r
1048                     pushFollow(FOLLOW_cmpOp_in_nodeCmp1003);\r
1049                     cmpOp22=cmpOp();\r
1050 \r
1051                     state._fsp--;\r
1052 \r
1053                     stream_cmpOp.add(cmpOp22.getTree());\r
1054                     pushFollow(FOLLOW_value_in_nodeCmp1005);\r
1055                     value23=value();\r
1056 \r
1057                     state._fsp--;\r
1058 \r
1059                     stream_value.add(value23.getTree());\r
1060 \r
1061 \r
1062                     // AST REWRITE\r
1063                     // elements: \r
1064                     // token labels: \r
1065                     // rule labels: retval\r
1066                     // token list labels: \r
1067                     // rule list labels: \r
1068                     // wildcard labels: \r
1069                     retval.tree = root_0;\r
1070                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);\r
1071 \r
1072                     root_0 = (Object)adaptor.nil();\r
1073                     // 226:17: -> ^( COMPARE OPERATOR[$cmpOp.text] OPERAND[$value.text] )\r
1074                     {\r
1075                         // LensQuery.g:226:20: ^( COMPARE OPERATOR[$cmpOp.text] OPERAND[$value.text] )\r
1076                         {\r
1077                         Object root_1 = (Object)adaptor.nil();\r
1078                         root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(COMPARE, "COMPARE"), root_1);\r
1079 \r
1080                         adaptor.addChild(root_1, (Object)adaptor.create(OPERATOR, (cmpOp22!=null?input.toString(cmpOp22.start,cmpOp22.stop):null)));\r
1081                         adaptor.addChild(root_1, (Object)adaptor.create(OPERAND, (value23!=null?input.toString(value23.start,value23.stop):null)));\r
1082 \r
1083                         adaptor.addChild(root_0, root_1);\r
1084                         }\r
1085 \r
1086                     }\r
1087 \r
1088                     retval.tree = root_0;\r
1089                     }\r
1090                     break;\r
1091                 case 2 :\r
1092                     // LensQuery.g:227:5: Match Regex\r
1093                     {\r
1094                     Match24=(Token)match(input,Match,FOLLOW_Match_in_nodeCmp1023);  \r
1095                     stream_Match.add(Match24);\r
1096 \r
1097                     Regex25=(Token)match(input,Regex,FOLLOW_Regex_in_nodeCmp1025);  \r
1098                     stream_Regex.add(Regex25);\r
1099 \r
1100 \r
1101 \r
1102                     // AST REWRITE\r
1103                     // elements: \r
1104                     // token labels: \r
1105                     // rule labels: retval\r
1106                     // token list labels: \r
1107                     // rule list labels: \r
1108                     // wildcard labels: \r
1109                     retval.tree = root_0;\r
1110                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);\r
1111 \r
1112                     root_0 = (Object)adaptor.nil();\r
1113                     // 227:17: -> ^( PATTERNMATCH OPERAND[$Regex.text] )\r
1114                     {\r
1115                         // LensQuery.g:227:20: ^( PATTERNMATCH OPERAND[$Regex.text] )\r
1116                         {\r
1117                         Object root_1 = (Object)adaptor.nil();\r
1118                         root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(PATTERNMATCH, "PATTERNMATCH"), root_1);\r
1119 \r
1120                         adaptor.addChild(root_1, (Object)adaptor.create(OPERAND, (Regex25!=null?Regex25.getText():null)));\r
1121 \r
1122                         adaptor.addChild(root_0, root_1);\r
1123                         }\r
1124 \r
1125                     }\r
1126 \r
1127                     retval.tree = root_0;\r
1128                     }\r
1129                     break;\r
1130 \r
1131             }\r
1132             retval.stop = input.LT(-1);\r
1133 \r
1134             retval.tree = (Object)adaptor.rulePostProcessing(root_0);\r
1135             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);\r
1136 \r
1137         }\r
1138         catch (RecognitionException re) {\r
1139             reportError(re);\r
1140             recover(input,re);\r
1141         retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);\r
1142 \r
1143         }\r
1144         finally {\r
1145         }\r
1146         return retval;\r
1147     }\r
1148     // $ANTLR end "nodeCmp"\r
1149 \r
1150     public static class cmpOp_return extends ParserRuleReturnScope {\r
1151         Object tree;\r
1152         public Object getTree() { return tree; }\r
1153     };\r
1154 \r
1155     // $ANTLR start "cmpOp"\r
1156     // LensQuery.g:230:1: fragment cmpOp : ( Lt | Gt | Eq | Leq | Geq | Neq ) ;\r
1157     public final LensQueryParser.cmpOp_return cmpOp() throws RecognitionException {\r
1158         LensQueryParser.cmpOp_return retval = new LensQueryParser.cmpOp_return();\r
1159         retval.start = input.LT(1);\r
1160 \r
1161         Object root_0 = null;\r
1162 \r
1163         Token set26=null;\r
1164 \r
1165         Object set26_tree=null;\r
1166 \r
1167         try {\r
1168             // LensQuery.g:231:6: ( ( Lt | Gt | Eq | Leq | Geq | Neq ) )\r
1169             // LensQuery.g:231:8: ( Lt | Gt | Eq | Leq | Geq | Neq )\r
1170             {\r
1171             root_0 = (Object)adaptor.nil();\r
1172 \r
1173             set26=(Token)input.LT(1);\r
1174             if ( (input.LA(1)>=Lt && input.LA(1)<=Neq) ) {\r
1175                 input.consume();\r
1176                 adaptor.addChild(root_0, (Object)adaptor.create(set26));\r
1177                 state.errorRecovery=false;\r
1178             }\r
1179             else {\r
1180                 MismatchedSetException mse = new MismatchedSetException(null,input);\r
1181                 throw mse;\r
1182             }\r
1183 \r
1184 \r
1185             }\r
1186 \r
1187             retval.stop = input.LT(-1);\r
1188 \r
1189             retval.tree = (Object)adaptor.rulePostProcessing(root_0);\r
1190             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);\r
1191 \r
1192         }\r
1193         catch (RecognitionException re) {\r
1194             reportError(re);\r
1195             recover(input,re);\r
1196         retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);\r
1197 \r
1198         }\r
1199         finally {\r
1200         }\r
1201         return retval;\r
1202     }\r
1203     // $ANTLR end "cmpOp"\r
1204 \r
1205     // Delegated rules\r
1206 \r
1207 \r
1208  \r
1209 \r
1210     public static final BitSet FOLLOW_relation_in_expr774 = new BitSet(new long[]{0x0000000000000002L});\r
1211     public static final BitSet FOLLOW_relation_i_in_relation792 = new BitSet(new long[]{0x0000000000000002L});\r
1212     public static final BitSet FOLLOW_nodeName_in_relation_i808 = new BitSet(new long[]{0x0000300000000000L});\r
1213     public static final BitSet FOLLOW_alias_in_relation_i810 = new BitSet(new long[]{0x0000200000000000L});\r
1214     public static final BitSet FOLLOW_LParen_in_relation_i813 = new BitSet(new long[]{0x0020000002000000L});\r
1215     public static final BitSet FOLLOW_nodeItem_in_relation_i816 = new BitSet(new long[]{0x0000440000000000L});\r
1216     public static final BitSet FOLLOW_Comma_in_relation_i819 = new BitSet(new long[]{0x0020000002000000L});\r
1217     public static final BitSet FOLLOW_nodeItem_in_relation_i822 = new BitSet(new long[]{0x0000440000000000L});\r
1218     public static final BitSet FOLLOW_RParen_in_relation_i826 = new BitSet(new long[]{0x0000000000000002L});\r
1219     public static final BitSet FOLLOW_QName_in_nodeName840 = new BitSet(new long[]{0x0000000000000002L});\r
1220     public static final BitSet FOLLOW_String_in_nodeName851 = new BitSet(new long[]{0x0000000000000002L});\r
1221     public static final BitSet FOLLOW_As_in_alias868 = new BitSet(new long[]{0x0020000000000000L});\r
1222     public static final BitSet FOLLOW_QName_in_alias870 = new BitSet(new long[]{0x0000000000000002L});\r
1223     public static final BitSet FOLLOW_nodeName_in_nodeItem890 = new BitSet(new long[]{0x000018FE00000002L});\r
1224     public static final BitSet FOLLOW_alias_in_nodeItem892 = new BitSet(new long[]{0x000008FE00000002L});\r
1225     public static final BitSet FOLLOW_nodeValue_in_nodeItem895 = new BitSet(new long[]{0x0000000000000002L});\r
1226     public static final BitSet FOLLOW_relation_in_nodeItem921 = new BitSet(new long[]{0x0000000000000002L});\r
1227     public static final BitSet FOLLOW_set_in_value0 = new BitSet(new long[]{0x0000000000000002L});\r
1228     public static final BitSet FOLLOW_Colon_in_nodeValue970 = new BitSet(new long[]{0x0020000026000000L});\r
1229     public static final BitSet FOLLOW_value_in_nodeValue972 = new BitSet(new long[]{0x0000000000000002L});\r
1230     public static final BitSet FOLLOW_nodeCmp_in_nodeValue983 = new BitSet(new long[]{0x0000000000000002L});\r
1231     public static final BitSet FOLLOW_cmpOp_in_nodeCmp1003 = new BitSet(new long[]{0x0020000026000000L});\r
1232     public static final BitSet FOLLOW_value_in_nodeCmp1005 = new BitSet(new long[]{0x0000000000000002L});\r
1233     public static final BitSet FOLLOW_Match_in_nodeCmp1023 = new BitSet(new long[]{0x0000010000000000L});\r
1234     public static final BitSet FOLLOW_Regex_in_nodeCmp1025 = new BitSet(new long[]{0x0000000000000002L});\r
1235     public static final BitSet FOLLOW_set_in_cmpOp1050 = new BitSet(new long[]{0x0000000000000002L});\r
1236 \r
1237 }