Issue #1338 - Part 1: Update NSPR to 4.24

25 files changed, 860 insertions, 454 deletions

diff --git a/nsprpub/pr/src/cplus/rcascii.h b/nsprpub/pr/src/cplus/rcascii.h
index 7383d8d66..f8b59ce0f 100644
--- a/nsprpub/pr/src/cplus/rcascii.h
+++ b/nsprpub/pr/src/cplus/rcascii.h
@@ -81,7 +81,7 @@ private:
     ** for this class.
     */
     PRSize StuffFunction(void*, const char*, PRSize);
-        
+
 };  /* RCFormatBuffer */
 
 /*
diff --git a/nsprpub/pr/src/cplus/rcbase.cpp b/nsprpub/pr/src/cplus/rcbase.cpp
index c258081d3..7c12e6d3d 100644
--- a/nsprpub/pr/src/cplus/rcbase.cpp
+++ b/nsprpub/pr/src/cplus/rcbase.cpp
@@ -11,13 +11,21 @@
 
 RCBase::~RCBase() { }
 
-PRSize RCBase::GetErrorTextLength() { return PR_GetErrorTextLength(); }
-PRSize RCBase::CopyErrorText(char *text) { return PR_GetErrorText(text); }
+PRSize RCBase::GetErrorTextLength() {
+    return PR_GetErrorTextLength();
+}
+PRSize RCBase::CopyErrorText(char *text) {
+    return PR_GetErrorText(text);
+}
 
 void RCBase::SetError(PRErrorCode error, PRInt32 oserror)
-    { PR_SetError(error, oserror); }
+{
+    PR_SetError(error, oserror);
+}
 
 void RCBase::SetErrorText(PRSize text_length, const char *text)
-    { PR_SetErrorText(text_length, text); }
+{
+    PR_SetErrorText(text_length, text);
+}
 
 /* rcbase.cpp */
diff --git a/nsprpub/pr/src/cplus/rcbase.h b/nsprpub/pr/src/cplus/rcbase.h
index 58df43c12..3cc91f804 100644
--- a/nsprpub/pr/src/cplus/rcbase.h
+++ b/nsprpub/pr/src/cplus/rcbase.h
@@ -43,8 +43,12 @@ protected:
     RCBase() { }
 };  /* RCObject */
 
-inline PRErrorCode RCBase::GetError() { return PR_GetError(); }
-inline PRInt32 RCBase::GetOSError() { return PR_GetOSError(); }
+inline PRErrorCode RCBase::GetError() {
+    return PR_GetError();
+}
+inline PRInt32 RCBase::GetOSError() {
+    return PR_GetOSError();
+}
 
 #endif  /* defined(_RCRUNTIME_H) */
 
diff --git a/nsprpub/pr/src/cplus/rccv.cpp b/nsprpub/pr/src/cplus/rccv.cpp
index 32b84b1cb..f12438535 100644
--- a/nsprpub/pr/src/cplus/rccv.cpp
+++ b/nsprpub/pr/src/cplus/rccv.cpp
@@ -22,7 +22,9 @@ RCCondition::RCCondition(class RCLock *lock): RCBase()
 
 RCCondition::~RCCondition()
 {
-    if (NULL != cv) PR_DestroyCondVar(cv);
+    if (NULL != cv) {
+        PR_DestroyCondVar(cv);
+    }
 }  /* RCCondition::~RCCondition */
 
 PRStatus RCCondition::Wait()
@@ -34,8 +36,9 @@ PRStatus RCCondition::Wait()
         SetError(PR_INVALID_ARGUMENT_ERROR, 0);
         rv = PR_FAILURE;
     }
-    else
+    else {
         rv = PR_WaitCondVar(cv, timeout.interval);
+    }
     return rv;
 }  /* RCCondition::Wait */
 
@@ -60,6 +63,8 @@ PRStatus RCCondition::SetTimeout(const RCInterval& tmo)
     return PR_SUCCESS;
 }  /* RCCondition::SetTimeout */
 
-RCInterval RCCondition::GetTimeout() const { return timeout; }
+RCInterval RCCondition::GetTimeout() const {
+    return timeout;
+}
 
 /* rccv.cpp */
diff --git a/nsprpub/pr/src/cplus/rccv.h b/nsprpub/pr/src/cplus/rccv.h
index e5c89135f..afeec6161 100644
--- a/nsprpub/pr/src/cplus/rccv.h
+++ b/nsprpub/pr/src/cplus/rccv.h
@@ -41,7 +41,7 @@ public:
     virtual PRStatus Broadcast();   /* perhaps ready many threads */
 
     virtual PRStatus SetTimeout(const RCInterval&);
-                                    /* set object's current timeout value */
+    /* set object's current timeout value */
 
 private:
     PRCondVar *cv;
diff --git a/nsprpub/pr/src/cplus/rcfileio.cpp b/nsprpub/pr/src/cplus/rcfileio.cpp
index cdf6318a0..91c5fde6f 100644
--- a/nsprpub/pr/src/cplus/rcfileio.cpp
+++ b/nsprpub/pr/src/cplus/rcfileio.cpp
@@ -13,24 +13,42 @@
 
 RCFileIO::RCFileIO(): RCIO(RCIO::file) { }
 
-RCFileIO::~RCFileIO() { if (NULL != fd) (void)Close(); }
+RCFileIO::~RCFileIO() {
+    if (NULL != fd) {
+        (void)Close();
+    }
+}
 
 PRInt64 RCFileIO::Available()
-    { return fd->methods->available(fd); }
+{
+    return fd->methods->available(fd);
+}
 
 PRStatus RCFileIO::Close()
-    { PRStatus rv = fd->methods->close(fd); fd = NULL; return rv; }
+{
+    PRStatus rv = fd->methods->close(fd);
+    fd = NULL;
+    return rv;
+}
 
-PRStatus RCFileIO::Delete(const char* filename) { return PR_Delete(filename); }
+PRStatus RCFileIO::Delete(const char* filename) {
+    return PR_Delete(filename);
+}
 
 PRStatus RCFileIO::FileInfo(RCFileInfo* info) const
-    { return fd->methods->fileInfo64(fd, &info->info); }
+{
+    return fd->methods->fileInfo64(fd, &info->info);
+}
 
 PRStatus RCFileIO::FileInfo(const char *name, RCFileInfo* info)
-    { return PR_GetFileInfo64(name, &info->info); }
+{
+    return PR_GetFileInfo64(name, &info->info);
+}
 
 PRStatus RCFileIO::Fsync()
-    { return fd->methods->fsync(fd); }
+{
+    return fd->methods->fsync(fd);
+}
 
 PRStatus RCFileIO::Open(const char *filename, PRIntn flags, PRIntn mode)
 {
@@ -39,7 +57,9 @@ PRStatus RCFileIO::Open(const char *filename, PRIntn flags, PRIntn mode)
 }  /* RCFileIO::Open */
 
 PRInt32 RCFileIO::Read(void *buf, PRSize amount)
-    { return fd->methods->read(fd, buf, amount); }
+{
+    return fd->methods->read(fd, buf, amount);
+}
 
 PRInt64 RCFileIO::Seek(PRInt64 offset, RCIO::Whence how)
 {
@@ -55,11 +75,15 @@ PRInt64 RCFileIO::Seek(PRInt64 offset, RCIO::Whence how)
 }  /* RCFileIO::Seek */
 
 PRInt32 RCFileIO::Write(const void *buf, PRSize amount)
-    { return fd->methods->write(fd, buf, amount); }
+{
+    return fd->methods->write(fd, buf, amount);
+}
 
 PRInt32 RCFileIO::Writev(
     const PRIOVec *iov, PRSize size, const RCInterval& timeout)
-    { return fd->methods->writev(fd, iov, size, timeout); }
+{
+    return fd->methods->writev(fd, iov, size, timeout);
+}
 
 RCIO *RCFileIO::GetSpecialFile(RCFileIO::SpecialFile special)
 {
@@ -78,7 +102,9 @@ RCIO *RCFileIO::GetSpecialFile(RCFileIO::SpecialFile special)
     if (NULL != fd)
     {
         spec = new RCFileIO();
-        if (NULL != spec) spec->fd = fd;
+        if (NULL != spec) {
+            spec->fd = fd;
+        }
     }
     return spec;
 }  /* RCFileIO::GetSpecialFile */
@@ -90,56 +116,104 @@ RCIO *RCFileIO::GetSpecialFile(RCFileIO::SpecialFile special)
 ** are not valid for this type of I/O class (normal and special file).
 */
 PRStatus RCFileIO::Connect(const RCNetAddr&, const RCInterval&)
-{ PR_SetError(PR_INVALID_METHOD_ERROR, 0); return PR_FAILURE; }
+{
+    PR_SetError(PR_INVALID_METHOD_ERROR, 0);
+    return PR_FAILURE;
+}
 
 PRStatus RCFileIO::GetLocalName(RCNetAddr*) const
-{ PR_SetError(PR_INVALID_METHOD_ERROR, 0); return PR_FAILURE; }
+{
+    PR_SetError(PR_INVALID_METHOD_ERROR, 0);
+    return PR_FAILURE;
+}
 
 PRStatus RCFileIO::GetPeerName(RCNetAddr*) const
-{ PR_SetError(PR_INVALID_METHOD_ERROR, 0); return PR_FAILURE; }
+{
+    PR_SetError(PR_INVALID_METHOD_ERROR, 0);
+    return PR_FAILURE;
+}
 
 PRStatus RCFileIO::GetSocketOption(PRSocketOptionData*) const
-{ PR_SetError(PR_INVALID_METHOD_ERROR, 0); return PR_FAILURE; }
+{
+    PR_SetError(PR_INVALID_METHOD_ERROR, 0);
+    return PR_FAILURE;
+}
 
 PRStatus RCFileIO::Listen(PRIntn)
-{ PR_SetError(PR_INVALID_METHOD_ERROR, 0); return PR_FAILURE; }
+{
+    PR_SetError(PR_INVALID_METHOD_ERROR, 0);
+    return PR_FAILURE;
+}
 
 PRInt16 RCFileIO::Poll(PRInt16, PRInt16*)
-{ PR_SetError(PR_INVALID_METHOD_ERROR, 0); return 0; }
+{
+    PR_SetError(PR_INVALID_METHOD_ERROR, 0);
+    return 0;
+}
 
 PRInt32 RCFileIO::Recv(void*, PRSize, PRIntn, const RCInterval&)
-{ PR_SetError(PR_INVALID_METHOD_ERROR, 0); return -1; }
+{
+    PR_SetError(PR_INVALID_METHOD_ERROR, 0);
+    return -1;
+}
 
 PRInt32 RCFileIO::Recvfrom(void*, PRSize, PRIntn, RCNetAddr*, const RCInterval&)
-{ PR_SetError(PR_INVALID_METHOD_ERROR, 0); return -1; }
+{
+    PR_SetError(PR_INVALID_METHOD_ERROR, 0);
+    return -1;
+}
 
 PRInt32 RCFileIO::Send(
     const void*, PRSize, PRIntn, const RCInterval&)
-{ PR_SetError(PR_INVALID_METHOD_ERROR, 0); return -1; }
+{
+    PR_SetError(PR_INVALID_METHOD_ERROR, 0);
+    return -1;
+}
 
 PRInt32 RCFileIO::Sendto(
     const void*, PRSize, PRIntn, const RCNetAddr&, const RCInterval&)
-{ PR_SetError(PR_INVALID_METHOD_ERROR, 0); return -1; }
+{
+    PR_SetError(PR_INVALID_METHOD_ERROR, 0);
+    return -1;
+}
 
 RCIO* RCFileIO::Accept(RCNetAddr*, const RCInterval&)
-{ PR_SetError(PR_INVALID_METHOD_ERROR, 0); return NULL; }
+{
+    PR_SetError(PR_INVALID_METHOD_ERROR, 0);
+    return NULL;
+}
 
 PRStatus RCFileIO::Bind(const RCNetAddr&)
