## include/boost/regex/v5/regex_traits_defaults.hpp

96.5% Lines (83/86) 90.5% List of functions (38/43)
regex_traits_defaults.hpp
f(x) Functions (43)
Function Calls Lines Blocks
bool boost::re_detail_600::is_extended<wchar_t>(wchar_t) :43 6576x 100.0% 100.0% boost::re_detail_600::is_extended(char) :48 0 0.0% 0.0% boost::re_detail_600::get_default_syntax(unsigned char) :51 2596x 100.0% 83.0% boost::re_detail_600::get_default_error_string(boost::regex_constants::error_type) :121 44651x 100.0% 80.0% <unknown function 151> :151 – – – boost::re_detail_600::get_default_syntax_type(char) :154 7574840x 100.0% 100.0% boost::re_detail_600::get_default_escape_syntax_type(char) :349 887628x 100.0% 100.0% boost::re_detail_600::is_combining_implementation(unsigned short) :545 3144x 80.0% 89.0% bool boost::re_detail_600::is_combining<char32_t>(char32_t) :595 0 0.0% 0.0% bool boost::re_detail_600::is_combining<int>(int) :595 864x 100.0% 100.0% bool boost::re_detail_600::is_combining<wchar_t>(wchar_t) :595 2280x 100.0% 100.0% bool boost::re_detail_600::is_combining<char>(char) :600 1668x 100.0% 100.0% bool boost::re_detail_600::is_separator<char32_t>(char32_t) :640 0 0.0% 0.0% bool boost::re_detail_600::is_separator<int>(int) :640 245618x 100.0% 100.0% bool boost::re_detail_600::is_separator<unsigned int>(unsigned int) :640 384x 100.0% 90.0% bool boost::re_detail_600::is_separator<wchar_t>(wchar_t) :640 429926x 100.0% 100.0% bool boost::re_detail_600::is_separator<char>(char) :651 184105598x 100.0% 100.0% boost::re_detail_600::lookup_default_collate_name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) :659 22420x 92.3% 100.0% boost::re_detail_600::character_pointer_range<char>::operator<(boost::re_detail_600::character_pointer_range<char> const&) const :741 3096776x 100.0% 100.0% boost::re_detail_600::character_pointer_range<int>::operator<(boost::re_detail_600::character_pointer_range<int> const&) const :741 3832790x 100.0% 100.0% boost::re_detail_600::character_pointer_range<wchar_t>::operator<(boost::re_detail_600::character_pointer_range<wchar_t> const&) const :741 3111867x 100.0% 100.0% boost::re_detail_600::character_pointer_range<char>::operator==(boost::re_detail_600::character_pointer_range<char> const&) const :745 671596x 100.0% 100.0% boost::re_detail_600::character_pointer_range<int>::operator==(boost::re_detail_600::character_pointer_range<int> const&) const :745 824372x 100.0% 100.0% boost::re_detail_600::character_pointer_range<wchar_t>::operator==(boost::re_detail_600::character_pointer_range<wchar_t> const&) const :745 674833x 100.0% 100.0% int boost::re_detail_600::get_default_class_id<char>(char const*, char const*) :768 671596x 100.0% 100.0% int boost::re_detail_600::get_default_class_id<int>(int const*, int const*) :768 809947x 100.0% 100.0% int boost::re_detail_600::get_default_class_id<wchar_t>(wchar_t const*, wchar_t const*) :768 674833x 100.0% 100.0% boost::re_detail_600::do_global_lower(char) :859 180x 100.0% 100.0% boost::re_detail_600::do_global_upper(char) :864 132x 100.0% 100.0% boost::re_detail_600::do_global_lower(wchar_t) :869 180x 100.0% 100.0% boost::re_detail_600::do_global_upper(wchar_t) :874 132x 100.0% 100.0% char boost::re_detail_600::global_lower<char>(char) :889 180x 100.0% 100.0% char boost::re_detail_600::global_upper<char>(char) :890 132x 100.0% 100.0% wchar_t boost::re_detail_600::global_lower<wchar_t>(wchar_t) :892 180x 100.0% 100.0% wchar_t boost::re_detail_600::global_upper<wchar_t>(wchar_t) :893 132x 100.0% 100.0% long boost::re_detail_600::global_toi<char, boost::re_detail_600::default_wrapper<boost::c_regex_traits<char> > >(char const*&, char const*, int, boost::re_detail_600::default_wrapper<boost::c_regex_traits<char> > const&) :915 227820x 93.3% 94.0% long boost::re_detail_600::global_toi<char32_t, boost::re_detail_600::default_wrapper<char32_traits> >(char32_t const*&, char32_t const*, int, boost::re_detail_600::default_wrapper<char32_traits> const&) :915 8x 86.7% 88.0% long boost::re_detail_600::global_toi<int, boost::icu_regex_traits>(int const*&, int const*, int, boost::icu_regex_traits const&) :915 80339x 93.3% 94.0% long boost::re_detail_600::global_toi<wchar_t, boost::re_detail_600::default_wrapper<boost::c_regex_traits<wchar_t> > >(wchar_t const*&, wchar_t const*, int, boost::re_detail_600::default_wrapper<boost::c_regex_traits<wchar_t> > const&) :915 37464x 93.3% 94.0% std::enable_if<((sizeof (char32_t))>(1)), char32_t const*>::type boost::re_detail_600::get_escape_R_string<char32_t>() :938 0 0.0% 0.0% std::enable_if<((sizeof (int))>(1)), int const*>::type boost::re_detail_600::get_escape_R_string<int>() :938 1440x 100.0% 80.0% std::enable_if<((sizeof (wchar_t))>(1)), wchar_t const*>::type boost::re_detail_600::get_escape_R_string<wchar_t>() :938 1296x 100.0% 80.0% std::enable_if<(sizeof (char))==(1), char const*>::type boost::re_detail_600::get_escape_R_string<char>() :960 864x 100.0% 100.0%

Line | TLA | 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 regex_traits_defaults.hpp
15 |  |  | * VERSION see <boost/version.hpp>
16 |  |  | * DESCRIPTION: Declares API's for access to regex_traits default properties.
17 |  |  | */
18 |  |  |
19 |  |  | #ifndef BOOST_REGEX_TRAITS_DEFAULTS_HPP_INCLUDED
20 |  |  | #define BOOST_REGEX_TRAITS_DEFAULTS_HPP_INCLUDED
21 |  |  |
22 |  |  | #include <boost/regex/config.hpp>
23 |  |  |
24 |  |  | #include <boost/regex/v5/syntax_type.hpp>
25 |  |  | #include <boost/regex/v5/error_type.hpp>
26 |  |  | #include <boost/regex/v5/regex_workaround.hpp>
27 |  |  | #ifndef BOOST_REGEX_AS_MODULE
28 |  |  | #include <type_traits>
29 |  |  | #include <cstdint>
30 |  |  | #include <cctype>
31 |  |  | #include <locale>
32 |  |  | #include <cwctype>
33 |  |  | #include <limits>
34 |  |  | #endif
35 |  |  |
36 |  |  | namespace boost{ namespace BOOST_REGEX_DETAIL_NS{
37 |  |  |
38 |  |  |
39 |  |  | //
40 |  |  | // helpers to suppress warnings:
41 |  |  | //
42 |  |  | template <class charT>
43 |  | 6576x | inline bool is_extended(charT c)
44 |  |  | {
45 |  |  | typedef typename std::make_unsigned<charT>::type unsigned_type;
46 |  | 6576x | return (sizeof(charT) > 1) && (static_cast<unsigned_type>(c) >= 256u);
47 |  |  | }
48 |  | ✗ | inline bool is_extended(char)
49 |  | ✗ | { return false; }
50 |  |  |
51 |  | 2596x | inline const char* get_default_syntax(regex_constants::syntax_type n)
52 |  |  | {
53 |  |  | // if the user hasn't supplied a message catalog, then this supplies
54 |  |  | // default "messages" for us to load in the range 1-100.
55 |  | 2596x | const char* messages[] = {
56 |  |  | "",
57 |  |  | "(",
58 |  |  | ")",
59 |  |  | "$",
60 |  |  | "^",
61 |  |  | ".",
62 |  |  | "*",
63 |  |  | "+",
64 |  |  | "?",
65 |  |  | "[",
66 |  |  | "]",
67 |  |  | "|",
68 |  |  | "\\",
69 |  |  | "#",
70 |  |  | "-",
71 |  |  | "{",
72 |  |  | "}",
73 |  |  | "0123456789",
74 |  |  | "b",
75 |  |  | "B",
76 |  |  | "<",
77 |  |  | ">",
78 |  |  | "",
79 |  |  | "",
80 |  |  | "A`",
81 |  |  | "z'",
82 |  |  | "\n",
83 |  |  | ",",
84 |  |  | "a",
85 |  |  | "f",
86 |  |  | "n",
87 |  |  | "r",
88 |  |  | "t",
89 |  |  | "v",
90 |  |  | "x",
91 |  |  | "c",
92 |  |  | ":",
93 |  |  | "=",
94 |  |  | "e",
95 |  |  | "",
96 |  |  | "",
97 |  |  | "",
98 |  |  | "",
99 |  |  | "",
100 |  |  | "",
101 |  |  | "",
102 |  |  | "",
103 |  |  | "E",
104 |  |  | "Q",
105 |  |  | "X",
106 |  |  | "C",
107 |  |  | "Z",
108 |  |  | "G",
109 |  |  | "!",
110 |  |  | "p",
111 |  |  | "P",
112 |  |  | "N",
113 |  |  | "gk",
114 |  |  | "K",
115 |  |  | "R",
116 |  |  | };
117 |  |  |
118 |  | 2596x | return ((n >= (sizeof(messages) / sizeof(messages[1]))) ? "" : messages[n]);
119 |  |  | }
120 |  |  |
121 |  | 44651x | inline const char* get_default_error_string(regex_constants::error_type n)
122 |  |  | {
123 |  |  | static const char* const s_default_error_messages[] = {
124 |  |  | "Success", /* REG_NOERROR 0 error_ok */
125 |  |  | "No match", /* REG_NOMATCH 1 error_no_match */
126 |  |  | "Invalid regular expression.", /* REG_BADPAT 2 error_bad_pattern */
127 |  |  | "Invalid collation character.", /* REG_ECOLLATE 3 error_collate */
128 |  |  | "Invalid character class name, collating name, or character range.", /* REG_ECTYPE 4 error_ctype */
129 |  |  | "Invalid or unterminated escape sequence.", /* REG_EESCAPE 5 error_escape */
130 |  |  | "Invalid back reference: specified capturing group does not exist.", /* REG_ESUBREG 6 error_backref */
131 |  |  | "Unmatched [ or [^ in character class declaration.", /* REG_EBRACK 7 error_brack */
132 |  |  | "Unmatched marking parenthesis ( or \\(.", /* REG_EPAREN 8 error_paren */
133 |  |  | "Unmatched quantified repeat operator { or \\{.", /* REG_EBRACE 9 error_brace */
134 |  |  | "Invalid content of repeat range.", /* REG_BADBR 10 error_badbrace */
135 |  |  | "Invalid range end in character class", /* REG_ERANGE 11 error_range */
136 |  |  | "Out of memory.", /* REG_ESPACE 12 error_space NOT USED */
137 |  |  | "Invalid preceding regular expression prior to repetition operator.", /* REG_BADRPT 13 error_badrepeat */
138 |  |  | "Premature end of regular expression", /* REG_EEND 14 error_end NOT USED */
139 |  |  | "Regular expression is too large.", /* REG_ESIZE 15 error_size NOT USED */
140 |  |  | "Unmatched ) or \\)", /* REG_ERPAREN 16 error_right_paren NOT USED */
141 |  |  | "Empty regular expression.", /* REG_EMPTY 17 error_empty */
142 |  |  | "The complexity of matching the regular expression exceeded predefined bounds. "
143 |  |  | "Try refactoring the regular expression to make each choice made by the state machine unambiguous. "
144 |  |  | "This exception is thrown to prevent \"eternal\" matches that take an "
145 |  |  | "indefinite period time to locate.", /* REG_ECOMPLEXITY 18 error_complexity */
146 |  |  | "Ran out of stack space trying to match the regular expression.", /* REG_ESTACK 19 error_stack */
147 |  |  | "Invalid or unterminated Perl (?...) sequence.", /* REG_E_PERL 20 error_perl */
148 |  |  | "Unknown error.", /* REG_E_UNKNOWN 21 error_unknown */
149 |  |  | };
150 |  |  |
151 |  | 44651x | return (n > ::boost::regex_constants::error_unknown) ? s_default_error_messages[::boost::regex_constants::error_unknown] : s_default_error_messages[n];
152 |  |  | }
153 |  |  |
154 |  | 7574840x | inline regex_constants::syntax_type get_default_syntax_type(char c)
155 |  |  | {
156 |  |  | //
157 |  |  | // char_syntax determines how the compiler treats a given character
158 |  |  | // in a regular expression.
159 |  |  | //
160 |  |  | static regex_constants::syntax_type char_syntax[] = {
161 |  |  | regex_constants::syntax_char, /**/
162 |  |  | regex_constants::syntax_char, /**/
163 |  |  | regex_constants::syntax_char, /**/
164 |  |  | regex_constants::syntax_char, /**/
165 |  |  | regex_constants::syntax_char, /**/
166 |  |  | regex_constants::syntax_char, /**/
167 |  |  | regex_constants::syntax_char, /**/
168 |  |  | regex_constants::syntax_char, /**/
169 |  |  | regex_constants::syntax_char, /**/
170 |  |  | regex_constants::syntax_char, /**/
171 |  |  | regex_constants::syntax_newline, /**/
172 |  |  | regex_constants::syntax_char, /**/
173 |  |  | regex_constants::syntax_char, /**/
174 |  |  | regex_constants::syntax_char, /**/
175 |  |  | regex_constants::syntax_char, /**/
176 |  |  | regex_constants::syntax_char, /**/
177 |  |  | regex_constants::syntax_char, /**/
178 |  |  | regex_constants::syntax_char, /**/
179 |  |  | regex_constants::syntax_char, /**/
180 |  |  | regex_constants::syntax_char, /**/
181 |  |  | regex_constants::syntax_char, /**/
182 |  |  | regex_constants::syntax_char, /**/
183 |  |  | regex_constants::syntax_char, /**/
184 |  |  | regex_constants::syntax_char, /**/
185 |  |  | regex_constants::syntax_char, /**/
186 |  |  | regex_constants::syntax_char, /**/
187 |  |  | regex_constants::syntax_char, /**/
188 |  |  | regex_constants::syntax_char, /**/
189 |  |  | regex_constants::syntax_char, /**/
190 |  |  | regex_constants::syntax_char, /**/
191 |  |  | regex_constants::syntax_char, /**/
192 |  |  | regex_constants::syntax_char, /**/
193 |  |  | regex_constants::syntax_char, /* */ // 32
194 |  |  | regex_constants::syntax_not, /*!*/
195 |  |  | regex_constants::syntax_char, /*"*/
196 |  |  | regex_constants::syntax_hash, /*#*/
197 |  |  | regex_constants::syntax_dollar, /*$*/
198 |  |  | regex_constants::syntax_char, /*%*/
199 |  |  | regex_constants::syntax_char, /*&*/
200 |  |  | regex_constants::escape_type_end_buffer, /*'*/
201 |  |  | regex_constants::syntax_open_mark, /*(*/
202 |  |  | regex_constants::syntax_close_mark, /*)*/
203 |  |  | regex_constants::syntax_star, /***/
204 |  |  | regex_constants::syntax_plus, /*+*/
205 |  |  | regex_constants::syntax_comma, /*,*/
206 |  |  | regex_constants::syntax_dash, /*-*/
207 |  |  | regex_constants::syntax_dot, /*.*/
208 |  |  | regex_constants::syntax_char, /*/*/
209 |  |  | regex_constants::syntax_digit, /*0*/
210 |  |  | regex_constants::syntax_digit, /*1*/
211 |  |  | regex_constants::syntax_digit, /*2*/
212 |  |  | regex_constants::syntax_digit, /*3*/
213 |  |  | regex_constants::syntax_digit, /*4*/
214 |  |  | regex_constants::syntax_digit, /*5*/
215 |  |  | regex_constants::syntax_digit, /*6*/
216 |  |  | regex_constants::syntax_digit, /*7*/
217 |  |  | regex_constants::syntax_digit, /*8*/
218 |  |  | regex_constants::syntax_digit, /*9*/
219 |  |  | regex_constants::syntax_colon, /*:*/
220 |  |  | regex_constants::syntax_char, /*;*/
221 |  |  | regex_constants::escape_type_left_word, /*<*/
222 |  |  | regex_constants::syntax_equal, /*=*/
223 |  |  | regex_constants::escape_type_right_word, /*>*/
224 |  |  | regex_constants::syntax_question, /*?*/
225 |  |  | regex_constants::syntax_char, /*@*/
226 |  |  | regex_constants::syntax_char, /*A*/
227 |  |  | regex_constants::syntax_char, /*B*/
228 |  |  | regex_constants::syntax_char, /*C*/
229 |  |  | regex_constants::syntax_char, /*D*/
230 |  |  | regex_constants::syntax_char, /*E*/
231 |  |  | regex_constants::syntax_char, /*F*/
232 |  |  | regex_constants::syntax_char, /*G*/
233 |  |  | regex_constants::syntax_char, /*H*/
234 |  |  | regex_constants::syntax_char, /*I*/
235 |  |  | regex_constants::syntax_char, /*J*/
236 |  |  | regex_constants::syntax_char, /*K*/
237 |  |  | regex_constants::syntax_char, /*L*/
238 |  |  | regex_constants::syntax_char, /*M*/
239 |  |  | regex_constants::syntax_char, /*N*/
240 |  |  | regex_constants::syntax_char, /*O*/
241 |  |  | regex_constants::syntax_char, /*P*/
242 |  |  | regex_constants::syntax_char, /*Q*/
243 |  |  | regex_constants::syntax_char, /*R*/
244 |  |  | regex_constants::syntax_char, /*S*/
245 |  |  | regex_constants::syntax_char, /*T*/
246 |  |  | regex_constants::syntax_char, /*U*/
247 |  |  | regex_constants::syntax_char, /*V*/
248 |  |  | regex_constants::syntax_char, /*W*/
249 |  |  | regex_constants::syntax_char, /*X*/
250 |  |  | regex_constants::syntax_char, /*Y*/
251 |  |  | regex_constants::syntax_char, /*Z*/
252 |  |  | regex_constants::syntax_open_set, /*[*/
253 |  |  | regex_constants::syntax_escape, /*\*/
254 |  |  | regex_constants::syntax_close_set, /*]*/
255 |  |  | regex_constants::syntax_caret, /*^*/
256 |  |  | regex_constants::syntax_char, /*_*/
257 |  |  | regex_constants::syntax_char, /*`*/
258 |  |  | regex_constants::syntax_char, /*a*/
259 |  |  | regex_constants::syntax_char, /*b*/
260 |  |  | regex_constants::syntax_char, /*c*/
261 |  |  | regex_constants::syntax_char, /*d*/
262 |  |  | regex_constants::syntax_char, /*e*/
263 |  |  | regex_constants::syntax_char, /*f*/
264 |  |  | regex_constants::syntax_char, /*g*/
265 |  |  | regex_constants::syntax_char, /*h*/
266 |  |  | regex_constants::syntax_char, /*i*/
267 |  |  | regex_constants::syntax_char, /*j*/
268 |  |  | regex_constants::syntax_char, /*k*/
269 |  |  | regex_constants::syntax_char, /*l*/
270 |  |  | regex_constants::syntax_char, /*m*/
271 |  |  | regex_constants::syntax_char, /*n*/
272 |  |  | regex_constants::syntax_char, /*o*/
273 |  |  | regex_constants::syntax_char, /*p*/
274 |  |  | regex_constants::syntax_char, /*q*/
275 |  |  | regex_constants::syntax_char, /*r*/
276 |  |  | regex_constants::syntax_char, /*s*/
277 |  |  | regex_constants::syntax_char, /*t*/
278 |  |  | regex_constants::syntax_char, /*u*/
279 |  |  | regex_constants::syntax_char, /*v*/
280 |  |  | regex_constants::syntax_char, /*w*/
281 |  |  | regex_constants::syntax_char, /*x*/
282 |  |  | regex_constants::syntax_char, /*y*/
283 |  |  | regex_constants::syntax_char, /*z*/
284 |  |  | regex_constants::syntax_open_brace, /*{*/
285 |  |  | regex_constants::syntax_or, /*|*/
286 |  |  | regex_constants::syntax_close_brace, /*}*/
287 |  |  | regex_constants::syntax_char, /*~*/
288 |  |  | regex_constants::syntax_char, /**/
289 |  |  | regex_constants::syntax_char, /**/
290 |  |  | regex_constants::syntax_char, /**/
291 |  |  | regex_constants::syntax_char, /**/
292 |  |  | regex_constants::syntax_char, /**/
293 |  |  | regex_constants::syntax_char, /**/
294 |  |  | regex_constants::syntax_char, /**/
295 |  |  | regex_constants::syntax_char, /**/
296 |  |  | regex_constants::syntax_char, /**/
297 |  |  | regex_constants::syntax_char, /**/
298 |  |  | regex_constants::syntax_char, /**/
299 |  |  | regex_constants::syntax_char, /**/
300 |  |  | regex_constants::syntax_char, /**/
301 |  |  | regex_constants::syntax_char, /**/
302 |  |  | regex_constants::syntax_char, /**/
303 |  |  | regex_constants::syntax_char, /**/
304 |  |  | regex_constants::syntax_char, /**/
305 |  |  | regex_constants::syntax_char, /**/
306 |  |  | regex_constants::syntax_char, /**/
307 |  |  | regex_constants::syntax_char, /**/
308 |  |  | regex_constants::syntax_char, /**/
309 |  |  | regex_constants::syntax_char, /**/
310 |  |  | regex_constants::syntax_char, /**/
311 |  |  | regex_constants::syntax_char, /**/
312 |  |  | regex_constants::syntax_char, /**/
313 |  |  | regex_constants::syntax_char, /**/
314 |  |  | regex_constants::syntax_char, /**/
315 |  |  | regex_constants::syntax_char, /**/
316 |  |  | regex_constants::syntax_char, /**/
317 |  |  | regex_constants::syntax_char, /**/
318 |  |  | regex_constants::syntax_char, /**/
319 |  |  | regex_constants::syntax_char, /**/
320 |  |  | regex_constants::syntax_char, /**/
321 |  |  | regex_constants::syntax_char, /**/
322 |  |  | regex_constants::syntax_char, /**/
323 |  |  | regex_constants::syntax_char, /**/
324 |  |  | regex_constants::syntax_char, /**/
325 |  |  | regex_constants::syntax_char, /**/
326 |  |  | regex_constants::syntax_char, /**/
327 |  |  | regex_constants::syntax_char, /**/
328 |  |  | regex_constants::syntax_char, /**/
329 |  |  | regex_constants::syntax_char, /**/
330 |  |  | regex_constants::syntax_char, /**/
331 |  |  | regex_constants::syntax_char, /**/
332 |  |  | regex_constants::syntax_char, /**/
333 |  |  | regex_constants::syntax_char, /**/
334 |  |  | regex_constants::syntax_char, /**/
335 |  |  | regex_constants::syntax_char, /**/
336 |  |  | regex_constants::syntax_char, /**/
337 |  |  | regex_constants::syntax_char, /**/
338 |  |  | regex_constants::syntax_char, /**/
339 |  |  | regex_constants::syntax_char, /**/
340 |  |  | regex_constants::syntax_char, /**/
341 |  |  | regex_constants::syntax_char, /**/
342 |  |  | regex_constants::syntax_char, /**/
343 |  |  | regex_constants::syntax_char, /**/
344 |  |  | };
345 |  |  |
346 |  | 7574840x | return char_syntax[(unsigned char)c];
347 |  |  | }
348 |  |  |
349 |  | 887628x | inline regex_constants::escape_syntax_type get_default_escape_syntax_type(char c)
350 |  |  | {
351 |  |  | //
352 |  |  | // char_syntax determines how the compiler treats a given character
353 |  |  | // in a regular expression.
354 |  |  | //
355 |  |  | static regex_constants::escape_syntax_type char_syntax[] = {
356 |  |  | regex_constants::escape_type_identity, /**/
357 |  |  | regex_constants::escape_type_identity, /**/
358 |  |  | regex_constants::escape_type_identity, /**/
359 |  |  | regex_constants::escape_type_identity, /**/
360 |  |  | regex_constants::escape_type_identity, /**/
361 |  |  | regex_constants::escape_type_identity, /**/
362 |  |  | regex_constants::escape_type_identity, /**/
363 |  |  | regex_constants::escape_type_identity, /**/
364 |  |  | regex_constants::escape_type_identity, /**/
365 |  |  | regex_constants::escape_type_identity, /**/
366 |  |  | regex_constants::escape_type_identity, /**/
367 |  |  | regex_constants::escape_type_identity, /**/
368 |  |  | regex_constants::escape_type_identity, /**/
369 |  |  | regex_constants::escape_type_identity, /**/
370 |  |  | regex_constants::escape_type_identity, /**/
371 |  |  | regex_constants::escape_type_identity, /**/
372 |  |  | regex_constants::escape_type_identity, /**/
373 |  |  | regex_constants::escape_type_identity, /**/
374 |  |  | regex_constants::escape_type_identity, /**/
375 |  |  | regex_constants::escape_type_identity, /**/
376 |  |  | regex_constants::escape_type_identity, /**/
377 |  |  | regex_constants::escape_type_identity, /**/
378 |  |  | regex_constants::escape_type_identity, /**/
379 |  |  | regex_constants::escape_type_identity, /**/
380 |  |  | regex_constants::escape_type_identity, /**/
381 |  |  | regex_constants::escape_type_identity, /**/
382 |  |  | regex_constants::escape_type_identity, /**/
383 |  |  | regex_constants::escape_type_identity, /**/
384 |  |  | regex_constants::escape_type_identity, /**/
385 |  |  | regex_constants::escape_type_identity, /**/
386 |  |  | regex_constants::escape_type_identity, /**/
387 |  |  | regex_constants::escape_type_identity, /**/
388 |  |  | regex_constants::escape_type_identity, /* */ // 32
389 |  |  | regex_constants::escape_type_identity, /*!*/
390 |  |  | regex_constants::escape_type_identity, /*"*/
391 |  |  | regex_constants::escape_type_identity, /*#*/
392 |  |  | regex_constants::escape_type_identity, /*$*/
393 |  |  | regex_constants::escape_type_identity, /*%*/
394 |  |  | regex_constants::escape_type_identity, /*&*/
395 |  |  | regex_constants::escape_type_end_buffer, /*'*/
396 |  |  | regex_constants::syntax_open_mark, /*(*/
397 |  |  | regex_constants::syntax_close_mark, /*)*/
398 |  |  | regex_constants::escape_type_identity, /***/
399 |  |  | regex_constants::syntax_plus, /*+*/
400 |  |  | regex_constants::escape_type_identity, /*,*/
401 |  |  | regex_constants::escape_type_identity, /*-*/
402 |  |  | regex_constants::escape_type_identity, /*.*/
403 |  |  | regex_constants::escape_type_identity, /*/*/
404 |  |  | regex_constants::escape_type_decimal, /*0*/
405 |  |  | regex_constants::escape_type_backref, /*1*/
406 |  |  | regex_constants::escape_type_backref, /*2*/
407 |  |  | regex_constants::escape_type_backref, /*3*/
408 |  |  | regex_constants::escape_type_backref, /*4*/
409 |  |  | regex_constants::escape_type_backref, /*5*/
410 |  |  | regex_constants::escape_type_backref, /*6*/
411 |  |  | regex_constants::escape_type_backref, /*7*/
412 |  |  | regex_constants::escape_type_backref, /*8*/
413 |  |  | regex_constants::escape_type_backref, /*9*/
414 |  |  | regex_constants::escape_type_identity, /*:*/
415 |  |  | regex_constants::escape_type_identity, /*;*/
416 |  |  | regex_constants::escape_type_left_word, /*<*/
417 |  |  | regex_constants::escape_type_identity, /*=*/
418 |  |  | regex_constants::escape_type_right_word, /*>*/
419 |  |  | regex_constants::syntax_question, /*?*/
420 |  |  | regex_constants::escape_type_identity, /*@*/
421 |  |  | regex_constants::escape_type_start_buffer, /*A*/
422 |  |  | regex_constants::escape_type_not_word_assert, /*B*/
423 |  |  | regex_constants::escape_type_C, /*C*/
424 |  |  | regex_constants::escape_type_not_class, /*D*/
425 |  |  | regex_constants::escape_type_E, /*E*/
426 |  |  | regex_constants::escape_type_not_class, /*F*/
427 |  |  | regex_constants::escape_type_G, /*G*/
428 |  |  | regex_constants::escape_type_not_class, /*H*/
429 |  |  | regex_constants::escape_type_not_class, /*I*/
430 |  |  | regex_constants::escape_type_not_class, /*J*/
431 |  |  | regex_constants::escape_type_reset_start_mark, /*K*/
432 |  |  | regex_constants::escape_type_not_class, /*L*/
433 |  |  | regex_constants::escape_type_not_class, /*M*/
434 |  |  | regex_constants::escape_type_named_char, /*N*/
435 |  |  | regex_constants::escape_type_not_class, /*O*/
436 |  |  | regex_constants::escape_type_not_property, /*P*/
437 |  |  | regex_constants::escape_type_Q, /*Q*/
438 |  |  | regex_constants::escape_type_line_ending, /*R*/
439 |  |  | regex_constants::escape_type_not_class, /*S*/
440 |  |  | regex_constants::escape_type_not_class, /*T*/
441 |  |  | regex_constants::escape_type_not_class, /*U*/
442 |  |  | regex_constants::escape_type_not_class, /*V*/
443 |  |  | regex_constants::escape_type_not_class, /*W*/
444 |  |  | regex_constants::escape_type_X, /*X*/
445 |  |  | regex_constants::escape_type_not_class, /*Y*/
446 |  |  | regex_constants::escape_type_Z, /*Z*/
447 |  |  | regex_constants::escape_type_identity, /*[*/
448 |  |  | regex_constants::escape_type_identity, /*\*/
449 |  |  | regex_constants::escape_type_identity, /*]*/
450 |  |  | regex_constants::escape_type_identity, /*^*/
451 |  |  | regex_constants::escape_type_identity, /*_*/
452 |  |  | regex_constants::escape_type_start_buffer, /*`*/
453 |  |  | regex_constants::escape_type_control_a, /*a*/
454 |  |  | regex_constants::escape_type_word_assert, /*b*/
455 |  |  | regex_constants::escape_type_ascii_control, /*c*/
456 |  |  | regex_constants::escape_type_class, /*d*/
457 |  |  | regex_constants::escape_type_e, /*e*/
458 |  |  | regex_constants::escape_type_control_f, /*f*/
459 |  |  | regex_constants::escape_type_extended_backref, /*g*/
460 |  |  | regex_constants::escape_type_class, /*h*/
461 |  |  | regex_constants::escape_type_class, /*i*/
462 |  |  | regex_constants::escape_type_class, /*j*/
463 |  |  | regex_constants::escape_type_extended_backref, /*k*/
464 |  |  | regex_constants::escape_type_class, /*l*/
465 |  |  | regex_constants::escape_type_class, /*m*/
466 |  |  | regex_constants::escape_type_control_n, /*n*/
467 |  |  | regex_constants::escape_type_class, /*o*/
468 |  |  | regex_constants::escape_type_property, /*p*/
469 |  |  | regex_constants::escape_type_class, /*q*/
470 |  |  | regex_constants::escape_type_control_r, /*r*/
471 |  |  | regex_constants::escape_type_class, /*s*/
472 |  |  | regex_constants::escape_type_control_t, /*t*/
473 |  |  | regex_constants::escape_type_class, /*u*/
474 |  |  | regex_constants::escape_type_control_v, /*v*/
475 |  |  | regex_constants::escape_type_class, /*w*/
476 |  |  | regex_constants::escape_type_hex, /*x*/
477 |  |  | regex_constants::escape_type_class, /*y*/
478 |  |  | regex_constants::escape_type_end_buffer, /*z*/
479 |  |  | regex_constants::syntax_open_brace, /*{*/
480 |  |  | regex_constants::syntax_or, /*|*/
481 |  |  | regex_constants::syntax_close_brace, /*}*/
482 |  |  | regex_constants::escape_type_identity, /*~*/
483 |  |  | regex_constants::escape_type_identity, /**/
484 |  |  | regex_constants::escape_type_identity, /**/
485 |  |  | regex_constants::escape_type_identity, /**/
486 |  |  | regex_constants::escape_type_identity, /**/
487 |  |  | regex_constants::escape_type_identity, /**/
488 |  |  | regex_constants::escape_type_identity, /**/
489 |  |  | regex_constants::escape_type_identity, /**/
490 |  |  | regex_constants::escape_type_identity, /**/
491 |  |  | regex_constants::escape_type_identity, /**/
492 |  |  | regex_constants::escape_type_identity, /**/
493 |  |  | regex_constants::escape_type_identity, /**/
494 |  |  | regex_constants::escape_type_identity, /**/
495 |  |  | regex_constants::escape_type_identity, /**/
496 |  |  | regex_constants::escape_type_identity, /**/
497 |  |  | regex_constants::escape_type_identity, /**/
498 |  |  | regex_constants::escape_type_identity, /**/
499 |  |  | regex_constants::escape_type_identity, /**/
500 |  |  | regex_constants::escape_type_identity, /**/
501 |  |  | regex_constants::escape_type_identity, /**/
502 |  |  | regex_constants::escape_type_identity, /**/
503 |  |  | regex_constants::escape_type_identity, /**/
504 |  |  | regex_constants::escape_type_identity, /**/
505 |  |  | regex_constants::escape_type_identity, /**/
506 |  |  | regex_constants::escape_type_identity, /**/
507 |  |  | regex_constants::escape_type_identity, /**/
508 |  |  | regex_constants::escape_type_identity, /**/
509 |  |  | regex_constants::escape_type_identity, /**/
510 |  |  | regex_constants::escape_type_identity, /**/
511 |  |  | regex_constants::escape_type_identity, /**/
512 |  |  | regex_constants::escape_type_identity, /**/
513 |  |  | regex_constants::escape_type_identity, /**/
514 |  |  | regex_constants::escape_type_identity, /**/
515 |  |  | regex_constants::escape_type_identity, /**/
516 |  |  | regex_constants::escape_type_identity, /**/
517 |  |  | regex_constants::escape_type_identity, /**/
518 |  |  | regex_constants::escape_type_identity, /**/
519 |  |  | regex_constants::escape_type_identity, /**/
520 |  |  | regex_constants::escape_type_identity, /**/
521 |  |  | regex_constants::escape_type_identity, /**/
522 |  |  | regex_constants::escape_type_identity, /**/
523 |  |  | regex_constants::escape_type_identity, /**/
524 |  |  | regex_constants::escape_type_identity, /**/
525 |  |  | regex_constants::escape_type_identity, /**/
526 |  |  | regex_constants::escape_type_identity, /**/
527 |  |  | regex_constants::escape_type_identity, /**/
528 |  |  | regex_constants::escape_type_identity, /**/
529 |  |  | regex_constants::escape_type_identity, /**/
530 |  |  | regex_constants::escape_type_identity, /**/
531 |  |  | regex_constants::escape_type_identity, /**/
532 |  |  | regex_constants::escape_type_identity, /**/
533 |  |  | regex_constants::escape_type_identity, /**/
534 |  |  | regex_constants::escape_type_identity, /**/
535 |  |  | regex_constants::escape_type_identity, /**/
536 |  |  | regex_constants::escape_type_identity, /**/
537 |  |  | regex_constants::escape_type_identity, /**/
538 |  |  | regex_constants::escape_type_identity, /**/
539 |  |  | };
540 |  |  |
541 |  | 887628x | return char_syntax[(unsigned char)c];
542 |  |  | }
543 |  |  |
544 |  |  | // is charT c a combining character?
545 |  | 3144x | inline bool is_combining_implementation(std::uint_least16_t c)
546 |  |  | {
547 |  | 3144x | const std::uint_least16_t combining_ranges[] = { 0x0300, 0x0361,
548 |  |  | 0x0483, 0x0486,
549 |  |  | 0x0903, 0x0903,
550 |  |  | 0x093E, 0x0940,
551 |  |  | 0x0949, 0x094C,
552 |  |  | 0x0982, 0x0983,
553 |  |  | 0x09BE, 0x09C0,
554 |  |  | 0x09C7, 0x09CC,
555 |  |  | 0x09D7, 0x09D7,
556 |  |  | 0x0A3E, 0x0A40,
557 |  |  | 0x0A83, 0x0A83,
558 |  |  | 0x0ABE, 0x0AC0,
559 |  |  | 0x0AC9, 0x0ACC,
560 |  |  | 0x0B02, 0x0B03,
561 |  |  | 0x0B3E, 0x0B3E,
562 |  |  | 0x0B40, 0x0B40,
563 |  |  | 0x0B47, 0x0B4C,
564 |  |  | 0x0B57, 0x0B57,
565 |  |  | 0x0B83, 0x0B83,
566 |  |  | 0x0BBE, 0x0BBF,
567 |  |  | 0x0BC1, 0x0BCC,
568 |  |  | 0x0BD7, 0x0BD7,
569 |  |  | 0x0C01, 0x0C03,
570 |  |  | 0x0C41, 0x0C44,
571 |  |  | 0x0C82, 0x0C83,
572 |  |  | 0x0CBE, 0x0CBE,
573 |  |  | 0x0CC0, 0x0CC4,
574 |  |  | 0x0CC7, 0x0CCB,
575 |  |  | 0x0CD5, 0x0CD6,
576 |  |  | 0x0D02, 0x0D03,
577 |  |  | 0x0D3E, 0x0D40,
578 |  |  | 0x0D46, 0x0D4C,
579 |  |  | 0x0D57, 0x0D57,
580 |  |  | 0x0F7F, 0x0F7F,
581 |  |  | 0x20D0, 0x20E1,
582 |  |  | 0x3099, 0x309A,
583 |  |  | 0xFE20, 0xFE23,
584 |  |  | 0xffff, 0xffff, };
585 |  |  |
586 |  | 3144x | const std::uint_least16_t* p = combining_ranges + 1;
587 |  | 3144x | while (*p < c) p += 2;
588 |  | 3144x | --p;
589 |  | 3144x | if ((c >= *p) && (c <= *(p + 1)))
590 |  | 552x | return true;
591 |  | 2592x | return false;
592 |  |  | }
593 |  |  |
594 |  |  | template <class charT>
595 |  | 3144x | inline bool is_combining(charT c)
596 |  |  | {
597 |  | 3144x | return (c <= static_cast<charT>(0)) ? false : ((c >= static_cast<charT>((std::numeric_limits<uint_least16_t>::max)())) ? false : is_combining_implementation(static_cast<unsigned short>(c)));
598 |  |  | }
599 |  |  | template <>
600 |  | 1668x | inline bool is_combining<char>(char)
601 |  |  | {
602 |  | 1668x | return false;
603 |  |  | }
604 |  |  | template <>
605 |  |  | inline bool is_combining<signed char>(signed char)
606 |  |  | {
607 |  |  | return false;
608 |  |  | }
609 |  |  | template <>
610 |  |  | inline bool is_combining<unsigned char>(unsigned char)
611 |  |  | {
612 |  |  | return false;
613 |  |  | }
614 |  |  | #ifdef _MSC_VER
615 |  |  | template<>
616 |  |  | inline bool is_combining<wchar_t>(wchar_t c)
617 |  |  | {
618 |  |  | return is_combining_implementation(static_cast<unsigned short>(c));
619 |  |  | }
620 |  |  | #elif !defined(__DECCXX) && !defined(__osf__) && !defined(__OSF__) && defined(WCHAR_MIN) && (WCHAR_MIN == 0) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
621 |  |  | #if defined(WCHAR_MAX) && (WCHAR_MAX <= USHRT_MAX)
622 |  |  | template<>
623 |  |  | inline bool is_combining<wchar_t>(wchar_t c)
624 |  |  | {
625 |  |  | return is_combining_implementation(static_cast<unsigned short>(c));
626 |  |  | }
627 |  |  | #else
628 |  |  | template<>
629 |  |  | inline bool is_combining<wchar_t>(wchar_t c)
630 |  |  | {
631 |  |  | return (c >= (std::numeric_limits<uint_least16_t>::max)()) ? false : is_combining_implementation(static_cast<unsigned short>(c));
632 |  |  | }
633 |  |  | #endif
634 |  |  | #endif
635 |  |  |
636 |  |  | //
637 |  |  | // is a charT c a line separator?
638 |  |  | //
639 |  |  | template <class charT>
640 |  | 675928x | inline bool is_separator(charT c)
641 |  |  | {
642 |  | 675928x | return BOOST_REGEX_MAKE_BOOL(
643 |  |  | (c == static_cast<charT>('\n'))
644 |  |  | || (c == static_cast<charT>('\r'))
645 |  |  | || (c == static_cast<charT>('\f'))
646 |  |  | || (static_cast<std::uint16_t>(c) == 0x2028u)
647 |  |  | || (static_cast<std::uint16_t>(c) == 0x2029u)
648 |  |  | || (static_cast<std::uint16_t>(c) == 0x85u));
649 |  |  | }
650 |  |  | template <>
651 |  | 184105598x | inline bool is_separator<char>(char c)
652 |  |  | {
653 |  | 184105598x | return BOOST_REGEX_MAKE_BOOL((c == '\n') || (c == '\r') || (c == '\f'));
654 |  |  | }
655 |  |  |
656 |  |  | //
657 |  |  | // get a default collating element:
658 |  |  | //
659 |  | 22420x | inline std::string lookup_default_collate_name(const std::string& name)
660 |  |  | {
661 |  |  | //
662 |  |  | // these are the POSIX collating names:
663 |  |  | //
664 |  |  | static const char* def_coll_names[] = {
665 |  |  | "NUL", "SOH", "STX", "ETX", "EOT", "ENQ", "ACK", "alert", "backspace", "tab", "newline",
666 |  |  | "vertical-tab", "form-feed", "carriage-return", "SO", "SI", "DLE", "DC1", "DC2", "DC3", "DC4", "NAK",
667 |  |  | "SYN", "ETB", "CAN", "EM", "SUB", "ESC", "IS4", "IS3", "IS2", "IS1", "space", "exclamation-mark",
668 |  |  | "quotation-mark", "number-sign", "dollar-sign", "percent-sign", "ampersand", "apostrophe",
669 |  |  | "left-parenthesis", "right-parenthesis", "asterisk", "plus-sign", "comma", "hyphen",
670 |  |  | "period", "slash", "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine",
671 |  |  | "colon", "semicolon", "less-than-sign", "equals-sign", "greater-than-sign",
672 |  |  | "question-mark", "commercial-at", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P",
673 |  |  | "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "left-square-bracket", "backslash",
674 |  |  | "right-square-bracket", "circumflex", "underscore", "grave-accent", "a", "b", "c", "d", "e", "f",
675 |  |  | "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "left-curly-bracket",
676 |  |  | "vertical-line", "right-curly-bracket", "tilde", "DEL", "",
677 |  |  | };
678 |  |  |
679 |  |  | // these multi-character collating elements
680 |  |  | // should keep most Western-European locales
681 |  |  | // happy - we should really localise these a
682 |  |  | // little more - but this will have to do for
683 |  |  | // now:
684 |  |  |
685 |  |  | static const char* def_multi_coll[] = {
686 |  |  | "ae",
687 |  |  | "Ae",
688 |  |  | "AE",
689 |  |  | "ch",
690 |  |  | "Ch",
691 |  |  | "CH",
692 |  |  | "ll",
693 |  |  | "Ll",
694 |  |  | "LL",
695 |  |  | "ss",
696 |  |  | "Ss",
697 |  |  | "SS",
698 |  |  | "nj",
699 |  |  | "Nj",
700 |  |  | "NJ",
701 |  |  | "dz",
702 |  |  | "Dz",
703 |  |  | "DZ",
704 |  |  | "lj",
705 |  |  | "Lj",
706 |  |  | "LJ",
707 |  |  | "",
708 |  |  | };
709 |  |  |
710 |  | 22420x | unsigned int i = 0;
711 |  | 2298212x | while (*def_coll_names[i])
712 |  |  | {
713 |  | 2283596x | if (def_coll_names[i] == name)
714 |  |  | {
715 |  | 15608x | return std::string(1, char(i));
716 |  |  | }
717 |  | 2275792x | ++i;
718 |  |  | }
719 |  | 14616x | i = 0;
720 |  | 44184x | while (*def_multi_coll[i])
721 |  |  | {
722 |  | 42936x | if (def_multi_coll[i] == name)
723 |  |  | {
724 |  | 26736x | return def_multi_coll[i];
725 |  |  | }
726 |  | 29568x | ++i;
727 |  |  | }
728 |  | 1248x | return std::string();
729 |  |  | }
730 |  |  |
731 |  |  | //
732 |  |  | // get the state_id of a character classification, the individual
733 |  |  | // traits classes then transform that state_id into a bitmask:
734 |  |  | //
735 |  |  | template <class charT>
736 |  |  | struct character_pointer_range
737 |  |  | {
738 |  |  | const charT* p1;
739 |  |  | const charT* p2;
740 |  |  |
741 |  | 10041433x | bool operator < (const character_pointer_range& r)const
742 |  |  | {
743 |  | 10041433x | return std::lexicographical_compare(p1, p2, r.p1, r.p2);
744 |  |  | }
745 |  | 2170801x | bool operator == (const character_pointer_range& r)const
746 |  |  | {
747 |  |  | // Not only do we check that the ranges are of equal size before
748 |  |  | // calling std::equal, but there is no other algorithm available:
749 |  |  | // not even a non-standard MS one. So forward to unchecked_equal
750 |  |  | // in the MS case.
751 |  |  | #ifdef __cpp_lib_robust_nonmodifying_seq_ops
752 |  | 2170801x | return std::equal(p1, p2, r.p1, r.p2);
753 |  |  | #elif defined(BOOST_REGEX_MSVC)
754 |  |  | if (((p2 - p1) != (r.p2 - r.p1)))
755 |  |  | return false;
756 |  |  | const charT* with = r.p1;
757 |  |  | const charT* pos = p1;
758 |  |  | while (pos != p2)
759 |  |  | if (*pos++ != *with++) return false;
760 |  |  | return true;
761 |  |  |
762 |  |  | #else
763 |  |  | return ((p2 - p1) == (r.p2 - r.p1)) && std::equal(p1, p2, r.p1);
764 |  |  | #endif
765 |  |  | }
766 |  |  | };
767 |  |  | template <class charT>
768 |  | 2156376x | int get_default_class_id(const charT* p1, const charT* p2)
769 |  |  | {
770 |  |  | static const charT data[73] = {
771 |  |  | 'a', 'l', 'n', 'u', 'm',
772 |  |  | 'a', 'l', 'p', 'h', 'a',
773 |  |  | 'b', 'l', 'a', 'n', 'k',
774 |  |  | 'c', 'n', 't', 'r', 'l',
775 |  |  | 'd', 'i', 'g', 'i', 't',
776 |  |  | 'g', 'r', 'a', 'p', 'h',
777 |  |  | 'l', 'o', 'w', 'e', 'r',
778 |  |  | 'p', 'r', 'i', 'n', 't',
779 |  |  | 'p', 'u', 'n', 'c', 't',
780 |  |  | 's', 'p', 'a', 'c', 'e',
781 |  |  | 'u', 'n', 'i', 'c', 'o', 'd', 'e',
782 |  |  | 'u', 'p', 'p', 'e', 'r',
783 |  |  | 'v',
784 |  |  | 'w', 'o', 'r', 'd',
785 |  |  | 'x', 'd', 'i', 'g', 'i', 't',
786 |  |  | };
787 |  |  |
788 |  |  | static const character_pointer_range<charT> ranges[21] =
789 |  |  | {
790 |  |  | {data+0, data+5,}, // alnum
791 |  |  | {data+5, data+10,}, // alpha
792 |  |  | {data+10, data+15,}, // blank
793 |  |  | {data+15, data+20,}, // cntrl
794 |  |  | {data+20, data+21,}, // d
795 |  |  | {data+20, data+25,}, // digit
796 |  |  | {data+25, data+30,}, // graph
797 |  |  | {data+29, data+30,}, // h
798 |  |  | {data+30, data+31,}, // l
799 |  |  | {data+30, data+35,}, // lower
800 |  |  | {data+35, data+40,}, // print
801 |  |  | {data+40, data+45,}, // punct
802 |  |  | {data+45, data+46,}, // s
803 |  |  | {data+45, data+50,}, // space
804 |  |  | {data+57, data+58,}, // u
805 |  |  | {data+50, data+57,}, // unicode
806 |  |  | {data+57, data+62,}, // upper
807 |  |  | {data+62, data+63,}, // v
808 |  |  | {data+63, data+64,}, // w
809 |  |  | {data+63, data+67,}, // word
810 |  |  | {data+67, data+73,}, // xdigit
811 |  |  | };
812 |  | 2156376x | const character_pointer_range<charT>* ranges_begin = ranges;
813 |  | 2156376x | const character_pointer_range<charT>* ranges_end = ranges + (sizeof(ranges)/sizeof(ranges[0]));
814 |  |  |
815 |  | 2156376x | character_pointer_range<charT> t = { p1, p2, };
816 |  | 2156376x | const character_pointer_range<charT>* p = std::lower_bound(ranges_begin, ranges_end, t);
817 |  | 2156376x | if((p != ranges_end) && (t == *p))
818 |  | 2131843x | return static_cast<int>(p - ranges);
819 |  | 24533x | return -1;
820 |  |  | }
821 |  |  |
822 |  |  | //
823 |  |  | // helper functions:
824 |  |  | //
825 |  |  | template <class charT>
826 |  |  | std::ptrdiff_t global_length(const charT* p)
827 |  |  | {
828 |  |  | std::ptrdiff_t n = 0;
829 |  |  | while(*p)
830 |  |  | {
831 |  |  | ++p;
832 |  |  | ++n;
833 |  |  | }
834 |  |  | return n;
835 |  |  | }
836 |  |  | template<>
837 |  |  | inline std::ptrdiff_t global_length<char>(const char* p)
838 |  |  | {
839 |  |  | return (std::strlen)(p);
840 |  |  | }
841 |  |  | #ifndef BOOST_NO_WREGEX
842 |  |  | template<>
843 |  |  | inline std::ptrdiff_t global_length<wchar_t>(const wchar_t* p)
844 |  |  | {
845 |  |  | return (std::ptrdiff_t)(std::wcslen)(p);
846 |  |  | }
847 |  |  | #endif
848 |  |  | template <class charT>
849 |  |  | inline charT global_lower(charT c)
850 |  |  | {
851 |  |  | return c;
852 |  |  | }
853 |  |  | template <class charT>
854 |  |  | inline charT global_upper(charT c)
855 |  |  | {
856 |  |  | return c;
857 |  |  | }
858 |  |  |
859 |  | 180x | inline char do_global_lower(char c)
860 |  |  | {
861 |  | 180x | return static_cast<char>((std::tolower)((unsigned char)c));
862 |  |  | }
863 |  |  |
864 |  | 132x | inline char do_global_upper(char c)
865 |  |  | {
866 |  | 132x | return static_cast<char>((std::toupper)((unsigned char)c));
867 |  |  | }
868 |  |  | #ifndef BOOST_NO_WREGEX
869 |  | 180x | inline wchar_t do_global_lower(wchar_t c)
870 |  |  | {
871 |  | 180x | return (std::towlower)(c);
872 |  |  | }
873 |  |  |
874 |  | 132x | inline wchar_t do_global_upper(wchar_t c)
875 |  |  | {
876 |  | 132x | return (std::towupper)(c);
877 |  |  | }
878 |  |  | #endif
879 |  |  | //
880 |  |  | // This sucks: declare template specialisations of global_lower/global_upper
881 |  |  | // that just forward to the non-template implementation functions. We do
882 |  |  | // this because there is one compiler (Compaq Tru64 C++) that doesn't seem
883 |  |  | // to differentiate between templates and non-template overloads....
884 |  |  | // what's more, the primary template, plus all overloads have to be
885 |  |  | // defined in the same translation unit (if one is inline they all must be)
886 |  |  | // otherwise the "local template instantiation" compiler option can pick
887 |  |  | // the wrong instantiation when linking:
888 |  |  | //
889 |  | 180x | template<> inline char global_lower<char>(char c) { return do_global_lower(c); }
890 |  | 132x | template<> inline char global_upper<char>(char c) { return do_global_upper(c); }
891 |  |  | #ifndef BOOST_NO_WREGEX
892 |  | 180x | template<> inline wchar_t global_lower<wchar_t>(wchar_t c) { return do_global_lower(c); }
893 |  | 132x | template<> inline wchar_t global_upper<wchar_t>(wchar_t c) { return do_global_upper(c); }
894 |  |  | #endif
895 |  |  |
896 |  |  | template <class charT>
897 |  |  | int global_value(charT c)
898 |  |  | {
899 |  |  | static const charT zero = '0';
900 |  |  | static const charT nine = '9';
901 |  |  | static const charT a = 'a';
902 |  |  | static const charT f = 'f';
903 |  |  | static const charT A = 'A';
904 |  |  | static const charT F = 'F';
905 |  |  |
906 |  |  | if(c > f) return -1;
907 |  |  | if(c >= a) return 10 + (c - a);
908 |  |  | if(c > F) return -1;
909 |  |  | if(c >= A) return 10 + (c - A);
910 |  |  | if(c > nine) return -1;
911 |  |  | if(c >= zero) return c - zero;
912 |  |  | return -1;
913 |  |  | }
914 |  |  | template <class charT, class traits>
915 |  | 345631x | std::intmax_t global_toi(const charT*& p1, const charT* p2, int radix, const traits& t)
916 |  |  | {
917 |  |  | (void)t; // warning suppression
918 |  | 345631x | std::intmax_t limit = (std::numeric_limits<std::intmax_t>::max)() / radix;
919 |  | 345631x | std::intmax_t next_value = t.value(*p1, radix);
920 |  | 345631x | if((p1 == p2) || (next_value < 0) || (next_value >= radix))
921 |  | 31826x | return -1;
922 |  | 313805x | std::intmax_t result = 0;
923 |  | 826090x | while(p1 != p2)
924 |  |  | {
925 |  | 671337x | next_value = t.value(*p1, radix);
926 |  | 671337x | if((next_value < 0) || (next_value >= radix))
927 |  |  | break;
928 |  | 512285x | result *= radix;
929 |  | 512285x | result += next_value;
930 |  | 512285x | ++p1;
931 |  | 512285x | if (result > limit)
932 |  | ✗ | return -1;
933 |  |  | }
934 |  | 313805x | return result;
935 |  |  | }
936 |  |  |
937 |  |  | template <class charT>
938 |  | 2736x | inline typename std::enable_if<(sizeof(charT) > 1), const charT*>::type get_escape_R_string()
939 |  |  | {
940 |  |  | #ifdef BOOST_REGEX_MSVC
941 |  |  | # pragma warning(push)
942 |  |  | # pragma warning(disable:4309 4245)
943 |  |  | #endif
944 |  |  | static const charT e1[] = { '(', '?', '-', 'x', ':', '(', '?', '>', '\x0D', '\x0A', '?',
945 |  |  | '|', '[', '\x0A', '\x0B', '\x0C', static_cast<charT>(0x85), static_cast<charT>(0x2028),
946 |  |  | static_cast<charT>(0x2029), ']', ')', ')', '\0' };
947 |  |  | static const charT e2[] = { '(', '?', '-', 'x', ':', '(', '?', '>', '\x0D', '\x0A', '?',
948 |  |  | '|', '[', '\x0A', '\x0B', '\x0C', static_cast<charT>(0x85), ']', ')', ')', '\0' };
949 |  |  |
950 |  | 2736x | charT c = static_cast<charT>(0x2029u);
951 |  | 2736x | bool b = (static_cast<unsigned>(c) == 0x2029u);
952 |  |  |
953 |  | 2736x | return (b ? e1 : e2);
954 |  |  | #ifdef BOOST_REGEX_MSVC
955 |  |  | # pragma warning(pop)
956 |  |  | #endif
957 |  |  | }
958 |  |  |
959 |  |  | template <class charT>
960 |  | 864x | inline typename std::enable_if<(sizeof(charT) == 1), const charT*>::type get_escape_R_string()
961 |  |  | {
962 |  |  | #ifdef BOOST_REGEX_MSVC
963 |  |  | # pragma warning(push)
964 |  |  | # pragma warning(disable:4309 4245)
965 |  |  | #endif
966 |  |  | static const charT e2[] = {
967 |  |  | static_cast<charT>('('),
968 |  |  | static_cast<charT>('?'),
969 |  |  | static_cast<charT>('-'),
970 |  |  | static_cast<charT>('x'),
971 |  |  | static_cast<charT>(':'),
972 |  |  | static_cast<charT>('('),
973 |  |  | static_cast<charT>('?'),
974 |  |  | static_cast<charT>('>'),
975 |  |  | static_cast<charT>('\x0D'),
976 |  |  | static_cast<charT>('\x0A'),
977 |  |  | static_cast<charT>('?'),
978 |  |  | static_cast<charT>('|'),
979 |  |  | static_cast<charT>('['),
980 |  |  | static_cast<charT>('\x0A'),
981 |  |  | static_cast<charT>('\x0B'),
982 |  |  | static_cast<charT>('\x0C'),
983 |  |  | static_cast<charT>('\x85'),
984 |  |  | static_cast<charT>(']'),
985 |  |  | static_cast<charT>(')'),
986 |  |  | static_cast<charT>(')'),
987 |  |  | static_cast<charT>('\0')
988 |  |  | };
989 |  | 864x | return e2;
990 |  |  | #ifdef BOOST_REGEX_MSVC
991 |  |  | # pragma warning(pop)
992 |  |  | #endif
993 |  |  | }
994 |  |  |
995 |  |  | } // BOOST_REGEX_DETAIL_NS
996 |  |  | } // boost
997 |  |  |
998 |  |  | #endif
999 |  |  |