diff -ru boost.orig/boost/bind/bind.hpp boost/boost/bind/bind.hpp
--- foo/misc/boost.orig/boost/bind/bind.hpp	2015-05-04 00:08:08.000000000 +0200
+++ foo/misc/boost/boost/bind/bind.hpp	2015-07-16 22:47:55.972950054 +0200
@@ -145,7 +145,7 @@
 
 template<class F> struct unwrapper
 {
-    static inline F & unwrap( F & f, long )
+    static inline F & unwrap( F & f, __attribute__ ((unused)) long )
     {
         return f;
     }
@@ -228,7 +228,7 @@
 
     A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
 
-    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A1 operator[] (__attribute__ ((unused)) boost::arg<1> (*) ()) const { return base_type::a1_; }
 
     template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
 
@@ -240,22 +240,22 @@
 
     template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 
-    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, __attribute__ ((unused)) long)
     {
         return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);
     }
 
-    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, __attribute__ ((unused)) long) const
     {
         return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_]);
     }
 
-    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
+    template<class F, class A> void operator()(type<void>, F & f, A & a, __attribute__ ((unused)) int)
     {
         unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);
     }
 
-    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, __attribute__ ((unused)) int) const
     {
         unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_]);
     }
@@ -284,11 +284,11 @@
 
     list2( A1 a1, A2 a2 ): base_type( a1, a2 ) {}
 
-    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
-    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
+    A1 operator[] (__attribute__ ((unused)) boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (__attribute__ ((unused)) boost::arg<2>) const { return base_type::a2_; }
 
-    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
-    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
+    A1 operator[] (__attribute__ ((unused)) boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A2 operator[] (__attribute__ ((unused)) boost::arg<2> (*) ()) const { return base_type::a2_; }
 
     template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
 
@@ -300,42 +300,42 @@
 
     template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 
-    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, __attribute__ ((unused)) long)
     {
         return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
     }
 
-    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, __attribute__ ((unused)) long) const
     {
         return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
     }
 
-    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
+    template<class F, class A> void operator()(type<void>, F & f, A & a, __attribute__ ((unused)) int)
     {
         unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
     }
 
-    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, __attribute__ ((unused)) int) const
     {
         unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
     }
 
-    template<class A> bool operator()( type<bool>, logical_and & /*f*/, A & a, int )
+    template<class A> bool operator()( type<bool>, logical_and & /*f*/, A & a,  __attribute__ ((unused)) int )
     {
         return a[ base_type::a1_ ] && a[ base_type::a2_ ];
     }
 
-    template<class A> bool operator()( type<bool>, logical_and const & /*f*/, A & a, int ) const
+    template<class A> bool operator()( type<bool>, logical_and const & /*f*/, A & a,  __attribute__ ((unused)) int ) const
     {
         return a[ base_type::a1_ ] && a[ base_type::a2_ ];
     }
 
-    template<class A> bool operator()( type<bool>, logical_or & /*f*/, A & a, int )
+    template<class A> bool operator()( type<bool>, logical_or & /*f*/, A & a,  __attribute__ ((unused)) int )
     {
         return a[ base_type::a1_ ] || a[ base_type::a2_ ];
     }
 
-    template<class A> bool operator()( type<bool>, logical_or const & /*f*/, A & a, int ) const
+    template<class A> bool operator()( type<bool>, logical_or const & /*f*/, A & a,  __attribute__ ((unused)) int ) const
     {
         return a[ base_type::a1_ ] || a[ base_type::a2_ ];
     }
@@ -361,13 +361,13 @@
 
     list3( A1 a1, A2 a2, A3 a3 ): base_type( a1, a2, a3 ) {}
 
-    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
-    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
-    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
-
-    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
-    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
-    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
+    A1 operator[] (__attribute__ ((unused)) boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (__attribute__ ((unused)) boost::arg<2>) const { return base_type::a2_; }
+    A3 operator[] (__attribute__ ((unused)) boost::arg<3>) const { return base_type::a3_; }
+
+    A1 operator[] (__attribute__ ((unused)) boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A2 operator[] (__attribute__ ((unused)) boost::arg<2> (*) ()) const { return base_type::a2_; }
+    A3 operator[] (__attribute__ ((unused)) boost::arg<3> (*) ()) const { return base_type::a3_; }
 
     template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
 
@@ -379,22 +379,22 @@
 
     template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 
-    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, __attribute__ ((unused)) long)
     {
         return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
     }
 
-    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, __attribute__ ((unused)) long) const
     {
         return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
     }
 
-    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
+    template<class F, class A> void operator()(type<void>, F & f, A & a, __attribute__ ((unused)) int)
     {
         unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
     }
 
-    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, __attribute__ ((unused)) int) const
     {
         unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
     }
@@ -424,15 +424,15 @@
 
     list4( A1 a1, A2 a2, A3 a3, A4 a4 ): base_type( a1, a2, a3, a4 ) {}
 
-    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
-    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
-    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
-    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
-
-    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
-    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
-    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
-    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
+    A1 operator[] (__attribute__ ((unused)) boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (__attribute__ ((unused)) boost::arg<2>) const { return base_type::a2_; }
+    A3 operator[] (__attribute__ ((unused)) boost::arg<3>) const { return base_type::a3_; }
+    A4 operator[] (__attribute__ ((unused)) boost::arg<4>) const { return base_type::a4_; }
+
+    A1 operator[] (__attribute__ ((unused)) boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A2 operator[] (__attribute__ ((unused)) boost::arg<2> (*) ()) const { return base_type::a2_; }
+    A3 operator[] (__attribute__ ((unused)) boost::arg<3> (*) ()) const { return base_type::a3_; }
+    A4 operator[] (__attribute__ ((unused)) boost::arg<4> (*) ()) const { return base_type::a4_; }
 
     template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
 
@@ -444,22 +444,22 @@
 
     template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 
-    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, __attribute__ ((unused)) long)
     {
         return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
     }
 
-    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, __attribute__ ((unused)) long) const
     {
         return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
     }
 
-    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
+    template<class F, class A> void operator()(type<void>, F & f, A & a, __attribute__ ((unused)) int)
     {
         unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
     }
 
-    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, __attribute__ ((unused)) int) const
     {
         unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
     }
@@ -490,11 +490,11 @@
 
     list5( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5 ): base_type( a1, a2, a3, a4, a5 ) {}
 
