docs: public final EventFilterParser.comparison_function_return comparison_function() throws RecognitionException {
          EventFilterParser.comparison_function_return retval = new EventFilterParser.comparison_function_return();
          retval.start = input.LT(1);
  
  
          CommonTree root_0 = null;
  
          Token EQUALS19=null;
          Token NOT_EQUALS22=null;
          Token GT25=null;
          Token GE28=null;
          Token LT31=null;
          Token LE34=null;
          EventFilterParser.path_function_return path_function18 =null;
  
          EventFilterParser.value_function_return value_function20 =null;
  
          EventFilterParser.path_function_return path_function21 =null;
  
          EventFilterParser.value_function_return value_function23 =null;
  
          EventFilterParser.path_function_return path_function24 =null;
  
          EventFilterParser.compariable_value_function_return compariable_value_function26 =null;
  
          EventFilterParser.path_function_return path_function27 =null;
  
          EventFilterParser.compariable_value_function_return compariable_value_function29 =null;
  
          EventFilterParser.path_function_return path_function30 =null;
  
          EventFilterParser.compariable_value_function_return compariable_value_function32 =null;
  
          EventFilterParser.path_function_return path_function33 =null;
  
          EventFilterParser.compariable_value_function_return compariable_value_function35 =null;
  
  
          CommonTree EQUALS19_tree=null;
          CommonTree NOT_EQUALS22_tree=null;
          CommonTree GT25_tree=null;
          CommonTree GE28_tree=null;
          CommonTree LT31_tree=null;
          CommonTree LE34_tree=null;
          RewriteRuleTokenStream stream_GE=new RewriteRuleTokenStream(adaptor,"token GE");
          RewriteRuleTokenStream stream_GT=new RewriteRuleTokenStream(adaptor,"token GT");
          RewriteRuleTokenStream stream_LT=new RewriteRuleTokenStream(adaptor,"token LT");
          RewriteRuleTokenStream stream_EQUALS=new RewriteRuleTokenStream(adaptor,"token EQUALS");
          RewriteRuleTokenStream stream_NOT_EQUALS=new RewriteRuleTokenStream(adaptor,"token NOT_EQUALS");
          RewriteRuleTokenStream stream_LE=new RewriteRuleTokenStream(adaptor,"token LE");
          RewriteRuleSubtreeStream stream_compariable_value_function=new RewriteRuleSubtreeStream(adaptor,"rule compariable_value_function");
          RewriteRuleSubtreeStream stream_value_function=new RewriteRuleSubtreeStream(adaptor,"rule value_function");
          RewriteRuleSubtreeStream stream_path_function=new RewriteRuleSubtreeStream(adaptor,"rule path_function");
          try {
              // EventFilter.g:129:2: ( path_function EQUALS value_function -> ^( EQUALS path_function value_function ) | path_function NOT_EQUALS value_function -> ^( NOT_EQUALS path_function value_function ) | path_function GT compariable_value_function -> ^( GT path_function compariable_value_function ) | path_function GE compariable_value_function -> ^( GE path_function compariable_value_function ) | path_function LT compariable_value_function -> ^( LT path_function compariable_value_function ) | path_function LE compariable_value_function -> ^( LE path_function compariable_value_function ) )
              int alt6=6;
              int LA6_0 = input.LA(1);
  
              if ( (LA6_0==XPATH_FUN_NAME) ) {
                  int LA6_1 = input.LA(2);
  
                  if ( (LA6_1==33) ) {
                      int LA6_2 = input.LA(3);
  
                      if ( (LA6_2==STRING) ) {
                          int LA6_3 = input.LA(4);
  
                          if ( (LA6_3==34) ) {
                              switch ( input.LA(5) ) {
                              case EQUALS:
                                  {
                                  alt6=1;
                                  }
                                  break;
                              case NOT_EQUALS:
                                  {
                                  alt6=2;
                                  }
                                  break;
                              case GT:
                                  {
                                  alt6=3;
                                  }
                                  break;
                              case GE:
                                  {
                                  alt6=4;
                                  }
                                  break;
                              case LT:
                                  {
                                  alt6=5;
                                  }
                                  break;
                              case LE:
                                  {
                                  alt6=6;
                                  }
                                  break;
                              default:
                                  NoViableAltException nvae =
                                      new NoViableAltException("", 6, 4, input);
  
                                  throw nvae;
  
                              }
  
                          }
                          else {
                              NoViableAltException nvae =
                                  new NoViableAltException("", 6, 3, input);
  
                              throw nvae;
  
                          }
                      }
                      else {
                          NoViableAltException nvae =
                              new NoViableAltException("", 6, 2, input);
  
                          throw nvae;
  
                      }
                  }
                  else {
                      NoViableAltException nvae =
                          new NoViableAltException("", 6, 1, input);
  
                      throw nvae;
  
                  }
              }
              else {
                  NoViableAltException nvae =
                      new NoViableAltException("", 6, 0, input);
  
                  throw nvae;
  
              }
              switch (alt6) {
                  case 1 :
                      // EventFilter.g:129:4: path_function EQUALS value_function
                      {
                      pushFollow(FOLLOW_path_function_in_comparison_function529);
                      path_function18=path_function();
  
                      state._fsp--;
  
                      stream_path_function.add(path_function18.getTree());
  
                      EQUALS19=(Token)match(input,EQUALS,FOLLOW_EQUALS_in_comparison_function531);
                      stream_EQUALS.add(EQUALS19);
  
  
                      pushFollow(FOLLOW_value_function_in_comparison_function533);
                      value_function20=value_function();
  
                      state._fsp--;
  
                      stream_value_function.add(value_function20.getTree());
  
                      // AST REWRITE
                      // elements: value_function, path_function, EQUALS
                      // token labels:
                      // rule labels: retval
                      // token list labels:
                      // rule list labels:
                      // wildcard labels:
                      retval.tree = root_0;
                      RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
  
                      root_0 = (CommonTree)adaptor.nil();
                      // 129:40: -> ^( EQUALS path_function value_function )
                      {
                          // EventFilter.g:129:43: ^( EQUALS path_function value_function )
                          {
                          CommonTree root_1 = (CommonTree)adaptor.nil();
                          root_1 = (CommonTree)adaptor.becomeRoot(
                          new EqualsTreeNode(stream_EQUALS.nextToken())
                          , root_1);
  
                          adaptor.addChild(root_1, stream_path_function.nextTree());
  
                          adaptor.addChild(root_1, stream_value_function.nextTree());
  
                          adaptor.addChild(root_0, root_1);
                          }
  
                      }
  
  
                      retval.tree = root_0;
  
                      }
                      break;
                  case 2 :
                      // EventFilter.g:130:3: path_function NOT_EQUALS value_function
                      {
                      pushFollow(FOLLOW_path_function_in_comparison_function552);
                      path_function21=path_function();
  
                      state._fsp--;
  
                      stream_path_function.add(path_function21.getTree());
  
                      NOT_EQUALS22=(Token)match(input,NOT_EQUALS,FOLLOW_NOT_EQUALS_in_comparison_function554);
                      stream_NOT_EQUALS.add(NOT_EQUALS22);
  
  
                      pushFollow(FOLLOW_value_function_in_comparison_function556);
                      value_function23=value_function();
  
                      state._fsp--;
  
                      stream_value_function.add(value_function23.getTree());
  
                      // AST REWRITE
                      // elements: value_function, path_function, NOT_EQUALS
                      // token labels:
                      // rule labels: retval
                      // token list labels:
                      // rule list labels:
                      // wildcard labels:
                      retval.tree = root_0;
                      RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
  
                      root_0 = (CommonTree)adaptor.nil();
                      // 130:43: -> ^( NOT_EQUALS path_function value_function )
                      {
                          // EventFilter.g:130:46: ^( NOT_EQUALS path_function value_function )
                          {
                          CommonTree root_1 = (CommonTree)adaptor.nil();
                          root_1 = (CommonTree)adaptor.becomeRoot(
                          new NotEqualsTreeNode(stream_NOT_EQUALS.nextToken())
                          , root_1);
  
                          adaptor.addChild(root_1, stream_path_function.nextTree());
  
                          adaptor.addChild(root_1, stream_value_function.nextTree());
  
                          adaptor.addChild(root_0, root_1);
                          }
  
                      }
  
  
                      retval.tree = root_0;
  
                      }
                      break;
                  case 3 :
                      // EventFilter.g:131:3: path_function GT compariable_value_function
                      {
                      pushFollow(FOLLOW_path_function_in_comparison_function575);
                      path_function24=path_function();
  
                      state._fsp--;
  
                      stream_path_function.add(path_function24.getTree());
  
                      GT25=(Token)match(input,GT,FOLLOW_GT_in_comparison_function577);
                      stream_GT.add(GT25);
  
  
                      pushFollow(FOLLOW_compariable_value_function_in_comparison_function579);
                      compariable_value_function26=compariable_value_function();
  
                      state._fsp--;
  
                      stream_compariable_value_function.add(compariable_value_function26.getTree());
  
                      // AST REWRITE
                      // elements: path_function, GT, compariable_value_function
                      // token labels:
                      // rule labels: retval
                      // token list labels:
                      // rule list labels:
                      // wildcard labels:
                      retval.tree = root_0;
                      RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
  
                      root_0 = (CommonTree)adaptor.nil();
                      // 131:47: -> ^( GT path_function compariable_value_function )
                      {
                          // EventFilter.g:131:50: ^( GT path_function compariable_value_function )
                          {
                          CommonTree root_1 = (CommonTree)adaptor.nil();
                          root_1 = (CommonTree)adaptor.becomeRoot(
                          new ComparableTreeNode(stream_GT.nextToken())
                          , root_1);
  
                          adaptor.addChild(root_1, stream_path_function.nextTree());
  
                          adaptor.addChild(root_1, stream_compariable_value_function.nextTree());
  
                          adaptor.addChild(root_0, root_1);
                          }
  
                      }
  
  
                      retval.tree = root_0;
  
                      }
                      break;
                  case 4 :
                      // EventFilter.g:132:3: path_function GE compariable_value_function
                      {
                      pushFollow(FOLLOW_path_function_in_comparison_function598);
                      path_function27=path_function();
  
                      state._fsp--;
  
                      stream_path_function.add(path_function27.getTree());
  
                      GE28=(Token)match(input,GE,FOLLOW_GE_in_comparison_function600);
                      stream_GE.add(GE28);
  
  
                      pushFollow(FOLLOW_compariable_value_function_in_comparison_function602);
                      compariable_value_function29=compariable_value_function();
  
                      state._fsp--;
  
                      stream_compariable_value_function.add(compariable_value_function29.getTree());
  
                      // AST REWRITE
                      // elements: compariable_value_function, path_function, GE
                      // token labels:
                      // rule labels: retval
                      // token list labels:
                      // rule list labels:
                      // wildcard labels:
                      retval.tree = root_0;
                      RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
  
                      root_0 = (CommonTree)adaptor.nil();
                      // 132:47: -> ^( GE path_function compariable_value_function )
                      {
                          // EventFilter.g:132:50: ^( GE path_function compariable_value_function )
                          {
                          CommonTree root_1 = (CommonTree)adaptor.nil();
                          root_1 = (CommonTree)adaptor.becomeRoot(
                          new ComparableTreeNode(stream_GE.nextToken())
                          , root_1);
  
                          adaptor.addChild(root_1, stream_path_function.nextTree());
  
                          adaptor.addChild(root_1, stream_compariable_value_function.nextTree());
  
                          adaptor.addChild(root_0, root_1);
                          }
  
                      }
  
  
                      retval.tree = root_0;
  
                      }
                      break;
                  case 5 :
                      // EventFilter.g:133:3: path_function LT compariable_value_function
                      {
                      pushFollow(FOLLOW_path_function_in_comparison_function621);
                      path_function30=path_function();
  
                      state._fsp--;
  
                      stream_path_function.add(path_function30.getTree());
  
                      LT31=(Token)match(input,LT,FOLLOW_LT_in_comparison_function623);
                      stream_LT.add(LT31);
  
  
                      pushFollow(FOLLOW_compariable_value_function_in_comparison_function625);
                      compariable_value_function32=compariable_value_function();
  
                      state._fsp--;
  
                      stream_compariable_value_function.add(compariable_value_function32.getTree());
  
                      // AST REWRITE
                      // elements: path_function, compariable_value_function, LT
                      // token labels:
                      // rule labels: retval
                      // token list labels:
                      // rule list labels:
                      // wildcard labels:
                      retval.tree = root_0;
                      RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
  
                      root_0 = (CommonTree)adaptor.nil();
                      // 133:47: -> ^( LT path_function compariable_value_function )
                      {
                          // EventFilter.g:133:50: ^( LT path_function compariable_value_function )
                          {
                          CommonTree root_1 = (CommonTree)adaptor.nil();
                          root_1 = (CommonTree)adaptor.becomeRoot(
                          new ComparableTreeNode(stream_LT.nextToken())
                          , root_1);
  
                          adaptor.addChild(root_1, stream_path_function.nextTree());
  
                          adaptor.addChild(root_1, stream_compariable_value_function.nextTree());
  
                          adaptor.addChild(root_0, root_1);
                          }
  
                      }
  
  
                      retval.tree = root_0;
  
                      }
                      break;
                  case 6 :
                      // EventFilter.g:134:3: path_function LE compariable_value_function
                      {
                      pushFollow(FOLLOW_path_function_in_comparison_function644);
                      path_function33=path_function();
  
                      state._fsp--;
  
                      stream_path_function.add(path_function33.getTree());
  
                      LE34=(Token)match(input,LE,FOLLOW_LE_in_comparison_function646);
                      stream_LE.add(LE34);
  
  
                      pushFollow(FOLLOW_compariable_value_function_in_comparison_function648);
                      compariable_value_function35=compariable_value_function();
  
                      state._fsp--;
  
                      stream_compariable_value_function.add(compariable_value_function35.getTree());
  
                      // AST REWRITE
                      // elements: compariable_value_function, LE, path_function
                      // token labels:
                      // rule labels: retval
                      // token list labels:
                      // rule list labels:
                      // wildcard labels:
                      retval.tree = root_0;
                      RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
  
                      root_0 = (CommonTree)adaptor.nil();
                      // 134:47: -> ^( LE path_function compariable_value_function )
                      {
                          // EventFilter.g:134:50: ^( LE path_function compariable_value_function )
                          {
                          CommonTree root_1 = (CommonTree)adaptor.nil();
                          root_1 = (CommonTree)adaptor.becomeRoot(
                          new ComparableTreeNode(stream_LE.nextToken())
                          , root_1);
  
                          adaptor.addChild(root_1, stream_path_function.nextTree());
  
                          adaptor.addChild(root_1, stream_compariable_value_function.nextTree());
  
                          adaptor.addChild(root_0, root_1);
                          }
  
                      }
  
  
                      retval.tree = root_0;
  
                      }
                      break;
  
              }
              retval.stop = input.LT(-1);
  
  
              retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
              adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
  
          }
          catch (RecognitionException re) {
              reportError(re);
              recover(input,re);
      	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
  
          }
  
          finally {
          	// do for sure before leaving
          }
          return retval;
      }