*Backed out changeset 3be01fb200a5

--HG--
branch : trunk

1 files changed, 121 insertions, 0 deletions

diff --git a/dep/ACE_wrappers/ace/Process.h b/dep/ACE_wrappers/ace/Process.h
index 6a89e5825e4..908d3d0cf97 100644
--- a/dep/ACE_wrappers/ace/Process.h
+++ b/dep/ACE_wrappers/ace/Process.h
@@ -1,4 +1,5 @@
 // -*- C++ -*-
+
 //=============================================================================
 /**
  *  @file    Process.h
@@ -8,19 +9,27 @@
  *  @author Tim Harrison <harrison@cs.wustl.edu>
  */
 //=============================================================================
+
 #ifndef ACE_PROCESS_H
 #define ACE_PROCESS_H
+
 #include /**/ "ace/pre.h"
+
 #include /**/ "ace/ACE_export.h"
+
 #if !defined (ACE_LACKS_PRAGMA_ONCE)
 # pragma once
 #endif /* ACE_LACKS_PRAGMA_ONCE */
+
 #include "ace/Handle_Set.h"
 #include "ace/Global_Macros.h"
 #include "ace/os_include/sys/os_types.h"
+
 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
+
 // Forward declaration
 class ACE_Time_Value;
+
 /**
  * @class ACE_Process_Options
  *
@@ -53,6 +62,7 @@ public:
     NO_EXEC = 1
 #endif /* ACE_WIN32 */
   };
+
 protected:
   // = Default settings not part of public Interface.
   //
@@ -64,6 +74,7 @@ protected:
     ENVIRONMENT_BUFFER = 16 * 1024, // 16K
     MAX_ENVIRONMENT_ARGS = 512 //
   };
+
 public:
   /**
    * If @a inherit_environment == true, the new process will inherit the
@@ -74,9 +85,12 @@ public:
                        int command_line_buf_len = DEFAULT_COMMAND_LINE_BUF_LEN,
                        int env_buf_len = ENVIRONMENT_BUFFER,
                        int max_env_args = MAX_ENVIRONMENT_ARGS);
+
   /// Destructor.
   ~ACE_Process_Options (void);
+
   // = Methods to set process creation options portably.
+
   /**
    * Set the standard handles of the new process to the respective
    * handles.  If you want to affect a subset of the handles, make
@@ -86,12 +100,15 @@ public:
   int set_handles (ACE_HANDLE std_in,
                    ACE_HANDLE std_out = ACE_INVALID_HANDLE,
                    ACE_HANDLE std_err = ACE_INVALID_HANDLE);
+
   /// Release the standard handles previously set with set_handles;
   void release_handles (void);
+
   /// @param format must be of the form "VARIABLE=VALUE".  There can not be
   /// any spaces between VARIABLE and the equal sign.
   int setenv (const ACE_TCHAR *format,
               ...);
+
   /**
    * Set a single environment variable, @a variable_name.  Since
    * different platforms separate each environment variable
@@ -103,15 +120,19 @@ public:
   int setenv (const ACE_TCHAR *variable_name,
               const ACE_TCHAR *format,
               ...);
+
   /// Same as above with argv format.  @a envp must be null terminated.
   int setenv (ACE_TCHAR *envp[]);
+
   /// Set the working directory for the process.  strlen of @a wd must
   /// be <= MAXPATHLEN.
   void working_directory (const char *wd);
+
 #if defined (ACE_HAS_WCHAR)
   /// wchar_t version of working_directory
   void working_directory (const wchar_t *wd);
 #endif /* ACE_HAS_WCHAR */
+
   /**
    * Set the command-line arguments.  @a format can use any printf
    * formats.  The first token in @a format should be the path to the
@@ -122,12 +143,15 @@ public:
    * on success, -1 on failure.
    */
   int command_line (const ACE_TCHAR *format, ...);
+
 #if defined (ACE_HAS_WCHAR) && !defined (ACE_HAS_WINCE)
   /// Anti-TChar version of command_line ()
   int command_line (const ACE_ANTI_TCHAR *format, ...);
 #endif /* ACE_HAS_WCHAR && !ACE_HAS_WINCE */
+
   /// Same as above in argv format.  @a argv must be null terminated.
   int command_line (const ACE_TCHAR * const argv[]);
+
   /**
    * Specify the full path or relative path, or just the executable
    * name for the process. If this is set, then @a name will be used to
@@ -136,11 +160,14 @@ public:
    * executable name as argv[0].
    */
   void process_name (const ACE_TCHAR *name);
+
   /// Return the process_name.  If the <process_name(name)> set
   /// method is not called, this method will return argv[0].
   const ACE_TCHAR *process_name (void);
+
   /// Get the creation flags.
   u_long creation_flags (void) const;
