Project import
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..6f03604
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,155 @@
+#
+# Copyright (c) 2010-2012 Nest Labs, Inc.
+# All rights reserved.
+#
+# This document is the property of Nest. It is considered
+# confidential and proprietary information.
+#
+# This document may not be reproduced or transmitted in any form,
+# in whole or in part, without the express written permission of
+# Nest.
+#
+# Description:
+# This file is the makefile for Boost, a collection of open
+# source libraries that extend the functionality of the C++ standard
+# library.
+#
+
+BuildConfigSpecialized := No
+BuildProductSpecialized := Yes
+
+include pre.mak
+
+PackageName := boost
+
+PackageExtension := tar.bz2
+PackageSeparator := _
+
+PackagePatchArgs := -p1
+
+PackageArchive := $(PackageName).$(PackageExtension)
+PackageSourceDir := $(PackageName)$(PackageSeparator)$(PackageVersion)
+
+CleanPaths += $(PackageLicenseFile)
+
+TpsDir := sw/tps
+
+IcuDir := $(TpsDir)/icu
+IcuSearchPath := $(call GenerateResultPaths,$(IcuDir),usr)
+
+PythonDir := $(TpsDir)/python
+PythonSearchPath := $(call GenerateResultPaths,$(PythonDir),/)
+
+# For the short-term, we are always building with GCC even though the
+# actual tool chain may be some repackaged version of GCC. So, just
+# specify that.
+
+BoostToolset := gcc
+
+# We do not want versioned headers and libraries, so specify the
+# 'system' layout. Also, we do not want all the various combinations
+# of shared/static, release/debug, stripped/unstripped and
+# non-threaded/threaded libraries, so just specify 'minimal'.
+
+BoostJamConfig += --layout=system \
+ --build-type=minimal \
+ -sICU_PATH=$(IcuSearchPath) \
+ link=shared
+
+# If ForceLibStdCPP is set, tell boost to use libstdc++ instead of
+# the compiler default
+ifeq ($(call IsYes,$(ForceLibStdCPP)),Y)
+BoostJamConfig += cxxflags="-stdlib=libstdc++" linkflags="-stdlib=libstdc++"
+endif
+
+
+BoostLibraries = filesystem \
+ system \
+ signals
+
+ifeq ($(BUILD_FEATURE_BOOST_PYTHON),1)
+BoostLibraries += \
+ python
+endif
+
+BoostLibrariesList = $(subst $(Space),$(Comma),$(strip $(BoostLibraries)))
+
+BoostConfigure = $(call GenerateBuildPaths,bootstrap.sh)
+BoostProjectConfig = $(call GenerateBuildPaths,project-config.jam)
+
+all: $(PackageDefaultGoal)
+
+# Generate the package license contents.
+
+$(PackageSourceDir)/LICENSE_1_0.txt: source
+
+$(PackageLicenseFile): $(PackageSourceDir)/LICENSE_1_0.txt
+ $(copy-result)
+
+# Extract the source from the archive and apply patches, if any.
+
+$(PackageSourceDir): $(PackageArchive) $(PackagePatchPaths)
+ $(expand-and-patch-package)
+
+# Prepare the sources.
+
+.PHONY: source
+source: | $(PackageSourceDir)
+
+# Patch the sources, if necessary.
+
+.PHONY: patch
+patch: source
+
+# Generate the package build makefile.
+
+$(BoostConfigure): | $(PackageSourceDir) $(BuildDirectory)
+ $(call create-links,$(CURDIR)/$(PackageSourceDir),$(BuildDirectory))
+
+# Generate the build-specific makefile and user configuration. We have
+# to post-process the generated user configuration since Boost's
+# adominable build system has no other way to override the actual C++
+# compiler executable used (see http://goodliffe.blogspot.com/2008/05/
+# cross-compiling-boost.html and boost/docs/html/bbv2/
+# tasks.html#bbv2.tasks.crosscompile).
+
+$(BoostProjectConfig): $(BoostConfigure)
+ $(Verbose)cd $(BuildDirectory) && \
+ ./bootstrap.sh \
+ --prefix=$(ResultDirectory) \
+ --with-toolset=$(BoostToolset) \
+ --with-icu=$(IcuSearchPath) \
+ --with-libraries=$(BoostLibrariesList) \
+ --with-python-root=$(PythonSearchPath)
+ $(Verbose)$(SED) -e "s#^\([[:space:]]*using\)[[:space:]]\{1,\}\($(BoostToolset)\)[[:space:]]\{1,\};#\1 \2 : $(TargetProcArch) : $(CXX) $(CPPOPTFLAGS) ;#g" \
+ < $(@) > $(@).N || $(RM) -f $(@)
+ $(Verbose)mv -f $(@) $(@).O
+ $(Verbose)mv -f $(@).N $(@)
+
+# Configure the source for building.
+
+.PHONY: configure
+configure: source $(BoostProjectConfig)
+
+# Build the source.
+
+.PHONY: build
+build: configure
+ $(Verbose)cd $(BuildDirectory) && \
+ ./bjam $(JOBSFLAG) $(BoostJamConfig)
+
+# Stage the build to a temporary installation area.
+
+.PHONY: stage
+stage: build | $(ResultDirectory)
+ $(Verbose)cd $(BuildDirectory) && \
+ INSTALL="$(INSTALL) $(INSTALLFLAGS)" && \
+ ./bjam $(JOBSFLAG) $(BoostJamConfig) \
+ install --prefix=$(ResultDirectory)
+
+clean:
+ $(Verbose)$(RM) $(RMFLAGS) -r $(PackageSourceDir)
+ $(Verbose)$(RM) $(RMFLAGS) -r $(BuildDirectory)
+ $(Verbose)$(RM) $(RMFLAGS) -r $(ResultDirectory)
+
+include post.mak
diff --git a/boost.patches/boost-00.description b/boost.patches/boost-00.description
new file mode 100644
index 0000000..40cbf45
--- /dev/null
+++ b/boost.patches/boost-00.description
@@ -0,0 +1 @@
+This patch fixes https://svn.boost.org/trac/boost/ticket/4688
diff --git a/boost.patches/boost-00.patch b/boost.patches/boost-00.patch
new file mode 100644
index 0000000..85362e4
--- /dev/null
+++ b/boost.patches/boost-00.patch
@@ -0,0 +1,26 @@
+diff --git a/libs/filesystem/v2/src/v2_path.cpp b/libs/filesystem/v2/src/v2_path.cpp
+index 7adeaff..027b299 100644
+--- a/libs/filesystem/v2/src/v2_path.cpp
++++ b/libs/filesystem/v2/src/v2_path.cpp
+@@ -45,7 +45,7 @@ namespace
+ {
+ #if !defined(macintosh) && !defined(__APPLE__) && !defined(__APPLE_CC__)
+ // ISO C calls this "the locale-specific native environment":
+- static std::locale lc("");
++ static std::locale lc;
+ #else // Mac OS
+ // "All BSD system functions expect their string parameters to be in UTF-8 encoding
+ // and nothing else."
+diff --git a/libs/filesystem/v3/src/path.cpp b/libs/filesystem/v3/src/path.cpp
+index 7dc0b53..213ca36 100644
+--- a/libs/filesystem/v3/src/path.cpp
++++ b/libs/filesystem/v3/src/path.cpp
+@@ -760,7 +760,7 @@ namespace
+
+ # else
+ // ISO C calls this "the locale-specific native environment":
+- return std::locale("");
++ return std::locale();
+
+ # endif
+ }
diff --git a/boost.patches/boost-00.url b/boost.patches/boost-00.url
new file mode 100644
index 0000000..42f770e
--- /dev/null
+++ b/boost.patches/boost-00.url
@@ -0,0 +1 @@
+https://svn.boost.org/trac/boost/raw-attachment/ticket/4688/boost_filesystem.patch
diff --git a/boost.patches/boost-01.description b/boost.patches/boost-01.description
new file mode 100644
index 0000000..cc99764
--- /dev/null
+++ b/boost.patches/boost-01.description
@@ -0,0 +1,5 @@
+This patch addresses upstream issues 5331
+<https://svn.boost.org/trac/boost/attachment/ticket/5331> and 6692
+<https://svn.boost.org/trac/boost/attachment/ticket/6692> by removing
+the use of the deprecated swp{b} instructions on ARMv6 and ARMv7
+architectures, replacing them with the newer {ld,st}rex.
diff --git a/boost.patches/boost-01.patch b/boost.patches/boost-01.patch
new file mode 100644
index 0000000..e556c4e
--- /dev/null
+++ b/boost.patches/boost-01.patch
@@ -0,0 +1,88 @@
+--- a/boost/smart_ptr/detail/spinlock_gcc_arm.hpp 2009-03-02 08:22:16.000000000 -0800
++++ b/boost/smart_ptr/detail/spinlock_gcc_arm.hpp 2012-06-28 16:39:55.000000000 -0700
+@@ -2,7 +2,7 @@
+ #define BOOST_SMART_PTR_DETAIL_SPINLOCK_GCC_ARM_HPP_INCLUDED
+
+ //
+-// Copyright (c) 2008 Peter Dimov
++// Copyright (c) 2008, 2011 Peter Dimov
+ //
+ // Distributed under the Boost Software License, Version 1.0.
+ // See accompanying file LICENSE_1_0.txt or copy at
+@@ -11,6 +11,20 @@
+
+ #include <boost/smart_ptr/detail/yield_k.hpp>
+
++#if defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7EM__)
++
++# define BOOST_SP_ARM_BARRIER "dmb"
++
++#elif defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__)
++
++# define BOOST_SP_ARM_BARRIER "mcr p15, 0, r0, c7, c10, 5"
++
++#else
++
++# define BOOST_SP_ARM_BARRIER ""
++
++#endif
++
+ namespace boost
+ {
+
+@@ -29,12 +43,38 @@
+ {
+ int r;
+
++#if defined(__ARM_ARCH_6__) \
++ || defined(__ARM_ARCH_6J__) \
++ || defined(__ARM_ARCH_6K__) \
++ || defined(__ARM_ARCH_6Z__) \
++ || defined(__ARM_ARCH_6ZK__) \
++ || defined(__ARM_ARCH_6T2__) \
++ || defined(__ARM_ARCH_7__) \
++ || defined(__ARM_ARCH_7A__) \
++ || defined(__ARM_ARCH_7R__) \
++ || defined(__ARM_ARCH_7M__) \
++ || defined(__ARM_ARCH_7EM__)
++
+ __asm__ __volatile__(
+- "swp %0, %1, [%2]":
++ "ldrex %0, [%2]; \n"
++ "cmp %0, %1; \n"
++ "strexne %0, %1, [%2]; \n"
++ BOOST_SP_ARM_BARRIER :
+ "=&r"( r ): // outputs
+ "r"( 1 ), "r"( &v_ ): // inputs
+ "memory", "cc" );
+
++#else
++
++ __asm__ __volatile__(
++ "swp %0, %1, [%2];\n"
++ BOOST_SP_ARM_BARRIER :
++ "=&r"( r ): // outputs
++ "r"( 1 ), "r"( &v_ ): // inputs
++ "memory", "cc" );
++
++#endif
++
+ return r == 0;
+ }
+
+@@ -48,7 +88,7 @@
+
+ void unlock()
+ {
+- __asm__ __volatile__( "" ::: "memory" );
++ __asm__ __volatile__( BOOST_SP_ARM_BARRIER ::: "memory" );
+ *const_cast< int volatile* >( &v_ ) = 0;
+ }
+
+@@ -82,4 +122,6 @@
+
+ #define BOOST_DETAIL_SPINLOCK_INIT {0}
+
++#undef BOOST_SP_ARM_BARRIER
++
+ #endif // #ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_GCC_ARM_HPP_INCLUDED
diff --git a/boost.patches/boost-02.description b/boost.patches/boost-02.description
new file mode 100644
index 0000000..32ef535
--- /dev/null
+++ b/boost.patches/boost-02.description
@@ -0,0 +1,3 @@
+This patch fixes various compilation errors and warnings when compiling using gcc 4.8.2
+
+
diff --git a/boost.patches/boost-02.patch b/boost.patches/boost-02.patch
new file mode 100644
index 0000000..66f0979
--- /dev/null
+++ b/boost.patches/boost-02.patch
@@ -0,0 +1,126 @@
+--- a/boost/config/stdlib/libstdcpp3.hpp 2010-10-01 02:19:44.000000000 -0700
++++ b/boost/config/stdlib/libstdcpp3.hpp 2014-05-31 04:07:43.998193374 -0700
+@@ -31,7 +31,8 @@
+
+ #ifdef __GLIBCXX__ // gcc 3.4 and greater:
+ # if defined(_GLIBCXX_HAVE_GTHR_DEFAULT) \
+- || defined(_GLIBCXX__PTHREADS)
++ || defined(_GLIBCXX__PTHREADS) \
++ || defined(_GLIBCXX_HAS_GTHREADS)
+ //
+ // If the std lib has thread support turned on, then turn it on in Boost
+ // as well. We do this because some gcc-3.4 std lib headers define _REENTANT
+--- a/boost/thread/xtime.hpp 2008-06-18 06:01:08.000000000 -0700
++++ b/boost/thread/xtime.hpp 2014-05-31 04:07:44.098193379 -0700
+@@ -20,7 +20,7 @@
+
+ enum xtime_clock_types
+ {
+- TIME_UTC=1
++ TIME_UTC_=1
+ // TIME_TAI,
+ // TIME_MONOTONIC,
+ // TIME_PROCESS,
+@@ -68,7 +68,7 @@
+
+ inline int xtime_get(struct xtime* xtp, int clock_type)
+ {
+- if (clock_type == TIME_UTC)
++ if (clock_type == TIME_UTC_)
+ {
+ *xtp=get_xtime(get_system_time());
+ return clock_type;
+--- a/libs/thread/src/pthread/thread.cpp 2010-10-29 16:27:00.000000000 -0700
++++ b/libs/thread/src/pthread/thread.cpp 2014-05-31 04:07:50.302193645 -0700
+@@ -350,7 +350,7 @@
+ cond.timed_wait(lock, xt);
+ # endif
+ xtime cur;
+- xtime_get(&cur, TIME_UTC);
++ xtime_get(&cur, TIME_UTC_);
+ if (xtime_cmp(xt, cur) <= 0)
+ return;
+ }
+@@ -365,7 +365,7 @@
+ BOOST_VERIFY(!pthread_yield());
+ # else
+ xtime xt;
+- xtime_get(&xt, TIME_UTC);
++ xtime_get(&xt, TIME_UTC_);
+ sleep(xt);
+ # endif
+ }
+--- a/libs/thread/src/pthread/timeconv.inl 2010-04-01 08:04:15.000000000 -0700
++++ b/libs/thread/src/pthread/timeconv.inl 2014-05-31 04:07:50.302193645 -0700
+@@ -20,8 +20,8 @@
+ inline void to_time(int milliseconds, boost::xtime& xt)
+ {
+ int res = 0;
+- res = boost::xtime_get(&xt, boost::TIME_UTC);
+- BOOST_ASSERT(res == boost::TIME_UTC);
++ res = boost::xtime_get(&xt, boost::TIME_UTC_);
++ BOOST_ASSERT(res == boost::TIME_UTC_);
+
+ xt.sec += (milliseconds / MILLISECONDS_PER_SECOND);
+ xt.nsec += ((milliseconds % MILLISECONDS_PER_SECOND) *
+@@ -57,8 +57,8 @@
+ {
+ boost::xtime cur;
+ int res = 0;
+- res = boost::xtime_get(&cur, boost::TIME_UTC);
+- BOOST_ASSERT(res == boost::TIME_UTC);
++ res = boost::xtime_get(&cur, boost::TIME_UTC_);
++ BOOST_ASSERT(res == boost::TIME_UTC_);
+
+ if (boost::xtime_cmp(xt, cur) <= 0)
+ {
+@@ -88,8 +88,8 @@
+ {
+ boost::xtime cur;
+ int res = 0;
+- res = boost::xtime_get(&cur, boost::TIME_UTC);
+- BOOST_ASSERT(res == boost::TIME_UTC);
++ res = boost::xtime_get(&cur, boost::TIME_UTC_);
++ BOOST_ASSERT(res == boost::TIME_UTC_);
+
+ if (boost::xtime_cmp(xt, cur) <= 0)
+ milliseconds = 0;
+@@ -110,8 +110,8 @@
+ {
+ boost::xtime cur;
+ int res = 0;
+- res = boost::xtime_get(&cur, boost::TIME_UTC);
+- BOOST_ASSERT(res == boost::TIME_UTC);
++ res = boost::xtime_get(&cur, boost::TIME_UTC_);
++ BOOST_ASSERT(res == boost::TIME_UTC_);
+
+ if (boost::xtime_cmp(xt, cur) <= 0)
+ microseconds = 0;
+--- a/boost/static_assert.hpp 2008-07-11 03:49:31.000000000 -0700
++++ b/boost/static_assert.hpp 2014-06-07 07:32:29.365107458 -0700
+@@ -38,6 +38,15 @@
+ # define BOOST_STATIC_ASSERT_BOOL_CAST(x) (bool)(x)
+ #endif
+
++//
++// If the compiler warns about unused typedefs then enable this:
++//
++#if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)))
++# define BOOST_STATIC_ASSERT_UNUSED_ATTRIBUTE __attribute__((unused))
++#else
++# define BOOST_STATIC_ASSERT_UNUSED_ATTRIBUTE
++#endif
++
+ #ifdef BOOST_HAS_STATIC_ASSERT
+ # define BOOST_STATIC_ASSERT( B ) static_assert(B, #B)
+ #else
+@@ -116,7 +125,7 @@
+ #define BOOST_STATIC_ASSERT( B ) \
+ typedef ::boost::static_assert_test<\
+ sizeof(::boost::STATIC_ASSERTION_FAILURE< BOOST_STATIC_ASSERT_BOOL_CAST( B ) >)>\
+- BOOST_JOIN(boost_static_assert_typedef_, __LINE__)
++ BOOST_JOIN(boost_static_assert_typedef_, __LINE__) BOOST_STATIC_ASSERT_UNUSED_ATTRIBUTE
+ #endif
+
+ #else
+
diff --git a/boost.patches/boost-50.description b/boost.patches/boost-50.description
new file mode 100644
index 0000000..b4de134
--- /dev/null
+++ b/boost.patches/boost-50.description
@@ -0,0 +1 @@
+This patch resolves compiler errors / warnings regarding shadow variables.
diff --git a/boost.patches/boost-50.patch b/boost.patches/boost-50.patch
new file mode 100644
index 0000000..474e31f
--- /dev/null
+++ b/boost.patches/boost-50.patch
@@ -0,0 +1,110 @@
+--- a/boost/concept_check.hpp
++++ b/boost/concept_check.hpp
+@@ -1014,11 +1014,11 @@
+ c.swap(c);
+ }
+
+- void const_constraints(const C& c) {
+- ci = c.begin();
+- ci = c.end();
+- n = c.size();
+- b = c.empty();
++ void const_constraints(const C& constraint) {
++ ci = constraint.begin();
++ ci = constraint.end();
++ n = constraint.size();
++ b = constraint.empty();
+ }
+
+ private:
+--- a/boost/filesystem/v3/path.hpp 2010-10-16 06:09:25.000000000 -0700
++++ b/boost/filesystem/v3/path.hpp 2011-05-14 16:54:35.927910801 -0700
+@@ -142,23 +142,23 @@
+ }
+
+ template <class InputIterator>
+- path(InputIterator begin, InputIterator end)
++ path(InputIterator first, InputIterator last)
+ {
+- if (begin != end)
++ if (first != last)
+ {
+ std::basic_string<typename std::iterator_traits<InputIterator>::value_type>
+- s(begin, end);
++ s(first, last);
+ path_traits::convert(s.c_str(), s.c_str()+s.size(), m_pathname, codecvt());
+ }
+ }
+
+ template <class InputIterator>
+- path(InputIterator begin, InputIterator end, const codecvt_type& cvt)
++ path(InputIterator first, InputIterator last, const codecvt_type& cvt)
+ {
+- if (begin != end)
++ if (first != last)
+ {
+ std::basic_string<typename std::iterator_traits<InputIterator>::value_type>
+- s(begin, end);
++ s(first, last);
+ path_traits::convert(s.c_str(), s.c_str()+s.size(), m_pathname, cvt);
+ }
+ }
+@@ -190,19 +190,19 @@
+ }
+
+ template <class InputIterator>
+- path& assign(InputIterator begin, InputIterator end)
++ path& assign(InputIterator first, InputIterator last)
+ {
+- return assign(begin, end, codecvt());
++ return assign(first, last, codecvt());
+ }
+
+ template <class InputIterator>
+- path& assign(InputIterator begin, InputIterator end, const codecvt_type& cvt)
++ path& assign(InputIterator first, InputIterator last, const codecvt_type& cvt)
+ {
+ m_pathname.clear();
+- if (begin != end)
++ if (first != last)
+ {
+ std::basic_string<typename std::iterator_traits<InputIterator>::value_type>
+- s(begin, end);
++ s(first, last);
+ path_traits::convert(s.c_str(), s.c_str()+s.size(), m_pathname, cvt);
+ }
+ return *this;
+@@ -227,13 +227,13 @@
+ path& append(Source const& source, const codecvt_type& cvt);
+
+ template <class InputIterator>
+- path& append(InputIterator begin, InputIterator end)
++ path& append(InputIterator first, InputIterator last)
+ {
+- return append(begin, end, codecvt());
++ return append(first, last, codecvt());
+ }
+
+ template <class InputIterator>
+- path& append(InputIterator begin, InputIterator end, const codecvt_type& cvt);
++ path& append(InputIterator first, InputIterator last, const codecvt_type& cvt);
+
+ // ----- modifiers -----
+
+@@ -612,13 +612,13 @@
+ //--------------------------------------------------------------------------------------//
+
+ template <class InputIterator>
+- path& path::append(InputIterator begin, InputIterator end, const codecvt_type& cvt)
++ path& path::append(InputIterator first, InputIterator last, const codecvt_type& cvt)
+ {
+- if (begin == end)
++ if (first == last)
+ return *this;
+ string_type::size_type sep_pos(m_append_separator_if_needed());
+ std::basic_string<typename std::iterator_traits<InputIterator>::value_type>
+- s(begin, end);
++ s(first, last);
+ path_traits::convert(s.c_str(), s.c_str()+s.size(), m_pathname, cvt);
+ if (sep_pos)
+ m_erase_redundant_separator(sep_pos);
diff --git a/boost.patches/boost-51.description b/boost.patches/boost-51.description
new file mode 100644
index 0000000..ab896a1
--- /dev/null
+++ b/boost.patches/boost-51.description
@@ -0,0 +1 @@
+This patch applies upstream change set 67067 <https://svn.boost.org/trac/boost/changeset/67067> for issue 4930 <https://svn.boost.org/trac/boost/ticket/4930>.
diff --git a/boost.patches/boost-51.patch b/boost.patches/boost-51.patch
new file mode 100644
index 0000000..a7ffbec
--- /dev/null
+++ b/boost.patches/boost-51.patch
@@ -0,0 +1,28 @@
+--- a/libs/filesystem/v2/src/v2_operations.cpp 2010-08-10 13:00:09.000000000 -0700
++++ b/libs/filesystem/v2/src/v2_operations.cpp 2011-06-16 17:28:00.000000000 -0700
+@@ -1215,8 +1214,9 @@
+ if ( ::stat( from_file_ph.c_str(), &from_stat ) != 0 )
+ { return error_code( errno, system_category() ); }
+
+- int oflag = O_CREAT | O_WRONLY;
+- if ( fail_if_exists ) oflag |= O_EXCL;
++ int oflag = O_CREAT | O_WRONLY | O_TRUNC;
++ if ( fail_if_exists )
++ oflag |= O_EXCL;
+ if ( (outfile = ::open( to_file_ph.c_str(), oflag, from_stat.st_mode )) < 0 )
+ {
+ int open_errno = errno;
+--- a/libs/filesystem/v3/src/operations.cpp 2010-10-16 06:09:25.000000000 -0700
++++ b/libs/filesystem/v3/src/operations.cpp 2011-06-16 17:28:00.000000000 -0700
+@@ -426,8 +433,9 @@
+ if (::stat(from_p.c_str(), &from_stat)!= 0)
+ { return false; }
+
+- int oflag = O_CREAT | O_WRONLY;
+- if (fail_if_exists)oflag |= O_EXCL;
++ int oflag = O_CREAT | O_WRONLY | O_TRUNC;
++ if (fail_if_exists)
++ oflag |= O_EXCL;
+ if ((outfile = ::open(to_p.c_str(), oflag, from_stat.st_mode))< 0)
+ {
+ int open_errno = errno;
diff --git a/boost.patches/boost-52.description b/boost.patches/boost-52.description
new file mode 100644
index 0000000..98582d2
--- /dev/null
+++ b/boost.patches/boost-52.description
@@ -0,0 +1 @@
+This patch resolves compiler errors / warnings regarding shadow variables in boost::numeric::ublas.
diff --git a/boost.patches/boost-52.patch b/boost.patches/boost-52.patch
new file mode 100644
index 0000000..aeae509
--- /dev/null
+++ b/boost.patches/boost-52.patch
@@ -0,0 +1,1948 @@
+diff -aruN a/boost/archive/basic_archive.hpp b/boost/archive/basic_archive.hpp
+--- a/boost/archive/basic_archive.hpp 2010-11-06 09:31:31.000000000 -0700
++++ b/boost/archive/basic_archive.hpp 2012-02-07 15:25:24.619334954 -0800
+@@ -254,7 +254,7 @@
+ #define BOOST_ARCHIVE_STRONG_TYPEDEF(T, D) \
+ class D : public T { \
+ public: \
+- explicit D(const T t) : T(t){} \
++ explicit D(const T t) : T(type){} \
+ }; \
+ /**/
+
+diff -aruN a/boost/numeric/ublas/banded.hpp b/boost/numeric/ublas/banded.hpp
+--- a/boost/numeric/ublas/banded.hpp 2010-07-04 23:06:24.000000000 -0700
++++ b/boost/numeric/ublas/banded.hpp 2012-02-07 15:25:24.623735807 -0800
+@@ -63,16 +63,16 @@
+ size1_ (0), size2_ (0),
+ lower_ (0), upper_ (0), data_ (0) {}
+ BOOST_UBLAS_INLINE
+- banded_matrix (size_type size1, size_type size2, size_type lower = 0, size_type upper = 0):
++ banded_matrix (size_type s1, size_type s2, size_type l = 0, size_type u = 0):
+ matrix_container<self_type> (),
+- size1_ (size1), size2_ (size2),
+- lower_ (lower), upper_ (upper), data_ ((std::max) (size1, size2) * (lower + 1 + upper)) {
++ size1_ (s1), size2_ (s2),
++ lower_ (l), upper_ (u), data_ ((std::max) (s1, s2) * (l + 1 + u)) {
+ }
+ BOOST_UBLAS_INLINE
+- banded_matrix (size_type size1, size_type size2, size_type lower, size_type upper, const array_type &data):
++ banded_matrix (size_type s1, size_type s2, size_type l, size_type u, const array_type &d):
+ matrix_container<self_type> (),
+- size1_ (size1), size2_ (size2),
+- lower_ (lower), upper_ (upper), data_ (data) {}
++ size1_ (s1), size2_ (s2),
++ lower_ (l), upper_ (u), data_ (d) {}
+ BOOST_UBLAS_INLINE
+ banded_matrix (const banded_matrix &m):
+ matrix_container<self_type> (),
+@@ -80,10 +80,10 @@
+ lower_ (m.lower_), upper_ (m.upper_), data_ (m.data_) {}
+ template<class AE>
+ BOOST_UBLAS_INLINE
+- banded_matrix (const matrix_expression<AE> &ae, size_type lower = 0, size_type upper = 0):
++ banded_matrix (const matrix_expression<AE> &ae, size_type l = 0, size_type u = 0):
+ matrix_container<self_type> (),
+ size1_ (ae ().size1 ()), size2_ (ae ().size2 ()),
+- lower_ (lower), upper_ (upper),
++ lower_ (l), upper_ (u),
+ data_ ((std::max) (size1_, size2_) * (lower_ + 1 + upper_)) {
+ matrix_assign<scalar_assign> (*this, ae);
+ }
+@@ -118,27 +118,27 @@
+
+ // Resizing
+ BOOST_UBLAS_INLINE
+- void resize (size_type size1, size_type size2, size_type lower = 0, size_type upper = 0, bool preserve = true) {
++ void resize (size_type s1, size_type s2, size_type l = 0, size_type u = 0, bool preserve = true) {
+ if (preserve) {
+- self_type temporary (size1, size2, lower, upper);
++ self_type temporary (s1, s2, l, u);
+ detail::matrix_resize_preserve<layout_type> (*this, temporary);
+ }
+ else {
+- data ().resize ((std::max) (size1, size2) * (lower + 1 + upper));
+- size1_ = size1;
+- size2_ = size2;
+- lower_ = lower;
+- upper_ = upper;
++ data ().resize ((std::max) (s1, s2) * (l + 1 + u));
++ size1_ = s1;
++ size2_ = s2;
++ lower_ = l;
++ upper_ = u;
+ }
+ }
+
+ BOOST_UBLAS_INLINE
+- void resize_packed_preserve (size_type size1, size_type size2, size_type lower = 0, size_type upper = 0) {
+- size1_ = size1;
+- size2_ = size2;
+- lower_ = lower;
+- upper_ = upper;
+- data ().resize ((std::max) (size1, size2) * (lower + 1 + upper), value_type ());
++ void resize_packed_preserve (size_type s1, size_type s2, size_type l = 0, size_type u = 0) {
++ size1_ = s1;
++ size2_ = s2;
++ lower_ = l;
++ upper_ = u;
++ data ().resize ((std::max) (size1, size2) * (l + 1 + u), value_type ());
+ }
+
+ // Element access
+@@ -1082,9 +1082,9 @@
+
+ // Construction and destruction
+ BOOST_UBLAS_INLINE
+- banded_adaptor (matrix_type &data, size_type lower = 0, size_type upper = 0):
++ banded_adaptor (matrix_type &d, size_type l = 0, size_type u = 0):
+ matrix_expression<self_type> (),
+- data_ (data), lower_ (lower), upper_ (upper) {}
++ data_ (d), lower_ (l), upper_ (u) {}
+ BOOST_UBLAS_INLINE
+ banded_adaptor (const banded_adaptor &m):
+ matrix_expression<self_type> (),
+diff -aruN a/boost/numeric/ublas/detail/matrix_assign.hpp b/boost/numeric/ublas/detail/matrix_assign.hpp
+--- a/boost/numeric/ublas/detail/matrix_assign.hpp 2010-10-19 00:01:35.000000000 -0700
++++ b/boost/numeric/ublas/detail/matrix_assign.hpp 2012-02-07 15:25:24.623735807 -0800
+@@ -75,21 +75,21 @@
+ if (it2 != it2_end && it2e != it2e_end) {
+ size_type it2_index = it2.index2 (), it2e_index = it2e.index2 ();
+ while (true) {
+- difference_type compare = it2_index - it2e_index;
+- if (compare == 0) {
++ difference_type compare2 = it2_index - it2e_index;
++ if (compare2 == 0) {
+ ++ it2, ++ it2e;
+ if (it2 != it2_end && it2e != it2e_end) {
+ it2_index = it2.index2 ();
+ it2e_index = it2e.index2 ();
+ } else
+ break;
+- } else if (compare < 0) {
+- increment (it2, it2_end, - compare);
++ } else if (compare2 < 0) {
++ increment (it2, it2_end, - compare2);
+ if (it2 != it2_end)
+ it2_index = it2.index2 ();
+ else
+ break;
+- } else if (compare > 0) {
++ } else if (compare2 > 0) {
+ if (conformant_restrict_type::other (it2e.index1 (), it2e.index2 ()))
+ if (static_cast<value_type>(*it2e) != value_type/*zero*/())
+ index.push_back (std::pair<size_type, size_type> (it2e.index1 (), it2e.index2 ()));
+@@ -178,21 +178,21 @@
+ if (it1 != it1_end && it1e != it1e_end) {
+ size_type it1_index = it1.index1 (), it1e_index = it1e.index1 ();
+ while (true) {
+- difference_type compare = it1_index - it1e_index;
+- if (compare == 0) {
++ difference_type compare2 = it1_index - it1e_index;
++ if (compare2 == 0) {
+ ++ it1, ++ it1e;
+ if (it1 != it1_end && it1e != it1e_end) {
+ it1_index = it1.index1 ();
+ it1e_index = it1e.index1 ();
+ } else
+ break;
+- } else if (compare < 0) {
+- increment (it1, it1_end, - compare);
++ } else if (compare2 < 0) {
++ increment (it1, it1_end, - compare2);
+ if (it1 != it1_end)
+ it1_index = it1.index1 ();
+ else
+ break;
+- } else if (compare > 0) {
++ } else if (compare2 > 0) {
+ if (conformant_restrict_type::other (it1e.index1 (), it1e.index2 ()))
+ if (static_cast<value_type>(*it1e) != value_type/*zero*/())
+ index.push_back (std::pair<size_type, size_type> (it1e.index1 (), it1e.index2 ()));
+@@ -997,8 +997,8 @@
+ if (it2 != it2_end && it2e != it2e_end) {
+ size_type it2_index = it2.index2 (), it2e_index = it2e.index2 ();
+ while (true) {
+- difference_type compare = it2_index - it2e_index;
+- if (compare == 0) {
++ difference_type compare2 = it2_index - it2e_index;
++ if (compare2 == 0) {
+ functor_type::apply (*it2, *it2e);
+ ++ it2, ++ it2e;
+ if (it2 != it2_end && it2e != it2e_end) {
+@@ -1006,18 +1006,18 @@
+ it2e_index = it2e.index2 ();
+ } else
+ break;
+- } else if (compare < 0) {
++ } else if (compare2 < 0) {
+ if (!functor_type::computed) {
+ functor_type::apply (*it2, expr_value_type/*zero*/());
+ ++ it2;
+ } else
+- increment (it2, it2_end, - compare);
++ increment (it2, it2_end, - compare2);
+ if (it2 != it2_end)
+ it2_index = it2.index2 ();
+ else
+ break;
+- } else if (compare > 0) {
+- increment (it2e, it2e_end, compare);
++ } else if (compare2 > 0) {
++ increment (it2e, it2e_end, compare2);
+ if (it2e != it2e_end)
+ it2e_index = it2e.index2 ();
+ else
+@@ -1118,8 +1118,8 @@
+ if (it1 != it1_end && it1e != it1e_end) {
+ size_type it1_index = it1.index1 (), it1e_index = it1e.index1 ();
+ while (true) {
+- difference_type compare = it1_index - it1e_index;
+- if (compare == 0) {
++ difference_type compare2 = it1_index - it1e_index;
++ if (compare2 == 0) {
+ functor_type::apply (*it1, *it1e);
+ ++ it1, ++ it1e;
+ if (it1 != it1_end && it1e != it1e_end) {
+@@ -1127,18 +1127,18 @@
+ it1e_index = it1e.index1 ();
+ } else
+ break;
+- } else if (compare < 0) {
++ } else if (compare2 < 0) {
+ if (!functor_type::computed) {
+ functor_type::apply (*it1, expr_value_type/*zero*/()); // zeroing
+ ++ it1;
+ } else
+- increment (it1, it1_end, - compare);
++ increment (it1, it1_end, - compare2);
+ if (it1 != it1_end)
+ it1_index = it1.index1 ();
+ else
+ break;
+- } else if (compare > 0) {
+- increment (it1e, it1e_end, compare);
++ } else if (compare2 > 0) {
++ increment (it1e, it1e_end, compare2);
+ if (it1e != it1e_end)
+ it1e_index = it1e.index1 ();
+ else
+@@ -1386,8 +1386,8 @@
+ if (it2 != it2_end && it2e != it2e_end) {
+ size_type it2_index = it2.index2 (), it2e_index = it2e.index2 ();
+ while (true) {
+- difference_type compare = it2_index - it2e_index;
+- if (compare == 0) {
++ difference_type compare2 = it2_index - it2e_index;
++ if (compare2 == 0) {
+ functor_type::apply (*it2, *it2e);
+ ++ it2, ++ it2e;
+ if (it2 != it2_end && it2e != it2e_end) {
+@@ -1395,14 +1395,14 @@
+ it2e_index = it2e.index2 ();
+ } else
+ break;
+- } else if (compare < 0) {
+- increment (it2, it2_end, - compare);
++ } else if (compare2 < 0) {
++ increment (it2, it2_end, - compare2);
+ if (it2 != it2_end)
+ it2_index = it2.index2 ();
+ else
+ break;
+- } else if (compare > 0) {
+- increment (it2e, it2e_end, compare);
++ } else if (compare2 > 0) {
++ increment (it2e, it2e_end, compare2);
+ if (it2e != it2e_end)
+ it2e_index = it2e.index2 ();
+ else
+@@ -1511,8 +1511,8 @@
+ if (it1 != it1_end && it1e != it1e_end) {
+ size_type it1_index = it1.index1 (), it1e_index = it1e.index1 ();
+ while (true) {
+- difference_type compare = it1_index - it1e_index;
+- if (compare == 0) {
++ difference_type compare2 = it1_index - it1e_index;
++ if (compare2 == 0) {
+ functor_type::apply (*it1, *it1e);
+ ++ it1, ++ it1e;
+ if (it1 != it1_end && it1e != it1e_end) {
+@@ -1520,14 +1520,14 @@
+ it1e_index = it1e.index1 ();
+ } else
+ break;
+- } else if (compare < 0) {
+- increment (it1, it1_end, - compare);
++ } else if (compare2 < 0) {
++ increment (it1, it1_end, - compare2);
+ if (it1 != it1_end)
+ it1_index = it1.index1 ();
+ else
+ break;
+- } else if (compare > 0) {
+- increment (it1e, it1e_end, compare);
++ } else if (compare2 > 0) {
++ increment (it1e, it1e_end, compare2);
+ if (it1e != it1e_end)
+ it1e_index = it1e.index1 ();
+ else
+diff -aruN a/boost/numeric/ublas/hermitian.hpp b/boost/numeric/ublas/hermitian.hpp
+--- a/boost/numeric/ublas/hermitian.hpp 2010-07-04 23:06:24.000000000 -0700
++++ b/boost/numeric/ublas/hermitian.hpp 2012-02-07 15:25:24.627228060 -0800
+@@ -284,14 +284,14 @@
+ size_ (BOOST_UBLAS_SAME (size, size)), data_ (triangular_type::packed_size (layout_type (), size, size)) {
+ }
+ BOOST_UBLAS_INLINE
+- hermitian_matrix (size_type size1, size_type size2):
++ hermitian_matrix (size_type s1, size_type s2):
+ matrix_container<self_type> (),
+- size_ (BOOST_UBLAS_SAME (size1, size2)), data_ (triangular_type::packed_size (layout_type (), size1, size2)) {
++ size_ (BOOST_UBLAS_SAME (s1, s2)), data_ (triangular_type::packed_size (layout_type (), s1, s2)) {
+ }
+ BOOST_UBLAS_INLINE
+- hermitian_matrix (size_type size, const array_type &data):
++ hermitian_matrix (size_type s, const array_type &d):
+ matrix_container<self_type> (),
+- size_ (size), data_ (data) {}
++ size_ (s), data_ (d) {}
+ BOOST_UBLAS_INLINE
+ hermitian_matrix (const hermitian_matrix &m):
+ matrix_container<self_type> (),
+@@ -338,8 +338,8 @@
+ }
+ }
+ BOOST_UBLAS_INLINE
+- void resize (size_type size1, size_type size2, bool preserve = true) {
+- resize (BOOST_UBLAS_SAME (size1, size2), preserve);
++ void resize (size_type s1, size_type s2, bool preserve = true) {
++ resize (BOOST_UBLAS_SAME (s1, s2), preserve);
+ }
+ BOOST_UBLAS_INLINE
+ void resize_packed_preserve (size_type size) {
+@@ -1192,9 +1192,9 @@
+
+ // Construction and destruction
+ BOOST_UBLAS_INLINE
+- hermitian_adaptor (matrix_type &data):
++ hermitian_adaptor (matrix_type &d):
+ matrix_expression<self_type> (),
+- data_ (data) {
++ data_ (d) {
+ BOOST_UBLAS_CHECK (data_.size1 () == data_.size2 (), bad_size ());
+ }
+ BOOST_UBLAS_INLINE
+@@ -1508,11 +1508,11 @@
+ it1_begin_ (), it1_end_ (), it1_ (),
+ it2_begin_ (), it2_end_ (), it2_ () {}
+ BOOST_UBLAS_INLINE
+- const_iterator1 (const self_type &m, int begin, int end,
++ const_iterator1 (const self_type &m, int b, int e,
+ const const_subiterator1_type &it1_begin, const const_subiterator1_type &it1_end,
+ const const_subiterator2_type &it2_begin, const const_subiterator2_type &it2_end):
+ container_const_reference<self_type> (m),
+- begin_ (begin), end_ (end), current_ (begin),
++ begin_ (b), end_ (e), current_ (b),
+ it1_begin_ (it1_begin), it1_end_ (it1_end), it1_ (it1_begin_),
+ it2_begin_ (it2_begin), it2_end_ (it2_end), it2_ (it2_begin_) {
+ if (current_ == 0 && it1_ == it1_end_)
+@@ -1962,11 +1962,11 @@
+ it1_begin_ (), it1_end_ (), it1_ (),
+ it2_begin_ (), it2_end_ (), it2_ () {}
+ BOOST_UBLAS_INLINE
+- const_iterator2 (const self_type &m, int begin, int end,
++ const_iterator2 (const self_type &m, int b, int e,
+ const const_subiterator1_type &it1_begin, const const_subiterator1_type &it1_end,
+ const const_subiterator2_type &it2_begin, const const_subiterator2_type &it2_end):
+ container_const_reference<self_type> (m),
+- begin_ (begin), end_ (end), current_ (begin),
++ begin_ (b), end_ (e), current_ (b),
+ it1_begin_ (it1_begin), it1_end_ (it1_end), it1_ (it1_begin_),
+ it2_begin_ (it2_begin), it2_end_ (it2_end), it2_ (it2_begin_) {
+ if (current_ == 0 && it1_ == it1_end_)
+diff -aruN a/boost/numeric/ublas/matrix_expression.hpp b/boost/numeric/ublas/matrix_expression.hpp
+--- a/boost/numeric/ublas/matrix_expression.hpp 2009-10-06 16:31:22.000000000 -0700
++++ b/boost/numeric/ublas/matrix_expression.hpp 2012-02-07 15:25:24.627228060 -0800
+@@ -1918,39 +1918,39 @@
+ // Sparse specializations
+ BOOST_UBLAS_INLINE
+ void increment (sparse_bidirectional_iterator_tag) {
+- size_type index1 = (*this) ().size1 ();
++ size_type temp_index1 = (*this) ().size1 ();
+ if (it1_ != it1_end_) {
+ if (it1_.index1 () <= i_)
+ ++ it1_;
+ if (it1_ != it1_end_)
+- index1 = it1_.index1 ();
++ temp_index1 = it1_.index1 ();
+ }
+- size_type index2 = (*this) ().size1 ();
++ size_type temp_index2 = (*this) ().size1 ();
+ if (it2_ != it2_end_)
+ if (it2_.index1 () <= i_)
+ ++ it2_;
+ if (it2_ != it2_end_) {
+- index2 = it2_.index1 ();
++ temp_index2 = it2_.index1 ();
+ }
+- i_ = (std::min) (index1, index2);
++ i_ = (std::min) (temp_index1, temp_index2);
+ }
+ BOOST_UBLAS_INLINE
+ void decrement (sparse_bidirectional_iterator_tag) {
+- size_type index1 = (*this) ().size1 ();
++ size_type temp_index1 = (*this) ().size1 ();
+ if (it1_ != it1_end_) {
+ if (i_ <= it1_.index1 ())
+ -- it1_;
+ if (it1_ != it1_end_)
+- index1 = it1_.index1 ();
++ temp_index1 = it1_.index1 ();
+ }
+- size_type index2 = (*this) ().size1 ();
++ size_type temp_index2 = (*this) ().size1 ();
+ if (it2_ != it2_end_) {
+ if (i_ <= it2_.index1 ())
+ -- it2_;
+ if (it2_ != it2_end_)
+- index2 = it2_.index1 ();
++ temp_index2 = it2_.index1 ();
+ }
+- i_ = (std::max) (index1, index2);
++ i_ = (std::max) (temp_index1, temp_index2);
+ }
+ BOOST_UBLAS_INLINE
+ void increment (sparse_bidirectional_iterator_tag, difference_type n) {
+@@ -2233,39 +2233,39 @@
+ // Sparse specializations
+ BOOST_UBLAS_INLINE
+ void increment (sparse_bidirectional_iterator_tag) {
+- size_type index1 = (*this) ().size2 ();
++ size_type temp_index1 = (*this) ().size2 ();
+ if (it1_ != it1_end_) {
+ if (it1_.index2 () <= j_)
+ ++ it1_;
+ if (it1_ != it1_end_)
+ index1 = it1_.index2 ();
+ }
+- size_type index2 = (*this) ().size2 ();
++ size_type temp_index2 = (*this) ().size2 ();
+ if (it2_ != it2_end_) {
+ if (it2_.index2 () <= j_)
+ ++ it2_;
+ if (it2_ != it2_end_)
+ index2 = it2_.index2 ();
+ }
+- j_ = (std::min) (index1, index2);
++ j_ = (std::min) (temp_index1, temp_index2);
+ }
+ BOOST_UBLAS_INLINE
+ void decrement (sparse_bidirectional_iterator_tag) {
+- size_type index1 = (*this) ().size2 ();
++ size_type temp_index1 = (*this) ().size2 ();
+ if (it1_ != it1_end_) {
+ if (j_ <= it1_.index2 ())
+ -- it1_;
+ if (it1_ != it1_end_)
+ index1 = it1_.index2 ();
+ }
+- size_type index2 = (*this) ().size2 ();
++ size_type temp_index2 = (*this) ().size2 ();
+ if (it2_ != it2_end_) {
+ if (j_ <= it2_.index2 ())
+ -- it2_;
+ if (it2_ != it2_end_)
+ index2 = it2_.index2 ();
+ }
+- j_ = (std::max) (index1, index2);
++ j_ = (std::max) (temp_index1, temp_index2);
+ }
+ BOOST_UBLAS_INLINE
+ void increment (sparse_bidirectional_iterator_tag, difference_type n) {
+diff -aruN a/boost/numeric/ublas/matrix.hpp b/boost/numeric/ublas/matrix.hpp
+--- a/boost/numeric/ublas/matrix.hpp 2010-10-19 00:01:35.000000000 -0700
++++ b/boost/numeric/ublas/matrix.hpp 2012-02-07 15:25:24.631348942 -0800
+@@ -126,9 +126,9 @@
+ * \param size2 number of columns
+ */
+ BOOST_UBLAS_INLINE
+- matrix (size_type size1, size_type size2):
++ matrix (size_type s1, size_type s2):
+ matrix_container<self_type> (),
+- size1_ (size1), size2_ (size2), data_ (layout_type::storage_size (size1, size2)) {
++ size1_ (s1), size2_ (s2), data_ (layout_type::storage_size (s1, s2)) {
+ }
+
+ /** Dense matrix constructor with defined size a initial value for all the matrix elements
+@@ -136,9 +136,9 @@
+ * \param size2 number of columns
+ * \param init initial value assigned to all elements
+ */
+- matrix (size_type size1, size_type size2, const value_type &init):
++ matrix (size_type s1, size_type s2, const value_type &init):
+ matrix_container<self_type> (),
+- size1_ (size1), size2_ (size2), data_ (layout_type::storage_size (size1, size2), init) {
++ size1_ (s1), size2_ (s2), data_ (layout_type::storage_size (s1, s2), init) {
+ }
+
+ /** Dense matrix constructor with defined size and an initial data array
+@@ -147,9 +147,9 @@
+ * \param data array to copy into the matrix. Must have the same dimension as the matrix
+ */
+ BOOST_UBLAS_INLINE
+- matrix (size_type size1, size_type size2, const array_type &data):
++ matrix (size_type s1, size_type s2, const array_type &d):
+ matrix_container<self_type> (),
+- size1_ (size1), size2_ (size2), data_ (data) {}
++ size1_ (s1), size2_ (s2), data_ (d) {}
+
+ /** Copy-constructor of a dense matrix
+ * \param m is a dense matrix
+@@ -212,15 +212,15 @@
+ * \param preserve a boolean to say if one wants the data to be preserved during the resizing. Default is true.
+ */
+ BOOST_UBLAS_INLINE
+- void resize (size_type size1, size_type size2, bool preserve = true) {
++ void resize (size_type s1, size_type s2, bool preserve = true) {
+ if (preserve) {
+- self_type temporary (size1, size2);
++ self_type temporary (s1, s2);
+ detail::matrix_resize_preserve<layout_type> (*this, temporary);
+ }
+ else {
+- data ().resize (layout_type::storage_size (size1, size2));
+- size1_ = size1;
+- size2_ = size2;
++ data ().resize (layout_type::storage_size (s1, s2));
++ size1_ = s1;
++ size2_ = s2;
+ }
+ }
+
+@@ -1186,10 +1186,10 @@
+ matrix_container<self_type> (),
+ size1_ (0), size2_ (0), data_ (1) {}
+ BOOST_UBLAS_INLINE
+- vector_of_vector (size_type size1, size_type size2):
++ vector_of_vector (size_type s1, size_type s2):
+ matrix_container<self_type> (),
+- size1_ (size1), size2_ (size2), data_ (1) {
+- resize (size1, size2, true);
++ size1_ (s1), size2_ (s2), data_ (1) {
++ resize (s1, s2, true);
+ }
+ BOOST_UBLAS_INLINE
+ vector_of_vector (const vector_of_vector &m):
+@@ -1227,18 +1227,18 @@
+
+ // Resizing
+ BOOST_UBLAS_INLINE
+- void resize (size_type size1, size_type size2, bool preserve = true) {
+- size1_ = size1;
+- size2_ = size2;
++ void resize (size_type s1, size_type s2, bool preserve = true) {
++ size1_ = s1;
++ size2_ = s2;
+ if (preserve)
+- data ().resize (layout_type::size_M (size1, size2) + 1, typename array_type::value_type ());
++ data ().resize (layout_type::size_M (s1, s2) + 1, typename array_type::value_type ());
+ else
+- data ().resize (layout_type::size_M (size1, size2) + 1);
+- for (size_type k = 0; k < layout_type::size_M (size1, size2); ++ k) {
++ data ().resize (layout_type::size_M (s1, s2) + 1);
++ for (size_type k = 0; k < layout_type::size_M (s1, s2); ++ k) {
+ if (preserve)
+- data () [k].resize (layout_type::size_m (size1, size2), value_type ());
++ data () [k].resize (layout_type::size_m (s1, s2), value_type ());
+ else
+- data () [k].resize (layout_type::size_m (size1, size2));
++ data () [k].resize (layout_type::size_m (s1, s2));
+ }
+ }
+
+@@ -2171,9 +2171,9 @@
+ matrix_container<self_type> (),
+ size1_ (size), size2_ (size) {}
+ BOOST_UBLAS_INLINE
+- zero_matrix (size_type size1, size_type size2):
++ zero_matrix (size_type s1, size_type s2):
+ matrix_container<self_type> (),
+- size1_ (size1), size2_ (size2) {}
++ size1_ (s1), size2_ (s2) {}
+ BOOST_UBLAS_INLINE
+ zero_matrix (const zero_matrix &m):
+ matrix_container<self_type> (),
+@@ -2196,9 +2196,9 @@
+ size2_ = size;
+ }
+ BOOST_UBLAS_INLINE
+- void resize (size_type size1, size_type size2, bool /*preserve*/ = true) {
+- size1_ = size1;
+- size2_ = size2;
++ void resize (size_type s1, size_type s2, bool /*preserve*/ = true) {
++ size1_ = s1;
++ size2_ = s2;
+ }
+
+ // Element access
+@@ -2558,9 +2558,9 @@
+ matrix_container<self_type> (),
+ size1_ (size), size2_ (size), size_common_ ((std::min) (size1_, size2_)) {}
+ BOOST_UBLAS_INLINE
+- identity_matrix (size_type size1, size_type size2):
++ identity_matrix (size_type s1, size_type s2):
+ matrix_container<self_type> (),
+- size1_ (size1), size2_ (size2), size_common_ ((std::min) (size1_, size2_)) {}
++ size1_ (s1), size2_ (s2), size_common_ ((std::min) (size1_, size2_)) {}
+ BOOST_UBLAS_INLINE
+ identity_matrix (const identity_matrix &m):
+ matrix_container<self_type> (),
+@@ -2584,9 +2584,9 @@
+ size_common_ = ((std::min)(size1_, size2_));
+ }
+ BOOST_UBLAS_INLINE
+- void resize (size_type size1, size_type size2, bool /*preserve*/ = true) {
+- size1_ = size1;
+- size2_ = size2;
++ void resize (size_type s1, size_type s2, bool /*preserve*/ = true) {
++ size1_ = s1;
++ size2_ = s2;
+ size_common_ = ((std::min)(size1_, size2_));
+ }
+
+@@ -2970,9 +2970,9 @@
+ matrix_container<self_type> (),
+ size1_ (0), size2_ (0), value_ () {}
+ BOOST_UBLAS_INLINE
+- scalar_matrix (size_type size1, size_type size2, const value_type &value = value_type(1)):
++ scalar_matrix (size_type s1, size_type s2, const value_type &value = value_type(1)):
+ matrix_container<self_type> (),
+- size1_ (size1), size2_ (size2), value_ (value) {}
++ size1_ (s1), size2_ (s2), value_ (value) {}
+ BOOST_UBLAS_INLINE
+ scalar_matrix (const scalar_matrix &m):
+ matrix_container<self_type> (),
+@@ -2990,9 +2990,9 @@
+
+ // Resizing
+ BOOST_UBLAS_INLINE
+- void resize (size_type size1, size_type size2, bool /*preserve*/ = true) {
+- size1_ = size1;
+- size2_ = size2;
++ void resize (size_type s1, size_type s2, bool /*preserve*/ = true) {
++ size1_ = s1;
++ size2_ = s2;
+ }
+
+ // Element access
+@@ -3446,8 +3446,8 @@
+ size1_ (N), size2_ (M) /* , data_ () */ {
+ }
+ BOOST_UBLAS_INLINE
+- c_matrix (size_type size1, size_type size2):
+- size1_ (size1), size2_ (size2) /* , data_ () */ {
++ c_matrix (size_type s1, size_type s2):
++ size1_ (s1), size2_ (s2) /* , data_ () */ {
+ if (size1_ > N || size2_ > M)
+ bad_size ().raise ();
+ }
+@@ -3487,14 +3487,14 @@
+
+ // Resizing
+ BOOST_UBLAS_INLINE
+- void resize (size_type size1, size_type size2, bool preserve = true) {
+- if (size1 > N || size2 > M)
++ void resize (size_type s1, size_type s2, bool preserve = true) {
++ if (s1 > N || s2 > M)
+ bad_size ().raise ();
+ if (preserve) {
+- self_type temporary (size1, size2);
++ self_type temporary (s1, s2);
+ // Common elements to preserve
+- const size_type size1_min = (std::min) (size1, size1_);
+- const size_type size2_min = (std::min) (size2, size2_);
++ const size_type size1_min = (std::min) (s1, size1_);
++ const size_type size2_min = (std::min) (s2, size2_);
+ for (size_type i = 0; i != size1_min; ++i) { // indexing copy over major
+ for (size_type j = 0; j != size2_min; ++j) {
+ temporary.data_[i][j] = data_[i][j];
+@@ -3503,8 +3503,8 @@
+ assign_temporary (temporary);
+ }
+ else {
+- size1_ = size1;
+- size2_ = size2;
++ size1_ = s1;
++ size2_ = s2;
+ }
+ }
+
+diff -aruN a/boost/numeric/ublas/matrix_proxy.hpp b/boost/numeric/ublas/matrix_proxy.hpp
+--- a/boost/numeric/ublas/matrix_proxy.hpp 2010-07-04 23:06:24.000000000 -0700
++++ b/boost/numeric/ublas/matrix_proxy.hpp 2012-02-07 15:25:24.631348942 -0800
+@@ -51,8 +51,8 @@
+
+ // Construction and destruction
+ BOOST_UBLAS_INLINE
+- matrix_row (matrix_type &data, size_type i):
+- data_ (data), i_ (i) {
++ matrix_row (matrix_type &d, size_type i):
++ data_ (d), i_ (i) {
+ // Early checking of preconditions here.
+ // BOOST_UBLAS_CHECK (i_ < data_.size1 (), bad_index ());
+ }
+@@ -508,8 +508,8 @@
+
+ // Construction and destruction
+ BOOST_UBLAS_INLINE
+- matrix_column (matrix_type &data, size_type j):
+- data_ (data), j_ (j) {
++ matrix_column (matrix_type &d, size_type j):
++ data_ (d), j_ (j) {
+ // Early checking of preconditions here.
+ // BOOST_UBLAS_CHECK (j_ < data_.size2 (), bad_index ());
+ }
+@@ -965,8 +965,8 @@
+
+ // Construction and destruction
+ BOOST_UBLAS_INLINE
+- matrix_vector_range (matrix_type &data, const range_type &r1, const range_type &r2):
+- data_ (data), r1_ (r1.preprocess (data.size1 ())), r2_ (r2.preprocess (data.size2 ())) {
++ matrix_vector_range (matrix_type &d, const range_type &r1, const range_type &r2):
++ data_ (d), r1_ (r1.preprocess (d.size1 ())), r2_ (r2.preprocess (d.size2 ())) {
+ // Early checking of preconditions here.
+ // BOOST_UBLAS_CHECK (r1_.start () <= data_.size1 () &&
+ // r1_.start () + r1_.size () <= data_.size1 (), bad_index ());
+@@ -1421,8 +1421,8 @@
+
+ // Construction and destruction
+ BOOST_UBLAS_INLINE
+- matrix_vector_slice (matrix_type &data, const slice_type &s1, const slice_type &s2):
+- data_ (data), s1_ (s1.preprocess (data.size1 ())), s2_ (s2.preprocess (data.size2 ())) {
++ matrix_vector_slice (matrix_type &d, const slice_type &s1, const slice_type &s2):
++ data_ (d), s1_ (s1.preprocess (d.size1 ())), s2_ (s2.preprocess (d.size2 ())) {
+ // Early checking of preconditions here.
+ // BOOST_UBLAS_CHECK (s1_.start () <= data_.size1 () &&
+ // s1_.start () + s1_.stride () * (s1_.size () - (s1_.size () > 0)) <= data_.size1 (), bad_index ());
+@@ -1886,11 +1886,11 @@
+
+ // Construction and destruction
+ BOOST_UBLAS_INLINE
+- matrix_vector_indirect (matrix_type &data, size_type size):
+- data_ (data), ia1_ (size), ia2_ (size) {}
++ matrix_vector_indirect (matrix_type &d, size_type s):
++ data_ (d), ia1_ (s), ia2_ (s) {}
+ BOOST_UBLAS_INLINE
+- matrix_vector_indirect (matrix_type &data, const indirect_array_type &ia1, const indirect_array_type &ia2):
+- data_ (data), ia1_ (ia1), ia2_ (ia2) {
++ matrix_vector_indirect (matrix_type &d, const indirect_array_type &ia1, const indirect_array_type &ia2):
++ data_ (d), ia1_ (ia1), ia2_ (ia2) {
+ // Early checking of preconditions here.
+ // BOOST_UBLAS_CHECK (ia1_.size () == ia2_.size (), bad_size ());
+ }
+@@ -2351,8 +2351,8 @@
+
+ // Construction and destruction
+ BOOST_UBLAS_INLINE
+- matrix_range (matrix_type &data, const range_type &r1, const range_type &r2):
+- data_ (data), r1_ (r1.preprocess (data.size1 ())), r2_ (r2.preprocess (data.size2 ())) {
++ matrix_range (matrix_type &d, const range_type &r1, const range_type &r2):
++ data_ (d), r1_ (r1.preprocess (d.size1 ())), r2_ (r2.preprocess (d.size2 ())) {
+ // Early checking of preconditions here.
+ // BOOST_UBLAS_CHECK (r1_.start () <= data_.size1 () &&
+ // r1_.start () + r1_.size () <= data_.size1 (), bad_index ());
+@@ -2360,8 +2360,8 @@
+ // r2_.start () + r2_.size () <= data_.size2 (), bad_index ());
+ }
+ BOOST_UBLAS_INLINE
+- matrix_range (const matrix_closure_type &data, const range_type &r1, const range_type &r2, int):
+- data_ (data), r1_ (r1.preprocess (data.size1 ())), r2_ (r2.preprocess (data.size2 ())) {
++ matrix_range (const matrix_closure_type &d, const range_type &r1, const range_type &r2, int):
++ data_ (d), r1_ (r1.preprocess (d.size1 ())), r2_ (r2.preprocess (d.size2 ())) {
+ // Early checking of preconditions here.
+ // BOOST_UBLAS_CHECK (r1_.start () <= data_.size1 () &&
+ // r1_.start () + r1_.size () <= data_.size1 (), bad_index ());
+@@ -3255,8 +3255,8 @@
+
+ // Construction and destruction
+ BOOST_UBLAS_INLINE
+- matrix_slice (matrix_type &data, const slice_type &s1, const slice_type &s2):
+- data_ (data), s1_ (s1.preprocess (data.size1 ())), s2_ (s2.preprocess (data.size2 ())) {
++ matrix_slice (matrix_type &d, const slice_type &s1, const slice_type &s2):
++ data_ (d), s1_ (s1.preprocess (d.size1 ())), s2_ (s2.preprocess (d.size2 ())) {
+ // Early checking of preconditions here.
+ // BOOST_UBLAS_CHECK (s1_.start () <= data_.size1 () &&
+ // s1_.start () + s1_.stride () * (s1_.size () - (s1_.size () > 0)) <= data_.size1 (), bad_index ());
+@@ -3264,8 +3264,8 @@
+ // s2_.start () + s2_.stride () * (s2_.size () - (s2_.size () > 0)) <= data_.size2 (), bad_index ());
+ }
+ BOOST_UBLAS_INLINE
+- matrix_slice (const matrix_closure_type &data, const slice_type &s1, const slice_type &s2, int):
+- data_ (data), s1_ (s1.preprocess (data.size1 ())), s2_ (s2.preprocess (data.size2 ())) {
++ matrix_slice (const matrix_closure_type &d, const slice_type &s1, const slice_type &s2, int):
++ data_ (d), s1_ (s1.preprocess (d.size1 ())), s2_ (s2.preprocess (d.size2 ())) {
+ // Early checking of preconditions.
+ // BOOST_UBLAS_CHECK (s1_.start () <= data_.size1 () &&
+ // s1_.start () + s1_.stride () * (s1_.size () - (s1_.size () > 0)) <= data_.size1 (), bad_index ());
+@@ -4213,14 +4213,14 @@
+
+ // Construction and destruction
+ BOOST_UBLAS_INLINE
+- matrix_indirect (matrix_type &data, size_type size1, size_type size2):
+- data_ (data), ia1_ (size1), ia2_ (size2) {}
++ matrix_indirect (matrix_type &d, size_type s1, size_type s2):
++ data_ (d), ia1_ (s1), ia2_ (s2) {}
+ BOOST_UBLAS_INLINE
+- matrix_indirect (matrix_type &data, const indirect_array_type &ia1, const indirect_array_type &ia2):
+- data_ (data), ia1_ (ia1.preprocess (data.size1 ())), ia2_ (ia2.preprocess (data.size2 ())) {}
++ matrix_indirect (matrix_type &d, const indirect_array_type &ia1, const indirect_array_type &ia2):
++ data_ (d), ia1_ (ia1.preprocess (d.size1 ())), ia2_ (ia2.preprocess (d.size2 ())) {}
+ BOOST_UBLAS_INLINE
+- matrix_indirect (const matrix_closure_type &data, const indirect_array_type &ia1, const indirect_array_type &ia2, int):
+- data_ (data), ia1_ (ia1.preprocess (data.size1 ())), ia2_ (ia2.preprocess (data.size2 ())) {}
++ matrix_indirect (const matrix_closure_type &d, const indirect_array_type &ia1, const indirect_array_type &ia2, int):
++ data_ (d), ia1_ (ia1.preprocess (d.size1 ())), ia2_ (ia2.preprocess (d.size2 ())) {}
+
+ // Accessors
+ BOOST_UBLAS_INLINE
+diff -aruN a/boost/numeric/ublas/matrix_sparse.hpp b/boost/numeric/ublas/matrix_sparse.hpp
+--- a/boost/numeric/ublas/matrix_sparse.hpp 2010-07-04 23:06:24.000000000 -0700
++++ b/boost/numeric/ublas/matrix_sparse.hpp 2012-02-07 15:25:24.635307503 -0800
+@@ -300,9 +300,9 @@
+ matrix_container<self_type> (),
+ size1_ (0), size2_ (0), data_ () {}
+ BOOST_UBLAS_INLINE
+- mapped_matrix (size_type size1, size_type size2, size_type non_zeros = 0):
++ mapped_matrix (size_type s1, size_type s2, size_type non_zeros = 0):
+ matrix_container<self_type> (),
+- size1_ (size1), size2_ (size2), data_ () {
++ size1_ (s1), size2_ (s2), data_ () {
+ detail::map_reserve (data (), restrict_capacity (non_zeros));
+ }
+ BOOST_UBLAS_INLINE
+@@ -358,11 +358,11 @@
+ }
+ public:
+ BOOST_UBLAS_INLINE
+- void resize (size_type size1, size_type size2, bool preserve = true) {
++ void resize (size_type s1, size_type s2, bool preserve = true) {
+ // FIXME preserve unimplemented
+ BOOST_UBLAS_CHECK (!preserve, internal_logic ());
+- size1_ = size1;
+- size2_ = size2;
++ size1_ = s1;
++ size2_ = s2;
+ data ().clear ();
+ }
+
+@@ -1373,9 +1373,9 @@
+ data_ [layout_type::size_M (size1_, size2_)] = vector_data_value_type ();
+ }
+ BOOST_UBLAS_INLINE
+- mapped_vector_of_mapped_vector (size_type size1, size_type size2, size_type non_zeros = 0):
++ mapped_vector_of_mapped_vector (size_type s1, size_type s2, size_type non_zeros = 0):
+ matrix_container<self_type> (),
+- size1_ (size1), size2_ (size2), data_ () {
++ size1_ (s1), size2_ (s2), data_ () {
+ data_ [layout_type::size_M (size1_, size2_)] = vector_data_value_type ();
+ }
+ BOOST_UBLAS_INLINE
+@@ -1427,11 +1427,11 @@
+
+ // Resizing
+ BOOST_UBLAS_INLINE
+- void resize (size_type size1, size_type size2, bool preserve = true) {
++ void resize (size_type s1, size_type s2, bool preserve = true) {
+ // FIXME preserve unimplemented
+ BOOST_UBLAS_CHECK (!preserve, internal_logic ());
+- size1_ = size1;
+- size2_ = size2;
++ size1_ = s1;
++ size2_ = s2;
+ data ().clear ();
+ data () [layout_type::size_M (size1_, size2_)] = vector_data_value_type ();
+ }
+@@ -2666,9 +2666,9 @@
+ storage_invariants ();
+ }
+ BOOST_UBLAS_INLINE
+- compressed_matrix (size_type size1, size_type size2, size_type non_zeros = 0):
++ compressed_matrix (size_type s1, size_type s2, size_type non_zeros = 0):
+ matrix_container<self_type> (),
+- size1_ (size1), size2_ (size2), capacity_ (restrict_capacity (non_zeros)),
++ size1_ (s1), size2_ (s2), capacity_ (restrict_capacity (non_zeros)),
+ filled1_ (1), filled2_ (0),
+ index1_data_ (layout_type::size_M (size1_, size2_) + 1), index2_data_ (capacity_), value_data_ (capacity_) {
+ index1_data_ [filled1_ - 1] = k_based (filled2_);
+@@ -2764,9 +2764,9 @@
+ return value_data_;
+ }
+ BOOST_UBLAS_INLINE
+- void set_filled (const array_size_type& filled1, const array_size_type& filled2) {
+- filled1_ = filled1;
+- filled2_ = filled2;
++ void set_filled (const array_size_type& f1, const array_size_type& f2) {
++ filled1_ = f1;
++ filled2_ = f2;
+ storage_invariants ();
+ }
+ BOOST_UBLAS_INLINE
+@@ -2802,11 +2802,11 @@
+ }
+ public:
+ BOOST_UBLAS_INLINE
+- void resize (size_type size1, size_type size2, bool preserve = true) {
++ void resize (size_type s1, size_type s2, bool preserve = true) {
+ // FIXME preserve unimplemented
+ BOOST_UBLAS_CHECK (!preserve, internal_logic ());
+- size1_ = size1;
+- size2_ = size2;
++ size1_ = s1;
++ size2_ = s2;
+ capacity_ = restrict_capacity (capacity_);
+ filled1_ = 1;
+ filled2_ = 0;
+@@ -4045,9 +4045,9 @@
+ storage_invariants ();
+ }
+ BOOST_UBLAS_INLINE
+- coordinate_matrix (size_type size1, size_type size2, array_size_type non_zeros = 0):
++ coordinate_matrix (size_type s1, size_type s2, array_size_type non_zeros = 0):
+ matrix_container<self_type> (),
+- size1_ (size1), size2_ (size2), capacity_ (restrict_capacity (non_zeros)),
++ size1_ (s1), size2_ (s2), capacity_ (restrict_capacity (non_zeros)),
+ filled_ (0), sorted_filled_ (filled_), sorted_ (true),
+ index1_data_ (capacity_), index2_data_ (capacity_), value_data_ (capacity_) {
+ storage_invariants ();
+@@ -4111,13 +4111,13 @@
+ return value_data_;
+ }
+ BOOST_UBLAS_INLINE
+- void set_filled (const array_size_type &filled) {
++ void set_filled (const array_size_type &f) {
+ // Make sure that storage_invariants() succeeds
+- if (sorted_ && filled < filled_)
+- sorted_filled_ = filled;
++ if (sorted_ && f < filled_)
++ sorted_filled_ = f;
+ else
+- sorted_ = (sorted_filled_ == filled);
+- filled_ = filled;
++ sorted_ = (sorted_filled_ == f);
++ filled_ = f;
+ storage_invariants ();
+ }
+ BOOST_UBLAS_INLINE
+@@ -4144,11 +4144,11 @@
+ }
+ public:
+ BOOST_UBLAS_INLINE
+- void resize (size_type size1, size_type size2, bool preserve = true) {
++ void resize (size_type s1, size_type s2, bool preserve = true) {
+ // FIXME preserve unimplemented
+ BOOST_UBLAS_CHECK (!preserve, internal_logic ());
+- size1_ = size1;
+- size2_ = size2;
++ size1_ = s1;
++ size2_ = s2;
+ capacity_ = restrict_capacity (capacity_);
+ index1_data_.resize (capacity_);
+ index2_data_.resize (capacity_);
+@@ -4403,21 +4403,21 @@
+ std::inplace_merge (ita.begin (), iunsorted, ita.end ());
+
+ // sum duplicates with += and remove
+- array_size_type filled = 0;
++ array_size_type f = 0;
+ for (array_size_type i = 1; i < filled_; ++ i) {
+- if (index1_data_ [filled] != index1_data_ [i] ||
+- index2_data_ [filled] != index2_data_ [i]) {
+- ++ filled;
+- if (filled != i) {
+- index1_data_ [filled] = index1_data_ [i];
+- index2_data_ [filled] = index2_data_ [i];
+- value_data_ [filled] = value_data_ [i];
++ if (index1_data_ [f] != index1_data_ [i] ||
++ index2_data_ [f] != index2_data_ [i]) {
++ ++ f;
++ if (f != i) {
++ index1_data_ [f] = index1_data_ [i];
++ index2_data_ [f] = index2_data_ [i];
++ value_data_ [f] = value_data_ [i];
+ }
+ } else {
+- value_data_ [filled] += value_data_ [i];
++ value_data_ [f] += value_data_ [i];
+ }
+ }
+- filled_ = filled + 1;
++ filled_ = f + 1;
+ sorted_filled_ = filled_;
+ sorted_ = true;
+ storage_invariants ();
+diff -aruN a/boost/numeric/ublas/storage.hpp b/boost/numeric/ublas/storage.hpp
+--- a/boost/numeric/ublas/storage.hpp 2010-04-06 13:09:04.000000000 -0700
++++ b/boost/numeric/ublas/storage.hpp 2012-02-07 15:25:24.635307503 -0800
+@@ -62,8 +62,8 @@
+ data_ = 0;
+ }
+ explicit BOOST_UBLAS_INLINE
+- unbounded_array (size_type size, const ALLOC &a = ALLOC()):
+- alloc_(a), size_ (size) {
++ unbounded_array (size_type s, const ALLOC &a = ALLOC()):
++ alloc_(a), size_ (s) {
+ if (size_) {
+ data_ = alloc_.allocate (size_);
+ if (! detail::has_trivial_constructor<T>::value) {
+@@ -76,8 +76,8 @@
+ }
+ // No value initialised, but still be default constructed
+ BOOST_UBLAS_INLINE
+- unbounded_array (size_type size, const value_type &init, const ALLOC &a = ALLOC()):
+- alloc_ (a), size_ (size) {
++ unbounded_array (size_type s, const value_type &init, const ALLOC &a = ALLOC()):
++ alloc_ (a), size_ (s) {
+ if (size_) {
+ data_ = alloc_.allocate (size_);
+ std::uninitialized_fill (begin(), end(), init);
+@@ -113,33 +113,33 @@
+ // Resizing
+ private:
+ BOOST_UBLAS_INLINE
+- void resize_internal (const size_type size, const value_type init, const bool preserve) {
+- if (size != size_) {
++ void resize_internal (const size_type s, const value_type init, const bool preserve) {
++ if (s != size_) {
+ pointer p_data = data_;
+- if (size) {
+- data_ = alloc_.allocate (size);
++ if (s) {
++ data_ = alloc_.allocate (s);
+ if (preserve) {
+ pointer si = p_data;
+ pointer di = data_;
+- if (size < size_) {
+- for (; di != data_ + size; ++di) {
++ if (s < size_) {
++ for (; di != data_ + s; ++di) {
+ alloc_.construct (di, *si);
+ ++si;
+ }
+ }
+ else {
+- for (pointer si = p_data; si != p_data + size_; ++si) {
+- alloc_.construct (di, *si);
++ for (pointer si2 = p_data; si2 != p_data + size_; ++si) {
++ alloc_.construct (di, *si2);
+ ++di;
+ }
+- for (; di != data_ + size; ++di) {
++ for (; di != data_ + s; ++di) {
+ alloc_.construct (di, init);
+ }
+ }
+ }
+ else {
+ if (! detail::has_trivial_constructor<T>::value) {
+- for (pointer di = data_; di != data_ + size; ++di)
++ for (pointer di = data_; di != data_ + s; ++di)
+ alloc_.construct (di, value_type());
+ }
+ }
+@@ -153,19 +153,19 @@
+ alloc_.deallocate (p_data, size_);
+ }
+
+- if (!size)
++ if (!s)
+ data_ = 0;
+- size_ = size;
++ size_ = s;
+ }
+ }
+ public:
+ BOOST_UBLAS_INLINE
+- void resize (size_type size) {
+- resize_internal (size, value_type (), false);
++ void resize (size_type s) {
++ resize_internal (s, value_type (), false);
+ }
+ BOOST_UBLAS_INLINE
+- void resize (size_type size, value_type init) {
+- resize_internal (size, init, true);
++ void resize (size_type s, value_type init) {
++ resize_internal (s, init, true);
+ }
+
+ // Random Access Container
+@@ -318,14 +318,14 @@
+ size_ (0) /*, data_ ()*/ { // size 0 - use bounded_vector to default construct with size N
+ }
+ explicit BOOST_UBLAS_INLINE
+- bounded_array (size_type size):
+- size_ (size) /*, data_ ()*/ {
++ bounded_array (size_type s):
++ size_ (s) /*, data_ ()*/ {
+ BOOST_UBLAS_CHECK (size_ <= N, bad_size ());
+ // data_ (an array) elements are already default constructed
+ }
+ BOOST_UBLAS_INLINE
+- bounded_array (size_type size, const value_type &init):
+- size_ (size) /*, data_ ()*/ {
++ bounded_array (size_type s, const value_type &init):
++ size_ (s) /*, data_ ()*/ {
+ BOOST_UBLAS_CHECK (size_ <= N, bad_size ());
+ // ISSUE elements should be value constructed here, but we must fill instead as already default constructed
+ std::fill (begin(), end(), init) ;
+@@ -339,16 +339,16 @@
+
+ // Resizing
+ BOOST_UBLAS_INLINE
+- void resize (size_type size) {
+- BOOST_UBLAS_CHECK (size <= N, bad_size ());
+- size_ = size;
++ void resize (size_type s) {
++ BOOST_UBLAS_CHECK (s <= N, bad_size ());
++ size_ = s;
+ }
+ BOOST_UBLAS_INLINE
+- void resize (size_type size, value_type init) {
+- BOOST_UBLAS_CHECK (size <= N, bad_size ());
+- if (size > size_)
+- std::fill (data_ + size_, data_ + size, init);
+- size_ = size;
++ void resize (size_type s, value_type init) {
++ BOOST_UBLAS_CHECK (s <= N, bad_size ());
++ if (s > size_)
++ std::fill (data_ + size_, data_ + s, init);
++ size_ = s;
+ }
+
+ // Random Access Container
+@@ -489,17 +489,17 @@
+ size_ (0), own_ (true), data_ (new value_type [0]) {
+ }
+ explicit BOOST_UBLAS_INLINE
+- array_adaptor (size_type size):
+- size_ (size), own_ (true), data_ (new value_type [size]) {
++ array_adaptor (size_type s):
++ size_ (s), own_ (true), data_ (new value_type [s]) {
+ }
+ BOOST_UBLAS_INLINE
+- array_adaptor (size_type size, const value_type &init):
+- size_ (size), own_ (true), data_ (new value_type [size]) {
++ array_adaptor (size_type s, const value_type &init):
++ size_ (s), own_ (true), data_ (new value_type [s]) {
+ std::fill (data_, data_ + size_, init);
+ }
+ BOOST_UBLAS_INLINE
+- array_adaptor (size_type size, pointer data):
+- size_ (size), own_ (false), data_ (data) {}
++ array_adaptor (size_type s, pointer d):
++ size_ (s), own_ (false), data_ (d) {}
+ BOOST_UBLAS_INLINE
+ array_adaptor (const array_adaptor &a):
+ storage_array<self_type> (),
+@@ -516,26 +516,26 @@
+ // Resizing
+ private:
+ BOOST_UBLAS_INLINE
+- void resize_internal (size_type size, value_type init, bool preserve = true) {
+- if (size != size_) {
+- pointer data = new value_type [size];
++ void resize_internal (size_type s, value_type init, bool preserve = true) {
++ if (s != size_) {
++ pointer data = new value_type [s];
+ if (preserve) {
+- std::copy (data_, data_ + (std::min) (size, size_), data);
+- std::fill (data + (std::min) (size, size_), data + size, init);
++ std::copy (data_, data_ + (std::min) (s, size_), data);
++ std::fill (data + (std::min) (s, size_), data + s, init);
+ }
+ if (own_)
+ delete [] data_;
+- size_ = size;
++ size_ = s;
+ own_ = true;
+ data_ = data;
+ }
+ }
+ BOOST_UBLAS_INLINE
+- void resize_internal (size_type size, pointer data, value_type init, bool preserve = true) {
++ void resize_internal (size_type s, pointer data, value_type init, bool preserve = true) {
+ if (data != data_) {
+ if (preserve) {
+- std::copy (data_, data_ + (std::min) (size, size_), data);
+- std::fill (data + (std::min) (size, size_), data + size, init);
++ std::copy (data_, data_ + (std::min) (s, size_), data);
++ std::fill (data + (std::min) (s, size_), data + s, init);
+ }
+ if (own_)
+ delete [] data_;
+@@ -543,26 +543,26 @@
+ data_ = data;
+ }
+ else {
+- std::fill (data + (std::min) (size, size_), data + size, init);
++ std::fill (data + (std::min) (s, size_), data + s, init);
+ }
+- size_ = size;
++ size_ = s;
+ }
+ public:
+ BOOST_UBLAS_INLINE
+- void resize (size_type size) {
+- resize_internal (size, value_type (), false);
++ void resize (size_type s) {
++ resize_internal (s, value_type (), false);
+ }
+ BOOST_UBLAS_INLINE
+- void resize (size_type size, value_type init) {
+- resize_internal (size, init, true);
++ void resize (size_type s, value_type init) {
++ resize_internal (s, init, true);
+ }
+ BOOST_UBLAS_INLINE
+- void resize (size_type size, pointer data) {
+- resize_internal (size, data, value_type (), false);
++ void resize (size_type s, pointer data) {
++ resize_internal (s, data, value_type (), false);
+ }
+ BOOST_UBLAS_INLINE
+- void resize (size_type size, pointer data, value_type init) {
+- resize_internal (size, data, init, true);
++ void resize (size_type s, pointer data, value_type init) {
++ resize_internal (s, data, init, true);
+ }
+
+ BOOST_UBLAS_INLINE
+@@ -882,9 +882,9 @@
+ basic_range ():
+ start_ (0), size_ (0) {}
+ BOOST_UBLAS_INLINE
+- basic_range (size_type start, size_type stop):
+- start_ (start), size_ (stop - start) {
+- BOOST_UBLAS_CHECK (start_ <= stop, bad_index ());
++ basic_range (size_type in_start, size_type in_stop):
++ start_ (in_start), size_ (in_stop - in_start) {
++ BOOST_UBLAS_CHECK (start_ <= in_stop, bad_index ());
+ }
+
+ BOOST_UBLAS_INLINE
+@@ -1055,10 +1055,10 @@
+ }
+
+ BOOST_UBLAS_INLINE
+- basic_range preprocess (size_type size) const {
++ basic_range preprocess (size_type s) const {
+ if (this != &all_)
+ return *this;
+- return basic_range (0, size);
++ return basic_range (0, s);
+ }
+ static
+ BOOST_UBLAS_INLINE
+@@ -1094,8 +1094,8 @@
+ basic_slice ():
+ start_ (0), stride_ (0), size_ (0) {}
+ BOOST_UBLAS_INLINE
+- basic_slice (size_type start, difference_type stride, size_type size):
+- start_ (start), stride_ (stride), size_ (size) {}
++ basic_slice (size_type in_start, difference_type in_stride, size_type in_size):
++ start_ (in_start), stride_ (in_stride), size_ (in_size) {}
+
+ BOOST_UBLAS_INLINE
+ size_type start () const {
+@@ -1274,10 +1274,10 @@
+ }
+
+ BOOST_UBLAS_INLINE
+- basic_slice preprocess (size_type size) const {
++ basic_slice preprocess (size_type s) const {
+ if (this != &all_)
+ return *this;
+- return basic_slice (0, 1, size);
++ return basic_slice (0, 1, s);
+ }
+ static
+ BOOST_UBLAS_INLINE
+@@ -1316,11 +1316,11 @@
+ indirect_array ():
+ size_ (), data_ () {}
+ explicit BOOST_UBLAS_INLINE
+- indirect_array (size_type size):
+- size_ (size), data_ (size) {}
++ indirect_array (size_type s):
++ size_ (s), data_ (s) {}
+ BOOST_UBLAS_INLINE
+- indirect_array (size_type size, const array_type &data):
+- size_ (size), data_ (data) {}
++ indirect_array (size_type s, const array_type &d):
++ size_ (s), data_ (d) {}
+ BOOST_UBLAS_INLINE
+ indirect_array (pointer start, pointer stop):
+ size_ (stop - start), data_ (stop - start) {
+@@ -1376,27 +1376,27 @@
+ BOOST_UBLAS_INLINE
+ indirect_array compose (const basic_range<size_type, difference_type> &r) const {
+ BOOST_UBLAS_CHECK (r.start () + r.size () <= size_, bad_size ());
+- array_type data (r.size ());
++ array_type local_data (r.size ());
+ for (size_type i = 0; i < r.size (); ++ i)
+- data [i] = data_ [r.start () + i];
+- return indirect_array (r.size (), data);
++ local_data [i] = data_ [r.start () + i];
++ return indirect_array (r.size (), local_data);
+ }
+ BOOST_UBLAS_INLINE
+ indirect_array compose (const basic_slice<size_type, difference_type> &s) const {
+ BOOST_UBLAS_CHECK (s.start () + s.stride () * (s.size () - (s.size () > 0)) <= size (), bad_size ());
+- array_type data (s.size ());
++ array_type local_data (s.size ());
+ for (size_type i = 0; i < s.size (); ++ i)
+- data [i] = data_ [s.start () + s.stride () * i];
+- return indirect_array (s.size (), data);
++ local_data [i] = data_ [s.start () + s.stride () * i];
++ return indirect_array (s.size (), local_data);
+ }
+ BOOST_UBLAS_INLINE
+ indirect_array compose (const indirect_array &ia) const {
+- array_type data (ia.size_);
++ array_type local_data (ia.size_);
+ for (size_type i = 0; i < ia.size_; ++ i) {
+ BOOST_UBLAS_CHECK (ia.data_ [i] <= size_, bad_size ());
+- data [i] = data_ [ia.data_ [i]];
++ local_data [i] = data_ [ia.data_ [i]];
+ }
+- return indirect_array (ia.size_, data);
++ return indirect_array (ia.size_, local_data);
+ }
+
+ // Comparison
+@@ -1534,11 +1534,11 @@
+ }
+
+ BOOST_UBLAS_INLINE
+- indirect_array preprocess (size_type size) const {
++ indirect_array preprocess (size_type s) const {
+ if (this != &all_)
+ return *this;
+- indirect_array ia (size);
+- for (size_type i = 0; i < size; ++ i)
++ indirect_array ia (s);
++ for (size_type i = 0; i < s; ++ i)
+ ia (i) = i;
+ return ia;
+ }
+@@ -1666,8 +1666,8 @@
+ typedef const value_type const_reference;
+
+ BOOST_UBLAS_INLINE
+- index_pair_array(size_type size, V1& data1, V2& data2) :
+- size_(size),data1_(data1),data2_(data2) {}
++ index_pair_array(size_type s, V1& data1, V2& data2) :
++ size_(s),data1_(data1),data2_(data2) {}
+
+ BOOST_UBLAS_INLINE
+ size_type size() const {
+@@ -1841,8 +1841,8 @@
+ typedef const value_type const_reference;
+
+ BOOST_UBLAS_INLINE
+- index_triple_array(size_type size, V1& data1, V2& data2, V3& data3) :
+- size_(size),data1_(data1),data2_(data2),data3_(data3) {}
++ index_triple_array(size_type s, V1& data1, V2& data2, V3& data3) :
++ size_(s),data1_(data1),data2_(data2),data3_(data3) {}
+
+ BOOST_UBLAS_INLINE
+ size_type size() const {
+diff -aruN a/boost/numeric/ublas/storage_sparse.hpp b/boost/numeric/ublas/storage_sparse.hpp
+--- a/boost/numeric/ublas/storage_sparse.hpp 2009-03-09 13:24:11.000000000 -0700
++++ b/boost/numeric/ublas/storage_sparse.hpp 2012-02-07 15:25:24.635307503 -0800
+@@ -263,38 +263,38 @@
+ private:
+ // Resizing - implicitly exposses uninitialized (but default constructed) mapped_type
+ BOOST_UBLAS_INLINE
+- void resize (size_type size) {
++ void resize (size_type s) {
+ BOOST_UBLAS_CHECK (size_ <= capacity_, internal_logic ());
+- if (size > capacity_) {
+- const size_type capacity = size << 1;
+- BOOST_UBLAS_CHECK (capacity, internal_logic ());
+- pointer data = alloc_.allocate (capacity);
+- std::uninitialized_copy (data_, data_ + (std::min) (size, size_), data);
+- std::uninitialized_fill (data + (std::min) (size, size_), data + capacity, value_type ());
++ if (s > capacity_) {
++ const size_type cap = s << 1;
++ BOOST_UBLAS_CHECK (cap, internal_logic ());
++ pointer data = alloc_.allocate (cap);
++ std::uninitialized_copy (data_, data_ + (std::min) (s, size_), data);
++ std::uninitialized_fill (data + (std::min) (s, size_), data + cap, value_type ());
+
+ if (capacity_) {
+ std::for_each (data_, data_ + capacity_, static_destroy);
+ alloc_.deallocate (data_, capacity_);
+ }
+- capacity_ = capacity;
++ capacity_ = cap;
+ data_ = data;
+ }
+- size_ = size;
++ size_ = s;
+ BOOST_UBLAS_CHECK (size_ <= capacity_, internal_logic ());
+ }
+ public:
+
+ // Reserving
+ BOOST_UBLAS_INLINE
+- void reserve (size_type capacity) {
++ void reserve (size_type cap) {
+ BOOST_UBLAS_CHECK (size_ <= capacity_, internal_logic ());
+ // Reduce capacity_ if size_ allows
+- BOOST_UBLAS_CHECK (capacity >= size_, bad_size ());
++ BOOST_UBLAS_CHECK (cap >= size_, bad_size ());
+ pointer data;
+- if (capacity) {
+- data = alloc_.allocate (capacity);
++ if (cap) {
++ data = alloc_.allocate (cap);
+ std::uninitialized_copy (data_, data_ + size_, data);
+- std::uninitialized_fill (data + size_, data + capacity, value_type ());
++ std::uninitialized_fill (data + size_, data + cap, value_type ());
+ }
+ else
+ data = 0;
+@@ -303,7 +303,7 @@
+ std::for_each (data_, data_ + capacity_, static_destroy);
+ alloc_.deallocate (data_, capacity_);
+ }
+- capacity_ = capacity;
++ capacity_ = cap;
+ data_ = data;
+ BOOST_UBLAS_CHECK (size_ <= capacity_, internal_logic ());
+ }
+diff -aruN a/boost/numeric/ublas/symmetric.hpp b/boost/numeric/ublas/symmetric.hpp
+--- a/boost/numeric/ublas/symmetric.hpp 2009-10-06 16:53:19.000000000 -0700
++++ b/boost/numeric/ublas/symmetric.hpp 2012-02-07 15:25:24.635307503 -0800
+@@ -76,14 +76,14 @@
+ size_ (BOOST_UBLAS_SAME (size, size)), data_ (triangular_type::packed_size (layout_type (), size, size)) {
+ }
+ BOOST_UBLAS_INLINE
+- symmetric_matrix (size_type size1, size_type size2):
++ symmetric_matrix (size_type s1, size_type s2):
+ matrix_container<self_type> (),
+- size_ (BOOST_UBLAS_SAME (size1, size2)), data_ (triangular_type::packed_size (layout_type (), size1, size2)) {
++ size_ (BOOST_UBLAS_SAME (s1, s2)), data_ (triangular_type::packed_size (layout_type (), s1, s2)) {
+ }
+ BOOST_UBLAS_INLINE
+- symmetric_matrix (size_type size, const array_type &data):
++ symmetric_matrix (size_type size, const array_type &d):
+ matrix_container<self_type> (),
+- size_ (size), data_ (data) {}
++ size_ (size), data_ (d) {}
+ BOOST_UBLAS_INLINE
+ symmetric_matrix (const symmetric_matrix &m):
+ matrix_container<self_type> (),
+@@ -130,8 +130,8 @@
+ }
+ }
+ BOOST_UBLAS_INLINE
+- void resize (size_type size1, size_type size2, bool preserve = true) {
+- resize (BOOST_UBLAS_SAME (size1, size2), preserve);
++ void resize (size_type s1, size_type s2, bool preserve = true) {
++ resize (BOOST_UBLAS_SAME (s1, s2), preserve);
+ }
+ BOOST_UBLAS_INLINE
+ void resize_packed_preserve (size_type size) {
+@@ -944,9 +944,9 @@
+
+ // Construction and destruction
+ BOOST_UBLAS_INLINE
+- symmetric_adaptor (matrix_type &data):
++ symmetric_adaptor (matrix_type &d):
+ matrix_expression<self_type> (),
+- data_ (data) {
++ data_ (d) {
+ BOOST_UBLAS_CHECK (data_.size1 () == data_.size2 (), bad_size ());
+ }
+ BOOST_UBLAS_INLINE
+@@ -1201,11 +1201,11 @@
+ it1_begin_ (), it1_end_ (), it1_ (),
+ it2_begin_ (), it2_end_ (), it2_ () {}
+ BOOST_UBLAS_INLINE
+- const_iterator1 (const self_type &m, int begin, int end,
++ const_iterator1 (const self_type &m, int b, int e,
+ const const_subiterator1_type &it1_begin, const const_subiterator1_type &it1_end,
+ const const_subiterator2_type &it2_begin, const const_subiterator2_type &it2_end):
+ container_const_reference<self_type> (m),
+- begin_ (begin), end_ (end), current_ (begin),
++ begin_ (b), end_ (e), current_ (b),
+ it1_begin_ (it1_begin), it1_end_ (it1_end), it1_ (it1_begin_),
+ it2_begin_ (it2_begin), it2_end_ (it2_end), it2_ (it2_begin_) {
+ if (current_ == 0 && it1_ == it1_end_)
+@@ -1648,11 +1648,11 @@
+ it1_begin_ (), it1_end_ (), it1_ (),
+ it2_begin_ (), it2_end_ (), it2_ () {}
+ BOOST_UBLAS_INLINE
+- const_iterator2 (const self_type &m, int begin, int end,
++ const_iterator2 (const self_type &m, int b, int e,
+ const const_subiterator1_type &it1_begin, const const_subiterator1_type &it1_end,
+ const const_subiterator2_type &it2_begin, const const_subiterator2_type &it2_end):
+ container_const_reference<self_type> (m),
+- begin_ (begin), end_ (end), current_ (begin),
++ begin_ (b), end_ (e), current_ (b),
+ it1_begin_ (it1_begin), it1_end_ (it1_end), it1_ (it1_begin_),
+ it2_begin_ (it2_begin), it2_end_ (it2_end), it2_ (it2_begin_) {
+ if (current_ == 0 && it1_ == it1_end_)
+diff -aruN a/boost/numeric/ublas/triangular.hpp b/boost/numeric/ublas/triangular.hpp
+--- a/boost/numeric/ublas/triangular.hpp 2010-07-04 23:06:24.000000000 -0700
++++ b/boost/numeric/ublas/triangular.hpp 2012-02-07 15:25:24.639286239 -0800
+@@ -106,14 +106,14 @@
+ matrix_container<self_type> (),
+ size1_ (0), size2_ (0), data_ (0) {}
+ BOOST_UBLAS_INLINE
+- triangular_matrix (size_type size1, size_type size2):
++ triangular_matrix (size_type s1, size_type s2):
+ matrix_container<self_type> (),
+- size1_ (size1), size2_ (size2), data_ (triangular_type::packed_size (layout_type (), size1, size2)) {
++ size1_ (s1), size2_ (s2), data_ (triangular_type::packed_size (layout_type (), s1, s2)) {
+ }
+ BOOST_UBLAS_INLINE
+- triangular_matrix (size_type size1, size_type size2, const array_type &data):
++ triangular_matrix (size_type s1, size_type s2, const array_type &d):
+ matrix_container<self_type> (),
+- size1_ (size1), size2_ (size2), data_ (data) {}
++ size1_ (s1), size2_ (s2), data_ (d) {}
+ BOOST_UBLAS_INLINE
+ triangular_matrix (const triangular_matrix &m):
+ matrix_container<self_type> (),
+@@ -149,21 +149,21 @@
+
+ // Resizing
+ BOOST_UBLAS_INLINE
+- void resize (size_type size1, size_type size2, bool preserve = true) {
++ void resize (size_type s1, size_type s2, bool preserve = true) {
+ if (preserve) {
+- self_type temporary (size1, size2);
++ self_type temporary (s1, s2);
+ detail::matrix_resize_preserve<layout_type, triangular_type> (*this, temporary);
+ }
+ else {
+- data ().resize (triangular_type::packed_size (layout_type (), size1, size2));
+- size1_ = size1;
+- size2_ = size2;
++ data ().resize (triangular_type::packed_size (layout_type (), s1, s2));
++ size1_ = s1;
++ size2_ = s2;
+ }
+ }
+ BOOST_UBLAS_INLINE
+- void resize_packed_preserve (size_type size1, size_type size2) {
+- size1_ = size1;
+- size2_ = size2;
++ void resize_packed_preserve (size_type s1, size_type s2) {
++ size1_ = s1;
++ size2_ = s2;
+ data ().resize (triangular_type::packed_size (layout_type (), size1_, size2_), value_type ());
+ }
+
+@@ -996,9 +996,9 @@
+
+ // Construction and destruction
+ BOOST_UBLAS_INLINE
+- triangular_adaptor (matrix_type &data):
++ triangular_adaptor (matrix_type &d):
+ matrix_expression<self_type> (),
+- data_ (data) {}
++ data_ (d) {}
+ BOOST_UBLAS_INLINE
+ triangular_adaptor (const triangular_adaptor &m):
+ matrix_expression<self_type> (),
+diff -aruN a/boost/numeric/ublas/vector.hpp b/boost/numeric/ublas/vector.hpp
+--- a/boost/numeric/ublas/vector.hpp 2010-07-04 23:06:24.000000000 -0700
++++ b/boost/numeric/ublas/vector.hpp 2012-02-07 15:25:24.639286239 -0800
+@@ -72,9 +72,9 @@
+ /// By default, its elements are initialized to 0.
+ /// \param size initial size of the vector
+ explicit BOOST_UBLAS_INLINE
+- vector (size_type size):
++ vector (size_type s):
+ vector_container<self_type> (),
+- data_ (size) {
++ data_ (s) {
+ }
+
+ /// \brief Constructor of a vector by copying from another container
+@@ -83,25 +83,25 @@
+ /// \param data container of type \c A
+ /// \todo remove this definition because \c size is not used
+ BOOST_UBLAS_INLINE
+- vector (size_type size, const array_type &data):
++ vector (size_type s, const array_type &d):
+ vector_container<self_type> (),
+- data_ (data) {}
++ data_ (d) {}
+
+ /// \brief Constructor of a vector by copying from another container
+ /// This type has the generic name \c array_typ within the vector definition.
+ /// \param data container of type \c A
+ BOOST_UBLAS_INLINE
+- vector (const array_type &data):
++ vector (const array_type &d):
+ vector_container<self_type> (),
+- data_ (data) {}
++ data_ (d) {}
+
+ /// \brief Constructor of a vector with a predefined size and a unique initial value
+ /// \param size of the vector
+ /// \param init value to assign to each element of the vector
+ BOOST_UBLAS_INLINE
+- vector (size_type size, const value_type &init):
++ vector (size_type s, const value_type &init):
+ vector_container<self_type> (),
+- data_ (size, init) {}
++ data_ (s, init) {}
+
+ /// \brief Copy-constructor of a vector
+ /// \param v is the vector to be duplicated
+@@ -175,11 +175,11 @@
+ /// \param size new size of the vector
+ /// \param preserve if true, keep values
+ BOOST_UBLAS_INLINE
+- void resize (size_type size, bool preserve = true) {
++ void resize (size_type s, bool preserve = true) {
+ if (preserve)
+- data ().resize (size, typename A::value_type ());
++ data ().resize (s, typename A::value_type ());
+ else
+- data ().resize (size);
++ data ().resize (s);
+ }
+
+ // ---------------
+@@ -900,9 +900,9 @@
+ vector_container<self_type> (),
+ size_ (0) {}
+ explicit BOOST_UBLAS_INLINE
+- zero_vector (size_type size):
++ zero_vector (size_type s):
+ vector_container<self_type> (),
+- size_ (size) {}
++ size_ (s) {}
+ BOOST_UBLAS_INLINE
+ zero_vector (const zero_vector &v):
+ vector_container<self_type> (),
+@@ -916,8 +916,8 @@
+
+ // Resizing
+ BOOST_UBLAS_INLINE
+- void resize (size_type size, bool /*preserve*/ = true) {
+- size_ = size;
++ void resize (size_type s, bool /*preserve*/ = true) {
++ size_ = s;
+ }
+
+ // Element support
+@@ -1110,9 +1110,9 @@
+ /// \param size is the dimension of the vector
+ /// \param index is the order of the vector
+ BOOST_UBLAS_INLINE
+- explicit unit_vector (size_type size, size_type index = 0):
++ explicit unit_vector (size_type s, size_type i = 0):
+ vector_container<self_type> (),
+- size_ (size), index_ (index) {}
++ size_ (s), index_ (i) {}
+
+ /// \brief Copy-constructor
+ BOOST_UBLAS_INLINE
+@@ -1141,8 +1141,8 @@
+ /// \brief Resize the vector. The values are preserved by default (i.e. the index does not change)
+ /// \param size is the new size of the vector
+ BOOST_UBLAS_INLINE
+- void resize (size_type size, bool /*preserve*/ = true) {
+- size_ = size;
++ void resize (size_type s, bool /*preserve*/ = true) {
++ size_ = s;
+ }
+
+ // Element support
+@@ -1352,9 +1352,9 @@
+ vector_container<self_type> (),
+ size_ (0), value_ () {}
+ BOOST_UBLAS_INLINE
+- explicit scalar_vector (size_type size, const value_type &value = value_type(1)):
++ explicit scalar_vector (size_type s, const value_type &value = value_type(1)):
+ vector_container<self_type> (),
+- size_ (size), value_ (value) {}
++ size_ (s), value_ (value) {}
+ BOOST_UBLAS_INLINE
+ scalar_vector (const scalar_vector &v):
+ vector_container<self_type> (),
+@@ -1368,8 +1368,8 @@
+
+ // Resizing
+ BOOST_UBLAS_INLINE
+- void resize (size_type size, bool /*preserve*/ = true) {
+- size_ = size;
++ void resize (size_type s, bool /*preserve*/ = true) {
++ size_ = s;
+ }
+
+ // Element support
+@@ -1594,8 +1594,8 @@
+ c_vector ():
+ size_ (N) /* , data_ () */ {}
+ explicit BOOST_UBLAS_INLINE
+- c_vector (size_type size):
+- size_ (size) /* , data_ () */ {
++ c_vector (size_type s):
++ size_ (s) /* , data_ () */ {
+ if (size_ > N)
+ bad_size ().raise ();
+ }
+@@ -1631,10 +1631,10 @@
+
+ // Resizing
+ BOOST_UBLAS_INLINE
+- void resize (size_type size, bool preserve = true) {
+- if (size > N)
++ void resize (size_type s, bool preserve = true) {
++ if (s > N)
+ bad_size ().raise ();
+- size_ = size;
++ size_ = s;
+ }
+
+ // Element support
+diff -aruN a/boost/numeric/ublas/vector_of_vector.hpp b/boost/numeric/ublas/vector_of_vector.hpp
+--- a/boost/numeric/ublas/vector_of_vector.hpp 2007-11-25 10:07:19.000000000 -0800
++++ b/boost/numeric/ublas/vector_of_vector.hpp 2012-02-07 15:25:24.639286239 -0800
+@@ -66,9 +66,9 @@
+ storage_invariants ();
+ }
+ BOOST_UBLAS_INLINE
+- generalized_vector_of_vector (size_type size1, size_type size2, size_type non_zeros = 0):
++ generalized_vector_of_vector (size_type s1, size_type s2, size_type non_zeros = 0):
+ matrix_container<self_type> (),
+- size1_ (size1), size2_ (size2), data_ (layout_type::size_M (size1_, size2_) + 1) {
++ size1_ (s1), size2_ (s2), data_ (layout_type::size_M (size1_, size2_) + 1) {
+ const size_type sizeM = layout_type::size_M (size1_, size2_);
+ const size_type sizem = layout_type::size_m (size1_, size2_);
+ for (size_type i = 0; i < sizeM; ++ i) // create size1 vector elements
+@@ -132,10 +132,10 @@
+
+ // Resizing
+ BOOST_UBLAS_INLINE
+- void resize (size_type size1, size_type size2, bool preserve = true) {
++ void resize (size_type s1, size_type s2, bool preserve = true) {
+ const size_type oldM = layout_type::size_M (size1_, size2_);
+- size1_ = size1;
+- size2_ = size2;
++ size1_ = s1;
++ size2_ = s2;
+ const size_type sizeM = layout_type::size_M (size1_, size2_);
+ const size_type sizem = layout_type::size_m (size1_, size2_);
+ data ().resize (sizeM + 1, preserve);
+diff -aruN a/boost/numeric/ublas/vector_proxy.hpp b/boost/numeric/ublas/vector_proxy.hpp
+--- a/boost/numeric/ublas/vector_proxy.hpp 2010-07-04 23:06:24.000000000 -0700
++++ b/boost/numeric/ublas/vector_proxy.hpp 2012-02-07 15:25:24.639286239 -0800
+@@ -59,15 +59,15 @@
+
+ // Construction and destruction
+ BOOST_UBLAS_INLINE
+- vector_range (vector_type &data, const range_type &r):
+- data_ (data), r_ (r.preprocess (data.size ())) {
++ vector_range (vector_type &d, const range_type &r):
++ data_ (d), r_ (r.preprocess (d.size ())) {
+ // Early checking of preconditions here.
+ // BOOST_UBLAS_CHECK (r_.start () <= data_.size () &&
+ // r_.start () + r_.size () <= data_.size (), bad_index ());
+ }
+ BOOST_UBLAS_INLINE
+- vector_range (const vector_closure_type &data, const range_type &r, bool):
+- data_ (data), r_ (r.preprocess (data.size ())) {
++ vector_range (const vector_closure_type &d, const range_type &r, bool):
++ data_ (d), r_ (r.preprocess (d.size ())) {
+ // Early checking of preconditions here.
+ // BOOST_UBLAS_CHECK (r_.start () <= data_.size () &&
+ // r_.start () + r_.size () <= data_.size (), bad_index ());
+@@ -614,15 +614,15 @@
+
+ // Construction and destruction
+ BOOST_UBLAS_INLINE
+- vector_slice (vector_type &data, const slice_type &s):
+- data_ (data), s_ (s.preprocess (data.size ())) {
++ vector_slice (vector_type &d, const slice_type &s):
++ data_ (d), s_ (s.preprocess (d.size ())) {
+ // Early checking of preconditions here.
+ // BOOST_UBLAS_CHECK (s_.start () <= data_.size () &&
+ // s_.start () + s_.stride () * (s_.size () - (s_.size () > 0)) <= data_.size (), bad_index ());
+ }
+ BOOST_UBLAS_INLINE
+- vector_slice (const vector_closure_type &data, const slice_type &s, int):
+- data_ (data), s_ (s.preprocess (data.size ())) {
++ vector_slice (const vector_closure_type &d, const slice_type &s, int):
++ data_ (d), s_ (s.preprocess (d.size ())) {
+ // Early checking of preconditions here.
+ // BOOST_UBLAS_CHECK (s_.start () <= data_.size () &&
+ // s_.start () + s_.stride () * (s_.size () - (s_.size () > 0)) <= data_.size (), bad_index ());
+@@ -1159,14 +1159,14 @@
+
+ // Construction and destruction
+ BOOST_UBLAS_INLINE
+- vector_indirect (vector_type &data, size_type size):
+- data_ (data), ia_ (size) {}
++ vector_indirect (vector_type &d, size_type s):
++ data_ (d), ia_ (s) {}
+ BOOST_UBLAS_INLINE
+- vector_indirect (vector_type &data, const indirect_array_type &ia):
+- data_ (data), ia_ (ia.preprocess (data.size ())) {}
++ vector_indirect (vector_type &d, const indirect_array_type &ia):
++ data_ (d), ia_ (ia.preprocess (d.size ())) {}
+ BOOST_UBLAS_INLINE
+- vector_indirect (const vector_closure_type &data, const indirect_array_type &ia, int):
+- data_ (data), ia_ (ia.preprocess (data.size ())) {}
++ vector_indirect (const vector_closure_type &d, const indirect_array_type &ia, int):
++ data_ (d), ia_ (ia.preprocess (d.size ())) {}
+
+ // Accessors
+ BOOST_UBLAS_INLINE
+diff -aruN a/boost/numeric/ublas/vector_sparse.hpp b/boost/numeric/ublas/vector_sparse.hpp
+--- a/boost/numeric/ublas/vector_sparse.hpp 2010-07-04 23:06:24.000000000 -0700
++++ b/boost/numeric/ublas/vector_sparse.hpp 2012-02-07 15:25:24.639286239 -0800
+@@ -309,9 +309,9 @@
+ vector_container<self_type> (),
+ size_ (0), data_ () {}
+ BOOST_UBLAS_INLINE
+- mapped_vector (size_type size, size_type non_zeros = 0):
++ mapped_vector (size_type s, size_type non_zeros = 0):
+ vector_container<self_type> (),
+- size_ (size), data_ () {
++ size_ (s), data_ () {
+ detail::map_reserve (data(), restrict_capacity (non_zeros));
+ }
+ BOOST_UBLAS_INLINE
+@@ -360,8 +360,8 @@
+ }
+ public:
+ BOOST_UBLAS_INLINE
+- void resize (size_type size, bool preserve = true) {
+- size_ = size;
++ void resize (size_type s, bool preserve = true) {
++ size_ = s;
+ if (preserve) {
+ data ().erase (data ().lower_bound(size_), data ().end());
+ }
+@@ -832,9 +832,9 @@
+ storage_invariants ();
+ }
+ explicit BOOST_UBLAS_INLINE
+- compressed_vector (size_type size, size_type non_zeros = 0):
++ compressed_vector (size_type s, size_type non_zeros = 0):
+ vector_container<self_type> (),
+- size_ (size), capacity_ (restrict_capacity (non_zeros)), filled_ (0),
++ size_ (s), capacity_ (restrict_capacity (non_zeros)), filled_ (0),
+ index_data_ (capacity_), value_data_ (capacity_) {
+ storage_invariants ();
+ }
+@@ -887,8 +887,8 @@
+ return value_data_;
+ }
+ BOOST_UBLAS_INLINE
+- void set_filled (const typename index_array_type::size_type & filled) {
+- filled_ = filled;
++ void set_filled (const typename index_array_type::size_type & f) {
++ filled_ = f;
+ storage_invariants ();
+ }
+ BOOST_UBLAS_INLINE
+@@ -910,14 +910,14 @@
+ }
+ public:
+ BOOST_UBLAS_INLINE
+- void resize (size_type size, bool preserve = true) {
+- size_ = size;
++ void resize (size_type s, bool preserve = true) {
++ size_ = s;
+ capacity_ = restrict_capacity (capacity_);
+ if (preserve) {
+ index_data_. resize (capacity_, size_type ());
+ value_data_. resize (capacity_, value_type ());
+ filled_ = (std::min) (capacity_, filled_);
+- while ((filled_ > 0) && (zero_based(index_data_[filled_ - 1]) >= size)) {
++ while ((filled_ > 0) && (zero_based(index_data_[filled_ - 1]) >= s)) {
+ --filled_;
+ }
+ }
+@@ -1473,9 +1473,9 @@
+ storage_invariants ();
+ }
+ explicit BOOST_UBLAS_INLINE
+- coordinate_vector (size_type size, size_type non_zeros = 0):
++ coordinate_vector (size_type s, size_type non_zeros = 0):
+ vector_container<self_type> (),
+- size_ (size), capacity_ (restrict_capacity (non_zeros)),
++ size_ (s), capacity_ (restrict_capacity (non_zeros)),
+ filled_ (0), sorted_filled_ (filled_), sorted_ (true),
+ index_data_ (capacity_), value_data_ (capacity_) {
+ storage_invariants ();
+@@ -1531,9 +1531,9 @@
+ return value_data_;
+ }
+ BOOST_UBLAS_INLINE
+- void set_filled (const typename index_array_type::size_type &sorted, const typename index_array_type::size_type &filled) {
++ void set_filled (const typename index_array_type::size_type &sorted, const typename index_array_type::size_type &f) {
+ sorted_filled_ = sorted;
+- filled_ = filled;
++ filled_ = f;
+ storage_invariants ();
+ }
+ BOOST_UBLAS_INLINE
+@@ -1556,16 +1556,16 @@
+ }
+ public:
+ BOOST_UBLAS_INLINE
+- void resize (size_type size, bool preserve = true) {
++ void resize (size_type s, bool preserve = true) {
+ if (preserve)
+ sort (); // remove duplicate elements.
+- size_ = size;
++ size_ = s;
+ capacity_ = restrict_capacity (capacity_);
+ if (preserve) {
+ index_data_. resize (capacity_, size_type ());
+ value_data_. resize (capacity_, value_type ());
+ filled_ = (std::min) (capacity_, filled_);
+- while ((filled_ > 0) && (zero_based(index_data_[filled_ - 1]) >= size)) {
++ while ((filled_ > 0) && (zero_based(index_data_[filled_ - 1]) >= s)) {
+ --filled_;
+ }
+ }
+@@ -1813,19 +1813,19 @@
+ std::inplace_merge (ipa.begin (), iunsorted, ipa.end ());
+
+ // sum duplicates with += and remove
+- size_type filled = 0;
++ size_type f = 0;
+ for (size_type i = 1; i < filled_; ++ i) {
+- if (index_data_ [filled] != index_data_ [i]) {
+- ++ filled;
+- if (filled != i) {
+- index_data_ [filled] = index_data_ [i];
+- value_data_ [filled] = value_data_ [i];
++ if (index_data_ [f] != index_data_ [i]) {
++ ++ f;
++ if (f != i) {
++ index_data_ [f] = index_data_ [i];
++ value_data_ [f] = value_data_ [i];
+ }
+ } else {
+- value_data_ [filled] += value_data_ [i];
++ value_data_ [f] += value_data_ [i];
+ }
+ }
+- filled_ = filled + 1;
++ filled_ = f + 1;
+ sorted_filled_ = filled_;
+ sorted_ = true;
+ storage_invariants ();
diff --git a/boost.patches/boost-53.description b/boost.patches/boost-53.description
new file mode 100644
index 0000000..a8c9afd
--- /dev/null
+++ b/boost.patches/boost-53.description
@@ -0,0 +1,3 @@
+Fix compiler warnings triggered by -Wunused-local-typedefs. Some of this was taken
+from here https://svn.boost.org/trac/boost/ticket/8546 and some was fixed by looking
+at the build log.
diff --git a/boost.patches/boost-53.patch b/boost.patches/boost-53.patch
new file mode 100644
index 0000000..552e5a2
--- /dev/null
+++ b/boost.patches/boost-53.patch
@@ -0,0 +1,158 @@
+diff -Naur a/boost/algorithm/string/detail/finder.hpp b/boost/algorithm/string/detail/finder.hpp
+--- a/boost/algorithm/string/detail/finder.hpp 2009-09-13 12:10:55.000000000 -0700
++++ b/boost/algorithm/string/detail/finder.hpp 2015-04-15 09:02:18.683944124 -0700
+@@ -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 ) )
+diff -Naur a/boost/bind/arg.hpp b/boost/bind/arg.hpp
+--- a/boost/bind/arg.hpp 2007-11-25 10:07:19.000000000 -0800
++++ b/boost/bind/arg.hpp 2015-04-15 09:02:18.683944124 -0700
+@@ -34,7 +34,6 @@
+ template< class T > arg( T const & /* t */ )
+ {
+ // static assert I == is_placeholder<T>::value
+- typedef char T_must_be_placeholder[ I == is_placeholder<T>::value? 1: -1 ];
+ }
+ };
+
+diff -Naur a/boost/concept/detail/general.hpp b/boost/concept/detail/general.hpp
+--- a/boost/concept/detail/general.hpp 2010-06-08 12:31:13.000000000 -0700
++++ b/boost/concept/detail/general.hpp 2015-04-15 09:02:18.683944124 -0700
+@@ -12,6 +12,15 @@
+ # include <boost/mpl/if.hpp>
+ # endif
+
++
++// If the compiler warns about unused typedefs then enable this:
++//
++#if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)))
++# define BOOST_CONCEPT_ASSERT_UNUSED_ATTRIBUTE __attribute__((unused))
++#else
++# define BOOST_CONCEPT_ASSERT_UNUSED_ATTRIBUTE
++#endif
++
+ // This implementation works on Comeau and GCC, all the way back to
+ // 2.95
+ namespace boost { namespace concepts {
+@@ -68,7 +77,7 @@
+ # 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__) BOOST_CONCEPT_ASSERT_UNUSED_ATTRIBUTE
+
+ }}
+
+diff -Naur a/boost/ptr_container/detail/move.hpp b/boost/ptr_container/detail/move.hpp
+--- a/boost/ptr_container/detail/move.hpp 2008-03-22 14:45:55.000000000 -0700
++++ b/boost/ptr_container/detail/move.hpp 2015-04-15 09:02:18.699944284 -0700
+@@ -20,7 +20,7 @@
+ template<typename Ptr>
+ class move_source {
+ public:
+- move_source(Ptr& ptr) : ptr_(ptr) {}
++ move_source(Ptr& ptrArg) : ptr_(ptrArg) {}
+ Ptr& ptr() const { return ptr_; }
+ private:
+ Ptr& ptr_;
+diff -Naur a/boost/ptr_container/detail/reversible_ptr_container.hpp b/boost/ptr_container/detail/reversible_ptr_container.hpp
+--- a/boost/ptr_container/detail/reversible_ptr_container.hpp 2009-04-05 12:55:59.000000000 -0700
++++ b/boost/ptr_container/detail/reversible_ptr_container.hpp 2015-04-15 09:02:18.699944284 -0700
+@@ -278,9 +278,9 @@
+
+ private:
+ template< class ForwardIterator >
+- ForwardIterator advance( ForwardIterator begin, size_type n )
++ ForwardIterator advance( ForwardIterator beginArg, size_type n )
+ {
+- ForwardIterator iter = begin;
++ ForwardIterator iter = beginArg;
+ std::advance( iter, n );
+ return iter;
+ }
+diff -Naur a/boost/ptr_container/detail/static_move_ptr.hpp b/boost/ptr_container/detail/static_move_ptr.hpp
+--- a/boost/ptr_container/detail/static_move_ptr.hpp 2008-03-22 14:45:55.000000000 -0700
++++ b/boost/ptr_container/detail/static_move_ptr.hpp 2015-04-15 09:02:18.699944284 -0700
+@@ -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>& ptrArg)
+ {
+ typedef move_ptrs::is_smart_ptr_convertible<TT, T> convertible;
+ BOOST_STATIC_ASSERT(convertible::value);
+diff -Naur a/boost/ptr_container/exception.hpp b/boost/ptr_container/exception.hpp
+--- a/boost/ptr_container/exception.hpp 2008-03-22 14:45:55.000000000 -0700
++++ b/boost/ptr_container/exception.hpp 2015-04-15 09:02:18.699944284 -0700
+@@ -24,7 +24,7 @@
+ {
+ const char* what_;
+ public:
+- bad_ptr_container_operation( const char* what ) : what_( what )
++ bad_ptr_container_operation( const char* whatArg ) : what_( whatArg )
+ { }
+
+ 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* whatArg ) : bad_ptr_container_operation( whatArg )
+ { }
+ };
+
+diff -Naur a/boost/system/error_code.hpp b/boost/system/error_code.hpp
+--- a/boost/system/error_code.hpp 2010-07-06 03:47:30.000000000 -0700
++++ b/boost/system/error_code.hpp 2015-04-15 09:02:18.695944245 -0700
+@@ -211,9 +211,9 @@
+ inline const error_category & get_system_category() { return system_category(); }
+ inline const error_category & get_generic_category() { return generic_category(); }
+ inline const error_category & get_posix_category() { return generic_category(); }
+- static const error_category & posix_category = generic_category();
+- static const error_category & errno_ecat = generic_category();
+- static const error_category & native_ecat = system_category();
++ //static const error_category & posix_category = generic_category();
++ //static const error_category & errno_ecat = generic_category();
++ //static const error_category & native_ecat = system_category();
+ # endif
+
+ // class error_condition -----------------------------------------------//
diff --git a/boost.patches/boost-54.description b/boost.patches/boost-54.description
new file mode 100644
index 0000000..679dc8c
--- /dev/null
+++ b/boost.patches/boost-54.description
@@ -0,0 +1 @@
+Fix compiler shadowed declaration warnings in uuid_io
diff --git a/boost.patches/boost-54.patch b/boost.patches/boost-54.patch
new file mode 100644
index 0000000..12718e7
--- /dev/null
+++ b/boost.patches/boost-54.patch
@@ -0,0 +1,12 @@
+diff -aruN boost_1_45_0/boost/uuid/uuid_io.hpp boost_1_45_0.N/boost/uuid/uuid_io.hpp
+--- boost_1_45_0/boost/uuid/uuid_io.hpp 2010-07-12 17:37:17.000000000 -0700
++++ boost_1_45_0.N/boost/uuid/uuid_io.hpp 2015-04-28 17:59:01.600615207 -0700
+@@ -59,7 +59,7 @@
+ }
+
+ if (flags & std::ios_base::left) {
+- for (std::streamsize i=uuid_width; i<width; i++) {
++ for (std::streamsize j=uuid_width; j<width; j++) {
+ os << fill;
+ }
+ }
diff --git a/boost.tar.bz2 b/boost.tar.bz2
new file mode 100644
index 0000000..e824653
--- /dev/null
+++ b/boost.tar.bz2
Binary files differ
diff --git a/boost.url b/boost.url
new file mode 100644
index 0000000..75502b2
--- /dev/null
+++ b/boost.url
@@ -0,0 +1 @@
+http://download.sourceforge.net/boost/boost_1_45_0.tar.bz2
diff --git a/boost.version b/boost.version
new file mode 100644
index 0000000..37918b8
--- /dev/null
+++ b/boost.version
@@ -0,0 +1 @@
+1_45_0
