Convert get/set/size to PEP-384 style

jcpunk · jcpunk · commit 3e644c63c262 · 2020-10-16T14:20:41.000-05:00
diff --git a/include/boost/python/detail/caller.hpp b/include/boost/python/detail/caller.hpp
@@ -45,12 +45,12 @@ namespace boost { namespace python { namespace detail {
 template <int N>
 inline PyObject* get(mpl::int_<N>, PyObject* const& args_)
 {
-    return PyTuple_GET_ITEM(args_,N);
+    return PyTuple_GetItem(args_,N);
 }
 
 inline Py_ssize_t arity(PyObject* const& args_)
 {
-    return PyTuple_GET_SIZE(args_);
+    return PyTuple_Size(args_);
 }
 
 // This "result converter" is really just used as
diff --git a/include/boost/python/detail/make_tuple.hpp b/include/boost/python/detail/make_tuple.hpp
@@ -11,7 +11,7 @@
 #  define N BOOST_PP_ITERATION()
 
 #  define BOOST_PYTHON_MAKE_TUPLE_ARG(z, N, ignored)    \
-    PyTuple_SET_ITEM(                                   \
+    PyTuple_SetItem(                                    \
         result.ptr()                                    \
         , N                                             \
         , python::incref(python::object(a##N).ptr())    \
diff --git a/include/boost/python/enum.hpp b/include/boost/python/enum.hpp
@@ -80,9 +80,9 @@ template <class T>
 void enum_<T>::construct(PyObject* obj, converter::rvalue_from_python_stage1_data* data)
 {
 #if PY_VERSION_HEX >= 0x03000000
-    T x = static_cast<T>(PyLong_AS_LONG(obj));
+    T x = static_cast<T>(PyLong_AsLong(obj));
 #else
-    T x = static_cast<T>(PyInt_AS_LONG(obj));
+    T x = static_cast<T>(PyInt_AsLong(obj));
 #endif
     void* const storage = ((converter::rvalue_from_python_storage<T>*)data)->storage.bytes;
     new (storage) T(x);
diff --git a/src/converter/builtin_converters.cpp b/src/converter/builtin_converters.cpp
@@ -214,9 +214,9 @@ namespace
               return numeric_cast<T>(result);
           } else {
               // None of PyInt_AsUnsigned*() functions check for negative
-              // overflow, so use PyInt_AS_LONG instead and check if number is
+              // overflow, so use PyInt_AsLong instead and check if number is
               // negative, issuing the exception appropriately.
-              long result = PyInt_AS_LONG(intermediate);
+              long result = PyInt_AsLong(intermediate);
               if (PyErr_Occurred())
                   throw_error_already_set();
               if (result < 0) {
@@ -268,7 +268,7 @@ namespace
 #if PY_VERSION_HEX < 0x03000000
           if (PyInt_Check(intermediate))
           {
-              return PyInt_AS_LONG(intermediate);
+              return PyInt_AsLong(intermediate);
           }
           else
 #endif
@@ -290,7 +290,7 @@ namespace
 #if PY_VERSION_HEX < 0x03000000
           if (PyInt_Check(intermediate))
           {
-              return numeric_cast<unsigned BOOST_PYTHON_LONG_LONG>(PyInt_AS_LONG(intermediate));
+              return numeric_cast<unsigned BOOST_PYTHON_LONG_LONG>(PyInt_AsLong(intermediate));
           }
           else
 #endif
@@ -360,12 +360,12 @@ namespace
 #if PY_VERSION_HEX < 0x03000000
           if (PyInt_Check(intermediate))
           {
-              return PyInt_AS_LONG(intermediate);
+              return PyInt_AsLong(intermediate);
           }
           else
 #endif
           {
-              return PyFloat_AS_DOUBLE(intermediate);
+              return PyFloat_AsDouble(intermediate);
           }
       }
       static PyTypeObject const* get_pytype() { return &PyFloat_Type;}
@@ -493,12 +493,12 @@ namespace
 #if PY_VERSION_HEX < 0x03000000
           else if (PyInt_Check(intermediate))
           {
-              return PyInt_AS_LONG(intermediate);
+              return PyInt_AsLong(intermediate);
           }
 #endif
           else
           {
-              return PyFloat_AS_DOUBLE(intermediate);
+              return PyFloat_AsDouble(intermediate);
           }
       }
       static PyTypeObject const* get_pytype() { return &PyComplex_Type;}
diff --git a/src/object/class.cpp b/src/object/class.cpp
@@ -559,8 +559,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_SET_ITEM steals this reference
-          PyTuple_SET_ITEM(bases.get(), static_cast<ssize_t>(i - 1), upcast<PyObject>(c.release()));
+          // PyTuple_SetItem steals this reference
+          PyTuple_SetItem(bases.get(), static_cast<ssize_t>(i - 1), upcast<PyObject>(c.release()));
       }
 
       // Call the class metatype to create a new class
diff --git a/src/object/enum.cpp b/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_AS_LONG(self_));
+                PyString_FromFormat("%s.%s(%ld)", PyString_AsString(mod), self_->ob_type->tp_name, PyInt_AsLong(self_));
 #endif
         }
         else
diff --git a/src/object/function.cpp b/src/object/function.cpp
@@ -78,7 +78,7 @@ function::function(
         if (num_keywords != 0)
         {
             for (unsigned j = 0; j < keyword_offset; ++j)
-                PyTuple_SET_ITEM(m_arg_names.ptr(), j, incref(Py_None));
+                PyTuple_SetItem(m_arg_names.ptr(), j, incref(Py_None));
         }
         
         for (unsigned i = 0; i < num_keywords; ++i)
@@ -96,7 +96,7 @@ function::function(
                 kv = make_tuple(p->name);
             }
 
-            PyTuple_SET_ITEM(
+            PyTuple_SetItem(
                 m_arg_names.ptr()
                 , i + keyword_offset
                 , incref(kv.ptr())
@@ -122,7 +122,7 @@ function::~function()
 
 PyObject* function::call(PyObject* args, PyObject* keywords) const
 {
-    std::size_t n_unnamed_actual = PyTuple_GET_SIZE(args);
+    std::size_t n_unnamed_actual = PyTuple_Size(args);
     std::size_t n_keyword_actual = keywords ? PyDict_Size(keywords) : 0;
     std::size_t n_actual = n_unnamed_actual + n_keyword_actual;
     
@@ -167,28 +167,28 @@ PyObject* function::call(PyObject* args, PyObject* keywords) const
 
                         // Fill in the positional arguments
                         for (std::size_t i = 0; i < n_unnamed_actual; ++i)
-                            PyTuple_SET_ITEM(inner_args.get(), i, incref(PyTuple_GET_ITEM(args, i)));
+                            PyTuple_SetItem(inner_args.get(), i, incref(PyTuple_GetItem(args, i)));
 
                         // Grab remaining arguments by name from the keyword dictionary
                         std::size_t n_actual_processed = n_unnamed_actual;
                 
                         for (std::size_t arg_pos = n_unnamed_actual; arg_pos < max_arity ; ++arg_pos)
                         {
                             // Get the keyword[, value pair] corresponding
-                            PyObject* kv = PyTuple_GET_ITEM(f->m_arg_names.ptr(), arg_pos);
+                            PyObject* kv = PyTuple_GetItem(f->m_arg_names.ptr(), arg_pos);
 
                             // If there were any keyword arguments,
                             // look up the one we need for this
                             // argument position
                             PyObject* value = n_keyword_actual
-                                ? PyDict_GetItem(keywords, PyTuple_GET_ITEM(kv, 0))
+                                ? PyDict_GetItem(keywords, PyTuple_GetItem(kv, 0))
                                 : 0;
 
                             if (!value)
                             {
                                 // Not found; check if there's a default value
-                                if (PyTuple_GET_SIZE(kv) > 1)
-                                    value = PyTuple_GET_ITEM(kv, 1);
+                                if (PyTuple_Size(kv) > 1)
+                                    value = PyTuple_GetItem(kv, 1);
                         
                                 if (!value)
                                 {
@@ -203,7 +203,7 @@ PyObject* function::call(PyObject* args, PyObject* keywords) const
                                 ++n_actual_processed;
                             }
 
-                            PyTuple_SET_ITEM(inner_args.get(), arg_pos, incref(value));
+                            PyTuple_SetItem(inner_args.get(), arg_pos, incref(value));
                         }
 
                         if (inner_args.get())
diff --git a/src/object/iterator.cpp b/src/object/iterator.cpp
@@ -14,7 +14,7 @@ namespace
 {
   PyObject* identity(PyObject* args_, PyObject*)
   {
-      PyObject* x = PyTuple_GET_ITEM(args_,0);
+      PyObject* x = PyTuple_GetItem(args_,0);
       Py_INCREF(x);
       return x;
   }
diff --git a/src/object/life_support.cpp b/src/object/life_support.cpp
@@ -30,7 +30,7 @@ extern "C"
         Py_XDECREF(((life_support*)self)->patient);
         ((life_support*)self)->patient = 0;
         // Let the weak reference die. This probably kills us.
-        Py_XDECREF(PyTuple_GET_ITEM(arg, 0));
+        Py_XDECREF(PyTuple_GetItem(arg, 0));
         return ::boost::python::detail::none();
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -45,12 +45,12 @@ namespace boost { namespace python { namespace detail {`
`45`	`45`	`template <int N>`
`46`	`46`	`inline PyObject* get(mpl::int_<N>, PyObject* const& args_)`
`47`	`47`	`{`
`48`		`- return PyTuple_GET_ITEM(args_,N);`
	`48`	`+ return PyTuple_GetItem(args_,N);`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`inline Py_ssize_t arity(PyObject* const& args_)`
`52`	`52`	`{`
`53`		`- return PyTuple_GET_SIZE(args_);`
	`53`	`+ return PyTuple_Size(args_);`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`// This "result converter" is really just used as`
Original file line number	Diff line number	Diff line change
`@@ -214,9 +214,9 @@ namespace`
`214`	`214`	`return numeric_cast<T>(result);`
`215`	`215`	`} else {`
`216`	`216`	`// None of PyInt_AsUnsigned*() functions check for negative`
`217`		`- // overflow, so use PyInt_AS_LONG instead and check if number is`
	`217`	`+ // overflow, so use PyInt_AsLong instead and check if number is`
`218`	`218`	`// negative, issuing the exception appropriately.`
`219`		`- long result = PyInt_AS_LONG(intermediate);`
	`219`	`+ long result = PyInt_AsLong(intermediate);`
`220`	`220`	`if (PyErr_Occurred())`
`221`	`221`	`throw_error_already_set();`
`222`	`222`	`if (result < 0) {`
`@@ -268,7 +268,7 @@ namespace`
`268`	`268`	`#if PY_VERSION_HEX < 0x03000000`
`269`	`269`	`if (PyInt_Check(intermediate))`
`270`	`270`	`{`
`271`		`- return PyInt_AS_LONG(intermediate);`
	`271`	`+ return PyInt_AsLong(intermediate);`
`272`	`272`	`}`
`273`	`273`	`else`
`274`	`274`	`#endif`
`@@ -290,7 +290,7 @@ namespace`
`290`	`290`	`#if PY_VERSION_HEX < 0x03000000`
`291`	`291`	`if (PyInt_Check(intermediate))`
`292`	`292`	`{`
`293`		`- return numeric_cast<unsigned BOOST_PYTHON_LONG_LONG>(PyInt_AS_LONG(intermediate));`
	`293`	`+ return numeric_cast<unsigned BOOST_PYTHON_LONG_LONG>(PyInt_AsLong(intermediate));`
`294`	`294`	`}`
`295`	`295`	`else`
`296`	`296`	`#endif`
`@@ -360,12 +360,12 @@ namespace`
`360`	`360`	`#if PY_VERSION_HEX < 0x03000000`
`361`	`361`	`if (PyInt_Check(intermediate))`
`362`	`362`	`{`
`363`		`- return PyInt_AS_LONG(intermediate);`
	`363`	`+ return PyInt_AsLong(intermediate);`
`364`	`364`	`}`
`365`	`365`	`else`
`366`	`366`	`#endif`
`367`	`367`	`{`
`368`		`- return PyFloat_AS_DOUBLE(intermediate);`
	`368`	`+ return PyFloat_AsDouble(intermediate);`
`369`	`369`	`}`
`370`	`370`	`}`
`371`	`371`	`static PyTypeObject const* get_pytype() { return &PyFloat_Type;}`
`@@ -493,12 +493,12 @@ namespace`
`493`	`493`	`#if PY_VERSION_HEX < 0x03000000`
`494`	`494`	`else if (PyInt_Check(intermediate))`
`495`	`495`	`{`
`496`		`- return PyInt_AS_LONG(intermediate);`
	`496`	`+ return PyInt_AsLong(intermediate);`
`497`	`497`	`}`
`498`	`498`	`#endif`
`499`	`499`	`else`
`500`	`500`	`{`
`501`		`- return PyFloat_AS_DOUBLE(intermediate);`
	`501`	`+ return PyFloat_AsDouble(intermediate);`
`502`	`502`	`}`
`503`	`503`	`}`
`504`	`504`	`static PyTypeObject const* get_pytype() { return &PyComplex_Type;}`
Original file line number	Diff line number	Diff line change
`@@ -559,8 +559,8 @@ namespace objects`
`559`	`559`	`for (ssize_t i = 1; i <= num_bases; ++i)`
`560`	`560`	`{`
`561`	`561`	`type_handle c = (i >= static_cast<ssize_t>(num_types)) ? class_type() : get_class(types[i]);`
`562`		`- // PyTuple_SET_ITEM steals this reference`
`563`		`- PyTuple_SET_ITEM(bases.get(), static_cast<ssize_t>(i - 1), upcast<PyObject>(c.release()));`
	`562`	`+ // PyTuple_SetItem steals this reference`
	`563`	`+ PyTuple_SetItem(bases.get(), static_cast<ssize_t>(i - 1), upcast<PyObject>(c.release()));`
`564`	`564`	`}`
`565`	`565`
`566`	`566`	`// Call the class metatype to create a new class`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ extern "C"`
`52`	`52`	`#if PY_VERSION_HEX >= 0x03000000`
`53`	`53`	`PyUnicode_FromFormat("%S.%s(%ld)", mod, self_->ob_type->tp_name, PyLong_AsLong(self_));`
`54`	`54`	`#else`
`55`		`- PyString_FromFormat("%s.%s(%ld)", PyString_AsString(mod), self_->ob_type->tp_name, PyInt_AS_LONG(self_));`
	`55`	`+ PyString_FromFormat("%s.%s(%ld)", PyString_AsString(mod), self_->ob_type->tp_name, PyInt_AsLong(self_));`
`56`	`56`	`#endif`
`57`	`57`	`}`
`58`	`58`	`else`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ namespace`
`14`	`14`	`{`
`15`	`15`	`PyObject* identity(PyObject* args_, PyObject*)`
`16`	`16`	`{`
`17`		`- PyObject* x = PyTuple_GET_ITEM(args_,0);`
	`17`	`+ PyObject* x = PyTuple_GetItem(args_,0);`
`18`	`18`	`Py_INCREF(x);`
`19`	`19`	`return x;`
`20`	`20`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ extern "C"`
`30`	`30`	`Py_XDECREF(((life_support*)self)->patient);`
`31`	`31`	`((life_support*)self)->patient = 0;`
`32`	`32`	`// Let the weak reference die. This probably kills us.`
`33`		`- Py_XDECREF(PyTuple_GET_ITEM(arg, 0));`
	`33`	`+ Py_XDECREF(PyTuple_GetItem(arg, 0));`
`34`	`34`	`return ::boost::python::detail::none();`
`35`	`35`	`}`
`36`	`36`	`}`