1 files changed, 106 insertions, 95 deletions

diff --git a/nsprpub/pr/src/threads/combined/prulock.c b/nsprpub/pr/src/threads/combined/prulock.c
index 8b2f41eec4..69c27d149f 100644
--- a/nsprpub/pr/src/threads/combined/prulock.c
+++ b/nsprpub/pr/src/threads/combined/prulock.c
@@ -7,10 +7,10 @@
 
 #if defined(WIN95)
 /*
-** Some local variables report warnings on Win95 because the code paths 
+** Some local variables report warnings on Win95 because the code paths
 ** using them are conditioned on HAVE_CUSTOME_USER_THREADS.
 ** The pragma suppresses the warning.
-** 
+**
 */
 #pragma warning(disable : 4101)
 #endif
@@ -18,7 +18,7 @@
 
 void _PR_InitLocks(void)
 {
-	_PR_MD_INIT_LOCKS();
+    _PR_MD_INIT_LOCKS();
 }
 
 /*
@@ -33,7 +33,7 @@ void _PR_IntsOn(_PRCPU *cpu)
 
     PR_ASSERT(cpu);   /* Global threads don't have CPUs */
     PR_ASSERT(_PR_MD_GET_INTSOFF() > 0);
-	me = _PR_MD_CURRENT_THREAD();
+    me = _PR_MD_CURRENT_THREAD();
     PR_ASSERT(!(me->flags & _PR_IDLE_THREAD));
 
     /*
@@ -69,15 +69,15 @@ void _PR_IntsOn(_PRCPU *cpu)
     if (cpu->u.missed[3] != 0) {
         _PRCPU *cpu;
 
-		_PR_THREAD_LOCK(me);
+        _PR_THREAD_LOCK(me);
         me->state = _PR_RUNNABLE;
         pri = me->priority;
 
         cpu = me->cpu;
-		_PR_RUNQ_LOCK(cpu);
+        _PR_RUNQ_LOCK(cpu);
         _PR_ADD_RUNQ(me, cpu, pri);
-		_PR_RUNQ_UNLOCK(cpu);
-		_PR_THREAD_UNLOCK(me);
+        _PR_RUNQ_UNLOCK(cpu);
+        _PR_THREAD_UNLOCK(me);
         _PR_MD_SWITCH_CONTEXT(me);
     }
 }
@@ -99,11 +99,11 @@ void _PR_UnblockLockWaiter(PRLock *lock)
         /* Unblock first waiter */
         t = _PR_THREAD_CONDQ_PTR(q);
 
-		/* 
-		** We are about to change the thread's state to runnable and for local
-		** threads, we are going to assign a cpu to it.  So, protect thread's
-		** data structure.
-		*/
+        /*
+        ** We are about to change the thread's state to runnable and for local
+        ** threads, we are going to assign a cpu to it.  So, protect thread's
+        ** data structure.
+        */
         _PR_THREAD_LOCK(t);
 
         if (t->flags & _PR_SUSPENDING) {
@@ -113,24 +113,24 @@ void _PR_UnblockLockWaiter(PRLock *lock)
         }
 
         /* Found a runnable thread */
-	    PR_ASSERT(t->state == _PR_LOCK_WAIT);
-	    PR_ASSERT(t->wait.lock == lock);
+        PR_ASSERT(t->state == _PR_LOCK_WAIT);
+        PR_ASSERT(t->wait.lock == lock);
         t->wait.lock = 0;
         PR_REMOVE_LINK(&t->waitQLinks);         /* take it off lock's waitQ */
 
-		/*
-		** If this is a native thread, nothing else to do except to wake it
-		** up by calling the machine dependent wakeup routine.
-		**
-		** If this is a local thread, we need to assign it a cpu and
-		** put the thread on that cpu's run queue.  There are two cases to
-		** take care of.  If the currently running thread is also a local
-		** thread, we just assign our own cpu to that thread and put it on
-		** the cpu's run queue.  If the the currently running thread is a
-		** native thread, we assign the primordial cpu to it (on NT,
-		** MD_WAKEUP handles the cpu assignment).  
-		*/
-		
+        /*
+        ** If this is a native thread, nothing else to do except to wake it
+        ** up by calling the machine dependent wakeup routine.
+        **
+        ** If this is a local thread, we need to assign it a cpu and
+        ** put the thread on that cpu's run queue.  There are two cases to
+        ** take care of.  If the currently running thread is also a local
+        ** thread, we just assign our own cpu to that thread and put it on
+        ** the cpu's run queue.  If the the currently running thread is a
+        ** native thread, we assign the primordial cpu to it (on NT,
+        ** MD_WAKEUP handles the cpu assignment).
+        */
+
         if ( !_PR_IS_NATIVE_THREAD(t) ) {
 
             t->state = _PR_RUNNABLE;
@@ -156,7 +156,9 @@ PR_IMPLEMENT(PRLock*) PR_NewLock(void)
 {
     PRLock *lock;
 
-    if (!_pr_initialized) _PR_ImplicitInitialization();
+    if (!_pr_initialized) {
+        _PR_ImplicitInitialization();
+    }
 
     lock = PR_NEWZAP(PRLock);
     if (lock) {
@@ -206,25 +208,26 @@ PR_IMPLEMENT(void) PR_Lock(PRLock *lock)
     PRThread *t;
     PRCList *q;
 
-    PR_ASSERT(me != suspendAllThread); 
+    PR_ASSERT(me != suspendAllThread);
     PR_ASSERT(!(me->flags & _PR_IDLE_THREAD));
     PR_ASSERT(lock != NULL);
-#ifdef _PR_GLOBAL_THREADS_ONLY 
+#ifdef _PR_GLOBAL_THREADS_ONLY
     _PR_MD_LOCK(&lock->ilock);
     PR_ASSERT(lock->owner == 0);
     lock->owner = me;
     return;
 #else  /* _PR_GLOBAL_THREADS_ONLY */
 
-	if (_native_threads_only) {
-		_PR_MD_LOCK(&lock->ilock);
-		PR_ASSERT(lock->owner == 0);
-		lock->owner = me;
-		return;
-	}
+    if (_native_threads_only) {
+        _PR_MD_LOCK(&lock->ilock);
+        PR_ASSERT(lock->owner == 0);
+        lock->owner = me;
+        return;
+    }
 
-    if (!_PR_IS_NATIVE_THREAD(me))
-    	_PR_INTSOFF(is);
+    if (!_PR_IS_NATIVE_THREAD(me)) {
+        _PR_INTSOFF(is);
+    }
 
     PR_ASSERT(_PR_IS_NATIVE_THREAD(me) || _PR_MD_GET_INTSOFF() != 0);
 
@@ -234,11 +237,12 @@ retry:
         /* Just got the lock */
         lock->owner = me;
         lock->priority = me->priority;
-		/* Add the granted lock to this owning thread's lock list */
+        /* Add the granted lock to this owning thread's lock list */
         PR_APPEND_LINK(&lock->links, &me->lockList);
         _PR_LOCK_UNLOCK(lock);
-    	if (!_PR_IS_NATIVE_THREAD(me))
-        	_PR_FAST_INTSON(is);
+        if (!_PR_IS_NATIVE_THREAD(me)) {
+            _PR_FAST_INTSON(is);
+        }
         return;
     }
 
@@ -258,39 +262,39 @@ retry:
     }
 #endif
 
-    /* 
+    /*
     Add this thread to the asked for lock's list of waiting threads.  We
     add this thread thread in the right priority order so when the unlock
     occurs, the thread with the higher priority will get the lock.
     */
     q = lock->waitQ.next;
     if (q == &lock->waitQ || _PR_THREAD_CONDQ_PTR(q)->priority ==
-      	_PR_THREAD_CONDQ_PTR(lock->waitQ.prev)->priority) {
-		/*
-		 * If all the threads in the lock waitQ have the same priority,
-		 * then avoid scanning the list:  insert the element at the end.
-		 */
-		q = &lock->waitQ;
+        _PR_THREAD_CONDQ_PTR(lock->waitQ.prev)->priority) {
+        /*
+         * If all the threads in the lock waitQ have the same priority,
+         * then avoid scanning the list:  insert the element at the end.
+         */
+        q = &lock->waitQ;
     } else {
-		/* Sort thread into lock's waitQ at appropriate point */
-		/* Now scan the list for where to insert this entry */
-		while (q != &lock->waitQ) {
-			t = _PR_THREAD_CONDQ_PTR(lock->waitQ.next);
-			if (me->priority > t->priority) {
-				/* Found a lower priority thread to insert in front of */
-				break;
-			}
-			q = q->next;
-		}
-	}
+        /* Sort thread into lock's waitQ at appropriate point */
+        /* Now scan the list for where to insert this entry */
+        while (q != &lock->waitQ) {
+            t = _PR_THREAD_CONDQ_PTR(lock->waitQ.next);
+            if (me->priority > t->priority) {
+                /* Found a lower priority thread to insert in front of */
+                break;
+            }
+            q = q->next;
+        }
+    }
     PR_INSERT_BEFORE(&me->waitQLinks, q);
 
-	/* 
-	Now grab the threadLock since we are about to change the state.  We have
-	to do this since a PR_Suspend or PR_SetThreadPriority type call that takes
-	a PRThread* as an argument could be changing the state of this thread from
-	a thread running on a different cpu.
-	*/
+    /*
+    Now grab the threadLock since we are about to change the state.  We have
+    to do this since a PR_Suspend or PR_SetThreadPriority type call that takes
+    a PRThread* as an argument could be changing the state of this thread from
+    a thread running on a different cpu.
+    */
 
     _PR_THREAD_LOCK(me);
     me->state = _PR_LOCK_WAIT;
@@ -300,7 +304,7 @@ retry:
     _PR_LOCK_UNLOCK(lock);
 
     _PR_MD_WAIT(me, PR_INTERVAL_NO_TIMEOUT);
-	goto retry;
+    goto retry;
 
 #endif  /* _PR_GLOBAL_THREADS_ONLY */
 }
@@ -317,29 +321,30 @@ PR_IMPLEMENT(PRStatus) PR_Unlock(PRLock *lock)
 
     PR_ASSERT(lock != NULL);
     PR_ASSERT(lock->owner == me);
