--- misc/boost_1_44_0/boost/date_time/date_names_put.hpp 2008-02-27 21:00:24.000000000 +0100 +++ misc/build/boost_1_44_0/boost/date_time/date_names_put.hpp 2011-10-05 16:58:58.413575307 +0200 @@ -218,14 +218,14 @@ const charT* const weekday_long_names[], charT separator_char = '-', ymd_order_spec order_spec = ymd_order_iso, - month_format_spec month_format = month_as_short_string) : + month_format_spec month_format_ = month_as_short_string) : month_short_names_(month_short_names), month_long_names_(month_long_names), special_value_names_(special_value_names), weekday_short_names_(weekday_short_names), weekday_long_names_(weekday_long_names), order_spec_(order_spec), - month_format_spec_(month_format) + month_format_spec_(month_format_) { separator_char_[0] = separator_char; separator_char_[1] = '\0'; --- 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 } } @@ -671,6 +671,7 @@ void range_check_impl( iterator first, iterator last, std::random_access_iterator_tag ) { + (void)first; (void)last; 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 @@ { 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) @@ -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 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); } --- 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 inline BOOST_DEDUCED_TYPENAME hash_equivalent_table::node_ptr hash_equivalent_table - ::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 - void check(const static_move_ptr& ptr) + void check(const static_move_ptr&) { typedef move_ptrs::is_smart_ptr_convertible 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 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, nil_t> > - operator,(subrule_parser const& rhs) const + operator,(subrule_parser const& rhs_) const { return subrule_list< self_t, @@ -220,7 +220,7 @@ *this, subrule_list< subrule_parser, 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::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::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 @@ -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::digits); std::size_t seed = static_cast(v); - v -= seed; + v -= static_cast(seed); // ceiling(digits(T) * log2(radix(T))/ digits(size_t)) - 1; std::size_t const length @@ -66,7 +66,7 @@ { v = ldexp(v, limits::digits); std::size_t part = static_cast(v); - v -= part; + v -= static_cast(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(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(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", --- misc/boost_1_44_0/boost/pool/object_pool.hpp.orig 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(sizeof(T), next_size) { } + explicit object_pool(const size_type next_size_ = 32) + :pool(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* - create_facet_def(char type) + create_facet_def(char /* type */) { typedef boost::date_time::all_date_names_put 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 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* - create_facet_def(wchar_t type) + create_facet_def(wchar_t /* type */) { typedef boost::date_time::all_date_names_put 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 facet_def; return std::locale(loc, new facet_def(w_short_month_names, w_long_month_names,