#include "Python.h"

#ifdef HAVE_DLOPEN

#ifdef HAVE_DLFCN_H

#include <dlfcn.h>

#ifndef RTLD_LAZY

#define RTLD_LAZY 1

#define ZAP(x) { \

PyObject *tmp = (PyObject *)(x); \

(x) = NULL; \

Py_XDECREF(tmp); \

}

#ifdef WITH_THREAD

#include "pythread.h"

static PyThread_type_lock head_mutex = NULL; /* Protects interp->tstate_head */

#define HEAD_INIT() (void)(head_mutex || (head_mutex = PyThread_allocate_lock()))

#define HEAD_LOCK() PyThread_acquire_lock(head_mutex, WAIT_LOCK)

#define HEAD_UNLOCK() PyThread_release_lock(head_mutex)

#define HEAD_INIT() /* Nothing */

#define HEAD_LOCK() /* Nothing */

#define HEAD_UNLOCK() /* Nothing */

static PyInterpreterState *interp_head = NULL;

PyThreadState *_PyThreadState_Current = NULL;

PyThreadFrameGetter _PyThreadState_GetFrame = NULL;

PyInterpreterState *

PyInterpreterState_New(void)

{

PyInterpreterState *interp = (PyInterpreterState *)

malloc(sizeof(PyInterpreterState));

if (interp != NULL) {

HEAD_INIT();

interp->modules = NULL;

interp->sysdict = NULL;

interp->builtins = NULL;

interp->tstate_head = NULL;

interp->codec_search_path = NULL;

interp->codec_search_cache = NULL;

interp->codec_error_registry = NULL;

#ifdef HAVE_DLOPEN

#ifdef RTLD_NOW

interp->dlopenflags = RTLD_NOW;

interp->dlopenflags = RTLD_LAZY;

HEAD_LOCK();

interp->next = interp_head;

interp_head = interp;

HEAD_UNLOCK();

}

return interp;

}

PyInterpreterState_Clear(PyInterpreterState *interp)

{

PyThreadState *p;

HEAD_LOCK();

for (p = interp->tstate_head; p != NULL; p = p->next)

PyThreadState_Clear(p);

HEAD_UNLOCK();

ZAP(interp->codec_search_path);

ZAP(interp->codec_search_cache);

ZAP(interp->codec_error_registry);

ZAP(interp->modules);

ZAP(interp->sysdict);

ZAP(interp->builtins);

}

static void

zapthreads(PyInterpreterState *interp)

{

PyThreadState *p;

/* No need to lock the mutex here because this should only happen

while ((p = interp->tstate_head) != NULL) {

PyThreadState_Delete(p);

}

}

PyInterpreterState_Delete(PyInterpreterState *interp)

{

PyInterpreterState **p;

zapthreads(interp);

HEAD_LOCK();

for (p = &interp_head; ; p = &(*p)->next) {

if (*p == NULL)

Py_FatalError(

"PyInterpreterState_Delete: invalid interp");

if (*p == interp)

break;

}

if (interp->tstate_head != NULL)

Py_FatalError("PyInterpreterState_Delete: remaining threads");

*p = interp->next;

HEAD_UNLOCK();

free(interp);

}

static struct _frame *

threadstate_getframe(PyThreadState *self)

{

return self->frame;

}

PyThreadState *

PyThreadState_New(PyInterpreterState *interp)

{

PyThreadState *tstate = (PyThreadState *)malloc(sizeof(PyThreadState));

if (_PyThreadState_GetFrame == NULL)

_PyThreadState_GetFrame = threadstate_getframe;

if (tstate != NULL) {

tstate->interp = interp;

tstate->frame = NULL;

tstate->recursion_depth = 0;

tstate->tracing = 0;

tstate->use_tracing = 0;

tstate->tick_counter = 0;

tstate->gilstate_counter = 0;

tstate->async_exc = NULL;

#ifdef WITH_THREAD

tstate->thread_id = PyThread_get_thread_ident();

tstate->thread_id = 0;

tstate->dict = NULL;

tstate->curexc_type = NULL;

tstate->curexc_value = NULL;

tstate->curexc_traceback = NULL;

tstate->exc_type = NULL;

tstate->exc_value = NULL;

tstate->exc_traceback = NULL;

tstate->c_profilefunc = NULL;

tstate->c_tracefunc = NULL;

tstate->c_profileobj = NULL;

tstate->c_traceobj = NULL;

HEAD_LOCK();

tstate->next = interp->tstate_head;

interp->tstate_head = tstate;

HEAD_UNLOCK();

}

return tstate;

}

PyThreadState_Clear(PyThreadState *tstate)

{

if (Py_VerboseFlag && tstate->frame != NULL)

fprintf(stderr,

"PyThreadState_Clear: warning: thread still has a frame\n");

ZAP(tstate->frame);

ZAP(tstate->dict);

ZAP(tstate->async_exc);

ZAP(tstate->curexc_type);

ZAP(tstate->curexc_value);

ZAP(tstate->curexc_traceback);

ZAP(tstate->exc_type);

ZAP(tstate->exc_value);

ZAP(tstate->exc_traceback);

tstate->c_profilefunc = NULL;

tstate->c_tracefunc = NULL;

ZAP(tstate->c_profileobj);

ZAP(tstate->c_traceobj);

}

static void

tstate_delete_common(PyThreadState *tstate)

{

PyInterpreterState *interp;

PyThreadState **p;

if (tstate == NULL)

Py_FatalError("PyThreadState_Delete: NULL tstate");

interp = tstate->interp;

if (interp == NULL)

Py_FatalError("PyThreadState_Delete: NULL interp");

HEAD_LOCK();

for (p = &interp->tstate_head; ; p = &(*p)->next) {

if (*p == NULL)

Py_FatalError(

"PyThreadState_Delete: invalid tstate");

if (*p == tstate)

break;

}

*p = tstate->next;

HEAD_UNLOCK();

free(tstate);

}

PyThreadState_Delete(PyThreadState *tstate)

{

if (tstate == _PyThreadState_Current)

Py_FatalError("PyThreadState_Delete: tstate is still current");

tstate_delete_common(tstate);

}

#ifdef WITH_THREAD

PyThreadState_DeleteCurrent()

{

PyThreadState *tstate = _PyThreadState_Current;

if (tstate == NULL)

Py_FatalError(

"PyThreadState_DeleteCurrent: no current tstate");

_PyThreadState_Current = NULL;

tstate_delete_common(tstate);

PyEval_ReleaseLock();

}

#endif /* WITH_THREAD */

PyThreadState *

PyThreadState_Get(void)

{

if (_PyThreadState_Current == NULL)

Py_FatalError("PyThreadState_Get: no current thread");

return _PyThreadState_Current;

}

PyThreadState *

PyThreadState_Swap(PyThreadState *new)

{

PyThreadState *old = _PyThreadState_Current;

_PyThreadState_Current = new;

/* It should not be possible for more than one thread state

#if defined(Py_DEBUG) && defined(WITH_THREAD)

if (new) {

PyThreadState *check = PyGILState_GetThisThreadState();

if (check && check != new)

Py_FatalError("Invalid thread state for this thread");

}

return old;

}

PyObject *

PyThreadState_GetDict(void)

{

if (_PyThreadState_Current == NULL)

return NULL;

if (_PyThreadState_Current->dict == NULL) {

PyObject *d;

_PyThreadState_Current->dict = d = PyDict_New();

if (d == NULL)

PyErr_Clear();

}

return _PyThreadState_Current->dict;

}

PyThreadState_SetAsyncExc(long id, PyObject *exc) {

PyThreadState *tstate = PyThreadState_GET();

PyInterpreterState *interp = tstate->interp;

PyThreadState *p;

int count = 0;

for (p = interp->tstate_head; p != NULL; p = p->next) {

if (p->thread_id != id)

continue;

ZAP(p->async_exc);

Py_XINCREF(exc);

p->async_exc = exc;

count += 1;

}

return count;

}

PyInterpreterState *

PyInterpreterState_Head(void)

{

return interp_head;

}

PyInterpreterState *

PyInterpreterState_Next(PyInterpreterState *interp) {

return interp->next;

}

PyThreadState *

PyInterpreterState_ThreadHead(PyInterpreterState *interp) {

return interp->tstate_head;

}

PyThreadState *

PyThreadState_Next(PyThreadState *tstate) {

return tstate->next;

}

#ifdef WITH_THREAD

static int

PyThreadState_IsCurrent(PyThreadState *tstate)

{

/* Must be the tstate for this thread */

assert(PyGILState_GetThisThreadState()==tstate);

/* On Windows at least, simple reads and writes to 32 bit values

return tstate == _PyThreadState_Current;

}

static PyInterpreterState *autoInterpreterState = NULL;

static int autoTLSkey = 0;

_PyGILState_Init(PyInterpreterState *i, PyThreadState *t)

{

assert(i && t); /* must init with valid states */

autoTLSkey = PyThread_create_key();

autoInterpreterState = i;

/* Now stash the thread state for this thread in TLS */

assert(PyThread_get_key_value(autoTLSkey) == NULL);

if (PyThread_set_key_value(autoTLSkey, (void *)t) < 0)

Py_FatalError("Couldn't create autoTLSkey mapping");

assert(t->gilstate_counter == 0); /* must be a new thread state */

t->gilstate_counter = 1;

}

_PyGILState_Fini(void)

{

PyThread_delete_key(autoTLSkey);

autoTLSkey = 0;

autoInterpreterState = NULL;;

}

PyThreadState *

PyGILState_GetThisThreadState(void)

{

if (autoInterpreterState == NULL || autoTLSkey == 0)

return NULL;

return (PyThreadState *)PyThread_get_key_value(autoTLSkey);

}

PyGILState_Ensure(void)

{

int current;

PyThreadState *tcur;

/* Note that we do not auto-init Python here - apart from

assert(autoInterpreterState); /* Py_Initialize() hasn't been called! */

tcur = PyThread_get_key_value(autoTLSkey);

if (tcur == NULL) {

/* Create a new thread state for this thread */

tcur = PyThreadState_New(autoInterpreterState);

if (tcur == NULL)

Py_FatalError("Couldn't create thread-state for new thread");

if (PyThread_set_key_value(autoTLSkey, (void *)tcur) < 0)

Py_FatalError("Couldn't create autoTLSkey mapping");

current = 0; /* new thread state is never current */

}

else

current = PyThreadState_IsCurrent(tcur);

if (current == 0)

PyEval_RestoreThread(tcur);

/* Update our counter in the thread-state - no need for locks:

++tcur->gilstate_counter;

return current ? PyGILState_LOCKED : PyGILState_UNLOCKED;

}

PyGILState_Release(PyGILState_STATE oldstate)

{

PyThreadState *tcur = PyThread_get_key_value(autoTLSkey);

if (tcur == NULL)

Py_FatalError("auto-releasing thread-state, "

"but no thread-state for this thread");

/* We must hold the GIL and have our thread state current */

/* XXX - remove the check - the assert should be fine,

if (! PyThreadState_IsCurrent(tcur))

Py_FatalError("This thread state must be current when releasing");

assert(PyThreadState_IsCurrent(tcur));

--tcur->gilstate_counter;

assert(tcur->gilstate_counter >= 0); /* illegal counter value */

/* If we're going to destroy this thread-state, we must

if (tcur->gilstate_counter == 0) {

/* can't have been locked when we created it */

assert(oldstate == PyGILState_UNLOCKED);

PyThreadState_Clear(tcur);

/* Delete the thread-state. Note this releases the GIL too!

PyThreadState_DeleteCurrent();

/* Delete this thread from our TLS. */

PyThread_delete_key_value(autoTLSkey);

}

/* Release the lock if necessary */

else if (oldstate == PyGILState_UNLOCKED)

PyEval_ReleaseThread(tcur);

}

#endif /* WITH_THREAD */