DeSR Dependency Parser

ixe/io/pstream.h

Go to the documentation of this file.

/* $Id: pstream.h,v 1.3 2007-07-26 15:52:49 attardi Exp $
PStreams - POSIX Process I/O for C++
Copyright (C) 2001,2002,2003,2004 Jonathan Wakely

This file is part of PStreams.

PStreams is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as
published by the Free Software Foundation; either version 2.1 of
the License, or (at your option) any later version.

PStreams is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with PStreams; if not, write to the Free Software Foundation, Inc.,
59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef REDI_PSTREAM_H_SEEN
#define REDI_PSTREAM_H_SEEN

#if defined(__GNUC__) && (__GNUC__ < 3) 

#define PSTREAMS_VERSION 0x0011   // 0.17

// check whether to provide pstream
// popen() needs to use bidirectional pipe
#if ! defined(REDI_PSTREAMS_POPEN_USES_BIDIRECTIONAL_PIPE)
#if defined(__FreeBSD__) && __FreeBSD__ >= 3
# define REDI_PSTREAMS_POPEN_USES_BIDIRECTIONAL_PIPE 1
#elif defined(__NetBSD_Version__) && __NetBSD_Version__ >= 0x01040000
# define REDI_PSTREAMS_POPEN_USES_BIDIRECTIONAL_PIPE 1
#endif
#endif


#include <iostream>
#include <istream.h>
#include <ostream.h>
#include <string>
#include <cstdio>
#include <cerrno>

// TODO add buffering to pstreambuf

// TODO replace popen() with handrolled version


// backward compatibility
namespace std {
template<typename _CharT>
class char_traits : public string_char_traits<_CharT>
{
public:
  typedef _CharT            char_type;
  // Unsigned as wint_t is unsigned.
  typedef int               int_type;
  typedef streampos         pos_type;
  typedef streamoff         off_type;

  static char_type to_char_type(const int_type& __c) { return char_type(__c); }

  static int_type to_int_type(const char_type& __c) { return int_type(__c); }

  static bool eq_int_type(const int_type& __c1, const int_type& __c2)
  { return __c1 == __c2; }

  static int_type eof() { return static_cast<int_type>(EOF); }

  static int_type not_eof(const int_type& __c)
      { return (__c == eof()) ? 0 : __c; }
};
template<typename _CharT, typename _Traits>
class basic_streambuf : public streambuf
{ }; 
template<typename _CharT, typename _Traits>
class basic_ios : public ios
{
public:
  basic_ios(streambuf* sb = 0, ostream* tie_to = 0) : ios(sb, tie_to) { }
};
template<typename _CharT, typename _Traits>
class basic_istream : public istream
{
public:
  basic_istream() : istream() { }
  basic_istream(streambuf* sb, ostream*tied=NULL) : istream(sb, tied) { }
};
template<typename _CharT, typename _Traits>
class basic_ostream : public ostream
{ };
template<typename _CharT, typename _Traits>
class basic_iostream : public iostream
{ };
} // namespace std

namespace IXE {
namespace io
{
  std::string
  openmode2str(std::ios::openmode mode);
  // TODO extend openmode2str() to handle all openmode values

  template <typename CharT, typename Traits>
    class basic_pstreambuf : public std::basic_streambuf<CharT, Traits>
    {
    public:
      // Type definitions for dependent types
      typedef CharT                             char_type;
      typedef Traits                            traits_type;
      typedef typename traits_type::int_type    int_type;
      typedef typename traits_type::off_type    off_type;
      typedef typename traits_type::pos_type    pos_type;

      basic_pstreambuf();

      basic_pstreambuf(const std::string& command, std::ios::openmode mode);

      ~basic_pstreambuf();

      basic_pstreambuf*
      open(const std::string& command, std::ios::openmode mode);

      basic_pstreambuf*
      close();

      bool
      is_open() const;

    protected:
      int_type
      overflow(int_type c);

      int_type
      uflow();

      int_type
      underflow();

      int_type
      pbackfail(int_type c = traits_type::eof());

      std::streamsize
      write(char_type* s, std::streamsize n);

      std::streamsize
      read(char_type* s, std::streamsize n);

      bool
      write(char_type c);

      bool
      read(char_type& c);

    private:
      basic_pstreambuf(const basic_pstreambuf&);
      basic_pstreambuf& operator=(const basic_pstreambuf&);

      FILE*         file_;
      char_type     char_buf_;
      bool          take_from_buf_;
    };


  template <typename CharT, typename Traits = std::char_traits<CharT> >
    class basic_ipstream : public std::basic_istream<CharT, Traits>
    {
      typedef std::basic_istream<CharT, Traits>     istream_type;
      typedef basic_pstreambuf<CharT, Traits>       streambuf_type;

    public:
      basic_ipstream();

      basic_ipstream(const std::string& command, std::ios::openmode mode = ios::in);

      ~basic_ipstream() { }

      void
      open(const std::string& command, std::ios::openmode mode = std::ios::in);

      void
      close();

      bool
      is_open() const;

      const std::string&
      command() const;

    private:
      std::string       command_;
      streambuf_type    buf_;
    };


  template <typename CharT, typename Traits = std::char_traits<CharT> >
    class basic_opstream : public std::basic_ostream<CharT, Traits>
    {
      typedef std::basic_ostream<CharT, Traits>     ostream_type;
      typedef basic_pstreambuf<CharT, Traits>       streambuf_type;

    public:
      basic_opstream();

      basic_opstream(const std::string& command, std::ios::openmode mode = std::ios::out);

      ~basic_opstream() { }

      void
      open(const std::string& command, std::ios::openmode mode = std::ios::out);

      void
      close();

      bool
      is_open() const;

      const std::string&
      command() const;

    private:
      std::string       command_;
      streambuf_type    buf_;
    };

  typedef basic_ipstream<char> ipstream;
  typedef basic_opstream<char> opstream;


  // member definitions for pstreambuf

  template <typename C, typename T>
    inline
    basic_pstreambuf<C,T>::basic_pstreambuf()
    : file_(0)
    , take_from_buf_(false)
    { }

  template <typename C, typename T>
    inline
    basic_pstreambuf<C,T>::basic_pstreambuf( const std::string& command, std::ios::openmode mode )
    : file_(0)
    , take_from_buf_(false)
    {
      this->open(command, mode);
    }

  template <typename C, typename T>
    inline
    basic_pstreambuf<C,T>::~basic_pstreambuf()
    {
      this->close();
    }

  template <typename C, typename T>
    inline basic_pstreambuf<C,T>*
    basic_pstreambuf<C,T>::open( const std::string& command, std::ios::openmode mode )
    {
      basic_pstreambuf<C,T>* ret = NULL;
      if (!this->is_open())
      {
          file_ = ::popen(command.c_str(), openmode2str(mode).c_str());
          if (this->is_open())
              ret = this;
      }
      return ret;
    }

  template <typename C, typename T>
    inline basic_pstreambuf<C,T>*
    basic_pstreambuf<C,T>::close()
    {
      basic_pstreambuf<C,T>* ret = NULL;
      if (this->is_open())
      {
        errno = 0;
        ::pclose(file_);
        if (errno==0)
        {
          ret = this;
          file_ = 0;
        }
      }
      return ret;
    }

  template <typename C, typename T>
    inline bool
    basic_pstreambuf<C,T>::is_open() const
    {
      return bool(file_);
    }


  template <typename C, typename T>
    typename basic_pstreambuf<C,T>::int_type
    basic_pstreambuf<C,T>::overflow(int_type c)
    {
      if (!traits_type::eq_int_type(c, traits_type::eof()))
      {
        if (!this->write(traits_type::to_char_type(c)))
          return traits_type::eof();
        else
          return c;
      }
      return traits_type::not_eof(c);
    }

  template <typename C, typename T>
    typename basic_pstreambuf<C,T>::int_type
    basic_pstreambuf<C,T>::uflow()
    {
      if (take_from_buf_)
      {
        take_from_buf_ = false;
        return traits_type::to_int_type(char_buf_);
      }
      else
      {
        char_type c;

        if (!this->read(c))
        {
          return traits_type::eof();
        }
        else
        {
          char_buf_ = c;
          return traits_type::to_int_type(c);
        }
      }
    }

  template <typename C, typename T>
    typename basic_pstreambuf<C,T>::int_type
    basic_pstreambuf<C,T>::underflow()
    {
      if (take_from_buf_)
      {
        return traits_type::to_int_type(char_buf_);
      }
      else
      {
        char_type c;

        if (!this->read(c))
        {
          return traits_type::eof();
        }
        else
        {
          take_from_buf_ = true;
          char_buf_ = c;
          return traits_type::to_int_type(c);
        }
      }
    }

  template <typename C, typename T>
    typename basic_pstreambuf<C,T>::int_type
    basic_pstreambuf<C,T>::pbackfail(int_type c)
    {
      if (!take_from_buf_)
      {
        if (!traits_type::eq_int_type(c, traits_type::eof()))
        {
          char_buf_ = traits_type::to_char_type(c); 
        }
        take_from_buf_ = true;
        return traits_type::to_int_type(char_buf_);
      }
      else
      {
         return traits_type::eof();
      }
    }

  template <typename C, typename T>
    inline bool
    basic_pstreambuf<C,T>::write(char_type c)
    {
      return (this->write(&c, 1) == 1);
    }

  template <typename C, typename T>
    inline bool
    basic_pstreambuf<C,T>::read(char_type& c)
    {
      return (this->read(&c, 1) == 1);
    }

  template <typename C, typename T>
    inline std::streamsize
    basic_pstreambuf<C,T>::write(char_type* s, std::streamsize n)
    {
      return (file_ ? std::fwrite(s, sizeof(char_type), n, file_) : 0);
    }

  template <typename C, typename T>
    inline std::streamsize
    basic_pstreambuf<C,T>::read(char_type* s, std::streamsize n)
    {
      return (file_ ? std::fread(s, sizeof(char_type), n, file_) : 0);
    }


  // member definitions for basic_ipstream

  template <typename C, typename T>
    inline
    basic_ipstream<C,T>::basic_ipstream()
    : istream_type(NULL)
    , command_()
    , buf_()
    {
      this->init(&buf_);
    }
    
  template <typename C, typename T>
    inline
    basic_ipstream<C,T>::basic_ipstream( const std::string& command, std::ios::openmode mode )
    : istream_type(NULL)
    , command_(command)
    , buf_()
    {
      this->init(&buf_);
      this->open(command_, mode);
    }

  template <typename C, typename T>
    inline void
    basic_ipstream<C,T>::open( const std::string& command, std::ios::openmode mode )
    {
      if (!buf_.open((command_=command), (mode|std::ios::in)))
        this->setstate(std::ios::failbit);
    }

  template <typename C, typename T>
    inline void
    basic_ipstream<C,T>::close()
    {
      if (!buf_.close())
        this->setstate(std::ios::failbit);
    }

  template <typename C, typename T>
    inline bool
    basic_ipstream<C,T>::is_open() const
    {
      return buf_.is_open();
    }

  template <typename C, typename T>
    inline const std::string&
    basic_ipstream<C,T>::command() const
    {
      return command_;
    }


  // member definitions for basic_opstream

  template <typename C, typename T>
    inline
    basic_opstream<C,T>::basic_opstream()
    : ostream_type(NULL)
    , command_()
    , buf_()
    {
      this->init(&buf_);
    }

  template <typename C, typename T>
    inline
    basic_opstream<C,T>::basic_opstream( const std::string& command, std::ios::openmode mode )
    : ostream_type(NULL)
    , command_(command)
    , buf_()
    {
      this->init(&buf_);
      this->open(command_, mode);
    }

  template <typename C, typename T>
    inline void
    basic_opstream<C,T>::open( const std::string& command, std::ios::openmode mode )
    {
      if (!buf_.open((command_=command), (mode|std::ios::out)))
        this->setstate(std::ios::failbit);
    }

  template <typename C, typename T>
    inline void
    basic_opstream<C,T>::close()
    {
      if (!buf_.close())
        this->setstate(std::ios::failbit);
    }

  template <typename C, typename T>
    inline bool
    basic_opstream<C,T>::is_open() const
    {
      return buf_.is_open();
    }

  template <typename C, typename T>
    inline const std::string&
    basic_opstream<C,T>::command() const
    {
      return command_;
    }


  // non-member function definitions

  inline std::string
  openmode2str( std::ios::openmode mode )
  {
    using std::ios;
    // restrict to the openmodes that pstreambuf honours
    mode &= (ios::in|ios::out);
    if (mode == ios::in)
      return "r";
    else if (mode == ios::out)
      return "w";
    else if (mode == (ios::in|ios::out))
      return "r+";
    else
      return "";
  }

#if REDI_PSTREAMS_POPEN_USES_BIDIRECTIONAL_PIPE

  template <typename CharT, typename Traits = std::char_traits<CharT> >
    class basic_pstream : public std::basic_iostream<CharT, Traits>
    {
      typedef std::basic_iostream<CharT, Traits>    iostream_type;
      typedef basic_pstreambuf<CharT, Traits>       streambuf_type;

    public:
      basic_pstream();

      basic_pstream(const std::string& command, std::ios::openmode mode = std::ios::in|std::ios::out);

      ~basic_pstream() { }

      void
      open(const std::string& command, std::ios::openmode mode = std::ios::in|std::ios::out);

      void
      close();

      bool
      is_open() const;

      const std::string&
      command() const;

    private:
      std::string command_;
      streambuf_type buf_;
    };

  typedef basic_pstream<char> pstream;


  // member definitions for basic_pstream

  template <typename C, typename T>
    basic_pstream<C,T>::basic_pstream()
    : iostream_type(NULL)
    , command_()
    , buf_()
    {
      this->init(&buf_);
    }

  template <typename C, typename T>
    basic_pstream<C,T>::basic_pstream(const std::string& command, std::ios::openmode mode)
    : iostream_type(NULL)
    , command_(command)
    , buf_()
    {
      this->init(&buf_);
      this->open(command_, mode);
    }

  template <typename C, typename T>
    inline void
    basic_pstream<C,T>::open(const std::string& command, std::ios::openmode mode)
    {
      if (!buf_.open((command_=command), mode))
        this->setstate(std::ios::failbit);
    }

  template <typename C, typename T>
    inline void
    basic_pstream<C,T>::close()
    {
      if (!buf_.close())
        this->setstate(std::ios::failbit);
    }

  template <typename C, typename T>
    inline bool
    basic_pstream<C,T>::is_open() const
    {
      return buf_.is_open();
    }

  template <typename C, typename T>
    inline const std::string&
    basic_pstream<C,T>::command() const
    {
      return command_;
    }

#endif //  REDI_PSTREAMS_POPEN_USES_BIDIRECTIONAL_PIPE

} // namespace io
} // namespace IXE


#else //  !defined(__GNUC__) || (__GNUC__ >= 3) 

#include <ios>
#include <streambuf>
#include <istream>
#include <ostream>
#include <string>
#include <vector>
#include <algorithm>    // for min()
#include <cstring>      // for memcpy(), memmove() etc.
#include <cerrno>       // for errno
#include <cstddef>      // for size_t
#include <cstdlib>      // for exit()
#include <sys/types.h>  // for pid_t
#include <sys/wait.h>   // for waitpid()
#include <unistd.h>     // for pipe() fork() exec() and filedes functions
#include <signal.h>     // for kill()
#if REDI_EVISCERATE_PSTREAMS
#include <stdio.h>       // for FILE, fdopen()
#endif


#define PSTREAMS_VERSION 0x0050   // 0.5.0

namespace IXE {
namespace io
{
  struct pstreams
  {
    typedef std::ios::openmode           pmode;

    typedef std::vector<std::string>          argv_type;

    static const pmode pstdin  = std::ios::out; 
    static const pmode pstdout = std::ios::in;  
    static const pmode pstderr = std::ios::app; 

  protected:
    enum { bufsz = 32 };  
    enum { pbsz  = 2 };   
  };

  template <typename CharT, typename Traits = std::char_traits<CharT> >
    class basic_pstreambuf
    : public std::basic_streambuf<CharT, Traits>
    , public pstreams
    {
    public:
      // Type definitions for dependent types
      typedef CharT                             char_type;
      typedef Traits                            traits_type;
      typedef typename traits_type::int_type    int_type;
      typedef typename traits_type::off_type    off_type;
      typedef typename traits_type::pos_type    pos_type;
      typedef int                               fd_type;
      typedef fd_type                           fd_t;

      basic_pstreambuf();

      basic_pstreambuf(const std::string& command, pmode mode);

      basic_pstreambuf( const std::string& file,
                        const argv_type& argv,
                        pmode mode );

      ~basic_pstreambuf();

      basic_pstreambuf*
      open(const std::string& command, pmode mode);

      basic_pstreambuf*
      open(const std::string& file, const argv_type& argv, pmode mode);

      basic_pstreambuf*
      close();

      basic_pstreambuf*
      kill(int signal = SIGTERM);

      void
      peof();

      bool
      read_err(bool readerr = true);

      bool
      is_open() const;

      bool
      exited();

#if REDI_EVISCERATE_PSTREAMS
      std::size_t
      fopen(std::FILE*& in, std::FILE*& out, std::FILE*& err);
#endif

      int
      status() const;

      int
      error() const;

    protected:
      int_type
      overflow(int_type c);

      int_type
      underflow();

      int_type
      pbackfail(int_type c = traits_type::eof());

      int
      sync();

      std::streamsize
      xsputn(const char_type* s, std::streamsize n);

      std::streamsize
      write(char_type* s, std::streamsize n);

      std::streamsize
      read(char_type* s, std::streamsize n);

    protected:
      enum buf_read_src { rsrc_out = 0, rsrc_err = 1 };

      pid_t
      fork(pmode mode);

      int
      wait(bool nohang = false);

      fd_type&
      wpipe();

      fd_type&
      rpipe();

      fd_type&
      rpipe(buf_read_src which);

      void
      create_buffers(pmode mode);

      void
      destroy_buffers(pmode mode);

      bool
      empty_buffer();

      bool
      fill_buffer();

      char_type*
      rbuffer();

      buf_read_src
      switch_read_buffer(buf_read_src);

    private:
      basic_pstreambuf(const basic_pstreambuf&);
      basic_pstreambuf& operator=(const basic_pstreambuf&);

      void
      init_rbuffers();

      pid_t         ppid_;        // pid of process
      fd_type       wpipe_;       // pipe used to write to process' stdin
      fd_type       rpipe_[2];    // two pipes to read from, stdout and stderr
      char_type*    wbuffer_;
      char_type*    rbuffer_[2];
      char_type*    rbufstate_[3];
      buf_read_src  rsrc_;
      int           status_;      // hold exit status of child process
      int           error_;       // hold errno if fork() or exec() fails
    };

  template <typename CharT, typename Traits = std::char_traits<CharT> >
    class pstream_common
    : virtual public std::basic_ios<CharT, Traits>
    , virtual public pstreams
    {
    protected:
      typedef basic_pstreambuf<CharT, Traits>       streambuf_type;

      pstream_common();

      pstream_common(const std::string& command, pmode mode);

      pstream_common( const std::string& file,
                      const argv_type& argv,
                      pmode mode );

      virtual
      ~pstream_common() = 0;

      void
      do_open(const std::string& command, pmode mode);

      void
      do_open(const std::string& file, const argv_type& argv, pmode mode);

    public:
      void
      close();

      bool
      is_open() const;

      const std::string&
      command() const;

      streambuf_type*
      rdbuf() const;

#if REDI_EVISCERATE_PSTREAMS
      std::size_t
      fopen(std::FILE*& in, std::FILE*& out, std::FILE*& err);
#endif

    protected:
      std::string       command_; 
      streambuf_type    buf_;     
    };


  template <typename CharT, typename Traits = std::char_traits<CharT> >
    class basic_ipstream
    : public std::basic_istream<CharT, Traits>
    , public pstream_common<CharT, Traits>
    , virtual public pstreams
    {
      typedef std::basic_istream<CharT, Traits>     istream_type;
      typedef pstream_common<CharT, Traits>         pbase_type;

      using pbase_type::buf_;  // declare name in this scope

    public:
      typedef typename pbase_type::pmode            pmode;

      typedef typename pbase_type::argv_type        argv_type;

      basic_ipstream()
      : istream_type(NULL), pbase_type()
      { }

      basic_ipstream(const std::string& command, pmode mode = pstdout)
      : istream_type(NULL), pbase_type(command, mode|pstdout)
      { }

      basic_ipstream( const std::string& file,
                      const argv_type& argv,
                      pmode mode = pstdout )
      : istream_type(NULL), pbase_type(file, argv, mode|pstdout)
      { }

      ~basic_ipstream()
      { }

      void
      open(const std::string& command, pmode mode = pstdout)
      {
        this->do_open(command, mode|pstdout);
      }

      void
      open( const std::string& file,
            const argv_type& argv,
            pmode mode = pstdout )
      {
        this->do_open(file, argv, mode|pstdout);
      }

      basic_ipstream&
      out()
      {
        this->buf_.read_err(false);
        return *this;
      }

      basic_ipstream&
      err()
      {
        this->buf_.read_err(true);
        return *this;
      }
    };


  template <typename CharT, typename Traits = std::char_traits<CharT> >
    class basic_opstream
    : public std::basic_ostream<CharT, Traits>
    , public pstream_common<CharT, Traits>
    , virtual public pstreams
    {
      typedef std::basic_ostream<CharT, Traits>     ostream_type;
      typedef pstream_common<CharT, Traits>         pbase_type;

      using pbase_type::buf_;  // declare name in this scope

    public:
      typedef typename pbase_type::pmode            pmode;

      typedef typename pbase_type::argv_type        argv_type;

      basic_opstream()
      : ostream_type(NULL), pbase_type()
      { }

      basic_opstream(const std::string& command, pmode mode = pstdin)
      : ostream_type(NULL), pbase_type(command, mode|pstdin)
      { }

      basic_opstream( const std::string& file,
                      const argv_type& argv,
                      pmode mode = pstdin )
      : ostream_type(NULL), pbase_type(file, argv, mode|pstdin)
      { }

      ~basic_opstream() { }

      void
      open(const std::string& command, pmode mode = pstdin)
      {
        this->do_open(command, mode|pstdin);
      }

      void
      open( const std::string& file,
            const argv_type& argv,
            pmode mode = pstdin)
      {
        this->do_open(file, argv, mode|pstdin);
      }
    };


  template <typename CharT, typename Traits = std::char_traits<CharT> >
    class basic_pstream
    : public std::basic_iostream<CharT, Traits>
    , public pstream_common<CharT, Traits>
    , virtual public pstreams
    {
      typedef std::basic_iostream<CharT, Traits>    iostream_type;
      typedef pstream_common<CharT, Traits>         pbase_type;

      using pbase_type::buf_;  // declare name in this scope

    public:
      typedef typename pbase_type::pmode            pmode;

      typedef typename pbase_type::argv_type        argv_type;

      basic_pstream()
      : iostream_type(NULL), pbase_type()
      { }

      basic_pstream( const std::string& command,
                     pmode mode = pstdout|pstdin )
      : iostream_type(NULL), pbase_type(command, mode)
      { }

      basic_pstream( const std::string& file,
                     const argv_type& argv,
                     pmode mode = pstdout|pstdin )
      : iostream_type(NULL), pbase_type(file, argv, mode)
      { }

      ~basic_pstream() { }

      void
      open(const std::string& command, pmode mode = pstdout|pstdin)
      {
        this->do_open(command, mode);
      }

      void
      open( const std::string& file,
            const argv_type& argv,
            pmode mode = pstdout|pstdin )
      {
        this->do_open(file, argv, mode);
      }

      basic_pstream&
      out()
      {
        this->buf_.read_err(false);
        return *this;
      }

      basic_pstream&
      err()
      {
        this->buf_.read_err(true);
        return *this;
      }
    };


  template <typename CharT, typename Traits = std::char_traits<CharT> >
    class basic_rpstream
    : public std::basic_ostream<CharT, Traits>
    , private std::basic_istream<CharT, Traits>
    , private pstream_common<CharT, Traits>
    , virtual public pstreams
    {
      typedef std::basic_ostream<CharT, Traits>     ostream_type;
      typedef std::basic_istream<CharT, Traits>     istream_type;
      typedef pstream_common<CharT, Traits>         pbase_type;

      using pbase_type::buf_;  // declare name in this scope

    public:
      typedef typename pbase_type::pmode            pmode;

      typedef typename pbase_type::argv_type        argv_type;

      basic_rpstream()
      : ostream_type(NULL) , istream_type(NULL) , pbase_type()
      { }

      basic_rpstream(const std::string& command, pmode mode = pstdout|pstdin)
      : ostream_type(NULL) , istream_type(NULL) , pbase_type(command, mode)
      { }

      basic_rpstream( const std::string& file,
                      const argv_type& argv,
                      pmode mode = pstdout|pstdin )
      : ostream_type(NULL), istream_type(NULL), pbase_type(file, argv, mode)
      { }

      ~basic_rpstream() { }

      void
      open(const std::string& command, pmode mode = pstdout|pstdin)
      {
        this->do_open(command, mode);
      }

      void
      open( const std::string& file,
            const argv_type& argv,
            pmode mode = pstdout|pstdin )
      {
        this->do_open(file, argv, mode);
      }

      istream_type&
      out()
      {
        this->buf_.read_err(false);
        return *this;
      }

      istream_type&
      err()
      {
        this->buf_.read_err(true);
        return *this;
      }
    };


  typedef basic_pstreambuf<char> pstreambuf;
  typedef basic_ipstream<char> ipstream;
  typedef basic_opstream<char> opstream;
  typedef basic_pstream<char> pstream;
  typedef basic_rpstream<char> rpstream;


  template <typename C, typename T>
    inline std::basic_ostream<C,T>&
    peof(std::basic_ostream<C,T>& s)
    {
      typedef basic_pstreambuf<C,T> pstreambuf;
      if (pstreambuf* p = dynamic_cast<pstreambuf*>(s.rdbuf()))
        p->peof();
      return s;
    }


  /*
   * member definitions for pstreambuf
   */


  template <typename C, typename T>
    inline
    basic_pstreambuf<C,T>::basic_pstreambuf()
    : ppid_(-1)   // initialise to -1 to indicate no process run yet.
    , wpipe_(-1)
    , wbuffer_(NULL)
    , rsrc_(rsrc_out)
    , status_(-1)
    , error_(0)
    {
      init_rbuffers();
    }

  template <typename C, typename T>
    inline
    basic_pstreambuf<C,T>::basic_pstreambuf(const std::string& command, pmode mode)
    : ppid_(-1)   // initialise to -1 to indicate no process run yet.
    , wpipe_(-1)
    , wbuffer_(NULL)
    , rsrc_(rsrc_out)
    , status_(-1)
    , error_(0)
    {
      init_rbuffers();
      open(command, mode);
    }

  template <typename C, typename T>
    inline
    basic_pstreambuf<C,T>::basic_pstreambuf( const std::string& file,
                                             const argv_type& argv,
                                             pmode mode )
    : ppid_(-1)   // initialise to -1 to indicate no process run yet.
    , wpipe_(-1)
    , wbuffer_(NULL)
    , rsrc_(rsrc_out)
    , status_(-1)
    , error_(0)
    {
      init_rbuffers();
      open(file, argv, mode);
    }

  template <typename C, typename T>
    inline
    basic_pstreambuf<C,T>::~basic_pstreambuf()
    {
      close();
    }

  template <typename C, typename T>
    basic_pstreambuf<C,T>*
    basic_pstreambuf<C,T>::open(const std::string& command, pmode mode)
    {
      basic_pstreambuf<C,T>* ret = NULL;

      if (!is_open())
      {
        switch(fork(mode))
        {
          case 0 :
          {
            // this is the new process, exec command
            ::execlp("sh", "sh", "-c", command.c_str(), (void*)NULL);

            // can only reach this point if exec() failed

            // parent can get exit code from waitpid()
            ::_exit(errno);
            // using std::exit() would make static dtors run twice
          }
          case -1 :
          {
            // couldn't fork, error already handled in pstreambuf::fork()
            break;
          }
          default :
          {
            // this is the parent process
            // activate buffers
            create_buffers(mode);
            ret = this;
          }
        }
      }
      return ret;
    }

  template <typename C, typename T>
    basic_pstreambuf<C,T>*
    basic_pstreambuf<C,T>::open( const std::string& file,
                                 const argv_type& argv,
                                 pmode mode )
    {
      basic_pstreambuf<C,T>* ret = NULL;

      if (!is_open())
      {
        switch(fork(mode))
        {
          case 0 :
          {
            // this is the new process, exec command

            char** arg_v = new char*[argv.size()+1];
            for (std::size_t i = 0; i < argv.size(); ++i)
            {
              const std::string& src = argv[i];
              char*& dest = arg_v[i];
              dest = new char[src.size()+1];
              dest[ src.copy(dest, src.size()) ] = '\0';
            }
            arg_v[argv.size()] = NULL;

            ::execvp(file.c_str(), arg_v);

            // can only reach this point if exec() failed

            // parent can get exit code from waitpid()
            ::_exit(errno);
            // using std::exit() would make static dtors run twice
          }
          case -1 :
          {
            // couldn't fork, error already handled in pstreambuf::fork()
            break;
          }
          default :
          {
            // this is the parent process
            // activate buffers
            create_buffers(mode);
            ret = this;
          }
        }
      }
      return ret;
    }

  inline void
  close_fd_array(int* filedes, std::size_t count)
  {
    for (std::size_t i = 0; i < count; ++i)
      if (filedes[i] >= 0)
        if (::close(filedes[i]) == 0)
          filedes[i] = -1;
  }

  template <typename C, typename T>
    pid_t
    basic_pstreambuf<C,T>::fork(pmode mode)
    {
      pid_t pid = -1;

      // three pairs of file descriptors, for pipes connected to the
      // process' stdin, stdout and stderr
      // (stored in a single array so close_fd_array() can close all at once)
      fd_type fd[6] =  {-1, -1, -1, -1, -1, -1};
      fd_type* const pin = fd;
      fd_type* const pout = fd+2;
      fd_type* const perr = fd+4;

      // constants for read/write ends of pipe
      const int RD = 0;
      const int WR = 1;

      // N.B.
      // For the pstreambuf pin is an output stream and
      // pout and perr are input streams.

      if (!error_ && mode&pstdin && ::pipe(pin))
        error_ = errno;

      if (!error_ && mode&pstdout && ::pipe(pout))
        error_ = errno;

      if (!error_ && mode&pstderr && ::pipe(perr))
        error_ = errno;

      if (!error_)
      {
        pid = ::fork();
        switch (pid)
        {
          case 0 :
          {
            // this is the new process

            // for each open pipe close one end and redirect the
            // respective standard stream to the other end

            if (*pin >= 0)
            {
              ::close(pin[WR]);
              ::dup2(pin[RD], STDIN_FILENO);
              ::close(pin[RD]);
            }
            if (*pout >= 0)
            {
              ::close(pout[RD]);
              ::dup2(pout[WR], STDOUT_FILENO);
              ::close(pout[WR]);
            }
            if (*perr >= 0)
            {
              ::close(perr[RD]);
              ::dup2(perr[WR], STDERR_FILENO);
              ::close(perr[WR]);
            }
            break;
          }
          case -1 :
          {
            // couldn't fork for some reason
            error_ = errno;
            // close any open pipes
            close_fd_array(fd, 6);
            break;
          }
          default :
          {
            // this is the parent process, store process' pid
            ppid_ = pid;

            // store one end of open pipes and close other end
            if (*pin >= 0)
            {
              wpipe_ = pin[WR];
              ::close(pin[RD]);
            }
            if (*pout >= 0)
            {
              rpipe_[rsrc_out] = pout[RD];
              ::close(pout[WR]);
            }
            if (*perr >= 0)
            {
              rpipe_[rsrc_err] = perr[RD];
              ::close(perr[WR]);
            }

            if (rpipe_[rsrc_out] == -1 && rpipe_[rsrc_err] >= 0)
            {
              // reading stderr but not stdout, so use stderr for all reads
              read_err(true);
            }
          }
        }
      }
      else
      {
        // close any pipes we opened before failure
        close_fd_array(fd, 6);
      }
      return pid;
    }

  template <typename C, typename T>
    basic_pstreambuf<C,T>*
    basic_pstreambuf<C,T>::close()
    {
      basic_pstreambuf<C,T>* ret = NULL;
      if (is_open())
      {
        sync();

        destroy_buffers(pstdin|pstdout|pstderr);

        // close pipes before wait() so child gets EOF/SIGPIPE
        close_fd_array(&wpipe_, 1);
        close_fd_array(rpipe_, 2);

        if (wait() == 1)
        {
          ret = this;
        }
      }
      return ret;
    }

  template <typename C, typename T>
    inline void
    basic_pstreambuf<C,T>::init_rbuffers()
    {
      rpipe_[rsrc_out] = rpipe_[rsrc_err] = -1;
      rbuffer_[rsrc_out] = rbuffer_[rsrc_err] = NULL;
      rbufstate_[0] = rbufstate_[1] = rbufstate_[2] = NULL;
    }

  template <typename C, typename T>
    void
    basic_pstreambuf<C,T>::create_buffers(pmode mode)
    {
      if (mode & pstdin)
      {
        delete[] wbuffer_;
        wbuffer_ = new char_type[bufsz];
        this->setp(wbuffer_, wbuffer_ + bufsz);
      }
      if (mode & pstdout)
      {
        delete[] rbuffer_[rsrc_out];
        rbuffer_[rsrc_out] = new char_type[bufsz];
        if (rsrc_ == rsrc_out)
          this->setg(rbuffer_[rsrc_out] + pbsz, rbuffer_[rsrc_out] + pbsz,
              rbuffer_[rsrc_out] + pbsz);
      }
      if (mode & pstderr)
      {
        delete[] rbuffer_[rsrc_err];
        rbuffer_[rsrc_err] = new char_type[bufsz];
        if (rsrc_ == rsrc_err)
          this->setg(rbuffer_[rsrc_err] + pbsz, rbuffer_[rsrc_err] + pbsz,
              rbuffer_[rsrc_err] + pbsz);
      }
    }

  template <typename C, typename T>
    void
    basic_pstreambuf<C,T>::destroy_buffers(pmode mode)
    {
      if (mode & pstdin)
      {
        this->setp(NULL, NULL);
        delete[] wbuffer_;
        wbuffer_ = NULL;
      }
      if (mode & pstdout)
      {
        if (rsrc_ == rsrc_out)
          this->setg(NULL, NULL, NULL);
        delete[] rbuffer_[rsrc_out];
        rbuffer_[rsrc_out] = NULL;
      }
      if (mode & pstderr)
      {
        if (rsrc_ == rsrc_err)
          this->setg(NULL, NULL, NULL);
        delete[] rbuffer_[rsrc_err];
        rbuffer_[rsrc_err] = NULL;
      }
    }

  template <typename C, typename T>
    typename basic_pstreambuf<C,T>::buf_read_src
    basic_pstreambuf<C,T>::switch_read_buffer(buf_read_src src)
    {
      if (rsrc_ != src)
      {
        char_type* tmpbufstate[] = {this->eback(), this->gptr(), this->egptr()};
        this->setg(rbufstate_[0], rbufstate_[1], rbufstate_[2]);
        for (std::size_t i = 0; i < 3; ++i)
          rbufstate_[i] = tmpbufstate[i];
        rsrc_ = src;
      }
      return rsrc_;
    }

  template <typename C, typename T>
    int
    basic_pstreambuf<C,T>::wait(bool nohang)
    {
      int exited = -1;
      if (is_open())
      {
        int status;
        switch(::waitpid(ppid_, &status, nohang ? WNOHANG : 0))
        {
          case 0 :
            // nohang was true and process has not exited
            exited = 0;
            break;
          case -1 :
            error_ = errno;
            break;
          default :
            // process has exited
            ppid_ = 0;
            status_ = status;
            exited = 1;
            destroy_buffers(pstdin|pstdout|pstderr);
            close_fd_array(&wpipe_, 1);
            close_fd_array(rpipe_, 2);
            break;
        }
      }
      return exited;
    }

  template <typename C, typename T>
    inline basic_pstreambuf<C,T>*
    basic_pstreambuf<C,T>::kill(int signal)
    {
      basic_pstreambuf<C,T>* ret = NULL;
      if (is_open())
      {
        if (::kill(ppid_, signal))
          error_ = errno;
        else
        {
          // TODO call exited() to check for exit and clean up? leave to user?
          ret = this;
        }
      }
      return ret;
    }

  template <typename C, typename T>
    inline bool
    basic_pstreambuf<C,T>::exited()
    {
      return ppid_ == 0 || wait(true)==1;
    }


  template <typename C, typename T>
    inline int
    basic_pstreambuf<C,T>::status() const
    {
      return status_;
    }

  template <typename C, typename T>
    inline int
    basic_pstreambuf<C,T>::error() const
    {
      return error_;
    }

  template <typename C, typename T>
    inline void
    basic_pstreambuf<C,T>::peof()
    {
      sync();
      destroy_buffers(pstdin);
      close_fd_array(&wpipe_, 1);
    }

  template <typename C, typename T>
    inline bool
    basic_pstreambuf<C,T>::is_open() const
    {
      return ppid_ > 0;
    }

  template <typename C, typename T>
    inline bool
    basic_pstreambuf<C,T>::read_err(bool readerr)
    {
      buf_read_src src = readerr ? rsrc_err : rsrc_out;
      if (rpipe_[src]>=0)
      {
        switch_read_buffer(src);
        return true;
      }
      return false;
    }

  template <typename C, typename T>
    typename basic_pstreambuf<C,T>::int_type
    basic_pstreambuf<C,T>::overflow(int_type c)
    {
      if (!empty_buffer())
        return traits_type::eof();
      else if (!traits_type::eq_int_type(c, traits_type::eof()))
        return this->sputc(c);
      else
        return traits_type::not_eof(c);
    }


  template <typename C, typename T>
    int
    basic_pstreambuf<C,T>::sync()
    {
      return !exited() && empty_buffer() ? 0 : -1;
    }

  template <typename C, typename T>
    std::streamsize
    basic_pstreambuf<C,T>::xsputn(const char_type* s, std::streamsize n)
    {
      if (n < this->epptr() - this->pptr())
      {
        std::memcpy(this->pptr(), s, n * sizeof(char_type));
        this->pbump(n);
        return n;
      }
      else
      {
        for (std::streamsize i = 0; i < n; ++i)
        {
          if (traits_type::eq_int_type(this->sputc(s[i]), traits_type::eof()))
            return i;
        }
        return n;
      }
    }

  template <typename C, typename T>
    bool
    basic_pstreambuf<C,T>::empty_buffer()
    {
      const std::streamsize count = this->pptr() - this->pbase();
      const std::streamsize written = this->write(this->wbuffer_, count);
      if (count > 0 && written == count)
      {
        this->pbump(-written);
        return true;
      }
      return false;
    }

  template <typename C, typename T>
    typename basic_pstreambuf<C,T>::int_type
    basic_pstreambuf<C,T>::underflow()
    {
      if (this->gptr() < this->egptr() || fill_buffer())
        return traits_type::to_int_type(*this->gptr());
      else
        return traits_type::eof();
    }

  template <typename C, typename T>
    typename basic_pstreambuf<C,T>::int_type
    basic_pstreambuf<C,T>::pbackfail(int_type c)
    {
      if (this->gptr() != this->eback())
      {
        this->gbump(-1);
        if (!traits_type::eq_int_type(c, traits_type::eof()))
          *this->gptr() = traits_type::to_char_type(c);
        return traits_type::not_eof(c);
      }
      else
         return traits_type::eof();
    }

  template <typename C, typename T>
    bool
    basic_pstreambuf<C,T>::fill_buffer()
    {
      const std::streamsize pb1 = this->gptr() - this->eback();
      const std::streamsize pb2 = pbsz;
      const std::streamsize npb = std::min(pb1, pb2);

      std::memmove( rbuffer() + pbsz - npb,
                    this->gptr() - npb,
                    npb * sizeof(char_type) );

      const std::streamsize rc = read(rbuffer() + pbsz, bufsz - pbsz);

      if (rc > 0)
      {
        this->setg( rbuffer() + pbsz - npb,
                    rbuffer() + pbsz,
                    rbuffer() + pbsz + rc );
        return true;
      }
      else
      {
        this->setg(NULL, NULL, NULL);
        return false;
      }
    }

  template <typename C, typename T>
    inline std::streamsize
    basic_pstreambuf<C,T>::write(char_type* s, std::streamsize n)
    {
      return wpipe() >= 0 ? ::write(wpipe(), s, n * sizeof(char_type)) : 0;
    }

  template <typename C, typename T>
    inline std::streamsize
    basic_pstreambuf<C,T>::read(char_type* s, std::streamsize n)
    {
      return rpipe() >= 0 ? ::read(rpipe(), s, n * sizeof(char_type)) : 0;
    }

  template <typename C, typename T>
    inline typename basic_pstreambuf<C,T>::fd_type&
    basic_pstreambuf<C,T>::wpipe()
    {
      return wpipe_;
    }

  template <typename C, typename T>
    inline typename basic_pstreambuf<C,T>::fd_type&
    basic_pstreambuf<C,T>::rpipe()
    {
      return rpipe_[rsrc_];
    }

  template <typename C, typename T>
    inline typename basic_pstreambuf<C,T>::fd_type&
    basic_pstreambuf<C,T>::rpipe(buf_read_src which)
    {
      return rpipe_[which];
    }

  template <typename C, typename T>
    inline typename basic_pstreambuf<C,T>::char_type*
    basic_pstreambuf<C,T>::rbuffer()
    {
      return rbuffer_[rsrc_];
    }


  /*
   * member definitions for pstream_common
   */

  template <typename C, typename T>
    inline
    pstream_common<C,T>::pstream_common()
    : std::basic_ios<C,T>(NULL)
    , command_()
    , buf_()
    {
      this->init(&buf_);
    }

  template <typename C, typename T>
    inline
    pstream_common<C,T>::pstream_common(const std::string& command, pmode mode)
    : std::basic_ios<C,T>(NULL)
    , command_(command)
    , buf_()
    {
      this->init(&buf_);
      do_open(command, mode);
    }

  template <typename C, typename T>
    inline
    pstream_common<C,T>::pstream_common( const std::string& file,
                                         const argv_type& argv,
                                         pmode mode )
    : std::basic_ios<C,T>(NULL)
    , command_(file)
    , buf_()
    {
      this->init(&buf_);
      do_open(file, argv, mode);
    }

  template <typename C, typename T>
    inline
    pstream_common<C,T>::~pstream_common()
    {
    }

  template <typename C, typename T>
    inline void
    pstream_common<C,T>::do_open(const std::string& command, pmode mode)
    {
      if (!buf_.open((command_=command), mode))
        this->setstate(std::ios::failbit);
    }

  template <typename C, typename T>
    inline void
    pstream_common<C,T>::do_open( const std::string& file,
                                  const argv_type& argv,
                                  pmode mode )
    {
      if (!buf_.open((command_=file), argv, mode))
        this->setstate(std::ios::failbit);
    }

  template <typename C, typename T>
    inline void
    pstream_common<C,T>::close()
    {
      if (!buf_.close())
        this->setstate(std::ios::failbit);
    }

  template <typename C, typename T>
    inline bool
    pstream_common<C,T>::is_open() const
    {
      return buf_.is_open();
    }

  template <typename C, typename T>
    inline const std::string&
    pstream_common<C,T>::command() const
    {
      return command_;
    }

  // TODO  document behaviour if buffer replaced.
  template <typename C, typename T>
    inline typename pstream_common<C,T>::streambuf_type*
    pstream_common<C,T>::rdbuf() const
    {
      return const_cast<streambuf_type*>(&buf_);
    }


