ChangeLogTag:Wed Aug 24 19:09:31 2005 Steve Huston <shuston@riverace.com>

4 files changed, 244 insertions, 213 deletions

diff --git a/ChangeLog b/ChangeLog
index 20c12aeb715..e8c00918581 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,12 @@
+Wed Aug 24 19:09:31 2005  Steve Huston  <shuston@riverace.com>
+
+	* configure.ac: Copied in updated copyright paragraph from COPYING.
+
+	* ace/OS_NS_Thread.cpp: Formatting fixes.
+
+	* tests/Process_Manual_Event_Test.cpp: ACE_ERROR formatting
+	  corrections (%p needs a string); code format fixes.
+
 Wed Aug 24 17:15:28 2005  Steve Huston  <shuston@riverace.com>
 
 	* ace/Stream_Modules.h: Added some info about ACE_Stream_Head so
diff --git a/ace/OS_NS_Thread.cpp b/ace/OS_NS_Thread.cpp
index 130f67bec7e..b34c371e758 100644
--- a/ace/OS_NS_Thread.cpp
+++ b/ace/OS_NS_Thread.cpp
@@ -2808,193 +2808,202 @@ ACE_OS::event_init (ACE_event_t *event,
   ACE_eventdata_t* evtdata;
 
   if (type == USYNC_PROCESS)
-  {
-    int owner = 0;
-    // Let's see if the shared memory entity already exists.
-    ACE_HANDLE fd = ACE_OS::shm_open (ACE_TEXT_CHAR_TO_TCHAR(name),
-                                      O_RDWR | O_CREAT | O_EXCL,
-                                      ACE_DEFAULT_FILE_PERMS);
-    if (fd == ACE_INVALID_HANDLE)
     {
-      if (errno == EEXIST)
-        fd = ACE_OS::shm_open (ACE_TEXT_CHAR_TO_TCHAR(name),
-                               O_RDWR | O_CREAT,
-                               ACE_DEFAULT_FILE_PERMS);
+      int owner = 0;
+      // Let's see if the shared memory entity already exists.
+      ACE_HANDLE fd = ACE_OS::shm_open (ACE_TEXT_CHAR_TO_TCHAR (name),
+                                        O_RDWR | O_CREAT | O_EXCL,
+                                        ACE_DEFAULT_FILE_PERMS);
+      if (fd == ACE_INVALID_HANDLE)
+        {
+          if (errno == EEXIST)
+            fd = ACE_OS::shm_open (ACE_TEXT_CHAR_TO_TCHAR (name),
+                                   O_RDWR | O_CREAT,
+                                   ACE_DEFAULT_FILE_PERMS);
+          if (fd == ACE_INVALID_HANDLE)   // Still can't get it.
+            return -1;
+        }
       else
-        return(-1);
-    }
-    else
-    {
+        {
           // We own this shared memory object!  Let's set its size.
-      if (ACE_OS::ftruncate (fd,
-                             sizeof (ACE_eventdata_t)) == -1)
-      {
-        ACE_OS::close (fd);
-        return(-1);
-      }
-      owner = 1;
-    }
+          if (ACE_OS::ftruncate (fd, sizeof (ACE_eventdata_t)) == -1)
+            {
+              ACE_OS::close (fd);
+              return -1;
+            }
+          owner = 1;
+        }
 
-    evtdata =
+      evtdata =
         (ACE_eventdata_t *) ACE_OS::mmap (0,
                                           sizeof (ACE_eventdata_t),
                                           PROT_RDWR,
                                           MAP_SHARED,
                                           fd,
                                           0);
-    ACE_OS::close (fd);
-    if (evtdata == MAP_FAILED)
-    {
-      if (owner)
-        ACE_OS::shm_unlink (ACE_TEXT_CHAR_TO_TCHAR(name));
-      return(-1);
-    }
+      ACE_OS::close (fd);
+      if (evtdata == MAP_FAILED)
+        {
+          if (owner)
+            ACE_OS::shm_unlink (ACE_TEXT_CHAR_TO_TCHAR (name));
+          return -1;
+        }
 
-    if (owner)
-    {
-      event->name_ = ACE_OS::strdup (name);
-      if (event->name_ == 0)
-      {
-        ACE_OS::shm_unlink (ACE_TEXT_CHAR_TO_TCHAR(name));
-        return(-1);
-      }
-      event->eventdata_ = evtdata;
-      event->eventdata_->type_ = type;
-      event->eventdata_->manual_reset_ = manual_reset;
-      event->eventdata_->is_signaled_ = initial_state;
-      event->eventdata_->auto_event_signaled_ = false;
-      event->eventdata_->waiting_threads_ = 0;
-      event->eventdata_->signal_count_ = 0;
+      if (owner)
+        {
+          event->name_ = ACE_OS::strdup (name);
+          if (event->name_ == 0)
+            {
+              ACE_OS::shm_unlink (ACE_TEXT_CHAR_TO_TCHAR (name));
+              return -1;
+            }
+          event->eventdata_ = evtdata;
+          event->eventdata_->type_ = type;
+          event->eventdata_->manual_reset_ = manual_reset;
+          event->eventdata_->is_signaled_ = initial_state;
+          event->eventdata_->auto_event_signaled_ = false;
+          event->eventdata_->waiting_threads_ = 0;
+          event->eventdata_->signal_count_ = 0;
 
 # if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && !defined (ACE_LACKS_CONDATTR_PSHARED)) || \
     (!defined (ACE_USES_FIFO_SEM) && \
       (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_SEM_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM)))
-      int result = ACE_OS::cond_init (&event->eventdata_->condition_,
-                                       static_cast<short> (type),
-                                       name,
-                                       arg);
+          int result = ACE_OS::cond_init (&event->eventdata_->condition_,
+                                          static_cast<short> (type),
+                                          name,
+                                          arg);
 # else
-      char   sem_name[128];
-      ACE_OS::strncpy (sem_name, name, sizeof(sem_name)-(1+sizeof("._ACE_EVTSEM_")));
-      ACE_OS::strcat (sem_name, "._ACE_EVTSEM_");
-      int result = ACE_OS::sema_init (&event->semaphore_,
-                                      0,
-                                      type,
-                                      sem_name,
-                                      arg);
+          char   sem_name[128];
+          ACE_OS::strncpy (sem_name,
+                           name,
+                           sizeof (sem_name) - (1 + sizeof ("._ACE_EVTSEM_")));
+          ACE_OS::strcat (sem_name, "._ACE_EVTSEM_");
+          int result = ACE_OS::sema_init (&event->semaphore_,
+                                          0,
+                                          type,
+                                          sem_name,
+                                          arg);
 # endif
-      if (result == 0)
+          if (result == 0)
 # if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && \
         (!defined (ACE_LACKS_MUTEXATTR_PSHARED) || !defined (ACE_LACKS_CONDATTR_PSHARED))) || \
      (!defined (ACE_USES_FIFO_SEM) && \
         (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM)))
-        result = ACE_OS::mutex_init (&event->eventdata_->lock_,
-                                      type,
-                                      name,
-                                      (ACE_mutexattr_t *) arg);
+            result = ACE_OS::mutex_init (&event->eventdata_->lock_,
+                                         type,
+                                         name,
+                                         (ACE_mutexattr_t *) arg);
 # else
-        {
-          char   lck_name[128];
-          ACE_OS::strncpy (lck_name, name, sizeof(lck_name)-(1+sizeof("._ACE_EVTLCK_")));
-          ACE_OS::strcat (lck_name, "._ACE_EVTLCK_");
-          result = ACE_OS::sema_init (&event->lock_,
-                                      0,
-                                      type,
-                                      lck_name,
-                                      arg);
-          if (result == 0)
-            result = ACE_OS::sema_post(&event->lock_);    /* initially unlock */
-        }
+          {
+            char   lck_name[128];
+            ACE_OS::strncpy
+              (lck_name,
+               name,
+               sizeof (lck_name) - (1 + sizeof ("._ACE_EVTLCK_")));
+            ACE_OS::strcat (lck_name, "._ACE_EVTLCK_");
+            result = ACE_OS::sema_init (&event->lock_,
+                                        0,
+                                        type,
+                                        lck_name,
+                                        arg);
+            if (result == 0)
+              result = ACE_OS::sema_post (&event->lock_); /* Initially unlock */
+          }
 # endif
-      return result;
-    }
-    else
-    {
-      int result = 0;
+          return result;
+        }
+      else
+        {
+          int result = 0;
 
-      event->name_ = 0;
-      event->eventdata_ = evtdata;
+          event->name_ = 0;
+          event->eventdata_ = evtdata;
 #if (!defined (ACE_HAS_PTHREADS) || !defined (_POSIX_THREAD_PROCESS_SHARED) || defined (ACE_LACKS_CONDATTR_PSHARED)) && \
   (defined (ACE_USES_FIFO_SEM) || \
     (defined (ACE_HAS_POSIX_SEM) && defined (ACE_HAS_POSIX_SEM_TIMEOUT) && !defined (ACE_LACKS_NAMED_POSIX_SEM)))
-      char   sem_name[128];
-      ACE_OS::strncpy (sem_name, name, sizeof(sem_name)-(1+sizeof("._ACE_EVTSEM_")));
-      ACE_OS::strcat (sem_name, "._ACE_EVTSEM_");
-      result = ACE_OS::sema_init(&event->semaphore_,
-                                  0,
-                                  type,
-                                  sem_name,
-                                  arg);
+          char   sem_name[128];
+          ACE_OS::strncpy (sem_name,
+                           name,
+                           sizeof (sem_name) - (1 + sizeof ("._ACE_EVTSEM_")));
+          ACE_OS::strcat (sem_name, "._ACE_EVTSEM_");
+          result = ACE_OS::sema_init(&event->semaphore_,
+                                     0,
+                                     type,
+                                     sem_name,
+                                     arg);
 # endif
 
 # if (!defined (ACE_HAS_PTHREADS) || !defined (_POSIX_THREAD_PROCESS_SHARED) || \
         (defined (ACE_LACKS_MUTEXATTR_PSHARED) && defined (ACE_LACKS_CONDATTR_PSHARED))) && \
      (defined (ACE_USES_FIFO_SEM) || \
         (defined (ACE_HAS_POSIX_SEM) && defined (ACE_HAS_POSIX_TIMEOUT) && defined (ACE_LACKS_NAMED_POSIX_SEM)))
