symbols.ipp

著名的Parser库Spirit在VC6上的Port

    IteratorT   save = first;
    search_info result = { 0, 0 };

    while (np)
    {
        if (ch < np->value)
        {
            if (np->value == 0)
                result.data = np->middle.data;
            np = np->left;
        }
        else
        {
            if (ch == np->value)
            {
                if (first == last)
                {
                    result.data = np->middle.data;
                    break;
                }
                ch = *(++first);
                np = np->middle.link;
                ++result.length;
            }
            else
            {
                if (np->value == 0)
                    result.data = np->middle.data;
                np = np->right;
            }
        }
    }

    if (result.data == 0)
        first = save;
    return result;
}

///////////////////////////////////////////////////////////////////////////////
//
//  symbol_match class implementation
//
///////////////////////////////////////////////////////////////////////////////
template <typename T>
inline symbol_match<T>::symbol_match()
:   match(),
    info(0)
{
}

//////////////////////////////////
template <typename T>
inline symbol_match<T>::symbol_match(unsigned length, T* info_)
:   match(length),
    info(info_)
{
}

//////////////////////////////////
template <typename T>
inline T*
symbol_match<T>::data() const
{
    return info;
}

///////////////////////////////////////////////////////////////////////////////
//
//  ast_symbol_match class implementation
//
///////////////////////////////////////////////////////////////////////////////
template <typename MatchTraitsT, typename T>
inline ast_symbol_match<MatchTraitsT, T>::ast_symbol_match()
:   MatchTraitsT::match_t(),
    info(0)
{
}

//////////////////////////////////
template <typename MatchTraitsT, typename T>
inline ast_symbol_match<MatchTraitsT, T>::ast_symbol_match(unsigned length, 
        T* info_)
:   MatchTraitsT::match_t(length),
    info(info_)
{
}

//////////////////////////////////
template <typename MatchTraitsT, typename T>
inline T*
ast_symbol_match<MatchTraitsT, T>::data() const
{
    return info;
}

///////////////////////////////////////////////////////////////////////////////
//
//  symbol_inserter class implementation
//
///////////////////////////////////////////////////////////////////////////////
template <typename T, typename SetT>
symbol_inserter<T, SetT>::symbol_inserter(SetT& set_)
:   set(set_)
{
}

//////////////////////////////////
template <typename T, typename SetT>
template <typename IteratorT>
inline T*
symbol_inserter<T, SetT>::operator()(
    IteratorT           first,
    IteratorT const&    last,
    T const&            data) const
{
    return set.add(first, last, data);
}

template <typename T, typename SetT>
template <typename CharT>
inline symbol_inserter<T, SetT> const&
symbol_inserter<T, SetT>::operator,(CharT const* str) const
{
    CharT const* last = str;
    while (*last)
        last++;
    set.add(str, last, T());
    return *this;
}

///////////////////////////////////////////////////////////////////////////////
//
//  symbol_action class implementation
//
///////////////////////////////////////////////////////////////////////////////
template <typename ParserT, typename ActionT>
inline symbol_action<ParserT, ActionT>::symbol_action(
    ParserT const&  parser,
    ActionT const&   actor_)
:   unary<ParserT>(parser),
    actor(actor_)
{
}

//////////////////////////////////
template <typename ParserT, typename ActionT>
template <typename IteratorT>
inline match
symbol_action<ParserT, ActionT>::parse(
    IteratorT&          first,
    IteratorT const&    last) const
{
    typedef impl::strip_scanner<IteratorT> strip_scanner;
    typename strip_scanner::iterator_type
        begin = strip_scanner::get(first);

    typename ParserT::symbol_match hit = this->subject().parse(first, last);

    if (hit)
        actor(begin, strip_scanner::get(first), *hit.data());

    return hit;
}

//////////////////////////////////
template <typename ParserT, typename ActionT>
template <typename IteratorT, typename MatchTraitsT>
inline typename MatchTraitsT::match_t
symbol_action<ParserT, ActionT>::ast_parse(
    IteratorT&          first,
    IteratorT const&    last, 
    MatchTraitsT const& mt) const
{
    typedef impl::strip_scanner<IteratorT> strip_scanner;
    typename strip_scanner::iterator_type
        begin = strip_scanner::get(first);

    ast_symbol_match<MatchTraitsT, typename ParserT::symbol_data_t> 
        hit = this->subject().ast_parse(first, last, mt);

    if (hit)
        actor(begin, strip_scanner::get(first), *hit.data());

    return hit;
}

///////////////////////////////////////////////////////////////////////////////
//
//  symbols class implementation
//
///////////////////////////////////////////////////////////////////////////////
template <typename T, typename CharT, typename SetT>
inline symbols<T, CharT, SetT>::symbols()
:   tst<T, CharT>(),
    add(*this)
{
}

//////////////////////////////////
template <typename T, typename CharT, typename SetT>
symbols<T, CharT, SetT>::symbols(symbols const& other)
:   tst<T, CharT>(other)
,   parser<symbols<T, CharT, SetT> >()
,   add(*this)
{
}

//////////////////////////////////
template <typename T, typename CharT, typename SetT>
inline symbols<T, CharT, SetT>::~symbols()
{
}

//////////////////////////////////
template <typename T, typename CharT, typename SetT>
inline symbols<T, CharT, SetT>&
symbols<T, CharT, SetT>::operator=(symbols const& other)
{
    tst<T, CharT>::operator=(other);
    return *this;
}

//////////////////////////////////
template <typename T, typename CharT, typename SetT>
inline symbol_inserter<T, SetT> const&
symbols<T, CharT, SetT>::operator=(CharT const* str)
{
    return add, str;
}

//////////////////////////////////
template <typename T, typename CharT, typename SetT>
template <typename IteratorT>
inline symbol_match<T>
symbols<T, CharT, SetT>::parse(
    IteratorT&          first,
    IteratorT const&    last) const
{
    typename SetT::search_info result = tst<T, CharT>::find(first, last);

    if (result.data)
        return symbol_match(result.length, result.data);
    else
        return symbol_match();
}

//////////////////////////////////
template <typename T, typename CharT, typename SetT>
template <typename IteratorT, typename MatchTraitsT>
inline ast_symbol_match<MatchTraitsT, T>
symbols<T, CharT, SetT>::ast_parse(
    IteratorT&          first,
    IteratorT const&    last, 
    MatchTraitsT const& mt) const
{
    typename SetT::search_info result = tst<T, CharT>::find(first, last);

    if (result.data)
        return ast_symbol_match<MatchTraitsT, T>(result.length, result.data);
    else
        return ast_symbol_match<MatchTraitsT, T>();
}

///////////////////////////////////////////////////////////////////////////////
//
//  Symbol table utilities
//
///////////////////////////////////////////////////////////////////////////////
template <typename T, typename CharT, typename SetT>
inline T*
find(symbols<T, CharT, SetT>& table, CharT const* sym)
{
    CharT const* last = sym;
    while (*last)
        last++;
    return table.parse(sym, last).info();
}

//////////////////////////////////
template <typename T, typename CharT, typename SetT>
inline T*
add(symbols<T, CharT, SetT>& table, CharT const* sym, T const& data)
{
    CharT const* last = sym;
    while (*last)
        last++;
    return table.add(sym, last, data);
}

///////////////////////////////////////////////////////////////////////////////
}   //  namespace Spirit

#endif