-{ PR_SetError(PR_INVALID_METHOD_ERROR, 0); return PR_FAILURE; }
+{
+    PR_SetError(PR_INVALID_METHOD_ERROR, 0);
+    return PR_FAILURE;
+}
 
 PRInt32 RCFileIO::AcceptRead(
     RCIO**, RCNetAddr**, void*, PRSize, const RCInterval&)
-{ PR_SetError(PR_INVALID_METHOD_ERROR, 0); return -1; }
+{
+    PR_SetError(PR_INVALID_METHOD_ERROR, 0);
+    return -1;
+}
 
 PRStatus RCFileIO::SetSocketOption(const PRSocketOptionData*)
-{ PR_SetError(PR_INVALID_METHOD_ERROR, 0); return PR_FAILURE; }
+{
+    PR_SetError(PR_INVALID_METHOD_ERROR, 0);
+    return PR_FAILURE;
+}
 
 PRStatus RCFileIO::Shutdown(RCIO::ShutdownHow)
-{ PR_SetError(PR_INVALID_METHOD_ERROR, 0); return PR_FAILURE; }
+{
+    PR_SetError(PR_INVALID_METHOD_ERROR, 0);
+    return PR_FAILURE;
+}
 
 PRInt32 RCFileIO::TransmitFile(
     RCIO*, const void*, PRSize, RCIO::FileDisposition, const RCInterval&)
-{ PR_SetError(PR_INVALID_METHOD_ERROR, 0); return -1; }
+{
+    PR_SetError(PR_INVALID_METHOD_ERROR, 0);
+    return -1;
+}
 
 /*
 ** Class implementation for file information object (ref: prio.h)
@@ -148,11 +222,17 @@ PRInt32 RCFileIO::TransmitFile(
 RCFileInfo::~RCFileInfo() { }
 
 RCFileInfo::RCFileInfo(const RCFileInfo& her): RCBase()
-    { info = her.info; }  /* RCFileInfo::RCFileInfo */
+{
+    info = her.info;    /* RCFileInfo::RCFileInfo */
+}
 
-RCTime RCFileInfo::CreationTime() const { return RCTime(info.creationTime); }
+RCTime RCFileInfo::CreationTime() const {
+    return RCTime(info.creationTime);
+}
 
-RCTime RCFileInfo::ModifyTime() const { return RCTime(info.modifyTime); }
+RCTime RCFileInfo::ModifyTime() const {
+    return RCTime(info.modifyTime);
+}
 
 RCFileInfo::FileType RCFileInfo::Type() const
 {
diff --git a/nsprpub/pr/src/cplus/rcfileio.h b/nsprpub/pr/src/cplus/rcfileio.h
index d9c82582d..9e28b36ac 100644
--- a/nsprpub/pr/src/cplus/rcfileio.h
+++ b/nsprpub/pr/src/cplus/rcfileio.h
@@ -41,8 +41,8 @@ public:
     virtual PRInt64     Seek(PRInt64 offset, RCIO::Whence how);
     virtual PRInt32     Write(const void *buf, PRSize amount);
     virtual PRInt32     Writev(
-                            const PRIOVec *iov, PRSize size,
-                            const RCInterval& timeout);
+        const PRIOVec *iov, PRSize size,
+        const RCInterval& timeout);
 
 private:
 
@@ -52,8 +52,8 @@ private:
 
     RCIO*       Accept(RCNetAddr* addr, const RCInterval& timeout);
     PRInt32     AcceptRead(
-                    RCIO **newfd, RCNetAddr **address, void *buffer,
-                    PRSize amount, const RCInterval& timeout);
+        RCIO **newfd, RCNetAddr **address, void *buffer,
+        PRSize amount, const RCInterval& timeout);
     PRStatus    Bind(const RCNetAddr& addr);
     PRStatus    Connect(const RCNetAddr& addr, const RCInterval& timeout);
     PRStatus    GetLocalName(RCNetAddr *addr) const;
@@ -62,24 +62,24 @@ private:
     PRStatus    Listen(PRIntn backlog);
     PRInt16     Poll(PRInt16 in_flags, PRInt16 *out_flags);
     PRInt32     Recv(
-                    void *buf, PRSize amount, PRIntn flags,
-                    const RCInterval& timeout);
+        void *buf, PRSize amount, PRIntn flags,
+        const RCInterval& timeout);
     PRInt32     Recvfrom(
-                    void *buf, PRSize amount, PRIntn flags,
-                    RCNetAddr* addr, const RCInterval& timeout);
+        void *buf, PRSize amount, PRIntn flags,
+        RCNetAddr* addr, const RCInterval& timeout);
     PRInt32     Send(
-                    const void *buf, PRSize amount, PRIntn flags,
-                    const RCInterval& timeout);
+        const void *buf, PRSize amount, PRIntn flags,
+        const RCInterval& timeout);
     PRInt32     Sendto(
-                    const void *buf, PRSize amount, PRIntn flags,
-                    const RCNetAddr& addr,
-                    const RCInterval& timeout);
+        const void *buf, PRSize amount, PRIntn flags,
+        const RCNetAddr& addr,
+        const RCInterval& timeout);
     PRStatus    SetSocketOption(const PRSocketOptionData *data);
     PRStatus    Shutdown(RCIO::ShutdownHow how);
     PRInt32     TransmitFile(
-                    RCIO *source, const void *headers,
-                    PRSize hlen, RCIO::FileDisposition flags,
-                    const RCInterval& timeout);
+        RCIO *source, const void *headers,
+        PRSize hlen, RCIO::FileDisposition flags,
+        const RCInterval& timeout);
 public:
 
     /*
@@ -116,14 +116,16 @@ public:
     RCTime ModifyTime() const;
     RCFileInfo::FileType Type() const;
 
-friend PRStatus RCFileIO::FileInfo(RCFileInfo*) const;
-friend PRStatus RCFileIO::FileInfo(const char *name, RCFileInfo*);
+    friend PRStatus RCFileIO::FileInfo(RCFileInfo*) const;
+    friend PRStatus RCFileIO::FileInfo(const char *name, RCFileInfo*);
 
 private:
     PRFileInfo64 info;
 };  /* RCFileInfo */
 
 inline RCFileInfo::RCFileInfo(): RCBase() { }
-inline PRInt64 RCFileInfo::Size() const { return info.size; }
+inline PRInt64 RCFileInfo::Size() const {
+    return info.size;
+}
 
 #endif /* defined(_RCFILEIO_H) */
diff --git a/nsprpub/pr/src/cplus/rcinrval.cpp b/nsprpub/pr/src/cplus/rcinrval.cpp
index cda5f8dfd..3805a5766 100644
--- a/nsprpub/pr/src/cplus/rcinrval.cpp
+++ b/nsprpub/pr/src/cplus/rcinrval.cpp
@@ -20,17 +20,17 @@ RCInterval::RCInterval(RCInterval::RCReservedInterval special): RCBase()
 {
     switch (special)
     {
-    case RCInterval::now:
-        interval = PR_IntervalNow();
-        break;
-    case RCInterval::no_timeout:
-        interval = PR_INTERVAL_NO_TIMEOUT;
-        break;
-    case RCInterval::no_wait:
-        interval = PR_INTERVAL_NO_WAIT;
-        break;
-    default:
-        break;
+        case RCInterval::now:
+            interval = PR_IntervalNow();
+            break;
+        case RCInterval::no_timeout:
+            interval = PR_INTERVAL_NO_TIMEOUT;
+            break;
+        case RCInterval::no_wait:
+            interval = PR_INTERVAL_NO_WAIT;
+            break;
+        default:
+            break;
     }
 }  /* RCInterval::RCInterval */
 
diff --git a/nsprpub/pr/src/cplus/rcinrval.h b/nsprpub/pr/src/cplus/rcinrval.h
index bcf755fa8..333209e61 100644
--- a/nsprpub/pr/src/cplus/rcinrval.h
+++ b/nsprpub/pr/src/cplus/rcinrval.h
@@ -66,71 +66,125 @@ public:
 
 private:
     PRIntervalTime interval;
-    
+
 };  /* RCInterval */
 
 
 inline RCInterval::RCInterval(): RCBase() { }
 
 inline RCInterval::RCInterval(const RCInterval& his): RCBase()
-    { interval = his.interval; }
+{
+    interval = his.interval;
+}
 
 inline RCInterval::RCInterval(PRIntervalTime ticks): RCBase()
-    { interval = ticks; }
+{
+    interval = ticks;
+}
 
-inline void RCInterval::SetToNow() { interval = PR_IntervalNow(); }
+inline void RCInterval::SetToNow() {
+    interval = PR_IntervalNow();
+}
 
 inline void RCInterval::operator=(const RCInterval& his)
-    { interval = his.interval; }
+{
+    interval = his.interval;
+}
 
 inline void RCInterval::operator=(PRIntervalTime his)
-    { interval = his; }
+{
+    interval = his;
+}
 
 inline PRBool RCInterval::operator==(const RCInterval& his)
-    { return (interval == his.interval) ? PR_TRUE : PR_FALSE; }
+{
+    return (interval == his.interval) ? PR_TRUE : PR_FALSE;
+}
 inline PRBool RCInterval::operator<(const RCInterval& his)
-    { return (interval < his.interval)? PR_TRUE : PR_FALSE; }
+{
+    return (interval < his.interval)? PR_TRUE : PR_FALSE;
+}
 inline PRBool RCInterval::operator>(const RCInterval& his)
-    { return (interval > his.interval) ? PR_TRUE : PR_FALSE; }
+{
+    return (interval > his.interval) ? PR_TRUE : PR_FALSE;
+}
 inline PRBool RCInterval::operator<=(const RCInterval& his)
-    { return (interval <= his.interval) ? PR_TRUE : PR_FALSE; }
+{
+    return (interval <= his.interval) ? PR_TRUE : PR_FALSE;
+}
 inline PRBool RCInterval::operator>=(const RCInterval& his)
-    { return (interval <= his.interval) ? PR_TRUE : PR_FALSE; }
+{
+    return (interval <= his.interval) ? PR_TRUE : PR_FALSE;
+}
 
 inline RCInterval RCInterval::operator+(const RCInterval& his)
-    { return RCInterval((PRIntervalTime)(interval + his.interval)); }
+{
+    return RCInterval((PRIntervalTime)(interval + his.interval));
+}
 inline RCInterval RCInterval::operator-(const RCInterval& his)
-    { return RCInterval((PRIntervalTime)(interval - his.interval)); }
+{
+    return RCInterval((PRIntervalTime)(interval - his.interval));
+}
 inline RCInterval& RCInterval::operator+=(const RCInterval& his)
-    { interval += his.interval; return *this; }
+{
+    interval += his.interval;
+    return *this;
+}
 inline RCInterval& RCInterval::operator-=(const RCInterval& his)
-    { interval -= his.interval; return *this; }
+{
+    interval -= his.interval;
+    return *this;
+}
 
 inline RCInterval RCInterval::operator/(PRUint32 him)
-    { return RCInterval((PRIntervalTime)(interval / him)); }
+{
+    return RCInterval((PRIntervalTime)(interval / him));
+}
 inline RCInterval RCInterval::operator*(PRUint32 him)
-    { return RCInterval((PRIntervalTime)(interval * him)); }
+{
+    return RCInterval((PRIntervalTime)(interval * him));
+}
 
 inline RCInterval& RCInterval::operator/=(PRUint32 him)
-    { interval /= him; return *this; }
+{
+    interval /= him;
+    return *this;
+}
 
 inline RCInterval& RCInterval::operator*=(PRUint32 him)
-    { interval *= him; return *this; }
+{
+    interval *= him;
+    return *this;
+}
 
 inline PRUint32 RCInterval::ToSeconds() const
-    { return PR_IntervalToSeconds(interval); }
+{
+    return PR_IntervalToSeconds(interval);
+}
 inline PRUint32 RCInterval::ToMilliseconds() const
-    { return PR_IntervalToMilliseconds(interval); }
+{
+    return PR_IntervalToMilliseconds(interval);
+}
 inline PRUint32 RCInterval::ToMicroseconds() const
-    { return PR_IntervalToMicroseconds(interval); }
-inline RCInterval::operator PRIntervalTime() const { return interval; }
+{
+    return PR_IntervalToMicroseconds(interval);
+}
+inline RCInterval::operator PRIntervalTime() const {
+    return interval;
+}
 
 inline PRIntervalTime RCInterval::FromSeconds(PRUint32 seconds)
-    { return PR_SecondsToInterval(seconds); }
+{
+    return PR_SecondsToInterval(seconds);
+}
 inline PRIntervalTime RCInterval::FromMilliseconds(PRUint32 milli)
-    { return PR_MillisecondsToInterval(milli); }
+{
+    return PR_MillisecondsToInterval(milli);
+}
 inline PRIntervalTime RCInterval::FromMicroseconds(PRUint32 micro)
-    { return PR_MicrosecondsToInterval(micro); }
+{
+    return PR_MicrosecondsToInterval(micro);
+}
 
 #endif  /* defined(_RCINTERVAL_H) */
 
diff --git a/nsprpub/pr/src/cplus/rcio.h b/nsprpub/pr/src/cplus/rcio.h
index a4278d2ae..1bd3ac414 100644
--- a/nsprpub/pr/src/cplus/rcio.h
+++ b/nsprpub/pr/src/cplus/rcio.h
@@ -49,14 +49,14 @@ public:
 
     virtual RCIO*       Accept(RCNetAddr* addr, const RCInterval& timeout) = 0;
     virtual PRInt32     AcceptRead(
-                            RCIO **nd, RCNetAddr **raddr, void *buf,
-                            PRSize amount, const RCInterval& timeout) = 0;
+        RCIO **nd, RCNetAddr **raddr, void *buf,
+        PRSize amount, const RCInterval& timeout) = 0;
     virtual PRInt64     Available() = 0;
     virtual PRStatus    Bind(const RCNetAddr& addr) = 0;
     virtual PRStatus    Close() = 0;
     virtual PRStatus    Connect(
-                            const RCNetAddr& addr,
-                            const RCInterval& timeout) = 0;
+        const RCNetAddr& addr,
+        const RCInterval& timeout) = 0;
     virtual PRStatus    FileInfo(RCFileInfo *info) const = 0;
     virtual PRStatus    Fsync() = 0;
     virtual PRStatus    GetLocalName(RCNetAddr *addr) const = 0;
@@ -67,36 +67,37 @@ public:
     virtual PRInt16     Poll(PRInt16 in_flags, PRInt16 *out_flags) = 0;
     virtual PRInt32     Read(void *buf, PRSize amount) = 0;
     virtual PRInt32     Recv(
-                            void *buf, PRSize amount, PRIntn flags,
-                            const RCInterval& timeout) = 0;
+        void *buf, PRSize amount, PRIntn flags,
+        const RCInterval& timeout) = 0;
     virtual PRInt32     Recvfrom(
-                            void *buf, PRSize amount, PRIntn flags,
-                            RCNetAddr* addr, const RCInterval& timeout) = 0;
+        void *buf, PRSize amount, PRIntn flags,
+        RCNetAddr* addr, const RCInterval& timeout) = 0;
     virtual PRInt64     Seek(PRInt64 offset, Whence how) = 0;
     virtual PRInt32     Send(
-                            const void *buf, PRSize amount, PRIntn flags,
-                            const RCInterval& timeout) = 0;
+        const void *buf, PRSize amount, PRIntn flags,
+        const RCInterval& timeout) = 0;
     virtual PRInt32     Sendto(
-                            const void *buf, PRSize amount, PRIntn flags,
-                            const RCNetAddr& addr,
-                            const RCInterval& timeout) = 0;
+        const void *buf, PRSize amount, PRIntn flags,
+        const RCNetAddr& addr,
+        const RCInterval& timeout) = 0;
     virtual PRStatus    SetSocketOption(const PRSocketOptionData *data) = 0;
     virtual PRStatus    Shutdown(ShutdownHow how) = 0;
     virtual PRInt32     TransmitFile(
-                            RCIO *source, const void *headers,
-                            PRSize hlen, RCIO::FileDisposition flags,
-                            const RCInterval& timeout) = 0;
+        RCIO *source, const void *headers,
+        PRSize hlen, RCIO::FileDisposition flags,
+        const RCInterval& timeout) = 0;
     virtual PRInt32     Write(const void *buf, PRSize amount) = 0;
     virtual PRInt32     Writev(
-                            const PRIOVec *iov, PRSize size,
-                            const RCInterval& timeout) = 0;
+        const PRIOVec *iov, PRSize size,
+        const RCInterval& timeout) = 0;
 
 protected:
     typedef enum {
         file = PR_DESC_FILE,
         tcp = PR_DESC_SOCKET_TCP,
         udp = PR_DESC_SOCKET_UDP,
-        layered = PR_DESC_LAYERED} RCIOType;
+        layered = PR_DESC_LAYERED
+    } RCIOType;
 
     RCIO(RCIOType);
 
diff --git a/nsprpub/pr/src/cplus/rclock.cpp b/nsprpub/pr/src/cplus/rclock.cpp
index 60d13b887..8c106de08 100644
--- a/nsprpub/pr/src/cplus/rclock.cpp
+++ b/nsprpub/pr/src/cplus/rclock.cpp
@@ -18,7 +18,9 @@ RCLock::RCLock()
 
 RCLock::~RCLock()
 {
-    if (NULL != lock) PR_DestroyLock(lock);
+    if (NULL != lock) {
+        PR_DestroyLock(lock);
+    }
     lock = NULL;
 }  /* RCLock::~RCLock */
 
diff --git a/nsprpub/pr/src/cplus/rclock.h b/nsprpub/pr/src/cplus/rclock.h
index 511b6fa4b..c86c2f17b 100644
--- a/nsprpub/pr/src/cplus/rclock.h
+++ b/nsprpub/pr/src/cplus/rclock.h
@@ -53,13 +53,21 @@ private:
     RCEnter(const RCEnter&);
     void operator=(const RCEnter&);
 
-    void *operator new(PRSize) { return NULL; }
+    void *operator new(PRSize) {
+        return NULL;
+    }
     void operator delete(void*) { }
 };  /* RCEnter */
 
 
-inline RCEnter::RCEnter(RCLock* ml) { lock = ml; lock->Acquire(); }
-inline RCEnter::~RCEnter() { lock->Release(); lock = NULL; }
+inline RCEnter::RCEnter(RCLock* ml) {
+    lock = ml;
+    lock->Acquire();
+}
+inline RCEnter::~RCEnter() {
+    lock->Release();
+    lock = NULL;
+}
 
 #endif /* defined(_RCLOCK_H) */
 
diff --git a/nsprpub/pr/src/cplus/rcnetdb.cpp b/nsprpub/pr/src/cplus/rcnetdb.cpp
index 042943bc4..19eb66540 100644
--- a/nsprpub/pr/src/cplus/rcnetdb.cpp
+++ b/nsprpub/pr/src/cplus/rcnetdb.cpp
@@ -15,7 +15,9 @@
 #include <string.h>
 
 RCNetAddr::RCNetAddr(const RCNetAddr& his): RCBase()
-    { address = his.address; }
+{
+    address = his.address;
+}
 
 RCNetAddr::RCNetAddr(const RCNetAddr& his, PRUint16 port): RCBase()
 {
@@ -42,12 +44,18 @@ RCNetAddr::RCNetAddr(RCNetAddr::HostValue host, PRUint16 port): RCBase()
 
 RCNetAddr::~RCNetAddr() { }
 
-void RCNetAddr::operator=(const RCNetAddr& his) { address = his.address; }
+void RCNetAddr::operator=(const RCNetAddr& his) {
+    address = his.address;
+}
 
 PRStatus RCNetAddr::FromString(const char* string)
-    { return PR_StringToNetAddr(string, &address); }
+{
+    return PR_StringToNetAddr(string, &address);
+}
 
-void RCNetAddr::operator=(const PRNetAddr* addr) { address = *addr; }
+void RCNetAddr::operator=(const PRNetAddr* addr) {
+    address = *addr;
+}
 
 PRBool RCNetAddr::operator==(const RCNetAddr& his) const
 {
@@ -76,14 +84,14 @@ PRBool RCNetAddr::EqualHost(const RCNetAddr& his) const
             rv = (address.inet.ip == his.address.inet.ip); break;
         case PR_AF_INET6:
             rv = (0 == memcmp(
-                &address.ipv6.ip, &his.address.ipv6.ip,
-                sizeof(address.ipv6.ip)));
+                      &address.ipv6.ip, &his.address.ipv6.ip,
+                      sizeof(address.ipv6.ip)));
             break;
 #if defined(XP_UNIX)
         case PR_AF_LOCAL:
             rv = (0 == strncmp(
-                address.local.path, his.address.local.path,
-                sizeof(address.local.path)));
+                      address.local.path, his.address.local.path,
+                      sizeof(address.local.path)));
             break;
 #endif
         default: break;
@@ -92,7 +100,9 @@ PRBool RCNetAddr::EqualHost(const RCNetAddr& his) const
 }  /* RCNetAddr::operator== */
 
 PRStatus RCNetAddr::ToString(char *string, PRSize size) const
-    { return PR_NetAddrToString(&address, string, size); }
+{
+    return PR_NetAddrToString(&address, string, size);
+}
 
 /*
 ** RCHostLookup
@@ -100,7 +110,9 @@ PRStatus RCNetAddr::ToString(char *string, PRSize size) const
 
 RCHostLookup::~RCHostLookup()
 {
-    if (NULL != address) delete [] address;
+    if (NULL != address) {
+        delete [] address;
+    }
 }  /* RCHostLookup::~RCHostLookup */
 
 RCHostLookup::RCHostLookup(): RCBase()
@@ -118,14 +130,18 @@ PRStatus RCHostLookup::ByName(const char* name)
     RCNetAddr* vector = NULL;
     RCNetAddr* old_vector = NULL;
     void* buffer = PR_Malloc(PR_NETDB_BUF_SIZE);
-    if (NULL == buffer) return PR_FAILURE;
+    if (NULL == buffer) {
+        return PR_FAILURE;
+    }
     rv = PR_GetHostByName(name, (char*)buffer, PR_NETDB_BUF_SIZE, &hostentry);
     if (PR_SUCCESS == rv)
     {
         for (max = 0, index = 0;; ++max)
         {
             index = PR_EnumerateHostEnt(index, &hostentry, 0, &addr);
-            if (0 == index) break;
+            if (0 == index) {
+                break;
+            }
         }
         if (max > 0)
         {
@@ -133,7 +149,9 @@ PRStatus RCHostLookup::ByName(const char* name)
             while (--max > 0)
             {
                 index = PR_EnumerateHostEnt(index, &hostentry, 0, &addr);
-                if (0 == index) break;
+                if (0 == index) {
+                    break;
+                }
                 vector[index] = &addr;
             }
             {
@@ -142,10 +160,14 @@ PRStatus RCHostLookup::ByName(const char* name)
                 address = vector;
                 max_index = max;
             }
-            if (NULL != old_vector) delete [] old_vector;
+            if (NULL != old_vector) {
+                delete [] old_vector;
+            }
         }
     }
-    if (NULL != buffer) PR_DELETE(buffer);
+    if (NULL != buffer) {
+        PR_DELETE(buffer);
+    }
     return PR_SUCCESS;
 }  /* RCHostLookup::ByName */
 
@@ -158,14 +180,18 @@ PRStatus RCHostLookup::ByAddress(const RCNetAddr& host_addr)
     RCNetAddr* vector = NULL;
     RCNetAddr* old_vector = NULL;
     char *buffer = (char*)PR_Malloc(PR_NETDB_BUF_SIZE);
