Leahnaya/SDL
1
0
Fork 0
mirror of https://github.com/yawut/SDL.git synced 2026-09-08 17:16:19 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

Removed AmigaOS code for 1.3 branch.

Browse Source
This commit is contained in:
Ryan C. Gordon
2006-10-29 04:09:17 +00:00
parent a08b4ac133
commit b94f08253a
33 changed files with 3 additions and 5638 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/thread/SDL_thread_c.h
View File

@@ -27,8 +27,6 @@
/* Need the definitions of SYS_ThreadHandle */
#if SDL_THREADS_DISABLED
#include "generic/SDL_systhread_c.h"
#elif SDL_THREAD_AMIGA
#include "amigaos/SDL_systhread_c.h"
#elif SDL_THREAD_BEOS
#include "beos/SDL_systhread_c.h"
#elif SDL_THREAD_DC

154
src/thread/amigaos/SDL_syssem.c
View File

@@ -1,154 +0,0 @@
/*
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 "SDL_config.h"
/* An implementation of semaphores using mutexes and condition variables */
#include "SDL_thread.h"
#include "SDL_systhread_c.h"
struct SDL_semaphore
{
struct SignalSemaphore Sem;
};
#undef D
#define D(x)
SDL_sem *
SDL_CreateSemaphore(Uint32 initial_value)
{
SDL_sem *sem;
sem = (SDL_sem *) SDL_malloc(sizeof(*sem));
if (!sem) {
SDL_OutOfMemory();
return (0);
}
D(bug("Creating semaphore %lx...\n", sem));
SDL_memset(sem, 0, sizeof(*sem));
InitSemaphore(&sem->Sem);
return (sem);
}
void
SDL_DestroySemaphore(SDL_sem * sem)
{
D(bug("Destroying semaphore %lx...\n", sem));
if (sem) {
// Condizioni per liberare i task in attesa?
SDL_free(sem);
}
}
int
SDL_SemTryWait(SDL_sem * sem)
{
if (!sem) {
SDL_SetError("Passed a NULL semaphore");
return -1;
}
D(bug("TryWait semaphore...%lx\n", sem));
ObtainSemaphore(&sem->Sem);
// ReleaseSemaphore(&sem->Sem);
return 1;
}
int
SDL_SemWaitTimeout(SDL_sem * sem, Uint32 timeout)
{
int retval;
if (!sem) {
SDL_SetError("Passed a NULL semaphore");
return -1;
}
D(bug("WaitTimeout (%ld) semaphore...%lx\n", timeout, sem));
/* A timeout of 0 is an easy case */
if (timeout == 0) {
ObtainSemaphore(&sem->Sem);
return 1;
}
if (!(retval = AttemptSemaphore(&sem->Sem))) {
SDL_Delay(timeout);
retval = AttemptSemaphore(&sem->Sem);
}
if (retval == TRUE) {
// ReleaseSemaphore(&sem->Sem);
retval = 1;
}
return retval;
}
int
SDL_SemWait(SDL_sem * sem)
{
ObtainSemaphore(&sem->Sem);
return 0;
}
Uint32
SDL_SemValue(SDL_sem * sem)
{
Uint32 value;
value = 0;
if (sem) {
#ifdef STORMC4_WOS
value = sem->Sem.ssppc_SS.ss_NestCount;
#else
value = sem->Sem.ss_NestCount;
#endif
}
return value;
}
int
SDL_SemPost(SDL_sem * sem)
{
if (!sem) {
SDL_SetError("Passed a NULL semaphore");
return -1;
}
D(bug("SemPost semaphore...%lx\n", sem));
ReleaseSemaphore(&sem->Sem);
return 0;
}
/* vi: set ts=4 sw=4 expandtab: */

165
src/thread/amigaos/SDL_systhread.c
View File

