#include "Python.h"

#include "pycore_abstract.h" // _PyObject_RealIsSubclass()

#include "pycore_call.h" // _PyStack_AsDict()

#include "pycore_ceval.h" // _Py_EnterRecursiveCallTstate()

#include "pycore_wasm_trampoline.h" // descr_set_trampoline_call(), descr_get_trampoline_call()

#include "pycore_descrobject.h" // _PyMethodWrapper_Type

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

#include "pycore_object.h" // _PyObject_GC_UNTRACK()

#include "pycore_object_deferred.h" // _PyObject_SetDeferredRefcount()

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

#include "pycore_tuple.h" // _PyTuple_ITEMS()

#include "clinic/descrobject.c.h"

static void

descr_dealloc(PyObject *self)

{

PyDescrObject *descr = (PyDescrObject *)self;

_PyObject_GC_UNTRACK(descr);

Py_XDECREF(descr->d_type);

Py_XDECREF(descr->d_name);

Py_XDECREF(descr->d_qualname);

PyObject_GC_Del(descr);

}

static PyObject *

descr_name(PyDescrObject *descr)

{

if (descr->d_name != NULL && PyUnicode_Check(descr->d_name))

return descr->d_name;

return NULL;

}

static PyObject *

descr_repr(PyDescrObject *descr, const char *kind)

{

PyObject *name = NULL;

if (descr->d_name != NULL && PyUnicode_Check(descr->d_name))

name = descr->d_name;

if (descr->d_type == &PyBaseObject_Type) {

return PyUnicode_FromFormat("<%s '%V'>", kind, name, "?");

}

return PyUnicode_FromFormat("<%s '%V' of '%s' objects>",

kind, name, "?", descr->d_type->tp_name);

}

static PyObject *

method_repr(PyObject *descr)

{

return descr_repr((PyDescrObject *)descr, "method");

}

static PyObject *

member_repr(PyObject *descr)

{

return descr_repr((PyDescrObject *)descr, "member");

}

static PyObject *

getset_repr(PyObject *descr)

{

return descr_repr((PyDescrObject *)descr, "attribute");

}

static PyObject *

wrapperdescr_repr(PyObject *descr)

{

return descr_repr((PyDescrObject *)descr, "slot wrapper");

}

static int

descr_check(PyDescrObject *descr, PyObject *obj)

{

if (!PyObject_TypeCheck(obj, descr->d_type)) {

PyErr_Format(PyExc_TypeError,

"descriptor '%V' for '%.100s' objects "

"doesn't apply to a '%.100s' object",

descr_name((PyDescrObject *)descr), "?",

descr->d_type->tp_name,

Py_TYPE(obj)->tp_name);

return -1;

}

return 0;

}

static PyObject *

classmethod_get(PyObject *self, PyObject *obj, PyObject *type)

{

PyMethodDescrObject *descr = (PyMethodDescrObject *)self;

/* Ensure a valid type. Class methods ignore obj. */

if (type == NULL) {

if (obj != NULL)

type = (PyObject *)Py_TYPE(obj);

else {

/* Wot - no type?! */

PyErr_Format(PyExc_TypeError,

"descriptor '%V' for type '%.100s' "

"needs either an object or a type",

descr_name((PyDescrObject *)descr), "?",

PyDescr_TYPE(descr)->tp_name);

return NULL;

}

}

if (!PyType_Check(type)) {

PyErr_Format(PyExc_TypeError,

"descriptor '%V' for type '%.100s' "

"needs a type, not a '%.100s' as arg 2",

descr_name((PyDescrObject *)descr), "?",

PyDescr_TYPE(descr)->tp_name,

Py_TYPE(type)->tp_name);

return NULL;

}

if (!PyType_IsSubtype((PyTypeObject *)type, PyDescr_TYPE(descr))) {

PyErr_Format(PyExc_TypeError,

"descriptor '%V' requires a subtype of '%.100s' "

"but received '%.100s'",

descr_name((PyDescrObject *)descr), "?",

PyDescr_TYPE(descr)->tp_name,

((PyTypeObject *)type)->tp_name);

return NULL;

}

PyTypeObject *cls = NULL;

if (descr->d_method->ml_flags & METH_METHOD) {

cls = descr->d_common.d_type;

}

return PyCMethod_New(descr->d_method, type, NULL, cls);

}

static PyObject *

method_get(PyObject *self, PyObject *obj, PyObject *type)

{

PyMethodDescrObject *descr = (PyMethodDescrObject *)self;

if (obj == NULL) {

return Py_NewRef(descr);

}

if (descr_check((PyDescrObject *)descr, obj) < 0) {

return NULL;

}

if (descr->d_method->ml_flags & METH_METHOD) {

if (type == NULL || PyType_Check(type)) {

return PyCMethod_New(descr->d_method, obj, NULL, descr->d_common.d_type);

} else {

PyErr_Format(PyExc_TypeError,

"descriptor '%V' needs a type, not '%s', as arg 2",

descr_name((PyDescrObject *)descr), "?",

Py_TYPE(type)->tp_name);

return NULL;

}

} else {

return PyCFunction_NewEx(descr->d_method, obj, NULL);

}

}

static PyObject *

member_get(PyObject *self, PyObject *obj, PyObject *type)

{

PyMemberDescrObject *descr = (PyMemberDescrObject *)self;

if (obj == NULL) {

return Py_NewRef(descr);

}

if (descr_check((PyDescrObject *)descr, obj) < 0) {

return NULL;

}

if (descr->d_member->flags & Py_AUDIT_READ) {

if (PySys_Audit("object.__getattr__", "Os",

obj ? obj : Py_None, descr->d_member->name) < 0) {

return NULL;

}

}

return PyMember_GetOne((char *)obj, descr->d_member);

}

static PyObject *

getset_get(PyObject *self, PyObject *obj, PyObject *type)

{

PyGetSetDescrObject *descr = (PyGetSetDescrObject *)self;

if (obj == NULL) {

return Py_NewRef(descr);

}

if (descr_check((PyDescrObject *)descr, obj) < 0) {

return NULL;

}

if (descr->d_getset->get != NULL)

return descr_get_trampoline_call(

descr->d_getset->get, obj, descr->d_getset->closure);

PyErr_Format(PyExc_AttributeError,

"attribute '%V' of '%.100s' objects is not readable",

descr_name((PyDescrObject *)descr), "?",

PyDescr_TYPE(descr)->tp_name);

return NULL;

}

static PyObject *

wrapperdescr_get(PyObject *self, PyObject *obj, PyObject *type)

{

PyWrapperDescrObject *descr = (PyWrapperDescrObject *)self;

if (obj == NULL) {

return Py_NewRef(descr);

}

if (descr_check((PyDescrObject *)descr, obj) < 0) {

return NULL;

}

return PyWrapper_New((PyObject *)descr, obj);

}

static int

descr_setcheck(PyDescrObject *descr, PyObject *obj, PyObject *value)

{

assert(obj != NULL);

if (!PyObject_TypeCheck(obj, descr->d_type)) {

PyErr_Format(PyExc_TypeError,

"descriptor '%V' for '%.100s' objects "

"doesn't apply to a '%.100s' object",

descr_name(descr), "?",

descr->d_type->tp_name,

Py_TYPE(obj)->tp_name);

return -1;

}

return 0;

}

static int

member_set(PyObject *self, PyObject *obj, PyObject *value)

{

PyMemberDescrObject *descr = (PyMemberDescrObject *)self;

if (descr_setcheck((PyDescrObject *)descr, obj, value) < 0) {

return -1;

}

return PyMember_SetOne((char *)obj, descr->d_member, value);

}

static int

getset_set(PyObject *self, PyObject *obj, PyObject *value)

{

PyGetSetDescrObject *descr = (PyGetSetDescrObject *)self;

if (descr_setcheck((PyDescrObject *)descr, obj, value) < 0) {

return -1;

}

if (descr->d_getset->set != NULL) {

return descr_set_trampoline_call(

descr->d_getset->set, obj, value,

descr->d_getset->closure);

}

PyErr_Format(PyExc_AttributeError,

"attribute '%V' of '%.100s' objects is not writable",

descr_name((PyDescrObject *)descr), "?",

PyDescr_TYPE(descr)->tp_name);

return -1;

}

static inline int

method_check_args(PyObject *func, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

assert(!PyErr_Occurred());

if (nargs < 1) {

PyObject *funcstr = _PyObject_FunctionStr(func);

if (funcstr != NULL) {

PyErr_Format(PyExc_TypeError,

"unbound method %U needs an argument", funcstr);

Py_DECREF(funcstr);

}

return -1;

}

PyObject *self = args[0];

if (descr_check((PyDescrObject *)func, self) < 0) {

return -1;

}

if (kwnames && PyTuple_GET_SIZE(kwnames)) {

PyObject *funcstr = _PyObject_FunctionStr(func);

if (funcstr != NULL) {

PyErr_Format(PyExc_TypeError,

"%U takes no keyword arguments", funcstr);

Py_DECREF(funcstr);

}

return -1;

}

return 0;

}

typedef void (*funcptr)(void);

static inline funcptr

method_enter_call(PyThreadState *tstate, PyObject *func)

{

if (_Py_EnterRecursiveCallTstate(tstate, " while calling a Python object")) {

return NULL;

}

return (funcptr)((PyMethodDescrObject *)func)->d_method->ml_meth;

}

static PyObject *

method_vectorcall_VARARGS(

PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)

{

PyThreadState *tstate = _PyThreadState_GET();

Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);

if (method_check_args(func, args, nargs, kwnames)) {

return NULL;

}

PyObject *argstuple = PyTuple_FromArray(args+1, nargs-1);

if (argstuple == NULL) {

return NULL;

}

PyCFunction meth = (PyCFunction)method_enter_call(tstate, func);

if (meth == NULL) {

Py_DECREF(argstuple);

return NULL;

}

PyObject *result = _PyCFunction_TrampolineCall(

meth, args[0], argstuple);

Py_DECREF(argstuple);

_Py_LeaveRecursiveCallTstate(tstate);

return result;

}

static PyObject *

method_vectorcall_VARARGS_KEYWORDS(

PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)

{

PyThreadState *tstate = _PyThreadState_GET();

Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);

if (method_check_args(func, args, nargs, NULL)) {

return NULL;

}

PyObject *argstuple = PyTuple_FromArray(args+1, nargs-1);

if (argstuple == NULL) {

return NULL;

}

PyObject *result = NULL;

/* Create a temporary dict for keyword arguments */

PyObject *kwdict = NULL;

if (kwnames != NULL && PyTuple_GET_SIZE(kwnames) > 0) {

kwdict = _PyStack_AsDict(args + nargs, kwnames);

if (kwdict == NULL) {

goto exit;

}

}

PyCFunctionWithKeywords meth = (PyCFunctionWithKeywords)

method_enter_call(tstate, func);

if (meth == NULL) {

goto exit;

}

result = _PyCFunctionWithKeywords_TrampolineCall(

meth, args[0], argstuple, kwdict);

_Py_LeaveRecursiveCallTstate(tstate);

exit:

Py_DECREF(argstuple);

Py_XDECREF(kwdict);

return result;

}

static PyObject *

method_vectorcall_FASTCALL_KEYWORDS_METHOD(

PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)

{

PyThreadState *tstate = _PyThreadState_GET();

Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);

if (method_check_args(func, args, nargs, NULL)) {

return NULL;

}

PyCMethod meth = (PyCMethod) method_enter_call(tstate, func);

if (meth == NULL) {

return NULL;

}

PyObject *result = meth(args[0],

((PyMethodDescrObject *)func)->d_common.d_type,

args+1, nargs-1, kwnames);

_Py_LeaveRecursiveCall();

return result;

}

static PyObject *

method_vectorcall_FASTCALL(

PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)

{

PyThreadState *tstate = _PyThreadState_GET();

Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);

if (method_check_args(func, args, nargs, kwnames)) {

return NULL;

}

PyCFunctionFast meth = (PyCFunctionFast)

method_enter_call(tstate, func);

if (meth == NULL) {

return NULL;

}

PyObject *result = meth(args[0], args+1, nargs-1);

_Py_LeaveRecursiveCallTstate(tstate);

return result;

}

static PyObject *

method_vectorcall_FASTCALL_KEYWORDS(

PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)

{

PyThreadState *tstate = _PyThreadState_GET();

Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);

if (method_check_args(func, args, nargs, NULL)) {

return NULL;

}

PyCFunctionFastWithKeywords meth = (PyCFunctionFastWithKeywords)

method_enter_call(tstate, func);

if (meth == NULL) {

return NULL;

}

PyObject *result = meth(args[0], args+1, nargs-1, kwnames);

_Py_LeaveRecursiveCallTstate(tstate);

return result;

}

static PyObject *

method_vectorcall_NOARGS(

PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)

{

PyThreadState *tstate = _PyThreadState_GET();

Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);

