Merge 'origin/develop' into ft_fixes

nascheme · nascheme · commit bf7916250e8f · 2025-11-06T16:05:50.000-08:00
diff --git a/.github/workflows/test-ubuntu.yml b/.github/workflows/test-ubuntu.yml
@@ -11,23 +11,27 @@ jobs:
       matrix:
         python: [python, python3]
         cxx: [g++, clang++]
-        std: [c++98, c++11, c++14, c++17]
+        std: [c++11, c++14, c++17]
         include:
           # Add the appropriate docker image for each compiler.
           # The images from teeks99/boost-python-test already have boost::python
           # pre-reqs installed, see:
           # https://github.com/teeks99/boost-python-test-docker
           - cxx: clang++
-            docker-img: teeks99/boost-python-test:clang-12_1.76.0
+            docker-img: teeks99/boost-python-test:clang-21_1.89.0
           - cxx: g++
-            docker-img: teeks99/boost-python-test:gcc-10_1.76.0
+            docker-img: teeks99/boost-python-test:gcc-15_1.89.0
 
     container:
       image: ${{ matrix.docker-img }}
 
     steps:
     - uses: actions/checkout@v5
 
+    - name: setup prerequisites
+      run: |
+        # Warning: this is not necessarily the same Python version as the one configured above !
+        python3 -m pip install -U faber --break-system-packages
     - name: build
       run: |
         ${{ matrix.python }} --version
diff --git a/doc/numpy/_templates/layout.html b/doc/numpy/_templates/layout.html
@@ -90,7 +90,7 @@
       <tr>
         <td valign="top" width="300">
           <h3><a href="{{ pathto('index') }}"><img 
-          alt="C++ Boost" src="{{ pathto('_static/' + logo, 1) }}" border="0"></a></h3>
+          alt="C++ Boost" src="{{ pathto('_static/bpl.png', 1) }}" border="0"></a></h3>
         </td>
 
         <td >
diff --git a/doc/tutorial.qbk b/doc/tutorial.qbk
@@ -117,7 +117,7 @@ platforms. The complete list of Bjam executables can be found
 [h2 Let's Jam!]
 __jam__
 
-[@../../../../example/tutorial/Jamroot Here] is our minimalist Jamroot
+[@../example/Jamroot Here] is our minimalist Jamroot
 file. Simply copy the file and tweak [^use-project boost] to where your
 boost root directory is and you're OK.
 
diff --git a/fabscript b/fabscript
@@ -16,6 +16,7 @@ from faber.config.try_run import try_run
 
 features += include('include')
 features += define('BOOST_ALL_NO_LIB')  # disable auto-linking
+features += define('BOOST_NO_AUTO_PTR')
 boost_include = options.get_with('boost-include')
 if boost_include:
     features += include(boost_include)
diff --git a/include/boost/python/detail/is_auto_ptr.hpp b/include/boost/python/detail/is_auto_ptr.hpp
@@ -8,6 +8,8 @@
 # ifndef BOOST_NO_AUTO_PTR
 #  include <boost/python/detail/is_xxx.hpp>
 #  include <memory>
+# else
+#  include <boost/mpl/bool.hpp>
 # endif
 
 namespace boost { namespace python { namespace detail { 
diff --git a/include/boost/python/numpy/dtype.hpp b/include/boost/python/numpy/dtype.hpp
@@ -17,6 +17,7 @@
 #include <boost/python/numpy/numpy_object_mgr_traits.hpp>
 #include <boost/mpl/for_each.hpp>
 #include <boost/python/detail/type_traits.hpp>
+#include <boost/type_traits/is_unsigned.hpp>
 
 namespace boost { namespace python { namespace numpy {
 
diff --git a/test/back_reference.cpp b/test/back_reference.cpp
@@ -99,7 +99,7 @@ BOOST_PYTHON_MODULE(back_reference_ext)
         .def("set", &Y::set)
         ;
 
-    class_<Z,std::auto_ptr<Z> >("Z", init<int>())
+    class_<Z,std::shared_ptr<Z> >("Z", init<int>())
         .def("value", &Z::value)
         .def("set", &Z::set)
         ;
diff --git a/test/copy_ctor_mutates_rhs.cpp b/test/copy_ctor_mutates_rhs.cpp
@@ -9,14 +9,13 @@
 
 struct foo
 {
-    operator std::auto_ptr<int>&() const;
+    operator std::shared_ptr<int>&() const;
 };
 
 int main()
 {
     using namespace boost::python::detail;
     BOOST_STATIC_ASSERT(!copy_ctor_mutates_rhs<int>::value);
-    BOOST_STATIC_ASSERT(copy_ctor_mutates_rhs<std::auto_ptr<int> >::value);
     BOOST_STATIC_ASSERT(!copy_ctor_mutates_rhs<std::string>::value);
     BOOST_STATIC_ASSERT(!copy_ctor_mutates_rhs<foo>::value);
     return 0;
diff --git a/test/fabscript b/test/fabscript
@@ -119,10 +119,10 @@ for t in [('injected',),
 
 tests.append(extension_test('shared_ptr',
                             condition=set.define.contains('HAS_CXX11')))
-tests.append(extension_test('polymorphism2_auto_ptr',
-                            condition=set.define.contains('HAS_CXX11').not_()))
-tests.append(extension_test('auto_ptr',
-                            condition=set.define.contains('HAS_CXX11')))
+#tests.append(extension_test('polymorphism2_auto_ptr',
+#                            condition=set.define.contains('HAS_CXX11').not_()))
+#tests.append(extension_test('auto_ptr',
+#                            condition=set.define.contains('HAS_CXX11')))
 
 import_ = binary('import_', ['import_.cpp', src.bpl], features=features|python_libs)
 if platform.os == 'Windows':
diff --git a/test/injected.cpp b/test/injected.cpp
@@ -17,7 +17,7 @@ typedef test_class<> X;
 
 X* empty() { return new X(1000); }
 
-std::auto_ptr<X> sum(int a, int b) { return std::auto_ptr<X>(new X(a+b)); }
+std::shared_ptr<X> sum(int a, int b) { return std::shared_ptr<X>(new X(a+b)); }
 
 boost::shared_ptr<X> product(int a, int b, int c)
 {
diff --git a/test/operators_wrapper.cpp b/test/operators_wrapper.cpp
@@ -36,7 +36,7 @@ BOOST_PYTHON_MODULE( operators_wrapper_ext )
         ;
     
     scope().attr("v") = vector();
-    std::auto_ptr<vector> dp(new dvector);
-    register_ptr_to_python< std::auto_ptr<vector> >();
+    std::shared_ptr<vector> dp(new dvector);
+    register_ptr_to_python< std::shared_ptr<vector> >();
     scope().attr("d") = dp;
 }
diff --git a/test/select_holder.cpp b/test/select_holder.cpp
@@ -62,14 +62,14 @@ int test_main(int, char * [])
     assert_holder<Base,Derived
         ,value_holder_back_reference<Base,Derived> >();
 
-    assert_holder<Base,std::auto_ptr<Base>
-        ,pointer_holder<std::auto_ptr<Base>,Base> >();
+    assert_holder<Base,std::unique_ptr<Base>
+        ,pointer_holder<std::unique_ptr<Base>,Base> >();
     
-    assert_holder<Base,std::auto_ptr<Derived>
-        ,pointer_holder_back_reference<std::auto_ptr<Derived>,Base> >();
+    assert_holder<Base,std::unique_ptr<Derived>
+        ,pointer_holder_back_reference<std::unique_ptr<Derived>,Base> >();
 
-    assert_holder<BR,std::auto_ptr<BR>
-        ,pointer_holder_back_reference<std::auto_ptr<BR>,BR> > ();
+    assert_holder<BR,std::unique_ptr<BR>
+        ,pointer_holder_back_reference<std::unique_ptr<BR>,BR> > ();
 
     return 0;
 }
diff --git a/test/shared_ptr.py b/test/shared_ptr.py
@@ -38,7 +38,7 @@
 12
 >>> try: modify(p)
 ... except TypeError: pass
-... else: 'print(expected a TypeError)'
+... else: print('expected a TypeError')
 >>> look(None)
 -1
 >>> store(p)
@@ -61,7 +61,7 @@
 13
 >>> try: modify(z)
 ... except TypeError: pass
-... else: 'print(expected a TypeError)'
+... else: print('expected a TypeError')
 
 >>> Z.get() # should be None
 >>> store(z)
@@ -84,7 +84,7 @@
 17
 >>> try: modify(x)
 ... except TypeError: pass
-... else: 'print(expected a TypeError)'
+... else: print('expected a TypeError')
 >>> look(None)
 -1
 >>> store(x)
diff --git a/test/upcast.cpp b/test/upcast.cpp
@@ -13,17 +13,7 @@ int main()
 {
     PyTypeObject o;
     Y y;
-    // Test that upcast preserves object identity by comparing pointers.
-#if PY_VERSION_HEX >= 0x030a0000
-    // In Python >= 3.10, Py_REFCNT cannot be used as an l-value.  Instead, we
-    // directly compare the object pointers. For types directly derived from
-    // PyObject (like PyTypeObject), the addresses should match. For Y, which
-    // has multiple inheritance, upcast correctly adjusts to the PyObject base.
     BOOST_TEST(boost::python::upcast<PyObject>(&o) == reinterpret_cast<PyObject*>(&o));
-    BOOST_TEST(boost::python::upcast<PyObject>(&y) == static_cast<PyObject*>(&y));
-#else
-    BOOST_TEST(&Py_REFCNT(boost::python::upcast<PyObject>(&o)) == &Py_REFCNT(&o));
-    BOOST_TEST(&Py_REFCNT(boost::python::upcast<PyObject>(&y)) == &Py_REFCNT(&y));
-#endif
+    BOOST_TEST(boost::python::upcast<PyObject>(&y) == &y);
     return boost::report_errors();
 }
diff --git a/test/wrapper_held_type.cpp b/test/wrapper_held_type.cpp
@@ -20,12 +20,12 @@ struct data
     }
 };
     
-std::auto_ptr<data> create_data()
+std::shared_ptr<data> create_data()
 { 
-    return std::auto_ptr<data>( new data ); 
+    return std::shared_ptr<data>( new data ); 
 }
 
-void do_nothing( std::auto_ptr<data>& ){}
+void do_nothing( std::shared_ptr<data>& ){}
 
     
 namespace bp = boost::python;
@@ -59,7 +59,7 @@ struct data_wrapper : data, bp::wrapper< data >
 
 BOOST_PYTHON_MODULE(wrapper_held_type_ext)
 {
-    bp::class_< data_wrapper, std::auto_ptr< data > >( "data" )    
+    bp::class_< data_wrapper, std::shared_ptr< data > >( "data" )    
         .def( "id", &data::id, &::data_wrapper::default_id );
 
     bp::def( "do_nothing", &do_nothing );

Original file line number	Diff line number	Diff line change
`@@ -99,7 +99,7 @@ BOOST_PYTHON_MODULE(back_reference_ext)`
`99`	`99`	`.def("set", &Y::set)`
`100`	`100`	`;`
`101`	`101`
`102`		`- class_<Z,std::auto_ptr<Z> >("Z", init<int>())`
	`102`	`+ class_<Z,std::shared_ptr<Z> >("Z", init<int>())`
`103`	`103`	`.def("value", &Z::value)`
`104`	`104`	`.def("set", &Z::set)`
`105`	`105`	`;`
Original file line number	Diff line number	Diff line change
`@@ -9,14 +9,13 @@`
`9`	`9`
`10`	`10`	`struct foo`
`11`	`11`	`{`
`12`		`- operator std::auto_ptr<int>&() const;`
	`12`	`+ operator std::shared_ptr<int>&() const;`
`13`	`13`	`};`
`14`	`14`
`15`	`15`	`int main()`
`16`	`16`	`{`
`17`	`17`	`using namespace boost::python::detail;`
`18`	`18`	`BOOST_STATIC_ASSERT(!copy_ctor_mutates_rhs<int>::value);`
`19`		`- BOOST_STATIC_ASSERT(copy_ctor_mutates_rhs<std::auto_ptr<int> >::value);`
`20`	`19`	`BOOST_STATIC_ASSERT(!copy_ctor_mutates_rhs<std::string>::value);`
`21`	`20`	`BOOST_STATIC_ASSERT(!copy_ctor_mutates_rhs<foo>::value);`
`22`	`21`	`return 0;`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ typedef test_class<> X;`
`17`	`17`
`18`	`18`	`X* empty() { return new X(1000); }`
`19`	`19`
`20`		`-std::auto_ptr<X> sum(int a, int b) { return std::auto_ptr<X>(new X(a+b)); }`
	`20`	`+std::shared_ptr<X> sum(int a, int b) { return std::shared_ptr<X>(new X(a+b)); }`
`21`	`21`
`22`	`22`	`boost::shared_ptr<X> product(int a, int b, int c)`
`23`	`23`	`{`