stlab.adobe.com Adobe Systems Incorporated

lex_shared_fwd.hpp

Go to the documentation of this file.
00001 /*
00002     Copyright 2005-2007 Adobe Systems Incorporated
00003     Distributed under the MIT License (see accompanying file LICENSE_1_0_0.txt
00004     or a copy at http://stlab.adobe.com/licenses.html)
00005 */
00006 
00007 /*************************************************************************************************/
00008 
00009 #ifndef ADOBE_LEX_SHARED_FWD_HPP
00010 #define ADOBE_LEX_SHARED_FWD_HPP
00011 
00012 /*************************************************************************************************/
00013 
00014 #include <adobe/config.hpp>
00015 
00016 #include <functional>
00017 #include <iterator>
00018 #include <iterator>
00019 #include <utility>
00020 
00021 #include <boost/operators.hpp>
00022 #include <boost/static_assert.hpp>
00023 
00024 #include <adobe/algorithm/copy.hpp>
00025 #include <adobe/algorithm/lower_bound.hpp>
00026 #include <adobe/algorithm/mismatch.hpp>
00027 #include <adobe/algorithm/sort.hpp>
00028 #include <adobe/name.hpp>
00029 #include <adobe/any_regular.hpp>
00030 #include <adobe/utility.hpp>
00031 
00032 #ifndef NDEBUG
00033     #include <iostream>
00034 #endif
00035 
00036 /*************************************************************************************************/
00037 
00038 namespace adobe {
00039 
00040 /*************************************************************************************************/
00041 
00042 typedef const unsigned char* uchar_ptr_t;
00043 
00044 /*************************************************************************************************/
00045 
00063 template <  typename I1, // models InputIterator
00064             typename I2, // models InputIterator
00065             typename BP> // models BinaryPredicate
00066 inline bool bounded_equal(I1 first1, I1 last1, I2 first2, I2 last2, BP pred)
00067 {
00068     for (; first1 != last1 && first2 != last2; ++first1, ++first2)
00069         if (!pred(*first1, *first2)) return false;
00070 
00071     return first1 == last1 && first2 == last2;
00072 }
00073 
00074 /*************************************************************************************************/
00075 
00092 template <  typename I1, // models InputIterator
00093             typename I2> // models InputIterator
00094 inline bool bounded_equal(I1 first1, I1 last1, I2 first2, I2 last2)
00095 {
00096     typedef typename std::iterator_traits<I1>::value_type value_type;
00097 
00098     return bounded_equal(first1, last1, first2, last2, std::equal_to<value_type>());
00099 }
00100 
00101 /*************************************************************************************************/
00102 
00117 template <  typename R1, // models InputRange
00118             typename R2> // models InputRange
00119 inline bool bounded_equal(R1& range1, R2& range2)
00120 {
00121     return bounded_equal(   boost::begin(range1), boost::end(range1),
00122                             boost::begin(range2), boost::end(range2));
00123 }
00124 
00125 /*************************************************************************************************/
00126 
00145 typedef std::pair<uchar_ptr_t, uchar_ptr_t> token_range_t;
00146 
00147 /*************************************************************************************************/
00148 
00164 inline bool token_range_equal(const token_range_t& x, const token_range_t& y)
00165 {
00166     return boost::size(x) == boost::size(y) && adobe::bounded_equal(x, y);
00167 }
00168 
00169 /*************************************************************************************************/
00170 
00194 inline bool token_range_less(const token_range_t& x, const token_range_t& y)
00195 {
00196     std::size_t sizex(boost::size(x));
00197     std::size_t sizey(boost::size(y));
00198 
00199     if (sizex < sizey) return true;
00200     else if (sizey < sizex) return false;
00201 
00202     std::pair<uchar_ptr_t, uchar_ptr_t> diff(adobe::mismatch(x, boost::begin(y)));
00203 
00204     if (diff.first == boost::end(x)) return false;
00205 
00206     return *diff.first < *diff.second;
00207 }
00208 
00209 /*************************************************************************************************/
00210 
00211 #ifndef NDEBUG
00212 
00223 inline std::ostream& operator << (std::ostream& s, const token_range_t& x)
00224 {
00225     adobe::copy(x, std::ostream_iterator<char>(s));
00226 
00227     return s;
00228 }
00229 #endif
00230 
00231 /*************************************************************************************************/
00232 
00244 template <typename T>
00245 inline token_range_t static_token_range(T* begin)
00246 {
00247     BOOST_STATIC_ASSERT(sizeof(T) == sizeof(unsigned char));
00248 
00249     T* end(begin);
00250 
00251     while (*end != 0)
00252         ++end;
00253 
00254     return token_range_t(reinterpret_cast<uchar_ptr_t>(begin), reinterpret_cast<uchar_ptr_t>(end));
00255 }
00256 
00257 /*************************************************************************************************/
00258 
00259 template <typename E> // E models Enumeration
00260 struct lex_token_t
00261 {
00262     lex_token_t()
00263     { }
00264 
00265     explicit lex_token_t(E enumeration, uchar_ptr_t first = 0, uchar_ptr_t last = 0) :
00266         enum_m(enumeration), range_m(first, last)
00267     { }
00268 
00269     E               enum_m;
00270     token_range_t   range_m;
00271 };
00272 
00273 /*************************************************************************************************/
00274 
00275 typedef pair<name_t, any_regular_t> stream_lex_token_t;
00276 
00277 /*************************************************************************************************/
00278 
00279 extern aggregate_name_t eof_k; // EOF token name
00280 
00281 /*************************************************************************************************/
00282 
00283 template <typename E> inline E eof_token(); // specialize
00284 
00285 /*************************************************************************************************/
00286 
00287 } // namespace adobe
00288 
00289 /*************************************************************************************************/
00290 
00291 #endif
00292 
00293 /*************************************************************************************************/

Copyright © 2006-2007 Adobe Systems Incorporated.

Use of this website signifies your agreement to the Terms of Use and Online Privacy Policy.

Search powered by Google