-    if (NULL == buffer) return PR_FAILURE;
+    if (NULL == buffer) {
+        return PR_FAILURE;
+    }
     rv = PR_GetHostByAddr(host_addr, buffer, PR_NETDB_BUF_SIZE, &hostentry);
     if (PR_SUCCESS == rv)
     {
         for (max = 0, index = 0;; ++max)
         {
             index = PR_EnumerateHostEnt(index, &hostentry, 0, &addr);
-            if (0 == index) break;
+            if (0 == index) {
+                break;
+            }
         }
         if (max > 0)
         {
@@ -173,7 +199,9 @@ PRStatus RCHostLookup::ByAddress(const RCNetAddr& host_addr)
             while (--max > 0)
             {
                 index = PR_EnumerateHostEnt(index, &hostentry, 0, &addr);
-                if (0 == index) break;
+                if (0 == index) {
+                    break;
+                }
                 vector[index] = &addr;
             }
             {
@@ -182,18 +210,23 @@ PRStatus RCHostLookup::ByAddress(const RCNetAddr& host_addr)
                 address = vector;
                 max_index = max;
             }
-            if (NULL != old_vector) delete [] old_vector;
+            if (NULL != old_vector) {
+                delete [] old_vector;
+            }
         }
     }
-    if (NULL != buffer) PR_DELETE(buffer);
+    if (NULL != buffer) {
+        PR_DELETE(buffer);
+    }
     return PR_SUCCESS;
 }  /* RCHostLookup::ByAddress */
 
 const RCNetAddr* RCHostLookup::operator[](PRUintn which)
 {
     RCNetAddr* addr = NULL;
-    if (which < max_index)
+    if (which < max_index) {
         addr = &address[which];
+    }
     return addr;
 }  /* RCHostLookup::operator[] */
 
diff --git a/nsprpub/pr/src/cplus/rcnetdb.h b/nsprpub/pr/src/cplus/rcnetdb.h
index 8096113bd..14e96ecd8 100644
--- a/nsprpub/pr/src/cplus/rcnetdb.h
+++ b/nsprpub/pr/src/cplus/rcnetdb.h
@@ -28,16 +28,16 @@ public:
     RCNetAddr(const RCNetAddr&);        /* copy constructor */
     RCNetAddr(HostValue, PRUint16 port);/* init'd w/ 'special' assignments */
     RCNetAddr(const RCNetAddr&, PRUint16 port);
-                                        /* copy w/ port reassigment */
+    /* copy w/ port reassigment */
 
     virtual ~RCNetAddr();
 
     void operator=(const RCNetAddr&);
 
     virtual PRBool operator==(const RCNetAddr&) const;
-                                        /* compare of all relavent fields */
+    /* compare of all relavent fields */
     virtual PRBool EqualHost(const RCNetAddr&) const;
-                                        /* compare of just host field */
+    /* compare of just host field */
 
 
 public:
@@ -45,9 +45,9 @@ public:
     void operator=(const PRNetAddr*);   /* construction from more primitive data */
     operator const PRNetAddr*() const;  /* extraction of underlying representation */
     virtual PRStatus FromString(const char* string);
-                                        /* initialization from an ASCII string */
+    /* initialization from an ASCII string */
     virtual PRStatus ToString(char *string, PRSize size) const;
-                                        /* convert internal fromat to a string */
+    /* convert internal fromat to a string */
 
 private:
 
@@ -87,7 +87,9 @@ private:
 };
 
 inline RCNetAddr::RCNetAddr(): RCBase() { }
-inline RCNetAddr::operator const PRNetAddr*() const { return &address; }
+inline RCNetAddr::operator const PRNetAddr*() const {
+    return &address;
+}
 
 
 #endif /* defined(_RCNETDB_H) */
diff --git a/nsprpub/pr/src/cplus/rcnetio.cpp b/nsprpub/pr/src/cplus/rcnetio.cpp
index f511d81dc..e351345e4 100644
--- a/nsprpub/pr/src/cplus/rcnetio.cpp
+++ b/nsprpub/pr/src/cplus/rcnetio.cpp
@@ -12,13 +12,20 @@
 #include <private/pprio.h>
 
 RCNetStreamIO::~RCNetStreamIO()
-    { PRStatus rv = (fd->methods->close)(fd); fd = NULL; }
+{
+    PRStatus rv = (fd->methods->close)(fd);
+    fd = NULL;
+}
 
 RCNetStreamIO::RCNetStreamIO(): RCIO(RCIO::tcp)
-    { fd = PR_NewTCPSocket(); }
+{
+    fd = PR_NewTCPSocket();
+}
 
 RCNetStreamIO::RCNetStreamIO(PRIntn protocol): RCIO(RCIO::tcp)
-    { fd = PR_Socket(PR_AF_INET, PR_SOCK_STREAM, protocol); }
+{
+    fd = PR_Socket(PR_AF_INET, PR_SOCK_STREAM, protocol);
+}
 
 RCIO* RCNetStreamIO::Accept(RCNetAddr* addr, const RCInterval& timeout)
 {
@@ -33,8 +40,9 @@ RCIO* RCNetStreamIO::Accept(RCNetAddr* addr, const RCInterval& timeout)
             *addr = &peer;
             rcio->fd = newfd;
         }
-        else
+        else {
             (void)(newfd->methods->close)(newfd);
+        }
     }
     return rcio;
 }  /* RCNetStreamIO::Accept */
@@ -42,35 +50,48 @@ RCIO* RCNetStreamIO::Accept(RCNetAddr* addr, const RCInterval& timeout)
 PRInt32 RCNetStreamIO::AcceptRead(
     RCIO **nd, RCNetAddr **raddr, void *buf,
     PRSize amount, const RCInterval& timeout)
-{   
+{
     PRNetAddr *from;
     PRFileDesc *accepted;
     PRInt32 rv = (fd->methods->acceptread)(
-        fd, &accepted, &from, buf, amount, timeout);
+                     fd, &accepted, &from, buf, amount, timeout);
     if (rv >= 0)
     {
         RCNetStreamIO *ns = new RCNetStreamIO();
-        if (NULL != *nd) ns->fd = accepted;
-        else {PR_Close(accepted); rv = -1; }
+        if (NULL != *nd) {
+            ns->fd = accepted;
+        }
+        else {
+            PR_Close(accepted);
+            rv = -1;
+        }
         *nd = ns;
     }
     return rv;
 }  /* RCNetStreamIO::AcceptRead */
 
 PRInt64 RCNetStreamIO::Available()
-    { return (fd->methods->available64)(fd); }
+{
+    return (fd->methods->available64)(fd);
+}
 
 PRStatus RCNetStreamIO::Bind(const RCNetAddr& addr)
-    { return (fd->methods->bind)(fd, addr); }
+{
+    return (fd->methods->bind)(fd, addr);
+}
 
 PRStatus RCNetStreamIO::Connect(const RCNetAddr& addr, const RCInterval& timeout)
-    { return (fd->methods->connect)(fd, addr, timeout); }
+{
+    return (fd->methods->connect)(fd, addr, timeout);
+}
 
 PRStatus RCNetStreamIO::GetLocalName(RCNetAddr *addr) const
 {
     PRNetAddr local;
     PRStatus rv = (fd->methods->getsockname)(fd, &local);
-    if (PR_SUCCESS == rv) *addr = &local;
+    if (PR_SUCCESS == rv) {
+        *addr = &local;
+    }
     return rv;
 }  /* RCNetStreamIO::GetLocalName */
 
@@ -78,25 +99,37 @@ PRStatus RCNetStreamIO::GetPeerName(RCNetAddr *addr) const
 {
     PRNetAddr peer;
     PRStatus rv = (fd->methods->getpeername)(fd, &peer);
-    if (PR_SUCCESS == rv) *addr = &peer;
+    if (PR_SUCCESS == rv) {
+        *addr = &peer;
+    }
     return rv;
 }  /* RCNetStreamIO::GetPeerName */
 
 PRStatus RCNetStreamIO::GetSocketOption(PRSocketOptionData *data) const
-    { return (fd->methods->getsocketoption)(fd, data); }
+{
+    return (fd->methods->getsocketoption)(fd, data);
+}
 
 PRStatus RCNetStreamIO::Listen(PRIntn backlog)
-    { return (fd->methods->listen)(fd, backlog); }
+{
+    return (fd->methods->listen)(fd, backlog);
+}
 
 PRInt16 RCNetStreamIO::Poll(PRInt16 in_flags, PRInt16 *out_flags)
-    { return (fd->methods->poll)(fd, in_flags, out_flags); }
+{
+    return (fd->methods->poll)(fd, in_flags, out_flags);
+}
 
 PRInt32 RCNetStreamIO::Read(void *buf, PRSize amount)
-    { return (fd->methods->read)(fd, buf, amount); }
+{
+    return (fd->methods->read)(fd, buf, amount);
+}
 
 PRInt32 RCNetStreamIO::Recv(
     void *buf, PRSize amount, PRIntn flags, const RCInterval& timeout)
-    { return (fd->methods->recv)(fd, buf, amount, flags, timeout); }
+{
+    return (fd->methods->recv)(fd, buf, amount, flags, timeout);
+}
 
 PRInt32 RCNetStreamIO::Recvfrom(
     void *buf, PRSize amount, PRIntn flags,
@@ -104,25 +137,35 @@ PRInt32 RCNetStreamIO::Recvfrom(
 {
     PRNetAddr peer;
     PRInt32 rv = (fd->methods->recvfrom)(
-        fd, buf, amount, flags, &peer, timeout);
-    if (-1 != rv) *addr = &peer;
+                     fd, buf, amount, flags, &peer, timeout);
+    if (-1 != rv) {
+        *addr = &peer;
+    }
     return rv;
 }  /* RCNetStreamIO::Recvfrom */
 
 PRInt32 RCNetStreamIO::Send(
     const void *buf, PRSize amount, PRIntn flags, const RCInterval& timeout)
-    { return (fd->methods->send)(fd, buf, amount, flags, timeout); }
+{
+    return (fd->methods->send)(fd, buf, amount, flags, timeout);
+}
 
 PRInt32 RCNetStreamIO::Sendto(
     const void *buf, PRSize amount, PRIntn flags,
     const RCNetAddr& addr, const RCInterval& timeout)
-    { return (fd->methods->sendto)(fd, buf, amount, flags, addr, timeout); }
+{
+    return (fd->methods->sendto)(fd, buf, amount, flags, addr, timeout);
+}
 
 PRStatus RCNetStreamIO::SetSocketOption(const PRSocketOptionData *data)
-    { return (fd->methods->setsocketoption)(fd, data); }
+{
+    return (fd->methods->setsocketoption)(fd, data);
+}
 
 PRStatus RCNetStreamIO::Shutdown(RCIO::ShutdownHow how)
-    { return (fd->methods->shutdown)(fd, (PRIntn)how); }
+{
+    return (fd->methods->shutdown)(fd, (PRIntn)how);
+}
 
 PRInt32 RCNetStreamIO::TransmitFile(
     RCIO *source, const void *headers, PRSize hlen,
@@ -130,33 +173,52 @@ PRInt32 RCNetStreamIO::TransmitFile(
 {
     RCNetStreamIO *src = (RCNetStreamIO*)source;
     return (fd->methods->transmitfile)(
-        fd, src->fd, headers, hlen, (PRTransmitFileFlags)flags, timeout); }
+               fd, src->fd, headers, hlen, (PRTransmitFileFlags)flags, timeout);
+}
 
 PRInt32 RCNetStreamIO::Write(const void *buf, PRSize amount)
-    { return (fd->methods->write)(fd, buf, amount); }
+{
+    return (fd->methods->write)(fd, buf, amount);
+}
 
 PRInt32 RCNetStreamIO::Writev(
     const PRIOVec *iov, PRSize size, const RCInterval& timeout)
-    { return (fd->methods->writev)(fd, iov, size, timeout); }
-    
+{
+    return (fd->methods->writev)(fd, iov, size, timeout);
+}
+
 /*
 ** Invalid functions
 */
 
 PRStatus RCNetStreamIO::Close()
-    { PR_SetError(PR_INVALID_METHOD_ERROR, 0); return PR_FAILURE; }
+{
+    PR_SetError(PR_INVALID_METHOD_ERROR, 0);
+    return PR_FAILURE;
+}
 
 PRStatus RCNetStreamIO::FileInfo(RCFileInfo*) const
-    { PR_SetError(PR_INVALID_METHOD_ERROR, 0); return PR_FAILURE; }
+{
+    PR_SetError(PR_INVALID_METHOD_ERROR, 0);
+    return PR_FAILURE;
+}
 
 PRStatus RCNetStreamIO::Fsync()
-    { return (fd->methods->fsync)(fd); }
+{
+    return (fd->methods->fsync)(fd);
+}
 
 PRStatus RCNetStreamIO::Open(const char*, PRIntn, PRIntn)
-    { PR_SetError(PR_INVALID_METHOD_ERROR, 0); return PR_FAILURE; }
+{
+    PR_SetError(PR_INVALID_METHOD_ERROR, 0);
+    return PR_FAILURE;
+}
 
 PRInt64 RCNetStreamIO::Seek(PRInt64, RCIO::Whence)
-    { PR_SetError(PR_INVALID_METHOD_ERROR, 0); return PR_FAILURE; }
+{
+    PR_SetError(PR_INVALID_METHOD_ERROR, 0);
+    return PR_FAILURE;
+}
 
 /* RCNetStreamIO.cpp */
 
diff --git a/nsprpub/pr/src/cplus/rcnetio.h b/nsprpub/pr/src/cplus/rcnetio.h
index 44b8bf071..7f6b669d5 100644
--- a/nsprpub/pr/src/cplus/rcnetio.h
+++ b/nsprpub/pr/src/cplus/rcnetio.h
@@ -37,12 +37,12 @@ public:
 
     virtual RCIO*       Accept(RCNetAddr* addr, const RCInterval& timeout);
     virtual PRInt32     AcceptRead(
-                            RCIO **nd, RCNetAddr **raddr, void *buf,
-                            PRSize amount, const RCInterval& timeout);
+        RCIO **nd, RCNetAddr **raddr, void *buf,
+        PRSize amount, const RCInterval& timeout);
     virtual PRInt64     Available();
     virtual PRStatus    Bind(const RCNetAddr& addr);
     virtual PRStatus    Connect(
-                            const RCNetAddr& addr, const RCInterval& timeout);
+        const RCNetAddr& addr, const RCInterval& timeout);
     virtual PRStatus    GetLocalName(RCNetAddr *addr) const;
     virtual PRStatus    GetPeerName(RCNetAddr *addr) const;
     virtual PRStatus    GetSocketOption(PRSocketOptionData *data) const;
@@ -50,28 +50,28 @@ public:
     virtual PRInt16     Poll(PRInt16 in_flags, PRInt16 *out_flags);
     virtual PRInt32     Read(void *buf, PRSize amount);
     virtual PRInt32     Recv(
-                            void *buf, PRSize amount, PRIntn flags,
-                            const RCInterval& timeout);
+        void *buf, PRSize amount, PRIntn flags,
+        const RCInterval& timeout);
     virtual PRInt32     Recvfrom(
-                            void *buf, PRSize amount, PRIntn flags,
-                            RCNetAddr* addr, const RCInterval& timeout);
+        void *buf, PRSize amount, PRIntn flags,
+        RCNetAddr* addr, const RCInterval& timeout);
     virtual PRInt32     Send(
-                            const void *buf, PRSize amount, PRIntn flags,
-                            const RCInterval& timeout);
+        const void *buf, PRSize amount, PRIntn flags,
+        const RCInterval& timeout);
     virtual PRInt32     Sendto(
-                            const void *buf, PRSize amount, PRIntn flags,
-                            const RCNetAddr& addr,
-                            const RCInterval& timeout);
+        const void *buf, PRSize amount, PRIntn flags,
+        const RCNetAddr& addr,
+        const RCInterval& timeout);
     virtual PRStatus    SetSocketOption(const PRSocketOptionData *data);
     virtual PRStatus    Shutdown(ShutdownHow how);
     virtual PRInt32     TransmitFile(
-                            RCIO *source, const void *headers,
-                            PRSize hlen, RCIO::FileDisposition flags,
-                            const RCInterval& timeout);
+        RCIO *source, const void *headers,
+        PRSize hlen, RCIO::FileDisposition flags,
+        const RCInterval& timeout);
     virtual PRInt32     Write(const void *buf, PRSize amount);
     virtual PRInt32     Writev(
-                            const PRIOVec *iov, PRSize size,
-                            const RCInterval& timeout);
+        const PRIOVec *iov, PRSize size,
+        const RCInterval& timeout);
 
 private:
     /* functions unavailable to this clients of this class */
diff --git a/nsprpub/pr/src/cplus/rcthread.cpp b/nsprpub/pr/src/cplus/rcthread.cpp
index 3db00d369..471e580a2 100755
--- a/nsprpub/pr/src/cplus/rcthread.cpp
+++ b/nsprpub/pr/src/cplus/rcthread.cpp
@@ -18,11 +18,13 @@ static RCPrimordialThread *primordial = NULL;
 void nas_Root(void *arg)
 {
     RCThread *him = (RCThread*)arg;
-    while (RCThread::ex_unstarted == him->execution)
-        (void)PR_Sleep(PR_INTERVAL_NO_TIMEOUT);  /* wait for Start() */
+    while (RCThread::ex_unstarted == him->execution) {
+        (void)PR_Sleep(PR_INTERVAL_NO_TIMEOUT);    /* wait for Start() */
+    }
     him->RootFunction();  /* he gets a self reference */
-    if (PR_UNJOINABLE_THREAD == PR_GetThreadState(him->identity))
+    if (PR_UNJOINABLE_THREAD == PR_GetThreadState(him->identity)) {
         delete him;
+    }
 }  /* nas_Root */
 
 RCThread::~RCThread() { }
@@ -40,9 +42,9 @@ RCThread::RCThread(
 {
     execution = ex_unstarted;
     identity = PR_CreateThread(
-        PR_USER_THREAD, nas_Root, this,
-        PR_GetThreadPriority(PR_GetCurrentThread()),
-        (PRThreadScope)scope, (PRThreadState)join, stackSize);
+                   PR_USER_THREAD, nas_Root, this,
+                   PR_GetThreadPriority(PR_GetCurrentThread()),
+                   (PRThreadScope)scope, (PRThreadState)join, stackSize);
 }  /* RCThread::RCThread */
 
 void RCThread::operator=(const RCThread&)
@@ -77,8 +79,12 @@ PRStatus RCThread::Join()
         rv = PR_FAILURE;
         PR_SetError(PR_INVALID_STATE_ERROR, 0);
     }
-    else rv = PR_JoinThread(identity);
-    if (PR_SUCCESS == rv) delete this;
+    else {
+        rv = PR_JoinThread(identity);
+    }
+    if (PR_SUCCESS == rv) {
+        delete this;
+    }
     return rv;
 }  /* RCThread::Join */
 
@@ -90,27 +96,41 @@ PRStatus RCThread::Interrupt()
         rv = PR_FAILURE;
         PR_SetError(PR_INVALID_STATE_ERROR, 0);
     }
-    else rv = PR_Interrupt(identity);
+    else {
+        rv = PR_Interrupt(identity);
+    }
     return rv;
 }  /* RCThread::Interrupt */
 
-void RCThread::ClearInterrupt() { PR_ClearInterrupt(); }
+void RCThread::ClearInterrupt() {
+    PR_ClearInterrupt();
+}
 
 void RCThread::SetPriority(RCThread::Priority new_priority)
-    { PR_SetThreadPriority(identity, (PRThreadPriority)new_priority); }
+{
+    PR_SetThreadPriority(identity, (PRThreadPriority)new_priority);
+}
 
 PRThread *RCThread::Self()
-    { return PR_GetCurrentThread(); }
+{
+    return PR_GetCurrentThread();
+}
 
 RCThread::Scope RCThread::GetScope() const
-    { return (RCThread::Scope)PR_GetThreadScope(identity); }
+{
+    return (RCThread::Scope)PR_GetThreadScope(identity);
+}
 
 RCThread::State RCThread::GetState() const
-    { return (RCThread::State)PR_GetThreadState(identity); }
+{
+    return (RCThread::State)PR_GetThreadState(identity);
+}
 
 RCThread::Priority RCThread::GetPriority() const
-    { return (RCThread::Priority)PR_GetThreadPriority(identity); }
-    
+{
+    return (RCThread::Priority)PR_GetThreadPriority(identity);
+}
+
 static void _rc_PDDestructor(RCThreadPrivateData* privateData)
 {
     PR_ASSERT(NULL != privateData);
@@ -120,10 +140,14 @@ static void _rc_PDDestructor(RCThreadPrivateData* privateData)
 static PRThreadPrivateDTOR _tpd_dtor = (PRThreadPrivateDTOR)_rc_PDDestructor;
 
 PRStatus RCThread::NewPrivateIndex(PRUintn* index)
-    { return PR_NewThreadPrivateIndex(index, _tpd_dtor); }
+{
+    return PR_NewThreadPrivateIndex(index, _tpd_dtor);
+}
 
 PRStatus RCThread::SetPrivateData(PRUintn index)
-    { return PR_SetThreadPrivate(index, NULL); }
+{
+    return PR_SetThreadPrivate(index, NULL);
+}
 
 PRStatus RCThread::SetPrivateData(PRUintn index, RCThreadPrivateData* data)
 {
@@ -131,10 +155,15 @@ PRStatus RCThread::SetPrivateData(PRUintn index, RCThreadPrivateData* data)
 }
 
 RCThreadPrivateData* RCThread::GetPrivateData(PRUintn index)
-    { return (RCThreadPrivateData*)PR_GetThreadPrivate(index); }
+{
+    return (RCThreadPrivateData*)PR_GetThreadPrivate(index);
+}
 
 PRStatus RCThread::Sleep(const RCInterval& ticks)
-    { PRIntervalTime tmo = ticks; return PR_Sleep(tmo); }
+{
+    PRIntervalTime tmo = ticks;
+    return PR_Sleep(tmo);
+}
 
 RCPrimordialThread *RCThread::WrapPrimordialThread()
 {
@@ -155,7 +184,9 @@ RCPrimordialThread *RCThread::WrapPrimordialThread()
             me->execution = RCThread::ex_started;
             me->identity = PR_GetCurrentThread();
         }
-        else delete me;  /* somebody beat us to it */
+        else {
+            delete me;    /* somebody beat us to it */
+        }
     }
     return primordial;
 }  /* RCThread::WrapPrimordialThread */
@@ -166,10 +197,12 @@ RCPrimordialThread::~RCPrimordialThread() { }
 
 void RCPrimordialThread::RootFunction()
 {
-    PR_NOT_REACHED("Primordial thread calling root function"); 
+    PR_NOT_REACHED("Primordial thread calling root function");
 }  /* RCPrimordialThread::RootFunction */
- 
-PRStatus RCPrimordialThread::Cleanup() { return PR_Cleanup(); }
+
+PRStatus RCPrimordialThread::Cleanup() {
+    return PR_Cleanup();
+}
 
 PRStatus RCPrimordialThread::SetVirtualProcessors(PRIntn count)
 {
diff --git a/nsprpub/pr/src/cplus/rcthread.h b/nsprpub/pr/src/cplus/rcthread.h
index 8683c0a55..b7716d4b9 100644
--- a/nsprpub/pr/src/cplus/rcthread.h
+++ b/nsprpub/pr/src/cplus/rcthread.h
@@ -31,7 +31,7 @@ class PR_IMPLEMENT(RCThread): public RCBase
 {
 public:
 
-    typedef enum 
+    typedef enum
     {
         local = PR_LOCAL_THREAD, global = PR_GLOBAL_THREAD
     } Scope;
@@ -68,12 +68,12 @@ public:
      * the target thread returns from it's root function.
      */
     virtual PRStatus Join();
-    
+
     /*
      * The priority of a newly created thread is the same as the creator.
      * The priority may be changed either by the new thread itself, by
      * the creator or any other arbitrary thread.
-     */   
+     */
     virtual void SetPriority(Priority newPriority);
 
 
@@ -82,14 +82,14 @@ public:
      * is doing and return with a well known error code.
      */
     virtual PRStatus Interrupt();
-    
+
     /*
      * And in case a thread was interrupted and didn't get a chance
      * to have the notification delivered, a way to cancel the pending
      * status.
      */
     static void ClearInterrupt();
-    
+
     /*
      * Methods to discover the attributes of an existing thread.
      */
@@ -150,15 +150,15 @@ private:
     /* There is no public default constructor or copy constructor */
     RCThread();
     RCThread(const RCThread&);
-    
+
     /* And there is no assignment operator */
     void operator=(const RCThread&);
 
 public:
-    static RCPrimordialThread *WrapPrimordialThread();    
+    static RCPrimordialThread *WrapPrimordialThread();
+
+};
 
- };
- 
 /*
 ** class RCPrimordialThread
 */
@@ -180,7 +180,7 @@ public:
     */
     static PRStatus SetVirtualProcessors(PRIntn count=10);
 
-friend class RCThread;
+    friend class RCThread;
 private:
     /*
     ** None other than the runtime can create of destruct
@@ -192,4 +192,4 @@ private:
     void RootFunction();
 };  /* RCPrimordialThread */
 
- #endif /* defined(_RCTHREAD_H) */
+#endif /* defined(_RCTHREAD_H) */
diff --git a/nsprpub/pr/src/cplus/rctime.cpp b/nsprpub/pr/src/cplus/rctime.cpp
index d65510402..2c9823e15 100644
--- a/nsprpub/pr/src/cplus/rctime.cpp
+++ b/nsprpub/pr/src/cplus/rctime.cpp
@@ -11,24 +11,46 @@
 
 RCTime::~RCTime() { }
 
-RCTime::RCTime(PRTime time): RCBase() { gmt = time; }
-RCTime::RCTime(const RCTime& his): RCBase() { gmt = his.gmt; }
-RCTime::RCTime(RCTime::Current): RCBase() { gmt = PR_Now(); }
+RCTime::RCTime(PRTime time): RCBase() {
+    gmt = time;
+}
+RCTime::RCTime(const RCTime& his): RCBase() {
+    gmt = his.gmt;
+}
+RCTime::RCTime(RCTime::Current): RCBase() {
+    gmt = PR_Now();
+}
 RCTime::RCTime(const PRExplodedTime& time): RCBase()
-{ gmt = PR_ImplodeTime(&time); }
+{
+    gmt = PR_ImplodeTime(&time);
+}
 
 void RCTime::operator=(const PRExplodedTime& time)
-{ gmt = PR_ImplodeTime(&time); }
+{
+    gmt = PR_ImplodeTime(&time);
+}
 
 RCTime RCTime::operator+(const RCTime& his)
-{ RCTime sum(gmt + his.gmt); return sum; }
+{
+    RCTime sum(gmt + his.gmt);
+    return sum;
+}
 
 RCTime RCTime::operator-(const RCTime& his)
-{ RCTime difference(gmt - his.gmt); return difference; }
+{
+    RCTime difference(gmt - his.gmt);
+    return difference;
+}
 
 RCTime RCTime::operator/(PRUint64 his)
-{ RCTime quotient(gmt / gmt); return quotient; }
+{
+    RCTime quotient(gmt / gmt);
+    return quotient;
+}
 
 RCTime RCTime::operator*(PRUint64 his)
-{ RCTime product(gmt * his); return product; }
+{
+    RCTime product(gmt * his);
+    return product;
+}
 
diff --git a/nsprpub/pr/src/cplus/rctime.h b/nsprpub/pr/src/cplus/rctime.h
index 4cf7b9042..3752a3d53 100644
--- a/nsprpub/pr/src/cplus/rctime.h
+++ b/nsprpub/pr/src/cplus/rctime.h
@@ -39,7 +39,7 @@ public:
     virtual ~RCTime();
 
     /* assignment operators */
-    void operator=(const RCTime&); 
+    void operator=(const RCTime&);
     void operator=(const PRExplodedTime&);
 
     /* comparitive operators */
@@ -75,31 +75,61 @@ public:
 
 inline RCTime::RCTime(): RCBase() { }
 
-inline void RCTime::Now() { gmt = PR_Now(); }
-inline RCTime::operator PRTime() const { return gmt; }
+inline void RCTime::Now() {
+    gmt = PR_Now();
+}
+inline RCTime::operator PRTime() const {
+    return gmt;
+}
 
-inline void RCTime::operator=(PRTime his) { gmt = his; }
-inline void RCTime::operator=(const RCTime& his) { gmt = his.gmt; }
+inline void RCTime::operator=(PRTime his) {
+    gmt = his;
+}
+inline void RCTime::operator=(const RCTime& his) {
+    gmt = his.gmt;
+}
 
 inline PRBool RCTime::operator<(const RCTime& his)
-    { return (gmt < his.gmt) ? PR_TRUE : PR_FALSE; }
+{
+    return (gmt < his.gmt) ? PR_TRUE : PR_FALSE;
+}
 inline PRBool RCTime::operator>(const RCTime& his)
-    { return (gmt > his.gmt) ? PR_TRUE : PR_FALSE; }
+{
+    return (gmt > his.gmt) ? PR_TRUE : PR_FALSE;
+}
 inline PRBool RCTime::operator<=(const RCTime& his)
-    { return (gmt <= his.gmt) ? PR_TRUE : PR_FALSE; }
+{
+    return (gmt <= his.gmt) ? PR_TRUE : PR_FALSE;
+}
 inline PRBool RCTime::operator>=(const RCTime& his)
-    { return (gmt >= his.gmt) ? PR_TRUE : PR_FALSE; }
+{
+    return (gmt >= his.gmt) ? PR_TRUE : PR_FALSE;
+}
 inline PRBool RCTime::operator==(const RCTime& his)
-    { return (gmt == his.gmt) ? PR_TRUE : PR_FALSE; }
+{
+    return (gmt == his.gmt) ? PR_TRUE : PR_FALSE;
+}
 
 inline RCTime& RCTime::operator+=(const RCTime& his)
-    { gmt += his.gmt; return *this; }
+{
+    gmt += his.gmt;
+    return *this;
+}
 inline RCTime& RCTime::operator-=(const RCTime& his)
-    { gmt -= his.gmt; return *this; }
+{
+    gmt -= his.gmt;
+    return *this;
+}
 inline RCTime& RCTime::operator/=(PRUint64 his)
-    { gmt /= his; return *this; }
+{
+    gmt /= his;
+    return *this;
+}
 inline RCTime& RCTime::operator*=(PRUint64 his)
-    { gmt *= his; return *this; }
+{
+    gmt *= his;
+    return *this;
+}
 
 #endif /* defined(_RCTIME_H) */
 
diff --git a/nsprpub/pr/src/cplus/tests/Makefile.in b/nsprpub/pr/src/cplus/tests/Makefile.in
index c16423872..df4827656 100644
--- a/nsprpub/pr/src/cplus/tests/Makefile.in
+++ b/nsprpub/pr/src/cplus/tests/Makefile.in
@@ -49,24 +49,6 @@ LDOPTS = -L$(dist_libdir)
 LIBPR = -lnspr$(MOD_MAJOR_VERSION)
 LIBPL = -lplc$(MOD_MAJOR_VERSION)
 
-ifeq ($(OS_ARCH), IRIX)
-    LDOPTS += -rpath $(PWD)/$(dist_libdir) -rdata_shared
-    # For 6.x machines, include this flag
-    ifeq ($(basename $(OS_RELEASE)),6)
-        ifeq ($(USE_N32),1)
-            LDOPTS += -n32
-        else
-            LDOPTS += -32
-        endif
-
-        ifeq ($(USE_PTHREADS), 1)
-            ifeq ($(OS_RELEASE), 6.2)
-                LDOPTS += -Wl,-woff,85
-            endif
-        endif
-    endif
-endif
-
 # Solaris
 ifeq ($(OS_ARCH), SunOS)
     ifdef NS_USE_GCC
@@ -103,10 +85,6 @@ ifneq ($(OS_ARCH), WINNT)
 PWD = $(shell pwd)
 endif
 
-ifeq ($(OS_ARCH), OSF1)
-LDOPTS += -rpath $(PWD)/$(dist_libdir)
-endif
-
 ifeq ($(OS_ARCH), HP-UX)
     LDOPTS += -Wl,+s,+b,$(PWD)/$(dist_libdir)
 endif
diff --git a/nsprpub/pr/src/cplus/tests/ranfile.cpp b/nsprpub/pr/src/cplus/tests/ranfile.cpp
index c3ac0d3a4..0fb4c5d23 100644
--- a/nsprpub/pr/src/cplus/tests/ranfile.cpp
+++ b/nsprpub/pr/src/cplus/tests/ranfile.cpp
@@ -12,12 +12,12 @@
 ** Description: Test to hammer on various components of NSPR
 ** Modification History:
 ** 20-May-97 AGarcia- Converted the test to accomodate the debug_mode flag.
-**	         The debug mode will print all of the printfs associated with this test.
-**			 The regress mode will be the default mode. Since the regress tool limits
+**           The debug mode will print all of the printfs associated with this test.
+**           The regress mode will be the default mode. Since the regress tool limits
 **           the output to a one line status:PASS or FAIL,all of the printf statements
-**			 have been handled with an if (debug_mode) statement.
+**           have been handled with an if (debug_mode) statement.
 ** 04-June-97 AGarcia removed the Test_Result function. Regress tool has been updated to
-**			recognize the return code from tha main program.
+**          recognize the return code from tha main program.
 ***********************************************************************/
 
 
@@ -46,19 +46,21 @@ class HammerData
 {
 public:
     typedef enum {
-        sg_go, sg_stop, sg_done} Action;
+        sg_go, sg_stop, sg_done
+    } Action;
     typedef enum {
-        sg_okay, sg_open, sg_close, sg_delete, sg_write, sg_seek} Problem;
+        sg_okay, sg_open, sg_close, sg_delete, sg_write, sg_seek
+    } Problem;
 
-	virtual ~HammerData();
-	HammerData(RCLock* lock, RCCondition *cond, PRUint32 clip);
+    virtual ~HammerData();
+    HammerData(RCLock* lock, RCCondition *cond, PRUint32 clip);
     virtual PRUint32 Random();
 
     Action action;
     Problem problem;
     PRUint32 writes;
     RCInterval timein;
-friend class Hammer;
+    friend class Hammer;
 private:
     RCLock *ml;
     RCCondition *cv;
@@ -117,7 +119,7 @@ Hammer::~Hammer() { }
 
 Hammer::Hammer(
     RCThread::Scope scope, RCLock* lock, RCCondition *cond, PRUint32 clip):
-	HammerData(lock, cond, clip), RCThread(scope, RCThread::joinable, 0) { }
+    HammerData(lock, cond, clip), RCThread(scope, RCThread::joinable, 0) { }
 
 HammerData::~HammerData() { }
 
@@ -171,7 +173,9 @@ void Hammer::RootFunction()
 
     (void)sprintf(filename, "%ssg%04p.dat", baseName, this);
 
