Ticket #7432: boost-warnings.diff

boost/circular_buffer/base.hpp

@@ -2316 +2316 @@
     }
 
     //! Specialized method for swapping the allocator.
-    void swap_allocator(circular_buffer<T, Alloc>& cb, const true_type&) {
+    void swap_allocator(circular_buffer<T, Alloc>&, const true_type&) {
         // Swap is not needed because allocators have no state.
     }
 

boost/circular_buffer/space_optimized.hpp

@@ -1300 +1300 @@
 
     //! Specialized method for determining the initial capacity.
     template <class IntegralType>
-    static size_type init_capacity(const capacity_type& capacity_ctrl, IntegralType n, IntegralType item,
+    static size_type init_capacity(const capacity_type& capacity_ctrl, IntegralType n, IntegralType,
         const true_type&) {
         return init_capacity(capacity_ctrl, static_cast<size_type>(n));
     }
@@ -1320 +1320 @@
 
     //! Specialized method for determining the initial capacity.
     template <class InputIterator>
-    static size_type init_capacity(const capacity_type& capacity_ctrl, InputIterator first, InputIterator last,
+    static size_type init_capacity(const capacity_type& capacity_ctrl, InputIterator, InputIterator,
         const std::input_iterator_tag&) {
         return capacity_ctrl.capacity();
     }

boost/detail/utf8_codecvt_facet.hpp

@@ -179 +179 @@
         ) const;
 #endif
 
+    using std::codecvt<wchar_t, char, std::mbstate_t>::do_length;
+
     // Largest possible value do_length(state,from,from_end,1) could return.
     virtual int do_max_length() const throw () {
         return 6; // largest UTF-8 encoding of a UCS-4 character

boost/lambda/detail/ret.hpp

@@ -284 +284 @@
 lambda_functor<
   lambda_functor_base<do_nothing_action, null_type> 
 > 
-make_void(const Arg1& a1) { 
+make_void(const Arg1& /*a1*/) { 
 return 
     lambda_functor_base<do_nothing_action, null_type>();
 }

boost/multi_index/detail/index_matcher.hpp

@@ -132 +132 @@
         entries(),entries()+size_,
         entry(node),entry::less_by_node()); /* localize entry */
     ent->ordered=false;
-    std::size_t n=ent->pos;                 /* get its position */
+    std::size_t np=ent->pos;                 /* get its position */
 
     entry dummy(0);
-    dummy.pile_top=n;
+    dummy.pile_top=np;
 
     entry* pile_ent=                        /* find the first available pile */
       std::lower_bound(                     /* to stack the entry            */
         entries(),entries()+num_piles,
         dummy,entry::less_by_pile_top());
 
-    pile_ent->pile_top=n;                   /* stack the entry */
+    pile_ent->pile_top=np;                   /* stack the entry */
     pile_ent->pile_top_entry=ent;        
 
     /* if not the first pile, link entry to top of the preceding pile */
@@ -164 +164 @@
        */
 
       entry* ent=entries()[num_piles-1].pile_top_entry;
-      for(std::size_t n=num_piles;n--;){
+      for(std::size_t np=num_piles;np--;){
         ent->ordered=true;
         ent=ent->previous;
       }

boost/multi_index/ordered_index.hpp

@@ -438 +438 @@
 
   template<typename CompatibleKey,typename CompatibleCompare>
   iterator find(
-    const CompatibleKey& x,const CompatibleCompare& comp)const
+    const CompatibleKey& x,const CompatibleCompare& comp_)const
   {
-    return make_iterator(ordered_index_find(root(),header(),key,x,comp));
+    return make_iterator(ordered_index_find(root(),header(),key,x,comp_));
   }
 
   template<typename CompatibleKey>
@@ -450 +450 @@
   }
 
   template<typename CompatibleKey,typename CompatibleCompare>
-  size_type count(const CompatibleKey& x,const CompatibleCompare& comp)const
+  size_type count(const CompatibleKey& x,const CompatibleCompare& comp_)const
   {
-    std::pair<iterator,iterator> p=equal_range(x,comp);
+    std::pair<iterator,iterator> p=equal_range(x,comp_);
     size_type n=std::distance(p.first,p.second);
     return n;
   }
@@ -466 +466 @@
 
   template<typename CompatibleKey,typename CompatibleCompare>
   iterator lower_bound(
-    const CompatibleKey& x,const CompatibleCompare& comp)const
+    const CompatibleKey& x,const CompatibleCompare& comp_)const
   {
     return make_iterator(
-      ordered_index_lower_bound(root(),header(),key,x,comp));
+      ordered_index_lower_bound(root(),header(),key,x,comp_));
   }
 
   template<typename CompatibleKey>
