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