Ticket #8349: I_to___I.patch

File I_to___I.patch, 23.2 KB (added by Kevin Waugh <kevin.waugh@…>, 10 years ago)

  • algorithm/string/yes_no_type.hpp 

    diff -rupN boost-1_53_0/algorithm/string/yes_no_type.hpp boost/algorithm/string/yes_no_type.hpp
    old new namespace boost {  
    1818        // when yes_no_type will become officially
    1919        // a part of boost distribution, this header
    2020        // will be deprecated
    21         template<int I> struct size_descriptor
     21        template<int __I> struct size_descriptor
    2222        {
    23             typedef char (& type)[I];
     23            typedef char (& type)[__I];
    2424        };
    2525
    2626        typedef size_descriptor<1>::type yes_type;

  • bind/arg.hpp 

    diff -rupN boost-1_53_0/bind/arg.hpp boost/bind/arg.hpp
    old new  
    2525namespace boost
    2626{
    2727
    28 template< int I > struct arg
     28template< int __I > struct arg
    2929{
    3030    arg()
    3131    {
    … … template< int I > struct arg  
    3434    template< class T > arg( T const & /* t */ )
    3535    {
    3636        // static assert I == is_placeholder<T>::value
    37         typedef char T_must_be_placeholder[ I == is_placeholder<T>::value? 1: -1 ];
     37        typedef char T_must_be_placeholder[ __I == is_placeholder<T>::value? 1: -1 ];
    3838    }
    3939};
    4040
    41 template< int I > bool operator==( arg<I> const &, arg<I> const & )
     41template< int __I > bool operator==( arg<__I> const &, arg<__I> const & )
    4242{
    4343    return true;
    4444}
    4545
    4646#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
    4747
    48 template< int I > struct is_placeholder< arg<I> >
     48template< int __I > struct is_placeholder< arg<__I> >
    4949{
    50     enum _vt { value = I };
     50    enum _vt { value = __I };
    5151};
    5252
    53 template< int I > struct is_placeholder< arg<I> (*) () >
     53template< int __I > struct is_placeholder< arg<__I> (*) () >
    5454{
    55     enum _vt { value = I };
     55    enum _vt { value = __I };
    5656};
    5757
    5858#endif

  • bind/bind.hpp 

    diff -rupN boost-1_53_0/bind/bind.hpp boost/bind/bind.hpp
    old new template<class T> bool ref_compare( T co  
    8383    return a == b;
    8484}
    8585
    86 template<int I> bool ref_compare( arg<I> const &, arg<I> const &, int )
     86template<int __I> bool ref_compare( arg<__I> const &, arg<__I> const &, int )
    8787{
    8888    return true;
    8989}
    9090
    91 template<int I> bool ref_compare( arg<I> (*) (), arg<I> (*) (), int )
     91template<int __I> bool ref_compare( arg<__I> (*) (), arg<__I> (*) (), int )
    9292{
    9393    return true;
    9494}
    … … template<class T> struct add_value  
    991991
    992992#else
    993993
    994 template< class T, int I > struct add_value_2
     994template< class T, int __I > struct add_value_2
    995995{
    996     typedef boost::arg<I> type;
     996    typedef boost::arg<__I> type;
    997997};
    998998
    999999template< class T > struct add_value_2< T, 0 >
    … … template<class T> struct add_value< refe  
    10181018    typedef reference_wrapper<T> type;
    10191019};
    10201020
    1021 template<int I> struct add_value< arg<I> >
     1021template<int __I> struct add_value< arg<__I> >
    10221022{
    1023     typedef boost::arg<I> type;
     1023    typedef boost::arg<__I> type;
    10241024};
    10251025
    1026 template<int I> struct add_value< arg<I> (*) () >
     1026template<int __I> struct add_value< arg<__I> (*) () >
    10271027{
    1028     typedef boost::arg<I> (*type) ();
     1028    typedef boost::arg<__I> (*type) ();
    10291029};
    10301030
    10311031template<class R, class F, class L> struct add_value< bind_t<R, F, L> >
    … … template<class R, class F, class L> stru  
    10351035
    10361036#else
    10371037
    1038 template<int I> struct _avt_0;
     1038template<int __I> struct _avt_0;
    10391039
    10401040template<> struct _avt_0<1>
    10411041{
    … … typedef char (&_avt_r2) [2];  
    10581058
    10591059template<class T> _avt_r1 _avt_f(value<T>);
    10601060template<class T> _avt_r1 _avt_f(reference_wrapper<T>);
    1061 template<int I> _avt_r1 _avt_f(arg<I>);
    1062 template<int I> _avt_r1 _avt_f(arg<I> (*) ());
     1061template<int __I> _avt_r1 _avt_f(arg<__I>);
     1062template<int __I> _avt_r1 _avt_f(arg<__I> (*) ());
    10631063template<class R, class F, class L> _avt_r1 _avt_f(bind_t<R, F, L>);
    10641064
    10651065_avt_r2 _avt_f(...);
    … … _bi::bind_t< R, _mfi::dm<R, T>, typename  
    16561656namespace _bi
    16571657{
    16581658
    1659 template< class Pm, int I > struct add_cref;
     1659template< class Pm, int __I > struct add_cref;
    16601660
    16611661template< class M, class T > struct add_cref< M T::*, 0 >
    16621662{

  • bind/storage.hpp 

    diff -rupN boost-1_53_0/bind/storage.hpp boost/bind/storage.hpp
    old new template<class A1> struct storage1  
    5151
    5252#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) && !defined( __BORLANDC__ )
    5353
    54 template<int I> struct storage1< boost::arg<I> >
     54template<int __I> struct storage1< boost::arg<__I> >
    5555{
    56     explicit storage1( boost::arg<I> ) {}
     56    explicit storage1( boost::arg<__I> ) {}
    5757
    5858    template<class V> void accept(V &) const { }
    5959
    60     static boost::arg<I> a1_() { return boost::arg<I>(); }
     60    static boost::arg<__I> a1_() { return boost::arg<__I>(); }
    6161};
    6262
    63 template<int I> struct storage1< boost::arg<I> (*) () >
     63template<int __I> struct storage1< boost::arg<__I> (*) () >
    6464{
    65     explicit storage1( boost::arg<I> (*) () ) {}
     65    explicit storage1( boost::arg<__I> (*) () ) {}
    6666
    6767    template<class V> void accept(V &) const { }
    6868
    69     static boost::arg<I> a1_() { return boost::arg<I>(); }
     69    static boost::arg<__I> a1_() { return boost::arg<__I>(); }
    7070};
    7171
    7272#endif
    … … template<class A1, class A2> struct stor  
    9090
    9191#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
    9292
    93 template<class A1, int I> struct storage2< A1, boost::arg<I> >: public storage1<A1>
     93template<class A1, int __I> struct storage2< A1, boost::arg<__I> >: public storage1<A1>
    9494{
    9595    typedef storage1<A1> inherited;
    9696
    97     storage2( A1 a1, boost::arg<I> ): storage1<A1>( a1 ) {}
     97    storage2( A1 a1, boost::arg<__I> ): storage1<A1>( a1 ) {}
    9898
    9999    template<class V> void accept(V & v) const
    100100    {
    101101        inherited::accept(v);
    102102    }
    103103
    104     static boost::arg<I> a2_() { return boost::arg<I>(); }
     104    static boost::arg<__I> a2_() { return boost::arg<__I>(); }
    105105};
    106106
    107 template<class A1, int I> struct storage2< A1, boost::arg<I> (*) () >: public storage1<A1>
     107template<class A1, int __I> struct storage2< A1, boost::arg<__I> (*) () >: public storage1<A1>
    108108{
    109109    typedef storage1<A1> inherited;
    110110
    111     storage2( A1 a1, boost::arg<I> (*) () ): storage1<A1>( a1 ) {}
     111    storage2( A1 a1, boost::arg<__I> (*) () ): storage1<A1>( a1 ) {}
    112112
    113113    template<class V> void accept(V & v) const
    114114    {
    115115        inherited::accept(v);
    116116    }
    117117
    118     static boost::arg<I> a2_() { return boost::arg<I>(); }
     118    static boost::arg<__I> a2_() { return boost::arg<__I>(); }
    119119};
    120120
    121121#endif
    … … template<class A1, class A2, class A3> s  
    139139
    140140#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
    141141
    142 template<class A1, class A2, int I> struct storage3< A1, A2, boost::arg<I> >: public storage2< A1, A2 >
     142template<class A1, class A2, int __I> struct storage3< A1, A2, boost::arg<__I> >: public storage2< A1, A2 >
    143143{
    144144    typedef storage2<A1, A2> inherited;
    145145
    146     storage3( A1 a1, A2 a2, boost::arg<I> ): storage2<A1, A2>( a1, a2 ) {}
     146    storage3( A1 a1, A2 a2, boost::arg<__I> ): storage2<A1, A2>( a1, a2 ) {}
    147147
    148148    template<class V> void accept(V & v) const
    149149    {
    150150        inherited::accept(v);
    151151    }
    152152
    153     static boost::arg<I> a3_() { return boost::arg<I>(); }
     153    static boost::arg<__I> a3_() { return boost::arg<__I>(); }
    154154};
    155155
    156 template<class A1, class A2, int I> struct storage3< A1, A2, boost::arg<I> (*) () >: public storage2< A1, A2 >
     156template<class A1, class A2, int __I> struct storage3< A1, A2, boost::arg<__I> (*) () >: public storage2< A1, A2 >
    157157{
    158158    typedef storage2<A1, A2> inherited;
    159159
    160     storage3( A1 a1, A2 a2, boost::arg<I> (*) () ): storage2<A1, A2>( a1, a2 ) {}
     160    storage3( A1 a1, A2 a2, boost::arg<__I> (*) () ): storage2<A1, A2>( a1, a2 ) {}
    161161
    162162    template<class V> void accept(V & v) const
    163163    {
    164164        inherited::accept(v);
    165165    }
    166166
    167     static boost::arg<I> a3_() { return boost::arg<I>(); }
     167    static boost::arg<__I> a3_() { return boost::arg<__I>(); }
    168168};
    169169
    170170#endif
    … … template<class A1, class A2, class A3, c  
    188188
    189189#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
    190190
    191 template<class A1, class A2, class A3, int I> struct storage4< A1, A2, A3, boost::arg<I> >: public storage3< A1, A2, A3 >
     191template<class A1, class A2, class A3, int __I> struct storage4< A1, A2, A3, boost::arg<__I> >: public storage3< A1, A2, A3 >
    192192{
    193193    typedef storage3<A1, A2, A3> inherited;
    194194
    195     storage4( A1 a1, A2 a2, A3 a3, boost::arg<I> ): storage3<A1, A2, A3>( a1, a2, a3 ) {}
     195    storage4( A1 a1, A2 a2, A3 a3, boost::arg<__I> ): storage3<A1, A2, A3>( a1, a2, a3 ) {}
    196196
    197197    template<class V> void accept(V & v) const
    198198    {
    199199        inherited::accept(v);
    200200    }
    201201
    202     static boost::arg<I> a4_() { return boost::arg<I>(); }
     202    static boost::arg<__I> a4_() { return boost::arg<__I>(); }
    203203};
    204204
    205 template<class A1, class A2, class A3, int I> struct storage4< A1, A2, A3, boost::arg<I> (*) () >: public storage3< A1, A2, A3 >
     205template<class A1, class A2, class A3, int __I> struct storage4< A1, A2, A3, boost::arg<__I> (*) () >: public storage3< A1, A2, A3 >
    206206{
    207207    typedef storage3<A1, A2, A3> inherited;
    208208
    209     storage4( A1 a1, A2 a2, A3 a3, boost::arg<I> (*) () ): storage3<A1, A2, A3>( a1, a2, a3 ) {}
     209    storage4( A1 a1, A2 a2, A3 a3, boost::arg<__I> (*) () ): storage3<A1, A2, A3>( a1, a2, a3 ) {}
    210210
    211211    template<class V> void accept(V & v) const
    212212    {
    213213        inherited::accept(v);
    214214    }
    215215
    216     static boost::arg<I> a4_() { return boost::arg<I>(); }
     216    static boost::arg<__I> a4_() { return boost::arg<__I>(); }
    217217};
    218218
    219219#endif
    … … template<class A1, class A2, class A3, c  
    237237
    238238#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
    239239
    240 template<class A1, class A2, class A3, class A4, int I> struct storage5< A1, A2, A3, A4, boost::arg<I> >: public storage4< A1, A2, A3, A4 >
     240template<class A1, class A2, class A3, class A4, int __I> struct storage5< A1, A2, A3, A4, boost::arg<__I> >: public storage4< A1, A2, A3, A4 >
    241241{
    242242    typedef storage4<A1, A2, A3, A4> inherited;
    243243
    244     storage5( A1 a1, A2 a2, A3 a3, A4 a4, boost::arg<I> ): storage4<A1, A2, A3, A4>( a1, a2, a3, a4 ) {}
     244    storage5( A1 a1, A2 a2, A3 a3, A4 a4, boost::arg<__I> ): storage4<A1, A2, A3, A4>( a1, a2, a3, a4 ) {}
    245245
    246246    template<class V> void accept(V & v) const
    247247    {
    248248        inherited::accept(v);
    249249    }
    250250
    251     static boost::arg<I> a5_() { return boost::arg<I>(); }
     251    static boost::arg<__I> a5_() { return boost::arg<__I>(); }
    252252};
    253253
    254 template<class A1, class A2, class A3, class A4, int I> struct storage5< A1, A2, A3, A4, boost::arg<I> (*) () >: public storage4< A1, A2, A3, A4 >
     254template<class A1, class A2, class A3, class A4, int __I> struct storage5< A1, A2, A3, A4, boost::arg<__I> (*) () >: public storage4< A1, A2, A3, A4 >
    255255{
    256256    typedef storage4<A1, A2, A3, A4> inherited;
    257257
    258     storage5( A1 a1, A2 a2, A3 a3, A4 a4, boost::arg<I> (*) () ): storage4<A1, A2, A3, A4>( a1, a2, a3, a4 ) {}
     258    storage5( A1 a1, A2 a2, A3 a3, A4 a4, boost::arg<__I> (*) () ): storage4<A1, A2, A3, A4>( a1, a2, a3, a4 ) {}
    259259
    260260    template<class V> void accept(V & v) const
    261261    {
    262262        inherited::accept(v);
    263263    }
    264264
    265     static boost::arg<I> a5_() { return boost::arg<I>(); }
     265    static boost::arg<__I> a5_() { return boost::arg<__I>(); }
    266266};
    267267
    268268#endif
    … … template<class A1, class A2, class A3, c  
    286286
    287287#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
    288288
    289 template<class A1, class A2, class A3, class A4, class A5, int I> struct storage6< A1, A2, A3, A4, A5, boost::arg<I> >: public storage5< A1, A2, A3, A4, A5 >
     289template<class A1, class A2, class A3, class A4, class A5, int __I> struct storage6< A1, A2, A3, A4, A5, boost::arg<__I> >: public storage5< A1, A2, A3, A4, A5 >
    290290{
    291291    typedef storage5<A1, A2, A3, A4, A5> inherited;
    292292
    293     storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, boost::arg<I> ): storage5<A1, A2, A3, A4, A5>( a1, a2, a3, a4, a5 ) {}
     293    storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, boost::arg<__I> ): storage5<A1, A2, A3, A4, A5>( a1, a2, a3, a4, a5 ) {}
    294294
    295295    template<class V> void accept(V & v) const
    296296    {
    297297        inherited::accept(v);
    298298    }
    299299
    300     static boost::arg<I> a6_() { return boost::arg<I>(); }
     300    static boost::arg<__I> a6_() { return boost::arg<__I>(); }
    301301};
    302302
    303 template<class A1, class A2, class A3, class A4, class A5, int I> struct storage6< A1, A2, A3, A4, A5, boost::arg<I> (*) () >: public storage5< A1, A2, A3, A4, A5 >
     303template<class A1, class A2, class A3, class A4, class A5, int __I> struct storage6< A1, A2, A3, A4, A5, boost::arg<__I> (*) () >: public storage5< A1, A2, A3, A4, A5 >
    304304{
    305305    typedef storage5<A1, A2, A3, A4, A5> inherited;
    306306
    307     storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, boost::arg<I> (*) () ): storage5<A1, A2, A3, A4, A5>( a1, a2, a3, a4, a5 ) {}
     307    storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, boost::arg<__I> (*) () ): storage5<A1, A2, A3, A4, A5>( a1, a2, a3, a4, a5 ) {}
    308308
    309309    template<class V> void accept(V & v) const
    310310    {
    311311        inherited::accept(v);
    312312    }
    313313
    314     static boost::arg<I> a6_() { return boost::arg<I>(); }
     314    static boost::arg<__I> a6_() { return boost::arg<__I>(); }
    315315};
    316316
    317317#endif
    … … template<class A1, class A2, class A3, c  
    335335
    336336#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
    337337
    338 template<class A1, class A2, class A3, class A4, class A5, class A6, int I> struct storage7< A1, A2, A3, A4, A5, A6, boost::arg<I> >: public storage6< A1, A2, A3, A4, A5, A6 >
     338template<class A1, class A2, class A3, class A4, class A5, class A6, int __I> struct storage7< A1, A2, A3, A4, A5, A6, boost::arg<__I> >: public storage6< A1, A2, A3, A4, A5, A6 >
    339339{
    340340    typedef storage6<A1, A2, A3, A4, A5, A6> inherited;
    341341
    342     storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, boost::arg<I> ): storage6<A1, A2, A3, A4, A5, A6>( a1, a2, a3, a4, a5, a6 ) {}
     342    storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, boost::arg<__I> ): storage6<A1, A2, A3, A4, A5, A6>( a1, a2, a3, a4, a5, a6 ) {}
    343343
    344344    template<class V> void accept(V & v) const
    345345    {
    346346        inherited::accept(v);
    347347    }
    348348
    349     static boost::arg<I> a7_() { return boost::arg<I>(); }
     349    static boost::arg<__I> a7_() { return boost::arg<__I>(); }
    350350};
    351351
    352 template<class A1, class A2, class A3, class A4, class A5, class A6, int I> struct storage7< A1, A2, A3, A4, A5, A6, boost::arg<I> (*) () >: public storage6< A1, A2, A3, A4, A5, A6 >
     352template<class A1, class A2, class A3, class A4, class A5, class A6, int __I> struct storage7< A1, A2, A3, A4, A5, A6, boost::arg<__I> (*) () >: public storage6< A1, A2, A3, A4, A5, A6 >
    353353{
    354354    typedef storage6<A1, A2, A3, A4, A5, A6> inherited;
    355355
    356     storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, boost::arg<I> (*) () ): storage6<A1, A2, A3, A4, A5, A6>( a1, a2, a3, a4, a5, a6 ) {}
     356    storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, boost::arg<__I> (*) () ): storage6<A1, A2, A3, A4, A5, A6>( a1, a2, a3, a4, a5, a6 ) {}
    357357
    358358    template<class V> void accept(V & v) const
    359359    {
    360360        inherited::accept(v);
    361361    }
    362362
    363     static boost::arg<I> a7_() { return boost::arg<I>(); }
     363    static boost::arg<__I> a7_() { return boost::arg<__I>(); }
    364364};
    365365
    366366#endif
    … … template<class A1, class A2, class A3, c  
    384384
    385385#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
    386386
    387 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, int I> struct storage8< A1, A2, A3, A4, A5, A6, A7, boost::arg<I> >: public storage7< A1, A2, A3, A4, A5, A6, A7 >
     387template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, int __I> struct storage8< A1, A2, A3, A4, A5, A6, A7, boost::arg<__I> >: public storage7< A1, A2, A3, A4, A5, A6, A7 >
    388388{
    389389    typedef storage7<A1, A2, A3, A4, A5, A6, A7> inherited;
    390390
    391     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>( a1, a2, a3, a4, a5, a6, a7 ) {}
     391    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>( a1, a2, a3, a4, a5, a6, a7 ) {}
    392392
    393393    template<class V> void accept(V & v) const
    394394    {
    395395        inherited::accept(v);
    396396    }
    397397
    398     static boost::arg<I> a8_() { return boost::arg<I>(); }
     398    static boost::arg<__I> a8_() { return boost::arg<__I>(); }
    399399};
    400400
    401 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, int I> struct storage8< A1, A2, A3, A4, A5, A6, A7, boost::arg<I> (*) () >: public storage7< A1, A2, A3, A4, A5, A6, A7 >
     401template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, int __I> struct storage8< A1, A2, A3, A4, A5, A6, A7, boost::arg<__I> (*) () >: public storage7< A1, A2, A3, A4, A5, A6, A7 >
    402402{
    403403    typedef storage7<A1, A2, A3, A4, A5, A6, A7> inherited;
    404404
    405     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>( a1, a2, a3, a4, a5, a6, a7 ) {}
     405    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>( a1, a2, a3, a4, a5, a6, a7 ) {}
    406406
    407407    template<class V> void accept(V & v) const
    408408    {
    409409        inherited::accept(v);
    410410    }
    411411
    412     static boost::arg<I> a8_() { return boost::arg<I>(); }
     412    static boost::arg<__I> a8_() { return boost::arg<__I>(); }
    413413};
    414414
    415415#endif
    … … template<class A1, class A2, class A3, c  
    433433
    434434#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
    435435
    436 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, int I> struct storage9< A1, A2, A3, A4, A5, A6, A7, A8, boost::arg<I> >: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
     436template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, int __I> struct storage9< A1, A2, A3, A4, A5, A6, A7, A8, boost::arg<__I> >: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
    437437{
    438438    typedef storage8<A1, A2, A3, A4, A5, A6, A7, A8> inherited;
    439439
    440     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>( a1, a2, a3, a4, a5, a6, a7, a8 ) {}
     440    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>( a1, a2, a3, a4, a5, a6, a7, a8 ) {}
    441441
    442442    template<class V> void accept(V & v) const
    443443    {
    444444        inherited::accept(v);
    445445    }
    446446
    447     static boost::arg<I> a9_() { return boost::arg<I>(); }
     447    static boost::arg<__I> a9_() { return boost::arg<__I>(); }
    448448};
    449449
    450 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, int I> struct storage9< A1, A2, A3, A4, A5, A6, A7, A8, boost::arg<I> (*) () >: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
     450template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, int __I> struct storage9< A1, A2, A3, A4, A5, A6, A7, A8, boost::arg<__I> (*) () >: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
    451451{
    452452    typedef storage8<A1, A2, A3, A4, A5, A6, A7, A8> inherited;
    453453
    454     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>( a1, a2, a3, a4, a5, a6, a7, a8 ) {}
     454    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>( a1, a2, a3, a4, a5, a6, a7, a8 ) {}
    455455
    456456    template<class V> void accept(V & v) const
    457457    {
    458458        inherited::accept(v);
    459459    }
    460460
    461     static boost::arg<I> a9_() { return boost::arg<I>(); }
     461    static boost::arg<__I> a9_() { return boost::arg<__I>(); }
    462462};
    463463
    464464#endif

  • iterator/iterator_facade.hpp 

    diff -rupN boost-1_53_0/iterator/iterator_facade.hpp boost/iterator/iterator_facade.hpp
    old new namespace boost  
    4040{
    4141  // This forward declaration is required for the friend declaration
    4242  // in iterator_core_access
    43   template <class I, class V, class TC, class R, class D> class iterator_facade;
     43  template <class __I, class V, class TC, class R, class D> class iterator_facade;
    4444
    4545  namespace detail
    4646  {
    … … namespace boost  
    474474   public:
    475475# else
    476476     
    477       template <class I, class V, class TC, class R, class D> friend class iterator_facade;
     477      template <class __I, class V, class TC, class R, class D> friend class iterator_facade;
    478478
    479479#  define BOOST_ITERATOR_FACADE_RELATION(op)                                \
    480480      BOOST_ITERATOR_FACADE_INTEROP_HEAD(friend,op, boost::detail::always_bool2);
    … … namespace boost  
    561561      //
    562562      // Curiously Recurring Template interface.
    563563      //
    564       template <class I, class V, class TC, class R, class D>
    565       static I& derived(iterator_facade<I,V,TC,R,D>& facade)
     564      template <class __I, class V, class TC, class R, class D>
     565      static __I& derived(iterator_facade<__I,V,TC,R,D>& facade)
    566566      {
    567           return *static_cast<I*>(&facade);
     567          return *static_cast<__I*>(&facade);
    568568      }
    569569
    570       template <class I, class V, class TC, class R, class D>
    571       static I const& derived(iterator_facade<I,V,TC,R,D> const& facade)
     570      template <class __I, class V, class TC, class R, class D>
     571      static __I const& derived(iterator_facade<__I,V,TC,R,D> const& facade)
    572572      {
    573           return *static_cast<I const*>(&facade);
     573          return *static_cast<__I const*>(&facade);
    574574      }
    575575
    576576   private:
    … … namespace boost  
    717717  };
    718718
    719719# if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
    720   template <class I, class V, class TC, class R, class D>
    721   inline typename boost::detail::postfix_increment_result<I,V,R,TC>::type
     720  template <class __I, class V, class TC, class R, class D>
     721  inline typename boost::detail::postfix_increment_result<__I,V,R,TC>::type
    722722  operator++(
    723       iterator_facade<I,V,TC,R,D>& i
     723      iterator_facade<__I,V,TC,R,D>& i
    724724    , int
    725725  )
    726726  {
    727       typename boost::detail::postfix_increment_result<I,V,R,TC>::type
    728           tmp(*static_cast<I*>(&i));
     727      typename boost::detail::postfix_increment_result<__I,V,R,TC>::type
     728          tmp(*static_cast<__I*>(&i));
    729729     
    730730      ++i;
    731731     

  • operators.hpp 

    diff -rupN boost-1_53_0/operators.hpp boost/operators.hpp
    old new struct dereferenceable : B  
    305305  }
    306306};
    307307
    308 template <class T, class I, class R, class B = ::boost::detail::empty_base<T> >
     308template <class T, class __I, class R, class B = ::boost::detail::empty_base<T> >
    309309struct indexable : B
    310310{
    311   R operator[](I n) const
     311  R operator[](__I n) const
    312312  {
    313313    return *(static_cast<const T&>(*this) + n);
    314314  }

  • smart_ptr/detail/spinlock_pool.hpp 

    diff -rupN boost-1_53_0/smart_ptr/detail/spinlock_pool.hpp boost/smart_ptr/detail/spinlock_pool.hpp
    old new namespace boost  
    3131namespace detail
    3232{
    3333
    34 template< int I > class spinlock_pool
     34template< int __I > class spinlock_pool
    3535{
    3636private:
    3737
    … … public:  
    7272    };
    7373};
    7474
    75 template< int I > spinlock spinlock_pool< I >::pool_[ 41 ] =
     75template< int __I > spinlock spinlock_pool< __I >::pool_[ 41 ] =
    7676{
    7777    BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT,
    7878    BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT,