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>
author: Khaled Hosny <khaledhosny@eglug.org> 2013-10-17 01:15:08 +0200
committer: Björn Michaelsen <bjoern.michaelsen@canonical.com> 2013-10-17 10:39:39 +0000
commit: 174e24ffff2f76da94df3bdefa5416c5f2256b78 (patch)
tree: b580a19675daff3882ed415cb36711a17ced94cc /external/boost
parent: fdo#70393: move apache-commons to a subdir of external (diff)
download: core-174e24ffff2f76da94df3bdefa5416c5f2256b78.tar.gz
core-174e24ffff2f76da94df3bdefa5416c5f2256b78.zip
33 files changed, 4261 insertions, 0 deletions
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,
author	Khaled Hosny <khaledhosny@eglug.org>	2013-10-17 01:15:08 +0200
committer	Björn Michaelsen <bjoern.michaelsen@canonical.com>	2013-10-17 10:39:39 +0000
commit	174e24ffff2f76da94df3bdefa5416c5f2256b78 (patch)
tree	b580a19675daff3882ed415cb36711a17ced94cc /external/boost
parent	fdo#70393: move apache-commons to a subdir of external (diff)
download	core-174e24ffff2f76da94df3bdefa5416c5f2256b78.tar.gz core-174e24ffff2f76da94df3bdefa5416c5f2256b78.zip