-/*

- *

- * Copyright (c) 2004

- * John Maddock

- *

- * Use, modification and distribution are 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)

- *

- */

-

- /*

- * LOCATION: see http://www.boost.org for most recent version.

- * FILE icu.cpp

- * VERSION see <boost/version.hpp>

- * DESCRIPTION: Unicode regular expressions on top of the ICU Library.

- */

-#define BOOST_REGEX_SOURCE

-

-#include <boost/regex/config.hpp>

-#ifdef BOOST_HAS_ICU

-#define BOOST_REGEX_ICU_INSTANTIATE

-#include <boost/regex/icu.hpp>

-

-namespace boost{

-

-namespace re_detail{

-

-icu_regex_traits_implementation::string_type icu_regex_traits_implementation::do_transform(const char_type* p1, const char_type* p2, const U_NAMESPACE_QUALIFIER Collator* pcoll) const

-{

- // TODO make thread safe!!!! :

- typedef u32_to_u16_iterator<const char_type*, ::UChar> itt;

- itt i(p1), j(p2);

-#ifndef BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS

- std::vector< ::UChar> t(i, j);

-#else

- std::vector< ::UChar> t;

- while(i != j)

- t.push_back(*i++);

-#endif

- ::uint8_t result[100];

- ::int32_t len;

- if(t.size())

- len = pcoll->getSortKey(&*t.begin(), static_cast< ::int32_t>(t.size()), result, sizeof(result));

- else

- len = pcoll->getSortKey(static_cast<UChar const*>(0), static_cast< ::int32_t>(0), result, sizeof(result));

- if(std::size_t(len) > sizeof(result))

- {

- scoped_array< ::uint8_t> presult(new ::uint8_t[len+1]);

- if(t.size())

- len = pcoll->getSortKey(&*t.begin(), static_cast< ::int32_t>(t.size()), presult.get(), len+1);

- else

- len = pcoll->getSortKey(static_cast<UChar const*>(0), static_cast< ::int32_t>(0), presult.get(), len+1);

- if((0 == presult[len-1]) && (len > 1))

- --len;

-#ifndef BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS

- return string_type(presult.get(), presult.get()+len);

-#else

- string_type sresult;

- ::uint8_t const* ia = presult.get();

- ::uint8_t const* ib = presult.get()+len;

- while(ia != ib)

- sresult.push_back(*ia++);

- return sresult;

-#endif

- }

- if((0 == result[len-1]) && (len > 1))

- --len;

-#ifndef BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS

- return string_type(result, result+len);

-#else

- string_type sresult;

- ::uint8_t const* ia = result;

- ::uint8_t const* ib = result+len;

- while(ia != ib)

- sresult.push_back(*ia++);

- return sresult;

-#endif

-}

-

-}

-

-icu_regex_traits::size_type icu_regex_traits::length(const char_type* p)

-{

- size_type result = 0;

- while(*p)

- {

- ++p;

- ++result;

- }

- return result;

-}

-

-//

-// define our bitmasks:

-//

-const icu_regex_traits::char_class_type icu_regex_traits::mask_blank = icu_regex_traits::char_class_type(1) << offset_blank;

-const icu_regex_traits::char_class_type icu_regex_traits::mask_space = icu_regex_traits::char_class_type(1) << offset_space;

-const icu_regex_traits::char_class_type icu_regex_traits::mask_xdigit = icu_regex_traits::char_class_type(1) << offset_xdigit;

-const icu_regex_traits::char_class_type icu_regex_traits::mask_underscore = icu_regex_traits::char_class_type(1) << offset_underscore;

-const icu_regex_traits::char_class_type icu_regex_traits::mask_unicode = icu_regex_traits::char_class_type(1) << offset_unicode;

-const icu_regex_traits::char_class_type icu_regex_traits::mask_any = icu_regex_traits::char_class_type(1) << offset_any;

-const icu_regex_traits::char_class_type icu_regex_traits::mask_ascii = icu_regex_traits::char_class_type(1) << offset_ascii;

-

-icu_regex_traits::char_class_type icu_regex_traits::lookup_icu_mask(const ::UChar32* p1, const ::UChar32* p2)

-{

- static const ::UChar32 prop_name_table[] = {

- /* any */ 'a', 'n', 'y',

- /* ascii */ 'a', 's', 'c', 'i', 'i',

- /* assigned */ 'a', 's', 's', 'i', 'g', 'n', 'e', 'd',

- /* c* */ 'c', '*',

- /* cc */ 'c', 'c',

- /* cf */ 'c', 'f',

- /* closepunctuation */ 'c', 'l', 'o', 's', 'e', 'p', 'u', 'n', 'c', 't', 'u', 'a', 't', 'i', 'o', 'n',

- /* cn */ 'c', 'n',

- /* co */ 'c', 'o',

- /* connectorpunctuation */ 'c', 'o', 'n', 'n', 'e', 'c', 't', 'o', 'r', 'p', 'u', 'n', 'c', 't', 'u', 'a', 't', 'i', 'o', 'n',

- /* control */ 'c', 'o', 'n', 't', 'r', 'o', 'l',

- /* cs */ 'c', 's',

- /* currencysymbol */ 'c', 'u', 'r', 'r', 'e', 'n', 'c', 'y', 's', 'y', 'm', 'b', 'o', 'l',

- /* dashpunctuation */ 'd', 'a', 's', 'h', 'p', 'u', 'n', 'c', 't', 'u', 'a', 't', 'i', 'o', 'n',

- /* decimaldigitnumber */ 'd', 'e', 'c', 'i', 'm', 'a', 'l', 'd', 'i', 'g', 'i', 't', 'n', 'u', 'm', 'b', 'e', 'r',

- /* enclosingmark */ 'e', 'n', 'c', 'l', 'o', 's', 'i', 'n', 'g', 'm', 'a', 'r', 'k',

- /* finalpunctuation */ 'f', 'i', 'n', 'a', 'l', 'p', 'u', 'n', 'c', 't', 'u', 'a', 't', 'i', 'o', 'n',

- /* format */ 'f', 'o', 'r', 'm', 'a', 't',

- /* initialpunctuation */ 'i', 'n', 'i', 't', 'i', 'a', 'l', 'p', 'u', 'n', 'c', 't', 'u', 'a', 't', 'i', 'o', 'n',

- /* l* */ 'l', '*',

- /* letter */ 'l', 'e', 't', 't', 'e', 'r',

- /* letternumber */ 'l', 'e', 't', 't', 'e', 'r', 'n', 'u', 'm', 'b', 'e', 'r',

- /* lineseparator */ 'l', 'i', 'n', 'e', 's', 'e', 'p', 'a', 'r', 'a', 't', 'o', 'r',

- /* ll */ 'l', 'l',

- /* lm */ 'l', 'm',

- /* lo */ 'l', 'o',

- /* lowercaseletter */ 'l', 'o', 'w', 'e', 'r', 'c', 'a', 's', 'e', 'l', 'e', 't', 't', 'e', 'r',

- /* lt */ 'l', 't',

- /* lu */ 'l', 'u',

- /* m* */ 'm', '*',

- /* mark */ 'm', 'a', 'r', 'k',

- /* mathsymbol */ 'm', 'a', 't', 'h', 's', 'y', 'm', 'b', 'o', 'l',

- /* mc */ 'm', 'c',

- /* me */ 'm', 'e',

- /* mn */ 'm', 'n',

- /* modifierletter */ 'm', 'o', 'd', 'i', 'f', 'i', 'e', 'r', 'l', 'e', 't', 't', 'e', 'r',

- /* modifiersymbol */ 'm', 'o', 'd', 'i', 'f', 'i', 'e', 'r', 's', 'y', 'm', 'b', 'o', 'l',

- /* n* */ 'n', '*',

- /* nd */ 'n', 'd',

- /* nl */ 'n', 'l',

- /* no */ 'n', 'o',

- /* nonspacingmark */ 'n', 'o', 'n', 's', 'p', 'a', 'c', 'i', 'n', 'g', 'm', 'a', 'r', 'k',

- /* notassigned */ 'n', 'o', 't', 'a', 's', 's', 'i', 'g', 'n', 'e', 'd',

- /* number */ 'n', 'u', 'm', 'b', 'e', 'r',

- /* openpunctuation */ 'o', 'p', 'e', 'n', 'p', 'u', 'n', 'c', 't', 'u', 'a', 't', 'i', 'o', 'n',

- /* other */ 'o', 't', 'h', 'e', 'r',

- /* otherletter */ 'o', 't', 'h', 'e', 'r', 'l', 'e', 't', 't', 'e', 'r',

- /* othernumber */ 'o', 't', 'h', 'e', 'r', 'n', 'u', 'm', 'b', 'e', 'r',

- /* otherpunctuation */ 'o', 't', 'h', 'e', 'r', 'p', 'u', 'n', 'c', 't', 'u', 'a', 't', 'i', 'o', 'n',

- /* othersymbol */ 'o', 't', 'h', 'e', 'r', 's', 'y', 'm', 'b', 'o', 'l',

- /* p* */ 'p', '*',

- /* paragraphseparator */ 'p', 'a', 'r', 'a', 'g', 'r', 'a', 'p', 'h', 's', 'e', 'p', 'a', 'r', 'a', 't', 'o', 'r',

- /* pc */ 'p', 'c',

- /* pd */ 'p', 'd',

- /* pe */ 'p', 'e',

- /* pf */ 'p', 'f',

- /* pi */ 'p', 'i',

- /* po */ 'p', 'o',

- /* privateuse */ 'p', 'r', 'i', 'v', 'a', 't', 'e', 'u', 's', 'e',

- /* ps */ 'p', 's',

- /* punctuation */ 'p', 'u', 'n', 'c', 't', 'u', 'a', 't', 'i', 'o', 'n',

- /* s* */ 's', '*',

- /* sc */ 's', 'c',

- /* separator */ 's', 'e', 'p', 'a', 'r', 'a', 't', 'o', 'r',

- /* sk */ 's', 'k',

- /* sm */ 's', 'm',

- /* so */ 's', 'o',

- /* spaceseparator */ 's', 'p', 'a', 'c', 'e', 's', 'e', 'p', 'a', 'r', 'a', 't', 'o', 'r',

- /* spacingcombiningmark */ 's', 'p', 'a', 'c', 'i', 'n', 'g', 'c', 'o', 'm', 'b', 'i', 'n', 'i', 'n', 'g', 'm', 'a', 'r', 'k',

- /* surrogate */ 's', 'u', 'r', 'r', 'o', 'g', 'a', 't', 'e',

- /* symbol */ 's', 'y', 'm', 'b', 'o', 'l',

- /* titlecase */ 't', 'i', 't', 'l', 'e', 'c', 'a', 's', 'e',

- /* titlecaseletter */ 't', 'i', 't', 'l', 'e', 'c', 'a', 's', 'e', 'l', 'e', 't', 't', 'e', 'r',

- /* uppercaseletter */ 'u', 'p', 'p', 'e', 'r', 'c', 'a', 's', 'e', 'l', 'e', 't', 't', 'e', 'r',

- /* z* */ 'z', '*',

- /* zl */ 'z', 'l',

- /* zp */ 'z', 'p',

- /* zs */ 'z', 's',

- };

-

- static const re_detail::character_pointer_range< ::UChar32> range_data[] = {

- { prop_name_table+0, prop_name_table+3, }, // any

- { prop_name_table+3, prop_name_table+8, }, // ascii

- { prop_name_table+8, prop_name_table+16, }, // assigned

- { prop_name_table+16, prop_name_table+18, }, // c*

- { prop_name_table+18, prop_name_table+20, }, // cc

- { prop_name_table+20, prop_name_table+22, }, // cf

- { prop_name_table+22, prop_name_table+38, }, // closepunctuation

- { prop_name_table+38, prop_name_table+40, }, // cn

- { prop_name_table+40, prop_name_table+42, }, // co

- { prop_name_table+42, prop_name_table+62, }, // connectorpunctuation

- { prop_name_table+62, prop_name_table+69, }, // control

- { prop_name_table+69, prop_name_table+71, }, // cs

- { prop_name_table+71, prop_name_table+85, }, // currencysymbol

- { prop_name_table+85, prop_name_table+100, }, // dashpunctuation

- { prop_name_table+100, prop_name_table+118, }, // decimaldigitnumber

- { prop_name_table+118, prop_name_table+131, }, // enclosingmark

- { prop_name_table+131, prop_name_table+147, }, // finalpunctuation

- { prop_name_table+147, prop_name_table+153, }, // format

- { prop_name_table+153, prop_name_table+171, }, // initialpunctuation

- { prop_name_table+171, prop_name_table+173, }, // l*

- { prop_name_table+173, prop_name_table+179, }, // letter

- { prop_name_table+179, prop_name_table+191, }, // letternumber

- { prop_name_table+191, prop_name_table+204, }, // lineseparator

- { prop_name_table+204, prop_name_table+206, }, // ll

- { prop_name_table+206, prop_name_table+208, }, // lm

- { prop_name_table+208, prop_name_table+210, }, // lo

- { prop_name_table+210, prop_name_table+225, }, // lowercaseletter

- { prop_name_table+225, prop_name_table+227, }, // lt

- { prop_name_table+227, prop_name_table+229, }, // lu

- { prop_name_table+229, prop_name_table+231, }, // m*

- { prop_name_table+231, prop_name_table+235, }, // mark

- { prop_name_table+235, prop_name_table+245, }, // mathsymbol

- { prop_name_table+245, prop_name_table+247, }, // mc

- { prop_name_table+247, prop_name_table+249, }, // me

- { prop_name_table+249, prop_name_table+251, }, // mn

- { prop_name_table+251, prop_name_table+265, }, // modifierletter

- { prop_name_table+265, prop_name_table+279, }, // modifiersymbol

- { prop_name_table+279, prop_name_table+281, }, // n*

- { prop_name_table+281, prop_name_table+283, }, // nd

- { prop_name_table+283, prop_name_table+285, }, // nl

- { prop_name_table+285, prop_name_table+287, }, // no

- { prop_name_table+287, prop_name_table+301, }, // nonspacingmark

- { prop_name_table+301, prop_name_table+312, }, // notassigned

- { prop_name_table+312, prop_name_table+318, }, // number

- { prop_name_table+318, prop_name_table+333, }, // openpunctuation

- { prop_name_table+333, prop_name_table+338, }, // other

- { prop_name_table+338, prop_name_table+349, }, // otherletter

- { prop_name_table+349, prop_name_table+360, }, // othernumber

- { prop_name_table+360, prop_name_table+376, }, // otherpunctuation

- { prop_name_table+376, prop_name_table+387, }, // othersymbol

- { prop_name_table+387, prop_name_table+389, }, // p*

- { prop_name_table+389, prop_name_table+407, }, // paragraphseparator

- { prop_name_table+407, prop_name_table+409, }, // pc

- { prop_name_table+409, prop_name_table+411, }, // pd

- { prop_name_table+411, prop_name_table+413, }, // pe

- { prop_name_table+413, prop_name_table+415, }, // pf

- { prop_name_table+415, prop_name_table+417, }, // pi

- { prop_name_table+417, prop_name_table+419, }, // po

- { prop_name_table+419, prop_name_table+429, }, // privateuse

- { prop_name_table+429, prop_name_table+431, }, // ps

- { prop_name_table+431, prop_name_table+442, }, // punctuation

- { prop_name_table+442, prop_name_table+444, }, // s*

- { prop_name_table+444, prop_name_table+446, }, // sc

- { prop_name_table+446, prop_name_table+455, }, // separator

- { prop_name_table+455, prop_name_table+457, }, // sk

- { prop_name_table+457, prop_name_table+459, }, // sm

- { prop_name_table+459, prop_name_table+461, }, // so

- { prop_name_table+461, prop_name_table+475, }, // spaceseparator

- { prop_name_table+475, prop_name_table+495, }, // spacingcombiningmark

- { prop_name_table+495, prop_name_table+504, }, // surrogate

- { prop_name_table+504, prop_name_table+510, }, // symbol

- { prop_name_table+510, prop_name_table+519, }, // titlecase

- { prop_name_table+519, prop_name_table+534, }, // titlecaseletter

- { prop_name_table+534, prop_name_table+549, }, // uppercaseletter

- { prop_name_table+549, prop_name_table+551, }, // z*

- { prop_name_table+551, prop_name_table+553, }, // zl

- { prop_name_table+553, prop_name_table+555, }, // zp

- { prop_name_table+555, prop_name_table+557, }, // zs

- };

-

- static const icu_regex_traits::char_class_type icu_class_map[] = {

- icu_regex_traits::mask_any, // any

- icu_regex_traits::mask_ascii, // ascii

- (0x3FFFFFFFu) & ~(U_GC_CN_MASK), // assigned

- U_GC_C_MASK, // c*

- U_GC_CC_MASK, // cc

- U_GC_CF_MASK, // cf

- U_GC_PE_MASK, // closepunctuation

- U_GC_CN_MASK, // cn

- U_GC_CO_MASK, // co

- U_GC_PC_MASK, // connectorpunctuation

- U_GC_CC_MASK, // control

- U_GC_CS_MASK, // cs

- U_GC_SC_MASK, // currencysymbol

- U_GC_PD_MASK, // dashpunctuation

- U_GC_ND_MASK, // decimaldigitnumber

- U_GC_ME_MASK, // enclosingmark

- U_GC_PF_MASK, // finalpunctuation

- U_GC_CF_MASK, // format

- U_GC_PI_MASK, // initialpunctuation

- U_GC_L_MASK, // l*

- U_GC_L_MASK, // letter

- U_GC_NL_MASK, // letternumber

- U_GC_ZL_MASK, // lineseparator

- U_GC_LL_MASK, // ll

- U_GC_LM_MASK, // lm

- U_GC_LO_MASK, // lo

- U_GC_LL_MASK, // lowercaseletter

- U_GC_LT_MASK, // lt

- U_GC_LU_MASK, // lu

- U_GC_M_MASK, // m*

- U_GC_M_MASK, // mark

- U_GC_SM_MASK, // mathsymbol

- U_GC_MC_MASK, // mc

- U_GC_ME_MASK, // me

- U_GC_MN_MASK, // mn

- U_GC_LM_MASK, // modifierletter

- U_GC_SK_MASK, // modifiersymbol

- U_GC_N_MASK, // n*

- U_GC_ND_MASK, // nd

- U_GC_NL_MASK, // nl

- U_GC_NO_MASK, // no

- U_GC_MN_MASK, // nonspacingmark

- U_GC_CN_MASK, // notassigned

- U_GC_N_MASK, // number

- U_GC_PS_MASK, // openpunctuation

- U_GC_C_MASK, // other

- U_GC_LO_MASK, // otherletter

- U_GC_NO_MASK, // othernumber

- U_GC_PO_MASK, // otherpunctuation

- U_GC_SO_MASK, // othersymbol

- U_GC_P_MASK, // p*

- U_GC_ZP_MASK, // paragraphseparator

- U_GC_PC_MASK, // pc

- U_GC_PD_MASK, // pd

- U_GC_PE_MASK, // pe

- U_GC_PF_MASK, // pf

- U_GC_PI_MASK, // pi

- U_GC_PO_MASK, // po

- U_GC_CO_MASK, // privateuse

- U_GC_PS_MASK, // ps

- U_GC_P_MASK, // punctuation

- U_GC_S_MASK, // s*

- U_GC_SC_MASK, // sc

- U_GC_Z_MASK, // separator

- U_GC_SK_MASK, // sk

- U_GC_SM_MASK, // sm

- U_GC_SO_MASK, // so

- U_GC_ZS_MASK, // spaceseparator

- U_GC_MC_MASK, // spacingcombiningmark

- U_GC_CS_MASK, // surrogate

- U_GC_S_MASK, // symbol

- U_GC_LT_MASK, // titlecase

- U_GC_LT_MASK, // titlecaseletter

- U_GC_LU_MASK, // uppercaseletter

- U_GC_Z_MASK, // z*

- U_GC_ZL_MASK, // zl

- U_GC_ZP_MASK, // zp

- U_GC_ZS_MASK, // zs

- };

-

-

- static const re_detail::character_pointer_range< ::UChar32>* ranges_begin = range_data;

- static const re_detail::character_pointer_range< ::UChar32>* ranges_end = range_data + (sizeof(range_data)/sizeof(range_data[0]));

-

- re_detail::character_pointer_range< ::UChar32> t = { p1, p2, };

- const re_detail::character_pointer_range< ::UChar32>* p = std::lower_bound(ranges_begin, ranges_end, t);

- if((p != ranges_end) && (t == *p))

- return icu_class_map[p - ranges_begin];

- return 0;

-}

-

-icu_regex_traits::char_class_type icu_regex_traits::lookup_classname(const char_type* p1, const char_type* p2) const

-{

- static const char_class_type masks[] =

- {

- 0,

- U_GC_L_MASK | U_GC_ND_MASK,

- U_GC_L_MASK,

- mask_blank,

- U_GC_CC_MASK | U_GC_CF_MASK | U_GC_ZL_MASK | U_GC_ZP_MASK,

- U_GC_ND_MASK,

- U_GC_ND_MASK,

- (0x3FFFFFFFu) & ~(U_GC_CC_MASK | U_GC_CF_MASK | U_GC_CS_MASK | U_GC_CN_MASK | U_GC_Z_MASK),

- U_GC_LL_MASK,

- U_GC_LL_MASK,

- ~(U_GC_C_MASK),

- U_GC_P_MASK,

- char_class_type(U_GC_Z_MASK) | mask_space,

- char_class_type(U_GC_Z_MASK) | mask_space,

- U_GC_LU_MASK,

- mask_unicode,

- U_GC_LU_MASK,

- char_class_type(U_GC_L_MASK | U_GC_ND_MASK | U_GC_MN_MASK) | mask_underscore,

- char_class_type(U_GC_L_MASK | U_GC_ND_MASK | U_GC_MN_MASK) | mask_underscore,

- char_class_type(U_GC_ND_MASK) | mask_xdigit,

- };

-

- int id = ::boost::re_detail::get_default_class_id(p1, p2);

- if(id >= 0)

- return masks[id+1];

- char_class_type result = lookup_icu_mask(p1, p2);

- if(result != 0)

- return result;

-

- if(id < 0)

- {

- string_type s(p1, p2);

- string_type::size_type i = 0;

- while(i < s.size())

- {

- s[i] = static_cast<char>((::u_tolower)(s[i]));

- if(::u_isspace(s[i]) || (s[i] == '-') || (s[i] == '_'))

- s.erase(s.begin()+i, s.begin()+i+1);

- else

- {

- s[i] = static_cast<char>((::u_tolower)(s[i]));

- ++i;

- }

- }

- if(s.size())

- id = ::boost::re_detail::get_default_class_id(&*s.begin(), &*s.begin() + s.size());

- if(id >= 0)

- return masks[id+1];

- if(s.size())

- result = lookup_icu_mask(&*s.begin(), &*s.begin() + s.size());

- if(result != 0)

- return result;

- }

- BOOST_ASSERT(std::size_t(id+1) < sizeof(masks) / sizeof(masks[0]));

- return masks[id+1];

-}

-

-icu_regex_traits::string_type icu_regex_traits::lookup_collatename(const char_type* p1, const char_type* p2) const

-{

- string_type result;

- if(std::find_if(p1, p2, std::bind2nd(std::greater< ::UChar32>(), 0x7f)) == p2)

- {

-#ifndef BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS

- std::string s(p1, p2);

-#else

- std::string s;

- const char_type* p3 = p1;

- while(p3 != p2)

- s.append(1, *p3++);

-#endif

- // Try Unicode name:

- UErrorCode err = U_ZERO_ERROR;

- UChar32 c = ::u_charFromName(U_UNICODE_CHAR_NAME, s.c_str(), &err);

- if(U_SUCCESS(err))

- {

- result.push_back(c);

- return result;

- }

- // Try Unicode-extended name:

- err = U_ZERO_ERROR;

- c = ::u_charFromName(U_EXTENDED_CHAR_NAME, s.c_str(), &err);

- if(U_SUCCESS(err))

- {

- result.push_back(c);

- return result;

- }

- // try POSIX name:

- s = ::boost::re_detail::lookup_default_collate_name(s);

-#ifndef BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS

- result.assign(s.begin(), s.end());

-#else

- result.clear();

- std::string::const_iterator si, sj;

- si = s.begin();

- sj = s.end();

- while(si != sj)

- result.push_back(*si++);

-#endif

- }

- if(result.empty() && (p2-p1 == 1))

- result.push_back(*p1);

- return result;

-}

-

-bool icu_regex_traits::isctype(char_type c, char_class_type f) const

-{

- // check for standard catagories first:

- char_class_type m = char_class_type(1u << u_charType(c));

- if((m & f) != 0)

- return true;

- // now check for special cases:

- if(((f & mask_blank) != 0) && u_isblank(c))

- return true;

- if(((f & mask_space) != 0) && u_isspace(c))

- return true;

- if(((f & mask_xdigit) != 0) && (u_digit(c, 16) >= 0))

- return true;

- if(((f & mask_unicode) != 0) && (c >= 0x100))

- return true;

- if(((f & mask_underscore) != 0) && (c == '_'))

- return true;

- if(((f & mask_any) != 0) && (c <= 0x10FFFF))

- return true;

- if(((f & mask_ascii) != 0) && (c <= 0x7F))

- return true;

- return false;

-}

-

-}

-

-#endif // BOOST_HAS_ICU