From: Georg Baum Date: Wed, 15 Jun 2016 20:21:21 +0000 (+0200) Subject: Fix boost packaging X-Git-Tag: 2.3.0alpha1~1443 X-Git-Url: https://git.lyx.org/gitweb/?a=commitdiff_plain;h=d32f8f326a01ca9257667ff3cf5c2e103f3b5596;p=features.git Fix boost packaging icu.{hpp,cpp} is not needed and cannot be compiled since it depends on libicu. The other two files are currently not used, but could be in principle, so I added them to the build. --- diff --git a/3rdparty/boost/Makefile.am b/3rdparty/boost/Makefile.am index 7bd1ff0113..a273de15a3 100644 --- a/3rdparty/boost/Makefile.am +++ b/3rdparty/boost/Makefile.am @@ -7,7 +7,9 @@ EXTRA_DIST = boost \ LICENSE_1_0.txt \ libs/CMakeLists.txt \ libs/regex/CMakeLists.txt \ - libs/regex/src/CMakeLists.txt + libs/regex/src/CMakeLists.txt \ + libs/regex/src/usinstances.cpp +# The last file above is only compiled for msvc (see cmake) AM_CPPFLAGS += -DBOOST_USER_CONFIG="" AM_CPPFLAGS += $(BOOST_INCLUDES) @@ -20,8 +22,8 @@ liblyxboost_a_SOURCES = \ lyxboost.cpp \ libs/regex/src/instances.cpp \ libs/regex/src/cpp_regex_traits.cpp \ - libs/regex/src/c_regex_traits.cpp - + libs/regex/src/c_regex_traits.cpp \ + libs/regex/src/wc_regex_traits.cpp else @@ -38,6 +40,7 @@ liblyxboost_a_SOURCES = \ libs/regex/src/regex_raw_buffer.cpp \ libs/regex/src/regex_traits_defaults.cpp \ libs/regex/src/w32_regex_traits.cpp \ + libs/regex/src/wc_regex_traits.cpp \ libs/regex/src/wide_posix_api.cpp \ libs/regex/src/winstances.cpp \ libs/regex/src/static_mutex.cpp diff --git a/3rdparty/boost/boost/regex/icu.hpp b/3rdparty/boost/boost/regex/icu.hpp deleted file mode 100644 index a70aa0da81..0000000000 --- a/3rdparty/boost/boost/regex/icu.hpp +++ /dev/null @@ -1,1022 +0,0 @@ -/* - * - * 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 - * DESCRIPTION: Unicode regular expressions on top of the ICU Library. - */ - -#ifndef BOOST_REGEX_ICU_HPP -#define BOOST_REGEX_ICU_HPP - -#include -#include -#include -#include -#include -#include -#include - -#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 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 get_icu_regex_traits_implementation(const U_NAMESPACE_QUALIFIER Locale& loc) -{ - return boost::shared_ptr(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 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(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(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 -#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 u32match; -typedef match_results 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 -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 conv_type; - return u32regex(conv_type(i, i, j), conv_type(j, i, j), opt); -} - -template -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 conv_type; - return u32regex(conv_type(i, i, j), conv_type(j, i, j), opt); -} - -template -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 -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 conv_type; - typedef std::vector 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(0), static_cast(0), opt); -} - -template -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 conv_type; - typedef std::vector 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(0), static_cast(0), opt); -} - -template -inline u32regex do_make_u32regex(InputIterator i, - InputIterator j, - boost::regex_constants::syntax_option_type opt, - const boost::mpl::int_<4>*) -{ - typedef std::vector 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(0), static_cast(0), opt); -} -#endif -} - -// -// Construction from an iterator pair: -// -template -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 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 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(p)), opt, static_cast 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 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 const*>(0)); -} -#endif -// -// construction from basic_string class-template: -// -template -inline u32regex make_u32regex(const std::basic_string& 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 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 const*>(0)); -} - -// -// regex_match overloads that widen the character type as appropriate: -// -namespace BOOST_REGEX_DETAIL_NS{ -template -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 -inline bool do_regex_match(BidiIterator first, BidiIterator last, - match_results& m, - const u32regex& e, - match_flag_type flags, - boost::mpl::int_<4> const*) -{ - return ::boost::regex_match(first, last, m, e, flags); -} -template -bool do_regex_match(BidiIterator first, BidiIterator last, - match_results& m, - const u32regex& e, - match_flag_type flags, - boost::mpl::int_<2> const*) -{ - typedef u16_to_u32_iterator conv_type; - typedef match_results 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 -bool do_regex_match(BidiIterator first, BidiIterator last, - match_results& m, - const u32regex& e, - match_flag_type flags, - boost::mpl::int_<1> const*) -{ - typedef u8_to_u32_iterator conv_type; - typedef match_results 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 -inline bool u32regex_match(BidiIterator first, BidiIterator last, - match_results& 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 const*>(0)); -} -inline bool u32regex_match(const UChar* p, - match_results& 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 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& 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 const*>(0)); -} -#endif -inline bool u32regex_match(const char* p, - match_results& 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 const*>(0)); -} -inline bool u32regex_match(const unsigned char* p, - match_results& 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 const*>(0)); -} -inline bool u32regex_match(const std::string& s, - match_results& 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 const*>(0)); -} -#ifndef BOOST_NO_STD_WSTRING -inline bool u32regex_match(const std::wstring& s, - match_results& 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 const*>(0)); -} -#endif -inline bool u32regex_match(const U_NAMESPACE_QUALIFIER UnicodeString& s, - match_results& 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 const*>(0)); -} -// -// regex_match overloads that do not return what matched: -// -template -inline bool u32regex_match(BidiIterator first, BidiIterator last, - const u32regex& e, - match_flag_type flags = match_default) -{ - match_results m; - return BOOST_REGEX_DETAIL_NS::do_regex_match(first, last, m, e, flags, static_cast const*>(0)); -} -inline bool u32regex_match(const UChar* p, - const u32regex& e, - match_flag_type flags = match_default) -{ - match_results m; - return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+u_strlen(p), m, e, flags, static_cast 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 m; - return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+std::wcslen(p), m, e, flags, static_cast const*>(0)); -} -#endif -inline bool u32regex_match(const char* p, - const u32regex& e, - match_flag_type flags = match_default) -{ - match_results m; - return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+std::strlen(p), m, e, flags, static_cast const*>(0)); -} -inline bool u32regex_match(const unsigned char* p, - const u32regex& e, - match_flag_type flags = match_default) -{ - match_results m; - return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+std::strlen((const char*)p), m, e, flags, static_cast const*>(0)); -} -inline bool u32regex_match(const std::string& s, - const u32regex& e, - match_flag_type flags = match_default) -{ - match_results m; - return BOOST_REGEX_DETAIL_NS::do_regex_match(s.begin(), s.end(), m, e, flags, static_cast 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 m; - return BOOST_REGEX_DETAIL_NS::do_regex_match(s.begin(), s.end(), m, e, flags, static_cast const*>(0)); -} -#endif -inline bool u32regex_match(const U_NAMESPACE_QUALIFIER UnicodeString& s, - const u32regex& e, - match_flag_type flags = match_default) -{ - match_results m; - return BOOST_REGEX_DETAIL_NS::do_regex_match(s.getBuffer(), s.getBuffer() + s.length(), m, e, flags, static_cast const*>(0)); -} - -// -// regex_search overloads that widen the character type as appropriate: -// -namespace BOOST_REGEX_DETAIL_NS{ -template -inline bool do_regex_search(BidiIterator first, BidiIterator last, - match_results& 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 -bool do_regex_search(BidiIterator first, BidiIterator last, - match_results& m, - const u32regex& e, - match_flag_type flags, - BidiIterator base, - boost::mpl::int_<2> const*) -{ - typedef u16_to_u32_iterator conv_type; - typedef match_results 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 -bool do_regex_search(BidiIterator first, BidiIterator last, - match_results& m, - const u32regex& e, - match_flag_type flags, - BidiIterator base, - boost::mpl::int_<1> const*) -{ - typedef u8_to_u32_iterator conv_type; - typedef match_results 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 -inline bool u32regex_search(BidiIterator first, BidiIterator last, - match_results& 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 const*>(0)); -} -template -inline bool u32regex_search(BidiIterator first, BidiIterator last, - match_results& 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 const*>(0)); -} -inline bool u32regex_search(const UChar* p, - match_results& 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 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& 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 const*>(0)); -} -#endif -inline bool u32regex_search(const char* p, - match_results& 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 const*>(0)); -} -inline bool u32regex_search(const unsigned char* p, - match_results& 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 const*>(0)); -} -inline bool u32regex_search(const std::string& s, - match_results& 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 const*>(0)); -} -#ifndef BOOST_NO_STD_WSTRING -inline bool u32regex_search(const std::wstring& s, - match_results& 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 const*>(0)); -} -#endif -inline bool u32regex_search(const U_NAMESPACE_QUALIFIER UnicodeString& s, - match_results& 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 const*>(0)); -} -template -inline bool u32regex_search(BidiIterator first, BidiIterator last, - const u32regex& e, - match_flag_type flags = match_default) -{ - match_results m; - return BOOST_REGEX_DETAIL_NS::do_regex_search(first, last, m, e, flags, first, static_cast const*>(0)); -} -inline bool u32regex_search(const UChar* p, - const u32regex& e, - match_flag_type flags = match_default) -{ - match_results m; - return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+u_strlen(p), m, e, flags, p, static_cast 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 m; - return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+std::wcslen(p), m, e, flags, p, static_cast const*>(0)); -} -#endif -inline bool u32regex_search(const char* p, - const u32regex& e, - match_flag_type flags = match_default) -{ - match_results m; - return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+std::strlen(p), m, e, flags, p, static_cast const*>(0)); -} -inline bool u32regex_search(const unsigned char* p, - const u32regex& e, - match_flag_type flags = match_default) -{ - match_results m; - return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+std::strlen((const char*)p), m, e, flags, p, static_cast const*>(0)); -} -inline bool u32regex_search(const std::string& s, - const u32regex& e, - match_flag_type flags = match_default) -{ - match_results m; - return BOOST_REGEX_DETAIL_NS::do_regex_search(s.begin(), s.end(), m, e, flags, s.begin(), static_cast 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 m; - return BOOST_REGEX_DETAIL_NS::do_regex_search(s.begin(), s.end(), m, e, flags, s.begin(), static_cast const*>(0)); -} -#endif -inline bool u32regex_search(const U_NAMESPACE_QUALIFIER UnicodeString& s, - const u32regex& e, - match_flag_type flags = match_default) -{ - match_results m; - return BOOST_REGEX_DETAIL_NS::do_regex_search(s.getBuffer(), s.getBuffer() + s.length(), m, e, flags, s.getBuffer(), static_cast const*>(0)); -} - -// -// overloads for regex_replace with utf-8 and utf-16 data types: -// -namespace BOOST_REGEX_DETAIL_NS{ -template -inline std::pair< boost::u8_to_u32_iterator, boost::u8_to_u32_iterator > - make_utf32_seq(I i, I j, mpl::int_<1> const*) -{ - return std::pair< boost::u8_to_u32_iterator, boost::u8_to_u32_iterator >(boost::u8_to_u32_iterator(i, i, j), boost::u8_to_u32_iterator(j, i, j)); -} -template -inline std::pair< boost::u16_to_u32_iterator, boost::u16_to_u32_iterator > - make_utf32_seq(I i, I j, mpl::int_<2> const*) -{ - return std::pair< boost::u16_to_u32_iterator, boost::u16_to_u32_iterator >(boost::u16_to_u32_iterator(i, i, j), boost::u16_to_u32_iterator(j, i, j)); -} -template -inline std::pair< I, I > - make_utf32_seq(I i, I j, mpl::int_<4> const*) -{ - return std::pair< I, I >(i, j); -} -template -inline std::pair< boost::u8_to_u32_iterator, boost::u8_to_u32_iterator > - 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, boost::u8_to_u32_iterator >(boost::u8_to_u32_iterator(p, p, p+len), boost::u8_to_u32_iterator(p+len, p, p+len)); -} -template -inline std::pair< boost::u16_to_u32_iterator, boost::u16_to_u32_iterator > - 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, boost::u16_to_u32_iterator >(boost::u16_to_u32_iterator(p, p, p + len), boost::u16_to_u32_iterator(p+len, p, p + len)); -} -template -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 -inline OutputIterator make_utf32_out(OutputIterator o, mpl::int_<4> const*) -{ - return o; -} -template -inline utf16_output_iterator make_utf32_out(OutputIterator o, mpl::int_<2> const*) -{ - return o; -} -template -inline utf8_output_iterator make_utf32_out(OutputIterator o, mpl::int_<1> const*) -{ - return o; -} - -template -OutputIterator do_regex_replace(OutputIterator out, - std::pair const& in, - const u32regex& e, - const std::pair& fmt, - match_flag_type flags - ) -{ - // unfortunately we have to copy the format string in order to pass in onward: - std::vector 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 i(in.first, in.second, e, flags); - regex_iterator 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(0), static_cast(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 -inline const BaseIterator& extract_output_base(const BaseIterator& b) -{ - return b; -} -template -inline BaseIterator extract_output_base(const utf8_output_iterator& b) -{ - return b.base(); -} -template -inline BaseIterator extract_output_base(const utf16_output_iterator& b) -{ - return b.base(); -} -} // BOOST_REGEX_DETAIL_NS - -template -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 const*>(0)), - BOOST_REGEX_DETAIL_NS::make_utf32_seq(first, last, static_cast const*>(0)), - e, - BOOST_REGEX_DETAIL_NS::make_utf32_seq(fmt, static_cast const*>(0)), - flags) - ); -} - -template -inline OutputIterator u32regex_replace(OutputIterator out, - Iterator first, - Iterator last, - const u32regex& e, - const std::basic_string& 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 const*>(0)), - BOOST_REGEX_DETAIL_NS::make_utf32_seq(first, last, static_cast const*>(0)), - e, - BOOST_REGEX_DETAIL_NS::make_utf32_seq(fmt.begin(), fmt.end(), static_cast const*>(0)), - flags) - ); -} - -template -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 const*>(0)), - BOOST_REGEX_DETAIL_NS::make_utf32_seq(first, last, static_cast const*>(0)), - e, - BOOST_REGEX_DETAIL_NS::make_utf32_seq(fmt.getBuffer(), fmt.getBuffer() + fmt.length(), static_cast const*>(0)), - flags) - ); -} - -template -std::basic_string u32regex_replace(const std::basic_string& s, - const u32regex& e, - const charT* fmt, - match_flag_type flags = match_default) -{ - std::basic_string result; - BOOST_REGEX_DETAIL_NS::string_out_iterator > i(result); - u32regex_replace(i, s.begin(), s.end(), e, fmt, flags); - return result; -} - -template -std::basic_string u32regex_replace(const std::basic_string& s, - const u32regex& e, - const std::basic_string& fmt, - match_flag_type flags = match_default) -{ - std::basic_string result; - BOOST_REGEX_DETAIL_NS::string_out_iterator > 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 const*>(0)), - BOOST_REGEX_DETAIL_NS::make_utf32_seq(s.getBuffer(), s.getBuffer()+s.length(), static_cast const*>(0)), - e, - BOOST_REGEX_DETAIL_NS::make_utf32_seq(fmt.getBuffer(), fmt.getBuffer() + fmt.length(), static_cast const*>(0)), - flags); - return result; -} - -} // namespace boost. - -#ifdef BOOST_MSVC -#pragma warning (pop) -#endif - -#include -#include - -#endif diff --git a/3rdparty/boost/extract.sh b/3rdparty/boost/extract.sh index 41e869c831..04eeb5cf10 100755 --- a/3rdparty/boost/extract.sh +++ b/3rdparty/boost/extract.sh @@ -45,11 +45,11 @@ cp -vR needed/libs . rm -rf needed # found by bcp but not needed by us +rm -rf boost/regex/icu.hpp rm -rf boost/typeof rm -rf libs/config rm -rf libs/smart_ptr rm -rf libs/regex/build rm -rf libs/regex/test - - +rm -rf libs/regex/src/icu.cpp diff --git a/3rdparty/boost/libs/regex/src/CMakeLists.txt b/3rdparty/boost/libs/regex/src/CMakeLists.txt index 59e1b7c4ca..5ec05a2e47 100755 --- a/3rdparty/boost/libs/regex/src/CMakeLists.txt +++ b/3rdparty/boost/libs/regex/src/CMakeLists.txt @@ -18,7 +18,6 @@ boost_add_library(boost_regex cpp_regex_traits.cpp cregex.cpp fileiter.cpp - icu.cpp instances.cpp posix_api.cpp regex.cpp diff --git a/3rdparty/boost/libs/regex/src/icu.cpp b/3rdparty/boost/libs/regex/src/icu.cpp deleted file mode 100644 index 5d166a6974..0000000000 --- a/3rdparty/boost/libs/regex/src/icu.cpp +++ /dev/null @@ -1,507 +0,0 @@ -/* - * - * 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 - * DESCRIPTION: Unicode regular expressions on top of the ICU Library. - */ -#define BOOST_REGEX_SOURCE - -#include -#ifdef BOOST_HAS_ICU -#define BOOST_REGEX_ICU_INSTANTIATE -#include - -#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 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(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(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((::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((::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('\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('\v'))) - return true; - return false; -} - -} - -#endif // BOOST_HAS_ICU