#include "Python.h"

#include "pycore_interp.h" // _PyInterpreterState.threads.count

#include "pycore_moduleobject.h" // _PyModule_GetState()

#include "pycore_pylifecycle.h"

#include "pycore_pystate.h" // _PyThreadState_SetCurrent()

#include <stddef.h> // offsetof()

#include "structmember.h" // PyMemberDef

#ifdef HAVE_SIGNAL_H

# include <signal.h> // SIGINT

#define ThreadError PyExc_RuntimeError

static struct PyModuleDef thread_module;

typedef struct {

PyTypeObject *excepthook_type;

PyTypeObject *lock_type;

PyTypeObject *local_type;

PyTypeObject *local_dummy_type;

} thread_module_state;

static inline thread_module_state*

get_thread_state(PyObject *module)

{

void *state = _PyModule_GetState(module);

assert(state != NULL);

return (thread_module_state *)state;

}

typedef struct {

PyObject_HEAD

PyThread_type_lock lock_lock;

PyObject *in_weakreflist;

char locked; /* for sanity checking */

} lockobject;

static int

lock_traverse(lockobject *self, visitproc visit, void *arg)

{

Py_VISIT(Py_TYPE(self));

return 0;

}

static void

lock_dealloc(lockobject *self)

{

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

}

PyTypeObject *tp = Py_TYPE(self);

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

Py_DECREF(tp);

}

static PyLockStatus

acquire_timed(PyThread_type_lock lock, _PyTime_t timeout)

{

_PyTime_t endtime = 0;

if (timeout > 0) {

endtime = _PyDeadline_Init(timeout);

}

PyLockStatus r;

do {

_PyTime_t microseconds;

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 = _PyDeadline_Get(endtime);

/* 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_TIMEOUT) < 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_TIMEOUT);

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;

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

return NULL;

PyLockStatus 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, PyObject *Py_UNUSED(ignored))

{

/* 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, PyObject *Py_UNUSED(ignored))

{

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

}

#ifdef HAVE_FORK

static PyObject *

lock__at_fork_reinit(lockobject *self, PyObject *Py_UNUSED(args))

{

if (_PyThread_at_fork_reinit(&self->lock_lock) < 0) {

PyErr_SetString(ThreadError, "failed to reinitialize lock at fork");

return NULL;

}

self->locked = 0;

Py_RETURN_NONE;

}

#endif /* HAVE_FORK */

static PyMethodDef lock_methods[] = {

{"acquire_lock", _PyCFunction_CAST(lock_PyThread_acquire_lock),

METH_VARARGS | METH_KEYWORDS, acquire_doc},

{"acquire", _PyCFunction_CAST(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_CAST(lock_PyThread_acquire_lock),

METH_VARARGS | METH_KEYWORDS, acquire_doc},

{"__exit__", (PyCFunction)lock_PyThread_release_lock,

METH_VARARGS, release_doc},

#ifdef HAVE_FORK

{"_at_fork_reinit", (PyCFunction)lock__at_fork_reinit,

METH_NOARGS, NULL},

{NULL, NULL} /* sentinel */

};

PyDoc_STRVAR(lock_doc,

will block until another thread unlocks it. Deadlocks may ensue.");

static PyMemberDef lock_type_members[] = {

{"__weaklistoffset__", T_PYSSIZET, offsetof(lockobject, in_weakreflist), READONLY},

{NULL},

};

static PyType_Slot lock_type_slots[] = {

{Py_tp_dealloc, (destructor)lock_dealloc},

{Py_tp_repr, (reprfunc)lock_repr},

{Py_tp_doc, (void *)lock_doc},

{Py_tp_methods, lock_methods},

{Py_tp_traverse, lock_traverse},

{Py_tp_members, lock_type_members},

{0, 0}

};

static PyType_Spec lock_type_spec = {

.name = "_thread.lock",

.basicsize = sizeof(lockobject),

.flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |

Py_TPFLAGS_DISALLOW_INSTANTIATION | Py_TPFLAGS_IMMUTABLETYPE),

.slots = lock_type_slots,

};

typedef struct {

PyObject_HEAD

PyThread_type_lock rlock_lock;

unsigned long rlock_owner;

unsigned long rlock_count;

PyObject *in_weakreflist;

} rlockobject;

static int

rlock_traverse(rlockobject *self, visitproc visit, void *arg)

{

Py_VISIT(Py_TYPE(self));

return 0;

}

static void

rlock_dealloc(rlockobject *self)

{

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

}

PyTypeObject *tp = Py_TYPE(self);

tp->tp_free(self);

Py_DECREF(tp);

}

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, PyObject *Py_UNUSED(ignored))

{

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, PyObject *Py_UNUSED(ignored))

{

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_recursion_count(rlockobject *self, PyObject *Py_UNUSED(ignored))

{

unsigned long tid = PyThread_get_thread_ident();

return PyLong_FromUnsignedLong(

self->rlock_owner == tid ? self->rlock_count : 0UL);

}

PyDoc_STRVAR(rlock_recursion_count_doc,

For internal use by reentrancy checks.");

static PyObject *

rlock_is_owned(rlockobject *self, PyObject *Py_UNUSED(ignored))

{

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 = (rlockobject *) type->tp_alloc(type, 0);

if (self == NULL) {

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

}

#ifdef HAVE_FORK

static PyObject *

rlock__at_fork_reinit(rlockobject *self, PyObject *Py_UNUSED(args))

{

if (_PyThread_at_fork_reinit(&self->rlock_lock) < 0) {

PyErr_SetString(ThreadError, "failed to reinitialize lock at fork");

return NULL;

}

self->rlock_owner = 0;

self->rlock_count = 0;

Py_RETURN_NONE;

}

#endif /* HAVE_FORK */

static PyMethodDef rlock_methods[] = {

{"acquire", _PyCFunction_CAST(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},

{"_recursion_count", (PyCFunction)rlock_recursion_count,

METH_NOARGS, rlock_recursion_count_doc},

{"__enter__", _PyCFunction_CAST(rlock_acquire),

METH_VARARGS | METH_KEYWORDS, rlock_acquire_doc},

{"__exit__", (PyCFunction)rlock_release,

METH_VARARGS, rlock_release_doc},

#ifdef HAVE_FORK

{"_at_fork_reinit", (PyCFunction)rlock__at_fork_reinit,

METH_NOARGS, NULL},

{NULL, NULL} /* sentinel */

};

static PyMemberDef rlock_type_members[] = {

{"__weaklistoffset__", T_PYSSIZET, offsetof(rlockobject, in_weakreflist), READONLY},

{NULL},

};

static PyType_Slot rlock_type_slots[] = {

{Py_tp_dealloc, (destructor)rlock_dealloc},

{Py_tp_repr, (reprfunc)rlock_repr},

{Py_tp_methods, rlock_methods},

{Py_tp_alloc, PyType_GenericAlloc},

{Py_tp_new, rlock_new},

{Py_tp_members, rlock_type_members},

{Py_tp_traverse, rlock_traverse},

{0, 0},

};

static PyType_Spec rlock_type_spec = {

.name = "_thread.RLock",

.basicsize = sizeof(rlockobject),

.flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE |

Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_IMMUTABLETYPE),

.slots = rlock_type_slots,

};

static lockobject *

newlockobject(PyObject *module)

{

thread_module_state *state = get_thread_state(module);

PyTypeObject *type = state->lock_type;

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

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;

}

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

PyTypeObject *tp = Py_TYPE(self);

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

Py_DECREF(tp);

}

static PyMemberDef local_dummy_type_members[] = {

{"__weaklistoffset__", T_PYSSIZET, offsetof(localdummyobject, weakreflist), READONLY},

{NULL},

};

static PyType_Slot local_dummy_type_slots[] = {

{Py_tp_dealloc, (destructor)localdummy_dealloc},

{Py_tp_doc, "Thread-local dummy"},

{Py_tp_members, local_dummy_type_members},

{0, 0}

};

static PyType_Spec local_dummy_type_spec = {

.name = "_thread._localdummy",

.basicsize = sizeof(localdummyobject),

.flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION |

Py_TPFLAGS_IMMUTABLETYPE),

.slots = local_dummy_type_slots,

};

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, thread_module_state *state);

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

static PyObject *

_local_create_dummy(localobject *self, thread_module_state *state)

{

PyObject *ldict = NULL, *wr = NULL;

localdummyobject *dummy = NULL;

PyTypeObject *type = state->local_dummy_type;

PyObject *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 *) type->tp_alloc(type, 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

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

{

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;

}

}

PyObject *module = PyType_GetModuleByDef(type, &thread_module);

thread_module_state *state = get_thread_state(module);

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

if (self == NULL) {

return NULL;

}

self->args = Py_XNewRef(args);

self->kw = Py_XNewRef(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

PyObject *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, state) == NULL) {

goto err;

}

return (PyObject *)self;

err:

Py_DECREF(self);

return NULL;

}

static int

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

{

Py_VISIT(Py_TYPE(self));

Py_VISIT(self->args);

Py_VISIT(self->kw);

Py_VISIT(self->dummies);

return 0;

}

#define HEAD_LOCK(runtime) \

PyThread_acquire_lock((runtime)->interpreters.mutex, WAIT_LOCK)

#define HEAD_UNLOCK(runtime) \

PyThread_release_lock((runtime)->interpreters.mutex)

static int

local_clear(localobject *self)

{

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

PyInterpreterState *interp = _PyInterpreterState_GET();

_PyRuntimeState *runtime = &_PyRuntime;

HEAD_LOCK(runtime);

PyThreadState *tstate = PyInterpreterState_ThreadHead(interp);

HEAD_UNLOCK(runtime);

while (tstate) {

if (tstate->dict) {

PyObject *v = _PyDict_Pop(tstate->dict, self->key, Py_None);

if (v != NULL) {

Py_DECREF(v);

}

else {

PyErr_Clear();

}

}

HEAD_LOCK(runtime);

tstate = PyThreadState_Next(tstate);

HEAD_UNLOCK(runtime);

}

}

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

PyTypeObject *tp = Py_TYPE(self);

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

Py_DECREF(tp);

}

static PyObject *

_ldict(localobject *self, thread_module_state *state)

{

PyObject *tdict = PyThreadState_GetDict();

if (tdict == NULL) {

PyErr_SetString(PyExc_SystemError,

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

return NULL;

}

PyObject *ldict;

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

if (dummy == NULL) {

if (PyErr_Occurred()) {

return NULL;

}

ldict = _local_create_dummy(self, state);

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_IS_TYPE(dummy, state->local_dummy_type));

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

}

return ldict;

}

static int

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

{

PyObject *module = PyType_GetModuleByDef(Py_TYPE(self), &thread_module);

thread_module_state *state = get_thread_state(module);

PyObject *ldict = _ldict(self, state);

if (ldict == NULL) {

return -1;

}

int r = PyObject_RichCompareBool(name, &_Py_ID(__dict__), Py_EQ);

if (r == -1) {

return -1;

}

if (r == 1) {

PyErr_Format(PyExc_AttributeError,

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

Py_TYPE(self)->tp_name, name);

return -1;

}

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

}

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

static PyMemberDef local_type_members[] = {

{"__weaklistoffset__", T_PYSSIZET, offsetof(localobject, weakreflist), READONLY},

{NULL},

};

static PyType_Slot local_type_slots[] = {

{Py_tp_dealloc, (destructor)local_dealloc},

{Py_tp_getattro, (getattrofunc)local_getattro},

{Py_tp_setattro, (setattrofunc)local_setattro},

{Py_tp_doc, "Thread-local data"},

{Py_tp_traverse, (traverseproc)local_traverse},

{Py_tp_clear, (inquiry)local_clear},

{Py_tp_new, local_new},

{Py_tp_members, local_type_members},

{0, 0}

};

static PyType_Spec local_type_spec = {

.name = "_thread._local",

.basicsize = sizeof(localobject),

.flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC |

Py_TPFLAGS_IMMUTABLETYPE),

.slots = local_type_slots,