@@ -1,165 +0,0 @@
/*
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 "SDL_config.h"
/* BeOS thread management routines for SDL */
#include "SDL_mutex.h"
#include "SDL_thread.h"
#include "../SDL_thread_c.h"
#include "../SDL_systhread.h"
#include "mydebug.h"
typedef struct
{
int (*func) (void *);
void *data;
SDL_Thread *info;
struct Task *wait;
} thread_args;
#ifndef MORPHOS
#if defined(__SASC) && !defined(__PPC__)
__saveds __asm Uint32
RunThread(register __a0 char *args)
#elif defined(__PPC__)
Uint32
RunThread(char *args)
#else
Uint32 __saveds
RunThread(char *args __asm("a0"))
#endif
{
#ifdef STORMC4_WOS
thread_args *data = (thread_args *) args;
#else
thread_args *data = (thread_args *) atol(args);
#endif
struct Task *Father;
D(bug("Received data: %lx\n", data));
Father = data->wait;
SDL_RunThread(data);
Signal(Father, SIGBREAKF_CTRL_F);
D(bug("Thread with data %lx ended\n", data));
return (0);
}
#else
#include <emul/emulinterface.h>
Uint32
RunTheThread(void)
{
thread_args *data = (thread_args *) atol((char *) REG_A0);
struct Task *Father;
D(bug("Received data: %lx\n", data));
Father = data->wait;
SDL_RunThread(data);
Signal(Father, SIGBREAKF_CTRL_F);
D(bug("Thread with data %lx ended\n", data));
return (0);
}
struct EmulLibEntry RunThreadStruct = {
TRAP_LIB,
0,
(ULONG) RunTheThread
};
void *RunThread = &RunThreadStruct;
#endif
int
SDL_SYS_CreateThread(SDL_Thread * thread, void *args)
{
/* Create the thread and go! */
char buffer[20];
D(bug("Sending %lx to the new thread...\n", args));
if (args)
SDL_snprintf(buffer, SDL_arraysize(buffer), "%ld", args);
#ifdef STORMC4_WOS
thread->handle = CreateTaskPPCTags(TASKATTR_CODE, RunThread,
TASKATTR_NAME, "SDL subtask",
TASKATTR_STACKSIZE, 100000,
(args ? TASKATTR_R3 : TAG_IGNORE),
args, TASKATTR_INHERITR2, TRUE,
TAG_DONE);
#else
thread->handle = (struct Task *) CreateNewProcTags(NP_Output, Output(),
NP_Name,
(ULONG) "SDL subtask",
NP_CloseOutput, FALSE,
NP_StackSize, 20000,
NP_Entry,
(ULONG) RunThread,
args ? NP_Arguments :
TAG_IGNORE,
(ULONG) buffer,
TAG_DONE);
#endif
if (!thread->handle) {
SDL_SetError("Not enough resources to create thread");
return (-1);
}
return (0);
}
void
SDL_SYS_SetupThread(void)
{
}
Uint32
SDL_ThreadID(void)
{
return ((Uint32) FindTask(NULL));
}
void
SDL_SYS_WaitThread(SDL_Thread * thread)
{
SetSignal(0L, SIGBREAKF_CTRL_F | SIGBREAKF_CTRL_C);
Wait(SIGBREAKF_CTRL_F | SIGBREAKF_CTRL_C);
}
void
SDL_SYS_KillThread(SDL_Thread * thread)
{
Signal((struct Task *) thread->handle, SIGBREAKF_CTRL_C);
}
/* vi: set ts=4 sw=4 expandtab: */

61
src/thread/amigaos/SDL_systhread_c.h
View File

@@ -1,61 +0,0 @@
/*
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 "SDL_config.h"
#include <exec/exec.h>
#include <dos/dos.h>
#include <dos/dostags.h>
#if defined (__SASC) || defined(STORMC4_WOS)
#include <proto/dos.h>
#include <proto/exec.h>
#else
#include <inline/dos.h>
#include <inline/exec.h>
#endif
#include "mydebug.h"
extern struct ExecBase *SysBase;
extern struct DosLibrary *DOSBase;
#ifdef STORMC4_WOS
#include <proto/powerpc.h>
/* use powerpc.library functions instead og exec */
#define SYS_ThreadHandle struct TaskPPC *
#define Signal SignalPPC
#define Wait WaitPPC
#define Task TaskPPC
#define FindTask FindTaskPPC
#define SetSignal SetSignalPPC
#define InitSemaphore InitSemaphorePPC
#define ObtainSemaphore ObtainSemaphorePPC
#define AttemptSemaphore AttemptSemaphorePPC
#define ReleaseSemaphore ReleaseSemaphorePPC
#define SignalSemaphore SignalSemaphorePPC
#else
#define SYS_ThreadHandle struct Task *
#endif /*STORMC4_WOS */
/* vi: set ts=4 sw=4 expandtab: */

291
src/thread/amigaos/SDL_thread.c
View File

