From 5e41e330018eb04cff13087fd96cb907ecf4d801 Mon Sep 17 00:00:00 2001 From: jmmv Date: Fri, 4 Jan 2008 19:58:39 +0000 Subject: Update boost to 1.34.1. This is based on the patches provided by Brook Milligan in PR pkg/36558. Committing it right after the freeze so that we have enough time to resolve the problems that this will surely cause. New Libraries * Foreach Library: BOOST_FOREACH macro for easily iterating over the elements of a sequence, from Eric Niebler. * Statechart Library: Arbitrarily complex finite state machines can be implemented in easily readable and maintainable C++ code, from Andreas Huber. * TR1 Library: An implementation of the C++ Technical Report on Standard Library Extensions, from John Maddock. This library does not itself implement the TR1 components, rather it's a thin wrapper that will include your standard library's TR1 implementation (if it has one), otherwise it will include the Boost Library equivalents, and import them into namespace std::tr1. Highlights include: Reference Wrappers, Smart Pointers, result_of, Function Object Binders, Polymorphic function wrappers, Type Traits, Random Number Generators and Distributions, Tuples, Fixed Size Array, Hash Function Objects, Regular Expressions and Complex Number Additional Algorithms. * Typeof Library: Typeof operator emulation, from Arkadiy Vertleyb and Peder Holt. * Xpressive Library: Regular expressions that can be written as strings or as expression templates, and that can refer to each other and themselves recursively with the power of context-free grammars, from Eric Niebler. Updated Libraries * Assign Library: o Support for ptr_map via the new function ptr_map_insert() o Support for initialization of Pointer Containers when the containers hold pointers to an abstract base class. * Date_time library: o Support for new US/Canada timezone rules and other bug fixes. See Change History for details. * Filesystem Library: Major upgrade in preparation for submission to the C++ Standards Committee for TR2. Changes include: o Internationalization, provided by class templates basic_path, basic_filesystem_error, basic_directory_iterator and basic_directory_entry. o Simplification of the path interface by eliminating special constructors to identify native formats. o Rationalization of predicate function design, including the addition of several new functions. o Clearer specification by reference to POSIX, the ISO/IEEE Single Unix Standard, with provisions for Windows and other operating systems. o Preservation of existing user code whenever possible. o More efficient directory iteration. o Addition of a recursive directory iterator. * Function Library: Boost.Function now implements a small buffer optimization, which can drastically improve the performance when copying or constructing Boost.Function objects storing small function objects. For instance, bind(&X:foo, &x, _1, _2) requires no heap allocation when placed into a Boost.Function object. * Functional/Hash Library o Use declarations for standard classes, so that the library doesn't need to include all of their headers o Deprecated the headers. o Add support for the BOOST_HASH_NO_EXTENSIONS macro, which disables the extensions to TR1 o Minor improvements to the hash functions for floating point numbers. * Graph Library: o edmonds_maximum_cardinality_matching, from Aaron Windsor. o lengauer_tarjan_dominator_tree, from JongSoo Park. o compressed_sparse_row_graph, from Jeremiah Willcock and Douglas Gregor of Indiana University. o sorted_erdos_renyi_iterator, from Jeremiah Willcock of Indiana University. o biconnected_components now supports a visitor and named parameters, from Janusz Piwowarski. o adjacency_matrix now models the Bidirectional Graph concept. o dijkstra_shortest_paths now calls vis.initialize_vertex for each vertex during initialization. o Note: the name of the compiled library for the GraphViz reader has changed to boost_graph (from bgl-viz) to match Boost conventions. o See the complete revision history for more information. * MultiArray Library: Boost.MultiArray now by default provides range-checking for operator[]. Range checking can be disabled by defining the macro BOOST_DISABLE_ASSERTS before including multi_array.hpp. A bug in multi_array::resize() related to storage orders was fixed. * Multi-index Containers Library: o New random access indices. o Non key-based indices feature new rearrange facilities. o This version also includes a number of optimizations and usage improvements. For a complete list of changes, see the library release notes. * Optional Library: o boost::none_t and boost::none now added to Optional's documentation o Relational operators now directly support arguments of type 'T' and 'none_t' o operator->() now also works with reference types. o Helper functions make_optional(val), make_optional(cond,val) and get_optional_value_or(opt,alternative_value) added. o Constructor taking a boolean condition (as well as a value) added. o Member function get_value_or(alternative_value) added. o Incompatbility bug with mpl::apply<> fixed. o Converting assignment bug with uninitialized lvalues fixed. * Parameter Library: o Every ArgumentPack is now a valid MPL Forward Sequence. o Support for unnamed arguments (those whose keyword is deduced from their types) is added. o Support for named and unnamed template arguments is added. o New overload generation macros solve the forwarding problem directly. o See also the Python library changes, below. * Pointer Container Library: o Support for serialization via Boost.Serialization. o Exceptions can be disabled by defining the macro BOOST_PTR_CONTAINER_NO_EXCEPTIONS before including any header. This macro is defined by default if BOOST_NO_EXCEPTIONS is defined. o Additional std::auto_ptr overloads added s.t. one can also pass std::auto_ptr instead of only T* arguments to member functions. o transfer() now has weaker requirements s.t. one can transfer objects from ptr_container to ptr_container, * Python Library: o Boost.Python now automatically appends C++ signatures to docstrings. The new docstring_options.hpp header is available to control the content of docstrings. o stl_input_iterator, for turning a Python iterable object into an STL input iterator, from Eric Niebler. o Support for void* conversions is added. o Integrated support for wrapping C++ functions built with the parameter library; keyword names are automatically known to docsstrings. o Enhancements to the API for better embedding support (boost::python::import(), boost::python::exec() and boost::python::exec_file()). * Signals Library: More improvements to signal invocation performance from Robert Zeh. * Smart Pointers Library: o Allocator support as proposed in N1851 (162 Kb PDF). o pointer_cast and pointer_to_other utilities to allow pointer-independent code, from Ion Gaztanaga. * String Algorithm Library: o lexicographical_compare o join o New comparison predicates is_less, is_not_greater. o Negative indexes support (like Perl) in various algorihtms (*_head/tail, *_nth). * Wave Library: o Wave now correctly recognizes pp-number tokens as mandated by the C++ Standard, which are converted to C++ tokens right before they are returned from the library. o Several new preprocessing hooks have been added. For a complete description please refer to the related documentation page: The Context Policy. o Shared library (dll) support has been added for the generated Wave libraries. o The overall error handling has been improved. It is now possible to recover and continue after an error or a warning was issued. o Support for optional comment and/or full whitespace preservation in the generated output stream has been added. o The Wave library now performs automatic include guard detection to avoid accessing header files more than once, if appropriate. o Full interactive mode has been added to the Wave tool. Now the Wave tool can be used just like Python or Perl for instance to interactively try out your BOOST_PP macros. Additionally it is now possible to load and save the current state of an interactive session (macro tables et.al.). o The overall performance has been improved by upto 40-60%, depending on the concrete files to process. o Support for new pragmas has been added allowing to control certain library features from inside the preprocessed sources (partial output redirection, control of generated whitespace and #line directives). o Optional support for #pragma message "..." has been added. o This version also includes a number of bug fixes and usage improvements. For a complete list of changes, see the libraries change log. --- meta-pkgs/boost/Makefile.common | 6 +- meta-pkgs/boost/distinfo | 26 +- meta-pkgs/boost/patches/patch-aa | 48 ---- meta-pkgs/boost/patches/patch-ab | 13 - meta-pkgs/boost/patches/patch-ad | 8 +- meta-pkgs/boost/patches/patch-ae | 21 -- meta-pkgs/boost/patches/patch-af | 23 +- meta-pkgs/boost/patches/patch-ag | 12 - meta-pkgs/boost/patches/patch-ah | 10 +- meta-pkgs/boost/patches/patch-ai | 15 -- meta-pkgs/boost/patches/patch-aj | 21 -- meta-pkgs/boost/patches/patch-ak | 8 +- meta-pkgs/boost/patches/patch-al | 42 +++ meta-pkgs/boost/patches/patch-am | 12 + meta-pkgs/boost/patches/patch-an | 160 +++++++++++ meta-pkgs/boost/patches/patch-ao | 556 +++++++++++++++++++++++++++++++++++++++ 16 files changed, 804 insertions(+), 177 deletions(-) delete mode 100644 meta-pkgs/boost/patches/patch-aa delete mode 100644 meta-pkgs/boost/patches/patch-ab delete mode 100644 meta-pkgs/boost/patches/patch-ae delete mode 100644 meta-pkgs/boost/patches/patch-ag delete mode 100644 meta-pkgs/boost/patches/patch-ai delete mode 100644 meta-pkgs/boost/patches/patch-aj create mode 100644 meta-pkgs/boost/patches/patch-al create mode 100644 meta-pkgs/boost/patches/patch-am create mode 100644 meta-pkgs/boost/patches/patch-an create mode 100644 meta-pkgs/boost/patches/patch-ao (limited to 'meta-pkgs') diff --git a/meta-pkgs/boost/Makefile.common b/meta-pkgs/boost/Makefile.common index f80c056bdb7..7e206ae9e33 100644 --- a/meta-pkgs/boost/Makefile.common +++ b/meta-pkgs/boost/Makefile.common @@ -1,10 +1,10 @@ -# $NetBSD: Makefile.common,v 1.10 2007/02/22 19:30:05 wiz Exp $ +# $NetBSD: Makefile.common,v 1.11 2008/01/04 19:58:41 jmmv Exp $ # BOOST_PACKAGE?= undefined BOOST_COMMENT?= undefined -BOOST_VERSION= 1.33.1 +BOOST_VERSION= 1.34.1 BOOST_SHORT_VERSION= ${BOOST_VERSION:S/./_/:C/\..*$//} DISTNAME= boost_${BOOST_VERSION:S/./_/g} @@ -25,7 +25,7 @@ MAINTAINER= jmmv@NetBSD.org HOMEPAGE= http://www.boost.org/ COMMENT= Free, peer-reviewed portable C++ source libraries ${BOOST_COMMENT} -CONFLICTS+= boost<1.32.0 +CONFLICTS+= boost<1.34.0 DISTINFO_FILE= ${.CURDIR}/../../meta-pkgs/boost/distinfo PATCHDIR= ${.CURDIR}/../../meta-pkgs/boost/patches diff --git a/meta-pkgs/boost/distinfo b/meta-pkgs/boost/distinfo index 818a141e3cb..5e09483305f 100644 --- a/meta-pkgs/boost/distinfo +++ b/meta-pkgs/boost/distinfo @@ -1,16 +1,14 @@ -$NetBSD: distinfo,v 1.10 2006/09/18 22:51:25 joerg Exp $ +$NetBSD: distinfo,v 1.11 2008/01/04 19:58:41 jmmv Exp $ -SHA1 (boost_1_33_1.tar.bz2) = 22682f75ff0d1ea548688e78c8cca83d599ca576 -RMD160 (boost_1_33_1.tar.bz2) = 3d5999d321b558f74d786bec52ee1b1fcd7e7152 -Size (boost_1_33_1.tar.bz2) = 11507161 bytes -SHA1 (patch-aa) = 957dad8d5993f0d28b399eedb2d0ae14ecfebc4c -SHA1 (patch-ab) = 197c51ac67d74923d02f8a9746b5d2e0f7b84736 +SHA1 (boost_1_34_1.tar.bz2) = b771271d5cbd3bdb0f119dd66dfd36bad7a66866 +RMD160 (boost_1_34_1.tar.bz2) = 303327ff852bc19dd7a94657fdef3c56f5882e06 +Size (boost_1_34_1.tar.bz2) = 12986931 bytes SHA1 (patch-ac) = 453d4107df03e96e66cbdbebceebdfcbed2710c1 -SHA1 (patch-ad) = 4d8bd0cea4b6758d52890cec420892f3ece4ea09 -SHA1 (patch-ae) = e557356101204290a70084eb284d90ce8f4cbd71 -SHA1 (patch-af) = 64a6fa2be7a526a0a3e6f47d5f703d7253a51615 -SHA1 (patch-ag) = 6c862a0f50590327344d6973617ccc56df67fa76 -SHA1 (patch-ah) = e16c08bb0f63e63ae082e9d83c588e3adcf9cb3b -SHA1 (patch-ai) = 1e2d946090093bb4b9ab8fa78ccfaa0189b1d145 -SHA1 (patch-aj) = 09d27fc296105d3a8141df26ce3e8942ca973746 -SHA1 (patch-ak) = 9eb5353855d2b9b0638c98ab3fce33ac19e0f29a +SHA1 (patch-ad) = 074db0bdee7ca145cda2c938626b7d5e3e1e7368 +SHA1 (patch-af) = f0a1fc4b9884663fbe5b9613bc61837b8e6e6af1 +SHA1 (patch-ah) = dc5d1d90998aad0f9689470166fd82f1eccdffe3 +SHA1 (patch-ak) = 32785c636ccc9be479db2d40d170f95e77d4e291 +SHA1 (patch-al) = 23756770d17d7958b0b9423e379fe0a1a2dd83f8 +SHA1 (patch-am) = 07f1e1e15d4129c7a8762ad2e81632fdd24e9515 +SHA1 (patch-an) = 91887a9a37e9d891252e0556ee40b58a1c6bc6cf +SHA1 (patch-ao) = a8499a326f72c9fbfd31f0b0f23014729a2a0dae diff --git a/meta-pkgs/boost/patches/patch-aa b/meta-pkgs/boost/patches/patch-aa deleted file mode 100644 index 39dfa037a6a..00000000000 --- a/meta-pkgs/boost/patches/patch-aa +++ /dev/null @@ -1,48 +0,0 @@ -$NetBSD: patch-aa,v 1.3 2006/01/20 20:40:19 jmmv Exp $ - ---- tools/build/v1/gcc-tools.jam.orig 2005-11-19 20:21:16.000000000 +0100 -+++ tools/build/v1/gcc-tools.jam -@@ -123,6 +123,12 @@ else if $(UNIX) - .GCC ?= cc ; - .GXX ?= c++ ; - } -+ case NetBSD : -+ { -+ flags gcc CFLAGS multi : -pthread ; -+ flags gcc LINKFLAGS multi : -lpthread ; -+ # there is no -lrt on NetBSD -+ } - case *BSD : - { - flags gcc CFLAGS multi : -pthread ; -@@ -179,7 +185,11 @@ if $(UNIX) - SONAME = -Wl,-soname, ; - flags gcc OBJCOPY_FLAGS on : "--set-section-flags .debug_str=contents,debug" ; - } -- case OpenBSD : -+ case *BSD : -+ { -+ SONAME = -Wl,-soname, ; -+ } -+ case DragonFly : - { - SONAME = -Wl,-soname, ; - } -@@ -420,7 +430,7 @@ rule Link-action - LNOPT on $(<) = "" ; - } - # do we use sonames or not? -- if $(DLLVERSION) && $(TARGET_TYPE) in $(SHARED_TYPES) && ( $(OS) = LINUX || $(OS) = OPENBSD || $(OS) = KFREEBSD ) && ! $(NO_GNU_LN) -+ if $(DLLVERSION) && $(TARGET_TYPE) in $(SHARED_TYPES) && ( $(OS) = DRAGONFLY || $(OS) = FREEBSD || $(OS) = LINUX || $(OS) = NETBSD || $(OS) = OPENBSD || $(OS) = KFREEBSD ) && ! $(NO_GNU_LN) - { - OUTTAG on $(<) = ".$(DLLVERSION)" ; - SOTAG on $(<) = ".$(DLLVERSION)" ; -@@ -466,7 +476,7 @@ rule Link-action - gcc-spawn $(<) ; - gcc-Link-action $(<) : $(>) ; - -- if $(DLLVERSION) && $(TARGET_TYPE) in $(SHARED_TYPES) && ( $(OS) = LINUX || $(OS) = OPENBSD || $(OS) = KFREEBSD ) && ! $(NO_GNU_LN) -+ if $(DLLVERSION) && $(TARGET_TYPE) in $(SHARED_TYPES) && ( $(OS) = DRAGONFLY || $(OS) = FREEBSD || $(OS) = LINUX || $(OS) = NETBSD || $(OS) = OPENBSD || $(OS) = KFREEBSD ) && ! $(NO_GNU_LN) - { - return "$(<[1]).$(DLLVERSION)" ; - } diff --git a/meta-pkgs/boost/patches/patch-ab b/meta-pkgs/boost/patches/patch-ab deleted file mode 100644 index 3d1929058e8..00000000000 --- a/meta-pkgs/boost/patches/patch-ab +++ /dev/null @@ -1,13 +0,0 @@ -$NetBSD: patch-ab,v 1.1 2005/02/26 22:48:34 jmmv Exp $ - ---- libs/config/test/boost_no_cwchar.ipp.orig 2003-10-14 12:33:07.000000000 +0200 -+++ libs/config/test/boost_no_cwchar.ipp -@@ -18,7 +18,7 @@ int test() - { - wchar_t c1[2] = { 0 }; - wchar_t c2[2] = { 0 }; -- if(wcscmp(c1,c2) || wcslen(c1)) return -1; -+ if(std::wcscmp(c1,c2) || std::wcslen(c1)) return -1; - wcscpy(c1,c2); - wcsxfrm(c1,c2,0); - return 0; diff --git a/meta-pkgs/boost/patches/patch-ad b/meta-pkgs/boost/patches/patch-ad index ee5d77c5720..2ce7e848eca 100644 --- a/meta-pkgs/boost/patches/patch-ad +++ b/meta-pkgs/boost/patches/patch-ad @@ -1,13 +1,13 @@ -$NetBSD: patch-ad,v 1.4 2006/01/21 09:02:16 jmmv Exp $ +$NetBSD: patch-ad,v 1.5 2008/01/04 19:58:41 jmmv Exp $ ---- boost/config/suffix.hpp.orig 2006-01-20 21:59:33.000000000 +0100 +--- boost/config/suffix.hpp.orig 2007-10-13 15:10:16.000000000 +0200 +++ boost/config/suffix.hpp -@@ -213,7 +213,7 @@ +@@ -207,7 +207,7 @@ // from here then add to the appropriate compiler section): // #if (defined(__MT__) || defined(_MT) || defined(_REENTRANT) \ - || defined(_PTHREADS)) && !defined(BOOST_HAS_THREADS) -+ || defined(_PTHREADS) || defined(__DragonFly__) || defined(__APPLE__)) && !defined(BOOST_HAS_THREADS) ++ || defined(_PTHREADS) || defined(__APPLE__) || defined(__DragonFly__)) && !defined(BOOST_HAS_THREADS) # define BOOST_HAS_THREADS #endif diff --git a/meta-pkgs/boost/patches/patch-ae b/meta-pkgs/boost/patches/patch-ae deleted file mode 100644 index cb46b29391c..00000000000 --- a/meta-pkgs/boost/patches/patch-ae +++ /dev/null @@ -1,21 +0,0 @@ -$NetBSD: patch-ae,v 1.4 2006/01/21 10:12:40 jmmv Exp $ - ---- tools/build/v1/darwin-tools.jam.orig 2005-05-11 08:15:20.000000000 +0200 -+++ tools/build/v1/darwin-tools.jam -@@ -149,6 +149,7 @@ if -bind_at_load in $(.LINKFLAGS) - .LINKFLAGS = [ difference $(.LINKFLAGS) : -bind_at_load ] ; - } - flags darwin LINKFLAGS : $(.LINKFLAGS) ; -+flags darwin LINKFLAGS : -flat_namespace -undefined suppress ; - - - #### Link #### -@@ -187,7 +188,7 @@ actions darwin-Link-DyLib-action bind NE - && \ - $(.GCC_BIN_DIR)$(.GXX) $(LINKFLAGS) -o "$(<[1])" "$(<[1]:S=.lo)" \ - -F$(FRAMEWORKS:D) -framework$(_)$(FRAMEWORKS:D=) \ -- -L"$(LIBPATH:T)" -L"$(STDLIBPATH:T)" "$(NEEDLIBS)" "$(NEEDLIBS)" -l$(FINDLIBS) -dynamiclib -install_name "$(<[1]:D=:S=.dylib)" \ -+ -L"$(LIBPATH:T)" -L"$(STDLIBPATH:T)" "$(NEEDLIBS)" "$(NEEDLIBS)" -l$(FINDLIBS) -dynamiclib -install_name "$(TARGET_LIBDIR)/$(<[1]:D=:S=.dylib)" \ - && \ - rm -f "$(<[1]:S=.lo)" - } diff --git a/meta-pkgs/boost/patches/patch-af b/meta-pkgs/boost/patches/patch-af index 6c239de3058..288719240bd 100644 --- a/meta-pkgs/boost/patches/patch-af +++ b/meta-pkgs/boost/patches/patch-af @@ -1,24 +1,13 @@ -$NetBSD: patch-af,v 1.2 2006/01/20 20:40:19 jmmv Exp $ +$NetBSD: patch-af,v 1.3 2008/01/04 19:58:42 jmmv Exp $ ---- boost/config/platform/bsd.hpp.orig 2005-08-24 17:45:17.000000000 +0200 +--- boost/config/platform/bsd.hpp.orig 2006-02-16 12:05:44.000000000 +0100 +++ boost/config/platform/bsd.hpp -@@ -23,6 +23,10 @@ - #define BOOST_PLATFORM "DragonFly " BOOST_STRINGIZE(__DragonFly__) - #endif - -+#if defined(__DragonFly__) -+#define _REENTRANT 1 -+#endif -+ - // - // is this the correct version check? - // FreeBSD has but does not -@@ -36,20 +40,20 @@ +@@ -36,20 +36,20 @@ // FreeBSD 3.x has pthreads support, but defines _POSIX_THREADS in // and not in // --#if defined(__FreeBSD__) && (__FreeBSD__ <= 3) -+#if defined(__DragonFly__) || defined(__FreeBSD__) && (__FreeBSD__ <= 3) +-#if (defined(__FreeBSD__) && (__FreeBSD__ <= 3)) || defined(__OpenBSD__) ++#if (defined(__FreeBSD__) && (__FreeBSD__ <= 3)) || defined(__OpenBSD__) || defined(__DragonFly__) # define BOOST_HAS_PTHREADS #endif @@ -26,7 +15,7 @@ $NetBSD: patch-af,v 1.2 2006/01/20 20:40:19 jmmv Exp $ // No wide character support in the BSD header files: // -#if !(defined(__FreeBSD__) && (__FreeBSD__ >= 5)) -+#if !((defined(__FreeBSD__) && (__FreeBSD__ >= 5))) && !defined(__DragonFly__) ++#if !(defined(__FreeBSD__) && (__FreeBSD__ >= 5)) && !defined(__DragonFly__) # define BOOST_NO_CWCHAR #endif // diff --git a/meta-pkgs/boost/patches/patch-ag b/meta-pkgs/boost/patches/patch-ag deleted file mode 100644 index bf86a0a492e..00000000000 --- a/meta-pkgs/boost/patches/patch-ag +++ /dev/null @@ -1,12 +0,0 @@ -$NetBSD: patch-ag,v 1.3 2006/01/21 09:02:16 jmmv Exp $ - ---- tools/build/v1/boost-base.jam.orig 2006-01-21 00:28:08.000000000 +0100 -+++ tools/build/v1/boost-base.jam -@@ -2616,6 +2616,7 @@ rule common-variant-tag ( toolset varian - - local thread-tag = ; - if multi in $(properties) { thread-tag = mt ; } -+ if $(OS) = MACOSX { thread-tag = mt ; } - - local runtime-tag = ; - if static in $(properties) { runtime-tag += s ; } diff --git a/meta-pkgs/boost/patches/patch-ah b/meta-pkgs/boost/patches/patch-ah index 8ad7606d91d..0ed927c7f67 100644 --- a/meta-pkgs/boost/patches/patch-ah +++ b/meta-pkgs/boost/patches/patch-ah @@ -1,7 +1,7 @@ -$NetBSD: patch-ah,v 1.1 2006/01/12 22:48:46 joerg Exp $ +$NetBSD: patch-ah,v 1.2 2008/01/04 19:58:42 jmmv Exp $ ---- tools/build/jam_src/jam.h.orig 2006-01-12 21:30:50.000000000 +0000 -+++ tools/build/jam_src/jam.h +--- tools/jam/src/jam.h.orig 2005-10-16 17:34:27.000000000 +0200 ++++ tools/jam/src/jam.h @@ -250,8 +250,8 @@ # define OS_FREEBSD # endif @@ -13,7 +13,7 @@ $NetBSD: patch-ah,v 1.1 2006/01/12 22:48:46 joerg Exp $ # endif # ifdef __DGUX__ # define OSMINOR "OS=DGUX" -@@ -415,7 +415,7 @@ +@@ -419,7 +419,7 @@ # if !defined(OS_BSDI) && \ !defined(OS_FREEBSD) && \ @@ -22,7 +22,7 @@ $NetBSD: patch-ah,v 1.1 2006/01/12 22:48:46 joerg Exp $ !defined(OS_NEXT) && \ !defined(OS_MACHTEN) && \ !defined(OS_MACOSX) && \ -@@ -448,7 +448,7 @@ +@@ -452,7 +452,7 @@ defined( __i386__ ) || \ defined( _M_IX86 ) # if !defined( OS_FREEBSD ) && \ diff --git a/meta-pkgs/boost/patches/patch-ai b/meta-pkgs/boost/patches/patch-ai deleted file mode 100644 index afa27ae3092..00000000000 --- a/meta-pkgs/boost/patches/patch-ai +++ /dev/null @@ -1,15 +0,0 @@ -$NetBSD: patch-ai,v 1.1 2006/08/24 08:45:35 jmmv Exp $ - ---- boost/python/converter/rvalue_from_python_data.hpp.orig 2006-08-23 23:48:06.000000000 +0200 -+++ boost/python/converter/rvalue_from_python_data.hpp -@@ -94,7 +94,9 @@ struct rvalue_from_python_data : rvalue_ - # if (!defined(__MWERKS__) || __MWERKS__ >= 0x3000) \ - && (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= 245) \ - && (!defined(__DECCXX_VER) || __DECCXX_VER > 60590014) \ -- && !defined(BOOST_PYTHON_SYNOPSIS) /* Synopsis' OpenCXX has trouble parsing this */ -+ && !defined(BOOST_PYTHON_SYNOPSIS) /* Synopsis' OpenCXX has trouble parsing this */ \ -+ && !(BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, == 4)) \ -+ && !(BOOST_WORKAROUND(__GNUC__, == 4)) - // This must always be a POD struct with m_data its first member. - BOOST_STATIC_ASSERT(BOOST_PYTHON_OFFSETOF(rvalue_from_python_storage,stage1) == 0); - # endif diff --git a/meta-pkgs/boost/patches/patch-aj b/meta-pkgs/boost/patches/patch-aj deleted file mode 100644 index 04fb3dab277..00000000000 --- a/meta-pkgs/boost/patches/patch-aj +++ /dev/null @@ -1,21 +0,0 @@ -$NetBSD: patch-aj,v 1.1 2006/08/24 08:45:35 jmmv Exp $ - ---- boost/python/object/instance.hpp.orig 2006-08-23 23:48:06.000000000 +0200 -+++ boost/python/object/instance.hpp -@@ -41,9 +41,16 @@ struct additional_instance_size - { - typedef instance instance_data; - typedef instance instance_char; -+#if !(BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, == 4)) \ -+ && !(BOOST_WORKAROUND(__GNUC__, == 4)) - BOOST_STATIC_CONSTANT( - std::size_t, value = sizeof(instance_data) - - BOOST_PYTHON_OFFSETOF(instance_char,storage)); -+#else -+ BOOST_STATIC_CONSTANT( -+ std::size_t, value = sizeof(instance_data) -+ - (sizeof(PyVarObject) + sizeof(PyObject*) + sizeof(PyObject*) + sizeof(instance_holder*))); -+#endif - }; - - }}} // namespace boost::python::object diff --git a/meta-pkgs/boost/patches/patch-ak b/meta-pkgs/boost/patches/patch-ak index 37e4de4262c..046a7c96f48 100644 --- a/meta-pkgs/boost/patches/patch-ak +++ b/meta-pkgs/boost/patches/patch-ak @@ -1,13 +1,13 @@ -$NetBSD: patch-ak,v 1.1 2006/09/18 22:51:25 joerg Exp $ +$NetBSD: patch-ak,v 1.2 2008/01/04 19:58:42 jmmv Exp $ ---- boost/wave/token_ids.hpp.orig 2006-09-18 22:37:11.000000000 +0000 +--- boost/wave/token_ids.hpp.orig 2006-12-20 17:38:24.000000000 +0100 +++ boost/wave/token_ids.hpp -@@ -23,7 +23,7 @@ +@@ -27,7 +27,7 @@ #if !defined(BOOST_WAVE_TOKEN_IDS_DEFINED) #define BOOST_WAVE_TOKEN_IDS_DEFINED -#if defined (__FreeBSD__) && defined (T_DIVIDE) -+#if (defined (__FreeBSD__) || defined(__DragonFly__)) && defined (T_DIVIDE) ++#if (defined (__FreeBSD__) || defined (__DragonFly__)) && defined (T_DIVIDE) #undef T_DIVIDE #endif diff --git a/meta-pkgs/boost/patches/patch-al b/meta-pkgs/boost/patches/patch-al new file mode 100644 index 00000000000..38ec3782917 --- /dev/null +++ b/meta-pkgs/boost/patches/patch-al @@ -0,0 +1,42 @@ +$NetBSD: patch-al,v 1.1 2008/01/04 19:58:42 jmmv Exp $ + +--- Jamfile.v2.orig ++++ Jamfile.v2 +@@ -106,6 +106,9 @@ + + constant BOOST_VERSION_TAG : $(version-tag:J="_") ; + ++local PREFIX = [ os.environ PREFIX ] ; ++local COMPILER_RPATH_FLAG = [ os.environ COMPILER_RPATH_FLAG ] ; ++ + local default-build ; + if $(__file__:D) = "" + { +@@ -113,6 +116,7 @@ + debug release + single multi + shared static ++ $(COMPILER_RPATH_FLAG)$(PREFIX)/lib + ; + + if [ os.name ] = NT +@@ -215,7 +216,7 @@ + EXIT ; + } + local wrong = [ set.difference $(without-parameter) : $(existing-libraries) ] ; +- if $(wrong) ++ if $(without-parameter) != * && $(wrong) + { + ECHO "error: wrong library name '$(wrong[1])' in the --without- option." ; + EXIT ; +@@ -225,6 +226,10 @@ + { + return [ set.intersection $(existing-libraries) : $(with-parameter) ] ; + } ++ else if $(without-parameter) = * ++ { ++ return [ set.difference "" : "" ] ; ++ } + else + { + return [ set.difference $(existing-libraries) : $(without-parameter) ] ; diff --git a/meta-pkgs/boost/patches/patch-am b/meta-pkgs/boost/patches/patch-am new file mode 100644 index 00000000000..33c01da41a6 --- /dev/null +++ b/meta-pkgs/boost/patches/patch-am @@ -0,0 +1,12 @@ +$NetBSD: patch-am,v 1.1 2008/01/04 19:58:43 jmmv Exp $ + +--- tools/build/v2/tools/python.jam.orig 2007-09-22 22:13:17.000000000 +0200 ++++ tools/build/v2/tools/python.jam +@@ -622,6 +622,7 @@ local rule system-library-dependencies ( + + case qnx* : return ; + case darwin : return ; ++ case netbsd : return ; + case windows : return ; + + case hpux : return rt ; diff --git a/meta-pkgs/boost/patches/patch-an b/meta-pkgs/boost/patches/patch-an new file mode 100644 index 00000000000..f396ab73481 --- /dev/null +++ b/meta-pkgs/boost/patches/patch-an @@ -0,0 +1,160 @@ +$NetBSD: patch-an,v 1.1 2008/01/04 19:58:43 jmmv Exp $ + +Critical fix for Boost.Function, which addresses a problem in multi-threaded +applications. Generated from complete file posted at: + +http://boost.org/function-1-34-fix/function_base.hpp + +--- boost/function/function_base.hpp 2006-10-13 16:29:45.000000000 +0200 ++++ boost/function/function_base.hpp 2008-01-04 16:21:22.000000000 +0100 +@@ -15,6 +15,7 @@ + #include + #include + #include ++#include // unary_function, binary_function + #include + #include + #include +@@ -30,6 +31,20 @@ + #endif + #include + ++#if defined(BOOST_MSVC) ++# pragma warning( push ) ++# pragma warning( disable : 4793 ) // complaint about native code generation ++# pragma warning( disable : 4127 ) // "conditional expression is constant" ++#endif ++ ++// Define BOOST_FUNCTION_STD_NS to the namespace that contains type_info. ++#ifdef BOOST_NO_EXCEPTION_STD_NAMESPACE ++// Embedded VC++ does not have type_info in namespace std ++# define BOOST_FUNCTION_STD_NS ++#else ++# define BOOST_FUNCTION_STD_NS std ++#endif ++ + // Borrowed from Boost.Python library: determines the cases where we + // need to use std::type_info::name to compare instead of operator==. + # if (defined(__GNUC__) && __GNUC__ >= 3) \ +@@ -59,7 +74,7 @@ namespace boost { namespace python { nam + + #if defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ + || defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG) \ +- || !(BOOST_STRICT_CONFIG || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540) ++ || !(defined(BOOST_STRICT_CONFIG) || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540) + # define BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX + #endif + +@@ -198,8 +213,8 @@ namespace boost { + struct reference_manager + { + static inline void +- get(const function_buffer& in_buffer, function_buffer& out_buffer, +- functor_manager_operation_type op) ++ manage(const function_buffer& in_buffer, function_buffer& out_buffer, ++ functor_manager_operation_type op) + { + switch (op) { + case clone_functor_tag: +@@ -215,8 +230,8 @@ namespace boost { + // DPG TBD: Since we're only storing a pointer, it's + // possible that the user could ask for a base class or + // derived class. Is that okay? +- const std::type_info& check_type = +- *static_cast(out_buffer.const_obj_ptr); ++ const BOOST_FUNCTION_STD_NS::type_info& check_type = ++ *static_cast(out_buffer.const_obj_ptr); + if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(F))) + out_buffer.obj_ptr = in_buffer.obj_ptr; + else +@@ -265,8 +280,8 @@ namespace boost { + else if (op == destroy_functor_tag) + out_buffer.func_ptr = 0; + else /* op == check_functor_type_tag */ { +- const std::type_info& check_type = +- *static_cast(out_buffer.const_obj_ptr); ++ const BOOST_FUNCTION_STD_NS::type_info& check_type = ++ *static_cast(out_buffer.const_obj_ptr); + if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor))) + out_buffer.obj_ptr = &in_buffer.func_ptr; + else +@@ -287,8 +302,8 @@ namespace boost { + // Some compilers (Borland, vc6, ...) are unhappy with ~functor_type. + reinterpret_cast(&out_buffer.data)->~Functor(); + } else /* op == check_functor_type_tag */ { +- const std::type_info& check_type = +- *static_cast(out_buffer.const_obj_ptr); ++ const BOOST_FUNCTION_STD_NS::type_info& check_type = ++ *static_cast(out_buffer.const_obj_ptr); + if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor))) + out_buffer.obj_ptr = &in_buffer.data; + else +@@ -348,8 +363,8 @@ namespace boost { + # endif // BOOST_NO_STD_ALLOCATOR + out_buffer.obj_ptr = 0; + } else /* op == check_functor_type_tag */ { +- const std::type_info& check_type = +- *static_cast(out_buffer.const_obj_ptr); ++ const BOOST_FUNCTION_STD_NS::type_info& check_type = ++ *static_cast(out_buffer.const_obj_ptr); + if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor))) + out_buffer.obj_ptr = in_buffer.obj_ptr; + else +@@ -368,6 +383,15 @@ namespace boost { + mpl::bool_<(function_allows_small_object_optimization::value)>()); + } + ++ // For member pointers, we treat them as function objects with ++ // the small-object optimization always enabled. ++ static inline void ++ manager(const function_buffer& in_buffer, function_buffer& out_buffer, ++ functor_manager_operation_type op, member_ptr_tag) ++ { ++ manager(in_buffer, out_buffer, op, mpl::true_()); ++ } ++ + public: + /* Dispatch to an appropriate manager based on whether we have a + function pointer or a function object pointer. */ +@@ -456,7 +480,6 @@ namespace boost { + */ + struct vtable_base + { +- vtable_base() : manager(0) { } + void (*manager)(const function_buffer& in_buffer, + function_buffer& out_buffer, + functor_manager_operation_type op); +@@ -480,13 +503,13 @@ public: + + /** Retrieve the type of the stored function object, or typeid(void) + if this is empty. */ +- const std::type_info& target_type() const ++ const BOOST_FUNCTION_STD_NS::type_info& target_type() const + { + if (!vtable) return typeid(void); + + detail::function::function_buffer type; + vtable->manager(functor, type, detail::function::get_functor_type_tag); +- return *static_cast(type.const_obj_ptr); ++ return *static_cast(type.const_obj_ptr); + } + + template +@@ -558,7 +581,7 @@ public: + #endif + + public: // should be protected, but GCC 2.95.3 will fail to allow access +- detail::function::vtable_base* vtable; ++ const detail::function::vtable_base* vtable; + mutable detail::function::function_buffer functor; + }; + +@@ -733,4 +756,8 @@ namespace detail { + #undef BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL + #undef BOOST_FUNCTION_COMPARE_TYPE_ID + ++#if defined(BOOST_MSVC) ++# pragma warning( pop ) ++#endif ++ + #endif // BOOST_FUNCTION_BASE_HEADER diff --git a/meta-pkgs/boost/patches/patch-ao b/meta-pkgs/boost/patches/patch-ao new file mode 100644 index 00000000000..7fdcf451aad --- /dev/null +++ b/meta-pkgs/boost/patches/patch-ao @@ -0,0 +1,556 @@ +$NetBSD: patch-ao,v 1.1 2008/01/04 19:58:43 jmmv Exp $ + +Critical fix for Boost.Function, which addresses a problem in multi-threaded +applications. Generated from complete file posted at: + +http://boost.org/function-1-34-fix/function_template.hpp + +--- boost/function/function_template.hpp 2006-09-29 19:23:28.000000000 +0200 ++++ boost/function/function_template.hpp 2008-01-04 16:21:27.000000000 +0100 +@@ -11,6 +11,11 @@ + // protection. + #include + ++#if defined(BOOST_MSVC) ++# pragma warning( push ) ++# pragma warning( disable : 4127 ) // "conditional expression is constant" ++#endif ++ + #define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T) + + #define BOOST_FUNCTION_TEMPLATE_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, T) +@@ -54,12 +59,20 @@ + BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS) + #define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER \ + BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS) ++#define BOOST_FUNCTION_MEMBER_INVOKER \ ++ BOOST_JOIN(member_invoker,BOOST_FUNCTION_NUM_ARGS) ++#define BOOST_FUNCTION_VOID_MEMBER_INVOKER \ ++ BOOST_JOIN(void_member_invoker,BOOST_FUNCTION_NUM_ARGS) + #define BOOST_FUNCTION_GET_FUNCTION_INVOKER \ + BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS) + #define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER \ + BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS) + #define BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER \ + BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS) ++#define BOOST_FUNCTION_GET_MEMBER_INVOKER \ ++ BOOST_JOIN(get_member_invoker,BOOST_FUNCTION_NUM_ARGS) ++#define BOOST_FUNCTION_GET_INVOKER \ ++ BOOST_JOIN(get_invoker,BOOST_FUNCTION_NUM_ARGS) + #define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS) + + #ifndef BOOST_NO_VOID_RETURNS +@@ -70,16 +83,6 @@ + # define BOOST_FUNCTION_RETURN(X) X; return BOOST_FUNCTION_VOID_RETURN_TYPE () + #endif + +-#ifdef BOOST_MSVC +-# pragma warning(push) +-# pragma warning(disable: 4127) // conditional expression is constant. +-#endif +- +-#ifdef BOOST_MSVC +-# pragma warning(push) +-# pragma warning(disable: 4127) // conditional expression is constant. +-#endif +- + namespace boost { + namespace detail { + namespace function { +@@ -191,6 +194,44 @@ namespace boost { + } + }; + ++#if BOOST_FUNCTION_NUM_ARGS > 0 ++ /* Handle invocation of member pointers. */ ++ template< ++ typename MemberPtr, ++ typename R BOOST_FUNCTION_COMMA ++ BOOST_FUNCTION_TEMPLATE_PARMS ++ > ++ struct BOOST_FUNCTION_MEMBER_INVOKER ++ { ++ static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA ++ BOOST_FUNCTION_PARMS) ++ ++ { ++ MemberPtr* f = ++ reinterpret_cast(&function_obj_ptr.data); ++ return boost::mem_fn(*f)(BOOST_FUNCTION_ARGS); ++ } ++ }; ++ ++ template< ++ typename MemberPtr, ++ typename R BOOST_FUNCTION_COMMA ++ BOOST_FUNCTION_TEMPLATE_PARMS ++ > ++ struct BOOST_FUNCTION_VOID_MEMBER_INVOKER ++ { ++ static BOOST_FUNCTION_VOID_RETURN_TYPE ++ invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA ++ BOOST_FUNCTION_PARMS) ++ ++ { ++ MemberPtr* f = ++ reinterpret_cast(&function_obj_ptr.data); ++ BOOST_FUNCTION_RETURN(boost::mem_fn(*f)(BOOST_FUNCTION_ARGS)); ++ } ++ }; ++#endif ++ + template< + typename FunctionPtr, + typename R BOOST_FUNCTION_COMMA +@@ -254,12 +295,130 @@ namespace boost { + >::type type; + }; + ++#if BOOST_FUNCTION_NUM_ARGS > 0 ++ /* Retrieve the appropriate invoker for a member pointer. */ ++ template< ++ typename MemberPtr, ++ typename R BOOST_FUNCTION_COMMA ++ BOOST_FUNCTION_TEMPLATE_PARMS ++ > ++ struct BOOST_FUNCTION_GET_MEMBER_INVOKER ++ { ++ typedef typename mpl::if_c<(is_void::value), ++ BOOST_FUNCTION_VOID_MEMBER_INVOKER< ++ MemberPtr, ++ R BOOST_FUNCTION_COMMA ++ BOOST_FUNCTION_TEMPLATE_ARGS ++ >, ++ BOOST_FUNCTION_MEMBER_INVOKER< ++ MemberPtr, ++ R BOOST_FUNCTION_COMMA ++ BOOST_FUNCTION_TEMPLATE_ARGS ++ > ++ >::type type; ++ }; ++#endif ++ ++ /* Given the tag returned by get_function_tag, retrieve the ++ actual invoker that will be used for the given function ++ object. ++ ++ Each specialization contains an "apply" nested class template ++ that accepts the function object, return type, function ++ argument types, and allocator. The resulting "apply" class ++ contains two typedefs, "invoker_type" and "manager_type", ++ which correspond to the invoker and manager types. */ ++ template ++ struct BOOST_FUNCTION_GET_INVOKER { }; ++ ++ /* Retrieve the invoker for a function pointer. */ ++ template<> ++ struct BOOST_FUNCTION_GET_INVOKER ++ { ++ template ++ struct apply ++ { ++ typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER< ++ FunctionPtr, ++ R BOOST_FUNCTION_COMMA ++ BOOST_FUNCTION_TEMPLATE_ARGS ++ >::type ++ invoker_type; ++ ++ typedef functor_manager manager_type; ++ }; ++ }; ++ ++#if BOOST_FUNCTION_NUM_ARGS > 0 ++ /* Retrieve the invoker for a member pointer. */ ++ template<> ++ struct BOOST_FUNCTION_GET_INVOKER ++ { ++ template ++ struct apply ++ { ++ typedef typename BOOST_FUNCTION_GET_MEMBER_INVOKER< ++ MemberPtr, ++ R BOOST_FUNCTION_COMMA ++ BOOST_FUNCTION_TEMPLATE_ARGS ++ >::type ++ invoker_type; ++ ++ typedef functor_manager manager_type; ++ }; ++ }; ++#endif ++ ++ /* Retrieve the invoker for a function object. */ ++ template<> ++ struct BOOST_FUNCTION_GET_INVOKER ++ { ++ template ++ struct apply ++ { ++ typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER< ++ FunctionObj, ++ R BOOST_FUNCTION_COMMA ++ BOOST_FUNCTION_TEMPLATE_ARGS ++ >::type ++ invoker_type; ++ ++ typedef functor_manager manager_type; ++ }; ++ }; ++ ++ /* Retrieve the invoker for a reference to a function object. */ ++ template<> ++ struct BOOST_FUNCTION_GET_INVOKER ++ { ++ template ++ struct apply ++ { ++ typedef typename BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER< ++ typename RefWrapper::type, ++ R BOOST_FUNCTION_COMMA ++ BOOST_FUNCTION_TEMPLATE_ARGS ++ >::type ++ invoker_type; ++ ++ typedef reference_manager manager_type; ++ }; ++ }; ++ + /** + * vtable for a specific boost::function instance. + */ + template +- struct BOOST_FUNCTION_VTABLE : vtable_base ++ struct BOOST_FUNCTION_VTABLE + { + #ifndef BOOST_NO_VOID_RETURNS + typedef R result_type; +@@ -272,50 +431,25 @@ namespace boost { + BOOST_FUNCTION_TEMPLATE_ARGS); + + template +- BOOST_FUNCTION_VTABLE(F f) : vtable_base(), invoker(0) +- { +- init(f); +- } +- +- template +- bool assign_to(F f, function_buffer& functor) ++ bool assign_to(const F& f, function_buffer& functor) const + { + typedef typename get_function_tag::type tag; + return assign_to(f, functor, tag()); + } + +- void clear(function_buffer& functor) ++ void clear(function_buffer& functor) const + { +- if (manager) +- manager(functor, functor, destroy_functor_tag); ++ if (base.manager) ++ base.manager(functor, functor, destroy_functor_tag); + } +- ++#ifndef BOOST_NO_PRIVATE_IN_AGGREGATE + private: +- template +- void init(F f) +- { +- typedef typename get_function_tag::type tag; +- init(f, tag()); +- } +- ++#endif + // Function pointers + template +- void init(FunctionPtr /*f*/, function_ptr_tag) +- { +- typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER< +- FunctionPtr, +- R BOOST_FUNCTION_COMMA +- BOOST_FUNCTION_TEMPLATE_ARGS +- >::type +- actual_invoker_type; +- +- invoker = &actual_invoker_type::invoke; +- manager = &functor_manager::manage; +- } +- +- template + bool +- assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) ++ assign_to(FunctionPtr f, function_buffer& functor, ++ function_ptr_tag) const + { + this->clear(functor); + if (f) { +@@ -331,22 +465,13 @@ namespace boost { + // Member pointers + #if BOOST_FUNCTION_NUM_ARGS > 0 + template +- void init(MemberPtr f, member_ptr_tag) +- { +- // DPG TBD: Add explicit support for member function +- // objects, so we invoke through mem_fn() but we retain the +- // right target_type() values. +- this->init(mem_fn(f)); +- } +- +- template +- bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) ++ bool ++ assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const + { +- // DPG TBD: Add explicit support for member function +- // objects, so we invoke through mem_fn() but we retain the +- // right target_type() values. + if (f) { +- this->assign_to(mem_fn(f), functor); ++ // Always use the small-object optimization for member ++ // pointers. ++ assign_functor(f, functor, mpl::true_()); + return true; + } else { + return false; +@@ -355,24 +480,11 @@ namespace boost { + #endif // BOOST_FUNCTION_NUM_ARGS > 0 + + // Function objects +- template +- void init(FunctionObj /*f*/, function_obj_tag) +- { +- typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER< +- FunctionObj, +- R BOOST_FUNCTION_COMMA +- BOOST_FUNCTION_TEMPLATE_ARGS +- >::type +- actual_invoker_type; +- +- invoker = &actual_invoker_type::invoke; +- manager = &functor_manager::manage; +- } +- + // Assign to a function object using the small object optimization + template + void +- assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) ++ assign_functor(const FunctionObj& f, function_buffer& functor, ++ mpl::true_) const + { + new ((void*)&functor.data) FunctionObj(f); + } +@@ -380,7 +492,8 @@ namespace boost { + // Assign to a function object allocated on the heap. + template + void +- assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) ++ assign_functor(const FunctionObj& f, function_buffer& functor, ++ mpl::false_) const + { + #ifndef BOOST_NO_STD_ALLOCATOR + typedef typename Allocator::template rebind::other +@@ -400,7 +513,8 @@ namespace boost { + + template + bool +- assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) ++ assign_to(const FunctionObj& f, function_buffer& functor, ++ function_obj_tag) const + { + if (!boost::detail::function::has_empty_target(boost::addressof(f))) { + assign_functor(f, functor, +@@ -413,24 +527,9 @@ namespace boost { + + // Reference to a function object + template +- void +- init(const reference_wrapper& /*f*/, function_obj_ref_tag) +- { +- typedef typename BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER< +- FunctionObj, +- R BOOST_FUNCTION_COMMA +- BOOST_FUNCTION_TEMPLATE_ARGS +- >::type +- actual_invoker_type; +- +- invoker = &actual_invoker_type::invoke; +- manager = &reference_manager::get; +- } +- +- template + bool + assign_to(const reference_wrapper& f, +- function_buffer& functor, function_obj_ref_tag) ++ function_buffer& functor, function_obj_ref_tag) const + { + if (!boost::detail::function::has_empty_target(f.get_pointer())) { + // DPG TBD: We might need to detect constness of +@@ -445,6 +544,7 @@ namespace boost { + } + + public: ++ vtable_base base; + invoker_type invoker; + }; + } // end namespace function +@@ -456,6 +556,17 @@ namespace boost { + typename Allocator = BOOST_FUNCTION_DEFAULT_ALLOCATOR + > + class BOOST_FUNCTION_FUNCTION : public function_base ++ ++#if BOOST_FUNCTION_NUM_ARGS == 1 ++ ++ , public std::unary_function ++ ++#elif BOOST_FUNCTION_NUM_ARGS == 2 ++ ++ , public std::binary_function ++ ++#endif ++ + { + public: + #ifndef BOOST_NO_VOID_RETURNS +@@ -537,7 +648,7 @@ namespace boost { + if (this->empty()) + boost::throw_exception(bad_function_call()); + +- return static_cast(vtable)->invoker ++ return reinterpret_cast(vtable)->invoker + (this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS); + } + #else +@@ -561,12 +672,16 @@ namespace boost { + operator=(Functor BOOST_FUNCTION_TARGET_FIX(const &) f) + { + this->clear(); ++#ifndef BOOST_NO_EXCEPTIONS + try { + this->assign_to(f); + } catch (...) { + vtable = 0; + throw; + } ++#else ++ this->assign_to(f); ++#endif + return *this; + } + +@@ -592,12 +707,16 @@ namespace boost { + return *this; + + this->clear(); ++#ifndef BOOST_NO_EXCEPTIONS + try { + this->assign_to_own(f); + } catch (...) { + vtable = 0; + throw; + } ++#else ++ this->assign_to_own(f); ++#endif + return *this; + } + +@@ -615,7 +734,7 @@ namespace boost { + void clear() + { + if (vtable) { +- static_cast(vtable)->clear(this->functor); ++ reinterpret_cast(vtable)->clear(this->functor); + vtable = 0; + } + } +@@ -650,10 +769,24 @@ namespace boost { + } + + template +- void assign_to(Functor f) ++ void assign_to(const Functor& f) + { +- static vtable_type stored_vtable(f); +- if (stored_vtable.assign_to(f, functor)) vtable = &stored_vtable; ++ using detail::function::vtable_base; ++ ++ typedef typename detail::function::get_function_tag::type tag; ++ typedef detail::function::BOOST_FUNCTION_GET_INVOKER get_invoker; ++ typedef typename get_invoker:: ++ template apply ++ handler_type; ++ ++ typedef typename handler_type::invoker_type invoker_type; ++ typedef typename handler_type::manager_type manager_type; ++ ++ static const vtable_type stored_vtable = ++ { { &manager_type::manage }, &invoker_type::invoke }; ++ ++ if (stored_vtable.assign_to(f, functor)) vtable = &stored_vtable.base; + else vtable = 0; + } + }; +@@ -688,7 +821,7 @@ namespace boost { + if (this->empty()) + boost::throw_exception(bad_function_call()); + +- return static_cast(vtable)->invoker ++ return reinterpret_cast(vtable)->invoker + (this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS); + } + #endif +@@ -798,21 +931,14 @@ public: + } + }; + +-#ifdef BOOST_MSVC +-# pragma warning(pop) +-#endif +- + #undef BOOST_FUNCTION_PARTIAL_SPEC + #endif // have partial specialization + + } // end namespace boost + +-#ifdef BOOST_MSVC +-# pragma warning(pop) +-#endif +- + // Cleanup after ourselves... + #undef BOOST_FUNCTION_VTABLE ++#undef BOOST_FUNCTION_GET_INVOKER + #undef BOOST_FUNCTION_DEFAULT_ALLOCATOR + #undef BOOST_FUNCTION_COMMA + #undef BOOST_FUNCTION_FUNCTION +@@ -822,10 +948,12 @@ public: + #undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER + #undef BOOST_FUNCTION_FUNCTION_REF_INVOKER + #undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER ++#undef BOOST_FUNCTION_MEMBER_INVOKER ++#undef BOOST_FUNCTION_VOID_MEMBER_INVOKER + #undef BOOST_FUNCTION_GET_FUNCTION_INVOKER + #undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER + #undef BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER +-#undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER ++#undef BOOST_FUNCTION_GET_MEMBER_INVOKER + #undef BOOST_FUNCTION_TEMPLATE_PARMS + #undef BOOST_FUNCTION_TEMPLATE_ARGS + #undef BOOST_FUNCTION_PARMS +@@ -835,3 +963,7 @@ public: + #undef BOOST_FUNCTION_ARG_TYPES + #undef BOOST_FUNCTION_VOID_RETURN_TYPE + #undef BOOST_FUNCTION_RETURN ++ ++#if defined(BOOST_MSVC) ++# pragma warning( pop ) ++#endif -- cgit v1.2.3