+
   /**
    * Set the creation flags to affect how a new process is spawned.
    * The only ACE-defined flag is @c NO_EXEC which prevents the new process
@@ -153,8 +180,10 @@ public:
    * system call as the value of the @c dwCreationFlags parameter.
    */
   void creation_flags (u_long);
+
   /// Current working directory.  Returns "" if nothing has been set.
   ACE_TCHAR *working_directory (void);
+
   /// Buffer of command-line options.  Returns a pointer to a buffer that
   /// contains the list of command line options.  Prior to a call to
   /// command_line_argv(), this is a single string of space separated
@@ -166,6 +195,7 @@ public:
   /// providing max_len. @arg max_len, if non-zero, provides a location
   /// into which the total length of the command line buffer is returned.
   ACE_TCHAR *command_line_buf (int *max_len = 0);
+
   /**
    * argv-style command-line options.  Parses and modifies the string
    * created from <command_line_>.  All spaces not in quotes ("" or
@@ -174,21 +204,26 @@ public:
    * null-terminated string.  Returns { 0 } if nothing has been set.
    */
   ACE_TCHAR * const *command_line_argv (void);
+
   /**
    * Null-terminated buffer of null terminated strings.  Each string
    * is an environment assignment "VARIABLE=value".  This buffer
    * should end with two null characters.
    */
   ACE_TCHAR *env_buf (void);
+
   /// Get the process group.  On UNIX, these methods are used by the
   /// ACE_Process_Manager to manage groups of processes.
   pid_t getgroup (void) const;
+
   /// Set the process group.  On UNIX, these methods are used by the
   /// ACE_Process_Manager to manage groups of processes.
   pid_t setgroup (pid_t pgrp);
+
   /// Allows disabling of handle inheritence, default is TRUE.
   int handle_inheritence (void);
   void handle_inheritence (int);
+
   /// Cause the specified handle to be passed to a child process
   /// when it runs a new program image.
   /**
@@ -200,6 +235,7 @@ public:
    * @return 0 if success, -1 if failure.
    */
   int pass_handle (ACE_HANDLE);
+
   /// Get a copy of the handles the ACE_Process_Options duplicated
   /// for the spawned process.
   /**
@@ -208,6 +244,7 @@ public:
    * @return 0 if there were no handles to return; 1 if there were.
    */
   int dup_handles (ACE_Handle_Set &set) const;
+
   /// Get a copy of the handles passed to the spawned process. This
   /// will be the set of handles previously passed to @arg pass_handle().
   /**
@@ -216,40 +253,55 @@ public:
    * @return 0 if there were no handles to return; 1 if there were.
    */
   int passed_handles (ACE_Handle_Set &set) const;
+
   /// Set value for avoid_zombies (has no real effect except on *nix).
   void avoid_zombies (int);
+
   /// Get current value for avoid_zombies.
   int avoid_zombies (void);
+
   /// Enable the use of a Unicode environment.  This only makes sense
   /// for Win32 when ACE_USES_WCHAR is not defined.
   void enable_unicode_environment (void);
+
   /// Disable the use of a Unicode environment.
   void disable_unicode_environment (void);
+
   /// Return the unicode environment status
   bool use_unicode_environment (void) const;
+
 #if defined (ACE_WIN32)
   // = Non-portable accessors for when you "just have to use them."
+
   /// Used for setting and getting.
   ACE_TEXT_STARTUPINFO *startup_info (void);
+
   /// Get the process_attributes.  Returns NULL if
   /// set_process_attributes has not been set.
   LPSECURITY_ATTRIBUTES get_process_attributes (void) const;
+
   /// If this is called, a non-null process attributes is sent to
   /// CreateProcess.
   LPSECURITY_ATTRIBUTES set_process_attributes (void);
+
   /// Get the thread_attributes.  Returns NULL if set_thread_attributes
   /// has not been set.
   LPSECURITY_ATTRIBUTES get_thread_attributes (void) const;
+
   /// If this is called, a non-null thread attributes is sent to
   /// CreateProcess.
   LPSECURITY_ATTRIBUTES set_thread_attributes (void);
+
 #else /* All things not WIN32 */
+
   /// argv-style array of environment settings.
   ACE_TCHAR *const *env_argv (void);
+
   // = Accessors for the standard handles.
   ACE_HANDLE get_stdin (void) const;
   ACE_HANDLE get_stdout (void) const;
   ACE_HANDLE get_stderr (void) const;
+
   // = Set/get real & effective user & group id associated with user.
   int setreugid (const ACE_TCHAR* user);
   void setruid (uid_t id);
@@ -260,49 +312,65 @@ public:
   uid_t geteuid (void) const;
   uid_t getrgid (void) const;
   uid_t getegid (void) const;
+
   /**
    * Get the inherit_environment flag.
    */
   bool inherit_environment (void) const;
+
   /**
    * Set the inherit_environment flag.
    */
   void inherit_environment (bool nv);
 #endif /* ACE_WIN32 */
 protected:
+
 #if !defined (ACE_HAS_WINCE)
   /// Add @a assignment to environment_buf_ and adjust
   /// environment_argv_.  @a len is the strlen of @a assignment.
   int setenv_i (ACE_TCHAR *assignment, size_t len);
+
   /// Whether the child process inherits the current process
   /// environment.
   bool inherit_environment_;
 #endif /* !ACE_HAS_WINCE */
+
   /// Default 0.
   u_long creation_flags_;
+
   /// Avoid zombies for spawned processes.
   int avoid_zombies_;
+
 #if defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)
   /// Helper function to grab win32 environment and stick it in
   /// environment_buf_ using this->setenv_i.
   void inherit_environment (void);
+
   /// Ensures once only call to inherit environment.
   int environment_inherited_;
+
   ACE_TEXT_STARTUPINFO startup_info_;
+
   /// Default TRUE.
   BOOL handle_inheritence_;
+
   /// Pointer to security_buf1_.
   LPSECURITY_ATTRIBUTES process_attributes_;
+
   /// Pointer to security_buf2_.
   LPSECURITY_ATTRIBUTES thread_attributes_;
+
   /// Data for process_attributes_.
   SECURITY_ATTRIBUTES security_buf1_;
+
   /// Data for thread_attributes_.
   SECURITY_ATTRIBUTES security_buf2_;
+
 #else /* !ACE_WIN32 */
   ACE_HANDLE stdin_;
   ACE_HANDLE stdout_;
   ACE_HANDLE stderr_;
+
   // = Real & effective user & group id's.
   //   These should be set to -1 to leave unchanged (default).
   uid_t ruid_;
@@ -310,51 +378,72 @@ protected:
   uid_t rgid_;
   uid_t egid_;
 #endif /* ACE_WIN32 */
+
 #if !defined (ACE_HAS_WINCE)
   /// Is 1 if stdhandles was called.
   int set_handles_called_;
+
   /// Pointer into environment_buf_.  This should point to the next
   /// free spot.
   size_t environment_buf_index_;
+
   /// Pointer to environment_argv_.
   int environment_argv_index_;
+
   /// Pointer to buffer of the environment settings.
   ACE_TCHAR *environment_buf_;
+
   /// Size of the environment buffer. Configurable
   size_t environment_buf_len_;
+
   /// Pointers into environment_buf_.
   ACE_TCHAR **environment_argv_;
+
   /// Maximum number of environment variables. Configurable
   int max_environment_args_;
+
   /// Maximum index of environment_argv_ buffer
   int max_environ_argv_index_;
+
   /// The current working directory.
   ACE_TCHAR working_directory_[MAXPATHLEN + 1];
 #endif /* !ACE_HAS_WINCE */
+
   /// Ensures command_line_argv is only calculated once.
   int command_line_argv_calculated_;
+
   /// Pointer to buffer of command-line arguments.  E.g., "-f foo -b bar".
   ACE_TCHAR *command_line_buf_;
+
   /// Pointer to copy of command-line arguments, which is needed when
   /// converting a command-line string into a command-line argv.
   ACE_TCHAR *command_line_copy_;
+
   /// Max length of command_line_buf_
   int command_line_buf_len_;
+
   /// Argv-style command-line arguments.
   ACE_TCHAR *command_line_argv_[MAX_COMMAND_LINE_OPTIONS];
+
   /// Process-group on Unix; unused on Win32.
   pid_t process_group_;
+
   /// Set of handles that were passed in pass_handle ().
   ACE_Handle_Set handles_passed_;
+
   /// Results of duplicating handles passed in pass_handle ().
   ACE_Handle_Set dup_handles_;
+
   /// Pathname for the process. Relative path or absolute path or just
   /// the program name.
   ACE_TCHAR process_name_[MAXPATHLEN + 1];
+
   /// Indicate if a Unicode environment should be used
   bool use_unicode_environment_;
 };
+
 //class ACE_Process_Manager;
+
 /**
  * @class ACE_Process
  *
@@ -372,16 +461,20 @@ class ACE_Export ACE_Process
 {
 public:
   friend class ACE_Process_Manager;
+
   /// Default construction.  Must use <ACE_Process::spawn> to start.
   ACE_Process (void);
+
   /// Destructor.
   virtual ~ACE_Process (void);
+
   /**
    * Called just before <ACE_OS::fork> in the <spawn>.  If this
    * returns non-zero, the <spawn> is aborted (and returns
    * ACE_INVALID_PID).  The default simply returns zero.
    */
   virtual int prepare (ACE_Process_Options &options);
+
   /**
    * Launch a new process as described by @a options. On success,
    * returns 1 if the option avoid_zombies is set, else returns the
@@ -390,18 +483,22 @@ public:
    * the process id of the child will be returned regardless of the option.
    */
   virtual pid_t spawn (ACE_Process_Options &options);
+
   /// Called just after <ACE_OS::fork> in the parent's context, if the
   /// <fork> succeeds.  The default is to do nothing.
   virtual void parent (pid_t child);
+
   /**
    * Called just after <ACE_OS::fork> in the child's context.  The
    * default does nothing.  This function is *not* called on Win32
    * because the process-creation scheme does not allow it.
    */
   virtual void child (pid_t parent);
+
   /// Called by a <Process_Manager> that is removing this Process from
   /// its table of managed Processes.  Default is to do nothing.
   virtual void unmanage (void);
+
   /**
    * Wait for the process we've created to exit.  If <status> != 0, it
    * points to an integer where the function store the exit status of
@@ -412,6 +509,7 @@ public:
    */
   pid_t wait (ACE_exitcode *status = 0,
               int wait_options = 0);
+
   /**
    * Timed wait for the process we've created to exit.  A return value
    * of -1 indicates that the something failed; 0 indicates that a
@@ -427,48 +525,62 @@ public:
    */
   pid_t wait (const ACE_Time_Value &tv,
               ACE_exitcode *status = 0);
+
   /// Send the process a signal.  This is only portable to operating
   /// systems that support signals, such as UNIX/POSIX.
   int kill (int signum = SIGINT);
+
   /**
    * Terminate the process abruptly using <ACE::terminate_process>.
    * This call doesn't give the process a chance to cleanup, so use it
    * with caution...
    */
   int terminate (void);
+
   /// Return the process id of the new child process.
   pid_t getpid (void) const;
+
   /// Return the handle of the process, if it has one.
   ACE_HANDLE gethandle (void) const;
+
   /// Return 1 if running; 0 otherwise.
   int running (void) const;
+
   /// Return the Process' exit code.  This method returns the raw
   /// exit status returned from system APIs (such as <wait> or
   /// <waitpid>).  This value is system dependent.
   ACE_exitcode exit_code (void) const;
+
   /// Return the Process' return value.  This method returns the
   /// actual return value that a child process returns or <exit>s.
   int return_value (void) const;
+
   /// Close all the handles in the set obtained from the
   /// @arg ACE_Process_Options::dup_handles object used to spawn
   /// the process.
   void close_dup_handles (void);
+
   /// Close all the handles in the set obtained from the
   /// @arg ACE_Process_Options::passed_handles object used to spawn
   /// the process.
   void close_passed_handles (void);
+
 #if defined (ACE_WIN32)
   PROCESS_INFORMATION process_info (void);
 #endif /* ACE_WIN32 */
+
 private:
+
   // Disallow copying and assignment since we don't support this (yet).
   ACE_Process (const ACE_Process &);
   void operator= (const ACE_Process &);
+
 protected:
   /// Set this process' <exit_code_>.  ACE_Process_Manager uses this
   /// method to set the <exit_code_> after successfully waiting for
   /// this process to exit.
   void exit_code (ACE_exitcode code);
+
 #if defined (ACE_WIN32)
   PROCESS_INFORMATION process_info_;
 #else /* ACE_WIN32 */
@@ -476,10 +588,12 @@ protected:
   pid_t child_id_;
 #endif /* ACE_WIN32 */
   ACE_exitcode exit_code_;
+
   /// Set of handles that were passed to the child process.
   ACE_Handle_Set handles_passed_;
   /// Handle duplicates made for the child process.
   ACE_Handle_Set dup_handles_;
+
 private:
 #if defined (ACE_WIN32) && \
     defined (ACE_HAS_WCHAR) && !defined (ACE_USES_WCHAR) && \
@@ -488,6 +602,7 @@ private:
 #endif
 };
 
+
 /**
  * @class ACE_Managed_Process
  *
@@ -500,16 +615,22 @@ private:
 class ACE_Export ACE_Managed_Process : public ACE_Process
 {
 public:
+
   /// Cleanup by deleting @c this.
   virtual void unmanage (void);
+
 protected:
+
   /// Make sure that we're allocated dynamically!
   virtual ~ACE_Managed_Process (void);
 };
+
 ACE_END_VERSIONED_NAMESPACE_DECL
+
 #if defined (__ACE_INLINE__)
 #include "ace/Process.inl"
 #endif /* __ACE_INLINE__ */
+
 #include /**/ "ace/post.h"
 #endif /* ACE_PROCESS_H */