blob: db15f78e410b46ed14da5526dad89bf472f1c874 [file] [log] [blame]
Howard Hinnanta3af5a32010-06-17 00:34:59 +00001// -*- C++ -*-
2//===--------------------------- regex ------------------------------------===//
3//
4// The LLVM Compiler Infrastructure
5//
Howard Hinnantee11c312010-11-16 22:09:02 +00006// This file is dual licensed under the MIT and the University of Illinois Open
7// Source Licenses. See LICENSE.TXT for details.
Howard Hinnanta3af5a32010-06-17 00:34:59 +00008//
9//===----------------------------------------------------------------------===//
10
11#ifndef _LIBCPP_REGEX
12#define _LIBCPP_REGEX
13
14/*
15 regex synopsis
16
17#include <initializer_list>
18
19namespace std
20{
21
22namespace regex_constants
23{
24
25emum 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};
38
39constexpr syntax_option_type operator~(syntax_option_type f);
40constexpr syntax_option_type operator&(syntax_option_type lhs, syntax_option_type rhs);
41constexpr syntax_option_type operator|(syntax_option_type lhs, syntax_option_type rhs);
42
43enum match_flag_type
44{
45 match_default = 0,
46 match_not_bol = unspecified,
47 match_not_eol = unspecified,
48 match_not_bow = unspecified,
49 match_not_eow = unspecified,
50 match_any = unspecified,
51 match_not_null = unspecified,
52 match_continuous = unspecified,
53 match_prev_avail = unspecified,
54 format_default = 0,
55 format_sed = unspecified,
56 format_no_copy = unspecified,
57 format_first_only = unspecified
58};
59
60constexpr match_flag_type operator~(match_flag_type f);
61constexpr match_flag_type operator&(match_flag_type lhs, match_flag_type rhs);
62constexpr match_flag_type operator|(match_flag_type lhs, match_flag_type rhs);
63
64enum error_type
65{
66 error_collate = unspecified,
67 error_ctype = unspecified,
68 error_escape = unspecified,
69 error_backref = unspecified,
70 error_brack = unspecified,
71 error_paren = unspecified,
72 error_brace = unspecified,
73 error_badbrace = unspecified,
74 error_range = unspecified,
75 error_space = unspecified,
76 error_badrepeat = unspecified,
77 error_complexity = unspecified,
78 error_stack = unspecified
79};
80
81} // regex_constants
82
83class regex_error
84 : public runtime_error
85{
86public:
87 explicit regex_error(regex_constants::error_type ecode);
88 regex_constants::error_type code() const;
89};
90
91template <class charT>
92struct regex_traits
93{
94public:
95 typedef charT char_type;
96 typedef basic_string<char_type> string_type;
97 typedef locale locale_type;
98 typedef /bitmask_type/ char_class_type;
99
100 regex_traits();
101
102 static size_t length(const char_type* p);
103 charT translate(charT c) const;
104 charT translate_nocase(charT c) const;
105 template <class ForwardIterator>
106 string_type
107 transform(ForwardIterator first, ForwardIterator last) const;
108 template <class ForwardIterator>
109 string_type
110 transform_primary( ForwardIterator first, ForwardIterator last) const;
111 template <class ForwardIterator>
112 string_type
113 lookup_collatename(ForwardIterator first, ForwardIterator last) const;
114 template <class ForwardIterator>
115 char_class_type
116 lookup_classname(ForwardIterator first, ForwardIterator last,
117 bool icase = false) const;
118 bool isctype(charT c, char_class_type f) const;
119 int value(charT ch, int radix) const;
120 locale_type imbue(locale_type l);
121 locale_type getloc()const;
122};
123
124template <class charT, class traits = regex_traits<charT>>
125class basic_regex
126{
127public:
128 // types:
129 typedef charT value_type;
Hubert Tong1f1ae9c2016-08-02 21:34:48 +0000130 typedef traits traits_type;
131 typedef typename traits::string_type string_type;
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000132 typedef regex_constants::syntax_option_type flag_type;
133 typedef typename traits::locale_type locale_type;
134
135 // constants:
136 static constexpr regex_constants::syntax_option_type icase = regex_constants::icase;
137 static constexpr regex_constants::syntax_option_type nosubs = regex_constants::nosubs;
138 static constexpr regex_constants::syntax_option_type optimize = regex_constants::optimize;
139 static constexpr regex_constants::syntax_option_type collate = regex_constants::collate;
140 static constexpr regex_constants::syntax_option_type ECMAScript = regex_constants::ECMAScript;
141 static constexpr regex_constants::syntax_option_type basic = regex_constants::basic;
142 static constexpr regex_constants::syntax_option_type extended = regex_constants::extended;
143 static constexpr regex_constants::syntax_option_type awk = regex_constants::awk;
144 static constexpr regex_constants::syntax_option_type grep = regex_constants::grep;
145 static constexpr regex_constants::syntax_option_type egrep = regex_constants::egrep;
146
147 // construct/copy/destroy:
148 basic_regex();
149 explicit basic_regex(const charT* p, flag_type f = regex_constants::ECMAScript);
Hubert Tong19662862016-08-07 22:26:04 +0000150 basic_regex(const charT* p, size_t len, flag_type f = regex_constants::ECMAScript);
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000151 basic_regex(const basic_regex&);
Howard Hinnant5ddd33c2012-07-21 01:31:58 +0000152 basic_regex(basic_regex&&) noexcept;
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000153 template <class ST, class SA>
154 explicit basic_regex(const basic_string<charT, ST, SA>& p,
155 flag_type f = regex_constants::ECMAScript);
156 template <class ForwardIterator>
157 basic_regex(ForwardIterator first, ForwardIterator last,
158 flag_type f = regex_constants::ECMAScript);
159 basic_regex(initializer_list<charT>, flag_type = regex_constants::ECMAScript);
160
161 ~basic_regex();
162
163 basic_regex& operator=(const basic_regex&);
Howard Hinnant5ddd33c2012-07-21 01:31:58 +0000164 basic_regex& operator=(basic_regex&&) noexcept;
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000165 basic_regex& operator=(const charT* ptr);
166 basic_regex& operator=(initializer_list<charT> il);
167 template <class ST, class SA>
168 basic_regex& operator=(const basic_string<charT, ST, SA>& p);
169
170 // assign:
171 basic_regex& assign(const basic_regex& that);
Howard Hinnant5ddd33c2012-07-21 01:31:58 +0000172 basic_regex& assign(basic_regex&& that) noexcept;
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000173 basic_regex& assign(const charT* ptr, flag_type f = regex_constants::ECMAScript);
174 basic_regex& assign(const charT* p, size_t len, flag_type f);
175 template <class string_traits, class A>
176 basic_regex& assign(const basic_string<charT, string_traits, A>& s,
177 flag_type f = regex_constants::ECMAScript);
178 template <class InputIterator>
179 basic_regex& assign(InputIterator first, InputIterator last,
180 flag_type f = regex_constants::ECMAScript);
181 basic_regex& assign(initializer_list<charT>, flag_type = regex_constants::ECMAScript);
182
183 // const operations:
184 unsigned mark_count() const;
185 flag_type flags() const;
186
187 // locale:
188 locale_type imbue(locale_type loc);
189 locale_type getloc() const;
190
191 // swap:
192 void swap(basic_regex&);
193};
194
Marshall Clow2dce1f42018-05-23 01:57:02 +0000195template<class ForwardIterator>
196basic_regex(ForwardIterator, ForwardIterator,
197 regex_constants::syntax_option_type = regex_constants::ECMAScript)
198 -> basic_regex<typename iterator_traits<ForwardIterator>::value_type>; // C++17
199
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000200typedef basic_regex<char> regex;
201typedef basic_regex<wchar_t> wregex;
202
203template <class charT, class traits>
204 void swap(basic_regex<charT, traits>& e1, basic_regex<charT, traits>& e2);
205
206template <class BidirectionalIterator>
207class sub_match
208 : public pair<BidirectionalIterator, BidirectionalIterator>
209{
210public:
211 typedef typename iterator_traits<BidirectionalIterator>::value_type value_type;
212 typedef typename iterator_traits<BidirectionalIterator>::difference_type difference_type;
213 typedef BidirectionalIterator iterator;
214 typedef basic_string<value_type> string_type;
215
216 bool matched;
217
Howard Hinnantb5c53a82010-12-08 21:07:55 +0000218 constexpr sub_match();
219
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000220 difference_type length() const;
221 operator string_type() const;
222 string_type str() const;
223
224 int compare(const sub_match& s) const;
225 int compare(const string_type& s) const;
226 int compare(const value_type* s) const;
227};
228
229typedef sub_match<const char*> csub_match;
230typedef sub_match<const wchar_t*> wcsub_match;
231typedef sub_match<string::const_iterator> ssub_match;
232typedef sub_match<wstring::const_iterator> wssub_match;
233
234template <class BiIter>
235 bool
236 operator==(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
237
238template <class BiIter>
239 bool
240 operator!=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
241
242template <class BiIter>
243 bool
244 operator<(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
245
246template <class BiIter>
247 bool
248 operator<=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
249
250template <class BiIter>
251 bool
252 operator>=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
253
254template <class BiIter>
255 bool
256 operator>(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
257
258template <class BiIter, class ST, class SA>
259 bool
260 operator==(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
261 const sub_match<BiIter>& rhs);
262
263template <class BiIter, class ST, class SA>
264 bool
265 operator!=(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
266 const sub_match<BiIter>& rhs);
267
268template <class BiIter, class ST, class SA>
269 bool
270 operator<(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
271 const sub_match<BiIter>& rhs);
272
273template <class BiIter, class ST, class SA>
274 bool
275 operator>(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
276 const sub_match<BiIter>& rhs);
277
278template <class BiIter, class ST, class SA>
279 bool operator>=(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
280 const sub_match<BiIter>& rhs);
281
282template <class BiIter, class ST, class SA>
283 bool
284 operator<=(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
285 const sub_match<BiIter>& rhs);
286
287template <class BiIter, class ST, class SA>
288 bool
289 operator==(const sub_match<BiIter>& lhs,
290 const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
291
292template <class BiIter, class ST, class SA>
293 bool
294 operator!=(const sub_match<BiIter>& lhs,
295 const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
296
297template <class BiIter, class ST, class SA>
298 bool
299 operator<(const sub_match<BiIter>& lhs,
300 const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
301
302template <class BiIter, class ST, class SA>
303 bool operator>(const sub_match<BiIter>& lhs,
304 const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
305
306template <class BiIter, class ST, class SA>
307 bool
308 operator>=(const sub_match<BiIter>& lhs,
309 const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
310
311template <class BiIter, class ST, class SA>
312 bool
313 operator<=(const sub_match<BiIter>& lhs,
314 const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
315
316template <class BiIter>
317 bool
318 operator==(typename iterator_traits<BiIter>::value_type const* lhs,
319 const sub_match<BiIter>& rhs);
320
321template <class BiIter>
322 bool
323 operator!=(typename iterator_traits<BiIter>::value_type const* lhs,
324 const sub_match<BiIter>& rhs);
325
326template <class BiIter>
327 bool
328 operator<(typename iterator_traits<BiIter>::value_type const* lhs,
329 const sub_match<BiIter>& rhs);
330
331template <class BiIter>
332 bool
333 operator>(typename iterator_traits<BiIter>::value_type const* lhs,
334 const sub_match<BiIter>& rhs);
335
336template <class BiIter>
337 bool
338 operator>=(typename iterator_traits<BiIter>::value_type const* lhs,
339 const sub_match<BiIter>& rhs);
340
341template <class BiIter>
342 bool
343 operator<=(typename iterator_traits<BiIter>::value_type const* lhs,
344 const sub_match<BiIter>& rhs);
345
346template <class BiIter>
347 bool
348 operator==(const sub_match<BiIter>& lhs,
349 typename iterator_traits<BiIter>::value_type const* rhs);
350
351template <class BiIter>
352 bool
353 operator!=(const sub_match<BiIter>& lhs,
354 typename iterator_traits<BiIter>::value_type const* rhs);
355
356template <class BiIter>
357 bool
358 operator<(const sub_match<BiIter>& lhs,
359 typename iterator_traits<BiIter>::value_type const* rhs);
360
361template <class BiIter>
362 bool
363 operator>(const sub_match<BiIter>& lhs,
364 typename iterator_traits<BiIter>::value_type const* rhs);
365
366template <class BiIter>
367 bool
368 operator>=(const sub_match<BiIter>& lhs,
369 typename iterator_traits<BiIter>::value_type const* rhs);
370
371template <class BiIter>
372 bool
373 operator<=(const sub_match<BiIter>& lhs,
374 typename iterator_traits<BiIter>::value_type const* rhs);
375
376template <class BiIter>
377 bool
378 operator==(typename iterator_traits<BiIter>::value_type const& lhs,
379 const sub_match<BiIter>& rhs);
380
381template <class BiIter>
382 bool
383 operator!=(typename iterator_traits<BiIter>::value_type const& lhs,
384 const sub_match<BiIter>& rhs);
385
386template <class BiIter>
387 bool
388 operator<(typename iterator_traits<BiIter>::value_type const& lhs,
389 const sub_match<BiIter>& rhs);
390
391template <class BiIter>
392 bool
393 operator>(typename iterator_traits<BiIter>::value_type const& lhs,
394 const sub_match<BiIter>& rhs);
395
396template <class BiIter>
397 bool
398 operator>=(typename iterator_traits<BiIter>::value_type const& lhs,
399 const sub_match<BiIter>& rhs);
400
401template <class BiIter>
402 bool
403 operator<=(typename iterator_traits<BiIter>::value_type const& lhs,
404 const sub_match<BiIter>& rhs);
405
406template <class BiIter>
407 bool
408 operator==(const sub_match<BiIter>& lhs,
409 typename iterator_traits<BiIter>::value_type const& rhs);
410
411template <class BiIter>
412 bool
413 operator!=(const sub_match<BiIter>& lhs,
414 typename iterator_traits<BiIter>::value_type const& rhs);
415
416template <class BiIter>
417 bool
418 operator<(const sub_match<BiIter>& lhs,
419 typename iterator_traits<BiIter>::value_type const& rhs);
420
421template <class BiIter>
422 bool
423 operator>(const sub_match<BiIter>& lhs,
424 typename iterator_traits<BiIter>::value_type const& rhs);
425
426template <class BiIter>
427 bool
428 operator>=(const sub_match<BiIter>& lhs,
429 typename iterator_traits<BiIter>::value_type const& rhs);
430
431template <class BiIter>
432 bool
433 operator<=(const sub_match<BiIter>& lhs,
434 typename iterator_traits<BiIter>::value_type const& rhs);
435
436template <class charT, class ST, class BiIter>
437 basic_ostream<charT, ST>&
438 operator<<(basic_ostream<charT, ST>& os, const sub_match<BiIter>& m);
439
440template <class BidirectionalIterator,
441 class Allocator = allocator<sub_match<BidirectionalIterator>>>
442class match_results
443{
444public:
445 typedef sub_match<BidirectionalIterator> value_type;
446 typedef const value_type& const_reference;
Marshall Clow96e06142014-02-26 01:56:31 +0000447 typedef value_type& reference;
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000448 typedef /implementation-defined/ const_iterator;
449 typedef const_iterator iterator;
450 typedef typename iterator_traits<BidirectionalIterator>::difference_type difference_type;
451 typedef typename allocator_traits<Allocator>::size_type size_type;
452 typedef Allocator allocator_type;
453 typedef typename iterator_traits<BidirectionalIterator>::value_type char_type;
454 typedef basic_string<char_type> string_type;
455
456 // construct/copy/destroy:
457 explicit match_results(const Allocator& a = Allocator());
458 match_results(const match_results& m);
Howard Hinnant5ddd33c2012-07-21 01:31:58 +0000459 match_results(match_results&& m) noexcept;
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000460 match_results& operator=(const match_results& m);
461 match_results& operator=(match_results&& m);
462 ~match_results();
463
Howard Hinnantb5c53a82010-12-08 21:07:55 +0000464 bool ready() const;
465
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000466 // size:
467 size_type size() const;
468 size_type max_size() const;
469 bool empty() const;
470
471 // element access:
472 difference_type length(size_type sub = 0) const;
473 difference_type position(size_type sub = 0) const;
474 string_type str(size_type sub = 0) const;
475 const_reference operator[](size_type n) const;
476
477 const_reference prefix() const;
478 const_reference suffix() const;
479
480 const_iterator begin() const;
481 const_iterator end() const;
482 const_iterator cbegin() const;
483 const_iterator cend() const;
484
485 // format:
486 template <class OutputIter>
487 OutputIter
488 format(OutputIter out, const char_type* fmt_first,
489 const char_type* fmt_last,
490 regex_constants::match_flag_type flags = regex_constants::format_default) const;
491 template <class OutputIter, class ST, class SA>
492 OutputIter
493 format(OutputIter out, const basic_string<char_type, ST, SA>& fmt,
494 regex_constants::match_flag_type flags = regex_constants::format_default) const;
495 template <class ST, class SA>
496 basic_string<char_type, ST, SA>
497 format(const basic_string<char_type, ST, SA>& fmt,
498 regex_constants::match_flag_type flags = regex_constants::format_default) const;
499 string_type
500 format(const char_type* fmt,
501 regex_constants::match_flag_type flags = regex_constants::format_default) const;
502
503 // allocator:
504 allocator_type get_allocator() const;
505
506 // swap:
507 void swap(match_results& that);
508};
509
510typedef match_results<const char*> cmatch;
511typedef match_results<const wchar_t*> wcmatch;
512typedef match_results<string::const_iterator> smatch;
513typedef match_results<wstring::const_iterator> wsmatch;
514
515template <class BidirectionalIterator, class Allocator>
516 bool
517 operator==(const match_results<BidirectionalIterator, Allocator>& m1,
518 const match_results<BidirectionalIterator, Allocator>& m2);
519
520template <class BidirectionalIterator, class Allocator>
521 bool
522 operator!=(const match_results<BidirectionalIterator, Allocator>& m1,
523 const match_results<BidirectionalIterator, Allocator>& m2);
524
525template <class BidirectionalIterator, class Allocator>
526 void
527 swap(match_results<BidirectionalIterator, Allocator>& m1,
528 match_results<BidirectionalIterator, Allocator>& m2);
529
530template <class BidirectionalIterator, class Allocator, class charT, class traits>
531 bool
532 regex_match(BidirectionalIterator first, BidirectionalIterator last,
533 match_results<BidirectionalIterator, Allocator>& m,
534 const basic_regex<charT, traits>& e,
535 regex_constants::match_flag_type flags = regex_constants::match_default);
536
537template <class BidirectionalIterator, class charT, class traits>
538 bool
539 regex_match(BidirectionalIterator first, BidirectionalIterator last,
540 const basic_regex<charT, traits>& e,
541 regex_constants::match_flag_type flags = regex_constants::match_default);
542
543template <class charT, class Allocator, class traits>
544 bool
545 regex_match(const charT* str, match_results<const charT*, Allocator>& m,
546 const basic_regex<charT, traits>& e,
547 regex_constants::match_flag_type flags = regex_constants::match_default);
548
549template <class ST, class SA, class Allocator, class charT, class traits>
550 bool
551 regex_match(const basic_string<charT, ST, SA>& s,
552 match_results<typename basic_string<charT, ST, SA>::const_iterator, Allocator>& m,
553 const basic_regex<charT, traits>& e,
554 regex_constants::match_flag_type flags = regex_constants::match_default);
555
Marshall Clow8c950072014-02-19 21:21:11 +0000556template <class ST, class SA, class Allocator, class charT, class traits>
557 bool
558 regex_match(const basic_string<charT, ST, SA>&& s,
559 match_results<typename basic_string<charT, ST, SA>::const_iterator, Allocator>& m,
560 const basic_regex<charT, traits>& e,
561 regex_constants::match_flag_type flags = regex_constants::match_default) = delete; // C++14
562
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000563template <class charT, class traits>
564 bool
565 regex_match(const charT* str, const basic_regex<charT, traits>& e,
566 regex_constants::match_flag_type flags = regex_constants::match_default);
567
568template <class ST, class SA, class charT, class traits>
569 bool
570 regex_match(const basic_string<charT, ST, SA>& s,
571 const basic_regex<charT, traits>& e,
572 regex_constants::match_flag_type flags = regex_constants::match_default);
573
574template <class BidirectionalIterator, class Allocator, class charT, class traits>
575 bool
576 regex_search(BidirectionalIterator first, BidirectionalIterator last,
577 match_results<BidirectionalIterator, Allocator>& m,
578 const basic_regex<charT, traits>& e,
579 regex_constants::match_flag_type flags = regex_constants::match_default);
580
581template <class BidirectionalIterator, class charT, class traits>
582 bool
583 regex_search(BidirectionalIterator first, BidirectionalIterator last,
584 const basic_regex<charT, traits>& e,
585 regex_constants::match_flag_type flags = regex_constants::match_default);
586
587template <class charT, class Allocator, class traits>
588 bool
589 regex_search(const charT* str, match_results<const charT*, Allocator>& m,
590 const basic_regex<charT, traits>& e,
591 regex_constants::match_flag_type flags = regex_constants::match_default);
592
593template <class charT, class traits>
594 bool
595 regex_search(const charT* str, const basic_regex<charT, traits>& e,
596 regex_constants::match_flag_type flags = regex_constants::match_default);
597
598template <class ST, class SA, class charT, class traits>
599 bool
600 regex_search(const basic_string<charT, ST, SA>& s,
601 const basic_regex<charT, traits>& e,
602 regex_constants::match_flag_type flags = regex_constants::match_default);
603
604template <class ST, class SA, class Allocator, class charT, class traits>
605 bool
606 regex_search(const basic_string<charT, ST, SA>& s,
607 match_results<typename basic_string<charT, ST, SA>::const_iterator, Allocator>& m,
608 const basic_regex<charT, traits>& e,
609 regex_constants::match_flag_type flags = regex_constants::match_default);
610
Marshall Clow8c950072014-02-19 21:21:11 +0000611template <class ST, class SA, class Allocator, class charT, class traits>
612 bool
613 regex_search(const basic_string<charT, ST, SA>&& s,
614 match_results<typename basic_string<charT, ST, SA>::const_iterator, Allocator>& m,
615 const basic_regex<charT, traits>& e,
616 regex_constants::match_flag_type flags = regex_constants::match_default) = delete; // C++14
617
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000618template <class OutputIterator, class BidirectionalIterator,
619 class traits, class charT, class ST, class SA>
620 OutputIterator
621 regex_replace(OutputIterator out,
622 BidirectionalIterator first, BidirectionalIterator last,
623 const basic_regex<charT, traits>& e,
624 const basic_string<charT, ST, SA>& fmt,
625 regex_constants::match_flag_type flags = regex_constants::match_default);
626
627template <class OutputIterator, class BidirectionalIterator,
628 class traits, class charT>
629 OutputIterator
630 regex_replace(OutputIterator out,
631 BidirectionalIterator first, BidirectionalIterator last,
632 const basic_regex<charT, traits>& e, const charT* fmt,
633 regex_constants::match_flag_type flags = regex_constants::match_default);
634
635template <class traits, class charT, class ST, class SA, class FST, class FSA>>
636 basic_string<charT, ST, SA>
637 regex_replace(const basic_string<charT, ST, SA>& s,
638 const basic_regex<charT, traits>& e,
639 const basic_string<charT, FST, FSA>& fmt,
640 regex_constants::match_flag_type flags = regex_constants::match_default);
641
642template <class traits, class charT, class ST, class SA>
643 basic_string<charT, ST, SA>
644 regex_replace(const basic_string<charT, ST, SA>& s,
645 const basic_regex<charT, traits>& e, const charT* fmt,
646 regex_constants::match_flag_type flags = regex_constants::match_default);
647
648template <class traits, class charT, class ST, class SA>
649 basic_string<charT>
650 regex_replace(const charT* s,
651 const basic_regex<charT, traits>& e,
652 const basic_string<charT, ST, SA>& fmt,
653 regex_constants::match_flag_type flags = regex_constants::match_default);
654
655template <class traits, class charT>
656 basic_string<charT>
657 regex_replace(const charT* s,
658 const basic_regex<charT, traits>& e,
659 const charT* fmt,
660 regex_constants::match_flag_type flags = regex_constants::match_default);
661
662template <class BidirectionalIterator,
663 class charT = typename iterator_traits< BidirectionalIterator>::value_type,
664 class traits = regex_traits<charT>>
665class regex_iterator
666{
667public:
668 typedef basic_regex<charT, traits> regex_type;
669 typedef match_results<BidirectionalIterator> value_type;
670 typedef ptrdiff_t difference_type;
671 typedef const value_type* pointer;
672 typedef const value_type& reference;
673 typedef forward_iterator_tag iterator_category;
674
675 regex_iterator();
676 regex_iterator(BidirectionalIterator a, BidirectionalIterator b,
677 const regex_type& re,
678 regex_constants::match_flag_type m = regex_constants::match_default);
Marshall Clow8c950072014-02-19 21:21:11 +0000679 regex_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
680 const regex_type&& __re,
681 regex_constants::match_flag_type __m
682 = regex_constants::match_default) = delete; // C++14
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000683 regex_iterator(const regex_iterator&);
684 regex_iterator& operator=(const regex_iterator&);
685
686 bool operator==(const regex_iterator&) const;
687 bool operator!=(const regex_iterator&) const;
688
689 const value_type& operator*() const;
690 const value_type* operator->() const;
691
692 regex_iterator& operator++();
693 regex_iterator operator++(int);
694};
695
696typedef regex_iterator<const char*> cregex_iterator;
697typedef regex_iterator<const wchar_t*> wcregex_iterator;
698typedef regex_iterator<string::const_iterator> sregex_iterator;
699typedef regex_iterator<wstring::const_iterator> wsregex_iterator;
700
701template <class BidirectionalIterator,
702 class charT = typename iterator_traits< BidirectionalIterator>::value_type,
703 class traits = regex_traits<charT>>
704class regex_token_iterator
705{
706public:
707 typedef basic_regex<charT, traits> regex_type;
708 typedef sub_match<BidirectionalIterator> value_type;
709 typedef ptrdiff_t difference_type;
710 typedef const value_type* pointer;
711 typedef const value_type& reference;
712 typedef forward_iterator_tag iterator_category;
713
714 regex_token_iterator();
715 regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
716 const regex_type& re, int submatch = 0,
717 regex_constants::match_flag_type m = regex_constants::match_default);
718 regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
Marshall Clow8c950072014-02-19 21:21:11 +0000719 const regex_type&& re, int submatch = 0,
720 regex_constants::match_flag_type m = regex_constants::match_default) = delete; // C++14
721 regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000722 const regex_type& re, const vector<int>& submatches,
723 regex_constants::match_flag_type m = regex_constants::match_default);
724 regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
Marshall Clow8c950072014-02-19 21:21:11 +0000725 const regex_type&& re, const vector<int>& submatches,
726 regex_constants::match_flag_type m = regex_constants::match_default) = delete; // C++14
727 regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000728 const regex_type& re, initializer_list<int> submatches,
729 regex_constants::match_flag_type m = regex_constants::match_default);
Marshall Clow8c950072014-02-19 21:21:11 +0000730 regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
731 const regex_type&& re, initializer_list<int> submatches,
732 regex_constants::match_flag_type m = regex_constants::match_default) = delete; // C++14
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000733 template <size_t N>
734 regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
735 const regex_type& re, const int (&submatches)[N],
736 regex_constants::match_flag_type m = regex_constants::match_default);
Marshall Clow8c950072014-02-19 21:21:11 +0000737 template <size_t N>
738 regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
739 const regex_type& re, const int (&submatches)[N],
740 regex_constants::match_flag_type m = regex_constants::match_default) = delete // C++14;
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000741 regex_token_iterator(const regex_token_iterator&);
742 regex_token_iterator& operator=(const regex_token_iterator&);
743
744 bool operator==(const regex_token_iterator&) const;
745 bool operator!=(const regex_token_iterator&) const;
746
747 const value_type& operator*() const;
748 const value_type* operator->() const;
749
750 regex_token_iterator& operator++();
751 regex_token_iterator operator++(int);
752};
753
754typedef regex_token_iterator<const char*> cregex_token_iterator;
755typedef regex_token_iterator<const wchar_t*> wcregex_token_iterator;
756typedef regex_token_iterator<string::const_iterator> sregex_token_iterator;
757typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;
758
759} // std
760*/
761
762#include <__config>
763#include <stdexcept>
764#include <__locale>
Howard Hinnant6c891682010-06-24 21:28:00 +0000765#include <initializer_list>
Howard Hinnant67ad2132010-06-29 18:37:43 +0000766#include <utility>
767#include <iterator>
768#include <string>
Howard Hinnant65a3f3d2010-06-30 00:21:42 +0000769#include <memory>
770#include <vector>
Howard Hinnantaa0874c2010-07-12 15:51:17 +0000771#include <deque>
Marshall Clow0a1e7502018-09-12 19:41:40 +0000772#include <version>
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000773
Howard Hinnantaaaa52b2011-10-17 20:05:10 +0000774#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000775#pragma GCC system_header
Howard Hinnantaaaa52b2011-10-17 20:05:10 +0000776#endif
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000777
Eric Fiselierf4433a32017-05-31 22:07:49 +0000778_LIBCPP_PUSH_MACROS
779#include <__undef_macros>
780
781
Marshall Clowd39d21d2017-09-12 17:56:59 +0000782#define _LIBCPP_REGEX_COMPLEXITY_FACTOR 4096
783
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000784_LIBCPP_BEGIN_NAMESPACE_STD
785
786namespace regex_constants
787{
788
789// syntax_option_type
790
791enum syntax_option_type
792{
793 icase = 1 << 0,
794 nosubs = 1 << 1,
795 optimize = 1 << 2,
796 collate = 1 << 3,
Howard Hinnantebbc2b62010-07-27 17:24:17 +0000797 ECMAScript = 0,
798 basic = 1 << 4,
799 extended = 1 << 5,
800 awk = 1 << 6,
801 grep = 1 << 7,
802 egrep = 1 << 8
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000803};
804
Howard Hinnant7ca9d942010-09-23 15:13:20 +0000805inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnant5ddd33c2012-07-21 01:31:58 +0000806_LIBCPP_CONSTEXPR
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000807syntax_option_type
808operator~(syntax_option_type __x)
809{
Marshall Clow924cffa2013-03-22 02:13:55 +0000810 return syntax_option_type(~int(__x) & 0x1FF);
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000811}
812
Howard Hinnant7ca9d942010-09-23 15:13:20 +0000813inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnant5ddd33c2012-07-21 01:31:58 +0000814_LIBCPP_CONSTEXPR
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000815syntax_option_type
816operator&(syntax_option_type __x, syntax_option_type __y)
817{
818 return syntax_option_type(int(__x) & int(__y));
819}
820
Howard Hinnant7ca9d942010-09-23 15:13:20 +0000821inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnant5ddd33c2012-07-21 01:31:58 +0000822_LIBCPP_CONSTEXPR
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000823syntax_option_type
824operator|(syntax_option_type __x, syntax_option_type __y)
825{
826 return syntax_option_type(int(__x) | int(__y));
827}
828
Howard Hinnant7ca9d942010-09-23 15:13:20 +0000829inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnant5ddd33c2012-07-21 01:31:58 +0000830_LIBCPP_CONSTEXPR
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000831syntax_option_type
832operator^(syntax_option_type __x, syntax_option_type __y)
833{
834 return syntax_option_type(int(__x) ^ int(__y));
835}
836
Howard Hinnant7ca9d942010-09-23 15:13:20 +0000837inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000838syntax_option_type&
839operator&=(syntax_option_type& __x, syntax_option_type __y)
840{
841 __x = __x & __y;
842 return __x;
843}
844
Howard Hinnant7ca9d942010-09-23 15:13:20 +0000845inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000846syntax_option_type&
847operator|=(syntax_option_type& __x, syntax_option_type __y)
848{
849 __x = __x | __y;
850 return __x;
851}
852
Howard Hinnant7ca9d942010-09-23 15:13:20 +0000853inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000854syntax_option_type&
855operator^=(syntax_option_type& __x, syntax_option_type __y)
856{
857 __x = __x ^ __y;
858 return __x;
859}
860
861// match_flag_type
862
863enum match_flag_type
864{
865 match_default = 0,
866 match_not_bol = 1 << 0,
867 match_not_eol = 1 << 1,
868 match_not_bow = 1 << 2,
869 match_not_eow = 1 << 3,
870 match_any = 1 << 4,
871 match_not_null = 1 << 5,
872 match_continuous = 1 << 6,
873 match_prev_avail = 1 << 7,
874 format_default = 0,
875 format_sed = 1 << 8,
876 format_no_copy = 1 << 9,
Howard Hinnantd3925342010-08-16 20:21:16 +0000877 format_first_only = 1 << 10,
Tim Shen11113f52016-10-27 21:40:34 +0000878 __no_update_pos = 1 << 11,
879 __full_match = 1 << 12
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000880};
881
Howard Hinnant7ca9d942010-09-23 15:13:20 +0000882inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnant5ddd33c2012-07-21 01:31:58 +0000883_LIBCPP_CONSTEXPR
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000884match_flag_type
885operator~(match_flag_type __x)
886{
Marshall Clow924cffa2013-03-22 02:13:55 +0000887 return match_flag_type(~int(__x) & 0x0FFF);
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000888}
889
Howard Hinnant7ca9d942010-09-23 15:13:20 +0000890inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnant5ddd33c2012-07-21 01:31:58 +0000891_LIBCPP_CONSTEXPR
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000892match_flag_type
893operator&(match_flag_type __x, match_flag_type __y)
894{
895 return match_flag_type(int(__x) & int(__y));
896}
897
Howard Hinnant7ca9d942010-09-23 15:13:20 +0000898inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnant5ddd33c2012-07-21 01:31:58 +0000899_LIBCPP_CONSTEXPR
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000900match_flag_type
901operator|(match_flag_type __x, match_flag_type __y)
902{
903 return match_flag_type(int(__x) | int(__y));
904}
905
Howard Hinnant7ca9d942010-09-23 15:13:20 +0000906inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnant5ddd33c2012-07-21 01:31:58 +0000907_LIBCPP_CONSTEXPR
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000908match_flag_type
909operator^(match_flag_type __x, match_flag_type __y)
910{
911 return match_flag_type(int(__x) ^ int(__y));
912}
913
Howard Hinnant7ca9d942010-09-23 15:13:20 +0000914inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000915match_flag_type&
916operator&=(match_flag_type& __x, match_flag_type __y)
917{
918 __x = __x & __y;
919 return __x;
920}
921
Howard Hinnant7ca9d942010-09-23 15:13:20 +0000922inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000923match_flag_type&
924operator|=(match_flag_type& __x, match_flag_type __y)
925{
926 __x = __x | __y;
927 return __x;
928}
929
Howard Hinnant7ca9d942010-09-23 15:13:20 +0000930inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000931match_flag_type&
932operator^=(match_flag_type& __x, match_flag_type __y)
933{
934 __x = __x ^ __y;
935 return __x;
936}
937
938enum error_type
939{
940 error_collate = 1,
941 error_ctype,
942 error_escape,
943 error_backref,
944 error_brack,
945 error_paren,
946 error_brace,
947 error_badbrace,
948 error_range,
949 error_space,
950 error_badrepeat,
951 error_complexity,
Howard Hinnant6c891682010-06-24 21:28:00 +0000952 error_stack,
Howard Hinnantebbc2b62010-07-27 17:24:17 +0000953 __re_err_grammar,
954 __re_err_empty,
955 __re_err_unknown
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000956};
957
958} // regex_constants
959
960class _LIBCPP_EXCEPTION_ABI regex_error
961 : public runtime_error
962{
963 regex_constants::error_type __code_;
964public:
965 explicit regex_error(regex_constants::error_type __ecode);
966 virtual ~regex_error() throw();
Howard Hinnant7ca9d942010-09-23 15:13:20 +0000967 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000968 regex_constants::error_type code() const {return __code_;}
969};
970
Marshall Clowc8ccc292015-07-28 13:30:47 +0000971template <regex_constants::error_type _Ev>
Louis Dionne16fe2952018-07-11 23:14:33 +0000972_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
Marshall Clowc8ccc292015-07-28 13:30:47 +0000973void __throw_regex_error()
974{
975#ifndef _LIBCPP_NO_EXCEPTIONS
Marshall Clow8bf61bb2015-08-17 21:14:16 +0000976 throw regex_error(_Ev);
977#else
Marshall Clow8fea1612016-08-25 15:09:01 +0000978 _VSTD::abort();
Marshall Clowc8ccc292015-07-28 13:30:47 +0000979#endif
980}
981
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000982template <class _CharT>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000983struct _LIBCPP_TEMPLATE_VIS regex_traits
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000984{
985public:
986 typedef _CharT char_type;
987 typedef basic_string<char_type> string_type;
988 typedef locale locale_type;
Howard Hinnant40b45e12010-06-21 21:01:43 +0000989 typedef ctype_base::mask char_class_type;
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000990
Daniel Sanders81c0eea2016-02-17 13:16:31 +0000991#if defined(__mips__) && defined(__GLIBC__)
992 static const char_class_type __regex_word = static_cast<char_class_type>(_ISbit(15));
993#else
Howard Hinnant40b45e12010-06-21 21:01:43 +0000994 static const char_class_type __regex_word = 0x80;
Daniel Sanders81c0eea2016-02-17 13:16:31 +0000995#endif
996
Howard Hinnanta3af5a32010-06-17 00:34:59 +0000997private:
998 locale __loc_;
999 const ctype<char_type>* __ct_;
1000 const collate<char_type>* __col_;
1001
1002public:
1003 regex_traits();
1004
Howard Hinnant7ca9d942010-09-23 15:13:20 +00001005 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanta3af5a32010-06-17 00:34:59 +00001006 static size_t length(const char_type* __p)
1007 {return char_traits<char_type>::length(__p);}
Howard Hinnant7ca9d942010-09-23 15:13:20 +00001008 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanta3af5a32010-06-17 00:34:59 +00001009 char_type translate(char_type __c) const {return __c;}
1010 char_type translate_nocase(char_type __c) const;
1011 template <class _ForwardIterator>
1012 string_type
1013 transform(_ForwardIterator __f, _ForwardIterator __l) const;
1014 template <class _ForwardIterator>
Howard Hinnant7ca9d942010-09-23 15:13:20 +00001015 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanta3af5a32010-06-17 00:34:59 +00001016 string_type
1017 transform_primary( _ForwardIterator __f, _ForwardIterator __l) const
1018 {return __transform_primary(__f, __l, char_type());}
1019 template <class _ForwardIterator>
Howard Hinnant7ca9d942010-09-23 15:13:20 +00001020 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanta3af5a32010-06-17 00:34:59 +00001021 string_type
1022 lookup_collatename(_ForwardIterator __f, _ForwardIterator __l) const
1023 {return __lookup_collatename(__f, __l, char_type());}
1024 template <class _ForwardIterator>
Howard Hinnant7ca9d942010-09-23 15:13:20 +00001025 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanta3af5a32010-06-17 00:34:59 +00001026 char_class_type
1027 lookup_classname(_ForwardIterator __f, _ForwardIterator __l,
Howard Hinnant40b45e12010-06-21 21:01:43 +00001028 bool __icase = false) const
1029 {return __lookup_classname(__f, __l, __icase, char_type());}
1030 bool isctype(char_type __c, char_class_type __m) const;
Howard Hinnant7ca9d942010-09-23 15:13:20 +00001031 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant40b45e12010-06-21 21:01:43 +00001032 int value(char_type __ch, int __radix) const
Marshall Clowef420192013-10-21 15:43:25 +00001033 {return __regex_traits_value(__ch, __radix);}
Howard Hinnanta3af5a32010-06-17 00:34:59 +00001034 locale_type imbue(locale_type __l);
Howard Hinnant7ca9d942010-09-23 15:13:20 +00001035 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanta3af5a32010-06-17 00:34:59 +00001036 locale_type getloc()const {return __loc_;}
1037
1038private:
1039 void __init();
1040
1041 template <class _ForwardIterator>
1042 string_type
1043 __transform_primary(_ForwardIterator __f, _ForwardIterator __l, char) const;
1044 template <class _ForwardIterator>
1045 string_type
1046 __transform_primary(_ForwardIterator __f, _ForwardIterator __l, wchar_t) const;
1047
1048 template <class _ForwardIterator>
1049 string_type
1050 __lookup_collatename(_ForwardIterator __f, _ForwardIterator __l, char) const;
1051 template <class _ForwardIterator>
1052 string_type
1053 __lookup_collatename(_ForwardIterator __f, _ForwardIterator __l, wchar_t) const;
Howard Hinnant40b45e12010-06-21 21:01:43 +00001054
1055 template <class _ForwardIterator>
1056 char_class_type
1057 __lookup_classname(_ForwardIterator __f, _ForwardIterator __l,
1058 bool __icase, char) const;
1059 template <class _ForwardIterator>
1060 char_class_type
1061 __lookup_classname(_ForwardIterator __f, _ForwardIterator __l,
1062 bool __icase, wchar_t) const;
1063
Marshall Clowef420192013-10-21 15:43:25 +00001064 static int __regex_traits_value(unsigned char __ch, int __radix);
Howard Hinnant7ca9d942010-09-23 15:13:20 +00001065 _LIBCPP_INLINE_VISIBILITY
Marshall Clowef420192013-10-21 15:43:25 +00001066 int __regex_traits_value(char __ch, int __radix) const
1067 {return __regex_traits_value(static_cast<unsigned char>(__ch), __radix);}
Evgeniy Stepanov2fb1cb62015-11-07 01:22:13 +00001068 _LIBCPP_INLINE_VISIBILITY
Marshall Clowef420192013-10-21 15:43:25 +00001069 int __regex_traits_value(wchar_t __ch, int __radix) const;
Howard Hinnanta3af5a32010-06-17 00:34:59 +00001070};
1071
1072template <class _CharT>
Howard Hinnant592cb612013-03-07 19:38:08 +00001073const typename regex_traits<_CharT>::char_class_type
1074regex_traits<_CharT>::__regex_word;
1075
1076template <class _CharT>
Howard Hinnanta3af5a32010-06-17 00:34:59 +00001077regex_traits<_CharT>::regex_traits()
1078{
1079 __init();
1080}
1081
1082template <class _CharT>
1083typename regex_traits<_CharT>::char_type
1084regex_traits<_CharT>::translate_nocase(char_type __c) const
1085{
1086 return __ct_->tolower(__c);
1087}
1088
1089template <class _CharT>
1090template <class _ForwardIterator>
1091typename regex_traits<_CharT>::string_type
1092regex_traits<_CharT>::transform(_ForwardIterator __f, _ForwardIterator __l) const
1093{
1094 string_type __s(__f, __l);
1095 return __col_->transform(__s.data(), __s.data() + __s.size());
1096}
1097
1098template <class _CharT>
1099void
1100regex_traits<_CharT>::__init()
1101{
1102 __ct_ = &use_facet<ctype<char_type> >(__loc_);
1103 __col_ = &use_facet<collate<char_type> >(__loc_);
1104}
1105
1106template <class _CharT>
1107typename regex_traits<_CharT>::locale_type
1108regex_traits<_CharT>::imbue(locale_type __l)
1109{
1110 locale __r = __loc_;
1111 __loc_ = __l;
1112 __init();
1113 return __r;
1114}
1115
1116// transform_primary is very FreeBSD-specific
1117
1118template <class _CharT>
1119template <class _ForwardIterator>
1120typename regex_traits<_CharT>::string_type
1121regex_traits<_CharT>::__transform_primary(_ForwardIterator __f,
1122 _ForwardIterator __l, char) const
1123{
1124 const string_type __s(__f, __l);
1125 string_type __d = __col_->transform(__s.data(), __s.data() + __s.size());
1126 switch (__d.size())
1127 {
1128 case 1:
1129 break;
1130 case 12:
1131 __d[11] = __d[3];
1132 break;
1133 default:
1134 __d.clear();
1135 break;
1136 }
1137 return __d;
1138}
1139
1140template <class _CharT>
1141template <class _ForwardIterator>
1142typename regex_traits<_CharT>::string_type
1143regex_traits<_CharT>::__transform_primary(_ForwardIterator __f,
1144 _ForwardIterator __l, wchar_t) const
1145{
1146 const string_type __s(__f, __l);
1147 string_type __d = __col_->transform(__s.data(), __s.data() + __s.size());
1148 switch (__d.size())
1149 {
1150 case 1:
1151 break;
1152 case 3:
1153 __d[2] = __d[0];
1154 break;
1155 default:
1156 __d.clear();
1157 break;
1158 }
1159 return __d;
1160}
1161
1162// lookup_collatename is very FreeBSD-specific
1163
Howard Hinnanta37d3cf2013-08-12 18:38:34 +00001164_LIBCPP_FUNC_VIS string __get_collation_name(const char* __s);
Howard Hinnanta3af5a32010-06-17 00:34:59 +00001165
1166template <class _CharT>
1167template <class _ForwardIterator>
1168typename regex_traits<_CharT>::string_type
1169regex_traits<_CharT>::__lookup_collatename(_ForwardIterator __f,
1170 _ForwardIterator __l, char) const
1171{
1172 string_type __s(__f, __l);
1173 string_type __r;
1174 if (!__s.empty())
1175 {
1176 __r = __get_collation_name(__s.c_str());
1177 if (__r.empty() && __s.size() <= 2)
1178 {
1179 __r = __col_->transform(__s.data(), __s.data() + __s.size());
1180 if (__r.size() == 1 || __r.size() == 12)
1181 __r = __s;
1182 else
1183 __r.clear();
1184 }
1185 }
1186 return __r;
1187}
1188
1189template <class _CharT>
1190template <class _ForwardIterator>
1191typename regex_traits<_CharT>::string_type
1192regex_traits<_CharT>::__lookup_collatename(_ForwardIterator __f,
1193 _ForwardIterator __l, wchar_t) const
1194{
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();
1199 __i != __e; ++__i)
1200 {
1201 if (static_cast<unsigned>(*__i) >= 127)
1202 return string_type();
1203 __n.push_back(char(*__i));
1204 }
1205 string_type __r;
1206 if (!__s.empty())
1207 {
1208 __n = __get_collation_name(__n.c_str());
1209 if (!__n.empty())
1210 __r.assign(__n.begin(), __n.end());
1211 else if (__s.size() <= 2)
1212 {
1213 __r = __col_->transform(__s.data(), __s.data() + __s.size());
1214 if (__r.size() == 1 || __r.size() == 3)
1215 __r = __s;
1216 else
1217 __r.clear();
1218 }
1219 }
1220 return __r;
1221}
1222
Howard Hinnant40b45e12010-06-21 21:01:43 +00001223// lookup_classname
1224
Dan Albert49f384c2014-07-29 19:23:39 +00001225regex_traits<char>::char_class_type _LIBCPP_FUNC_VIS
1226__get_classname(const char* __s, bool __icase);
Howard Hinnant40b45e12010-06-21 21:01:43 +00001227
1228template <class _CharT>
1229template <class _ForwardIterator>
1230typename regex_traits<_CharT>::char_class_type
1231regex_traits<_CharT>::__lookup_classname(_ForwardIterator __f,
1232 _ForwardIterator __l,
1233 bool __icase, char) const
1234{
1235 string_type __s(__f, __l);
1236 __ct_->tolower(&__s[0], &__s[0] + __s.size());
1237 return __get_classname(__s.c_str(), __icase);
1238}
1239
1240template <class _CharT>
1241template <class _ForwardIterator>
1242typename regex_traits<_CharT>::char_class_type
1243regex_traits<_CharT>::__lookup_classname(_ForwardIterator __f,
1244 _ForwardIterator __l,
1245 bool __icase, wchar_t) const
1246{
1247 string_type __s(__f, __l);
1248 __ct_->tolower(&__s[0], &__s[0] + __s.size());
1249 string __n;
1250 __n.reserve(__s.size());
1251 for (typename string_type::const_iterator __i = __s.begin(), __e = __s.end();
1252 __i != __e; ++__i)
1253 {
1254 if (static_cast<unsigned>(*__i) >= 127)
1255 return char_class_type();
1256 __n.push_back(char(*__i));
1257 }
1258 return __get_classname(__n.c_str(), __icase);
1259}
1260
1261template <class _CharT>
1262bool
1263regex_traits<_CharT>::isctype(char_type __c, char_class_type __m) const
1264{
1265 if (__ct_->is(__m, __c))
1266 return true;
1267 return (__c == '_' && (__m & __regex_word));
1268}
1269
1270template <class _CharT>
1271int
Marshall Clowef420192013-10-21 15:43:25 +00001272regex_traits<_CharT>::__regex_traits_value(unsigned char __ch, int __radix)
Howard Hinnant40b45e12010-06-21 21:01:43 +00001273{
1274 if ((__ch & 0xF8u) == 0x30) // '0' <= __ch && __ch <= '7'
1275 return __ch - '0';
1276 if (__radix != 8)
1277 {
1278 if ((__ch & 0xFEu) == 0x38) // '8' <= __ch && __ch <= '9'
1279 return __ch - '0';
1280 if (__radix == 16)
1281 {
1282 __ch |= 0x20; // tolower
1283 if ('a' <= __ch && __ch <= 'f')
Howard Hinnant6c891682010-06-24 21:28:00 +00001284 return __ch - ('a' - 10);
Howard Hinnant40b45e12010-06-21 21:01:43 +00001285 }
1286 }
1287 return -1;
1288}
1289
1290template <class _CharT>
Evgeniy Stepanov2fb1cb62015-11-07 01:22:13 +00001291inline
Howard Hinnant40b45e12010-06-21 21:01:43 +00001292int
Marshall Clowef420192013-10-21 15:43:25 +00001293regex_traits<_CharT>::__regex_traits_value(wchar_t __ch, int __radix) const
Howard Hinnant40b45e12010-06-21 21:01:43 +00001294{
Marshall Clowef420192013-10-21 15:43:25 +00001295 return __regex_traits_value(static_cast<unsigned char>(__ct_->narrow(__ch, char_type())), __radix);
Howard Hinnant40b45e12010-06-21 21:01:43 +00001296}
1297
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001298template <class _CharT> class __node;
1299
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +00001300template <class _BidirectionalIterator> class _LIBCPP_TEMPLATE_VIS sub_match;
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001301
Howard Hinnant70d27852010-07-27 01:25:38 +00001302template <class _BidirectionalIterator,
1303 class _Allocator = allocator<sub_match<_BidirectionalIterator> > >
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +00001304class _LIBCPP_TEMPLATE_VIS match_results;
Howard Hinnant70d27852010-07-27 01:25:38 +00001305
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001306template <class _CharT>
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001307struct __state
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001308{
1309 enum
1310 {
1311 __end_state = -1000,
1312 __consume_input, // -999
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001313 __begin_marked_expr, // -998
1314 __end_marked_expr, // -997
Howard Hinnant5bf96132010-07-08 17:43:58 +00001315 __pop_state, // -996
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001316 __accept_and_consume, // -995
1317 __accept_but_not_consume, // -994
1318 __reject, // -993
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001319 __split,
1320 __repeat
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001321 };
1322
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001323 int __do_;
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001324 const _CharT* __first_;
1325 const _CharT* __current_;
1326 const _CharT* __last_;
1327 vector<sub_match<const _CharT*> > __sub_matches_;
1328 vector<pair<size_t, const _CharT*> > __loop_data_;
1329 const __node<_CharT>* __node_;
1330 regex_constants::match_flag_type __flags_;
Howard Hinnant066ba512011-03-26 20:02:27 +00001331 bool __at_first_;
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001332
Howard Hinnant7ca9d942010-09-23 15:13:20 +00001333 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001334 __state()
1335 : __do_(0), __first_(nullptr), __current_(nullptr), __last_(nullptr),
1336 __node_(nullptr), __flags_() {}
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001337};
1338
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001339// __node
Howard Hinnant67ad2132010-06-29 18:37:43 +00001340
1341template <class _CharT>
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001342class __node
Howard Hinnant67ad2132010-06-29 18:37:43 +00001343{
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001344 __node(const __node&);
1345 __node& operator=(const __node&);
Howard Hinnant67ad2132010-06-29 18:37:43 +00001346public:
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00001347 typedef _VSTD::__state<_CharT> __state;
Howard Hinnant67ad2132010-06-29 18:37:43 +00001348
Howard Hinnant7ca9d942010-09-23 15:13:20 +00001349 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001350 __node() {}
Howard Hinnant7ca9d942010-09-23 15:13:20 +00001351 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001352 virtual ~__node() {}
Howard Hinnant67ad2132010-06-29 18:37:43 +00001353
Howard Hinnant7ca9d942010-09-23 15:13:20 +00001354 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001355 virtual void __exec(__state&) const {};
Howard Hinnant7ca9d942010-09-23 15:13:20 +00001356 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001357 virtual void __exec_split(bool, __state&) const {};
Howard Hinnant67ad2132010-06-29 18:37:43 +00001358};
1359
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001360// __end_state
Howard Hinnant67ad2132010-06-29 18:37:43 +00001361
1362template <class _CharT>
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001363class __end_state
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001364 : public __node<_CharT>
Howard Hinnant67ad2132010-06-29 18:37:43 +00001365{
Howard Hinnant67ad2132010-06-29 18:37:43 +00001366public:
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00001367 typedef _VSTD::__state<_CharT> __state;
Howard Hinnant67ad2132010-06-29 18:37:43 +00001368
Howard Hinnant7ca9d942010-09-23 15:13:20 +00001369 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001370 __end_state() {}
Howard Hinnantf5cb6eb2010-06-30 17:22:19 +00001371
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001372 virtual void __exec(__state&) const;
Howard Hinnant67ad2132010-06-29 18:37:43 +00001373};
1374
1375template <class _CharT>
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001376void
1377__end_state<_CharT>::__exec(__state& __s) const
Howard Hinnant93ef6552010-06-30 20:30:19 +00001378{
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001379 __s.__do_ = __state::__end_state;
Howard Hinnant93ef6552010-06-30 20:30:19 +00001380}
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001381
1382// __has_one_state
1383
Howard Hinnant93ef6552010-06-30 20:30:19 +00001384template <class _CharT>
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001385class __has_one_state
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001386 : public __node<_CharT>
Howard Hinnantf5cb6eb2010-06-30 17:22:19 +00001387{
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001388 __node<_CharT>* __first_;
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001389
1390public:
Howard Hinnant7ca9d942010-09-23 15:13:20 +00001391 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001392 explicit __has_one_state(__node<_CharT>* __s)
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001393 : __first_(__s) {}
1394
Howard Hinnant7ca9d942010-09-23 15:13:20 +00001395 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001396 __node<_CharT>* first() const {return __first_;}
Howard Hinnant7ca9d942010-09-23 15:13:20 +00001397 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001398 __node<_CharT>*& first() {return __first_;}
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001399};
1400
1401// __owns_one_state
1402
1403template <class _CharT>
1404class __owns_one_state
1405 : public __has_one_state<_CharT>
1406{
1407 typedef __has_one_state<_CharT> base;
1408
1409public:
Howard Hinnant7ca9d942010-09-23 15:13:20 +00001410 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001411 explicit __owns_one_state(__node<_CharT>* __s)
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001412 : base(__s) {}
1413
1414 virtual ~__owns_one_state();
1415};
1416
1417template <class _CharT>
1418__owns_one_state<_CharT>::~__owns_one_state()
1419{
1420 delete this->first();
Howard Hinnantf5cb6eb2010-06-30 17:22:19 +00001421}
1422
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001423// __empty_state
1424
1425template <class _CharT>
1426class __empty_state
1427 : public __owns_one_state<_CharT>
1428{
1429 typedef __owns_one_state<_CharT> base;
1430
1431public:
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00001432 typedef _VSTD::__state<_CharT> __state;
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001433
Howard Hinnant7ca9d942010-09-23 15:13:20 +00001434 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001435 explicit __empty_state(__node<_CharT>* __s)
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001436 : base(__s) {}
1437
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001438 virtual void __exec(__state&) const;
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001439};
1440
1441template <class _CharT>
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001442void
1443__empty_state<_CharT>::__exec(__state& __s) const
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001444{
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001445 __s.__do_ = __state::__accept_but_not_consume;
1446 __s.__node_ = this->first();
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001447}
1448
1449// __empty_non_own_state
1450
1451template <class _CharT>
1452class __empty_non_own_state
1453 : public __has_one_state<_CharT>
1454{
1455 typedef __has_one_state<_CharT> base;
1456
1457public:
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00001458 typedef _VSTD::__state<_CharT> __state;
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001459
Howard Hinnant7ca9d942010-09-23 15:13:20 +00001460 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001461 explicit __empty_non_own_state(__node<_CharT>* __s)
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001462 : base(__s) {}
1463
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001464 virtual void __exec(__state&) const;
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001465};
1466
1467template <class _CharT>
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001468void
1469__empty_non_own_state<_CharT>::__exec(__state& __s) const
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001470{
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001471 __s.__do_ = __state::__accept_but_not_consume;
1472 __s.__node_ = this->first();
1473}
1474
1475// __repeat_one_loop
1476
1477template <class _CharT>
1478class __repeat_one_loop
1479 : public __has_one_state<_CharT>
1480{
1481 typedef __has_one_state<_CharT> base;
1482
1483public:
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00001484 typedef _VSTD::__state<_CharT> __state;
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001485
Howard Hinnant7ca9d942010-09-23 15:13:20 +00001486 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001487 explicit __repeat_one_loop(__node<_CharT>* __s)
1488 : base(__s) {}
1489
1490 virtual void __exec(__state&) const;
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001491};
1492
1493template <class _CharT>
1494void
1495__repeat_one_loop<_CharT>::__exec(__state& __s) const
1496{
1497 __s.__do_ = __state::__repeat;
1498 __s.__node_ = this->first();
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001499}
1500
1501// __owns_two_states
1502
1503template <class _CharT>
1504class __owns_two_states
1505 : public __owns_one_state<_CharT>
1506{
1507 typedef __owns_one_state<_CharT> base;
1508
1509 base* __second_;
1510
1511public:
Howard Hinnant7ca9d942010-09-23 15:13:20 +00001512 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001513 explicit __owns_two_states(__node<_CharT>* __s1, base* __s2)
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001514 : base(__s1), __second_(__s2) {}
1515
1516 virtual ~__owns_two_states();
1517
Howard Hinnant7ca9d942010-09-23 15:13:20 +00001518 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001519 base* second() const {return __second_;}
Howard Hinnant7ca9d942010-09-23 15:13:20 +00001520 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001521 base*& second() {return __second_;}
1522};
1523
1524template <class _CharT>
1525__owns_two_states<_CharT>::~__owns_two_states()
1526{
1527 delete __second_;
1528}
1529
1530// __loop
1531
1532template <class _CharT>
1533class __loop
1534 : public __owns_two_states<_CharT>
1535{
1536 typedef __owns_two_states<_CharT> base;
1537
1538 size_t __min_;
1539 size_t __max_;
1540 unsigned __loop_id_;
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001541 unsigned __mexp_begin_;
1542 unsigned __mexp_end_;
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001543 bool __greedy_;
1544
1545public:
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00001546 typedef _VSTD::__state<_CharT> __state;
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001547
Howard Hinnant7ca9d942010-09-23 15:13:20 +00001548 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001549 explicit __loop(unsigned __loop_id,
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001550 __node<_CharT>* __s1, __owns_one_state<_CharT>* __s2,
1551 unsigned __mexp_begin, unsigned __mexp_end,
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001552 bool __greedy = true,
1553 size_t __min = 0,
1554 size_t __max = numeric_limits<size_t>::max())
1555 : base(__s1, __s2), __min_(__min), __max_(__max), __loop_id_(__loop_id),
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001556 __mexp_begin_(__mexp_begin), __mexp_end_(__mexp_end),
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001557 __greedy_(__greedy) {}
1558
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001559 virtual void __exec(__state& __s) const;
1560 virtual void __exec_split(bool __second, __state& __s) const;
Howard Hinnant5bf96132010-07-08 17:43:58 +00001561
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001562private:
Howard Hinnant7ca9d942010-09-23 15:13:20 +00001563 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001564 void __init_repeat(__state& __s) const
1565 {
1566 __s.__loop_data_[__loop_id_].second = __s.__current_;
1567 for (size_t __i = __mexp_begin_-1; __i != __mexp_end_-1; ++__i)
1568 {
1569 __s.__sub_matches_[__i].first = __s.__last_;
1570 __s.__sub_matches_[__i].second = __s.__last_;
1571 __s.__sub_matches_[__i].matched = false;
1572 }
1573 }
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001574};
1575
1576template <class _CharT>
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001577void
1578__loop<_CharT>::__exec(__state& __s) const
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001579{
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001580 if (__s.__do_ == __state::__repeat)
1581 {
1582 bool __do_repeat = ++__s.__loop_data_[__loop_id_].first < __max_;
1583 bool __do_alt = __s.__loop_data_[__loop_id_].first >= __min_;
1584 if (__do_repeat && __do_alt &&
1585 __s.__loop_data_[__loop_id_].second == __s.__current_)
1586 __do_repeat = false;
1587 if (__do_repeat && __do_alt)
1588 __s.__do_ = __state::__split;
1589 else if (__do_repeat)
1590 {
1591 __s.__do_ = __state::__accept_but_not_consume;
1592 __s.__node_ = this->first();
1593 __init_repeat(__s);
1594 }
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001595 else
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001596 {
1597 __s.__do_ = __state::__accept_but_not_consume;
1598 __s.__node_ = this->second();
1599 }
1600 }
1601 else
1602 {
Howard Hinnantebbc2b62010-07-27 17:24:17 +00001603 __s.__loop_data_[__loop_id_].first = 0;
1604 bool __do_repeat = 0 < __max_;
1605 bool __do_alt = 0 >= __min_;
1606 if (__do_repeat && __do_alt)
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001607 __s.__do_ = __state::__split;
Howard Hinnantebbc2b62010-07-27 17:24:17 +00001608 else if (__do_repeat)
1609 {
1610 __s.__do_ = __state::__accept_but_not_consume;
1611 __s.__node_ = this->first();
1612 __init_repeat(__s);
1613 }
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001614 else
1615 {
1616 __s.__do_ = __state::__accept_but_not_consume;
1617 __s.__node_ = this->second();
1618 }
1619 }
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001620}
1621
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001622template <class _CharT>
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001623void
1624__loop<_CharT>::__exec_split(bool __second, __state& __s) const
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001625{
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001626 __s.__do_ = __state::__accept_but_not_consume;
1627 if (__greedy_ != __second)
Howard Hinnant5bf96132010-07-08 17:43:58 +00001628 {
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001629 __s.__node_ = this->first();
1630 __init_repeat(__s);
Howard Hinnant5bf96132010-07-08 17:43:58 +00001631 }
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001632 else
1633 __s.__node_ = this->second();
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001634}
1635
Howard Hinnant16d65422010-07-16 19:08:36 +00001636// __alternate
1637
1638template <class _CharT>
1639class __alternate
1640 : public __owns_two_states<_CharT>
1641{
1642 typedef __owns_two_states<_CharT> base;
1643
1644public:
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00001645 typedef _VSTD::__state<_CharT> __state;
Howard Hinnant16d65422010-07-16 19:08:36 +00001646
Howard Hinnant7ca9d942010-09-23 15:13:20 +00001647 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant16d65422010-07-16 19:08:36 +00001648 explicit __alternate(__owns_one_state<_CharT>* __s1,
1649 __owns_one_state<_CharT>* __s2)
1650 : base(__s1, __s2) {}
1651
1652 virtual void __exec(__state& __s) const;
1653 virtual void __exec_split(bool __second, __state& __s) const;
Howard Hinnant16d65422010-07-16 19:08:36 +00001654};
1655
1656template <class _CharT>
1657void
1658__alternate<_CharT>::__exec(__state& __s) const
1659{
1660 __s.__do_ = __state::__split;
1661}
1662
1663template <class _CharT>
1664void
1665__alternate<_CharT>::__exec_split(bool __second, __state& __s) const
1666{
1667 __s.__do_ = __state::__accept_but_not_consume;
Howard Hinnantcbf2f3f2010-07-22 14:12:20 +00001668 if (__second)
Howard Hinnant16d65422010-07-16 19:08:36 +00001669 __s.__node_ = this->second();
Howard Hinnantcbf2f3f2010-07-22 14:12:20 +00001670 else
1671 __s.__node_ = this->first();
Howard Hinnant16d65422010-07-16 19:08:36 +00001672}
1673
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001674// __begin_marked_subexpression
1675
1676template <class _CharT>
1677class __begin_marked_subexpression
1678 : public __owns_one_state<_CharT>
1679{
1680 typedef __owns_one_state<_CharT> base;
1681
Howard Hinnant5bf96132010-07-08 17:43:58 +00001682 unsigned __mexp_;
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001683public:
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00001684 typedef _VSTD::__state<_CharT> __state;
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001685
Howard Hinnant7ca9d942010-09-23 15:13:20 +00001686 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001687 explicit __begin_marked_subexpression(unsigned __mexp, __node<_CharT>* __s)
Howard Hinnant5bf96132010-07-08 17:43:58 +00001688 : base(__s), __mexp_(__mexp) {}
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001689
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001690 virtual void __exec(__state&) const;
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001691};
1692
1693template <class _CharT>
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001694void
1695__begin_marked_subexpression<_CharT>::__exec(__state& __s) const
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001696{
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001697 __s.__do_ = __state::__accept_but_not_consume;
1698 __s.__sub_matches_[__mexp_-1].first = __s.__current_;
1699 __s.__node_ = this->first();
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001700}
1701
1702// __end_marked_subexpression
1703
1704template <class _CharT>
1705class __end_marked_subexpression
1706 : public __owns_one_state<_CharT>
1707{
1708 typedef __owns_one_state<_CharT> base;
1709
Howard Hinnant5bf96132010-07-08 17:43:58 +00001710 unsigned __mexp_;
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001711public:
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00001712 typedef _VSTD::__state<_CharT> __state;
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001713
Howard Hinnant7ca9d942010-09-23 15:13:20 +00001714 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001715 explicit __end_marked_subexpression(unsigned __mexp, __node<_CharT>* __s)
Howard Hinnant5bf96132010-07-08 17:43:58 +00001716 : base(__s), __mexp_(__mexp) {}
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001717
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001718 virtual void __exec(__state&) const;
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001719};
1720
1721template <class _CharT>
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001722void
1723__end_marked_subexpression<_CharT>::__exec(__state& __s) const
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001724{
Howard Hinnantaa0874c2010-07-12 15:51:17 +00001725 __s.__do_ = __state::__accept_but_not_consume;
1726 __s.__sub_matches_[__mexp_-1].second = __s.__current_;
1727 __s.__sub_matches_[__mexp_-1].matched = true;
1728 __s.__node_ = this->first();
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001729}
1730
Howard Hinnant2a315e32010-07-12 18:16:05 +00001731// __back_ref
1732
1733template <class _CharT>
1734class __back_ref
1735 : public __owns_one_state<_CharT>
1736{
1737 typedef __owns_one_state<_CharT> base;
1738
1739 unsigned __mexp_;
1740public:
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00001741 typedef _VSTD::__state<_CharT> __state;
Howard Hinnant2a315e32010-07-12 18:16:05 +00001742
Howard Hinnant7ca9d942010-09-23 15:13:20 +00001743 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant2a315e32010-07-12 18:16:05 +00001744 explicit __back_ref(unsigned __mexp, __node<_CharT>* __s)
1745 : base(__s), __mexp_(__mexp) {}
1746
1747 virtual void __exec(__state&) const;
Howard Hinnant2a315e32010-07-12 18:16:05 +00001748};
1749
1750template <class _CharT>
1751void
1752__back_ref<_CharT>::__exec(__state& __s) const
1753{
Marshall Clow360e8392015-08-24 15:57:09 +00001754 if (__mexp_ > __s.__sub_matches_.size())
1755 __throw_regex_error<regex_constants::error_backref>();
Howard Hinnant2a315e32010-07-12 18:16:05 +00001756 sub_match<const _CharT*>& __sm = __s.__sub_matches_[__mexp_-1];
1757 if (__sm.matched)
1758 {
1759 ptrdiff_t __len = __sm.second - __sm.first;
1760 if (__s.__last_ - __s.__current_ >= __len &&
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00001761 _VSTD::equal(__sm.first, __sm.second, __s.__current_))
Howard Hinnant2a315e32010-07-12 18:16:05 +00001762 {
1763 __s.__do_ = __state::__accept_but_not_consume;
1764 __s.__current_ += __len;
1765 __s.__node_ = this->first();
1766 }
1767 else
1768 {
1769 __s.__do_ = __state::__reject;
1770 __s.__node_ = nullptr;
1771 }
1772 }
1773 else
1774 {
1775 __s.__do_ = __state::__reject;
1776 __s.__node_ = nullptr;
1777 }
1778}
1779
Howard Hinnantcfe8d272010-07-12 19:11:27 +00001780// __back_ref_icase
1781
1782template <class _CharT, class _Traits>
1783class __back_ref_icase
1784 : public __owns_one_state<_CharT>
1785{
1786 typedef __owns_one_state<_CharT> base;
1787
1788 _Traits __traits_;
1789 unsigned __mexp_;
1790public:
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00001791 typedef _VSTD::__state<_CharT> __state;
Howard Hinnantcfe8d272010-07-12 19:11:27 +00001792
Howard Hinnant7ca9d942010-09-23 15:13:20 +00001793 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantcfe8d272010-07-12 19:11:27 +00001794 explicit __back_ref_icase(const _Traits& __traits, unsigned __mexp,
1795 __node<_CharT>* __s)
1796 : base(__s), __traits_(__traits), __mexp_(__mexp) {}
1797
1798 virtual void __exec(__state&) const;
Howard Hinnantcfe8d272010-07-12 19:11:27 +00001799};
1800
1801template <class _CharT, class _Traits>
1802void
1803__back_ref_icase<_CharT, _Traits>::__exec(__state& __s) const
1804{
1805 sub_match<const _CharT*>& __sm = __s.__sub_matches_[__mexp_-1];
1806 if (__sm.matched)
1807 {
1808 ptrdiff_t __len = __sm.second - __sm.first;
1809 if (__s.__last_ - __s.__current_ >= __len)
1810 {
1811 for (ptrdiff_t __i = 0; __i < __len; ++__i)
1812 {
1813 if (__traits_.translate_nocase(__sm.first[__i]) !=
1814 __traits_.translate_nocase(__s.__current_[__i]))
1815 goto __not_equal;
1816 }
1817 __s.__do_ = __state::__accept_but_not_consume;
1818 __s.__current_ += __len;
1819 __s.__node_ = this->first();
1820 }
1821 else
1822 {
1823 __s.__do_ = __state::__reject;
1824 __s.__node_ = nullptr;
1825 }
1826 }
1827 else
1828 {
1829__not_equal:
1830 __s.__do_ = __state::__reject;
1831 __s.__node_ = nullptr;
1832 }
1833}
1834
1835// __back_ref_collate
1836
1837template <class _CharT, class _Traits>
1838class __back_ref_collate
1839 : public __owns_one_state<_CharT>
1840{
1841 typedef __owns_one_state<_CharT> base;
1842
1843 _Traits __traits_;
1844 unsigned __mexp_;
1845public:
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00001846 typedef _VSTD::__state<_CharT> __state;
Howard Hinnantcfe8d272010-07-12 19:11:27 +00001847
Howard Hinnant7ca9d942010-09-23 15:13:20 +00001848 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantcfe8d272010-07-12 19:11:27 +00001849 explicit __back_ref_collate(const _Traits& __traits, unsigned __mexp,
1850 __node<_CharT>* __s)
1851 : base(__s), __traits_(__traits), __mexp_(__mexp) {}
1852
1853 virtual void __exec(__state&) const;
Howard Hinnantcfe8d272010-07-12 19:11:27 +00001854};
1855
1856template <class _CharT, class _Traits>
1857void
1858__back_ref_collate<_CharT, _Traits>::__exec(__state& __s) const
1859{
1860 sub_match<const _CharT*>& __sm = __s.__sub_matches_[__mexp_-1];
1861 if (__sm.matched)
1862 {
1863 ptrdiff_t __len = __sm.second - __sm.first;
1864 if (__s.__last_ - __s.__current_ >= __len)
1865 {
1866 for (ptrdiff_t __i = 0; __i < __len; ++__i)
1867 {
1868 if (__traits_.translate(__sm.first[__i]) !=
1869 __traits_.translate(__s.__current_[__i]))
1870 goto __not_equal;
1871 }
1872 __s.__do_ = __state::__accept_but_not_consume;
1873 __s.__current_ += __len;
1874 __s.__node_ = this->first();
1875 }
1876 else
1877 {
1878 __s.__do_ = __state::__reject;
1879 __s.__node_ = nullptr;
1880 }
1881 }
1882 else
1883 {
1884__not_equal:
1885 __s.__do_ = __state::__reject;
1886 __s.__node_ = nullptr;
1887 }
1888}
1889
Howard Hinnant70d27852010-07-27 01:25:38 +00001890// __word_boundary
1891
1892template <class _CharT, class _Traits>
1893class __word_boundary
1894 : public __owns_one_state<_CharT>
1895{
1896 typedef __owns_one_state<_CharT> base;
1897
1898 _Traits __traits_;
1899 bool __invert_;
1900public:
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00001901 typedef _VSTD::__state<_CharT> __state;
Howard Hinnant70d27852010-07-27 01:25:38 +00001902
Howard Hinnant7ca9d942010-09-23 15:13:20 +00001903 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant70d27852010-07-27 01:25:38 +00001904 explicit __word_boundary(const _Traits& __traits, bool __invert,
1905 __node<_CharT>* __s)
1906 : base(__s), __traits_(__traits), __invert_(__invert) {}
1907
1908 virtual void __exec(__state&) const;
Howard Hinnant70d27852010-07-27 01:25:38 +00001909};
1910
1911template <class _CharT, class _Traits>
1912void
1913__word_boundary<_CharT, _Traits>::__exec(__state& __s) const
1914{
1915 bool __is_word_b = false;
1916 if (__s.__first_ != __s.__last_)
1917 {
1918 if (__s.__current_ == __s.__last_)
1919 {
1920 if (!(__s.__flags_ & regex_constants::match_not_eow))
1921 {
1922 _CharT __c = __s.__current_[-1];
1923 __is_word_b = __c == '_' ||
1924 __traits_.isctype(__c, ctype_base::alnum);
1925 }
1926 }
Howard Hinnant6b2602a2010-07-29 15:17:28 +00001927 else if (__s.__current_ == __s.__first_ &&
1928 !(__s.__flags_ & regex_constants::match_prev_avail))
Howard Hinnant70d27852010-07-27 01:25:38 +00001929 {
1930 if (!(__s.__flags_ & regex_constants::match_not_bow))
1931 {
1932 _CharT __c = *__s.__current_;
1933 __is_word_b = __c == '_' ||
1934 __traits_.isctype(__c, ctype_base::alnum);
1935 }
1936 }
1937 else
1938 {
1939 _CharT __c1 = __s.__current_[-1];
1940 _CharT __c2 = *__s.__current_;
1941 bool __is_c1_b = __c1 == '_' ||
1942 __traits_.isctype(__c1, ctype_base::alnum);
1943 bool __is_c2_b = __c2 == '_' ||
1944 __traits_.isctype(__c2, ctype_base::alnum);
1945 __is_word_b = __is_c1_b != __is_c2_b;
1946 }
1947 }
1948 if (__is_word_b != __invert_)
1949 {
1950 __s.__do_ = __state::__accept_but_not_consume;
1951 __s.__node_ = this->first();
1952 }
1953 else
1954 {
1955 __s.__do_ = __state::__reject;
1956 __s.__node_ = nullptr;
1957 }
1958}
1959
Howard Hinnant066ba512011-03-26 20:02:27 +00001960// __l_anchor
1961
1962template <class _CharT>
1963class __l_anchor
1964 : public __owns_one_state<_CharT>
1965{
1966 typedef __owns_one_state<_CharT> base;
1967
1968public:
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00001969 typedef _VSTD::__state<_CharT> __state;
Howard Hinnant066ba512011-03-26 20:02:27 +00001970
1971 _LIBCPP_INLINE_VISIBILITY
1972 __l_anchor(__node<_CharT>* __s)
1973 : base(__s) {}
1974
1975 virtual void __exec(__state&) const;
1976};
1977
1978template <class _CharT>
1979void
1980__l_anchor<_CharT>::__exec(__state& __s) const
1981{
Marshall Clow54404392015-03-19 17:05:59 +00001982 if (__s.__at_first_ && __s.__current_ == __s.__first_ &&
1983 !(__s.__flags_ & regex_constants::match_not_bol))
Howard Hinnant066ba512011-03-26 20:02:27 +00001984 {
1985 __s.__do_ = __state::__accept_but_not_consume;
1986 __s.__node_ = this->first();
1987 }
1988 else
1989 {
1990 __s.__do_ = __state::__reject;
1991 __s.__node_ = nullptr;
1992 }
1993}
1994
Howard Hinnantaad0aa62010-07-09 00:15:26 +00001995// __r_anchor
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001996
1997template <class _CharT>
Howard Hinnantaad0aa62010-07-09 00:15:26 +00001998class __r_anchor
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00001999 : public __owns_one_state<_CharT>
2000{
2001 typedef __owns_one_state<_CharT> base;
2002
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00002003public:
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002004 typedef _VSTD::__state<_CharT> __state;
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00002005
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002006 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaa0874c2010-07-12 15:51:17 +00002007 __r_anchor(__node<_CharT>* __s)
Howard Hinnantaad0aa62010-07-09 00:15:26 +00002008 : base(__s) {}
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00002009
Howard Hinnantaa0874c2010-07-12 15:51:17 +00002010 virtual void __exec(__state&) const;
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00002011};
2012
2013template <class _CharT>
Howard Hinnantaa0874c2010-07-12 15:51:17 +00002014void
2015__r_anchor<_CharT>::__exec(__state& __s) const
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00002016{
Marshall Clow54404392015-03-19 17:05:59 +00002017 if (__s.__current_ == __s.__last_ &&
2018 !(__s.__flags_ & regex_constants::match_not_eol))
Howard Hinnantaa0874c2010-07-12 15:51:17 +00002019 {
2020 __s.__do_ = __state::__accept_but_not_consume;
2021 __s.__node_ = this->first();
2022 }
2023 else
2024 {
2025 __s.__do_ = __state::__reject;
2026 __s.__node_ = nullptr;
2027 }
2028}
2029
2030// __match_any
2031
2032template <class _CharT>
2033class __match_any
2034 : public __owns_one_state<_CharT>
2035{
2036 typedef __owns_one_state<_CharT> base;
2037
2038public:
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002039 typedef _VSTD::__state<_CharT> __state;
Howard Hinnantaa0874c2010-07-12 15:51:17 +00002040
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002041 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaa0874c2010-07-12 15:51:17 +00002042 __match_any(__node<_CharT>* __s)
2043 : base(__s) {}
2044
2045 virtual void __exec(__state&) const;
Howard Hinnantaa0874c2010-07-12 15:51:17 +00002046};
2047
2048template <class _CharT>
2049void
2050__match_any<_CharT>::__exec(__state& __s) const
2051{
2052 if (__s.__current_ != __s.__last_ && *__s.__current_ != 0)
2053 {
2054 __s.__do_ = __state::__accept_and_consume;
2055 ++__s.__current_;
2056 __s.__node_ = this->first();
2057 }
2058 else
2059 {
2060 __s.__do_ = __state::__reject;
2061 __s.__node_ = nullptr;
2062 }
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00002063}
2064
Howard Hinnant70d27852010-07-27 01:25:38 +00002065// __match_any_but_newline
2066
2067template <class _CharT>
2068class __match_any_but_newline
2069 : public __owns_one_state<_CharT>
2070{
2071 typedef __owns_one_state<_CharT> base;
2072
2073public:
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002074 typedef _VSTD::__state<_CharT> __state;
Howard Hinnant70d27852010-07-27 01:25:38 +00002075
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002076 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant70d27852010-07-27 01:25:38 +00002077 __match_any_but_newline(__node<_CharT>* __s)
2078 : base(__s) {}
2079
2080 virtual void __exec(__state&) const;
Howard Hinnant70d27852010-07-27 01:25:38 +00002081};
2082
Howard Hinnanta37d3cf2013-08-12 18:38:34 +00002083template <> _LIBCPP_FUNC_VIS void __match_any_but_newline<char>::__exec(__state&) const;
2084template <> _LIBCPP_FUNC_VIS void __match_any_but_newline<wchar_t>::__exec(__state&) const;
2085
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00002086// __match_char
2087
Howard Hinnantf5cb6eb2010-06-30 17:22:19 +00002088template <class _CharT>
Howard Hinnant67ad2132010-06-29 18:37:43 +00002089class __match_char
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00002090 : public __owns_one_state<_CharT>
Howard Hinnant67ad2132010-06-29 18:37:43 +00002091{
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00002092 typedef __owns_one_state<_CharT> base;
2093
Howard Hinnant67ad2132010-06-29 18:37:43 +00002094 _CharT __c_;
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00002095
2096 __match_char(const __match_char&);
2097 __match_char& operator=(const __match_char&);
Howard Hinnant67ad2132010-06-29 18:37:43 +00002098public:
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002099 typedef _VSTD::__state<_CharT> __state;
Howard Hinnant93ef6552010-06-30 20:30:19 +00002100
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002101 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaa0874c2010-07-12 15:51:17 +00002102 __match_char(_CharT __c, __node<_CharT>* __s)
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00002103 : base(__s), __c_(__c) {}
Howard Hinnant67ad2132010-06-29 18:37:43 +00002104
Howard Hinnantaa0874c2010-07-12 15:51:17 +00002105 virtual void __exec(__state&) const;
Howard Hinnant67ad2132010-06-29 18:37:43 +00002106};
2107
Howard Hinnant93ef6552010-06-30 20:30:19 +00002108template <class _CharT>
Howard Hinnantaa0874c2010-07-12 15:51:17 +00002109void
2110__match_char<_CharT>::__exec(__state& __s) const
Howard Hinnant93ef6552010-06-30 20:30:19 +00002111{
Howard Hinnantaa0874c2010-07-12 15:51:17 +00002112 if (__s.__current_ != __s.__last_ && *__s.__current_ == __c_)
2113 {
2114 __s.__do_ = __state::__accept_and_consume;
2115 ++__s.__current_;
2116 __s.__node_ = this->first();
2117 }
2118 else
2119 {
2120 __s.__do_ = __state::__reject;
2121 __s.__node_ = nullptr;
2122 }
Howard Hinnant93ef6552010-06-30 20:30:19 +00002123}
Howard Hinnant93ef6552010-06-30 20:30:19 +00002124
Howard Hinnantcfe8d272010-07-12 19:11:27 +00002125// __match_char_icase
2126
2127template <class _CharT, class _Traits>
2128class __match_char_icase
2129 : public __owns_one_state<_CharT>
2130{
2131 typedef __owns_one_state<_CharT> base;
2132
2133 _Traits __traits_;
2134 _CharT __c_;
2135
2136 __match_char_icase(const __match_char_icase&);
2137 __match_char_icase& operator=(const __match_char_icase&);
2138public:
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002139 typedef _VSTD::__state<_CharT> __state;
Howard Hinnantcfe8d272010-07-12 19:11:27 +00002140
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002141 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantcfe8d272010-07-12 19:11:27 +00002142 __match_char_icase(const _Traits& __traits, _CharT __c, __node<_CharT>* __s)
2143 : base(__s), __traits_(__traits), __c_(__traits.translate_nocase(__c)) {}
2144
2145 virtual void __exec(__state&) const;
Howard Hinnantcfe8d272010-07-12 19:11:27 +00002146};
2147
2148template <class _CharT, class _Traits>
2149void
2150__match_char_icase<_CharT, _Traits>::__exec(__state& __s) const
2151{
2152 if (__s.__current_ != __s.__last_ &&
2153 __traits_.translate_nocase(*__s.__current_) == __c_)
2154 {
2155 __s.__do_ = __state::__accept_and_consume;
2156 ++__s.__current_;
2157 __s.__node_ = this->first();
2158 }
2159 else
2160 {
2161 __s.__do_ = __state::__reject;
2162 __s.__node_ = nullptr;
2163 }
2164}
2165
2166// __match_char_collate
2167
2168template <class _CharT, class _Traits>
2169class __match_char_collate
2170 : public __owns_one_state<_CharT>
2171{
2172 typedef __owns_one_state<_CharT> base;
2173
2174 _Traits __traits_;
2175 _CharT __c_;
2176
2177 __match_char_collate(const __match_char_collate&);
2178 __match_char_collate& operator=(const __match_char_collate&);
2179public:
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002180 typedef _VSTD::__state<_CharT> __state;
Howard Hinnantcfe8d272010-07-12 19:11:27 +00002181
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002182 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantcfe8d272010-07-12 19:11:27 +00002183 __match_char_collate(const _Traits& __traits, _CharT __c, __node<_CharT>* __s)
2184 : base(__s), __traits_(__traits), __c_(__traits.translate(__c)) {}
2185
2186 virtual void __exec(__state&) const;
Howard Hinnantcfe8d272010-07-12 19:11:27 +00002187};
2188
2189template <class _CharT, class _Traits>
2190void
2191__match_char_collate<_CharT, _Traits>::__exec(__state& __s) const
2192{
2193 if (__s.__current_ != __s.__last_ &&
2194 __traits_.translate(*__s.__current_) == __c_)
2195 {
2196 __s.__do_ = __state::__accept_and_consume;
2197 ++__s.__current_;
2198 __s.__node_ = this->first();
2199 }
2200 else
2201 {
2202 __s.__do_ = __state::__reject;
2203 __s.__node_ = nullptr;
2204 }
2205}
2206
Howard Hinnant3034c902010-07-13 21:48:06 +00002207// __bracket_expression
2208
2209template <class _CharT, class _Traits>
2210class __bracket_expression
2211 : public __owns_one_state<_CharT>
2212{
2213 typedef __owns_one_state<_CharT> base;
2214 typedef typename _Traits::string_type string_type;
2215
2216 _Traits __traits_;
2217 vector<_CharT> __chars_;
Howard Hinnant70b3e192010-07-28 17:35:27 +00002218 vector<_CharT> __neg_chars_;
Howard Hinnant3034c902010-07-13 21:48:06 +00002219 vector<pair<string_type, string_type> > __ranges_;
2220 vector<pair<_CharT, _CharT> > __digraphs_;
2221 vector<string_type> __equivalences_;
Dan Albert49f384c2014-07-29 19:23:39 +00002222 typename regex_traits<_CharT>::char_class_type __mask_;
2223 typename regex_traits<_CharT>::char_class_type __neg_mask_;
Howard Hinnant3034c902010-07-13 21:48:06 +00002224 bool __negate_;
2225 bool __icase_;
2226 bool __collate_;
Howard Hinnant5d4aaa42010-07-14 15:45:11 +00002227 bool __might_have_digraph_;
Howard Hinnant3034c902010-07-13 21:48:06 +00002228
2229 __bracket_expression(const __bracket_expression&);
2230 __bracket_expression& operator=(const __bracket_expression&);
2231public:
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002232 typedef _VSTD::__state<_CharT> __state;
Howard Hinnant3034c902010-07-13 21:48:06 +00002233
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002234 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant3034c902010-07-13 21:48:06 +00002235 __bracket_expression(const _Traits& __traits, __node<_CharT>* __s,
2236 bool __negate, bool __icase, bool __collate)
Howard Hinnant70b3e192010-07-28 17:35:27 +00002237 : base(__s), __traits_(__traits), __mask_(), __neg_mask_(),
2238 __negate_(__negate), __icase_(__icase), __collate_(__collate),
Howard Hinnant5d4aaa42010-07-14 15:45:11 +00002239 __might_have_digraph_(__traits_.getloc().name() != "C") {}
Howard Hinnant3034c902010-07-13 21:48:06 +00002240
2241 virtual void __exec(__state&) const;
2242
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002243 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant70b3e192010-07-28 17:35:27 +00002244 bool __negated() const {return __negate_;}
2245
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002246 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant3034c902010-07-13 21:48:06 +00002247 void __add_char(_CharT __c)
2248 {
2249 if (__icase_)
2250 __chars_.push_back(__traits_.translate_nocase(__c));
2251 else if (__collate_)
2252 __chars_.push_back(__traits_.translate(__c));
2253 else
2254 __chars_.push_back(__c);
2255 }
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002256 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant70b3e192010-07-28 17:35:27 +00002257 void __add_neg_char(_CharT __c)
2258 {
2259 if (__icase_)
2260 __neg_chars_.push_back(__traits_.translate_nocase(__c));
2261 else if (__collate_)
2262 __neg_chars_.push_back(__traits_.translate(__c));
2263 else
2264 __neg_chars_.push_back(__c);
2265 }
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002266 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant3034c902010-07-13 21:48:06 +00002267 void __add_range(string_type __b, string_type __e)
2268 {
2269 if (__collate_)
2270 {
2271 if (__icase_)
2272 {
2273 for (size_t __i = 0; __i < __b.size(); ++__i)
2274 __b[__i] = __traits_.translate_nocase(__b[__i]);
2275 for (size_t __i = 0; __i < __e.size(); ++__i)
2276 __e[__i] = __traits_.translate_nocase(__e[__i]);
2277 }
2278 else
2279 {
2280 for (size_t __i = 0; __i < __b.size(); ++__i)
2281 __b[__i] = __traits_.translate(__b[__i]);
2282 for (size_t __i = 0; __i < __e.size(); ++__i)
2283 __e[__i] = __traits_.translate(__e[__i]);
2284 }
2285 __ranges_.push_back(make_pair(
2286 __traits_.transform(__b.begin(), __b.end()),
2287 __traits_.transform(__e.begin(), __e.end())));
2288 }
2289 else
2290 {
2291 if (__b.size() != 1 || __e.size() != 1)
Marshall Clowc8ccc292015-07-28 13:30:47 +00002292 __throw_regex_error<regex_constants::error_collate>();
Howard Hinnant3034c902010-07-13 21:48:06 +00002293 if (__icase_)
2294 {
2295 __b[0] = __traits_.translate_nocase(__b[0]);
2296 __e[0] = __traits_.translate_nocase(__e[0]);
2297 }
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002298 __ranges_.push_back(make_pair(_VSTD::move(__b), _VSTD::move(__e)));
Howard Hinnant3034c902010-07-13 21:48:06 +00002299 }
2300 }
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002301 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant3034c902010-07-13 21:48:06 +00002302 void __add_digraph(_CharT __c1, _CharT __c2)
2303 {
2304 if (__icase_)
2305 __digraphs_.push_back(make_pair(__traits_.translate_nocase(__c1),
2306 __traits_.translate_nocase(__c2)));
2307 else if (__collate_)
2308 __digraphs_.push_back(make_pair(__traits_.translate(__c1),
2309 __traits_.translate(__c2)));
2310 else
2311 __digraphs_.push_back(make_pair(__c1, __c2));
2312 }
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002313 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant3034c902010-07-13 21:48:06 +00002314 void __add_equivalence(const string_type& __s)
2315 {__equivalences_.push_back(__s);}
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002316 _LIBCPP_INLINE_VISIBILITY
Dan Albert49f384c2014-07-29 19:23:39 +00002317 void __add_class(typename regex_traits<_CharT>::char_class_type __mask)
Howard Hinnant3034c902010-07-13 21:48:06 +00002318 {__mask_ |= __mask;}
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002319 _LIBCPP_INLINE_VISIBILITY
Dan Albert49f384c2014-07-29 19:23:39 +00002320 void __add_neg_class(typename regex_traits<_CharT>::char_class_type __mask)
Howard Hinnant70b3e192010-07-28 17:35:27 +00002321 {__neg_mask_ |= __mask;}
Howard Hinnant3034c902010-07-13 21:48:06 +00002322};
2323
2324template <class _CharT, class _Traits>
2325void
2326__bracket_expression<_CharT, _Traits>::__exec(__state& __s) const
2327{
2328 bool __found = false;
2329 unsigned __consumed = 0;
2330 if (__s.__current_ != __s.__last_)
2331 {
2332 ++__consumed;
Howard Hinnant5d4aaa42010-07-14 15:45:11 +00002333 if (__might_have_digraph_)
Howard Hinnant3034c902010-07-13 21:48:06 +00002334 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002335 const _CharT* __next = _VSTD::next(__s.__current_);
Howard Hinnant5d4aaa42010-07-14 15:45:11 +00002336 if (__next != __s.__last_)
Howard Hinnant3034c902010-07-13 21:48:06 +00002337 {
Howard Hinnant5d4aaa42010-07-14 15:45:11 +00002338 pair<_CharT, _CharT> __ch2(*__s.__current_, *__next);
2339 if (__icase_)
Howard Hinnant3034c902010-07-13 21:48:06 +00002340 {
Howard Hinnant5d4aaa42010-07-14 15:45:11 +00002341 __ch2.first = __traits_.translate_nocase(__ch2.first);
2342 __ch2.second = __traits_.translate_nocase(__ch2.second);
2343 }
2344 else if (__collate_)
2345 {
2346 __ch2.first = __traits_.translate(__ch2.first);
2347 __ch2.second = __traits_.translate(__ch2.second);
2348 }
2349 if (!__traits_.lookup_collatename(&__ch2.first, &__ch2.first+2).empty())
2350 {
2351 // __ch2 is a digraph in this locale
2352 ++__consumed;
2353 for (size_t __i = 0; __i < __digraphs_.size(); ++__i)
2354 {
2355 if (__ch2 == __digraphs_[__i])
2356 {
2357 __found = true;
2358 goto __exit;
2359 }
2360 }
2361 if (__collate_ && !__ranges_.empty())
2362 {
2363 string_type __s2 = __traits_.transform(&__ch2.first,
2364 &__ch2.first + 2);
2365 for (size_t __i = 0; __i < __ranges_.size(); ++__i)
2366 {
2367 if (__ranges_[__i].first <= __s2 &&
2368 __s2 <= __ranges_[__i].second)
2369 {
2370 __found = true;
2371 goto __exit;
2372 }
2373 }
2374 }
2375 if (!__equivalences_.empty())
2376 {
2377 string_type __s2 = __traits_.transform_primary(&__ch2.first,
2378 &__ch2.first + 2);
2379 for (size_t __i = 0; __i < __equivalences_.size(); ++__i)
2380 {
2381 if (__s2 == __equivalences_[__i])
2382 {
2383 __found = true;
2384 goto __exit;
2385 }
2386 }
2387 }
2388 if (__traits_.isctype(__ch2.first, __mask_) &&
2389 __traits_.isctype(__ch2.second, __mask_))
Howard Hinnant3034c902010-07-13 21:48:06 +00002390 {
2391 __found = true;
2392 goto __exit;
2393 }
Howard Hinnant70b3e192010-07-28 17:35:27 +00002394 if (!__traits_.isctype(__ch2.first, __neg_mask_) &&
2395 !__traits_.isctype(__ch2.second, __neg_mask_))
2396 {
2397 __found = true;
2398 goto __exit;
2399 }
Howard Hinnant3034c902010-07-13 21:48:06 +00002400 goto __exit;
2401 }
Howard Hinnant3034c902010-07-13 21:48:06 +00002402 }
2403 }
2404 // test *__s.__current_ as not a digraph
2405 _CharT __ch = *__s.__current_;
2406 if (__icase_)
2407 __ch = __traits_.translate_nocase(__ch);
2408 else if (__collate_)
2409 __ch = __traits_.translate(__ch);
2410 for (size_t __i = 0; __i < __chars_.size(); ++__i)
2411 {
2412 if (__ch == __chars_[__i])
2413 {
2414 __found = true;
2415 goto __exit;
2416 }
2417 }
Louis Dionne9023f022018-08-24 14:10:28 +00002418 // When there's at least one of __neg_chars_ and __neg_mask_, the set
2419 // of "__found" chars is
Marshall Clow42af8d92017-10-18 16:49:22 +00002420 // union(complement(union(__neg_chars_, __neg_mask_)),
2421 // other cases...)
2422 //
Louis Dionne9023f022018-08-24 14:10:28 +00002423 // It doesn't make sense to check this when there are no __neg_chars_
2424 // and no __neg_mask_.
2425 if (!(__neg_mask_ == 0 && __neg_chars_.empty()))
Howard Hinnant70b3e192010-07-28 17:35:27 +00002426 {
Louis Dionne9023f022018-08-24 14:10:28 +00002427 const bool __in_neg_mask = __traits_.isctype(__ch, __neg_mask_);
Marshall Clow42af8d92017-10-18 16:49:22 +00002428 const bool __in_neg_chars =
Marshall Clow42af8d92017-10-18 16:49:22 +00002429 std::find(__neg_chars_.begin(), __neg_chars_.end(), __ch) !=
2430 __neg_chars_.end();
2431 if (!(__in_neg_mask || __in_neg_chars))
2432 {
Howard Hinnant70b3e192010-07-28 17:35:27 +00002433 __found = true;
2434 goto __exit;
Marshall Clow42af8d92017-10-18 16:49:22 +00002435 }
Howard Hinnant70b3e192010-07-28 17:35:27 +00002436 }
Howard Hinnant3034c902010-07-13 21:48:06 +00002437 if (!__ranges_.empty())
2438 {
2439 string_type __s2 = __collate_ ?
2440 __traits_.transform(&__ch, &__ch + 1) :
2441 string_type(1, __ch);
2442 for (size_t __i = 0; __i < __ranges_.size(); ++__i)
2443 {
2444 if (__ranges_[__i].first <= __s2 && __s2 <= __ranges_[__i].second)
2445 {
2446 __found = true;
2447 goto __exit;
2448 }
2449 }
2450 }
2451 if (!__equivalences_.empty())
2452 {
2453 string_type __s2 = __traits_.transform_primary(&__ch, &__ch + 1);
2454 for (size_t __i = 0; __i < __equivalences_.size(); ++__i)
2455 {
2456 if (__s2 == __equivalences_[__i])
2457 {
2458 __found = true;
2459 goto __exit;
2460 }
2461 }
2462 }
2463 if (__traits_.isctype(__ch, __mask_))
Howard Hinnant70b3e192010-07-28 17:35:27 +00002464 {
Howard Hinnant3034c902010-07-13 21:48:06 +00002465 __found = true;
Howard Hinnant70b3e192010-07-28 17:35:27 +00002466 goto __exit;
2467 }
Howard Hinnant3034c902010-07-13 21:48:06 +00002468 }
2469 else
2470 __found = __negate_; // force reject
2471__exit:
2472 if (__found != __negate_)
2473 {
Howard Hinnant3034c902010-07-13 21:48:06 +00002474 __s.__do_ = __state::__accept_and_consume;
2475 __s.__current_ += __consumed;
2476 __s.__node_ = this->first();
2477 }
2478 else
2479 {
2480 __s.__do_ = __state::__reject;
2481 __s.__node_ = nullptr;
2482 }
2483}
2484
Howard Hinnant944510a2011-06-14 19:58:17 +00002485template <class _CharT, class _Traits> class __lookahead;
Howard Hinnantf5cb6eb2010-06-30 17:22:19 +00002486
Howard Hinnant6c891682010-06-24 21:28:00 +00002487template <class _CharT, class _Traits = regex_traits<_CharT> >
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +00002488class _LIBCPP_TEMPLATE_VIS basic_regex
Howard Hinnant6c891682010-06-24 21:28:00 +00002489{
2490public:
2491 // types:
2492 typedef _CharT value_type;
Hubert Tong1f1ae9c2016-08-02 21:34:48 +00002493 typedef _Traits traits_type;
2494 typedef typename _Traits::string_type string_type;
Howard Hinnant6c891682010-06-24 21:28:00 +00002495 typedef regex_constants::syntax_option_type flag_type;
2496 typedef typename _Traits::locale_type locale_type;
2497
2498private:
2499 _Traits __traits_;
2500 flag_type __flags_;
2501 unsigned __marked_count_;
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00002502 unsigned __loop_count_;
Howard Hinnant67ad2132010-06-29 18:37:43 +00002503 int __open_count_;
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00002504 shared_ptr<__empty_state<_CharT> > __start_;
2505 __owns_one_state<_CharT>* __end_;
2506
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002507 typedef _VSTD::__state<_CharT> __state;
2508 typedef _VSTD::__node<_CharT> __node;
Howard Hinnant6c891682010-06-24 21:28:00 +00002509
2510public:
2511 // constants:
Howard Hinnant5ddd33c2012-07-21 01:31:58 +00002512 static const regex_constants::syntax_option_type icase = regex_constants::icase;
2513 static const regex_constants::syntax_option_type nosubs = regex_constants::nosubs;
2514 static const regex_constants::syntax_option_type optimize = regex_constants::optimize;
2515 static const regex_constants::syntax_option_type collate = regex_constants::collate;
2516 static const regex_constants::syntax_option_type ECMAScript = regex_constants::ECMAScript;
2517 static const regex_constants::syntax_option_type basic = regex_constants::basic;
2518 static const regex_constants::syntax_option_type extended = regex_constants::extended;
2519 static const regex_constants::syntax_option_type awk = regex_constants::awk;
2520 static const regex_constants::syntax_option_type grep = regex_constants::grep;
2521 static const regex_constants::syntax_option_type egrep = regex_constants::egrep;
Howard Hinnant6c891682010-06-24 21:28:00 +00002522
2523 // construct/copy/destroy:
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002524 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00002525 basic_regex()
Howard Hinnantaad0aa62010-07-09 00:15:26 +00002526 : __flags_(), __marked_count_(0), __loop_count_(0), __open_count_(0),
Howard Hinnant066ba512011-03-26 20:02:27 +00002527 __end_(0)
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00002528 {}
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002529 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6c891682010-06-24 21:28:00 +00002530 explicit basic_regex(const value_type* __p, flag_type __f = regex_constants::ECMAScript)
Howard Hinnantaad0aa62010-07-09 00:15:26 +00002531 : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
Howard Hinnant066ba512011-03-26 20:02:27 +00002532 __end_(0)
Howard Hinnant6c891682010-06-24 21:28:00 +00002533 {__parse(__p, __p + __traits_.length(__p));}
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002534 _LIBCPP_INLINE_VISIBILITY
Hubert Tong19662862016-08-07 22:26:04 +00002535 basic_regex(const value_type* __p, size_t __len, flag_type __f = regex_constants::ECMAScript)
Howard Hinnantaad0aa62010-07-09 00:15:26 +00002536 : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
Howard Hinnant066ba512011-03-26 20:02:27 +00002537 __end_(0)
Howard Hinnant6c891682010-06-24 21:28:00 +00002538 {__parse(__p, __p + __len);}
Howard Hinnant126da6a2010-07-27 22:20:32 +00002539// basic_regex(const basic_regex&) = default;
2540// basic_regex(basic_regex&&) = default;
Howard Hinnant6c891682010-06-24 21:28:00 +00002541 template <class _ST, class _SA>
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002542 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6c891682010-06-24 21:28:00 +00002543 explicit basic_regex(const basic_string<value_type, _ST, _SA>& __p,
2544 flag_type __f = regex_constants::ECMAScript)
Howard Hinnantaad0aa62010-07-09 00:15:26 +00002545 : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
Howard Hinnant066ba512011-03-26 20:02:27 +00002546 __end_(0)
Howard Hinnant6c891682010-06-24 21:28:00 +00002547 {__parse(__p.begin(), __p.end());}
2548 template <class _ForwardIterator>
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002549 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6c891682010-06-24 21:28:00 +00002550 basic_regex(_ForwardIterator __first, _ForwardIterator __last,
2551 flag_type __f = regex_constants::ECMAScript)
Howard Hinnantaad0aa62010-07-09 00:15:26 +00002552 : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
Howard Hinnant066ba512011-03-26 20:02:27 +00002553 __end_(0)
Howard Hinnant6c891682010-06-24 21:28:00 +00002554 {__parse(__first, __last);}
Eric Fiselier6f8516f2017-04-18 23:42:15 +00002555#ifndef _LIBCPP_CXX03_LANG
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002556 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6c891682010-06-24 21:28:00 +00002557 basic_regex(initializer_list<value_type> __il,
2558 flag_type __f = regex_constants::ECMAScript)
Howard Hinnantaad0aa62010-07-09 00:15:26 +00002559 : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
Howard Hinnant066ba512011-03-26 20:02:27 +00002560 __end_(0)
Howard Hinnant6c891682010-06-24 21:28:00 +00002561 {__parse(__il.begin(), __il.end());}
Eric Fiselier6f8516f2017-04-18 23:42:15 +00002562#endif // _LIBCPP_CXX03_LANG
Howard Hinnant6c891682010-06-24 21:28:00 +00002563
Howard Hinnant997621e2010-08-13 18:11:23 +00002564// ~basic_regex() = default;
Howard Hinnant6c891682010-06-24 21:28:00 +00002565
Howard Hinnant126da6a2010-07-27 22:20:32 +00002566// basic_regex& operator=(const basic_regex&) = default;
2567// basic_regex& operator=(basic_regex&&) = default;
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002568 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant997621e2010-08-13 18:11:23 +00002569 basic_regex& operator=(const value_type* __p)
2570 {return assign(__p);}
Eric Fiselier6f8516f2017-04-18 23:42:15 +00002571#ifndef _LIBCPP_CXX03_LANG
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002572 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant997621e2010-08-13 18:11:23 +00002573 basic_regex& operator=(initializer_list<value_type> __il)
2574 {return assign(__il);}
Eric Fiselier6f8516f2017-04-18 23:42:15 +00002575#endif // _LIBCPP_CXX03_LANG
Howard Hinnant6c891682010-06-24 21:28:00 +00002576 template <class _ST, class _SA>
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002577 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant997621e2010-08-13 18:11:23 +00002578 basic_regex& operator=(const basic_string<value_type, _ST, _SA>& __p)
2579 {return assign(__p);}
Howard Hinnant6c891682010-06-24 21:28:00 +00002580
2581 // assign:
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002582 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant997621e2010-08-13 18:11:23 +00002583 basic_regex& assign(const basic_regex& __that)
2584 {return *this = __that;}
Eric Fiselier6f8516f2017-04-18 23:42:15 +00002585#ifndef _LIBCPP_CXX03_LANG
Howard Hinnant5ddd33c2012-07-21 01:31:58 +00002586 _LIBCPP_INLINE_VISIBILITY
2587 basic_regex& assign(basic_regex&& __that) _NOEXCEPT
2588 {return *this = _VSTD::move(__that);}
2589#endif
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002590 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant997621e2010-08-13 18:11:23 +00002591 basic_regex& assign(const value_type* __p, flag_type __f = regex_constants::ECMAScript)
2592 {return assign(__p, __p + __traits_.length(__p), __f);}
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002593 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant997621e2010-08-13 18:11:23 +00002594 basic_regex& assign(const value_type* __p, size_t __len, flag_type __f)
2595 {return assign(__p, __p + __len, __f);}
Howard Hinnant6c891682010-06-24 21:28:00 +00002596 template <class _ST, class _SA>
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002597 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6c891682010-06-24 21:28:00 +00002598 basic_regex& assign(const basic_string<value_type, _ST, _SA>& __s,
Howard Hinnant997621e2010-08-13 18:11:23 +00002599 flag_type __f = regex_constants::ECMAScript)
2600 {return assign(__s.begin(), __s.end(), __f);}
2601
Howard Hinnant6c891682010-06-24 21:28:00 +00002602 template <class _InputIterator>
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002603 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant997621e2010-08-13 18:11:23 +00002604 typename enable_if
2605 <
2606 __is_input_iterator <_InputIterator>::value &&
2607 !__is_forward_iterator<_InputIterator>::value,
2608 basic_regex&
2609 >::type
2610 assign(_InputIterator __first, _InputIterator __last,
2611 flag_type __f = regex_constants::ECMAScript)
2612 {
2613 basic_string<_CharT> __t(__first, __last);
2614 return assign(__t.begin(), __t.end(), __f);
2615 }
2616
2617private:
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002618 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant997621e2010-08-13 18:11:23 +00002619 void __member_init(flag_type __f)
2620 {
2621 __flags_ = __f;
2622 __marked_count_ = 0;
2623 __loop_count_ = 0;
2624 __open_count_ = 0;
2625 __end_ = nullptr;
Howard Hinnant997621e2010-08-13 18:11:23 +00002626 }
2627public:
2628
2629 template <class _ForwardIterator>
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002630 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant997621e2010-08-13 18:11:23 +00002631 typename enable_if
2632 <
2633 __is_forward_iterator<_ForwardIterator>::value,
2634 basic_regex&
2635 >::type
2636 assign(_ForwardIterator __first, _ForwardIterator __last,
2637 flag_type __f = regex_constants::ECMAScript)
2638 {
Marshall Clowce03dc12015-01-13 16:49:52 +00002639 return assign(basic_regex(__first, __last, __f));
Howard Hinnant997621e2010-08-13 18:11:23 +00002640 }
2641
Eric Fiselier6f8516f2017-04-18 23:42:15 +00002642#ifndef _LIBCPP_CXX03_LANG
Howard Hinnant33711792011-08-12 21:56:02 +00002643
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002644 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6c891682010-06-24 21:28:00 +00002645 basic_regex& assign(initializer_list<value_type> __il,
Howard Hinnant997621e2010-08-13 18:11:23 +00002646 flag_type __f = regex_constants::ECMAScript)
2647 {return assign(__il.begin(), __il.end(), __f);}
Howard Hinnant6c891682010-06-24 21:28:00 +00002648
Eric Fiselier6f8516f2017-04-18 23:42:15 +00002649#endif // _LIBCPP_CXX03_LANG
Howard Hinnant33711792011-08-12 21:56:02 +00002650
Howard Hinnant6c891682010-06-24 21:28:00 +00002651 // const operations:
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002652 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6c891682010-06-24 21:28:00 +00002653 unsigned mark_count() const {return __marked_count_;}
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002654 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6c891682010-06-24 21:28:00 +00002655 flag_type flags() const {return __flags_;}
2656
2657 // locale:
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002658 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant997621e2010-08-13 18:11:23 +00002659 locale_type imbue(locale_type __loc)
2660 {
2661 __member_init(ECMAScript);
2662 __start_.reset();
2663 return __traits_.imbue(__loc);
2664 }
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002665 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6c891682010-06-24 21:28:00 +00002666 locale_type getloc() const {return __traits_.getloc();}
2667
2668 // swap:
Howard Hinnant997621e2010-08-13 18:11:23 +00002669 void swap(basic_regex& __r);
Howard Hinnant6c891682010-06-24 21:28:00 +00002670
2671private:
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002672 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00002673 unsigned __loop_count() const {return __loop_count_;}
2674
Howard Hinnant6c891682010-06-24 21:28:00 +00002675 template <class _ForwardIterator>
Howard Hinnant126da6a2010-07-27 22:20:32 +00002676 _ForwardIterator
2677 __parse(_ForwardIterator __first, _ForwardIterator __last);
Howard Hinnant6c891682010-06-24 21:28:00 +00002678 template <class _ForwardIterator>
2679 _ForwardIterator
2680 __parse_basic_reg_exp(_ForwardIterator __first, _ForwardIterator __last);
2681 template <class _ForwardIterator>
2682 _ForwardIterator
2683 __parse_RE_expression(_ForwardIterator __first, _ForwardIterator __last);
2684 template <class _ForwardIterator>
2685 _ForwardIterator
2686 __parse_simple_RE(_ForwardIterator __first, _ForwardIterator __last);
2687 template <class _ForwardIterator>
2688 _ForwardIterator
2689 __parse_nondupl_RE(_ForwardIterator __first, _ForwardIterator __last);
2690 template <class _ForwardIterator>
2691 _ForwardIterator
2692 __parse_one_char_or_coll_elem_RE(_ForwardIterator __first, _ForwardIterator __last);
2693 template <class _ForwardIterator>
2694 _ForwardIterator
2695 __parse_Back_open_paren(_ForwardIterator __first, _ForwardIterator __last);
2696 template <class _ForwardIterator>
2697 _ForwardIterator
2698 __parse_Back_close_paren(_ForwardIterator __first, _ForwardIterator __last);
2699 template <class _ForwardIterator>
2700 _ForwardIterator
2701 __parse_Back_open_brace(_ForwardIterator __first, _ForwardIterator __last);
2702 template <class _ForwardIterator>
2703 _ForwardIterator
2704 __parse_Back_close_brace(_ForwardIterator __first, _ForwardIterator __last);
2705 template <class _ForwardIterator>
2706 _ForwardIterator
2707 __parse_BACKREF(_ForwardIterator __first, _ForwardIterator __last);
2708 template <class _ForwardIterator>
2709 _ForwardIterator
2710 __parse_ORD_CHAR(_ForwardIterator __first, _ForwardIterator __last);
2711 template <class _ForwardIterator>
2712 _ForwardIterator
2713 __parse_QUOTED_CHAR(_ForwardIterator __first, _ForwardIterator __last);
2714 template <class _ForwardIterator>
2715 _ForwardIterator
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00002716 __parse_RE_dupl_symbol(_ForwardIterator __first, _ForwardIterator __last,
Howard Hinnant5bf96132010-07-08 17:43:58 +00002717 __owns_one_state<_CharT>* __s,
2718 unsigned __mexp_begin, unsigned __mexp_end);
Howard Hinnant89a40572010-06-25 20:56:08 +00002719 template <class _ForwardIterator>
2720 _ForwardIterator
Howard Hinnant16d65422010-07-16 19:08:36 +00002721 __parse_ERE_dupl_symbol(_ForwardIterator __first, _ForwardIterator __last,
2722 __owns_one_state<_CharT>* __s,
2723 unsigned __mexp_begin, unsigned __mexp_end);
Howard Hinnant67ad2132010-06-29 18:37:43 +00002724 template <class _ForwardIterator>
2725 _ForwardIterator
Howard Hinnant89a40572010-06-25 20:56:08 +00002726 __parse_bracket_expression(_ForwardIterator __first, _ForwardIterator __last);
2727 template <class _ForwardIterator>
2728 _ForwardIterator
Howard Hinnant3034c902010-07-13 21:48:06 +00002729 __parse_follow_list(_ForwardIterator __first, _ForwardIterator __last,
2730 __bracket_expression<_CharT, _Traits>* __ml);
Howard Hinnant89a40572010-06-25 20:56:08 +00002731 template <class _ForwardIterator>
2732 _ForwardIterator
Howard Hinnant3034c902010-07-13 21:48:06 +00002733 __parse_expression_term(_ForwardIterator __first, _ForwardIterator __last,
2734 __bracket_expression<_CharT, _Traits>* __ml);
Howard Hinnant89a40572010-06-25 20:56:08 +00002735 template <class _ForwardIterator>
2736 _ForwardIterator
Howard Hinnant3034c902010-07-13 21:48:06 +00002737 __parse_equivalence_class(_ForwardIterator __first, _ForwardIterator __last,
2738 __bracket_expression<_CharT, _Traits>* __ml);
Howard Hinnant89a40572010-06-25 20:56:08 +00002739 template <class _ForwardIterator>
2740 _ForwardIterator
Howard Hinnant3034c902010-07-13 21:48:06 +00002741 __parse_character_class(_ForwardIterator __first, _ForwardIterator __last,
2742 __bracket_expression<_CharT, _Traits>* __ml);
Howard Hinnant89a40572010-06-25 20:56:08 +00002743 template <class _ForwardIterator>
2744 _ForwardIterator
Howard Hinnant3034c902010-07-13 21:48:06 +00002745 __parse_collating_symbol(_ForwardIterator __first, _ForwardIterator __last,
2746 basic_string<_CharT>& __col_sym);
Howard Hinnant89a40572010-06-25 20:56:08 +00002747 template <class _ForwardIterator>
2748 _ForwardIterator
2749 __parse_DUP_COUNT(_ForwardIterator __first, _ForwardIterator __last, int& __c);
Howard Hinnant67ad2132010-06-29 18:37:43 +00002750 template <class _ForwardIterator>
2751 _ForwardIterator
2752 __parse_extended_reg_exp(_ForwardIterator __first, _ForwardIterator __last);
2753 template <class _ForwardIterator>
2754 _ForwardIterator
2755 __parse_ERE_branch(_ForwardIterator __first, _ForwardIterator __last);
2756 template <class _ForwardIterator>
2757 _ForwardIterator
2758 __parse_ERE_expression(_ForwardIterator __first, _ForwardIterator __last);
2759 template <class _ForwardIterator>
2760 _ForwardIterator
2761 __parse_one_char_or_coll_elem_ERE(_ForwardIterator __first, _ForwardIterator __last);
2762 template <class _ForwardIterator>
2763 _ForwardIterator
2764 __parse_ORD_CHAR_ERE(_ForwardIterator __first, _ForwardIterator __last);
2765 template <class _ForwardIterator>
2766 _ForwardIterator
2767 __parse_QUOTED_CHAR_ERE(_ForwardIterator __first, _ForwardIterator __last);
Howard Hinnante1053822010-07-22 17:53:24 +00002768 template <class _ForwardIterator>
2769 _ForwardIterator
2770 __parse_ecma_exp(_ForwardIterator __first, _ForwardIterator __last);
2771 template <class _ForwardIterator>
2772 _ForwardIterator
2773 __parse_alternative(_ForwardIterator __first, _ForwardIterator __last);
2774 template <class _ForwardIterator>
2775 _ForwardIterator
2776 __parse_term(_ForwardIterator __first, _ForwardIterator __last);
2777 template <class _ForwardIterator>
2778 _ForwardIterator
2779 __parse_assertion(_ForwardIterator __first, _ForwardIterator __last);
2780 template <class _ForwardIterator>
2781 _ForwardIterator
2782 __parse_atom(_ForwardIterator __first, _ForwardIterator __last);
2783 template <class _ForwardIterator>
2784 _ForwardIterator
Howard Hinnant70d27852010-07-27 01:25:38 +00002785 __parse_atom_escape(_ForwardIterator __first, _ForwardIterator __last);
2786 template <class _ForwardIterator>
2787 _ForwardIterator
2788 __parse_decimal_escape(_ForwardIterator __first, _ForwardIterator __last);
2789 template <class _ForwardIterator>
2790 _ForwardIterator
2791 __parse_character_class_escape(_ForwardIterator __first, _ForwardIterator __last);
2792 template <class _ForwardIterator>
2793 _ForwardIterator
Howard Hinnant70b3e192010-07-28 17:35:27 +00002794 __parse_character_escape(_ForwardIterator __first, _ForwardIterator __last,
2795 basic_string<_CharT>* __str = nullptr);
Howard Hinnant70d27852010-07-27 01:25:38 +00002796 template <class _ForwardIterator>
2797 _ForwardIterator
2798 __parse_pattern_character(_ForwardIterator __first, _ForwardIterator __last);
Howard Hinnanteaf649e2010-07-27 19:53:10 +00002799 template <class _ForwardIterator>
2800 _ForwardIterator
2801 __parse_grep(_ForwardIterator __first, _ForwardIterator __last);
2802 template <class _ForwardIterator>
2803 _ForwardIterator
2804 __parse_egrep(_ForwardIterator __first, _ForwardIterator __last);
Howard Hinnant70b3e192010-07-28 17:35:27 +00002805 template <class _ForwardIterator>
2806 _ForwardIterator
2807 __parse_class_escape(_ForwardIterator __first, _ForwardIterator __last,
2808 basic_string<_CharT>& __str,
2809 __bracket_expression<_CharT, _Traits>* __ml);
2810 template <class _ForwardIterator>
2811 _ForwardIterator
2812 __parse_awk_escape(_ForwardIterator __first, _ForwardIterator __last,
2813 basic_string<_CharT>* __str = nullptr);
Howard Hinnant6c891682010-06-24 21:28:00 +00002814
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002815 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant066ba512011-03-26 20:02:27 +00002816 void __push_l_anchor();
Howard Hinnantaad0aa62010-07-09 00:15:26 +00002817 void __push_r_anchor();
Howard Hinnantaa0874c2010-07-12 15:51:17 +00002818 void __push_match_any();
Howard Hinnant70d27852010-07-27 01:25:38 +00002819 void __push_match_any_but_newline();
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002820 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant5bf96132010-07-08 17:43:58 +00002821 void __push_greedy_inf_repeat(size_t __min, __owns_one_state<_CharT>* __s,
2822 unsigned __mexp_begin = 0, unsigned __mexp_end = 0)
2823 {__push_loop(__min, numeric_limits<size_t>::max(), __s,
2824 __mexp_begin, __mexp_end);}
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002825 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant70d27852010-07-27 01:25:38 +00002826 void __push_nongreedy_inf_repeat(size_t __min, __owns_one_state<_CharT>* __s,
2827 unsigned __mexp_begin = 0, unsigned __mexp_end = 0)
2828 {__push_loop(__min, numeric_limits<size_t>::max(), __s,
2829 __mexp_begin, __mexp_end, false);}
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00002830 void __push_loop(size_t __min, size_t __max, __owns_one_state<_CharT>* __s,
2831 size_t __mexp_begin = 0, size_t __mexp_end = 0,
2832 bool __greedy = true);
Howard Hinnant3034c902010-07-13 21:48:06 +00002833 __bracket_expression<_CharT, _Traits>* __start_matching_list(bool __negate);
Howard Hinnant67ad2132010-06-29 18:37:43 +00002834 void __push_char(value_type __c);
Howard Hinnant2a315e32010-07-12 18:16:05 +00002835 void __push_back_ref(int __i);
Howard Hinnant16d65422010-07-16 19:08:36 +00002836 void __push_alternation(__owns_one_state<_CharT>* __sa,
2837 __owns_one_state<_CharT>* __sb);
Howard Hinnant93ef6552010-06-30 20:30:19 +00002838 void __push_begin_marked_subexpression();
2839 void __push_end_marked_subexpression(unsigned);
Howard Hinnante1053822010-07-22 17:53:24 +00002840 void __push_empty();
Howard Hinnant70d27852010-07-27 01:25:38 +00002841 void __push_word_boundary(bool);
Howard Hinnant3efac712013-07-23 16:18:04 +00002842 void __push_lookahead(const basic_regex&, bool, unsigned);
Howard Hinnantf5cb6eb2010-06-30 17:22:19 +00002843
Howard Hinnant66423212010-07-14 21:14:52 +00002844 template <class _Allocator>
Howard Hinnantf5cb6eb2010-06-30 17:22:19 +00002845 bool
Howard Hinnant66423212010-07-14 21:14:52 +00002846 __search(const _CharT* __first, const _CharT* __last,
2847 match_results<const _CharT*, _Allocator>& __m,
Howard Hinnantf5cb6eb2010-06-30 17:22:19 +00002848 regex_constants::match_flag_type __flags) const;
2849
Howard Hinnant66423212010-07-14 21:14:52 +00002850 template <class _Allocator>
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00002851 bool
Howard Hinnant66423212010-07-14 21:14:52 +00002852 __match_at_start(const _CharT* __first, const _CharT* __last,
2853 match_results<const _CharT*, _Allocator>& __m,
Howard Hinnant066ba512011-03-26 20:02:27 +00002854 regex_constants::match_flag_type __flags, bool) const;
Howard Hinnant70d27852010-07-27 01:25:38 +00002855 template <class _Allocator>
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00002856 bool
Howard Hinnant70d27852010-07-27 01:25:38 +00002857 __match_at_start_ecma(const _CharT* __first, const _CharT* __last,
2858 match_results<const _CharT*, _Allocator>& __m,
Howard Hinnant066ba512011-03-26 20:02:27 +00002859 regex_constants::match_flag_type __flags, bool) const;
Howard Hinnant66423212010-07-14 21:14:52 +00002860 template <class _Allocator>
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00002861 bool
2862 __match_at_start_posix_nosubs(const _CharT* __first, const _CharT* __last,
Howard Hinnant66423212010-07-14 21:14:52 +00002863 match_results<const _CharT*, _Allocator>& __m,
Howard Hinnant066ba512011-03-26 20:02:27 +00002864 regex_constants::match_flag_type __flags, bool) const;
Howard Hinnant66423212010-07-14 21:14:52 +00002865 template <class _Allocator>
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00002866 bool
Howard Hinnant66423212010-07-14 21:14:52 +00002867 __match_at_start_posix_subs(const _CharT* __first, const _CharT* __last,
2868 match_results<const _CharT*, _Allocator>& __m,
Howard Hinnant066ba512011-03-26 20:02:27 +00002869 regex_constants::match_flag_type __flags, bool) const;
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00002870
Howard Hinnantc834c512011-11-29 18:15:50 +00002871 template <class _Bp, class _Ap, class _Cp, class _Tp>
Howard Hinnantf5cb6eb2010-06-30 17:22:19 +00002872 friend
2873 bool
Howard Hinnantc834c512011-11-29 18:15:50 +00002874 regex_search(_Bp, _Bp, match_results<_Bp, _Ap>&, const basic_regex<_Cp, _Tp>&,
Howard Hinnantf5cb6eb2010-06-30 17:22:19 +00002875 regex_constants::match_flag_type);
Howard Hinnant6c891682010-06-24 21:28:00 +00002876
Howard Hinnantc834c512011-11-29 18:15:50 +00002877 template <class _Ap, class _Cp, class _Tp>
Howard Hinnant66423212010-07-14 21:14:52 +00002878 friend
2879 bool
Howard Hinnantc834c512011-11-29 18:15:50 +00002880 regex_search(const _Cp*, const _Cp*, match_results<const _Cp*, _Ap>&,
2881 const basic_regex<_Cp, _Tp>&, regex_constants::match_flag_type);
Howard Hinnant66423212010-07-14 21:14:52 +00002882
Howard Hinnantc834c512011-11-29 18:15:50 +00002883 template <class _Bp, class _Cp, class _Tp>
Howard Hinnant66423212010-07-14 21:14:52 +00002884 friend
2885 bool
Howard Hinnantc834c512011-11-29 18:15:50 +00002886 regex_search(_Bp, _Bp, const basic_regex<_Cp, _Tp>&,
Howard Hinnant66423212010-07-14 21:14:52 +00002887 regex_constants::match_flag_type);
2888
Howard Hinnantc834c512011-11-29 18:15:50 +00002889 template <class _Cp, class _Tp>
Howard Hinnant66423212010-07-14 21:14:52 +00002890 friend
2891 bool
Howard Hinnantc834c512011-11-29 18:15:50 +00002892 regex_search(const _Cp*, const _Cp*,
2893 const basic_regex<_Cp, _Tp>&, regex_constants::match_flag_type);
Howard Hinnant66423212010-07-14 21:14:52 +00002894
Howard Hinnantc834c512011-11-29 18:15:50 +00002895 template <class _Cp, class _Ap, class _Tp>
Howard Hinnant66423212010-07-14 21:14:52 +00002896 friend
2897 bool
Howard Hinnantc834c512011-11-29 18:15:50 +00002898 regex_search(const _Cp*, match_results<const _Cp*, _Ap>&, const basic_regex<_Cp, _Tp>&,
Howard Hinnant66423212010-07-14 21:14:52 +00002899 regex_constants::match_flag_type);
2900
Howard Hinnantc834c512011-11-29 18:15:50 +00002901 template <class _ST, class _SA, class _Cp, class _Tp>
Howard Hinnant66423212010-07-14 21:14:52 +00002902 friend
2903 bool
Howard Hinnantc834c512011-11-29 18:15:50 +00002904 regex_search(const basic_string<_Cp, _ST, _SA>& __s,
2905 const basic_regex<_Cp, _Tp>& __e,
Howard Hinnant66423212010-07-14 21:14:52 +00002906 regex_constants::match_flag_type __flags);
2907
Howard Hinnantc834c512011-11-29 18:15:50 +00002908 template <class _ST, class _SA, class _Ap, class _Cp, class _Tp>
Howard Hinnant66423212010-07-14 21:14:52 +00002909 friend
2910 bool
Howard Hinnantc834c512011-11-29 18:15:50 +00002911 regex_search(const basic_string<_Cp, _ST, _SA>& __s,
2912 match_results<typename basic_string<_Cp, _ST, _SA>::const_iterator, _Ap>&,
2913 const basic_regex<_Cp, _Tp>& __e,
Howard Hinnant66423212010-07-14 21:14:52 +00002914 regex_constants::match_flag_type __flags);
Howard Hinnant126da6a2010-07-27 22:20:32 +00002915
Howard Hinnant4018c482013-06-29 23:45:43 +00002916 template <class _Iter, class _Ap, class _Cp, class _Tp>
2917 friend
2918 bool
2919 regex_search(__wrap_iter<_Iter> __first,
2920 __wrap_iter<_Iter> __last,
2921 match_results<__wrap_iter<_Iter>, _Ap>& __m,
2922 const basic_regex<_Cp, _Tp>& __e,
2923 regex_constants::match_flag_type __flags);
2924
Howard Hinnant126da6a2010-07-27 22:20:32 +00002925 template <class, class> friend class __lookahead;
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00002926};
Howard Hinnant6c891682010-06-24 21:28:00 +00002927
Marshall Clow2dce1f42018-05-23 01:57:02 +00002928#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
2929template <class _ForwardIterator,
2930 class = typename enable_if<__is_forward_iterator<_ForwardIterator>::value, nullptr_t>::type
2931>
2932basic_regex(_ForwardIterator, _ForwardIterator,
2933 regex_constants::syntax_option_type = regex_constants::ECMAScript)
2934 -> basic_regex<typename iterator_traits<_ForwardIterator>::value_type>;
2935#endif
2936
Howard Hinnant6c891682010-06-24 21:28:00 +00002937template <class _CharT, class _Traits>
Howard Hinnant2c45cb42012-12-12 21:14:28 +00002938 const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::icase;
2939template <class _CharT, class _Traits>
2940 const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::nosubs;
2941template <class _CharT, class _Traits>
2942 const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::optimize;
2943template <class _CharT, class _Traits>
2944 const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::collate;
2945template <class _CharT, class _Traits>
2946 const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::ECMAScript;
2947template <class _CharT, class _Traits>
2948 const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::basic;
2949template <class _CharT, class _Traits>
2950 const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::extended;
2951template <class _CharT, class _Traits>
2952 const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::awk;
2953template <class _CharT, class _Traits>
2954 const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::grep;
2955template <class _CharT, class _Traits>
2956 const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::egrep;
2957
2958template <class _CharT, class _Traits>
Howard Hinnant997621e2010-08-13 18:11:23 +00002959void
2960basic_regex<_CharT, _Traits>::swap(basic_regex& __r)
Howard Hinnant6c891682010-06-24 21:28:00 +00002961{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002962 using _VSTD::swap;
Howard Hinnant997621e2010-08-13 18:11:23 +00002963 swap(__traits_, __r.__traits_);
2964 swap(__flags_, __r.__flags_);
2965 swap(__marked_count_, __r.__marked_count_);
2966 swap(__loop_count_, __r.__loop_count_);
2967 swap(__open_count_, __r.__open_count_);
2968 swap(__start_, __r.__start_);
2969 swap(__end_, __r.__end_);
Howard Hinnant997621e2010-08-13 18:11:23 +00002970}
2971
2972template <class _CharT, class _Traits>
2973inline _LIBCPP_INLINE_VISIBILITY
2974void
2975swap(basic_regex<_CharT, _Traits>& __x, basic_regex<_CharT, _Traits>& __y)
2976{
2977 return __x.swap(__y);
Howard Hinnant6c891682010-06-24 21:28:00 +00002978}
2979
Howard Hinnant126da6a2010-07-27 22:20:32 +00002980// __lookahead
2981
2982template <class _CharT, class _Traits>
2983class __lookahead
2984 : public __owns_one_state<_CharT>
2985{
2986 typedef __owns_one_state<_CharT> base;
2987
2988 basic_regex<_CharT, _Traits> __exp_;
Howard Hinnant3efac712013-07-23 16:18:04 +00002989 unsigned __mexp_;
Howard Hinnant126da6a2010-07-27 22:20:32 +00002990 bool __invert_;
2991
2992 __lookahead(const __lookahead&);
2993 __lookahead& operator=(const __lookahead&);
2994public:
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002995 typedef _VSTD::__state<_CharT> __state;
Howard Hinnant126da6a2010-07-27 22:20:32 +00002996
Howard Hinnant7ca9d942010-09-23 15:13:20 +00002997 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant3efac712013-07-23 16:18:04 +00002998 __lookahead(const basic_regex<_CharT, _Traits>& __exp, bool __invert, __node<_CharT>* __s, unsigned __mexp)
Eric Fiseliera75ee262015-07-22 01:29:41 +00002999 : base(__s), __exp_(__exp), __mexp_(__mexp), __invert_(__invert) {}
Howard Hinnant126da6a2010-07-27 22:20:32 +00003000
3001 virtual void __exec(__state&) const;
Howard Hinnant126da6a2010-07-27 22:20:32 +00003002};
3003
3004template <class _CharT, class _Traits>
3005void
3006__lookahead<_CharT, _Traits>::__exec(__state& __s) const
3007{
3008 match_results<const _CharT*> __m;
3009 __m.__init(1 + __exp_.mark_count(), __s.__current_, __s.__last_);
Tim Shen11113f52016-10-27 21:40:34 +00003010 bool __matched = __exp_.__match_at_start_ecma(
3011 __s.__current_, __s.__last_,
3012 __m,
3013 (__s.__flags_ | regex_constants::match_continuous) &
3014 ~regex_constants::__full_match,
3015 __s.__at_first_ && __s.__current_ == __s.__first_);
Howard Hinnant126da6a2010-07-27 22:20:32 +00003016 if (__matched != __invert_)
3017 {
3018 __s.__do_ = __state::__accept_but_not_consume;
3019 __s.__node_ = this->first();
Howard Hinnant3efac712013-07-23 16:18:04 +00003020 for (unsigned __i = 1; __i < __m.size(); ++__i) {
3021 __s.__sub_matches_[__mexp_ + __i - 1] = __m.__matches_[__i];
3022 }
Howard Hinnant126da6a2010-07-27 22:20:32 +00003023 }
3024 else
3025 {
3026 __s.__do_ = __state::__reject;
3027 __s.__node_ = nullptr;
3028 }
3029}
3030
Howard Hinnant6c891682010-06-24 21:28:00 +00003031template <class _CharT, class _Traits>
3032template <class _ForwardIterator>
Howard Hinnant126da6a2010-07-27 22:20:32 +00003033_ForwardIterator
Howard Hinnant6c891682010-06-24 21:28:00 +00003034basic_regex<_CharT, _Traits>::__parse(_ForwardIterator __first,
3035 _ForwardIterator __last)
3036{
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00003037 {
Howard Hinnantaa0874c2010-07-12 15:51:17 +00003038 unique_ptr<__node> __h(new __end_state<_CharT>);
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00003039 __start_.reset(new __empty_state<_CharT>(__h.get()));
3040 __h.release();
3041 __end_ = __start_.get();
3042 }
Howard Hinnantebbc2b62010-07-27 17:24:17 +00003043 switch (__flags_ & 0x1F0)
Howard Hinnant6c891682010-06-24 21:28:00 +00003044 {
3045 case ECMAScript:
Howard Hinnant126da6a2010-07-27 22:20:32 +00003046 __first = __parse_ecma_exp(__first, __last);
Howard Hinnant6c891682010-06-24 21:28:00 +00003047 break;
3048 case basic:
Howard Hinnant126da6a2010-07-27 22:20:32 +00003049 __first = __parse_basic_reg_exp(__first, __last);
Howard Hinnant6c891682010-06-24 21:28:00 +00003050 break;
3051 case extended:
Howard Hinnant6c891682010-06-24 21:28:00 +00003052 case awk:
Howard Hinnant70b3e192010-07-28 17:35:27 +00003053 __first = __parse_extended_reg_exp(__first, __last);
Howard Hinnant6c891682010-06-24 21:28:00 +00003054 break;
3055 case grep:
Howard Hinnant126da6a2010-07-27 22:20:32 +00003056 __first = __parse_grep(__first, __last);
Howard Hinnant6c891682010-06-24 21:28:00 +00003057 break;
3058 case egrep:
Howard Hinnant126da6a2010-07-27 22:20:32 +00003059 __first = __parse_egrep(__first, __last);
Howard Hinnant6c891682010-06-24 21:28:00 +00003060 break;
3061 default:
Marshall Clowc8ccc292015-07-28 13:30:47 +00003062 __throw_regex_error<regex_constants::__re_err_grammar>();
Howard Hinnant6c891682010-06-24 21:28:00 +00003063 }
Howard Hinnant126da6a2010-07-27 22:20:32 +00003064 return __first;
Howard Hinnant6c891682010-06-24 21:28:00 +00003065}
3066
3067template <class _CharT, class _Traits>
3068template <class _ForwardIterator>
3069_ForwardIterator
3070basic_regex<_CharT, _Traits>::__parse_basic_reg_exp(_ForwardIterator __first,
3071 _ForwardIterator __last)
3072{
3073 if (__first != __last)
3074 {
3075 if (*__first == '^')
3076 {
3077 __push_l_anchor();
3078 ++__first;
3079 }
3080 if (__first != __last)
3081 {
3082 __first = __parse_RE_expression(__first, __last);
3083 if (__first != __last)
3084 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003085 _ForwardIterator __temp = _VSTD::next(__first);
Howard Hinnant6c891682010-06-24 21:28:00 +00003086 if (__temp == __last && *__first == '$')
3087 {
3088 __push_r_anchor();
3089 ++__first;
3090 }
3091 }
3092 }
3093 if (__first != __last)
Marshall Clowc8ccc292015-07-28 13:30:47 +00003094 __throw_regex_error<regex_constants::__re_err_empty>();
Howard Hinnant6c891682010-06-24 21:28:00 +00003095 }
3096 return __first;
3097}
3098
3099template <class _CharT, class _Traits>
3100template <class _ForwardIterator>
3101_ForwardIterator
Howard Hinnant67ad2132010-06-29 18:37:43 +00003102basic_regex<_CharT, _Traits>::__parse_extended_reg_exp(_ForwardIterator __first,
3103 _ForwardIterator __last)
3104{
Howard Hinnant16d65422010-07-16 19:08:36 +00003105 __owns_one_state<_CharT>* __sa = __end_;
3106 _ForwardIterator __temp = __parse_ERE_branch(__first, __last);
3107 if (__temp == __first)
Marshall Clowc8ccc292015-07-28 13:30:47 +00003108 __throw_regex_error<regex_constants::__re_err_empty>();
Howard Hinnant16d65422010-07-16 19:08:36 +00003109 __first = __temp;
3110 while (__first != __last && *__first == '|')
Howard Hinnant67ad2132010-06-29 18:37:43 +00003111 {
Howard Hinnant16d65422010-07-16 19:08:36 +00003112 __owns_one_state<_CharT>* __sb = __end_;
3113 __temp = __parse_ERE_branch(++__first, __last);
Howard Hinnant67ad2132010-06-29 18:37:43 +00003114 if (__temp == __first)
Marshall Clowc8ccc292015-07-28 13:30:47 +00003115 __throw_regex_error<regex_constants::__re_err_empty>();
Howard Hinnant16d65422010-07-16 19:08:36 +00003116 __push_alternation(__sa, __sb);
Howard Hinnant67ad2132010-06-29 18:37:43 +00003117 __first = __temp;
Howard Hinnant67ad2132010-06-29 18:37:43 +00003118 }
3119 return __first;
3120}
3121
3122template <class _CharT, class _Traits>
3123template <class _ForwardIterator>
3124_ForwardIterator
3125basic_regex<_CharT, _Traits>::__parse_ERE_branch(_ForwardIterator __first,
3126 _ForwardIterator __last)
3127{
3128 _ForwardIterator __temp = __parse_ERE_expression(__first, __last);
3129 if (__temp == __first)
Marshall Clowc8ccc292015-07-28 13:30:47 +00003130 __throw_regex_error<regex_constants::__re_err_empty>();
Howard Hinnant67ad2132010-06-29 18:37:43 +00003131 do
3132 {
3133 __first = __temp;
3134 __temp = __parse_ERE_expression(__first, __last);
3135 } while (__temp != __first);
3136 return __first;
3137}
3138
3139template <class _CharT, class _Traits>
3140template <class _ForwardIterator>
3141_ForwardIterator
3142basic_regex<_CharT, _Traits>::__parse_ERE_expression(_ForwardIterator __first,
3143 _ForwardIterator __last)
3144{
Howard Hinnant16d65422010-07-16 19:08:36 +00003145 __owns_one_state<_CharT>* __e = __end_;
3146 unsigned __mexp_begin = __marked_count_;
Howard Hinnant67ad2132010-06-29 18:37:43 +00003147 _ForwardIterator __temp = __parse_one_char_or_coll_elem_ERE(__first, __last);
3148 if (__temp == __first && __temp != __last)
3149 {
3150 switch (*__temp)
3151 {
3152 case '^':
3153 __push_l_anchor();
3154 ++__temp;
3155 break;
3156 case '$':
3157 __push_r_anchor();
3158 ++__temp;
3159 break;
3160 case '(':
Howard Hinnant93ef6552010-06-30 20:30:19 +00003161 __push_begin_marked_subexpression();
3162 unsigned __temp_count = __marked_count_;
Howard Hinnant67ad2132010-06-29 18:37:43 +00003163 ++__open_count_;
3164 __temp = __parse_extended_reg_exp(++__temp, __last);
3165 if (__temp == __last || *__temp != ')')
Marshall Clowc8ccc292015-07-28 13:30:47 +00003166 __throw_regex_error<regex_constants::error_paren>();
Howard Hinnant93ef6552010-06-30 20:30:19 +00003167 __push_end_marked_subexpression(__temp_count);
Howard Hinnant67ad2132010-06-29 18:37:43 +00003168 --__open_count_;
3169 ++__temp;
3170 break;
3171 }
3172 }
3173 if (__temp != __first)
Howard Hinnant16d65422010-07-16 19:08:36 +00003174 __temp = __parse_ERE_dupl_symbol(__temp, __last, __e, __mexp_begin+1,
3175 __marked_count_+1);
Howard Hinnant67ad2132010-06-29 18:37:43 +00003176 __first = __temp;
3177 return __first;
3178}
3179
3180template <class _CharT, class _Traits>
3181template <class _ForwardIterator>
3182_ForwardIterator
Howard Hinnant6c891682010-06-24 21:28:00 +00003183basic_regex<_CharT, _Traits>::__parse_RE_expression(_ForwardIterator __first,
3184 _ForwardIterator __last)
3185{
3186 while (true)
3187 {
3188 _ForwardIterator __temp = __parse_simple_RE(__first, __last);
3189 if (__temp == __first)
3190 break;
3191 __first = __temp;
3192 }
3193 return __first;
3194}
3195
3196template <class _CharT, class _Traits>
3197template <class _ForwardIterator>
3198_ForwardIterator
3199basic_regex<_CharT, _Traits>::__parse_simple_RE(_ForwardIterator __first,
3200 _ForwardIterator __last)
3201{
3202 if (__first != __last)
3203 {
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00003204 __owns_one_state<_CharT>* __e = __end_;
Howard Hinnant5bf96132010-07-08 17:43:58 +00003205 unsigned __mexp_begin = __marked_count_;
Howard Hinnant6c891682010-06-24 21:28:00 +00003206 _ForwardIterator __temp = __parse_nondupl_RE(__first, __last);
3207 if (__temp != __first)
Howard Hinnant5bf96132010-07-08 17:43:58 +00003208 __first = __parse_RE_dupl_symbol(__temp, __last, __e,
3209 __mexp_begin+1, __marked_count_+1);
Howard Hinnant6c891682010-06-24 21:28:00 +00003210 }
3211 return __first;
3212}
3213
3214template <class _CharT, class _Traits>
3215template <class _ForwardIterator>
3216_ForwardIterator
3217basic_regex<_CharT, _Traits>::__parse_nondupl_RE(_ForwardIterator __first,
3218 _ForwardIterator __last)
3219{
3220 _ForwardIterator __temp = __first;
3221 __first = __parse_one_char_or_coll_elem_RE(__first, __last);
3222 if (__temp == __first)
3223 {
3224 __temp = __parse_Back_open_paren(__first, __last);
3225 if (__temp != __first)
3226 {
Howard Hinnant93ef6552010-06-30 20:30:19 +00003227 __push_begin_marked_subexpression();
3228 unsigned __temp_count = __marked_count_;
Howard Hinnant6c891682010-06-24 21:28:00 +00003229 __first = __parse_RE_expression(__temp, __last);
3230 __temp = __parse_Back_close_paren(__first, __last);
3231 if (__temp == __first)
Marshall Clowc8ccc292015-07-28 13:30:47 +00003232 __throw_regex_error<regex_constants::error_paren>();
Howard Hinnant93ef6552010-06-30 20:30:19 +00003233 __push_end_marked_subexpression(__temp_count);
Howard Hinnant6c891682010-06-24 21:28:00 +00003234 __first = __temp;
Howard Hinnant6c891682010-06-24 21:28:00 +00003235 }
3236 else
3237 __first = __parse_BACKREF(__first, __last);
3238 }
3239 return __first;
3240}
3241
3242template <class _CharT, class _Traits>
3243template <class _ForwardIterator>
3244_ForwardIterator
3245basic_regex<_CharT, _Traits>::__parse_one_char_or_coll_elem_RE(
3246 _ForwardIterator __first,
3247 _ForwardIterator __last)
3248{
Howard Hinnant67ad2132010-06-29 18:37:43 +00003249 _ForwardIterator __temp = __parse_ORD_CHAR(__first, __last);
Howard Hinnant6c891682010-06-24 21:28:00 +00003250 if (__temp == __first)
3251 {
Howard Hinnant67ad2132010-06-29 18:37:43 +00003252 __temp = __parse_QUOTED_CHAR(__first, __last);
Howard Hinnant6c891682010-06-24 21:28:00 +00003253 if (__temp == __first)
3254 {
Howard Hinnant67ad2132010-06-29 18:37:43 +00003255 if (__temp != __last && *__temp == '.')
Howard Hinnant6c891682010-06-24 21:28:00 +00003256 {
3257 __push_match_any();
Howard Hinnant67ad2132010-06-29 18:37:43 +00003258 ++__temp;
Howard Hinnant6c891682010-06-24 21:28:00 +00003259 }
3260 else
Howard Hinnant67ad2132010-06-29 18:37:43 +00003261 __temp = __parse_bracket_expression(__first, __last);
Howard Hinnant6c891682010-06-24 21:28:00 +00003262 }
3263 }
Howard Hinnant67ad2132010-06-29 18:37:43 +00003264 __first = __temp;
3265 return __first;
3266}
3267
3268template <class _CharT, class _Traits>
3269template <class _ForwardIterator>
3270_ForwardIterator
3271basic_regex<_CharT, _Traits>::__parse_one_char_or_coll_elem_ERE(
3272 _ForwardIterator __first,
3273 _ForwardIterator __last)
3274{
3275 _ForwardIterator __temp = __parse_ORD_CHAR_ERE(__first, __last);
3276 if (__temp == __first)
3277 {
3278 __temp = __parse_QUOTED_CHAR_ERE(__first, __last);
3279 if (__temp == __first)
3280 {
3281 if (__temp != __last && *__temp == '.')
3282 {
3283 __push_match_any();
3284 ++__temp;
3285 }
3286 else
3287 __temp = __parse_bracket_expression(__first, __last);
3288 }
3289 }
3290 __first = __temp;
Howard Hinnant6c891682010-06-24 21:28:00 +00003291 return __first;
3292}
3293
3294template <class _CharT, class _Traits>
3295template <class _ForwardIterator>
3296_ForwardIterator
3297basic_regex<_CharT, _Traits>::__parse_Back_open_paren(_ForwardIterator __first,
3298 _ForwardIterator __last)
3299{
3300 if (__first != __last)
3301 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003302 _ForwardIterator __temp = _VSTD::next(__first);
Howard Hinnant6c891682010-06-24 21:28:00 +00003303 if (__temp != __last)
3304 {
3305 if (*__first == '\\' && *__temp == '(')
3306 __first = ++__temp;
3307 }
3308 }
3309 return __first;
3310}
3311
3312template <class _CharT, class _Traits>
3313template <class _ForwardIterator>
3314_ForwardIterator
3315basic_regex<_CharT, _Traits>::__parse_Back_close_paren(_ForwardIterator __first,
3316 _ForwardIterator __last)
3317{
3318 if (__first != __last)
3319 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003320 _ForwardIterator __temp = _VSTD::next(__first);
Howard Hinnant6c891682010-06-24 21:28:00 +00003321 if (__temp != __last)
3322 {
3323 if (*__first == '\\' && *__temp == ')')
3324 __first = ++__temp;
3325 }
3326 }
3327 return __first;
3328}
3329
3330template <class _CharT, class _Traits>
3331template <class _ForwardIterator>
3332_ForwardIterator
3333basic_regex<_CharT, _Traits>::__parse_Back_open_brace(_ForwardIterator __first,
3334 _ForwardIterator __last)
3335{
3336 if (__first != __last)
3337 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003338 _ForwardIterator __temp = _VSTD::next(__first);
Howard Hinnant6c891682010-06-24 21:28:00 +00003339 if (__temp != __last)
3340 {
3341 if (*__first == '\\' && *__temp == '{')
3342 __first = ++__temp;
3343 }
3344 }
3345 return __first;
3346}
3347
3348template <class _CharT, class _Traits>
3349template <class _ForwardIterator>
3350_ForwardIterator
3351basic_regex<_CharT, _Traits>::__parse_Back_close_brace(_ForwardIterator __first,
3352 _ForwardIterator __last)
3353{
3354 if (__first != __last)
3355 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003356 _ForwardIterator __temp = _VSTD::next(__first);
Howard Hinnant6c891682010-06-24 21:28:00 +00003357 if (__temp != __last)
3358 {
3359 if (*__first == '\\' && *__temp == '}')
3360 __first = ++__temp;
3361 }
3362 }
3363 return __first;
3364}
3365
3366template <class _CharT, class _Traits>
3367template <class _ForwardIterator>
3368_ForwardIterator
3369basic_regex<_CharT, _Traits>::__parse_BACKREF(_ForwardIterator __first,
3370 _ForwardIterator __last)
3371{
3372 if (__first != __last)
3373 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003374 _ForwardIterator __temp = _VSTD::next(__first);
Howard Hinnant6c891682010-06-24 21:28:00 +00003375 if (__temp != __last)
3376 {
Marshall Clowaa38d972014-01-18 03:40:03 +00003377 if (*__first == '\\')
3378 {
3379 int __val = __traits_.value(*__temp, 10);
3380 if (__val >= 1 && __val <= 9)
3381 {
3382 __push_back_ref(__val);
3383 __first = ++__temp;
3384 }
Howard Hinnant6c891682010-06-24 21:28:00 +00003385 }
3386 }
3387 }
3388 return __first;
3389}
3390
3391template <class _CharT, class _Traits>
3392template <class _ForwardIterator>
3393_ForwardIterator
3394basic_regex<_CharT, _Traits>::__parse_ORD_CHAR(_ForwardIterator __first,
3395 _ForwardIterator __last)
3396{
3397 if (__first != __last)
3398 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003399 _ForwardIterator __temp = _VSTD::next(__first);
Howard Hinnant6c891682010-06-24 21:28:00 +00003400 if (__temp == __last && *__first == '$')
3401 return __first;
3402 // Not called inside a bracket
3403 if (*__first == '.' || *__first == '\\' || *__first == '[')
3404 return __first;
Howard Hinnant89a40572010-06-25 20:56:08 +00003405 __push_char(*__first);
Howard Hinnant6c891682010-06-24 21:28:00 +00003406 ++__first;
3407 }
3408 return __first;
3409}
3410
3411template <class _CharT, class _Traits>
3412template <class _ForwardIterator>
3413_ForwardIterator
Howard Hinnant67ad2132010-06-29 18:37:43 +00003414basic_regex<_CharT, _Traits>::__parse_ORD_CHAR_ERE(_ForwardIterator __first,
3415 _ForwardIterator __last)
3416{
3417 if (__first != __last)
3418 {
3419 switch (*__first)
3420 {
3421 case '^':
3422 case '.':
3423 case '[':
3424 case '$':
3425 case '(':
3426 case '|':
3427 case '*':
3428 case '+':
3429 case '?':
3430 case '{':
3431 case '\\':
3432 break;
3433 case ')':
3434 if (__open_count_ == 0)
3435 {
3436 __push_char(*__first);
3437 ++__first;
3438 }
3439 break;
3440 default:
3441 __push_char(*__first);
3442 ++__first;
3443 break;
3444 }
3445 }
3446 return __first;
3447}
3448
3449template <class _CharT, class _Traits>
3450template <class _ForwardIterator>
3451_ForwardIterator
Howard Hinnant6c891682010-06-24 21:28:00 +00003452basic_regex<_CharT, _Traits>::__parse_QUOTED_CHAR(_ForwardIterator __first,
3453 _ForwardIterator __last)
3454{
3455 if (__first != __last)
3456 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003457 _ForwardIterator __temp = _VSTD::next(__first);
Howard Hinnant6c891682010-06-24 21:28:00 +00003458 if (__temp != __last)
3459 {
3460 if (*__first == '\\')
3461 {
3462 switch (*__temp)
3463 {
3464 case '^':
3465 case '.':
3466 case '*':
3467 case '[':
3468 case '$':
3469 case '\\':
Howard Hinnant89a40572010-06-25 20:56:08 +00003470 __push_char(*__temp);
Howard Hinnant6c891682010-06-24 21:28:00 +00003471 __first = ++__temp;
3472 break;
3473 }
3474 }
3475 }
3476 }
3477 return __first;
3478}
3479
3480template <class _CharT, class _Traits>
3481template <class _ForwardIterator>
3482_ForwardIterator
Howard Hinnant67ad2132010-06-29 18:37:43 +00003483basic_regex<_CharT, _Traits>::__parse_QUOTED_CHAR_ERE(_ForwardIterator __first,
3484 _ForwardIterator __last)
3485{
3486 if (__first != __last)
3487 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003488 _ForwardIterator __temp = _VSTD::next(__first);
Howard Hinnant67ad2132010-06-29 18:37:43 +00003489 if (__temp != __last)
3490 {
3491 if (*__first == '\\')
3492 {
3493 switch (*__temp)
3494 {
3495 case '^':
3496 case '.':
3497 case '*':
3498 case '[':
3499 case '$':
3500 case '\\':
3501 case '(':
3502 case ')':
3503 case '|':
3504 case '+':
3505 case '?':
3506 case '{':
Howard Hinnant73072eb2013-06-28 20:31:05 +00003507 case '}':
Howard Hinnant67ad2132010-06-29 18:37:43 +00003508 __push_char(*__temp);
3509 __first = ++__temp;
3510 break;
Howard Hinnant70b3e192010-07-28 17:35:27 +00003511 default:
3512 if ((__flags_ & 0x1F0) == awk)
3513 __first = __parse_awk_escape(++__first, __last);
3514 break;
Howard Hinnant67ad2132010-06-29 18:37:43 +00003515 }
3516 }
3517 }
3518 }
3519 return __first;
3520}
3521
3522template <class _CharT, class _Traits>
3523template <class _ForwardIterator>
3524_ForwardIterator
Howard Hinnant6c891682010-06-24 21:28:00 +00003525basic_regex<_CharT, _Traits>::__parse_RE_dupl_symbol(_ForwardIterator __first,
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00003526 _ForwardIterator __last,
Howard Hinnant5bf96132010-07-08 17:43:58 +00003527 __owns_one_state<_CharT>* __s,
3528 unsigned __mexp_begin,
3529 unsigned __mexp_end)
Howard Hinnant6c891682010-06-24 21:28:00 +00003530{
3531 if (__first != __last)
3532 {
Howard Hinnant89a40572010-06-25 20:56:08 +00003533 if (*__first == '*')
Howard Hinnant6c891682010-06-24 21:28:00 +00003534 {
Howard Hinnant5bf96132010-07-08 17:43:58 +00003535 __push_greedy_inf_repeat(0, __s, __mexp_begin, __mexp_end);
Howard Hinnant6c891682010-06-24 21:28:00 +00003536 ++__first;
3537 }
3538 else
3539 {
3540 _ForwardIterator __temp = __parse_Back_open_brace(__first, __last);
3541 if (__temp != __first)
3542 {
3543 int __min = 0;
3544 __first = __temp;
3545 __temp = __parse_DUP_COUNT(__first, __last, __min);
3546 if (__temp == __first)
Marshall Clowc8ccc292015-07-28 13:30:47 +00003547 __throw_regex_error<regex_constants::error_badbrace>();
Howard Hinnant6c891682010-06-24 21:28:00 +00003548 __first = __temp;
3549 if (__first == __last)
Marshall Clowc8ccc292015-07-28 13:30:47 +00003550 __throw_regex_error<regex_constants::error_brace>();
Howard Hinnant6c891682010-06-24 21:28:00 +00003551 if (*__first != ',')
3552 {
3553 __temp = __parse_Back_close_brace(__first, __last);
3554 if (__temp == __first)
Marshall Clowc8ccc292015-07-28 13:30:47 +00003555 __throw_regex_error<regex_constants::error_brace>();
Howard Hinnant2a315e32010-07-12 18:16:05 +00003556 __push_loop(__min, __min, __s, __mexp_begin, __mexp_end,
3557 true);
Howard Hinnant6c891682010-06-24 21:28:00 +00003558 __first = __temp;
3559 }
3560 else
3561 {
3562 ++__first; // consume ','
3563 int __max = -1;
3564 __first = __parse_DUP_COUNT(__first, __last, __max);
3565 __temp = __parse_Back_close_brace(__first, __last);
3566 if (__temp == __first)
Marshall Clowc8ccc292015-07-28 13:30:47 +00003567 __throw_regex_error<regex_constants::error_brace>();
Howard Hinnant6c891682010-06-24 21:28:00 +00003568 if (__max == -1)
Howard Hinnant16d65422010-07-16 19:08:36 +00003569 __push_greedy_inf_repeat(__min, __s, __mexp_begin, __mexp_end);
Howard Hinnant6c891682010-06-24 21:28:00 +00003570 else
3571 {
3572 if (__max < __min)
Marshall Clowc8ccc292015-07-28 13:30:47 +00003573 __throw_regex_error<regex_constants::error_badbrace>();
Howard Hinnant2a315e32010-07-12 18:16:05 +00003574 __push_loop(__min, __max, __s, __mexp_begin, __mexp_end,
3575 true);
Howard Hinnant6c891682010-06-24 21:28:00 +00003576 }
3577 __first = __temp;
3578 }
3579 }
3580 }
3581 }
3582 return __first;
3583}
3584
Howard Hinnant89a40572010-06-25 20:56:08 +00003585template <class _CharT, class _Traits>
3586template <class _ForwardIterator>
3587_ForwardIterator
Howard Hinnant67ad2132010-06-29 18:37:43 +00003588basic_regex<_CharT, _Traits>::__parse_ERE_dupl_symbol(_ForwardIterator __first,
Howard Hinnant16d65422010-07-16 19:08:36 +00003589 _ForwardIterator __last,
3590 __owns_one_state<_CharT>* __s,
3591 unsigned __mexp_begin,
3592 unsigned __mexp_end)
Howard Hinnant67ad2132010-06-29 18:37:43 +00003593{
3594 if (__first != __last)
3595 {
Howard Hinnant446e9c62010-07-29 00:36:00 +00003596 unsigned __grammar = __flags_ & 0x1F0;
Howard Hinnant67ad2132010-06-29 18:37:43 +00003597 switch (*__first)
3598 {
3599 case '*':
Howard Hinnant67ad2132010-06-29 18:37:43 +00003600 ++__first;
Howard Hinnant446e9c62010-07-29 00:36:00 +00003601 if (__grammar == ECMAScript && __first != __last && *__first == '?')
Howard Hinnant70d27852010-07-27 01:25:38 +00003602 {
3603 ++__first;
3604 __push_nongreedy_inf_repeat(0, __s, __mexp_begin, __mexp_end);
3605 }
3606 else
3607 __push_greedy_inf_repeat(0, __s, __mexp_begin, __mexp_end);
Howard Hinnant67ad2132010-06-29 18:37:43 +00003608 break;
3609 case '+':
Howard Hinnant67ad2132010-06-29 18:37:43 +00003610 ++__first;
Howard Hinnant446e9c62010-07-29 00:36:00 +00003611 if (__grammar == ECMAScript && __first != __last && *__first == '?')
Howard Hinnant70d27852010-07-27 01:25:38 +00003612 {
3613 ++__first;
3614 __push_nongreedy_inf_repeat(1, __s, __mexp_begin, __mexp_end);
3615 }
3616 else
3617 __push_greedy_inf_repeat(1, __s, __mexp_begin, __mexp_end);
Howard Hinnant67ad2132010-06-29 18:37:43 +00003618 break;
3619 case '?':
Howard Hinnant67ad2132010-06-29 18:37:43 +00003620 ++__first;
Howard Hinnant446e9c62010-07-29 00:36:00 +00003621 if (__grammar == ECMAScript && __first != __last && *__first == '?')
Howard Hinnant70d27852010-07-27 01:25:38 +00003622 {
3623 ++__first;
3624 __push_loop(0, 1, __s, __mexp_begin, __mexp_end, false);
3625 }
3626 else
3627 __push_loop(0, 1, __s, __mexp_begin, __mexp_end);
Howard Hinnant67ad2132010-06-29 18:37:43 +00003628 break;
3629 case '{':
3630 {
3631 int __min;
Howard Hinnant16d65422010-07-16 19:08:36 +00003632 _ForwardIterator __temp = __parse_DUP_COUNT(++__first, __last, __min);
Howard Hinnant67ad2132010-06-29 18:37:43 +00003633 if (__temp == __first)
Marshall Clowc8ccc292015-07-28 13:30:47 +00003634 __throw_regex_error<regex_constants::error_badbrace>();
Howard Hinnant67ad2132010-06-29 18:37:43 +00003635 __first = __temp;
3636 if (__first == __last)
Marshall Clowc8ccc292015-07-28 13:30:47 +00003637 __throw_regex_error<regex_constants::error_brace>();
Howard Hinnant67ad2132010-06-29 18:37:43 +00003638 switch (*__first)
3639 {
3640 case '}':
Howard Hinnant67ad2132010-06-29 18:37:43 +00003641 ++__first;
Howard Hinnant446e9c62010-07-29 00:36:00 +00003642 if (__grammar == ECMAScript && __first != __last && *__first == '?')
Howard Hinnant70d27852010-07-27 01:25:38 +00003643 {
3644 ++__first;
3645 __push_loop(__min, __min, __s, __mexp_begin, __mexp_end, false);
3646 }
3647 else
3648 __push_loop(__min, __min, __s, __mexp_begin, __mexp_end);
Howard Hinnant67ad2132010-06-29 18:37:43 +00003649 break;
3650 case ',':
Howard Hinnant72f73582010-08-11 17:04:31 +00003651 ++__first;
Howard Hinnant72f73582010-08-11 17:04:31 +00003652 if (__first == __last)
Marshall Clowc8ccc292015-07-28 13:30:47 +00003653 __throw_regex_error<regex_constants::error_badbrace>();
Howard Hinnant67ad2132010-06-29 18:37:43 +00003654 if (*__first == '}')
3655 {
Howard Hinnant67ad2132010-06-29 18:37:43 +00003656 ++__first;
Howard Hinnant446e9c62010-07-29 00:36:00 +00003657 if (__grammar == ECMAScript && __first != __last && *__first == '?')
Howard Hinnant70d27852010-07-27 01:25:38 +00003658 {
3659 ++__first;
3660 __push_nongreedy_inf_repeat(__min, __s, __mexp_begin, __mexp_end);
3661 }
3662 else
3663 __push_greedy_inf_repeat(__min, __s, __mexp_begin, __mexp_end);
Howard Hinnant67ad2132010-06-29 18:37:43 +00003664 }
3665 else
3666 {
Howard Hinnant16d65422010-07-16 19:08:36 +00003667 int __max = -1;
Howard Hinnant67ad2132010-06-29 18:37:43 +00003668 __temp = __parse_DUP_COUNT(__first, __last, __max);
3669 if (__temp == __first)
Marshall Clowc8ccc292015-07-28 13:30:47 +00003670 __throw_regex_error<regex_constants::error_brace>();
Howard Hinnant67ad2132010-06-29 18:37:43 +00003671 __first = __temp;
3672 if (__first == __last || *__first != '}')
Marshall Clowc8ccc292015-07-28 13:30:47 +00003673 __throw_regex_error<regex_constants::error_brace>();
Howard Hinnant67ad2132010-06-29 18:37:43 +00003674 ++__first;
3675 if (__max < __min)
Marshall Clowc8ccc292015-07-28 13:30:47 +00003676 __throw_regex_error<regex_constants::error_badbrace>();
Howard Hinnant446e9c62010-07-29 00:36:00 +00003677 if (__grammar == ECMAScript && __first != __last && *__first == '?')
Howard Hinnant70d27852010-07-27 01:25:38 +00003678 {
3679 ++__first;
3680 __push_loop(__min, __max, __s, __mexp_begin, __mexp_end, false);
3681 }
3682 else
3683 __push_loop(__min, __max, __s, __mexp_begin, __mexp_end);
Howard Hinnant67ad2132010-06-29 18:37:43 +00003684 }
Howard Hinnant16d65422010-07-16 19:08:36 +00003685 break;
Howard Hinnant67ad2132010-06-29 18:37:43 +00003686 default:
Marshall Clowc8ccc292015-07-28 13:30:47 +00003687 __throw_regex_error<regex_constants::error_badbrace>();
Howard Hinnant67ad2132010-06-29 18:37:43 +00003688 }
3689 }
3690 break;
3691 }
3692 }
3693 return __first;
3694}
3695
3696template <class _CharT, class _Traits>
3697template <class _ForwardIterator>
3698_ForwardIterator
Howard Hinnant89a40572010-06-25 20:56:08 +00003699basic_regex<_CharT, _Traits>::__parse_bracket_expression(_ForwardIterator __first,
3700 _ForwardIterator __last)
3701{
3702 if (__first != __last && *__first == '[')
3703 {
Howard Hinnant72f73582010-08-11 17:04:31 +00003704 ++__first;
Howard Hinnant72f73582010-08-11 17:04:31 +00003705 if (__first == __last)
Marshall Clowc8ccc292015-07-28 13:30:47 +00003706 __throw_regex_error<regex_constants::error_brack>();
Howard Hinnant3034c902010-07-13 21:48:06 +00003707 bool __negate = false;
Howard Hinnant89a40572010-06-25 20:56:08 +00003708 if (*__first == '^')
3709 {
3710 ++__first;
Howard Hinnant3034c902010-07-13 21:48:06 +00003711 __negate = true;
Howard Hinnant89a40572010-06-25 20:56:08 +00003712 }
Howard Hinnant3034c902010-07-13 21:48:06 +00003713 __bracket_expression<_CharT, _Traits>* __ml = __start_matching_list(__negate);
3714 // __ml owned by *this
Howard Hinnant89a40572010-06-25 20:56:08 +00003715 if (__first == __last)
Marshall Clowc8ccc292015-07-28 13:30:47 +00003716 __throw_regex_error<regex_constants::error_brack>();
Howard Hinnant70b3e192010-07-28 17:35:27 +00003717 if ((__flags_ & 0x1F0) != ECMAScript && *__first == ']')
Howard Hinnant89a40572010-06-25 20:56:08 +00003718 {
Howard Hinnant3034c902010-07-13 21:48:06 +00003719 __ml->__add_char(']');
Howard Hinnant89a40572010-06-25 20:56:08 +00003720 ++__first;
3721 }
Howard Hinnant3034c902010-07-13 21:48:06 +00003722 __first = __parse_follow_list(__first, __last, __ml);
Howard Hinnant89a40572010-06-25 20:56:08 +00003723 if (__first == __last)
Marshall Clowc8ccc292015-07-28 13:30:47 +00003724 __throw_regex_error<regex_constants::error_brack>();
Howard Hinnant89a40572010-06-25 20:56:08 +00003725 if (*__first == '-')
3726 {
Howard Hinnant3034c902010-07-13 21:48:06 +00003727 __ml->__add_char('-');
Howard Hinnant89a40572010-06-25 20:56:08 +00003728 ++__first;
3729 }
3730 if (__first == __last || *__first != ']')
Marshall Clowc8ccc292015-07-28 13:30:47 +00003731 __throw_regex_error<regex_constants::error_brack>();
Howard Hinnant89a40572010-06-25 20:56:08 +00003732 ++__first;
3733 }
3734 return __first;
3735}
3736
3737template <class _CharT, class _Traits>
3738template <class _ForwardIterator>
3739_ForwardIterator
3740basic_regex<_CharT, _Traits>::__parse_follow_list(_ForwardIterator __first,
Howard Hinnant3034c902010-07-13 21:48:06 +00003741 _ForwardIterator __last,
3742 __bracket_expression<_CharT, _Traits>* __ml)
Howard Hinnant89a40572010-06-25 20:56:08 +00003743{
3744 if (__first != __last)
3745 {
3746 while (true)
3747 {
Howard Hinnant3034c902010-07-13 21:48:06 +00003748 _ForwardIterator __temp = __parse_expression_term(__first, __last,
3749 __ml);
Howard Hinnant89a40572010-06-25 20:56:08 +00003750 if (__temp == __first)
3751 break;
3752 __first = __temp;
3753 }
3754 }
3755 return __first;
3756}
3757
3758template <class _CharT, class _Traits>
3759template <class _ForwardIterator>
3760_ForwardIterator
3761basic_regex<_CharT, _Traits>::__parse_expression_term(_ForwardIterator __first,
Howard Hinnant3034c902010-07-13 21:48:06 +00003762 _ForwardIterator __last,
3763 __bracket_expression<_CharT, _Traits>* __ml)
Howard Hinnant89a40572010-06-25 20:56:08 +00003764{
3765 if (__first != __last && *__first != ']')
3766 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003767 _ForwardIterator __temp = _VSTD::next(__first);
Howard Hinnant3034c902010-07-13 21:48:06 +00003768 basic_string<_CharT> __start_range;
Howard Hinnant89a40572010-06-25 20:56:08 +00003769 if (__temp != __last && *__first == '[')
3770 {
3771 if (*__temp == '=')
Howard Hinnant3034c902010-07-13 21:48:06 +00003772 return __parse_equivalence_class(++__temp, __last, __ml);
Howard Hinnant89a40572010-06-25 20:56:08 +00003773 else if (*__temp == ':')
Howard Hinnant3034c902010-07-13 21:48:06 +00003774 return __parse_character_class(++__temp, __last, __ml);
Howard Hinnant89a40572010-06-25 20:56:08 +00003775 else if (*__temp == '.')
Howard Hinnant3034c902010-07-13 21:48:06 +00003776 __first = __parse_collating_symbol(++__temp, __last, __start_range);
Howard Hinnant89a40572010-06-25 20:56:08 +00003777 }
Howard Hinnant70b3e192010-07-28 17:35:27 +00003778 unsigned __grammar = __flags_ & 0x1F0;
3779 if (__start_range.empty())
Howard Hinnant89a40572010-06-25 20:56:08 +00003780 {
Howard Hinnant70b3e192010-07-28 17:35:27 +00003781 if ((__grammar == ECMAScript || __grammar == awk) && *__first == '\\')
3782 {
3783 if (__grammar == ECMAScript)
3784 __first = __parse_class_escape(++__first, __last, __start_range, __ml);
3785 else
3786 __first = __parse_awk_escape(++__first, __last, &__start_range);
3787 }
3788 else
3789 {
3790 __start_range = *__first;
3791 ++__first;
3792 }
Howard Hinnant89a40572010-06-25 20:56:08 +00003793 }
3794 if (__first != __last && *__first != ']')
3795 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003796 __temp = _VSTD::next(__first);
Howard Hinnant89a40572010-06-25 20:56:08 +00003797 if (__temp != __last && *__first == '-' && *__temp != ']')
3798 {
3799 // parse a range
Howard Hinnant3034c902010-07-13 21:48:06 +00003800 basic_string<_CharT> __end_range;
Howard Hinnant89a40572010-06-25 20:56:08 +00003801 __first = __temp;
3802 ++__temp;
3803 if (__temp != __last && *__first == '[' && *__temp == '.')
Howard Hinnant3034c902010-07-13 21:48:06 +00003804 __first = __parse_collating_symbol(++__temp, __last, __end_range);
Howard Hinnant89a40572010-06-25 20:56:08 +00003805 else
3806 {
Howard Hinnant70b3e192010-07-28 17:35:27 +00003807 if ((__grammar == ECMAScript || __grammar == awk) && *__first == '\\')
3808 {
3809 if (__grammar == ECMAScript)
3810 __first = __parse_class_escape(++__first, __last,
3811 __end_range, __ml);
3812 else
3813 __first = __parse_awk_escape(++__first, __last,
3814 &__end_range);
3815 }
3816 else
3817 {
3818 __end_range = *__first;
3819 ++__first;
3820 }
Howard Hinnant89a40572010-06-25 20:56:08 +00003821 }
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003822 __ml->__add_range(_VSTD::move(__start_range), _VSTD::move(__end_range));
Howard Hinnant89a40572010-06-25 20:56:08 +00003823 }
Howard Hinnant8ea98242013-08-23 17:37:05 +00003824 else if (!__start_range.empty())
Howard Hinnant3034c902010-07-13 21:48:06 +00003825 {
3826 if (__start_range.size() == 1)
3827 __ml->__add_char(__start_range[0]);
3828 else
3829 __ml->__add_digraph(__start_range[0], __start_range[1]);
3830 }
3831 }
Howard Hinnant8ea98242013-08-23 17:37:05 +00003832 else if (!__start_range.empty())
Howard Hinnant3034c902010-07-13 21:48:06 +00003833 {
3834 if (__start_range.size() == 1)
3835 __ml->__add_char(__start_range[0]);
3836 else
3837 __ml->__add_digraph(__start_range[0], __start_range[1]);
Howard Hinnant89a40572010-06-25 20:56:08 +00003838 }
3839 }
3840 return __first;
3841}
3842
3843template <class _CharT, class _Traits>
3844template <class _ForwardIterator>
3845_ForwardIterator
Howard Hinnant70b3e192010-07-28 17:35:27 +00003846basic_regex<_CharT, _Traits>::__parse_class_escape(_ForwardIterator __first,
3847 _ForwardIterator __last,
3848 basic_string<_CharT>& __str,
3849 __bracket_expression<_CharT, _Traits>* __ml)
3850{
3851 if (__first == __last)
Marshall Clowc8ccc292015-07-28 13:30:47 +00003852 __throw_regex_error<regex_constants::error_escape>();
Howard Hinnant70b3e192010-07-28 17:35:27 +00003853 switch (*__first)
3854 {
3855 case 0:
3856 __str = *__first;
3857 return ++__first;
3858 case 'b':
3859 __str = _CharT(8);
3860 return ++__first;
3861 case 'd':
3862 __ml->__add_class(ctype_base::digit);
3863 return ++__first;
3864 case 'D':
3865 __ml->__add_neg_class(ctype_base::digit);
3866 return ++__first;
3867 case 's':
3868 __ml->__add_class(ctype_base::space);
3869 return ++__first;
3870 case 'S':
3871 __ml->__add_neg_class(ctype_base::space);
3872 return ++__first;
3873 case 'w':
3874 __ml->__add_class(ctype_base::alnum);
3875 __ml->__add_char('_');
3876 return ++__first;
3877 case 'W':
3878 __ml->__add_neg_class(ctype_base::alnum);
3879 __ml->__add_neg_char('_');
3880 return ++__first;
3881 }
3882 __first = __parse_character_escape(__first, __last, &__str);
3883 return __first;
3884}
3885
3886template <class _CharT, class _Traits>
3887template <class _ForwardIterator>
3888_ForwardIterator
3889basic_regex<_CharT, _Traits>::__parse_awk_escape(_ForwardIterator __first,
3890 _ForwardIterator __last,
3891 basic_string<_CharT>* __str)
3892{
3893 if (__first == __last)
Marshall Clowc8ccc292015-07-28 13:30:47 +00003894 __throw_regex_error<regex_constants::error_escape>();
Howard Hinnant70b3e192010-07-28 17:35:27 +00003895 switch (*__first)
3896 {
3897 case '\\':
3898 case '"':
3899 case '/':
3900 if (__str)
3901 *__str = *__first;
3902 else
3903 __push_char(*__first);
3904 return ++__first;
3905 case 'a':
3906 if (__str)
3907 *__str = _CharT(7);
3908 else
3909 __push_char(_CharT(7));
3910 return ++__first;
3911 case 'b':
3912 if (__str)
3913 *__str = _CharT(8);
3914 else
3915 __push_char(_CharT(8));
3916 return ++__first;
3917 case 'f':
3918 if (__str)
3919 *__str = _CharT(0xC);
3920 else
3921 __push_char(_CharT(0xC));
3922 return ++__first;
3923 case 'n':
3924 if (__str)
3925 *__str = _CharT(0xA);
3926 else
3927 __push_char(_CharT(0xA));
3928 return ++__first;
3929 case 'r':
3930 if (__str)
3931 *__str = _CharT(0xD);
3932 else
3933 __push_char(_CharT(0xD));
3934 return ++__first;
3935 case 't':
3936 if (__str)
3937 *__str = _CharT(0x9);
3938 else
3939 __push_char(_CharT(0x9));
3940 return ++__first;
3941 case 'v':
3942 if (__str)
3943 *__str = _CharT(0xB);
3944 else
3945 __push_char(_CharT(0xB));
3946 return ++__first;
3947 }
3948 if ('0' <= *__first && *__first <= '7')
3949 {
3950 unsigned __val = *__first - '0';
3951 if (++__first != __last && ('0' <= *__first && *__first <= '7'))
3952 {
3953 __val = 8 * __val + *__first - '0';
3954 if (++__first != __last && ('0' <= *__first && *__first <= '7'))
Howard Hinnanta3096872013-07-02 17:43:31 +00003955 __val = 8 * __val + *__first++ - '0';
Howard Hinnant70b3e192010-07-28 17:35:27 +00003956 }
3957 if (__str)
3958 *__str = _CharT(__val);
3959 else
3960 __push_char(_CharT(__val));
3961 }
3962 else
Marshall Clowc8ccc292015-07-28 13:30:47 +00003963 __throw_regex_error<regex_constants::error_escape>();
Howard Hinnant70b3e192010-07-28 17:35:27 +00003964 return __first;
3965}
3966
3967template <class _CharT, class _Traits>
3968template <class _ForwardIterator>
3969_ForwardIterator
Howard Hinnant89a40572010-06-25 20:56:08 +00003970basic_regex<_CharT, _Traits>::__parse_equivalence_class(_ForwardIterator __first,
Howard Hinnant3034c902010-07-13 21:48:06 +00003971 _ForwardIterator __last,
3972 __bracket_expression<_CharT, _Traits>* __ml)
Howard Hinnant89a40572010-06-25 20:56:08 +00003973{
3974 // Found [=
3975 // This means =] must exist
3976 value_type _Equal_close[2] = {'=', ']'};
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003977 _ForwardIterator __temp = _VSTD::search(__first, __last, _Equal_close,
Howard Hinnant89a40572010-06-25 20:56:08 +00003978 _Equal_close+2);
3979 if (__temp == __last)
Marshall Clowc8ccc292015-07-28 13:30:47 +00003980 __throw_regex_error<regex_constants::error_brack>();
Howard Hinnant89a40572010-06-25 20:56:08 +00003981 // [__first, __temp) contains all text in [= ... =]
Howard Hinnant89a40572010-06-25 20:56:08 +00003982 string_type __collate_name =
3983 __traits_.lookup_collatename(__first, __temp);
3984 if (__collate_name.empty())
Marshall Clowc8ccc292015-07-28 13:30:47 +00003985 __throw_regex_error<regex_constants::error_collate>();
Howard Hinnant89a40572010-06-25 20:56:08 +00003986 string_type __equiv_name =
3987 __traits_.transform_primary(__collate_name.begin(),
3988 __collate_name.end());
3989 if (!__equiv_name.empty())
Howard Hinnant3034c902010-07-13 21:48:06 +00003990 __ml->__add_equivalence(__equiv_name);
Howard Hinnant89a40572010-06-25 20:56:08 +00003991 else
Howard Hinnant3034c902010-07-13 21:48:06 +00003992 {
3993 switch (__collate_name.size())
3994 {
3995 case 1:
3996 __ml->__add_char(__collate_name[0]);
3997 break;
3998 case 2:
3999 __ml->__add_digraph(__collate_name[0], __collate_name[1]);
4000 break;
4001 default:
Marshall Clowc8ccc292015-07-28 13:30:47 +00004002 __throw_regex_error<regex_constants::error_collate>();
Howard Hinnant3034c902010-07-13 21:48:06 +00004003 }
4004 }
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004005 __first = _VSTD::next(__temp, 2);
Howard Hinnant89a40572010-06-25 20:56:08 +00004006 return __first;
4007}
4008
4009template <class _CharT, class _Traits>
4010template <class _ForwardIterator>
4011_ForwardIterator
4012basic_regex<_CharT, _Traits>::__parse_character_class(_ForwardIterator __first,
Howard Hinnant3034c902010-07-13 21:48:06 +00004013 _ForwardIterator __last,
4014 __bracket_expression<_CharT, _Traits>* __ml)
Howard Hinnant89a40572010-06-25 20:56:08 +00004015{
4016 // Found [:
4017 // This means :] must exist
4018 value_type _Colon_close[2] = {':', ']'};
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004019 _ForwardIterator __temp = _VSTD::search(__first, __last, _Colon_close,
Howard Hinnant89a40572010-06-25 20:56:08 +00004020 _Colon_close+2);
4021 if (__temp == __last)
Marshall Clowc8ccc292015-07-28 13:30:47 +00004022 __throw_regex_error<regex_constants::error_brack>();
Howard Hinnant89a40572010-06-25 20:56:08 +00004023 // [__first, __temp) contains all text in [: ... :]
4024 typedef typename _Traits::char_class_type char_class_type;
4025 char_class_type __class_type =
4026 __traits_.lookup_classname(__first, __temp, __flags_ & icase);
4027 if (__class_type == 0)
Mikhail Maltsev6ef945b2018-01-24 12:45:18 +00004028 __throw_regex_error<regex_constants::error_ctype>();
Howard Hinnant3034c902010-07-13 21:48:06 +00004029 __ml->__add_class(__class_type);
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004030 __first = _VSTD::next(__temp, 2);
Howard Hinnant89a40572010-06-25 20:56:08 +00004031 return __first;
4032}
4033
4034template <class _CharT, class _Traits>
4035template <class _ForwardIterator>
4036_ForwardIterator
4037basic_regex<_CharT, _Traits>::__parse_collating_symbol(_ForwardIterator __first,
Howard Hinnant3034c902010-07-13 21:48:06 +00004038 _ForwardIterator __last,
4039 basic_string<_CharT>& __col_sym)
Howard Hinnant89a40572010-06-25 20:56:08 +00004040{
4041 // Found [.
4042 // This means .] must exist
4043 value_type _Dot_close[2] = {'.', ']'};
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004044 _ForwardIterator __temp = _VSTD::search(__first, __last, _Dot_close,
Howard Hinnant89a40572010-06-25 20:56:08 +00004045 _Dot_close+2);
4046 if (__temp == __last)
Marshall Clowc8ccc292015-07-28 13:30:47 +00004047 __throw_regex_error<regex_constants::error_brack>();
Howard Hinnant89a40572010-06-25 20:56:08 +00004048 // [__first, __temp) contains all text in [. ... .]
Howard Hinnant3034c902010-07-13 21:48:06 +00004049 __col_sym = __traits_.lookup_collatename(__first, __temp);
4050 switch (__col_sym.size())
4051 {
4052 case 1:
4053 case 2:
4054 break;
4055 default:
Marshall Clowc8ccc292015-07-28 13:30:47 +00004056 __throw_regex_error<regex_constants::error_collate>();
Howard Hinnant3034c902010-07-13 21:48:06 +00004057 }
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004058 __first = _VSTD::next(__temp, 2);
Howard Hinnant89a40572010-06-25 20:56:08 +00004059 return __first;
4060}
4061
4062template <class _CharT, class _Traits>
4063template <class _ForwardIterator>
4064_ForwardIterator
4065basic_regex<_CharT, _Traits>::__parse_DUP_COUNT(_ForwardIterator __first,
4066 _ForwardIterator __last,
4067 int& __c)
4068{
Marshall Clowaa38d972014-01-18 03:40:03 +00004069 if (__first != __last )
Howard Hinnant89a40572010-06-25 20:56:08 +00004070 {
Marshall Clowaa38d972014-01-18 03:40:03 +00004071 int __val = __traits_.value(*__first, 10);
4072 if ( __val != -1 )
Howard Hinnant89a40572010-06-25 20:56:08 +00004073 {
Marshall Clowaa38d972014-01-18 03:40:03 +00004074 __c = __val;
4075 for (++__first;
4076 __first != __last && ( __val = __traits_.value(*__first, 10)) != -1;
4077 ++__first)
4078 {
Marshall Clow863ae382017-10-19 17:39:16 +00004079 if (__c >= std::numeric_limits<int>::max() / 10)
4080 __throw_regex_error<regex_constants::error_badbrace>();
Marshall Clowaa38d972014-01-18 03:40:03 +00004081 __c *= 10;
4082 __c += __val;
4083 }
Howard Hinnant89a40572010-06-25 20:56:08 +00004084 }
4085 }
4086 return __first;
4087}
4088
Howard Hinnant67ad2132010-06-29 18:37:43 +00004089template <class _CharT, class _Traits>
Howard Hinnante1053822010-07-22 17:53:24 +00004090template <class _ForwardIterator>
4091_ForwardIterator
4092basic_regex<_CharT, _Traits>::__parse_ecma_exp(_ForwardIterator __first,
4093 _ForwardIterator __last)
4094{
4095 __owns_one_state<_CharT>* __sa = __end_;
4096 _ForwardIterator __temp = __parse_alternative(__first, __last);
4097 if (__temp == __first)
4098 __push_empty();
4099 __first = __temp;
4100 while (__first != __last && *__first == '|')
4101 {
4102 __owns_one_state<_CharT>* __sb = __end_;
4103 __temp = __parse_alternative(++__first, __last);
4104 if (__temp == __first)
4105 __push_empty();
4106 __push_alternation(__sa, __sb);
4107 __first = __temp;
4108 }
4109 return __first;
4110}
4111
4112template <class _CharT, class _Traits>
4113template <class _ForwardIterator>
4114_ForwardIterator
4115basic_regex<_CharT, _Traits>::__parse_alternative(_ForwardIterator __first,
4116 _ForwardIterator __last)
4117{
4118 while (true)
4119 {
4120 _ForwardIterator __temp = __parse_term(__first, __last);
4121 if (__temp == __first)
4122 break;
4123 __first = __temp;
4124 }
4125 return __first;
4126}
4127
4128template <class _CharT, class _Traits>
4129template <class _ForwardIterator>
4130_ForwardIterator
4131basic_regex<_CharT, _Traits>::__parse_term(_ForwardIterator __first,
4132 _ForwardIterator __last)
4133{
4134 _ForwardIterator __temp = __parse_assertion(__first, __last);
4135 if (__temp == __first)
4136 {
Howard Hinnant70d27852010-07-27 01:25:38 +00004137 __owns_one_state<_CharT>* __e = __end_;
4138 unsigned __mexp_begin = __marked_count_;
Howard Hinnante1053822010-07-22 17:53:24 +00004139 __temp = __parse_atom(__first, __last);
4140 if (__temp != __first)
Howard Hinnant70d27852010-07-27 01:25:38 +00004141 __first = __parse_ERE_dupl_symbol(__temp, __last, __e,
4142 __mexp_begin+1, __marked_count_+1);
Howard Hinnante1053822010-07-22 17:53:24 +00004143 }
Howard Hinnant70d27852010-07-27 01:25:38 +00004144 else
4145 __first = __temp;
Howard Hinnante1053822010-07-22 17:53:24 +00004146 return __first;
4147}
4148
4149template <class _CharT, class _Traits>
4150template <class _ForwardIterator>
4151_ForwardIterator
4152basic_regex<_CharT, _Traits>::__parse_assertion(_ForwardIterator __first,
4153 _ForwardIterator __last)
4154{
4155 if (__first != __last)
4156 {
4157 switch (*__first)
4158 {
4159 case '^':
4160 __push_l_anchor();
4161 ++__first;
4162 break;
4163 case '$':
4164 __push_r_anchor();
4165 ++__first;
4166 break;
4167 case '\\':
4168 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004169 _ForwardIterator __temp = _VSTD::next(__first);
Howard Hinnante1053822010-07-22 17:53:24 +00004170 if (__temp != __last)
4171 {
4172 if (*__temp == 'b')
4173 {
Howard Hinnant70d27852010-07-27 01:25:38 +00004174 __push_word_boundary(false);
Howard Hinnante1053822010-07-22 17:53:24 +00004175 __first = ++__temp;
4176 }
4177 else if (*__temp == 'B')
4178 {
Howard Hinnant70d27852010-07-27 01:25:38 +00004179 __push_word_boundary(true);
Howard Hinnante1053822010-07-22 17:53:24 +00004180 __first = ++__temp;
4181 }
4182 }
4183 }
4184 break;
4185 case '(':
4186 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004187 _ForwardIterator __temp = _VSTD::next(__first);
Howard Hinnante1053822010-07-22 17:53:24 +00004188 if (__temp != __last && *__temp == '?')
4189 {
4190 if (++__temp != __last)
4191 {
4192 switch (*__temp)
4193 {
4194 case '=':
Howard Hinnant126da6a2010-07-27 22:20:32 +00004195 {
4196 basic_regex __exp;
4197 __exp.__flags_ = __flags_;
4198 __temp = __exp.__parse(++__temp, __last);
Howard Hinnant3efac712013-07-23 16:18:04 +00004199 unsigned __mexp = __exp.__marked_count_;
4200 __push_lookahead(_VSTD::move(__exp), false, __marked_count_);
4201 __marked_count_ += __mexp;
Howard Hinnant126da6a2010-07-27 22:20:32 +00004202 if (__temp == __last || *__temp != ')')
Marshall Clowc8ccc292015-07-28 13:30:47 +00004203 __throw_regex_error<regex_constants::error_paren>();
Howard Hinnant126da6a2010-07-27 22:20:32 +00004204 __first = ++__temp;
4205 }
Howard Hinnante1053822010-07-22 17:53:24 +00004206 break;
4207 case '!':
Howard Hinnant126da6a2010-07-27 22:20:32 +00004208 {
4209 basic_regex __exp;
4210 __exp.__flags_ = __flags_;
4211 __temp = __exp.__parse(++__temp, __last);
Howard Hinnant3efac712013-07-23 16:18:04 +00004212 unsigned __mexp = __exp.__marked_count_;
4213 __push_lookahead(_VSTD::move(__exp), true, __marked_count_);
4214 __marked_count_ += __mexp;
Howard Hinnant126da6a2010-07-27 22:20:32 +00004215 if (__temp == __last || *__temp != ')')
Marshall Clowc8ccc292015-07-28 13:30:47 +00004216 __throw_regex_error<regex_constants::error_paren>();
Howard Hinnant126da6a2010-07-27 22:20:32 +00004217 __first = ++__temp;
4218 }
Howard Hinnante1053822010-07-22 17:53:24 +00004219 break;
4220 }
4221 }
4222 }
4223 }
4224 break;
4225 }
4226 }
4227 return __first;
4228}
4229
4230template <class _CharT, class _Traits>
4231template <class _ForwardIterator>
4232_ForwardIterator
4233basic_regex<_CharT, _Traits>::__parse_atom(_ForwardIterator __first,
4234 _ForwardIterator __last)
4235{
Howard Hinnant70d27852010-07-27 01:25:38 +00004236 if (__first != __last)
4237 {
4238 switch (*__first)
4239 {
4240 case '.':
4241 __push_match_any_but_newline();
4242 ++__first;
4243 break;
4244 case '\\':
4245 __first = __parse_atom_escape(__first, __last);
4246 break;
4247 case '[':
4248 __first = __parse_bracket_expression(__first, __last);
4249 break;
4250 case '(':
4251 {
Howard Hinnant72f73582010-08-11 17:04:31 +00004252 ++__first;
Howard Hinnant72f73582010-08-11 17:04:31 +00004253 if (__first == __last)
Marshall Clowc8ccc292015-07-28 13:30:47 +00004254 __throw_regex_error<regex_constants::error_paren>();
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004255 _ForwardIterator __temp = _VSTD::next(__first);
Howard Hinnant70d27852010-07-27 01:25:38 +00004256 if (__temp != __last && *__first == '?' && *__temp == ':')
4257 {
4258 ++__open_count_;
4259 __first = __parse_ecma_exp(++__temp, __last);
4260 if (__first == __last || *__first != ')')
Marshall Clowc8ccc292015-07-28 13:30:47 +00004261 __throw_regex_error<regex_constants::error_paren>();
Howard Hinnant70d27852010-07-27 01:25:38 +00004262 --__open_count_;
4263 ++__first;
4264 }
4265 else
4266 {
4267 __push_begin_marked_subexpression();
4268 unsigned __temp_count = __marked_count_;
4269 ++__open_count_;
4270 __first = __parse_ecma_exp(__first, __last);
4271 if (__first == __last || *__first != ')')
Marshall Clowc8ccc292015-07-28 13:30:47 +00004272 __throw_regex_error<regex_constants::error_paren>();
Howard Hinnant70d27852010-07-27 01:25:38 +00004273 __push_end_marked_subexpression(__temp_count);
4274 --__open_count_;
4275 ++__first;
4276 }
4277 }
4278 break;
Marshall Clow82058212015-07-23 18:27:51 +00004279 case '*':
4280 case '+':
4281 case '?':
4282 case '{':
Marshall Clowc8ccc292015-07-28 13:30:47 +00004283 __throw_regex_error<regex_constants::error_badrepeat>();
Marshall Clow82058212015-07-23 18:27:51 +00004284 break;
Howard Hinnant70d27852010-07-27 01:25:38 +00004285 default:
4286 __first = __parse_pattern_character(__first, __last);
4287 break;
4288 }
4289 }
4290 return __first;
4291}
4292
4293template <class _CharT, class _Traits>
4294template <class _ForwardIterator>
4295_ForwardIterator
4296basic_regex<_CharT, _Traits>::__parse_atom_escape(_ForwardIterator __first,
4297 _ForwardIterator __last)
4298{
4299 if (__first != __last && *__first == '\\')
4300 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004301 _ForwardIterator __t1 = _VSTD::next(__first);
Marshall Clowdb9633c2016-01-19 00:50:37 +00004302 if (__t1 == __last)
4303 __throw_regex_error<regex_constants::error_escape>();
4304
Howard Hinnant70d27852010-07-27 01:25:38 +00004305 _ForwardIterator __t2 = __parse_decimal_escape(__t1, __last);
4306 if (__t2 != __t1)
4307 __first = __t2;
4308 else
4309 {
4310 __t2 = __parse_character_class_escape(__t1, __last);
4311 if (__t2 != __t1)
4312 __first = __t2;
4313 else
4314 {
4315 __t2 = __parse_character_escape(__t1, __last);
4316 if (__t2 != __t1)
4317 __first = __t2;
4318 }
4319 }
4320 }
4321 return __first;
4322}
4323
4324template <class _CharT, class _Traits>
4325template <class _ForwardIterator>
4326_ForwardIterator
4327basic_regex<_CharT, _Traits>::__parse_decimal_escape(_ForwardIterator __first,
4328 _ForwardIterator __last)
4329{
4330 if (__first != __last)
4331 {
4332 if (*__first == '0')
4333 {
4334 __push_char(_CharT());
4335 ++__first;
4336 }
4337 else if ('1' <= *__first && *__first <= '9')
4338 {
4339 unsigned __v = *__first - '0';
Marshall Clowdc03ec72016-12-24 17:21:03 +00004340 for (++__first;
4341 __first != __last && '0' <= *__first && *__first <= '9'; ++__first)
Marshall Clow266b5ec2017-10-19 22:10:41 +00004342 {
4343 if (__v >= std::numeric_limits<unsigned>::max() / 10)
4344 __throw_regex_error<regex_constants::error_backref>();
Howard Hinnant70d27852010-07-27 01:25:38 +00004345 __v = 10 * __v + *__first - '0';
Marshall Clow266b5ec2017-10-19 22:10:41 +00004346 }
4347 if (__v == 0 || __v > mark_count())
Marshall Clowc8ccc292015-07-28 13:30:47 +00004348 __throw_regex_error<regex_constants::error_backref>();
Howard Hinnant70d27852010-07-27 01:25:38 +00004349 __push_back_ref(__v);
4350 }
4351 }
4352 return __first;
4353}
4354
4355template <class _CharT, class _Traits>
4356template <class _ForwardIterator>
4357_ForwardIterator
4358basic_regex<_CharT, _Traits>::__parse_character_class_escape(_ForwardIterator __first,
4359 _ForwardIterator __last)
4360{
4361 if (__first != __last)
4362 {
4363 __bracket_expression<_CharT, _Traits>* __ml;
4364 switch (*__first)
4365 {
4366 case 'd':
4367 __ml = __start_matching_list(false);
4368 __ml->__add_class(ctype_base::digit);
4369 ++__first;
4370 break;
4371 case 'D':
4372 __ml = __start_matching_list(true);
4373 __ml->__add_class(ctype_base::digit);
4374 ++__first;
4375 break;
4376 case 's':
4377 __ml = __start_matching_list(false);
4378 __ml->__add_class(ctype_base::space);
4379 ++__first;
4380 break;
4381 case 'S':
4382 __ml = __start_matching_list(true);
4383 __ml->__add_class(ctype_base::space);
4384 ++__first;
4385 break;
4386 case 'w':
4387 __ml = __start_matching_list(false);
4388 __ml->__add_class(ctype_base::alnum);
4389 __ml->__add_char('_');
4390 ++__first;
4391 break;
4392 case 'W':
4393 __ml = __start_matching_list(true);
4394 __ml->__add_class(ctype_base::alnum);
4395 __ml->__add_char('_');
4396 ++__first;
4397 break;
4398 }
4399 }
4400 return __first;
4401}
4402
4403template <class _CharT, class _Traits>
4404template <class _ForwardIterator>
4405_ForwardIterator
4406basic_regex<_CharT, _Traits>::__parse_character_escape(_ForwardIterator __first,
Howard Hinnant70b3e192010-07-28 17:35:27 +00004407 _ForwardIterator __last,
4408 basic_string<_CharT>* __str)
Howard Hinnant70d27852010-07-27 01:25:38 +00004409{
4410 if (__first != __last)
4411 {
4412 _ForwardIterator __t;
4413 unsigned __sum = 0;
4414 int __hd;
4415 switch (*__first)
4416 {
4417 case 'f':
Howard Hinnant70b3e192010-07-28 17:35:27 +00004418 if (__str)
4419 *__str = _CharT(0xC);
4420 else
4421 __push_char(_CharT(0xC));
Howard Hinnant70d27852010-07-27 01:25:38 +00004422 ++__first;
4423 break;
4424 case 'n':
Howard Hinnant70b3e192010-07-28 17:35:27 +00004425 if (__str)
4426 *__str = _CharT(0xA);
4427 else
4428 __push_char(_CharT(0xA));
Howard Hinnant70d27852010-07-27 01:25:38 +00004429 ++__first;
4430 break;
4431 case 'r':
Howard Hinnant70b3e192010-07-28 17:35:27 +00004432 if (__str)
4433 *__str = _CharT(0xD);
4434 else
4435 __push_char(_CharT(0xD));
Howard Hinnant70d27852010-07-27 01:25:38 +00004436 ++__first;
4437 break;
4438 case 't':
Howard Hinnant70b3e192010-07-28 17:35:27 +00004439 if (__str)
4440 *__str = _CharT(0x9);
4441 else
4442 __push_char(_CharT(0x9));
Howard Hinnant70d27852010-07-27 01:25:38 +00004443 ++__first;
4444 break;
4445 case 'v':
Howard Hinnant70b3e192010-07-28 17:35:27 +00004446 if (__str)
4447 *__str = _CharT(0xB);
4448 else
4449 __push_char(_CharT(0xB));
Howard Hinnant70d27852010-07-27 01:25:38 +00004450 ++__first;
4451 break;
4452 case 'c':
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004453 if ((__t = _VSTD::next(__first)) != __last)
Howard Hinnant70d27852010-07-27 01:25:38 +00004454 {
Howard Hinnantd04741b2013-07-15 18:21:11 +00004455 if (('A' <= *__t && *__t <= 'Z') ||
4456 ('a' <= *__t && *__t <= 'z'))
Howard Hinnant70d27852010-07-27 01:25:38 +00004457 {
Howard Hinnant70b3e192010-07-28 17:35:27 +00004458 if (__str)
4459 *__str = _CharT(*__t % 32);
4460 else
4461 __push_char(_CharT(*__t % 32));
Howard Hinnant70d27852010-07-27 01:25:38 +00004462 __first = ++__t;
4463 }
Howard Hinnantd04741b2013-07-15 18:21:11 +00004464 else
Marshall Clowc8ccc292015-07-28 13:30:47 +00004465 __throw_regex_error<regex_constants::error_escape>();
Howard Hinnant70d27852010-07-27 01:25:38 +00004466 }
Howard Hinnantd04741b2013-07-15 18:21:11 +00004467 else
Marshall Clowc8ccc292015-07-28 13:30:47 +00004468 __throw_regex_error<regex_constants::error_escape>();
Howard Hinnant70d27852010-07-27 01:25:38 +00004469 break;
4470 case 'u':
Howard Hinnant72f73582010-08-11 17:04:31 +00004471 ++__first;
Howard Hinnant72f73582010-08-11 17:04:31 +00004472 if (__first == __last)
Marshall Clowc8ccc292015-07-28 13:30:47 +00004473 __throw_regex_error<regex_constants::error_escape>();
Howard Hinnant70d27852010-07-27 01:25:38 +00004474 __hd = __traits_.value(*__first, 16);
4475 if (__hd == -1)
Marshall Clowc8ccc292015-07-28 13:30:47 +00004476 __throw_regex_error<regex_constants::error_escape>();
Howard Hinnant28b24882011-12-01 20:21:04 +00004477 __sum = 16 * __sum + static_cast<unsigned>(__hd);
Howard Hinnant72f73582010-08-11 17:04:31 +00004478 ++__first;
Howard Hinnant72f73582010-08-11 17:04:31 +00004479 if (__first == __last)
Marshall Clowc8ccc292015-07-28 13:30:47 +00004480 __throw_regex_error<regex_constants::error_escape>();
Howard Hinnant70d27852010-07-27 01:25:38 +00004481 __hd = __traits_.value(*__first, 16);
4482 if (__hd == -1)
Marshall Clowc8ccc292015-07-28 13:30:47 +00004483 __throw_regex_error<regex_constants::error_escape>();
Howard Hinnant28b24882011-12-01 20:21:04 +00004484 __sum = 16 * __sum + static_cast<unsigned>(__hd);
Howard Hinnant70d27852010-07-27 01:25:38 +00004485 // drop through
4486 case 'x':
Howard Hinnant72f73582010-08-11 17:04:31 +00004487 ++__first;
Howard Hinnant72f73582010-08-11 17:04:31 +00004488 if (__first == __last)
Marshall Clowc8ccc292015-07-28 13:30:47 +00004489 __throw_regex_error<regex_constants::error_escape>();
Howard Hinnant70d27852010-07-27 01:25:38 +00004490 __hd = __traits_.value(*__first, 16);
4491 if (__hd == -1)
Marshall Clowc8ccc292015-07-28 13:30:47 +00004492 __throw_regex_error<regex_constants::error_escape>();
Howard Hinnant28b24882011-12-01 20:21:04 +00004493 __sum = 16 * __sum + static_cast<unsigned>(__hd);
Howard Hinnant72f73582010-08-11 17:04:31 +00004494 ++__first;
Howard Hinnant72f73582010-08-11 17:04:31 +00004495 if (__first == __last)
Marshall Clowc8ccc292015-07-28 13:30:47 +00004496 __throw_regex_error<regex_constants::error_escape>();
Howard Hinnant70d27852010-07-27 01:25:38 +00004497 __hd = __traits_.value(*__first, 16);
4498 if (__hd == -1)
Marshall Clowc8ccc292015-07-28 13:30:47 +00004499 __throw_regex_error<regex_constants::error_escape>();
Howard Hinnant28b24882011-12-01 20:21:04 +00004500 __sum = 16 * __sum + static_cast<unsigned>(__hd);
Howard Hinnant70b3e192010-07-28 17:35:27 +00004501 if (__str)
4502 *__str = _CharT(__sum);
4503 else
4504 __push_char(_CharT(__sum));
Howard Hinnant70d27852010-07-27 01:25:38 +00004505 ++__first;
4506 break;
Marshall Clowf6cef0d2014-05-21 16:29:50 +00004507 case '0':
4508 if (__str)
4509 *__str = _CharT(0);
4510 else
4511 __push_char(_CharT(0));
4512 ++__first;
4513 break;
Howard Hinnant70d27852010-07-27 01:25:38 +00004514 default:
4515 if (*__first != '_' && !__traits_.isctype(*__first, ctype_base::alnum))
4516 {
Howard Hinnant70b3e192010-07-28 17:35:27 +00004517 if (__str)
4518 *__str = *__first;
4519 else
4520 __push_char(*__first);
Howard Hinnant70d27852010-07-27 01:25:38 +00004521 ++__first;
4522 }
Howard Hinnant4f7a1f52013-06-28 18:57:30 +00004523 else
Marshall Clowc8ccc292015-07-28 13:30:47 +00004524 __throw_regex_error<regex_constants::error_escape>();
Howard Hinnant70d27852010-07-27 01:25:38 +00004525 break;
4526 }
4527 }
4528 return __first;
4529}
4530
4531template <class _CharT, class _Traits>
4532template <class _ForwardIterator>
4533_ForwardIterator
4534basic_regex<_CharT, _Traits>::__parse_pattern_character(_ForwardIterator __first,
4535 _ForwardIterator __last)
4536{
4537 if (__first != __last)
4538 {
4539 switch (*__first)
4540 {
4541 case '^':
4542 case '$':
4543 case '\\':
4544 case '.':
4545 case '*':
4546 case '+':
4547 case '?':
4548 case '(':
4549 case ')':
4550 case '[':
4551 case ']':
4552 case '{':
4553 case '}':
4554 case '|':
4555 break;
4556 default:
4557 __push_char(*__first);
4558 ++__first;
4559 break;
4560 }
4561 }
4562 return __first;
Howard Hinnante1053822010-07-22 17:53:24 +00004563}
4564
4565template <class _CharT, class _Traits>
Howard Hinnanteaf649e2010-07-27 19:53:10 +00004566template <class _ForwardIterator>
4567_ForwardIterator
4568basic_regex<_CharT, _Traits>::__parse_grep(_ForwardIterator __first,
4569 _ForwardIterator __last)
4570{
4571 __owns_one_state<_CharT>* __sa = __end_;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004572 _ForwardIterator __t1 = _VSTD::find(__first, __last, _CharT('\n'));
Howard Hinnanteaf649e2010-07-27 19:53:10 +00004573 if (__t1 != __first)
4574 __parse_basic_reg_exp(__first, __t1);
4575 else
4576 __push_empty();
4577 __first = __t1;
4578 if (__first != __last)
4579 ++__first;
4580 while (__first != __last)
4581 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004582 __t1 = _VSTD::find(__first, __last, _CharT('\n'));
Howard Hinnanteaf649e2010-07-27 19:53:10 +00004583 __owns_one_state<_CharT>* __sb = __end_;
4584 if (__t1 != __first)
4585 __parse_basic_reg_exp(__first, __t1);
4586 else
4587 __push_empty();
4588 __push_alternation(__sa, __sb);
4589 __first = __t1;
4590 if (__first != __last)
4591 ++__first;
4592 }
4593 return __first;
4594}
4595
4596template <class _CharT, class _Traits>
4597template <class _ForwardIterator>
4598_ForwardIterator
4599basic_regex<_CharT, _Traits>::__parse_egrep(_ForwardIterator __first,
4600 _ForwardIterator __last)
4601{
4602 __owns_one_state<_CharT>* __sa = __end_;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004603 _ForwardIterator __t1 = _VSTD::find(__first, __last, _CharT('\n'));
Howard Hinnanteaf649e2010-07-27 19:53:10 +00004604 if (__t1 != __first)
4605 __parse_extended_reg_exp(__first, __t1);
4606 else
4607 __push_empty();
4608 __first = __t1;
4609 if (__first != __last)
4610 ++__first;
4611 while (__first != __last)
4612 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004613 __t1 = _VSTD::find(__first, __last, _CharT('\n'));
Howard Hinnanteaf649e2010-07-27 19:53:10 +00004614 __owns_one_state<_CharT>* __sb = __end_;
4615 if (__t1 != __first)
4616 __parse_extended_reg_exp(__first, __t1);
4617 else
4618 __push_empty();
4619 __push_alternation(__sa, __sb);
4620 __first = __t1;
4621 if (__first != __last)
4622 ++__first;
4623 }
4624 return __first;
4625}
4626
4627template <class _CharT, class _Traits>
Howard Hinnant67ad2132010-06-29 18:37:43 +00004628void
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00004629basic_regex<_CharT, _Traits>::__push_loop(size_t __min, size_t __max,
4630 __owns_one_state<_CharT>* __s, size_t __mexp_begin, size_t __mexp_end,
4631 bool __greedy)
4632{
4633 unique_ptr<__empty_state<_CharT> > __e1(new __empty_state<_CharT>(__end_->first()));
4634 __end_->first() = nullptr;
Howard Hinnantaa0874c2010-07-12 15:51:17 +00004635 unique_ptr<__loop<_CharT> > __e2(new __loop<_CharT>(__loop_count_,
4636 __s->first(), __e1.get(), __mexp_begin, __mexp_end, __greedy,
4637 __min, __max));
4638 __s->first() = nullptr;
4639 __e1.release();
4640 __end_->first() = new __repeat_one_loop<_CharT>(__e2.get());
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00004641 __end_ = __e2->second();
Howard Hinnantaa0874c2010-07-12 15:51:17 +00004642 __s->first() = __e2.release();
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00004643 ++__loop_count_;
4644}
4645
4646template <class _CharT, class _Traits>
4647void
Howard Hinnant67ad2132010-06-29 18:37:43 +00004648basic_regex<_CharT, _Traits>::__push_char(value_type __c)
4649{
Howard Hinnant3034c902010-07-13 21:48:06 +00004650 if (flags() & icase)
Howard Hinnantcfe8d272010-07-12 19:11:27 +00004651 __end_->first() = new __match_char_icase<_CharT, _Traits>
4652 (__traits_, __c, __end_->first());
Howard Hinnant3034c902010-07-13 21:48:06 +00004653 else if (flags() & collate)
Howard Hinnantcfe8d272010-07-12 19:11:27 +00004654 __end_->first() = new __match_char_collate<_CharT, _Traits>
4655 (__traits_, __c, __end_->first());
4656 else
4657 __end_->first() = new __match_char<_CharT>(__c, __end_->first());
Howard Hinnant5bf96132010-07-08 17:43:58 +00004658 __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
Howard Hinnant67ad2132010-06-29 18:37:43 +00004659}
4660
Howard Hinnant93ef6552010-06-30 20:30:19 +00004661template <class _CharT, class _Traits>
4662void
4663basic_regex<_CharT, _Traits>::__push_begin_marked_subexpression()
4664{
Howard Hinnant5d4aaa42010-07-14 15:45:11 +00004665 if (!(__flags_ & nosubs))
4666 {
4667 __end_->first() =
4668 new __begin_marked_subexpression<_CharT>(++__marked_count_,
4669 __end_->first());
4670 __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
4671 }
Howard Hinnant93ef6552010-06-30 20:30:19 +00004672}
4673
4674template <class _CharT, class _Traits>
4675void
4676basic_regex<_CharT, _Traits>::__push_end_marked_subexpression(unsigned __sub)
4677{
Howard Hinnant5d4aaa42010-07-14 15:45:11 +00004678 if (!(__flags_ & nosubs))
4679 {
4680 __end_->first() =
4681 new __end_marked_subexpression<_CharT>(__sub, __end_->first());
4682 __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
4683 }
Howard Hinnant93ef6552010-06-30 20:30:19 +00004684}
4685
Howard Hinnantaad0aa62010-07-09 00:15:26 +00004686template <class _CharT, class _Traits>
4687void
Howard Hinnant066ba512011-03-26 20:02:27 +00004688basic_regex<_CharT, _Traits>::__push_l_anchor()
4689{
4690 __end_->first() = new __l_anchor<_CharT>(__end_->first());
4691 __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
4692}
4693
4694template <class _CharT, class _Traits>
4695void
Howard Hinnantaad0aa62010-07-09 00:15:26 +00004696basic_regex<_CharT, _Traits>::__push_r_anchor()
4697{
4698 __end_->first() = new __r_anchor<_CharT>(__end_->first());
4699 __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
4700}
4701
Howard Hinnantaa0874c2010-07-12 15:51:17 +00004702template <class _CharT, class _Traits>
4703void
4704basic_regex<_CharT, _Traits>::__push_match_any()
4705{
4706 __end_->first() = new __match_any<_CharT>(__end_->first());
4707 __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
4708}
Howard Hinnantaad0aa62010-07-09 00:15:26 +00004709
Howard Hinnant2a315e32010-07-12 18:16:05 +00004710template <class _CharT, class _Traits>
4711void
Howard Hinnant70d27852010-07-27 01:25:38 +00004712basic_regex<_CharT, _Traits>::__push_match_any_but_newline()
4713{
4714 __end_->first() = new __match_any_but_newline<_CharT>(__end_->first());
4715 __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
4716}
4717
4718template <class _CharT, class _Traits>
4719void
Howard Hinnante1053822010-07-22 17:53:24 +00004720basic_regex<_CharT, _Traits>::__push_empty()
4721{
4722 __end_->first() = new __empty_state<_CharT>(__end_->first());
4723 __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
4724}
4725
4726template <class _CharT, class _Traits>
4727void
Howard Hinnant70d27852010-07-27 01:25:38 +00004728basic_regex<_CharT, _Traits>::__push_word_boundary(bool __invert)
4729{
4730 __end_->first() = new __word_boundary<_CharT, _Traits>(__traits_, __invert,
4731 __end_->first());
4732 __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
4733}
4734
4735template <class _CharT, class _Traits>
4736void
Howard Hinnant2a315e32010-07-12 18:16:05 +00004737basic_regex<_CharT, _Traits>::__push_back_ref(int __i)
4738{
Howard Hinnant3034c902010-07-13 21:48:06 +00004739 if (flags() & icase)
Howard Hinnantcfe8d272010-07-12 19:11:27 +00004740 __end_->first() = new __back_ref_icase<_CharT, _Traits>
4741 (__traits_, __i, __end_->first());
Howard Hinnant3034c902010-07-13 21:48:06 +00004742 else if (flags() & collate)
Howard Hinnantcfe8d272010-07-12 19:11:27 +00004743 __end_->first() = new __back_ref_collate<_CharT, _Traits>
4744 (__traits_, __i, __end_->first());
4745 else
4746 __end_->first() = new __back_ref<_CharT>(__i, __end_->first());
Howard Hinnant2a315e32010-07-12 18:16:05 +00004747 __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
4748}
4749
Howard Hinnant3034c902010-07-13 21:48:06 +00004750template <class _CharT, class _Traits>
Howard Hinnant16d65422010-07-16 19:08:36 +00004751void
4752basic_regex<_CharT, _Traits>::__push_alternation(__owns_one_state<_CharT>* __sa,
4753 __owns_one_state<_CharT>* __ea)
4754{
4755 __sa->first() = new __alternate<_CharT>(
4756 static_cast<__owns_one_state<_CharT>*>(__sa->first()),
4757 static_cast<__owns_one_state<_CharT>*>(__ea->first()));
4758 __ea->first() = nullptr;
4759 __ea->first() = new __empty_state<_CharT>(__end_->first());
4760 __end_->first() = nullptr;
4761 __end_->first() = new __empty_non_own_state<_CharT>(__ea->first());
4762 __end_ = static_cast<__owns_one_state<_CharT>*>(__ea->first());
4763}
4764
4765template <class _CharT, class _Traits>
Howard Hinnant3034c902010-07-13 21:48:06 +00004766__bracket_expression<_CharT, _Traits>*
4767basic_regex<_CharT, _Traits>::__start_matching_list(bool __negate)
4768{
4769 __bracket_expression<_CharT, _Traits>* __r =
4770 new __bracket_expression<_CharT, _Traits>(__traits_, __end_->first(),
4771 __negate, __flags_ & icase,
4772 __flags_ & collate);
4773 __end_->first() = __r;
4774 __end_ = __r;
4775 return __r;
4776}
4777
Howard Hinnant126da6a2010-07-27 22:20:32 +00004778template <class _CharT, class _Traits>
4779void
4780basic_regex<_CharT, _Traits>::__push_lookahead(const basic_regex& __exp,
Howard Hinnant3efac712013-07-23 16:18:04 +00004781 bool __invert,
4782 unsigned __mexp)
Howard Hinnant126da6a2010-07-27 22:20:32 +00004783{
4784 __end_->first() = new __lookahead<_CharT, _Traits>(__exp, __invert,
Howard Hinnant3efac712013-07-23 16:18:04 +00004785 __end_->first(), __mexp);
Howard Hinnant126da6a2010-07-27 22:20:32 +00004786 __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
4787}
4788
Howard Hinnant6c891682010-06-24 21:28:00 +00004789typedef basic_regex<char> regex;
4790typedef basic_regex<wchar_t> wregex;
4791
Howard Hinnant67ad2132010-06-29 18:37:43 +00004792// sub_match
4793
4794template <class _BidirectionalIterator>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +00004795class _LIBCPP_TEMPLATE_VIS sub_match
Howard Hinnant67ad2132010-06-29 18:37:43 +00004796 : public pair<_BidirectionalIterator, _BidirectionalIterator>
4797{
4798public:
4799 typedef _BidirectionalIterator iterator;
4800 typedef typename iterator_traits<iterator>::value_type value_type;
4801 typedef typename iterator_traits<iterator>::difference_type difference_type;
4802 typedef basic_string<value_type> string_type;
4803
4804 bool matched;
4805
Howard Hinnant7ca9d942010-09-23 15:13:20 +00004806 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant5ddd33c2012-07-21 01:31:58 +00004807 _LIBCPP_CONSTEXPR sub_match() : matched() {}
Howard Hinnantb5c53a82010-12-08 21:07:55 +00004808
4809 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant67ad2132010-06-29 18:37:43 +00004810 difference_type length() const
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004811 {return matched ? _VSTD::distance(this->first, this->second) : 0;}
Howard Hinnant7ca9d942010-09-23 15:13:20 +00004812 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant67ad2132010-06-29 18:37:43 +00004813 string_type str() const
4814 {return matched ? string_type(this->first, this->second) : string_type();}
Howard Hinnant7ca9d942010-09-23 15:13:20 +00004815 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant67ad2132010-06-29 18:37:43 +00004816 operator string_type() const
4817 {return str();}
4818
Howard Hinnant7ca9d942010-09-23 15:13:20 +00004819 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant67ad2132010-06-29 18:37:43 +00004820 int compare(const sub_match& __s) const
4821 {return str().compare(__s.str());}
Howard Hinnant7ca9d942010-09-23 15:13:20 +00004822 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant67ad2132010-06-29 18:37:43 +00004823 int compare(const string_type& __s) const
4824 {return str().compare(__s);}
Howard Hinnant7ca9d942010-09-23 15:13:20 +00004825 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant67ad2132010-06-29 18:37:43 +00004826 int compare(const value_type* __s) const
4827 {return str().compare(__s);}
4828};
4829
4830typedef sub_match<const char*> csub_match;
4831typedef sub_match<const wchar_t*> wcsub_match;
4832typedef sub_match<string::const_iterator> ssub_match;
4833typedef sub_match<wstring::const_iterator> wssub_match;
4834
4835template <class _BiIter>
4836inline _LIBCPP_INLINE_VISIBILITY
4837bool
4838operator==(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y)
4839{
4840 return __x.compare(__y) == 0;
4841}
4842
4843template <class _BiIter>
4844inline _LIBCPP_INLINE_VISIBILITY
4845bool
4846operator!=(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y)
4847{
4848 return !(__x == __y);
4849}
4850
4851template <class _BiIter>
4852inline _LIBCPP_INLINE_VISIBILITY
4853bool
4854operator<(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y)
4855{
4856 return __x.compare(__y) < 0;
4857}
4858
4859template <class _BiIter>
4860inline _LIBCPP_INLINE_VISIBILITY
4861bool
4862operator<=(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y)
4863{
4864 return !(__y < __x);
4865}
4866
4867template <class _BiIter>
4868inline _LIBCPP_INLINE_VISIBILITY
4869bool
4870operator>=(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y)
4871{
4872 return !(__x < __y);
4873}
4874
4875template <class _BiIter>
4876inline _LIBCPP_INLINE_VISIBILITY
4877bool
4878operator>(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y)
4879{
4880 return __y < __x;
4881}
4882
4883template <class _BiIter, class _ST, class _SA>
4884inline _LIBCPP_INLINE_VISIBILITY
4885bool
4886operator==(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x,
4887 const sub_match<_BiIter>& __y)
4888{
Marshall Clow54a46342014-12-15 23:57:56 +00004889 return __y.compare(typename sub_match<_BiIter>::string_type(__x.data(), __x.size())) == 0;
Howard Hinnant67ad2132010-06-29 18:37:43 +00004890}
4891
4892template <class _BiIter, class _ST, class _SA>
4893inline _LIBCPP_INLINE_VISIBILITY
4894bool
4895operator!=(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x,
4896 const sub_match<_BiIter>& __y)
4897{
4898 return !(__x == __y);
4899}
4900
4901template <class _BiIter, class _ST, class _SA>
4902inline _LIBCPP_INLINE_VISIBILITY
4903bool
4904operator<(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x,
4905 const sub_match<_BiIter>& __y)
4906{
Marshall Clow54a46342014-12-15 23:57:56 +00004907 return __y.compare(typename sub_match<_BiIter>::string_type(__x.data(), __x.size())) > 0;
Howard Hinnant67ad2132010-06-29 18:37:43 +00004908}
4909
4910template <class _BiIter, class _ST, class _SA>
4911inline _LIBCPP_INLINE_VISIBILITY
4912bool
4913operator>(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x,
4914 const sub_match<_BiIter>& __y)
4915{
4916 return __y < __x;
4917}
4918
4919template <class _BiIter, class _ST, class _SA>
4920inline _LIBCPP_INLINE_VISIBILITY
4921bool operator>=(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x,
4922 const sub_match<_BiIter>& __y)
4923{
4924 return !(__x < __y);
4925}
4926
4927template <class _BiIter, class _ST, class _SA>
4928inline _LIBCPP_INLINE_VISIBILITY
4929bool
4930operator<=(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x,
4931 const sub_match<_BiIter>& __y)
4932{
4933 return !(__y < __x);
4934}
4935
4936template <class _BiIter, class _ST, class _SA>
4937inline _LIBCPP_INLINE_VISIBILITY
4938bool
4939operator==(const sub_match<_BiIter>& __x,
4940 const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y)
4941{
Marshall Clow54a46342014-12-15 23:57:56 +00004942 return __x.compare(typename sub_match<_BiIter>::string_type(__y.data(), __y.size())) == 0;
Howard Hinnant67ad2132010-06-29 18:37:43 +00004943}
4944
4945template <class _BiIter, class _ST, class _SA>
4946inline _LIBCPP_INLINE_VISIBILITY
4947bool
4948operator!=(const sub_match<_BiIter>& __x,
4949 const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y)
4950{
4951 return !(__x == __y);
4952}
4953
4954template <class _BiIter, class _ST, class _SA>
4955inline _LIBCPP_INLINE_VISIBILITY
4956bool
4957operator<(const sub_match<_BiIter>& __x,
4958 const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y)
4959{
Marshall Clow54a46342014-12-15 23:57:56 +00004960 return __x.compare(typename sub_match<_BiIter>::string_type(__y.data(), __y.size())) < 0;
Howard Hinnant67ad2132010-06-29 18:37:43 +00004961}
4962
4963template <class _BiIter, class _ST, class _SA>
4964inline _LIBCPP_INLINE_VISIBILITY
4965bool operator>(const sub_match<_BiIter>& __x,
4966 const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y)
4967{
4968 return __y < __x;
4969}
4970
4971template <class _BiIter, class _ST, class _SA>
4972inline _LIBCPP_INLINE_VISIBILITY
4973bool
4974operator>=(const sub_match<_BiIter>& __x,
4975 const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y)
4976{
4977 return !(__x < __y);
4978}
4979
4980template <class _BiIter, class _ST, class _SA>
4981inline _LIBCPP_INLINE_VISIBILITY
4982bool
4983operator<=(const sub_match<_BiIter>& __x,
4984 const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y)
4985{
4986 return !(__y < __x);
4987}
4988
4989template <class _BiIter>
4990inline _LIBCPP_INLINE_VISIBILITY
4991bool
4992operator==(typename iterator_traits<_BiIter>::value_type const* __x,
4993 const sub_match<_BiIter>& __y)
4994{
4995 return __y.compare(__x) == 0;
4996}
4997
4998template <class _BiIter>
4999inline _LIBCPP_INLINE_VISIBILITY
5000bool
5001operator!=(typename iterator_traits<_BiIter>::value_type const* __x,
5002 const sub_match<_BiIter>& __y)
5003{
5004 return !(__x == __y);
5005}
5006
5007template <class _BiIter>
5008inline _LIBCPP_INLINE_VISIBILITY
5009bool
5010operator<(typename iterator_traits<_BiIter>::value_type const* __x,
5011 const sub_match<_BiIter>& __y)
5012{
5013 return __y.compare(__x) > 0;
5014}
5015
5016template <class _BiIter>
5017inline _LIBCPP_INLINE_VISIBILITY
5018bool
5019operator>(typename iterator_traits<_BiIter>::value_type const* __x,
5020 const sub_match<_BiIter>& __y)
5021{
5022 return __y < __x;
5023}
5024
5025template <class _BiIter>
5026inline _LIBCPP_INLINE_VISIBILITY
5027bool
5028operator>=(typename iterator_traits<_BiIter>::value_type const* __x,
5029 const sub_match<_BiIter>& __y)
5030{
5031 return !(__x < __y);
5032}
5033
5034template <class _BiIter>
5035inline _LIBCPP_INLINE_VISIBILITY
5036bool
5037operator<=(typename iterator_traits<_BiIter>::value_type const* __x,
5038 const sub_match<_BiIter>& __y)
5039{
5040 return !(__y < __x);
5041}
5042
5043template <class _BiIter>
5044inline _LIBCPP_INLINE_VISIBILITY
5045bool
5046operator==(const sub_match<_BiIter>& __x,
5047 typename iterator_traits<_BiIter>::value_type const* __y)
5048{
5049 return __x.compare(__y) == 0;
5050}
5051
5052template <class _BiIter>
5053inline _LIBCPP_INLINE_VISIBILITY
5054bool
5055operator!=(const sub_match<_BiIter>& __x,
5056 typename iterator_traits<_BiIter>::value_type const* __y)
5057{
5058 return !(__x == __y);
5059}
5060
5061template <class _BiIter>
5062inline _LIBCPP_INLINE_VISIBILITY
5063bool
5064operator<(const sub_match<_BiIter>& __x,
5065 typename iterator_traits<_BiIter>::value_type const* __y)
5066{
5067 return __x.compare(__y) < 0;
5068}
5069
5070template <class _BiIter>
5071inline _LIBCPP_INLINE_VISIBILITY
5072bool
5073operator>(const sub_match<_BiIter>& __x,
5074 typename iterator_traits<_BiIter>::value_type const* __y)
5075{
5076 return __y < __x;
5077}
5078
5079template <class _BiIter>
5080inline _LIBCPP_INLINE_VISIBILITY
5081bool
5082operator>=(const sub_match<_BiIter>& __x,
5083 typename iterator_traits<_BiIter>::value_type const* __y)
5084{
5085 return !(__x < __y);
5086}
5087
5088template <class _BiIter>
5089inline _LIBCPP_INLINE_VISIBILITY
5090bool
5091operator<=(const sub_match<_BiIter>& __x,
5092 typename iterator_traits<_BiIter>::value_type const* __y)
5093{
5094 return !(__y < __x);
5095}
5096
5097template <class _BiIter>
5098inline _LIBCPP_INLINE_VISIBILITY
5099bool
5100operator==(typename iterator_traits<_BiIter>::value_type const& __x,
5101 const sub_match<_BiIter>& __y)
5102{
5103 typedef basic_string<typename iterator_traits<_BiIter>::value_type> string_type;
5104 return __y.compare(string_type(1, __x)) == 0;
5105}
5106
5107template <class _BiIter>
5108inline _LIBCPP_INLINE_VISIBILITY
5109bool
5110operator!=(typename iterator_traits<_BiIter>::value_type const& __x,
5111 const sub_match<_BiIter>& __y)
5112{
5113 return !(__x == __y);
5114}
5115
5116template <class _BiIter>
5117inline _LIBCPP_INLINE_VISIBILITY
5118bool
5119operator<(typename iterator_traits<_BiIter>::value_type const& __x,
5120 const sub_match<_BiIter>& __y)
5121{
5122 typedef basic_string<typename iterator_traits<_BiIter>::value_type> string_type;
5123 return __y.compare(string_type(1, __x)) > 0;
5124}
5125
5126template <class _BiIter>
5127inline _LIBCPP_INLINE_VISIBILITY
5128bool
5129operator>(typename iterator_traits<_BiIter>::value_type const& __x,
5130 const sub_match<_BiIter>& __y)
5131{
5132 return __y < __x;
5133}
5134
5135template <class _BiIter>
5136inline _LIBCPP_INLINE_VISIBILITY
5137bool
5138operator>=(typename iterator_traits<_BiIter>::value_type const& __x,
5139 const sub_match<_BiIter>& __y)
5140{
5141 return !(__x < __y);
5142}
5143
5144template <class _BiIter>
5145inline _LIBCPP_INLINE_VISIBILITY
5146bool
5147operator<=(typename iterator_traits<_BiIter>::value_type const& __x,
5148 const sub_match<_BiIter>& __y)
5149{
5150 return !(__y < __x);
5151}
5152
5153template <class _BiIter>
5154inline _LIBCPP_INLINE_VISIBILITY
5155bool
5156operator==(const sub_match<_BiIter>& __x,
5157 typename iterator_traits<_BiIter>::value_type const& __y)
5158{
5159 typedef basic_string<typename iterator_traits<_BiIter>::value_type> string_type;
5160 return __x.compare(string_type(1, __y)) == 0;
5161}
5162
5163template <class _BiIter>
5164inline _LIBCPP_INLINE_VISIBILITY
5165bool
5166operator!=(const sub_match<_BiIter>& __x,
5167 typename iterator_traits<_BiIter>::value_type const& __y)
5168{
5169 return !(__x == __y);
5170}
5171
5172template <class _BiIter>
5173inline _LIBCPP_INLINE_VISIBILITY
5174bool
5175operator<(const sub_match<_BiIter>& __x,
5176 typename iterator_traits<_BiIter>::value_type const& __y)
5177{
5178 typedef basic_string<typename iterator_traits<_BiIter>::value_type> string_type;
5179 return __x.compare(string_type(1, __y)) < 0;
5180}
5181
5182template <class _BiIter>
5183inline _LIBCPP_INLINE_VISIBILITY
5184bool
5185operator>(const sub_match<_BiIter>& __x,
5186 typename iterator_traits<_BiIter>::value_type const& __y)
5187{
5188 return __y < __x;
5189}
5190
5191template <class _BiIter>
5192inline _LIBCPP_INLINE_VISIBILITY
5193bool
5194operator>=(const sub_match<_BiIter>& __x,
5195 typename iterator_traits<_BiIter>::value_type const& __y)
5196{
5197 return !(__x < __y);
5198}
5199
5200template <class _BiIter>
5201inline _LIBCPP_INLINE_VISIBILITY
5202bool
5203operator<=(const sub_match<_BiIter>& __x,
5204 typename iterator_traits<_BiIter>::value_type const& __y)
5205{
5206 return !(__y < __x);
5207}
5208
5209template <class _CharT, class _ST, class _BiIter>
5210inline _LIBCPP_INLINE_VISIBILITY
5211basic_ostream<_CharT, _ST>&
5212operator<<(basic_ostream<_CharT, _ST>& __os, const sub_match<_BiIter>& __m)
5213{
5214 return __os << __m.str();
5215}
5216
Howard Hinnant70d27852010-07-27 01:25:38 +00005217template <class _BidirectionalIterator, class _Allocator>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +00005218class _LIBCPP_TEMPLATE_VIS match_results
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00005219{
5220public:
5221 typedef _Allocator allocator_type;
5222 typedef sub_match<_BidirectionalIterator> value_type;
5223private:
5224 typedef vector<value_type, allocator_type> __container_type;
5225
5226 __container_type __matches_;
5227 value_type __unmatched_;
5228 value_type __prefix_;
5229 value_type __suffix_;
Howard Hinnantb5c53a82010-12-08 21:07:55 +00005230 bool __ready_;
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00005231public:
Howard Hinnantd3925342010-08-16 20:21:16 +00005232 _BidirectionalIterator __position_start_;
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00005233 typedef const value_type& const_reference;
Marshall Clow96e06142014-02-26 01:56:31 +00005234 typedef value_type& reference;
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00005235 typedef typename __container_type::const_iterator const_iterator;
5236 typedef const_iterator iterator;
5237 typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type;
5238 typedef typename allocator_traits<allocator_type>::size_type size_type;
5239 typedef typename iterator_traits<_BidirectionalIterator>::value_type char_type;
5240 typedef basic_string<char_type> string_type;
5241
5242 // construct/copy/destroy:
5243 explicit match_results(const allocator_type& __a = allocator_type());
5244// match_results(const match_results&) = default;
5245// match_results& operator=(const match_results&) = default;
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00005246// match_results(match_results&& __m) = default;
5247// match_results& operator=(match_results&& __m) = default;
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00005248// ~match_results() = default;
5249
Howard Hinnantb5c53a82010-12-08 21:07:55 +00005250 _LIBCPP_INLINE_VISIBILITY
5251 bool ready() const {return __ready_;}
5252
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00005253 // size:
Howard Hinnant7ca9d942010-09-23 15:13:20 +00005254 _LIBCPP_INLINE_VISIBILITY
Marshall Clow081bcd22017-11-16 04:48:34 +00005255 size_type size() const _NOEXCEPT {return __matches_.size();}
Howard Hinnant7ca9d942010-09-23 15:13:20 +00005256 _LIBCPP_INLINE_VISIBILITY
Marshall Clow081bcd22017-11-16 04:48:34 +00005257 size_type max_size() const _NOEXCEPT {return __matches_.max_size();}
5258 _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
5259 bool empty() const _NOEXCEPT {return size() == 0;}
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00005260
5261 // element access:
Howard Hinnant7ca9d942010-09-23 15:13:20 +00005262 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00005263 difference_type length(size_type __sub = 0) const
5264 {return (*this)[__sub].length();}
Howard Hinnant7ca9d942010-09-23 15:13:20 +00005265 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00005266 difference_type position(size_type __sub = 0) const
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00005267 {return _VSTD::distance(__position_start_, (*this)[__sub].first);}
Howard Hinnant7ca9d942010-09-23 15:13:20 +00005268 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00005269 string_type str(size_type __sub = 0) const
5270 {return (*this)[__sub].str();}
Howard Hinnant7ca9d942010-09-23 15:13:20 +00005271 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00005272 const_reference operator[](size_type __n) const
5273 {return __n < __matches_.size() ? __matches_[__n] : __unmatched_;}
5274
Howard Hinnant7ca9d942010-09-23 15:13:20 +00005275 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00005276 const_reference prefix() const {return __prefix_;}
Howard Hinnant7ca9d942010-09-23 15:13:20 +00005277 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00005278 const_reference suffix() const {return __suffix_;}
5279
Howard Hinnant7ca9d942010-09-23 15:13:20 +00005280 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant2f4191f2011-10-08 14:36:16 +00005281 const_iterator begin() const {return empty() ? __matches_.end() : __matches_.begin();}
Howard Hinnant7ca9d942010-09-23 15:13:20 +00005282 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00005283 const_iterator end() const {return __matches_.end();}
Howard Hinnant7ca9d942010-09-23 15:13:20 +00005284 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant2f4191f2011-10-08 14:36:16 +00005285 const_iterator cbegin() const {return empty() ? __matches_.end() : __matches_.begin();}
Howard Hinnant7ca9d942010-09-23 15:13:20 +00005286 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00005287 const_iterator cend() const {return __matches_.end();}
5288
5289 // format:
5290 template <class _OutputIter>
5291 _OutputIter
Alexander Richardsonc9637642017-11-14 11:14:25 +00005292 format(_OutputIter __output_iter, const char_type* __fmt_first,
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00005293 const char_type* __fmt_last,
5294 regex_constants::match_flag_type __flags = regex_constants::format_default) const;
5295 template <class _OutputIter, class _ST, class _SA>
Howard Hinnant7ca9d942010-09-23 15:13:20 +00005296 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00005297 _OutputIter
Alexander Richardsonc9637642017-11-14 11:14:25 +00005298 format(_OutputIter __output_iter, const basic_string<char_type, _ST, _SA>& __fmt,
Howard Hinnantcbc45252010-08-14 18:14:02 +00005299 regex_constants::match_flag_type __flags = regex_constants::format_default) const
Alexander Richardsonc9637642017-11-14 11:14:25 +00005300 {return format(__output_iter, __fmt.data(), __fmt.data() + __fmt.size(), __flags);}
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00005301 template <class _ST, class _SA>
Howard Hinnant7ca9d942010-09-23 15:13:20 +00005302 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00005303 basic_string<char_type, _ST, _SA>
5304 format(const basic_string<char_type, _ST, _SA>& __fmt,
Howard Hinnantcbc45252010-08-14 18:14:02 +00005305 regex_constants::match_flag_type __flags = regex_constants::format_default) const
5306 {
5307 basic_string<char_type, _ST, _SA> __r;
5308 format(back_inserter(__r), __fmt.data(), __fmt.data() + __fmt.size(),
5309 __flags);
5310 return __r;
5311 }
Howard Hinnant7ca9d942010-09-23 15:13:20 +00005312 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00005313 string_type
5314 format(const char_type* __fmt,
Howard Hinnantcbc45252010-08-14 18:14:02 +00005315 regex_constants::match_flag_type __flags = regex_constants::format_default) const
5316 {
5317 string_type __r;
5318 format(back_inserter(__r), __fmt,
5319 __fmt + char_traits<char_type>::length(__fmt), __flags);
5320 return __r;
5321 }
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00005322
5323 // allocator:
Howard Hinnant7ca9d942010-09-23 15:13:20 +00005324 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00005325 allocator_type get_allocator() const {return __matches_.get_allocator();}
5326
5327 // swap:
5328 void swap(match_results& __m);
5329
Howard Hinnantc834c512011-11-29 18:15:50 +00005330 template <class _Bp, class _Ap>
Howard Hinnant7ca9d942010-09-23 15:13:20 +00005331 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant66423212010-07-14 21:14:52 +00005332 void __assign(_BidirectionalIterator __f, _BidirectionalIterator __l,
Howard Hinnantc834c512011-11-29 18:15:50 +00005333 const match_results<_Bp, _Ap>& __m, bool __no_update_pos)
Howard Hinnant66423212010-07-14 21:14:52 +00005334 {
Howard Hinnantc834c512011-11-29 18:15:50 +00005335 _Bp __mf = __m.prefix().first;
Howard Hinnant66423212010-07-14 21:14:52 +00005336 __matches_.resize(__m.size());
5337 for (size_type __i = 0; __i < __matches_.size(); ++__i)
5338 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00005339 __matches_[__i].first = _VSTD::next(__f, _VSTD::distance(__mf, __m[__i].first));
5340 __matches_[__i].second = _VSTD::next(__f, _VSTD::distance(__mf, __m[__i].second));
Howard Hinnant66423212010-07-14 21:14:52 +00005341 __matches_[__i].matched = __m[__i].matched;
5342 }
5343 __unmatched_.first = __l;
5344 __unmatched_.second = __l;
5345 __unmatched_.matched = false;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00005346 __prefix_.first = _VSTD::next(__f, _VSTD::distance(__mf, __m.prefix().first));
5347 __prefix_.second = _VSTD::next(__f, _VSTD::distance(__mf, __m.prefix().second));
Howard Hinnant66423212010-07-14 21:14:52 +00005348 __prefix_.matched = __m.prefix().matched;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00005349 __suffix_.first = _VSTD::next(__f, _VSTD::distance(__mf, __m.suffix().first));
5350 __suffix_.second = _VSTD::next(__f, _VSTD::distance(__mf, __m.suffix().second));
Howard Hinnant66423212010-07-14 21:14:52 +00005351 __suffix_.matched = __m.suffix().matched;
Howard Hinnantd3925342010-08-16 20:21:16 +00005352 if (!__no_update_pos)
5353 __position_start_ = __prefix_.first;
Howard Hinnantb5c53a82010-12-08 21:07:55 +00005354 __ready_ = __m.ready();
Howard Hinnant66423212010-07-14 21:14:52 +00005355 }
5356
Howard Hinnantf5cb6eb2010-06-30 17:22:19 +00005357private:
5358 void __init(unsigned __s,
Howard Hinnantd3925342010-08-16 20:21:16 +00005359 _BidirectionalIterator __f, _BidirectionalIterator __l,
5360 bool __no_update_pos = false);
Howard Hinnantf5cb6eb2010-06-30 17:22:19 +00005361
5362 template <class, class> friend class basic_regex;
5363
Howard Hinnantc834c512011-11-29 18:15:50 +00005364 template <class _Bp, class _Ap, class _Cp, class _Tp>
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00005365 friend
5366 bool
Howard Hinnantc834c512011-11-29 18:15:50 +00005367 regex_match(_Bp, _Bp, match_results<_Bp, _Ap>&, const basic_regex<_Cp, _Tp>&,
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00005368 regex_constants::match_flag_type);
Howard Hinnant126da6a2010-07-27 22:20:32 +00005369
Howard Hinnantc834c512011-11-29 18:15:50 +00005370 template <class _Bp, class _Ap>
Howard Hinnantcbc45252010-08-14 18:14:02 +00005371 friend
5372 bool
Howard Hinnantc834c512011-11-29 18:15:50 +00005373 operator==(const match_results<_Bp, _Ap>&, const match_results<_Bp, _Ap>&);
Howard Hinnantcbc45252010-08-14 18:14:02 +00005374
Howard Hinnant126da6a2010-07-27 22:20:32 +00005375 template <class, class> friend class __lookahead;
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00005376};
5377
5378template <class _BidirectionalIterator, class _Allocator>
5379match_results<_BidirectionalIterator, _Allocator>::match_results(
5380 const allocator_type& __a)
5381 : __matches_(__a),
5382 __unmatched_(),
5383 __prefix_(),
Howard Hinnantd3925342010-08-16 20:21:16 +00005384 __suffix_(),
Eric Fiseliera75ee262015-07-22 01:29:41 +00005385 __ready_(false),
5386 __position_start_()
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00005387{
5388}
5389
Howard Hinnantf5cb6eb2010-06-30 17:22:19 +00005390template <class _BidirectionalIterator, class _Allocator>
5391void
5392match_results<_BidirectionalIterator, _Allocator>::__init(unsigned __s,
Howard Hinnantd3925342010-08-16 20:21:16 +00005393 _BidirectionalIterator __f, _BidirectionalIterator __l,
5394 bool __no_update_pos)
Howard Hinnantf5cb6eb2010-06-30 17:22:19 +00005395{
Howard Hinnantf5cb6eb2010-06-30 17:22:19 +00005396 __unmatched_.first = __l;
5397 __unmatched_.second = __l;
5398 __unmatched_.matched = false;
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00005399 __matches_.assign(__s, __unmatched_);
Howard Hinnantf5cb6eb2010-06-30 17:22:19 +00005400 __prefix_.first = __f;
5401 __prefix_.second = __f;
5402 __prefix_.matched = false;
Howard Hinnant5bf96132010-07-08 17:43:58 +00005403 __suffix_ = __unmatched_;
Howard Hinnantd3925342010-08-16 20:21:16 +00005404 if (!__no_update_pos)
5405 __position_start_ = __prefix_.first;
Howard Hinnantb5c53a82010-12-08 21:07:55 +00005406 __ready_ = true;
Howard Hinnantf5cb6eb2010-06-30 17:22:19 +00005407}
5408
Howard Hinnantcbc45252010-08-14 18:14:02 +00005409template <class _BidirectionalIterator, class _Allocator>
5410template <class _OutputIter>
5411_OutputIter
Alexander Richardsonc9637642017-11-14 11:14:25 +00005412match_results<_BidirectionalIterator, _Allocator>::format(_OutputIter __output_iter,
Howard Hinnantcbc45252010-08-14 18:14:02 +00005413 const char_type* __fmt_first, const char_type* __fmt_last,
5414 regex_constants::match_flag_type __flags) const
5415{
5416 if (__flags & regex_constants::format_sed)
5417 {
5418 for (; __fmt_first != __fmt_last; ++__fmt_first)
5419 {
5420 if (*__fmt_first == '&')
Alexander Richardsonc9637642017-11-14 11:14:25 +00005421 __output_iter = _VSTD::copy(__matches_[0].first, __matches_[0].second,
5422 __output_iter);
Howard Hinnantcbc45252010-08-14 18:14:02 +00005423 else if (*__fmt_first == '\\' && __fmt_first + 1 != __fmt_last)
5424 {
5425 ++__fmt_first;
5426 if ('0' <= *__fmt_first && *__fmt_first <= '9')
5427 {
5428 size_t __i = *__fmt_first - '0';
Alexander Richardsonc9637642017-11-14 11:14:25 +00005429 __output_iter = _VSTD::copy((*this)[__i].first,
5430 (*this)[__i].second, __output_iter);
Howard Hinnantcbc45252010-08-14 18:14:02 +00005431 }
5432 else
5433 {
Alexander Richardsonc9637642017-11-14 11:14:25 +00005434 *__output_iter = *__fmt_first;
5435 ++__output_iter;
Howard Hinnantcbc45252010-08-14 18:14:02 +00005436 }
5437 }
5438 else
5439 {
Alexander Richardsonc9637642017-11-14 11:14:25 +00005440 *__output_iter = *__fmt_first;
5441 ++__output_iter;
Howard Hinnantcbc45252010-08-14 18:14:02 +00005442 }
5443 }
5444 }
5445 else
5446 {
5447 for (; __fmt_first != __fmt_last; ++__fmt_first)
5448 {
5449 if (*__fmt_first == '$' && __fmt_first + 1 != __fmt_last)
5450 {
5451 switch (__fmt_first[1])
5452 {
5453 case '$':
Alexander Richardsonc9637642017-11-14 11:14:25 +00005454 *__output_iter = *++__fmt_first;
5455 ++__output_iter;
Howard Hinnantcbc45252010-08-14 18:14:02 +00005456 break;
5457 case '&':
5458 ++__fmt_first;
Alexander Richardsonc9637642017-11-14 11:14:25 +00005459 __output_iter = _VSTD::copy(__matches_[0].first, __matches_[0].second,
5460 __output_iter);
Howard Hinnantcbc45252010-08-14 18:14:02 +00005461 break;
5462 case '`':
5463 ++__fmt_first;
Alexander Richardsonc9637642017-11-14 11:14:25 +00005464 __output_iter = _VSTD::copy(__prefix_.first, __prefix_.second, __output_iter);
Howard Hinnantcbc45252010-08-14 18:14:02 +00005465 break;
5466 case '\'':
5467 ++__fmt_first;
Alexander Richardsonc9637642017-11-14 11:14:25 +00005468 __output_iter = _VSTD::copy(__suffix_.first, __suffix_.second, __output_iter);
Howard Hinnantcbc45252010-08-14 18:14:02 +00005469 break;
5470 default:
5471 if ('0' <= __fmt_first[1] && __fmt_first[1] <= '9')
5472 {
5473 ++__fmt_first;
Marshall Clow266b5ec2017-10-19 22:10:41 +00005474 size_t __idx = *__fmt_first - '0';
Howard Hinnantcbc45252010-08-14 18:14:02 +00005475 if (__fmt_first + 1 != __fmt_last &&
5476 '0' <= __fmt_first[1] && __fmt_first[1] <= '9')
5477 {
5478 ++__fmt_first;
Marshall Clow266b5ec2017-10-19 22:10:41 +00005479 if (__idx >= std::numeric_limits<size_t>::max() / 10)
5480 __throw_regex_error<regex_constants::error_escape>();
5481 __idx = 10 * __idx + *__fmt_first - '0';
Howard Hinnantcbc45252010-08-14 18:14:02 +00005482 }
Alexander Richardsonc9637642017-11-14 11:14:25 +00005483 __output_iter = _VSTD::copy((*this)[__idx].first,
5484 (*this)[__idx].second, __output_iter);
Howard Hinnantcbc45252010-08-14 18:14:02 +00005485 }
5486 else
5487 {
Alexander Richardsonc9637642017-11-14 11:14:25 +00005488 *__output_iter = *__fmt_first;
5489 ++__output_iter;
Howard Hinnantcbc45252010-08-14 18:14:02 +00005490 }
5491 break;
5492 }
5493 }
5494 else
5495 {
Alexander Richardsonc9637642017-11-14 11:14:25 +00005496 *__output_iter = *__fmt_first;
5497 ++__output_iter;
Howard Hinnantcbc45252010-08-14 18:14:02 +00005498 }
5499 }
5500 }
Alexander Richardsonc9637642017-11-14 11:14:25 +00005501 return __output_iter;
Howard Hinnantcbc45252010-08-14 18:14:02 +00005502}
5503
5504template <class _BidirectionalIterator, class _Allocator>
5505void
5506match_results<_BidirectionalIterator, _Allocator>::swap(match_results& __m)
5507{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00005508 using _VSTD::swap;
Howard Hinnantcbc45252010-08-14 18:14:02 +00005509 swap(__matches_, __m.__matches_);
5510 swap(__unmatched_, __m.__unmatched_);
5511 swap(__prefix_, __m.__prefix_);
5512 swap(__suffix_, __m.__suffix_);
Howard Hinnantd3925342010-08-16 20:21:16 +00005513 swap(__position_start_, __m.__position_start_);
Howard Hinnantb5c53a82010-12-08 21:07:55 +00005514 swap(__ready_, __m.__ready_);
Howard Hinnantcbc45252010-08-14 18:14:02 +00005515}
5516
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00005517typedef match_results<const char*> cmatch;
5518typedef match_results<const wchar_t*> wcmatch;
5519typedef match_results<string::const_iterator> smatch;
5520typedef match_results<wstring::const_iterator> wsmatch;
5521
5522template <class _BidirectionalIterator, class _Allocator>
Howard Hinnantcbc45252010-08-14 18:14:02 +00005523bool
5524operator==(const match_results<_BidirectionalIterator, _Allocator>& __x,
5525 const match_results<_BidirectionalIterator, _Allocator>& __y)
5526{
Howard Hinnantb5c53a82010-12-08 21:07:55 +00005527 if (__x.__ready_ != __y.__ready_)
5528 return false;
5529 if (!__x.__ready_)
5530 return true;
Howard Hinnantcbc45252010-08-14 18:14:02 +00005531 return __x.__matches_ == __y.__matches_ &&
5532 __x.__prefix_ == __y.__prefix_ &&
Howard Hinnantb5c53a82010-12-08 21:07:55 +00005533 __x.__suffix_ == __y.__suffix_;
Howard Hinnantcbc45252010-08-14 18:14:02 +00005534}
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00005535
5536template <class _BidirectionalIterator, class _Allocator>
Howard Hinnantcbc45252010-08-14 18:14:02 +00005537inline _LIBCPP_INLINE_VISIBILITY
5538bool
5539operator!=(const match_results<_BidirectionalIterator, _Allocator>& __x,
5540 const match_results<_BidirectionalIterator, _Allocator>& __y)
5541{
5542 return !(__x == __y);
5543}
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00005544
5545template <class _BidirectionalIterator, class _Allocator>
Howard Hinnantcbc45252010-08-14 18:14:02 +00005546inline _LIBCPP_INLINE_VISIBILITY
5547void
5548swap(match_results<_BidirectionalIterator, _Allocator>& __x,
5549 match_results<_BidirectionalIterator, _Allocator>& __y)
5550{
5551 __x.swap(__y);
5552}
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00005553
5554// regex_search
5555
Howard Hinnantf5cb6eb2010-06-30 17:22:19 +00005556template <class _CharT, class _Traits>
Howard Hinnant70d27852010-07-27 01:25:38 +00005557template <class _Allocator>
Howard Hinnantf5cb6eb2010-06-30 17:22:19 +00005558bool
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00005559basic_regex<_CharT, _Traits>::__match_at_start_ecma(
Howard Hinnant70d27852010-07-27 01:25:38 +00005560 const _CharT* __first, const _CharT* __last,
5561 match_results<const _CharT*, _Allocator>& __m,
Howard Hinnant066ba512011-03-26 20:02:27 +00005562 regex_constants::match_flag_type __flags, bool __at_first) const
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00005563{
Howard Hinnant70d27852010-07-27 01:25:38 +00005564 vector<__state> __states;
Howard Hinnant70d27852010-07-27 01:25:38 +00005565 __node* __st = __start_.get();
5566 if (__st)
5567 {
Marshall Clow8db143c2015-01-28 22:22:35 +00005568 sub_match<const _CharT*> __unmatched;
5569 __unmatched.first = __last;
5570 __unmatched.second = __last;
5571 __unmatched.matched = false;
5572
Howard Hinnant70d27852010-07-27 01:25:38 +00005573 __states.push_back(__state());
5574 __states.back().__do_ = 0;
5575 __states.back().__first_ = __first;
5576 __states.back().__current_ = __first;
5577 __states.back().__last_ = __last;
Marshall Clow8db143c2015-01-28 22:22:35 +00005578 __states.back().__sub_matches_.resize(mark_count(), __unmatched);
Howard Hinnant70d27852010-07-27 01:25:38 +00005579 __states.back().__loop_data_.resize(__loop_count());
5580 __states.back().__node_ = __st;
5581 __states.back().__flags_ = __flags;
Howard Hinnant066ba512011-03-26 20:02:27 +00005582 __states.back().__at_first_ = __at_first;
Marshall Clowd39d21d2017-09-12 17:56:59 +00005583 int __counter = 0;
5584 int __length = __last - __first;
Howard Hinnant70d27852010-07-27 01:25:38 +00005585 do
5586 {
Marshall Clowd39d21d2017-09-12 17:56:59 +00005587 ++__counter;
5588 if (__counter % _LIBCPP_REGEX_COMPLEXITY_FACTOR == 0 &&
5589 __counter / _LIBCPP_REGEX_COMPLEXITY_FACTOR >= __length)
5590 __throw_regex_error<regex_constants::error_complexity>();
Howard Hinnant70d27852010-07-27 01:25:38 +00005591 __state& __s = __states.back();
5592 if (__s.__node_)
5593 __s.__node_->__exec(__s);
5594 switch (__s.__do_)
5595 {
5596 case __state::__end_state:
Tim Shen11113f52016-10-27 21:40:34 +00005597 if ((__flags & regex_constants::match_not_null) &&
Tim Shend5f175a2016-10-21 20:41:47 +00005598 __s.__current_ == __first)
5599 {
5600 __states.pop_back();
5601 break;
5602 }
Tim Shen11113f52016-10-27 21:40:34 +00005603 if ((__flags & regex_constants::__full_match) &&
5604 __s.__current_ != __last)
5605 {
5606 __states.pop_back();
5607 break;
5608 }
Howard Hinnant70d27852010-07-27 01:25:38 +00005609 __m.__matches_[0].first = __first;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00005610 __m.__matches_[0].second = _VSTD::next(__first, __s.__current_ - __first);
Howard Hinnant70d27852010-07-27 01:25:38 +00005611 __m.__matches_[0].matched = true;
5612 for (unsigned __i = 0; __i < __s.__sub_matches_.size(); ++__i)
5613 __m.__matches_[__i+1] = __s.__sub_matches_[__i];
5614 return true;
5615 case __state::__accept_and_consume:
5616 case __state::__repeat:
5617 case __state::__accept_but_not_consume:
5618 break;
5619 case __state::__split:
5620 {
5621 __state __snext = __s;
5622 __s.__node_->__exec_split(true, __s);
5623 __snext.__node_->__exec_split(false, __snext);
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00005624 __states.push_back(_VSTD::move(__snext));
Howard Hinnant70d27852010-07-27 01:25:38 +00005625 }
5626 break;
5627 case __state::__reject:
5628 __states.pop_back();
5629 break;
5630 default:
Marshall Clowc8ccc292015-07-28 13:30:47 +00005631 __throw_regex_error<regex_constants::__re_err_unknown>();
Howard Hinnant70d27852010-07-27 01:25:38 +00005632 break;
Howard Hinnant72f73582010-08-11 17:04:31 +00005633
Howard Hinnant70d27852010-07-27 01:25:38 +00005634 }
5635 } while (!__states.empty());
5636 }
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00005637 return false;
5638}
5639
5640template <class _CharT, class _Traits>
Howard Hinnant66423212010-07-14 21:14:52 +00005641template <class _Allocator>
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00005642bool
5643basic_regex<_CharT, _Traits>::__match_at_start_posix_nosubs(
5644 const _CharT* __first, const _CharT* __last,
Howard Hinnant66423212010-07-14 21:14:52 +00005645 match_results<const _CharT*, _Allocator>& __m,
Howard Hinnant066ba512011-03-26 20:02:27 +00005646 regex_constants::match_flag_type __flags, bool __at_first) const
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00005647{
Howard Hinnantaa0874c2010-07-12 15:51:17 +00005648 deque<__state> __states;
Howard Hinnant66423212010-07-14 21:14:52 +00005649 ptrdiff_t __highest_j = 0;
Howard Hinnantc834c512011-11-29 18:15:50 +00005650 ptrdiff_t _Np = _VSTD::distance(__first, __last);
Howard Hinnantaa0874c2010-07-12 15:51:17 +00005651 __node* __st = __start_.get();
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00005652 if (__st)
5653 {
Howard Hinnantaa0874c2010-07-12 15:51:17 +00005654 __states.push_back(__state());
Howard Hinnantaa0874c2010-07-12 15:51:17 +00005655 __states.back().__do_ = 0;
5656 __states.back().__first_ = __first;
5657 __states.back().__current_ = __first;
5658 __states.back().__last_ = __last;
5659 __states.back().__loop_data_.resize(__loop_count());
5660 __states.back().__node_ = __st;
5661 __states.back().__flags_ = __flags;
Howard Hinnant066ba512011-03-26 20:02:27 +00005662 __states.back().__at_first_ = __at_first;
Howard Hinnant5d4aaa42010-07-14 15:45:11 +00005663 bool __matched = false;
Marshall Clowd39d21d2017-09-12 17:56:59 +00005664 int __counter = 0;
5665 int __length = __last - __first;
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00005666 do
5667 {
Marshall Clowd39d21d2017-09-12 17:56:59 +00005668 ++__counter;
5669 if (__counter % _LIBCPP_REGEX_COMPLEXITY_FACTOR == 0 &&
5670 __counter / _LIBCPP_REGEX_COMPLEXITY_FACTOR >= __length)
5671 __throw_regex_error<regex_constants::error_complexity>();
Howard Hinnantaa0874c2010-07-12 15:51:17 +00005672 __state& __s = __states.back();
5673 if (__s.__node_)
5674 __s.__node_->__exec(__s);
5675 switch (__s.__do_)
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00005676 {
Howard Hinnantaa0874c2010-07-12 15:51:17 +00005677 case __state::__end_state:
Tim Shen11113f52016-10-27 21:40:34 +00005678 if ((__flags & regex_constants::match_not_null) &&
Tim Shend5f175a2016-10-21 20:41:47 +00005679 __s.__current_ == __first)
5680 {
5681 __states.pop_back();
5682 break;
5683 }
Tim Shen11113f52016-10-27 21:40:34 +00005684 if ((__flags & regex_constants::__full_match) &&
5685 __s.__current_ != __last)
5686 {
5687 __states.pop_back();
5688 break;
5689 }
Howard Hinnantebbc2b62010-07-27 17:24:17 +00005690 if (!__matched || __highest_j < __s.__current_ - __s.__first_)
Howard Hinnant5d4aaa42010-07-14 15:45:11 +00005691 __highest_j = __s.__current_ - __s.__first_;
Howard Hinnantebbc2b62010-07-27 17:24:17 +00005692 __matched = true;
Howard Hinnantc834c512011-11-29 18:15:50 +00005693 if (__highest_j == _Np)
Howard Hinnantaa0874c2010-07-12 15:51:17 +00005694 __states.clear();
5695 else
5696 __states.pop_back();
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00005697 break;
Howard Hinnantaa0874c2010-07-12 15:51:17 +00005698 case __state::__consume_input:
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00005699 break;
Howard Hinnantaa0874c2010-07-12 15:51:17 +00005700 case __state::__accept_and_consume:
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00005701 __states.push_front(_VSTD::move(__s));
Howard Hinnantaa0874c2010-07-12 15:51:17 +00005702 __states.pop_back();
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00005703 break;
Howard Hinnantaa0874c2010-07-12 15:51:17 +00005704 case __state::__repeat:
5705 case __state::__accept_but_not_consume:
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00005706 break;
Howard Hinnantaa0874c2010-07-12 15:51:17 +00005707 case __state::__split:
5708 {
5709 __state __snext = __s;
5710 __s.__node_->__exec_split(true, __s);
5711 __snext.__node_->__exec_split(false, __snext);
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00005712 __states.push_back(_VSTD::move(__snext));
Howard Hinnantaa0874c2010-07-12 15:51:17 +00005713 }
5714 break;
5715 case __state::__reject:
5716 __states.pop_back();
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00005717 break;
5718 default:
Marshall Clowc8ccc292015-07-28 13:30:47 +00005719 __throw_regex_error<regex_constants::__re_err_unknown>();
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00005720 break;
5721 }
Howard Hinnantaa0874c2010-07-12 15:51:17 +00005722 } while (!__states.empty());
Howard Hinnant5d4aaa42010-07-14 15:45:11 +00005723 if (__matched)
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00005724 {
5725 __m.__matches_[0].first = __first;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00005726 __m.__matches_[0].second = _VSTD::next(__first, __highest_j);
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00005727 __m.__matches_[0].matched = true;
5728 return true;
5729 }
5730 }
5731 return false;
5732}
5733
5734template <class _CharT, class _Traits>
Howard Hinnant66423212010-07-14 21:14:52 +00005735template <class _Allocator>
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00005736bool
5737basic_regex<_CharT, _Traits>::__match_at_start_posix_subs(
Howard Hinnant66423212010-07-14 21:14:52 +00005738 const _CharT* __first, const _CharT* __last,
5739 match_results<const _CharT*, _Allocator>& __m,
Howard Hinnant066ba512011-03-26 20:02:27 +00005740 regex_constants::match_flag_type __flags, bool __at_first) const
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00005741{
Howard Hinnantaa0874c2010-07-12 15:51:17 +00005742 vector<__state> __states;
Howard Hinnantaa0874c2010-07-12 15:51:17 +00005743 __state __best_state;
Howard Hinnant66423212010-07-14 21:14:52 +00005744 ptrdiff_t __j = 0;
5745 ptrdiff_t __highest_j = 0;
Howard Hinnantc834c512011-11-29 18:15:50 +00005746 ptrdiff_t _Np = _VSTD::distance(__first, __last);
Howard Hinnantaa0874c2010-07-12 15:51:17 +00005747 __node* __st = __start_.get();
Howard Hinnant5bf96132010-07-08 17:43:58 +00005748 if (__st)
5749 {
Marshall Clow8db143c2015-01-28 22:22:35 +00005750 sub_match<const _CharT*> __unmatched;
5751 __unmatched.first = __last;
5752 __unmatched.second = __last;
5753 __unmatched.matched = false;
5754
Howard Hinnantaa0874c2010-07-12 15:51:17 +00005755 __states.push_back(__state());
5756 __states.back().__do_ = 0;
5757 __states.back().__first_ = __first;
5758 __states.back().__current_ = __first;
5759 __states.back().__last_ = __last;
Marshall Clow8db143c2015-01-28 22:22:35 +00005760 __states.back().__sub_matches_.resize(mark_count(), __unmatched);
Howard Hinnantaa0874c2010-07-12 15:51:17 +00005761 __states.back().__loop_data_.resize(__loop_count());
5762 __states.back().__node_ = __st;
5763 __states.back().__flags_ = __flags;
Howard Hinnant066ba512011-03-26 20:02:27 +00005764 __states.back().__at_first_ = __at_first;
Howard Hinnant66423212010-07-14 21:14:52 +00005765 const _CharT* __current = __first;
Howard Hinnantaa0874c2010-07-12 15:51:17 +00005766 bool __matched = false;
Marshall Clowd39d21d2017-09-12 17:56:59 +00005767 int __counter = 0;
5768 int __length = __last - __first;
Howard Hinnant5bf96132010-07-08 17:43:58 +00005769 do
5770 {
Marshall Clowd39d21d2017-09-12 17:56:59 +00005771 ++__counter;
5772 if (__counter % _LIBCPP_REGEX_COMPLEXITY_FACTOR == 0 &&
5773 __counter / _LIBCPP_REGEX_COMPLEXITY_FACTOR >= __length)
5774 __throw_regex_error<regex_constants::error_complexity>();
Howard Hinnantaa0874c2010-07-12 15:51:17 +00005775 __state& __s = __states.back();
5776 if (__s.__node_)
5777 __s.__node_->__exec(__s);
5778 switch (__s.__do_)
Howard Hinnant5bf96132010-07-08 17:43:58 +00005779 {
Howard Hinnantaa0874c2010-07-12 15:51:17 +00005780 case __state::__end_state:
Tim Shen11113f52016-10-27 21:40:34 +00005781 if ((__flags & regex_constants::match_not_null) &&
Tim Shend5f175a2016-10-21 20:41:47 +00005782 __s.__current_ == __first)
5783 {
5784 __states.pop_back();
5785 break;
5786 }
Tim Shen11113f52016-10-27 21:40:34 +00005787 if ((__flags & regex_constants::__full_match) &&
5788 __s.__current_ != __last)
5789 {
5790 __states.pop_back();
5791 break;
5792 }
Howard Hinnantebbc2b62010-07-27 17:24:17 +00005793 if (!__matched || __highest_j < __s.__current_ - __s.__first_)
Howard Hinnant5bf96132010-07-08 17:43:58 +00005794 {
Howard Hinnantebbc2b62010-07-27 17:24:17 +00005795 __highest_j = __s.__current_ - __s.__first_;
Howard Hinnantaa0874c2010-07-12 15:51:17 +00005796 __best_state = __s;
Howard Hinnant5bf96132010-07-08 17:43:58 +00005797 }
Howard Hinnantebbc2b62010-07-27 17:24:17 +00005798 __matched = true;
Howard Hinnantc834c512011-11-29 18:15:50 +00005799 if (__highest_j == _Np)
Howard Hinnantebbc2b62010-07-27 17:24:17 +00005800 __states.clear();
5801 else
5802 __states.pop_back();
Howard Hinnant5bf96132010-07-08 17:43:58 +00005803 break;
Howard Hinnantaa0874c2010-07-12 15:51:17 +00005804 case __state::__accept_and_consume:
Howard Hinnant2a315e32010-07-12 18:16:05 +00005805 __j += __s.__current_ - __current;
5806 __current = __s.__current_;
Howard Hinnant5bf96132010-07-08 17:43:58 +00005807 break;
Howard Hinnantaa0874c2010-07-12 15:51:17 +00005808 case __state::__repeat:
5809 case __state::__accept_but_not_consume:
Howard Hinnant5bf96132010-07-08 17:43:58 +00005810 break;
Howard Hinnantaa0874c2010-07-12 15:51:17 +00005811 case __state::__split:
5812 {
5813 __state __snext = __s;
5814 __s.__node_->__exec_split(true, __s);
5815 __snext.__node_->__exec_split(false, __snext);
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00005816 __states.push_back(_VSTD::move(__snext));
Howard Hinnantaa0874c2010-07-12 15:51:17 +00005817 }
5818 break;
5819 case __state::__reject:
5820 __states.pop_back();
Howard Hinnant5bf96132010-07-08 17:43:58 +00005821 break;
5822 default:
Marshall Clowc8ccc292015-07-28 13:30:47 +00005823 __throw_regex_error<regex_constants::__re_err_unknown>();
Howard Hinnant5bf96132010-07-08 17:43:58 +00005824 break;
5825 }
Howard Hinnantaa0874c2010-07-12 15:51:17 +00005826 } while (!__states.empty());
5827 if (__matched)
Howard Hinnant5bf96132010-07-08 17:43:58 +00005828 {
5829 __m.__matches_[0].first = __first;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00005830 __m.__matches_[0].second = _VSTD::next(__first, __highest_j);
Howard Hinnant5bf96132010-07-08 17:43:58 +00005831 __m.__matches_[0].matched = true;
Howard Hinnantaa0874c2010-07-12 15:51:17 +00005832 for (unsigned __i = 0; __i < __best_state.__sub_matches_.size(); ++__i)
5833 __m.__matches_[__i+1] = __best_state.__sub_matches_[__i];
Howard Hinnant5bf96132010-07-08 17:43:58 +00005834 return true;
5835 }
5836 }
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00005837 return false;
5838}
5839
5840template <class _CharT, class _Traits>
Howard Hinnant66423212010-07-14 21:14:52 +00005841template <class _Allocator>
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00005842bool
5843basic_regex<_CharT, _Traits>::__match_at_start(
Howard Hinnant66423212010-07-14 21:14:52 +00005844 const _CharT* __first, const _CharT* __last,
5845 match_results<const _CharT*, _Allocator>& __m,
Howard Hinnant066ba512011-03-26 20:02:27 +00005846 regex_constants::match_flag_type __flags, bool __at_first) const
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00005847{
Howard Hinnantebbc2b62010-07-27 17:24:17 +00005848 if ((__flags_ & 0x1F0) == ECMAScript)
Howard Hinnant066ba512011-03-26 20:02:27 +00005849 return __match_at_start_ecma(__first, __last, __m, __flags, __at_first);
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00005850 if (mark_count() == 0)
Howard Hinnant066ba512011-03-26 20:02:27 +00005851 return __match_at_start_posix_nosubs(__first, __last, __m, __flags, __at_first);
5852 return __match_at_start_posix_subs(__first, __last, __m, __flags, __at_first);
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00005853}
5854
5855template <class _CharT, class _Traits>
Howard Hinnant66423212010-07-14 21:14:52 +00005856template <class _Allocator>
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00005857bool
Howard Hinnantf5cb6eb2010-06-30 17:22:19 +00005858basic_regex<_CharT, _Traits>::__search(
Howard Hinnant66423212010-07-14 21:14:52 +00005859 const _CharT* __first, const _CharT* __last,
5860 match_results<const _CharT*, _Allocator>& __m,
Howard Hinnantf5cb6eb2010-06-30 17:22:19 +00005861 regex_constants::match_flag_type __flags) const
5862{
Howard Hinnantd3925342010-08-16 20:21:16 +00005863 __m.__init(1 + mark_count(), __first, __last,
5864 __flags & regex_constants::__no_update_pos);
Howard Hinnant38d14f72013-07-09 17:29:09 +00005865 if (__match_at_start(__first, __last, __m, __flags,
5866 !(__flags & regex_constants::__no_update_pos)))
Howard Hinnantf5cb6eb2010-06-30 17:22:19 +00005867 {
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00005868 __m.__prefix_.second = __m[0].first;
5869 __m.__prefix_.matched = __m.__prefix_.first != __m.__prefix_.second;
5870 __m.__suffix_.first = __m[0].second;
5871 __m.__suffix_.matched = __m.__suffix_.first != __m.__suffix_.second;
5872 return true;
5873 }
Howard Hinnant22cf4862010-07-29 01:15:27 +00005874 if (__first != __last && !(__flags & regex_constants::match_continuous))
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00005875 {
Howard Hinnant6b2602a2010-07-29 15:17:28 +00005876 __flags |= regex_constants::match_prev_avail;
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00005877 for (++__first; __first != __last; ++__first)
Howard Hinnantf5cb6eb2010-06-30 17:22:19 +00005878 {
Howard Hinnant6b2602a2010-07-29 15:17:28 +00005879 __m.__matches_.assign(__m.size(), __m.__unmatched_);
Howard Hinnant066ba512011-03-26 20:02:27 +00005880 if (__match_at_start(__first, __last, __m, __flags, false))
Howard Hinnantf5cb6eb2010-06-30 17:22:19 +00005881 {
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00005882 __m.__prefix_.second = __m[0].first;
5883 __m.__prefix_.matched = __m.__prefix_.first != __m.__prefix_.second;
5884 __m.__suffix_.first = __m[0].second;
5885 __m.__suffix_.matched = __m.__suffix_.first != __m.__suffix_.second;
5886 return true;
Howard Hinnantf5cb6eb2010-06-30 17:22:19 +00005887 }
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00005888 __m.__matches_.assign(__m.size(), __m.__unmatched_);
Howard Hinnantf5cb6eb2010-06-30 17:22:19 +00005889 }
5890 }
Howard Hinnant66bcf7e2010-07-07 19:14:52 +00005891 __m.__matches_.clear();
5892 return false;
Howard Hinnantf5cb6eb2010-06-30 17:22:19 +00005893}
5894
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00005895template <class _BidirectionalIterator, class _Allocator, class _CharT, class _Traits>
Howard Hinnantf5cb6eb2010-06-30 17:22:19 +00005896inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00005897bool
5898regex_search(_BidirectionalIterator __first, _BidirectionalIterator __last,
5899 match_results<_BidirectionalIterator, _Allocator>& __m,
5900 const basic_regex<_CharT, _Traits>& __e,
Howard Hinnantf5cb6eb2010-06-30 17:22:19 +00005901 regex_constants::match_flag_type __flags = regex_constants::match_default)
5902{
Howard Hinnant1e5de642013-07-11 15:32:55 +00005903 int __offset = (__flags & regex_constants::match_prev_avail) ? 1 : 0;
5904 basic_string<_CharT> __s(_VSTD::prev(__first, __offset), __last);
Howard Hinnant66423212010-07-14 21:14:52 +00005905 match_results<const _CharT*> __mc;
Howard Hinnant1e5de642013-07-11 15:32:55 +00005906 bool __r = __e.__search(__s.data() + __offset, __s.data() + __s.size(), __mc, __flags);
Howard Hinnantd3925342010-08-16 20:21:16 +00005907 __m.__assign(__first, __last, __mc, __flags & regex_constants::__no_update_pos);
Howard Hinnant66423212010-07-14 21:14:52 +00005908 return __r;
5909}
5910
Howard Hinnant4018c482013-06-29 23:45:43 +00005911template <class _Iter, class _Allocator, class _CharT, class _Traits>
5912inline _LIBCPP_INLINE_VISIBILITY
5913bool
5914regex_search(__wrap_iter<_Iter> __first,
5915 __wrap_iter<_Iter> __last,
5916 match_results<__wrap_iter<_Iter>, _Allocator>& __m,
5917 const basic_regex<_CharT, _Traits>& __e,
5918 regex_constants::match_flag_type __flags = regex_constants::match_default)
5919{
5920 match_results<const _CharT*> __mc;
5921 bool __r = __e.__search(__first.base(), __last.base(), __mc, __flags);
5922 __m.__assign(__first, __last, __mc, __flags & regex_constants::__no_update_pos);
5923 return __r;
5924}
5925
Howard Hinnant66423212010-07-14 21:14:52 +00005926template <class _Allocator, class _CharT, class _Traits>
5927inline _LIBCPP_INLINE_VISIBILITY
5928bool
5929regex_search(const _CharT* __first, const _CharT* __last,
5930 match_results<const _CharT*, _Allocator>& __m,
5931 const basic_regex<_CharT, _Traits>& __e,
5932 regex_constants::match_flag_type __flags = regex_constants::match_default)
5933{
Howard Hinnantf5cb6eb2010-06-30 17:22:19 +00005934 return __e.__search(__first, __last, __m, __flags);
5935}
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00005936
5937template <class _BidirectionalIterator, class _CharT, class _Traits>
5938inline _LIBCPP_INLINE_VISIBILITY
5939bool
5940regex_search(_BidirectionalIterator __first, _BidirectionalIterator __last,
5941 const basic_regex<_CharT, _Traits>& __e,
5942 regex_constants::match_flag_type __flags = regex_constants::match_default)
5943{
Howard Hinnant66423212010-07-14 21:14:52 +00005944 basic_string<_CharT> __s(__first, __last);
5945 match_results<const _CharT*> __mc;
5946 return __e.__search(__s.data(), __s.data() + __s.size(), __mc, __flags);
5947}
5948
5949template <class _CharT, class _Traits>
5950inline _LIBCPP_INLINE_VISIBILITY
5951bool
5952regex_search(const _CharT* __first, const _CharT* __last,
5953 const basic_regex<_CharT, _Traits>& __e,
5954 regex_constants::match_flag_type __flags = regex_constants::match_default)
5955{
5956 match_results<const _CharT*> __mc;
5957 return __e.__search(__first, __last, __mc, __flags);
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00005958}
5959
5960template <class _CharT, class _Allocator, class _Traits>
5961inline _LIBCPP_INLINE_VISIBILITY
5962bool
5963regex_search(const _CharT* __str, match_results<const _CharT*, _Allocator>& __m,
5964 const basic_regex<_CharT, _Traits>& __e,
5965 regex_constants::match_flag_type __flags = regex_constants::match_default)
5966{
Howard Hinnant66423212010-07-14 21:14:52 +00005967 return __e.__search(__str, __str + _Traits::length(__str), __m, __flags);
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00005968}
5969
5970template <class _CharT, class _Traits>
5971inline _LIBCPP_INLINE_VISIBILITY
5972bool
5973regex_search(const _CharT* __str, const basic_regex<_CharT, _Traits>& __e,
5974 regex_constants::match_flag_type __flags = regex_constants::match_default)
5975{
Howard Hinnant66423212010-07-14 21:14:52 +00005976 match_results<const _CharT*> __m;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00005977 return _VSTD::regex_search(__str, __m, __e, __flags);
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00005978}
5979
5980template <class _ST, class _SA, class _CharT, class _Traits>
5981inline _LIBCPP_INLINE_VISIBILITY
5982bool
5983regex_search(const basic_string<_CharT, _ST, _SA>& __s,
5984 const basic_regex<_CharT, _Traits>& __e,
5985 regex_constants::match_flag_type __flags = regex_constants::match_default)
5986{
Howard Hinnant66423212010-07-14 21:14:52 +00005987 match_results<const _CharT*> __mc;
5988 return __e.__search(__s.data(), __s.data() + __s.size(), __mc, __flags);
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00005989}
5990
5991template <class _ST, class _SA, class _Allocator, class _CharT, class _Traits>
5992inline _LIBCPP_INLINE_VISIBILITY
5993bool
5994regex_search(const basic_string<_CharT, _ST, _SA>& __s,
5995 match_results<typename basic_string<_CharT, _ST, _SA>::const_iterator, _Allocator>& __m,
5996 const basic_regex<_CharT, _Traits>& __e,
5997 regex_constants::match_flag_type __flags = regex_constants::match_default)
5998{
Howard Hinnant66423212010-07-14 21:14:52 +00005999 match_results<const _CharT*> __mc;
6000 bool __r = __e.__search(__s.data(), __s.data() + __s.size(), __mc, __flags);
Howard Hinnantd3925342010-08-16 20:21:16 +00006001 __m.__assign(__s.begin(), __s.end(), __mc, __flags & regex_constants::__no_update_pos);
Howard Hinnant66423212010-07-14 21:14:52 +00006002 return __r;
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00006003}
6004
Marshall Clow8c950072014-02-19 21:21:11 +00006005#if _LIBCPP_STD_VER > 11
6006template <class _ST, class _SA, class _Ap, class _Cp, class _Tp>
6007bool
6008regex_search(const basic_string<_Cp, _ST, _SA>&& __s,
6009 match_results<typename basic_string<_Cp, _ST, _SA>::const_iterator, _Ap>&,
6010 const basic_regex<_Cp, _Tp>& __e,
6011 regex_constants::match_flag_type __flags = regex_constants::match_default) = delete;
6012#endif
6013
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00006014// regex_match
6015
6016template <class _BidirectionalIterator, class _Allocator, class _CharT, class _Traits>
6017bool
6018regex_match(_BidirectionalIterator __first, _BidirectionalIterator __last,
6019 match_results<_BidirectionalIterator, _Allocator>& __m,
6020 const basic_regex<_CharT, _Traits>& __e,
6021 regex_constants::match_flag_type __flags = regex_constants::match_default)
6022{
Tim Shen11113f52016-10-27 21:40:34 +00006023 bool __r = _VSTD::regex_search(
6024 __first, __last, __m, __e,
6025 __flags | regex_constants::match_continuous |
6026 regex_constants::__full_match);
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00006027 if (__r)
6028 {
6029 __r = !__m.suffix().matched;
6030 if (!__r)
6031 __m.__matches_.clear();
6032 }
6033 return __r;
6034}
6035
6036template <class _BidirectionalIterator, class _CharT, class _Traits>
6037inline _LIBCPP_INLINE_VISIBILITY
6038bool
6039regex_match(_BidirectionalIterator __first, _BidirectionalIterator __last,
6040 const basic_regex<_CharT, _Traits>& __e,
6041 regex_constants::match_flag_type __flags = regex_constants::match_default)
6042{
6043 match_results<_BidirectionalIterator> __m;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00006044 return _VSTD::regex_match(__first, __last, __m, __e, __flags);
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00006045}
6046
6047template <class _CharT, class _Allocator, class _Traits>
6048inline _LIBCPP_INLINE_VISIBILITY
6049bool
6050regex_match(const _CharT* __str, match_results<const _CharT*, _Allocator>& __m,
6051 const basic_regex<_CharT, _Traits>& __e,
6052 regex_constants::match_flag_type __flags = regex_constants::match_default)
6053{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00006054 return _VSTD::regex_match(__str, __str + _Traits::length(__str), __m, __e, __flags);
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00006055}
6056
6057template <class _ST, class _SA, class _Allocator, class _CharT, class _Traits>
6058inline _LIBCPP_INLINE_VISIBILITY
6059bool
6060regex_match(const basic_string<_CharT, _ST, _SA>& __s,
6061 match_results<typename basic_string<_CharT, _ST, _SA>::const_iterator, _Allocator>& __m,
6062 const basic_regex<_CharT, _Traits>& __e,
6063 regex_constants::match_flag_type __flags = regex_constants::match_default)
6064{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00006065 return _VSTD::regex_match(__s.begin(), __s.end(), __m, __e, __flags);
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00006066}
6067
Marshall Clow8c950072014-02-19 21:21:11 +00006068#if _LIBCPP_STD_VER > 11
6069template <class _ST, class _SA, class _Allocator, class _CharT, class _Traits>
6070inline _LIBCPP_INLINE_VISIBILITY
6071bool
6072regex_match(const basic_string<_CharT, _ST, _SA>&& __s,
6073 match_results<typename basic_string<_CharT, _ST, _SA>::const_iterator, _Allocator>& __m,
6074 const basic_regex<_CharT, _Traits>& __e,
6075 regex_constants::match_flag_type __flags = regex_constants::match_default) = delete;
6076#endif
6077
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00006078template <class _CharT, class _Traits>
6079inline _LIBCPP_INLINE_VISIBILITY
6080bool
6081regex_match(const _CharT* __str, const basic_regex<_CharT, _Traits>& __e,
6082 regex_constants::match_flag_type __flags = regex_constants::match_default)
6083{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00006084 return _VSTD::regex_match(__str, __str + _Traits::length(__str), __e, __flags);
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00006085}
6086
6087template <class _ST, class _SA, class _CharT, class _Traits>
6088inline _LIBCPP_INLINE_VISIBILITY
6089bool
6090regex_match(const basic_string<_CharT, _ST, _SA>& __s,
6091 const basic_regex<_CharT, _Traits>& __e,
6092 regex_constants::match_flag_type __flags = regex_constants::match_default)
6093{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00006094 return _VSTD::regex_match(__s.begin(), __s.end(), __e, __flags);
Howard Hinnant65a3f3d2010-06-30 00:21:42 +00006095}
6096
Howard Hinnantd3925342010-08-16 20:21:16 +00006097// regex_iterator
6098
6099template <class _BidirectionalIterator,
6100 class _CharT = typename iterator_traits<_BidirectionalIterator>::value_type,
6101 class _Traits = regex_traits<_CharT> >
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +00006102class _LIBCPP_TEMPLATE_VIS regex_iterator
Howard Hinnantd3925342010-08-16 20:21:16 +00006103{
6104public:
6105 typedef basic_regex<_CharT, _Traits> regex_type;
6106 typedef match_results<_BidirectionalIterator> value_type;
6107 typedef ptrdiff_t difference_type;
6108 typedef const value_type* pointer;
6109 typedef const value_type& reference;
6110 typedef forward_iterator_tag iterator_category;
6111
6112private:
6113 _BidirectionalIterator __begin_;
6114 _BidirectionalIterator __end_;
6115 const regex_type* __pregex_;
6116 regex_constants::match_flag_type __flags_;
6117 value_type __match_;
6118
6119public:
6120 regex_iterator();
6121 regex_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
6122 const regex_type& __re,
Marshall Clow8c950072014-02-19 21:21:11 +00006123 regex_constants::match_flag_type __m
6124 = regex_constants::match_default);
6125#if _LIBCPP_STD_VER > 11
6126 regex_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
6127 const regex_type&& __re,
6128 regex_constants::match_flag_type __m
6129 = regex_constants::match_default) = delete;
6130#endif
Howard Hinnantd3925342010-08-16 20:21:16 +00006131
6132 bool operator==(const regex_iterator& __x) const;
Howard Hinnant7ca9d942010-09-23 15:13:20 +00006133 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantd3925342010-08-16 20:21:16 +00006134 bool operator!=(const regex_iterator& __x) const {return !(*this == __x);}
6135
Howard Hinnant7ca9d942010-09-23 15:13:20 +00006136 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantd3925342010-08-16 20:21:16 +00006137 reference operator*() const {return __match_;}
Howard Hinnant7ca9d942010-09-23 15:13:20 +00006138 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantd3925342010-08-16 20:21:16 +00006139 pointer operator->() const {return &__match_;}
6140
6141 regex_iterator& operator++();
Howard Hinnant7ca9d942010-09-23 15:13:20 +00006142 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantd3925342010-08-16 20:21:16 +00006143 regex_iterator operator++(int)
6144 {
6145 regex_iterator __t(*this);
6146 ++(*this);
6147 return __t;
6148 }
6149};
6150
6151template <class _BidirectionalIterator, class _CharT, class _Traits>
6152regex_iterator<_BidirectionalIterator, _CharT, _Traits>::regex_iterator()
6153 : __begin_(), __end_(), __pregex_(nullptr), __flags_(), __match_()
6154{
6155}
6156
6157template <class _BidirectionalIterator, class _CharT, class _Traits>
6158regex_iterator<_BidirectionalIterator, _CharT, _Traits>::
6159 regex_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
6160 const regex_type& __re, regex_constants::match_flag_type __m)
6161 : __begin_(__a),
6162 __end_(__b),
6163 __pregex_(&__re),
6164 __flags_(__m)
6165{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00006166 _VSTD::regex_search(__begin_, __end_, __match_, *__pregex_, __flags_);
Howard Hinnantd3925342010-08-16 20:21:16 +00006167}
6168
6169template <class _BidirectionalIterator, class _CharT, class _Traits>
6170bool
6171regex_iterator<_BidirectionalIterator, _CharT, _Traits>::
6172 operator==(const regex_iterator& __x) const
6173{
6174 if (__match_.empty() && __x.__match_.empty())
6175 return true;
6176 if (__match_.empty() || __x.__match_.empty())
6177 return false;
6178 return __begin_ == __x.__begin_ &&
6179 __end_ == __x.__end_ &&
6180 __pregex_ == __x.__pregex_ &&
6181 __flags_ == __x.__flags_ &&
6182 __match_[0] == __x.__match_[0];
6183}
6184
6185template <class _BidirectionalIterator, class _CharT, class _Traits>
6186regex_iterator<_BidirectionalIterator, _CharT, _Traits>&
6187regex_iterator<_BidirectionalIterator, _CharT, _Traits>::operator++()
6188{
6189 __flags_ |= regex_constants::__no_update_pos;
6190 _BidirectionalIterator __start = __match_[0].second;
Marshall Clowfaa964d2017-07-05 16:37:19 +00006191 if (__match_[0].first == __match_[0].second)
Howard Hinnantd3925342010-08-16 20:21:16 +00006192 {
6193 if (__start == __end_)
6194 {
6195 __match_ = value_type();
6196 return *this;
6197 }
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00006198 else if (_VSTD::regex_search(__start, __end_, __match_, *__pregex_,
Howard Hinnantd3925342010-08-16 20:21:16 +00006199 __flags_ | regex_constants::match_not_null |
6200 regex_constants::match_continuous))
6201 return *this;
6202 else
6203 ++__start;
6204 }
6205 __flags_ |= regex_constants::match_prev_avail;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00006206 if (!_VSTD::regex_search(__start, __end_, __match_, *__pregex_, __flags_))
Howard Hinnantd3925342010-08-16 20:21:16 +00006207 __match_ = value_type();
6208 return *this;
6209}
6210
6211typedef regex_iterator<const char*> cregex_iterator;
6212typedef regex_iterator<const wchar_t*> wcregex_iterator;
6213typedef regex_iterator<string::const_iterator> sregex_iterator;
6214typedef regex_iterator<wstring::const_iterator> wsregex_iterator;
6215
6216// regex_token_iterator
6217
6218template <class _BidirectionalIterator,
6219 class _CharT = typename iterator_traits<_BidirectionalIterator>::value_type,
6220 class _Traits = regex_traits<_CharT> >
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +00006221class _LIBCPP_TEMPLATE_VIS regex_token_iterator
Howard Hinnantd3925342010-08-16 20:21:16 +00006222{
6223public:
6224 typedef basic_regex<_CharT, _Traits> regex_type;
6225 typedef sub_match<_BidirectionalIterator> value_type;
6226 typedef ptrdiff_t difference_type;
6227 typedef const value_type* pointer;
6228 typedef const value_type& reference;
6229 typedef forward_iterator_tag iterator_category;
6230
Howard Hinnant63c9ce62010-08-17 20:42:03 +00006231private:
6232 typedef regex_iterator<_BidirectionalIterator, _CharT, _Traits> _Position;
6233
6234 _Position __position_;
6235 const value_type* __result_;
6236 value_type __suffix_;
Eric Fiselier37c22152016-12-24 00:24:44 +00006237 ptrdiff_t __n_;
Howard Hinnant63c9ce62010-08-17 20:42:03 +00006238 vector<int> __subs_;
6239
6240public:
Howard Hinnantd3925342010-08-16 20:21:16 +00006241 regex_token_iterator();
6242 regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
6243 const regex_type& __re, int __submatch = 0,
Howard Hinnant63c9ce62010-08-17 20:42:03 +00006244 regex_constants::match_flag_type __m =
6245 regex_constants::match_default);
Marshall Clow8c950072014-02-19 21:21:11 +00006246#if _LIBCPP_STD_VER > 11
6247 regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
6248 const regex_type&& __re, int __submatch = 0,
6249 regex_constants::match_flag_type __m =
6250 regex_constants::match_default) = delete;
6251#endif
6252
Howard Hinnantd3925342010-08-16 20:21:16 +00006253 regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
6254 const regex_type& __re, const vector<int>& __submatches,
Howard Hinnant63c9ce62010-08-17 20:42:03 +00006255 regex_constants::match_flag_type __m =
6256 regex_constants::match_default);
Marshall Clow8c950072014-02-19 21:21:11 +00006257#if _LIBCPP_STD_VER > 11
6258 regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
6259 const regex_type&& __re, const vector<int>& __submatches,
6260 regex_constants::match_flag_type __m =
6261 regex_constants::match_default) = delete;
6262#endif
6263
Eric Fiselier6f8516f2017-04-18 23:42:15 +00006264#ifndef _LIBCPP_CXX03_LANG
Howard Hinnantd3925342010-08-16 20:21:16 +00006265 regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
Howard Hinnant63c9ce62010-08-17 20:42:03 +00006266 const regex_type& __re,
6267 initializer_list<int> __submatches,
6268 regex_constants::match_flag_type __m =
6269 regex_constants::match_default);
Marshall Clow8c950072014-02-19 21:21:11 +00006270
6271#if _LIBCPP_STD_VER > 11
6272 regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
6273 const regex_type&& __re,
6274 initializer_list<int> __submatches,
6275 regex_constants::match_flag_type __m =
6276 regex_constants::match_default) = delete;
6277#endif
Eric Fiselier6f8516f2017-04-18 23:42:15 +00006278#endif // _LIBCPP_CXX03_LANG
Howard Hinnantc834c512011-11-29 18:15:50 +00006279 template <size_t _Np>
Howard Hinnant63c9ce62010-08-17 20:42:03 +00006280 regex_token_iterator(_BidirectionalIterator __a,
6281 _BidirectionalIterator __b,
6282 const regex_type& __re,
Howard Hinnantc834c512011-11-29 18:15:50 +00006283 const int (&__submatches)[_Np],
Howard Hinnant63c9ce62010-08-17 20:42:03 +00006284 regex_constants::match_flag_type __m =
6285 regex_constants::match_default);
Marshall Clow8c950072014-02-19 21:21:11 +00006286#if _LIBCPP_STD_VER > 11
6287 template <std::size_t _Np>
6288 regex_token_iterator(_BidirectionalIterator __a,
6289 _BidirectionalIterator __b,
6290 const regex_type&& __re,
6291 const int (&__submatches)[_Np],
6292 regex_constants::match_flag_type __m =
6293 regex_constants::match_default) = delete;
6294#endif
6295
Howard Hinnantd3925342010-08-16 20:21:16 +00006296 regex_token_iterator(const regex_token_iterator&);
6297 regex_token_iterator& operator=(const regex_token_iterator&);
6298
Howard Hinnant63c9ce62010-08-17 20:42:03 +00006299 bool operator==(const regex_token_iterator& __x) const;
Howard Hinnant7ca9d942010-09-23 15:13:20 +00006300 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant63c9ce62010-08-17 20:42:03 +00006301 bool operator!=(const regex_token_iterator& __x) const {return !(*this == __x);}
Howard Hinnantd3925342010-08-16 20:21:16 +00006302
Howard Hinnant7ca9d942010-09-23 15:13:20 +00006303 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant63c9ce62010-08-17 20:42:03 +00006304 const value_type& operator*() const {return *__result_;}
Howard Hinnant7ca9d942010-09-23 15:13:20 +00006305 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant63c9ce62010-08-17 20:42:03 +00006306 const value_type* operator->() const {return __result_;}
Howard Hinnantd3925342010-08-16 20:21:16 +00006307
6308 regex_token_iterator& operator++();
Howard Hinnant7ca9d942010-09-23 15:13:20 +00006309 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant63c9ce62010-08-17 20:42:03 +00006310 regex_token_iterator operator++(int)
6311 {
6312 regex_token_iterator __t(*this);
6313 ++(*this);
6314 return __t;
6315 }
6316
6317private:
6318 void __init(_BidirectionalIterator __a, _BidirectionalIterator __b);
Marshall Clow68083022014-01-09 18:25:57 +00006319 void __establish_result () {
Eric Fiselier37c22152016-12-24 00:24:44 +00006320 if (__subs_[__n_] == -1)
Marshall Clow68083022014-01-09 18:25:57 +00006321 __result_ = &__position_->prefix();
6322 else
Eric Fiselier37c22152016-12-24 00:24:44 +00006323 __result_ = &(*__position_)[__subs_[__n_]];
Marshall Clow68083022014-01-09 18:25:57 +00006324 }
Howard Hinnantd3925342010-08-16 20:21:16 +00006325};
6326
Howard Hinnant63c9ce62010-08-17 20:42:03 +00006327template <class _BidirectionalIterator, class _CharT, class _Traits>
6328regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
6329 regex_token_iterator()
6330 : __result_(nullptr),
6331 __suffix_(),
Eric Fiselier37c22152016-12-24 00:24:44 +00006332 __n_(0)
Howard Hinnant63c9ce62010-08-17 20:42:03 +00006333{
6334}
6335
6336template <class _BidirectionalIterator, class _CharT, class _Traits>
6337void
6338regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
6339 __init(_BidirectionalIterator __a, _BidirectionalIterator __b)
6340{
6341 if (__position_ != _Position())
Marshall Clow68083022014-01-09 18:25:57 +00006342 __establish_result ();
Eric Fiselier37c22152016-12-24 00:24:44 +00006343 else if (__subs_[__n_] == -1)
Howard Hinnant63c9ce62010-08-17 20:42:03 +00006344 {
6345 __suffix_.matched = true;
6346 __suffix_.first = __a;
6347 __suffix_.second = __b;
6348 __result_ = &__suffix_;
6349 }
6350 else
6351 __result_ = nullptr;
6352}
6353
6354template <class _BidirectionalIterator, class _CharT, class _Traits>
6355regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
6356 regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
6357 const regex_type& __re, int __submatch,
6358 regex_constants::match_flag_type __m)
6359 : __position_(__a, __b, __re, __m),
Eric Fiselier37c22152016-12-24 00:24:44 +00006360 __n_(0),
Howard Hinnant63c9ce62010-08-17 20:42:03 +00006361 __subs_(1, __submatch)
6362{
6363 __init(__a, __b);
6364}
6365
6366template <class _BidirectionalIterator, class _CharT, class _Traits>
6367regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
6368 regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
6369 const regex_type& __re, const vector<int>& __submatches,
6370 regex_constants::match_flag_type __m)
6371 : __position_(__a, __b, __re, __m),
Eric Fiselier37c22152016-12-24 00:24:44 +00006372 __n_(0),
Howard Hinnant63c9ce62010-08-17 20:42:03 +00006373 __subs_(__submatches)
6374{
6375 __init(__a, __b);
6376}
6377
Eric Fiselier6f8516f2017-04-18 23:42:15 +00006378#ifndef _LIBCPP_CXX03_LANG
Howard Hinnant33711792011-08-12 21:56:02 +00006379
Howard Hinnant63c9ce62010-08-17 20:42:03 +00006380template <class _BidirectionalIterator, class _CharT, class _Traits>
6381regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
6382 regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
6383 const regex_type& __re,
6384 initializer_list<int> __submatches,
6385 regex_constants::match_flag_type __m)
6386 : __position_(__a, __b, __re, __m),
Eric Fiselier37c22152016-12-24 00:24:44 +00006387 __n_(0),
Howard Hinnant63c9ce62010-08-17 20:42:03 +00006388 __subs_(__submatches)
6389{
6390 __init(__a, __b);
6391}
6392
Eric Fiselier6f8516f2017-04-18 23:42:15 +00006393#endif // _LIBCPP_CXX03_LANG
Howard Hinnant33711792011-08-12 21:56:02 +00006394
Howard Hinnant63c9ce62010-08-17 20:42:03 +00006395template <class _BidirectionalIterator, class _CharT, class _Traits>
Howard Hinnantc834c512011-11-29 18:15:50 +00006396template <size_t _Np>
Howard Hinnant63c9ce62010-08-17 20:42:03 +00006397regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
6398 regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
6399 const regex_type& __re,
Howard Hinnantc834c512011-11-29 18:15:50 +00006400 const int (&__submatches)[_Np],
Howard Hinnant63c9ce62010-08-17 20:42:03 +00006401 regex_constants::match_flag_type __m)
6402 : __position_(__a, __b, __re, __m),
Eric Fiselier37c22152016-12-24 00:24:44 +00006403 __n_(0),
Howard Hinnantc834c512011-11-29 18:15:50 +00006404 __subs_(__submatches, __submatches + _Np)
Howard Hinnant63c9ce62010-08-17 20:42:03 +00006405{
6406 __init(__a, __b);
6407}
6408
6409template <class _BidirectionalIterator, class _CharT, class _Traits>
6410regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
6411 regex_token_iterator(const regex_token_iterator& __x)
6412 : __position_(__x.__position_),
6413 __result_(__x.__result_),
6414 __suffix_(__x.__suffix_),
Eric Fiselier37c22152016-12-24 00:24:44 +00006415 __n_(__x.__n_),
Howard Hinnant63c9ce62010-08-17 20:42:03 +00006416 __subs_(__x.__subs_)
6417{
6418 if (__x.__result_ == &__x.__suffix_)
Marshall Clow20756ac2014-01-13 17:47:08 +00006419 __result_ = &__suffix_;
Marshall Clow68083022014-01-09 18:25:57 +00006420 else if ( __result_ != nullptr )
6421 __establish_result ();
Howard Hinnant63c9ce62010-08-17 20:42:03 +00006422}
6423
6424template <class _BidirectionalIterator, class _CharT, class _Traits>
6425regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>&
6426regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
6427 operator=(const regex_token_iterator& __x)
6428{
6429 if (this != &__x)
6430 {
6431 __position_ = __x.__position_;
6432 if (__x.__result_ == &__x.__suffix_)
Marshall Clow68083022014-01-09 18:25:57 +00006433 __result_ = &__suffix_;
Howard Hinnant63c9ce62010-08-17 20:42:03 +00006434 else
6435 __result_ = __x.__result_;
6436 __suffix_ = __x.__suffix_;
Eric Fiselier37c22152016-12-24 00:24:44 +00006437 __n_ = __x.__n_;
Howard Hinnant63c9ce62010-08-17 20:42:03 +00006438 __subs_ = __x.__subs_;
Marshall Clow68083022014-01-09 18:25:57 +00006439
6440 if ( __result_ != nullptr && __result_ != &__suffix_ )
6441 __establish_result();
Howard Hinnant63c9ce62010-08-17 20:42:03 +00006442 }
6443 return *this;
6444}
6445
6446template <class _BidirectionalIterator, class _CharT, class _Traits>
6447bool
6448regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
6449 operator==(const regex_token_iterator& __x) const
6450{
6451 if (__result_ == nullptr && __x.__result_ == nullptr)
6452 return true;
6453 if (__result_ == &__suffix_ && __x.__result_ == &__x.__suffix_ &&
6454 __suffix_ == __x.__suffix_)
6455 return true;
6456 if (__result_ == nullptr || __x.__result_ == nullptr)
6457 return false;
6458 if (__result_ == &__suffix_ || __x.__result_ == &__x.__suffix_)
6459 return false;
Eric Fiselier37c22152016-12-24 00:24:44 +00006460 return __position_ == __x.__position_ && __n_ == __x.__n_ &&
Howard Hinnant63c9ce62010-08-17 20:42:03 +00006461 __subs_ == __x.__subs_;
6462}
6463
6464template <class _BidirectionalIterator, class _CharT, class _Traits>
6465regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>&
6466regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::operator++()
6467{
6468 _Position __prev = __position_;
6469 if (__result_ == &__suffix_)
6470 __result_ = nullptr;
Eric Fiselier37c22152016-12-24 00:24:44 +00006471 else if (static_cast<size_t>(__n_ + 1) < __subs_.size())
Howard Hinnant63c9ce62010-08-17 20:42:03 +00006472 {
Eric Fiselier37c22152016-12-24 00:24:44 +00006473 ++__n_;
Marshall Clow68083022014-01-09 18:25:57 +00006474 __establish_result();
Howard Hinnant63c9ce62010-08-17 20:42:03 +00006475 }
6476 else
6477 {
Eric Fiselier37c22152016-12-24 00:24:44 +00006478 __n_ = 0;
Howard Hinnant63c9ce62010-08-17 20:42:03 +00006479 ++__position_;
6480 if (__position_ != _Position())
Marshall Clow68083022014-01-09 18:25:57 +00006481 __establish_result();
Howard Hinnant63c9ce62010-08-17 20:42:03 +00006482 else
6483 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00006484 if (_VSTD::find(__subs_.begin(), __subs_.end(), -1) != __subs_.end()
Howard Hinnant63c9ce62010-08-17 20:42:03 +00006485 && __prev->suffix().length() != 0)
6486 {
6487 __suffix_.matched = true;
6488 __suffix_.first = __prev->suffix().first;
6489 __suffix_.second = __prev->suffix().second;
6490 __result_ = &__suffix_;
6491 }
6492 else
6493 __result_ = nullptr;
6494 }
6495 }
6496 return *this;
6497}
6498
Howard Hinnantd3925342010-08-16 20:21:16 +00006499typedef regex_token_iterator<const char*> cregex_token_iterator;
6500typedef regex_token_iterator<const wchar_t*> wcregex_token_iterator;
6501typedef regex_token_iterator<string::const_iterator> sregex_token_iterator;
6502typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;
6503
Howard Hinnante90434c2010-08-18 00:13:08 +00006504// regex_replace
6505
6506template <class _OutputIterator, class _BidirectionalIterator,
6507 class _Traits, class _CharT>
6508_OutputIterator
Alexander Richardsonc9637642017-11-14 11:14:25 +00006509regex_replace(_OutputIterator __output_iter,
Howard Hinnante90434c2010-08-18 00:13:08 +00006510 _BidirectionalIterator __first, _BidirectionalIterator __last,
6511 const basic_regex<_CharT, _Traits>& __e, const _CharT* __fmt,
6512 regex_constants::match_flag_type __flags = regex_constants::match_default)
6513{
6514 typedef regex_iterator<_BidirectionalIterator, _CharT, _Traits> _Iter;
6515 _Iter __i(__first, __last, __e, __flags);
6516 _Iter __eof;
6517 if (__i == __eof)
6518 {
6519 if (!(__flags & regex_constants::format_no_copy))
Alexander Richardsonc9637642017-11-14 11:14:25 +00006520 __output_iter = _VSTD::copy(__first, __last, __output_iter);
Howard Hinnante90434c2010-08-18 00:13:08 +00006521 }
6522 else
6523 {
6524 sub_match<_BidirectionalIterator> __lm;
6525 for (size_t __len = char_traits<_CharT>::length(__fmt); __i != __eof; ++__i)
6526 {
6527 if (!(__flags & regex_constants::format_no_copy))
Alexander Richardsonc9637642017-11-14 11:14:25 +00006528 __output_iter = _VSTD::copy(__i->prefix().first, __i->prefix().second, __output_iter);
6529 __output_iter = __i->format(__output_iter, __fmt, __fmt + __len, __flags);
Howard Hinnante90434c2010-08-18 00:13:08 +00006530 __lm = __i->suffix();
6531 if (__flags & regex_constants::format_first_only)
6532 break;
6533 }
6534 if (!(__flags & regex_constants::format_no_copy))
Alexander Richardsonc9637642017-11-14 11:14:25 +00006535 __output_iter = _VSTD::copy(__lm.first, __lm.second, __output_iter);
Howard Hinnante90434c2010-08-18 00:13:08 +00006536 }
Alexander Richardsonc9637642017-11-14 11:14:25 +00006537 return __output_iter;
Howard Hinnante90434c2010-08-18 00:13:08 +00006538}
6539
6540template <class _OutputIterator, class _BidirectionalIterator,
6541 class _Traits, class _CharT, class _ST, class _SA>
6542inline _LIBCPP_INLINE_VISIBILITY
6543_OutputIterator
Alexander Richardsonc9637642017-11-14 11:14:25 +00006544regex_replace(_OutputIterator __output_iter,
Howard Hinnante90434c2010-08-18 00:13:08 +00006545 _BidirectionalIterator __first, _BidirectionalIterator __last,
6546 const basic_regex<_CharT, _Traits>& __e,
6547 const basic_string<_CharT, _ST, _SA>& __fmt,
6548 regex_constants::match_flag_type __flags = regex_constants::match_default)
6549{
Alexander Richardsonc9637642017-11-14 11:14:25 +00006550 return _VSTD::regex_replace(__output_iter, __first, __last, __e, __fmt.c_str(), __flags);
Howard Hinnante90434c2010-08-18 00:13:08 +00006551}
6552
6553template <class _Traits, class _CharT, class _ST, class _SA, class _FST,
6554 class _FSA>
6555inline _LIBCPP_INLINE_VISIBILITY
6556basic_string<_CharT, _ST, _SA>
6557regex_replace(const basic_string<_CharT, _ST, _SA>& __s,
6558 const basic_regex<_CharT, _Traits>& __e,
6559 const basic_string<_CharT, _FST, _FSA>& __fmt,
6560 regex_constants::match_flag_type __flags = regex_constants::match_default)
6561{
6562 basic_string<_CharT, _ST, _SA> __r;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00006563 _VSTD::regex_replace(back_inserter(__r), __s.begin(), __s.end(), __e,
Howard Hinnante90434c2010-08-18 00:13:08 +00006564 __fmt.c_str(), __flags);
6565 return __r;
6566}
6567
6568template <class _Traits, class _CharT, class _ST, class _SA>
6569inline _LIBCPP_INLINE_VISIBILITY
6570basic_string<_CharT, _ST, _SA>
6571regex_replace(const basic_string<_CharT, _ST, _SA>& __s,
6572 const basic_regex<_CharT, _Traits>& __e, const _CharT* __fmt,
6573 regex_constants::match_flag_type __flags = regex_constants::match_default)
6574{
6575 basic_string<_CharT, _ST, _SA> __r;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00006576 _VSTD::regex_replace(back_inserter(__r), __s.begin(), __s.end(), __e,
Howard Hinnante90434c2010-08-18 00:13:08 +00006577 __fmt, __flags);
6578 return __r;
6579}
6580
6581template <class _Traits, class _CharT, class _ST, class _SA>
6582inline _LIBCPP_INLINE_VISIBILITY
6583basic_string<_CharT>
6584regex_replace(const _CharT* __s,
6585 const basic_regex<_CharT, _Traits>& __e,
6586 const basic_string<_CharT, _ST, _SA>& __fmt,
6587 regex_constants::match_flag_type __flags = regex_constants::match_default)
6588{
6589 basic_string<_CharT> __r;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00006590 _VSTD::regex_replace(back_inserter(__r), __s,
Howard Hinnante90434c2010-08-18 00:13:08 +00006591 __s + char_traits<_CharT>::length(__s), __e,
6592 __fmt.c_str(), __flags);
6593 return __r;
6594}
6595
6596template <class _Traits, class _CharT>
6597inline _LIBCPP_INLINE_VISIBILITY
6598basic_string<_CharT>
6599regex_replace(const _CharT* __s,
6600 const basic_regex<_CharT, _Traits>& __e,
6601 const _CharT* __fmt,
6602 regex_constants::match_flag_type __flags = regex_constants::match_default)
6603{
6604 basic_string<_CharT> __r;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00006605 _VSTD::regex_replace(back_inserter(__r), __s,
Howard Hinnante90434c2010-08-18 00:13:08 +00006606 __s + char_traits<_CharT>::length(__s), __e,
6607 __fmt, __flags);
6608 return __r;
6609}
6610
Howard Hinnanta3af5a32010-06-17 00:34:59 +00006611_LIBCPP_END_NAMESPACE_STD
6612
Eric Fiselierf4433a32017-05-31 22:07:49 +00006613_LIBCPP_POP_MACROS
6614
Howard Hinnanta3af5a32010-06-17 00:34:59 +00006615#endif // _LIBCPP_REGEX