Ticket #5996: shadow.patch

File shadow.patch, 9.6 KB (added by Shuo Chen <giantchen@…>, 11 years ago)

  • boost/ptr_container/exception.hpp

     
    2424    {
    2525        const char* what_;
    2626    public:
    27         bad_ptr_container_operation( const char* what ) : what_( what )
     27        bad_ptr_container_operation( const char* whatArg ) : what_( whatArg )
    2828        { }
    2929       
    3030        virtual const char* what() const throw()
    … …  
    3838    class bad_index : public bad_ptr_container_operation
    3939    {
    4040    public:
    41         bad_index( const char* what ) : bad_ptr_container_operation( what )
     41        bad_index( const char* whatArg ) : bad_ptr_container_operation( whatArg )
    4242        { }
    4343    };
    4444

  • boost/ptr_container/detail/move.hpp

     
    2020template<typename Ptr>
    2121class move_source {
    2222public:
    23     move_source(Ptr& ptr) : ptr_(ptr) {}
     23    move_source(Ptr& ptrArg) : ptr_(ptrArg) {}
    2424    Ptr& ptr() const { return ptr_; }
    2525private:
    2626    Ptr& ptr_;

  • boost/ptr_container/detail/static_move_ptr.hpp

     
    145145    deleter_const_reference get_deleter() const { return impl_.second(); }
    146146private:
    147147    template<typename TT, typename DD>
    148     void check(const static_move_ptr<TT, DD>& ptr)
     148    void check(const static_move_ptr<TT, DD>& ptrArg)
    149149        {
    150150            typedef move_ptrs::is_smart_ptr_convertible<TT, T> convertible;
    151151            BOOST_STATIC_ASSERT(convertible::value);

  • boost/ptr_container/detail/reversible_ptr_container.hpp

     
    5454    struct dynamic_clone_deleter
    5555    {
    5656        dynamic_clone_deleter() { }
    57         dynamic_clone_deleter( Container& cont ) : cont(&cont) { }
     57        dynamic_clone_deleter( Container& contArg ) : cont(&contArg) { }
    5858        Container* cont;
    5959
    6060        template< class T >
    … …  
    287287       
    288288    private:
    289289        template< class ForwardIterator >
    290         ForwardIterator advance( ForwardIterator begin, size_type n )
     290        ForwardIterator advance( ForwardIterator beginArg, size_type n )
    291291        {
    292             ForwardIterator iter = begin;
     292            ForwardIterator iter = beginArg;
    293293            std::advance( iter, n );
    294294            return iter;
    295295        }       

  • boost/unordered/detail/equivalent.hpp

     
    248248            node_pointer n = this->find_node(k);
    249249            if (!n) return 0;
    250250
    251             std::size_t count = 0;
     251            std::size_t result = 0;
    252252            node_pointer it = n;
    253253            do {
    254254                it = static_cast<node_pointer>(it->group_prev_);
    255                 ++count;
     255                ++result;
    256256            } while(it != n);
    257257
    258             return count;
     258            return result;
    259259        }
    260260
    261261        std::pair<node_pointer, node_pointer>
    … …  
    523523
    524524            std::size_t hash = this->hash_function()(k);
    525525            std::size_t bucket_index = hash % this->bucket_count_;
    526             bucket_pointer bucket = this->get_bucket(bucket_index);
     526            bucket_pointer bucket_ptr = this->get_bucket(bucket_index);
    527527
    528             previous_pointer prev = bucket->next_;
     528            previous_pointer prev = bucket_ptr->next_;
    529529            if (!prev) return 0;
    530530
    531531            for (;;)
    … …  
    548548                static_cast<node_pointer>(pos->group_prev_)->next_;
    549549            node_pointer end = static_cast<node_pointer>(end1);
    550550            prev->next_ = end1;
    551             this->fix_buckets(bucket, prev, end);
     551            this->fix_buckets(bucket_ptr, prev, end);
    552552            return this->delete_nodes(pos, end);
    553553        }
    554554
    … …  
    557557            BOOST_ASSERT(r);
    558558            node_pointer next = static_cast<node_pointer>(r->next_);
    559559
    560             bucket_pointer bucket = this->get_bucket(
     560            bucket_pointer bucket_ptr = this->get_bucket(
    561561                r->hash_ % this->bucket_count_);
    562             previous_pointer prev = unlink_node(*bucket, r);
     562            previous_pointer prev = unlink_node(*bucket_ptr, r);
    563563
    564             this->fix_buckets(bucket, prev, next);
     564            this->fix_buckets(bucket_ptr, prev, next);
    565565
    566566            this->delete_node(r);
    567567

  • boost/unordered/detail/buckets.hpp

     
    478478
    479479        // This is called after erasing a node or group of nodes to fix up
    480480        // the bucket pointers.
    481         void fix_buckets(bucket_pointer bucket,
     481        void fix_buckets(bucket_pointer bucket_ptr,
    482482                previous_pointer prev, node_pointer next)
    483483        {
    484484            if (!next)
    485485            {
    486                 if (bucket->next_ == prev) bucket->next_ = node_pointer();
     486                if (bucket_ptr->next_ == prev) bucket_ptr->next_ = node_pointer();
    487487            }
    488488            else
    489489            {
    490490                bucket_pointer next_bucket = this->get_bucket(
    491491                    next->hash_ % this->bucket_count_);
    492492
    493                 if (next_bucket != bucket)
     493                if (next_bucket != bucket_ptr)
    494494                {
    495495                    next_bucket->next_ = prev;
    496                     if (bucket->next_ == prev) bucket->next_ = node_pointer();
     496                    if (bucket_ptr->next_ == prev) bucket_ptr->next_ = node_pointer();
    497497                }
    498498            }
    499499        }

  • boost/unordered/detail/emplace_args.hpp

     
    8989    {                                                                       \
    9090        BOOST_PP_REPEAT_##z(n, BOOST_UNORDERED_EARGS_MEMBER, _)             \
    9191        BOOST_PP_CAT(emplace_args, n) (                                     \
    92             BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, B, a)                       \
     92            BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, B, aa)                      \
    9393        ) : BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_EARGS_INIT, _)             \
    9494        {}                                                                  \
    9595                                                                            \
    … …  
    116116
    117117#define BOOST_UNORDERED_EARGS_INIT(z, n, _)                                 \
    118118    BOOST_PP_CAT(a, n)(                                                     \
    119         boost::forward<BOOST_PP_CAT(A,n)>(BOOST_PP_CAT(a, n)))
     119        boost::forward<BOOST_PP_CAT(A,n)>(BOOST_PP_CAT(aa, n)))
    120120
    121121#else
    122122
    … …  
    126126    BOOST_PP_CAT(B, n) BOOST_PP_CAT(a, n);
    127127
    128128#define BOOST_UNORDERED_EARGS_INIT(z, n, _)                                 \
    129     BOOST_PP_CAT(a, n)(BOOST_PP_CAT(a, n))
     129    BOOST_PP_CAT(a, n)(BOOST_PP_CAT(aa, n))
    130130
    131131#endif
    132132

  • boost/unordered/detail/unique.hpp

     
    525525
    526526            std::size_t hash = this->hash_function()(k);
    527527            std::size_t bucket_index = hash % this->bucket_count_;
    528             bucket_pointer bucket = this->get_bucket(bucket_index);
     528            bucket_pointer bucket_ptr = this->get_bucket(bucket_index);
    529529
    530             previous_pointer prev = bucket->next_;
     530            previous_pointer prev = bucket_ptr->next_;
    531531            if (!prev) return 0;
    532532
    533533            for (;;)
    … …  
    547547            node_pointer pos = static_cast<node_pointer>(prev->next_);
    548548            node_pointer end = static_cast<node_pointer>(pos->next_);
    549549            prev->next_ = pos->next_;
    550             this->fix_buckets(bucket, prev, end);
     550            this->fix_buckets(bucket_ptr, prev, end);
    551551            return this->delete_nodes(pos, end);
    552552        }
    553553
    … …  
    556556            BOOST_ASSERT(r);
    557557            node_pointer next = static_cast<node_pointer>(r->next_);
    558558
    559             bucket_pointer bucket = this->get_bucket(
     559            bucket_pointer bucket_ptr = this->get_bucket(
    560560                r->hash_ % this->bucket_count_);
    561             previous_pointer prev = unlink_node(*bucket, r);
     561            previous_pointer prev = unlink_node(*bucket_ptr, r);
    562562
    563             this->fix_buckets(bucket, prev, next);
     563            this->fix_buckets(bucket_ptr, prev, next);
    564564
    565565            this->delete_node(r);
    566566

  • boost/concept_check.hpp

     
    10501050        c.swap(c);
    10511051      }
    10521052
    1053       void const_constraints(const C& c) {
    1054         ci = c.begin();
    1055         ci = c.end();
    1056         n = c.size();
    1057         b = c.empty();
     1053      void const_constraints(const C& cc) {
     1054        ci = cc.begin();
     1055        ci = cc.end();
     1056        n = cc.size();
     1057        b = cc.empty();
    10581058      }
    10591059
    10601060    private: