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