LCOV - code coverage report
Current view: top level - Objects - typeobject.c (source / functions) Hit Total Coverage
Test: CPython lcov report Lines: 1302 3073 42.4 %
Date: 2017-04-19 Functions: 82 220 37.3 %

          Line data    Source code
       1             : /* Type object implementation */
       2             : 
       3             : #include "Python.h"
       4             : #include "structmember.h"
       5             : 
       6             : #include <ctype.h>
       7             : 
       8             : 
       9             : /* Support type attribute cache */
      10             : 
      11             : /* The cache can keep references to the names alive for longer than
      12             :    they normally would.  This is why the maximum size is limited to
      13             :    MCACHE_MAX_ATTR_SIZE, since it might be a problem if very large
      14             :    strings are used as attribute names. */
      15             : #define MCACHE_MAX_ATTR_SIZE    100
      16             : #define MCACHE_SIZE_EXP         12
      17             : #define MCACHE_HASH(version, name_hash)                                 \
      18             :         (((unsigned int)(version) ^ (unsigned int)(name_hash))          \
      19             :          & ((1 << MCACHE_SIZE_EXP) - 1))
      20             : 
      21             : #define MCACHE_HASH_METHOD(type, name)                                  \
      22             :         MCACHE_HASH((type)->tp_version_tag,                     \
      23             :                     ((PyStringObject *)(name))->ob_shash)
      24             : #define MCACHE_CACHEABLE_NAME(name)                                     \
      25             :         PyString_CheckExact(name) &&                            \
      26             :         PyString_GET_SIZE(name) <= MCACHE_MAX_ATTR_SIZE
      27             : 
      28             : struct method_cache_entry {
      29             :     unsigned int version;
      30             :     PyObject *name;             /* reference to exactly a str or None */
      31             :     PyObject *value;            /* borrowed */
      32             : };
      33             : 
      34             : static struct method_cache_entry method_cache[1 << MCACHE_SIZE_EXP];
      35             : static unsigned int next_version_tag = 0;
      36             : 
      37             : #define MCACHE_STATS 0
      38             : 
      39             : #if MCACHE_STATS
      40             : static size_t method_cache_hits = 0;
      41             : static size_t method_cache_misses = 0;
      42             : static size_t method_cache_collisions = 0;
      43             : #endif
      44             : 
      45             : unsigned int
      46           3 : PyType_ClearCache(void)
      47             : {
      48             :     Py_ssize_t i;
      49           3 :     unsigned int cur_version_tag = next_version_tag - 1;
      50             : 
      51             : #if MCACHE_STATS
      52             :     size_t total = method_cache_hits + method_cache_collisions + method_cache_misses;
      53             :     fprintf(stderr, "-- Method cache hits        = %zd (%d%%)\n",
      54             :             method_cache_hits, (int) (100.0 * method_cache_hits / total));
      55             :     fprintf(stderr, "-- Method cache true misses = %zd (%d%%)\n",
      56             :             method_cache_misses, (int) (100.0 * method_cache_misses / total));
      57             :     fprintf(stderr, "-- Method cache collisions  = %zd (%d%%)\n",
      58             :             method_cache_collisions, (int) (100.0 * method_cache_collisions / total));
      59             :     fprintf(stderr, "-- Method cache size        = %zd KB\n",
      60             :             sizeof(method_cache) / 1024);
      61             : #endif
      62             : 
      63       12291 :     for (i = 0; i < (1 << MCACHE_SIZE_EXP); i++) {
      64       12288 :         method_cache[i].version = 0;
      65       12288 :         Py_CLEAR(method_cache[i].name);
      66       12288 :         method_cache[i].value = NULL;
      67             :     }
      68           3 :     next_version_tag = 0;
      69             :     /* mark all version tags as invalid */
      70           3 :     PyType_Modified(&PyBaseObject_Type);
      71           3 :     return cur_version_tag;
      72             : }
      73             : 
      74             : void
      75        3813 : PyType_Modified(PyTypeObject *type)
      76             : {
      77             :     /* Invalidate any cached data for the specified type and all
      78             :        subclasses.  This function is called after the base
      79             :        classes, mro, or attributes of the type are altered.
      80             : 
      81             :        Invariants:
      82             : 
      83             :        - Py_TPFLAGS_VALID_VERSION_TAG is never set if
      84             :          Py_TPFLAGS_HAVE_VERSION_TAG is not set (e.g. on type
      85             :          objects coming from non-recompiled extension modules)
      86             : 
      87             :        - before Py_TPFLAGS_VALID_VERSION_TAG can be set on a type,
      88             :          it must first be set on all super types.
      89             : 
      90             :        This function clears the Py_TPFLAGS_VALID_VERSION_TAG of a
      91             :        type (so it must first clear it on all subclasses).  The
      92             :        tp_version_tag value is meaningless unless this flag is set.
      93             :        We don't assign new version tags eagerly, but only as
      94             :        needed.
      95             :      */
      96             :     PyObject *raw, *ref;
      97             :     Py_ssize_t i, n;
      98             : 
      99        3813 :     if (!PyType_HasFeature(type, Py_TPFLAGS_VALID_VERSION_TAG))
     100        5943 :         return;
     101             : 
     102        1683 :     raw = type->tp_subclasses;
     103        1683 :     if (raw != NULL) {
     104         174 :         n = PyList_GET_SIZE(raw);
     105        1395 :         for (i = 0; i < n; i++) {
     106        1221 :             ref = PyList_GET_ITEM(raw, i);
     107        1221 :             ref = PyWeakref_GET_OBJECT(ref);
     108        1221 :             if (ref != Py_None) {
     109        1221 :                 PyType_Modified((PyTypeObject *)ref);
     110             :             }
     111             :         }
     112             :     }
     113        1683 :     type->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
     114             : }
     115             : 
     116             : static void
     117        2592 : type_mro_modified(PyTypeObject *type, PyObject *bases) {
     118             :     /*
     119             :        Check that all base classes or elements of the mro of type are
     120             :        able to be cached.  This function is called after the base
     121             :        classes or mro of the type are altered.
     122             : 
     123             :        Unset HAVE_VERSION_TAG and VALID_VERSION_TAG if the type
     124             :        inherits from an old-style class, either directly or if it
     125             :        appears in the MRO of a new-style class.  No support either for
     126             :        custom MROs that include types that are not officially super
     127             :        types.
     128             : 
     129             :        Called from mro_internal, which will subsequently be called on
     130             :        each subclass when their mro is recursively updated.
     131             :      */
     132             :     Py_ssize_t i, n;
     133        2592 :     int clear = 0;
     134             : 
     135        2592 :     if (!PyType_HasFeature(type, Py_TPFLAGS_HAVE_VERSION_TAG))
     136        2925 :         return;
     137             : 
     138        2259 :     n = PyTuple_GET_SIZE(bases);
     139        7422 :     for (i = 0; i < n; i++) {
     140        5184 :         PyObject *b = PyTuple_GET_ITEM(bases, i);
     141             :         PyTypeObject *cls;
     142             : 
     143        5184 :         if (!PyType_Check(b) ) {
     144           0 :             clear = 1;
     145           0 :             break;
     146             :         }
     147             : 
     148        5184 :         cls = (PyTypeObject *)b;
     149             : 
     150       10347 :         if (!PyType_HasFeature(cls, Py_TPFLAGS_HAVE_VERSION_TAG) ||
     151        5163 :             !PyType_IsSubtype(type, cls)) {
     152          21 :             clear = 1;
     153          21 :             break;
     154             :         }
     155             :     }
     156             : 
     157        2259 :     if (clear)
     158          21 :         type->tp_flags &= ~(Py_TPFLAGS_HAVE_VERSION_TAG|
     159             :                             Py_TPFLAGS_VALID_VERSION_TAG);
     160             : }
     161             : 
     162             : static int
     163       78585 : assign_version_tag(PyTypeObject *type)
     164             : {
     165             :     /* Ensure that the tp_version_tag is valid and set
     166             :        Py_TPFLAGS_VALID_VERSION_TAG.  To respect the invariant, this
     167             :        must first be done on all super classes.  Return 0 if this
     168             :        cannot be done, 1 if Py_TPFLAGS_VALID_VERSION_TAG.
     169             :     */
     170             :     Py_ssize_t i, n;
     171             :     PyObject *bases;
     172             : 
     173       78585 :     if (PyType_HasFeature(type, Py_TPFLAGS_VALID_VERSION_TAG))
     174       74517 :         return 1;
     175        4068 :     if (!PyType_HasFeature(type, Py_TPFLAGS_HAVE_VERSION_TAG))
     176        2370 :         return 0;
     177        1698 :     if (!PyType_HasFeature(type, Py_TPFLAGS_READY))
     178           0 :         return 0;
     179             : 
     180        1698 :     type->tp_version_tag = next_version_tag++;
     181             :     /* for stress-testing: next_version_tag &= 0xFF; */
     182             : 
     183        1698 :     if (type->tp_version_tag == 0) {
     184             :         /* wrap-around or just starting Python - clear the whole
     185             :            cache by filling names with references to Py_None.
     186             :            Values are also set to NULL for added protection, as they
     187             :            are borrowed reference */
     188       24582 :         for (i = 0; i < (1 << MCACHE_SIZE_EXP); i++) {
     189       24576 :             method_cache[i].value = NULL;
     190       24576 :             Py_INCREF(Py_None);
     191       24576 :             Py_XSETREF(method_cache[i].name, Py_None);
     192             :         }
     193             :         /* mark all version tags as invalid */
     194           6 :         PyType_Modified(&PyBaseObject_Type);
     195           6 :         return 1;
     196             :     }
     197        1692 :     bases = type->tp_bases;
     198        1692 :     n = PyTuple_GET_SIZE(bases);
     199        3456 :     for (i = 0; i < n; i++) {
     200        1764 :         PyObject *b = PyTuple_GET_ITEM(bases, i);
     201             :         assert(PyType_Check(b));
     202        1764 :         if (!assign_version_tag((PyTypeObject *)b))
     203           0 :             return 0;
     204             :     }
     205        1692 :     type->tp_flags |= Py_TPFLAGS_VALID_VERSION_TAG;
     206        1692 :     return 1;
     207             : }
     208             : 
     209             : 
     210             : static PyMemberDef type_members[] = {
     211             :     {"__basicsize__", T_PYSSIZET, offsetof(PyTypeObject,tp_basicsize),READONLY},
     212             :     {"__itemsize__", T_PYSSIZET, offsetof(PyTypeObject, tp_itemsize), READONLY},
     213             :     {"__flags__", T_LONG, offsetof(PyTypeObject, tp_flags), READONLY},
     214             :     {"__weakrefoffset__", T_LONG,
     215             :      offsetof(PyTypeObject, tp_weaklistoffset), READONLY},
     216             :     {"__base__", T_OBJECT, offsetof(PyTypeObject, tp_base), READONLY},
     217             :     {"__dictoffset__", T_LONG,
     218             :      offsetof(PyTypeObject, tp_dictoffset), READONLY},
     219             :     {"__mro__", T_OBJECT, offsetof(PyTypeObject, tp_mro), READONLY},
     220             :     {0}
     221             : };
     222             : 
     223             : static PyObject *
     224           0 : type_name(PyTypeObject *type, void *context)
     225             : {
     226             :     const char *s;
     227             : 
     228           0 :     if (type->tp_flags & Py_TPFLAGS_HEAPTYPE) {
     229           0 :         PyHeapTypeObject* et = (PyHeapTypeObject*)type;
     230             : 
     231           0 :         Py_INCREF(et->ht_name);
     232           0 :         return et->ht_name;
     233             :     }
     234             :     else {
     235           0 :         s = strrchr(type->tp_name, '.');
     236           0 :         if (s == NULL)
     237           0 :             s = type->tp_name;
     238             :         else
     239           0 :             s++;
     240           0 :         return PyString_FromString(s);
     241             :     }
     242             : }
     243             : 
     244             : static int
     245           0 : type_set_name(PyTypeObject *type, PyObject *value, void *context)
     246             : {
     247             :     PyHeapTypeObject* et;
     248             :     PyObject *tmp;
     249             : 
     250           0 :     if (!(type->tp_flags & Py_TPFLAGS_HEAPTYPE)) {
     251           0 :         PyErr_Format(PyExc_TypeError,
     252             :                      "can't set %s.__name__", type->tp_name);
     253           0 :         return -1;
     254             :     }
     255           0 :     if (!value) {
     256           0 :         PyErr_Format(PyExc_TypeError,
     257             :                      "can't delete %s.__name__", type->tp_name);
     258           0 :         return -1;
     259             :     }
     260           0 :     if (!PyString_Check(value)) {
     261           0 :         PyErr_Format(PyExc_TypeError,
     262             :                      "can only assign string to %s.__name__, not '%s'",
     263           0 :                      type->tp_name, Py_TYPE(value)->tp_name);
     264           0 :         return -1;
     265             :     }
     266           0 :     if (strlen(PyString_AS_STRING(value))
     267           0 :         != (size_t)PyString_GET_SIZE(value)) {
     268           0 :         PyErr_SetString(PyExc_ValueError,
     269             :                         "type name must not contain null characters");
     270           0 :         return -1;
     271             :     }
     272             : 
     273           0 :     et = (PyHeapTypeObject*)type;
     274             : 
     275           0 :     Py_INCREF(value);
     276             : 
     277             :     /* Wait until et is a sane state before Py_DECREF'ing the old et->ht_name
     278             :        value.  (Bug #16447.)  */
     279           0 :     tmp = et->ht_name;
     280           0 :     et->ht_name = value;
     281             : 
     282           0 :     type->tp_name = PyString_AS_STRING(value);
     283           0 :     Py_DECREF(tmp);
     284             : 
     285           0 :     return 0;
     286             : }
     287             : 
     288             : static PyObject *
     289           0 : type_module(PyTypeObject *type, void *context)
     290             : {
     291             :     PyObject *mod;
     292             :     char *s;
     293             : 
     294           0 :     if (type->tp_flags & Py_TPFLAGS_HEAPTYPE) {
     295           0 :         mod = PyDict_GetItemString(type->tp_dict, "__module__");
     296           0 :         if (!mod) {
     297           0 :             PyErr_Format(PyExc_AttributeError, "__module__");
     298           0 :             return 0;
     299             :         }
     300           0 :         Py_XINCREF(mod);
     301           0 :         return mod;
     302             :     }
     303             :     else {
     304           0 :         s = strrchr(type->tp_name, '.');
     305           0 :         if (s != NULL)
     306           0 :             return PyString_FromStringAndSize(
     307           0 :                 type->tp_name, (Py_ssize_t)(s - type->tp_name));
     308           0 :         return PyString_FromString("__builtin__");
     309             :     }
     310             : }
     311             : 
     312             : static int
     313          27 : type_set_module(PyTypeObject *type, PyObject *value, void *context)
     314             : {
     315          27 :     if (!(type->tp_flags & Py_TPFLAGS_HEAPTYPE)) {
     316           0 :         PyErr_Format(PyExc_TypeError,
     317             :                      "can't set %s.__module__", type->tp_name);
     318           0 :         return -1;
     319             :     }
     320          27 :     if (!value) {
     321           0 :         PyErr_Format(PyExc_TypeError,
     322             :                      "can't delete %s.__module__", type->tp_name);
     323           0 :         return -1;
     324             :     }
     325             : 
     326          27 :     PyType_Modified(type);
     327             : 
     328          27 :     return PyDict_SetItemString(type->tp_dict, "__module__", value);
     329             : }
     330             : 
     331             : static PyObject *
     332          78 : type_abstractmethods(PyTypeObject *type, void *context)
     333             : {
     334          78 :     PyObject *mod = NULL;
     335             :     /* type itself has an __abstractmethods__ descriptor (this). Don't return
     336             :        that. */
     337          78 :     if (type != &PyType_Type)
     338          78 :         mod = PyDict_GetItemString(type->tp_dict, "__abstractmethods__");
     339          78 :     if (!mod) {
     340          12 :         PyErr_SetString(PyExc_AttributeError, "__abstractmethods__");
     341          12 :         return NULL;
     342             :     }
     343          66 :     Py_XINCREF(mod);
     344          66 :     return mod;
     345             : }
     346             : 
     347             : static int
     348          60 : type_set_abstractmethods(PyTypeObject *type, PyObject *value, void *context)
     349             : {
     350             :     /* __abstractmethods__ should only be set once on a type, in
     351             :        abc.ABCMeta.__new__, so this function doesn't do anything
     352             :        special to update subclasses.
     353             :     */
     354             :     int abstract, res;
     355          60 :     if (value != NULL) {
     356          60 :         abstract = PyObject_IsTrue(value);
     357          60 :         if (abstract < 0)
     358           0 :             return -1;
     359          60 :         res = PyDict_SetItemString(type->tp_dict, "__abstractmethods__", value);
     360             :     }
     361             :     else {
     362           0 :         abstract = 0;
     363           0 :         res = PyDict_DelItemString(type->tp_dict, "__abstractmethods__");
     364           0 :         if (res && PyErr_ExceptionMatches(PyExc_KeyError)) {
     365           0 :             PyErr_SetString(PyExc_AttributeError, "__abstractmethods__");
     366           0 :             return -1;
     367             :         }
     368             :     }
     369          60 :     if (res == 0) {
     370          60 :         PyType_Modified(type);
     371          60 :         if (abstract)
     372          36 :             type->tp_flags |= Py_TPFLAGS_IS_ABSTRACT;
     373             :         else
     374          24 :             type->tp_flags &= ~Py_TPFLAGS_IS_ABSTRACT;
     375             :     }
     376          60 :     return res;
     377             : }
     378             : 
     379             : static PyObject *
     380          30 : type_get_bases(PyTypeObject *type, void *context)
     381             : {
     382          30 :     Py_INCREF(type->tp_bases);
     383          30 :     return type->tp_bases;
     384             : }
     385             : 
     386             : static PyTypeObject *best_base(PyObject *);
     387             : static int mro_internal(PyTypeObject *);
     388             : static int compatible_for_assignment(PyTypeObject *, PyTypeObject *, char *);
     389             : static int add_subclass(PyTypeObject*, PyTypeObject*);
     390             : static void remove_subclass(PyTypeObject *, PyTypeObject *);
     391             : static void update_all_slots(PyTypeObject *);
     392             : 
     393             : typedef int (*update_callback)(PyTypeObject *, void *);
     394             : static int update_subclasses(PyTypeObject *type, PyObject *name,
     395             :                              update_callback callback, void *data);
     396             : static int recurse_down_subclasses(PyTypeObject *type, PyObject *name,
     397             :                                    update_callback callback, void *data);
     398             : 
     399             : static int
     400           0 : mro_subclasses(PyTypeObject *type, PyObject* temp)
     401             : {
     402             :     PyTypeObject *subclass;
     403             :     PyObject *ref, *subclasses, *old_mro;
     404             :     Py_ssize_t i, n;
     405             : 
     406           0 :     subclasses = type->tp_subclasses;
     407           0 :     if (subclasses == NULL)
     408           0 :         return 0;
     409             :     assert(PyList_Check(subclasses));
     410           0 :     n = PyList_GET_SIZE(subclasses);
     411           0 :     for (i = 0; i < n; i++) {
     412           0 :         ref = PyList_GET_ITEM(subclasses, i);
     413             :         assert(PyWeakref_CheckRef(ref));
     414           0 :         subclass = (PyTypeObject *)PyWeakref_GET_OBJECT(ref);
     415             :         assert(subclass != NULL);
     416           0 :         if ((PyObject *)subclass == Py_None)
     417           0 :             continue;
     418             :         assert(PyType_Check(subclass));
     419           0 :         old_mro = subclass->tp_mro;
     420           0 :         if (mro_internal(subclass) < 0) {
     421           0 :             subclass->tp_mro = old_mro;
     422           0 :             return -1;
     423             :         }
     424             :         else {
     425             :             PyObject* tuple;
     426           0 :             tuple = PyTuple_Pack(2, subclass, old_mro);
     427           0 :             Py_DECREF(old_mro);
     428           0 :             if (!tuple)
     429           0 :                 return -1;
     430           0 :             if (PyList_Append(temp, tuple) < 0)
     431           0 :                 return -1;
     432           0 :             Py_DECREF(tuple);
     433             :         }
     434           0 :         if (mro_subclasses(subclass, temp) < 0)
     435           0 :             return -1;
     436             :     }
     437           0 :     return 0;
     438             : }
     439             : 
     440             : static int
     441           0 : type_set_bases(PyTypeObject *type, PyObject *value, void *context)
     442             : {
     443             :     Py_ssize_t i;
     444           0 :     int r = 0;
     445             :     PyObject *ob, *temp;
     446             :     PyTypeObject *new_base, *old_base;
     447             :     PyObject *old_bases, *old_mro;
     448             : 
     449           0 :     if (!(type->tp_flags & Py_TPFLAGS_HEAPTYPE)) {
     450           0 :         PyErr_Format(PyExc_TypeError,
     451             :                      "can't set %s.__bases__", type->tp_name);
     452           0 :         return -1;
     453             :     }
     454           0 :     if (!value) {
     455           0 :         PyErr_Format(PyExc_TypeError,
     456             :                      "can't delete %s.__bases__", type->tp_name);
     457           0 :         return -1;
     458             :     }
     459           0 :     if (!PyTuple_Check(value)) {
     460           0 :         PyErr_Format(PyExc_TypeError,
     461             :              "can only assign tuple to %s.__bases__, not %s",
     462           0 :                  type->tp_name, Py_TYPE(value)->tp_name);
     463           0 :         return -1;
     464             :     }
     465           0 :     if (PyTuple_GET_SIZE(value) == 0) {
     466           0 :         PyErr_Format(PyExc_TypeError,
     467             :              "can only assign non-empty tuple to %s.__bases__, not ()",
     468             :                  type->tp_name);
     469           0 :         return -1;
     470             :     }
     471           0 :     for (i = 0; i < PyTuple_GET_SIZE(value); i++) {
     472           0 :         ob = PyTuple_GET_ITEM(value, i);
     473           0 :         if (!PyClass_Check(ob) && !PyType_Check(ob)) {
     474           0 :             PyErr_Format(
     475             :                 PyExc_TypeError,
     476             :     "%s.__bases__ must be tuple of old- or new-style classes, not '%s'",
     477           0 :                             type->tp_name, Py_TYPE(ob)->tp_name);
     478           0 :                     return -1;
     479             :         }
     480           0 :         if (PyType_Check(ob)) {
     481           0 :             if (PyType_IsSubtype((PyTypeObject*)ob, type)) {
     482           0 :                 PyErr_SetString(PyExc_TypeError,
     483             :             "a __bases__ item causes an inheritance cycle");
     484           0 :                 return -1;
     485             :             }
     486             :         }
     487             :     }
     488             : 
     489           0 :     new_base = best_base(value);
     490             : 
     491           0 :     if (!new_base) {
     492           0 :         return -1;
     493             :     }
     494             : 
     495           0 :     if (!compatible_for_assignment(type->tp_base, new_base, "__bases__"))
     496           0 :         return -1;
     497             : 
     498           0 :     Py_INCREF(new_base);
     499           0 :     Py_INCREF(value);
     500             : 
     501           0 :     old_bases = type->tp_bases;
     502           0 :     old_base = type->tp_base;
     503           0 :     old_mro = type->tp_mro;
     504             : 
     505           0 :     type->tp_bases = value;
     506           0 :     type->tp_base = new_base;
     507             : 
     508           0 :     if (mro_internal(type) < 0) {
     509           0 :         goto bail;
     510             :     }
     511             : 
     512           0 :     temp = PyList_New(0);
     513           0 :     if (!temp)
     514           0 :         goto bail;
     515             : 
     516           0 :     r = mro_subclasses(type, temp);
     517             : 
     518           0 :     if (r < 0) {
     519           0 :         for (i = 0; i < PyList_Size(temp); i++) {
     520             :             PyTypeObject* cls;
     521             :             PyObject* mro;
     522           0 :             PyArg_UnpackTuple(PyList_GET_ITEM(temp, i),
     523             :                              "", 2, 2, &cls, &mro);
     524           0 :             Py_INCREF(mro);
     525           0 :             ob = cls->tp_mro;
     526           0 :             cls->tp_mro = mro;
     527           0 :             Py_DECREF(ob);
     528             :         }
     529           0 :         Py_DECREF(temp);
     530           0 :         goto bail;
     531             :     }
     532             : 
     533           0 :     Py_DECREF(temp);
     534             : 
     535             :     /* any base that was in __bases__ but now isn't, we
     536             :        need to remove |type| from its tp_subclasses.
     537             :        conversely, any class now in __bases__ that wasn't
     538             :        needs to have |type| added to its subclasses. */
     539             : 
     540             :     /* for now, sod that: just remove from all old_bases,
     541             :        add to all new_bases */
     542             : 
     543           0 :     for (i = PyTuple_GET_SIZE(old_bases) - 1; i >= 0; i--) {
     544           0 :         ob = PyTuple_GET_ITEM(old_bases, i);
     545           0 :         if (PyType_Check(ob)) {
     546           0 :             remove_subclass(
     547             :                 (PyTypeObject*)ob, type);
     548             :         }
     549             :     }
     550             : 
     551           0 :     for (i = PyTuple_GET_SIZE(value) - 1; i >= 0; i--) {
     552           0 :         ob = PyTuple_GET_ITEM(value, i);
     553           0 :         if (PyType_Check(ob)) {
     554           0 :             if (add_subclass((PyTypeObject*)ob, type) < 0)
     555           0 :                 r = -1;
     556             :         }
     557             :     }
     558             : 
     559           0 :     update_all_slots(type);
     560             : 
     561           0 :     Py_DECREF(old_bases);
     562           0 :     Py_DECREF(old_base);
     563           0 :     Py_DECREF(old_mro);
     564             : 
     565           0 :     return r;
     566             : 
     567             :   bail:
     568           0 :     Py_DECREF(type->tp_bases);
     569           0 :     Py_DECREF(type->tp_base);
     570           0 :     if (type->tp_mro != old_mro) {
     571           0 :         Py_DECREF(type->tp_mro);
     572             :     }
     573             : 
     574           0 :     type->tp_bases = old_bases;
     575           0 :     type->tp_base = old_base;
     576           0 :     type->tp_mro = old_mro;
     577             : 
     578           0 :     return -1;
     579             : }
     580             : 
     581             : static PyObject *
     582          12 : type_dict(PyTypeObject *type, void *context)
     583             : {
     584          12 :     if (type->tp_dict == NULL) {
     585           0 :         Py_INCREF(Py_None);
     586           0 :         return Py_None;
     587             :     }
     588          12 :     return PyDictProxy_New(type->tp_dict);
     589             : }
     590             : 
     591             : static PyObject *
     592          12 : type_get_doc(PyTypeObject *type, void *context)
     593             : {
     594             :     PyObject *result;
     595          12 :     if (!(type->tp_flags & Py_TPFLAGS_HEAPTYPE) && type->tp_doc != NULL)
     596          12 :         return PyString_FromString(type->tp_doc);
     597           0 :     result = PyDict_GetItemString(type->tp_dict, "__doc__");
     598           0 :     if (result == NULL) {
     599           0 :         result = Py_None;
     600           0 :         Py_INCREF(result);
     601             :     }
     602           0 :     else if (Py_TYPE(result)->tp_descr_get) {
     603           0 :         result = Py_TYPE(result)->tp_descr_get(result, NULL,
     604             :                                                (PyObject *)type);
     605             :     }
     606             :     else {
     607           0 :         Py_INCREF(result);
     608             :     }
     609           0 :     return result;
     610             : }
     611             : 
     612             : static PyObject *
     613        7102 : type___instancecheck__(PyObject *type, PyObject *inst)
     614             : {
     615        7102 :     switch (_PyObject_RealIsInstance(inst, type)) {
     616             :     case -1:
     617           0 :         return NULL;
     618             :     case 0:
     619        7063 :         Py_RETURN_FALSE;
     620             :     default:
     621          39 :         Py_RETURN_TRUE;
     622             :     }
     623             : }
     624             : 
     625             : 
     626             : static PyObject *
     627       10031 : type___subclasscheck__(PyObject *type, PyObject *inst)
     628             : {
     629       10031 :     switch (_PyObject_RealIsSubclass(inst, type)) {
     630             :     case -1:
     631           0 :         return NULL;
     632             :     case 0:
     633         126 :         Py_RETURN_FALSE;
     634             :     default:
     635        9905 :         Py_RETURN_TRUE;
     636             :     }
     637             : }
     638             : 
     639             : 
     640             : static PyGetSetDef type_getsets[] = {
     641             :     {"__name__", (getter)type_name, (setter)type_set_name, NULL},
     642             :     {"__bases__", (getter)type_get_bases, (setter)type_set_bases, NULL},
     643             :     {"__module__", (getter)type_module, (setter)type_set_module, NULL},
     644             :     {"__abstractmethods__", (getter)type_abstractmethods,
     645             :      (setter)type_set_abstractmethods, NULL},
     646             :     {"__dict__",  (getter)type_dict,  NULL, NULL},
     647             :     {"__doc__", (getter)type_get_doc, NULL, NULL},
     648             :     {0}
     649             : };
     650             : 
     651             : 
     652             : static PyObject*
     653         315 : type_richcompare(PyObject *v, PyObject *w, int op)
     654             : {
     655             :     PyObject *result;
     656             :     Py_uintptr_t vv, ww;
     657             :     int c;
     658             : 
     659             :     /* Make sure both arguments are types. */
     660         630 :     if (!PyType_Check(v) || !PyType_Check(w) ||
     661             :         /* If there is a __cmp__ method defined, let it be called instead
     662             :            of our dumb function designed merely to warn.  See bug
     663             :            #7491. */
     664         630 :         Py_TYPE(v)->tp_compare || Py_TYPE(w)->tp_compare) {
     665           0 :         result = Py_NotImplemented;
     666           0 :         goto out;
     667             :     }
     668             : 
     669             :     /* Py3K warning if comparison isn't == or !=  */
     670         315 :     if (Py_Py3kWarningFlag && op != Py_EQ && op != Py_NE &&
     671           0 :         PyErr_WarnEx(PyExc_DeprecationWarning,
     672             :                    "type inequality comparisons not supported "
     673             :                    "in 3.x", 1) < 0) {
     674           0 :         return NULL;
     675             :     }
     676             : 
     677             :     /* Compare addresses */
     678         315 :     vv = (Py_uintptr_t)v;
     679         315 :     ww = (Py_uintptr_t)w;
     680         315 :     switch (op) {
     681           0 :     case Py_LT: c = vv <  ww; break;
     682           0 :     case Py_LE: c = vv <= ww; break;
     683         174 :     case Py_EQ: c = vv == ww; break;
     684         141 :     case Py_NE: c = vv != ww; break;
     685           0 :     case Py_GT: c = vv >  ww; break;
     686           0 :     case Py_GE: c = vv >= ww; break;
     687             :     default:
     688           0 :         result = Py_NotImplemented;
     689           0 :         goto out;
     690             :     }
     691         315 :     result = c ? Py_True : Py_False;
     692             : 
     693             :   /* incref and return */
     694             :   out:
     695         315 :     Py_INCREF(result);
     696         315 :     return result;
     697             : }
     698             : 
     699             : static PyObject *
     700           0 : type_repr(PyTypeObject *type)
     701             : {
     702             :     PyObject *mod, *name, *rtn;
     703             :     char *kind;
     704             : 
     705           0 :     mod = type_module(type, NULL);
     706           0 :     if (mod == NULL)
     707           0 :         PyErr_Clear();
     708           0 :     else if (!PyString_Check(mod)) {
     709           0 :         Py_DECREF(mod);
     710           0 :         mod = NULL;
     711             :     }
     712           0 :     name = type_name(type, NULL);
     713           0 :     if (name == NULL) {
     714           0 :         Py_XDECREF(mod);
     715           0 :         return NULL;
     716             :     }
     717             : 
     718           0 :     if (type->tp_flags & Py_TPFLAGS_HEAPTYPE)
     719           0 :         kind = "class";
     720             :     else
     721           0 :         kind = "type";
     722             : 
     723           0 :     if (mod != NULL && strcmp(PyString_AS_STRING(mod), "__builtin__")) {
     724           0 :         rtn = PyString_FromFormat("<%s '%s.%s'>",
     725             :                                   kind,
     726           0 :                                   PyString_AS_STRING(mod),
     727           0 :                                   PyString_AS_STRING(name));
     728             :     }
     729             :     else
     730           0 :         rtn = PyString_FromFormat("<%s '%s'>", kind, type->tp_name);
     731             : 
     732           0 :     Py_XDECREF(mod);
     733           0 :     Py_DECREF(name);
     734           0 :     return rtn;
     735             : }
     736             : 
     737             : static PyObject *
     738       18528 : type_call(PyTypeObject *type, PyObject *args, PyObject *kwds)
     739             : {
     740             :     PyObject *obj;
     741             : 
     742       18528 :     if (type->tp_new == NULL) {
     743           0 :         PyErr_Format(PyExc_TypeError,
     744             :                      "cannot create '%.100s' instances",
     745             :                      type->tp_name);
     746           0 :         return NULL;
     747             :     }
     748             : 
     749       18528 :     obj = type->tp_new(type, args, kwds);
     750       18528 :     if (obj != NULL) {
     751             :         /* Ugly exception: when the call was type(something),
     752             :            don't call tp_init on the result. */
     753       21966 :         if (type == &PyType_Type &&
     754        6876 :             PyTuple_Check(args) && PyTuple_GET_SIZE(args) == 1 &&
     755           0 :             (kwds == NULL ||
     756           0 :              (PyDict_Check(kwds) && PyDict_Size(kwds) == 0)))
     757        2703 :             return obj;
     758             :         /* If the returned object is not an instance of type,
     759             :            it won't be initialized. */
     760       15825 :         if (!PyType_IsSubtype(obj->ob_type, type))
     761           3 :             return obj;
     762       15822 :         type = obj->ob_type;
     763       31644 :         if (PyType_HasFeature(type, Py_TPFLAGS_HAVE_CLASS) &&
     764       31644 :             type->tp_init != NULL &&
     765       15822 :             type->tp_init(obj, args, kwds) < 0) {
     766          78 :             Py_DECREF(obj);
     767          78 :             obj = NULL;
     768             :         }
     769             :     }
     770       15822 :     return obj;
     771             : }
     772             : 
     773             : PyObject *
     774       16494 : PyType_GenericAlloc(PyTypeObject *type, Py_ssize_t nitems)
     775             : {
     776             :     PyObject *obj;
     777       16494 :     const size_t size = _PyObject_VAR_SIZE(type, nitems+1);
     778             :     /* note that we need to add one, for the sentinel */
     779             : 
     780       16494 :     if (PyType_IS_GC(type))
     781       15783 :         obj = _PyObject_GC_Malloc(size);
     782             :     else
     783         711 :         obj = (PyObject *)PyObject_MALLOC(size);
     784             : 
     785       16494 :     if (obj == NULL)
     786           0 :         return PyErr_NoMemory();
     787             : 
     788       16494 :     memset(obj, '\0', size);
     789             : 
     790       16494 :     if (type->tp_flags & Py_TPFLAGS_HEAPTYPE)
     791        4233 :         Py_INCREF(type);
     792             : 
     793       16494 :     if (type->tp_itemsize == 0)
     794       13290 :         (void)PyObject_INIT(obj, type);
     795             :     else
     796        3204 :         (void) PyObject_INIT_VAR((PyVarObject *)obj, type, nitems);
     797             : 
     798       16494 :     if (PyType_IS_GC(type))
     799       15783 :         _PyObject_GC_TRACK(obj);
     800       16494 :     return obj;
     801             : }
     802             : 
     803             : PyObject *
     804        2037 : PyType_GenericNew(PyTypeObject *type, PyObject *args, PyObject *kwds)
     805             : {
     806        2037 :     return type->tp_alloc(type, 0);
     807             : }
     808             : 
     809             : /* Helpers for subtyping */
     810             : 
     811             : static int
     812           0 : traverse_slots(PyTypeObject *type, PyObject *self, visitproc visit, void *arg)
     813             : {
     814             :     Py_ssize_t i, n;
     815             :     PyMemberDef *mp;
     816             : 
     817           0 :     n = Py_SIZE(type);
     818           0 :     mp = PyHeapType_GET_MEMBERS((PyHeapTypeObject *)type);
     819           0 :     for (i = 0; i < n; i++, mp++) {
     820           0 :         if (mp->type == T_OBJECT_EX) {
     821           0 :             char *addr = (char *)self + mp->offset;
     822           0 :             PyObject *obj = *(PyObject **)addr;
     823           0 :             if (obj != NULL) {
     824           0 :                 int err = visit(obj, arg);
     825           0 :                 if (err)
     826           0 :                     return err;
     827             :             }
     828             :         }
     829             :     }
     830           0 :     return 0;
     831             : }
     832             : 
     833             : static int
     834        8949 : subtype_traverse(PyObject *self, visitproc visit, void *arg)
     835             : {
     836             :     PyTypeObject *type, *base;
     837             :     traverseproc basetraverse;
     838             : 
     839             :     /* Find the nearest base with a different tp_traverse,
     840             :        and traverse slots while we're at it */
     841        8949 :     type = Py_TYPE(self);
     842        8949 :     base = type;
     843       27021 :     while ((basetraverse = base->tp_traverse) == subtype_traverse) {
     844        9123 :         if (Py_SIZE(base)) {
     845           0 :             int err = traverse_slots(base, self, visit, arg);
     846           0 :             if (err)
     847           0 :                 return err;
     848             :         }
     849        9123 :         base = base->tp_base;
     850             :         assert(base);
     851             :     }
     852             : 
     853        8949 :     if (type->tp_dictoffset != base->tp_dictoffset) {
     854        8565 :         PyObject **dictptr = _PyObject_GetDictPtr(self);
     855        8565 :         if (dictptr && *dictptr)
     856        8485 :             Py_VISIT(*dictptr);
     857             :     }
     858             : 
     859        8949 :     if (type->tp_flags & Py_TPFLAGS_HEAPTYPE)
     860             :         /* For a heaptype, the instances count as references
     861             :            to the type.          Traverse the type so the collector
     862             :            can find cycles involving this link. */
     863        8949 :         Py_VISIT(type);
     864             : 
     865        8949 :     if (basetraverse)
     866         402 :         return basetraverse(self, visit, arg);
     867        8547 :     return 0;
     868             : }
     869             : 
     870             : static void
     871           0 : clear_slots(PyTypeObject *type, PyObject *self)
     872             : {
     873             :     Py_ssize_t i, n;
     874             :     PyMemberDef *mp;
     875             : 
     876           0 :     n = Py_SIZE(type);
     877           0 :     mp = PyHeapType_GET_MEMBERS((PyHeapTypeObject *)type);
     878           0 :     for (i = 0; i < n; i++, mp++) {
     879           0 :         if (mp->type == T_OBJECT_EX && !(mp->flags & READONLY)) {
     880           0 :             char *addr = (char *)self + mp->offset;
     881           0 :             PyObject *obj = *(PyObject **)addr;
     882           0 :             if (obj != NULL) {
     883           0 :                 *(PyObject **)addr = NULL;
     884           0 :                 Py_DECREF(obj);
     885             :             }
     886             :         }
     887             :     }
     888           0 : }
     889             : 
     890             : static int
     891          24 : subtype_clear(PyObject *self)
     892             : {
     893             :     PyTypeObject *type, *base;
     894             :     inquiry baseclear;
     895             : 
     896             :     /* Find the nearest base with a different tp_clear
     897             :        and clear slots while we're at it */
     898          24 :     type = Py_TYPE(self);
     899          24 :     base = type;
     900          78 :     while ((baseclear = base->tp_clear) == subtype_clear) {
     901          30 :         if (Py_SIZE(base))
     902           0 :             clear_slots(base, self);
     903          30 :         base = base->tp_base;
     904             :         assert(base);
     905             :     }
     906             : 
     907             :     /* Clear the instance dict (if any), to break cycles involving only
     908             :        __dict__ slots (as in the case 'self.__dict__ is self'). */
     909          24 :     if (type->tp_dictoffset != base->tp_dictoffset) {
     910          24 :         PyObject **dictptr = _PyObject_GetDictPtr(self);
     911          24 :         if (dictptr && *dictptr)
     912          24 :             Py_CLEAR(*dictptr);
     913             :     }
     914             : 
     915          24 :     if (baseclear)
     916           0 :         return baseclear(self);
     917          24 :     return 0;
     918             : }
     919             : 
     920             : static void
     921        3309 : subtype_dealloc(PyObject *self)
     922             : {
     923             :     PyTypeObject *type, *base;
     924             :     destructor basedealloc;
     925        3309 :     PyThreadState *tstate = PyThreadState_GET();
     926             : 
     927             :     /* Extract the type; we expect it to be a heap type */
     928        3309 :     type = Py_TYPE(self);
     929             :     assert(type->tp_flags & Py_TPFLAGS_HEAPTYPE);
     930             : 
     931             :     /* Test whether the type has GC exactly once */
     932             : 
     933        3309 :     if (!PyType_IS_GC(type)) {
     934             :         /* It's really rare to find a dynamic type that doesn't have
     935             :            GC; it can only happen when deriving from 'object' and not
     936             :            adding any slots or instance variables.  This allows
     937             :            certain simplifications: there's no need to call
     938             :            clear_slots(), or DECREF the dict, or clear weakrefs. */
     939             : 
     940             :         /* Maybe call finalizer; exit early if resurrected */
     941           0 :         if (type->tp_del) {
     942           0 :             type->tp_del(self);
     943           0 :             if (self->ob_refcnt > 0)
     944           0 :                 return;
     945             :         }
     946             : 
     947             :         /* Find the nearest base with a different tp_dealloc */
     948           0 :         base = type;
     949           0 :         while ((basedealloc = base->tp_dealloc) == subtype_dealloc) {
     950             :             assert(Py_SIZE(base) == 0);
     951           0 :             base = base->tp_base;
     952             :             assert(base);
     953             :         }
     954             : 
     955             :         /* Extract the type again; tp_del may have changed it */
     956           0 :         type = Py_TYPE(self);
     957             : 
     958             :         /* Call the base tp_dealloc() */
     959             :         assert(basedealloc);
     960           0 :         basedealloc(self);
     961             : 
     962             :         /* Can't reference self beyond this point */
     963           0 :         Py_DECREF(type);
     964             : 
     965             :         /* Done */
     966           0 :         return;
     967             :     }
     968             : 
     969             :     /* We get here only if the type has GC */
     970             : 
     971             :     /* UnTrack and re-Track around the trashcan macro, alas */
     972             :     /* See explanation at end of function for full disclosure */
     973        3309 :     PyObject_GC_UnTrack(self);
     974        3309 :     ++_PyTrash_delete_nesting;
     975        3309 :     ++ tstate->trash_delete_nesting;
     976        3309 :     Py_TRASHCAN_SAFE_BEGIN(self);
     977        3309 :     --_PyTrash_delete_nesting;
     978        3309 :     -- tstate->trash_delete_nesting;
     979             :     /* DO NOT restore GC tracking at this point.  weakref callbacks
     980             :      * (if any, and whether directly here or indirectly in something we
     981             :      * call) may trigger GC, and if self is tracked at that point, it
     982             :      * will look like trash to GC and GC will try to delete self again.
     983             :      */
     984             : 
     985             :     /* Find the nearest base with a different tp_dealloc */
     986        3309 :     base = type;
     987       10326 :     while ((basedealloc = base->tp_dealloc) == subtype_dealloc) {
     988        3708 :         base = base->tp_base;
     989             :         assert(base);
     990             :     }
     991             : 
     992             :     /* If we added a weaklist, we clear it.      Do this *before* calling
     993             :        the finalizer (__del__), clearing slots, or clearing the instance
     994             :        dict. */
     995             : 
     996        3309 :     if (type->tp_weaklistoffset && !base->tp_weaklistoffset)
     997         894 :         PyObject_ClearWeakRefs(self);
     998             : 
     999             :     /* Maybe call finalizer; exit early if resurrected */
    1000        3309 :     if (type->tp_del) {
    1001           0 :         _PyObject_GC_TRACK(self);
    1002           0 :         type->tp_del(self);
    1003           0 :         if (self->ob_refcnt > 0)
    1004           0 :             goto endlabel;              /* resurrected */
    1005             :         else
    1006           0 :             _PyObject_GC_UNTRACK(self);
    1007             :         /* New weakrefs could be created during the finalizer call.
    1008             :             If this occurs, clear them out without calling their
    1009             :             finalizers since they might rely on part of the object
    1010             :             being finalized that has already been destroyed. */
    1011           0 :         if (type->tp_weaklistoffset && !base->tp_weaklistoffset) {
    1012             :             /* Modeled after GET_WEAKREFS_LISTPTR() */
    1013           0 :             PyWeakReference **list = (PyWeakReference **) \
    1014           0 :                 PyObject_GET_WEAKREFS_LISTPTR(self);
    1015           0 :             while (*list)
    1016           0 :                 _PyWeakref_ClearRef(*list);
    1017             :         }
    1018             :     }
    1019             : 
    1020             :     /*  Clear slots up to the nearest base with a different tp_dealloc */
    1021        3309 :     base = type;
    1022       10326 :     while (base->tp_dealloc == subtype_dealloc) {
    1023        3708 :         if (Py_SIZE(base))
    1024           0 :             clear_slots(base, self);
    1025        3708 :         base = base->tp_base;
    1026             :         assert(base);
    1027             :     }
    1028             : 
    1029             :     /* If we added a dict, DECREF it */
    1030        3309 :     if (type->tp_dictoffset && !base->tp_dictoffset) {
    1031         897 :         PyObject **dictptr = _PyObject_GetDictPtr(self);
    1032         897 :         if (dictptr != NULL) {
    1033         897 :             PyObject *dict = *dictptr;
    1034         897 :             if (dict != NULL) {
    1035         861 :                 Py_DECREF(dict);
    1036         861 :                 *dictptr = NULL;
    1037             :             }
    1038             :         }
    1039             :     }
    1040             : 
    1041             :     /* Extract the type again; tp_del may have changed it */
    1042        3309 :     type = Py_TYPE(self);
    1043             : 
    1044             :     /* Call the base tp_dealloc(); first retrack self if
    1045             :      * basedealloc knows about gc.
    1046             :      */
    1047        3309 :     if (PyType_IS_GC(base))
    1048        2415 :         _PyObject_GC_TRACK(self);
    1049             :     assert(basedealloc);
    1050        3309 :     basedealloc(self);
    1051             : 
    1052             :     /* Can't reference self beyond this point */
    1053        3309 :     Py_DECREF(type);
    1054             : 
    1055             :   endlabel:
    1056        3309 :     ++_PyTrash_delete_nesting;
    1057        3309 :     ++ tstate->trash_delete_nesting;
    1058        3309 :     Py_TRASHCAN_SAFE_END(self);
    1059        3309 :     --_PyTrash_delete_nesting;
    1060        3309 :     -- tstate->trash_delete_nesting;
    1061             : 
    1062             :     /* Explanation of the weirdness around the trashcan macros:
    1063             : 
    1064             :        Q. What do the trashcan macros do?
    1065             : 
    1066             :        A. Read the comment titled "Trashcan mechanism" in object.h.
    1067             :           For one, this explains why there must be a call to GC-untrack
    1068             :           before the trashcan begin macro.      Without understanding the
    1069             :           trashcan code, the answers to the following questions don't make
    1070             :           sense.
    1071             : 
    1072             :        Q. Why do we GC-untrack before the trashcan and then immediately
    1073             :           GC-track again afterward?
    1074             : 
    1075             :        A. In the case that the base class is GC-aware, the base class
    1076             :           probably GC-untracks the object.      If it does that using the
    1077             :           UNTRACK macro, this will crash when the object is already
    1078             :           untracked.  Because we don't know what the base class does, the
    1079             :           only safe thing is to make sure the object is tracked when we
    1080             :           call the base class dealloc.  But...  The trashcan begin macro
    1081             :           requires that the object is *untracked* before it is called.  So
    1082             :           the dance becomes:
    1083             : 
    1084             :          GC untrack
    1085             :          trashcan begin
    1086             :          GC track
    1087             : 
    1088             :        Q. Why did the last question say "immediately GC-track again"?
    1089             :           It's nowhere near immediately.
    1090             : 
    1091             :        A. Because the code *used* to re-track immediately.      Bad Idea.
    1092             :           self has a refcount of 0, and if gc ever gets its hands on it
    1093             :           (which can happen if any weakref callback gets invoked), it
    1094             :           looks like trash to gc too, and gc also tries to delete self
    1095             :           then.  But we're already deleting self.  Double deallocation is
    1096             :           a subtle disaster.
    1097             : 
    1098             :        Q. Why the bizarre (net-zero) manipulation of
    1099             :           _PyTrash_delete_nesting around the trashcan macros?
    1100             : 
    1101             :        A. Some base classes (e.g. list) also use the trashcan mechanism.
    1102             :           The following scenario used to be possible:
    1103             : 
    1104             :           - suppose the trashcan level is one below the trashcan limit
    1105             : 
    1106             :           - subtype_dealloc() is called
    1107             : 
    1108             :           - the trashcan limit is not yet reached, so the trashcan level
    1109             :         is incremented and the code between trashcan begin and end is
    1110             :         executed
    1111             : 
    1112             :           - this destroys much of the object's contents, including its
    1113             :         slots and __dict__
    1114             : 
    1115             :           - basedealloc() is called; this is really list_dealloc(), or
    1116             :         some other type which also uses the trashcan macros
    1117             : 
    1118             :           - the trashcan limit is now reached, so the object is put on the
    1119             :         trashcan's to-be-deleted-later list
    1120             : 
    1121             :           - basedealloc() returns
    1122             : 
    1123             :           - subtype_dealloc() decrefs the object's type
    1124             : 
    1125             :           - subtype_dealloc() returns
    1126             : 
    1127             :           - later, the trashcan code starts deleting the objects from its
    1128             :         to-be-deleted-later list
    1129             : 
    1130             :           - subtype_dealloc() is called *AGAIN* for the same object
    1131             : 
    1132             :           - at the very least (if the destroyed slots and __dict__ don't
    1133             :         cause problems) the object's type gets decref'ed a second
    1134             :         time, which is *BAD*!!!
    1135             : 
    1136             :           The remedy is to make sure that if the code between trashcan
    1137             :           begin and end in subtype_dealloc() is called, the code between
    1138             :           trashcan begin and end in basedealloc() will also be called.
    1139             :           This is done by decrementing the level after passing into the
    1140             :           trashcan block, and incrementing it just before leaving the
    1141             :           block.
    1142             : 
    1143             :           But now it's possible that a chain of objects consisting solely
    1144             :           of objects whose deallocator is subtype_dealloc() will defeat
    1145             :           the trashcan mechanism completely: the decremented level means
    1146             :           that the effective level never reaches the limit.      Therefore, we
    1147             :           *increment* the level *before* entering the trashcan block, and
    1148             :           matchingly decrement it after leaving.  This means the trashcan
    1149             :           code will trigger a little early, but that's no big deal.
    1150             : 
    1151             :        Q. Are there any live examples of code in need of all this
    1152             :           complexity?
    1153             : 
    1154             :        A. Yes.  See SF bug 668433 for code that crashed (when Python was
    1155             :           compiled in debug mode) before the trashcan level manipulations
    1156             :           were added.  For more discussion, see SF patches 581742, 575073
    1157             :           and bug 574207.
    1158             :     */
    1159             : }
    1160             : 
    1161             : static PyTypeObject *solid_base(PyTypeObject *type);
    1162             : 
    1163             : /* type test with subclassing support */
    1164             : 
    1165             : int
    1166      114436 : PyType_IsSubtype(PyTypeObject *a, PyTypeObject *b)
    1167             : {
    1168             :     PyObject *mro;
    1169             : 
    1170      114436 :     if (!(a->tp_flags & Py_TPFLAGS_HAVE_CLASS))
    1171        4965 :         return b == a || b == &PyBaseObject_Type;
    1172             : 
    1173      109471 :     mro = a->tp_mro;
    1174      109471 :     if (mro != NULL) {
    1175             :         /* Deal with multiple inheritance without recursion
    1176             :            by walking the MRO tuple */
    1177             :         Py_ssize_t i, n;
    1178             :         assert(PyTuple_Check(mro));
    1179      109291 :         n = PyTuple_GET_SIZE(mro);
    1180      261686 :         for (i = 0; i < n; i++) {
    1181      203306 :             if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b)
    1182       50911 :                 return 1;
    1183             :         }
    1184       58380 :         return 0;
    1185             :     }
    1186             :     else {
    1187             :         /* a is not completely initilized yet; follow tp_base */
    1188             :         do {
    1189         546 :             if (a == b)
    1190         177 :                 return 1;
    1191         369 :             a = a->tp_base;
    1192         369 :         } while (a != NULL);
    1193           3 :         return b == &PyBaseObject_Type;
    1194             :     }
    1195             : }
    1196             : 
    1197             : /* Internal routines to do a method lookup in the type
    1198             :    without looking in the instance dictionary
    1199             :    (so we can't use PyObject_GetAttr) but still binding
    1200             :    it to the instance.  The arguments are the object,
    1201             :    the method name as a C string, and the address of a
    1202             :    static variable used to cache the interned Python string.
    1203             : 
    1204             :    Two variants:
    1205             : 
    1206             :    - lookup_maybe() returns NULL without raising an exception
    1207             :      when the _PyType_Lookup() call fails;
    1208             : 
    1209             :    - lookup_method() always raises an exception upon errors.
    1210             : 
    1211             :    - _PyObject_LookupSpecial() exported for the benefit of other places.
    1212             : */
    1213             : 
    1214             : static PyObject *
    1215       21670 : lookup_maybe(PyObject *self, char *attrstr, PyObject **attrobj)
    1216             : {
    1217             :     PyObject *res;
    1218             : 
    1219       21670 :     if (*attrobj == NULL) {
    1220          48 :         *attrobj = PyString_InternFromString(attrstr);
    1221          48 :         if (*attrobj == NULL)
    1222           0 :             return NULL;
    1223             :     }
    1224       21670 :     res = _PyType_Lookup(Py_TYPE(self), *attrobj);
    1225       21670 :     if (res != NULL) {
    1226             :         descrgetfunc f;
    1227       20755 :         if ((f = Py_TYPE(res)->tp_descr_get) == NULL)
    1228           0 :             Py_INCREF(res);
    1229             :         else
    1230       20755 :             res = f(res, self, (PyObject *)(Py_TYPE(self)));
    1231             :     }
    1232       21670 :     return res;
    1233             : }
    1234             : 
    1235             : static PyObject *
    1236        3910 : lookup_method(PyObject *self, char *attrstr, PyObject **attrobj)
    1237             : {
    1238        3910 :     PyObject *res = lookup_maybe(self, attrstr, attrobj);
    1239        3910 :     if (res == NULL && !PyErr_Occurred())
    1240         762 :         PyErr_SetObject(PyExc_AttributeError, *attrobj);
    1241        3910 :     return res;
    1242             : }
    1243             : 
    1244             : PyObject *
    1245       17502 : _PyObject_LookupSpecial(PyObject *self, char *attrstr, PyObject **attrobj)
    1246             : {
    1247             :     assert(!PyInstance_Check(self));
    1248       17502 :     return lookup_maybe(self, attrstr, attrobj);
    1249             : }
    1250             : 
    1251             : /* A variation of PyObject_CallMethod that uses lookup_method()
    1252             :    instead of PyObject_GetAttrString().  This uses the same convention
    1253             :    as lookup_method to cache the interned name string object. */
    1254             : 
    1255             : static PyObject *
    1256         165 : call_method(PyObject *o, char *name, PyObject **nameobj, char *format, ...)
    1257             : {
    1258             :     va_list va;
    1259         165 :     PyObject *args, *func = 0, *retval;
    1260         165 :     va_start(va, format);
    1261             : 
    1262         165 :     func = lookup_maybe(o, name, nameobj);
    1263         165 :     if (func == NULL) {
    1264           0 :         va_end(va);
    1265           0 :         if (!PyErr_Occurred())
    1266           0 :             PyErr_SetObject(PyExc_AttributeError, *nameobj);
    1267           0 :         return NULL;
    1268             :     }
    1269             : 
    1270         165 :     if (format && *format)
    1271         165 :         args = Py_VaBuildValue(format, va);
    1272             :     else
    1273           0 :         args = PyTuple_New(0);
    1274             : 
    1275         165 :     va_end(va);
    1276             : 
    1277         165 :     if (args == NULL) {
    1278           0 :         Py_DECREF(func);
    1279           0 :         return NULL;
    1280             :     }
    1281             : 
    1282             :     assert(PyTuple_Check(args));
    1283         165 :     retval = PyObject_Call(func, args, NULL);
    1284             : 
    1285         165 :     Py_DECREF(args);
    1286         165 :     Py_DECREF(func);
    1287             : 
    1288         165 :     return retval;
    1289             : }
    1290             : 
    1291             : /* Clone of call_method() that returns NotImplemented when the lookup fails. */
    1292             : 
    1293             : static PyObject *
    1294           0 : call_maybe(PyObject *o, char *name, PyObject **nameobj, char *format, ...)
    1295             : {
    1296             :     va_list va;
    1297           0 :     PyObject *args, *func = 0, *retval;
    1298           0 :     va_start(va, format);
    1299             : 
    1300           0 :     func = lookup_maybe(o, name, nameobj);
    1301           0 :     if (func == NULL) {
    1302           0 :         va_end(va);
    1303           0 :         if (!PyErr_Occurred()) {
    1304           0 :             Py_INCREF(Py_NotImplemented);
    1305           0 :             return Py_NotImplemented;
    1306             :         }
    1307           0 :         return NULL;
    1308             :     }
    1309             : 
    1310           0 :     if (format && *format)
    1311           0 :         args = Py_VaBuildValue(format, va);
    1312             :     else
    1313           0 :         args = PyTuple_New(0);
    1314             : 
    1315           0 :     va_end(va);
    1316             : 
    1317           0 :     if (args == NULL) {
    1318           0 :         Py_DECREF(func);
    1319           0 :         return NULL;
    1320             :     }
    1321             : 
    1322             :     assert(PyTuple_Check(args));
    1323           0 :     retval = PyObject_Call(func, args, NULL);
    1324             : 
    1325           0 :     Py_DECREF(args);
    1326           0 :     Py_DECREF(func);
    1327             : 
    1328           0 :     return retval;
    1329             : }
    1330             : 
    1331             : static int
    1332           0 : fill_classic_mro(PyObject *mro, PyObject *cls)
    1333             : {
    1334             :     PyObject *bases, *base;
    1335             :     Py_ssize_t i, n;
    1336             : 
    1337             :     assert(PyList_Check(mro));
    1338             :     assert(PyClass_Check(cls));
    1339           0 :     i = PySequence_Contains(mro, cls);
    1340           0 :     if (i < 0)
    1341           0 :         return -1;
    1342           0 :     if (!i) {
    1343           0 :         if (PyList_Append(mro, cls) < 0)
    1344           0 :             return -1;
    1345             :     }
    1346           0 :     bases = ((PyClassObject *)cls)->cl_bases;
    1347             :     assert(bases && PyTuple_Check(bases));
    1348           0 :     n = PyTuple_GET_SIZE(bases);
    1349           0 :     for (i = 0; i < n; i++) {
    1350           0 :         base = PyTuple_GET_ITEM(bases, i);
    1351           0 :         if (fill_classic_mro(mro, base) < 0)
    1352           0 :             return -1;
    1353             :     }
    1354           0 :     return 0;
    1355             : }
    1356             : 
    1357             : static PyObject *
    1358           0 : classic_mro(PyObject *cls)
    1359             : {
    1360             :     PyObject *mro;
    1361             : 
    1362             :     assert(PyClass_Check(cls));
    1363           0 :     mro = PyList_New(0);
    1364           0 :     if (mro != NULL) {
    1365           0 :         if (fill_classic_mro(mro, cls) == 0)
    1366           0 :             return mro;
    1367           0 :         Py_DECREF(mro);
    1368             :     }
    1369           0 :     return NULL;
    1370             : }
    1371             : 
    1372             : /*
    1373             :     Method resolution order algorithm C3 described in
    1374             :     "A Monotonic Superclass Linearization for Dylan",
    1375             :     by Kim Barrett, Bob Cassel, Paul Haahr,
    1376             :     David A. Moon, Keith Playford, and P. Tucker Withington.
    1377             :     (OOPSLA 1996)
    1378             : 
    1379             :     Some notes about the rules implied by C3:
    1380             : 
    1381             :     No duplicate bases.
    1382             :     It isn't legal to repeat a class in a list of base classes.
    1383             : 
    1384             :     The next three properties are the 3 constraints in "C3".
    1385             : 
    1386             :     Local precedence order.
    1387             :     If A precedes B in C's MRO, then A will precede B in the MRO of all
    1388             :     subclasses of C.
    1389             : 
    1390             :     Monotonicity.
    1391             :     The MRO of a class must be an extension without reordering of the
    1392             :     MRO of each of its superclasses.
    1393             : 
    1394             :     Extended Precedence Graph (EPG).
    1395             :     Linearization is consistent if there is a path in the EPG from
    1396             :     each class to all its successors in the linearization.  See
    1397             :     the paper for definition of EPG.
    1398             :  */
    1399             : 
    1400             : static int
    1401        6699 : tail_contains(PyObject *list, int whence, PyObject *o) {
    1402             :     Py_ssize_t j, size;
    1403        6699 :     size = PyList_GET_SIZE(list);
    1404             : 
    1405       10644 :     for (j = whence+1; j < size; j++) {
    1406        4014 :         if (PyList_GET_ITEM(list, j) == o)
    1407          69 :             return 1;
    1408             :     }
    1409        6630 :     return 0;
    1410             : }
    1411             : 
    1412             : static PyObject *
    1413           0 : class_name(PyObject *cls)
    1414             : {
    1415           0 :     PyObject *name = PyObject_GetAttrString(cls, "__name__");
    1416           0 :     if (name == NULL) {
    1417           0 :         PyErr_Clear();
    1418           0 :         Py_XDECREF(name);
    1419           0 :         name = PyObject_Repr(cls);
    1420             :     }
    1421           0 :     if (name == NULL)
    1422           0 :         return NULL;
    1423           0 :     if (!PyString_Check(name)) {
    1424           0 :         Py_DECREF(name);
    1425           0 :         return NULL;
    1426             :     }
    1427           0 :     return name;
    1428             : }
    1429             : 
    1430             : static int
    1431        1296 : check_duplicates(PyObject *list)
    1432             : {
    1433             :     Py_ssize_t i, j, n;
    1434             :     /* Let's use a quadratic time algorithm,
    1435             :        assuming that the bases lists is short.
    1436             :     */
    1437        1296 :     n = PyList_GET_SIZE(list);
    1438        2634 :     for (i = 0; i < n; i++) {
    1439        1338 :         PyObject *o = PyList_GET_ITEM(list, i);
    1440        1392 :         for (j = i + 1; j < n; j++) {
    1441          54 :             if (PyList_GET_ITEM(list, j) == o) {
    1442           0 :                 o = class_name(o);
    1443           0 :                 PyErr_Format(PyExc_TypeError,
    1444             :                              "duplicate base class %s",
    1445             :                              o ? PyString_AS_STRING(o) : "?");
    1446           0 :                 Py_XDECREF(o);
    1447           0 :                 return -1;
    1448             :             }
    1449             :         }
    1450             :     }
    1451        1296 :     return 0;
    1452             : }
    1453             : 
    1454             : /* Raise a TypeError for an MRO order disagreement.
    1455             : 
    1456             :    It's hard to produce a good error message.  In the absence of better
    1457             :    insight into error reporting, report the classes that were candidates
    1458             :    to be put next into the MRO.  There is some conflict between the
    1459             :    order in which they should be put in the MRO, but it's hard to
    1460             :    diagnose what constraint can't be satisfied.
    1461             : */
    1462             : 
    1463             : static void
    1464           0 : set_mro_error(PyObject *to_merge, int *remain)
    1465             : {
    1466             :     Py_ssize_t i, n, off, to_merge_size;
    1467             :     char buf[1000];
    1468             :     PyObject *k, *v;
    1469           0 :     PyObject *set = PyDict_New();
    1470           0 :     if (!set) return;
    1471             : 
    1472           0 :     to_merge_size = PyList_GET_SIZE(to_merge);
    1473           0 :     for (i = 0; i < to_merge_size; i++) {
    1474           0 :         PyObject *L = PyList_GET_ITEM(to_merge, i);
    1475           0 :         if (remain[i] < PyList_GET_SIZE(L)) {
    1476           0 :             PyObject *c = PyList_GET_ITEM(L, remain[i]);
    1477           0 :             if (PyDict_SetItem(set, c, Py_None) < 0) {
    1478           0 :                 Py_DECREF(set);
    1479           0 :                 return;
    1480             :             }
    1481             :         }
    1482             :     }
    1483           0 :     n = PyDict_Size(set);
    1484             : 
    1485           0 :     off = PyOS_snprintf(buf, sizeof(buf), "Cannot create a \
    1486             : consistent method resolution\norder (MRO) for bases");
    1487           0 :     i = 0;
    1488           0 :     while (PyDict_Next(set, &i, &k, &v) && (size_t)off < sizeof(buf)) {
    1489           0 :         PyObject *name = class_name(k);
    1490           0 :         off += PyOS_snprintf(buf + off, sizeof(buf) - off, " %s",
    1491             :                              name ? PyString_AS_STRING(name) : "?");
    1492           0 :         Py_XDECREF(name);
    1493           0 :         if (--n && (size_t)(off+1) < sizeof(buf)) {
    1494           0 :             buf[off++] = ',';
    1495           0 :             buf[off] = '\0';
    1496             :         }
    1497             :     }
    1498           0 :     PyErr_SetString(PyExc_TypeError, buf);
    1499           0 :     Py_DECREF(set);
    1500             : }
    1501             : 
    1502             : static int
    1503        1296 : pmerge(PyObject *acc, PyObject* to_merge) {
    1504             :     Py_ssize_t i, j, to_merge_size, empty_cnt;
    1505             :     int *remain;
    1506             :     int ok;
    1507             : 
    1508        1296 :     to_merge_size = PyList_GET_SIZE(to_merge);
    1509             : 
    1510             :     /* remain stores an index into each sublist of to_merge.
    1511             :        remain[i] is the index of the next base in to_merge[i]
    1512             :        that is not included in acc.
    1513             :     */
    1514        1296 :     remain = (int *)PyMem_MALLOC(SIZEOF_INT*to_merge_size);
    1515        1296 :     if (remain == NULL)
    1516           0 :         return -1;
    1517        3930 :     for (i = 0; i < to_merge_size; i++)
    1518        2634 :         remain[i] = 0;
    1519             : 
    1520             :   again:
    1521        4464 :     empty_cnt = 0;
    1522        7167 :     for (i = 0; i < to_merge_size; i++) {
    1523             :         PyObject *candidate;
    1524             : 
    1525        5871 :         PyObject *cur_list = PyList_GET_ITEM(to_merge, i);
    1526             : 
    1527        5871 :         if (remain[i] >= PyList_GET_SIZE(cur_list)) {
    1528        2634 :             empty_cnt++;
    1529        2634 :             continue;
    1530             :         }
    1531             : 
    1532             :         /* Choose next candidate for MRO.
    1533             : 
    1534             :            The input sequences alone can determine the choice.
    1535             :            If not, choose the class which appears in the MRO
    1536             :            of the earliest direct superclass of the new class.
    1537             :         */
    1538             : 
    1539        3237 :         candidate = PyList_GET_ITEM(cur_list, remain[i]);
    1540        9867 :         for (j = 0; j < to_merge_size; j++) {
    1541        6699 :             PyObject *j_lst = PyList_GET_ITEM(to_merge, j);
    1542        6699 :             if (tail_contains(j_lst, remain[j], candidate)) {
    1543          69 :                 goto skip; /* continue outer loop */
    1544             :             }
    1545             :         }
    1546        3168 :         ok = PyList_Append(acc, candidate);
    1547        3168 :         if (ok < 0) {
    1548           0 :             PyMem_Free(remain);
    1549           0 :             return -1;
    1550             :         }
    1551        9711 :         for (j = 0; j < to_merge_size; j++) {
    1552        6543 :             PyObject *j_lst = PyList_GET_ITEM(to_merge, j);
    1553       11262 :             if (remain[j] < PyList_GET_SIZE(j_lst) &&
    1554        4719 :                 PyList_GET_ITEM(j_lst, remain[j]) == candidate) {
    1555        4584 :                 remain[j]++;
    1556             :             }
    1557             :         }
    1558        3168 :         goto again;
    1559             :       skip: ;
    1560             :     }
    1561             : 
    1562        1296 :     if (empty_cnt == to_merge_size) {
    1563        1296 :         PyMem_FREE(remain);
    1564        1296 :         return 0;
    1565             :     }
    1566           0 :     set_mro_error(to_merge, remain);
    1567           0 :     PyMem_FREE(remain);
    1568           0 :     return -1;
    1569             : }
    1570             : 
    1571             : static PyObject *
    1572        1296 : mro_implementation(PyTypeObject *type)
    1573             : {
    1574             :     Py_ssize_t i, n;
    1575             :     int ok;
    1576             :     PyObject *bases, *result;
    1577             :     PyObject *to_merge, *bases_aslist;
    1578             : 
    1579        1296 :     if (type->tp_dict == NULL) {
    1580           0 :         if (PyType_Ready(type) < 0)
    1581           0 :             return NULL;
    1582             :     }
    1583             : 
    1584             :     /* Find a superclass linearization that honors the constraints
    1585             :        of the explicit lists of bases and the constraints implied by
    1586             :        each base class.
    1587             : 
    1588             :        to_merge is a list of lists, where each list is a superclass
    1589             :        linearization implied by a base class.  The last element of
    1590             :        to_merge is the declared list of bases.
    1591             :     */
    1592             : 
    1593        1296 :     bases = type->tp_bases;
    1594        1296 :     n = PyTuple_GET_SIZE(bases);
    1595             : 
    1596        1296 :     to_merge = PyList_New(n+1);
    1597        1296 :     if (to_merge == NULL)
    1598           0 :         return NULL;
    1599             : 
    1600        2634 :     for (i = 0; i < n; i++) {
    1601        1338 :         PyObject *base = PyTuple_GET_ITEM(bases, i);
    1602             :         PyObject *parentMRO;
    1603        1338 :         if (PyType_Check(base))
    1604        1338 :             parentMRO = PySequence_List(
    1605             :                 ((PyTypeObject*)base)->tp_mro);
    1606             :         else
    1607           0 :             parentMRO = classic_mro(base);
    1608        1338 :         if (parentMRO == NULL) {
    1609           0 :             Py_DECREF(to_merge);
    1610           0 :             return NULL;
    1611             :         }
    1612             : 
    1613        1338 :         PyList_SET_ITEM(to_merge, i, parentMRO);
    1614             :     }
    1615             : 
    1616        1296 :     bases_aslist = PySequence_List(bases);
    1617        1296 :     if (bases_aslist == NULL) {
    1618           0 :         Py_DECREF(to_merge);
    1619           0 :         return NULL;
    1620             :     }
    1621             :     /* This is just a basic sanity check. */
    1622        1296 :     if (check_duplicates(bases_aslist) < 0) {
    1623           0 :         Py_DECREF(to_merge);
    1624           0 :         Py_DECREF(bases_aslist);
    1625           0 :         return NULL;
    1626             :     }
    1627        1296 :     PyList_SET_ITEM(to_merge, n, bases_aslist);
    1628             : 
    1629        1296 :     result = Py_BuildValue("[O]", (PyObject *)type);
    1630        1296 :     if (result == NULL) {
    1631           0 :         Py_DECREF(to_merge);
    1632           0 :         return NULL;
    1633             :     }
    1634             : 
    1635        1296 :     ok = pmerge(result, to_merge);
    1636        1296 :     Py_DECREF(to_merge);
    1637        1296 :     if (ok < 0) {
    1638           0 :         Py_DECREF(result);
    1639           0 :         return NULL;
    1640             :     }
    1641             : 
    1642        1296 :     return result;
    1643             : }
    1644             : 
    1645             : static PyObject *
    1646          63 : mro_external(PyObject *self)
    1647             : {
    1648          63 :     PyTypeObject *type = (PyTypeObject *)self;
    1649             : 
    1650          63 :     return mro_implementation(type);
    1651             : }
    1652             : 
    1653             : static int
    1654        1296 : mro_internal(PyTypeObject *type)
    1655             : {
    1656             :     PyObject *mro, *result, *tuple;
    1657        1296 :     int checkit = 0;
    1658             : 
    1659        1296 :     if (Py_TYPE(type) == &PyType_Type) {
    1660        1233 :         result = mro_implementation(type);
    1661             :     }
    1662             :     else {
    1663             :         static PyObject *mro_str;
    1664          63 :         checkit = 1;
    1665          63 :         mro = lookup_method((PyObject *)type, "mro", &mro_str);
    1666          63 :         if (mro == NULL)
    1667           0 :             return -1;
    1668          63 :         result = PyObject_CallObject(mro, NULL);
    1669          63 :         Py_DECREF(mro);
    1670             :     }
    1671        1296 :     if (result == NULL)
    1672           0 :         return -1;
    1673        1296 :     tuple = PySequence_Tuple(result);
    1674        1296 :     Py_DECREF(result);
    1675        1296 :     if (tuple == NULL)
    1676           0 :         return -1;
    1677        1296 :     if (checkit) {
    1678             :         Py_ssize_t i, len;
    1679             :         PyObject *cls;
    1680             :         PyTypeObject *solid;
    1681             : 
    1682          63 :         solid = solid_base(type);
    1683             : 
    1684          63 :         len = PyTuple_GET_SIZE(tuple);
    1685             : 
    1686         324 :         for (i = 0; i < len; i++) {
    1687             :             PyTypeObject *t;
    1688         261 :             cls = PyTuple_GET_ITEM(tuple, i);
    1689         261 :             if (PyClass_Check(cls))
    1690           0 :                 continue;
    1691         261 :             else if (!PyType_Check(cls)) {
    1692           0 :                 PyErr_Format(PyExc_TypeError,
    1693             :                  "mro() returned a non-class ('%.500s')",
    1694           0 :                                  Py_TYPE(cls)->tp_name);
    1695           0 :                 Py_DECREF(tuple);
    1696           0 :                 return -1;
    1697             :             }
    1698         261 :             t = (PyTypeObject*)cls;
    1699         261 :             if (!PyType_IsSubtype(solid, solid_base(t))) {
    1700           0 :                 PyErr_Format(PyExc_TypeError,
    1701             :              "mro() returned base with unsuitable layout ('%.500s')",
    1702             :                                      t->tp_name);
    1703           0 :                         Py_DECREF(tuple);
    1704           0 :                         return -1;
    1705             :             }
    1706             :         }
    1707             :     }
    1708        1296 :     type->tp_mro = tuple;
    1709             : 
    1710        1296 :     type_mro_modified(type, type->tp_mro);
    1711             :     /* corner case: the old-style super class might have been hidden
    1712             :        from the custom MRO */
    1713        1296 :     type_mro_modified(type, type->tp_bases);
    1714             : 
    1715        1296 :     PyType_Modified(type);
    1716             : 
    1717        1296 :     return 0;
    1718             : }
    1719             : 
    1720             : 
    1721             : /* Calculate the best base amongst multiple base classes.
    1722             :    This is the first one that's on the path to the "solid base". */
    1723             : 
    1724             : static PyTypeObject *
    1725         789 : best_base(PyObject *bases)
    1726             : {
    1727             :     Py_ssize_t i, n;
    1728             :     PyTypeObject *base, *winner, *candidate, *base_i;
    1729             :     PyObject *base_proto;
    1730             : 
    1731             :     assert(PyTuple_Check(bases));
    1732         789 :     n = PyTuple_GET_SIZE(bases);
    1733             :     assert(n > 0);
    1734         789 :     base = NULL;
    1735         789 :     winner = NULL;
    1736        1623 :     for (i = 0; i < n; i++) {
    1737         834 :         base_proto = PyTuple_GET_ITEM(bases, i);
    1738         834 :         if (PyClass_Check(base_proto))
    1739           0 :             continue;
    1740         834 :         if (!PyType_Check(base_proto)) {
    1741           0 :             PyErr_SetString(
    1742             :                 PyExc_TypeError,
    1743             :                 "bases must be types");
    1744           0 :             return NULL;
    1745             :         }
    1746         834 :         base_i = (PyTypeObject *)base_proto;
    1747         834 :         if (base_i->tp_dict == NULL) {
    1748           0 :             if (PyType_Ready(base_i) < 0)
    1749           0 :                 return NULL;
    1750             :         }
    1751         834 :         if (!PyType_HasFeature(base_i, Py_TPFLAGS_BASETYPE)) {
    1752           0 :             PyErr_Format(PyExc_TypeError,
    1753             :                          "type '%.100s' is not an acceptable base type",
    1754             :                          base_i->tp_name);
    1755           0 :             return NULL;
    1756             :         }
    1757         834 :         candidate = solid_base(base_i);
    1758         834 :         if (winner == NULL) {
    1759         789 :             winner = candidate;
    1760         789 :             base = base_i;
    1761             :         }
    1762          45 :         else if (PyType_IsSubtype(winner, candidate))
    1763             :             ;
    1764           3 :         else if (PyType_IsSubtype(candidate, winner)) {
    1765           3 :             winner = candidate;
    1766           3 :             base = base_i;
    1767             :         }
    1768             :         else {
    1769           0 :             PyErr_SetString(
    1770             :                 PyExc_TypeError,
    1771             :                 "multiple bases have "
    1772             :                 "instance lay-out conflict");
    1773           0 :             return NULL;
    1774             :         }
    1775             :     }
    1776         789 :     if (base == NULL)
    1777           0 :         PyErr_SetString(PyExc_TypeError,
    1778             :             "a new-style class can't have only classic bases");
    1779         789 :     return base;
    1780             : }
    1781             : 
    1782             : static int
    1783        2952 : extra_ivars(PyTypeObject *type, PyTypeObject *base)
    1784             : {
    1785        2952 :     size_t t_size = type->tp_basicsize;
    1786        2952 :     size_t b_size = base->tp_basicsize;
    1787             : 
    1788             :     assert(t_size >= b_size); /* Else type smaller than base! */
    1789        2952 :     if (type->tp_itemsize || base->tp_itemsize) {
    1790             :         /* If itemsize is involved, stricter rules */
    1791          54 :         return t_size != b_size ||
    1792           6 :             type->tp_itemsize != base->tp_itemsize;
    1793             :     }
    1794        4233 :     if (type->tp_weaklistoffset && base->tp_weaklistoffset == 0 &&
    1795        2658 :         type->tp_weaklistoffset + sizeof(PyObject *) == t_size &&
    1796        1329 :         type->tp_flags & Py_TPFLAGS_HEAPTYPE)
    1797        1254 :         t_size -= sizeof(PyObject *);
    1798        4302 :     if (type->tp_dictoffset && base->tp_dictoffset == 0 &&
    1799        2631 :         type->tp_dictoffset + sizeof(PyObject *) == t_size &&
    1800        1233 :         type->tp_flags & Py_TPFLAGS_HEAPTYPE)
    1801        1233 :         t_size -= sizeof(PyObject *);
    1802             : 
    1803        2904 :     return t_size != b_size;
    1804             : }
    1805             : 
    1806             : static PyTypeObject *
    1807        2952 : solid_base(PyTypeObject *type)
    1808             : {
    1809             :     PyTypeObject *base;
    1810             : 
    1811        2952 :     if (type->tp_base)
    1812        1794 :         base = solid_base(type->tp_base);
    1813             :     else
    1814        1158 :         base = &PyBaseObject_Type;
    1815        2952 :     if (extra_ivars(type, base))
    1816         300 :         return type;
    1817             :     else
    1818        2652 :         return base;
    1819             : }
    1820             : 
    1821             : static void object_dealloc(PyObject *);
    1822             : static int object_init(PyObject *, PyObject *, PyObject *);
    1823             : static int update_slot(PyTypeObject *, PyObject *);
    1824             : static void fixup_slot_dispatchers(PyTypeObject *);
    1825             : 
    1826             : /*
    1827             :  * Helpers for  __dict__ descriptor.  We don't want to expose the dicts
    1828             :  * inherited from various builtin types.  The builtin base usually provides
    1829             :  * its own __dict__ descriptor, so we use that when we can.
    1830             :  */
    1831             : static PyTypeObject *
    1832         706 : get_builtin_base_with_dict(PyTypeObject *type)
    1833             : {
    1834        3805 :     while (type->tp_base != NULL) {
    1835        4786 :         if (type->tp_dictoffset != 0 &&
    1836        2393 :             !(type->tp_flags & Py_TPFLAGS_HEAPTYPE))
    1837           0 :             return type;
    1838        2393 :         type = type->tp_base;
    1839             :     }
    1840         706 :     return NULL;
    1841             : }
    1842             : 
    1843             : static PyObject *
    1844           0 : get_dict_descriptor(PyTypeObject *type)
    1845             : {
    1846             :     static PyObject *dict_str;
    1847             :     PyObject *descr;
    1848             : 
    1849           0 :     if (dict_str == NULL) {
    1850           0 :         dict_str = PyString_InternFromString("__dict__");
    1851           0 :         if (dict_str == NULL)
    1852           0 :             return NULL;
    1853             :     }
    1854           0 :     descr = _PyType_Lookup(type, dict_str);
    1855           0 :     if (descr == NULL || !PyDescr_IsData(descr))
    1856           0 :         return NULL;
    1857             : 
    1858           0 :     return descr;
    1859             : }
    1860             : 
    1861             : static void
    1862           0 : raise_dict_descr_error(PyObject *obj)
    1863             : {
    1864           0 :     PyErr_Format(PyExc_TypeError,
    1865             :                  "this __dict__ descriptor does not support "
    1866           0 :                  "'%.200s' objects", obj->ob_type->tp_name);
    1867           0 : }
    1868             : 
    1869             : static PyObject *
    1870         706 : subtype_dict(PyObject *obj, void *context)
    1871             : {
    1872             :     PyObject **dictptr;
    1873             :     PyObject *dict;
    1874             :     PyTypeObject *base;
    1875             : 
    1876         706 :     base = get_builtin_base_with_dict(obj->ob_type);
    1877         706 :     if (base != NULL) {
    1878             :         descrgetfunc func;
    1879           0 :         PyObject *descr = get_dict_descriptor(base);
    1880           0 :         if (descr == NULL) {
    1881           0 :             raise_dict_descr_error(obj);
    1882           0 :             return NULL;
    1883             :         }
    1884           0 :         func = descr->ob_type->tp_descr_get;
    1885           0 :         if (func == NULL) {
    1886           0 :             raise_dict_descr_error(obj);
    1887           0 :             return NULL;
    1888             :         }
    1889           0 :         return func(descr, obj, (PyObject *)(obj->ob_type));
    1890             :     }
    1891             : 
    1892         706 :     dictptr = _PyObject_GetDictPtr(obj);
    1893         706 :     if (dictptr == NULL) {
    1894           0 :         PyErr_SetString(PyExc_AttributeError,
    1895             :                         "This object has no __dict__");
    1896           0 :         return NULL;
    1897             :     }
    1898         706 :     dict = *dictptr;
    1899         706 :     if (dict == NULL)
    1900         155 :         *dictptr = dict = PyDict_New();
    1901         706 :     Py_XINCREF(dict);
    1902         706 :     return dict;
    1903             : }
    1904             : 
    1905             : static int
    1906           0 : subtype_setdict(PyObject *obj, PyObject *value, void *context)
    1907             : {
    1908             :     PyObject **dictptr;
    1909             :     PyObject *dict;
    1910             :     PyTypeObject *base;
    1911             : 
    1912           0 :     base = get_builtin_base_with_dict(obj->ob_type);
    1913           0 :     if (base != NULL) {
    1914             :         descrsetfunc func;
    1915           0 :         PyObject *descr = get_dict_descriptor(base);
    1916           0 :         if (descr == NULL) {
    1917           0 :             raise_dict_descr_error(obj);
    1918           0 :             return -1;
    1919             :         }
    1920           0 :         func = descr->ob_type->tp_descr_set;
    1921           0 :         if (func == NULL) {
    1922           0 :             raise_dict_descr_error(obj);
    1923           0 :             return -1;
    1924             :         }
    1925           0 :         return func(descr, obj, value);
    1926             :     }
    1927             : 
    1928           0 :     dictptr = _PyObject_GetDictPtr(obj);
    1929           0 :     if (dictptr == NULL) {
    1930           0 :         PyErr_SetString(PyExc_AttributeError,
    1931             :                         "This object has no __dict__");
    1932           0 :         return -1;
    1933             :     }
    1934           0 :     if (value != NULL && !PyDict_Check(value)) {
    1935           0 :         PyErr_Format(PyExc_TypeError,
    1936             :                      "__dict__ must be set to a dictionary, "
    1937           0 :                      "not a '%.200s'", Py_TYPE(value)->tp_name);
    1938           0 :         return -1;
    1939             :     }
    1940           0 :     dict = *dictptr;
    1941           0 :     Py_XINCREF(value);
    1942           0 :     *dictptr = value;
    1943           0 :     Py_XDECREF(dict);
    1944           0 :     return 0;
    1945             : }
    1946             : 
    1947             : static PyObject *
    1948           0 : subtype_getweakref(PyObject *obj, void *context)
    1949             : {
    1950             :     PyObject **weaklistptr;
    1951             :     PyObject *result;
    1952             : 
    1953           0 :     if (Py_TYPE(obj)->tp_weaklistoffset == 0) {
    1954           0 :         PyErr_SetString(PyExc_AttributeError,
    1955             :                         "This object has no __weakref__");
    1956           0 :         return NULL;
    1957             :     }
    1958             :     assert(Py_TYPE(obj)->tp_weaklistoffset > 0);
    1959             :     assert(Py_TYPE(obj)->tp_weaklistoffset + sizeof(PyObject *) <=
    1960             :            (size_t)(Py_TYPE(obj)->tp_basicsize));
    1961           0 :     weaklistptr = (PyObject **)
    1962           0 :         ((char *)obj + Py_TYPE(obj)->tp_weaklistoffset);
    1963           0 :     if (*weaklistptr == NULL)
    1964           0 :         result = Py_None;
    1965             :     else
    1966           0 :         result = *weaklistptr;
    1967           0 :     Py_INCREF(result);
    1968           0 :     return result;
    1969             : }
    1970             : 
    1971             : /* Three variants on the subtype_getsets list. */
    1972             : 
    1973             : static PyGetSetDef subtype_getsets_full[] = {
    1974             :     {"__dict__", subtype_dict, subtype_setdict,
    1975             :      PyDoc_STR("dictionary for instance variables (if defined)")},
    1976             :     {"__weakref__", subtype_getweakref, NULL,
    1977             :      PyDoc_STR("list of weak references to the object (if defined)")},
    1978             :     {0}
    1979             : };
    1980             : 
    1981             : static PyGetSetDef subtype_getsets_dict_only[] = {
    1982             :     {"__dict__", subtype_dict, subtype_setdict,
    1983             :      PyDoc_STR("dictionary for instance variables (if defined)")},
    1984             :     {0}
    1985             : };
    1986             : 
    1987             : static PyGetSetDef subtype_getsets_weakref_only[] = {
    1988             :     {"__weakref__", subtype_getweakref, NULL,
    1989             :      PyDoc_STR("list of weak references to the object (if defined)")},
    1990             :     {0}
    1991             : };
    1992             : 
    1993             : static int
    1994           3 : valid_identifier(PyObject *s)
    1995             : {
    1996             :     unsigned char *p;
    1997             :     Py_ssize_t i, n;
    1998             : 
    1999           3 :     if (!PyString_Check(s)) {
    2000           0 :         PyErr_Format(PyExc_TypeError,
    2001             :                      "__slots__ items must be strings, not '%.200s'",
    2002           0 :                      Py_TYPE(s)->tp_name);
    2003           0 :         return 0;
    2004             :     }
    2005           3 :     p = (unsigned char *) PyString_AS_STRING(s);
    2006           3 :     n = PyString_GET_SIZE(s);
    2007             :     /* We must reject an empty name.  As a hack, we bump the
    2008             :        length to 1 so that the loop will balk on the trailing \0. */
    2009           3 :     if (n == 0)
    2010           0 :         n = 1;
    2011          12 :     for (i = 0; i < n; i++, p++) {
    2012           9 :         if (!(i == 0 ? isalpha(*p) : isalnum(*p)) && *p != '_') {
    2013           0 :             PyErr_SetString(PyExc_TypeError,
    2014             :                             "__slots__ must be identifiers");
    2015           0 :             return 0;
    2016             :         }
    2017             :     }
    2018           3 :     return 1;
    2019             : }
    2020             : 
    2021             : #ifdef Py_USING_UNICODE
    2022             : /* Replace Unicode objects in slots.  */
    2023             : 
    2024             : static PyObject *
    2025          36 : _unicode_to_string(PyObject *slots, Py_ssize_t nslots)
    2026             : {
    2027          36 :     PyObject *tmp = NULL;
    2028             :     PyObject *slot_name, *new_name;
    2029             :     Py_ssize_t i;
    2030             : 
    2031          39 :     for (i = 0; i < nslots; i++) {
    2032           3 :         if (PyUnicode_Check(slot_name = PyTuple_GET_ITEM(slots, i))) {
    2033           0 :             if (tmp == NULL) {
    2034           0 :                 tmp = PySequence_List(slots);
    2035           0 :                 if (tmp == NULL)
    2036           0 :                     return NULL;
    2037             :             }
    2038           0 :             new_name = _PyUnicode_AsDefaultEncodedString(slot_name,
    2039             :                                                          NULL);
    2040           0 :             if (new_name == NULL) {
    2041           0 :                 Py_DECREF(tmp);
    2042           0 :                 return NULL;
    2043             :             }
    2044           0 :             Py_INCREF(new_name);
    2045           0 :             PyList_SET_ITEM(tmp, i, new_name);
    2046           0 :             Py_DECREF(slot_name);
    2047             :         }
    2048             :     }
    2049          36 :     if (tmp != NULL) {
    2050           0 :         slots = PyList_AsTuple(tmp);
    2051           0 :         Py_DECREF(tmp);
    2052             :     }
    2053          36 :     return slots;
    2054             : }
    2055             : #endif
    2056             : 
    2057             : /* Forward */
    2058             : static int
    2059             : object_init(PyObject *self, PyObject *args, PyObject *kwds);
    2060             : 
    2061             : static int
    2062         789 : type_init(PyObject *cls, PyObject *args, PyObject *kwds)
    2063             : {
    2064             :     int res;
    2065             : 
    2066             :     assert(args != NULL && PyTuple_Check(args));
    2067             :     assert(kwds == NULL || PyDict_Check(kwds));
    2068             : 
    2069         789 :     if (kwds != NULL && PyDict_Check(kwds) && PyDict_Size(kwds) != 0) {
    2070           0 :         PyErr_SetString(PyExc_TypeError,
    2071             :                         "type.__init__() takes no keyword arguments");
    2072           0 :         return -1;
    2073             :     }
    2074             : 
    2075        1578 :     if (args != NULL && PyTuple_Check(args) &&
    2076        1578 :         (PyTuple_GET_SIZE(args) != 1 && PyTuple_GET_SIZE(args) != 3)) {
    2077           0 :         PyErr_SetString(PyExc_TypeError,
    2078             :                         "type.__init__() takes 1 or 3 arguments");
    2079           0 :         return -1;
    2080             :     }
    2081             : 
    2082             :     /* Call object.__init__(self) now. */
    2083             :     /* XXX Could call super(type, cls).__init__() but what's the point? */
    2084         789 :     args = PyTuple_GetSlice(args, 0, 0);
    2085         789 :     res = object_init(cls, args, NULL);
    2086         789 :     Py_DECREF(args);
    2087         789 :     return res;
    2088             : }
    2089             : 
    2090             : static PyObject *
    2091        3501 : type_new(PyTypeObject *metatype, PyObject *args, PyObject *kwds)
    2092             : {
    2093             :     PyObject *name, *bases, *dict;
    2094             :     static char *kwlist[] = {"name", "bases", "dict", 0};
    2095             :     PyObject *slots, *tmp, *newslots;
    2096             :     PyTypeObject *type, *base, *tmptype, *winner;
    2097             :     PyHeapTypeObject *et;
    2098             :     PyMemberDef *mp;
    2099             :     Py_ssize_t i, nbases, nslots, slotoffset;
    2100             :     int j, may_add_dict, may_add_weak, add_dict, add_weak;
    2101             : 
    2102             :     assert(args != NULL && PyTuple_Check(args));
    2103             :     assert(kwds == NULL || PyDict_Check(kwds));
    2104             : 
    2105             :     /* Special case: type(x) should return x->ob_type */
    2106             :     {
    2107        3501 :         const Py_ssize_t nargs = PyTuple_GET_SIZE(args);
    2108        3501 :         const Py_ssize_t nkwds = kwds == NULL ? 0 : PyDict_Size(kwds);
    2109             : 
    2110        3501 :         if (PyType_CheckExact(metatype) && nargs == 1 && nkwds == 0) {
    2111        2703 :             PyObject *x = PyTuple_GET_ITEM(args, 0);
    2112        2703 :             Py_INCREF(Py_TYPE(x));
    2113        2703 :             return (PyObject *) Py_TYPE(x);
    2114             :         }
    2115             : 
    2116             :         /* SF bug 475327 -- if that didn't trigger, we need 3
    2117             :            arguments. but PyArg_ParseTupleAndKeywords below may give
    2118             :            a msg saying type() needs exactly 3. */
    2119         798 :         if (nargs + nkwds != 3) {
    2120           0 :             PyErr_SetString(PyExc_TypeError,
    2121             :                             "type() takes 1 or 3 arguments");
    2122           0 :             return NULL;
    2123             :         }
    2124             :     }
    2125             : 
    2126             :     /* Check arguments: (name, bases, dict) */
    2127         798 :     if (!PyArg_ParseTupleAndKeywords(args, kwds, "SO!O!:type", kwlist,
    2128             :                                      &name,
    2129             :                                      &PyTuple_Type, &bases,
    2130             :                                      &PyDict_Type, &dict))
    2131           0 :         return NULL;
    2132             : 
    2133             :     /* Determine the proper metatype to deal with this,
    2134             :        and check for metatype conflicts while we're at it.
    2135             :        Note that if some other metatype wins to contract,
    2136             :        it's possible that its instances are not types. */
    2137         798 :     nbases = PyTuple_GET_SIZE(bases);
    2138         798 :     winner = metatype;
    2139        1590 :     for (i = 0; i < nbases; i++) {
    2140         792 :         tmp = PyTuple_GET_ITEM(bases, i);
    2141         792 :         tmptype = tmp->ob_type;
    2142         792 :         if (tmptype == &PyClass_Type)
    2143           0 :             continue; /* Special case classic classes */
    2144         792 :         if (PyType_IsSubtype(winner, tmptype))
    2145         783 :             continue;
    2146           9 :         if (PyType_IsSubtype(tmptype, winner)) {
    2147           9 :             winner = tmptype;
    2148           9 :             continue;
    2149             :         }
    2150           0 :         PyErr_SetString(PyExc_TypeError,
    2151             :                         "metaclass conflict: "
    2152             :                         "the metaclass of a derived class "
    2153             :                         "must be a (non-strict) subclass "
    2154             :                         "of the metaclasses of all its bases");
    2155           0 :         return NULL;
    2156             :     }
    2157         798 :     if (winner != metatype) {
    2158           9 :         if (winner->tp_new != type_new) /* Pass it to the winner */
    2159           9 :             return winner->tp_new(winner, args, kwds);
    2160           0 :         metatype = winner;
    2161             :     }
    2162             : 
    2163             :     /* Adjust for empty tuple bases */
    2164         789 :     if (nbases == 0) {
    2165          60 :         bases = PyTuple_Pack(1, &PyBaseObject_Type);
    2166          60 :         if (bases == NULL)
    2167           0 :             return NULL;
    2168          60 :         nbases = 1;
    2169             :     }
    2170             :     else
    2171         729 :         Py_INCREF(bases);
    2172             : 
    2173             :     /* XXX From here until type is allocated, "return NULL" leaks bases! */
    2174             : 
    2175             :     /* Calculate best base, and check that all bases are type objects */
    2176         789 :     base = best_base(bases);
    2177         789 :     if (base == NULL) {
    2178           0 :         Py_DECREF(bases);
    2179           0 :         return NULL;
    2180             :     }
    2181             : 
    2182             :     /* Check for a __slots__ sequence variable in dict, and count it */
    2183         789 :     slots = PyDict_GetItemString(dict, "__slots__");
    2184         789 :     nslots = 0;
    2185         789 :     add_dict = 0;
    2186         789 :     add_weak = 0;
    2187         789 :     may_add_dict = base->tp_dictoffset == 0;
    2188         789 :     may_add_weak = base->tp_weaklistoffset == 0 && base->tp_itemsize == 0;
    2189         789 :     if (slots == NULL) {
    2190         753 :         if (may_add_dict) {
    2191         249 :             add_dict++;
    2192             :         }
    2193         753 :         if (may_add_weak) {
    2194         315 :             add_weak++;
    2195             :         }
    2196             :     }
    2197             :     else {
    2198             :         /* Have slots */
    2199             : 
    2200             :         /* Make it into a tuple */
    2201          36 :         if (PyString_Check(slots) || PyUnicode_Check(slots))
    2202           0 :             slots = PyTuple_Pack(1, slots);
    2203             :         else
    2204          36 :             slots = PySequence_Tuple(slots);
    2205          36 :         if (slots == NULL) {
    2206           0 :             Py_DECREF(bases);
    2207           0 :             return NULL;
    2208             :         }
    2209             :         assert(PyTuple_Check(slots));
    2210             : 
    2211             :         /* Are slots allowed? */
    2212          36 :         nslots = PyTuple_GET_SIZE(slots);
    2213          36 :         if (nslots > 0 && base->tp_itemsize != 0) {
    2214           0 :             PyErr_Format(PyExc_TypeError,
    2215             :                          "nonempty __slots__ "
    2216             :                          "not supported for subtype of '%s'",
    2217             :                          base->tp_name);
    2218             :           bad_slots:
    2219           0 :             Py_DECREF(bases);
    2220           0 :             Py_DECREF(slots);
    2221           0 :             return NULL;
    2222             :         }
    2223             : 
    2224             : #ifdef Py_USING_UNICODE
    2225          36 :         tmp = _unicode_to_string(slots, nslots);
    2226          36 :         if (tmp == NULL)
    2227           0 :             goto bad_slots;
    2228          36 :         if (tmp != slots) {
    2229           0 :             Py_DECREF(slots);
    2230           0 :             slots = tmp;
    2231             :         }
    2232             : #endif
    2233             :         /* Check for valid slot names and two special cases */
    2234          39 :         for (i = 0; i < nslots; i++) {
    2235           3 :             PyObject *tmp = PyTuple_GET_ITEM(slots, i);
    2236             :             char *s;
    2237           3 :             if (!valid_identifier(tmp))
    2238           0 :                 goto bad_slots;
    2239             :             assert(PyString_Check(tmp));
    2240           3 :             s = PyString_AS_STRING(tmp);
    2241           3 :             if (strcmp(s, "__dict__") == 0) {
    2242           0 :                 if (!may_add_dict || add_dict) {
    2243           0 :                     PyErr_SetString(PyExc_TypeError,
    2244             :                         "__dict__ slot disallowed: "
    2245             :                         "we already got one");
    2246           0 :                     goto bad_slots;
    2247             :                 }
    2248           0 :                 add_dict++;
    2249             :             }
    2250           3 :             if (strcmp(s, "__weakref__") == 0) {
    2251           0 :                 if (!may_add_weak || add_weak) {
    2252           0 :                     PyErr_SetString(PyExc_TypeError,
    2253             :                         "__weakref__ slot disallowed: "
    2254             :                         "either we already got one, "
    2255             :                         "or __itemsize__ != 0");
    2256           0 :                     goto bad_slots;
    2257             :                 }
    2258           0 :                 add_weak++;
    2259             :             }
    2260             :         }
    2261             : 
    2262             :         /* Copy slots into a list, mangle names and sort them.
    2263             :            Sorted names are needed for __class__ assignment.
    2264             :            Convert them back to tuple at the end.
    2265             :         */
    2266          36 :         newslots = PyList_New(nslots - add_dict - add_weak);
    2267          36 :         if (newslots == NULL)
    2268           0 :             goto bad_slots;
    2269          39 :         for (i = j = 0; i < nslots; i++) {
    2270             :             char *s;
    2271           3 :             tmp = PyTuple_GET_ITEM(slots, i);
    2272           3 :             s = PyString_AS_STRING(tmp);
    2273           3 :             if ((add_dict && strcmp(s, "__dict__") == 0) ||
    2274           0 :                 (add_weak && strcmp(s, "__weakref__") == 0))
    2275           0 :                 continue;
    2276           3 :             tmp =_Py_Mangle(name, tmp);
    2277           3 :             if (!tmp) {
    2278           0 :                 Py_DECREF(newslots);
    2279           0 :                 goto bad_slots;
    2280             :             }
    2281           3 :             PyList_SET_ITEM(newslots, j, tmp);
    2282           3 :             j++;
    2283             :         }
    2284             :         assert(j == nslots - add_dict - add_weak);
    2285          36 :         nslots = j;
    2286          36 :         Py_DECREF(slots);
    2287          36 :         if (PyList_Sort(newslots) == -1) {
    2288           0 :             Py_DECREF(bases);
    2289           0 :             Py_DECREF(newslots);
    2290           0 :             return NULL;
    2291             :         }
    2292          36 :         slots = PyList_AsTuple(newslots);
    2293          36 :         Py_DECREF(newslots);
    2294          36 :         if (slots == NULL) {
    2295           0 :             Py_DECREF(bases);
    2296           0 :             return NULL;
    2297             :         }
    2298             : 
    2299             :         /* Secondary bases may provide weakrefs or dict */
    2300          36 :         if (nbases > 1 &&
    2301           6 :             ((may_add_dict && !add_dict) ||
    2302           0 :              (may_add_weak && !add_weak))) {
    2303          12 :             for (i = 0; i < nbases; i++) {
    2304          12 :                 tmp = PyTuple_GET_ITEM(bases, i);
    2305          12 :                 if (tmp == (PyObject *)base)
    2306           6 :                     continue; /* Skip primary base */
    2307           6 :                 if (PyClass_Check(tmp)) {
    2308             :                     /* Classic base class provides both */
    2309           0 :                     if (may_add_dict && !add_dict)
    2310           0 :                         add_dict++;
    2311           0 :                     if (may_add_weak && !add_weak)
    2312           0 :                         add_weak++;
    2313           0 :                     break;
    2314             :                 }
    2315             :                 assert(PyType_Check(tmp));
    2316           6 :                 tmptype = (PyTypeObject *)tmp;
    2317          12 :                 if (may_add_dict && !add_dict &&
    2318           6 :                     tmptype->tp_dictoffset != 0)
    2319           6 :                     add_dict++;
    2320           6 :                 if (may_add_weak && !add_weak &&
    2321           0 :                     tmptype->tp_weaklistoffset != 0)
    2322           0 :                     add_weak++;
    2323           6 :                 if (may_add_dict && !add_dict)
    2324           0 :                     continue;
    2325           6 :                 if (may_add_weak && !add_weak)
    2326           0 :                     continue;
    2327             :                 /* Nothing more to check */
    2328           6 :                 break;
    2329             :             }
    2330             :         }
    2331             :     }
    2332             : 
    2333             :     /* XXX From here until type is safely allocated,
    2334             :        "return NULL" may leak slots! */
    2335             : 
    2336             :     /* Allocate the type object */
    2337         789 :     type = (PyTypeObject *)metatype->tp_alloc(metatype, nslots);
    2338         789 :     if (type == NULL) {
    2339           0 :         Py_XDECREF(slots);
    2340           0 :         Py_DECREF(bases);
    2341           0 :         return NULL;
    2342             :     }
    2343             : 
    2344             :     /* Keep name and slots alive in the extended type object */
    2345         789 :     et = (PyHeapTypeObject *)type;
    2346         789 :     Py_INCREF(name);
    2347         789 :     et->ht_name = name;
    2348         789 :     et->ht_slots = slots;
    2349             : 
    2350             :     /* Initialize tp_flags */
    2351         789 :     type->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HEAPTYPE |
    2352             :         Py_TPFLAGS_BASETYPE;
    2353         789 :     if (base->tp_flags & Py_TPFLAGS_HAVE_GC)
    2354         552 :         type->tp_flags |= Py_TPFLAGS_HAVE_GC;
    2355         789 :     if (base->tp_flags & Py_TPFLAGS_HAVE_NEWBUFFER)
    2356           0 :         type->tp_flags |= Py_TPFLAGS_HAVE_NEWBUFFER;
    2357             : 
    2358             :     /* It's a new-style number unless it specifically inherits any
    2359             :        old-style numeric behavior */
    2360        1155 :     if ((base->tp_flags & Py_TPFLAGS_CHECKTYPES) ||
    2361         366 :         (base->tp_as_number == NULL))
    2362         789 :         type->tp_flags |= Py_TPFLAGS_CHECKTYPES;
    2363             : 
    2364             :     /* Initialize essential fields */
    2365         789 :     type->tp_as_number = &et->as_number;
    2366         789 :     type->tp_as_sequence = &et->as_sequence;
    2367         789 :     type->tp_as_mapping = &et->as_mapping;
    2368         789 :     type->tp_as_buffer = &et->as_buffer;
    2369         789 :     type->tp_name = PyString_AS_STRING(name);
    2370         789 :     if (!type->tp_name) {
    2371           0 :         Py_DECREF(bases);
    2372           0 :         Py_DECREF(type);
    2373           0 :         return NULL;
    2374             :     }
    2375         789 :     if (strlen(type->tp_name) != (size_t)PyString_GET_SIZE(name)) {
    2376           0 :         PyErr_SetString(PyExc_ValueError,
    2377             :                         "type name must not contain null characters");
    2378           0 :         Py_DECREF(bases);
    2379           0 :         Py_DECREF(type);
    2380           0 :         return NULL;
    2381             :     }
    2382             : 
    2383             :     /* Set tp_base and tp_bases */
    2384         789 :     type->tp_bases = bases;
    2385         789 :     Py_INCREF(base);
    2386         789 :     type->tp_base = base;
    2387             : 
    2388             :     /* Initialize tp_dict from passed-in dict */
    2389         789 :     type->tp_dict = dict = PyDict_Copy(dict);
    2390         789 :     if (dict == NULL) {
    2391           0 :         Py_DECREF(type);
    2392           0 :         return NULL;
    2393             :     }
    2394             : 
    2395             :     /* Set __module__ in the dict */
    2396         789 :     if (PyDict_GetItemString(dict, "__module__") == NULL) {
    2397         333 :         tmp = PyEval_GetGlobals();
    2398         333 :         if (tmp != NULL) {
    2399         333 :             tmp = PyDict_GetItemString(tmp, "__name__");
    2400         333 :             if (tmp != NULL) {
    2401         333 :                 if (PyDict_SetItemString(dict, "__module__",
    2402             :                                          tmp) < 0) {
    2403           0 :                     Py_DECREF(type);
    2404           0 :                     return NULL;
    2405             :                 }
    2406             :             }
    2407             :         }
    2408             :     }
    2409             : 
    2410             :     /* Set tp_doc to a copy of dict['__doc__'], if the latter is there
    2411             :        and is a string.  The __doc__ accessor will first look for tp_doc;
    2412             :        if that fails, it will still look into __dict__.
    2413             :     */
    2414             :     {
    2415         789 :         PyObject *doc = PyDict_GetItemString(dict, "__doc__");
    2416         789 :         if (doc != NULL && PyString_Check(doc)) {
    2417         276 :             const size_t n = (size_t)PyString_GET_SIZE(doc);
    2418         276 :             char *tp_doc = (char *)PyObject_MALLOC(n+1);
    2419         276 :             if (tp_doc == NULL) {
    2420           0 :                 Py_DECREF(type);
    2421           0 :                 return NULL;
    2422             :             }
    2423         276 :             memcpy(tp_doc, PyString_AS_STRING(doc), n+1);
    2424         276 :             type->tp_doc = tp_doc;
    2425             :         }
    2426             :     }
    2427             : 
    2428             :     /* Special-case __new__: if it's a plain function,
    2429             :        make it a static function */
    2430         789 :     tmp = PyDict_GetItemString(dict, "__new__");
    2431         789 :     if (tmp != NULL && PyFunction_Check(tmp)) {
    2432          36 :         tmp = PyStaticMethod_New(tmp);
    2433          36 :         if (tmp == NULL) {
    2434           0 :             Py_DECREF(type);
    2435           0 :             return NULL;
    2436             :         }
    2437          36 :         if (PyDict_SetItemString(dict, "__new__", tmp) < 0) {
    2438           0 :             Py_DECREF(tmp);
    2439           0 :             Py_DECREF(type);
    2440           0 :             return NULL;
    2441             :         }
    2442          36 :         Py_DECREF(tmp);
    2443             :     }
    2444             : 
    2445             :     /* Add descriptors for custom slots from __slots__, or for __dict__ */
    2446         789 :     mp = PyHeapType_GET_MEMBERS(et);
    2447         789 :     slotoffset = base->tp_basicsize;
    2448         789 :     if (slots != NULL) {
    2449          39 :         for (i = 0; i < nslots; i++, mp++) {
    2450           3 :             mp->name = PyString_AS_STRING(
    2451             :                 PyTuple_GET_ITEM(slots, i));
    2452           3 :             mp->type = T_OBJECT_EX;
    2453           3 :             mp->offset = slotoffset;
    2454             : 
    2455             :             /* __dict__ and __weakref__ are already filtered out */
    2456             :             assert(strcmp(mp->name, "__dict__") != 0);
    2457             :             assert(strcmp(mp->name, "__weakref__") != 0);
    2458             : 
    2459           3 :             slotoffset += sizeof(PyObject *);
    2460             :         }
    2461             :     }
    2462         789 :     if (add_dict) {
    2463         255 :         if (base->tp_itemsize)
    2464           9 :             type->tp_dictoffset = -(long)sizeof(PyObject *);
    2465             :         else
    2466         246 :             type->tp_dictoffset = slotoffset;
    2467         255 :         slotoffset += sizeof(PyObject *);
    2468             :     }
    2469         789 :     if (add_weak) {
    2470             :         assert(!base->tp_itemsize);
    2471         315 :         type->tp_weaklistoffset = slotoffset;
    2472         315 :         slotoffset += sizeof(PyObject *);
    2473             :     }
    2474         789 :     type->tp_basicsize = slotoffset;
    2475         789 :     type->tp_itemsize = base->tp_itemsize;
    2476         789 :     type->tp_members = PyHeapType_GET_MEMBERS(et);
    2477             : 
    2478         789 :     if (type->tp_weaklistoffset && type->tp_dictoffset)
    2479         246 :         type->tp_getset = subtype_getsets_full;
    2480         543 :     else if (type->tp_weaklistoffset && !type->tp_dictoffset)
    2481          69 :         type->tp_getset = subtype_getsets_weakref_only;
    2482         474 :     else if (!type->tp_weaklistoffset && type->tp_dictoffset)
    2483           9 :         type->tp_getset = subtype_getsets_dict_only;
    2484             :     else
    2485         465 :         type->tp_getset = NULL;
    2486             : 
    2487             :     /* Special case some slots */
    2488         789 :     if (type->tp_dictoffset != 0 || nslots > 0) {
    2489         258 :         if (base->tp_getattr == NULL && base->tp_getattro == NULL)
    2490           0 :             type->tp_getattro = PyObject_GenericGetAttr;
    2491         258 :         if (base->tp_setattr == NULL && base->tp_setattro == NULL)
    2492           0 :             type->tp_setattro = PyObject_GenericSetAttr;
    2493             :     }
    2494         789 :     type->tp_dealloc = subtype_dealloc;
    2495             : 
    2496             :     /* Enable GC unless there are really no instance variables possible */
    2497         789 :     if (!(type->tp_basicsize == sizeof(PyObject) &&
    2498           0 :           type->tp_itemsize == 0))
    2499         789 :         type->tp_flags |= Py_TPFLAGS_HAVE_GC;
    2500             : 
    2501             :     /* Always override allocation strategy to use regular heap */
    2502         789 :     type->tp_alloc = PyType_GenericAlloc;
    2503         789 :     if (type->tp_flags & Py_TPFLAGS_HAVE_GC) {
    2504         789 :         type->tp_free = PyObject_GC_Del;
    2505         789 :         type->tp_traverse = subtype_traverse;
    2506         789 :         type->tp_clear = subtype_clear;
    2507             :     }
    2508             :     else
    2509           0 :         type->tp_free = PyObject_Del;
    2510             : 
    2511             :     /* Initialize the rest */
    2512         789 :     if (PyType_Ready(type) < 0) {
    2513           0 :         Py_DECREF(type);
    2514           0 :         return NULL;
    2515             :     }
    2516             : 
    2517             :     /* Put the proper slots in place */
    2518         789 :     fixup_slot_dispatchers(type);
    2519             : 
    2520         789 :     return (PyObject *)type;
    2521             : }
    2522             : 
    2523             : /* Internal API to look for a name through the MRO.
    2524             :    This returns a borrowed reference, and doesn't set an exception! */
    2525             : PyObject *
    2526      223131 : _PyType_Lookup(PyTypeObject *type, PyObject *name)
    2527             : {
    2528             :     Py_ssize_t i, n;
    2529             :     PyObject *mro, *res, *base, *dict;
    2530             :     unsigned int h;
    2531             : 
    2532      446262 :     if (MCACHE_CACHEABLE_NAME(name) &&
    2533      223131 :         PyType_HasFeature(type, Py_TPFLAGS_VALID_VERSION_TAG)) {
    2534             :         /* fast path */
    2535      219129 :         h = MCACHE_HASH_METHOD(type, name);
    2536      366474 :         if (method_cache[h].version == type->tp_version_tag &&
    2537      147345 :             method_cache[h].name == name) {
    2538             : #if MCACHE_STATS
    2539             :             method_cache_hits++;
    2540             : #endif
    2541      146310 :             return method_cache[h].value;
    2542             :         }
    2543             :     }
    2544             : 
    2545             :     /* Look in tp_dict of types in MRO */
    2546       76821 :     mro = type->tp_mro;
    2547             : 
    2548       76821 :     if (mro == NULL) {
    2549           0 :         if ((type->tp_flags & Py_TPFLAGS_READYING) == 0 &&
    2550           0 :             PyType_Ready(type) < 0) {
    2551             :             /* It's not ideal to clear the error condition,
    2552             :                but this function is documented as not setting
    2553             :                an exception, and I don't want to change that.
    2554             :                When PyType_Ready() can't proceed, it won't
    2555             :                set the "ready" flag, so future attempts to ready
    2556             :                the same type will call it again -- hopefully
    2557             :                in a context that propagates the exception out.
    2558             :             */
    2559           0 :             PyErr_Clear();
    2560           0 :             return NULL;
    2561             :         }
    2562           0 :         mro = type->tp_mro;
    2563           0 :         if (mro == NULL) {
    2564           0 :             return NULL;
    2565             :         }
    2566             :     }
    2567             : 
    2568       76821 :     res = NULL;
    2569             :     assert(PyTuple_Check(mro));
    2570       76821 :     n = PyTuple_GET_SIZE(mro);
    2571      323509 :     for (i = 0; i < n; i++) {
    2572      258640 :         base = PyTuple_GET_ITEM(mro, i);
    2573      258640 :         if (PyClass_Check(base))
    2574           0 :             dict = ((PyClassObject *)base)->cl_dict;
    2575             :         else {
    2576             :             assert(PyType_Check(base));
    2577      258640 :             dict = ((PyTypeObject *)base)->tp_dict;
    2578             :         }
    2579             :         assert(dict && PyDict_Check(dict));
    2580      258640 :         res = PyDict_GetItem(dict, name);
    2581      258640 :         if (res != NULL)
    2582       11952 :             break;
    2583             :     }
    2584             : 
    2585       76821 :     if (MCACHE_CACHEABLE_NAME(name) && assign_version_tag(type)) {
    2586       74451 :         h = MCACHE_HASH_METHOD(type, name);
    2587       74451 :         method_cache[h].version = type->tp_version_tag;
    2588       74451 :         method_cache[h].value = res;  /* borrowed */
    2589       74451 :         Py_INCREF(name);
    2590             :         assert(((PyStringObject *)(name))->ob_shash != -1);
    2591             : #if MCACHE_STATS
    2592             :         if (method_cache[h].name != Py_None && method_cache[h].name != name)
    2593             :             method_cache_collisions++;
    2594             :         else
    2595             :             method_cache_misses++;
    2596             : #endif
    2597       74451 :         Py_DECREF(method_cache[h].name);
    2598       74451 :         method_cache[h].name = name;
    2599             :     }
    2600       76821 :     return res;
    2601             : }
    2602             : 
    2603             : /* This is similar to PyObject_GenericGetAttr(),
    2604             :    but uses _PyType_Lookup() instead of just looking in type->tp_dict. */
    2605             : static PyObject *
    2606        8472 : type_getattro(PyTypeObject *type, PyObject *name)
    2607             : {
    2608        8472 :     PyTypeObject *metatype = Py_TYPE(type);
    2609             :     PyObject *meta_attribute, *attribute;
    2610             :     descrgetfunc meta_get;
    2611             : 
    2612        8472 :     if (!PyString_Check(name)) {
    2613           0 :         PyErr_Format(PyExc_TypeError,
    2614             :                      "attribute name must be string, not '%.200s'",
    2615           0 :                      name->ob_type->tp_name);
    2616           0 :         return NULL;
    2617             :     }
    2618             : 
    2619             :     /* Initialize this type (we'll assume the metatype is initialized) */
    2620        8472 :     if (type->tp_dict == NULL) {
    2621           9 :         if (PyType_Ready(type) < 0)
    2622           0 :             return NULL;
    2623             :     }
    2624             : 
    2625             :     /* No readable descriptor found yet */
    2626        8472 :     meta_get = NULL;
    2627             : 
    2628             :     /* Look for the attribute in the metatype */
    2629        8472 :     meta_attribute = _PyType_Lookup(metatype, name);
    2630             : 
    2631        8472 :     if (meta_attribute != NULL) {
    2632        5727 :         meta_get = Py_TYPE(meta_attribute)->tp_descr_get;
    2633             : 
    2634        5727 :         if (meta_get != NULL && PyDescr_IsData(meta_attribute)) {
    2635             :             /* Data descriptors implement tp_descr_set to intercept
    2636             :              * writes. Assume the attribute is not overridden in
    2637             :              * type's tp_dict (and bases): call the descriptor now.
    2638             :              */
    2639         612 :             return meta_get(meta_attribute, (PyObject *)type,
    2640             :                             (PyObject *)metatype);
    2641             :         }
    2642        5115 :         Py_INCREF(meta_attribute);
    2643             :     }
    2644             : 
    2645             :     /* No data descriptor found on metatype. Look in tp_dict of this
    2646             :      * type and its bases */
    2647        7860 :     attribute = _PyType_Lookup(type, name);
    2648        7860 :     if (attribute != NULL) {
    2649             :         /* Implement descriptor functionality, if any */
    2650        7713 :         descrgetfunc local_get = Py_TYPE(attribute)->tp_descr_get;
    2651             : 
    2652        7713 :         Py_XDECREF(meta_attribute);
    2653             : 
    2654        7713 :         if (local_get != NULL) {
    2655             :             /* NULL 2nd argument indicates the descriptor was
    2656             :              * found on the target object itself (or a base)  */
    2657        2634 :             return local_get(attribute, (PyObject *)NULL,
    2658             :                              (PyObject *)type);
    2659             :         }
    2660             : 
    2661        5079 :         Py_INCREF(attribute);
    2662        5079 :         return attribute;
    2663             :     }
    2664             : 
    2665             :     /* No attribute found in local __dict__ (or bases): use the
    2666             :      * descriptor from the metatype, if any */
    2667         147 :     if (meta_get != NULL) {
    2668             :         PyObject *res;
    2669         129 :         res = meta_get(meta_attribute, (PyObject *)type,
    2670             :                        (PyObject *)metatype);
    2671         129 :         Py_DECREF(meta_attribute);
    2672         129 :         return res;
    2673             :     }
    2674             : 
    2675             :     /* If an ordinary attribute was found on the metatype, return it now */
    2676          18 :     if (meta_attribute != NULL) {
    2677           0 :         return meta_attribute;
    2678             :     }
    2679             : 
    2680             :     /* Give up */
    2681          18 :     PyErr_Format(PyExc_AttributeError,
    2682             :                      "type object '%.50s' has no attribute '%.400s'",
    2683          18 :                      type->tp_name, PyString_AS_STRING(name));
    2684          18 :     return NULL;
    2685             : }
    2686             : 
    2687             : static int
    2688        1200 : type_setattro(PyTypeObject *type, PyObject *name, PyObject *value)
    2689             : {
    2690        1200 :     if (!(type->tp_flags & Py_TPFLAGS_HEAPTYPE)) {
    2691           0 :         PyErr_Format(
    2692             :             PyExc_TypeError,
    2693             :             "can't set attributes of built-in/extension type '%s'",
    2694             :             type->tp_name);
    2695           0 :         return -1;
    2696             :     }
    2697        1200 :     if (PyObject_GenericSetAttr((PyObject *)type, name, value) < 0)
    2698           0 :         return -1;
    2699        1200 :     return update_slot(type, name);
    2700             : }
    2701             : 
    2702             : static void
    2703           0 : type_dealloc(PyTypeObject *type)
    2704             : {
    2705             :     PyHeapTypeObject *et;
    2706             : 
    2707             :     /* Assert this is a heap-allocated type object */
    2708             :     assert(type->tp_flags & Py_TPFLAGS_HEAPTYPE);
    2709           0 :     _PyObject_GC_UNTRACK(type);
    2710           0 :     PyObject_ClearWeakRefs((PyObject *)type);
    2711           0 :     et = (PyHeapTypeObject *)type;
    2712           0 :     Py_XDECREF(type->tp_base);
    2713           0 :     Py_XDECREF(type->tp_dict);
    2714           0 :     Py_XDECREF(type->tp_bases);
    2715           0 :     Py_XDECREF(type->tp_mro);
    2716           0 :     Py_XDECREF(type->tp_cache);
    2717           0 :     Py_XDECREF(type->tp_subclasses);
    2718             :     /* A type's tp_doc is heap allocated, unlike the tp_doc slots
    2719             :      * of most other objects.  It's okay to cast it to char *.
    2720             :      */
    2721           0 :     PyObject_Free((char *)type->tp_doc);
    2722           0 :     Py_XDECREF(et->ht_name);
    2723           0 :     Py_XDECREF(et->ht_slots);
    2724           0 :     Py_TYPE(type)->tp_free((PyObject *)type);
    2725           0 : }
    2726             : 
    2727             : static PyObject *
    2728          63 : type_subclasses(PyTypeObject *type, PyObject *args_ignored)
    2729             : {
    2730             :     PyObject *list, *raw, *ref;
    2731             :     Py_ssize_t i, n;
    2732             : 
    2733          63 :     list = PyList_New(0);
    2734          63 :     if (list == NULL)
    2735           0 :         return NULL;
    2736          63 :     raw = type->tp_subclasses;
    2737          63 :     if (raw == NULL)
    2738          63 :         return list;
    2739             :     assert(PyList_Check(raw));
    2740           0 :     n = PyList_GET_SIZE(raw);
    2741           0 :     for (i = 0; i < n; i++) {
    2742           0 :         ref = PyList_GET_ITEM(raw, i);
    2743             :         assert(PyWeakref_CheckRef(ref));
    2744           0 :         ref = PyWeakref_GET_OBJECT(ref);
    2745           0 :         if (ref != Py_None) {
    2746           0 :             if (PyList_Append(list, ref) < 0) {
    2747           0 :                 Py_DECREF(list);
    2748           0 :                 return NULL;
    2749             :             }
    2750             :         }
    2751             :     }
    2752           0 :     return list;
    2753             : }
    2754             : 
    2755             : static PyMethodDef type_methods[] = {
    2756             :     {"mro", (PyCFunction)mro_external, METH_NOARGS,
    2757             :      PyDoc_STR("mro() -> list\nreturn a type's method resolution order")},
    2758             :     {"__subclasses__", (PyCFunction)type_subclasses, METH_NOARGS,
    2759             :      PyDoc_STR("__subclasses__() -> list of immediate subclasses")},
    2760             :     {"__instancecheck__", type___instancecheck__, METH_O,
    2761             :      PyDoc_STR("__instancecheck__() -> bool\ncheck if an object is an instance")},
    2762             :     {"__subclasscheck__", type___subclasscheck__, METH_O,
    2763             :      PyDoc_STR("__subclasscheck__() -> bool\ncheck if a class is a subclass")},
    2764             :     {0}
    2765             : };
    2766             : 
    2767             : PyDoc_STRVAR(type_doc,
    2768             : "type(object) -> the object's type\n"
    2769             : "type(name, bases, dict) -> a new type");
    2770             : 
    2771             : static int
    2772        4462 : type_traverse(PyTypeObject *type, visitproc visit, void *arg)
    2773             : {
    2774             :     /* Because of type_is_gc(), the collector only calls this
    2775             :        for heaptypes. */
    2776             :     assert(type->tp_flags & Py_TPFLAGS_HEAPTYPE);
    2777             : 
    2778        4462 :     Py_VISIT(type->tp_dict);
    2779        4462 :     Py_VISIT(type->tp_cache);
    2780        4462 :     Py_VISIT(type->tp_mro);
    2781        4462 :     Py_VISIT(type->tp_bases);
    2782        4462 :     Py_VISIT(type->tp_base);
    2783             : 
    2784             :     /* There's no need to visit type->tp_subclasses or
    2785             :        ((PyHeapTypeObject *)type)->ht_slots, because they can't be involved
    2786             :        in cycles; tp_subclasses is a list of weak references,
    2787             :        and slots is a tuple of strings. */
    2788             : 
    2789        4462 :     return 0;
    2790             : }
    2791             : 
    2792             : static int
    2793           0 : type_clear(PyTypeObject *type)
    2794             : {
    2795             :     /* Because of type_is_gc(), the collector only calls this
    2796             :        for heaptypes. */
    2797             :     assert(type->tp_flags & Py_TPFLAGS_HEAPTYPE);
    2798             : 
    2799             :     /* We need to invalidate the method cache carefully before clearing
    2800             :        the dict, so that other objects caught in a reference cycle
    2801             :        don't start calling destroyed methods.
    2802             : 
    2803             :        Otherwise, the only field we need to clear is tp_mro, which is
    2804             :        part of a hard cycle (its first element is the class itself) that
    2805             :        won't be broken otherwise (it's a tuple and tuples don't have a
    2806             :        tp_clear handler).  None of the other fields need to be
    2807             :        cleared, and here's why:
    2808             : 
    2809             :        tp_cache:
    2810             :            Not used; if it were, it would be a dict.
    2811             : 
    2812             :        tp_bases, tp_base:
    2813             :            If these are involved in a cycle, there must be at least
    2814             :            one other, mutable object in the cycle, e.g. a base
    2815             :            class's dict; the cycle will be broken that way.
    2816             : 
    2817             :        tp_subclasses:
    2818             :            A list of weak references can't be part of a cycle; and
    2819             :            lists have their own tp_clear.
    2820             : 
    2821             :        slots (in PyHeapTypeObject):
    2822             :            A tuple of strings can't be part of a cycle.
    2823             :     */
    2824             : 
    2825           0 :     PyType_Modified(type);
    2826           0 :     if (type->tp_dict)
    2827           0 :         PyDict_Clear(type->tp_dict);
    2828           0 :     Py_CLEAR(type->tp_mro);
    2829             : 
    2830           0 :     return 0;
    2831             : }
    2832             : 
    2833             : static int
    2834      102580 : type_is_gc(PyTypeObject *type)
    2835             : {
    2836      102580 :     return type->tp_flags & Py_TPFLAGS_HEAPTYPE;
    2837             : }
    2838             : 
    2839             : PyTypeObject PyType_Type = {
    2840             :     PyVarObject_HEAD_INIT(&PyType_Type, 0)
    2841             :     "type",                                     /* tp_name */
    2842             :     sizeof(PyHeapTypeObject),                   /* tp_basicsize */
    2843             :     sizeof(PyMemberDef),                        /* tp_itemsize */
    2844             :     (destructor)type_dealloc,                   /* tp_dealloc */
    2845             :     0,                                          /* tp_print */
    2846             :     0,                                          /* tp_getattr */
    2847             :     0,                                          /* tp_setattr */
    2848             :     0,                                  /* tp_compare */
    2849             :     (reprfunc)type_repr,                        /* tp_repr */
    2850             :     0,                                          /* tp_as_number */
    2851             :     0,                                          /* tp_as_sequence */
    2852             :     0,                                          /* tp_as_mapping */
    2853             :     (hashfunc)_Py_HashPointer,                  /* tp_hash */
    2854             :     (ternaryfunc)type_call,                     /* tp_call */
    2855             :     0,                                          /* tp_str */
    2856             :     (getattrofunc)type_getattro,                /* tp_getattro */
    2857             :     (setattrofunc)type_setattro,                /* tp_setattro */
    2858             :     0,                                          /* tp_as_buffer */
    2859             :     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
    2860             :         Py_TPFLAGS_BASETYPE | Py_TPFLAGS_TYPE_SUBCLASS,         /* tp_flags */
    2861             :     type_doc,                                   /* tp_doc */
    2862             :     (traverseproc)type_traverse,                /* tp_traverse */
    2863             :     (inquiry)type_clear,                        /* tp_clear */
    2864             :     type_richcompare,                                           /* tp_richcompare */
    2865             :     offsetof(PyTypeObject, tp_weaklist),        /* tp_weaklistoffset */
    2866             :     0,                                          /* tp_iter */
    2867             :     0,                                          /* tp_iternext */
    2868             :     type_methods,                               /* tp_methods */
    2869             :     type_members,                               /* tp_members */
    2870             :     type_getsets,                               /* tp_getset */
    2871             :     0,                                          /* tp_base */
    2872             :     0,                                          /* tp_dict */
    2873             :     0,                                          /* tp_descr_get */
    2874             :     0,                                          /* tp_descr_set */
    2875             :     offsetof(PyTypeObject, tp_dict),            /* tp_dictoffset */
    2876             :     type_init,                                  /* tp_init */
    2877             :     0,                                          /* tp_alloc */
    2878             :     type_new,                                   /* tp_new */
    2879             :     PyObject_GC_Del,                            /* tp_free */
    2880             :     (inquiry)type_is_gc,                        /* tp_is_gc */
    2881             : };
    2882             : 
    2883             : 
    2884             : /* The base type of all types (eventually)... except itself. */
    2885             : 
    2886             : /* You may wonder why object.__new__() only complains about arguments
    2887             :    when object.__init__() is not overridden, and vice versa.
    2888             : 
    2889             :    Consider the use cases:
    2890             : 
    2891             :    1. When neither is overridden, we want to hear complaints about
    2892             :       excess (i.e., any) arguments, since their presence could
    2893             :       indicate there's a bug.
    2894             : 
    2895             :    2. When defining an Immutable type, we are likely to override only
    2896             :       __new__(), since __init__() is called too late to initialize an
    2897             :       Immutable object.  Since __new__() defines the signature for the
    2898             :       type, it would be a pain to have to override __init__() just to
    2899             :       stop it from complaining about excess arguments.
    2900             : 
    2901             :    3. When defining a Mutable type, we are likely to override only
    2902             :       __init__().  So here the converse reasoning applies: we don't
    2903             :       want to have to override __new__() just to stop it from
    2904             :       complaining.
    2905             : 
    2906             :    4. When __init__() is overridden, and the subclass __init__() calls
    2907             :       object.__init__(), the latter should complain about excess
    2908             :       arguments; ditto for __new__().
    2909             : 
    2910             :    Use cases 2 and 3 make it unattractive to unconditionally check for
    2911             :    excess arguments.  The best solution that addresses all four use
    2912             :    cases is as follows: __init__() complains about excess arguments
    2913             :    unless __new__() is overridden and __init__() is not overridden
    2914             :    (IOW, if __init__() is overridden or __new__() is not overridden);
    2915             :    symmetrically, __new__() complains about excess arguments unless
    2916             :    __init__() is overridden and __new__() is not overridden
    2917             :    (IOW, if __new__() is overridden or __init__() is not overridden).
    2918             : 
    2919             :    However, for backwards compatibility, this breaks too much code.
    2920             :    Therefore, in 2.6, we'll *warn* about excess arguments when both
    2921             :    methods are overridden; for all other cases we'll use the above
    2922             :    rules.
    2923             : 
    2924             : */
    2925             : 
    2926             : /* Forward */
    2927             : static PyObject *
    2928             : object_new(PyTypeObject *type, PyObject *args, PyObject *kwds);
    2929             : 
    2930             : static int
    2931       11643 : excess_args(PyObject *args, PyObject *kwds)
    2932             : {
    2933       22179 :     return PyTuple_GET_SIZE(args) ||
    2934         186 :         (kwds && PyDict_Check(kwds) && PyDict_Size(kwds));
    2935             : }
    2936             : 
    2937             : static int
    2938        9885 : object_init(PyObject *self, PyObject *args, PyObject *kwds)
    2939             : {
    2940        9885 :     int err = 0;
    2941        9885 :     if (excess_args(args, kwds)) {
    2942        9090 :         PyTypeObject *type = Py_TYPE(self);
    2943        9090 :         if (type->tp_init != object_init &&
    2944           0 :             type->tp_new != object_new)
    2945             :         {
    2946           0 :             err = PyErr_WarnEx(PyExc_DeprecationWarning,
    2947             :                        "object.__init__() takes no parameters",
    2948             :                        1);
    2949             :         }
    2950       18180 :         else if (type->tp_init != object_init ||
    2951        9090 :                  type->tp_new == object_new)
    2952             :         {
    2953           0 :             PyErr_SetString(PyExc_TypeError,
    2954             :                 "object.__init__() takes no parameters");
    2955           0 :             err = -1;
    2956             :         }
    2957             :     }
    2958        9885 :     return err;
    2959             : }
    2960             : 
    2961             : static PyObject *
    2962        1758 : object_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
    2963             : {
    2964        1758 :     int err = 0;
    2965        1758 :     if (excess_args(args, kwds)) {
    2966        1446 :         if (type->tp_new != object_new &&
    2967           0 :             type->tp_init != object_init)
    2968             :         {
    2969           0 :             err = PyErr_WarnEx(PyExc_DeprecationWarning,
    2970             :                        "object() takes no parameters",
    2971             :                        1);
    2972             :         }
    2973        2892 :         else if (type->tp_new != object_new ||
    2974        1446 :                  type->tp_init == object_init)
    2975             :         {
    2976           0 :             PyErr_SetString(PyExc_TypeError,
    2977             :                 "object() takes no parameters");
    2978           0 :             err = -1;
    2979             :         }
    2980             :     }
    2981        1758 :     if (err < 0)
    2982           0 :         return NULL;
    2983             : 
    2984        1758 :     if (type->tp_flags & Py_TPFLAGS_IS_ABSTRACT) {
    2985             :         static PyObject *comma = NULL;
    2986           0 :         PyObject *abstract_methods = NULL;
    2987             :         PyObject *builtins;
    2988             :         PyObject *sorted;
    2989           0 :         PyObject *sorted_methods = NULL;
    2990           0 :         PyObject *joined = NULL;
    2991             :         const char *joined_str;
    2992             : 
    2993             :         /* Compute ", ".join(sorted(type.__abstractmethods__))
    2994             :            into joined. */
    2995           0 :         abstract_methods = type_abstractmethods(type, NULL);
    2996           0 :         if (abstract_methods == NULL)
    2997           0 :             goto error;
    2998           0 :         builtins = PyEval_GetBuiltins();
    2999           0 :         if (builtins == NULL)
    3000           0 :             goto error;
    3001           0 :         sorted = PyDict_GetItemString(builtins, "sorted");
    3002           0 :         if (sorted == NULL)
    3003           0 :             goto error;
    3004           0 :         sorted_methods = PyObject_CallFunctionObjArgs(sorted,
    3005             :                                                       abstract_methods,
    3006             :                                                       NULL);
    3007           0 :         if (sorted_methods == NULL)
    3008           0 :             goto error;
    3009           0 :         if (comma == NULL) {
    3010           0 :             comma = PyString_InternFromString(", ");
    3011           0 :             if (comma == NULL)
    3012           0 :                 goto error;
    3013             :         }
    3014           0 :         joined = PyObject_CallMethod(comma, "join",
    3015             :                                      "O",  sorted_methods);
    3016           0 :         if (joined == NULL)
    3017           0 :             goto error;
    3018           0 :         joined_str = PyString_AsString(joined);
    3019           0 :         if (joined_str == NULL)
    3020           0 :             goto error;
    3021             : 
    3022           0 :         PyErr_Format(PyExc_TypeError,
    3023             :                      "Can't instantiate abstract class %s "
    3024             :                      "with abstract methods %s",
    3025             :                      type->tp_name,
    3026             :                      joined_str);
    3027             :     error:
    3028           0 :         Py_XDECREF(joined);
    3029           0 :         Py_XDECREF(sorted_methods);
    3030           0 :         Py_XDECREF(abstract_methods);
    3031           0 :         return NULL;
    3032             :     }
    3033        1758 :     return type->tp_alloc(type, 0);
    3034             : }
    3035             : 
    3036             : static void
    3037         936 : object_dealloc(PyObject *self)
    3038             : {
    3039         936 :     Py_TYPE(self)->tp_free(self);
    3040         936 : }
    3041             : 
    3042             : static PyObject *
    3043           0 : object_repr(PyObject *self)
    3044             : {
    3045             :     PyTypeObject *type;
    3046             :     PyObject *mod, *name, *rtn;
    3047             : 
    3048           0 :     type = Py_TYPE(self);
    3049           0 :     mod = type_module(type, NULL);
    3050           0 :     if (mod == NULL)
    3051           0 :         PyErr_Clear();
    3052           0 :     else if (!PyString_Check(mod)) {
    3053           0 :         Py_DECREF(mod);
    3054           0 :         mod = NULL;
    3055             :     }
    3056           0 :     name = type_name(type, NULL);
    3057           0 :     if (name == NULL) {
    3058           0 :         Py_XDECREF(mod);
    3059           0 :         return NULL;
    3060             :     }
    3061           0 :     if (mod != NULL && strcmp(PyString_AS_STRING(mod), "__builtin__"))
    3062           0 :         rtn = PyString_FromFormat("<%s.%s object at %p>",
    3063           0 :                                   PyString_AS_STRING(mod),
    3064           0 :                                   PyString_AS_STRING(name),
    3065             :                                   self);
    3066             :     else
    3067           0 :         rtn = PyString_FromFormat("<%s object at %p>",
    3068             :                                   type->tp_name, self);
    3069           0 :     Py_XDECREF(mod);
    3070           0 :     Py_DECREF(name);
    3071           0 :     return rtn;
    3072             : }
    3073             : 
    3074             : static PyObject *
    3075           0 : object_str(PyObject *self)
    3076             : {
    3077             :     unaryfunc f;
    3078             : 
    3079           0 :     f = Py_TYPE(self)->tp_repr;
    3080           0 :     if (f == NULL)
    3081           0 :         f = object_repr;
    3082           0 :     return f(self);
    3083             : }
    3084             : 
    3085             : static PyObject *
    3086        7519 : object_get_class(PyObject *self, void *closure)
    3087             : {
    3088        7519 :     Py_INCREF(Py_TYPE(self));
    3089        7519 :     return (PyObject *)(Py_TYPE(self));
    3090             : }
    3091             : 
    3092             : static int
    3093           0 : equiv_structs(PyTypeObject *a, PyTypeObject *b)
    3094             : {
    3095           0 :     return a == b ||
    3096           0 :            (a != NULL &&
    3097           0 :         b != NULL &&
    3098           0 :         a->tp_basicsize == b->tp_basicsize &&
    3099           0 :         a->tp_itemsize == b->tp_itemsize &&
    3100           0 :         a->tp_dictoffset == b->tp_dictoffset &&
    3101           0 :         a->tp_weaklistoffset == b->tp_weaklistoffset &&
    3102           0 :         ((a->tp_flags & Py_TPFLAGS_HAVE_GC) ==
    3103           0 :          (b->tp_flags & Py_TPFLAGS_HAVE_GC)));
    3104             : }
    3105             : 
    3106             : static int
    3107           0 : same_slots_added(PyTypeObject *a, PyTypeObject *b)
    3108             : {
    3109           0 :     PyTypeObject *base = a->tp_base;
    3110             :     Py_ssize_t size;
    3111             :     PyObject *slots_a, *slots_b;
    3112             : 
    3113             :     assert(base == b->tp_base);
    3114           0 :     size = base->tp_basicsize;
    3115           0 :     if (a->tp_dictoffset == size && b->tp_dictoffset == size)
    3116           0 :         size += sizeof(PyObject *);
    3117           0 :     if (a->tp_weaklistoffset == size && b->tp_weaklistoffset == size)
    3118           0 :         size += sizeof(PyObject *);
    3119             : 
    3120             :     /* Check slots compliance */
    3121           0 :     slots_a = ((PyHeapTypeObject *)a)->ht_slots;
    3122           0 :     slots_b = ((PyHeapTypeObject *)b)->ht_slots;
    3123           0 :     if (slots_a && slots_b) {
    3124           0 :         if (PyObject_Compare(slots_a, slots_b) != 0)
    3125           0 :             return 0;
    3126           0 :         size += sizeof(PyObject *) * PyTuple_GET_SIZE(slots_a);
    3127             :     }
    3128           0 :     return size == a->tp_basicsize && size == b->tp_basicsize;
    3129             : }
    3130             : 
    3131             : static int
    3132           0 : compatible_for_assignment(PyTypeObject* oldto, PyTypeObject* newto, char* attr)
    3133             : {
    3134             :     PyTypeObject *newbase, *oldbase;
    3135             : 
    3136           0 :     if (newto->tp_dealloc != oldto->tp_dealloc ||
    3137           0 :         newto->tp_free != oldto->tp_free)
    3138             :     {
    3139           0 :         PyErr_Format(PyExc_TypeError,
    3140             :                      "%s assignment: "
    3141             :                      "'%s' deallocator differs from '%s'",
    3142             :                      attr,
    3143             :                      newto->tp_name,
    3144             :                      oldto->tp_name);
    3145           0 :         return 0;
    3146             :     }
    3147           0 :     newbase = newto;
    3148           0 :     oldbase = oldto;
    3149           0 :     while (equiv_structs(newbase, newbase->tp_base))
    3150           0 :         newbase = newbase->tp_base;
    3151           0 :     while (equiv_structs(oldbase, oldbase->tp_base))
    3152           0 :         oldbase = oldbase->tp_base;
    3153           0 :     if (newbase != oldbase &&
    3154           0 :         (newbase->tp_base != oldbase->tp_base ||
    3155           0 :          !same_slots_added(newbase, oldbase))) {
    3156           0 :         PyErr_Format(PyExc_TypeError,
    3157             :                      "%s assignment: "
    3158             :                      "'%s' object layout differs from '%s'",
    3159             :                      attr,
    3160             :                      newto->tp_name,
    3161             :                      oldto->tp_name);
    3162           0 :         return 0;
    3163             :     }
    3164             : 
    3165           0 :     return 1;
    3166             : }
    3167             : 
    3168             : static int
    3169           0 : object_set_class(PyObject *self, PyObject *value, void *closure)
    3170             : {
    3171           0 :     PyTypeObject *oldto = Py_TYPE(self);
    3172             :     PyTypeObject *newto;
    3173             : 
    3174           0 :     if (value == NULL) {
    3175           0 :         PyErr_SetString(PyExc_TypeError,
    3176             :                         "can't delete __class__ attribute");
    3177           0 :         return -1;
    3178             :     }
    3179           0 :     if (!PyType_Check(value)) {
    3180           0 :         PyErr_Format(PyExc_TypeError,
    3181             :           "__class__ must be set to new-style class, not '%s' object",
    3182           0 :           Py_TYPE(value)->tp_name);
    3183           0 :         return -1;
    3184             :     }
    3185           0 :     newto = (PyTypeObject *)value;
    3186           0 :     if (!(newto->tp_flags & Py_TPFLAGS_HEAPTYPE) ||
    3187           0 :         !(oldto->tp_flags & Py_TPFLAGS_HEAPTYPE))
    3188             :     {
    3189           0 :         PyErr_Format(PyExc_TypeError,
    3190             :                      "__class__ assignment: only for heap types");
    3191           0 :         return -1;
    3192             :     }
    3193           0 :     if (compatible_for_assignment(newto, oldto, "__class__")) {
    3194           0 :         Py_INCREF(newto);
    3195           0 :         Py_TYPE(self) = newto;
    3196           0 :         Py_DECREF(oldto);
    3197           0 :         return 0;
    3198             :     }
    3199             :     else {
    3200           0 :         return -1;
    3201             :     }
    3202             : }
    3203             : 
    3204             : static PyGetSetDef object_getsets[] = {
    3205             :     {"__class__", object_get_class, object_set_class,
    3206             :      PyDoc_STR("the object's class")},
    3207             :     {0}
    3208             : };
    3209             : 
    3210             : 
    3211             : /* Stuff to implement __reduce_ex__ for pickle protocols >= 2.
    3212             :    We fall back to helpers in copy_reg for:
    3213             :    - pickle protocols < 2
    3214             :    - calculating the list of slot names (done only once per class)
    3215             :    - the __newobj__ function (which is used as a token but never called)
    3216             : */
    3217             : 
    3218             : static PyObject *
    3219           0 : import_copyreg(void)
    3220             : {
    3221             :     static PyObject *copyreg_str;
    3222             : 
    3223           0 :     if (!copyreg_str) {
    3224           0 :         copyreg_str = PyString_InternFromString("copy_reg");
    3225           0 :         if (copyreg_str == NULL)
    3226           0 :             return NULL;
    3227             :     }
    3228             : 
    3229           0 :     return PyImport_Import(copyreg_str);
    3230             : }
    3231             : 
    3232             : static PyObject *
    3233           0 : slotnames(PyObject *cls)
    3234             : {
    3235             :     PyObject *clsdict;
    3236             :     PyObject *copyreg;
    3237             :     PyObject *slotnames;
    3238             : 
    3239           0 :     if (!PyType_Check(cls)) {
    3240           0 :         Py_INCREF(Py_None);
    3241           0 :         return Py_None;
    3242             :     }
    3243             : 
    3244           0 :     clsdict = ((PyTypeObject *)cls)->tp_dict;
    3245           0 :     slotnames = PyDict_GetItemString(clsdict, "__slotnames__");
    3246           0 :     if (slotnames != NULL && PyList_Check(slotnames)) {
    3247           0 :         Py_INCREF(slotnames);
    3248           0 :         return slotnames;
    3249             :     }
    3250             : 
    3251           0 :     copyreg = import_copyreg();
    3252           0 :     if (copyreg == NULL)
    3253           0 :         return NULL;
    3254             : 
    3255           0 :     slotnames = PyObject_CallMethod(copyreg, "_slotnames", "O", cls);
    3256           0 :     Py_DECREF(copyreg);
    3257           0 :     if (slotnames != NULL &&
    3258           0 :         slotnames != Py_None &&
    3259           0 :         !PyList_Check(slotnames))
    3260             :     {
    3261           0 :         PyErr_SetString(PyExc_TypeError,
    3262             :             "copy_reg._slotnames didn't return a list or None");
    3263           0 :         Py_DECREF(slotnames);
    3264           0 :         slotnames = NULL;
    3265             :     }
    3266             : 
    3267           0 :     return slotnames;
    3268             : }
    3269             : 
    3270             : static PyObject *
    3271           0 : reduce_2(PyObject *obj)
    3272             : {
    3273             :     PyObject *cls, *getnewargs;
    3274           0 :     PyObject *args = NULL, *args2 = NULL;
    3275           0 :     PyObject *getstate = NULL, *state = NULL, *names = NULL;
    3276           0 :     PyObject *slots = NULL, *listitems = NULL, *dictitems = NULL;
    3277           0 :     PyObject *copyreg = NULL, *newobj = NULL, *res = NULL;
    3278             :     Py_ssize_t i, n;
    3279           0 :     int required_state = 0;
    3280             : 
    3281           0 :     cls = PyObject_GetAttrString(obj, "__class__");
    3282           0 :     if (cls == NULL)
    3283           0 :         return NULL;
    3284             : 
    3285           0 :     if (PyType_Check(cls) && ((PyTypeObject *)cls)->tp_new == NULL) {
    3286           0 :         PyErr_Format(PyExc_TypeError,
    3287             :                      "can't pickle %.200s objects",
    3288             :                      ((PyTypeObject *)cls)->tp_name);
    3289           0 :         goto end;
    3290             :     }
    3291             : 
    3292           0 :     getnewargs = PyObject_GetAttrString(obj, "__getnewargs__");
    3293           0 :     if (getnewargs != NULL) {
    3294           0 :         args = PyObject_CallObject(getnewargs, NULL);
    3295           0 :         Py_DECREF(getnewargs);
    3296           0 :         if (args == NULL)
    3297           0 :             goto end;
    3298           0 :         if (!PyTuple_Check(args)) {
    3299           0 :             PyErr_Format(PyExc_TypeError,
    3300             :                 "__getnewargs__ should return a tuple, "
    3301           0 :                 "not '%.200s'", Py_TYPE(args)->tp_name);
    3302           0 :             goto end;
    3303             :         }
    3304             :     }
    3305             :     else {
    3306           0 :         PyErr_Clear();
    3307           0 :         required_state = !PyList_Check(obj) && !PyDict_Check(obj);
    3308             :     }
    3309             : 
    3310           0 :     getstate = PyObject_GetAttrString(obj, "__getstate__");
    3311           0 :     if (getstate != NULL) {
    3312           0 :         state = PyObject_CallObject(getstate, NULL);
    3313           0 :         Py_DECREF(getstate);
    3314           0 :         if (state == NULL)
    3315           0 :             goto end;
    3316             :     }
    3317             :     else {
    3318           0 :         PyErr_Clear();
    3319             : 
    3320           0 :         if (required_state && obj->ob_type->tp_itemsize) {
    3321           0 :             PyErr_Format(PyExc_TypeError,
    3322             :                          "can't pickle %.200s objects",
    3323           0 :                          Py_TYPE(obj)->tp_name);
    3324           0 :             goto end;
    3325             :         }
    3326             : 
    3327           0 :         state = PyObject_GetAttrString(obj, "__dict__");
    3328           0 :         if (state == NULL) {
    3329           0 :             PyErr_Clear();
    3330           0 :             state = Py_None;
    3331           0 :             Py_INCREF(state);
    3332             :         }
    3333           0 :         names = slotnames(cls);
    3334           0 :         if (names == NULL)
    3335           0 :             goto end;
    3336             :         assert(names == Py_None || PyList_Check(names));
    3337             : 
    3338           0 :         if (names != Py_None) {
    3339           0 :             slots = PyDict_New();
    3340           0 :             if (slots == NULL)
    3341           0 :                 goto end;
    3342           0 :             n = 0;
    3343             :             /* Can't pre-compute the list size; the list
    3344             :                is stored on the class so accessible to other
    3345             :                threads, which may be run by DECREF */
    3346           0 :             for (i = 0; i < PyList_GET_SIZE(names); i++) {
    3347             :                 PyObject *name, *value;
    3348           0 :                 name = PyList_GET_ITEM(names, i);
    3349           0 :                 Py_INCREF(name);
    3350           0 :                 value = PyObject_GetAttr(obj, name);
    3351           0 :                 if (value == NULL) {
    3352           0 :                     Py_DECREF(name);
    3353           0 :                     PyErr_Clear();
    3354             :                 }
    3355             :                 else {
    3356           0 :                     int err = PyDict_SetItem(slots, name,
    3357             :                                              value);
    3358           0 :                     Py_DECREF(name);
    3359           0 :                     Py_DECREF(value);
    3360           0 :                     if (err)
    3361           0 :                         goto end;
    3362           0 :                     n++;
    3363             :                 }
    3364             :             }
    3365           0 :             if (n) {
    3366           0 :                 state = Py_BuildValue("(NO)", state, slots);
    3367           0 :                 if (state == NULL)
    3368           0 :                     goto end;
    3369             :             }
    3370             :         }
    3371             :     }
    3372             : 
    3373           0 :     if (!PyList_Check(obj)) {
    3374           0 :         listitems = Py_None;
    3375           0 :         Py_INCREF(listitems);
    3376             :     }
    3377             :     else {
    3378           0 :         listitems = PyObject_GetIter(obj);
    3379           0 :         if (listitems == NULL)
    3380           0 :             goto end;
    3381             :     }
    3382             : 
    3383           0 :     if (!PyDict_Check(obj)) {
    3384           0 :         dictitems = Py_None;
    3385           0 :         Py_INCREF(dictitems);
    3386             :     }
    3387             :     else {
    3388           0 :         dictitems = PyObject_CallMethod(obj, "iteritems", "");
    3389           0 :         if (dictitems == NULL)
    3390           0 :             goto end;
    3391             :     }
    3392             : 
    3393           0 :     copyreg = import_copyreg();
    3394           0 :     if (copyreg == NULL)
    3395           0 :         goto end;
    3396           0 :     newobj = PyObject_GetAttrString(copyreg, "__newobj__");
    3397           0 :     if (newobj == NULL)
    3398           0 :         goto end;
    3399             : 
    3400           0 :     n = args ? PyTuple_GET_SIZE(args) : 0;
    3401           0 :     args2 = PyTuple_New(n+1);
    3402           0 :     if (args2 == NULL)
    3403           0 :         goto end;
    3404           0 :     PyTuple_SET_ITEM(args2, 0, cls);
    3405           0 :     cls = NULL;
    3406           0 :     for (i = 0; i < n; i++) {
    3407           0 :         PyObject *v = PyTuple_GET_ITEM(args, i);
    3408           0 :         Py_INCREF(v);
    3409           0 :         PyTuple_SET_ITEM(args2, i+1, v);
    3410             :     }
    3411             : 
    3412           0 :     res = PyTuple_Pack(5, newobj, args2, state, listitems, dictitems);
    3413             : 
    3414             :   end:
    3415           0 :     Py_XDECREF(cls);
    3416           0 :     Py_XDECREF(args);
    3417           0 :     Py_XDECREF(args2);
    3418           0 :     Py_XDECREF(slots);
    3419           0 :     Py_XDECREF(state);
    3420           0 :     Py_XDECREF(names);
    3421           0 :     Py_XDECREF(listitems);
    3422           0 :     Py_XDECREF(dictitems);
    3423           0 :     Py_XDECREF(copyreg);
    3424           0 :     Py_XDECREF(newobj);
    3425           0 :     return res;
    3426             : }
    3427             : 
    3428             : /*
    3429             :  * There were two problems when object.__reduce__ and object.__reduce_ex__
    3430             :  * were implemented in the same function:
    3431             :  *  - trying to pickle an object with a custom __reduce__ method that
    3432             :  *    fell back to object.__reduce__ in certain circumstances led to
    3433             :  *    infinite recursion at Python level and eventual RuntimeError.
    3434             :  *  - Pickling objects that lied about their type by overwriting the
    3435             :  *    __class__ descriptor could lead to infinite recursion at C level
    3436             :  *    and eventual segfault.
    3437             :  *
    3438             :  * Because of backwards compatibility, the two methods still have to
    3439             :  * behave in the same way, even if this is not required by the pickle
    3440             :  * protocol. This common functionality was moved to the _common_reduce
    3441             :  * function.
    3442             :  */
    3443             : static PyObject *
    3444           0 : _common_reduce(PyObject *self, int proto)
    3445             : {
    3446             :     PyObject *copyreg, *res;
    3447             : 
    3448           0 :     if (proto >= 2)
    3449           0 :         return reduce_2(self);
    3450             : 
    3451           0 :     copyreg = import_copyreg();
    3452           0 :     if (!copyreg)
    3453           0 :         return NULL;
    3454             : 
    3455           0 :     res = PyEval_CallMethod(copyreg, "_reduce_ex", "(Oi)", self, proto);
    3456           0 :     Py_DECREF(copyreg);
    3457             : 
    3458           0 :     return res;
    3459             : }
    3460             : 
    3461             : static PyObject *
    3462           0 : object_reduce(PyObject *self, PyObject *args)
    3463             : {
    3464           0 :     int proto = 0;
    3465             : 
    3466           0 :     if (!PyArg_ParseTuple(args, "|i:__reduce__", &proto))
    3467           0 :         return NULL;
    3468             : 
    3469           0 :     return _common_reduce(self, proto);
    3470             : }
    3471             : 
    3472             : static PyObject *
    3473           0 : object_reduce_ex(PyObject *self, PyObject *args)
    3474             : {
    3475             :     PyObject *reduce, *res;
    3476           0 :     int proto = 0;
    3477             : 
    3478           0 :     if (!PyArg_ParseTuple(args, "|i:__reduce_ex__", &proto))
    3479           0 :         return NULL;
    3480             : 
    3481           0 :     reduce = PyObject_GetAttrString(self, "__reduce__");
    3482           0 :     if (reduce == NULL)
    3483           0 :         PyErr_Clear();
    3484             :     else {
    3485             :         PyObject *cls, *clsreduce, *objreduce;
    3486             :         int override;
    3487           0 :         cls = PyObject_GetAttrString(self, "__class__");
    3488           0 :         if (cls == NULL) {
    3489           0 :             Py_DECREF(reduce);
    3490           0 :             return NULL;
    3491             :         }
    3492           0 :         clsreduce = PyObject_GetAttrString(cls, "__reduce__");
    3493           0 :         Py_DECREF(cls);
    3494           0 :         if (clsreduce == NULL) {
    3495           0 :             Py_DECREF(reduce);
    3496           0 :             return NULL;
    3497             :         }
    3498           0 :         objreduce = PyDict_GetItemString(PyBaseObject_Type.tp_dict,
    3499             :                                          "__reduce__");
    3500           0 :         override = (clsreduce != objreduce);
    3501           0 :         Py_DECREF(clsreduce);
    3502           0 :         if (override) {
    3503           0 :             res = PyObject_CallObject(reduce, NULL);
    3504           0 :             Py_DECREF(reduce);
    3505           0 :             return res;
    3506             :         }
    3507             :         else
    3508           0 :             Py_DECREF(reduce);
    3509             :     }
    3510             : 
    3511           0 :     return _common_reduce(self, proto);
    3512             : }
    3513             : 
    3514             : static PyObject *
    3515          24 : object_subclasshook(PyObject *cls, PyObject *args)
    3516             : {
    3517          24 :     Py_INCREF(Py_NotImplemented);
    3518          24 :     return Py_NotImplemented;
    3519             : }
    3520             : 
    3521             : PyDoc_STRVAR(object_subclasshook_doc,
    3522             : "Abstract classes can override this to customize issubclass().\n"
    3523             : "\n"
    3524             : "This is invoked early on by abc.ABCMeta.__subclasscheck__().\n"
    3525             : "It should return True, False or NotImplemented.  If it returns\n"
    3526             : "NotImplemented, the normal algorithm is used.  Otherwise, it\n"
    3527             : "overrides the normal algorithm (and the outcome is cached).\n");
    3528             : 
    3529             : /*
    3530             :    from PEP 3101, this code implements:
    3531             : 
    3532             :    class object:
    3533             :        def __format__(self, format_spec):
    3534             :            if isinstance(format_spec, str):
    3535             :                return format(str(self), format_spec)
    3536             :            elif isinstance(format_spec, unicode):
    3537             :                return format(unicode(self), format_spec)
    3538             : */
    3539             : static PyObject *
    3540           0 : object_format(PyObject *self, PyObject *args)
    3541             : {
    3542             :     PyObject *format_spec;
    3543           0 :     PyObject *self_as_str = NULL;
    3544           0 :     PyObject *result = NULL;
    3545             :     Py_ssize_t format_len;
    3546             : 
    3547           0 :     if (!PyArg_ParseTuple(args, "O:__format__", &format_spec))
    3548           0 :         return NULL;
    3549             : #ifdef Py_USING_UNICODE
    3550           0 :     if (PyUnicode_Check(format_spec)) {
    3551           0 :         format_len = PyUnicode_GET_SIZE(format_spec);
    3552           0 :         self_as_str = PyObject_Unicode(self);
    3553           0 :     } else if (PyString_Check(format_spec)) {
    3554             : #else
    3555             :     if (PyString_Check(format_spec)) {
    3556             : #endif
    3557           0 :         format_len = PyString_GET_SIZE(format_spec);
    3558           0 :         self_as_str = PyObject_Str(self);
    3559             :     } else {
    3560           0 :         PyErr_SetString(PyExc_TypeError,
    3561             :                  "argument to __format__ must be unicode or str");
    3562           0 :         return NULL;
    3563             :     }
    3564             : 
    3565           0 :     if (self_as_str != NULL) {
    3566             :         /* Issue 7994: If we're converting to a string, we
    3567             :            should reject format specifications */
    3568           0 :         if (format_len > 0) {
    3569           0 :             if (PyErr_WarnEx(PyExc_PendingDeprecationWarning,
    3570             :              "object.__format__ with a non-empty format "
    3571             :              "string is deprecated", 1) < 0) {
    3572           0 :                 goto done;
    3573             :             }
    3574             :             /* Eventually this will become an error:
    3575             :             PyErr_Format(PyExc_TypeError,
    3576             :                "non-empty format string passed to object.__format__");
    3577             :             goto done;
    3578             :             */
    3579             :         }
    3580           0 :         result = PyObject_Format(self_as_str, format_spec);
    3581             :     }
    3582             : 
    3583             : done:
    3584           0 :     Py_XDECREF(self_as_str);
    3585             : 
    3586           0 :     return result;
    3587             : }
    3588             : 
    3589             : static PyObject *
    3590           0 : object_sizeof(PyObject *self, PyObject *args)
    3591             : {
    3592             :     Py_ssize_t res, isize;
    3593             : 
    3594           0 :     res = 0;
    3595           0 :     isize = self->ob_type->tp_itemsize;
    3596           0 :     if (isize > 0)
    3597           0 :         res = Py_SIZE(self) * isize;
    3598           0 :     res += self->ob_type->tp_basicsize;
    3599             : 
    3600           0 :     return PyInt_FromSsize_t(res);
    3601             : }
    3602             : 
    3603             : static PyMethodDef object_methods[] = {
    3604             :     {"__reduce_ex__", object_reduce_ex, METH_VARARGS,
    3605             :      PyDoc_STR("helper for pickle")},
    3606             :     {"__reduce__", object_reduce, METH_VARARGS,
    3607             :      PyDoc_STR("helper for pickle")},
    3608             :     {"__subclasshook__", object_subclasshook, METH_CLASS | METH_VARARGS,
    3609             :      object_subclasshook_doc},
    3610             :     {"__format__", object_format, METH_VARARGS,
    3611             :      PyDoc_STR("default object formatter")},
    3612             :     {"__sizeof__", object_sizeof, METH_NOARGS,
    3613             :      PyDoc_STR("__sizeof__() -> int\nsize of object in memory, in bytes")},
    3614             :     {0}
    3615             : };
    3616             : 
    3617             : 
    3618             : PyTypeObject PyBaseObject_Type = {
    3619             :     PyVarObject_HEAD_INIT(&PyType_Type, 0)
    3620             :     "object",                                   /* tp_name */
    3621             :     sizeof(PyObject),                           /* tp_basicsize */
    3622             :     0,                                          /* tp_itemsize */
    3623             :     object_dealloc,                             /* tp_dealloc */
    3624             :     0,                                          /* tp_print */
    3625             :     0,                                          /* tp_getattr */
    3626             :     0,                                          /* tp_setattr */
    3627             :     0,                                          /* tp_compare */
    3628             :     object_repr,                                /* tp_repr */
    3629             :     0,                                          /* tp_as_number */
    3630             :     0,                                          /* tp_as_sequence */
    3631             :     0,                                          /* tp_as_mapping */
    3632             :     (hashfunc)_Py_HashPointer,                  /* tp_hash */
    3633             :     0,                                          /* tp_call */
    3634             :     object_str,                                 /* tp_str */
    3635             :     PyObject_GenericGetAttr,                    /* tp_getattro */
    3636             :     PyObject_GenericSetAttr,                    /* tp_setattro */
    3637             :     0,                                          /* tp_as_buffer */
    3638             :     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
    3639             :     PyDoc_STR("The most base type"),            /* tp_doc */
    3640             :     0,                                          /* tp_traverse */
    3641             :     0,                                          /* tp_clear */
    3642             :     0,                                          /* tp_richcompare */
    3643             :     0,                                          /* tp_weaklistoffset */
    3644             :     0,                                          /* tp_iter */
    3645             :     0,                                          /* tp_iternext */
    3646             :     object_methods,                             /* tp_methods */
    3647             :     0,                                          /* tp_members */
    3648             :     object_getsets,                             /* tp_getset */
    3649             :     0,                                          /* tp_base */
    3650             :     0,                                          /* tp_dict */
    3651             :     0,                                          /* tp_descr_get */
    3652             :     0,                                          /* tp_descr_set */
    3653             :     0,                                          /* tp_dictoffset */
    3654             :     object_init,                                /* tp_init */
    3655             :     PyType_GenericAlloc,                        /* tp_alloc */
    3656             :     object_new,                                 /* tp_new */
    3657             :     PyObject_Del,                               /* tp_free */
    3658             : };
    3659             : 
    3660             : 
    3661             : /* Initialize the __dict__ in a type object */
    3662             : 
    3663             : static int
    3664         219 : add_methods(PyTypeObject *type, PyMethodDef *meth)
    3665             : {
    3666         219 :     PyObject *dict = type->tp_dict;
    3667             : 
    3668        1821 :     for (; meth->ml_name != NULL; meth++) {
    3669             :         PyObject *descr;
    3670             :         int err;
    3671        1617 :         if (PyDict_GetItemString(dict, meth->ml_name) &&
    3672          15 :             !(meth->ml_flags & METH_COEXIST))
    3673           0 :                 continue;
    3674        1602 :         if (meth->ml_flags & METH_CLASS) {
    3675          21 :             if (meth->ml_flags & METH_STATIC) {
    3676           0 :                 PyErr_SetString(PyExc_ValueError,
    3677             :                      "method cannot be both class and static");
    3678           0 :                 return -1;
    3679             :             }
    3680          21 :             descr = PyDescr_NewClassMethod(type, meth);
    3681             :         }
    3682        1581 :         else if (meth->ml_flags & METH_STATIC) {
    3683           0 :             PyObject *cfunc = PyCFunction_New(meth, NULL);
    3684           0 :             if (cfunc == NULL)
    3685           0 :                 return -1;
    3686           0 :             descr = PyStaticMethod_New(cfunc);
    3687           0 :             Py_DECREF(cfunc);
    3688             :         }
    3689             :         else {
    3690        1581 :             descr = PyDescr_NewMethod(type, meth);
    3691             :         }
    3692        1602 :         if (descr == NULL)
    3693           0 :             return -1;
    3694        1602 :         err = PyDict_SetItemString(dict, meth->ml_name, descr);
    3695        1602 :         Py_DECREF(descr);
    3696        1602 :         if (err < 0)
    3697           0 :             return -1;
    3698             :     }
    3699         219 :     return 0;
    3700             : }
    3701             : 
    3702             : static int
    3703         933 : add_members(PyTypeObject *type, PyMemberDef *memb)
    3704             : {
    3705         933 :     PyObject *dict = type->tp_dict;
    3706             : 
    3707        1563 :     for (; memb->name != NULL; memb++) {
    3708             :         PyObject *descr;
    3709         630 :         if (PyDict_GetItemString(dict, memb->name))
    3710           0 :             continue;
    3711         630 :         descr = PyDescr_NewMember(type, memb);
    3712         630 :         if (descr == NULL)
    3713           0 :             return -1;
    3714         630 :         if (PyDict_SetItemString(dict, memb->name, descr) < 0) {
    3715           0 :             Py_DECREF(descr);
    3716           0 :             return -1;
    3717             :         }
    3718         630 :         Py_DECREF(descr);
    3719             :     }
    3720         933 :     return 0;
    3721             : }
    3722             : 
    3723             : static int
    3724         429 : add_getset(PyTypeObject *type, PyGetSetDef *gsp)
    3725             : {
    3726         429 :     PyObject *dict = type->tp_dict;
    3727             : 
    3728        1278 :     for (; gsp->name != NULL; gsp++) {
    3729             :         PyObject *descr;
    3730         849 :         if (PyDict_GetItemString(dict, gsp->name))
    3731           0 :             continue;
    3732         849 :         descr = PyDescr_NewGetSet(type, gsp);
    3733             : 
    3734         849 :         if (descr == NULL)
    3735           0 :             return -1;
    3736         849 :         if (PyDict_SetItemString(dict, gsp->name, descr) < 0) {
    3737           0 :             Py_DECREF(descr);
    3738           0 :             return -1;
    3739             :         }
    3740         849 :         Py_DECREF(descr);
    3741             :     }
    3742         429 :     return 0;
    3743             : }
    3744             : 
    3745             : #define BUFFER_FLAGS (Py_TPFLAGS_HAVE_GETCHARBUFFER | Py_TPFLAGS_HAVE_NEWBUFFER)
    3746             : 
    3747             : static void
    3748        1293 : inherit_special(PyTypeObject *type, PyTypeObject *base)
    3749             : {
    3750             :     Py_ssize_t oldsize, newsize;
    3751             : 
    3752             :     /* Special flag magic */
    3753        1293 :     if (!type->tp_as_buffer && base->tp_as_buffer) {
    3754           0 :         type->tp_flags &= ~BUFFER_FLAGS;
    3755           0 :         type->tp_flags |=
    3756           0 :             base->tp_flags & BUFFER_FLAGS;
    3757             :     }
    3758        1293 :     if (!type->tp_as_sequence && base->tp_as_sequence) {
    3759         147 :         type->tp_flags &= ~Py_TPFLAGS_HAVE_SEQUENCE_IN;
    3760         147 :         type->tp_flags |= base->tp_flags & Py_TPFLAGS_HAVE_SEQUENCE_IN;
    3761             :     }
    3762        2586 :     if ((type->tp_flags & Py_TPFLAGS_HAVE_INPLACEOPS) !=
    3763        1293 :         (base->tp_flags & Py_TPFLAGS_HAVE_INPLACEOPS)) {
    3764          18 :         if ((!type->tp_as_number && base->tp_as_number) ||
    3765          18 :             (!type->tp_as_sequence && base->tp_as_sequence)) {
    3766           0 :             type->tp_flags &= ~Py_TPFLAGS_HAVE_INPLACEOPS;
    3767           0 :             if (!type->tp_as_number && !type->tp_as_sequence) {
    3768           0 :                 type->tp_flags |= base->tp_flags &
    3769             :                     Py_TPFLAGS_HAVE_INPLACEOPS;
    3770             :             }
    3771             :         }
    3772             :         /* Wow */
    3773             :     }
    3774        1293 :     if (!type->tp_as_number && base->tp_as_number) {
    3775           0 :         type->tp_flags &= ~Py_TPFLAGS_CHECKTYPES;
    3776           0 :         type->tp_flags |= base->tp_flags & Py_TPFLAGS_CHECKTYPES;
    3777             :     }
    3778             : 
    3779             :     /* Copying basicsize is connected to the GC flags */
    3780        1293 :     oldsize = base->tp_basicsize;
    3781        1293 :     newsize = type->tp_basicsize ? type->tp_basicsize : oldsize;
    3782        1419 :     if (!(type->tp_flags & Py_TPFLAGS_HAVE_GC) &&
    3783         138 :         (base->tp_flags & Py_TPFLAGS_HAVE_GC) &&
    3784          24 :         (type->tp_flags & Py_TPFLAGS_HAVE_RICHCOMPARE/*GC slots exist*/) &&
    3785          24 :         (!type->tp_traverse && !type->tp_clear)) {
    3786          12 :         type->tp_flags |= Py_TPFLAGS_HAVE_GC;
    3787          12 :         if (type->tp_traverse == NULL)
    3788          12 :             type->tp_traverse = base->tp_traverse;
    3789          12 :         if (type->tp_clear == NULL)
    3790          12 :             type->tp_clear = base->tp_clear;
    3791             :     }
    3792        1293 :     if (type->tp_flags & base->tp_flags & Py_TPFLAGS_HAVE_CLASS) {
    3793             :         /* The condition below could use some explanation.
    3794             :            It appears that tp_new is not inherited for static types
    3795             :            whose base class is 'object'; this seems to be a precaution
    3796             :            so that old extension types don't suddenly become
    3797             :            callable (object.__new__ wouldn't insure the invariants
    3798             :            that the extension type's own factory function ensures).
    3799             :            Heap types, of course, are under our control, so they do
    3800             :            inherit tp_new; static extension types that specify some
    3801             :            other built-in type as the default are considered
    3802             :            new-style-aware so they also inherit object.__new__. */
    3803        1824 :         if (base != &PyBaseObject_Type ||
    3804         540 :             (type->tp_flags & Py_TPFLAGS_HEAPTYPE)) {
    3805         978 :             if (type->tp_new == NULL)
    3806         804 :                 type->tp_new = base->tp_new;
    3807             :         }
    3808             :     }
    3809        1293 :     type->tp_basicsize = newsize;
    3810             : 
    3811             :     /* Copy other non-function slots */
    3812             : 
    3813             : #undef COPYVAL
    3814             : #define COPYVAL(SLOT) \
    3815             :     if (type->SLOT == 0) type->SLOT = base->SLOT
    3816             : 
    3817        1293 :     COPYVAL(tp_itemsize);
    3818        1293 :     if (type->tp_flags & base->tp_flags & Py_TPFLAGS_HAVE_WEAKREFS) {
    3819        1284 :         COPYVAL(tp_weaklistoffset);
    3820             :     }
    3821        1293 :     if (type->tp_flags & base->tp_flags & Py_TPFLAGS_HAVE_CLASS) {
    3822        1284 :         COPYVAL(tp_dictoffset);
    3823             :     }
    3824             : 
    3825             :     /* Setup fast subclass flags */
    3826        1293 :     if (PyType_IsSubtype(base, (PyTypeObject*)PyExc_BaseException))
    3827         228 :         type->tp_flags |= Py_TPFLAGS_BASE_EXC_SUBCLASS;
    3828        1065 :     else if (PyType_IsSubtype(base, &PyType_Type))
    3829           6 :         type->tp_flags |= Py_TPFLAGS_TYPE_SUBCLASS;
    3830        1059 :     else if (PyType_IsSubtype(base, &PyInt_Type))
    3831           3 :         type->tp_flags |= Py_TPFLAGS_INT_SUBCLASS;
    3832        1056 :     else if (PyType_IsSubtype(base, &PyLong_Type))
    3833           0 :         type->tp_flags |= Py_TPFLAGS_LONG_SUBCLASS;
    3834        1056 :     else if (PyType_IsSubtype(base, &PyString_Type))
    3835           0 :         type->tp_flags |= Py_TPFLAGS_STRING_SUBCLASS;
    3836             : #ifdef Py_USING_UNICODE
    3837        1056 :     else if (PyType_IsSubtype(base, &PyUnicode_Type))
    3838           0 :         type->tp_flags |= Py_TPFLAGS_UNICODE_SUBCLASS;
    3839             : #endif
    3840        1056 :     else if (PyType_IsSubtype(base, &PyTuple_Type))
    3841          36 :         type->tp_flags |= Py_TPFLAGS_TUPLE_SUBCLASS;
    3842        1020 :     else if (PyType_IsSubtype(base, &PyList_Type))
    3843           0 :         type->tp_flags |= Py_TPFLAGS_LIST_SUBCLASS;
    3844        1020 :     else if (PyType_IsSubtype(base, &PyDict_Type))
    3845           9 :         type->tp_flags |= Py_TPFLAGS_DICT_SUBCLASS;
    3846        1293 : }
    3847             : 
    3848             : static int
    3849           0 : overrides_name(PyTypeObject *type, char *name)
    3850             : {
    3851           0 :     PyObject *dict = type->tp_dict;
    3852             : 
    3853             :     assert(dict != NULL);
    3854           0 :     if (PyDict_GetItemString(dict, name) != NULL) {
    3855           0 :         return 1;
    3856             :     }
    3857           0 :     return 0;
    3858             : }
    3859             : 
    3860             : #define OVERRIDES_HASH(x)       overrides_name(x, "__hash__")
    3861             : #define OVERRIDES_EQ(x)         overrides_name(x, "__eq__")
    3862             : 
    3863             : static void
    3864        3168 : inherit_slots(PyTypeObject *type, PyTypeObject *base)
    3865             : {
    3866             :     PyTypeObject *basebase;
    3867             : 
    3868             : #undef SLOTDEFINED
    3869             : #undef COPYSLOT
    3870             : #undef COPYNUM
    3871             : #undef COPYSEQ
    3872             : #undef COPYMAP
    3873             : #undef COPYBUF
    3874             : 
    3875             : #define SLOTDEFINED(SLOT) \
    3876             :     (base->SLOT != 0 && \
    3877             :      (basebase == NULL || base->SLOT != basebase->SLOT))
    3878             : 
    3879             : #define COPYSLOT(SLOT) \
    3880             :     if (!type->SLOT && SLOTDEFINED(SLOT)) type->SLOT = base->SLOT
    3881             : 
    3882             : #define COPYNUM(SLOT) COPYSLOT(tp_as_number->SLOT)
    3883             : #define COPYSEQ(SLOT) COPYSLOT(tp_as_sequence->SLOT)
    3884             : #define COPYMAP(SLOT) COPYSLOT(tp_as_mapping->SLOT)
    3885             : #define COPYBUF(SLOT) COPYSLOT(tp_as_buffer->SLOT)
    3886             : 
    3887             :     /* This won't inherit indirect slots (from tp_as_number etc.)
    3888             :        if type doesn't provide the space. */
    3889             : 
    3890        3168 :     if (type->tp_as_number != NULL && base->tp_as_number != NULL) {
    3891        1029 :         basebase = base->tp_base;
    3892        1029 :         if (basebase->tp_as_number == NULL)
    3893         489 :             basebase = NULL;
    3894        1029 :         COPYNUM(nb_add);
    3895        1029 :         COPYNUM(nb_subtract);
    3896        1029 :         COPYNUM(nb_multiply);
    3897        1029 :         COPYNUM(nb_divide);
    3898        1029 :         COPYNUM(nb_remainder);
    3899        1029 :         COPYNUM(nb_divmod);
    3900        1029 :         COPYNUM(nb_power);
    3901        1029 :         COPYNUM(nb_negative);
    3902        1029 :         COPYNUM(nb_positive);
    3903        1029 :         COPYNUM(nb_absolute);
    3904        1029 :         COPYNUM(nb_nonzero);
    3905        1029 :         COPYNUM(nb_invert);
    3906        1029 :         COPYNUM(nb_lshift);
    3907        1029 :         COPYNUM(nb_rshift);
    3908        1029 :         COPYNUM(nb_and);
    3909        1029 :         COPYNUM(nb_xor);
    3910        1029 :         COPYNUM(nb_or);
    3911        1029 :         COPYNUM(nb_coerce);
    3912        1029 :         COPYNUM(nb_int);
    3913        1029 :         COPYNUM(nb_long);
    3914        1029 :         COPYNUM(nb_float);
    3915        1029 :         COPYNUM(nb_oct);
    3916        1029 :         COPYNUM(nb_hex);
    3917        1029 :         COPYNUM(nb_inplace_add);
    3918        1029 :         COPYNUM(nb_inplace_subtract);
    3919        1029 :         COPYNUM(nb_inplace_multiply);
    3920        1029 :         COPYNUM(nb_inplace_divide);
    3921        1029 :         COPYNUM(nb_inplace_remainder);
    3922        1029 :         COPYNUM(nb_inplace_power);
    3923        1029 :         COPYNUM(nb_inplace_lshift);
    3924        1029 :         COPYNUM(nb_inplace_rshift);
    3925        1029 :         COPYNUM(nb_inplace_and);
    3926        1029 :         COPYNUM(nb_inplace_xor);
    3927        1029 :         COPYNUM(nb_inplace_or);
    3928        1029 :         if (base->tp_flags & Py_TPFLAGS_CHECKTYPES) {
    3929        1029 :             COPYNUM(nb_true_divide);
    3930        1029 :             COPYNUM(nb_floor_divide);
    3931        1029 :             COPYNUM(nb_inplace_true_divide);
    3932        1029 :             COPYNUM(nb_inplace_floor_divide);
    3933             :         }
    3934        1029 :         if (base->tp_flags & Py_TPFLAGS_HAVE_INDEX) {
    3935        1029 :             COPYNUM(nb_index);
    3936             :         }
    3937             :     }
    3938             : 
    3939        3168 :     if (type->tp_as_sequence != NULL && base->tp_as_sequence != NULL) {
    3940        1302 :         basebase = base->tp_base;
    3941        1302 :         if (basebase->tp_as_sequence == NULL)
    3942         591 :             basebase = NULL;
    3943        1302 :         COPYSEQ(sq_length);
    3944        1302 :         COPYSEQ(sq_concat);
    3945        1302 :         COPYSEQ(sq_repeat);
    3946        1302 :         COPYSEQ(sq_item);
    3947        1302 :         COPYSEQ(sq_slice);
    3948        1302 :         COPYSEQ(sq_ass_item);
    3949        1302 :         COPYSEQ(sq_ass_slice);
    3950        1302 :         COPYSEQ(sq_contains);
    3951        1302 :         COPYSEQ(sq_inplace_concat);
    3952        1302 :         COPYSEQ(sq_inplace_repeat);
    3953             :     }
    3954             : 
    3955        3168 :     if (type->tp_as_mapping != NULL && base->tp_as_mapping != NULL) {
    3956        1068 :         basebase = base->tp_base;
    3957        1068 :         if (basebase->tp_as_mapping == NULL)
    3958         522 :             basebase = NULL;
    3959        1068 :         COPYMAP(mp_length);
    3960        1068 :         COPYMAP(mp_subscript);
    3961        1068 :         COPYMAP(mp_ass_subscript);
    3962             :     }
    3963             : 
    3964        3168 :     if (type->tp_as_buffer != NULL && base->tp_as_buffer != NULL) {
    3965        1026 :         basebase = base->tp_base;
    3966        1026 :         if (basebase->tp_as_buffer == NULL)
    3967         486 :             basebase = NULL;
    3968        1026 :         COPYBUF(bf_getreadbuffer);
    3969        1026 :         COPYBUF(bf_getwritebuffer);
    3970        1026 :         COPYBUF(bf_getsegcount);
    3971        1026 :         COPYBUF(bf_getcharbuffer);
    3972        1026 :         COPYBUF(bf_getbuffer);
    3973        1026 :         COPYBUF(bf_releasebuffer);
    3974             :     }
    3975             : 
    3976        3168 :     basebase = base->tp_base;
    3977             : 
    3978        3168 :     COPYSLOT(tp_dealloc);
    3979        3168 :     COPYSLOT(tp_print);
    3980        3168 :     if (type->tp_getattr == NULL && type->tp_getattro == NULL) {
    3981        1047 :         type->tp_getattr = base->tp_getattr;
    3982        1047 :         type->tp_getattro = base->tp_getattro;
    3983             :     }
    3984        3168 :     if (type->tp_setattr == NULL && type->tp_setattro == NULL) {
    3985        1254 :         type->tp_setattr = base->tp_setattr;
    3986        1254 :         type->tp_setattro = base->tp_setattro;
    3987             :     }
    3988             :     /* tp_compare see tp_richcompare */
    3989        3168 :     COPYSLOT(tp_repr);
    3990             :     /* tp_hash see tp_richcompare */
    3991        3168 :     COPYSLOT(tp_call);
    3992        3168 :     COPYSLOT(tp_str);
    3993        3168 :     if (type->tp_flags & base->tp_flags & Py_TPFLAGS_HAVE_RICHCOMPARE) {
    3994        6261 :         if (type->tp_compare == NULL &&
    3995        5274 :             type->tp_richcompare == NULL &&
    3996        2172 :             type->tp_hash == NULL)
    3997             :         {
    3998        1176 :             type->tp_compare = base->tp_compare;
    3999        1176 :             type->tp_richcompare = base->tp_richcompare;
    4000        1176 :             type->tp_hash = base->tp_hash;
    4001             :             /* Check for changes to inherited methods in Py3k*/
    4002        1176 :             if (Py_Py3kWarningFlag) {
    4003           0 :                 if (base->tp_hash &&
    4004           0 :                                 (base->tp_hash != PyObject_HashNotImplemented) &&
    4005           0 :                                 !OVERRIDES_HASH(type)) {
    4006           0 :                     if (OVERRIDES_EQ(type)) {
    4007           0 :                         if (PyErr_WarnPy3k("Overriding "
    4008             :                                            "__eq__ blocks inheritance "
    4009             :                                            "of __hash__ in 3.x",
    4010           0 :                                            1) < 0)
    4011             :                             /* XXX This isn't right.  If the warning is turned
    4012             :                                into an exception, we should be communicating
    4013             :                                the error back to the caller, but figuring out
    4014             :                                how to clean up in that case is tricky.  See
    4015             :                                issue 8627 for more. */
    4016           0 :                             PyErr_Clear();
    4017             :                     }
    4018             :                 }
    4019             :             }
    4020             :         }
    4021             :     }
    4022             :     else {
    4023           9 :         COPYSLOT(tp_compare);
    4024             :     }
    4025        3168 :     if (type->tp_flags & base->tp_flags & Py_TPFLAGS_HAVE_ITER) {
    4026        3159 :         COPYSLOT(tp_iter);
    4027        3159 :         COPYSLOT(tp_iternext);
    4028             :     }
    4029        3168 :     if (type->tp_flags & base->tp_flags & Py_TPFLAGS_HAVE_CLASS) {
    4030        3159 :         COPYSLOT(tp_descr_get);
    4031        3159 :         COPYSLOT(tp_descr_set);
    4032        3159 :         COPYSLOT(tp_dictoffset);
    4033        3159 :         COPYSLOT(tp_init);
    4034        3159 :         COPYSLOT(tp_alloc);
    4035        3159 :         COPYSLOT(tp_is_gc);
    4036        6318 :         if ((type->tp_flags & Py_TPFLAGS_HAVE_GC) ==
    4037        3159 :             (base->tp_flags & Py_TPFLAGS_HAVE_GC)) {
    4038             :             /* They agree about gc. */
    4039        1971 :             COPYSLOT(tp_free);
    4040             :         }
    4041        2376 :         else if ((type->tp_flags & Py_TPFLAGS_HAVE_GC) &&
    4042        1281 :                  type->tp_free == NULL &&
    4043          93 :                  base->tp_free == _PyObject_Del) {
    4044             :             /* A bit of magic to plug in the correct default
    4045             :              * tp_free function when a derived class adds gc,
    4046             :              * didn't define tp_free, and the base uses the
    4047             :              * default non-gc tp_free.
    4048             :              */
    4049          93 :             type->tp_free = PyObject_GC_Del;
    4050             :         }
    4051             :         /* else they didn't agree about gc, and there isn't something
    4052             :          * obvious to be done -- the type is on its own.
    4053             :          */
    4054             :     }
    4055        3168 : }
    4056             : 
    4057             : static int add_operators(PyTypeObject *);
    4058             : 
    4059             : int
    4060        1308 : PyType_Ready(PyTypeObject *type)
    4061             : {
    4062             :     PyObject *dict, *bases;
    4063             :     PyTypeObject *base;
    4064             :     Py_ssize_t i, n;
    4065             : 
    4066        1308 :     if (type->tp_flags & Py_TPFLAGS_READY) {
    4067             :         assert(type->tp_dict != NULL);
    4068          12 :         return 0;
    4069             :     }
    4070             :     assert((type->tp_flags & Py_TPFLAGS_READYING) == 0);
    4071             : 
    4072        1296 :     type->tp_flags |= Py_TPFLAGS_READYING;
    4073             : 
    4074             : #ifdef Py_TRACE_REFS
    4075             :     /* PyType_Ready is the closest thing we have to a choke point
    4076             :      * for type objects, so is the best place I can think of to try
    4077             :      * to get type objects into the doubly-linked list of all objects.
    4078             :      * Still, not all type objects go thru PyType_Ready.
    4079             :      */
    4080             :     _Py_AddToAllObjects((PyObject *)type, 0);
    4081             : #endif
    4082             : 
    4083        1296 :     if (type->tp_name == NULL) {
    4084           0 :         PyErr_Format(PyExc_SystemError,
    4085             :                      "Type does not define the tp_name field.");
    4086           0 :         goto error;
    4087             :     }
    4088             : 
    4089             :     /* Initialize tp_base (defaults to BaseObject unless that's us) */
    4090        1296 :     base = type->tp_base;
    4091        1296 :     if (base == NULL && type != &PyBaseObject_Type) {
    4092         312 :         base = type->tp_base = &PyBaseObject_Type;
    4093         312 :         Py_INCREF(base);
    4094             :     }
    4095             : 
    4096             :     /* Now the only way base can still be NULL is if type is
    4097             :      * &PyBaseObject_Type.
    4098             :      */
    4099             : 
    4100             :     /* Initialize the base class */
    4101        1296 :     if (base && base->tp_dict == NULL) {
    4102           9 :         if (PyType_Ready(base) < 0)
    4103           0 :             goto error;
    4104             :     }
    4105             : 
    4106             :     /* Initialize ob_type if NULL.      This means extensions that want to be
    4107             :        compilable separately on Windows can call PyType_Ready() instead of
    4108             :        initializing the ob_type field of their type objects. */
    4109             :     /* The test for base != NULL is really unnecessary, since base is only
    4110             :        NULL when type is &PyBaseObject_Type, and we know its ob_type is
    4111             :        not NULL (it's initialized to &PyType_Type).      But coverity doesn't
    4112             :        know that. */
    4113        1296 :     if (Py_TYPE(type) == NULL && base != NULL)
    4114         300 :         Py_TYPE(type) = Py_TYPE(base);
    4115             : 
    4116             :     /* Initialize tp_bases */
    4117        1296 :     bases = type->tp_bases;
    4118        1296 :     if (bases == NULL) {
    4119         507 :         if (base == NULL)
    4120           3 :             bases = PyTuple_New(0);
    4121             :         else
    4122         504 :             bases = PyTuple_Pack(1, base);
    4123         507 :         if (bases == NULL)
    4124           0 :             goto error;
    4125         507 :         type->tp_bases = bases;
    4126             :     }
    4127             : 
    4128             :     /* Initialize tp_dict */
    4129        1296 :     dict = type->tp_dict;
    4130        1296 :     if (dict == NULL) {
    4131         507 :         dict = PyDict_New();
    4132         507 :         if (dict == NULL)
    4133           0 :             goto error;
    4134         507 :         type->tp_dict = dict;
    4135             :     }
    4136             : 
    4137             :     /* Add type-specific descriptors to tp_dict */
    4138        1296 :     if (add_operators(type) < 0)
    4139           0 :         goto error;
    4140        1296 :     if (type->tp_methods != NULL) {
    4141         219 :         if (add_methods(type, type->tp_methods) < 0)
    4142           0 :             goto error;
    4143             :     }
    4144        1296 :     if (type->tp_members != NULL) {
    4145         933 :         if (add_members(type, type->tp_members) < 0)
    4146           0 :             goto error;
    4147             :     }
    4148        1296 :     if (type->tp_getset != NULL) {
    4149         429 :         if (add_getset(type, type->tp_getset) < 0)
    4150           0 :             goto error;
    4151             :     }
    4152             : 
    4153             :     /* Calculate method resolution order */
    4154        1296 :     if (mro_internal(type) < 0) {
    4155           0 :         goto error;
    4156             :     }
    4157             : 
    4158             :     /* Inherit special flags from dominant base */
    4159        1296 :     if (type->tp_base != NULL)
    4160        1293 :         inherit_special(type, type->tp_base);
    4161             : 
    4162             :     /* Initialize tp_dict properly */
    4163        1296 :     bases = type->tp_mro;
    4164             :     assert(bases != NULL);
    4165             :     assert(PyTuple_Check(bases));
    4166        1296 :     n = PyTuple_GET_SIZE(bases);
    4167        4464 :     for (i = 1; i < n; i++) {
    4168        3168 :         PyObject *b = PyTuple_GET_ITEM(bases, i);
    4169        3168 :         if (PyType_Check(b))
    4170        3168 :             inherit_slots(type, (PyTypeObject *)b);
    4171             :     }
    4172             : 
    4173             :     /* All bases of statically allocated type should be statically allocated */
    4174        1296 :     if (Py_Py3kWarningFlag && !(type->tp_flags & Py_TPFLAGS_HEAPTYPE))
    4175           0 :         for (i = 0; i < n; i++) {
    4176           0 :             PyObject *b = PyTuple_GET_ITEM(bases, i);
    4177           0 :             if (PyType_Check(b) &&
    4178           0 :                 (((PyTypeObject *)b)->tp_flags & Py_TPFLAGS_HEAPTYPE)) {
    4179             :                 char buf[300];
    4180           0 :                 PyOS_snprintf(buf, sizeof(buf),
    4181             :                               "type '%.100s' is not dynamically allocated but "
    4182             :                               "its base type '%.100s' is dynamically allocated",
    4183             :                               type->tp_name, ((PyTypeObject *)b)->tp_name);
    4184           0 :                 if (PyErr_WarnPy3k(buf, 1) < 0)
    4185           0 :                     goto error;
    4186           0 :                 break;
    4187             :             }
    4188             :         }
    4189             : 
    4190             :     /* Sanity check for tp_free. */
    4191        2379 :     if (PyType_IS_GC(type) && (type->tp_flags & Py_TPFLAGS_BASETYPE) &&
    4192        2166 :         (type->tp_free == NULL || type->tp_free == PyObject_Del)) {
    4193             :         /* This base class needs to call tp_free, but doesn't have
    4194             :          * one, or its tp_free is for non-gc'ed objects.
    4195             :          */
    4196           0 :         PyErr_Format(PyExc_TypeError, "type '%.100s' participates in "
    4197             :                      "gc and is a base type but has inappropriate "
    4198             :                      "tp_free slot",
    4199             :                      type->tp_name);
    4200           0 :         goto error;
    4201             :     }
    4202             : 
    4203             :     /* if the type dictionary doesn't contain a __doc__, set it from
    4204             :        the tp_doc slot.
    4205             :      */
    4206        1296 :     if (PyDict_GetItemString(type->tp_dict, "__doc__") == NULL) {
    4207         996 :         if (type->tp_doc != NULL) {
    4208         414 :             PyObject *doc = PyString_FromString(type->tp_doc);
    4209         414 :             if (doc == NULL)
    4210           0 :                 goto error;
    4211         414 :             PyDict_SetItemString(type->tp_dict, "__doc__", doc);
    4212         414 :             Py_DECREF(doc);
    4213             :         } else {
    4214         582 :             PyDict_SetItemString(type->tp_dict,
    4215             :                                  "__doc__", Py_None);
    4216             :         }
    4217             :     }
    4218             : 
    4219             :     /* Some more special stuff */
    4220        1296 :     base = type->tp_base;
    4221        1296 :     if (base != NULL) {
    4222        1293 :         if (type->tp_as_number == NULL)
    4223         462 :             type->tp_as_number = base->tp_as_number;
    4224        1293 :         if (type->tp_as_sequence == NULL)
    4225         420 :             type->tp_as_sequence = base->tp_as_sequence;
    4226        1293 :         if (type->tp_as_mapping == NULL)
    4227         444 :             type->tp_as_mapping = base->tp_as_mapping;
    4228        1293 :         if (type->tp_as_buffer == NULL)
    4229         489 :             type->tp_as_buffer = base->tp_as_buffer;
    4230             :     }
    4231             : 
    4232             :     /* Link into each base class's list of subclasses */
    4233        1296 :     bases = type->tp_bases;
    4234        1296 :     n = PyTuple_GET_SIZE(bases);
    4235        2634 :     for (i = 0; i < n; i++) {
    4236        1338 :         PyObject *b = PyTuple_GET_ITEM(bases, i);
    4237        2676 :         if (PyType_Check(b) &&
    4238        1338 :             add_subclass((PyTypeObject *)b, type) < 0)
    4239           0 :             goto error;
    4240             :     }
    4241             : 
    4242             :     /* All done -- set the ready flag */
    4243             :     assert(type->tp_dict != NULL);
    4244        1296 :     type->tp_flags =
    4245        1296 :         (type->tp_flags & ~Py_TPFLAGS_READYING) | Py_TPFLAGS_READY;
    4246        1296 :     return 0;
    4247             : 
    4248             :   error:
    4249           0 :     type->tp_flags &= ~Py_TPFLAGS_READYING;
    4250           0 :     return -1;
    4251             : }
    4252             : 
    4253             : static int
    4254        1338 : add_subclass(PyTypeObject *base, PyTypeObject *type)
    4255             : {
    4256             :     Py_ssize_t i;
    4257             :     int result;
    4258             :     PyObject *list, *ref, *newobj;
    4259             : 
    4260        1338 :     list = base->tp_subclasses;
    4261        1338 :     if (list == NULL) {
    4262         213 :         base->tp_subclasses = list = PyList_New(0);
    4263         213 :         if (list == NULL)
    4264           0 :             return -1;
    4265             :     }
    4266             :     assert(PyList_Check(list));
    4267        1338 :     newobj = PyWeakref_NewRef((PyObject *)type, NULL);
    4268        1338 :     i = PyList_GET_SIZE(list);
    4269       55869 :     while (--i >= 0) {
    4270       53193 :         ref = PyList_GET_ITEM(list, i);
    4271             :         assert(PyWeakref_CheckRef(ref));
    4272       53193 :         if (PyWeakref_GET_OBJECT(ref) == Py_None)
    4273           0 :             return PyList_SetItem(list, i, newobj);
    4274             :     }
    4275        1338 :     result = PyList_Append(list, newobj);
    4276        1338 :     Py_DECREF(newobj);
    4277        1338 :     return result;
    4278             : }
    4279             : 
    4280             : static void
    4281           0 : remove_subclass(PyTypeObject *base, PyTypeObject *type)
    4282             : {
    4283             :     Py_ssize_t i;
    4284             :     PyObject *list, *ref;
    4285             : 
    4286           0 :     list = base->tp_subclasses;
    4287           0 :     if (list == NULL) {
    4288           0 :         return;
    4289             :     }
    4290             :     assert(PyList_Check(list));
    4291           0 :     i = PyList_GET_SIZE(list);
    4292           0 :     while (--i >= 0) {
    4293           0 :         ref = PyList_GET_ITEM(list, i);
    4294             :         assert(PyWeakref_CheckRef(ref));
    4295           0 :         if (PyWeakref_GET_OBJECT(ref) == (PyObject*)type) {
    4296             :             /* this can't fail, right? */
    4297           0 :             PySequence_DelItem(list, i);
    4298           0 :             return;
    4299             :         }
    4300             :     }
    4301             : }
    4302             : 
    4303             : static int
    4304           0 : check_num_args(PyObject *ob, int n)
    4305             : {
    4306           0 :     if (!PyTuple_CheckExact(ob)) {
    4307           0 :         PyErr_SetString(PyExc_SystemError,
    4308             :             "PyArg_UnpackTuple() argument list is not a tuple");
    4309           0 :         return 0;
    4310             :     }
    4311           0 :     if (n == PyTuple_GET_SIZE(ob))
    4312           0 :         return 1;
    4313           0 :     PyErr_Format(
    4314             :         PyExc_TypeError,
    4315             :         "expected %d arguments, got %zd", n, PyTuple_GET_SIZE(ob));
    4316           0 :     return 0;
    4317             : }
    4318             : 
    4319             : /* Generic wrappers for overloadable 'operators' such as __getitem__ */
    4320             : 
    4321             : /* There's a wrapper *function* for each distinct function typedef used
    4322             :    for type object slots (e.g. binaryfunc, ternaryfunc, etc.).  There's a
    4323             :    wrapper *table* for each distinct operation (e.g. __len__, __add__).
    4324             :    Most tables have only one entry; the tables for binary operators have two
    4325             :    entries, one regular and one with reversed arguments. */
    4326             : 
    4327             : static PyObject *
    4328           0 : wrap_lenfunc(PyObject *self, PyObject *args, void *wrapped)
    4329             : {
    4330           0 :     lenfunc func = (lenfunc)wrapped;
    4331             :     Py_ssize_t res;
    4332             : 
    4333           0 :     if (!check_num_args(args, 0))
    4334           0 :         return NULL;
    4335           0 :     res = (*func)(self);
    4336           0 :     if (res == -1 && PyErr_Occurred())
    4337           0 :         return NULL;
    4338           0 :     return PyInt_FromLong((long)res);
    4339             : }
    4340             : 
    4341             : static PyObject *
    4342           0 : wrap_inquirypred(PyObject *self, PyObject *args, void *wrapped)
    4343             : {
    4344           0 :     inquiry func = (inquiry)wrapped;
    4345             :     int res;
    4346             : 
    4347           0 :     if (!check_num_args(args, 0))
    4348           0 :         return NULL;
    4349           0 :     res = (*func)(self);
    4350           0 :     if (res == -1 && PyErr_Occurred())
    4351           0 :         return NULL;
    4352           0 :     return PyBool_FromLong((long)res);
    4353             : }
    4354             : 
    4355             : static PyObject *
    4356           0 : wrap_binaryfunc(PyObject *self, PyObject *args, void *wrapped)
    4357             : {
    4358           0 :     binaryfunc func = (binaryfunc)wrapped;
    4359             :     PyObject *other;
    4360             : 
    4361           0 :     if (!check_num_args(args, 1))
    4362           0 :         return NULL;
    4363           0 :     other = PyTuple_GET_ITEM(args, 0);
    4364           0 :     return (*func)(self, other);
    4365             : }
    4366             : 
    4367             : static PyObject *
    4368           0 : wrap_binaryfunc_l(PyObject *self, PyObject *args, void *wrapped)
    4369             : {
    4370           0 :     binaryfunc func = (binaryfunc)wrapped;
    4371             :     PyObject *other;
    4372             : 
    4373           0 :     if (!check_num_args(args, 1))
    4374           0 :         return NULL;
    4375           0 :     other = PyTuple_GET_ITEM(args, 0);
    4376           0 :     if (!(self->ob_type->tp_flags & Py_TPFLAGS_CHECKTYPES) &&
    4377           0 :         !PyType_IsSubtype(other->ob_type, self->ob_type)) {
    4378           0 :         Py_INCREF(Py_NotImplemented);
    4379           0 :         return Py_NotImplemented;
    4380             :     }
    4381           0 :     return (*func)(self, other);
    4382             : }
    4383             : 
    4384             : static PyObject *
    4385           0 : wrap_binaryfunc_r(PyObject *self, PyObject *args, void *wrapped)
    4386             : {
    4387           0 :     binaryfunc func = (binaryfunc)wrapped;
    4388             :     PyObject *other;
    4389             : 
    4390           0 :     if (!check_num_args(args, 1))
    4391           0 :         return NULL;
    4392           0 :     other = PyTuple_GET_ITEM(args, 0);
    4393           0 :     if (!(self->ob_type->tp_flags & Py_TPFLAGS_CHECKTYPES) &&
    4394           0 :         !PyType_IsSubtype(other->ob_type, self->ob_type)) {
    4395           0 :         Py_INCREF(Py_NotImplemented);
    4396           0 :         return Py_NotImplemented;
    4397             :     }
    4398           0 :     return (*func)(other, self);
    4399             : }
    4400             : 
    4401             : static PyObject *
    4402           0 : wrap_coercefunc(PyObject *self, PyObject *args, void *wrapped)
    4403             : {
    4404           0 :     coercion func = (coercion)wrapped;
    4405             :     PyObject *other, *res;
    4406             :     int ok;
    4407             : 
    4408           0 :     if (!check_num_args(args, 1))
    4409           0 :         return NULL;
    4410           0 :     other = PyTuple_GET_ITEM(args, 0);
    4411           0 :     ok = func(&self, &other);
    4412           0 :     if (ok < 0)
    4413           0 :         return NULL;
    4414           0 :     if (ok > 0) {
    4415           0 :         Py_INCREF(Py_NotImplemented);
    4416           0 :         return Py_NotImplemented;
    4417             :     }
    4418           0 :     res = PyTuple_New(2);
    4419           0 :     if (res == NULL) {
    4420           0 :         Py_DECREF(self);
    4421           0 :         Py_DECREF(other);
    4422           0 :         return NULL;
    4423             :     }
    4424           0 :     PyTuple_SET_ITEM(res, 0, self);
    4425           0 :     PyTuple_SET_ITEM(res, 1, other);
    4426           0 :     return res;
    4427             : }
    4428             : 
    4429             : static PyObject *
    4430           0 : wrap_ternaryfunc(PyObject *self, PyObject *args, void *wrapped)
    4431             : {
    4432           0 :     ternaryfunc func = (ternaryfunc)wrapped;
    4433             :     PyObject *other;
    4434           0 :     PyObject *third = Py_None;
    4435             : 
    4436             :     /* Note: This wrapper only works for __pow__() */
    4437             : 
    4438           0 :     if (!PyArg_UnpackTuple(args, "", 1, 2, &other, &third))
    4439           0 :         return NULL;
    4440           0 :     return (*func)(self, other, third);
    4441             : }
    4442             : 
    4443             : static PyObject *
    4444           0 : wrap_ternaryfunc_r(PyObject *self, PyObject *args, void *wrapped)
    4445             : {
    4446           0 :     ternaryfunc func = (ternaryfunc)wrapped;
    4447             :     PyObject *other;
    4448           0 :     PyObject *third = Py_None;
    4449             : 
    4450             :     /* Note: This wrapper only works for __pow__() */
    4451             : 
    4452           0 :     if (!PyArg_UnpackTuple(args, "", 1, 2, &other, &third))
    4453           0 :         return NULL;
    4454           0 :     return (*func)(other, self, third);
    4455             : }
    4456             : 
    4457             : static PyObject *
    4458           0 : wrap_unaryfunc(PyObject *self, PyObject *args, void *wrapped)
    4459             : {
    4460           0 :     unaryfunc func = (unaryfunc)wrapped;
    4461             : 
    4462           0 :     if (!check_num_args(args, 0))
    4463           0 :         return NULL;
    4464           0 :     return (*func)(self);
    4465             : }
    4466             : 
    4467             : static PyObject *
    4468           0 : wrap_indexargfunc(PyObject *self, PyObject *args, void *wrapped)
    4469             : {
    4470           0 :     ssizeargfunc func = (ssizeargfunc)wrapped;
    4471             :     PyObject* o;
    4472             :     Py_ssize_t i;
    4473             : 
    4474           0 :     if (!PyArg_UnpackTuple(args, "", 1, 1, &o))
    4475           0 :         return NULL;
    4476           0 :     i = PyNumber_AsSsize_t(o, PyExc_OverflowError);
    4477           0 :     if (i == -1 && PyErr_Occurred())
    4478           0 :         return NULL;
    4479           0 :     return (*func)(self, i);
    4480             : }
    4481             : 
    4482             : static Py_ssize_t
    4483           0 : getindex(PyObject *self, PyObject *arg)
    4484             : {
    4485             :     Py_ssize_t i;
    4486             : 
    4487           0 :     i = PyNumber_AsSsize_t(arg, PyExc_OverflowError);
    4488           0 :     if (i == -1 && PyErr_Occurred())
    4489           0 :         return -1;
    4490           0 :     if (i < 0) {
    4491           0 :         PySequenceMethods *sq = Py_TYPE(self)->tp_as_sequence;
    4492           0 :         if (sq && sq->sq_length) {
    4493           0 :             Py_ssize_t n = (*sq->sq_length)(self);
    4494           0 :             if (n < 0)
    4495           0 :                 return -1;
    4496           0 :             i += n;
    4497             :         }
    4498             :     }
    4499           0 :     return i;
    4500             : }
    4501             : 
    4502             : static PyObject *
    4503           0 : wrap_sq_item(PyObject *self, PyObject *args, void *wrapped)
    4504             : {
    4505           0 :     ssizeargfunc func = (ssizeargfunc)wrapped;
    4506             :     PyObject *arg;
    4507             :     Py_ssize_t i;
    4508             : 
    4509           0 :     if (PyTuple_GET_SIZE(args) == 1) {
    4510           0 :         arg = PyTuple_GET_ITEM(args, 0);
    4511           0 :         i = getindex(self, arg);
    4512           0 :         if (i == -1 && PyErr_Occurred())
    4513           0 :             return NULL;
    4514           0 :         return (*func)(self, i);
    4515             :     }
    4516           0 :     check_num_args(args, 1);
    4517             :     assert(PyErr_Occurred());
    4518           0 :     return NULL;
    4519             : }
    4520             : 
    4521             : static PyObject *
    4522           0 : wrap_ssizessizeargfunc(PyObject *self, PyObject *args, void *wrapped)
    4523             : {
    4524           0 :     ssizessizeargfunc func = (ssizessizeargfunc)wrapped;
    4525             :     Py_ssize_t i, j;
    4526             : 
    4527           0 :     if (!PyArg_ParseTuple(args, "nn", &i, &j))
    4528           0 :         return NULL;
    4529           0 :     return (*func)(self, i, j);
    4530             : }
    4531             : 
    4532             : static PyObject *
    4533           0 : wrap_sq_setitem(PyObject *self, PyObject *args, void *wrapped)
    4534             : {
    4535           0 :     ssizeobjargproc func = (ssizeobjargproc)wrapped;
    4536             :     Py_ssize_t i;
    4537             :     int res;
    4538             :     PyObject *arg, *value;
    4539             : 
    4540           0 :     if (!PyArg_UnpackTuple(args, "", 2, 2, &arg, &value))
    4541           0 :         return NULL;
    4542           0 :     i = getindex(self, arg);
    4543           0 :     if (i == -1 && PyErr_Occurred())
    4544           0 :         return NULL;
    4545           0 :     res = (*func)(self, i, value);
    4546           0 :     if (res == -1 && PyErr_Occurred())
    4547           0 :         return NULL;
    4548           0 :     Py_INCREF(Py_None);
    4549           0 :     return Py_None;
    4550             : }
    4551             : 
    4552             : static PyObject *
    4553           0 : wrap_sq_delitem(PyObject *self, PyObject *args, void *wrapped)
    4554             : {
    4555           0 :     ssizeobjargproc func = (ssizeobjargproc)wrapped;
    4556             :     Py_ssize_t i;
    4557             :     int res;
    4558             :     PyObject *arg;
    4559             : 
    4560           0 :     if (!check_num_args(args, 1))
    4561           0 :         return NULL;
    4562           0 :     arg = PyTuple_GET_ITEM(args, 0);
    4563           0 :     i = getindex(self, arg);
    4564           0 :     if (i == -1 && PyErr_Occurred())
    4565           0 :         return NULL;
    4566           0 :     res = (*func)(self, i, NULL);
    4567           0 :     if (res == -1 && PyErr_Occurred())
    4568           0 :         return NULL;
    4569           0 :     Py_INCREF(Py_None);
    4570           0 :     return Py_None;
    4571             : }
    4572             : 
    4573             : static PyObject *
    4574           0 : wrap_ssizessizeobjargproc(PyObject *self, PyObject *args, void *wrapped)
    4575             : {
    4576           0 :     ssizessizeobjargproc func = (ssizessizeobjargproc)wrapped;
    4577             :     Py_ssize_t i, j;
    4578             :     int res;
    4579             :     PyObject *value;
    4580             : 
    4581           0 :     if (!PyArg_ParseTuple(args, "nnO", &i, &j, &value))
    4582           0 :         return NULL;
    4583           0 :     res = (*func)(self, i, j, value);
    4584           0 :     if (res == -1 && PyErr_Occurred())
    4585           0 :         return NULL;
    4586           0 :     Py_INCREF(Py_None);
    4587           0 :     return Py_None;
    4588             : }
    4589             : 
    4590             : static PyObject *
    4591           0 : wrap_delslice(PyObject *self, PyObject *args, void *wrapped)
    4592             : {
    4593           0 :     ssizessizeobjargproc func = (ssizessizeobjargproc)wrapped;
    4594             :     Py_ssize_t i, j;
    4595             :     int res;
    4596             : 
    4597           0 :     if (!PyArg_ParseTuple(args, "nn", &i, &j))
    4598           0 :         return NULL;
    4599           0 :     res = (*func)(self, i, j, NULL);
    4600           0 :     if (res == -1 && PyErr_Occurred())
    4601           0 :         return NULL;
    4602           0 :     Py_INCREF(Py_None);
    4603           0 :     return Py_None;
    4604             : }
    4605             : 
    4606             : /* XXX objobjproc is a misnomer; should be objargpred */
    4607             : static PyObject *
    4608           0 : wrap_objobjproc(PyObject *self, PyObject *args, void *wrapped)
    4609             : {
    4610           0 :     objobjproc func = (objobjproc)wrapped;
    4611             :     int res;
    4612             :     PyObject *value;
    4613             : 
    4614           0 :     if (!check_num_args(args, 1))
    4615           0 :         return NULL;
    4616           0 :     value = PyTuple_GET_ITEM(args, 0);
    4617           0 :     res = (*func)(self, value);
    4618           0 :     if (res == -1 && PyErr_Occurred())
    4619           0 :         return NULL;
    4620             :     else
    4621           0 :         return PyBool_FromLong(res);
    4622             : }
    4623             : 
    4624             : static PyObject *
    4625           0 : wrap_objobjargproc(PyObject *self, PyObject *args, void *wrapped)
    4626             : {
    4627           0 :     objobjargproc func = (objobjargproc)wrapped;
    4628             :     int res;
    4629             :     PyObject *key, *value;
    4630             : 
    4631           0 :     if (!PyArg_UnpackTuple(args, "", 2, 2, &key, &value))
    4632           0 :         return NULL;
    4633           0 :     res = (*func)(self, key, value);
    4634           0 :     if (res == -1 && PyErr_Occurred())
    4635           0 :         return NULL;
    4636           0 :     Py_INCREF(Py_None);
    4637           0 :     return Py_None;
    4638             : }
    4639             : 
    4640             : static PyObject *
    4641           0 : wrap_delitem(PyObject *self, PyObject *args, void *wrapped)
    4642             : {
    4643           0 :     objobjargproc func = (objobjargproc)wrapped;
    4644             :     int res;
    4645             :     PyObject *key;
    4646             : 
    4647           0 :     if (!check_num_args(args, 1))
    4648           0 :         return NULL;
    4649           0 :     key = PyTuple_GET_ITEM(args, 0);
    4650           0 :     res = (*func)(self, key, NULL);
    4651           0 :     if (res == -1 && PyErr_Occurred())
    4652           0 :         return NULL;
    4653           0 :     Py_INCREF(Py_None);
    4654           0 :     return Py_None;
    4655             : }
    4656             : 
    4657             : static PyObject *
    4658           0 : wrap_cmpfunc(PyObject *self, PyObject *args, void *wrapped)
    4659             : {
    4660           0 :     cmpfunc func = (cmpfunc)wrapped;
    4661             :     int res;
    4662             :     PyObject *other;
    4663             : 
    4664           0 :     if (!check_num_args(args, 1))
    4665           0 :         return NULL;
    4666           0 :     other = PyTuple_GET_ITEM(args, 0);
    4667           0 :     if (Py_TYPE(other)->tp_compare != func &&
    4668           0 :         !PyType_IsSubtype(Py_TYPE(other), Py_TYPE(self))) {
    4669           0 :         PyErr_Format(
    4670             :             PyExc_TypeError,
    4671             :             "%s.__cmp__(x,y) requires y to be a '%s', not a '%s'",
    4672           0 :             Py_TYPE(self)->tp_name,
    4673           0 :             Py_TYPE(self)->tp_name,
    4674           0 :             Py_TYPE(other)->tp_name);
    4675           0 :         return NULL;
    4676             :     }
    4677           0 :     res = (*func)(self, other);
    4678           0 :     if (PyErr_Occurred())
    4679           0 :         return NULL;
    4680           0 :     return PyInt_FromLong((long)res);
    4681             : }
    4682             : 
    4683             : /* Helper to check for object.__setattr__ or __delattr__ applied to a type.
    4684             :    This is called the Carlo Verre hack after its discoverer. */
    4685             : static int
    4686           0 : hackcheck(PyObject *self, setattrofunc func, char *what)
    4687             : {
    4688           0 :     PyTypeObject *type = Py_TYPE(self);
    4689           0 :     while (type && type->tp_flags & Py_TPFLAGS_HEAPTYPE)
    4690           0 :         type = type->tp_base;
    4691             :     /* If type is NULL now, this is a really weird type.
    4692             :        In the spirit of backwards compatibility (?), just shut up. */
    4693           0 :     if (type && type->tp_setattro != func) {
    4694           0 :         PyErr_Format(PyExc_TypeError,
    4695             :                      "can't apply this %s to %s object",
    4696             :                      what,
    4697             :                      type->tp_name);
    4698           0 :         return 0;
    4699             :     }
    4700           0 :     return 1;
    4701             : }
    4702             : 
    4703             : static PyObject *
    4704           0 : wrap_setattr(PyObject *self, PyObject *args, void *wrapped)
    4705             : {
    4706           0 :     setattrofunc func = (setattrofunc)wrapped;
    4707             :     int res;
    4708             :     PyObject *name, *value;
    4709             : 
    4710           0 :     if (!PyArg_UnpackTuple(args, "", 2, 2, &name, &value))
    4711           0 :         return NULL;
    4712           0 :     if (!hackcheck(self, func, "__setattr__"))
    4713           0 :         return NULL;
    4714           0 :     res = (*func)(self, name, value);
    4715           0 :     if (res < 0)
    4716           0 :         return NULL;
    4717           0 :     Py_INCREF(Py_None);
    4718           0 :     return Py_None;
    4719             : }
    4720             : 
    4721             : static PyObject *
    4722           0 : wrap_delattr(PyObject *self, PyObject *args, void *wrapped)
    4723             : {
    4724           0 :     setattrofunc func = (setattrofunc)wrapped;
    4725             :     int res;
    4726             :     PyObject *name;
    4727             : 
    4728           0 :     if (!check_num_args(args, 1))
    4729           0 :         return NULL;
    4730           0 :     name = PyTuple_GET_ITEM(args, 0);
    4731           0 :     if (!hackcheck(self, func, "__delattr__"))
    4732           0 :         return NULL;
    4733           0 :     res = (*func)(self, name, NULL);
    4734           0 :     if (res < 0)
    4735           0 :         return NULL;
    4736           0 :     Py_INCREF(Py_None);
    4737           0 :     return Py_None;
    4738             : }
    4739             : 
    4740             : static PyObject *
    4741           0 : wrap_hashfunc(PyObject *self, PyObject *args, void *wrapped)
    4742             : {
    4743           0 :     hashfunc func = (hashfunc)wrapped;
    4744             :     long res;
    4745             : 
    4746           0 :     if (!check_num_args(args, 0))
    4747           0 :         return NULL;
    4748           0 :     res = (*func)(self);
    4749           0 :     if (res == -1 && PyErr_Occurred())
    4750           0 :         return NULL;
    4751           0 :     return PyInt_FromLong(res);
    4752             : }
    4753             : 
    4754             : static PyObject *
    4755           0 : wrap_call(PyObject *self, PyObject *args, void *wrapped, PyObject *kwds)
    4756             : {
    4757           0 :     ternaryfunc func = (ternaryfunc)wrapped;
    4758             : 
    4759           0 :     return (*func)(self, args, kwds);
    4760             : }
    4761             : 
    4762             : static PyObject *
    4763           0 : wrap_richcmpfunc(PyObject *self, PyObject *args, void *wrapped, int op)
    4764             : {
    4765           0 :     richcmpfunc func = (richcmpfunc)wrapped;
    4766             :     PyObject *other;
    4767             : 
    4768           0 :     if (!check_num_args(args, 1))
    4769           0 :         return NULL;
    4770           0 :     other = PyTuple_GET_ITEM(args, 0);
    4771           0 :     return (*func)(self, other, op);
    4772             : }
    4773             : 
    4774             : #undef RICHCMP_WRAPPER
    4775             : #define RICHCMP_WRAPPER(NAME, OP) \
    4776             : static PyObject * \
    4777             : richcmp_##NAME(PyObject *self, PyObject *args, void *wrapped) \
    4778             : { \
    4779             :     return wrap_richcmpfunc(self, args, wrapped, OP); \
    4780             : }
    4781             : 
    4782           0 : RICHCMP_WRAPPER(lt, Py_LT)
    4783           0 : RICHCMP_WRAPPER(le, Py_LE)
    4784           0 : RICHCMP_WRAPPER(eq, Py_EQ)
    4785           0 : RICHCMP_WRAPPER(ne, Py_NE)
    4786           0 : RICHCMP_WRAPPER(gt, Py_GT)
    4787           0 : RICHCMP_WRAPPER(ge, Py_GE)
    4788             : 
    4789             : static PyObject *
    4790           0 : wrap_next(PyObject *self, PyObject *args, void *wrapped)
    4791             : {
    4792           0 :     unaryfunc func = (unaryfunc)wrapped;
    4793             :     PyObject *res;
    4794             : 
    4795           0 :     if (!check_num_args(args, 0))
    4796           0 :         return NULL;
    4797           0 :     res = (*func)(self);
    4798           0 :     if (res == NULL && !PyErr_Occurred())
    4799           0 :         PyErr_SetNone(PyExc_StopIteration);
    4800           0 :     return res;
    4801             : }
    4802             : 
    4803             : static PyObject *
    4804           0 : wrap_descr_get(PyObject *self, PyObject *args, void *wrapped)
    4805             : {
    4806           0 :     descrgetfunc func = (descrgetfunc)wrapped;
    4807             :     PyObject *obj;
    4808           0 :     PyObject *type = NULL;
    4809             : 
    4810           0 :     if (!PyArg_UnpackTuple(args, "", 1, 2, &obj, &type))
    4811           0 :         return NULL;
    4812           0 :     if (obj == Py_None)
    4813           0 :         obj = NULL;
    4814           0 :     if (type == Py_None)
    4815           0 :         type = NULL;
    4816           0 :     if (type == NULL &&obj == NULL) {
    4817           0 :         PyErr_SetString(PyExc_TypeError,
    4818             :                         "__get__(None, None) is invalid");
    4819           0 :         return NULL;
    4820             :     }
    4821           0 :     return (*func)(self, obj, type);
    4822             : }
    4823             : 
    4824             : static PyObject *
    4825           0 : wrap_descr_set(PyObject *self, PyObject *args, void *wrapped)
    4826             : {
    4827           0 :     descrsetfunc func = (descrsetfunc)wrapped;
    4828             :     PyObject *obj, *value;
    4829             :     int ret;
    4830             : 
    4831           0 :     if (!PyArg_UnpackTuple(args, "", 2, 2, &obj, &value))
    4832           0 :         return NULL;
    4833           0 :     ret = (*func)(self, obj, value);
    4834           0 :     if (ret < 0)
    4835           0 :         return NULL;
    4836           0 :     Py_INCREF(Py_None);
    4837           0 :     return Py_None;
    4838             : }
    4839             : 
    4840             : static PyObject *
    4841           0 : wrap_descr_delete(PyObject *self, PyObject *args, void *wrapped)
    4842             : {
    4843           0 :     descrsetfunc func = (descrsetfunc)wrapped;
    4844             :     PyObject *obj;
    4845             :     int ret;
    4846             : 
    4847           0 :     if (!check_num_args(args, 1))
    4848           0 :         return NULL;
    4849           0 :     obj = PyTuple_GET_ITEM(args, 0);
    4850           0 :     ret = (*func)(self, obj, NULL);
    4851           0 :     if (ret < 0)
    4852           0 :         return NULL;
    4853           0 :     Py_INCREF(Py_None);
    4854           0 :     return Py_None;
    4855             : }
    4856             : 
    4857             : static PyObject *
    4858           3 : wrap_init(PyObject *self, PyObject *args, void *wrapped, PyObject *kwds)
    4859             : {
    4860           3 :     initproc func = (initproc)wrapped;
    4861             : 
    4862           3 :     if (func(self, args, kwds) < 0)
    4863           0 :         return NULL;
    4864           3 :     Py_INCREF(Py_None);
    4865           3 :     return Py_None;
    4866             : }
    4867             : 
    4868             : static PyObject *
    4869        2475 : tp_new_wrapper(PyObject *self, PyObject *args, PyObject *kwds)
    4870             : {
    4871             :     PyTypeObject *type, *subtype, *staticbase;
    4872             :     PyObject *arg0, *res;
    4873             : 
    4874        2475 :     if (self == NULL || !PyType_Check(self))
    4875           0 :         Py_FatalError("__new__() called with non-type 'self'");
    4876        2475 :     type = (PyTypeObject *)self;
    4877        2475 :     if (!PyTuple_Check(args) || PyTuple_GET_SIZE(args) < 1) {
    4878           0 :         PyErr_Format(PyExc_TypeError,
    4879             :                      "%s.__new__(): not enough arguments",
    4880             :                      type->tp_name);
    4881           0 :         return NULL;
    4882             :     }
    4883        2475 :     arg0 = PyTuple_GET_ITEM(args, 0);
    4884        2475 :     if (!PyType_Check(arg0)) {
    4885           0 :         PyErr_Format(PyExc_TypeError,
    4886             :                      "%s.__new__(X): X is not a type object (%s)",
    4887             :                      type->tp_name,
    4888           0 :                      Py_TYPE(arg0)->tp_name);
    4889           0 :         return NULL;
    4890             :     }
    4891        2475 :     subtype = (PyTypeObject *)arg0;
    4892        2475 :     if (!PyType_IsSubtype(subtype, type)) {
    4893           0 :         PyErr_Format(PyExc_TypeError,
    4894             :                      "%s.__new__(%s): %s is not a subtype of %s",
    4895             :                      type->tp_name,
    4896             :                      subtype->tp_name,
    4897             :                      subtype->tp_name,
    4898             :                      type->tp_name);
    4899           0 :         return NULL;
    4900             :     }
    4901             : 
    4902             :     /* Check that the use doesn't do something silly and unsafe like
    4903             :        object.__new__(dict).  To do this, we check that the
    4904             :        most derived base that's not a heap type is this type. */
    4905        2475 :     staticbase = subtype;
    4906        7425 :     while (staticbase && (staticbase->tp_flags & Py_TPFLAGS_HEAPTYPE))
    4907        2475 :         staticbase = staticbase->tp_base;
    4908             :     /* If staticbase is NULL now, it is a really weird type.
    4909             :        In the spirit of backwards compatibility (?), just shut up. */
    4910        2475 :     if (staticbase && staticbase->tp_new != type->tp_new) {
    4911           0 :         PyErr_Format(PyExc_TypeError,
    4912             :                      "%s.__new__(%s) is not safe, use %s.__new__()",
    4913             :                      type->tp_name,
    4914             :                      subtype->tp_name,
    4915             :                      staticbase->tp_name);
    4916           0 :         return NULL;
    4917             :     }
    4918             : 
    4919        2475 :     args = PyTuple_GetSlice(args, 1, PyTuple_GET_SIZE(args));
    4920        2475 :     if (args == NULL)
    4921           0 :         return NULL;
    4922        2475 :     res = type->tp_new(subtype, args, kwds);
    4923        2475 :     Py_DECREF(args);
    4924        2475 :     return res;
    4925             : }
    4926             : 
    4927             : static struct PyMethodDef tp_new_methoddef[] = {
    4928             :     {"__new__", (PyCFunction)tp_new_wrapper, METH_VARARGS|METH_KEYWORDS,
    4929             :      PyDoc_STR("T.__new__(S, ...) -> "
    4930             :                "a new object with type S, a subtype of T")},
    4931             :     {0}
    4932             : };
    4933             : 
    4934             : static int
    4935         393 : add_tp_new_wrapper(PyTypeObject *type)
    4936             : {
    4937             :     PyObject *func;
    4938             : 
    4939         393 :     if (PyDict_GetItemString(type->tp_dict, "__new__") != NULL)
    4940           0 :         return 0;
    4941         393 :     func = PyCFunction_New(tp_new_methoddef, (PyObject *)type);
    4942         393 :     if (func == NULL)
    4943           0 :         return -1;
    4944         393 :     if (PyDict_SetItemString(type->tp_dict, "__new__", func)) {
    4945           0 :         Py_DECREF(func);
    4946           0 :         return -1;
    4947             :     }
    4948         393 :     Py_DECREF(func);
    4949         393 :     return 0;
    4950             : }
    4951             : 
    4952             : /* Slot wrappers that call the corresponding __foo__ slot.  See comments
    4953             :    below at override_slots() for more explanation. */
    4954             : 
    4955             : #define SLOT0(FUNCNAME, OPSTR) \
    4956             : static PyObject * \
    4957             : FUNCNAME(PyObject *self) \
    4958             : { \
    4959             :     static PyObject *cache_str; \
    4960             :     return call_method(self, OPSTR, &cache_str, "()"); \
    4961             : }
    4962             : 
    4963             : #define SLOT1(FUNCNAME, OPSTR, ARG1TYPE, ARGCODES) \
    4964             : static PyObject * \
    4965             : FUNCNAME(PyObject *self, ARG1TYPE arg1) \
    4966             : { \
    4967             :     static PyObject *cache_str; \
    4968             :     return call_method(self, OPSTR, &cache_str, "(" ARGCODES ")", arg1); \
    4969             : }
    4970             : 
    4971             : /* Boolean helper for SLOT1BINFULL().
    4972             :    right.__class__ is a nontrivial subclass of left.__class__. */
    4973             : static int
    4974           0 : method_is_overloaded(PyObject *left, PyObject *right, char *name)
    4975             : {
    4976             :     PyObject *a, *b;
    4977             :     int ok;
    4978             : 
    4979           0 :     b = PyObject_GetAttrString((PyObject *)(Py_TYPE(right)), name);
    4980           0 :     if (b == NULL) {
    4981           0 :         PyErr_Clear();
    4982             :         /* If right doesn't have it, it's not overloaded */
    4983           0 :         return 0;
    4984             :     }
    4985             : 
    4986           0 :     a = PyObject_GetAttrString((PyObject *)(Py_TYPE(left)), name);
    4987           0 :     if (a == NULL) {
    4988           0 :         PyErr_Clear();
    4989           0 :         Py_DECREF(b);
    4990             :         /* If right has it but left doesn't, it's overloaded */
    4991           0 :         return 1;
    4992             :     }
    4993             : 
    4994           0 :     ok = PyObject_RichCompareBool(a, b, Py_NE);
    4995           0 :     Py_DECREF(a);
    4996           0 :     Py_DECREF(b);
    4997           0 :     if (ok < 0) {
    4998           0 :         PyErr_Clear();
    4999           0 :         return 0;
    5000             :     }
    5001             : 
    5002           0 :     return ok;
    5003             : }
    5004             : 
    5005             : 
    5006             : #define SLOT1BINFULL(FUNCNAME, TESTFUNC, SLOTNAME, OPSTR, ROPSTR) \
    5007             : static PyObject * \
    5008             : FUNCNAME(PyObject *self, PyObject *other) \
    5009             : { \
    5010             :     static PyObject *cache_str, *rcache_str; \
    5011             :     int do_other = Py_TYPE(self) != Py_TYPE(other) && \
    5012             :         Py_TYPE(other)->tp_as_number != NULL && \
    5013             :         Py_TYPE(other)->tp_as_number->SLOTNAME == TESTFUNC; \
    5014             :     if (Py_TYPE(self)->tp_as_number != NULL && \
    5015             :         Py_TYPE(self)->tp_as_number->SLOTNAME == TESTFUNC) { \
    5016             :         PyObject *r; \
    5017             :         if (do_other && \
    5018             :             PyType_IsSubtype(Py_TYPE(other), Py_TYPE(self)) && \
    5019             :             method_is_overloaded(self, other, ROPSTR)) { \
    5020             :             r = call_maybe( \
    5021             :                 other, ROPSTR, &rcache_str, "(O)", self); \
    5022             :             if (r != Py_NotImplemented) \
    5023             :                 return r; \
    5024             :             Py_DECREF(r); \
    5025             :             do_other = 0; \
    5026             :         } \
    5027             :         r = call_maybe( \
    5028             :             self, OPSTR, &cache_str, "(O)", other); \
    5029             :         if (r != Py_NotImplemented || \
    5030             :             Py_TYPE(other) == Py_TYPE(self)) \
    5031             :             return r; \
    5032             :         Py_DECREF(r); \
    5033             :     } \
    5034             :     if (do_other) { \
    5035             :         return call_maybe( \
    5036             :             other, ROPSTR, &rcache_str, "(O)", self); \
    5037             :     } \
    5038             :     Py_INCREF(Py_NotImplemented); \
    5039             :     return Py_NotImplemented; \
    5040             : }
    5041             : 
    5042             : #define SLOT1BIN(FUNCNAME, SLOTNAME, OPSTR, ROPSTR) \
    5043             :     SLOT1BINFULL(FUNCNAME, FUNCNAME, SLOTNAME, OPSTR, ROPSTR)
    5044             : 
    5045             : #define SLOT2(FUNCNAME, OPSTR, ARG1TYPE, ARG2TYPE, ARGCODES) \
    5046             : static PyObject * \
    5047             : FUNCNAME(PyObject *self, ARG1TYPE arg1, ARG2TYPE arg2) \
    5048             : { \
    5049             :     static PyObject *cache_str; \
    5050             :     return call_method(self, OPSTR, &cache_str, \
    5051             :                        "(" ARGCODES ")", arg1, arg2); \
    5052             : }
    5053             : 
    5054             : static Py_ssize_t
    5055           0 : slot_sq_length(PyObject *self)
    5056             : {
    5057             :     static PyObject *len_str;
    5058           0 :     PyObject *res = call_method(self, "__len__", &len_str, "()");
    5059             :     Py_ssize_t len;
    5060             : 
    5061           0 :     if (res == NULL)
    5062           0 :         return -1;
    5063           0 :     len = PyInt_AsSsize_t(res);
    5064           0 :     Py_DECREF(res);
    5065           0 :     if (len < 0) {
    5066           0 :         if (!PyErr_Occurred())
    5067           0 :             PyErr_SetString(PyExc_ValueError,
    5068             :                             "__len__() should return >= 0");
    5069           0 :         return -1;
    5070             :     }
    5071           0 :     return len;
    5072             : }
    5073             : 
    5074             : /* Super-optimized version of slot_sq_item.
    5075             :    Other slots could do the same... */
    5076             : static PyObject *
    5077           0 : slot_sq_item(PyObject *self, Py_ssize_t i)
    5078             : {
    5079             :     static PyObject *getitem_str;
    5080           0 :     PyObject *func, *args = NULL, *ival = NULL, *retval = NULL;
    5081             :     descrgetfunc f;
    5082             : 
    5083           0 :     if (getitem_str == NULL) {
    5084           0 :         getitem_str = PyString_InternFromString("__getitem__");
    5085           0 :         if (getitem_str == NULL)
    5086           0 :             return NULL;
    5087             :     }
    5088           0 :     func = _PyType_Lookup(Py_TYPE(self), getitem_str);
    5089           0 :     if (func != NULL) {
    5090           0 :         if ((f = Py_TYPE(func)->tp_descr_get) == NULL)
    5091           0 :             Py_INCREF(func);
    5092             :         else {
    5093           0 :             func = f(func, self, (PyObject *)(Py_TYPE(self)));
    5094           0 :             if (func == NULL) {
    5095           0 :                 return NULL;
    5096             :             }
    5097             :         }
    5098           0 :         ival = PyInt_FromSsize_t(i);
    5099           0 :         if (ival != NULL) {
    5100           0 :             args = PyTuple_New(1);
    5101           0 :             if (args != NULL) {
    5102           0 :                 PyTuple_SET_ITEM(args, 0, ival);
    5103           0 :                 retval = PyObject_Call(func, args, NULL);
    5104           0 :                 Py_XDECREF(args);
    5105           0 :                 Py_XDECREF(func);
    5106           0 :                 return retval;
    5107             :             }
    5108             :         }
    5109             :     }
    5110             :     else {
    5111           0 :         PyErr_SetObject(PyExc_AttributeError, getitem_str);
    5112             :     }
    5113           0 :     Py_XDECREF(args);
    5114           0 :     Py_XDECREF(ival);
    5115           0 :     Py_XDECREF(func);
    5116           0 :     return NULL;
    5117             : }
    5118             : 
    5119             : static PyObject*
    5120           0 : slot_sq_slice(PyObject *self, Py_ssize_t i, Py_ssize_t j)
    5121             : {
    5122             :     static PyObject *getslice_str;
    5123             : 
    5124           0 :     if (PyErr_WarnPy3k("in 3.x, __getslice__ has been removed; "
    5125           0 :                         "use __getitem__", 1) < 0)
    5126           0 :         return NULL;
    5127           0 :     return call_method(self, "__getslice__", &getslice_str,
    5128             :         "nn", i, j);
    5129             : }
    5130             : 
    5131             : static int
    5132           0 : slot_sq_ass_item(PyObject *self, Py_ssize_t index, PyObject *value)
    5133             : {
    5134             :     PyObject *res;
    5135             :     static PyObject *delitem_str, *setitem_str;
    5136             : 
    5137           0 :     if (value == NULL)
    5138           0 :         res = call_method(self, "__delitem__", &delitem_str,
    5139             :                           "(n)", index);
    5140             :     else
    5141           0 :         res = call_method(self, "__setitem__", &setitem_str,
    5142             :                           "(nO)", index, value);
    5143           0 :     if (res == NULL)
    5144           0 :         return -1;
    5145           0 :     Py_DECREF(res);
    5146           0 :     return 0;
    5147             : }
    5148             : 
    5149             : static int
    5150           0 : slot_sq_ass_slice(PyObject *self, Py_ssize_t i, Py_ssize_t j, PyObject *value)
    5151             : {
    5152             :     PyObject *res;
    5153             :     static PyObject *delslice_str, *setslice_str;
    5154             : 
    5155           0 :     if (value == NULL) {
    5156           0 :         if (PyErr_WarnPy3k("in 3.x, __delslice__ has been removed; "
    5157           0 :                            "use __delitem__", 1) < 0)
    5158           0 :             return -1;
    5159           0 :         res = call_method(self, "__delslice__", &delslice_str,
    5160             :                           "(nn)", i, j);
    5161             :     }
    5162             :     else {
    5163           0 :         if (PyErr_WarnPy3k("in 3.x, __setslice__ has been removed; "
    5164           0 :                                 "use __setitem__", 1) < 0)
    5165           0 :             return -1;
    5166           0 :         res = call_method(self, "__setslice__", &setslice_str,
    5167             :                   "(nnO)", i, j, value);
    5168             :     }
    5169           0 :     if (res == NULL)
    5170           0 :         return -1;
    5171           0 :     Py_DECREF(res);
    5172           0 :     return 0;
    5173             : }
    5174             : 
    5175             : static int
    5176          93 : slot_sq_contains(PyObject *self, PyObject *value)
    5177             : {
    5178             :     PyObject *func, *res, *args;
    5179          93 :     int result = -1;
    5180             : 
    5181             :     static PyObject *contains_str;
    5182             : 
    5183          93 :     func = lookup_maybe(self, "__contains__", &contains_str);
    5184          93 :     if (func != NULL) {
    5185          93 :         args = PyTuple_Pack(1, value);
    5186          93 :         if (args == NULL)
    5187           0 :             res = NULL;
    5188             :         else {
    5189          93 :             res = PyObject_Call(func, args, NULL);
    5190          93 :             Py_DECREF(args);
    5191             :         }
    5192          93 :         Py_DECREF(func);
    5193          93 :         if (res != NULL) {
    5194          93 :             result = PyObject_IsTrue(res);
    5195          93 :             Py_DECREF(res);
    5196             :         }
    5197             :     }
    5198           0 :     else if (! PyErr_Occurred()) {
    5199             :         /* Possible results: -1 and 1 */
    5200           0 :         result = (int)_PySequence_IterSearch(self, value,
    5201             :                                          PY_ITERSEARCH_CONTAINS);
    5202             :     }
    5203          93 :     return result;
    5204             : }
    5205             : 
    5206             : #define slot_mp_length slot_sq_length
    5207             : 
    5208           0 : SLOT1(slot_mp_subscript, "__getitem__", PyObject *, "O")
    5209             : 
    5210             : static int
    5211           0 : slot_mp_ass_subscript(PyObject *self, PyObject *key, PyObject *value)
    5212             : {
    5213             :     PyObject *res;
    5214             :     static PyObject *delitem_str, *setitem_str;
    5215             : 
    5216           0 :     if (value == NULL)
    5217           0 :         res = call_method(self, "__delitem__", &delitem_str,
    5218             :                           "(O)", key);
    5219             :     else
    5220           0 :         res = call_method(self, "__setitem__", &setitem_str,
    5221             :                          "(OO)", key, value);
    5222           0 :     if (res == NULL)
    5223           0 :         return -1;
    5224           0 :     Py_DECREF(res);
    5225           0 :     return 0;
    5226             : }
    5227             : 
    5228           0 : SLOT1BIN(slot_nb_add, nb_add, "__add__", "__radd__")
    5229           0 : SLOT1BIN(slot_nb_subtract, nb_subtract, "__sub__", "__rsub__")
    5230           0 : SLOT1BIN(slot_nb_multiply, nb_multiply, "__mul__", "__rmul__")
    5231           0 : SLOT1BIN(slot_nb_divide, nb_divide, "__div__", "__rdiv__")
    5232           0 : SLOT1BIN(slot_nb_remainder, nb_remainder, "__mod__", "__rmod__")
    5233           0 : SLOT1BIN(slot_nb_divmod, nb_divmod, "__divmod__", "__rdivmod__")
    5234             : 
    5235             : static PyObject *slot_nb_power(PyObject *, PyObject *, PyObject *);
    5236             : 
    5237           0 : SLOT1BINFULL(slot_nb_power_binary, slot_nb_power,
    5238             :              nb_power, "__pow__", "__rpow__")
    5239             : 
    5240             : static PyObject *
    5241           0 : slot_nb_power(PyObject *self, PyObject *other, PyObject *modulus)
    5242             : {
    5243             :     static PyObject *pow_str;
    5244             : 
    5245           0 :     if (modulus == Py_None)
    5246           0 :         return slot_nb_power_binary(self, other);
    5247             :     /* Three-arg power doesn't use __rpow__.  But ternary_op
    5248             :        can call this when the second argument's type uses
    5249             :        slot_nb_power, so check before calling self.__pow__. */
    5250           0 :     if (Py_TYPE(self)->tp_as_number != NULL &&
    5251           0 :         Py_TYPE(self)->tp_as_number->nb_power == slot_nb_power) {
    5252           0 :         return call_method(self, "__pow__", &pow_str,
    5253             :                            "(OO)", other, modulus);
    5254             :     }
    5255           0 :     Py_INCREF(Py_NotImplemented);
    5256           0 :     return Py_NotImplemented;
    5257             : }
    5258             : 
    5259           0 : SLOT0(slot_nb_negative, "__neg__")
    5260           0 : SLOT0(slot_nb_positive, "__pos__")
    5261           0 : SLOT0(slot_nb_absolute, "__abs__")
    5262             : 
    5263             : static int
    5264           0 : slot_nb_nonzero(PyObject *self)
    5265             : {
    5266             :     PyObject *func, *args;
    5267             :     static PyObject *nonzero_str, *len_str;
    5268           0 :     int result = -1;
    5269           0 :     int using_len = 0;
    5270             : 
    5271           0 :     func = lookup_maybe(self, "__nonzero__", &nonzero_str);
    5272           0 :     if (func == NULL) {
    5273           0 :         if (PyErr_Occurred())
    5274           0 :             return -1;
    5275           0 :         func = lookup_maybe(self, "__len__", &len_str);
    5276           0 :         if (func == NULL)
    5277           0 :             return PyErr_Occurred() ? -1 : 1;
    5278           0 :         using_len = 1;
    5279             :     }
    5280           0 :     args = PyTuple_New(0);
    5281           0 :     if (args != NULL) {
    5282           0 :         PyObject *temp = PyObject_Call(func, args, NULL);
    5283           0 :         Py_DECREF(args);
    5284           0 :         if (temp != NULL) {
    5285           0 :             if (PyInt_CheckExact(temp) || PyBool_Check(temp))
    5286           0 :                 result = PyObject_IsTrue(temp);
    5287             :             else {
    5288           0 :                 PyErr_Format(PyExc_TypeError,
    5289             :                              "%s should return "
    5290             :                              "bool or int, returned %s",
    5291             :                              (using_len ? "__len__"
    5292             :                                         : "__nonzero__"),
    5293           0 :                              temp->ob_type->tp_name);
    5294           0 :                 result = -1;
    5295             :             }
    5296           0 :             Py_DECREF(temp);
    5297             :         }
    5298             :     }
    5299           0 :     Py_DECREF(func);
    5300           0 :     return result;
    5301             : }
    5302             : 
    5303             : 
    5304             : static PyObject *
    5305           0 : slot_nb_index(PyObject *self)
    5306             : {
    5307             :     static PyObject *index_str;
    5308           0 :     return call_method(self, "__index__", &index_str, "()");
    5309             : }
    5310             : 
    5311             : 
    5312           0 : SLOT0(slot_nb_invert, "__invert__")
    5313           0 : SLOT1BIN(slot_nb_lshift, nb_lshift, "__lshift__", "__rlshift__")
    5314           0 : SLOT1BIN(slot_nb_rshift, nb_rshift, "__rshift__", "__rrshift__")
    5315           0 : SLOT1BIN(slot_nb_and, nb_and, "__and__", "__rand__")
    5316           0 : SLOT1BIN(slot_nb_xor, nb_xor, "__xor__", "__rxor__")
    5317           0 : SLOT1BIN(slot_nb_or, nb_or, "__or__", "__ror__")
    5318             : 
    5319             : static int
    5320           0 : slot_nb_coerce(PyObject **a, PyObject **b)
    5321             : {
    5322             :     static PyObject *coerce_str;
    5323           0 :     PyObject *self = *a, *other = *b;
    5324             : 
    5325           0 :     if (self->ob_type->tp_as_number != NULL &&
    5326           0 :         self->ob_type->tp_as_number->nb_coerce == slot_nb_coerce) {
    5327             :         PyObject *r;
    5328           0 :         r = call_maybe(
    5329             :             self, "__coerce__", &coerce_str, "(O)", other);
    5330           0 :         if (r == NULL)
    5331           0 :             return -1;
    5332           0 :         if (r == Py_NotImplemented) {
    5333           0 :             Py_DECREF(r);
    5334             :         }
    5335             :         else {
    5336           0 :             if (!PyTuple_Check(r) || PyTuple_GET_SIZE(r) != 2) {
    5337           0 :                 PyErr_SetString(PyExc_TypeError,
    5338             :                     "__coerce__ didn't return a 2-tuple");
    5339           0 :                 Py_DECREF(r);
    5340           0 :                 return -1;
    5341             :             }
    5342           0 :             *a = PyTuple_GET_ITEM(r, 0);
    5343           0 :             Py_INCREF(*a);
    5344           0 :             *b = PyTuple_GET_ITEM(r, 1);
    5345           0 :             Py_INCREF(*b);
    5346           0 :             Py_DECREF(r);
    5347           0 :             return 0;
    5348             :         }
    5349             :     }
    5350           0 :     if (other->ob_type->tp_as_number != NULL &&
    5351           0 :         other->ob_type->tp_as_number->nb_coerce == slot_nb_coerce) {
    5352             :         PyObject *r;
    5353           0 :         r = call_maybe(
    5354             :             other, "__coerce__", &coerce_str, "(O)", self);
    5355           0 :         if (r == NULL)
    5356           0 :             return -1;
    5357           0 :         if (r == Py_NotImplemented) {
    5358           0 :             Py_DECREF(r);
    5359           0 :             return 1;
    5360             :         }
    5361           0 :         if (!PyTuple_Check(r) || PyTuple_GET_SIZE(r) != 2) {
    5362           0 :             PyErr_SetString(PyExc_TypeError,
    5363             :                             "__coerce__ didn't return a 2-tuple");
    5364           0 :             Py_DECREF(r);
    5365           0 :             return -1;
    5366             :         }
    5367           0 :         *a = PyTuple_GET_ITEM(r, 1);
    5368           0 :         Py_INCREF(*a);
    5369           0 :         *b = PyTuple_GET_ITEM(r, 0);
    5370           0 :         Py_INCREF(*b);
    5371           0 :         Py_DECREF(r);
    5372           0 :         return 0;
    5373             :     }
    5374           0 :     return 1;
    5375             : }
    5376             : 
    5377           0 : SLOT0(slot_nb_int, "__int__")
    5378           0 : SLOT0(slot_nb_long, "__long__")
    5379           0 : SLOT0(slot_nb_float, "__float__")
    5380           0 : SLOT0(slot_nb_oct, "__oct__")
    5381           0 : SLOT0(slot_nb_hex, "__hex__")
    5382           0 : SLOT1(slot_nb_inplace_add, "__iadd__", PyObject *, "O")
    5383           0 : SLOT1(slot_nb_inplace_subtract, "__isub__", PyObject *, "O")
    5384           0 : SLOT1(slot_nb_inplace_multiply, "__imul__", PyObject *, "O")
    5385           0 : SLOT1(slot_nb_inplace_divide, "__idiv__", PyObject *, "O")
    5386           0 : SLOT1(slot_nb_inplace_remainder, "__imod__", PyObject *, "O")
    5387             : /* Can't use SLOT1 here, because nb_inplace_power is ternary */
    5388             : static PyObject *
    5389           0 : slot_nb_inplace_power(PyObject *self, PyObject * arg1, PyObject *arg2)
    5390             : {
    5391             :   static PyObject *cache_str;
    5392           0 :   return call_method(self, "__ipow__", &cache_str, "(" "O" ")", arg1);
    5393             : }
    5394           0 : SLOT1(slot_nb_inplace_lshift, "__ilshift__", PyObject *, "O")
    5395           0 : SLOT1(slot_nb_inplace_rshift, "__irshift__", PyObject *, "O")
    5396           0 : SLOT1(slot_nb_inplace_and, "__iand__", PyObject *, "O")
    5397           0 : SLOT1(slot_nb_inplace_xor, "__ixor__", PyObject *, "O")
    5398           0 : SLOT1(slot_nb_inplace_or, "__ior__", PyObject *, "O")
    5399           0 : SLOT1BIN(slot_nb_floor_divide, nb_floor_divide,
    5400             :          "__floordiv__", "__rfloordiv__")
    5401           0 : SLOT1BIN(slot_nb_true_divide, nb_true_divide, "__truediv__", "__rtruediv__")
    5402           0 : SLOT1(slot_nb_inplace_floor_divide, "__ifloordiv__", PyObject *, "O")
    5403           0 : SLOT1(slot_nb_inplace_true_divide, "__itruediv__", PyObject *, "O")
    5404             : 
    5405             : static int
    5406           0 : half_compare(PyObject *self, PyObject *other)
    5407             : {
    5408             :     PyObject *func, *args, *res;
    5409             :     static PyObject *cmp_str;
    5410             :     Py_ssize_t c;
    5411             : 
    5412           0 :     func = lookup_method(self, "__cmp__", &cmp_str);
    5413           0 :     if (func == NULL) {
    5414           0 :         PyErr_Clear();
    5415             :     }
    5416             :     else {
    5417           0 :         args = PyTuple_Pack(1, other);
    5418           0 :         if (args == NULL)
    5419           0 :             res = NULL;
    5420             :         else {
    5421           0 :             res = PyObject_Call(func, args, NULL);
    5422           0 :             Py_DECREF(args);
    5423             :         }
    5424           0 :         Py_DECREF(func);
    5425           0 :         if (res != Py_NotImplemented) {
    5426           0 :             if (res == NULL)
    5427           0 :                 return -2;
    5428           0 :             c = PyInt_AsLong(res);
    5429           0 :             Py_DECREF(res);
    5430           0 :             if (c == -1 && PyErr_Occurred())
    5431           0 :                 return -2;
    5432           0 :             return (c < 0) ? -1 : (c > 0) ? 1 : 0;
    5433             :         }
    5434           0 :         Py_DECREF(res);
    5435             :     }
    5436           0 :     return 2;
    5437             : }
    5438             : 
    5439             : /* This slot is published for the benefit of try_3way_compare in object.c */
    5440             : int
    5441           0 : _PyObject_SlotCompare(PyObject *self, PyObject *other)
    5442             : {
    5443             :     int c;
    5444             : 
    5445           0 :     if (Py_TYPE(self)->tp_compare == _PyObject_SlotCompare) {
    5446           0 :         c = half_compare(self, other);
    5447           0 :         if (c <= 1)
    5448           0 :             return c;
    5449             :     }
    5450           0 :     if (Py_TYPE(other)->tp_compare == _PyObject_SlotCompare) {
    5451           0 :         c = half_compare(other, self);
    5452           0 :         if (c < -1)
    5453           0 :             return -2;
    5454           0 :         if (c <= 1)
    5455           0 :             return -c;
    5456             :     }
    5457           0 :     return (void *)self < (void *)other ? -1 :
    5458           0 :         (void *)self > (void *)other ? 1 : 0;
    5459             : }
    5460             : 
    5461             : static PyObject *
    5462           0 : slot_tp_repr(PyObject *self)
    5463             : {
    5464             :     PyObject *func, *res;
    5465             :     static PyObject *repr_str;
    5466             : 
    5467           0 :     func = lookup_method(self, "__repr__", &repr_str);
    5468           0 :     if (func != NULL) {
    5469           0 :         res = PyEval_CallObject(func, NULL);
    5470           0 :         Py_DECREF(func);
    5471           0 :         return res;
    5472             :     }
    5473           0 :     PyErr_Clear();
    5474           0 :     return PyString_FromFormat("<%s object at %p>",
    5475           0 :                                Py_TYPE(self)->tp_name, self);
    5476             : }
    5477             : 
    5478             : static PyObject *
    5479           0 : slot_tp_str(PyObject *self)
    5480             : {
    5481             :     PyObject *func, *res;
    5482             :     static PyObject *str_str;
    5483             : 
    5484           0 :     func = lookup_method(self, "__str__", &str_str);
    5485           0 :     if (func != NULL) {
    5486           0 :         res = PyEval_CallObject(func, NULL);
    5487           0 :         Py_DECREF(func);
    5488           0 :         return res;
    5489             :     }
    5490             :     else {
    5491           0 :         PyErr_Clear();
    5492           0 :         return slot_tp_repr(self);
    5493             :     }
    5494             : }
    5495             : 
    5496             : static long
    5497         823 : slot_tp_hash(PyObject *self)
    5498             : {
    5499             :     PyObject *func;
    5500             :     static PyObject *hash_str, *eq_str, *cmp_str;
    5501             :     long h;
    5502             : 
    5503         823 :     func = lookup_method(self, "__hash__", &hash_str);
    5504             : 
    5505        1646 :     if (func != NULL && func != Py_None) {
    5506         823 :         PyObject *res = PyEval_CallObject(func, NULL);
    5507         823 :         Py_DECREF(func);
    5508         823 :         if (res == NULL)
    5509           0 :             return -1;
    5510         823 :         if (PyLong_Check(res))
    5511           0 :             h = PyLong_Type.tp_hash(res);
    5512             :         else
    5513         823 :             h = PyInt_AsLong(res);
    5514         823 :         Py_DECREF(res);
    5515             :     }
    5516             :     else {
    5517           0 :         Py_XDECREF(func); /* may be None */
    5518           0 :         PyErr_Clear();
    5519           0 :         func = lookup_method(self, "__eq__", &eq_str);
    5520           0 :         if (func == NULL) {
    5521           0 :             PyErr_Clear();
    5522           0 :             func = lookup_method(self, "__cmp__", &cmp_str);
    5523             :         }
    5524           0 :         if (func != NULL) {
    5525           0 :             Py_DECREF(func);
    5526           0 :             return PyObject_HashNotImplemented(self);
    5527             :         }
    5528           0 :         PyErr_Clear();
    5529           0 :         h = _Py_HashPointer((void *)self);
    5530             :     }
    5531         823 :     if (h == -1 && !PyErr_Occurred())
    5532           0 :         h = -2;
    5533         823 :     return h;
    5534             : }
    5535             : 
    5536             : static PyObject *
    5537           0 : slot_tp_call(PyObject *self, PyObject *args, PyObject *kwds)
    5538             : {
    5539             :     static PyObject *call_str;
    5540           0 :     PyObject *meth = lookup_method(self, "__call__", &call_str);
    5541             :     PyObject *res;
    5542             : 
    5543           0 :     if (meth == NULL)
    5544           0 :         return NULL;
    5545             : 
    5546           0 :     res = PyObject_Call(meth, args, kwds);
    5547             : 
    5548           0 :     Py_DECREF(meth);
    5549           0 :     return res;
    5550             : }
    5551             : 
    5552             : /* There are two slot dispatch functions for tp_getattro.
    5553             : 
    5554             :    - slot_tp_getattro() is used when __getattribute__ is overridden
    5555             :      but no __getattr__ hook is present;
    5556             : 
    5557             :    - slot_tp_getattr_hook() is used when a __getattr__ hook is present.
    5558             : 
    5559             :    The code in update_one_slot() always installs slot_tp_getattr_hook(); this
    5560             :    detects the absence of __getattr__ and then installs the simpler slot if
    5561             :    necessary. */
    5562             : 
    5563             : static PyObject *
    5564           0 : slot_tp_getattro(PyObject *self, PyObject *name)
    5565             : {
    5566             :     static PyObject *getattribute_str = NULL;
    5567           0 :     return call_method(self, "__getattribute__", &getattribute_str,
    5568             :                        "(O)", name);
    5569             : }
    5570             : 
    5571             : static PyObject *
    5572         321 : call_attribute(PyObject *self, PyObject *attr, PyObject *name)
    5573             : {
    5574         321 :     PyObject *res, *descr = NULL;
    5575         321 :     descrgetfunc f = Py_TYPE(attr)->tp_descr_get;
    5576             : 
    5577         321 :     if (f != NULL) {
    5578         321 :         descr = f(attr, self, (PyObject *)(Py_TYPE(self)));
    5579         321 :         if (descr == NULL)
    5580           0 :             return NULL;
    5581             :         else
    5582         321 :             attr = descr;
    5583             :     }
    5584         321 :     res = PyObject_CallFunctionObjArgs(attr, name, NULL);
    5585         321 :     Py_XDECREF(descr);
    5586         321 :     return res;
    5587             : }
    5588             : 
    5589             : static PyObject *
    5590         960 : slot_tp_getattr_hook(PyObject *self, PyObject *name)
    5591             : {
    5592         960 :     PyTypeObject *tp = Py_TYPE(self);
    5593             :     PyObject *getattr, *getattribute, *res;
    5594             :     static PyObject *getattribute_str = NULL;
    5595             :     static PyObject *getattr_str = NULL;
    5596             : 
    5597         960 :     if (getattr_str == NULL) {
    5598           3 :         getattr_str = PyString_InternFromString("__getattr__");
    5599           3 :         if (getattr_str == NULL)
    5600           0 :             return NULL;
    5601             :     }
    5602         960 :     if (getattribute_str == NULL) {
    5603           3 :         getattribute_str =
    5604           3 :             PyString_InternFromString("__getattribute__");
    5605           3 :         if (getattribute_str == NULL)
    5606           0 :             return NULL;
    5607             :     }
    5608             :     /* speed hack: we could use lookup_maybe, but that would resolve the
    5609             :        method fully for each attribute lookup for classes with
    5610             :        __getattr__, even when the attribute is present. So we use
    5611             :        _PyType_Lookup and create the method only when needed, with
    5612             :        call_attribute. */
    5613         960 :     getattr = _PyType_Lookup(tp, getattr_str);
    5614         960 :     if (getattr == NULL) {
    5615             :         /* No __getattr__ hook: use a simpler dispatcher */
    5616           0 :         tp->tp_getattro = slot_tp_getattro;
    5617           0 :         return slot_tp_getattro(self, name);
    5618             :     }
    5619         960 :     Py_INCREF(getattr);
    5620             :     /* speed hack: we could use lookup_maybe, but that would resolve the
    5621             :        method fully for each attribute lookup for classes with
    5622             :        __getattr__, even when self has the default __getattribute__
    5623             :        method. So we use _PyType_Lookup and create the method only when
    5624             :        needed, with call_attribute. */
    5625         960 :     getattribute = _PyType_Lookup(tp, getattribute_str);
    5626        1920 :     if (getattribute == NULL ||
    5627        1920 :         (Py_TYPE(getattribute) == &PyWrapperDescr_Type &&
    5628         960 :          ((PyWrapperDescrObject *)getattribute)->d_wrapped ==
    5629             :          (void *)PyObject_GenericGetAttr))
    5630         960 :         res = PyObject_GenericGetAttr(self, name);
    5631             :     else {
    5632           0 :         Py_INCREF(getattribute);
    5633           0 :         res = call_attribute(self, getattribute, name);
    5634           0 :         Py_DECREF(getattribute);
    5635             :     }
    5636         960 :     if (res == NULL && PyErr_ExceptionMatches(PyExc_AttributeError)) {
    5637         321 :         PyErr_Clear();
    5638         321 :         res = call_attribute(self, getattr, name);
    5639             :     }
    5640         960 :     Py_DECREF(getattr);
    5641         960 :     return res;
    5642             : }
    5643             : 
    5644             : static int
    5645         165 : slot_tp_setattro(PyObject *self, PyObject *name, PyObject *value)
    5646             : {
    5647             :     PyObject *res;
    5648             :     static PyObject *delattr_str, *setattr_str;
    5649             : 
    5650         165 :     if (value == NULL)
    5651           0 :         res = call_method(self, "__delattr__", &delattr_str,
    5652             :                           "(O)", name);
    5653             :     else
    5654         165 :         res = call_method(self, "__setattr__", &setattr_str,
    5655             :                           "(OO)", name, value);
    5656         165 :     if (res == NULL)
    5657           0 :         return -1;
    5658         165 :     Py_DECREF(res);
    5659         165 :     return 0;
    5660             : }
    5661             : 
    5662             : static char *name_op[] = {
    5663             :     "__lt__",
    5664             :     "__le__",
    5665             :     "__eq__",
    5666             :     "__ne__",
    5667             :     "__gt__",
    5668             :     "__ge__",
    5669             : };
    5670             : 
    5671             : static PyObject *
    5672        1203 : half_richcompare(PyObject *self, PyObject *other, int op)
    5673             : {
    5674             :     PyObject *func, *args, *res;
    5675             :     static PyObject *op_str[6];
    5676             : 
    5677        1203 :     func = lookup_method(self, name_op[op], &op_str[op]);
    5678        1203 :     if (func == NULL) {
    5679         762 :         PyErr_Clear();
    5680         762 :         Py_INCREF(Py_NotImplemented);
    5681         762 :         return Py_NotImplemented;
    5682             :     }
    5683         441 :     args = PyTuple_Pack(1, other);
    5684         441 :     if (args == NULL)
    5685           0 :         res = NULL;
    5686             :     else {
    5687         441 :         res = PyObject_Call(func, args, NULL);
    5688         441 :         Py_DECREF(args);
    5689             :     }
    5690         441 :     Py_DECREF(func);
    5691         441 :     return res;
    5692             : }
    5693             : 
    5694             : static PyObject *
    5695         822 : slot_tp_richcompare(PyObject *self, PyObject *other, int op)
    5696             : {
    5697             :     PyObject *res;
    5698             : 
    5699         822 :     if (Py_TYPE(self)->tp_richcompare == slot_tp_richcompare) {
    5700         822 :         res = half_richcompare(self, other, op);
    5701         822 :         if (res != Py_NotImplemented)
    5702         441 :             return res;
    5703         381 :         Py_DECREF(res);
    5704             :     }
    5705         381 :     if (Py_TYPE(other)->tp_richcompare == slot_tp_richcompare) {
    5706         381 :         res = half_richcompare(other, self, _Py_SwappedOp[op]);
    5707         381 :         if (res != Py_NotImplemented) {
    5708           0 :             return res;
    5709             :         }
    5710         381 :         Py_DECREF(res);
    5711             :     }
    5712         381 :     Py_INCREF(Py_NotImplemented);
    5713         381 :     return Py_NotImplemented;
    5714             : }
    5715             : 
    5716             : static PyObject *
    5717          63 : slot_tp_iter(PyObject *self)
    5718             : {
    5719             :     PyObject *func, *res;
    5720             :     static PyObject *iter_str, *getitem_str;
    5721             : 
    5722          63 :     func = lookup_method(self, "__iter__", &iter_str);
    5723          63 :     if (func != NULL) {
    5724             :         PyObject *args;
    5725          63 :         args = res = PyTuple_New(0);
    5726          63 :         if (args != NULL) {
    5727          63 :             res = PyObject_Call(func, args, NULL);
    5728          63 :             Py_DECREF(args);
    5729             :         }
    5730          63 :         Py_DECREF(func);
    5731          63 :         return res;
    5732             :     }
    5733           0 :     PyErr_Clear();
    5734           0 :     func = lookup_method(self, "__getitem__", &getitem_str);
    5735           0 :     if (func == NULL) {
    5736           0 :         PyErr_Format(PyExc_TypeError,
    5737             :                      "'%.200s' object is not iterable",
    5738           0 :                      Py_TYPE(self)->tp_name);
    5739           0 :         return NULL;
    5740             :     }
    5741           0 :     Py_DECREF(func);
    5742           0 :     return PySeqIter_New(self);
    5743             : }
    5744             : 
    5745             : static PyObject *
    5746           0 : slot_tp_iternext(PyObject *self)
    5747             : {
    5748             :     static PyObject *next_str;
    5749           0 :     return call_method(self, "next", &next_str, "()");
    5750             : }
    5751             : 
    5752             : static PyObject *
    5753           0 : slot_tp_descr_get(PyObject *self, PyObject *obj, PyObject *type)
    5754             : {
    5755           0 :     PyTypeObject *tp = Py_TYPE(self);
    5756             :     PyObject *get;
    5757             :     static PyObject *get_str = NULL;
    5758             : 
    5759           0 :     if (get_str == NULL) {
    5760           0 :         get_str = PyString_InternFromString("__get__");
    5761           0 :         if (get_str == NULL)
    5762           0 :             return NULL;
    5763             :     }
    5764           0 :     get = _PyType_Lookup(tp, get_str);
    5765           0 :     if (get == NULL) {
    5766             :         /* Avoid further slowdowns */
    5767           0 :         if (tp->tp_descr_get == slot_tp_descr_get)
    5768           0 :             tp->tp_descr_get = NULL;
    5769           0 :         Py_INCREF(self);
    5770           0 :         return self;
    5771             :     }
    5772           0 :     if (obj == NULL)
    5773           0 :         obj = Py_None;
    5774           0 :     if (type == NULL)
    5775           0 :         type = Py_None;
    5776           0 :     return PyObject_CallFunctionObjArgs(get, self, obj, type, NULL);
    5777             : }
    5778             : 
    5779             : static int
    5780           0 : slot_tp_descr_set(PyObject *self, PyObject *target, PyObject *value)
    5781             : {
    5782             :     PyObject *res;
    5783             :     static PyObject *del_str, *set_str;
    5784             : 
    5785           0 :     if (value == NULL)
    5786           0 :         res = call_method(self, "__delete__", &del_str,
    5787             :                           "(O)", target);
    5788             :     else
    5789           0 :         res = call_method(self, "__set__", &set_str,
    5790             :                           "(OO)", target, value);
    5791           0 :     if (res == NULL)
    5792           0 :         return -1;
    5793           0 :     Py_DECREF(res);
    5794           0 :     return 0;
    5795             : }
    5796             : 
    5797             : static int
    5798        1758 : slot_tp_init(PyObject *self, PyObject *args, PyObject *kwds)
    5799             : {
    5800             :     static PyObject *init_str;
    5801        1758 :     PyObject *meth = lookup_method(self, "__init__", &init_str);
    5802             :     PyObject *res;
    5803             : 
    5804        1758 :     if (meth == NULL)
    5805           0 :         return -1;
    5806        1758 :     res = PyObject_Call(meth, args, kwds);
    5807        1758 :     Py_DECREF(meth);
    5808        1758 :     if (res == NULL)
    5809           0 :         return -1;
    5810        1758 :     if (res != Py_None) {
    5811           0 :         PyErr_Format(PyExc_TypeError,
    5812             :                      "__init__() should return None, not '%.200s'",
    5813           0 :                      Py_TYPE(res)->tp_name);
    5814           0 :         Py_DECREF(res);
    5815           0 :         return -1;
    5816             :     }
    5817        1758 :     Py_DECREF(res);
    5818        1758 :     return 0;
    5819             : }
    5820             : 
    5821             : static PyObject *
    5822        2475 : slot_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
    5823             : {
    5824             :     static PyObject *new_str;
    5825             :     PyObject *func;
    5826             :     PyObject *newargs, *x;
    5827             :     Py_ssize_t i, n;
    5828             : 
    5829        2475 :     if (new_str == NULL) {
    5830           3 :         new_str = PyString_InternFromString("__new__");
    5831           3 :         if (new_str == NULL)
    5832           0 :             return NULL;
    5833             :     }
    5834        2475 :     func = PyObject_GetAttr((PyObject *)type, new_str);
    5835        2475 :     if (func == NULL)
    5836           0 :         return NULL;
    5837             :     assert(PyTuple_Check(args));
    5838        2475 :     n = PyTuple_GET_SIZE(args);
    5839        2475 :     newargs = PyTuple_New(n+1);
    5840        2475 :     if (newargs == NULL)
    5841           0 :         return NULL;
    5842        2475 :     Py_INCREF(type);
    5843        2475 :     PyTuple_SET_ITEM(newargs, 0, (PyObject *)type);
    5844        9891 :     for (i = 0; i < n; i++) {
    5845        7416 :         x = PyTuple_GET_ITEM(args, i);
    5846        7416 :         Py_INCREF(x);
    5847        7416 :         PyTuple_SET_ITEM(newargs, i+1, x);
    5848             :     }
    5849        2475 :     x = PyObject_Call(func, newargs, kwds);
    5850        2475 :     Py_DECREF(newargs);
    5851        2475 :     Py_DECREF(func);
    5852        2475 :     return x;
    5853             : }
    5854             : 
    5855             : static void
    5856           0 : slot_tp_del(PyObject *self)
    5857             : {
    5858             :     static PyObject *del_str = NULL;
    5859             :     PyObject *del, *res;
    5860             :     PyObject *error_type, *error_value, *error_traceback;
    5861             : 
    5862             :     /* Temporarily resurrect the object. */
    5863             :     assert(self->ob_refcnt == 0);
    5864           0 :     self->ob_refcnt = 1;
    5865             : 
    5866             :     /* Save the current exception, if any. */
    5867           0 :     PyErr_Fetch(&error_type, &error_value, &error_traceback);
    5868             : 
    5869             :     /* Execute __del__ method, if any. */
    5870           0 :     del = lookup_maybe(self, "__del__", &del_str);
    5871           0 :     if (del != NULL) {
    5872           0 :         res = PyEval_CallObject(del, NULL);
    5873           0 :         if (res == NULL)
    5874           0 :             PyErr_WriteUnraisable(del);
    5875             :         else
    5876           0 :             Py_DECREF(res);
    5877           0 :         Py_DECREF(del);
    5878             :     }
    5879             : 
    5880             :     /* Restore the saved exception. */
    5881           0 :     PyErr_Restore(error_type, error_value, error_traceback);
    5882             : 
    5883             :     /* Undo the temporary resurrection; can't use DECREF here, it would
    5884             :      * cause a recursive call.
    5885             :      */
    5886             :     assert(self->ob_refcnt > 0);
    5887           0 :     if (--self->ob_refcnt == 0)
    5888           0 :         return;         /* this is the normal path out */
    5889             : 
    5890             :     /* __del__ resurrected it!  Make it look like the original Py_DECREF
    5891             :      * never happened.
    5892             :      */
    5893             :     {
    5894           0 :         Py_ssize_t refcnt = self->ob_refcnt;
    5895           0 :         _Py_NewReference(self);
    5896           0 :         self->ob_refcnt = refcnt;
    5897             :     }
    5898             :     assert(!PyType_IS_GC(Py_TYPE(self)) ||
    5899             :            _Py_AS_GC(self)->gc.gc_refs != _PyGC_REFS_UNTRACKED);
    5900             :     /* If Py_REF_DEBUG, _Py_NewReference bumped _Py_RefTotal, so
    5901             :      * we need to undo that. */
    5902             :     _Py_DEC_REFTOTAL;
    5903             :     /* If Py_TRACE_REFS, _Py_NewReference re-added self to the object
    5904             :      * chain, so no more to do there.
    5905             :      * If COUNT_ALLOCS, the original decref bumped tp_frees, and
    5906             :      * _Py_NewReference bumped tp_allocs:  both of those need to be
    5907             :      * undone.
    5908             :      */
    5909             : #ifdef COUNT_ALLOCS
    5910             :     --Py_TYPE(self)->tp_frees;
    5911             :     --Py_TYPE(self)->tp_allocs;
    5912             : #endif
    5913             : }
    5914             : 
    5915             : 
    5916             : /*
    5917             : Table mapping __foo__ names to tp_foo offsets and slot_tp_foo wrapper functions.
    5918             : 
    5919             : The table is ordered by offsets relative to the 'PyHeapTypeObject' structure,
    5920             : which incorporates the additional structures used for numbers, sequences and
    5921             : mappings.  Note that multiple names may map to the same slot (e.g. __eq__,
    5922             : __ne__ etc. all map to tp_richcompare) and one name may map to multiple slots
    5923             : (e.g. __str__ affects tp_str as well as tp_repr). The table is terminated with
    5924             : an all-zero entry.  (This table is further initialized in init_slotdefs().)
    5925             : */
    5926             : 
    5927             : typedef struct wrapperbase slotdef;
    5928             : 
    5929             : #undef TPSLOT
    5930             : #undef FLSLOT
    5931             : #undef ETSLOT
    5932             : #undef SQSLOT
    5933             : #undef MPSLOT
    5934             : #undef NBSLOT
    5935             : #undef UNSLOT
    5936             : #undef IBSLOT
    5937             : #undef BINSLOT
    5938             : #undef RBINSLOT
    5939             : 
    5940             : #define TPSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC) \
    5941             :     {NAME, offsetof(PyTypeObject, SLOT), (void *)(FUNCTION), WRAPPER, \
    5942             :      PyDoc_STR(DOC)}
    5943             : #define FLSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC, FLAGS) \
    5944             :     {NAME, offsetof(PyTypeObject, SLOT), (void *)(FUNCTION), WRAPPER, \
    5945             :      PyDoc_STR(DOC), FLAGS}
    5946             : #define ETSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC) \
    5947             :     {NAME, offsetof(PyHeapTypeObject, SLOT), (void *)(FUNCTION), WRAPPER, \
    5948             :      PyDoc_STR(DOC)}
    5949             : #define SQSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC) \
    5950             :     ETSLOT(NAME, as_sequence.SLOT, FUNCTION, WRAPPER, DOC)
    5951             : #define MPSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC) \
    5952             :     ETSLOT(NAME, as_mapping.SLOT, FUNCTION, WRAPPER, DOC)
    5953             : #define NBSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC) \
    5954             :     ETSLOT(NAME, as_number.SLOT, FUNCTION, WRAPPER, DOC)
    5955             : #define UNSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC) \
    5956             :     ETSLOT(NAME, as_number.SLOT, FUNCTION, WRAPPER, \
    5957             :            "x." NAME "() <==> " DOC)
    5958             : #define IBSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC) \
    5959             :     ETSLOT(NAME, as_number.SLOT, FUNCTION, WRAPPER, \
    5960             :            "x." NAME "(y) <==> x" DOC "y")
    5961             : #define BINSLOT(NAME, SLOT, FUNCTION, DOC) \
    5962             :     ETSLOT(NAME, as_number.SLOT, FUNCTION, wrap_binaryfunc_l, \
    5963             :            "x." NAME "(y) <==> x" DOC "y")
    5964             : #define RBINSLOT(NAME, SLOT, FUNCTION, DOC) \
    5965             :     ETSLOT(NAME, as_number.SLOT, FUNCTION, wrap_binaryfunc_r, \
    5966             :            "x." NAME "(y) <==> y" DOC "x")
    5967             : #define BINSLOTNOTINFIX(NAME, SLOT, FUNCTION, DOC) \
    5968             :     ETSLOT(NAME, as_number.SLOT, FUNCTION, wrap_binaryfunc_l, \
    5969             :            "x." NAME "(y) <==> " DOC)
    5970             : #define RBINSLOTNOTINFIX(NAME, SLOT, FUNCTION, DOC) \
    5971             :     ETSLOT(NAME, as_number.SLOT, FUNCTION, wrap_binaryfunc_r, \
    5972             :            "x." NAME "(y) <==> " DOC)
    5973             : 
    5974             : static slotdef slotdefs[] = {
    5975             :     TPSLOT("__str__", tp_print, NULL, NULL, ""),
    5976             :     TPSLOT("__repr__", tp_print, NULL, NULL, ""),
    5977             :     TPSLOT("__getattribute__", tp_getattr, NULL, NULL, ""),
    5978             :     TPSLOT("__getattr__", tp_getattr, NULL, NULL, ""),
    5979             :     TPSLOT("__setattr__", tp_setattr, NULL, NULL, ""),
    5980             :     TPSLOT("__delattr__", tp_setattr, NULL, NULL, ""),
    5981             :     TPSLOT("__cmp__", tp_compare, _PyObject_SlotCompare, wrap_cmpfunc,
    5982             :            "x.__cmp__(y) <==> cmp(x,y)"),
    5983             :     TPSLOT("__repr__", tp_repr, slot_tp_repr, wrap_unaryfunc,
    5984             :            "x.__repr__() <==> repr(x)"),
    5985             :     TPSLOT("__hash__", tp_hash, slot_tp_hash, wrap_hashfunc,
    5986             :            "x.__hash__() <==> hash(x)"),
    5987             :     FLSLOT("__call__", tp_call, slot_tp_call, (wrapperfunc)wrap_call,
    5988             :            "x.__call__(...) <==> x(...)", PyWrapperFlag_KEYWORDS),
    5989             :     TPSLOT("__str__", tp_str, slot_tp_str, wrap_unaryfunc,
    5990             :            "x.__str__() <==> str(x)"),
    5991             :     TPSLOT("__getattribute__", tp_getattro, slot_tp_getattr_hook,
    5992             :            wrap_binaryfunc, "x.__getattribute__('name') <==> x.name"),
    5993             :     TPSLOT("__getattr__", tp_getattro, slot_tp_getattr_hook, NULL, ""),
    5994             :     TPSLOT("__setattr__", tp_setattro, slot_tp_setattro, wrap_setattr,
    5995             :            "x.__setattr__('name', value) <==> x.name = value"),
    5996             :     TPSLOT("__delattr__", tp_setattro, slot_tp_setattro, wrap_delattr,
    5997             :            "x.__delattr__('name') <==> del x.name"),
    5998             :     TPSLOT("__lt__", tp_richcompare, slot_tp_richcompare, richcmp_lt,
    5999             :            "x.__lt__(y) <==> x<y"),
    6000             :     TPSLOT("__le__", tp_richcompare, slot_tp_richcompare, richcmp_le,
    6001             :            "x.__le__(y) <==> x<=y"),
    6002             :     TPSLOT("__eq__", tp_richcompare, slot_tp_richcompare, richcmp_eq,
    6003             :            "x.__eq__(y) <==> x==y"),
    6004             :     TPSLOT("__ne__", tp_richcompare, slot_tp_richcompare, richcmp_ne,
    6005             :            "x.__ne__(y) <==> x!=y"),
    6006             :     TPSLOT("__gt__", tp_richcompare, slot_tp_richcompare, richcmp_gt,
    6007             :            "x.__gt__(y) <==> x>y"),
    6008             :     TPSLOT("__ge__", tp_richcompare, slot_tp_richcompare, richcmp_ge,
    6009             :            "x.__ge__(y) <==> x>=y"),
    6010             :     TPSLOT("__iter__", tp_iter, slot_tp_iter, wrap_unaryfunc,
    6011             :            "x.__iter__() <==> iter(x)"),
    6012             :     TPSLOT("next", tp_iternext, slot_tp_iternext, wrap_next,
    6013             :            "x.next() -> the next value, or raise StopIteration"),
    6014             :     TPSLOT("__get__", tp_descr_get, slot_tp_descr_get, wrap_descr_get,
    6015             :            "descr.__get__(obj[, type]) -> value"),
    6016             :     TPSLOT("__set__", tp_descr_set, slot_tp_descr_set, wrap_descr_set,
    6017             :            "descr.__set__(obj, value)"),
    6018             :     TPSLOT("__delete__", tp_descr_set, slot_tp_descr_set,
    6019             :            wrap_descr_delete, "descr.__delete__(obj)"),
    6020             :     FLSLOT("__init__", tp_init, slot_tp_init, (wrapperfunc)wrap_init,
    6021             :            "x.__init__(...) initializes x; "
    6022             :            "see help(type(x)) for signature",
    6023             :            PyWrapperFlag_KEYWORDS),
    6024             :     TPSLOT("__new__", tp_new, slot_tp_new, NULL, ""),
    6025             :     TPSLOT("__del__", tp_del, slot_tp_del, NULL, ""),
    6026             :     BINSLOT("__add__", nb_add, slot_nb_add,
    6027             :         "+"),
    6028             :     RBINSLOT("__radd__", nb_add, slot_nb_add,
    6029             :              "+"),
    6030             :     BINSLOT("__sub__", nb_subtract, slot_nb_subtract,
    6031             :         "-"),
    6032             :     RBINSLOT("__rsub__", nb_subtract, slot_nb_subtract,
    6033             :              "-"),
    6034             :     BINSLOT("__mul__", nb_multiply, slot_nb_multiply,
    6035             :         "*"),
    6036             :     RBINSLOT("__rmul__", nb_multiply, slot_nb_multiply,
    6037             :              "*"),
    6038             :     BINSLOT("__div__", nb_divide, slot_nb_divide,
    6039             :         "/"),
    6040             :     RBINSLOT("__rdiv__", nb_divide, slot_nb_divide,
    6041             :              "/"),
    6042             :     BINSLOT("__mod__", nb_remainder, slot_nb_remainder,
    6043             :         "%"),
    6044             :     RBINSLOT("__rmod__", nb_remainder, slot_nb_remainder,
    6045             :              "%"),
    6046             :     BINSLOTNOTINFIX("__divmod__", nb_divmod, slot_nb_divmod,
    6047             :         "divmod(x, y)"),
    6048             :     RBINSLOTNOTINFIX("__rdivmod__", nb_divmod, slot_nb_divmod,
    6049             :              "divmod(y, x)"),
    6050             :     NBSLOT("__pow__", nb_power, slot_nb_power, wrap_ternaryfunc,
    6051             :            "x.__pow__(y[, z]) <==> pow(x, y[, z])"),
    6052             :     NBSLOT("__rpow__", nb_power, slot_nb_power, wrap_ternaryfunc_r,
    6053             :            "y.__rpow__(x[, z]) <==> pow(x, y[, z])"),
    6054             :     UNSLOT("__neg__", nb_negative, slot_nb_negative, wrap_unaryfunc, "-x"),
    6055             :     UNSLOT("__pos__", nb_positive, slot_nb_positive, wrap_unaryfunc, "+x"),
    6056             :     UNSLOT("__abs__", nb_absolute, slot_nb_absolute, wrap_unaryfunc,
    6057             :            "abs(x)"),
    6058             :     UNSLOT("__nonzero__", nb_nonzero, slot_nb_nonzero, wrap_inquirypred,
    6059             :            "x != 0"),
    6060             :     UNSLOT("__invert__", nb_invert, slot_nb_invert, wrap_unaryfunc, "~x"),
    6061             :     BINSLOT("__lshift__", nb_lshift, slot_nb_lshift, "<<"),
    6062             :     RBINSLOT("__rlshift__", nb_lshift, slot_nb_lshift, "<<"),
    6063             :     BINSLOT("__rshift__", nb_rshift, slot_nb_rshift, ">>"),
    6064             :     RBINSLOT("__rrshift__", nb_rshift, slot_nb_rshift, ">>"),
    6065             :     BINSLOT("__and__", nb_and, slot_nb_and, "&"),
    6066             :     RBINSLOT("__rand__", nb_and, slot_nb_and, "&"),
    6067             :     BINSLOT("__xor__", nb_xor, slot_nb_xor, "^"),
    6068             :     RBINSLOT("__rxor__", nb_xor, slot_nb_xor, "^"),
    6069             :     BINSLOT("__or__", nb_or, slot_nb_or, "|"),
    6070             :     RBINSLOT("__ror__", nb_or, slot_nb_or, "|"),
    6071             :     NBSLOT("__coerce__", nb_coerce, slot_nb_coerce, wrap_coercefunc,
    6072             :            "x.__coerce__(y) <==> coerce(x, y)"),
    6073             :     UNSLOT("__int__", nb_int, slot_nb_int, wrap_unaryfunc,
    6074             :            "int(x)"),
    6075             :     UNSLOT("__long__", nb_long, slot_nb_long, wrap_unaryfunc,
    6076             :            "long(x)"),
    6077             :     UNSLOT("__float__", nb_float, slot_nb_float, wrap_unaryfunc,
    6078             :            "float(x)"),
    6079             :     UNSLOT("__oct__", nb_oct, slot_nb_oct, wrap_unaryfunc,
    6080             :            "oct(x)"),
    6081             :     UNSLOT("__hex__", nb_hex, slot_nb_hex, wrap_unaryfunc,
    6082             :            "hex(x)"),
    6083             :     IBSLOT("__iadd__", nb_inplace_add, slot_nb_inplace_add,
    6084             :            wrap_binaryfunc, "+="),
    6085             :     IBSLOT("__isub__", nb_inplace_subtract, slot_nb_inplace_subtract,
    6086             :            wrap_binaryfunc, "-="),
    6087             :     IBSLOT("__imul__", nb_inplace_multiply, slot_nb_inplace_multiply,
    6088             :            wrap_binaryfunc, "*="),
    6089             :     IBSLOT("__idiv__", nb_inplace_divide, slot_nb_inplace_divide,
    6090             :            wrap_binaryfunc, "/="),
    6091             :     IBSLOT("__imod__", nb_inplace_remainder, slot_nb_inplace_remainder,
    6092             :            wrap_binaryfunc, "%="),
    6093             :     IBSLOT("__ipow__", nb_inplace_power, slot_nb_inplace_power,
    6094             :            wrap_binaryfunc, "**="),
    6095             :     IBSLOT("__ilshift__", nb_inplace_lshift, slot_nb_inplace_lshift,
    6096             :            wrap_binaryfunc, "<<="),
    6097             :     IBSLOT("__irshift__", nb_inplace_rshift, slot_nb_inplace_rshift,
    6098             :            wrap_binaryfunc, ">>="),
    6099             :     IBSLOT("__iand__", nb_inplace_and, slot_nb_inplace_and,
    6100             :            wrap_binaryfunc, "&="),
    6101             :     IBSLOT("__ixor__", nb_inplace_xor, slot_nb_inplace_xor,
    6102             :            wrap_binaryfunc, "^="),
    6103             :     IBSLOT("__ior__", nb_inplace_or, slot_nb_inplace_or,
    6104             :            wrap_binaryfunc, "|="),
    6105             :     BINSLOT("__floordiv__", nb_floor_divide, slot_nb_floor_divide, "//"),
    6106             :     RBINSLOT("__rfloordiv__", nb_floor_divide, slot_nb_floor_divide, "//"),
    6107             :     BINSLOT("__truediv__", nb_true_divide, slot_nb_true_divide, "/"),
    6108             :     RBINSLOT("__rtruediv__", nb_true_divide, slot_nb_true_divide, "/"),
    6109             :     IBSLOT("__ifloordiv__", nb_inplace_floor_divide,
    6110             :            slot_nb_inplace_floor_divide, wrap_binaryfunc, "//="),
    6111             :     IBSLOT("__itruediv__", nb_inplace_true_divide,
    6112             :            slot_nb_inplace_true_divide, wrap_binaryfunc, "/="),
    6113             :     NBSLOT("__index__", nb_index, slot_nb_index, wrap_unaryfunc,
    6114             :            "x[y:z] <==> x[y.__index__():z.__index__()]"),
    6115             :     MPSLOT("__len__", mp_length, slot_mp_length, wrap_lenfunc,
    6116             :            "x.__len__() <==> len(x)"),
    6117             :     MPSLOT("__getitem__", mp_subscript, slot_mp_subscript,
    6118             :            wrap_binaryfunc,
    6119             :            "x.__getitem__(y) <==> x[y]"),
    6120             :     MPSLOT("__setitem__", mp_ass_subscript, slot_mp_ass_subscript,
    6121             :            wrap_objobjargproc,
    6122             :            "x.__setitem__(i, y) <==> x[i]=y"),
    6123             :     MPSLOT("__delitem__", mp_ass_subscript, slot_mp_ass_subscript,
    6124             :            wrap_delitem,
    6125             :            "x.__delitem__(y) <==> del x[y]"),
    6126             :     SQSLOT("__len__", sq_length, slot_sq_length, wrap_lenfunc,
    6127             :            "x.__len__() <==> len(x)"),
    6128             :     /* Heap types defining __add__/__mul__ have sq_concat/sq_repeat == NULL.
    6129             :        The logic in abstract.c always falls back to nb_add/nb_multiply in
    6130             :        this case.  Defining both the nb_* and the sq_* slots to call the
    6131             :        user-defined methods has unexpected side-effects, as shown by
    6132             :        test_descr.notimplemented() */
    6133             :     SQSLOT("__add__", sq_concat, NULL, wrap_binaryfunc,
    6134             :       "x.__add__(y) <==> x+y"),
    6135             :     SQSLOT("__mul__", sq_repeat, NULL, wrap_indexargfunc,
    6136             :       "x.__mul__(n) <==> x*n"),
    6137             :     SQSLOT("__rmul__", sq_repeat, NULL, wrap_indexargfunc,
    6138             :       "x.__rmul__(n) <==> n*x"),
    6139             :     SQSLOT("__getitem__", sq_item, slot_sq_item, wrap_sq_item,
    6140             :            "x.__getitem__(y) <==> x[y]"),
    6141             :     SQSLOT("__getslice__", sq_slice, slot_sq_slice, wrap_ssizessizeargfunc,
    6142             :            "x.__getslice__(i, j) <==> x[i:j]\n\
    6143             :            \n\
    6144             :            Use of negative indices is not supported."),
    6145             :     SQSLOT("__setitem__", sq_ass_item, slot_sq_ass_item, wrap_sq_setitem,
    6146             :            "x.__setitem__(i, y) <==> x[i]=y"),
    6147             :     SQSLOT("__delitem__", sq_ass_item, slot_sq_ass_item, wrap_sq_delitem,
    6148             :            "x.__delitem__(y) <==> del x[y]"),
    6149             :     SQSLOT("__setslice__", sq_ass_slice, slot_sq_ass_slice,
    6150             :            wrap_ssizessizeobjargproc,
    6151             :            "x.__setslice__(i, j, y) <==> x[i:j]=y\n\
    6152             :            \n\
    6153             :            Use  of negative indices is not supported."),
    6154             :     SQSLOT("__delslice__", sq_ass_slice, slot_sq_ass_slice, wrap_delslice,
    6155             :            "x.__delslice__(i, j) <==> del x[i:j]\n\
    6156             :            \n\
    6157             :            Use of negative indices is not supported."),
    6158             :     SQSLOT("__contains__", sq_contains, slot_sq_contains, wrap_objobjproc,
    6159             :            "x.__contains__(y) <==> y in x"),
    6160             :     SQSLOT("__iadd__", sq_inplace_concat, NULL,
    6161             :       wrap_binaryfunc, "x.__iadd__(y) <==> x+=y"),
    6162             :     SQSLOT("__imul__", sq_inplace_repeat, NULL,
    6163             :       wrap_indexargfunc, "x.__imul__(y) <==> x*=y"),
    6164             :     {NULL}
    6165             : };
    6166             : 
    6167             : /* Given a type pointer and an offset gotten from a slotdef entry, return a
    6168             :    pointer to the actual slot.  This is not quite the same as simply adding
    6169             :    the offset to the type pointer, since it takes care to indirect through the
    6170             :    proper indirection pointer (as_buffer, etc.); it returns NULL if the
    6171             :    indirection pointer is NULL. */
    6172             : static void **
    6173      187548 : slotptr(PyTypeObject *type, int ioffset)
    6174             : {
    6175             :     char *ptr;
    6176      187548 :     long offset = ioffset;
    6177             : 
    6178             :     /* Note: this depends on the order of the members of PyHeapTypeObject! */
    6179             :     assert(offset >= 0);
    6180             :     assert((size_t)offset < offsetof(PyHeapTypeObject, as_buffer));
    6181      187548 :     if ((size_t)offset >= offsetof(PyHeapTypeObject, as_sequence)) {
    6182       25440 :         ptr = (char *)type->tp_as_sequence;
    6183       25440 :         offset -= offsetof(PyHeapTypeObject, as_sequence);
    6184             :     }
    6185      162108 :     else if ((size_t)offset >= offsetof(PyHeapTypeObject, as_mapping)) {
    6186        7881 :         ptr = (char *)type->tp_as_mapping;
    6187        7881 :         offset -= offsetof(PyHeapTypeObject, as_mapping);
    6188             :     }
    6189      154227 :     else if ((size_t)offset >= offsetof(PyHeapTypeObject, as_number)) {
    6190       99675 :         ptr = (char *)type->tp_as_number;
    6191       99675 :         offset -= offsetof(PyHeapTypeObject, as_number);
    6192             :     }
    6193             :     else {
    6194       54552 :         ptr = (char *)type;
    6195             :     }
    6196      187548 :     if (ptr != NULL)
    6197      155616 :         ptr += offset;
    6198      187548 :     return (void **)ptr;
    6199             : }
    6200             : 
    6201             : /* Length of array of slotdef pointers used to store slots with the
    6202             :    same __name__.  There should be at most MAX_EQUIV-1 slotdef entries with
    6203             :    the same __name__, for any __name__. Since that's a static property, it is
    6204             :    appropriate to declare fixed-size arrays for this. */
    6205             : #define MAX_EQUIV 10
    6206             : 
    6207             : /* Return a slot pointer for a given name, but ONLY if the attribute has
    6208             :    exactly one slot function.  The name must be an interned string. */
    6209             : static void **
    6210        8592 : resolve_slotdups(PyTypeObject *type, PyObject *name)
    6211             : {
    6212             :     /* XXX Maybe this could be optimized more -- but is it worth it? */
    6213             : 
    6214             :     /* pname and ptrs act as a little cache */
    6215             :     static PyObject *pname;
    6216             :     static slotdef *ptrs[MAX_EQUIV];
    6217             :     slotdef *p, **pp;
    6218             :     void **res, **ptr;
    6219             : 
    6220        8592 :     if (pname != name) {
    6221             :         /* Collect all slotdefs that match name into ptrs. */
    6222        8505 :         pname = name;
    6223        8505 :         pp = ptrs;
    6224      850500 :         for (p = slotdefs; p->name_strobj; p++) {
    6225      841995 :             if (p->name_strobj == name)
    6226       15504 :                 *pp++ = p;
    6227             :         }
    6228        8505 :         *pp = NULL;
    6229             :     }
    6230             : 
    6231             :     /* Look in all matching slots of the type; if exactly one of these has
    6232             :        a filled-in slot, return its value.      Otherwise return NULL. */
    6233        8592 :     res = NULL;
    6234       24084 :     for (pp = ptrs; *pp; pp++) {
    6235       15678 :         ptr = slotptr(type, (*pp)->offset);
    6236       15678 :         if (ptr == NULL || *ptr == NULL)
    6237        6900 :             continue;
    6238        8778 :         if (res != NULL)
    6239         186 :             return NULL;
    6240        8592 :         res = ptr;
    6241             :     }
    6242        8406 :     return res;
    6243             : }
    6244             : 
    6245             : /* Common code for update_slots_callback() and fixup_slot_dispatchers().  This
    6246             :    does some incredibly complex thinking and then sticks something into the
    6247             :    slot.  (It sees if the adjacent slotdefs for the same slot have conflicting
    6248             :    interests, and then stores a generic wrapper or a specific function into
    6249             :    the slot.)  Return a pointer to the next slotdef with a different offset,
    6250             :    because that's convenient  for fixup_slot_dispatchers(). */
    6251             : static slotdef *
    6252       55230 : update_one_slot(PyTypeObject *type, slotdef *p)
    6253             : {
    6254             :     PyObject *descr;
    6255             :     PyWrapperDescrObject *d;
    6256       55230 :     void *generic = NULL, *specific = NULL;
    6257       55230 :     int use_generic = 0;
    6258       55230 :     int offset = p->offset;
    6259       55230 :     void **ptr = slotptr(type, offset);
    6260             : 
    6261       55230 :     if (ptr == NULL) {
    6262             :         do {
    6263           0 :             ++p;
    6264           0 :         } while (p->offset == offset);
    6265           0 :         return p;
    6266             :     }
    6267             :     do {
    6268       78111 :         descr = _PyType_Lookup(type, p->name_strobj);
    6269       78111 :         if (descr == NULL) {
    6270       65676 :             if (ptr == (void**)&type->tp_iternext) {
    6271         774 :                 specific = _PyObject_NextNotImplemented;
    6272             :             }
    6273       65676 :             continue;
    6274             :         }
    6275       21027 :         if (Py_TYPE(descr) == &PyWrapperDescr_Type &&
    6276       17184 :             ((PyWrapperDescrObject *)descr)->d_base->name_strobj == p->name_strobj) {
    6277        8592 :             void **tptr = resolve_slotdups(type, p->name_strobj);
    6278        8592 :             if (tptr == NULL || tptr == ptr)
    6279        5163 :                 generic = p->function;
    6280        8592 :             d = (PyWrapperDescrObject *)descr;
    6281       13683 :             if (d->d_base->wrapper == p->wrapper &&
    6282        5091 :                 PyType_IsSubtype(type, d->d_type))
    6283             :             {
    6284        5880 :                 if (specific == NULL ||
    6285         789 :                     specific == d->d_wrapped)
    6286        5091 :                     specific = d->d_wrapped;
    6287             :                 else
    6288           0 :                     use_generic = 1;
    6289             :             }
    6290             :         }
    6291        4590 :         else if (Py_TYPE(descr) == &PyCFunction_Type &&
    6292         747 :                  PyCFunction_GET_FUNCTION(descr) ==
    6293         747 :                  (PyCFunction)tp_new_wrapper &&
    6294         747 :                  ptr == (void**)&type->tp_new)
    6295             :         {
    6296             :             /* The __new__ wrapper is not a wrapper descriptor,
    6297             :                so must be special-cased differently.
    6298             :                If we don't do this, creating an instance will
    6299             :                always use slot_tp_new which will look up
    6300             :                __new__ in the MRO which will call tp_new_wrapper
    6301             :                which will look through the base classes looking
    6302             :                for a static base and call its tp_new (usually
    6303             :                PyType_GenericNew), after performing various
    6304             :                sanity checks and constructing a new argument
    6305             :                list.  Cut all that nonsense short -- this speeds
    6306             :                up instance creation tremendously. */
    6307         747 :             specific = (void *)type->tp_new;
    6308             :             /* XXX I'm not 100% sure that there isn't a hole
    6309             :                in this reasoning that requires additional
    6310             :                sanity checks.  I'll buy the first person to
    6311             :                point out a bug in this reasoning a beer. */
    6312             :         }
    6313        3123 :         else if (descr == Py_None &&
    6314          27 :                  ptr == (void**)&type->tp_hash) {
    6315             :             /* We specifically allow __hash__ to be set to None
    6316             :                to prevent inheritance of the default
    6317             :                implementation from object.__hash__ */
    6318          27 :             specific = PyObject_HashNotImplemented;
    6319             :         }
    6320             :         else {
    6321        3069 :             use_generic = 1;
    6322        3069 :             generic = p->function;
    6323             :         }
    6324       78111 :     } while ((++p)->offset == offset);
    6325       55230 :     if (specific && !use_generic)
    6326        5553 :         *ptr = specific;
    6327             :     else
    6328       49677 :         *ptr = generic;
    6329       55230 :     return p;
    6330             : }
    6331             : 
    6332             : /* In the type, update the slots whose slotdefs are gathered in the pp array.
    6333             :    This is a callback for update_subclasses(). */
    6334             : static int
    6335           0 : update_slots_callback(PyTypeObject *type, void *data)
    6336             : {
    6337           0 :     slotdef **pp = (slotdef **)data;
    6338             : 
    6339           0 :     for (; *pp; pp++)
    6340           0 :         update_one_slot(type, *pp);
    6341           0 :     return 0;
    6342             : }
    6343             : 
    6344             : /* Initialize the slotdefs table by adding interned string objects for the
    6345             :    names and sorting the entries. */
    6346             : static void
    6347        3285 : init_slotdefs(void)
    6348             : {
    6349             :     slotdef *p;
    6350             :     static int initialized = 0;
    6351             : 
    6352        3285 :     if (initialized)
    6353        6567 :         return;
    6354         300 :     for (p = slotdefs; p->name; p++) {
    6355             :         /* Slots must be ordered by their offset in the PyHeapTypeObject. */
    6356             :         assert(!p[1].name || p->offset <= p[1].offset);
    6357         297 :         p->name_strobj = PyString_InternFromString(p->name);
    6358         297 :         if (!p->name_strobj)
    6359           0 :             Py_FatalError("Out of memory interning slotdef names");
    6360             :     }
    6361           3 :     initialized = 1;
    6362             : }
    6363             : 
    6364             : /* Update the slots after assignment to a class (type) attribute. */
    6365             : static int
    6366        1200 : update_slot(PyTypeObject *type, PyObject *name)
    6367             : {
    6368             :     slotdef *ptrs[MAX_EQUIV];
    6369             :     slotdef *p;
    6370             :     slotdef **pp;
    6371             :     int offset;
    6372             : 
    6373             :     /* Clear the VALID_VERSION flag of 'type' and all its
    6374             :        subclasses.  This could possibly be unified with the
    6375             :        update_subclasses() recursion below, but carefully:
    6376             :        they each have their own conditions on which to stop
    6377             :        recursing into subclasses. */
    6378        1200 :     PyType_Modified(type);
    6379             : 
    6380        1200 :     init_slotdefs();
    6381        1200 :     pp = ptrs;
    6382      120000 :     for (p = slotdefs; p->name; p++) {
    6383             :         /* XXX assume name is interned! */
    6384      118800 :         if (p->name_strobj == name)
    6385           0 :             *pp++ = p;
    6386             :     }
    6387        1200 :     *pp = NULL;
    6388        1200 :     for (pp = ptrs; *pp; pp++) {
    6389           0 :         p = *pp;
    6390           0 :         offset = p->offset;
    6391           0 :         while (p > slotdefs && (p-1)->offset == offset)
    6392           0 :             --p;
    6393           0 :         *pp = p;
    6394             :     }
    6395        1200 :     if (ptrs[0] == NULL)
    6396        1200 :         return 0; /* Not an attribute that affects any slots */
    6397           0 :     return update_subclasses(type, name,
    6398             :                              update_slots_callback, (void *)ptrs);
    6399             : }
    6400             : 
    6401             : /* Store the proper functions in the slot dispatches at class (type)
    6402             :    definition time, based upon which operations the class overrides in its
    6403             :    dict. */
    6404             : static void
    6405         789 : fixup_slot_dispatchers(PyTypeObject *type)
    6406             : {
    6407             :     slotdef *p;
    6408             : 
    6409         789 :     init_slotdefs();
    6410       56808 :     for (p = slotdefs; p->name; )
    6411       55230 :         p = update_one_slot(type, p);
    6412         789 : }
    6413             : 
    6414             : static void
    6415           0 : update_all_slots(PyTypeObject* type)
    6416             : {
    6417             :     slotdef *p;
    6418             : 
    6419           0 :     init_slotdefs();
    6420           0 :     for (p = slotdefs; p->name; p++) {
    6421             :         /* update_slot returns int but can't actually fail */
    6422           0 :         update_slot(type, p->name_strobj);
    6423             :     }
    6424           0 : }
    6425             : 
    6426             : /* recurse_down_subclasses() and update_subclasses() are mutually
    6427             :    recursive functions to call a callback for all subclasses,
    6428             :    but refraining from recursing into subclasses that define 'name'. */
    6429             : 
    6430             : static int
    6431           0 : update_subclasses(PyTypeObject *type, PyObject *name,
    6432             :                   update_callback callback, void *data)
    6433             : {
    6434           0 :     if (callback(type, data) < 0)
    6435           0 :         return -1;
    6436           0 :     return recurse_down_subclasses(type, name, callback, data);
    6437             : }
    6438             : 
    6439             : static int
    6440           0 : recurse_down_subclasses(PyTypeObject *type, PyObject *name,
    6441             :                         update_callback callback, void *data)
    6442             : {
    6443             :     PyTypeObject *subclass;
    6444             :     PyObject *ref, *subclasses, *dict;
    6445             :     Py_ssize_t i, n;
    6446             : 
    6447           0 :     subclasses = type->tp_subclasses;
    6448           0 :     if (subclasses == NULL)
    6449           0 :         return 0;
    6450             :     assert(PyList_Check(subclasses));
    6451           0 :     n = PyList_GET_SIZE(subclasses);
    6452           0 :     for (i = 0; i < n; i++) {
    6453           0 :         ref = PyList_GET_ITEM(subclasses, i);
    6454             :         assert(PyWeakref_CheckRef(ref));
    6455           0 :         subclass = (PyTypeObject *)PyWeakref_GET_OBJECT(ref);
    6456             :         assert(subclass != NULL);
    6457           0 :         if ((PyObject *)subclass == Py_None)
    6458           0 :             continue;
    6459             :         assert(PyType_Check(subclass));
    6460             :         /* Avoid recursing down into unaffected classes */
    6461           0 :         dict = subclass->tp_dict;
    6462           0 :         if (dict != NULL && PyDict_Check(dict) &&
    6463           0 :             PyDict_GetItem(dict, name) != NULL)
    6464           0 :             continue;
    6465           0 :         if (update_subclasses(subclass, name, callback, data) < 0)
    6466           0 :             return -1;
    6467             :     }
    6468           0 :     return 0;
    6469             : }
    6470             : 
    6471             : /* This function is called by PyType_Ready() to populate the type's
    6472             :    dictionary with method descriptors for function slots.  For each
    6473             :    function slot (like tp_repr) that's defined in the type, one or more
    6474             :    corresponding descriptors are added in the type's tp_dict dictionary
    6475             :    under the appropriate name (like __repr__).  Some function slots
    6476             :    cause more than one descriptor to be added (for example, the nb_add
    6477             :    slot adds both __add__ and __radd__ descriptors) and some function
    6478             :    slots compete for the same descriptor (for example both sq_item and
    6479             :    mp_subscript generate a __getitem__ descriptor).
    6480             : 
    6481             :    In the latter case, the first slotdef entry encountered wins.  Since
    6482             :    slotdef entries are sorted by the offset of the slot in the
    6483             :    PyHeapTypeObject, this gives us some control over disambiguating
    6484             :    between competing slots: the members of PyHeapTypeObject are listed
    6485             :    from most general to least general, so the most general slot is
    6486             :    preferred.  In particular, because as_mapping comes before as_sequence,
    6487             :    for a type that defines both mp_subscript and sq_item, mp_subscript
    6488             :    wins.
    6489             : 
    6490             :    This only adds new descriptors and doesn't overwrite entries in
    6491             :    tp_dict that were previously defined.  The descriptors contain a
    6492             :    reference to the C function they must call, so that it's safe if they
    6493             :    are copied into a subtype's __dict__ and the subtype has a different
    6494             :    C function in its slot -- calling the method defined by the
    6495             :    descriptor will call the C function that was used to create it,
    6496             :    rather than the C function present in the slot when it is called.
    6497             :    (This is important because a subtype may have a C function in the
    6498             :    slot that calls the method from the dictionary, and we want to avoid
    6499             :    infinite recursion here.) */
    6500             : 
    6501             : static int
    6502        1296 : add_operators(PyTypeObject *type)
    6503             : {
    6504        1296 :     PyObject *dict = type->tp_dict;
    6505             :     slotdef *p;
    6506             :     PyObject *descr;
    6507             :     void **ptr;
    6508             : 
    6509        1296 :     init_slotdefs();
    6510      129600 :     for (p = slotdefs; p->name; p++) {
    6511      128304 :         if (p->wrapper == NULL)
    6512       11664 :             continue;
    6513      116640 :         ptr = slotptr(type, p->offset);
    6514      116640 :         if (!ptr || !*ptr)
    6515      113202 :             continue;
    6516        3438 :         if (PyDict_GetItem(dict, p->name_strobj))
    6517         123 :             continue;
    6518        3315 :         if (*ptr == PyObject_HashNotImplemented) {
    6519             :             /* Classes may prevent the inheritance of the tp_hash
    6520             :                slot by storing PyObject_HashNotImplemented in it. Make it
    6521             :                visible as a None value for the __hash__ attribute. */
    6522          12 :             if (PyDict_SetItem(dict, p->name_strobj, Py_None) < 0)
    6523           0 :                 return -1;
    6524             :         }
    6525             :         else {
    6526        3303 :             descr = PyDescr_NewWrapper(type, p, *ptr);
    6527        3303 :             if (descr == NULL)
    6528           0 :                 return -1;
    6529        3303 :             if (PyDict_SetItem(dict, p->name_strobj, descr) < 0) {
    6530           0 :                 Py_DECREF(descr);
    6531           0 :                 return -1;
    6532             :             }
    6533        3303 :             Py_DECREF(descr);
    6534             :         }
    6535             :     }
    6536        1296 :     if (type->tp_new != NULL) {
    6537         393 :         if (add_tp_new_wrapper(type) < 0)
    6538           0 :             return -1;
    6539             :     }
    6540        1296 :     return 0;
    6541             : }
    6542             : 
    6543             : 
    6544             : /* Cooperative 'super' */
    6545             : 
    6546             : typedef struct {
    6547             :     PyObject_HEAD
    6548             :     PyTypeObject *type;
    6549             :     PyObject *obj;
    6550             :     PyTypeObject *obj_type;
    6551             : } superobject;
    6552             : 
    6553             : static PyMemberDef super_members[] = {
    6554             :     {"__thisclass__", T_OBJECT, offsetof(superobject, type), READONLY,
    6555             :      "the class invoking super()"},
    6556             :     {"__self__",  T_OBJECT, offsetof(superobject, obj), READONLY,
    6557             :      "the instance invoking super(); may be None"},
    6558             :     {"__self_class__", T_OBJECT, offsetof(superobject, obj_type), READONLY,
    6559             :      "the type of the instance invoking super(); may be None"},
    6560             :     {0}
    6561             : };
    6562             : 
    6563             : static void
    6564          72 : super_dealloc(PyObject *self)
    6565             : {
    6566          72 :     superobject *su = (superobject *)self;
    6567             : 
    6568          72 :     _PyObject_GC_UNTRACK(self);
    6569          72 :     Py_XDECREF(su->obj);
    6570          72 :     Py_XDECREF(su->type);
    6571          72 :     Py_XDECREF(su->obj_type);
    6572          72 :     Py_TYPE(self)->tp_free(self);
    6573          72 : }
    6574             : 
    6575             : static PyObject *
    6576           0 : super_repr(PyObject *self)
    6577             : {
    6578           0 :     superobject *su = (superobject *)self;
    6579             : 
    6580           0 :     if (su->obj_type)
    6581           0 :         return PyString_FromFormat(
    6582             :             "<super: <class '%s'>, <%s object>>",
    6583           0 :             su->type ? su->type->tp_name : "NULL",
    6584           0 :             su->obj_type->tp_name);
    6585             :     else
    6586           0 :         return PyString_FromFormat(
    6587             :             "<super: <class '%s'>, NULL>",
    6588           0 :             su->type ? su->type->tp_name : "NULL");
    6589             : }
    6590             : 
    6591             : static PyObject *
    6592          72 : super_getattro(PyObject *self, PyObject *name)
    6593             : {
    6594          72 :     superobject *su = (superobject *)self;
    6595          72 :     int skip = su->obj_type == NULL;
    6596             : 
    6597          72 :     if (!skip) {
    6598             :         /* We want __class__ to return the class of the super object
    6599             :            (i.e. super, or a subclass), not the class of su->obj. */
    6600         216 :         skip = (PyString_Check(name) &&
    6601          72 :             PyString_GET_SIZE(name) == 9 &&
    6602           0 :             strcmp(PyString_AS_STRING(name), "__class__") == 0);
    6603             :     }
    6604             : 
    6605          72 :     if (!skip) {
    6606             :         PyObject *mro, *res, *tmp, *dict;
    6607             :         PyTypeObject *starttype;
    6608             :         descrgetfunc f;
    6609             :         Py_ssize_t i, n;
    6610             : 
    6611          72 :         starttype = su->obj_type;
    6612          72 :         mro = starttype->tp_mro;
    6613             : 
    6614          72 :         if (mro == NULL)
    6615           0 :             n = 0;
    6616             :         else {
    6617             :             assert(PyTuple_Check(mro));
    6618          72 :             n = PyTuple_GET_SIZE(mro);
    6619             :         }
    6620          72 :         for (i = 0; i < n; i++) {
    6621          72 :             if ((PyObject *)(su->type) == PyTuple_GET_ITEM(mro, i))
    6622          72 :                 break;
    6623             :         }
    6624          72 :         i++;
    6625          72 :         res = NULL;
    6626          72 :         for (; i < n; i++) {
    6627          72 :             tmp = PyTuple_GET_ITEM(mro, i);
    6628          72 :             if (PyType_Check(tmp))
    6629          72 :                 dict = ((PyTypeObject *)tmp)->tp_dict;
    6630           0 :             else if (PyClass_Check(tmp))
    6631           0 :                 dict = ((PyClassObject *)tmp)->cl_dict;
    6632             :             else
    6633           0 :                 continue;
    6634          72 :             res = PyDict_GetItem(dict, name);
    6635          72 :             if (res != NULL) {
    6636          72 :                 Py_INCREF(res);
    6637          72 :                 f = Py_TYPE(res)->tp_descr_get;
    6638          72 :                 if (f != NULL) {
    6639          12 :                     tmp = f(res,
    6640             :                         /* Only pass 'obj' param if
    6641             :                            this is instance-mode super
    6642             :                            (See SF ID #743627)
    6643             :                         */
    6644          12 :                         (su->obj == (PyObject *)
    6645          12 :                                     su->obj_type
    6646             :                             ? (PyObject *)NULL
    6647             :                             : su->obj),
    6648             :                         (PyObject *)starttype);
    6649          12 :                     Py_DECREF(res);
    6650          12 :                     res = tmp;
    6651             :                 }
    6652          72 :                 return res;
    6653             :             }
    6654             :         }
    6655             :     }
    6656           0 :     return PyObject_GenericGetAttr(self, name);
    6657             : }
    6658             : 
    6659             : static PyTypeObject *
    6660          72 : supercheck(PyTypeObject *type, PyObject *obj)
    6661             : {
    6662             :     /* Check that a super() call makes sense.  Return a type object.
    6663             : 
    6664             :        obj can be a new-style class, or an instance of one:
    6665             : 
    6666             :        - If it is a class, it must be a subclass of 'type'.      This case is
    6667             :          used for class methods; the return value is obj.
    6668             : 
    6669             :        - If it is an instance, it must be an instance of 'type'.  This is
    6670             :          the normal case; the return value is obj.__class__.
    6671             : 
    6672             :        But... when obj is an instance, we want to allow for the case where
    6673             :        Py_TYPE(obj) is not a subclass of type, but obj.__class__ is!
    6674             :        This will allow using super() with a proxy for obj.
    6675             :     */
    6676             : 
    6677             :     /* Check for first bullet above (special case) */
    6678          72 :     if (PyType_Check(obj) && PyType_IsSubtype((PyTypeObject *)obj, type)) {
    6679          60 :         Py_INCREF(obj);
    6680          60 :         return (PyTypeObject *)obj;
    6681             :     }
    6682             : 
    6683             :     /* Normal case */
    6684          12 :     if (PyType_IsSubtype(Py_TYPE(obj), type)) {
    6685          12 :         Py_INCREF(Py_TYPE(obj));
    6686          12 :         return Py_TYPE(obj);
    6687             :     }
    6688             :     else {
    6689             :         /* Try the slow way */
    6690             :         static PyObject *class_str = NULL;
    6691             :         PyObject *class_attr;
    6692             : 
    6693           0 :         if (class_str == NULL) {
    6694           0 :             class_str = PyString_FromString("__class__");
    6695           0 :             if (class_str == NULL)
    6696           0 :                 return NULL;
    6697             :         }
    6698             : 
    6699           0 :         class_attr = PyObject_GetAttr(obj, class_str);
    6700             : 
    6701           0 :         if (class_attr != NULL &&
    6702           0 :             PyType_Check(class_attr) &&
    6703           0 :             (PyTypeObject *)class_attr != Py_TYPE(obj))
    6704             :         {
    6705           0 :             int ok = PyType_IsSubtype(
    6706             :                 (PyTypeObject *)class_attr, type);
    6707           0 :             if (ok)
    6708           0 :                 return (PyTypeObject *)class_attr;
    6709             :         }
    6710             : 
    6711           0 :         if (class_attr == NULL)
    6712           0 :             PyErr_Clear();
    6713             :         else
    6714           0 :             Py_DECREF(class_attr);
    6715             :     }
    6716             : 
    6717           0 :     PyErr_SetString(PyExc_TypeError,
    6718             :                     "super(type, obj): "
    6719             :                     "obj must be an instance or subtype of type");
    6720           0 :     return NULL;
    6721             : }
    6722             : 
    6723             : static PyObject *
    6724           0 : super_descr_get(PyObject *self, PyObject *obj, PyObject *type)
    6725             : {
    6726           0 :     superobject *su = (superobject *)self;
    6727             :     superobject *newobj;
    6728             : 
    6729           0 :     if (obj == NULL || obj == Py_None || su->obj != NULL) {
    6730             :         /* Not binding to an object, or already bound */
    6731           0 :         Py_INCREF(self);
    6732           0 :         return self;
    6733             :     }
    6734           0 :     if (Py_TYPE(su) != &PySuper_Type)
    6735             :         /* If su is an instance of a (strict) subclass of super,
    6736             :            call its type */
    6737           0 :         return PyObject_CallFunctionObjArgs((PyObject *)Py_TYPE(su),
    6738             :                                             su->type, obj, NULL);
    6739             :     else {
    6740             :         /* Inline the common case */
    6741           0 :         PyTypeObject *obj_type = supercheck(su->type, obj);
    6742           0 :         if (obj_type == NULL)
    6743           0 :             return NULL;
    6744           0 :         newobj = (superobject *)PySuper_Type.tp_new(&PySuper_Type,
    6745             :                                                  NULL, NULL);
    6746           0 :         if (newobj == NULL)
    6747           0 :             return NULL;
    6748           0 :         Py_INCREF(su->type);
    6749           0 :         Py_INCREF(obj);
    6750           0 :         newobj->type = su->type;
    6751           0 :         newobj->obj = obj;
    6752           0 :         newobj->obj_type = obj_type;
    6753           0 :         return (PyObject *)newobj;
    6754             :     }
    6755             : }
    6756             : 
    6757             : static int
    6758          72 : super_init(PyObject *self, PyObject *args, PyObject *kwds)
    6759             : {
    6760          72 :     superobject *su = (superobject *)self;
    6761             :     PyTypeObject *type;
    6762          72 :     PyObject *obj = NULL;
    6763          72 :     PyTypeObject *obj_type = NULL;
    6764             : 
    6765          72 :     if (!_PyArg_NoKeywords("super", kwds))
    6766           0 :         return -1;
    6767          72 :     if (!PyArg_ParseTuple(args, "O!|O:super", &PyType_Type, &type, &obj))
    6768           0 :         return -1;
    6769          72 :     if (obj == Py_None)
    6770           0 :         obj = NULL;
    6771          72 :     if (obj != NULL) {
    6772          72 :         obj_type = supercheck(type, obj);
    6773          72 :         if (obj_type == NULL)
    6774           0 :             return -1;
    6775          72 :         Py_INCREF(obj);
    6776             :     }
    6777          72 :     Py_INCREF(type);
    6778          72 :     Py_XSETREF(su->type, type);
    6779          72 :     Py_XSETREF(su->obj, obj);
    6780          72 :     Py_XSETREF(su->obj_type, obj_type);
    6781          72 :     return 0;
    6782             : }
    6783             : 
    6784             : PyDoc_STRVAR(super_doc,
    6785             : "super(type, obj) -> bound super object; requires isinstance(obj, type)\n"
    6786             : "super(type) -> unbound super object\n"
    6787             : "super(type, type2) -> bound super object; requires issubclass(type2, type)\n"
    6788             : "Typical use to call a cooperative superclass method:\n"
    6789             : "class C(B):\n"
    6790             : "    def meth(self, arg):\n"
    6791             : "        super(C, self).meth(arg)");
    6792             : 
    6793             : static int
    6794           0 : super_traverse(PyObject *self, visitproc visit, void *arg)
    6795             : {
    6796           0 :     superobject *su = (superobject *)self;
    6797             : 
    6798           0 :     Py_VISIT(su->obj);
    6799           0 :     Py_VISIT(su->type);
    6800           0 :     Py_VISIT(su->obj_type);
    6801             : 
    6802           0 :     return 0;
    6803             : }
    6804             : 
    6805             : PyTypeObject PySuper_Type = {
    6806             :     PyVarObject_HEAD_INIT(&PyType_Type, 0)
    6807             :     "super",                                    /* tp_name */
    6808             :     sizeof(superobject),                        /* tp_basicsize */
    6809             :     0,                                          /* tp_itemsize */
    6810             :     /* methods */
    6811             :     super_dealloc,                              /* tp_dealloc */
    6812             :     0,                                          /* tp_print */
    6813             :     0,                                          /* tp_getattr */
    6814             :     0,                                          /* tp_setattr */
    6815             :     0,                                          /* tp_compare */
    6816             :     super_repr,                                 /* tp_repr */
    6817             :     0,                                          /* tp_as_number */
    6818             :     0,                                          /* tp_as_sequence */
    6819             :     0,                                          /* tp_as_mapping */
    6820             :     0,                                          /* tp_hash */
    6821             :     0,                                          /* tp_call */
    6822             :     0,                                          /* tp_str */
    6823             :     super_getattro,                             /* tp_getattro */
    6824             :     0,                                          /* tp_setattro */
    6825             :     0,                                          /* tp_as_buffer */
    6826             :     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
    6827             :         Py_TPFLAGS_BASETYPE,                    /* tp_flags */
    6828             :     super_doc,                                  /* tp_doc */
    6829             :     super_traverse,                             /* tp_traverse */
    6830             :     0,                                          /* tp_clear */
    6831             :     0,                                          /* tp_richcompare */
    6832             :     0,                                          /* tp_weaklistoffset */
    6833             :     0,                                          /* tp_iter */
    6834             :     0,                                          /* tp_iternext */
    6835             :     0,                                          /* tp_methods */
    6836             :     super_members,                              /* tp_members */
    6837             :     0,                                          /* tp_getset */
    6838             :     0,                                          /* tp_base */
    6839             :     0,                                          /* tp_dict */
    6840             :     super_descr_get,                            /* tp_descr_get */
    6841             :     0,                                          /* tp_descr_set */
    6842             :     0,                                          /* tp_dictoffset */
    6843             :     super_init,                                 /* tp_init */
    6844             :     PyType_GenericAlloc,                        /* tp_alloc */
    6845             :     PyType_GenericNew,                          /* tp_new */
    6846             :     PyObject_GC_Del,                            /* tp_free */
    6847             : };

Generated by: LCOV version 1.10