-      if (result == 0)
-      {
-        char   lck_name[128];
-        ACE_OS::strncpy (lck_name, name, sizeof(lck_name)-(1+sizeof("._ACE_EVTLCK_")));
-        ACE_OS::strcat (lck_name, "._ACE_EVTLCK_");
-        result = ACE_OS::sema_init (&event->lock_,
-                                    0,
-                                    type,
-                                    lck_name,
-                                    arg);
-      }
+          if (result == 0)
+            {
+              char   lck_name[128];
+              ACE_OS::strncpy
+                (lck_name,
+                 name,
+                 sizeof (lck_name) - (1 + sizeof ("._ACE_EVTLCK_")));
+              ACE_OS::strcat (lck_name, "._ACE_EVTLCK_");
+              result = ACE_OS::sema_init (&event->lock_,
+                                          0,
+                                          type,
+                                          lck_name,
+                                          arg);
+            }
 # endif
-      return result;
+          return result;
+        }
+
+      return 0;
     }
-  }
   else
-  {
-    ACE_NEW_RETURN (evtdata,
-                    ACE_eventdata_t,
-                    -1);
-    event->name_ = 0;
-    event->eventdata_ = evtdata;
-    event->eventdata_->type_ = type;
-    event->eventdata_->manual_reset_ = manual_reset;
-    event->eventdata_->is_signaled_ = initial_state;
-    event->eventdata_->auto_event_signaled_ = false;
-    event->eventdata_->waiting_threads_ = 0;
-    event->eventdata_->signal_count_ = 0;
+    {
+      ACE_NEW_RETURN (evtdata, ACE_eventdata_t, -1);
+      event->name_ = 0;
+      event->eventdata_ = evtdata;
+      event->eventdata_->type_ = type;
+      event->eventdata_->manual_reset_ = manual_reset;
+      event->eventdata_->is_signaled_ = initial_state;
+      event->eventdata_->auto_event_signaled_ = false;
+      event->eventdata_->waiting_threads_ = 0;
+      event->eventdata_->signal_count_ = 0;
 
 # if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && !defined (ACE_LACKS_CONDATTR_PSHARED)) || \
     (!defined (ACE_USES_FIFO_SEM) && \
       (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_SEM_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM)))
-    int result = ACE_OS::cond_init (&event->eventdata_->condition_,
-                                     static_cast<short> (type),
-                                     name,
-                                     arg);
+      int result = ACE_OS::cond_init (&event->eventdata_->condition_,
+                                      static_cast<short> (type),
+                                      name,
+                                      arg);
 # else
-    int result = ACE_OS::sema_init(&event->semaphore_,
-                                    0,
-                                    type,
-                                    name,
-                                    arg);
+      int result = ACE_OS::sema_init (&event->semaphore_,
+                                      0,
+                                      type,
+                                      name,
+                                      arg);
 # endif
-    if (result == 0)
+      if (result == 0)
 # if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && \
         (!defined (ACE_LACKS_MUTEXATTR_PSHARED) || !defined (ACE_LACKS_CONDATTR_PSHARED))) || \
      (!defined (ACE_USES_FIFO_SEM) && \
         (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM)))
