diff --git a/include/wx/unix/private/execute.h b/include/wx/unix/private/execute.h index e976d154c7..156413cc42 100644 --- a/include/wx/unix/private/execute.h +++ b/include/wx/unix/private/execute.h @@ -27,17 +27,17 @@ class wxExecuteData public: wxExecuteData() { - flags = - pid = 0; - exitcode = -1; + m_flags = + m_pid = 0; + m_exitcode = -1; - process = NULL; + m_process = NULL; - syncEventLoop = NULL; + m_syncEventLoop = NULL; #if wxUSE_STREAMS - fdOut = - fdErr = wxPipe::INVALID_FD; + m_fdOut = + m_fdErr = wxPipe::INVALID_FD; #endif // wxUSE_STREAMS } @@ -51,36 +51,36 @@ public: void OnExit(int exitcode); // Return true if we should (or already did) redirect the child IO. - bool IsRedirected() const { return process && process->IsRedirected(); } + bool IsRedirected() const { return m_process && m_process->IsRedirected(); } // wxExecute() flags - int flags; + int m_flags; // the pid of the child process - int pid; + int m_pid; // The exit code of the process, set once the child terminates. - int exitcode; + int m_exitcode; // the associated process object or NULL - wxProcess *process; + wxProcess *m_process; // Local event loop used to wait for the child process termination in // synchronous execution case. We can't create it ourselves as its exact // type depends on the application kind (console/GUI), so we rely on // wxAppTraits setting up this pointer to point to the appropriate object. - wxEventLoopBase *syncEventLoop; + wxEventLoopBase *m_syncEventLoop; #if wxUSE_STREAMS // the input buffer bufOut is connected to stdout, this is why it is // called bufOut and not bufIn - wxStreamTempInputBuffer bufOut, - bufErr; + wxStreamTempInputBuffer m_bufOut, + m_bufErr; // the corresponding FDs, -1 if not redirected - int fdOut, - fdErr; + int m_fdOut, + m_fdErr; #endif // wxUSE_STREAMS diff --git a/src/unix/apptraits.cpp b/src/unix/apptraits.cpp index ba2c94629e..633000e6b0 100644 --- a/src/unix/apptraits.cpp +++ b/src/unix/apptraits.cpp @@ -40,7 +40,7 @@ int wxGUIAppTraits::WaitForChild(wxExecuteData& execData) // prepare to wait for the child termination: show to the user that we're // busy and refuse all input unless explicitly told otherwise wxBusyCursor bc; - wxWindowDisabler wd(!(execData.flags & wxEXEC_NODISABLE)); + wxWindowDisabler wd(!(execData.m_flags & wxEXEC_NODISABLE)); // Allocate an event loop that will be used to wait for the process // to terminate, will handle stdout, stderr, and any other events and pass diff --git a/src/unix/utilsunx.cpp b/src/unix/utilsunx.cpp index 2925c2f968..b4f84fb2e8 100644 --- a/src/unix/utilsunx.cpp +++ b/src/unix/utilsunx.cpp @@ -535,25 +535,25 @@ int BlockUntilChildExit(wxExecuteData& execData) stdoutHandler.reset(new wxExecuteFDIOHandler ( dispatcher, - execData.fdOut, - execData.bufOut + execData.m_fdOut, + execData.m_bufOut )); stderrHandler.reset(new wxExecuteFDIOHandler ( dispatcher, - execData.fdErr, - execData.bufErr + execData.m_fdErr, + execData.m_bufErr )); } #endif // wxUSE_STREAMS // And dispatch until the PID is reset from wxExecuteData::OnExit(). - while ( execData.pid ) + while ( execData.m_pid ) { dispatcher.Dispatch(); } - return execData.exitcode; + return execData.m_exitcode; #else // !wxUSE_SELECT_DISPATCHER wxFAIL_MSG( wxS("Can't block until child exit without wxSelectDispatcher") ); @@ -601,8 +601,8 @@ long wxExecute(const char* const* argv, int flags, wxProcess* process, wxScopedPtr execDataPtr(new wxExecuteData); wxExecuteData& execData = *execDataPtr; - execData.flags = flags; - execData.process = process; + execData.m_flags = flags; + execData.m_process = process; // create pipes for inter process communication wxPipe pipeIn, // stdin @@ -805,11 +805,11 @@ long wxExecute(const char* const* argv, int flags, wxProcess* process, if ( flags & wxEXEC_SYNC ) { - execData.bufOut.Init(outStream); - execData.bufErr.Init(errStream); + execData.m_bufOut.Init(outStream); + execData.m_bufErr.Init(errStream); - execData.fdOut = fdOut; - execData.fdErr = fdErr; + execData.m_fdOut = fdOut; + execData.m_fdErr = fdErr; } } #endif // HAS_PIPE_STREAMS @@ -1498,8 +1498,8 @@ wxAppTraits::RunLoopUntilChildExit(wxExecuteData& execData, // It is possible that wxExecuteData::OnExit() had already been called // and reset the PID to 0, in which case we don't need to do anything // at all. - if ( !execData.pid ) - return execData.exitcode; + if ( !execData.m_pid ) + return execData.m_exitcode; #if wxUSE_STREAMS // Monitor the child streams if necessary. @@ -1510,24 +1510,24 @@ wxAppTraits::RunLoopUntilChildExit(wxExecuteData& execData, { stdoutHandler.reset(new wxExecuteEventLoopSourceHandler ( - execData.fdOut, execData.bufOut + execData.m_fdOut, execData.m_bufOut )); stderrHandler.reset(new wxExecuteEventLoopSourceHandler ( - execData.fdErr, execData.bufErr + execData.m_fdErr, execData.m_bufErr )); } #endif // wxUSE_STREAMS // Store the event loop in the data associated with the child // process so that it could exit the loop when the child exits. - execData.syncEventLoop = &loop; + execData.m_syncEventLoop = &loop; // And run it. loop.Run(); // The exit code will have been set when the child termination was detected. - return execData.exitcode; + return execData.m_exitcode; } // ---------------------------------------------------------------------------- @@ -1626,7 +1626,7 @@ void wxExecuteData::OnSomeChildExited(int WXUNUSED(sig)) } } -void wxExecuteData::OnStart(int pid_) +void wxExecuteData::OnStart(int pid) { wxCHECK_RET( wxTheApp, wxS("Ensure wxTheApp is set before calling wxExecute()") ); @@ -1640,21 +1640,21 @@ void wxExecuteData::OnStart(int pid_) // Remember the child PID to be able to wait for it later. - pid = pid_; + m_pid = pid; // Also save it in wxProcess where it will be accessible to the user code. - if ( process ) - process->SetPid(pid); + if ( m_process ) + m_process->SetPid(m_pid); // Add this object itself to the list of child processes so that // we can check for its termination the next time we get SIGCHLD. - ms_childProcesses[pid] = this; + ms_childProcesses[m_pid] = this; // However, if the child exited before we finished setting up above, // we may have already missed its SIGCHLD. So we also do an explicit // check here before returning. int exitcode; - if ( CheckForChildExit(pid, &exitcode) ) + if ( CheckForChildExit(m_pid, &exitcode) ) { // Handle its termination if it did. // This call will implicitly remove it from ms_childProcesses @@ -1663,18 +1663,18 @@ void wxExecuteData::OnStart(int pid_) } } -void wxExecuteData::OnExit(int exitcode_) +void wxExecuteData::OnExit(int exitcode) { // Remove this process from the hash list of child processes that are // still open as soon as possible to ensure we don't process it again even // if another SIGCHLD happens. - if ( !ms_childProcesses.erase(pid) ) + if ( !ms_childProcesses.erase(m_pid) ) { - wxFAIL_MSG(wxString::Format(wxS("Data for PID %d not in the list?"), pid)); + wxFAIL_MSG(wxString::Format(wxS("Data for PID %d not in the list?"), m_pid)); } - exitcode = exitcode_; + m_exitcode = exitcode; #if wxUSE_STREAMS if ( IsRedirected() ) @@ -1682,16 +1682,16 @@ void wxExecuteData::OnExit(int exitcode_) // Read the remaining data in a blocking way: this is fine because the // child has already exited and hence all the data must be already // available in the streams buffers. - bufOut.ReadAll(); - bufErr.ReadAll(); + m_bufOut.ReadAll(); + m_bufErr.ReadAll(); } #endif // wxUSE_STREAMS // Notify user about termination if required - if ( !(flags & wxEXEC_SYNC) ) + if ( !(m_flags & wxEXEC_SYNC) ) { - if ( process ) - process->OnTerminate(pid, exitcode); + if ( m_process ) + m_process->OnTerminate(m_pid, m_exitcode); // in case of asynchronous execution we don't need this object any more // after the child terminates @@ -1700,10 +1700,10 @@ void wxExecuteData::OnExit(int exitcode_) else // sync execution { // let wxExecute() know that the process has terminated - pid = 0; + m_pid = 0; // Stop the event loop for synchronous wxExecute() if we're running one. - if ( syncEventLoop ) - syncEventLoop->ScheduleExit(); + if ( m_syncEventLoop ) + m_syncEventLoop->ScheduleExit(); } }