if (method_check_args(func, args, nargs, kwnames)) {

return NULL;

}

if (nargs != 1) {

PyObject *funcstr = _PyObject_FunctionStr(func);

if (funcstr != NULL) {

PyErr_Format(PyExc_TypeError,

"%U takes no arguments (%zd given)", funcstr, nargs-1);

Py_DECREF(funcstr);

}

return NULL;

}

PyCFunction meth = (PyCFunction)method_enter_call(tstate, func);

if (meth == NULL) {

return NULL;

}

PyObject *result = _PyCFunction_TrampolineCall(meth, args[0], NULL);

_Py_LeaveRecursiveCallTstate(tstate);

return result;

}

static PyObject *

method_vectorcall_O(

PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)

{

PyThreadState *tstate = _PyThreadState_GET();

Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);

if (method_check_args(func, args, nargs, kwnames)) {

return NULL;

}

if (nargs != 2) {

PyObject *funcstr = _PyObject_FunctionStr(func);

if (funcstr != NULL) {

PyErr_Format(PyExc_TypeError,

"%U takes exactly one argument (%zd given)",

funcstr, nargs-1);

Py_DECREF(funcstr);

}

return NULL;

}

PyCFunction meth = (PyCFunction)method_enter_call(tstate, func);

if (meth == NULL) {

return NULL;

}

PyObject *result = _PyCFunction_TrampolineCall(meth, args[0], args[1]);

_Py_LeaveRecursiveCallTstate(tstate);

return result;

}

static PyObject *

classmethoddescr_call(PyObject *_descr, PyObject *args,

PyObject *kwds)

{

PyMethodDescrObject *descr = (PyMethodDescrObject *)_descr;

Py_ssize_t argc = PyTuple_GET_SIZE(args);

if (argc < 1) {

PyErr_Format(PyExc_TypeError,

"descriptor '%V' of '%.100s' "

"object needs an argument",

descr_name((PyDescrObject *)descr), "?",

PyDescr_TYPE(descr)->tp_name);

return NULL;

}

PyObject *self = PyTuple_GET_ITEM(args, 0);

PyObject *bound = classmethod_get((PyObject *)descr, NULL, self);

if (bound == NULL) {

return NULL;

}

PyObject *res = PyObject_VectorcallDict(bound, _PyTuple_ITEMS(args)+1,

argc-1, kwds);

Py_DECREF(bound);

return res;

}

Py_LOCAL_INLINE(PyObject *)

wrapperdescr_raw_call(PyWrapperDescrObject *descr, PyObject *self,

PyObject *args, PyObject *kwds)

{

wrapperfunc wrapper = descr->d_base->wrapper;

if (descr->d_base->flags & PyWrapperFlag_KEYWORDS) {

wrapperfunc_kwds wk = _Py_FUNC_CAST(wrapperfunc_kwds, wrapper);

return (*wk)(self, args, descr->d_wrapped, kwds);

}

if (kwds != NULL && (!PyDict_Check(kwds) || PyDict_GET_SIZE(kwds) != 0)) {

PyErr_Format(PyExc_TypeError,

"wrapper %s() takes no keyword arguments",

descr->d_base->name);

return NULL;

}

return (*wrapper)(self, args, descr->d_wrapped);

}

static PyObject *

wrapperdescr_call(PyObject *_descr, PyObject *args, PyObject *kwds)

{

PyWrapperDescrObject *descr = (PyWrapperDescrObject *)_descr;

Py_ssize_t argc;

PyObject *self, *result;

/* Make sure that the first argument is acceptable as 'self' */

assert(PyTuple_Check(args));

argc = PyTuple_GET_SIZE(args);

if (argc < 1) {

PyErr_Format(PyExc_TypeError,

"descriptor '%V' of '%.100s' "

"object needs an argument",

descr_name((PyDescrObject *)descr), "?",

PyDescr_TYPE(descr)->tp_name);

return NULL;

}

self = PyTuple_GET_ITEM(args, 0);

if (!_PyObject_RealIsSubclass((PyObject *)Py_TYPE(self),

(PyObject *)PyDescr_TYPE(descr))) {

PyErr_Format(PyExc_TypeError,

"descriptor '%V' "

"requires a '%.100s' object "

"but received a '%.100s'",

descr_name((PyDescrObject *)descr), "?",

PyDescr_TYPE(descr)->tp_name,

Py_TYPE(self)->tp_name);

return NULL;

}

args = PyTuple_GetSlice(args, 1, argc);

if (args == NULL) {

return NULL;

}

result = wrapperdescr_raw_call(descr, self, args, kwds);

Py_DECREF(args);

return result;

}

