#include "Python.h"

#include "structmember.h" /* offsetof */

#ifndef WITH_THREAD

#error "Error! The rest of Python is not compiled with thread support."

#error "Rerun configure, adding a --with-threads option."

#error "Then run `make clean' followed by `make'."

#include "pythread.h"

static PyObject *ThreadError;

static long nb_threads = 0;

static PyObject *str_dict;

_Py_IDENTIFIER(stderr);

typedef struct {

PyObject_HEAD

PyThread_type_lock lock_lock;

PyObject *in_weakreflist;

char locked; /* for sanity checking */

} lockobject;

static void

lock_dealloc(lockobject *self)

{

if (self->in_weakreflist != NULL)

PyObject_ClearWeakRefs((PyObject *) self);

if (self->lock_lock != NULL) {

/* Unlock the lock so it's safe to free it */

if (self->locked)

PyThread_release_lock(self->lock_lock);

PyThread_free_lock(self->lock_lock);

}

PyObject_Del(self);

}

static PyLockStatus

acquire_timed(PyThread_type_lock lock, _PyTime_t timeout)

{

PyLockStatus r;

_PyTime_t endtime = 0;

_PyTime_t microseconds;

if (timeout > 0)

endtime = _PyTime_GetMonotonicClock() + timeout;

do {

microseconds = _PyTime_AsMicroseconds(timeout, _PyTime_ROUND_CEILING);

/* first a simple non-blocking try without releasing the GIL */

r = PyThread_acquire_lock_timed(lock, 0, 0);

if (r == PY_LOCK_FAILURE && microseconds != 0) {

Py_BEGIN_ALLOW_THREADS

r = PyThread_acquire_lock_timed(lock, microseconds, 1);

Py_END_ALLOW_THREADS

}

if (r == PY_LOCK_INTR) {

/* Run signal handlers if we were interrupted. Propagate

if (Py_MakePendingCalls() < 0) {

return PY_LOCK_INTR;

}

/* If we're using a timeout, recompute the timeout after processing

if (timeout > 0) {

timeout = endtime - _PyTime_GetMonotonicClock();

/* Check for negative values, since those mean block forever.

if (timeout < 0) {

r = PY_LOCK_FAILURE;

}

}

}

} while (r == PY_LOCK_INTR); /* Retry if we were interrupted. */

return r;

}

static int

lock_acquire_parse_args(PyObject *args, PyObject *kwds,

_PyTime_t *timeout)

{

char *kwlist[] = {"blocking", "timeout", NULL};

int blocking = 1;

PyObject *timeout_obj = NULL;

const _PyTime_t unset_timeout = _PyTime_FromSeconds(-1);

*timeout = unset_timeout ;

if (!PyArg_ParseTupleAndKeywords(args, kwds, "|iO:acquire", kwlist,

&blocking, &timeout_obj))

return -1;

if (timeout_obj

&& _PyTime_FromSecondsObject(timeout,

timeout_obj, _PyTime_ROUND_CEILING) < 0)

return -1;

if (!blocking && *timeout != unset_timeout ) {

PyErr_SetString(PyExc_ValueError,

"can't specify a timeout for a non-blocking call");

return -1;

}

if (*timeout < 0 && *timeout != unset_timeout) {

PyErr_SetString(PyExc_ValueError,

"timeout value must be positive");

return -1;

}

if (!blocking)

*timeout = 0;

else if (*timeout != unset_timeout) {

_PyTime_t microseconds;

microseconds = _PyTime_AsMicroseconds(*timeout, _PyTime_ROUND_CEILING);

if (microseconds >= PY_TIMEOUT_MAX) {

PyErr_SetString(PyExc_OverflowError,

"timeout value is too large");

return -1;

}

}

return 0;

}

static PyObject *

lock_PyThread_acquire_lock(lockobject *self, PyObject *args, PyObject *kwds)

{

_PyTime_t timeout;

PyLockStatus r;

if (lock_acquire_parse_args(args, kwds, &timeout) < 0)

return NULL;

r = acquire_timed(self->lock_lock, timeout);

if (r == PY_LOCK_INTR) {

return NULL;

}

if (r == PY_LOCK_ACQUIRED)

self->locked = 1;

return PyBool_FromLong(r == PY_LOCK_ACQUIRED);

}

PyDoc_STRVAR(acquire_doc,

The blocking operation is interruptible.");

static PyObject *

lock_PyThread_release_lock(lockobject *self)

{

/* Sanity check: the lock must be locked */

if (!self->locked) {

PyErr_SetString(ThreadError, "release unlocked lock");

return NULL;

}

PyThread_release_lock(self->lock_lock);

self->locked = 0;

Py_RETURN_NONE;

}

PyDoc_STRVAR(release_doc,

but it needn't be locked by the same thread that unlocks it.");

static PyObject *

lock_locked_lock(lockobject *self)

{

return PyBool_FromLong((long)self->locked);

}

PyDoc_STRVAR(locked_doc,

Return whether the lock is in the locked state.");

static PyObject *

lock_repr(lockobject *self)

{

return PyUnicode_FromFormat("<%s %s object at %p>",

self->locked ? "locked" : "unlocked", Py_TYPE(self)->tp_name, self);

}

static PyMethodDef lock_methods[] = {

{"acquire_lock", (PyCFunction)lock_PyThread_acquire_lock,

METH_VARARGS | METH_KEYWORDS, acquire_doc},

{"acquire", (PyCFunction)lock_PyThread_acquire_lock,

METH_VARARGS | METH_KEYWORDS, acquire_doc},

{"release_lock", (PyCFunction)lock_PyThread_release_lock,

METH_NOARGS, release_doc},

{"release", (PyCFunction)lock_PyThread_release_lock,

METH_NOARGS, release_doc},

{"locked_lock", (PyCFunction)lock_locked_lock,

METH_NOARGS, locked_doc},

{"locked", (PyCFunction)lock_locked_lock,

METH_NOARGS, locked_doc},

{"__enter__", (PyCFunction)lock_PyThread_acquire_lock,

METH_VARARGS | METH_KEYWORDS, acquire_doc},

{"__exit__", (PyCFunction)lock_PyThread_release_lock,

METH_VARARGS, release_doc},

{NULL, NULL} /* sentinel */

};

static PyTypeObject Locktype = {

PyVarObject_HEAD_INIT(&PyType_Type, 0)

"_thread.lock", /*tp_name*/

sizeof(lockobject), /*tp_size*/

0, /*tp_itemsize*/

/* methods */

(destructor)lock_dealloc, /*tp_dealloc*/

0, /*tp_print*/

0, /*tp_getattr*/

0, /*tp_setattr*/

0, /*tp_reserved*/

(reprfunc)lock_repr, /*tp_repr*/

0, /*tp_as_number*/

0, /*tp_as_sequence*/

0, /*tp_as_mapping*/

0, /*tp_hash*/

0, /*tp_call*/

0, /*tp_str*/

0, /*tp_getattro*/

0, /*tp_setattro*/

0, /*tp_as_buffer*/

Py_TPFLAGS_DEFAULT, /*tp_flags*/

0, /*tp_doc*/

0, /*tp_traverse*/

0, /*tp_clear*/

0, /*tp_richcompare*/

offsetof(lockobject, in_weakreflist), /*tp_weaklistoffset*/

0, /*tp_iter*/

0, /*tp_iternext*/

lock_methods, /*tp_methods*/

};

typedef struct {

PyObject_HEAD

PyThread_type_lock rlock_lock;

unsigned long rlock_owner;

unsigned long rlock_count;

PyObject *in_weakreflist;

} rlockobject;

static void

rlock_dealloc(rlockobject *self)

{

if (self->in_weakreflist != NULL)

PyObject_ClearWeakRefs((PyObject *) self);

/* self->rlock_lock can be NULL if PyThread_allocate_lock() failed

if (self->rlock_lock != NULL) {

/* Unlock the lock so it's safe to free it */

if (self->rlock_count > 0)

PyThread_release_lock(self->rlock_lock);

PyThread_free_lock(self->rlock_lock);

}

Py_TYPE(self)->tp_free(self);

}

static PyObject *

rlock_acquire(rlockobject *self, PyObject *args, PyObject *kwds)

{

_PyTime_t timeout;

unsigned long tid;

PyLockStatus r = PY_LOCK_ACQUIRED;

if (lock_acquire_parse_args(args, kwds, &timeout) < 0)

return NULL;

tid = PyThread_get_thread_ident();

if (self->rlock_count > 0 && tid == self->rlock_owner) {

unsigned long count = self->rlock_count + 1;

if (count <= self->rlock_count) {

PyErr_SetString(PyExc_OverflowError,

"Internal lock count overflowed");

return NULL;

}

self->rlock_count = count;

Py_RETURN_TRUE;

}

r = acquire_timed(self->rlock_lock, timeout);

if (r == PY_LOCK_ACQUIRED) {

assert(self->rlock_count == 0);

self->rlock_owner = tid;

self->rlock_count = 1;

}

else if (r == PY_LOCK_INTR) {

return NULL;

}

return PyBool_FromLong(r == PY_LOCK_ACQUIRED);

}

PyDoc_STRVAR(rlock_acquire_doc,

the lock is taken and its internal counter initialized to 1.");

static PyObject *

rlock_release(rlockobject *self)

{

unsigned long tid = PyThread_get_thread_ident();

if (self->rlock_count == 0 || self->rlock_owner != tid) {

PyErr_SetString(PyExc_RuntimeError,

"cannot release un-acquired lock");

return NULL;

}

if (--self->rlock_count == 0) {

self->rlock_owner = 0;

PyThread_release_lock(self->rlock_lock);

}

Py_RETURN_NONE;

}

PyDoc_STRVAR(rlock_release_doc,

to be available for other threads.");

static PyObject *

rlock_acquire_restore(rlockobject *self, PyObject *args)

{

unsigned long owner;

unsigned long count;

int r = 1;

if (!PyArg_ParseTuple(args, "(kk):_acquire_restore", &count, &owner))

return NULL;

if (!PyThread_acquire_lock(self->rlock_lock, 0)) {

Py_BEGIN_ALLOW_THREADS

r = PyThread_acquire_lock(self->rlock_lock, 1);

Py_END_ALLOW_THREADS

}

if (!r) {

PyErr_SetString(ThreadError, "couldn't acquire lock");

return NULL;

}

assert(self->rlock_count == 0);

self->rlock_owner = owner;

self->rlock_count = count;

Py_RETURN_NONE;

}

PyDoc_STRVAR(rlock_acquire_restore_doc,

For internal use by `threading.Condition`.");

static PyObject *

rlock_release_save(rlockobject *self)

{

unsigned long owner;

unsigned long count;

if (self->rlock_count == 0) {

PyErr_SetString(PyExc_RuntimeError,

"cannot release un-acquired lock");

return NULL;

}

owner = self->rlock_owner;

count = self->rlock_count;

self->rlock_count = 0;

self->rlock_owner = 0;

PyThread_release_lock(self->rlock_lock);

return Py_BuildValue("kk", count, owner);

}

PyDoc_STRVAR(rlock_release_save_doc,

For internal use by `threading.Condition`.");

static PyObject *

rlock_is_owned(rlockobject *self)

{

unsigned long tid = PyThread_get_thread_ident();

if (self->rlock_count > 0 && self->rlock_owner == tid) {

Py_RETURN_TRUE;

}

Py_RETURN_FALSE;

}

PyDoc_STRVAR(rlock_is_owned_doc,

For internal use by `threading.Condition`.");

static PyObject *

rlock_new(PyTypeObject *type, PyObject *args, PyObject *kwds)

{

rlockobject *self;

self = (rlockobject *) type->tp_alloc(type, 0);

if (self != NULL) {

self->in_weakreflist = NULL;

self->rlock_owner = 0;

self->rlock_count = 0;

self->rlock_lock = PyThread_allocate_lock();

if (self->rlock_lock == NULL) {

Py_DECREF(self);

PyErr_SetString(ThreadError, "can't allocate lock");

return NULL;

}

}

return (PyObject *) self;

}

static PyObject *

rlock_repr(rlockobject *self)

{

return PyUnicode_FromFormat("<%s %s object owner=%ld count=%lu at %p>",

self->rlock_count ? "locked" : "unlocked",

Py_TYPE(self)->tp_name, self->rlock_owner,

self->rlock_count, self);

}

static PyMethodDef rlock_methods[] = {

{"acquire", (PyCFunction)rlock_acquire,

METH_VARARGS | METH_KEYWORDS, rlock_acquire_doc},

{"release", (PyCFunction)rlock_release,

METH_NOARGS, rlock_release_doc},

{"_is_owned", (PyCFunction)rlock_is_owned,

METH_NOARGS, rlock_is_owned_doc},

{"_acquire_restore", (PyCFunction)rlock_acquire_restore,

METH_VARARGS, rlock_acquire_restore_doc},

{"_release_save", (PyCFunction)rlock_release_save,

METH_NOARGS, rlock_release_save_doc},

{"__enter__", (PyCFunction)rlock_acquire,

METH_VARARGS | METH_KEYWORDS, rlock_acquire_doc},

{"__exit__", (PyCFunction)rlock_release,

METH_VARARGS, rlock_release_doc},

{NULL, NULL} /* sentinel */

};

static PyTypeObject RLocktype = {

PyVarObject_HEAD_INIT(&PyType_Type, 0)

"_thread.RLock", /*tp_name*/

sizeof(rlockobject), /*tp_size*/

0, /*tp_itemsize*/

/* methods */

(destructor)rlock_dealloc, /*tp_dealloc*/

0, /*tp_print*/

0, /*tp_getattr*/

0, /*tp_setattr*/

0, /*tp_reserved*/

(reprfunc)rlock_repr, /*tp_repr*/

0, /*tp_as_number*/

0, /*tp_as_sequence*/

0, /*tp_as_mapping*/

0, /*tp_hash*/

0, /*tp_call*/

0, /*tp_str*/

0, /*tp_getattro*/

0, /*tp_setattro*/

0, /*tp_as_buffer*/

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */

0, /*tp_doc*/

0, /*tp_traverse*/

0, /*tp_clear*/

0, /*tp_richcompare*/

offsetof(rlockobject, in_weakreflist), /*tp_weaklistoffset*/

0, /*tp_iter*/

0, /*tp_iternext*/

rlock_methods, /*tp_methods*/

0, /* tp_members */

0, /* tp_getset */

0, /* tp_base */

0, /* tp_dict */

0, /* tp_descr_get */

0, /* tp_descr_set */

0, /* tp_dictoffset */

0, /* tp_init */

PyType_GenericAlloc, /* tp_alloc */

rlock_new /* tp_new */

};

static lockobject *

newlockobject(void)

{

lockobject *self;

self = PyObject_New(lockobject, &Locktype);

if (self == NULL)

return NULL;

self->lock_lock = PyThread_allocate_lock();

self->locked = 0;

self->in_weakreflist = NULL;

if (self->lock_lock == NULL) {

Py_DECREF(self);

PyErr_SetString(ThreadError, "can't allocate lock");

return NULL;

}

return self;

}

#include "structmember.h"

typedef struct {

PyObject_HEAD

PyObject *localdict; /* Borrowed reference! */

PyObject *weakreflist; /* List of weak references to self */

} localdummyobject;

static void

localdummy_dealloc(localdummyobject *self)

{

if (self->weakreflist != NULL)

PyObject_ClearWeakRefs((PyObject *) self);

Py_TYPE(self)->tp_free((PyObject*)self);

}

static PyTypeObject localdummytype = {

PyVarObject_HEAD_INIT(NULL, 0)

/* tp_name */ "_thread._localdummy",

/* tp_basicsize */ sizeof(localdummyobject),

/* tp_itemsize */ 0,

/* tp_dealloc */ (destructor)localdummy_dealloc,

/* tp_print */ 0,

/* tp_getattr */ 0,

/* tp_setattr */ 0,

/* tp_reserved */ 0,

/* tp_repr */ 0,

/* tp_as_number */ 0,

/* tp_as_sequence */ 0,

/* tp_as_mapping */ 0,

/* tp_hash */ 0,

/* tp_call */ 0,

/* tp_str */ 0,

/* tp_getattro */ 0,

/* tp_setattro */ 0,

/* tp_as_buffer */ 0,

/* tp_flags */ Py_TPFLAGS_DEFAULT,

/* tp_doc */ "Thread-local dummy",

/* tp_traverse */ 0,

/* tp_clear */ 0,

/* tp_richcompare */ 0,

/* tp_weaklistoffset */ offsetof(localdummyobject, weakreflist)

};

typedef struct {

PyObject_HEAD

PyObject *key;

PyObject *args;

PyObject *kw;

PyObject *weakreflist; /* List of weak references to self */

/* A {localdummy weakref -> localdict} dict */

PyObject *dummies;

/* The callback for weakrefs to localdummies */

PyObject *wr_callback;

} localobject;

static PyObject *_ldict(localobject *self);

static PyObject *_localdummy_destroyed(PyObject *meth_self, PyObject *dummyweakref);

static PyObject *

_local_create_dummy(localobject *self)

{

PyObject *tdict, *ldict = NULL, *wr = NULL;

localdummyobject *dummy = NULL;

int r;

tdict = PyThreadState_GetDict();

if (tdict == NULL) {

PyErr_SetString(PyExc_SystemError,

"Couldn't get thread-state dictionary");

goto err;

}

ldict = PyDict_New();

if (ldict == NULL)

goto err;

dummy = (localdummyobject *) localdummytype.tp_alloc(&localdummytype, 0);

if (dummy == NULL)

goto err;

dummy->localdict = ldict;

wr = PyWeakref_NewRef((PyObject *) dummy, self->wr_callback);

if (wr == NULL)

goto err;

/* As a side-effect, this will cache the weakref's hash before the

r = PyDict_SetItem(self->dummies, wr, ldict);

if (r < 0)

goto err;

Py_CLEAR(wr);

r = PyDict_SetItem(tdict, self->key, (PyObject *) dummy);

if (r < 0)

goto err;

Py_CLEAR(dummy);

Py_DECREF(ldict);

return ldict;

err:

Py_XDECREF(ldict);

Py_XDECREF(wr);

Py_XDECREF(dummy);

return NULL;

}

static PyObject *

local_new(PyTypeObject *type, PyObject *args, PyObject *kw)

{

localobject *self;

PyObject *wr;

static PyMethodDef wr_callback_def = {

"_localdummy_destroyed", (PyCFunction) _localdummy_destroyed, METH_O

};

if (type->tp_init == PyBaseObject_Type.tp_init) {

int rc = 0;

if (args != NULL)

rc = PyObject_IsTrue(args);

if (rc == 0 && kw != NULL)

rc = PyObject_IsTrue(kw);

if (rc != 0) {

if (rc > 0)

PyErr_SetString(PyExc_TypeError,

"Initialization arguments are not supported");

return NULL;

}

}

self = (localobject *)type->tp_alloc(type, 0);

if (self == NULL)

return NULL;

Py_XINCREF(args);

self->args = args;

Py_XINCREF(kw);

self->kw = kw;

self->key = PyUnicode_FromFormat("thread.local.%p", self);

if (self->key == NULL)

goto err;

self->dummies = PyDict_New();

if (self->dummies == NULL)

goto err;

/* We use a weak reference to self in the callback closure

wr = PyWeakref_NewRef((PyObject *) self, NULL);

if (wr == NULL)

goto err;

self->wr_callback = PyCFunction_NewEx(&wr_callback_def, wr, NULL);

Py_DECREF(wr);

if (self->wr_callback == NULL)

goto err;

if (_local_create_dummy(self) == NULL)

goto err;

return (PyObject *)self;

err:

Py_DECREF(self);

return NULL;

}

static int

local_traverse(localobject *self, visitproc visit, void *arg)

{

Py_VISIT(self->args);

Py_VISIT(self->kw);

Py_VISIT(self->dummies);

return 0;

}

static int

local_clear(localobject *self)

{

PyThreadState *tstate;

Py_CLEAR(self->args);

Py_CLEAR(self->kw);

Py_CLEAR(self->dummies);

Py_CLEAR(self->wr_callback);

/* Remove all strong references to dummies from the thread states */

if (self->key

&& (tstate = PyThreadState_Get())

&& tstate->interp) {

for(tstate = PyInterpreterState_ThreadHead(tstate->interp);

tstate;

tstate = PyThreadState_Next(tstate))

if (tstate->dict &&

PyDict_GetItem(tstate->dict, self->key))

PyDict_DelItem(tstate->dict, self->key);

}

return 0;

}

static void

local_dealloc(localobject *self)

{

/* Weakrefs must be invalidated right now, otherwise they can be used

if (self->weakreflist != NULL)

PyObject_ClearWeakRefs((PyObject *) self);

PyObject_GC_UnTrack(self);

local_clear(self);

Py_XDECREF(self->key);

Py_TYPE(self)->tp_free((PyObject*)self);

}

static PyObject *

_ldict(localobject *self)

{

PyObject *tdict, *ldict, *dummy;

tdict = PyThreadState_GetDict();

if (tdict == NULL) {

PyErr_SetString(PyExc_SystemError,

"Couldn't get thread-state dictionary");

return NULL;

}

dummy = PyDict_GetItem(tdict, self->key);

if (dummy == NULL) {

ldict = _local_create_dummy(self);

if (ldict == NULL)

return NULL;

if (Py_TYPE(self)->tp_init != PyBaseObject_Type.tp_init &&

Py_TYPE(self)->tp_init((PyObject*)self,

self->args, self->kw) < 0) {

/* we need to get rid of ldict from thread so

PyDict_DelItem(tdict, self->key);

return NULL;

}

}

else {

assert(Py_TYPE(dummy) == &localdummytype);

ldict = ((localdummyobject *) dummy)->localdict;

}

return ldict;

}

static int

local_setattro(localobject *self, PyObject *name, PyObject *v)

{

PyObject *ldict;

int r;

ldict = _ldict(self);

if (ldict == NULL)

return -1;

r = PyObject_RichCompareBool(name, str_dict, Py_EQ);

if (r == 1) {

PyErr_Format(PyExc_AttributeError,

"'%.50s' object attribute '%U' is read-only",

Py_TYPE(self)->tp_name, name);

return -1;

}

if (r == -1)

return -1;

return _PyObject_GenericSetAttrWithDict((PyObject *)self, name, v, ldict);

}

static PyObject *local_getattro(localobject *, PyObject *);

static PyTypeObject localtype = {

PyVarObject_HEAD_INIT(NULL, 0)

/* tp_name */ "_thread._local",

/* tp_basicsize */ sizeof(localobject),

/* tp_itemsize */ 0,

/* tp_dealloc */ (destructor)local_dealloc,

/* tp_print */ 0,

/* tp_getattr */ 0,

/* tp_setattr */ 0,

/* tp_reserved */ 0,

/* tp_repr */ 0,

/* tp_as_number */ 0,

/* tp_as_sequence */ 0,

/* tp_as_mapping */ 0,

/* tp_hash */ 0,

/* tp_call */ 0,

/* tp_str */ 0,

/* tp_getattro */ (getattrofunc)local_getattro,

/* tp_setattro */ (setattrofunc)local_setattro,

/* tp_as_buffer */ 0,

/* tp_flags */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE

| Py_TPFLAGS_HAVE_GC,

/* tp_doc */ "Thread-local data",

/* tp_traverse */ (traverseproc)local_traverse,

/* tp_clear */ (inquiry)local_clear,

/* tp_richcompare */ 0,

/* tp_weaklistoffset */ offsetof(localobject, weakreflist),

/* tp_iter */ 0,

/* tp_iternext */ 0,

/* tp_methods */ 0,

/* tp_members */ 0,

/* tp_getset */ 0,

/* tp_base */ 0,

/* tp_dict */ 0, /* internal use */

/* tp_descr_get */ 0,

/* tp_descr_set */ 0,

/* tp_dictoffset */ 0,

/* tp_init */ 0,

/* tp_alloc */ 0,

/* tp_new */ local_new,

/* tp_free */ 0, /* Low-level free-mem routine */

/* tp_is_gc */ 0, /* For PyObject_IS_GC */

};

static PyObject *

local_getattro(localobject *self, PyObject *name)

{

PyObject *ldict, *value;

int r;

ldict = _ldict(self);

if (ldict == NULL)

return NULL;

r = PyObject_RichCompareBool(name, str_dict, Py_EQ);

if (r == 1) {

Py_INCREF(ldict);

return ldict;

}

if (r == -1)

return NULL;

if (Py_TYPE(self) != &localtype)

/* use generic lookup for subtypes */

return _PyObject_GenericGetAttrWithDict((PyObject *)self, name, ldict);

/* Optimization: just look in dict ourselves */

value = PyDict_GetItem(ldict, name);

if (value == NULL)

/* Fall back on generic to get __class__ and __dict__ */

return _PyObject_GenericGetAttrWithDict((PyObject *)self, name, ldict);

Py_INCREF(value);

return value;

}

static PyObject *

_localdummy_destroyed(PyObject *localweakref, PyObject *dummyweakref)

{

PyObject *obj;

localobject *self;

assert(PyWeakref_CheckRef(localweakref));

obj = PyWeakref_GET_OBJECT(localweakref);

if (obj == Py_None)

Py_RETURN_NONE;

Py_INCREF(obj);

assert(PyObject_TypeCheck(obj, &localtype));

/* If the thread-local object is still alive and not being cleared,

self = (localobject *) obj;

if (self->dummies != NULL) {

PyObject *ldict;

ldict = PyDict_GetItem(self->dummies, dummyweakref);

if (ldict != NULL) {

PyDict_DelItem(self->dummies, dummyweakref);

}

if (PyErr_Occurred())

PyErr_WriteUnraisable(obj);

}

Py_DECREF(obj);

Py_RETURN_NONE;

}

struct bootstate {

};

static void

t_bootstrap(void *boot_raw)

{

struct bootstate *boot = (struct bootstate *) boot_raw;

PyThreadState *tstate;

PyObject *res;

tstate = boot->tstate;

tstate->thread_id = PyThread_get_thread_ident();

_PyThreadState_Init(tstate);

PyEval_AcquireThread(tstate);

nb_threads++;

res = PyObject_Call(boot->func, boot->args, boot->keyw);

if (res == NULL) {

if (PyErr_ExceptionMatches(PyExc_SystemExit))

PyErr_Clear();