--- a/src/thread/generic/SDL_syscond.c	Mon May 29 03:53:21 2006 +0000
+++ b/src/thread/generic/SDL_syscond.c	Mon May 29 04:04:35 2006 +0000
@@ -40,64 +40,64 @@
 
 /* Create a condition variable */
 SDL_cond *
-SDL_CreateCond (void)
+SDL_CreateCond(void)
 {
     SDL_cond *cond;
 
-    cond = (SDL_cond *) SDL_malloc (sizeof (SDL_cond));
+    cond = (SDL_cond *) SDL_malloc(sizeof(SDL_cond));
     if (cond) {
-        cond->lock = SDL_CreateMutex ();
-        cond->wait_sem = SDL_CreateSemaphore (0);
-        cond->wait_done = SDL_CreateSemaphore (0);
+        cond->lock = SDL_CreateMutex();
+        cond->wait_sem = SDL_CreateSemaphore(0);
+        cond->wait_done = SDL_CreateSemaphore(0);
         cond->waiting = cond->signals = 0;
         if (!cond->lock || !cond->wait_sem || !cond->wait_done) {
-            SDL_DestroyCond (cond);
+            SDL_DestroyCond(cond);
             cond = NULL;
         }
     } else {
-        SDL_OutOfMemory ();
+        SDL_OutOfMemory();
     }
     return (cond);
 }
 
 /* Destroy a condition variable */
 void
-SDL_DestroyCond (SDL_cond * cond)
+SDL_DestroyCond(SDL_cond * cond)
 {
     if (cond) {
         if (cond->wait_sem) {
-            SDL_DestroySemaphore (cond->wait_sem);
+            SDL_DestroySemaphore(cond->wait_sem);
         }
         if (cond->wait_done) {
-            SDL_DestroySemaphore (cond->wait_done);
+            SDL_DestroySemaphore(cond->wait_done);
         }
         if (cond->lock) {
-            SDL_DestroyMutex (cond->lock);
+            SDL_DestroyMutex(cond->lock);
         }
-        SDL_free (cond);
+        SDL_free(cond);
     }
 }
 
 /* Restart one of the threads that are waiting on the condition variable */
 int
-SDL_CondSignal (SDL_cond * cond)
+SDL_CondSignal(SDL_cond * cond)
 {
     if (!cond) {
-        SDL_SetError ("Passed a NULL condition variable");
+        SDL_SetError("Passed a NULL condition variable");
         return -1;
     }
 
     /* If there are waiting threads not already signalled, then
        signal the condition and wait for the thread to respond.
      */
-    SDL_LockMutex (cond->lock);
+    SDL_LockMutex(cond->lock);
     if (cond->waiting > cond->signals) {
         ++cond->signals;
-        SDL_SemPost (cond->wait_sem);
-        SDL_UnlockMutex (cond->lock);
-        SDL_SemWait (cond->wait_done);
+        SDL_SemPost(cond->wait_sem);
+        SDL_UnlockMutex(cond->lock);
+        SDL_SemWait(cond->wait_done);
     } else {
-        SDL_UnlockMutex (cond->lock);
+        SDL_UnlockMutex(cond->lock);
     }
 
     return 0;
@@ -105,34 +105,34 @@
 
 /* Restart all threads that are waiting on the condition variable */
 int
-SDL_CondBroadcast (SDL_cond * cond)
+SDL_CondBroadcast(SDL_cond * cond)
 {
     if (!cond) {
-        SDL_SetError ("Passed a NULL condition variable");
+        SDL_SetError("Passed a NULL condition variable");
         return -1;
     }
 
     /* If there are waiting threads not already signalled, then
        signal the condition and wait for the thread to respond.
      */
-    SDL_LockMutex (cond->lock);
+    SDL_LockMutex(cond->lock);
     if (cond->waiting > cond->signals) {
         int i, num_waiting;
 
         num_waiting = (cond->waiting - cond->signals);
         cond->signals = cond->waiting;
         for (i = 0; i < num_waiting; ++i) {
-            SDL_SemPost (cond->wait_sem);
+            SDL_SemPost(cond->wait_sem);
         }
         /* Now all released threads are blocked here, waiting for us.
            Collect them all (and win fabulous prizes!) :-)
          */
-        SDL_UnlockMutex (cond->lock);
+        SDL_UnlockMutex(cond->lock);
         for (i = 0; i < num_waiting; ++i) {
-            SDL_SemWait (cond->wait_done);
+            SDL_SemWait(cond->wait_done);
         }
     } else {
-        SDL_UnlockMutex (cond->lock);
+        SDL_UnlockMutex(cond->lock);
     }
 
     return 0;
@@ -159,12 +159,12 @@
 	SDL_UnlockMutex(lock);
  */
 int
-SDL_CondWaitTimeout (SDL_cond * cond, SDL_mutex * mutex, Uint32 ms)
+SDL_CondWaitTimeout(SDL_cond * cond, SDL_mutex * mutex, Uint32 ms)
 {
     int retval;
 
     if (!cond) {
-        SDL_SetError ("Passed a NULL condition variable");
+        SDL_SetError("Passed a NULL condition variable");
         return -1;
     }
 
@@ -172,18 +172,18 @@
        This allows the signal mechanism to only perform a signal if there
        are waiting threads.
      */
-    SDL_LockMutex (cond->lock);
+    SDL_LockMutex(cond->lock);
     ++cond->waiting;
-    SDL_UnlockMutex (cond->lock);
+    SDL_UnlockMutex(cond->lock);
 
     /* Unlock the mutex, as is required by condition variable semantics */
-    SDL_UnlockMutex (mutex);
+    SDL_UnlockMutex(mutex);
 
     /* Wait for a signal */
     if (ms == SDL_MUTEX_MAXWAIT) {
-        retval = SDL_SemWait (cond->wait_sem);
+        retval = SDL_SemWait(cond->wait_sem);
     } else {
-        retval = SDL_SemWaitTimeout (cond->wait_sem, ms);
+        retval = SDL_SemWaitTimeout(cond->wait_sem, ms);
     }
 
     /* Let the signaler know we have completed the wait, otherwise
@@ -192,32 +192,32 @@
        giving a deadlock.  See the following URL for details:
        http://www-classic.be.com/aboutbe/benewsletter/volume_III/Issue40.html
      */
-    SDL_LockMutex (cond->lock);
+    SDL_LockMutex(cond->lock);
     if (cond->signals > 0) {
         /* If we timed out, we need to eat a condition signal */
         if (retval > 0) {
-            SDL_SemWait (cond->wait_sem);
+            SDL_SemWait(cond->wait_sem);
         }
         /* We always notify the signal thread that we are done */
-        SDL_SemPost (cond->wait_done);
+        SDL_SemPost(cond->wait_done);
 
         /* Signal handshake complete */
         --cond->signals;
     }
     --cond->waiting;
-    SDL_UnlockMutex (cond->lock);
+    SDL_UnlockMutex(cond->lock);
 
     /* Lock the mutex, as is required by condition variable semantics */
-    SDL_LockMutex (mutex);
+    SDL_LockMutex(mutex);
 
     return retval;
 }
 
 /* Wait on the condition variable forever */
 int
-SDL_CondWait (SDL_cond * cond, SDL_mutex * mutex)
+SDL_CondWait(SDL_cond * cond, SDL_mutex * mutex)
 {
-    return SDL_CondWaitTimeout (cond, mutex, SDL_MUTEX_MAXWAIT);
+    return SDL_CondWaitTimeout(cond, mutex, SDL_MUTEX_MAXWAIT);
 }
 
 /* vi: set ts=4 sw=4 expandtab: */