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