-      result = ACE_OS::mutex_init (&event->eventdata_->lock_,
-                                    type,
-                                    name,
-                                    (ACE_mutexattr_t *) arg);
+        result = ACE_OS::mutex_init (&event->eventdata_->lock_,
+                                     type,
+                                     name,
+                                     (ACE_mutexattr_t *) arg);
 # else
       result = ACE_OS::sema_init (&event->lock_,
                                   0,
                                   type,
                                   name,
                                   arg);
-    if (result == 0)
-      result = ACE_OS::sema_post(&event->lock_);    /* initially unlock */
+      if (result == 0)
+        result = ACE_OS::sema_post(&event->lock_);    /* initially unlock */
 # endif
 
-    return result;
-  }
+      return result;
+    }
 #else
   ACE_UNUSED_ARG (event);
   ACE_UNUSED_ARG (manual_reset);
diff --git a/configure.ac b/configure.ac
index 66f2be9efb1..c4afcc4715e 100644
--- a/configure.ac
+++ b/configure.ac
@@ -21,13 +21,17 @@ AC_INIT([ACE],
 
 AC_REVISION([$Id$])
 
-AC_COPYRIGHT([ACE(TM) and TAO(TM) are copyrighted by Douglas C. Schmidt and
-his research group at Vanderbilt University, Washington University, and
-University of California, Irvine.  Copyright (c) 1993-2004, all rights
-reserved.  Since ACE and TAO are open-source, free software, you are
-free to use, modify, and distribute the ACE and TAO source code and
-object code produced from the source, as long as you include this
-copyright statement along with code built using ACE and TAO.
+AC_COPYRIGHT([ACE(TM), TAO(TM), CIAO(TM), and CoSMIC(TM) (henceforth
+referred to as "DOC software") are copyrighted by Douglas C.
+Schmidt and his research group at Washington University,
+University of California, Irvine, and Vanderbilt University,
+Copyright (c) 1993-2005, all rights reserved. Since DOC software is
+open-source, free software, you are free to use, modify, copy, and
+distribute--perpetually and irrevocably--the DOC software source code
+and object code produced from the source, as well as copy and
+distribute modified versions of this software. You must, however,
+include this copyright statement along with code built using DOC
+software.
 
 Please see the file `COPYING' in the top level ACE directory for
 additional details.])
diff --git a/tests/Process_Manual_Event_Test.cpp b/tests/Process_Manual_Event_Test.cpp
index c29b87e4bed..373e2e7fd76 100644
--- a/tests/Process_Manual_Event_Test.cpp
+++ b/tests/Process_Manual_Event_Test.cpp
@@ -10,7 +10,7 @@
 //
 // = DESCRIPTION
 //    This test verifies the functionality of the <ACE_Manual_Event>
-//    processshared implementation.
+//    process-shared implementation.
 //
 // = AUTHOR
 //    Martin Corino <mcorino@remedy.nl>
@@ -36,8 +36,8 @@
    (defined (ACE_HAS_POSIX_SEM) && defined (ACE_HAS_POSIX_SEM_TIMEOUT) && !defined (ACE_LACKS_NAMED_POSIX_SEM)))
 static int iterations = 10;
 static int child_process = 0;
-static const char *event_ping_name = "ACE_Ping_Event";
-static const char *event_pong_name = "ACE_Pong_Event";
+static const ACE_TCHAR *event_ping_name = ACE_TEXT ("ACE_Ping_Event");
+static const ACE_TCHAR *event_pong_name = ACE_TEXT ("ACE_Pong_Event");
 
 // Explain usage and exit.
 static void
@@ -58,24 +58,24 @@ parse_args (int argc, ACE_TCHAR *argv[])
 
   while ((c = get_opt ()) != -1)
     switch (c)
-    {
-    case 'i':
-      iterations = ACE_OS::atoi (get_opt.opt_arg ());
-      break;
-    case 'c':
-      child_process = 1;
-      break;
-    default:
-      print_usage_and_die ();
-      break;
-  }
+      {
+      case 'i':
+        iterations = ACE_OS::atoi (get_opt.opt_arg ());
+        break;
+      case 'c':
+        child_process = 1;
+        break;
+      default:
+        print_usage_and_die ();
+        break;
+      }
 }
 
 static void
 acquire_release (void)
 {
-  ACE_Manual_Event event_ping (0, USYNC_PROCESS, ACE_TEXT_CHAR_TO_TCHAR (event_ping_name));
-  ACE_Manual_Event event_pong (0, USYNC_PROCESS, ACE_TEXT_CHAR_TO_TCHAR (event_pong_name));
+  ACE_Manual_Event event_ping (0, USYNC_PROCESS, event_ping_name);
+  ACE_Manual_Event event_pong (0, USYNC_PROCESS, event_pong_name);
 
   // Make sure the constructor succeeded
   ACE_ASSERT (ACE_LOG_MSG->op_status () == 0);
@@ -83,76 +83,82 @@ acquire_release (void)
   ACE_DEBUG ((LM_DEBUG,
               ACE_TEXT ("(%P) Begin ping-pong\n")));
 
+  int i;
   if (child_process)
-  {
-    for (int i=0; i<iterations ;++i)
     {
-      event_ping.signal ();
-
-      if (event_pong.wait ())
-        ACE_DEBUG ((LM_ERROR,
-                    ACE_TEXT ("(%P) Failed acquiring pong (%p)\n")));
+      for (i = 0; i < iterations; ++i)
+        {
+          event_ping.signal ();
+
+          if (event_pong.wait ())
+            ACE_DEBUG ((LM_ERROR,
+                        ACE_TEXT ("(%P) %p\n"),
+                        ACE_TEXT ("Failed acquiring pong")));
+          else
+            {
+              ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P) Pong\n")));
+              event_pong.reset ();
+            }
+        }
+
+      ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P) Testing timeouts\n")));
+
+      // test timed wait
+      ACE_Time_Value wait = ACE_OS::gettimeofday ();
+      wait.sec (wait.sec () + 3); // timeout in 3 secs
+
+      if (event_pong.wait (&wait))
+        if (errno != ETIME)
+          ACE_ERROR ((LM_ERROR,
+                      ACE_TEXT ("(%P) %p, but expected ETIME\n"),
+                      ACE_TEXT ("event_pong.wait()")));
       else
-      {
-        ACE_DEBUG ((LM_DEBUG,
-                    ACE_TEXT ("(%P) Pong\n")));
-        event_pong.reset ();
-      }
-    }
-
-    ACE_DEBUG ((LM_DEBUG,
-                ACE_TEXT ("(%P) Testing timeouts\n")));
-
-    // test timed wait
-    ACE_Time_Value wait = ACE_OS::gettimeofday ();
-    wait.sec (wait.sec () + 3); // timeout in 3 secs
-
-    if (event_pong.wait (&wait))
-        ACE_ASSERT(errno == ETIME);
-    else
         ACE_DEBUG ((LM_ERROR,
                     ACE_TEXT ("(%P) Acquired pong without release()\n")));
 
-    event_ping.signal ();   // release waiting parent before timeout
-  }
-  else
-  {
-    for (int i=0; i<iterations ;++i)
-    {
-      if (event_ping.wait ())
-        ACE_DEBUG ((LM_ERROR,
-                    ACE_TEXT ("(%P) Failed acquiring ping (%p)\n")));
-      else
-      {
-        ACE_DEBUG ((LM_DEBUG,
-                    ACE_TEXT ("(%P) Ping\n")));
-        event_ping.reset ();
-      }
-
-      event_pong.signal ();
+      event_ping.signal ();   // release waiting parent before timeout
     }
-
-    ACE_DEBUG ((LM_DEBUG,
-                ACE_TEXT ("(%P) Testing timeouts\n")));
-
-    // test timed wait
-    ACE_Time_Value wait = ACE_OS::gettimeofday ();
-    wait.sec (wait.sec () + 10); // timeout in 10 secs
-
-    if (event_ping.wait (&wait))
+  else
     {
-      ACE_ASSERT(errno == ETIME);
-      ACE_DEBUG ((LM_ERROR,
-                  ACE_TEXT ("(%P) Acquiring pong timed out\n")));
+      for (i = 0; i < iterations; ++i)
+        {
+          if (event_ping.wait ())
+            ACE_DEBUG ((LM_ERROR,
+                        ACE_TEXT ("(%P) %p\n"),
+                        ACE_TEXT ("Failed acquiring ping")));
+          else
+            {
+              ACE_DEBUG ((LM_DEBUG,
+                          ACE_TEXT ("(%P) Ping\n")));
+              event_ping.reset ();
+            }
+
+          event_pong.signal ();
+        }
+
+      ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P) Testing timeouts\n")));
+
+      // test timed wait
+      ACE_Time_Value wait = ACE_OS::gettimeofday ();
+      wait.sec (wait.sec () + 10); // timeout in 10 secs
+
+      if (event_ping.wait (&wait))
+        {
+          if (errno != ETIME)
+            ACE_ERROR ((LM_ERROR,
+                        ACE_TEXT ("(%P) %p but should be ETIME\n"),
+                        ACE_TEXT ("Acquire pong")));
+          else
+            ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P) Acquire pong timed out\n")));
+        }
     }
-  }
 }
 #endif /* ! ACE_LACKS_FORK */
 
 int
 run_main (int argc, ACE_TCHAR *argv[])
 {
-#if defined (ACE_LACKS_FORK)
+#if defined (ACE_LACKS_FORK) && !defined (ACE_WIN32)
   ACE_UNUSED_ARG (argc);
   ACE_UNUSED_ARG (argv);
 
@@ -178,7 +184,7 @@ run_main (int argc, ACE_TCHAR *argv[])
   else
     {
       ACE_START_TEST (ACE_TEXT ("Process_Manual_Event_Test"));
-
+#if 0
       ACE_Process_Options options;
       options.command_line (ACE_TEXT (".") ACE_DIRECTORY_SEPARATOR_STR
                             ACE_TEXT ("Process_Manual_Event_Test")
@@ -211,7 +217,10 @@ run_main (int argc, ACE_TCHAR *argv[])
         ACE_ERROR ((LM_ERROR,
                     ACE_TEXT ("Child %d finished with status %d\n"),
                     child.getpid (), child_status));
-
+#else
+      // start test
+      acquire_release ();
+#endif
       ACE_END_TEST;
     }
 #else /* !ACE_LACKS_FORK */