Move away from static types.

Author: knoepfel

src/object/class.cpp

@@ -141,16 +141,20 @@ extern "C"
   }
 }
 
-static PyTypeObject static_data_object = {
-    PyVarObject_HEAD_INIT(NULL, 0)
-    .tp_name = const_cast<char*>("Boost.Python.StaticProperty"),
-    .tp_basicsize = sizeof(propertyobject),
-    .tp_flags = Py_TPFLAGS_DEFAULT // | Py_TPFLAGS_HAVE_GC
-    | Py_TPFLAGS_BASETYPE,          /* tp_flags */
-    .tp_descr_get = static_data_descr_get,
-    .tp_descr_set = static_data_descr_set,
-    .tp_init = property_init,
+static PyType_Slot static_data_object_slots[] = {
+  {Py_tp_descr_get, (void*)static_data_descr_get},
+  {Py_tp_descr_set, (void*)static_data_descr_set},
+  {Py_tp_init, (void*)property_init},
 };
+static PyType_Spec static_data_object_spec = {
+    const_cast<char*>("Boost.Python.StaticProperty"),
+    sizeof(propertyobject),
+    0,
+    Py_TPFLAGS_DEFAULT // | Py_TPFLAGS_HAVE_GC
+  | Py_TPFLAGS_BASETYPE,
+  static_data_object_slots,
+};
+
 
 namespace objects
 {
@@ -165,14 +169,16 @@ namespace objects
 
   BOOST_PYTHON_DECL PyObject* static_data()
   {
-      if (static_data_object.tp_dict == 0)
+
+    PyTypeObject* not_static_data_object = (PyTypeObject*)PyType_FromSpec(&static_data_object_spec);
+    if (not_static_data_object->tp_dict == 0)
       {
-          Py_TYPE(&static_data_object) = &PyType_Type;
-          static_data_object.tp_base = &PyProperty_Type;
-          if (PyType_Ready(&static_data_object))
+          Py_TYPE(not_static_data_object) = &PyType_Type;
+          not_static_data_object->tp_base = &PyProperty_Type;
+          if (PyType_Ready(not_static_data_object))
               return 0;
       }
-      return upcast<PyObject>(&static_data_object);
+      return upcast<PyObject>(not_static_data_object);
   }
 }  
 
@@ -206,21 +212,26 @@ extern "C"
     }
 }
 
-static PyTypeObject class_metatype_object = {
-    PyVarObject_HEAD_INIT(NULL, 0)
-    .tp_name = const_cast<char*>("Boost.Python.class"),
-    .tp_basicsize = PyType_Type.tp_basicsize,
-    .tp_setattro = class_setattro,
-    .tp_flags = Py_TPFLAGS_DEFAULT // | Py_TPFLAGS_HAVE_GC
-    | Py_TPFLAGS_BASETYPE,          /* tp_flags */
-    .tp_is_gc = (inquiry)type_is_gc,
+static PyType_Slot class_metatype_object_slots[] = {
+  {Py_tp_setattro, (void*)class_setattro},
+  {Py_tp_is_gc, (void*)type_is_gc},
+};
+static PyType_Spec class_metatype_object_spec = {
+    const_cast<char*>("Boost.Python.class"),
+    PyType_Type.tp_basicsize,
+    0,
+    Py_TPFLAGS_DEFAULT // | Py_TPFLAGS_HAVE_GC
+    | Py_TPFLAGS_BASETYPE,
+  class_metatype_object_slots,
 };
 
+
 // Install the instance data for a C++ object into a Python instance
 // object.
 void instance_holder::install(PyObject* self) throw()
 {
-    assert(PyType_IsSubtype(Py_TYPE(Py_TYPE(self)), &class_metatype_object));
+    PyTypeObject* class_metatype_object = (PyTypeObject*)PyType_FromSpec(&class_metatype_object_spec);
+    assert(PyType_IsSubtype(Py_TYPE(Py_TYPE(self)), class_metatype_object));
     m_next = ((objects::instance<>*)self)->objects;
     ((objects::instance<>*)self)->objects = this;
 }
@@ -231,14 +242,15 @@ namespace objects
 // Get the metatype object for all extension classes.
   BOOST_PYTHON_DECL type_handle class_metatype()
   {
-      if (class_metatype_object.tp_dict == 0)
+      PyTypeObject* class_metatype_object = (PyTypeObject*)PyType_FromSpec(&class_metatype_object_spec);
+      if (class_metatype_object->tp_dict == 0)
       {
-          Py_TYPE(&class_metatype_object) = &PyType_Type;
-          class_metatype_object.tp_base = &PyType_Type;
-          if (PyType_Ready(&class_metatype_object))
+          Py_TYPE(class_metatype_object) = &PyType_Type;
+          class_metatype_object->tp_base = &PyType_Type;
+          if (PyType_Ready(class_metatype_object))
               return type_handle();
       }
-      return type_handle(borrowed(&class_metatype_object));
+      return type_handle(borrowed(class_metatype_object));
   }
   extern "C"
   {
@@ -331,40 +343,45 @@ namespace objects
       {0, 0, 0, 0, 0}
   };
 
-  static PyTypeObject class_type_object = {
-      PyVarObject_HEAD_INIT(NULL, 0)
-      .tp_name = const_cast<char*>("Boost.Python.instance"),
-      .tp_basicsize =offsetof(instance<>,storage),
-      .tp_itemsize = 1,
-      .tp_dealloc = instance_dealloc,
-      .tp_flags = Py_TPFLAGS_DEFAULT // | Py_TPFLAGS_HAVE_GC
-      | Py_TPFLAGS_BASETYPE,          /* tp_flags */
-      .tp_weaklistoffset =offsetof(instance<>,weakrefs),
-      .tp_members = instance_members,
-      .tp_getset = instance_getsets,
-      .tp_dictoffset = offsetof(instance<>,dict),
-      .tp_alloc = PyType_GenericAlloc,
-      .tp_new = instance_new,
+  static PyType_Slot class_type_object_slots[] = {
+    {Py_tp_dealloc, (void*)instance_dealloc},
+    {Py_tp_members, instance_members},
+    {Py_tp_getset, instance_getsets},
+    {Py_tp_alloc, (void*)PyType_GenericAlloc},
+    {Py_tp_new, (void*)instance_new},
+  };
+  static PyType_Spec class_type_object_spec = {
+      const_cast<char*>("Boost.Python.instance"),
+    offsetof(instance<>,storage),
+    1,
+      Py_TPFLAGS_DEFAULT // | Py_TPFLAGS_HAVE_GC
+      | Py_TPFLAGS_BASETYPE,
+    class_type_object_slots,
   };
 
+
   BOOST_PYTHON_DECL type_handle class_type()
   {
-      if (class_type_object.tp_dict == 0)
+      PyTypeObject* class_type_object = (PyTypeObject*)PyType_FromSpec(&class_type_object_spec);
+      class_type_object->tp_weaklistoffset = offsetof(instance<>,weakrefs);
+      class_type_object->tp_dictoffset = offsetof(instance<>,dict);
+      if (class_type_object->tp_dict == 0)
       {
           Py_TYPE(&class_type_object) = incref(class_metatype().get());
-          class_type_object.tp_base = &PyBaseObject_Type;
-          if (PyType_Ready(&class_type_object))
+          class_type_object->tp_base = &PyBaseObject_Type;
+          if (PyType_Ready(class_type_object))
               return type_handle();
-//          class_type_object.tp_setattro = class_setattro;
+//          class_type_object->tp_setattro = class_setattro;
       }
-      return type_handle(borrowed(&class_type_object));
+      return type_handle(borrowed(class_type_object));
   }
 
   BOOST_PYTHON_DECL void*
   find_instance_impl(PyObject* inst, type_info type, bool null_shared_ptr_only)
   {
+      PyTypeObject* class_metatype_object = (PyTypeObject*)PyType_FromSpec(&class_metatype_object_spec);
       if (!Py_TYPE(Py_TYPE(inst)) ||
-              !PyType_IsSubtype(Py_TYPE(Py_TYPE(inst)), &class_metatype_object))
+              !PyType_IsSubtype(Py_TYPE(Py_TYPE(inst)), class_metatype_object))
           return 0;
 
       instance<>* self = reinterpret_cast<instance<>*>(inst);
@@ -440,8 +457,8 @@ namespace objects
       for (ssize_t i = 1; i <= num_bases; ++i)
       {
           type_handle c = (i >= static_cast<ssize_t>(num_types)) ? class_type() : get_class(types[i]);
-          // PyTuple_SetItem steals this reference
-          PyTuple_SetItem(bases.get(), static_cast<ssize_t>(i - 1), upcast<PyObject>(c.release()));
+          // PyTuple_SET_ITEM steals this reference
+          PyTuple_SET_ITEM(bases.get(), static_cast<ssize_t>(i - 1), upcast<PyObject>(c.release()));
       }
 
       // Call the class metatype to create a new class
@@ -609,7 +626,8 @@ namespace objects
 
 void* instance_holder::allocate(PyObject* self_, std::size_t holder_offset, std::size_t holder_size)
 {
-    assert(PyType_IsSubtype(Py_TYPE(Py_TYPE(self_)), &class_metatype_object));
+    assert(PyType_IsSubtype(Py_TYPE(Py_TYPE(self_)),
+                            (PyTypeObject*)PyType_FromSpec(&class_metatype_object_spec)));
     objects::instance<>* self = (objects::instance<>*)self_;
 
     int total_size_needed = holder_offset + holder_size;
@@ -634,7 +652,8 @@ void* instance_holder::allocate(PyObject* self_, std::size_t holder_offset, std:
 
 void instance_holder::deallocate(PyObject* self_, void* storage) throw()
 {
-    assert(PyType_IsSubtype(Py_TYPE(Py_TYPE(self_)), &class_metatype_object));
+    assert(PyType_IsSubtype(Py_TYPE(Py_TYPE(self_)),
+                            (PyTypeObject*)PyType_FromSpec(&class_metatype_object_spec)));
     objects::instance<>* self = (objects::instance<>*)self_;
     if (storage != (char*)self + Py_SIZE(self))
     {

src/object/enum.cpp

@@ -52,7 +52,7 @@ extern "C"
 #if PY_VERSION_HEX >= 0x03000000
                 PyUnicode_FromFormat("%S.%s(%ld)", mod, self_->ob_type->tp_name, PyLong_AsLong(self_));
 #else
-                PyString_FromFormat("%s.%s(%ld)", PyString_AsString(mod), self_->ob_type->tp_name, PyInt_AsLong(self_));
+                PyString_FromFormat("%s.%s(%ld)", PyString_AsString(mod), self_->ob_type->tp_name, PyInt_AS_LONG(self_));
 #endif
         }
         else
@@ -89,43 +89,47 @@ extern "C"
     }
 }
 
-static PyTypeObject enum_type_object = {
-    PyVarObject_HEAD_INIT(NULL, 0) // &PyType_Type
-    .tp_name = const_cast<char*>("Boost.Python.enum"),
-    .tp_basicsize = sizeof(enum_object),
-    .tp_dealloc = (destructor) enum_dealloc,
-    .tp_repr = enum_repr,
-    .tp_str = enum_str,
-    .tp_flags =
+static PyType_Slot enum_type_object_slots[] = {
+    {Py_tp_dealloc, (void*) enum_dealloc},
+    {Py_tp_repr, (void*) enum_repr},
+    {Py_tp_str, (void*) enum_str},
+    {Py_tp_members, (void*) enum_members},
+};
+static PyType_Spec enum_type_object_spec = {
+    const_cast<char*>("Boost.Python.enum"),
+    sizeof(enum_object),
+    0,
     Py_TPFLAGS_DEFAULT
 #if PY_VERSION_HEX < 0x03000000
     | Py_TPFLAGS_CHECKTYPES
 #endif
     | Py_TPFLAGS_HAVE_GC
-    | Py_TPFLAGS_BASETYPE,                  /* tp_flags */
-    .tp_members = enum_members,
+    | Py_TPFLAGS_BASETYPE,
+    enum_type_object_slots,
 };
 
+
 object module_prefix();
 
 namespace
 {
   object new_enum_type(char const* name, char const *doc)
   {
-      if (enum_type_object.tp_dict == 0)
+      PyTypeObject* enum_type_object = (PyTypeObject*)PyType_FromSpec(&enum_type_object_spec);
+      if (enum_type_object->tp_dict == 0)
       {
-          Py_TYPE(&enum_type_object) = incref(&PyType_Type);
+          Py_TYPE(enum_type_object) = incref(&PyType_Type);
 #if PY_VERSION_HEX >= 0x03000000
-          enum_type_object.tp_base = &PyLong_Type;
+          enum_type_object->tp_base = &PyLong_Type;
 #else
-          enum_type_object.tp_base = &PyInt_Type;
+          enum_type_object->tp_base = &PyInt_Type;
 #endif
-          if (PyType_Ready(&enum_type_object))
+          if (PyType_Ready(enum_type_object))
               throw_error_already_set();
       }
 
       type_handle metatype(borrowed(&PyType_Type));
-      type_handle base(borrowed(&enum_type_object));
+      type_handle base(borrowed(enum_type_object));
 
       // suppress the instance __dict__ in these enum objects. There
       // may be a slicker way, but this'll do for now.