diff --git a/include/boost/function.hpp b/include/boost/function.hpp index bdb2769..b72842b 100644 --- a/include/boost/function.hpp +++ b/include/boost/function.hpp @@ -23,8 +23,8 @@ // in anything that may be included by function_template.hpp doesn't break #include -// Visual Age C++ doesn't handle the file iteration well -#if BOOST_WORKAROUND(__IBMCPP__, >= 500) +// Older Visual Age C++ version do not handle the file iteration well +#if BOOST_WORKAROUND(__IBMCPP__, >= 500) && BOOST_WORKAROUND(__IBMCPP__, < 800) # if BOOST_FUNCTION_MAX_ARGS >= 0 # include # endif diff --git a/include/boost/function/function_base.hpp b/include/boost/function/function_base.hpp index fe9bbbe..78b7dd1 100644 --- a/include/boost/function/function_base.hpp +++ b/include/boost/function/function_base.hpp @@ -203,11 +203,11 @@ namespace boost { { switch (op) { case clone_functor_tag: - out_buffer.obj_ref.obj_ptr = in_buffer.obj_ref.obj_ptr; + out_buffer.obj_ref = in_buffer.obj_ref; return; case move_functor_tag: - out_buffer.obj_ref.obj_ptr = in_buffer.obj_ref.obj_ptr; + out_buffer.obj_ref = in_buffer.obj_ref; in_buffer.obj_ref.obj_ptr = 0; return; @@ -315,14 +315,18 @@ namespace boost { if (op == clone_functor_tag || op == move_functor_tag) { const functor_type* in_functor = reinterpret_cast(&in_buffer.data); - new ((void*)&out_buffer.data) functor_type(*in_functor); + new (reinterpret_cast(&out_buffer.data)) functor_type(*in_functor); if (op == move_functor_tag) { - reinterpret_cast(&in_buffer.data)->~Functor(); + functor_type* f = reinterpret_cast(&in_buffer.data); + (void)f; // suppress warning about the value of f not being used (MSVC) + f->~Functor(); } } else if (op == destroy_functor_tag) { // Some compilers (Borland, vc6, ...) are unhappy with ~functor_type. - reinterpret_cast(&out_buffer.data)->~Functor(); + functor_type* f = reinterpret_cast(&out_buffer.data); + (void)f; // suppress warning about the value of f not being used (MSVC) + f->~Functor(); } else if (op == check_functor_type_tag) { const detail::sp_typeinfo& check_type = *out_buffer.type.type; @@ -369,8 +373,10 @@ namespace boost { // Clone the functor // GCC 2.95.3 gets the CV qualifiers wrong here, so we // can't do the static_cast that we should do. + // jewillco: Changing this to static_cast because GCC 2.95.3 is + // obsolete. const functor_type* f = - (const functor_type*)(in_buffer.obj_ptr); + static_cast(in_buffer.obj_ptr); functor_type* new_f = new functor_type(*f); out_buffer.obj_ptr = new_f; } else if (op == move_functor_tag) { @@ -474,7 +480,7 @@ namespace boost { // GCC 2.95.3 gets the CV qualifiers wrong here, so we // can't do the static_cast that we should do. const functor_wrapper_type* f = - (const functor_wrapper_type*)(in_buffer.obj_ptr); + static_cast(in_buffer.obj_ptr); wrapper_allocator_type wrapper_allocator(static_cast(*f)); wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1); wrapper_allocator.construct(copy, *f); @@ -671,7 +677,7 @@ public: detail::function::check_functor_type_tag); // GCC 2.95.3 gets the CV qualifiers wrong here, so we // can't do the static_cast that we should do. - return (const Functor*)(type_result.obj_ptr); + return static_cast(type_result.obj_ptr); } template @@ -715,7 +721,7 @@ public: public: // should be protected, but GCC 2.95.3 will fail to allow access detail::function::vtable_base* get_vtable() const { return reinterpret_cast( - reinterpret_cast(vtable) & ~(std::size_t)0x01); + reinterpret_cast(vtable) & ~static_cast(0x01)); } bool has_trivial_copy_and_destroy() const { diff --git a/include/boost/function/function_template.hpp b/include/boost/function/function_template.hpp index 6a99109..00a4a2c 100644 --- a/include/boost/function/function_template.hpp +++ b/include/boost/function/function_template.hpp @@ -514,7 +514,7 @@ namespace boost { if (f) { // should be a reinterpret cast, but some compilers insist // on giving cv-qualifiers to free functions - functor.func_ptr = (void (*)())(f); + functor.func_ptr = reinterpret_cast(f); return true; } else { return false; @@ -536,7 +536,7 @@ namespace boost { // objects, so we invoke through mem_fn() but we retain the // right target_type() values. if (f) { - this->assign_to(mem_fn(f), functor); + this->assign_to(boost::mem_fn(f), functor); return true; } else { return false; @@ -549,7 +549,7 @@ namespace boost { // objects, so we invoke through mem_fn() but we retain the // right target_type() values. if (f) { - this->assign_to_a(mem_fn(f), functor, a); + this->assign_to_a(boost::mem_fn(f), functor, a); return true; } else { return false; @@ -563,7 +563,7 @@ namespace boost { void assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) { - new ((void*)&functor.data) FunctionObj(f); + new (reinterpret_cast(&functor.data)) FunctionObj(f); } template void @@ -625,7 +625,7 @@ namespace boost { assign_to(const reference_wrapper& f, function_buffer& functor, function_obj_ref_tag) { - functor.obj_ref.obj_ptr = (void *)f.get_pointer(); + functor.obj_ref.obj_ptr = (void *)(f.get_pointer()); functor.obj_ref.is_const_qualified = is_const::value; functor.obj_ref.is_volatile_qualified = is_volatile::value; return true; @@ -677,7 +677,7 @@ namespace boost { vtable_type* get_vtable() const { return reinterpret_cast( - reinterpret_cast(vtable) & ~(std::size_t)0x01); + reinterpret_cast(vtable) & ~static_cast(0x01)); } struct clear_type {}; @@ -751,9 +751,6 @@ namespace boost { ~BOOST_FUNCTION_FUNCTION() { clear(); } -#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) - // MSVC 6.0 and prior require all definitions to be inline, but - // these definitions can become very costly. result_type operator()(BOOST_FUNCTION_PARMS) const { if (this->empty()) @@ -762,9 +759,6 @@ namespace boost { return get_vtable()->invoker (this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS); } -#else - result_type operator()(BOOST_FUNCTION_PARMS) const; -#endif // The distinction between when to use BOOST_FUNCTION_FUNCTION and // when to use self_type is obnoxious. MSVC cannot handle self_type as @@ -917,7 +911,7 @@ namespace boost { if (boost::has_trivial_copy_constructor::value && boost::has_trivial_destructor::value && detail::function::function_allows_small_object_optimization::value) - value |= (std::size_t)0x01; + value |= static_cast(0x01); vtable = reinterpret_cast(value); } else vtable = 0; @@ -951,7 +945,7 @@ namespace boost { if (boost::has_trivial_copy_constructor::value && boost::has_trivial_destructor::value && detail::function::function_allows_small_object_optimization::value) - value |= (std::size_t)0x01; + value |= static_cast(0x01); vtable = reinterpret_cast(value); } else vtable = 0; @@ -998,22 +992,6 @@ namespace boost { f1.swap(f2); } -#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) - template - typename BOOST_FUNCTION_FUNCTION< - R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS>::result_type - inline - BOOST_FUNCTION_FUNCTION - ::operator()(BOOST_FUNCTION_PARMS) const - { - if (this->empty()) - boost::throw_exception(bad_function_call()); - - return get_vtable()->invoker - (this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS); - } -#endif - // Poison comparisons between boost::function objects of the same type. template void operator==(const BOOST_FUNCTION_FUNCTION< diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index ef4e0d1..68895fa 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -8,6 +8,7 @@ # For more information, see http://www.boost.org/ project + : requirements msvc:on : source-location $(BOOST_ROOT) ; diff --git a/test/mem_fun_cxx98.cpp b/test/mem_fun_cxx98.cpp index afded46..fba21dd 100644 --- a/test/mem_fun_cxx98.cpp +++ b/test/mem_fun_cxx98.cpp @@ -10,22 +10,28 @@ #include +#include #include #include struct X { int foo(int); + std::ostream& foo2(std::ostream&) const; }; int X::foo(int x) { return -x; } +std::ostream& X::foo2(std::ostream& x) const { return x; } int main() { boost::function f; + boost::function f2; -f = &X::foo; - -X x; -f(&x, 5); + f = &X::foo; + f2 = &X::foo2; - return 0; + X x; + BOOST_TEST(f(&x, 5) == -5); + BOOST_TEST(f2(&x, boost::ref(std::cout)) == std::cout); + + return ::boost::report_errors(); } diff --git a/test/mem_fun_portable.cpp b/test/mem_fun_portable.cpp index 689eb22..b0dcd14 100644 --- a/test/mem_fun_portable.cpp +++ b/test/mem_fun_portable.cpp @@ -10,22 +10,28 @@ #include +#include #include #include struct X { int foo(int); + std::ostream& foo2(std::ostream&) const; }; int X::foo(int x) { return -x; } +std::ostream& X::foo2(std::ostream& x) const { return x; } int main() { boost::function2 f; + boost::function2 f2; -f = &X::foo; - -X x; -f(&x, 5); + f = &X::foo; + f2 = &X::foo2; - return 0; + X x; + BOOST_TEST(f(&x, 5) == -5); + BOOST_TEST(f2(&x, boost::ref(std::cout)) == std::cout); + + return ::boost::report_errors(); }