@@ -1,291 +0,0 @@
/*
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 "SDL_config.h"
/* System independent thread management routines for SDL */
#include "SDL_mutex.h"
#include "SDL_thread.h"
#include "../SDL_thread_c.h"
#include "../SDL_systhread.h"
#define ARRAY_CHUNKSIZE 32
/* The array of threads currently active in the application
(except the main thread)
The manipulation of an array here is safer than using a linked list.
*/
static int SDL_maxthreads = 0;
static int SDL_numthreads = 0;
static SDL_Thread **SDL_Threads = NULL;
static struct SignalSemaphore thread_lock;
int thread_lock_created = 0;
int
SDL_ThreadsInit(void)
{
InitSemaphore(&thread_lock);
thread_lock_created = 1;
return 0;
}
/* This should never be called...
If this is called by SDL_Quit(), we don't know whether or not we should
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()
{
thread_lock_created = 0;
}
/* Routines for manipulating the thread list */
static void
SDL_AddThread(SDL_Thread * thread)
{
SDL_Thread **threads;
/* 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_created) {
if (SDL_ThreadsInit() < 0) {
return;
}
}
ObtainSemaphore(&thread_lock);
/* Expand the list of threads, if necessary */
#ifdef DEBUG_THREADS
printf("Adding thread (%d already - %d max)\n",
SDL_numthreads, SDL_maxthreads);
#endif
if (SDL_numthreads == SDL_maxthreads) {
threads =
(SDL_Thread **) SDL_malloc((SDL_maxthreads + ARRAY_CHUNKSIZE) *
(sizeof *threads));
if (threads == NULL) {
SDL_OutOfMemory();
goto done;
}
SDL_memcpy(threads, SDL_Threads, SDL_numthreads * (sizeof *threads));
SDL_maxthreads += ARRAY_CHUNKSIZE;
if (SDL_Threads) {
SDL_free(SDL_Threads);
}
SDL_Threads = threads;
}
SDL_Threads[SDL_numthreads++] = thread;
done:
ReleaseSemaphore(&thread_lock);
}
static void
SDL_DelThread(SDL_Thread * thread)
{
int i;
if (thread_lock_created) {
ObtainSemaphore(&thread_lock);
for (i = 0; i < SDL_numthreads; ++i) {
if (thread == SDL_Threads[i]) {
break;
}
}
if (i < SDL_numthreads) {
--SDL_numthreads;
while (i < SDL_numthreads) {
SDL_Threads[i] = SDL_Threads[i + 1];
++i;
}
#ifdef DEBUG_THREADS
printf("Deleting thread (%d left - %d max)\n",
SDL_numthreads, SDL_maxthreads);
#endif
}
ReleaseSemaphore(&thread_lock);
}
}
/* 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 *errbuf;
errbuf = &SDL_global_error;
if (SDL_Threads) {
int i;
Uint32 this_thread;
this_thread = SDL_ThreadID();
ObtainSemaphore(&thread_lock);
for (i = 0; i < SDL_numthreads; ++i) {
if (this_thread == SDL_Threads[i]->threadid) {
errbuf = &SDL_Threads[i]->errbuf;
break;
}
}
ReleaseSemaphore(&thread_lock);
}
return (errbuf);
}
/* Arguments and callback to setup and run the user thread function */
typedef struct
{
int (*func) (void *);
void *data;
SDL_Thread *info;
struct Task *wait;
} thread_args;
void
SDL_RunThread(void *data)
{
thread_args *args;
int (*userfunc) (void *);
void *userdata;
int *statusloc;
/* 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();
/* Figure out what function to run */
userfunc = args->func;
userdata = args->data;
statusloc = &args->info->status;
/* Wake up the parent thread */
Signal(args->wait, SIGBREAKF_CTRL_E);
/* Run the function */
*statusloc = userfunc(userdata);
}
SDL_Thread *
SDL_CreateThread(int (*fn) (void *), void *data)
{
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;
/* 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 = FindTask(NULL);
if (args->wait == NULL) {
SDL_free(thread);
SDL_free(args);
SDL_OutOfMemory();
return (NULL);
}
/* Add the thread to the list of available threads */
SDL_AddThread(thread);
D(bug("Starting thread...\n"));
/* Create the thread and go! */
ret = SDL_SYS_CreateThread(thread, args);
if (ret >= 0) {
D(bug("Waiting for thread CTRL_E...\n"));
/* Wait for the thread function to use arguments */
Wait(SIGBREAKF_CTRL_E);
D(bug(" Arrived."));
} else {
/* Oops, failed. Gotta free everything */
SDL_DelThread(thread);
SDL_free(thread);
thread = NULL;
}
SDL_free(args);
/* Everything is running now */
return (thread);
}
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);
}
}
Uint32
SDL_GetThreadID(SDL_Thread * thread)
{
Uint32 id;
if (thread) {
id = thread->threadid;
} else {
id = SDL_ThreadID();
}
return (id);
}
void
SDL_KillThread(SDL_Thread * thread)
{
if (thread) {
SDL_SYS_KillThread(thread);
SDL_WaitThread(thread, NULL);
}
}
/* vi: set ts=4 sw=4 expandtab: */