From d4d400cb8a87a0960936d644a750f896a73c46d6 Mon Sep 17 00:00:00 2001 From: Benjamin Peterson Date: Sat, 18 Apr 2009 20:12:47 +0000 Subject: [PATCH] try to initalize all builtin types with PyType_Ready to avoid problems like #5787 --- Lib/test/test_descr.py | 12 +++++++ Misc/NEWS | 3 ++ Objects/frameobject.c | 8 ----- Objects/object.c | 76 +++++++++++++++++++++++++++++++++++++----- 4 files changed, 83 insertions(+), 16 deletions(-) diff --git a/Lib/test/test_descr.py b/Lib/test/test_descr.py index aa5bde42ab9..b5c767c6bfe 100644 --- a/Lib/test/test_descr.py +++ b/Lib/test/test_descr.py @@ -1,3 +1,4 @@ +import __builtin__ import types import unittest import warnings @@ -3895,6 +3896,17 @@ order (MRO) for bases """ else: self.fail("new-style class must have a new-style base") + def test_builtin_bases(self): + # Make sure all the builtin types can have their base queried without + # segfaulting. See issue #5787. + builtin_types = [tp for tp in __builtin__.__dict__.itervalues() + if isinstance(tp, type)] + for tp in builtin_types: + object.__getattribute__(tp, "__bases__") + if tp is not object: + self.assertEqual(len(tp.__bases__), 1, tp) + + def test_mutable_bases_with_failing_mro(self): # Testing mutable bases with failing mro... class WorkOnce(type): diff --git a/Misc/NEWS b/Misc/NEWS index 58197de0490..c2a07ece766 100644 --- a/Misc/NEWS +++ b/Misc/NEWS @@ -12,6 +12,9 @@ What's New in Python 2.7 alpha 1 Core and Builtins ----------------- +- Issue #5787: object.__getattribute__(some_type, "__bases__") segfaulted on + some builtin types. + - Issue #1869: fix a couple of minor round() issues. round(5e15+1) was giving 5e15+2; round(-0.0) was losing the sign of the zero. diff --git a/Objects/frameobject.c b/Objects/frameobject.c index c8cf71b34c0..4ac1ab02ddf 100644 --- a/Objects/frameobject.c +++ b/Objects/frameobject.c @@ -606,14 +606,6 @@ int _PyFrame_Init() builtin_object = PyString_InternFromString("__builtins__"); if (builtin_object == NULL) return 0; - /* - Traceback objects are not created the normal way (through calling the - type), so PyType_Ready has to be called here. - */ - if (PyType_Ready(&PyTraceBack_Type)) { - Py_DECREF(builtin_object); - return 0; - } return 1; } diff --git a/Objects/object.c b/Objects/object.c index 7395b0c2f77..b8f13521988 100644 --- a/Objects/object.c +++ b/Objects/object.c @@ -2033,28 +2033,88 @@ void _Py_ReadyTypes(void) { if (PyType_Ready(&PyType_Type) < 0) - Py_FatalError("Can't initialize 'type'"); + Py_FatalError("Can't initialize type type"); if (PyType_Ready(&_PyWeakref_RefType) < 0) - Py_FatalError("Can't initialize 'weakref'"); + Py_FatalError("Can't initialize weakref type"); if (PyType_Ready(&PyBool_Type) < 0) - Py_FatalError("Can't initialize 'bool'"); + Py_FatalError("Can't initialize bool type"); if (PyType_Ready(&PyString_Type) < 0) - Py_FatalError("Can't initialize 'str'"); + Py_FatalError("Can't initialize str type"); if (PyType_Ready(&PyByteArray_Type) < 0) - Py_FatalError("Can't initialize 'bytes'"); + Py_FatalError("Can't initialize bytearray"); if (PyType_Ready(&PyList_Type) < 0) - Py_FatalError("Can't initialize 'list'"); + Py_FatalError("Can't initialize list"); if (PyType_Ready(&PyNone_Type) < 0) - Py_FatalError("Can't initialize type(None)"); + Py_FatalError("Can't initialize None type"); if (PyType_Ready(&PyNotImplemented_Type) < 0) - Py_FatalError("Can't initialize type(NotImplemented)"); + Py_FatalError("Can't initialize NotImplemented type"); + + if (PyType_Ready(&PyTraceBack_Type) < 0) + Py_FatalError("Can't initialize traceback type"); + + if (PyType_Ready(&PySuper_Type) < 0) + Py_FatalError("Can't initialize super type"); + + if (PyType_Ready(&PyBaseObject_Type) < 0) + Py_FatalError("Can't initialize object type"); + + if (PyType_Ready(&PyRange_Type) < 0) + Py_FatalError("Can't initialize xrange type"); + + if (PyType_Ready(&PyDict_Type) < 0) + Py_FatalError("Can't initialize dict type"); + + if (PyType_Ready(&PySet_Type) < 0) + Py_FatalError("Can't initialize set type"); + + if (PyType_Ready(&PyUnicode_Type) < 0) + Py_FatalError("Can't initialize unicode type"); + + if (PyType_Ready(&PySlice_Type) < 0) + Py_FatalError("Can't initialize slice type"); + + if (PyType_Ready(&PyStaticMethod_Type) < 0) + Py_FatalError("Can't initialize static method type"); + + if (PyType_Ready(&PyComplex_Type) < 0) + Py_FatalError("Can't initalize complex type"); + + if (PyType_Ready(&PyFloat_Type) < 0) + Py_FatalError("Can't initalize float type"); + + if (PyType_Ready(&PyBuffer_Type) < 0) + Py_FatalError("Can't initialize buffer type"); + + if (PyType_Ready(&PyLong_Type) < 0) + Py_FatalError("Can't initialize long type"); + + if (PyType_Ready(&PyInt_Type) < 0) + Py_FatalError("Can't initialize int type"); + + if (PyType_Ready(&PyFrozenSet_Type) < 0) + Py_FatalError("Can't initialize frozenset type"); + + if (PyType_Ready(&PyProperty_Type) < 0) + Py_FatalError("Can't initialize property type"); + + if (PyType_Ready(&PyMemoryView_Type) < 0) + Py_FatalError("Can't initialize memoryview type"); + + if (PyType_Ready(&PyTuple_Type) < 0) + Py_FatalError("Can't initalize tuple type"); + + if (PyType_Ready(&PyEnum_Type) < 0) + Py_FatalError("Can't initalize enumerate type"); + + if (PyType_Ready(&PyReversed_Type) < 0) + Py_FatalError("Can't initalize reversed type"); }