src/common/process.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        process.cpp
// Purpose:     Process termination classes
// Author:      Guilhem Lavaux
// Modified by: Vadim Zeitlin to check error codes, added Detach() method
// Created:     24/06/98
// RCS-ID:      $Id: process.cpp 42702 2006-10-30 09:03:18Z JS $
// Copyright:   (c) Guilhem Lavaux
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// ============================================================================
// declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#include "wx/process.h"

// ----------------------------------------------------------------------------
// event tables and such
// ----------------------------------------------------------------------------

DEFINE_EVENT_TYPE(wxEVT_END_PROCESS)

IMPLEMENT_DYNAMIC_CLASS(wxProcess, wxEvtHandler)
IMPLEMENT_DYNAMIC_CLASS(wxProcessEvent, wxEvent)

// ============================================================================
// wxProcess implementation
// ============================================================================

// ----------------------------------------------------------------------------
// wxProcess creation
// ----------------------------------------------------------------------------

void wxProcess::Init(wxEvtHandler *parent, int id, int flags)
{
    if ( parent )
        SetNextHandler(parent);

    m_id         = id;
    m_pid        = 0;
    m_redirect   = (flags & wxPROCESS_REDIRECT) != 0;

#if wxUSE_STREAMS
    m_inputStream  = NULL;
    m_errorStream  = NULL;
    m_outputStream = NULL;
#endif // wxUSE_STREAMS
}

/* static */
wxProcess *wxProcess::Open(const wxString& cmd, int flags)
{
    wxASSERT_MSG( !(flags & wxEXEC_SYNC), wxT("wxEXEC_SYNC should not be used." ));
    wxProcess *process = new wxProcess(wxPROCESS_REDIRECT);
    long pid = wxExecute(cmd, flags, process);
    if( !pid )
    {
        // couldn't launch the process
        delete process;
        return NULL;
    }

    process->SetPid(pid);

    return process;
}

// ----------------------------------------------------------------------------
// wxProcess termination
// ----------------------------------------------------------------------------

wxProcess::~wxProcess()
{
#if wxUSE_STREAMS
    delete m_inputStream;
    delete m_errorStream;
    delete m_outputStream;
#endif // wxUSE_STREAMS
}

void wxProcess::OnTerminate(int pid, int status)
{
    wxProcessEvent event(m_id, pid, status);

    if ( !ProcessEvent(event) )
        delete this;
    //else: the object which processed the event is responsible for deleting
    //      us!
}

void wxProcess::Detach()
{
    SetNextHandler(NULL);
}

// ----------------------------------------------------------------------------
// process IO redirection
// ----------------------------------------------------------------------------

#if wxUSE_STREAMS

void wxProcess::SetPipeStreams(wxInputStream *inputSstream,
                               wxOutputStream *outputStream,
                               wxInputStream *errorStream)
{
    m_inputStream  = inputSstream;
    m_errorStream  = errorStream;
    m_outputStream = outputStream;
}

bool wxProcess::IsInputOpened() const
{
    return m_inputStream && m_inputStream->GetLastError() != wxSTREAM_EOF;
}

bool wxProcess::IsInputAvailable() const
{
    return m_inputStream && m_inputStream->CanRead();
}

bool wxProcess::IsErrorAvailable() const
{
    return m_errorStream && m_errorStream->CanRead();
}

#endif // wxUSE_STREAMS

// ----------------------------------------------------------------------------
// process killing
// ----------------------------------------------------------------------------

/* static */
wxKillError wxProcess::Kill(int pid, wxSignal sig, int flags)
{
    wxKillError rc;
    (void)wxKill(pid, sig, &rc, flags);

    return rc;
}

/* static */
bool wxProcess::Exists(int pid)
{
    switch ( Kill(pid, wxSIGNONE) )
    {
        case wxKILL_OK:
        case wxKILL_ACCESS_DENIED:
            return true;

        default:
        case wxKILL_ERROR:
        case wxKILL_BAD_SIGNAL:
            wxFAIL_MSG( _T("unexpected wxProcess::Kill() return code") );
            // fall through

        case wxKILL_NO_PROCESS:
            return false;
    }
}

