Ticket #2304: spirit.patch

File spirit.patch, 9.2 KB (added by alexott@…, 14 years ago)

patch to fix warnings

  • boost/spirit/home/classic/core/impl/match.ipp

     
    1919    : len(-1), val() {}
    2020
    2121    template <typename T>
    22     inline match<T>::match(std::size_t length)
    23     : len(length), val() {}
     22    inline match<T>::match(std::size_t length_)
     23    : len(length_), val() {}
    2424
    2525    template <typename T>
    26     inline match<T>::match(std::size_t length, ctor_param_t val_)
    27     : len(length), val(val_) {}
     26    inline match<T>::match(std::size_t length_, ctor_param_t val_)
     27    : len(length_), val(val_) {}
    2828
    2929    template <typename T>
    3030    inline bool
    … …  
    6666    inline match<nil_t>::match()
    6767    : len(-1) {}
    6868
    69     inline match<nil_t>::match(std::size_t length)
    70     : len(length) {}
     69    inline match<nil_t>::match(std::size_t length_)
     70    : len(length_) {}
    7171
    72     inline match<nil_t>::match(std::size_t length, nil_t)
    73     : len(length) {}
     72    inline match<nil_t>::match(std::size_t length_, nil_t)
     73    : len(length_) {}
    7474
    7575    inline bool
    7676    match<nil_t>::operator!() const

  • boost/spirit/home/classic/core/non_terminal/impl/rule.ipp

     
    226226        template <typename ParserT, typename ScannerT, typename AttrT>
    227227        struct concrete_parser : abstract_parser<ScannerT, AttrT>
    228228        {
    229             concrete_parser(ParserT const& p) : p(p) {}
     229            concrete_parser(ParserT const& p_) : p(p_) {}
    230230            virtual ~concrete_parser() {}
    231231
    232232            virtual typename match_result<ScannerT, AttrT>::type

  • boost/spirit/home/classic/core/non_terminal/subrule.hpp

     
    148148            subrule_list<
    149149                subrule_parser<ID, DefT, ContextT>,
    150150                RestT> >
    151         operator,(subrule_parser<ID, DefT, ContextT> const& rhs)
     151        operator,(subrule_parser<ID, DefT, ContextT> const& rhs_)
    152152        {
    153153            return subrule_list<
    154154                FirstT,
    … …  
    158158                        first,
    159159                        subrule_list<
    160160                            subrule_parser<ID, DefT, ContextT>,
    161                             RestT>(rhs, rest));
     161                            RestT>(rhs_, rest));
    162162        }
    163163
    164164        FirstT first;
    … …  
    258258        parse_main(ScannerT const& scan) const
    259259        {
    260260            typedef typename parser_result<self_t, ScannerT>::type result_t;
    261             result_t result;
     261            result_t result_;
    262262            impl::parse_subrule<result_t, ScannerT, ID>::
    263                 do_(result, scan);
    264             return result;
     263                do_(result_, scan);
     264            return result_;
    265265        }
    266266
    267267        template <typename ScannerT>

  • boost/spirit/home/classic/core/non_terminal/rule.hpp

     
    159159            return ptr.get();
    160160        }
    161161
    162         rule(abstract_parser_t* ptr)
    163         : ptr(ptr) {}
     162        rule(abstract_parser_t* ptr_)
     163        : ptr(ptr_) {}
    164164
    165         rule(abstract_parser_t const* ptr)
    166         : ptr(ptr) {}
     165        rule(abstract_parser_t const* ptr_)
     166        : ptr(ptr_) {}
    167167
    168168        scoped_ptr<abstract_parser_t> ptr;
    169169    };

  • boost/spirit/home/classic/core/non_terminal/parser_id.hpp

     
    106106                : parser_id(reinterpret_cast<std::size_t>(this));
    107107        }
    108108
    109         void set_id(parser_id id) { tag = id; }
     109        void set_id(parser_id id_) { tag = id_; }
    110110       
    111111    private:
    112112   

  • boost/spirit/home/classic/error_handling/exceptions.hpp

     
    126126        typedef unary<ParserT, parser<self_t> >         base_t;
    127127        typedef unary_parser_category                   parser_category_t;
    128128
    129         assertive_parser(ParserT const& parser, ErrorDescrT descriptor)
    130         : base_t(parser), descriptor(descriptor) {}
     129        assertive_parser(ParserT const& parser, ErrorDescrT descriptor_)
     130        : base_t(parser), descriptor(descriptor_) {}
    131131
    132132        template <typename ScannerT>
    133133        struct result

  • boost/spirit/home/classic/tree/common.hpp

     
    555555    {}
    556556
    557557    explicit
    558     tree_match(std::size_t length)
    559     : match<T>(length), trees()
     558    tree_match(std::size_t length_)
     559    : match<T>(length_), trees()
    560560    {}
    561561
    562     tree_match(std::size_t length, parse_node_t const& n)
    563     : match<T>(length), trees()
     562    tree_match(std::size_t length_, parse_node_t const& n)
     563    : match<T>(length_), trees()
    564564    {
    565565        trees.push_back(node_t(n));
    566566    }
    567567
    568     tree_match(std::size_t length, param_type val, parse_node_t const& n)
    569     : match<T>(length, val), trees()
     568    tree_match(std::size_t length_, param_type val, parse_node_t const& n)
     569    : match<T>(length_, val), trees()
    570570    {
    571571#if !defined(BOOST_SPIRIT_USE_LIST_FOR_TREES)
    572572        trees.reserve(10); // this is more or less an arbitrary number...
    … …  
    575575    }
    576576
    577577    // attention, these constructors will change the second parameter!
    578     tree_match(std::size_t length, container_t& c)
    579     : match<T>(length), trees()
     578    tree_match(std::size_t length_, container_t& c)
     579    : match<T>(length_), trees()
    580580    {
    581581        impl::cp_swap(trees, c);
    582582    }
    583583
    584     tree_match(std::size_t length, param_type val, container_t& c)
    585     : match<T>(length, val), trees()
     584    tree_match(std::size_t length_, param_type val, container_t& c)
     585    : match<T>(length_, val), trees()
    586586    {
    587587        impl::cp_swap(trees, c);
    588588    }

  • boost/spirit/home/classic/phoenix/actor.hpp

     
    340340template <typename BaseT>
    341341template <typename A>
    342342inline typename actor_result<BaseT, tuple<A&> >::type
    343 actor<BaseT>::operator()(A& a) const
     343actor<BaseT>::operator()(A& a_) const
    344344{
    345     return BaseT::eval(tuple<A&>(a));
     345    return BaseT::eval(tuple<A&>(a_));
    346346}
    347347
    348348//////////////////////////////////
    349349template <typename BaseT>
    350350template <typename A, typename B>
    351351inline typename actor_result<BaseT, tuple<A&, B&> >::type
    352 actor<BaseT>::operator()(A& a, B& b) const
     352actor<BaseT>::operator()(A& a_, B& b_) const
    353353{
    354     return BaseT::eval(tuple<A&, B&>(a, b));
     354    return BaseT::eval(tuple<A&, B&>(a_, b_));
    355355}
    356356
    357357//////////////////////////////////
    358358template <typename BaseT>
    359359template <typename A, typename B, typename C>
    360360inline typename actor_result<BaseT, tuple<A&, B&, C&> >::type
    361 actor<BaseT>::operator()(A& a, B& b, C& c) const
     361actor<BaseT>::operator()(A& a_, B& b_, C& c_) const
    362362{
    363     return BaseT::eval(tuple<A&, B&, C&>(a, b, c));
     363    return BaseT::eval(tuple<A&, B&, C&>(a_, b_, c_));
    364364}
    365365
    366366#if PHOENIX_LIMIT > 3
    … …  
    368368template <typename BaseT>
    369369template <typename A, typename B, typename C, typename D>
    370370inline typename actor_result<BaseT, tuple<A&, B&, C&, D&> >::type
    371 actor<BaseT>::operator()(A& a, B& b, C& c, D& d) const
     371actor<BaseT>::operator()(A& a_, B& b_, C& c_, D& d_) const
    372372{
    373     return BaseT::eval(tuple<A&, B&, C&, D&>(a, b, c, d));
     373    return BaseT::eval(tuple<A&, B&, C&, D&>(a_, b_, c_, d_));
    374374}
    375375
    376376//////////////////////////////////
    377377template <typename BaseT>
    378378template <typename A, typename B, typename C, typename D, typename E>
    379379inline typename actor_result<BaseT, tuple<A&, B&, C&, D&, E&> >::type
    380 actor<BaseT>::operator()(A& a, B& b, C& c, D& d, E& e) const
     380actor<BaseT>::operator()(A& a_, B& b_, C& c_, D& d_, E& e_) const
    381381{
    382     return BaseT::eval(tuple<A&, B&, C&, D&, E&>(a, b, c, d, e));
     382    return BaseT::eval(tuple<A&, B&, C&, D&, E&>(a_, b_, c_, d_, e_));
    383383}
    384384
    385385//////////////////////////////////
    … …  
    391391    tuple<A&, B&, C&, D&, E&, F&>
    392392>::type
    393393actor<BaseT>::operator()(
    394     A& a, B& b, C& c, D& d, E& e, F& f
     394    A& a_, B& b_, C& c_, D& d_, E& e_, F& f_
    395395) const
    396396{
    397397    return BaseT::eval(
    398398        tuple<A&, B&, C&, D&, E&, F&>
    399         (a, b, c, d, e, f)
     399        (a_, b_, c_, d_, e_, f_)
    400400    );
    401401}
    402402