include/boost/regex/v5/icu.hpp

83.6% Lines (310/371) 50.5% List of functions (97/192)

[ ] prev/next file n p prev/next uncovered line

icu.hpp

f(x) Functions (192)

Function Calls Lines Blocks

Line	Hits	Source Code
1		/*
2		*
3		* Copyright (c) 2004
4		* John Maddock
5		*
6		* Use, modification and distribution are subject to the
7		* Boost Software License, Version 1.0. (See accompanying file
8		* LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
9		*
10		*/
11
12		/*
13		* LOCATION: see http://www.boost.org for most recent version.
14		* FILE icu.hpp
15		* VERSION see <boost/version.hpp>
16		* DESCRIPTION: Unicode regular expressions on top of the ICU Library.
17		*/
18
19		#ifndef BOOST_REGEX_ICU_V5_HPP
20		#define BOOST_REGEX_ICU_V5_HPP
21
22		#ifndef BOOST_REGEX_AS_MODULE
23		#include <unicode/utypes.h>
24		#include <unicode/uchar.h>
25		#include <unicode/coll.h>
26		#include <type_traits>
27		#include <functional>
28		#endif
29		#include <boost/regex.hpp>
30		#include <boost/regex/v5/unicode_iterator.hpp>
31
32		#ifdef BOOST_REGEX_MSVC
33		#pragma warning (push)
34		#pragma warning (disable: 4251)
35		#endif
36
37		namespace boost{
38
39		namespace BOOST_REGEX_DETAIL_NS{
40
41		//
42		// Implementation details:
43		//
44		class icu_regex_traits_implementation
45		{
46		typedef UChar32 char_type;
47		typedef std::size_t size_type;
48		typedef std::vector<char_type> string_type;
49		typedef U_NAMESPACE_QUALIFIER Locale locale_type;
50		typedef std::uint_least32_t char_class_type;
51		public:
52	149306x	icu_regex_traits_implementation(const U_NAMESPACE_QUALIFIER Locale& l)
53	149306x	: m_locale(l)
54		{
55	149306x	UErrorCode success = U_ZERO_ERROR;
56	149306x	m_collator.reset(U_NAMESPACE_QUALIFIER Collator::createInstance(l, success));
57	149306x	if(U_SUCCESS(success) == 0)
58	✗	init_error();
59	149306x	m_collator->setStrength(U_NAMESPACE_QUALIFIER Collator::IDENTICAL);
60	149306x	success = U_ZERO_ERROR;
61	149306x	m_primary_collator.reset(U_NAMESPACE_QUALIFIER Collator::createInstance(l, success));
62	149306x	if(U_SUCCESS(success) == 0)
63	✗	init_error();
64	149306x	m_primary_collator->setStrength(U_NAMESPACE_QUALIFIER Collator::PRIMARY);
65	149306x	}
66	64x	U_NAMESPACE_QUALIFIER Locale getloc()const
67		{
68	64x	return m_locale;
69		}
70	401160x	string_type do_transform(const char_type* p1, const char_type* p2, const U_NAMESPACE_QUALIFIER Collator* pcoll) const
71		{
72		// TODO make thread safe!!!! :
73		typedef u32_to_u16_iterator<const char_type*, ::UChar> itt;
74	401160x	itt i(p1), j(p2);
75	401160x	std::vector< ::UChar> t(i, j);
76		std::uint8_t result[100];
77		std::int32_t len;
78	401160x	if (!t.empty())
79	401160x	len = pcoll->getSortKey(&*t.begin(), static_cast<std::int32_t>(t.size()), result, sizeof(result));
80		else
81	✗	len = pcoll->getSortKey(static_cast<UChar const*>(0), static_cast<std::int32_t>(0), result, sizeof(result));
82	401160x	if (std::size_t(len) > sizeof(result))
83		{
84	✗	std::unique_ptr< std::uint8_t[]> presult(new ::uint8_t[len + 1]);
85	✗	if (!t.empty())
86	✗	len = pcoll->getSortKey(&*t.begin(), static_cast<std::int32_t>(t.size()), presult.get(), len + 1);
87		else
88	✗	len = pcoll->getSortKey(static_cast<UChar const*>(0), static_cast<std::int32_t>(0), presult.get(), len + 1);
89	✗	if ((0 == presult[len - 1]) && (len > 1))
90	✗	--len;
91	✗	return string_type(presult.get(), presult.get() + len);
92	✗	}
93	401160x	if ((0 == result[len - 1]) && (len > 1))
94	382704x	--len;
95	802320x	return string_type(result, result + len);
96	401160x	}
97	322200x	string_type transform(const char_type* p1, const char_type* p2) const
98		{
99	322200x	return do_transform(p1, p2, m_collator.get());
100		}
101	78960x	string_type transform_primary(const char_type* p1, const char_type* p2) const
102		{
103	78960x	return do_transform(p1, p2, m_primary_collator.get());
104		}
105		private:
106	✗	void init_error()
107		{
108	✗	std::runtime_error e("Could not initialize ICU resources");
109		#ifndef BOOST_REGEX_STANDALONE
110	✗	boost::throw_exception(e);
111		#else
112		throw e;
113		#endif
114	✗	}
115		U_NAMESPACE_QUALIFIER Locale m_locale; // The ICU locale that we're using
116		std::unique_ptr< U_NAMESPACE_QUALIFIER Collator> m_collator; // The full collation object
117		std::unique_ptr< U_NAMESPACE_QUALIFIER Collator> m_primary_collator; // The primary collation object
118		};
119	149306x	inline std::shared_ptr<icu_regex_traits_implementation> get_icu_regex_traits_implementation(const U_NAMESPACE_QUALIFIER Locale& loc)
120		{
121	149306x	return std::shared_ptr<icu_regex_traits_implementation>(new icu_regex_traits_implementation(loc));
122		}
123
124		}
125
126		class icu_regex_traits
127		{
128		public:
129		typedef UChar32 char_type;
130		typedef std::size_t size_type;
131		typedef std::vector<char_type> string_type;
132		typedef U_NAMESPACE_QUALIFIER Locale locale_type;
133		typedef std::uint64_t char_class_type;
134
135		struct boost_extensions_tag{};
136
137	149242x	icu_regex_traits()
138	149242x	: m_pimpl(BOOST_REGEX_DETAIL_NS::get_icu_regex_traits_implementation(U_NAMESPACE_QUALIFIER Locale()))
139		{
140	149242x	}
141	3276x	static size_type length(const char_type* p)
142		{
143	3276x	size_type result = 0;
144	47508x	while (*p)
145		{
146	44232x	++p;
147	44232x	++result;
148		}
149	3276x	return result;
150		}
151
152	2643091x	::boost::regex_constants::syntax_type syntax_type(char_type c)const
153		{
154	2643091x	return ((c < 0x7f) && (c > 0)) ? BOOST_REGEX_DETAIL_NS::get_default_syntax_type(static_cast<char>(c)) : regex_constants::syntax_char;
155		}
156	119970x	::boost::regex_constants::escape_syntax_type escape_syntax_type(char_type c) const
157		{
158	119970x	return ((c < 0x7f) && (c > 0)) ? BOOST_REGEX_DETAIL_NS::get_default_escape_syntax_type(static_cast<char>(c)) : regex_constants::syntax_char;
159		}
160	80841541x	char_type translate(char_type c) const
161		{
162	80841541x	return c;
163		}
164	3471437x	char_type translate_nocase(char_type c) const
165		{
166	3471437x	return ::u_foldCase(c, U_FOLD_CASE_DEFAULT);
167		}
168	84312715x	char_type translate(char_type c, bool icase) const
169		{
170	84312715x	return icase ? translate_nocase(c) : translate(c);
171		}
172	959x	char_type tolower(char_type c) const
173		{
174	959x	return ::u_tolower(c);
175		}
176	661x	char_type toupper(char_type c) const
177		{
178	661x	return ::u_toupper(c);
179		}
180	322200x	string_type transform(const char_type* p1, const char_type* p2) const
181		{
182	322200x	return m_pimpl->transform(p1, p2);
183		}
184	78960x	string_type transform_primary(const char_type* p1, const char_type* p2) const
185		{
186	78960x	return m_pimpl->transform_primary(p1, p2);
187		}
188	801325x	char_class_type lookup_classname(const char_type* p1, const char_type* p2) const
189		{
190	801325x	constexpr char_class_type mask_blank = char_class_type(1) << offset_blank;
191	801325x	constexpr char_class_type mask_space = char_class_type(1) << offset_space;
192	801325x	constexpr char_class_type mask_xdigit = char_class_type(1) << offset_xdigit;
193	801325x	constexpr char_class_type mask_underscore = char_class_type(1) << offset_underscore;
194	801325x	constexpr char_class_type mask_unicode = char_class_type(1) << offset_unicode;
195		//constexpr char_class_type mask_any = char_class_type(1) << offset_any;
196		//constexpr char_class_type mask_ascii = char_class_type(1) << offset_ascii;
197	801325x	constexpr char_class_type mask_horizontal = char_class_type(1) << offset_horizontal;
198	801325x	constexpr char_class_type mask_vertical = char_class_type(1) << offset_vertical;
199
200		static const char_class_type masks[] =
201		{
202		0,
203		U_GC_L_MASK \| U_GC_ND_MASK,
204		U_GC_L_MASK,
205		mask_blank,
206		U_GC_CC_MASK \| U_GC_CF_MASK \| U_GC_ZL_MASK \| U_GC_ZP_MASK,
207		U_GC_ND_MASK,
208		U_GC_ND_MASK,
209		(0x3FFFFFFFu) & ~(U_GC_CC_MASK \| U_GC_CF_MASK \| U_GC_CS_MASK \| U_GC_CN_MASK \| U_GC_Z_MASK),
210		mask_horizontal,
211		U_GC_LL_MASK,
212		U_GC_LL_MASK,
213		~(U_GC_C_MASK),
214		U_GC_P_MASK,
215		char_class_type(U_GC_Z_MASK) \| mask_space,
216		char_class_type(U_GC_Z_MASK) \| mask_space,
217		U_GC_LU_MASK,
218		mask_unicode,
219		U_GC_LU_MASK,
220		mask_vertical,
221		char_class_type(U_GC_L_MASK \| U_GC_ND_MASK \| U_GC_MN_MASK) \| mask_underscore,
222		char_class_type(U_GC_L_MASK \| U_GC_ND_MASK \| U_GC_MN_MASK) \| mask_underscore,
223		char_class_type(U_GC_ND_MASK) \| mask_xdigit,
224		};
225
226	801325x	int idx = ::boost::BOOST_REGEX_DETAIL_NS::get_default_class_id(p1, p2);
227	801325x	if (idx >= 0)
228	792631x	return masks[idx + 1];
229	8694x	char_class_type result = lookup_icu_mask(p1, p2);
230	8694x	if (result != 0)
231	✗	return result;
232
233	8694x	if (idx < 0)
234		{
235	8694x	string_type s(p1, p2);
236	8694x	string_type::size_type i = 0;
237	52559x	while (i < s.size())
238		{
239	43865x	s[i] = static_cast<char>((::u_tolower)(s[i]));
240	43865x	if (::u_isspace(s[i]) \|\| (s[i] == '-') \|\| (s[i] == '_'))
241	2160x	s.erase(s.begin() + i, s.begin() + i + 1);
242		else
243		{
244	41705x	s[i] = static_cast<char>((::u_tolower)(s[i]));
245	41705x	++i;
246		}
247		}
248	8694x	if (!s.empty())
249	8622x	idx = ::boost::BOOST_REGEX_DETAIL_NS::get_default_class_id(&s.begin(), &s.begin() + s.size());
250	8694x	if (idx >= 0)
251	2647x	return masks[idx + 1];
252	6047x	if (!s.empty())
253	5975x	result = lookup_icu_mask(&s.begin(), &s.begin() + s.size());
254	6047x	if (result != 0)
255	4643x	return result;
256	8694x	}
257	1404x	BOOST_REGEX_ASSERT(std::size_t(idx + 1) < sizeof(masks) / sizeof(masks[0]));
258	1404x	return masks[idx + 1];
259		}
260	8452x	string_type lookup_collatename(const char_type* p1, const char_type* p2) const
261		{
262	8452x	string_type result;
263	8452x	if (std::find_if(p1, p2, std::bind(std::greater< ::UChar32>(), std::placeholders::_1, 0x7f)) == p2)
264		{
265	8272x	std::string s(p1, p2);
266		// Try Unicode name:
267	8272x	UErrorCode err = U_ZERO_ERROR;
268	8272x	UChar32 c = ::u_charFromName(U_UNICODE_CHAR_NAME, s.c_str(), &err);
269	8272x	if (U_SUCCESS(err))
270		{
271	420x	result.push_back(c);
272	420x	return result;
273		}
274		// Try Unicode-extended name:
275	7852x	err = U_ZERO_ERROR;
276	7852x	c = ::u_charFromName(U_EXTENDED_CHAR_NAME, s.c_str(), &err);
277	7852x	if (U_SUCCESS(err))
278		{
279	✗	result.push_back(c);
280	✗	return result;
281		}
282		// try POSIX name:
283	7852x	s = ::boost::BOOST_REGEX_DETAIL_NS::lookup_default_collate_name(s);
284	7852x	result.assign(s.begin(), s.end());
285	8272x	}
286	8032x	if (result.empty() && (p2 - p1 == 1))
287	180x	result.push_back(*p1);
288	8032x	return result;
289	✗	}
290	15666933x	bool isctype(char_type c, char_class_type f) const
291		{
292	15666933x	constexpr char_class_type mask_blank = char_class_type(1) << offset_blank;
293	15666933x	constexpr char_class_type mask_space = char_class_type(1) << offset_space;
294	15666933x	constexpr char_class_type mask_xdigit = char_class_type(1) << offset_xdigit;
295	15666933x	constexpr char_class_type mask_underscore = char_class_type(1) << offset_underscore;
296	15666933x	constexpr char_class_type mask_unicode = char_class_type(1) << offset_unicode;
297	15666933x	constexpr char_class_type mask_any = char_class_type(1) << offset_any;
298	15666933x	constexpr char_class_type mask_ascii = char_class_type(1) << offset_ascii;
299	15666933x	constexpr char_class_type mask_horizontal = char_class_type(1) << offset_horizontal;
300	15666933x	constexpr char_class_type mask_vertical = char_class_type(1) << offset_vertical;
301
302		// check for standard catagories first:
303	15666933x	char_class_type m = char_class_type(static_cast<char_class_type>(1) << u_charType(c));
304	15666933x	if ((m & f) != 0)
305	2356800x	return true;
306		// now check for special cases:
307	13310133x	if (((f & mask_blank) != 0) && u_isblank(c))
308	3174x	return true;
309	13306959x	if (((f & mask_space) != 0) && u_isspace(c))
310	48426x	return true;
311	13258533x	if (((f & mask_xdigit) != 0) && (u_digit(c, 16) >= 0))
312	9408x	return true;
313	13249125x	if (((f & mask_unicode) != 0) && (c >= 0x100))
314	144x	return true;
315	13248981x	if (((f & mask_underscore) != 0) && (c == '_'))
316	11723x	return true;
317	13237258x	if (((f & mask_any) != 0) && (c <= 0x10FFFF))
318	15432x	return true;
319	13221826x	if (((f & mask_ascii) != 0) && (c <= 0x7F))
320	15432x	return true;
321	13206394x	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)))
322	1644x	return true;
323	13204750x	if (((f & mask_horizontal) != 0) && !::boost::BOOST_REGEX_DETAIL_NS::is_separator(c) && u_isspace(c) && (c != static_cast<char_type>('\v')))
324	1224x	return true;
325	13203526x	return false;
326		}
327	80339x	std::intmax_t toi(const char_type& p1, const char_type p2, int radix)const
328		{
329	80339x	return BOOST_REGEX_DETAIL_NS::global_toi(p1, p2, radix, *this);
330		}
331	203040x	int value(char_type c, int radix)const
332		{
333	203040x	return u_digit(c, static_cast< std::int8_t>(radix));
334		}
335	64x	locale_type imbue(locale_type l)
336		{
337	64x	locale_type result(m_pimpl->getloc());
338	64x	m_pimpl = BOOST_REGEX_DETAIL_NS::get_icu_regex_traits_implementation(l);
339	64x	return result;
340	✗	}
341		locale_type getloc()const
342		{
343		return locale_type();
344		}
345	14580x	std::string error_string(::boost::regex_constants::error_type n) const
346		{
347	29160x	return BOOST_REGEX_DETAIL_NS::get_default_error_string(n);
348		}
349		private:
350		icu_regex_traits(const icu_regex_traits&);
351		icu_regex_traits& operator=(const icu_regex_traits&);
352
353		//
354		// define the bitmasks offsets we need for additional character properties:
355		//
356		enum{
357		offset_blank = U_CHAR_CATEGORY_COUNT,
358		offset_space = U_CHAR_CATEGORY_COUNT+1,
359		offset_xdigit = U_CHAR_CATEGORY_COUNT+2,
360		offset_underscore = U_CHAR_CATEGORY_COUNT+3,
361		offset_unicode = U_CHAR_CATEGORY_COUNT+4,
362		offset_any = U_CHAR_CATEGORY_COUNT+5,
363		offset_ascii = U_CHAR_CATEGORY_COUNT+6,
364		offset_horizontal = U_CHAR_CATEGORY_COUNT+7,
365		offset_vertical = U_CHAR_CATEGORY_COUNT+8
366		};
367
368	14669x	static char_class_type lookup_icu_mask(const ::UChar32* p1, const ::UChar32* p2)
369		{
370		//constexpr char_class_type mask_blank = char_class_type(1) << offset_blank;
371		//constexpr char_class_type mask_space = char_class_type(1) << offset_space;
372		//constexpr char_class_type mask_xdigit = char_class_type(1) << offset_xdigit;
373		//constexpr char_class_type mask_underscore = char_class_type(1) << offset_underscore;
374		//constexpr char_class_type mask_unicode = char_class_type(1) << offset_unicode;
375	14669x	constexpr char_class_type mask_any = char_class_type(1) << offset_any;
376	14669x	constexpr char_class_type mask_ascii = char_class_type(1) << offset_ascii;
377		//constexpr char_class_type mask_horizontal = char_class_type(1) << offset_horizontal;
378		//constexpr char_class_type mask_vertical = char_class_type(1) << offset_vertical;
379
380		static const ::UChar32 prop_name_table[] = {
381		/* any */ 'a', 'n', 'y',
382		/* ascii */ 'a', 's', 'c', 'i', 'i',
383		/* assigned */ 'a', 's', 's', 'i', 'g', 'n', 'e', 'd',
384		/* c* / 'c', '',
385		/* cc */ 'c', 'c',
386		/* cf */ 'c', 'f',
387		/* closepunctuation */ 'c', 'l', 'o', 's', 'e', 'p', 'u', 'n', 'c', 't', 'u', 'a', 't', 'i', 'o', 'n',
388		/* cn */ 'c', 'n',
389		/* co */ 'c', 'o',
390		/* connectorpunctuation */ 'c', 'o', 'n', 'n', 'e', 'c', 't', 'o', 'r', 'p', 'u', 'n', 'c', 't', 'u', 'a', 't', 'i', 'o', 'n',
391		/* control */ 'c', 'o', 'n', 't', 'r', 'o', 'l',
392		/* cs */ 'c', 's',
393		/* currencysymbol */ 'c', 'u', 'r', 'r', 'e', 'n', 'c', 'y', 's', 'y', 'm', 'b', 'o', 'l',
394		/* dashpunctuation */ 'd', 'a', 's', 'h', 'p', 'u', 'n', 'c', 't', 'u', 'a', 't', 'i', 'o', 'n',
395		/* decimaldigitnumber */ 'd', 'e', 'c', 'i', 'm', 'a', 'l', 'd', 'i', 'g', 'i', 't', 'n', 'u', 'm', 'b', 'e', 'r',
396		/* enclosingmark */ 'e', 'n', 'c', 'l', 'o', 's', 'i', 'n', 'g', 'm', 'a', 'r', 'k',
397		/* finalpunctuation */ 'f', 'i', 'n', 'a', 'l', 'p', 'u', 'n', 'c', 't', 'u', 'a', 't', 'i', 'o', 'n',
398		/* format */ 'f', 'o', 'r', 'm', 'a', 't',
399		/* initialpunctuation */ 'i', 'n', 'i', 't', 'i', 'a', 'l', 'p', 'u', 'n', 'c', 't', 'u', 'a', 't', 'i', 'o', 'n',
400		/* l* / 'l', '',
401		/* letter */ 'l', 'e', 't', 't', 'e', 'r',
402		/* letternumber */ 'l', 'e', 't', 't', 'e', 'r', 'n', 'u', 'm', 'b', 'e', 'r',
403		/* lineseparator */ 'l', 'i', 'n', 'e', 's', 'e', 'p', 'a', 'r', 'a', 't', 'o', 'r',
404		/* ll */ 'l', 'l',
405		/* lm */ 'l', 'm',
406		/* lo */ 'l', 'o',
407		/* lowercaseletter */ 'l', 'o', 'w', 'e', 'r', 'c', 'a', 's', 'e', 'l', 'e', 't', 't', 'e', 'r',
408		/* lt */ 'l', 't',
409		/* lu */ 'l', 'u',
410		/* m* / 'm', '',
411		/* mark */ 'm', 'a', 'r', 'k',
412		/* mathsymbol */ 'm', 'a', 't', 'h', 's', 'y', 'm', 'b', 'o', 'l',
413		/* mc */ 'm', 'c',
414		/* me */ 'm', 'e',
415		/* mn */ 'm', 'n',
416		/* modifierletter */ 'm', 'o', 'd', 'i', 'f', 'i', 'e', 'r', 'l', 'e', 't', 't', 'e', 'r',
417		/* modifiersymbol */ 'm', 'o', 'd', 'i', 'f', 'i', 'e', 'r', 's', 'y', 'm', 'b', 'o', 'l',
418		/* n* / 'n', '',
419		/* nd */ 'n', 'd',
420		/* nl */ 'n', 'l',
421		/* no */ 'n', 'o',
422		/* nonspacingmark */ 'n', 'o', 'n', 's', 'p', 'a', 'c', 'i', 'n', 'g', 'm', 'a', 'r', 'k',
423		/* notassigned */ 'n', 'o', 't', 'a', 's', 's', 'i', 'g', 'n', 'e', 'd',
424		/* number */ 'n', 'u', 'm', 'b', 'e', 'r',
425		/* openpunctuation */ 'o', 'p', 'e', 'n', 'p', 'u', 'n', 'c', 't', 'u', 'a', 't', 'i', 'o', 'n',
426		/* other */ 'o', 't', 'h', 'e', 'r',
427		/* otherletter */ 'o', 't', 'h', 'e', 'r', 'l', 'e', 't', 't', 'e', 'r',
428		/* othernumber */ 'o', 't', 'h', 'e', 'r', 'n', 'u', 'm', 'b', 'e', 'r',
429		/* otherpunctuation */ 'o', 't', 'h', 'e', 'r', 'p', 'u', 'n', 'c', 't', 'u', 'a', 't', 'i', 'o', 'n',
430		/* othersymbol */ 'o', 't', 'h', 'e', 'r', 's', 'y', 'm', 'b', 'o', 'l',
431		/* p* / 'p', '',
432		/* paragraphseparator */ 'p', 'a', 'r', 'a', 'g', 'r', 'a', 'p', 'h', 's', 'e', 'p', 'a', 'r', 'a', 't', 'o', 'r',
433		/* pc */ 'p', 'c',
434		/* pd */ 'p', 'd',
435		/* pe */ 'p', 'e',
436		/* pf */ 'p', 'f',
437		/* pi */ 'p', 'i',
438		/* po */ 'p', 'o',
439		/* privateuse */ 'p', 'r', 'i', 'v', 'a', 't', 'e', 'u', 's', 'e',
440		/* ps */ 'p', 's',
441		/* punctuation */ 'p', 'u', 'n', 'c', 't', 'u', 'a', 't', 'i', 'o', 'n',
442		/* s* / 's', '',
443		/* sc */ 's', 'c',
444		/* separator */ 's', 'e', 'p', 'a', 'r', 'a', 't', 'o', 'r',
445		/* sk */ 's', 'k',
446		/* sm */ 's', 'm',
447		/* so */ 's', 'o',
448		/* spaceseparator */ 's', 'p', 'a', 'c', 'e', 's', 'e', 'p', 'a', 'r', 'a', 't', 'o', 'r',
449		/* spacingcombiningmark */ 's', 'p', 'a', 'c', 'i', 'n', 'g', 'c', 'o', 'm', 'b', 'i', 'n', 'i', 'n', 'g', 'm', 'a', 'r', 'k',
450		/* surrogate */ 's', 'u', 'r', 'r', 'o', 'g', 'a', 't', 'e',
451		/* symbol */ 's', 'y', 'm', 'b', 'o', 'l',
452		/* titlecase */ 't', 'i', 't', 'l', 'e', 'c', 'a', 's', 'e',
453		/* titlecaseletter */ 't', 'i', 't', 'l', 'e', 'c', 'a', 's', 'e', 'l', 'e', 't', 't', 'e', 'r',
454		/* uppercaseletter */ 'u', 'p', 'p', 'e', 'r', 'c', 'a', 's', 'e', 'l', 'e', 't', 't', 'e', 'r',
455		/* z* / 'z', '',
456		/* zl */ 'z', 'l',
457		/* zp */ 'z', 'p',
458		/* zs */ 'z', 's',
459		};
460
461		static const BOOST_REGEX_DETAIL_NS::character_pointer_range< ::UChar32> range_data[] = {
462		{ prop_name_table + 0, prop_name_table + 3, }, // any
463		{ prop_name_table + 3, prop_name_table + 8, }, // ascii
464		{ prop_name_table + 8, prop_name_table + 16, }, // assigned
465		{ prop_name_table + 16, prop_name_table + 18, }, // c*
466		{ prop_name_table + 18, prop_name_table + 20, }, // cc
467		{ prop_name_table + 20, prop_name_table + 22, }, // cf
468		{ prop_name_table + 22, prop_name_table + 38, }, // closepunctuation
469		{ prop_name_table + 38, prop_name_table + 40, }, // cn
470		{ prop_name_table + 40, prop_name_table + 42, }, // co
471		{ prop_name_table + 42, prop_name_table + 62, }, // connectorpunctuation
472		{ prop_name_table + 62, prop_name_table + 69, }, // control
473		{ prop_name_table + 69, prop_name_table + 71, }, // cs
474		{ prop_name_table + 71, prop_name_table + 85, }, // currencysymbol
475		{ prop_name_table + 85, prop_name_table + 100, }, // dashpunctuation
476		{ prop_name_table + 100, prop_name_table + 118, }, // decimaldigitnumber
477		{ prop_name_table + 118, prop_name_table + 131, }, // enclosingmark
478		{ prop_name_table + 131, prop_name_table + 147, }, // finalpunctuation
479		{ prop_name_table + 147, prop_name_table + 153, }, // format
480		{ prop_name_table + 153, prop_name_table + 171, }, // initialpunctuation
481		{ prop_name_table + 171, prop_name_table + 173, }, // l*
482		{ prop_name_table + 173, prop_name_table + 179, }, // letter
483		{ prop_name_table + 179, prop_name_table + 191, }, // letternumber
484		{ prop_name_table + 191, prop_name_table + 204, }, // lineseparator
485		{ prop_name_table + 204, prop_name_table + 206, }, // ll
486		{ prop_name_table + 206, prop_name_table + 208, }, // lm
487		{ prop_name_table + 208, prop_name_table + 210, }, // lo
488		{ prop_name_table + 210, prop_name_table + 225, }, // lowercaseletter
489		{ prop_name_table + 225, prop_name_table + 227, }, // lt
490		{ prop_name_table + 227, prop_name_table + 229, }, // lu
491		{ prop_name_table + 229, prop_name_table + 231, }, // m*
492		{ prop_name_table + 231, prop_name_table + 235, }, // mark
493		{ prop_name_table + 235, prop_name_table + 245, }, // mathsymbol
494		{ prop_name_table + 245, prop_name_table + 247, }, // mc
495		{ prop_name_table + 247, prop_name_table + 249, }, // me
496		{ prop_name_table + 249, prop_name_table + 251, }, // mn
497		{ prop_name_table + 251, prop_name_table + 265, }, // modifierletter
498		{ prop_name_table + 265, prop_name_table + 279, }, // modifiersymbol
499		{ prop_name_table + 279, prop_name_table + 281, }, // n*
500		{ prop_name_table + 281, prop_name_table + 283, }, // nd
501		{ prop_name_table + 283, prop_name_table + 285, }, // nl
502		{ prop_name_table + 285, prop_name_table + 287, }, // no
503		{ prop_name_table + 287, prop_name_table + 301, }, // nonspacingmark
504		{ prop_name_table + 301, prop_name_table + 312, }, // notassigned
505		{ prop_name_table + 312, prop_name_table + 318, }, // number
506		{ prop_name_table + 318, prop_name_table + 333, }, // openpunctuation
507		{ prop_name_table + 333, prop_name_table + 338, }, // other
508		{ prop_name_table + 338, prop_name_table + 349, }, // otherletter
509		{ prop_name_table + 349, prop_name_table + 360, }, // othernumber
510		{ prop_name_table + 360, prop_name_table + 376, }, // otherpunctuation
511		{ prop_name_table + 376, prop_name_table + 387, }, // othersymbol
512		{ prop_name_table + 387, prop_name_table + 389, }, // p*
513		{ prop_name_table + 389, prop_name_table + 407, }, // paragraphseparator
514		{ prop_name_table + 407, prop_name_table + 409, }, // pc
515		{ prop_name_table + 409, prop_name_table + 411, }, // pd
516		{ prop_name_table + 411, prop_name_table + 413, }, // pe
517		{ prop_name_table + 413, prop_name_table + 415, }, // pf
518		{ prop_name_table + 415, prop_name_table + 417, }, // pi
519		{ prop_name_table + 417, prop_name_table + 419, }, // po
520		{ prop_name_table + 419, prop_name_table + 429, }, // privateuse
521		{ prop_name_table + 429, prop_name_table + 431, }, // ps
522		{ prop_name_table + 431, prop_name_table + 442, }, // punctuation
523		{ prop_name_table + 442, prop_name_table + 444, }, // s*
524		{ prop_name_table + 444, prop_name_table + 446, }, // sc
525		{ prop_name_table + 446, prop_name_table + 455, }, // separator
526		{ prop_name_table + 455, prop_name_table + 457, }, // sk
527		{ prop_name_table + 457, prop_name_table + 459, }, // sm
528		{ prop_name_table + 459, prop_name_table + 461, }, // so
529		{ prop_name_table + 461, prop_name_table + 475, }, // spaceseparator
530		{ prop_name_table + 475, prop_name_table + 495, }, // spacingcombiningmark
531		{ prop_name_table + 495, prop_name_table + 504, }, // surrogate
532		{ prop_name_table + 504, prop_name_table + 510, }, // symbol
533		{ prop_name_table + 510, prop_name_table + 519, }, // titlecase
534		{ prop_name_table + 519, prop_name_table + 534, }, // titlecaseletter
535		{ prop_name_table + 534, prop_name_table + 549, }, // uppercaseletter
536		{ prop_name_table + 549, prop_name_table + 551, }, // z*
537		{ prop_name_table + 551, prop_name_table + 553, }, // zl
538		{ prop_name_table + 553, prop_name_table + 555, }, // zp
539		{ prop_name_table + 555, prop_name_table + 557, }, // zs
540		};
541
542		static const icu_regex_traits::char_class_type icu_class_map[] = {
543		mask_any, // any
544		mask_ascii, // ascii
545		(0x3FFFFFFFu) & ~(U_GC_CN_MASK), // assigned
546		U_GC_C_MASK, // c*
547		U_GC_CC_MASK, // cc
548		U_GC_CF_MASK, // cf
549		U_GC_PE_MASK, // closepunctuation
550		U_GC_CN_MASK, // cn
551		U_GC_CO_MASK, // co
552		U_GC_PC_MASK, // connectorpunctuation
553		U_GC_CC_MASK, // control
554		U_GC_CS_MASK, // cs
555		U_GC_SC_MASK, // currencysymbol
556		U_GC_PD_MASK, // dashpunctuation
557		U_GC_ND_MASK, // decimaldigitnumber
558		U_GC_ME_MASK, // enclosingmark
559		U_GC_PF_MASK, // finalpunctuation
560		U_GC_CF_MASK, // format
561		U_GC_PI_MASK, // initialpunctuation
562		U_GC_L_MASK, // l*
563		U_GC_L_MASK, // letter
564		U_GC_NL_MASK, // letternumber
565		U_GC_ZL_MASK, // lineseparator
566		U_GC_LL_MASK, // ll
567		U_GC_LM_MASK, // lm
568		U_GC_LO_MASK, // lo
569		U_GC_LL_MASK, // lowercaseletter
570		U_GC_LT_MASK, // lt
571		U_GC_LU_MASK, // lu
572		U_GC_M_MASK, // m*
573		U_GC_M_MASK, // mark
574		U_GC_SM_MASK, // mathsymbol
575		U_GC_MC_MASK, // mc
576		U_GC_ME_MASK, // me
577		U_GC_MN_MASK, // mn
578		U_GC_LM_MASK, // modifierletter
579		U_GC_SK_MASK, // modifiersymbol
580		U_GC_N_MASK, // n*
581		U_GC_ND_MASK, // nd
582		U_GC_NL_MASK, // nl
583		U_GC_NO_MASK, // no
584		U_GC_MN_MASK, // nonspacingmark
585		U_GC_CN_MASK, // notassigned
586		U_GC_N_MASK, // number
587		U_GC_PS_MASK, // openpunctuation
588		U_GC_C_MASK, // other
589		U_GC_LO_MASK, // otherletter
590		U_GC_NO_MASK, // othernumber
591		U_GC_PO_MASK, // otherpunctuation
592		U_GC_SO_MASK, // othersymbol
593		U_GC_P_MASK, // p*
594		U_GC_ZP_MASK, // paragraphseparator
595		U_GC_PC_MASK, // pc
596		U_GC_PD_MASK, // pd
597		U_GC_PE_MASK, // pe
598		U_GC_PF_MASK, // pf
599		U_GC_PI_MASK, // pi
600		U_GC_PO_MASK, // po
601		U_GC_CO_MASK, // privateuse
602		U_GC_PS_MASK, // ps
603		U_GC_P_MASK, // punctuation
604		U_GC_S_MASK, // s*
605		U_GC_SC_MASK, // sc
606		U_GC_Z_MASK, // separator
607		U_GC_SK_MASK, // sk
608		U_GC_SM_MASK, // sm
609		U_GC_SO_MASK, // so
610		U_GC_ZS_MASK, // spaceseparator
611		U_GC_MC_MASK, // spacingcombiningmark
612		U_GC_CS_MASK, // surrogate
613		U_GC_S_MASK, // symbol
614		U_GC_LT_MASK, // titlecase
615		U_GC_LT_MASK, // titlecaseletter
616		U_GC_LU_MASK, // uppercaseletter
617		U_GC_Z_MASK, // z*
618		U_GC_ZL_MASK, // zl
619		U_GC_ZP_MASK, // zp
620		U_GC_ZS_MASK, // zs
621		};
622
623
624	14669x	const BOOST_REGEX_DETAIL_NS::character_pointer_range< ::UChar32>* ranges_begin = range_data;
625	14669x	const BOOST_REGEX_DETAIL_NS::character_pointer_range< ::UChar32>* ranges_end = range_data + (sizeof(range_data) / sizeof(range_data[0]));
626
627	14669x	BOOST_REGEX_DETAIL_NS::character_pointer_range< ::UChar32> t = { p1, p2, };
628	14669x	const BOOST_REGEX_DETAIL_NS::character_pointer_range< ::UChar32>* p = std::lower_bound(ranges_begin, ranges_end, t);
629	14669x	if ((p != ranges_end) && (t == *p))
630	4643x	return icu_class_map[p - ranges_begin];
631	10026x	return 0;
632		}
633		std::shared_ptr< ::boost::BOOST_REGEX_DETAIL_NS::icu_regex_traits_implementation> m_pimpl;
634		};
635
636		} // namespace boost
637
638		namespace boost{
639
640		// types:
641		typedef basic_regex< ::UChar32, icu_regex_traits> u32regex;
642		typedef match_results<const ::UChar32*> u32match;
643		typedef match_results<const ::UChar*> u16match;
644
645		//
646		// Construction of 32-bit regex types from UTF-8 and UTF-16 primitives:
647		//
648		namespace BOOST_REGEX_DETAIL_NS{
649
650		template <class InputIterator>
651	59677x	inline u32regex do_make_u32regex(InputIterator i,
652		InputIterator j,
653		boost::regex_constants::syntax_option_type opt,
654		const std::integral_constant<int, 1>*)
655		{
656		typedef boost::u8_to_u32_iterator<InputIterator, UChar32> conv_type;
657	59677x	return u32regex(conv_type(i, i, j), conv_type(j, i, j), opt);
658		}
659
660		template <class InputIterator>
661	59666x	inline u32regex do_make_u32regex(InputIterator i,
662		InputIterator j,
663		boost::regex_constants::syntax_option_type opt,
664		const std::integral_constant<int, 2>*)
665		{
666		typedef boost::u16_to_u32_iterator<InputIterator, UChar32> conv_type;
667	59666x	return u32regex(conv_type(i, i, j), conv_type(j, i, j), opt);
668		}
669
670		template <class InputIterator>
671	1x	inline u32regex do_make_u32regex(InputIterator i,
672		InputIterator j,
673		boost::regex_constants::syntax_option_type opt,
674		const std::integral_constant<int, 4>*)
675		{
676	1x	return u32regex(i, j, opt);
677		}
678		}
679
680		// BOOST_REGEX_UCHAR_IS_WCHAR_T
681		//
682		// Source inspection of unicode/umachine.h in ICU version 59 indicates that:
683		//
684		// On version 59, UChar is always char16_t in C++ mode (and uint16_t in C mode)
685		//
686		// On earlier versions, the logic is
687		//
688		// #if U_SIZEOF_WCHAR_T==2
689		// typedef wchar_t OldUChar;
690		// #elif defined(__CHAR16_TYPE__)
691		// typedef __CHAR16_TYPE__ OldUChar;
692		// #else
693		// typedef uint16_t OldUChar;
694		// #endif
695		//
696		// That is, UChar is wchar_t only on versions below 59, when U_SIZEOF_WCHAR_T==2
697		//
698		// Hence,
699
700		#define BOOST_REGEX_UCHAR_IS_WCHAR_T (U_ICU_VERSION_MAJOR_NUM < 59 && U_SIZEOF_WCHAR_T == 2)
701
702		#if BOOST_REGEX_UCHAR_IS_WCHAR_T
703		static_assert((std::is_same<UChar, wchar_t>::value), "Configuration logic has failed!");
704		#else
705		static_assert(!(std::is_same<UChar, wchar_t>::value), "Configuration logic has failed!");
706		#endif
707
708		//
709		// Construction from an iterator pair:
710		//
711		template <class InputIterator>
712	63336x	inline u32regex make_u32regex(InputIterator i,
713		InputIterator j,
714		boost::regex_constants::syntax_option_type opt)
715		{
716	63336x	return BOOST_REGEX_DETAIL_NS::do_make_u32regex(i, j, opt, static_cast<std::integral_constant<int, sizeof(i)> const>(0));
717		}
718		//
719		// construction from UTF-8 nul-terminated strings:
720		//
721	5x	inline u32regex make_u32regex(const char* p, boost::regex_constants::syntax_option_type opt = boost::regex_constants::perl)
722		{
723	5x	return BOOST_REGEX_DETAIL_NS::do_make_u32regex(p, p + std::strlen(p), opt, static_cast<std::integral_constant<int, 1> const*>(0));
724		}
725	27996x	inline u32regex make_u32regex(const unsigned char* p, boost::regex_constants::syntax_option_type opt = boost::regex_constants::perl)
726		{
727	27996x	return BOOST_REGEX_DETAIL_NS::do_make_u32regex(p, p + std::strlen(reinterpret_cast<const char>(p)), opt, static_cast<std::integral_constant<int, 1> const>(0));
728		}
729		//
730		// construction from UTF-16 nul-terminated strings:
731		//
732		#ifndef BOOST_NO_WREGEX
733	1x	inline u32regex make_u32regex(const wchar_t* p, boost::regex_constants::syntax_option_type opt = boost::regex_constants::perl)
734		{
735	1x	return BOOST_REGEX_DETAIL_NS::do_make_u32regex(p, p + std::wcslen(p), opt, static_cast<std::integral_constant<int, sizeof(wchar_t)> const*>(0));
736		}
737		#endif
738		#if !BOOST_REGEX_UCHAR_IS_WCHAR_T
739	27996x	inline u32regex make_u32regex(const UChar* p, boost::regex_constants::syntax_option_type opt = boost::regex_constants::perl)
740		{
741	27996x	return BOOST_REGEX_DETAIL_NS::do_make_u32regex(p, p + u_strlen(p), opt, static_cast<std::integral_constant<int, 2> const*>(0));
742		}
743		#endif
744		//
745		// construction from basic_string class-template:
746		//
747		template<class C, class T, class A>
748	8x	inline u32regex make_u32regex(const std::basic_string<C, T, A>& s, boost::regex_constants::syntax_option_type opt = boost::regex_constants::perl)
749		{
750	8x	return BOOST_REGEX_DETAIL_NS::do_make_u32regex(s.begin(), s.end(), opt, static_cast<std::integral_constant<int, sizeof(C)> const*>(0));
751		}
752		//
753		// Construction from ICU string type:
754		//
755	2x	inline u32regex make_u32regex(const U_NAMESPACE_QUALIFIER UnicodeString& s, boost::regex_constants::syntax_option_type opt = boost::regex_constants::perl)
756		{
757	2x	return BOOST_REGEX_DETAIL_NS::do_make_u32regex(s.getBuffer(), s.getBuffer() + s.length(), opt, static_cast<std::integral_constant<int, 2> const*>(0));
758		}
759
760		//
761		// regex_match overloads that widen the character type as appropriate:
762		//
763		namespace BOOST_REGEX_DETAIL_NS{
764		template<class MR1, class MR2, class NSubs>
765	78808x	void copy_results(MR1& out, MR2 const& in, NSubs named_subs)
766		{
767		// copy results from an adapted MR2 match_results:
768	78808x	out.set_size(in.size(), in.prefix().first.base(), in.suffix().second.base());
769	78808x	out.set_base(in.base().base());
770	78808x	out.set_named_subs(named_subs);
771	213181x	for(int i = 0; i < (int)in.size(); ++i)
772		{
773	134373x	if(in[i].matched \|\| !i)
774		{
775	113202x	out.set_first(in[i].first.base(), i);
776	113202x	out.set_second(in[i].second.base(), i, in[i].matched);
777		}
778		}
779		#ifdef BOOST_REGEX_MATCH_EXTRA
780		// Copy full capture info as well:
781	35x	for(int i = 0; i < (int)in.size(); ++i)
782		{
783	27x	if(in[i].captures().size())
784		{
785	24x	out[i].get_captures().assign(in[i].captures().size(), typename MR1::value_type());
786	111x	for(int j = 0; j < (int)out[i].captures().size(); ++j)
787		{
788	87x	out[i].get_captures()[j].first = in[i].captures()[j].first.base();
789	87x	out[i].get_captures()[j].second = in[i].captures()[j].second.base();
790	87x	out[i].get_captures()[j].matched = in[i].captures()[j].matched;
791		}
792		}
793		}
794		#endif
795	78808x	}
796
797		template <class BidiIterator, class Allocator>
798	✗	inline bool do_regex_match(BidiIterator first, BidiIterator last,
799		match_results<BidiIterator, Allocator>& m,
800		const u32regex& e,
801		match_flag_type flags,
802		std::integral_constant<int, 4> const*)
803		{
804	✗	return ::boost::regex_match(first, last, m, e, flags);
805		}
806		template <class BidiIterator, class Allocator>
807	2x	bool do_regex_match(BidiIterator first, BidiIterator last,
808		match_results<BidiIterator, Allocator>& m,
809		const u32regex& e,
810		match_flag_type flags,
811		std::integral_constant<int, 2> const*)
812		{
813		typedef u16_to_u32_iterator<BidiIterator, UChar32> conv_type;
814		typedef match_results<conv_type> match_type;
815		//typedef typename match_type::allocator_type alloc_type;
816	2x	match_type what;
817	2x	bool result = ::boost::regex_match(conv_type(first, first, last), conv_type(last, first, last), what, e, flags);
818		// copy results across to m:
819	2x	if(result) copy_results(m, what, e.get_named_subs());
820	2x	return result;
821	2x	}
822		template <class BidiIterator, class Allocator>
823	10x	bool do_regex_match(BidiIterator first, BidiIterator last,
824		match_results<BidiIterator, Allocator>& m,
825		const u32regex& e,
826		match_flag_type flags,
827		std::integral_constant<int, 1> const*)
828		{
829		typedef u8_to_u32_iterator<BidiIterator, UChar32> conv_type;
830		typedef match_results<conv_type> match_type;
831		//typedef typename match_type::allocator_type alloc_type;
832	10x	match_type what;
833	10x	bool result = ::boost::regex_match(conv_type(first, first, last), conv_type(last, first, last), what, e, flags);
834		// copy results across to m:
835	10x	if(result) copy_results(m, what, e.get_named_subs());
836	10x	return result;
837	10x	}
838		} // namespace BOOST_REGEX_DETAIL_NS
839
840		BOOST_REGEX_MODULE_EXPORT template <class BidiIterator, class Allocator>
841	✗	inline bool u32regex_match(BidiIterator first, BidiIterator last,
842		match_results<BidiIterator, Allocator>& m,
843		const u32regex& e,
844		match_flag_type flags = match_default)
845		{
846	✗	return BOOST_REGEX_DETAIL_NS::do_regex_match(first, last, m, e, flags, static_cast<std::integral_constant<int, sizeof(first)> const>(0));
847		}
848	✗	BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const UChar* p,
849		match_results<const UChar*>& m,
850		const u32regex& e,
851		match_flag_type flags = match_default)
852		{
853	✗	return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+u_strlen(p), m, e, flags, static_cast<std::integral_constant<int, 2> const*>(0));
854		}
855		#if !BOOST_REGEX_UCHAR_IS_WCHAR_T && !defined(BOOST_NO_WREGEX)
856	✗	BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const wchar_t* p,
857		match_results<const wchar_t*>& m,
858		const u32regex& e,
859		match_flag_type flags = match_default)
860		{
861	✗	return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+std::wcslen(p), m, e, flags, static_cast<std::integral_constant<int, sizeof(wchar_t)> const*>(0));
862		}
863		#endif
864	✗	BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const char* p,
865		match_results<const char*>& m,
866		const u32regex& e,
867		match_flag_type flags = match_default)
868		{
869	✗	return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+std::strlen(p), m, e, flags, static_cast<std::integral_constant<int, 1> const*>(0));
870		}
871	✗	BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const unsigned char* p,
872		match_results<const unsigned char*>& m,
873		const u32regex& e,
874		match_flag_type flags = match_default)
875		{
876	✗	return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+std::strlen((const char)p), m, e, flags, static_cast<std::integral_constant<int, 1> const>(0));
877		}
878	10x	BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const std::string& s,
879		match_results<std::string::const_iterator>& m,
880		const u32regex& e,
881		match_flag_type flags = match_default)
882		{
883	10x	return BOOST_REGEX_DETAIL_NS::do_regex_match(s.begin(), s.end(), m, e, flags, static_cast<std::integral_constant<int, 1> const*>(0));
884		}
885		#ifndef BOOST_NO_STD_WSTRING
886	✗	BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const std::wstring& s,
887		match_results<std::wstring::const_iterator>& m,
888		const u32regex& e,
889		match_flag_type flags = match_default)
890		{
891	✗	return BOOST_REGEX_DETAIL_NS::do_regex_match(s.begin(), s.end(), m, e, flags, static_cast<std::integral_constant<int, sizeof(wchar_t)> const*>(0));
892		}
893		#endif
894	✗	BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const U_NAMESPACE_QUALIFIER UnicodeString& s,
895		match_results<const UChar*>& m,
896		const u32regex& e,
897		match_flag_type flags = match_default)
898		{
899	✗	return BOOST_REGEX_DETAIL_NS::do_regex_match(s.getBuffer(), s.getBuffer() + s.length(), m, e, flags, static_cast<std::integral_constant<int, 2> const*>(0));
900		}
901		//
902		// regex_match overloads that do not return what matched:
903		//
904		BOOST_REGEX_MODULE_EXPORT template <class BidiIterator>
905		inline bool u32regex_match(BidiIterator first, BidiIterator last,
906		const u32regex& e,
907		match_flag_type flags = match_default)
908		{
909		match_results<BidiIterator> m;
910		return BOOST_REGEX_DETAIL_NS::do_regex_match(first, last, m, e, flags, static_cast<std::integral_constant<int, sizeof(first)> const>(0));
911		}
912		BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const UChar* p,
913		const u32regex& e,
914		match_flag_type flags = match_default)
915		{
916		match_results<const UChar*> m;
917		return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+u_strlen(p), m, e, flags, static_cast<std::integral_constant<int, 2> const*>(0));
918		}
919		#if !BOOST_REGEX_UCHAR_IS_WCHAR_T && !defined(BOOST_NO_WREGEX)
920		BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const wchar_t* p,
921		const u32regex& e,
922		match_flag_type flags = match_default)
923		{
924		match_results<const wchar_t*> m;
925		return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+std::wcslen(p), m, e, flags, static_cast<std::integral_constant<int, sizeof(wchar_t)> const*>(0));
926		}
927		#endif
928		BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const char* p,
929		const u32regex& e,
930		match_flag_type flags = match_default)
931		{
932		match_results<const char*> m;
933		return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+std::strlen(p), m, e, flags, static_cast<std::integral_constant<int, 1> const*>(0));
934		}
935		BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const unsigned char* p,
936		const u32regex& e,
937		match_flag_type flags = match_default)
938		{
939		match_results<const unsigned char*> m;
940		return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+std::strlen((const char)p), m, e, flags, static_cast<std::integral_constant<int, 1> const>(0));
941		}
942		BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const std::string& s,
943		const u32regex& e,
944		match_flag_type flags = match_default)
945		{
946		match_results<std::string::const_iterator> m;
947		return BOOST_REGEX_DETAIL_NS::do_regex_match(s.begin(), s.end(), m, e, flags, static_cast<std::integral_constant<int, 1> const*>(0));
948		}
949		#ifndef BOOST_NO_STD_WSTRING
950		BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const std::wstring& s,
951		const u32regex& e,
952		match_flag_type flags = match_default)
953		{
954		match_results<std::wstring::const_iterator> m;
955		return BOOST_REGEX_DETAIL_NS::do_regex_match(s.begin(), s.end(), m, e, flags, static_cast<std::integral_constant<int, sizeof(wchar_t)> const*>(0));
956		}
957		#endif
958	2x	BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const U_NAMESPACE_QUALIFIER UnicodeString& s,
959		const u32regex& e,
960		match_flag_type flags = match_default)
961		{
962	2x	match_results<const UChar*> m;
963	4x	return BOOST_REGEX_DETAIL_NS::do_regex_match(s.getBuffer(), s.getBuffer() + s.length(), m, e, flags, static_cast<std::integral_constant<int, 2> const*>(0));
964	2x	}
965
966		//
967		// regex_search overloads that widen the character type as appropriate:
968		//
969		namespace BOOST_REGEX_DETAIL_NS{
970		template <class BidiIterator, class Allocator>
971	94624x	inline bool do_regex_search(BidiIterator first, BidiIterator last,
972		match_results<BidiIterator, Allocator>& m,
973		const u32regex& e,
974		match_flag_type flags,
975		BidiIterator base,
976		std::integral_constant<int, 4> const*)
977		{
978	94624x	return ::boost::regex_search(first, last, m, e, flags, base);
979		}
980		template <class BidiIterator, class Allocator>
981	48805x	bool do_regex_search(BidiIterator first, BidiIterator last,
982		match_results<BidiIterator, Allocator>& m,
983		const u32regex& e,
984		match_flag_type flags,
985		BidiIterator base,
986		std::integral_constant<int, 2> const*)
987		{
988		typedef u16_to_u32_iterator<BidiIterator, UChar32> conv_type;
989		typedef match_results<conv_type> match_type;
990		//typedef typename match_type::allocator_type alloc_type;
991	48805x	match_type what;
992	48805x	bool result = ::boost::regex_search(conv_type(first, first, last), conv_type(last, first, last), what, e, flags, conv_type(base));
993		// copy results across to m:
994	48805x	if(result) copy_results(m, what, e.get_named_subs());
995	52872x	return result;
996	48805x	}
997		template <class BidiIterator, class Allocator>
998	48810x	bool do_regex_search(BidiIterator first, BidiIterator last,
999		match_results<BidiIterator, Allocator>& m,
1000		const u32regex& e,
1001		match_flag_type flags,
1002		BidiIterator base,
1003		std::integral_constant<int, 1> const*)
1004		{
1005		typedef u8_to_u32_iterator<BidiIterator, UChar32> conv_type;
1006		typedef match_results<conv_type> match_type;
1007		//typedef typename match_type::allocator_type alloc_type;
1008	48810x	match_type what;
1009	48810x	bool result = ::boost::regex_search(conv_type(first, first, last), conv_type(last, first, last), what, e, flags, conv_type(base));
1010		// copy results across to m:
1011	48810x	if(result) copy_results(m, what, e.get_named_subs());
1012	52877x	return result;
1013	48810x	}
1014		}
1015
1016		BOOST_REGEX_MODULE_EXPORT template <class BidiIterator, class Allocator>
1017	73576x	inline bool u32regex_search(BidiIterator first, BidiIterator last,
1018		match_results<BidiIterator, Allocator>& m,
1019		const u32regex& e,
1020		match_flag_type flags = match_default)
1021		{
1022	73576x	return BOOST_REGEX_DETAIL_NS::do_regex_search(first, last, m, e, flags, first, static_cast<std::integral_constant<int, sizeof(first)> const>(0));
1023		}
1024		BOOST_REGEX_MODULE_EXPORT template <class BidiIterator, class Allocator>
1025	70062x	inline bool u32regex_search(BidiIterator first, BidiIterator last,
1026		match_results<BidiIterator, Allocator>& m,
1027		const u32regex& e,
1028		match_flag_type flags,
1029		BidiIterator base)
1030		{
1031	70062x	return BOOST_REGEX_DETAIL_NS::do_regex_search(first, last, m, e, flags, base, static_cast<std::integral_constant<int, sizeof(first)> const>(0));
1032		}
1033	24300x	BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const UChar* p,
1034		match_results<const UChar*>& m,
1035		const u32regex& e,
1036		match_flag_type flags = match_default)
1037		{
1038	24300x	return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+u_strlen(p), m, e, flags, p, static_cast<std::integral_constant<int, 2> const*>(0));
1039		}
1040		#if !BOOST_REGEX_UCHAR_IS_WCHAR_T && !defined(BOOST_NO_WREGEX)
1041	✗	BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const wchar_t* p,
1042		match_results<const wchar_t*>& m,
1043		const u32regex& e,
1044		match_flag_type flags = match_default)
1045		{
1046	✗	return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+std::wcslen(p), m, e, flags, p, static_cast<std::integral_constant<int, sizeof(wchar_t)> const*>(0));
1047		}
1048		#endif
1049	✗	BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const char* p,
1050		match_results<const char*>& m,
1051		const u32regex& e,
1052		match_flag_type flags = match_default)
1053		{
1054	✗	return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+std::strlen(p), m, e, flags, p, static_cast<std::integral_constant<int, 1> const*>(0));
1055		}
1056	24300x	BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const unsigned char* p,
1057		match_results<const unsigned char*>& m,
1058		const u32regex& e,
1059		match_flag_type flags = match_default)
1060		{
1061	24300x	return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+std::strlen((const char)p), m, e, flags, p, static_cast<std::integral_constant<int, 1> const>(0));
1062		}
1063	✗	BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const std::string& s,
1064		match_results<std::string::const_iterator>& m,
1065		const u32regex& e,
1066		match_flag_type flags = match_default)
1067		{
1068	✗	return BOOST_REGEX_DETAIL_NS::do_regex_search(s.begin(), s.end(), m, e, flags, s.begin(), static_cast<std::integral_constant<int, 1> const*>(0));
1069		}
1070		#ifndef BOOST_NO_STD_WSTRING
1071	✗	BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const std::wstring& s,
1072		match_results<std::wstring::const_iterator>& m,
1073		const u32regex& e,
1074		match_flag_type flags = match_default)
1075		{
1076	✗	return BOOST_REGEX_DETAIL_NS::do_regex_search(s.begin(), s.end(), m, e, flags, s.begin(), static_cast<std::integral_constant<int, sizeof(wchar_t)> const*>(0));
1077		}
1078		#endif
1079	1x	BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const U_NAMESPACE_QUALIFIER UnicodeString& s,
1080		match_results<const UChar*>& m,
1081		const u32regex& e,
1082		match_flag_type flags = match_default)
1083		{
1084	1x	return BOOST_REGEX_DETAIL_NS::do_regex_search(s.getBuffer(), s.getBuffer() + s.length(), m, e, flags, s.getBuffer(), static_cast<std::integral_constant<int, 2> const*>(0));
1085		}
1086		BOOST_REGEX_MODULE_EXPORT template <class BidiIterator>
1087		inline bool u32regex_search(BidiIterator first, BidiIterator last,
1088		const u32regex& e,
1089		match_flag_type flags = match_default)
1090		{
1091		match_results<BidiIterator> m;
1092		return BOOST_REGEX_DETAIL_NS::do_regex_search(first, last, m, e, flags, first, static_cast<std::integral_constant<int, sizeof(first)> const>(0));
1093		}
1094		BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const UChar* p,
1095		const u32regex& e,
1096		match_flag_type flags = match_default)
1097		{
1098		match_results<const UChar*> m;
1099		return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+u_strlen(p), m, e, flags, p, static_cast<std::integral_constant<int, 2> const*>(0));
1100		}
1101		#if !BOOST_REGEX_UCHAR_IS_WCHAR_T && !defined(BOOST_NO_WREGEX)
1102		BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const wchar_t* p,
1103		const u32regex& e,
1104		match_flag_type flags = match_default)
1105		{
1106		match_results<const wchar_t*> m;
1107		return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+std::wcslen(p), m, e, flags, p, static_cast<std::integral_constant<int, sizeof(wchar_t)> const*>(0));
1108		}
1109		#endif
1110		BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const char* p,
1111		const u32regex& e,
1112		match_flag_type flags = match_default)
1113		{
1114		match_results<const char*> m;
1115		return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+std::strlen(p), m, e, flags, p, static_cast<std::integral_constant<int, 1> const*>(0));
1116		}
1117		BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const unsigned char* p,
1118		const u32regex& e,
1119		match_flag_type flags = match_default)
1120		{
1121		match_results<const unsigned char*> m;
1122		return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+std::strlen((const char)p), m, e, flags, p, static_cast<std::integral_constant<int, 1> const>(0));
1123		}
1124		BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const std::string& s,
1125		const u32regex& e,
1126		match_flag_type flags = match_default)
1127		{
1128		match_results<std::string::const_iterator> m;
1129		return BOOST_REGEX_DETAIL_NS::do_regex_search(s.begin(), s.end(), m, e, flags, s.begin(), static_cast<std::integral_constant<int, 1> const*>(0));
1130		}
1131		#ifndef BOOST_NO_STD_WSTRING
1132		BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const std::wstring& s,
1133		const u32regex& e,
1134		match_flag_type flags = match_default)
1135		{
1136		match_results<std::wstring::const_iterator> m;
1137		return BOOST_REGEX_DETAIL_NS::do_regex_search(s.begin(), s.end(), m, e, flags, s.begin(), static_cast<std::integral_constant<int, sizeof(wchar_t)> const*>(0));
1138		}
1139		#endif
1140		BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const U_NAMESPACE_QUALIFIER UnicodeString& s,
1141		const u32regex& e,
1142		match_flag_type flags = match_default)
1143		{
1144		match_results<const UChar*> m;
1145		return BOOST_REGEX_DETAIL_NS::do_regex_search(s.getBuffer(), s.getBuffer() + s.length(), m, e, flags, s.getBuffer(), static_cast<std::integral_constant<int, 2> const*>(0));
1146		}
1147
1148		//
1149		// overloads for regex_replace with utf-8 and utf-16 data types:
1150		//
1151		namespace BOOST_REGEX_DETAIL_NS{
1152		template <class I>
1153		inline std::pair< boost::u8_to_u32_iterator<I>, boost::u8_to_u32_iterator<I> >
1154	3672x	make_utf32_seq(I i, I j, std::integral_constant<int, 1> const*)
1155		{
1156	3672x	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));
1157		}
1158		template <class I>
1159		inline std::pair< boost::u16_to_u32_iterator<I>, boost::u16_to_u32_iterator<I> >
1160	5510x	make_utf32_seq(I i, I j, std::integral_constant<int, 2> const*)
1161		{
1162	5510x	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));
1163		}
1164		template <class I>
1165		inline std::pair< I, I >
1166	1836x	make_utf32_seq(I i, I j, std::integral_constant<int, 4> const*)
1167		{
1168	1836x	return std::pair< I, I >(i, j);
1169		}
1170		template <class charT>
1171		inline std::pair< boost::u8_to_u32_iterator<const charT>, boost::u8_to_u32_iterator<const charT> >
1172	3672x	make_utf32_seq(const charT* p, std::integral_constant<int, 1> const*)
1173		{
1174	3672x	std::size_t len = std::strlen((const char*)p);
1175	3672x	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));
1176		}
1177		template <class charT>
1178		inline std::pair< boost::u16_to_u32_iterator<const charT>, boost::u16_to_u32_iterator<const charT> >
1179	1836x	make_utf32_seq(const charT* p, std::integral_constant<int, 2> const*)
1180		{
1181	1836x	std::size_t len = u_strlen((const UChar*)p);
1182	1836x	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));
1183		}
1184		template <class charT>
1185		inline std::pair< const charT, const charT >
1186	1836x	make_utf32_seq(const charT* p, std::integral_constant<int, 4> const*)
1187		{
1188	1836x	return std::pair< const charT, const charT >(p, p+icu_regex_traits::length((UChar32 const*)p));
1189		}
1190		template <class OutputIterator>
1191	1836x	inline OutputIterator make_utf32_out(OutputIterator o, std::integral_constant<int, 4> const*)
1192		{
1193	1836x	return o;
1194		}
1195		template <class OutputIterator>
1196	3673x	inline utf16_output_iterator<OutputIterator> make_utf32_out(OutputIterator o, std::integral_constant<int, 2> const*)
1197		{
1198	3673x	return o;
1199		}
1200		template <class OutputIterator>
1201	3672x	inline utf8_output_iterator<OutputIterator> make_utf32_out(OutputIterator o, std::integral_constant<int, 1> const*)
1202		{
1203	3672x	return o;
1204		}
1205
1206		template <class OutputIterator, class I1, class I2>
1207	9181x	OutputIterator do_regex_replace(OutputIterator out,
1208		std::pair<I1, I1> const& in,
1209		const u32regex& e,
1210		const std::pair<I2, I2>& fmt,
1211		match_flag_type flags
1212		)
1213		{
1214		// unfortunately we have to copy the format string in order to pass in onward:
1215	9181x	std::vector<UChar32> f;
1216	9181x	f.assign(fmt.first, fmt.second);
1217
1218	9181x	regex_iterator<I1, UChar32, icu_regex_traits> i(in.first, in.second, e, flags);
1219	9181x	regex_iterator<I1, UChar32, icu_regex_traits> j;
1220	9181x	if(i == j)
1221		{
1222	120x	if(!(flags & regex_constants::format_no_copy))
1223	60x	out = std::copy(in.first, in.second, out);
1224		}
1225		else
1226		{
1227	9061x	I1 last_m = in.first;
1228	25082x	while(i != j)
1229		{
1230	16261x	if(!(flags & regex_constants::format_no_copy))
1231	9961x	out = std::copy(i->prefix().first, i->prefix().second, out);
1232	16261x	if(!f.empty())
1233	16261x	out = ::boost::BOOST_REGEX_DETAIL_NS::regex_format_imp(out, i, &f.begin(), &*f.begin() + f.size(), flags, e.get_traits());
1234		else
1235	✗	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());
1236	16261x	last_m = (*i)[0].second;
1237	16261x	if(flags & regex_constants::format_first_only)
1238	240x	break;
1239	16021x	++i;
1240		}
1241	9061x	if(!(flags & regex_constants::format_no_copy))
1242	3181x	out = std::copy(last_m, in.second, out);
1243		}
1244	16067x	return out;
1245	9181x	}
1246		template <class BaseIterator>
1247	1836x	inline const BaseIterator& extract_output_base(const BaseIterator& b)
1248		{
1249	1836x	return b;
1250		}
1251		template <class BaseIterator>
1252	3672x	inline BaseIterator extract_output_base(const utf8_output_iterator<BaseIterator>& b)
1253		{
1254	3672x	return b.base();
1255		}
1256		template <class BaseIterator>
1257	1836x	inline BaseIterator extract_output_base(const utf16_output_iterator<BaseIterator>& b)
1258		{
1259	1836x	return b.base();
1260		}
1261		} // BOOST_REGEX_DETAIL_NS
1262
1263		BOOST_REGEX_MODULE_EXPORT template <class OutputIterator, class BidirectionalIterator, class charT>
1264	7344x	inline OutputIterator u32regex_replace(OutputIterator out,
1265		BidirectionalIterator first,
1266		BidirectionalIterator last,
1267		const u32regex& e,
1268		const charT* fmt,
1269		match_flag_type flags = match_default)
1270		{
1271		return BOOST_REGEX_DETAIL_NS::extract_output_base
1272	7344x	(
1273	1836x	BOOST_REGEX_DETAIL_NS::do_regex_replace(
1274		BOOST_REGEX_DETAIL_NS::make_utf32_out(out, static_cast<std::integral_constant<int, sizeof(first)> const>(0)),
1275	7344x	BOOST_REGEX_DETAIL_NS::make_utf32_seq(first, last, static_cast<std::integral_constant<int, sizeof(first)> const>(0)),
1276		e,
1277	12852x	BOOST_REGEX_DETAIL_NS::make_utf32_seq(fmt, static_cast<std::integral_constant<int, sizeof(fmt)> const>(0)),
1278		flags)
1279	12393x	);
1280		}
1281
1282		BOOST_REGEX_MODULE_EXPORT template <class OutputIterator, class Iterator, class charT>
1283	✗	inline OutputIterator u32regex_replace(OutputIterator out,
1284		Iterator first,
1285		Iterator last,
1286		const u32regex& e,
1287		const std::basic_string<charT>& fmt,
1288		match_flag_type flags = match_default)
1289		{
1290		return BOOST_REGEX_DETAIL_NS::extract_output_base
1291	✗	(
1292		BOOST_REGEX_DETAIL_NS::do_regex_replace(
1293		BOOST_REGEX_DETAIL_NS::make_utf32_out(out, static_cast<std::integral_constant<int, sizeof(first)> const>(0)),
1294		BOOST_REGEX_DETAIL_NS::make_utf32_seq(first, last, static_cast<std::integral_constant<int, sizeof(first)> const>(0)),
1295		e,
1296	✗	BOOST_REGEX_DETAIL_NS::make_utf32_seq(fmt.begin(), fmt.end(), static_cast<std::integral_constant<int, sizeof(charT)> const*>(0)),
1297		flags)
1298	✗	);
1299		}
1300
1301		BOOST_REGEX_MODULE_EXPORT template <class OutputIterator, class Iterator>
1302	✗	inline OutputIterator u32regex_replace(OutputIterator out,
1303		Iterator first,
1304		Iterator last,
1305		const u32regex& e,
1306		const U_NAMESPACE_QUALIFIER UnicodeString& fmt,
1307		match_flag_type flags = match_default)
1308		{
1309		return BOOST_REGEX_DETAIL_NS::extract_output_base
1310	✗	(
1311		BOOST_REGEX_DETAIL_NS::do_regex_replace(
1312		BOOST_REGEX_DETAIL_NS::make_utf32_out(out, static_cast<std::integral_constant<int, sizeof(first)> const>(0)),
1313		BOOST_REGEX_DETAIL_NS::make_utf32_seq(first, last, static_cast<std::integral_constant<int, sizeof(first)> const>(0)),
1314		e,
1315	✗	BOOST_REGEX_DETAIL_NS::make_utf32_seq(fmt.getBuffer(), fmt.getBuffer() + fmt.length(), static_cast<std::integral_constant<int, 2> const*>(0)),
1316		flags)
1317	✗	);
1318		}
1319
1320		BOOST_REGEX_MODULE_EXPORT template <class charT>
1321	✗	std::basic_string<charT> u32regex_replace(const std::basic_string<charT>& s,
1322		const u32regex& e,
1323		const charT* fmt,
1324		match_flag_type flags = match_default)
1325		{
1326	✗	std::basic_string<charT> result;
1327	✗	BOOST_REGEX_DETAIL_NS::string_out_iterator<std::basic_string<charT> > i(result);
1328	✗	u32regex_replace(i, s.begin(), s.end(), e, fmt, flags);
1329	✗	return result;
1330	✗	}
1331
1332		BOOST_REGEX_MODULE_EXPORT template <class charT>
1333	1836x	std::basic_string<charT> u32regex_replace(const std::basic_string<charT>& s,
1334		const u32regex& e,
1335		const std::basic_string<charT>& fmt,
1336		match_flag_type flags = match_default)
1337		{
1338	1836x	std::basic_string<charT> result;
1339	1836x	BOOST_REGEX_DETAIL_NS::string_out_iterator<std::basic_string<charT> > i(result);
1340	1836x	u32regex_replace(i, s.begin(), s.end(), e, fmt.c_str(), flags);
1341	3519x	return result;
1342	✗	}
1343
1344		namespace BOOST_REGEX_DETAIL_NS{
1345
1346		class unicode_string_out_iterator
1347		{
1348		U_NAMESPACE_QUALIFIER UnicodeString* out;
1349		public:
1350	1837x	unicode_string_out_iterator(U_NAMESPACE_QUALIFIER UnicodeString& s) : out(&s) {}
1351		unicode_string_out_iterator& operator++() { return *this; }
1352	11371x	unicode_string_out_iterator& operator++(int) { return *this; }
1353	11371x	unicode_string_out_iterator& operator() { return this; }
1354	11371x	unicode_string_out_iterator& operator=(UChar v)
1355		{
1356	11371x	*out += v;
1357	11371x	return *this;
1358		}
1359		typedef std::ptrdiff_t difference_type;
1360		typedef UChar value_type;
1361		typedef value_type* pointer;
1362		typedef value_type& reference;
1363		typedef std::output_iterator_tag iterator_category;
1364		};
1365
1366		}
1367
1368		inline U_NAMESPACE_QUALIFIER UnicodeString u32regex_replace(const U_NAMESPACE_QUALIFIER UnicodeString& s,
1369		const u32regex& e,
1370		const UChar* fmt,
1371		match_flag_type flags = match_default)
1372		{
1373		U_NAMESPACE_QUALIFIER UnicodeString result;
1374		BOOST_REGEX_DETAIL_NS::unicode_string_out_iterator i(result);
1375		u32regex_replace(i, s.getBuffer(), s.getBuffer()+s.length(), e, fmt, flags);
1376		return result;
1377		}
1378
1379	1837x	inline U_NAMESPACE_QUALIFIER UnicodeString u32regex_replace(const U_NAMESPACE_QUALIFIER UnicodeString& s,
1380		const u32regex& e,
1381		const U_NAMESPACE_QUALIFIER UnicodeString& fmt,
1382		match_flag_type flags = match_default)
1383		{
1384	1837x	U_NAMESPACE_QUALIFIER UnicodeString result;
1385	1837x	BOOST_REGEX_DETAIL_NS::unicode_string_out_iterator i(result);
1386	1837x	BOOST_REGEX_DETAIL_NS::do_regex_replace(
1387	1837x	BOOST_REGEX_DETAIL_NS::make_utf32_out(i, static_cast<std::integral_constant<int, 2> const*>(0)),
1388	1837x	BOOST_REGEX_DETAIL_NS::make_utf32_seq(s.getBuffer(), s.getBuffer()+s.length(), static_cast<std::integral_constant<int, 2> const*>(0)),
1389		e,
1390	1837x	BOOST_REGEX_DETAIL_NS::make_utf32_seq(fmt.getBuffer(), fmt.getBuffer() + fmt.length(), static_cast<std::integral_constant<int, 2> const*>(0)),
1391		flags);
1392	3521x	return result;
1393	✗	}
1394
1395		} // namespace boost.
1396
1397		#ifdef BOOST_REGEX_MSVC
1398		#pragma warning (pop)
1399		#endif
1400
1401		#include <boost/regex/v5/u32regex_iterator.hpp>
1402		#include <boost/regex/v5/u32regex_token_iterator.hpp>
1403
1404		#endif
1405