Changeset 102000 in vbox

Timestamp:

Nov 8, 2023 6:30:47 PM (15 months ago)

Author:

vboxsync

Message:

libs/xpcom/nsprpub: Convert from PR_ASSERT to IPRT assertions, bugref:10545

Location:

trunk/src/libs/xpcom18a4/nsprpub/pr/src

Files:

• io/priometh.c (modified) (6 diffs)
• io/prmmap.c (modified) (2 diffs)
• io/prprf.c (modified) (11 diffs)
• io/prscanf.c (modified) (5 diffs)
• md/unix/unix.c (modified) (5 diffs)
• misc/prinrval.c (modified) (2 diffs)
• misc/prtime.c (modified) (5 diffs)
• pthreads/ptio.c (modified) (24 diffs)
• pthreads/ptsynch.c (modified) (27 diffs)

trunk/src/libs/xpcom18a4/nsprpub/pr/src/io/priometh.c

@@ -39 +39 @@
 
 #include <string.h>
+#include <iprt/assert.h>
 
 /*****************************************************************************/
@@ -78 +79 @@
 PRIntn _PR_InvalidInt(void)
 {
-    PR_ASSERT(!"I/O method is invalid");
+    Assert(!"I/O method is invalid");
     PR_SetError(PR_INVALID_METHOD_ERROR, 0);
     return -1;
@@ -85 +86 @@
 PRInt16 _PR_InvalidInt16(void)
 {
-    PR_ASSERT(!"I/O method is invalid");
+    Assert(!"I/O method is invalid");
     PR_SetError(PR_INVALID_METHOD_ERROR, 0);
     return -1;
@@ -94 +95 @@
     PRInt64 rv;
     LL_I2L(rv, -1);
-    PR_ASSERT(!"I/O method is invalid");
+    Assert(!"I/O method is invalid");
     PR_SetError(PR_INVALID_METHOD_ERROR, 0);
     return rv;
@@ -105 +106 @@
 PRStatus _PR_InvalidStatus(void)
 {
-    PR_ASSERT(!"I/O method is invalid");
+    Assert(!"I/O method is invalid");
     PR_SetError(PR_INVALID_METHOD_ERROR, 0);
     return PR_FAILURE;
@@ -116 +117 @@
 PRFileDesc *_PR_InvalidDesc(void)
 {
-    PR_ASSERT(!"I/O method is invalid");
+    Assert(!"I/O method is invalid");
     PR_SetError(PR_INVALID_METHOD_ERROR, 0);
     return NULL;

trunk/src/libs/xpcom18a4/nsprpub/pr/src/io/prmmap.c

@@ -46 +46 @@
 #include "primpl.h"
 
+#include <iprt/assert.h>
+
 PR_IMPLEMENT(PRFileMap *) PR_CreateFileMap(
     PRFileDesc *fd,
@@ -53 +55 @@
     PRFileMap *fmap;
 
-    PR_ASSERT(prot == PR_PROT_READONLY || prot == PR_PROT_READWRITE
-            || prot == PR_PROT_WRITECOPY);
+    Assert(prot == PR_PROT_READONLY || prot == PR_PROT_READWRITE
+           || prot == PR_PROT_WRITECOPY);
     fmap = PR_NEWZAP(PRFileMap);
     if (NULL == fmap) {

trunk/src/libs/xpcom18a4/nsprpub/pr/src/io/prprf.c

@@ -48 +48 @@
 #include "prprf.h"
 #include "prlong.h"
-#include "prlog.h"
 #include "prmem.h"
+
+#include <iprt/assert.h>
 
 /*
@@ -351 +352 @@
         const char *p = fin;
         while (*p) {
-            PR_ASSERT(*p != 'L');
+            Assert(*p != 'L');
             p++;
         }
@@ -568 +569 @@
         case 'G':
             /* XXX not supported I suppose */
-            PR_ASSERT(0);
+            Assert(0);
             nas[ cn ].type = TYPE_UNKNOWN;
             break;
@@ -581 +582 @@
 
         default:
-            PR_ASSERT(0);
+            Assert(0);
             nas[ cn ].type = TYPE_UNKNOWN;
             break;
@@ -701 +702 @@
     if( rv < 0 ){
         /* the fmt contains error Numbered Argument format, [email protected] */
-        PR_ASSERT(0);
+        Assert(0);
         return rv;
     }
@@ -954 +955 @@
                 type = TYPE_UINTN;
             } else {
-                PR_ASSERT(0);
+                Assert(0);
                 break;
             }
@@ -966 +967 @@
           case 'G':
             /* XXX not supported I suppose */
-            PR_ASSERT(0);
+            Assert(0);
             break;
 #endif
@@ -988 +989 @@
             /* Not a % token after all... skip it */
 #if 0
-            PR_ASSERT(0);
+            Assert(0);
 #endif
             rv = (*ss->stuff)(ss, "%", 1);
@@ -1084 +1085 @@
         *ss->cur++ = *sp++;
     }
-    PR_ASSERT((PRUint32)(ss->cur - ss->base) <= ss->maxlen);
+    Assert((PRUint32)(ss->cur - ss->base) <= ss->maxlen);
     return 0;
 }
@@ -1155 +1156 @@
     PRUint32 rv;
 
-    PR_ASSERT((PRInt32)outlen > 0);
+    Assert((PRInt32)outlen > 0);
     if ((PRInt32)outlen <= 0) {
         return 0;
@@ -1172 +1173 @@
     PRUint32 n;
 
-    PR_ASSERT((PRInt32)outlen > 0);
+    Assert((PRInt32)outlen > 0);
     if ((PRInt32)outlen <= 0) {
         return 0;

trunk/src/libs/xpcom18a4/nsprpub/pr/src/io/prscanf.c

@@ -54 +54 @@
 #include "prprf.h"
 #include "prdtoa.h"
-#include "prlog.h"
 #include "prerror.h"
+
+#include <iprt/assert.h>
 
 /*
@@ -142 +143 @@
     const char *digitStart;
 
-    PR_ASSERT(base == 0 || base == 8 || base == 10 || base == 16);
+    Assert(base == 0 || base == 8 || base == 10 || base == 16);
     if (base < 0 || base == 1 || base > BASE_MAX) {
         if (endptr) {
@@ -177 +178 @@
         } 
     }
-    PR_ASSERT(base != 0);
+    Assert(base != 0);
     LL_I2L(base64, base);
     digitStart = cPtr;
@@ -280 +281 @@
         dlen = 8;
     } else {
-        PR_ASSERT(base == 16);
+        Assert(base == 16);
         dlen = 16 + 6; /* 16 digits, plus 6 in uppercase */
     }
@@ -483 +484 @@
                         break;
                     default:
-                        PR_ASSERT(0);
+                        Assert(0);
                 }
             }

trunk/src/libs/xpcom18a4/nsprpub/pr/src/md/unix/unix.c

@@ -66 +66 @@
 
 #ifdef VBOX
+# include <iprt/assert.h>
 # include <iprt/mem.h>
 #endif
@@ -98 +99 @@
     int flags;
 
-    PR_ASSERT(_PR_TRI_UNKNOWN == fd->secret->inheritable);
+    Assert(_PR_TRI_UNKNOWN == fd->secret->inheritable);
     flags = fcntl(fd->secret->md.osfd, F_GETFD, 0);
-    PR_ASSERT(-1 != flags);
+    Assert(-1 != flags);
     fd->secret->inheritable = (flags & FD_CLOEXEC) ?
         _PR_TRI_FALSE : _PR_TRI_TRUE;
@@ -524 +525 @@
     sigact.sa_flags = 0;
     rv = sigaction(SIGPIPE, &sigact, 0);
-    PR_ASSERT(0 == rv);
+    Assert(0 == rv);
 
     _PR_InitIOV();  /* one last hack */
@@ -721 +722 @@
             }
         }
