summaryrefslogtreecommitdiff
path: root/external
diff options
context:
space:
mode:
authorKhaled Hosny <khaledhosny@eglug.org>2013-10-17 01:15:08 +0200
committerBjörn Michaelsen <bjoern.michaelsen@canonical.com>2013-10-17 10:39:39 +0000
commit174e24ffff2f76da94df3bdefa5416c5f2256b78 (patch)
treeb580a19675daff3882ed415cb36711a17ced94cc /external
parent694248e9785e943bfc83d119304a5b18b683e21f (diff)
fdo#70393: move boost to a subdir of external
Change-Id: Ib6aa36e296dfc1237463c4257f7ea1bd1fe72a1b Reviewed-on: https://gerrit.libreoffice.org/6282 Reviewed-by: Björn Michaelsen <bjoern.michaelsen@canonical.com> Tested-by: Björn Michaelsen <bjoern.michaelsen@canonical.com>
Diffstat (limited to 'external')
-rw-r--r--external/Module_external.mk1
-rw-r--r--external/boost/Makefile7
-rw-r--r--external/boost/Module_boost.mk24
-rw-r--r--external/boost/README4
-rw-r--r--external/boost/StaticLibrary_boostdatetime.mk30
-rw-r--r--external/boost/StaticLibrary_boostsystem.mk27
-rw-r--r--external/boost/StaticLibrary_boostthread.mk29
-rw-r--r--external/boost/UnpackedTarball_boost.mk61
-rw-r--r--external/boost/boost.3780.aliasing.patch23
-rw-r--r--external/boost/boost.4100.warnings.patch19
-rw-r--r--external/boost/boost.4510.warnings.patch26
-rw-r--r--external/boost/boost.4713.warnings.patch282
-rw-r--r--external/boost/boost.6142.warnings.patch.138
-rw-r--r--external/boost/boost.6369.warnings.patch323
-rw-r--r--external/boost/boost.6397.warnings.patch568
-rw-r--r--external/boost/boost.7551.unusedvars.patch10
-rw-r--r--external/boost/boost.auto_link.patch40
-rw-r--r--external/boost/boost.endian.patch13
-rw-r--r--external/boost/boost.gcc47679.patch61
-rw-r--r--external/boost/boost.libcdr.warnings.patch.1539
-rw-r--r--external/boost/boost.loplugin.patch19
-rw-r--r--external/boost/boost.std.move.patch20
-rw-r--r--external/boost/boost.transform_width.patch11
-rw-r--r--external/boost/boost.vc2012.patch25
-rw-r--r--external/boost/boost.wdeprecated-auto_ptr.patch.091
-rw-r--r--external/boost/boost.wdeprecated-register.patch.036
-rw-r--r--external/boost/boost.windows.patch12
-rw-r--r--external/boost/boost.wshadow.patch330
-rw-r--r--external/boost/boost.wundef.patch119
-rw-r--r--external/boost/boost.wuninitialized.patch10
-rw-r--r--external/boost/boost.wunused.patch50
-rw-r--r--external/boost/boost_1_44_0-clang-warnings.patch50
-rw-r--r--external/boost/boost_1_44_0-gcc4.8.patch448
-rw-r--r--external/boost/boost_1_44_0-unused-parameters.patch916
34 files changed, 4262 insertions, 0 deletions
diff --git a/external/Module_external.mk b/external/Module_external.mk
index 2aca373c3363..627b4243cefe 100644
--- a/external/Module_external.mk
+++ b/external/Module_external.mk
@@ -20,6 +20,7 @@ endif
$(eval $(call gb_Module_add_moduledirs,external,\
$(call gb_Helper_optional,AFMS,afms) \
$(call gb_Helper_optional,APACHE_COMMONS,apache-commons) \
+ $(call gb_Helper_optional,BOOST,boost) \
$(call gb_Helper_optional,HARFBUZZ,harfbuzz) \
$(call gb_Helper_optional,LIBPNG,libpng) \
))
diff --git a/external/boost/Makefile b/external/boost/Makefile
new file mode 100644
index 000000000000..ccb1c85a04da
--- /dev/null
+++ b/external/boost/Makefile
@@ -0,0 +1,7 @@
+# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*-
+
+module_directory:=$(dir $(realpath $(firstword $(MAKEFILE_LIST))))
+
+include $(module_directory)/../solenv/gbuild/partial_build.mk
+
+# vim: set noet sw=4 ts=4:
diff --git a/external/boost/Module_boost.mk b/external/boost/Module_boost.mk
new file mode 100644
index 000000000000..1a21a770476d
--- /dev/null
+++ b/external/boost/Module_boost.mk
@@ -0,0 +1,24 @@
+# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*-
+#
+# This file is part of the LibreOffice project.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+
+$(eval $(call gb_Module_Module,boost))
+
+$(eval $(call gb_Module_add_targets,boost,\
+ StaticLibrary_boostdatetime \
+ StaticLibrary_boostsystem \
+ UnpackedTarball_boost \
+))
+
+ifeq ($(OS),WNT)
+$(eval $(call gb_Module_add_targets,boost,\
+ StaticLibrary_boostthread \
+))
+endif
+
+# vim: set noet sw=4 ts=4:
diff --git a/external/boost/README b/external/boost/README
new file mode 100644
index 000000000000..7e6426bf939b
--- /dev/null
+++ b/external/boost/README
@@ -0,0 +1,4 @@
+From [http://www.boost.org/].
+
+Apart from the spirit parsing framework, LibreOffice currently mostly
+uses the smart pointers, pool memory and binders functionality.
diff --git a/external/boost/StaticLibrary_boostdatetime.mk b/external/boost/StaticLibrary_boostdatetime.mk
new file mode 100644
index 000000000000..bea82da1cf31
--- /dev/null
+++ b/external/boost/StaticLibrary_boostdatetime.mk
@@ -0,0 +1,30 @@
+# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*-
+#
+# This file is part of the LibreOffice project.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+
+$(eval $(call gb_StaticLibrary_StaticLibrary,boostdatetime))
+
+$(eval $(call gb_StaticLibrary_set_warnings_not_errors,boostdatetime))
+
+# disable "auto link" "feature" on MSVC
+$(eval $(call gb_StaticLibrary_add_defs,boostdatetime,\
+ -DBOOST_ALL_NO_LIB \
+))
+
+$(eval $(call gb_StaticLibrary_use_external,boostdatetime,boost_headers))
+
+$(eval $(call gb_StaticLibrary_set_generated_cxx_suffix,boostdatetime,cpp))
+
+$(eval $(call gb_StaticLibrary_add_generated_exception_objects,boostdatetime,\
+ UnpackedTarball/boost/libs/date_time/src/gregorian/date_generators \
+ UnpackedTarball/boost/libs/date_time/src/gregorian/gregorian_types \
+ UnpackedTarball/boost/libs/date_time/src/gregorian/greg_month \
+ UnpackedTarball/boost/libs/date_time/src/gregorian/greg_weekday \
+))
+
+# vim: set noet sw=4 ts=4:
diff --git a/external/boost/StaticLibrary_boostsystem.mk b/external/boost/StaticLibrary_boostsystem.mk
new file mode 100644
index 000000000000..053321b3f02f
--- /dev/null
+++ b/external/boost/StaticLibrary_boostsystem.mk
@@ -0,0 +1,27 @@
+# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*-
+#
+# This file is part of the LibreOffice project.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+
+$(eval $(call gb_StaticLibrary_StaticLibrary,boostsystem))
+
+$(eval $(call gb_StaticLibrary_set_warnings_not_errors,boostsystem))
+
+# disable "auto link" "feature" on MSVC
+$(eval $(call gb_StaticLibrary_add_defs,boostsystem,\
+ -DBOOST_ALL_NO_LIB \
+))
+
+$(eval $(call gb_StaticLibrary_use_external,boostsystem,boost_headers))
+
+$(eval $(call gb_StaticLibrary_set_generated_cxx_suffix,boostsystem,cpp))
+
+$(eval $(call gb_StaticLibrary_add_generated_exception_objects,boostsystem,\
+ UnpackedTarball/boost/libs/system/src/error_code \
+))
+
+# vim: set noet sw=4 ts=4:
diff --git a/external/boost/StaticLibrary_boostthread.mk b/external/boost/StaticLibrary_boostthread.mk
new file mode 100644
index 000000000000..41b6765e2da3
--- /dev/null
+++ b/external/boost/StaticLibrary_boostthread.mk
@@ -0,0 +1,29 @@
+# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*-
+#
+# This file is part of the LibreOffice project.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+
+$(eval $(call gb_StaticLibrary_StaticLibrary,boostthread))
+
+$(eval $(call gb_StaticLibrary_set_warnings_not_errors,boostthread))
+
+# disable "auto link" "feature" on MSVC
+$(eval $(call gb_StaticLibrary_add_defs,boostthread,\
+ -DBOOST_ALL_NO_LIB \
+))
+
+$(eval $(call gb_StaticLibrary_use_external,boostthread,boost_headers))
+
+$(eval $(call gb_StaticLibrary_set_generated_cxx_suffix,boostthread,cpp))
+
+$(eval $(call gb_StaticLibrary_add_generated_exception_objects,boostthread,\
+ UnpackedTarball/boost/libs/thread/src/win32/thread \
+ UnpackedTarball/boost/libs/thread/src/win32/tss_dll \
+ UnpackedTarball/boost/libs/thread/src/win32/tss_pe \
+))
+
+# vim: set noet sw=4 ts=4:
diff --git a/external/boost/UnpackedTarball_boost.mk b/external/boost/UnpackedTarball_boost.mk
new file mode 100644
index 000000000000..777a8c4417eb
--- /dev/null
+++ b/external/boost/UnpackedTarball_boost.mk
@@ -0,0 +1,61 @@
+# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*-
+#
+# This file is part of the LibreOffice project.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+
+boost_patches :=
+#https://svn.boost.org/trac/boost/ticket/3780
+boost_patches += boost.3780.aliasing.patch
+#https://svn.boost.org/trac/boost/ticket/4713
+boost_patches += boost.4713.warnings.patch
+#http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47679
+boost_patches += boost.gcc47679.patch
+#https://svn.boost.org/trac/boost/ticket/6369
+boost_patches += boost.6369.warnings.patch
+#https://svn.boost.org/trac/boost/ticket/6397
+boost_patches += boost.6397.warnings.patch
+#https://svn.boost.org/trac/boost/ticket/7551
+boost_patches += boost.7551.unusedvars.patch
+boost_patches += boost.4100.warnings.patch
+boost_patches += boost.4510.warnings.patch
+#https://svn.boost.org/trac/boost/ticket/6142
+boost_patches += boost.6142.warnings.patch.1
+boost_patches += boost.libcdr.warnings.patch.1
+
+# Help static analysis tools (see SAL_UNUSED_PARAMETER in sal/types.h):
+ifeq (GCC,$(COM))
+boost_patches += boost_1_44_0-unused-parameters.patch
+endif
+
+# Clang warnings:
+boost_patches += boost_1_44_0-clang-warnings.patch
+
+boost_patches += boost_1_44_0-gcc4.8.patch
+
+boost_patches += boost.auto_link.patch
+boost_patches += boost.endian.patch
+boost_patches += boost.loplugin.patch
+boost_patches += boost.std.move.patch
+boost_patches += boost.transform_width.patch
+boost_patches += boost.wundef.patch
+boost_patches += boost.wunused.patch
+boost_patches += boost.wshadow.patch
+boost_patches += boost.wdeprecated-register.patch.0
+boost_patches += boost.wuninitialized.patch
+boost_patches += boost.wdeprecated-auto_ptr.patch.0
+
+$(eval $(call gb_UnpackedTarball_UnpackedTarball,boost))
+
+$(eval $(call gb_UnpackedTarball_set_tarball,boost,$(BOOST_TARBALL)))
+
+$(eval $(call gb_UnpackedTarball_set_patchlevel,boost,3))
+
+$(eval $(call gb_UnpackedTarball_add_patches,boost,\
+ $(foreach patch,$(boost_patches),external/boost/$(patch)) \
+))
+
+# vim: set noet sw=4 ts=4:
diff --git a/external/boost/boost.3780.aliasing.patch b/external/boost/boost.3780.aliasing.patch
new file mode 100644
index 000000000000..d9cff1b7aa99
--- /dev/null
+++ b/external/boost/boost.3780.aliasing.patch
@@ -0,0 +1,23 @@
+--- misc/boost_1_44_0/boost/function/function_base.hpp
++++ misc/build/boost_1_44_0/boost/function/function_base.hpp
+@@ -314,17 +322,17 @@
+ {
+ if (op == clone_functor_tag || op == move_functor_tag) {
+ const functor_type* in_functor =
+- reinterpret_cast<const functor_type*>(&in_buffer.data);
++ static_cast<const functor_type*>(static_cast<void*>(&in_buffer.data));
+ new (reinterpret_cast<void*>(&out_buffer.data)) functor_type(*in_functor);
+
+ if (op == move_functor_tag) {
+- functor_type* f = reinterpret_cast<functor_type*>(&in_buffer.data);
++ functor_type* f = static_cast<functor_type*>(static_cast<void*>(&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.
+- functor_type* f = reinterpret_cast<functor_type*>(&out_buffer.data);
++ functor_type* f = static_cast<functor_type*>(static_cast<void*>(&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) {
diff --git a/external/boost/boost.4100.warnings.patch b/external/boost/boost.4100.warnings.patch
new file mode 100644
index 000000000000..ea475777c7f2
--- /dev/null
+++ b/external/boost/boost.4100.warnings.patch
@@ -0,0 +1,19 @@
+--- misc/boost_1_44_0/boost/concept/detail/msvc.hpp
++++ misc/build/boost_1_44_0/boost/concept/detail/msvc.hpp
+@@ -12,6 +12,9 @@
+ # include <boost/mpl/if.hpp>
+ # endif
+
++// disable spurious "unreferenced formal parameter" warnings
++#pragma warning( push )
++#pragma warning( disable: 4100 )
+
+ namespace boost { namespace concepts {
+
+@@ -111,4 +114,6 @@
+ # endif
+ }}
+
++#pragma warning( pop )
++
+ #endif // BOOST_CONCEPT_CHECK_MSVC_DWA2006429_HPP
diff --git a/external/boost/boost.4510.warnings.patch b/external/boost/boost.4510.warnings.patch
new file mode 100644
index 000000000000..11fdaceef1e2
--- /dev/null
+++ b/external/boost/boost.4510.warnings.patch
@@ -0,0 +1,26 @@
+--- misc/boost_1_44_0/boost/multi_array/concept_checks.hpp
++++ misc/build/boost_1_44_0/boost/multi_array/concept_checks.hpp
+@@ -56,6 +56,13 @@
+
+ } // namespace detail
+
++// MSVC 2008 produces 2 warnings "default constructor could not be generated"
++// here that run over ~100 lines :(
++#ifdef _MSC_VER
++#pragma warning(push,1)
++#pragma warning(disable: 4510)
++#pragma warning(disable: 4610)
++#endif
+
+ template <typename Array, std::size_t NumDims >
+ struct ConstMultiArrayConcept
+@@ -117,6 +124,9 @@
+ index_range range;
+ };
+
++#ifdef _MSC_VER
++#pragma warning(pop)
++#endif
+
+ template <typename Array, std::size_t NumDims >
+ struct MutableMultiArrayConcept
diff --git a/external/boost/boost.4713.warnings.patch b/external/boost/boost.4713.warnings.patch
new file mode 100644
index 000000000000..7a5726e032fd
--- /dev/null
+++ b/external/boost/boost.4713.warnings.patch
@@ -0,0 +1,282 @@
+--- misc/boost_1_44_0/boost/date_time/date_names_put.hpp 2008-02-27 21:00:24.000000000 +0100
++++ misc/build/boost_1_44_0/boost/date_time/date_names_put.hpp 2011-10-05 16:58:58.413575307 +0200
+@@ -218,14 +218,14 @@
+ const charT* const weekday_long_names[],
+ charT separator_char = '-',
+ ymd_order_spec order_spec = ymd_order_iso,
+- month_format_spec month_format = month_as_short_string) :
++ month_format_spec month_format_ = month_as_short_string) :
+ month_short_names_(month_short_names),
+ month_long_names_(month_long_names),
+ special_value_names_(special_value_names),
+ weekday_short_names_(weekday_short_names),
+ weekday_long_names_(weekday_long_names),
+ order_spec_(order_spec),
+- month_format_spec_(month_format)
++ month_format_spec_(month_format_)
+ {
+ separator_char_[0] = separator_char;
+ separator_char_[1] = '\0';
+--- misc/boost_1_44_0/boost/ptr_container/detail/map_iterator.hpp 2008-06-24 22:37:35.000000000 +0200
++++ misc/build/boost_1_44_0/boost/ptr_container/detail/map_iterator.hpp 2011-02-04 16:39:19.000000000 +0100
+@@ -49,7 +49,7 @@
+ : first(rp->first), second(rp->second)
+ { }
+
+- const ref_pair* const operator->() const
++ const ref_pair* operator->() const
+ {
+ return this;
+ }
+--- misc/boost_1_44_0/boost/ptr_container/ptr_map_adapter.hpp 2008-06-24 22:37:35.000000000 +0200
++++ misc/build/boost_1_44_0/boost/ptr_container/ptr_map_adapter.hpp 2011-02-04 16:39:19.000000000 +0100
+@@ -477,6 +477,7 @@
+ }
+
+ ptr_map_adapter( const ptr_map_adapter& r )
++ : base_type()
+ {
+ map_basic_clone_and_insert( r.begin(), r.end() );
+ }
+--- misc/boost_1_44_0/boost/ptr_container/ptr_sequence_adapter.hpp 2009-11-01 12:07:12.000000000 +0100
++++ misc/build/boost_1_44_0/boost/ptr_container/ptr_sequence_adapter.hpp 2011-02-04 16:39:19.000000000 +0100
+@@ -476,19 +476,19 @@
+ public: // C-array support
+
+ void transfer( iterator before, value_type* from,
+- size_type size, bool delete_from = true ) // strong
++ size_type size_, bool delete_from = true ) // strong
+ {
+ BOOST_ASSERT( from != 0 );
+ if( delete_from )
+ {
+ BOOST_DEDUCED_TYPENAME base_type::scoped_deleter
+- deleter( from, size ); // nothrow
+- this->base().insert( before.base(), from, from + size ); // strong
++ deleter( from, size_ ); // nothrow
++ this->base().insert( before.base(), from, from + size_ ); // strong
+ deleter.release(); // nothrow
+ }
+ else
+ {
+- this->base().insert( before.base(), from, from + size ); // strong
++ this->base().insert( before.base(), from, from + size_ ); // strong
+ }
+ }
+
+@@ -671,6 +671,7 @@
+ void range_check_impl( iterator first, iterator last,
+ std::random_access_iterator_tag )
+ {
++ (void)first; (void)last;
+ BOOST_ASSERT( first <= last && "out of range unique()/erase_if()" );
+ BOOST_ASSERT( this->begin() <= first && "out of range unique()/erase_if()" );
+ BOOST_ASSERT( last <= this->end() && "out of range unique()/erase_if)(" );
+--- misc/boost_1_44_0/boost/spirit/home/classic/symbols/symbols.hpp 2008-06-22 17:05:38.000000000 +0200
++++ misc/build/boost_1_44_0/boost/spirit/home/classic/symbols/symbols.hpp 2011-02-04 16:39:19.000000000 +0100
+@@ -102,13 +102,13 @@
+ {
+ typedef typename ScannerT::iterator_t iterator_t;
+ iterator_t first = scan.first;
+- typename SetT::search_info result = SetT::find(scan);
++ typename SetT::search_info result_ = SetT::find(scan);
+
+- if (result.data)
++ if (result_.data)
+ return scan.
+ create_match(
+- result.length,
+- symbol_ref_t(*result.data),
++ result_.length,
++ symbol_ref_t(*result_.data),
+ first,
+ scan.first);
+ else
+--- misc/boost_1_44_0/boost/ptr_container/exception.hpp 2011-02-05 09:42:56.074932485 +0000
++++ misc/build/boost_1_44_0/boost/ptr_container/exception.hpp 2011-02-05 09:43:00.350931536 +0000
+@@ -24,7 +24,7 @@
+ {
+ const char* what_;
+ public:
+- bad_ptr_container_operation( const char* what ) : what_( what )
++ bad_ptr_container_operation( const char* _what ) : what_( _what )
+ { }
+
+ virtual const char* what() const throw()
+@@ -38,7 +38,7 @@
+ class bad_index : public bad_ptr_container_operation
+ {
+ public:
+- bad_index( const char* what ) : bad_ptr_container_operation( what )
++ bad_index( const char* _what ) : bad_ptr_container_operation( _what )
+ { }
+ };
+
+--- misc/boost_1_44_0/boost/ptr_container/detail/reversible_ptr_container.hpp 2011-02-05 09:49:30.373931807 +0000
++++ misc/build/boost_1_44_0/boost/ptr_container/detail/reversible_ptr_container.hpp 2011-02-05 09:49:34.804931932 +0000
+@@ -278,9 +278,9 @@
+
+ private:
+ template< class ForwardIterator >
+- ForwardIterator advance( ForwardIterator begin, size_type n )
++ ForwardIterator advance( ForwardIterator begin_, size_type n )
+ {
+- ForwardIterator iter = begin;
++ ForwardIterator iter = begin_;
+ std::advance( iter, n );
+ return iter;
+ }
+--- misc/boost_1_44_0/boost/ptr_container/detail/static_move_ptr.hpp 2011-02-05 09:55:44.846931338 +0000
++++ misc/build/boost_1_44_0/boost/ptr_container/detail/static_move_ptr.hpp 2011-02-05 09:56:42.760931701 +0000
+@@ -151,7 +151,7 @@
+ deleter_const_reference get_deleter() const { return impl_.second(); }
+ private:
+ template<typename TT, typename DD>
+- void check(const static_move_ptr<TT, DD>& ptr)
++ void check(const static_move_ptr<TT, DD>&)
+ {
+ typedef move_ptrs::is_smart_ptr_convertible<TT, T> convertible;
+ BOOST_STATIC_ASSERT(convertible::value);
+--- misc/boost_1_44_0/boost/ptr_container/detail/move.hpp 2011-02-05 10:01:21.156931884 +0000
++++ misc/build/boost_1_44_0/boost/ptr_container/detail/move.hpp 2011-02-05 10:01:14.160931007 +0000
+@@ -20,7 +20,7 @@
+ template<typename Ptr>
+ class move_source {
+ public:
+- move_source(Ptr& ptr) : ptr_(ptr) {}
++ move_source(Ptr& _ptr) : ptr_(_ptr) {}
+ Ptr& ptr() const { return ptr_; }
+ private:
+ Ptr& ptr_;
+--- misc/boost_1_44_0/boost/spirit/home/classic/core/non_terminal/subrule.hpp 2011-02-08 09:24:50.817320629 +0000
++++ misc/build/boost_1_44_0/boost/spirit/home/classic/core/non_terminal/subrule.hpp 2011-02-08 09:25:20.496639901 +0000
+@@ -210,7 +210,7 @@
+ subrule_list<
+ subrule_parser<ID2, DefT2, ContextT2>,
+ nil_t> >
+- operator,(subrule_parser<ID2, DefT2, ContextT2> const& rhs) const
++ operator,(subrule_parser<ID2, DefT2, ContextT2> const& rhs_) const
+ {
+ return subrule_list<
+ self_t,
+@@ -220,7 +220,7 @@
+ *this,
+ subrule_list<
+ subrule_parser<ID2, DefT2, ContextT2>, nil_t>(
+- rhs, nil_t()));
++ rhs_, nil_t()));
+ }
+
+ typename DefT::embed_t rhs;
+--- misc/boost_1_44_0/boost/ptr_container/ptr_sequence_adapter.hpp 2011-02-09 08:49:00.416529470 +0000
++++ misc/build/boost_1_44_0/boost/ptr_container/ptr_sequence_adapter.hpp 2011-02-09 08:50:44.607653864 +0000
+@@ -510,72 +510,72 @@
+
+ public: // resize
+
+- void resize( size_type size ) // basic
++ void resize( size_type size_ ) // basic
+ {
+ size_type old_size = this->size();
+- if( old_size > size )
++ if( old_size > size_ )
+ {
+- this->erase( boost::next( this->begin(), size ), this->end() );
++ this->erase( boost::next( this->begin(), size_ ), this->end() );
+ }
+- else if( size > old_size )
++ else if( size_ > old_size )
+ {
+- for( ; old_size != size; ++old_size )
++ for( ; old_size != size_; ++old_size )
+ this->push_back( new BOOST_DEDUCED_TYPENAME
+ boost::remove_pointer<value_type>::type() );
+ }
+
+- BOOST_ASSERT( this->size() == size );
++ BOOST_ASSERT( this->size() == size_ );
+ }
+
+- void resize( size_type size, value_type to_clone ) // basic
++ void resize( size_type size_, value_type to_clone ) // basic
+ {
+ size_type old_size = this->size();
+- if( old_size > size )
++ if( old_size > size_ )
+ {
+- this->erase( boost::next( this->begin(), size ), this->end() );
++ this->erase( boost::next( this->begin(), size_ ), this->end() );
+ }
+- else if( size > old_size )
++ else if( size_ > old_size )
+ {
+- for( ; old_size != size; ++old_size )
++ for( ; old_size != size_; ++old_size )
+ this->push_back( this->null_policy_allocate_clone( to_clone ) );
+ }
+
+- BOOST_ASSERT( this->size() == size );
++ BOOST_ASSERT( this->size() == size_ );
+ }
+
+- void rresize( size_type size ) // basic
++ void rresize( size_type size_ ) // basic
+ {
+ size_type old_size = this->size();
+- if( old_size > size )
++ if( old_size > size_ )
+ {
+ this->erase( this->begin(),
+- boost::next( this->begin(), old_size - size ) );
++ boost::next( this->begin(), old_size - size_ ) );
+ }
+- else if( size > old_size )
++ else if( size_ > old_size )
+ {
+- for( ; old_size != size; ++old_size )
++ for( ; old_size != size_; ++old_size )
+ this->push_front( new BOOST_DEDUCED_TYPENAME
+ boost::remove_pointer<value_type>::type() );
+ }
+
+- BOOST_ASSERT( this->size() == size );
++ BOOST_ASSERT( this->size() == size_ );
+ }
+
+- void rresize( size_type size, value_type to_clone ) // basic
++ void rresize( size_type size_, value_type to_clone ) // basic
+ {
+ size_type old_size = this->size();
+- if( old_size > size )
++ if( old_size > size_ )
+ {
+ this->erase( this->begin(),
+- boost::next( this->begin(), old_size - size ) );
++ boost::next( this->begin(), old_size - size_ ) );
+ }
+- else if( size > old_size )
++ else if( size_ > old_size )
+ {
+- for( ; old_size != size; ++old_size )
++ for( ; old_size != size_; ++old_size )
+ this->push_front( this->null_policy_allocate_clone( to_clone ) );
+ }
+
+- BOOST_ASSERT( this->size() == size );
++ BOOST_ASSERT( this->size() == size_ );
+ }
+
+ public: // algorithms
+--- misc/boost_1_44_0/boost/ptr_container/detail/reversible_ptr_container.hpp 2011-03-04 11:33:36.269274940 +0000
++++ misc/build/boost_1_44_0/boost/ptr_container/detail/reversible_ptr_container.hpp 2011-03-04 11:33:36.269274940 +0000
+@@ -259,6 +259,10 @@
+
+ static void enforce_null_policy( const Ty_* x, const char* msg )
+ {
++#ifdef BOOST_PTR_CONTAINER_NO_EXCEPTIONS
++ (void)x;
++ (void)msg;
++#endif
+ if( !allow_null )
+ {
+ BOOST_PTR_CONTAINER_THROW_EXCEPTION( 0 == x && "null not allowed",
diff --git a/external/boost/boost.6142.warnings.patch.1 b/external/boost/boost.6142.warnings.patch.1
new file mode 100644
index 000000000000..b38efd90d16e
--- /dev/null
+++ b/external/boost/boost.6142.warnings.patch.1
@@ -0,0 +1,38 @@
+--- a/boost/mpl/has_xxx.hpp.orig 2011-11-18 13:45:00.000000000 +0100
++++ b/boost/mpl/has_xxx.hpp 2011-11-18 13:47:19.000000000 +0100
+@@ -341,7 +341,7 @@
+ ) \
+ /**/
+
+-# if !BOOST_MPL_HAS_XXX_NO_EXPLICIT_TEST_FUNCTION
++# if !defined(BOOST_MPL_HAS_XXX_NO_EXPLICIT_TEST_FUNCTION) || !BOOST_MPL_HAS_XXX_NO_EXPLICIT_TEST_FUNCTION
+ # define BOOST_MPL_HAS_MEMBER_REJECT(args, member_macro) \
+ template< typename V > \
+ static boost::mpl::aux::no_tag \
+@@ -354,7 +354,7 @@
+ /**/
+ # endif
+
+-# if !BOOST_MPL_HAS_XXX_NO_WRAPPED_TYPES
++# if !defined(BOOST_MPL_HAS_XXX_NO_WRAPPED_TYPES) || !BOOST_MPL_HAS_XXX_NO_WRAPPED_TYPES
+ # define BOOST_MPL_HAS_MEMBER_MULTI_ACCEPT(z, n, args) \
+ template< typename V > \
+ static boost::mpl::aux::yes_tag \
+@@ -383,7 +383,7 @@
+ /**/
+ # endif
+
+-# if !BOOST_MPL_HAS_XXX_NO_EXPLICIT_TEST_FUNCTION
++# if !defined(BOOST_MPL_HAS_XXX_NO_EXPLICIT_TEST_FUNCTION) || !BOOST_MPL_HAS_XXX_NO_EXPLICIT_TEST_FUNCTION
+ # define BOOST_MPL_HAS_MEMBER_TEST(args) \
+ sizeof(BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)< U >(0)) \
+ == sizeof(boost::mpl::aux::yes_tag) \
+@@ -456,7 +456,7 @@
+ ) \
+ /**/
+
+-# if BOOST_MPL_HAS_XXX_NEEDS_TEMPLATE_SFINAE
++# if defined(BOOST_MPL_HAS_XXX_NEEDS_TEMPLATE_SFINAE) && BOOST_MPL_HAS_XXX_NEEDS_TEMPLATE_SFINAE
+
+ # if !defined(BOOST_MPL_HAS_XXX_NEEDS_NAMESPACE_LEVEL_SUBSTITUTE)
+ # if BOOST_WORKAROUND(BOOST_MSVC, <= 1400)
diff --git a/external/boost/boost.6369.warnings.patch b/external/boost/boost.6369.warnings.patch
new file mode 100644
index 000000000000..81a5eac655a5
--- /dev/null
+++ b/external/boost/boost.6369.warnings.patch
@@ -0,0 +1,323 @@
+--- misc/boost_1_44_0/boost/date_time/gregorian/gregorian_io.hpp 2012-01-08 20:16:41.321760852 +0000
++++ misc/build/boost_1_44_0/boost/date_time/gregorian/gregorian_io.hpp 2012-01-08 20:25:43.233484675 +0000
+@@ -77,14 +77,14 @@
+ typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
+ if (strm_sentry) {
+ try {
+- typedef typename date_time::date_input_facet<date, CharT> date_input_facet;
++ typedef typename date_time::date_input_facet<date, CharT> lcl_date_input_facet;
+
+ std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
+- if(std::has_facet<date_input_facet>(is.getloc())) {
+- std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, d);
++ if(std::has_facet<lcl_date_input_facet>(is.getloc())) {
++ std::use_facet<lcl_date_input_facet>(is.getloc()).get(sit, str_end, is, d);
+ }
+ else {
+- date_input_facet* f = new date_input_facet();
++ lcl_date_input_facet* f = new lcl_date_input_facet();
+ std::locale l = std::locale(is.getloc(), f);
+ is.imbue(l);
+ f->get(sit, str_end, is, d);
+@@ -138,14 +138,14 @@
+ typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
+ if (strm_sentry) {
+ try {
+- typedef typename date_time::date_input_facet<date, CharT> date_input_facet;
++ typedef typename date_time::date_input_facet<date, CharT> lcl_date_input_facet;
+
+ std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
+- if(std::has_facet<date_input_facet>(is.getloc())) {
+- std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, dd);
++ if(std::has_facet<lcl_date_input_facet>(is.getloc())) {
++ std::use_facet<lcl_date_input_facet>(is.getloc()).get(sit, str_end, is, dd);
+ }
+ else {
+- date_input_facet* f = new date_input_facet();
++ lcl_date_input_facet* f = new lcl_date_input_facet();
+ std::locale l = std::locale(is.getloc(), f);
+ is.imbue(l);
+ f->get(sit, str_end, is, dd);
+@@ -202,14 +202,14 @@
+ typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
+ if (strm_sentry) {
+ try {
+- typedef typename date_time::date_input_facet<date, CharT> date_input_facet;
++ typedef typename date_time::date_input_facet<date, CharT> lcl_date_input_facet;
+
+ std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
+- if(std::has_facet<date_input_facet>(is.getloc())) {
+- std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, dp);
++ if(std::has_facet<lcl_date_input_facet>(is.getloc())) {
++ std::use_facet<lcl_date_input_facet>(is.getloc()).get(sit, str_end, is, dp);
+ }
+ else {
+- date_input_facet* f = new date_input_facet();
++ lcl_date_input_facet* f = new lcl_date_input_facet();
+ std::locale l = std::locale(is.getloc(), f);
+ is.imbue(l);
+ f->get(sit, str_end, is, dp);
+@@ -261,14 +261,14 @@
+ typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
+ if (strm_sentry) {
+ try {
+- typedef typename date_time::date_input_facet<date, CharT> date_input_facet;
++ typedef typename date_time::date_input_facet<date, CharT> lcl_date_input_facet;
+
+ std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
+- if(std::has_facet<date_input_facet>(is.getloc())) {
+- std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, m);
++ if(std::has_facet<lcl_date_input_facet>(is.getloc())) {
++ std::use_facet<lcl_date_input_facet>(is.getloc()).get(sit, str_end, is, m);
+ }
+ else {
+- date_input_facet* f = new date_input_facet();
++ lcl_date_input_facet* f = new lcl_date_input_facet();
+ std::locale l = std::locale(is.getloc(), f);
+ is.imbue(l);
+ f->get(sit, str_end, is, m);
+@@ -318,14 +318,14 @@
+ typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
+ if (strm_sentry) {
+ try {
+- typedef typename date_time::date_input_facet<date, CharT> date_input_facet;
++ typedef typename date_time::date_input_facet<date, CharT> lcl_date_input_facet;
+
+ std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
+- if(std::has_facet<date_input_facet>(is.getloc())) {
+- std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, wd);
++ if(std::has_facet<lcl_date_input_facet>(is.getloc())) {
++ std::use_facet<lcl_date_input_facet>(is.getloc()).get(sit, str_end, is, wd);
+ }
+ else {
+- date_input_facet* f = new date_input_facet();
++ lcl_date_input_facet* f = new lcl_date_input_facet();
+ std::locale l = std::locale(is.getloc(), f);
+ is.imbue(l);
+ f->get(sit, str_end, is, wd);
+@@ -359,14 +359,14 @@
+ typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
+ if (strm_sentry) {
+ try {
+- typedef typename date_time::date_input_facet<date, CharT> date_input_facet;
++ typedef typename date_time::date_input_facet<date, CharT> lcl_date_input_facet;
+
+ std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
+- if(std::has_facet<date_input_facet>(is.getloc())) {
+- std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, gd);
++ if(std::has_facet<lcl_date_input_facet>(is.getloc())) {
++ std::use_facet<lcl_date_input_facet>(is.getloc()).get(sit, str_end, is, gd);
+ }
+ else {
+- date_input_facet* f = new date_input_facet();
++ lcl_date_input_facet* f = new lcl_date_input_facet();
+ std::locale l = std::locale(is.getloc(), f);
+ is.imbue(l);
+ f->get(sit, str_end, is, gd);
+@@ -400,14 +400,14 @@
+ typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
+ if (strm_sentry) {
+ try {
+- typedef typename date_time::date_input_facet<date, CharT> date_input_facet;
++ typedef typename date_time::date_input_facet<date, CharT> lcl_date_input_facet;
+
+ std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
+- if(std::has_facet<date_input_facet>(is.getloc())) {
+- std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, gy);
++ if(std::has_facet<lcl_date_input_facet>(is.getloc())) {
++ std::use_facet<lcl_date_input_facet>(is.getloc()).get(sit, str_end, is, gy);
+ }
+ else {
+- date_input_facet* f = new date_input_facet();
++ lcl_date_input_facet* f = new lcl_date_input_facet();
+ std::locale l = std::locale(is.getloc(), f);
+ is.imbue(l);
+ f->get(sit, str_end, is, gy);
+@@ -458,14 +458,14 @@
+ typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
+ if (strm_sentry) {
+ try {
+- typedef typename date_time::date_input_facet<date, CharT> date_input_facet;
++ typedef typename date_time::date_input_facet<date, CharT> lcl_date_input_facet;
+
+ std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
+- if(std::has_facet<date_input_facet>(is.getloc())) {
+- std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, pd);
++ if(std::has_facet<lcl_date_input_facet>(is.getloc())) {
++ std::use_facet<lcl_date_input_facet>(is.getloc()).get(sit, str_end, is, pd);
+ }
+ else {
+- date_input_facet* f = new date_input_facet();
++ lcl_date_input_facet* f = new lcl_date_input_facet();
+ std::locale l = std::locale(is.getloc(), f);
+ is.imbue(l);
+ f->get(sit, str_end, is, pd);
+@@ -515,14 +515,14 @@
+ typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
+ if (strm_sentry) {
+ try {
+- typedef typename date_time::date_input_facet<date, CharT> date_input_facet;
++ typedef typename date_time::date_input_facet<date, CharT> lcl_date_input_facet;
+
+ std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
+- if(std::has_facet<date_input_facet>(is.getloc())) {
+- std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, nday);
++ if(std::has_facet<lcl_date_input_facet>(is.getloc())) {
++ std::use_facet<lcl_date_input_facet>(is.getloc()).get(sit, str_end, is, nday);
+ }
+ else {
+- date_input_facet* f = new date_input_facet();
++ lcl_date_input_facet* f = new lcl_date_input_facet();
+ std::locale l = std::locale(is.getloc(), f);
+ is.imbue(l);
+ f->get(sit, str_end, is, nday);
+@@ -573,14 +573,14 @@
+ typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
+ if (strm_sentry) {
+ try {
+- typedef typename date_time::date_input_facet<date, CharT> date_input_facet;
++ typedef typename date_time::date_input_facet<date, CharT> lcl_date_input_facet;
+
+ std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
+- if(std::has_facet<date_input_facet>(is.getloc())) {
+- std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, fkd);
++ if(std::has_facet<lcl_date_input_facet>(is.getloc())) {
++ std::use_facet<lcl_date_input_facet>(is.getloc()).get(sit, str_end, is, fkd);
+ }
+ else {
+- date_input_facet* f = new date_input_facet();
++ lcl_date_input_facet* f = new lcl_date_input_facet();
+ std::locale l = std::locale(is.getloc(), f);
+ is.imbue(l);
+ f->get(sit, str_end, is, fkd);
+@@ -631,14 +631,14 @@
+ typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
+ if (strm_sentry) {
+ try {
+- typedef typename date_time::date_input_facet<date, CharT> date_input_facet;
++ typedef typename date_time::date_input_facet<date, CharT> lcl_date_input_facet;
+
+ std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
+- if(std::has_facet<date_input_facet>(is.getloc())) {
+- std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, lkd);
++ if(std::has_facet<lcl_date_input_facet>(is.getloc())) {
++ std::use_facet<lcl_date_input_facet>(is.getloc()).get(sit, str_end, is, lkd);
+ }
+ else {
+- date_input_facet* f = new date_input_facet();
++ lcl_date_input_facet* f = new lcl_date_input_facet();
+ std::locale l = std::locale(is.getloc(), f);
+ is.imbue(l);
+ f->get(sit, str_end, is, lkd);
+@@ -690,14 +690,14 @@
+ typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
+ if (strm_sentry) {
+ try {
+- typedef typename date_time::date_input_facet<date, CharT> date_input_facet;
++ typedef typename date_time::date_input_facet<date, CharT> lcl_date_input_facet;
+
+ std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
+- if(std::has_facet<date_input_facet>(is.getloc())) {
+- std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, fka);
++ if(std::has_facet<lcl_date_input_facet>(is.getloc())) {
++ std::use_facet<lcl_date_input_facet>(is.getloc()).get(sit, str_end, is, fka);
+ }
+ else {
+- date_input_facet* f = new date_input_facet();
++ lcl_date_input_facet* f = new lcl_date_input_facet();
+ std::locale l = std::locale(is.getloc(), f);
+ is.imbue(l);
+ f->get(sit, str_end, is, fka);
+@@ -749,14 +749,14 @@
+ typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
+ if (strm_sentry) {
+ try {
+- typedef typename date_time::date_input_facet<date, CharT> date_input_facet;
++ typedef typename date_time::date_input_facet<date, CharT> lcl_date_input_facet;
+
+ std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
+- if(std::has_facet<date_input_facet>(is.getloc())) {
+- std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, fkb);
++ if(std::has_facet<lcl_date_input_facet>(is.getloc())) {
++ std::use_facet<lcl_date_input_facet>(is.getloc()).get(sit, str_end, is, fkb);
+ }
+ else {
+- date_input_facet* f = new date_input_facet();
++ lcl_date_input_facet* f = new lcl_date_input_facet();
+ std::locale l = std::locale(is.getloc(), f);
+ is.imbue(l);
+ f->get(sit, str_end, is, fkb);
+--- misc/boost_1_44_0/boost/date_time/posix_time/posix_time_io.hpp 2012-01-08 20:16:41.342761072 +0000
++++ misc/build/boost_1_44_0/boost/date_time/posix_time/posix_time_io.hpp 2012-01-09 09:47:25.426730124 +0000
+@@ -75,13 +75,13 @@
+ typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
+ if (strm_sentry) {
+ try {
+- typedef typename date_time::time_input_facet<ptime, CharT> time_input_facet;
++ typedef typename date_time::time_input_facet<ptime, CharT> lcl_time_input_facet;
+ std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
+- if(std::has_facet<time_input_facet>(is.getloc())) {
+- std::use_facet<time_input_facet>(is.getloc()).get(sit, str_end, is, pt);
++ if(std::has_facet<lcl_time_input_facet>(is.getloc())) {
++ std::use_facet<lcl_time_input_facet>(is.getloc()).get(sit, str_end, is, pt);
+ }
+ else {
+- time_input_facet* f = new time_input_facet();
++ lcl_time_input_facet* f = new lcl_time_input_facet();
+ std::locale l = std::locale(is.getloc(), f);
+ is.imbue(l);
+ f->get(sit, str_end, is, pt);
+@@ -143,13 +143,13 @@
+ typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
+ if (strm_sentry) {
+ try {
+- typedef typename date_time::time_input_facet<ptime, CharT> time_input_facet;
++ typedef typename date_time::time_input_facet<ptime, CharT> lcl_time_input_facet;
+ std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
+- if(std::has_facet<time_input_facet>(is.getloc())) {
+- std::use_facet<time_input_facet>(is.getloc()).get(sit, str_end, is, tp);
++ if(std::has_facet<lcl_time_input_facet>(is.getloc())) {
++ std::use_facet<lcl_time_input_facet>(is.getloc()).get(sit, str_end, is, tp);
+ }
+ else {
+- time_input_facet* f = new time_input_facet();
++ lcl_time_input_facet* f = new lcl_time_input_facet();
+ std::locale l = std::locale(is.getloc(), f);
+ is.imbue(l);
+ f->get(sit, str_end, is, tp);
+@@ -208,13 +208,13 @@
+ typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
+ if (strm_sentry) {
+ try {
+- typedef typename date_time::time_input_facet<ptime, CharT> time_input_facet;
++ typedef typename date_time::time_input_facet<ptime, CharT> lcl_time_input_facet;
+ std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
+- if(std::has_facet<time_input_facet>(is.getloc())) {
+- std::use_facet<time_input_facet>(is.getloc()).get(sit, str_end, is, td);
++ if(std::has_facet<lcl_time_input_facet>(is.getloc())) {
++ std::use_facet<lcl_time_input_facet>(is.getloc()).get(sit, str_end, is, td);
+ }
+ else {
+- time_input_facet* f = new time_input_facet();
++ lcl_time_input_facet* f = new lcl_time_input_facet();
+ std::locale l = std::locale(is.getloc(), f);
+ is.imbue(l);
+ f->get(sit, str_end, is, td);
+--- misc/boost_1_44_0/boost/spirit/home/classic/debug/impl/parser_names.ipp 2012-04-10 21:23:48.599238472 +0100
++++ misc/build/boost_1_44_0/boost/spirit/home/classic/debug/impl/parser_names.ipp 2012-04-10 21:24:02.752394878 +0100
+@@ -395,13 +395,13 @@
+ }
+
+ bool register_node(void const *r, char const *name_to_register,
+- bool trace_node)
++ bool trace_node_)
+ {
+ if (infos.find(r) != infos.end())
+ return false;
+
+ return infos.insert(rule_infos::value_type(r,
+- rule_info(std::string(name_to_register), trace_node))
++ rule_info(std::string(name_to_register), trace_node_))
+ ).second;
+ }
+
diff --git a/external/boost/boost.6397.warnings.patch b/external/boost/boost.6397.warnings.patch
new file mode 100644
index 000000000000..1cb18d468fb2
--- /dev/null
+++ b/external/boost/boost.6397.warnings.patch
@@ -0,0 +1,568 @@
+--- misc/boost_1_44_0/boost/boost/crc.hpp
++++ misc/build/boost_1_44_0/boost/boost/crc.hpp
+@@ -755,15 +755,15 @@ void
+ crc_basic<Bits>::process_bits
+ (
+ unsigned char bits,
+- std::size_t bit_count
++ std::size_t bit_count_
+ )
+ {
+ // ignore the bits above the ones we want
+- bits <<= CHAR_BIT - bit_count;
++ bits <<= CHAR_BIT - bit_count_;
+
+ // compute the CRC for each bit, starting with the upper ones
+ unsigned char const high_bit_mask = 1u << ( CHAR_BIT - 1u );
+- for ( std::size_t i = bit_count ; i > 0u ; --i, bits <<= 1u )
++ for ( std::size_t i = bit_count_ ; i > 0u ; --i, bits <<= 1u )
+ {
+ process_bit( static_cast<bool>(bits & high_bit_mask) );
+ }
+--- misc/boost_1_44_0/boost/multi_array/concept_checks.hpp 2012-01-12 20:21:29.790009198 +0000
++++ misc/build/boost_1_44_0/boost/multi_array/concept_checks.hpp 2012-01-12 20:29:56.482879277 +0000
+@@ -39,8 +39,8 @@
+
+ template <typename Array, typename IdxGen, typename Call_Type>
+ static void call(Array& a, const IdxGen& idgen, Call_Type c) {
+- typedef typename Array::index_range index_range;
+- typedef typename Array::index index;
++ typedef typename Array::index_range index_range_;
++ typedef typename Array::index index_;
+ idgen_helper<N-1>::call(a,idgen[c],c);
+ }
+ };
+@@ -50,8 +50,8 @@
+
+ template <typename Array, typename IdxGen, typename Call_Type>
+ static void call(Array& a, const IdxGen& idgen, Call_Type) {
+- typedef typename Array::index_range index_range;
+- typedef typename Array::index index;
++ typedef typename Array::index_range index_range_;
++ typedef typename Array::index index_;
+ a[ idgen ];
+ }
+ };
+@@ -153,27 +153,27 @@
+ const_constraints(a);
+ }
+
+- void const_constraints(const Array& a) {
++ void const_constraints(const Array& a_) {
+
+ // value_type vt = a[ id ];
+
+ // Test slicing, keeping only the first dimension, losing the rest
+- detail::idgen_helper<NumDims-1>::call(a,idgen[range],id);
++ detail::idgen_helper<NumDims-1>::call(a_,idgen[range],id);
+
+ // Test slicing, keeping all dimensions.
+- detail::idgen_helper<NumDims-1>::call(a,idgen[range],range);
++ detail::idgen_helper<NumDims-1>::call(a_,idgen[range],range);
+
+- st = a.size();
+- st = a.num_dimensions();
+- st = a.num_elements();
+- stp = a.shape();
+- idp = a.strides();
+- idp = a.index_bases();
+- cit = a.begin();
+- cit = a.end();
+- crit = a.rbegin();
+- crit = a.rend();
+- eltp = a.origin();
++ st = a_.size();
++ st = a_.num_dimensions();
++ st = a_.num_elements();
++ stp = a_.shape();
++ idp = a_.strides();
++ idp = a_.index_bases();
++ cit = a_.begin();
++ cit = a_.end();
++ crit = a_.rbegin();
++ crit = a_.rend();
++ eltp = a_.origin();
+ }
+
+ typedef typename Array::value_type value_type;
+--- misc/boost_1_44_0/boost/multi_array/extent_range.hpp 2012-01-12 20:21:29.790009198 +0000
++++ misc/build/boost_1_44_0/boost/multi_array/extent_range.hpp 2012-01-12 20:32:16.696241748 +0000
+@@ -26,11 +26,11 @@
+ typedef Extent index;
+ typedef SizeType size_type;
+
+- extent_range(index start, index finish) :
+- super_type(start,finish) { }
++ extent_range(index start_, index finish_) :
++ super_type(start_,finish_) { }
+
+- extent_range(index finish) :
+- super_type(0,finish) { }
++ extent_range(index finish_) :
++ super_type(0,finish_) { }
+
+ extent_range() : super_type(0,0) { }
+
+--- misc/boost_1_44_0/boost/multi_array/index_range.hpp 2012-01-12 20:21:29.790009198 +0000
++++ misc/build/boost_1_44_0/boost/multi_array/index_range.hpp 2012-01-12 20:31:29.405781105 +0000
+@@ -60,8 +60,8 @@
+ degenerate_ = true;
+ }
+
+- explicit index_range(index start, index finish, index stride=1)
+- : start_(start), finish_(finish), stride_(stride),
++ explicit index_range(index i_start, index i_finish, index i_stride=1)
++ : start_(i_start), finish_(i_finish), stride_(i_stride),
+ degenerate_(false)
+ { }
+
+@@ -107,11 +107,11 @@
+
+ index stride() const { return stride_; }
+
+- void set_index_range(index start, index finish, index stride=1)
++ void set_index_range(index i_start, index i_finish, index i_stride=1)
+ {
+- start_ = start;
+- finish_ = finish;
+- stride_ = stride;
++ start_ = i_start;
++ finish_ = i_finish;
++ stride_ = i_stride;
+ }
+
+ static index_range all()
+--- misc/boost_1_44_0/boost/multi_array/multi_array_ref.hpp 2012-01-12 20:21:29.790009198 +0000
++++ misc/build/boost_1_44_0/boost/multi_array/multi_array_ref.hpp 2012-01-12 20:25:49.280492556 +0000
+@@ -86,24 +86,24 @@
+ num_elements_(other.num_elements_) { }
+
+ template <typename ExtentList>
+- explicit const_multi_array_ref(TPtr base, const ExtentList& extents) :
++ explicit const_multi_array_ref(TPtr base, const ExtentList& extents_) :
+ base_(base), storage_(c_storage_order()) {
+ boost::function_requires<
+ CollectionConcept<ExtentList> >();
+
+ index_base_list_.assign(0);
+- init_multi_array_ref(extents.begin());
++ init_multi_array_ref(extents_.begin());
+ }
+
+ template <typename ExtentList>
+- explicit const_multi_array_ref(TPtr base, const ExtentList& extents,
++ explicit const_multi_array_ref(TPtr base, const ExtentList& extents_,
+ const general_storage_order<NumDims>& so) :
+ base_(base), storage_(so) {
+ boost::function_requires<
+ CollectionConcept<ExtentList> >();
+
+ index_base_list_.assign(0);
+- init_multi_array_ref(extents.begin());
++ init_multi_array_ref(extents_.begin());
+ }
+
+ explicit const_multi_array_ref(TPtr base,
+@@ -124,13 +124,13 @@
+ }
+
+ template <class InputIterator>
+- void assign(InputIterator begin, InputIterator end) {
++ void assign(InputIterator begin_, InputIterator end_) {
+ boost::function_requires<InputIteratorConcept<InputIterator> >();
+
+- InputIterator in_iter = begin;
++ InputIterator in_iter = begin_;
+ T* out_iter = base_;
+ std::size_t copy_count=0;
+- while (in_iter != end && copy_count < num_elements_) {
++ while (in_iter != end_ && copy_count < num_elements_) {
+ *out_iter++ = *in_iter++;
+ copy_count++;
+ }
+@@ -161,14 +161,14 @@
+ }
+
+ template <typename SizeList>
+- void reshape(const SizeList& extents) {
++ void reshape(const SizeList& extents_) {
+ boost::function_requires<
+ CollectionConcept<SizeList> >();
+ BOOST_ASSERT(num_elements_ ==
+- std::accumulate(extents.begin(),extents.end(),
++ std::accumulate(extents_.begin(),extents_.end(),
+ size_type(1),std::multiplies<size_type>()));
+
+- std::copy(extents.begin(),extents.end(),extent_list_.begin());
++ std::copy(extents_.begin(),extents_.end(),extent_list_.begin());
+ this->compute_strides(stride_list_,extent_list_,storage_);
+
+ origin_offset_ =
+@@ -208,11 +208,11 @@
+ }
+
+ template <typename IndexList>
+- const element& operator()(IndexList indices) const {
++ const element& operator()(IndexList indices_) const {
+ boost::function_requires<
+ CollectionConcept<IndexList> >();
+ return super_type::access_element(boost::type<const element&>(),
+- indices,origin(),
++ indices_,origin(),
+ shape(),strides(),index_bases());
+ }
+
+@@ -231,12 +231,12 @@
+ #endif // BOOST_MSVC
+ typename const_array_view<NDims>::type
+ operator[](const detail::multi_array::
+- index_gen<NumDims,NDims>& indices)
++ index_gen<NumDims,NDims>& indices_)
+ const {
+ typedef typename const_array_view<NDims>::type return_type;
+ return
+ super_type::generate_array_view(boost::type<return_type>(),
+- indices,
++ indices_,
+ shape(),
+ strides(),
+ index_bases(),
+@@ -327,20 +327,20 @@
+ explicit
+ const_multi_array_ref(TPtr base,
+ const storage_order_type& so,
+- const index * index_bases,
++ const index * index_bases_,
+- const size_type* extents) :
++ const size_type* extents_) :
+ base_(base), storage_(so), origin_offset_(0), directional_offset_(0)
+ {
+- // If index_bases or extents is null, then initialize the corresponding
++ // If index_bases_ or extents_ is null, then initialize the corresponding
+ // private data to zeroed lists.
+- if(index_bases) {
++ if(index_bases_) {
+ boost::detail::multi_array::
+- copy_n(index_bases,NumDims,index_base_list_.begin());
++ copy_n(index_bases_,NumDims,index_base_list_.begin());
+ } else {
+ std::fill_n(index_base_list_.begin(),NumDims,0);
+ }
+- if(extents) {
+- init_multi_array_ref(extents);
++ if(extents_) {
++ init_multi_array_ref(extents_);
+ } else {
+ boost::array<index,NumDims> extent_list;
+ extent_list.assign(0);
+@@ -374,12 +374,12 @@
+ boost::mem_fun_ref(&extent_range::start));
+
+ // calculate the extents
+- extent_list extents;
++ extent_list extents_;
+ std::transform(ranges.ranges_.begin(),ranges.ranges_.end(),
+- extents.begin(),
++ extents_.begin(),
+ boost::mem_fun_ref(&extent_range::size));
+
+- init_multi_array_ref(extents.begin());
++ init_multi_array_ref(extents_.begin());
+ }
+
+
+@@ -445,16 +445,16 @@
+ };
+
+ template <class ExtentList>
+- explicit multi_array_ref(T* base, const ExtentList& extents) :
+- super_type(base,extents) {
++ explicit multi_array_ref(T* base, const ExtentList& extents_) :
++ super_type(base,extents_) {
+ boost::function_requires<
+ CollectionConcept<ExtentList> >();
+ }
+
+ template <class ExtentList>
+- explicit multi_array_ref(T* base, const ExtentList& extents,
++ explicit multi_array_ref(T* base, const ExtentList& extents_,
+ const general_storage_order<NumDims>& so) :
+- super_type(base,extents,so) {
++ super_type(base,extents_,so) {
+ boost::function_requires<
+ CollectionConcept<ExtentList> >();
+ }
+@@ -509,11 +509,11 @@
+ element* data() { return super_type::base_; }
+
+ template <class IndexList>
+- element& operator()(const IndexList& indices) {
++ element& operator()(const IndexList& indices_) {
+ boost::function_requires<
+ CollectionConcept<IndexList> >();
+ return super_type::access_element(boost::type<element&>(),
+- indices,origin(),
++ indices_,origin(),
+ this->shape(),this->strides(),
+ this->index_bases());
+ }
+@@ -535,11 +535,11 @@
+ #endif // BOOST_MSVC
+ typename array_view<NDims>::type
+ operator[](const detail::multi_array::
+- index_gen<NumDims,NDims>& indices) {
++ index_gen<NumDims,NDims>& indices_) {
+ typedef typename array_view<NDims>::type return_type;
+ return
+ super_type::generate_array_view(boost::type<return_type>(),
+- indices,
++ indices_,
+ this->shape(),
+ this->strides(),
+ this->index_bases(),
+@@ -576,10 +576,10 @@
+ const element* data() const { return super_type::data(); }
+
+ template <class IndexList>
+- const element& operator()(const IndexList& indices) const {
++ const element& operator()(const IndexList& indices_) const {
+ boost::function_requires<
+ CollectionConcept<IndexList> >();
+- return super_type::operator()(indices);
++ return super_type::operator()(indices_);
+ }
+
+ const_reference operator[](index idx) const {
+@@ -597,9 +597,9 @@
+ #endif // BOOST_MSVC
+ typename const_array_view<NDims>::type
+ operator[](const detail::multi_array::
+- index_gen<NumDims,NDims>& indices)
++ index_gen<NumDims,NDims>& indices_)
+ const {
+- return super_type::operator[](indices);
++ return super_type::operator[](indices_);
+ }
+
+ const_iterator begin() const {
+@@ -622,9 +622,9 @@
+ // This is only supplied to support multi_array's default constructor
+ explicit multi_array_ref(T* base,
+ const storage_order_type& so,
+- const index* index_bases,
+- const size_type* extents) :
+- super_type(base,so,index_bases,extents) { }
++ const index* index_bases_,
++ const size_type* extents_) :
++ super_type(base,so,index_bases_,extents_) { }
+
+ };
+
+--- misc/boost_1_44_0/boost/multi_array/storage_order.hpp 2012-01-12 20:21:29.790009198 +0000
++++ misc/build/boost_1_44_0/boost/multi_array/storage_order.hpp 2012-01-12 20:30:57.667472937 +0000
+@@ -34,10 +34,10 @@
+ public:
+ typedef detail::multi_array::size_type size_type;
+ template <typename OrderingIter, typename AscendingIter>
+- general_storage_order(OrderingIter ordering,
+- AscendingIter ascending) {
+- boost::detail::multi_array::copy_n(ordering,NumDims,ordering_.begin());
+- boost::detail::multi_array::copy_n(ascending,NumDims,ascending_.begin());
++ general_storage_order(OrderingIter i_ordering,
++ AscendingIter i_ascending) {
++ boost::detail::multi_array::copy_n(i_ordering,NumDims,ordering_.begin());
++ boost::detail::multi_array::copy_n(i_ascending,NumDims,ascending_.begin());
+ }
+
+ // RG - ideally these would not be necessary, but some compilers
+--- misc/boost_1_44_0/boost/multi_array/subarray.hpp 2012-01-12 20:21:29.790009198 +0000
++++ misc/build/boost_1_44_0/boost/multi_array/subarray.hpp 2012-01-12 20:27:12.346292228 +0000
+@@ -181,9 +181,9 @@
+
+ const_sub_array (TPtr base,
+ const size_type* extents,
+- const index* strides,
++ const index* i_strides,
+ const index* index_base) :
+- base_(base), extents_(extents), strides_(strides),
++ base_(base), extents_(extents), strides_(i_strides),
+ index_base_(index_base) {
+ }
+
+@@ -369,9 +369,9 @@
+
+ sub_array (T* base,
+ const size_type* extents,
+- const index* strides,
++ const index* _strides,
+ const index* index_base) :
+- super_type(base,extents,strides,index_base) {
++ super_type(base,extents,_strides,index_base) {
+ }
+
+ };
+--- misc/boost_1_44_0/boost/multi_array/view.hpp 2012-01-12 20:21:29.790009198 +0000
++++ misc/build/boost_1_44_0/boost/multi_array/view.hpp 2012-01-12 20:26:36.350945110 +0000
+@@ -231,7 +231,7 @@
+ template <typename ExtentList, typename Index>
+ explicit const_multi_array_view(TPtr base,
+ const ExtentList& extents,
+- const boost::array<Index,NumDims>& strides):
++ const boost::array<Index,NumDims>& strides_):
+ base_(base), origin_offset_(0) {
+
+ index_base_list_.assign(0);
+@@ -240,7 +240,7 @@
+ boost::detail::multi_array::
+ copy_n(extents.begin(),NumDims,extent_list_.begin());
+ boost::detail::multi_array::
+- copy_n(strides.begin(),NumDims,stride_list_.begin());
++ copy_n(strides_.begin(),NumDims,stride_list_.begin());
+
+ // Calculate the array size
+ num_elements_ = std::accumulate(extent_list_.begin(),extent_list_.end(),
+@@ -441,8 +441,8 @@
+ template <typename ExtentList, typename Index>
+ explicit multi_array_view(T* base,
+ const ExtentList& extents,
+- const boost::array<Index,NumDims>& strides) :
+- super_type(base,extents,strides) { }
++ const boost::array<Index,NumDims>& _strides) :
++ super_type(base,extents,_strides) { }
+
+ };
+
+--- misc/boost_1_44_0/boost/multi_array.hpp 2012-09-28 13:06:44.796521371 +0100
++++ misc/build/boost_1_44_0/boost/multi_array.hpp 2012-09-28 13:07:25.119002500 +0100
+@@ -139,20 +139,20 @@
+
+ explicit multi_array() :
+ super_type((T*)initial_base_,c_storage_order(),
+- /*index_bases=*/0, /*extents=*/0) {
++ /*index_bases=*/0, /*extents_=*/0) {
+ allocate_space();
+ }
+
+ template <class ExtentList>
+ explicit multi_array(
+- ExtentList const& extents
++ ExtentList const& extents_
+ #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+ , typename mpl::if_<
+ detail::multi_array::is_multi_array_impl<ExtentList>,
+ int&,int>::type* = 0
+ #endif
+ ) :
+- super_type((T*)initial_base_,extents) {
++ super_type((T*)initial_base_,extents_) {
+ boost::function_requires<
+ detail::multi_array::CollectionConcept<ExtentList> >();
+ allocate_space();
+@@ -160,19 +160,19 @@
+
+
+ template <class ExtentList>
+- explicit multi_array(ExtentList const& extents,
++ explicit multi_array(ExtentList const& extents_,
+ const general_storage_order<NumDims>& so) :
+- super_type((T*)initial_base_,extents,so) {
++ super_type((T*)initial_base_,extents_,so) {
+ boost::function_requires<
+ detail::multi_array::CollectionConcept<ExtentList> >();
+ allocate_space();
+ }
+
+ template <class ExtentList>
+- explicit multi_array(ExtentList const& extents,
++ explicit multi_array(ExtentList const& extents_,
+ const general_storage_order<NumDims>& so,
+ Allocator const& alloc) :
+- super_type((T*)initial_base_,extents,so), allocator_(alloc) {
++ super_type((T*)initial_base_,extents_,so), allocator_(alloc) {
+ boost::function_requires<
+ detail::multi_array::CollectionConcept<ExtentList> >();
+ allocate_space();
+@@ -381,7 +381,7 @@
+
+
+ template <typename ExtentList>
+- multi_array& resize(const ExtentList& extents) {
++ multi_array& resize(const ExtentList& extents_) {
+ boost::function_requires<
+ detail::multi_array::CollectionConcept<ExtentList> >();
+
+@@ -390,7 +390,7 @@
+
+ for (int i=0; i != NumDims; ++i) {
+ typedef typename gen_type::range range_type;
+- ranges.ranges_[i] = range_type(0,extents[i]);
++ ranges.ranges_[i] = range_type(0,extents_[i]);
+ }
+
+ return this->resize(ranges);
+@@ -423,9 +423,9 @@
+ // Build index_gen objects to create views with the same shape
+
+ // these need to be separate to handle non-zero index bases
+- typedef detail::multi_array::index_gen<NumDims,NumDims> index_gen;
+- index_gen old_idxes;
+- index_gen new_idxes;
++ typedef detail::multi_array::index_gen<NumDims,NumDims> lcl_index_gen;
++ lcl_index_gen old_idxes;
++ lcl_index_gen new_idxes;
+
+ std::transform(new_array.index_base_list_.begin(),
+ new_array.index_base_list_.end(),
+--- misc/boost_1_44_0/boost/random/mersenne_twister.hpp
++++ misc/build/boost_1_44_0/boost/random/mersenne_twister.hpp
+@@ -195,19 +195,19 @@
+ * Returns true if the two generators are in the same state,
+ * and will thus produce identical sequences.
+ */
+- friend bool operator==(const mersenne_twister_engine& x,
+- const mersenne_twister_engine& y)
++ friend bool operator==(const mersenne_twister_engine& x_arg,
++ const mersenne_twister_engine& y_arg)
+ {
+- if(x.i < y.i) return x.equal_imp(y);
+- else return y.equal_imp(x);
++ if(x_arg.i < y_arg.i) return x_arg.equal_imp(y_arg);
++ else return y_arg.equal_imp(x_arg);
+ }
+
+ /**
+ * Returns true if the two generators are in different states.
+ */
+- friend bool operator!=(const mersenne_twister_engine& x,
+- const mersenne_twister_engine& y)
+- { return !(x == y); }
++ friend bool operator!=(const mersenne_twister_engine& x_arg,
++ const mersenne_twister_engine& y_arg)
++ { return !(x_arg == y_arg); }
+
+ private:
+ /// \cond show_private
+--- misc/boost_1_44_0/boost/uuid/uuid_io.hpp
++++ misc/build/boost_1_44_0/boost/uuid/uuid_io.hpp
+@@ -59,7 +59,7 @@
+ }
+
+ if (flags & std::ios_base::left) {
+- for (std::streamsize i=uuid_width; i<width; i++) {
++ for (std::streamsize s=uuid_width; s<width; ++s) {
+ os << fill;
+ }
+ }
+--- misc/boost_1_44_0/boost/uuid/name_generator.hpp
++++ misc/build/boost_1_44_0/boost/uuid/name_generator.hpp
+@@ -30,8 +30,8 @@
+ public:
+ typedef uuid result_type;
+
+- explicit name_generator(uuid const& namespace_uuid)
+- : namespace_uuid(namespace_uuid)
++ explicit name_generator(uuid const& namespace_uuid_)
++ : namespace_uuid(namespace_uuid_)
+ {}
+
+ uuid operator()(const char* name) {
diff --git a/external/boost/boost.7551.unusedvars.patch b/external/boost/boost.7551.unusedvars.patch
new file mode 100644
index 000000000000..a80d4a14e914
--- /dev/null
+++ b/external/boost/boost.7551.unusedvars.patch
@@ -0,0 +1,10 @@
+--- misc/boost_1_44_0/boost/date_time/tz_db_base.hpp
++++ misc/build/boost_1_44_0/boost/date_time/tz_db_base.hpp
+@@ -170,7 +170,6 @@
+ /*! May throw data_not_accessible, or bad_field_count exceptions */
+ void load_from_file(const std::string& pathspec)
+ {
+- string_type in_str;
+ std::string buff;
+
+ std::ifstream ifs(pathspec.c_str());
diff --git a/external/boost/boost.auto_link.patch b/external/boost/boost.auto_link.patch
new file mode 100644
index 000000000000..556d14e0feea
--- /dev/null
+++ b/external/boost/boost.auto_link.patch
@@ -0,0 +1,40 @@
+--- foo/foo/foo/boost/config/auto_link.hpp
++++ foo/foo/foo/boost/config/auto_link.hpp
+@@ -357,37 +357,6 @@
+ # define BOOST_LIB_PREFIX "lib"
+ #endif
+
+-//
+-// now include the lib:
+-//
+-#if defined(BOOST_LIB_NAME) \
+- && defined(BOOST_LIB_PREFIX) \
+- && defined(BOOST_LIB_TOOLSET) \
+- && defined(BOOST_LIB_THREAD_OPT) \
+- && defined(BOOST_LIB_RT_OPT) \
+- && defined(BOOST_LIB_VERSION)
+-
+-#ifdef BOOST_AUTO_LINK_TAGGED
+-# pragma comment(lib, BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT ".lib")
+-# ifdef BOOST_LIB_DIAGNOSTIC
+-# pragma message ("Linking to lib file: " BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT ".lib")
+-# endif
+-#elif defined(BOOST_AUTO_LINK_NOMANGLE)
+-# pragma comment(lib, BOOST_STRINGIZE(BOOST_LIB_NAME) ".lib")
+-# ifdef BOOST_LIB_DIAGNOSTIC
+-# pragma message ("Linking to lib file: " BOOST_STRINGIZE(BOOST_LIB_NAME) ".lib")
+-# endif
+-#else
+-# pragma comment(lib, BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) "-" BOOST_LIB_TOOLSET BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT "-" BOOST_LIB_VERSION ".lib")
+-# ifdef BOOST_LIB_DIAGNOSTIC
+-# pragma message ("Linking to lib file: " BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) "-" BOOST_LIB_TOOLSET BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT "-" BOOST_LIB_VERSION ".lib")
+-# endif
+-#endif
+-
+-#else
+-# error "some required macros where not defined (internal logic error)."
+-#endif
+-
+
+ #endif // _MSC_VER || __BORLANDC__
+
diff --git a/external/boost/boost.endian.patch b/external/boost/boost.endian.patch
new file mode 100644
index 000000000000..14505e0b3e52
--- /dev/null
+++ b/external/boost/boost.endian.patch
@@ -0,0 +1,13 @@
+--- foo/foo/foo/boost/detail/endian.hpp
++++ foo/foo/foo/boost/detail/endian.hpp
+@@ -28,8 +28,8 @@
+ //
+ // Special cases come first:
+ //
+-#if defined (__GLIBC__)
+-// GNU libc offers the helpful header <endian.h> which defines
++#if defined (__GLIBC__) || defined(__ANDROID__)
++// GNU libc and Android's bionic offer the helpful header <endian.h> which defines
+ // __BYTE_ORDER
+ # include <endian.h>
+ # if (__BYTE_ORDER == __LITTLE_ENDIAN)
diff --git a/external/boost/boost.gcc47679.patch b/external/boost/boost.gcc47679.patch
new file mode 100644
index 000000000000..e62a874c1bfc
--- /dev/null
+++ b/external/boost/boost.gcc47679.patch
@@ -0,0 +1,61 @@
+--- misc/boost_1_44_0/boost/utility/compare_pointees.hpp 2011-02-10 16:39:05.960176555 +0000
++++ misc/build/boost_1_44_0/boost/utility/compare_pointees.hpp 2011-02-10 16:40:59.091423279 +0000
+@@ -29,7 +29,11 @@
+ inline
+ bool equal_pointees ( OptionalPointee const& x, OptionalPointee const& y )
+ {
+- return (!x) != (!y) ? false : ( !x ? true : (*x) == (*y) ) ;
++ if (!x && !y)
++ return true;
++ if (!x || !y)
++ return false;
++ return (*x) == (*y);
+ }
+
+ template<class OptionalPointee>
+--- misc/boost_1_44_0/boost/spirit/home/classic/core/primitives/impl/numerics.ipp 2011-03-02 12:22:47.222870106 +0000
++++ misc/build/boost_1_44_0/boost/spirit/home/classic/core/primitives/impl/numerics.ipp 2011-03-02 12:22:47.222870106 +0000
+@@ -219,6 +219,20 @@
+ }
+ };
+
++ template <int Radix>
++ struct negative_accumulate<unsigned char, Radix>
++ {
++ // Use this accumulator if number is negative
++ static bool add(unsigned char& n, unsigned digit)
++ {
++ n *= Radix;
++ if (n < digit)
++ return false;
++ n -= digit;
++ return true;
++ }
++ };
++
+ template <int MaxDigits>
+ inline bool allow_more_digits(std::size_t i)
+ {
+--- misc/boost_1_44_0/boost/optional/optional.hpp 2011-04-05 13:19:01.223587256 +0100
++++ misc/build/boost_1_44_0/boost/optional/optional.hpp 2011-04-05 13:19:01.223587256 +0100
+@@ -31,6 +31,8 @@
+
+ #include <boost/optional/optional_fwd.hpp>
+
++#include <string.h>
++
+ #if BOOST_WORKAROUND(BOOST_MSVC, == 1200)
+ // VC6.0 has the following bug:
+ // When a templated assignment operator exist, an implicit conversion
+@@ -114,6 +116,11 @@
+
+ public:
+
++ aligned_storage()
++ {
++ memset(&dummy_, 0, sizeof(dummy_));
++ }
++
+ #if defined(BOOST_OPTIONAL_DETAIL_USE_ATTRIBUTE_MAY_ALIAS)
+ void const* address() const { return &dummy_; }
+ void * address() { return &dummy_; }
diff --git a/external/boost/boost.libcdr.warnings.patch.1 b/external/boost/boost.libcdr.warnings.patch.1
new file mode 100644
index 000000000000..22888c464b7a
--- /dev/null
+++ b/external/boost/boost.libcdr.warnings.patch.1
@@ -0,0 +1,539 @@
+--- boost/boost/multi_index/detail/index_matcher.hpp 2008-07-03 18:51:53.000000000 +0200
++++ boost/boost/multi_index/detail/index_matcher.hpp 2013-05-17 15:30:12.539099597 +0200
+@@ -132,17 +132,17 @@
+ entries(),entries()+size_,
+ entry(node),entry::less_by_node()); /* localize entry */
+ ent->ordered=false;
+- std::size_t n=ent->pos; /* get its position */
++ std::size_t n_=ent->pos; /* get its position */
+
+ entry dummy(0);
+- dummy.pile_top=n;
++ dummy.pile_top=n_;
+
+ entry* pile_ent= /* find the first available pile */
+ std::lower_bound( /* to stack the entry */
+ entries(),entries()+num_piles,
+ dummy,entry::less_by_pile_top());
+
+- pile_ent->pile_top=n; /* stack the entry */
++ pile_ent->pile_top=n_; /* stack the entry */
+ pile_ent->pile_top_entry=ent;
+
+ /* if not the first pile, link entry to top of the preceding pile */
+@@ -164,7 +164,7 @@
+ */
+
+ entry* ent=entries()[num_piles-1].pile_top_entry;
+- for(std::size_t n=num_piles;n--;){
++ for(std::size_t n_=num_piles;n_--;){
+ ent->ordered=true;
+ ent=ent->previous;
+ }
+--- boost/boost/multi_index/ordered_index.hpp 2010-07-25 12:44:55.000000000 +0200
++++ boost/boost/multi_index/ordered_index.hpp 2013-05-17 15:33:42.785182819 +0200
+@@ -436,9 +436,9 @@
+
+ template<typename CompatibleKey,typename CompatibleCompare>
+ iterator find(
+- const CompatibleKey& x,const CompatibleCompare& comp)const
++ const CompatibleKey& x,const CompatibleCompare& comp_)const
+ {
+- return make_iterator(ordered_index_find(root(),header(),key,x,comp));
++ return make_iterator(ordered_index_find(root(),header(),key,x,comp_));
+ }
+
+ template<typename CompatibleKey>
+@@ -448,9 +448,9 @@
+ }
+
+ template<typename CompatibleKey,typename CompatibleCompare>
+- size_type count(const CompatibleKey& x,const CompatibleCompare& comp)const
++ size_type count(const CompatibleKey& x,const CompatibleCompare& comp_)const
+ {
+- std::pair<iterator,iterator> p=equal_range(x,comp);
++ std::pair<iterator,iterator> p=equal_range(x,comp_);
+ size_type n=std::distance(p.first,p.second);
+ return n;
+ }
+@@ -464,10 +464,10 @@
+
+ template<typename CompatibleKey,typename CompatibleCompare>
+ iterator lower_bound(
+- const CompatibleKey& x,const CompatibleCompare& comp)const
++ const CompatibleKey& x,const CompatibleCompare& comp_)const
+ {
+ return make_iterator(
+- ordered_index_lower_bound(root(),header(),key,x,comp));
++ ordered_index_lower_bound(root(),header(),key,x,comp_));
+ }
+
+ template<typename CompatibleKey>
+@@ -479,10 +479,10 @@
+
+ template<typename CompatibleKey,typename CompatibleCompare>
+ iterator upper_bound(
+- const CompatibleKey& x,const CompatibleCompare& comp)const
++ const CompatibleKey& x,const CompatibleCompare& comp_)const
+ {
+ return make_iterator(
+- ordered_index_upper_bound(root(),header(),key,x,comp));
++ ordered_index_upper_bound(root(),header(),key,x,comp_));
+ }
+
+ template<typename CompatibleKey>
+@@ -497,10 +497,10 @@
+
+ template<typename CompatibleKey,typename CompatibleCompare>
+ std::pair<iterator,iterator> equal_range(
+- const CompatibleKey& x,const CompatibleCompare& comp)const
++ const CompatibleKey& x,const CompatibleCompare& comp_)const
+ {
+ std::pair<node_type*,node_type*> p=
+- ordered_index_equal_range(root(),header(),key,x,comp);
++ ordered_index_equal_range(root(),header(),key,x,comp_);
+ return std::pair<iterator,iterator>(
+ make_iterator(p.first),make_iterator(p.second));
+ }
+--- boost/boost/multi_index/sequenced_index.hpp 2008-07-03 18:51:53.000000000 +0200
++++ boost/boost/multi_index/sequenced_index.hpp 2013-05-17 15:44:15.265289335 +0200
+@@ -346,7 +346,7 @@
+ }
+
+ template<typename Modifier,typename Rollback>
+- bool modify(iterator position,Modifier mod,Rollback back)
++ bool modify(iterator position,Modifier mod,Rollback back_)
+ {
+ BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+ BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
+@@ -363,7 +363,7 @@
+ #endif
+
+ return this->final_modify_(
+- mod,back,static_cast<final_node_type*>(position.get_node()));
++ mod,back_,static_cast<final_node_type*>(position.get_node()));
+ }
+
+ void swap(sequenced_index<SuperMeta,TagList>& x)
+--- boost/boost/multi_index_container.hpp 2010-07-24 11:20:29.000000000 +0200
++++ boost/boost/multi_index_container.hpp 2013-05-17 15:45:56.723899853 +0200
+@@ -360,7 +360,7 @@
+ IteratorType it
+ BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N))
+ {
+- typedef typename nth_index<N>::type index;
++ typedef typename nth_index<N>::type index_;
+
+ #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
+ BOOST_STATIC_ASSERT(
+@@ -371,7 +371,7 @@
+ BOOST_MULTI_INDEX_CHECK_IS_OWNER(
+ it,static_cast<typename IteratorType::container_type&>(*this));
+
+- return index::make_iterator(static_cast<node_type*>(it.get_node()));
++ return index_::make_iterator(static_cast<node_type*>(it.get_node()));
+ }
+
+ template<int N,typename IteratorType>
+@@ -379,7 +379,7 @@
+ IteratorType it
+ BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N))const
+ {
+- typedef typename nth_index<N>::type index;
++ typedef typename nth_index<N>::type index_;
+
+ #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
+ BOOST_STATIC_ASSERT((
+@@ -390,7 +390,7 @@
+ BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
+ BOOST_MULTI_INDEX_CHECK_IS_OWNER(
+ it,static_cast<const typename IteratorType::container_type&>(*this));
+- return index::make_iterator(static_cast<node_type*>(it.get_node()));
++ return index_::make_iterator(static_cast<node_type*>(it.get_node()));
+ }
+ #endif
+
+@@ -414,7 +414,7 @@
+ IteratorType it
+ BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag))
+ {
+- typedef typename index<Tag>::type index;
++ typedef typename index<Tag>::type index_;
+
+ #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
+ BOOST_STATIC_ASSERT(
+@@ -424,7 +424,7 @@
+ BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
+ BOOST_MULTI_INDEX_CHECK_IS_OWNER(
+ it,static_cast<typename IteratorType::container_type&>(*this));
+- return index::make_iterator(static_cast<node_type*>(it.get_node()));
++ return index_::make_iterator(static_cast<node_type*>(it.get_node()));
+ }
+
+ template<typename Tag,typename IteratorType>
+@@ -432,7 +432,7 @@
+ IteratorType it
+ BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag))const
+ {
+- typedef typename index<Tag>::type index;
++ typedef typename index<Tag>::type index_;
+
+ #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
+ BOOST_STATIC_ASSERT((
+@@ -443,7 +443,7 @@
+ BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
+ BOOST_MULTI_INDEX_CHECK_IS_OWNER(
+ it,static_cast<const typename IteratorType::container_type&>(*this));
+- return index::make_iterator(static_cast<node_type*>(it.get_node()));
++ return index_::make_iterator(static_cast<node_type*>(it.get_node()));
+ }
+ #endif
+
+--- boost/boost/property_tree/detail/json_parser_error.hpp 2007-05-13 00:02:53.000000000 +0200
++++ boost/boost/property_tree/detail/json_parser_error.hpp 2013-05-17 15:36:44.605902442 +0200
+@@ -20,10 +20,10 @@
+ class json_parser_error: public file_parser_error
+ {
+ public:
+- json_parser_error(const std::string &message,
+- const std::string &filename,
+- unsigned long line):
+- file_parser_error(message, filename, line)
++ json_parser_error(const std::string &message_,
++ const std::string &filename_,
++ unsigned long line_):
++ file_parser_error(message_, filename_, line_)
+ {
+ }
+ };
+--- boost/boost/property_tree/detail/json_parser_read.hpp 2013-05-17 15:57:23.740638395 +0200
++++ boost/boost/property_tree/detail/json_parser_read.hpp 2013-05-17 15:31:05.666857356 +0200
+@@ -45,7 +45,7 @@
+ struct a_object_s
+ {
+ context &c;
+- a_object_s(context &c): c(c) { }
++ a_object_s(context &c_): c(c_) { }
+ void operator()(Ch) const
+ {
+ if (c.stack.empty())
+@@ -63,7 +63,7 @@
+ struct a_object_e
+ {
+ context &c;
+- a_object_e(context &c): c(c) { }
++ a_object_e(context &c_): c(c_) { }
+ void operator()(Ch) const
+ {
+ BOOST_ASSERT(c.stack.size() >= 1);
+@@ -74,7 +74,7 @@
+ struct a_name
+ {
+ context &c;
+- a_name(context &c): c(c) { }
++ a_name(context &c_): c(c_) { }
+ void operator()(It, It) const
+ {
+ c.name.swap(c.string);
+@@ -85,7 +85,7 @@
+ struct a_string_val
+ {
+ context &c;
+- a_string_val(context &c): c(c) { }
++ a_string_val(context &c_): c(c_) { }
+ void operator()(It, It) const
+ {
+ BOOST_ASSERT(c.stack.size() >= 1);
+@@ -98,7 +98,7 @@
+ struct a_literal_val
+ {
+ context &c;
+- a_literal_val(context &c): c(c) { }
++ a_literal_val(context &c_): c(c_) { }
+ void operator()(It b, It e) const
+ {
+ BOOST_ASSERT(c.stack.size() >= 1);
+@@ -111,8 +111,8 @@
+ struct a_char
+ {
+ context &c;
+- a_char(context &c): c(c) { }
+- void operator()(It b, It e) const
++ a_char(context &c_): c(c_) { }
++ void operator()(It b, It /* e */) const
+ {
+ c.string += *b;
+ }
+@@ -121,7 +121,7 @@
+ struct a_escape
+ {
+ context &c;
+- a_escape(context &c): c(c) { }
++ a_escape(context &c_): c(c_) { }
+ void operator()(Ch ch) const
+ {
+ switch (ch)
+@@ -142,7 +142,7 @@
+ struct a_unicode
+ {
+ context &c;
+- a_unicode(context &c): c(c) { }
++ a_unicode(context &c_): c(c_) { }
+ void operator()(unsigned long u) const
+ {
+ u = (std::min)(u, static_cast<unsigned long>((std::numeric_limits<Ch>::max)()));
+--- boost/boost/property_tree/detail/ptree_implementation.hpp 2010-07-03 22:59:45.000000000 +0200
++++ boost/boost/property_tree/detail/ptree_implementation.hpp 2013-05-17 15:55:56.449713452 +0200
+@@ -539,48 +539,48 @@
+
+ template<class K, class D, class C>
+ basic_ptree<K, D, C> &
+- basic_ptree<K, D, C>::get_child(const path_type &path)
++ basic_ptree<K, D, C>::get_child(const path_type &path_)
+ {
+- path_type p(path);
++ path_type p(path_);
+ self_type *n = walk_path(p);
+ if (!n) {
+- BOOST_PROPERTY_TREE_THROW(ptree_bad_path("No such node", path));
++ BOOST_PROPERTY_TREE_THROW(ptree_bad_path("No such node", path_));
+ }
+ return *n;
+ }
+
+ template<class K, class D, class C> inline
+ const basic_ptree<K, D, C> &
+- basic_ptree<K, D, C>::get_child(const path_type &path) const
++ basic_ptree<K, D, C>::get_child(const path_type &path_) const
+ {
+- return const_cast<self_type*>(this)->get_child(path);
++ return const_cast<self_type*>(this)->get_child(path_);
+ }
+
+ template<class K, class D, class C> inline
+ basic_ptree<K, D, C> &
+- basic_ptree<K, D, C>::get_child(const path_type &path,
++ basic_ptree<K, D, C>::get_child(const path_type &path_,
+ self_type &default_value)
+ {
+- path_type p(path);
++ path_type p(path_);
+ self_type *n = walk_path(p);
+ return n ? *n : default_value;
+ }
+
+ template<class K, class D, class C> inline
+ const basic_ptree<K, D, C> &
+- basic_ptree<K, D, C>::get_child(const path_type &path,
++ basic_ptree<K, D, C>::get_child(const path_type &path_,
+ const self_type &default_value) const
+ {
+- return const_cast<self_type*>(this)->get_child(path,
++ return const_cast<self_type*>(this)->get_child(path_,
+ const_cast<self_type&>(default_value));
+ }
+
+
+ template<class K, class D, class C>
+ optional<basic_ptree<K, D, C> &>
+- basic_ptree<K, D, C>::get_child_optional(const path_type &path)
++ basic_ptree<K, D, C>::get_child_optional(const path_type &path_)
+ {
+- path_type p(path);
++ path_type p(path_);
+ self_type *n = walk_path(p);
+ if (!n) {
+ return optional<self_type&>();
+@@ -590,9 +590,9 @@
+
+ template<class K, class D, class C>
+ optional<const basic_ptree<K, D, C> &>
+- basic_ptree<K, D, C>::get_child_optional(const path_type &path) const
++ basic_ptree<K, D, C>::get_child_optional(const path_type &path_) const
+ {
+- path_type p(path);
++ path_type p(path_);
+ self_type *n = walk_path(p);
+ if (!n) {
+ return optional<const self_type&>();
+@@ -602,10 +602,10 @@
+
+ template<class K, class D, class C>
+ basic_ptree<K, D, C> &
+- basic_ptree<K, D, C>::put_child(const path_type &path,
++ basic_ptree<K, D, C>::put_child(const path_type &path_,
+ const self_type &value)
+ {
+- path_type p(path);
++ path_type p(path_);
+ self_type &parent = force_path(p);
+ // Got the parent. Now get the correct child.
+ key_type fragment = p.reduce();
+@@ -620,10 +620,10 @@
+
+ template<class K, class D, class C>
+ basic_ptree<K, D, C> &
+- basic_ptree<K, D, C>::add_child(const path_type &path,
++ basic_ptree<K, D, C>::add_child(const path_type &path_,
+ const self_type &value)
+ {
+- path_type p(path);
++ path_type p(path_);
+ self_type &parent = force_path(p);
+ // Got the parent.
+ key_type fragment = p.reduce();
+@@ -709,26 +709,26 @@
+ template<class K, class D, class C>
+ template<class Type, class Translator> inline
+ typename boost::enable_if<detail::is_translator<Translator>, Type>::type
+- basic_ptree<K, D, C>::get(const path_type &path,
++ basic_ptree<K, D, C>::get(const path_type &path_,
+ Translator tr) const
+ {
+- return get_child(path).BOOST_NESTED_TEMPLATE get_value<Type>(tr);
++ return get_child(path_).BOOST_NESTED_TEMPLATE get_value<Type>(tr);
+ }
+
+ template<class K, class D, class C>
+ template<class Type> inline
+- Type basic_ptree<K, D, C>::get(const path_type &path) const
++ Type basic_ptree<K, D, C>::get(const path_type &path_) const
+ {
+- return get_child(path).BOOST_NESTED_TEMPLATE get_value<Type>();
++ return get_child(path_).BOOST_NESTED_TEMPLATE get_value<Type>();
+ }
+
+ template<class K, class D, class C>
+ template<class Type, class Translator> inline
+- Type basic_ptree<K, D, C>::get(const path_type &path,
++ Type basic_ptree<K, D, C>::get(const path_type &path_,
+ const Type &default_value,
+ Translator tr) const
+ {
+- return get_optional<Type>(path, tr).get_value_or(default_value);
++ return get_optional<Type>(path_, tr).get_value_or(default_value);
+ }
+
+ template<class K, class D, class C>
+@@ -738,18 +738,18 @@
+ std::basic_string<Ch>
+ >::type
+ basic_ptree<K, D, C>::get(
+- const path_type &path, const Ch *default_value, Translator tr) const
++ const path_type &path_, const Ch *default_value, Translator tr) const
+ {
+- return get<std::basic_string<Ch>, Translator>(path, default_value, tr);
++ return get<std::basic_string<Ch>, Translator>(path_, default_value, tr);
+ }
+
+ template<class K, class D, class C>
+ template<class Type> inline
+ typename boost::disable_if<detail::is_translator<Type>, Type>::type
+- basic_ptree<K, D, C>::get(const path_type &path,
++ basic_ptree<K, D, C>::get(const path_type &path_,
+ const Type &default_value) const
+ {
+- return get_optional<Type>(path).get_value_or(default_value);
++ return get_optional<Type>(path_).get_value_or(default_value);
+ }
+
+ template<class K, class D, class C>
+@@ -759,17 +759,17 @@
+ std::basic_string<Ch>
+ >::type
+ basic_ptree<K, D, C>::get(
+- const path_type &path, const Ch *default_value) const
++ const path_type &path_, const Ch *default_value) const
+ {
+- return get< std::basic_string<Ch> >(path, default_value);
++ return get< std::basic_string<Ch> >(path_, default_value);
+ }
+
+ template<class K, class D, class C>
+ template<class Type, class Translator>
+- optional<Type> basic_ptree<K, D, C>::get_optional(const path_type &path,
++ optional<Type> basic_ptree<K, D, C>::get_optional(const path_type &path_,
+ Translator tr) const
+ {
+- if (optional<const self_type&> child = get_child_optional(path))
++ if (optional<const self_type&> child = get_child_optional(path_))
+ return child.get().
+ BOOST_NESTED_TEMPLATE get_value_optional<Type>(tr);
+ else
+@@ -778,9 +778,9 @@
+ template<class K, class D, class C>
+ template<class Type>
+ optional<Type> basic_ptree<K, D, C>::get_optional(
+- const path_type &path) const
++ const path_type &path_) const
+ {
+- if (optional<const self_type&> child = get_child_optional(path))
++ if (optional<const self_type&> child = get_child_optional(path_))
+ return child.get().BOOST_NESTED_TEMPLATE get_value_optional<Type>();
+ else
+ return optional<Type>();
+@@ -809,13 +809,13 @@
+ template<class K, class D, class C>
+ template<class Type, typename Translator>
+ basic_ptree<K, D, C> & basic_ptree<K, D, C>::put(
+- const path_type &path, const Type &value, Translator tr)
++ const path_type &path_, const Type &value, Translator tr)
+ {
+- if(optional<self_type &> child = get_child_optional(path)) {
++ if(optional<self_type &> child = get_child_optional(path_)) {
+ child.get().put_value(value, tr);
+ return *child;
+ } else {
+- self_type &child2 = put_child(path, self_type());
++ self_type &child2 = put_child(path_, self_type());
+ child2.put_value(value, tr);
+ return child2;
+ }
+@@ -824,18 +824,18 @@
+ template<class K, class D, class C>
+ template<class Type> inline
+ basic_ptree<K, D, C> & basic_ptree<K, D, C>::put(
+- const path_type &path, const Type &value)
++ const path_type &path_, const Type &value)
+ {
+- return put(path, value,
++ return put(path_, value,
+ typename translator_between<data_type, Type>::type());
+ }
+
+ template<class K, class D, class C>
+ template<class Type, typename Translator> inline
+ basic_ptree<K, D, C> & basic_ptree<K, D, C>::add(
+- const path_type &path, const Type &value, Translator tr)
++ const path_type &path_, const Type &value, Translator tr)
+ {
+- self_type &child = add_child(path, self_type());
++ self_type &child = add_child(path_, self_type());
+ child.put_value(value, tr);
+ return child;
+ }
+@@ -843,9 +843,9 @@
+ template<class K, class D, class C>
+ template<class Type> inline
+ basic_ptree<K, D, C> & basic_ptree<K, D, C>::add(
+- const path_type &path, const Type &value)
++ const path_type &path_, const Type &value)
+ {
+- return add(path, value,
++ return add(path_, value,
+ typename translator_between<data_type, Type>::type());
+ }
+
+--- boost/boost/spirit/home/classic/error_handling/exceptions.hpp 2013-05-17 15:57:23.722638823 +0200
++++ boost/boost/spirit/home/classic/error_handling/exceptions.hpp 2013-05-17 15:26:32.319247352 +0200
+@@ -126,8 +126,8 @@
+ typedef unary<ParserT, parser<self_t> > base_t;
+ typedef unary_parser_category parser_category_t;
+
+- assertive_parser(ParserT const& parser, ErrorDescrT descriptor_)
+- : base_t(parser), descriptor(descriptor_) {}
++ assertive_parser(ParserT const& parser_, ErrorDescrT descriptor_)
++ : base_t(parser_), descriptor(descriptor_) {}
+
+ template <typename ScannerT>
+ struct result
diff --git a/external/boost/boost.loplugin.patch b/external/boost/boost.loplugin.patch
new file mode 100644
index 000000000000..7c35d33034bd
--- /dev/null
+++ b/external/boost/boost.loplugin.patch
@@ -0,0 +1,19 @@
+--- foo/foo/foo/boost/lexical_cast.hpp
++++ foo/foo/foo/boost/lexical_cast.hpp
+@@ -1016,7 +1016,7 @@
+ if( !has_minus ) value = std::numeric_limits<T>::quiet_NaN();
+ else value = (boost::math::changesign) (std::numeric_limits<T>::quiet_NaN());
+ return true;
+- } else
++ } else {
+ if (( /* 'INF' or 'inf' */
+ end-begin==3
+ &&
+@@ -1031,6 +1031,7 @@
+ else value = (boost::math::changesign) (std::numeric_limits<T>::infinity());
+ return true;
+ }
++ }
+
+ return false;
+ }
diff --git a/external/boost/boost.std.move.patch b/external/boost/boost.std.move.patch
new file mode 100644
index 000000000000..83badae6c60a
--- /dev/null
+++ b/external/boost/boost.std.move.patch
@@ -0,0 +1,20 @@
+--- foo/foo/foo/boost/config/compiler/clang.hpp
++++ foo/foo/foo/boost/config/compiler/clang.hpp
+@@ -8,6 +8,8 @@
+
+ // Clang compiler setup.
+
++#include <utility>
++
+ #if !__has_feature(cxx_exceptions) && !defined(BOOST_NO_EXCEPTIONS)
+ # define BOOST_NO_EXCEPTIONS
+ #endif
+@@ -108,7 +108,7 @@
+ # define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+ #endif
+
+-#if !__has_feature(cxx_rvalue_references)
++#if !__has_feature(cxx_rvalue_references) || (defined(__APPLE__) && !defined(_LIBCPP_VERSION))
+ # define BOOST_NO_CXX11_RVALUE_REFERENCES
+ #endif
+
diff --git a/external/boost/boost.transform_width.patch b/external/boost/boost.transform_width.patch
new file mode 100644
index 000000000000..747a17db13de
--- /dev/null
+++ b/external/boost/boost.transform_width.patch
@@ -0,0 +1,11 @@
+--- foo/foo/foo/boost/archive/iterators/transform_width.hpp
++++ foo/foo/foo/boost/archive/iterators/transform_width.hpp
+@@ -23,6 +23,8 @@
+ // stream length is some common multiple of x and y. E.G. Base64 6 bit
+ // character and 8 bit bytes. Lowest common multiple is 24 => 4 6 bit characters
+ // or 3 8 bit characters
++
++#include <algorithm>
+
+ #include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME & PTFO
+ #include <boost/serialization/pfto.hpp>
diff --git a/external/boost/boost.vc2012.patch b/external/boost/boost.vc2012.patch
new file mode 100644
index 000000000000..ac206997dbbb
--- /dev/null
+++ b/external/boost/boost.vc2012.patch
@@ -0,0 +1,25 @@
+--- misc/build/boost_1_44_0/boost/config/compiler/visualc.hpp
++++ misc/build/boost_1_44_0/boost/config/compiler/visualc.hpp
+@@ -101,6 +101,11 @@
+ # define BOOST_NO_ADL_BARRIER
+ #endif
+
++#if _MSC_VER >= 1700 // 1700 == VC++ 11.0
++ // Removed in VC11:
++# define BOOST_NO_0X_HDR_INITIALIZER_LIST
++#endif
++
+
+ #if (_MSC_VER <= 1600)
+ // MSVC (including the latest checked version) has not yet completely
+@@ -269,8 +269,8 @@
+ #error "Compiler not supported or configured - please reconfigure"
+ #endif
+ //
+-// last known and checked version is 1600 (VC10, aka 2010):
+-#if (_MSC_VER > 1600)
++// last known and checked version is 1700 (VC12, aka 2012):
++#if (_MSC_VER > 1700)
+ # if defined(BOOST_ASSERT_CONFIG)
+ # error "Unknown compiler version - please run the configure tests and report the results"
+ # else
diff --git a/external/boost/boost.wdeprecated-auto_ptr.patch.0 b/external/boost/boost.wdeprecated-auto_ptr.patch.0
new file mode 100644
index 000000000000..dd3ce71b910d
--- /dev/null
+++ b/external/boost/boost.wdeprecated-auto_ptr.patch.0
@@ -0,0 +1,91 @@
+--- boost/ptr_container/ptr_map.hpp
++++ boost/ptr_container/ptr_map.hpp
+@@ -16,6 +16,10 @@
+ # pragma once
+ #endif
+
++#if defined __GNUC__
++#pragma GCC system_header
++#endif
++
+ #include <map>
+ #include <boost/ptr_container/ptr_map_adapter.hpp>
+
+--- boost/ptr_container/ptr_map_adapter.hpp
++++ boost/ptr_container/ptr_map_adapter.hpp
+@@ -16,6 +16,10 @@
+ # pragma once
+ #endif
+
++#if defined __GNUC__
++#pragma GCC system_header
++#endif
++
+ #include <boost/ptr_container/detail/map_iterator.hpp>
+ #include <boost/ptr_container/detail/associative_ptr_container.hpp>
+ #include <boost/ptr_container/detail/meta_functions.hpp>
+--- boost/ptr_container/ptr_set_adapter.hpp
++++ boost/ptr_container/ptr_set_adapter.hpp
+@@ -16,6 +16,10 @@
+ # pragma once
+ #endif
+
++#if defined __GNUC__
++#pragma GCC system_header
++#endif
++
+ #include <boost/ptr_container/detail/associative_ptr_container.hpp>
+ #include <boost/ptr_container/detail/meta_functions.hpp>
+ #include <boost/ptr_container/detail/void_ptr_iterator.hpp>
+--- boost/ptr_container/ptr_vector.hpp
++++ boost/ptr_container/ptr_vector.hpp
+@@ -16,6 +16,10 @@
+ # pragma once
+ #endif
+
++#if defined __GNUC__
++#pragma GCC system_header
++#endif
++
+ #include <vector>
+ #include <boost/ptr_container/ptr_sequence_adapter.hpp>
+
+--- boost/smart_ptr/detail/shared_count.hpp
++++ boost/smart_ptr/detail/shared_count.hpp
+@@ -18,6 +18,10 @@
+ // http://www.boost.org/LICENSE_1_0.txt)
+ //
+
++#if defined __GNUC__
++#pragma GCC system_header
++#endif
++
+ #ifdef __BORLANDC__
+ # pragma warn -8027 // Functions containing try are not expanded inline
+ #endif
+--- boost/smart_ptr/scoped_ptr.hpp
++++ boost/smart_ptr/scoped_ptr.hpp
+@@ -11,6 +11,10 @@
+ // http://www.boost.org/libs/smart_ptr/scoped_ptr.htm
+ //
+
++#if defined __GNUC__
++#pragma GCC system_header
++#endif
++
+ #include <boost/config.hpp>
+ #include <boost/assert.hpp>
+ #include <boost/checked_delete.hpp>
+--- boost/smart_ptr/shared_ptr.hpp
++++ boost/smart_ptr/shared_ptr.hpp
+@@ -14,6 +14,10 @@
+ // See http://www.boost.org/libs/smart_ptr/shared_ptr.htm for documentation.
+ //
+
++#if defined __GNUC__
++#pragma GCC system_header
++#endif
++
+ #include <boost/config.hpp> // for broken compiler workarounds
+
+ #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
diff --git a/external/boost/boost.wdeprecated-register.patch.0 b/external/boost/boost.wdeprecated-register.patch.0
new file mode 100644
index 000000000000..d11de3a817ed
--- /dev/null
+++ b/external/boost/boost.wdeprecated-register.patch.0
@@ -0,0 +1,36 @@
+--- boost/math/special_functions/detail/lanczos_sse2.hpp
++++ boost/math/special_functions/detail/lanczos_sse2.hpp
+@@ -51,11 +51,11 @@
+ static_cast<double>(23531376880.41075968857200767445163675473L),
+ static_cast<double>(0u)
+ };
+- register __m128d vx = _mm_load1_pd(&x);
+- register __m128d sum_even = _mm_load_pd(coeff);
+- register __m128d sum_odd = _mm_load_pd(coeff+2);
+- register __m128d nc_odd, nc_even;
+- register __m128d vx2 = _mm_mul_pd(vx, vx);
++ __m128d vx = _mm_load1_pd(&x);
++ __m128d sum_even = _mm_load_pd(coeff);
++ __m128d sum_odd = _mm_load_pd(coeff+2);
++ __m128d nc_odd, nc_even;
++ __m128d vx2 = _mm_mul_pd(vx, vx);
+
+ sum_even = _mm_mul_pd(sum_even, vx2);
+ nc_even = _mm_load_pd(coeff + 4);
+@@ -136,11 +136,11 @@
+ static_cast<double>(56906521.91347156388090791033559122686859L),
+ static_cast<double>(0u)
+ };
+- register __m128d vx = _mm_load1_pd(&x);
+- register __m128d sum_even = _mm_load_pd(coeff);
+- register __m128d sum_odd = _mm_load_pd(coeff+2);
+- register __m128d nc_odd, nc_even;
+- register __m128d vx2 = _mm_mul_pd(vx, vx);
++ __m128d vx = _mm_load1_pd(&x);
++ __m128d sum_even = _mm_load_pd(coeff);
++ __m128d sum_odd = _mm_load_pd(coeff+2);
++ __m128d nc_odd, nc_even;
++ __m128d vx2 = _mm_mul_pd(vx, vx);
+
+ sum_even = _mm_mul_pd(sum_even, vx2);
+ nc_even = _mm_load_pd(coeff + 4);
diff --git a/external/boost/boost.windows.patch b/external/boost/boost.windows.patch
new file mode 100644
index 000000000000..befc805d5753
--- /dev/null
+++ b/external/boost/boost.windows.patch
@@ -0,0 +1,12 @@
+--- misc/build/boost_1_44_0/boost/pool/detail/mutex.hpp
++++ misc/build/boost_1_44_0/boost/pool/detail/mutex.hpp
+@@ -45,7 +45,9 @@
+
+ #ifndef BOOST_NO_MT
+ # ifdef BOOST_WINDOWS
++# define NOMINMAX
+ # include <windows.h>
++# undef NOMINMAX
+ # endif
+ # if defined(_POSIX_THREADS) || defined(BOOST_HAS_PTHREADS)
+ # include <pthread.h>
diff --git a/external/boost/boost.wshadow.patch b/external/boost/boost.wshadow.patch
new file mode 100644
index 000000000000..d27feaca9bcc
--- /dev/null
+++ b/external/boost/boost.wshadow.patch
@@ -0,0 +1,330 @@
+--- foo/foo/foo/boost/math/special_functions/detail/bessel_jy_series.hpp
++++ foo/foo/foo/boost/math/special_functions/detail/bessel_jy_series.hpp
+@@ -194,9 +194,9 @@
+ }
+ else
+ {
+- int s;
+- prefix = boost::math::lgamma(-v, &s, pol) + p;
+- prefix = exp(prefix) * s / constants::pi<T>();
++ int s_lcl;
++ prefix = boost::math::lgamma(-v, &s_lcl, pol) + p;
++ prefix = exp(prefix) * s_lcl / constants::pi<T>();
+ }
+ bessel_y_small_z_series_term_b<T, Policy> s2(v, x);
+ max_iter = policies::get_max_series_iterations<Policy>();
+--- foo/foo/foo/boost/math/special_functions/ellint_rj.hpp
++++ foo/foo/foo/boost/math/special_functions/ellint_rj.hpp
+@@ -91,11 +91,11 @@
+
+ BOOST_ASSERT(pmy >= 0);
+
+- T p = pmy + y;
+- value = boost::math::ellint_rj(x, y, z, p, pol);
++ T p_lcl = pmy + y;
++ value = boost::math::ellint_rj(x, y, z, p_lcl, pol);
+ value *= pmy;
+ value -= 3 * boost::math::ellint_rf(x, y, z, pol);
+- value += 3 * sqrt((x * y * z) / (x * z + p * q)) * boost::math::ellint_rc(x * z + p * q, p * q, pol);
++ value += 3 * sqrt((x * y * z) / (x * z + p_lcl * q)) * boost::math::ellint_rc(x * z + p_lcl * q, p_lcl * q, pol);
+ value /= (y + q);
+ return value;
+ }
+--- foo/foo/foo/boost/random/binomial_distribution.hpp
++++ foo/foo/foo/boost/random/binomial_distribution.hpp
+@@ -272,21 +272,21 @@
+ using std::sqrt;
+ using std::pow;
+
+- RealType p = (0.5 < _p)? (1 - _p) : _p;
+- IntType t = _t;
++ RealType p_lcl = (0.5 < _p)? (1 - _p) : _p;
++ IntType t_lcl = _t;
+
+- m = static_cast<IntType>((t+1)*p);
++ m = static_cast<IntType>((t_lcl+1)*p_lcl);
+
+ if(use_inversion()) {
+- q_n = pow((1 - p), static_cast<RealType>(t));
++ q_n = pow((1 - p_lcl), static_cast<RealType>(t_lcl));
+ } else {
+- btrd.r = p/(1-p);
+- btrd.nr = (t+1)*btrd.r;
+- btrd.npq = t*p*(1-p);
++ btrd.r = p_lcl/(1-p_lcl);
++ btrd.nr = (t_lcl+1)*btrd.r;
++ btrd.npq = t_lcl*p_lcl*(1-p_lcl);
+ RealType sqrt_npq = sqrt(btrd.npq);
+ btrd.b = 1.15 + 2.53 * sqrt_npq;
+- btrd.a = -0.0873 + 0.0248*btrd.b + 0.01*p;
+- btrd.c = t*p + 0.5;
++ btrd.a = -0.0873 + 0.0248*btrd.b + 0.01*p_lcl;
++ btrd.c = t_lcl*p_lcl + 0.5;
+ btrd.alpha = (2.83 + 5.1/btrd.b) * sqrt_npq;
+ btrd.v_r = 0.92 - 4.2/btrd.b;
+ btrd.u_rv_r = 0.86*btrd.v_r;
+@@ -304,9 +304,9 @@
+ RealType u;
+ RealType v = uniform_01<RealType>()(urng);
+ if(v <= btrd.u_rv_r) {
+- RealType u = v/btrd.v_r - 0.43;
++ RealType u_lcl = v/btrd.v_r - 0.43;
+ return static_cast<IntType>(floor(
+- (2*btrd.a/(0.5 - abs(u)) + btrd.b)*u + btrd.c));
++ (2*btrd.a/(0.5 - abs(u_lcl)) + btrd.b)*u_lcl + btrd.c));
+ }
+
+ if(v >= btrd.v_r) {
+@@ -344,9 +344,9 @@
+ v = log(v);
+ RealType rho =
+ (km/btrd.npq)*(((km/3. + 0.625)*km + 1./6)/btrd.npq + 0.5);
+- RealType t = -km*km/(2*btrd.npq);
+- if(v < t - rho) return k;
+- if(v > t + rho) continue;
++ RealType t_lcl = -km*km/(2*btrd.npq);
++ if(v < t_lcl - rho) return k;
++ if(v > t_lcl + rho) continue;
+
+ IntType nm = _t - m + 1;
+ RealType h = (m + 0.5)*log((m + 1)/(btrd.r*nm))
+@@ -367,11 +367,11 @@
+ }
+
+ template<class URNG>
+- IntType invert(IntType t, RealType p, URNG& urng) const
++ IntType invert(IntType t_arg, RealType p_arg, URNG& urng) const
+ {
+- RealType q = 1 - p;
+- RealType s = p / q;
+- RealType a = (t + 1) * s;
++ RealType q = 1 - p_arg;
++ RealType s = p_arg / q;
++ RealType a = (t_arg + 1) * s;
+ RealType r = q_n;
+ RealType u = uniform_01<RealType>()(urng);
+ IntType x = 0;
+--- foo/foo/foo/boost/random/geometric_distribution.hpp
++++ foo/foo/foo/boost/random/geometric_distribution.hpp
+@@ -104,8 +104,8 @@
+ *
+ * Requires: 0 < p < 1
+ */
+- explicit geometric_distribution(const RealType& p = RealType(0.5))
+- : _p(p)
++ explicit geometric_distribution(const RealType& p_arg = RealType(0.5))
++ : _p(p_arg)
+ {
+ BOOST_ASSERT(RealType(0) < _p && _p < RealType(1));
+ init();
+--- foo/foo/foo/boost/random/shuffle_order.hpp
++++ foo/foo/foo/boost/random/shuffle_order.hpp
+@@ -200,8 +200,8 @@
+ }
+
+ /** Returns true if the two generators will produce identical sequences. */
+- BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(shuffle_order_engine, x, y)
+- { return x._rng == y._rng && x.y == y.y && std::equal(x.v, x.v+k, y.v); }
++ BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(shuffle_order_engine, x, y_arg)
++ { return x._rng == y_arg._rng && x.y == y_arg.y && std::equal(x.v, x.v+k, y_arg.v); }
+ /** Returns true if the two generators will produce different sequences. */
+ BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(shuffle_order_engine)
+
+--- foo/foo/foo/boost/random/subtract_with_carry.hpp
++++ foo/foo/foo/boost/random/subtract_with_carry.hpp
+@@ -268,21 +268,21 @@
+
+ friend struct detail::subtract_with_carry_discard;
+
+- IntType do_update(std::size_t current, std::size_t short_index, IntType carry)
++ IntType do_update(std::size_t current, std::size_t short_index, IntType carry_arg)
+ {
+ IntType delta;
+- IntType temp = x[current] + carry;
++ IntType temp = x[current] + carry_arg;
+ if (x[short_index] >= temp) {
+ // x(n) >= 0
+ delta = x[short_index] - temp;
+- carry = 0;
++ carry_arg = 0;
+ } else {
+ // x(n) < 0
+ delta = modulus - temp + x[short_index];
+- carry = 1;
++ carry_arg = 1;
+ }
+ x[current] = delta;
+- return carry;
++ return carry_arg;
+ }
+ /// \endcond
+
+@@ -498,17 +498,17 @@
+
+ friend struct detail::subtract_with_carry_discard;
+
+- RealType do_update(std::size_t current, std::size_t short_index, RealType carry)
++ RealType do_update(std::size_t current, std::size_t short_index, RealType carry_arg)
+ {
+- RealType delta = x[short_index] - x[current] - carry;
++ RealType delta = x[short_index] - x[current] - carry_arg;
+ if(delta < 0) {
+ delta += RealType(1);
+- carry = RealType(1)/_modulus;
++ carry_arg = RealType(1)/_modulus;
+ } else {
+- carry = 0;
++ carry_arg = 0;
+ }
+ x[current] = delta;
+- return carry;
++ return carry_arg;
+ }
+ /// \endcond
+ std::size_t k;
+--- foo/foo/foo/boost/unordered/detail/equivalent.hpp
++++ foo/foo/foo/boost/unordered/detail/equivalent.hpp
+@@ -536,9 +536,9 @@
+ node_pointer first_node = static_cast<node_pointer>(prev->next_);
+ link_pointer end = first_node->group_prev_->next_;
+
+- std::size_t count = this->delete_nodes(prev, end);
++ std::size_t count_lcl = this->delete_nodes(prev, end);
+ this->fix_bucket(bucket_index, prev);
+- return count;
++ return count_lcl;
+ }
+
+ iterator erase(c_iterator r)
+@@ -557,21 +557,21 @@
+ return iterator(r2.node_);
+ }
+
+- link_pointer erase_nodes(node_pointer begin, node_pointer end)
++ link_pointer erase_nodes(node_pointer begin_arg, node_pointer end)
+ {
+- std::size_t bucket_index = this->hash_to_bucket(begin->hash_);
++ std::size_t bucket_index = this->hash_to_bucket(begin_arg->hash_);
+
+- // Split the groups containing 'begin' and 'end'.
+- // And get the pointer to the node before begin while
++ // Split the groups containing 'begin_arg' and 'end.'
++ // And get the pointer to the node before begin_arg while
+ // we're at it.
+- link_pointer prev = split_groups(begin, end);
++ link_pointer prev = split_groups(begin_arg, end);
+
+- // If we don't have a 'prev' it means that begin is at the
++ // If we don't have a 'prev' it means that begin_arg is at the
+ // beginning of a block, so search through the blocks in the
+ // same bucket.
+ if (!prev) {
+ prev = this->get_previous_start(bucket_index);
+- while (prev->next_ != begin)
++ while (prev->next_ != begin_arg)
+ prev = static_cast<node_pointer>(prev->next_)->group_prev_;
+ }
+
+@@ -586,27 +586,27 @@
+ return prev;
+ }
+
+- static link_pointer split_groups(node_pointer begin, node_pointer end)
++ static link_pointer split_groups(node_pointer begin_arg, node_pointer end)
+ {
+- node_pointer prev = begin->group_prev_;
+- if (prev->next_ != begin) prev = node_pointer();
++ node_pointer prev = begin_arg->group_prev_;
++ if (prev->next_ != begin_arg) prev = node_pointer();
+
+ if (end) {
+ node_pointer first = end;
+- while (first != begin && first->group_prev_->next_ == first) {
++ while (first != begin_arg && first->group_prev_->next_ == first) {
+ first = first->group_prev_;
+ }
+
+ boost::swap(first->group_prev_, end->group_prev_);
+- if (first == begin) return prev;
++ if (first == begin_arg) return prev;
+ }
+
+ if (prev) {
+ node_pointer first = prev;
+ while (first->group_prev_->next_ == first) {
+ first = first->group_prev_;
+ }
+- boost::swap(first->group_prev_, begin->group_prev_);
++ boost::swap(first->group_prev_, begin_arg->group_prev_);
+ }
+
+ return prev;
+--- foo/foo/foo/boost/unordered/detail/table.hpp
++++ foo/foo/foo/boost/unordered/detail/table.hpp
+@@ -256,9 +256,9 @@
+ return prev ? iterator(prev->next_) : iterator();
+ }
+
+- std::size_t hash_to_bucket(std::size_t hash) const
++ std::size_t hash_to_bucket(std::size_t hash_arg) const
+ {
+- return policy::to_bucket(bucket_count_, hash);
++ return policy::to_bucket(bucket_count_, hash_arg);
+ }
+
+ float load_factor() const
+@@ -655,8 +655,8 @@
+ // assign_nodes takes ownership of the container's elements,
+ // assigning to them if possible, and deleting any that are
+ // left over.
+- assign_nodes<table> assign(*this);
+- table_impl::fill_buckets(x.begin(), *this, assign);
++ assign_nodes<table> assign_lcl(*this);
++ table_impl::fill_buckets(x.begin(), *this, assign_lcl);
+ }
+
+ void assign(table const& x, true_type)
+@@ -732,9 +732,9 @@
+ // move_assign_nodes takes ownership of the container's
+ // elements, assigning to them if possible, and deleting
+ // any that are left over.
+- move_assign_nodes<table> assign(*this);
++ move_assign_nodes<table> assign_lcl(*this);
+ node_holder<node_allocator> nodes(x);
+- table_impl::fill_buckets(nodes.begin(), *this, assign);
++ table_impl::fill_buckets(nodes.begin(), *this, assign_lcl);
+ }
+ }
+
+--- foo/foo/foo/boost/unordered/detail/unique.hpp
++++ foo/foo/foo/boost/unordered/detail/unique.hpp
+@@ -531,9 +531,9 @@
+
+ link_pointer end = static_cast<node_pointer>(prev->next_)->next_;
+
+- std::size_t count = this->delete_nodes(prev, end);
++ std::size_t count_lcl = this->delete_nodes(prev, end);
+ this->fix_bucket(bucket_index, prev);
+- return count;
++ return count_lcl;
+ }
+
+ iterator erase(c_iterator r)
+@@ -552,13 +552,13 @@
+ return iterator(r2.node_);
+ }
+
+- void erase_nodes(node_pointer begin, node_pointer end)
++ void erase_nodes(node_pointer begin_arg, node_pointer end)
+ {
+- std::size_t bucket_index = this->hash_to_bucket(begin->hash_);
++ std::size_t bucket_index = this->hash_to_bucket(begin_arg->hash_);
+
+- // Find the node before begin.
++ // Find the node before begin_arg.
+ link_pointer prev = this->get_previous_start(bucket_index);
+- while(prev->next_ != begin) prev = prev->next_;
++ while(prev->next_ != begin_arg) prev = prev->next_;
+
+ // Delete the nodes.
+ do {
diff --git a/external/boost/boost.wundef.patch b/external/boost/boost.wundef.patch
new file mode 100644
index 000000000000..d4538146485a
--- /dev/null
+++ b/external/boost/boost.wundef.patch
@@ -0,0 +1,119 @@
+--- foo/foo/foo/boost/detail/endian.hpp
++++ foo/foo/foo/boost/detail/endian.hpp
+@@ -47,15 +47,15 @@
+ # define BOOST_LITTLE_ENDIAN
+ # elif (__BYTE_ORDER == __BIG_ENDIAN)
+ # define BOOST_BIG_ENDIAN
+-# elif (__BYTE_ORDER == __PDP_ENDIAN)
++# elif defined(__PDP_ENDIAN) && (__BYTE_ORDER == __PDP_ENDIAN)
+ # define BOOST_PDP_ENDIAN
+ # else
+ # error Unknown machine endianness detected.
+ # endif
+ # define BOOST_BYTE_ORDER __BYTE_ORDER
+
+ #elif defined(__NetBSD__) || defined(__FreeBSD__) || \
+- defined(__OpenBSD__) || (__DragonFly__)
++ defined(__OpenBSD__) || (defined(__DragonFly__) && (__DragonFly__))
+ //
+ // BSD has endian.h, see https://svn.boost.org/trac/boost/ticket/6013
+ # if defined(__OpenBSD__)
+--- foo/foo/foo/boost/lexical_cast.hpp
++++ foo/foo/foo/boost/lexical_cast.hpp
+@@ -69,7 +69,7 @@
+ throw_exception(bad_lexical_cast(typeid(Source), typeid(Target)))
+ #endif
+
+-#if (defined(BOOST_LCAST_HAS_INT128) && !defined(__GNUC__)) || GCC_VERSION > 40700
++#if (defined(BOOST_LCAST_HAS_INT128) && !defined(__GNUC__)) || (defined(GCC_VERSION) && GCC_VERSION > 40700)
+ #define BOOST_LCAST_HAS_INT128
+ #endif
+
+--- foo/foo/foo/boost/multi_array/base.hpp
++++ foo/foo/foo/boost/multi_array/base.hpp
+@@ -65,7 +65,7 @@
+ // object creation in small-memory environments. Thus, the objects
+ // can be left undefined by defining BOOST_MULTI_ARRAY_NO_GENERATORS
+ // before loading multi_array.hpp.
+-#if !BOOST_MULTI_ARRAY_NO_GENERATORS
++#if !defined(BOOST_MULTI_ARRAY_NO_GENERATORS) || !BOOST_MULTI_ARRAY_NO_GENERATORS
+ namespace {
+ multi_array_types::extent_gen extents;
+ multi_array_types::index_gen indices;
+--- foo/foo/foo/boost/preprocessor/config/config.hpp
++++ foo/foo/foo/boost/preprocessor/config/config.hpp
+@@ -90,7 +90,7 @@
+ # define BOOST_PP_VARIADICS 0
+ # endif
+ # /* Wave (C/C++), GCC (C++) */
+-# elif defined __WAVE__ && __WAVE_HAS_VARIADICS__ || defined __GNUC__ && __GXX_EXPERIMENTAL_CXX0X__
++# elif defined __WAVE__ && __WAVE_HAS_VARIADICS__ || defined __GNUC__ && defined __GXX_EXPERIMENTAL_CXX0X__ && __GXX_EXPERIMENTAL_CXX0X__
+ # define BOOST_PP_VARIADICS 1
+ # /* EDG-based (C/C++), GCC (C), and unknown (C/C++) */
+ # elif !defined __cplusplus && __STDC_VERSION__ >= 199901L || __cplusplus >= 201103L
+--- foo/foo/foo/boost/preprocessor/tuple/elem.hpp
++++ foo/foo/foo/boost/preprocessor/tuple/elem.hpp
+@@ -22,7 +22,7 @@
+ # include <boost/preprocessor/variadic/elem.hpp>
+ #
+ # if BOOST_PP_VARIADICS
+-# if BOOST_PP_VARIADICS_MSVC
++# if defined(BOOST_PP_VARIADICS_MSVC) && BOOST_PP_VARIADICS_MSVC
+ # define BOOST_PP_TUPLE_ELEM(...) BOOST_PP_TUPLE_ELEM_I(BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_ELEM_O_, __VA_ARGS__), (__VA_ARGS__))
+ # define BOOST_PP_TUPLE_ELEM_I(m, args) BOOST_PP_TUPLE_ELEM_II(m, args)
+ # define BOOST_PP_TUPLE_ELEM_II(m, args) BOOST_PP_CAT(m ## args,)
+--- foo/foo/foo/boost/preprocessor/tuple/rem.hpp
++++ foo/foo/foo/boost/preprocessor/tuple/rem.hpp
+@@ -105,7 +105,7 @@
+ # /* BOOST_PP_TUPLE_REM_CTOR */
+ #
+ # if BOOST_PP_VARIADICS
+-# if BOOST_PP_VARIADICS_MSVC
++# if defined(BOOST_PP_VARIADICS_MSVC) && BOOST_PP_VARIADICS_MSVC
+ # define BOOST_PP_TUPLE_REM_CTOR(...) BOOST_PP_TUPLE_REM_CTOR_I(BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_REM_CTOR_O_, __VA_ARGS__), (__VA_ARGS__))
+ # define BOOST_PP_TUPLE_REM_CTOR_I(m, args) BOOST_PP_TUPLE_REM_CTOR_II(m, args)
+ # define BOOST_PP_TUPLE_REM_CTOR_II(m, args) BOOST_PP_CAT(m ## args,)
+--- foo/foo/foo/boost/preprocessor/tuple/to_list.hpp
++++ foo/foo/foo/boost/preprocessor/tuple/to_list.hpp
+@@ -23,7 +23,7 @@
+ # /* BOOST_PP_TUPLE_TO_LIST */
+ #
+ # if BOOST_PP_VARIADICS
+-# if BOOST_PP_VARIADICS_MSVC
++# if defined(BOOST_PP_VARIADICS_MSVC) && BOOST_PP_VARIADICS_MSVC
+ # define BOOST_PP_TUPLE_TO_LIST(...) BOOST_PP_TUPLE_TO_LIST_I(BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_TO_LIST_O_, __VA_ARGS__), (__VA_ARGS__))
+ # define BOOST_PP_TUPLE_TO_LIST_I(m, args) BOOST_PP_TUPLE_TO_LIST_II(m, args)
+ # define BOOST_PP_TUPLE_TO_LIST_II(m, args) BOOST_PP_CAT(m ## args,)
+--- foo/foo/foo/boost/preprocessor/variadic/elem.hpp
++++ foo/foo/foo/boost/preprocessor/variadic/elem.hpp
+@@ -19,7 +19,7 @@
+ # /* BOOST_PP_VARIADIC_ELEM */
+ #
+ # if BOOST_PP_VARIADICS
+-# if BOOST_PP_VARIADICS_MSVC
++# if defined(BOOST_PP_VARIADICS_MSVC) && BOOST_PP_VARIADICS_MSVC
+ # define BOOST_PP_VARIADIC_ELEM(n, ...) BOOST_PP_VARIADIC_ELEM_I(n,__VA_ARGS__)
+ # define BOOST_PP_VARIADIC_ELEM_I(n, ...) BOOST_PP_CAT(BOOST_PP_CAT(BOOST_PP_VARIADIC_ELEM_, n)(__VA_ARGS__,),)
+ # else
+--- foo/foo/foo/boost/preprocessor/variadic/size.hpp
++++ foo/foo/foo/boost/preprocessor/variadic/size.hpp
+@@ -19,7 +19,7 @@
+ # /* BOOST_PP_VARIADIC_SIZE */
+ #
+ # if BOOST_PP_VARIADICS
+-# if BOOST_PP_VARIADICS_MSVC
++# if defined(BOOST_PP_VARIADICS_MSVC) && BOOST_PP_VARIADICS_MSVC
+ # define BOOST_PP_VARIADIC_SIZE(...) BOOST_PP_CAT(BOOST_PP_VARIADIC_SIZE_I(__VA_ARGS__, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,),)
+ # else
+ # define BOOST_PP_VARIADIC_SIZE(...) BOOST_PP_VARIADIC_SIZE_I(__VA_ARGS__, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,)
+--- foo/foo/foo/boost/utility/result_of.hpp
++++ foo/foo/foo/boost/utility/result_of.hpp
+@@ -72,7 +72,7 @@
+ // There doesn't seem to be any other way to turn this off such that the presence of
+ // the user-defined operator,() below doesn't cause spurious warning all over the place,
+ // so unconditionally turn it off.
+-#if BOOST_MSVC
++#if defined(BOOST_MSVC) && BOOST_MSVC
+ # pragma warning(disable: 4913) // user defined binary operator ',' exists but no overload could convert all operands, default built-in binary operator ',' used
+ #endif
+
diff --git a/external/boost/boost.wuninitialized.patch b/external/boost/boost.wuninitialized.patch
new file mode 100644
index 000000000000..1b6384e3e7fa
--- /dev/null
+++ b/external/boost/boost.wuninitialized.patch
@@ -0,0 +1,10 @@
+--- foo/foo/foo/boost/random/binomial_distribution.hpp
++++ foo/foo/foo/boost/random/binomial_distribution.hpp
+@@ -278,6 +278,7 @@
+ m = static_cast<IntType>((t_lcl+1)*p_lcl);
+
+ if(use_inversion()) {
++ btrd.r = btrd.nr = btrd.npq = btrd.b = btrd.a = btrd.c = btrd.alpha = btrd.v_r = btrd.u_rv_r = 0;
+ q_n = pow((1 - p_lcl), static_cast<RealType>(t_lcl));
+ } else {
+ btrd.r = p_lcl/(1-p_lcl);
diff --git a/external/boost/boost.wunused.patch b/external/boost/boost.wunused.patch
new file mode 100644
index 000000000000..ddffa045ba29
--- /dev/null
+++ b/external/boost/boost.wunused.patch
@@ -0,0 +1,50 @@
+--- foo/foo/foo/boost/math/special_functions/airy.hpp
++++ foo/foo/foo/boost/math/special_functions/airy.hpp
+@@ -340,13 +340,6 @@
+ inline T airy_ai_zero(unsigned m, const Policy& pol)
+ {
+ BOOST_FPU_EXCEPTION_GUARD
+- typedef typename policies::evaluation<T, Policy>::type value_type;
+- typedef typename policies::normalise<
+- Policy,
+- policies::promote_float<false>,
+- policies::promote_double<false>,
+- policies::discrete_quantile<>,
+- policies::assert_undefined<> >::type forwarding_policy;
+ BOOST_STATIC_ASSERT_MSG(false == std::numeric_limits<T>::is_integer, "Airy return type must be a floating-point type.");
+ return policies::checked_narrowing_cast<T, Policy>(detail::airy_ai_zero_imp<T>(m, pol), "boost::math::airy_ai_zero<%1%>(unsigned)");
+ }
+@@ -388,13 +381,6 @@
+ inline T airy_bi_zero(unsigned m, const Policy& pol)
+ {
+ BOOST_FPU_EXCEPTION_GUARD
+- typedef typename policies::evaluation<T, Policy>::type value_type;
+- typedef typename policies::normalise<
+- Policy,
+- policies::promote_float<false>,
+- policies::promote_double<false>,
+- policies::discrete_quantile<>,
+- policies::assert_undefined<> >::type forwarding_policy;
+ BOOST_STATIC_ASSERT_MSG(false == std::numeric_limits<T>::is_integer, "Airy return type must be a floating-point type.");
+ return policies::checked_narrowing_cast<T, Policy>(detail::airy_bi_zero_imp<T>(m, pol), "boost::math::airy_bi_zero<%1%>(unsigned)");
+ }
+--- foo/foo/foo/boost/multi_array/base.hpp
++++ foo/foo/foo/boost/multi_array/base.hpp
+@@ -501,6 +501,7 @@
+ // the "far side" of the range (the top if stride is positive, the bottom
+ // if stride is negative).
+ index bound_adjustment = stride < 0 ? 1 : 0;
++ (void) bound_adjustment;
+ BOOST_ASSERT(((index_bases[n] - bound_adjustment) <= finish) &&
+ (finish <= (index_bases[n] + index(extents[n]) - bound_adjustment)));
+ #endif // BOOST_DISABLE_ASSERTS
+--- foo/foo/foo/boost/unordered/detail/table.hpp
++++ foo/foo/foo/boost/unordered/detail/table.hpp
+@@ -458,6 +458,7 @@
+ // According to 23.2.1.8, if propagate_on_container_swap is
+ // false the behaviour is undefined unless the allocators
+ // are equal.
++ (void) other;
+ BOOST_ASSERT(node_alloc() == other.node_alloc());
+ }
+
diff --git a/external/boost/boost_1_44_0-clang-warnings.patch b/external/boost/boost_1_44_0-clang-warnings.patch
new file mode 100644
index 000000000000..0ab163617069
--- /dev/null
+++ b/external/boost/boost_1_44_0-clang-warnings.patch
@@ -0,0 +1,50 @@
+--- misc/boost_1_44_0/boost/math/tools/fraction.hpp
++++ misc/build/boost_1_44_0/boost/math/tools/fraction.hpp
+@@ -33,7 +33,7 @@
+ typedef typename Gen::result_type result_type;
+ typedef typename Gen::result_type value_type;
+
+- static result_type a(const value_type& v)
++ static result_type a(const value_type&)
+ {
+ return 1;
+ }
+--- misc/boost_1_44_0/boost/random/lagged_fibonacci.hpp
++++ misc/build/boost_1_44_0/boost/random/lagged_fibonacci.hpp
+@@ -16,6 +16,10 @@
+ #ifndef BOOST_RANDOM_LAGGED_FIBONACCI_HPP
+ #define BOOST_RANDOM_LAGGED_FIBONACCI_HPP
+
++#if defined __GNUC__
++#pragma GCC system_header
++#endif
++
+ #include <istream>
+ #include <iosfwd>
+ #include <algorithm> // std::max
+--- misc/boost_1_44_0/boost/random/shuffle_output.hpp
++++ misc/build/boost_1_44_0/boost/random/shuffle_output.hpp
+@@ -16,6 +16,10 @@
+ #ifndef BOOST_RANDOM_SHUFFLE_OUTPUT_HPP
+ #define BOOST_RANDOM_SHUFFLE_OUTPUT_HPP
+
++#if defined __GNUC__
++#pragma GCC system_header
++#endif
++
+ #include <boost/random/shuffle_order.hpp>
+
+ namespace boost {
+--- misc/boost_1_44_0/boost/random/subtract_with_carry.hpp
++++ misc/build/boost_1_44_0/boost/random/subtract_with_carry.hpp
+@@ -16,6 +16,10 @@
+ #ifndef BOOST_RANDOM_SUBTRACT_WITH_CARRY_HPP
+ #define BOOST_RANDOM_SUBTRACT_WITH_CARRY_HPP
+
++#if defined __GNUC__
++#pragma GCC system_header
++#endif
++
+ #include <boost/config/no_tr1/cmath.hpp> // std::pow
+ #include <iostream>
+ #include <algorithm> // std::equal
diff --git a/external/boost/boost_1_44_0-gcc4.8.patch b/external/boost/boost_1_44_0-gcc4.8.patch
new file mode 100644
index 000000000000..700e2ff98bc5
--- /dev/null
+++ b/external/boost/boost_1_44_0-gcc4.8.patch
@@ -0,0 +1,448 @@
+
+
+--- a/b/boost/boost/math/special_functions/beta.hpp 2013-05-31 18:12:02.036007347 +0200
++++ a/b/boost/boost/math/special_functions/beta.hpp 2013-05-31 18:11:56.260996218 +0200
+@@ -1331,7 +1331,6 @@
+ BOOST_FPU_EXCEPTION_GUARD
+ typedef typename tools::promote_args<RT1, RT2, RT3>::type result_type;
+ typedef typename policies::evaluation<result_type, Policy>::type value_type;
+- typedef typename lanczos::lanczos<value_type, Policy>::type evaluation_type;
+ typedef typename policies::normalise<
+ Policy,
+ policies::promote_float<false>,
+@@ -1349,7 +1348,6 @@
+ BOOST_FPU_EXCEPTION_GUARD
+ typedef typename tools::promote_args<RT1, RT2, RT3>::type result_type;
+ typedef typename policies::evaluation<result_type, Policy>::type value_type;
+- typedef typename lanczos::lanczos<value_type, Policy>::type evaluation_type;
+ typedef typename policies::normalise<
+ Policy,
+ policies::promote_float<false>,
+--- a/b/boost/boost/random/generate_canonical.hpp 2013-05-31 18:13:09.804149686 +0200
++++ a/b/boost/boost/random/generate_canonical.hpp 2013-05-31 18:13:30.020195845 +0200
+@@ -55,7 +55,6 @@
+ using std::floor;
+ BOOST_ASSERT((g.min)() == 0);
+ BOOST_ASSERT((g.max)() == 1);
+- typedef typename URNG::result_type base_result;
+ std::size_t digits = std::numeric_limits<RealType>::digits;
+ std::size_t engine_bits = detail::generator_bits<URNG>::value();
+ std::size_t b = (std::min)(bits, digits);
+--- a/b/boost/boost/random/uniform_real_distribution.hpp 2013-05-31 18:15:04.571429634 +0200
++++ a/b/boost/boost/random/uniform_real_distribution.hpp 2013-05-31 18:14:28.452337186 +0200
+@@ -36,7 +36,6 @@
+ {
+ for(;;) {
+ typedef T result_type;
+- typedef typename Engine::result_type base_result;
+ result_type numerator = static_cast<T>(eng() - (eng.min)());
+ result_type divisor = static_cast<T>((eng.max)() - (eng.min)());
+ BOOST_ASSERT(divisor > 0);
+--- a/b/boost/boost/math/special_functions/fpclassify.hpp 2013-05-31 14:02:13.660436127 +0200
++++ a/b/boost/boost/math/special_functions/fpclassify.hpp 2013-05-31 14:01:17.372246240 +0200
+@@ -339,7 +338,6 @@
+ { //!< \brief return true if floating-point type t is finite.
+ typedef detail::fp_traits<long double>::type traits;
+ typedef traits::method method;
+- typedef boost::is_floating_point<long double>::type fp_tag;
+ typedef long double value_type;
+ return detail::isfinite_impl(static_cast<value_type>(x), method());
+ }
+@@ -410,7 +407,6 @@
+ {
+ typedef detail::fp_traits<long double>::type traits;
+ typedef traits::method method;
+- typedef boost::is_floating_point<long double>::type fp_tag;
+ typedef long double value_type;
+ return detail::isnormal_impl(static_cast<value_type>(x), method());
+ }
+@@ -499,7 +494,6 @@
+ {
+ typedef detail::fp_traits<long double>::type traits;
+ typedef traits::method method;
+- typedef boost::is_floating_point<long double>::type fp_tag;
+ typedef long double value_type;
+ return detail::isinf_impl(static_cast<value_type>(x), method());
+ }
+@@ -585,7 +578,6 @@
+ { //!< \brief return true if floating-point type t is NaN (Not A Number).
+ typedef detail::fp_traits<long double>::type traits;
+ typedef traits::method method;
+- typedef boost::is_floating_point<long double>::type fp_tag;
+ return detail::isnan_impl(x, method());
+ }
+ #endif
+--- a/b/boost/boost/date_time/gregorian/greg_facet.hpp 2013-05-31 14:03:30.476695310 +0200
++++ a/b/boost/boost/date_time/gregorian/greg_facet.hpp 2013-05-31 14:03:22.894669713 +0200
+@@ -215,7 +215,6 @@
+ {
+ std::istream_iterator<std::basic_string<charT>, charT> beg(is), eos;
+
+- typedef boost::date_time::all_date_names_put<greg_facet_config, charT> facet_def;
+ d = from_stream(beg, eos);
+ return is;
+ }
+--- a/b/boost/boost/unordered/detail/unique.hpp 2013-05-31 13:32:51.122254361 +0200
++++ a/b/boost/boost/unordered/detail/unique.hpp 2013-05-31 13:32:57.578278121 +0200
+@@ -334,8 +334,6 @@
+
+ value_type& operator[](key_type const& k)
+ {
+- typedef typename value_type::second_type mapped_type;
+-
+ std::size_t key_hash = this->hash(k);
+ iterator pos = this->find_node(key_hash, k);
+
+--- a/b/boost/boost/tuple/detail/tuple_basic.hpp 2013-05-31 13:31:21.682966336 +0200
++++ a/b/boost/boost/tuple/detail/tuple_basic.hpp 2013-05-31 13:32:44.067231648 +0200
+@@ -225,7 +225,6 @@
+ get(const cons<HT, TT>& c BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {
+ typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
+ apply<cons<HT, TT> > impl;
+- typedef BOOST_DEDUCED_TYPENAME impl::type cons_element;
+ return impl::call(c).head;
+ }
+
+--- misc/boost_1_44_0/boost/algorithm/string/detail/finder.hpp
++++ misc/build/boost_1_44_0/boost/algorithm/string/detail/finder.hpp
+@@ -142,7 +142,6 @@
+ ForwardIteratorT End,
+ std::forward_iterator_tag ) const
+ {
+- typedef ForwardIteratorT input_iterator_type;
+ typedef iterator_range<ForwardIteratorT> result_type;
+
+ first_finder_type first_finder(
+@@ -263,7 +262,6 @@
+ ForwardIteratorT End,
+ unsigned int N) const
+ {
+- typedef ForwardIteratorT input_iterator_type;
+ typedef iterator_range<ForwardIteratorT> result_type;
+
+ // Sanity check
+@@ -298,7 +296,6 @@
+ ForwardIteratorT End,
+ unsigned int N) const
+ {
+- typedef ForwardIteratorT input_iterator_type;
+ typedef iterator_range<ForwardIteratorT> result_type;
+
+ // Sanity check
+@@ -362,7 +359,6 @@
+ unsigned int N,
+ std::random_access_iterator_tag )
+ {
+- typedef ForwardIteratorT input_iterator_type;
+ typedef iterator_range<ForwardIteratorT> result_type;
+
+ if ( (End<=Begin) || ( static_cast<unsigned int>(End-Begin) < N ) )
+@@ -436,7 +432,6 @@
+ unsigned int N,
+ std::random_access_iterator_tag )
+ {
+- typedef ForwardIteratorT input_iterator_type;
+ typedef iterator_range<ForwardIteratorT> result_type;
+
+ if ( (End<=Begin) || ( static_cast<unsigned int>(End-Begin) < N ) )
+--- misc/boost_1_44_0/boost/bind/arg.hpp
++++ misc/build/boost_1_44_0/boost/bind/arg.hpp
+@@ -35,6 +35,8 @@
+ {
+ // static assert I == is_placeholder<T>::value
+ typedef char T_must_be_placeholder[ I == is_placeholder<T>::value? 1: -1 ];
++ T_must_be_placeholder dummy; (void) dummy;
++ // silence -Werror=unused-local-typedefs (GCC 4.8)
+ }
+ };
+
+--- misc/boost_1_44_0/boost/concept/detail/general.hpp
++++ misc/build/boost_1_44_0/boost/concept/detail/general.hpp
+@@ -68,7 +68,9 @@
+ # define BOOST_CONCEPT_ASSERT_FN( ModelFnPtr ) \
+ typedef ::boost::concepts::detail::instantiate< \
+ &::boost::concepts::requirement_<ModelFnPtr>::failed> \
+- BOOST_PP_CAT(boost_concept_check,__LINE__)
++ BOOST_PP_CAT(boost_concept_check,__LINE__); \
++ void BOOST_PP_CAT(boost_concept_check_dummy,__LINE__)(BOOST_PP_CAT(boost_concept_check,__LINE__) *)
++ // silence -Werror=unused-local-typedefs (GCC 4.8)
+
+ }}
+
+--- misc/boost_1_44_0/boost/date_time/date_parsing.hpp
++++ misc/build/boost_1_44_0/boost/date_time/date_parsing.hpp
+@@ -113,7 +113,6 @@
+ spec_str = "mdy";
+ }
+
+- typedef typename date_type::year_type year_type;
+ typedef typename date_type::month_type month_type;
+ unsigned pos = 0;
+ unsigned short year(0), month(0), day(0);
+@@ -159,7 +158,7 @@
+ parse_undelimited_date(const std::string& s) {
+ int offsets[] = {4,2,2};
+ int pos = 0;
+- typedef typename date_type::year_type year_type;
++ //typedef typename date_type::year_type year_type;
+ //typename date_type::ymd_type ymd((year_type::min)(),1,1);
+ unsigned short y = 0, m = 0, d = 0;
+
+--- misc/boost_1_44_0/boost/date_time/local_time/local_time_io.hpp
++++ misc/build/boost_1_44_0/boost/date_time/local_time/local_time_io.hpp
+@@ -36,7 +36,6 @@
+ boost::io::ios_flags_saver iflags(os);
+ typedef local_date_time time_type;//::utc_time_type typename
+ typedef date_time::time_facet<time_type, CharT> custom_time_facet;
+- typedef std::time_put<CharT> std_time_facet;
+ std::ostreambuf_iterator<CharT> oitr(os);
+
+ if(std::has_facet<custom_time_facet>(os.getloc())) {
+@@ -123,7 +122,6 @@
+ const boost::local_time::local_time_period& p) {
+ boost::io::ios_flags_saver iflags(os);
+ typedef boost::date_time::time_facet<local_date_time, CharT> custom_facet;
+- typedef std::time_put<CharT> std_time_facet;
+ std::ostreambuf_iterator<CharT> oitr(os);
+ if (std::has_facet<custom_facet>(os.getloc())) {
+ std::use_facet<custom_facet>(os.getloc()).put(oitr, os, os.fill(), p);
+--- misc/boost_1_44_0/boost/date_time/posix_time/posix_time_io.hpp
++++ misc/build/boost_1_44_0/boost/date_time/posix_time/posix_time_io.hpp
+@@ -47,7 +47,6 @@
+ const ptime& p) {
+ boost::io::ios_flags_saver iflags(os);
+ typedef boost::date_time::time_facet<ptime, CharT> custom_ptime_facet;
+- typedef std::time_put<CharT> std_ptime_facet;
+ std::ostreambuf_iterator<CharT> oitr(os);
+ if (std::has_facet<custom_ptime_facet>(os.getloc()))
+ std::use_facet<custom_ptime_facet>(os.getloc()).put(oitr, os, os.fill(), p);
+@@ -114,7 +113,6 @@
+ const boost::posix_time::time_period& p) {
+ boost::io::ios_flags_saver iflags(os);
+ typedef boost::date_time::time_facet<ptime, CharT> custom_ptime_facet;
+- typedef std::time_put<CharT> std_time_facet;
+ std::ostreambuf_iterator<CharT> oitr(os);
+ if (std::has_facet<custom_ptime_facet>(os.getloc())) {
+ std::use_facet<custom_ptime_facet>(os.getloc()).put(oitr, os, os.fill(), p);
+@@ -180,7 +178,6 @@
+ {
+ boost::io::ios_flags_saver iflags(os);
+ typedef boost::date_time::time_facet<ptime, CharT> custom_ptime_facet;
+- typedef std::time_put<CharT> std_ptime_facet;
+ std::ostreambuf_iterator<CharT> oitr(os);
+ if (std::has_facet<custom_ptime_facet>(os.getloc()))
+ std::use_facet<custom_ptime_facet>(os.getloc()).put(oitr, os, os.fill(), td);
+--- misc/boost_1_44_0/boost/date_time/string_convert.hpp
++++ misc/build/boost_1_44_0/boost/date_time/string_convert.hpp
+@@ -21,7 +21,6 @@
+ inline
+ std::basic_string<OutputT> convert_string_type(const std::basic_string<InputT>& inp_str)
+ {
+- typedef std::basic_string<InputT> input_type;
+ typedef std::basic_string<OutputT> output_type;
+ output_type result;
+ result.insert(result.begin(), inp_str.begin(), inp_str.end());
+--- misc/boost_1_44_0/boost/date_time/strings_from_facet.hpp
++++ misc/build/boost_1_44_0/boost/date_time/strings_from_facet.hpp
+@@ -35,7 +35,6 @@
+ {
+ typedef std::basic_string<charT> string_type;
+ typedef std::vector<string_type> collection_type;
+- typedef std::basic_ostringstream<charT> ostream_type;
+ typedef std::ostreambuf_iterator<charT> ostream_iter_type;
+ typedef std::basic_ostringstream<charT> stringstream_type;
+ typedef std::time_put<charT> time_put_facet_type;
+@@ -85,7 +84,6 @@
+ {
+ typedef std::basic_string<charT> string_type;
+ typedef std::vector<string_type> collection_type;
+- typedef std::basic_ostringstream<charT> ostream_type;
+ typedef std::ostreambuf_iterator<charT> ostream_iter_type;
+ typedef std::basic_ostringstream<charT> stringstream_type;
+ typedef std::time_put<charT> time_put_facet_type;
+--- misc/boost_1_44_0/boost/multi_array/concept_checks.hpp
++++ misc/build/boost_1_44_0/boost/multi_array/concept_checks.hpp
+@@ -39,8 +39,6 @@
+
+ template <typename Array, typename IdxGen, typename Call_Type>
+ static void call(Array& a, const IdxGen& idgen, Call_Type c) {
+- typedef typename Array::index_range index_range_;
+- typedef typename Array::index index_;
+ idgen_helper<N-1>::call(a,idgen[c],c);
+ }
+ };
+@@ -50,8 +48,6 @@
+
+ template <typename Array, typename IdxGen, typename Call_Type>
+ static void call(Array& a, const IdxGen& idgen, Call_Type) {
+- typedef typename Array::index_range index_range_;
+- typedef typename Array::index index_;
+ a[ idgen ];
+ }
+ };
+--- misc/boost_1_44_0/boost/spirit/home/classic/core/non_terminal/impl/grammar.ipp
++++ misc/build/boost_1_44_0/boost/spirit/home/classic/core/non_terminal/impl/grammar.ipp
+@@ -307,7 +307,6 @@
+ #if !defined(BOOST_SPIRIT_SINGLE_GRAMMAR_INSTANCE)
+ typedef impl::grammar_helper_base<GrammarT> helper_base_t;
+ typedef grammar_helper_list<GrammarT> helper_list_t;
+- typedef typename helper_list_t::vector_t::reverse_iterator iterator_t;
+
+ helper_list_t& helpers =
+ # if !defined(__GNUC__) || (__GNUC__ > 2)
+@@ -318,6 +317,7 @@
+
+ # if (defined(BOOST_MSVC) && (BOOST_MSVC < 1300)) \
+ || defined(BOOST_INTEL_CXX_VERSION)
++ typedef typename helper_list_t::vector_t::reverse_iterator iterator_t;
+ for (iterator_t i = helpers.rbegin(); i != helpers.rend(); ++i)
+ (*i)->undefine(self);
+ # else
+--- misc/boost_1_44_0/boost/spirit/home/classic/core/primitives/primitives.hpp
++++ misc/build/boost_1_44_0/boost/spirit/home/classic/core/primitives/primitives.hpp
+@@ -47,7 +47,6 @@
+ typename parser_result<self_t, ScannerT>::type
+ parse(ScannerT const& scan) const
+ {
+- typedef typename parser_result<self_t, ScannerT>::type result_t;
+ typedef typename ScannerT::value_t value_t;
+ typedef typename ScannerT::iterator_t iterator_t;
+
+--- misc/boost_1_44_0/boost/spirit/home/classic/error_handling/exceptions.hpp
++++ misc/build/boost_1_44_0/boost/spirit/home/classic/error_handling/exceptions.hpp
+@@ -140,7 +140,6 @@
+ parse(ScannerT const& scan) const
+ {
+ typedef typename parser_result<ParserT, ScannerT>::type result_t;
+- typedef typename ScannerT::iterator_t iterator_t;
+
+ result_t hit = this->subject().parse(scan);
+ if (!hit)
+--- misc/boost_1_44_0/boost/spirit/home/classic/utility/functor_parser.hpp
++++ misc/build/boost_1_44_0/boost/spirit/home/classic/utility/functor_parser.hpp
+@@ -49,8 +49,6 @@
+ typename parser_result<self_t, ScannerT>::type
+ parse(ScannerT const& scan) const
+ {
+- typedef typename parser_result<self_t, ScannerT>::type result_t;
+- typedef typename ScannerT::value_t value_t;
+ typedef typename ScannerT::iterator_t iterator_t;
+
+ iterator_t const s(scan.first);
+--- misc/boost_1_44_0/boost/date_time/time_facet.hpp
++++ misc/build/boost_1_44_0/boost/date_time/time_facet.hpp
+@@ -439,31 +439,31 @@
+ time_dur_arg.get_rep().as_special());
+ }
+
+- string_type format(m_time_duration_format);
++ string_type lcl_format(m_time_duration_format);
+ if (time_dur_arg.is_negative()) {
+ // replace %- with minus sign. Should we use the numpunct facet?
+- boost::algorithm::replace_all(format,
++ boost::algorithm::replace_all(lcl_format,
+ duration_sign_negative_only,
+ negative_sign);
+ // remove all the %+ in the string with '-'
+- boost::algorithm::replace_all(format,
++ boost::algorithm::replace_all(lcl_format,
+ duration_sign_always,
+ negative_sign);
+ }
+ else { //duration is positive
+ // remove all the %- combos from the string
+- boost::algorithm::erase_all(format, duration_sign_negative_only);
++ boost::algorithm::erase_all(lcl_format, duration_sign_negative_only);
+ // remove all the %+ in the string with '+'
+- boost::algorithm::replace_all(format,
++ boost::algorithm::replace_all(lcl_format,
+ duration_sign_always,
+ positive_sign);
+ }
+
+ // %T and %R have to be replaced here since they are not standard
+- boost::algorithm::replace_all(format,
++ boost::algorithm::replace_all(lcl_format,
+ boost::as_literal(formats_type::full_24_hour_time_format),
+ boost::as_literal(formats_type::full_24_hour_time_expanded_format));
+- boost::algorithm::replace_all(format,
++ boost::algorithm::replace_all(lcl_format,
+ boost::as_literal(formats_type::short_24_hour_time_format),
+ boost::as_literal(formats_type::short_24_hour_time_expanded_format));
+
+@@ -476,22 +476,22 @@
+ * here ourself.
+ */
+ string_type hours_str;
+- if (format.find(unrestricted_hours_format) != string_type::npos) {
++ if (lcl_format.find(unrestricted_hours_format) != string_type::npos) {
+ hours_str = hours_as_string(time_dur_arg);
+- boost::algorithm::replace_all(format, unrestricted_hours_format, hours_str);
++ boost::algorithm::replace_all(lcl_format, unrestricted_hours_format, hours_str);
+ }
+ // We still have to process restricted hours format specifier. In order to
+ // support parseability of durations in ISO format (%H%M%S), we'll have to
+ // restrict the stringified hours length to 2 characters.
+- if (format.find(hours_format) != string_type::npos) {
++ if (lcl_format.find(hours_format) != string_type::npos) {
+ if (hours_str.empty())
+ hours_str = hours_as_string(time_dur_arg);
+ BOOST_ASSERT(hours_str.length() <= 2);
+- boost::algorithm::replace_all(format, hours_format, hours_str);
++ boost::algorithm::replace_all(lcl_format, hours_format, hours_str);
+ }
+
+ string_type frac_str;
+- if (format.find(seconds_with_fractional_seconds_format) != string_type::npos) {
++ if (lcl_format.find(seconds_with_fractional_seconds_format) != string_type::npos) {
+ // replace %s with %S.nnn
+ frac_str =
+ fractional_seconds_as_string(time_dur_arg, false);
+@@ -500,21 +500,21 @@
+ string_type replace_string(seconds_format);
+ replace_string += sep;
+ replace_string += frac_str;
+- boost::algorithm::replace_all(format,
++ boost::algorithm::replace_all(lcl_format,
+ seconds_with_fractional_seconds_format,
+ replace_string);
+ }
+- if (format.find(fractional_seconds_format) != string_type::npos) {
++ if (lcl_format.find(fractional_seconds_format) != string_type::npos) {
+ // replace %f with nnnnnnn
+ if (!frac_str.size()) {
+ frac_str = fractional_seconds_as_string(time_dur_arg, false);
+ }
+- boost::algorithm::replace_all(format,
++ boost::algorithm::replace_all(lcl_format,
+ fractional_seconds_format,
+ frac_str);
+ }
+
+- if (format.find(fractional_seconds_or_none_format) != string_type::npos) {
++ if (lcl_format.find(fractional_seconds_or_none_format) != string_type::npos) {
+ // replace %F with nnnnnnn or nothing if fs == 0
+ frac_str =
+ fractional_seconds_as_string(time_dur_arg, true);
+@@ -523,18 +523,18 @@
+ string_type replace_string;
+ replace_string += sep;
+ replace_string += frac_str;
+- boost::algorithm::replace_all(format,
++ boost::algorithm::replace_all(lcl_format,
+ fractional_seconds_or_none_format,
+ replace_string);
+ }
+ else {
+- boost::algorithm::erase_all(format,
++ boost::algorithm::erase_all(lcl_format,
+ fractional_seconds_or_none_format);
+ }
+ }
+
+ return this->do_put_tm(next_arg, ios_arg, fill_arg,
+- to_tm(time_dur_arg), format);
++ to_tm(time_dur_arg), lcl_format);
+ }
+
+ OutItrT put(OutItrT next, std::ios_base& ios_arg,
diff --git a/external/boost/boost_1_44_0-unused-parameters.patch b/external/boost/boost_1_44_0-unused-parameters.patch
new file mode 100644
index 000000000000..4fe61bac6959
--- /dev/null
+++ b/external/boost/boost_1_44_0-unused-parameters.patch
@@ -0,0 +1,916 @@
+--- misc/boost_1_44_0/boost/bind/bind.hpp 2009-11-30 21:30:22.000000000 +0100
++++ misc/build/boost_1_44_0/boost/bind/bind.hpp 2012-01-20 12:44:07.111316403 +0100
+@@ -143,7 +143,7 @@
+
+ template<class F> struct unwrapper
+ {
+- static inline F & unwrap( F & f, long )
++ static inline F & unwrap( F & f, __attribute__ ((unused)) long )
+ {
+ return f;
+ }
+@@ -226,7 +226,7 @@
+
+ A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
+
+- A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
++ A1 operator[] (__attribute__ ((unused)) boost::arg<1> (*) ()) const { return base_type::a1_; }
+
+ template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
+
+@@ -238,22 +238,22 @@
+
+ template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+
+- template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
++ template<class R, class F, class A> R operator()(type<R>, F & f, A & a, __attribute__ ((unused)) long)
+ {
+ return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);
+ }
+
+- template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
++ template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, __attribute__ ((unused)) long) const
+ {
+ return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_]);
+ }
+
+- template<class F, class A> void operator()(type<void>, F & f, A & a, int)
++ template<class F, class A> void operator()(type<void>, F & f, A & a, __attribute__ ((unused)) int)
+ {
+ unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);
+ }
+
+- template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
++ template<class F, class A> void operator()(type<void>, F const & f, A & a, __attribute__ ((unused)) int) const
+ {
+ unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_]);
+ }
+@@ -285,8 +285,8 @@
+ A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
+ A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
+
+- A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
+- A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
++ A1 operator[] (__attribute__ ((unused)) boost::arg<1> (*) ()) const { return base_type::a1_; }
++ A2 operator[] (__attribute__ ((unused)) boost::arg<2> (*) ()) const { return base_type::a2_; }
+
+ template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
+
+@@ -298,22 +298,22 @@
+
+ template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+
+- template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
++ template<class R, class F, class A> R operator()(type<R>, F & f, A & a, __attribute__ ((unused)) long)
+ {
+ return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
+ }
+
+- template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
++ template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, __attribute__ ((unused)) long) const
+ {
+ return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
+ }
+
+- template<class F, class A> void operator()(type<void>, F & f, A & a, int)
++ template<class F, class A> void operator()(type<void>, F & f, A & a, __attribute__ ((unused)) int)
+ {
+ unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
+ }
+
+- template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
++ template<class F, class A> void operator()(type<void>, F const & f, A & a, __attribute__ ((unused)) int) const
+ {
+ unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
+ }
+@@ -377,7 +377,7 @@
+
+ template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+
+- template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
++ template<class R, class F, class A> R operator()(type<R>, F & f, A & a, __attribute__ ((unused)) long)
+ {
+ return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
+ }
+@@ -387,12 +387,12 @@
+ return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
+ }
+
+- template<class F, class A> void operator()(type<void>, F & f, A & a, int)
++ template<class F, class A> void operator()(type<void>, F & f, A & a, __attribute__ ((unused)) int)
+ {
+ unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
+ }
+
+- template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
++ template<class F, class A> void operator()(type<void>, F const & f, A & a, __attribute__ ((unused)) int) const
+ {
+ unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
+ }
+@@ -427,10 +427,10 @@
+ A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
+ A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
+
+- A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
+- A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
+- A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
+- A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
++ A1 operator[] (__attribute__ ((unused)) boost::arg<1> (*) ()) const { return base_type::a1_; }
++ A2 operator[] (__attribute__ ((unused)) boost::arg<2> (*) ()) const { return base_type::a2_; }
++ A3 operator[] (__attribute__ ((unused)) boost::arg<3> (*) ()) const { return base_type::a3_; }
++ A4 operator[] (__attribute__ ((unused)) boost::arg<4> (*) ()) const { return base_type::a4_; }
+
+ template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
+
+@@ -442,7 +442,7 @@
+
+ template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+
+- template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
++ template<class R, class F, class A> R operator()(type<R>, F & f, A & a, __attribute__ ((unused)) long)
+ {
+ return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
+ }
+@@ -452,7 +452,7 @@
+ return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
+ }
+
+- template<class F, class A> void operator()(type<void>, F & f, A & a, int)
++ template<class F, class A> void operator()(type<void>, F & f, A & a, __attribute__ ((unused)) int)
+ {
+ unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
+ }
+@@ -510,7 +510,7 @@
+
+ template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+
+- template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
++ template<class R, class F, class A> R operator()(type<R>, F & f, A & a, __attribute__ ((unused)) long)
+ {
+ return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
+ }
+@@ -520,7 +520,7 @@
+ return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
+ }
+
+- template<class F, class A> void operator()(type<void>, F & f, A & a, int)
++ template<class F, class A> void operator()(type<void>, F & f, A & a, __attribute__ ((unused)) int)
+ {
+ unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
+ }
+@@ -591,7 +591,7 @@
+ return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
+ }
+
+- template<class F, class A> void operator()(type<void>, F & f, A & a, int)
++ template<class F, class A> void operator()(type<void>, F & f, A & a, __attribute__ ((unused)) int)
+ {
+ unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
+ }
+--- misc/boost_1_44_0/boost/bind/mem_fn.hpp 2009-03-02 17:15:40.000000000 +0100
++++ misc/build/boost_1_44_0/boost/bind/mem_fn.hpp 2012-01-20 12:44:07.112316398 +0100
+@@ -328,7 +328,7 @@
+ return (u.*f_);
+ }
+
+- template<class U> R const & call(U & u, void const *) const
++ template<class U> R const & call(U & u, __attribute__ ((unused)) void const *) const
+ {
+ return (get_pointer(u)->*f_);
+ }
+--- misc/boost_1_44_0/boost/bind/mem_fn_template.hpp 2009-12-03 18:44:37.000000000 +0100
++++ misc/build/boost_1_44_0/boost/bind/mem_fn_template.hpp 2012-01-20 12:44:07.112316398 +0100
+@@ -35,7 +35,7 @@
+ BOOST_MEM_FN_RETURN (u.*f_)();
+ }
+
+- template<class U> R call(U & u, void const *) const
++ template<class U> R call(U & u, __attribute__ ((unused)) void const *) const
+ {
+ BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)();
+ }
+@@ -100,7 +100,7 @@
+ BOOST_MEM_FN_RETURN (u.*f_)();
+ }
+
+- template<class U> R call(U & u, void const *) const
++ template<class U> R call(U & u, __attribute__ ((unused)) void const *) const
+ {
+ BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)();
+ }
+@@ -146,12 +146,12 @@
+ BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1))
+ F f_;
+
+- template<class U, class B1> R call(U & u, T const *, B1 & b1) const
++ template<class U, class B1> R call(U & u, __attribute__ ((unused)) T const *, B1 & b1) const
+ {
+ BOOST_MEM_FN_RETURN (u.*f_)(b1);
+ }
+
+- template<class U, class B1> R call(U & u, void const *, B1 & b1) const
++ template<class U, class B1> R call(U & u, __attribute__ ((unused)) void const *, B1 & b1) const
+ {
+ BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1);
+ }
+@@ -217,7 +217,7 @@
+ BOOST_MEM_FN_RETURN (u.*f_)(b1);
+ }
+
+- template<class U, class B1> R call(U & u, void const *, B1 & b1) const
++ template<class U, class B1> R call(U & u, __attribute__ ((unused)) void const *, B1 & b1) const
+ {
+ BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1);
+ }
+@@ -266,7 +266,7 @@
+ BOOST_MEM_FN_RETURN (u.*f_)(b1, b2);
+ }
+
+- template<class U, class B1, class B2> R call(U & u, void const *, B1 & b1, B2 & b2) const
++ template<class U, class B1, class B2> R call(U & u, __attribute__ ((unused)) void const *, B1 & b1, B2 & b2) const
+ {
+ BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2);
+ }
+@@ -330,7 +330,7 @@
+ BOOST_MEM_FN_RETURN (u.*f_)(b1, b2);
+ }
+
+- template<class U, class B1, class B2> R call(U & u, void const *, B1 & b1, B2 & b2) const
++ template<class U, class B1, class B2> R call(U & u, __attribute__ ((unused)) void const *, B1 & b1, B2 & b2) const
+ {
+ BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2);
+ }
+@@ -379,7 +379,7 @@
+ BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3);
+ }
+
+- template<class U, class B1, class B2, class B3> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3) const
++ template<class U, class B1, class B2, class B3> R call(U & u, __attribute__ ((unused)) void const *, B1 & b1, B2 & b2, B3 & b3) const
+ {
+ BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3);
+ }
+@@ -492,7 +492,7 @@
+ BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4);
+ }
+
+- template<class U, class B1, class B2, class B3, class B4> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
++ template<class U, class B1, class B2, class B3, class B4> R call(U & u, __attribute__ ((unused)) void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
+ {
+ BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4);
+ }
+@@ -556,7 +556,7 @@
+ BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4);
+ }
+
+- template<class U, class B1, class B2, class B3, class B4> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
++ template<class U, class B1, class B2, class B3, class B4> R call(U & u, __attribute__ ((unused)) void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
+ {
+ BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4);
+ }
+--- misc/boost_1_44_0/boost/detail/dynamic_bitset.hpp 2008-10-21 20:13:59.000000000 +0200
++++ misc/build/boost_1_44_0/boost/detail/dynamic_bitset.hpp 2012-01-20 12:44:07.113316394 +0100
+@@ -100,8 +100,8 @@
+
+ template <typename Iterator>
+ inline std::size_t do_count(Iterator first, std::size_t length,
+- int /*dummy param*/,
+- value_to_type<access_by_bytes>* )
++ __attribute__ ((unused)) int /*dummy param*/,
++ __attribute__ ((unused)) value_to_type<access_by_bytes>* )
+ {
+ std::size_t num = 0;
+ if (length)
+--- misc/boost_1_44_0/boost/foreach.hpp 2010-07-30 22:26:40.000000000 +0200
++++ misc/build/boost_1_44_0/boost/foreach.hpp 2012-01-20 12:44:07.114316390 +0100
+@@ -610,7 +610,7 @@
+ }
+
+ template<typename T>
+-inline auto_any<T *> contain(T &t, boost::mpl::false_ *) // lvalue
++inline auto_any<T *> contain(T &t, __attribute__ ((unused)) boost::mpl::false_ *) // lvalue
+ {
+ // Cannot seem to get sunpro to handle addressof() with array types.
+ #if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x570))
+@@ -641,7 +641,7 @@
+
+ template<typename T, typename C>
+ inline auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type>
+-begin(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *) // lvalue
++begin(auto_any_t col, __attribute__ ((unused)) type2type<T, C> *, __attribute__ ((unused)) boost::mpl::false_ *) // lvalue
+ {
+ typedef BOOST_DEDUCED_TYPENAME type2type<T, C>::type type;
+ typedef BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type iterator;
+@@ -678,7 +678,7 @@
+
+ template<typename T, typename C>
+ inline auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type>
+-end(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *) // lvalue
++end(auto_any_t col, __attribute__ ((unused)) type2type<T, C> *, __attribute__ ((unused)) boost::mpl::false_ *) // lvalue
+ {
+ typedef BOOST_DEDUCED_TYPENAME type2type<T, C>::type type;
+ typedef BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type iterator;
+@@ -707,7 +707,7 @@
+ // done
+ //
+ template<typename T, typename C>
+-inline bool done(auto_any_t cur, auto_any_t end, type2type<T, C> *)
++inline bool done(auto_any_t cur, auto_any_t end, __attribute__ ((unused)) type2type<T, C> *)
+ {
+ typedef BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type iter_t;
+ return auto_any_cast<iter_t, boost::mpl::false_>(cur) == auto_any_cast<iter_t, boost::mpl::false_>(end);
+@@ -725,7 +725,7 @@
+ // next
+ //
+ template<typename T, typename C>
+-inline void next(auto_any_t cur, type2type<T, C> *)
++inline void next(auto_any_t cur, __attribute__ ((unused)) type2type<T, C> *)
+ {
+ typedef BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type iter_t;
+ ++auto_any_cast<iter_t, boost::mpl::false_>(cur);
+@@ -736,7 +736,7 @@
+ //
+ template<typename T, typename C>
+ inline BOOST_DEDUCED_TYPENAME foreach_reference<T, C>::type
+-deref(auto_any_t cur, type2type<T, C> *)
++deref(auto_any_t cur, __attribute__ ((unused)) type2type<T, C> *)
+ {
+ typedef BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type iter_t;
+ return *auto_any_cast<iter_t, boost::mpl::false_>(cur);
+--- misc/boost_1_44_0/boost/function/function_template.hpp 2009-07-09 01:23:52.000000000 +0200
++++ misc/build/boost_1_44_0/boost/function/function_template.hpp 2012-01-20 15:29:25.217770399 +0100
+@@ -711,7 +711,7 @@
+ template<typename Functor>
+ BOOST_FUNCTION_FUNCTION(Functor BOOST_FUNCTION_TARGET_FIX(const &) f
+ #ifndef BOOST_NO_SFINAE
+- ,typename enable_if_c<
++ ,__attribute__ ((unused)) typename enable_if_c<
+ (boost::type_traits::ice_not<
+ (is_integral<Functor>::value)>::value),
+ int>::type = 0
+@@ -724,7 +724,7 @@
+ template<typename Functor,typename Allocator>
+ BOOST_FUNCTION_FUNCTION(Functor BOOST_FUNCTION_TARGET_FIX(const &) f, Allocator a
+ #ifndef BOOST_NO_SFINAE
+- ,typename enable_if_c<
++ ,__attribute__ ((unused)) typename enable_if_c<
+ (boost::type_traits::ice_not<
+ (is_integral<Functor>::value)>::value),
+ int>::type = 0
+@@ -1055,7 +1055,7 @@
+ template<typename Functor>
+ function(Functor f
+ #ifndef BOOST_NO_SFINAE
+- ,typename enable_if_c<
++ ,__attribute__ ((unused)) typename enable_if_c<
+ (boost::type_traits::ice_not<
+ (is_integral<Functor>::value)>::value),
+ int>::type = 0
+@@ -1067,7 +1067,7 @@
+ template<typename Functor,typename Allocator>
+ function(Functor f, Allocator a
+ #ifndef BOOST_NO_SFINAE
+- ,typename enable_if_c<
++ ,__attribute__ ((unused)) typename enable_if_c<
+ (boost::type_traits::ice_not<
+ (is_integral<Functor>::value)>::value),
+ int>::type = 0
+--- misc/boost_1_44_0/boost/iterator/reverse_iterator.hpp 2004-08-12 19:13:07.000000000 +0200
++++ misc/build/boost_1_44_0/boost/iterator/reverse_iterator.hpp 2012-01-20 12:44:07.122316355 +0100
+@@ -34,7 +34,7 @@
+ template<class OtherIterator>
+ reverse_iterator(
+ reverse_iterator<OtherIterator> const& r
+- , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0
++ , __attribute__ ((unused)) typename enable_if_convertible<OtherIterator, Iterator>::type* = 0
+ )
+ : super_t(r.base())
+ {}
+--- misc/boost_1_44_0/boost/optional/optional.hpp 2012-01-20 15:24:32.364576113 +0100
++++ misc/build/boost_1_44_0/boost/optional/optional.hpp 2012-01-20 12:44:07.123316351 +0100
+@@ -365,7 +365,7 @@
+ // Converting constructions of optional<T> from optional<U> uses this function with
+ // 'Expr' being of type 'U' and relying on a converting constructor of T from U.
+ template<class Expr>
+- void construct ( Expr const& expr, void const* )
++ void construct ( Expr const& expr, __attribute__ ((unused)) void const* )
+ {
+ new (m_storage.address()) internal_type(expr) ;
+ m_initialized = true ;
+@@ -376,7 +376,7 @@
+ // Converting assignments of optional<T> from optional<U> uses this function with
+ // 'Expr' being of type 'U' and relying on a converting assignment of T from U.
+ template<class Expr>
+- void assign_expr_to_initialized ( Expr const& expr, void const* )
++ void assign_expr_to_initialized ( Expr const& expr, __attribute__ ((unused)) void const* )
+ {
+ assign_value(expr, is_reference_predicate());
+ }
+@@ -846,12 +846,12 @@
+
+ template<class T>
+ inline
+-bool operator == ( none_t , optional<T> const& y )
++bool operator == ( __attribute__ ((unused)) none_t , optional<T> const& y )
+ { return equal_pointees(optional<T>() ,y); }
+
+ template<class T>
+ inline
+-bool operator < ( none_t , optional<T> const& y )
++bool operator < ( __attribute__ ((unused)) none_t , optional<T> const& y )
+ { return less_pointees(optional<T>() ,y); }
+
+ template<class T>
+--- misc/boost_1_44_0/boost/spirit/home/classic/actor/ref_const_ref_actor.hpp 2008-06-22 17:05:38.000000000 +0200
++++ misc/build/boost_1_44_0/boost/spirit/home/classic/actor/ref_const_ref_actor.hpp 2012-01-20 12:44:07.124316347 +0100
+@@ -63,8 +63,8 @@
+
+ template<typename IteratorT>
+ void operator()(
+- IteratorT const& /*first*/,
+- IteratorT const& /*last*/
++ __attribute__ ((unused)) IteratorT const& /*first*/,
++ __attribute__ ((unused)) IteratorT const& /*last*/
+ ) const
+ {
+ this->act(ref,value_ref); // defined in ActionT
+--- misc/boost_1_44_0/boost/spirit/home/classic/core/composite/no_actions.hpp
++++ misc/build/boost_1_44_0/boost/spirit/home/classic/core/composite/no_actions.hpp
+@@ -38,10 +38,10 @@
+ template<typename ActorT, typename AttrT, typename IteratorT>
+ void
+ do_action(
+- ActorT const& actor,
+- AttrT& val,
+- IteratorT const& first,
+- IteratorT const& last) const
++ __attribute__ ((unused)) ActorT const& actor,
++ __attribute__ ((unused)) AttrT& val,
++ __attribute__ ((unused)) IteratorT const& first,
++ __attribute__ ((unused)) IteratorT const& last) const
+ {}
+ };
+
+--- misc/boost_1_44_0/boost/spirit/home/classic/core/composite/impl/directives.ipp 2008-06-22 17:05:38.000000000 +0200
++++ misc/build/boost_1_44_0/boost/spirit/home/classic/core/composite/impl/directives.ipp 2012-01-20 12:44:07.124316347 +0100
+@@ -41,7 +41,7 @@
+ contiguous_parser_parse(
+ ST const& s,
+ ScannerT const& scan,
+- skipper_iteration_policy<BaseT> const&)
++ __attribute__ ((unused)) skipper_iteration_policy<BaseT> const&)
+ {
+ typedef scanner_policies<
+ no_skipper_iteration_policy<
+@@ -61,7 +61,7 @@
+ contiguous_parser_parse(
+ ST const& s,
+ ScannerT const& scan,
+- no_skipper_iteration_policy<BaseT> const&)
++ __attribute__ ((unused)) no_skipper_iteration_policy<BaseT> const&)
+ {
+ return s.parse(scan);
+ }
+@@ -85,7 +85,7 @@
+ implicit_lexeme_parse(
+ ParserT const& p,
+ ScannerT const& scan,
+- skipper_iteration_policy<BaseT> const&)
++ __attribute__ ((unused)) skipper_iteration_policy<BaseT> const&)
+ {
+ typedef scanner_policies<
+ no_skipper_iteration_policy<
+@@ -129,7 +129,7 @@
+ inhibit_case_parser_parse(
+ ST const& s,
+ ScannerT const& scan,
+- iteration_policy const&)
++ __attribute__ ((unused)) iteration_policy const&)
+ {
+ typedef scanner_policies<
+ inhibit_case_iteration_policy<
+--- misc/boost_1_44_0/boost/spirit/home/classic/core/non_terminal/impl/grammar.ipp
++++ misc/build/boost_1_44_0/boost/spirit/home/classic/core/non_terminal/impl/grammar.ipp
+@@ -83,7 +83,7 @@
+ { // Does _not_ copy the helpers member !
+ }
+
+- grammar_helper_list& operator=(grammar_helper_list const& x)
++ grammar_helper_list& operator=(__attribute__ ((unused)) grammar_helper_list const& x)
+ { // Does _not_ copy the helpers member !
+ return *this;
+ }
+--- misc/boost_1_44_0/boost/spirit/home/classic/core/non_terminal/parser_context.hpp 2008-06-22 17:05:38.000000000 +0200
++++ misc/build/boost_1_44_0/boost/spirit/home/classic/core/non_terminal/parser_context.hpp 2012-01-20 12:44:07.124316347 +0100
+@@ -51,15 +51,15 @@
+ typedef parser_context_linker<parser_context<AttrT> > context_linker_t;
+
+ template <typename ParserT>
+- parser_context(ParserT const&) {}
++ parser_context(__attribute__ ((unused)) ParserT const&) {}
+
+ template <typename ParserT, typename ScannerT>
+ void
+- pre_parse(ParserT const&, ScannerT const&) {}
++ pre_parse(__attribute__ ((unused)) ParserT const&, __attribute__ ((unused)) ScannerT const&) {}
+
+ template <typename ResultT, typename ParserT, typename ScannerT>
+ ResultT&
+- post_parse(ResultT& hit, ParserT const&, ScannerT const&)
++ post_parse(ResultT& hit, __attribute__ ((unused)) ParserT const&, __attribute__ ((unused)) ScannerT const&)
+ { return hit; }
+ };
+
+--- misc/boost_1_44_0/boost/spirit/home/classic/core/primitives/impl/numerics.ipp 2012-01-20 15:24:32.364576113 +0100
++++ misc/build/boost_1_44_0/boost/spirit/home/classic/core/primitives/impl/numerics.ipp 2012-01-20 12:44:07.125316343 +0100
+@@ -240,7 +240,7 @@
+ }
+
+ template <>
+- inline bool allow_more_digits<-1>(std::size_t)
++ inline bool allow_more_digits<-1>(__attribute__ ((unused)) std::size_t)
+ {
+ return true;
+ }
+--- misc/boost_1_44_0/boost/spirit/home/classic/core/primitives/primitives.hpp 2008-06-22 17:05:38.000000000 +0200
++++ misc/build/boost_1_44_0/boost/spirit/home/classic/core/primitives/primitives.hpp 2012-01-20 12:44:07.125316343 +0100
+@@ -316,7 +316,7 @@
+ anychar_parser() {}
+
+ template <typename CharT>
+- bool test(CharT) const
++ bool test(__attribute__ ((unused)) CharT) const
+ {
+ return true;
+ }
+--- misc/boost_1_44_0/boost/spirit/home/classic/core/scanner/impl/skipper.ipp 2008-06-22 17:05:38.000000000 +0200
++++ misc/build/boost_1_44_0/boost/spirit/home/classic/core/scanner/impl/skipper.ipp 2012-01-20 12:44:07.125316343 +0100
+@@ -122,7 +122,7 @@
+ IteratorT const& first_,
+ IteratorT const& last,
+ ParserT const& p,
+- space_parser const&)
++ __attribute__ ((unused)) space_parser const&)
+ {
+ typedef skipper_iteration_policy<> iter_policy_t;
+ typedef scanner_policies<iter_policy_t> scanner_policies_t;
+--- misc/boost_1_44_0/boost/spirit/home/classic/core/scanner/scanner.hpp 2008-06-22 17:05:38.000000000 +0200
++++ misc/build/boost_1_44_0/boost/spirit/home/classic/core/scanner/scanner.hpp 2012-01-20 12:44:07.126316338 +0100
+@@ -82,18 +82,18 @@
+ create_match(
+ std::size_t length,
+ AttrT const& val,
+- IteratorT const& /*first*/,
+- IteratorT const& /*last*/) const
++ __attribute__ ((unused)) IteratorT const& /*first*/,
++ __attribute__ ((unused)) IteratorT const& /*last*/) const
+ {
+ return match<AttrT>(length, val);
+ }
+
+ template <typename MatchT, typename IteratorT>
+ void group_match(
+- MatchT& /*m*/,
+- parser_id const& /*id*/,
+- IteratorT const& /*first*/,
+- IteratorT const& /*last*/) const {}
++ __attribute__ ((unused)) MatchT& /*m*/,
++ __attribute__ ((unused)) parser_id const& /*id*/,
++ __attribute__ ((unused)) IteratorT const& /*first*/,
++ __attribute__ ((unused)) IteratorT const& /*last*/) const {}
+
+ template <typename Match1T, typename Match2T>
+ void concat_match(Match1T& l, Match2T const& r) const
+@@ -126,8 +126,8 @@
+ call(
+ ActorT const& actor,
+ AttrT& val,
+- IteratorT const&,
+- IteratorT const&)
++ __attribute__ ((unused)) IteratorT const&,
++ __attribute__ ((unused)) IteratorT const&)
+ {
+ actor(val);
+ }
+--- misc/boost_1_44_0/boost/spirit/home/classic/core/scanner/skipper.hpp 2008-06-22 17:05:38.000000000 +0200
++++ misc/build/boost_1_44_0/boost/spirit/home/classic/core/scanner/skipper.hpp 2012-01-20 12:44:07.126316338 +0100
+@@ -82,7 +82,7 @@
+
+ template <typename ScannerT>
+ void
+- skip(ScannerT const& /*scan*/) const {}
++ skip(__attribute__ ((unused)) ScannerT const& /*scan*/) const {}
+ };
+
+ ///////////////////////////////////////////////////////////////////////////
+--- misc/boost_1_44_0/boost/spirit/home/classic/meta/impl/refactoring.ipp 2008-06-22 17:05:38.000000000 +0200
++++ misc/build/boost_1_44_0/boost/spirit/home/classic/meta/impl/refactoring.ipp 2012-01-20 12:44:07.126316338 +0100
+@@ -92,7 +92,7 @@
+
+ template <typename ParserT, typename ScannerT, typename BinaryT>
+ static typename parser_result<ParserT, ScannerT>::type
+- parse(ParserT const &, ScannerT const& scan, BinaryT const& binary)
++ parse(__attribute__ ((unused)) ParserT const &, ScannerT const& scan, BinaryT const& binary)
+ {
+ return binary.parse(scan);
+ }
+@@ -140,7 +140,7 @@
+ template <typename ParserT, typename ScannerT, typename BinaryT>
+ static typename parser_result<ParserT, ScannerT>::type
+ parse(ParserT const &p, ScannerT const& scan, BinaryT const& binary,
+- non_nested_refactoring const&)
++ __attribute__ ((unused)) non_nested_refactoring const&)
+ {
+ typedef
+ typename BinaryT::left_t::parser_category_t
+@@ -205,7 +205,7 @@
+ typename NestedT
+ >
+ static typename parser_result<ParserT, ScannerT>::type
+- parse(ParserT const &, ScannerT const& scan, BinaryT const& binary,
++ parse(__attribute__ ((unused)) ParserT const &, ScannerT const& scan, BinaryT const& binary,
+ NestedT const& nested_d)
+ {
+ typedef typename BinaryT::parser_generator_t binary_gen_t;
+@@ -324,7 +324,7 @@
+ >
+ static typename parser_result<ParserT, ScannerT>::type
+ parse(ParserT const &, ScannerT const& scan, ActionT const &action,
+- NestedT const& nested_d)
++ __attribute__ ((unused)) NestedT const& nested_d)
+ {
+ return action.parse(scan);
+ }
+--- misc/boost_1_44_0/boost/spirit/home/classic/utility/impl/chset.ipp
++++ misc/build/boost_1_44_0/boost/spirit/home/classic/utility/impl/chset.ipp
+@@ -129,7 +129,7 @@
+ }
+
+ template <typename CharT>
+-inline chset<CharT>::chset(nothing_parser arg_)
++inline chset<CharT>::chset(__attribute__ ((unused)) nothing_parser arg_)
+ : ptr(new basic_chset<CharT>()) {}
+
+ template <typename CharT>
+@@ -182,7 +182,7 @@
+
+ template <typename CharT>
+ inline chset<CharT>&
+-chset<CharT>::operator=(anychar_parser rhs)
++chset<CharT>::operator=(__attribute__ ((unused)) anychar_parser rhs)
+ {
+ utility::impl::detach_clear(ptr);
+ ptr->set(
+@@ -194,7 +194,7 @@
+
+ template <typename CharT>
+ inline chset<CharT>&
+-chset<CharT>::operator=(nothing_parser rhs)
++chset<CharT>::operator=(__attribute__ ((unused)) nothing_parser rhs)
+ {
+ utility::impl::detach_clear(ptr);
+ return *this;
+--- misc/boost_1_44_0/boost/spirit/home/classic/utility/impl/chset_operators.ipp 2008-06-22 17:05:38.000000000 +0200
++++ misc/build/boost_1_44_0/boost/spirit/home/classic/utility/impl/chset_operators.ipp 2012-01-20 12:44:07.127316333 +0100
+@@ -576,7 +576,7 @@
+ //////////////////////////////////
+ template <typename CharT>
+ inline chset<CharT>
+-operator-(anychar_parser, chset<CharT> const& b)
++operator-(__attribute__ ((unused)) anychar_parser, chset<CharT> const& b)
+ {
+ return ~b;
+ }
+--- misc/boost_1_44_0/boost/spirit/home/classic/utility/impl/lists.ipp 2008-06-22 17:05:38.000000000 +0200
++++ misc/build/boost_1_44_0/boost/spirit/home/classic/utility/impl/lists.ipp 2012-01-20 12:44:07.127316333 +0100
+@@ -64,8 +64,8 @@
+ typename ItemT, typename DelimT
+ >
+ static typename parser_result<ParserT, ScannerT>::type
+- parse(ScannerT const& scan, ParserT const& /*p*/,
+- ItemT const &item, DelimT const &delim, no_list_endtoken const&)
++ parse(ScannerT const& scan, __attribute__ ((unused)) ParserT const& /*p*/,
++ ItemT const &item, DelimT const &delim, __attribute__ ((unused)) no_list_endtoken const&)
+ {
+ typedef refactor_action_gen<refactor_unary_gen<> > refactor_t;
+ const refactor_t refactor_item_d = refactor_t(refactor_unary_d);
+@@ -112,8 +112,8 @@
+ typename ItemT, typename DelimT
+ >
+ static typename parser_result<ParserT, ScannerT>::type
+- parse(ScannerT const& scan, ParserT const& /*p*/,
+- ItemT const &item, DelimT const &delim, no_list_endtoken const&)
++ parse(ScannerT const& scan, __attribute__ ((unused)) ParserT const& /*p*/,
++ ItemT const &item, DelimT const &delim, __attribute__ ((unused)) no_list_endtoken const&)
+ {
+ return (
+ (item - delim)
+--- misc/boost_1_44_0/boost/spirit/home/classic/phoenix/tuples.hpp
++++ misc/build/boost_1_44_0/boost/spirit/home/classic/phoenix/tuples.hpp
+@@ -211,7 +211,7 @@
+ typedef nil_t& rtype;
+ typedef nil_t const& crtype;
+
+- static nil_t get(TupleT const& t) { return nil_t(); }
++ static nil_t get(__attribute__ ((unused)) TupleT const& t) { return nil_t(); }
+ };
+
+ //////////////////////////////////
+--- misc/boost_1_44_0/boost/throw_exception.hpp 2010-07-03 23:32:02.000000000 +0200
++++ misc/build/boost_1_44_0/boost/throw_exception.hpp 2012-01-20 12:44:07.127316333 +0100
+@@ -49,7 +49,7 @@
+
+ #else
+
+-inline void throw_exception_assert_compatibility( std::exception const & ) { }
++inline void throw_exception_assert_compatibility( __attribute__ ((unused)) std::exception const & ) { }
+
+ template<class E> BOOST_ATTRIBUTE_NORETURN inline void throw_exception( E const & e )
+ {
+--- misc/boost_1_44_0/boost/utility/addressof.hpp 2009-05-16 20:15:17.000000000 +0200
++++ misc/build/boost_1_44_0/boost/utility/addressof.hpp 2012-01-20 12:44:07.128316328 +0100
+@@ -34,7 +34,7 @@
+
+ template<class T> struct addressof_impl
+ {
+- static inline T * f( T & v, long )
++ static inline T * f( T & v, __attribute__ ((unused)) long )
+ {
+ return reinterpret_cast<T*>(
+ &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
+--- misc/boost_1_44_0/boost/variant/detail/visitation_impl.hpp 2010-06-10 17:32:07.000000000 +0200
++++ misc/build/boost_1_44_0/boost/variant/detail/visitation_impl.hpp 2012-01-20 12:44:07.128316328 +0100
+@@ -121,7 +121,7 @@
+ inline
+ BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type)
+ visitation_impl_invoke_impl(
+- int, Visitor& visitor, VoidPtrCV storage, T*
++ int, Visitor& visitor, VoidPtrCV storage, __attribute__ ((unused)) T*
+ , mpl::true_// never_uses_backup
+ )
+ {
+@@ -158,7 +158,7 @@
+ visitation_impl_invoke(
+ int internal_which, Visitor& visitor, VoidPtrCV storage, T* t
+ , NoBackupFlag
+- , int
++ , __attribute__ ((unused)) int
+ )
+ {
+ typedef typename mpl::or_<
+@@ -176,7 +176,7 @@
+ template <typename Visitor, typename VoidPtrCV, typename NBF>
+ inline
+ BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type)
+-visitation_impl_invoke(int, Visitor&, VoidPtrCV, apply_visitor_unrolled*, NBF, long)
++visitation_impl_invoke(__attribute__ ((unused)) int, __attribute__ ((unused)) Visitor&, VoidPtrCV, __attribute__ ((unused)) apply_visitor_unrolled*, NBF, __attribute__ ((unused)) long)
+ {
+ // should never be here at runtime:
+ BOOST_ASSERT(false);
+@@ -198,9 +198,9 @@
+ inline
+ BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type)
+ visitation_impl(
+- int, int, Visitor&, VPCV
++ __attribute__ ((unused)) int, __attribute__ ((unused)) int, __attribute__ ((unused)) Visitor&, VPCV
+ , mpl::true_ // is_apply_visitor_unrolled
+- , NBF, W* = 0, S* = 0
++ , NBF, __attribute__ ((unused)) W* = 0, __attribute__ ((unused)) S* = 0
+ )
+ {
+ // should never be here at runtime:
+@@ -221,7 +221,7 @@
+ , Visitor& visitor, VoidPtrCV storage
+ , mpl::false_ // is_apply_visitor_unrolled
+ , NoBackupFlag no_backup_flag
+- , Which* = 0, step0* = 0
++ , __attribute__ ((unused)) Which* = 0, __attribute__ ((unused)) step0* = 0
+ )
+ {
+ // Typedef apply_visitor_unrolled steps and associated types...
+--- misc/boost_1_44_0/boost/variant/get.hpp 2005-08-25 18:27:28.000000000 +0200
++++ misc/build/boost_1_44_0/boost/variant/get.hpp 2012-01-20 12:44:07.129316324 +0100
+@@ -85,7 +85,7 @@
+ }
+
+ template <typename U>
+- pointer operator()(const U&) const
++ pointer operator()(__attribute__ ((unused)) const U&) const
+ {
+ return static_cast<pointer>(0);
+ }
+--- misc/boost_1_44_0/boost/variant/variant.hpp 2010-06-10 17:32:07.000000000 +0200
++++ misc/build/boost_1_44_0/boost/variant/variant.hpp 2012-01-20 12:44:07.129316324 +0100
+@@ -290,7 +290,7 @@
+
+ template <typename T>
+ BOOST_VARIANT_AUX_RETURN_VOID_TYPE
+- internal_visit(T& operand, int) const
++ internal_visit(T& operand, __attribute__ ((unused)) int) const
+ {
+ operand.~T();
+
+@@ -404,7 +404,7 @@
+
+ template <typename T>
+ BOOST_VARIANT_AUX_RETURN_VOID_TYPE
+- internal_visit(const T& operand, int) const
++ internal_visit(const T& operand, __attribute__ ((unused)) int) const
+ {
+ new(storage_) T(operand);
+ BOOST_VARIANT_AUX_RETURN_VOID;
+@@ -454,7 +454,7 @@
+
+ template <typename T>
+ BOOST_VARIANT_AUX_RETURN_VOID_TYPE
+- internal_visit(T& lhs_content, int) const
++ internal_visit(T& lhs_content, __attribute__ ((unused)) int) const
+ {
+ // NOTE TO USER :
+ // Compile error here indicates one of variant's bounded types does
+@@ -502,7 +502,7 @@
+ }
+
+ template <typename U>
+- bool operator()(U&) BOOST_NOEXCEPT
++ bool operator()(__attribute__ ((unused)) U&) BOOST_NOEXCEPT
+ {
+ return false;
+ }
+@@ -827,7 +827,7 @@
+ public: // internal visitor interfaces
+
+ template <typename T>
+- result_type internal_visit(T& operand, int)
++ result_type internal_visit(T& operand, __attribute__ ((unused)) int)
+ {
+ return visitor_(operand);
+ }
+@@ -1225,7 +1225,7 @@
+ public: // internal visitor interfaces (below)
+
+ template <typename T>
+- int internal_visit(T& operand, int) const
++ int internal_visit(T& operand, __attribute__ ((unused)) int) const
+ {
+ // NOTE TO USER :
+ // Compile error here indicates one of the source variant's types
+@@ -1288,7 +1288,7 @@
+ template <typename T>
+ void convert_construct(
+ T& operand
+- , int
++ , __attribute__ ((unused)) int
+ , mpl::false_ = mpl::false_() // is_foreign_variant
+ )
+ {
+@@ -1308,7 +1308,7 @@
+ template <typename Variant>
+ void convert_construct(
+ Variant& operand
+- , long
++ , __attribute__ ((unused)) long
+ , mpl::true_// is_foreign_variant
+ )
+ {
+@@ -1348,7 +1348,7 @@
+ template <BOOST_VARIANT_ENUM_PARAMS(typename U)>
+ void convert_construct(
+ boost::variant<BOOST_VARIANT_ENUM_PARAMS(U)>& operand
+- , long
++ , __attribute__ ((unused)) long
+ )
+ {
+ convert_construct_variant(operand);
+@@ -1553,7 +1553,7 @@
+
+ template <typename RhsT>
+ BOOST_VARIANT_AUX_RETURN_VOID_TYPE
+- internal_visit(const RhsT& rhs_content, int)
++ internal_visit(const RhsT& rhs_content, __attribute__ ((unused)) int)
+ {
+ typedef typename has_nothrow_copy<RhsT>::type
+ nothrow_copy;
+--- misc/boost_1_44_0/boost/ptr_container/detail/default_deleter.hpp
++++ misc/build/boost_1_44_0/boost/ptr_container/detail/default_deleter.hpp
+@@ -61,7 +61,7 @@
+ {
+ default_deleter() { }
+ template<typename TT>
+- default_deleter(default_deleter<TT> tt) { }
++ default_deleter(__attribute__ ((unused)) default_deleter<TT> tt) { }
+ };
+
+ } } } // End namespaces ptr_container_detail, move_ptrs, boost.
+--- misc/boost_1_44_0/boost/ptr_container/ptr_sequence_adapter.hpp
++++ misc/build/boost_1_44_0/boost/ptr_container/ptr_sequence_adapter.hpp
+@@ -664,8 +664,8 @@
+
+ }
+
+- void range_check_impl( iterator first, iterator last,
+- std::bidirectional_iterator_tag )
++ void range_check_impl( __attribute__ ((unused)) iterator first, __attribute__ ((unused)) iterator last,
++ std::bidirectional_iterator_tag )
+ { /* do nothing */ }
+
+ void range_check_impl( iterator first, iterator last,
generated by cgit (git 2.34.1) at 2025-02-01 04:52:34 +0000