-    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
-    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
-    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
-    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
-    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
+    A1 operator[] (__attribute__ ((unused)) boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (__attribute__ ((unused)) boost::arg<2>) const { return base_type::a2_; }
+    A3 operator[] (__attribute__ ((unused)) boost::arg<3>) const { return base_type::a3_; }
+    A4 operator[] (__attribute__ ((unused)) boost::arg<4>) const { return base_type::a4_; }
+    A5 operator[] (__attribute__ ((unused)) boost::arg<5>) const { return base_type::a5_; }
 
     A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
     A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
@@ -512,12 +512,12 @@
 
     template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 
-    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, __attribute__ ((unused)) long)
     {
         return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
     }
 
-    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, __attribute__ ((unused)) long) const
     {
         return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
     }
@@ -527,7 +527,7 @@
         unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
     }
 
-    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, __attribute__ ((unused)) int) const
     {
         unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
     }
@@ -559,19 +559,19 @@
 
     list6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6 ): base_type( a1, a2, a3, a4, a5, a6 ) {}
 
-    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
-    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
-    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
-    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
-    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
-    A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
-
-    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
-    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
-    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
-    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
-    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
-    A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
+    A1 operator[] (__attribute__ ((unused)) boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (__attribute__ ((unused)) boost::arg<2>) const { return base_type::a2_; }
+    A3 operator[] (__attribute__ ((unused)) boost::arg<3>) const { return base_type::a3_; }
+    A4 operator[] (__attribute__ ((unused)) boost::arg<4>) const { return base_type::a4_; }
+    A5 operator[] (__attribute__ ((unused)) boost::arg<5>) const { return base_type::a5_; }
+    A6 operator[] (__attribute__ ((unused)) boost::arg<6>) const { return base_type::a6_; }
+
+    A1 operator[] (__attribute__ ((unused)) boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A2 operator[] (__attribute__ ((unused)) boost::arg<2> (*) ()) const { return base_type::a2_; }
+    A3 operator[] (__attribute__ ((unused)) boost::arg<3> (*) ()) const { return base_type::a3_; }
+    A4 operator[] (__attribute__ ((unused)) boost::arg<4> (*) ()) const { return base_type::a4_; }
+    A5 operator[] (__attribute__ ((unused)) boost::arg<5> (*) ()) const { return base_type::a5_; }
+    A6 operator[] (__attribute__ ((unused)) boost::arg<6> (*) ()) const { return base_type::a6_; }
 
     template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
 
@@ -583,12 +583,12 @@
 
     template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 
-    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, __attribute__ ((unused)) long)
     {
         return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
     }
 
-    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, __attribute__ ((unused)) long) const
     {
         return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
     }
@@ -598,7 +598,7 @@
         unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
     }
 
-    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, __attribute__ ((unused)) int) const
     {
         unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
     }
@@ -631,21 +631,21 @@
 
     list7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7 ): base_type( a1, a2, a3, a4, a5, a6, a7 ) {}
 
-    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
-    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
-    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
-    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
-    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
-    A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
-    A7 operator[] (boost::arg<7>) const { return base_type::a7_; }
-
-    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
-    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
-    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
-    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
-    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
-    A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
-    A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }
+    A1 operator[] (__attribute__ ((unused)) boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (__attribute__ ((unused)) boost::arg<2>) const { return base_type::a2_; }
+    A3 operator[] (__attribute__ ((unused)) boost::arg<3>) const { return base_type::a3_; }
+    A4 operator[] (__attribute__ ((unused)) boost::arg<4>) const { return base_type::a4_; }
+    A5 operator[] (__attribute__ ((unused)) boost::arg<5>) const { return base_type::a5_; }
+    A6 operator[] (__attribute__ ((unused)) boost::arg<6>) const { return base_type::a6_; }
+    A7 operator[] (__attribute__ ((unused)) boost::arg<7>) const { return base_type::a7_; }
+
+    A1 operator[] (__attribute__ ((unused)) boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A2 operator[] (__attribute__ ((unused)) boost::arg<2> (*) ()) const { return base_type::a2_; }
+    A3 operator[] (__attribute__ ((unused)) boost::arg<3> (*) ()) const { return base_type::a3_; }
+    A4 operator[] (__attribute__ ((unused)) boost::arg<4> (*) ()) const { return base_type::a4_; }
+    A5 operator[] (__attribute__ ((unused)) boost::arg<5> (*) ()) const { return base_type::a5_; }
+    A6 operator[] (__attribute__ ((unused)) boost::arg<6> (*) ()) const { return base_type::a6_; }
+    A7 operator[] (__attribute__ ((unused)) boost::arg<7> (*) ()) const { return base_type::a7_; }
 
     template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
 
@@ -657,22 +657,22 @@
 
     template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 
-    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, __attribute__ ((unused)) long)
     {
         return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
     }
 
-    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, __attribute__ ((unused)) long) const
     {
         return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
     }
 
-    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
+    template<class F, class A> void operator()(type<void>, F & f, A & a, __attribute__ ((unused)) int)
     {
         unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
     }
 
-    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, __attribute__ ((unused)) int) const
     {
         unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
     }
@@ -706,23 +706,23 @@
 
     list8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8 ): base_type( a1, a2, a3, a4, a5, a6, a7, a8 ) {}
 
-    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
-    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
-    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
-    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
-    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
-    A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
-    A7 operator[] (boost::arg<7>) const { return base_type::a7_; }
-    A8 operator[] (boost::arg<8>) const { return base_type::a8_; }
-
-    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
-    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
-    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
-    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
-    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
-    A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
-    A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }
-    A8 operator[] (boost::arg<8> (*) ()) const { return base_type::a8_; }
+    A1 operator[] (__attribute__ ((unused)) boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (__attribute__ ((unused)) boost::arg<2>) const { return base_type::a2_; }
+    A3 operator[] (__attribute__ ((unused)) boost::arg<3>) const { return base_type::a3_; }
+    A4 operator[] (__attribute__ ((unused)) boost::arg<4>) const { return base_type::a4_; }
+    A5 operator[] (__attribute__ ((unused)) boost::arg<5>) const { return base_type::a5_; }
+    A6 operator[] (__attribute__ ((unused)) boost::arg<6>) const { return base_type::a6_; }
+    A7 operator[] (__attribute__ ((unused)) boost::arg<7>) const { return base_type::a7_; }
+    A8 operator[] (__attribute__ ((unused)) boost::arg<8>) const { return base_type::a8_; }
+
+    A1 operator[] (__attribute__ ((unused)) boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A2 operator[] (__attribute__ ((unused)) boost::arg<2> (*) ()) const { return base_type::a2_; }
+    A3 operator[] (__attribute__ ((unused)) boost::arg<3> (*) ()) const { return base_type::a3_; }
+    A4 operator[] (__attribute__ ((unused)) boost::arg<4> (*) ()) const { return base_type::a4_; }
+    A5 operator[] (__attribute__ ((unused)) boost::arg<5> (*) ()) const { return base_type::a5_; }
+    A6 operator[] (__attribute__ ((unused)) boost::arg<6> (*) ()) const { return base_type::a6_; }
+    A7 operator[] (__attribute__ ((unused)) boost::arg<7> (*) ()) const { return base_type::a7_; }
+    A8 operator[] (__attribute__ ((unused)) boost::arg<8> (*) ()) const { return base_type::a8_; }
 
     template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
 
@@ -734,22 +734,22 @@
 
     template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 
-    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, __attribute__ ((unused)) long)
     {
         return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
     }
 
-    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, __attribute__ ((unused)) long) const
     {
         return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
     }
 
-    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
+    template<class F, class A> void operator()(type<void>, F & f, A & a, __attribute__ ((unused)) int)
     {
         unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
     }
 
-    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, __attribute__ ((unused)) int) const
     {
         unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
     }
@@ -784,25 +784,25 @@
 
     list9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9 ): base_type( a1, a2, a3, a4, a5, a6, a7, a8, a9 ) {}
 
-    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
-    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
-    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
-    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
-    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
-    A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
-    A7 operator[] (boost::arg<7>) const { return base_type::a7_; }
-    A8 operator[] (boost::arg<8>) const { return base_type::a8_; }
-    A9 operator[] (boost::arg<9>) const { return base_type::a9_; }
-
-    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
-    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
-    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
-    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
-    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
-    A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
-    A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }
-    A8 operator[] (boost::arg<8> (*) ()) const { return base_type::a8_; }
-    A9 operator[] (boost::arg<9> (*) ()) const { return base_type::a9_; }
+    A1 operator[] (__attribute__ ((unused)) boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (__attribute__ ((unused)) boost::arg<2>) const { return base_type::a2_; }
+    A3 operator[] (__attribute__ ((unused)) boost::arg<3>) const { return base_type::a3_; }
+    A4 operator[] (__attribute__ ((unused)) boost::arg<4>) const { return base_type::a4_; }
+    A5 operator[] (__attribute__ ((unused)) boost::arg<5>) const { return base_type::a5_; }
+    A6 operator[] (__attribute__ ((unused)) boost::arg<6>) const { return base_type::a6_; }
+    A7 operator[] (__attribute__ ((unused)) boost::arg<7>) const { return base_type::a7_; }
+    A8 operator[] (__attribute__ ((unused)) boost::arg<8>) const { return base_type::a8_; }
+    A9 operator[] (__attribute__ ((unused)) boost::arg<9>) const { return base_type::a9_; }
+
+    A1 operator[] (__attribute__ ((unused)) boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A2 operator[] (__attribute__ ((unused)) boost::arg<2> (*) ()) const { return base_type::a2_; }
+    A3 operator[] (__attribute__ ((unused)) boost::arg<3> (*) ()) const { return base_type::a3_; }
+    A4 operator[] (__attribute__ ((unused)) boost::arg<4> (*) ()) const { return base_type::a4_; }
+    A5 operator[] (__attribute__ ((unused)) boost::arg<5> (*) ()) const { return base_type::a5_; }
+    A6 operator[] (__attribute__ ((unused)) boost::arg<6> (*) ()) const { return base_type::a6_; }
+    A7 operator[] (__attribute__ ((unused)) boost::arg<7> (*) ()) const { return base_type::a7_; }
+    A8 operator[] (__attribute__ ((unused)) boost::arg<8> (*) ()) const { return base_type::a8_; }
+    A9 operator[] (__attribute__ ((unused)) boost::arg<9> (*) ()) const { return base_type::a9_; }
 
     template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
 
@@ -814,22 +814,22 @@
 
     template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 
-    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, __attribute__ ((unused)) long)
     {
         return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
     }
 
-    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, __attribute__ ((unused)) long) const
     {
         return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
     }
 
-    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
+    template<class F, class A> void operator()(type<void>, F & f, A & a, __attribute__ ((unused)) int)
     {
         unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
     }
 
-    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, __attribute__ ((unused)) int) const
     {
         unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
     }
diff -ru boost.orig/boost/bind/mem_fn.hpp boost/boost/bind/mem_fn.hpp
--- foo/misc/boost.orig/boost/bind/mem_fn.hpp	2015-05-04 00:08:08.000000000 +0200
+++ foo/misc/boost/boost/bind/mem_fn.hpp	2015-07-16 21:54:24.695986146 +0200
@@ -328,7 +328,7 @@
         return (u.*f_);
     }
 
-    template<class U> R const & call(U & u, void const *) const
+    template<class U> R const & call(U & u, __attribute__ ((unused)) void const *) const
     {
         return (get_pointer(u)->*f_);
     }
diff -ru boost.orig/boost/bind/mem_fn_template.hpp boost/boost/bind/mem_fn_template.hpp
--- foo/misc/boost.orig/boost/bind/mem_fn_template.hpp	2015-05-04 00:08:08.000000000 +0200
+++ foo/misc/boost/boost/bind/mem_fn_template.hpp	2015-07-16 21:58:25.008983445 +0200
@@ -35,7 +35,7 @@
         BOOST_MEM_FN_RETURN (u.*f_)();
     }
 
-    template<class U> R call(U & u, void const *) const
+    template<class U> R call(U & u, __attribute__ ((unused)) void const *) const
     {
         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)();
     }
@@ -100,7 +100,7 @@
         BOOST_MEM_FN_RETURN (u.*f_)();
     }
 
-    template<class U> R call(U & u, void const *) const
+    template<class U> R call(U & u, __attribute__ ((unused)) void const *) const
     {
         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)();
     }
@@ -146,12 +146,12 @@
     BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1))
     F f_;
 
-    template<class U, class B1> R call(U & u, T const *, B1 & b1) const
+    template<class U, class B1> R call(U & u, __attribute__ ((unused)) T const *, B1 & b1) const
     {
         BOOST_MEM_FN_RETURN (u.*f_)(b1);
     }
 
-    template<class U, class B1> R call(U & u, void const *, B1 & b1) const
+    template<class U, class B1> R call(U & u, __attribute__ ((unused)) void const *, B1 & b1) const
     {
         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1);
     }
@@ -217,7 +217,7 @@
         BOOST_MEM_FN_RETURN (u.*f_)(b1);
     }
 
-    template<class U, class B1> R call(U & u, void const *, B1 & b1) const
+    template<class U, class B1> R call(U & u, __attribute__ ((unused)) void const *, B1 & b1) const
     {
         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1);
     }
@@ -266,7 +266,7 @@
         BOOST_MEM_FN_RETURN (u.*f_)(b1, b2);
     }
 
-    template<class U, class B1, class B2> R call(U & u, void const *, B1 & b1, B2 & b2) const
+    template<class U, class B1, class B2> R call(U & u, __attribute__ ((unused)) void const *, B1 & b1, B2 & b2) const
     {
         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2);
     }
@@ -379,7 +379,7 @@
         BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3);
     }
 
-    template<class U, class B1, class B2, class B3> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3) const
+    template<class U, class B1, class B2, class B3> R call(U & u, __attribute__ ((unused)) void const *, B1 & b1, B2 & b2, B3 & b3) const
     {
         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3);
     }
@@ -492,7 +492,7 @@
         BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4);
     }
 
-    template<class U, class B1, class B2, class B3, class B4> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
+    template<class U, class B1, class B2, class B3, class B4> R call(U & u, __attribute__ ((unused)) void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
     {
         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4);
     }
@@ -556,7 +556,7 @@
         BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4);
     }
 
-    template<class U, class B1, class B2, class B3, class B4> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
+    template<class U, class B1, class B2, class B3, class B4> R call(U & u, __attribute__ ((unused)) void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
     {
         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4);
     }
diff -ru boost.orig/boost/detail/dynamic_bitset.hpp boost/boost/detail/dynamic_bitset.hpp
--- foo/misc/boost.orig/boost/detail/dynamic_bitset.hpp	2015-06-04 07:43:44.000000000 +0200
+++ foo/misc/boost/boost/detail/dynamic_bitset.hpp	2015-07-16 21:59:20.786982818 +0200
@@ -104,8 +104,8 @@
 
      template <typename Iterator>
      inline std::size_t do_count(Iterator first, std::size_t length,
-                                 int /*dummy param*/,
-                                 value_to_type<access_by_bytes>* )
+                                 __attribute__ ((unused)) int /*dummy param*/,
+                                 __attribute__ ((unused)) value_to_type<access_by_bytes>* )
      {
          std::size_t num = 0;
          if (length)
diff -ru boost.orig/boost/foreach.hpp boost/boost/foreach.hpp
--- foo/misc/boost.orig/boost/foreach.hpp	2015-03-04 21:36:38.000000000 +0100
+++ foo/misc/boost/boost/foreach.hpp	2015-07-16 22:01:53.617981100 +0200
@@ -633,7 +633,7 @@
 }
 
 template<typename T>
