+++ /dev/null
-/*
- *
- * 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.hpp
- * VERSION see <boost/version.hpp>
- * DESCRIPTION: Unicode regular expressions on top of the ICU Library.
- */
-
-#ifndef BOOST_REGEX_ICU_HPP
-#define BOOST_REGEX_ICU_HPP
-
-#include <unicode/utypes.h>
-#include <unicode/uchar.h>
-#include <unicode/coll.h>
-#include <boost/regex.hpp>
-#include <boost/regex/pending/unicode_iterator.hpp>
-#include <boost/mpl/int_fwd.hpp>
-#include <bitset>
-
-#ifdef BOOST_MSVC
-#pragma warning (push)
-#pragma warning (disable: 4251)
-#endif
-
-namespace boost{
-
-namespace BOOST_REGEX_DETAIL_NS{
-
-//
-// Implementation details:
-//
-class BOOST_REGEX_DECL icu_regex_traits_implementation
-{
- typedef UChar32 char_type;
- typedef std::size_t size_type;
- typedef std::vector<char_type> string_type;
- typedef U_NAMESPACE_QUALIFIER Locale locale_type;
- typedef boost::uint_least32_t char_class_type;
-public:
- icu_regex_traits_implementation(const U_NAMESPACE_QUALIFIER Locale& l)
- : m_locale(l)
- {
- UErrorCode success = U_ZERO_ERROR;
- m_collator.reset(U_NAMESPACE_QUALIFIER Collator::createInstance(l, success));
- if(U_SUCCESS(success) == 0)
- init_error();
- m_collator->setStrength(U_NAMESPACE_QUALIFIER Collator::IDENTICAL);
- success = U_ZERO_ERROR;
- m_primary_collator.reset(U_NAMESPACE_QUALIFIER Collator::createInstance(l, success));
- if(U_SUCCESS(success) == 0)
- init_error();
- m_primary_collator->setStrength(U_NAMESPACE_QUALIFIER Collator::PRIMARY);
- }
- U_NAMESPACE_QUALIFIER Locale getloc()const
- {
- return m_locale;
- }
- string_type do_transform(const char_type* p1, const char_type* p2, const U_NAMESPACE_QUALIFIER Collator* pcoll) const;
- string_type transform(const char_type* p1, const char_type* p2) const
- {
- return do_transform(p1, p2, m_collator.get());
- }
- string_type transform_primary(const char_type* p1, const char_type* p2) const
- {
- return do_transform(p1, p2, m_primary_collator.get());
- }
-private:
- void init_error()
- {
- std::runtime_error e("Could not initialize ICU resources");
- boost::throw_exception(e);
- }
- U_NAMESPACE_QUALIFIER Locale m_locale; // The ICU locale that we're using
- boost::scoped_ptr< U_NAMESPACE_QUALIFIER Collator> m_collator; // The full collation object
- boost::scoped_ptr< U_NAMESPACE_QUALIFIER Collator> m_primary_collator; // The primary collation object
-};
-
-inline boost::shared_ptr<icu_regex_traits_implementation> get_icu_regex_traits_implementation(const U_NAMESPACE_QUALIFIER Locale& loc)
-{
- return boost::shared_ptr<icu_regex_traits_implementation>(new icu_regex_traits_implementation(loc));
-}
-
-}
-
-class BOOST_REGEX_DECL icu_regex_traits
-{
-public:
- typedef UChar32 char_type;
- typedef std::size_t size_type;
- typedef std::vector<char_type> string_type;
- typedef U_NAMESPACE_QUALIFIER Locale locale_type;
-#ifdef BOOST_NO_INT64_T
- typedef std::bitset<64> char_class_type;
-#else
- typedef boost::uint64_t char_class_type;
-#endif
-
- struct boost_extensions_tag{};
-
- icu_regex_traits()
- : m_pimpl(BOOST_REGEX_DETAIL_NS::get_icu_regex_traits_implementation(U_NAMESPACE_QUALIFIER Locale()))
- {
- }
- static size_type length(const char_type* p);
-
- ::boost::regex_constants::syntax_type syntax_type(char_type c)const
- {
- return ((c < 0x7f) && (c > 0)) ? BOOST_REGEX_DETAIL_NS::get_default_syntax_type(static_cast<char>(c)) : regex_constants::syntax_char;
- }
- ::boost::regex_constants::escape_syntax_type escape_syntax_type(char_type c) const
- {
- return ((c < 0x7f) && (c > 0)) ? BOOST_REGEX_DETAIL_NS::get_default_escape_syntax_type(static_cast<char>(c)) : regex_constants::syntax_char;
- }
- char_type translate(char_type c) const
- {
- return c;
- }
- char_type translate_nocase(char_type c) const
- {
- return ::u_tolower(c);
- }
- char_type translate(char_type c, bool icase) const
- {
- return icase ? translate_nocase(c) : translate(c);
- }
- char_type tolower(char_type c) const
- {
- return ::u_tolower(c);
- }
- char_type toupper(char_type c) const
- {
- return ::u_toupper(c);
- }
- string_type transform(const char_type* p1, const char_type* p2) const
- {
- return m_pimpl->transform(p1, p2);
- }
- string_type transform_primary(const char_type* p1, const char_type* p2) const
- {
- return m_pimpl->transform_primary(p1, p2);
- }
- char_class_type lookup_classname(const char_type* p1, const char_type* p2) const;
- string_type lookup_collatename(const char_type* p1, const char_type* p2) const;
- bool isctype(char_type c, char_class_type f) const;
- int toi(const char_type*& p1, const char_type* p2, int radix)const
- {
- return BOOST_REGEX_DETAIL_NS::global_toi(p1, p2, radix, *this);
- }
- int value(char_type c, int radix)const
- {
- return u_digit(c, static_cast< ::int8_t>(radix));
- }
- locale_type imbue(locale_type l)
- {
- locale_type result(m_pimpl->getloc());
- m_pimpl = BOOST_REGEX_DETAIL_NS::get_icu_regex_traits_implementation(l);
- return result;
- }
- locale_type getloc()const
- {
- return locale_type();
- }
- std::string error_string(::boost::regex_constants::error_type n) const
- {
- return BOOST_REGEX_DETAIL_NS::get_default_error_string(n);
- }
-private:
- icu_regex_traits(const icu_regex_traits&);
- icu_regex_traits& operator=(const icu_regex_traits&);
-
- //
- // define the bitmasks offsets we need for additional character properties:
- //
- enum{
- offset_blank = U_CHAR_CATEGORY_COUNT,
- offset_space = U_CHAR_CATEGORY_COUNT+1,
- offset_xdigit = U_CHAR_CATEGORY_COUNT+2,
- offset_underscore = U_CHAR_CATEGORY_COUNT+3,
- offset_unicode = U_CHAR_CATEGORY_COUNT+4,
- offset_any = U_CHAR_CATEGORY_COUNT+5,
- offset_ascii = U_CHAR_CATEGORY_COUNT+6,
- offset_horizontal = U_CHAR_CATEGORY_COUNT+7,
- offset_vertical = U_CHAR_CATEGORY_COUNT+8
- };
-
- //
- // and now the masks:
- //
- static const char_class_type mask_blank;
- static const char_class_type mask_space;
- static const char_class_type mask_xdigit;
- static const char_class_type mask_underscore;
- static const char_class_type mask_unicode;
- static const char_class_type mask_any;
- static const char_class_type mask_ascii;
- static const char_class_type mask_horizontal;
- static const char_class_type mask_vertical;
-
- static char_class_type lookup_icu_mask(const ::UChar32* p1, const ::UChar32* p2);
-
- boost::shared_ptr< ::boost::BOOST_REGEX_DETAIL_NS::icu_regex_traits_implementation> m_pimpl;
-};
-
-} // namespace boost
-
-//
-// template instances:
-//
-#define BOOST_REGEX_CHAR_T UChar32
-#undef BOOST_REGEX_TRAITS_T
-#define BOOST_REGEX_TRAITS_T , icu_regex_traits
-#define BOOST_REGEX_ICU_INSTANCES
-#ifdef BOOST_REGEX_ICU_INSTANTIATE
-# define BOOST_REGEX_INSTANTIATE
-#endif
-#include <boost/regex/v4/instances.hpp>
-#undef BOOST_REGEX_CHAR_T
-#undef BOOST_REGEX_TRAITS_T
-#undef BOOST_REGEX_ICU_INSTANCES
-#ifdef BOOST_REGEX_INSTANTIATE
-# undef BOOST_REGEX_INSTANTIATE
-#endif
-
-namespace boost{
-
-// types:
-typedef basic_regex< ::UChar32, icu_regex_traits> u32regex;
-typedef match_results<const ::UChar32*> u32match;
-typedef match_results<const ::UChar*> u16match;
-
-//
-// Construction of 32-bit regex types from UTF-8 and UTF-16 primitives:
-//
-namespace BOOST_REGEX_DETAIL_NS{
-
-#if !defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(__IBMCPP__)
-template <class InputIterator>
-inline u32regex do_make_u32regex(InputIterator i,
- InputIterator j,
- boost::regex_constants::syntax_option_type opt,
- const boost::mpl::int_<1>*)
-{
- typedef boost::u8_to_u32_iterator<InputIterator, UChar32> conv_type;
- return u32regex(conv_type(i, i, j), conv_type(j, i, j), opt);
-}
-
-template <class InputIterator>
-inline u32regex do_make_u32regex(InputIterator i,
- InputIterator j,
- boost::regex_constants::syntax_option_type opt,
- const boost::mpl::int_<2>*)
-{
- typedef boost::u16_to_u32_iterator<InputIterator, UChar32> conv_type;
- return u32regex(conv_type(i, i, j), conv_type(j, i, j), opt);
-}
-
-template <class InputIterator>
-inline u32regex do_make_u32regex(InputIterator i,
- InputIterator j,
- boost::regex_constants::syntax_option_type opt,
- const boost::mpl::int_<4>*)
-{
- return u32regex(i, j, opt);
-}
-#else
-template <class InputIterator>
-inline u32regex do_make_u32regex(InputIterator i,
- InputIterator j,
- boost::regex_constants::syntax_option_type opt,
- const boost::mpl::int_<1>*)
-{
- typedef boost::u8_to_u32_iterator<InputIterator, UChar32> conv_type;
- typedef std::vector<UChar32> vector_type;
- vector_type v;
- conv_type a(i, i, j), b(j, i, j);
- while(a != b)
- {
- v.push_back(*a);
- ++a;
- }
- if(v.size())
- return u32regex(&*v.begin(), v.size(), opt);
- return u32regex(static_cast<UChar32 const*>(0), static_cast<u32regex::size_type>(0), opt);
-}
-
-template <class InputIterator>
-inline u32regex do_make_u32regex(InputIterator i,
- InputIterator j,
- boost::regex_constants::syntax_option_type opt,
- const boost::mpl::int_<2>*)
-{
- typedef boost::u16_to_u32_iterator<InputIterator, UChar32> conv_type;
- typedef std::vector<UChar32> vector_type;
- vector_type v;
- conv_type a(i, i, j), b(j, i, j);
- while(a != b)
- {
- v.push_back(*a);
- ++a;
- }
- if(v.size())
- return u32regex(&*v.begin(), v.size(), opt);
- return u32regex(static_cast<UChar32 const*>(0), static_cast<u32regex::size_type>(0), opt);
-}
-
-template <class InputIterator>
-inline u32regex do_make_u32regex(InputIterator i,
- InputIterator j,
- boost::regex_constants::syntax_option_type opt,
- const boost::mpl::int_<4>*)
-{
- typedef std::vector<UChar32> vector_type;
- vector_type v;
- while(i != j)
- {
- v.push_back((UChar32)(*i));
- ++i;
- }
- if(v.size())
- return u32regex(&*v.begin(), v.size(), opt);
- return u32regex(static_cast<UChar32 const*>(0), static_cast<u32regex::size_type>(0), opt);
-}
-#endif
-}
-
-//
-// Construction from an iterator pair:
-//
-template <class InputIterator>
-inline u32regex make_u32regex(InputIterator i,
- InputIterator j,
- boost::regex_constants::syntax_option_type opt)
-{
- return BOOST_REGEX_DETAIL_NS::do_make_u32regex(i, j, opt, static_cast<boost::mpl::int_<sizeof(*i)> const*>(0));
-}
-//
-// construction from UTF-8 nul-terminated strings:
-//
-inline u32regex make_u32regex(const char* p, boost::regex_constants::syntax_option_type opt = boost::regex_constants::perl)
-{
- return BOOST_REGEX_DETAIL_NS::do_make_u32regex(p, p + std::strlen(p), opt, static_cast<boost::mpl::int_<1> const*>(0));
-}
-inline u32regex make_u32regex(const unsigned char* p, boost::regex_constants::syntax_option_type opt = boost::regex_constants::perl)
-{
- return BOOST_REGEX_DETAIL_NS::do_make_u32regex(p, p + std::strlen(reinterpret_cast<const char*>(p)), opt, static_cast<boost::mpl::int_<1> const*>(0));
-}
-//
-// construction from UTF-16 nul-terminated strings:
-//
-#ifndef BOOST_NO_WREGEX
-inline u32regex make_u32regex(const wchar_t* p, boost::regex_constants::syntax_option_type opt = boost::regex_constants::perl)
-{
- return BOOST_REGEX_DETAIL_NS::do_make_u32regex(p, p + std::wcslen(p), opt, static_cast<boost::mpl::int_<sizeof(wchar_t)> const*>(0));
-}
-#endif
-#if !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2)
-inline u32regex make_u32regex(const UChar* p, boost::regex_constants::syntax_option_type opt = boost::regex_constants::perl)
-{
- return BOOST_REGEX_DETAIL_NS::do_make_u32regex(p, p + u_strlen(p), opt, static_cast<boost::mpl::int_<2> const*>(0));
-}
-#endif
-//
-// construction from basic_string class-template:
-//
-template<class C, class T, class A>
-inline u32regex make_u32regex(const std::basic_string<C, T, A>& s, boost::regex_constants::syntax_option_type opt = boost::regex_constants::perl)
-{
- return BOOST_REGEX_DETAIL_NS::do_make_u32regex(s.begin(), s.end(), opt, static_cast<boost::mpl::int_<sizeof(C)> const*>(0));
-}
-//
-// Construction from ICU string type:
-//
-inline u32regex make_u32regex(const U_NAMESPACE_QUALIFIER UnicodeString& s, boost::regex_constants::syntax_option_type opt = boost::regex_constants::perl)
-{
- return BOOST_REGEX_DETAIL_NS::do_make_u32regex(s.getBuffer(), s.getBuffer() + s.length(), opt, static_cast<boost::mpl::int_<2> const*>(0));
-}
-
-//
-// regex_match overloads that widen the character type as appropriate:
-//
-namespace BOOST_REGEX_DETAIL_NS{
-template<class MR1, class MR2>
-void copy_results(MR1& out, MR2 const& in)
-{
- // copy results from an adapted MR2 match_results:
- out.set_size(in.size(), in.prefix().first.base(), in.suffix().second.base());
- out.set_base(in.base().base());
- for(int i = 0; i < (int)in.size(); ++i)
- {
- if(in[i].matched || !i)
- {
- out.set_first(in[i].first.base(), i);
- out.set_second(in[i].second.base(), i, in[i].matched);
- }
- }
-}
-
-template <class BidiIterator, class Allocator>
-inline bool do_regex_match(BidiIterator first, BidiIterator last,
- match_results<BidiIterator, Allocator>& m,
- const u32regex& e,
- match_flag_type flags,
- boost::mpl::int_<4> const*)
-{
- return ::boost::regex_match(first, last, m, e, flags);
-}
-template <class BidiIterator, class Allocator>
-bool do_regex_match(BidiIterator first, BidiIterator last,
- match_results<BidiIterator, Allocator>& m,
- const u32regex& e,
- match_flag_type flags,
- boost::mpl::int_<2> const*)
-{
- typedef u16_to_u32_iterator<BidiIterator, UChar32> conv_type;
- typedef match_results<conv_type> match_type;
- //typedef typename match_type::allocator_type alloc_type;
- match_type what;
- bool result = ::boost::regex_match(conv_type(first, first, last), conv_type(last, first, last), what, e, flags);
- // copy results across to m:
- if(result) copy_results(m, what);
- return result;
-}
-template <class BidiIterator, class Allocator>
-bool do_regex_match(BidiIterator first, BidiIterator last,
- match_results<BidiIterator, Allocator>& m,
- const u32regex& e,
- match_flag_type flags,
- boost::mpl::int_<1> const*)
-{
- typedef u8_to_u32_iterator<BidiIterator, UChar32> conv_type;
- typedef match_results<conv_type> match_type;
- //typedef typename match_type::allocator_type alloc_type;
- match_type what;
- bool result = ::boost::regex_match(conv_type(first, first, last), conv_type(last, first, last), what, e, flags);
- // copy results across to m:
- if(result) copy_results(m, what);
- return result;
-}
-} // namespace BOOST_REGEX_DETAIL_NS
-
-template <class BidiIterator, class Allocator>
-inline bool u32regex_match(BidiIterator first, BidiIterator last,
- match_results<BidiIterator, Allocator>& m,
- const u32regex& e,
- match_flag_type flags = match_default)
-{
- return BOOST_REGEX_DETAIL_NS::do_regex_match(first, last, m, e, flags, static_cast<mpl::int_<sizeof(*first)> const*>(0));
-}
-inline bool u32regex_match(const UChar* p,
- match_results<const UChar*>& m,
- const u32regex& e,
- match_flag_type flags = match_default)
-{
- return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+u_strlen(p), m, e, flags, static_cast<mpl::int_<2> const*>(0));
-}
-#if !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2) && !defined(BOOST_NO_WREGEX)
-inline bool u32regex_match(const wchar_t* p,
- match_results<const wchar_t*>& m,
- const u32regex& e,
- match_flag_type flags = match_default)
-{
- return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+std::wcslen(p), m, e, flags, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
-}
-#endif
-inline bool u32regex_match(const char* p,
- match_results<const char*>& m,
- const u32regex& e,
- match_flag_type flags = match_default)
-{
- return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+std::strlen(p), m, e, flags, static_cast<mpl::int_<1> const*>(0));
-}
-inline bool u32regex_match(const unsigned char* p,
- match_results<const unsigned char*>& m,
- const u32regex& e,
- match_flag_type flags = match_default)
-{
- return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+std::strlen((const char*)p), m, e, flags, static_cast<mpl::int_<1> const*>(0));
-}
-inline bool u32regex_match(const std::string& s,
- match_results<std::string::const_iterator>& m,
- const u32regex& e,
- match_flag_type flags = match_default)
-{
- return BOOST_REGEX_DETAIL_NS::do_regex_match(s.begin(), s.end(), m, e, flags, static_cast<mpl::int_<1> const*>(0));
-}
-#ifndef BOOST_NO_STD_WSTRING
-inline bool u32regex_match(const std::wstring& s,
- match_results<std::wstring::const_iterator>& m,
- const u32regex& e,
- match_flag_type flags = match_default)
-{
- return BOOST_REGEX_DETAIL_NS::do_regex_match(s.begin(), s.end(), m, e, flags, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
-}
-#endif
-inline bool u32regex_match(const U_NAMESPACE_QUALIFIER UnicodeString& s,
- match_results<const UChar*>& m,
- const u32regex& e,
- match_flag_type flags = match_default)
-{
- return BOOST_REGEX_DETAIL_NS::do_regex_match(s.getBuffer(), s.getBuffer() + s.length(), m, e, flags, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
-}
-//
-// regex_match overloads that do not return what matched:
-//
-template <class BidiIterator>
-inline bool u32regex_match(BidiIterator first, BidiIterator last,
- const u32regex& e,
- match_flag_type flags = match_default)
-{
- match_results<BidiIterator> m;
- return BOOST_REGEX_DETAIL_NS::do_regex_match(first, last, m, e, flags, static_cast<mpl::int_<sizeof(*first)> const*>(0));
-}
-inline bool u32regex_match(const UChar* p,
- const u32regex& e,
- match_flag_type flags = match_default)
-{
- match_results<const UChar*> m;
- return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+u_strlen(p), m, e, flags, static_cast<mpl::int_<2> const*>(0));
-}
-#if !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2) && !defined(BOOST_NO_WREGEX)
-inline bool u32regex_match(const wchar_t* p,
- const u32regex& e,
- match_flag_type flags = match_default)
-{
- match_results<const wchar_t*> m;
- return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+std::wcslen(p), m, e, flags, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
-}
-#endif
-inline bool u32regex_match(const char* p,
- const u32regex& e,
- match_flag_type flags = match_default)
-{
- match_results<const char*> m;
- return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+std::strlen(p), m, e, flags, static_cast<mpl::int_<1> const*>(0));
-}
-inline bool u32regex_match(const unsigned char* p,
- const u32regex& e,
- match_flag_type flags = match_default)
-{
- match_results<const unsigned char*> m;
- return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+std::strlen((const char*)p), m, e, flags, static_cast<mpl::int_<1> const*>(0));
-}
-inline bool u32regex_match(const std::string& s,
- const u32regex& e,
- match_flag_type flags = match_default)
-{
- match_results<std::string::const_iterator> m;
- return BOOST_REGEX_DETAIL_NS::do_regex_match(s.begin(), s.end(), m, e, flags, static_cast<mpl::int_<1> const*>(0));
-}
-#ifndef BOOST_NO_STD_WSTRING
-inline bool u32regex_match(const std::wstring& s,
- const u32regex& e,
- match_flag_type flags = match_default)
-{
- match_results<std::wstring::const_iterator> m;
- return BOOST_REGEX_DETAIL_NS::do_regex_match(s.begin(), s.end(), m, e, flags, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
-}
-#endif
-inline bool u32regex_match(const U_NAMESPACE_QUALIFIER UnicodeString& s,
- const u32regex& e,
- match_flag_type flags = match_default)
-{
- match_results<const UChar*> m;
- return BOOST_REGEX_DETAIL_NS::do_regex_match(s.getBuffer(), s.getBuffer() + s.length(), m, e, flags, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
-}
-
-//
-// regex_search overloads that widen the character type as appropriate:
-//
-namespace BOOST_REGEX_DETAIL_NS{
-template <class BidiIterator, class Allocator>
-inline bool do_regex_search(BidiIterator first, BidiIterator last,
- match_results<BidiIterator, Allocator>& m,
- const u32regex& e,
- match_flag_type flags,
- BidiIterator base,
- boost::mpl::int_<4> const*)
-{
- return ::boost::regex_search(first, last, m, e, flags, base);
-}
-template <class BidiIterator, class Allocator>
-bool do_regex_search(BidiIterator first, BidiIterator last,
- match_results<BidiIterator, Allocator>& m,
- const u32regex& e,
- match_flag_type flags,
- BidiIterator base,
- boost::mpl::int_<2> const*)
-{
- typedef u16_to_u32_iterator<BidiIterator, UChar32> conv_type;
- typedef match_results<conv_type> match_type;
- //typedef typename match_type::allocator_type alloc_type;
- match_type what;
- bool result = ::boost::regex_search(conv_type(first, first, last), conv_type(last, first, last), what, e, flags, conv_type(base));
- // copy results across to m:
- if(result) copy_results(m, what);
- return result;
-}
-template <class BidiIterator, class Allocator>
-bool do_regex_search(BidiIterator first, BidiIterator last,
- match_results<BidiIterator, Allocator>& m,
- const u32regex& e,
- match_flag_type flags,
- BidiIterator base,
- boost::mpl::int_<1> const*)
-{
- typedef u8_to_u32_iterator<BidiIterator, UChar32> conv_type;
- typedef match_results<conv_type> match_type;
- //typedef typename match_type::allocator_type alloc_type;
- match_type what;
- bool result = ::boost::regex_search(conv_type(first, first, last), conv_type(last, first, last), what, e, flags, conv_type(base));
- // copy results across to m:
- if(result) copy_results(m, what);
- return result;
-}
-}
-
-template <class BidiIterator, class Allocator>
-inline bool u32regex_search(BidiIterator first, BidiIterator last,
- match_results<BidiIterator, Allocator>& m,
- const u32regex& e,
- match_flag_type flags = match_default)
-{
- return BOOST_REGEX_DETAIL_NS::do_regex_search(first, last, m, e, flags, first, static_cast<mpl::int_<sizeof(*first)> const*>(0));
-}
-template <class BidiIterator, class Allocator>
-inline bool u32regex_search(BidiIterator first, BidiIterator last,
- match_results<BidiIterator, Allocator>& m,
- const u32regex& e,
- match_flag_type flags,
- BidiIterator base)
-{
- return BOOST_REGEX_DETAIL_NS::do_regex_search(first, last, m, e, flags, base, static_cast<mpl::int_<sizeof(*first)> const*>(0));
-}
-inline bool u32regex_search(const UChar* p,
- match_results<const UChar*>& m,
- const u32regex& e,
- match_flag_type flags = match_default)
-{
- return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+u_strlen(p), m, e, flags, p, static_cast<mpl::int_<2> const*>(0));
-}
-#if !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2) && !defined(BOOST_NO_WREGEX)
-inline bool u32regex_search(const wchar_t* p,
- match_results<const wchar_t*>& m,
- const u32regex& e,
- match_flag_type flags = match_default)
-{
- return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+std::wcslen(p), m, e, flags, p, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
-}
-#endif
-inline bool u32regex_search(const char* p,
- match_results<const char*>& m,
- const u32regex& e,
- match_flag_type flags = match_default)
-{
- return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+std::strlen(p), m, e, flags, p, static_cast<mpl::int_<1> const*>(0));
-}
-inline bool u32regex_search(const unsigned char* p,
- match_results<const unsigned char*>& m,
- const u32regex& e,
- match_flag_type flags = match_default)
-{
- return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+std::strlen((const char*)p), m, e, flags, p, static_cast<mpl::int_<1> const*>(0));
-}
-inline bool u32regex_search(const std::string& s,
- match_results<std::string::const_iterator>& m,
- const u32regex& e,
- match_flag_type flags = match_default)
-{
- return BOOST_REGEX_DETAIL_NS::do_regex_search(s.begin(), s.end(), m, e, flags, s.begin(), static_cast<mpl::int_<1> const*>(0));
-}
-#ifndef BOOST_NO_STD_WSTRING
-inline bool u32regex_search(const std::wstring& s,
- match_results<std::wstring::const_iterator>& m,
- const u32regex& e,
- match_flag_type flags = match_default)
-{
- return BOOST_REGEX_DETAIL_NS::do_regex_search(s.begin(), s.end(), m, e, flags, s.begin(), static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
-}
-#endif
-inline bool u32regex_search(const U_NAMESPACE_QUALIFIER UnicodeString& s,
- match_results<const UChar*>& m,
- const u32regex& e,
- match_flag_type flags = match_default)
-{
- return BOOST_REGEX_DETAIL_NS::do_regex_search(s.getBuffer(), s.getBuffer() + s.length(), m, e, flags, s.getBuffer(), static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
-}
-template <class BidiIterator>
-inline bool u32regex_search(BidiIterator first, BidiIterator last,
- const u32regex& e,
- match_flag_type flags = match_default)
-{
- match_results<BidiIterator> m;
- return BOOST_REGEX_DETAIL_NS::do_regex_search(first, last, m, e, flags, first, static_cast<mpl::int_<sizeof(*first)> const*>(0));
-}
-inline bool u32regex_search(const UChar* p,
- const u32regex& e,
- match_flag_type flags = match_default)
-{
- match_results<const UChar*> m;
- return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+u_strlen(p), m, e, flags, p, static_cast<mpl::int_<2> const*>(0));
-}
-#if !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2) && !defined(BOOST_NO_WREGEX)
-inline bool u32regex_search(const wchar_t* p,
- const u32regex& e,
- match_flag_type flags = match_default)
-{
- match_results<const wchar_t*> m;
- return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+std::wcslen(p), m, e, flags, p, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
-}
-#endif
-inline bool u32regex_search(const char* p,
- const u32regex& e,
- match_flag_type flags = match_default)
-{
- match_results<const char*> m;
- return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+std::strlen(p), m, e, flags, p, static_cast<mpl::int_<1> const*>(0));
-}
-inline bool u32regex_search(const unsigned char* p,
- const u32regex& e,
- match_flag_type flags = match_default)
-{
- match_results<const unsigned char*> m;
- return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+std::strlen((const char*)p), m, e, flags, p, static_cast<mpl::int_<1> const*>(0));
-}
-inline bool u32regex_search(const std::string& s,
- const u32regex& e,
- match_flag_type flags = match_default)
-{
- match_results<std::string::const_iterator> m;
- return BOOST_REGEX_DETAIL_NS::do_regex_search(s.begin(), s.end(), m, e, flags, s.begin(), static_cast<mpl::int_<1> const*>(0));
-}
-#ifndef BOOST_NO_STD_WSTRING
-inline bool u32regex_search(const std::wstring& s,
- const u32regex& e,
- match_flag_type flags = match_default)
-{
- match_results<std::wstring::const_iterator> m;
- return BOOST_REGEX_DETAIL_NS::do_regex_search(s.begin(), s.end(), m, e, flags, s.begin(), static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
-}
-#endif
-inline bool u32regex_search(const U_NAMESPACE_QUALIFIER UnicodeString& s,
- const u32regex& e,
- match_flag_type flags = match_default)
-{
- match_results<const UChar*> m;
- return BOOST_REGEX_DETAIL_NS::do_regex_search(s.getBuffer(), s.getBuffer() + s.length(), m, e, flags, s.getBuffer(), static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
-}
-
-//
-// overloads for regex_replace with utf-8 and utf-16 data types:
-//
-namespace BOOST_REGEX_DETAIL_NS{
-template <class I>
-inline std::pair< boost::u8_to_u32_iterator<I>, boost::u8_to_u32_iterator<I> >
- make_utf32_seq(I i, I j, mpl::int_<1> const*)
-{
- return std::pair< boost::u8_to_u32_iterator<I>, boost::u8_to_u32_iterator<I> >(boost::u8_to_u32_iterator<I>(i, i, j), boost::u8_to_u32_iterator<I>(j, i, j));
-}
-template <class I>
-inline std::pair< boost::u16_to_u32_iterator<I>, boost::u16_to_u32_iterator<I> >
- make_utf32_seq(I i, I j, mpl::int_<2> const*)
-{
- return std::pair< boost::u16_to_u32_iterator<I>, boost::u16_to_u32_iterator<I> >(boost::u16_to_u32_iterator<I>(i, i, j), boost::u16_to_u32_iterator<I>(j, i, j));
-}
-template <class I>
-inline std::pair< I, I >
- make_utf32_seq(I i, I j, mpl::int_<4> const*)
-{
- return std::pair< I, I >(i, j);
-}
-template <class charT>
-inline std::pair< boost::u8_to_u32_iterator<const charT*>, boost::u8_to_u32_iterator<const charT*> >
- make_utf32_seq(const charT* p, mpl::int_<1> const*)
-{
- std::size_t len = std::strlen((const char*)p);
- return std::pair< boost::u8_to_u32_iterator<const charT*>, boost::u8_to_u32_iterator<const charT*> >(boost::u8_to_u32_iterator<const charT*>(p, p, p+len), boost::u8_to_u32_iterator<const charT*>(p+len, p, p+len));
-}
-template <class charT>
-inline std::pair< boost::u16_to_u32_iterator<const charT*>, boost::u16_to_u32_iterator<const charT*> >
- make_utf32_seq(const charT* p, mpl::int_<2> const*)
-{
- std::size_t len = u_strlen((const UChar*)p);
- return std::pair< boost::u16_to_u32_iterator<const charT*>, boost::u16_to_u32_iterator<const charT*> >(boost::u16_to_u32_iterator<const charT*>(p, p, p + len), boost::u16_to_u32_iterator<const charT*>(p+len, p, p + len));
-}
-template <class charT>
-inline std::pair< const charT*, const charT* >
- make_utf32_seq(const charT* p, mpl::int_<4> const*)
-{
- return std::pair< const charT*, const charT* >(p, p+icu_regex_traits::length((UChar32 const*)p));
-}
-template <class OutputIterator>
-inline OutputIterator make_utf32_out(OutputIterator o, mpl::int_<4> const*)
-{
- return o;
-}
-template <class OutputIterator>
-inline utf16_output_iterator<OutputIterator> make_utf32_out(OutputIterator o, mpl::int_<2> const*)
-{
- return o;
-}
-template <class OutputIterator>
-inline utf8_output_iterator<OutputIterator> make_utf32_out(OutputIterator o, mpl::int_<1> const*)
-{
- return o;
-}
-
-template <class OutputIterator, class I1, class I2>
-OutputIterator do_regex_replace(OutputIterator out,
- std::pair<I1, I1> const& in,
- const u32regex& e,
- const std::pair<I2, I2>& fmt,
- match_flag_type flags
- )
-{
- // unfortunately we have to copy the format string in order to pass in onward:
- std::vector<UChar32> f;
-#ifndef BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
- f.assign(fmt.first, fmt.second);
-#else
- f.clear();
- I2 pos = fmt.first;
- while(pos != fmt.second)
- f.push_back(*pos++);
-#endif
-
- regex_iterator<I1, UChar32, icu_regex_traits> i(in.first, in.second, e, flags);
- regex_iterator<I1, UChar32, icu_regex_traits> j;
- if(i == j)
- {
- if(!(flags & regex_constants::format_no_copy))
- out = BOOST_REGEX_DETAIL_NS::copy(in.first, in.second, out);
- }
- else
- {
- I1 last_m = in.first;
- while(i != j)
- {
- if(!(flags & regex_constants::format_no_copy))
- out = BOOST_REGEX_DETAIL_NS::copy(i->prefix().first, i->prefix().second, out);
- if(f.size())
- out = ::boost::BOOST_REGEX_DETAIL_NS::regex_format_imp(out, *i, &*f.begin(), &*f.begin() + f.size(), flags, e.get_traits());
- else
- out = ::boost::BOOST_REGEX_DETAIL_NS::regex_format_imp(out, *i, static_cast<UChar32 const*>(0), static_cast<UChar32 const*>(0), flags, e.get_traits());
- last_m = (*i)[0].second;
- if(flags & regex_constants::format_first_only)
- break;
- ++i;
- }
- if(!(flags & regex_constants::format_no_copy))
- out = BOOST_REGEX_DETAIL_NS::copy(last_m, in.second, out);
- }
- return out;
-}
-template <class BaseIterator>
-inline const BaseIterator& extract_output_base(const BaseIterator& b)
-{
- return b;
-}
-template <class BaseIterator>
-inline BaseIterator extract_output_base(const utf8_output_iterator<BaseIterator>& b)
-{
- return b.base();
-}
-template <class BaseIterator>
-inline BaseIterator extract_output_base(const utf16_output_iterator<BaseIterator>& b)
-{
- return b.base();
-}
-} // BOOST_REGEX_DETAIL_NS
-
-template <class OutputIterator, class BidirectionalIterator, class charT>
-inline OutputIterator u32regex_replace(OutputIterator out,
- BidirectionalIterator first,
- BidirectionalIterator last,
- const u32regex& e,
- const charT* fmt,
- match_flag_type flags = match_default)
-{
- return BOOST_REGEX_DETAIL_NS::extract_output_base
- (
- BOOST_REGEX_DETAIL_NS::do_regex_replace(
- BOOST_REGEX_DETAIL_NS::make_utf32_out(out, static_cast<mpl::int_<sizeof(*first)> const*>(0)),
- BOOST_REGEX_DETAIL_NS::make_utf32_seq(first, last, static_cast<mpl::int_<sizeof(*first)> const*>(0)),
- e,
- BOOST_REGEX_DETAIL_NS::make_utf32_seq(fmt, static_cast<mpl::int_<sizeof(*fmt)> const*>(0)),
- flags)
- );
-}
-
-template <class OutputIterator, class Iterator, class charT>
-inline OutputIterator u32regex_replace(OutputIterator out,
- Iterator first,
- Iterator last,
- const u32regex& e,
- const std::basic_string<charT>& fmt,
- match_flag_type flags = match_default)
-{
- return BOOST_REGEX_DETAIL_NS::extract_output_base
- (
- BOOST_REGEX_DETAIL_NS::do_regex_replace(
- BOOST_REGEX_DETAIL_NS::make_utf32_out(out, static_cast<mpl::int_<sizeof(*first)> const*>(0)),
- BOOST_REGEX_DETAIL_NS::make_utf32_seq(first, last, static_cast<mpl::int_<sizeof(*first)> const*>(0)),
- e,
- BOOST_REGEX_DETAIL_NS::make_utf32_seq(fmt.begin(), fmt.end(), static_cast<mpl::int_<sizeof(charT)> const*>(0)),
- flags)
- );
-}
-
-template <class OutputIterator, class Iterator>
-inline OutputIterator u32regex_replace(OutputIterator out,
- Iterator first,
- Iterator last,
- const u32regex& e,
- const U_NAMESPACE_QUALIFIER UnicodeString& fmt,
- match_flag_type flags = match_default)
-{
- return BOOST_REGEX_DETAIL_NS::extract_output_base
- (
- BOOST_REGEX_DETAIL_NS::do_regex_replace(
- BOOST_REGEX_DETAIL_NS::make_utf32_out(out, static_cast<mpl::int_<sizeof(*first)> const*>(0)),
- BOOST_REGEX_DETAIL_NS::make_utf32_seq(first, last, static_cast<mpl::int_<sizeof(*first)> const*>(0)),
- e,
- BOOST_REGEX_DETAIL_NS::make_utf32_seq(fmt.getBuffer(), fmt.getBuffer() + fmt.length(), static_cast<mpl::int_<2> const*>(0)),
- flags)
- );
-}
-
-template <class charT>
-std::basic_string<charT> u32regex_replace(const std::basic_string<charT>& s,
- const u32regex& e,
- const charT* fmt,
- match_flag_type flags = match_default)
-{
- std::basic_string<charT> result;
- BOOST_REGEX_DETAIL_NS::string_out_iterator<std::basic_string<charT> > i(result);
- u32regex_replace(i, s.begin(), s.end(), e, fmt, flags);
- return result;
-}
-
-template <class charT>
-std::basic_string<charT> u32regex_replace(const std::basic_string<charT>& s,
- const u32regex& e,
- const std::basic_string<charT>& fmt,
- match_flag_type flags = match_default)
-{
- std::basic_string<charT> result;
- BOOST_REGEX_DETAIL_NS::string_out_iterator<std::basic_string<charT> > i(result);
- u32regex_replace(i, s.begin(), s.end(), e, fmt.c_str(), flags);
- return result;
-}
-
-namespace BOOST_REGEX_DETAIL_NS{
-
-class unicode_string_out_iterator
-{
- U_NAMESPACE_QUALIFIER UnicodeString* out;
-public:
- unicode_string_out_iterator(U_NAMESPACE_QUALIFIER UnicodeString& s) : out(&s) {}
- unicode_string_out_iterator& operator++() { return *this; }
- unicode_string_out_iterator& operator++(int) { return *this; }
- unicode_string_out_iterator& operator*() { return *this; }
- unicode_string_out_iterator& operator=(UChar v)
- {
- *out += v;
- return *this;
- }
- typedef std::ptrdiff_t difference_type;
- typedef UChar value_type;
- typedef value_type* pointer;
- typedef value_type& reference;
- typedef std::output_iterator_tag iterator_category;
-};
-
-}
-
-inline U_NAMESPACE_QUALIFIER UnicodeString u32regex_replace(const U_NAMESPACE_QUALIFIER UnicodeString& s,
- const u32regex& e,
- const UChar* fmt,
- match_flag_type flags = match_default)
-{
- U_NAMESPACE_QUALIFIER UnicodeString result;
- BOOST_REGEX_DETAIL_NS::unicode_string_out_iterator i(result);
- u32regex_replace(i, s.getBuffer(), s.getBuffer()+s.length(), e, fmt, flags);
- return result;
-}
-
-inline U_NAMESPACE_QUALIFIER UnicodeString u32regex_replace(const U_NAMESPACE_QUALIFIER UnicodeString& s,
- const u32regex& e,
- const U_NAMESPACE_QUALIFIER UnicodeString& fmt,
- match_flag_type flags = match_default)
-{
- U_NAMESPACE_QUALIFIER UnicodeString result;
- BOOST_REGEX_DETAIL_NS::unicode_string_out_iterator i(result);
- BOOST_REGEX_DETAIL_NS::do_regex_replace(
- BOOST_REGEX_DETAIL_NS::make_utf32_out(i, static_cast<mpl::int_<2> const*>(0)),
- BOOST_REGEX_DETAIL_NS::make_utf32_seq(s.getBuffer(), s.getBuffer()+s.length(), static_cast<mpl::int_<2> const*>(0)),
- e,
- BOOST_REGEX_DETAIL_NS::make_utf32_seq(fmt.getBuffer(), fmt.getBuffer() + fmt.length(), static_cast<mpl::int_<2> const*>(0)),
- flags);
- return result;
-}
-
-} // namespace boost.
-
-#ifdef BOOST_MSVC
-#pragma warning (pop)
-#endif
-
-#include <boost/regex/v4/u32regex_iterator.hpp>
-#include <boost/regex/v4/u32regex_token_iterator.hpp>
-
-#endif
+++ /dev/null
-/*
- *
- * 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>
-
-#ifdef BOOST_INTEL
-#pragma warning(disable:981 2259 383)
-#endif
-
-namespace boost{
-
-namespace BOOST_REGEX_DETAIL_NS{
-
-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;
-const icu_regex_traits::char_class_type icu_regex_traits::mask_horizontal = icu_regex_traits::char_class_type(1) << offset_horizontal;
-const icu_regex_traits::char_class_type icu_regex_traits::mask_vertical = icu_regex_traits::char_class_type(1) << offset_vertical;
-
-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 BOOST_REGEX_DETAIL_NS::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 BOOST_REGEX_DETAIL_NS::character_pointer_range< ::UChar32>* ranges_begin = range_data;
- static const BOOST_REGEX_DETAIL_NS::character_pointer_range< ::UChar32>* ranges_end = range_data + (sizeof(range_data)/sizeof(range_data[0]));
-
- BOOST_REGEX_DETAIL_NS::character_pointer_range< ::UChar32> t = { p1, p2, };
- const BOOST_REGEX_DETAIL_NS::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),
- mask_horizontal,
- 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,
- mask_vertical,
- 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 idx = ::boost::BOOST_REGEX_DETAIL_NS::get_default_class_id(p1, p2);
- if(idx >= 0)
- return masks[idx+1];
- char_class_type result = lookup_icu_mask(p1, p2);
- if(result != 0)
- return result;
-
- if(idx < 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())
- idx = ::boost::BOOST_REGEX_DETAIL_NS::get_default_class_id(&*s.begin(), &*s.begin() + s.size());
- if(idx >= 0)
- return masks[idx+1];
- if(s.size())
- result = lookup_icu_mask(&*s.begin(), &*s.begin() + s.size());
- if(result != 0)
- return result;
- }
- BOOST_ASSERT(std::size_t(idx+1) < sizeof(masks) / sizeof(masks[0]));
- return masks[idx+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::BOOST_REGEX_DETAIL_NS::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;
- if(((f & mask_vertical) != 0) && (::boost::BOOST_REGEX_DETAIL_NS::is_separator(c) || (c == static_cast<char_type>('\v')) || (m == U_GC_ZL_MASK) || (m == U_GC_ZP_MASK)))
- return true;
- if(((f & mask_horizontal) != 0) && !::boost::BOOST_REGEX_DETAIL_NS::is_separator(c) && u_isspace(c) && (c != static_cast<char_type>('\v')))
- return true;
- return false;
-}
-
-}
-
-#endif // BOOST_HAS_ICU