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