--- a/src/thread/nds/SDL_sysmutex.c	Tue Jun 10 06:57:57 2008 +0000
+++ b/src/thread/nds/SDL_sysmutex.c	Thu Jun 12 02:38:49 2008 +0000
@@ -22,7 +22,7 @@
 
 #ifdef SAVE_RCSID
 static char rcsid =
- "@(#) $Id: SDL_sysmutex.c,v 1.2 2001/04/26 16:50:18 hercules Exp $";
+    "@(#) $Id: SDL_sysmutex.c,v 1.2 2001/04/26 16:50:18 hercules Exp $";
 #endif
 
 /* An implementation of mutexes using semaphores */
@@ -35,103 +35,108 @@
 #include "SDL_systhread_c.h"
 
 
-struct SDL_mutex {
-	int recursive;
-	Uint32 owner;
-	SDL_sem *sem;
+struct SDL_mutex
+{
+    int recursive;
+    Uint32 owner;
+    SDL_sem *sem;
 };
 
 /* Create a mutex */
-SDL_mutex *SDL_CreateMutex(void)
+SDL_mutex *
+SDL_CreateMutex(void)
 {
-	SDL_mutex *mutex;
+    SDL_mutex *mutex;
 
-	/* Allocate mutex memory */
-	mutex = (SDL_mutex *)malloc(sizeof(*mutex));
-	if ( mutex ) {
-		/* Create the mutex semaphore, with initial value 1 */
-		mutex->sem = SDL_CreateSemaphore(1);
-		mutex->recursive = 0;
-		mutex->owner = 0;
-		if ( ! mutex->sem ) {
-			free(mutex);
-			mutex = NULL;
-		}
-	} else {
-		SDL_OutOfMemory();
-	}
-	return mutex;
+    /* Allocate mutex memory */
+    mutex = (SDL_mutex *) malloc(sizeof(*mutex));
+    if (mutex) {
+        /* Create the mutex semaphore, with initial value 1 */
+        mutex->sem = SDL_CreateSemaphore(1);
+        mutex->recursive = 0;
+        mutex->owner = 0;
+        if (!mutex->sem) {
+            free(mutex);
+            mutex = NULL;
+        }
+    } else {
+        SDL_OutOfMemory();
+    }
+    return mutex;
 }
 
 /* Free the mutex */
-void SDL_DestroyMutex(SDL_mutex *mutex)
+void
+SDL_DestroyMutex(SDL_mutex * mutex)
 {
-	if ( mutex ) {
-		if ( mutex->sem ) {
-			SDL_DestroySemaphore(mutex->sem);
-		}
-		free(mutex);
-	}
+    if (mutex) {
+        if (mutex->sem) {
+            SDL_DestroySemaphore(mutex->sem);
+        }
+        free(mutex);
+    }
 }
 
 /* Lock the semaphore */
-int SDL_mutexP(SDL_mutex *mutex)
+int
+SDL_mutexP(SDL_mutex * mutex)
 {
 #ifdef DISABLE_THREADS
-	return 0;
+    return 0;
 #else
-	Uint32 this_thread;
+    Uint32 this_thread;
 
-	if ( mutex == NULL ) {
-		SDL_SetError("Passed a NULL mutex");
-		return -1;
-	}
+    if (mutex == NULL) {
+        SDL_SetError("Passed a NULL mutex");
+        return -1;
+    }
 
-	this_thread = SDL_ThreadID();
-	if ( mutex->owner == this_thread ) {
-		++mutex->recursive;
-	} else {
-		/* The order of operations is important.
-		   We set the locking thread id after we obtain the lock
-		   so unlocks from other threads will fail.
-		*/
-		SDL_SemWait(mutex->sem);
-		mutex->owner = this_thread;
-		mutex->recursive = 0;
-	}
+    this_thread = SDL_ThreadID();
+    if (mutex->owner == this_thread) {
+        ++mutex->recursive;
+    } else {
+        /* The order of operations is important.
+           We set the locking thread id after we obtain the lock
+           so unlocks from other threads will fail.
+         */
+        SDL_SemWait(mutex->sem);
+        mutex->owner = this_thread;
+        mutex->recursive = 0;
+    }
 
-	return 0;
+    return 0;
 #endif /* DISABLE_THREADS */
 }
 
 /* Unlock the mutex */
-int SDL_mutexV(SDL_mutex *mutex)
+int
+SDL_mutexV(SDL_mutex * mutex)
 {
 #ifdef DISABLE_THREADS
-	return 0;
+    return 0;
 #else
-	if ( mutex == NULL ) {
-		SDL_SetError("Passed a NULL mutex");
-		return -1;
-	}
+    if (mutex == NULL) {
+        SDL_SetError("Passed a NULL mutex");
+        return -1;
+    }
 
-	/* If we don't own the mutex, we can't unlock it */
-	if ( SDL_ThreadID() != mutex->owner ) {
-		SDL_SetError("mutex not owned by this thread");
-		return -1;
-	}
+    /* If we don't own the mutex, we can't unlock it */
+    if (SDL_ThreadID() != mutex->owner) {
+        SDL_SetError("mutex not owned by this thread");
+        return -1;
+    }
 
-	if ( mutex->recursive ) {
-		--mutex->recursive;
-	} else {
-		/* The order of operations is important.
-		   First reset the owner so another thread doesn't lock
-		   the mutex and set the ownership before we reset it,
-		   then release the lock semaphore.
-		 */
-		mutex->owner = 0;
-		SDL_SemPost(mutex->sem);
-	}
-	return 0;
+    if (mutex->recursive) {
+        --mutex->recursive;
+    } else {
+        /* The order of operations is important.
+           First reset the owner so another thread doesn't lock
+           the mutex and set the ownership before we reset it,
+           then release the lock semaphore.
+         */
+        mutex->owner = 0;
+        SDL_SemPost(mutex->sem);
+    }
+    return 0;
 #endif /* DISABLE_THREADS */
 }