lex_shared_fwd.hpp

Go to the documentation of this file.

/*
    Copyright 2005-2007 Adobe Systems Incorporated
    Distributed under the MIT License (see accompanying file LICENSE_1_0_0.txt
    or a copy at http://stlab.adobe.com/licenses.html)
*/

/*************************************************************************************************/

#ifndef ADOBE_LEX_SHARED_FWD_HPP
#define ADOBE_LEX_SHARED_FWD_HPP

/*************************************************************************************************/

#include <adobe/config.hpp>

#include <functional>
#include <iterator>
#include <iterator>
#include <utility>

#include <boost/operators.hpp>
#include <boost/static_assert.hpp>

#include <adobe/algorithm/copy.hpp>
#include <adobe/algorithm/lower_bound.hpp>
#include <adobe/algorithm/mismatch.hpp>
#include <adobe/algorithm/sort.hpp>
#include <adobe/name.hpp>
#include <adobe/any_regular.hpp>
#include <adobe/utility.hpp>

#ifndef NDEBUG
    #include <iostream>
#endif

/*************************************************************************************************/

namespace adobe {

/*************************************************************************************************/

typedef const unsigned char* uchar_ptr_t;

/*************************************************************************************************/

template <  typename I1, // models InputIterator
            typename I2, // models InputIterator
            typename BP> // models BinaryPredicate
inline bool bounded_equal(I1 first1, I1 last1, I2 first2, I2 last2, BP pred)
{
    for (; first1 != last1 && first2 != last2; ++first1, ++first2)
        if (!pred(*first1, *first2)) return false;

    return first1 == last1 && first2 == last2;
}

/*************************************************************************************************/

template <  typename I1, // models InputIterator
            typename I2> // models InputIterator
inline bool bounded_equal(I1 first1, I1 last1, I2 first2, I2 last2)
{
    typedef typename std::iterator_traits<I1>::value_type value_type;

    return bounded_equal(first1, last1, first2, last2, std::equal_to<value_type>());
}

/*************************************************************************************************/

template <  typename R1, // models InputRange
            typename R2> // models InputRange
inline bool bounded_equal(R1& range1, R2& range2)
{
    return bounded_equal(   boost::begin(range1), boost::end(range1),
                            boost::begin(range2), boost::end(range2));
}

/*************************************************************************************************/

typedef std::pair<uchar_ptr_t, uchar_ptr_t> token_range_t;

/*************************************************************************************************/

inline bool token_range_equal(const token_range_t& x, const token_range_t& y)
{
    return boost::size(x) == boost::size(y) && adobe::bounded_equal(x, y);
}

/*************************************************************************************************/

inline bool token_range_less(const token_range_t& x, const token_range_t& y)
{
    std::size_t sizex(boost::size(x));
    std::size_t sizey(boost::size(y));

    if (sizex < sizey) return true;
    else if (sizey < sizex) return false;

    std::pair<uchar_ptr_t, uchar_ptr_t> diff(adobe::mismatch(x, boost::begin(y)));

    if (diff.first == boost::end(x)) return false;

    return *diff.first < *diff.second;
}

/*************************************************************************************************/

#ifndef NDEBUG

inline std::ostream& operator << (std::ostream& s, const token_range_t& x)
{
    adobe::copy(x, std::ostream_iterator<char>(s));

    return s;
}
#endif

/*************************************************************************************************/

template <typename T>
inline token_range_t static_token_range(T* begin)
{
    BOOST_STATIC_ASSERT(sizeof(T) == sizeof(unsigned char));

    T* end(begin);

    while (*end != 0)
        ++end;

    return token_range_t(reinterpret_cast<uchar_ptr_t>(begin), reinterpret_cast<uchar_ptr_t>(end));
}

/*************************************************************************************************/

template <typename E> // E models Enumeration
struct lex_token_t
{
    lex_token_t()
    { }

    explicit lex_token_t(E enumeration, uchar_ptr_t first = 0, uchar_ptr_t last = 0) :
        enum_m(enumeration), range_m(first, last)
    { }

    E               enum_m;
    token_range_t   range_m;
};

/*************************************************************************************************/

typedef pair<name_t, any_regular_t> stream_lex_token_t;

/*************************************************************************************************/

extern aggregate_name_t eof_k; // EOF token name

/*************************************************************************************************/

template <typename E> inline E eof_token(); // specialize

/*************************************************************************************************/

} // namespace adobe

/*************************************************************************************************/

#endif

/*************************************************************************************************/