docs: public final QueryParser.value_return value() throws RecognitionException {
          QueryParser.value_return retval = new QueryParser.value_return();
          retval.start = input.LT(1);
  
          CommonTree root_0 = null;
  
          Token String78=null;
          Token INT82=null;
          Token FLOAT83=null;
          QueryParser.t_return t79 = null;
  
          QueryParser.f_return f80 = null;
  
          QueryParser.nil_return nil81 = null;
  
  
          CommonTree String78_tree=null;
          CommonTree INT82_tree=null;
          CommonTree FLOAT83_tree=null;
  
          try {
              // src/riemann/Query.g:69:7: ( ( String | t | f | nil | INT | FLOAT ) )
              // src/riemann/Query.g:69:10: ( String | t | f | nil | INT | FLOAT )
              {
              root_0 = (CommonTree)adaptor.nil();
  
              // src/riemann/Query.g:69:10: ( String | t | f | nil | INT | FLOAT )
              int alt30=6;
              switch ( input.LA(1) ) {
              case String:
                  {
                  alt30=1;
                  }
                  break;
              case 27:
                  {
                  alt30=2;
                  }
                  break;
              case 28:
                  {
                  alt30=3;
                  }
                  break;
              case 29:
              case 30:
                  {
                  alt30=4;
                  }
                  break;
              case INT:
                  {
                  alt30=5;
                  }
                  break;
              case FLOAT:
                  {
                  alt30=6;
                  }
                  break;
              default:
                  NoViableAltException nvae =
                      new NoViableAltException("", 30, 0, input);
  
                  throw nvae;
              }
  
              switch (alt30) {
                  case 1 :
                      // src/riemann/Query.g:69:11: String
                      {
                      String78=(Token)match(input,String,FOLLOW_String_in_value523); 
                      String78_tree = (CommonTree)adaptor.create(String78);
                      adaptor.addChild(root_0, String78_tree);
  
  
                      }
                      break;
                  case 2 :
                      // src/riemann/Query.g:69:20: t
                      {
                      pushFollow(FOLLOW_t_in_value527);
                      t79=t();
  
                      state._fsp--;
  
                      adaptor.addChild(root_0, t79.getTree());
  
                      }
                      break;
                  case 3 :
                      // src/riemann/Query.g:69:24: f
                      {
                      pushFollow(FOLLOW_f_in_value531);
                      f80=f();
  
                      state._fsp--;
  
                      adaptor.addChild(root_0, f80.getTree());
  
                      }
                      break;
                  case 4 :
                      // src/riemann/Query.g:69:28: nil
                      {
                      pushFollow(FOLLOW_nil_in_value535);
                      nil81=nil();
  
                      state._fsp--;
  
                      adaptor.addChild(root_0, nil81.getTree());
  
                      }
                      break;
                  case 5 :
                      // src/riemann/Query.g:69:34: INT
                      {
                      INT82=(Token)match(input,INT,FOLLOW_INT_in_value539); 
                      INT82_tree = (CommonTree)adaptor.create(INT82);
                      adaptor.addChild(root_0, INT82_tree);
  
  
                      }
                      break;
                  case 6 :
                      // src/riemann/Query.g:69:40: FLOAT
                      {
                      FLOAT83=(Token)match(input,FLOAT,FOLLOW_FLOAT_in_value543); 
                      FLOAT83_tree = (CommonTree)adaptor.create(FLOAT83);
                      adaptor.addChild(root_0, FLOAT83_tree);
  
  
                      }
                      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 {
          }
          return retval;
      }