docs: public final EventFilterParser.equality_value_function_return equality_value_function() throws RecognitionException {
          EventFilterParser.equality_value_function_return retval = new EventFilterParser.equality_value_function_return();
          retval.start = input.LT(1);
  
  
          CommonTree root_0 = null;
  
          Token STRING87=null;
          Token TRUE88=null;
          Token FALSE89=null;
          Token NULL90=null;
          EventFilterParser.path_function_return path_function91 =null;
  
  
          CommonTree STRING87_tree=null;
          CommonTree TRUE88_tree=null;
          CommonTree FALSE89_tree=null;
          CommonTree NULL90_tree=null;
          RewriteRuleTokenStream stream_FALSE=new RewriteRuleTokenStream(adaptor,"token FALSE");
          RewriteRuleTokenStream stream_TRUE=new RewriteRuleTokenStream(adaptor,"token TRUE");
          RewriteRuleTokenStream stream_NULL=new RewriteRuleTokenStream(adaptor,"token NULL");
          RewriteRuleTokenStream stream_STRING=new RewriteRuleTokenStream(adaptor,"token STRING");
  
          try {
              // EventFilter.g:173:2: ( STRING -> STRING | TRUE -> TRUE | FALSE -> FALSE | NULL -> NULL | path_function )
              int alt13=5;
              switch ( input.LA(1) ) {
              case STRING:
                  {
                  alt13=1;
                  }
                  break;
              case TRUE:
                  {
                  alt13=2;
                  }
                  break;
              case FALSE:
                  {
                  alt13=3;
                  }
                  break;
              case NULL:
                  {
                  alt13=4;
                  }
                  break;
              case XPATH_FUN_NAME:
                  {
                  alt13=5;
                  }
                  break;
              default:
                  NoViableAltException nvae =
                      new NoViableAltException("", 13, 0, input);
  
                  throw nvae;
  
              }
  
              switch (alt13) {
                  case 1 :
                      // EventFilter.g:173:4: STRING
                      {
                      STRING87=(Token)match(input,STRING,FOLLOW_STRING_in_equality_value_function1038);
                      stream_STRING.add(STRING87);
  
  
                      // AST REWRITE
                      // elements: STRING
                      // 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();
                      // 173:11: -> STRING
                      {
                          adaptor.addChild(root_0,
                          new StringTreeNode(stream_STRING.nextToken())
                          );
  
                      }
  
  
                      retval.tree = root_0;
  
                      }
                      break;
                  case 2 :
                      // EventFilter.g:174:3: TRUE
                      {
                      TRUE88=(Token)match(input,TRUE,FOLLOW_TRUE_in_equality_value_function1051);
                      stream_TRUE.add(TRUE88);
  
  
                      // AST REWRITE
                      // elements: TRUE
                      // 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();
                      // 174:8: -> TRUE
                      {
                          adaptor.addChild(root_0,
                          new TrueValueTreeNode(stream_TRUE.nextToken())
                          );
  
                      }
  
  
                      retval.tree = root_0;
  
                      }
                      break;
                  case 3 :
                      // EventFilter.g:175:3: FALSE
                      {
                      FALSE89=(Token)match(input,FALSE,FOLLOW_FALSE_in_equality_value_function1064);
                      stream_FALSE.add(FALSE89);
  
  
                      // AST REWRITE
                      // elements: FALSE
                      // 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();
                      // 175:9: -> FALSE
                      {
                          adaptor.addChild(root_0,
                          new FalseValueTreeNode(stream_FALSE.nextToken())
                          );
  
                      }
  
  
                      retval.tree = root_0;
  
                      }
                      break;
                  case 4 :
                      // EventFilter.g:176:3: NULL
                      {
                      NULL90=(Token)match(input,NULL,FOLLOW_NULL_in_equality_value_function1077);
                      stream_NULL.add(NULL90);
  
  
                      // AST REWRITE
                      // elements: NULL
                      // 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();
                      // 176:8: -> NULL
                      {
                          adaptor.addChild(root_0,
                          new NullValueTreeNode(stream_NULL.nextToken())
                          );
  
                      }
  
  
                      retval.tree = root_0;
  
                      }
                      break;
                  case 5 :
                      // EventFilter.g:177:3: path_function
                      {
                      root_0 = (CommonTree)adaptor.nil();
  
  
                      pushFollow(FOLLOW_path_function_in_equality_value_function1090);
                      path_function91=path_function();
  
                      state._fsp--;
  
                      adaptor.addChild(root_0, path_function91.getTree());
  
                      }
                      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;
      }