@@ -481 +481 @@
 
   template<typename CompatibleKey,typename CompatibleCompare>
   iterator upper_bound(
-    const CompatibleKey& x,const CompatibleCompare& comp)const
+    const CompatibleKey& x,const CompatibleCompare& comp_)const
   {
     return make_iterator(
-      ordered_index_upper_bound(root(),header(),key,x,comp));
+      ordered_index_upper_bound(root(),header(),key,x,comp_));
   }
 
   template<typename CompatibleKey>
@@ -499 +499 @@
 
   template<typename CompatibleKey,typename CompatibleCompare>
   std::pair<iterator,iterator> equal_range(
-    const CompatibleKey& x,const CompatibleCompare& comp)const
+    const CompatibleKey& x,const CompatibleCompare& comp_)const
   {
     std::pair<node_type*,node_type*> p=
-      ordered_index_equal_range(root(),header(),key,x,comp);
+      ordered_index_equal_range(root(),header(),key,x,comp_);
     return std::pair<iterator,iterator>(
       make_iterator(p.first),make_iterator(p.second));
   }

boost/optional/optional.hpp

@@ -890 +890 @@
 
 template<class T>
 inline
-bool operator == ( none_t x, optional<T> const& y )
+bool operator == ( none_t, optional<T> const& y )
 { return equal_pointees(optional<T>() ,y); }
 
 template<class T>
 inline
-bool operator < ( none_t x, optional<T> const& y )
+bool operator < ( none_t, optional<T> const& y )
 { return less_pointees(optional<T>() ,y); }
 
 template<class T>

boost/parameter/aux_/tagged_argument.hpp

@@ -120 +120 @@
     }
 # else
     template <class Default>
-    reference operator[](default_<key_type,Default> const& x) const
+    reference operator[](default_<key_type,Default> const&) const
     {
         return value;
     }
 
     template <class F>
-    reference operator[](lazy_default<key_type,F> const& x) const
+    reference operator[](lazy_default<key_type,F> const&) const
     {
         return value;
     }

boost/regex/v4/basic_regex_parser.hpp

@@ -1107 +1107 @@
       }
       // get the value if any:
       v = this->m_traits.toi(m_position, m_end, 10);
-      max = (v >= 0) ? v : (std::numeric_limits<std::size_t>::max)();
+      max = (v >= 0) ? (std::size_t)v : (std::numeric_limits<std::size_t>::max)();
    }
    else
    {

boost/serialization/smart_cast.hpp

@@ -249 +249 @@
         // cast on a system which doesn't support partial template 
         // specialization
         template<class U>
-        static T cast(U u){
+        static T cast(U){
             BOOST_STATIC_ASSERT(sizeof(T)==0);
             return * static_cast<T *>(NULL);
         }

boost/token_functions.hpp

@@ -309 +309 @@
   template <>
   struct assign_or_plus_equal<std::input_iterator_tag> {
     template<class Iterator, class Token>
-    static void assign(Iterator b, Iterator e, Token &t) { }
+    static void assign(Iterator, Iterator, Token &) { }
     template<class Token, class Value> 
     static void plus_equal(Token &t, const Value &v) {
       t += v;

boost/xpressive/match_results.hpp

@@ -934 +934 @@
     (
         OutputIterator out
       , Expr const &format
-      , regex_constants::match_flag_type flags
+      , regex_constants::match_flag_type
       , mpl::size_t<4>
     ) const
     {

boost/xpressive/traits/cpp_regex_traits.hpp

@@ -467 +467 @@
     ///
     /// \attention Not currently used
     template<typename FwdIter>
-    string_type transform(FwdIter begin, FwdIter end) const
+    string_type transform(FwdIter, FwdIter) const
     {
         //string_type str(begin, end);
         //return this->transform(str.data(), str.data() + str.size());
@@ -483 +483 @@
     ///
     /// \attention Not currently used
     template<typename FwdIter>
-    string_type transform_primary(FwdIter begin, FwdIter end) const
+    string_type transform_primary(FwdIter, FwdIter ) const
     {
         BOOST_ASSERT(false); // TODO implement me
         return string_type();
@@ -495 +495 @@
     ///
     /// \attention Not currently used
     template<typename FwdIter>
-    string_type lookup_collatename(FwdIter begin, FwdIter end) const
+    string_type lookup_collatename(FwdIter, FwdIter) const
     {
         BOOST_ASSERT(false); // TODO implement me
         return string_type();