LCOV - code coverage report
Current view: top level - Objects - classobject.c (source / functions) Hit Total Coverage
Test: CPython 3.12 LCOV report [commit 5e6661bce9] Lines: 58 206 28.2 %
Date: 2023-03-20 08:15:36 Functions: 6 24 25.0 %
Branches: 18 122 14.8 %

           Branch data     Line data    Source code
       1                 :            : /* Class object implementation (dead now except for methods) */
       2                 :            : 
       3                 :            : #include "Python.h"
       4                 :            : #include "pycore_call.h"          // _PyObject_VectorcallTstate()
       5                 :            : #include "pycore_object.h"
       6                 :            : #include "pycore_pyerrors.h"
       7                 :            : #include "pycore_pystate.h"       // _PyThreadState_GET()
       8                 :            : #include "structmember.h"         // PyMemberDef
       9                 :            : 
      10                 :            : #include "clinic/classobject.c.h"
      11                 :            : 
      12                 :            : #define TP_DESCR_GET(t) ((t)->tp_descr_get)
      13                 :            : 
      14                 :            : /*[clinic input]
      15                 :            : class method "PyMethodObject *" "&PyMethod_Type"
      16                 :            : [clinic start generated code]*/
      17                 :            : /*[clinic end generated code: output=da39a3ee5e6b4b0d input=b16e47edf6107c23]*/
      18                 :            : 
      19                 :            : 
      20                 :            : PyObject *
      21                 :          0 : PyMethod_Function(PyObject *im)
      22                 :            : {
      23         [ #  # ]:          0 :     if (!PyMethod_Check(im)) {
      24                 :          0 :         PyErr_BadInternalCall();
      25                 :          0 :         return NULL;
      26                 :            :     }
      27                 :          0 :     return ((PyMethodObject *)im)->im_func;
      28                 :            : }
      29                 :            : 
      30                 :            : PyObject *
      31                 :          0 : PyMethod_Self(PyObject *im)
      32                 :            : {
      33         [ #  # ]:          0 :     if (!PyMethod_Check(im)) {
      34                 :          0 :         PyErr_BadInternalCall();
      35                 :          0 :         return NULL;
      36                 :            :     }
      37                 :          0 :     return ((PyMethodObject *)im)->im_self;
      38                 :            : }
      39                 :            : 
      40                 :            : 
      41                 :            : static PyObject *
      42                 :     277876 : method_vectorcall(PyObject *method, PyObject *const *args,
      43                 :            :                   size_t nargsf, PyObject *kwnames)
      44                 :            : {
      45                 :            :     assert(Py_IS_TYPE(method, &PyMethod_Type));
      46                 :            : 
      47                 :     277876 :     PyThreadState *tstate = _PyThreadState_GET();
      48                 :     277876 :     PyObject *self = PyMethod_GET_SELF(method);
      49                 :     277876 :     PyObject *func = PyMethod_GET_FUNCTION(method);
      50                 :     277876 :     Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
      51                 :            : 
      52                 :            :     PyObject *result;
      53         [ +  + ]:     277876 :     if (nargsf & PY_VECTORCALL_ARGUMENTS_OFFSET) {
      54                 :            :         /* PY_VECTORCALL_ARGUMENTS_OFFSET is set, so we are allowed to mutate the vector */
      55                 :     174858 :         PyObject **newargs = (PyObject**)args - 1;
      56                 :     174858 :         nargs += 1;
      57                 :     174858 :         PyObject *tmp = newargs[0];
      58                 :     174858 :         newargs[0] = self;
      59                 :     174858 :         result = _PyObject_VectorcallTstate(tstate, func, newargs,
      60                 :            :                                             nargs, kwnames);
      61                 :     174858 :         newargs[0] = tmp;
      62                 :            :     }
      63                 :            :     else {
      64         [ -  + ]:     103018 :         Py_ssize_t nkwargs = (kwnames == NULL) ? 0 : PyTuple_GET_SIZE(kwnames);
      65                 :     103018 :         Py_ssize_t totalargs = nargs + nkwargs;
      66         [ +  + ]:     103018 :         if (totalargs == 0) {
      67                 :     102735 :             return _PyObject_VectorcallTstate(tstate, func, &self, 1, NULL);
      68                 :            :         }
      69                 :            : 
      70                 :            :         PyObject *newargs_stack[_PY_FASTCALL_SMALL_STACK];
      71                 :            :         PyObject **newargs;
      72         [ +  - ]:        283 :         if (totalargs <= (Py_ssize_t)Py_ARRAY_LENGTH(newargs_stack) - 1) {
      73                 :        283 :             newargs = newargs_stack;
      74                 :            :         }
      75                 :            :         else {
      76                 :          0 :             newargs = PyMem_Malloc((totalargs+1) * sizeof(PyObject *));
      77         [ #  # ]:          0 :             if (newargs == NULL) {
      78                 :          0 :                 _PyErr_NoMemory(tstate);
      79                 :          0 :                 return NULL;
      80                 :            :             }
      81                 :            :         }
      82                 :            :         /* use borrowed references */
      83                 :        283 :         newargs[0] = self;
      84                 :            :         /* bpo-37138: since totalargs > 0, it's impossible that args is NULL.
      85                 :            :          * We need this, since calling memcpy() with a NULL pointer is
      86                 :            :          * undefined behaviour. */
      87                 :            :         assert(args != NULL);
      88                 :        283 :         memcpy(newargs + 1, args, totalargs * sizeof(PyObject *));
      89                 :        283 :         result = _PyObject_VectorcallTstate(tstate, func,
      90                 :        283 :                                             newargs, nargs+1, kwnames);
      91         [ -  + ]:        283 :         if (newargs != newargs_stack) {
      92                 :          0 :             PyMem_Free(newargs);
      93                 :            :         }
      94                 :            :     }
      95                 :     175141 :     return result;
      96                 :            : }
      97                 :            : 
      98                 :            : 
      99                 :            : /* Method objects are used for bound instance methods returned by
     100                 :            :    instancename.methodname. ClassName.methodname returns an ordinary
     101                 :            :    function.
     102                 :            : */
     103                 :            : 
     104                 :            : PyObject *
     105                 :     550818 : PyMethod_New(PyObject *func, PyObject *self)
     106                 :            : {
     107         [ -  + ]:     550818 :     if (self == NULL) {
     108                 :          0 :         PyErr_BadInternalCall();
     109                 :          0 :         return NULL;
     110                 :            :     }
     111                 :     550818 :     PyMethodObject *im = PyObject_GC_New(PyMethodObject, &PyMethod_Type);
     112         [ -  + ]:     550818 :     if (im == NULL) {
     113                 :          0 :         return NULL;
     114                 :            :     }
     115                 :     550818 :     im->im_weakreflist = NULL;
     116                 :     550818 :     im->im_func = Py_NewRef(func);
     117                 :     550818 :     im->im_self = Py_NewRef(self);
     118                 :     550818 :     im->vectorcall = method_vectorcall;
     119                 :     550818 :     _PyObject_GC_TRACK(im);
     120                 :     550818 :     return (PyObject *)im;
     121                 :            : }
     122                 :            : 
     123                 :            : /*[clinic input]
     124                 :            : method.__reduce__
     125                 :            : [clinic start generated code]*/
     126                 :            : 
     127                 :            : static PyObject *
     128                 :          0 : method___reduce___impl(PyMethodObject *self)
     129                 :            : /*[clinic end generated code: output=6c04506d0fa6fdcb input=143a0bf5e96de6e8]*/
     130                 :            : {
     131                 :          0 :     PyObject *funcself = PyMethod_GET_SELF(self);
     132                 :          0 :     PyObject *func = PyMethod_GET_FUNCTION(self);
     133                 :          0 :     PyObject *funcname = PyObject_GetAttr(func, &_Py_ID(__name__));
     134         [ #  # ]:          0 :     if (funcname == NULL) {
     135                 :          0 :         return NULL;
     136                 :            :     }
     137                 :          0 :     return Py_BuildValue(
     138                 :            :             "N(ON)", _PyEval_GetBuiltin(&_Py_ID(getattr)), funcself, funcname);
     139                 :            : }
     140                 :            : 
     141                 :            : static PyMethodDef method_methods[] = {
     142                 :            :     METHOD___REDUCE___METHODDEF
     143                 :            :     {NULL, NULL}
     144                 :            : };
     145                 :            : 
     146                 :            : /* Descriptors for PyMethod attributes */
     147                 :            : 
     148                 :            : /* im_func and im_self are stored in the PyMethod object */
     149                 :            : 
     150                 :            : #define MO_OFF(x) offsetof(PyMethodObject, x)
     151                 :            : 
     152                 :            : static PyMemberDef method_memberlist[] = {
     153                 :            :     {"__func__", T_OBJECT, MO_OFF(im_func), READONLY,
     154                 :            :      "the function (or other callable) implementing a method"},
     155                 :            :     {"__self__", T_OBJECT, MO_OFF(im_self), READONLY,
     156                 :            :      "the instance to which a method is bound"},
     157                 :            :     {NULL}      /* Sentinel */
     158                 :            : };
     159                 :            : 
     160                 :            : /* Christian Tismer argued convincingly that method attributes should
     161                 :            :    (nearly) always override function attributes.
     162                 :            :    The one exception is __doc__; there's a default __doc__ which
     163                 :            :    should only be used for the class, not for instances */
     164                 :            : 
     165                 :            : static PyObject *
     166                 :      14385 : method_get_doc(PyMethodObject *im, void *context)
     167                 :            : {
     168                 :      14385 :     return PyObject_GetAttr(im->im_func, &_Py_ID(__doc__));
     169                 :            : }
     170                 :            : 
     171                 :            : static PyGetSetDef method_getset[] = {
     172                 :            :     {"__doc__", (getter)method_get_doc, NULL, NULL},
     173                 :            :     {0}
     174                 :            : };
     175                 :            : 
     176                 :            : static PyObject *
     177                 :      14541 : method_getattro(PyObject *obj, PyObject *name)
     178                 :            : {
     179                 :      14541 :     PyMethodObject *im = (PyMethodObject *)obj;
     180                 :      14541 :     PyTypeObject *tp = Py_TYPE(obj);
     181                 :      14541 :     PyObject *descr = NULL;
     182                 :            : 
     183                 :            :     {
     184         [ -  + ]:      14541 :         if (tp->tp_dict == NULL) {
     185         [ #  # ]:          0 :             if (PyType_Ready(tp) < 0)
     186                 :          0 :                 return NULL;
     187                 :            :         }
     188                 :      14541 :         descr = _PyType_Lookup(tp, name);
     189                 :            :     }
     190                 :            : 
     191         [ +  + ]:      14541 :     if (descr != NULL) {
     192                 :      14385 :         descrgetfunc f = TP_DESCR_GET(Py_TYPE(descr));
     193         [ +  - ]:      14385 :         if (f != NULL)
     194                 :      14385 :             return f(descr, obj, (PyObject *)Py_TYPE(obj));
     195                 :            :         else {
     196                 :          0 :             return Py_NewRef(descr);
     197                 :            :         }
     198                 :            :     }
     199                 :            : 
     200                 :        156 :     return PyObject_GetAttr(im->im_func, name);
     201                 :            : }
     202                 :            : 
     203                 :            : /*[clinic input]
     204                 :            : @classmethod
     205                 :            : method.__new__ as method_new
     206                 :            :     function: object
     207                 :            :     instance: object
     208                 :            :     /
     209                 :            : 
     210                 :            : Create a bound instance method object.
     211                 :            : [clinic start generated code]*/
     212                 :            : 
     213                 :            : static PyObject *
     214                 :          0 : method_new_impl(PyTypeObject *type, PyObject *function, PyObject *instance)
     215                 :            : /*[clinic end generated code: output=d33ef4ebf702e1f7 input=4e32facc3c3108ae]*/
     216                 :            : {
     217         [ #  # ]:          0 :     if (!PyCallable_Check(function)) {
     218                 :          0 :         PyErr_SetString(PyExc_TypeError,
     219                 :            :                         "first argument must be callable");
     220                 :          0 :         return NULL;
     221                 :            :     }
     222   [ #  #  #  # ]:          0 :     if (instance == NULL || instance == Py_None) {
     223                 :          0 :         PyErr_SetString(PyExc_TypeError,
     224                 :            :             "instance must not be None");
     225                 :          0 :         return NULL;
     226                 :            :     }
     227                 :            : 
     228                 :          0 :     return PyMethod_New(function, instance);
     229                 :            : }
     230                 :            : 
     231                 :            : static void
     232                 :     550818 : method_dealloc(PyMethodObject *im)
     233                 :            : {
     234                 :     550818 :     _PyObject_GC_UNTRACK(im);
     235         [ -  + ]:     550818 :     if (im->im_weakreflist != NULL)
     236                 :          0 :         PyObject_ClearWeakRefs((PyObject *)im);
     237                 :     550818 :     Py_DECREF(im->im_func);
     238                 :     550818 :     Py_XDECREF(im->im_self);
     239                 :     550818 :     PyObject_GC_Del(im);
     240                 :     550818 : }
     241                 :            : 
     242                 :            : static PyObject *
     243                 :          0 : method_richcompare(PyObject *self, PyObject *other, int op)
     244                 :            : {
     245                 :            :     PyMethodObject *a, *b;
     246                 :            :     PyObject *res;
     247                 :            :     int eq;
     248                 :            : 
     249   [ #  #  #  #  :          0 :     if ((op != Py_EQ && op != Py_NE) ||
                   #  # ]
     250         [ #  # ]:          0 :         !PyMethod_Check(self) ||
     251                 :          0 :         !PyMethod_Check(other))
     252                 :            :     {
     253                 :          0 :         Py_RETURN_NOTIMPLEMENTED;
     254                 :            :     }
     255                 :          0 :     a = (PyMethodObject *)self;
     256                 :          0 :     b = (PyMethodObject *)other;
     257                 :          0 :     eq = PyObject_RichCompareBool(a->im_func, b->im_func, Py_EQ);
     258         [ #  # ]:          0 :     if (eq == 1) {
     259                 :          0 :         eq = (a->im_self == b->im_self);
     260                 :            :     }
     261         [ #  # ]:          0 :     else if (eq < 0)
     262                 :          0 :         return NULL;
     263         [ #  # ]:          0 :     if (op == Py_EQ)
     264         [ #  # ]:          0 :         res = eq ? Py_True : Py_False;
     265                 :            :     else
     266         [ #  # ]:          0 :         res = eq ? Py_False : Py_True;
     267                 :          0 :     return Py_NewRef(res);
     268                 :            : }
     269                 :            : 
     270                 :            : static PyObject *
     271                 :          0 : method_repr(PyMethodObject *a)
     272                 :            : {
     273                 :          0 :     PyObject *self = a->im_self;
     274                 :          0 :     PyObject *func = a->im_func;
     275                 :            :     PyObject *funcname, *result;
     276                 :          0 :     const char *defname = "?";
     277                 :            : 
     278         [ #  # ]:          0 :     if (_PyObject_LookupAttr(func, &_Py_ID(__qualname__), &funcname) < 0 ||
     279   [ #  #  #  # ]:          0 :         (funcname == NULL &&
     280                 :          0 :          _PyObject_LookupAttr(func, &_Py_ID(__name__), &funcname) < 0))
     281                 :            :     {
     282                 :          0 :         return NULL;
     283                 :            :     }
     284                 :            : 
     285   [ #  #  #  # ]:          0 :     if (funcname != NULL && !PyUnicode_Check(funcname)) {
     286                 :          0 :         Py_SETREF(funcname, NULL);
     287                 :            :     }
     288                 :            : 
     289                 :            :     /* XXX Shouldn't use repr()/%R here! */
     290                 :          0 :     result = PyUnicode_FromFormat("<bound method %V of %R>",
     291                 :            :                                   funcname, defname, self);
     292                 :            : 
     293                 :          0 :     Py_XDECREF(funcname);
     294                 :          0 :     return result;
     295                 :            : }
     296                 :            : 
     297                 :            : static Py_hash_t
     298                 :          0 : method_hash(PyMethodObject *a)
     299                 :            : {
     300                 :            :     Py_hash_t x, y;
     301                 :          0 :     x = _Py_HashPointer(a->im_self);
     302                 :          0 :     y = PyObject_Hash(a->im_func);
     303         [ #  # ]:          0 :     if (y == -1)
     304                 :          0 :         return -1;
     305                 :          0 :     x = x ^ y;
     306         [ #  # ]:          0 :     if (x == -1)
     307                 :          0 :         x = -2;
     308                 :          0 :     return x;
     309                 :            : }
     310                 :            : 
     311                 :            : static int
     312                 :       3008 : method_traverse(PyMethodObject *im, visitproc visit, void *arg)
     313                 :            : {
     314   [ +  -  -  + ]:       3008 :     Py_VISIT(im->im_func);
     315   [ +  -  -  + ]:       3008 :     Py_VISIT(im->im_self);
     316                 :       3008 :     return 0;
     317                 :            : }
     318                 :            : 
     319                 :            : PyTypeObject PyMethod_Type = {
     320                 :            :     PyVarObject_HEAD_INIT(&PyType_Type, 0)
     321                 :            :     .tp_name = "method",
     322                 :            :     .tp_basicsize = sizeof(PyMethodObject),
     323                 :            :     .tp_dealloc = (destructor)method_dealloc,
     324                 :            :     .tp_vectorcall_offset = offsetof(PyMethodObject, vectorcall),
     325                 :            :     .tp_repr = (reprfunc)method_repr,
     326                 :            :     .tp_hash = (hashfunc)method_hash,
     327                 :            :     .tp_call = PyVectorcall_Call,
     328                 :            :     .tp_getattro = method_getattro,
     329                 :            :     .tp_setattro = PyObject_GenericSetAttr,
     330                 :            :     .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
     331                 :            :                 Py_TPFLAGS_HAVE_VECTORCALL,
     332                 :            :     .tp_doc = method_new__doc__,
     333                 :            :     .tp_traverse = (traverseproc)method_traverse,
     334                 :            :     .tp_richcompare = method_richcompare,
     335                 :            :     .tp_weaklistoffset = offsetof(PyMethodObject, im_weakreflist),
     336                 :            :     .tp_methods = method_methods,
     337                 :            :     .tp_members = method_memberlist,
     338                 :            :     .tp_getset = method_getset,
     339                 :            :     .tp_new = method_new,
     340                 :            : };
     341                 :            : 
     342                 :            : /* ------------------------------------------------------------------------
     343                 :            :  * instance method
     344                 :            :  */
     345                 :            : 
     346                 :            : /*[clinic input]
     347                 :            : class instancemethod "PyInstanceMethodObject *" "&PyInstanceMethod_Type"
     348                 :            : [clinic start generated code]*/
     349                 :            : /*[clinic end generated code: output=da39a3ee5e6b4b0d input=28c9762a9016f4d2]*/
     350                 :            : 
     351                 :            : PyObject *
     352                 :          0 : PyInstanceMethod_New(PyObject *func) {
     353                 :            :     PyInstanceMethodObject *method;
     354                 :          0 :     method = PyObject_GC_New(PyInstanceMethodObject,
     355                 :            :                              &PyInstanceMethod_Type);
     356         [ #  # ]:          0 :     if (method == NULL) return NULL;
     357                 :          0 :     method->func = Py_NewRef(func);
     358                 :          0 :     _PyObject_GC_TRACK(method);
     359                 :          0 :     return (PyObject *)method;
     360                 :            : }
     361                 :            : 
     362                 :            : PyObject *
     363                 :          0 : PyInstanceMethod_Function(PyObject *im)
     364                 :            : {
     365         [ #  # ]:          0 :     if (!PyInstanceMethod_Check(im)) {
     366                 :          0 :         PyErr_BadInternalCall();
     367                 :          0 :         return NULL;
     368                 :            :     }
     369                 :          0 :     return PyInstanceMethod_GET_FUNCTION(im);
     370                 :            : }
     371                 :            : 
     372                 :            : #define IMO_OFF(x) offsetof(PyInstanceMethodObject, x)
     373                 :            : 
     374                 :            : static PyMemberDef instancemethod_memberlist[] = {
     375                 :            :     {"__func__", T_OBJECT, IMO_OFF(func), READONLY,
     376                 :            :      "the function (or other callable) implementing a method"},
     377                 :            :     {NULL}      /* Sentinel */
     378                 :            : };
     379                 :            : 
     380                 :            : static PyObject *
     381                 :          0 : instancemethod_get_doc(PyObject *self, void *context)
     382                 :            : {
     383                 :          0 :     return PyObject_GetAttr(PyInstanceMethod_GET_FUNCTION(self),
     384                 :            :                             &_Py_ID(__doc__));
     385                 :            : }
     386                 :            : 
     387                 :            : static PyGetSetDef instancemethod_getset[] = {
     388                 :            :     {"__doc__", (getter)instancemethod_get_doc, NULL, NULL},
     389                 :            :     {0}
     390                 :            : };
     391                 :            : 
     392                 :            : static PyObject *
     393                 :          0 : instancemethod_getattro(PyObject *self, PyObject *name)
     394                 :            : {
     395                 :          0 :     PyTypeObject *tp = Py_TYPE(self);
     396                 :          0 :     PyObject *descr = NULL;
     397                 :            : 
     398         [ #  # ]:          0 :     if (tp->tp_dict == NULL) {
     399         [ #  # ]:          0 :         if (PyType_Ready(tp) < 0)
     400                 :          0 :             return NULL;
     401                 :            :     }
     402                 :          0 :     descr = _PyType_Lookup(tp, name);
     403                 :            : 
     404         [ #  # ]:          0 :     if (descr != NULL) {
     405                 :          0 :         descrgetfunc f = TP_DESCR_GET(Py_TYPE(descr));
     406         [ #  # ]:          0 :         if (f != NULL)
     407                 :          0 :             return f(descr, self, (PyObject *)Py_TYPE(self));
     408                 :            :         else {
     409                 :          0 :             return Py_NewRef(descr);
     410                 :            :         }
     411                 :            :     }
     412                 :            : 
     413                 :          0 :     return PyObject_GetAttr(PyInstanceMethod_GET_FUNCTION(self), name);
     414                 :            : }
     415                 :            : 
     416                 :            : static void
     417                 :          0 : instancemethod_dealloc(PyObject *self) {
     418                 :          0 :     _PyObject_GC_UNTRACK(self);
     419                 :          0 :     Py_DECREF(PyInstanceMethod_GET_FUNCTION(self));
     420                 :          0 :     PyObject_GC_Del(self);
     421                 :          0 : }
     422                 :            : 
     423                 :            : static int
     424                 :          0 : instancemethod_traverse(PyObject *self, visitproc visit, void *arg) {
     425   [ #  #  #  # ]:          0 :     Py_VISIT(PyInstanceMethod_GET_FUNCTION(self));
     426                 :          0 :     return 0;
     427                 :            : }
     428                 :            : 
     429                 :            : static PyObject *
     430                 :          0 : instancemethod_call(PyObject *self, PyObject *arg, PyObject *kw)
     431                 :            : {
     432                 :          0 :     return PyObject_Call(PyInstanceMethod_GET_FUNCTION(self), arg, kw);
     433                 :            : }
     434                 :            : 
     435                 :            : static PyObject *
     436                 :          0 : instancemethod_descr_get(PyObject *descr, PyObject *obj, PyObject *type) {
     437                 :          0 :     PyObject *func = PyInstanceMethod_GET_FUNCTION(descr);
     438         [ #  # ]:          0 :     if (obj == NULL) {
     439                 :          0 :         return Py_NewRef(func);
     440                 :            :     }
     441                 :            :     else
     442                 :          0 :         return PyMethod_New(func, obj);
     443                 :            : }
     444                 :            : 
     445                 :            : static PyObject *
     446                 :          0 : instancemethod_richcompare(PyObject *self, PyObject *other, int op)
     447                 :            : {
     448                 :            :     PyInstanceMethodObject *a, *b;
     449                 :            :     PyObject *res;
     450                 :            :     int eq;
     451                 :            : 
     452   [ #  #  #  #  :          0 :     if ((op != Py_EQ && op != Py_NE) ||
                   #  # ]
     453         [ #  # ]:          0 :         !PyInstanceMethod_Check(self) ||
     454                 :          0 :         !PyInstanceMethod_Check(other))
     455                 :            :     {
     456                 :          0 :         Py_RETURN_NOTIMPLEMENTED;
     457                 :            :     }
     458                 :          0 :     a = (PyInstanceMethodObject *)self;
     459                 :          0 :     b = (PyInstanceMethodObject *)other;
     460                 :          0 :     eq = PyObject_RichCompareBool(a->func, b->func, Py_EQ);
     461         [ #  # ]:          0 :     if (eq < 0)
     462                 :          0 :         return NULL;
     463         [ #  # ]:          0 :     if (op == Py_EQ)
     464         [ #  # ]:          0 :         res = eq ? Py_True : Py_False;
     465                 :            :     else
     466         [ #  # ]:          0 :         res = eq ? Py_False : Py_True;
     467                 :          0 :     return Py_NewRef(res);
     468                 :            : }
     469                 :            : 
     470                 :            : static PyObject *
     471                 :          0 : instancemethod_repr(PyObject *self)
     472                 :            : {
     473                 :          0 :     PyObject *func = PyInstanceMethod_Function(self);
     474                 :            :     PyObject *funcname, *result;
     475                 :          0 :     const char *defname = "?";
     476                 :            : 
     477         [ #  # ]:          0 :     if (func == NULL) {
     478                 :          0 :         PyErr_BadInternalCall();
     479                 :          0 :         return NULL;
     480                 :            :     }
     481                 :            : 
     482         [ #  # ]:          0 :     if (_PyObject_LookupAttr(func, &_Py_ID(__name__), &funcname) < 0) {
     483                 :          0 :         return NULL;
     484                 :            :     }
     485   [ #  #  #  # ]:          0 :     if (funcname != NULL && !PyUnicode_Check(funcname)) {
     486                 :          0 :         Py_SETREF(funcname, NULL);
     487                 :            :     }
     488                 :            : 
     489                 :          0 :     result = PyUnicode_FromFormat("<instancemethod %V at %p>",
     490                 :            :                                   funcname, defname, self);
     491                 :            : 
     492                 :          0 :     Py_XDECREF(funcname);
     493                 :          0 :     return result;
     494                 :            : }
     495                 :            : 
     496                 :            : /*[clinic input]
     497                 :            : @classmethod
     498                 :            : instancemethod.__new__ as instancemethod_new
     499                 :            :     function: object
     500                 :            :     /
     501                 :            : 
     502                 :            : Bind a function to a class.
     503                 :            : [clinic start generated code]*/
     504                 :            : 
     505                 :            : static PyObject *
     506                 :          0 : instancemethod_new_impl(PyTypeObject *type, PyObject *function)
     507                 :            : /*[clinic end generated code: output=5e0397b2bdb750be input=cfc54e8b973664a8]*/
     508                 :            : {
     509         [ #  # ]:          0 :     if (!PyCallable_Check(function)) {
     510                 :          0 :         PyErr_SetString(PyExc_TypeError,
     511                 :            :                         "first argument must be callable");
     512                 :          0 :         return NULL;
     513                 :            :     }
     514                 :            : 
     515                 :          0 :     return PyInstanceMethod_New(function);
     516                 :            : }
     517                 :            : 
     518                 :            : PyTypeObject PyInstanceMethod_Type = {
     519                 :            :     PyVarObject_HEAD_INIT(&PyType_Type, 0)
     520                 :            :     .tp_name = "instancemethod",
     521                 :            :     .tp_basicsize = sizeof(PyInstanceMethodObject),
     522                 :            :     .tp_dealloc = instancemethod_dealloc,
     523                 :            :     .tp_repr = (reprfunc)instancemethod_repr,
     524                 :            :     .tp_call = instancemethod_call,
     525                 :            :     .tp_getattro = instancemethod_getattro,
     526                 :            :     .tp_setattro = PyObject_GenericSetAttr,
     527                 :            :     .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
     528                 :            :     .tp_doc = instancemethod_new__doc__,
     529                 :            :     .tp_traverse = instancemethod_traverse,
     530                 :            :     .tp_richcompare = instancemethod_richcompare,
     531                 :            :     .tp_members = instancemethod_memberlist,
     532                 :            :     .tp_getset = instancemethod_getset,
     533                 :            :     .tp_descr_get = instancemethod_descr_get,
     534                 :            :     .tp_new = instancemethod_new,
     535                 :            : };

Generated by: LCOV version 1.14