diff -rupN boost-1_53_0/algorithm/string/yes_no_type.hpp boost/algorithm/string/yes_no_type.hpp --- boost-1_53_0/algorithm/string/yes_no_type.hpp 2013-03-27 20:24:04.972762038 -0400 +++ boost/algorithm/string/yes_no_type.hpp 2013-03-27 20:12:50.971510958 -0400 @@ -18,9 +18,9 @@ namespace boost { // when yes_no_type will become officially // a part of boost distribution, this header // will be deprecated - template struct size_descriptor + template struct size_descriptor { - typedef char (& type)[I]; + typedef char (& type)[__I]; }; typedef size_descriptor<1>::type yes_type; diff -rupN boost-1_53_0/bind/arg.hpp boost/bind/arg.hpp --- boost-1_53_0/bind/arg.hpp 2013-03-27 20:23:54.469824943 -0400 +++ boost/bind/arg.hpp 2013-03-27 20:00:22.470888709 -0400 @@ -25,7 +25,7 @@ namespace boost { -template< int I > struct arg +template< int __I > struct arg { arg() { @@ -34,25 +34,25 @@ template< int I > struct arg template< class T > arg( T const & /* t */ ) { // static assert I == is_placeholder::value - typedef char T_must_be_placeholder[ I == is_placeholder::value? 1: -1 ]; + typedef char T_must_be_placeholder[ __I == is_placeholder::value? 1: -1 ]; } }; -template< int I > bool operator==( arg const &, arg const & ) +template< int __I > bool operator==( arg<__I> const &, arg<__I> const & ) { return true; } #if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) -template< int I > struct is_placeholder< arg > +template< int __I > struct is_placeholder< arg<__I> > { - enum _vt { value = I }; + enum _vt { value = __I }; }; -template< int I > struct is_placeholder< arg (*) () > +template< int __I > struct is_placeholder< arg<__I> (*) () > { - enum _vt { value = I }; + enum _vt { value = __I }; }; #endif diff -rupN boost-1_53_0/bind/bind.hpp boost/bind/bind.hpp --- boost-1_53_0/bind/bind.hpp 2013-03-27 20:23:54.469824943 -0400 +++ boost/bind/bind.hpp 2013-03-27 19:58:23.469644751 -0400 @@ -83,12 +83,12 @@ template bool ref_compare( T co return a == b; } -template bool ref_compare( arg const &, arg const &, int ) +template bool ref_compare( arg<__I> const &, arg<__I> const &, int ) { return true; } -template bool ref_compare( arg (*) (), arg (*) (), int ) +template bool ref_compare( arg<__I> (*) (), arg<__I> (*) (), int ) { return true; } @@ -991,9 +991,9 @@ template struct add_value #else -template< class T, int I > struct add_value_2 +template< class T, int __I > struct add_value_2 { - typedef boost::arg type; + typedef boost::arg<__I> type; }; template< class T > struct add_value_2< T, 0 > @@ -1018,14 +1018,14 @@ template struct add_value< refe typedef reference_wrapper type; }; -template struct add_value< arg > +template struct add_value< arg<__I> > { - typedef boost::arg type; + typedef boost::arg<__I> type; }; -template struct add_value< arg (*) () > +template struct add_value< arg<__I> (*) () > { - typedef boost::arg (*type) (); + typedef boost::arg<__I> (*type) (); }; template struct add_value< bind_t > @@ -1035,7 +1035,7 @@ template stru #else -template struct _avt_0; +template struct _avt_0; template<> struct _avt_0<1> { @@ -1058,8 +1058,8 @@ typedef char (&_avt_r2) [2]; template _avt_r1 _avt_f(value); template _avt_r1 _avt_f(reference_wrapper); -template _avt_r1 _avt_f(arg); -template _avt_r1 _avt_f(arg (*) ()); +template _avt_r1 _avt_f(arg<__I>); +template _avt_r1 _avt_f(arg<__I> (*) ()); template _avt_r1 _avt_f(bind_t); _avt_r2 _avt_f(...); @@ -1656,7 +1656,7 @@ _bi::bind_t< R, _mfi::dm, typename namespace _bi { -template< class Pm, int I > struct add_cref; +template< class Pm, int __I > struct add_cref; template< class M, class T > struct add_cref< M T::*, 0 > { diff -rupN boost-1_53_0/bind/storage.hpp boost/bind/storage.hpp --- boost-1_53_0/bind/storage.hpp 2013-03-27 20:23:54.469824943 -0400 +++ boost/bind/storage.hpp 2013-03-27 20:03:39.969642619 -0400 @@ -51,22 +51,22 @@ template struct storage1 #if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) && !defined( __BORLANDC__ ) -template struct storage1< boost::arg > +template struct storage1< boost::arg<__I> > { - explicit storage1( boost::arg ) {} + explicit storage1( boost::arg<__I> ) {} template void accept(V &) const { } - static boost::arg a1_() { return boost::arg(); } + static boost::arg<__I> a1_() { return boost::arg<__I>(); } }; -template struct storage1< boost::arg (*) () > +template struct storage1< boost::arg<__I> (*) () > { - explicit storage1( boost::arg (*) () ) {} + explicit storage1( boost::arg<__I> (*) () ) {} template void accept(V &) const { } - static boost::arg a1_() { return boost::arg(); } + static boost::arg<__I> a1_() { return boost::arg<__I>(); } }; #endif @@ -90,32 +90,32 @@ template struct stor #if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) -template struct storage2< A1, boost::arg >: public storage1 +template struct storage2< A1, boost::arg<__I> >: public storage1 { typedef storage1 inherited; - storage2( A1 a1, boost::arg ): storage1( a1 ) {} + storage2( A1 a1, boost::arg<__I> ): storage1( a1 ) {} template void accept(V & v) const { inherited::accept(v); } - static boost::arg a2_() { return boost::arg(); } + static boost::arg<__I> a2_() { return boost::arg<__I>(); } }; -template struct storage2< A1, boost::arg (*) () >: public storage1 +template struct storage2< A1, boost::arg<__I> (*) () >: public storage1 { typedef storage1 inherited; - storage2( A1 a1, boost::arg (*) () ): storage1( a1 ) {} + storage2( A1 a1, boost::arg<__I> (*) () ): storage1( a1 ) {} template void accept(V & v) const { inherited::accept(v); } - static boost::arg a2_() { return boost::arg(); } + static boost::arg<__I> a2_() { return boost::arg<__I>(); } }; #endif @@ -139,32 +139,32 @@ template s #if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) -template struct storage3< A1, A2, boost::arg >: public storage2< A1, A2 > +template struct storage3< A1, A2, boost::arg<__I> >: public storage2< A1, A2 > { typedef storage2 inherited; - storage3( A1 a1, A2 a2, boost::arg ): storage2( a1, a2 ) {} + storage3( A1 a1, A2 a2, boost::arg<__I> ): storage2( a1, a2 ) {} template void accept(V & v) const { inherited::accept(v); } - static boost::arg a3_() { return boost::arg(); } + static boost::arg<__I> a3_() { return boost::arg<__I>(); } }; -template struct storage3< A1, A2, boost::arg (*) () >: public storage2< A1, A2 > +template struct storage3< A1, A2, boost::arg<__I> (*) () >: public storage2< A1, A2 > { typedef storage2 inherited; - storage3( A1 a1, A2 a2, boost::arg (*) () ): storage2( a1, a2 ) {} + storage3( A1 a1, A2 a2, boost::arg<__I> (*) () ): storage2( a1, a2 ) {} template void accept(V & v) const { inherited::accept(v); } - static boost::arg a3_() { return boost::arg(); } + static boost::arg<__I> a3_() { return boost::arg<__I>(); } }; #endif @@ -188,32 +188,32 @@ template struct storage4< A1, A2, A3, boost::arg >: public storage3< A1, A2, A3 > +template struct storage4< A1, A2, A3, boost::arg<__I> >: public storage3< A1, A2, A3 > { typedef storage3 inherited; - storage4( A1 a1, A2 a2, A3 a3, boost::arg ): storage3( a1, a2, a3 ) {} + storage4( A1 a1, A2 a2, A3 a3, boost::arg<__I> ): storage3( a1, a2, a3 ) {} template void accept(V & v) const { inherited::accept(v); } - static boost::arg a4_() { return boost::arg(); } + static boost::arg<__I> a4_() { return boost::arg<__I>(); } }; -template struct storage4< A1, A2, A3, boost::arg (*) () >: public storage3< A1, A2, A3 > +template struct storage4< A1, A2, A3, boost::arg<__I> (*) () >: public storage3< A1, A2, A3 > { typedef storage3 inherited; - storage4( A1 a1, A2 a2, A3 a3, boost::arg (*) () ): storage3( a1, a2, a3 ) {} + storage4( A1 a1, A2 a2, A3 a3, boost::arg<__I> (*) () ): storage3( a1, a2, a3 ) {} template void accept(V & v) const { inherited::accept(v); } - static boost::arg a4_() { return boost::arg(); } + static boost::arg<__I> a4_() { return boost::arg<__I>(); } }; #endif @@ -237,32 +237,32 @@ template struct storage5< A1, A2, A3, A4, boost::arg >: public storage4< A1, A2, A3, A4 > +template struct storage5< A1, A2, A3, A4, boost::arg<__I> >: public storage4< A1, A2, A3, A4 > { typedef storage4 inherited; - storage5( A1 a1, A2 a2, A3 a3, A4 a4, boost::arg ): storage4( a1, a2, a3, a4 ) {} + storage5( A1 a1, A2 a2, A3 a3, A4 a4, boost::arg<__I> ): storage4( a1, a2, a3, a4 ) {} template void accept(V & v) const { inherited::accept(v); } - static boost::arg a5_() { return boost::arg(); } + static boost::arg<__I> a5_() { return boost::arg<__I>(); } }; -template struct storage5< A1, A2, A3, A4, boost::arg (*) () >: public storage4< A1, A2, A3, A4 > +template struct storage5< A1, A2, A3, A4, boost::arg<__I> (*) () >: public storage4< A1, A2, A3, A4 > { typedef storage4 inherited; - storage5( A1 a1, A2 a2, A3 a3, A4 a4, boost::arg (*) () ): storage4( a1, a2, a3, a4 ) {} + storage5( A1 a1, A2 a2, A3 a3, A4 a4, boost::arg<__I> (*) () ): storage4( a1, a2, a3, a4 ) {} template void accept(V & v) const { inherited::accept(v); } - static boost::arg a5_() { return boost::arg(); } + static boost::arg<__I> a5_() { return boost::arg<__I>(); } }; #endif @@ -286,32 +286,32 @@ template struct storage6< A1, A2, A3, A4, A5, boost::arg >: public storage5< A1, A2, A3, A4, A5 > +template struct storage6< A1, A2, A3, A4, A5, boost::arg<__I> >: public storage5< A1, A2, A3, A4, A5 > { typedef storage5 inherited; - storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, boost::arg ): storage5( a1, a2, a3, a4, a5 ) {} + storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, boost::arg<__I> ): storage5( a1, a2, a3, a4, a5 ) {} template void accept(V & v) const { inherited::accept(v); } - static boost::arg a6_() { return boost::arg(); } + static boost::arg<__I> a6_() { return boost::arg<__I>(); } }; -template struct storage6< A1, A2, A3, A4, A5, boost::arg (*) () >: public storage5< A1, A2, A3, A4, A5 > +template struct storage6< A1, A2, A3, A4, A5, boost::arg<__I> (*) () >: public storage5< A1, A2, A3, A4, A5 > { typedef storage5 inherited; - storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, boost::arg (*) () ): storage5( a1, a2, a3, a4, a5 ) {} + storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, boost::arg<__I> (*) () ): storage5( a1, a2, a3, a4, a5 ) {} template void accept(V & v) const { inherited::accept(v); } - static boost::arg a6_() { return boost::arg(); } + static boost::arg<__I> a6_() { return boost::arg<__I>(); } }; #endif @@ -335,32 +335,32 @@ template struct storage7< A1, A2, A3, A4, A5, A6, boost::arg >: public storage6< A1, A2, A3, A4, A5, A6 > +template struct storage7< A1, A2, A3, A4, A5, A6, boost::arg<__I> >: public storage6< A1, A2, A3, A4, A5, A6 > { typedef storage6 inherited; - storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, boost::arg ): storage6( a1, a2, a3, a4, a5, a6 ) {} + storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, boost::arg<__I> ): storage6( a1, a2, a3, a4, a5, a6 ) {} template void accept(V & v) const { inherited::accept(v); } - static boost::arg a7_() { return boost::arg(); } + static boost::arg<__I> a7_() { return boost::arg<__I>(); } }; -template struct storage7< A1, A2, A3, A4, A5, A6, boost::arg (*) () >: public storage6< A1, A2, A3, A4, A5, A6 > +template struct storage7< A1, A2, A3, A4, A5, A6, boost::arg<__I> (*) () >: public storage6< A1, A2, A3, A4, A5, A6 > { typedef storage6 inherited; - storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, boost::arg (*) () ): storage6( a1, a2, a3, a4, a5, a6 ) {} + storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, boost::arg<__I> (*) () ): storage6( a1, a2, a3, a4, a5, a6 ) {} template void accept(V & v) const { inherited::accept(v); } - static boost::arg a7_() { return boost::arg(); } + static boost::arg<__I> a7_() { return boost::arg<__I>(); } }; #endif @@ -384,32 +384,32 @@ template struct storage8< A1, A2, A3, A4, A5, A6, A7, boost::arg >: public storage7< A1, A2, A3, A4, A5, A6, A7 > +template struct storage8< A1, A2, A3, A4, A5, A6, A7, boost::arg<__I> >: public storage7< A1, A2, A3, A4, A5, A6, A7 > { typedef storage7 inherited; - storage8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, boost::arg ): storage7( a1, a2, a3, a4, a5, a6, a7 ) {} + storage8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, boost::arg<__I> ): storage7( a1, a2, a3, a4, a5, a6, a7 ) {} template void accept(V & v) const { inherited::accept(v); } - static boost::arg a8_() { return boost::arg(); } + static boost::arg<__I> a8_() { return boost::arg<__I>(); } }; -template struct storage8< A1, A2, A3, A4, A5, A6, A7, boost::arg (*) () >: public storage7< A1, A2, A3, A4, A5, A6, A7 > +template struct storage8< A1, A2, A3, A4, A5, A6, A7, boost::arg<__I> (*) () >: public storage7< A1, A2, A3, A4, A5, A6, A7 > { typedef storage7 inherited; - storage8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, boost::arg (*) () ): storage7( a1, a2, a3, a4, a5, a6, a7 ) {} + storage8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, boost::arg<__I> (*) () ): storage7( a1, a2, a3, a4, a5, a6, a7 ) {} template void accept(V & v) const { inherited::accept(v); } - static boost::arg a8_() { return boost::arg(); } + static boost::arg<__I> a8_() { return boost::arg<__I>(); } }; #endif @@ -433,32 +433,32 @@ template struct storage9< A1, A2, A3, A4, A5, A6, A7, A8, boost::arg >: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 > +template struct storage9< A1, A2, A3, A4, A5, A6, A7, A8, boost::arg<__I> >: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 > { typedef storage8 inherited; - storage9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, boost::arg ): storage8( a1, a2, a3, a4, a5, a6, a7, a8 ) {} + storage9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, boost::arg<__I> ): storage8( a1, a2, a3, a4, a5, a6, a7, a8 ) {} template void accept(V & v) const { inherited::accept(v); } - static boost::arg a9_() { return boost::arg(); } + static boost::arg<__I> a9_() { return boost::arg<__I>(); } }; -template struct storage9< A1, A2, A3, A4, A5, A6, A7, A8, boost::arg (*) () >: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 > +template struct storage9< A1, A2, A3, A4, A5, A6, A7, A8, boost::arg<__I> (*) () >: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 > { typedef storage8 inherited; - storage9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, boost::arg (*) () ): storage8( a1, a2, a3, a4, a5, a6, a7, a8 ) {} + storage9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, boost::arg<__I> (*) () ): storage8( a1, a2, a3, a4, a5, a6, a7, a8 ) {} template void accept(V & v) const { inherited::accept(v); } - static boost::arg a9_() { return boost::arg(); } + static boost::arg<__I> a9_() { return boost::arg<__I>(); } }; #endif diff -rupN boost-1_53_0/iterator/iterator_facade.hpp boost/iterator/iterator_facade.hpp --- boost-1_53_0/iterator/iterator_facade.hpp 2013-03-27 20:24:19.972901122 -0400 +++ boost/iterator/iterator_facade.hpp 2013-03-27 20:11:42.970262124 -0400 @@ -40,7 +40,7 @@ namespace boost { // This forward declaration is required for the friend declaration // in iterator_core_access - template class iterator_facade; + template class iterator_facade; namespace detail { @@ -474,7 +474,7 @@ namespace boost public: # else - template friend class iterator_facade; + template friend class iterator_facade; # define BOOST_ITERATOR_FACADE_RELATION(op) \ BOOST_ITERATOR_FACADE_INTEROP_HEAD(friend,op, boost::detail::always_bool2); @@ -561,16 +561,16 @@ namespace boost // // Curiously Recurring Template interface. // - template - static I& derived(iterator_facade& facade) + template + static __I& derived(iterator_facade<__I,V,TC,R,D>& facade) { - return *static_cast(&facade); + return *static_cast<__I*>(&facade); } - template - static I const& derived(iterator_facade const& facade) + template + static __I const& derived(iterator_facade<__I,V,TC,R,D> const& facade) { - return *static_cast(&facade); + return *static_cast<__I const*>(&facade); } private: @@ -717,15 +717,15 @@ namespace boost }; # if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) - template - inline typename boost::detail::postfix_increment_result::type + template + inline typename boost::detail::postfix_increment_result<__I,V,R,TC>::type operator++( - iterator_facade& i + iterator_facade<__I,V,TC,R,D>& i , int ) { - typename boost::detail::postfix_increment_result::type - tmp(*static_cast(&i)); + typename boost::detail::postfix_increment_result<__I,V,R,TC>::type + tmp(*static_cast<__I*>(&i)); ++i; diff -rupN boost-1_53_0/operators.hpp boost/operators.hpp --- boost-1_53_0/operators.hpp 2013-03-27 20:23:43.972761367 -0400 +++ boost/operators.hpp 2013-03-27 20:20:28.971512120 -0400 @@ -305,10 +305,10 @@ struct dereferenceable : B } }; -template > +template > struct indexable : B { - R operator[](I n) const + R operator[](__I n) const { return *(static_cast(*this) + n); } diff -rupN boost-1_53_0/smart_ptr/detail/spinlock_pool.hpp boost/smart_ptr/detail/spinlock_pool.hpp --- boost-1_53_0/smart_ptr/detail/spinlock_pool.hpp 2013-03-27 20:23:51.472760586 -0400 +++ boost/smart_ptr/detail/spinlock_pool.hpp 2013-03-27 20:16:50.469634572 -0400 @@ -31,7 +31,7 @@ namespace boost namespace detail { -template< int I > class spinlock_pool +template< int __I > class spinlock_pool { private: @@ -72,7 +72,7 @@ public: }; }; -template< int I > spinlock spinlock_pool< I >::pool_[ 41 ] = +template< int __I > spinlock spinlock_pool< __I >::pool_[ 41 ] = { BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT,