/* This code implemented by [email protected] */

#define INCL_DOSPROCESS

#define INCL_DOSSEMAPHORES

#include "os2.h"

#include "limits.h"

#include "process.h"

#if defined(PYCC_GCC)

#include <sys/builtin.h>

#include <sys/fmutex.h>

#else

long PyThread_get_thread_ident(void);

#endif

/* default thread stack size of 64kB */

#if !defined(THREAD_STACK_SIZE)

#define THREAD_STACK_SIZE 0x10000

#endif

#define OS2_STACKSIZE(x) (x ? x : THREAD_STACK_SIZE)

/*

* Initialization of the C package, should not be needed.

*/

static void

PyThread__init_thread(void)

{

}

/*

* Thread support.

*/

long

PyThread_start_new_thread(void (*func)(void *), void *arg)

{

int thread_id;

thread_id = _beginthread(func,

NULL,

OS2_STACKSIZE(_pythread_stacksize),

arg);

if (thread_id == -1) {

dprintf(("_beginthread failed. return %ld\n", errno));

}

return thread_id;

}

long

PyThread_get_thread_ident(void)

{

#if !defined(PYCC_GCC)

PPIB pib;

PTIB tib;

#endif

if (!initialized)

PyThread_init_thread();

#if defined(PYCC_GCC)

return _gettid();

#else

DosGetInfoBlocks(&tib, &pib);

return tib->tib_ptib2->tib2_ultid;

#endif

}

static void

do_PyThread_exit_thread(int no_cleanup)

{

dprintf(("%ld: PyThread_exit_thread called\n",

PyThread_get_thread_ident()));

if (!initialized)

if (no_cleanup)

_exit(0);

else

exit(0);

_endthread();

}

void

PyThread_exit_thread(void)

{

do_PyThread_exit_thread(0);

}

void

PyThread__exit_thread(void)

{

do_PyThread_exit_thread(1);

}

#ifndef NO_EXIT_PROG

static void

do_PyThread_exit_prog(int status, int no_cleanup)

{

dprintf(("PyThread_exit_prog(%d) called\n", status));

if (!initialized)

if (no_cleanup)

_exit(status);

else

exit(status);

}

void

PyThread_exit_prog(int status)

{

do_PyThread_exit_prog(status, 0);

}

void

PyThread__exit_prog(int status)

{

do_PyThread_exit_prog(status, 1);

}

#endif /* NO_EXIT_PROG */

/*

* Lock support. This is implemented with an event semaphore and critical

* sections to make it behave more like a posix mutex than its OS/2

* counterparts.

*/

typedef struct os2_lock_t {

int is_set;

HEV changed;

} *type_os2_lock;

PyThread_type_lock

PyThread_allocate_lock(void)

{

#if defined(PYCC_GCC)

_fmutex *sem = malloc(sizeof(_fmutex));

if (!initialized)

PyThread_init_thread();

dprintf(("%ld: PyThread_allocate_lock() -> %lx\n",

PyThread_get_thread_ident(),

(long)sem));

if (_fmutex_create(sem, 0)) {

free(sem);

sem = NULL;

}

return (PyThread_type_lock)sem;

#else

APIRET rc;

type_os2_lock lock = (type_os2_lock)malloc(sizeof(struct os2_lock_t));

dprintf(("PyThread_allocate_lock called\n"));

if (!initialized)

PyThread_init_thread();

lock->is_set = 0;

DosCreateEventSem(NULL, &lock->changed, 0, 0);

dprintf(("%ld: PyThread_allocate_lock() -> %p\n",

PyThread_get_thread_ident(),

lock->changed));

return (PyThread_type_lock)lock;

#endif

}

void

PyThread_free_lock(PyThread_type_lock aLock)

{

#if !defined(PYCC_GCC)

type_os2_lock lock = (type_os2_lock)aLock;

#endif

dprintf(("%ld: PyThread_free_lock(%p) called\n",

PyThread_get_thread_ident(),aLock));

#if defined(PYCC_GCC)

if (aLock) {

_fmutex_close((_fmutex *)aLock);

free((_fmutex *)aLock);

}

#else

DosCloseEventSem(lock->changed);

free(aLock);

#endif

}

/*

* Return 1 on success if the lock was acquired

*

* and 0 if the lock was not acquired.

*/

int

PyThread_acquire_lock(PyThread_type_lock aLock, int waitflag)

{

#if !defined(PYCC_GCC)

int done = 0;

ULONG count;

PID pid = 0;

TID tid = 0;

type_os2_lock lock = (type_os2_lock)aLock;

#endif

dprintf(("%ld: PyThread_acquire_lock(%p, %d) called\n",

PyThread_get_thread_ident(),

aLock,

waitflag));

#if defined(PYCC_GCC)

/* always successful if the lock doesn't exist */

if (aLock &&

_fmutex_request((_fmutex *)aLock, waitflag ? 0 : _FMR_NOWAIT))

return 0;

#else

while (!done) {

/* if the lock is currently set, we have to wait for

* the state to change

*/

if (lock->is_set) {

if (!waitflag)

return 0;

DosWaitEventSem(lock->changed, SEM_INDEFINITE_WAIT);

}

/* enter a critical section and try to get the semaphore. If

* it is still locked, we will try again.

*/

if (DosEnterCritSec())

return 0;

if (!lock->is_set) {

lock->is_set = 1;

DosResetEventSem(lock->changed, &count);

done = 1;

}

DosExitCritSec();

}

#endif

return 1;

}

void

PyThread_release_lock(PyThread_type_lock aLock)

{

#if !defined(PYCC_GCC)

type_os2_lock lock = (type_os2_lock)aLock;

#endif

dprintf(("%ld: PyThread_release_lock(%p) called\n",

PyThread_get_thread_ident(),

aLock));

#if defined(PYCC_GCC)

if (aLock)

_fmutex_release((_fmutex *)aLock);

#else

if (!lock->is_set) {

dprintf(("%ld: Could not PyThread_release_lock(%p) error: %l\n",

PyThread_get_thread_ident(),

aLock,

GetLastError()));

return;

}

if (DosEnterCritSec()) {

dprintf(("%ld: Could not PyThread_release_lock(%p) error: %l\n",

PyThread_get_thread_ident(),

aLock,

GetLastError()));

return;

}

lock->is_set = 0;

DosPostEventSem(lock->changed);

DosExitCritSec();

#endif

}

/* minimum/maximum thread stack sizes supported */

#define THREAD_MIN_STACKSIZE 0x8000 /* 32kB */

#define THREAD_MAX_STACKSIZE 0x2000000 /* 32MB */

/* set the thread stack size.

* Return 0 if size is valid, -1 otherwise.

*/

static int

_pythread_os2_set_stacksize(size_t size)

{

/* set to default */

if (size == 0) {

_pythread_stacksize = 0;

return 0;

}

/* valid range? */

if (size >= THREAD_MIN_STACKSIZE && size < THREAD_MAX_STACKSIZE) {

_pythread_stacksize = size;

return 0;

}

return -1;

}

#define THREAD_SET_STACKSIZE(x) _pythread_os2_set_stacksize(x)