#if REDI_EVISCERATE_PSTREAMS

  template <typename C, typename T>
    std::size_t
    basic_pstreambuf<C,T>::fopen(std::FILE*& in, std::FILE*& out, std::FILE*& err)
    {
      in = out = err = NULL;
      std::size_t open_files = 0;
      if (wpipe() > -1)
      {
        if ((in = ::fdopen(wpipe(), "w")))
        {
            open_files |= pstdin;
        }
      }
      if (rpipe(rsrc_out) > -1)
      {
        if ((out = ::fdopen(rpipe(rsrc_out), "r")))
        {
            open_files |= pstdout;
        }
      }
      if (rpipe(rsrc_err) > -1)
      {
        if ((err = ::fdopen(rpipe(rsrc_err), "r")))
        {
            open_files |= pstderr;
        }
      }
      return open_files;
    }

  template <typename C, typename T>
    inline std::size_t
    pstream_common<C,T>::fopen(std::FILE*& in, std::FILE*& out, std::FILE*& err)
    {
      return buf_.fopen(in, out, err);
    }

#endif // REDI_EVISCERATE_PSTREAMS


} // namespace io
} // namespace IXE

#endif //  defined(__GNUC__) && (__GNUC__ < 3) 

#endif  // REDI_PSTREAM_H_SEEN

 

Copyright © 2005-2007 G. Attardi. Generated on 13 Aug 2009 by doxygen 1.5.7.1.