libs/glibmm2/glibmm/spawn.h

   1 // -*- c++ -*-
   2 // Generated by gtkmmproc -- DO NOT MODIFY!
   3 #ifndef _GLIBMM_SPAWN_H
   4 #define _GLIBMM_SPAWN_H
   5
   6
   7 /* $Id$ */
   8
   9 /* Copyright (C) 2002 The gtkmm Development Team
  10  *
  11  * This library is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Library General Public
  13  * License as published by the Free Software Foundation; either
  14  * version 2 of the License, or (at your option) any later version.
  15  *
  16  * This library is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Library General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Library General Public
  22  * License along with this library; if not, write to the Free
  23  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  24  */
  25
  26
  27 #include <string>
  28 #include <sigc++/sigc++.h>
  29 #include <glibmm/arrayhandle.h>
  30 #include <glibmm/error.h>
  31
  32 #include <glibmmconfig.h>
  33 GLIBMM_USING_STD(string)
  34
  35
  36 namespace Glib
  37 {
  38
  39 typedef GPid Pid;
  40
  41 /** @addtogroup glibmmEnums Enums and Flags */
  42
  43 /**
  44  * @ingroup glibmmEnums
  45  * @par Bitwise operators:
  46  * <tt>%SpawnFlags operator|(SpawnFlags, SpawnFlags)</tt><br>
  47  * <tt>%SpawnFlags operator&(SpawnFlags, SpawnFlags)</tt><br>
  48  * <tt>%SpawnFlags operator^(SpawnFlags, SpawnFlags)</tt><br>
  49  * <tt>%SpawnFlags operator~(SpawnFlags)</tt><br>
  50  * <tt>%SpawnFlags& operator|=(SpawnFlags&, SpawnFlags)</tt><br>
  51  * <tt>%SpawnFlags& operator&=(SpawnFlags&, SpawnFlags)</tt><br>
  52  * <tt>%SpawnFlags& operator^=(SpawnFlags&, SpawnFlags)</tt><br>
  53  */
  54 enum SpawnFlags
  55 {
  56   SPAWN_LEAVE_DESCRIPTORS_OPEN = 1 << 0,
  57   SPAWN_DO_NOT_REAP_CHILD = 1 << 1,
  58   SPAWN_SEARCH_PATH = 1 << 2,
  59   SPAWN_STDOUT_TO_DEV_NULL = 1 << 3,
  60   SPAWN_STDERR_TO_DEV_NULL = 1 << 4,
  61   SPAWN_CHILD_INHERITS_STDIN = 1 << 5,
  62   SPAWN_FILE_AND_ARGV_ZERO = 1 << 6
  63 };
  64
  65 /** @ingroup glibmmEnums */
  66 inline SpawnFlags operator|(SpawnFlags lhs, SpawnFlags rhs)
  67   { return static_cast<SpawnFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
  68
  69 /** @ingroup glibmmEnums */
  70 inline SpawnFlags operator&(SpawnFlags lhs, SpawnFlags rhs)
  71   { return static_cast<SpawnFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
  72
  73 /** @ingroup glibmmEnums */
  74 inline SpawnFlags operator^(SpawnFlags lhs, SpawnFlags rhs)
  75   { return static_cast<SpawnFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
  76
  77 /** @ingroup glibmmEnums */
  78 inline SpawnFlags operator~(SpawnFlags flags)
  79   { return static_cast<SpawnFlags>(~static_cast<unsigned>(flags)); }
  80
  81 /** @ingroup glibmmEnums */
  82 inline SpawnFlags& operator|=(SpawnFlags& lhs, SpawnFlags rhs)
  83   { return (lhs = static_cast<SpawnFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
  84
  85 /** @ingroup glibmmEnums */
  86 inline SpawnFlags& operator&=(SpawnFlags& lhs, SpawnFlags rhs)
  87   { return (lhs = static_cast<SpawnFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
  88
  89 /** @ingroup glibmmEnums */
  90 inline SpawnFlags& operator^=(SpawnFlags& lhs, SpawnFlags rhs)
  91   { return (lhs = static_cast<SpawnFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
  92
  93
  94 /** @defgroup Spawn Spawning Processes
  95  * Process launching with fork()/exec().
  96  * @{
  97  */
  98
  99 /** Exception class for errors occuring when spawning processes.
 100  */
 101 class SpawnError : public Glib::Error
 102 {
 103 public:
 104   enum Code
 105   {
 106     FORK,
 107     READ,
 108     CHDIR,
 109     ACCES,
 110     PERM,
 111     TOOBIG,
 112     NOEXEC,
 113     NAMETOOLONG,
 114     NOENT,
 115     NOMEM,
 116     NOTDIR,
 117     LOOP,
 118     TXTBUSY,
 119     IO,
 120     NFILE,
 121     MFILE,
 122     INVAL,
 123     ISDIR,
 124     LIBBAD
 125   };
 126
 127   SpawnError(Code error_code, const Glib::ustring& error_message);
 128   explicit SpawnError(GError* gobject);
 129   Code code() const;
 130
 131 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 132 private:
 133   static void throw_func(GError* gobject);
 134   friend void wrap_init(); // uses throw_func()
 135 #endif
 136 };
 137
 138
 139 void spawn_async_with_pipes(const std::string& working_directory,
 140                             const Glib::ArrayHandle<std::string>& argv,
 141                             const Glib::ArrayHandle<std::string>& envp,
 142                             SpawnFlags flags = SpawnFlags(0),
 143                             const sigc::slot<void>& child_setup = sigc::slot<void>(),
 144                             Pid* child_pid = 0,
 145                             int* standard_input = 0,
 146                             int* standard_output = 0,
 147                             int* standard_error = 0);
 148
 149 void spawn_async_with_pipes(const std::string& working_directory,
 150                             const Glib::ArrayHandle<std::string>& argv,
 151                             SpawnFlags flags = SpawnFlags(0),
 152                             const sigc::slot<void>& child_setup = sigc::slot<void>(),
 153                             Pid* child_pid = 0,
 154                             int* standard_input = 0,
 155                             int* standard_output = 0,
 156                             int* standard_error = 0);
 157
 158 void spawn_async(const std::string& working_directory,
 159                  const Glib::ArrayHandle<std::string>& argv,
 160                  const Glib::ArrayHandle<std::string>& envp,
 161                  SpawnFlags flags = SpawnFlags(0),
 162                  const sigc::slot<void>& child_setup = sigc::slot<void>(),
 163                  Pid* child_pid = 0);
 164
 165 void spawn_async(const std::string& working_directory,
 166                  const Glib::ArrayHandle<std::string>& argv,
 167                  SpawnFlags flags = SpawnFlags(0),
 168                  const sigc::slot<void>& child_setup = sigc::slot<void>(),
 169                  Pid* child_pid = 0);
 170
 171 void spawn_sync(const std::string& working_directory,
 172                 const Glib::ArrayHandle<std::string>& argv,
 173                 const Glib::ArrayHandle<std::string>& envp,
 174                 SpawnFlags flags = SpawnFlags(0),
 175                 const sigc::slot<void>& child_setup = sigc::slot<void>(),
 176                 std::string* standard_output = 0,
 177                 std::string* standard_error = 0,
 178                 int* exit_status = 0);
 179
 180 void spawn_sync(const std::string& working_directory,
 181                 const Glib::ArrayHandle<std::string>& argv,
 182                 SpawnFlags flags = SpawnFlags(0),
 183                 const sigc::slot<void>& child_setup = sigc::slot<void>(),
 184                 std::string* standard_output = 0,
 185                 std::string* standard_error = 0,
 186                 int* exit_status = 0);
 187
 188 void spawn_command_line_async(const std::string& command_line);
 189
 190 void spawn_command_line_sync(const std::string& command_line,
 191                              std::string* standard_output = 0,
 192                              std::string* standard_error = 0,
 193                              int* exit_status = 0);
 194
 195 void spawn_close_pid(Pid pid);
 196
 197 /** @} group Spawn */
 198
 199 } // namespace Glib
 200
 201
 202 #endif /* _GLIBMM_SPAWN_H */
 203