New configure-based build system. Still work in progress, but much improved

--HG--
extra : convert_revision : svn%3Ac70aab31-4412-0410-b14c-859654838e24/trunk%401365

src/thread/pthread/SDL_syscond.c

@@ -0,0 +1,154 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+#include <sys/time.h>
+#include <unistd.h>
+#include <errno.h>
+#include <pthread.h>
+
+#include "SDL_thread.h"
+#include "SDL_sysmutex_c.h"
+
+struct SDL_cond
+{
+	pthread_cond_t cond;
+};
+
+/* Create a condition variable */
+SDL_cond * SDL_CreateCond(void)
+{
+	SDL_cond *cond;
+
+	cond = (SDL_cond *) SDL_malloc(sizeof(SDL_cond));
+	if ( cond ) {
+		if ( pthread_cond_init(&cond->cond, NULL) < 0 ) {
+			SDL_SetError("pthread_cond_init() failed");
+			SDL_free(cond);
+			cond = NULL;
+		}
+	}
+	return(cond);
+}
+
+/* Destroy a condition variable */
+void SDL_DestroyCond(SDL_cond *cond)
+{
+	if ( cond ) {
+		pthread_cond_destroy(&cond->cond);
+		SDL_free(cond);
+	}
+}
+
+/* Restart one of the threads that are waiting on the condition variable */
+int SDL_CondSignal(SDL_cond *cond)
+{
+	int retval;
+
+	if ( ! cond ) {
+		SDL_SetError("Passed a NULL condition variable");
+		return -1;
+	}
+
+	retval = 0;
+	if ( pthread_cond_signal(&cond->cond) != 0 ) {
+		SDL_SetError("pthread_cond_signal() failed");
+		retval = -1;
+	}
+	return retval;
+}
+
+/* Restart all threads that are waiting on the condition variable */
+int SDL_CondBroadcast(SDL_cond *cond)
+{
+	int retval;
+
+	if ( ! cond ) {
+		SDL_SetError("Passed a NULL condition variable");
+		return -1;
+	}
+
+	retval = 0;
+	if ( pthread_cond_broadcast(&cond->cond) != 0 ) {
+		SDL_SetError("pthread_cond_broadcast() failed");
+		retval = -1;
+	}
+	return retval;
+}
+
+int SDL_CondWaitTimeout(SDL_cond *cond, SDL_mutex *mutex, Uint32 ms)
+{
+	int retval;
+	struct timeval delta;
+	struct timespec abstime;
+
+	if ( ! cond ) {
+		SDL_SetError("Passed a NULL condition variable");
+		return -1;
+	}
+
+	gettimeofday(&delta, NULL);
+
+	abstime.tv_sec = delta.tv_sec + (ms/1000);
+	abstime.tv_nsec = (delta.tv_usec + (ms%1000) * 1000) * 1000;
+        if ( abstime.tv_nsec > 1000000000 ) {
+          abstime.tv_sec += 1;
+          abstime.tv_nsec -= 1000000000;
+        }
+
+  tryagain:
+	retval = pthread_cond_timedwait(&cond->cond, &mutex->id, &abstime);
+	switch (retval) {
+	    case EINTR:
+		goto tryagain;
+		break;
+	    case ETIMEDOUT:
+		retval = SDL_MUTEX_TIMEDOUT;
+		break;
+	    case 0:
+		break;
+	    default:
+		SDL_SetError("pthread_cond_timedwait() failed");
+		retval = -1;
+		break;
+	}
+	return retval;
+}
+
+/* Wait on the condition variable, unlocking the provided mutex.
+   The mutex must be locked before entering this function!
+ */
+int SDL_CondWait(SDL_cond *cond, SDL_mutex *mutex)
+{
+	int retval;
+
+	if ( ! cond ) {
+		SDL_SetError("Passed a NULL condition variable");
+		return -1;
+	}
+
+	retval = 0;
+	if ( pthread_cond_wait(&cond->cond, &mutex->id) != 0 ) {
+		SDL_SetError("pthread_cond_wait() failed");
+		retval = -1;
+	}
+	return retval;
+}

src/thread/pthread/SDL_sysmutex.c

@@ -0,0 +1,152 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+#include <pthread.h>
+
+#include "SDL_thread.h"
+
+#if !SDL_THREAD_PTHREAD_RECURSIVE_MUTEX && \
+    !SDL_THREAD_PTHREAD_RECURSIVE_MUTEX_NP
+#define FAKE_RECURSIVE_MUTEX
+#endif
+
+struct SDL_mutex {
+	pthread_mutex_t id;
+#if FAKE_RECURSIVE_MUTEX
+	int recursive;
+	pthread_t owner;
+#endif
+};
+
+SDL_mutex *SDL_CreateMutex (void)
+{
+	SDL_mutex *mutex;
+	pthread_mutexattr_t attr;
+
+	/* Allocate the structure */
+	mutex = (SDL_mutex *)SDL_calloc(1, sizeof(*mutex));
+	if ( mutex ) {
+		pthread_mutexattr_init(&attr);
+#if SDL_THREAD_PTHREAD_RECURSIVE_MUTEX
+		pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+#elif SDL_THREAD_PTHREAD_RECURSIVE_MUTEX_NP
+		pthread_mutexattr_setkind_np(&attr, PTHREAD_MUTEX_RECURSIVE_NP);
+#else
+		/* No extra attributes necessary */
+#endif
+		if ( pthread_mutex_init(&mutex->id, &attr) != 0 ) {
+			SDL_SetError("pthread_mutex_init() failed");
+			SDL_free(mutex);
+			mutex = NULL;
+		}
+	} else {
+		SDL_OutOfMemory();
+	}
+	return(mutex);
+}
+
+void SDL_DestroyMutex(SDL_mutex *mutex)
+{
+	if ( mutex ) {
+		pthread_mutex_destroy(&mutex->id);
+		SDL_free(mutex);
+	}
+}
+
+/* Lock the mutex */
+int SDL_mutexP(SDL_mutex *mutex)
+{
+	int retval;
+#if FAKE_RECURSIVE_MUTEX
+	pthread_t this_thread;
+#endif
+
+	if ( mutex == NULL ) {
+		SDL_SetError("Passed a NULL mutex");
+		return -1;
+	}
+
+	retval = 0;
+#if FAKE_RECURSIVE_MUTEX
+	this_thread = pthread_self();
+	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.
+		*/
+		if ( pthread_mutex_lock(&mutex->id) == 0 ) {
+			mutex->owner = this_thread;
+			mutex->recursive = 0;
+		} else {
+			SDL_SetError("pthread_mutex_lock() failed");
+			retval = -1;
+		}
+	}
+#else
+	if ( pthread_mutex_lock(&mutex->id) < 0 ) {
+		SDL_SetError("pthread_mutex_lock() failed");
+		retval = -1;
+	}
+#endif
+	return retval;
+}
+
+int SDL_mutexV(SDL_mutex *mutex)
+{
+	int retval;
+
+	if ( mutex == NULL ) {
+		SDL_SetError("Passed a NULL mutex");
+		return -1;
+	}
+
+	retval = 0;
+#if FAKE_RECURSIVE_MUTEX
+	/* We can only unlock the mutex if we own it */
+	if ( pthread_self() == mutex->owner ) {
+		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;
+			pthread_mutex_unlock(&mutex->id);
+		}
+	} else {
+		SDL_SetError("mutex not owned by this thread");
+		retval = -1;
+	}
+
+#else
+	if ( pthread_mutex_unlock(&mutex->id) < 0 ) {
+		SDL_SetError("pthread_mutex_unlock() failed");
+		retval = -1;
+	}
+#endif /* FAKE_RECURSIVE_MUTEX */
+
+	return retval;
+}

src/thread/pthread/SDL_sysmutex_c.h

@@ -0,0 +1,30 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+#ifndef _SDL_mutex_c_h
+#define _SDL_mutex_c_h
+
+struct SDL_mutex {
+	pthread_mutex_t id;
+};
+
+#endif /* _SDL_mutex_c_h */

src/thread/pthread/SDL_syssem.c

@@ -0,0 +1,174 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+#include <pthread.h>
+#include <semaphore.h>
+
+#include "SDL_thread.h"
+#include "SDL_timer.h"
+
+/* Wrapper around POSIX 1003.1b semaphores */
+
+#if MACOSX
+#define USE_NAMED_SEMAPHORES 1
+#endif /* MACOSX */
+
+struct SDL_semaphore {
+	sem_t *sem;
+#if !USE_NAMED_SEMAPHORES
+	sem_t sem_data;
+#endif
+};
+
+/* Create a semaphore, initialized with value */
+SDL_sem *SDL_CreateSemaphore(Uint32 initial_value)
+{
+	SDL_sem *sem = (SDL_sem *) SDL_malloc(sizeof(SDL_sem));
+	if ( sem ) {
+#if USE_NAMED_SEMAPHORES
+		static int semnum = 0;
+		char name[32];
+
+		SDL_snprintf(name, SDL_arraysize(name), "/SDL_sem-%d-%4.4d", getpid(), semnum++);
+		sem->sem = sem_open(name, O_CREAT, 0600, initial_value);
+		if ( sem->sem == (sem_t *)SEM_FAILED ) {
+			SDL_SetError("sem_open(%s) failed", name);
+			SDL_free(sem);
+			sem = NULL;
+		} else {
+			sem_unlink(name);
+		}
+#else
+		if ( sem_init(&sem->sem_data, 0, initial_value) < 0 ) {
+			SDL_SetError("sem_init() failed");
+			SDL_free(sem);
+			sem = NULL;
+		} else {
+			sem->sem = &sem->sem_data;
+		}
+#endif /* USE_NAMED_SEMAPHORES */
+	} else {
+		SDL_OutOfMemory();
+	}
+	return sem;
+}
+
+void SDL_DestroySemaphore(SDL_sem *sem)
+{
+	if ( sem ) {
+#if USE_NAMED_SEMAPHORES
+		sem_close(sem->sem);
+#else
+		sem_destroy(sem->sem);
+#endif
+		SDL_free(sem);
+	}
+}
+
+int SDL_SemTryWait(SDL_sem *sem)
+{
+	int retval;
+
+	if ( ! sem ) {
+		SDL_SetError("Passed a NULL semaphore");
+		return -1;
+	}
+	retval = SDL_MUTEX_TIMEDOUT;
+	if ( sem_trywait(sem->sem) == 0 ) {
+		retval = 0;
+	}
+	return retval;
+}
+
+int SDL_SemWait(SDL_sem *sem)
+{
+	int retval;
+
+	if ( ! sem ) {
+		SDL_SetError("Passed a NULL semaphore");
+		return -1;
+	}
+
+	retval = sem_wait(sem->sem);
+	if ( retval < 0 ) {
+		SDL_SetError("sem_wait() failed");
+	}
+	return retval;
+}
+
+int SDL_SemWaitTimeout(SDL_sem *sem, Uint32 timeout)
+{
+	int retval;
+
+	if ( ! sem ) {
+		SDL_SetError("Passed a NULL semaphore");
+		return -1;
+	}
+
+	/* Try the easy cases first */
+	if ( timeout == 0 ) {
+		return SDL_SemTryWait(sem);
+	}
+	if ( timeout == SDL_MUTEX_MAXWAIT ) {
+		return SDL_SemWait(sem);
+	}
+
+	/* Ack!  We have to busy wait... */
+	timeout += SDL_GetTicks();
+	do {
+		retval = SDL_SemTryWait(sem);
+		if ( retval == 0 ) {
+			break;
+		}
+		SDL_Delay(1);
+	} while ( SDL_GetTicks() < timeout );
+
+	return retval;
+}
+
+Uint32 SDL_SemValue(SDL_sem *sem)
+{
+	int ret = 0;
+	if ( sem ) {
+		sem_getvalue(sem->sem, &ret);
+		if ( ret < 0 ) {
+			ret = 0;
+		}
+	}
+	return (Uint32)ret;
+}
+
+int SDL_SemPost(SDL_sem *sem)
+{
+	int retval;
+
+	if ( ! sem ) {
+		SDL_SetError("Passed a NULL semaphore");
+		return -1;
+	}
+
+	retval = sem_post(sem->sem);
+	if ( retval < 0 ) {
+		SDL_SetError("sem_post() failed");
+	}
+	return retval;
+}

src/thread/pthread/SDL_systhread.c

@@ -0,0 +1,104 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+#include <pthread.h>
+#include <signal.h>
+
+#include "SDL_thread.h"
+#include "../SDL_thread_c.h"
+#include "../SDL_systhread.h"
+
+/* List of signals to mask in the subthreads */
+static int sig_list[] = {
+	SIGHUP, SIGINT, SIGQUIT, SIGPIPE, SIGALRM, SIGTERM, SIGCHLD, SIGWINCH,
+	SIGVTALRM, SIGPROF, 0
+};
+
+
+static void *RunThread(void *data)
+{
+	SDL_RunThread(data);
+	pthread_exit((void*)0);
+	return((void *)0);		/* Prevent compiler warning */
+}
+
+int SDL_SYS_CreateThread(SDL_Thread *thread, void *args)
+{
+	pthread_attr_t type;
+
+	/* Set the thread attributes */
+	if ( pthread_attr_init(&type) != 0 ) {
+		SDL_SetError("Couldn't initialize pthread attributes");
+		return(-1);
+	}
+	pthread_attr_setdetachstate(&type, PTHREAD_CREATE_JOINABLE);
+
+	/* Create the thread and go! */
+	if ( pthread_create(&thread->handle, &type, RunThread, args) != 0 ) {
+		SDL_SetError("Not enough resources to create thread");
+		return(-1);
+	}
+	return(0);
+}
+
+void SDL_SYS_SetupThread(void)
+{
+	int i;
+	sigset_t mask;
+
+	/* Mask asynchronous signals for this thread */
+	sigemptyset(&mask);
+	for ( i=0; sig_list[i]; ++i ) {
+		sigaddset(&mask, sig_list[i]);
+	}
+	pthread_sigmask(SIG_BLOCK, &mask, 0);
+
+#ifdef PTHREAD_CANCEL_ASYNCHRONOUS
+	/* Allow ourselves to be asynchronously cancelled */
+	{ int oldstate;
+		pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &oldstate);
+	}
+#endif
+}
+
+/* WARNING:  This may not work for systems with 64-bit pid_t */
+Uint32 SDL_ThreadID(void)
+{
+	return((Uint32)pthread_self());
+}
+
+void SDL_SYS_WaitThread(SDL_Thread *thread)
+{
+	pthread_join(thread->handle, 0);
+}
+
+void SDL_SYS_KillThread(SDL_Thread *thread)
+{
+#ifdef PTHREAD_CANCEL_ASYNCHRONOUS
+	pthread_cancel(thread->handle);
+#else
+#ifdef __FreeBSD__
+#warning For some reason, this doesnt actually kill a thread - FreeBSD 3.2
+#endif
+	pthread_kill(thread->handle, SIGKILL);
+#endif
+}

src/thread/pthread/SDL_systhread_c.h

@@ -0,0 +1,25 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2004 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+#include <pthread.h>
+
+typedef pthread_t SYS_ThreadHandle;