Update bundled boost to 1.53.0
Modify our patches as necessary to match the updated boost sources. Drop
patches for which corresponding (or even identical) changes already are
present. Add a new boostsystem static library and use it in two places.
Change-Id: Ib59558feb56dab87a69c91b38caca8e7a9e9a22e
diff --git a/RepositoryExternal.mk b/RepositoryExternal.mk
index 973ebc5..0be2054 100644
--- a/RepositoryExternal.mk
+++ b/RepositoryExternal.mk
@@ -556,6 +556,24 @@ $(call gb_LinkTarget_add_libs,$(1),\
endef
define gb_LinkTarget__use_boostsystem
$(call gb_LinkTarget_set_include,$(1),\
$$(INCLUDE) \
$(BOOST_CPPFLAGS) \
)
$(call gb_LinkTarget_add_ldflags,$(1),\
$(BOOST_LDFLAGS) \
)
$(call gb_LinkTarget_add_libs,$(1),\
$(BOOST_SYSTEM_LIB) \
)
endef
gb_ExternalProject__use_boostsystem :=
define gb_LinkTarget__use_boost_headers
$(call gb_LinkTarget_set_include,$(1),\
$$(INCLUDE) \
@@ -570,6 +588,7 @@ else # !SYSTEM_BOOST
$(eval $(call gb_Helper_register_static_libraries,PLAINLIBS, \
boostdatetime \
boostsystem \
))
ifeq ($(OS),WNT)
@@ -600,6 +619,21 @@ $(call gb_LinkTarget_use_static_libraries,$(1),\
endef
define gb_LinkTarget__use_boostsystem
$(call gb_LinkTarget_add_defs,$(1),\
-DBOOST_ALL_NO_LIB \
)
$(call gb_LinkTarget_use_static_libraries,$(1),\
boostsystem \
)
endef
define gb_ExternalProject__use_boostsystem
$(call gb_LinkTarget_use_static_libraries,$(1),boostsystem)
endef
define gb_LinkTarget__use_boost_headers
$(call gb_LinkTarget_use_unpacked,$(1),boost)
$(call gb_LinkTarget_set_include,$(1),\
diff --git a/boost/Module_boost.mk b/boost/Module_boost.mk
index b9da8a7..9274e4a 100644
--- a/boost/Module_boost.mk
+++ b/boost/Module_boost.mk
@@ -13,6 +13,7 @@ ifeq ($(SYSTEM_BOOST),NO)
$(eval $(call gb_Module_add_targets,boost,\
StaticLibrary_boostdatetime \
StaticLibrary_boostsystem \
UnpackedTarball_boost \
))
diff --git a/boost/StaticLibrary_boostsystem.mk b/boost/StaticLibrary_boostsystem.mk
new file mode 100644
index 0000000..053321b
--- /dev/null
+++ b/boost/StaticLibrary_boostsystem.mk
@@ -0,0 +1,27 @@
# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*-
#
# This file is part of the LibreOffice project.
#
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
#
$(eval $(call gb_StaticLibrary_StaticLibrary,boostsystem))
$(eval $(call gb_StaticLibrary_set_warnings_not_errors,boostsystem))
# disable "auto link" "feature" on MSVC
$(eval $(call gb_StaticLibrary_add_defs,boostsystem,\
-DBOOST_ALL_NO_LIB \
))
$(eval $(call gb_StaticLibrary_use_external,boostsystem,boost_headers))
$(eval $(call gb_StaticLibrary_set_generated_cxx_suffix,boostsystem,cpp))
$(eval $(call gb_StaticLibrary_add_generated_exception_objects,boostsystem,\
UnpackedTarball/boost/libs/system/src/error_code \
))
# vim: set noet sw=4 ts=4:
diff --git a/boost/UnpackedTarball_boost.mk b/boost/UnpackedTarball_boost.mk
index ba497d0..274781a 100644
--- a/boost/UnpackedTarball_boost.mk
+++ b/boost/UnpackedTarball_boost.mk
@@ -8,64 +8,40 @@
#
boost_patches :=
#https://svn.boost.org/trac/boost/ticket/3093
boost_patches += boost.3093.warnings.patch
#https://svn.boost.org/trac/boost/ticket/3780
boost_patches += boost.3780.aliasing.patch
#https://svn.boost.org/trac/boost/ticket/4127
boost_patches += boost.4127.warnings.patch
#https://svn.boost.org/trac/boost/ticket/4713
boost_patches += boost.4713.warnings.patch
#https://svn.boost.org/trac/boost/ticket/5119
boost_patches += boost.5119.unordered_map-cp-ctor.patch
#http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47679
boost_patches += boost.gcc47679.patch
#https://svn.boost.org/trac/boost/ticket/6369
boost_patches += boost.6369.warnings.patch
#https://svn.boost.org/trac/boost/ticket/6397
boost_patches += boost.6397.warnings.patch
#backport from boost 1.48.0 fix for "opcode not supported on this processor"
boost_patches += boost.mipsbackport.patch
#https://svn.boost.org/trac/boost/ticket/7551
boost_patches += boost.7551.unusedvars.patch
boost_patches += boost.4100.warnings.patch
boost_patches += boost.4510.warnings.patch
#https://svn.boost.org/trac/boost/ticket/6139
boost_patches += boost.6139.clang.patch
#https://svn.boost.org/trac/boost/ticket/6940
boost_patches += boost.6940.glibc.patch
#https://svn.boost.org/trac/boost/ticket/7774
boost_patches += boost.7774.warnings.patch.1
#https://svn.boost.org/trac/boost/ticket/6142
boost_patches += boost.6142.warnings.patch.1
boost_patches += boost.wundef.patch.1
boost_patches += boost.windows.patch
boost_patches += boost.vc2012.patch
boost_patches += boost.libcdr.warnings.patch.1
# Help static analysis tools (see SAL_UNUSED_PARAMETER in sal/types.h):
ifeq (GCC,$(COM))
boost_patches += boost_1_44_0-unused-parameters.patch
boost_patches += boost_1_44_0-logical-op-parentheses.patch
endif
# Backporting fixes for the GCC 4.7 -std=c++11 mode from Boost 1.48.0:
boost_patches += boost_1_44_0-gcc4.7.patch
# Clang warnings:
boost_patches += boost_1_44_0-clang-warnings.patch
# Backport http://svn.boost.org/svn/boost/trunk r76133 "Fix threading detection
# in GCC-4.7 experimental":
boost_patches += boost_1_44_0-gthreads.patch
boost_patches += boost_1_44_0-gcc4.8.patch
# https://svn.boost.org/trac/boost/changeset/78496
boost_patches += boost.4874.patch
boost_patches += boost.ptree.patch
boost_patches += boost.loplugin.patch
boost_patches += boost.wundef.patch
boost_patches += boost.wshadow.patch
$(eval $(call gb_UnpackedTarball_UnpackedTarball,boost))
diff --git a/boost/boost.3093.warnings.patch b/boost/boost.3093.warnings.patch
deleted file mode 100755
index 1b2bf6d..0000000
--- a/boost/boost.3093.warnings.patch
+++ /dev/null
@@ -1,11 +0,0 @@
--- misc/boost_1_44_0/boost/logic/tribool.hpp Sun Nov 25 18:07:19 2007
+++ misc/build/boost_1_44_0/boost/logic/tribool.hpp Fri May 17 12:03:35 2013
@@ -93,7 +93,7 @@
*
* \throws nothrow
*/
- tribool(bool value) : value(value? true_value : false_value) {}
+ tribool(bool initial_value) : value(initial_value? true_value : false_value) {}
/**
* Construct a new 3-state boolean value with an indeterminate value.
diff --git a/boost/boost.3780.aliasing.patch b/boost/boost.3780.aliasing.patch
index 5ca5ed0..f279e33 100644
--- a/boost/boost.3780.aliasing.patch
+++ b/boost/boost.3780.aliasing.patch
@@ -1,43 +1,23 @@
--- misc/boost_1_44_0/boost/function/function_base.hpp
+++ misc/build/boost_1_44_0/boost/function/function_base.hpp
@@ -2,6 +2,7 @@
// Copyright Douglas Gregor 2001-2006
// Copyright Emil Dotchevski 2007
+// Copyright Dean Michael Berris 2009
// Use, modification and distribution is subject to the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
@@ -44,6 +45,13 @@
# pragma warning( disable : 4127 ) // "conditional expression is constant"
#endif
+#if defined(__GNUC__)
+// Because GCC complains of strict aliasing problems, we make it
+// treat the header as a system header, becoming more forgiving with
+// treating implementation details that may be potentially harmful.
+# pragma GCC system_header
+#endif
+
// Define BOOST_FUNCTION_STD_NS to the namespace that contains type_info.
#ifdef BOOST_NO_STD_TYPEINFO
// Embedded VC++ does not have type_info in namespace std
@@ -314,15 +322,15 @@
{
if (op == clone_functor_tag || op == move_functor_tag) {
const functor_type* in_functor =
- reinterpret_cast<const functor_type*>(&in_buffer.data);
+ static_cast<const functor_type*>(static_cast<void*>(&in_buffer.data));
new ((void*)&out_buffer.data) functor_type(*in_functor);
new (reinterpret_cast<void*>(&out_buffer.data)) functor_type(*in_functor);
if (op == move_functor_tag) {
- reinterpret_cast<functor_type*>(&in_buffer.data)->~Functor();
+ static_cast<functor_type*>(static_cast<void*>(&in_buffer.data))->~Functor();
- functor_type* f = reinterpret_cast<functor_type*>(&in_buffer.data);
+ functor_type* f = static_cast<functor_type*>(static_cast<void*>(&in_buffer.data));
(void)f; // suppress warning about the value of f not being used (MSVC)
f->~Functor();
}
} else if (op == destroy_functor_tag) {
// Some compilers (Borland, vc6, ...) are unhappy with ~functor_type.
- reinterpret_cast<functor_type*>(&out_buffer.data)->~Functor();
+ static_cast<functor_type*>(static_cast<void*>(&out_buffer.data))->~Functor();
- functor_type* f = reinterpret_cast<functor_type*>(&out_buffer.data);
+ functor_type* f = static_cast<functor_type*>(static_cast<void*>(&out_buffer.data));
(void)f; // suppress warning about the value of f not being used (MSVC)
f->~Functor();
} else if (op == check_functor_type_tag) {
const detail::sp_typeinfo& check_type
= *out_buffer.type.type;
diff --git a/boost/boost.4127.warnings.patch b/boost/boost.4127.warnings.patch
deleted file mode 100644
index fe3c2bf..0000000
--- a/boost/boost.4127.warnings.patch
+++ /dev/null
@@ -1,21 +0,0 @@
--- misc/boost_1_44_0/boost/smart_ptr/make_shared.hpp
+++ misc/build/boost_1_44_0/boost/smart_ptr/make_shared.hpp
@@ -49,7 +49,18 @@
{
if( initialized_ )
{
+#if defined( __GNUC__ )
+
+ // fixes incorrect aliasing warning
+ T * p = reinterpret_cast< T* >( storage_.data_ );
+ p->~T();
+
+#else
+
reinterpret_cast< T* >( storage_.data_ )->~T();
+
+#endif
+
initialized_ = false;
}
}
diff --git a/boost/boost.4713.warnings.patch b/boost/boost.4713.warnings.patch
index d1224f6..7a5726e 100644
--- a/boost/boost.4713.warnings.patch
+++ b/boost/boost.4713.warnings.patch
@@ -72,20 +72,6 @@
BOOST_ASSERT( first <= last && "out of range unique()/erase_if()" );
BOOST_ASSERT( this->begin() <= first && "out of range unique()/erase_if()" );
BOOST_ASSERT( last <= this->end() && "out of range unique()/erase_if)(" );
--- misc/boost_1_44_0/boost/spirit/home/classic/error_handling/exceptions.hpp 2010-04-07 02:41:42.000000000 +0200
+++ misc/build/boost_1_44_0/boost/spirit/home/classic/error_handling/exceptions.hpp 2011-02-04 16:39:19.000000000 +0100
@@ -222,9 +222,9 @@
error_status(
result_t result_ = fail,
- std::ptrdiff_t length = -1,
+ std::ptrdiff_t length_ = -1,
T const& value_ = T())
- : result(result_), length(length), value(value_) {}
+ : result(result_), length(length_), value(value_) {}
result_t result;
std::ptrdiff_t length;
--- misc/boost_1_44_0/boost/spirit/home/classic/symbols/symbols.hpp 2008-06-22 17:05:38.000000000 +0200
+++ misc/build/boost_1_44_0/boost/spirit/home/classic/symbols/symbols.hpp 2011-02-04 16:39:19.000000000 +0100
@@ -102,13 +102,13 @@
@@ -106,563 +92,6 @@
first,
scan.first);
else
--- misc/boost_1_44_0/boost/spirit/home/classic/utility/functor_parser.hpp 2008-06-22 17:05:38.000000000 +0200
+++ misc/build/boost_1_44_0/boost/spirit/home/classic/utility/functor_parser.hpp 2011-02-04 16:39:19.000000000 +0100
@@ -54,13 +54,13 @@
typedef typename ScannerT::iterator_t iterator_t;
iterator_t const s(scan.first);
- functor_result_t result;
- std::ptrdiff_t len = functor(scan, result);
+ functor_result_t functor_result;
+ std::ptrdiff_t len = functor(scan, functor_result);
if (len < 0)
return scan.no_match();
else
- return scan.create_match(std::size_t(len), result, s, scan.first);
+ return scan.create_match(std::size_t(len), functor_result, s, scan.first);
}
};
--- misc/boost_1_44_0/boost/spirit/home/classic/utility/loops.hpp 2008-06-22 17:05:38.000000000 +0200
+++ misc/build/boost_1_44_0/boost/spirit/home/classic/utility/loops.hpp 2011-02-04 16:39:19.000000000 +0100
@@ -47,8 +47,8 @@
typedef fixed_loop<ParserT, ExactT> self_t;
typedef unary<ParserT, parser<self_t> > base_t;
- fixed_loop (ParserT const & subject, ExactT const & exact)
- : base_t(subject), m_exact(exact) {}
+ fixed_loop (ParserT const & subject_, ExactT const & exact)
+ : base_t(subject_), m_exact(exact) {}
template <typename ScannerT>
typename parser_result <self_t, ScannerT>::type
@@ -112,8 +112,8 @@
typedef finite_loop <ParserT, MinT, MaxT> self_t;
typedef unary<ParserT, parser<self_t> > base_t;
- finite_loop (ParserT const & subject, MinT const & min, MaxT const & max)
- : base_t(subject), m_min(min), m_max(max) {}
+ finite_loop (ParserT const & subject_, MinT const & min, MaxT const & max)
+ : base_t(subject_), m_min(min), m_max(max) {}
template <typename ScannerT>
typename parser_result <self_t, ScannerT>::type
@@ -196,11 +196,11 @@
typedef unary<ParserT, parser<self_t> > base_t;
infinite_loop (
- ParserT const& subject,
+ ParserT const& subject_,
MinT const& min,
more_t const&
)
- : base_t(subject), m_min(min) {}
+ : base_t(subject_), m_min(min) {}
template <typename ScannerT>
typename parser_result <self_t, ScannerT>::type
@@ -253,9 +253,9 @@
template <typename ParserT>
fixed_loop <ParserT, ExactT>
- operator[](parser <ParserT> const & subject) const
+ operator[](parser <ParserT> const & subject_) const
{
- return fixed_loop <ParserT, ExactT> (subject.derived (), m_exact);
+ return fixed_loop <ParserT, ExactT> (subject_.derived (), m_exact);
}
ExactT m_exact;
@@ -283,11 +283,11 @@
template <typename ParserT>
typename impl::loop_traits<ParserT, MinT, MaxT>::type
- operator[](parser <ParserT> const & subject) const
+ operator[](parser <ParserT> const & subject_) const
{
typedef typename impl::loop_traits<ParserT, MinT, MaxT>::type ret_t;
return ret_t(
- subject.derived(),
+ subject_.derived(),
m_min,
m_max);
}
--- misc/boost_1_44_0/boost/unordered/detail/table.hpp 2011-02-04 16:55:26.000000000 +0100
+++ misc/build/boost_1_44_0/boost/unordered/detail/table.hpp 2011-02-05 03:34:26.000000000 +0100
@@ -33,10 +33,10 @@
template <class T>
template <class Key, class Pred>
inline BOOST_DEDUCED_TYPENAME T::node_ptr
- hash_table<T>::find_iterator(bucket_ptr bucket, Key const& k,
+ hash_table<T>::find_iterator(bucket_ptr bucket_, Key const& k,
Pred const& eq) const
{
- node_ptr it = bucket->next_;
+ node_ptr it = bucket_->next_;
while (BOOST_UNORDERED_BORLAND_BOOL(it) &&
!eq(k, get_key(node::get_value(it))))
{
@@ -50,9 +50,9 @@
template <class T>
inline BOOST_DEDUCED_TYPENAME T::node_ptr
hash_table<T>::find_iterator(
- bucket_ptr bucket, key_type const& k) const
+ bucket_ptr bucket_, key_type const& k) const
{
- node_ptr it = bucket->next_;
+ node_ptr it = bucket_->next_;
while (BOOST_UNORDERED_BORLAND_BOOL(it) &&
!equal(k, node::get_value(it)))
{
@@ -75,9 +75,9 @@
template <class T>
inline BOOST_DEDUCED_TYPENAME T::node_ptr*
hash_table<T>::find_for_erase(
- bucket_ptr bucket, key_type const& k) const
+ bucket_ptr bucket_, key_type const& k) const
{
- node_ptr* it = &bucket->next_;
+ node_ptr* it = &bucket_->next_;
while(BOOST_UNORDERED_BORLAND_BOOL(*it) &&
!equal(k, node::get_value(*it)))
{
@@ -475,7 +475,7 @@
{
hasher const& hf = this->hash_function();
std::size_t size = this->size_;
- bucket_ptr end = this->get_bucket(this->bucket_count_);
+ bucket_ptr end_ = this->get_bucket(this->bucket_count_);
buckets dst(this->node_alloc(), num_buckets);
dst.create_buckets();
@@ -484,10 +484,10 @@
src.swap(*this);
this->size_ = 0;
- for(bucket_ptr bucket = this->cached_begin_bucket_;
- bucket != end; ++bucket)
+ for(bucket_ptr bucket_ = this->cached_begin_bucket_;
+ bucket_ != end_; ++bucket_)
{
- node_ptr group = bucket->next_;
+ node_ptr group = bucket_->next_;
while(group) {
// Move the first group of equivalent nodes in bucket to dst.
@@ -496,10 +496,10 @@
hf(get_key_from_ptr(group)));
node_ptr& next_group = node::next_group(group);
- bucket->next_ = next_group;
+ bucket_->next_ = next_group;
next_group = dst_bucket->next_;
dst_bucket->next_ = group;
- group = bucket->next_;
+ group = bucket_->next_;
}
}
@@ -525,13 +525,13 @@
BOOST_ASSERT(this->buckets_ && !dst.buckets_);
hasher const& hf = this->hash_function();
- bucket_ptr end = this->get_bucket(this->bucket_count_);
+ bucket_ptr end_ = this->get_bucket(this->bucket_count_);
node_constructor a(dst);
dst.create_buckets();
// no throw:
- for(bucket_ptr i = this->cached_begin_bucket_; i != end; ++i) {
+ for(bucket_ptr i = this->cached_begin_bucket_; i != end_; ++i) {
// no throw:
for(node_ptr it = i->next_; it;) {
// hash function can throw.
@@ -579,11 +579,11 @@
{
if(!this->size_) return this->end();
- bucket_ptr bucket = this->get_bucket(this->bucket_index(k));
- node_ptr it = find_iterator(bucket, k);
+ bucket_ptr bucket_ = this->get_bucket(this->bucket_index(k));
+ node_ptr it = find_iterator(bucket_, k);
if (BOOST_UNORDERED_BORLAND_BOOL(it))
- return iterator_base(bucket, it);
+ return iterator_base(bucket_, it);
else
return this->end();
}
@@ -595,11 +595,11 @@
{
if(!this->size_) return this->end();
- bucket_ptr bucket = this->get_bucket(h(k) % this->bucket_count_);
- node_ptr it = find_iterator(bucket, k, eq);
+ bucket_ptr bucket_ = this->get_bucket(h(k) % this->bucket_count_);
+ node_ptr it = find_iterator(bucket_, k, eq);
if (BOOST_UNORDERED_BORLAND_BOOL(it))
- return iterator_base(bucket, it);
+ return iterator_base(bucket_, it);
else
return this->end();
}
@@ -611,8 +611,8 @@
if(!this->size_)
boost::throw_exception(std::out_of_range("Unable to find key in unordered_map."));
- bucket_ptr bucket = this->get_bucket(this->bucket_index(k));
- node_ptr it = find_iterator(bucket, k);
+ bucket_ptr bucket_ = this->get_bucket(this->bucket_index(k));
+ node_ptr it = find_iterator(bucket_, k);
if (!it)
boost::throw_exception(std::out_of_range("Unable to find key in unordered_map."));
@@ -630,10 +630,10 @@
if(!this->size_)
return iterator_pair(this->end(), this->end());
- bucket_ptr bucket = this->get_bucket(this->bucket_index(k));
- node_ptr it = find_iterator(bucket, k);
+ bucket_ptr bucket_ = this->get_bucket(this->bucket_index(k));
+ node_ptr it = find_iterator(bucket_, k);
if (BOOST_UNORDERED_BORLAND_BOOL(it)) {
- iterator_base first(iterator_base(bucket, it));
+ iterator_base first(iterator_base(bucket_, it));
iterator_base second(first);
second.increment_bucket(node::next_group(second.node_));
return iterator_pair(first, second);
@@ -651,26 +651,26 @@
{
if(!this->size_) return;
- bucket_ptr end = this->get_bucket(this->bucket_count_);
- for(bucket_ptr begin = this->buckets_; begin != end; ++begin) {
- this->clear_bucket(begin);
+ bucket_ptr end_ = this->get_bucket(this->bucket_count_);
+ for(bucket_ptr begin_ = this->buckets_; begin_ != end_; ++begin_) {
+ this->clear_bucket(begin_);
}
this->size_ = 0;
- this->cached_begin_bucket_ = end;
+ this->cached_begin_bucket_ = end_;
}
template <class T>
inline std::size_t hash_table<T>::erase_group(
- node_ptr* it, bucket_ptr bucket)
+ node_ptr* it, bucket_ptr bucket_)
{
node_ptr pos = *it;
- node_ptr end = node::next_group(pos);
- *it = end;
- std::size_t count = this->delete_nodes(pos, end);
- this->size_ -= count;
- this->recompute_begin_bucket(bucket);
- return count;
+ node_ptr end_ = node::next_group(pos);
+ *it = end_;
+ std::size_t count_ = this->delete_nodes(pos, end_);
+ this->size_ -= count_;
+ this->recompute_begin_bucket(bucket_);
+ return count_;
}
template <class T>
@@ -679,11 +679,11 @@
if(!this->size_) return 0;
// No side effects in initial section
- bucket_ptr bucket = this->get_bucket(this->bucket_index(k));
- node_ptr* it = this->find_for_erase(bucket, k);
+ bucket_ptr bucket_ = this->get_bucket(this->bucket_index(k));
+ node_ptr* it = this->find_for_erase(bucket_, k);
// No throw.
- return *it ? this->erase_group(it, bucket) : 0;
+ return *it ? this->erase_group(it, bucket_) : 0;
}
template <class T>
@@ -766,12 +766,12 @@
std::size_t hash_value = this->hash_function()(k);
if(this->buckets_) this->reserve_for_insert(size);
else this->create_for_insert(size);
- bucket_ptr bucket = this->bucket_ptr_from_hash(hash_value);
+ bucket_ptr bucket_ = this->bucket_ptr_from_hash(hash_value);
node_ptr n = a.release();
- node::add_to_bucket(n, *bucket);
+ node::add_to_bucket(n, *bucket_);
++this->size_;
- this->cached_begin_bucket_ = bucket;
- return iterator_base(bucket, n);
+ this->cached_begin_bucket_ = bucket_;
+ return iterator_base(bucket_, n);
}
}}
--- misc/boost_1_44_0/boost/unordered/detail/unique.hpp 2011-02-05 03:28:39.000000000 +0100
+++ misc/build/boost_1_44_0/boost/unordered/detail/unique.hpp 2011-02-05 03:36:54.000000000 +0100
@@ -57,7 +57,7 @@
bool equals(hash_unique_table const&) const;
- node_ptr add_node(node_constructor& a, bucket_ptr bucket);
+ node_ptr add_node(node_constructor& a, bucket_ptr bucket_);
#if defined(BOOST_UNORDERED_STD_FORWARD)
@@ -135,8 +135,8 @@
if(this->size_ != other.size_) return false;
if(!this->size_) return true;
- bucket_ptr end = this->get_bucket(this->bucket_count_);
- for(bucket_ptr i = this->cached_begin_bucket_; i != end; ++i)
+ bucket_ptr end_ = this->get_bucket(this->bucket_count_);
+ for(bucket_ptr i = this->cached_begin_bucket_; i != end_; ++i)
{
node_ptr it1 = i->next_;
while(BOOST_UNORDERED_BORLAND_BOOL(it1))
@@ -159,13 +159,13 @@
template <class T>
inline BOOST_DEDUCED_TYPENAME hash_unique_table<T>::node_ptr
hash_unique_table<T>::add_node(node_constructor& a,
- bucket_ptr bucket)
+ bucket_ptr bucket_)
{
node_ptr n = a.release();
- node::add_to_bucket(n, *bucket);
+ node::add_to_bucket(n, *bucket_);
++this->size_;
- if(bucket < this->cached_begin_bucket_)
- this->cached_begin_bucket_ = bucket;
+ if(bucket_ < this->cached_begin_bucket_)
+ this->cached_begin_bucket_ = bucket_;
return n;
}
@@ -181,7 +181,7 @@
typedef BOOST_DEDUCED_TYPENAME value_type::second_type mapped_type;
std::size_t hash_value = this->hash_function()(k);
- bucket_ptr bucket = this->bucket_ptr_from_hash(hash_value);
+ bucket_ptr bucket_ = this->bucket_ptr_from_hash(hash_value);
if(!this->buckets_) {
node_constructor a(*this);
@@ -189,7 +189,7 @@
return *this->emplace_empty_impl_with_node(a, 1);
}
- node_ptr pos = this->find_iterator(bucket, k);
+ node_ptr pos = this->find_iterator(bucket_, k);
if (BOOST_UNORDERED_BORLAND_BOOL(pos)) {
return node::get_value(pos);
@@ -205,11 +205,11 @@
// reserve has basic exception safety if the hash function
// throws, strong otherwise.
if(this->reserve_for_insert(this->size_ + 1))
- bucket = this->bucket_ptr_from_hash(hash_value);
+ bucket_ = this->bucket_ptr_from_hash(hash_value);
// Nothing after this point can throw.
- return node::get_value(add_node(a, bucket));
+ return node::get_value(add_node(a, bucket_));
}
}
@@ -220,22 +220,22 @@
// No side effects in this initial code
key_type const& k = this->get_key(a.value());
std::size_t hash_value = this->hash_function()(k);
- bucket_ptr bucket = this->bucket_ptr_from_hash(hash_value);
- node_ptr pos = this->find_iterator(bucket, k);
+ bucket_ptr bucket_ = this->bucket_ptr_from_hash(hash_value);
+ node_ptr pos = this->find_iterator(bucket_, k);
if (BOOST_UNORDERED_BORLAND_BOOL(pos)) {
// Found an existing key, return it (no throw).
- return emplace_return(iterator_base(bucket, pos), false);
+ return emplace_return(iterator_base(bucket_, pos), false);
} else {
// reserve has basic exception safety if the hash function
// throws, strong otherwise.
if(this->reserve_for_insert(this->size_ + 1))
- bucket = this->bucket_ptr_from_hash(hash_value);
+ bucket_ = this->bucket_ptr_from_hash(hash_value);
// Nothing after this point can throw.
return emplace_return(
- iterator_base(bucket, add_node(a, bucket)),
+ iterator_base(bucket_, add_node(a, bucket_)),
true);
}
}
@@ -250,12 +250,12 @@
{
// No side effects in this initial code
std::size_t hash_value = this->hash_function()(k);
- bucket_ptr bucket = this->bucket_ptr_from_hash(hash_value);
- node_ptr pos = this->find_iterator(bucket, k);
+ bucket_ptr bucket_ = this->bucket_ptr_from_hash(hash_value);
+ node_ptr pos = this->find_iterator(bucket_, k);
if (BOOST_UNORDERED_BORLAND_BOOL(pos)) {
// Found an existing key, return it (no throw).
- return emplace_return(iterator_base(bucket, pos), false);
+ return emplace_return(iterator_base(bucket_, pos), false);
} else {
// Doesn't already exist, add to bucket.
@@ -269,12 +269,12 @@
// reserve has basic exception safety if the hash function
// throws, strong otherwise.
if(this->reserve_for_insert(this->size_ + 1))
- bucket = this->bucket_ptr_from_hash(hash_value);
+ bucket_ = this->bucket_ptr_from_hash(hash_value);
// Nothing after this point can throw.
return emplace_return(
- iterator_base(bucket, add_node(a, bucket)),
+ iterator_base(bucket_, add_node(a, bucket_)),
true);
}
}
@@ -313,21 +313,21 @@
BOOST_UNORDERED_FUNCTION_PARAMS(z, num_params)) \
{ \
std::size_t hash_value = this->hash_function()(k); \
- bucket_ptr bucket \
+ bucket_ptr bucket_ \
= this->bucket_ptr_from_hash(hash_value); \
- node_ptr pos = this->find_iterator(bucket, k); \
+ node_ptr pos = this->find_iterator(bucket_, k); \
\
if (BOOST_UNORDERED_BORLAND_BOOL(pos)) { \
- return emplace_return(iterator_base(bucket, pos), false); \
+ return emplace_return(iterator_base(bucket_, pos), false); \
} else { \
node_constructor a(*this); \
a.construct(BOOST_UNORDERED_CALL_PARAMS(z, num_params)); \
\
if(this->reserve_for_insert(this->size_ + 1)) \
- bucket = this->bucket_ptr_from_hash(hash_value); \
+ bucket_ = this->bucket_ptr_from_hash(hash_value); \
\
- return emplace_return(iterator_base(bucket, \
- add_node(a, bucket)), true); \
+ return emplace_return(iterator_base(bucket_, \
+ add_node(a, bucket_)), true); \
} \
} \
\
@@ -441,8 +441,8 @@
// different second_type.
key_type const& k = extractor::extract(*i);
std::size_t hash_value = this->hash_function()(k);
- bucket_ptr bucket = this->bucket_ptr_from_hash(hash_value);
- node_ptr pos = this->find_iterator(bucket, k);
+ bucket_ptr bucket_ = this->bucket_ptr_from_hash(hash_value);
+ node_ptr pos = this->find_iterator(bucket_, k);
if (!BOOST_UNORDERED_BORLAND_BOOL(pos)) {
// Doesn't already exist, add to bucket.
@@ -456,11 +456,11 @@
// throws, strong otherwise.
if(this->size_ + 1 >= this->max_load_) {
this->reserve_for_insert(this->size_ + insert_size(i, j));
- bucket = this->bucket_ptr_from_hash(hash_value);
+ bucket_ = this->bucket_ptr_from_hash(hash_value);
}
// Nothing after this point can throw.
- add_node(a, bucket);
+ add_node(a, bucket_);
}
} while(++i != j);
}
--- misc/boost_1_44_0/boost/unordered/detail/equivalent.hpp 2010-06-09 01:23:43.000000000 +0200
+++ misc/build/boost_1_44_0/boost/unordered/detail/equivalent.hpp 2011-02-05 04:15:47.000000000 +0100
@@ -57,7 +57,7 @@
bool equals(hash_equivalent_table const&) const;
inline node_ptr add_node(node_constructor& a,
- bucket_ptr bucket, node_ptr pos);
+ bucket_ptr bucket_, node_ptr pos);
#if defined(BOOST_UNORDERED_STD_FORWARD)
@@ -117,8 +117,8 @@
if(this->size_ != other.size_) return false;
if(!this->size_) return true;
- bucket_ptr end = this->get_bucket(this->bucket_count_);
- for(bucket_ptr i = this->cached_begin_bucket_; i != end; ++i)
+ bucket_ptr end_ = this->get_bucket(this->bucket_count_);
+ for(bucket_ptr i = this->cached_begin_bucket_; i != end_; ++i)
{
node_ptr it1 = i->next_;
while(BOOST_UNORDERED_BORLAND_BOOL(it1))
@@ -149,16 +149,16 @@
template <class T>
inline BOOST_DEDUCED_TYPENAME hash_equivalent_table<T>::node_ptr
hash_equivalent_table<T>
- ::add_node(node_constructor& a, bucket_ptr bucket, node_ptr pos)
+ ::add_node(node_constructor& a, bucket_ptr bucket_, node_ptr pos)
{
node_ptr n = a.release();
if(BOOST_UNORDERED_BORLAND_BOOL(pos)) {
node::add_after_node(n, pos);
}
else {
- node::add_to_bucket(n, *bucket);
- if(bucket < this->cached_begin_bucket_)
- this->cached_begin_bucket_ = bucket;
+ node::add_to_bucket(n, *bucket_);
+ if(bucket_ < this->cached_begin_bucket_)
+ this->cached_begin_bucket_ = bucket_;
}
++this->size_;
return n;
@@ -179,15 +179,15 @@
return this->emplace_empty_impl_with_node(a, 1);
}
else {
- bucket_ptr bucket = this->bucket_ptr_from_hash(hash_value);
- node_ptr position = this->find_iterator(bucket, k);
+ bucket_ptr bucket_ = this->bucket_ptr_from_hash(hash_value);
+ node_ptr position = this->find_iterator(bucket_, k);
// reserve has basic exception safety if the hash function
// throws, strong otherwise.
if(this->reserve_for_insert(this->size_ + 1))
- bucket = this->bucket_ptr_from_hash(hash_value);
+ bucket_ = this->bucket_ptr_from_hash(hash_value);
- return iterator_base(bucket, add_node(a, bucket, position));
+ return iterator_base(bucket_, add_node(a, bucket_, position));
}
}
@@ -196,8 +196,8 @@
::emplace_impl_no_rehash(node_constructor& a)
{
key_type const& k = this->get_key(a.value());
- bucket_ptr bucket = this->get_bucket(this->bucket_index(k));
- add_node(a, bucket, this->find_iterator(bucket, k));
+ bucket_ptr bucket_ = this->get_bucket(this->bucket_index(k));
+ add_node(a, bucket_, this->find_iterator(bucket_, k));
}
#if defined(BOOST_UNORDERED_STD_FORWARD)
--- misc/boost_1_44_0/boost/ptr_container/exception.hpp 2011-02-05 09:42:56.074932485 +0000
+++ misc/build/boost_1_44_0/boost/ptr_container/exception.hpp 2011-02-05 09:43:00.350931536 +0000
@@ -24,7 +24,7 @@
@@ -838,61 +267,6 @@
}
public: // algorithms
--- misc/boost_1_44_0/boost/unordered/detail/table.hpp 2011-02-10 15:04:57.999046223 +0000
+++ misc/build/boost_1_44_0/boost/unordered/detail/table.hpp 2011-02-10 15:05:44.260588237 +0000
@@ -119,7 +119,7 @@
// From 6.3.1/13:
// Only resize when size >= mlf_ * count
- return double_to_size_t(ceil((double) mlf_ * this->bucket_count_));
+ return double_to_size_t(ceil((double)mlf_ * (double)this->bucket_count_));
}
template <class T>
@@ -145,7 +145,7 @@
//
// Or from rehash post-condition:
// count > size / mlf_
- return next_prime(double_to_size_t(floor(size / (double) mlf_)) + 1);
+ return next_prime(double_to_size_t(floor((double)size / (double)mlf_)) + 1);
}
////////////////////////////////////////////////////////////////////////////
--- misc/boost_1_44_0/boost/functional/hash/detail/hash_float_generic.hpp 2011-02-10 14:50:52.173229648 +0000
+++ misc/build/boost_1_44_0/boost/functional/hash/detail/hash_float_generic.hpp 2011-02-10 14:52:36.824433976 +0000
@@ -53,7 +53,7 @@
v = ldexp(v, limits<std::size_t>::digits);
std::size_t seed = static_cast<std::size_t>(v);
- v -= seed;
+ v -= static_cast<T>(seed);
// ceiling(digits(T) * log2(radix(T))/ digits(size_t)) - 1;
std::size_t const length
@@ -66,7 +66,7 @@
{
v = ldexp(v, limits<std::size_t>::digits);
std::size_t part = static_cast<std::size_t>(v);
- v -= part;
+ v -= static_cast<T>(part);
hash_float_combine(seed, part);
}
--- misc/boost_1_44_0/boost/dynamic_bitset.hpp 2011-02-28 17:10:13.892131527 +0000
+++ misc/build/boost_1_44_0/boost/dynamic_bitset/dynamic_bitset.hpp 2011-02-28 17:11:05.868726195 +0000
@@ -1108,10 +1108,10 @@
// beyond the "allowed" positions
typedef unsigned long result_type;
- const size_type max_size =
+ const size_type max_size_ =
(std::min)(m_num_bits, static_cast<size_type>(ulong_width));
- const size_type last_block = block_index( max_size - 1 );
+ const size_type last_block = block_index( max_size_ - 1 );
assert((last_block * bits_per_block) < static_cast<size_type>(ulong_width));
--- misc/boost_1_44_0/boost/ptr_container/detail/reversible_ptr_container.hpp 2011-03-04 11:33:36.269274940 +0000
+++ misc/build/boost_1_44_0/boost/ptr_container/detail/reversible_ptr_container.hpp 2011-03-04 11:33:36.269274940 +0000
@@ -259,6 +259,10 @@
@@ -906,171 +280,3 @@
if( !allow_null )
{
BOOST_PTR_CONTAINER_THROW_EXCEPTION( 0 == x && "null not allowed",
--- misc/boost_1_44_0/boost/pool/object_pool.hpp 2011-07-14 16:08:31.672964851 +0100
+++ misc/build/boost_1_44_0/boost/pool/object_pool.hpp 2011-07-14 16:09:20.851594534 +0100
@@ -53,8 +53,8 @@
public:
// This constructor parameter is an extension!
- explicit object_pool(const size_type next_size = 32)
- :pool<UserAllocator>(sizeof(T), next_size) { }
+ explicit object_pool(const size_type next_size_ = 32)
+ :pool<UserAllocator>(sizeof(T), next_size_) { }
~object_pool();
--- misc/boost_1_44_0/libs/date_time/src/gregorian/greg_month.cpp 2008-11-23 12:13:35.000000000 +0100
+++ misc/build/boost_1_44_0/libs/date_time/src/gregorian/greg_month.cpp 2011-10-05 16:56:34.627320523 +0200
@@ -108,7 +108,7 @@
*/
BOOST_DATE_TIME_DECL
boost::date_time::all_date_names_put<greg_facet_config, char>*
- create_facet_def(char type)
+ create_facet_def(char /* type */)
{
typedef
boost::date_time::all_date_names_put<greg_facet_config, char> facet_def;
@@ -121,7 +121,7 @@
}
//! generates a locale with the set of gregorian name-strings of type char*
- BOOST_DATE_TIME_DECL std::locale generate_locale(std::locale& loc, char type){
+ BOOST_DATE_TIME_DECL std::locale generate_locale(std::locale& loc, char /* type */){
typedef boost::date_time::all_date_names_put<greg_facet_config, char> facet_def;
return std::locale(loc, new facet_def(short_month_names,
long_month_names,
@@ -139,7 +139,7 @@
*/
BOOST_DATE_TIME_DECL
boost::date_time::all_date_names_put<greg_facet_config, wchar_t>*
- create_facet_def(wchar_t type)
+ create_facet_def(wchar_t /* type */)
{
typedef
boost::date_time::all_date_names_put<greg_facet_config,wchar_t> facet_def;
@@ -152,7 +152,7 @@
}
//! generates a locale with the set of gregorian name-strings of type wchar_t*
- BOOST_DATE_TIME_DECL std::locale generate_locale(std::locale& loc, wchar_t type){
+ BOOST_DATE_TIME_DECL std::locale generate_locale(std::locale& loc, wchar_t /* type */){
typedef boost::date_time::all_date_names_put<greg_facet_config, wchar_t> facet_def;
return std::locale(loc, new facet_def(w_short_month_names,
w_long_month_names,
--- misc/boost_1_44_0/boost/date_time/time_facet.hpp 2012-08-20 09:12:51.552094137 +0100
+++ misc/build/boost_1_44_0/boost/date_time/time_facet.hpp 2012-08-20 09:10:07.884255317 +0100
@@ -439,31 +439,31 @@
a_time_dur.get_rep().as_special());
}
- string_type format(m_time_duration_format);
+ string_type lcl_format(m_time_duration_format);
if (a_time_dur.is_negative()) {
// replace %- with minus sign. Should we use the numpunct facet?
- boost::algorithm::replace_all(format,
+ boost::algorithm::replace_all(lcl_format,
duration_sign_negative_only,
negative_sign);
// remove all the %+ in the string with '-'
- boost::algorithm::replace_all(format,
+ boost::algorithm::replace_all(lcl_format,
duration_sign_always,
negative_sign);
}
else { //duration is positive
// remove all the %- combos from the string
- boost::algorithm::erase_all(format, duration_sign_negative_only);
+ boost::algorithm::erase_all(lcl_format, duration_sign_negative_only);
// remove all the %+ in the string with '+'
- boost::algorithm::replace_all(format,
+ boost::algorithm::replace_all(lcl_format,
duration_sign_always,
positive_sign);
}
// %T and %R have to be replaced here since they are not standard
- boost::algorithm::replace_all(format,
+ boost::algorithm::replace_all(lcl_format,
boost::as_literal(formats_type::full_24_hour_time_format),
boost::as_literal(formats_type::full_24_hour_time_expanded_format));
- boost::algorithm::replace_all(format,
+ boost::algorithm::replace_all(lcl_format,
boost::as_literal(formats_type::short_24_hour_time_format),
boost::as_literal(formats_type::short_24_hour_time_expanded_format));
@@ -476,22 +476,22 @@
* here ourself.
*/
string_type hours_str;
- if (format.find(unrestricted_hours_format) != string_type::npos) {
+ if (lcl_format.find(unrestricted_hours_format) != string_type::npos) {
hours_str = hours_as_string(a_time_dur);
- boost::algorithm::replace_all(format, unrestricted_hours_format, hours_str);
+ boost::algorithm::replace_all(lcl_format, unrestricted_hours_format, hours_str);
}
// We still have to process restricted hours format specifier. In order to
// support parseability of durations in ISO format (%H%M%S), we'll have to
// restrict the stringified hours length to 2 characters.
- if (format.find(hours_format) != string_type::npos) {
+ if (lcl_format.find(hours_format) != string_type::npos) {
if (hours_str.empty())
hours_str = hours_as_string(a_time_dur);
BOOST_ASSERT(hours_str.length() <= 2);
- boost::algorithm::replace_all(format, hours_format, hours_str);
+ boost::algorithm::replace_all(lcl_format, hours_format, hours_str);
}
string_type frac_str;
- if (format.find(seconds_with_fractional_seconds_format) != string_type::npos) {
+ if (lcl_format.find(seconds_with_fractional_seconds_format) != string_type::npos) {
// replace %s with %S.nnn
frac_str =
fractional_seconds_as_string(a_time_dur, false);
@@ -500,21 +500,21 @@
string_type replace_string(seconds_format);
replace_string += sep;
replace_string += frac_str;
- boost::algorithm::replace_all(format,
+ boost::algorithm::replace_all(lcl_format,
seconds_with_fractional_seconds_format,
replace_string);
}
- if (format.find(fractional_seconds_format) != string_type::npos) {
+ if (lcl_format.find(fractional_seconds_format) != string_type::npos) {
// replace %f with nnnnnnn
if (!frac_str.size()) {
frac_str = fractional_seconds_as_string(a_time_dur, false);
}
- boost::algorithm::replace_all(format,
+ boost::algorithm::replace_all(lcl_format,
fractional_seconds_format,
frac_str);
}
- if (format.find(fractional_seconds_or_none_format) != string_type::npos) {
+ if (lcl_format.find(fractional_seconds_or_none_format) != string_type::npos) {
// replace %F with nnnnnnn or nothing if fs == 0
frac_str =
fractional_seconds_as_string(a_time_dur, true);
@@ -523,18 +523,18 @@
string_type replace_string;
replace_string += sep;
replace_string += frac_str;
- boost::algorithm::replace_all(format,
+ boost::algorithm::replace_all(lcl_format,
fractional_seconds_or_none_format,
replace_string);
}
else {
- boost::algorithm::erase_all(format,
+ boost::algorithm::erase_all(lcl_format,
fractional_seconds_or_none_format);
}
}
return this->do_put_tm(a_next, a_ios, a_fill,
- to_tm(a_time_dur), format);
+ to_tm(a_time_dur), lcl_format);
}
OutItrT put(OutItrT next, std::ios_base& a_ios,
diff --git a/boost/boost.4874.patch b/boost/boost.4874.patch
index 7dbd33d..c401cf7 100644
--- a/boost/boost.4874.patch
+++ b/boost/boost.4874.patch
@@ -10,14 +10,6 @@ Index: branches/release/boost/multi_array/base.hpp
#include "boost/multi_array/extent_range.hpp"
#include "boost/multi_array/extent_gen.hpp"
#include "boost/multi_array/index_range.hpp"
@@ -82,5 +82,6 @@
class const_sub_array;
-template <typename T, typename TPtr, typename NumDims, typename Reference>
+ template <typename T, typename TPtr, typename NumDims, typename Reference,
+ typename IteratorCategory>
class array_iterator;
@@ -252,5 +253,17 @@
/////////////////////////////////////////////////////////////////////////
@@ -37,23 +29,6 @@ Index: branches/release/boost/multi_array/base.hpp
+#endif
////////////////////////////////////////////////////////////////////////
@@ -302,6 +315,14 @@
// iterator support
//
- typedef array_iterator<T,T*,mpl::size_t<NumDims>,reference> iterator;
- typedef array_iterator<T,T const*,mpl::size_t<NumDims>,const_reference> const_iterator;
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1600)
+ // Deal with VC 2010 output_iterator_tag requirement
+ typedef array_iterator<T,T*,mpl::size_t<NumDims>,reference,
+ mutable_iterator_tag> iterator;
+#else
+ typedef array_iterator<T,T*,mpl::size_t<NumDims>,reference,
+ boost::random_access_traversal_tag> iterator;
+#endif
+ typedef array_iterator<T,T const*,mpl::size_t<NumDims>,const_reference,
+ boost::random_access_traversal_tag> const_iterator;
typedef ::boost::reverse_iterator<iterator> reverse_iterator;
@@ -322,5 +343,6 @@
const index* strides,
const index* index_bases) const {
@@ -62,23 +37,6 @@ Index: branches/release/boost/multi_array/base.hpp
+ detail::multi_array::CollectionConcept<IndexList> >();
ignore_unused_variable_warning(index_bases);
ignore_unused_variable_warning(extents);
@@ -333,7 +355,13 @@
index offset = 0;
- for (size_type n = 0; n != NumDims; ++n)
- offset += indices[n] * strides[n];
-
+ {
+ typename IndexList::const_iterator i = indices.begin();
+ size_type n = 0;
+ while (n != NumDims) {
+ offset += (*i) * strides[n];
+ ++n;
+ ++i;
+ }
+ }
return base[offset];
}
Index: branches/release/boost/multi_array/concept_checks.hpp
===================================================================
--- a/branches/release/boost/multi_array/concept_checks.hpp
@@ -89,52 +47,3 @@ Index: branches/release/boost/multi_array/concept_checks.hpp
+ function_requires< boost::OutputIterator<iterator,value_type> >();
// RG - a( CollectionArchetype) when available...
Index: branches/release/boost/multi_array/iterator.hpp
===================================================================
--- a/branches/release/boost/multi_array/iterator.hpp
+++ b/branches/release/boost/multi_array/iterator.hpp
@@ -45,14 +45,16 @@
};
-template <typename T, typename TPtr, typename NumDims, typename Reference>
+template <typename T, typename TPtr, typename NumDims, typename Reference,
+ typename IteratorCategory>
class array_iterator;
-template <typename T, typename TPtr, typename NumDims, typename Reference>
+template <typename T, typename TPtr, typename NumDims, typename Reference,
+ typename IteratorCategory>
class array_iterator
: public
iterator_facade<
- array_iterator<T,TPtr,NumDims,Reference>
+ array_iterator<T,TPtr,NumDims,Reference,IteratorCategory>
, typename associated_types<T,NumDims>::value_type
- , boost::random_access_traversal_tag
+ , IteratorCategory
, Reference
>
@@ -70,5 +72,5 @@
typedef iterator_facade<
- array_iterator<T,TPtr,NumDims,Reference>
+ array_iterator<T,TPtr,NumDims,Reference,IteratorCategory>
, typename detail::multi_array::associated_types<T,NumDims>::value_type
, boost::random_access_traversal_tag
@@ -80,5 +82,5 @@
#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
- template <typename, typename, typename, typename>
+ template <typename, typename, typename, typename, typename>
friend class array_iterator;
#else
@@ -106,7 +108,7 @@
strides_(strides), index_base_(index_base) { }
- template <typename OPtr, typename ORef>
+ template <typename OPtr, typename ORef, typename Cat>
array_iterator(
- const array_iterator<T,OPtr,NumDims,ORef>& rhs
+ const array_iterator<T,OPtr,NumDims,ORef,Cat>& rhs
, typename boost::enable_if_convertible<OPtr,TPtr>::type* = 0
)
diff --git a/boost/boost.5119.unordered_map-cp-ctor.patch b/boost/boost.5119.unordered_map-cp-ctor.patch
deleted file mode 100644
index 42e7175..0000000
--- a/boost/boost.5119.unordered_map-cp-ctor.patch
+++ /dev/null
@@ -1,92 +0,0 @@
Index: /trunk/boost/unordered/unordered_set.hpp
===================================================================
--- misc/boost_1_44_0/boost/unordered/unordered_set.hpp (revision 60754)
+++ misc/build/boost_1_44_0/boost/unordered/unordered_set.hpp (revision 68445)
@@ -155,4 +155,9 @@
#if !defined(BOOST_NO_RVALUE_REFERENCES)
+ unordered_set(unordered_set const& other)
+ : table_(other.table_)
+ {
+ }
+
unordered_set(unordered_set&& other)
: table_(other.table_, boost::unordered_detail::move_tag())
@@ -163,4 +168,10 @@
: table_(other.table_, a, boost::unordered_detail::move_tag())
{
+ }
+
+ unordered_set& operator=(unordered_set const& x)
+ {
+ table_ = x.table_;
+ return *this;
}
@@ -652,4 +663,9 @@
#if !defined(BOOST_NO_RVALUE_REFERENCES)
+ unordered_multiset(unordered_multiset const& other)
+ : table_(other.table_)
+ {
+ }
+
unordered_multiset(unordered_multiset&& other)
: table_(other.table_, boost::unordered_detail::move_tag())
@@ -660,4 +676,10 @@
: table_(other.table_, a, boost::unordered_detail::move_tag())
{
+ }
+
+ unordered_multiset& operator=(unordered_multiset const& x)
+ {
+ table_ = x.table_;
+ return *this;
}
Index: /trunk/boost/unordered/unordered_map.hpp
===================================================================
--- misc/boost_1_44_0/boost/unordered/unordered_map.hpp (revision 60754)
+++ misc/build/boost_1_44_0/boost/unordered/unordered_map.hpp (revision 68445)
@@ -161,4 +161,9 @@
#if !defined(BOOST_NO_RVALUE_REFERENCES)
+ unordered_map(unordered_map const& other)
+ : table_(other.table_)
+ {
+ }
+
unordered_map(unordered_map&& other)
: table_(other.table_, boost::unordered_detail::move_tag())
@@ -169,4 +174,10 @@
: table_(other.table_, a, boost::unordered_detail::move_tag())
{
+ }
+
+ unordered_map& operator=(unordered_map const& x)
+ {
+ table_ = x.table_;
+ return *this;
}
@@ -706,4 +717,9 @@
#if !defined(BOOST_NO_RVALUE_REFERENCES)
+ unordered_multimap(unordered_multimap const& other)
+ : table_(other.table_)
+ {
+ }
+
unordered_multimap(unordered_multimap&& other)
: table_(other.table_, boost::unordered_detail::move_tag())
@@ -714,4 +730,10 @@
: table_(other.table_, a, boost::unordered_detail::move_tag())
{
+ }
+
+ unordered_multimap& operator=(unordered_multimap const& x)
+ {
+ table_ = x.table_;
+ return *this;
}
diff --git a/boost/boost.6139.clang.patch b/boost/boost.6139.clang.patch
deleted file mode 100644
index afa9a25..0000000
--- a/boost/boost.6139.clang.patch
+++ /dev/null
@@ -1,10 +0,0 @@
--- misc/build/boost/boost/detail/container_fwd.hpp 2013-04-02 19:13:58.744000000 -0400
+++ misc/build/boost/boost/detail/container_fwd.hpp 2013-04-02 19:23:13.504000000 -0400
@@ -17,6 +17,7 @@
|| ((defined(__GLIBCPP__) || defined(__GLIBCXX__)) \
&& (defined(_GLIBCXX_DEBUG) || defined(_GLIBCXX_PARALLEL))) \
|| BOOST_WORKAROUND(__BORLANDC__, > 0x551) \
+ || __GLIBCXX__ >= 20070513 \
|| BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x842)) \
|| (defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION))
diff --git a/boost/boost.6369.warnings.patch b/boost/boost.6369.warnings.patch
index 5a7e336..81a5eac 100644
--- a/boost/boost.6369.warnings.patch
+++ b/boost/boost.6369.warnings.patch
@@ -321,24 +321,3 @@
).second;
}
--- misc/boost_1_44_0/boost/variant/variant.hpp 2012-01-08 20:16:41.321760852 +0000
+++ misc/build/boost_1_44_0/boost/variant/variant.hpp 2012-01-08 20:25:43.233484675 +0000
@@ -1143,14 +1143,14 @@
which_t which_;
storage_t storage_;
- void indicate_which(int which)
+ void indicate_which(int i_which)
{
- which_ = static_cast<which_t>( which );
+ which_ = static_cast<which_t>( i_which );
}
- void indicate_backup_which(int which)
+ void indicate_backup_which(int i_which)
{
- which_ = static_cast<which_t>( -(which + 1) );
+ which_ = static_cast<which_t>( -(i_which + 1) );
}
private: // helpers, for queries (below)
diff --git a/boost/boost.6397.warnings.patch b/boost/boost.6397.warnings.patch
index 383945e..1cb18d4 100644
--- a/boost/boost.6397.warnings.patch
+++ b/boost/boost.6397.warnings.patch
@@ -19,25 +19,6 @@
{
process_bit( static_cast<bool>(bits & high_bit_mask) );
}
--- misc/boost_1_44_0/boost/multi_array/collection_concept.hpp 2012-01-12 20:21:29.790009198 +0000
+++ misc/build/boost_1_44_0/boost/multi_array/collection_concept.hpp 2012-01-12 20:28:55.457287835 +0000
@@ -43,11 +43,11 @@
i = c.end();
c.swap(c);
}
- void const_constraints(const Collection& c) {
- ci = c.begin();
- ci = c.end();
- n = c.size();
- b = c.empty();
+ void const_constraints(const Collection& c_) {
+ ci = c_.begin();
+ ci = c_.end();
+ n = c_.size();
+ b = c_.empty();
}
Collection c;
bool b;
--- misc/boost_1_44_0/boost/multi_array/concept_checks.hpp 2012-01-12 20:21:29.790009198 +0000
+++ misc/build/boost_1_44_0/boost/multi_array/concept_checks.hpp 2012-01-12 20:29:56.482879277 +0000
@@ -39,8 +39,8 @@
@@ -72,12 +53,12 @@
// value_type vt = a[ id ];
// Test slicing, keeping only the first dimension, losing the rest
- idgen_helper<NumDims-1>::call(a,idgen[range],id);
+ idgen_helper<NumDims-1>::call(a_,idgen[range],id);
- detail::idgen_helper<NumDims-1>::call(a,idgen[range],id);
+ detail::idgen_helper<NumDims-1>::call(a_,idgen[range],id);
// Test slicing, keeping all dimensions.
- idgen_helper<NumDims-1>::call(a,idgen[range],range);
+ idgen_helper<NumDims-1>::call(a_,idgen[range],range);
- detail::idgen_helper<NumDims-1>::call(a,idgen[range],range);
+ detail::idgen_helper<NumDims-1>::call(a_,idgen[range],range);
- st = a.size();
- st = a.num_dimensions();
@@ -161,7 +142,7 @@
+ explicit const_multi_array_ref(TPtr base, const ExtentList& extents_) :
base_(base), storage_(c_storage_order()) {
boost::function_requires<
detail::multi_array::CollectionConcept<ExtentList> >();
CollectionConcept<ExtentList> >();
index_base_list_.assign(0);
- init_multi_array_ref(extents.begin());
@@ -174,7 +155,7 @@
const general_storage_order<NumDims>& so) :
base_(base), storage_(so) {
boost::function_requires<
detail::multi_array::CollectionConcept<ExtentList> >();
CollectionConcept<ExtentList> >();
index_base_list_.assign(0);
- init_multi_array_ref(extents.begin());
@@ -206,7 +187,7 @@
- void reshape(const SizeList& extents) {
+ void reshape(const SizeList& extents_) {
boost::function_requires<
detail::multi_array::CollectionConcept<SizeList> >();
CollectionConcept<SizeList> >();
BOOST_ASSERT(num_elements_ ==
- std::accumulate(extents.begin(),extents.end(),
+ std::accumulate(extents_.begin(),extents_.end(),
@@ -224,7 +205,7 @@
- const element& operator()(IndexList indices) const {
+ const element& operator()(IndexList indices_) const {
boost::function_requires<
detail::multi_array::CollectionConcept<IndexList> >();
CollectionConcept<IndexList> >();
return super_type::access_element(boost::type<const element&>(),
- indices,origin(),
+ indices_,origin(),
@@ -299,7 +280,7 @@
+ explicit multi_array_ref(T* base, const ExtentList& extents_) :
+ super_type(base,extents_) {
boost::function_requires<
detail::multi_array::CollectionConcept<ExtentList> >();
CollectionConcept<ExtentList> >();
}
template <class ExtentList>
@@ -309,7 +290,7 @@
- super_type(base,extents,so) {
+ super_type(base,extents_,so) {
boost::function_requires<
detail::multi_array::CollectionConcept<ExtentList> >();
CollectionConcept<ExtentList> >();
}
@@ -509,11 +509,11 @@
element* data() { return super_type::base_; }
@@ -318,7 +299,7 @@
- element& operator()(const IndexList& indices) {
+ element& operator()(const IndexList& indices_) {
boost::function_requires<
detail::multi_array::CollectionConcept<IndexList> >();
CollectionConcept<IndexList> >();
return super_type::access_element(boost::type<element&>(),
- indices,origin(),
+ indices_,origin(),
@@ -346,7 +327,7 @@
- const element& operator()(const IndexList& indices) const {
+ const element& operator()(const IndexList& indices_) const {
boost::function_requires<
detail::multi_array::CollectionConcept<IndexList> >();
CollectionConcept<IndexList> >();
- return super_type::operator()(indices);
+ return super_type::operator()(indices_);
}
@@ -534,27 +515,33 @@
new_array.index_base_list_.end(),
--- misc/boost_1_44_0/boost/random/mersenne_twister.hpp
+++ misc/build/boost_1_44_0/boost/random/mersenne_twister.hpp
@@ -195,16 +195,16 @@
}
#endif
@@ -195,19 +195,19 @@
* Returns true if the two generators are in the same state,
* and will thus produce identical sequences.
*/
- friend bool operator==(const mersenne_twister_engine& x,
- const mersenne_twister_engine& y)
+ friend bool operator==(const mersenne_twister_engine& x_arg,
+ const mersenne_twister_engine& y_arg)
{
- if(x.i < y.i) return x.equal_imp(y);
- else return y.equal_imp(x);
+ if(x_arg.i < y_arg.i) return x_arg.equal_imp(y_arg);
+ else return y_arg.equal_imp(x_arg);
}
/**
* Returns true if the two generators are in different states.
*/
- friend bool operator!=(const mersenne_twister_engine& x,
- const mersenne_twister_engine& y)
- { return !(x == y); }
+ friend bool operator!=(const mersenne_twister_engine& x_arg,
+ const mersenne_twister_engine& y_arg)
+ { return !(x_arg == y_arg); }
- friend bool operator==(const mersenne_twister& x, const mersenne_twister& y)
+ friend bool operator==(const mersenne_twister& x_, const mersenne_twister& y_)
{
for(int j = 0; j < state_size; ++j)
- if(x.compute(j) != y.compute(j))
+ if(x_.compute(j) != y_.compute(j))
return false;
return true;
}
- friend bool operator!=(const mersenne_twister& x, const mersenne_twister& y)
- { return !(x == y); }
+ friend bool operator!=(const mersenne_twister& x_, const mersenne_twister& y_)
+ { return !(x_ == y_); }
#else
// Use a member function; Streamable concept not supported.
bool operator==(const mersenne_twister& rhs) const
private:
/// \cond show_private
--- misc/boost_1_44_0/boost/uuid/uuid_io.hpp
+++ misc/build/boost_1_44_0/boost/uuid/uuid_io.hpp
@@ -59,7 +59,7 @@
diff --git a/boost/boost.6940.glibc.patch b/boost/boost.6940.glibc.patch
deleted file mode 100644
index b1f4230..0000000
--- a/boost/boost.6940.glibc.patch
+++ /dev/null
@@ -1,20 +0,0 @@
--- misc/boost_1_44_0/boost/thread/xtime.hpp 2012-11-05 20:13:28.034300778 -0500
+++ misc/build/boost_1_44_0/boost/thread/xtime.hpp 2012-11-05 20:13:50.856322691 -0500
@@ -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;
diff --git a/boost/boost.7774.warnings.patch.1 b/boost/boost.7774.warnings.patch.1
deleted file mode 100644
index 60c4f05..0000000
--- a/boost/boost.7774.warnings.patch.1
+++ /dev/null
@@ -1,34 +0,0 @@
diff -ur boost.org/boost/random/binomial_distribution.hpp boost/boost/random/binomial_distribution.hpp
--- boost.org/boost/random/binomial_distribution.hpp 2012-12-07 21:17:45.789067382 +0100
+++ boost/boost/random/binomial_distribution.hpp 2012-12-07 21:42:39.915034045 +0100
@@ -42,12 +42,12 @@
*
* Requires: t >=0 && 0 <= p <= 1
*/
- explicit binomial_distribution(IntType t = 1,
- const RealType& p = RealType(0.5))
- : _bernoulli(p), _t(t)
+ explicit binomial_distribution(IntType t_arg = 1,
+ const RealType& p_arg = RealType(0.5))
+ : _bernoulli(p_arg), _t(t_arg)
{
assert(_t >= 0);
- assert(RealType(0) <= p && p <= RealType(1));
+ assert(RealType(0) <= p_arg && p_arg <= RealType(1));
}
// compiler-generated copy ctor and assignment operator are fine
diff -ur boost.org/boost/random/geometric_distribution.hpp boost/boost/random/geometric_distribution.hpp
--- boost.org/boost/random/geometric_distribution.hpp 2012-12-07 21:17:45.789067382 +0100
+++ boost/boost/random/geometric_distribution.hpp 2012-12-07 21:41:34.970035494 +0100
@@ -50,8 +50,8 @@
*
* Requires: 0 < p < 1
*/
- explicit geometric_distribution(const RealType& p = RealType(0.5))
- : _p(p)
+ explicit geometric_distribution(const RealType& p_arg = RealType(0.5))
+ : _p(p_arg)
{
assert(RealType(0) < _p && _p < RealType(1));
init();
diff --git a/boost/boost.gcc47679.patch b/boost/boost.gcc47679.patch
index 9b33a5f..72ab15a 100644
--- a/boost/boost.gcc47679.patch
+++ b/boost/boost.gcc47679.patch
@@ -56,6 +56,6 @@
+ memset(&dummy_, 0, sizeof(dummy_));
+ }
+
void const* address() const { return &dummy_.data[0]; }
void * address() { return &dummy_.data[0]; }
} ;
#if defined(BOOST_OPTIONAL_DETAIL_USE_ATTRIBUTE_MAY_ALIAS)
void const* address() const { return &dummy_; }
void * address() { return &dummy_; }
diff --git a/boost/boost.libcdr.warnings.patch.1 b/boost/boost.libcdr.warnings.patch.1
index 2df0e3b..61a6a8c 100644
--- a/boost/boost.libcdr.warnings.patch.1
+++ b/boost/boost.libcdr.warnings.patch.1
@@ -1,50 +1,3 @@
--- boost/boost/archive/basic_archive.hpp 2010-08-11 20:15:46.000000000 +0200
+++ boost/boost/archive/basic_archive.hpp 2013-05-17 15:39:58.624333369 +0200
@@ -54,7 +54,7 @@
return *this;
}
// used for text output
- operator const base_type () const {
+ operator base_type () const {
return t;
}
// used for text input
@@ -90,7 +90,7 @@
return *this;
}
// used for text output
- operator const base_type () const {
+ operator base_type () const {
return t;
}
// used for text intput
@@ -127,7 +127,7 @@
}
// used for text output
- operator const int () const {
+ operator int () const {
return t;
}
// used for text input
@@ -161,7 +161,7 @@
return *this;
}
// used for text output
- operator const uint_least32_t () const {
+ operator uint_least32_t () const {
return t;
}
// used for text input
@@ -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(t_){} \
}; \
/**/
--- boost/boost/multi_index/detail/index_matcher.hpp 2008-07-03 18:51:53.000000000 +0200
+++ boost/boost/multi_index/detail/index_matcher.hpp 2013-05-17 15:30:12.539099597 +0200
@@ -132,17 +132,17 @@
@@ -236,92 +189,6 @@
}
#endif
--- boost/boost/property_tree/detail/exception_implementation.hpp 2009-09-01 23:27:45.000000000 +0200
+++ boost/boost/property_tree/detail/exception_implementation.hpp 2013-05-17 15:28:28.599529530 +0200
@@ -30,8 +30,8 @@
///////////////////////////////////////////////////////////////////////////
// ptree_error
- inline ptree_error::ptree_error(const std::string &what):
- std::runtime_error(what)
+ inline ptree_error::ptree_error(const std::string &what_):
+ std::runtime_error(what_)
{
}
@@ -43,8 +43,8 @@
// ptree_bad_data
template<class D> inline
- ptree_bad_data::ptree_bad_data(const std::string &what, const D &data):
- ptree_error(what), m_data(data)
+ ptree_bad_data::ptree_bad_data(const std::string &what_, const D &data_):
+ ptree_error(what_), m_data(data_)
{
}
@@ -62,8 +62,8 @@
// ptree_bad_path
template<class P> inline
- ptree_bad_path::ptree_bad_path(const std::string &what, const P &path):
- ptree_error(detail::prepare_bad_path_what(what, path)), m_path(path)
+ ptree_bad_path::ptree_bad_path(const std::string &what_, const P &path_):
+ ptree_error(detail::prepare_bad_path_what(what_, path_)), m_path(path_)
{
}
--- boost/boost/property_tree/detail/file_parser_error.hpp 2009-09-01 23:27:45.000000000 +0200
+++ boost/boost/property_tree/detail/file_parser_error.hpp 2013-05-17 15:36:01.615914822 +0200
@@ -26,11 +26,11 @@
// Construction & destruction
// Construct error
- file_parser_error(const std::string &message,
- const std::string &filename,
- unsigned long line) :
- ptree_error(format_what(message, filename, line)),
- m_message(message), m_filename(filename), m_line(line)
+ file_parser_error(const std::string &message_,
+ const std::string &filename_,
+ unsigned long line_) :
+ ptree_error(format_what(message_, filename_, line_)),
+ m_message(message_), m_filename(filename_), m_line(line_)
{
}
@@ -69,20 +69,20 @@
unsigned long m_line;
// Format error message to be returned by std::runtime_error::what()
- std::string format_what(const std::string &message,
- const std::string &filename,
- unsigned long line)
+ std::string format_what(const std::string &message_,
+ const std::string &filename_,
+ unsigned long line_)
{
std::stringstream stream;
- if (line > 0)
- stream << (filename.empty() ? "<unspecified file>"
- : filename.c_str())
- << '(' << line << "): "
- << message;
+ if (line_ > 0)
+ stream << (filename_.empty() ? "<unspecified file>"
+ : filename_.c_str())
+ << '(' << line_ << "): "
+ << message_;
else
- stream << (filename.empty() ? "<unspecified file>"
- : filename.c_str())
- << ": " << message;
+ stream << (filename_.empty() ? "<unspecified file>"
+ : filename_.c_str())
+ << ": " << message_;
return stream.str();
}
--- boost/boost/property_tree/detail/json_parser_error.hpp 2007-05-13 00:02:53.000000000 +0200
+++ boost/boost/property_tree/detail/json_parser_error.hpp 2013-05-17 15:36:44.605902442 +0200
@@ -20,10 +20,10 @@
@@ -417,17 +284,6 @@
u = (std::min)(u, static_cast<unsigned long>((std::numeric_limits<Ch>::max)()));
--- boost/boost/property_tree/detail/ptree_implementation.hpp 2010-07-03 22:59:45.000000000 +0200
+++ boost/boost/property_tree/detail/ptree_implementation.hpp 2013-05-17 15:55:56.449713452 +0200
@@ -183,8 +183,8 @@
}
template<class K, class D, class C> inline
- basic_ptree<K, D, C>::basic_ptree(const data_type &data)
- : m_data(data), m_children(new typename subs::base_container)
+ basic_ptree<K, D, C>::basic_ptree(const data_type &data_)
+ : m_data(data_), m_children(new typename subs::base_container)
{
}
@@ -539,48 +539,48 @@
template<class K, class D, class C>
@@ -582,7 +438,7 @@
}
template<class K, class D, class C>
@@ -759,17 +759,17 @@
@@ -759,18 +759,18 @@
std::basic_string<Ch>
>::type
basic_ptree<K, D, C>::get(
@@ -601,7 +457,8 @@
{
- if (optional<const self_type&> child = get_child_optional(path))
+ if (optional<const self_type&> child = get_child_optional(path_))
return child.get().BOOST_NESTED_TEMPLATE get_value_optional<Type>(tr);
return child.get().
BOOST_NESTED_TEMPLATE get_value_optional<Type>(tr);
else
return optional<Type>();
@@ -778,9 +778,9 @@
@@ -668,17 +525,6 @@
typename translator_between<data_type, Type>::type());
}
--- boost/boost/serialization/collection_size_type.hpp 2010-07-09 18:50:03.000000000 +0200
+++ boost/boost/serialization/collection_size_type.hpp 2013-05-17 15:40:32.789528782 +0200
@@ -37,7 +37,7 @@
return *this;
}
// used for text output
- operator const base_type () const {
+ operator base_type () const {
return t;
}
// used for text input
--- boost/boost/spirit/home/classic/error_handling/exceptions.hpp 2013-05-17 15:57:23.722638823 +0200
+++ boost/boost/spirit/home/classic/error_handling/exceptions.hpp 2013-05-17 15:26:32.319247352 +0200
@@ -126,8 +126,8 @@
diff --git a/boost/boost.loplugin.patch b/boost/boost.loplugin.patch
new file mode 100644
index 0000000..7c35d33
--- /dev/null
+++ b/boost/boost.loplugin.patch
@@ -0,0 +1,19 @@
--- foo/foo/foo/boost/lexical_cast.hpp
+++ foo/foo/foo/boost/lexical_cast.hpp
@@ -1016,7 +1016,7 @@
if( !has_minus ) value = std::numeric_limits<T>::quiet_NaN();
else value = (boost::math::changesign) (std::numeric_limits<T>::quiet_NaN());
return true;
- } else
+ } else {
if (( /* 'INF' or 'inf' */
end-begin==3
&&
@@ -1031,6 +1031,7 @@
else value = (boost::math::changesign) (std::numeric_limits<T>::infinity());
return true;
}
+ }
return false;
}
diff --git a/boost/boost.mipsbackport.patch b/boost/boost.mipsbackport.patch
deleted file mode 100644
index 085d232..0000000
--- a/boost/boost.mipsbackport.patch
+++ /dev/null
@@ -1,42 +0,0 @@
--- misc/boost_1_44_0/boost/smart_ptr/detail/sp_counted_base_gcc_mips.hpp 2009-03-27 13:10:46.000000000 +0000
+++ misc/build/boost_1_44_0/boost/smart_ptr/detail/sp_counted_base_gcc_mips.hpp 2011-11-07 14:25:23.000000000 +0000
@@ -37,9 +37,12 @@
__asm__ __volatile__
(
"0:\n\t"
+ ".set push\n\t"
+ ".set mips2\n\t"
"ll %0, %1\n\t"
"addiu %0, 1\n\t"
"sc %0, %1\n\t"
+ ".set pop\n\t"
"beqz %0, 0b":
"=&r"( tmp ), "=m"( *pw ):
"m"( *pw )
@@ -55,9 +58,12 @@
__asm__ __volatile__
(
"0:\n\t"
+ ".set push\n\t"
+ ".set mips2\n\t"
"ll %1, %2\n\t"
"addiu %0, %1, -1\n\t"
"sc %0, %2\n\t"
+ ".set pop\n\t"
"beqz %0, 0b\n\t"
"addiu %0, %1, -1":
"=&r"( rv ), "=&r"( tmp ), "=m"( *pw ):
@@ -78,10 +84,13 @@
__asm__ __volatile__
(
"0:\n\t"
+ ".set push\n\t"
+ ".set mips2\n\t"
"ll %0, %2\n\t"
"beqz %0, 1f\n\t"
"addiu %1, %0, 1\n\t"
"sc %1, %2\n\t"
+ ".set pop\n\t"
"beqz %1, 0b\n\t"
"addiu %0, %0, 1\n\t"
"1:":
diff --git a/boost/boost.ptree.patch b/boost/boost.ptree.patch
deleted file mode 100644
index 3fa98d8..0000000
--- a/boost/boost.ptree.patch
+++ /dev/null
@@ -1,11 +0,0 @@
--- misc/build/boost_1_44_0/boost/property_tree/detail/json_parser_read.hpp 2013-04-22 18:22:16.961642320 +0200
+++ misc/build/boost_1_44_0/boost/property_tree/detail/json_parser_read.hpp 2013-04-22 18:22:59.991632602 +0200
@@ -102,7 +102,7 @@
void operator()(It b, It e) const
{
BOOST_ASSERT(c.stack.size() >= 1);
- c.stack.back()->push_back(std::make_pair(c.name, Str(b, e)));
+ c.stack.back()->push_back(std::make_pair(c.name, Ptree(Str(b, e))));
c.name.clear();
c.string.clear();
}
diff --git a/boost/boost.wshadow.patch b/boost/boost.wshadow.patch
new file mode 100644
index 0000000..d905d8b
--- /dev/null
+++ b/boost/boost.wshadow.patch
@@ -0,0 +1,399 @@
--- foo/foo/foo/boost/math/special_functions/detail/bessel_jy_series.hpp
+++ foo/foo/foo/boost/math/special_functions/detail/bessel_jy_series.hpp
@@ -194,9 +194,9 @@
}
else
{
- int s;
- prefix = boost::math::lgamma(-v, &s, pol) + p;
- prefix = exp(prefix) * s / constants::pi<T>();
+ int s_lcl;
+ prefix = boost::math::lgamma(-v, &s_lcl, pol) + p;
+ prefix = exp(prefix) * s_lcl / constants::pi<T>();
}
bessel_y_small_z_series_term_b<T, Policy> s2(v, x);
max_iter = policies::get_max_series_iterations<Policy>();
--- foo/foo/foo/boost/math/special_functions/ellint_rj.hpp
+++ foo/foo/foo/boost/math/special_functions/ellint_rj.hpp
@@ -91,11 +91,11 @@
BOOST_ASSERT(pmy >= 0);
- T p = pmy + y;
- value = boost::math::ellint_rj(x, y, z, p, pol);
+ T p_lcl = pmy + y;
+ value = boost::math::ellint_rj(x, y, z, p_lcl, pol);
value *= pmy;
value -= 3 * boost::math::ellint_rf(x, y, z, pol);
- value += 3 * sqrt((x * y * z) / (x * z + p * q)) * boost::math::ellint_rc(x * z + p * q, p * q, pol);
+ value += 3 * sqrt((x * y * z) / (x * z + p_lcl * q)) * boost::math::ellint_rc(x * z + p_lcl * q, p_lcl * q, pol);
value /= (y + q);
return value;
}
--- foo/foo/foo/boost/random/binomial_distribution.hpp
+++ foo/foo/foo/boost/random/binomial_distribution.hpp
@@ -272,21 +272,21 @@
using std::sqrt;
using std::pow;
- RealType p = (0.5 < _p)? (1 - _p) : _p;
- IntType t = _t;
+ RealType p_lcl = (0.5 < _p)? (1 - _p) : _p;
+ IntType t_lcl = _t;
- m = static_cast<IntType>((t+1)*p);
+ m = static_cast<IntType>((t_lcl+1)*p_lcl);
if(use_inversion()) {
- q_n = pow((1 - p), static_cast<RealType>(t));
+ q_n = pow((1 - p_lcl), static_cast<RealType>(t_lcl));
} else {
- btrd.r = p/(1-p);
- btrd.nr = (t+1)*btrd.r;
- btrd.npq = t*p*(1-p);
+ btrd.r = p_lcl/(1-p_lcl);
+ btrd.nr = (t_lcl+1)*btrd.r;
+ btrd.npq = t_lcl*p_lcl*(1-p_lcl);
RealType sqrt_npq = sqrt(btrd.npq);
btrd.b = 1.15 + 2.53 * sqrt_npq;
- btrd.a = -0.0873 + 0.0248*btrd.b + 0.01*p;
- btrd.c = t*p + 0.5;
+ btrd.a = -0.0873 + 0.0248*btrd.b + 0.01*p_lcl;
+ btrd.c = t_lcl*p_lcl + 0.5;
btrd.alpha = (2.83 + 5.1/btrd.b) * sqrt_npq;
btrd.v_r = 0.92 - 4.2/btrd.b;
btrd.u_rv_r = 0.86*btrd.v_r;
@@ -304,9 +304,9 @@
RealType u;
RealType v = uniform_01<RealType>()(urng);
if(v <= btrd.u_rv_r) {
- RealType u = v/btrd.v_r - 0.43;
+ RealType u_lcl = v/btrd.v_r - 0.43;
return static_cast<IntType>(floor(
- (2*btrd.a/(0.5 - abs(u)) + btrd.b)*u + btrd.c));
+ (2*btrd.a/(0.5 - abs(u_lcl)) + btrd.b)*u_lcl + btrd.c));
}
if(v >= btrd.v_r) {
@@ -344,9 +344,9 @@
v = log(v);
RealType rho =
(km/btrd.npq)*(((km/3. + 0.625)*km + 1./6)/btrd.npq + 0.5);
- RealType t = -km*km/(2*btrd.npq);
- if(v < t - rho) return k;
- if(v > t + rho) continue;
+ RealType t_lcl = -km*km/(2*btrd.npq);
+ if(v < t_lcl - rho) return k;
+ if(v > t_lcl + rho) continue;
IntType nm = _t - m + 1;
RealType h = (m + 0.5)*log((m + 1)/(btrd.r*nm))
@@ -367,11 +367,11 @@
}
template<class URNG>
- IntType invert(IntType t, RealType p, URNG& urng) const
+ IntType invert(IntType t_arg, RealType p_arg, URNG& urng) const
{
- RealType q = 1 - p;
- RealType s = p / q;
- RealType a = (t + 1) * s;
+ RealType q = 1 - p_arg;
+ RealType s = p_arg / q;
+ RealType a = (t_arg + 1) * s;
RealType r = q_n;
RealType u = uniform_01<RealType>()(urng);
IntType x = 0;
--- foo/foo/foo/boost/random/geometric_distribution.hpp
+++ foo/foo/foo/boost/random/geometric_distribution.hpp
@@ -104,8 +104,8 @@
*
* Requires: 0 < p < 1
*/
- explicit geometric_distribution(const RealType& p = RealType(0.5))
- : _p(p)
+ explicit geometric_distribution(const RealType& p_arg = RealType(0.5))
+ : _p(p_arg)
{
BOOST_ASSERT(RealType(0) < _p && _p < RealType(1));
init();
--- foo/foo/foo/boost/random/shuffle_order.hpp
+++ foo/foo/foo/boost/random/shuffle_order.hpp
@@ -200,8 +200,8 @@
}
/** Returns true if the two generators will produce identical sequences. */
- BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(shuffle_order_engine, x, y)
- { return x._rng == y._rng && x.y == y.y && std::equal(x.v, x.v+k, y.v); }
+ BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(shuffle_order_engine, x, y_arg)
+ { return x._rng == y_arg._rng && x.y == y_arg.y && std::equal(x.v, x.v+k, y_arg.v); }
/** Returns true if the two generators will produce different sequences. */
BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(shuffle_order_engine)
--- foo/foo/foo/boost/random/subtract_with_carry.hpp
+++ foo/foo/foo/boost/random/subtract_with_carry.hpp
@@ -268,21 +268,21 @@
friend struct detail::subtract_with_carry_discard;
- IntType do_update(std::size_t current, std::size_t short_index, IntType carry)
+ IntType do_update(std::size_t current, std::size_t short_index, IntType carry_arg)
{
IntType delta;
- IntType temp = x[current] + carry;
+ IntType temp = x[current] + carry_arg;
if (x[short_index] >= temp) {
// x(n) >= 0
delta = x[short_index] - temp;
- carry = 0;
+ carry_arg = 0;
} else {
// x(n) < 0
delta = modulus - temp + x[short_index];
- carry = 1;
+ carry_arg = 1;
}
x[current] = delta;
- return carry;
+ return carry_arg;
}
/// \endcond
@@ -498,17 +498,17 @@
friend struct detail::subtract_with_carry_discard;
- RealType do_update(std::size_t current, std::size_t short_index, RealType carry)
+ RealType do_update(std::size_t current, std::size_t short_index, RealType carry_arg)
{
- RealType delta = x[short_index] - x[current] - carry;
+ RealType delta = x[short_index] - x[current] - carry_arg;
if(delta < 0) {
delta += RealType(1);
- carry = RealType(1)/_modulus;
+ carry_arg = RealType(1)/_modulus;
} else {
- carry = 0;
+ carry_arg = 0;
}
x[current] = delta;
- return carry;
+ return carry_arg;
}
/// \endcond
std::size_t k;
--- foo/foo/foo/boost/smart_ptr/detail/allocate_array_helper.hpp
+++ foo/foo/foo/boost/smart_ptr/detail/allocate_array_helper.hpp
@@ -33,10 +33,10 @@
struct rebind {
typedef allocate_array_helper<A, T[], U> other;
};
- allocate_array_helper(const A& allocator, std::size_t size, T** data)
- : allocator(allocator),
- size(sizeof(T) * size),
- data(data) {
+ allocate_array_helper(const A& allocator_arg, std::size_t size_arg, T** data_arg)
+ : allocator(allocator_arg),
+ size(sizeof(T) * size_arg),
+ data(data_arg) {
}
template<class U>
allocate_array_helper(const allocate_array_helper<A, T[], U>& other)
@@ -107,9 +107,9 @@
struct rebind {
typedef allocate_array_helper<A, T[N], U> other;
};
- allocate_array_helper(const A& allocator, T** data)
- : allocator(allocator),
- data(data) {
+ allocate_array_helper(const A& allocator_arg, T** data_arg)
+ : allocator(allocator_arg),
+ data(data_arg) {
}
template<class U>
allocate_array_helper(const allocate_array_helper<A, T[N], U>& other)
--- foo/foo/foo/boost/smart_ptr/detail/array_deleter.hpp
+++ foo/foo/foo/boost/smart_ptr/detail/array_deleter.hpp
@@ -20,8 +20,8 @@
template<typename T>
class array_deleter<T[]> {
public:
- array_deleter(std::size_t size)
- : size(size),
+ array_deleter(std::size_t size_arg)
+ : size(size_arg),
object(0) {
}
~array_deleter() {
--- foo/foo/foo/boost/smart_ptr/detail/make_array_helper.hpp
+++ foo/foo/foo/boost/smart_ptr/detail/make_array_helper.hpp
@@ -31,9 +31,9 @@
struct rebind {
typedef make_array_helper<T[], U> other;
};
- make_array_helper(std::size_t size, T** data)
- : size(sizeof(T) * size),
- data(data) {
+ make_array_helper(std::size_t size_arg, T** data_arg)
+ : size(sizeof(T) * size_arg),
+ data(data_arg) {
}
template<class U>
make_array_helper(const make_array_helper<T[], U>& other)
@@ -99,8 +99,8 @@
struct rebind {
typedef make_array_helper<T[N], U> other;
};
- make_array_helper(T** data)
- : data(data) {
+ make_array_helper(T** data_arg)
+ : data(data_arg) {
}
template<class U>
make_array_helper(const make_array_helper<T[N], U>& other)
--- foo/foo/foo/boost/unordered/detail/equivalent.hpp
+++ foo/foo/foo/boost/unordered/detail/equivalent.hpp
@@ -536,9 +536,9 @@
node_pointer first_node = static_cast<node_pointer>(prev->next_);
link_pointer end = first_node->group_prev_->next_;
- std::size_t count = this->delete_nodes(prev, end);
+ std::size_t count_lcl = this->delete_nodes(prev, end);
this->fix_bucket(bucket_index, prev);
- return count;
+ return count_lcl;
}
iterator erase(c_iterator r)
@@ -557,21 +557,21 @@
return iterator(r2.node_);
}
- link_pointer erase_nodes(node_pointer begin, node_pointer end)
+ link_pointer erase_nodes(node_pointer begin_arg, node_pointer end)
{
- std::size_t bucket_index = this->hash_to_bucket(begin->hash_);
+ std::size_t bucket_index = this->hash_to_bucket(begin_arg->hash_);
- // Split the groups containing 'begin' and 'end'.
- // And get the pointer to the node before begin while
+ // Split the groups containing 'begin_arg' and 'end.'
+ // And get the pointer to the node before begin_arg while
// we're at it.
- link_pointer prev = split_groups(begin, end);
+ link_pointer prev = split_groups(begin_arg, end);
- // If we don't have a 'prev' it means that begin is at the
+ // If we don't have a 'prev' it means that begin_arg is at the
// beginning of a block, so search through the blocks in the
// same bucket.
if (!prev) {
prev = this->get_previous_start(bucket_index);
- while (prev->next_ != begin)
+ while (prev->next_ != begin_arg)
prev = static_cast<node_pointer>(prev->next_)->group_prev_;
}
@@ -586,27 +586,27 @@
return prev;
}
- static link_pointer split_groups(node_pointer begin, node_pointer end)
+ static link_pointer split_groups(node_pointer begin_arg, node_pointer end)
{
- node_pointer prev = begin->group_prev_;
- if (prev->next_ != begin) prev = node_pointer();
+ node_pointer prev = begin_arg->group_prev_;
+ if (prev->next_ != begin_arg) prev = node_pointer();
if (end) {
node_pointer first = end;
- while (first != begin && first->group_prev_->next_ == first) {
+ while (first != begin_arg && first->group_prev_->next_ == first) {
first = first->group_prev_;
}
boost::swap(first->group_prev_, end->group_prev_);
- if (first == begin) return prev;
+ if (first == begin_arg) return prev;
}
if (prev) {
node_pointer first = prev;
while (first->group_prev_->next_ == first) {
first = first->group_prev_;
}
- boost::swap(first->group_prev_, begin->group_prev_);
+ boost::swap(first->group_prev_, begin_arg->group_prev_);
}
return prev;
--- foo/foo/foo/boost/unordered/detail/table.hpp
+++ foo/foo/foo/boost/unordered/detail/table.hpp
@@ -256,9 +256,9 @@
return prev ? iterator(prev->next_) : iterator();
}
- std::size_t hash_to_bucket(std::size_t hash) const
+ std::size_t hash_to_bucket(std::size_t hash_arg) const
{
- return policy::to_bucket(bucket_count_, hash);
+ return policy::to_bucket(bucket_count_, hash_arg);
}
float load_factor() const
@@ -655,8 +655,8 @@
// assign_nodes takes ownership of the container's elements,
// assigning to them if possible, and deleting any that are
// left over.
- assign_nodes<table> assign(*this);
- table_impl::fill_buckets(x.begin(), *this, assign);
+ assign_nodes<table> assign_lcl(*this);
+ table_impl::fill_buckets(x.begin(), *this, assign_lcl);
}
void assign(table const& x, true_type)
@@ -732,9 +732,9 @@
// move_assign_nodes takes ownership of the container's
// elements, assigning to them if possible, and deleting
// any that are left over.
- move_assign_nodes<table> assign(*this);
+ move_assign_nodes<table> assign_lcl(*this);
node_holder<node_allocator> nodes(x);
- table_impl::fill_buckets(nodes.begin(), *this, assign);
+ table_impl::fill_buckets(nodes.begin(), *this, assign_lcl);
}
}
--- foo/foo/foo/boost/unordered/detail/unique.hpp
+++ foo/foo/foo/boost/unordered/detail/unique.hpp
@@ -531,9 +531,9 @@
link_pointer end = static_cast<node_pointer>(prev->next_)->next_;
- std::size_t count = this->delete_nodes(prev, end);
+ std::size_t count_lcl = this->delete_nodes(prev, end);
this->fix_bucket(bucket_index, prev);
- return count;
+ return count_lcl;
}
iterator erase(c_iterator r)
@@ -552,13 +552,13 @@
return iterator(r2.node_);
}
- void erase_nodes(node_pointer begin, node_pointer end)
+ void erase_nodes(node_pointer begin_arg, node_pointer end)
{
- std::size_t bucket_index = this->hash_to_bucket(begin->hash_);
+ std::size_t bucket_index = this->hash_to_bucket(begin_arg->hash_);
- // Find the node before begin.
+ // Find the node before begin_arg.
link_pointer prev = this->get_previous_start(bucket_index);
- while(prev->next_ != begin) prev = prev->next_;
+ while(prev->next_ != begin_arg) prev = prev->next_;
// Delete the nodes.
do {
diff --git a/boost/boost.wundef.patch b/boost/boost.wundef.patch
new file mode 100644
index 0000000..a389d50
--- /dev/null
+++ b/boost/boost.wundef.patch
@@ -0,0 +1,66 @@
--- foo/foo/foo/boost/multi_array/base.hpp
+++ foo/foo/foo/boost/multi_array/base.hpp
@@ -65,7 +65,7 @@
// object creation in small-memory environments. Thus, the objects
// can be left undefined by defining BOOST_MULTI_ARRAY_NO_GENERATORS
// before loading multi_array.hpp.
-#if !BOOST_MULTI_ARRAY_NO_GENERATORS
+#if !defined(BOOST_MULTI_ARRAY_NO_GENERATORS) || !BOOST_MULTI_ARRAY_NO_GENERATORS
namespace {
multi_array_types::extent_gen extents;
multi_array_types::index_gen indices;
--- foo/foo/foo/boost/preprocessor/tuple/elem.hpp
+++ foo/foo/foo/boost/preprocessor/tuple/elem.hpp
@@ -22,7 +22,7 @@
# include <boost/preprocessor/variadic/elem.hpp>
#
# if BOOST_PP_VARIADICS
-# if BOOST_PP_VARIADICS_MSVC
+# if defined(BOOST_PP_VARIADICS_MSVC) && BOOST_PP_VARIADICS_MSVC
# define BOOST_PP_TUPLE_ELEM(...) BOOST_PP_TUPLE_ELEM_I(BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_ELEM_O_, __VA_ARGS__), (__VA_ARGS__))
# define BOOST_PP_TUPLE_ELEM_I(m, args) BOOST_PP_TUPLE_ELEM_II(m, args)
# define BOOST_PP_TUPLE_ELEM_II(m, args) BOOST_PP_CAT(m ## args,)
--- foo/foo/foo/boost/preprocessor/tuple/rem.hpp
+++ foo/foo/foo/boost/preprocessor/tuple/rem.hpp
@@ -105,7 +105,7 @@
# /* BOOST_PP_TUPLE_REM_CTOR */
#
# if BOOST_PP_VARIADICS
-# if BOOST_PP_VARIADICS_MSVC
+# if defined(BOOST_PP_VARIADICS_MSVC) && BOOST_PP_VARIADICS_MSVC
# define BOOST_PP_TUPLE_REM_CTOR(...) BOOST_PP_TUPLE_REM_CTOR_I(BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_REM_CTOR_O_, __VA_ARGS__), (__VA_ARGS__))
# define BOOST_PP_TUPLE_REM_CTOR_I(m, args) BOOST_PP_TUPLE_REM_CTOR_II(m, args)
# define BOOST_PP_TUPLE_REM_CTOR_II(m, args) BOOST_PP_CAT(m ## args,)
--- foo/foo/foo/boost/preprocessor/tuple/to_list.hpp
+++ foo/foo/foo/boost/preprocessor/tuple/to_list.hpp
@@ -23,7 +23,7 @@
# /* BOOST_PP_TUPLE_TO_LIST */
#
# if BOOST_PP_VARIADICS
-# if BOOST_PP_VARIADICS_MSVC
+# if defined(BOOST_PP_VARIADICS_MSVC) && BOOST_PP_VARIADICS_MSVC
# define BOOST_PP_TUPLE_TO_LIST(...) BOOST_PP_TUPLE_TO_LIST_I(BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_TO_LIST_O_, __VA_ARGS__), (__VA_ARGS__))
# define BOOST_PP_TUPLE_TO_LIST_I(m, args) BOOST_PP_TUPLE_TO_LIST_II(m, args)
# define BOOST_PP_TUPLE_TO_LIST_II(m, args) BOOST_PP_CAT(m ## args,)
--- foo/foo/foo/boost/preprocessor/variadic/elem.hpp
+++ foo/foo/foo/boost/preprocessor/variadic/elem.hpp
@@ -19,7 +19,7 @@
# /* BOOST_PP_VARIADIC_ELEM */
#
# if BOOST_PP_VARIADICS
-# if BOOST_PP_VARIADICS_MSVC
+# if defined(BOOST_PP_VARIADICS_MSVC) && BOOST_PP_VARIADICS_MSVC
# define BOOST_PP_VARIADIC_ELEM(n, ...) BOOST_PP_VARIADIC_ELEM_I(n,__VA_ARGS__)
# define BOOST_PP_VARIADIC_ELEM_I(n, ...) BOOST_PP_CAT(BOOST_PP_CAT(BOOST_PP_VARIADIC_ELEM_, n)(__VA_ARGS__,),)
# else
--- foo/foo/foo/boost/preprocessor/variadic/size.hpp
+++ foo/foo/foo/boost/preprocessor/variadic/size.hpp
@@ -19,7 +19,7 @@
# /* BOOST_PP_VARIADIC_SIZE */
#
# if BOOST_PP_VARIADICS
-# if BOOST_PP_VARIADICS_MSVC
+# if defined(BOOST_PP_VARIADICS_MSVC) && BOOST_PP_VARIADICS_MSVC
# define BOOST_PP_VARIADIC_SIZE(...) BOOST_PP_CAT(BOOST_PP_VARIADIC_SIZE_I(__VA_ARGS__, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,),)
# else
# define BOOST_PP_VARIADIC_SIZE(...) BOOST_PP_VARIADIC_SIZE_I(__VA_ARGS__, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,)
diff --git a/boost/boost.wundef.patch.1 b/boost/boost.wundef.patch.1
deleted file mode 100644
index cbdac45..0000000
--- a/boost/boost.wundef.patch.1
+++ /dev/null
@@ -1,54 +0,0 @@
--- a/boost/multi_array/base.hpp 2013-04-01 13:53:59.565375431 +0200
+++ b/boost/multi_array/base.hpp 2013-04-01 13:54:03.230375652 +0200
@@ -65,7 +65,7 @@
// object creation in small-memory environments. Thus, the objects
// can be left undefined by defining BOOST_MULTI_ARRAY_NO_GENERATORS
// before loading multi_array.hpp.
-#if !BOOST_MULTI_ARRAY_NO_GENERATORS
+#ifndef BOOST_MULTI_ARRAY_NO_GENERATORS
namespace {
multi_array_types::extent_gen extents;
multi_array_types::index_gen indices;
--- a/boost/interprocess/detail/workaround.hpp
+++ a/boost/interprocess/detail/workaround.hpp
@@ -29,19 +29,19 @@
#include <unistd.h>
- #if ((_POSIX_THREAD_PROCESS_SHARED - 0) > 0)
+ #if defined(_POSIX_THREAD_PROCESS_SHARED) && ((_POSIX_THREAD_PROCESS_SHARED - 0) > 0)
//Cygwin defines _POSIX_THREAD_PROCESS_SHARED but does not implement it.
//Mac Os X >= Leopard defines _POSIX_THREAD_PROCESS_SHARED but does not seems to work.
# if !defined(__CYGWIN__) && !defined(__APPLE__)
# define BOOST_INTERPROCESS_POSIX_PROCESS_SHARED
# endif
#endif
- #if ((_POSIX_BARRIERS - 0) > 0)
+ #if defined(_POSIX_BARRIERS) && ((_POSIX_BARRIERS - 0) > 0)
# define BOOST_INTERPROCESS_POSIX_BARRIERS
# endif
- #if ((_POSIX_SEMAPHORES - 0) > 0)
+ #if defined(_POSIX_SEMAPHORES) && ((_POSIX_SEMAPHORES - 0) > 0)
# define BOOST_INTERPROCESS_POSIX_NAMED_SEMAPHORES
# if defined(__CYGWIN__)
#define BOOST_INTERPROCESS_POSIX_SEMAPHORES_NO_UNLINK
@@ -67,7 +67,7 @@
# define BOOST_INTERPROCESS_XSI_SHARED_MEMORY_OBJECTS
#endif
- #if ((_POSIX_SHARED_MEMORY_OBJECTS - 0) > 0)
+ #if defined(_POSIX_SHARED_MEMORY_OBJECTS) && ((_POSIX_SHARED_MEMORY_OBJECTS - 0) > 0)
# define BOOST_INTERPROCESS_POSIX_SHARED_MEMORY_OBJECTS
#else
//VMS and MACOS don't define it but the have shm_open/close interface
@@ -88,7 +88,7 @@
//# define BOOST_INTERPROCESS_XSI_SHARED_MEMORY_OBJECTS_ONLY
#endif
- #if ((_POSIX_TIMEOUTS - 0) > 0)
+ #if defined(_POSIX_TIMEOUTS) && ((_POSIX_TIMEOUTS - 0) > 0)
# define BOOST_INTERPROCESS_POSIX_TIMEOUTS
#endif
diff --git a/boost/boost_1_44_0-clang-warnings.patch b/boost/boost_1_44_0-clang-warnings.patch
index d577205..c5bccaf 100644
--- a/boost/boost_1_44_0-clang-warnings.patch
+++ b/boost/boost_1_44_0-clang-warnings.patch
@@ -1,74 +1,14 @@
--- misc/boost_1_44_0/boost/algorithm/string/detail/find_format_store.hpp 2010-07-10 22:29:03.000000000 +0200
+++ misc/build/boost_1_44_0/boost/algorithm/string/detail/find_format_store.hpp 2012-06-06 23:13:26.000000000 +0200
@@ -71,7 +71,7 @@
};
--- misc/boost_1_44_0/boost/math/tools/fraction.hpp
+++ misc/build/boost_1_44_0/boost/math/tools/fraction.hpp
@@ -33,7 +33,7 @@
typedef typename Gen::result_type result_type;
typedef typename Gen::result_type value_type;
template<typename InputT, typename FindResultT>
- bool check_find_result(InputT& Input, FindResultT& FindResult)
+ bool check_find_result(InputT&, FindResultT& FindResult)
{
typedef BOOST_STRING_TYPENAME
range_const_iterator<InputT>::type input_iterator_type;
--- misc/boost_1_44_0/boost/concept_check.hpp
+++ misc/build/boost_1_44_0/boost/concept_check.hpp
@@ -136,7 +136,18 @@ namespace boost
{
BOOST_CONCEPT_USAGE(Assignable) {
#if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL
+#if defined __clang__
+#if __has_warning("-Wself-assign-field")
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wself-assign-field"
+#endif
+#endif
a = a; // require assignment operator
+#if defined __clang__
+#if __has_warning("-Wself-assign-field")
+#pragma clang diagnostic pop
+#endif
+#endif
#endif
const_constraints(a);
}
--- misc/boost_1_44_0/boost/date_time/dst_rules.hpp 2008-02-27 21:00:24.000000000 +0100
+++ misc/build/boost_1_44_0/boost/date_time/dst_rules.hpp 2012-06-06 23:11:03.000000000 +0200
@@ -371,7 +371,7 @@
return is_not_in_dst;
}
- static bool is_dst_boundary_day(date_type d)
+ static bool is_dst_boundary_day(date_type)
{
return false;
}
--- misc/boost_1_44_0/boost/date_time/gregorian_calendar.ipp 2010-01-10 20:17:23.000000000 +0100
+++ misc/build/boost_1_44_0/boost/date_time/gregorian_calendar.ipp 2012-06-06 22:27:07.000000000 +0200
@@ -47,7 +47,7 @@
return week;
}
- if ((week == 53)) {
+ if (week == 53) {
if((day==6) ||(day == 5 && is_leap_year(ymd.year))) {
return week; //under these circumstances week == 53.
} else {
--- misc/boost_1_44_0/boost/date_time/period_formatter.hpp 2008-02-27 21:00:24.000000000 +0100
+++ misc/build/boost_1_44_0/boost/date_time/period_formatter.hpp 2012-06-06 23:12:48.000000000 +0200
@@ -114,10 +114,10 @@
{
m_range_option = option;
}
- void delimiter_strings(const string_type& separator,
- const string_type& start_delim,
- const string_type& open_end_delim,
- const string_type& closed_end_delim)
+ void delimiter_strings(const string_type&,
+ const string_type&,
+ const string_type&,
+ const string_type&)
{
m_period_separator;
m_period_start_delimeter;
- static result_type a(const value_type& v)
+ static result_type a(const value_type&)
{
return 1;
}
--- misc/boost_1_44_0/boost/token_functions.hpp 2010-06-12 14:06:28.000000000 +0200
+++ misc/build/boost_1_44_0/boost/token_functions.hpp 2012-06-06 23:12:27.000000000 +0200
@@ -285,7 +285,7 @@
@@ -90,8 +30,8 @@
+#pragma GCC system_header
+#endif
+
#include <boost/config/no_tr1/cmath.hpp>
#include <iostream>
#include <istream>
#include <iosfwd>
#include <algorithm> // std::max
--- misc/boost_1_44_0/boost/random/shuffle_output.hpp
+++ misc/build/boost_1_44_0/boost/random/shuffle_output.hpp
@@ -103,9 +43,9 @@
+#pragma GCC system_header
+#endif
+
#include <iostream>
#include <algorithm> // std::copy
#include <cassert>
#include <boost/random/shuffle_order.hpp>
namespace boost {
--- misc/boost_1_44_0/boost/random/subtract_with_carry.hpp
+++ misc/build/boost_1_44_0/boost/random/subtract_with_carry.hpp
@@ -16,6 +16,10 @@
@@ -116,34 +56,26 @@
+#pragma GCC system_header
+#endif
+
#include <boost/config/no_tr1/cmath.hpp>
#include <boost/config/no_tr1/cmath.hpp> // std::pow
#include <iostream>
#include <algorithm> // std::equal
--- misc/boost_1_44_0/boost/uuid/name_generator.hpp
+++ misc/build/boost_1_44_0/boost/uuid/name_generator.hpp
@@ -72,10 +72,10 @@
for (size_t i=0; i<count; i++) {
uint32_t c = characters[i];
- sha.process_byte( (c >> 0) && 0xFF );
- sha.process_byte( (c >> 8) && 0xFF );
- sha.process_byte( (c >> 16) && 0xFF );
- sha.process_byte( (c >> 24) && 0xFF );
+ sha.process_byte( (c >> 0) & 0xFF );
+ sha.process_byte( (c >> 8) & 0xFF );
+ sha.process_byte( (c >> 16) & 0xFF );
+ sha.process_byte( (c >> 24) & 0xFF );
}
}
--- misc/boost_1_44_0/boost/random/discard_block.hpp
+++ misc/build/boost_1_44_0/boost/random/discard_block.hpp
@@ -76,7 +76,7 @@
result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () const { return (_rng.min)(); }
result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () const { return (_rng.max)(); }
- static bool validation(result_type x) { return true; } // dummy
+ static bool validation(result_type) { return true; } // dummy
#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
--- misc/boost_1_44_0/boost/smart_ptr/detail/make_array_helper.hpp
+++ misc/build/boost_1_44_0/boost/smart_ptr/detail/make_array_helper.hpp
@@ -72,7 +72,7 @@
memory->~Y();
}
template<typename U>
- bool operator==(const make_array_helper<T[], U>& other) const {
+ bool operator==(const make_array_helper<T[], U>&) const {
return true;
}
template<typename U>
@@ -138,7 +138,7 @@
memory->~Y();
}
template<typename U>
- bool operator==(const make_array_helper<T[N], U>& other) const {
+ bool operator==(const make_array_helper<T[N], U>&) const {
return true;
}
template<typename U>
diff --git a/boost/boost_1_44_0-gcc4.7.patch b/boost/boost_1_44_0-gcc4.7.patch
deleted file mode 100644
index 842a92a..0000000
--- a/boost/boost_1_44_0-gcc4.7.patch
+++ /dev/null
@@ -1,49 +0,0 @@
--- misc/boost_1_44_0/boost/smart_ptr/shared_ptr.hpp 2009-12-14 18:44:19.000000000 +0100
+++ misc/build/boost_1_44_0/boost/smart_ptr/shared_ptr.hpp 2012-03-28 08:32:46.772493003 +0200
@@ -207,7 +207,17 @@
boost::detail::sp_enable_shared_from_this( this, p, p );
}
-// generated copy constructor, destructor are fine
+// generated copy constructor, destructor are fine...
+
+#if defined( BOOST_HAS_RVALUE_REFS )
+
+// ... except in C++0x, move disables the implicit copy
+
+ shared_ptr( shared_ptr const & r ): px( r.px ), pn( r.pn ) // never throws
+ {
+ }
+
+#endif
template<class Y>
explicit shared_ptr(weak_ptr<Y> const & r): pn(r.pn) // may throw
--- misc/boost_1_44_0/boost/smart_ptr/weak_ptr.hpp 2009-12-14 18:44:19.000000000 +0100
+++ misc/build/boost_1_44_0/boost/smart_ptr/weak_ptr.hpp 2012-03-28 10:31:57.607462325 +0200
@@ -40,8 +40,24 @@
{
}
-// generated copy constructor, assignment, destructor are fine
+// generated copy constructor, assignment, destructor are fine...
+#if defined( BOOST_HAS_RVALUE_REFS )
+
+// ... except in C++0x, move disables the implicit copy
+
+ weak_ptr( weak_ptr const & r ): px( r.px ), pn( r.pn ) // never throws
+ {
+ }
+
+ weak_ptr & operator=( weak_ptr const & r ) // never throws
+ {
+ px = r.px;
+ pn = r.pn;
+ return *this;
+ }
+
+#endif
//
// The "obvious" converting constructor implementation:
diff --git a/boost/boost_1_44_0-gthreads.patch b/boost/boost_1_44_0-gthreads.patch
deleted file mode 100644
index d12b599..0000000
--- a/boost/boost_1_44_0-gthreads.patch
+++ /dev/null
@@ -1,12 +0,0 @@
--- misc/boost_1_44_0/boost/config/stdlib/libstdcpp3.hpp 2010-06-11 13:16:34.000000000 +0200
+++ misc/build/boost_1_44_0/boost/config/stdlib/libstdcpp3.hpp 2012-07-13 10:31:58.330127342 +0200
@@ -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
diff --git a/boost/boost_1_44_0-logical-op-parentheses.patch b/boost/boost_1_44_0-logical-op-parentheses.patch
deleted file mode 100644
index 33a8ea0..0000000
--- a/boost/boost_1_44_0-logical-op-parentheses.patch
+++ /dev/null
@@ -1,12 +0,0 @@
--- misc/boost_1_44_0/boost/spirit/home/classic/core/composite/directives.hpp
+++ misc/build/boost_1_44_0/boost/spirit/home/classic/core/composite/directives.hpp
@@ -364,7 +364,7 @@
if (l || r)
{
- if (l.length() < r.length() && l || !r)
+ if ((l.length() < r.length() && l) || !r)
{
scan.first = save;
return l;
diff --git a/boost/boost_1_44_0-unused-parameters.patch b/boost/boost_1_44_0-unused-parameters.patch
index 79ad4b8..4fe61ba 100644
--- a/boost/boost_1_44_0-unused-parameters.patch
+++ b/boost/boost_1_44_0-unused-parameters.patch
@@ -409,14 +409,14 @@
template<class T>
inline
-bool operator == ( none_t x, optional<T> const& y )
+bool operator == ( __attribute__ ((unused)) none_t x, optional<T> const& y )
-bool operator == ( none_t , optional<T> const& y )
+bool operator == ( __attribute__ ((unused)) none_t , optional<T> const& y )
{ return equal_pointees(optional<T>() ,y); }
template<class T>
inline
-bool operator < ( none_t x, optional<T> const& y )
+bool operator < ( __attribute__ ((unused)) none_t x, optional<T> const& y )
-bool operator < ( none_t , optional<T> const& y )
+bool operator < ( __attribute__ ((unused)) none_t , optional<T> const& y )
{ return less_pointees(optional<T>() ,y); }
template<class T>
@@ -726,37 +726,6 @@
template<class E> BOOST_ATTRIBUTE_NORETURN inline void throw_exception( E const & e )
{
--- misc/boost_1_44_0/boost/unordered/detail/node.hpp 2009-09-24 23:12:46.000000000 +0200
+++ misc/build/boost_1_44_0/boost/unordered/detail/node.hpp 2012-01-20 12:44:07.128316328 +0100
@@ -35,7 +35,7 @@
}
template <class A>
- inline std::size_t ungrouped_node_base<A>::group_count(node_ptr)
+ inline std::size_t ungrouped_node_base<A>::group_count(__attribute__ ((unused)) node_ptr)
{
return 1;
}
--- misc/boost_1_44_0/boost/unordered/detail/util.hpp 2010-02-25 20:05:01.000000000 +0100
+++ misc/build/boost_1_44_0/boost/unordered/detail/util.hpp 2012-01-20 12:44:07.128316328 +0100
@@ -149,7 +149,7 @@
#if defined(BOOST_UNORDERED_STD_FORWARD)
template <class T, class... Args>
- inline void construct_impl(T*, void* address, Args&&... args)
+ inline void construct_impl(__attribute__ ((unused)) T*, void* address, Args&&... args)
{
new(address) T(std::forward<Args>(args)...);
}
@@ -262,7 +262,7 @@
#endif
template <class K, class M>
- void construct_pair(K const& k, M*)
+ void construct_pair(K const& k, __attribute__ ((unused)) M*)
{
construct_preamble();
new(node_->address()) value_type(k, M());
--- misc/boost_1_44_0/boost/utility/addressof.hpp 2009-05-16 20:15:17.000000000 +0200
+++ misc/build/boost_1_44_0/boost/utility/addressof.hpp 2012-01-20 12:44:07.128316328 +0100
@@ -34,7 +34,7 @@
@@ -862,8 +831,8 @@
}
template <typename U>
- bool operator()(U&)
+ bool operator()(__attribute__ ((unused)) U&)
- bool operator()(U&) BOOST_NOEXCEPT
+ bool operator()(__attribute__ ((unused)) U&) BOOST_NOEXCEPT
{
return false;
}
@@ -921,44 +890,6 @@
{
typedef typename has_nothrow_copy<RhsT>::type
nothrow_copy;
--- misc/boost_1_44_0/libs/date_time/src/gregorian/greg_month.cpp 2012-01-20 15:24:32.362576125 +0100
+++ misc/build/boost_1_44_0/libs/date_time/src/gregorian/greg_month.cpp 2012-01-20 12:44:07.130316320 +0100
@@ -108,7 +108,7 @@
*/
BOOST_DATE_TIME_DECL
boost::date_time::all_date_names_put<greg_facet_config, char>*
- create_facet_def(char /* type */)
+ create_facet_def(__attribute__ ((unused)) char /* type */)
{
typedef
boost::date_time::all_date_names_put<greg_facet_config, char> facet_def;
@@ -121,7 +121,7 @@
}
//! generates a locale with the set of gregorian name-strings of type char*
- BOOST_DATE_TIME_DECL std::locale generate_locale(std::locale& loc, char /* type */){
+ BOOST_DATE_TIME_DECL std::locale generate_locale(std::locale& loc, __attribute__ ((unused)) char /* type */){
typedef boost::date_time::all_date_names_put<greg_facet_config, char> facet_def;
return std::locale(loc, new facet_def(short_month_names,
long_month_names,
@@ -139,7 +139,7 @@
*/
BOOST_DATE_TIME_DECL
boost::date_time::all_date_names_put<greg_facet_config, wchar_t>*
- create_facet_def(wchar_t /* type */)
+ create_facet_def(__attribute__ ((unused)) wchar_t /* type */)
{
typedef
boost::date_time::all_date_names_put<greg_facet_config,wchar_t> facet_def;
@@ -152,7 +152,7 @@
}
//! generates a locale with the set of gregorian name-strings of type wchar_t*
- BOOST_DATE_TIME_DECL std::locale generate_locale(std::locale& loc, wchar_t /* type */){
+ BOOST_DATE_TIME_DECL std::locale generate_locale(std::locale& loc, __attribute__ ((unused)) wchar_t /* type */){
typedef boost::date_time::all_date_names_put<greg_facet_config, wchar_t> facet_def;
return std::locale(loc, new facet_def(w_short_month_names,
w_long_month_names,
--- misc/boost_1_44_0/boost/ptr_container/detail/default_deleter.hpp
+++ misc/build/boost_1_44_0/boost/ptr_container/detail/default_deleter.hpp
@@ -61,7 +61,7 @@
diff --git a/download.lst b/download.lst
index 38466ab..50ecc7f 100644
--- a/download.lst
+++ b/download.lst
@@ -12,7 +12,7 @@ export APACHE_COMMONS_CODEC_TARBALL := 2e482c7567908d334785ce7d69ddfff7-commons-
export APACHE_COMMONS_HTTPCLIENT_TARBALL := 2c9b0f83ed5890af02c0df1c1776f39b-commons-httpclient-3.1-src.tar.gz
export APACHE_COMMONS_LANG_TARBALL := 625ff5f2f968dd908bca43c9469d6e6b-commons-lang-2.4-src.tar.gz
export APACHE_COMMONS_LOGGING_TARBALL := 3c219630e4302863a9a83d0efde889db-commons-logging-1.1.1-src.tar.gz
export BOOST_TARBALL := f02578f5218f217a9f20e9c30e119c6a-boost_1_44_0.tar.bz2
export BOOST_TARBALL := a00d22605d5dbcfb4c9936a9b35bc4c2-boost_1_53_0.tar.bz2
export BSH_TARBALL := ea570af93c284aa9e5621cd563f54f4d-bsh-2.0b1-src.tar.gz
export CAIRO_TARBALL := f101a9e88b783337b20b2e26dfd26d5f-cairo-1.10.2.tar.gz
export CLUCENE_TARBALL := 48d647fbd8ef8889e5a7f422c1bfda94-clucene-core-2.3.3.4.tar.gz
diff --git a/liborcus/ExternalProject_liborcus.mk b/liborcus/ExternalProject_liborcus.mk
index 6808ec3..b6ae1ee 100644
--- a/liborcus/ExternalProject_liborcus.mk
+++ b/liborcus/ExternalProject_liborcus.mk
@@ -13,6 +13,7 @@ $(eval $(call gb_ExternalProject_use_autoconf,liborcus,build))
$(eval $(call gb_ExternalProject_use_externals,liborcus, \
boost_headers \
boostsystem \
zlib \
))
@@ -36,6 +37,8 @@ liborcus_LIBS+=-lz
endif
ifeq ($(SYSTEM_BOOST),YES)
liborcus_LIBS+=$(BOOST_SYSTEM_LIB)
else
liborcus_LIBS+=$(SOLARLIB) -lboostsystem
endif
ifeq ($(OS),ANDROID)
liborcus_LIBS+=-lgnustl_shared -lm
diff --git a/sc/Library_scfilt.mk b/sc/Library_scfilt.mk
index 5b383c4..014b833 100644
--- a/sc/Library_scfilt.mk
+++ b/sc/Library_scfilt.mk
@@ -28,6 +28,7 @@ $(eval $(call gb_Library_use_custom_headers,scfilt,\
$(eval $(call gb_Library_use_externals,scfilt,\
boost_headers \
boostsystem \
mdds_headers \
))
