/* Descriptors -- a new, flexible way to describe attributes */

#include "Python.h"

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

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

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

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

#include "structmember.h" // PyMemberDef

_Py_IDENTIFIER(getattr);

/*[clinic input]

class mappingproxy "mappingproxyobject *" "&PyDictProxy_Type"

class property "propertyobject *" "&PyProperty_Type"

[clinic start generated code]*/

/*[clinic end generated code: output=da39a3ee5e6b4b0d input=556352653fd4c02e]*/

static void

descr_dealloc(PyDescrObject *descr)

{

_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 *format)

{

PyObject *name = NULL;

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

name = descr->d_name;

return PyUnicode_FromFormat(format, name, "?", descr->d_type->tp_name);

}

static PyObject *

method_repr(PyMethodDescrObject *descr)

{

return descr_repr((PyDescrObject *)descr,

"<method '%V' of '%s' objects>");

}

static PyObject *

member_repr(PyMemberDescrObject *descr)

{

return descr_repr((PyDescrObject *)descr,

"<member '%V' of '%s' objects>");

}

static PyObject *

getset_repr(PyGetSetDescrObject *descr)

{

return descr_repr((PyDescrObject *)descr,

"<attribute '%V' of '%s' objects>");

}

static PyObject *

wrapperdescr_repr(PyWrapperDescrObject *descr)

{

return descr_repr((PyDescrObject *)descr,

"<slot wrapper '%V' of '%s' objects>");

}

static int

descr_check(PyDescrObject *descr, PyObject *obj, PyObject **pres)

{

if (obj == NULL) {

Py_INCREF(descr);

*pres = (PyObject *)descr;

return 1;

}

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

*pres = NULL;

return 1;

}

return 0;

}

static PyObject *

classmethod_get(PyMethodDescrObject *descr, PyObject *obj, PyObject *type)

{

/* 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(PyMethodDescrObject *descr, PyObject *obj, PyObject *type)

{

PyObject *res;

if (descr_check((PyDescrObject *)descr, obj, &res))

return res;

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

if (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(PyMemberDescrObject *descr, PyObject *obj, PyObject *type)

{

PyObject *res;

if (descr_check((PyDescrObject *)descr, obj, &res))

return res;

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

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(PyGetSetDescrObject *descr, PyObject *obj, PyObject *type)

{

PyObject *res;

if (descr_check((PyDescrObject *)descr, obj, &res))

return res;

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

return 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(PyWrapperDescrObject *descr, PyObject *obj, PyObject *type)

{

PyObject *res;

if (descr_check((PyDescrObject *)descr, obj, &res))

return res;

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

}

static int

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

int *pres)

{

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

*pres = -1;

return 1;

}

return 0;

}

static int

member_set(PyMemberDescrObject *descr, PyObject *obj, PyObject *value)

{

int res;

if (descr_setcheck((PyDescrObject *)descr, obj, value, &res))

return res;

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

}

static int

getset_set(PyGetSetDescrObject *descr, PyObject *obj, PyObject *value)

{

int res;

if (descr_setcheck((PyDescrObject *)descr, obj, value, &res))

return res;

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

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

}

/* Vectorcall functions for each of the PyMethodDescr calling conventions.

*

* First, common helpers

*/

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

PyObject *dummy;

if (descr_check((PyDescrObject *)func, self, &dummy)) {

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_EnterRecursiveCall(tstate, " while calling a Python object")) {

return NULL;

}

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

}

/* Now the actual vectorcall functions */

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 = meth(args[0], argstuple);

Py_DECREF(argstuple);

