Clean up GCC warnings. Fixes #3033.

[SVN r62869]

include/boost/fusion/adapted/boost_tuple/boost_tuple_iterator.hpp

@@ -47,8 +47,8 @@ namespace boost { namespace fusion
     {
         typedef Cons cons_type;
 
-        explicit boost_tuple_iterator(Cons& cons)
+        explicit boost_tuple_iterator(Cons& in_cons)
-            : cons(cons) {}
+            : cons(in_cons) {}
         Cons& cons;
 
         template <typename Iterator>

include/boost/fusion/adapted/class/detail/adapt_base.hpp

@@ -45,8 +45,8 @@
         typedef BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE, 0, ATTRIBUTE) lvalue; \
         typedef BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE, 1, ATTRIBUTE) rvalue; \
                                                                                 \
-        class_member_proxy(BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)& obj)\
+        class_member_proxy(BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)& o)  \
-          : obj(obj)                                                            \
+          : obj(o)                                                              \
         {}                                                                      \
                                                                                 \
         template<class Arg>                                                     \

include/boost/fusion/adapted/struct/adapt_assoc_struct.hpp

@@ -59,7 +59,7 @@
     TEMPLATE_PARAMS_SEQ,NAME_SEQ, I, ATTRIBUTE)                                 \
                                                                                 \
     BOOST_FUSION_ADAPT_ASSOC_STRUCT_C_BASE(                                     \
-        TEMPLATE_PARAMS_SEQ,NAME_SEQ,I,BOOST_PP_EMPTY(),ATTRIBUTE)
+        TEMPLATE_PARAMS_SEQ,NAME_SEQ,I,BOOST_PP_EMPTY,ATTRIBUTE)
 
 #define BOOST_FUSION_ADAPT_ASSOC_TPL_STRUCT(                                    \
     TEMPLATE_PARAMS_SEQ, NAME_SEQ, ATTRIBUTES)                                  \

include/boost/fusion/adapted/struct/adapt_struct.hpp

@@ -38,7 +38,7 @@
 
 #define BOOST_FUSION_ADAPT_STRUCT_C(TEMPLATE_PARAMS_SEQ, NAME_SEQ, I, ATTRIBUTE)\
     BOOST_FUSION_ADAPT_STRUCT_C_BASE(                                           \
-        TEMPLATE_PARAMS_SEQ,NAME_SEQ,I,BOOST_PP_EMPTY(),ATTRIBUTE,2)
+        TEMPLATE_PARAMS_SEQ,NAME_SEQ,I,BOOST_PP_EMPTY,ATTRIBUTE,2)
 
 #define BOOST_FUSION_ADAPT_TPL_STRUCT(TEMPLATE_PARAMS_SEQ,NAME_SEQ, ATTRIBUTES) \
     BOOST_FUSION_ADAPT_STRUCT_BASE(                                             \

include/boost/fusion/adapted/struct/detail/adapt_base.hpp

@@ -117,7 +117,7 @@
             static type                                                         \
             call(Seq& seq)                                                      \
             {                                                                   \
-                return seq.PREFIX                                               \
+                return seq.PREFIX()                                             \
                     BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE, 1, ATTRIBUTE);    \
             }                                                                   \
         };                                                                      \

include/boost/fusion/adapted/struct/detail/define_struct.hpp

@@ -17,6 +17,7 @@
 #include <boost/fusion/adapted/struct/detail/namespace.hpp>
 #include <boost/preprocessor/inc.hpp>
 #include <boost/preprocessor/if.hpp>
+#include <boost/preprocessor/expr_if.hpp>
 #include <boost/preprocessor/dec.hpp>
 #include <boost/preprocessor/logical/not.hpp>
 #include <boost/preprocessor/punctuation/comma_if.hpp>
@@ -42,7 +43,7 @@
 #define BOOST_FUSION_DEFINE_STRUCT_ASSIGN_FILLER_I(                             \
     R, ATTRIBUTE_TUPEL_SIZE, I_, ATTRIBUTE)                                     \
                                                                                 \