-    if (debug_mode) PR_fprintf(output, "Starting work on %s\n", filename);
+    if (debug_mode) {
+        PR_fprintf(output, "Starting work on %s\n", filename);
+    }
 
     while (PR_TRUE)
     {
@@ -182,52 +186,78 @@ void Hammer::RootFunction()
         while (minor-- > 0)
         {
             problem = sg_okay;
-            if (action != sg_go) goto finished;
+            if (action != sg_go) {
+                goto finished;
+            }
             problem = sg_open;
             rv = file.Open(filename, PR_RDWR|PR_CREATE_FILE, 0666);
-            if (PR_FAILURE == rv) goto finished;
+            if (PR_FAILURE == rv) {
+                goto finished;
+            }
             for (index = 0; index < pages; index++)
             {
                 problem = sg_okay;
-                if (action != sg_go) goto close;
+                if (action != sg_go) {
+                    goto close;
+                }
                 problem = sg_seek;
                 bytes = file.Seek(pageSize * index, RCFileIO::set);
-                if (bytes != pageSize * index) goto close;
+                if (bytes != pageSize * index) {
+                    goto close;
+                }
                 problem = sg_write;
                 bytes = file.Write(&zero, sizeof(zero));
-                if (bytes <= 0) goto close;
+                if (bytes <= 0) {
+                    goto close;
+                }
                 writes += 1;
             }
             problem = sg_close;
             rv = file.Close();
-            if (rv != PR_SUCCESS) goto purge;
+            if (rv != PR_SUCCESS) {
+                goto purge;
+            }
 
             problem = sg_okay;
-            if (action != sg_go) goto purge;
+            if (action != sg_go) {
+                goto purge;
+            }
 
             problem = sg_open;
             rv = file.Open(filename, PR_RDWR, 0666);
-            if (PR_FAILURE == rv) goto finished;
+            if (PR_FAILURE == rv) {
+                goto finished;
+            }
             for (index = 0; index < pages; index++)
             {
                 problem = sg_okay;
-                if (action != sg_go) goto close;
+                if (action != sg_go) {
+                    goto close;
+                }
                 problem = sg_seek;
                 bytes = file.Seek(pageSize * index, RCFileIO::set);
-                if (bytes != pageSize * index) goto close;
+                if (bytes != pageSize * index) {
+                    goto close;
+                }
                 problem = sg_write;
                 bytes = file.Write(&zero, sizeof(zero));
-                if (bytes <= 0) goto close;
+                if (bytes <= 0) {
+                    goto close;
+                }
                 writes += 1;
                 random = (random + 511) % pages;
             }
             problem = sg_close;
             rv = file.Close();
-            if (rv != PR_SUCCESS) goto purge;
+            if (rv != PR_SUCCESS) {
+                goto purge;
+            }
             problem = sg_delete;
             rv = file.Delete(filename);
-            if (rv != PR_SUCCESS) goto finished;
-       }
+            if (rv != PR_SUCCESS) {
+                goto finished;
+            }
+        }
     }
 
 close:
@@ -239,7 +269,9 @@ finished:
     action = HammerData::sg_done;
     cv->Notify();
 
-    if (debug_mode) PR_fprintf(output, "Ending work on %s\n", filename);
+    if (debug_mode) {
+        PR_fprintf(output, "Ending work on %s\n", filename);
+    }
 
     return;
 }  /* Hammer::RootFunction */
@@ -278,7 +310,7 @@ static Hammer* hammer[100];
 PRIntn main (PRIntn argc, char *argv[])
 {
     RCLock ml;
-	PLOptStatus os;
+    PLOptStatus os;
     RCCondition cv(&ml);
     PRUint32 writesMax = 0, durationTot = 0;
     RCThread::Scope thread_scope = RCThread::local;
@@ -288,57 +320,65 @@ PRIntn main (PRIntn argc, char *argv[])
 
     const char *where[] = {"okay", "open", "close", "delete", "write", "seek"};
 
-	PLOptState *opt = PL_CreateOptState(argc, argv, "Gdl:t:i:");
-	while (PL_OPT_EOL != (os = PL_GetNextOpt(opt)))
+    PLOptState *opt = PL_CreateOptState(argc, argv, "Gdl:t:i:");
+    while (PL_OPT_EOL != (os = PL_GetNextOpt(opt)))
     {
-		if (PL_OPT_BAD == os) continue;
+        if (PL_OPT_BAD == os) {
+            continue;
+        }
         switch (opt->option)
         {
-	case 0:
-		baseName = opt->value;
-		break;
-        case 'G':  /* global threads */
-		thread_scope = RCThread::global;
-            break;
-        case 'd':  /* debug mode */
-			debug_mode = 1;
-            break;
-        case 'l':  /* limiting number */
-			limit = atoi(opt->value);
-            break;
-        case 't':  /* number of threads */
-			threads = atoi(opt->value);
-            break;
-        case 'i':  /* iteration counter */
-			max_virtual_procs = atoi(opt->value);
-            break;
-         default:
-            break;
+            case 0:
+                baseName = opt->value;
+                break;
+            case 'G':  /* global threads */
+                thread_scope = RCThread::global;
+                break;
+            case 'd':  /* debug mode */
+                debug_mode = 1;
+                break;
+            case 'l':  /* limiting number */
+                limit = atoi(opt->value);
+                break;
+            case 't':  /* number of threads */
+                threads = atoi(opt->value);
+                break;
+            case 'i':  /* iteration counter */
+                max_virtual_procs = atoi(opt->value);
+                break;
+            default:
+                break;
         }
     }
-	PL_DestroyOptState(opt);
+    PL_DestroyOptState(opt);
     output = PR_GetSpecialFD(PR_StandardOutput);
 
- /* main test */
- 
+    /* main test */
+
     cv.SetTimeout(interleave);
-	
-    if (max_virtual_procs == 0) max_virtual_procs = 2;
-    if (limit == 0) limit = 57;
-    if (threads == 0) threads = 10;
+
+    if (max_virtual_procs == 0) {
+        max_virtual_procs = 2;
+    }
+    if (limit == 0) {
+        limit = 57;
+    }
+    if (threads == 0) {
+        threads = 10;
+    }
 
     if (debug_mode) PR_fprintf(output,
-        "%s: Using %d virtual processors, %d threads, limit = %d and %s threads\n",
-        programName, max_virtual_procs, threads, limit,
-        (thread_scope == RCThread::local) ? "LOCAL" : "GLOBAL");
+                                   "%s: Using %d virtual processors, %d threads, limit = %d and %s threads\n",
+                                   programName, max_virtual_procs, threads, limit,
+                                   (thread_scope == RCThread::local) ? "LOCAL" : "GLOBAL");
 
     for (virtual_procs = 0; virtual_procs < max_virtual_procs; ++virtual_procs)
     {
         if (debug_mode)
-			PR_fprintf(output,
-				"%s: Setting number of virtual processors to %d\n",
-				programName, virtual_procs + 1);
-		RCPrimordialThread::SetVirtualProcessors(virtual_procs + 1);
+            PR_fprintf(output,
+                       "%s: Setting number of virtual processors to %d\n",
+                       programName, virtual_procs + 1);
+        RCPrimordialThread::SetVirtualProcessors(virtual_procs + 1);
         for (active = 0; active < threads; active++)
         {
             hammer[active] = new Hammer(thread_scope, &ml, &cv, limit);
@@ -354,8 +394,9 @@ PRIntn main (PRIntn argc, char *argv[])
             RCEnter scope(&ml);
             for (poll = 0; poll < threads; poll++)
             {
-                if (hammer[poll]->action == HammerData::sg_go)  /* don't overwrite done */
-                    hammer[poll]->action = HammerData::sg_stop;  /* ask him to stop */
+                if (hammer[poll]->action == HammerData::sg_go) { /* don't overwrite done */
+                    hammer[poll]->action = HammerData::sg_stop;    /* ask him to stop */
+                }
             }
         }
 
@@ -364,24 +405,32 @@ PRIntn main (PRIntn argc, char *argv[])
             for (poll = 0; poll < threads; poll++)
             {
                 ml.Acquire();
-                while (hammer[poll]->action < HammerData::sg_done) cv.Wait();
+                while (hammer[poll]->action < HammerData::sg_done) {
+                    cv.Wait();
+                }
                 ml.Release();
 
                 if (hammer[poll]->problem == HammerData::sg_okay)
                 {
                     duration = RCInterval(RCInterval::now) - hammer[poll]->timein;
                     writes = hammer[poll]->writes * 1000 / duration;
-                    if (writes < writesMin)  writesMin = writes;
-                    if (writes > writesMax) writesMax = writes;
+                    if (writes < writesMin) {
+                        writesMin = writes;
+                    }
+                    if (writes > writesMax) {
+                        writesMax = writes;
+                    }
                     writesTot += hammer[poll]->writes;
                     durationTot += duration;
                 }
                 else
                 {
                     if (debug_mode) PR_fprintf(output,
-                        "%s: test failed %s after %ld seconds\n",
-                        programName, where[hammer[poll]->problem], duration);
-					else failed_already=1;
+                                                   "%s: test failed %s after %ld seconds\n",
+                                                   programName, where[hammer[poll]->problem], duration);
+                    else {
+                        failed_already=1;
+                    }
                 }
                 active -= 1;  /* this is another one down */
                 (void)hammer[poll]->Join();
@@ -389,12 +438,12 @@ PRIntn main (PRIntn argc, char *argv[])
             }
         }
         if (debug_mode) PR_fprintf(output,
-            "%s: [%ld [%ld] %ld] writes/sec average\n",
-            programName, writesMin,
-            writesTot * 1000 / durationTot, writesMax);
+                                       "%s: [%ld [%ld] %ld] writes/sec average\n",
+                                       programName, writesMin,
+                                       writesTot * 1000 / durationTot, writesMax);
     }
 
-        failed_already |= (PR_FAILURE == RCPrimordialThread::Cleanup());
-	    PR_fprintf(output, "%s\n", (failed_already) ? "FAIL\n" : "PASS\n");
-		return failed_already;
+    failed_already |= (PR_FAILURE == RCPrimordialThread::Cleanup());
+    PR_fprintf(output, "%s\n", (failed_already) ? "FAIL\n" : "PASS\n");
+    return failed_already;
 }  /* main */
diff --git a/nsprpub/pr/src/cplus/tests/switch.cpp b/nsprpub/pr/src/cplus/tests/switch.cpp
index 4cb14c48f..00de8e306 100644
--- a/nsprpub/pr/src/cplus/tests/switch.cpp
+++ b/nsprpub/pr/src/cplus/tests/switch.cpp
@@ -70,8 +70,12 @@ void Shared::RootFunction()
     while (PR_SUCCESS == status)
     {
         RCEnter entry(ml);
-        while (twiddle && (PR_SUCCESS == status)) status = Wait();
-		if (verbosity) PR_fprintf(debug_out, "+");
+        while (twiddle && (PR_SUCCESS == status)) {
+            status = Wait();
+        }
+        if (verbosity) {
+            PR_fprintf(debug_out, "+");
+        }
         twiddle = PR_TRUE;
         next->twiddle = PR_FALSE;
         next->Notify();
@@ -83,11 +87,11 @@ static void Help(void)
     debug_out = PR_STDOUT;
 
     PR_fprintf(
-		debug_out, "Usage: >./switch [-d] [-c n] [-t n] [-T n] [-G]\n");
+        debug_out, "Usage: >./switch [-d] [-c n] [-t n] [-T n] [-G]\n");
     PR_fprintf(
-		debug_out, "-c n\tloops at thread level (default: %d)\n", DEFAULT_LOOPS);
+        debug_out, "-c n\tloops at thread level (default: %d)\n", DEFAULT_LOOPS);
     PR_fprintf(
-		debug_out, "-t n\tnumber of threads (default: %d)\n", DEFAULT_THREADS);
+        debug_out, "-t n\tnumber of threads (default: %d)\n", DEFAULT_THREADS);
     PR_fprintf(debug_out, "-d\tturn on debugging output (default: FALSE)\n");
     PR_fprintf(debug_out, "-v\tturn on verbose output (default: FALSE)\n");
     PR_fprintf(debug_out, "-G n\tglobal threads only (default: FALSE)\n");
