bringing wxmac in line using cflocale

[wxWidgets.git] / src / mac / corefoundation / utilsexc_cf.cpp

diff --git a/src/mac/corefoundation/utilsexc_cf.cpp b/src/mac/corefoundation/utilsexc_cf.cpp
index 5eadfff5706dff5dc58c01d905d325417daeebc7..93dc45dd5db283585477f8b660cc1b345cd00f3e 100644 (file)
--- a/src/mac/corefoundation/utilsexc_cf.cpp
+++ b/src/mac/corefoundation/utilsexc_cf.cpp
@@ -17,13 +17,18 @@
 #endif //ndef WX_PRECOMP
 #include "wx/unix/execute.h"
 #include "wx/stdpaths.h"
 #endif //ndef WX_PRECOMP
 #include "wx/unix/execute.h"
 #include "wx/stdpaths.h"

+#include "wx/app.h"

 #include "wx/apptrait.h"
 #include "wx/thread.h"
 #include "wx/process.h"
 
 #include "wx/apptrait.h"
 #include "wx/thread.h"
 #include "wx/process.h"
 

+#include <sys/wait.h>
+

 // Use polling instead of Mach ports, which doesn't work on Intel
 // due to task_for_pid security issues.
 
 // Use polling instead of Mach ports, which doesn't work on Intel
 // due to task_for_pid security issues.
 

+// http://developer.apple.com/technotes/tn/tn2050.html
+

 // What's a better test for Intel vs PPC?
 #ifdef WORDS_BIGENDIAN
 #define USE_POLLING 0
 // What's a better test for Intel vs PPC?
 #ifdef WORDS_BIGENDIAN
 #define USE_POLLING 0


@@ -33,6 +38,7 @@
 
 #if USE_POLLING
 
 
 #if USE_POLLING
 

+#if wxUSE_THREADS

 class wxProcessTerminationEventHandler: public wxEvtHandler
 {
   public:
 class wxProcessTerminationEventHandler: public wxEvtHandler
 {
   public:


@@ -46,7 +52,14 @@ class wxProcessTerminationEventHandler: public wxEvtHandler
     {
         Disconnect(-1, wxEVT_END_PROCESS, wxProcessEventHandler(wxProcessTerminationEventHandler::OnTerminate));
         wxHandleProcessTermination(m_data);
     {
         Disconnect(-1, wxEVT_END_PROCESS, wxProcessEventHandler(wxProcessTerminationEventHandler::OnTerminate));
         wxHandleProcessTermination(m_data);

-        delete this;
+
+        // NOTE: We don't use this to delay destruction until the next idle run but rather to
+        // avoid killing ourselves while our caller (which is our wxEvtHandler superclass
+        // ProcessPendingEvents) still needs our m_eventsLocker to be valid.
+        // Since we're in the GUI library we can guarantee that ScheduleForDestroy is using
+        // the GUI implementation which delays destruction and not the base implementation
+        // which does it immediately.
+        wxTheApp->GetTraits()->ScheduleForDestroy(this);

     }
 
     wxEndProcessData* m_data;
     }
 
     wxEndProcessData* m_data;


@@ -77,7 +90,7 @@ void* wxProcessTerminationThread::Entry()
     {
         usleep(100);
         int status = 0;
     {
         usleep(100);
         int status = 0;

-        int rc = waitpid(abs(m_data->pid), & status, WNOHANG);
+        int rc = waitpid(abs(m_data->pid), & status, 0);

         if (rc != 0)
         {
             if ((rc != -1) && WIFEXITED(status))
         if (rc != 0)
         {
             if ((rc != -1) && WIFEXITED(status))


@@ -91,7 +104,7 @@ void* wxProcessTerminationThread::Entry()
             break;
         }
     }
             break;
         }
     }

-    
+

     return NULL;
 }
 
     return NULL;
 }
 


@@ -100,9 +113,9 @@ int wxAddProcessCallbackForPid(wxEndProcessData *proc_data, int pid)
     if (pid < 1)
         return -1;
 
     if (pid < 1)
         return -1;
 

-    wxProcessTerminationEventHandler* handler = new wxProcessTerminationEventHandler(proc_data);    
+    wxProcessTerminationEventHandler* handler = new wxProcessTerminationEventHandler(proc_data);

     wxProcessTerminationThread* thread = new wxProcessTerminationThread(proc_data, handler);
     wxProcessTerminationThread* thread = new wxProcessTerminationThread(proc_data, handler);

