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