Fix Python 3.10 (PEP-620) incompatibility.

stefanseefeld · stefanseefeld · commit 500194edb783 · 2021-01-04T01:31:40.000-05:00
diff --git a/include/boost/python/detail/wrap_python.hpp b/include/boost/python/detail/wrap_python.hpp
@@ -227,7 +227,11 @@ typedef int pid_t;
 
 # define PyVarObject_HEAD_INIT(type, size) \
         PyObject_HEAD_INIT(type) size,
+#endif
 
+#if PY_VERSION_HEX < 0x030900A4
+#  define Py_SET_TYPE(obj, type) ((Py_TYPE(obj) = (type)), (void)0)
+#  define Py_SET_SIZE(obj, size) ((Py_SIZE(obj) = (size)), (void)0)
 #endif
 
 
diff --git a/include/boost/python/object/make_instance.hpp b/include/boost/python/object/make_instance.hpp
@@ -47,7 +47,7 @@ struct make_instance_impl
               
             // Note the position of the internally-stored Holder,
             // for the sake of destruction
-            Py_SIZE(instance) = offsetof(instance_t, storage);
+            Py_SET_SIZE(instance, offsetof(instance_t, storage));
 
             // Release ownership of the python object
             protect.cancel();
diff --git a/src/object/class.cpp b/src/object/class.cpp
@@ -208,7 +208,7 @@ namespace objects
   {
       if (static_data_object.tp_dict == 0)
       {
-          Py_TYPE(&static_data_object) = &PyType_Type;
+          Py_SET_TYPE(&static_data_object, &PyType_Type);
           static_data_object.tp_base = &PyProperty_Type;
           if (PyType_Ready(&static_data_object))
               return 0;
@@ -316,7 +316,7 @@ namespace objects
   {
       if (class_metatype_object.tp_dict == 0)
       {
-          Py_TYPE(&class_metatype_object) = &PyType_Type;
+          Py_SET_TYPE(&class_metatype_object, &PyType_Type);
           class_metatype_object.tp_base = &PyType_Type;
           if (PyType_Ready(&class_metatype_object))
               return type_handle();
@@ -374,12 +374,7 @@ namespace objects
               // like, so we'll store the total size of the object
               // there. A negative number indicates that the extra
               // instance memory is not yet allocated to any holders.
-#if PY_VERSION_HEX >= 0x02060000
-              Py_SIZE(result) =
-#else
-              result->ob_size =
-#endif
-                  -(static_cast<int>(offsetof(instance<>,storage) + instance_size));
+              Py_SET_SIZE(result,-static_cast<int>(offsetof(instance<>,storage) + instance_size));
           }
           return (PyObject*)result;
       }
@@ -470,7 +465,7 @@ namespace objects
   {
       if (class_type_object.tp_dict == 0)
       {
-          Py_TYPE(&class_type_object) = incref(class_metatype().get());
+          Py_SET_TYPE(&class_type_object, incref(class_metatype().get()));
           class_type_object.tp_base = &PyBaseObject_Type;
           if (PyType_Ready(&class_type_object))
               return type_handle();
@@ -739,7 +734,7 @@ void* instance_holder::allocate(PyObject* self_, std::size_t holder_offset, std:
         assert(holder_offset >= offsetof(objects::instance<>,storage));
 
         // Record the fact that the storage is occupied, noting where it starts
-        Py_SIZE(self) = holder_offset;
+        Py_SET_SIZE(self, holder_offset);
         return (char*)self + holder_offset;
     }
     else
diff --git a/src/object/enum.cpp b/src/object/enum.cpp
@@ -153,7 +153,7 @@ namespace
   {
       if (enum_type_object.tp_dict == 0)
       {
-          Py_TYPE(&enum_type_object) = incref(&PyType_Type);
+          Py_SET_TYPE(&enum_type_object, incref(&PyType_Type));
 #if PY_VERSION_HEX >= 0x03000000
           enum_type_object.tp_base = &PyLong_Type;
 #else
diff --git a/src/object/function.cpp b/src/object/function.cpp
@@ -107,7 +107,7 @@ function::function(
     PyObject* p = this;
     if (Py_TYPE(&function_type) == 0)
     {
-        Py_TYPE(&function_type) = &PyType_Type;
+        Py_SET_TYPE(&function_type, &PyType_Type);
         ::PyType_Ready(&function_type);
     }
     
diff --git a/src/object/life_support.cpp b/src/object/life_support.cpp
@@ -93,7 +93,7 @@ PyObject* make_nurse_and_patient(PyObject* nurse, PyObject* patient)
     
     if (Py_TYPE(&life_support_type) == 0)
     {
-        Py_TYPE(&life_support_type) = &PyType_Type;
+        Py_SET_TYPE(&life_support_type, &PyType_Type);
         PyType_Ready(&life_support_type);
     }
     

Original file line number	Diff line number	Diff line change
`@@ -208,7 +208,7 @@ namespace objects`
`208`	`208`	`{`
`209`	`209`	`if (static_data_object.tp_dict == 0)`
`210`	`210`	`{`
`211`		`- Py_TYPE(&static_data_object) = &PyType_Type;`
	`211`	`+ Py_SET_TYPE(&static_data_object, &PyType_Type);`
`212`	`212`	`static_data_object.tp_base = &PyProperty_Type;`
`213`	`213`	`if (PyType_Ready(&static_data_object))`
`214`	`214`	`return 0;`
`@@ -316,7 +316,7 @@ namespace objects`
`316`	`316`	`{`
`317`	`317`	`if (class_metatype_object.tp_dict == 0)`
`318`	`318`	`{`
`319`		`- Py_TYPE(&class_metatype_object) = &PyType_Type;`
	`319`	`+ Py_SET_TYPE(&class_metatype_object, &PyType_Type);`
`320`	`320`	`class_metatype_object.tp_base = &PyType_Type;`
`321`	`321`	`if (PyType_Ready(&class_metatype_object))`
`322`	`322`	`return type_handle();`
`@@ -374,12 +374,7 @@ namespace objects`
`374`	`374`	`// like, so we'll store the total size of the object`
`375`	`375`	`// there. A negative number indicates that the extra`
`376`	`376`	`// instance memory is not yet allocated to any holders.`
`377`		`-#if PY_VERSION_HEX >= 0x02060000`
`378`		`- Py_SIZE(result) =`
`379`		`-#else`
`380`		`- result->ob_size =`
`381`		`-#endif`
`382`		`- -(static_cast<int>(offsetof(instance<>,storage) + instance_size));`
	`377`	`+ Py_SET_SIZE(result,-static_cast<int>(offsetof(instance<>,storage) + instance_size));`
`383`	`378`	`}`
`384`	`379`	`return (PyObject*)result;`
`385`	`380`	`}`
`@@ -470,7 +465,7 @@ namespace objects`
`470`	`465`	`{`
`471`	`466`	`if (class_type_object.tp_dict == 0)`
`472`	`467`	`{`
`473`		`- Py_TYPE(&class_type_object) = incref(class_metatype().get());`
	`468`	`+ Py_SET_TYPE(&class_type_object, incref(class_metatype().get()));`
`474`	`469`	`class_type_object.tp_base = &PyBaseObject_Type;`
`475`	`470`	`if (PyType_Ready(&class_type_object))`
`476`	`471`	`return type_handle();`
`@@ -739,7 +734,7 @@ void* instance_holder::allocate(PyObject* self_, std::size_t holder_offset, std:`
`739`	`734`	`assert(holder_offset >= offsetof(objects::instance<>,storage));`
`740`	`735`
`741`	`736`	`// Record the fact that the storage is occupied, noting where it starts`
`742`		`- Py_SIZE(self) = holder_offset;`
	`737`	`+ Py_SET_SIZE(self, holder_offset);`
`743`	`738`	`return (char*)self + holder_offset;`
`744`	`739`	`}`
`745`	`740`	`else`
Original file line number	Diff line number	Diff line change
`@@ -153,7 +153,7 @@ namespace`
`153`	`153`	`{`
`154`	`154`	`if (enum_type_object.tp_dict == 0)`
`155`	`155`	`{`
`156`		`- Py_TYPE(&enum_type_object) = incref(&PyType_Type);`
	`156`	`+ Py_SET_TYPE(&enum_type_object, incref(&PyType_Type));`
`157`	`157`	`#if PY_VERSION_HEX >= 0x03000000`
`158`	`158`	`enum_type_object.tp_base = &PyLong_Type;`
`159`	`159`	`#else`
Original file line number	Diff line number	Diff line change
`@@ -107,7 +107,7 @@ function::function(`
`107`	`107`	`PyObject* p = this;`
`108`	`108`	`if (Py_TYPE(&function_type) == 0)`
`109`	`109`	`{`
`110`		`- Py_TYPE(&function_type) = &PyType_Type;`
	`110`	`+ Py_SET_TYPE(&function_type, &PyType_Type);`
`111`	`111`	`::PyType_Ready(&function_type);`
`112`	`112`	`}`
`113`	`113`
Original file line number	Diff line number	Diff line change
`@@ -93,7 +93,7 @@ PyObject* make_nurse_and_patient(PyObject* nurse, PyObject* patient)`
`93`	`93`
`94`	`94`	`if (Py_TYPE(&life_support_type) == 0)`
`95`	`95`	`{`
`96`		`- Py_TYPE(&life_support_type) = &PyType_Type;`
	`96`	`+ Py_SET_TYPE(&life_support_type, &PyType_Type);`
`97`	`97`	`PyType_Ready(&life_support_type);`
`98`	`98`	`}`
`99`	`99`