-    PR_ASSERT(me != suspendAllThread); 
+    PR_ASSERT(me != suspendAllThread);
     PR_ASSERT(!(me->flags & _PR_IDLE_THREAD));
     if (lock->owner != me) {
         return PR_FAILURE;
     }
 
-#ifdef _PR_GLOBAL_THREADS_ONLY 
+#ifdef _PR_GLOBAL_THREADS_ONLY
     lock->owner = 0;
     _PR_MD_UNLOCK(&lock->ilock);
     return PR_SUCCESS;
 #else  /* _PR_GLOBAL_THREADS_ONLY */
 
-	if (_native_threads_only) {
-		lock->owner = 0;
-		_PR_MD_UNLOCK(&lock->ilock);
-		return PR_SUCCESS;
-	}
+    if (_native_threads_only) {
+        lock->owner = 0;
+        _PR_MD_UNLOCK(&lock->ilock);
+        return PR_SUCCESS;
+    }
 
-    if (!_PR_IS_NATIVE_THREAD(me))
-    	_PR_INTSOFF(is);
+    if (!_PR_IS_NATIVE_THREAD(me)) {
+        _PR_INTSOFF(is);
+    }
     _PR_LOCK_LOCK(lock);
 
-	/* Remove the lock from the owning thread's lock list */
+    /* Remove the lock from the owning thread's lock list */
     PR_REMOVE_LINK(&lock->links);
     pri = lock->priority;
     boost = lock->boostPriority;
@@ -365,13 +370,15 @@ PR_IMPLEMENT(PRStatus) PR_Unlock(PRLock *lock)
 
     /* Unblock the first waiting thread */
     q = lock->waitQ.next;
-    if (q != &lock->waitQ)
+    if (q != &lock->waitQ) {
         _PR_UnblockLockWaiter(lock);
+    }
     lock->boostPriority = PR_PRIORITY_LOW;
     lock->owner = 0;
     _PR_LOCK_UNLOCK(lock);
-    if (!_PR_IS_NATIVE_THREAD(me))
-    	_PR_INTSON(is);
+    if (!_PR_IS_NATIVE_THREAD(me)) {
+        _PR_INTSON(is);
+    }
     return PR_SUCCESS;
 #endif  /* _PR_GLOBAL_THREADS_ONLY */
 }
@@ -397,7 +404,7 @@ PR_IMPLEMENT(PRBool) PR_TestAndLock(PRLock *lock)
     PRBool rv = PR_FALSE;
     PRIntn is;
 
-#ifdef _PR_GLOBAL_THREADS_ONLY 
+#ifdef _PR_GLOBAL_THREADS_ONLY
     is = _PR_MD_TEST_AND_LOCK(&lock->ilock);
     if (is == 0) {
         lock->owner = me;
@@ -407,32 +414,34 @@ PR_IMPLEMENT(PRBool) PR_TestAndLock(PRLock *lock)
 #else  /* _PR_GLOBAL_THREADS_ONLY */
 
 #ifndef _PR_LOCAL_THREADS_ONLY
-	if (_native_threads_only) {
-		is = _PR_MD_TEST_AND_LOCK(&lock->ilock);
-		if (is == 0) {
-			lock->owner = me;
-			return PR_TRUE;
-		}
-    	return PR_FALSE;
-	}
+    if (_native_threads_only) {
+        is = _PR_MD_TEST_AND_LOCK(&lock->ilock);
+        if (is == 0) {
+            lock->owner = me;
+            return PR_TRUE;
+        }
+        return PR_FALSE;
+    }
 #endif
 
-    if (!_PR_IS_NATIVE_THREAD(me))
-    	_PR_INTSOFF(is);
+    if (!_PR_IS_NATIVE_THREAD(me)) {
+        _PR_INTSOFF(is);
+    }
 
     _PR_LOCK_LOCK(lock);
     if (lock->owner == 0) {
         /* Just got the lock */
         lock->owner = me;
         lock->priority = me->priority;
-		/* Add the granted lock to this owning thread's lock list */
+        /* Add the granted lock to this owning thread's lock list */
         PR_APPEND_LINK(&lock->links, &me->lockList);
         rv = PR_TRUE;
     }
     _PR_LOCK_UNLOCK(lock);
 
-    if (!_PR_IS_NATIVE_THREAD(me))
-    	_PR_INTSON(is);
+    if (!_PR_IS_NATIVE_THREAD(me)) {
+        _PR_INTSON(is);
+    }
     return rv;
 #endif  /* _PR_GLOBAL_THREADS_ONLY */
 }
@@ -443,4 +452,6 @@ PR_IMPLEMENT(PRBool) PR_TestAndLock(PRLock *lock)
 /************************************************************************/
 /************************************************************************/
 PR_IMPLEMENT(PRStatus) PRP_TryLock(PRLock *lock)
-    { return (PR_TestAndLock(lock)) ? PR_SUCCESS : PR_FAILURE; }
+{
+    return (PR_TestAndLock(lock)) ? PR_SUCCESS : PR_FAILURE;
+}