docs: public final QueryParser.regex_match_return regex_match() throws RecognitionException {
          QueryParser.regex_match_return retval = new QueryParser.regex_match_return();
          retval.start = input.LT(1);
  
          CommonTree root_0 = null;
  
          Token WS41=null;
          Token REGEX_MATCH42=null;
          Token WS43=null;
          QueryParser.field_return field40 = null;
  
          QueryParser.value_return value44 = null;
  
  
          CommonTree WS41_tree=null;
          CommonTree REGEX_MATCH42_tree=null;
          CommonTree WS43_tree=null;
  
          try {
              // src/riemann/Query.g:56:2: ( field ( WS )* REGEX_MATCH ( WS )* value )
              // src/riemann/Query.g:56:4: field ( WS )* REGEX_MATCH ( WS )* value
              {
              root_0 = (CommonTree)adaptor.nil();
  
              pushFollow(FOLLOW_field_in_regex_match376);
              field40=field();
  
              state._fsp--;
  
              adaptor.addChild(root_0, field40.getTree());
              // src/riemann/Query.g:56:10: ( WS )*
              loop15:
              do {
                  int alt15=2;
                  int LA15_0 = input.LA(1);
  
                  if ( (LA15_0==WS) ) {
                      alt15=1;
                  }
  
  
                  switch (alt15) {
              	case 1 :
              	    // src/riemann/Query.g:56:10: WS
              	    {
              	    WS41=(Token)match(input,WS,FOLLOW_WS_in_regex_match378); 
              	    WS41_tree = (CommonTree)adaptor.create(WS41);
              	    adaptor.addChild(root_0, WS41_tree);
  
  
              	    }
              	    break;
  
              	default :
              	    break loop15;
                  }
              } while (true);
  
              REGEX_MATCH42=(Token)match(input,REGEX_MATCH,FOLLOW_REGEX_MATCH_in_regex_match381); 
              REGEX_MATCH42_tree = (CommonTree)adaptor.create(REGEX_MATCH42);
              root_0 = (CommonTree)adaptor.becomeRoot(REGEX_MATCH42_tree, root_0);
  
              // src/riemann/Query.g:56:27: ( WS )*
              loop16:
              do {
                  int alt16=2;
                  int LA16_0 = input.LA(1);
  
                  if ( (LA16_0==WS) ) {
                      alt16=1;
                  }
  
  
                  switch (alt16) {
              	case 1 :
              	    // src/riemann/Query.g:56:27: WS
              	    {
              	    WS43=(Token)match(input,WS,FOLLOW_WS_in_regex_match384); 
              	    WS43_tree = (CommonTree)adaptor.create(WS43);
              	    adaptor.addChild(root_0, WS43_tree);
  
  
              	    }
              	    break;
  
              	default :
              	    break loop16;
                  }
              } while (true);
  
              pushFollow(FOLLOW_value_in_regex_match387);
              value44=value();
  
              state._fsp--;
  
              adaptor.addChild(root_0, value44.getTree());
  
              }
  
              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 {
          }
          return retval;
      }