utilities.ipp

来自「著名的Parser库Spirit在VC6上的Port」· IPP 代码 · 共 1,305 行 · 第 1/4 页

            typename IteratorT, typename MatchTraitsT,
            typename ItemT, typename DelimT, typename EndT
        >
        static typename MatchTraitsT::match_t
        ast_parse(IteratorT& first, IteratorT const& last, 
                MatchTraitsT const& mt, ItemT const &item, DelimT const &delim,
                EndT const &end)
        {
            return (
                    *(item - (delim | end))
                >>  *(delim >> *(item - (delim | end)))
                >>  !end
            ).ast_parse(first, last, mt);
        }
    };

///////////////////////////////////////////////////////////////////////////////
// action_parser_category types as ItemT require some special handling
    template <>
    struct list_parser_type<action_parser_category> 
    {
    // match list with 'normal' syntax
        template <typename IteratorT, typename ItemT, typename DelimT>
        static match
        parse(IteratorT& first, IteratorT const& last, 
            ItemT const &item, DelimT const &delim)
        {
            return (
                    *(item.subject() - delim)[item.predicate()]
                >>  *(delim >> *(item.subject() - delim)[item.predicate()])
            ).parse(first, last);
        }

        template <typename IteratorT, typename MatchTraitsT, typename ItemT, 
                    typename DelimT>
        static typename MatchTraitsT::match_t
        ast_parse(IteratorT& first, IteratorT const& last, 
                MatchTraitsT const& mt, ItemT const &item, DelimT const &delim)
        {
            return (
                    *(item.subject() - delim)[item.predicate()]
                >>  *(delim >> *(item.subject() - delim)[item.predicate()])
            ).ast_parse(first, last, mt);
        }

    // match list with 'extended' syntax
        template <
            typename IteratorT, 
            typename ItemT, typename DelimT, typename EndT
        >
        static match
        parse(IteratorT& first, IteratorT const& last, 
            ItemT const &item, DelimT const &delim, EndT const &end)
        {
            return (
                    *(item.subject() - (delim | end))[item.predicate()]
                >>  *(delim >> *(item.subject() - (delim | end))[
                        item.predicate()])
                >>  !end
            ).parse(first, last);
        }

        template <
            typename IteratorT, typename MatchTraitsT, 
            typename ItemT, typename DelimT, typename EndT
        >
        static typename MatchTraitsT::match_t
        ast_parse(IteratorT& first, IteratorT const& last, 
                MatchTraitsT const& mt, ItemT const &item, DelimT const &delim,
                EndT const &end)
        {
            return (
                    *(item.subject() - (delim | end))[item.predicate()]
                >>  *(delim >> *(item.subject() - (delim | end))[
                        item.predicate()])
                >>  !end
            ).ast_parse(first, last, mt);
        }
    };

}   // end of namespace impl

template <
    typename ItemT, typename DelimT, 
    typename StringT, typename CategoryT
>
inline list_parser<ItemT, DelimT, StringT, CategoryT>
    ::list_parser(ItemT const &item_, DelimT const &delim_) :
    item(item_), delim(delim_)
{
}

template <
    typename ItemT, typename DelimT, 
    typename StringT, typename CategoryT
>
template <typename IteratorT>
inline match
list_parser<ItemT, DelimT, StringT, CategoryT>
    ::parse(IteratorT& first, IteratorT const& last) const
{
    return impl::list_parser_type<CategoryT>
            ::parse(first, last, item, delim);
}

template <
    typename ItemT, typename DelimT, 
    typename StringT, typename CategoryT
>
template <typename IteratorT, typename MatchTraitsT>
inline typename MatchTraitsT::match_t
list_parser<ItemT, DelimT, StringT, CategoryT>
    ::ast_parse(IteratorT& first, IteratorT const& last, 
            MatchTraitsT const& mt) const
{
    return impl::list_parser_type<CategoryT>
            ::ast_parse(first, last, mt, item, delim);
}

///////////////////////////////////////////////////////////////////////////////
// 
//  list_parser_ex class
//
///////////////////////////////////////////////////////////////////////////////
template <
    typename ItemT, typename DelimT, typename EndT, 
    typename StringT, typename CategoryT
>
inline list_parser_ex<ItemT, DelimT, EndT, StringT, CategoryT>
    ::list_parser_ex(ItemT const &item_, DelimT const &delim_, 
            EndT const &end_) :
    item(item_), delim(delim_), end(end_)
{
}

template <
    typename ItemT, typename DelimT, typename EndT, 
    typename StringT, typename CategoryT
>
template <typename IteratorT>
inline match
list_parser_ex<ItemT, DelimT, EndT, StringT, CategoryT>
    ::parse(IteratorT& first, IteratorT const& last) const
{
    return impl::list_parser_type<CategoryT>
            ::parse(first, last, item, delim, end);
}

template <
    typename ItemT, typename DelimT, typename EndT, 
    typename StringT, typename CategoryT
>
template <typename IteratorT, typename MatchTraitsT>
inline typename MatchTraitsT::match_t
list_parser_ex<ItemT, DelimT, EndT, StringT, CategoryT>
    ::ast_parse(IteratorT& first, IteratorT const& last, 
            MatchTraitsT const& mt) const
{
    return impl::list_parser_type<CategoryT>
            ::ast_parse(first, last, mt, item, delim, end);
}

///////////////////////////////////////////////////////////////////////////////
//
//  Generic generator function for creation of concrete list parsers for
//  'normal' list syntax: 
//
//      item >> *(delim >> item)
//
//  If item isn't given, everything between two delimiters is matched.
//
///////////////////////////////////////////////////////////////////////////////
template <typename StringT>
template <typename DelimT>
inline list_parser<
    anychar_,
    typename impl::parser_type<DelimT>::parser_t,
    StringT,
    plain_parser_category          // anychar is a plain_parser type
>
list_parser_gen<StringT>::operator()(DelimT const &delim_) const
{
    typedef typename impl::parser_type<DelimT>::parser_t delim_t;

    typedef 
        list_parser<anychar_, delim_t, StringT, plain_parser_category> 
        return_t;

    return return_t(
        anychar,
        impl::parser_type<DelimT>::get(delim_)
    );
}

template <typename StringT>
template <typename ItemT, typename DelimT>
inline list_parser<
    typename impl::parser_type<ItemT>::parser_t,
    typename impl::parser_type<DelimT>::parser_t,
    StringT
>
list_parser_gen<StringT>::operator()(ItemT const &item_, 
        DelimT const &delim_) const
{
    typedef typename impl::parser_type<ItemT>::parser_t item_t;
    typedef typename impl::parser_type<DelimT>::parser_t delim_t;

    typedef list_parser<item_t, delim_t, StringT> return_t;

    return return_t(
        impl::parser_type<ItemT>::get(item_),
        impl::parser_type<DelimT>::get(delim_)
    );
}

///////////////////////////////////////////////////////////////////////////////
//
//  Generic generator function for creation of concrete list parsers for
//  'extended' list syntax: 
//
//      item >> *(delim >> item) >> !end
//
///////////////////////////////////////////////////////////////////////////////
template <typename StringT>
template<typename ItemT, typename DelimT, typename EndT>
inline list_parser_ex<
    typename impl::parser_type<ItemT>::parser_t,
    typename impl::parser_type<DelimT>::parser_t,
    typename impl::parser_type<EndT>::parser_t,
    StringT
>
list_parser_gen<StringT>::operator()(
    ItemT const &item_, DelimT const &delim_, EndT const &end_) const
{
    typedef typename impl::parser_type<ItemT>::parser_t item_t;
    typedef typename impl::parser_type<DelimT>::parser_t delim_t;
    typedef typename impl::parser_type<EndT>::parser_t end_t;

    typedef list_parser_ex<item_t, delim_t, end_t, StringT> return_t;

    return return_t(
        impl::parser_type<ItemT>::get(item_),
        impl::parser_type<DelimT>::get(delim_),
        impl::parser_type<EndT>::get(end_)
    );
}

///////////////////////////////////////////////////////////////////////////////
//
//  Generic generator function for creation of concrete list parsers for
//  'normal' list syntax: 
//
//      item >> *(delim >> item)
//
//  If item isn't given, everything between two delimiters is matched.
//
//  The following function should be used, if the 'item' parser has an attached 
//  semantic action and this action should _not_ be re-attached during parser 
//  construction (see comment in utilities.hpp).
//
///////////////////////////////////////////////////////////////////////////////
template <typename StringT>
template <typename ItemT, typename DelimT>
inline list_parser<
    typename impl::parser_type<ItemT>::parser_t,
    typename impl::parser_type<DelimT>::parser_t,
    StringT,
    plain_parser_category        // inhibit action re-attachment
>
list_parser_gen<StringT>::direct(ItemT const &item_, DelimT const &delim_) const
{
    typedef typename impl::parser_type<ItemT>::parser_t item_t;
    typedef typename impl::parser_type<DelimT>::parser_t delim_t;

    typedef 
        list_parser<item_t, delim_t, StringT, plain_parser_category> 
        return_t;

    return return_t(
        impl::parser_type<ItemT>::get(item_),
        impl::parser_type<DelimT>::get(delim_)
    );
}

///////////////////////////////////////////////////////////////////////////////
//
//  Generic generator function for creation of concrete list parsers for
//  'extended' list syntax: 
//
//      item >> *(delim >> item) >> !end
//
///////////////////////////////////////////////////////////////////////////////
template <typename StringT>
template<typename ItemT, typename DelimT, typename EndT>
inline list_parser_ex<
    typename impl::parser_type<ItemT>::parser_t,
    typename impl::parser_type<DelimT>::parser_t,
    typename impl::parser_type<EndT>::parser_t,
    StringT,
    plain_parser_category        // inhibit action re-attachment
>
list_parser_gen<StringT>::direct(
    ItemT const &item_, DelimT const &delim_, EndT const &end_) const
{
    typedef typename impl::parser_type<ItemT>::parser_t item_t;
    typedef typename impl::parser_type<DelimT>::parser_t delim_t;
    typedef typename impl::parser_type<EndT>::parser_t end_t;

    typedef 
        list_parser_ex<item_t, delim_t, end_t, StringT, plain_parser_category> 
        return_t;

    return return_t(
        impl::parser_type<ItemT>::get(item_),
        impl::parser_type<DelimT>::get(delim_),
        impl::parser_type<EndT>::get(end_)
    );
}

} // namespace spirit

#endif