boost/xpressive/traits/detail/c_ctype.hpp
///////////////////////////////////////////////////////////////////////////////
// c_ctype.hpp
//
// Copyright 2007 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