Index: mozilla/nsprpub/pr/src/pthreads/ptsynch.c
===================================================================
RCS file: /cvsroot/mozilla/nsprpub/pr/src/pthreads/ptsynch.c,v
retrieving revision 3.29
diff -pU10 -r3.29 mozilla/nsprpub/pr/src/pthreads/ptsynch.c
--- mozilla/nsprpub/pr/src/pthreads/ptsynch.c
+++ mozilla/nsprpub/pr/src/pthreads/ptsynch.c
@@ -189,21 +189,21 @@ PR_IMPLEMENT(void) PR_DestroyLock(PRLock
     PR_ASSERT(NULL != lock);
     PR_ASSERT(PR_FALSE == lock->locked);
     PR_ASSERT(0 == lock->notified.length);
     PR_ASSERT(NULL == lock->notified.link);
     rv = pthread_mutex_destroy(&lock->mutex);
     PR_ASSERT(0 == rv);
 #if defined(DEBUG)
     memset(lock, 0xaf, sizeof(PRLock));
     pt_debug.locks_destroyed += 1;
 #endif
-    PR_DELETE(lock);
+    PR_Free(lock);
 }  /* PR_DestroyLock */
 
 PR_IMPLEMENT(void) PR_Lock(PRLock *lock)
 {
     PRIntn rv;
     PR_ASSERT(lock != NULL);
     rv = pthread_mutex_lock(&lock->mutex);
     PR_ASSERT(0 == rv);
     PR_ASSERT(0 == lock->notified.length);
     PR_ASSERT(NULL == lock->notified.link);
@@ -355,21 +355,21 @@ PR_IMPLEMENT(PRCondVar*) PR_NewCondVar(P
 
 PR_IMPLEMENT(void) PR_DestroyCondVar(PRCondVar *cvar)
 {
     if (0 > PR_AtomicDecrement(&cvar->notify_pending))
     {
         PRIntn rv = pthread_cond_destroy(&cvar->cv); PR_ASSERT(0 == rv);
 #if defined(DEBUG)
         memset(cvar, 0xaf, sizeof(PRCondVar));
         pt_debug.cvars_destroyed += 1;
 #endif
-        PR_DELETE(cvar);
+        PR_Free(cvar);
     }
 }  /* PR_DestroyCondVar */
 
 PR_IMPLEMENT(PRStatus) PR_WaitCondVar(PRCondVar *cvar, PRIntervalTime timeout)
 {
     PRIntn rv;
     PRThread *thred = PR_GetCurrentThread();
 
     PR_ASSERT(cvar != NULL);
     /* We'd better be locked */
@@ -444,49 +444,62 @@ PR_IMPLEMENT(PRStatus) PR_NotifyAllCondV
 /**************************************************************/
 /**************************************************************/
 /***************************MONITORS***************************/
 /**************************************************************/
 /**************************************************************/
 
 PR_IMPLEMENT(PRMonitor*) PR_NewMonitor(void)
 {
     PRMonitor *mon;
     PRCondVar *cvar;
+    int rv;
 
     if (!_pr_initialized) _PR_ImplicitInitialization();
 
     cvar = PR_NEWZAP(PRCondVar);
     if (NULL == cvar)
     {
         PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
         return NULL;
     }
     mon = PR_NEWZAP(PRMonitor);
-    if (mon != NULL)
+    if (mon == NULL)
     {
-        int rv;
-        rv = _PT_PTHREAD_MUTEX_INIT(mon->lock.mutex, _pt_mattr); 
-        PR_ASSERT(0 == rv);
+        PR_Free(cvar);
+        PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
+        return NULL;
+    }
 
-        _PT_PTHREAD_INVALIDATE_THR_HANDLE(mon->owner);
+    rv = _PT_PTHREAD_MUTEX_INIT(mon->lock.mutex, _pt_mattr); 
+    PR_ASSERT(0 == rv);
+    if (0 != rv)
+    {
+        PR_Free(mon);
+        PR_Free(cvar);
+        PR_SetError(PR_OPERATION_NOT_SUPPORTED_ERROR, 0);
+        return NULL;
+    }
 
-        mon->cvar = cvar;
-        rv = _PT_PTHREAD_COND_INIT(mon->cvar->cv, _pt_cvar_attr); 
-        PR_ASSERT(0 == rv);
-        mon->entryCount = 0;
-        mon->cvar->lock = &mon->lock;
-        if (0 != rv)
-        {
-            PR_DELETE(mon);
-            PR_DELETE(cvar);
-            mon = NULL;
-        }
+    _PT_PTHREAD_INVALIDATE_THR_HANDLE(mon->owner);
+
+    mon->cvar = cvar;
+    rv = _PT_PTHREAD_COND_INIT(mon->cvar->cv, _pt_cvar_attr); 
+    PR_ASSERT(0 == rv);
+    mon->entryCount = 0;
+    mon->cvar->lock = &mon->lock;
+    if (0 != rv)
+    {
+        pthread_mutex_destroy(&mon->lock.mutex);
+        PR_Free(mon);
+        PR_Free(cvar);
+        PR_SetError(PR_OPERATION_NOT_SUPPORTED_ERROR, 0);
+        return NULL;
     }
     return mon;
 }  /* PR_NewMonitor */
 
 PR_IMPLEMENT(PRMonitor*) PR_NewNamedMonitor(const char* name)
 {
     PRMonitor* mon = PR_NewMonitor();
     if (mon)
         mon->name = name;
     return mon;
@@ -494,21 +507,21 @@ PR_IMPLEMENT(PRMonitor*) PR_NewNamedMoni
 
 PR_IMPLEMENT(void) PR_DestroyMonitor(PRMonitor *mon)
 {
     int rv;
     PR_ASSERT(mon != NULL);
     PR_DestroyCondVar(mon->cvar);
     rv = pthread_mutex_destroy(&mon->lock.mutex); PR_ASSERT(0 == rv);
 #if defined(DEBUG)
         memset(mon, 0xaf, sizeof(PRMonitor));
 #endif
-    PR_DELETE(mon);    
+    PR_Free(mon);    
 }  /* PR_DestroyMonitor */
 
 
 /* The GC uses this; it is quite arguably a bad interface.  I'm just 
  * duplicating it for now - XXXMB
  */
 PR_IMPLEMENT(PRIntn) PR_GetMonitorEntryCount(PRMonitor *mon)
 {
     pthread_t self = pthread_self();
     if (pthread_equal(mon->owner, self))
@@ -650,21 +663,21 @@ PR_IMPLEMENT(PRStatus) PR_WaitSem(PRSema
 	return status;
 }  /* PR_WaitSem */
 
 PR_IMPLEMENT(void) PR_DestroySem(PRSemaphore *semaphore)
 {
     static PRBool unwarned = PR_TRUE;
     if (unwarned) unwarned = _PR_Obsolete(
         "PR_DestroySem", "locks & condition variables");
     PR_DestroyLock(semaphore->cvar->lock);
     PR_DestroyCondVar(semaphore->cvar);
-    PR_DELETE(semaphore);
+    PR_Free(semaphore);
 }  /* PR_DestroySem */
 
 PR_IMPLEMENT(PRSemaphore*) PR_NewSem(PRUintn value)
 {
     PRSemaphore *semaphore;
     static PRBool unwarned = PR_TRUE;
     if (!_pr_initialized) _PR_ImplicitInitialization();
 
     if (unwarned) unwarned = _PR_Obsolete(
         "PR_NewSem", "locks & condition variables");
@@ -676,21 +689,21 @@ PR_IMPLEMENT(PRSemaphore*) PR_NewSem(PRU
         if (NULL != lock)
         {
             semaphore->cvar = PR_NewCondVar(lock);
             if (NULL != semaphore->cvar)
             {
                 semaphore->count = value;
                 return semaphore;
             }
             PR_DestroyLock(lock);
         }
-        PR_DELETE(semaphore);
+        PR_Free(semaphore);
     }
     return NULL;
 }
 
 /*
  * Define the interprocess named semaphore functions.
  * There are three implementations:
  * 1. POSIX semaphore based;
  * 2. System V semaphore based;
  * 3. unsupported (fails with PR_NOT_IMPLEMENTED_ERROR).
@@ -733,21 +746,21 @@ PR_IMPLEMENT(PRSem *) PR_OpenSemaphore(
 #ifdef HPUX
         /* Pass 0 as the mode and value arguments to work around a bug. */
         sem->sem = sem_open(osname, 0, 0, 0);
 #else
         sem->sem = sem_open(osname, 0);
 #endif
     }
     if ((sem_t *) -1 == sem->sem)
     {
         _PR_MD_MAP_DEFAULT_ERROR(errno);
-        PR_DELETE(sem);
+        PR_Free(sem);
         return NULL;
     }
     return sem;
 }
 
 PR_IMPLEMENT(PRStatus) PR_WaitSemaphore(PRSem *sem)
 {
     int rv;
     rv = sem_wait(sem->sem);
     if (0 != rv)
@@ -772,21 +785,21 @@ PR_IMPLEMENT(PRStatus) PR_PostSemaphore(
 
 PR_IMPLEMENT(PRStatus) PR_CloseSemaphore(PRSem *sem)
 {
     int rv;
     rv = sem_close(sem->sem);
     if (0 != rv)
     {
         _PR_MD_MAP_DEFAULT_ERROR(errno);
         return PR_FAILURE;
     }
-    PR_DELETE(sem);
+    PR_Free(sem);
     return PR_SUCCESS;
 }
 
 PR_IMPLEMENT(PRStatus) PR_DeleteSemaphore(const char *name)
 {
     int rv;
     char osname[PR_IPC_NAME_SIZE];
 
     if (_PR_MakeNativeIPCName(name, osname, sizeof(osname), _PRIPCSem)
         == PR_FAILURE)
@@ -882,62 +895,62 @@ PR_IMPLEMENT(PRSem *) PR_OpenSemaphore(
     if (flags & PR_SEM_CREATE)
     {
         sem->semid = semget(key, 1, mode|IPC_CREAT|IPC_EXCL);
         if (sem->semid >= 0)
         {
             /* creator of a semaphore is responsible for initializing it */
             arg.val = 0;
             if (semctl(sem->semid, 0, SETVAL, arg) == -1)
             {
                 _PR_MD_MAP_DEFAULT_ERROR(errno);
-                PR_DELETE(sem);
+                PR_Free(sem);
                 return NULL;
             }
             /* call semop to set sem_otime to nonzero */
             sop.sem_num = 0;
             sop.sem_op = value;
             sop.sem_flg = 0;
             if (semop(sem->semid, &sop, 1) == -1)
             {
                 _PR_MD_MAP_DEFAULT_ERROR(errno);
-                PR_DELETE(sem);
+                PR_Free(sem);
                 return NULL;
             }
             return sem;
         }
 
         if (errno != EEXIST || flags & PR_SEM_EXCL)
         {
             _PR_MD_MAP_DEFAULT_ERROR(errno);
-            PR_DELETE(sem);
+            PR_Free(sem);
             return NULL;
         }
     }
 
     sem->semid = semget(key, 1, NSPR_SEM_MODE);
     if (sem->semid == -1)
     {
         _PR_MD_MAP_DEFAULT_ERROR(errno);
-        PR_DELETE(sem);
+        PR_Free(sem);
         return NULL;
     }
     for (i = 0; i < MAX_TRIES; i++)
     {
         arg.buf = &seminfo;
         semctl(sem->semid, 0, IPC_STAT, arg);
         if (seminfo.sem_otime != 0) break;
         sleep(1);
     }
     if (i == MAX_TRIES)
     {
         PR_SetError(PR_IO_TIMEOUT_ERROR, 0);
-        PR_DELETE(sem);
+        PR_Free(sem);
         return NULL;
     }
     return sem;
 }
 
 PR_IMPLEMENT(PRStatus) PR_WaitSemaphore(PRSem *sem)
 {
     struct sembuf sop;
 
     sop.sem_num = 0;
@@ -961,21 +974,21 @@ PR_IMPLEMENT(PRStatus) PR_PostSemaphore(
     if (semop(sem->semid, &sop, 1) == -1)
     {
         _PR_MD_MAP_DEFAULT_ERROR(errno);
         return PR_FAILURE;
     }
     return PR_SUCCESS;
 }
 
 PR_IMPLEMENT(PRStatus) PR_CloseSemaphore(PRSem *sem)
 {
-    PR_DELETE(sem);
+    PR_Free(sem);
     return PR_SUCCESS;
 }
 
 PR_IMPLEMENT(PRStatus) PR_DeleteSemaphore(const char *name)
 {
     key_t key;
     int semid;
     /* On some systems (e.g., glibc 2.0) semctl requires a fourth argument */
     union semun unused;
     char osname[PR_IPC_NAME_SIZE];
@@ -1087,21 +1100,21 @@ PR_IMPLEMENT(PRCondVar*) PRP_NewNakedCon
     return cv;
 }  /* PRP_NewNakedCondVar */
 
 PR_IMPLEMENT(void) PRP_DestroyNakedCondVar(PRCondVar *cvar)
 {
     int rv;
     rv = pthread_cond_destroy(&cvar->cv); PR_ASSERT(0 == rv);
 #if defined(DEBUG)
         memset(cvar, 0xaf, sizeof(PRCondVar));
 #endif
-    PR_DELETE(cvar);
+    PR_Free(cvar);
 }  /* PRP_DestroyNakedCondVar */
 
 PR_IMPLEMENT(PRStatus) PRP_NakedWait(
     PRCondVar *cvar, PRLock *ml, PRIntervalTime timeout)
 {
     PRIntn rv;
     PR_ASSERT(cvar != NULL);
     /* XXX do we really want to assert this in a naked wait? */
     PR_ASSERT(_PT_PTHREAD_MUTEX_IS_LOCKED(ml->mutex));
     if (timeout == PR_INTERVAL_NO_TIMEOUT)