static PyObject *

method_get_doc(PyObject *_descr, void *closure)

{

PyMethodDescrObject *descr = (PyMethodDescrObject *)_descr;

return _PyType_GetDocFromInternalDoc(descr->d_method->ml_name, descr->d_method->ml_doc);

}

static PyObject *

method_get_text_signature(PyObject *_descr, void *closure)

{

PyMethodDescrObject *descr = (PyMethodDescrObject *)_descr;

return _PyType_GetTextSignatureFromInternalDoc(descr->d_method->ml_name,

descr->d_method->ml_doc,

descr->d_method->ml_flags);

}

static PyObject *

calculate_qualname(PyDescrObject *descr)

{

PyObject *type_qualname, *res;

if (descr->d_name == NULL || !PyUnicode_Check(descr->d_name)) {

PyErr_SetString(PyExc_TypeError,

"<descriptor>.__name__ is not a unicode object");

return NULL;

}

type_qualname = PyObject_GetAttr(

(PyObject *)descr->d_type, &_Py_ID(__qualname__));

if (type_qualname == NULL)

return NULL;

if (!PyUnicode_Check(type_qualname)) {

PyErr_SetString(PyExc_TypeError, "<descriptor>.__objclass__."

"__qualname__ is not a unicode object");

Py_XDECREF(type_qualname);

return NULL;

}

res = PyUnicode_FromFormat("%S.%S", type_qualname, descr->d_name);

Py_DECREF(type_qualname);

return res;

}

static PyObject *

descr_get_qualname(PyObject *self, void *Py_UNUSED(ignored))

{

PyDescrObject *descr = (PyDescrObject *)self;

PyObject *qualname;

Py_BEGIN_CRITICAL_SECTION(self);

if (descr->d_qualname == NULL) {

PyObject *new_qualname = calculate_qualname(descr);

if (new_qualname != NULL) {

Py_XSETREF(descr->d_qualname, new_qualname);

}

}

qualname = Py_XNewRef(descr->d_qualname);

Py_END_CRITICAL_SECTION();

return qualname;

}

static PyObject *

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

{

PyDescrObject *descr = (PyDescrObject *)self;

return Py_BuildValue("N(OO)", _PyEval_GetBuiltin(&_Py_ID(getattr)),

PyDescr_TYPE(descr), PyDescr_NAME(descr));

}

static PyMethodDef descr_methods[] = {

{"__reduce__", descr_reduce, METH_NOARGS, NULL},

{NULL, NULL}

};

static PyMemberDef descr_members[] = {

{"__objclass__", _Py_T_OBJECT, offsetof(PyDescrObject, d_type), Py_READONLY},

{"__name__", _Py_T_OBJECT, offsetof(PyDescrObject, d_name), Py_READONLY},

{0}

};

static PyGetSetDef method_getset[] = {

{"__doc__", method_get_doc},

{"__qualname__", descr_get_qualname},

{"__text_signature__", method_get_text_signature},

{0}

};

static PyObject *

member_get_doc(PyObject *_descr, void *closure)

{

PyMemberDescrObject *descr = (PyMemberDescrObject *)_descr;

if (descr->d_member->doc == NULL) {

Py_RETURN_NONE;

}

return PyUnicode_FromString(descr->d_member->doc);

}

static PyGetSetDef member_getset[] = {

{"__doc__", member_get_doc},

{"__qualname__", descr_get_qualname},

{0}

};

static PyObject *

getset_get_doc(PyObject *self, void *closure)

{

PyGetSetDescrObject *descr = (PyGetSetDescrObject *)self;

if (descr->d_getset->doc == NULL) {

Py_RETURN_NONE;

}

return PyUnicode_FromString(descr->d_getset->doc);

}

static PyGetSetDef getset_getset[] = {

{"__doc__", getset_get_doc},

{"__qualname__", descr_get_qualname},

{0}

};

static PyObject *

wrapperdescr_get_doc(PyObject *self, void *closure)

{

PyWrapperDescrObject *descr = (PyWrapperDescrObject *)self;

return _PyType_GetDocFromInternalDoc(descr->d_base->name, descr->d_base->doc);

}

