diff options
Diffstat (limited to 'boost/boost.4713.warnings.patch')
| -rw-r--r-- | boost/boost.4713.warnings.patch | 881 |
1 files changed, 881 insertions, 0 deletions
diff --git a/boost/boost.4713.warnings.patch b/boost/boost.4713.warnings.patch new file mode 100644 index 000000000000..29653ca79fdd --- /dev/null +++ b/boost/boost.4713.warnings.patch @@ -0,0 +1,881 @@ +--- misc/boost_1_44_0/boost/ptr_container/detail/map_iterator.hpp 2008-06-24 22:37:35.000000000 +0200 ++++ misc/build/boost_1_44_0/boost/ptr_container/detail/map_iterator.hpp 2011-02-04 16:39:19.000000000 +0100 +@@ -49,7 +49,7 @@ + : first(rp->first), second(rp->second) + { } + +- const ref_pair* const operator->() const ++ const ref_pair* operator->() const + { + return this; + } +--- misc/boost_1_44_0/boost/ptr_container/ptr_map_adapter.hpp 2008-06-24 22:37:35.000000000 +0200 ++++ misc/build/boost_1_44_0/boost/ptr_container/ptr_map_adapter.hpp 2011-02-04 16:39:19.000000000 +0100 +@@ -477,6 +477,7 @@ + } + + ptr_map_adapter( const ptr_map_adapter& r ) ++ : base_type() + { + map_basic_clone_and_insert( r.begin(), r.end() ); + } +--- misc/boost_1_44_0/boost/ptr_container/ptr_sequence_adapter.hpp 2009-11-01 12:07:12.000000000 +0100 ++++ misc/build/boost_1_44_0/boost/ptr_container/ptr_sequence_adapter.hpp 2011-02-04 16:39:19.000000000 +0100 +@@ -476,19 +476,19 @@ + public: // C-array support + + void transfer( iterator before, value_type* from, +- size_type size, bool delete_from = true ) // strong ++ size_type size_, bool delete_from = true ) // strong + { + BOOST_ASSERT( from != 0 ); + if( delete_from ) + { + BOOST_DEDUCED_TYPENAME base_type::scoped_deleter +- deleter( from, size ); // nothrow +- this->base().insert( before.base(), from, from + size ); // strong ++ deleter( from, size_ ); // nothrow ++ this->base().insert( before.base(), from, from + size_ ); // strong + deleter.release(); // nothrow + } + else + { +- this->base().insert( before.base(), from, from + size ); // strong ++ this->base().insert( before.base(), from, from + size_ ); // strong + } + } + +--- 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 @@ + { + typedef typename ScannerT::iterator_t iterator_t; + iterator_t first = scan.first; +- typename SetT::search_info result = SetT::find(scan); ++ typename SetT::search_info result_ = SetT::find(scan); + +- if (result.data) ++ if (result_.data) + return scan. + create_match( +- result.length, +- symbol_ref_t(*result.data), ++ result_.length, ++ symbol_ref_t(*result_.data), + first, + scan.first); + else +--- misc/boost_1_44_0/boost/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 @@ + { + const char* what_; + public: +- bad_ptr_container_operation( const char* what ) : what_( what ) ++ bad_ptr_container_operation( const char* _what ) : what_( _what ) + { } + + virtual const char* what() const throw() +@@ -38,7 +38,7 @@ + class bad_index : public bad_ptr_container_operation + { + public: +- bad_index( const char* what ) : bad_ptr_container_operation( what ) ++ bad_index( const char* _what ) : bad_ptr_container_operation( _what ) + { } + }; + +--- misc/boost_1_44_0/boost/ptr_container/detail/reversible_ptr_container.hpp 2011-02-05 09:49:30.373931807 +0000 ++++ misc/build/boost_1_44_0/boost/ptr_container/detail/reversible_ptr_container.hpp 2011-02-05 09:49:34.804931932 +0000 +@@ -278,9 +278,9 @@ + + private: + template< class ForwardIterator > +- ForwardIterator advance( ForwardIterator begin, size_type n ) ++ ForwardIterator advance( ForwardIterator begin_, size_type n ) + { +- ForwardIterator iter = begin; ++ ForwardIterator iter = begin_; + std::advance( iter, n ); + return iter; + } +--- misc/boost_1_44_0/boost/ptr_container/detail/static_move_ptr.hpp 2011-02-05 09:55:44.846931338 +0000 ++++ misc/build/boost_1_44_0/boost/ptr_container/detail/static_move_ptr.hpp 2011-02-05 09:56:42.760931701 +0000 +@@ -151,7 +151,7 @@ + deleter_const_reference get_deleter() const { return impl_.second(); } + private: + template<typename TT, typename DD> +- void check(const static_move_ptr<TT, DD>& ptr) ++ void check(const static_move_ptr<TT, DD>&) + { + typedef move_ptrs::is_smart_ptr_convertible<TT, T> convertible; + BOOST_STATIC_ASSERT(convertible::value); +--- misc/boost_1_44_0/boost/ptr_container/detail/move.hpp 2011-02-05 10:01:21.156931884 +0000 ++++ misc/build/boost_1_44_0/boost/ptr_container/detail/move.hpp 2011-02-05 10:01:14.160931007 +0000 +@@ -20,7 +20,7 @@ + template<typename Ptr> + class move_source { + public: +- move_source(Ptr& ptr) : ptr_(ptr) {} ++ move_source(Ptr& _ptr) : ptr_(_ptr) {} + Ptr& ptr() const { return ptr_; } + private: + Ptr& ptr_; +--- misc/boost_1_44_0/boost/spirit/home/classic/core/non_terminal/subrule.hpp 2011-02-08 09:24:50.817320629 +0000 ++++ misc/build/boost_1_44_0/boost/spirit/home/classic/core/non_terminal/subrule.hpp 2011-02-08 09:25:20.496639901 +0000 +@@ -210,7 +210,7 @@ + subrule_list< + subrule_parser<ID2, DefT2, ContextT2>, + nil_t> > +- operator,(subrule_parser<ID2, DefT2, ContextT2> const& rhs) const ++ operator,(subrule_parser<ID2, DefT2, ContextT2> const& rhs_) const + { + return subrule_list< + self_t, +@@ -220,7 +220,7 @@ + *this, + subrule_list< + subrule_parser<ID2, DefT2, ContextT2>, nil_t>( +- rhs, nil_t())); ++ rhs_, nil_t())); + } + + typename DefT::embed_t rhs; +--- misc/boost_1_44_0/boost/ptr_container/ptr_sequence_adapter.hpp 2011-02-09 08:49:00.416529470 +0000 ++++ misc/build/boost_1_44_0/boost/ptr_container/ptr_sequence_adapter.hpp 2011-02-09 08:50:44.607653864 +0000 +@@ -510,72 +510,72 @@ + + public: // resize + +- void resize( size_type size ) // basic ++ void resize( size_type size_ ) // basic + { + size_type old_size = this->size(); +- if( old_size > size ) ++ if( old_size > size_ ) + { +- this->erase( boost::next( this->begin(), size ), this->end() ); ++ this->erase( boost::next( this->begin(), size_ ), this->end() ); + } +- else if( size > old_size ) ++ else if( size_ > old_size ) + { +- for( ; old_size != size; ++old_size ) ++ for( ; old_size != size_; ++old_size ) + this->push_back( new BOOST_DEDUCED_TYPENAME + boost::remove_pointer<value_type>::type() ); + } + +- BOOST_ASSERT( this->size() == size ); ++ BOOST_ASSERT( this->size() == size_ ); + } + +- void resize( size_type size, value_type to_clone ) // basic ++ void resize( size_type size_, value_type to_clone ) // basic + { + size_type old_size = this->size(); +- if( old_size > size ) ++ if( old_size > size_ ) + { +- this->erase( boost::next( this->begin(), size ), this->end() ); ++ this->erase( boost::next( this->begin(), size_ ), this->end() ); + } +- else if( size > old_size ) ++ else if( size_ > old_size ) + { +- for( ; old_size != size; ++old_size ) ++ for( ; old_size != size_; ++old_size ) + this->push_back( this->null_policy_allocate_clone( to_clone ) ); + } + +- BOOST_ASSERT( this->size() == size ); ++ BOOST_ASSERT( this->size() == size_ ); + } + +- void rresize( size_type size ) // basic ++ void rresize( size_type size_ ) // basic + { + size_type old_size = this->size(); +- if( old_size > size ) ++ if( old_size > size_ ) + { + this->erase( this->begin(), +- boost::next( this->begin(), old_size - size ) ); ++ boost::next( this->begin(), old_size - size_ ) ); + } +- else if( size > old_size ) ++ else if( size_ > old_size ) + { +- for( ; old_size != size; ++old_size ) ++ for( ; old_size != size_; ++old_size ) + this->push_front( new BOOST_DEDUCED_TYPENAME + boost::remove_pointer<value_type>::type() ); + } + +- BOOST_ASSERT( this->size() == size ); ++ BOOST_ASSERT( this->size() == size_ ); + } + +- void rresize( size_type size, value_type to_clone ) // basic ++ void rresize( size_type size_, value_type to_clone ) // basic + { + size_type old_size = this->size(); +- if( old_size > size ) ++ if( old_size > size_ ) + { + this->erase( this->begin(), +- boost::next( this->begin(), old_size - size ) ); ++ boost::next( this->begin(), old_size - size_ ) ); + } +- else if( size > old_size ) ++ else if( size_ > old_size ) + { +- for( ; old_size != size; ++old_size ) ++ for( ; old_size != size_; ++old_size ) + this->push_front( this->null_policy_allocate_clone( to_clone ) ); + } + +- BOOST_ASSERT( this->size() == size ); ++ BOOST_ASSERT( this->size() == size_ ); + } + + public: // algorithms +--- misc/boost_1_44_0/boost/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 @@ + + static void enforce_null_policy( const Ty_* x, const char* msg ) + { ++#ifdef BOOST_PTR_CONTAINER_NO_EXCEPTIONS ++ (void)x; ++ (void)msg; ++#endif + if( !allow_null ) + { + BOOST_PTR_CONTAINER_THROW_EXCEPTION( 0 == x && "null not allowed", |