int

SDL_ThreadsInit(void)

    int retval;

    retval = 0;

    thread_lock = SDL_CreateMutex();

    if (thread_lock == NULL) {

        retval = -1;

    }

    return (retval);

void

SDL_ThreadsQuit(void)

    SDL_mutex *mutex;

    mutex = thread_lock;

    thread_lock = NULL;

    if (mutex != NULL) {

        SDL_DestroyMutex(mutex);

    }

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);

    /* Expand the list of threads, if necessary */

    printf("Adding thread (%d already - %d max)\n",

           SDL_numthreads, SDL_maxthreads);

    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)

    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;

        }

        printf("Deleting thread (%d left - %d max)\n",

               SDL_numthreads, SDL_maxthreads);

    }

    SDL_mutexV(thread_lock);

    if (SDL_Threads == NULL) {

        SDL_ThreadsQuit();

    }

SDL_error *

SDL_GetErrBuf(void)

    SDL_error *errbuf;

    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);

typedef struct

{

    int (SDLCALL * func) (void *);

    void *data;

    SDL_Thread *info;

    SDL_sem *wait;

void

SDL_RunThread(void *data)

    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();

    /* 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 */

    SDL_SemPost(args->wait);

    /* Run the function */

    *statusloc = userfunc(userdata);

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)

    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 = 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);

    /* Create the thread and go! */

    ret = SDL_SYS_CreateThread(thread, args, pfnBeginThread, pfnEndThread);

    ret = SDL_SYS_CreateThread(thread, 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);

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: */