src/thread/SDL_thread.c
changeset 1895 c121d94672cb
parent 1769 290b5baf2fca
child 2779 4436464c4f51
--- a/src/thread/SDL_thread.c	Thu Jul 06 18:01:37 2006 +0000
+++ b/src/thread/SDL_thread.c	Mon Jul 10 21:04:37 2006 +0000
@@ -38,16 +38,17 @@
 static SDL_Thread **SDL_Threads = NULL;
 static SDL_mutex *thread_lock = NULL;
 
-int SDL_ThreadsInit(void)
+int
+SDL_ThreadsInit(void)
 {
-	int retval;
+    int retval;
 
-	retval = 0;
-	thread_lock = SDL_CreateMutex();
-	if ( thread_lock == NULL ) {
-		retval = -1;
-	}
-	return(retval);
+    retval = 0;
+    thread_lock = SDL_CreateMutex();
+    if (thread_lock == NULL) {
+        retval = -1;
+    }
+    return (retval);
 }
 
 /* This should never be called...
@@ -55,244 +56,260 @@
    clean up threads here.  If any threads are still running after this call,
    they will no longer have access to any per-thread data.
  */
-void SDL_ThreadsQuit(void)
+void
+SDL_ThreadsQuit(void)
 {
-	SDL_mutex *mutex;
+    SDL_mutex *mutex;
 
-	mutex = thread_lock;
-	thread_lock = NULL;
-	if ( mutex != NULL ) {
-		SDL_DestroyMutex(mutex);
-	}
+    mutex = thread_lock;
+    thread_lock = NULL;
+    if (mutex != NULL) {
+        SDL_DestroyMutex(mutex);
+    }
 }
 
 /* Routines for manipulating the thread list */
-static void SDL_AddThread(SDL_Thread *thread)
+static void
+SDL_AddThread(SDL_Thread * thread)
 {
-	/* WARNING:
-	   If the very first threads are created simultaneously, then
-	   there could be a race condition causing memory corruption.
-	   In practice, this isn't a problem because by definition there
-	   is only one thread running the first time this is called.
-	*/
-	if ( !thread_lock ) {
-		if ( SDL_ThreadsInit() < 0 ) {
-			return;
-		}
-	}
-	SDL_mutexP(thread_lock);
+    /* WARNING:
+       If the very first threads are created simultaneously, then
+       there could be a race condition causing memory corruption.
+       In practice, this isn't a problem because by definition there
+       is only one thread running the first time this is called.
+     */
+    if (!thread_lock) {
+        if (SDL_ThreadsInit() < 0) {
+            return;
+        }
+    }
+    SDL_mutexP(thread_lock);
 
-	/* Expand the list of threads, if necessary */
+    /* Expand the list of threads, if necessary */
 #ifdef DEBUG_THREADS
-	printf("Adding thread (%d already - %d max)\n",
-			SDL_numthreads, SDL_maxthreads);
+    printf("Adding thread (%d already - %d max)\n",
+           SDL_numthreads, SDL_maxthreads);
 #endif
-	if ( SDL_numthreads == SDL_maxthreads ) {
-		SDL_Thread **threads;
-		threads = (SDL_Thread **)SDL_realloc(SDL_Threads,
-			(SDL_maxthreads+ARRAY_CHUNKSIZE)*(sizeof *threads));
-		if ( threads == NULL ) {
-			SDL_OutOfMemory();
-			goto done;
-		}
-		SDL_maxthreads += ARRAY_CHUNKSIZE;
-		SDL_Threads = threads;
-	}
-	SDL_Threads[SDL_numthreads++] = thread;
-done:
-	SDL_mutexV(thread_lock);
+    if (SDL_numthreads == SDL_maxthreads) {
+        SDL_Thread **threads;
+        threads = (SDL_Thread **) SDL_realloc(SDL_Threads,
+                                              (SDL_maxthreads +
+                                               ARRAY_CHUNKSIZE) *
+                                              (sizeof *threads));
+        if (threads == NULL) {
+            SDL_OutOfMemory();
+            goto done;
+        }
+        SDL_maxthreads += ARRAY_CHUNKSIZE;
+        SDL_Threads = threads;
+    }
+    SDL_Threads[SDL_numthreads++] = thread;
+  done:
+    SDL_mutexV(thread_lock);
 }
 
