attr_rule.hpp

著名的Parser库Spirit在VC6上的Port

        typename boost::tuples::tuple<T0, T1, T2, T3>
    > 
    operator()(T0 const &t0, T1 const &t1, T2 const &t2, T3 const &t3)
   {
       typedef typename boost::tuples::tuple<T0,T1,
         T2, T3> init_tuple_t
        return param_parser<TupleT, ParserT, init_tuple_t>(
        boost::tuples::make_tuple(t0,t1,t2,t3), ptr, parser);
   }


    //////////////////////////////////////////////////////////// 
    template <typename T0, typename T1, typename T2, typename T3, typename T4>
    param_parser<
        TupleT, ParserT, 
        typename boost::tuples::tuple<
            T0, T1, T2, T3, T4>
    > 
    operator()(T0 const &t0, T1 const &t1, T2 const &t2, T3 const &t3, 
        T4 const &t4)
   {
       typedef typename boost::tuples::tuple<T0,T1,
         T2, T3, T4> init_tuple_t
        return param_parser<TupleT, ParserT, init_tuple_t>(
        boost::tuples::make_tuple(t0,t1,t2,t3,t4), ptr, parser);
   }

    //////////////////////////////////////////////////////////// 
    template <
        typename T0, typename T1, typename T2, typename T3, typename T4,
        typename T5
    >
    param_parser<
        TupleT, ParserT, 
        typename boost::tuples::tuple<
            T0, T1, T2, T3, T4, T5>
    > 
    operator()(T0 const &t0, T1 const &t1, T2 const &t2, T3 const &t3, 
        T4 const &t4, T5 const &t5)
   {
       typedef typename boost::tuples::tuple<T0,T1,
         T2, T3, T4, T5> init_tuple_t
        return param_parser<TupleT, ParserT, init_tuple_t>(
        boost::tuples::make_tuple(t0,t1,t2,t3,t4,t5), ptr, parser);
   }

    //////////////////////////////////////////////////////////// 
    template <
        typename T0, typename T1, typename T2, typename T3, typename T4,
        typename T5, typename T6
    >
    param_parser<
        TupleT, ParserT, 
        typename boost::tuples::tuple<
            T0, T1, T2, T3, T4, T5, T6>
    > 
    operator()(T0 const &t0, T1 const &t1, T2 const &t2, T3 const &t3, 
        T4 const &t4, T5 const &t5, T6 const &t6)
   {
       typedef typename boost::tuples::tuple<T0,T1,
         T2, T3, T4, T5, T6> init_tuple_t
        return param_parser<TupleT, ParserT, init_tuple_t>(
        boost::tuples::make_tuple(t0,t1,t2,t3,t4,t5,t6), ptr, parser);
   }


    //////////////////////////////////////////////////////////// 
    template <
        typename T0, typename T1, typename T2, typename T3, typename T4,
        typename T5, typename T6, typename T7
    >
    param_parser<
        TupleT, ParserT, 
        typename boost::tuples::tuple<
            T0, T1, T2, T3, T4, T5, T6, T7>
    > 
    operator()(T0 const &t0, T1 const &t1, T2 const &t2, T3 const &t3, 
        T4 const &t4, T5 const &t5, T6 const &t6, T7 const &t7)
   {
       typedef typename boost::tuples::tuple<T0,T1,
         T2, T3, T4, T5, T6, T7> init_tuple_t
        return param_parser<TupleT, ParserT, init_tuple_t>(
        boost::tuples::make_tuple(t0,t1,t2,t3,t4,t5,t6,t7), ptr, parser);
   }

    //////////////////////////////////////////////////////////// 
    template <
        typename T0, typename T1, typename T2, typename T3, typename T4,
        typename T5, typename T6, typename T7, typename T8
    >
    param_parser<
        TupleT, ParserT, 
        typename boost::tuples::tuple<
            T0, T1, T2, T3, T4, T5, T6, T7, T8>
    > 
    operator()(T0 const &t0, T1 const &t1, T2 const &t2, T3 const &t3, 
        T4 const &t4, T5 const &t5, T6 const &t6, T7 const &t7, T8 const &t8)
   {
       typedef typename boost::tuples::tuple<T0,T1,
         T2, T3, T4, T5, T6, T7, T8> init_tuple_t
        return param_parser<TupleT, ParserT, init_tuple_t>(
        boost::tuples::make_tuple(t0,t1,t2,t3,t4,t5,t6,t7,t8), ptr, parser);
   }

    //////////////////////////////////////////////////////////// 
    template <
        typename T0, typename T1, typename T2, typename T3, typename T4,
        typename T5, typename T6, typename T7, typename T8, typename T9
    >
    param_parser<
        TupleT, ParserT, 
        typename boost::tuples::tuple<
            T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
    > 
    operator()(T0 const &t0, T1 const &t1, T2 const &t2, T3 const &t3, 
        T4 const &t4, T5 const &t5, T6 const &t6, T7 const &t7, T8 const &t8,
        T9 const &t9)
   {
       typedef typename boost::tuples::tuple<T0,T1,
         T2, T3, T4, T5, T6, T7, T8,T9> init_tuple_t
        return param_parser<TupleT, ParserT, init_tuple_t>(
        boost::tuples::make_tuple(t0,t1,t2,t3,t4,t5,t6,t7,t8.t9), ptr, parser);
   }