-    BOOST_PP_IF(                                                                \
+    BOOST_PP_EXPR_IF(                                                           \
         I_,                                                                     \
         typedef typename                                                        \
             boost::fusion::result_of::next<                                     \
@@ -50,9 +51,8 @@
             >::type                                                             \
         BOOST_PP_CAT(I,I_);                                                     \
         BOOST_PP_CAT(I,I_) BOOST_PP_CAT(i,I_)=                                  \
-            boost::fusion::next(BOOST_PP_CAT(i,BOOST_PP_DEC(I_)));,             \
+                boost::fusion::next(BOOST_PP_CAT(i,BOOST_PP_DEC(I_)));          \
-        BOOST_PP_EMPTY()                                                        \
+    )                                                                           \
-        )                                                                       \
                                                                                 \
     BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE,1,ATTRIBUTE)=                      \
         boost::fusion::deref(BOOST_PP_CAT(i,I_));

include/boost/fusion/adapted/struct/detail/proxy_type.hpp

@@ -18,8 +18,8 @@
                                                                                 \
     struct NAME                                                                 \
     {                                                                           \
-        NAME(WRAPPED_TYPE& obj)                                                 \
+        NAME(WRAPPED_TYPE& in_obj)                                              \
-          : obj(obj)                                                            \
+          : obj(in_obj)                                                         \
         {}                                                                      \
                                                                                 \
         WRAPPED_TYPE& obj;                                                      \

include/boost/fusion/algorithm/query/detail/count.hpp

@@ -50,8 +50,8 @@ namespace boost { namespace fusion { namespace detail
     struct count_compare
     {
         typedef typename detail::call_param<T1>::type param;
-        count_compare(param x)
+        count_compare(param in_x)
-            : x(x) {}
+            : x(in_x) {}
 
         template <typename T2>
         bool

include/boost/fusion/algorithm/transformation/detail/replace.hpp

@@ -41,8 +41,8 @@ namespace boost { namespace fusion { namespace detail
     template <typename T>
     struct replacer
     {
-        replacer(T const& old_value, T const& new_value)
+        replacer(T const& in_old_value, T const& in_new_value)
-            : old_value(old_value), new_value(new_value) {}
+            : old_value(in_old_value), new_value(in_new_value) {}
 
         template<typename Sig>
         struct result;

include/boost/fusion/algorithm/transformation/detail/replace_if.hpp

@@ -41,8 +41,8 @@ namespace boost { namespace fusion { namespace detail
     template <typename F, typename T>
     struct replacer_if
     {
-        replacer_if(F f, T const& new_value)
+        replacer_if(F in_f, T const& in_new_value)
-            : f(f), new_value(new_value) {}
+            : f(in_f), new_value(in_new_value) {}
 
         template<typename Params>
         struct result;

include/boost/fusion/container/list/cons.hpp

@@ -69,13 +69,13 @@ namespace boost { namespace fusion
         cons()
             : car(), cdr() {}
 
-        explicit cons(typename detail::call_param<Car>::type car)
+        explicit cons(typename detail::call_param<Car>::type in_car)
-            : car(car), cdr() {}
+            : car(in_car), cdr() {}
 
         cons(
-            typename detail::call_param<Car>::type car
+            typename detail::call_param<Car>::type in_car
-          , typename detail::call_param<Cdr>::type cdr)
+          , typename detail::call_param<Cdr>::type in_cdr)
-            : car(car), cdr(cdr) {}
+            : car(in_car), cdr(in_cdr) {}
         
         template <typename Car2, typename Cdr2>
         cons(cons<Car2, Cdr2> const& rhs)

include/boost/fusion/container/list/cons_iterator.hpp

@@ -35,8 +35,8 @@ namespace boost { namespace fusion
             typename add_const<Cons>::type> 
         identity;
 
-        explicit cons_iterator(cons_type& cons)
+        explicit cons_iterator(cons_type& in_cons)
-            : cons(cons) {}
+            : cons(in_cons) {}
 
         cons_type& cons;
 

include/boost/fusion/container/vector/vector_iterator.hpp

@@ -36,8 +36,8 @@ namespace boost { namespace fusion
         typedef vector_iterator_identity<
             typename add_const<Vector>::type, N> identity;
 
-        vector_iterator(Vector& vec)
+        vector_iterator(Vector& in_vec)
-            : vec(vec) {}
+            : vec(in_vec) {}
         Vector& vec;
 
     private:

include/boost/fusion/iterator/basic_iterator.hpp

@@ -122,8 +122,8 @@ namespace boost { namespace fusion
           : seq(it.seq)
         {}
 
-        basic_iterator(Seq& seq, int)
+        basic_iterator(Seq& in_seq, int)
-          : seq(&seq)
+          : seq(&in_seq)
         {}
 
         template<typename OtherSeq>

include/boost/fusion/sequence/comparison/detail/equal_to.hpp

@@ -50,7 +50,7 @@ namespace boost { namespace fusion { namespace detail
     {
         template <typename I1, typename I2>
         static bool
-        call(I1 const& a, I2 const& b)
+        call(I1 const& /*a*/, I2 const& /*b*/)
         {
             return false;
         }

include/boost/fusion/view/filter_view/filter_view.hpp

@@ -45,8 +45,8 @@ namespace boost { namespace fusion
         typedef typename result_of::end<Sequence>::type last_type;
         typedef Pred pred_type;
 
-        filter_view(Sequence& seq)
+        filter_view(Sequence& in_seq)
-            : seq(seq)
+            : seq(in_seq)
         {}
 
         first_type first() const { return fusion::begin(seq); }

include/boost/fusion/view/filter_view/filter_view_iterator.hpp

@@ -54,8 +54,8 @@ namespace boost { namespace fusion
         typedef last_iter last_type;
         typedef Pred pred_type;
 
-        filter_iterator(First const& first)
+        filter_iterator(First const& in_first)
-            : first(filter::call(first_converter::call(first))) {}
+            : first(filter::call(first_converter::call(in_first))) {}
 
         first_type first;
 

include/boost/fusion/view/iterator_range/iterator_range.hpp

@@ -41,9 +41,9 @@ namespace boost { namespace fusion
 
         typedef typename traits::category_of<begin_type>::type category;
 
-        iterator_range(First const& first, Last const& last)
+        iterator_range(First const& in_first, Last const& in_last)
-            : first(convert_iterator<First>::call(first))
+            : first(convert_iterator<First>::call(in_first))
-            , last(convert_iterator<Last>::call(last)) {}
+            , last(convert_iterator<Last>::call(in_last)) {}
 
         begin_type first;
         end_type last;

include/boost/fusion/view/joint_view/joint_view.hpp

@@ -52,9 +52,9 @@ namespace boost { namespace fusion
         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)
+        joint_view(Sequence1& in_seq1, Sequence2& in_seq2)
-            : seq1(seq1)
+            : seq1(in_seq1)
-            , seq2(seq2)
+            , seq2(in_seq2)
         {}
 
         first_type first() const { return fusion::begin(seq1); }

include/boost/fusion/view/joint_view/joint_view_iterator.hpp

@@ -40,9 +40,9 @@ namespace boost { namespace fusion
         typedef Category category;
         BOOST_STATIC_ASSERT((!result_of::equal_to<first_type, last_type>::value));
 
-        joint_view_iterator(First const& first, Concat const& concat)
+        joint_view_iterator(First const& in_first, Concat const& in_concat)
-            : first(first_converter::call(first))
+            : first(first_converter::call(in_first))
-            , concat(concat_converter::call(concat))
+            , concat(concat_converter::call(in_concat))
         {}
 
         first_type first;

include/boost/fusion/view/nview/nview_iterator.hpp

@@ -41,8 +41,8 @@ namespace boost { namespace fusion
         typedef Sequence sequence_type;
         typedef mpl_iterator<Pos> first_type;
 
-        explicit nview_iterator(Sequence& seq)
+        explicit nview_iterator(Sequence& in_seq)
-          : seq(seq) {}
+          : seq(in_seq) {}
 
         Sequence& seq;
 

include/boost/fusion/view/repetitive_view/repetitive_view.hpp

@@ -37,8 +37,8 @@ namespace boost { namespace fusion
             mpl::if_<traits::is_view<Sequence>, Sequence, sequence_type&>::type
         stored_seq_type;
 
-        repetitive_view(Sequence& seq)
+        repetitive_view(Sequence& in_seq)
-            : seq(seq) {}
+            : seq(in_seq) {}
 
         stored_seq_type seq;
 

include/boost/fusion/view/repetitive_view/repetitive_view_iterator.hpp

@@ -35,11 +35,11 @@ namespace boost { namespace fusion
         typedef typename convert_iterator<typename result_of::end<Sequence>::type>::type end_type;
         typedef single_pass_traversal_tag category;
 
-        explicit repetitive_view_iterator(Sequence& seq)
+        explicit repetitive_view_iterator(Sequence& in_seq)
-            : seq(seq), pos(begin(seq)) {}
+            : seq(in_seq), pos(begin(in_seq)) {}
 
-        repetitive_view_iterator(Sequence& seq, pos_type const& pos)
+        repetitive_view_iterator(Sequence& in_seq, pos_type const& in_pos)
-            : seq(seq), pos(pos) {}
+            : seq(in_seq), pos(in_pos) {}
 
         Sequence& seq;
         pos_type pos;

include/boost/fusion/view/reverse_view/reverse_view.hpp

@@ -49,8 +49,8 @@ namespace boost { namespace fusion
                 bidirectional_traversal_tag
               , typename traits::category_of<first_type>::type>::value));
 
-        reverse_view(Sequence& seq)
+        reverse_view(Sequence& in_seq)
-            : seq(seq)
+            : seq(in_seq)
         {}
 
         first_type first() const { return fusion::begin(seq); }

include/boost/fusion/view/reverse_view/reverse_view_iterator.hpp

@@ -41,8 +41,8 @@ namespace boost { namespace fusion
                 bidirectional_traversal_tag
               , category>::value));
 
-        reverse_view_iterator(First const& first)
+        reverse_view_iterator(First const& in_first)
-            : first(converter::call(first)) {}
+            : first(converter::call(in_first)) {}
 
         first_type first;
 

include/boost/fusion/view/single_view/single_view.hpp

@@ -41,8 +41,8 @@ namespace boost { namespace fusion
         single_view()
             : val() {}
 
-        explicit single_view(typename detail::call_param<T>::type val)
+        explicit single_view(typename detail::call_param<T>::type in_val)
-            : val(val) {}
+            : val(in_val) {}
 
         value_type val;
     };

include/boost/fusion/view/transform_view/transform_view.hpp

@@ -55,10 +55,10 @@ namespace boost { namespace fusion
         typedef Sequence2 sequence2_type;
         typedef F transform_type;
 
-        transform_view(Sequence1& seq1, Sequence2& seq2, F const& binop)
+        transform_view(Sequence1& in_seq1, Sequence2& in_seq2, F const& binop)
             : f(binop)
-            , seq1(seq1)
+            , seq1(in_seq1)
-            , seq2(seq2)
+            , seq2(in_seq2)
         {}
 
         first1_type first1() const { return fusion::begin(seq1); }
@@ -94,9 +94,9 @@ namespace boost { namespace fusion
         typedef Sequence sequence_type;
         typedef F transform_type;
 
-        transform_view(Sequence& seq, F const& f)
+        transform_view(Sequence& in_seq, F const& in_f)
-            : seq(seq)
+            : seq(in_seq)
-            , f(f)
+            , f(in_f)
         {}
 
         first_type first() const { return fusion::begin(seq); }

include/boost/fusion/view/transform_view/transform_view_iterator.hpp

@@ -34,8 +34,8 @@ namespace boost { namespace fusion
         typedef typename traits::category_of<first_type>::type category;
         typedef F transform_type;
 
-        transform_view_iterator(First const& first, F const& f)
+        transform_view_iterator(First const& in_first, F const& in_f)
-            : first(converter::call(first)), f(f) {}
+            : first(converter::call(in_first)), f(in_f) {}
 
         first_type first;
         transform_type f;
@@ -60,8 +60,8 @@ namespace boost { namespace fusion
         typedef typename traits::category_of<first1_type>::type category;
         typedef F transform_type;
 
-        transform_view_iterator2(First1 const& first1, First2 const& first2, F const& f)
+        transform_view_iterator2(First1 const& in_first1, First2 const& in_first2, F const& in_f)
-            : first1(converter1::call(first1)), first2(converter2::call(first2)), f(f) {}
+            : first1(converter1::call(in_first1)), first2(converter2::call(in_first2)), f(in_f) {}
 
         first1_type first1;
         first2_type first2;

test/algorithm/all.cpp

@@ -16,8 +16,8 @@ namespace
 {
     struct search_for
     {
-        explicit search_for(int search)
+        explicit search_for(int in_search)
-            : search(search)
+            : search(in_search)
         {}
 
         template<typename T>

test/algorithm/any.cpp

@@ -17,8 +17,8 @@ namespace
 {
     struct search_for
     {
-        explicit search_for(int search)
+        explicit search_for(int in_search)
-            : search(search)
+            : search(in_search)
         {}
 
         template<typename T>

test/algorithm/fold.cpp

@@ -81,8 +81,8 @@ struct count_ints
     typename result<count_ints(CountT, T)>::type
     operator()(CountT const&, T const&) const
     {
-        typedef typename result<count_ints(CountT, T)>::type result;
+        typedef typename result<count_ints(CountT, T)>::type result_;
-        return result();
+        return result_();
     }
 };
 

test/algorithm/none.cpp

@@ -16,8 +16,8 @@ namespace
 {
     struct search_for
     {
-        explicit search_for(int search)
+        explicit search_for(int in_search)
-            : search(search)
+            : search(in_search)
         {}
 
         template<typename T>

test/sequence/adapt_assoc_class.cpp

@@ -31,7 +31,7 @@ namespace ns
     public:
     
         point() : x(0), y(0) {}
-        point(int x, int y) : x(x), y(y) {}
+        point(int in_x, int in_y) : x(in_x), y(in_y) {}
             
         int get_x() const { return x; }
         int get_y() const { return y; }

test/sequence/adapt_assoc_class_named.cpp

@@ -31,7 +31,7 @@ namespace ns
     public:
     
         point() : x(0), y(0) {}
-        point(int x, int y) : x(x), y(y) {}
+        point(int in_x, int in_y) : x(in_x), y(in_y) {}
             
         int get_x() const { return x; }
         int get_y() const { return y; }

test/sequence/adapt_assoc_tpl_class.cpp

@@ -32,7 +32,7 @@ namespace ns
     public:
     
         point() : x(0), y(0) {}
-        point(X x, Y y) : x(x), y(y) {}
+        point(X in_x, Y in_y) : x(in_x), y(in_y) {}
             
         X get_x() const { return x; }
         Y get_y() const { return y; }

test/sequence/adapt_class.cpp

@@ -38,7 +38,7 @@ namespace ns
     public:
     
         point() : x(0), y(0) {}
-        point(int x, int y) : x(x), y(y) {}
+        point(int in_x, int in_y) : x(in_x), y(in_y) {}
             
         int get_x() const { return x; }
         int get_y() const { return y; }

test/sequence/adapt_class_named.cpp

@@ -38,7 +38,7 @@ namespace ns
     public:
     
         point() : x(0), y(0) {}
-        point(int x, int y) : x(x), y(y) {}
+        point(int in_x, int in_y) : x(in_x), y(in_y) {}
             
         int get_x() const { return x; }
         int get_y() const { return y; }

test/sequence/adapt_tpl_class.cpp

@@ -40,7 +40,7 @@ namespace ns
     public:
     
         point() : x(0), y(0) {}
-        point(X x, Y y) : x(x), y(y) {}
+        point(X x_, Y y_) : x(x_), y(y_) {}
             
         X get_x() const { return x; }
         Y get_y() const { return y; }

test/sequence/nview.cpp

@@ -26,7 +26,7 @@ BOOST_FUSION_ADAPT_STRUCT(
     (int, int_)
     (std::string, string_)
     (double, double_)
-);
+)
 
 namespace fusion = boost::fusion;