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