-static void SDL_DelThread(SDL_Thread *thread)
+static void
+SDL_DelThread(SDL_Thread * thread)
 {
-	int i;
+    int i;
 
-	if ( !thread_lock ) {
-		return;
-	}
-	SDL_mutexP(thread_lock);
-	for ( i=0; i<SDL_numthreads; ++i ) {
-		if ( thread == SDL_Threads[i] ) {
-			break;
-		}
-	}
-	if ( i < SDL_numthreads ) {
-		if ( --SDL_numthreads > 0 ) {
-			while ( i < SDL_numthreads ) {
-				SDL_Threads[i] = SDL_Threads[i+1];
-				++i;
-			}
-		} else {
-			SDL_maxthreads = 0;
-			SDL_free(SDL_Threads);
-			SDL_Threads = NULL;
-		}
+    if (!thread_lock) {
+        return;
+    }
+    SDL_mutexP(thread_lock);
+    for (i = 0; i < SDL_numthreads; ++i) {
+        if (thread == SDL_Threads[i]) {
+            break;
+        }
+    }
+    if (i < SDL_numthreads) {
+        if (--SDL_numthreads > 0) {
+            while (i < SDL_numthreads) {
+                SDL_Threads[i] = SDL_Threads[i + 1];
+                ++i;
+            }
+        } else {
+            SDL_maxthreads = 0;
+            SDL_free(SDL_Threads);
+            SDL_Threads = NULL;
+        }
 #ifdef DEBUG_THREADS
-		printf("Deleting thread (%d left - %d max)\n",
-				SDL_numthreads, SDL_maxthreads);
+        printf("Deleting thread (%d left - %d max)\n",
+               SDL_numthreads, SDL_maxthreads);
 #endif
-	}
-	SDL_mutexV(thread_lock);
+    }
+    SDL_mutexV(thread_lock);
 
-	if ( SDL_Threads == NULL ) {
-		SDL_ThreadsQuit();
-	}
+    if (SDL_Threads == NULL) {
+        SDL_ThreadsQuit();
+    }
 }
 
 /* The default (non-thread-safe) global error variable */
 static SDL_error SDL_global_error;
 
 /* Routine to get the thread-specific error variable */
-SDL_error *SDL_GetErrBuf(void)
+SDL_error *
+SDL_GetErrBuf(void)
 {
-	SDL_error *errbuf;
+    SDL_error *errbuf;
 
-	errbuf = &SDL_global_error;
-	if ( SDL_Threads ) {
-		int i;
-		Uint32 this_thread;
+    errbuf = &SDL_global_error;
+    if (SDL_Threads) {
+        int i;
+        Uint32 this_thread;
 
-		this_thread = SDL_ThreadID();
-		SDL_mutexP(thread_lock);
-		for ( i=0; i<SDL_numthreads; ++i ) {
-			if ( this_thread == SDL_Threads[i]->threadid ) {
-				errbuf = &SDL_Threads[i]->errbuf;
-				break;
-			}
-		}
-		SDL_mutexV(thread_lock);
-	}
-	return(errbuf);
+        this_thread = SDL_ThreadID();
+        SDL_mutexP(thread_lock);
+        for (i = 0; i < SDL_numthreads; ++i) {
+            if (this_thread == SDL_Threads[i]->threadid) {
+                errbuf = &SDL_Threads[i]->errbuf;
+                break;
+            }
+        }
+        SDL_mutexV(thread_lock);
+    }
+    return (errbuf);
 }
 
 
 /* Arguments and callback to setup and run the user thread function */
-typedef struct {
-	int (SDLCALL *func)(void *);
-	void *data;
-	SDL_Thread *info;
-	SDL_sem *wait;
+typedef struct
+{
+    int (SDLCALL * func) (void *);
+    void *data;
+    SDL_Thread *info;
+    SDL_sem *wait;
 } thread_args;
 
-void SDL_RunThread(void *data)
+void
+SDL_RunThread(void *data)
 {
-	thread_args *args;
-	int (SDLCALL *userfunc)(void *);
-	void *userdata;
-	int *statusloc;
+    thread_args *args;
+    int (SDLCALL * userfunc) (void *);
+    void *userdata;
+    int *statusloc;
 
-	/* Perform any system-dependent setup
-	   - this function cannot fail, and cannot use SDL_SetError()
-	 */
-	SDL_SYS_SetupThread();
+    /* Perform any system-dependent setup
+       - this function cannot fail, and cannot use SDL_SetError()
+     */
+    SDL_SYS_SetupThread();
 
-	/* Get the thread id */
-	args = (thread_args *)data;
-	args->info->threadid = SDL_ThreadID();
+    /* Get the thread id */
+    args = (thread_args *) data;
+    args->info->threadid = SDL_ThreadID();
 
-	/* Figure out what function to run */
-	userfunc = args->func;
-	userdata = args->data;
-	statusloc = &args->info->status;
+    /* Figure out what function to run */
+    userfunc = args->func;
+    userdata = args->data;
+    statusloc = &args->info->status;
 
-	/* Wake up the parent thread */
-	SDL_SemPost(args->wait);
+    /* Wake up the parent thread */
+    SDL_SemPost(args->wait);
 
-	/* Run the function */
-	*statusloc = userfunc(userdata);
+    /* Run the function */
+    *statusloc = userfunc(userdata);
 }
 
 #ifdef SDL_PASSED_BEGINTHREAD_ENDTHREAD
 #undef SDL_CreateThread
-DECLSPEC SDL_Thread * SDLCALL SDL_CreateThread(int (SDLCALL *fn)(void *), void *data, pfnSDL_CurrentBeginThread pfnBeginThread, pfnSDL_CurrentEndThread pfnEndThread)
+DECLSPEC SDL_Thread *SDLCALL
+SDL_CreateThread(int (SDLCALL * fn) (void *), void *data,
+                 pfnSDL_CurrentBeginThread pfnBeginThread,
+                 pfnSDL_CurrentEndThread pfnEndThread)
 #else
-DECLSPEC SDL_Thread * SDLCALL SDL_CreateThread(int (SDLCALL *fn)(void *), void *data)
+DECLSPEC SDL_Thread *SDLCALL
+SDL_CreateThread(int (SDLCALL * fn) (void *), void *data)
 #endif
 {
-	SDL_Thread *thread;
-	thread_args *args;
-	int ret;
+    SDL_Thread *thread;
+    thread_args *args;
+    int ret;
 
-	/* Allocate memory for the thread info structure */
-	thread = (SDL_Thread *)SDL_malloc(sizeof(*thread));
-	if ( thread == NULL ) {
-		SDL_OutOfMemory();
-		return(NULL);
-	}
-	SDL_memset(thread, 0, (sizeof *thread));
-	thread->status = -1;
+    /* Allocate memory for the thread info structure */
+    thread = (SDL_Thread *) SDL_malloc(sizeof(*thread));
+    if (thread == NULL) {
+        SDL_OutOfMemory();
+        return (NULL);
+    }
+    SDL_memset(thread, 0, (sizeof *thread));
+    thread->status = -1;
 
-	/* Set up the arguments for the thread */
-	args = (thread_args *)SDL_malloc(sizeof(*args));
-	if ( args == NULL ) {
-		SDL_OutOfMemory();
-		SDL_free(thread);
-		return(NULL);
-	}
-	args->func = fn;
-	args->data = data;
-	args->info = thread;
-	args->wait = SDL_CreateSemaphore(0);
-	if ( args->wait == NULL ) {
-		SDL_free(thread);
-		SDL_free(args);
-		return(NULL);
-	}
+    /* Set up the arguments for the thread */
+    args = (thread_args *) SDL_malloc(sizeof(*args));
+    if (args == NULL) {
+        SDL_OutOfMemory();
+        SDL_free(thread);
+        return (NULL);
+    }
+    args->func = fn;
+    args->data = data;
+    args->info = thread;
+    args->wait = SDL_CreateSemaphore(0);
+    if (args->wait == NULL) {
+        SDL_free(thread);
+        SDL_free(args);
+        return (NULL);
+    }
 
-	/* Add the thread to the list of available threads */
-	SDL_AddThread(thread);
+    /* Add the thread to the list of available threads */
+    SDL_AddThread(thread);
 
-	/* Create the thread and go! */
+    /* Create the thread and go! */
 #ifdef SDL_PASSED_BEGINTHREAD_ENDTHREAD
-	ret = SDL_SYS_CreateThread(thread, args, pfnBeginThread, pfnEndThread);
+    ret = SDL_SYS_CreateThread(thread, args, pfnBeginThread, pfnEndThread);
 #else
-	ret = SDL_SYS_CreateThread(thread, args);
+    ret = SDL_SYS_CreateThread(thread, args);
 #endif
-	if ( ret >= 0 ) {
-		/* Wait for the thread function to use arguments */
-		SDL_SemWait(args->wait);
-	} else {
-		/* Oops, failed.  Gotta free everything */
-		SDL_DelThread(thread);
-		SDL_free(thread);
-		thread = NULL;
-	}
-	SDL_DestroySemaphore(args->wait);
-	SDL_free(args);
+    if (ret >= 0) {
+        /* Wait for the thread function to use arguments */
+        SDL_SemWait(args->wait);
+    } else {
+        /* Oops, failed.  Gotta free everything */
+        SDL_DelThread(thread);
+        SDL_free(thread);
+        thread = NULL;
+    }
+    SDL_DestroySemaphore(args->wait);
+    SDL_free(args);
 
-	/* Everything is running now */
-	return(thread);
+    /* Everything is running now */
+    return (thread);
 }
 
-void SDL_WaitThread(SDL_Thread *thread, int *status)
+void
+SDL_WaitThread(SDL_Thread * thread, int *status)
 {
-	if ( thread ) {
-		SDL_SYS_WaitThread(thread);
-		if ( status ) {
-			*status = thread->status;
-		}
-		SDL_DelThread(thread);
-		SDL_free(thread);
-	}
+    if (thread) {
+        SDL_SYS_WaitThread(thread);
+        if (status) {
+            *status = thread->status;
+        }
+        SDL_DelThread(thread);
+        SDL_free(thread);
+    }
 }
 
-Uint32 SDL_GetThreadID(SDL_Thread *thread)
+Uint32
+SDL_GetThreadID(SDL_Thread * thread)
 {
-	Uint32 id;
+    Uint32 id;
 
-	if ( thread ) {
-		id = thread->threadid;
-	} else {
-		id = SDL_ThreadID();
-	}
-	return(id);
+    if (thread) {
+        id = thread->threadid;
+    } else {
+        id = SDL_ThreadID();
+    }
+    return (id);
 }
 
-void SDL_KillThread(SDL_Thread *thread)
+void
+SDL_KillThread(SDL_Thread * thread)
 {
-	if ( thread ) {
-		SDL_SYS_KillThread(thread);
-		SDL_WaitThread(thread, NULL);
-	}
+    if (thread) {
+        SDL_SYS_KillThread(thread);
+        SDL_WaitThread(thread, NULL);
+    }
 }
 
+/* vi: set ts=4 sw=4 expandtab: */