josh/TCPlayerbotCore
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

*Massive cleanup (\n\n -> \n, *\n -> \n, cleanup for(...) to for (...), and some other cleanups by hand)

Browse Source 
*Fix a possible crash in Spell::DoAllEffectOnTarget

--HG--
branch : trunk
This commit is contained in:
maximius
2009-10-17 15:35:07 -07:00
parent f21f47005d
commit 26b5e033ff
2257 changed files with 750 additions and 103852 deletions
Download Patch File Download Diff File Expand all files Collapse all files
dep/ACE_wrappers/ace/Process.h
-121
View File
@@ -1,5 +1,4 @@
// -*- C++ -*-
//=============================================================================
/**
* @file Process.h
@@ -9,27 +8,19 @@
* @author Tim Harrison <[email protected]>
*/
//=============================================================================
#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
*
@@ -62,7 +53,6 @@ public:
NO_EXEC = 1
#endif /* ACE_WIN32 */
};
protected:
// = Default settings not part of public Interface.
//
@@ -74,7 +64,6 @@ protected:
ENVIRONMENT_BUFFER = 16 * 1024, // 16K
MAX_ENVIRONMENT_ARGS = 512 //
};
public:
/**
* If @a inherit_environment == true, the new process will inherit the
@@ -85,12 +74,9 @@ 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
@@ -100,15 +86,12 @@ 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
@@ -120,19 +103,15 @@ 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
@@ -143,15 +122,12 @@ 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
@@ -160,14 +136,11 @@ 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
@@ -180,10 +153,8 @@ 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
@@ -195,7 +166,6 @@ 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
@@ -204,26 +174,21 @@ 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.
/**
@@ -235,7 +200,6 @@ 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.
/**
@@ -244,7 +208,6 @@ 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().
/**
@@ -253,55 +216,40 @@ 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);
@@ -312,65 +260,49 @@ 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_;
@@ -378,72 +310,51 @@ 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
*
@@ -461,20 +372,16 @@ 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
@@ -483,22 +390,18 @@ 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
@@ -509,7 +412,6 @@ 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
@@ -525,62 +427,48 @@ 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 */
@@ -588,12 +476,10 @@ 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) && \
@@ -602,7 +488,6 @@ private:
#endif
};
/**
* @class ACE_Managed_Process
*
@@ -615,22 +500,16 @@ 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 */