diff -r 7050c9fc1f72 Include/descrobject.h --- a/Include/descrobject.h Wed May 04 11:28:09 2016 +0300 +++ b/Include/descrobject.h Wed May 04 16:43:14 2016 +0300 @@ -67,10 +67,13 @@ typedef struct { void *d_wrapped; /* This can be any function pointer */ } PyWrapperDescrObject; +PyAPI_DATA(PyTypeObject) _PyClassMethodDescr_Type; +PyAPI_DATA(PyTypeObject) _PyMethodDescr_Type; PyAPI_DATA(PyTypeObject) PyWrapperDescr_Type; PyAPI_DATA(PyTypeObject) PyDictProxy_Type; PyAPI_DATA(PyTypeObject) PyGetSetDescr_Type; PyAPI_DATA(PyTypeObject) PyMemberDescr_Type; +PyAPI_DATA(PyTypeObject) _PyMethodWrapper_Type; PyAPI_FUNC(PyObject *) PyDescr_NewMethod(PyTypeObject *, PyMethodDef *); PyAPI_FUNC(PyObject *) PyDescr_NewClassMethod(PyTypeObject *, PyMethodDef *); diff -r 7050c9fc1f72 Include/listobject.h --- a/Include/listobject.h Wed May 04 11:28:09 2016 +0300 +++ b/Include/listobject.h Wed May 04 16:43:14 2016 +0300 @@ -39,6 +39,8 @@ typedef struct { } PyListObject; PyAPI_DATA(PyTypeObject) PyList_Type; +PyAPI_DATA(PyTypeObject) _PyListIter_Type; +PyAPI_DATA(PyTypeObject) _PyListRevIter_Type; #define PyList_Check(op) \ PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_LIST_SUBCLASS) diff -r 7050c9fc1f72 Include/rangeobject.h --- a/Include/rangeobject.h Wed May 04 11:28:09 2016 +0300 +++ b/Include/rangeobject.h Wed May 04 16:43:14 2016 +0300 @@ -19,6 +19,7 @@ they are represented by a start, stop, a */ PyAPI_DATA(PyTypeObject) PyRange_Type; +PyAPI_DATA(PyTypeObject) _PyRangeIter_Type; #define PyRange_Check(op) (Py_TYPE(op) == &PyRange_Type) diff -r 7050c9fc1f72 Include/setobject.h --- a/Include/setobject.h Wed May 04 11:28:09 2016 +0300 +++ b/Include/setobject.h Wed May 04 16:43:14 2016 +0300 @@ -58,6 +58,7 @@ struct _setobject { PyAPI_DATA(PyTypeObject) PySet_Type; PyAPI_DATA(PyTypeObject) PyFrozenSet_Type; +PyAPI_DATA(PyTypeObject) _PySetIter_Type; /* Invariants for frozensets: * data is immutable. diff -r 7050c9fc1f72 Include/tupleobject.h --- a/Include/tupleobject.h Wed May 04 11:28:09 2016 +0300 +++ b/Include/tupleobject.h Wed May 04 16:43:14 2016 +0300 @@ -32,6 +32,7 @@ typedef struct { } PyTupleObject; PyAPI_DATA(PyTypeObject) PyTuple_Type; +PyAPI_DATA(PyTypeObject) _PyTupleIter_Type; #define PyTuple_Check(op) \ PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_TUPLE_SUBCLASS) diff -r 7050c9fc1f72 Mac/Modules/MacOS.c --- a/Mac/Modules/MacOS.c Wed May 04 11:28:09 2016 +0300 +++ b/Mac/Modules/MacOS.c Wed May 04 16:43:14 2016 +0300 @@ -706,6 +706,8 @@ initMacOS(void) if (MacOS_Error == NULL || PyDict_SetItemString(d, "Error", MacOS_Error) != 0) return; Rftype.ob_type = &PyType_Type; + if (PyType_Ready(&Rftype) < 0) + return; Py_INCREF(&Rftype); if (PyDict_SetItemString(d, "ResourceForkType", (PyObject *)&Rftype) != 0) return; diff -r 7050c9fc1f72 Mac/Modules/scrap/_Scrapmodule.c --- a/Mac/Modules/scrap/_Scrapmodule.c Wed May 04 11:28:09 2016 +0300 +++ b/Mac/Modules/scrap/_Scrapmodule.c Wed May 04 16:43:14 2016 +0300 @@ -355,6 +355,8 @@ void init_Scrap(void) PyDict_SetItemString(d, "Error", Scrap_Error) != 0) return; Scrap_Type.ob_type = &PyType_Type; + if (PyType_Ready(&Scrap_Type) < 0) + return; Py_INCREF(&Scrap_Type); if (PyDict_SetItemString(d, "ScrapType", (PyObject *)&Scrap_Type) != 0) Py_FatalError("can't initialize ScrapType"); diff -r 7050c9fc1f72 Modules/_curses_panel.c --- a/Modules/_curses_panel.c Wed May 04 11:28:09 2016 +0300 +++ b/Modules/_curses_panel.c Wed May 04 16:43:14 2016 +0300 @@ -469,6 +469,8 @@ init_curses_panel(void) /* Initialize object type */ Py_TYPE(&PyCursesPanel_Type) = &PyType_Type; + if (PyType_Ready(&PyCursesPanel_Type) < 0) + return; import_curses(); diff -r 7050c9fc1f72 Modules/_cursesmodule.c --- a/Modules/_cursesmodule.c Wed May 04 11:28:09 2016 +0300 +++ b/Modules/_cursesmodule.c Wed May 04 16:43:14 2016 +0300 @@ -2738,6 +2738,8 @@ init_curses(void) /* Initialize object type */ Py_TYPE(&PyCursesWindow_Type) = &PyType_Type; + if (PyType_Ready(&PyCursesWindow_Type) < 0) + return; /* Initialize the C API pointer array */ PyCurses_API[0] = (void *)&PyCursesWindow_Type; diff -r 7050c9fc1f72 Modules/_elementtree.c --- a/Modules/_elementtree.c Wed May 04 11:28:09 2016 +0300 +++ b/Modules/_elementtree.c Wed May 04 16:43:14 2016 +0300 @@ -2877,8 +2877,12 @@ init_elementtree(void) /* Patch object type */ Py_TYPE(&Element_Type) = Py_TYPE(&TreeBuilder_Type) = &PyType_Type; + if (PyType_Ready(&Element_Type) < 0) + return; #if defined(USE_EXPAT) Py_TYPE(&XMLParser_Type) = &PyType_Type; + if (PyType_Ready(&XMLParser_Type) < 0) + return; #endif m = Py_InitModule("_elementtree", _functions); diff -r 7050c9fc1f72 Modules/_hotshot.c --- a/Modules/_hotshot.c Wed May 04 11:28:09 2016 +0300 +++ b/Modules/_hotshot.c Wed May 04 16:43:14 2016 +0300 @@ -1614,7 +1614,11 @@ init_hotshot(void) PyObject *module; Py_TYPE(&LogReaderType) = &PyType_Type; + if (PyType_Ready(&LogReaderType) < 0) + return; Py_TYPE(&ProfilerType) = &PyType_Type; + if (PyType_Ready(&ProfilerType) < 0) + return; module = Py_InitModule("_hotshot", functions); if (module != NULL) { char *s = get_version_string(); diff -r 7050c9fc1f72 Modules/_tkinter.c --- a/Modules/_tkinter.c Wed May 04 11:28:09 2016 +0300 +++ b/Modules/_tkinter.c Wed May 04 16:43:14 2016 +0300 @@ -3637,6 +3637,8 @@ init_tkinter(void) PyObject *m, *d; Py_TYPE(&Tkapp_Type) = &PyType_Type; + if (PyType_Ready(&Tkapp_Type) < 0) + return; #ifdef WITH_THREAD tcl_lock = PyThread_allocate_lock(); @@ -3665,9 +3667,13 @@ init_tkinter(void) PyDict_SetItemString(d, "TkappType", (PyObject *)&Tkapp_Type); Py_TYPE(&Tktt_Type) = &PyType_Type; + if (PyType_Ready(&Tktt_Type) < 0) + return; PyDict_SetItemString(d, "TkttType", (PyObject *)&Tktt_Type); Py_TYPE(&PyTclObject_Type) = &PyType_Type; + if (PyType_Ready(&PyTclObject_Type) < 0) + return; PyDict_SetItemString(d, "Tcl_Obj", (PyObject *)&PyTclObject_Type); #ifdef TK_AQUA diff -r 7050c9fc1f72 Modules/arraymodule.c --- a/Modules/arraymodule.c Wed May 04 11:28:09 2016 +0300 +++ b/Modules/arraymodule.c Wed May 04 16:43:14 2016 +0300 @@ -2267,7 +2267,11 @@ initarray(void) PyObject *m; Arraytype.ob_type = &PyType_Type; + if (PyType_Ready(&Arraytype) < 0) + return; PyArrayIter_Type.ob_type = &PyType_Type; + if (PyType_Ready(&PyArrayIter_Type) < 0) + return; m = Py_InitModule3("array", a_methods, module_doc); if (m == NULL) return; diff -r 7050c9fc1f72 Modules/bsddbmodule.c --- a/Modules/bsddbmodule.c Wed May 04 11:28:09 2016 +0300 +++ b/Modules/bsddbmodule.c Wed May 04 16:43:14 2016 +0300 @@ -854,6 +854,8 @@ initbsddb185(void) { return; Bsddbtype.ob_type = &PyType_Type; + if (PyType_Ready(&Bsddbtype) < 0) + return; m = Py_InitModule("bsddb185", bsddbmodule_methods); if (m == NULL) return; diff -r 7050c9fc1f72 Modules/cPickle.c --- a/Modules/cPickle.c Wed May 04 11:28:09 2016 +0300 +++ b/Modules/cPickle.c Wed May 04 16:43:14 2016 +0300 @@ -5896,6 +5896,8 @@ init_stuff(PyObject *module_dict) return -1; if (PyType_Ready(&Picklertype) < 0) return -1; + if (PyType_Ready(&PdataType) < 0) + return -1; INIT_STR(__class__); INIT_STR(__getinitargs__); diff -r 7050c9fc1f72 Modules/dbmmodule.c --- a/Modules/dbmmodule.c Wed May 04 11:28:09 2016 +0300 +++ b/Modules/dbmmodule.c Wed May 04 16:43:14 2016 +0300 @@ -403,6 +403,8 @@ initdbm(void) { PyObject *m, *d, *s; Dbmtype.ob_type = &PyType_Type; + if (PyType_Ready(&Dbmtype) < 0) + return; m = Py_InitModule("dbm", dbmmodule_methods); if (m == NULL) return; diff -r 7050c9fc1f72 Modules/dlmodule.c --- a/Modules/dlmodule.c Wed May 04 11:28:09 2016 +0300 +++ b/Modules/dlmodule.c Wed May 04 16:43:14 2016 +0300 @@ -244,6 +244,8 @@ initdl(void) /* Initialize object type */ Py_TYPE(&Dltype) = &PyType_Type; + if (PyType_Ready(&Dltype) < 0) + return; /* Create the module and add the functions */ m = Py_InitModule("dl", dl_methods); diff -r 7050c9fc1f72 Modules/gdbmmodule.c --- a/Modules/gdbmmodule.c Wed May 04 11:28:09 2016 +0300 +++ b/Modules/gdbmmodule.c Wed May 04 16:43:14 2016 +0300 @@ -532,6 +532,8 @@ initgdbm(void) { PyObject *m, *d, *s; Dbmtype.ob_type = &PyType_Type; + if (PyType_Ready(&Dbmtype) < 0) + return; m = Py_InitModule4("gdbm", dbmmodule_methods, gdbmmodule__doc__, (PyObject *)NULL, PYTHON_API_VERSION); diff -r 7050c9fc1f72 Modules/parsermodule.c --- a/Modules/parsermodule.c Wed May 04 11:28:09 2016 +0300 +++ b/Modules/parsermodule.c Wed May 04 16:43:14 2016 +0300 @@ -3433,6 +3433,8 @@ initparser(void) PyObject *module, *copyreg; Py_TYPE(&PyST_Type) = &PyType_Type; + if (PyType_Ready(&PyST_Type) < 0) + return; module = Py_InitModule("parser", parser_functions); if (module == NULL) return; diff -r 7050c9fc1f72 Modules/pyexpat.c --- a/Modules/pyexpat.c Wed May 04 11:28:09 2016 +0300 +++ b/Modules/pyexpat.c Wed May 04 16:43:14 2016 +0300 @@ -1852,6 +1852,8 @@ MODULE_INITFUNC(void) return; Py_TYPE(&Xmlparsetype) = &PyType_Type; + if (PyType_Ready(&Xmlparsetype) < 0) + return; /* Create the module and add the functions */ m = Py_InitModule3(MODULE_NAME, pyexpat_methods, diff -r 7050c9fc1f72 Modules/selectmodule.c --- a/Modules/selectmodule.c Wed May 04 11:28:09 2016 +0300 +++ b/Modules/selectmodule.c Wed May 04 16:43:14 2016 +0300 @@ -1830,6 +1830,8 @@ initselect(void) { #endif Py_TYPE(&poll_Type) = &PyType_Type; + if (PyType_Ready(&poll_Type) < 0) + return; PyModule_AddIntConstant(m, "POLLIN", POLLIN); PyModule_AddIntConstant(m, "POLLPRI", POLLPRI); PyModule_AddIntConstant(m, "POLLOUT", POLLOUT); diff -r 7050c9fc1f72 Modules/socketmodule.c --- a/Modules/socketmodule.c Wed May 04 11:28:09 2016 +0300 +++ b/Modules/socketmodule.c Wed May 04 16:43:14 2016 +0300 @@ -4604,6 +4604,8 @@ init_socket(void) return; Py_TYPE(&sock_type) = &PyType_Type; + if (PyType_Ready(&sock_type) < 0) + return; m = Py_InitModule3(PySocket_MODULE_NAME, socket_methods, socket_doc); diff -r 7050c9fc1f72 Modules/unicodedata.c --- a/Modules/unicodedata.c Wed May 04 11:28:09 2016 +0300 +++ b/Modules/unicodedata.c Wed May 04 16:43:14 2016 +0300 @@ -1258,6 +1258,8 @@ initunicodedata(void) PyObject *m, *v; Py_TYPE(&UCD_Type) = &PyType_Type; + if (PyType_Ready(&UCD_Type) < 0) + return; m = Py_InitModule3( "unicodedata", unicodedata_functions, unicodedata_docstring); diff -r 7050c9fc1f72 Modules/zlibmodule.c --- a/Modules/zlibmodule.c Wed May 04 11:28:09 2016 +0300 +++ b/Modules/zlibmodule.c Wed May 04 16:43:14 2016 +0300 @@ -1048,7 +1048,11 @@ PyInit_zlib(void) { PyObject *m, *ver; Py_TYPE(&Comptype) = &PyType_Type; + if (PyType_Ready(&Comptype) < 0) + return; Py_TYPE(&Decomptype) = &PyType_Type; + if (PyType_Ready(&Decomptype) < 0) + return; m = Py_InitModule4("zlib", zlib_methods, zlib_module_documentation, (PyObject*)NULL,PYTHON_API_VERSION); diff -r 7050c9fc1f72 Objects/descrobject.c --- a/Objects/descrobject.c Wed May 04 11:28:09 2016 +0300 +++ b/Objects/descrobject.c Wed May 04 16:43:14 2016 +0300 @@ -420,7 +420,7 @@ descr_traverse(PyObject *self, visitproc return 0; } -static PyTypeObject PyMethodDescr_Type = { +PyTypeObject _PyMethodDescr_Type = { PyVarObject_HEAD_INIT(&PyType_Type, 0) "method_descriptor", sizeof(PyMethodDescrObject), @@ -458,7 +458,7 @@ static PyTypeObject PyMethodDescr_Type = }; /* This is for METH_CLASS in C, not for "f = classmethod(f)" in Python! */ -static PyTypeObject PyClassMethodDescr_Type = { +PyTypeObject _PyClassMethodDescr_Type = { PyVarObject_HEAD_INIT(&PyType_Type, 0) "classmethod_descriptor", sizeof(PyMethodDescrObject), @@ -629,7 +629,7 @@ PyDescr_NewMethod(PyTypeObject *type, Py { PyMethodDescrObject *descr; - descr = (PyMethodDescrObject *)descr_new(&PyMethodDescr_Type, + descr = (PyMethodDescrObject *)descr_new(&_PyMethodDescr_Type, type, method->ml_name); if (descr != NULL) descr->d_method = method; @@ -641,7 +641,7 @@ PyDescr_NewClassMethod(PyTypeObject *typ { PyMethodDescrObject *descr; - descr = (PyMethodDescrObject *)descr_new(&PyClassMethodDescr_Type, + descr = (PyMethodDescrObject *)descr_new(&_PyClassMethodDescr_Type, type, method->ml_name); if (descr != NULL) descr->d_method = method; @@ -1053,7 +1053,7 @@ wrapper_traverse(PyObject *self, visitpr return 0; } -static PyTypeObject wrappertype = { +PyTypeObject _PyMethodWrapper_Type = { PyVarObject_HEAD_INIT(&PyType_Type, 0) "method-wrapper", /* tp_name */ sizeof(wrapperobject), /* tp_basicsize */ @@ -1102,7 +1102,7 @@ PyWrapper_New(PyObject *d, PyObject *sel assert(_PyObject_RealIsSubclass((PyObject *)Py_TYPE(self), (PyObject *)(descr->d_type))); - wp = PyObject_GC_New(wrapperobject, &wrappertype); + wp = PyObject_GC_New(wrapperobject, &_PyMethodWrapper_Type); if (wp != NULL) { Py_INCREF(descr); wp->descr = descr; diff -r 7050c9fc1f72 Objects/listobject.c --- a/Objects/listobject.c Wed May 04 11:28:09 2016 +0300 +++ b/Objects/listobject.c Wed May 04 16:43:14 2016 +0300 @@ -2828,7 +2828,7 @@ static PyMethodDef listiter_methods[] = {NULL, NULL} /* sentinel */ }; -PyTypeObject PyListIter_Type = { +PyTypeObject _PyListIter_Type = { PyVarObject_HEAD_INIT(&PyType_Type, 0) "listiterator", /* tp_name */ sizeof(listiterobject), /* tp_basicsize */ @@ -2871,7 +2871,7 @@ list_iter(PyObject *seq) PyErr_BadInternalCall(); return NULL; } - it = PyObject_GC_New(listiterobject, &PyListIter_Type); + it = PyObject_GC_New(listiterobject, &_PyListIter_Type); if (it == NULL) return NULL; it->it_index = 0; @@ -2950,7 +2950,7 @@ static PyMethodDef listreviter_methods[] {NULL, NULL} /* sentinel */ }; -PyTypeObject PyListRevIter_Type = { +PyTypeObject _PyListRevIter_Type = { PyVarObject_HEAD_INIT(&PyType_Type, 0) "listreverseiterator", /* tp_name */ sizeof(listreviterobject), /* tp_basicsize */ @@ -2988,7 +2988,7 @@ list_reversed(PyListObject *seq, PyObjec { listreviterobject *it; - it = PyObject_GC_New(listreviterobject, &PyListRevIter_Type); + it = PyObject_GC_New(listreviterobject, &_PyListRevIter_Type); if (it == NULL) return NULL; assert(PyList_Check(seq)); diff -r 7050c9fc1f72 Objects/object.c --- a/Objects/object.c Wed May 04 11:28:09 2016 +0300 +++ b/Objects/object.c Wed May 04 16:43:14 2016 +0300 @@ -2192,6 +2192,9 @@ void if (PyType_Ready(&PyWrapperDescr_Type) < 0) Py_FatalError("Can't initialize wrapper type"); + if (PyType_Ready(&_PyMethodWrapper_Type) < 0) + Py_FatalError("Can't initialize method wrapper type"); + if (PyType_Ready(&PyInstance_Type) < 0) Py_FatalError("Can't initialize instance type"); @@ -2210,11 +2213,44 @@ void if (PyType_Ready(&PyCell_Type) < 0) Py_FatalError("Can't initialize cell type"); + if (PyType_Ready(&_PyClassMethodDescr_Type) < 0) + Py_FatalError("Can't initialize class method descr type"); + + if (PyType_Ready(&_PyMethodDescr_Type) < 0) + Py_FatalError("Can't initialize method descr type"); + if (PyType_Ready(&PyCallIter_Type) < 0) Py_FatalError("Can't initialize call iter type"); if (PyType_Ready(&PySeqIter_Type) < 0) Py_FatalError("Can't initialize sequence iterator type"); + + if (PyType_Ready(&_PyListIter_Type) < 0) + Py_FatalError("Can't initialize list iterator type"); + + if (PyType_Ready(&_PyListRevIter_Type) < 0) + Py_FatalError("Can't initialize list reversed iterator type"); + + if (PyType_Ready(&_PyTupleIter_Type) < 0) + Py_FatalError("Can't initialize tuple iterator type"); + + if (PyType_Ready(&_PySetIter_Type) < 0) + Py_FatalError("Can't initialize set iterator type"); + + if (PyType_Ready(&_PyRangeIter_Type) < 0) + Py_FatalError("Can't initialize xrange iterator type"); + + if (PyType_Ready(&PyByteArrayIter_Type) < 0) + Py_FatalError("Can't initialize bytearray iterator type"); + + if (PyType_Ready(&PyDictIterKey_Type) < 0) + Py_FatalError("Can't initialize dict key iterator type"); + + if (PyType_Ready(&PyDictIterValue_Type) < 0) + Py_FatalError("Can't initialize dict value iterator type"); + + if (PyType_Ready(&PyDictIterItem_Type) < 0) + Py_FatalError("Can't initialize dict item iterator type"); } diff -r 7050c9fc1f72 Objects/rangeobject.c --- a/Objects/rangeobject.c Wed May 04 11:28:09 2016 +0300 +++ b/Objects/rangeobject.c Wed May 04 16:43:14 2016 +0300 @@ -255,7 +255,7 @@ static PyMethodDef rangeiter_methods[] = {NULL, NULL} /* sentinel */ }; -static PyTypeObject Pyrangeiter_Type = { +PyTypeObject _PyRangeIter_Type = { PyObject_HEAD_INIT(&PyType_Type) 0, /* ob_size */ "rangeiterator", /* tp_name */ @@ -298,7 +298,7 @@ range_iter(PyObject *seq) PyErr_BadInternalCall(); return NULL; } - it = PyObject_New(rangeiterobject, &Pyrangeiter_Type); + it = PyObject_New(rangeiterobject, &_PyRangeIter_Type); if (it == NULL) return NULL; it->index = 0; @@ -318,7 +318,8 @@ range_reverse(PyObject *seq) PyErr_BadInternalCall(); return NULL; } - it = PyObject_New(rangeiterobject, &Pyrangeiter_Type); + it = PyObject_New(rangeiterobject, &_PyRangeIter_Type + ); if (it == NULL) return NULL; diff -r 7050c9fc1f72 Objects/setobject.c --- a/Objects/setobject.c Wed May 04 11:28:09 2016 +0300 +++ b/Objects/setobject.c Wed May 04 16:43:14 2016 +0300 @@ -876,7 +876,7 @@ fail: return NULL; } -static PyTypeObject PySetIter_Type = { +PyTypeObject _PySetIter_Type = { PyVarObject_HEAD_INIT(&PyType_Type, 0) "setiterator", /* tp_name */ sizeof(setiterobject), /* tp_basicsize */ @@ -912,7 +912,7 @@ static PyTypeObject PySetIter_Type = { static PyObject * set_iter(PySetObject *so) { - setiterobject *si = PyObject_GC_New(setiterobject, &PySetIter_Type); + setiterobject *si = PyObject_GC_New(setiterobject, &_PySetIter_Type); if (si == NULL) return NULL; Py_INCREF(so); diff -r 7050c9fc1f72 Objects/tupleobject.c --- a/Objects/tupleobject.c Wed May 04 11:28:09 2016 +0300 +++ b/Objects/tupleobject.c Wed May 04 16:43:14 2016 +0300 @@ -987,7 +987,7 @@ static PyMethodDef tupleiter_methods[] = {NULL, NULL} /* sentinel */ }; -PyTypeObject PyTupleIter_Type = { +PyTypeObject _PyTupleIter_Type = { PyVarObject_HEAD_INIT(&PyType_Type, 0) "tupleiterator", /* tp_name */ sizeof(tupleiterobject), /* tp_basicsize */ @@ -1029,7 +1029,7 @@ tuple_iter(PyObject *seq) PyErr_BadInternalCall(); return NULL; } - it = PyObject_GC_New(tupleiterobject, &PyTupleIter_Type); + it = PyObject_GC_New(tupleiterobject, &_PyTupleIter_Type); if (it == NULL) return NULL; it->it_index = 0; diff -r 7050c9fc1f72 PC/_subprocess.c --- a/PC/_subprocess.c Wed May 04 11:28:09 2016 +0300 +++ b/PC/_subprocess.c Wed May 04 16:43:14 2016 +0300 @@ -653,6 +653,8 @@ init_subprocess() /* patch up object descriptors */ sp_handle_type.ob_type = &PyType_Type; sp_handle_as_number.nb_int = (unaryfunc) sp_handle_as_int; + if (PyType_Ready(&sp_handle_type) < 0) + return; m = Py_InitModule("_subprocess", sp_functions); if (m == NULL)