-    
+

     if (thread->Create() != wxTHREAD_NO_ERROR)
     {
         wxLogDebug(wxT("Could not create termination detection thread."));
     if (thread->Create() != wxTHREAD_NO_ERROR)
     {
         wxLogDebug(wxT("Could not create termination detection thread."));


@@ -112,19 +125,25 @@ int wxAddProcessCallbackForPid(wxEndProcessData *proc_data, int pid)
     }
 
     thread->Run();
     }
 
     thread->Run();

-    
+

     return 0;
 }
     return 0;
 }

+#else // !wxUSE_THREADS
+int wxAddProcessCallbackForPid(wxEndProcessData*, int)
+{
+    wxLogDebug(wxT("Could not create termination detection thread."));
+    return -1;
+}
+#endif // wxUSE_THREADS/!wxUSE_THREADS

 
 

-#else
+#else // !USE_POLLING

 
 #include <CoreFoundation/CFMachPort.h>
 
 #include <CoreFoundation/CFMachPort.h>

-#include <sys/wait.h>

 extern "C" {
 #include <mach/mach.h>
 }
 
 extern "C" {
 #include <mach/mach.h>
 }
 

-void wxMAC_MachPortEndProcessDetect(CFMachPortRef port, void *data)
+void wxMAC_MachPortEndProcessDetect(CFMachPortRef WXUNUSED(port), void *data)

 {
     wxEndProcessData *proc_data = (wxEndProcessData*)data;
     wxLogDebug(wxT("Process ended"));
 {
     wxEndProcessData *proc_data = (wxEndProcessData*)data;
     wxLogDebug(wxT("Process ended"));


@@ -132,13 +151,13 @@ void wxMAC_MachPortEndProcessDetect(CFMachPortRef port, void *data)
     int rc = waitpid(abs(proc_data->pid), &status, WNOHANG);
     if(!rc)
     {
     int rc = waitpid(abs(proc_data->pid), &status, WNOHANG);
     if(!rc)
     {

-       wxLogDebug(wxT("Mach port was invalidated, but process hasn't terminated!"));
-       return;
+        wxLogDebug(wxT("Mach port was invalidated, but process hasn't terminated!"));
+        return;

     }
     if((rc != -1) && WIFEXITED(status))
     }
     if((rc != -1) && WIFEXITED(status))

-       proc_data->exitcode = WEXITSTATUS(status);
+        proc_data->exitcode = WEXITSTATUS(status);

     else
     else

-       proc_data->exitcode = -1;
+        proc_data->exitcode = -1;

     wxHandleProcessTermination(proc_data);
 }
 
     wxHandleProcessTermination(proc_data);
 }
 


@@ -201,7 +220,7 @@ int wxAddProcessCallbackForPid(wxEndProcessData *proc_data, int pid)
         wxLogDebug(wxT("Couldn't create runloopsource"));
         return -1;
     }
         wxLogDebug(wxT("Couldn't create runloopsource"));
         return -1;
     }

-    
+

     CFRelease(CFMachPortForProcess);
 
     CFRunLoopAddSource(CFRunLoopGetCurrent(),runloopsource,kCFRunLoopDefaultMode);
     CFRelease(CFMachPortForProcess);
 
     CFRunLoopAddSource(CFRunLoopGetCurrent(),runloopsource,kCFRunLoopDefaultMode);


@@ -210,14 +229,140 @@ int wxAddProcessCallbackForPid(wxEndProcessData *proc_data, int pid)
     return 0;
 }
 
     return 0;
 }
 