-inline auto_any<T *> contain(T &t, boost::mpl::false_ *) // lvalue
+inline auto_any<T *> contain(T &t, __attribute__ ((unused)) boost::mpl::false_ *) // lvalue
 {
     // Cannot seem to get sunpro to handle addressof() with array types.
     #if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x570))
@@ -665,7 +665,7 @@
 
 template<typename T, typename C>
 inline auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type>
-begin(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *) // lvalue
+begin(auto_any_t col, __attribute__ ((unused)) type2type<T, C> *, __attribute__ ((unused)) boost::mpl::false_ *) // lvalue
 {
     typedef BOOST_DEDUCED_TYPENAME type2type<T, C>::type type;
     typedef BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type iterator;
@@ -754,7 +754,7 @@
 // next
 //
 template<typename T, typename C>
-inline void next(auto_any_t cur, type2type<T, C> *)
+inline void next(auto_any_t cur, __attribute__ ((unused)) type2type<T, C> *)
 {
     typedef BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type iter_t;
     ++auto_any_cast<iter_t, boost::mpl::false_>(cur);
@@ -765,7 +765,7 @@
 //
 template<typename T, typename C>
 inline BOOST_DEDUCED_TYPENAME foreach_reference<T, C>::type
-deref(auto_any_t cur, type2type<T, C> *)
+deref(auto_any_t cur, __attribute__ ((unused)) type2type<T, C> *)
 {
     typedef BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type iter_t;
     return *auto_any_cast<iter_t, boost::mpl::false_>(cur);
@@ -784,7 +784,7 @@
 
 template<typename T, typename C>
 inline auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type>
-rbegin(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *) // lvalue
+rbegin(auto_any_t col, __attribute__ ((unused)) type2type<T, C> *, __attribute__ ((unused))  boost::mpl::false_ *) // lvalue
 {
     typedef BOOST_DEDUCED_TYPENAME type2type<T, C>::type type;
     typedef BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type iterator;
diff -ru boost.orig/boost/function/function_template.hpp boost/boost/function/function_template.hpp
--- foo/misc/boost.orig/boost/function/function_template.hpp	2015-07-22 19:33:01.000000000 +0200
+++ foo/misc/boost/boost/function/function_template.hpp	2015-08-27 10:14:49.023960640 +0200
@@ -717,7 +717,7 @@
     template<typename Functor>
     BOOST_FUNCTION_FUNCTION(Functor BOOST_FUNCTION_TARGET_FIX(const &) f
 #ifndef BOOST_NO_SFINAE
-                            ,typename boost::enable_if_c<
+                            ,__attribute__ ((unused)) typename boost::enable_if_c<
                              !(is_integral<Functor>::value),
                                         int>::type = 0
 #endif // BOOST_NO_SFINAE
@@ -729,7 +729,7 @@
     template<typename Functor,typename Allocator>
     BOOST_FUNCTION_FUNCTION(Functor BOOST_FUNCTION_TARGET_FIX(const &) f, Allocator a
 #ifndef BOOST_NO_SFINAE
-                            ,typename boost::enable_if_c<
+                            ,__attribute__ ((unused)) typename boost::enable_if_c<
                               !(is_integral<Functor>::value),
                                         int>::type = 0
 #endif // BOOST_NO_SFINAE
@@ -1065,7 +1065,7 @@
   template<typename Functor>
   function(Functor f
 #ifndef BOOST_NO_SFINAE
-           ,typename boost::enable_if_c<
+           ,__attribute__ ((unused)) typename boost::enable_if_c<
                           !(is_integral<Functor>::value),
                        int>::type = 0
 #endif
@@ -1076,7 +1076,7 @@
   template<typename Functor,typename Allocator>
   function(Functor f, Allocator a
 #ifndef BOOST_NO_SFINAE
-           ,typename boost::enable_if_c<
+           ,__attribute__ ((unused)) typename boost::enable_if_c<
                            !(is_integral<Functor>::value),
                        int>::type = 0
 #endif
diff -ru boost.orig/boost/iterator/reverse_iterator.hpp boost/boost/iterator/reverse_iterator.hpp
--- foo/misc/boost.orig/boost/iterator/reverse_iterator.hpp	2014-09-06 19:18:28.000000000 +0200
+++ foo/misc/boost/boost/iterator/reverse_iterator.hpp	2015-07-16 22:04:18.012979478 +0200
@@ -34,7 +34,7 @@
       template<class OtherIterator>
       reverse_iterator(
           reverse_iterator<OtherIterator> const& r
-          , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0
+          , __attribute__ ((unused)) typename enable_if_convertible<OtherIterator, Iterator>::type* = 0
           )
           : super_t(r.base())
       {}
diff -ru boost.orig/boost/optional/optional.hpp boost/boost/optional/optional.hpp
--- foo/misc/boost.orig/boost/optional/optional.hpp	2015-07-09 00:01:02.000000000 +0200
+++ foo/misc/boost/boost/optional/optional.hpp	2015-07-16 22:06:21.657978088 +0200
@@ -634,7 +634,7 @@
     // Converting constructions of optional<T> from optional<U> uses this function with
     // 'Expr' being of type 'U' and relying on a converting constructor of T from U.
     template<class Expr>
-    void construct ( Expr const& expr, void const* )
+    void construct ( Expr const& expr, __attribute__ ((unused)) void const* )
      {
        new (m_storage.address()) internal_type(expr) ;
        m_initialized = true ;
@@ -645,7 +645,7 @@
     // Converting assignments of optional<T> from optional<U> uses this function with
     // 'Expr' being of type 'U' and relying on a converting assignment of T from U.
     template<class Expr>
-    void assign_expr_to_initialized ( Expr const& expr, void const* )
+    void assign_expr_to_initialized ( Expr const& expr, __attribute__ ((unused)) void const* )
      {
        assign_value(expr, is_reference_predicate());
      }
@@ -1424,17 +1424,17 @@
 
 template<class T>
 inline
-bool operator == ( none_t , optional<T> const& y ) BOOST_NOEXCEPT
+bool operator == ( __attribute__ ((unused)) none_t , optional<T> const& y ) BOOST_NOEXCEPT
 { return !y; }
 
 template<class T>
 inline
-bool operator < ( none_t , optional<T> const& y )
+bool operator < ( __attribute__ ((unused)) none_t , optional<T> const& y )
 { return less_pointees(optional<T>() ,y); }
 
 template<class T>
 inline
-bool operator != ( none_t, optional<T> const& y ) BOOST_NOEXCEPT
+bool operator != ( __attribute__ ((unused)) none_t, optional<T> const& y ) BOOST_NOEXCEPT
 { return bool(y); }
 
 template<class T>
diff -ru boost.orig/boost/ptr_container/detail/default_deleter.hpp boost/boost/ptr_container/detail/default_deleter.hpp
--- foo/misc/boost.orig/boost/ptr_container/detail/default_deleter.hpp	2015-01-25 20:27:11.000000000 +0100
+++ foo/misc/boost/boost/ptr_container/detail/default_deleter.hpp	2015-07-16 22:45:54.427951420 +0200
@@ -61,7 +61,7 @@
 { 
     default_deleter() { }
     template<typename TT>
-    default_deleter(default_deleter<TT> tt) { }
+    default_deleter(__attribute__ ((unused)) default_deleter<TT> tt) { }
 };
 
 } } } // End namespaces ptr_container_detail, move_ptrs, boost.
diff -ru boost.orig/boost/ptr_container/ptr_sequence_adapter.hpp boost/boost/ptr_container/ptr_sequence_adapter.hpp
--- foo/misc/boost.orig/boost/ptr_container/ptr_sequence_adapter.hpp	2015-07-16 08:47:41.786947347 +0200
+++ foo/misc/boost/boost/ptr_container/ptr_sequence_adapter.hpp	2015-07-16 22:46:28.137951041 +0200
@@ -664,7 +664,7 @@
             
         }
 
-        void range_check_impl( iterator first, iterator last, 
+        void range_check_impl( __attribute__ ((unused)) iterator first, __attribute__ ((unused)) iterator last, 
                                std::bidirectional_iterator_tag )
         { /* do nothing */ }
 
diff -ru boost.orig/boost/spirit/home/classic/actor/ref_const_ref_actor.hpp boost/boost/spirit/home/classic/actor/ref_const_ref_actor.hpp
--- foo/misc/boost.orig/boost/spirit/home/classic/actor/ref_const_ref_actor.hpp	2015-05-17 14:17:51.000000000 +0200
+++ foo/misc/boost/boost/spirit/home/classic/actor/ref_const_ref_actor.hpp	2015-07-16 22:07:32.910977287 +0200
@@ -63,8 +63,8 @@
 
         template<typename IteratorT>
             void operator()(
-            IteratorT const& /*first*/,
-            IteratorT const& /*last*/
+            __attribute__ ((unused)) IteratorT const& /*first*/,
+            __attribute__ ((unused)) IteratorT const& /*last*/
             ) const
         {
             this->act(ref,value_ref); // defined in ActionT
diff -ru boost.orig/boost/spirit/home/classic/core/composite/impl/directives.ipp boost/boost/spirit/home/classic/core/composite/impl/directives.ipp
--- foo/misc/boost.orig/boost/spirit/home/classic/core/composite/impl/directives.ipp	2015-05-17 14:17:51.000000000 +0200
+++ foo/misc/boost/boost/spirit/home/classic/core/composite/impl/directives.ipp	2015-07-16 22:12:36.614973874 +0200
@@ -41,7 +41,7 @@
         contiguous_parser_parse(
             ST const& s,
             ScannerT const& scan,
-            skipper_iteration_policy<BaseT> const&)
+            __attribute__ ((unused)) skipper_iteration_policy<BaseT> const&)
         {
             typedef scanner_policies<
                 no_skipper_iteration_policy<
@@ -61,7 +61,7 @@
         contiguous_parser_parse(
             ST const& s,
             ScannerT const& scan,
-            no_skipper_iteration_policy<BaseT> const&)
+            __attribute__ ((unused)) no_skipper_iteration_policy<BaseT> const&)
         {
             return s.parse(scan);
         }
@@ -85,7 +85,7 @@
         implicit_lexeme_parse(
             ParserT const& p,
             ScannerT const& scan,
-            skipper_iteration_policy<BaseT> const&)
+            __attribute__ ((unused)) skipper_iteration_policy<BaseT> const&)
         {
             typedef scanner_policies<
                 no_skipper_iteration_policy<
@@ -129,7 +129,7 @@
         inhibit_case_parser_parse(
             ST const& s,
             ScannerT const& scan,
-            iteration_policy const&)
+            __attribute__ ((unused)) iteration_policy const&)
         {
             typedef scanner_policies<
                 inhibit_case_iteration_policy<
diff -ru boost.orig/boost/spirit/home/classic/core/composite/no_actions.hpp boost/boost/spirit/home/classic/core/composite/no_actions.hpp
--- foo/misc/boost.orig/boost/spirit/home/classic/core/composite/no_actions.hpp	2015-05-17 14:17:51.000000000 +0200
+++ foo/misc/boost/boost/spirit/home/classic/core/composite/no_actions.hpp	2015-07-16 22:08:22.699976727 +0200
@@ -38,10 +38,10 @@
     template<typename ActorT, typename AttrT, typename IteratorT>
     void
     do_action(
-        ActorT const&       actor,
-        AttrT&              val,
-        IteratorT const&    first,
-        IteratorT const&    last) const
+        __attribute__ ((unused)) ActorT const&       actor,
+        __attribute__ ((unused)) AttrT&              val,
+        __attribute__ ((unused)) IteratorT const&    first,
+        __attribute__ ((unused)) IteratorT const&    last) const
     {}
 };
 
diff -ru boost.orig/boost/spirit/home/classic/core/non_terminal/impl/grammar.ipp boost/boost/spirit/home/classic/core/non_terminal/impl/grammar.ipp
--- foo/misc/boost.orig/boost/spirit/home/classic/core/non_terminal/impl/grammar.ipp	2015-05-17 14:17:51.000000000 +0200
+++ foo/misc/boost/boost/spirit/home/classic/core/non_terminal/impl/grammar.ipp	2015-07-16 22:13:57.708972962 +0200
@@ -69,7 +69,7 @@
         {   // Does _not_ copy the helpers member !
         }
 
-        grammar_helper_list& operator=(grammar_helper_list const& x)
+        grammar_helper_list& operator=(__attribute__ ((unused)) grammar_helper_list const& x)
         {   // Does _not_ copy the helpers member !
             return *this;
         }
diff -ru boost.orig/boost/spirit/home/classic/core/non_terminal/parser_context.hpp boost/boost/spirit/home/classic/core/non_terminal/parser_context.hpp
--- foo/misc/boost.orig/boost/spirit/home/classic/core/non_terminal/parser_context.hpp	2015-05-17 14:17:51.000000000 +0200
+++ foo/misc/boost/boost/spirit/home/classic/core/non_terminal/parser_context.hpp	2015-07-16 22:17:08.977970813 +0200
@@ -51,15 +51,15 @@
         typedef parser_context_linker<parser_context<AttrT> > context_linker_t;
 
         template <typename ParserT>
-        parser_context(ParserT const&) {}
+        parser_context(__attribute__ ((unused)) ParserT const&) {}
 
         template <typename ParserT, typename ScannerT>
         void
-        pre_parse(ParserT const&, ScannerT const&) {}
+        pre_parse(__attribute__ ((unused)) ParserT const&, __attribute__ ((unused)) ScannerT const&) {}
 
         template <typename ResultT, typename ParserT, typename ScannerT>
         ResultT&
-        post_parse(ResultT& hit, ParserT const&, ScannerT const&)
+        post_parse(__attribute__ ((unused)) ResultT& hit, __attribute__ ((unused)) ParserT const&, __attribute__ ((unused)) ScannerT const&)
         { return hit; }
     };
 
diff -ru boost.orig/boost/spirit/home/classic/core/primitives/impl/numerics.ipp boost/boost/spirit/home/classic/core/primitives/impl/numerics.ipp
--- foo/misc/boost.orig/boost/spirit/home/classic/core/primitives/impl/numerics.ipp	2015-05-17 14:17:51.000000000 +0200
+++ foo/misc/boost/boost/spirit/home/classic/core/primitives/impl/numerics.ipp	2015-07-16 22:17:53.303970314 +0200
@@ -226,7 +226,7 @@
         }
 
         template <>
-        inline bool allow_more_digits<-1>(std::size_t)
+        inline bool allow_more_digits<-1>(__attribute__ ((unused)) std::size_t)
         {
             return true;
         }
diff -ru boost.orig/boost/spirit/home/classic/core/primitives/primitives.hpp boost/boost/spirit/home/classic/core/primitives/primitives.hpp
--- foo/misc/boost.orig/boost/spirit/home/classic/core/primitives/primitives.hpp	2015-05-17 14:17:51.000000000 +0200
+++ foo/misc/boost/boost/spirit/home/classic/core/primitives/primitives.hpp	2015-07-16 22:18:27.942969925 +0200
@@ -316,7 +316,7 @@
         anychar_parser() {}
 
         template <typename CharT>
-        bool test(CharT) const
+        bool test(__attribute__ ((unused)) CharT) const
         {
             return true;
         }
diff -ru boost.orig/boost/spirit/home/classic/core/scanner/impl/skipper.ipp boost/boost/spirit/home/classic/core/scanner/impl/skipper.ipp
--- foo/misc/boost.orig/boost/spirit/home/classic/core/scanner/impl/skipper.ipp	2015-05-17 14:17:51.000000000 +0200
+++ foo/misc/boost/boost/spirit/home/classic/core/scanner/impl/skipper.ipp	2015-07-16 22:19:06.409969493 +0200
@@ -122,7 +122,7 @@
                 IteratorT const&    first_,
                 IteratorT const&    last,
                 ParserT const&      p,
-                space_parser const&)
+                __attribute__ ((unused)) space_parser const&)
             {
                 typedef skipper_iteration_policy<> iter_policy_t;
                 typedef scanner_policies<iter_policy_t> scanner_policies_t;
diff -ru boost.orig/boost/spirit/home/classic/core/scanner/scanner.hpp boost/boost/spirit/home/classic/core/scanner/scanner.hpp
--- foo/misc/boost.orig/boost/spirit/home/classic/core/scanner/scanner.hpp	2015-05-17 14:17:51.000000000 +0200
+++ foo/misc/boost/boost/spirit/home/classic/core/scanner/scanner.hpp	2015-07-16 22:20:18.232968685 +0200
@@ -82,18 +82,18 @@
         create_match(
             std::size_t         length,
             AttrT const&        val,
-            IteratorT const&    /*first*/,
-            IteratorT const&    /*last*/) const
+            __attribute__ ((unused)) IteratorT const&    /*first*/,
+            __attribute__ ((unused)) IteratorT const&    /*last*/) const
         {
             return match<AttrT>(length, val);
         }
 
         template <typename MatchT, typename IteratorT>
         void group_match(
-            MatchT&             /*m*/,
-            parser_id const&    /*id*/,
-            IteratorT const&    /*first*/,
-            IteratorT const&    /*last*/) const {}
+            __attribute__ ((unused)) MatchT&             /*m*/,
+            __attribute__ ((unused)) parser_id const&    /*id*/,
+            __attribute__ ((unused)) IteratorT const&    /*first*/,
+            __attribute__ ((unused)) IteratorT const&    /*last*/) const {}
 
         template <typename Match1T, typename Match2T>
         void concat_match(Match1T& l, Match2T const& r) const
