File Coverage

/usr/include/c++/5/bits/regex.h
Criterion Covered Total %
statement 0 68 0.0
branch 0 44 0.0
condition n/a
subroutine n/a
pod n/a
total 0 112 0.0


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