-#endif
-  // USE_POLLING
+#endif // USE_POLLING/!USE_POLLING
+
+/////////////////////////////////////////////////////////////////////////////
+// New implementation avoiding mach ports entirely.
+
+#include <CoreFoundation/CFSocket.h>
+
+/*!
+    Called due to source signal detected by the CFRunLoop.
+    This is nearly identical to the wxGTK equivalent.
+ */
+extern "C" void WXCF_EndProcessDetector(CFSocketRef s,
+                                        CFSocketCallBackType WXUNUSED(callbackType),
+                                        CFDataRef WXUNUSED(address),
+                                        void const *WXUNUSED(data),
+                                        void *info)
+{
+    wxEndProcessData * const proc_data = static_cast<wxEndProcessData*>(info);
+
+/// This code could reasonably be shared between wxMac/wxCocoa and wxGTK ///
+    // PID is always positive on UNIX but wx uses the sign bit as a flag.
+    int pid = (proc_data->pid > 0) ? proc_data->pid : -proc_data->pid;
+    int status = 0;
+    int rc = waitpid(pid, &status, WNOHANG);
+    if(rc == 0)
+    {
+        // Keep waiting in case we got a spurious notification
+        // NOTE: In my limited testing, this doesn't happen.
+        return;
+    }
+
+    if(rc == -1)
+    {   // Error.. really shouldn't happen but try to gracefully handle it
+        wxLogLastError(_T("waitpid"));
+        proc_data->exitcode = -1;
+    }
+    else
+    {   // Process ended for some reason
+        wxASSERT_MSG(rc == pid, _T("unexpected waitpid() return value"));
+
+        if(WIFEXITED(status))
+            proc_data->exitcode = WEXITSTATUS(status);
+        else if(WIFSIGNALED(status))
+            // wxGTK doesn't do this but why not?
+            proc_data->exitcode = -WTERMSIG(status);
+        else
+        {   // Should NEVER happen according to waitpid docs
+            wxLogError(wxT("waitpid indicates process exited but not due to exiting or signalling"));
+            proc_data->exitcode = -1;
+        }
+    }
+/// The above code could reasonably be shared between wxMac/wxCocoa and wxGTK ///
+
+    /*
+        Either waitpid failed or the process ended successfully.  Either way,
+        we're done.  It's not if waitpid is going to magically succeed when
+        we get fired again.  CFSocketInvalidate closes the fd for us and also
+        invalidates the run loop source for us which should cause it to
+        release the CFSocket (thus causing it to be deallocated) and remove
+        itself from the runloop which should release it and cause it to also
+        be deallocated.  Of course, it's possible the RunLoop hangs onto
+        one or both of them by retaining/releasing them within its stack
+        frame.  However, that shouldn't be depended on.  Assume that s is
+        deallocated due to the following call.
+     */
+    CFSocketInvalidate(s);

 
 

-// NOTE: This doens't really belong here but this was a handy file to
+    // Now tell wx that the process has ended.
+    wxHandleProcessTermination(proc_data);
+}
+
+/*!
+    Implements the GUI-specific wxAddProcessCallback for both wxMac and
+    wxCocoa using the CFSocket/CFRunLoop API which is available to both.
+    Takes advantage of the fact that sockets on UNIX are just regular
+    file descriptors and thus even a non-socket file descriptor can
+    apparently be used with CFSocket so long as you only tell CFSocket
+    to do things with it that would be valid for a non-socket fd.
+ */
+int wxAddProcessCallback(wxEndProcessData *proc_data, int fd)
+{
+    static int s_last_tag = 0;
+    CFSocketContext context =
+    {   0
+    ,   static_cast<void*>(proc_data)
+    ,   NULL
+    ,   NULL
+    ,   NULL
+    };
+    CFSocketRef cfSocket = CFSocketCreateWithNative(kCFAllocatorDefault,fd,kCFSocketReadCallBack,&WXCF_EndProcessDetector,&context);
+    if(cfSocket == NULL)
+    {
+        wxLogError(wxT("Failed to create socket for end process detection"));
+        return 0;
+    }
+    CFRunLoopSourceRef runLoopSource = CFSocketCreateRunLoopSource(kCFAllocatorDefault, cfSocket, /*highest priority:*/0);
+    if(runLoopSource == NULL)
+    {
+        wxLogError(wxT("Failed to create CFRunLoopSource from CFSocket for end process detection"));
+        // closes the fd.. we can't really stop it, nor do we necessarily want to.
+        CFSocketInvalidate(cfSocket);
+        CFRelease(cfSocket);
+        return 0;
+    }
+    // Now that the run loop source has the socket retained and we no longer
+    // need to refer to it within this method, we can release it.
+    CFRelease(cfSocket);
+
+    CFRunLoopAddSource(CFRunLoopGetCurrent(), runLoopSource, kCFRunLoopCommonModes);
+    // Now that the run loop has the source retained we can release it.
+    CFRelease(runLoopSource);
+
+    /*
+        Feed wx some bullshit.. we don't use it since CFSocket helpfully passes
+        itself into our callback and that's enough to be able to
+        CFSocketInvalidate it which is all we need to do to get everything we
+        just created to be deallocated.
+     */
+    return ++s_last_tag;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+
+// NOTE: This doesn't really belong here but this was a handy file to

 // put it in because it's already compiled for wxCocoa and wxMac GUI lib.
 // put it in because it's already compiled for wxCocoa and wxMac GUI lib.

+#if wxUSE_GUI
+
+#if wxUSE_STDPATHS

 static wxStandardPathsCF gs_stdPaths;
 wxStandardPathsBase& wxGUIAppTraits::GetStandardPaths()
 {
     return gs_stdPaths;
 }
 static wxStandardPathsCF gs_stdPaths;
 wxStandardPathsBase& wxGUIAppTraits::GetStandardPaths()
 {
     return gs_stdPaths;
 }

+#endif
+
+#endif // wxUSE_GUI