@@ -96,59 +100,63 @@ static void Help(void)
 
 PRIntn main(PRIntn argc, char **argv)
 {
-	PLOptStatus os;
+    PLOptStatus os;
     PRStatus status;
     PRBool help = PR_FALSE;
     PRUintn concurrency = 1;
     RCThread::Scope thread_scope = RCThread::local;
     PRUintn thread_count, inner_count, loop_count, average;
     PRUintn thread_limit = DEFAULT_THREADS, loop_limit = DEFAULT_LOOPS;
-	PLOptState *opt = PL_CreateOptState(argc, argv, "hdvc:t:C:G");
-	while (PL_OPT_EOL != (os = PL_GetNextOpt(opt)))
+    PLOptState *opt = PL_CreateOptState(argc, argv, "hdvc:t:C:G");
+    while (PL_OPT_EOL != (os = PL_GetNextOpt(opt)))
     {
-		if (PL_OPT_BAD == os) continue;
+        if (PL_OPT_BAD == os) {
+            continue;
+        }
         switch (opt->option)
         {
-        case 'v':  /* verbose mode */
-			verbosity = PR_TRUE;
-        case 'd':  /* debug mode */
-			debug_mode = PR_TRUE;
-            break;
-        case 'c':  /* loop counter */
-			loop_limit = atoi(opt->value);
-            break;
-        case 't':  /* thread limit */
-			thread_limit = atoi(opt->value);
-            break;
-        case 'C':  /* Concurrency limit */
-			concurrency = atoi(opt->value);
-            break;
-        case 'G':  /* global threads only */
-			thread_scope = RCThread::global;
-            break;
-        case 'h':  /* help message */
-			Help();
-			help = PR_TRUE;
-            break;
-         default:
-            break;
+            case 'v':  /* verbose mode */
+                verbosity = PR_TRUE;
+            case 'd':  /* debug mode */
+                debug_mode = PR_TRUE;
+                break;
+            case 'c':  /* loop counter */
+                loop_limit = atoi(opt->value);
+                break;
+            case 't':  /* thread limit */
+                thread_limit = atoi(opt->value);
+                break;
+            case 'C':  /* Concurrency limit */
+                concurrency = atoi(opt->value);
+                break;
+            case 'G':  /* global threads only */
+                thread_scope = RCThread::global;
+                break;
+            case 'h':  /* help message */
+                Help();
+                help = PR_TRUE;
+                break;
+            default:
+                break;
         }
     }
-	PL_DestroyOptState(opt);
-
-    if (help) return -1;
-
-	if (PR_TRUE == debug_mode)
-	{
-		debug_out = PR_STDOUT;
-		PR_fprintf(debug_out, "Test parameters\n");
-		PR_fprintf(debug_out, "\tThreads involved: %d\n", thread_limit);
-		PR_fprintf(debug_out, "\tIteration limit: %d\n", loop_limit);
-		PR_fprintf(debug_out, "\tConcurrency: %d\n", concurrency);
-		PR_fprintf(
-			debug_out, "\tThread type: %s\n",
-			(PR_GLOBAL_THREAD == thread_scope) ? "GLOBAL" : "LOCAL");
-	}
+    PL_DestroyOptState(opt);
+
+    if (help) {
+        return -1;
+    }
+
+    if (PR_TRUE == debug_mode)
+    {
+        debug_out = PR_STDOUT;
+        PR_fprintf(debug_out, "Test parameters\n");
+        PR_fprintf(debug_out, "\tThreads involved: %d\n", thread_limit);
+        PR_fprintf(debug_out, "\tIteration limit: %d\n", loop_limit);
+        PR_fprintf(debug_out, "\tConcurrency: %d\n", concurrency);
+        PR_fprintf(
+            debug_out, "\tThread type: %s\n",
+            (PR_GLOBAL_THREAD == thread_scope) ? "GLOBAL" : "LOCAL");
+    }
 
     /*
     ** The interesting part starts here
@@ -165,62 +173,68 @@ PRIntn main(PRIntn argc, char **argv)
         shared = new Shared(thread_scope, link, &lock);
         shared->Start();  /* make it run */
         link = (Home*)shared;
-	}
+    }
 
     /* Pass the message around the horn a few times */
     for (loop_count = 1; loop_count <= loop_limit; ++loop_count)
     {
-		timein.SetToNow();
-		for (inner_count = 0; inner_count < INNER_LOOPS; ++inner_count)
-		{
-			RCEnter entry(&lock);
-			home.twiddle = PR_TRUE;
-			shared->twiddle = PR_FALSE;
-			shared->Notify();
-			while (home.twiddle)
+        timein.SetToNow();
+        for (inner_count = 0; inner_count < INNER_LOOPS; ++inner_count)
+        {
+            RCEnter entry(&lock);
+            home.twiddle = PR_TRUE;
+            shared->twiddle = PR_FALSE;
+            shared->Notify();
+            while (home.twiddle)
             {
-				failed = (PR_FAILURE == home.Wait()) ? PR_TRUE : PR_FALSE;
+                failed = (PR_FAILURE == home.Wait()) ? PR_TRUE : PR_FALSE;
             }
-		}
-		timeout += (RCInterval(RCInterval::now) - timein);
-	}
+        }
+        timeout += (RCInterval(RCInterval::now) - timein);
+    }
 
     /* Figure out how well we did */
-	if (debug_mode)
-	{
-		average = timeout.ToMicroseconds()
-			/ (INNER_LOOPS * loop_limit * thread_count);
-		PR_fprintf(
-			debug_out, "Average switch times %d usecs for %d threads\n",
+    if (debug_mode)
+    {
+        average = timeout.ToMicroseconds()
+                  / (INNER_LOOPS * loop_limit * thread_count);
+        PR_fprintf(
+            debug_out, "Average switch times %d usecs for %d threads\n",
             average, thread_limit);
-	}
+    }
 
     /* Start reclamation process */
     link = shared;
     for (thread_count = 1; thread_count <= thread_limit; ++thread_count)
     {
-        if (&home == link) break;
+        if (&home == link) {
+            break;
+        }
         status = ((Shared*)link)->Interrupt();
-		if (PR_SUCCESS != status)
+        if (PR_SUCCESS != status)
         {
             failed = PR_TRUE;
-            if (debug_mode)
-			    PL_FPrintError(debug_out, "Failed to interrupt");
+            if (debug_mode) {
+                PL_FPrintError(debug_out, "Failed to interrupt");
+            }
         }
-		link = link->next; 
+        link = link->next;
     }
 
     for (thread_count = 1; thread_count <= thread_limit; ++thread_count)
     {
         link = shared->next;
         status = shared->Join();
-		if (PR_SUCCESS != status)
-		{
+        if (PR_SUCCESS != status)
+        {
             failed = PR_TRUE;
-            if (debug_mode)
-			    PL_FPrintError(debug_out, "Failed to join");
+            if (debug_mode) {
+                PL_FPrintError(debug_out, "Failed to join");
+            }
+        }
+        if (&home == link) {
+            break;
         }
-        if (&home == link) break;
         shared = (Shared*)link;
     }
 
diff --git a/nsprpub/pr/src/cplus/tests/thread.cpp b/nsprpub/pr/src/cplus/tests/thread.cpp
index 442c534d0..ff01402d8 100644
--- a/nsprpub/pr/src/cplus/tests/thread.cpp
+++ b/nsprpub/pr/src/cplus/tests/thread.cpp
@@ -28,7 +28,9 @@ private:
 TestThread::~TestThread() { }
 
 TestThread::TestThread(RCThread::State state, PRIntn count):
-    RCThread(RCThread::global, state, 0) { mydata = count; }
+    RCThread(RCThread::global, state, 0) {
+    mydata = count;
+}
 
 void TestThread::RootFunction()
 {
@@ -46,7 +48,7 @@ public:
     PRIntn data;
 };
 
-Foo1::Foo1() 
+Foo1::Foo1()
 {
     data = 0xafaf;
     thread = new TestThread(RCThread::joinable, 0xafaf);
diff --git a/nsprpub/pr/src/cplus/tests/tpd.cpp b/nsprpub/pr/src/cplus/tests/tpd.cpp
index 42290ab11..2a18c9cb1 100644
--- a/nsprpub/pr/src/cplus/tests/tpd.cpp
+++ b/nsprpub/pr/src/cplus/tests/tpd.cpp
@@ -68,8 +68,9 @@ static void PrintProgress(PRIntn line)
 
 static void MyAssert(const char *expr, const char *file, PRIntn line)
 {
-    if (debug > 0)
+    if (debug > 0) {
         (void)PR_fprintf(fout, "'%s' in file: %s: %d\n", expr, file, line);
+    }
 }  /* MyAssert */
 
 #define MY_ASSERT(_expr) \
@@ -86,14 +87,16 @@ int main(PRIntn argc, char *argv[])
     RCThread *primordial = RCThread::WrapPrimordialThread();
     while (PL_OPT_EOL != (os = PL_GetNextOpt(opt)))
     {
-        if (PL_OPT_BAD == os) continue;
+        if (PL_OPT_BAD == os) {
+            continue;
+        }
         switch (opt->option)
         {
-        case 'd':  /* debug mode */
-            debug = PR_TRUE;
-            break;
-         default:
-            break;
+            case 'd':  /* debug mode */
+                debug = PR_TRUE;
+                break;
+            default:
+                break;
         }
     }
     PL_DestroyOptState(opt);
@@ -103,8 +106,9 @@ int main(PRIntn argc, char *argv[])
     MyPrivateData extension = MyPrivateData("EXTENSION");
     MyPrivateData key_string[] = {
         "Key #0", "Key #1", "Key #2", "Key #3",
-        "Bogus #5", "Bogus #6", "Bogus #7", "Bogus #8"};
-    
+        "Bogus #5", "Bogus #6", "Bogus #7", "Bogus #8"
+    };
+
 
     did = should = PR_FALSE;
     for (keys = 0; keys < 4; ++keys)
@@ -133,7 +137,7 @@ int main(PRIntn argc, char *argv[])
     }
     PrintProgress(__LINE__);
 
-    /* re-assign the private data, albeit the same content */    
+    /* re-assign the private data, albeit the same content */
     did = PR_FALSE; should = PR_TRUE;
     for (keys = 0; keys < 4; ++keys)
     {
@@ -190,13 +194,21 @@ int main(PRIntn argc, char *argv[])
         MY_ASSERT(PR_SUCCESS == rv);
     }
 
-    if (debug) PR_fprintf(fout, "Creating thread\n");
+    if (debug) {
+        PR_fprintf(fout, "Creating thread\n");
+    }
     thread = new MyThread();
-    if (debug) PR_fprintf(fout, "Starting thread\n");
+    if (debug) {
+        PR_fprintf(fout, "Starting thread\n");
+    }
     thread->Start();
-    if (debug) PR_fprintf(fout, "Joining thread\n");
+    if (debug) {
+        PR_fprintf(fout, "Joining thread\n");
+    }
     (void)thread->Join();
-    if (debug) PR_fprintf(fout, "Joined thread\n");
+    if (debug) {
+        PR_fprintf(fout, "Joined thread\n");
+    }
 
     failed |= (PR_FAILURE == RCPrimordialThread::Cleanup());
 
@@ -237,8 +249,12 @@ MyPrivateData::MyPrivateData(const MyPrivateData& him): RCThreadPrivateData(him)
 
 void MyPrivateData::Release()
 {
-    if (should) did = PR_TRUE;
-    else failed = PR_TRUE;
+    if (should) {
+        did = PR_TRUE;
+    }
+    else {
+        failed = PR_TRUE;
+    }
 }  /* MyPrivateData::operator= */
 
 /*
@@ -253,12 +269,13 @@ void MyThread::RootFunction()
     PRStatus rv;
     PRUintn keys;
     const RCThreadPrivateData *pd;
-    
+
     MyPrivateData extension = MyPrivateData("EXTENSION");
     MyPrivateData key_string[] = {
         "Key #0", "Key #1", "Key #2", "Key #3",
-        "Bogus #5", "Bogus #6", "Bogus #7", "Bogus #8"};
-    
+        "Bogus #5", "Bogus #6", "Bogus #7", "Bogus #8"
+    };
+
     did = should = PR_FALSE;
     for (keys = 0; keys < 8; ++keys)
     {
@@ -284,7 +301,7 @@ void MyThread::RootFunction()
     }
     PrintProgress(__LINE__);
 #endif
-    
+
     did = PR_FALSE; should = PR_TRUE;
     for (keys = 0; keys < 4; ++keys)
     {