_Py_LeaveRecursiveCall(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 = meth(args[0], argstuple, kwdict);

_Py_LeaveRecursiveCall(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_LeaveRecursiveCall(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_LeaveRecursiveCall(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 = meth(args[0], NULL);

_Py_LeaveRecursiveCall(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 = meth(args[0], args[1]);

_Py_LeaveRecursiveCall(tstate);

return result;

}

/* Instances of classmethod_descriptor are unlikely to be called directly.

For one, the analogous class "classmethod" (for Python classes) is not

callable. Second, users are not likely to access a classmethod_descriptor

directly, since it means pulling it from the class __dict__.

This is just an excuse to say that this doesn't need to be optimized:

we implement this simply by calling __get__ and then calling the result.

*/

static PyObject *

classmethoddescr_call(PyMethodDescrObject *descr, PyObject *args,

PyObject *kwds)

{

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(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 = (wrapperfunc_kwds)(void(*)(void))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(PyWrapperDescrObject *descr, PyObject *args, PyObject *kwds)

{

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(PyMethodDescrObject *descr, void *closure)

{

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

}

static PyObject *

method_get_text_signature(PyMethodDescrObject *descr, void *closure)

{

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

}

static PyObject *

calculate_qualname(PyDescrObject *descr)

{

PyObject *type_qualname, *res;

_Py_IDENTIFIER(__qualname__);

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_GetAttrId((PyObject *)descr->d_type,

&PyId___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(PyDescrObject *descr, void *Py_UNUSED(ignored))

{

if (descr->d_qualname == NULL)

descr->d_qualname = calculate_qualname(descr);

Py_XINCREF(descr->d_qualname);

return descr->d_qualname;

}

static PyObject *

descr_reduce(PyDescrObject *descr, PyObject *Py_UNUSED(ignored))

{

return Py_BuildValue("N(OO)", _PyEval_GetBuiltinId(&PyId_getattr),

PyDescr_TYPE(descr), PyDescr_NAME(descr));

}

static PyMethodDef descr_methods[] = {

{"__reduce__", (PyCFunction)descr_reduce, METH_NOARGS, NULL},

{NULL, NULL}

};

static PyMemberDef descr_members[] = {

{"__objclass__", T_OBJECT, offsetof(PyDescrObject, d_type), READONLY},

{"__name__", T_OBJECT, offsetof(PyDescrObject, d_name), READONLY},

{0}

};

static PyGetSetDef method_getset[] = {

{"__doc__", (getter)method_get_doc},

{"__qualname__", (getter)descr_get_qualname},

{"__text_signature__", (getter)method_get_text_signature},

{0}

};

static PyObject *

member_get_doc(PyMemberDescrObject *descr, void *closure)

{

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

Py_RETURN_NONE;

}

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

}

static PyGetSetDef member_getset[] = {

{"__doc__", (getter)member_get_doc},

{"__qualname__", (getter)descr_get_qualname},

{0}

};

static PyObject *

getset_get_doc(PyGetSetDescrObject *descr, void *closure)

{

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

Py_RETURN_NONE;

}

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

}

static PyGetSetDef getset_getset[] = {

{"__doc__", (getter)getset_get_doc},

{"__qualname__", (getter)descr_get_qualname},

{0}

};

static PyObject *

wrapperdescr_get_doc(PyWrapperDescrObject *descr, void *closure)

{

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

}

static PyObject *

wrapperdescr_get_text_signature(PyWrapperDescrObject *descr, void *closure)

{

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

}

static PyGetSetDef wrapperdescr_getset[] = {

{"__doc__", (getter)wrapperdescr_get_doc},

{"__qualname__", (getter)descr_get_qualname},

{"__text_signature__", (getter)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,

(destructor)descr_dealloc, /* tp_dealloc */

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

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_as_async */

(reprfunc)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 */

(descrgetfunc)method_get, /* tp_descr_get */

0, /* tp_descr_set */

};

/* This is for METH_CLASS in C, not for "f = classmethod(f)" in Python! */

PyTypeObject PyClassMethodDescr_Type = {

PyVarObject_HEAD_INIT(&PyType_Type, 0)

"classmethod_descriptor",

sizeof(PyMethodDescrObject),

0,

(destructor)descr_dealloc, /* tp_dealloc */

0, /* tp_vectorcall_offset */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_as_async */

(reprfunc)method_repr, /* tp_repr */

0, /* tp_as_number */

0, /* tp_as_sequence */

0, /* tp_as_mapping */

0, /* tp_hash */

(ternaryfunc)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 */

descr_methods, /* tp_methods */

descr_members, /* tp_members */

method_getset, /* tp_getset */

0, /* tp_base */

0, /* tp_dict */

(descrgetfunc)classmethod_get, /* tp_descr_get */

0, /* tp_descr_set */

};

PyTypeObject PyMemberDescr_Type = {

PyVarObject_HEAD_INIT(&PyType_Type, 0)

"member_descriptor",

sizeof(PyMemberDescrObject),

0,

(destructor)descr_dealloc, /* tp_dealloc */

0, /* tp_vectorcall_offset */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_as_async */

(reprfunc)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 */

(descrgetfunc)member_get, /* tp_descr_get */

(descrsetfunc)member_set, /* tp_descr_set */

};

PyTypeObject PyGetSetDescr_Type = {

PyVarObject_HEAD_INIT(&PyType_Type, 0)

"getset_descriptor",

sizeof(PyGetSetDescrObject),

0,

(destructor)descr_dealloc, /* tp_dealloc */

0, /* tp_vectorcall_offset */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_as_async */

(reprfunc)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 */

(descrgetfunc)getset_get, /* tp_descr_get */

(descrsetfunc)getset_set, /* tp_descr_set */

};

PyTypeObject PyWrapperDescr_Type = {

PyVarObject_HEAD_INIT(&PyType_Type, 0)

"wrapper_descriptor",

sizeof(PyWrapperDescrObject),

0,

(destructor)descr_dealloc, /* tp_dealloc */

0, /* tp_vectorcall_offset */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_as_async */

(reprfunc)wrapperdescr_repr, /* tp_repr */

0, /* tp_as_number */

0, /* tp_as_sequence */

0, /* tp_as_mapping */

0, /* tp_hash */

(ternaryfunc)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 */

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

Py_XINCREF(type);

descr->d_type = type;

descr->d_name = PyUnicode_InternFromString(name);

if (descr->d_name == NULL) {

Py_DECREF(descr);

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 & (METH_VARARGS | METH_FASTCALL | METH_NOARGS |

METH_O | METH_KEYWORDS | METH_METHOD))

{

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;

descr = (PyMemberDescrObject *)descr_new(&PyMemberDescr_Type,

type, member->name);

if (descr != NULL)

descr->d_member = member;

return (PyObject *)descr;

}

PyObject *

PyDescr_NewGetSet(PyTypeObject *type, PyGetSetDef *getset)

{

PyGetSetDescrObject *descr;

descr = (PyGetSetDescrObject *)descr_new(&PyGetSetDescr_Type,

type, getset->name);

if (descr != NULL)

descr->d_getset = getset;

return (PyObject *)descr;

}

PyObject *

PyDescr_NewWrapper(PyTypeObject *type, struct wrapperbase *base, void *wrapped)

{

PyWrapperDescrObject *descr;

descr = (PyWrapperDescrObject *)descr_new(&PyWrapperDescr_Type,

type, base->name);

if (descr != NULL) {

descr->d_base = base;

descr->d_wrapped = wrapped;

}

return (PyObject *)descr;

}

/* --- mappingproxy: read-only proxy for mappings --- */