-        PR_ASSERT(rv > 0);
+        Assert(rv > 0);
     } else if (rv == -1 && errno == EBADF) {
         rv = 0;
@@ -734 +735 @@
             }
         }
-        PR_ASSERT(rv > 0);
-    }
-    PR_ASSERT(-1 != timeout || rv != 0);
+        Assert(rv > 0);
+    }
+    Assert(-1 != timeout || rv != 0);
 
     return rv;

trunk/src/libs/xpcom18a4/nsprpub/pr/src/misc/prinrval.c

@@ -43 +43 @@
 #include "primpl.h"
 
+#include <iprt/assert.h>
+
 /*
  *-----------------------------------------------------------------------
@@ -59 +61 @@
         PRIntervalTime ticksPerSec = PR_TicksPerSecond();
 
-        PR_ASSERT(ticksPerSec >= PR_INTERVAL_MIN);
-        PR_ASSERT(ticksPerSec <= PR_INTERVAL_MAX);
+        Assert(ticksPerSec >= PR_INTERVAL_MIN);
+        Assert(ticksPerSec <= PR_INTERVAL_MAX);
     }
 #endif /* DEBUG */

trunk/src/libs/xpcom18a4/nsprpub/pr/src/misc/prtime.c

@@ -47 +47 @@
 #include "prlock.h"
 #include "prprf.h"
-#include "prlog.h"
 
 #include <string.h>
 #include <ctype.h>
+
+#include <iprt/assert.h>
 
 /*
@@ -948 +949 @@
 #endif
 
-  PR_ASSERT(string && result);
+  Assert(string && result);
   if (!string || !result) return PR_FAILURE;
 
@@ -957 +958 @@
           if (iterations++ > 1000)
                 {
-                  PR_ASSERT(0);
+                  Assert(0);
                   return PR_FAILURE;
                 }
@@ -1477 +1478 @@
                 case TT_JST: zone_offset =  9 * 60; break;
                 default:
-                  PR_ASSERT (0);
+                  Assert (0);
                   break;
                 }
@@ -1519 +1520 @@
           time_t secs;
 
-          PR_ASSERT(tm.tm_month > -1 
+          Assert(tm.tm_month > -1 
                                    && tm.tm_mday > 0 
                                    && tm.tm_hour > -1

trunk/src/libs/xpcom18a4/nsprpub/pr/src/pthreads/ptio.c

@@ -79 +79 @@
 #endif
 
+#include <iprt/assert.h>
 #include <iprt/thread.h>
 
@@ -307 +308 @@
     PRThread *self = PR_GetCurrentThread();
 
-        PR_ASSERT(PR_INTERVAL_NO_WAIT != op->timeout);
+        Assert(PR_INTERVAL_NO_WAIT != op->timeout);
 
     switch (op->timeout) {
@@ -445 +446 @@
          */
         pt_poll_now(op);
-        PR_ASSERT(pt_continuation_done == op->status);
+        Assert(pt_continuation_done == op->status);
     return op->result.code;
 }  /* pt_Continue */
@@ -649 +650 @@
 
     _pr_rename_lock = PR_NewLock();
-    PR_ASSERT(NULL != _pr_rename_lock);
+    Assert(NULL != _pr_rename_lock);
 
     _pr_stdin = pt_SetMethods(0, PR_DESC_FILE, PR_FALSE, PR_TRUE);
     _pr_stdout = pt_SetMethods(1, PR_DESC_FILE, PR_FALSE, PR_TRUE);
     _pr_stderr = pt_SetMethods(2, PR_DESC_FILE, PR_FALSE, PR_TRUE);
-    PR_ASSERT(_pr_stdin && _pr_stdout && _pr_stderr);
+    Assert(_pr_stdin && _pr_stdout && _pr_stderr);
 
 #ifdef DARWIN
@@ -697 +698 @@
 {
     PRFileDesc *result = NULL;
-    PR_ASSERT(osfd >= PR_StandardInput && osfd <= PR_StandardError);
+    Assert(osfd >= PR_StandardInput && osfd <= PR_StandardError);
 
     if (!_pr_initialized) _PR_ImplicitInitialization();
@@ -863 +864 @@
 
     /* Ensured by PR_Writev */
-    PR_ASSERT(iov_len <= PR_MAX_IOVECTOR_SIZE);
+    Assert(iov_len <= PR_MAX_IOVECTOR_SIZE);
 
     /*
@@ -903 +904 @@
                 bytes -= osiov->iov_len;  /* this one's done cooked */
             }
-            PR_ASSERT(osiov_len > 0 || bytes == 0);
+            Assert(osiov_len > 0 || bytes == 0);
             if (osiov_len > 0)
             {
@@ -1027 +1028 @@
     if (pt_TestAbort()) return PR_FAILURE;
 
-    PR_ASSERT(IsValidNetAddr(addr) == PR_TRUE);
+    Assert(IsValidNetAddr(addr) == PR_TRUE);
     addr_len = PR_NETADDR_SIZE(addr);
 
@@ -1079 +1080 @@
     if ((out_flags & (PR_POLL_WRITE | PR_POLL_EXCEPT | PR_POLL_ERR)) == 0)
     {
-        PR_ASSERT(out_flags == 0);
+        Assert(out_flags == 0);
         PR_SetError(PR_IN_PROGRESS_ERROR, 0);
         return PR_FAILURE;
@@ -1168 +1169 @@
     else
     {
-        PR_ASSERT(IsValidNetAddr(addr) == PR_TRUE);
-        PR_ASSERT(IsValidNetAddrLen(addr, addr_len) == PR_TRUE);
+        Assert(IsValidNetAddr(addr) == PR_TRUE);
+        Assert(IsValidNetAddrLen(addr, addr_len) == PR_TRUE);
 #ifdef LINUX
         /*
@@ -1198 +1199 @@
     if (pt_TestAbort()) return PR_FAILURE;
 
-    PR_ASSERT(IsValidNetAddr(addr) == PR_TRUE);
+    Assert(IsValidNetAddr(addr) == PR_TRUE);
     if (addr->raw.family == AF_UNIX)
     {
@@ -1349 +1350 @@
      */
 #if defined(SOLARIS)
-    PR_ASSERT(0 == flags);
+    Assert(0 == flags);
 retry:
     bytes = write(fd->secret->md.osfd, PT_SENDBUF_CAST buf, tmp_amount);
@@ -1442 +1443 @@
 #endif /* _PR_HAVE_SOCKADDR_LEN */
 
-        PR_ASSERT(IsValidNetAddr(addr) == PR_TRUE);
-        PR_ASSERT(IsValidNetAddrLen(addr, addr_len) == PR_TRUE);
+        Assert(IsValidNetAddr(addr) == PR_TRUE);
+        Assert(IsValidNetAddrLen(addr, addr_len) == PR_TRUE);
         return PR_SUCCESS;
     }
@@ -1470 +1471 @@
 #endif /* _PR_HAVE_SOCKADDR_LEN */
 
-        PR_ASSERT(IsValidNetAddr(addr) == PR_TRUE);
-        PR_ASSERT(IsValidNetAddrLen(addr, addr_len) == PR_TRUE);
+        Assert(IsValidNetAddr(addr) == PR_TRUE);
+        Assert(IsValidNetAddrLen(addr, addr_len) == PR_TRUE);
         return PR_SUCCESS;
     }
@@ -1503 +1504 @@
                 rv = getsockopt(
                     fd->secret->md.osfd, level, name, (char *) &linger, &length);
-                PR_ASSERT((-1 == rv) || (sizeof(linger) == length));
+                Assert((-1 == rv) || (sizeof(linger) == length));
                 data->value.linger.polarity =
                     (linger.l_onoff) ? PR_TRUE : PR_FALSE;
@@ -1519 +1520 @@
                 rv = getsockopt(
                     fd->secret->md.osfd, level, name, (char*)&value, &length);
-                PR_ASSERT((-1 == rv) || (sizeof(PRIntn) == length));
+                Assert((-1 == rv) || (sizeof(PRIntn) == length));
                 data->value.reuse_addr = (0 == value) ? PR_FALSE : PR_TRUE;
                 break;
@@ -1530 +1531 @@
                     fd->secret->md.osfd, level, name,
                     (char*)&xbool, &length);
-                PR_ASSERT((-1 == rv) || (sizeof(xbool) == length));
+                Assert((-1 == rv) || (sizeof(xbool) == length));
                 data->value.mcast_loopback = (0 == xbool) ? PR_FALSE : PR_TRUE;
                 break;
@@ -1542 +1543 @@
                 rv = getsockopt(
                     fd->secret->md.osfd, level, name, (char*)&value, &length);
-                PR_ASSERT((-1 == rv) || (sizeof(PRIntn) == length));
+                Assert((-1 == rv) || (sizeof(PRIntn) == length));
                 data->value.recv_buffer_size = value;
                 break;
@@ -1553 +1554 @@
                     fd->secret->md.osfd, level, name,
                     (char*)&data->value.ip_ttl, &length);
-                PR_ASSERT((-1 == rv) || (sizeof(PRIntn) == length));
+                Assert((-1 == rv) || (sizeof(PRIntn) == length));
                 break;
             }
@@ -1563 +1564 @@
                     fd->secret->md.osfd, level, name,
                     (char*)&ttl, &length);
-                PR_ASSERT((-1 == rv) || (sizeof(ttl) == length));
+                Assert((-1 == rv) || (sizeof(ttl) == length));
                 data->value.mcast_ttl = ttl;
                 break;
@@ -1574 +1575 @@
                 rv = getsockopt(
                     fd->secret->md.osfd, level, name, (char*)&mreq, &length);
-                PR_ASSERT((-1 == rv) || (sizeof(mreq) == length));
+                Assert((-1 == rv) || (sizeof(mreq) == length));
                 data->value.add_member.mcaddr.inet.ip =
                     mreq.imr_multiaddr.s_addr;
@@ -1587 +1588 @@
                     fd->secret->md.osfd, level, name,
                     (char*)&data->value.mcast_if.inet.ip, &length);
-                PR_ASSERT((-1 == rv)
+                Assert((-1 == rv)
                     || (sizeof(data->value.mcast_if.inet.ip) == length));
                 break;
             }
             default:
-                PR_NOT_REACHED("Unknown socket option");
                 break;
         }
@@ -1702 +1702 @@
             }
             default:
-                PR_NOT_REACHED("Unknown socket option");
                 break;
         }
@@ -2216 +2215 @@
                     PRFileDesc *bottom = PR_GetIdentitiesLayer(
                         pds[index].fd, PR_NSPR_IO_LAYER);
-                    PR_ASSERT(NULL != bottom);  /* what to do about that? */
+                    Assert(NULL != bottom);  /* what to do about that? */
                     pds[index].out_flags = 0;  /* pre-condition */
                     if ((NULL != bottom)

trunk/src/libs/xpcom18a4/nsprpub/pr/src/pthreads/ptsynch.c

@@ -49 +49 @@
 
 #include <iprt/asm.h>
+#include <iprt/assert.h>
 
 #ifdef VBOX
@@ -72 +73 @@
     int rv;
     rv = _PT_PTHREAD_MUTEXATTR_INIT(&_pt_mattr); 
-    PR_ASSERT(0 == rv);
+    Assert(0 == rv);
 
 #ifdef LINUX
 #if (__GLIBC__ > 2) || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
     rv = pthread_mutexattr_settype(&_pt_mattr, PTHREAD_MUTEX_ADAPTIVE_NP);
-    PR_ASSERT(0 == rv);
+    Assert(0 == rv);
 #endif
 #endif
 
     rv = _PT_PTHREAD_CONDATTR_INIT(&_pt_cvar_attr);
-    PR_ASSERT(0 == rv);
+    Assert(0 == rv);
 }
 
@@ -109 +110 @@
     {
         rv = pthread_mutex_unlock(&lock->mutex);
-        PR_ASSERT(0 == rv);
+        Assert(0 == rv);
     }
 
@@ -118 +119 @@
         {
             PRCondVar *cv = notified->cv[index].cv;
-            PR_ASSERT(NULL != cv);
-            PR_ASSERT(0 != notified->cv[index].times);
+            Assert(NULL != cv);
+            Assert(0 != notified->cv[index].times);
             if (-1 == notified->cv[index].times)
             {
                 rv = pthread_cond_broadcast(&cv->cv);
-                PR_ASSERT(0 == rv);
+                Assert(0 == rv);
             }
             else
@@ -130 +131 @@
                 {
                     rv = pthread_cond_signal(&cv->cv);
-                    PR_ASSERT(0 == rv);
+                    Assert(0 == rv);
                 }
             }
@@ -162 +163 @@
     {
         rv = _PT_PTHREAD_MUTEX_INIT(lock->mutex, _pt_mattr); 
-        PR_ASSERT(0 == rv);
+        Assert(0 == rv);
     }
 #if defined(DEBUG)
@@ -173 +174 @@
 {
     PRIntn rv;
-    PR_ASSERT(NULL != lock);
-    PR_ASSERT(PR_FALSE == lock->locked);
-    PR_ASSERT(0 == lock->notified.length);
-    PR_ASSERT(NULL == lock->notified.link);
+    Assert(NULL != lock);
+    Assert(PR_FALSE == lock->locked);
+    Assert(0 == lock->notified.length);
+    Assert(NULL == lock->notified.link);
     rv = pthread_mutex_destroy(&lock->mutex);
-    PR_ASSERT(0 == rv);
+    Assert(0 == rv);
 #if defined(DEBUG)
     memset(lock, 0xaf, sizeof(PRLock));
@@ -189 +190 @@
 {
     PRIntn rv;
-    PR_ASSERT(lock != NULL);
+    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);
-    PR_ASSERT(PR_FALSE == lock->locked);
+    Assert(0 == rv);
+    Assert(0 == lock->notified.length);
+    Assert(NULL == lock->notified.link);
+    Assert(PR_FALSE == lock->locked);
     lock->locked = PR_TRUE;
     lock->owner = pthread_self();
@@ -206 +207 @@
     PRIntn rv;
 
-    PR_ASSERT(lock != NULL);
-    PR_ASSERT(_PT_PTHREAD_MUTEX_IS_LOCKED(lock->mutex));
-    PR_ASSERT(PR_TRUE == lock->locked);
-    PR_ASSERT(pthread_equal(lock->owner, pthread_self()));
+    Assert(lock != NULL);
+    Assert(_PT_PTHREAD_MUTEX_IS_LOCKED(lock->mutex));
+    Assert(PR_TRUE == lock->locked);
+    Assert(pthread_equal(lock->owner, pthread_self()));
 
     if (!lock->locked || !pthread_equal(lock->owner, pthread_self()))
@@ -218 +219 @@
     {
         rv = pthread_mutex_unlock(&lock->mutex);
-        PR_ASSERT(0 == rv);
+        Assert(0 == rv);
     }
     else pt_PostNotifies(lock, PR_TRUE);
@@ -281 +282 @@
     _PT_Notified *notified = &cvar->lock->notified;
 
-    PR_ASSERT(PR_TRUE == cvar->lock->locked);
-    PR_ASSERT(pthread_equal(cvar->lock->owner, pthread_self()));
-    PR_ASSERT(_PT_PTHREAD_MUTEX_IS_LOCKED(cvar->lock->mutex));
+    Assert(PR_TRUE == cvar->lock->locked);
+    Assert(pthread_equal(cvar->lock->owner, pthread_self()));
+    Assert(_PT_PTHREAD_MUTEX_IS_LOCKED(cvar->lock->mutex));
 
     while (1)
@@ -314 +315 @@
 
 finished:
-    PR_ASSERT(PR_TRUE == cvar->lock->locked);
-    PR_ASSERT(pthread_equal(cvar->lock->owner, pthread_self()));
+    Assert(PR_TRUE == cvar->lock->locked);
+    Assert(pthread_equal(cvar->lock->owner, pthread_self()));
 }  /* pt_PostNotifyToCvar */
 
