--- 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 self_t; typedef unary > 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 parser_result ::type @@ -112,8 +112,8 @@ typedef finite_loop self_t; typedef unary > 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 parser_result ::type @@ -196,11 +196,11 @@ typedef unary > 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 parser_result ::type @@ -253,9 +253,9 @@ template fixed_loop - operator[](parser const & subject) const + operator[](parser const & subject_) const { - return fixed_loop (subject.derived (), m_exact); + return fixed_loop (subject_.derived (), m_exact); } ExactT m_exact; @@ -283,11 +283,11 @@ template typename impl::loop_traits::type - operator[](parser const & subject) const + operator[](parser const & subject_) const { typedef typename impl::loop_traits::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 template inline BOOST_DEDUCED_TYPENAME T::node_ptr - hash_table::find_iterator(bucket_ptr bucket, Key const& k, + hash_table::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 inline BOOST_DEDUCED_TYPENAME T::node_ptr hash_table::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 inline BOOST_DEDUCED_TYPENAME T::node_ptr* hash_table::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 inline std::size_t hash_table::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 @@ -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 @@ -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) @@ -159,13 +159,13 @@ template inline BOOST_DEDUCED_TYPENAME hash_unique_table::node_ptr hash_unique_table::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); }