1// class template regex -*- C++ -*-
2
3// Copyright (C) 2010-2018 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library. This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.
10
11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14// GNU General Public License for more details.
15
16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.
19
20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23// <http://www.gnu.org/licenses/>.
24
25/**
26 * @file bits/regex.h
27 * This is an internal header file, included by other library headers.
28 * Do not attempt to use it directly. @headername{regex}
29 */
30
31namespace std _GLIBCXX_VISIBILITY(default)
32{
33_GLIBCXX_BEGIN_NAMESPACE_VERSION
34_GLIBCXX_BEGIN_NAMESPACE_CXX11
35 template<typename, typename>
36 class basic_regex;
37
38 template<typename, typename>
39 class match_results;
40
41_GLIBCXX_END_NAMESPACE_CXX11
42
43namespace __detail
44{
45 enum class _RegexExecutorPolicy : int
46 { _S_auto, _S_alternate };
47
48 template<typename _BiIter, typename _Alloc,
49 typename _CharT, typename _TraitsT,
50 _RegexExecutorPolicy __policy,
51 bool __match_mode>
52 bool
53 __regex_algo_impl(_BiIter __s,
54 _BiIter __e,
55 match_results<_BiIter, _Alloc>& __m,
56 const basic_regex<_CharT, _TraitsT>& __re,
57 regex_constants::match_flag_type __flags);
58
59 template<typename, typename, typename, bool>
60 class _Executor;
61}
62
63_GLIBCXX_BEGIN_NAMESPACE_CXX11
64
65 /**
66 * @addtogroup regex
67 * @{
68 */
69
70 /**
71 * @brief Describes aspects of a regular expression.
72 *
73 * A regular expression traits class that satisfies the requirements of
74 * section [28.7].
75 *
76 * The class %regex is parameterized around a set of related types and
77 * functions used to complete the definition of its semantics. This class
78 * satisfies the requirements of such a traits class.
79 */
80 template<typename _Ch_type>
81 struct regex_traits
82 {
83 public:
84 typedef _Ch_type char_type;
85 typedef std::basic_string<char_type> string_type;
86 typedef std::locale locale_type;
87 private:
88 struct _RegexMask
89 {
90 typedef std::ctype_base::mask _BaseType;
91 _BaseType _M_base;
92 unsigned char _M_extended;
93 static constexpr unsigned char _S_under = 1 << 0;
94 static constexpr unsigned char _S_valid_mask = 0x1;
95
96 constexpr _RegexMask(_BaseType __base = 0,
97 unsigned char __extended = 0)
98 : _M_base(__base), _M_extended(__extended)
99 { }
100
101 constexpr _RegexMask
102 operator&(_RegexMask __other) const
103 {
104 return _RegexMask(_M_base & __other._M_base,
105 _M_extended & __other._M_extended);
106 }
107
108 constexpr _RegexMask
109 operator|(_RegexMask __other) const
110 {
111 return _RegexMask(_M_base | __other._M_base,
112 _M_extended | __other._M_extended);
113 }
114
115 constexpr _RegexMask
116 operator^(_RegexMask __other) const
117 {
118 return _RegexMask(_M_base ^ __other._M_base,
119 _M_extended ^ __other._M_extended);
120 }
121
122 constexpr _RegexMask
123 operator~() const
124 { return _RegexMask(~_M_base, ~_M_extended); }
125
126 _RegexMask&
127 operator&=(_RegexMask __other)
128 { return *this = (*this) & __other; }
129
130 _RegexMask&
131 operator|=(_RegexMask __other)
132 { return *this = (*this) | __other; }
133
134 _RegexMask&
135 operator^=(_RegexMask __other)
136 { return *this = (*this) ^ __other; }
137
138 constexpr bool
139 operator==(_RegexMask __other) const
140 {
141 return (_M_extended & _S_valid_mask)
142 == (__other._M_extended & _S_valid_mask)
143 && _M_base == __other._M_base;
144 }
145
146 constexpr bool
147 operator!=(_RegexMask __other) const
148 { return !((*this) == __other); }
149
150 };
151 public:
152 typedef _RegexMask char_class_type;
153
154 public:
155 /**
156 * @brief Constructs a default traits object.
157 */
158 regex_traits() { }
159
160 /**
161 * @brief Gives the length of a C-style string starting at @p __p.
162 *
163 * @param __p a pointer to the start of a character sequence.
164 *
165 * @returns the number of characters between @p *__p and the first
166 * default-initialized value of type @p char_type. In other words, uses
167 * the C-string algorithm for determining the length of a sequence of
168 * characters.
169 */
170 static std::size_t
171 length(const char_type* __p)
172 { return string_type::traits_type::length(__p); }
173
174 /**
175 * @brief Performs the identity translation.
176 *
177 * @param __c A character to the locale-specific character set.
178 *
179 * @returns __c.
180 */
181 char_type
182 translate(char_type __c) const
183 { return __c; }
184
185 /**
186 * @brief Translates a character into a case-insensitive equivalent.
187 *
188 * @param __c A character to the locale-specific character set.
189 *
190 * @returns the locale-specific lower-case equivalent of __c.
191 * @throws std::bad_cast if the imbued locale does not support the ctype
192 * facet.
193 */
194 char_type
195 translate_nocase(char_type __c) const
196 {
197 typedef std::ctype<char_type> __ctype_type;
198 const __ctype_type& __fctyp(use_facet<__ctype_type>(_M_locale));
199 return __fctyp.tolower(__c);
200 }
201
202 /**
203 * @brief Gets a sort key for a character sequence.
204 *
205 * @param __first beginning of the character sequence.
206 * @param __last one-past-the-end of the character sequence.
207 *
208 * Returns a sort key for the character sequence designated by the
209 * iterator range [F1, F2) such that if the character sequence [G1, G2)
210 * sorts before the character sequence [H1, H2) then
211 * v.transform(G1, G2) < v.transform(H1, H2).
212 *
213 * What this really does is provide a more efficient way to compare a
214 * string to multiple other strings in locales with fancy collation
215 * rules and equivalence classes.
216 *
217 * @returns a locale-specific sort key equivalent to the input range.
218 *
219 * @throws std::bad_cast if the current locale does not have a collate
220 * facet.
221 */
222 template<typename _Fwd_iter>
223 string_type
224 transform(_Fwd_iter __first, _Fwd_iter __last) const
225 {
226 typedef std::collate<char_type> __collate_type;
227 const __collate_type& __fclt(use_facet<__collate_type>(_M_locale));
228 string_type __s(__first, __last);
229 return __fclt.transform(__s.data(), __s.data() + __s.size());
230 }
231
232 /**
233 * @brief Gets a sort key for a character sequence, independent of case.
234 *
235 * @param __first beginning of the character sequence.
236 * @param __last one-past-the-end of the character sequence.
237 *
238 * Effects: if typeid(use_facet<collate<_Ch_type> >) ==
239 * typeid(collate_byname<_Ch_type>) and the form of the sort key
240 * returned by collate_byname<_Ch_type>::transform(__first, __last)
241 * is known and can be converted into a primary sort key
242 * then returns that key, otherwise returns an empty string.
243 *
244 * @todo Implement this function correctly.
245 */
246 template<typename _Fwd_iter>
247 string_type
248 transform_primary(_Fwd_iter __first, _Fwd_iter __last) const
249 {
250 // TODO : this is not entirely correct.
251 // This function requires extra support from the platform.
252 //
253 // Read http://gcc.gnu.org/ml/libstdc++/2013-09/msg00117.html and
254 // http://www.open-std.org/Jtc1/sc22/wg21/docs/papers/2003/n1429.htm
255 // for details.
256 typedef std::ctype<char_type> __ctype_type;
257 const __ctype_type& __fctyp(use_facet<__ctype_type>(_M_locale));
258 std::vector<char_type> __s(__first, __last);
259 __fctyp.tolower(__s.data(), __s.data() + __s.size());
260 return this->transform(__s.data(), __s.data() + __s.size());
261 }
262
263 /**
264 * @brief Gets a collation element by name.
265 *
266 * @param __first beginning of the collation element name.
267 * @param __last one-past-the-end of the collation element name.
268 *
269 * @returns a sequence of one or more characters that represents the
270 * collating element consisting of the character sequence designated by
271 * the iterator range [__first, __last). Returns an empty string if the
272 * character sequence is not a valid collating element.
273 */
274 template<typename _Fwd_iter>
275 string_type
276 lookup_collatename(_Fwd_iter __first, _Fwd_iter __last) const;
277
278 /**
279 * @brief Maps one or more characters to a named character
280 * classification.
281 *
282 * @param __first beginning of the character sequence.
283 * @param __last one-past-the-end of the character sequence.
284 * @param __icase ignores the case of the classification name.
285 *
286 * @returns an unspecified value that represents the character
287 * classification named by the character sequence designated by
288 * the iterator range [__first, __last). If @p icase is true,
289 * the returned mask identifies the classification regardless of
290 * the case of the characters to be matched (for example,
291 * [[:lower:]] is the same as [[:alpha:]]), otherwise a
292 * case-dependent classification is returned. The value
293 * returned shall be independent of the case of the characters
294 * in the character sequence. If the name is not recognized then
295 * returns a value that compares equal to 0.
296 *
297 * At least the following names (or their wide-character equivalent) are
298 * supported.
299 * - d
300 * - w
301 * - s
302 * - alnum
303 * - alpha
304 * - blank
305 * - cntrl
306 * - digit
307 * - graph
308 * - lower
309 * - print
310 * - punct
311 * - space
312 * - upper
313 * - xdigit
314 */
315 template<typename _Fwd_iter>
316 char_class_type
317 lookup_classname(_Fwd_iter __first, _Fwd_iter __last,
318 bool __icase = false) const;
319
320 /**
321 * @brief Determines if @p c is a member of an identified class.
322 *
323 * @param __c a character.
324 * @param __f a class type (as returned from lookup_classname).
325 *
326 * @returns true if the character @p __c is a member of the classification
327 * represented by @p __f, false otherwise.
328 *
329 * @throws std::bad_cast if the current locale does not have a ctype
330 * facet.
331 */
332 bool
333 isctype(_Ch_type __c, char_class_type __f) const;
334
335 /**
336 * @brief Converts a digit to an int.
337 *
338 * @param __ch a character representing a digit.
339 * @param __radix the radix if the numeric conversion (limited to 8, 10,
340 * or 16).
341 *
342 * @returns the value represented by the digit __ch in base radix if the
343 * character __ch is a valid digit in base radix; otherwise returns -1.
344 */
345 int
346 value(_Ch_type __ch, int __radix) const;
347
348 /**
349 * @brief Imbues the regex_traits object with a copy of a new locale.
350 *
351 * @param __loc A locale.
352 *
353 * @returns a copy of the previous locale in use by the regex_traits
354 * object.
355 *
356 * @note Calling imbue with a different locale than the one currently in
357 * use invalidates all cached data held by *this.
358 */
359 locale_type
360 imbue(locale_type __loc)
361 {
362 std::swap(_M_locale, __loc);
363 return __loc;
364 }
365
366 /**
367 * @brief Gets a copy of the current locale in use by the regex_traits
368 * object.
369 */
370 locale_type
371 getloc() const
372 { return _M_locale; }
373
374 protected:
375 locale_type _M_locale;
376 };
377
378 // [7.8] Class basic_regex
379 /**
380 * Objects of specializations of this class represent regular expressions
381 * constructed from sequences of character type @p _Ch_type.
382 *
383 * Storage for the regular expression is allocated and deallocated as
384 * necessary by the member functions of this class.
385 */
386 template<typename _Ch_type, typename _Rx_traits = regex_traits<_Ch_type>>
387 class basic_regex
388 {
389 public:
390 static_assert(is_same<_Ch_type, typename _Rx_traits::char_type>::value,
391 "regex traits class must have the same char_type");
392
393 // types:
394 typedef _Ch_type value_type;
395 typedef _Rx_traits traits_type;
396 typedef typename traits_type::string_type string_type;
397 typedef regex_constants::syntax_option_type flag_type;
398 typedef typename traits_type::locale_type locale_type;
399
400 /**
401 * @name Constants
402 * std [28.8.1](1)
403 */
404 //@{
405 static constexpr flag_type icase = regex_constants::icase;
406 static constexpr flag_type nosubs = regex_constants::nosubs;
407 static constexpr flag_type optimize = regex_constants::optimize;
408 static constexpr flag_type collate = regex_constants::collate;
409 static constexpr flag_type ECMAScript = regex_constants::ECMAScript;
410 static constexpr flag_type basic = regex_constants::basic;
411 static constexpr flag_type extended = regex_constants::extended;
412 static constexpr flag_type awk = regex_constants::awk;
413 static constexpr flag_type grep = regex_constants::grep;
414 static constexpr flag_type egrep = regex_constants::egrep;
415 //@}
416
417 // [7.8.2] construct/copy/destroy
418 /**
419 * Constructs a basic regular expression that does not match any
420 * character sequence.
421 */
422 basic_regex()
423 : _M_flags(ECMAScript), _M_loc(), _M_automaton(nullptr)
424 { }
425
426 /**
427 * @brief Constructs a basic regular expression from the
428 * sequence [__p, __p + char_traits<_Ch_type>::length(__p))
429 * interpreted according to the flags in @p __f.
430 *
431 * @param __p A pointer to the start of a C-style null-terminated string
432 * containing a regular expression.
433 * @param __f Flags indicating the syntax rules and options.
434 *
435 * @throws regex_error if @p __p is not a valid regular expression.
436 */
437 explicit
438 basic_regex(const _Ch_type* __p, flag_type __f = ECMAScript)
439 : basic_regex(__p, __p + char_traits<_Ch_type>::length(__p), __f)
440 { }
441
442 /**
443 * @brief Constructs a basic regular expression from the sequence
444 * [p, p + len) interpreted according to the flags in @p f.
445 *
446 * @param __p A pointer to the start of a string containing a regular
447 * expression.
448 * @param __len The length of the string containing the regular
449 * expression.
450 * @param __f Flags indicating the syntax rules and options.
451 *
452 * @throws regex_error if @p __p is not a valid regular expression.
453 */
454 basic_regex(const _Ch_type* __p, std::size_t __len,
455 flag_type __f = ECMAScript)
456 : basic_regex(__p, __p + __len, __f)
457 { }
458
459 /**
460 * @brief Copy-constructs a basic regular expression.
461 *
462 * @param __rhs A @p regex object.
463 */
464 basic_regex(const basic_regex& __rhs) = default;
465
466 /**
467 * @brief Move-constructs a basic regular expression.
468 *
469 * @param __rhs A @p regex object.
470 */
471 basic_regex(basic_regex&& __rhs) noexcept = default;
472
473 /**
474 * @brief Constructs a basic regular expression from the string
475 * @p s interpreted according to the flags in @p f.
476 *
477 * @param __s A string containing a regular expression.
478 * @param __f Flags indicating the syntax rules and options.
479 *
480 * @throws regex_error if @p __s is not a valid regular expression.
481 */
482 template<typename _Ch_traits, typename _Ch_alloc>
483 explicit
484 basic_regex(const std::basic_string<_Ch_type, _Ch_traits,
485 _Ch_alloc>& __s,
486 flag_type __f = ECMAScript)
487 : basic_regex(__s.data(), __s.data() + __s.size(), __f)
488 { }
489
490 /**
491 * @brief Constructs a basic regular expression from the range
492 * [first, last) interpreted according to the flags in @p f.
493 *
494 * @param __first The start of a range containing a valid regular
495 * expression.
496 * @param __last The end of a range containing a valid regular
497 * expression.
498 * @param __f The format flags of the regular expression.
499 *
500 * @throws regex_error if @p [__first, __last) is not a valid regular
501 * expression.
502 */
503 template<typename _FwdIter>
504 basic_regex(_FwdIter __first, _FwdIter __last,
505 flag_type __f = ECMAScript)
506 : basic_regex(std::move(__first), std::move(__last), locale_type(), __f)
507 { }
508
509 /**
510 * @brief Constructs a basic regular expression from an initializer list.
511 *
512 * @param __l The initializer list.
513 * @param __f The format flags of the regular expression.
514 *
515 * @throws regex_error if @p __l is not a valid regular expression.
516 */
517 basic_regex(initializer_list<_Ch_type> __l, flag_type __f = ECMAScript)
518 : basic_regex(__l.begin(), __l.end(), __f)
519 { }
520
521 /**
522 * @brief Destroys a basic regular expression.
523 */
524 ~basic_regex()
525 { }
526
527 /**
528 * @brief Assigns one regular expression to another.
529 */
530 basic_regex&
531 operator=(const basic_regex& __rhs)
532 { return this->assign(__rhs); }
533
534 /**
535 * @brief Move-assigns one regular expression to another.
536 */
537 basic_regex&
538 operator=(basic_regex&& __rhs) noexcept
539 { return this->assign(std::move(__rhs)); }
540
541 /**
542 * @brief Replaces a regular expression with a new one constructed from
543 * a C-style null-terminated string.
544 *
545 * @param __p A pointer to the start of a null-terminated C-style string
546 * containing a regular expression.
547 */
548 basic_regex&
549 operator=(const _Ch_type* __p)
550 { return this->assign(__p); }
551
552 /**
553 * @brief Replaces a regular expression with a new one constructed from
554 * an initializer list.
555 *
556 * @param __l The initializer list.
557 *
558 * @throws regex_error if @p __l is not a valid regular expression.
559 */
560 basic_regex&
561 operator=(initializer_list<_Ch_type> __l)
562 { return this->assign(__l.begin(), __l.end()); }
563
564 /**
565 * @brief Replaces a regular expression with a new one constructed from
566 * a string.
567 *
568 * @param __s A pointer to a string containing a regular expression.
569 */
570 template<typename _Ch_traits, typename _Alloc>
571 basic_regex&
572 operator=(const basic_string<_Ch_type, _Ch_traits, _Alloc>& __s)
573 { return this->assign(__s); }
574
575 // [7.8.3] assign
576 /**
577 * @brief the real assignment operator.
578 *
579 * @param __rhs Another regular expression object.
580 */
581 basic_regex&
582 assign(const basic_regex& __rhs)
583 {
584 basic_regex __tmp(__rhs);
585 this->swap(__tmp);
586 return *this;
587 }
588
589 /**
590 * @brief The move-assignment operator.
591 *
592 * @param __rhs Another regular expression object.
593 */
594 basic_regex&
595 assign(basic_regex&& __rhs) noexcept
596 {
597 basic_regex __tmp(std::move(__rhs));
598 this->swap(__tmp);
599 return *this;
600 }
601
602 /**
603 * @brief Assigns a new regular expression to a regex object from a
604 * C-style null-terminated string containing a regular expression
605 * pattern.
606 *
607 * @param __p A pointer to a C-style null-terminated string containing
608 * a regular expression pattern.
609 * @param __flags Syntax option flags.
610 *
611 * @throws regex_error if __p does not contain a valid regular
612 * expression pattern interpreted according to @p __flags. If
613 * regex_error is thrown, *this remains unchanged.
614 */
615 basic_regex&
616 assign(const _Ch_type* __p, flag_type __flags = ECMAScript)
617 { return this->assign(string_type(__p), __flags); }
618
619 /**
620 * @brief Assigns a new regular expression to a regex object from a
621 * C-style string containing a regular expression pattern.
622 *
623 * @param __p A pointer to a C-style string containing a
624 * regular expression pattern.
625 * @param __len The length of the regular expression pattern string.
626 * @param __flags Syntax option flags.
627 *
628 * @throws regex_error if p does not contain a valid regular
629 * expression pattern interpreted according to @p __flags. If
630 * regex_error is thrown, *this remains unchanged.
631 */
632 basic_regex&
633 assign(const _Ch_type* __p, std::size_t __len, flag_type __flags)
634 { return this->assign(string_type(__p, __len), __flags); }
635
636 /**
637 * @brief Assigns a new regular expression to a regex object from a
638 * string containing a regular expression pattern.
639 *
640 * @param __s A string containing a regular expression pattern.
641 * @param __flags Syntax option flags.
642 *
643 * @throws regex_error if __s does not contain a valid regular
644 * expression pattern interpreted according to @p __flags. If
645 * regex_error is thrown, *this remains unchanged.
646 */
647 template<typename _Ch_traits, typename _Alloc>
648 basic_regex&
649 assign(const basic_string<_Ch_type, _Ch_traits, _Alloc>& __s,
650 flag_type __flags = ECMAScript)
651 {
652 return this->assign(basic_regex(__s.data(), __s.data() + __s.size(),
653 _M_loc, __flags));
654 }
655
656 /**
657 * @brief Assigns a new regular expression to a regex object.
658 *
659 * @param __first The start of a range containing a valid regular
660 * expression.
661 * @param __last The end of a range containing a valid regular
662 * expression.
663 * @param __flags Syntax option flags.
664 *
665 * @throws regex_error if p does not contain a valid regular
666 * expression pattern interpreted according to @p __flags. If
667 * regex_error is thrown, the object remains unchanged.
668 */
669 template<typename _InputIterator>
670 basic_regex&
671 assign(_InputIterator __first, _InputIterator __last,
672 flag_type __flags = ECMAScript)
673 { return this->assign(string_type(__first, __last), __flags); }
674
675 /**
676 * @brief Assigns a new regular expression to a regex object.
677 *
678 * @param __l An initializer list representing a regular expression.
679 * @param __flags Syntax option flags.
680 *
681 * @throws regex_error if @p __l does not contain a valid
682 * regular expression pattern interpreted according to @p
683 * __flags. If regex_error is thrown, the object remains
684 * unchanged.
685 */
686 basic_regex&
687 assign(initializer_list<_Ch_type> __l, flag_type __flags = ECMAScript)
688 { return this->assign(__l.begin(), __l.end(), __flags); }
689
690 // [7.8.4] const operations
691 /**
692 * @brief Gets the number of marked subexpressions within the regular
693 * expression.
694 */
695 unsigned int
696 mark_count() const
697 {
698 if (_M_automaton)
699 return _M_automaton->_M_sub_count() - 1;
700 return 0;
701 }
702
703 /**
704 * @brief Gets the flags used to construct the regular expression
705 * or in the last call to assign().
706 */
707 flag_type
708 flags() const
709 { return _M_flags; }
710
711 // [7.8.5] locale
712 /**
713 * @brief Imbues the regular expression object with the given locale.
714 *
715 * @param __loc A locale.
716 */
717 locale_type
718 imbue(locale_type __loc)
719 {
720 std::swap(__loc, _M_loc);
721 _M_automaton.reset();
722 return __loc;
723 }
724
725 /**
726 * @brief Gets the locale currently imbued in the regular expression
727 * object.
728 */
729 locale_type
730 getloc() const
731 { return _M_loc; }
732
733 // [7.8.6] swap
734 /**
735 * @brief Swaps the contents of two regular expression objects.
736 *
737 * @param __rhs Another regular expression object.
738 */
739 void
740 swap(basic_regex& __rhs)
741 {
742 std::swap(_M_flags, __rhs._M_flags);
743 std::swap(_M_loc, __rhs._M_loc);
744 std::swap(_M_automaton, __rhs._M_automaton);
745 }
746
747#ifdef _GLIBCXX_DEBUG
748 void
749 _M_dot(std::ostream& __ostr)
750 { _M_automaton->_M_dot(__ostr); }
751#endif
752
753 private:
754 typedef std::shared_ptr<const __detail::_NFA<_Rx_traits>> _AutomatonPtr;
755
756 template<typename _FwdIter>
757 basic_regex(_FwdIter __first, _FwdIter __last, locale_type __loc,
758 flag_type __f)
759 : _M_flags(__f), _M_loc(std::move(__loc)),
760 _M_automaton(__detail::__compile_nfa<_Rx_traits>(
761 std::move(__first), std::move(__last), _M_loc, _M_flags))
762 { }
763
764 template<typename _Bp, typename _Ap, typename _Cp, typename _Rp,
765 __detail::_RegexExecutorPolicy, bool>
766 friend bool
767 __detail::__regex_algo_impl(_Bp, _Bp, match_results<_Bp, _Ap>&,
768 const basic_regex<_Cp, _Rp>&,
769 regex_constants::match_flag_type);
770
771 template<typename, typename, typename, bool>
772 friend class __detail::_Executor;
773
774 flag_type _M_flags;
775 locale_type _M_loc;
776 _AutomatonPtr _M_automaton;
777 };
778
779#if __cpp_deduction_guides >= 201606
780 template<typename _ForwardIterator>
781 basic_regex(_ForwardIterator, _ForwardIterator,
782 regex_constants::syntax_option_type = {})
783 -> basic_regex<typename iterator_traits<_ForwardIterator>::value_type>;
784#endif
785
786 /** @brief Standard regular expressions. */
787 typedef basic_regex<char> regex;
788
789#ifdef _GLIBCXX_USE_WCHAR_T
790 /** @brief Standard wide-character regular expressions. */
791 typedef basic_regex<wchar_t> wregex;
792#endif
793
794
795 // [7.8.6] basic_regex swap
796 /**
797 * @brief Swaps the contents of two regular expression objects.
798 * @param __lhs First regular expression.
799 * @param __rhs Second regular expression.
800 */
801 template<typename _Ch_type, typename _Rx_traits>
802 inline void
803 swap(basic_regex<_Ch_type, _Rx_traits>& __lhs,
804 basic_regex<_Ch_type, _Rx_traits>& __rhs)
805 { __lhs.swap(__rhs); }
806
807
808 // [7.9] Class template sub_match
809 /**
810 * A sequence of characters matched by a particular marked sub-expression.
811 *
812 * An object of this class is essentially a pair of iterators marking a
813 * matched subexpression within a regular expression pattern match. Such
814 * objects can be converted to and compared with std::basic_string objects
815 * of a similar base character type as the pattern matched by the regular
816 * expression.
817 *
818 * The iterators that make up the pair are the usual half-open interval
819 * referencing the actual original pattern matched.
820 */
821 template<typename _BiIter>
822 class sub_match : public std::pair<_BiIter, _BiIter>
823 {
824 typedef iterator_traits<_BiIter> __iter_traits;
825
826 public:
827 typedef typename __iter_traits::value_type value_type;
828 typedef typename __iter_traits::difference_type difference_type;
829 typedef _BiIter iterator;
830 typedef std::basic_string<value_type> string_type;
831
832 bool matched;
833
834 constexpr sub_match() : matched() { }
835
836 /**
837 * Gets the length of the matching sequence.
838 */
839 difference_type
840 length() const
841 { return this->matched ? std::distance(this->first, this->second) : 0; }
842
843 /**
844 * @brief Gets the matching sequence as a string.
845 *
846 * @returns the matching sequence as a string.
847 *
848 * This is the implicit conversion operator. It is identical to the
849 * str() member function except that it will want to pop up in
850 * unexpected places and cause a great deal of confusion and cursing
851 * from the unwary.
852 */
853 operator string_type() const
854 {
855 return this->matched
856 ? string_type(this->first, this->second)
857 : string_type();
858 }
859
860 /**
861 * @brief Gets the matching sequence as a string.
862 *
863 * @returns the matching sequence as a string.
864 */
865 string_type
866 str() const
867 {
868 return this->matched
869 ? string_type(this->first, this->second)
870 : string_type();
871 }
872
873 /**
874 * @brief Compares this and another matched sequence.
875 *
876 * @param __s Another matched sequence to compare to this one.
877 *
878 * @retval <0 this matched sequence will collate before @p __s.
879 * @retval =0 this matched sequence is equivalent to @p __s.
880 * @retval <0 this matched sequence will collate after @p __s.
881 */
882 int
883 compare(const sub_match& __s) const
884 { return this->str().compare(__s.str()); }
885
886 /**
887 * @brief Compares this sub_match to a string.
888 *
889 * @param __s A string to compare to this sub_match.
890 *
891 * @retval <0 this matched sequence will collate before @p __s.
892 * @retval =0 this matched sequence is equivalent to @p __s.
893 * @retval <0 this matched sequence will collate after @p __s.
894 */
895 int
896 compare(const string_type& __s) const
897 { return this->str().compare(__s); }
898
899 /**
900 * @brief Compares this sub_match to a C-style string.
901 *
902 * @param __s A C-style string to compare to this sub_match.
903 *
904 * @retval <0 this matched sequence will collate before @p __s.
905 * @retval =0 this matched sequence is equivalent to @p __s.
906 * @retval <0 this matched sequence will collate after @p __s.
907 */
908 int
909 compare(const value_type* __s) const
910 { return this->str().compare(__s); }
911 };
912
913
914 /** @brief Standard regex submatch over a C-style null-terminated string. */
915 typedef sub_match<const char*> csub_match;
916
917 /** @brief Standard regex submatch over a standard string. */
918 typedef sub_match<string::const_iterator> ssub_match;
919
920#ifdef _GLIBCXX_USE_WCHAR_T
921 /** @brief Regex submatch over a C-style null-terminated wide string. */
922 typedef sub_match<const wchar_t*> wcsub_match;
923
924 /** @brief Regex submatch over a standard wide string. */
925 typedef sub_match<wstring::const_iterator> wssub_match;
926#endif
927
928 // [7.9.2] sub_match non-member operators
929
930 /**
931 * @brief Tests the equivalence of two regular expression submatches.
932 * @param __lhs First regular expression submatch.
933 * @param __rhs Second regular expression submatch.
934 * @returns true if @a __lhs is equivalent to @a __rhs, false otherwise.
935 */
936 template<typename _BiIter>
937 inline bool
938 operator==(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs)
939 { return __lhs.compare(__rhs) == 0; }
940
941 /**
942 * @brief Tests the inequivalence of two regular expression submatches.
943 * @param __lhs First regular expression submatch.
944 * @param __rhs Second regular expression submatch.
945 * @returns true if @a __lhs is not equivalent to @a __rhs, false otherwise.
946 */
947 template<typename _BiIter>
948 inline bool
949 operator!=(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs)
950 { return __lhs.compare(__rhs) != 0; }
951
952 /**
953 * @brief Tests the ordering of two regular expression submatches.
954 * @param __lhs First regular expression submatch.
955 * @param __rhs Second regular expression submatch.
956 * @returns true if @a __lhs precedes @a __rhs, false otherwise.
957 */
958 template<typename _BiIter>
959 inline bool
960 operator<(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs)
961 { return __lhs.compare(__rhs) < 0; }
962
963 /**
964 * @brief Tests the ordering of two regular expression submatches.
965 * @param __lhs First regular expression submatch.
966 * @param __rhs Second regular expression submatch.
967 * @returns true if @a __lhs does not succeed @a __rhs, false otherwise.
968 */
969 template<typename _BiIter>
970 inline bool
971 operator<=(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs)
972 { return __lhs.compare(__rhs) <= 0; }
973
974 /**
975 * @brief Tests the ordering of two regular expression submatches.
976 * @param __lhs First regular expression submatch.
977 * @param __rhs Second regular expression submatch.
978 * @returns true if @a __lhs does not precede @a __rhs, false otherwise.
979 */
980 template<typename _BiIter>
981 inline bool
982 operator>=(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs)
983 { return __lhs.compare(__rhs) >= 0; }
984
985 /**
986 * @brief Tests the ordering of two regular expression submatches.
987 * @param __lhs First regular expression submatch.
988 * @param __rhs Second regular expression submatch.
989 * @returns true if @a __lhs succeeds @a __rhs, false otherwise.
990 */
991 template<typename _BiIter>
992 inline bool
993 operator>(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs)
994 { return __lhs.compare(__rhs) > 0; }
995
996 // Alias for sub_match'd string.
997 template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
998 using __sub_match_string = basic_string<
999 typename iterator_traits<_Bi_iter>::value_type,
1000 _Ch_traits, _Ch_alloc>;
1001
1002 /**
1003 * @brief Tests the equivalence of a string and a regular expression
1004 * submatch.
1005 * @param __lhs A string.
1006 * @param __rhs A regular expression submatch.
1007 * @returns true if @a __lhs is equivalent to @a __rhs, false otherwise.
1008 */
1009 template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1010 inline bool
1011 operator==(const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1012 const sub_match<_Bi_iter>& __rhs)
1013 {
1014 typedef typename sub_match<_Bi_iter>::string_type string_type;
1015 return __rhs.compare(string_type(__lhs.data(), __lhs.size())) == 0;
1016 }
1017
1018 /**
1019 * @brief Tests the inequivalence of a string and a regular expression
1020 * submatch.
1021 * @param __lhs A string.
1022 * @param __rhs A regular expression submatch.
1023 * @returns true if @a __lhs is not equivalent to @a __rhs, false otherwise.
1024 */
1025 template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1026 inline bool
1027 operator!=(const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1028 const sub_match<_Bi_iter>& __rhs)
1029 { return !(__lhs == __rhs); }
1030
1031 /**
1032 * @brief Tests the ordering of a string and a regular expression submatch.
1033 * @param __lhs A string.
1034 * @param __rhs A regular expression submatch.
1035 * @returns true if @a __lhs precedes @a __rhs, false otherwise.
1036 */
1037 template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1038 inline bool
1039 operator<(const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1040 const sub_match<_Bi_iter>& __rhs)
1041 {
1042 typedef typename sub_match<_Bi_iter>::string_type string_type;
1043 return __rhs.compare(string_type(__lhs.data(), __lhs.size())) > 0;
1044 }
1045
1046 /**
1047 * @brief Tests the ordering of a string and a regular expression submatch.
1048 * @param __lhs A string.
1049 * @param __rhs A regular expression submatch.
1050 * @returns true if @a __lhs succeeds @a __rhs, false otherwise.
1051 */
1052 template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1053 inline bool
1054 operator>(const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1055 const sub_match<_Bi_iter>& __rhs)
1056 { return __rhs < __lhs; }
1057
1058 /**
1059 * @brief Tests the ordering of a string and a regular expression submatch.
1060 * @param __lhs A string.
1061 * @param __rhs A regular expression submatch.
1062 * @returns true if @a __lhs does not precede @a __rhs, false otherwise.
1063 */
1064 template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1065 inline bool
1066 operator>=(const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1067 const sub_match<_Bi_iter>& __rhs)
1068 { return !(__lhs < __rhs); }
1069
1070 /**
1071 * @brief Tests the ordering of a string and a regular expression submatch.
1072 * @param __lhs A string.
1073 * @param __rhs A regular expression submatch.
1074 * @returns true if @a __lhs does not succeed @a __rhs, false otherwise.
1075 */
1076 template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1077 inline bool
1078 operator<=(const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1079 const sub_match<_Bi_iter>& __rhs)
1080 { return !(__rhs < __lhs); }
1081
1082 /**
1083 * @brief Tests the equivalence of a regular expression submatch and a
1084 * string.
1085 * @param __lhs A regular expression submatch.
1086 * @param __rhs A string.
1087 * @returns true if @a __lhs is equivalent to @a __rhs, false otherwise.
1088 */
1089 template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1090 inline bool
1091 operator==(const sub_match<_Bi_iter>& __lhs,
1092 const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1093 {
1094 typedef typename sub_match<_Bi_iter>::string_type string_type;
1095 return __lhs.compare(string_type(__rhs.data(), __rhs.size())) == 0;
1096 }
1097
1098 /**
1099 * @brief Tests the inequivalence of a regular expression submatch and a
1100 * string.
1101 * @param __lhs A regular expression submatch.
1102 * @param __rhs A string.
1103 * @returns true if @a __lhs is not equivalent to @a __rhs, false otherwise.
1104 */
1105 template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1106 inline bool
1107 operator!=(const sub_match<_Bi_iter>& __lhs,
1108 const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1109 { return !(__lhs == __rhs); }
1110
1111 /**
1112 * @brief Tests the ordering of a regular expression submatch and a string.
1113 * @param __lhs A regular expression submatch.
1114 * @param __rhs A string.
1115 * @returns true if @a __lhs precedes @a __rhs, false otherwise.
1116 */
1117 template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
1118 inline bool
1119 operator<(const sub_match<_Bi_iter>& __lhs,
1120 const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1121 {
1122 typedef typename sub_match<_Bi_iter>::string_type string_type;
1123 return __lhs.compare(string_type(__rhs.data(), __rhs.size())) < 0;
1124 }
1125
1126 /**
1127 * @brief Tests the ordering of a regular expression submatch and a string.
1128 * @param __lhs A regular expression submatch.
1129 * @param __rhs A string.
1130 * @returns true if @a __lhs succeeds @a __rhs, false otherwise.
1131 */
1132 template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
1133 inline bool
1134 operator>(const sub_match<_Bi_iter>& __lhs,
1135 const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1136 { return __rhs < __lhs; }
1137
1138 /**
1139 * @brief Tests the ordering of a regular expression submatch and a string.
1140 * @param __lhs A regular expression submatch.
1141 * @param __rhs A string.
1142 * @returns true if @a __lhs does not precede @a __rhs, false otherwise.
1143 */
1144 template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
1145 inline bool
1146 operator>=(const sub_match<_Bi_iter>& __lhs,
1147 const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1148 { return !(__lhs < __rhs); }
1149
1150 /**
1151 * @brief Tests the ordering of a regular expression submatch and a string.
1152 * @param __lhs A regular expression submatch.
1153 * @param __rhs A string.
1154 * @returns true if @a __lhs does not succeed @a __rhs, false otherwise.
1155 */
1156 template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
1157 inline bool
1158 operator<=(const sub_match<_Bi_iter>& __lhs,
1159 const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1160 { return !(__rhs < __lhs); }
1161
1162 /**
1163 * @brief Tests the equivalence of a C string and a regular expression
1164 * submatch.
1165 * @param __lhs A C string.
1166 * @param __rhs A regular expression submatch.
1167 * @returns true if @a __lhs is equivalent to @a __rhs, false otherwise.
1168 */
1169 template<typename _Bi_iter>
1170 inline bool
1171 operator==(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
1172 const sub_match<_Bi_iter>& __rhs)
1173 { return __rhs.compare(__lhs) == 0; }
1174
1175 /**
1176 * @brief Tests the inequivalence of an iterator value and a regular
1177 * expression submatch.
1178 * @param __lhs A regular expression submatch.
1179 * @param __rhs A string.
1180 * @returns true if @a __lhs is not equivalent to @a __rhs, false otherwise.
1181 */
1182 template<typename _Bi_iter>
1183 inline bool
1184 operator!=(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
1185 const sub_match<_Bi_iter>& __rhs)
1186 { return !(__lhs == __rhs); }
1187
1188 /**
1189 * @brief Tests the ordering of a string and a regular expression submatch.
1190 * @param __lhs A string.
1191 * @param __rhs A regular expression submatch.
1192 * @returns true if @a __lhs precedes @a __rhs, false otherwise.
1193 */
1194 template<typename _Bi_iter>
1195 inline bool
1196 operator<(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
1197 const sub_match<_Bi_iter>& __rhs)
1198 { return __rhs.compare(__lhs) > 0; }
1199
1200 /**
1201 * @brief Tests the ordering of a string and a regular expression submatch.
1202 * @param __lhs A string.
1203 * @param __rhs A regular expression submatch.
1204 * @returns true if @a __lhs succeeds @a __rhs, false otherwise.
1205 */
1206 template<typename _Bi_iter>
1207 inline bool
1208 operator>(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
1209 const sub_match<_Bi_iter>& __rhs)
1210 { return __rhs < __lhs; }
1211
1212 /**
1213 * @brief Tests the ordering of a string and a regular expression submatch.
1214 * @param __lhs A string.
1215 * @param __rhs A regular expression submatch.
1216 * @returns true if @a __lhs does not precede @a __rhs, false otherwise.
1217 */
1218 template<typename _Bi_iter>
1219 inline bool
1220 operator>=(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
1221 const sub_match<_Bi_iter>& __rhs)
1222 { return !(__lhs < __rhs); }
1223
1224 /**
1225 * @brief Tests the ordering of a string and a regular expression submatch.
1226 * @param __lhs A string.
1227 * @param __rhs A regular expression submatch.
1228 * @returns true if @a __lhs does not succeed @a __rhs, false otherwise.
1229 */
1230 template<typename _Bi_iter>
1231 inline bool
1232 operator<=(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
1233 const sub_match<_Bi_iter>& __rhs)
1234 { return !(__rhs < __lhs); }
1235
1236 /**
1237 * @brief Tests the equivalence of a regular expression submatch and a
1238 * string.
1239 * @param __lhs A regular expression submatch.
1240 * @param __rhs A pointer to a string?
1241 * @returns true if @a __lhs is equivalent to @a __rhs, false otherwise.
1242 */
1243 template<typename _Bi_iter>
1244 inline bool
1245 operator==(const sub_match<_Bi_iter>& __lhs,
1246 typename iterator_traits<_Bi_iter>::value_type const* __rhs)
1247 { return __lhs.compare(__rhs) == 0; }
1248
1249 /**
1250 * @brief Tests the inequivalence of a regular expression submatch and a
1251 * string.
1252 * @param __lhs A regular expression submatch.
1253 * @param __rhs A pointer to a string.
1254 * @returns true if @a __lhs is not equivalent to @a __rhs, false otherwise.
1255 */
1256 template<typename _Bi_iter>
1257 inline bool
1258 operator!=(const sub_match<_Bi_iter>& __lhs,
1259 typename iterator_traits<_Bi_iter>::value_type const* __rhs)
1260 { return !(__lhs == __rhs); }
1261
1262 /**
1263 * @brief Tests the ordering of a regular expression submatch and a string.
1264 * @param __lhs A regular expression submatch.
1265 * @param __rhs A string.
1266 * @returns true if @a __lhs precedes @a __rhs, false otherwise.
1267 */
1268 template<typename _Bi_iter>
1269 inline bool
1270 operator<(const sub_match<_Bi_iter>& __lhs,
1271 typename iterator_traits<_Bi_iter>::value_type const* __rhs)
1272 { return __lhs.compare(__rhs) < 0; }
1273
1274 /**
1275 * @brief Tests the ordering of a regular expression submatch and a string.
1276 * @param __lhs A regular expression submatch.
1277 * @param __rhs A string.
1278 * @returns true if @a __lhs succeeds @a __rhs, false otherwise.
1279 */
1280 template<typename _Bi_iter>
1281 inline bool
1282 operator>(const sub_match<_Bi_iter>& __lhs,
1283 typename iterator_traits<_Bi_iter>::value_type const* __rhs)
1284 { return __rhs < __lhs; }
1285
1286 /**
1287 * @brief Tests the ordering of a regular expression submatch and a string.
1288 * @param __lhs A regular expression submatch.
1289 * @param __rhs A string.
1290 * @returns true if @a __lhs does not precede @a __rhs, false otherwise.
1291 */
1292 template<typename _Bi_iter>
1293 inline bool
1294 operator>=(const sub_match<_Bi_iter>& __lhs,
1295 typename iterator_traits<_Bi_iter>::value_type const* __rhs)
1296 { return !(__lhs < __rhs); }
1297
1298 /**
1299 * @brief Tests the ordering of a regular expression submatch and a string.
1300 * @param __lhs A regular expression submatch.
1301 * @param __rhs A string.
1302 * @returns true if @a __lhs does not succeed @a __rhs, false otherwise.
1303 */
1304 template<typename _Bi_iter>
1305 inline bool
1306 operator<=(const sub_match<_Bi_iter>& __lhs,
1307 typename iterator_traits<_Bi_iter>::value_type const* __rhs)
1308 { return !(__rhs < __lhs); }
1309
1310 /**
1311 * @brief Tests the equivalence of a string and a regular expression
1312 * submatch.
1313 * @param __lhs A string.
1314 * @param __rhs A regular expression submatch.
1315 * @returns true if @a __lhs is equivalent to @a __rhs, false otherwise.
1316 */
1317 template<typename _Bi_iter>
1318 inline bool
1319 operator==(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
1320 const sub_match<_Bi_iter>& __rhs)
1321 {
1322 typedef typename sub_match<_Bi_iter>::string_type string_type;
1323 return __rhs.compare(string_type(1, __lhs)) == 0;
1324 }
1325
1326 /**
1327 * @brief Tests the inequivalence of a string and a regular expression
1328 * submatch.
1329 * @param __lhs A string.
1330 * @param __rhs A regular expression submatch.
1331 * @returns true if @a __lhs is not equivalent to @a __rhs, false otherwise.
1332 */
1333 template<typename _Bi_iter>
1334 inline bool
1335 operator!=(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
1336 const sub_match<_Bi_iter>& __rhs)
1337 { return !(__lhs == __rhs); }
1338
1339 /**
1340 * @brief Tests the ordering of a string and a regular expression submatch.
1341 * @param __lhs A string.
1342 * @param __rhs A regular expression submatch.
1343 * @returns true if @a __lhs precedes @a __rhs, false otherwise.
1344 */
1345 template<typename _Bi_iter>
1346 inline bool
1347 operator<(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
1348 const sub_match<_Bi_iter>& __rhs)
1349 {
1350 typedef typename sub_match<_Bi_iter>::string_type string_type;
1351 return __rhs.compare(string_type(1, __lhs)) > 0;
1352 }
1353
1354 /**
1355 * @brief Tests the ordering of a string and a regular expression submatch.
1356 * @param __lhs A string.
1357 * @param __rhs A regular expression submatch.
1358 * @returns true if @a __lhs succeeds @a __rhs, false otherwise.
1359 */
1360 template<typename _Bi_iter>
1361 inline bool
1362 operator>(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
1363 const sub_match<_Bi_iter>& __rhs)
1364 { return __rhs < __lhs; }
1365
1366 /**
1367 * @brief Tests the ordering of a string and a regular expression submatch.
1368 * @param __lhs A string.
1369 * @param __rhs A regular expression submatch.
1370 * @returns true if @a __lhs does not precede @a __rhs, false otherwise.
1371 */
1372 template<typename _Bi_iter>
1373 inline bool
1374 operator>=(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
1375 const sub_match<_Bi_iter>& __rhs)
1376 { return !(__lhs < __rhs); }
1377
1378 /**
1379 * @brief Tests the ordering of a string and a regular expression submatch.
1380 * @param __lhs A string.
1381 * @param __rhs A regular expression submatch.
1382 * @returns true if @a __lhs does not succeed @a __rhs, false otherwise.
1383 */
1384 template<typename _Bi_iter>
1385 inline bool
1386 operator<=(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
1387 const sub_match<_Bi_iter>& __rhs)
1388 { return !(__rhs < __lhs); }
1389
1390 /**
1391 * @brief Tests the equivalence of a regular expression submatch and a
1392 * string.
1393 * @param __lhs A regular expression submatch.
1394 * @param __rhs A const string reference.
1395 * @returns true if @a __lhs is equivalent to @a __rhs, false otherwise.
1396 */
1397 template<typename _Bi_iter>
1398 inline bool
1399 operator==(const sub_match<_Bi_iter>& __lhs,
1400 typename iterator_traits<_Bi_iter>::value_type const& __rhs)
1401 {
1402 typedef typename sub_match<_Bi_iter>::string_type string_type;
1403 return __lhs.compare(string_type(1, __rhs)) == 0;
1404 }
1405
1406 /**
1407 * @brief Tests the inequivalence of a regular expression submatch and a
1408 * string.
1409 * @param __lhs A regular expression submatch.
1410 * @param __rhs A const string reference.
1411 * @returns true if @a __lhs is not equivalent to @a __rhs, false otherwise.
1412 */
1413 template<typename _Bi_iter>
1414 inline bool
1415 operator!=(const sub_match<_Bi_iter>& __lhs,
1416 typename iterator_traits<_Bi_iter>::value_type const& __rhs)
1417 { return !(__lhs == __rhs); }
1418
1419 /**
1420 * @brief Tests the ordering of a regular expression submatch and a string.
1421 * @param __lhs A regular expression submatch.
1422 * @param __rhs A const string reference.
1423 * @returns true if @a __lhs precedes @a __rhs, false otherwise.
1424 */
1425 template<typename _Bi_iter>
1426 inline bool
1427 operator<(const sub_match<_Bi_iter>& __lhs,
1428 typename iterator_traits<_Bi_iter>::value_type const& __rhs)
1429 {
1430 typedef typename sub_match<_Bi_iter>::string_type string_type;
1431 return __lhs.compare(string_type(1, __rhs)) < 0;
1432 }
1433
1434 /**
1435 * @brief Tests the ordering of a regular expression submatch and a string.
1436 * @param __lhs A regular expression submatch.
1437 * @param __rhs A const string reference.
1438 * @returns true if @a __lhs succeeds @a __rhs, false otherwise.
1439 */
1440 template<typename _Bi_iter>
1441 inline bool
1442 operator>(const sub_match<_Bi_iter>& __lhs,
1443 typename iterator_traits<_Bi_iter>::value_type const& __rhs)
1444 { return __rhs < __lhs; }
1445
1446 /**
1447 * @brief Tests the ordering of a regular expression submatch and a string.
1448 * @param __lhs A regular expression submatch.
1449 * @param __rhs A const string reference.
1450 * @returns true if @a __lhs does not precede @a __rhs, false otherwise.
1451 */
1452 template<typename _Bi_iter>
1453 inline bool
1454 operator>=(const sub_match<_Bi_iter>& __lhs,
1455 typename iterator_traits<_Bi_iter>::value_type const& __rhs)
1456 { return !(__lhs < __rhs); }
1457
1458 /**
1459 * @brief Tests the ordering of a regular expression submatch and a string.
1460 * @param __lhs A regular expression submatch.
1461 * @param __rhs A const string reference.
1462 * @returns true if @a __lhs does not succeed @a __rhs, false otherwise.
1463 */
1464 template<typename _Bi_iter>
1465 inline bool
1466 operator<=(const sub_match<_Bi_iter>& __lhs,
1467 typename iterator_traits<_Bi_iter>::value_type const& __rhs)
1468 { return !(__rhs < __lhs); }
1469
1470 /**
1471 * @brief Inserts a matched string into an output stream.
1472 *
1473 * @param __os The output stream.
1474 * @param __m A submatch string.
1475 *
1476 * @returns the output stream with the submatch string inserted.
1477 */
1478 template<typename _Ch_type, typename _Ch_traits, typename _Bi_iter>
1479 inline
1480 basic_ostream<_Ch_type, _Ch_traits>&
1481 operator<<(basic_ostream<_Ch_type, _Ch_traits>& __os,
1482 const sub_match<_Bi_iter>& __m)
1483 { return __os << __m.str(); }
1484
1485 // [7.10] Class template match_results
1486
1487 /**
1488 * @brief The results of a match or search operation.
1489 *
1490 * A collection of character sequences representing the result of a regular
1491 * expression match. Storage for the collection is allocated and freed as
1492 * necessary by the member functions of class template match_results.
1493 *
1494 * This class satisfies the Sequence requirements, with the exception that
1495 * only the operations defined for a const-qualified Sequence are supported.
1496 *
1497 * The sub_match object stored at index 0 represents sub-expression 0, i.e.
1498 * the whole match. In this case the %sub_match member matched is always true.
1499 * The sub_match object stored at index n denotes what matched the marked
1500 * sub-expression n within the matched expression. If the sub-expression n
1501 * participated in a regular expression match then the %sub_match member
1502 * matched evaluates to true, and members first and second denote the range
1503 * of characters [first, second) which formed that match. Otherwise matched
1504 * is false, and members first and second point to the end of the sequence
1505 * that was searched.
1506 *
1507 * @nosubgrouping
1508 */
1509 template<typename _Bi_iter,
1510 typename _Alloc = allocator<sub_match<_Bi_iter> > >
1511 class match_results
1512 : private std::vector<sub_match<_Bi_iter>, _Alloc>
1513 {
1514 private:
1515 /*
1516 * The vector base is empty if this does not represent a match (!ready());
1517 * Otherwise if it's a match failure, it contains 3 elements:
1518 * [0] unmatched
1519 * [1] prefix
1520 * [2] suffix
1521 * Otherwise it contains n+4 elements where n is the number of marked
1522 * sub-expressions:
1523 * [0] entire match
1524 * [1] 1st marked subexpression
1525 * ...
1526 * [n] nth marked subexpression
1527 * [n+1] unmatched
1528 * [n+2] prefix
1529 * [n+3] suffix
1530 */
1531 typedef std::vector<sub_match<_Bi_iter>, _Alloc> _Base_type;
1532 typedef std::iterator_traits<_Bi_iter> __iter_traits;
1533 typedef regex_constants::match_flag_type match_flag_type;
1534
1535 public:
1536 /**
1537 * @name 10.? Public Types
1538 */
1539 //@{
1540 typedef sub_match<_Bi_iter> value_type;
1541 typedef const value_type& const_reference;
1542 typedef value_type& reference;
1543 typedef typename _Base_type::const_iterator const_iterator;
1544 typedef const_iterator iterator;
1545 typedef typename __iter_traits::difference_type difference_type;
1546 typedef typename allocator_traits<_Alloc>::size_type size_type;
1547 typedef _Alloc allocator_type;
1548 typedef typename __iter_traits::value_type char_type;
1549 typedef std::basic_string<char_type> string_type;
1550 //@}
1551
1552 public:
1553 /**
1554 * @name 28.10.1 Construction, Copying, and Destruction
1555 */
1556 //@{
1557
1558 /**
1559 * @brief Constructs a default %match_results container.
1560 * @post size() returns 0 and str() returns an empty string.
1561 */
1562 explicit
1563 match_results(const _Alloc& __a = _Alloc())
1564 : _Base_type(__a)
1565 { }
1566
1567 /**
1568 * @brief Copy constructs a %match_results.
1569 */
1570 match_results(const match_results& __rhs) = default;
1571
1572 /**
1573 * @brief Move constructs a %match_results.
1574 */
1575 match_results(match_results&& __rhs) noexcept = default;
1576
1577 /**
1578 * @brief Assigns rhs to *this.
1579 */
1580 match_results&
1581 operator=(const match_results& __rhs) = default;
1582
1583 /**
1584 * @brief Move-assigns rhs to *this.
1585 */
1586 match_results&
1587 operator=(match_results&& __rhs) = default;
1588
1589 /**
1590 * @brief Destroys a %match_results object.
1591 */
1592 ~match_results()
1593 { }
1594
1595 //@}
1596
1597 // 28.10.2, state:
1598 /**
1599 * @brief Indicates if the %match_results is ready.
1600 * @retval true The object has a fully-established result state.
1601 * @retval false The object is not ready.
1602 */
1603 bool ready() const { return !_Base_type::empty(); }
1604
1605 /**
1606 * @name 28.10.2 Size
1607 */
1608 //@{
1609
1610 /**
1611 * @brief Gets the number of matches and submatches.
1612 *
1613 * The number of matches for a given regular expression will be either 0
1614 * if there was no match or mark_count() + 1 if a match was successful.
1615 * Some matches may be empty.
1616 *
1617 * @returns the number of matches found.
1618 */
1619 size_type
1620 size() const
1621 { return _Base_type::empty() ? 0 : _Base_type::size() - 3; }
1622
1623 size_type
1624 max_size() const
1625 { return _Base_type::max_size(); }
1626
1627 /**
1628 * @brief Indicates if the %match_results contains no results.
1629 * @retval true The %match_results object is empty.
1630 * @retval false The %match_results object is not empty.
1631 */
1632 bool
1633 empty() const
1634 { return size() == 0; }
1635
1636 //@}
1637
1638 /**
1639 * @name 10.3 Element Access
1640 */
1641 //@{
1642
1643 /**
1644 * @brief Gets the length of the indicated submatch.
1645 * @param __sub indicates the submatch.
1646 * @pre ready() == true
1647 *
1648 * This function returns the length of the indicated submatch, or the
1649 * length of the entire match if @p __sub is zero (the default).
1650 */
1651 difference_type
1652 length(size_type __sub = 0) const
1653 { return (*this)[__sub].length(); }
1654
1655 /**
1656 * @brief Gets the offset of the beginning of the indicated submatch.
1657 * @param __sub indicates the submatch.
1658 * @pre ready() == true
1659 *
1660 * This function returns the offset from the beginning of the target
1661 * sequence to the beginning of the submatch, unless the value of @p __sub
1662 * is zero (the default), in which case this function returns the offset
1663 * from the beginning of the target sequence to the beginning of the
1664 * match.
1665 */
1666 difference_type
1667 position(size_type __sub = 0) const
1668 { return std::distance(_M_begin, (*this)[__sub].first); }
1669
1670 /**
1671 * @brief Gets the match or submatch converted to a string type.
1672 * @param __sub indicates the submatch.
1673 * @pre ready() == true
1674 *
1675 * This function gets the submatch (or match, if @p __sub is
1676 * zero) extracted from the target range and converted to the
1677 * associated string type.
1678 */
1679 string_type
1680 str(size_type __sub = 0) const
1681 { return string_type((*this)[__sub]); }
1682
1683 /**
1684 * @brief Gets a %sub_match reference for the match or submatch.
1685 * @param __sub indicates the submatch.
1686 * @pre ready() == true
1687 *
1688 * This function gets a reference to the indicated submatch, or
1689 * the entire match if @p __sub is zero.
1690 *
1691 * If @p __sub >= size() then this function returns a %sub_match with a
1692 * special value indicating no submatch.
1693 */
1694 const_reference
1695 operator[](size_type __sub) const
1696 {
1697 __glibcxx_assert( ready() );
1698 return __sub < size()
1699 ? _Base_type::operator[](__sub)
1700 : _M_unmatched_sub();
1701 }
1702
1703 /**
1704 * @brief Gets a %sub_match representing the match prefix.
1705 * @pre ready() == true
1706 *
1707 * This function gets a reference to a %sub_match object representing the
1708 * part of the target range between the start of the target range and the
1709 * start of the match.
1710 */
1711 const_reference
1712 prefix() const
1713 {
1714 __glibcxx_assert( ready() );
1715 return !empty() ? _M_prefix() : _M_unmatched_sub();
1716 }
1717
1718 /**
1719 * @brief Gets a %sub_match representing the match suffix.
1720 * @pre ready() == true
1721 *
1722 * This function gets a reference to a %sub_match object representing the
1723 * part of the target range between the end of the match and the end of
1724 * the target range.
1725 */
1726 const_reference
1727 suffix() const
1728 {
1729 __glibcxx_assert( ready() );
1730 return !empty() ? _M_suffix() : _M_unmatched_sub();
1731 }
1732
1733 /**
1734 * @brief Gets an iterator to the start of the %sub_match collection.
1735 */
1736 const_iterator
1737 begin() const
1738 { return _Base_type::begin(); }
1739
1740 /**
1741 * @brief Gets an iterator to the start of the %sub_match collection.
1742 */
1743 const_iterator
1744 cbegin() const
1745 { return this->begin(); }
1746
1747 /**
1748 * @brief Gets an iterator to one-past-the-end of the collection.
1749 */
1750 const_iterator
1751 end() const
1752 { return _Base_type::end() - (empty() ? 0 : 3); }
1753
1754 /**
1755 * @brief Gets an iterator to one-past-the-end of the collection.
1756 */
1757 const_iterator
1758 cend() const
1759 { return this->end(); }
1760
1761 //@}
1762
1763 /**
1764 * @name 10.4 Formatting
1765 *
1766 * These functions perform formatted substitution of the matched
1767 * character sequences into their target. The format specifiers and
1768 * escape sequences accepted by these functions are determined by
1769 * their @p flags parameter as documented above.
1770 */
1771 //@{
1772
1773 /**
1774 * @pre ready() == true
1775 */
1776 template<typename _Out_iter>
1777 _Out_iter
1778 format(_Out_iter __out, const char_type* __fmt_first,
1779 const char_type* __fmt_last,
1780 match_flag_type __flags = regex_constants::format_default) const;
1781
1782 /**
1783 * @pre ready() == true
1784 */
1785 template<typename _Out_iter, typename _St, typename _Sa>
1786 _Out_iter
1787 format(_Out_iter __out, const basic_string<char_type, _St, _Sa>& __fmt,
1788 match_flag_type __flags = regex_constants::format_default) const
1789 {
1790 return format(__out, __fmt.data(), __fmt.data() + __fmt.size(),
1791 __flags);
1792 }
1793
1794 /**
1795 * @pre ready() == true
1796 */
1797 template<typename _St, typename _Sa>
1798 basic_string<char_type, _St, _Sa>
1799 format(const basic_string<char_type, _St, _Sa>& __fmt,
1800 match_flag_type __flags = regex_constants::format_default) const
1801 {
1802 basic_string<char_type, _St, _Sa> __result;
1803 format(std::back_inserter(__result), __fmt, __flags);
1804 return __result;
1805 }
1806
1807 /**
1808 * @pre ready() == true
1809 */
1810 string_type
1811 format(const char_type* __fmt,
1812 match_flag_type __flags = regex_constants::format_default) const
1813 {
1814 string_type __result;
1815 format(std::back_inserter(__result),
1816 __fmt,
1817 __fmt + char_traits<char_type>::length(__fmt),
1818 __flags);
1819 return __result;
1820 }
1821
1822 //@}
1823
1824 /**
1825 * @name 10.5 Allocator
1826 */
1827 //@{
1828
1829 /**
1830 * @brief Gets a copy of the allocator.
1831 */
1832 allocator_type
1833 get_allocator() const
1834 { return _Base_type::get_allocator(); }
1835
1836 //@}
1837
1838 /**
1839 * @name 10.6 Swap
1840 */
1841 //@{
1842
1843 /**
1844 * @brief Swaps the contents of two match_results.
1845 */
1846 void
1847 swap(match_results& __that)
1848 {
1849 using std::swap;
1850 _Base_type::swap(__that);
1851 swap(_M_begin, __that._M_begin);
1852 }
1853 //@}
1854
1855 private:
1856 template<typename, typename, typename, bool>
1857 friend class __detail::_Executor;
1858
1859 template<typename, typename, typename>
1860 friend class regex_iterator;
1861
1862 template<typename _Bp, typename _Ap, typename _Cp, typename _Rp,
1863 __detail::_RegexExecutorPolicy, bool>
1864 friend bool
1865 __detail::__regex_algo_impl(_Bp, _Bp, match_results<_Bp, _Ap>&,
1866 const basic_regex<_Cp, _Rp>&,
1867 regex_constants::match_flag_type);
1868
1869 void
1870 _M_resize(unsigned int __size)
1871 { _Base_type::resize(__size + 3); }
1872
1873 const_reference
1874 _M_unmatched_sub() const
1875 { return _Base_type::operator[](_Base_type::size() - 3); }
1876
1877 sub_match<_Bi_iter>&
1878 _M_unmatched_sub()
1879 { return _Base_type::operator[](_Base_type::size() - 3); }
1880
1881 const_reference
1882 _M_prefix() const
1883 { return _Base_type::operator[](_Base_type::size() - 2); }
1884
1885 sub_match<_Bi_iter>&
1886 _M_prefix()
1887 { return _Base_type::operator[](_Base_type::size() - 2); }
1888
1889 const_reference
1890 _M_suffix() const
1891 { return _Base_type::operator[](_Base_type::size() - 1); }
1892
1893 sub_match<_Bi_iter>&
1894 _M_suffix()
1895 { return _Base_type::operator[](_Base_type::size() - 1); }
1896
1897 _Bi_iter _M_begin;
1898 };
1899
1900 typedef match_results<const char*> cmatch;
1901 typedef match_results<string::const_iterator> smatch;
1902#ifdef _GLIBCXX_USE_WCHAR_T
1903 typedef match_results<const wchar_t*> wcmatch;
1904 typedef match_results<wstring::const_iterator> wsmatch;
1905#endif
1906
1907 // match_results comparisons
1908 /**
1909 * @brief Compares two match_results for equality.
1910 * @returns true if the two objects refer to the same match,
1911 * false otherwise.
1912 */
1913 template<typename _Bi_iter, typename _Alloc>
1914 inline bool
1915 operator==(const match_results<_Bi_iter, _Alloc>& __m1,
1916 const match_results<_Bi_iter, _Alloc>& __m2)
1917 {
1918 if (__m1.ready() != __m2.ready())
1919 return false;
1920 if (!__m1.ready()) // both are not ready
1921 return true;
1922 if (__m1.empty() != __m2.empty())
1923 return false;
1924 if (__m1.empty()) // both are empty
1925 return true;
1926 return __m1.prefix() == __m2.prefix()
1927 && __m1.size() == __m2.size()
1928 && std::equal(__m1.begin(), __m1.end(), __m2.begin())
1929 && __m1.suffix() == __m2.suffix();
1930 }
1931
1932 /**
1933 * @brief Compares two match_results for inequality.
1934 * @returns true if the two objects do not refer to the same match,
1935 * false otherwise.
1936 */
1937 template<typename _Bi_iter, class _Alloc>
1938 inline bool
1939 operator!=(const match_results<_Bi_iter, _Alloc>& __m1,
1940 const match_results<_Bi_iter, _Alloc>& __m2)
1941 { return !(__m1 == __m2); }
1942
1943 // [7.10.6] match_results swap
1944 /**
1945 * @brief Swaps two match results.
1946 * @param __lhs A match result.
1947 * @param __rhs A match result.
1948 *
1949 * The contents of the two match_results objects are swapped.
1950 */
1951 template<typename _Bi_iter, typename _Alloc>
1952 inline void
1953 swap(match_results<_Bi_iter, _Alloc>& __lhs,
1954 match_results<_Bi_iter, _Alloc>& __rhs)
1955 { __lhs.swap(__rhs); }
1956
1957_GLIBCXX_END_NAMESPACE_CXX11
1958
1959 // [7.11.2] Function template regex_match
1960 /**
1961 * @name Matching, Searching, and Replacing
1962 */
1963 //@{
1964
1965 /**
1966 * @brief Determines if there is a match between the regular expression @p e
1967 * and all of the character sequence [first, last).
1968 *
1969 * @param __s Start of the character sequence to match.
1970 * @param __e One-past-the-end of the character sequence to match.
1971 * @param __m The match results.
1972 * @param __re The regular expression.
1973 * @param __flags Controls how the regular expression is matched.
1974 *
1975 * @retval true A match exists.
1976 * @retval false Otherwise.
1977 *
1978 * @throws an exception of type regex_error.
1979 */
1980 template<typename _Bi_iter, typename _Alloc,
1981 typename _Ch_type, typename _Rx_traits>
1982 inline bool
1983 regex_match(_Bi_iter __s,
1984 _Bi_iter __e,
1985 match_results<_Bi_iter, _Alloc>& __m,
1986 const basic_regex<_Ch_type, _Rx_traits>& __re,
1987 regex_constants::match_flag_type __flags
1988 = regex_constants::match_default)
1989 {
1990 return __detail::__regex_algo_impl<_Bi_iter, _Alloc, _Ch_type, _Rx_traits,
1991 __detail::_RegexExecutorPolicy::_S_auto, true>
1992 (__s, __e, __m, __re, __flags);
1993 }
1994
1995 /**
1996 * @brief Indicates if there is a match between the regular expression @p e
1997 * and all of the character sequence [first, last).
1998 *
1999 * @param __first Beginning of the character sequence to match.
2000 * @param __last One-past-the-end of the character sequence to match.
2001 * @param __re The regular expression.
2002 * @param __flags Controls how the regular expression is matched.
2003 *
2004 * @retval true A match exists.
2005 * @retval false Otherwise.
2006 *
2007 * @throws an exception of type regex_error.
2008 */
2009 template<typename _Bi_iter, typename _Ch_type, typename _Rx_traits>
2010 inline bool
2011 regex_match(_Bi_iter __first, _Bi_iter __last,
2012 const basic_regex<_Ch_type, _Rx_traits>& __re,
2013 regex_constants::match_flag_type __flags
2014 = regex_constants::match_default)
2015 {
2016 match_results<_Bi_iter> __what;
2017 return regex_match(__first, __last, __what, __re, __flags);
2018 }
2019
2020 /**
2021 * @brief Determines if there is a match between the regular expression @p e
2022 * and a C-style null-terminated string.
2023 *
2024 * @param __s The C-style null-terminated string to match.
2025 * @param __m The match results.
2026 * @param __re The regular expression.
2027 * @param __f Controls how the regular expression is matched.
2028 *
2029 * @retval true A match exists.
2030 * @retval false Otherwise.
2031 *
2032 * @throws an exception of type regex_error.
2033 */
2034 template<typename _Ch_type, typename _Alloc, typename _Rx_traits>
2035 inline bool
2036 regex_match(const _Ch_type* __s,
2037 match_results<const _Ch_type*, _Alloc>& __m,
2038 const basic_regex<_Ch_type, _Rx_traits>& __re,
2039 regex_constants::match_flag_type __f
2040 = regex_constants::match_default)
2041 { return regex_match(__s, __s + _Rx_traits::length(__s), __m, __re, __f); }
2042
2043 /**
2044 * @brief Determines if there is a match between the regular expression @p e
2045 * and a string.
2046 *
2047 * @param __s The string to match.
2048 * @param __m The match results.
2049 * @param __re The regular expression.
2050 * @param __flags Controls how the regular expression is matched.
2051 *
2052 * @retval true A match exists.
2053 * @retval false Otherwise.
2054 *
2055 * @throws an exception of type regex_error.
2056 */
2057 template<typename _Ch_traits, typename _Ch_alloc,
2058 typename _Alloc, typename _Ch_type, typename _Rx_traits>
2059 inline bool
2060 regex_match(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s,
2061 match_results<typename basic_string<_Ch_type,
2062 _Ch_traits, _Ch_alloc>::const_iterator, _Alloc>& __m,
2063 const basic_regex<_Ch_type, _Rx_traits>& __re,
2064 regex_constants::match_flag_type __flags
2065 = regex_constants::match_default)
2066 { return regex_match(__s.begin(), __s.end(), __m, __re, __flags); }
2067
2068 // _GLIBCXX_RESOLVE_LIB_DEFECTS
2069 // 2329. regex_match() with match_results should forbid temporary strings
2070 /// Prevent unsafe attempts to get match_results from a temporary string.
2071 template<typename _Ch_traits, typename _Ch_alloc,
2072 typename _Alloc, typename _Ch_type, typename _Rx_traits>
2073 bool
2074 regex_match(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>&&,
2075 match_results<typename basic_string<_Ch_type,
2076 _Ch_traits, _Ch_alloc>::const_iterator, _Alloc>&,
2077 const basic_regex<_Ch_type, _Rx_traits>&,
2078 regex_constants::match_flag_type
2079 = regex_constants::match_default) = delete;
2080
2081 /**
2082 * @brief Indicates if there is a match between the regular expression @p e
2083 * and a C-style null-terminated string.
2084 *
2085 * @param __s The C-style null-terminated string to match.
2086 * @param __re The regular expression.
2087 * @param __f Controls how the regular expression is matched.
2088 *
2089 * @retval true A match exists.
2090 * @retval false Otherwise.
2091 *
2092 * @throws an exception of type regex_error.
2093 */
2094 template<typename _Ch_type, class _Rx_traits>
2095 inline bool
2096 regex_match(const _Ch_type* __s,
2097 const basic_regex<_Ch_type, _Rx_traits>& __re,
2098 regex_constants::match_flag_type __f
2099 = regex_constants::match_default)
2100 { return regex_match(__s, __s + _Rx_traits::length(__s), __re, __f); }
2101
2102 /**
2103 * @brief Indicates if there is a match between the regular expression @p e
2104 * and a string.
2105 *
2106 * @param __s [IN] The string to match.
2107 * @param __re [IN] The regular expression.
2108 * @param __flags [IN] Controls how the regular expression is matched.
2109 *
2110 * @retval true A match exists.
2111 * @retval false Otherwise.
2112 *
2113 * @throws an exception of type regex_error.
2114 */
2115 template<typename _Ch_traits, typename _Str_allocator,
2116 typename _Ch_type, typename _Rx_traits>
2117 inline bool
2118 regex_match(const basic_string<_Ch_type, _Ch_traits, _Str_allocator>& __s,
2119 const basic_regex<_Ch_type, _Rx_traits>& __re,
2120 regex_constants::match_flag_type __flags
2121 = regex_constants::match_default)
2122 { return regex_match(__s.begin(), __s.end(), __re, __flags); }
2123
2124 // [7.11.3] Function template regex_search
2125 /**
2126 * Searches for a regular expression within a range.
2127 * @param __s [IN] The start of the string to search.
2128 * @param __e [IN] One-past-the-end of the string to search.
2129 * @param __m [OUT] The match results.
2130 * @param __re [IN] The regular expression to search for.
2131 * @param __flags [IN] Search policy flags.
2132 * @retval true A match was found within the string.
2133 * @retval false No match was found within the string, the content of %m is
2134 * undefined.
2135 *
2136 * @throws an exception of type regex_error.
2137 */
2138 template<typename _Bi_iter, typename _Alloc,
2139 typename _Ch_type, typename _Rx_traits>
2140 inline bool
2141 regex_search(_Bi_iter __s, _Bi_iter __e,
2142 match_results<_Bi_iter, _Alloc>& __m,
2143 const basic_regex<_Ch_type, _Rx_traits>& __re,
2144 regex_constants::match_flag_type __flags
2145 = regex_constants::match_default)
2146 {
2147 return __detail::__regex_algo_impl<_Bi_iter, _Alloc, _Ch_type, _Rx_traits,
2148 __detail::_RegexExecutorPolicy::_S_auto, false>
2149 (__s, __e, __m, __re, __flags);
2150 }
2151
2152 /**
2153 * Searches for a regular expression within a range.
2154 * @param __first [IN] The start of the string to search.
2155 * @param __last [IN] One-past-the-end of the string to search.
2156 * @param __re [IN] The regular expression to search for.
2157 * @param __flags [IN] Search policy flags.
2158 * @retval true A match was found within the string.
2159 * @retval false No match was found within the string.
2160 *
2161 * @throws an exception of type regex_error.
2162 */
2163 template<typename _Bi_iter, typename _Ch_type, typename _Rx_traits>
2164 inline bool
2165 regex_search(_Bi_iter __first, _Bi_iter __last,
2166 const basic_regex<_Ch_type, _Rx_traits>& __re,
2167 regex_constants::match_flag_type __flags
2168 = regex_constants::match_default)
2169 {
2170 match_results<_Bi_iter> __what;
2171 return regex_search(__first, __last, __what, __re, __flags);
2172 }
2173
2174 /**
2175 * @brief Searches for a regular expression within a C-string.
2176 * @param __s [IN] A C-string to search for the regex.
2177 * @param __m [OUT] The set of regex matches.
2178 * @param __e [IN] The regex to search for in @p s.
2179 * @param __f [IN] The search flags.
2180 * @retval true A match was found within the string.
2181 * @retval false No match was found within the string, the content of %m is
2182 * undefined.
2183 *
2184 * @throws an exception of type regex_error.
2185 */
2186 template<typename _Ch_type, class _Alloc, class _Rx_traits>
2187 inline bool
2188 regex_search(const _Ch_type* __s,
2189 match_results<const _Ch_type*, _Alloc>& __m,
2190 const basic_regex<_Ch_type, _Rx_traits>& __e,
2191 regex_constants::match_flag_type __f
2192 = regex_constants::match_default)
2193 { return regex_search(__s, __s + _Rx_traits::length(__s), __m, __e, __f); }
2194
2195 /**
2196 * @brief Searches for a regular expression within a C-string.
2197 * @param __s [IN] The C-string to search.
2198 * @param __e [IN] The regular expression to search for.
2199 * @param __f [IN] Search policy flags.
2200 * @retval true A match was found within the string.
2201 * @retval false No match was found within the string.
2202 *
2203 * @throws an exception of type regex_error.
2204 */
2205 template<typename _Ch_type, typename _Rx_traits>
2206 inline bool
2207 regex_search(const _Ch_type* __s,
2208 const basic_regex<_Ch_type, _Rx_traits>& __e,
2209 regex_constants::match_flag_type __f
2210 = regex_constants::match_default)
2211 { return regex_search(__s, __s + _Rx_traits::length(__s), __e, __f); }
2212
2213 /**
2214 * @brief Searches for a regular expression within a string.
2215 * @param __s [IN] The string to search.
2216 * @param __e [IN] The regular expression to search for.
2217 * @param __flags [IN] Search policy flags.
2218 * @retval true A match was found within the string.
2219 * @retval false No match was found within the string.
2220 *
2221 * @throws an exception of type regex_error.
2222 */
2223 template<typename _Ch_traits, typename _String_allocator,
2224 typename _Ch_type, typename _Rx_traits>
2225 inline bool
2226 regex_search(const basic_string<_Ch_type, _Ch_traits,
2227 _String_allocator>& __s,
2228 const basic_regex<_Ch_type, _Rx_traits>& __e,
2229 regex_constants::match_flag_type __flags
2230 = regex_constants::match_default)
2231 { return regex_search(__s.begin(), __s.end(), __e, __flags); }
2232
2233 /**
2234 * @brief Searches for a regular expression within a string.
2235 * @param __s [IN] A C++ string to search for the regex.
2236 * @param __m [OUT] The set of regex matches.
2237 * @param __e [IN] The regex to search for in @p s.
2238 * @param __f [IN] The search flags.
2239 * @retval true A match was found within the string.
2240 * @retval false No match was found within the string, the content of %m is
2241 * undefined.
2242 *
2243 * @throws an exception of type regex_error.
2244 */
2245 template<typename _Ch_traits, typename _Ch_alloc,
2246 typename _Alloc, typename _Ch_type,
2247 typename _Rx_traits>
2248 inline bool
2249 regex_search(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s,
2250 match_results<typename basic_string<_Ch_type,
2251 _Ch_traits, _Ch_alloc>::const_iterator, _Alloc>& __m,
2252 const basic_regex<_Ch_type, _Rx_traits>& __e,
2253 regex_constants::match_flag_type __f
2254 = regex_constants::match_default)
2255 { return regex_search(__s.begin(), __s.end(), __m, __e, __f); }
2256
2257 // _GLIBCXX_RESOLVE_LIB_DEFECTS
2258 // 2329. regex_search() with match_results should forbid temporary strings
2259 /// Prevent unsafe attempts to get match_results from a temporary string.
2260 template<typename _Ch_traits, typename _Ch_alloc,
2261 typename _Alloc, typename _Ch_type,
2262 typename _Rx_traits>
2263 bool
2264 regex_search(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>&&,
2265 match_results<typename basic_string<_Ch_type,
2266 _Ch_traits, _Ch_alloc>::const_iterator, _Alloc>&,
2267 const basic_regex<_Ch_type, _Rx_traits>&,
2268 regex_constants::match_flag_type
2269 = regex_constants::match_default) = delete;
2270
2271 // std [28.11.4] Function template regex_replace
2272 /**
2273 * @brief Search for a regular expression within a range for multiple times,
2274 and replace the matched parts through filling a format string.
2275 * @param __out [OUT] The output iterator.
2276 * @param __first [IN] The start of the string to search.
2277 * @param __last [IN] One-past-the-end of the string to search.
2278 * @param __e [IN] The regular expression to search for.
2279 * @param __fmt [IN] The format string.
2280 * @param __flags [IN] Search and replace policy flags.
2281 *
2282 * @returns __out
2283 * @throws an exception of type regex_error.
2284 */
2285 template<typename _Out_iter, typename _Bi_iter,
2286 typename _Rx_traits, typename _Ch_type,
2287 typename _St, typename _Sa>
2288 inline _Out_iter
2289 regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last,
2290 const basic_regex<_Ch_type, _Rx_traits>& __e,
2291 const basic_string<_Ch_type, _St, _Sa>& __fmt,
2292 regex_constants::match_flag_type __flags
2293 = regex_constants::match_default)
2294 {
2295 return regex_replace(__out, __first, __last, __e, __fmt.c_str(), __flags);
2296 }
2297
2298 /**
2299 * @brief Search for a regular expression within a range for multiple times,
2300 and replace the matched parts through filling a format C-string.
2301 * @param __out [OUT] The output iterator.
2302 * @param __first [IN] The start of the string to search.
2303 * @param __last [IN] One-past-the-end of the string to search.
2304 * @param __e [IN] The regular expression to search for.
2305 * @param __fmt [IN] The format C-string.
2306 * @param __flags [IN] Search and replace policy flags.
2307 *
2308 * @returns __out
2309 * @throws an exception of type regex_error.
2310 */
2311 template<typename _Out_iter, typename _Bi_iter,
2312 typename _Rx_traits, typename _Ch_type>
2313 _Out_iter
2314 regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last,
2315 const basic_regex<_Ch_type, _Rx_traits>& __e,
2316 const _Ch_type* __fmt,
2317 regex_constants::match_flag_type __flags
2318 = regex_constants::match_default);
2319
2320 /**
2321 * @brief Search for a regular expression within a string for multiple times,
2322 and replace the matched parts through filling a format string.
2323 * @param __s [IN] The string to search and replace.
2324 * @param __e [IN] The regular expression to search for.
2325 * @param __fmt [IN] The format string.
2326 * @param __flags [IN] Search and replace policy flags.
2327 *
2328 * @returns The string after replacing.
2329 * @throws an exception of type regex_error.
2330 */
2331 template<typename _Rx_traits, typename _Ch_type,
2332 typename _St, typename _Sa, typename _Fst, typename _Fsa>
2333 inline basic_string<_Ch_type, _St, _Sa>
2334 regex_replace(const basic_string<_Ch_type, _St, _Sa>& __s,
2335 const basic_regex<_Ch_type, _Rx_traits>& __e,
2336 const basic_string<_Ch_type, _Fst, _Fsa>& __fmt,
2337 regex_constants::match_flag_type __flags
2338 = regex_constants::match_default)
2339 {
2340 basic_string<_Ch_type, _St, _Sa> __result;
2341 regex_replace(std::back_inserter(__result),
2342 __s.begin(), __s.end(), __e, __fmt, __flags);
2343 return __result;
2344 }
2345
2346 /**
2347 * @brief Search for a regular expression within a string for multiple times,
2348 and replace the matched parts through filling a format C-string.
2349 * @param __s [IN] The string to search and replace.
2350 * @param __e [IN] The regular expression to search for.
2351 * @param __fmt [IN] The format C-string.
2352 * @param __flags [IN] Search and replace policy flags.
2353 *
2354 * @returns The string after replacing.
2355 * @throws an exception of type regex_error.
2356 */
2357 template<typename _Rx_traits, typename _Ch_type,
2358 typename _St, typename _Sa>
2359 inline basic_string<_Ch_type, _St, _Sa>
2360 regex_replace(const basic_string<_Ch_type, _St, _Sa>& __s,
2361 const basic_regex<_Ch_type, _Rx_traits>& __e,
2362 const _Ch_type* __fmt,
2363 regex_constants::match_flag_type __flags
2364 = regex_constants::match_default)
2365 {
2366 basic_string<_Ch_type, _St, _Sa> __result;
2367 regex_replace(std::back_inserter(__result),
2368 __s.begin(), __s.end(), __e, __fmt, __flags);
2369 return __result;
2370 }
2371
2372 /**
2373 * @brief Search for a regular expression within a C-string for multiple
2374 times, and replace the matched parts through filling a format string.
2375 * @param __s [IN] The C-string to search and replace.
2376 * @param __e [IN] The regular expression to search for.
2377 * @param __fmt [IN] The format string.
2378 * @param __flags [IN] Search and replace policy flags.
2379 *
2380 * @returns The string after replacing.
2381 * @throws an exception of type regex_error.
2382 */
2383 template<typename _Rx_traits, typename _Ch_type,
2384 typename _St, typename _Sa>
2385 inline basic_string<_Ch_type>
2386 regex_replace(const _Ch_type* __s,
2387 const basic_regex<_Ch_type, _Rx_traits>& __e,
2388 const basic_string<_Ch_type, _St, _Sa>& __fmt,
2389 regex_constants::match_flag_type __flags
2390 = regex_constants::match_default)
2391 {
2392 basic_string<_Ch_type> __result;
2393 regex_replace(std::back_inserter(__result), __s,
2394 __s + char_traits<_Ch_type>::length(__s),
2395 __e, __fmt, __flags);
2396 return __result;
2397 }
2398
2399 /**
2400 * @brief Search for a regular expression within a C-string for multiple
2401 times, and replace the matched parts through filling a format C-string.
2402 * @param __s [IN] The C-string to search and replace.
2403 * @param __e [IN] The regular expression to search for.
2404 * @param __fmt [IN] The format C-string.
2405 * @param __flags [IN] Search and replace policy flags.
2406 *
2407 * @returns The string after replacing.
2408 * @throws an exception of type regex_error.
2409 */
2410 template<typename _Rx_traits, typename _Ch_type>
2411 inline basic_string<_Ch_type>
2412 regex_replace(const _Ch_type* __s,
2413 const basic_regex<_Ch_type, _Rx_traits>& __e,
2414 const _Ch_type* __fmt,
2415 regex_constants::match_flag_type __flags
2416 = regex_constants::match_default)
2417 {
2418 basic_string<_Ch_type> __result;
2419 regex_replace(std::back_inserter(__result), __s,
2420 __s + char_traits<_Ch_type>::length(__s),
2421 __e, __fmt, __flags);
2422 return __result;
2423 }
2424
2425 //@}
2426
2427_GLIBCXX_BEGIN_NAMESPACE_CXX11
2428
2429 // std [28.12] Class template regex_iterator
2430 /**
2431 * An iterator adaptor that will provide repeated calls of regex_search over
2432 * a range until no more matches remain.
2433 */
2434 template<typename _Bi_iter,
2435 typename _Ch_type = typename iterator_traits<_Bi_iter>::value_type,
2436 typename _Rx_traits = regex_traits<_Ch_type> >
2437 class regex_iterator
2438 {
2439 public:
2440 typedef basic_regex<_Ch_type, _Rx_traits> regex_type;
2441 typedef match_results<_Bi_iter> value_type;
2442 typedef std::ptrdiff_t difference_type;
2443 typedef const value_type* pointer;
2444 typedef const value_type& reference;
2445 typedef std::forward_iterator_tag iterator_category;
2446
2447 /**
2448 * @brief Provides a singular iterator, useful for indicating
2449 * one-past-the-end of a range.
2450 */
2451 regex_iterator()
2452 : _M_pregex()
2453 { }
2454
2455 /**
2456 * Constructs a %regex_iterator...
2457 * @param __a [IN] The start of a text range to search.
2458 * @param __b [IN] One-past-the-end of the text range to search.
2459 * @param __re [IN] The regular expression to match.
2460 * @param __m [IN] Policy flags for match rules.
2461 */
2462 regex_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re,
2463 regex_constants::match_flag_type __m
2464 = regex_constants::match_default)
2465 : _M_begin(__a), _M_end(__b), _M_pregex(&__re), _M_flags(__m), _M_match()
2466 {
2467 if (!regex_search(_M_begin, _M_end, _M_match, *_M_pregex, _M_flags))
2468 *this = regex_iterator();
2469 }
2470
2471 // _GLIBCXX_RESOLVE_LIB_DEFECTS
2472 // 2332. regex_iterator should forbid temporary regexes
2473 regex_iterator(_Bi_iter, _Bi_iter, const regex_type&&,
2474 regex_constants::match_flag_type
2475 = regex_constants::match_default) = delete;
2476 /**
2477 * Copy constructs a %regex_iterator.
2478 */
2479 regex_iterator(const regex_iterator& __rhs) = default;
2480
2481 /**
2482 * @brief Assigns one %regex_iterator to another.
2483 */
2484 regex_iterator&
2485 operator=(const regex_iterator& __rhs) = default;
2486
2487 /**
2488 * @brief Tests the equivalence of two regex iterators.
2489 */
2490 bool
2491 operator==(const regex_iterator& __rhs) const;
2492
2493 /**
2494 * @brief Tests the inequivalence of two regex iterators.
2495 */
2496 bool
2497 operator!=(const regex_iterator& __rhs) const
2498 { return !(*this == __rhs); }
2499
2500 /**
2501 * @brief Dereferences a %regex_iterator.
2502 */
2503 const value_type&
2504 operator*() const
2505 { return _M_match; }
2506
2507 /**
2508 * @brief Selects a %regex_iterator member.
2509 */
2510 const value_type*
2511 operator->() const
2512 { return &_M_match; }
2513
2514 /**
2515 * @brief Increments a %regex_iterator.
2516 */
2517 regex_iterator&
2518 operator++();
2519
2520 /**
2521 * @brief Postincrements a %regex_iterator.
2522 */
2523 regex_iterator
2524 operator++(int)
2525 {
2526 auto __tmp = *this;
2527 ++(*this);
2528 return __tmp;
2529 }
2530
2531 private:
2532 _Bi_iter _M_begin;
2533 _Bi_iter _M_end;
2534 const regex_type* _M_pregex;
2535 regex_constants::match_flag_type _M_flags;
2536 match_results<_Bi_iter> _M_match;
2537 };
2538
2539 typedef regex_iterator<const char*> cregex_iterator;
2540 typedef regex_iterator<string::const_iterator> sregex_iterator;
2541#ifdef _GLIBCXX_USE_WCHAR_T
2542 typedef regex_iterator<const wchar_t*> wcregex_iterator;
2543 typedef regex_iterator<wstring::const_iterator> wsregex_iterator;
2544#endif
2545
2546 // [7.12.2] Class template regex_token_iterator
2547 /**
2548 * Iterates over submatches in a range (or @a splits a text string).
2549 *
2550 * The purpose of this iterator is to enumerate all, or all specified,
2551 * matches of a regular expression within a text range. The dereferenced
2552 * value of an iterator of this class is a std::sub_match object.
2553 */
2554 template<typename _Bi_iter,
2555 typename _Ch_type = typename iterator_traits<_Bi_iter>::value_type,
2556 typename _Rx_traits = regex_traits<_Ch_type> >
2557 class regex_token_iterator
2558 {
2559 public:
2560 typedef basic_regex<_Ch_type, _Rx_traits> regex_type;
2561 typedef sub_match<_Bi_iter> value_type;
2562 typedef std::ptrdiff_t difference_type;
2563 typedef const value_type* pointer;
2564 typedef const value_type& reference;
2565 typedef std::forward_iterator_tag iterator_category;
2566
2567 public:
2568 /**
2569 * @brief Default constructs a %regex_token_iterator.
2570 *
2571 * A default-constructed %regex_token_iterator is a singular iterator
2572 * that will compare equal to the one-past-the-end value for any
2573 * iterator of the same type.
2574 */
2575 regex_token_iterator()
2576 : _M_position(), _M_subs(), _M_suffix(), _M_n(0), _M_result(nullptr),
2577 _M_has_m1(false)
2578 { }
2579
2580 /**
2581 * Constructs a %regex_token_iterator...
2582 * @param __a [IN] The start of the text to search.
2583 * @param __b [IN] One-past-the-end of the text to search.
2584 * @param __re [IN] The regular expression to search for.
2585 * @param __submatch [IN] Which submatch to return. There are some
2586 * special values for this parameter:
2587 * - -1 each enumerated subexpression does NOT
2588 * match the regular expression (aka field
2589 * splitting)
2590 * - 0 the entire string matching the
2591 * subexpression is returned for each match
2592 * within the text.
2593 * - >0 enumerates only the indicated
2594 * subexpression from a match within the text.
2595 * @param __m [IN] Policy flags for match rules.
2596 */
2597 regex_token_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re,
2598 int __submatch = 0,
2599 regex_constants::match_flag_type __m
2600 = regex_constants::match_default)
2601 : _M_position(__a, __b, __re, __m), _M_subs(1, __submatch), _M_n(0)
2602 { _M_init(__a, __b); }
2603
2604 /**
2605 * Constructs a %regex_token_iterator...
2606 * @param __a [IN] The start of the text to search.
2607 * @param __b [IN] One-past-the-end of the text to search.
2608 * @param __re [IN] The regular expression to search for.
2609 * @param __submatches [IN] A list of subexpressions to return for each
2610 * regular expression match within the text.
2611 * @param __m [IN] Policy flags for match rules.
2612 */
2613 regex_token_iterator(_Bi_iter __a, _Bi_iter __b,
2614 const regex_type& __re,
2615 const std::vector<int>& __submatches,
2616 regex_constants::match_flag_type __m
2617 = regex_constants::match_default)
2618 : _M_position(__a, __b, __re, __m), _M_subs(__submatches), _M_n(0)
2619 { _M_init(__a, __b); }
2620
2621 /**
2622 * Constructs a %regex_token_iterator...
2623 * @param __a [IN] The start of the text to search.
2624 * @param __b [IN] One-past-the-end of the text to search.
2625 * @param __re [IN] The regular expression to search for.
2626 * @param __submatches [IN] A list of subexpressions to return for each
2627 * regular expression match within the text.
2628 * @param __m [IN] Policy flags for match rules.
2629 */
2630 regex_token_iterator(_Bi_iter __a, _Bi_iter __b,
2631 const regex_type& __re,
2632 initializer_list<int> __submatches,
2633 regex_constants::match_flag_type __m
2634 = regex_constants::match_default)
2635 : _M_position(__a, __b, __re, __m), _M_subs(__submatches), _M_n(0)
2636 { _M_init(__a, __b); }
2637
2638 /**
2639 * Constructs a %regex_token_iterator...
2640 * @param __a [IN] The start of the text to search.
2641 * @param __b [IN] One-past-the-end of the text to search.
2642 * @param __re [IN] The regular expression to search for.
2643 * @param __submatches [IN] A list of subexpressions to return for each
2644 * regular expression match within the text.
2645 * @param __m [IN] Policy flags for match rules.
2646 */
2647 template<std::size_t _Nm>
2648 regex_token_iterator(_Bi_iter __a, _Bi_iter __b,
2649 const regex_type& __re,
2650 const int (&__submatches)[_Nm],
2651 regex_constants::match_flag_type __m
2652 = regex_constants::match_default)
2653 : _M_position(__a, __b, __re, __m),
2654 _M_subs(__submatches, __submatches + _Nm), _M_n(0)
2655 { _M_init(__a, __b); }
2656
2657 // _GLIBCXX_RESOLVE_LIB_DEFECTS
2658 // 2332. regex_token_iterator should forbid temporary regexes
2659 regex_token_iterator(_Bi_iter, _Bi_iter, const regex_type&&, int = 0,
2660 regex_constants::match_flag_type =
2661 regex_constants::match_default) = delete;
2662 regex_token_iterator(_Bi_iter, _Bi_iter, const regex_type&&,
2663 const std::vector<int>&,
2664 regex_constants::match_flag_type =
2665 regex_constants::match_default) = delete;
2666 regex_token_iterator(_Bi_iter, _Bi_iter, const regex_type&&,
2667 initializer_list<int>,
2668 regex_constants::match_flag_type =
2669 regex_constants::match_default) = delete;
2670 template <std::size_t _Nm>
2671 regex_token_iterator(_Bi_iter, _Bi_iter, const regex_type&&,
2672 const int (&)[_Nm],
2673 regex_constants::match_flag_type =
2674 regex_constants::match_default) = delete;
2675
2676 /**
2677 * @brief Copy constructs a %regex_token_iterator.
2678 * @param __rhs [IN] A %regex_token_iterator to copy.
2679 */
2680 regex_token_iterator(const regex_token_iterator& __rhs)
2681 : _M_position(__rhs._M_position), _M_subs(__rhs._M_subs),
2682 _M_suffix(__rhs._M_suffix), _M_n(__rhs._M_n), _M_has_m1(__rhs._M_has_m1)
2683 { _M_normalize_result(); }
2684
2685 /**
2686 * @brief Assigns a %regex_token_iterator to another.
2687 * @param __rhs [IN] A %regex_token_iterator to copy.
2688 */
2689 regex_token_iterator&
2690 operator=(const regex_token_iterator& __rhs);
2691
2692 /**
2693 * @brief Compares a %regex_token_iterator to another for equality.
2694 */
2695 bool
2696 operator==(const regex_token_iterator& __rhs) const;
2697
2698 /**
2699 * @brief Compares a %regex_token_iterator to another for inequality.
2700 */
2701 bool
2702 operator!=(const regex_token_iterator& __rhs) const
2703 { return !(*this == __rhs); }
2704
2705 /**
2706 * @brief Dereferences a %regex_token_iterator.
2707 */
2708 const value_type&
2709 operator*() const
2710 { return *_M_result; }
2711
2712 /**
2713 * @brief Selects a %regex_token_iterator member.
2714 */
2715 const value_type*
2716 operator->() const
2717 { return _M_result; }
2718
2719 /**
2720 * @brief Increments a %regex_token_iterator.
2721 */
2722 regex_token_iterator&
2723 operator++();
2724
2725 /**
2726 * @brief Postincrements a %regex_token_iterator.
2727 */
2728 regex_token_iterator
2729 operator++(int)
2730 {
2731 auto __tmp = *this;
2732 ++(*this);
2733 return __tmp;
2734 }
2735
2736 private:
2737 typedef regex_iterator<_Bi_iter, _Ch_type, _Rx_traits> _Position;
2738
2739 void
2740 _M_init(_Bi_iter __a, _Bi_iter __b);
2741
2742 const value_type&
2743 _M_current_match() const
2744 {
2745 if (_M_subs[_M_n] == -1)
2746 return (*_M_position).prefix();
2747 else
2748 return (*_M_position)[_M_subs[_M_n]];
2749 }
2750
2751 constexpr bool
2752 _M_end_of_seq() const
2753 { return _M_result == nullptr; }
2754
2755 // [28.12.2.2.4]
2756 void
2757 _M_normalize_result()
2758 {
2759 if (_M_position != _Position())
2760 _M_result = &_M_current_match();
2761 else if (_M_has_m1)
2762 _M_result = &_M_suffix;
2763 else
2764 _M_result = nullptr;
2765 }
2766
2767 _Position _M_position;
2768 std::vector<int> _M_subs;
2769 value_type _M_suffix;
2770 std::size_t _M_n;
2771 const value_type* _M_result;
2772
2773 // Show whether _M_subs contains -1
2774 bool _M_has_m1;
2775 };
2776
2777 /** @brief Token iterator for C-style NULL-terminated strings. */
2778 typedef regex_token_iterator<const char*> cregex_token_iterator;
2779
2780 /** @brief Token iterator for standard strings. */
2781 typedef regex_token_iterator<string::const_iterator> sregex_token_iterator;
2782
2783#ifdef _GLIBCXX_USE_WCHAR_T
2784 /** @brief Token iterator for C-style NULL-terminated wide strings. */
2785 typedef regex_token_iterator<const wchar_t*> wcregex_token_iterator;
2786
2787 /** @brief Token iterator for standard wide-character strings. */
2788 typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;
2789#endif
2790
2791 //@} // group regex
2792
2793_GLIBCXX_END_NAMESPACE_CXX11
2794_GLIBCXX_END_NAMESPACE_VERSION
2795} // namespace
2796
2797#include <bits/regex.tcc>
2798