@@ -126,8 +126,8 @@
         call(
             ActorT const& actor,
             AttrT& val,
-            IteratorT const&,
-            IteratorT const&)
+            __attribute__ ((unused)) IteratorT const&,
+            __attribute__ ((unused)) IteratorT const&)
         {
             actor(val);
         }
diff -ru boost.orig/boost/spirit/home/classic/core/scanner/skipper.hpp boost/boost/spirit/home/classic/core/scanner/skipper.hpp
--- foo/misc/boost.orig/boost/spirit/home/classic/core/scanner/skipper.hpp	2015-05-17 14:17:51.000000000 +0200
+++ foo/misc/boost/boost/spirit/home/classic/core/scanner/skipper.hpp	2015-07-16 22:20:47.695968354 +0200
@@ -82,7 +82,7 @@
 
         template <typename ScannerT>
         void
-        skip(ScannerT const& /*scan*/) const {}
+        skip(__attribute__ ((unused)) ScannerT const& /*scan*/) const {}
     };
 
     ///////////////////////////////////////////////////////////////////////////
diff -ru boost.orig/boost/spirit/home/classic/meta/impl/refactoring.ipp boost/boost/spirit/home/classic/meta/impl/refactoring.ipp
--- foo/misc/boost.orig/boost/spirit/home/classic/meta/impl/refactoring.ipp	2015-05-17 14:17:51.000000000 +0200
+++ foo/misc/boost/boost/spirit/home/classic/meta/impl/refactoring.ipp	2015-07-16 22:23:33.840966487 +0200
@@ -92,7 +92,7 @@
 
         template <typename ParserT, typename ScannerT, typename BinaryT>
         static typename parser_result<ParserT, ScannerT>::type