@@ -321 +322 @@
 {
     PRCondVar *cv = PR_NEW(PRCondVar);
-    PR_ASSERT(lock != NULL);
+    Assert(lock != NULL);
     if (cv != NULL)
     {
         int rv = _PT_PTHREAD_COND_INIT(cv->cv, _pt_cvar_attr); 
-        PR_ASSERT(0 == rv);
+        Assert(0 == rv);
         cv->lock = lock;
         cv->notify_pending = 0;
@@ -339 +340 @@
     if (0 > ASMAtomicDecU32(&cvar->notify_pending))
     {
-        PRIntn rv = pthread_cond_destroy(&cvar->cv); PR_ASSERT(0 == rv);
+        PRIntn rv = pthread_cond_destroy(&cvar->cv); Assert(0 == rv);
 #if defined(DEBUG)
         memset(cvar, 0xaf, sizeof(PRCondVar));
@@ -353 +354 @@
     PRThread *thred = PR_CurrentThread();
 
-    PR_ASSERT(cvar != NULL);
+    Assert(cvar != NULL);
     /* We'd better be locked */
-    PR_ASSERT(_PT_PTHREAD_MUTEX_IS_LOCKED(cvar->lock->mutex));
-    PR_ASSERT(PR_TRUE == cvar->lock->locked);
+    Assert(_PT_PTHREAD_MUTEX_IS_LOCKED(cvar->lock->mutex));
+    Assert(PR_TRUE == cvar->lock->locked);
     /* and it better be by us */
-    PR_ASSERT(pthread_equal(cvar->lock->owner, pthread_self()));
+    Assert(pthread_equal(cvar->lock->owner, pthread_self()));
 
     if (_PT_THREAD_INTERRUPTED(thred)) goto aborted;
@@ -389 +390 @@
 
     /* We just got the lock back - this better be empty */
-    PR_ASSERT(PR_FALSE == cvar->lock->locked);
+    Assert(PR_FALSE == cvar->lock->locked);
     cvar->lock->locked = PR_TRUE;
     cvar->lock->owner = pthread_self();
 
-    PR_ASSERT(0 == cvar->lock->notified.length);
+    Assert(0 == cvar->lock->notified.length);
     thred->waiting = NULL;  /* and now we're not */
     if (_PT_THREAD_INTERRUPTED(thred)) goto aborted;
@@ -411 +412 @@
 PR_IMPLEMENT(PRStatus) PR_NotifyCondVar(PRCondVar *cvar)
 {
-    PR_ASSERT(cvar != NULL);   
+    Assert(cvar != NULL);   
     pt_PostNotifyToCvar(cvar, PR_FALSE);
     return PR_SUCCESS;
@@ -418 +419 @@
 PR_IMPLEMENT(PRStatus) PR_NotifyAllCondVar(PRCondVar *cvar)
 {
-    PR_ASSERT(cvar != NULL);
+    Assert(cvar != NULL);
     pt_PostNotifyToCvar(cvar, PR_TRUE);
     return PR_SUCCESS;
@@ -447 +448 @@
         int rv;
         rv = _PT_PTHREAD_MUTEX_INIT(mon->lock.mutex, _pt_mattr); 
-        PR_ASSERT(0 == rv);
+        Assert(0 == rv);
 
         _PT_PTHREAD_INVALIDATE_THR_HANDLE(mon->owner);
@@ -453 +454 @@
         mon->cvar = cvar;
         rv = _PT_PTHREAD_COND_INIT(mon->cvar->cv, _pt_cvar_attr); 
-        PR_ASSERT(0 == rv);
+        Assert(0 == rv);
         mon->entryCount = 0;
         mon->cvar->lock = &mon->lock;
@@ -477 +478 @@
 {
     int rv;
-    PR_ASSERT(mon != NULL);
+    Assert(mon != NULL);
     PR_DestroyCondVar(mon->cvar);
-    rv = pthread_mutex_destroy(&mon->lock.mutex); PR_ASSERT(0 == rv);
+    rv = pthread_mutex_destroy(&mon->lock.mutex); Assert(0 == rv);
 #if defined(DEBUG)
         memset(mon, 0xaf, sizeof(PRMonitor));
@@ -502 +503 @@
     pthread_t self = pthread_self();
 
-    PR_ASSERT(mon != NULL);
+    Assert(mon != NULL);
     /*
      * This is safe only if mon->owner (a pthread_t) can be
@@ -512 +513 @@
         PR_Lock(&mon->lock);
         /* and now I have the lock */
-        PR_ASSERT(0 == mon->entryCount);
-        PR_ASSERT(_PT_PTHREAD_THR_HANDLE_IS_INVALID(mon->owner));
+        Assert(0 == mon->entryCount);
+        Assert(_PT_PTHREAD_THR_HANDLE_IS_INVALID(mon->owner));
         _PT_PTHREAD_COPY_THR_HANDLE(self, mon->owner);
     }
@@ -523 +524 @@
     pthread_t self = pthread_self();
 
-    PR_ASSERT(mon != NULL);
+    Assert(mon != NULL);
     /* The lock better be that - locked */
-    PR_ASSERT(_PT_PTHREAD_MUTEX_IS_LOCKED(mon->lock.mutex));
+    Assert(_PT_PTHREAD_MUTEX_IS_LOCKED(mon->lock.mutex));
     /* we'd better be the owner */
-    PR_ASSERT(pthread_equal(mon->owner, self));
+    Assert(pthread_equal(mon->owner, self));
     if (!pthread_equal(mon->owner, self))
         return PR_FAILURE;
 
     /* if it's locked and we have it, then the entries should be > 0 */
-    PR_ASSERT(mon->entryCount > 0);
+    Assert(mon->entryCount > 0);
     mon->entryCount -= 1;  /* reduce by one */
     if (mon->entryCount == 0)
@@ -549 +550 @@
     pthread_t saved_owner;
 
-    PR_ASSERT(mon != NULL);
+    Assert(mon != NULL);
     /* we'd better be locked */
-    PR_ASSERT(_PT_PTHREAD_MUTEX_IS_LOCKED(mon->lock.mutex));
+    Assert(_PT_PTHREAD_MUTEX_IS_LOCKED(mon->lock.mutex));
     /* and the entries better be positive */
-    PR_ASSERT(mon->entryCount > 0);
+    Assert(mon->entryCount > 0);
     /* and it better be by us */
-    PR_ASSERT(pthread_equal(mon->owner, pthread_self()));
+    Assert(pthread_equal(mon->owner, pthread_self()));
 
     /* tuck these away 'till later */
@@ -574 +575 @@
 PR_IMPLEMENT(PRStatus) PR_Notify(PRMonitor *mon)
 {
-    PR_ASSERT(NULL != mon);
+    Assert(NULL != mon);
     /* we'd better be locked */
-    PR_ASSERT(_PT_PTHREAD_MUTEX_IS_LOCKED(mon->lock.mutex));
+    Assert(_PT_PTHREAD_MUTEX_IS_LOCKED(mon->lock.mutex));
     /* and the entries better be positive */
-    PR_ASSERT(mon->entryCount > 0);
+    Assert(mon->entryCount > 0);
     /* and it better be by us */
-    PR_ASSERT(pthread_equal(mon->owner, pthread_self()));
+    Assert(pthread_equal(mon->owner, pthread_self()));
 
     pt_PostNotifyToCvar(mon->cvar, PR_FALSE);
@@ -589 +590 @@
 PR_IMPLEMENT(PRStatus) PR_NotifyAll(PRMonitor *mon)
 {
-    PR_ASSERT(mon != NULL);
+    Assert(mon != NULL);
     /* we'd better be locked */
-    PR_ASSERT(_PT_PTHREAD_MUTEX_IS_LOCKED(mon->lock.mutex));
+    Assert(_PT_PTHREAD_MUTEX_IS_LOCKED(mon->lock.mutex));
     /* and the entries better be positive */
-    PR_ASSERT(mon->entryCount > 0);
+    Assert(mon->entryCount > 0);
     /* and it better be by us */
-    PR_ASSERT(pthread_equal(mon->owner, pthread_self()));
+    Assert(pthread_equal(mon->owner, pthread_self()));
 
     pt_PostNotifyToCvar(mon->cvar, PR_TRUE);