attr_rule.ipp

著名的Parser库Spirit在VC6上的Port

    TupleT, ParserT, 
    typename boost::tuples::detail::make_tuple_mapper<T0, T1, T2, T3>::type
> 
param_parser_gen<TupleT, ParserT>
    ::operator()(T0 const &t0, T1 const &t1, T2 const &t2, T3 const &t3)
{
    typedef 
        typename boost::tuples::detail::make_tuple_mapper<T0, T1, T2, T3>::type 
        init_tuple_t;

    return param_parser<TupleT, ParserT, init_tuple_t>(
        boost::tuples::make_tuple(t0, t1, t2, t3), ptr, parser);
}

///////////////////////////////////////////////////////////////////////////////
template <typename TupleT, typename ParserT>
template <typename T0, typename T1, typename T2, typename T3, typename T4>
inline
param_parser<
    TupleT, ParserT, 
    typename boost::tuples::detail::make_tuple_mapper<
        T0, T1, T2, T3, T4>::type
> 
param_parser_gen<TupleT, ParserT>
    ::operator()(T0 const &t0, T1 const &t1, T2 const &t2, T3 const &t3,
        T4 const &t4)
{
    typedef 
        typename boost::tuples::detail::make_tuple_mapper<
            T0, T1, T2, T3, T4>::type 
        init_tuple_t;

    return param_parser<TupleT, ParserT, init_tuple_t>(
        boost::tuples::make_tuple(t0, t1, t2, t3, t4), ptr, parser);
}

///////////////////////////////////////////////////////////////////////////////
template <typename TupleT, typename ParserT>
template <
    typename T0, typename T1, typename T2, typename T3, typename T4,
    typename T5
>
inline
param_parser<
    TupleT, ParserT, 
    typename boost::tuples::detail::make_tuple_mapper<
        T0, T1, T2, T3, T4, T5>::type
> 
param_parser_gen<TupleT, ParserT>
    ::operator()(T0 const &t0, T1 const &t1, T2 const &t2, T3 const &t3,
        T4 const &t4, T5 const &t5)
{
    typedef 
        typename boost::tuples::detail::make_tuple_mapper<
            T0, T1, T2, T3, T4, T5>::type 
        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 TupleT, typename ParserT>
template <
    typename T0, typename T1, typename T2, typename T3, typename T4,
    typename T5, typename T6
>
inline
param_parser<
    TupleT, ParserT, 
    typename boost::tuples::detail::make_tuple_mapper<
        T0, T1, T2, T3, T4, T5, T6>::type
> 
param_parser_gen<TupleT, ParserT>
    ::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::detail::make_tuple_mapper<
            T0, T1, T2, T3, T4, T5, T6>::type 
        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 TupleT, typename ParserT>
template <
    typename T0, typename T1, typename T2, typename T3, typename T4,
    typename T5, typename T6, typename T7
>
inline
param_parser<
    TupleT, ParserT, 
    typename boost::tuples::detail::make_tuple_mapper<
        T0, T1, T2, T3, T4, T5, T6, T7>::type
> 
param_parser_gen<TupleT, ParserT>
    ::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::detail::make_tuple_mapper<
            T0, T1, T2, T3, T4, T5, T6, T7>::type 
        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 TupleT, typename ParserT>
template <
    typename T0, typename T1, typename T2, typename T3, typename T4,
    typename T5, typename T6, typename T7, typename T8
>
inline
param_parser<
    TupleT, ParserT, 
    typename boost::tuples::detail::make_tuple_mapper<
        T0, T1, T2, T3, T4, T5, T6, T7, T8>::type
> 
param_parser_gen<TupleT, ParserT>
    ::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::detail::make_tuple_mapper<
            T0, T1, T2, T3, T4, T5, T6, T7, T8>::type 
        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 TupleT, typename ParserT>
template <
    typename T0, typename T1, typename T2, typename T3, typename T4,
    typename T5, typename T6, typename T7, typename T8, typename T9
>
inline
param_parser<
    TupleT, ParserT, 
    typename boost::tuples::detail::make_tuple_mapper<
        T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
> 
param_parser_gen<TupleT, ParserT>
    ::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::detail::make_tuple_mapper<
            T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type 
        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);
}

///////////////////////////////////////////////////////////////////////////////
// 
//  attr_rule class implementation
//
///////////////////////////////////////////////////////////////////////////////

template <typename ClosureT, typename IteratorT, typename MatchTraitsT>
inline attr_rule<ClosureT, IteratorT, MatchTraitsT>::attr_rule() :
    init(ptr, rule_base())
{
}

template <typename ClosureT, typename IteratorT, typename MatchTraitsT>
inline attr_rule<ClosureT, IteratorT, MatchTraitsT>
    ::attr_rule(attr_rule const& other) : 
        rule_t(static_cast<rule_t const &>(other)),
        init(ptr, rule_base())
{
}

template <typename ClosureT, typename IteratorT, typename MatchTraitsT>
inline attr_rule<ClosureT, IteratorT, MatchTraitsT>
    ::attr_rule(rule_t const& other) : 
        rule_t(other),
        init(ptr, rule_base())
{
}

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

template <typename ClosureT, typename IteratorT, typename MatchTraitsT>
inline attr_rule<ClosureT, IteratorT, MatchTraitsT>::~attr_rule()
{
}

// parsing functions
template <typename ClosureT, typename IteratorT, typename MatchTraitsT>
inline 
attr_match<
    typename element<0, typename ClosureT::base_closure_t::tuple_t>::type
>
attr_rule<ClosureT, IteratorT, MatchTraitsT>
    ::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);
}

template <typename ClosureT, typename IteratorT, typename MatchTraitsT>
inline attr_match<
    typename element<0, typename ClosureT::base_closure_t::tuple_t>::type, 
    typename MatchTraitsT::match_t
>
attr_rule<ClosureT, IteratorT, MatchTraitsT>
    ::ast_parse(IteratorT& first, IteratorT const& last, 
                MatchTraitsT const &mt) const
{
    typedef closure_parser<tuple_t, rule_t> closure_parser_t;
    return closure_parser_t(ptr, rule_base()).ast_parse(first, last, mt);
}

// rule specific functions
template <typename ClosureT, typename IteratorT, typename MatchTraitsT>
inline attr_rule<ClosureT, IteratorT, MatchTraitsT>&
attr_rule<ClosureT, IteratorT, MatchTraitsT>
    ::operator=(attr_rule const& other)
{
    if (this != &other)
        *static_cast<rule_t *>(this) = other;
    return *this;
}

template <typename ClosureT, typename IteratorT, typename MatchTraitsT>
inline attr_rule<ClosureT, IteratorT, MatchTraitsT>&
attr_rule<ClosureT, IteratorT, MatchTraitsT>
    ::operator=(rule_t const& other)
{
    *static_cast<rule_t *>(this) = other;
    return *this;
}

template <typename ClosureT, typename IteratorT, typename MatchTraitsT>
template <typename ParserT>
inline attr_rule<ClosureT, IteratorT, MatchTraitsT>&
attr_rule<ClosureT, IteratorT, MatchTraitsT>
    ::operator=(ParserT const& parser) 
{
    *static_cast<rule_t *>(this) = parser;
    return *this;
}

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

}   //  namespace Spirit

#endif