Added boost header

test/external/boost/xpressive/traits/detail/c_ctype.hpp

@@ -0,0 +1,841 @@
+///////////////////////////////////////////////////////////////////////////////
+// c_ctype.hpp
+//
+//  Copyright 2008 Eric Niebler. Distributed under 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)
+
+#ifndef BOOST_XPRESSIVE_TRAITS_DETAIL_C_CTYPE_HPP_EAN_10_04_2005
+#define BOOST_XPRESSIVE_TRAITS_DETAIL_C_CTYPE_HPP_EAN_10_04_2005
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <cctype>
+#include <cstring>
+#include <boost/mpl/assert.hpp>
+#include <boost/xpressive/detail/detail_fwd.hpp>
+
+#ifndef BOOST_XPRESSIVE_NO_WREGEX
+# include <cwchar>
+# include <cwctype>
+#endif
+
+namespace boost { namespace xpressive { namespace detail
+{
+
+///////////////////////////////////////////////////////////////////////////////
+// isnewline
+//
+inline bool isnewline(char ch)
+{
+    switch(ch)
+    {
+    case L'\n': case L'\r': case L'\f':
+        return true;
+    default:
+        return false;
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// iswnewline
+//
+inline bool iswnewline(wchar_t ch)
+{
+    switch(ch)
+    {
+    case L'\n': case L'\r': case L'\f': case 0x2028u: case 0x2029u: case 0x85u:
+        return true;
+    default:
+        return false;
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// classname_a
+//
+template<typename FwdIter>
+inline std::string classname_a(FwdIter begin, FwdIter end)
+{
+    std::string name(begin, end);
+    for(std::size_t i = 0; i < name.size(); ++i)
+    {
+        using namespace std;
+        name[i] = static_cast<char>(tolower(static_cast<unsigned char>(name[i])));
+    }
+    return name;
+}
+
+#ifndef BOOST_XPRESSIVE_NO_WREGEX
+///////////////////////////////////////////////////////////////////////////////
+// classname_w
+//
+template<typename FwdIter>
+inline std::wstring classname_w(FwdIter begin, FwdIter end)
+{
+    std::wstring name(begin, end);
+    for(std::size_t i = 0; i < name.size(); ++i)
+    {
+        using namespace std;
+        name[i] = towlower(name[i]);
+    }
+    return name;
+}
+#endif
+
+
+
+///////////////////////////////////////////////////////////////////////////////
+// char_class_impl
+//
+template<typename Char>
+struct char_class_impl;
+
+
+#if defined(__QNXNTO__)
+
+///////////////////////////////////////////////////////////////////////////////
+//
+template<>
+struct char_class_impl<char>
+{
+    typedef short char_class_type;
+    BOOST_MPL_ASSERT_RELATION(0x07FF, ==, (_XB|_XA|_XS|_BB|_CN|_DI|_LO|_PU|_SP|_UP|_XD));
+    BOOST_STATIC_CONSTANT(short, char_class_underscore = 0x1000);
+    BOOST_STATIC_CONSTANT(short, char_class_newline = 0x2000);
+
+    template<typename FwdIter>
+    static char_class_type lookup_classname(FwdIter begin, FwdIter end, bool icase)
+    {
+        using namespace std;
+        string const name = classname_a(begin, end);
+        if(name == "alnum")     return _DI|_LO|_UP|_XA;
+        if(name == "alpha")     return _LO|_UP|_XA;
+        if(name == "blank")     return _SP|_XB;
+        if(name == "cntrl")     return _BB;
+        if(name == "d")         return _DI;
+        if(name == "digit")     return _DI;
+        if(name == "graph")     return _DI|_LO|_PU|_UP|_XA;
+        if(name == "lower")     return icase ? (_LO|_UP) : _LO;
+        if(name == "newline")   return char_class_newline;
+        if(name == "print")     return _DI|_LO|_PU|_SP|_UP|_XA;
+        if(name == "punct")     return _PU;
+        if(name == "s")         return _CN|_SP|_XS;
+        if(name == "space")     return _CN|_SP|_XS;
+        if(name == "upper")     return icase ? (_UP|_LO) : _UP;
+        if(name == "w")         return _DI|_LO|_UP|_XA|char_class_underscore;
+        if(name == "xdigit")    return _XD;
+        return 0;
+    }
+
+    static bool isctype(char ch, char_class_type mask)
+    {
+        using namespace std;
+        if(0 != (_Getchrtype((unsigned char)ch) & mask))
+        {
+            return true;
+        }
+
+        switch(ch)
+        {
+        case '_': return 0 != (mask & char_class_underscore);
+        case '\n': case '\r': case '\f': return 0 != (mask & char_class_newline);
+        default:;
+        }
+
+        return false;
+    }
+};
+
+#ifndef BOOST_XPRESSIVE_NO_WREGEX
+///////////////////////////////////////////////////////////////////////////////
+//
+template<>
+struct char_class_impl<wchar_t>
+{
+    typedef int char_class_type;
+    //BOOST_STATIC_CONSTANT(int, char_class_alnum         = 0x0001);
+    BOOST_STATIC_CONSTANT(int, char_class_alpha         = 0x0002);
+    BOOST_STATIC_CONSTANT(int, char_class_blank         = 0x0004);
+    BOOST_STATIC_CONSTANT(int, char_class_cntrl         = 0x0008);
+    BOOST_STATIC_CONSTANT(int, char_class_digit         = 0x0010);
+    //BOOST_STATIC_CONSTANT(int, char_class_graph         = 0x0020);
+    BOOST_STATIC_CONSTANT(int, char_class_lower         = 0x0040);
+    //BOOST_STATIC_CONSTANT(int, char_class_print         = 0x0080);
+    BOOST_STATIC_CONSTANT(int, char_class_punct         = 0x0100);
+    BOOST_STATIC_CONSTANT(int, char_class_space         = 0x0200);
+    BOOST_STATIC_CONSTANT(int, char_class_upper         = 0x0400);
+    BOOST_STATIC_CONSTANT(int, char_class_underscore    = 0x0800);
+    BOOST_STATIC_CONSTANT(int, char_class_xdigit        = 0x1000);
+    BOOST_STATIC_CONSTANT(int, char_class_newline       = 0x2000);
+
+    template<typename FwdIter>
+    static char_class_type lookup_classname(FwdIter begin, FwdIter end, bool icase)
+    {
+        using namespace std;
+        wstring const name = classname_w(begin, end);
+        if(name == L"alnum")    return char_class_alpha|char_class_digit;
+        if(name == L"alpha")    return char_class_alpha;
+        if(name == L"blank")    return char_class_blank;
+        if(name == L"cntrl")    return char_class_cntrl;
+        if(name == L"d")        return char_class_digit;
+        if(name == L"digit")    return char_class_digit;
+        if(name == L"graph")    return char_class_punct|char_class_alpha|char_class_digit;
+        if(name == L"lower")    return icase ? (char_class_lower|char_class_upper) : char_class_lower;
+        if(name == L"newline")  return char_class_newline;
+        if(name == L"print")    return char_class_blank|char_class_punct|char_class_alpha|char_class_digit;
+        if(name == L"punct")    return char_class_punct;
+        if(name == L"s")        return char_class_space;
+        if(name == L"space")    return char_class_space;
+        if(name == L"upper")    return icase ? (char_class_upper|char_class_lower) : char_class_upper;
+        if(name == L"w")        return char_class_alpha|char_class_digit|char_class_underscore;
+        if(name == L"xdigit")   return char_class_xdigit;
+        return 0;
+    }
+
+    static bool isctype(wchar_t ch, char_class_type mask)
+    {
+        using namespace std;
+        return ((char_class_alpha & mask) && iswalpha(ch))
+            || ((char_class_blank & mask) && (L' ' == ch || L'\t' == ch)) // BUGBUG
+            || ((char_class_cntrl & mask) && iswcntrl(ch))
+            || ((char_class_digit & mask) && iswdigit(ch))
+            || ((char_class_lower & mask) && iswlower(ch))
+            || ((char_class_newline & mask) && detail::iswnewline(ch))
+            || ((char_class_punct & mask) && iswpunct(ch))
+            || ((char_class_space & mask) && iswspace(ch))
+            || ((char_class_upper & mask) && iswupper(ch))
+            || ((char_class_underscore & mask) && L'_' == ch)
+            || ((char_class_xdigit & mask) && iswxdigit(ch))
+            ;
+    }
+};
+#endif
+
+
+#elif defined(__MINGW32_VERSION)
+
+
+///////////////////////////////////////////////////////////////////////////////
+//
+template<>
+struct char_class_impl<char>
+{
+    typedef int char_class_type;
+    BOOST_MPL_ASSERT_RELATION(0x81FF, ==, (_ALPHA|_UPPER|_LOWER|_DIGIT|_SPACE|_PUNCT|_CONTROL|_BLANK|_HEX|_LEADBYTE));
+    BOOST_STATIC_CONSTANT(int, char_class_underscore = 0x1000);
+    BOOST_STATIC_CONSTANT(int, char_class_newline = 0x2000);
+
+    template<typename FwdIter>
+    static char_class_type lookup_classname(FwdIter begin, FwdIter end, bool icase)
+    {
+        using namespace std;
+        string const name = classname_a(begin, end);
+        if(name == "alnum")     return _ALPHA|_DIGIT;
+        if(name == "alpha")     return _ALPHA;
+        if(name == "blank")     return _BLANK; // this is ONLY space!!!
+        if(name == "cntrl")     return _CONTROL;
+        if(name == "d")         return _DIGIT;
+        if(name == "digit")     return _DIGIT;
+        if(name == "graph")     return _PUNCT|_ALPHA|_DIGIT;
+        if(name == "lower")     return icase ? (_LOWER|_UPPER) : _LOWER;
+        if(name == "newline")   return char_class_newline;
+        if(name == "print")     return _BLANK|_PUNCT|_ALPHA|_DIGIT;
+        if(name == "punct")     return _PUNCT;
+        if(name == "s")         return _SPACE;
+        if(name == "space")     return _SPACE;
+        if(name == "upper")     return icase ? (_UPPER|_LOWER) : _UPPER;
+        if(name == "w")         return _ALPHA|_DIGIT|char_class_underscore;
+        if(name == "xdigit")    return _HEX;
+        return 0;
+    }
+
+    static bool isctype(char ch, char_class_type mask)
+    {
+        using namespace std;
+        if(0 != _isctype(static_cast<unsigned char>(ch), mask))
+        {
+            return true;
+        }
+
+        switch(ch)
+        {
+        case '\t': return 0 != (mask & _BLANK);
+        case '_': return 0 != (mask & char_class_underscore);
+        case '\n': case '\r': case '\f': return 0 != (mask & char_class_newline);
+        default:;
+        }
+
+        return false;
+    }
+};
+
+#ifndef BOOST_XPRESSIVE_NO_WREGEX
+///////////////////////////////////////////////////////////////////////////////
+//
+template<>
+struct char_class_impl<wchar_t>
+{
+    typedef wctype_t char_class_type;
+    BOOST_MPL_ASSERT_RELATION(0x81FF, ==, (_ALPHA|_UPPER|_LOWER|_DIGIT|_SPACE|_PUNCT|_CONTROL|_BLANK|_HEX|_LEADBYTE));
+    BOOST_STATIC_CONSTANT(int, char_class_underscore = 0x1000);
+    BOOST_STATIC_CONSTANT(int, char_class_newline = 0x2000);
+
+    template<typename FwdIter>
+    static char_class_type lookup_classname(FwdIter begin, FwdIter end, bool icase)
+    {
+        using namespace std;
+        wstring const name = classname_w(begin, end);
+        if(name == L"alnum")    return _ALPHA|_DIGIT;
+        if(name == L"alpha")    return _ALPHA;
+        if(name == L"blank")    return _BLANK; // this is ONLY space!!!
+        if(name == L"cntrl")    return _CONTROL;
+        if(name == L"d")        return _DIGIT;
+        if(name == L"digit")    return _DIGIT;
+        if(name == L"graph")    return _PUNCT|_ALPHA|_DIGIT;
+        if(name == L"lower")    return icase ? (_LOWER|_UPPER) : _LOWER;
+        if(name == L"newline")  return char_class_newline;
+        if(name == L"print")    return _BLANK|_PUNCT|_ALPHA|_DIGIT;
+        if(name == L"punct")    return _PUNCT;
+        if(name == L"s")        return _SPACE;
+        if(name == L"space")    return _SPACE;
+        if(name == L"upper")    return icase ? (_UPPER|_LOWER) : _UPPER;
+        if(name == L"w")        return _ALPHA|_DIGIT|char_class_underscore;
+        if(name == L"xdigit")   return _HEX;
+        return 0;
+    }
+
+    static bool isctype(wchar_t ch, char_class_type mask)
+    {
+        using namespace std;
+        if(0 != iswctype(ch, mask))
+        {
+            return true;
+        }
+
+        switch(ch)
+        {
+        case L'\t': return 0 != (mask & _BLANK);
+        case L'_': return 0 != (mask & char_class_underscore);
+        case L'\n': case L'\r': case L'\f': case 0x2028u: case 0x2029u: case 0x85u:
+            return 0 != (mask & char_class_newline);
+        default:;
+        }
+
+        return false;
+    }
+};
+#endif
+
+
+#elif defined(__CYGWIN__)
+
+
+
+///////////////////////////////////////////////////////////////////////////////
+//
+template<>
+struct char_class_impl<char>
+{
+    typedef int char_class_type;
+    BOOST_MPL_ASSERT_RELATION(0377, ==, (_U|_L|_N|_S|_P|_C|_B|_X));
+    BOOST_STATIC_CONSTANT(int, char_class_underscore = 0400);
+    BOOST_STATIC_CONSTANT(int, char_class_newline = 01000);
+
+    template<typename FwdIter>
+    static char_class_type lookup_classname(FwdIter begin, FwdIter end, bool icase)
+    {
+        using namespace std;
+        string const name = classname_a(begin, end);
+        if(name == "alnum")     return _U|_L|_N;
+        if(name == "alpha")     return _U|_L;
+        if(name == "blank")     return _B; // BUGBUG what is this?
+        if(name == "cntrl")     return _C;
+        if(name == "d")         return _N;
+        if(name == "digit")     return _N;
+        if(name == "graph")     return _P|_U|_L|_N;
+        if(name == "lower")     return icase ? (_L|_U) : _L;
+        if(name == "newline")   return char_class_newline;
+        if(name == "print")     return _B|_P|_U|_L|_N;
+        if(name == "punct")     return _P;
+        if(name == "s")         return _S;
+        if(name == "space")     return _S;
+        if(name == "upper")     return icase ? (_U|_L) : _U;
+        if(name == "w")         return _U|_L|_N|char_class_underscore;
+        if(name == "xdigit")    return _X;
+        return 0;
+    }
+
+    static bool isctype(char ch, char_class_type mask)
+    {
+        if(0 != static_cast<unsigned char>(((_ctype_+1)[(unsigned)(ch)]) & mask))
+        {
+            return true;
+        }
+
+        switch(ch)
+        {
+        case '_': return 0 != (mask & char_class_underscore);
+        case '\n': case '\r': case '\f': return 0 != (mask & char_class_newline);
+        default:;
+        }
+
+        return false;
+    }
+};
+
+#ifndef BOOST_XPRESSIVE_NO_WREGEX
+///////////////////////////////////////////////////////////////////////////////
+//
+template<>
+struct char_class_impl<wchar_t>
+{
+    typedef int char_class_type;
+    //BOOST_STATIC_CONSTANT(int, char_class_alnum         = 0x0001);
+    BOOST_STATIC_CONSTANT(int, char_class_alpha         = 0x0002);
+    BOOST_STATIC_CONSTANT(int, char_class_blank         = 0x0004);
+    BOOST_STATIC_CONSTANT(int, char_class_cntrl         = 0x0008);
+    BOOST_STATIC_CONSTANT(int, char_class_digit         = 0x0010);
+    //BOOST_STATIC_CONSTANT(int, char_class_graph         = 0x0020);
+    BOOST_STATIC_CONSTANT(int, char_class_lower         = 0x0040);
+    //BOOST_STATIC_CONSTANT(int, char_class_print         = 0x0080);
+    BOOST_STATIC_CONSTANT(int, char_class_punct         = 0x0100);
+    BOOST_STATIC_CONSTANT(int, char_class_space         = 0x0200);
+    BOOST_STATIC_CONSTANT(int, char_class_upper         = 0x0400);
+    BOOST_STATIC_CONSTANT(int, char_class_underscore    = 0x0800);
+    BOOST_STATIC_CONSTANT(int, char_class_xdigit        = 0x1000);
+    BOOST_STATIC_CONSTANT(int, char_class_newline       = 0x2000);
+
+    template<typename FwdIter>
+    static char_class_type lookup_classname(FwdIter begin, FwdIter end, bool icase)
+    {
+        using namespace std;
+        wstring const name = classname_w(begin, end);
+        if(name == L"alnum")    return char_class_alpha|char_class_digit;
+        if(name == L"alpha")    return char_class_alpha;
+        if(name == L"blank")    return char_class_blank;
+        if(name == L"cntrl")    return char_class_cntrl;
+        if(name == L"d")        return char_class_digit;
+        if(name == L"digit")    return char_class_digit;
+        if(name == L"graph")    return char_class_punct|char_class_alpha|char_class_digit;
+        if(name == L"lower")    return icase ? (char_class_lower|char_class_upper) : char_class_lower;
+        if(name == L"newline")  return char_class_newline;
+        if(name == L"print")    return char_class_blank|char_class_punct|char_class_alpha|char_class_digit;
+        if(name == L"punct")    return char_class_punct;
+        if(name == L"s")        return char_class_space;
+        if(name == L"space")    return char_class_space;
+        if(name == L"upper")    return icase ? (char_class_upper|char_class_lower) : char_class_upper;
+        if(name == L"w")        return char_class_alpha|char_class_digit|char_class_underscore;
+        if(name == L"xdigit")   return char_class_xdigit;
+        return 0;
+    }
+
+    static bool isctype(wchar_t ch, char_class_type mask)
+    {
+        using namespace std;
+        return ((char_class_alpha & mask) && iswalpha(ch))
+            || ((char_class_blank & mask) && (L' ' == ch || L'\t' == ch)) // BUGBUG
+            || ((char_class_cntrl & mask) && iswcntrl(ch))
+            || ((char_class_digit & mask) && iswdigit(ch))
+            || ((char_class_lower & mask) && iswlower(ch))
+            || ((char_class_newline & mask) && detail::iswnewline(ch))
+            || ((char_class_punct & mask) && iswpunct(ch))
+            || ((char_class_space & mask) && iswspace(ch))
+            || ((char_class_upper & mask) && iswupper(ch))
+            || ((char_class_underscore & mask) && L'_' == ch)
+            || ((char_class_xdigit & mask) && iswxdigit(ch))
+            ;
+    }
+};
+#endif
+
+
+
+#elif defined(__GLIBC__)
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////
+//
+template<>
+struct char_class_impl<char>
+{
+    typedef int char_class_type;
+    BOOST_MPL_ASSERT_RELATION(0xffff, ==, (_ISalnum|_ISalpha|_ISblank|_IScntrl|_ISdigit|_ISgraph|
+                                           _ISlower|_ISprint|_ISpunct|_ISspace|_ISupper|_ISxdigit|0xffff));
+    BOOST_STATIC_CONSTANT(int, char_class_underscore = 0x00010000);
+    BOOST_STATIC_CONSTANT(int, char_class_newline = 0x00020000);
+
+    template<typename FwdIter>
+    static char_class_type lookup_classname(FwdIter begin, FwdIter end, bool icase)
+    {
+        using namespace std;
+        string const name = classname_a(begin, end);
+        if(name == "alnum")     return _ISalnum;
+        if(name == "alpha")     return _ISalpha;
+        if(name == "blank")     return _ISblank;
+        if(name == "cntrl")     return _IScntrl;
+        if(name == "d")         return _ISdigit;
+        if(name == "digit")     return _ISdigit;
+        if(name == "graph")     return _ISgraph;
+        if(name == "lower")     return icase ? (_ISlower|_ISupper) : _ISlower;
+        if(name == "print")     return _ISprint;
+        if(name == "newline")   return char_class_newline;
+        if(name == "punct")     return _ISpunct;
+        if(name == "s")         return _ISspace;
+        if(name == "space")     return _ISspace;
+        if(name == "upper")     return icase ? (_ISupper|_ISlower) : _ISupper;
+        if(name == "w")         return _ISalnum|char_class_underscore;
+        if(name == "xdigit")    return _ISxdigit;
+        return 0;
+    }
+
+    static bool isctype(char ch, char_class_type mask)
+    {
+        using namespace std;
+        if(0 != __isctype(static_cast<unsigned char>(ch), mask))
+        {
+            return true;
+        }
+
+        switch(ch)
+        {
+        case '_': return 0 != (mask & char_class_underscore);
+        case '\n': case '\r': case '\f': return 0 != (mask & char_class_newline);
+        default:;
+        }
+
+        return false;
+    }
+};
+
+#ifndef BOOST_XPRESSIVE_NO_WREGEX
+///////////////////////////////////////////////////////////////////////////////
+//
+template<>
+struct char_class_impl<wchar_t>
+{
+    typedef int char_class_type;
+    //BOOST_STATIC_CONSTANT(int, char_class_alnum         = 0x0001);
+    BOOST_STATIC_CONSTANT(int, char_class_alpha         = 0x0002);
+    BOOST_STATIC_CONSTANT(int, char_class_blank         = 0x0004);
+    BOOST_STATIC_CONSTANT(int, char_class_cntrl         = 0x0008);
+    BOOST_STATIC_CONSTANT(int, char_class_digit         = 0x0010);
+    //BOOST_STATIC_CONSTANT(int, char_class_graph         = 0x0020);
+    BOOST_STATIC_CONSTANT(int, char_class_lower         = 0x0040);
+    //BOOST_STATIC_CONSTANT(int, char_class_print         = 0x0080);
+    BOOST_STATIC_CONSTANT(int, char_class_punct         = 0x0100);
+    BOOST_STATIC_CONSTANT(int, char_class_space         = 0x0200);
+    BOOST_STATIC_CONSTANT(int, char_class_upper         = 0x0400);
+    BOOST_STATIC_CONSTANT(int, char_class_underscore    = 0x0800);
+    BOOST_STATIC_CONSTANT(int, char_class_xdigit        = 0x1000);
+    BOOST_STATIC_CONSTANT(int, char_class_newline       = 0x2000);
+
+    template<typename FwdIter>
+    static char_class_type lookup_classname(FwdIter begin, FwdIter end, bool icase)
+    {
+        using namespace std;
+        wstring const name = classname_w(begin, end);
+        if(name == L"alnum")    return char_class_alpha|char_class_digit;
+        if(name == L"alpha")    return char_class_alpha;
+        if(name == L"blank")    return char_class_blank;
+        if(name == L"cntrl")    return char_class_cntrl;
+        if(name == L"d")        return char_class_digit;
+        if(name == L"digit")    return char_class_digit;
+        if(name == L"graph")    return char_class_punct|char_class_alpha|char_class_digit;
+        if(name == L"lower")    return icase ? (char_class_lower|char_class_upper) : char_class_lower;
+        if(name == L"newline")  return char_class_newline;
+        if(name == L"print")    return char_class_blank|char_class_punct|char_class_alpha|char_class_digit;
+        if(name == L"punct")    return char_class_punct;
+        if(name == L"s")        return char_class_space;
+        if(name == L"space")    return char_class_space;
+        if(name == L"upper")    return icase ? (char_class_upper|char_class_lower) : char_class_upper;
+        if(name == L"w")        return char_class_alpha|char_class_digit|char_class_underscore;
+        if(name == L"xdigit")   return char_class_xdigit;
+        return 0;
+    }
+
+    static bool isctype(wchar_t ch, char_class_type mask)
+    {
+        using namespace std;
+        return ((char_class_alpha & mask) && iswalpha(ch))
+            || ((char_class_blank & mask) && (L' ' == ch || L'\t' == ch)) // BUGBUG
+            || ((char_class_cntrl & mask) && iswcntrl(ch))
+            || ((char_class_digit & mask) && iswdigit(ch))
+            || ((char_class_lower & mask) && iswlower(ch))
+            || ((char_class_newline & mask) && detail::iswnewline(ch))
+            || ((char_class_punct & mask) && iswpunct(ch))
+            || ((char_class_space & mask) && iswspace(ch))
+            || ((char_class_upper & mask) && iswupper(ch))
+            || ((char_class_underscore & mask) && L'_' == ch)
+            || ((char_class_xdigit & mask) && iswxdigit(ch))
+            ;
+    }
+};
+#endif
+
+
+
+#elif defined(_CPPLIB_VER) // Dinkumware STL
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////
+//
+template<>
+struct char_class_impl<char>
+{
+    typedef int char_class_type;
+    BOOST_MPL_ASSERT_RELATION(0x81FF, ==, (_ALPHA|_UPPER|_LOWER|_DIGIT|_SPACE|_PUNCT|_CONTROL|_BLANK|_HEX|_LEADBYTE));
+    BOOST_STATIC_CONSTANT(int, char_class_underscore = 0x1000);
+    BOOST_STATIC_CONSTANT(int, char_class_newline = 0x2000);
+
+    template<typename FwdIter>
+    static char_class_type lookup_classname(FwdIter begin, FwdIter end, bool icase)
+    {
+        using namespace std;
+        string const name = classname_a(begin, end);
+        if(name == "alnum")     return _ALPHA|_DIGIT;
+        if(name == "alpha")     return _ALPHA;
+        if(name == "blank")     return _BLANK; // this is ONLY space!!!
+        if(name == "cntrl")     return _CONTROL;
+        if(name == "d")         return _DIGIT;
+        if(name == "digit")     return _DIGIT;
+        if(name == "graph")     return _PUNCT|_ALPHA|_DIGIT;
+        if(name == "lower")     return icase ? (_LOWER|_UPPER) : _LOWER;
+        if(name == "newline")   return char_class_newline;
+        if(name == "print")     return _BLANK|_PUNCT|_ALPHA|_DIGIT;
+        if(name == "punct")     return _PUNCT;
+        if(name == "s")         return _SPACE;
+        if(name == "space")     return _SPACE;
+        if(name == "upper")     return icase ? (_UPPER|_LOWER) : _UPPER;
+        if(name == "w")         return _ALPHA|_DIGIT|char_class_underscore;
+        if(name == "xdigit")    return _HEX;
+        return 0;
+    }
+
+    static bool isctype(char ch, char_class_type mask)
+    {
+        using namespace std;
+        if(0 != _isctype(static_cast<unsigned char>(ch), mask))
+        {
+            return true;
+        }
+
+        switch(ch)
+        {
+        case '\t': return 0 != (mask & _BLANK);
+        case '_': return 0 != (mask & char_class_underscore);
+        case '\n': case '\r': case '\f': return 0 != (mask & char_class_newline);
+        default:;
+        }
+
+        return false;
+    }
+};
+
+#ifndef BOOST_XPRESSIVE_NO_WREGEX
+///////////////////////////////////////////////////////////////////////////////
+//
+template<>
+struct char_class_impl<wchar_t>
+{
+    typedef wctype_t char_class_type;
+    BOOST_MPL_ASSERT_RELATION(0x81FF, ==, (_ALPHA|_UPPER|_LOWER|_DIGIT|_SPACE|_PUNCT|_CONTROL|_BLANK|_HEX|_LEADBYTE));
+    BOOST_STATIC_CONSTANT(int, char_class_underscore = 0x1000);
+    BOOST_STATIC_CONSTANT(int, char_class_newline = 0x2000);
+
+    template<typename FwdIter>
+    static char_class_type lookup_classname(FwdIter begin, FwdIter end, bool icase)
+    {
+        using namespace std;
+        wstring const name = classname_w(begin, end);
+        if(name == L"alnum")    return _ALPHA|_DIGIT;
+        if(name == L"alpha")    return _ALPHA;
+        if(name == L"blank")    return _BLANK; // this is ONLY space!!!
+        if(name == L"cntrl")    return _CONTROL;
+        if(name == L"d")        return _DIGIT;
+        if(name == L"digit")    return _DIGIT;
+        if(name == L"graph")    return _PUNCT|_ALPHA|_DIGIT;
+        if(name == L"lower")    return icase ? _LOWER|_UPPER : _LOWER;
+        if(name == L"newline")  return char_class_newline;
+        if(name == L"print")    return _BLANK|_PUNCT|_ALPHA|_DIGIT;
+        if(name == L"punct")    return _PUNCT;
+        if(name == L"s")        return _SPACE;
+        if(name == L"space")    return _SPACE;
+        if(name == L"upper")    return icase ? _UPPER|_LOWER : _UPPER;
+        if(name == L"w")        return _ALPHA|_DIGIT|char_class_underscore;
+        if(name == L"xdigit")   return _HEX;
+        return 0;
+    }
+
+    static bool isctype(wchar_t ch, char_class_type mask)
+    {
+        using namespace std;
+        if(0 != iswctype(ch, mask))
+        {
+            return true;
+        }
+
+        switch(ch)
+        {
+        case L'\t': return 0 != (mask & _BLANK);
+        case L'_': return 0 != (mask & char_class_underscore);
+        case L'\n': case L'\r': case L'\f': case 0x2028u: case 0x2029u: case 0x85u:
+            return 0 != (mask & char_class_newline);
+        default:;
+        }
+
+        return false;
+    }
+};
+#endif
+
+
+
+#else // unknown, use portable implementation
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////
+//
+template<>
+struct char_class_impl<char>
+{
+    typedef int char_class_type;
+    //BOOST_STATIC_CONSTANT(int, char_class_alnum         = 0x0001);
+    BOOST_STATIC_CONSTANT(int, char_class_alpha         = 0x0002);
+    BOOST_STATIC_CONSTANT(int, char_class_blank         = 0x0004);
+    BOOST_STATIC_CONSTANT(int, char_class_cntrl         = 0x0008);
+    BOOST_STATIC_CONSTANT(int, char_class_digit         = 0x0010);
+    //BOOST_STATIC_CONSTANT(int, char_class_graph         = 0x0020);
+    BOOST_STATIC_CONSTANT(int, char_class_lower         = 0x0040);
+    //BOOST_STATIC_CONSTANT(int, char_class_print         = 0x0080);
+    BOOST_STATIC_CONSTANT(int, char_class_punct         = 0x0100);
+    BOOST_STATIC_CONSTANT(int, char_class_space         = 0x0200);
+    BOOST_STATIC_CONSTANT(int, char_class_upper         = 0x0400);
+    BOOST_STATIC_CONSTANT(int, char_class_underscore    = 0x0800);
+    BOOST_STATIC_CONSTANT(int, char_class_xdigit        = 0x1000);
+    BOOST_STATIC_CONSTANT(int, char_class_newline       = 0x2000);
+
+    template<typename FwdIter>
+    static char_class_type lookup_classname(FwdIter begin, FwdIter end, bool icase)
+    {
+        using namespace std;
+        string const name = classname_a(begin, end);
+        if(name == "alnum")     return char_class_alpha|char_class_digit;
+        if(name == "alpha")     return char_class_alpha;
+        if(name == "blank")     return char_class_blank;
+        if(name == "cntrl")     return char_class_cntrl;
+        if(name == "d")         return char_class_digit;
+        if(name == "digit")     return char_class_digit;
+        if(name == "graph")     return char_class_punct|char_class_alpha|char_class_digit;
+        if(name == "lower")     return icase ? (char_class_lower|char_class_upper) : char_class_lower;
+        if(name == "newline")   return char_class_newline;
+        if(name == "print")     return char_class_blank|char_class_punct|char_class_alpha|char_class_digit;
+        if(name == "punct")     return char_class_punct;
+        if(name == "s")         return char_class_space;
+        if(name == "space")     return char_class_space;
+        if(name == "upper")     return icase ? (char_class_upper|char_class_lower) : char_class_upper;
+        if(name == "w")         return char_class_alpha|char_class_digit|char_class_underscore;
+        if(name == "xdigit")    return char_class_xdigit;
+        return 0;
+    }
+
+    static bool isctype(char ch, char_class_type mask)
+    {
+        using namespace std;
+        unsigned char uch = static_cast<unsigned char>(ch);
+        return ((char_class_alpha & mask) && isalpha(uch))
+            || ((char_class_blank & mask) && (' ' == ch || '\t' == ch)) // BUGBUG
+            || ((char_class_cntrl & mask) && iscntrl(uch))
+            || ((char_class_digit & mask) && isdigit(uch))
+            || ((char_class_lower & mask) && islower(uch))
+            || ((char_class_newline & mask) && detail::isnewline(ch))
+            || ((char_class_punct & mask) && ispunct(uch))
+            || ((char_class_space & mask) && isspace(uch))
+            || ((char_class_upper & mask) && isupper(uch))
+            || ((char_class_underscore & mask) && '_' == ch)
+            || ((char_class_xdigit & mask) && isxdigit(uch))
+            ;
+    }
+};
+
+#ifndef BOOST_XPRESSIVE_NO_WREGEX
+///////////////////////////////////////////////////////////////////////////////
+//
+template<>
+struct char_class_impl<wchar_t>
+{
+    typedef int char_class_type;
+    //BOOST_STATIC_CONSTANT(int, char_class_alnum         = 0x0001);
+    BOOST_STATIC_CONSTANT(int, char_class_alpha         = 0x0002);
+    BOOST_STATIC_CONSTANT(int, char_class_blank         = 0x0004);
+    BOOST_STATIC_CONSTANT(int, char_class_cntrl         = 0x0008);
+    BOOST_STATIC_CONSTANT(int, char_class_digit         = 0x0010);
+    //BOOST_STATIC_CONSTANT(int, char_class_graph         = 0x0020);
+    BOOST_STATIC_CONSTANT(int, char_class_lower         = 0x0040);
+    //BOOST_STATIC_CONSTANT(int, char_class_print         = 0x0080);
+    BOOST_STATIC_CONSTANT(int, char_class_punct         = 0x0100);
+    BOOST_STATIC_CONSTANT(int, char_class_space         = 0x0200);
+    BOOST_STATIC_CONSTANT(int, char_class_upper         = 0x0400);
+    BOOST_STATIC_CONSTANT(int, char_class_underscore    = 0x0800);
+    BOOST_STATIC_CONSTANT(int, char_class_xdigit        = 0x1000);
+    BOOST_STATIC_CONSTANT(int, char_class_newline       = 0x2000);
+
+    template<typename FwdIter>
+    static char_class_type lookup_classname(FwdIter begin, FwdIter end, bool icase)
+    {
+        using namespace std;
+        wstring const name = classname_w(begin, end);
+        if(name == L"alnum")    return char_class_alpha|char_class_digit;
+        if(name == L"alpha")    return char_class_alpha;
+        if(name == L"blank")    return char_class_blank;
+        if(name == L"cntrl")    return char_class_cntrl;
+        if(name == L"d")        return char_class_digit;
+        if(name == L"digit")    return char_class_digit;
+        if(name == L"graph")    return char_class_punct|char_class_alpha|char_class_digit;
+        if(name == L"newline")  return char_class_newline;
+        if(name == L"lower")    return icase ? (char_class_lower|char_class_upper) : char_class_lower;
+        if(name == L"print")    return char_class_blank|char_class_punct|char_class_alpha|char_class_digit;
+        if(name == L"punct")    return char_class_punct;
+        if(name == L"s")        return char_class_space;
+        if(name == L"space")    return char_class_space;
+        if(name == L"upper")    return icase ? (char_class_upper|char_class_lower) : char_class_upper;
+        if(name == L"w")        return char_class_alpha|char_class_digit|char_class_underscore;
+        if(name == L"xdigit")   return char_class_xdigit;
+        return 0;
+    }
+
+    static bool isctype(wchar_t ch, char_class_type mask)
+    {
+        using namespace std;
+        return ((char_class_alpha & mask) && iswalpha(ch))
+            || ((char_class_blank & mask) && (L' ' == ch || L'\t' == ch)) // BUGBUG
+            || ((char_class_cntrl & mask) && iswcntrl(ch))
+            || ((char_class_digit & mask) && iswdigit(ch))
+            || ((char_class_lower & mask) && iswlower(ch))
+            || ((char_class_newline & mask) && detail::iswnewline(ch))
+            || ((char_class_punct & mask) && iswpunct(ch))
+            || ((char_class_space & mask) && iswspace(ch))
+            || ((char_class_upper & mask) && iswupper(ch))
+            || ((char_class_underscore & mask) && L'_' == ch)
+            || ((char_class_xdigit & mask) && iswxdigit(ch))
+            ;
+    }
+};
+#endif
+
+
+#endif
+
+
+}}} // namespace boost::xpressive::detail
+
+#endif