1// -*- C++ -*-
2//===----------------------------------------------------------------------===//
3//
4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5// See https://llvm.org/LICENSE.txt for license information.
6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7//
8//===----------------------------------------------------------------------===//
9
10#ifndef _LIBCPP_REGEX
11#define _LIBCPP_REGEX
12
13/*
14 regex synopsis
15
16#include <compare>
17#include <initializer_list>
18
19namespace std
20{
21
22namespace regex_constants
23{
24
25enum syntax_option_type
26{
27 icase = unspecified,
28 nosubs = unspecified,
29 optimize = unspecified,
30 collate = unspecified,
31 ECMAScript = unspecified,
32 basic = unspecified,
33 extended = unspecified,
34 awk = unspecified,
35 grep = unspecified,
36 egrep = unspecified,
37 multiline = unspecified
38};
39
40constexpr syntax_option_type operator~(syntax_option_type f);
41constexpr syntax_option_type operator&(syntax_option_type lhs, syntax_option_type rhs);
42constexpr syntax_option_type operator|(syntax_option_type lhs, syntax_option_type rhs);
43
44enum match_flag_type
45{
46 match_default = 0,
47 match_not_bol = unspecified,
48 match_not_eol = unspecified,
49 match_not_bow = unspecified,
50 match_not_eow = unspecified,
51 match_any = unspecified,
52 match_not_null = unspecified,
53 match_continuous = unspecified,
54 match_prev_avail = unspecified,
55 format_default = 0,
56 format_sed = unspecified,
57 format_no_copy = unspecified,
58 format_first_only = unspecified
59};
60
61constexpr match_flag_type operator~(match_flag_type f);
62constexpr match_flag_type operator&(match_flag_type lhs, match_flag_type rhs);
63constexpr match_flag_type operator|(match_flag_type lhs, match_flag_type rhs);
64
65enum error_type
66{
67 error_collate = unspecified,
68 error_ctype = unspecified,
69 error_escape = unspecified,
70 error_backref = unspecified,
71 error_brack = unspecified,
72 error_paren = unspecified,
73 error_brace = unspecified,
74 error_badbrace = unspecified,
75 error_range = unspecified,
76 error_space = unspecified,
77 error_badrepeat = unspecified,
78 error_complexity = unspecified,
79 error_stack = unspecified
80};
81
82} // regex_constants
83
84class regex_error
85 : public runtime_error
86{
87public:
88 explicit regex_error(regex_constants::error_type ecode);
89 regex_constants::error_type code() const;
90};
91
92template <class charT>
93struct regex_traits
94{
95public:
96 typedef charT char_type;
97 typedef basic_string<char_type> string_type;
98 typedef locale locale_type;
99 typedef /bitmask_type/ char_class_type;
100
101 regex_traits();
102
103 static size_t length(const char_type* p);
104 charT translate(charT c) const;
105 charT translate_nocase(charT c) const;
106 template <class ForwardIterator>
107 string_type
108 transform(ForwardIterator first, ForwardIterator last) const;
109 template <class ForwardIterator>
110 string_type
111 transform_primary( ForwardIterator first, ForwardIterator last) const;
112 template <class ForwardIterator>
113 string_type
114 lookup_collatename(ForwardIterator first, ForwardIterator last) const;
115 template <class ForwardIterator>
116 char_class_type
117 lookup_classname(ForwardIterator first, ForwardIterator last,
118 bool icase = false) const;
119 bool isctype(charT c, char_class_type f) const;
120 int value(charT ch, int radix) const;
121 locale_type imbue(locale_type l);
122 locale_type getloc()const;
123};
124
125template <class charT, class traits = regex_traits<charT>>
126class basic_regex
127{
128public:
129 // types:
130 typedef charT value_type;
131 typedef traits traits_type;
132 typedef typename traits::string_type string_type;
133 typedef regex_constants::syntax_option_type flag_type;
134 typedef typename traits::locale_type locale_type;
135
136 // constants:
137 static constexpr regex_constants::syntax_option_type icase = regex_constants::icase;
138 static constexpr regex_constants::syntax_option_type nosubs = regex_constants::nosubs;
139 static constexpr regex_constants::syntax_option_type optimize = regex_constants::optimize;
140 static constexpr regex_constants::syntax_option_type collate = regex_constants::collate;
141 static constexpr regex_constants::syntax_option_type ECMAScript = regex_constants::ECMAScript;
142 static constexpr regex_constants::syntax_option_type basic = regex_constants::basic;
143 static constexpr regex_constants::syntax_option_type extended = regex_constants::extended;
144 static constexpr regex_constants::syntax_option_type awk = regex_constants::awk;
145 static constexpr regex_constants::syntax_option_type grep = regex_constants::grep;
146 static constexpr regex_constants::syntax_option_type egrep = regex_constants::egrep;
147 static constexpr regex_constants::syntax_option_type multiline = regex_constants::multiline;
148
149 // construct/copy/destroy:
150 basic_regex();
151 explicit basic_regex(const charT* p, flag_type f = regex_constants::ECMAScript);
152 basic_regex(const charT* p, size_t len, flag_type f = regex_constants::ECMAScript);
153 basic_regex(const basic_regex&);
154 basic_regex(basic_regex&&) noexcept;
155 template <class ST, class SA>
156 explicit basic_regex(const basic_string<charT, ST, SA>& p,
157 flag_type f = regex_constants::ECMAScript);
158 template <class ForwardIterator>
159 basic_regex(ForwardIterator first, ForwardIterator last,
160 flag_type f = regex_constants::ECMAScript);
161 basic_regex(initializer_list<charT>, flag_type = regex_constants::ECMAScript);
162
163 ~basic_regex();
164
165 basic_regex& operator=(const basic_regex&);
166 basic_regex& operator=(basic_regex&&) noexcept;
167 basic_regex& operator=(const charT* ptr);
168 basic_regex& operator=(initializer_list<charT> il);
169 template <class ST, class SA>
170 basic_regex& operator=(const basic_string<charT, ST, SA>& p);
171
172 // assign:
173 basic_regex& assign(const basic_regex& that);
174 basic_regex& assign(basic_regex&& that) noexcept;
175 basic_regex& assign(const charT* ptr, flag_type f = regex_constants::ECMAScript);
176 basic_regex& assign(const charT* p, size_t len, flag_type f = regex_constants::ECMAScript);
177 template <class string_traits, class A>
178 basic_regex& assign(const basic_string<charT, string_traits, A>& s,
179 flag_type f = regex_constants::ECMAScript);
180 template <class InputIterator>
181 basic_regex& assign(InputIterator first, InputIterator last,
182 flag_type f = regex_constants::ECMAScript);
183 basic_regex& assign(initializer_list<charT>, flag_type f = regex_constants::ECMAScript);
184
185 // const operations:
186 unsigned mark_count() const;
187 flag_type flags() const;
188
189 // locale:
190 locale_type imbue(locale_type loc);
191 locale_type getloc() const;
192
193 // swap:
194 void swap(basic_regex&);
195};
196
197template<class ForwardIterator>
198basic_regex(ForwardIterator, ForwardIterator,
199 regex_constants::syntax_option_type = regex_constants::ECMAScript)
200 -> basic_regex<typename iterator_traits<ForwardIterator>::value_type>; // C++17
201
202typedef basic_regex<char> regex;
203typedef basic_regex<wchar_t> wregex;
204
205template <class charT, class traits>
206 void swap(basic_regex<charT, traits>& e1, basic_regex<charT, traits>& e2);
207
208template <class BidirectionalIterator>
209class sub_match
210 : public pair<BidirectionalIterator, BidirectionalIterator>
211{
212public:
213 typedef typename iterator_traits<BidirectionalIterator>::value_type value_type;
214 typedef typename iterator_traits<BidirectionalIterator>::difference_type difference_type;
215 typedef BidirectionalIterator iterator;
216 typedef basic_string<value_type> string_type;
217
218 bool matched;
219
220 constexpr sub_match();
221
222 difference_type length() const;
223 operator string_type() const;
224 string_type str() const;
225
226 int compare(const sub_match& s) const;
227 int compare(const string_type& s) const;
228 int compare(const value_type* s) const;
229
230 void swap(sub_match& s) noexcept(see below);
231};
232
233typedef sub_match<const char*> csub_match;
234typedef sub_match<const wchar_t*> wcsub_match;
235typedef sub_match<string::const_iterator> ssub_match;
236typedef sub_match<wstring::const_iterator> wssub_match;
237
238template <class BiIter>
239 bool
240 operator==(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
241
242template <class BiIter>
243 auto
244 operator<=>(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs); // Since C++20
245
246 template <class BiIter> // Removed in C++20
247 bool
248 operator!=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
249
250template <class BiIter> // Removed in C++20
251 bool
252 operator<(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
253
254template <class BiIter> // Removed in C++20
255 bool
256 operator<=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
257
258template <class BiIter> // Removed in C++20
259 bool
260 operator>=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
261
262template <class BiIter> // Removed in C++20
263 bool
264 operator>(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
265
266template <class BiIter, class ST, class SA> // Removed in C++20
267 bool
268 operator==(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
269 const sub_match<BiIter>& rhs);
270
271template <class BiIter, class ST, class SA> // Removed in C++20
272 bool
273 operator!=(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
274 const sub_match<BiIter>& rhs);
275
276template <class BiIter, class ST, class SA> // Removed in C++20
277 bool
278 operator<(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
279 const sub_match<BiIter>& rhs);
280
281template <class BiIter, class ST, class SA> // Removed in C++20
282 bool
283 operator>(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
284 const sub_match<BiIter>& rhs);
285
286template <class BiIter, class ST, class SA> // Removed in C++20
287 bool operator>=(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
288 const sub_match<BiIter>& rhs);
289
290template <class BiIter, class ST, class SA> // Removed in C++20
291 bool
292 operator<=(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
293 const sub_match<BiIter>& rhs);
294
295template <class BiIter, class ST, class SA>
296 bool
297 operator==(const sub_match<BiIter>& lhs,
298 const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
299
300template <class BiIter, class ST, class SA> // Since C++20
301 auto
302 operator<=>(const sub_match<BiIter>& lhs,
303 const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
304
305template <class BiIter, class ST, class SA> // Removed in C++20
306 bool
307 operator!=(const sub_match<BiIter>& lhs,
308 const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
309
310template <class BiIter, class ST, class SA> // Removed in C++20
311 bool
312 operator<(const sub_match<BiIter>& lhs,
313 const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
314
315template <class BiIter, class ST, class SA> // Removed in C++20
316 bool
317 operator>(const sub_match<BiIter>& lhs,
318 const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
319
320template <class BiIter, class ST, class SA> // Removed in C++20
321 bool
322 operator>=(const sub_match<BiIter>& lhs,
323 const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
324
325template <class BiIter, class ST, class SA> // Removed in C++20
326 bool
327 operator<=(const sub_match<BiIter>& lhs,
328 const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
329
330template <class BiIter> // Removed in C++20
331 bool
332 operator==(typename iterator_traits<BiIter>::value_type const* lhs,
333 const sub_match<BiIter>& rhs);
334
335template <class BiIter> // Removed in C++20
336 bool
337 operator!=(typename iterator_traits<BiIter>::value_type const* lhs,
338 const sub_match<BiIter>& rhs);
339
340template <class BiIter> // Removed in C++20
341 bool
342 operator<(typename iterator_traits<BiIter>::value_type const* lhs,
343 const sub_match<BiIter>& rhs);
344
345template <class BiIter> // Removed in C++20
346 bool
347 operator>(typename iterator_traits<BiIter>::value_type const* lhs,
348 const sub_match<BiIter>& rhs);
349
350template <class BiIter> // Removed in C++20
351 bool
352 operator>=(typename iterator_traits<BiIter>::value_type const* lhs,
353 const sub_match<BiIter>& rhs);
354
355template <class BiIter> // Removed in C++20
356 bool
357 operator<=(typename iterator_traits<BiIter>::value_type const* lhs,
358 const sub_match<BiIter>& rhs);
359
360template <class BiIter>
361 bool
362 operator==(const sub_match<BiIter>& lhs,
363 typename iterator_traits<BiIter>::value_type const* rhs);
364
365template <class BiIter> // Since C++20
366 auto
367 operator<=>(const sub_match<BiIter>& lhs,
368 typename iterator_traits<BiIter>::value_type const* rhs);
369
370template <class BiIter, class ST, class SA> // Removed in C++20
371 bool
372 operator!=(const sub_match<BiIter>& lhs,
373 typename iterator_traits<BiIter>::value_type const* rhs);
374
375template <class BiIter> // Removed in C++20
376 bool
377 operator<(const sub_match<BiIter>& lhs,
378 typename iterator_traits<BiIter>::value_type const* rhs);
379
380template <class BiIter> // Removed in C++20
381 bool
382 operator>(const sub_match<BiIter>& lhs,
383 typename iterator_traits<BiIter>::value_type const* rhs);
384
385template <class BiIter> // Removed in C++20
386 bool
387 operator>=(const sub_match<BiIter>& lhs,
388 typename iterator_traits<BiIter>::value_type const* rhs);
389
390template <class BiIter> // Removed in C++20
391 bool
392 operator<=(const sub_match<BiIter>& lhs,
393 typename iterator_traits<BiIter>::value_type const* rhs);
394
395template <class BiIter> // Removed in C++20
396 bool
397 operator==(typename iterator_traits<BiIter>::value_type const& lhs,
398 const sub_match<BiIter>& rhs);
399
400template <class BiIter> // Removed in C++20
401 bool
402 operator!=(typename iterator_traits<BiIter>::value_type const& lhs,
403 const sub_match<BiIter>& rhs);
404
405template <class BiIter> // Removed in C++20
406 bool
407 operator<(typename iterator_traits<BiIter>::value_type const& lhs,
408 const sub_match<BiIter>& rhs);
409
410template <class BiIter> // Removed in C++20
411 bool
412 operator>(typename iterator_traits<BiIter>::value_type const& lhs,
413 const sub_match<BiIter>& rhs);
414
415template <class BiIter> // Removed in C++20
416 bool
417 operator>=(typename iterator_traits<BiIter>::value_type const& lhs,
418 const sub_match<BiIter>& rhs);
419
420template <class BiIter> // Removed in C++20
421 bool
422 operator<=(typename iterator_traits<BiIter>::value_type const& lhs,
423 const sub_match<BiIter>& rhs);
424
425template <class BiIter>
426 bool
427 operator==(const sub_match<BiIter>& lhs,
428 typename iterator_traits<BiIter>::value_type const& rhs);
429
430template <class BiIter> // Since C++20
431 auto
432 operator<=>(const sub_match<BiIter>& lhs,
433 typename iterator_traits<BiIter>::value_type const& rhs);
434
435template <class BiIter> // Removed in C++20
436 bool
437 operator!=(const sub_match<BiIter>& lhs,
438 typename iterator_traits<BiIter>::value_type const& rhs);
439
440template <class BiIter> // Removed in C++20
441 bool
442 operator<(const sub_match<BiIter>& lhs,
443 typename iterator_traits<BiIter>::value_type const& rhs);
444
445template <class BiIter> // Removed in C++20
446 bool
447 operator>(const sub_match<BiIter>& lhs,
448 typename iterator_traits<BiIter>::value_type const& rhs);
449
450template <class BiIter> // Removed in C++20
451 bool
452 operator>=(const sub_match<BiIter>& lhs,
453 typename iterator_traits<BiIter>::value_type const& rhs);
454
455template <class BiIter> // Removed in C++20
456 bool
457 operator<=(const sub_match<BiIter>& lhs,
458 typename iterator_traits<BiIter>::value_type const& rhs);
459
460template <class charT, class ST, class BiIter>
461 basic_ostream<charT, ST>&
462 operator<<(basic_ostream<charT, ST>& os, const sub_match<BiIter>& m);
463
464template <class BidirectionalIterator,
465 class Allocator = allocator<sub_match<BidirectionalIterator>>>
466class match_results
467{
468public:
469 typedef sub_match<BidirectionalIterator> value_type;
470 typedef const value_type& const_reference;
471 typedef value_type& reference;
472 typedef /implementation-defined/ const_iterator;
473 typedef const_iterator iterator;
474 typedef typename iterator_traits<BidirectionalIterator>::difference_type difference_type;
475 typedef typename allocator_traits<Allocator>::size_type size_type;
476 typedef Allocator allocator_type;
477 typedef typename iterator_traits<BidirectionalIterator>::value_type char_type;
478 typedef basic_string<char_type> string_type;
479
480 // construct/copy/destroy:
481 explicit match_results(const Allocator& a = Allocator()); // before C++20
482 match_results() : match_results(Allocator()) {} // C++20
483 explicit match_results(const Allocator& a); // C++20
484 match_results(const match_results& m);
485 match_results(match_results&& m) noexcept;
486 match_results& operator=(const match_results& m);
487 match_results& operator=(match_results&& m);
488 ~match_results();
489
490 bool ready() const;
491
492 // size:
493 size_type size() const;
494 size_type max_size() const;
495 bool empty() const;
496
497 // element access:
498 difference_type length(size_type sub = 0) const;
499 difference_type position(size_type sub = 0) const;
500 string_type str(size_type sub = 0) const;
501 const_reference operator[](size_type n) const;
502
503 const_reference prefix() const;
504 const_reference suffix() const;
505
506 const_iterator begin() const;
507 const_iterator end() const;
508 const_iterator cbegin() const;
509 const_iterator cend() const;
510
511 // format:
512 template <class OutputIter>
513 OutputIter
514 format(OutputIter out, const char_type* fmt_first,
515 const char_type* fmt_last,
516 regex_constants::match_flag_type flags = regex_constants::format_default) const;
517 template <class OutputIter, class ST, class SA>
518 OutputIter
519 format(OutputIter out, const basic_string<char_type, ST, SA>& fmt,
520 regex_constants::match_flag_type flags = regex_constants::format_default) const;
521 template <class ST, class SA>
522 basic_string<char_type, ST, SA>
523 format(const basic_string<char_type, ST, SA>& fmt,
524 regex_constants::match_flag_type flags = regex_constants::format_default) const;
525 string_type
526 format(const char_type* fmt,
527 regex_constants::match_flag_type flags = regex_constants::format_default) const;
528
529 // allocator:
530 allocator_type get_allocator() const;
531
532 // swap:
533 void swap(match_results& that);
534};
535
536typedef match_results<const char*> cmatch;
537typedef match_results<const wchar_t*> wcmatch;
538typedef match_results<string::const_iterator> smatch;
539typedef match_results<wstring::const_iterator> wsmatch;
540
541template <class BidirectionalIterator, class Allocator>
542 bool
543 operator==(const match_results<BidirectionalIterator, Allocator>& m1,
544 const match_results<BidirectionalIterator, Allocator>& m2);
545
546template <class BidirectionalIterator, class Allocator> // Removed in C++20
547 bool
548 operator!=(const match_results<BidirectionalIterator, Allocator>& m1,
549 const match_results<BidirectionalIterator, Allocator>& m2);
550
551template <class BidirectionalIterator, class Allocator>
552 void
553 swap(match_results<BidirectionalIterator, Allocator>& m1,
554 match_results<BidirectionalIterator, Allocator>& m2);
555
556template <class BidirectionalIterator, class Allocator, class charT, class traits>
557 bool
558 regex_match(BidirectionalIterator first, BidirectionalIterator last,
559 match_results<BidirectionalIterator, Allocator>& m,
560 const basic_regex<charT, traits>& e,
561 regex_constants::match_flag_type flags = regex_constants::match_default);
562
563template <class BidirectionalIterator, class charT, class traits>
564 bool
565 regex_match(BidirectionalIterator first, BidirectionalIterator last,
566 const basic_regex<charT, traits>& e,
567 regex_constants::match_flag_type flags = regex_constants::match_default);
568
569template <class charT, class Allocator, class traits>
570 bool
571 regex_match(const charT* str, match_results<const charT*, Allocator>& m,
572 const basic_regex<charT, traits>& e,
573 regex_constants::match_flag_type flags = regex_constants::match_default);
574
575template <class ST, class SA, class Allocator, class charT, class traits>
576 bool
577 regex_match(const basic_string<charT, ST, SA>& s,
578 match_results<typename basic_string<charT, ST, SA>::const_iterator, Allocator>& m,
579 const basic_regex<charT, traits>& e,
580 regex_constants::match_flag_type flags = regex_constants::match_default);
581
582template <class ST, class SA, class Allocator, class charT, class traits>
583 bool
584 regex_match(const basic_string<charT, ST, SA>&& s,
585 match_results<typename basic_string<charT, ST, SA>::const_iterator, Allocator>& m,
586 const basic_regex<charT, traits>& e,
587 regex_constants::match_flag_type flags = regex_constants::match_default) = delete; // C++14
588
589template <class charT, class traits>
590 bool
591 regex_match(const charT* str, const basic_regex<charT, traits>& e,
592 regex_constants::match_flag_type flags = regex_constants::match_default);
593
594template <class ST, class SA, class charT, class traits>
595 bool
596 regex_match(const basic_string<charT, ST, SA>& s,
597 const basic_regex<charT, traits>& e,
598 regex_constants::match_flag_type flags = regex_constants::match_default);
599
600template <class BidirectionalIterator, class Allocator, class charT, class traits>
601 bool
602 regex_search(BidirectionalIterator first, BidirectionalIterator last,
603 match_results<BidirectionalIterator, Allocator>& m,
604 const basic_regex<charT, traits>& e,
605 regex_constants::match_flag_type flags = regex_constants::match_default);
606
607template <class BidirectionalIterator, class charT, class traits>
608 bool
609 regex_search(BidirectionalIterator first, BidirectionalIterator last,
610 const basic_regex<charT, traits>& e,
611 regex_constants::match_flag_type flags = regex_constants::match_default);
612
613template <class charT, class Allocator, class traits>
614 bool
615 regex_search(const charT* str, match_results<const charT*, Allocator>& m,
616 const basic_regex<charT, traits>& e,
617 regex_constants::match_flag_type flags = regex_constants::match_default);
618
619template <class charT, class traits>
620 bool
621 regex_search(const charT* str, const basic_regex<charT, traits>& e,
622 regex_constants::match_flag_type flags = regex_constants::match_default);
623
624template <class ST, class SA, class charT, class traits>
625 bool
626 regex_search(const basic_string<charT, ST, SA>& s,
627 const basic_regex<charT, traits>& e,
628 regex_constants::match_flag_type flags = regex_constants::match_default);
629
630template <class ST, class SA, class Allocator, class charT, class traits>
631 bool
632 regex_search(const basic_string<charT, ST, SA>& s,
633 match_results<typename basic_string<charT, ST, SA>::const_iterator, Allocator>& m,
634 const basic_regex<charT, traits>& e,
635 regex_constants::match_flag_type flags = regex_constants::match_default);
636
637template <class ST, class SA, class Allocator, class charT, class traits>
638 bool
639 regex_search(const basic_string<charT, ST, SA>&& s,
640 match_results<typename basic_string<charT, ST, SA>::const_iterator, Allocator>& m,
641 const basic_regex<charT, traits>& e,
642 regex_constants::match_flag_type flags = regex_constants::match_default) = delete; // C++14
643
644template <class OutputIterator, class BidirectionalIterator,
645 class traits, class charT, class ST, class SA>
646 OutputIterator
647 regex_replace(OutputIterator out,
648 BidirectionalIterator first, BidirectionalIterator last,
649 const basic_regex<charT, traits>& e,
650 const basic_string<charT, ST, SA>& fmt,
651 regex_constants::match_flag_type flags = regex_constants::match_default);
652
653template <class OutputIterator, class BidirectionalIterator,
654 class traits, class charT>
655 OutputIterator
656 regex_replace(OutputIterator out,
657 BidirectionalIterator first, BidirectionalIterator last,
658 const basic_regex<charT, traits>& e, const charT* fmt,
659 regex_constants::match_flag_type flags = regex_constants::match_default);
660
661template <class traits, class charT, class ST, class SA, class FST, class FSA>
662 basic_string<charT, ST, SA>
663 regex_replace(const basic_string<charT, ST, SA>& s,
664 const basic_regex<charT, traits>& e,
665 const basic_string<charT, FST, FSA>& fmt,
666 regex_constants::match_flag_type flags = regex_constants::match_default);
667
668template <class traits, class charT, class ST, class SA>
669 basic_string<charT, ST, SA>
670 regex_replace(const basic_string<charT, ST, SA>& s,
671 const basic_regex<charT, traits>& e, const charT* fmt,
672 regex_constants::match_flag_type flags = regex_constants::match_default);
673
674template <class traits, class charT, class ST, class SA>
675 basic_string<charT>
676 regex_replace(const charT* s,
677 const basic_regex<charT, traits>& e,
678 const basic_string<charT, ST, SA>& fmt,
679 regex_constants::match_flag_type flags = regex_constants::match_default);
680
681template <class traits, class charT>
682 basic_string<charT>
683 regex_replace(const charT* s,
684 const basic_regex<charT, traits>& e,
685 const charT* fmt,
686 regex_constants::match_flag_type flags = regex_constants::match_default);
687
688template <class BidirectionalIterator,
689 class charT = typename iterator_traits< BidirectionalIterator>::value_type,
690 class traits = regex_traits<charT>>
691class regex_iterator
692{
693public:
694 typedef basic_regex<charT, traits> regex_type;
695 typedef match_results<BidirectionalIterator> value_type;
696 typedef ptrdiff_t difference_type;
697 typedef const value_type* pointer;
698 typedef const value_type& reference;
699 typedef forward_iterator_tag iterator_category;
700 typedef input_iterator_tag iterator_concept; // since C++20
701
702 regex_iterator();
703 regex_iterator(BidirectionalIterator a, BidirectionalIterator b,
704 const regex_type& re,
705 regex_constants::match_flag_type m = regex_constants::match_default);
706 regex_iterator(BidirectionalIterator a, BidirectionalIterator b,
707 const regex_type&& re,
708 regex_constants::match_flag_type m
709 = regex_constants::match_default) = delete; // C++14
710 regex_iterator(const regex_iterator&);
711 regex_iterator& operator=(const regex_iterator&);
712
713 bool operator==(const regex_iterator&) const;
714 bool operator==(default_sentinel_t) const { return *this == regex_iterator(); } // since C++20
715 bool operator!=(const regex_iterator&) const; // Removed in C++20
716
717 const value_type& operator*() const;
718 const value_type* operator->() const;
719
720 regex_iterator& operator++();
721 regex_iterator operator++(int);
722};
723
724typedef regex_iterator<const char*> cregex_iterator;
725typedef regex_iterator<const wchar_t*> wcregex_iterator;
726typedef regex_iterator<string::const_iterator> sregex_iterator;
727typedef regex_iterator<wstring::const_iterator> wsregex_iterator;
728
729template <class BidirectionalIterator,
730 class charT = typename iterator_traits<BidirectionalIterator>::value_type,
731 class traits = regex_traits<charT>>
732class regex_token_iterator
733{
734public:
735 typedef basic_regex<charT, traits> regex_type;
736 typedef sub_match<BidirectionalIterator> value_type;
737 typedef ptrdiff_t difference_type;
738 typedef const value_type* pointer;
739 typedef const value_type& reference;
740 typedef forward_iterator_tag iterator_category;
741 typedef input_iterator_tag iterator_concept; // since C++20
742
743 regex_token_iterator();
744 regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
745 const regex_type& re, int submatch = 0,
746 regex_constants::match_flag_type m = regex_constants::match_default);
747 regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
748 const regex_type&& re, int submatch = 0,
749 regex_constants::match_flag_type m = regex_constants::match_default) = delete; // C++14
750 regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
751 const regex_type& re, const vector<int>& submatches,
752 regex_constants::match_flag_type m = regex_constants::match_default);
753 regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
754 const regex_type&& re, const vector<int>& submatches,
755 regex_constants::match_flag_type m = regex_constants::match_default) = delete; // C++14
756 regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
757 const regex_type& re, initializer_list<int> submatches,
758 regex_constants::match_flag_type m = regex_constants::match_default);
759 regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
760 const regex_type&& re, initializer_list<int> submatches,
761 regex_constants::match_flag_type m = regex_constants::match_default) = delete; // C++14
762 template <size_t N>
763 regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
764 const regex_type& re, const int (&submatches)[N],
765 regex_constants::match_flag_type m = regex_constants::match_default);
766 template <size_t N>
767 regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
768 const regex_type&& re, const int (&submatches)[N],
769 regex_constants::match_flag_type m = regex_constants::match_default) = delete; // C++14
770 regex_token_iterator(const regex_token_iterator&);
771 regex_token_iterator& operator=(const regex_token_iterator&);
772
773 bool operator==(const regex_token_iterator&) const;
774 bool operator==(default_sentinel_t) const { return *this == regex_token_iterator(); } // since C++20
775 bool operator!=(const regex_token_iterator&) const; // Removed in C++20
776
777 const value_type& operator*() const;
778 const value_type* operator->() const;
779
780 regex_token_iterator& operator++();
781 regex_token_iterator operator++(int);
782};
783
784typedef regex_token_iterator<const char*> cregex_token_iterator;
785typedef regex_token_iterator<const wchar_t*> wcregex_token_iterator;
786typedef regex_token_iterator<string::const_iterator> sregex_token_iterator;
787typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;
788
789} // std
790*/
791
792#include <__algorithm/find.h>
793#include <__algorithm/search.h>
794#include <__assert>
795#include <__config>
796#include <__iterator/back_insert_iterator.h>
797#include <__iterator/default_sentinel.h>
798#include <__iterator/wrap_iter.h>
799#include <__locale>
800#include <__memory/shared_ptr.h>
801#include <__memory_resource/polymorphic_allocator.h>
802#include <__type_traits/is_swappable.h>
803#include <__utility/move.h>
804#include <__utility/pair.h>
805#include <__utility/swap.h>
806#include <__verbose_abort>
807#include <deque>
808#include <stdexcept>
809#include <string>
810#include <vector>
811#include <version>
812
813// standard-mandated includes
814
815// [iterator.range]
816#include <__iterator/access.h>
817#include <__iterator/data.h>
818#include <__iterator/empty.h>
819#include <__iterator/reverse_access.h>
820#include <__iterator/size.h>
821
822// [re.syn]
823#include <compare>
824#include <initializer_list>
825
826#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
827# pragma GCC system_header
828#endif
829
830_LIBCPP_PUSH_MACROS
831#include <__undef_macros>
832
833#define _LIBCPP_REGEX_COMPLEXITY_FACTOR 4096
834
835_LIBCPP_BEGIN_NAMESPACE_STD
836
837namespace regex_constants {
838
839// syntax_option_type
840
841enum syntax_option_type {
842 icase = 1 << 0,
843 nosubs = 1 << 1,
844 optimize = 1 << 2,
845 collate = 1 << 3,
846#ifdef _LIBCPP_ABI_REGEX_CONSTANTS_NONZERO
847 ECMAScript = 1 << 9,
848#else
849 ECMAScript = 0,
850#endif
851 basic = 1 << 4,
852 extended = 1 << 5,
853 awk = 1 << 6,
854 grep = 1 << 7,
855 egrep = 1 << 8,
856 // 1 << 9 may be used by ECMAScript
857 multiline = 1 << 10
858};
859
860_LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR syntax_option_type __get_grammar(syntax_option_type __g) {
861#ifdef _LIBCPP_ABI_REGEX_CONSTANTS_NONZERO
862 return static_cast<syntax_option_type>(__g & 0x3F0);
863#else
864 return static_cast<syntax_option_type>(__g & 0x1F0);
865#endif
866}
867
868inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR syntax_option_type operator~(syntax_option_type __x) {
869 return syntax_option_type(~int(__x) & 0x1FF);
870}
871
872inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR syntax_option_type
873operator&(syntax_option_type __x, syntax_option_type __y) {
874 return syntax_option_type(int(__x) & int(__y));
875}
876
877inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR syntax_option_type
878operator|(syntax_option_type __x, syntax_option_type __y) {
879 return syntax_option_type(int(__x) | int(__y));
880}
881
882inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR syntax_option_type
883operator^(syntax_option_type __x, syntax_option_type __y) {
884 return syntax_option_type(int(__x) ^ int(__y));
885}
886
887inline _LIBCPP_HIDE_FROM_ABI syntax_option_type& operator&=(syntax_option_type& __x, syntax_option_type __y) {
888 __x = __x & __y;
889 return __x;
890}
891
892inline _LIBCPP_HIDE_FROM_ABI syntax_option_type& operator|=(syntax_option_type& __x, syntax_option_type __y) {
893 __x = __x | __y;
894 return __x;
895}
896
897inline _LIBCPP_HIDE_FROM_ABI syntax_option_type& operator^=(syntax_option_type& __x, syntax_option_type __y) {
898 __x = __x ^ __y;
899 return __x;
900}
901
902// match_flag_type
903
904enum match_flag_type {
905 match_default = 0,
906 match_not_bol = 1 << 0,
907 match_not_eol = 1 << 1,
908 match_not_bow = 1 << 2,
909 match_not_eow = 1 << 3,
910 match_any = 1 << 4,
911 match_not_null = 1 << 5,
912 match_continuous = 1 << 6,
913 match_prev_avail = 1 << 7,
914 format_default = 0,
915 format_sed = 1 << 8,
916 format_no_copy = 1 << 9,
917 format_first_only = 1 << 10,
918 __no_update_pos = 1 << 11,
919 __full_match = 1 << 12
920};
921
922inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR match_flag_type operator~(match_flag_type __x) {
923 return match_flag_type(~int(__x) & 0x0FFF);
924}
925
926inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR match_flag_type operator&(match_flag_type __x, match_flag_type __y) {
927 return match_flag_type(int(__x) & int(__y));
928}
929
930inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR match_flag_type operator|(match_flag_type __x, match_flag_type __y) {
931 return match_flag_type(int(__x) | int(__y));
932}
933
934inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR match_flag_type operator^(match_flag_type __x, match_flag_type __y) {
935 return match_flag_type(int(__x) ^ int(__y));
936}
937
938inline _LIBCPP_HIDE_FROM_ABI match_flag_type& operator&=(match_flag_type& __x, match_flag_type __y) {
939 __x = __x & __y;
940 return __x;
941}
942
943inline _LIBCPP_HIDE_FROM_ABI match_flag_type& operator|=(match_flag_type& __x, match_flag_type __y) {
944 __x = __x | __y;
945 return __x;
946}
947
948inline _LIBCPP_HIDE_FROM_ABI match_flag_type& operator^=(match_flag_type& __x, match_flag_type __y) {
949 __x = __x ^ __y;
950 return __x;
951}
952
953enum error_type {
954 error_collate = 1,
955 error_ctype,
956 error_escape,
957 error_backref,
958 error_brack,
959 error_paren,
960 error_brace,
961 error_badbrace,
962 error_range,
963 error_space,
964 error_badrepeat,
965 error_complexity,
966 error_stack,
967 __re_err_grammar,
968 __re_err_empty,
969 __re_err_unknown,
970 __re_err_parse
971};
972
973} // namespace regex_constants
974
975class _LIBCPP_EXPORTED_FROM_ABI regex_error : public runtime_error {
976 regex_constants::error_type __code_;
977
978public:
979 explicit regex_error(regex_constants::error_type __ecode);
980 _LIBCPP_HIDE_FROM_ABI regex_error(const regex_error&) _NOEXCEPT = default;
981 ~regex_error() _NOEXCEPT override;
982 _LIBCPP_HIDE_FROM_ABI regex_constants::error_type code() const { return __code_; }
983};
984
985template <regex_constants::error_type _Ev>
986_LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI void __throw_regex_error() {
987#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
988 throw regex_error(_Ev);
989#else
990 _LIBCPP_VERBOSE_ABORT("regex_error was thrown in -fno-exceptions mode");
991#endif
992}
993
994template <class _CharT>
995struct _LIBCPP_TEMPLATE_VIS regex_traits {
996public:
997 typedef _CharT char_type;
998 typedef basic_string<char_type> string_type;
999 typedef locale locale_type;
1000#if defined(__BIONIC__) || defined(_NEWLIB_VERSION)
1001 // Originally bionic's ctype_base used its own ctype masks because the
1002 // builtin ctype implementation wasn't in libc++ yet. Bionic's ctype mask
1003 // was only 8 bits wide and already saturated, so it used a wider type here
1004 // to make room for __regex_word (then a part of this class rather than
1005 // ctype_base). Bionic has since moved to the builtin ctype_base
1006 // implementation, but this was not updated to match. Since then Android has
1007 // needed to maintain a stable libc++ ABI, and this can't be changed without
1008 // an ABI break.
1009 // We also need this workaround for newlib since _NEWLIB_VERSION is not
1010 // defined yet inside __config, so we can't set the
1011 // _LIBCPP_PROVIDES_DEFAULT_RUNE_TABLE macro. Additionally, newlib is
1012 // often used for space constrained environments, so it makes sense not to
1013 // duplicate the ctype table.
1014 typedef uint16_t char_class_type;
1015#else
1016 typedef ctype_base::mask char_class_type;
1017#endif
1018
1019 static const char_class_type __regex_word = ctype_base::__regex_word;
1020
1021private:
1022 locale __loc_;
1023 const ctype<char_type>* __ct_;
1024 const collate<char_type>* __col_;
1025
1026public:
1027 regex_traits();
1028
1029 _LIBCPP_HIDE_FROM_ABI static size_t length(const char_type* __p) { return char_traits<char_type>::length(__p); }
1030 _LIBCPP_HIDE_FROM_ABI char_type translate(char_type __c) const { return __c; }
1031 char_type translate_nocase(char_type __c) const;
1032 template <class _ForwardIterator>
1033 string_type transform(_ForwardIterator __f, _ForwardIterator __l) const;
1034 template <class _ForwardIterator>
1035 _LIBCPP_HIDE_FROM_ABI string_type transform_primary(_ForwardIterator __f, _ForwardIterator __l) const {
1036 return __transform_primary(__f, __l, char_type());
1037 }
1038 template <class _ForwardIterator>
1039 _LIBCPP_HIDE_FROM_ABI string_type lookup_collatename(_ForwardIterator __f, _ForwardIterator __l) const {
1040 return __lookup_collatename(__f, __l, char_type());
1041 }
1042 template <class _ForwardIterator>
1043 _LIBCPP_HIDE_FROM_ABI char_class_type
1044 lookup_classname(_ForwardIterator __f, _ForwardIterator __l, bool __icase = false) const {
1045 return __lookup_classname(__f, __l, __icase, char_type());
1046 }
1047 bool isctype(char_type __c, char_class_type __m) const;
1048 _LIBCPP_HIDE_FROM_ABI int value(char_type __ch, int __radix) const { return __regex_traits_value(__ch, __radix); }
1049 locale_type imbue(locale_type __l);
1050 _LIBCPP_HIDE_FROM_ABI locale_type getloc() const { return __loc_; }
1051
1052private:
1053 void __init();
1054
1055 template <class _ForwardIterator>
1056 string_type __transform_primary(_ForwardIterator __f, _ForwardIterator __l, char) const;
1057#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
1058 template <class _ForwardIterator>
1059 string_type __transform_primary(_ForwardIterator __f, _ForwardIterator __l, wchar_t) const;
1060#endif
1061 template <class _ForwardIterator>
1062 string_type __lookup_collatename(_ForwardIterator __f, _ForwardIterator __l, char) const;
1063#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
1064 template <class _ForwardIterator>
1065 string_type __lookup_collatename(_ForwardIterator __f, _ForwardIterator __l, wchar_t) const;
1066#endif
1067 template <class _ForwardIterator>
1068 char_class_type __lookup_classname(_ForwardIterator __f, _ForwardIterator __l, bool __icase, char) const;
1069#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
1070 template <class _ForwardIterator>
1071 char_class_type __lookup_classname(_ForwardIterator __f, _ForwardIterator __l, bool __icase, wchar_t) const;
1072#endif
1073
1074 static int __regex_traits_value(unsigned char __ch, int __radix);
1075 _LIBCPP_HIDE_FROM_ABI int __regex_traits_value(char __ch, int __radix) const {
1076 return __regex_traits_value(static_cast<unsigned char>(__ch), __radix);
1077 }
1078#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
1079 _LIBCPP_HIDE_FROM_ABI int __regex_traits_value(wchar_t __ch, int __radix) const;
1080#endif
1081};
1082
1083template <class _CharT>
1084const typename regex_traits<_CharT>::char_class_type regex_traits<_CharT>::__regex_word;
1085
1086template <class _CharT>
1087regex_traits<_CharT>::regex_traits() {
1088 __init();
1089}
1090
1091template <class _CharT>
1092typename regex_traits<_CharT>::char_type regex_traits<_CharT>::translate_nocase(char_type __c) const {
1093 return __ct_->tolower(__c);
1094}
1095
1096template <class _CharT>
1097template <class _ForwardIterator>
1098typename regex_traits<_CharT>::string_type
1099regex_traits<_CharT>::transform(_ForwardIterator __f, _ForwardIterator __l) const {
1100 string_type __s(__f, __l);
1101 return __col_->transform(__s.data(), __s.data() + __s.size());
1102}
1103
1104template <class _CharT>
1105void regex_traits<_CharT>::__init() {
1106 __ct_ = &std::use_facet<ctype<char_type> >(__loc_);
1107 __col_ = &std::use_facet<collate<char_type> >(__loc_);
1108}
1109
1110template <class _CharT>
1111typename regex_traits<_CharT>::locale_type regex_traits<_CharT>::imbue(locale_type __l) {
1112 locale __r = __loc_;
1113 __loc_ = __l;
1114 __init();
1115 return __r;
1116}
1117
1118// transform_primary is very FreeBSD-specific
1119
1120template <class _CharT>
1121template <class _ForwardIterator>
1122typename regex_traits<_CharT>::string_type
1123regex_traits<_CharT>::__transform_primary(_ForwardIterator __f, _ForwardIterator __l, char) const {
1124 const string_type __s(__f, __l);
1125 string_type __d = __col_->transform(__s.data(), __s.data() + __s.size());
1126 switch (__d.size()) {
1127 case 1:
1128 break;
1129 case 12:
1130 __d[11] = __d[3];
1131 break;
1132 default:
1133 __d.clear();
1134 break;
1135 }
1136 return __d;
1137}
1138
1139#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
1140template <class _CharT>
1141template <class _ForwardIterator>
1142typename regex_traits<_CharT>::string_type
1143regex_traits<_CharT>::__transform_primary(_ForwardIterator __f, _ForwardIterator __l, wchar_t) const {
1144 const string_type __s(__f, __l);
1145 string_type __d = __col_->transform(__s.data(), __s.data() + __s.size());
1146 switch (__d.size()) {
1147 case 1:
1148 break;
1149 case 3:
1150 __d[2] = __d[0];
1151 break;
1152 default:
1153 __d.clear();
1154 break;
1155 }
1156 return __d;
1157}
1158#endif
1159
1160// lookup_collatename is very FreeBSD-specific
1161
1162_LIBCPP_EXPORTED_FROM_ABI string __get_collation_name(const char* __s);
1163
1164template <class _CharT>
1165template <class _ForwardIterator>
1166typename regex_traits<_CharT>::string_type
1167regex_traits<_CharT>::__lookup_collatename(_ForwardIterator __f, _ForwardIterator __l, char) const {
1168 string_type __s(__f, __l);
1169 string_type __r;
1170 if (!__s.empty()) {
1171 __r = std::__get_collation_name(__s.c_str());
1172 if (__r.empty() && __s.size() <= 2) {
1173 __r = __col_->transform(__s.data(), __s.data() + __s.size());
1174 if (__r.size() == 1 || __r.size() == 12)
1175 __r = __s;
1176 else
1177 __r.clear();
1178 }
1179 }
1180 return __r;
1181}
1182
1183#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
1184template <class _CharT>
1185template <class _ForwardIterator>
1186typename regex_traits<_CharT>::string_type
1187regex_traits<_CharT>::__lookup_collatename(_ForwardIterator __f, _ForwardIterator __l, wchar_t) const {
1188 string_type __s(__f, __l);
1189 string __n;
1190 __n.reserve(__s.size());
1191 for (typename string_type::const_iterator __i = __s.begin(), __e = __s.end(); __i != __e; ++__i) {
1192 if (static_cast<unsigned>(*__i) >= 127)
1193 return string_type();
1194 __n.push_back(char(*__i));
1195 }
1196 string_type __r;
1197 if (!__s.empty()) {
1198 __n = __get_collation_name(__n.c_str());
1199 if (!__n.empty())
1200 __r.assign(__n.begin(), __n.end());
1201 else if (__s.size() <= 2) {
1202 __r = __col_->transform(__s.data(), __s.data() + __s.size());
1203 if (__r.size() == 1 || __r.size() == 3)
1204 __r = __s;
1205 else
1206 __r.clear();
1207 }
1208 }
1209 return __r;
1210}
1211#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
1212
1213// lookup_classname
1214
1215regex_traits<char>::char_class_type _LIBCPP_EXPORTED_FROM_ABI __get_classname(const char* __s, bool __icase);
1216
1217template <class _CharT>
1218template <class _ForwardIterator>
1219typename regex_traits<_CharT>::char_class_type
1220regex_traits<_CharT>::__lookup_classname(_ForwardIterator __f, _ForwardIterator __l, bool __icase, char) const {
1221 string_type __s(__f, __l);
1222 __ct_->tolower(&__s[0], &__s[0] + __s.size());
1223 return std::__get_classname(__s.c_str(), __icase);
1224}
1225
1226#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
1227template <class _CharT>
1228template <class _ForwardIterator>
1229typename regex_traits<_CharT>::char_class_type
1230regex_traits<_CharT>::__lookup_classname(_ForwardIterator __f, _ForwardIterator __l, bool __icase, wchar_t) const {
1231 string_type __s(__f, __l);
1232 __ct_->tolower(&__s[0], &__s[0] + __s.size());
1233 string __n;
1234 __n.reserve(__s.size());
1235 for (typename string_type::const_iterator __i = __s.begin(), __e = __s.end(); __i != __e; ++__i) {
1236 if (static_cast<unsigned>(*__i) >= 127)
1237 return char_class_type();
1238 __n.push_back(char(*__i));
1239 }
1240 return __get_classname(__n.c_str(), __icase);
1241}
1242#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
1243
1244template <class _CharT>
1245bool regex_traits<_CharT>::isctype(char_type __c, char_class_type __m) const {
1246 if (__ct_->is(__m, __c))
1247 return true;
1248 return (__c == '_' && (__m & __regex_word));
1249}
1250
1251inline _LIBCPP_HIDE_FROM_ABI bool __is_07(unsigned char __c) {
1252 return (__c & 0xF8u) ==
1253#if defined(__MVS__) && !defined(__NATIVE_ASCII_F)
1254 0xF0;
1255#else
1256 0x30;
1257#endif
1258}
1259
1260inline _LIBCPP_HIDE_FROM_ABI bool __is_89(unsigned char __c) {
1261 return (__c & 0xFEu) ==
1262#if defined(__MVS__) && !defined(__NATIVE_ASCII_F)
1263 0xF8;
1264#else
1265 0x38;
1266#endif
1267}
1268
1269inline _LIBCPP_HIDE_FROM_ABI unsigned char __to_lower(unsigned char __c) {
1270#if defined(__MVS__) && !defined(__NATIVE_ASCII_F)
1271 return __c & 0xBF;
1272#else
1273 return __c | 0x20;
1274#endif
1275}
1276
1277template <class _CharT>
1278int regex_traits<_CharT>::__regex_traits_value(unsigned char __ch, int __radix) {
1279 if (__is_07(__ch)) // '0' <= __ch && __ch <= '7'
1280 return __ch - '0';
1281 if (__radix != 8) {
1282 if (__is_89(__ch)) // '8' <= __ch && __ch <= '9'
1283 return __ch - '0';
1284 if (__radix == 16) {
1285 __ch = __to_lower(__ch); // tolower
1286 if ('a' <= __ch && __ch <= 'f')
1287 return __ch - ('a' - 10);
1288 }
1289 }
1290 return -1;
1291}
1292
1293#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
1294template <class _CharT>
1295inline int regex_traits<_CharT>::__regex_traits_value(wchar_t __ch, int __radix) const {
1296 return __regex_traits_value(static_cast<unsigned char>(__ct_->narrow(__ch, char_type())), __radix);
1297}
1298#endif
1299
1300template <class _CharT>
1301class __node;
1302
1303template <class _BidirectionalIterator>
1304class _LIBCPP_TEMPLATE_VIS sub_match;
1305
1306template <class _BidirectionalIterator, class _Allocator = allocator<sub_match<_BidirectionalIterator> > >
1307class _LIBCPP_TEMPLATE_VIS match_results;
1308
1309template <class _CharT>
1310struct __state {
1311 enum {
1312 __end_state = -1000,
1313 __consume_input, // -999
1314 __begin_marked_expr, // -998
1315 __end_marked_expr, // -997
1316 __pop_state, // -996
1317 __accept_and_consume, // -995
1318 __accept_but_not_consume, // -994
1319 __reject, // -993
1320 __split,
1321 __repeat
1322 };
1323
1324 int __do_;
1325 const _CharT* __first_;
1326 const _CharT* __current_;
1327 const _CharT* __last_;
1328 vector<sub_match<const _CharT*> > __sub_matches_;
1329 vector<pair<size_t, const _CharT*> > __loop_data_;
1330 const __node<_CharT>* __node_;
1331 regex_constants::match_flag_type __flags_;
1332 bool __at_first_;
1333
1334 _LIBCPP_HIDE_FROM_ABI __state()
1335 : __do_(0),
1336 __first_(nullptr),
1337 __current_(nullptr),
1338 __last_(nullptr),
1339 __node_(nullptr),
1340 __flags_(),
1341 __at_first_(false) {}
1342};
1343
1344// __node
1345
1346template <class _CharT>
1347class __node {
1348public:
1349 typedef std::__state<_CharT> __state;
1350
1351 _LIBCPP_HIDE_FROM_ABI __node() {}
1352 __node(const __node&) = delete;
1353 __node& operator=(const __node&) = delete;
1354 _LIBCPP_HIDE_FROM_ABI_VIRTUAL
1355 virtual ~__node() {}
1356
1357 _LIBCPP_HIDE_FROM_ABI_VIRTUAL
1358 virtual void __exec(__state&) const {}
1359 _LIBCPP_HIDE_FROM_ABI_VIRTUAL
1360 virtual void __exec_split(bool, __state&) const {}
1361};
1362
1363// __end_state
1364
1365template <class _CharT>
1366class __end_state : public __node<_CharT> {
1367public:
1368 typedef std::__state<_CharT> __state;
1369
1370 _LIBCPP_HIDE_FROM_ABI __end_state() {}
1371
1372 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
1373};
1374
1375template <class _CharT>
1376void __end_state<_CharT>::__exec(__state& __s) const {
1377 __s.__do_ = __state::__end_state;
1378}
1379
1380// __has_one_state
1381
1382template <class _CharT>
1383class __has_one_state : public __node<_CharT> {
1384 __node<_CharT>* __first_;
1385
1386public:
1387 _LIBCPP_HIDE_FROM_ABI explicit __has_one_state(__node<_CharT>* __s) : __first_(__s) {}
1388
1389 _LIBCPP_HIDE_FROM_ABI __node<_CharT>* first() const { return __first_; }
1390 _LIBCPP_HIDE_FROM_ABI __node<_CharT>*& first() { return __first_; }
1391};
1392
1393// __owns_one_state
1394
1395template <class _CharT>
1396class __owns_one_state : public __has_one_state<_CharT> {
1397 typedef __has_one_state<_CharT> base;
1398
1399public:
1400 _LIBCPP_HIDE_FROM_ABI explicit __owns_one_state(__node<_CharT>* __s) : base(__s) {}
1401
1402 ~__owns_one_state() override;
1403};
1404
1405template <class _CharT>
1406__owns_one_state<_CharT>::~__owns_one_state() {
1407 delete this->first();
1408}
1409
1410// __empty_state
1411
1412template <class _CharT>
1413class __empty_state : public __owns_one_state<_CharT> {
1414 typedef __owns_one_state<_CharT> base;
1415
1416public:
1417 typedef std::__state<_CharT> __state;
1418
1419 _LIBCPP_HIDE_FROM_ABI explicit __empty_state(__node<_CharT>* __s) : base(__s) {}
1420
1421 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
1422};
1423
1424template <class _CharT>
1425void __empty_state<_CharT>::__exec(__state& __s) const {
1426 __s.__do_ = __state::__accept_but_not_consume;
1427 __s.__node_ = this->first();
1428}
1429
1430// __empty_non_own_state
1431
1432template <class _CharT>
1433class __empty_non_own_state : public __has_one_state<_CharT> {
1434 typedef __has_one_state<_CharT> base;
1435
1436public:
1437 typedef std::__state<_CharT> __state;
1438
1439 _LIBCPP_HIDE_FROM_ABI explicit __empty_non_own_state(__node<_CharT>* __s) : base(__s) {}
1440
1441 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
1442};
1443
1444template <class _CharT>
1445void __empty_non_own_state<_CharT>::__exec(__state& __s) const {
1446 __s.__do_ = __state::__accept_but_not_consume;
1447 __s.__node_ = this->first();
1448}
1449
1450// __repeat_one_loop
1451
1452template <class _CharT>
1453class __repeat_one_loop : public __has_one_state<_CharT> {
1454 typedef __has_one_state<_CharT> base;
1455
1456public:
1457 typedef std::__state<_CharT> __state;
1458
1459 _LIBCPP_HIDE_FROM_ABI explicit __repeat_one_loop(__node<_CharT>* __s) : base(__s) {}
1460
1461 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
1462};
1463
1464template <class _CharT>
1465void __repeat_one_loop<_CharT>::__exec(__state& __s) const {
1466 __s.__do_ = __state::__repeat;
1467 __s.__node_ = this->first();
1468}
1469
1470// __owns_two_states
1471
1472template <class _CharT>
1473class __owns_two_states : public __owns_one_state<_CharT> {
1474 typedef __owns_one_state<_CharT> base;
1475
1476 base* __second_;
1477
1478public:
1479 _LIBCPP_HIDE_FROM_ABI explicit __owns_two_states(__node<_CharT>* __s1, base* __s2) : base(__s1), __second_(__s2) {}
1480
1481 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual ~__owns_two_states();
1482
1483 _LIBCPP_HIDE_FROM_ABI base* second() const { return __second_; }
1484 _LIBCPP_HIDE_FROM_ABI base*& second() { return __second_; }
1485};
1486
1487template <class _CharT>
1488__owns_two_states<_CharT>::~__owns_two_states() {
1489 delete __second_;
1490}
1491
1492// __loop
1493
1494template <class _CharT>
1495class __loop : public __owns_two_states<_CharT> {
1496 typedef __owns_two_states<_CharT> base;
1497
1498 size_t __min_;
1499 size_t __max_;
1500 unsigned __loop_id_;
1501 unsigned __mexp_begin_;
1502 unsigned __mexp_end_;
1503 bool __greedy_;
1504
1505public:
1506 typedef std::__state<_CharT> __state;
1507
1508 _LIBCPP_HIDE_FROM_ABI explicit __loop(
1509 unsigned __loop_id,
1510 __node<_CharT>* __s1,
1511 __owns_one_state<_CharT>* __s2,
1512 unsigned __mexp_begin,
1513 unsigned __mexp_end,
1514 bool __greedy = true,
1515 size_t __min = 0,
1516 size_t __max = numeric_limits<size_t>::max())
1517 : base(__s1, __s2),
1518 __min_(__min),
1519 __max_(__max),
1520 __loop_id_(__loop_id),
1521 __mexp_begin_(__mexp_begin),
1522 __mexp_end_(__mexp_end),
1523 __greedy_(__greedy) {}
1524
1525 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state& __s) const;
1526 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec_split(bool __second, __state& __s) const;
1527
1528private:
1529 _LIBCPP_HIDE_FROM_ABI void __init_repeat(__state& __s) const {
1530 __s.__loop_data_[__loop_id_].second = __s.__current_;
1531 for (size_t __i = __mexp_begin_ - 1; __i != __mexp_end_ - 1; ++__i) {
1532 __s.__sub_matches_[__i].first = __s.__last_;
1533 __s.__sub_matches_[__i].second = __s.__last_;
1534 __s.__sub_matches_[__i].matched = false;
1535 }
1536 }
1537};
1538
1539template <class _CharT>
1540void __loop<_CharT>::__exec(__state& __s) const {
1541 if (__s.__do_ == __state::__repeat) {
1542 bool __do_repeat = ++__s.__loop_data_[__loop_id_].first < __max_;
1543 bool __do_alt = __s.__loop_data_[__loop_id_].first >= __min_;
1544 if (__do_repeat && __do_alt && __s.__loop_data_[__loop_id_].second == __s.__current_)
1545 __do_repeat = false;
1546 if (__do_repeat && __do_alt)
1547 __s.__do_ = __state::__split;
1548 else if (__do_repeat) {
1549 __s.__do_ = __state::__accept_but_not_consume;
1550 __s.__node_ = this->first();
1551 __init_repeat(__s);
1552 } else {
1553 __s.__do_ = __state::__accept_but_not_consume;
1554 __s.__node_ = this->second();
1555 }
1556 } else {
1557 __s.__loop_data_[__loop_id_].first = 0;
1558 bool __do_repeat = 0 < __max_;
1559 bool __do_alt = 0 >= __min_;
1560 if (__do_repeat && __do_alt)
1561 __s.__do_ = __state::__split;
1562 else if (__do_repeat) {
1563 __s.__do_ = __state::__accept_but_not_consume;
1564 __s.__node_ = this->first();
1565 __init_repeat(__s);
1566 } else {
1567 __s.__do_ = __state::__accept_but_not_consume;
1568 __s.__node_ = this->second();
1569 }
1570 }
1571}
1572
1573template <class _CharT>
1574void __loop<_CharT>::__exec_split(bool __second, __state& __s) const {
1575 __s.__do_ = __state::__accept_but_not_consume;
1576 if (__greedy_ != __second) {
1577 __s.__node_ = this->first();
1578 __init_repeat(__s);
1579 } else
1580 __s.__node_ = this->second();
1581}
1582
1583// __alternate
1584
1585template <class _CharT>
1586class __alternate : public __owns_two_states<_CharT> {
1587 typedef __owns_two_states<_CharT> base;
1588
1589public:
1590 typedef std::__state<_CharT> __state;
1591
1592 _LIBCPP_HIDE_FROM_ABI explicit __alternate(__owns_one_state<_CharT>* __s1, __owns_one_state<_CharT>* __s2)
1593 : base(__s1, __s2) {}
1594
1595 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state& __s) const;
1596 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec_split(bool __second, __state& __s) const;
1597};
1598
1599template <class _CharT>
1600void __alternate<_CharT>::__exec(__state& __s) const {
1601 __s.__do_ = __state::__split;
1602}
1603
1604template <class _CharT>
1605void __alternate<_CharT>::__exec_split(bool __second, __state& __s) const {
1606 __s.__do_ = __state::__accept_but_not_consume;
1607 if (__second)
1608 __s.__node_ = this->second();
1609 else
1610 __s.__node_ = this->first();
1611}
1612
1613// __begin_marked_subexpression
1614
1615template <class _CharT>
1616class __begin_marked_subexpression : public __owns_one_state<_CharT> {
1617 typedef __owns_one_state<_CharT> base;
1618
1619 unsigned __mexp_;
1620
1621public:
1622 typedef std::__state<_CharT> __state;
1623
1624 _LIBCPP_HIDE_FROM_ABI explicit __begin_marked_subexpression(unsigned __mexp, __node<_CharT>* __s)
1625 : base(__s), __mexp_(__mexp) {}
1626
1627 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
1628};
1629
1630template <class _CharT>
1631void __begin_marked_subexpression<_CharT>::__exec(__state& __s) const {
1632 __s.__do_ = __state::__accept_but_not_consume;
1633 __s.__sub_matches_[__mexp_ - 1].first = __s.__current_;
1634 __s.__node_ = this->first();
1635}
1636
1637// __end_marked_subexpression
1638
1639template <class _CharT>
1640class __end_marked_subexpression : public __owns_one_state<_CharT> {
1641 typedef __owns_one_state<_CharT> base;
1642
1643 unsigned __mexp_;
1644
1645public:
1646 typedef std::__state<_CharT> __state;
1647
1648 _LIBCPP_HIDE_FROM_ABI explicit __end_marked_subexpression(unsigned __mexp, __node<_CharT>* __s)
1649 : base(__s), __mexp_(__mexp) {}
1650
1651 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
1652};
1653
1654template <class _CharT>
1655void __end_marked_subexpression<_CharT>::__exec(__state& __s) const {
1656 __s.__do_ = __state::__accept_but_not_consume;
1657 __s.__sub_matches_[__mexp_ - 1].second = __s.__current_;
1658 __s.__sub_matches_[__mexp_ - 1].matched = true;
1659 __s.__node_ = this->first();
1660}
1661
1662// __back_ref
1663
1664template <class _CharT>
1665class __back_ref : public __owns_one_state<_CharT> {
1666 typedef __owns_one_state<_CharT> base;
1667
1668 unsigned __mexp_;
1669
1670public:
1671 typedef std::__state<_CharT> __state;
1672
1673 _LIBCPP_HIDE_FROM_ABI explicit __back_ref(unsigned __mexp, __node<_CharT>* __s) : base(__s), __mexp_(__mexp) {}
1674
1675 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
1676};
1677
1678template <class _CharT>
1679void __back_ref<_CharT>::__exec(__state& __s) const {
1680 if (__mexp_ > __s.__sub_matches_.size())
1681 __throw_regex_error<regex_constants::error_backref>();
1682 sub_match<const _CharT*>& __sm = __s.__sub_matches_[__mexp_ - 1];
1683 if (__sm.matched) {
1684 ptrdiff_t __len = __sm.second - __sm.first;
1685 if (__s.__last_ - __s.__current_ >= __len && std::equal(__sm.first, __sm.second, __s.__current_)) {
1686 __s.__do_ = __state::__accept_but_not_consume;
1687 __s.__current_ += __len;
1688 __s.__node_ = this->first();
1689 } else {
1690 __s.__do_ = __state::__reject;
1691 __s.__node_ = nullptr;
1692 }
1693 } else {
1694 __s.__do_ = __state::__reject;
1695 __s.__node_ = nullptr;
1696 }
1697}
1698
1699// __back_ref_icase
1700
1701template <class _CharT, class _Traits>
1702class __back_ref_icase : public __owns_one_state<_CharT> {
1703 typedef __owns_one_state<_CharT> base;
1704
1705 _Traits __traits_;
1706 unsigned __mexp_;
1707
1708public:
1709 typedef std::__state<_CharT> __state;
1710
1711 _LIBCPP_HIDE_FROM_ABI explicit __back_ref_icase(const _Traits& __traits, unsigned __mexp, __node<_CharT>* __s)
1712 : base(__s), __traits_(__traits), __mexp_(__mexp) {}
1713
1714 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
1715};
1716
1717template <class _CharT, class _Traits>
1718void __back_ref_icase<_CharT, _Traits>::__exec(__state& __s) const {
1719 sub_match<const _CharT*>& __sm = __s.__sub_matches_[__mexp_ - 1];
1720 if (__sm.matched) {
1721 ptrdiff_t __len = __sm.second - __sm.first;
1722 if (__s.__last_ - __s.__current_ >= __len) {
1723 for (ptrdiff_t __i = 0; __i < __len; ++__i) {
1724 if (__traits_.translate_nocase(__sm.first[__i]) != __traits_.translate_nocase(__s.__current_[__i]))
1725 goto __not_equal;
1726 }
1727 __s.__do_ = __state::__accept_but_not_consume;
1728 __s.__current_ += __len;
1729 __s.__node_ = this->first();
1730 } else {
1731 __s.__do_ = __state::__reject;
1732 __s.__node_ = nullptr;
1733 }
1734 } else {
1735 __not_equal:
1736 __s.__do_ = __state::__reject;
1737 __s.__node_ = nullptr;
1738 }
1739}
1740
1741// __back_ref_collate
1742
1743template <class _CharT, class _Traits>
1744class __back_ref_collate : public __owns_one_state<_CharT> {
1745 typedef __owns_one_state<_CharT> base;
1746
1747 _Traits __traits_;
1748 unsigned __mexp_;
1749
1750public:
1751 typedef std::__state<_CharT> __state;
1752
1753 _LIBCPP_HIDE_FROM_ABI explicit __back_ref_collate(const _Traits& __traits, unsigned __mexp, __node<_CharT>* __s)
1754 : base(__s), __traits_(__traits), __mexp_(__mexp) {}
1755
1756 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
1757};
1758
1759template <class _CharT, class _Traits>
1760void __back_ref_collate<_CharT, _Traits>::__exec(__state& __s) const {
1761 sub_match<const _CharT*>& __sm = __s.__sub_matches_[__mexp_ - 1];
1762 if (__sm.matched) {
1763 ptrdiff_t __len = __sm.second - __sm.first;
1764 if (__s.__last_ - __s.__current_ >= __len) {
1765 for (ptrdiff_t __i = 0; __i < __len; ++__i) {
1766 if (__traits_.translate(__sm.first[__i]) != __traits_.translate(__s.__current_[__i]))
1767 goto __not_equal;
1768 }
1769 __s.__do_ = __state::__accept_but_not_consume;
1770 __s.__current_ += __len;
1771 __s.__node_ = this->first();
1772 } else {
1773 __s.__do_ = __state::__reject;
1774 __s.__node_ = nullptr;
1775 }
1776 } else {
1777 __not_equal:
1778 __s.__do_ = __state::__reject;
1779 __s.__node_ = nullptr;
1780 }
1781}
1782
1783// __word_boundary
1784
1785template <class _CharT, class _Traits>
1786class __word_boundary : public __owns_one_state<_CharT> {
1787 typedef __owns_one_state<_CharT> base;
1788
1789 _Traits __traits_;
1790 bool __invert_;
1791
1792public:
1793 typedef std::__state<_CharT> __state;
1794
1795 _LIBCPP_HIDE_FROM_ABI explicit __word_boundary(const _Traits& __traits, bool __invert, __node<_CharT>* __s)
1796 : base(__s), __traits_(__traits), __invert_(__invert) {}
1797
1798 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
1799};
1800
1801template <class _CharT, class _Traits>
1802void __word_boundary<_CharT, _Traits>::__exec(__state& __s) const {
1803 bool __is_word_b = false;
1804 if (__s.__first_ != __s.__last_) {
1805 if (__s.__current_ == __s.__last_) {
1806 if (!(__s.__flags_ & regex_constants::match_not_eow)) {
1807 _CharT __c = __s.__current_[-1];
1808 __is_word_b = __c == '_' || __traits_.isctype(__c, ctype_base::alnum);
1809 }
1810 } else if (__s.__current_ == __s.__first_ && !(__s.__flags_ & regex_constants::match_prev_avail)) {
1811 if (!(__s.__flags_ & regex_constants::match_not_bow)) {
1812 _CharT __c = *__s.__current_;
1813 __is_word_b = __c == '_' || __traits_.isctype(__c, ctype_base::alnum);
1814 }
1815 } else {
1816 _CharT __c1 = __s.__current_[-1];
1817 _CharT __c2 = *__s.__current_;
1818 bool __is_c1_b = __c1 == '_' || __traits_.isctype(__c1, ctype_base::alnum);
1819 bool __is_c2_b = __c2 == '_' || __traits_.isctype(__c2, ctype_base::alnum);
1820 __is_word_b = __is_c1_b != __is_c2_b;
1821 }
1822 }
1823 if (__is_word_b != __invert_) {
1824 __s.__do_ = __state::__accept_but_not_consume;
1825 __s.__node_ = this->first();
1826 } else {
1827 __s.__do_ = __state::__reject;
1828 __s.__node_ = nullptr;
1829 }
1830}
1831
1832// __l_anchor
1833
1834template <class _CharT>
1835_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool __is_eol(_CharT __c) {
1836 return __c == '\r' || __c == '\n';
1837}
1838
1839template <class _CharT>
1840class __l_anchor_multiline : public __owns_one_state<_CharT> {
1841 typedef __owns_one_state<_CharT> base;
1842
1843 bool __multiline_;
1844
1845public:
1846 typedef std::__state<_CharT> __state;
1847
1848 _LIBCPP_HIDE_FROM_ABI __l_anchor_multiline(bool __multiline, __node<_CharT>* __s)
1849 : base(__s), __multiline_(__multiline) {}
1850
1851 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
1852};
1853
1854template <class _CharT>
1855void __l_anchor_multiline<_CharT>::__exec(__state& __s) const {
1856 if (__s.__at_first_ && __s.__current_ == __s.__first_ && !(__s.__flags_ & regex_constants::match_not_bol)) {
1857 __s.__do_ = __state::__accept_but_not_consume;
1858 __s.__node_ = this->first();
1859 } else if (__multiline_ && !__s.__at_first_ && std::__is_eol(*std::prev(__s.__current_))) {
1860 __s.__do_ = __state::__accept_but_not_consume;
1861 __s.__node_ = this->first();
1862 } else {
1863 __s.__do_ = __state::__reject;
1864 __s.__node_ = nullptr;
1865 }
1866}
1867
1868// __r_anchor
1869
1870template <class _CharT>
1871class __r_anchor_multiline : public __owns_one_state<_CharT> {
1872 typedef __owns_one_state<_CharT> base;
1873
1874 bool __multiline_;
1875
1876public:
1877 typedef std::__state<_CharT> __state;
1878
1879 _LIBCPP_HIDE_FROM_ABI __r_anchor_multiline(bool __multiline, __node<_CharT>* __s)
1880 : base(__s), __multiline_(__multiline) {}
1881
1882 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
1883};
1884
1885template <class _CharT>
1886void __r_anchor_multiline<_CharT>::__exec(__state& __s) const {
1887 if (__s.__current_ == __s.__last_ && !(__s.__flags_ & regex_constants::match_not_eol)) {
1888 __s.__do_ = __state::__accept_but_not_consume;
1889 __s.__node_ = this->first();
1890 } else if (__multiline_ && std::__is_eol(*__s.__current_)) {
1891 __s.__do_ = __state::__accept_but_not_consume;
1892 __s.__node_ = this->first();
1893 } else {
1894 __s.__do_ = __state::__reject;
1895 __s.__node_ = nullptr;
1896 }
1897}
1898
1899// __match_any
1900
1901template <class _CharT>
1902class __match_any : public __owns_one_state<_CharT> {
1903 typedef __owns_one_state<_CharT> base;
1904
1905public:
1906 typedef std::__state<_CharT> __state;
1907
1908 _LIBCPP_HIDE_FROM_ABI __match_any(__node<_CharT>* __s) : base(__s) {}
1909
1910 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
1911};
1912
1913template <class _CharT>
1914void __match_any<_CharT>::__exec(__state& __s) const {
1915 if (__s.__current_ != __s.__last_ && *__s.__current_ != 0) {
1916 __s.__do_ = __state::__accept_and_consume;
1917 ++__s.__current_;
1918 __s.__node_ = this->first();
1919 } else {
1920 __s.__do_ = __state::__reject;
1921 __s.__node_ = nullptr;
1922 }
1923}
1924
1925// __match_any_but_newline
1926
1927template <class _CharT>
1928class __match_any_but_newline : public __owns_one_state<_CharT> {
1929 typedef __owns_one_state<_CharT> base;
1930
1931public:
1932 typedef std::__state<_CharT> __state;
1933
1934 _LIBCPP_HIDE_FROM_ABI __match_any_but_newline(__node<_CharT>* __s) : base(__s) {}
1935
1936 void __exec(__state&) const override;
1937};
1938
1939template <>
1940_LIBCPP_EXPORTED_FROM_ABI void __match_any_but_newline<char>::__exec(__state&) const;
1941#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
1942template <>
1943_LIBCPP_EXPORTED_FROM_ABI void __match_any_but_newline<wchar_t>::__exec(__state&) const;
1944#endif
1945
1946// __match_char
1947
1948template <class _CharT>
1949class __match_char : public __owns_one_state<_CharT> {
1950 typedef __owns_one_state<_CharT> base;
1951
1952 _CharT __c_;
1953
1954public:
1955 typedef std::__state<_CharT> __state;
1956
1957 _LIBCPP_HIDE_FROM_ABI __match_char(_CharT __c, __node<_CharT>* __s) : base(__s), __c_(__c) {}
1958
1959 __match_char(const __match_char&) = delete;
1960 __match_char& operator=(const __match_char&) = delete;
1961
1962 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
1963};
1964
1965template <class _CharT>
1966void __match_char<_CharT>::__exec(__state& __s) const {
1967 if (__s.__current_ != __s.__last_ && *__s.__current_ == __c_) {
1968 __s.__do_ = __state::__accept_and_consume;
1969 ++__s.__current_;
1970 __s.__node_ = this->first();
1971 } else {
1972 __s.__do_ = __state::__reject;
1973 __s.__node_ = nullptr;
1974 }
1975}
1976
1977// __match_char_icase
1978
1979template <class _CharT, class _Traits>
1980class __match_char_icase : public __owns_one_state<_CharT> {
1981 typedef __owns_one_state<_CharT> base;
1982
1983 _Traits __traits_;
1984 _CharT __c_;
1985
1986public:
1987 typedef std::__state<_CharT> __state;
1988
1989 _LIBCPP_HIDE_FROM_ABI __match_char_icase(const _Traits& __traits, _CharT __c, __node<_CharT>* __s)
1990 : base(__s), __traits_(__traits), __c_(__traits.translate_nocase(__c)) {}
1991
1992 __match_char_icase(const __match_char_icase&) = delete;
1993 __match_char_icase& operator=(const __match_char_icase&) = delete;
1994
1995 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
1996};
1997
1998template <class _CharT, class _Traits>
1999void __match_char_icase<_CharT, _Traits>::__exec(__state& __s) const {
2000 if (__s.__current_ != __s.__last_ && __traits_.translate_nocase(*__s.__current_) == __c_) {
2001 __s.__do_ = __state::__accept_and_consume;
2002 ++__s.__current_;
2003 __s.__node_ = this->first();
2004 } else {
2005 __s.__do_ = __state::__reject;
2006 __s.__node_ = nullptr;
2007 }
2008}
2009
2010// __match_char_collate
2011
2012template <class _CharT, class _Traits>
2013class __match_char_collate : public __owns_one_state<_CharT> {
2014 typedef __owns_one_state<_CharT> base;
2015
2016 _Traits __traits_;
2017 _CharT __c_;
2018
2019public:
2020 typedef std::__state<_CharT> __state;
2021
2022 _LIBCPP_HIDE_FROM_ABI __match_char_collate(const _Traits& __traits, _CharT __c, __node<_CharT>* __s)
2023 : base(__s), __traits_(__traits), __c_(__traits.translate(__c)) {}
2024
2025 __match_char_collate(const __match_char_collate&) = delete;
2026 __match_char_collate& operator=(const __match_char_collate&) = delete;
2027
2028 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
2029};
2030
2031template <class _CharT, class _Traits>
2032void __match_char_collate<_CharT, _Traits>::__exec(__state& __s) const {
2033 if (__s.__current_ != __s.__last_ && __traits_.translate(*__s.__current_) == __c_) {
2034 __s.__do_ = __state::__accept_and_consume;
2035 ++__s.__current_;
2036 __s.__node_ = this->first();
2037 } else {
2038 __s.__do_ = __state::__reject;
2039 __s.__node_ = nullptr;
2040 }
2041}
2042
2043// __bracket_expression
2044
2045template <class _CharT, class _Traits>
2046class __bracket_expression : public __owns_one_state<_CharT> {
2047 typedef __owns_one_state<_CharT> base;
2048 typedef typename _Traits::string_type string_type;
2049
2050 _Traits __traits_;
2051 vector<_CharT> __chars_;
2052 vector<_CharT> __neg_chars_;
2053 vector<pair<string_type, string_type> > __ranges_;
2054 vector<pair<_CharT, _CharT> > __digraphs_;
2055 vector<string_type> __equivalences_;
2056 typename regex_traits<_CharT>::char_class_type __mask_;
2057 typename regex_traits<_CharT>::char_class_type __neg_mask_;
2058 bool __negate_;
2059 bool __icase_;
2060 bool __collate_;
2061 bool __might_have_digraph_;
2062
2063public:
2064 typedef std::__state<_CharT> __state;
2065
2066 _LIBCPP_HIDE_FROM_ABI
2067 __bracket_expression(const _Traits& __traits, __node<_CharT>* __s, bool __negate, bool __icase, bool __collate)
2068 : base(__s),
2069 __traits_(__traits),
2070 __mask_(),
2071 __neg_mask_(),
2072 __negate_(__negate),
2073 __icase_(__icase),
2074 __collate_(__collate),
2075 __might_have_digraph_(__traits_.getloc().name() != "C") {}
2076
2077 __bracket_expression(const __bracket_expression&) = delete;
2078 __bracket_expression& operator=(const __bracket_expression&) = delete;
2079
2080 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
2081
2082 _LIBCPP_HIDE_FROM_ABI bool __negated() const { return __negate_; }
2083
2084 _LIBCPP_HIDE_FROM_ABI void __add_char(_CharT __c) {
2085 if (__icase_)
2086 __chars_.push_back(__traits_.translate_nocase(__c));
2087 else if (__collate_)
2088 __chars_.push_back(__traits_.translate(__c));
2089 else
2090 __chars_.push_back(__c);
2091 }
2092 _LIBCPP_HIDE_FROM_ABI void __add_neg_char(_CharT __c) {
2093 if (__icase_)
2094 __neg_chars_.push_back(__traits_.translate_nocase(__c));
2095 else if (__collate_)
2096 __neg_chars_.push_back(__traits_.translate(__c));
2097 else
2098 __neg_chars_.push_back(__c);
2099 }
2100 _LIBCPP_HIDE_FROM_ABI void __add_range(string_type __b, string_type __e) {
2101 if (__collate_) {
2102 if (__icase_) {
2103 for (size_t __i = 0; __i < __b.size(); ++__i)
2104 __b[__i] = __traits_.translate_nocase(__b[__i]);
2105 for (size_t __i = 0; __i < __e.size(); ++__i)
2106 __e[__i] = __traits_.translate_nocase(__e[__i]);
2107 } else {
2108 for (size_t __i = 0; __i < __b.size(); ++__i)
2109 __b[__i] = __traits_.translate(__b[__i]);
2110 for (size_t __i = 0; __i < __e.size(); ++__i)
2111 __e[__i] = __traits_.translate(__e[__i]);
2112 }
2113 __ranges_.push_back(
2114 std::make_pair(__traits_.transform(__b.begin(), __b.end()), __traits_.transform(__e.begin(), __e.end())));
2115 } else {
2116 if (__b.size() != 1 || __e.size() != 1)
2117 __throw_regex_error<regex_constants::error_range>();
2118 if (__icase_) {
2119 __b[0] = __traits_.translate_nocase(__b[0]);
2120 __e[0] = __traits_.translate_nocase(__e[0]);
2121 }
2122 __ranges_.push_back(std::make_pair(std::move(__b), std::move(__e)));
2123 }
2124 }
2125 _LIBCPP_HIDE_FROM_ABI void __add_digraph(_CharT __c1, _CharT __c2) {
2126 if (__icase_)
2127 __digraphs_.push_back(std::make_pair(__traits_.translate_nocase(__c1), __traits_.translate_nocase(__c2)));
2128 else if (__collate_)
2129 __digraphs_.push_back(std::make_pair(__traits_.translate(__c1), __traits_.translate(__c2)));
2130 else
2131 __digraphs_.push_back(std::make_pair(__c1, __c2));
2132 }
2133 _LIBCPP_HIDE_FROM_ABI void __add_equivalence(const string_type& __s) { __equivalences_.push_back(__s); }
2134 _LIBCPP_HIDE_FROM_ABI void __add_class(typename regex_traits<_CharT>::char_class_type __mask) { __mask_ |= __mask; }
2135 _LIBCPP_HIDE_FROM_ABI void __add_neg_class(typename regex_traits<_CharT>::char_class_type __mask) {
2136 __neg_mask_ |= __mask;
2137 }
2138};
2139
2140template <class _CharT, class _Traits>
2141void __bracket_expression<_CharT, _Traits>::__exec(__state& __s) const {
2142 bool __found = false;
2143 unsigned __consumed = 0;
2144 if (__s.__current_ != __s.__last_) {
2145 ++__consumed;
2146 if (__might_have_digraph_) {
2147 const _CharT* __next = std::next(__s.__current_);
2148 if (__next != __s.__last_) {
2149 pair<_CharT, _CharT> __ch2(*__s.__current_, *__next);
2150 if (__icase_) {
2151 __ch2.first = __traits_.translate_nocase(__ch2.first);
2152 __ch2.second = __traits_.translate_nocase(__ch2.second);
2153 } else if (__collate_) {
2154 __ch2.first = __traits_.translate(__ch2.first);
2155 __ch2.second = __traits_.translate(__ch2.second);
2156 }
2157 if (!__traits_.lookup_collatename(&__ch2.first, &__ch2.first + 2).empty()) {
2158 // __ch2 is a digraph in this locale
2159 ++__consumed;
2160 for (size_t __i = 0; __i < __digraphs_.size(); ++__i) {
2161 if (__ch2 == __digraphs_[__i]) {
2162 __found = true;
2163 goto __exit;
2164 }
2165 }
2166 if (__collate_ && !__ranges_.empty()) {
2167 string_type __s2 = __traits_.transform(&__ch2.first, &__ch2.first + 2);
2168 for (size_t __i = 0; __i < __ranges_.size(); ++__i) {
2169 if (__ranges_[__i].first <= __s2 && __s2 <= __ranges_[__i].second) {
2170 __found = true;
2171 goto __exit;
2172 }
2173 }
2174 }
2175 if (!__equivalences_.empty()) {
2176 string_type __s2 = __traits_.transform_primary(&__ch2.first, &__ch2.first + 2);
2177 for (size_t __i = 0; __i < __equivalences_.size(); ++__i) {
2178 if (__s2 == __equivalences_[__i]) {
2179 __found = true;
2180 goto __exit;
2181 }
2182 }
2183 }
2184 if (__traits_.isctype(__ch2.first, __mask_) && __traits_.isctype(__ch2.second, __mask_)) {
2185 __found = true;
2186 goto __exit;
2187 }
2188 if (!__traits_.isctype(__ch2.first, __neg_mask_) && !__traits_.isctype(__ch2.second, __neg_mask_)) {
2189 __found = true;
2190 goto __exit;
2191 }
2192 goto __exit;
2193 }
2194 }
2195 }
2196 // test *__s.__current_ as not a digraph
2197 _CharT __ch = *__s.__current_;
2198 if (__icase_)
2199 __ch = __traits_.translate_nocase(__ch);
2200 else if (__collate_)
2201 __ch = __traits_.translate(__ch);
2202 for (size_t __i = 0; __i < __chars_.size(); ++__i) {
2203 if (__ch == __chars_[__i]) {
2204 __found = true;
2205 goto __exit;
2206 }
2207 }
2208 // When there's at least one of __neg_chars_ and __neg_mask_, the set
2209 // of "__found" chars is
2210 // union(complement(union(__neg_chars_, __neg_mask_)),
2211 // other cases...)
2212 //
2213 // It doesn't make sense to check this when there are no __neg_chars_
2214 // and no __neg_mask_.
2215 if (!(__neg_mask_ == 0 && __neg_chars_.empty())) {
2216 const bool __in_neg_mask = __traits_.isctype(__ch, __neg_mask_);
2217 const bool __in_neg_chars = std::find(__neg_chars_.begin(), __neg_chars_.end(), __ch) != __neg_chars_.end();
2218 if (!(__in_neg_mask || __in_neg_chars)) {
2219 __found = true;
2220 goto __exit;
2221 }
2222 }
2223 if (!__ranges_.empty()) {
2224 string_type __s2 = __collate_ ? __traits_.transform(&__ch, &__ch + 1) : string_type(1, __ch);
2225 for (size_t __i = 0; __i < __ranges_.size(); ++__i) {
2226 if (__ranges_[__i].first <= __s2 && __s2 <= __ranges_[__i].second) {
2227 __found = true;
2228 goto __exit;
2229 }
2230 }
2231 }
2232 if (!__equivalences_.empty()) {
2233 string_type __s2 = __traits_.transform_primary(&__ch, &__ch + 1);
2234 for (size_t __i = 0; __i < __equivalences_.size(); ++__i) {
2235 if (__s2 == __equivalences_[__i]) {
2236 __found = true;
2237 goto __exit;
2238 }
2239 }
2240 }
2241 if (__traits_.isctype(__ch, __mask_)) {
2242 __found = true;
2243 goto __exit;
2244 }
2245 } else
2246 __found = __negate_; // force reject
2247__exit:
2248 if (__found != __negate_) {
2249 __s.__do_ = __state::__accept_and_consume;
2250 __s.__current_ += __consumed;
2251 __s.__node_ = this->first();
2252 } else {
2253 __s.__do_ = __state::__reject;
2254 __s.__node_ = nullptr;
2255 }
2256}
2257
2258template <class _CharT, class _Traits>
2259class __lookahead;
2260
2261template <class _CharT, class _Traits = regex_traits<_CharT> >
2262class _LIBCPP_TEMPLATE_VIS basic_regex;
2263
2264typedef basic_regex<char> regex;
2265#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
2266typedef basic_regex<wchar_t> wregex;
2267#endif
2268
2269template <class _CharT, class _Traits>
2270class _LIBCPP_TEMPLATE_VIS _LIBCPP_PREFERRED_NAME(regex)
2271 _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wregex)) basic_regex {
2272public:
2273 // types:
2274 typedef _CharT value_type;
2275 typedef _Traits traits_type;
2276 typedef typename _Traits::string_type string_type;
2277 typedef regex_constants::syntax_option_type flag_type;
2278 typedef typename _Traits::locale_type locale_type;
2279
2280private:
2281 _Traits __traits_;
2282 flag_type __flags_;
2283 unsigned __marked_count_;
2284 unsigned __loop_count_;
2285 int __open_count_;
2286 shared_ptr<__empty_state<_CharT> > __start_;
2287 __owns_one_state<_CharT>* __end_;
2288
2289 typedef std::__state<_CharT> __state;
2290 typedef std::__node<_CharT> __node;
2291
2292public:
2293 // constants:
2294 static const regex_constants::syntax_option_type icase = regex_constants::icase;
2295 static const regex_constants::syntax_option_type nosubs = regex_constants::nosubs;
2296 static const regex_constants::syntax_option_type optimize = regex_constants::optimize;
2297 static const regex_constants::syntax_option_type collate = regex_constants::collate;
2298 static const regex_constants::syntax_option_type ECMAScript = regex_constants::ECMAScript;
2299 static const regex_constants::syntax_option_type basic = regex_constants::basic;
2300 static const regex_constants::syntax_option_type extended = regex_constants::extended;
2301 static const regex_constants::syntax_option_type awk = regex_constants::awk;
2302 static const regex_constants::syntax_option_type grep = regex_constants::grep;
2303 static const regex_constants::syntax_option_type egrep = regex_constants::egrep;
2304 static const regex_constants::syntax_option_type multiline = regex_constants::multiline;
2305
2306 // construct/copy/destroy:
2307 _LIBCPP_HIDE_FROM_ABI basic_regex()
2308 : __flags_(regex_constants::ECMAScript),
2309 __marked_count_(0),
2310 __loop_count_(0),
2311 __open_count_(0),
2312 __end_(nullptr) {}
2313 _LIBCPP_HIDE_FROM_ABI explicit basic_regex(const value_type* __p, flag_type __f = regex_constants::ECMAScript)
2314 : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0), __end_(nullptr) {
2315 __init(__p, __p + __traits_.length(__p));
2316 }
2317
2318 _LIBCPP_HIDE_FROM_ABI basic_regex(const value_type* __p, size_t __len, flag_type __f = regex_constants::ECMAScript)
2319 : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0), __end_(nullptr) {
2320 __init(__p, __p + __len);
2321 }
2322
2323 // basic_regex(const basic_regex&) = default;
2324 // basic_regex(basic_regex&&) = default;
2325 template <class _ST, class _SA>
2326 _LIBCPP_HIDE_FROM_ABI explicit basic_regex(const basic_string<value_type, _ST, _SA>& __p,
2327 flag_type __f = regex_constants::ECMAScript)
2328 : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0), __end_(nullptr) {
2329 __init(__p.begin(), __p.end());
2330 }
2331
2332 template <class _ForwardIterator>
2333 _LIBCPP_HIDE_FROM_ABI
2334 basic_regex(_ForwardIterator __first, _ForwardIterator __last, flag_type __f = regex_constants::ECMAScript)
2335 : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0), __end_(nullptr) {
2336 __init(__first, __last);
2337 }
2338#ifndef _LIBCPP_CXX03_LANG
2339 _LIBCPP_HIDE_FROM_ABI basic_regex(initializer_list<value_type> __il, flag_type __f = regex_constants::ECMAScript)
2340 : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0), __end_(nullptr) {
2341 __init(__il.begin(), __il.end());
2342 }
2343#endif // _LIBCPP_CXX03_LANG
2344
2345 // ~basic_regex() = default;
2346
2347 // basic_regex& operator=(const basic_regex&) = default;
2348 // basic_regex& operator=(basic_regex&&) = default;
2349 _LIBCPP_HIDE_FROM_ABI basic_regex& operator=(const value_type* __p) { return assign(__p); }
2350#ifndef _LIBCPP_CXX03_LANG
2351 _LIBCPP_HIDE_FROM_ABI basic_regex& operator=(initializer_list<value_type> __il) { return assign(__il); }
2352#endif // _LIBCPP_CXX03_LANG
2353 template <class _ST, class _SA>
2354 _LIBCPP_HIDE_FROM_ABI basic_regex& operator=(const basic_string<value_type, _ST, _SA>& __p) {
2355 return assign(__p);
2356 }
2357
2358 // assign:
2359 _LIBCPP_HIDE_FROM_ABI basic_regex& assign(const basic_regex& __that) { return *this = __that; }
2360#ifndef _LIBCPP_CXX03_LANG
2361 _LIBCPP_HIDE_FROM_ABI basic_regex& assign(basic_regex&& __that) _NOEXCEPT { return *this = std::move(__that); }
2362#endif
2363 _LIBCPP_HIDE_FROM_ABI basic_regex& assign(const value_type* __p, flag_type __f = regex_constants::ECMAScript) {
2364 return assign(__p, __p + __traits_.length(__p), __f);
2365 }
2366 _LIBCPP_HIDE_FROM_ABI basic_regex&
2367 assign(const value_type* __p, size_t __len, flag_type __f = regex_constants::ECMAScript) {
2368 return assign(__p, __p + __len, __f);
2369 }
2370 template <class _ST, class _SA>
2371 _LIBCPP_HIDE_FROM_ABI basic_regex&
2372 assign(const basic_string<value_type, _ST, _SA>& __s, flag_type __f = regex_constants::ECMAScript) {
2373 return assign(__s.begin(), __s.end(), __f);
2374 }
2375
2376 template <class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value, int> = 0>
2377 _LIBCPP_HIDE_FROM_ABI basic_regex&
2378 assign(_InputIterator __first, _InputIterator __last, flag_type __f = regex_constants::ECMAScript) {
2379 basic_string<_CharT> __t(__first, __last);
2380 return assign(__t.begin(), __t.end(), __f);
2381 }
2382
2383private:
2384 _LIBCPP_HIDE_FROM_ABI void __member_init(flag_type __f) {
2385 __flags_ = __f;
2386 __marked_count_ = 0;
2387 __loop_count_ = 0;
2388 __open_count_ = 0;
2389 __end_ = nullptr;
2390 }
2391
2392public:
2393 template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> = 0>
2394 _LIBCPP_HIDE_FROM_ABI basic_regex&
2395 assign(_ForwardIterator __first, _ForwardIterator __last, flag_type __f = regex_constants::ECMAScript) {
2396 return assign(basic_regex(__first, __last, __f));
2397 }
2398
2399#ifndef _LIBCPP_CXX03_LANG
2400
2401 _LIBCPP_HIDE_FROM_ABI basic_regex&
2402 assign(initializer_list<value_type> __il, flag_type __f = regex_constants::ECMAScript) {
2403 return assign(__il.begin(), __il.end(), __f);
2404 }
2405
2406#endif // _LIBCPP_CXX03_LANG
2407
2408 // const operations:
2409 _LIBCPP_HIDE_FROM_ABI unsigned mark_count() const { return __marked_count_; }
2410 _LIBCPP_HIDE_FROM_ABI flag_type flags() const { return __flags_; }
2411
2412 // locale:
2413 _LIBCPP_HIDE_FROM_ABI locale_type imbue(locale_type __loc) {
2414 __member_init(ECMAScript);
2415 __start_.reset();
2416 return __traits_.imbue(__loc);
2417 }
2418 _LIBCPP_HIDE_FROM_ABI locale_type getloc() const { return __traits_.getloc(); }
2419
2420 // swap:
2421 void swap(basic_regex& __r);
2422
2423private:
2424 _LIBCPP_HIDE_FROM_ABI unsigned __loop_count() const { return __loop_count_; }
2425
2426 _LIBCPP_HIDE_FROM_ABI bool __use_multiline() const {
2427 return __get_grammar(__flags_) == ECMAScript && (__flags_ & multiline);
2428 }
2429
2430 template <class _ForwardIterator>
2431 void __init(_ForwardIterator __first, _ForwardIterator __last);
2432 template <class _ForwardIterator>
2433 _ForwardIterator __parse(_ForwardIterator __first, _ForwardIterator __last);
2434 template <class _ForwardIterator>
2435 _ForwardIterator __parse_basic_reg_exp(_ForwardIterator __first, _ForwardIterator __last);
2436 template <class _ForwardIterator>
2437 _ForwardIterator __parse_RE_expression(_ForwardIterator __first, _ForwardIterator __last);
2438 template <class _ForwardIterator>
2439 _ForwardIterator __parse_simple_RE(_ForwardIterator __first, _ForwardIterator __last);
2440 template <class _ForwardIterator>
2441 _ForwardIterator __parse_nondupl_RE(_ForwardIterator __first, _ForwardIterator __last);
2442 template <class _ForwardIterator>
2443 _ForwardIterator __parse_one_char_or_coll_elem_RE(_ForwardIterator __first, _ForwardIterator __last);
2444 template <class _ForwardIterator>
2445 _ForwardIterator __parse_Back_open_paren(_ForwardIterator __first, _ForwardIterator __last);
2446 template <class _ForwardIterator>
2447 _ForwardIterator __parse_Back_close_paren(_ForwardIterator __first, _ForwardIterator __last);
2448 template <class _ForwardIterator>
2449 _ForwardIterator __parse_Back_open_brace(_ForwardIterator __first, _ForwardIterator __last);
2450 template <class _ForwardIterator>
2451 _ForwardIterator __parse_Back_close_brace(_ForwardIterator __first, _ForwardIterator __last);
2452 template <class _ForwardIterator>
2453 _ForwardIterator __parse_BACKREF(_ForwardIterator __first, _ForwardIterator __last);
2454 template <class _ForwardIterator>
2455 _ForwardIterator __parse_ORD_CHAR(_ForwardIterator __first, _ForwardIterator __last);
2456 template <class _ForwardIterator>
2457 _ForwardIterator __parse_QUOTED_CHAR(_ForwardIterator __first, _ForwardIterator __last);
2458 template <class _ForwardIterator>
2459 _ForwardIterator __parse_RE_dupl_symbol(
2460 _ForwardIterator __first,
2461 _ForwardIterator __last,
2462 __owns_one_state<_CharT>* __s,
2463 unsigned __mexp_begin,
2464 unsigned __mexp_end);
2465 template <class _ForwardIterator>
2466 _ForwardIterator __parse_ERE_dupl_symbol(
2467 _ForwardIterator __first,
2468 _ForwardIterator __last,
2469 __owns_one_state<_CharT>* __s,
2470 unsigned __mexp_begin,
2471 unsigned __mexp_end);
2472 template <class _ForwardIterator>
2473 _ForwardIterator __parse_bracket_expression(_ForwardIterator __first, _ForwardIterator __last);
2474 template <class _ForwardIterator>
2475 _ForwardIterator
2476 __parse_follow_list(_ForwardIterator __first, _ForwardIterator __last, __bracket_expression<_CharT, _Traits>* __ml);
2477 template <class _ForwardIterator>
2478 _ForwardIterator __parse_expression_term(
2479 _ForwardIterator __first, _ForwardIterator __last, __bracket_expression<_CharT, _Traits>* __ml);
2480 template <class _ForwardIterator>
2481 _ForwardIterator __parse_equivalence_class(
2482 _ForwardIterator __first, _ForwardIterator __last, __bracket_expression<_CharT, _Traits>* __ml);
2483 template <class _ForwardIterator>
2484 _ForwardIterator __parse_character_class(
2485 _ForwardIterator __first, _ForwardIterator __last, __bracket_expression<_CharT, _Traits>* __ml);
2486 template <class _ForwardIterator>
2487 _ForwardIterator
2488 __parse_collating_symbol(_ForwardIterator __first, _ForwardIterator __last, basic_string<_CharT>& __col_sym);
2489 template <class _ForwardIterator>
2490 _ForwardIterator __parse_DUP_COUNT(_ForwardIterator __first, _ForwardIterator __last, int& __c);
2491 template <class _ForwardIterator>
2492 _ForwardIterator __parse_extended_reg_exp(_ForwardIterator __first, _ForwardIterator __last);
2493 template <class _ForwardIterator>
2494 _ForwardIterator __parse_ERE_branch(_ForwardIterator __first, _ForwardIterator __last);
2495 template <class _ForwardIterator>
2496 _ForwardIterator __parse_ERE_expression(_ForwardIterator __first, _ForwardIterator __last);
2497 template <class _ForwardIterator>
2498 _ForwardIterator __parse_one_char_or_coll_elem_ERE(_ForwardIterator __first, _ForwardIterator __last);
2499 template <class _ForwardIterator>
2500 _ForwardIterator __parse_ORD_CHAR_ERE(_ForwardIterator __first, _ForwardIterator __last);
2501 template <class _ForwardIterator>
2502 _ForwardIterator __parse_QUOTED_CHAR_ERE(_ForwardIterator __first, _ForwardIterator __last);
2503 template <class _ForwardIterator>
2504 _ForwardIterator __parse_ecma_exp(_ForwardIterator __first, _ForwardIterator __last);
2505 template <class _ForwardIterator>
2506 _ForwardIterator __parse_alternative(_ForwardIterator __first, _ForwardIterator __last);
2507 template <class _ForwardIterator>
2508 _ForwardIterator __parse_term(_ForwardIterator __first, _ForwardIterator __last);
2509 template <class _ForwardIterator>
2510 _ForwardIterator __parse_assertion(_ForwardIterator __first, _ForwardIterator __last);
2511 template <class _ForwardIterator>
2512 _ForwardIterator __parse_atom(_ForwardIterator __first, _ForwardIterator __last);
2513 template <class _ForwardIterator>
2514 _ForwardIterator __parse_atom_escape(_ForwardIterator __first, _ForwardIterator __last);
2515 template <class _ForwardIterator>
2516 _ForwardIterator __parse_decimal_escape(_ForwardIterator __first, _ForwardIterator __last);
2517 template <class _ForwardIterator>
2518 _ForwardIterator __parse_character_class_escape(_ForwardIterator __first, _ForwardIterator __last);
2519 template <class _ForwardIterator>
2520 _ForwardIterator
2521 __parse_character_escape(_ForwardIterator __first, _ForwardIterator __last, basic_string<_CharT>* __str = nullptr);
2522 template <class _ForwardIterator>
2523 _ForwardIterator __parse_pattern_character(_ForwardIterator __first, _ForwardIterator __last);
2524 template <class _ForwardIterator>
2525 _ForwardIterator __parse_grep(_ForwardIterator __first, _ForwardIterator __last);
2526 template <class _ForwardIterator>
2527 _ForwardIterator __parse_egrep(_ForwardIterator __first, _ForwardIterator __last);
2528 template <class _ForwardIterator>
2529 _ForwardIterator __parse_class_escape(
2530 _ForwardIterator __first,
2531 _ForwardIterator __last,
2532 basic_string<_CharT>& __str,
2533 __bracket_expression<_CharT, _Traits>* __ml);
2534 template <class _ForwardIterator>
2535 _ForwardIterator
2536 __parse_awk_escape(_ForwardIterator __first, _ForwardIterator __last, basic_string<_CharT>* __str = nullptr);
2537
2538 bool __test_back_ref(_CharT);
2539
2540 _LIBCPP_HIDE_FROM_ABI void __push_l_anchor();
2541 void __push_r_anchor();
2542 void __push_match_any();
2543 void __push_match_any_but_newline();
2544 _LIBCPP_HIDE_FROM_ABI void __push_greedy_inf_repeat(
2545 size_t __min, __owns_one_state<_CharT>* __s, unsigned __mexp_begin = 0, unsigned __mexp_end = 0) {
2546 __push_loop(__min, numeric_limits<size_t>::max(), __s, __mexp_begin, __mexp_end);
2547 }
2548 _LIBCPP_HIDE_FROM_ABI void __push_nongreedy_inf_repeat(
2549 size_t __min, __owns_one_state<_CharT>* __s, unsigned __mexp_begin = 0, unsigned __mexp_end = 0) {
2550 __push_loop(__min, numeric_limits<size_t>::max(), __s, __mexp_begin, __mexp_end, false);
2551 }
2552 void __push_loop(size_t __min,
2553 size_t __max,
2554 __owns_one_state<_CharT>* __s,
2555 size_t __mexp_begin = 0,
2556 size_t __mexp_end = 0,
2557 bool __greedy = true);
2558 __bracket_expression<_CharT, _Traits>* __start_matching_list(bool __negate);
2559 void __push_char(value_type __c);
2560 void __push_back_ref(int __i);
2561 void __push_alternation(__owns_one_state<_CharT>* __sa, __owns_one_state<_CharT>* __sb);
2562 void __push_begin_marked_subexpression();
2563 void __push_end_marked_subexpression(unsigned);
2564 void __push_empty();
2565 void __push_word_boundary(bool);
2566 void __push_lookahead(const basic_regex&, bool, unsigned);
2567
2568 template <class _Allocator>
2569 bool __search(const _CharT* __first,
2570 const _CharT* __last,
2571 match_results<const _CharT*, _Allocator>& __m,
2572 regex_constants::match_flag_type __flags) const;
2573
2574 template <class _Allocator>
2575 bool __match_at_start(const _CharT* __first,
2576 const _CharT* __last,
2577 match_results<const _CharT*, _Allocator>& __m,
2578 regex_constants::match_flag_type __flags,
2579 bool) const;
2580 template <class _Allocator>
2581 bool __match_at_start_ecma(
2582 const _CharT* __first,
2583 const _CharT* __last,
2584 match_results<const _CharT*, _Allocator>& __m,
2585 regex_constants::match_flag_type __flags,
2586 bool) const;
2587 template <class _Allocator>
2588 bool __match_at_start_posix_nosubs(
2589 const _CharT* __first,
2590 const _CharT* __last,
2591 match_results<const _CharT*, _Allocator>& __m,
2592 regex_constants::match_flag_type __flags,
2593 bool) const;
2594 template <class _Allocator>
2595 bool __match_at_start_posix_subs(
2596 const _CharT* __first,
2597 const _CharT* __last,
2598 match_results<const _CharT*, _Allocator>& __m,
2599 regex_constants::match_flag_type __flags,
2600 bool) const;
2601
2602 template <class _Bp, class _Ap, class _Cp, class _Tp>
2603 friend bool
2604 regex_search(_Bp, _Bp, match_results<_Bp, _Ap>&, const basic_regex<_Cp, _Tp>&, regex_constants::match_flag_type);
2605
2606 template <class _Ap, class _Cp, class _Tp>
2607 friend bool
2608 regex_search(const _Cp*,
2609 const _Cp*,
2610 match_results<const _Cp*, _Ap>&,
2611 const basic_regex<_Cp, _Tp>&,
2612 regex_constants::match_flag_type);
2613
2614 template <class _Bp, class _Cp, class _Tp>
2615 friend bool regex_search(_Bp, _Bp, const basic_regex<_Cp, _Tp>&, regex_constants::match_flag_type);
2616
2617 template <class _Cp, class _Tp>
2618 friend bool regex_search(const _Cp*, const _Cp*, const basic_regex<_Cp, _Tp>&, regex_constants::match_flag_type);
2619
2620 template <class _Cp, class _Ap, class _Tp>
2621 friend bool regex_search(
2622 const _Cp*, match_results<const _Cp*, _Ap>&, const basic_regex<_Cp, _Tp>&, regex_constants::match_flag_type);
2623
2624 template <class _ST, class _SA, class _Cp, class _Tp>
2625 friend bool regex_search(const basic_string<_Cp, _ST, _SA>& __s,
2626 const basic_regex<_Cp, _Tp>& __e,
2627 regex_constants::match_flag_type __flags);
2628
2629 template <class _ST, class _SA, class _Ap, class _Cp, class _Tp>
2630 friend bool regex_search(const basic_string<_Cp, _ST, _SA>& __s,
2631 match_results<typename basic_string<_Cp, _ST, _SA>::const_iterator, _Ap>&,
2632 const basic_regex<_Cp, _Tp>& __e,
2633 regex_constants::match_flag_type __flags);
2634
2635 template <class _Iter, class _Ap, class _Cp, class _Tp>
2636 friend bool
2637 regex_search(__wrap_iter<_Iter> __first,
2638 __wrap_iter<_Iter> __last,
2639 match_results<__wrap_iter<_Iter>, _Ap>& __m,
2640 const basic_regex<_Cp, _Tp>& __e,
2641 regex_constants::match_flag_type __flags);
2642
2643 template <class, class>
2644 friend class __lookahead;
2645};
2646
2647#if _LIBCPP_STD_VER >= 17
2648template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> = 0>
2649basic_regex(_ForwardIterator, _ForwardIterator, regex_constants::syntax_option_type = regex_constants::ECMAScript)
2650 -> basic_regex<typename iterator_traits<_ForwardIterator>::value_type>;
2651#endif
2652
2653template <class _CharT, class _Traits>
2654const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::icase;
2655template <class _CharT, class _Traits>
2656const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::nosubs;
2657template <class _CharT, class _Traits>
2658const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::optimize;
2659template <class _CharT, class _Traits>
2660const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::collate;
2661template <class _CharT, class _Traits>
2662const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::ECMAScript;
2663template <class _CharT, class _Traits>
2664const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::basic;
2665template <class _CharT, class _Traits>
2666const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::extended;
2667template <class _CharT, class _Traits>
2668const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::awk;
2669template <class _CharT, class _Traits>
2670const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::grep;
2671template <class _CharT, class _Traits>
2672const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::egrep;
2673
2674template <class _CharT, class _Traits>
2675void basic_regex<_CharT, _Traits>::swap(basic_regex& __r) {
2676 using std::swap;
2677 swap(__traits_, __r.__traits_);
2678 swap(__flags_, __r.__flags_);
2679 swap(__marked_count_, __r.__marked_count_);
2680 swap(__loop_count_, __r.__loop_count_);
2681 swap(__open_count_, __r.__open_count_);
2682 swap(__start_, __r.__start_);
2683 swap(__end_, __r.__end_);
2684}
2685
2686template <class _CharT, class _Traits>
2687inline _LIBCPP_HIDE_FROM_ABI void swap(basic_regex<_CharT, _Traits>& __x, basic_regex<_CharT, _Traits>& __y) {
2688 return __x.swap(__y);
2689}
2690
2691// __lookahead
2692
2693template <class _CharT, class _Traits>
2694class __lookahead : public __owns_one_state<_CharT> {
2695 typedef __owns_one_state<_CharT> base;
2696
2697 basic_regex<_CharT, _Traits> __exp_;
2698 unsigned __mexp_;
2699 bool __invert_;
2700
2701public:
2702 typedef std::__state<_CharT> __state;
2703
2704 _LIBCPP_HIDE_FROM_ABI
2705 __lookahead(const basic_regex<_CharT, _Traits>& __exp, bool __invert, __node<_CharT>* __s, unsigned __mexp)
2706 : base(__s), __exp_(__exp), __mexp_(__mexp), __invert_(__invert) {}
2707
2708 __lookahead(const __lookahead&) = delete;
2709 __lookahead& operator=(const __lookahead&) = delete;
2710
2711 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
2712};
2713
2714template <class _CharT, class _Traits>
2715void __lookahead<_CharT, _Traits>::__exec(__state& __s) const {
2716 match_results<const _CharT*> __m;
2717 __m.__init(1 + __exp_.mark_count(), __s.__current_, __s.__last_);
2718 bool __matched = __exp_.__match_at_start_ecma(
2719 __s.__current_,
2720 __s.__last_,
2721 __m,
2722 (__s.__flags_ | regex_constants::match_continuous) & ~regex_constants::__full_match,
2723 __s.__at_first_ && __s.__current_ == __s.__first_);
2724 if (__matched != __invert_) {
2725 __s.__do_ = __state::__accept_but_not_consume;
2726 __s.__node_ = this->first();
2727 for (unsigned __i = 1; __i < __m.size(); ++__i) {
2728 __s.__sub_matches_[__mexp_ + __i - 1] = __m.__matches_[__i];
2729 }
2730 } else {
2731 __s.__do_ = __state::__reject;
2732 __s.__node_ = nullptr;
2733 }
2734}
2735
2736template <class _CharT, class _Traits>
2737template <class _ForwardIterator>
2738void basic_regex<_CharT, _Traits>::__init(_ForwardIterator __first, _ForwardIterator __last) {
2739 if (__get_grammar(__flags_) == 0)
2740 __flags_ |= regex_constants::ECMAScript;
2741 _ForwardIterator __temp = __parse(__first, __last);
2742 if (__temp != __last)
2743 __throw_regex_error<regex_constants::__re_err_parse>();
2744}
2745
2746template <class _CharT, class _Traits>
2747template <class _ForwardIterator>
2748_ForwardIterator basic_regex<_CharT, _Traits>::__parse(_ForwardIterator __first, _ForwardIterator __last) {
2749 {
2750 unique_ptr<__node> __h(new __end_state<_CharT>);
2751 __start_.reset(new __empty_state<_CharT>(__h.get()));
2752 __h.release();
2753 __end_ = __start_.get();
2754 }
2755 switch (__get_grammar(__flags_)) {
2756 case ECMAScript:
2757 __first = __parse_ecma_exp(__first, __last);
2758 break;
2759 case basic:
2760 __first = __parse_basic_reg_exp(__first, __last);
2761 break;
2762 case extended:
2763 case awk:
2764 __first = __parse_extended_reg_exp(__first, __last);
2765 break;
2766 case grep:
2767 __first = __parse_grep(__first, __last);
2768 break;
2769 case egrep:
2770 __first = __parse_egrep(__first, __last);
2771 break;
2772 default:
2773 __throw_regex_error<regex_constants::__re_err_grammar>();
2774 }
2775 return __first;
2776}
2777
2778template <class _CharT, class _Traits>
2779template <class _ForwardIterator>
2780_ForwardIterator
2781basic_regex<_CharT, _Traits>::__parse_basic_reg_exp(_ForwardIterator __first, _ForwardIterator __last) {
2782 if (__first != __last) {
2783 if (*__first == '^') {
2784 __push_l_anchor();
2785 ++__first;
2786 }
2787 if (__first != __last) {
2788 __first = __parse_RE_expression(__first, __last);
2789 if (__first != __last) {
2790 _ForwardIterator __temp = std::next(__first);
2791 if (__temp == __last && *__first == '$') {
2792 __push_r_anchor();
2793 ++__first;
2794 }
2795 }
2796 }
2797 if (__first != __last)
2798 __throw_regex_error<regex_constants::__re_err_empty>();
2799 }
2800 return __first;
2801}
2802
2803template <class _CharT, class _Traits>
2804template <class _ForwardIterator>
2805_ForwardIterator
2806basic_regex<_CharT, _Traits>::__parse_extended_reg_exp(_ForwardIterator __first, _ForwardIterator __last) {
2807 __owns_one_state<_CharT>* __sa = __end_;
2808 _ForwardIterator __temp = __parse_ERE_branch(__first, __last);
2809 if (__temp == __first)
2810 __throw_regex_error<regex_constants::__re_err_empty>();
2811 __first = __temp;
2812 while (__first != __last && *__first == '|') {
2813 __owns_one_state<_CharT>* __sb = __end_;
2814 __temp = __parse_ERE_branch(++__first, __last);
2815 if (__temp == __first)
2816 __throw_regex_error<regex_constants::__re_err_empty>();
2817 __push_alternation(__sa, __sb);
2818 __first = __temp;
2819 }
2820 return __first;
2821}
2822
2823template <class _CharT, class _Traits>
2824template <class _ForwardIterator>
2825_ForwardIterator basic_regex<_CharT, _Traits>::__parse_ERE_branch(_ForwardIterator __first, _ForwardIterator __last) {
2826 _ForwardIterator __temp = __parse_ERE_expression(__first, __last);
2827 if (__temp == __first)
2828 __throw_regex_error<regex_constants::__re_err_empty>();
2829 do {
2830 __first = __temp;
2831 __temp = __parse_ERE_expression(__first, __last);
2832 } while (__temp != __first);
2833 return __first;
2834}
2835
2836template <class _CharT, class _Traits>
2837template <class _ForwardIterator>
2838_ForwardIterator
2839basic_regex<_CharT, _Traits>::__parse_ERE_expression(_ForwardIterator __first, _ForwardIterator __last) {
2840 __owns_one_state<_CharT>* __e = __end_;
2841 unsigned __mexp_begin = __marked_count_;
2842 _ForwardIterator __temp = __parse_one_char_or_coll_elem_ERE(__first, __last);
2843 if (__temp == __first && __temp != __last) {
2844 switch (*__temp) {
2845 case '^':
2846 __push_l_anchor();
2847 ++__temp;
2848 break;
2849 case '$':
2850 __push_r_anchor();
2851 ++__temp;
2852 break;
2853 case '(':
2854 __push_begin_marked_subexpression();
2855 unsigned __temp_count = __marked_count_;
2856 ++__open_count_;
2857 __temp = __parse_extended_reg_exp(++__temp, __last);
2858 if (__temp == __last || *__temp != ')')
2859 __throw_regex_error<regex_constants::error_paren>();
2860 __push_end_marked_subexpression(__temp_count);
2861 --__open_count_;
2862 ++__temp;
2863 break;
2864 }
2865 }
2866 if (__temp != __first)
2867 __temp = __parse_ERE_dupl_symbol(__temp, __last, __e, __mexp_begin + 1, __marked_count_ + 1);
2868 __first = __temp;
2869 return __first;
2870}
2871
2872template <class _CharT, class _Traits>
2873template <class _ForwardIterator>
2874_ForwardIterator
2875basic_regex<_CharT, _Traits>::__parse_RE_expression(_ForwardIterator __first, _ForwardIterator __last) {
2876 while (true) {
2877 _ForwardIterator __temp = __parse_simple_RE(__first, __last);
2878 if (__temp == __first)
2879 break;
2880 __first = __temp;
2881 }
2882 return __first;
2883}
2884
2885template <class _CharT, class _Traits>
2886template <class _ForwardIterator>
2887_ForwardIterator basic_regex<_CharT, _Traits>::__parse_simple_RE(_ForwardIterator __first, _ForwardIterator __last) {
2888 if (__first != __last) {
2889 __owns_one_state<_CharT>* __e = __end_;
2890 unsigned __mexp_begin = __marked_count_;
2891 _ForwardIterator __temp = __parse_nondupl_RE(__first, __last);
2892 if (__temp != __first)
2893 __first = __parse_RE_dupl_symbol(__temp, __last, __e, __mexp_begin + 1, __marked_count_ + 1);
2894 }
2895 return __first;
2896}
2897
2898template <class _CharT, class _Traits>
2899template <class _ForwardIterator>
2900_ForwardIterator basic_regex<_CharT, _Traits>::__parse_nondupl_RE(_ForwardIterator __first, _ForwardIterator __last) {
2901 _ForwardIterator __temp = __first;
2902 __first = __parse_one_char_or_coll_elem_RE(__first, __last);
2903 if (__temp == __first) {
2904 __temp = __parse_Back_open_paren(__first, __last);
2905 if (__temp != __first) {
2906 __push_begin_marked_subexpression();
2907 unsigned __temp_count = __marked_count_;
2908 __first = __parse_RE_expression(__temp, __last);
2909 __temp = __parse_Back_close_paren(__first, __last);
2910 if (__temp == __first)
2911 __throw_regex_error<regex_constants::error_paren>();
2912 __push_end_marked_subexpression(__temp_count);
2913 __first = __temp;
2914 } else
2915 __first = __parse_BACKREF(__first, __last);
2916 }
2917 return __first;
2918}
2919
2920template <class _CharT, class _Traits>
2921template <class _ForwardIterator>
2922_ForwardIterator
2923basic_regex<_CharT, _Traits>::__parse_one_char_or_coll_elem_RE(_ForwardIterator __first, _ForwardIterator __last) {
2924 _ForwardIterator __temp = __parse_ORD_CHAR(__first, __last);
2925 if (__temp == __first) {
2926 __temp = __parse_QUOTED_CHAR(__first, __last);
2927 if (__temp == __first) {
2928 if (__temp != __last && *__temp == '.') {
2929 __push_match_any();
2930 ++__temp;
2931 } else
2932 __temp = __parse_bracket_expression(__first, __last);
2933 }
2934 }
2935 __first = __temp;
2936 return __first;
2937}
2938
2939template <class _CharT, class _Traits>
2940template <class _ForwardIterator>
2941_ForwardIterator
2942basic_regex<_CharT, _Traits>::__parse_one_char_or_coll_elem_ERE(_ForwardIterator __first, _ForwardIterator __last) {
2943 _ForwardIterator __temp = __parse_ORD_CHAR_ERE(__first, __last);
2944 if (__temp == __first) {
2945 __temp = __parse_QUOTED_CHAR_ERE(__first, __last);
2946 if (__temp == __first) {
2947 if (__temp != __last && *__temp == '.') {
2948 __push_match_any();
2949 ++__temp;
2950 } else
2951 __temp = __parse_bracket_expression(__first, __last);
2952 }
2953 }
2954 __first = __temp;
2955 return __first;
2956}
2957
2958template <class _CharT, class _Traits>
2959template <class _ForwardIterator>
2960_ForwardIterator
2961basic_regex<_CharT, _Traits>::__parse_Back_open_paren(_ForwardIterator __first, _ForwardIterator __last) {
2962 if (__first != __last) {
2963 _ForwardIterator __temp = std::next(__first);
2964 if (__temp != __last) {
2965 if (*__first == '\\' && *__temp == '(')
2966 __first = ++__temp;
2967 }
2968 }
2969 return __first;
2970}
2971
2972template <class _CharT, class _Traits>
2973template <class _ForwardIterator>
2974_ForwardIterator
2975basic_regex<_CharT, _Traits>::__parse_Back_close_paren(_ForwardIterator __first, _ForwardIterator __last) {
2976 if (__first != __last) {
2977 _ForwardIterator __temp = std::next(__first);
2978 if (__temp != __last) {
2979 if (*__first == '\\' && *__temp == ')')
2980 __first = ++__temp;
2981 }
2982 }
2983 return __first;
2984}
2985
2986template <class _CharT, class _Traits>
2987template <class _ForwardIterator>
2988_ForwardIterator
2989basic_regex<_CharT, _Traits>::__parse_Back_open_brace(_ForwardIterator __first, _ForwardIterator __last) {
2990 if (__first != __last) {
2991 _ForwardIterator __temp = std::next(__first);
2992 if (__temp != __last) {
2993 if (*__first == '\\' && *__temp == '{')
2994 __first = ++__temp;
2995 }
2996 }
2997 return __first;
2998}
2999
3000template <class _CharT, class _Traits>
3001template <class _ForwardIterator>
3002_ForwardIterator
3003basic_regex<_CharT, _Traits>::__parse_Back_close_brace(_ForwardIterator __first, _ForwardIterator __last) {
3004 if (__first != __last) {
3005 _ForwardIterator __temp = std::next(__first);
3006 if (__temp != __last) {
3007 if (*__first == '\\' && *__temp == '}')
3008 __first = ++__temp;
3009 }
3010 }
3011 return __first;
3012}
3013
3014template <class _CharT, class _Traits>
3015template <class _ForwardIterator>
3016_ForwardIterator basic_regex<_CharT, _Traits>::__parse_BACKREF(_ForwardIterator __first, _ForwardIterator __last) {
3017 if (__first != __last) {
3018 _ForwardIterator __temp = std::next(__first);
3019 if (__temp != __last && *__first == '\\' && __test_back_ref(*__temp))
3020 __first = ++__temp;
3021 }
3022 return __first;
3023}
3024
3025template <class _CharT, class _Traits>
3026template <class _ForwardIterator>
3027_ForwardIterator basic_regex<_CharT, _Traits>::__parse_ORD_CHAR(_ForwardIterator __first, _ForwardIterator __last) {
3028 if (__first != __last) {
3029 _ForwardIterator __temp = std::next(__first);
3030 if (__temp == __last && *__first == '$')
3031 return __first;
3032 // Not called inside a bracket
3033 if (*__first == '.' || *__first == '\\' || *__first == '[')
3034 return __first;
3035 __push_char(*__first);
3036 ++__first;
3037 }
3038 return __first;
3039}
3040
3041template <class _CharT, class _Traits>
3042template <class _ForwardIterator>
3043_ForwardIterator basic_regex<_CharT, _Traits>::__parse_ORD_CHAR_ERE(_ForwardIterator __first, _ForwardIterator __last) {
3044 if (__first != __last) {
3045 switch (*__first) {
3046 case '^':
3047 case '.':
3048 case '[':
3049 case '$':
3050 case '(':
3051 case '|':
3052 case '*':
3053 case '+':
3054 case '?':
3055 case '{':
3056 case '\\':
3057 break;
3058 case ')':
3059 if (__open_count_ == 0) {
3060 __push_char(*__first);
3061 ++__first;
3062 }
3063 break;
3064 default:
3065 __push_char(*__first);
3066 ++__first;
3067 break;
3068 }
3069 }
3070 return __first;
3071}
3072
3073template <class _CharT, class _Traits>
3074template <class _ForwardIterator>
3075_ForwardIterator basic_regex<_CharT, _Traits>::__parse_QUOTED_CHAR(_ForwardIterator __first, _ForwardIterator __last) {
3076 if (__first != __last) {
3077 _ForwardIterator __temp = std::next(__first);
3078 if (__temp != __last) {
3079 if (*__first == '\\') {
3080 switch (*__temp) {
3081 case '^':
3082 case '.':
3083 case '*':
3084 case '[':
3085 case '$':
3086 case '\\':
3087 __push_char(*__temp);
3088 __first = ++__temp;
3089 break;
3090 }
3091 }
3092 }
3093 }
3094 return __first;
3095}
3096
3097template <class _CharT, class _Traits>
3098template <class _ForwardIterator>
3099_ForwardIterator
3100basic_regex<_CharT, _Traits>::__parse_QUOTED_CHAR_ERE(_ForwardIterator __first, _ForwardIterator __last) {
3101 if (__first != __last) {
3102 _ForwardIterator __temp = std::next(__first);
3103 if (__temp != __last) {
3104 if (*__first == '\\') {
3105 switch (*__temp) {
3106 case '^':
3107 case '.':
3108 case '*':
3109 case '[':
3110 case '$':
3111 case '\\':
3112 case '(':
3113 case ')':
3114 case '|':
3115 case '+':
3116 case '?':
3117 case '{':
3118 case '}':
3119 __push_char(*__temp);
3120 __first = ++__temp;
3121 break;
3122 default:
3123 if (__get_grammar(__flags_) == awk)
3124 __first = __parse_awk_escape(++__first, __last);
3125 else if (__test_back_ref(*__temp))
3126 __first = ++__temp;
3127 break;
3128 }
3129 }
3130 }
3131 }
3132 return __first;
3133}
3134
3135template <class _CharT, class _Traits>
3136template <class _ForwardIterator>
3137_ForwardIterator basic_regex<_CharT, _Traits>::__parse_RE_dupl_symbol(
3138 _ForwardIterator __first,
3139 _ForwardIterator __last,
3140 __owns_one_state<_CharT>* __s,
3141 unsigned __mexp_begin,
3142 unsigned __mexp_end) {
3143 if (__first != __last) {
3144 if (*__first == '*') {
3145 __push_greedy_inf_repeat(0, __s, __mexp_begin, __mexp_end);
3146 ++__first;
3147 } else {
3148 _ForwardIterator __temp = __parse_Back_open_brace(__first, __last);
3149 if (__temp != __first) {
3150 int __min = 0;
3151 __first = __temp;
3152 __temp = __parse_DUP_COUNT(__first, __last, __min);
3153 if (__temp == __first)
3154 __throw_regex_error<regex_constants::error_badbrace>();
3155 __first = __temp;
3156 if (__first == __last)
3157 __throw_regex_error<regex_constants::error_brace>();
3158 if (*__first != ',') {
3159 __temp = __parse_Back_close_brace(__first, __last);
3160 if (__temp == __first)
3161 __throw_regex_error<regex_constants::error_brace>();
3162 __push_loop(__min, __min, __s, __mexp_begin, __mexp_end, true);
3163 __first = __temp;
3164 } else {
3165 ++__first; // consume ','
3166 int __max = -1;
3167 __first = __parse_DUP_COUNT(__first, __last, __max);
3168 __temp = __parse_Back_close_brace(__first, __last);
3169 if (__temp == __first)
3170 __throw_regex_error<regex_constants::error_brace>();
3171 if (__max == -1)
3172 __push_greedy_inf_repeat(__min, __s, __mexp_begin, __mexp_end);
3173 else {
3174 if (__max < __min)
3175 __throw_regex_error<regex_constants::error_badbrace>();
3176 __push_loop(__min, __max, __s, __mexp_begin, __mexp_end, true);
3177 }
3178 __first = __temp;
3179 }
3180 }
3181 }
3182 }
3183 return __first;
3184}
3185
3186template <class _CharT, class _Traits>
3187template <class _ForwardIterator>
3188_ForwardIterator basic_regex<_CharT, _Traits>::__parse_ERE_dupl_symbol(
3189 _ForwardIterator __first,
3190 _ForwardIterator __last,
3191 __owns_one_state<_CharT>* __s,
3192 unsigned __mexp_begin,
3193 unsigned __mexp_end) {
3194 if (__first != __last) {
3195 unsigned __grammar = __get_grammar(__flags_);
3196 switch (*__first) {
3197 case '*':
3198 ++__first;
3199 if (__grammar == ECMAScript && __first != __last && *__first == '?') {
3200 ++__first;
3201 __push_nongreedy_inf_repeat(0, __s, __mexp_begin, __mexp_end);
3202 } else
3203 __push_greedy_inf_repeat(0, __s, __mexp_begin, __mexp_end);
3204 break;
3205 case '+':
3206 ++__first;
3207 if (__grammar == ECMAScript && __first != __last && *__first == '?') {
3208 ++__first;
3209 __push_nongreedy_inf_repeat(1, __s, __mexp_begin, __mexp_end);
3210 } else
3211 __push_greedy_inf_repeat(1, __s, __mexp_begin, __mexp_end);
3212 break;
3213 case '?':
3214 ++__first;
3215 if (__grammar == ECMAScript && __first != __last && *__first == '?') {
3216 ++__first;
3217 __push_loop(0, 1, __s, __mexp_begin, __mexp_end, false);
3218 } else
3219 __push_loop(0, 1, __s, __mexp_begin, __mexp_end);
3220 break;
3221 case '{': {
3222 int __min;
3223 _ForwardIterator __temp = __parse_DUP_COUNT(++__first, __last, __min);
3224 if (__temp == __first)
3225 __throw_regex_error<regex_constants::error_badbrace>();
3226 __first = __temp;
3227 if (__first == __last)
3228 __throw_regex_error<regex_constants::error_brace>();
3229 switch (*__first) {
3230 case '}':
3231 ++__first;
3232 if (__grammar == ECMAScript && __first != __last && *__first == '?') {
3233 ++__first;
3234 __push_loop(__min, __min, __s, __mexp_begin, __mexp_end, false);
3235 } else
3236 __push_loop(__min, __min, __s, __mexp_begin, __mexp_end);
3237 break;
3238 case ',':
3239 ++__first;
3240 if (__first == __last)
3241 __throw_regex_error<regex_constants::error_badbrace>();
3242 if (*__first == '}') {
3243 ++__first;
3244 if (__grammar == ECMAScript && __first != __last && *__first == '?') {
3245 ++__first;
3246 __push_nongreedy_inf_repeat(__min, __s, __mexp_begin, __mexp_end);
3247 } else
3248 __push_greedy_inf_repeat(__min, __s, __mexp_begin, __mexp_end);
3249 } else {
3250 int __max = -1;
3251 __temp = __parse_DUP_COUNT(__first, __last, __max);
3252 if (__temp == __first)
3253 __throw_regex_error<regex_constants::error_brace>();
3254 __first = __temp;
3255 if (__first == __last || *__first != '}')
3256 __throw_regex_error<regex_constants::error_brace>();
3257 ++__first;
3258 if (__max < __min)
3259 __throw_regex_error<regex_constants::error_badbrace>();
3260 if (__grammar == ECMAScript && __first != __last && *__first == '?') {
3261 ++__first;
3262 __push_loop(__min, __max, __s, __mexp_begin, __mexp_end, false);
3263 } else
3264 __push_loop(__min, __max, __s, __mexp_begin, __mexp_end);
3265 }
3266 break;
3267 default:
3268 __throw_regex_error<regex_constants::error_badbrace>();
3269 }
3270 } break;
3271 }
3272 }
3273 return __first;
3274}
3275
3276template <class _CharT, class _Traits>
3277template <class _ForwardIterator>
3278_ForwardIterator
3279basic_regex<_CharT, _Traits>::__parse_bracket_expression(_ForwardIterator __first, _ForwardIterator __last) {
3280 if (__first != __last && *__first == '[') {
3281 ++__first;
3282 if (__first == __last)
3283 __throw_regex_error<regex_constants::error_brack>();
3284 bool __negate = false;
3285 if (*__first == '^') {
3286 ++__first;
3287 __negate = true;
3288 }
3289 __bracket_expression<_CharT, _Traits>* __ml = __start_matching_list(__negate);
3290 // __ml owned by *this
3291 if (__first == __last)
3292 __throw_regex_error<regex_constants::error_brack>();
3293 if (__get_grammar(__flags_) != ECMAScript && *__first == ']') {
3294 __ml->__add_char(']');
3295 ++__first;
3296 }
3297 __first = __parse_follow_list(__first, __last, __ml);
3298 if (__first == __last)
3299 __throw_regex_error<regex_constants::error_brack>();
3300 if (*__first == '-') {
3301 __ml->__add_char('-');
3302 ++__first;
3303 }
3304 if (__first == __last || *__first != ']')
3305 __throw_regex_error<regex_constants::error_brack>();
3306 ++__first;
3307 }
3308 return __first;
3309}
3310
3311template <class _CharT, class _Traits>
3312template <class _ForwardIterator>
3313_ForwardIterator basic_regex<_CharT, _Traits>::__parse_follow_list(
3314 _ForwardIterator __first, _ForwardIterator __last, __bracket_expression<_CharT, _Traits>* __ml) {
3315 if (__first != __last) {
3316 while (true) {
3317 _ForwardIterator __temp = __parse_expression_term(__first, __last, __ml);
3318 if (__temp == __first)
3319 break;
3320 __first = __temp;
3321 }
3322 }
3323 return __first;
3324}
3325
3326template <class _CharT, class _Traits>
3327template <class _ForwardIterator>
3328_ForwardIterator basic_regex<_CharT, _Traits>::__parse_expression_term(
3329 _ForwardIterator __first, _ForwardIterator __last, __bracket_expression<_CharT, _Traits>* __ml) {
3330 if (__first != __last && *__first != ']') {
3331 _ForwardIterator __temp = std::next(__first);
3332 basic_string<_CharT> __start_range;
3333 if (__temp != __last && *__first == '[') {
3334 if (*__temp == '=')
3335 return __parse_equivalence_class(++__temp, __last, __ml);
3336 else if (*__temp == ':')
3337 return __parse_character_class(++__temp, __last, __ml);
3338 else if (*__temp == '.')
3339 __first = __parse_collating_symbol(++__temp, __last, __start_range);
3340 }
3341 unsigned __grammar = __get_grammar(__flags_);
3342 if (__start_range.empty()) {
3343 if ((__grammar == ECMAScript || __grammar == awk) && *__first == '\\') {
3344 if (__grammar == ECMAScript)
3345 __first = __parse_class_escape(++__first, __last, __start_range, __ml);
3346 else
3347 __first = __parse_awk_escape(++__first, __last, &__start_range);
3348 } else {
3349 __start_range = *__first;
3350 ++__first;
3351 }
3352 }
3353 if (__first != __last && *__first != ']') {
3354 __temp = std::next(__first);
3355 if (__temp != __last && *__first == '-' && *__temp != ']') {
3356 // parse a range
3357 basic_string<_CharT> __end_range;
3358 __first = __temp;
3359 ++__temp;
3360 if (__temp != __last && *__first == '[' && *__temp == '.')
3361 __first = __parse_collating_symbol(++__temp, __last, __end_range);
3362 else {
3363 if ((__grammar == ECMAScript || __grammar == awk) && *__first == '\\') {
3364 if (__grammar == ECMAScript)
3365 __first = __parse_class_escape(++__first, __last, __end_range, __ml);
3366 else
3367 __first = __parse_awk_escape(++__first, __last, &__end_range);
3368 } else {
3369 __end_range = *__first;
3370 ++__first;
3371 }
3372 }
3373 __ml->__add_range(std::move(__start_range), std::move(__end_range));
3374 } else if (!__start_range.empty()) {
3375 if (__start_range.size() == 1)
3376 __ml->__add_char(__start_range[0]);
3377 else
3378 __ml->__add_digraph(__start_range[0], __start_range[1]);
3379 }
3380 } else if (!__start_range.empty()) {
3381 if (__start_range.size() == 1)
3382 __ml->__add_char(__start_range[0]);
3383 else
3384 __ml->__add_digraph(__start_range[0], __start_range[1]);
3385 }
3386 }
3387 return __first;
3388}
3389
3390template <class _CharT, class _Traits>
3391template <class _ForwardIterator>
3392_ForwardIterator basic_regex<_CharT, _Traits>::__parse_class_escape(
3393 _ForwardIterator __first,
3394 _ForwardIterator __last,
3395 basic_string<_CharT>& __str,
3396 __bracket_expression<_CharT, _Traits>* __ml) {
3397 if (__first == __last)
3398 __throw_regex_error<regex_constants::error_escape>();
3399 switch (*__first) {
3400 case 0:
3401 __str = *__first;
3402 return ++__first;
3403 case 'b':
3404 __str = _CharT(8);
3405 return ++__first;
3406 case 'd':
3407 __ml->__add_class(ctype_base::digit);
3408 return ++__first;
3409 case 'D':
3410 __ml->__add_neg_class(ctype_base::digit);
3411 return ++__first;
3412 case 's':
3413 __ml->__add_class(ctype_base::space);
3414 return ++__first;
3415 case 'S':
3416 __ml->__add_neg_class(ctype_base::space);
3417 return ++__first;
3418 case 'w':
3419 __ml->__add_class(ctype_base::alnum);
3420 __ml->__add_char('_');
3421 return ++__first;
3422 case 'W':
3423 __ml->__add_neg_class(ctype_base::alnum);
3424 __ml->__add_neg_char('_');
3425 return ++__first;
3426 }
3427 __first = __parse_character_escape(__first, __last, &__str);
3428 return __first;
3429}
3430
3431template <class _CharT, class _Traits>
3432template <class _ForwardIterator>
3433_ForwardIterator basic_regex<_CharT, _Traits>::__parse_awk_escape(
3434 _ForwardIterator __first, _ForwardIterator __last, basic_string<_CharT>* __str) {
3435 if (__first == __last)
3436 __throw_regex_error<regex_constants::error_escape>();
3437 switch (*__first) {
3438 case '\\':
3439 case '"':
3440 case '/':
3441 if (__str)
3442 *__str = *__first;
3443 else
3444 __push_char(*__first);
3445 return ++__first;
3446 case 'a':
3447 if (__str)
3448 *__str = _CharT(7);
3449 else
3450 __push_char(_CharT(7));
3451 return ++__first;
3452 case 'b':
3453 if (__str)
3454 *__str = _CharT(8);
3455 else
3456 __push_char(_CharT(8));
3457 return ++__first;
3458 case 'f':
3459 if (__str)
3460 *__str = _CharT(0xC);
3461 else
3462 __push_char(_CharT(0xC));
3463 return ++__first;
3464 case 'n':
3465 if (__str)
3466 *__str = _CharT(0xA);
3467 else
3468 __push_char(_CharT(0xA));
3469 return ++__first;
3470 case 'r':
3471 if (__str)
3472 *__str = _CharT(0xD);
3473 else
3474 __push_char(_CharT(0xD));
3475 return ++__first;
3476 case 't':
3477 if (__str)
3478 *__str = _CharT(0x9);
3479 else
3480 __push_char(_CharT(0x9));
3481 return ++__first;
3482 case 'v':
3483 if (__str)
3484 *__str = _CharT(0xB);
3485 else
3486 __push_char(_CharT(0xB));
3487 return ++__first;
3488 }
3489 if ('0' <= *__first && *__first <= '7') {
3490 unsigned __val = *__first - '0';
3491 if (++__first != __last && ('0' <= *__first && *__first <= '7')) {
3492 __val = 8 * __val + *__first - '0';
3493 if (++__first != __last && ('0' <= *__first && *__first <= '7'))
3494 __val = 8 * __val + *__first++ - '0';
3495 }
3496 if (__str)
3497 *__str = _CharT(__val);
3498 else
3499 __push_char(_CharT(__val));
3500 } else
3501 __throw_regex_error<regex_constants::error_escape>();
3502 return __first;
3503}
3504
3505template <class _CharT, class _Traits>
3506template <class _ForwardIterator>
3507_ForwardIterator basic_regex<_CharT, _Traits>::__parse_equivalence_class(
3508 _ForwardIterator __first, _ForwardIterator __last, __bracket_expression<_CharT, _Traits>* __ml) {
3509 // Found [=
3510 // This means =] must exist
3511 value_type __equal_close[2] = {'=', ']'};
3512 _ForwardIterator __temp = std::search(__first, __last, __equal_close, __equal_close + 2);
3513 if (__temp == __last)
3514 __throw_regex_error<regex_constants::error_brack>();
3515 // [__first, __temp) contains all text in [= ... =]
3516 string_type __collate_name = __traits_.lookup_collatename(__first, __temp);
3517 if (__collate_name.empty())
3518 __throw_regex_error<regex_constants::error_collate>();
3519 string_type __equiv_name = __traits_.transform_primary(__collate_name.begin(), __collate_name.end());
3520 if (!__equiv_name.empty())
3521 __ml->__add_equivalence(__equiv_name);
3522 else {
3523 switch (__collate_name.size()) {
3524 case 1:
3525 __ml->__add_char(__collate_name[0]);
3526 break;
3527 case 2:
3528 __ml->__add_digraph(__collate_name[0], __collate_name[1]);
3529 break;
3530 default:
3531 __throw_regex_error<regex_constants::error_collate>();
3532 }
3533 }
3534 __first = std::next(__temp, 2);
3535 return __first;
3536}
3537
3538template <class _CharT, class _Traits>
3539template <class _ForwardIterator>
3540_ForwardIterator basic_regex<_CharT, _Traits>::__parse_character_class(
3541 _ForwardIterator __first, _ForwardIterator __last, __bracket_expression<_CharT, _Traits>* __ml) {
3542 // Found [:
3543 // This means :] must exist
3544 value_type __colon_close[2] = {':', ']'};
3545 _ForwardIterator __temp = std::search(__first, __last, __colon_close, __colon_close + 2);
3546 if (__temp == __last)
3547 __throw_regex_error<regex_constants::error_brack>();
3548 // [__first, __temp) contains all text in [: ... :]
3549 typedef typename _Traits::char_class_type char_class_type;
3550 char_class_type __class_type = __traits_.lookup_classname(__first, __temp, __flags_ & icase);
3551 if (__class_type == 0)
3552 __throw_regex_error<regex_constants::error_ctype>();
3553 __ml->__add_class(__class_type);
3554 __first = std::next(__temp, 2);
3555 return __first;
3556}
3557
3558template <class _CharT, class _Traits>
3559template <class _ForwardIterator>
3560_ForwardIterator basic_regex<_CharT, _Traits>::__parse_collating_symbol(
3561 _ForwardIterator __first, _ForwardIterator __last, basic_string<_CharT>& __col_sym) {
3562 // Found [.
3563 // This means .] must exist
3564 value_type __dot_close[2] = {'.', ']'};
3565 _ForwardIterator __temp = std::search(__first, __last, __dot_close, __dot_close + 2);
3566 if (__temp == __last)
3567 __throw_regex_error<regex_constants::error_brack>();
3568 // [__first, __temp) contains all text in [. ... .]
3569 __col_sym = __traits_.lookup_collatename(__first, __temp);
3570 switch (__col_sym.size()) {
3571 case 1:
3572 case 2:
3573 break;
3574 default:
3575 __throw_regex_error<regex_constants::error_collate>();
3576 }
3577 __first = std::next(__temp, 2);
3578 return __first;
3579}
3580
3581template <class _CharT, class _Traits>
3582template <class _ForwardIterator>
3583_ForwardIterator
3584basic_regex<_CharT, _Traits>::__parse_DUP_COUNT(_ForwardIterator __first, _ForwardIterator __last, int& __c) {
3585 if (__first != __last) {
3586 int __val = __traits_.value(*__first, 10);
3587 if (__val != -1) {
3588 __c = __val;
3589 for (++__first; __first != __last && (__val = __traits_.value(*__first, 10)) != -1; ++__first) {
3590 if (__c >= numeric_limits<int>::max() / 10)
3591 __throw_regex_error<regex_constants::error_badbrace>();
3592 __c *= 10;
3593 __c += __val;
3594 }
3595 }
3596 }
3597 return __first;
3598}
3599
3600template <class _CharT, class _Traits>
3601template <class _ForwardIterator>
3602_ForwardIterator basic_regex<_CharT, _Traits>::__parse_ecma_exp(_ForwardIterator __first, _ForwardIterator __last) {
3603 __owns_one_state<_CharT>* __sa = __end_;
3604 _ForwardIterator __temp = __parse_alternative(__first, __last);
3605 if (__temp == __first)
3606 __push_empty();
3607 __first = __temp;
3608 while (__first != __last && *__first == '|') {
3609 __owns_one_state<_CharT>* __sb = __end_;
3610 __temp = __parse_alternative(++__first, __last);
3611 if (__temp == __first)
3612 __push_empty();
3613 __push_alternation(__sa, __sb);
3614 __first = __temp;
3615 }
3616 return __first;
3617}
3618
3619template <class _CharT, class _Traits>
3620template <class _ForwardIterator>
3621_ForwardIterator basic_regex<_CharT, _Traits>::__parse_alternative(_ForwardIterator __first, _ForwardIterator __last) {
3622 while (true) {
3623 _ForwardIterator __temp = __parse_term(__first, __last);
3624 if (__temp == __first)
3625 break;
3626 __first = __temp;
3627 }
3628 return __first;
3629}
3630
3631template <class _CharT, class _Traits>
3632template <class _ForwardIterator>
3633_ForwardIterator basic_regex<_CharT, _Traits>::__parse_term(_ForwardIterator __first, _ForwardIterator __last) {
3634 _ForwardIterator __temp = __parse_assertion(__first, __last);
3635 if (__temp == __first) {
3636 __owns_one_state<_CharT>* __e = __end_;
3637 unsigned __mexp_begin = __marked_count_;
3638 __temp = __parse_atom(__first, __last);
3639 if (__temp != __first)
3640 __first = __parse_ERE_dupl_symbol(__temp, __last, __e, __mexp_begin + 1, __marked_count_ + 1);
3641 } else
3642 __first = __temp;
3643 return __first;
3644}
3645
3646template <class _CharT, class _Traits>
3647template <class _ForwardIterator>
3648_ForwardIterator basic_regex<_CharT, _Traits>::__parse_assertion(_ForwardIterator __first, _ForwardIterator __last) {
3649 if (__first != __last) {
3650 switch (*__first) {
3651 case '^':
3652 __push_l_anchor();
3653 ++__first;
3654 break;
3655 case '$':
3656 __push_r_anchor();
3657 ++__first;
3658 break;
3659 case '\\': {
3660 _ForwardIterator __temp = std::next(__first);
3661 if (__temp != __last) {
3662 if (*__temp == 'b') {
3663 __push_word_boundary(false);
3664 __first = ++__temp;
3665 } else if (*__temp == 'B') {
3666 __push_word_boundary(true);
3667 __first = ++__temp;
3668 }
3669 }
3670 } break;
3671 case '(': {
3672 _ForwardIterator __temp = std::next(__first);
3673 if (__temp != __last && *__temp == '?') {
3674 if (++__temp != __last) {
3675 switch (*__temp) {
3676 case '=': {
3677 basic_regex __exp;
3678 __exp.__flags_ = __flags_;
3679 __temp = __exp.__parse(++__temp, __last);
3680 unsigned __mexp = __exp.__marked_count_;
3681 __push_lookahead(std::move(__exp), false, __marked_count_);
3682 __marked_count_ += __mexp;
3683 if (__temp == __last || *__temp != ')')
3684 __throw_regex_error<regex_constants::error_paren>();
3685 __first = ++__temp;
3686 } break;
3687 case '!': {
3688 basic_regex __exp;
3689 __exp.__flags_ = __flags_;
3690 __temp = __exp.__parse(++__temp, __last);
3691 unsigned __mexp = __exp.__marked_count_;
3692 __push_lookahead(std::move(__exp), true, __marked_count_);
3693 __marked_count_ += __mexp;
3694 if (__temp == __last || *__temp != ')')
3695 __throw_regex_error<regex_constants::error_paren>();
3696 __first = ++__temp;
3697 } break;
3698 }
3699 }
3700 }
3701 } break;
3702 }
3703 }
3704 return __first;
3705}
3706
3707template <class _CharT, class _Traits>
3708template <class _ForwardIterator>
3709_ForwardIterator basic_regex<_CharT, _Traits>::__parse_atom(_ForwardIterator __first, _ForwardIterator __last) {
3710 if (__first != __last) {
3711 switch (*__first) {
3712 case '.':
3713 __push_match_any_but_newline();
3714 ++__first;
3715 break;
3716 case '\\':
3717 __first = __parse_atom_escape(__first, __last);
3718 break;
3719 case '[':
3720 __first = __parse_bracket_expression(__first, __last);
3721 break;
3722 case '(': {
3723 ++__first;
3724 if (__first == __last)
3725 __throw_regex_error<regex_constants::error_paren>();
3726 _ForwardIterator __temp = std::next(__first);
3727 if (__temp != __last && *__first == '?' && *__temp == ':') {
3728 ++__open_count_;
3729 __first = __parse_ecma_exp(++__temp, __last);
3730 if (__first == __last || *__first != ')')
3731 __throw_regex_error<regex_constants::error_paren>();
3732 --__open_count_;
3733 ++__first;
3734 } else {
3735 __push_begin_marked_subexpression();
3736 unsigned __temp_count = __marked_count_;
3737 ++__open_count_;
3738 __first = __parse_ecma_exp(__first, __last);
3739 if (__first == __last || *__first != ')')
3740 __throw_regex_error<regex_constants::error_paren>();
3741 __push_end_marked_subexpression(__temp_count);
3742 --__open_count_;
3743 ++__first;
3744 }
3745 } break;
3746 case '*':
3747 case '+':
3748 case '?':
3749 case '{':
3750 __throw_regex_error<regex_constants::error_badrepeat>();
3751 break;
3752 default:
3753 __first = __parse_pattern_character(__first, __last);
3754 break;
3755 }
3756 }
3757 return __first;
3758}
3759
3760template <class _CharT, class _Traits>
3761template <class _ForwardIterator>
3762_ForwardIterator basic_regex<_CharT, _Traits>::__parse_atom_escape(_ForwardIterator __first, _ForwardIterator __last) {
3763 if (__first != __last && *__first == '\\') {
3764 _ForwardIterator __t1 = std::next(__first);
3765 if (__t1 == __last)
3766 __throw_regex_error<regex_constants::error_escape>();
3767
3768 _ForwardIterator __t2 = __parse_decimal_escape(__t1, __last);
3769 if (__t2 != __t1)
3770 __first = __t2;
3771 else {
3772 __t2 = __parse_character_class_escape(__t1, __last);
3773 if (__t2 != __t1)
3774 __first = __t2;
3775 else {
3776 __t2 = __parse_character_escape(__t1, __last);
3777 if (__t2 != __t1)
3778 __first = __t2;
3779 }
3780 }
3781 }
3782 return __first;
3783}
3784
3785template <class _CharT, class _Traits>
3786template <class _ForwardIterator>
3787_ForwardIterator
3788basic_regex<_CharT, _Traits>::__parse_decimal_escape(_ForwardIterator __first, _ForwardIterator __last) {
3789 if (__first != __last) {
3790 if (*__first == '0') {
3791 __push_char(_CharT());
3792 ++__first;
3793 } else if ('1' <= *__first && *__first <= '9') {
3794 unsigned __v = *__first - '0';
3795 for (++__first; __first != __last && '0' <= *__first && *__first <= '9'; ++__first) {
3796 if (__v >= numeric_limits<unsigned>::max() / 10)
3797 __throw_regex_error<regex_constants::error_backref>();
3798 __v = 10 * __v + *__first - '0';
3799 }
3800 if (__v == 0 || __v > mark_count())
3801 __throw_regex_error<regex_constants::error_backref>();
3802 __push_back_ref(__v);
3803 }
3804 }
3805 return __first;
3806}
3807
3808template <class _CharT, class _Traits>
3809template <class _ForwardIterator>
3810_ForwardIterator
3811basic_regex<_CharT, _Traits>::__parse_character_class_escape(_ForwardIterator __first, _ForwardIterator __last) {
3812 if (__first != __last) {
3813 __bracket_expression<_CharT, _Traits>* __ml;
3814 switch (*__first) {
3815 case 'd':
3816 __ml = __start_matching_list(false);
3817 __ml->__add_class(ctype_base::digit);
3818 ++__first;
3819 break;
3820 case 'D':
3821 __ml = __start_matching_list(true);
3822 __ml->__add_class(ctype_base::digit);
3823 ++__first;
3824 break;
3825 case 's':
3826 __ml = __start_matching_list(false);
3827 __ml->__add_class(ctype_base::space);
3828 ++__first;
3829 break;
3830 case 'S':
3831 __ml = __start_matching_list(true);
3832 __ml->__add_class(ctype_base::space);
3833 ++__first;
3834 break;
3835 case 'w':
3836 __ml = __start_matching_list(false);
3837 __ml->__add_class(ctype_base::alnum);
3838 __ml->__add_char('_');
3839 ++__first;
3840 break;
3841 case 'W':
3842 __ml = __start_matching_list(true);
3843 __ml->__add_class(ctype_base::alnum);
3844 __ml->__add_char('_');
3845 ++__first;
3846 break;
3847 }
3848 }
3849 return __first;
3850}
3851
3852template <class _CharT, class _Traits>
3853template <class _ForwardIterator>
3854_ForwardIterator basic_regex<_CharT, _Traits>::__parse_character_escape(
3855 _ForwardIterator __first, _ForwardIterator __last, basic_string<_CharT>* __str) {
3856 if (__first != __last) {
3857 _ForwardIterator __t;
3858 unsigned __sum = 0;
3859 int __hd;
3860 switch (*__first) {
3861 case 'f':
3862 if (__str)
3863 *__str = _CharT(0xC);
3864 else
3865 __push_char(_CharT(0xC));
3866 ++__first;
3867 break;
3868 case 'n':
3869 if (__str)
3870 *__str = _CharT(0xA);
3871 else
3872 __push_char(_CharT(0xA));
3873 ++__first;
3874 break;
3875 case 'r':
3876 if (__str)
3877 *__str = _CharT(0xD);
3878 else
3879 __push_char(_CharT(0xD));
3880 ++__first;
3881 break;
3882 case 't':
3883 if (__str)
3884 *__str = _CharT(0x9);
3885 else
3886 __push_char(_CharT(0x9));
3887 ++__first;
3888 break;
3889 case 'v':
3890 if (__str)
3891 *__str = _CharT(0xB);
3892 else
3893 __push_char(_CharT(0xB));
3894 ++__first;
3895 break;
3896 case 'c':
3897 if ((__t = std::next(__first)) != __last) {
3898 if (('A' <= *__t && *__t <= 'Z') || ('a' <= *__t && *__t <= 'z')) {
3899 if (__str)
3900 *__str = _CharT(*__t % 32);
3901 else
3902 __push_char(_CharT(*__t % 32));
3903 __first = ++__t;
3904 } else
3905 __throw_regex_error<regex_constants::error_escape>();
3906 } else
3907 __throw_regex_error<regex_constants::error_escape>();
3908 break;
3909 case 'u':
3910 ++__first;
3911 if (__first == __last)
3912 __throw_regex_error<regex_constants::error_escape>();
3913 __hd = __traits_.value(*__first, 16);
3914 if (__hd == -1)
3915 __throw_regex_error<regex_constants::error_escape>();
3916 __sum = 16 * __sum + static_cast<unsigned>(__hd);
3917 ++__first;
3918 if (__first == __last)
3919 __throw_regex_error<regex_constants::error_escape>();
3920 __hd = __traits_.value(*__first, 16);
3921 if (__hd == -1)
3922 __throw_regex_error<regex_constants::error_escape>();
3923 __sum = 16 * __sum + static_cast<unsigned>(__hd);
3924 // fallthrough
3925 case 'x':
3926 ++__first;
3927 if (__first == __last)
3928 __throw_regex_error<regex_constants::error_escape>();
3929 __hd = __traits_.value(*__first, 16);
3930 if (__hd == -1)
3931 __throw_regex_error<regex_constants::error_escape>();
3932 __sum = 16 * __sum + static_cast<unsigned>(__hd);
3933 ++__first;
3934 if (__first == __last)
3935 __throw_regex_error<regex_constants::error_escape>();
3936 __hd = __traits_.value(*__first, 16);
3937 if (__hd == -1)
3938 __throw_regex_error<regex_constants::error_escape>();
3939 __sum = 16 * __sum + static_cast<unsigned>(__hd);
3940 if (__str)
3941 *__str = _CharT(__sum);
3942 else
3943 __push_char(_CharT(__sum));
3944 ++__first;
3945 break;
3946 case '0':
3947 if (__str)
3948 *__str = _CharT(0);
3949 else
3950 __push_char(_CharT(0));
3951 ++__first;
3952 break;
3953 default:
3954 if (*__first != '_' && !__traits_.isctype(*__first, ctype_base::alnum)) {
3955 if (__str)
3956 *__str = *__first;
3957 else
3958 __push_char(*__first);
3959 ++__first;
3960 } else
3961 __throw_regex_error<regex_constants::error_escape>();
3962 break;
3963 }
3964 }
3965 return __first;
3966}
3967
3968template <class _CharT, class _Traits>
3969template <class _ForwardIterator>
3970_ForwardIterator
3971basic_regex<_CharT, _Traits>::__parse_pattern_character(_ForwardIterator __first, _ForwardIterator __last) {
3972 if (__first != __last) {
3973 switch (*__first) {
3974 case '^':
3975 case '$':
3976 case '\\':
3977 case '.':
3978 case '*':
3979 case '+':
3980 case '?':
3981 case '(':
3982 case ')':
3983 case '[':
3984 case ']':
3985 case '{':
3986 case '}':
3987 case '|':
3988 break;
3989 default:
3990 __push_char(*__first);
3991 ++__first;
3992 break;
3993 }
3994 }
3995 return __first;
3996}
3997
3998template <class _CharT, class _Traits>
3999template <class _ForwardIterator>
4000_ForwardIterator basic_regex<_CharT, _Traits>::__parse_grep(_ForwardIterator __first, _ForwardIterator __last) {
4001 __owns_one_state<_CharT>* __sa = __end_;
4002 _ForwardIterator __t1 = std::find(__first, __last, _CharT('\n'));
4003 if (__t1 != __first)
4004 __parse_basic_reg_exp(__first, __t1);
4005 else
4006 __push_empty();
4007 __first = __t1;
4008 if (__first != __last)
4009 ++__first;
4010 while (__first != __last) {
4011 __t1 = std::find(__first, __last, _CharT('\n'));
4012 __owns_one_state<_CharT>* __sb = __end_;
4013 if (__t1 != __first)
4014 __parse_basic_reg_exp(__first, __t1);
4015 else
4016 __push_empty();
4017 __push_alternation(__sa, __sb);
4018 __first = __t1;
4019 if (__first != __last)
4020 ++__first;
4021 }
4022 return __first;
4023}
4024
4025template <class _CharT, class _Traits>
4026template <class _ForwardIterator>
4027_ForwardIterator basic_regex<_CharT, _Traits>::__parse_egrep(_ForwardIterator __first, _ForwardIterator __last) {
4028 __owns_one_state<_CharT>* __sa = __end_;
4029 _ForwardIterator __t1 = std::find(__first, __last, _CharT('\n'));
4030 if (__t1 != __first)
4031 __parse_extended_reg_exp(__first, __t1);
4032 else
4033 __push_empty();
4034 __first = __t1;
4035 if (__first != __last)
4036 ++__first;
4037 while (__first != __last) {
4038 __t1 = std::find(__first, __last, _CharT('\n'));
4039 __owns_one_state<_CharT>* __sb = __end_;
4040 if (__t1 != __first)
4041 __parse_extended_reg_exp(__first, __t1);
4042 else
4043 __push_empty();
4044 __push_alternation(__sa, __sb);
4045 __first = __t1;
4046 if (__first != __last)
4047 ++__first;
4048 }
4049 return __first;
4050}
4051
4052template <class _CharT, class _Traits>
4053bool basic_regex<_CharT, _Traits>::__test_back_ref(_CharT __c) {
4054 unsigned __val = __traits_.value(__c, 10);
4055 if (__val >= 1 && __val <= 9) {
4056 if (__val > mark_count())
4057 __throw_regex_error<regex_constants::error_backref>();
4058 __push_back_ref(__val);
4059 return true;
4060 }
4061
4062 return false;
4063}
4064
4065template <class _CharT, class _Traits>
4066void basic_regex<_CharT, _Traits>::__push_loop(
4067 size_t __min, size_t __max, __owns_one_state<_CharT>* __s, size_t __mexp_begin, size_t __mexp_end, bool __greedy) {
4068 unique_ptr<__empty_state<_CharT> > __e1(new __empty_state<_CharT>(__end_->first()));
4069 __end_->first() = nullptr;
4070 unique_ptr<__loop<_CharT> > __e2(
4071 new __loop<_CharT>(__loop_count_, __s->first(), __e1.get(), __mexp_begin, __mexp_end, __greedy, __min, __max));
4072 __s->first() = nullptr;
4073 __e1.release();
4074 __end_->first() = new __repeat_one_loop<_CharT>(__e2.get());
4075 __end_ = __e2->second();
4076 __s->first() = __e2.release();
4077 ++__loop_count_;
4078}
4079
4080template <class _CharT, class _Traits>
4081void basic_regex<_CharT, _Traits>::__push_char(value_type __c) {
4082 if (flags() & icase)
4083 __end_->first() = new __match_char_icase<_CharT, _Traits>(__traits_, __c, __end_->first());
4084 else if (flags() & collate)
4085 __end_->first() = new __match_char_collate<_CharT, _Traits>(__traits_, __c, __end_->first());
4086 else
4087 __end_->first() = new __match_char<_CharT>(__c, __end_->first());
4088 __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
4089}
4090
4091template <class _CharT, class _Traits>
4092void basic_regex<_CharT, _Traits>::__push_begin_marked_subexpression() {
4093 if (!(__flags_ & nosubs)) {
4094 __end_->first() = new __begin_marked_subexpression<_CharT>(++__marked_count_, __end_->first());
4095 __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
4096 }
4097}
4098
4099template <class _CharT, class _Traits>
4100void basic_regex<_CharT, _Traits>::__push_end_marked_subexpression(unsigned __sub) {
4101 if (!(__flags_ & nosubs)) {
4102 __end_->first() = new __end_marked_subexpression<_CharT>(__sub, __end_->first());
4103 __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
4104 }
4105}
4106
4107template <class _CharT, class _Traits>
4108void basic_regex<_CharT, _Traits>::__push_l_anchor() {
4109 __end_->first() = new __l_anchor_multiline<_CharT>(__use_multiline(), __end_->first());
4110 __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
4111}
4112
4113template <class _CharT, class _Traits>
4114void basic_regex<_CharT, _Traits>::__push_r_anchor() {
4115 __end_->first() = new __r_anchor_multiline<_CharT>(__use_multiline(), __end_->first());
4116 __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
4117}
4118
4119template <class _CharT, class _Traits>
4120void basic_regex<_CharT, _Traits>::__push_match_any() {
4121 __end_->first() = new __match_any<_CharT>(__end_->first());
4122 __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
4123}
4124
4125template <class _CharT, class _Traits>
4126void basic_regex<_CharT, _Traits>::__push_match_any_but_newline() {
4127 __end_->first() = new __match_any_but_newline<_CharT>(__end_->first());
4128 __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
4129}
4130
4131template <class _CharT, class _Traits>
4132void basic_regex<_CharT, _Traits>::__push_empty() {
4133 __end_->first() = new __empty_state<_CharT>(__end_->first());
4134 __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
4135}
4136
4137template <class _CharT, class _Traits>
4138void basic_regex<_CharT, _Traits>::__push_word_boundary(bool __invert) {
4139 __end_->first() = new __word_boundary<_CharT, _Traits>(__traits_, __invert, __end_->first());
4140 __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
4141}
4142
4143template <class _CharT, class _Traits>
4144void basic_regex<_CharT, _Traits>::__push_back_ref(int __i) {
4145 if (flags() & icase)
4146 __end_->first() = new __back_ref_icase<_CharT, _Traits>(__traits_, __i, __end_->first());
4147 else if (flags() & collate)
4148 __end_->first() = new __back_ref_collate<_CharT, _Traits>(__traits_, __i, __end_->first());
4149 else
4150 __end_->first() = new __back_ref<_CharT>(__i, __end_->first());
4151 __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
4152}
4153
4154template <class _CharT, class _Traits>
4155void basic_regex<_CharT, _Traits>::__push_alternation(__owns_one_state<_CharT>* __sa, __owns_one_state<_CharT>* __ea) {
4156 __sa->first() = new __alternate<_CharT>(
4157 static_cast<__owns_one_state<_CharT>*>(__sa->first()), static_cast<__owns_one_state<_CharT>*>(__ea->first()));
4158 __ea->first() = nullptr;
4159 __ea->first() = new __empty_state<_CharT>(__end_->first());
4160 __end_->first() = nullptr;
4161 __end_->first() = new __empty_non_own_state<_CharT>(__ea->first());
4162 __end_ = static_cast<__owns_one_state<_CharT>*>(__ea->first());
4163}
4164
4165template <class _CharT, class _Traits>
4166__bracket_expression<_CharT, _Traits>* basic_regex<_CharT, _Traits>::__start_matching_list(bool __negate) {
4167 __bracket_expression<_CharT, _Traits>* __r = new __bracket_expression<_CharT, _Traits>(
4168 __traits_, __end_->first(), __negate, __flags_ & icase, __flags_ & collate);
4169 __end_->first() = __r;
4170 __end_ = __r;
4171 return __r;
4172}
4173
4174template <class _CharT, class _Traits>
4175void basic_regex<_CharT, _Traits>::__push_lookahead(const basic_regex& __exp, bool __invert, unsigned __mexp) {
4176 __end_->first() = new __lookahead<_CharT, _Traits>(__exp, __invert, __end_->first(), __mexp);
4177 __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
4178}
4179
4180// sub_match
4181
4182typedef sub_match<const char*> csub_match;
4183typedef sub_match<string::const_iterator> ssub_match;
4184#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
4185typedef sub_match<const wchar_t*> wcsub_match;
4186typedef sub_match<wstring::const_iterator> wssub_match;
4187#endif
4188
4189template <class _BidirectionalIterator>
4190class _LIBCPP_TEMPLATE_VIS _LIBCPP_PREFERRED_NAME(csub_match)
4191 _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wcsub_match)) _LIBCPP_PREFERRED_NAME(ssub_match)
4192 _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wssub_match)) sub_match
4193 : public pair<_BidirectionalIterator, _BidirectionalIterator> {
4194public:
4195 typedef _BidirectionalIterator iterator;
4196 typedef typename iterator_traits<iterator>::value_type value_type;
4197 typedef typename iterator_traits<iterator>::difference_type difference_type;
4198 typedef basic_string<value_type> string_type;
4199
4200 bool matched;
4201
4202 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR sub_match() : matched() {}
4203
4204 _LIBCPP_HIDE_FROM_ABI difference_type length() const {
4205 return matched ? std::distance(this->first, this->second) : 0;
4206 }
4207 _LIBCPP_HIDE_FROM_ABI string_type str() const {
4208 return matched ? string_type(this->first, this->second) : string_type();
4209 }
4210 _LIBCPP_HIDE_FROM_ABI operator string_type() const { return str(); }
4211
4212 _LIBCPP_HIDE_FROM_ABI int compare(const sub_match& __s) const { return str().compare(__s.str()); }
4213 _LIBCPP_HIDE_FROM_ABI int compare(const string_type& __s) const { return str().compare(__s); }
4214 _LIBCPP_HIDE_FROM_ABI int compare(const value_type* __s) const { return str().compare(__s); }
4215
4216 _LIBCPP_HIDE_FROM_ABI void swap(sub_match& __s) _NOEXCEPT_(__is_nothrow_swappable_v<_BidirectionalIterator>) {
4217 this->pair<_BidirectionalIterator, _BidirectionalIterator>::swap(__s);
4218 std::swap(matched, __s.matched);
4219 }
4220};
4221
4222template <class _BiIter>
4223inline _LIBCPP_HIDE_FROM_ABI bool operator==(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y) {
4224 return __x.compare(__y) == 0;
4225}
4226
4227#if _LIBCPP_STD_VER >= 20
4228template <class _BiIter>
4229using __sub_match_cat = compare_three_way_result_t<basic_string<typename iterator_traits<_BiIter>::value_type>>;
4230
4231template <class _BiIter>
4232_LIBCPP_HIDE_FROM_ABI auto operator<=>(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y) {
4233 return static_cast<__sub_match_cat<_BiIter>>(__x.compare(__y) <=> 0);
4234}
4235#else // _LIBCPP_STD_VER >= 20
4236template <class _BiIter>
4237inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y) {
4238 return !(__x == __y);
4239}
4240
4241template <class _BiIter>
4242inline _LIBCPP_HIDE_FROM_ABI bool operator<(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y) {
4243 return __x.compare(__y) < 0;
4244}
4245
4246template <class _BiIter>
4247inline _LIBCPP_HIDE_FROM_ABI bool operator<=(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y) {
4248 return !(__y < __x);
4249}
4250
4251template <class _BiIter>
4252inline _LIBCPP_HIDE_FROM_ABI bool operator>=(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y) {
4253 return !(__x < __y);
4254}
4255
4256template <class _BiIter>
4257inline _LIBCPP_HIDE_FROM_ABI bool operator>(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y) {
4258 return __y < __x;
4259}
4260
4261template <class _BiIter, class _ST, class _SA>
4262inline _LIBCPP_HIDE_FROM_ABI bool
4263operator==(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x,
4264 const sub_match<_BiIter>& __y) {
4265 return __y.compare(typename sub_match<_BiIter>::string_type(__x.data(), __x.size())) == 0;
4266}
4267
4268template <class _BiIter, class _ST, class _SA>
4269inline _LIBCPP_HIDE_FROM_ABI bool
4270operator!=(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x,
4271 const sub_match<_BiIter>& __y) {
4272 return !(__x == __y);
4273}
4274
4275template <class _BiIter, class _ST, class _SA>
4276inline _LIBCPP_HIDE_FROM_ABI bool
4277operator<(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x,
4278 const sub_match<_BiIter>& __y) {
4279 return __y.compare(typename sub_match<_BiIter>::string_type(__x.data(), __x.size())) > 0;
4280}
4281
4282template <class _BiIter, class _ST, class _SA>
4283inline _LIBCPP_HIDE_FROM_ABI bool
4284operator>(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x,
4285 const sub_match<_BiIter>& __y) {
4286 return __y < __x;
4287}
4288
4289template <class _BiIter, class _ST, class _SA>
4290inline _LIBCPP_HIDE_FROM_ABI bool
4291operator>=(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x,
4292 const sub_match<_BiIter>& __y) {
4293 return !(__x < __y);
4294}
4295
4296template <class _BiIter, class _ST, class _SA>
4297inline _LIBCPP_HIDE_FROM_ABI bool
4298operator<=(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x,
4299 const sub_match<_BiIter>& __y) {
4300 return !(__y < __x);
4301}
4302#endif // _LIBCPP_STD_VER >= 20
4303
4304template <class _BiIter, class _ST, class _SA>
4305inline _LIBCPP_HIDE_FROM_ABI bool
4306operator==(const sub_match<_BiIter>& __x,
4307 const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y) {
4308 return __x.compare(typename sub_match<_BiIter>::string_type(__y.data(), __y.size())) == 0;
4309}
4310
4311#if _LIBCPP_STD_VER >= 20
4312template <class _BiIter, class _ST, class _SA>
4313_LIBCPP_HIDE_FROM_ABI auto
4314operator<=>(const sub_match<_BiIter>& __x,
4315 const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y) {
4316 return static_cast<__sub_match_cat<_BiIter>>(
4317 __x.compare(typename sub_match<_BiIter>::string_type(__y.data(), __y.size())) <=> 0);
4318}
4319#else // _LIBCPP_STD_VER >= 20
4320template <class _BiIter, class _ST, class _SA>
4321inline _LIBCPP_HIDE_FROM_ABI bool
4322operator!=(const sub_match<_BiIter>& __x,
4323 const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y) {
4324 return !(__x == __y);
4325}
4326
4327template <class _BiIter, class _ST, class _SA>
4328inline _LIBCPP_HIDE_FROM_ABI bool
4329operator<(const sub_match<_BiIter>& __x,
4330 const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y) {
4331 return __x.compare(typename sub_match<_BiIter>::string_type(__y.data(), __y.size())) < 0;
4332}
4333
4334template <class _BiIter, class _ST, class _SA>
4335inline _LIBCPP_HIDE_FROM_ABI bool
4336operator>(const sub_match<_BiIter>& __x,
4337 const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y) {
4338 return __y < __x;
4339}
4340
4341template <class _BiIter, class _ST, class _SA>
4342inline _LIBCPP_HIDE_FROM_ABI bool
4343operator>=(const sub_match<_BiIter>& __x,
4344 const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y) {
4345 return !(__x < __y);
4346}
4347
4348template <class _BiIter, class _ST, class _SA>
4349inline _LIBCPP_HIDE_FROM_ABI bool
4350operator<=(const sub_match<_BiIter>& __x,
4351 const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y) {
4352 return !(__y < __x);
4353}
4354
4355template <class _BiIter>
4356inline _LIBCPP_HIDE_FROM_ABI bool
4357operator==(typename iterator_traits<_BiIter>::value_type const* __x, const sub_match<_BiIter>& __y) {
4358 return __y.compare(__x) == 0;
4359}
4360
4361template <class _BiIter>
4362inline _LIBCPP_HIDE_FROM_ABI bool
4363operator!=(typename iterator_traits<_BiIter>::value_type const* __x, const sub_match<_BiIter>& __y) {
4364 return !(__x == __y);
4365}
4366
4367template <class _BiIter>
4368inline _LIBCPP_HIDE_FROM_ABI bool
4369operator<(typename iterator_traits<_BiIter>::value_type const* __x, const sub_match<_BiIter>& __y) {
4370 return __y.compare(__x) > 0;
4371}
4372
4373template <class _BiIter>
4374inline _LIBCPP_HIDE_FROM_ABI bool
4375operator>(typename iterator_traits<_BiIter>::value_type const* __x, const sub_match<_BiIter>& __y) {
4376 return __y < __x;
4377}
4378
4379template <class _BiIter>
4380inline _LIBCPP_HIDE_FROM_ABI bool
4381operator>=(typename iterator_traits<_BiIter>::value_type const* __x, const sub_match<_BiIter>& __y) {
4382 return !(__x < __y);
4383}
4384
4385template <class _BiIter>
4386inline _LIBCPP_HIDE_FROM_ABI bool
4387operator<=(typename iterator_traits<_BiIter>::value_type const* __x, const sub_match<_BiIter>& __y) {
4388 return !(__y < __x);
4389}
4390#endif // _LIBCPP_STD_VER >= 20
4391
4392template <class _BiIter>
4393inline _LIBCPP_HIDE_FROM_ABI bool
4394operator==(const sub_match<_BiIter>& __x, typename iterator_traits<_BiIter>::value_type const* __y) {
4395 return __x.compare(__y) == 0;
4396}
4397
4398#if _LIBCPP_STD_VER >= 20
4399template <class _BiIter>
4400_LIBCPP_HIDE_FROM_ABI auto
4401operator<=>(const sub_match<_BiIter>& __x, typename iterator_traits<_BiIter>::value_type const* __y) {
4402 return static_cast<__sub_match_cat<_BiIter>>(__x.compare(__y) <=> 0);
4403}
4404#else // _LIBCPP_STD_VER >= 20
4405template <class _BiIter>
4406inline _LIBCPP_HIDE_FROM_ABI bool
4407operator!=(const sub_match<_BiIter>& __x, typename iterator_traits<_BiIter>::value_type const* __y) {
4408 return !(__x == __y);
4409}
4410
4411template <class _BiIter>
4412inline _LIBCPP_HIDE_FROM_ABI bool
4413operator<(const sub_match<_BiIter>& __x, typename iterator_traits<_BiIter>::value_type const* __y) {
4414 return __x.compare(__y) < 0;
4415}
4416
4417template <class _BiIter>
4418inline _LIBCPP_HIDE_FROM_ABI bool
4419operator>(const sub_match<_BiIter>& __x, typename iterator_traits<_BiIter>::value_type const* __y) {
4420 return __y < __x;
4421}
4422
4423template <class _BiIter>
4424inline _LIBCPP_HIDE_FROM_ABI bool
4425operator>=(const sub_match<_BiIter>& __x, typename iterator_traits<_BiIter>::value_type const* __y) {
4426 return !(__x < __y);
4427}
4428
4429template <class _BiIter>
4430inline _LIBCPP_HIDE_FROM_ABI bool
4431operator<=(const sub_match<_BiIter>& __x, typename iterator_traits<_BiIter>::value_type const* __y) {
4432 return !(__y < __x);
4433}
4434
4435template <class _BiIter>
4436inline _LIBCPP_HIDE_FROM_ABI bool
4437operator==(typename iterator_traits<_BiIter>::value_type const& __x, const sub_match<_BiIter>& __y) {
4438 typedef basic_string<typename iterator_traits<_BiIter>::value_type> string_type;
4439 return __y.compare(string_type(1, __x)) == 0;
4440}
4441
4442template <class _BiIter>
4443inline _LIBCPP_HIDE_FROM_ABI bool
4444operator!=(typename iterator_traits<_BiIter>::value_type const& __x, const sub_match<_BiIter>& __y) {
4445 return !(__x == __y);
4446}
4447
4448template <class _BiIter>
4449inline _LIBCPP_HIDE_FROM_ABI bool
4450operator<(typename iterator_traits<_BiIter>::value_type const& __x, const sub_match<_BiIter>& __y) {
4451 typedef basic_string<typename iterator_traits<_BiIter>::value_type> string_type;
4452 return __y.compare(string_type(1, __x)) > 0;
4453}
4454
4455template <class _BiIter>
4456inline _LIBCPP_HIDE_FROM_ABI bool
4457operator>(typename iterator_traits<_BiIter>::value_type const& __x, const sub_match<_BiIter>& __y) {
4458 return __y < __x;
4459}
4460
4461template <class _BiIter>
4462inline _LIBCPP_HIDE_FROM_ABI bool
4463operator>=(typename iterator_traits<_BiIter>::value_type const& __x, const sub_match<_BiIter>& __y) {
4464 return !(__x < __y);
4465}
4466
4467template <class _BiIter>
4468inline _LIBCPP_HIDE_FROM_ABI bool
4469operator<=(typename iterator_traits<_BiIter>::value_type const& __x, const sub_match<_BiIter>& __y) {
4470 return !(__y < __x);
4471}
4472#endif // _LIBCPP_STD_VER >= 20
4473
4474template <class _BiIter>
4475inline _LIBCPP_HIDE_FROM_ABI bool
4476operator==(const sub_match<_BiIter>& __x, typename iterator_traits<_BiIter>::value_type const& __y) {
4477 typedef basic_string<typename iterator_traits<_BiIter>::value_type> string_type;
4478 return __x.compare(string_type(1, __y)) == 0;
4479}
4480
4481#if _LIBCPP_STD_VER >= 20
4482template <class _BiIter>
4483_LIBCPP_HIDE_FROM_ABI auto
4484operator<=>(const sub_match<_BiIter>& __x, typename iterator_traits<_BiIter>::value_type const& __y) {
4485 using string_type = basic_string<typename iterator_traits<_BiIter>::value_type>;
4486 return static_cast<__sub_match_cat<_BiIter>>(__x.compare(string_type(1, __y)) <=> 0);
4487}
4488#else // _LIBCPP_STD_VER >= 20
4489template <class _BiIter>
4490inline _LIBCPP_HIDE_FROM_ABI bool
4491operator!=(const sub_match<_BiIter>& __x, typename iterator_traits<_BiIter>::value_type const& __y) {
4492 return !(__x == __y);
4493}
4494
4495template <class _BiIter>
4496inline _LIBCPP_HIDE_FROM_ABI bool
4497operator<(const sub_match<_BiIter>& __x, typename iterator_traits<_BiIter>::value_type const& __y) {
4498 typedef basic_string<typename iterator_traits<_BiIter>::value_type> string_type;
4499 return __x.compare(string_type(1, __y)) < 0;
4500}
4501
4502template <class _BiIter>
4503inline _LIBCPP_HIDE_FROM_ABI bool
4504operator>(const sub_match<_BiIter>& __x, typename iterator_traits<_BiIter>::value_type const& __y) {
4505 return __y < __x;
4506}
4507
4508template <class _BiIter>
4509inline _LIBCPP_HIDE_FROM_ABI bool
4510operator>=(const sub_match<_BiIter>& __x, typename iterator_traits<_BiIter>::value_type const& __y) {
4511 return !(__x < __y);
4512}
4513
4514template <class _BiIter>
4515inline _LIBCPP_HIDE_FROM_ABI bool
4516operator<=(const sub_match<_BiIter>& __x, typename iterator_traits<_BiIter>::value_type const& __y) {
4517 return !(__y < __x);
4518}
4519#endif // _LIBCPP_STD_VER >= 20
4520
4521template <class _CharT, class _ST, class _BiIter>
4522inline _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _ST>&
4523operator<<(basic_ostream<_CharT, _ST>& __os, const sub_match<_BiIter>& __m) {
4524 return __os << __m.str();
4525}
4526
4527typedef match_results<const char*> cmatch;
4528typedef match_results<string::const_iterator> smatch;
4529#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
4530typedef match_results<const wchar_t*> wcmatch;
4531typedef match_results<wstring::const_iterator> wsmatch;
4532#endif
4533
4534template <class _BidirectionalIterator, class _Allocator>
4535class _LIBCPP_TEMPLATE_VIS _LIBCPP_PREFERRED_NAME(cmatch) _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wcmatch))
4536 _LIBCPP_PREFERRED_NAME(smatch) _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wsmatch)) match_results {
4537public:
4538 typedef _Allocator allocator_type;
4539 typedef sub_match<_BidirectionalIterator> value_type;
4540
4541private:
4542 typedef vector<value_type, allocator_type> __container_type;
4543
4544 __container_type __matches_;
4545 value_type __unmatched_;
4546 value_type __prefix_;
4547 value_type __suffix_;
4548 bool __ready_;
4549
4550public:
4551 _BidirectionalIterator __position_start_;
4552 typedef const value_type& const_reference;
4553 typedef value_type& reference;
4554 typedef typename __container_type::const_iterator const_iterator;
4555 typedef const_iterator iterator;
4556 typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type;
4557 typedef typename allocator_traits<allocator_type>::size_type size_type;
4558 typedef typename iterator_traits<_BidirectionalIterator>::value_type char_type;
4559 typedef basic_string<char_type> string_type;
4560
4561 // construct/copy/destroy:
4562#ifndef _LIBCPP_CXX03_LANG
4563 match_results() : match_results(allocator_type()) {}
4564 explicit match_results(const allocator_type& __a);
4565#else
4566 explicit match_results(const allocator_type& __a = allocator_type());
4567#endif
4568
4569 // match_results(const match_results&) = default;
4570 // match_results& operator=(const match_results&) = default;
4571 // match_results(match_results&& __m) = default;
4572 // match_results& operator=(match_results&& __m) = default;
4573 // ~match_results() = default;
4574
4575 _LIBCPP_HIDE_FROM_ABI bool ready() const { return __ready_; }
4576
4577 // size:
4578 _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __matches_.size(); }
4579 _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT { return __matches_.max_size(); }
4580 _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI bool empty() const _NOEXCEPT { return size() == 0; }
4581
4582 // element access:
4583 _LIBCPP_HIDE_FROM_ABI difference_type length(size_type __sub = 0) const {
4584 // If the match results are not ready, this will return `0`.
4585 _LIBCPP_ASSERT_PEDANTIC(ready(), "match_results::length() called when not ready");
4586 return (*this)[__sub].length();
4587 }
4588 _LIBCPP_HIDE_FROM_ABI difference_type position(size_type __sub = 0) const {
4589 // If the match results are not ready, this will return the result of subtracting two default-constructed iterators
4590 // (which is typically a well-defined operation).
4591 _LIBCPP_ASSERT_PEDANTIC(ready(), "match_results::position() called when not ready");
4592 return std::distance(__position_start_, (*this)[__sub].first);
4593 }
4594 _LIBCPP_HIDE_FROM_ABI string_type str(size_type __sub = 0) const {
4595 // If the match results are not ready, this will return an empty string.
4596 _LIBCPP_ASSERT_PEDANTIC(ready(), "match_results::str() called when not ready");
4597 return (*this)[__sub].str();
4598 }
4599 _LIBCPP_HIDE_FROM_ABI const_reference operator[](size_type __n) const {
4600 // If the match results are not ready, this call will be equivalent to calling this function with `__n >= size()`,
4601 // returning an empty subrange.
4602 _LIBCPP_ASSERT_PEDANTIC(ready(), "match_results::operator[]() called when not ready");
4603 return __n < __matches_.size() ? __matches_[__n] : __unmatched_;
4604 }
4605
4606 _LIBCPP_HIDE_FROM_ABI const_reference prefix() const {
4607 // If the match results are not ready, this will return a default-constructed empty `__suffix_`.
4608 _LIBCPP_ASSERT_PEDANTIC(ready(), "match_results::prefix() called when not ready");
4609 return __prefix_;
4610 }
4611 _LIBCPP_HIDE_FROM_ABI const_reference suffix() const {
4612 // If the match results are not ready, this will return a default-constructed empty `__suffix_`.
4613 _LIBCPP_ASSERT_PEDANTIC(ready(), "match_results::suffix() called when not ready");
4614 return __suffix_;
4615 }
4616
4617 _LIBCPP_HIDE_FROM_ABI const_iterator begin() const { return empty() ? __matches_.end() : __matches_.begin(); }
4618 _LIBCPP_HIDE_FROM_ABI const_iterator end() const { return __matches_.end(); }
4619 _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const { return empty() ? __matches_.end() : __matches_.begin(); }
4620 _LIBCPP_HIDE_FROM_ABI const_iterator cend() const { return __matches_.end(); }
4621
4622 // format:
4623 template <class _OutputIter>
4624 _OutputIter format(_OutputIter __output_iter,
4625 const char_type* __fmt_first,
4626 const char_type* __fmt_last,
4627 regex_constants::match_flag_type __flags = regex_constants::format_default) const;
4628 template <class _OutputIter, class _ST, class _SA>
4629 _LIBCPP_HIDE_FROM_ABI _OutputIter
4630 format(_OutputIter __output_iter,
4631 const basic_string<char_type, _ST, _SA>& __fmt,
4632 regex_constants::match_flag_type __flags = regex_constants::format_default) const {
4633 return format(__output_iter, __fmt.data(), __fmt.data() + __fmt.size(), __flags);
4634 }
4635 template <class _ST, class _SA>
4636 _LIBCPP_HIDE_FROM_ABI basic_string<char_type, _ST, _SA>
4637 format(const basic_string<char_type, _ST, _SA>& __fmt,
4638 regex_constants::match_flag_type __flags = regex_constants::format_default) const {
4639 basic_string<char_type, _ST, _SA> __r;
4640 format(std::back_inserter(__r), __fmt.data(), __fmt.data() + __fmt.size(), __flags);
4641 return __r;
4642 }
4643 _LIBCPP_HIDE_FROM_ABI string_type
4644 format(const char_type* __fmt, regex_constants::match_flag_type __flags = regex_constants::format_default) const {
4645 string_type __r;
4646 format(std::back_inserter(__r), __fmt, __fmt + char_traits<char_type>::length(__fmt), __flags);
4647 return __r;
4648 }
4649
4650 // allocator:
4651 _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const { return __matches_.get_allocator(); }
4652
4653 // swap:
4654 void swap(match_results& __m);
4655
4656 template <class _Bp, class _Ap>
4657 _LIBCPP_HIDE_FROM_ABI void
4658 __assign(_BidirectionalIterator __f,
4659 _BidirectionalIterator __l,
4660 const match_results<_Bp, _Ap>& __m,
4661 bool __no_update_pos) {
4662 _Bp __mf = __m.prefix().first;
4663 __matches_.resize(__m.size());
4664 for (size_type __i = 0; __i < __matches_.size(); ++__i) {
4665 __matches_[__i].first = std::next(__f, std::distance(__mf, __m[__i].first));
4666 __matches_[__i].second = std::next(__f, std::distance(__mf, __m[__i].second));
4667 __matches_[__i].matched = __m[__i].matched;
4668 }
4669 __unmatched_.first = __l;
4670 __unmatched_.second = __l;
4671 __unmatched_.matched = false;
4672 __prefix_.first = std::next(__f, std::distance(__mf, __m.prefix().first));
4673 __prefix_.second = std::next(__f, std::distance(__mf, __m.prefix().second));
4674 __prefix_.matched = __m.prefix().matched;
4675 __suffix_.first = std::next(__f, std::distance(__mf, __m.suffix().first));
4676 __suffix_.second = std::next(__f, std::distance(__mf, __m.suffix().second));
4677 __suffix_.matched = __m.suffix().matched;
4678 if (!__no_update_pos)
4679 __position_start_ = __prefix_.first;
4680 __ready_ = __m.ready();
4681 }
4682
4683private:
4684 void __init(unsigned __s, _BidirectionalIterator __f, _BidirectionalIterator __l, bool __no_update_pos = false);
4685
4686 template <class, class>
4687 friend class basic_regex;
4688
4689 template <class _Bp, class _Ap, class _Cp, class _Tp>
4690 friend bool
4691 regex_match(_Bp, _Bp, match_results<_Bp, _Ap>&, const basic_regex<_Cp, _Tp>&, regex_constants::match_flag_type);
4692
4693 template <class _Bp, class _Ap>
4694 friend bool operator==(const match_results<_Bp, _Ap>&, const match_results<_Bp, _Ap>&);
4695
4696 template <class, class>
4697 friend class __lookahead;
4698
4699 template <class, class, class>
4700 friend class regex_iterator;
4701};
4702
4703template <class _BidirectionalIterator, class _Allocator>
4704match_results<_BidirectionalIterator, _Allocator>::match_results(const allocator_type& __a)
4705 : __matches_(__a), __unmatched_(), __prefix_(), __suffix_(), __ready_(false), __position_start_() {}
4706
4707template <class _BidirectionalIterator, class _Allocator>
4708void match_results<_BidirectionalIterator, _Allocator>::__init(
4709 unsigned __s, _BidirectionalIterator __f, _BidirectionalIterator __l, bool __no_update_pos) {
4710 __unmatched_.first = __l;
4711 __unmatched_.second = __l;
4712 __unmatched_.matched = false;
4713 __matches_.assign(__s, __unmatched_);
4714 __prefix_.first = __f;
4715 __prefix_.second = __f;
4716 __prefix_.matched = false;
4717 __suffix_ = __unmatched_;
4718 if (!__no_update_pos)
4719 __position_start_ = __prefix_.first;
4720 __ready_ = true;
4721}
4722
4723template <class _BidirectionalIterator, class _Allocator>
4724template <class _OutputIter>
4725_OutputIter match_results<_BidirectionalIterator, _Allocator>::format(
4726 _OutputIter __output_iter,
4727 const char_type* __fmt_first,
4728 const char_type* __fmt_last,
4729 regex_constants::match_flag_type __flags) const {
4730 // Note: this duplicates a check in `vector::operator[]` but provides a better error message.
4731 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(ready(), "match_results::format() called when not ready");
4732 if (__flags & regex_constants::format_sed) {
4733 for (; __fmt_first != __fmt_last; ++__fmt_first) {
4734 if (*__fmt_first == '&')
4735 __output_iter = std::copy(__matches_[0].first, __matches_[0].second, __output_iter);
4736 else if (*__fmt_first == '\\' && __fmt_first + 1 != __fmt_last) {
4737 ++__fmt_first;
4738 if ('0' <= *__fmt_first && *__fmt_first <= '9') {
4739 size_t __i = *__fmt_first - '0';
4740 __output_iter = std::copy((*this)[__i].first, (*this)[__i].second, __output_iter);
4741 } else {
4742 *__output_iter = *__fmt_first;
4743 ++__output_iter;
4744 }
4745 } else {
4746 *__output_iter = *__fmt_first;
4747 ++__output_iter;
4748 }
4749 }
4750 } else {
4751 for (; __fmt_first != __fmt_last; ++__fmt_first) {
4752 if (*__fmt_first == '$' && __fmt_first + 1 != __fmt_last) {
4753 switch (__fmt_first[1]) {
4754 case '$':
4755 *__output_iter = *++__fmt_first;
4756 ++__output_iter;
4757 break;
4758 case '&':
4759 ++__fmt_first;
4760 __output_iter = std::copy(__matches_[0].first, __matches_[0].second, __output_iter);
4761 break;
4762 case '`':
4763 ++__fmt_first;
4764 __output_iter = std::copy(__prefix_.first, __prefix_.second, __output_iter);
4765 break;
4766 case '\'':
4767 ++__fmt_first;
4768 __output_iter = std::copy(__suffix_.first, __suffix_.second, __output_iter);
4769 break;
4770 default:
4771 if ('0' <= __fmt_first[1] && __fmt_first[1] <= '9') {
4772 ++__fmt_first;
4773 size_t __idx = *__fmt_first - '0';
4774 if (__fmt_first + 1 != __fmt_last && '0' <= __fmt_first[1] && __fmt_first[1] <= '9') {
4775 ++__fmt_first;
4776 if (__idx >= numeric_limits<size_t>::max() / 10)
4777 __throw_regex_error<regex_constants::error_escape>();
4778 __idx = 10 * __idx + *__fmt_first - '0';
4779 }
4780 __output_iter = std::copy((*this)[__idx].first, (*this)[__idx].second, __output_iter);
4781 } else {
4782 *__output_iter = *__fmt_first;
4783 ++__output_iter;
4784 }
4785 break;
4786 }
4787 } else {
4788 *__output_iter = *__fmt_first;
4789 ++__output_iter;
4790 }
4791 }
4792 }
4793 return __output_iter;
4794}
4795
4796template <class _BidirectionalIterator, class _Allocator>
4797void match_results<_BidirectionalIterator, _Allocator>::swap(match_results& __m) {
4798 using std::swap;
4799 swap(__matches_, __m.__matches_);
4800 swap(__unmatched_, __m.__unmatched_);
4801 swap(__prefix_, __m.__prefix_);
4802 swap(__suffix_, __m.__suffix_);
4803 swap(__position_start_, __m.__position_start_);
4804 swap(__ready_, __m.__ready_);
4805}
4806
4807template <class _BidirectionalIterator, class _Allocator>
4808_LIBCPP_HIDE_FROM_ABI bool operator==(const match_results<_BidirectionalIterator, _Allocator>& __x,
4809 const match_results<_BidirectionalIterator, _Allocator>& __y) {
4810 if (__x.__ready_ != __y.__ready_)
4811 return false;
4812 if (!__x.__ready_)
4813 return true;
4814 return __x.__matches_ == __y.__matches_ && __x.__prefix_ == __y.__prefix_ && __x.__suffix_ == __y.__suffix_;
4815}
4816
4817#if _LIBCPP_STD_VER < 20
4818template <class _BidirectionalIterator, class _Allocator>
4819inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const match_results<_BidirectionalIterator, _Allocator>& __x,
4820 const match_results<_BidirectionalIterator, _Allocator>& __y) {
4821 return !(__x == __y);
4822}
4823#endif
4824
4825template <class _BidirectionalIterator, class _Allocator>
4826inline _LIBCPP_HIDE_FROM_ABI void
4827swap(match_results<_BidirectionalIterator, _Allocator>& __x, match_results<_BidirectionalIterator, _Allocator>& __y) {
4828 __x.swap(__y);
4829}
4830
4831// regex_search
4832
4833template <class _CharT, class _Traits>
4834template <class _Allocator>
4835bool basic_regex<_CharT, _Traits>::__match_at_start_ecma(
4836 const _CharT* __first,
4837 const _CharT* __last,
4838 match_results<const _CharT*, _Allocator>& __m,
4839 regex_constants::match_flag_type __flags,
4840 bool __at_first) const {
4841 vector<__state> __states;
4842 __node* __st = __start_.get();
4843 if (__st) {
4844 sub_match<const _CharT*> __unmatched;
4845 __unmatched.first = __last;
4846 __unmatched.second = __last;
4847 __unmatched.matched = false;
4848
4849 __states.push_back(__state());
4850 __states.back().__do_ = 0;
4851 __states.back().__first_ = __first;
4852 __states.back().__current_ = __first;
4853 __states.back().__last_ = __last;
4854 __states.back().__sub_matches_.resize(mark_count(), __unmatched);
4855 __states.back().__loop_data_.resize(__loop_count());
4856 __states.back().__node_ = __st;
4857 __states.back().__flags_ = __flags;
4858 __states.back().__at_first_ = __at_first;
4859 int __counter = 0;
4860 int __length = __last - __first;
4861 do {
4862 ++__counter;
4863 if (__counter % _LIBCPP_REGEX_COMPLEXITY_FACTOR == 0 && __counter / _LIBCPP_REGEX_COMPLEXITY_FACTOR >= __length)
4864 __throw_regex_error<regex_constants::error_complexity>();
4865 __state& __s = __states.back();
4866 if (__s.__node_)
4867 __s.__node_->__exec(__s);
4868 switch (__s.__do_) {
4869 case __state::__end_state:
4870 if ((__flags & regex_constants::match_not_null) && __s.__current_ == __first) {
4871 __states.pop_back();
4872 break;
4873 }
4874 if ((__flags & regex_constants::__full_match) && __s.__current_ != __last) {
4875 __states.pop_back();
4876 break;
4877 }
4878 __m.__matches_[0].first = __first;
4879 __m.__matches_[0].second = std::next(__first, __s.__current_ - __first);
4880 __m.__matches_[0].matched = true;
4881 for (unsigned __i = 0; __i < __s.__sub_matches_.size(); ++__i)
4882 __m.__matches_[__i + 1] = __s.__sub_matches_[__i];
4883 return true;
4884 case __state::__accept_and_consume:
4885 case __state::__repeat:
4886 case __state::__accept_but_not_consume:
4887 break;
4888 case __state::__split: {
4889 __state __snext = __s;
4890 __s.__node_->__exec_split(true, __s);
4891 __snext.__node_->__exec_split(false, __snext);
4892 __states.push_back(std::move(__snext));
4893 } break;
4894 case __state::__reject:
4895 __states.pop_back();
4896 break;
4897 default:
4898 __throw_regex_error<regex_constants::__re_err_unknown>();
4899 break;
4900 }
4901 } while (!__states.empty());
4902 }
4903 return false;
4904}
4905
4906template <class _CharT, class _Traits>
4907template <class _Allocator>
4908bool basic_regex<_CharT, _Traits>::__match_at_start_posix_nosubs(
4909 const _CharT* __first,
4910 const _CharT* __last,
4911 match_results<const _CharT*, _Allocator>& __m,
4912 regex_constants::match_flag_type __flags,
4913 bool __at_first) const {
4914 deque<__state> __states;
4915 ptrdiff_t __highest_j = 0;
4916 ptrdiff_t __np = std::distance(__first, __last);
4917 __node* __st = __start_.get();
4918 if (__st) {
4919 __states.push_back(__state());
4920 __states.back().__do_ = 0;
4921 __states.back().__first_ = __first;
4922 __states.back().__current_ = __first;
4923 __states.back().__last_ = __last;
4924 __states.back().__loop_data_.resize(__loop_count());
4925 __states.back().__node_ = __st;
4926 __states.back().__flags_ = __flags;
4927 __states.back().__at_first_ = __at_first;
4928 bool __matched = false;
4929 int __counter = 0;
4930 int __length = __last - __first;
4931 do {
4932 ++__counter;
4933 if (__counter % _LIBCPP_REGEX_COMPLEXITY_FACTOR == 0 && __counter / _LIBCPP_REGEX_COMPLEXITY_FACTOR >= __length)
4934 __throw_regex_error<regex_constants::error_complexity>();
4935 __state& __s = __states.back();
4936 if (__s.__node_)
4937 __s.__node_->__exec(__s);
4938 switch (__s.__do_) {
4939 case __state::__end_state:
4940 if ((__flags & regex_constants::match_not_null) && __s.__current_ == __first) {
4941 __states.pop_back();
4942 break;
4943 }
4944 if ((__flags & regex_constants::__full_match) && __s.__current_ != __last) {
4945 __states.pop_back();
4946 break;
4947 }
4948 if (!__matched || __highest_j < __s.__current_ - __s.__first_)
4949 __highest_j = __s.__current_ - __s.__first_;
4950 __matched = true;
4951 if (__highest_j == __np)
4952 __states.clear();
4953 else
4954 __states.pop_back();
4955 break;
4956 case __state::__consume_input:
4957 break;
4958 case __state::__accept_and_consume:
4959 __states.push_front(std::move(__s));
4960 __states.pop_back();
4961 break;
4962 case __state::__repeat:
4963 case __state::__accept_but_not_consume:
4964 break;
4965 case __state::__split: {
4966 __state __snext = __s;
4967 __s.__node_->__exec_split(true, __s);
4968 __snext.__node_->__exec_split(false, __snext);
4969 __states.push_back(std::move(__snext));
4970 } break;
4971 case __state::__reject:
4972 __states.pop_back();
4973 break;
4974 default:
4975 __throw_regex_error<regex_constants::__re_err_unknown>();
4976 break;
4977 }
4978 } while (!__states.empty());
4979 if (__matched) {
4980 __m.__matches_[0].first = __first;
4981 __m.__matches_[0].second = std::next(__first, __highest_j);
4982 __m.__matches_[0].matched = true;
4983 return true;
4984 }
4985 }
4986 return false;
4987}
4988
4989template <class _CharT, class _Traits>
4990template <class _Allocator>
4991bool basic_regex<_CharT, _Traits>::__match_at_start_posix_subs(
4992 const _CharT* __first,
4993 const _CharT* __last,
4994 match_results<const _CharT*, _Allocator>& __m,
4995 regex_constants::match_flag_type __flags,
4996 bool __at_first) const {
4997 vector<__state> __states;
4998 __state __best_state;
4999 ptrdiff_t __highest_j = 0;
5000 ptrdiff_t __np = std::distance(__first, __last);
5001 __node* __st = __start_.get();
5002 if (__st) {
5003 sub_match<const _CharT*> __unmatched;
5004 __unmatched.first = __last;
5005 __unmatched.second = __last;
5006 __unmatched.matched = false;
5007
5008 __states.push_back(__state());
5009 __states.back().__do_ = 0;
5010 __states.back().__first_ = __first;
5011 __states.back().__current_ = __first;
5012 __states.back().__last_ = __last;
5013 __states.back().__sub_matches_.resize(mark_count(), __unmatched);
5014 __states.back().__loop_data_.resize(__loop_count());
5015 __states.back().__node_ = __st;
5016 __states.back().__flags_ = __flags;
5017 __states.back().__at_first_ = __at_first;
5018 bool __matched = false;
5019 int __counter = 0;
5020 int __length = __last - __first;
5021 do {
5022 ++__counter;
5023 if (__counter % _LIBCPP_REGEX_COMPLEXITY_FACTOR == 0 && __counter / _LIBCPP_REGEX_COMPLEXITY_FACTOR >= __length)
5024 __throw_regex_error<regex_constants::error_complexity>();
5025 __state& __s = __states.back();
5026 if (__s.__node_)
5027 __s.__node_->__exec(__s);
5028 switch (__s.__do_) {
5029 case __state::__end_state:
5030 if ((__flags & regex_constants::match_not_null) && __s.__current_ == __first) {
5031 __states.pop_back();
5032 break;
5033 }
5034 if ((__flags & regex_constants::__full_match) && __s.__current_ != __last) {
5035 __states.pop_back();
5036 break;
5037 }
5038 if (!__matched || __highest_j < __s.__current_ - __s.__first_) {
5039 __highest_j = __s.__current_ - __s.__first_;
5040 __best_state = __s;
5041 }
5042 __matched = true;
5043 if (__highest_j == __np)
5044 __states.clear();
5045 else
5046 __states.pop_back();
5047 break;
5048 case __state::__accept_and_consume:
5049 case __state::__repeat:
5050 case __state::__accept_but_not_consume:
5051 break;
5052 case __state::__split: {
5053 __state __snext = __s;
5054 __s.__node_->__exec_split(true, __s);
5055 __snext.__node_->__exec_split(false, __snext);
5056 __states.push_back(std::move(__snext));
5057 } break;
5058 case __state::__reject:
5059 __states.pop_back();
5060 break;
5061 default:
5062 __throw_regex_error<regex_constants::__re_err_unknown>();
5063 break;
5064 }
5065 } while (!__states.empty());
5066 if (__matched) {
5067 __m.__matches_[0].first = __first;
5068 __m.__matches_[0].second = std::next(__first, __highest_j);
5069 __m.__matches_[0].matched = true;
5070 for (unsigned __i = 0; __i < __best_state.__sub_matches_.size(); ++__i)
5071 __m.__matches_[__i + 1] = __best_state.__sub_matches_[__i];
5072 return true;
5073 }
5074 }
5075 return false;
5076}
5077
5078template <class _CharT, class _Traits>
5079template <class _Allocator>
5080bool basic_regex<_CharT, _Traits>::__match_at_start(
5081 const _CharT* __first,
5082 const _CharT* __last,
5083 match_results<const _CharT*, _Allocator>& __m,
5084 regex_constants::match_flag_type __flags,
5085 bool __at_first) const {
5086 if (__get_grammar(__flags_) == ECMAScript)
5087 return __match_at_start_ecma(__first, __last, __m, __flags, __at_first);
5088 if (mark_count() == 0)
5089 return __match_at_start_posix_nosubs(__first, __last, __m, __flags, __at_first);
5090 return __match_at_start_posix_subs(__first, __last, __m, __flags, __at_first);
5091}
5092
5093template <class _CharT, class _Traits>
5094template <class _Allocator>
5095bool basic_regex<_CharT, _Traits>::__search(
5096 const _CharT* __first,
5097 const _CharT* __last,
5098 match_results<const _CharT*, _Allocator>& __m,
5099 regex_constants::match_flag_type __flags) const {
5100 if (__flags & regex_constants::match_prev_avail)
5101 __flags &= ~(regex_constants::match_not_bol | regex_constants::match_not_bow);
5102
5103 __m.__init(1 + mark_count(), __first, __last, __flags & regex_constants::__no_update_pos);
5104 if (__match_at_start(__first, __last, __m, __flags, !(__flags & regex_constants::__no_update_pos))) {
5105 __m.__prefix_.second = __m[0].first;
5106 __m.__prefix_.matched = __m.__prefix_.first != __m.__prefix_.second;
5107 __m.__suffix_.first = __m[0].second;
5108 __m.__suffix_.matched = __m.__suffix_.first != __m.__suffix_.second;
5109 return true;
5110 }
5111 if (__first != __last && !(__flags & regex_constants::match_continuous)) {
5112 __flags |= regex_constants::match_prev_avail;
5113 for (++__first; __first != __last; ++__first) {
5114 __m.__matches_.assign(__m.size(), __m.__unmatched_);
5115 if (__match_at_start(__first, __last, __m, __flags, false)) {
5116 __m.__prefix_.second = __m[0].first;
5117 __m.__prefix_.matched = __m.__prefix_.first != __m.__prefix_.second;
5118 __m.__suffix_.first = __m[0].second;
5119 __m.__suffix_.matched = __m.__suffix_.first != __m.__suffix_.second;
5120 return true;
5121 }
5122 __m.__matches_.assign(__m.size(), __m.__unmatched_);
5123 }
5124 __m.__matches_.assign(__m.size(), __m.__unmatched_);
5125 if (__match_at_start(__first, __last, __m, __flags, false)) {
5126 __m.__prefix_.second = __m[0].first;
5127 __m.__prefix_.matched = __m.__prefix_.first != __m.__prefix_.second;
5128 __m.__suffix_.first = __m[0].second;
5129 __m.__suffix_.matched = __m.__suffix_.first != __m.__suffix_.second;
5130 return true;
5131 }
5132 }
5133 __m.__matches_.clear();
5134 return false;
5135}
5136
5137template <class _BidirectionalIterator, class _Allocator, class _CharT, class _Traits>
5138inline _LIBCPP_HIDE_FROM_ABI bool
5139regex_search(_BidirectionalIterator __first,
5140 _BidirectionalIterator __last,
5141 match_results<_BidirectionalIterator, _Allocator>& __m,
5142 const basic_regex<_CharT, _Traits>& __e,
5143 regex_constants::match_flag_type __flags = regex_constants::match_default) {
5144 int __offset = (__flags & regex_constants::match_prev_avail) ? 1 : 0;
5145 basic_string<_CharT> __s(std::prev(__first, __offset), __last);
5146 match_results<const _CharT*> __mc;
5147 bool __r = __e.__search(__s.data() + __offset, __s.data() + __s.size(), __mc, __flags);
5148 __m.__assign(__first, __last, __mc, __flags & regex_constants::__no_update_pos);
5149 return __r;
5150}
5151
5152template <class _Iter, class _Allocator, class _CharT, class _Traits>
5153inline _LIBCPP_HIDE_FROM_ABI bool
5154regex_search(__wrap_iter<_Iter> __first,
5155 __wrap_iter<_Iter> __last,
5156 match_results<__wrap_iter<_Iter>, _Allocator>& __m,
5157 const basic_regex<_CharT, _Traits>& __e,
5158 regex_constants::match_flag_type __flags = regex_constants::match_default) {
5159 match_results<const _CharT*> __mc;
5160 bool __r = __e.__search(__first.base(), __last.base(), __mc, __flags);
5161 __m.__assign(__first, __last, __mc, __flags & regex_constants::__no_update_pos);
5162 return __r;
5163}
5164
5165template <class _Allocator, class _CharT, class _Traits>
5166inline _LIBCPP_HIDE_FROM_ABI bool
5167regex_search(const _CharT* __first,
5168 const _CharT* __last,
5169 match_results<const _CharT*, _Allocator>& __m,
5170 const basic_regex<_CharT, _Traits>& __e,
5171 regex_constants::match_flag_type __flags = regex_constants::match_default) {
5172 return __e.__search(__first, __last, __m, __flags);
5173}
5174
5175template <class _BidirectionalIterator, class _CharT, class _Traits>
5176inline _LIBCPP_HIDE_FROM_ABI bool
5177regex_search(_BidirectionalIterator __first,
5178 _BidirectionalIterator __last,
5179 const basic_regex<_CharT, _Traits>& __e,
5180 regex_constants::match_flag_type __flags = regex_constants::match_default) {
5181 basic_string<_CharT> __s(__first, __last);
5182 match_results<const _CharT*> __mc;
5183 return __e.__search(__s.data(), __s.data() + __s.size(), __mc, __flags);
5184}
5185
5186template <class _CharT, class _Traits>
5187inline _LIBCPP_HIDE_FROM_ABI bool
5188regex_search(const _CharT* __first,
5189 const _CharT* __last,
5190 const basic_regex<_CharT, _Traits>& __e,
5191 regex_constants::match_flag_type __flags = regex_constants::match_default) {
5192 match_results<const _CharT*> __mc;
5193 return __e.__search(__first, __last, __mc, __flags);
5194}
5195
5196template <class _CharT, class _Allocator, class _Traits>
5197inline _LIBCPP_HIDE_FROM_ABI bool
5198regex_search(const _CharT* __str,
5199 match_results<const _CharT*, _Allocator>& __m,
5200 const basic_regex<_CharT, _Traits>& __e,
5201 regex_constants::match_flag_type __flags = regex_constants::match_default) {
5202 return __e.__search(__str, __str + _Traits::length(__str), __m, __flags);
5203}
5204
5205template <class _CharT, class _Traits>
5206inline _LIBCPP_HIDE_FROM_ABI bool
5207regex_search(const _CharT* __str,
5208 const basic_regex<_CharT, _Traits>& __e,
5209 regex_constants::match_flag_type __flags = regex_constants::match_default) {
5210 match_results<const _CharT*> __m;
5211 return std::regex_search(__str, __m, __e, __flags);
5212}
5213
5214template <class _ST, class _SA, class _CharT, class _Traits>
5215inline _LIBCPP_HIDE_FROM_ABI bool
5216regex_search(const basic_string<_CharT, _ST, _SA>& __s,
5217 const basic_regex<_CharT, _Traits>& __e,
5218 regex_constants::match_flag_type __flags = regex_constants::match_default) {
5219 match_results<const _CharT*> __mc;
5220 return __e.__search(__s.data(), __s.data() + __s.size(), __mc, __flags);
5221}
5222
5223template <class _ST, class _SA, class _Allocator, class _CharT, class _Traits>
5224inline _LIBCPP_HIDE_FROM_ABI bool
5225regex_search(const basic_string<_CharT, _ST, _SA>& __s,
5226 match_results<typename basic_string<_CharT, _ST, _SA>::const_iterator, _Allocator>& __m,
5227 const basic_regex<_CharT, _Traits>& __e,
5228 regex_constants::match_flag_type __flags = regex_constants::match_default) {
5229 match_results<const _CharT*> __mc;
5230 bool __r = __e.__search(__s.data(), __s.data() + __s.size(), __mc, __flags);
5231 __m.__assign(__s.begin(), __s.end(), __mc, __flags & regex_constants::__no_update_pos);
5232 return __r;
5233}
5234
5235#if _LIBCPP_STD_VER >= 14
5236template <class _ST, class _SA, class _Ap, class _Cp, class _Tp>
5237bool regex_search(const basic_string<_Cp, _ST, _SA>&& __s,
5238 match_results<typename basic_string<_Cp, _ST, _SA>::const_iterator, _Ap>&,
5239 const basic_regex<_Cp, _Tp>& __e,
5240 regex_constants::match_flag_type __flags = regex_constants::match_default) = delete;
5241#endif
5242
5243// regex_match
5244
5245template <class _BidirectionalIterator, class _Allocator, class _CharT, class _Traits>
5246_LIBCPP_HIDE_FROM_ABI bool
5247regex_match(_BidirectionalIterator __first,
5248 _BidirectionalIterator __last,
5249 match_results<_BidirectionalIterator, _Allocator>& __m,
5250 const basic_regex<_CharT, _Traits>& __e,
5251 regex_constants::match_flag_type __flags = regex_constants::match_default) {
5252 bool __r = std::regex_search(
5253 __first, __last, __m, __e, __flags | regex_constants::match_continuous | regex_constants::__full_match);
5254 if (__r) {
5255 __r = !__m.suffix().matched;
5256 if (!__r)
5257 __m.__matches_.clear();
5258 }
5259 return __r;
5260}
5261
5262template <class _BidirectionalIterator, class _CharT, class _Traits>
5263inline _LIBCPP_HIDE_FROM_ABI bool
5264regex_match(_BidirectionalIterator __first,
5265 _BidirectionalIterator __last,
5266 const basic_regex<_CharT, _Traits>& __e,
5267 regex_constants::match_flag_type __flags = regex_constants::match_default) {
5268 match_results<_BidirectionalIterator> __m;
5269 return std::regex_match(__first, __last, __m, __e, __flags);
5270}
5271
5272template <class _CharT, class _Allocator, class _Traits>
5273inline _LIBCPP_HIDE_FROM_ABI bool
5274regex_match(const _CharT* __str,
5275 match_results<const _CharT*, _Allocator>& __m,
5276 const basic_regex<_CharT, _Traits>& __e,
5277 regex_constants::match_flag_type __flags = regex_constants::match_default) {
5278 return std::regex_match(__str, __str + _Traits::length(__str), __m, __e, __flags);
5279}
5280
5281template <class _ST, class _SA, class _Allocator, class _CharT, class _Traits>
5282inline _LIBCPP_HIDE_FROM_ABI bool
5283regex_match(const basic_string<_CharT, _ST, _SA>& __s,
5284 match_results<typename basic_string<_CharT, _ST, _SA>::const_iterator, _Allocator>& __m,
5285 const basic_regex<_CharT, _Traits>& __e,
5286 regex_constants::match_flag_type __flags = regex_constants::match_default) {
5287 return std::regex_match(__s.begin(), __s.end(), __m, __e, __flags);
5288}
5289
5290#if _LIBCPP_STD_VER >= 14
5291template <class _ST, class _SA, class _Allocator, class _CharT, class _Traits>
5292inline _LIBCPP_HIDE_FROM_ABI bool
5293regex_match(const basic_string<_CharT, _ST, _SA>&& __s,
5294 match_results<typename basic_string<_CharT, _ST, _SA>::const_iterator, _Allocator>& __m,
5295 const basic_regex<_CharT, _Traits>& __e,
5296 regex_constants::match_flag_type __flags = regex_constants::match_default) = delete;
5297#endif
5298
5299template <class _CharT, class _Traits>
5300inline _LIBCPP_HIDE_FROM_ABI bool
5301regex_match(const _CharT* __str,
5302 const basic_regex<_CharT, _Traits>& __e,
5303 regex_constants::match_flag_type __flags = regex_constants::match_default) {
5304 return std::regex_match(__str, __str + _Traits::length(__str), __e, __flags);
5305}
5306
5307template <class _ST, class _SA, class _CharT, class _Traits>
5308inline _LIBCPP_HIDE_FROM_ABI bool
5309regex_match(const basic_string<_CharT, _ST, _SA>& __s,
5310 const basic_regex<_CharT, _Traits>& __e,
5311 regex_constants::match_flag_type __flags = regex_constants::match_default) {
5312 return std::regex_match(__s.begin(), __s.end(), __e, __flags);
5313}
5314
5315// regex_iterator
5316
5317template <class _BidirectionalIterator,
5318 class _CharT = typename iterator_traits<_BidirectionalIterator>::value_type,
5319 class _Traits = regex_traits<_CharT> >
5320class _LIBCPP_TEMPLATE_VIS regex_iterator;
5321
5322typedef regex_iterator<const char*> cregex_iterator;
5323typedef regex_iterator<string::const_iterator> sregex_iterator;
5324#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
5325typedef regex_iterator<const wchar_t*> wcregex_iterator;
5326typedef regex_iterator<wstring::const_iterator> wsregex_iterator;
5327#endif
5328
5329template <class _BidirectionalIterator, class _CharT, class _Traits>
5330class _LIBCPP_TEMPLATE_VIS _LIBCPP_PREFERRED_NAME(cregex_iterator)
5331 _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wcregex_iterator)) _LIBCPP_PREFERRED_NAME(sregex_iterator)
5332 _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wsregex_iterator)) regex_iterator {
5333public:
5334 typedef basic_regex<_CharT, _Traits> regex_type;
5335 typedef match_results<_BidirectionalIterator> value_type;
5336 typedef ptrdiff_t difference_type;
5337 typedef const value_type* pointer;
5338 typedef const value_type& reference;
5339 typedef forward_iterator_tag iterator_category;
5340#if _LIBCPP_STD_VER >= 20
5341 typedef input_iterator_tag iterator_concept;
5342#endif
5343
5344private:
5345 _BidirectionalIterator __begin_;
5346 _BidirectionalIterator __end_;
5347 const regex_type* __pregex_;
5348 regex_constants::match_flag_type __flags_;
5349 value_type __match_;
5350
5351public:
5352 regex_iterator();
5353 regex_iterator(_BidirectionalIterator __a,
5354 _BidirectionalIterator __b,
5355 const regex_type& __re,
5356 regex_constants::match_flag_type __m = regex_constants::match_default);
5357#if _LIBCPP_STD_VER >= 14
5358 regex_iterator(_BidirectionalIterator __a,
5359 _BidirectionalIterator __b,
5360 const regex_type&& __re,
5361 regex_constants::match_flag_type __m = regex_constants::match_default) = delete;
5362#endif
5363
5364 _LIBCPP_HIDE_FROM_ABI bool operator==(const regex_iterator& __x) const;
5365#if _LIBCPP_STD_VER >= 20
5366 _LIBCPP_HIDE_FROM_ABI bool operator==(default_sentinel_t) const { return *this == regex_iterator(); }
5367#endif
5368#if _LIBCPP_STD_VER < 20
5369 _LIBCPP_HIDE_FROM_ABI bool operator!=(const regex_iterator& __x) const { return !(*this == __x); }
5370#endif
5371
5372 _LIBCPP_HIDE_FROM_ABI reference operator*() const { return __match_; }
5373 _LIBCPP_HIDE_FROM_ABI pointer operator->() const { return std::addressof(__match_); }
5374
5375 regex_iterator& operator++();
5376 _LIBCPP_HIDE_FROM_ABI regex_iterator operator++(int) {
5377 regex_iterator __t(*this);
5378 ++(*this);
5379 return __t;
5380 }
5381};
5382
5383template <class _BidirectionalIterator, class _CharT, class _Traits>
5384regex_iterator<_BidirectionalIterator, _CharT, _Traits>::regex_iterator()
5385 : __begin_(), __end_(), __pregex_(nullptr), __flags_(), __match_() {}
5386
5387template <class _BidirectionalIterator, class _CharT, class _Traits>
5388regex_iterator<_BidirectionalIterator, _CharT, _Traits>::regex_iterator(
5389 _BidirectionalIterator __a,
5390 _BidirectionalIterator __b,
5391 const regex_type& __re,
5392 regex_constants::match_flag_type __m)
5393 : __begin_(__a), __end_(__b), __pregex_(std::addressof(__re)), __flags_(__m) {
5394 std::regex_search(__begin_, __end_, __match_, *__pregex_, __flags_);
5395}
5396
5397template <class _BidirectionalIterator, class _CharT, class _Traits>
5398bool regex_iterator<_BidirectionalIterator, _CharT, _Traits>::operator==(const regex_iterator& __x) const {
5399 if (__match_.empty() && __x.__match_.empty())
5400 return true;
5401 if (__match_.empty() || __x.__match_.empty())
5402 return false;
5403 return __begin_ == __x.__begin_ && __end_ == __x.__end_ && __pregex_ == __x.__pregex_ && __flags_ == __x.__flags_ &&
5404 __match_[0] == __x.__match_[0];
5405}
5406
5407template <class _BidirectionalIterator, class _CharT, class _Traits>
5408regex_iterator<_BidirectionalIterator, _CharT, _Traits>&
5409regex_iterator<_BidirectionalIterator, _CharT, _Traits>::operator++() {
5410 __flags_ |= regex_constants::__no_update_pos;
5411 _BidirectionalIterator __start = __match_[0].second;
5412 _BidirectionalIterator __prefix_start = __start;
5413
5414 if (__match_[0].first == __match_[0].second) {
5415 if (__start == __end_) {
5416 __match_ = value_type();
5417 return *this;
5418 } else if (std::regex_search(__start,
5419 __end_,
5420 __match_,
5421 *__pregex_,
5422 __flags_ | regex_constants::match_not_null | regex_constants::match_continuous))
5423 return *this;
5424 else
5425 ++__start;
5426 }
5427
5428 __flags_ |= regex_constants::match_prev_avail;
5429 if (!std::regex_search(__start, __end_, __match_, *__pregex_, __flags_)) {
5430 __match_ = value_type();
5431
5432 } else {
5433 // The Standard mandates that if `regex_search` returns true ([re.regiter.incr]), "`match.prefix().first` shall be
5434 // equal to the previous value of `match[0].second`... It is unspecified how the implementation makes these
5435 // adjustments." The adjustment is necessary if we incremented `__start` above (the branch that deals with
5436 // zero-length matches).
5437 auto& __prefix = __match_.__prefix_;
5438 __prefix.first = __prefix_start;
5439 __prefix.matched = __prefix.first != __prefix.second;
5440 }
5441
5442 return *this;
5443}
5444
5445// regex_token_iterator
5446
5447template <class _BidirectionalIterator,
5448 class _CharT = typename iterator_traits<_BidirectionalIterator>::value_type,
5449 class _Traits = regex_traits<_CharT> >
5450class _LIBCPP_TEMPLATE_VIS regex_token_iterator;
5451
5452typedef regex_token_iterator<const char*> cregex_token_iterator;
5453typedef regex_token_iterator<string::const_iterator> sregex_token_iterator;
5454#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
5455typedef regex_token_iterator<const wchar_t*> wcregex_token_iterator;
5456typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;
5457#endif
5458
5459template <class _BidirectionalIterator, class _CharT, class _Traits>
5460class _LIBCPP_TEMPLATE_VIS _LIBCPP_PREFERRED_NAME(cregex_token_iterator)
5461 _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wcregex_token_iterator))
5462 _LIBCPP_PREFERRED_NAME(sregex_token_iterator)
5463 _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wsregex_token_iterator)) regex_token_iterator {
5464public:
5465 typedef basic_regex<_CharT, _Traits> regex_type;
5466 typedef sub_match<_BidirectionalIterator> value_type;
5467 typedef ptrdiff_t difference_type;
5468 typedef const value_type* pointer;
5469 typedef const value_type& reference;
5470 typedef forward_iterator_tag iterator_category;
5471#if _LIBCPP_STD_VER >= 20
5472 typedef input_iterator_tag iterator_concept;
5473#endif
5474
5475private:
5476 typedef regex_iterator<_BidirectionalIterator, _CharT, _Traits> _Position;
5477
5478 _Position __position_;
5479 const value_type* __result_;
5480 value_type __suffix_;
5481 ptrdiff_t __n_;
5482 vector<int> __subs_;
5483
5484public:
5485 regex_token_iterator();
5486 regex_token_iterator(_BidirectionalIterator __a,
5487 _BidirectionalIterator __b,
5488 const regex_type& __re,
5489 int __submatch = 0,
5490 regex_constants::match_flag_type __m = regex_constants::match_default);
5491#if _LIBCPP_STD_VER >= 14
5492 regex_token_iterator(_BidirectionalIterator __a,
5493 _BidirectionalIterator __b,
5494 const regex_type&& __re,
5495 int __submatch = 0,
5496 regex_constants::match_flag_type __m = regex_constants::match_default) = delete;
5497#endif
5498
5499 regex_token_iterator(_BidirectionalIterator __a,
5500 _BidirectionalIterator __b,
5501 const regex_type& __re,
5502 const vector<int>& __submatches,
5503 regex_constants::match_flag_type __m = regex_constants::match_default);
5504#if _LIBCPP_STD_VER >= 14
5505 regex_token_iterator(_BidirectionalIterator __a,
5506 _BidirectionalIterator __b,
5507 const regex_type&& __re,
5508 const vector<int>& __submatches,
5509 regex_constants::match_flag_type __m = regex_constants::match_default) = delete;
5510#endif
5511
5512#ifndef _LIBCPP_CXX03_LANG
5513 regex_token_iterator(_BidirectionalIterator __a,
5514 _BidirectionalIterator __b,
5515 const regex_type& __re,
5516 initializer_list<int> __submatches,
5517 regex_constants::match_flag_type __m = regex_constants::match_default);
5518
5519# if _LIBCPP_STD_VER >= 14
5520 regex_token_iterator(_BidirectionalIterator __a,
5521 _BidirectionalIterator __b,
5522 const regex_type&& __re,
5523 initializer_list<int> __submatches,
5524 regex_constants::match_flag_type __m = regex_constants::match_default) = delete;
5525# endif
5526#endif // _LIBCPP_CXX03_LANG
5527 template <size_t _Np>
5528 regex_token_iterator(_BidirectionalIterator __a,
5529 _BidirectionalIterator __b,
5530 const regex_type& __re,
5531 const int (&__submatches)[_Np],
5532 regex_constants::match_flag_type __m = regex_constants::match_default);
5533#if _LIBCPP_STD_VER >= 14
5534 template <size_t _Np>
5535 regex_token_iterator(_BidirectionalIterator __a,
5536 _BidirectionalIterator __b,
5537 const regex_type&& __re,
5538 const int (&__submatches)[_Np],
5539 regex_constants::match_flag_type __m = regex_constants::match_default) = delete;
5540#endif
5541
5542 regex_token_iterator(const regex_token_iterator&);
5543 regex_token_iterator& operator=(const regex_token_iterator&);
5544
5545 _LIBCPP_HIDE_FROM_ABI bool operator==(const regex_token_iterator& __x) const;
5546#if _LIBCPP_STD_VER >= 20
5547 _LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI bool operator==(default_sentinel_t) const {
5548 return *this == regex_token_iterator();
5549 }
5550#endif
5551#if _LIBCPP_STD_VER < 20
5552 _LIBCPP_HIDE_FROM_ABI bool operator!=(const regex_token_iterator& __x) const { return !(*this == __x); }
5553#endif
5554
5555 _LIBCPP_HIDE_FROM_ABI const value_type& operator*() const { return *__result_; }
5556 _LIBCPP_HIDE_FROM_ABI const value_type* operator->() const { return __result_; }
5557
5558 regex_token_iterator& operator++();
5559 _LIBCPP_HIDE_FROM_ABI regex_token_iterator operator++(int) {
5560 regex_token_iterator __t(*this);
5561 ++(*this);
5562 return __t;
5563 }
5564
5565private:
5566 void __init(_BidirectionalIterator __a, _BidirectionalIterator __b);
5567 void __establish_result() {
5568 if (__subs_[__n_] == -1)
5569 __result_ = &__position_->prefix();
5570 else
5571 __result_ = &(*__position_)[__subs_[__n_]];
5572 }
5573};
5574
5575template <class _BidirectionalIterator, class _CharT, class _Traits>
5576regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::regex_token_iterator()
5577 : __result_(nullptr), __suffix_(), __n_(0) {}
5578
5579template <class _BidirectionalIterator, class _CharT, class _Traits>
5580void regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::__init(
5581 _BidirectionalIterator __a, _BidirectionalIterator __b) {
5582 if (__position_ != _Position())
5583 __establish_result();
5584 else if (__subs_[__n_] == -1) {
5585 __suffix_.matched = true;
5586 __suffix_.first = __a;
5587 __suffix_.second = __b;
5588 __result_ = &__suffix_;
5589 } else
5590 __result_ = nullptr;
5591}
5592
5593template <class _BidirectionalIterator, class _CharT, class _Traits>
5594regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::regex_token_iterator(
5595 _BidirectionalIterator __a,
5596 _BidirectionalIterator __b,
5597 const regex_type& __re,
5598 int __submatch,
5599 regex_constants::match_flag_type __m)
5600 : __position_(__a, __b, __re, __m), __n_(0), __subs_(1, __submatch) {
5601 __init(__a, __b);
5602}
5603
5604template <class _BidirectionalIterator, class _CharT, class _Traits>
5605regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::regex_token_iterator(
5606 _BidirectionalIterator __a,
5607 _BidirectionalIterator __b,
5608 const regex_type& __re,
5609 const vector<int>& __submatches,
5610 regex_constants::match_flag_type __m)
5611 : __position_(__a, __b, __re, __m), __n_(0), __subs_(__submatches) {
5612 __init(__a, __b);
5613}
5614
5615#ifndef _LIBCPP_CXX03_LANG
5616
5617template <class _BidirectionalIterator, class _CharT, class _Traits>
5618regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::regex_token_iterator(
5619 _BidirectionalIterator __a,
5620 _BidirectionalIterator __b,
5621 const regex_type& __re,
5622 initializer_list<int> __submatches,
5623 regex_constants::match_flag_type __m)
5624 : __position_(__a, __b, __re, __m), __n_(0), __subs_(__submatches) {
5625 __init(__a, __b);
5626}
5627
5628#endif // _LIBCPP_CXX03_LANG
5629
5630template <class _BidirectionalIterator, class _CharT, class _Traits>
5631template <size_t _Np>
5632regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::regex_token_iterator(
5633 _BidirectionalIterator __a,
5634 _BidirectionalIterator __b,
5635 const regex_type& __re,
5636 const int (&__submatches)[_Np],
5637 regex_constants::match_flag_type __m)
5638 : __position_(__a, __b, __re, __m), __n_(0), __subs_(begin(__submatches), end(__submatches)) {
5639 __init(__a, __b);
5640}
5641
5642template <class _BidirectionalIterator, class _CharT, class _Traits>
5643regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::regex_token_iterator(const regex_token_iterator& __x)
5644 : __position_(__x.__position_),
5645 __result_(__x.__result_),
5646 __suffix_(__x.__suffix_),
5647 __n_(__x.__n_),
5648 __subs_(__x.__subs_) {
5649 if (__x.__result_ == &__x.__suffix_)
5650 __result_ = &__suffix_;
5651 else if (__result_ != nullptr)
5652 __establish_result();
5653}
5654
5655template <class _BidirectionalIterator, class _CharT, class _Traits>
5656regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>&
5657regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::operator=(const regex_token_iterator& __x) {
5658 if (this != &__x) {
5659 __position_ = __x.__position_;
5660 if (__x.__result_ == &__x.__suffix_)
5661 __result_ = &__suffix_;
5662 else
5663 __result_ = __x.__result_;
5664 __suffix_ = __x.__suffix_;
5665 __n_ = __x.__n_;
5666 __subs_ = __x.__subs_;
5667
5668 if (__result_ != nullptr && __result_ != &__suffix_)
5669 __establish_result();
5670 }
5671 return *this;
5672}
5673
5674template <class _BidirectionalIterator, class _CharT, class _Traits>
5675bool regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::operator==(const regex_token_iterator& __x) const {
5676 if (__result_ == nullptr && __x.__result_ == nullptr)
5677 return true;
5678 if (__result_ == &__suffix_ && __x.__result_ == &__x.__suffix_ && __suffix_ == __x.__suffix_)
5679 return true;
5680 if (__result_ == nullptr || __x.__result_ == nullptr)
5681 return false;
5682 if (__result_ == &__suffix_ || __x.__result_ == &__x.__suffix_)
5683 return false;
5684 return __position_ == __x.__position_ && __n_ == __x.__n_ && __subs_ == __x.__subs_;
5685}
5686
5687template <class _BidirectionalIterator, class _CharT, class _Traits>
5688regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>&
5689regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::operator++() {
5690 _Position __prev = __position_;
5691 if (__result_ == &__suffix_)
5692 __result_ = nullptr;
5693 else if (static_cast<size_t>(__n_ + 1) < __subs_.size()) {
5694 ++__n_;
5695 __establish_result();
5696 } else {
5697 __n_ = 0;
5698 ++__position_;
5699 if (__position_ != _Position())
5700 __establish_result();
5701 else {
5702 if (std::find(__subs_.begin(), __subs_.end(), -1) != __subs_.end() && __prev->suffix().length() != 0) {
5703 __suffix_.matched = true;
5704 __suffix_.first = __prev->suffix().first;
5705 __suffix_.second = __prev->suffix().second;
5706 __result_ = &__suffix_;
5707 } else
5708 __result_ = nullptr;
5709 }
5710 }
5711 return *this;
5712}
5713
5714// regex_replace
5715
5716template <class _OutputIterator, class _BidirectionalIterator, class _Traits, class _CharT>
5717_LIBCPP_HIDE_FROM_ABI _OutputIterator regex_replace(
5718 _OutputIterator __output_iter,
5719 _BidirectionalIterator __first,
5720 _BidirectionalIterator __last,
5721 const basic_regex<_CharT, _Traits>& __e,
5722 const _CharT* __fmt,
5723 regex_constants::match_flag_type __flags = regex_constants::match_default) {
5724 typedef regex_iterator<_BidirectionalIterator, _CharT, _Traits> _Iter;
5725 _Iter __i(__first, __last, __e, __flags);
5726 _Iter __eof;
5727 if (__i == __eof) {
5728 if (!(__flags & regex_constants::format_no_copy))
5729 __output_iter = std::copy(__first, __last, __output_iter);
5730 } else {
5731 sub_match<_BidirectionalIterator> __lm;
5732 for (size_t __len = char_traits<_CharT>::length(__fmt); __i != __eof; ++__i) {
5733 if (!(__flags & regex_constants::format_no_copy))
5734 __output_iter = std::copy(__i->prefix().first, __i->prefix().second, __output_iter);
5735 __output_iter = __i->format(__output_iter, __fmt, __fmt + __len, __flags);
5736 __lm = __i->suffix();
5737 if (__flags & regex_constants::format_first_only)
5738 break;
5739 }
5740 if (!(__flags & regex_constants::format_no_copy))
5741 __output_iter = std::copy(__lm.first, __lm.second, __output_iter);
5742 }
5743 return __output_iter;
5744}
5745
5746template <class _OutputIterator, class _BidirectionalIterator, class _Traits, class _CharT, class _ST, class _SA>
5747inline _LIBCPP_HIDE_FROM_ABI _OutputIterator regex_replace(
5748 _OutputIterator __output_iter,
5749 _BidirectionalIterator __first,
5750 _BidirectionalIterator __last,
5751 const basic_regex<_CharT, _Traits>& __e,
5752 const basic_string<_CharT, _ST, _SA>& __fmt,
5753 regex_constants::match_flag_type __flags = regex_constants::match_default) {
5754 return std::regex_replace(__output_iter, __first, __last, __e, __fmt.c_str(), __flags);
5755}
5756
5757template <class _Traits, class _CharT, class _ST, class _SA, class _FST, class _FSA>
5758inline _LIBCPP_HIDE_FROM_ABI basic_string<_CharT, _ST, _SA>
5759regex_replace(const basic_string<_CharT, _ST, _SA>& __s,
5760 const basic_regex<_CharT, _Traits>& __e,
5761 const basic_string<_CharT, _FST, _FSA>& __fmt,
5762 regex_constants::match_flag_type __flags = regex_constants::match_default) {
5763 basic_string<_CharT, _ST, _SA> __r;
5764 std::regex_replace(std::back_inserter(__r), __s.begin(), __s.end(), __e, __fmt.c_str(), __flags);
5765 return __r;
5766}
5767
5768template <class _Traits, class _CharT, class _ST, class _SA>
5769inline _LIBCPP_HIDE_FROM_ABI basic_string<_CharT, _ST, _SA>
5770regex_replace(const basic_string<_CharT, _ST, _SA>& __s,
5771 const basic_regex<_CharT, _Traits>& __e,
5772 const _CharT* __fmt,
5773 regex_constants::match_flag_type __flags = regex_constants::match_default) {
5774 basic_string<_CharT, _ST, _SA> __r;
5775 std::regex_replace(std::back_inserter(__r), __s.begin(), __s.end(), __e, __fmt, __flags);
5776 return __r;
5777}
5778
5779template <class _Traits, class _CharT, class _ST, class _SA>
5780inline _LIBCPP_HIDE_FROM_ABI basic_string<_CharT>
5781regex_replace(const _CharT* __s,
5782 const basic_regex<_CharT, _Traits>& __e,
5783 const basic_string<_CharT, _ST, _SA>& __fmt,
5784 regex_constants::match_flag_type __flags = regex_constants::match_default) {
5785 basic_string<_CharT> __r;
5786 std::regex_replace(std::back_inserter(__r), __s, __s + char_traits<_CharT>::length(__s), __e, __fmt.c_str(), __flags);
5787 return __r;
5788}
5789
5790template <class _Traits, class _CharT>
5791inline _LIBCPP_HIDE_FROM_ABI basic_string<_CharT>
5792regex_replace(const _CharT* __s,
5793 const basic_regex<_CharT, _Traits>& __e,
5794 const _CharT* __fmt,
5795 regex_constants::match_flag_type __flags = regex_constants::match_default) {
5796 basic_string<_CharT> __r;
5797 std::regex_replace(std::back_inserter(__r), __s, __s + char_traits<_CharT>::length(__s), __e, __fmt, __flags);
5798 return __r;
5799}
5800
5801_LIBCPP_END_NAMESPACE_STD
5802
5803#if _LIBCPP_STD_VER >= 17
5804_LIBCPP_BEGIN_NAMESPACE_STD
5805namespace pmr {
5806template <class _BidirT>
5807using match_results _LIBCPP_AVAILABILITY_PMR =
5808 std::match_results<_BidirT, polymorphic_allocator<std::sub_match<_BidirT>>>;
5809
5810using cmatch _LIBCPP_AVAILABILITY_PMR = match_results<const char*>;
5811using smatch _LIBCPP_AVAILABILITY_PMR = match_results<std::pmr::string::const_iterator>;
5812
5813# ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
5814using wcmatch _LIBCPP_AVAILABILITY_PMR = match_results<const wchar_t*>;
5815using wsmatch _LIBCPP_AVAILABILITY_PMR = match_results<std::pmr::wstring::const_iterator>;
5816# endif
5817} // namespace pmr
5818_LIBCPP_END_NAMESPACE_STD
5819#endif
5820
5821_LIBCPP_POP_MACROS
5822
5823#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
5824# include <atomic>
5825# include <concepts>
5826# include <cstdlib>
5827# include <iosfwd>
5828# include <iterator>
5829# include <mutex>
5830# include <new>
5831# include <type_traits>
5832# include <typeinfo>
5833# include <utility>
5834#endif
5835
5836#endif // _LIBCPP_REGEX
5837