/////////////////////////////////////////////////////////////////////////////
-// Name: utilsunx.cpp
+// Name: unix/utilsunx.cpp
// Purpose: generic Unix implementation of many wx functions
// Author: Vadim Zeitlin
// Id: $Id$
#include "wx/wfstream.h"
+#if defined( __MWERKS__ ) && defined(__MACH__)
+#define WXWIN_OS_DESCRIPTION "MacOS X"
+#define HAVE_NANOSLEEP
+#endif
+
+// not only the statfs syscall is called differently depending on platform, but
+// one of its incarnations, statvfs(), takes different arguments under
+// different platforms and even different versions of the same system (Solaris
+// 7 and 8): if you want to test for this, don't forget that the problems only
+// appear if the large files support is enabled
#ifdef HAVE_STATFS
-# ifdef __BSD__
-# include <sys/param.h>
-# include <sys/mount.h>
-# else
-# include <sys/vfs.h>
-# endif
+ #ifdef __BSD__
+ #include <sys/param.h>
+ #include <sys/mount.h>
+ #else // !__BSD__
+ #include <sys/vfs.h>
+ #endif // __BSD__/!__BSD__
+
+ #define wxStatfs statfs
#endif // HAVE_STATFS
-// not only the statfs syscall is called differently depending on platform, but
-// we also can't use "struct statvfs" under Solaris because it breaks down if
-// HAVE_LARGEFILE_SUPPORT == 1 and we must use statvfs_t instead
#ifdef HAVE_STATVFS
#include <sys/statvfs.h>
- #define statfs statvfs
- #define wxStatFs statvfs_t
-#elif HAVE_STATFS
- #define wxStatFs struct statfs
-#endif // HAVE_STAT[V]FS
+ #define wxStatfs statvfs
+#endif // HAVE_STATVFS
+
+#if defined(HAVE_STATFS) || defined(HAVE_STATVFS)
+ // WX_STATFS_T is detected by configure
+ #define wxStatfs_t WX_STATFS_T
+#endif
#if wxUSE_GUI
#include "wx/unix/execute.h"
{
wxCHECK_MSG( !command.IsEmpty(), 0, wxT("can't exec empty command") );
+#if wxUSE_THREADS
+ // fork() doesn't mix well with POSIX threads: on many systems the program
+ // deadlocks or crashes for some reason. Probably our code is buggy and
+ // doesn't do something which must be done to allow this to work, but I
+ // don't know what yet, so for now just warn the user (this is the least we
+ // can do) about it
+ wxASSERT_MSG( wxThread::IsMain(),
+ _T("wxExecute() can be called only from the main thread") );
+#endif // wxUSE_THREADS
+
int argc = 0;
wxChar *argv[WXEXECUTE_NARGS];
wxString argument;
#if wxUSE_STREAMS
// ----------------------------------------------------------------------------
-// wxProcessFileInputStream: stream for reading from a pipe
+// wxPipeInputStream: stream for reading from a pipe
// ----------------------------------------------------------------------------
-class wxProcessFileInputStream : public wxFileInputStream
+class wxPipeInputStream : public wxFileInputStream
{
public:
- wxProcessFileInputStream(int fd) : wxFileInputStream(fd) { }
+ wxPipeInputStream(int fd) : wxFileInputStream(fd) { }
+
+ // return TRUE if the pipe is still opened
+ bool IsOpened() const { return !Eof(); }
// return TRUE if we have anything to read, don't block
- bool IsAvailable() const;
+ virtual bool CanRead() const;
};
-bool wxProcessFileInputStream::IsAvailable() const
+bool wxPipeInputStream::CanRead() const
{
if ( m_lasterror == wxSTREAM_EOF )
- return TRUE;
+ return FALSE;
// check if there is any input available
struct timeval tv;
// fall through
case 0:
- return TRUE;
+ return FALSE;
default:
wxFAIL_MSG(_T("unexpected select() return value"));
// still fall through
case 1:
- // input available
- return TRUE;
+ // input available -- or maybe not, as select() returns 1 when a
+ // read() will complete without delay, but it could still not read
+ // anything
+ return !Eof();
}
}
-// ----------------------------------------------------------------------------
-// wxStreamTempInputBuffer
-// ----------------------------------------------------------------------------
-
-/*
- Extract of a mail to wx-users to give the context of the problem we are
- trying to solve here:
-
- MC> If I run the command:
- MC> find . -name "*.h" -exec grep linux {} \;
- MC> in the exec sample synchronously from the 'Capture command output'
- MC> menu, wxExecute never returns. I have to xkill it. Has anyone
- MC> else encountered this?
-
- Yes, I can reproduce it too.
-
- I even think I understand why it happens: before launching the external
- command we set up a pipe with a valid file descriptor on the reading side
- when the output is redirected. So the subprocess happily writes to it ...
- until the pipe buffer (which is usually quite big on Unix, I think the
- default is 4Kb) is full. Then the writing process stops and waits until we
- read some data from the pipe to be able to continue writing to it but we
- never do it because we wait until it terminates to start reading and so we
- have a classical deadlock.
-
- Here is the fix: we now read the output as soon as it appears into a temp
- buffer (wxStreamTempInputBuffer object) and later just stuff it back into the
- stream when the process terminates. See supporting code in wxExecute()
- itself as well.
-
- Note that this is horribly inefficient for large amounts of output (count
- the number of times we copy the data around) and so a better API is badly
- needed!
-*/
-
-class wxStreamTempInputBuffer
-{
-public:
- wxStreamTempInputBuffer();
-
- // call to associate a stream with this buffer, otherwise nothing happens
- // at all
- void Init(wxProcessFileInputStream *stream);
-
- // check for input on our stream and cache it in our buffer if any
- void Update();
-
- ~wxStreamTempInputBuffer();
-
-private:
- // the stream we're buffering, if NULL we don't do anything at all
- wxProcessFileInputStream *m_stream;
-
- // the buffer of size m_size (NULL if m_size == 0)
- void *m_buffer;
-
- // the size of the buffer
- size_t m_size;
-};
-
-wxStreamTempInputBuffer::wxStreamTempInputBuffer()
-{
- m_stream = NULL;
- m_buffer = NULL;
- m_size = 0;
-}
-
-void wxStreamTempInputBuffer::Init(wxProcessFileInputStream *stream)
-{
- m_stream = stream;
-}
-
-void wxStreamTempInputBuffer::Update()
-{
- if ( m_stream && m_stream->IsAvailable() )
- {
- // realloc in blocks of 4Kb: this is the default (and minimal) buffer
- // size of the Unix pipes so it should be the optimal step
- static const size_t incSize = 4096;
-
- void *buf = realloc(m_buffer, m_size + incSize);
- if ( !buf )
- {
- // don't read any more, we don't have enough memory to do it
- m_stream = NULL;
- }
- else // got memory for the buffer
- {
- m_buffer = buf;
- m_stream->Read((char *)m_buffer + m_size, incSize);
- m_size += m_stream->LastRead();
- }
- }
-}
-
-wxStreamTempInputBuffer::~wxStreamTempInputBuffer()
-{
- if ( m_buffer )
- {
- m_stream->Ungetch(m_buffer, m_size);
- free(m_buffer);
- }
-}
+// define this to let wxexec.cpp know that we know what we're doing
+#define _WX_USED_BY_WXEXECUTE_
+#include "../common/execcmn.cpp"
#endif // wxUSE_STREAMS
// wxExecute: the real worker function
// ----------------------------------------------------------------------------
+#ifdef __VMS
+ #pragma message disable codeunreachable
+#endif
+
long wxExecute(wxChar **argv,
int flags,
wxProcess *process)
wxChar **mb_argv = argv;
#endif // Unicode/ANSI
-#if wxUSE_GUI
+#if wxUSE_GUI && !(defined(__DARWIN__) && defined(__WXMAC__))
// create pipes
wxPipe pipeEndProcDetect;
if ( !pipeEndProcDetect.Create() )
return ERROR_RETURN_CODE;
}
-#endif // wxUSE_GUI
+#endif // wxUSE_GUI && !(defined(__DARWIN__) && defined(__WXMAC__))
// pipes for inter process communication
wxPipe pipeIn, // stdin
}
// fork the process
-#ifdef HAVE_VFORK
- pid_t pid = vfork();
+ //
+ // NB: do *not* use vfork() here, it completely breaks this code for some
+ // reason under Solaris (and maybe others, although not under Linux)
+ // But on OpenVMS we do not have fork so we have to use vfork and
+ // cross our fingers that it works.
+#ifdef __VMS
+ pid_t pid = vfork();
#else
- pid_t pid = fork();
+ pid_t pid = fork();
#endif
-
- if ( pid == -1 ) // error?
+ if ( pid == -1 ) // error?
{
wxLogSysError( _("Fork failed") );
if ( fd == pipeIn[wxPipe::Read]
|| fd == pipeOut[wxPipe::Write]
|| fd == pipeErr[wxPipe::Write]
-#if wxUSE_GUI
+#if wxUSE_GUI && !(defined(__DARWIN__) && defined(__WXMAC__))
|| fd == pipeEndProcDetect[wxPipe::Write]
-#endif // wxUSE_GUI
+#endif // wxUSE_GUI && !(defined(__DARWIN__) && defined(__WXMAC__))
)
{
// don't close this one, we still need it
}
}
-#ifndef __VMS
+#if !defined(__VMS) && !defined(__EMX__)
if ( flags & wxEXEC_MAKE_GROUP_LEADER )
{
// Set process group to child process' pid. Then killing -pid
}
#endif // !__VMS
-#if wxUSE_GUI
+#if wxUSE_GUI && !(defined(__DARWIN__) && defined(__WXMAC__))
// reading side can be safely closed but we should keep the write one
// opened
pipeEndProcDetect.Detach(wxPipe::Write);
pipeEndProcDetect.Close();
-#endif // wxUSE_GUI
+#endif // wxUSE_GUI && !(defined(__DARWIN__) && defined(__WXMAC__))
// redirect stdin, stdout and stderr
if ( pipeIn.IsOk() )
execvp (*mb_argv, mb_argv);
+ fprintf(stderr, "execvp(");
+ // CS changed ppc to ppc_ as ppc is not available under mac os CW Mach-O
+ for ( char **ppc_ = mb_argv; *ppc_; ppc_++ )
+ fprintf(stderr, "%s%s", ppc_ == mb_argv ? "" : ", ", *ppc_);
+ fprintf(stderr, ") failed with error %d!\n", errno);
+
// there is no return after successful exec()
_exit(-1);
wxOutputStream *inStream =
new wxFileOutputStream(pipeIn.Detach(wxPipe::Write));
- wxProcessFileInputStream *outStream =
- new wxProcessFileInputStream(pipeOut.Detach(wxPipe::Read));
+ wxPipeInputStream *outStream =
+ new wxPipeInputStream(pipeOut.Detach(wxPipe::Read));
- wxProcessFileInputStream *errStream =
- new wxProcessFileInputStream(pipeErr.Detach(wxPipe::Read));
+ wxPipeInputStream *errStream =
+ new wxPipeInputStream(pipeErr.Detach(wxPipe::Read));
process->SetPipeStreams(outStream, inStream, errStream);
#if wxUSE_GUI && !defined(__WXMICROWIN__)
wxEndProcessData *data = new wxEndProcessData;
+ // wxAddProcessCallback is now (with DARWIN) allowed to call the
+ // callback function directly if the process terminates before
+ // the callback can be added to the run loop. Set up the data.
+ if ( flags & wxEXEC_SYNC )
+ {
+ // we may have process for capturing the program output, but it's
+ // not used in wxEndProcessData in the case of sync execution
+ data->process = NULL;
+
+ // sync execution: indicate it by negating the pid
+ data->pid = -pid;
+ }
+ else
+ {
+ // async execution, nothing special to do - caller will be
+ // notified about the process termination if process != NULL, data
+ // will be deleted in GTK_EndProcessDetector
+ data->process = process;
+ data->pid = pid;
+ }
+
+
+#if defined(__DARWIN__) && defined(__WXMAC__)
+ data->tag = wxAddProcessCallbackForPid(data,pid);
+#else
data->tag = wxAddProcessCallback
(
data,
);
pipeEndProcDetect.Close();
+#endif // defined(__DARWIN__) && defined(__WXMAC__)
if ( flags & wxEXEC_SYNC )
{
- // we may have process for capturing the program output, but it's
- // not used in wxEndProcessData in the case of sync execution
- data->process = NULL;
-
- // sync execution: indicate it by negating the pid
- data->pid = -pid;
-
wxBusyCursor bc;
wxWindowDisabler wd;
}
else // async execution
{
- // async execution, nothing special to do - caller will be
- // notified about the process termination if process != NULL, data
- // will be deleted in GTK_EndProcessDetector
- data->process = process;
- data->pid = pid;
-
return pid;
}
#else // !wxUSE_GUI
return exitcode;
#endif // wxUSE_GUI
}
+
+ return ERROR_RETURN_CODE;
}
+#ifdef __VMS
+ #pragma message enable codeunreachable
+#endif
+
#undef ERROR_RETURN_CODE
#undef ARGS_CLEANUP
const wxChar* wxGetHomeDir( wxString *home )
{
*home = wxGetUserHome( wxString() );
- wxString tmp;
+ wxString tmp;
if ( home->IsEmpty() )
*home = wxT("/");
#ifdef __VMS
- tmp = *home;
- if ( tmp.Last() != wxT(']'))
- if ( tmp.Last() != wxT('/')) *home << wxT('/');
+ tmp = *home;
+ if ( tmp.Last() != wxT(']'))
+ if ( tmp.Last() != wxT('/')) *home << wxT('/');
#endif
return home->c_str();
}
if ((ptr = wxGetenv(wxT("HOME"))) != NULL)
{
+#if wxUSE_UNICODE
+ wxWCharBuffer buffer( ptr );
+ return buffer;
+#else
return ptr;
+#endif
}
if ((ptr = wxGetenv(wxT("USER"))) != NULL || (ptr = wxGetenv(wxT("LOGNAME"))) != NULL)
{
#ifndef WXWIN_OS_DESCRIPTION
#error WXWIN_OS_DESCRIPTION should be defined in config.h by configure
#else
- return WXWIN_OS_DESCRIPTION;
+ return wxString::FromAscii( WXWIN_OS_DESCRIPTION );
#endif
}
#endif
{
#if defined(HAVE_STATFS) || defined(HAVE_STATVFS)
// the case to "char *" is needed for AIX 4.3
- wxStatFs fs;
- if ( statfs((char *)path.fn_str(), &fs) != 0 )
+ wxStatfs_t fs;
+ if ( wxStatfs((char *)(const char*)path.fn_str(), &fs) != 0 )
{
- wxLogSysError("Failed to get file system statistics");
+ wxLogSysError( wxT("Failed to get file system statistics") );
return FALSE;
}
projects / wxWidgets.git / blobdiff