diff options
Diffstat (limited to 'boost/boost.4713.warnings.patch')
| -rw-r--r-- | boost/boost.4713.warnings.patch | 1218 |
1 files changed, 677 insertions, 541 deletions
diff --git a/boost/boost.4713.warnings.patch b/boost/boost.4713.warnings.patch index 805447ceed94..29653ca79fdd 100644 --- a/boost/boost.4713.warnings.patch +++ b/boost/boost.4713.warnings.patch @@ -1,16 +1,52 @@ ---- misc/build/boost_1_39_0/boost/spirit/home/classic/error_handling/exceptions.hpp -+++ misc/build/boost_1_39_0/boost/spirit/home/classic/error_handling/exceptions.hpp -@@ -126,8 +126,8 @@ - typedef unary<ParserT, parser<self_t> > base_t; - typedef unary_parser_category parser_category_t; - -- assertive_parser(ParserT const& parser, ErrorDescrT descriptor) -- : base_t(parser), descriptor(descriptor) {} -+ assertive_parser(ParserT const& parser, ErrorDescrT descriptor_) -+ : base_t(parser), descriptor(descriptor_) {} +--- 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 + } + } - template <typename ScannerT> - struct result +--- 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( @@ -23,8 +59,28 @@ result_t result; std::ptrdiff_t length; ---- misc/build/boost_1_39_0/boost/spirit/home/classic/utility/functor_parser.hpp -+++ misc/build/boost_1_39_0/boost/spirit/home/classic/utility/functor_parser.hpp +--- 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; @@ -42,8 +98,8 @@ } }; ---- misc/build/boost_1_39_0/boost/spirit/home/classic/utility/loops.hpp -+++ misc/build/boost_1_39_0/boost/spirit/home/classic/utility/loops.hpp +--- 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; @@ -106,77 +162,558 @@ m_min, m_max); } ---- misc/build/boost_1_39_0/boost/spirit/home/classic/symbols/symbols.hpp -+++ misc/build/boost_1_39_0/boost/spirit/home/classic/symbols/symbols.hpp -@@ -102,13 +102,13 @@ +--- 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 { - 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); +- 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_; + } + } -- 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); +@@ -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 - ---- misc/build/boost_1_39_0/boost/date_time/posix_time/posix_time_config.hpp -+++ misc/build/boost_1_39_0/boost/date_time/posix_time/posix_time_config.hpp -@@ -82,8 +82,8 @@ - //Give duration access to ticks constructor -- hide from users - friend class date_time::time_duration<time_duration, time_res_traits>; - private: -- explicit time_duration(impl_type ticks) : -- date_time::time_duration<time_duration, time_res_traits>(ticks) -+ explicit time_duration(impl_type _ticks) : -+ date_time::time_duration<time_duration, time_res_traits>(_ticks) - {} - }; - ---- misc/build/boost_1_39_0/boost/ptr_container/detail/map_iterator.hpp -+++ misc/build/boost_1_39_0/boost/ptr_container/detail/map_iterator.hpp -@@ -49,7 +49,7 @@ - : first(rp->first), second(rp->second) - { } - -- const ref_pair* const operator->() const -+ const ref_pair* operator->() const - { - return this; - } ---- misc/build/boost_1_39_0/boost/ptr_container/ptr_sequence_adapter.hpp -+++ misc/build/boost_1_39_0/boost/ptr_container/ptr_sequence_adapter.hpp -@@ -476,19 +476,19 @@ - public: // C-array support + 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_; + } - void transfer( iterator before, value_type* from, -- size_type size, bool delete_from = true ) // strong -+ size_type size_, bool delete_from = true ) // strong + 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) { - 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 + 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 @@ -197,7 +734,7 @@ - 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::remove_pointer<value_type>::type() ); } - BOOST_ASSERT( this->size() == size ); @@ -243,7 +780,7 @@ - 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::remove_pointer<value_type>::type() ); } - BOOST_ASSERT( this->size() == size ); @@ -274,472 +811,71 @@ } public: // algorithms ---- misc/build/boost_1_39_0/boost/ptr_container/ptr_map_adapter.hpp -+++ misc/build/boost_1_39_0/boost/ptr_container/ptr_map_adapter.hpp -@@ -477,6 +477,7 @@ - } - - ptr_map_adapter( const ptr_map_adapter& r ) -+ : base_type() - { - map_basic_clone_and_insert( r.begin(), r.end() ); - } ---- misc/build/boost_1_39_0/boost/unordered/detail/hash_table_impl.hpp -+++ misc/build/boost_1_39_0/boost/unordered/detail/hash_table_impl.hpp -@@ -423,17 +423,17 @@ - void delete_buckets() - { - if(buckets_) { -- bucket_ptr begin = cached_begin_bucket_; -- bucket_ptr end = buckets_end(); -- while(begin != end) { -- clear_bucket(begin); -- ++begin; -+ bucket_ptr begin_ = cached_begin_bucket_; -+ bucket_ptr end_ = buckets_end(); -+ while(begin_ != end_) { -+ clear_bucket(begin_); -+ ++begin_; - } - - // Destroy an extra bucket for the sentinels. -- ++end; -- for(begin = buckets_; begin != end; ++begin) -- allocators_.bucket_alloc_.destroy(begin); -+ ++end_; -+ for(begin_ = buckets_; begin_ != end_; ++begin_) -+ allocators_.bucket_alloc_.destroy(begin_); - - allocators_.bucket_alloc_.deallocate(buckets_, - bucket_manager_.bucket_count() + 1); -@@ -680,11 +680,11 @@ - // The deleted node is at the end of the group, so the - // first node in the group is pointing to it. - // Find that to change its pointer. -- link_ptr it = n->group_prev_; -- while(prev_in_group(it) != *pos) { -- it = prev_in_group(it); -+ link_ptr it2 = n->group_prev_; -+ while(prev_in_group(it2) != *pos) { -+ it2 = prev_in_group(it2); - } -- prev_in_group(it) = n->group_prev_; -+ prev_in_group(it2) = n->group_prev_; - } - *pos = next; - --size_; -@@ -721,25 +721,25 @@ - size_ -= node_count(n.node_); - } - -- void unlink_nodes(iterator_base begin, iterator_base end) -+ void unlink_nodes(iterator_base begin_, iterator_base end_) +--- 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 @@ { -- BOOST_ASSERT(begin.bucket_ == end.bucket_); -- size_ -= node_count(begin.node_, end.node_); -- link_ptr* it = get_for_erase(begin); -- split_group(*it, end.node_); -- *it = end.node_; -+ BOOST_ASSERT(begin_.bucket_ == end_.bucket_); -+ size_ -= node_count(begin_.node_, end_.node_); -+ link_ptr* it = get_for_erase(begin_); -+ split_group(*it, end_.node_); -+ *it = end_.node_; + 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); } -- void unlink_nodes(bucket_ptr base, iterator_base end) -+ void unlink_nodes(bucket_ptr base, iterator_base end_) - { -- BOOST_ASSERT(base == end.bucket_); -+ BOOST_ASSERT(base == end_.bucket_); +--- 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; -- split_group(end.node_); -+ split_group(end_.node_); +- const size_type max_size = ++ const size_type max_size_ = + (std::min)(m_num_bits, static_cast<size_type>(ulong_width)); - link_ptr ptr(base->next_); -- base->next_ = end.node_; -+ base->next_ = end_.node_; +- const size_type last_block = block_index( max_size - 1 ); ++ const size_type last_block = block_index( max_size_ - 1 ); -- size_ -= node_count(ptr, end.node_); -+ size_ -= node_count(ptr, end_.node_); - } + assert((last_block * bits_per_block) < static_cast<size_type>(ulong_width)); - #if BOOST_UNORDERED_EQUIVALENT_KEYS -@@ -797,12 +797,12 @@ - { - node_constructor a(allocators_); +--- 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 @@ -- link_ptr end = next_group(it); -+ link_ptr end_ = next_group(it); - - a.construct(get_value(it)); // throws - link_ptr n = link_node_in_bucket(a, dst); - -- for(it = it->next_; it != end; it = it->next_) { -+ for(it = it->next_; it != end_; it = it->next_) { - a.construct(get_value(it)); // throws - link_node(a, n); - } -@@ -824,21 +824,21 @@ - // - // no throw - -- void delete_to_bucket_end(link_ptr begin) -+ void delete_to_bucket_end(link_ptr begin_) - { -- while(begin) { -- link_ptr node = begin; -- begin = begin->next_; -- allocators_.destroy(node); -+ while(begin_) { -+ link_ptr node_ = begin_; -+ begin_ = begin_->next_; -+ allocators_.destroy(node_); - } - } - -- void delete_nodes(link_ptr begin, link_ptr end) -+ void delete_nodes(link_ptr begin_, link_ptr end_) - { -- while(begin != end) { -- link_ptr node = begin; -- begin = begin->next_; -- allocators_.destroy(node); -+ while(begin_ != end_) { -+ link_ptr node_ = begin_; -+ begin_ = begin_->next_; -+ allocators_.destroy(node_); - } - } - -@@ -848,9 +848,9 @@ - delete_nodes(first_node, prev_in_group(first_node)->next_); - } - #else -- void delete_group(link_ptr node) -+ void delete_group(link_ptr node_) - { -- allocators_.destroy(node); -+ allocators_.destroy(node_); - } - #endif - -@@ -869,15 +869,15 @@ - - void clear() - { -- bucket_ptr begin = cached_begin_bucket_; -- bucket_ptr end = buckets_end(); -+ bucket_ptr begin_ = cached_begin_bucket_; -+ bucket_ptr end_ = buckets_end(); - - size_ = 0; -- cached_begin_bucket_ = end; -+ cached_begin_bucket_ = end_; - -- while(begin != end) { -- clear_bucket(begin); -- ++begin; -+ while(begin_ != end_) { -+ clear_bucket(begin_); -+ ++begin_; - } - } - -@@ -974,13 +974,13 @@ - cached_begin_bucket_ = b2; - } - -- size_type erase_group(link_ptr* it, bucket_ptr bucket) -+ size_type erase_group(link_ptr* it, bucket_ptr bucket_) - { - link_ptr pos = *it; - size_type count = unlink_group(it); - delete_group(pos); - -- this->recompute_begin_bucket(bucket); -+ this->recompute_begin_bucket(bucket_); - - return count; - } -@@ -1541,8 +1541,8 @@ - hf(extract_key(data::get_value(src_bucket->next_)))); - - link_ptr n = src_bucket->next_; -- size_type count = src.unlink_group(&src_bucket->next_); -- dst.link_group(n, dst_bucket, count); -+ size_type count_ = src.unlink_group(&src_bucket->next_); -+ dst.link_group(n, dst_bucket, count_); - } - } - } -@@ -1651,20 +1651,20 @@ - { - key_type const& k = extract_key(a.get()->value()); - size_type hash_value = hash_function()(k); -- bucket_ptr bucket = data_.bucket_ptr_from_hash(hash_value); -- link_ptr position = find_iterator(bucket, k); -+ bucket_ptr bucket_ = data_.bucket_ptr_from_hash(hash_value); -+ link_ptr position = find_iterator(bucket_, k); - - // reserve has basic exception safety if the hash function - // throws, strong otherwise. - if(reserve_for_insert(size() + 1)) -- bucket = data_.bucket_ptr_from_hash(hash_value); -+ bucket_ = data_.bucket_ptr_from_hash(hash_value); - - // I'm relying on link_ptr not being invalidated by - // the rehash here. -- return iterator_base(bucket, -+ return iterator_base(bucket_, - (BOOST_UNORDERED_BORLAND_BOOL(position)) ? - data_.link_node(a, position) : -- data_.link_node_in_bucket(a, bucket) -+ data_.link_node_in_bucket(a, bucket_) - ); - } - -@@ -1718,13 +1718,13 @@ - a.construct(*i); - - key_type const& k = extract_key(a.get()->value()); -- bucket_ptr bucket = get_bucket(k); -- link_ptr position = find_iterator(bucket, k); -+ bucket_ptr bucket_ = get_bucket(k); -+ link_ptr position = find_iterator(bucket_, k); - - if(BOOST_UNORDERED_BORLAND_BOOL(position)) - data_.link_node(a, position); - else -- data_.link_node_in_bucket(a, bucket); -+ data_.link_node_in_bucket(a, bucket_); - } - } - } -@@ -1761,8 +1761,8 @@ - typedef BOOST_DEDUCED_TYPENAME value_type::second_type mapped_type; - - size_type hash_value = hash_function()(k); -- bucket_ptr bucket = data_.bucket_ptr_from_hash(hash_value); -- link_ptr pos = find_iterator(bucket, k); -+ bucket_ptr bucket_ = data_.bucket_ptr_from_hash(hash_value); -+ link_ptr pos = find_iterator(bucket_, k); - - if (BOOST_UNORDERED_BORLAND_BOOL(pos)) - return data::get_value(pos); -@@ -1778,11 +1778,11 @@ - // reserve has basic exception safety if the hash function - // throws, strong otherwise. - if(reserve_for_insert(size() + 1)) -- bucket = data_.bucket_ptr_from_hash(hash_value); -+ bucket_ = data_.bucket_ptr_from_hash(hash_value); - - // Nothing after this point can throw. - -- return data::get_value(data_.link_node_in_bucket(a, bucket)); -+ return data::get_value(data_.link_node_in_bucket(a, bucket_)); - } - } - -@@ -1797,13 +1797,13 @@ - // No side effects in this initial code - key_type const& k = extract_key(v); - size_type hash_value = hash_function()(k); -- bucket_ptr bucket = data_.bucket_ptr_from_hash(hash_value); -- link_ptr pos = find_iterator(bucket, k); -+ bucket_ptr bucket_ = data_.bucket_ptr_from_hash(hash_value); -+ link_ptr pos = find_iterator(bucket_, k); - - if (BOOST_UNORDERED_BORLAND_BOOL(pos)) { - // Found an existing key, return it (no throw). - return std::pair<iterator_base, bool>( -- iterator_base(bucket, pos), false); -+ iterator_base(bucket_, pos), false); - - } else { - // Doesn't already exist, add to bucket. -@@ -1817,14 +1817,14 @@ - // reserve has basic exception safety if the hash function - // throws, strong otherwise. - if(reserve_for_insert(size() + 1)) -- bucket = data_.bucket_ptr_from_hash(hash_value); -+ bucket_ = data_.bucket_ptr_from_hash(hash_value); - - // Nothing after this point can throw. - -- link_ptr n = data_.link_node_in_bucket(a, bucket); -+ link_ptr n = data_.link_node_in_bucket(a, bucket_); - - return std::pair<iterator_base, bool>( -- iterator_base(bucket, n), true); -+ iterator_base(bucket_, n), true); - } - } - -@@ -1864,13 +1864,13 @@ - { - // No side effects in this initial code - size_type hash_value = hash_function()(k); -- bucket_ptr bucket = data_.bucket_ptr_from_hash(hash_value); -- link_ptr pos = find_iterator(bucket, k); -+ bucket_ptr bucket_ = data_.bucket_ptr_from_hash(hash_value); -+ link_ptr pos = find_iterator(bucket_, k); - - if (BOOST_UNORDERED_BORLAND_BOOL(pos)) { - // Found an existing key, return it (no throw). - return std::pair<iterator_base, bool>( -- iterator_base(bucket, pos), false); -+ iterator_base(bucket_, pos), false); - - } else { - // Doesn't already exist, add to bucket. -@@ -1884,12 +1884,12 @@ - // reserve has basic exception safety if the hash function - // throws, strong otherwise. - if(reserve_for_insert(size() + 1)) -- bucket = data_.bucket_ptr_from_hash(hash_value); -+ bucket_ = data_.bucket_ptr_from_hash(hash_value); - - // Nothing after this point can throw. - -- return std::pair<iterator_base, bool>(iterator_base(bucket, -- data_.link_node_in_bucket(a, bucket)), true); -+ return std::pair<iterator_base, bool>(iterator_base(bucket_, -+ data_.link_node_in_bucket(a, bucket_)), true); - } - } - -@@ -1904,23 +1904,23 @@ - // No side effects in this initial code - key_type const& k = extract_key(a.get()->value()); - size_type hash_value = hash_function()(k); -- bucket_ptr bucket = data_.bucket_ptr_from_hash(hash_value); -- link_ptr pos = find_iterator(bucket, k); -+ bucket_ptr bucket_ = data_.bucket_ptr_from_hash(hash_value); -+ link_ptr pos = find_iterator(bucket_, k); - - if (BOOST_UNORDERED_BORLAND_BOOL(pos)) { - // Found an existing key, return it (no throw). - return std::pair<iterator_base, bool>( -- iterator_base(bucket, pos), false); -+ iterator_base(bucket_, pos), false); - } else { - // reserve has basic exception safety if the hash function - // throws, strong otherwise. - if(reserve_for_insert(size() + 1)) -- bucket = data_.bucket_ptr_from_hash(hash_value); -+ bucket_ = data_.bucket_ptr_from_hash(hash_value); - - // Nothing after this point can throw. - -- return std::pair<iterator_base, bool>(iterator_base(bucket, -- data_.link_node_in_bucket(a, bucket)), true); -+ return std::pair<iterator_base, bool>(iterator_base(bucket_, -+ data_.link_node_in_bucket(a, bucket_)), true); - } - } - -@@ -1969,8 +1969,8 @@ - for (; i != j; ++i) { - // No side effects in this initial code - size_type hash_value = hash_function()(extract_key(*i)); -- bucket_ptr bucket = data_.bucket_ptr_from_hash(hash_value); -- link_ptr pos = find_iterator(bucket, extract_key(*i)); -+ bucket_ptr bucket_ = data_.bucket_ptr_from_hash(hash_value); -+ link_ptr pos = find_iterator(bucket_, extract_key(*i)); - - if (!BOOST_UNORDERED_BORLAND_BOOL(pos)) { - // Doesn't already exist, add to bucket. -@@ -1984,11 +1984,11 @@ - // throws, strong otherwise. - if(size() + 1 >= max_load_) { - reserve_for_insert(size() + insert_size(i, j)); -- bucket = data_.bucket_ptr_from_hash(hash_value); -+ bucket_ = data_.bucket_ptr_from_hash(hash_value); - } - - // Nothing after this point can throw. -- data_.link_node_in_bucket(a, bucket); -+ data_.link_node_in_bucket(a, bucket_); - } - } - } -@@ -2001,11 +2001,11 @@ - size_type erase_key(key_type const& k) - { - // No side effects in initial section -- bucket_ptr bucket = get_bucket(k); -- link_ptr* it = find_for_erase(bucket, k); -+ bucket_ptr bucket_ = get_bucket(k); -+ link_ptr* it = find_for_erase(bucket_, k); - - // No throw. -- return *it ? data_.erase_group(it, bucket) : 0; -+ return *it ? data_.erase_group(it, bucket_) : 0; - } - - // count -@@ -2022,19 +2022,19 @@ - // strong exception safety, no side effects - iterator_base find(key_type const& k) const - { -- bucket_ptr bucket = get_bucket(k); -- link_ptr it = find_iterator(bucket, k); -+ bucket_ptr bucket_ = get_bucket(k); -+ link_ptr it = find_iterator(bucket_, k); - - if (BOOST_UNORDERED_BORLAND_BOOL(it)) -- return iterator_base(bucket, it); -+ return iterator_base(bucket_, it); - else - return data_.end(); - } - - value_type& at(key_type const& k) const - { -- bucket_ptr bucket = get_bucket(k); -- link_ptr it = find_iterator(bucket, k); -+ bucket_ptr bucket_ = get_bucket(k); -+ link_ptr it = find_iterator(bucket_, k); - - if (BOOST_UNORDERED_BORLAND_BOOL(it)) - return data::get_value(it); -@@ -2047,10 +2047,10 @@ - // strong exception safety, no side effects - std::pair<iterator_base, iterator_base> equal_range(key_type const& k) const - { -- bucket_ptr bucket = get_bucket(k); -- link_ptr it = find_iterator(bucket, k); -+ bucket_ptr bucket_ = get_bucket(k); -+ link_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_group(); - return std::pair<iterator_base, iterator_base>(first, second); -@@ -2074,10 +2074,10 @@ - } - - // strong exception safety, no side effects -- link_ptr find_iterator(bucket_ptr bucket, -+ link_ptr find_iterator(bucket_ptr bucket_, - key_type const& k) const - { -- link_ptr it = data_.begin(bucket); -+ link_ptr it = data_.begin(bucket_); - while (BOOST_UNORDERED_BORLAND_BOOL(it) && !equal(k, data::get_value(it))) - it = data::next_group(it); - -@@ -2085,9 +2085,9 @@ - } - - // strong exception safety, no side effects -- link_ptr* find_for_erase(bucket_ptr bucket, key_type const& k) const -+ link_ptr* find_for_erase(bucket_ptr bucket_, key_type const& k) const + 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 ) { -- link_ptr* it = &bucket->next_; -+ link_ptr* it = &bucket_->next_; - while(BOOST_UNORDERED_BORLAND_BOOL(*it) && !equal(k, data::get_value(*it))) - it = &data::next_group(*it); - + BOOST_PTR_CONTAINER_THROW_EXCEPTION( 0 == x && "null not allowed", |