-        parse(ParserT const &, ScannerT const& scan, BinaryT const& binary)
+        parse(__attribute__ ((unused)) ParserT const &, ScannerT const& scan, BinaryT const& binary)
         {
             return binary.parse(scan);
         }
@@ -140,7 +140,7 @@
         template <typename ParserT, typename ScannerT, typename BinaryT>
         static typename parser_result<ParserT, ScannerT>::type
         parse(ParserT const &p, ScannerT const& scan, BinaryT const& binary,
-            non_nested_refactoring const&)
+            __attribute__ ((unused)) non_nested_refactoring const&)
         {
             typedef
                 typename BinaryT::left_t::parser_category_t
@@ -205,7 +205,7 @@
             typename NestedT
         >
         static typename parser_result<ParserT, ScannerT>::type
-        parse(ParserT const &, ScannerT const& scan, BinaryT const& binary,
+        parse(__attribute__ ((unused)) ParserT const &, ScannerT const& scan, BinaryT const& binary,
             NestedT const& nested_d)
         {
             typedef typename BinaryT::parser_generator_t binary_gen_t;
@@ -324,7 +324,7 @@
         >
         static typename parser_result<ParserT, ScannerT>::type
         parse(ParserT const &, ScannerT const& scan, ActionT const &action,
-            NestedT const& nested_d)
+            __attribute__ ((unused)) NestedT const& nested_d)
         {
             return action.parse(scan);
         }
diff -ru boost.orig/boost/spirit/home/classic/phoenix/tuples.hpp boost/boost/spirit/home/classic/phoenix/tuples.hpp
--- foo/misc/boost.orig/boost/spirit/home/classic/phoenix/tuples.hpp	2015-05-17 14:17:51.000000000 +0200
+++ foo/misc/boost/boost/spirit/home/classic/phoenix/tuples.hpp	2015-07-16 22:35:37.780958351 +0200
@@ -207,7 +207,7 @@
     typedef nil_t& rtype;
     typedef nil_t const& crtype;
 
-    static nil_t    get(TupleT const& t)    { return nil_t(); }
+    static nil_t    get(__attribute__ ((unused)) TupleT const& t)    { return nil_t(); }
 };
 
 //////////////////////////////////
diff -ru boost.orig/boost/spirit/home/classic/utility/impl/chset.ipp boost/boost/spirit/home/classic/utility/impl/chset.ipp
--- foo/misc/boost.orig/boost/spirit/home/classic/utility/impl/chset.ipp	2015-05-17 14:17:51.000000000 +0200
+++ foo/misc/boost/boost/spirit/home/classic/utility/impl/chset.ipp	2015-07-16 22:29:45.156962314 +0200
@@ -97,7 +97,7 @@
 }
 
 template <typename CharT>
-inline chset<CharT>::chset(nothing_parser /*arg_*/)
+inline chset<CharT>::chset(__attribute__ ((unused)) nothing_parser /*arg_*/)
 : ptr(new basic_chset<CharT>()) {}
 
 template <typename CharT>
@@ -146,7 +146,7 @@
 
 template <typename CharT>
 inline chset<CharT>&
