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