static PyObject *

wrapperdescr_get_text_signature(PyObject *self, void *closure)

{

PyWrapperDescrObject *descr = (PyWrapperDescrObject *)self;

return _PyType_GetTextSignatureFromInternalDoc(descr->d_base->name,

descr->d_base->doc, 0);

}

static PyGetSetDef wrapperdescr_getset[] = {

{"__doc__", wrapperdescr_get_doc},

{"__qualname__", descr_get_qualname},

{"__text_signature__", wrapperdescr_get_text_signature},

{0}

};

static int

descr_traverse(PyObject *self, visitproc visit, void *arg)

{

PyDescrObject *descr = (PyDescrObject *)self;

Py_VISIT(descr->d_type);

return 0;

}

PyTypeObject PyMethodDescr_Type = {

PyVarObject_HEAD_INIT(&PyType_Type, 0)

"method_descriptor",

sizeof(PyMethodDescrObject),

0,

descr_dealloc, /* tp_dealloc */

offsetof(PyMethodDescrObject, vectorcall), /* tp_vectorcall_offset */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_as_async */

method_repr, /* tp_repr */

0, /* tp_as_number */

0, /* tp_as_sequence */

0, /* tp_as_mapping */

0, /* tp_hash */

PyVectorcall_Call, /* tp_call */

0, /* tp_str */

PyObject_GenericGetAttr, /* tp_getattro */

0, /* tp_setattro */

0, /* tp_as_buffer */

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |

Py_TPFLAGS_HAVE_VECTORCALL |

Py_TPFLAGS_METHOD_DESCRIPTOR, /* tp_flags */

0, /* tp_doc */

descr_traverse, /* tp_traverse */

0, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

descr_methods, /* tp_methods */

descr_members, /* tp_members */

method_getset, /* tp_getset */

0, /* tp_base */

0, /* tp_dict */

method_get, /* tp_descr_get */

0, /* tp_descr_set */

};

PyTypeObject PyClassMethodDescr_Type = {

PyVarObject_HEAD_INIT(&PyType_Type, 0)

"classmethod_descriptor",

sizeof(PyMethodDescrObject),

0,

descr_dealloc, /* tp_dealloc */

0, /* tp_vectorcall_offset */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_as_async */

method_repr, /* tp_repr */

0, /* tp_as_number */

0, /* tp_as_sequence */

0, /* tp_as_mapping */

0, /* tp_hash */

classmethoddescr_call, /* tp_call */

0, /* tp_str */

PyObject_GenericGetAttr, /* tp_getattro */

0, /* tp_setattro */

0, /* tp_as_buffer */

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */

0, /* tp_doc */

descr_traverse, /* tp_traverse */

0, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

0, /* tp_methods */

descr_members, /* tp_members */

method_getset, /* tp_getset */

0, /* tp_base */

0, /* tp_dict */

classmethod_get, /* tp_descr_get */

0, /* tp_descr_set */

};

PyTypeObject PyMemberDescr_Type = {

PyVarObject_HEAD_INIT(&PyType_Type, 0)

"member_descriptor",

sizeof(PyMemberDescrObject),

0,

descr_dealloc, /* tp_dealloc */

0, /* tp_vectorcall_offset */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_as_async */

member_repr, /* tp_repr */

0, /* tp_as_number */

0, /* tp_as_sequence */

0, /* tp_as_mapping */

0, /* tp_hash */

0, /* tp_call */

0, /* tp_str */

PyObject_GenericGetAttr, /* tp_getattro */

0, /* tp_setattro */

0, /* tp_as_buffer */

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */

0, /* tp_doc */

descr_traverse, /* tp_traverse */

0, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

descr_methods, /* tp_methods */

descr_members, /* tp_members */

member_getset, /* tp_getset */

0, /* tp_base */

0, /* tp_dict */

member_get, /* tp_descr_get */

member_set, /* tp_descr_set */

};

PyTypeObject PyGetSetDescr_Type = {

PyVarObject_HEAD_INIT(&PyType_Type, 0)

"getset_descriptor",

sizeof(PyGetSetDescrObject),

0,

descr_dealloc, /* tp_dealloc */

0, /* tp_vectorcall_offset */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_as_async */

getset_repr, /* tp_repr */

0, /* tp_as_number */

0, /* tp_as_sequence */

0, /* tp_as_mapping */

0, /* tp_hash */

0, /* tp_call */

0, /* tp_str */

PyObject_GenericGetAttr, /* tp_getattro */

0, /* tp_setattro */

0, /* tp_as_buffer */

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */

0, /* tp_doc */

descr_traverse, /* tp_traverse */

0, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

0, /* tp_methods */

descr_members, /* tp_members */

getset_getset, /* tp_getset */

0, /* tp_base */

0, /* tp_dict */

getset_get, /* tp_descr_get */

getset_set, /* tp_descr_set */

};

PyTypeObject PyWrapperDescr_Type = {

PyVarObject_HEAD_INIT(&PyType_Type, 0)

"wrapper_descriptor",

sizeof(PyWrapperDescrObject),

0,

descr_dealloc, /* tp_dealloc */

0, /* tp_vectorcall_offset */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_as_async */

wrapperdescr_repr, /* tp_repr */

0, /* tp_as_number */

0, /* tp_as_sequence */

0, /* tp_as_mapping */

0, /* tp_hash */

wrapperdescr_call, /* tp_call */

0, /* tp_str */

PyObject_GenericGetAttr, /* tp_getattro */

0, /* tp_setattro */

0, /* tp_as_buffer */

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |

Py_TPFLAGS_METHOD_DESCRIPTOR, /* tp_flags */

0, /* tp_doc */

descr_traverse, /* tp_traverse */

0, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

descr_methods, /* tp_methods */

descr_members, /* tp_members */

wrapperdescr_getset, /* tp_getset */

0, /* tp_base */

0, /* tp_dict */

wrapperdescr_get, /* tp_descr_get */

0, /* tp_descr_set */

};

static PyDescrObject *

descr_new(PyTypeObject *descrtype, PyTypeObject *type, const char *name)

{

PyDescrObject *descr;

descr = (PyDescrObject *)PyType_GenericAlloc(descrtype, 0);

if (descr != NULL) {

_PyObject_SetDeferredRefcount((PyObject *)descr);

descr->d_type = (PyTypeObject*)Py_XNewRef(type);

descr->d_name = PyUnicode_InternFromString(name);

if (descr->d_name == NULL) {

Py_SETREF(descr, NULL);

}

else {

descr->d_qualname = NULL;

}

}

return descr;

}

PyObject *

PyDescr_NewMethod(PyTypeObject *type, PyMethodDef *method)

{

/* Figure out correct vectorcall function to use */

vectorcallfunc vectorcall;

switch (method->ml_flags & _Py_METH_CALL_FLAGS)

{

case METH_VARARGS:

vectorcall = method_vectorcall_VARARGS;

break;

case METH_VARARGS | METH_KEYWORDS:

vectorcall = method_vectorcall_VARARGS_KEYWORDS;

break;

case METH_FASTCALL:

vectorcall = method_vectorcall_FASTCALL;

break;

case METH_FASTCALL | METH_KEYWORDS:

vectorcall = method_vectorcall_FASTCALL_KEYWORDS;

break;

case METH_NOARGS:

vectorcall = method_vectorcall_NOARGS;

break;

case METH_O:

vectorcall = method_vectorcall_O;

break;

case METH_METHOD | METH_FASTCALL | METH_KEYWORDS:

vectorcall = method_vectorcall_FASTCALL_KEYWORDS_METHOD;

break;

default:

PyErr_Format(PyExc_SystemError,

"%s() method: bad call flags", method->ml_name);

return NULL;

}

PyMethodDescrObject *descr;

descr = (PyMethodDescrObject *)descr_new(&PyMethodDescr_Type,

type, method->ml_name);

if (descr != NULL) {

descr->d_method = method;

descr->vectorcall = vectorcall;

}

return (PyObject *)descr;

}

PyObject *

PyDescr_NewClassMethod(PyTypeObject *type, PyMethodDef *method)

{

PyMethodDescrObject *descr;

descr = (PyMethodDescrObject *)descr_new(&PyClassMethodDescr_Type,

type, method->ml_name);

if (descr != NULL)

descr->d_method = method;

return (PyObject *)descr;

}

PyObject *

PyDescr_NewMember(PyTypeObject *type, PyMemberDef *member)

{

PyMemberDescrObject *descr;

if (member->flags & Py_RELATIVE_OFFSET) {

PyErr_SetString(

PyExc_SystemError,