1	william	31	/////////////////////////////////////////////////////////////////////////////
2			// Name: process.cpp
3			// Purpose: Process termination classes
4			// Author: Guilhem Lavaux
5			// Modified by: Vadim Zeitlin to check error codes, added Detach() method
6			// Created: 24/06/98
7			// RCS-ID: $Id: process.cpp 42702 2006-10-30 09:03:18Z JS $
8			// Copyright: (c) Guilhem Lavaux
9			// Licence: wxWindows licence
10			/////////////////////////////////////////////////////////////////////////////
11
12			// ============================================================================
13			// declarations
14			// ============================================================================
15
16			// ----------------------------------------------------------------------------
17			// headers
18			// ----------------------------------------------------------------------------
19
20			// For compilers that support precompilation, includes "wx.h".
21			#include "wx/wxprec.h"
22
23			#ifdef __BORLANDC__
24			#pragma hdrstop
25			#endif
26
27			#include "wx/process.h"
28
29			// ----------------------------------------------------------------------------
30			// event tables and such
31			// ----------------------------------------------------------------------------
32
33			DEFINE_EVENT_TYPE(wxEVT_END_PROCESS)
34
35			IMPLEMENT_DYNAMIC_CLASS(wxProcess, wxEvtHandler)
36			IMPLEMENT_DYNAMIC_CLASS(wxProcessEvent, wxEvent)
37
38			// ============================================================================
39			// wxProcess implementation
40			// ============================================================================
41
42			// ----------------------------------------------------------------------------
43			// wxProcess creation
44			// ----------------------------------------------------------------------------
45
46			void wxProcess::Init(wxEvtHandler *parent, int id, int flags)
47			{
48			if ( parent )
49			SetNextHandler(parent);
50
51			m_id = id;
52			m_pid = 0;
53			m_redirect = (flags & wxPROCESS_REDIRECT) != 0;
54
55			#if wxUSE_STREAMS
56			m_inputStream = NULL;
57			m_errorStream = NULL;
58			m_outputStream = NULL;
59			#endif // wxUSE_STREAMS
60			}
61
62			/* static */
63			wxProcess *wxProcess::Open(const wxString& cmd, int flags)
64			{
65			wxASSERT_MSG( !(flags & wxEXEC_SYNC), wxT("wxEXEC_SYNC should not be used." ));
66			wxProcess *process = new wxProcess(wxPROCESS_REDIRECT);
67			long pid = wxExecute(cmd, flags, process);
68			if( !pid )
69			{
70			// couldn't launch the process
71			delete process;
72			return NULL;
73			}
74
75			process->SetPid(pid);
76
77			return process;
78			}
79
80			// ----------------------------------------------------------------------------
81			// wxProcess termination
82			// ----------------------------------------------------------------------------
83
84			wxProcess::~wxProcess()
85			{
86			#if wxUSE_STREAMS
87			delete m_inputStream;
88			delete m_errorStream;
89			delete m_outputStream;
90			#endif // wxUSE_STREAMS
91			}
92
93			void wxProcess::OnTerminate(int pid, int status)
94			{
95			wxProcessEvent event(m_id, pid, status);
96
97			if ( !ProcessEvent(event) )
98			delete this;
99			//else: the object which processed the event is responsible for deleting
100			// us!
101			}
102
103			void wxProcess::Detach()
104			{
105			SetNextHandler(NULL);
106			}
107
108			// ----------------------------------------------------------------------------
109			// process IO redirection
110			// ----------------------------------------------------------------------------
111
112			#if wxUSE_STREAMS
113
114			void wxProcess::SetPipeStreams(wxInputStream *inputSstream,
115			wxOutputStream *outputStream,
116			wxInputStream *errorStream)
117			{
118			m_inputStream = inputSstream;
119			m_errorStream = errorStream;
120			m_outputStream = outputStream;
121			}
122
123			bool wxProcess::IsInputOpened() const
124			{
125			return m_inputStream && m_inputStream->GetLastError() != wxSTREAM_EOF;
126			}
127
128			bool wxProcess::IsInputAvailable() const
129			{
130			return m_inputStream && m_inputStream->CanRead();
131			}
132
133			bool wxProcess::IsErrorAvailable() const
134			{
135			return m_errorStream && m_errorStream->CanRead();
136			}
137
138			#endif // wxUSE_STREAMS
139
140			// ----------------------------------------------------------------------------
141			// process killing
142			// ----------------------------------------------------------------------------
143
144			/* static */
145			wxKillError wxProcess::Kill(int pid, wxSignal sig, int flags)
146			{
147			wxKillError rc;
148			(void)wxKill(pid, sig, &rc, flags);
149
150			return rc;
151			}
152
153			/* static */
154			bool wxProcess::Exists(int pid)
155			{
156			switch ( Kill(pid, wxSIGNONE) )
157			{
158			case wxKILL_OK:
159			case wxKILL_ACCESS_DENIED:
160			return true;
161
162			default:
163			case wxKILL_ERROR:
164			case wxKILL_BAD_SIGNAL:
165			wxFAIL_MSG( _T("unexpected wxProcess::Kill() return code") );
166			// fall through
167
168			case wxKILL_NO_PROCESS:
169			return false;
170			}
171			}
172