| /*============================================================================= |
| Copyright (c) 1998-2003 Joel de Guzman |
| Copyright (c) 2003 Martin Wille |
| http://spirit.sourceforge.net/ |
| |
| Use, modification and distribution is subject to the Boost Software |
| License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at |
| http://www.boost.org/LICENSE_1_0.txt) |
| =============================================================================*/ |
| #if !defined(BOOST_SPIRIT_PRIMITIVES_IPP) |
| #define BOOST_SPIRIT_PRIMITIVES_IPP |
| |
| // This should eventually go to a config file. |
| #if defined(__GNUC__) && (__GNUC__ < 3) && !defined(_STLPORT_VERSION) |
| # ifndef BOOST_SPIRIT_NO_CHAR_TRAITS |
| # define BOOST_SPIRIT_NO_CHAR_TRAITS |
| # endif |
| #endif |
| |
| #include <cctype> |
| #if !defined(BOOST_NO_CWCTYPE) |
| #include <cwctype> |
| #endif |
| |
| #ifndef BOOST_SPIRIT_NO_CHAR_TRAITS |
| # include <string> // char_traits |
| #endif |
| |
| #if defined(BOOST_MSVC) |
| # pragma warning (push) |
| # pragma warning(disable:4800) |
| #endif |
| |
| namespace boost { namespace spirit { |
| |
| BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN |
| |
| template <typename DrivedT> struct char_parser; |
| |
| namespace impl |
| { |
| template <typename IteratorT> |
| inline IteratorT |
| get_last(IteratorT first) |
| { |
| while (*first) |
| first++; |
| return first; |
| } |
| |
| template< |
| typename RT, |
| typename IteratorT, |
| typename ScannerT> |
| inline RT |
| string_parser_parse( |
| IteratorT str_first, |
| IteratorT str_last, |
| ScannerT& scan) |
| { |
| typedef typename ScannerT::iterator_t iterator_t; |
| iterator_t saved = scan.first; |
| std::size_t slen = str_last - str_first; |
| |
| while (str_first != str_last) |
| { |
| if (scan.at_end() || (*str_first != *scan)) |
| return scan.no_match(); |
| ++str_first; |
| ++scan; |
| } |
| |
| return scan.create_match(slen, nil_t(), saved, scan.first); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // |
| // Conversion from char_type to int_type |
| // |
| /////////////////////////////////////////////////////////////////////////// |
| |
| #ifndef BOOST_SPIRIT_NO_CHAR_TRAITS |
| # define BOOST_SPIRIT_CHAR_TRAITS_NAMESPACE std |
| #else |
| |
| template <typename CharT> |
| struct char_traits |
| { |
| typedef CharT int_type; |
| typedef CharT char_type; |
| }; |
| |
| template<> |
| struct char_traits<char> |
| { |
| typedef int int_type; |
| typedef char char_type; |
| |
| static char_type |
| to_char_type(int_type c) |
| { |
| return static_cast<char_type>(c); |
| } |
| |
| static int |
| to_int_type(char c) |
| { |
| return static_cast<unsigned char>(c); |
| } |
| }; |
| |
| template<> |
| struct char_traits<unsigned char> |
| { |
| typedef int int_type; |
| typedef unsigned char char_type; |
| |
| static char_type |
| to_char_type(int_type c) |
| { |
| return static_cast<char_type>(c); |
| } |
| |
| static int |
| to_int_type(unsigned char c) |
| { |
| return c; |
| } |
| }; |
| |
| # define BOOST_SPIRIT_CHAR_TRAITS_NAMESPACE impl |
| # ifndef BOOST_NO_CWCTYPE |
| |
| template<> |
| struct char_traits<wchar_t> |
| { |
| typedef wint_t int_type; |
| typedef wchar_t char_type; |
| |
| static char_type |
| to_char_type(int_type c) |
| { |
| return static_cast<char_type>(c); |
| } |
| |
| static wint_t |
| to_int_type(wchar_t c) |
| { |
| return c; |
| } |
| }; |
| |
| # endif |
| #endif // BOOST_SPIRIT_NO_CHAR_TRAITS |
| |
| // Use char_traits for char and wchar_t only, as these are the only |
| // specializations provided in the standard. Other types are on their |
| // own. |
| // |
| // For UDT, one may override: |
| // |
| // isalnum |
| // isalpha |
| // iscntrl |
| // isdigit |
| // isgraph |
| // islower |
| // isprint |
| // ispunct |
| // isspace |
| // isupper |
| // isxdigit |
| // isblank |
| // isupper |
| // tolower |
| // toupper |
| // |
| // in a namespace suitable for Argument Dependent lookup or in |
| // namespace std (disallowed by the standard). |
| |
| template <typename CharT> |
| struct char_type_char_traits_helper |
| { |
| typedef CharT char_type; |
| typedef typename BOOST_SPIRIT_CHAR_TRAITS_NAMESPACE |
| ::char_traits<CharT>::int_type int_type; |
| |
| static int_type to_int_type(CharT c) |
| { |
| return BOOST_SPIRIT_CHAR_TRAITS_NAMESPACE |
| ::char_traits<CharT>::to_int_type(c); |
| } |
| |
| static char_type to_char_type(int_type i) |
| { |
| return BOOST_SPIRIT_CHAR_TRAITS_NAMESPACE |
| ::char_traits<CharT>::to_char_type(i); |
| } |
| }; |
| |
| template <typename CharT> |
| struct char_traits_helper |
| { |
| typedef CharT char_type; |
| typedef CharT int_type; |
| |
| static CharT & to_int_type(CharT & c) |
| { |
| return c; |
| } |
| |
| static CharT & to_char_type(CharT & c) |
| { |
| return c; |
| } |
| }; |
| |
| template <> |
| struct char_traits_helper<char> |
| : char_type_char_traits_helper<char> |
| { |
| }; |
| |
| #if !defined(BOOST_NO_CWCTYPE) |
| |
| template <> |
| struct char_traits_helper<wchar_t> |
| : char_type_char_traits_helper<wchar_t> |
| { |
| }; |
| |
| #endif |
| |
| template <typename CharT> |
| inline typename char_traits_helper<CharT>::int_type |
| to_int_type(CharT c) |
| { |
| return char_traits_helper<CharT>::to_int_type(c); |
| } |
| |
| template <typename CharT> |
| inline CharT |
| to_char_type(typename char_traits_helper<CharT>::int_type c) |
| { |
| return char_traits_helper<CharT>::to_char_type(c); |
| } |
| |
| /////////////////////////////////////////////////////////////////////// |
| // |
| // Convenience functions |
| // |
| /////////////////////////////////////////////////////////////////////// |
| |
| template <typename CharT> |
| inline bool |
| isalnum_(CharT c) |
| { |
| using namespace std; |
| return isalnum(to_int_type(c)) ? true : false; |
| } |
| |
| template <typename CharT> |
| inline bool |
| isalpha_(CharT c) |
| { |
| using namespace std; |
| return isalpha(to_int_type(c)) ? true : false; |
| } |
| |
| template <typename CharT> |
| inline bool |
| iscntrl_(CharT c) |
| { |
| using namespace std; |
| return iscntrl(to_int_type(c)) ? true : false; |
| } |
| |
| template <typename CharT> |
| inline bool |
| isdigit_(CharT c) |
| { |
| using namespace std; |
| return isdigit(to_int_type(c)) ? true : false; |
| } |
| |
| template <typename CharT> |
| inline bool |
| isgraph_(CharT c) |
| { |
| using namespace std; |
| return isgraph(to_int_type(c)) ? true : false; |
| } |
| |
| template <typename CharT> |
| inline bool |
| islower_(CharT c) |
| { |
| using namespace std; |
| return islower(to_int_type(c)) ? true : false; |
| } |
| |
| template <typename CharT> |
| inline bool |
| isprint_(CharT c) |
| { |
| using namespace std; |
| return isprint(to_int_type(c)) ? true : false; |
| } |
| |
| template <typename CharT> |
| inline bool |
| ispunct_(CharT c) |
| { |
| using namespace std; |
| return ispunct(to_int_type(c)) ? true : false; |
| } |
| |
| template <typename CharT> |
| inline bool |
| isspace_(CharT c) |
| { |
| using namespace std; |
| return isspace(to_int_type(c)) ? true : false; |
| } |
| |
| template <typename CharT> |
| inline bool |
| isupper_(CharT c) |
| { |
| using namespace std; |
| return isupper(to_int_type(c)) ? true : false; |
| } |
| |
| template <typename CharT> |
| inline bool |
| isxdigit_(CharT c) |
| { |
| using namespace std; |
| return isxdigit(to_int_type(c)) ? true : false; |
| } |
| |
| template <typename CharT> |
| inline bool |
| isblank_(CharT c) |
| { |
| return (c == ' ' || c == '\t'); |
| } |
| |
| template <typename CharT> |
| inline CharT |
| tolower_(CharT c) |
| { |
| using namespace std; |
| return to_char_type<CharT>(tolower(to_int_type(c))); |
| } |
| |
| template <typename CharT> |
| inline CharT |
| toupper_(CharT c) |
| { |
| using namespace std; |
| return to_char_type<CharT>(toupper(to_int_type(c))); |
| } |
| |
| #if !defined(BOOST_NO_CWCTYPE) |
| |
| inline bool |
| isalnum_(wchar_t c) |
| { |
| using namespace std; |
| return iswalnum(to_int_type(c)) ? true : false; |
| } |
| |
| inline bool |
| isalpha_(wchar_t c) |
| { |
| using namespace std; |
| return iswalpha(to_int_type(c)) ? true : false; |
| } |
| |
| inline bool |
| iscntrl_(wchar_t c) |
| { |
| using namespace std; |
| return iswcntrl(to_int_type(c)) ? true : false; |
| } |
| |
| inline bool |
| isdigit_(wchar_t c) |
| { |
| using namespace std; |
| return iswdigit(to_int_type(c)) ? true : false; |
| } |
| |
| inline bool |
| isgraph_(wchar_t c) |
| { |
| using namespace std; |
| return iswgraph(to_int_type(c)) ? true : false; |
| } |
| |
| inline bool |
| islower_(wchar_t c) |
| { |
| using namespace std; |
| return iswlower(to_int_type(c)) ? true : false; |
| } |
| |
| inline bool |
| isprint_(wchar_t c) |
| { |
| using namespace std; |
| return iswprint(to_int_type(c)) ? true : false; |
| } |
| |
| inline bool |
| ispunct_(wchar_t c) |
| { |
| using namespace std; |
| return iswpunct(to_int_type(c)) ? true : false; |
| } |
| |
| inline bool |
| isspace_(wchar_t c) |
| { |
| using namespace std; |
| return iswspace(to_int_type(c)) ? true : false; |
| } |
| |
| inline bool |
| isupper_(wchar_t c) |
| { |
| using namespace std; |
| return iswupper(to_int_type(c)) ? true : false; |
| } |
| |
| inline bool |
| isxdigit_(wchar_t c) |
| { |
| using namespace std; |
| return iswxdigit(to_int_type(c)) ? true : false; |
| } |
| |
| inline bool |
| isblank_(wchar_t c) |
| { |
| return (c == L' ' || c == L'\t'); |
| } |
| |
| inline wchar_t |
| tolower_(wchar_t c) |
| { |
| using namespace std; |
| return to_char_type<wchar_t>(towlower(to_int_type(c))); |
| } |
| |
| inline wchar_t |
| toupper_(wchar_t c) |
| { |
| using namespace std; |
| return to_char_type<wchar_t>(towupper(to_int_type(c))); |
| } |
| |
| #endif // !defined(BOOST_NO_CWCTYPE) |
| |
| } |
| |
| BOOST_SPIRIT_CLASSIC_NAMESPACE_END |
| |
| }} // namespace boost::spirit::impl |
| |
| #ifdef BOOST_MSVC |
| #pragma warning (pop) |
| #endif |
| |
| #endif |