Ignore:
Timestamp:
Mar 19, 2014, 11:11:30 AM (11 years ago)
Author:
dmik
Message:

python: Update vendor to 2.7.6.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • python/vendor/current/Objects/classobject.c

    r2 r388  
    1919/* Forward */
    2020static PyObject *class_lookup(PyClassObject *, PyObject *,
    21                               PyClassObject **);
     21                              PyClassObject **);
    2222static PyObject *instance_getattr1(PyInstanceObject *, PyObject *);
    2323static PyObject *instance_getattr2(PyInstanceObject *, PyObject *);
    … …  
    3030     /* bases is NULL or tuple of classobjects! */
    3131{
    32         PyClassObject *op, *dummy;
    33         static PyObject *docstr, *modstr, *namestr;
    34         if (docstr == NULL) {
    35                 docstr= PyString_InternFromString("__doc__");
    36                 if (docstr == NULL)
    37                         return NULL;
    38         }
    39         if (modstr == NULL) {
    40                 modstr= PyString_InternFromString("__module__");
    41                 if (modstr == NULL)
    42                         return NULL;
    43         }
    44         if (namestr == NULL) {
    45                 namestr= PyString_InternFromString("__name__");
    46                 if (namestr == NULL)
    47                         return NULL;
    48         }
    49         if (name == NULL || !PyString_Check(name)) {
    50                 PyErr_SetString(PyExc_TypeError,
    51                                 "PyClass_New: name must be a string");
    52                 return NULL;
    53         }
    54         if (dict == NULL || !PyDict_Check(dict)) {
    55                 PyErr_SetString(PyExc_TypeError,
    56                                 "PyClass_New: dict must be a dictionary");
    57                 return NULL;
    58         }
    59         if (PyDict_GetItem(dict, docstr) == NULL) {
    60                 if (PyDict_SetItem(dict, docstr, Py_None) < 0)
    61                         return NULL;
    62         }
    63         if (PyDict_GetItem(dict, modstr) == NULL) {
    64                 PyObject *globals = PyEval_GetGlobals();
    65                 if (globals != NULL) {
    66                         PyObject *modname = PyDict_GetItem(globals, namestr);
    67                         if (modname != NULL) {
    68                                 if (PyDict_SetItem(dict, modstr, modname) < 0)
    69                                         return NULL;
    70                         }
    71                 }
    72         }
    73         if (bases == NULL) {
    74                 bases = PyTuple_New(0);
    75                 if (bases == NULL)
    76                         return NULL;
    77         }
    78         else {
    79                 Py_ssize_t i, n;
    80                 PyObject *base;
    81                 if (!PyTuple_Check(bases)) {
    82                         PyErr_SetString(PyExc_TypeError,
    83                                         "PyClass_New: bases must be a tuple");
    84                         return NULL;
    85                 }
    86                 n = PyTuple_Size(bases);
    87                 for (i = 0; i < n; i++) {
    88                         base = PyTuple_GET_ITEM(bases, i);
    89                         if (!PyClass_Check(base)) {
    90                                 if (PyCallable_Check(
    91                                         (PyObject *) base->ob_type))
    92                                         return PyObject_CallFunctionObjArgs(
    93                                                 (PyObject *) base->ob_type,
    94                                                 name, bases, dict, NULL);
    95                                 PyErr_SetString(PyExc_TypeError,
    96                                         "PyClass_New: base must be a class");
    97                                 return NULL;
    98                         }
    99                 }
    100                 Py_INCREF(bases);
    101         }
    102 
    103         if (getattrstr == NULL) {
    104                 getattrstr = PyString_InternFromString("__getattr__");
    105                 if (getattrstr == NULL)
    106                         goto alloc_error;
    107                 setattrstr = PyString_InternFromString("__setattr__");
    108                 if (setattrstr == NULL)
    109                         goto alloc_error;
    110                 delattrstr = PyString_InternFromString("__delattr__");
    111                 if (delattrstr == NULL)
    112                         goto alloc_error;
    113         }
    114 
    115         op = PyObject_GC_New(PyClassObject, &PyClass_Type);
    116         if (op == NULL) {
     32    PyClassObject *op, *dummy;
     33    static PyObject *docstr, *modstr, *namestr;
     34    if (docstr == NULL) {
     35        docstr= PyString_InternFromString("__doc__");
     36        if (docstr == NULL)
     37            return NULL;
     38    }
     39    if (modstr == NULL) {
     40        modstr= PyString_InternFromString("__module__");
     41        if (modstr == NULL)
     42            return NULL;
     43    }
     44    if (namestr == NULL) {
     45        namestr= PyString_InternFromString("__name__");
     46        if (namestr == NULL)
     47            return NULL;
     48    }
     49    if (name == NULL || !PyString_Check(name)) {
     50        PyErr_SetString(PyExc_TypeError,
     51                        "PyClass_New: name must be a string");
     52        return NULL;
     53    }
     54    if (dict == NULL || !PyDict_Check(dict)) {
     55        PyErr_SetString(PyExc_TypeError,
     56                        "PyClass_New: dict must be a dictionary");
     57        return NULL;
     58    }
     59    if (PyDict_GetItem(dict, docstr) == NULL) {
     60        if (PyDict_SetItem(dict, docstr, Py_None) < 0)
     61            return NULL;
     62    }
     63    if (PyDict_GetItem(dict, modstr) == NULL) {
     64        PyObject *globals = PyEval_GetGlobals();
     65        if (globals != NULL) {
     66            PyObject *modname = PyDict_GetItem(globals, namestr);
     67            if (modname != NULL) {
     68                if (PyDict_SetItem(dict, modstr, modname) < 0)
     69                    return NULL;
     70            }
     71        }
     72    }
     73    if (bases == NULL) {
     74        bases = PyTuple_New(0);
     75        if (bases == NULL)
     76            return NULL;
     77    }
     78    else {
     79        Py_ssize_t i, n;
     80        PyObject *base;
     81        if (!PyTuple_Check(bases)) {
     82            PyErr_SetString(PyExc_TypeError,
     83                            "PyClass_New: bases must be a tuple");
     84            return NULL;
     85        }
     86        n = PyTuple_Size(bases);
     87        for (i = 0; i < n; i++) {
     88            base = PyTuple_GET_ITEM(bases, i);
     89            if (!PyClass_Check(base)) {
     90                if (PyCallable_Check(
     91                    (PyObject *) base->ob_type))
     92                    return PyObject_CallFunctionObjArgs(
     93                        (PyObject *) base->ob_type,
     94                        name, bases, dict, NULL);
     95                PyErr_SetString(PyExc_TypeError,
     96                    "PyClass_New: base must be a class");
     97                return NULL;
     98            }
     99        }
     100        Py_INCREF(bases);
     101    }
     102
     103    if (getattrstr == NULL) {
     104        getattrstr = PyString_InternFromString("__getattr__");
     105        if (getattrstr == NULL)
     106            goto alloc_error;
     107        setattrstr = PyString_InternFromString("__setattr__");
     108        if (setattrstr == NULL)
     109            goto alloc_error;
     110        delattrstr = PyString_InternFromString("__delattr__");
     111        if (delattrstr == NULL)
     112            goto alloc_error;
     113    }
     114
     115    op = PyObject_GC_New(PyClassObject, &PyClass_Type);
     116    if (op == NULL) {
    117117alloc_error:
    118                 Py_DECREF(bases);
    119                 return NULL;
    120         }
    121         op->cl_bases = bases;
    122         Py_INCREF(dict);
    123         op->cl_dict = dict;
    124         Py_XINCREF(name);
    125         op->cl_name = name;
    126 
    127         op->cl_getattr = class_lookup(op, getattrstr, &dummy);
    128         op->cl_setattr = class_lookup(op, setattrstr, &dummy);
    129         op->cl_delattr = class_lookup(op, delattrstr, &dummy);
    130         Py_XINCREF(op->cl_getattr);
    131         Py_XINCREF(op->cl_setattr);
    132         Py_XINCREF(op->cl_delattr);
    133         _PyObject_GC_TRACK(op);
    134         return (PyObject *) op;
     118        Py_DECREF(bases);
     119        return NULL;
     120    }
     121    op->cl_bases = bases;
     122    Py_INCREF(dict);
     123    op->cl_dict = dict;
     124    Py_XINCREF(name);
     125    op->cl_name = name;
     126    op->cl_weakreflist = NULL;
     127
     128    op->cl_getattr = class_lookup(op, getattrstr, &dummy);
     129    op->cl_setattr = class_lookup(op, setattrstr, &dummy);
     130    op->cl_delattr = class_lookup(op, delattrstr, &dummy);
     131    Py_XINCREF(op->cl_getattr);
     132    Py_XINCREF(op->cl_setattr);
     133    Py_XINCREF(op->cl_delattr);
     134    _PyObject_GC_TRACK(op);
     135    return (PyObject *) op;
    135136}
    136137
    … …  
    138139PyMethod_Function(PyObject *im)
    139140{
    140         if (!PyMethod_Check(im)) {
    141                 PyErr_BadInternalCall();
    142                 return NULL;
    143         }
    144         return ((PyMethodObject *)im)->im_func;
     141    if (!PyMethod_Check(im)) {
     142        PyErr_BadInternalCall();
     143        return NULL;
     144    }
     145    return ((PyMethodObject *)im)->im_func;
    145146}
    146147
    … …  
    148149PyMethod_Self(PyObject *im)
    149150{
    150         if (!PyMethod_Check(im)) {
    151                 PyErr_BadInternalCall();
    152                 return NULL;
    153         }
    154         return ((PyMethodObject *)im)->im_self;
     151    if (!PyMethod_Check(im)) {
     152        PyErr_BadInternalCall();
     153        return NULL;
     154    }
     155    return ((PyMethodObject *)im)->im_self;
    155156}
    156157
    … …  
    158159PyMethod_Class(PyObject *im)
    159160{
    160         if (!PyMethod_Check(im)) {
    161                 PyErr_BadInternalCall();
    162                 return NULL;
    163         }
    164         return ((PyMethodObject *)im)->im_class;
     161    if (!PyMethod_Check(im)) {
     162        PyErr_BadInternalCall();
     163        return NULL;
     164    }
     165    return ((PyMethodObject *)im)->im_class;
    165166}
    166167
    … …  
    174175class_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
    175176{
    176         PyObject *name, *bases, *dict;
    177         static char *kwlist[] = {"name", "bases", "dict", 0};
    178 
    179         if (!PyArg_ParseTupleAndKeywords(args, kwds, "SOO", kwlist,
    180                                         &name, &bases, &dict))
    181                 return NULL;
    182         return PyClass_New(bases, dict, name);
     177    PyObject *name, *bases, *dict;
     178    static char *kwlist[] = {"name", "bases", "dict", 0};
     179
     180    if (!PyArg_ParseTupleAndKeywords(args, kwds, "SOO", kwlist,
     181                                    &name, &bases, &dict))
     182        return NULL;
     183    return PyClass_New(bases, dict, name);
    183184}
    184185
    … …  
    188189class_dealloc(PyClassObject *op)
    189190{
    190         _PyObject_GC_UNTRACK(op);
    191         Py_DECREF(op->cl_bases);
    192         Py_DECREF(op->cl_dict);
    193         Py_XDECREF(op->cl_name);
    194         Py_XDECREF(op->cl_getattr);
    195         Py_XDECREF(op->cl_setattr);
    196         Py_XDECREF(op->cl_delattr);
    197         PyObject_GC_Del(op);
     191    _PyObject_GC_UNTRACK(op);
     192    if (op->cl_weakreflist != NULL)
     193        PyObject_ClearWeakRefs((PyObject *) op);
     194    Py_DECREF(op->cl_bases);
     195    Py_DECREF(op->cl_dict);
     196    Py_XDECREF(op->cl_name);
     197    Py_XDECREF(op->cl_getattr);
     198    Py_XDECREF(op->cl_setattr);
     199    Py_XDECREF(op->cl_delattr);
     200    PyObject_GC_Del(op);
    198201}
    199202
    … …  
    201204class_lookup(PyClassObject *cp, PyObject *name, PyClassObject **pclass)
    202205{
    203         Py_ssize_t i, n;
    204         PyObject *value = PyDict_GetItem(cp->cl_dict, name);
    205         if (value != NULL) {
    206                 *pclass = cp;
    207                 return value;
    208         }
    209         n = PyTuple_Size(cp->cl_bases);
    210         for (i = 0; i < n; i++) {
    211                 /* XXX What if one of the bases is not a class? */
    212                 PyObject *v = class_lookup(
    213                         (PyClassObject *)
    214                         PyTuple_GetItem(cp->cl_bases, i), name, pclass);
    215                 if (v != NULL)
    216                         return v;
    217         }
    218         return NULL;
     206    Py_ssize_t i, n;
     207    PyObject *value = PyDict_GetItem(cp->cl_dict, name);
     208    if (value != NULL) {
     209        *pclass = cp;
     210        return value;
     211    }
     212    n = PyTuple_Size(cp->cl_bases);
     213    for (i = 0; i < n; i++) {
     214        /* XXX What if one of the bases is not a class? */
     215        PyObject *v = class_lookup(
     216            (PyClassObject *)
     217            PyTuple_GetItem(cp->cl_bases, i), name, pclass);
     218        if (v != NULL)
     219            return v;
     220    }
     221    return NULL;
    219222}
    220223
    … …  
    222225class_getattr(register PyClassObject *op, PyObject *name)
    223226{
    224         register PyObject *v;
    225         register char *sname = PyString_AsString(name);
    226         PyClassObject *klass;
    227         descrgetfunc f;
    228 
    229         if (sname[0] == '_' && sname[1] == '_') {
    230                 if (strcmp(sname, "__dict__") == 0) {
    231                         if (PyEval_GetRestricted()) {
    232                                 PyErr_SetString(PyExc_RuntimeError,
    233                            "class.__dict__ not accessible in restricted mode");
    234                                 return NULL;
    235                         }
    236                         Py_INCREF(op->cl_dict);
    237                         return op->cl_dict;
    238                 }
    239                 if (strcmp(sname, "__bases__") == 0) {
    240                         Py_INCREF(op->cl_bases);
    241                         return op->cl_bases;
    242                 }
    243                 if (strcmp(sname, "__name__") == 0) {
    244                         if (op->cl_name == NULL)
    245                                 v = Py_None;
    246                         else
    247                                 v = op->cl_name;
    248                         Py_INCREF(v);
    249                         return v;
    250                 }
    251         }
    252         v = class_lookup(op, name, &klass);
    253         if (v == NULL) {
    254                 PyErr_Format(PyExc_AttributeError,
    255                              "class %.50s has no attribute '%.400s'",
    256                              PyString_AS_STRING(op->cl_name), sname);
    257                 return NULL;
    258         }
    259         f = TP_DESCR_GET(v->ob_type);
    260         if (f == NULL)
    261                 Py_INCREF(v);
    262         else
    263                 v = f(v, (PyObject *)NULL, (PyObject *)op);
    264         return v;
     227    register PyObject *v;
     228    register char *sname;
     229    PyClassObject *klass;
     230    descrgetfunc f;
     231
     232    if (!PyString_Check(name)) {
     233        PyErr_SetString(PyExc_TypeError, "attribute name must be a string");
     234        return NULL;
     235    }
     236
     237    sname = PyString_AsString(name);
     238    if (sname[0] == '_' && sname[1] == '_') {
     239        if (strcmp(sname, "__dict__") == 0) {
     240            if (PyEval_GetRestricted()) {
     241                PyErr_SetString(PyExc_RuntimeError,
     242               "class.__dict__ not accessible in restricted mode");
     243                return NULL;
     244            }
     245            Py_INCREF(op->cl_dict);
     246            return op->cl_dict;
     247        }
     248        if (strcmp(sname, "__bases__") == 0) {
     249            Py_INCREF(op->cl_bases);
     250            return op->cl_bases;
     251        }
     252        if (strcmp(sname, "__name__") == 0) {
     253            if (op->cl_name == NULL)
     254                v = Py_None;
     255            else
     256                v = op->cl_name;
     257            Py_INCREF(v);
     258            return v;
     259        }
     260    }
     261    v = class_lookup(op, name, &klass);
     262    if (v == NULL) {
     263        PyErr_Format(PyExc_AttributeError,
     264                     "class %.50s has no attribute '%.400s'",
     265                     PyString_AS_STRING(op->cl_name), sname);
     266        return NULL;
     267    }
     268    f = TP_DESCR_GET(v->ob_type);
     269    if (f == NULL)
     270        Py_INCREF(v);
     271    else
     272        v = f(v, (PyObject *)NULL, (PyObject *)op);
     273    return v;
    265274}
    266275
    … …  
    268277set_slot(PyObject **slot, PyObject *v)
    269278{
    270         PyObject *temp = *slot;
    271         Py_XINCREF(v);
    272         *slot = v;
    273         Py_XDECREF(temp);
     279    PyObject *temp = *slot;
     280    Py_XINCREF(v);
     281    *slot = v;
     282    Py_XDECREF(temp);
    274283}
    275284
    … …  
    277286set_attr_slots(PyClassObject *c)
    278287{
    279         PyClassObject *dummy;
    280 
    281         set_slot(&c->cl_getattr, class_lookup(c, getattrstr, &dummy));
    282         set_slot(&c->cl_setattr, class_lookup(c, setattrstr, &dummy));
    283         set_slot(&c->cl_delattr, class_lookup(c, delattrstr, &dummy));
     288    PyClassObject *dummy;
     289
     290    set_slot(&c->cl_getattr, class_lookup(c, getattrstr, &dummy));
     291    set_slot(&c->cl_setattr, class_lookup(c, setattrstr, &dummy));
     292    set_slot(&c->cl_delattr, class_lookup(c, delattrstr, &dummy));
    284293}
    285294
    … …  
    287296set_dict(PyClassObject *c, PyObject *v)
    288297{
    289         if (v == NULL || !PyDict_Check(v))
    290                 return "__dict__ must be a dictionary object";
    291         set_slot(&c->cl_dict, v);
    292         set_attr_slots(c);
    293         return "";
     298    if (v == NULL || !PyDict_Check(v))
     299        return "__dict__ must be a dictionary object";
     300    set_slot(&c->cl_dict, v);
     301    set_attr_slots(c);
     302    return "";
    294303}
    295304
    … …  
    297306set_bases(PyClassObject *c, PyObject *v)
    298307{
    299         Py_ssize_t i, n;
    300 
    301         if (v == NULL || !PyTuple_Check(v))
    302                 return "__bases__ must be a tuple object";
    303         n = PyTuple_Size(v);
    304         for (i = 0; i < n; i++) {
    305                 PyObject *x = PyTuple_GET_ITEM(v, i);
    306                 if (!PyClass_Check(x))
    307                         return "__bases__ items must be classes";
    308                 if (PyClass_IsSubclass(x, (PyObject *)c))
    309                         return "a __bases__ item causes an inheritance cycle";
    310         }
    311         set_slot(&c->cl_bases, v);
    312         set_attr_slots(c);
    313         return "";
     308    Py_ssize_t i, n;
     309
     310    if (v == NULL || !PyTuple_Check(v))
     311        return "__bases__ must be a tuple object";
     312    n = PyTuple_Size(v);
     313    for (i = 0; i < n; i++) {
     314        PyObject *x = PyTuple_GET_ITEM(v, i);
     315        if (!PyClass_Check(x))
     316            return "__bases__ items must be classes";
     317        if (PyClass_IsSubclass(x, (PyObject *)c))
     318            return "a __bases__ item causes an inheritance cycle";
     319    }
     320    set_slot(&c->cl_bases, v);
     321    set_attr_slots(c);
     322    return "";
    314323}
    315324
    … …  
    317326set_name(PyClassObject *c, PyObject *v)
    318327{
    319         if (v == NULL || !PyString_Check(v))
    320                 return "__name__ must be a string object";
    321         if (strlen(PyString_AS_STRING(v)) != (size_t)PyString_GET_SIZE(v))
    322                 return "__name__ must not contain null bytes";
    323         set_slot(&c->cl_name, v);
    324         return "";
     328    if (v == NULL || !PyString_Check(v))
     329        return "__name__ must be a string object";
     330    if (strlen(PyString_AS_STRING(v)) != (size_t)PyString_GET_SIZE(v))
     331        return "__name__ must not contain null bytes";
     332    set_slot(&c->cl_name, v);
     333    return "";
    325334}
    326335
    … …  
    328337class_setattr(PyClassObject *op, PyObject *name, PyObject *v)
    329338{
    330         char *sname;
    331         if (PyEval_GetRestricted()) {
    332                 PyErr_SetString(PyExc_RuntimeError,
    333                            "classes are read-only in restricted mode");
    334                 return -1;
    335         }
    336         sname = PyString_AsString(name);
    337         if (sname[0] == '_' && sname[1] == '_') {
    338                 Py_ssize_t n = PyString_Size(name);
    339                 if (sname[n-1] == '_' && sname[n-2] == '_') {
    340                         char *err = NULL;
    341                         if (strcmp(sname, "__dict__") == 0)
    342                                 err = set_dict(op, v);
    343                         else if (strcmp(sname, "__bases__") == 0)
    344                                 err = set_bases(op, v);
    345                         else if (strcmp(sname, "__name__") == 0)
    346                                 err = set_name(op, v);
    347                         else if (strcmp(sname, "__getattr__") == 0)
    348                                 set_slot(&op->cl_getattr, v);
    349                         else if (strcmp(sname, "__setattr__") == 0)
    350                                 set_slot(&op->cl_setattr, v);
    351                         else if (strcmp(sname, "__delattr__") == 0)
    352                                 set_slot(&op->cl_delattr, v);
    353                         /* For the last three, we fall through to update the
    354                            dictionary as well. */
    355                         if (err != NULL) {
    356                                 if (*err == '\0')
    357                                         return 0;
    358                                 PyErr_SetString(PyExc_TypeError, err);
    359                                 return -1;
    360                         }
    361                 }
    362         }
    363         if (v == NULL) {
    364                 int rv = PyDict_DelItem(op->cl_dict, name);
    365                 if (rv < 0)
    366                         PyErr_Format(PyExc_AttributeError,
    367                                      "class %.50s has no attribute '%.400s'",
    368                                      PyString_AS_STRING(op->cl_name), sname);
    369                 return rv;
    370         }
    371         else
    372                 return PyDict_SetItem(op->cl_dict, name, v);
     339    char *sname;
     340    if (PyEval_GetRestricted()) {
     341        PyErr_SetString(PyExc_RuntimeError,
     342                   "classes are read-only in restricted mode");
     343        return -1;
     344    }
     345    if (!PyString_Check(name)) {
     346        PyErr_SetString(PyExc_TypeError, "attribute name must be a string");
     347        return -1;
     348    }
     349    sname = PyString_AsString(name);
     350    if (sname[0] == '_' && sname[1] == '_') {
     351        Py_ssize_t n = PyString_Size(name);
     352        if (sname[n-1] == '_' && sname[n-2] == '_') {
     353            char *err = NULL;
     354            if (strcmp(sname, "__dict__") == 0)
     355                err = set_dict(op, v);
     356            else if (strcmp(sname, "__bases__") == 0)
     357                err = set_bases(op, v);
     358            else if (strcmp(sname, "__name__") == 0)
     359                err = set_name(op, v);
     360            else if (strcmp(sname, "__getattr__") == 0)
     361                set_slot(&op->cl_getattr, v);
     362            else if (strcmp(sname, "__setattr__") == 0)
     363                set_slot(&op->cl_setattr, v);
     364            else if (strcmp(sname, "__delattr__") == 0)
     365                set_slot(&op->cl_delattr, v);
     366            /* For the last three, we fall through to update the
     367               dictionary as well. */
     368            if (err != NULL) {
     369                if (*err == '\0')
     370                    return 0;
     371                PyErr_SetString(PyExc_TypeError, err);
     372                return -1;
     373            }
     374        }
     375    }
     376    if (v == NULL) {
     377        int rv = PyDict_DelItem(op->cl_dict, name);
     378        if (rv < 0)
     379            PyErr_Format(PyExc_AttributeError,
     380                         "class %.50s has no attribute '%.400s'",
     381                         PyString_AS_STRING(op->cl_name), sname);
     382        return rv;
     383    }
     384    else
     385        return PyDict_SetItem(op->cl_dict, name, v);
    373386}
    374387
    … …  
    376389class_repr(PyClassObject *op)
    377390{
    378         PyObject *mod = PyDict_GetItemString(op->cl_dict, "__module__");
    379         char *name;
    380         if (op->cl_name == NULL || !PyString_Check(op->cl_name))
    381                 name = "?";
    382         else
    383                 name = PyString_AsString(op->cl_name);
    384         if (mod == NULL || !PyString_Check(mod))
    385                 return PyString_FromFormat("<class ?.%s at %p>", name, op);
    386         else
    387                 return PyString_FromFormat("<class %s.%s at %p>",
    388                                            PyString_AsString(mod),
    389                                            name, op);
     391    PyObject *mod = PyDict_GetItemString(op->cl_dict, "__module__");
     392    char *name;
     393    if (op->cl_name == NULL || !PyString_Check(op->cl_name))
     394        name = "?";
     395    else
     396        name = PyString_AsString(op->cl_name);
     397    if (mod == NULL || !PyString_Check(mod))
     398        return PyString_FromFormat("<class ?.%s at %p>", name, op);
     399    else
     400        return PyString_FromFormat("<class %s.%s at %p>",
     401                                   PyString_AsString(mod),
     402                                   name, op);
    390403}
    391404
    … …  
    393406class_str(PyClassObject *op)
    394407{
    395         PyObject *mod = PyDict_GetItemString(op->cl_dict, "__module__");
    396         PyObject *name = op->cl_name;
    397         PyObject *res;
    398         Py_ssize_t m, n;
    399 
    400         if (name == NULL || !PyString_Check(name))
    401                 return class_repr(op);
    402         if (mod == NULL || !PyString_Check(mod)) {
    403                 Py_INCREF(name);
    404                 return name;
    405         }
    406         m = PyString_GET_SIZE(mod);
    407         n = PyString_GET_SIZE(name);
    408         res = PyString_FromStringAndSize((char *)NULL, m+1+n);
    409         if (res != NULL) {
    410                 char *s = PyString_AS_STRING(res);
    411                 memcpy(s, PyString_AS_STRING(mod), m);
    412                 s += m;
    413                 *s++ = '.';
    414                 memcpy(s, PyString_AS_STRING(name), n);
    415         }
    416         return res;
     408    PyObject *mod = PyDict_GetItemString(op->cl_dict, "__module__");
     409    PyObject *name = op->cl_name;
     410    PyObject *res;
     411    Py_ssize_t m, n;
     412
     413    if (name == NULL || !PyString_Check(name))
     414        return class_repr(op);
     415    if (mod == NULL || !PyString_Check(mod)) {
     416        Py_INCREF(name);
     417        return name;
     418    }
     419    m = PyString_GET_SIZE(mod);
     420    n = PyString_GET_SIZE(name);
     421    res = PyString_FromStringAndSize((char *)NULL, m+1+n);
     422    if (res != NULL) {
     423        char *s = PyString_AS_STRING(res);
     424        memcpy(s, PyString_AS_STRING(mod), m);
     425        s += m;
     426        *s++ = '.';
     427        memcpy(s, PyString_AS_STRING(name), n);
     428    }
     429    return res;
    417430}
    418431
    … …  
    420433class_traverse(PyClassObject *o, visitproc visit, void *arg)
    421434{
    422         Py_VISIT(o->cl_bases);
    423         Py_VISIT(o->cl_dict);
    424         Py_VISIT(o->cl_name);
    425         Py_VISIT(o->cl_getattr);
    426         Py_VISIT(o->cl_setattr);
    427         Py_VISIT(o->cl_delattr);
    428         return 0;
     435    Py_VISIT(o->cl_bases);
     436    Py_VISIT(o->cl_dict);
     437    Py_VISIT(o->cl_name);
     438    Py_VISIT(o->cl_getattr);
     439    Py_VISIT(o->cl_setattr);
     440    Py_VISIT(o->cl_delattr);
     441    return 0;
    429442}
    430443
    431444PyTypeObject PyClass_Type = {
    432         PyObject_HEAD_INIT(&PyType_Type)
    433         0,
    434         "classobj",
    435         sizeof(PyClassObject),
    436         0,
    437         (destructor)class_dealloc,              /* tp_dealloc */
    438         0,                                      /* tp_print */
    439         0,                                      /* tp_getattr */
    440         0,                                      /* tp_setattr */
    441         0,                                      /* tp_compare */
    442         (reprfunc)class_repr,                   /* tp_repr */
    443         0,                                      /* tp_as_number */
    444         0,                                      /* tp_as_sequence */
    445         0,                                      /* tp_as_mapping */
    446         0,                                      /* tp_hash */
    447         PyInstance_New,                         /* tp_call */
    448         (reprfunc)class_str,                    /* tp_str */
    449         (getattrofunc)class_getattr,            /* tp_getattro */
    450         (setattrofunc)class_setattr,            /* tp_setattro */
    451         0,                                      /* tp_as_buffer */
    452         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
    453         class_doc,                              /* tp_doc */
    454         (traverseproc)class_traverse,           /* tp_traverse */
    455         0,                                      /* tp_clear */
    456         0,                                      /* tp_richcompare */
    457         0,                                      /* tp_weaklistoffset */
    458         0,                                      /* tp_iter */
    459         0,                                      /* tp_iternext */
    460         0,                                      /* tp_methods */
    461         0,                                      /* tp_members */
    462         0,                                      /* tp_getset */
    463         0,                                      /* tp_base */
    464         0,                                      /* tp_dict */
    465         0,                                      /* tp_descr_get */
    466         0,                                      /* tp_descr_set */
    467         0,                                      /* tp_dictoffset */
    468         0,                                      /* tp_init */
    469         0,                                      /* tp_alloc */
    470         class_new,                              /* tp_new */
     445    PyObject_HEAD_INIT(&PyType_Type)
     446    0,
     447    "classobj",
     448    sizeof(PyClassObject),
     449    0,
     450    (destructor)class_dealloc,                  /* tp_dealloc */
     451    0,                                          /* tp_print */
     452    0,                                          /* tp_getattr */
     453    0,                                          /* tp_setattr */
     454    0,                                          /* tp_compare */
     455    (reprfunc)class_repr,                       /* tp_repr */
     456    0,                                          /* tp_as_number */
     457    0,                                          /* tp_as_sequence */
     458    0,                                          /* tp_as_mapping */
     459    0,                                          /* tp_hash */
     460    PyInstance_New,                             /* tp_call */
     461    (reprfunc)class_str,                        /* tp_str */
     462    (getattrofunc)class_getattr,                /* tp_getattro */
     463    (setattrofunc)class_setattr,                /* tp_setattro */
     464    0,                                          /* tp_as_buffer */
     465    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
     466    class_doc,                                  /* tp_doc */
     467    (traverseproc)class_traverse,               /* tp_traverse */
     468    0,                                          /* tp_clear */
     469    0,                                          /* tp_richcompare */
     470    offsetof(PyClassObject, cl_weakreflist), /* tp_weaklistoffset */
     471    0,                                          /* tp_iter */
     472    0,                                          /* tp_iternext */
     473    0,                                          /* tp_methods */
     474    0,                                          /* tp_members */
     475    0,                                          /* tp_getset */
     476    0,                                          /* tp_base */
     477    0,                                          /* tp_dict */
     478    0,                                          /* tp_descr_get */
     479    0,                                          /* tp_descr_set */
     480    0,                                          /* tp_dictoffset */
     481    0,                                          /* tp_init */
     482    0,                                          /* tp_alloc */
     483    class_new,                                  /* tp_new */
    471484};
    472485
    … …  
    474487PyClass_IsSubclass(PyObject *klass, PyObject *base)
    475488{
    476         Py_ssize_t i, n;
    477         PyClassObject *cp;
    478         if (klass == base)
    479                 return 1;
    480         if (PyTuple_Check(base)) {
    481                 n = PyTuple_GET_SIZE(base);
    482                 for (i = 0; i < n; i++) {
    483                         if (PyClass_IsSubclass(klass, PyTuple_GET_ITEM(base, i)))
    484                                 return 1;
    485                 }
    486                 return 0;
    487         }
    488         if (klass == NULL || !PyClass_Check(klass))
    489                 return 0;
    490         cp = (PyClassObject *)klass;
    491         n = PyTuple_Size(cp->cl_bases);
    492         for (i = 0; i < n; i++) {
    493                 if (PyClass_IsSubclass(PyTuple_GetItem(cp->cl_bases, i), base))
    494                         return 1;
    495         }
    496         return 0;
     489    Py_ssize_t i, n;
     490    PyClassObject *cp;
     491    if (klass == base)
     492        return 1;
     493    if (PyTuple_Check(base)) {
     494        n = PyTuple_GET_SIZE(base);
     495        for (i = 0; i < n; i++) {
     496            if (PyClass_IsSubclass(klass, PyTuple_GET_ITEM(base, i)))
     497                return 1;
     498        }
     499        return 0;
     500    }
     501    if (klass == NULL || !PyClass_Check(klass))
     502        return 0;
     503    cp = (PyClassObject *)klass;
     504    n = PyTuple_Size(cp->cl_bases);
     505    for (i = 0; i < n; i++) {
     506        if (PyClass_IsSubclass(PyTuple_GetItem(cp->cl_bases, i), base))
     507            return 1;
     508    }
     509    return 0;
    497510}
    498511
    … …  
    503516PyInstance_NewRaw(PyObject *klass, PyObject *dict)
    504517{
    505         PyInstanceObject *inst;
    506 
    507         if (!PyClass_Check(klass)) {
    508                 PyErr_BadInternalCall();
    509                 return NULL;
    510         }
    511         if (dict == NULL) {
    512                 dict = PyDict_New();
    513                 if (dict == NULL)
    514                         return NULL;
    515         }
    516         else {
    517                 if (!PyDict_Check(dict)) {
    518                         PyErr_BadInternalCall();
    519                         return NULL;
    520                 }
    521                 Py_INCREF(dict);
    522         }
    523         inst = PyObject_GC_New(PyInstanceObject, &PyInstance_Type);
    524         if (inst == NULL) {
    525                 Py_DECREF(dict);
    526                 return NULL;
    527         }
    528         inst->in_weakreflist = NULL;
    529         Py_INCREF(klass);
    530         inst->in_class = (PyClassObject *)klass;
    531         inst->in_dict = dict;
    532         _PyObject_GC_TRACK(inst);
    533         return (PyObject *)inst;
     518    PyInstanceObject *inst;
     519
     520    if (!PyClass_Check(klass)) {
     521        PyErr_BadInternalCall();
     522        return NULL;
     523    }
     524    if (dict == NULL) {
     525        dict = PyDict_New();
     526        if (dict == NULL)
     527            return NULL;
     528    }
     529    else {
     530        if (!PyDict_Check(dict)) {
     531            PyErr_BadInternalCall();
     532            return NULL;
     533        }
     534        Py_INCREF(dict);
     535    }
     536    inst = PyObject_GC_New(PyInstanceObject, &PyInstance_Type);
     537    if (inst == NULL) {
     538        Py_DECREF(dict);
     539        return NULL;
     540    }
     541    inst->in_weakreflist = NULL;
     542    Py_INCREF(klass);
     543    inst->in_class = (PyClassObject *)klass;
     544    inst->in_dict = dict;
     545    _PyObject_GC_TRACK(inst);
     546    return (PyObject *)inst;
    534547}
    535548
    … …  
    537550PyInstance_New(PyObject *klass, PyObject *arg, PyObject *kw)
    538551{
    539         register PyInstanceObject *inst;
    540         PyObject *init;
    541         static PyObject *initstr;
    542 
    543         if (initstr == NULL) {
    544                 initstr = PyString_InternFromString("__init__");
    545                 if (initstr == NULL)
    546                         return NULL;
    547         }
    548         inst = (PyInstanceObject *) PyInstance_NewRaw(klass, NULL);
    549         if (inst == NULL)
    550                 return NULL;
    551         init = instance_getattr2(inst, initstr);
    552         if (init == NULL) {
    553                 if (PyErr_Occurred()) {
    554                         Py_DECREF(inst);
    555                         return NULL;
    556                 }
    557                 if ((arg != NULL && (!PyTuple_Check(arg) ||
    558                                      PyTuple_Size(arg) != 0))
    559                     || (kw != NULL && (!PyDict_Check(kw) ||
    560                                       PyDict_Size(kw) != 0))) {
    561                         PyErr_SetString(PyExc_TypeError,
    562                                    "this constructor takes no arguments");
    563                         Py_DECREF(inst);
    564                         inst = NULL;
    565                 }
    566         }
    567         else {
    568                 PyObject *res = PyEval_CallObjectWithKeywords(init, arg, kw);
    569                 Py_DECREF(init);
    570                 if (res == NULL) {
    571                         Py_DECREF(inst);
    572                         inst = NULL;
    573                 }
    574                 else {
    575                         if (res != Py_None) {
    576                                 PyErr_SetString(PyExc_TypeError,
    577                                            "__init__() should return None");
    578                                 Py_DECREF(inst);
    579                                 inst = NULL;
    580                         }
    581                         Py_DECREF(res);
    582                 }
    583         }
    584         return (PyObject *)inst;
     552    register PyInstanceObject *inst;
     553    PyObject *init;
     554    static PyObject *initstr;
     555
     556    if (initstr == NULL) {
     557        initstr = PyString_InternFromString("__init__");
     558        if (initstr == NULL)
     559            return NULL;
     560    }
     561    inst = (PyInstanceObject *) PyInstance_NewRaw(klass, NULL);
     562    if (inst == NULL)
     563        return NULL;
     564    init = instance_getattr2(inst, initstr);
     565    if (init == NULL) {
     566        if (PyErr_Occurred()) {
     567            Py_DECREF(inst);
     568            return NULL;
     569        }
     570        if ((arg != NULL && (!PyTuple_Check(arg) ||
     571                             PyTuple_Size(arg) != 0))
     572            || (kw != NULL && (!PyDict_Check(kw) ||
     573                              PyDict_Size(kw) != 0))) {
     574            PyErr_SetString(PyExc_TypeError,
     575                       "this constructor takes no arguments");
     576            Py_DECREF(inst);
     577            inst = NULL;
     578        }
     579    }
     580    else {
     581        PyObject *res = PyEval_CallObjectWithKeywords(init, arg, kw);
     582        Py_DECREF(init);
     583        if (res == NULL) {
     584            Py_DECREF(inst);
     585            inst = NULL;
     586        }
     587        else {
     588            if (res != Py_None) {
     589                PyErr_SetString(PyExc_TypeError,
     590                           "__init__() should return None");
     591                Py_DECREF(inst);
     592                inst = NULL;
     593            }
     594            Py_DECREF(res);
     595        }
     596    }
     597    return (PyObject *)inst;
    585598}
    586599
    … …  
    597610instance_new(PyTypeObject* type, PyObject* args, PyObject *kw)
    598611{
    599         PyObject *klass;
    600         PyObject *dict = Py_None;
    601 
    602         if (!PyArg_ParseTuple(args, "O!|O:instance",
    603                               &PyClass_Type, &klass, &dict))
    604                 return NULL;
    605 
    606         if (dict == Py_None)
    607                 dict = NULL;
    608         else if (!PyDict_Check(dict)) {
    609                 PyErr_SetString(PyExc_TypeError,
    610                       "instance() second arg must be dictionary or None");
    611                 return NULL;
    612         }
    613         return PyInstance_NewRaw(klass, dict);
     612    PyObject *klass;
     613    PyObject *dict = Py_None;
     614
     615    if (!PyArg_ParseTuple(args, "O!|O:instance",
     616                          &PyClass_Type, &klass, &dict))
     617        return NULL;
     618
     619    if (dict == Py_None)
     620        dict = NULL;
     621    else if (!PyDict_Check(dict)) {
     622        PyErr_SetString(PyExc_TypeError,
     623              "instance() second arg must be dictionary or None");
     624        return NULL;
     625    }
     626    return PyInstance_NewRaw(klass, dict);
    614627}
    615628
    … …  
    618631instance_dealloc(register PyInstanceObject *inst)
    619632{
    620         PyObject *error_type, *error_value, *error_traceback;
    621         PyObject *del;
    622         static PyObject *delstr;
    623 
    624         _PyObject_GC_UNTRACK(inst);
    625         if (inst->in_weakreflist != NULL)
    626                 PyObject_ClearWeakRefs((PyObject *) inst);
    627 
    628         /* Temporarily resurrect the object. */
    629         assert(inst->ob_type == &PyInstance_Type);
    630         assert(inst->ob_refcnt == 0);
    631         inst->ob_refcnt = 1;
    632 
    633         /* Save the current exception, if any. */
    634         PyErr_Fetch(&error_type, &error_value, &error_traceback);
    635         /* Execute __del__ method, if any. */
    636         if (delstr == NULL) {
    637                 delstr = PyString_InternFromString("__del__");
    638                 if (delstr == NULL)
    639                         PyErr_WriteUnraisable((PyObject*)inst);
    640         }
    641         if (delstr && (del = instance_getattr2(inst, delstr)) != NULL) {
    642                 PyObject *res = PyEval_CallObject(del, (PyObject *)NULL);
    643                 if (res == NULL)
    644                         PyErr_WriteUnraisable(del);
    645                 else
    646                         Py_DECREF(res);
    647                 Py_DECREF(del);
    648         }
    649         /* Restore the saved exception. */
    650         PyErr_Restore(error_type, error_value, error_traceback);
    651 
    652         /* Undo the temporary resurrection; can't use DECREF here, it would
    653         * cause a recursive call.
    654         */
    655         assert(inst->ob_refcnt > 0);
    656         if (--inst->ob_refcnt == 0) {
    657 
    658                 /* New weakrefs could be created during the finalizer call.
    659                     If this occurs, clear them out without calling their
    660                     finalizers since they might rely on part of the object
    661                     being finalized that has already been destroyed. */
    662                 while (inst->in_weakreflist != NULL) {
    663                         _PyWeakref_ClearRef((PyWeakReference *)
    664                                             (inst->in_weakreflist));
    665                 }
    666 
    667                 Py_DECREF(inst->in_class);
    668                 Py_XDECREF(inst->in_dict);
    669                 PyObject_GC_Del(inst);
    670         }
    671         else {
    672                 Py_ssize_t refcnt = inst->ob_refcnt;
    673                 /* __del__ resurrected it!  Make it look like the original
    674                 * Py_DECREF never happened.
    675                 */
    676                 _Py_NewReference((PyObject *)inst);
    677                 inst->ob_refcnt = refcnt;
    678                 _PyObject_GC_TRACK(inst);
    679                 /* If Py_REF_DEBUG, _Py_NewReference bumped _Py_RefTotal, so
    680                 * we need to undo that. */
    681                 _Py_DEC_REFTOTAL;
    682                 /* If Py_TRACE_REFS, _Py_NewReference re-added self to the
    683                 * object chain, so no more to do there.
    684                 * If COUNT_ALLOCS, the original decref bumped tp_frees, and
    685                 * _Py_NewReference bumped tp_allocs: both of those need to be
    686                 * undone.
    687                 */
     633    PyObject *error_type, *error_value, *error_traceback;
     634    PyObject *del;
     635    static PyObject *delstr;
     636
     637    _PyObject_GC_UNTRACK(inst);
     638    if (inst->in_weakreflist != NULL)
     639        PyObject_ClearWeakRefs((PyObject *) inst);
     640
     641    /* Temporarily resurrect the object. */
     642    assert(inst->ob_type == &PyInstance_Type);
     643    assert(inst->ob_refcnt == 0);
     644    inst->ob_refcnt = 1;
     645
     646    /* Save the current exception, if any. */
     647    PyErr_Fetch(&error_type, &error_value, &error_traceback);
     648    /* Execute __del__ method, if any. */
     649    if (delstr == NULL) {
     650        delstr = PyString_InternFromString("__del__");
     651        if (delstr == NULL)
     652            PyErr_WriteUnraisable((PyObject*)inst);
     653    }
     654    if (delstr && (del = instance_getattr2(inst, delstr)) != NULL) {
     655        PyObject *res = PyEval_CallObject(del, (PyObject *)NULL);
     656        if (res == NULL)
     657            PyErr_WriteUnraisable(del);
     658        else
     659            Py_DECREF(res);
     660        Py_DECREF(del);
     661    }
     662    /* Restore the saved exception. */
     663    PyErr_Restore(error_type, error_value, error_traceback);
     664
     665    /* Undo the temporary resurrection; can't use DECREF here, it would
     666    * cause a recursive call.
     667    */
     668    assert(inst->ob_refcnt > 0);
     669    if (--inst->ob_refcnt == 0) {
     670
     671        /* New weakrefs could be created during the finalizer call.
     672            If this occurs, clear them out without calling their
     673            finalizers since they might rely on part of the object
     674            being finalized that has already been destroyed. */
     675        while (inst->in_weakreflist != NULL) {
     676            _PyWeakref_ClearRef((PyWeakReference *)
     677                                (inst->in_weakreflist));
     678        }
     679
     680        Py_DECREF(inst->in_class);
     681        Py_XDECREF(inst->in_dict);
     682        PyObject_GC_Del(inst);
     683    }
     684    else {
     685        Py_ssize_t refcnt = inst->ob_refcnt;
     686        /* __del__ resurrected it!  Make it look like the original
     687        * Py_DECREF never happened.
     688        */
     689        _Py_NewReference((PyObject *)inst);
     690        inst->ob_refcnt = refcnt;
     691        _PyObject_GC_TRACK(inst);
     692        /* If Py_REF_DEBUG, _Py_NewReference bumped _Py_RefTotal, so
     693        * we need to undo that. */
     694        _Py_DEC_REFTOTAL;
     695        /* If Py_TRACE_REFS, _Py_NewReference re-added self to the
     696        * object chain, so no more to do there.
     697        * If COUNT_ALLOCS, the original decref bumped tp_frees, and
     698        * _Py_NewReference bumped tp_allocs: both of those need to be
     699        * undone.
     700        */
    688701#ifdef COUNT_ALLOCS
    689                 --inst->ob_type->tp_frees;
    690                 --inst->ob_type->tp_allocs;
     702        --inst->ob_type->tp_frees;
     703        --inst->ob_type->tp_allocs;
    691704#endif
    692         }
     705    }
    693706}
    694707
    … …  
    696709instance_getattr1(register PyInstanceObject *inst, PyObject *name)
    697710{
    698         register PyObject *v;
    699         register char *sname = PyString_AsString(name);
    700         if (sname[0] == '_' && sname[1] == '_') {
    701                 if (strcmp(sname, "__dict__") == 0) {
    702                         if (PyEval_GetRestricted()) {
    703                                 PyErr_SetString(PyExc_RuntimeError,
    704                         "instance.__dict__ not accessible in restricted mode");
    705                                 return NULL;
    706                         }
    707                         Py_INCREF(inst->in_dict);
    708                         return inst->in_dict;
    709                 }
    710                 if (strcmp(sname, "__class__") == 0) {
    711                         Py_INCREF(inst->in_class);
    712                         return (PyObject *)inst->in_class;
    713                 }
    714         }
    715         v = instance_getattr2(inst, name);
    716         if (v == NULL && !PyErr_Occurred()) {
    717                 PyErr_Format(PyExc_AttributeError,
    718                              "%.50s instance has no attribute '%.400s'",
    719                              PyString_AS_STRING(inst->in_class->cl_name), sname);
    720         }
    721         return v;
     711    register PyObject *v;
     712    register char *sname;
     713
     714    if (!PyString_Check(name)) {
     715        PyErr_SetString(PyExc_TypeError, "attribute name must be a string");
     716        return NULL;
     717    }
     718
     719    sname = PyString_AsString(name);
     720    if (sname[0] == '_' && sname[1] == '_') {
     721        if (strcmp(sname, "__dict__") == 0) {
     722            if (PyEval_GetRestricted()) {
     723                PyErr_SetString(PyExc_RuntimeError,
     724            "instance.__dict__ not accessible in restricted mode");
     725                return NULL;
     726            }
     727            Py_INCREF(inst->in_dict);
     728            return inst->in_dict;
     729        }
     730        if (strcmp(sname, "__class__") == 0) {
     731            Py_INCREF(inst->in_class);
     732            return (PyObject *)inst->in_class;
     733        }
     734    }
     735    v = instance_getattr2(inst, name);
     736    if (v == NULL && !PyErr_Occurred()) {
     737        PyErr_Format(PyExc_AttributeError,
     738                     "%.50s instance has no attribute '%.400s'",
     739                     PyString_AS_STRING(inst->in_class->cl_name), sname);
     740    }
     741    return v;
    722742}
    723743
    … …  
    725745instance_getattr2(register PyInstanceObject *inst, PyObject *name)
    726746{
    727         register PyObject *v;
    728         PyClassObject *klass;
    729         descrgetfunc f;
    730 
    731         v = PyDict_GetItem(inst->in_dict, name);
    732         if (v != NULL) {
    733                 Py_INCREF(v);
    734                 return v;
    735         }
    736         v = class_lookup(inst->in_class, name, &klass);
    737         if (v != NULL) {
    738                 Py_INCREF(v);
    739                 f = TP_DESCR_GET(v->ob_type);
    740                 if (f != NULL) {
    741                         PyObject *w = f(v, (PyObject *)inst,
    742                                         (PyObject *)(inst->in_class));
    743                         Py_DECREF(v);
    744                         v = w;
    745                 }
    746         }
    747         return v;
     747    register PyObject *v;
     748    PyClassObject *klass;
     749    descrgetfunc f;
     750
     751    v = PyDict_GetItem(inst->in_dict, name);
     752    if (v != NULL) {
     753        Py_INCREF(v);
     754        return v;
     755    }
     756    v = class_lookup(inst->in_class, name, &klass);
     757    if (v != NULL) {
     758        Py_INCREF(v);
     759        f = TP_DESCR_GET(v->ob_type);
     760        if (f != NULL) {
     761            PyObject *w = f(v, (PyObject *)inst,
     762                            (PyObject *)(inst->in_class));
     763            Py_DECREF(v);
     764            v = w;
     765        }
     766    }
     767    return v;
    748768}
    749769
    … …  
    751771instance_getattr(register PyInstanceObject *inst, PyObject *name)
    752772{
    753         register PyObject *func, *res;
    754         res = instance_getattr1(inst, name);
    755         if (res == NULL && (func = inst->in_class->cl_getattr) != NULL) {
    756                 PyObject *args;
    757                 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
    758                         return NULL;
    759                 PyErr_Clear();
    760                 args = PyTuple_Pack(2, inst, name);
    761                 if (args == NULL)
    762                         return NULL;
    763                 res = PyEval_CallObject(func, args);
    764                 Py_DECREF(args);
    765         }
    766         return res;
     773    register PyObject *func, *res;
     774    res = instance_getattr1(inst, name);
     775    if (res == NULL && (func = inst->in_class->cl_getattr) != NULL) {
     776        PyObject *args;
     777        if (!PyErr_ExceptionMatches(PyExc_AttributeError))
     778            return NULL;
     779        PyErr_Clear();
     780        args = PyTuple_Pack(2, inst, name);
     781        if (args == NULL)
     782            return NULL;
     783        res = PyEval_CallObject(func, args);
     784        Py_DECREF(args);
     785    }
     786    return res;
    767787}
    768788
    … …  
    773793_PyInstance_Lookup(PyObject *pinst, PyObject *name)
    774794{
    775         PyObject *v;
    776         PyClassObject *klass;
    777         PyInstanceObject *inst; /* pinst cast to the right type */
    778 
    779         assert(PyInstance_Check(pinst));
    780         inst = (PyInstanceObject *)pinst;
    781 
    782         assert(PyString_Check(name));
    783 
    784         v = PyDict_GetItem(inst->in_dict, name);
    785         if (v == NULL)
    786                 v = class_lookup(inst->in_class, name, &klass);
    787         return v;
     795    PyObject *v;
     796    PyClassObject *klass;
     797    PyInstanceObject *inst;     /* pinst cast to the right type */
     798
     799    assert(PyInstance_Check(pinst));
     800    inst = (PyInstanceObject *)pinst;
     801
     802    assert(PyString_Check(name));
     803
     804    v = PyDict_GetItem(inst->in_dict, name);
     805    if (v == NULL)
     806        v = class_lookup(inst->in_class, name, &klass);
     807    return v;
    788808}
    789809
    … …  
    791811instance_setattr1(PyInstanceObject *inst, PyObject *name, PyObject *v)
    792812{
    793         if (v == NULL) {
    794                 int rv = PyDict_DelItem(inst->in_dict, name);
    795                 if (rv < 0)
    796                         PyErr_Format(PyExc_AttributeError,
    797                                      "%.50s instance has no attribute '%.400s'",
    798                                      PyString_AS_STRING(inst->in_class->cl_name),
    799                                      PyString_AS_STRING(name));
    800                 return rv;
    801         }
    802         else
    803                 return PyDict_SetItem(inst->in_dict, name, v);
     813    if (v == NULL) {
     814        int rv = PyDict_DelItem(inst->in_dict, name);
     815        if (rv < 0)
     816            PyErr_Format(PyExc_AttributeError,
     817                         "%.50s instance has no attribute '%.400s'",
     818                         PyString_AS_STRING(inst->in_class->cl_name),
     819                         PyString_AS_STRING(name));
     820        return rv;
     821    }
     822    else
     823        return PyDict_SetItem(inst->in_dict, name, v);
    804824}
    805825
    … …  
    807827instance_setattr(PyInstanceObject *inst, PyObject *name, PyObject *v)
    808828{
    809         PyObject *func, *args, *res, *tmp;
    810         char *sname = PyString_AsString(name);
    811         if (sname[0] == '_' && sname[1] == '_') {
    812                 Py_ssize_t n = PyString_Size(name);
    813                 if (sname[n-1] == '_' && sname[n-2] == '_') {
    814                         if (strcmp(sname, "__dict__") == 0) {
    815                                 if (PyEval_GetRestricted()) {
    816                                         PyErr_SetString(PyExc_RuntimeError,
    817                                  "__dict__ not accessible in restricted mode");
    818                                         return -1;
    819                                 }
    820                                 if (v == NULL || !PyDict_Check(v)) {
    821                                     PyErr_SetString(PyExc_TypeError,
    822                                        "__dict__ must be set to a dictionary");
    823                                     return -1;
    824                                 }
    825                                 tmp = inst->in_dict;
    826                                 Py_INCREF(v);
    827                                 inst->in_dict = v;
    828                                 Py_DECREF(tmp);
    829                                 return 0;
    830                         }
    831                         if (strcmp(sname, "__class__") == 0) {
    832                                 if (PyEval_GetRestricted()) {
    833                                         PyErr_SetString(PyExc_RuntimeError,
    834                                 "__class__ not accessible in restricted mode");
    835                                         return -1;
    836                                 }
    837                                 if (v == NULL || !PyClass_Check(v)) {
    838                                         PyErr_SetString(PyExc_TypeError,
    839                                            "__class__ must be set to a class");
    840                                         return -1;
    841                                 }
    842                                 tmp = (PyObject *)(inst->in_class);
    843                                 Py_INCREF(v);
    844                                 inst->in_class = (PyClassObject *)v;
    845                                 Py_DECREF(tmp);
    846                                 return 0;
    847                         }
    848                 }
    849         }
    850         if (v == NULL)
    851                 func = inst->in_class->cl_delattr;
    852         else
    853                 func = inst->in_class->cl_setattr;
    854         if (func == NULL)
    855                 return instance_setattr1(inst, name, v);
    856         if (v == NULL)
    857                 args = PyTuple_Pack(2, inst, name);
    858         else
    859                 args = PyTuple_Pack(3, inst, name, v);
    860         if (args == NULL)
    861                 return -1;
    862         res = PyEval_CallObject(func, args);
    863         Py_DECREF(args);
    864         if (res == NULL)
    865                 return -1;
    866         Py_DECREF(res);
    867         return 0;
     829    PyObject *func, *args, *res, *tmp;
     830    char *sname;
     831
     832    if (!PyString_Check(name)) {
     833        PyErr_SetString(PyExc_TypeError, "attribute name must be a string");
     834        return -1;
     835    }
     836
     837    sname = PyString_AsString(name);
     838    if (sname[0] == '_' && sname[1] == '_') {
     839        Py_ssize_t n = PyString_Size(name);
     840        if (sname[n-1] == '_' && sname[n-2] == '_') {
     841            if (strcmp(sname, "__dict__") == 0) {
     842                if (PyEval_GetRestricted()) {
     843                    PyErr_SetString(PyExc_RuntimeError,
     844                 "__dict__ not accessible in restricted mode");
     845                    return -1;
     846                }
     847                if (v == NULL || !PyDict_Check(v)) {
     848                    PyErr_SetString(PyExc_TypeError,
     849                       "__dict__ must be set to a dictionary");
     850                    return -1;
     851                }
     852                tmp = inst->in_dict;
     853                Py_INCREF(v);
     854                inst->in_dict = v;
     855                Py_DECREF(tmp);
     856                return 0;
     857            }
     858            if (strcmp(sname, "__class__") == 0) {
     859                if (PyEval_GetRestricted()) {
     860                    PyErr_SetString(PyExc_RuntimeError,
     861                "__class__ not accessible in restricted mode");
     862                    return -1;
     863                }
     864                if (v == NULL || !PyClass_Check(v)) {
     865                    PyErr_SetString(PyExc_TypeError,
     866                       "__class__ must be set to a class");
     867                    return -1;
     868                }
     869                tmp = (PyObject *)(inst->in_class);
     870                Py_INCREF(v);
     871                inst->in_class = (PyClassObject *)v;
     872                Py_DECREF(tmp);
     873                return 0;
     874            }
     875        }
     876    }
     877    if (v == NULL)
     878        func = inst->in_class->cl_delattr;
     879    else
     880        func = inst->in_class->cl_setattr;
     881    if (func == NULL)
     882        return instance_setattr1(inst, name, v);
     883    if (v == NULL)
     884        args = PyTuple_Pack(2, inst, name);
     885    else
     886        args = PyTuple_Pack(3, inst, name, v);
     887    if (args == NULL)
     888        return -1;
     889    res = PyEval_CallObject(func, args);
     890    Py_DECREF(args);
     891    if (res == NULL)
     892        return -1;
     893    Py_DECREF(res);
     894    return 0;
    868895}
    869896
    … …  
    871898instance_repr(PyInstanceObject *inst)
    872899{
    873         PyObject *func;
    874         PyObject *res;
    875         static PyObject *reprstr;
    876 
    877         if (reprstr == NULL) {
    878                 reprstr = PyString_InternFromString("__repr__");
    879                 if (reprstr == NULL)
    880                         return NULL;
    881         }
    882         func = instance_getattr(inst, reprstr);
    883         if (func == NULL) {
    884                 PyObject *classname, *mod;
    885                 char *cname;
    886                 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
    887                         return NULL;
    888                 PyErr_Clear();
    889                 classname = inst->in_class->cl_name;
    890                 mod = PyDict_GetItemString(inst->in_class->cl_dict,
    891                                            "__module__");
    892                 if (classname != NULL && PyString_Check(classname))
    893                         cname = PyString_AsString(classname);
    894                 else
    895                         cname = "?";
    896                 if (mod == NULL || !PyString_Check(mod))
    897                         return PyString_FromFormat("<?.%s instance at %p>",
    898                                                    cname, inst);
    899                 else
    900                         return PyString_FromFormat("<%s.%s instance at %p>",
    901                                                    PyString_AsString(mod),
    902                                                    cname, inst);
    903         }
    904         res = PyEval_CallObject(func, (PyObject *)NULL);
    905         Py_DECREF(func);
    906         return res;
     900    PyObject *func;
     901    PyObject *res;
     902    static PyObject *reprstr;
     903
     904    if (reprstr == NULL) {
     905        reprstr = PyString_InternFromString("__repr__");
     906        if (reprstr == NULL)
     907            return NULL;
     908    }
     909    func = instance_getattr(inst, reprstr);
     910    if (func == NULL) {
     911        PyObject *classname, *mod;
     912        char *cname;
     913        if (!PyErr_ExceptionMatches(PyExc_AttributeError))
     914            return NULL;
     915        PyErr_Clear();
     916        classname = inst->in_class->cl_name;
     917        mod = PyDict_GetItemString(inst->in_class->cl_dict,
     918                                   "__module__");
     919        if (classname != NULL && PyString_Check(classname))
     920            cname = PyString_AsString(classname);
     921        else
     922            cname = "?";
     923        if (mod == NULL || !PyString_Check(mod))
     924            return PyString_FromFormat("<?.%s instance at %p>",
     925                                       cname, inst);
     926        else
     927            return PyString_FromFormat("<%s.%s instance at %p>",
     928                                       PyString_AsString(mod),
     929                                       cname, inst);
     930    }
     931    res = PyEval_CallObject(func, (PyObject *)NULL);
     932    Py_DECREF(func);
     933    return res;
    907934}
    908935
    … …  
    910937instance_str(PyInstanceObject *inst)
    911938{
    912         PyObject *func;
    913         PyObject *res;
    914         static PyObject *strstr;
    915 
    916         if (strstr == NULL) {
    917                 strstr = PyString_InternFromString("__str__");
    918                 if (strstr == NULL)
    919                         return NULL;
    920         }
    921         func = instance_getattr(inst, strstr);
    922         if (func == NULL) {
    923                 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
    924                         return NULL;
    925                 PyErr_Clear();
    926                 return instance_repr(inst);
    927         }
    928         res = PyEval_CallObject(func, (PyObject *)NULL);
    929         Py_DECREF(func);
    930         return res;
     939    PyObject *func;
     940    PyObject *res;
     941    static PyObject *strstr;
     942
     943    if (strstr == NULL) {
     944        strstr = PyString_InternFromString("__str__");
     945        if (strstr == NULL)
     946            return NULL;
     947    }
     948    func = instance_getattr(inst, strstr);
     949    if (func == NULL) {
     950        if (!PyErr_ExceptionMatches(PyExc_AttributeError))
     951            return NULL;
     952        PyErr_Clear();
     953        return instance_repr(inst);
     954    }
     955    res = PyEval_CallObject(func, (PyObject *)NULL);
     956    Py_DECREF(func);
     957    return res;
    931958}
    932959
    … …  
    934961instance_hash(PyInstanceObject *inst)
    935962{
    936         PyObject *func;
    937         PyObject *res;
    938         long outcome;
    939         static PyObject *hashstr, *eqstr, *cmpstr;
    940 
    941         if (hashstr == NULL) {
    942                 hashstr = PyString_InternFromString("__hash__");
    943                 if (hashstr == NULL)
    944                         return -1;
    945         }
    946         func = instance_getattr(inst, hashstr);
    947         if (func == NULL) {
    948                 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
    949                         return -1;
    950                 PyErr_Clear();
    951                 /* If there is no __eq__ and no __cmp__ method, we hash on the
    952                    address.  If an __eq__ or __cmp__ method exists, there must
    953                    be a __hash__. */
    954                 if (eqstr == NULL) {
    955                         eqstr = PyString_InternFromString("__eq__");
    956                         if (eqstr == NULL)
    957                                 return -1;
    958                 }
    959                 func = instance_getattr(inst, eqstr);
    960                 if (func == NULL) {
    961                         if (!PyErr_ExceptionMatches(PyExc_AttributeError))
    962                                 return -1;
    963                         PyErr_Clear();
    964                         if (cmpstr == NULL) {
    965                                 cmpstr = PyString_InternFromString("__cmp__");
    966                                 if (cmpstr == NULL)
    967                                         return -1;
    968                         }
    969                         func = instance_getattr(inst, cmpstr);
    970                         if (func == NULL) {
    971                                 if (!PyErr_ExceptionMatches(
    972                                         PyExc_AttributeError))
    973                                         return -1;
    974                                 PyErr_Clear();
    975                                 return _Py_HashPointer(inst);
    976                         }
    977                 }
    978                 Py_XDECREF(func);
    979                 PyErr_SetString(PyExc_TypeError, "unhashable instance");
    980                 return -1;
    981         }
    982         res = PyEval_CallObject(func, (PyObject *)NULL);
    983         Py_DECREF(func);
    984         if (res == NULL)
    985                 return -1;
    986         if (PyInt_Check(res) || PyLong_Check(res))
    987                 /* This already converts a -1 result to -2. */
    988                 outcome = res->ob_type->tp_hash(res);
    989         else {
    990                 PyErr_SetString(PyExc_TypeError,
    991                                 "__hash__() should return an int");
    992                 outcome = -1;
    993         }
    994         Py_DECREF(res);
    995         return outcome;
     963    PyObject *func;
     964    PyObject *res;
     965    long outcome;
     966    static PyObject *hashstr, *eqstr, *cmpstr;
     967
     968    if (hashstr == NULL) {
     969        hashstr = PyString_InternFromString("__hash__");
     970        if (hashstr == NULL)
     971            return -1;
     972    }
     973    func = instance_getattr(inst, hashstr);
     974    if (func == NULL) {
     975        if (!PyErr_ExceptionMatches(PyExc_AttributeError))
     976            return -1;
     977        PyErr_Clear();
     978        /* If there is no __eq__ and no __cmp__ method, we hash on the
     979           address.  If an __eq__ or __cmp__ method exists, there must
     980           be a __hash__. */
     981        if (eqstr == NULL) {
     982            eqstr = PyString_InternFromString("__eq__");
     983            if (eqstr == NULL)
     984                return -1;
     985        }
     986        func = instance_getattr(inst, eqstr);
     987        if (func == NULL) {
     988            if (!PyErr_ExceptionMatches(PyExc_AttributeError))
     989                return -1;
     990            PyErr_Clear();
     991            if (cmpstr == NULL) {
     992                cmpstr = PyString_InternFromString("__cmp__");
     993                if (cmpstr == NULL)
     994                    return -1;
     995            }
     996            func = instance_getattr(inst, cmpstr);
     997            if (func == NULL) {
     998                if (!PyErr_ExceptionMatches(
     999                    PyExc_AttributeError))
     1000                    return -1;
     1001                PyErr_Clear();
     1002                return _Py_HashPointer(inst);
     1003            }
     1004        }
     1005        Py_XDECREF(func);
     1006        PyErr_SetString(PyExc_TypeError, "unhashable instance");
     1007        return -1;
     1008    }
     1009    res = PyEval_CallObject(func, (PyObject *)NULL);
     1010    Py_DECREF(func);
     1011    if (res == NULL)
     1012        return -1;
     1013    if (PyInt_Check(res) || PyLong_Check(res))
     1014        /* This already converts a -1 result to -2. */
     1015        outcome = res->ob_type->tp_hash(res);
     1016    else {
     1017        PyErr_SetString(PyExc_TypeError,
     1018                        "__hash__() should return an int");
     1019        outcome = -1;
     1020    }
     1021    Py_DECREF(res);
     1022    return outcome;
    9961023}
    9971024
    … …  
    9991026instance_traverse(PyInstanceObject *o, visitproc visit, void *arg)
    10001027{
    1001         Py_VISIT(o->in_class);
    1002         Py_VISIT(o->in_dict);
    1003         return 0;
     1028    Py_VISIT(o->in_class);
     1029    Py_VISIT(o->in_dict);
     1030    return 0;
    10041031}
    10051032
    … …  
    10101037instance_length(PyInstanceObject *inst)
    10111038{
    1012         PyObject *func;
    1013         PyObject *res;
    1014         Py_ssize_t outcome;
    1015 
    1016         if (lenstr == NULL) {
    1017                 lenstr = PyString_InternFromString("__len__");
    1018                 if (lenstr == NULL)
    1019                         return -1;
    1020         }
    1021         func = instance_getattr(inst, lenstr);
    1022         if (func == NULL)
    1023                 return -1;
    1024         res = PyEval_CallObject(func, (PyObject *)NULL);
    1025         Py_DECREF(func);
    1026         if (res == NULL)
    1027                 return -1;
    1028         if (PyInt_Check(res)) {
    1029                 outcome = PyInt_AsSsize_t(res);
    1030                 if (outcome == -1 && PyErr_Occurred()) {
    1031                         Py_DECREF(res);
    1032                         return -1;
    1033                 }
     1039    PyObject *func;
     1040    PyObject *res;
     1041    Py_ssize_t outcome;
     1042
     1043    if (lenstr == NULL) {
     1044        lenstr = PyString_InternFromString("__len__");
     1045        if (lenstr == NULL)
     1046            return -1;
     1047    }
     1048    func = instance_getattr(inst, lenstr);
     1049    if (func == NULL)
     1050        return -1;
     1051    res = PyEval_CallObject(func, (PyObject *)NULL);
     1052    Py_DECREF(func);
     1053    if (res == NULL)
     1054        return -1;
     1055    if (PyInt_Check(res)) {
     1056        outcome = PyInt_AsSsize_t(res);
     1057        if (outcome == -1 && PyErr_Occurred()) {
     1058            Py_DECREF(res);
     1059            return -1;
     1060        }
    10341061#if SIZEOF_SIZE_T < SIZEOF_INT
    1035                 /* Overflow check -- range of PyInt is more than C int */
    1036                 if (outcome != (int)outcome) {
    1037                         PyErr_SetString(PyExc_OverflowError,
    1038                         "__len__() should return 0 <= outcome < 2**31");
    1039                         outcome = -1;
    1040                 }
    1041                 else
     1062        /* Overflow check -- range of PyInt is more than C int */
     1063        if (outcome != (int)outcome) {
     1064            PyErr_SetString(PyExc_OverflowError,
     1065            "__len__() should return 0 <= outcome < 2**31");
     1066            outcome = -1;
     1067        }
     1068        else
    10421069#endif
    1043                 if (outcome < 0) {
    1044                         PyErr_SetString(PyExc_ValueError,
    1045                                         "__len__() should return >= 0");
    1046                         outcome = -1;
    1047                 }
    1048         }
    1049         else {
    1050                 PyErr_SetString(PyExc_TypeError,
    1051                                 "__len__() should return an int");
    1052                 outcome = -1;
    1053         }
    1054         Py_DECREF(res);
    1055         return outcome;
     1070        if (outcome < 0) {
     1071            PyErr_SetString(PyExc_ValueError,
     1072                            "__len__() should return >= 0");
     1073            outcome = -1;
     1074        }
     1075    }
     1076    else {
     1077        PyErr_SetString(PyExc_TypeError,
     1078                        "__len__() should return an int");
     1079        outcome = -1;
     1080    }
     1081    Py_DECREF(res);
     1082    return outcome;
    10561083}
    10571084
    … …  
    10591086instance_subscript(PyInstanceObject *inst, PyObject *key)
    10601087{
    1061         PyObject *func;
    1062         PyObject *arg;
    1063         PyObject *res;
    1064 
    1065         if (getitemstr == NULL) {
    1066                 getitemstr = PyString_InternFromString("__getitem__");
    1067                 if (getitemstr == NULL)
    1068                         return NULL;
    1069         }
    1070         func = instance_getattr(inst, getitemstr);
    1071         if (func == NULL)
    1072                 return NULL;
    1073         arg = PyTuple_Pack(1, key);
    1074         if (arg == NULL) {
    1075                 Py_DECREF(func);
    1076                 return NULL;
    1077         }
    1078         res = PyEval_CallObject(func, arg);
    1079         Py_DECREF(func);
    1080         Py_DECREF(arg);
    1081         return res;
     1088    PyObject *func;
     1089    PyObject *arg;
     1090    PyObject *res;
     1091
     1092    if (getitemstr == NULL) {
     1093        getitemstr = PyString_InternFromString("__getitem__");
     1094        if (getitemstr == NULL)
     1095            return NULL;
     1096    }
     1097    func = instance_getattr(inst, getitemstr);
     1098    if (func == NULL)
     1099        return NULL;
     1100    arg = PyTuple_Pack(1, key);
     1101    if (arg == NULL) {
     1102        Py_DECREF(func);
     1103        return NULL;
     1104    }
     1105    res = PyEval_CallObject(func, arg);
     1106    Py_DECREF(func);
     1107    Py_DECREF(arg);
     1108    return res;
    10821109}
    10831110
    … …  
    10851112instance_ass_subscript(PyInstanceObject *inst, PyObject *key, PyObject *value)
    10861113{
    1087         PyObject *func;
    1088         PyObject *arg;
    1089         PyObject *res;
    1090 
    1091         if (value == NULL) {
    1092                 if (delitemstr == NULL) {
    1093                         delitemstr = PyString_InternFromString("__delitem__");
    1094                         if (delitemstr == NULL)
    1095                                 return -1;
    1096                 }
    1097                 func = instance_getattr(inst, delitemstr);
    1098         }
    1099         else {
    1100                 if (setitemstr == NULL) {
    1101                         setitemstr = PyString_InternFromString("__setitem__");
    1102                         if (setitemstr == NULL)
    1103                                 return -1;
    1104                 }
    1105                 func = instance_getattr(inst, setitemstr);
    1106         }
    1107         if (func == NULL)
    1108                 return -1;
    1109         if (value == NULL)
    1110                 arg = PyTuple_Pack(1, key);
    1111         else
    1112                 arg = PyTuple_Pack(2, key, value);
    1113         if (arg == NULL) {
    1114                 Py_DECREF(func);
    1115                 return -1;
    1116         }
    1117         res = PyEval_CallObject(func, arg);
    1118         Py_DECREF(func);
    1119         Py_DECREF(arg);
    1120         if (res == NULL)
    1121                 return -1;
    1122         Py_DECREF(res);
    1123         return 0;
     1114    PyObject *func;
     1115    PyObject *arg;
     1116    PyObject *res;
     1117
     1118    if (value == NULL) {
     1119        if (delitemstr == NULL) {
     1120            delitemstr = PyString_InternFromString("__delitem__");
     1121            if (delitemstr == NULL)
     1122                return -1;
     1123        }
     1124        func = instance_getattr(inst, delitemstr);
     1125    }
     1126    else {
     1127        if (setitemstr == NULL) {
     1128            setitemstr = PyString_InternFromString("__setitem__");
     1129            if (setitemstr == NULL)
     1130                return -1;
     1131        }
     1132        func = instance_getattr(inst, setitemstr);
     1133    }
     1134    if (func == NULL)
     1135        return -1;
     1136    if (value == NULL)
     1137        arg = PyTuple_Pack(1, key);
     1138    else
     1139        arg = PyTuple_Pack(2, key, value);
     1140    if (arg == NULL) {
     1141        Py_DECREF(func);
     1142        return -1;
     1143    }
     1144    res = PyEval_CallObject(func, arg);
     1145    Py_DECREF(func);
     1146    Py_DECREF(arg);
     1147    if (res == NULL)
     1148        return -1;
     1149    Py_DECREF(res);
     1150    return 0;
    11241151}
    11251152
    11261153static PyMappingMethods instance_as_mapping = {
    1127         (lenfunc)instance_length,               /* mp_length */
    1128         (binaryfunc)instance_subscript,         /* mp_subscript */
    1129         (objobjargproc)instance_ass_subscript,  /* mp_ass_subscript */
     1154    (lenfunc)instance_length,                   /* mp_length */
     1155    (binaryfunc)instance_subscript,             /* mp_subscript */
     1156    (objobjargproc)instance_ass_subscript,      /* mp_ass_subscript */
    11301157};
    11311158
    … …  
    11331160instance_item(PyInstanceObject *inst, Py_ssize_t i)
    11341161{
    1135         PyObject *func, *res;
    1136 
    1137         if (getitemstr == NULL) {
    1138                 getitemstr = PyString_InternFromString("__getitem__");
    1139                 if (getitemstr == NULL)
    1140                         return NULL;
    1141         }
    1142         func = instance_getattr(inst, getitemstr);
    1143         if (func == NULL)
    1144                 return NULL;
    1145         res = PyObject_CallFunction(func, "n", i);
    1146         Py_DECREF(func);
    1147         return res;
     1162    PyObject *func, *res;
     1163
     1164    if (getitemstr == NULL) {
     1165        getitemstr = PyString_InternFromString("__getitem__");
     1166        if (getitemstr == NULL)
     1167            return NULL;
     1168    }
     1169    func = instance_getattr(inst, getitemstr);
     1170    if (func == NULL)
     1171        return NULL;
     1172    res = PyObject_CallFunction(func, "n", i);
     1173    Py_DECREF(func);
     1174    return res;
    11481175}
    11491176
    … …  
    11511178instance_slice(PyInstanceObject *inst, Py_ssize_t i, Py_ssize_t j)
    11521179{
    1153         PyObject *func, *arg, *res;
    1154         static PyObject *getslicestr;
    1155 
    1156         if (getslicestr == NULL) {
    1157                 getslicestr = PyString_InternFromString("__getslice__");
    1158                 if (getslicestr == NULL)
    1159                         return NULL;
    1160         }
    1161         func = instance_getattr(inst, getslicestr);
    1162 
    1163         if (func == NULL) {
    1164                 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
    1165                         return NULL;
    1166                 PyErr_Clear();
    1167 
    1168                 if (getitemstr == NULL) {
    1169                         getitemstr = PyString_InternFromString("__getitem__");
    1170                         if (getitemstr == NULL)
    1171                                 return NULL;
    1172                 }
    1173                 func = instance_getattr(inst, getitemstr);
    1174                 if (func == NULL)
    1175                         return NULL;
    1176                 arg = Py_BuildValue("(N)", _PySlice_FromIndices(i, j));
    1177         }
    1178         else {
    1179                 if (PyErr_WarnPy3k("in 3.x, __getslice__ has been removed; "
    1180                                    "use __getitem__", 1) < 0) {
    1181                         Py_DECREF(func);
    1182                         return NULL;
    1183                 }
    1184                 arg = Py_BuildValue("(nn)", i, j);
    1185         }
    1186 
    1187         if (arg == NULL) {
    1188                 Py_DECREF(func);
    1189                 return NULL;
    1190         }
    1191         res = PyEval_CallObject(func, arg);
    1192         Py_DECREF(func);
    1193         Py_DECREF(arg);
    1194         return res;
     1180    PyObject *func, *arg, *res;
     1181    static PyObject *getslicestr;
     1182
     1183    if (getslicestr == NULL) {
     1184        getslicestr = PyString_InternFromString("__getslice__");
     1185        if (getslicestr == NULL)
     1186            return NULL;
     1187    }
     1188    func = instance_getattr(inst, getslicestr);
     1189
     1190    if (func == NULL) {
     1191        if (!PyErr_ExceptionMatches(PyExc_AttributeError))
     1192            return NULL;
     1193        PyErr_Clear();
     1194
     1195        if (getitemstr == NULL) {
     1196            getitemstr = PyString_InternFromString("__getitem__");
     1197            if (getitemstr == NULL)
     1198                return NULL;
     1199        }
     1200        func = instance_getattr(inst, getitemstr);
     1201        if (func == NULL)
     1202            return NULL;
     1203        arg = Py_BuildValue("(N)", _PySlice_FromIndices(i, j));
     1204    }
     1205    else {
     1206        if (PyErr_WarnPy3k("in 3.x, __getslice__ has been removed; "
     1207                           "use __getitem__", 1) < 0) {
     1208            Py_DECREF(func);
     1209            return NULL;
     1210        }
     1211        arg = Py_BuildValue("(nn)", i, j);
     1212    }
     1213
     1214    if (arg == NULL) {
     1215        Py_DECREF(func);
     1216        return NULL;
     1217    }
     1218    res = PyEval_CallObject(func, arg);
     1219    Py_DECREF(func);
     1220    Py_DECREF(arg);
     1221    return res;
    11951222}
    11961223
    … …  
    11981225instance_ass_item(PyInstanceObject *inst, Py_ssize_t i, PyObject *item)
    11991226{
    1200         PyObject *func, *arg, *res;
    1201 
    1202         if (item == NULL) {
    1203                 if (delitemstr == NULL) {
    1204                         delitemstr = PyString_InternFromString("__delitem__");
    1205                         if (delitemstr == NULL)
    1206                                 return -1;
    1207                 }
    1208                 func = instance_getattr(inst, delitemstr);
    1209         }
    1210         else {
    1211                 if (setitemstr == NULL) {
    1212                         setitemstr = PyString_InternFromString("__setitem__");
    1213                         if (setitemstr == NULL)
    1214                                 return -1;
    1215                 }
    1216                 func = instance_getattr(inst, setitemstr);
    1217         }
    1218         if (func == NULL)
    1219                 return -1;
    1220         if (item == NULL)
    1221                 arg = PyInt_FromSsize_t(i);
    1222         else
    1223                 arg = Py_BuildValue("(nO)", i, item);
    1224         if (arg == NULL) {
    1225                 Py_DECREF(func);
    1226                 return -1;
    1227         }
    1228         res = PyEval_CallObject(func, arg);
    1229         Py_DECREF(func);
    1230         Py_DECREF(arg);
    1231         if (res == NULL)
    1232                 return -1;
    1233         Py_DECREF(res);
    1234         return 0;
     1227    PyObject *func, *arg, *res;
     1228
     1229    if (item == NULL) {
     1230        if (delitemstr == NULL) {
     1231            delitemstr = PyString_InternFromString("__delitem__");
     1232            if (delitemstr == NULL)
     1233                return -1;
     1234        }
     1235        func = instance_getattr(inst, delitemstr);
     1236    }
     1237    else {
     1238        if (setitemstr == NULL) {
     1239            setitemstr = PyString_InternFromString("__setitem__");
     1240            if (setitemstr == NULL)
     1241                return -1;
     1242        }
     1243        func = instance_getattr(inst, setitemstr);
     1244    }
     1245    if (func == NULL)
     1246        return -1;
     1247    if (item == NULL)
     1248        arg = Py_BuildValue("(n)", i);
     1249    else
     1250        arg = Py_BuildValue("(nO)", i, item);
     1251    if (arg == NULL) {
     1252        Py_DECREF(func);
     1253        return -1;
     1254    }
     1255    res = PyEval_CallObject(func, arg);
     1256    Py_DECREF(func);
     1257    Py_DECREF(arg);
     1258    if (res == NULL)
     1259        return -1;
     1260    Py_DECREF(res);
     1261    return 0;
    12351262}
    12361263
    … …  
    12381265instance_ass_slice(PyInstanceObject *inst, Py_ssize_t i, Py_ssize_t j, PyObject *value)
    12391266{
    1240         PyObject *func, *arg, *res;
    1241         static PyObject *setslicestr, *delslicestr;
    1242 
    1243         if (value == NULL) {
    1244                 if (delslicestr == NULL) {
    1245                         delslicestr =
    1246                                 PyString_InternFromString("__delslice__");
    1247                         if (delslicestr == NULL)
    1248                                 return -1;
    1249                 }
    1250                 func = instance_getattr(inst, delslicestr);
    1251                 if (func == NULL) {
    1252                         if (!PyErr_ExceptionMatches(PyExc_AttributeError))
    1253                                 return -1;
    1254                         PyErr_Clear();
    1255                         if (delitemstr == NULL) {
    1256                                 delitemstr =
    1257                                     PyString_InternFromString("__delitem__");
    1258                                 if (delitemstr == NULL)
    1259                                         return -1;
    1260                         }
    1261                         func = instance_getattr(inst, delitemstr);
    1262                         if (func == NULL)
    1263                                 return -1;
    1264 
    1265                         arg = Py_BuildValue("(N)",
    1266                                             _PySlice_FromIndices(i, j));
    1267                 }
    1268                 else {
    1269                         if (PyErr_WarnPy3k("in 3.x, __delslice__ has been "
    1270                                             "removed; use __delitem__", 1) < 0) {
    1271                                 Py_DECREF(func);
    1272                                 return -1;
    1273                         }
    1274                         arg = Py_BuildValue("(nn)", i, j);
    1275                 }
    1276         }
    1277         else {
    1278                 if (setslicestr == NULL) {
    1279                         setslicestr =
    1280                                 PyString_InternFromString("__setslice__");
    1281                         if (setslicestr == NULL)
    1282                                 return -1;
    1283                 }
    1284                 func = instance_getattr(inst, setslicestr);
    1285                 if (func == NULL) {
    1286                         if (!PyErr_ExceptionMatches(PyExc_AttributeError))
    1287                                 return -1;
    1288                         PyErr_Clear();
    1289                         if (setitemstr == NULL) {
    1290                                 setitemstr =
    1291                                     PyString_InternFromString("__setitem__");
    1292                                 if (setitemstr == NULL)
    1293                                         return -1;
    1294                         }
    1295                         func = instance_getattr(inst, setitemstr);
    1296                         if (func == NULL)
    1297                                 return -1;
    1298 
    1299                         arg = Py_BuildValue("(NO)",
    1300                                             _PySlice_FromIndices(i, j), value);
    1301                 }
    1302                 else {
    1303                         if (PyErr_WarnPy3k("in 3.x, __setslice__ has been "
    1304                                            "removed; use __setitem__", 1) < 0) {
    1305                                 Py_DECREF(func);
    1306                                 return -1;
    1307                         }
    1308                         arg = Py_BuildValue("(nnO)", i, j, value);
    1309                 }
    1310         }
    1311         if (arg == NULL) {
    1312                 Py_DECREF(func);
    1313                 return -1;
    1314         }
    1315         res = PyEval_CallObject(func, arg);
    1316         Py_DECREF(func);
    1317         Py_DECREF(arg);
    1318         if (res == NULL)
    1319                 return -1;
    1320         Py_DECREF(res);
    1321         return 0;
     1267    PyObject *func, *arg, *res;
     1268    static PyObject *setslicestr, *delslicestr;
     1269
     1270    if (value == NULL) {
     1271        if (delslicestr == NULL) {
     1272            delslicestr =
     1273                PyString_InternFromString("__delslice__");
     1274            if (delslicestr == NULL)
     1275                return -1;
     1276        }
     1277        func = instance_getattr(inst, delslicestr);
     1278        if (func == NULL) {
     1279            if (!PyErr_ExceptionMatches(PyExc_AttributeError))
     1280                return -1;
     1281            PyErr_Clear();
     1282            if (delitemstr == NULL) {
     1283                delitemstr =
     1284                    PyString_InternFromString("__delitem__");
     1285                if (delitemstr == NULL)
     1286                    return -1;
     1287            }
     1288            func = instance_getattr(inst, delitemstr);
     1289            if (func == NULL)
     1290                return -1;
     1291
     1292            arg = Py_BuildValue("(N)",
     1293                                _PySlice_FromIndices(i, j));
     1294        }
     1295        else {
     1296            if (PyErr_WarnPy3k("in 3.x, __delslice__ has been "
     1297                                "removed; use __delitem__", 1) < 0) {
     1298                Py_DECREF(func);
     1299                return -1;
     1300            }
     1301            arg = Py_BuildValue("(nn)", i, j);
     1302        }
     1303    }
     1304    else {
     1305        if (setslicestr == NULL) {
     1306            setslicestr =
     1307                PyString_InternFromString("__setslice__");
     1308            if (setslicestr == NULL)
     1309                return -1;
     1310        }
     1311        func = instance_getattr(inst, setslicestr);
     1312        if (func == NULL) {
     1313            if (!PyErr_ExceptionMatches(PyExc_AttributeError))
     1314                return -1;
     1315            PyErr_Clear();
     1316            if (setitemstr == NULL) {
     1317                setitemstr =
     1318                    PyString_InternFromString("__setitem__");
     1319                if (setitemstr == NULL)
     1320                    return -1;
     1321            }
     1322            func = instance_getattr(inst, setitemstr);
     1323            if (func == NULL)
     1324                return -1;
     1325
     1326            arg = Py_BuildValue("(NO)",
     1327                                _PySlice_FromIndices(i, j), value);
     1328        }
     1329        else {
     1330            if (PyErr_WarnPy3k("in 3.x, __setslice__ has been "
     1331                               "removed; use __setitem__", 1) < 0) {
     1332                Py_DECREF(func);
     1333                return -1;
     1334            }
     1335            arg = Py_BuildValue("(nnO)", i, j, value);
     1336        }
     1337    }
     1338    if (arg == NULL) {
     1339        Py_DECREF(func);
     1340        return -1;
     1341    }
     1342    res = PyEval_CallObject(func, arg);
     1343    Py_DECREF(func);
     1344    Py_DECREF(arg);
     1345    if (res == NULL)
     1346        return -1;
     1347    Py_DECREF(res);
     1348    return 0;
    13221349}
    13231350
    … …  
    13251352instance_contains(PyInstanceObject *inst, PyObject *member)
    13261353{
    1327         static PyObject *__contains__;
    1328         PyObject *func;
    1329 
    1330         /* Try __contains__ first.
    1331         * If that can't be done, try iterator-based searching.
    1332         */
    1333 
    1334         if(__contains__ == NULL) {
    1335                 __contains__ = PyString_InternFromString("__contains__");
    1336                 if(__contains__ == NULL)
    1337                         return -1;
    1338         }
    1339         func = instance_getattr(inst, __contains__);
    1340         if (func) {
    1341                 PyObject *res;
    1342                 int ret;
    1343                 PyObject *arg = PyTuple_Pack(1, member);
    1344                 if(arg == NULL) {
    1345                         Py_DECREF(func);
    1346                         return -1;
    1347                 }
    1348                 res = PyEval_CallObject(func, arg);
    1349                 Py_DECREF(func);
    1350                 Py_DECREF(arg);
    1351                 if(res == NULL)
    1352                         return -1;
    1353                 ret = PyObject_IsTrue(res);
    1354                 Py_DECREF(res);
    1355                 return ret;
    1356         }
    1357 
    1358         /* Couldn't find __contains__. */
    1359         if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
    1360                 Py_ssize_t rc;
    1361                 /* Assume the failure was simply due to that there is no
    1362                 * __contains__ attribute, and try iterating instead.
    1363                 */
    1364                 PyErr_Clear();
    1365                 rc = _PySequence_IterSearch((PyObject *)inst, member,
    1366                                             PY_ITERSEARCH_CONTAINS);
    1367                 if (rc >= 0)
    1368                         return rc > 0;
    1369         }
    1370         return -1;
     1354    static PyObject *__contains__;
     1355    PyObject *func;
     1356
     1357    /* Try __contains__ first.
     1358    * If that can't be done, try iterator-based searching.
     1359    */
     1360
     1361    if(__contains__ == NULL) {
     1362        __contains__ = PyString_InternFromString("__contains__");
     1363        if(__contains__ == NULL)
     1364            return -1;
     1365    }
     1366    func = instance_getattr(inst, __contains__);
     1367    if (func) {
     1368        PyObject *res;
     1369        int ret;
     1370        PyObject *arg = PyTuple_Pack(1, member);
     1371        if(arg == NULL) {
     1372            Py_DECREF(func);
     1373            return -1;
     1374        }
     1375        res = PyEval_CallObject(func, arg);
     1376        Py_DECREF(func);
     1377        Py_DECREF(arg);
     1378        if(res == NULL)
     1379            return -1;
     1380        ret = PyObject_IsTrue(res);
     1381        Py_DECREF(res);
     1382        return ret;
     1383    }
     1384
     1385    /* Couldn't find __contains__. */
     1386    if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
     1387        Py_ssize_t rc;
     1388        /* Assume the failure was simply due to that there is no
     1389        * __contains__ attribute, and try iterating instead.
     1390        */
     1391        PyErr_Clear();
     1392        rc = _PySequence_IterSearch((PyObject *)inst, member,
     1393                                    PY_ITERSEARCH_CONTAINS);
     1394        if (rc >= 0)
     1395            return rc > 0;
     1396    }
     1397    return -1;
    13711398}
    13721399
    13731400static PySequenceMethods
    13741401instance_as_sequence = {
    1375         (lenfunc)instance_length,               /* sq_length */
    1376         0,                                      /* sq_concat */
    1377         0,                                      /* sq_repeat */
    1378         (ssizeargfunc)instance_item,            /* sq_item */
    1379         (ssizessizeargfunc)instance_slice,      /* sq_slice */
    1380         (ssizeobjargproc)instance_ass_item,     /* sq_ass_item */
    1381         (ssizessizeobjargproc)instance_ass_slice,/* sq_ass_slice */
    1382         (objobjproc)instance_contains,          /* sq_contains */
     1402    (lenfunc)instance_length,                   /* sq_length */
     1403    0,                                          /* sq_concat */
     1404    0,                                          /* sq_repeat */
     1405    (ssizeargfunc)instance_item,                /* sq_item */
     1406    (ssizessizeargfunc)instance_slice,          /* sq_slice */
     1407    (ssizeobjargproc)instance_ass_item,         /* sq_ass_item */
     1408    (ssizessizeobjargproc)instance_ass_slice,/* sq_ass_slice */
     1409    (objobjproc)instance_contains,              /* sq_contains */
    13831410};
    13841411
    … …  
    13861413generic_unary_op(PyInstanceObject *self, PyObject *methodname)
    13871414{
    1388         PyObject *func, *res;
    1389 
    1390         if ((func = instance_getattr(self, methodname)) == NULL)
    1391                 return NULL;
    1392         res = PyEval_CallObject(func, (PyObject *)NULL);
    1393         Py_DECREF(func);
    1394         return res;
     1415    PyObject *func, *res;
     1416
     1417    if ((func = instance_getattr(self, methodname)) == NULL)
     1418        return NULL;
     1419    res = PyEval_CallObject(func, (PyObject *)NULL);
     1420    Py_DECREF(func);
     1421    return res;
    13951422}
    13961423
    … …  
    13981425generic_binary_op(PyObject *v, PyObject *w, char *opname)
    13991426{
    1400         PyObject *result;
    1401         PyObject *args;
    1402         PyObject *func = PyObject_GetAttrString(v, opname);
    1403         if (func == NULL) {
    1404                 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
    1405                         return NULL;
    1406                 PyErr_Clear();
    1407                 Py_INCREF(Py_NotImplemented);
    1408                 return Py_NotImplemented;
    1409         }
    1410         args = PyTuple_Pack(1, w);
    1411         if (args == NULL) {
    1412                 Py_DECREF(func);
    1413                 return NULL;
    1414         }
    1415         result = PyEval_CallObject(func, args);
    1416         Py_DECREF(args);
    1417         Py_DECREF(func);
    1418         return result;
     1427    PyObject *result;
     1428    PyObject *args;
     1429    PyObject *func = PyObject_GetAttrString(v, opname);
     1430    if (func == NULL) {
     1431        if (!PyErr_ExceptionMatches(PyExc_AttributeError))
     1432            return NULL;
     1433        PyErr_Clear();
     1434        Py_INCREF(Py_NotImplemented);
     1435        return Py_NotImplemented;
     1436    }
     1437    args = PyTuple_Pack(1, w);
     1438    if (args == NULL) {
     1439        Py_DECREF(func);
     1440        return NULL;
     1441    }
     1442    result = PyEval_CallObject(func, args);
     1443    Py_DECREF(args);
     1444    Py_DECREF(func);
     1445    return result;
    14191446}
    14201447
    … …  
    14251452static PyObject *
    14261453half_binop(PyObject *v, PyObject *w, char *opname, binaryfunc thisfunc,
    1427                 int swapped)
    1428 {
    1429         PyObject *args;
    1430         PyObject *coercefunc;
    1431         PyObject *coerced = NULL;
    1432         PyObject *v1;
    1433         PyObject *result;
    1434 
    1435         if (!PyInstance_Check(v)) {
    1436                 Py_INCREF(Py_NotImplemented);
    1437                 return Py_NotImplemented;
    1438         }
    1439 
    1440         if (coerce_obj == NULL) {
    1441                 coerce_obj = PyString_InternFromString("__coerce__");
    1442                 if (coerce_obj == NULL)
    1443                         return NULL;
    1444         }
    1445         coercefunc = PyObject_GetAttr(v, coerce_obj);
    1446         if (coercefunc == NULL) {
    1447                 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
    1448                         return NULL;
    1449                 PyErr_Clear();
    1450                 return generic_binary_op(v, w, opname);
    1451         }
    1452 
    1453         args = PyTuple_Pack(1, w);
    1454         if (args == NULL) {
    1455                 Py_DECREF(coercefunc);
    1456                 return NULL;
    1457         }
    1458         coerced = PyEval_CallObject(coercefunc, args);
    1459         Py_DECREF(args);
    1460         Py_DECREF(coercefunc);
    1461         if (coerced == NULL) {
    1462                 return NULL;
    1463         }
    1464         if (coerced == Py_None || coerced == Py_NotImplemented) {
    1465                 Py_DECREF(coerced);
    1466                 return generic_binary_op(v, w, opname);
    1467         }
    1468         if (!PyTuple_Check(coerced) || PyTuple_Size(coerced) != 2) {
    1469                 Py_DECREF(coerced);
    1470                 PyErr_SetString(PyExc_TypeError,
    1471                                 "coercion should return None or 2-tuple");
    1472                 return NULL;
    1473         }
    1474         v1 = PyTuple_GetItem(coerced, 0);
    1475         w = PyTuple_GetItem(coerced, 1);
    1476         if (v1->ob_type == v->ob_type && PyInstance_Check(v)) {
    1477                 /* prevent recursion if __coerce__ returns self as the first
    1478                 * argument */
    1479                 result = generic_binary_op(v1, w, opname);
    1480         } else {
    1481                 if (Py_EnterRecursiveCall(" after coercion"))
    1482                     return NULL;
    1483                 if (swapped)
    1484                         result = (thisfunc)(w, v1);
    1485                 else
    1486                         result = (thisfunc)(v1, w);
    1487                 Py_LeaveRecursiveCall();
    1488         }
    1489         Py_DECREF(coerced);
    1490         return result;
     1454                int swapped)
     1455{
     1456    PyObject *args;
     1457    PyObject *coercefunc;
     1458    PyObject *coerced = NULL;
     1459    PyObject *v1;
     1460    PyObject *result;
     1461
     1462    if (!PyInstance_Check(v)) {
     1463        Py_INCREF(Py_NotImplemented);
     1464        return Py_NotImplemented;
     1465    }
     1466
     1467    if (coerce_obj == NULL) {
     1468        coerce_obj = PyString_InternFromString("__coerce__");
     1469        if (coerce_obj == NULL)
     1470            return NULL;
     1471    }
     1472    coercefunc = PyObject_GetAttr(v, coerce_obj);
     1473    if (coercefunc == NULL) {
     1474        if (!PyErr_ExceptionMatches(PyExc_AttributeError))
     1475            return NULL;
     1476        PyErr_Clear();
     1477        return generic_binary_op(v, w, opname);
     1478    }
     1479
     1480    args = PyTuple_Pack(1, w);
     1481    if (args == NULL) {
     1482        Py_DECREF(coercefunc);
     1483        return NULL;
     1484    }
     1485    coerced = PyEval_CallObject(coercefunc, args);
     1486    Py_DECREF(args);
     1487    Py_DECREF(coercefunc);
     1488    if (coerced == NULL) {
     1489        return NULL;
     1490    }
     1491    if (coerced == Py_None || coerced == Py_NotImplemented) {
     1492        Py_DECREF(coerced);
     1493        return generic_binary_op(v, w, opname);
     1494    }
     1495    if (!PyTuple_Check(coerced) || PyTuple_Size(coerced) != 2) {
     1496        Py_DECREF(coerced);
     1497        PyErr_SetString(PyExc_TypeError,
     1498                        "coercion should return None or 2-tuple");
     1499        return NULL;
     1500    }
     1501    v1 = PyTuple_GetItem(coerced, 0);
     1502    w = PyTuple_GetItem(coerced, 1);
     1503    if (v1->ob_type == v->ob_type && PyInstance_Check(v)) {
     1504        /* prevent recursion if __coerce__ returns self as the first
     1505        * argument */
     1506        result = generic_binary_op(v1, w, opname);
     1507    } else {
     1508        if (Py_EnterRecursiveCall(" after coercion"))
     1509            return NULL;
     1510        if (swapped)
     1511            result = (thisfunc)(w, v1);
     1512        else
     1513            result = (thisfunc)(v1, w);
     1514        Py_LeaveRecursiveCall();
     1515    }
     1516    Py_DECREF(coerced);
     1517    return result;
    14911518}
    14921519
    … …  
    14961523                   binaryfunc thisfunc)
    14971524{
    1498         PyObject *result = half_binop(v, w, opname, thisfunc, 0);
    1499         if (result == Py_NotImplemented) {
    1500                 Py_DECREF(result);
    1501                 result = half_binop(w, v, ropname, thisfunc, 1);
    1502         }
    1503         return result;
     1525    PyObject *result = half_binop(v, w, opname, thisfunc, 0);
     1526    if (result == Py_NotImplemented) {
     1527        Py_DECREF(result);
     1528        result = half_binop(w, v, ropname, thisfunc, 1);
     1529    }
     1530    return result;
    15041531}
    15051532
    15061533static PyObject *
    15071534do_binop_inplace(PyObject *v, PyObject *w, char *iopname, char *opname,
    1508                         char *ropname, binaryfunc thisfunc)
    1509 {
    1510         PyObject *result = half_binop(v, w, iopname, thisfunc, 0);
    1511         if (result == Py_NotImplemented) {
    1512                 Py_DECREF(result);
    1513                 result = do_binop(v, w, opname, ropname, thisfunc);
    1514         }
    1515         return result;
     1535                        char *ropname, binaryfunc thisfunc)
     1536{
     1537    PyObject *result = half_binop(v, w, iopname, thisfunc, 0);
     1538    if (result == Py_NotImplemented) {
     1539        Py_DECREF(result);
     1540        result = do_binop(v, w, opname, ropname, thisfunc);
     1541    }
     1542    return result;
    15161543}
    15171544
    … …  
    15191546instance_coerce(PyObject **pv, PyObject **pw)
    15201547{
    1521         PyObject *v = *pv;
    1522         PyObject *w = *pw;
    1523         PyObject *coercefunc;
    1524         PyObject *args;
    1525         PyObject *coerced;
    1526 
    1527         if (coerce_obj == NULL) {
    1528                 coerce_obj = PyString_InternFromString("__coerce__");
    1529                 if (coerce_obj == NULL)
    1530                         return -1;
    1531         }
    1532         coercefunc = PyObject_GetAttr(v, coerce_obj);
    1533         if (coercefunc == NULL) {
    1534                 /* No __coerce__ method */
    1535                 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
    1536                         return -1;
    1537                 PyErr_Clear();
    1538                 return 1;
    1539         }
    1540         /* Has __coerce__ method: call it */
    1541         args = PyTuple_Pack(1, w);
    1542         if (args == NULL) {
    1543                 return -1;
    1544         }
    1545         coerced = PyEval_CallObject(coercefunc, args);
    1546         Py_DECREF(args);
    1547         Py_DECREF(coercefunc);
    1548         if (coerced == NULL) {
    1549                 /* __coerce__ call raised an exception */
    1550                 return -1;
    1551         }
    1552         if (coerced == Py_None || coerced == Py_NotImplemented) {
    1553                 /* __coerce__ says "I can't do it" */
    1554                 Py_DECREF(coerced);
    1555                 return 1;
    1556         }
    1557         if (!PyTuple_Check(coerced) || PyTuple_Size(coerced) != 2) {
    1558                 /* __coerce__ return value is malformed */
    1559                 Py_DECREF(coerced);
    1560                 PyErr_SetString(PyExc_TypeError,
    1561                            "coercion should return None or 2-tuple");
    1562                 return -1;
    1563         }
    1564         /* __coerce__ returned two new values */
    1565         *pv = PyTuple_GetItem(coerced, 0);
    1566         *pw = PyTuple_GetItem(coerced, 1);
    1567         Py_INCREF(*pv);
    1568         Py_INCREF(*pw);
    1569         Py_DECREF(coerced);
    1570         return 0;
     1548    PyObject *v = *pv;
     1549    PyObject *w = *pw;
     1550    PyObject *coercefunc;
     1551    PyObject *args;
     1552    PyObject *coerced;
     1553
     1554    if (coerce_obj == NULL) {
     1555        coerce_obj = PyString_InternFromString("__coerce__");
     1556        if (coerce_obj == NULL)
     1557            return -1;
     1558    }
     1559    coercefunc = PyObject_GetAttr(v, coerce_obj);
     1560    if (coercefunc == NULL) {
     1561        /* No __coerce__ method */
     1562        if (!PyErr_ExceptionMatches(PyExc_AttributeError))
     1563            return -1;
     1564        PyErr_Clear();
     1565        return 1;
     1566    }
     1567    /* Has __coerce__ method: call it */
     1568    args = PyTuple_Pack(1, w);
     1569    if (args == NULL) {
     1570        return -1;
     1571    }
     1572    coerced = PyEval_CallObject(coercefunc, args);
     1573    Py_DECREF(args);
     1574    Py_DECREF(coercefunc);
     1575    if (coerced == NULL) {
     1576        /* __coerce__ call raised an exception */
     1577        return -1;
     1578    }
     1579    if (coerced == Py_None || coerced == Py_NotImplemented) {
     1580        /* __coerce__ says "I can't do it" */
     1581        Py_DECREF(coerced);
     1582        return 1;
     1583    }
     1584    if (!PyTuple_Check(coerced) || PyTuple_Size(coerced) != 2) {
     1585        /* __coerce__ return value is malformed */
     1586        Py_DECREF(coerced);
     1587        PyErr_SetString(PyExc_TypeError,
     1588                   "coercion should return None or 2-tuple");
     1589        return -1;
     1590    }
     1591    /* __coerce__ returned two new values */
     1592    *pv = PyTuple_GetItem(coerced, 0);
     1593    *pw = PyTuple_GetItem(coerced, 1);
     1594    Py_INCREF(*pv);
     1595    Py_INCREF(*pw);
     1596    Py_DECREF(coerced);
     1597    return 0;
    15711598}
    15721599
    15731600#define UNARY(funcname, methodname) \
    15741601static PyObject *funcname(PyInstanceObject *self) { \
    1575         static PyObject *o; \
    1576         if (o == NULL) { o = PyString_InternFromString(methodname); \
    1577                         if (o == NULL) return NULL; } \
    1578         return generic_unary_op(self, o); \
     1602    static PyObject *o; \
     1603    if (o == NULL) { o = PyString_InternFromString(methodname); \
     1604                    if (o == NULL) return NULL; } \
     1605    return generic_unary_op(self, o); \
    15791606}
    15801607
    … …  
    15821609#define UNARY_FB(funcname, methodname, funcname_fb) \
    15831610static PyObject *funcname(PyInstanceObject *self) { \
    1584         static PyObject *o; \
    1585         if (o == NULL) { o = PyString_InternFromString(methodname); \
    1586                         if (o == NULL) return NULL; } \
    1587         if (PyObject_HasAttr((PyObject*)self, o)) \
    1588                 return generic_unary_op(self, o); \
    1589         else \
    1590                 return funcname_fb(self); \
     1611    static PyObject *o; \
     1612    if (o == NULL) { o = PyString_InternFromString(methodname); \
     1613                    if (o == NULL) return NULL; } \
     1614    if (PyObject_HasAttr((PyObject*)self, o)) \
     1615        return generic_unary_op(self, o); \
     1616    else \
     1617        return funcname_fb(self); \
    15911618}
    15921619
    15931620#define BINARY(f, m, n) \
    15941621static PyObject *f(PyObject *v, PyObject *w) { \
    1595         return do_binop(v, w, "__" m "__", "__r" m "__", n); \
     1622    return do_binop(v, w, "__" m "__", "__r" m "__", n); \
    15961623}
    15971624
    15981625#define BINARY_INPLACE(f, m, n) \
    15991626static PyObject *f(PyObject *v, PyObject *w) { \
    1600         return do_binop_inplace(v, w, "__i" m "__", "__" m "__", \
    1601                         "__r" m "__", n); \
     1627    return do_binop_inplace(v, w, "__i" m "__", "__" m "__", \
     1628                    "__r" m "__", n); \
    16021629}
    16031630
    … …  
    16431670half_cmp(PyObject *v, PyObject *w)
    16441671{
    1645         static PyObject *cmp_obj;
    1646         PyObject *args;
    1647         PyObject *cmp_func;
    1648         PyObject *result;
    1649         long l;
    1650 
    1651         assert(PyInstance_Check(v));
    1652 
    1653         if (cmp_obj == NULL) {
    1654                 cmp_obj = PyString_InternFromString("__cmp__");
    1655                 if (cmp_obj == NULL)
    1656                         return -2;
    1657         }
    1658 
    1659         cmp_func = PyObject_GetAttr(v, cmp_obj);
    1660         if (cmp_func == NULL) {
    1661                 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
    1662                         return -2;
    1663                 PyErr_Clear();
    1664                 return 2;
    1665         }
    1666 
    1667         args = PyTuple_Pack(1, w);
    1668         if (args == NULL) {
    1669                 Py_DECREF(cmp_func);
    1670                 return -2;
    1671         }
    1672 
    1673         result = PyEval_CallObject(cmp_func, args);
    1674         Py_DECREF(args);
    1675         Py_DECREF(cmp_func);
    1676 
    1677         if (result == NULL)
    1678                 return -2;
    1679 
    1680         if (result == Py_NotImplemented) {
    1681                 Py_DECREF(result);
    1682                 return 2;
    1683         }
    1684 
    1685         l = PyInt_AsLong(result);
    1686         Py_DECREF(result);
    1687         if (l == -1 && PyErr_Occurred()) {
    1688                 PyErr_SetString(PyExc_TypeError,
    1689                              "comparison did not return an int");
    1690                 return -2;
    1691         }
    1692 
    1693         return l < 0 ? -1 : l > 0 ? 1 : 0;
     1672    static PyObject *cmp_obj;
     1673    PyObject *args;
     1674    PyObject *cmp_func;
     1675    PyObject *result;
     1676    long l;
     1677
     1678    assert(PyInstance_Check(v));
     1679
     1680    if (cmp_obj == NULL) {
     1681        cmp_obj = PyString_InternFromString("__cmp__");
     1682        if (cmp_obj == NULL)
     1683            return -2;
     1684    }
     1685
     1686    cmp_func = PyObject_GetAttr(v, cmp_obj);
     1687    if (cmp_func == NULL) {
     1688        if (!PyErr_ExceptionMatches(PyExc_AttributeError))
     1689            return -2;
     1690        PyErr_Clear();
     1691        return 2;
     1692    }
     1693
     1694    args = PyTuple_Pack(1, w);
     1695    if (args == NULL) {
     1696        Py_DECREF(cmp_func);
     1697        return -2;
     1698    }
     1699
     1700    result = PyEval_CallObject(cmp_func, args);
     1701    Py_DECREF(args);
     1702    Py_DECREF(cmp_func);
     1703
     1704    if (result == NULL)
     1705        return -2;
     1706
     1707    if (result == Py_NotImplemented) {
     1708        Py_DECREF(result);
     1709        return 2;
     1710    }
     1711
     1712    l = PyInt_AsLong(result);
     1713    Py_DECREF(result);
     1714    if (l == -1 && PyErr_Occurred()) {
     1715        PyErr_SetString(PyExc_TypeError,
     1716                     "comparison did not return an int");
     1717        return -2;
     1718    }
     1719
     1720    return l < 0 ? -1 : l > 0 ? 1 : 0;
    16941721}
    16951722
    … …  
    17061733instance_compare(PyObject *v, PyObject *w)
    17071734{
    1708         int c;
    1709 
    1710         c = PyNumber_CoerceEx(&v, &w);
    1711         if (c < 0)
    1712                 return -2;
    1713         if (c == 0) {
    1714                 /* If neither is now an instance, use regular comparison */
    1715                 if (!PyInstance_Check(v) && !PyInstance_Check(w)) {
    1716                         c = PyObject_Compare(v, w);
    1717                         Py_DECREF(v);
    1718                         Py_DECREF(w);
    1719                         if (PyErr_Occurred())
    1720                                 return -2;
    1721                         return c < 0 ? -1 : c > 0 ? 1 : 0;
    1722                 }
    1723         }
    1724         else {
    1725                 /* The coercion didn't do anything.
    1726                    Treat this the same as returning v and w unchanged. */
    1727                 Py_INCREF(v);
    1728                 Py_INCREF(w);
    1729         }
    1730 
    1731         if (PyInstance_Check(v)) {
    1732                 c = half_cmp(v, w);
    1733                 if (c <= 1) {
    1734                         Py_DECREF(v);
    1735                         Py_DECREF(w);
    1736                         return c;
    1737                 }
    1738         }
    1739         if (PyInstance_Check(w)) {
    1740                 c = half_cmp(w, v);
    1741                 if (c <= 1) {
    1742                         Py_DECREF(v);
    1743                         Py_DECREF(w);
    1744                         if (c >= -1)
    1745                                 c = -c;
    1746                         return c;
    1747                 }
    1748         }
    1749         Py_DECREF(v);
    1750         Py_DECREF(w);
    1751         return 2;
     1735    int c;
     1736
     1737    c = PyNumber_CoerceEx(&v, &w);
     1738    if (c < 0)
     1739        return -2;
     1740    if (c == 0) {
     1741        /* If neither is now an instance, use regular comparison */
     1742        if (!PyInstance_Check(v) && !PyInstance_Check(w)) {
     1743            c = PyObject_Compare(v, w);
     1744            Py_DECREF(v);
     1745            Py_DECREF(w);
     1746            if (PyErr_Occurred())
     1747                return -2;
     1748            return c < 0 ? -1 : c > 0 ? 1 : 0;
     1749        }
     1750    }
     1751    else {
     1752        /* The coercion didn't do anything.
     1753           Treat this the same as returning v and w unchanged. */
     1754        Py_INCREF(v);
     1755        Py_INCREF(w);
     1756    }
     1757
     1758    if (PyInstance_Check(v)) {
     1759        c = half_cmp(v, w);
     1760        if (c <= 1) {
     1761            Py_DECREF(v);
     1762            Py_DECREF(w);
     1763            return c;
     1764        }
     1765    }
     1766    if (PyInstance_Check(w)) {
     1767        c = half_cmp(w, v);
     1768        if (c <= 1) {
     1769            Py_DECREF(v);
     1770            Py_DECREF(w);
     1771            if (c >= -1)
     1772                c = -c;
     1773            return c;
     1774        }
     1775    }
     1776    Py_DECREF(v);
     1777    Py_DECREF(w);
     1778    return 2;
    17521779}
    17531780
    … …  
    17551782instance_nonzero(PyInstanceObject *self)
    17561783{
    1757         PyObject *func, *res;
    1758         long outcome;
    1759         static PyObject *nonzerostr;
    1760 
    1761         if (nonzerostr == NULL) {
    1762                 nonzerostr = PyString_InternFromString("__nonzero__");
    1763                 if (nonzerostr == NULL)
    1764                         return -1;
    1765         }
    1766         if ((func = instance_getattr(self, nonzerostr)) == NULL) {
    1767                 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
    1768                         return -1;
    1769                 PyErr_Clear();
    1770                 if (lenstr == NULL) {
    1771                         lenstr = PyString_InternFromString("__len__");
    1772                         if (lenstr == NULL)
    1773                                 return -1;
    1774                 }
    1775                 if ((func = instance_getattr(self, lenstr)) == NULL) {
    1776                         if (!PyErr_ExceptionMatches(PyExc_AttributeError))
    1777                                 return -1;
    1778                         PyErr_Clear();
    1779                         /* Fall back to the default behavior:
    1780                            all instances are nonzero */
    1781                         return 1;
    1782                 }
    1783         }
    1784         res = PyEval_CallObject(func, (PyObject *)NULL);
    1785         Py_DECREF(func);
    1786         if (res == NULL)
    1787                 return -1;
    1788         if (!PyInt_Check(res)) {
    1789                 Py_DECREF(res);
    1790                 PyErr_SetString(PyExc_TypeError,
    1791                                 "__nonzero__ should return an int");
    1792                 return -1;
    1793         }
    1794         outcome = PyInt_AsLong(res);
    1795         Py_DECREF(res);
    1796         if (outcome < 0) {
    1797                 PyErr_SetString(PyExc_ValueError,
    1798                                 "__nonzero__ should return >= 0");
    1799                 return -1;
    1800         }
    1801         return outcome > 0;
     1784    PyObject *func, *res;
     1785    long outcome;
     1786    static PyObject *nonzerostr;
     1787
     1788    if (nonzerostr == NULL) {
     1789        nonzerostr = PyString_InternFromString("__nonzero__");
     1790        if (nonzerostr == NULL)
     1791            return -1;
     1792    }
     1793    if ((func = instance_getattr(self, nonzerostr)) == NULL) {
     1794        if (!PyErr_ExceptionMatches(PyExc_AttributeError))
     1795            return -1;
     1796        PyErr_Clear();
     1797        if (lenstr == NULL) {
     1798            lenstr = PyString_InternFromString("__len__");
     1799            if (lenstr == NULL)
     1800                return -1;
     1801        }
     1802        if ((func = instance_getattr(self, lenstr)) == NULL) {
     1803            if (!PyErr_ExceptionMatches(PyExc_AttributeError))
     1804                return -1;
     1805            PyErr_Clear();
     1806            /* Fall back to the default behavior:
     1807               all instances are nonzero */
     1808            return 1;
     1809        }
     1810    }
     1811    res = PyEval_CallObject(func, (PyObject *)NULL);
     1812    Py_DECREF(func);
     1813    if (res == NULL)
     1814        return -1;
     1815    if (!PyInt_Check(res)) {
     1816        Py_DECREF(res);
     1817        PyErr_SetString(PyExc_TypeError,
     1818                        "__nonzero__ should return an int");
     1819        return -1;
     1820    }
     1821    outcome = PyInt_AsLong(res);
     1822    Py_DECREF(res);
     1823    if (outcome < 0) {
     1824        PyErr_SetString(PyExc_ValueError,
     1825                        "__nonzero__ should return >= 0");
     1826        return -1;
     1827    }
     1828    return outcome > 0;
    18021829}
    18031830
    … …  
    18051832instance_index(PyInstanceObject *self)
    18061833{
    1807         PyObject *func, *res;
    1808         static PyObject *indexstr = NULL;
    1809 
    1810         if (indexstr == NULL) {
    1811                 indexstr = PyString_InternFromString("__index__");
    1812                 if (indexstr == NULL)
    1813                         return NULL;
    1814         }       
    1815         if ((func = instance_getattr(self, indexstr)) == NULL) {
    1816                 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
    1817                         return NULL;
    1818                 PyErr_Clear();
    1819                 PyErr_SetString(PyExc_TypeError,
    1820                                 "object cannot be interpreted as an index");
    1821                 return NULL;
    1822         }
    1823         res = PyEval_CallObject(func, (PyObject *)NULL);
    1824         Py_DECREF(func);
    1825         return res;
     1834    PyObject *func, *res;
     1835    static PyObject *indexstr = NULL;
     1836
     1837    if (indexstr == NULL) {
     1838        indexstr = PyString_InternFromString("__index__");
     1839        if (indexstr == NULL)
     1840            return NULL;
     1841    }
     1842    if ((func = instance_getattr(self, indexstr)) == NULL) {
     1843        if (!PyErr_ExceptionMatches(PyExc_AttributeError))
     1844            return NULL;
     1845        PyErr_Clear();
     1846        PyErr_SetString(PyExc_TypeError,
     1847                        "object cannot be interpreted as an index");
     1848        return NULL;
     1849    }
     1850    res = PyEval_CallObject(func, (PyObject *)NULL);
     1851    Py_DECREF(func);
     1852    return res;
    18261853}
    18271854
    … …  
    18331860instance_int(PyInstanceObject *self)
    18341861{
    1835         PyObject *truncated;
    1836         static PyObject *int_name;
    1837         if (int_name == NULL) {
    1838                 int_name = PyString_InternFromString("__int__");
    1839                 if (int_name == NULL)
    1840                         return NULL;
    1841         }
    1842         if (PyObject_HasAttr((PyObject*)self, int_name))
    1843                 return generic_unary_op(self, int_name);
    1844 
    1845         truncated = _instance_trunc(self);
    1846         /* __trunc__ is specified to return an Integral type, but
    1847            int() needs to return an int. */
    1848         return _PyNumber_ConvertIntegralToInt(
    1849                 truncated,
    1850                 "__trunc__ returned non-Integral (type %.200s)");
     1862    PyObject *truncated;
     1863    static PyObject *int_name;
     1864    if (int_name == NULL) {
     1865        int_name = PyString_InternFromString("__int__");
     1866        if (int_name == NULL)
     1867            return NULL;
     1868    }
     1869    if (PyObject_HasAttr((PyObject*)self, int_name))
     1870        return generic_unary_op(self, int_name);
     1871
     1872    truncated = _instance_trunc(self);
     1873    /* __trunc__ is specified to return an Integral type, but
     1874       int() needs to return an int. */
     1875    return _PyNumber_ConvertIntegralToInt(
     1876        truncated,
     1877        "__trunc__ returned non-Integral (type %.200s)");
    18511878}
    18521879
    … …  
    18591886bin_power(PyObject *v, PyObject *w)
    18601887{
    1861         return PyNumber_Power(v, w, Py_None);
     1888    return PyNumber_Power(v, w, Py_None);
    18621889}
    18631890
    … …  
    18661893instance_pow(PyObject *v, PyObject *w, PyObject *z)
    18671894{
    1868         if (z == Py_None) {
    1869                 return do_binop(v, w, "__pow__", "__rpow__", bin_power);
    1870         }
    1871         else {
    1872                 PyObject *func;
    1873                 PyObject *args;
    1874                 PyObject *result;
    1875 
    1876                 /* XXX Doesn't do coercions... */
    1877                 func = PyObject_GetAttrString(v, "__pow__");
    1878                 if (func == NULL)
    1879                         return NULL;
    1880                 args = PyTuple_Pack(2, w, z);
    1881                 if (args == NULL) {
    1882                         Py_DECREF(func);
    1883                         return NULL;
    1884                 }
    1885                 result = PyEval_CallObject(func, args);
    1886                 Py_DECREF(func);
    1887                 Py_DECREF(args);
    1888                 return result;
    1889         }
     1895    if (z == Py_None) {
     1896        return do_binop(v, w, "__pow__", "__rpow__", bin_power);
     1897    }
     1898    else {
     1899        PyObject *func;
     1900        PyObject *args;
     1901        PyObject *result;
     1902
     1903        /* XXX Doesn't do coercions... */
     1904        func = PyObject_GetAttrString(v, "__pow__");
     1905        if (func == NULL)
     1906            return NULL;
     1907        args = PyTuple_Pack(2, w, z);
     1908        if (args == NULL) {
     1909            Py_DECREF(func);
     1910            return NULL;
     1911        }
     1912        result = PyEval_CallObject(func, args);
     1913        Py_DECREF(func);
     1914        Py_DECREF(args);
     1915        return result;
     1916    }
    18901917}
    18911918
    … …  
    18931920bin_inplace_power(PyObject *v, PyObject *w)
    18941921{
    1895         return PyNumber_InPlacePower(v, w, Py_None);
     1922    return PyNumber_InPlacePower(v, w, Py_None);
    18961923}
    18971924
    … …  
    19001927instance_ipow(PyObject *v, PyObject *w, PyObject *z)
    19011928{
    1902         if (z == Py_None) {
    1903                 return do_binop_inplace(v, w, "__ipow__", "__pow__",
    1904                         "__rpow__", bin_inplace_power);
    1905         }
    1906         else {
    1907                 /* XXX Doesn't do coercions... */
    1908                 PyObject *func;
    1909                 PyObject *args;
    1910                 PyObject *result;
    1911 
    1912                 func = PyObject_GetAttrString(v, "__ipow__");
    1913                 if (func == NULL) {
    1914                         if (!PyErr_ExceptionMatches(PyExc_AttributeError))
    1915                                 return NULL;
    1916                         PyErr_Clear();
    1917                         return instance_pow(v, w, z);
    1918                 }
    1919                 args = PyTuple_Pack(2, w, z);
    1920                 if (args == NULL) {
    1921                         Py_DECREF(func);
    1922                         return NULL;
    1923                 }
    1924                 result = PyEval_CallObject(func, args);
    1925                 Py_DECREF(func);
    1926                 Py_DECREF(args);
    1927                 return result;
    1928         }
     1929    if (z == Py_None) {
     1930        return do_binop_inplace(v, w, "__ipow__", "__pow__",
     1931            "__rpow__", bin_inplace_power);
     1932    }
     1933    else {
     1934        /* XXX Doesn't do coercions... */
     1935        PyObject *func;
     1936        PyObject *args;
     1937        PyObject *result;
     1938
     1939        func = PyObject_GetAttrString(v, "__ipow__");
     1940        if (func == NULL) {
     1941            if (!PyErr_ExceptionMatches(PyExc_AttributeError))
     1942                return NULL;
     1943            PyErr_Clear();
     1944            return instance_pow(v, w, z);
     1945        }
     1946        args = PyTuple_Pack(2, w, z);
     1947        if (args == NULL) {
     1948            Py_DECREF(func);
     1949            return NULL;
     1950        }
     1951        result = PyEval_CallObject(func, args);
     1952        Py_DECREF(func);
     1953        Py_DECREF(args);
     1954        return result;
     1955    }
    19291956}
    19301957
    … …  
    19371964init_name_op(void)
    19381965{
    1939         int i;
    1940         char *_name_op[] = {
    1941                 "__lt__",
    1942                 "__le__",
    1943                 "__eq__",
    1944                 "__ne__",
    1945                 "__gt__",
    1946                 "__ge__",
    1947         };
    1948 
    1949         name_op = (PyObject **)malloc(sizeof(PyObject *) * NAME_OPS);
    1950         if (name_op == NULL)
    1951                 return -1;
    1952         for (i = 0; i < NAME_OPS; ++i) {
    1953                 name_op[i] = PyString_InternFromString(_name_op[i]);
    1954                 if (name_op[i] == NULL)
    1955                         return -1;
    1956         }
    1957         return 0;
     1966    int i;
     1967    char *_name_op[] = {
     1968        "__lt__",
     1969        "__le__",
     1970        "__eq__",
     1971        "__ne__",
     1972        "__gt__",
     1973        "__ge__",
     1974    };
     1975
     1976    name_op = (PyObject **)malloc(sizeof(PyObject *) * NAME_OPS);
     1977    if (name_op == NULL)
     1978        return -1;
     1979    for (i = 0; i < NAME_OPS; ++i) {
     1980        name_op[i] = PyString_InternFromString(_name_op[i]);
     1981        if (name_op[i] == NULL)
     1982            return -1;
     1983    }
     1984    return 0;
    19581985}
    19591986
    … …  
    19611988half_richcompare(PyObject *v, PyObject *w, int op)
    19621989{
    1963         PyObject *method;
    1964         PyObject *args;
    1965         PyObject *res;
    1966 
    1967         assert(PyInstance_Check(v));
    1968 
    1969         if (name_op == NULL) {
    1970                 if (init_name_op() < 0)
    1971                         return NULL;
    1972         }
    1973         /* If the instance doesn't define an __getattr__ method, use
    1974            instance_getattr2 directly because it will not set an
    1975            exception on failure. */
    1976         if (((PyInstanceObject *)v)->in_class->cl_getattr == NULL)
    1977                 method = instance_getattr2((PyInstanceObject *)v,
    1978                                            name_op[op]);
    1979         else
    1980                 method = PyObject_GetAttr(v, name_op[op]);
    1981         if (method == NULL) {
    1982                 if (PyErr_Occurred()) {
    1983                         if (!PyErr_ExceptionMatches(PyExc_AttributeError))
    1984                                 return NULL;
    1985                         PyErr_Clear();
    1986                 }
    1987                 res = Py_NotImplemented;
    1988                 Py_INCREF(res);
    1989                 return res;
    1990         }
    1991 
    1992         args = PyTuple_Pack(1, w);
    1993         if (args == NULL) {
    1994                 Py_DECREF(method);
    1995                 return NULL;
    1996         }
    1997 
    1998         res = PyEval_CallObject(method, args);
    1999         Py_DECREF(args);
    2000         Py_DECREF(method);
    2001 
    2002         return res;
     1990    PyObject *method;
     1991    PyObject *args;
     1992    PyObject *res;
     1993
     1994    assert(PyInstance_Check(v));
     1995
     1996    if (name_op == NULL) {
     1997        if (init_name_op() < 0)
     1998            return NULL;
     1999    }
     2000    /* If the instance doesn't define an __getattr__ method, use
     2001       instance_getattr2 directly because it will not set an
     2002       exception on failure. */
     2003    if (((PyInstanceObject *)v)->in_class->cl_getattr == NULL)
     2004        method = instance_getattr2((PyInstanceObject *)v,
     2005                                   name_op[op]);
     2006    else
     2007        method = PyObject_GetAttr(v, name_op[op]);
     2008    if (method == NULL) {
     2009        if (PyErr_Occurred()) {
     2010            if (!PyErr_ExceptionMatches(PyExc_AttributeError))
     2011                return NULL;
     2012            PyErr_Clear();
     2013        }
     2014        res = Py_NotImplemented;
     2015        Py_INCREF(res);
     2016        return res;
     2017    }
     2018
     2019    args = PyTuple_Pack(1, w);
     2020    if (args == NULL) {
     2021        Py_DECREF(method);
     2022        return NULL;
     2023    }
     2024
     2025    res = PyEval_CallObject(method, args);
     2026    Py_DECREF(args);
     2027    Py_DECREF(method);
     2028
     2029    return res;
    20032030}
    20042031
    … …  
    20062033instance_richcompare(PyObject *v, PyObject *w, int op)
    20072034{
    2008         PyObject *res;
    2009 
    2010         if (PyInstance_Check(v)) {
    2011                 res = half_richcompare(v, w, op);
    2012                 if (res != Py_NotImplemented)
    2013                         return res;
    2014                 Py_DECREF(res);
    2015         }
    2016 
    2017         if (PyInstance_Check(w)) {
    2018                 res = half_richcompare(w, v, _Py_SwappedOp[op]);
    2019                 if (res != Py_NotImplemented)
    2020                         return res;
    2021                 Py_DECREF(res);
    2022         }
    2023 
    2024         Py_INCREF(Py_NotImplemented);
    2025         return Py_NotImplemented;
     2035    PyObject *res;
     2036
     2037    if (PyInstance_Check(v)) {
     2038        res = half_richcompare(v, w, op);
     2039        if (res != Py_NotImplemented)
     2040            return res;
     2041        Py_DECREF(res);
     2042    }
     2043
     2044    if (PyInstance_Check(w)) {
     2045        res = half_richcompare(w, v, _Py_SwappedOp[op]);
     2046        if (res != Py_NotImplemented)
     2047            return res;
     2048        Py_DECREF(res);
     2049    }
     2050
     2051    Py_INCREF(Py_NotImplemented);
     2052    return Py_NotImplemented;
    20262053}
    20272054
    … …  
    20312058instance_getiter(PyInstanceObject *self)
    20322059{
    2033         PyObject *func;
    2034 
    2035         if (iterstr == NULL) {
    2036                 iterstr = PyString_InternFromString("__iter__");
    2037                 if (iterstr == NULL)
    2038                         return NULL;
    2039         }
    2040         if (getitemstr == NULL) {
    2041                 getitemstr = PyString_InternFromString("__getitem__");
    2042                 if (getitemstr == NULL)
    2043                         return NULL;
    2044         }
    2045 
    2046         if ((func = instance_getattr(self, iterstr)) != NULL) {
    2047                 PyObject *res = PyEval_CallObject(func, (PyObject *)NULL);
    2048                 Py_DECREF(func);
    2049                 if (res != NULL && !PyIter_Check(res)) {
    2050                         PyErr_Format(PyExc_TypeError,
    2051                                      "__iter__ returned non-iterator "
    2052                                      "of type '%.100s'",
    2053                                      res->ob_type->tp_name);
    2054                         Py_DECREF(res);
    2055                         res = NULL;
    2056                 }
    2057                 return res;
    2058         }
    2059         if (!PyErr_ExceptionMatches(PyExc_AttributeError))
    2060                 return NULL;
    2061         PyErr_Clear();
    2062         if ((func = instance_getattr(self, getitemstr)) == NULL) {
    2063                 PyErr_SetString(PyExc_TypeError,
    2064                                 "iteration over non-sequence");
    2065                 return NULL;
    2066         }
    2067         Py_DECREF(func);
    2068         return PySeqIter_New((PyObject *)self);
     2060    PyObject *func;
     2061
     2062    if (iterstr == NULL) {
     2063        iterstr = PyString_InternFromString("__iter__");
     2064        if (iterstr == NULL)
     2065            return NULL;
     2066    }
     2067    if (getitemstr == NULL) {
     2068        getitemstr = PyString_InternFromString("__getitem__");
     2069        if (getitemstr == NULL)
     2070            return NULL;
     2071    }
     2072
     2073    if ((func = instance_getattr(self, iterstr)) != NULL) {
     2074        PyObject *res = PyEval_CallObject(func, (PyObject *)NULL);
     2075        Py_DECREF(func);
     2076        if (res != NULL && !PyIter_Check(res)) {
     2077            PyErr_Format(PyExc_TypeError,
     2078                         "__iter__ returned non-iterator "
     2079                         "of type '%.100s'",
     2080                         res->ob_type->tp_name);
     2081            Py_DECREF(res);
     2082            res = NULL;
     2083        }
     2084        return res;
     2085    }
     2086    if (!PyErr_ExceptionMatches(PyExc_AttributeError))
     2087        return NULL;
     2088    PyErr_Clear();
     2089    if ((func = instance_getattr(self, getitemstr)) == NULL) {
     2090        PyErr_SetString(PyExc_TypeError,
     2091                        "iteration over non-sequence");
     2092        return NULL;
     2093    }
     2094    Py_DECREF(func);
     2095    return PySeqIter_New((PyObject *)self);
    20692096}
    20702097
    … …  
    20742101instance_iternext(PyInstanceObject *self)
    20752102{
    2076         PyObject *func;
    2077 
    2078         if (nextstr == NULL) {
    2079                 nextstr = PyString_InternFromString("next");
    2080                 if (nextstr == NULL)
    2081                         return NULL;
    2082         }
    2083 
    2084         if ((func = instance_getattr(self, nextstr)) != NULL) {
    2085                 PyObject *res = PyEval_CallObject(func, (PyObject *)NULL);
    2086                 Py_DECREF(func);
    2087                 if (res != NULL) {
    2088                         return res;
    2089                 }
    2090                 if (PyErr_ExceptionMatches(PyExc_StopIteration)) {
    2091                         PyErr_Clear();
    2092                         return NULL;
    2093                 }
    2094                 return NULL;
    2095         }
    2096         PyErr_SetString(PyExc_TypeError, "instance has no next() method");
    2097         return NULL;
     2103    PyObject *func;
     2104
     2105    if (nextstr == NULL) {
     2106        nextstr = PyString_InternFromString("next");
     2107        if (nextstr == NULL)
     2108            return NULL;
     2109    }
     2110
     2111    if ((func = instance_getattr(self, nextstr)) != NULL) {
     2112        PyObject *res = PyEval_CallObject(func, (PyObject *)NULL);
     2113        Py_DECREF(func);
     2114        if (res != NULL) {
     2115            return res;
     2116        }
     2117        if (PyErr_ExceptionMatches(PyExc_StopIteration)) {
     2118            PyErr_Clear();
     2119            return NULL;
     2120        }
     2121        return NULL;
     2122    }
     2123    PyErr_SetString(PyExc_TypeError, "instance has no next() method");
     2124    return NULL;
    20982125}
    20992126
    … …  
    21012128instance_call(PyObject *func, PyObject *arg, PyObject *kw)
    21022129{
    2103         PyObject *res, *call = PyObject_GetAttrString(func, "__call__");
    2104         if (call == NULL) {
    2105                 PyInstanceObject *inst = (PyInstanceObject*) func;
    2106                 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
    2107                         return NULL;
    2108                 PyErr_Clear();
    2109                 PyErr_Format(PyExc_AttributeError,
    2110                              "%.200s instance has no __call__ method",
    2111                              PyString_AsString(inst->in_class->cl_name));
    2112                 return NULL;
    2113         }
    2114         /* We must check and increment the recursion depth here. Scenario:
    2115                class A:
    2116                    pass
    2117                A.__call__ = A() # that's right
    2118                a = A() # ok
    2119                a() # infinite recursion
    2120            This bounces between instance_call() and PyObject_Call() without
    2121            ever hitting eval_frame() (which has the main recursion check). */
    2122         if (Py_EnterRecursiveCall(" in __call__")) {
    2123                 res = NULL;
    2124         }
    2125         else {
    2126                 res = PyObject_Call(call, arg, kw);
    2127                 Py_LeaveRecursiveCall();
    2128         }
    2129         Py_DECREF(call);
    2130         return res;
     2130    PyObject *res, *call = PyObject_GetAttrString(func, "__call__");
     2131    if (call == NULL) {
     2132        PyInstanceObject *inst = (PyInstanceObject*) func;
     2133        if (!PyErr_ExceptionMatches(PyExc_AttributeError))
     2134            return NULL;
     2135        PyErr_Clear();
     2136        PyErr_Format(PyExc_AttributeError,
     2137                     "%.200s instance has no __call__ method",
     2138                     PyString_AsString(inst->in_class->cl_name));
     2139        return NULL;
     2140    }
     2141    /* We must check and increment the recursion depth here. Scenario:
     2142           class A:
     2143           pass
     2144           A.__call__ = A() # that's right
     2145           a = A() # ok
     2146           a() # infinite recursion
     2147       This bounces between instance_call() and PyObject_Call() without
     2148       ever hitting eval_frame() (which has the main recursion check). */
     2149    if (Py_EnterRecursiveCall(" in __call__")) {
     2150        res = NULL;
     2151    }
     2152    else {
     2153        res = PyObject_Call(call, arg, kw);
     2154        Py_LeaveRecursiveCall();
     2155    }
     2156    Py_DECREF(call);
     2157    return res;
    21312158}
    21322159
    21332160
    21342161static PyNumberMethods instance_as_number = {
    2135         instance_add,                   /* nb_add */
    2136         instance_sub,                   /* nb_subtract */
    2137         instance_mul,                   /* nb_multiply */
    2138         instance_div,                   /* nb_divide */
    2139         instance_mod,                   /* nb_remainder */
    2140         instance_divmod,                /* nb_divmod */
    2141         instance_pow,                   /* nb_power */
    2142         (unaryfunc)instance_neg,        /* nb_negative */
    2143         (unaryfunc)instance_pos,        /* nb_positive */
    2144         (unaryfunc)instance_abs,        /* nb_absolute */
    2145         (inquiry)instance_nonzero,      /* nb_nonzero */
    2146         (unaryfunc)instance_invert,     /* nb_invert */
    2147         instance_lshift,                /* nb_lshift */
    2148         instance_rshift,                /* nb_rshift */
    2149         instance_and,                   /* nb_and */
    2150         instance_xor,                   /* nb_xor */
    2151         instance_or,                    /* nb_or */
    2152         instance_coerce,                /* nb_coerce */
    2153         (unaryfunc)instance_int,        /* nb_int */
    2154         (unaryfunc)instance_long,       /* nb_long */
    2155         (unaryfunc)instance_float,      /* nb_float */
    2156         (unaryfunc)instance_oct,        /* nb_oct */
    2157         (unaryfunc)instance_hex,        /* nb_hex */
    2158         instance_iadd,                  /* nb_inplace_add */
    2159         instance_isub,                  /* nb_inplace_subtract */
    2160         instance_imul,                  /* nb_inplace_multiply */
    2161         instance_idiv,                  /* nb_inplace_divide */
    2162         instance_imod,                  /* nb_inplace_remainder */
    2163         instance_ipow,                  /* nb_inplace_power */
    2164         instance_ilshift,               /* nb_inplace_lshift */
    2165         instance_irshift,               /* nb_inplace_rshift */
    2166         instance_iand,                  /* nb_inplace_and */
    2167         instance_ixor,                  /* nb_inplace_xor */
    2168         instance_ior,                   /* nb_inplace_or */
    2169         instance_floordiv,              /* nb_floor_divide */
    2170         instance_truediv,               /* nb_true_divide */
    2171         instance_ifloordiv,             /* nb_inplace_floor_divide */
    2172         instance_itruediv,              /* nb_inplace_true_divide */
    2173         (unaryfunc)instance_index,      /* nb_index */
     2162    instance_add,                       /* nb_add */
     2163    instance_sub,                       /* nb_subtract */
     2164    instance_mul,                       /* nb_multiply */
     2165    instance_div,                       /* nb_divide */
     2166    instance_mod,                       /* nb_remainder */
     2167    instance_divmod,                    /* nb_divmod */
     2168    instance_pow,                       /* nb_power */
     2169    (unaryfunc)instance_neg,            /* nb_negative */
     2170    (unaryfunc)instance_pos,            /* nb_positive */
     2171    (unaryfunc)instance_abs,            /* nb_absolute */
     2172    (inquiry)instance_nonzero,          /* nb_nonzero */
     2173    (unaryfunc)instance_invert,         /* nb_invert */
     2174    instance_lshift,                    /* nb_lshift */
     2175    instance_rshift,                    /* nb_rshift */
     2176    instance_and,                       /* nb_and */
     2177    instance_xor,                       /* nb_xor */
     2178    instance_or,                        /* nb_or */
     2179    instance_coerce,                    /* nb_coerce */
     2180    (unaryfunc)instance_int,            /* nb_int */
     2181    (unaryfunc)instance_long,           /* nb_long */
     2182    (unaryfunc)instance_float,          /* nb_float */
     2183    (unaryfunc)instance_oct,            /* nb_oct */
     2184    (unaryfunc)instance_hex,            /* nb_hex */
     2185    instance_iadd,                      /* nb_inplace_add */
     2186    instance_isub,                      /* nb_inplace_subtract */
     2187    instance_imul,                      /* nb_inplace_multiply */
     2188    instance_idiv,                      /* nb_inplace_divide */
     2189    instance_imod,                      /* nb_inplace_remainder */
     2190    instance_ipow,                      /* nb_inplace_power */
     2191    instance_ilshift,                   /* nb_inplace_lshift */
     2192    instance_irshift,                   /* nb_inplace_rshift */
     2193    instance_iand,                      /* nb_inplace_and */
     2194    instance_ixor,                      /* nb_inplace_xor */
     2195    instance_ior,                       /* nb_inplace_or */
     2196    instance_floordiv,                  /* nb_floor_divide */
     2197    instance_truediv,                   /* nb_true_divide */
     2198    instance_ifloordiv,                 /* nb_inplace_floor_divide */
     2199    instance_itruediv,                  /* nb_inplace_true_divide */
     2200    (unaryfunc)instance_index,          /* nb_index */
    21742201};
    21752202
    21762203PyTypeObject PyInstance_Type = {
    2177         PyObject_HEAD_INIT(&PyType_Type)
    2178         0,
    2179         "instance",
    2180         sizeof(PyInstanceObject),
    2181         0,
    2182         (destructor)instance_dealloc,           /* tp_dealloc */
    2183         0,                                      /* tp_print */
    2184         0,                                      /* tp_getattr */
    2185         0,                                      /* tp_setattr */
    2186         instance_compare,                       /* tp_compare */
    2187         (reprfunc)instance_repr,                /* tp_repr */
    2188         &instance_as_number,                    /* tp_as_number */
    2189         &instance_as_sequence,                  /* tp_as_sequence */
    2190         &instance_as_mapping,                   /* tp_as_mapping */
    2191         (hashfunc)instance_hash,                /* tp_hash */
    2192         instance_call,                          /* tp_call */
    2193         (reprfunc)instance_str,                 /* tp_str */
    2194         (getattrofunc)instance_getattr,         /* tp_getattro */
    2195         (setattrofunc)instance_setattr,         /* tp_setattro */
    2196         0,                                      /* tp_as_buffer */
    2197         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_CHECKTYPES,/*tp_flags*/
    2198         instance_doc,                           /* tp_doc */
    2199         (traverseproc)instance_traverse,        /* tp_traverse */
    2200         0,                                      /* tp_clear */
    2201         instance_richcompare,                   /* tp_richcompare */
    2202         offsetof(PyInstanceObject, in_weakreflist), /* tp_weaklistoffset */
    2203         (getiterfunc)instance_getiter,          /* tp_iter */
    2204         (iternextfunc)instance_iternext,        /* tp_iternext */
    2205         0,                                      /* tp_methods */
    2206         0,                                      /* tp_members */
    2207         0,                                      /* tp_getset */
    2208         0,                                      /* tp_base */
    2209         0,                                      /* tp_dict */
    2210         0,                                      /* tp_descr_get */
    2211         0,                                      /* tp_descr_set */
    2212         0,                                      /* tp_dictoffset */
    2213         0,                                      /* tp_init */
    2214         0,                                      /* tp_alloc */
    2215         instance_new,                           /* tp_new */
     2204    PyObject_HEAD_INIT(&PyType_Type)
     2205    0,
     2206    "instance",
     2207    sizeof(PyInstanceObject),
     2208    0,
     2209    (destructor)instance_dealloc,               /* tp_dealloc */
     2210    0,                                          /* tp_print */
     2211    0,                                          /* tp_getattr */
     2212    0,                                          /* tp_setattr */
     2213    instance_compare,                           /* tp_compare */
     2214    (reprfunc)instance_repr,                    /* tp_repr */
     2215    &instance_as_number,                        /* tp_as_number */
     2216    &instance_as_sequence,                      /* tp_as_sequence */
     2217    &instance_as_mapping,                       /* tp_as_mapping */
     2218    (hashfunc)instance_hash,                    /* tp_hash */
     2219    instance_call,                              /* tp_call */
     2220    (reprfunc)instance_str,                     /* tp_str */
     2221    (getattrofunc)instance_getattr,             /* tp_getattro */
     2222    (setattrofunc)instance_setattr,             /* tp_setattro */
     2223    0,                                          /* tp_as_buffer */
     2224    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_CHECKTYPES,/*tp_flags*/
     2225    instance_doc,                               /* tp_doc */
     2226    (traverseproc)instance_traverse,            /* tp_traverse */
     2227    0,                                          /* tp_clear */
     2228    instance_richcompare,                       /* tp_richcompare */
     2229    offsetof(PyInstanceObject, in_weakreflist), /* tp_weaklistoffset */
     2230    (getiterfunc)instance_getiter,              /* tp_iter */
     2231    (iternextfunc)instance_iternext,            /* tp_iternext */
     2232    0,                                          /* tp_methods */
     2233    0,                                          /* tp_members */
     2234    0,                                          /* tp_getset */
     2235    0,                                          /* tp_base */
     2236    0,                                          /* tp_dict */
     2237    0,                                          /* tp_descr_get */
     2238    0,                                          /* tp_descr_set */
     2239    0,                                          /* tp_dictoffset */
     2240    0,                                          /* tp_init */
     2241    0,                                          /* tp_alloc */
     2242    instance_new,                               /* tp_new */
    22162243};
    22172244
    … …  
    22262253PyMethod_New(PyObject *func, PyObject *self, PyObject *klass)
    22272254{
    2228         register PyMethodObject *im;
    2229         if (!PyCallable_Check(func)) {
    2230                 PyErr_BadInternalCall();
    2231                 return NULL;
    2232         }
    2233         im = free_list;
    2234         if (im != NULL) {
    2235                 free_list = (PyMethodObject *)(im->im_self);
    2236                 PyObject_INIT(im, &PyMethod_Type);
    2237                 numfree--;
    2238         }
    2239         else {
    2240                 im = PyObject_GC_New(PyMethodObject, &PyMethod_Type);
    2241                 if (im == NULL)
    2242                         return NULL;
    2243         }
    2244         im->im_weakreflist = NULL;
    2245         Py_INCREF(func);
    2246         im->im_func = func;
    2247         Py_XINCREF(self);
    2248         im->im_self = self;
    2249         Py_XINCREF(klass);
    2250         im->im_class = klass;
    2251         _PyObject_GC_TRACK(im);
    2252         return (PyObject *)im;
     2255    register PyMethodObject *im;
     2256    im = free_list;
     2257    if (im != NULL) {
     2258        free_list = (PyMethodObject *)(im->im_self);
     2259        PyObject_INIT(im, &PyMethod_Type);
     2260        numfree--;
     2261    }
     2262    else {
     2263        im = PyObject_GC_New(PyMethodObject, &PyMethod_Type);
     2264        if (im == NULL)
     2265            return NULL;
     2266    }
     2267    im->im_weakreflist = NULL;
     2268    Py_INCREF(func);
     2269    im->im_func = func;
     2270    Py_XINCREF(self);
     2271    im->im_self = self;
     2272    Py_XINCREF(klass);
     2273    im->im_class = klass;
     2274    _PyObject_GC_TRACK(im);
     2275    return (PyObject *)im;
    22532276}
    22542277
    … …  
    22602283
    22612284static PyMemberDef instancemethod_memberlist[] = {
    2262         {"im_class",    T_OBJECT,       OFF(im_class),  READONLY|RESTRICTED,
    2263         "the class associated with a method"},
    2264         {"im_func",     T_OBJECT,       OFF(im_func),   READONLY|RESTRICTED,
    2265         "the function (or other callable) implementing a method"},
    2266         {"__func__",    T_OBJECT,       OFF(im_func),   READONLY|RESTRICTED,
    2267         "the function (or other callable) implementing a method"},
    2268         {"im_self",     T_OBJECT,       OFF(im_self),   READONLY|RESTRICTED,
    2269         "the instance to which a method is bound; None for unbound methods"},
    2270         {"__self__",    T_OBJECT,       OFF(im_self),   READONLY|RESTRICTED,
    2271         "the instance to which a method is bound; None for unbound methods"},
    2272         {NULL}  /* Sentinel */
     2285    {"im_class",        T_OBJECT,       OFF(im_class),  READONLY|RESTRICTED,
     2286    "the class associated with a method"},
     2287    {"im_func",         T_OBJECT,       OFF(im_func),   READONLY|RESTRICTED,
     2288    "the function (or other callable) implementing a method"},
     2289    {"__func__",        T_OBJECT,       OFF(im_func),   READONLY|RESTRICTED,
     2290    "the function (or other callable) implementing a method"},
     2291    {"im_self",         T_OBJECT,       OFF(im_self),   READONLY|RESTRICTED,
     2292    "the instance to which a method is bound; None for unbound methods"},
     2293    {"__self__",        T_OBJECT,       OFF(im_self),   READONLY|RESTRICTED,
     2294    "the instance to which a method is bound; None for unbound methods"},
     2295    {NULL}      /* Sentinel */
    22732296};
    22742297
    … …  
    22812304instancemethod_get_doc(PyMethodObject *im, void *context)
    22822305{
    2283         static PyObject *docstr;
    2284         if (docstr == NULL) {
    2285                 docstr= PyString_InternFromString("__doc__");
    2286                 if (docstr == NULL)
    2287                         return NULL;
    2288         }
    2289         return PyObject_GetAttr(im->im_func, docstr);
     2306    static PyObject *docstr;
     2307    if (docstr == NULL) {
     2308        docstr= PyString_InternFromString("__doc__");
     2309        if (docstr == NULL)
     2310            return NULL;
     2311    }
     2312    return PyObject_GetAttr(im->im_func, docstr);
    22902313}
    22912314
    22922315static PyGetSetDef instancemethod_getset[] = {
    2293         {"__doc__", (getter)instancemethod_get_doc, NULL, NULL},
    2294         {0}
     2316    {"__doc__", (getter)instancemethod_get_doc, NULL, NULL},
     2317    {0}
    22952318};
    22962319
    … …  
    22982321instancemethod_getattro(PyObject *obj, PyObject *name)
    22992322{
    2300         PyMethodObject *im = (PyMethodObject *)obj;
    2301         PyTypeObject *tp = obj->ob_type;
    2302         PyObject *descr = NULL;
    2303 
    2304         if (PyType_HasFeature(tp, Py_TPFLAGS_HAVE_CLASS)) {
    2305                 if (tp->tp_dict == NULL) {
    2306                         if (PyType_Ready(tp) < 0)
    2307                                 return NULL;
    2308                 }
    2309                 descr = _PyType_Lookup(tp, name);
    2310         }
    2311 
    2312         if (descr != NULL) {
    2313                 descrgetfunc f = TP_DESCR_GET(descr->ob_type);
    2314                 if (f != NULL)
    2315                         return f(descr, obj, (PyObject *)obj->ob_type);
    2316                 else {
    2317                         Py_INCREF(descr);
    2318                         return descr;
    2319                 }
    2320         }
    2321 
    2322         return PyObject_GetAttr(im->im_func, name);
     2323    PyMethodObject *im = (PyMethodObject *)obj;
     2324    PyTypeObject *tp = obj->ob_type;
     2325    PyObject *descr = NULL;
     2326
     2327    if (PyType_HasFeature(tp, Py_TPFLAGS_HAVE_CLASS)) {
     2328        if (tp->tp_dict == NULL) {
     2329            if (PyType_Ready(tp) < 0)
     2330                return NULL;
     2331        }
     2332        descr = _PyType_Lookup(tp, name);
     2333    }
     2334
     2335    if (descr != NULL) {
     2336        descrgetfunc f = TP_DESCR_GET(descr->ob_type);
     2337        if (f != NULL)
     2338            return f(descr, obj, (PyObject *)obj->ob_type);
     2339        else {
     2340            Py_INCREF(descr);
     2341            return descr;
     2342        }
     2343    }
     2344
     2345    return PyObject_GetAttr(im->im_func, name);
    23232346}
    23242347
    … …  
    23312354instancemethod_new(PyTypeObject* type, PyObject* args, PyObject *kw)
    23322355{
    2333         PyObject *func;
    2334         PyObject *self;
    2335         PyObject *classObj = NULL;
    2336 
    2337         if (!_PyArg_NoKeywords("instancemethod", kw))
    2338                 return NULL;
    2339         if (!PyArg_UnpackTuple(args, "instancemethod", 2, 3,
    2340                               &func, &self, &classObj))
    2341                 return NULL;
    2342         if (!PyCallable_Check(func)) {
    2343                 PyErr_SetString(PyExc_TypeError,
    2344                                 "first argument must be callable");
    2345                 return NULL;
    2346         }
    2347         if (self == Py_None)
    2348                 self = NULL;
    2349         if (self == NULL && classObj == NULL) {
    2350                 PyErr_SetString(PyExc_TypeError,
    2351                         "unbound methods must have non-NULL im_class");
    2352                 return NULL;
    2353         }
    2354 
    2355         return PyMethod_New(func, self, classObj);
     2356    PyObject *func;
     2357    PyObject *self;
     2358    PyObject *classObj = NULL;
     2359
     2360    if (!_PyArg_NoKeywords("instancemethod", kw))
     2361        return NULL;
     2362    if (!PyArg_UnpackTuple(args, "instancemethod", 2, 3,
     2363                          &func, &self, &classObj))
     2364        return NULL;
     2365    if (!PyCallable_Check(func)) {
     2366        PyErr_SetString(PyExc_TypeError,
     2367                        "first argument must be callable");
     2368        return NULL;
     2369    }
     2370    if (self == Py_None)
     2371        self = NULL;
     2372    if (self == NULL && classObj == NULL) {
     2373        PyErr_SetString(PyExc_TypeError,
     2374            "unbound methods must have non-NULL im_class");
     2375        return NULL;
     2376    }
     2377
     2378    return PyMethod_New(func, self, classObj);
    23562379}
    23572380
    … …  
    23592382instancemethod_dealloc(register PyMethodObject *im)
    23602383{
    2361         _PyObject_GC_UNTRACK(im);
    2362         if (im->im_weakreflist != NULL)
    2363                 PyObject_ClearWeakRefs((PyObject *)im);
    2364         Py_DECREF(im->im_func);
    2365         Py_XDECREF(im->im_self);
    2366         Py_XDECREF(im->im_class);
    2367         if (numfree < PyMethod_MAXFREELIST) {
    2368                 im->im_self = (PyObject *)free_list;
    2369                 free_list = im;
    2370                 numfree++;
    2371         }
    2372         else {
    2373                 PyObject_GC_Del(im);
    2374         }
     2384    _PyObject_GC_UNTRACK(im);
     2385    if (im->im_weakreflist != NULL)
     2386        PyObject_ClearWeakRefs((PyObject *)im);
     2387    Py_DECREF(im->im_func);
     2388    Py_XDECREF(im->im_self);
     2389    Py_XDECREF(im->im_class);
     2390    if (numfree < PyMethod_MAXFREELIST) {
     2391        im->im_self = (PyObject *)free_list;
     2392        free_list = im;
     2393        numfree++;
     2394    }
     2395    else {
     2396        PyObject_GC_Del(im);
     2397    }
    23752398}
    23762399
    … …  
    23782401instancemethod_compare(PyMethodObject *a, PyMethodObject *b)
    23792402{
    2380         int cmp;
    2381         cmp = PyObject_Compare(a->im_func, b->im_func);
    2382         if (cmp)
    2383                 return cmp;
    2384 
    2385         if (a->im_self == b->im_self)
    2386                 return 0;
    2387         if (a->im_self == NULL || b->im_self == NULL)
    2388                 return (a->im_self < b->im_self) ? -1 : 1;
    2389         else
    2390                 return PyObject_Compare(a->im_self, b->im_self);
     2403    int cmp;
     2404    cmp = PyObject_Compare(a->im_func, b->im_func);
     2405    if (cmp)
     2406        return cmp;
     2407
     2408    if (a->im_self == b->im_self)
     2409        return 0;
     2410    if (a->im_self == NULL || b->im_self == NULL)
     2411        return (a->im_self < b->im_self) ? -1 : 1;
     2412    else
     2413        return PyObject_Compare(a->im_self, b->im_self);
    23912414}
    23922415
    … …  
    23942417instancemethod_repr(PyMethodObject *a)
    23952418{
    2396         PyObject *self = a->im_self;
    2397         PyObject *func = a->im_func;
    2398         PyObject *klass = a->im_class;
    2399         PyObject *funcname = NULL, *klassname = NULL, *result = NULL;
    2400         char *sfuncname = "?", *sklassname = "?";
    2401 
    2402         funcname = PyObject_GetAttrString(func, "__name__");
    2403         if (funcname == NULL) {
    2404                 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
    2405                         return NULL;
    2406                 PyErr_Clear();
    2407         }
    2408         else if (!PyString_Check(funcname)) {
    2409                 Py_DECREF(funcname);
    2410                 funcname = NULL;
    2411         }
    2412         else
    2413                 sfuncname = PyString_AS_STRING(funcname);
    2414         if (klass == NULL)
    2415                 klassname = NULL;
    2416         else {
    2417                 klassname = PyObject_GetAttrString(klass, "__name__");
    2418                 if (klassname == NULL) {
    2419                         if (!PyErr_ExceptionMatches(PyExc_AttributeError))
    2420                                 return NULL;
    2421                         PyErr_Clear();
    2422                 }
    2423                 else if (!PyString_Check(klassname)) {
    2424                         Py_DECREF(klassname);
    2425                         klassname = NULL;
    2426                 }
    2427                 else
    2428                         sklassname = PyString_AS_STRING(klassname);
    2429         }
    2430         if (self == NULL)
    2431                 result = PyString_FromFormat("<unbound method %s.%s>",
    2432                                              sklassname, sfuncname);
    2433         else {
    2434                 /* XXX Shouldn't use repr() here! */
    2435                 PyObject *selfrepr = PyObject_Repr(self);
    2436                 if (selfrepr == NULL)
    2437                         goto fail;
    2438                 if (!PyString_Check(selfrepr)) {
    2439                         Py_DECREF(selfrepr);
    2440                         goto fail;
    2441                 }
    2442                 result = PyString_FromFormat("<bound method %s.%s of %s>",
    2443                                              sklassname, sfuncname,
    2444                                              PyString_AS_STRING(selfrepr));
    2445                 Py_DECREF(selfrepr);
    2446         }
     2419    PyObject *self = a->im_self;
     2420    PyObject *func = a->im_func;
     2421    PyObject *klass = a->im_class;
     2422    PyObject *funcname = NULL, *klassname = NULL, *result = NULL;
     2423    char *sfuncname = "?", *sklassname = "?";
     2424
     2425    funcname = PyObject_GetAttrString(func, "__name__");
     2426    if (funcname == NULL) {
     2427        if (!PyErr_ExceptionMatches(PyExc_AttributeError))
     2428            return NULL;
     2429        PyErr_Clear();
     2430    }
     2431    else if (!PyString_Check(funcname)) {
     2432        Py_DECREF(funcname);
     2433        funcname = NULL;
     2434    }
     2435    else
     2436        sfuncname = PyString_AS_STRING(funcname);
     2437    if (klass == NULL)
     2438        klassname = NULL;
     2439    else {
     2440        klassname = PyObject_GetAttrString(klass, "__name__");
     2441        if (klassname == NULL) {
     2442            if (!PyErr_ExceptionMatches(PyExc_AttributeError))
     2443                return NULL;
     2444            PyErr_Clear();
     2445        }
     2446        else if (!PyString_Check(klassname)) {
     2447            Py_DECREF(klassname);
     2448            klassname = NULL;
     2449        }
     2450        else
     2451            sklassname = PyString_AS_STRING(klassname);
     2452    }
     2453    if (self == NULL)
     2454        result = PyString_FromFormat("<unbound method %s.%s>",
     2455                                     sklassname, sfuncname);
     2456    else {
     2457        /* XXX Shouldn't use repr() here! */
     2458        PyObject *selfrepr = PyObject_Repr(self);
     2459        if (selfrepr == NULL)
     2460            goto fail;
     2461        if (!PyString_Check(selfrepr)) {
     2462            Py_DECREF(selfrepr);
     2463            goto fail;
     2464        }
     2465        result = PyString_FromFormat("<bound method %s.%s of %s>",
     2466                                     sklassname, sfuncname,
     2467                                     PyString_AS_STRING(selfrepr));
     2468        Py_DECREF(selfrepr);
     2469    }
    24472470  fail:
    2448         Py_XDECREF(funcname);
    2449         Py_XDECREF(klassname);
    2450         return result;
     2471    Py_XDECREF(funcname);
     2472    Py_XDECREF(klassname);
     2473    return result;
    24512474}
    24522475
    … …  
    24542477instancemethod_hash(PyMethodObject *a)
    24552478{
    2456         long x, y;
    2457         if (a->im_self == NULL)
    2458                 x = PyObject_Hash(Py_None);
    2459         else
    2460                 x = PyObject_Hash(a->im_self);
    2461         if (x == -1)
    2462                 return -1;
    2463         y = PyObject_Hash(a->im_func);
    2464         if (y == -1)
    2465                 return -1;
    2466         x = x ^ y;
    2467         if (x == -1)
    2468                 x = -2;
    2469         return x;
     2479    long x, y;
     2480    if (a->im_self == NULL)
     2481        x = PyObject_Hash(Py_None);
     2482    else
     2483        x = PyObject_Hash(a->im_self);
     2484    if (x == -1)
     2485        return -1;
     2486    y = PyObject_Hash(a->im_func);
     2487    if (y == -1)
     2488        return -1;
     2489    x = x ^ y;
     2490    if (x == -1)
     2491        x = -2;
     2492    return x;
    24702493}
    24712494
    … …  
    24732496instancemethod_traverse(PyMethodObject *im, visitproc visit, void *arg)
    24742497{
    2475         Py_VISIT(im->im_func);
    2476         Py_VISIT(im->im_self);
    2477         Py_VISIT(im->im_class);
    2478         return 0;
     2498    Py_VISIT(im->im_func);
     2499    Py_VISIT(im->im_self);
     2500    Py_VISIT(im->im_class);
     2501    return 0;
    24792502}
    24802503
    … …  
    24822505getclassname(PyObject *klass, char *buf, int bufsize)
    24832506{
    2484         PyObject *name;
    2485 
    2486         assert(bufsize > 1);
    2487         strcpy(buf, "?"); /* Default outcome */
    2488         if (klass == NULL)
    2489                 return;
    2490         name = PyObject_GetAttrString(klass, "__name__");
    2491         if (name == NULL) {
    2492                 /* This function cannot return an exception */
    2493                 PyErr_Clear();
    2494                 return;
    2495         }
    2496         if (PyString_Check(name)) {
    2497                 strncpy(buf, PyString_AS_STRING(name), bufsize);
    2498                 buf[bufsize-1] = '\0';
    2499         }
    2500         Py_DECREF(name);
     2507    PyObject *name;
     2508
     2509    assert(bufsize > 1);
     2510    strcpy(buf, "?"); /* Default outcome */
     2511    if (klass == NULL)
     2512        return;
     2513    name = PyObject_GetAttrString(klass, "__name__");
     2514    if (name == NULL) {
     2515        /* This function cannot return an exception */
     2516        PyErr_Clear();
     2517        return;
     2518    }
     2519    if (PyString_Check(name)) {
     2520        strncpy(buf, PyString_AS_STRING(name), bufsize);
     2521        buf[bufsize-1] = '\0';
     2522    }
     2523    Py_DECREF(name);
    25012524}
    25022525
    … …  
    25042527getinstclassname(PyObject *inst, char *buf, int bufsize)
    25052528{
    2506         PyObject *klass;
    2507 
    2508         if (inst == NULL) {
    2509                 assert(bufsize > 0 && (size_t)bufsize > strlen("nothing"));
    2510                 strcpy(buf, "nothing");
    2511                 return;
    2512         }
    2513 
    2514         klass = PyObject_GetAttrString(inst, "__class__");
    2515         if (klass == NULL) {
    2516                 /* This function cannot return an exception */
    2517                 PyErr_Clear();
    2518                 klass = (PyObject *)(inst->ob_type);
    2519                 Py_INCREF(klass);
    2520         }
    2521         getclassname(klass, buf, bufsize);
    2522         Py_XDECREF(klass);
     2529    PyObject *klass;
     2530
     2531    if (inst == NULL) {
     2532        assert(bufsize > 0 && (size_t)bufsize > strlen("nothing"));
     2533        strcpy(buf, "nothing");
     2534        return;
     2535    }
     2536
     2537    klass = PyObject_GetAttrString(inst, "__class__");
     2538    if (klass == NULL) {
     2539        /* This function cannot return an exception */
     2540        PyErr_Clear();
     2541        klass = (PyObject *)(inst->ob_type);
     2542        Py_INCREF(klass);
     2543    }
     2544    getclassname(klass, buf, bufsize);
     2545    Py_XDECREF(klass);
    25232546}
    25242547
    … …  
    25262549instancemethod_call(PyObject *func, PyObject *arg, PyObject *kw)
    25272550{
    2528         PyObject *self = PyMethod_GET_SELF(func);
    2529         PyObject *klass = PyMethod_GET_CLASS(func);
    2530         PyObject *result;
    2531 
    2532         func = PyMethod_GET_FUNCTION(func);
    2533         if (self == NULL) {
    2534                 /* Unbound methods must be called with an instance of
    2535                    the class (or a derived class) as first argument */
    2536                 int ok;
    2537                 if (PyTuple_Size(arg) >= 1)
    2538                         self = PyTuple_GET_ITEM(arg, 0);
    2539                 if (self == NULL)
    2540                         ok = 0;
    2541                 else {
    2542                         ok = PyObject_IsInstance(self, klass);
    2543                         if (ok < 0)
    2544                                 return NULL;
    2545                 }
    2546                 if (!ok) {
    2547                         char clsbuf[256];
    2548                         char instbuf[256];
    2549                         getclassname(klass, clsbuf, sizeof(clsbuf));
    2550                         getinstclassname(self, instbuf, sizeof(instbuf));
    2551                         PyErr_Format(PyExc_TypeError,
    2552                                      "unbound method %s%s must be called with "
    2553                                      "%s instance as first argument "
    2554                                      "(got %s%s instead)",
    2555                                      PyEval_GetFuncName(func),
    2556                                      PyEval_GetFuncDesc(func),
    2557                                      clsbuf,
    2558                                      instbuf,
    2559                                      self == NULL ? "" : " instance");
    2560                         return NULL;
    2561                 }
    2562                 Py_INCREF(arg);
    2563         }
    2564         else {
    2565                 Py_ssize_t argcount = PyTuple_Size(arg);
    2566                 PyObject *newarg = PyTuple_New(argcount + 1);
    2567                 int i;
    2568                 if (newarg == NULL)
    2569                         return NULL;
    2570                 Py_INCREF(self);
    2571                 PyTuple_SET_ITEM(newarg, 0, self);
    2572                 for (i = 0; i < argcount; i++) {
    2573                         PyObject *v = PyTuple_GET_ITEM(arg, i);
    2574                         Py_XINCREF(v);
    2575                         PyTuple_SET_ITEM(newarg, i+1, v);
    2576                 }
    2577                 arg = newarg;
    2578         }
    2579         result = PyObject_Call((PyObject *)func, arg, kw);
    2580         Py_DECREF(arg);
    2581         return result;
     2551    PyObject *self = PyMethod_GET_SELF(func);
     2552    PyObject *klass = PyMethod_GET_CLASS(func);
     2553    PyObject *result;
     2554
     2555    func = PyMethod_GET_FUNCTION(func);
     2556    if (self == NULL) {
     2557        /* Unbound methods must be called with an instance of
     2558           the class (or a derived class) as first argument */
     2559        int ok;
     2560        if (PyTuple_Size(arg) >= 1)
     2561            self = PyTuple_GET_ITEM(arg, 0);
     2562        if (self == NULL)
     2563            ok = 0;
     2564        else {
     2565            ok = PyObject_IsInstance(self, klass);
     2566            if (ok < 0)
     2567                return NULL;
     2568        }
     2569        if (!ok) {
     2570            char clsbuf[256];
     2571            char instbuf[256];
     2572            getclassname(klass, clsbuf, sizeof(clsbuf));
     2573            getinstclassname(self, instbuf, sizeof(instbuf));
     2574            PyErr_Format(PyExc_TypeError,
     2575                         "unbound method %s%s must be called with "
     2576                         "%s instance as first argument "
     2577                         "(got %s%s instead)",
     2578                         PyEval_GetFuncName(func),
     2579                         PyEval_GetFuncDesc(func),
     2580                         clsbuf,
     2581                         instbuf,
     2582                         self == NULL ? "" : " instance");
     2583            return NULL;
     2584        }
     2585        Py_INCREF(arg);
     2586    }
     2587    else {
     2588        Py_ssize_t argcount = PyTuple_Size(arg);
     2589        PyObject *newarg = PyTuple_New(argcount + 1);
     2590        int i;
     2591        if (newarg == NULL)
     2592            return NULL;
     2593        Py_INCREF(self);
     2594        PyTuple_SET_ITEM(newarg, 0, self);
     2595        for (i = 0; i < argcount; i++) {
     2596            PyObject *v = PyTuple_GET_ITEM(arg, i);
     2597            Py_XINCREF(v);
     2598            PyTuple_SET_ITEM(newarg, i+1, v);
     2599        }
     2600        arg = newarg;
     2601    }
     2602    result = PyObject_Call((PyObject *)func, arg, kw);
     2603    Py_DECREF(arg);
     2604    return result;
    25822605}
    25832606
    … …  
    25852608instancemethod_descr_get(PyObject *meth, PyObject *obj, PyObject *cls)
    25862609{
    2587         /* Don't rebind an already bound method, or an unbound method
    2588            of a class that's not a base class of cls. */
    2589 
    2590         if (PyMethod_GET_SELF(meth) != NULL) {
    2591                 /* Already bound */
    2592                 Py_INCREF(meth);
    2593                 return meth;
    2594         }
    2595         /* No, it is an unbound method */
    2596         if (PyMethod_GET_CLASS(meth) != NULL && cls != NULL) {
    2597                 /* Do subclass test.  If it fails, return meth unchanged. */
    2598                 int ok = PyObject_IsSubclass(cls, PyMethod_GET_CLASS(meth));
    2599                 if (ok < 0)
    2600                         return NULL;
    2601                 if (!ok) {
    2602                         Py_INCREF(meth);
    2603                         return meth;
    2604                 }
    2605         }
    2606         /* Bind it to obj */
    2607         return PyMethod_New(PyMethod_GET_FUNCTION(meth), obj, cls);
     2610    /* Don't rebind an already bound method, or an unbound method
     2611       of a class that's not a base class of cls. */
     2612
     2613    if (PyMethod_GET_SELF(meth) != NULL) {
     2614        /* Already bound */
     2615        Py_INCREF(meth);
     2616        return meth;
     2617    }
     2618    /* No, it is an unbound method */
     2619    if (PyMethod_GET_CLASS(meth) != NULL && cls != NULL) {
     2620        /* Do subclass test.  If it fails, return meth unchanged. */
     2621        int ok = PyObject_IsSubclass(cls, PyMethod_GET_CLASS(meth));
     2622        if (ok < 0)
     2623            return NULL;
     2624        if (!ok) {
     2625            Py_INCREF(meth);
     2626            return meth;
     2627        }
     2628    }
     2629    /* Bind it to obj */
     2630    return PyMethod_New(PyMethod_GET_FUNCTION(meth), obj, cls);
    26082631}
    26092632
    26102633PyTypeObject PyMethod_Type = {
    2611         PyObject_HEAD_INIT(&PyType_Type)
    2612         0,
    2613         "instancemethod",
    2614         sizeof(PyMethodObject),
    2615         0,
    2616         (destructor)instancemethod_dealloc,     /* tp_dealloc */
    2617         0,                                      /* tp_print */
    2618         0,                                      /* tp_getattr */
    2619         0,                                      /* tp_setattr */
    2620         (cmpfunc)instancemethod_compare,        /* tp_compare */
    2621         (reprfunc)instancemethod_repr,          /* tp_repr */
    2622         0,                                      /* tp_as_number */
    2623         0,                                      /* tp_as_sequence */
    2624         0,                                      /* tp_as_mapping */
    2625         (hashfunc)instancemethod_hash,          /* tp_hash */
    2626         instancemethod_call,                    /* tp_call */
    2627         0,                                      /* tp_str */
    2628         instancemethod_getattro,                /* tp_getattro */
    2629         PyObject_GenericSetAttr,                /* tp_setattro */
    2630         0,                                      /* tp_as_buffer */
    2631         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC  | Py_TPFLAGS_HAVE_WEAKREFS, /* tp_flags */
    2632         instancemethod_doc,                     /* tp_doc */
    2633         (traverseproc)instancemethod_traverse,  /* tp_traverse */
    2634         0,                                      /* tp_clear */
    2635         0,                                      /* tp_richcompare */
    2636         offsetof(PyMethodObject, im_weakreflist), /* tp_weaklistoffset */
    2637         0,                                      /* tp_iter */
    2638         0,                                      /* tp_iternext */
    2639         0,                                      /* tp_methods */
    2640         instancemethod_memberlist,              /* tp_members */
    2641         instancemethod_getset,                  /* tp_getset */
    2642         0,                                      /* tp_base */
    2643         0,                                      /* tp_dict */
    2644         instancemethod_descr_get,               /* tp_descr_get */
    2645         0,                                      /* tp_descr_set */
    2646         0,                                      /* tp_dictoffset */
    2647         0,                                      /* tp_init */
    2648         0,                                      /* tp_alloc */
    2649         instancemethod_new,                     /* tp_new */
     2634    PyObject_HEAD_INIT(&PyType_Type)
     2635    0,
     2636    "instancemethod",
     2637    sizeof(PyMethodObject),
     2638    0,
     2639    (destructor)instancemethod_dealloc,         /* tp_dealloc */
     2640    0,                                          /* tp_print */
     2641    0,                                          /* tp_getattr */
     2642    0,                                          /* tp_setattr */
     2643    (cmpfunc)instancemethod_compare,            /* tp_compare */
     2644    (reprfunc)instancemethod_repr,              /* tp_repr */
     2645    0,                                          /* tp_as_number */
     2646    0,                                          /* tp_as_sequence */
     2647    0,                                          /* tp_as_mapping */
     2648    (hashfunc)instancemethod_hash,              /* tp_hash */
     2649    instancemethod_call,                        /* tp_call */
     2650    0,                                          /* tp_str */
     2651    instancemethod_getattro,                    /* tp_getattro */
     2652    PyObject_GenericSetAttr,                    /* tp_setattro */
     2653    0,                                          /* tp_as_buffer */
     2654    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC  | Py_TPFLAGS_HAVE_WEAKREFS, /* tp_flags */
     2655    instancemethod_doc,                         /* tp_doc */
     2656    (traverseproc)instancemethod_traverse,      /* tp_traverse */
     2657    0,                                          /* tp_clear */
     2658    0,                                          /* tp_richcompare */
     2659    offsetof(PyMethodObject, im_weakreflist), /* tp_weaklistoffset */
     2660    0,                                          /* tp_iter */
     2661    0,                                          /* tp_iternext */
     2662    0,                                          /* tp_methods */
     2663    instancemethod_memberlist,                  /* tp_members */
     2664    instancemethod_getset,                      /* tp_getset */
     2665    0,                                          /* tp_base */
     2666    0,                                          /* tp_dict */
     2667    instancemethod_descr_get,                   /* tp_descr_get */
     2668    0,                                          /* tp_descr_set */
     2669    0,                                          /* tp_dictoffset */
     2670    0,                                          /* tp_init */
     2671    0,                                          /* tp_alloc */
     2672    instancemethod_new,                         /* tp_new */
    26502673};
    26512674
    … …  
    26552678PyMethod_ClearFreeList(void)
    26562679{
    2657         int freelist_size = numfree;
    2658        
    2659         while (free_list) {
    2660                 PyMethodObject *im = free_list;
    2661                 free_list = (PyMethodObject *)(im->im_self);
    2662                 PyObject_GC_Del(im);
    2663                 numfree--;
    2664         }
    2665         assert(numfree == 0);
    2666         return freelist_size;
     2680    int freelist_size = numfree;
     2681
     2682    while (free_list) {
     2683        PyMethodObject *im = free_list;
     2684        free_list = (PyMethodObject *)(im->im_self);
     2685        PyObject_GC_Del(im);
     2686        numfree--;
     2687    }
     2688    assert(numfree == 0);
     2689    return freelist_size;
    26672690}
    26682691
    … …  
    26702693PyMethod_Fini(void)
    26712694{
    2672         (void)PyMethod_ClearFreeList();
    2673 }
     2695    (void)PyMethod_ClearFreeList();
     2696}
Note: See TracChangeset for help on using the changeset viewer.