private:
    TupleT *& ptr;
    ParserT const &parser;
};

///////////////////////////////////////////////////////////////////////////////
// 
//  attr_rule class
//
//      This class is essentially a closure wrapped around a rule, so that the
//      closure members are accessible all the way down the parser hierarchy.
//
///////////////////////////////////////////////////////////////////////////////

template <typename ClosureT, typename IteratorT, typename MatchTraitsT>
struct attr_rule :
    public base_rule<IteratorT, MatchTraitsT, 
        attr_rule<ClosureT, IteratorT, MatchTraitsT> >,
    public ClosureT::base_closure_t
{
    typedef attr_rule<ClosureT, IteratorT, MatchTraitsT> this_t;
    typedef base_rule<IteratorT, MatchTraitsT, this_t> rule_t;

    typedef typename ClosureT::base_closure_t closure_t;
    typedef typename closure_t::tuple_t tuple_t;
    typedef typename boost::tuples::element<0, tuple_t>::type return_t;

    typedef closure_parser_category parser_category;

    template <typename ParserT>
    attr_rule(ParserT const& parser)
    :    rule_t(parser),
        init(ptr, rule_base())
    {
    }

    attr_rule();
    attr_rule(this_t const& other);
    attr_rule(rule_t const& other);


    ~attr_rule();

// parsing functions
    attr_match<return_t>
    parse(IteratorT& first, IteratorT const& last) const
    {
      typedef closure_parser<tuple_t, rule_t> closure_parser_t;
      return closure_parser_t(ptr, rule_base()).parse(first, last);
   }


// rule specific functions
    template <typename ParserT>
    attr_rule& operator=(ParserT const& parser)
   {
      *static_cast<rule_t *>(this) = parser;
      return *this;
   }
    attr_rule& operator=(attr_rule const& other);
    attr_rule& operator=(rule_t const& other);

// closure specifics
    template <int N>
    reference_wrapper<local<tuple_t, N> >
    operator()(closure_member<N> cm)
        { return closure_t::operator()(cm); }

// generate different types of action parsers
    template <typename T>
    impl::IF<is_reference_wrapper<T>::value,
              closure_parser_action<this_t, 
	      reference_wrapper<typename T::value_type> >,
              action<rule_t ,T>  
             >::RET // one argument actors
    operator[](T const& actor) const              
    {
      typedef typename impl::IF<(is_reference_wrapper<T>::value),
               impl::selector1,
               impl::selector2>::RET dispatcher;
      return action_helper(actor, dispatcher()); 	        
    }   

// direct access of rule base member
    rule_t const &rule_base() const 
        { return *static_cast<rule_t const *>(this); }

// support for parser initialization
    param_parser_gen<tuple_t, rule_t> init;

private :
    template <typename ActionT>
    action<rule_t, ActionT>
    action_helper(ActionT const& actor, impl::selector2 ) const   // two argument actors
    { return rule_t::operator[](actor); }

    template <typename T>
    closure_parser_action<this_t, reference_wrapper<T> > // one argument actors
    action_helper(reference_wrapper<T> const& wrap, impl::selector1) const
    {
        typedef
            closure_parser_action<this_t, reference_wrapper<T> >
            actor_t;
        return actor_t(*this, wrap);
    }
      
};

///////////////////////////////////////////////////////////////////////////////

}   //  namespace Spirit

// include corresponding implementation header
// Can't do this because of dependencies on closure.ipp - DN
//#include "boost/spirit/impl/attr_rule.ipp"

#endif