#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

# include "pycore_gc.h" // PyGC_Head

# include "pycore_runtime.h" // _Py_ID()

#include "pycore_modsupport.h" // _PyArg_UnpackKeywords()

PyDoc_STRVAR(_thread_lock_acquire__doc__,

"The blocking operation is interruptible.");

#define _THREAD_LOCK_ACQUIRE_METHODDEF \

{"acquire", _PyCFunction_CAST(_thread_lock_acquire), METH_FASTCALL|METH_KEYWORDS, _thread_lock_acquire__doc__},

static PyObject *

_thread_lock_acquire_impl(lockobject *self, int blocking,

PyObject *timeoutobj);

static PyObject *

_thread_lock_acquire(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

#define NUM_KEYWORDS 2

static struct {

PyGC_Head _this_is_not_used;

PyObject_VAR_HEAD

Py_hash_t ob_hash;

PyObject *ob_item[NUM_KEYWORDS];

} _kwtuple = {

.ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)

.ob_hash = -1,

.ob_item = { &_Py_ID(blocking), &_Py_ID(timeout), },

};

#undef NUM_KEYWORDS

#define KWTUPLE (&_kwtuple.ob_base.ob_base)

#else // !Py_BUILD_CORE

# define KWTUPLE NULL

#endif // !Py_BUILD_CORE

static const char * const _keywords[] = {"blocking", "timeout", NULL};

static _PyArg_Parser _parser = {

.keywords = _keywords,

.fname = "acquire",

.kwtuple = KWTUPLE,

};

#undef KWTUPLE

PyObject *argsbuf[2];

Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;

int blocking = 1;

PyObject *timeoutobj = NULL;

args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,

/*minpos*/ 0, /*maxpos*/ 2, /*minkw*/ 0, /*varpos*/ 0, argsbuf);

if (!args) {

goto exit;

}

if (!noptargs) {

goto skip_optional_pos;

}

if (args[0]) {

blocking = PyObject_IsTrue(args[0]);

if (blocking < 0) {

goto exit;

}

if (!--noptargs) {

goto skip_optional_pos;

}

}

timeoutobj = args[1];

skip_optional_pos:

return_value = _thread_lock_acquire_impl((lockobject *)self, blocking, timeoutobj);

exit:

return return_value;

}

PyDoc_STRVAR(_thread_lock_acquire_lock__doc__,

"An obsolete synonym of acquire().");

#define _THREAD_LOCK_ACQUIRE_LOCK_METHODDEF \

{"acquire_lock", _PyCFunction_CAST(_thread_lock_acquire_lock), METH_FASTCALL|METH_KEYWORDS, _thread_lock_acquire_lock__doc__},

static PyObject *

_thread_lock_acquire_lock_impl(lockobject *self, int blocking,

PyObject *timeoutobj);

static PyObject *

_thread_lock_acquire_lock(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

#define NUM_KEYWORDS 2

static struct {

PyGC_Head _this_is_not_used;

PyObject_VAR_HEAD

Py_hash_t ob_hash;

PyObject *ob_item[NUM_KEYWORDS];

} _kwtuple = {

.ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)

.ob_hash = -1,

.ob_item = { &_Py_ID(blocking), &_Py_ID(timeout), },

};

#undef NUM_KEYWORDS

#define KWTUPLE (&_kwtuple.ob_base.ob_base)

#else // !Py_BUILD_CORE

# define KWTUPLE NULL

#endif // !Py_BUILD_CORE

static const char * const _keywords[] = {"blocking", "timeout", NULL};

static _PyArg_Parser _parser = {

.keywords = _keywords,

.fname = "acquire_lock",

.kwtuple = KWTUPLE,

};

#undef KWTUPLE

PyObject *argsbuf[2];

Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;

int blocking = 1;

PyObject *timeoutobj = NULL;

args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,

/*minpos*/ 0, /*maxpos*/ 2, /*minkw*/ 0, /*varpos*/ 0, argsbuf);

if (!args) {

goto exit;

}

if (!noptargs) {

goto skip_optional_pos;

}

if (args[0]) {

blocking = PyObject_IsTrue(args[0]);

if (blocking < 0) {

goto exit;

}

if (!--noptargs) {

goto skip_optional_pos;

}

}

timeoutobj = args[1];

skip_optional_pos:

return_value = _thread_lock_acquire_lock_impl((lockobject *)self, blocking, timeoutobj);

exit:

return return_value;

}

PyDoc_STRVAR(_thread_lock_release__doc__,

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

#define _THREAD_LOCK_RELEASE_METHODDEF \

{"release", (PyCFunction)_thread_lock_release, METH_NOARGS, _thread_lock_release__doc__},

static PyObject *

_thread_lock_release_impl(lockobject *self);

static PyObject *

_thread_lock_release(PyObject *self, PyObject *Py_UNUSED(ignored))

{

return _thread_lock_release_impl((lockobject *)self);

}

PyDoc_STRVAR(_thread_lock_release_lock__doc__,

"An obsolete synonym of release().");

#define _THREAD_LOCK_RELEASE_LOCK_METHODDEF \

{"release_lock", (PyCFunction)_thread_lock_release_lock, METH_NOARGS, _thread_lock_release_lock__doc__},

static PyObject *

_thread_lock_release_lock_impl(lockobject *self);

static PyObject *

_thread_lock_release_lock(PyObject *self, PyObject *Py_UNUSED(ignored))

{

return _thread_lock_release_lock_impl((lockobject *)self);

}

PyDoc_STRVAR(_thread_lock___enter____doc__,

"Lock the lock.");

#define _THREAD_LOCK___ENTER___METHODDEF \

{"__enter__", (PyCFunction)_thread_lock___enter__, METH_NOARGS, _thread_lock___enter____doc__},

static PyObject *

_thread_lock___enter___impl(lockobject *self);

static PyObject *

_thread_lock___enter__(PyObject *self, PyObject *Py_UNUSED(ignored))

{

return _thread_lock___enter___impl((lockobject *)self);

}

PyDoc_STRVAR(_thread_lock___exit____doc__,

"Release the lock.");

#define _THREAD_LOCK___EXIT___METHODDEF \

{"__exit__", _PyCFunction_CAST(_thread_lock___exit__), METH_FASTCALL, _thread_lock___exit____doc__},

static PyObject *

_thread_lock___exit___impl(lockobject *self, PyObject *exc_type,

PyObject *exc_value, PyObject *exc_tb);

static PyObject *

_thread_lock___exit__(PyObject *self, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

PyObject *exc_type;

PyObject *exc_value;

PyObject *exc_tb;

if (!_PyArg_CheckPositional("__exit__", nargs, 3, 3)) {

goto exit;

}

exc_type = args[0];

exc_value = args[1];

exc_tb = args[2];

return_value = _thread_lock___exit___impl((lockobject *)self, exc_type, exc_value, exc_tb);

exit:

return return_value;

}

PyDoc_STRVAR(_thread_lock_locked__doc__,

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

#define _THREAD_LOCK_LOCKED_METHODDEF \

{"locked", (PyCFunction)_thread_lock_locked, METH_NOARGS, _thread_lock_locked__doc__},

static PyObject *

_thread_lock_locked_impl(lockobject *self);

static PyObject *

_thread_lock_locked(PyObject *self, PyObject *Py_UNUSED(ignored))

{

return _thread_lock_locked_impl((lockobject *)self);

}

PyDoc_STRVAR(_thread_lock_locked_lock__doc__,

"An obsolete synonym of locked().");

#define _THREAD_LOCK_LOCKED_LOCK_METHODDEF \

{"locked_lock", (PyCFunction)_thread_lock_locked_lock, METH_NOARGS, _thread_lock_locked_lock__doc__},

static PyObject *

_thread_lock_locked_lock_impl(lockobject *self);

static PyObject *

_thread_lock_locked_lock(PyObject *self, PyObject *Py_UNUSED(ignored))

{

return _thread_lock_locked_lock_impl((lockobject *)self);

}

#if defined(HAVE_FORK)

PyDoc_STRVAR(_thread_lock__at_fork_reinit__doc__,

"\n");

#define _THREAD_LOCK__AT_FORK_REINIT_METHODDEF \

{"_at_fork_reinit", (PyCFunction)_thread_lock__at_fork_reinit, METH_NOARGS, _thread_lock__at_fork_reinit__doc__},

static PyObject *

_thread_lock__at_fork_reinit_impl(lockobject *self);

static PyObject *

_thread_lock__at_fork_reinit(PyObject *self, PyObject *Py_UNUSED(ignored))

{

return _thread_lock__at_fork_reinit_impl((lockobject *)self);

}

#endif /* defined(HAVE_FORK) */

static PyObject *

lock_new_impl(PyTypeObject *type);

static PyObject *

lock_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)

{

PyObject *return_value = NULL;

PyTypeObject *base_tp = clinic_state()->lock_type;

if ((type == base_tp || type->tp_init == base_tp->tp_init) &&

!_PyArg_NoPositional("lock", args)) {

goto exit;

}

if ((type == base_tp || type->tp_init == base_tp->tp_init) &&

!_PyArg_NoKeywords("lock", kwargs)) {

goto exit;

}

return_value = lock_new_impl(type);

exit:

return return_value;

}

PyDoc_STRVAR(_thread_RLock_acquire__doc__,

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

#define _THREAD_RLOCK_ACQUIRE_METHODDEF \

{"acquire", _PyCFunction_CAST(_thread_RLock_acquire), METH_FASTCALL|METH_KEYWORDS, _thread_RLock_acquire__doc__},

static PyObject *

_thread_RLock_acquire_impl(rlockobject *self, int blocking,

PyObject *timeoutobj);

static PyObject *

_thread_RLock_acquire(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

#define NUM_KEYWORDS 2

static struct {

PyGC_Head _this_is_not_used;

PyObject_VAR_HEAD

Py_hash_t ob_hash;

PyObject *ob_item[NUM_KEYWORDS];

} _kwtuple = {

.ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)

.ob_hash = -1,

.ob_item = { &_Py_ID(blocking), &_Py_ID(timeout), },

};

#undef NUM_KEYWORDS

#define KWTUPLE (&_kwtuple.ob_base.ob_base)

#else // !Py_BUILD_CORE

# define KWTUPLE NULL

#endif // !Py_BUILD_CORE

static const char * const _keywords[] = {"blocking", "timeout", NULL};

static _PyArg_Parser _parser = {

.keywords = _keywords,

.fname = "acquire",

.kwtuple = KWTUPLE,

};

#undef KWTUPLE

PyObject *argsbuf[2];

Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;

int blocking = 1;

PyObject *timeoutobj = NULL;

args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,

/*minpos*/ 0, /*maxpos*/ 2, /*minkw*/ 0, /*varpos*/ 0, argsbuf);

if (!args) {

goto exit;

}

if (!noptargs) {

goto skip_optional_pos;

}

if (args[0]) {

blocking = PyObject_IsTrue(args[0]);

if (blocking < 0) {

goto exit;

}

if (!--noptargs) {

goto skip_optional_pos;

}

}

timeoutobj = args[1];

skip_optional_pos:

return_value = _thread_RLock_acquire_impl((rlockobject *)self, blocking, timeoutobj);

exit:

return return_value;

}

