1 ///////////////////////////////////////////////////////////////////////////////
4 // Copyright 2008 Eric Niebler. Distributed under the Boost
5 // Software License, Version 1.0. (See accompanying file
6 // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
8 #ifndef BOOST_XPRESSIVE_TRAITS_DETAIL_C_CTYPE_HPP_EAN_10_04_2005
9 #define BOOST_XPRESSIVE_TRAITS_DETAIL_C_CTYPE_HPP_EAN_10_04_2005
11 // MS compatible compilers support #pragma once
18 #include <boost/mpl/assert.hpp>
19 #include <boost/xpressive/detail/detail_fwd.hpp>
21 #ifndef BOOST_XPRESSIVE_NO_WREGEX
26 namespace boost { namespace xpressive { namespace detail
29 ///////////////////////////////////////////////////////////////////////////////
32 inline bool isnewline(char ch)
36 case L'\n': case L'\r': case L'\f':
43 ///////////////////////////////////////////////////////////////////////////////
46 inline bool iswnewline(wchar_t ch)
50 case L'\n': case L'\r': case L'\f': case 0x2028u: case 0x2029u: case 0x85u:
57 ///////////////////////////////////////////////////////////////////////////////
60 template<typename FwdIter>
61 inline std::string classname_a(FwdIter begin, FwdIter end)
63 std::string name(begin, end);
64 for(std::size_t i = 0; i < name.size(); ++i)
67 name[i] = static_cast<char>(tolower(static_cast<unsigned char>(name[i])));
72 #ifndef BOOST_XPRESSIVE_NO_WREGEX
73 ///////////////////////////////////////////////////////////////////////////////
76 template<typename FwdIter>
77 inline std::wstring classname_w(FwdIter begin, FwdIter end)
79 std::wstring name(begin, end);
80 for(std::size_t i = 0; i < name.size(); ++i)
83 name[i] = towlower(name[i]);
91 ///////////////////////////////////////////////////////////////////////////////
94 template<typename Char>
95 struct char_class_impl;
98 #if defined(__QNXNTO__)
100 ///////////////////////////////////////////////////////////////////////////////
103 struct char_class_impl<char>
105 typedef short char_class_type;
106 BOOST_MPL_ASSERT_RELATION(0x07FF, ==, (_XB|_XA|_XS|_BB|_CN|_DI|_LO|_PU|_SP|_UP|_XD));
107 BOOST_STATIC_CONSTANT(short, char_class_underscore = 0x1000);
108 BOOST_STATIC_CONSTANT(short, char_class_newline = 0x2000);
110 template<typename FwdIter>
111 static char_class_type lookup_classname(FwdIter begin, FwdIter end, bool icase)
114 string const name = classname_a(begin, end);
115 if(name == "alnum") return _DI|_LO|_UP|_XA;
116 if(name == "alpha") return _LO|_UP|_XA;
117 if(name == "blank") return _SP|_XB;
118 if(name == "cntrl") return _BB;
119 if(name == "d") return _DI;
120 if(name == "digit") return _DI;
121 if(name == "graph") return _DI|_LO|_PU|_UP|_XA;
122 if(name == "lower") return icase ? (_LO|_UP) : _LO;
123 if(name == "newline") return char_class_newline;
124 if(name == "print") return _DI|_LO|_PU|_SP|_UP|_XA;
125 if(name == "punct") return _PU;
126 if(name == "s") return _CN|_SP|_XS;
127 if(name == "space") return _CN|_SP|_XS;
128 if(name == "upper") return icase ? (_UP|_LO) : _UP;
129 if(name == "w") return _DI|_LO|_UP|_XA|char_class_underscore;
130 if(name == "xdigit") return _XD;
134 static bool isctype(char ch, char_class_type mask)
137 if(0 != (_Getchrtype((unsigned char)ch) & mask))
144 case '_': return 0 != (mask & char_class_underscore);
145 case '\n': case '\r': case '\f': return 0 != (mask & char_class_newline);
153 #ifndef BOOST_XPRESSIVE_NO_WREGEX
154 ///////////////////////////////////////////////////////////////////////////////
157 struct char_class_impl<wchar_t>
159 typedef int char_class_type;
160 //BOOST_STATIC_CONSTANT(int, char_class_alnum = 0x0001);
161 BOOST_STATIC_CONSTANT(int, char_class_alpha = 0x0002);
162 BOOST_STATIC_CONSTANT(int, char_class_blank = 0x0004);
163 BOOST_STATIC_CONSTANT(int, char_class_cntrl = 0x0008);
164 BOOST_STATIC_CONSTANT(int, char_class_digit = 0x0010);
165 //BOOST_STATIC_CONSTANT(int, char_class_graph = 0x0020);
166 BOOST_STATIC_CONSTANT(int, char_class_lower = 0x0040);
167 //BOOST_STATIC_CONSTANT(int, char_class_print = 0x0080);
168 BOOST_STATIC_CONSTANT(int, char_class_punct = 0x0100);
169 BOOST_STATIC_CONSTANT(int, char_class_space = 0x0200);
170 BOOST_STATIC_CONSTANT(int, char_class_upper = 0x0400);
171 BOOST_STATIC_CONSTANT(int, char_class_underscore = 0x0800);
172 BOOST_STATIC_CONSTANT(int, char_class_xdigit = 0x1000);
173 BOOST_STATIC_CONSTANT(int, char_class_newline = 0x2000);
175 template<typename FwdIter>
176 static char_class_type lookup_classname(FwdIter begin, FwdIter end, bool icase)
179 wstring const name = classname_w(begin, end);
180 if(name == L"alnum") return char_class_alpha|char_class_digit;
181 if(name == L"alpha") return char_class_alpha;
182 if(name == L"blank") return char_class_blank;
183 if(name == L"cntrl") return char_class_cntrl;
184 if(name == L"d") return char_class_digit;
185 if(name == L"digit") return char_class_digit;
186 if(name == L"graph") return char_class_punct|char_class_alpha|char_class_digit;
187 if(name == L"lower") return icase ? (char_class_lower|char_class_upper) : char_class_lower;
188 if(name == L"newline") return char_class_newline;
189 if(name == L"print") return char_class_blank|char_class_punct|char_class_alpha|char_class_digit;
190 if(name == L"punct") return char_class_punct;
191 if(name == L"s") return char_class_space;
192 if(name == L"space") return char_class_space;
193 if(name == L"upper") return icase ? (char_class_upper|char_class_lower) : char_class_upper;
194 if(name == L"w") return char_class_alpha|char_class_digit|char_class_underscore;
195 if(name == L"xdigit") return char_class_xdigit;
199 static bool isctype(wchar_t ch, char_class_type mask)
202 return ((char_class_alpha & mask) && iswalpha(ch))
203 || ((char_class_blank & mask) && (L' ' == ch || L'\t' == ch)) // BUGBUG
204 || ((char_class_cntrl & mask) && iswcntrl(ch))
205 || ((char_class_digit & mask) && iswdigit(ch))
206 || ((char_class_lower & mask) && iswlower(ch))
207 || ((char_class_newline & mask) && detail::iswnewline(ch))
208 || ((char_class_punct & mask) && iswpunct(ch))
209 || ((char_class_space & mask) && iswspace(ch))
210 || ((char_class_upper & mask) && iswupper(ch))
211 || ((char_class_underscore & mask) && L'_' == ch)
212 || ((char_class_xdigit & mask) && iswxdigit(ch))
219 #elif defined(__MINGW32_VERSION)
222 ///////////////////////////////////////////////////////////////////////////////
225 struct char_class_impl<char>
227 typedef int char_class_type;
228 BOOST_MPL_ASSERT_RELATION(0x81FF, ==, (_ALPHA|_UPPER|_LOWER|_DIGIT|_SPACE|_PUNCT|_CONTROL|_BLANK|_HEX|_LEADBYTE));
229 BOOST_STATIC_CONSTANT(int, char_class_underscore = 0x1000);
230 BOOST_STATIC_CONSTANT(int, char_class_newline = 0x2000);
232 template<typename FwdIter>
233 static char_class_type lookup_classname(FwdIter begin, FwdIter end, bool icase)
236 string const name = classname_a(begin, end);
237 if(name == "alnum") return _ALPHA|_DIGIT;
238 if(name == "alpha") return _ALPHA;
239 if(name == "blank") return _BLANK; // this is ONLY space!!!
240 if(name == "cntrl") return _CONTROL;
241 if(name == "d") return _DIGIT;
242 if(name == "digit") return _DIGIT;
243 if(name == "graph") return _PUNCT|_ALPHA|_DIGIT;
244 if(name == "lower") return icase ? (_LOWER|_UPPER) : _LOWER;
245 if(name == "newline") return char_class_newline;
246 if(name == "print") return _BLANK|_PUNCT|_ALPHA|_DIGIT;
247 if(name == "punct") return _PUNCT;
248 if(name == "s") return _SPACE;
249 if(name == "space") return _SPACE;
250 if(name == "upper") return icase ? (_UPPER|_LOWER) : _UPPER;
251 if(name == "w") return _ALPHA|_DIGIT|char_class_underscore;
252 if(name == "xdigit") return _HEX;
256 static bool isctype(char ch, char_class_type mask)
259 if(0 != _isctype(static_cast<unsigned char>(ch), mask))
266 case '\t': return 0 != (mask & _BLANK);
267 case '_': return 0 != (mask & char_class_underscore);
268 case '\n': case '\r': case '\f': return 0 != (mask & char_class_newline);
276 #ifndef BOOST_XPRESSIVE_NO_WREGEX
277 ///////////////////////////////////////////////////////////////////////////////
280 struct char_class_impl<wchar_t>
282 typedef wctype_t char_class_type;
283 BOOST_MPL_ASSERT_RELATION(0x81FF, ==, (_ALPHA|_UPPER|_LOWER|_DIGIT|_SPACE|_PUNCT|_CONTROL|_BLANK|_HEX|_LEADBYTE));
284 BOOST_STATIC_CONSTANT(int, char_class_underscore = 0x1000);
285 BOOST_STATIC_CONSTANT(int, char_class_newline = 0x2000);
287 template<typename FwdIter>
288 static char_class_type lookup_classname(FwdIter begin, FwdIter end, bool icase)
291 wstring const name = classname_w(begin, end);
292 if(name == L"alnum") return _ALPHA|_DIGIT;
293 if(name == L"alpha") return _ALPHA;
294 if(name == L"blank") return _BLANK; // this is ONLY space!!!
295 if(name == L"cntrl") return _CONTROL;
296 if(name == L"d") return _DIGIT;
297 if(name == L"digit") return _DIGIT;
298 if(name == L"graph") return _PUNCT|_ALPHA|_DIGIT;
299 if(name == L"lower") return icase ? (_LOWER|_UPPER) : _LOWER;
300 if(name == L"newline") return char_class_newline;
301 if(name == L"print") return _BLANK|_PUNCT|_ALPHA|_DIGIT;
302 if(name == L"punct") return _PUNCT;
303 if(name == L"s") return _SPACE;
304 if(name == L"space") return _SPACE;
305 if(name == L"upper") return icase ? (_UPPER|_LOWER) : _UPPER;
306 if(name == L"w") return _ALPHA|_DIGIT|char_class_underscore;
307 if(name == L"xdigit") return _HEX;
311 static bool isctype(wchar_t ch, char_class_type mask)
314 if(0 != iswctype(ch, mask))
321 case L'\t': return 0 != (mask & _BLANK);
322 case L'_': return 0 != (mask & char_class_underscore);
323 case L'\n': case L'\r': case L'\f': case 0x2028u: case 0x2029u: case 0x85u:
324 return 0 != (mask & char_class_newline);
334 #elif defined(__CYGWIN__)
338 ///////////////////////////////////////////////////////////////////////////////
341 struct char_class_impl<char>
343 typedef int char_class_type;
344 BOOST_MPL_ASSERT_RELATION(0377, ==, (_U|_L|_N|_S|_P|_C|_B|_X));
345 BOOST_STATIC_CONSTANT(int, char_class_underscore = 0400);
346 BOOST_STATIC_CONSTANT(int, char_class_newline = 01000);
348 template<typename FwdIter>
349 static char_class_type lookup_classname(FwdIter begin, FwdIter end, bool icase)
352 string const name = classname_a(begin, end);
353 if(name == "alnum") return _U|_L|_N;
354 if(name == "alpha") return _U|_L;
355 if(name == "blank") return _B; // BUGBUG what is this?
356 if(name == "cntrl") return _C;
357 if(name == "d") return _N;
358 if(name == "digit") return _N;
359 if(name == "graph") return _P|_U|_L|_N;
360 if(name == "lower") return icase ? (_L|_U) : _L;
361 if(name == "newline") return char_class_newline;
362 if(name == "print") return _B|_P|_U|_L|_N;
363 if(name == "punct") return _P;
364 if(name == "s") return _S;
365 if(name == "space") return _S;
366 if(name == "upper") return icase ? (_U|_L) : _U;
367 if(name == "w") return _U|_L|_N|char_class_underscore;
368 if(name == "xdigit") return _X;
372 static bool isctype(char ch, char_class_type mask)
374 if(0 != static_cast<unsigned char>(((_ctype_+1)[(unsigned)(ch)]) & mask))
381 case '_': return 0 != (mask & char_class_underscore);
382 case '\n': case '\r': case '\f': return 0 != (mask & char_class_newline);
390 #ifndef BOOST_XPRESSIVE_NO_WREGEX
391 ///////////////////////////////////////////////////////////////////////////////
394 struct char_class_impl<wchar_t>
396 typedef int char_class_type;
397 //BOOST_STATIC_CONSTANT(int, char_class_alnum = 0x0001);
398 BOOST_STATIC_CONSTANT(int, char_class_alpha = 0x0002);
399 BOOST_STATIC_CONSTANT(int, char_class_blank = 0x0004);
400 BOOST_STATIC_CONSTANT(int, char_class_cntrl = 0x0008);
401 BOOST_STATIC_CONSTANT(int, char_class_digit = 0x0010);
402 //BOOST_STATIC_CONSTANT(int, char_class_graph = 0x0020);
403 BOOST_STATIC_CONSTANT(int, char_class_lower = 0x0040);
404 //BOOST_STATIC_CONSTANT(int, char_class_print = 0x0080);
405 BOOST_STATIC_CONSTANT(int, char_class_punct = 0x0100);
406 BOOST_STATIC_CONSTANT(int, char_class_space = 0x0200);
407 BOOST_STATIC_CONSTANT(int, char_class_upper = 0x0400);
408 BOOST_STATIC_CONSTANT(int, char_class_underscore = 0x0800);
409 BOOST_STATIC_CONSTANT(int, char_class_xdigit = 0x1000);
410 BOOST_STATIC_CONSTANT(int, char_class_newline = 0x2000);
412 template<typename FwdIter>
413 static char_class_type lookup_classname(FwdIter begin, FwdIter end, bool icase)
416 wstring const name = classname_w(begin, end);
417 if(name == L"alnum") return char_class_alpha|char_class_digit;
418 if(name == L"alpha") return char_class_alpha;
419 if(name == L"blank") return char_class_blank;
420 if(name == L"cntrl") return char_class_cntrl;
421 if(name == L"d") return char_class_digit;
422 if(name == L"digit") return char_class_digit;
423 if(name == L"graph") return char_class_punct|char_class_alpha|char_class_digit;
424 if(name == L"lower") return icase ? (char_class_lower|char_class_upper) : char_class_lower;
425 if(name == L"newline") return char_class_newline;
426 if(name == L"print") return char_class_blank|char_class_punct|char_class_alpha|char_class_digit;
427 if(name == L"punct") return char_class_punct;
428 if(name == L"s") return char_class_space;
429 if(name == L"space") return char_class_space;
430 if(name == L"upper") return icase ? (char_class_upper|char_class_lower) : char_class_upper;
431 if(name == L"w") return char_class_alpha|char_class_digit|char_class_underscore;
432 if(name == L"xdigit") return char_class_xdigit;
436 static bool isctype(wchar_t ch, char_class_type mask)
439 return ((char_class_alpha & mask) && iswalpha(ch))
440 || ((char_class_blank & mask) && (L' ' == ch || L'\t' == ch)) // BUGBUG
441 || ((char_class_cntrl & mask) && iswcntrl(ch))
442 || ((char_class_digit & mask) && iswdigit(ch))
443 || ((char_class_lower & mask) && iswlower(ch))
444 || ((char_class_newline & mask) && detail::iswnewline(ch))
445 || ((char_class_punct & mask) && iswpunct(ch))
446 || ((char_class_space & mask) && iswspace(ch))
447 || ((char_class_upper & mask) && iswupper(ch))
448 || ((char_class_underscore & mask) && L'_' == ch)
449 || ((char_class_xdigit & mask) && iswxdigit(ch))
457 #elif defined(__GLIBC__)
462 ///////////////////////////////////////////////////////////////////////////////
465 struct char_class_impl<char>
467 typedef int char_class_type;
468 BOOST_MPL_ASSERT_RELATION(0xffff, ==, (_ISalnum|_ISalpha|_ISblank|_IScntrl|_ISdigit|_ISgraph|
469 _ISlower|_ISprint|_ISpunct|_ISspace|_ISupper|_ISxdigit|0xffff));
470 BOOST_STATIC_CONSTANT(int, char_class_underscore = 0x00010000);
471 BOOST_STATIC_CONSTANT(int, char_class_newline = 0x00020000);
473 template<typename FwdIter>
474 static char_class_type lookup_classname(FwdIter begin, FwdIter end, bool icase)
477 string const name = classname_a(begin, end);
478 if(name == "alnum") return _ISalnum;
479 if(name == "alpha") return _ISalpha;
480 if(name == "blank") return _ISblank;
481 if(name == "cntrl") return _IScntrl;
482 if(name == "d") return _ISdigit;
483 if(name == "digit") return _ISdigit;
484 if(name == "graph") return _ISgraph;
485 if(name == "lower") return icase ? (_ISlower|_ISupper) : _ISlower;
486 if(name == "print") return _ISprint;
487 if(name == "newline") return char_class_newline;
488 if(name == "punct") return _ISpunct;
489 if(name == "s") return _ISspace;
490 if(name == "space") return _ISspace;
491 if(name == "upper") return icase ? (_ISupper|_ISlower) : _ISupper;
492 if(name == "w") return _ISalnum|char_class_underscore;
493 if(name == "xdigit") return _ISxdigit;
497 static bool isctype(char ch, char_class_type mask)
499 if(glibc_isctype(ch, mask))
506 case '_': return 0 != (mask & char_class_underscore);
507 case '\n': case '\r': case '\f': return 0 != (mask & char_class_newline);
514 static bool glibc_isctype(char ch, char_class_type mask)
517 return 0 != __isctype(ch, mask);
519 return 0 != ((*__ctype_b_loc())[(int)(ch)] & (unsigned short int)mask);
524 #ifndef BOOST_XPRESSIVE_NO_WREGEX
525 ///////////////////////////////////////////////////////////////////////////////
528 struct char_class_impl<wchar_t>
530 typedef int char_class_type;
531 //BOOST_STATIC_CONSTANT(int, char_class_alnum = 0x0001);
532 BOOST_STATIC_CONSTANT(int, char_class_alpha = 0x0002);
533 BOOST_STATIC_CONSTANT(int, char_class_blank = 0x0004);
534 BOOST_STATIC_CONSTANT(int, char_class_cntrl = 0x0008);
535 BOOST_STATIC_CONSTANT(int, char_class_digit = 0x0010);
536 //BOOST_STATIC_CONSTANT(int, char_class_graph = 0x0020);
537 BOOST_STATIC_CONSTANT(int, char_class_lower = 0x0040);
538 //BOOST_STATIC_CONSTANT(int, char_class_print = 0x0080);
539 BOOST_STATIC_CONSTANT(int, char_class_punct = 0x0100);
540 BOOST_STATIC_CONSTANT(int, char_class_space = 0x0200);
541 BOOST_STATIC_CONSTANT(int, char_class_upper = 0x0400);
542 BOOST_STATIC_CONSTANT(int, char_class_underscore = 0x0800);
543 BOOST_STATIC_CONSTANT(int, char_class_xdigit = 0x1000);
544 BOOST_STATIC_CONSTANT(int, char_class_newline = 0x2000);
546 template<typename FwdIter>
547 static char_class_type lookup_classname(FwdIter begin, FwdIter end, bool icase)
550 wstring const name = classname_w(begin, end);
551 if(name == L"alnum") return char_class_alpha|char_class_digit;
552 if(name == L"alpha") return char_class_alpha;
553 if(name == L"blank") return char_class_blank;
554 if(name == L"cntrl") return char_class_cntrl;
555 if(name == L"d") return char_class_digit;
556 if(name == L"digit") return char_class_digit;
557 if(name == L"graph") return char_class_punct|char_class_alpha|char_class_digit;
558 if(name == L"lower") return icase ? (char_class_lower|char_class_upper) : char_class_lower;
559 if(name == L"newline") return char_class_newline;
560 if(name == L"print") return char_class_blank|char_class_punct|char_class_alpha|char_class_digit;
561 if(name == L"punct") return char_class_punct;
562 if(name == L"s") return char_class_space;
563 if(name == L"space") return char_class_space;
564 if(name == L"upper") return icase ? (char_class_upper|char_class_lower) : char_class_upper;
565 if(name == L"w") return char_class_alpha|char_class_digit|char_class_underscore;
566 if(name == L"xdigit") return char_class_xdigit;
570 static bool isctype(wchar_t ch, char_class_type mask)
573 return ((char_class_alpha & mask) && iswalpha(ch))
574 || ((char_class_blank & mask) && (L' ' == ch || L'\t' == ch)) // BUGBUG
575 || ((char_class_cntrl & mask) && iswcntrl(ch))
576 || ((char_class_digit & mask) && iswdigit(ch))
577 || ((char_class_lower & mask) && iswlower(ch))
578 || ((char_class_newline & mask) && detail::iswnewline(ch))
579 || ((char_class_punct & mask) && iswpunct(ch))
580 || ((char_class_space & mask) && iswspace(ch))
581 || ((char_class_upper & mask) && iswupper(ch))
582 || ((char_class_underscore & mask) && L'_' == ch)
583 || ((char_class_xdigit & mask) && iswxdigit(ch))
591 #elif defined(_CPPLIB_VER) // Dinkumware STL
596 ///////////////////////////////////////////////////////////////////////////////
599 struct char_class_impl<char>
601 typedef int char_class_type;
602 BOOST_MPL_ASSERT_RELATION(0x81FF, ==, (_ALPHA|_UPPER|_LOWER|_DIGIT|_SPACE|_PUNCT|_CONTROL|_BLANK|_HEX|_LEADBYTE));
603 BOOST_STATIC_CONSTANT(int, char_class_underscore = 0x1000);
604 BOOST_STATIC_CONSTANT(int, char_class_newline = 0x2000);
606 template<typename FwdIter>
607 static char_class_type lookup_classname(FwdIter begin, FwdIter end, bool icase)
610 string const name = classname_a(begin, end);
611 if(name == "alnum") return _ALPHA|_DIGIT;
612 if(name == "alpha") return _ALPHA;
613 if(name == "blank") return _BLANK; // this is ONLY space!!!
614 if(name == "cntrl") return _CONTROL;
615 if(name == "d") return _DIGIT;
616 if(name == "digit") return _DIGIT;
617 if(name == "graph") return _PUNCT|_ALPHA|_DIGIT;
618 if(name == "lower") return icase ? (_LOWER|_UPPER) : _LOWER;
619 if(name == "newline") return char_class_newline;
620 if(name == "print") return _BLANK|_PUNCT|_ALPHA|_DIGIT;
621 if(name == "punct") return _PUNCT;
622 if(name == "s") return _SPACE;
623 if(name == "space") return _SPACE;
624 if(name == "upper") return icase ? (_UPPER|_LOWER) : _UPPER;
625 if(name == "w") return _ALPHA|_DIGIT|char_class_underscore;
626 if(name == "xdigit") return _HEX;
630 static bool isctype(char ch, char_class_type mask)
633 if(0 != _isctype(static_cast<unsigned char>(ch), mask))
640 case '\t': return 0 != (mask & _BLANK);
641 case '_': return 0 != (mask & char_class_underscore);
642 case '\n': case '\r': case '\f': return 0 != (mask & char_class_newline);
650 #ifndef BOOST_XPRESSIVE_NO_WREGEX
651 ///////////////////////////////////////////////////////////////////////////////
654 struct char_class_impl<wchar_t>
656 typedef wctype_t char_class_type;
657 BOOST_MPL_ASSERT_RELATION(0x81FF, ==, (_ALPHA|_UPPER|_LOWER|_DIGIT|_SPACE|_PUNCT|_CONTROL|_BLANK|_HEX|_LEADBYTE));
658 BOOST_STATIC_CONSTANT(int, char_class_underscore = 0x1000);
659 BOOST_STATIC_CONSTANT(int, char_class_newline = 0x2000);
661 template<typename FwdIter>
662 static char_class_type lookup_classname(FwdIter begin, FwdIter end, bool icase)
665 wstring const name = classname_w(begin, end);
666 if(name == L"alnum") return _ALPHA|_DIGIT;
667 if(name == L"alpha") return _ALPHA;
668 if(name == L"blank") return _BLANK; // this is ONLY space!!!
669 if(name == L"cntrl") return _CONTROL;
670 if(name == L"d") return _DIGIT;
671 if(name == L"digit") return _DIGIT;
672 if(name == L"graph") return _PUNCT|_ALPHA|_DIGIT;
673 if(name == L"lower") return icase ? _LOWER|_UPPER : _LOWER;
674 if(name == L"newline") return char_class_newline;
675 if(name == L"print") return _BLANK|_PUNCT|_ALPHA|_DIGIT;
676 if(name == L"punct") return _PUNCT;
677 if(name == L"s") return _SPACE;
678 if(name == L"space") return _SPACE;
679 if(name == L"upper") return icase ? _UPPER|_LOWER : _UPPER;
680 if(name == L"w") return _ALPHA|_DIGIT|char_class_underscore;
681 if(name == L"xdigit") return _HEX;
685 static bool isctype(wchar_t ch, char_class_type mask)
688 if(0 != iswctype(ch, mask))
695 case L'\t': return 0 != (mask & _BLANK);
696 case L'_': return 0 != (mask & char_class_underscore);
697 case L'\n': case L'\r': case L'\f': case 0x2028u: case 0x2029u: case 0x85u:
698 return 0 != (mask & char_class_newline);
709 #else // unknown, use portable implementation
714 ///////////////////////////////////////////////////////////////////////////////
717 struct char_class_impl<char>
719 typedef int char_class_type;
720 //BOOST_STATIC_CONSTANT(int, char_class_alnum = 0x0001);
721 BOOST_STATIC_CONSTANT(int, char_class_alpha = 0x0002);
722 BOOST_STATIC_CONSTANT(int, char_class_blank = 0x0004);
723 BOOST_STATIC_CONSTANT(int, char_class_cntrl = 0x0008);
724 BOOST_STATIC_CONSTANT(int, char_class_digit = 0x0010);
725 //BOOST_STATIC_CONSTANT(int, char_class_graph = 0x0020);
726 BOOST_STATIC_CONSTANT(int, char_class_lower = 0x0040);
727 //BOOST_STATIC_CONSTANT(int, char_class_print = 0x0080);
728 BOOST_STATIC_CONSTANT(int, char_class_punct = 0x0100);
729 BOOST_STATIC_CONSTANT(int, char_class_space = 0x0200);
730 BOOST_STATIC_CONSTANT(int, char_class_upper = 0x0400);
731 BOOST_STATIC_CONSTANT(int, char_class_underscore = 0x0800);
732 BOOST_STATIC_CONSTANT(int, char_class_xdigit = 0x1000);
733 BOOST_STATIC_CONSTANT(int, char_class_newline = 0x2000);
735 template<typename FwdIter>
736 static char_class_type lookup_classname(FwdIter begin, FwdIter end, bool icase)
739 string const name = classname_a(begin, end);
740 if(name == "alnum") return char_class_alpha|char_class_digit;
741 if(name == "alpha") return char_class_alpha;
742 if(name == "blank") return char_class_blank;
743 if(name == "cntrl") return char_class_cntrl;
744 if(name == "d") return char_class_digit;
745 if(name == "digit") return char_class_digit;
746 if(name == "graph") return char_class_punct|char_class_alpha|char_class_digit;
747 if(name == "lower") return icase ? (char_class_lower|char_class_upper) : char_class_lower;
748 if(name == "newline") return char_class_newline;
749 if(name == "print") return char_class_blank|char_class_punct|char_class_alpha|char_class_digit;
750 if(name == "punct") return char_class_punct;
751 if(name == "s") return char_class_space;
752 if(name == "space") return char_class_space;
753 if(name == "upper") return icase ? (char_class_upper|char_class_lower) : char_class_upper;
754 if(name == "w") return char_class_alpha|char_class_digit|char_class_underscore;
755 if(name == "xdigit") return char_class_xdigit;
759 static bool isctype(char ch, char_class_type mask)
762 unsigned char uch = static_cast<unsigned char>(ch);
763 return ((char_class_alpha & mask) && isalpha(uch))
764 || ((char_class_blank & mask) && (' ' == ch || '\t' == ch)) // BUGBUG
765 || ((char_class_cntrl & mask) && iscntrl(uch))
766 || ((char_class_digit & mask) && isdigit(uch))
767 || ((char_class_lower & mask) && islower(uch))
768 || ((char_class_newline & mask) && detail::isnewline(ch))
769 || ((char_class_punct & mask) && ispunct(uch))
770 || ((char_class_space & mask) && isspace(uch))
771 || ((char_class_upper & mask) && isupper(uch))
772 || ((char_class_underscore & mask) && '_' == ch)
773 || ((char_class_xdigit & mask) && isxdigit(uch))
778 #ifndef BOOST_XPRESSIVE_NO_WREGEX
779 ///////////////////////////////////////////////////////////////////////////////
782 struct char_class_impl<wchar_t>
784 typedef int char_class_type;
785 //BOOST_STATIC_CONSTANT(int, char_class_alnum = 0x0001);
786 BOOST_STATIC_CONSTANT(int, char_class_alpha = 0x0002);
787 BOOST_STATIC_CONSTANT(int, char_class_blank = 0x0004);
788 BOOST_STATIC_CONSTANT(int, char_class_cntrl = 0x0008);
789 BOOST_STATIC_CONSTANT(int, char_class_digit = 0x0010);
790 //BOOST_STATIC_CONSTANT(int, char_class_graph = 0x0020);
791 BOOST_STATIC_CONSTANT(int, char_class_lower = 0x0040);
792 //BOOST_STATIC_CONSTANT(int, char_class_print = 0x0080);
793 BOOST_STATIC_CONSTANT(int, char_class_punct = 0x0100);
794 BOOST_STATIC_CONSTANT(int, char_class_space = 0x0200);
795 BOOST_STATIC_CONSTANT(int, char_class_upper = 0x0400);
796 BOOST_STATIC_CONSTANT(int, char_class_underscore = 0x0800);
797 BOOST_STATIC_CONSTANT(int, char_class_xdigit = 0x1000);
798 BOOST_STATIC_CONSTANT(int, char_class_newline = 0x2000);
800 template<typename FwdIter>
801 static char_class_type lookup_classname(FwdIter begin, FwdIter end, bool icase)
804 wstring const name = classname_w(begin, end);
805 if(name == L"alnum") return char_class_alpha|char_class_digit;
806 if(name == L"alpha") return char_class_alpha;
807 if(name == L"blank") return char_class_blank;
808 if(name == L"cntrl") return char_class_cntrl;
809 if(name == L"d") return char_class_digit;
810 if(name == L"digit") return char_class_digit;
811 if(name == L"graph") return char_class_punct|char_class_alpha|char_class_digit;
812 if(name == L"newline") return char_class_newline;
813 if(name == L"lower") return icase ? (char_class_lower|char_class_upper) : char_class_lower;
814 if(name == L"print") return char_class_blank|char_class_punct|char_class_alpha|char_class_digit;
815 if(name == L"punct") return char_class_punct;
816 if(name == L"s") return char_class_space;
817 if(name == L"space") return char_class_space;
818 if(name == L"upper") return icase ? (char_class_upper|char_class_lower) : char_class_upper;
819 if(name == L"w") return char_class_alpha|char_class_digit|char_class_underscore;
820 if(name == L"xdigit") return char_class_xdigit;
824 static bool isctype(wchar_t ch, char_class_type mask)
827 return ((char_class_alpha & mask) && iswalpha(ch))
828 || ((char_class_blank & mask) && (L' ' == ch || L'\t' == ch)) // BUGBUG
829 || ((char_class_cntrl & mask) && iswcntrl(ch))
830 || ((char_class_digit & mask) && iswdigit(ch))
831 || ((char_class_lower & mask) && iswlower(ch))
832 || ((char_class_newline & mask) && detail::iswnewline(ch))
833 || ((char_class_punct & mask) && iswpunct(ch))
834 || ((char_class_space & mask) && iswspace(ch))
835 || ((char_class_upper & mask) && iswupper(ch))
836 || ((char_class_underscore & mask) && L'_' == ch)
837 || ((char_class_xdigit & mask) && iswxdigit(ch))
847 }}} // namespace boost::xpressive::detail