-chset<CharT>::operator=(anychar_parser /*rhs*/)
+chset<CharT>::operator=(__attribute__ ((unused)) anychar_parser /*rhs*/)
 {
     utility::impl::detach_clear(ptr);
     ptr->set(
@@ -158,7 +158,7 @@
 
 template <typename CharT>
 inline chset<CharT>&
-chset<CharT>::operator=(nothing_parser /*rhs*/)
+chset<CharT>::operator=(__attribute__ ((unused)) nothing_parser /*rhs*/)
 {
     utility::impl::detach_clear(ptr);
     return *this;
diff -ru boost.orig/boost/spirit/home/classic/utility/impl/chset_operators.ipp boost/boost/spirit/home/classic/utility/impl/chset_operators.ipp
--- foo/misc/boost.orig/boost/spirit/home/classic/utility/impl/chset_operators.ipp	2015-05-17 14:17:51.000000000 +0200
+++ foo/misc/boost/boost/spirit/home/classic/utility/impl/chset_operators.ipp	2015-07-16 22:31:03.363961435 +0200
@@ -502,7 +502,7 @@
 //////////////////////////////////
 template <typename CharT>
 inline chset<CharT>
-operator-(anychar_parser, chset<CharT> const& b)
+operator-(__attribute__ ((unused)) anychar_parser, chset<CharT> const& b)
 {
     return ~b;
 }
diff -ru boost.orig/boost/spirit/home/classic/utility/impl/lists.ipp boost/boost/spirit/home/classic/utility/impl/lists.ipp
--- foo/misc/boost.orig/boost/spirit/home/classic/utility/impl/lists.ipp	2015-05-17 14:17:51.000000000 +0200
+++ foo/misc/boost/boost/spirit/home/classic/utility/impl/lists.ipp	2015-07-16 22:34:55.728958823 +0200
@@ -64,8 +64,8 @@
             typename ItemT, typename DelimT
         >
         static typename parser_result<ParserT, ScannerT>::type
-        parse(ScannerT const& scan, ParserT const& /*p*/,
-            ItemT const &item, DelimT const &delim, no_list_endtoken const&)
+        parse(ScannerT const& scan, __attribute__ ((unused)) ParserT const& /*p*/,
+            ItemT const &item, DelimT const &delim, __attribute__ ((unused)) no_list_endtoken const&)
         {
             typedef refactor_action_gen<refactor_unary_gen<> > refactor_t;
             const refactor_t refactor_item_d = refactor_t(refactor_unary_d);
@@ -112,8 +112,8 @@
             typename ItemT, typename DelimT
         >
         static typename parser_result<ParserT, ScannerT>::type
-        parse(ScannerT const& scan, ParserT const& /*p*/,
-            ItemT const &item, DelimT const &delim, no_list_endtoken const&)
+        parse(ScannerT const& scan, __attribute__ ((unused)) ParserT const& /*p*/,
+            ItemT const &item, DelimT const &delim, __attribute__ ((unused)) no_list_endtoken const&)
         {
             return (
                     (item - delim)
diff -ru boost.orig/boost/throw_exception.hpp boost/boost/throw_exception.hpp
--- foo/misc/boost.orig/boost/throw_exception.hpp	2014-06-08 22:17:48.000000000 +0200
+++ foo/misc/boost/boost/throw_exception.hpp	2015-07-16 22:36:06.940958023 +0200
@@ -57,7 +57,7 @@
 
 #else
 
-inline void throw_exception_assert_compatibility( std::exception const & ) { }
+inline void throw_exception_assert_compatibility( __attribute__ ((unused)) std::exception const & ) { }
 
 template<class E> BOOST_NORETURN inline void throw_exception( E const & e )
 {
diff -ru boost.orig/boost/type_index/stl_type_index.hpp boost/boost/type_index/stl_type_index.hpp
--- foo/misc/boost.orig/boost/type_index/stl_type_index.hpp	2015-06-21 22:16:46.000000000 +0200
+++ foo/misc/boost/boost/type_index/stl_type_index.hpp	2015-07-16 22:55:42.886944806 +0200
@@ -174,7 +174,7 @@
 
 
 inline std::size_t stl_type_index::hash_code() const BOOST_NOEXCEPT {
-#if _MSC_VER > 1600 || (__GNUC__ == 4 && __GNUC_MINOR__ > 5 && defined(__GXX_EXPERIMENTAL_CXX0X__))
+#if (defined(_MSC_VER) && _MSC_VER > 1600) || (__GNUC__ == 4 && __GNUC_MINOR__ > 5 && defined(__GXX_EXPERIMENTAL_CXX0X__))
     return data_->hash_code();
 #else
     return boost::hash_range(raw_name(), raw_name() + std::strlen(raw_name()));
diff -ru boost.orig/boost/variant/detail/visitation_impl.hpp boost/boost/variant/detail/visitation_impl.hpp
--- foo/misc/boost.orig/boost/variant/detail/visitation_impl.hpp	2015-06-25 23:53:21.000000000 +0200
+++ foo/misc/boost/boost/variant/detail/visitation_impl.hpp	2015-07-16 22:40:41.528954937 +0200
@@ -105,7 +105,7 @@
 inline
     BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type)
 visitation_impl_invoke_impl(
-      int, Visitor& visitor, VoidPtrCV storage, T*
+      int, Visitor& visitor, VoidPtrCV storage, __attribute__ ((unused)) T*
     , mpl::true_// never_uses_backup
     )
 {
@@ -181,9 +181,9 @@
 inline
     BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type)
 visitation_impl(
-      int, int, Visitor&, VPCV
+      __attribute__ ((unused)) int, __attribute__ ((unused)) int, __attribute__ ((unused)) Visitor&, VPCV
     , mpl::true_ // is_apply_visitor_unrolled
-    , NBF, W* = 0, S* = 0
+    , NBF, __attribute__ ((unused)) W* = 0, __attribute__ ((unused)) S* = 0
     )
 {
     // should never be here at runtime!
@@ -203,7 +203,7 @@
     , Visitor& visitor, VoidPtrCV storage
     , mpl::false_ // is_apply_visitor_unrolled
     , NoBackupFlag no_backup_flag
-    , Which* = 0, step0* = 0
+    , __attribute__ ((unused)) Which* = 0, __attribute__ ((unused)) step0* = 0
     )
 {
     // Typedef apply_visitor_unrolled steps and associated types...
diff -ru boost.orig/boost/variant/get.hpp boost/boost/variant/get.hpp
--- foo/misc/boost.orig/boost/variant/get.hpp	2015-06-25 23:53:21.000000000 +0200
+++ foo/misc/boost/boost/variant/get.hpp	2015-07-16 22:41:42.159954255 +0200
@@ -80,7 +80,7 @@
     }
 
     template <typename U>
-    pointer operator()(const U&) const BOOST_NOEXCEPT
+    pointer operator()(__attribute__ ((unused)) const U&) const BOOST_NOEXCEPT
     {
         return static_cast<pointer>(0);
     }
diff -ru boost.orig/boost/variant/variant.hpp boost/boost/variant/variant.hpp
--- foo/misc/boost.orig/boost/variant/variant.hpp	2015-06-25 23:53:21.000000000 +0200
+++ foo/misc/boost/boost/variant/variant.hpp	2015-07-16 22:44:37.631952283 +0200
@@ -312,7 +312,7 @@
 
     template <typename T>
         BOOST_VARIANT_AUX_RETURN_VOID_TYPE
-    internal_visit(T& operand, int) const BOOST_NOEXCEPT
+    internal_visit(T& operand, __attribute__ ((unused)) int) const BOOST_NOEXCEPT
     {
         operand.~T(); // must be noexcept
 
@@ -392,7 +392,7 @@
 
     template <typename T>
         BOOST_VARIANT_AUX_RETURN_VOID_TYPE
-    internal_visit(const T& operand, int) const
+    internal_visit(const T& operand, __attribute__ ((unused)) int) const
     {
         new(storage_) T(operand);
         BOOST_VARIANT_AUX_RETURN_VOID;
@@ -539,7 +539,7 @@
 
     template <typename T>
         BOOST_VARIANT_AUX_RETURN_VOID_TYPE
-    internal_visit(T& lhs_content, int) const
+    internal_visit(T& lhs_content, __attribute__ ((unused)) int) const
     {
         // NOTE TO USER :
         // Compile error here indicates one of variant's bounded types does
@@ -585,7 +585,7 @@
     }
 
     template <typename U>
-    bool operator()(U&) BOOST_NOEXCEPT
+    bool operator()(__attribute__ ((unused)) U&) BOOST_NOEXCEPT
     {
         return false;
     }