I've recently added Boost to an Xcode 3.1.2 project with the following warnings enabled in GCC/G++ 4.0.1: -Werror -Wreturn-type -Wunused-function -Wunused-label -Wunused-variable -Wshadow Unfortunately, when boost is not installed in a "system" path as is the case here. Unused and shadow variable warnings cause the build to fail when warnings are treated as errors. This issue last come up for me about a year ago in 1_35_0 with filesystem.hpp: http://article.gmane.org/gmane.comp.lib.boost.user/38297/match=shadow+variab les+cause The included headers this time are: boost/accumulators/accumulators.hpp boost/accumulators/statistics/stats.hpp boost/accumulators/statistics/rolling_mean.hpp To test and fix, I isolated with: printf "#include <${BoostHeader}>\nint main(void) { return 0; }" | /Developer/usr/bin/gcc-4.0 -x c++ -Wall -Wshadow -Werror -o test -I${BoostRoot}/boost/include - The patch to address this is as follows and impacts the headers below: boost/accumulators/framework/accumulator_set.hpp boost/accumulators/framework/accumulators/droppable_accumulator.hpp boost/accumulators/statistics/rolling_mean.hpp boost/accumulators/statistics/rolling_window.hpp boost/accumulators/statistics_fwd.hpp boost/circular_buffer/base.hpp boost/circular_buffer/details.hpp boost/circular_buffer/space_optimized.hpp boost/fusion/container/list/cons.hpp boost/fusion/container/list/cons_iterator.hpp boost/fusion/container/vector/vector_iterator.hpp boost/fusion/view/filter_view/filter_view.hpp boost/fusion/view/filter_view/filter_view_iterator.hpp boost/fusion/view/iterator_range/iterator_range.hpp boost/fusion/view/joint_view/joint_view.hpp boost/fusion/view/joint_view/joint_view_iterator.hpp boost/fusion/view/single_view/single_view.hpp boost/parameter/aux_/arg_list.hpp boost/parameter/aux_/maybe.hpp Because this problem seems to come up frequently, perhaps there is a way -Wshadow and -Wall can be forced for all unit tests? Signed-off-by: Grant Erickson <gerickson@nuovations.com> --- --- a/boost/accumulators/framework/accumulator_set.hpp 2008-06-20 09:01:50.000000000 -0700 +++ b/boost/accumulators/framework/accumulator_set.hpp 2009-05-14 13:27:51.000000000 -0700 @@ -42,8 +42,8 @@ template<typename Args> struct accumulator_visitor { - explicit accumulator_visitor(Args const &args) - : args(args) + explicit accumulator_visitor(Args const &in_args) + : args(in_args) { } --- a/boost/accumulators/framework/accumulators/droppable_accumulator.hpp 2008-06-19 20:47:42.000000000 -0700 +++ b/boost/accumulators/framework/accumulators/droppable_accumulator.hpp 2009-05-14 13:23:19.000000000 -0700 @@ -218,9 +218,9 @@ private: with_cached_result &operator =(with_cached_result const &); - void set(result_type const &result) + void set(result_type const &in_result) { - ::new(this->cache.address()) result_type(result); + ::new(this->cache.address()) result_type(in_result); } result_type const &get() const --- a/boost/accumulators/statistics/rolling_mean.hpp 2008-12-30 11:30:45.000000000 -0800 +++ b/boost/accumulators/statistics/rolling_mean.hpp 2009-05-14 13:33:12.000000000 -0700 @@ -69,7 +69,7 @@ // namespace extract { - extractor<tag::rolling_mean> const rolling_mean = {}; + extern extractor<tag::rolling_mean> const rolling_mean = {}; } using extract::rolling_mean; --- a/boost/accumulators/statistics/rolling_window.hpp 2008-12-30 11:30:45.000000000 -0800 +++ b/boost/accumulators/statistics/rolling_window.hpp 2009-05-14 13:32:57.000000000 -0700 @@ -153,8 +153,8 @@ // namespace extract { - extractor<tag::rolling_window_plus1> const rolling_window_plus1 = {}; - extractor<tag::rolling_window> const rolling_window = {}; + extern extractor<tag::rolling_window_plus1> const rolling_window_plus1 = {}; + extern extractor<tag::rolling_window> const rolling_window = {}; } using extract::rolling_window_plus1; --- a/boost/accumulators/statistics_fwd.hpp 2008-12-30 11:30:45.000000000 -0800 +++ b/boost/accumulators/statistics_fwd.hpp 2009-05-14 13:31:22.000000000 -0700 @@ -30,7 +30,7 @@ } namespace extract { - extractor<tag::quantile> const quantile = {}; + extern extractor<tag::quantile> const quantile = {}; } using extract::quantile; @@ -46,7 +46,7 @@ } namespace extract { - extractor<tag::tail_mean> const tail_mean = {}; + extern extractor<tag::tail_mean> const tail_mean = {}; } using extract::tail_mean; --- a/boost/circular_buffer/base.hpp 2008-08-18 01:54:04.000000000 -0700 +++ b/boost/circular_buffer/base.hpp 2009-05-14 13:38:46.000000000 -0700 @@ -1006,9 +1006,9 @@ \par Complexity Constant. */ - explicit circular_buffer(capacity_type capacity, const allocator_type& alloc = allocator_type()) + explicit circular_buffer(capacity_type in_capacity, const allocator_type& alloc = allocator_type()) : m_size(0), m_alloc(alloc) { - initialize_buffer(capacity); + initialize_buffer(in_capacity); m_first = m_last = m_buff; } @@ -1046,13 +1046,13 @@ \par Complexity Linear (in the <code>n</code>). */ - circular_buffer(capacity_type capacity, size_type n, param_value_type item, + circular_buffer(capacity_type in_capacity, size_type n, param_value_type item, const allocator_type& alloc = allocator_type()) : m_size(n), m_alloc(alloc) { - BOOST_CB_ASSERT(capacity >= size()); // check for capacity lower than size - initialize_buffer(capacity, item); + BOOST_CB_ASSERT(in_capacity >= size()); // check for capacity lower than size + initialize_buffer(in_capacity, item); m_first = m_buff; - m_last = capacity == n ? m_buff : m_buff + n; + m_last = in_capacity == n ? m_buff : m_buff + n; } //! The copy constructor. @@ -1145,10 +1145,10 @@ <a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">RandomAccessIte rator</a>). */ template <class InputIterator> - circular_buffer(capacity_type capacity, InputIterator first, InputIterator last, + circular_buffer(capacity_type in_capacity, InputIterator first, InputIterator last, const allocator_type& alloc = allocator_type()) : m_alloc(alloc) { - initialize(capacity, first, last, is_integral<InputIterator>()); + initialize(in_capacity, first, last, is_integral<InputIterator>()); } #endif // #if BOOST_WORKAROUND(BOOST_MSVC, < 1300) @@ -1260,9 +1260,9 @@ assign(size_type, const_reference)\endlink</code>, <code>assign(InputIterator, InputIterator)</code>, <code>assign(capacity_type, InputIterator, InputIterator)</code> */ - void assign(capacity_type capacity, size_type n, param_value_type item) { - BOOST_CB_ASSERT(capacity >= n); // check for new capacity lower than n - assign_n(capacity, n, cb_details::assign_n<param_value_type, allocator_type>(n, item, m_alloc)); + void assign(capacity_type in_capacity, size_type n, param_value_type item) { + BOOST_CB_ASSERT(in_capacity >= n); // check for new capacity lower than n + assign_n(in_capacity, n, cb_details::assign_n<param_value_type, allocator_type>(n, item, m_alloc)); } //! Assign a copy of the range into the <code>circular_buffer</code>. @@ -1333,8 +1333,8 @@ <code>assign(InputIterator, InputIterator)</code> */ template <class InputIterator> - void assign(capacity_type capacity, InputIterator first, InputIterator last) { - assign(capacity, first, last, is_integral<InputIterator>()); + void assign(capacity_type in_capacity, InputIterator first, InputIterator last) { + assign(in_capacity, first, last, is_integral<InputIterator>()); } //! Swap the contents of two <code>circular_buffer</code>s. @@ -2079,14 +2079,14 @@ } //! Initialize the internal buffer. - void initialize_buffer(capacity_type capacity) { - m_buff = allocate(capacity); - m_end = m_buff + capacity; + void initialize_buffer(capacity_type in_capacity) { + m_buff = allocate(in_capacity); + m_end = m_buff + in_capacity; } //! Initialize the internal buffer. - void initialize_buffer(capacity_type capacity, param_value_type item) { - initialize_buffer(capacity); + void initialize_buffer(capacity_type in_capacity, param_value_type item) { + initialize_buffer(in_capacity); BOOST_TRY { cb_details::uninitialized_fill_n_with_alloc(m_buff, size(), item, m_alloc); } BOOST_CATCH(...) { @@ -2135,35 +2135,35 @@ //! Specialized initialize method. template <class IntegralType> - void initialize(capacity_type capacity, IntegralType n, IntegralType item, const true_type&) { - BOOST_CB_ASSERT(capacity >= static_cast<size_type>(n)); // check for capacity lower than n + void initialize(capacity_type in_capacity, IntegralType n, IntegralType item, const true_type&) { + BOOST_CB_ASSERT(in_capacity >= static_cast<size_type>(n)); // check for capacity lower than n m_size = static_cast<size_type>(n); - initialize_buffer(capacity, item); + initialize_buffer(in_capacity, item); m_first = m_buff; - m_last = capacity == size() ? m_buff : m_buff + size(); + m_last = in_capacity == size() ? m_buff : m_buff + size(); } //! Specialized initialize method. template <class Iterator> - void initialize(capacity_type capacity, Iterator first, Iterator last, const false_type&) { + void initialize(capacity_type in_capacity, Iterator first, Iterator last, const false_type&) { BOOST_CB_IS_CONVERTIBLE(Iterator, value_type); // check for invalid iterator type #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581)) - initialize(capacity, first, last, BOOST_ITERATOR_CATEGORY<Iterator>::type()); + initialize(in_capacity, first, last, BOOST_ITERATOR_CATEGORY<Iterator>::type()); #else - initialize(capacity, first, last, BOOST_DEDUCED_TYPENAME BOOST_ITERATOR_CATEGORY<Iterator>::type()); + initialize(in_capacity, first, last, BOOST_DEDUCED_TYPENAME BOOST_ITERATOR_CATEGORY<Iterator>::type()); #endif } //! Specialized initialize method. template <class InputIterator> - void initialize(capacity_type capacity, + void initialize(capacity_type in_capacity, InputIterator first, InputIterator last, const std::input_iterator_tag&) { - initialize_buffer(capacity); + initialize_buffer(in_capacity); m_first = m_last = m_buff; m_size = 0; - if (capacity == 0) + if (in_capacity == 0) return; while (first != last && !full()) { m_alloc.construct(m_last, *first++); @@ -2179,32 +2179,32 @@ //! Specialized initialize method. template <class ForwardIterator> - void initialize(capacity_type capacity, + void initialize(capacity_type in_capacity, ForwardIterator first, ForwardIterator last, const std::forward_iterator_tag&) { BOOST_CB_ASSERT(std::distance(first, last) >= 0); // check for wrong range - initialize(capacity, first, last, std::distance(first, last)); + initialize(in_capacity, first, last, std::distance(first, last)); } //! Initialize the circular buffer. template <class ForwardIterator> - void initialize(capacity_type capacity, + void initialize(capacity_type in_capacity, ForwardIterator first, ForwardIterator last, size_type distance) { - initialize_buffer(capacity); + initialize_buffer(in_capacity); m_first = m_buff; - if (distance > capacity) { - std::advance(first, distance - capacity); - m_size = capacity; + if (distance > in_capacity) { + std::advance(first, distance - in_capacity); + m_size = in_capacity; } else { m_size = distance; } BOOST_TRY { m_last = cb_details::uninitialized_copy_with_alloc(first, last, m_buff, m_alloc); } BOOST_CATCH(...) { - deallocate(m_buff, capacity); + deallocate(m_buff, in_capacity); BOOST_RETHROW } BOOST_CATCH_END --- a/boost/circular_buffer/details.hpp 2008-08-20 09:13:07.000000000 -0700 +++ b/boost/circular_buffer/details.hpp 2009-05-14 13:39:23.000000000 -0700 @@ -146,9 +146,9 @@ public: //! Constructor. - capacity_control(Size capacity, Size min_capacity = 0) - : m_capacity(capacity), m_min_capacity(min_capacity) { - BOOST_CB_ASSERT(capacity >= min_capacity); // check for capacity lower than min_capacity + capacity_control(Size in_capacity, Size in_min_capacity = 0) + : m_capacity(in_capacity), m_min_capacity(in_min_capacity) { + BOOST_CB_ASSERT(in_capacity >= in_min_capacity); // check for capacity lower than min_capacity } // Default copy constructor. --- a/boost/circular_buffer/space_optimized.hpp 2008-08-18 01:54:04.000000000 -0700 +++ b/boost/circular_buffer/space_optimized.hpp 2009-05-14 13:33:40.000000000 -0700 @@ -1229,8 +1229,8 @@ } //! Ensure the reserve for possible growth up. - size_type ensure_reserve(size_type new_capacity, size_type size) const { - if (size + new_capacity / 5 >= new_capacity) + size_type ensure_reserve(size_type new_capacity, size_type in_size) const { + if (in_size + new_capacity / 5 >= new_capacity) new_capacity *= 2; // ensure at least 20% reserve if (new_capacity > m_capacity_ctrl) return m_capacity_ctrl; --- a/boost/fusion/container/list/cons.hpp 2007-11-25 10:07:19.000000000 -0800 +++ b/boost/fusion/container/list/cons.hpp 2009-05-14 13:22:20.000000000 -0700 @@ -69,13 +69,13 @@ cons() : car(), cdr() {} - explicit cons(typename detail::call_param<Car>::type car) - : car(car), cdr() {} + explicit cons(typename detail::call_param<Car>::type in_car) + : car(in_car), cdr() {} cons( - typename detail::call_param<Car>::type car - , typename detail::call_param<Cdr>::type cdr) - : car(car), cdr(cdr) {} + typename detail::call_param<Car>::type in_car + , typename detail::call_param<Cdr>::type in_cdr) + : car(in_car), cdr(in_cdr) {} template <typename Car2, typename Cdr2> cons(cons<Car2, Cdr2> const& rhs) --- a/boost/fusion/container/list/cons_iterator.hpp 2007-11-25 10:07:19.000000000 -0800 +++ b/boost/fusion/container/list/cons_iterator.hpp 2009-05-14 13:21:41.000000000 -0700 @@ -35,8 +35,8 @@ typename add_const<Cons>::type> identity; - explicit cons_iterator(cons_type& cons) - : cons(cons) {} + explicit cons_iterator(cons_type& in_cons) + : cons(in_cons) {} cons_type& cons; }; --- a/boost/fusion/container/vector/vector_iterator.hpp 2007-11-25 10:07:19.000000000 -0800 +++ b/boost/fusion/container/vector/vector_iterator.hpp 2009-05-14 13:17:57.000000000 -0700 @@ -36,8 +36,8 @@ typedef vector_iterator_identity< typename add_const<Vector>::type, N> identity; - vector_iterator(Vector& vec) - : vec(vec) {} + vector_iterator(Vector& in_vec) + : vec(in_vec) {} Vector& vec; }; }} --- a/boost/fusion/view/filter_view/filter_view.hpp 2007-11-25 10:07:19.000000000 -0800 +++ b/boost/fusion/view/filter_view/filter_view.hpp 2009-05-14 13:27:21.000000000 -0700 @@ -36,8 +36,8 @@ typedef typename result_of::end<Sequence>::type last_type; typedef Pred pred_type; - filter_view(Sequence& seq) - : seq(seq) + filter_view(Sequence& in_seq) + : seq(in_seq) {} first_type first() const { return fusion::begin(seq); } --- a/boost/fusion/view/filter_view/filter_view_iterator.hpp 2007-11-25 10:07:19.000000000 -0800 +++ b/boost/fusion/view/filter_view/filter_view_iterator.hpp 2009-05-14 13:27:03.000000000 -0700 @@ -36,8 +36,8 @@ typedef last_iter last_type; typedef Pred pred_type; - filter_iterator(First const& first) - : first(filter::call(first_converter::call(first))) {} + filter_iterator(First const& in_first) + : first(filter::call(first_converter::call(in_first))) {} first_type first; }; --- a/boost/fusion/view/iterator_range/iterator_range.hpp 2007-11-25 10:07:19.000000000 -0800 +++ b/boost/fusion/view/iterator_range/iterator_range.hpp 2009-05-14 13:20:41.000000000 -0700 @@ -36,9 +36,9 @@ typedef typename traits::category_of<begin_type>::type category; - iterator_range(First const& first, Last const& last) - : first(convert_iterator<First>::call(first)) - , last(convert_iterator<Last>::call(last)) {} + iterator_range(First const& in_first, Last const& in_last) + : first(convert_iterator<First>::call(in_first)) + , last(convert_iterator<Last>::call(in_last)) {} begin_type first; end_type last; --- a/boost/fusion/view/joint_view/joint_view.hpp 2007-11-25 10:07:19.000000000 -0800 +++ b/boost/fusion/view/joint_view/joint_view.hpp 2009-05-14 13:19:35.000000000 -0700 @@ -40,9 +40,9 @@ typedef typename result_of::end<Sequence2>::type concat_last_type; typedef typename mpl::plus<result_of::size<Sequence1>, result_of::size<Sequence2> >::type size; - joint_view(Sequence1& seq1, Sequence2& seq2) - : seq1(seq1) - , seq2(seq2) + joint_view(Sequence1& in_seq1, Sequence2& in_seq2) + : seq1(in_seq1) + , seq2(in_seq2) {} first_type first() const { return fusion::begin(seq1); } --- a/boost/fusion/view/joint_view/joint_view_iterator.hpp 2007-11-25 10:07:19.000000000 -0800 +++ b/boost/fusion/view/joint_view/joint_view_iterator.hpp 2009-05-14 13:18:46.000000000 -0700 @@ -37,9 +37,9 @@ typedef forward_traversal_tag category; BOOST_STATIC_ASSERT((!result_of::equal_to<first_type, last_type>::value)); - joint_view_iterator(First const& first, Concat const& concat) - : first(first_converter::call(first)) - , concat(concat_converter::call(concat)) + joint_view_iterator(First const& in_first, Concat const& in_concat) + : first(first_converter::call(in_first)) + , concat(concat_converter::call(in_concat)) {} first_type first; --- a/boost/fusion/view/single_view/single_view.hpp 2007-11-25 10:07:19.000000000 -0800 +++ b/boost/fusion/view/single_view/single_view.hpp 2009-05-14 13:21:08.000000000 -0700 @@ -35,8 +35,8 @@ single_view() : val() {} - explicit single_view(typename detail::call_param<T>::type val) - : val(val) {} + explicit single_view(typename detail::call_param<T>::type in_val) + : val(in_val) {} value_type val; }; --- a/boost/parameter/aux_/arg_list.hpp 2008-03-22 14:45:55.000000000 -0700 +++ b/boost/parameter/aux_/arg_list.hpp 2009-05-14 13:16:48.000000000 -0700 @@ -211,9 +211,9 @@ // Create a new list by prepending arg to a copy of tail. Used // when incrementally building this structure with the comma // operator. - arg_list(TaggedArg arg, Next const& tail) + arg_list(TaggedArg in_arg, Next const& tail) : Next(tail) - , arg(arg) + , arg(in_arg) {} // A metafunction class that, given a keyword and a default --- a/boost/parameter/aux_/maybe.hpp 2008-03-22 14:45:55.000000000 -0700 +++ b/boost/parameter/aux_/maybe.hpp 2009-05-14 13:16:03.000000000 -0700 @@ -33,8 +33,8 @@ BOOST_DEDUCED_TYPENAME remove_reference<reference>::type >::type non_cv_value; - explicit maybe(T value) - : value(value) + explicit maybe(T in_value) + : value(in_value) , constructed(false) {} @@ -48,23 +48,23 @@ this->destroy(); } - reference construct(reference value) const + reference construct(reference in_value) const { - return value; + return in_value; } template <class U> - reference construct2(U const& value) const + reference construct2(U const& in_value) const { - new (m_storage.bytes) non_cv_value(value); + new (m_storage.bytes) non_cv_value(in_value); constructed = true; return *(non_cv_value*)m_storage.bytes; } template <class U> - reference construct(U const& value) const + reference construct(U const& in_value) const { - return this->construct2(value); + return this->construct2(in_value); } void destroy() ---