PyDoc_STRVAR(_thread_RLock___enter____doc__,

"Lock the lock.");

#define _THREAD_RLOCK___ENTER___METHODDEF \

{"__enter__", (PyCFunction)_thread_RLock___enter__, METH_NOARGS, _thread_RLock___enter____doc__},

static PyObject *

_thread_RLock___enter___impl(rlockobject *self);

static PyObject *

_thread_RLock___enter__(PyObject *self, PyObject *Py_UNUSED(ignored))

{

return _thread_RLock___enter___impl((rlockobject *)self);

}

PyDoc_STRVAR(_thread_RLock_release__doc__,

"the lock to be available for other threads.");

#define _THREAD_RLOCK_RELEASE_METHODDEF \

{"release", (PyCFunction)_thread_RLock_release, METH_NOARGS, _thread_RLock_release__doc__},

static PyObject *

_thread_RLock_release_impl(rlockobject *self);

static PyObject *

_thread_RLock_release(PyObject *self, PyObject *Py_UNUSED(ignored))

{

return _thread_RLock_release_impl((rlockobject *)self);

}

PyDoc_STRVAR(_thread_RLock___exit____doc__,

"Release the lock.");

#define _THREAD_RLOCK___EXIT___METHODDEF \

{"__exit__", _PyCFunction_CAST(_thread_RLock___exit__), METH_FASTCALL, _thread_RLock___exit____doc__},

static PyObject *

_thread_RLock___exit___impl(rlockobject *self, PyObject *exc_type,

PyObject *exc_value, PyObject *exc_tb);

static PyObject *

_thread_RLock___exit__(PyObject *self, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

PyObject *exc_type;

PyObject *exc_value;

PyObject *exc_tb;

if (!_PyArg_CheckPositional("__exit__", nargs, 3, 3)) {

goto exit;

}

exc_type = args[0];

exc_value = args[1];

exc_tb = args[2];

return_value = _thread_RLock___exit___impl((rlockobject *)self, exc_type, exc_value, exc_tb);

exit:

return return_value;

}

PyDoc_STRVAR(_thread_RLock_locked__doc__,

"Return a boolean indicating whether this object is locked right now.");

#define _THREAD_RLOCK_LOCKED_METHODDEF \

{"locked", (PyCFunction)_thread_RLock_locked, METH_NOARGS, _thread_RLock_locked__doc__},

static PyObject *

_thread_RLock_locked_impl(rlockobject *self);

static PyObject *

_thread_RLock_locked(PyObject *self, PyObject *Py_UNUSED(ignored))

{

return _thread_RLock_locked_impl((rlockobject *)self);

}

PyDoc_STRVAR(_thread_RLock__acquire_restore__doc__,

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

#define _THREAD_RLOCK__ACQUIRE_RESTORE_METHODDEF \

{"_acquire_restore", (PyCFunction)_thread_RLock__acquire_restore, METH_O, _thread_RLock__acquire_restore__doc__},

static PyObject *

_thread_RLock__acquire_restore_impl(rlockobject *self, PyObject *state);

static PyObject *

_thread_RLock__acquire_restore(PyObject *self, PyObject *state)

{

PyObject *return_value = NULL;

return_value = _thread_RLock__acquire_restore_impl((rlockobject *)self, state);

return return_value;

}

PyDoc_STRVAR(_thread_RLock__release_save__doc__,

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

#define _THREAD_RLOCK__RELEASE_SAVE_METHODDEF \

{"_release_save", (PyCFunction)_thread_RLock__release_save, METH_NOARGS, _thread_RLock__release_save__doc__},

static PyObject *

_thread_RLock__release_save_impl(rlockobject *self);

static PyObject *

_thread_RLock__release_save(PyObject *self, PyObject *Py_UNUSED(ignored))

{

return _thread_RLock__release_save_impl((rlockobject *)self);

}

PyDoc_STRVAR(_thread_RLock__recursion_count__doc__,

"For internal use by reentrancy checks.");

#define _THREAD_RLOCK__RECURSION_COUNT_METHODDEF \

{"_recursion_count", (PyCFunction)_thread_RLock__recursion_count, METH_NOARGS, _thread_RLock__recursion_count__doc__},

static PyObject *

_thread_RLock__recursion_count_impl(rlockobject *self);

static PyObject *

_thread_RLock__recursion_count(PyObject *self, PyObject *Py_UNUSED(ignored))

{

return _thread_RLock__recursion_count_impl((rlockobject *)self);

}

PyDoc_STRVAR(_thread_RLock__is_owned__doc__,

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

#define _THREAD_RLOCK__IS_OWNED_METHODDEF \

{"_is_owned", (PyCFunction)_thread_RLock__is_owned, METH_NOARGS, _thread_RLock__is_owned__doc__},

static PyObject *

_thread_RLock__is_owned_impl(rlockobject *self);

static PyObject *

_thread_RLock__is_owned(PyObject *self, PyObject *Py_UNUSED(ignored))

{

return _thread_RLock__is_owned_impl((rlockobject *)self);

}

static PyObject *

rlock_new_impl(PyTypeObject *type);

static PyObject *

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

{

PyObject *return_value = NULL;

PyTypeObject *base_tp = clinic_state()->rlock_type;

if ((type == base_tp || type->tp_init == base_tp->tp_init) &&

!_PyArg_NoPositional("RLock", args)) {

goto exit;

}

if ((type == base_tp || type->tp_init == base_tp->tp_init) &&

!_PyArg_NoKeywords("RLock", kwargs)) {

goto exit;

}

return_value = rlock_new_impl(type);

exit:

return return_value;

}

#if defined(HAVE_FORK)

PyDoc_STRVAR(_thread_RLock__at_fork_reinit__doc__,

"\n");

#define _THREAD_RLOCK__AT_FORK_REINIT_METHODDEF \

{"_at_fork_reinit", (PyCFunction)_thread_RLock__at_fork_reinit, METH_NOARGS, _thread_RLock__at_fork_reinit__doc__},

static PyObject *

_thread_RLock__at_fork_reinit_impl(rlockobject *self);

static PyObject *

_thread_RLock__at_fork_reinit(PyObject *self, PyObject *Py_UNUSED(ignored))

{

return _thread_RLock__at_fork_reinit_impl((rlockobject *)self);

}

#endif /* defined(HAVE_FORK) */

#if (defined(HAVE_PTHREAD_GETNAME_NP) || defined(HAVE_PTHREAD_GET_NAME_NP) || defined(MS_WINDOWS))

PyDoc_STRVAR(_thread__get_name__doc__,

"Get the name of the current thread.");

#define _THREAD__GET_NAME_METHODDEF \

{"_get_name", (PyCFunction)_thread__get_name, METH_NOARGS, _thread__get_name__doc__},

static PyObject *

_thread__get_name_impl(PyObject *module);

static PyObject *

_thread__get_name(PyObject *module, PyObject *Py_UNUSED(ignored))

{

return _thread__get_name_impl(module);

}

#endif /* (defined(HAVE_PTHREAD_GETNAME_NP) || defined(HAVE_PTHREAD_GET_NAME_NP) || defined(MS_WINDOWS)) */

#if (defined(HAVE_PTHREAD_SETNAME_NP) || defined(HAVE_PTHREAD_SET_NAME_NP) || defined(MS_WINDOWS))

PyDoc_STRVAR(_thread_set_name__doc__,

"Set the name of the current thread.");

#define _THREAD_SET_NAME_METHODDEF \

{"set_name", _PyCFunction_CAST(_thread_set_name), METH_FASTCALL|METH_KEYWORDS, _thread_set_name__doc__},

static PyObject *

_thread_set_name_impl(PyObject *module, PyObject *name_obj);

static PyObject *

_thread_set_name(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

#define NUM_KEYWORDS 1

static struct {

PyGC_Head _this_is_not_used;

PyObject_VAR_HEAD

Py_hash_t ob_hash;

PyObject *ob_item[NUM_KEYWORDS];

} _kwtuple = {

.ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)

.ob_hash = -1,

.ob_item = { &_Py_ID(name), },

};

#undef NUM_KEYWORDS

#define KWTUPLE (&_kwtuple.ob_base.ob_base)

#else // !Py_BUILD_CORE

# define KWTUPLE NULL

#endif // !Py_BUILD_CORE

static const char * const _keywords[] = {"name", NULL};

static _PyArg_Parser _parser = {

.keywords = _keywords,

.fname = "set_name",

.kwtuple = KWTUPLE,

};

#undef KWTUPLE

PyObject *argsbuf[1];

PyObject *name_obj;

args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,

/*minpos*/ 1, /*maxpos*/ 1, /*minkw*/ 0, /*varpos*/ 0, argsbuf);

if (!args) {

goto exit;

}

if (!PyUnicode_Check(args[0])) {

_PyArg_BadArgument("set_name", "argument 'name'", "str", args[0]);

goto exit;

}

name_obj = args[0];

return_value = _thread_set_name_impl(module, name_obj);

exit:

return return_value;

}

#endif /* (defined(HAVE_PTHREAD_SETNAME_NP) || defined(HAVE_PTHREAD_SET_NAME_NP) || defined(MS_WINDOWS)) */

#ifndef _THREAD_LOCK__AT_FORK_REINIT_METHODDEF

#define _THREAD_LOCK__AT_FORK_REINIT_METHODDEF

#endif /* !defined(_THREAD_LOCK__AT_FORK_REINIT_METHODDEF) */

#ifndef _THREAD_RLOCK__AT_FORK_REINIT_METHODDEF

#define _THREAD_RLOCK__AT_FORK_REINIT_METHODDEF

#endif /* !defined(_THREAD_RLOCK__AT_FORK_REINIT_METHODDEF) */

#ifndef _THREAD__GET_NAME_METHODDEF

#define _THREAD__GET_NAME_METHODDEF

#endif /* !defined(_THREAD__GET_NAME_METHODDEF) */

#ifndef _THREAD_SET_NAME_METHODDEF

#define _THREAD_SET_NAME_METHODDEF

#endif /* !defined(_THREAD_SET_NAME_METHODDEF) */