1// -*- C++ -*- 2//===--------------------------- regex ------------------------------------===// 3// 4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 5// See https://llvm.org/LICENSE.txt for license information. 6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 7// 8//===----------------------------------------------------------------------===// 9 10#ifndef _LIBCPP_REGEX 11#define _LIBCPP_REGEX 12 13/* 14 regex synopsis 15 16#include <initializer_list> 17 18namespace std 19{ 20 21namespace regex_constants 22{ 23 24emum syntax_option_type 25{ 26 icase = unspecified, 27 nosubs = unspecified, 28 optimize = unspecified, 29 collate = unspecified, 30 ECMAScript = unspecified, 31 basic = unspecified, 32 extended = unspecified, 33 awk = unspecified, 34 grep = unspecified, 35 egrep = unspecified 36}; 37 38constexpr syntax_option_type operator~(syntax_option_type f); 39constexpr syntax_option_type operator&(syntax_option_type lhs, syntax_option_type rhs); 40constexpr syntax_option_type operator|(syntax_option_type lhs, syntax_option_type rhs); 41 42enum match_flag_type 43{ 44 match_default = 0, 45 match_not_bol = unspecified, 46 match_not_eol = unspecified, 47 match_not_bow = unspecified, 48 match_not_eow = unspecified, 49 match_any = unspecified, 50 match_not_null = unspecified, 51 match_continuous = unspecified, 52 match_prev_avail = unspecified, 53 format_default = 0, 54 format_sed = unspecified, 55 format_no_copy = unspecified, 56 format_first_only = unspecified 57}; 58 59constexpr match_flag_type operator~(match_flag_type f); 60constexpr match_flag_type operator&(match_flag_type lhs, match_flag_type rhs); 61constexpr match_flag_type operator|(match_flag_type lhs, match_flag_type rhs); 62 63enum error_type 64{ 65 error_collate = unspecified, 66 error_ctype = unspecified, 67 error_escape = unspecified, 68 error_backref = unspecified, 69 error_brack = unspecified, 70 error_paren = unspecified, 71 error_brace = unspecified, 72 error_badbrace = unspecified, 73 error_range = unspecified, 74 error_space = unspecified, 75 error_badrepeat = unspecified, 76 error_complexity = unspecified, 77 error_stack = unspecified 78}; 79 80} // regex_constants 81 82class regex_error 83 : public runtime_error 84{ 85public: 86 explicit regex_error(regex_constants::error_type ecode); 87 regex_constants::error_type code() const; 88}; 89 90template <class charT> 91struct regex_traits 92{ 93public: 94 typedef charT char_type; 95 typedef basic_string<char_type> string_type; 96 typedef locale locale_type; 97 typedef /bitmask_type/ char_class_type; 98 99 regex_traits(); 100 101 static size_t length(const char_type* p); 102 charT translate(charT c) const; 103 charT translate_nocase(charT c) const; 104 template <class ForwardIterator> 105 string_type 106 transform(ForwardIterator first, ForwardIterator last) const; 107 template <class ForwardIterator> 108 string_type 109 transform_primary( ForwardIterator first, ForwardIterator last) const; 110 template <class ForwardIterator> 111 string_type 112 lookup_collatename(ForwardIterator first, ForwardIterator last) const; 113 template <class ForwardIterator> 114 char_class_type 115 lookup_classname(ForwardIterator first, ForwardIterator last, 116 bool icase = false) const; 117 bool isctype(charT c, char_class_type f) const; 118 int value(charT ch, int radix) const; 119 locale_type imbue(locale_type l); 120 locale_type getloc()const; 121}; 122 123template <class charT, class traits = regex_traits<charT>> 124class basic_regex 125{ 126public: 127 // types: 128 typedef charT value_type; 129 typedef traits traits_type; 130 typedef typename traits::string_type string_type; 131 typedef regex_constants::syntax_option_type flag_type; 132 typedef typename traits::locale_type locale_type; 133 134 // constants: 135 static constexpr regex_constants::syntax_option_type icase = regex_constants::icase; 136 static constexpr regex_constants::syntax_option_type nosubs = regex_constants::nosubs; 137 static constexpr regex_constants::syntax_option_type optimize = regex_constants::optimize; 138 static constexpr regex_constants::syntax_option_type collate = regex_constants::collate; 139 static constexpr regex_constants::syntax_option_type ECMAScript = regex_constants::ECMAScript; 140 static constexpr regex_constants::syntax_option_type basic = regex_constants::basic; 141 static constexpr regex_constants::syntax_option_type extended = regex_constants::extended; 142 static constexpr regex_constants::syntax_option_type awk = regex_constants::awk; 143 static constexpr regex_constants::syntax_option_type grep = regex_constants::grep; 144 static constexpr regex_constants::syntax_option_type egrep = regex_constants::egrep; 145 146 // construct/copy/destroy: 147 basic_regex(); 148 explicit basic_regex(const charT* p, flag_type f = regex_constants::ECMAScript); 149 basic_regex(const charT* p, size_t len, flag_type f = regex_constants::ECMAScript); 150 basic_regex(const basic_regex&); 151 basic_regex(basic_regex&&) noexcept; 152 template <class ST, class SA> 153 explicit basic_regex(const basic_string<charT, ST, SA>& p, 154 flag_type f = regex_constants::ECMAScript); 155 template <class ForwardIterator> 156 basic_regex(ForwardIterator first, ForwardIterator last, 157 flag_type f = regex_constants::ECMAScript); 158 basic_regex(initializer_list<charT>, flag_type = regex_constants::ECMAScript); 159 160 ~basic_regex(); 161 162 basic_regex& operator=(const basic_regex&); 163 basic_regex& operator=(basic_regex&&) noexcept; 164 basic_regex& operator=(const charT* ptr); 165 basic_regex& operator=(initializer_list<charT> il); 166 template <class ST, class SA> 167 basic_regex& operator=(const basic_string<charT, ST, SA>& p); 168 169 // assign: 170 basic_regex& assign(const basic_regex& that); 171 basic_regex& assign(basic_regex&& that) noexcept; 172 basic_regex& assign(const charT* ptr, flag_type f = regex_constants::ECMAScript); 173 basic_regex& assign(const charT* p, size_t len, flag_type f = regex_constants::ECMAScript); 174 template <class string_traits, class A> 175 basic_regex& assign(const basic_string<charT, string_traits, A>& s, 176 flag_type f = regex_constants::ECMAScript); 177 template <class InputIterator> 178 basic_regex& assign(InputIterator first, InputIterator last, 179 flag_type f = regex_constants::ECMAScript); 180 basic_regex& assign(initializer_list<charT>, flag_type f = regex_constants::ECMAScript); 181 182 // const operations: 183 unsigned mark_count() const; 184 flag_type flags() const; 185 186 // locale: 187 locale_type imbue(locale_type loc); 188 locale_type getloc() const; 189 190 // swap: 191 void swap(basic_regex&); 192}; 193 194template<class ForwardIterator> 195basic_regex(ForwardIterator, ForwardIterator, 196 regex_constants::syntax_option_type = regex_constants::ECMAScript) 197 -> basic_regex<typename iterator_traits<ForwardIterator>::value_type>; // C++17 198 199typedef basic_regex<char> regex; 200typedef basic_regex<wchar_t> wregex; 201 202template <class charT, class traits> 203 void swap(basic_regex<charT, traits>& e1, basic_regex<charT, traits>& e2); 204 205template <class BidirectionalIterator> 206class sub_match 207 : public pair<BidirectionalIterator, BidirectionalIterator> 208{ 209public: 210 typedef typename iterator_traits<BidirectionalIterator>::value_type value_type; 211 typedef typename iterator_traits<BidirectionalIterator>::difference_type difference_type; 212 typedef BidirectionalIterator iterator; 213 typedef basic_string<value_type> string_type; 214 215 bool matched; 216 217 constexpr sub_match(); 218 219 difference_type length() const; 220 operator string_type() const; 221 string_type str() const; 222 223 int compare(const sub_match& s) const; 224 int compare(const string_type& s) const; 225 int compare(const value_type* s) const; 226}; 227 228typedef sub_match<const char*> csub_match; 229typedef sub_match<const wchar_t*> wcsub_match; 230typedef sub_match<string::const_iterator> ssub_match; 231typedef sub_match<wstring::const_iterator> wssub_match; 232 233template <class BiIter> 234 bool 235 operator==(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs); 236 237template <class BiIter> 238 bool 239 operator!=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs); 240 241template <class BiIter> 242 bool 243 operator<(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs); 244 245template <class BiIter> 246 bool 247 operator<=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs); 248 249template <class BiIter> 250 bool 251 operator>=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs); 252 253template <class BiIter> 254 bool 255 operator>(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs); 256 257template <class BiIter, class ST, class SA> 258 bool 259 operator==(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs, 260 const sub_match<BiIter>& rhs); 261 262template <class BiIter, class ST, class SA> 263 bool 264 operator!=(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs, 265 const sub_match<BiIter>& rhs); 266 267template <class BiIter, class ST, class SA> 268 bool 269 operator<(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs, 270 const sub_match<BiIter>& rhs); 271 272template <class BiIter, class ST, class SA> 273 bool 274 operator>(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs, 275 const sub_match<BiIter>& rhs); 276 277template <class BiIter, class ST, class SA> 278 bool operator>=(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs, 279 const sub_match<BiIter>& rhs); 280 281template <class BiIter, class ST, class SA> 282 bool 283 operator<=(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs, 284 const sub_match<BiIter>& rhs); 285 286template <class BiIter, class ST, class SA> 287 bool 288 operator==(const sub_match<BiIter>& lhs, 289 const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs); 290 291template <class BiIter, class ST, class SA> 292 bool 293 operator!=(const sub_match<BiIter>& lhs, 294 const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs); 295 296template <class BiIter, class ST, class SA> 297 bool 298 operator<(const sub_match<BiIter>& lhs, 299 const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs); 300 301template <class BiIter, class ST, class SA> 302 bool operator>(const sub_match<BiIter>& lhs, 303 const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs); 304 305template <class BiIter, class ST, class SA> 306 bool 307 operator>=(const sub_match<BiIter>& lhs, 308 const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs); 309 310template <class BiIter, class ST, class SA> 311 bool 312 operator<=(const sub_match<BiIter>& lhs, 313 const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs); 314 315template <class BiIter> 316 bool 317 operator==(typename iterator_traits<BiIter>::value_type const* lhs, 318 const sub_match<BiIter>& rhs); 319 320template <class BiIter> 321 bool 322 operator!=(typename iterator_traits<BiIter>::value_type const* lhs, 323 const sub_match<BiIter>& rhs); 324 325template <class BiIter> 326 bool 327 operator<(typename iterator_traits<BiIter>::value_type const* lhs, 328 const sub_match<BiIter>& rhs); 329 330template <class BiIter> 331 bool 332 operator>(typename iterator_traits<BiIter>::value_type const* lhs, 333 const sub_match<BiIter>& rhs); 334 335template <class BiIter> 336 bool 337 operator>=(typename iterator_traits<BiIter>::value_type const* lhs, 338 const sub_match<BiIter>& rhs); 339 340template <class BiIter> 341 bool 342 operator<=(typename iterator_traits<BiIter>::value_type const* lhs, 343 const sub_match<BiIter>& rhs); 344 345template <class BiIter> 346 bool 347 operator==(const sub_match<BiIter>& lhs, 348 typename iterator_traits<BiIter>::value_type const* rhs); 349 350template <class BiIter> 351 bool 352 operator!=(const sub_match<BiIter>& lhs, 353 typename iterator_traits<BiIter>::value_type const* rhs); 354 355template <class BiIter> 356 bool 357 operator<(const sub_match<BiIter>& lhs, 358 typename iterator_traits<BiIter>::value_type const* rhs); 359 360template <class BiIter> 361 bool 362 operator>(const sub_match<BiIter>& lhs, 363 typename iterator_traits<BiIter>::value_type const* rhs); 364 365template <class BiIter> 366 bool 367 operator>=(const sub_match<BiIter>& lhs, 368 typename iterator_traits<BiIter>::value_type const* rhs); 369 370template <class BiIter> 371 bool 372 operator<=(const sub_match<BiIter>& lhs, 373 typename iterator_traits<BiIter>::value_type const* rhs); 374 375template <class BiIter> 376 bool 377 operator==(typename iterator_traits<BiIter>::value_type const& lhs, 378 const sub_match<BiIter>& rhs); 379 380template <class BiIter> 381 bool 382 operator!=(typename iterator_traits<BiIter>::value_type const& lhs, 383 const sub_match<BiIter>& rhs); 384 385template <class BiIter> 386 bool 387 operator<(typename iterator_traits<BiIter>::value_type const& lhs, 388 const sub_match<BiIter>& rhs); 389 390template <class BiIter> 391 bool 392 operator>(typename iterator_traits<BiIter>::value_type const& lhs, 393 const sub_match<BiIter>& rhs); 394 395template <class BiIter> 396 bool 397 operator>=(typename iterator_traits<BiIter>::value_type const& lhs, 398 const sub_match<BiIter>& rhs); 399 400template <class BiIter> 401 bool 402 operator<=(typename iterator_traits<BiIter>::value_type const& lhs, 403 const sub_match<BiIter>& rhs); 404 405template <class BiIter> 406 bool 407 operator==(const sub_match<BiIter>& lhs, 408 typename iterator_traits<BiIter>::value_type const& rhs); 409 410template <class BiIter> 411 bool 412 operator!=(const sub_match<BiIter>& lhs, 413 typename iterator_traits<BiIter>::value_type const& rhs); 414 415template <class BiIter> 416 bool 417 operator<(const sub_match<BiIter>& lhs, 418 typename iterator_traits<BiIter>::value_type const& rhs); 419 420template <class BiIter> 421 bool 422 operator>(const sub_match<BiIter>& lhs, 423 typename iterator_traits<BiIter>::value_type const& rhs); 424 425template <class BiIter> 426 bool 427 operator>=(const sub_match<BiIter>& lhs, 428 typename iterator_traits<BiIter>::value_type const& rhs); 429 430template <class BiIter> 431 bool 432 operator<=(const sub_match<BiIter>& lhs, 433 typename iterator_traits<BiIter>::value_type const& rhs); 434 435template <class charT, class ST, class BiIter> 436 basic_ostream<charT, ST>& 437 operator<<(basic_ostream<charT, ST>& os, const sub_match<BiIter>& m); 438 439template <class BidirectionalIterator, 440 class Allocator = allocator<sub_match<BidirectionalIterator>>> 441class match_results 442{ 443public: 444 typedef sub_match<BidirectionalIterator> value_type; 445 typedef const value_type& const_reference; 446 typedef value_type& reference; 447 typedef /implementation-defined/ const_iterator; 448 typedef const_iterator iterator; 449 typedef typename iterator_traits<BidirectionalIterator>::difference_type difference_type; 450 typedef typename allocator_traits<Allocator>::size_type size_type; 451 typedef Allocator allocator_type; 452 typedef typename iterator_traits<BidirectionalIterator>::value_type char_type; 453 typedef basic_string<char_type> string_type; 454 455 // construct/copy/destroy: 456 explicit match_results(const Allocator& a = Allocator()); 457 match_results(const match_results& m); 458 match_results(match_results&& m) noexcept; 459 match_results& operator=(const match_results& m); 460 match_results& operator=(match_results&& m); 461 ~match_results(); 462 463 bool ready() const; 464 465 // size: 466 size_type size() const; 467 size_type max_size() const; 468 bool empty() const; 469 470 // element access: 471 difference_type length(size_type sub = 0) const; 472 difference_type position(size_type sub = 0) const; 473 string_type str(size_type sub = 0) const; 474 const_reference operator[](size_type n) const; 475 476 const_reference prefix() const; 477 const_reference suffix() const; 478 479 const_iterator begin() const; 480 const_iterator end() const; 481 const_iterator cbegin() const; 482 const_iterator cend() const; 483 484 // format: 485 template <class OutputIter> 486 OutputIter 487 format(OutputIter out, const char_type* fmt_first, 488 const char_type* fmt_last, 489 regex_constants::match_flag_type flags = regex_constants::format_default) const; 490 template <class OutputIter, class ST, class SA> 491 OutputIter 492 format(OutputIter out, const basic_string<char_type, ST, SA>& fmt, 493 regex_constants::match_flag_type flags = regex_constants::format_default) const; 494 template <class ST, class SA> 495 basic_string<char_type, ST, SA> 496 format(const basic_string<char_type, ST, SA>& fmt, 497 regex_constants::match_flag_type flags = regex_constants::format_default) const; 498 string_type 499 format(const char_type* fmt, 500 regex_constants::match_flag_type flags = regex_constants::format_default) const; 501 502 // allocator: 503 allocator_type get_allocator() const; 504 505 // swap: 506 void swap(match_results& that); 507}; 508 509typedef match_results<const char*> cmatch; 510typedef match_results<const wchar_t*> wcmatch; 511typedef match_results<string::const_iterator> smatch; 512typedef match_results<wstring::const_iterator> wsmatch; 513 514template <class BidirectionalIterator, class Allocator> 515 bool 516 operator==(const match_results<BidirectionalIterator, Allocator>& m1, 517 const match_results<BidirectionalIterator, Allocator>& m2); 518 519template <class BidirectionalIterator, class Allocator> 520 bool 521 operator!=(const match_results<BidirectionalIterator, Allocator>& m1, 522 const match_results<BidirectionalIterator, Allocator>& m2); 523 524template <class BidirectionalIterator, class Allocator> 525 void 526 swap(match_results<BidirectionalIterator, Allocator>& m1, 527 match_results<BidirectionalIterator, Allocator>& m2); 528 529template <class BidirectionalIterator, class Allocator, class charT, class traits> 530 bool 531 regex_match(BidirectionalIterator first, BidirectionalIterator last, 532 match_results<BidirectionalIterator, Allocator>& m, 533 const basic_regex<charT, traits>& e, 534 regex_constants::match_flag_type flags = regex_constants::match_default); 535 536template <class BidirectionalIterator, class charT, class traits> 537 bool 538 regex_match(BidirectionalIterator first, BidirectionalIterator last, 539 const basic_regex<charT, traits>& e, 540 regex_constants::match_flag_type flags = regex_constants::match_default); 541 542template <class charT, class Allocator, class traits> 543 bool 544 regex_match(const charT* str, match_results<const charT*, Allocator>& m, 545 const basic_regex<charT, traits>& e, 546 regex_constants::match_flag_type flags = regex_constants::match_default); 547 548template <class ST, class SA, class Allocator, class charT, class traits> 549 bool 550 regex_match(const basic_string<charT, ST, SA>& s, 551 match_results<typename basic_string<charT, ST, SA>::const_iterator, Allocator>& m, 552 const basic_regex<charT, traits>& e, 553 regex_constants::match_flag_type flags = regex_constants::match_default); 554 555template <class ST, class SA, class Allocator, class charT, class traits> 556 bool 557 regex_match(const basic_string<charT, ST, SA>&& s, 558 match_results<typename basic_string<charT, ST, SA>::const_iterator, Allocator>& m, 559 const basic_regex<charT, traits>& e, 560 regex_constants::match_flag_type flags = regex_constants::match_default) = delete; // C++14 561 562template <class charT, class traits> 563 bool 564 regex_match(const charT* str, const basic_regex<charT, traits>& e, 565 regex_constants::match_flag_type flags = regex_constants::match_default); 566 567template <class ST, class SA, class charT, class traits> 568 bool 569 regex_match(const basic_string<charT, ST, SA>& s, 570 const basic_regex<charT, traits>& e, 571 regex_constants::match_flag_type flags = regex_constants::match_default); 572 573template <class BidirectionalIterator, class Allocator, class charT, class traits> 574 bool 575 regex_search(BidirectionalIterator first, BidirectionalIterator last, 576 match_results<BidirectionalIterator, Allocator>& m, 577 const basic_regex<charT, traits>& e, 578 regex_constants::match_flag_type flags = regex_constants::match_default); 579 580template <class BidirectionalIterator, class charT, class traits> 581 bool 582 regex_search(BidirectionalIterator first, BidirectionalIterator last, 583 const basic_regex<charT, traits>& e, 584 regex_constants::match_flag_type flags = regex_constants::match_default); 585 586template <class charT, class Allocator, class traits> 587 bool 588 regex_search(const charT* str, match_results<const charT*, Allocator>& m, 589 const basic_regex<charT, traits>& e, 590 regex_constants::match_flag_type flags = regex_constants::match_default); 591 592template <class charT, class traits> 593 bool 594 regex_search(const charT* str, const basic_regex<charT, traits>& e, 595 regex_constants::match_flag_type flags = regex_constants::match_default); 596 597template <class ST, class SA, class charT, class traits> 598 bool 599 regex_search(const basic_string<charT, ST, SA>& s, 600 const basic_regex<charT, traits>& e, 601 regex_constants::match_flag_type flags = regex_constants::match_default); 602 603template <class ST, class SA, class Allocator, class charT, class traits> 604 bool 605 regex_search(const basic_string<charT, ST, SA>& s, 606 match_results<typename basic_string<charT, ST, SA>::const_iterator, Allocator>& m, 607 const basic_regex<charT, traits>& e, 608 regex_constants::match_flag_type flags = regex_constants::match_default); 609 610template <class ST, class SA, class Allocator, class charT, class traits> 611 bool 612 regex_search(const basic_string<charT, ST, SA>&& s, 613 match_results<typename basic_string<charT, ST, SA>::const_iterator, Allocator>& m, 614 const basic_regex<charT, traits>& e, 615 regex_constants::match_flag_type flags = regex_constants::match_default) = delete; // C++14 616 617template <class OutputIterator, class BidirectionalIterator, 618 class traits, class charT, class ST, class SA> 619 OutputIterator 620 regex_replace(OutputIterator out, 621 BidirectionalIterator first, BidirectionalIterator last, 622 const basic_regex<charT, traits>& e, 623 const basic_string<charT, ST, SA>& fmt, 624 regex_constants::match_flag_type flags = regex_constants::match_default); 625 626template <class OutputIterator, class BidirectionalIterator, 627 class traits, class charT> 628 OutputIterator 629 regex_replace(OutputIterator out, 630 BidirectionalIterator first, BidirectionalIterator last, 631 const basic_regex<charT, traits>& e, const charT* fmt, 632 regex_constants::match_flag_type flags = regex_constants::match_default); 633 634template <class traits, class charT, class ST, class SA, class FST, class FSA>> 635 basic_string<charT, ST, SA> 636 regex_replace(const basic_string<charT, ST, SA>& s, 637 const basic_regex<charT, traits>& e, 638 const basic_string<charT, FST, FSA>& fmt, 639 regex_constants::match_flag_type flags = regex_constants::match_default); 640 641template <class traits, class charT, class ST, class SA> 642 basic_string<charT, ST, SA> 643 regex_replace(const basic_string<charT, ST, SA>& s, 644 const basic_regex<charT, traits>& e, const charT* fmt, 645 regex_constants::match_flag_type flags = regex_constants::match_default); 646 647template <class traits, class charT, class ST, class SA> 648 basic_string<charT> 649 regex_replace(const charT* s, 650 const basic_regex<charT, traits>& e, 651 const basic_string<charT, ST, SA>& fmt, 652 regex_constants::match_flag_type flags = regex_constants::match_default); 653 654template <class traits, class charT> 655 basic_string<charT> 656 regex_replace(const charT* s, 657 const basic_regex<charT, traits>& e, 658 const charT* fmt, 659 regex_constants::match_flag_type flags = regex_constants::match_default); 660 661template <class BidirectionalIterator, 662 class charT = typename iterator_traits< BidirectionalIterator>::value_type, 663 class traits = regex_traits<charT>> 664class regex_iterator 665{ 666public: 667 typedef basic_regex<charT, traits> regex_type; 668 typedef match_results<BidirectionalIterator> value_type; 669 typedef ptrdiff_t difference_type; 670 typedef const value_type* pointer; 671 typedef const value_type& reference; 672 typedef forward_iterator_tag iterator_category; 673 674 regex_iterator(); 675 regex_iterator(BidirectionalIterator a, BidirectionalIterator b, 676 const regex_type& re, 677 regex_constants::match_flag_type m = regex_constants::match_default); 678 regex_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b, 679 const regex_type&& __re, 680 regex_constants::match_flag_type __m 681 = regex_constants::match_default) = delete; // C++14 682 regex_iterator(const regex_iterator&); 683 regex_iterator& operator=(const regex_iterator&); 684 685 bool operator==(const regex_iterator&) const; 686 bool operator!=(const regex_iterator&) const; 687 688 const value_type& operator*() const; 689 const value_type* operator->() const; 690 691 regex_iterator& operator++(); 692 regex_iterator operator++(int); 693}; 694 695typedef regex_iterator<const char*> cregex_iterator; 696typedef regex_iterator<const wchar_t*> wcregex_iterator; 697typedef regex_iterator<string::const_iterator> sregex_iterator; 698typedef regex_iterator<wstring::const_iterator> wsregex_iterator; 699 700template <class BidirectionalIterator, 701 class charT = typename iterator_traits< BidirectionalIterator>::value_type, 702 class traits = regex_traits<charT>> 703class regex_token_iterator 704{ 705public: 706 typedef basic_regex<charT, traits> regex_type; 707 typedef sub_match<BidirectionalIterator> value_type; 708 typedef ptrdiff_t difference_type; 709 typedef const value_type* pointer; 710 typedef const value_type& reference; 711 typedef forward_iterator_tag iterator_category; 712 713 regex_token_iterator(); 714 regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, 715 const regex_type& re, int submatch = 0, 716 regex_constants::match_flag_type m = regex_constants::match_default); 717 regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, 718 const regex_type&& re, int submatch = 0, 719 regex_constants::match_flag_type m = regex_constants::match_default) = delete; // C++14 720 regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, 721 const regex_type& re, const vector<int>& submatches, 722 regex_constants::match_flag_type m = regex_constants::match_default); 723 regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, 724 const regex_type&& re, const vector<int>& submatches, 725 regex_constants::match_flag_type m = regex_constants::match_default) = delete; // C++14 726 regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, 727 const regex_type& re, initializer_list<int> submatches, 728 regex_constants::match_flag_type m = regex_constants::match_default); 729 regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, 730 const regex_type&& re, initializer_list<int> submatches, 731 regex_constants::match_flag_type m = regex_constants::match_default) = delete; // C++14 732 template <size_t N> 733 regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, 734 const regex_type& re, const int (&submatches)[N], 735 regex_constants::match_flag_type m = regex_constants::match_default); 736 template <size_t N> 737 regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, 738 const regex_type& re, const int (&submatches)[N], 739 regex_constants::match_flag_type m = regex_constants::match_default) = delete // C++14; 740 regex_token_iterator(const regex_token_iterator&); 741 regex_token_iterator& operator=(const regex_token_iterator&); 742 743 bool operator==(const regex_token_iterator&) const; 744 bool operator!=(const regex_token_iterator&) const; 745 746 const value_type& operator*() const; 747 const value_type* operator->() const; 748 749 regex_token_iterator& operator++(); 750 regex_token_iterator operator++(int); 751}; 752 753typedef regex_token_iterator<const char*> cregex_token_iterator; 754typedef regex_token_iterator<const wchar_t*> wcregex_token_iterator; 755typedef regex_token_iterator<string::const_iterator> sregex_token_iterator; 756typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator; 757 758} // std 759*/ 760 761#include <__config> 762#include <stdexcept> 763#include <__locale> 764#include <initializer_list> 765#include <utility> 766#include <iterator> 767#include <string> 768#include <memory> 769#include <vector> 770#include <deque> 771#include <version> 772 773#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 774#pragma GCC system_header 775#endif 776 777_LIBCPP_PUSH_MACROS 778#include <__undef_macros> 779 780 781#define _LIBCPP_REGEX_COMPLEXITY_FACTOR 4096 782 783_LIBCPP_BEGIN_NAMESPACE_STD 784 785namespace regex_constants 786{ 787 788// syntax_option_type 789 790enum syntax_option_type 791{ 792 icase = 1 << 0, 793 nosubs = 1 << 1, 794 optimize = 1 << 2, 795 collate = 1 << 3, 796#ifdef _LIBCPP_ABI_REGEX_CONSTANTS_NONZERO 797 ECMAScript = 1 << 9, 798#else 799 ECMAScript = 0, 800#endif 801 basic = 1 << 4, 802 extended = 1 << 5, 803 awk = 1 << 6, 804 grep = 1 << 7, 805 egrep = 1 << 8 806}; 807 808inline _LIBCPP_CONSTEXPR 809syntax_option_type __get_grammar(syntax_option_type __g) 810{ 811#ifdef _LIBCPP_ABI_REGEX_CONSTANTS_NONZERO 812 return static_cast<syntax_option_type>(__g & 0x3F0); 813#else 814 return static_cast<syntax_option_type>(__g & 0x1F0); 815#endif 816} 817 818inline _LIBCPP_INLINE_VISIBILITY 819_LIBCPP_CONSTEXPR 820syntax_option_type 821operator~(syntax_option_type __x) 822{ 823 return syntax_option_type(~int(__x) & 0x1FF); 824} 825 826inline _LIBCPP_INLINE_VISIBILITY 827_LIBCPP_CONSTEXPR 828syntax_option_type 829operator&(syntax_option_type __x, syntax_option_type __y) 830{ 831 return syntax_option_type(int(__x) & int(__y)); 832} 833 834inline _LIBCPP_INLINE_VISIBILITY 835_LIBCPP_CONSTEXPR 836syntax_option_type 837operator|(syntax_option_type __x, syntax_option_type __y) 838{ 839 return syntax_option_type(int(__x) | int(__y)); 840} 841 842inline _LIBCPP_INLINE_VISIBILITY 843_LIBCPP_CONSTEXPR 844syntax_option_type 845operator^(syntax_option_type __x, syntax_option_type __y) 846{ 847 return syntax_option_type(int(__x) ^ int(__y)); 848} 849 850inline _LIBCPP_INLINE_VISIBILITY 851syntax_option_type& 852operator&=(syntax_option_type& __x, syntax_option_type __y) 853{ 854 __x = __x & __y; 855 return __x; 856} 857 858inline _LIBCPP_INLINE_VISIBILITY 859syntax_option_type& 860operator|=(syntax_option_type& __x, syntax_option_type __y) 861{ 862 __x = __x | __y; 863 return __x; 864} 865 866inline _LIBCPP_INLINE_VISIBILITY 867syntax_option_type& 868operator^=(syntax_option_type& __x, syntax_option_type __y) 869{ 870 __x = __x ^ __y; 871 return __x; 872} 873 874// match_flag_type 875 876enum match_flag_type 877{ 878 match_default = 0, 879 match_not_bol = 1 << 0, 880 match_not_eol = 1 << 1, 881 match_not_bow = 1 << 2, 882 match_not_eow = 1 << 3, 883 match_any = 1 << 4, 884 match_not_null = 1 << 5, 885 match_continuous = 1 << 6, 886 match_prev_avail = 1 << 7, 887 format_default = 0, 888 format_sed = 1 << 8, 889 format_no_copy = 1 << 9, 890 format_first_only = 1 << 10, 891 __no_update_pos = 1 << 11, 892 __full_match = 1 << 12 893}; 894 895inline _LIBCPP_INLINE_VISIBILITY 896_LIBCPP_CONSTEXPR 897match_flag_type 898operator~(match_flag_type __x) 899{ 900 return match_flag_type(~int(__x) & 0x0FFF); 901} 902 903inline _LIBCPP_INLINE_VISIBILITY 904_LIBCPP_CONSTEXPR 905match_flag_type 906operator&(match_flag_type __x, match_flag_type __y) 907{ 908 return match_flag_type(int(__x) & int(__y)); 909} 910 911inline _LIBCPP_INLINE_VISIBILITY 912_LIBCPP_CONSTEXPR 913match_flag_type 914operator|(match_flag_type __x, match_flag_type __y) 915{ 916 return match_flag_type(int(__x) | int(__y)); 917} 918 919inline _LIBCPP_INLINE_VISIBILITY 920_LIBCPP_CONSTEXPR 921match_flag_type 922operator^(match_flag_type __x, match_flag_type __y) 923{ 924 return match_flag_type(int(__x) ^ int(__y)); 925} 926 927inline _LIBCPP_INLINE_VISIBILITY 928match_flag_type& 929operator&=(match_flag_type& __x, match_flag_type __y) 930{ 931 __x = __x & __y; 932 return __x; 933} 934 935inline _LIBCPP_INLINE_VISIBILITY 936match_flag_type& 937operator|=(match_flag_type& __x, match_flag_type __y) 938{ 939 __x = __x | __y; 940 return __x; 941} 942 943inline _LIBCPP_INLINE_VISIBILITY 944match_flag_type& 945operator^=(match_flag_type& __x, match_flag_type __y) 946{ 947 __x = __x ^ __y; 948 return __x; 949} 950 951enum error_type 952{ 953 error_collate = 1, 954 error_ctype, 955 error_escape, 956 error_backref, 957 error_brack, 958 error_paren, 959 error_brace, 960 error_badbrace, 961 error_range, 962 error_space, 963 error_badrepeat, 964 error_complexity, 965 error_stack, 966 __re_err_grammar, 967 __re_err_empty, 968 __re_err_unknown 969}; 970 971} // regex_constants 972 973class _LIBCPP_EXCEPTION_ABI regex_error 974 : public runtime_error 975{ 976 regex_constants::error_type __code_; 977public: 978 explicit regex_error(regex_constants::error_type __ecode); 979 virtual ~regex_error() throw(); 980 _LIBCPP_INLINE_VISIBILITY 981 regex_constants::error_type code() const {return __code_;} 982}; 983 984template <regex_constants::error_type _Ev> 985_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY 986void __throw_regex_error() 987{ 988#ifndef _LIBCPP_NO_EXCEPTIONS 989 throw regex_error(_Ev); 990#else 991 _VSTD::abort(); 992#endif 993} 994 995template <class _CharT> 996struct _LIBCPP_TEMPLATE_VIS regex_traits 997{ 998public: 999 typedef _CharT char_type; 1000 typedef basic_string<char_type> string_type; 1001 typedef locale locale_type; 1002 typedef ctype_base::mask char_class_type; 1003 1004 static const char_class_type __regex_word = ctype_base::__regex_word; 1005private: 1006 locale __loc_; 1007 const ctype<char_type>* __ct_; 1008 const collate<char_type>* __col_; 1009 1010public: 1011 regex_traits(); 1012 1013 _LIBCPP_INLINE_VISIBILITY 1014 static size_t length(const char_type* __p) 1015 {return char_traits<char_type>::length(__p);} 1016 _LIBCPP_INLINE_VISIBILITY 1017 char_type translate(char_type __c) const {return __c;} 1018 char_type translate_nocase(char_type __c) const; 1019 template <class _ForwardIterator> 1020 string_type 1021 transform(_ForwardIterator __f, _ForwardIterator __l) const; 1022 template <class _ForwardIterator> 1023 _LIBCPP_INLINE_VISIBILITY 1024 string_type 1025 transform_primary( _ForwardIterator __f, _ForwardIterator __l) const 1026 {return __transform_primary(__f, __l, char_type());} 1027 template <class _ForwardIterator> 1028 _LIBCPP_INLINE_VISIBILITY 1029 string_type 1030 lookup_collatename(_ForwardIterator __f, _ForwardIterator __l) const 1031 {return __lookup_collatename(__f, __l, char_type());} 1032 template <class _ForwardIterator> 1033 _LIBCPP_INLINE_VISIBILITY 1034 char_class_type 1035 lookup_classname(_ForwardIterator __f, _ForwardIterator __l, 1036 bool __icase = false) const 1037 {return __lookup_classname(__f, __l, __icase, char_type());} 1038 bool isctype(char_type __c, char_class_type __m) const; 1039 _LIBCPP_INLINE_VISIBILITY 1040 int value(char_type __ch, int __radix) const 1041 {return __regex_traits_value(__ch, __radix);} 1042 locale_type imbue(locale_type __l); 1043 _LIBCPP_INLINE_VISIBILITY 1044 locale_type getloc()const {return __loc_;} 1045 1046private: 1047 void __init(); 1048 1049 template <class _ForwardIterator> 1050 string_type 1051 __transform_primary(_ForwardIterator __f, _ForwardIterator __l, char) const; 1052 template <class _ForwardIterator> 1053 string_type 1054 __transform_primary(_ForwardIterator __f, _ForwardIterator __l, wchar_t) const; 1055 1056 template <class _ForwardIterator> 1057 string_type 1058 __lookup_collatename(_ForwardIterator __f, _ForwardIterator __l, char) const; 1059 template <class _ForwardIterator> 1060 string_type 1061 __lookup_collatename(_ForwardIterator __f, _ForwardIterator __l, wchar_t) const; 1062 1063 template <class _ForwardIterator> 1064 char_class_type 1065 __lookup_classname(_ForwardIterator __f, _ForwardIterator __l, 1066 bool __icase, char) const; 1067 template <class _ForwardIterator> 1068 char_class_type 1069 __lookup_classname(_ForwardIterator __f, _ForwardIterator __l, 1070 bool __icase, wchar_t) const; 1071 1072 static int __regex_traits_value(unsigned char __ch, int __radix); 1073 _LIBCPP_INLINE_VISIBILITY 1074 int __regex_traits_value(char __ch, int __radix) const 1075 {return __regex_traits_value(static_cast<unsigned char>(__ch), __radix);} 1076 _LIBCPP_INLINE_VISIBILITY 1077 int __regex_traits_value(wchar_t __ch, int __radix) const; 1078}; 1079 1080template <class _CharT> 1081const typename regex_traits<_CharT>::char_class_type 1082regex_traits<_CharT>::__regex_word; 1083 1084template <class _CharT> 1085regex_traits<_CharT>::regex_traits() 1086{ 1087 __init(); 1088} 1089 1090template <class _CharT> 1091typename regex_traits<_CharT>::char_type 1092regex_traits<_CharT>::translate_nocase(char_type __c) const 1093{ 1094 return __ct_->tolower(__c); 1095} 1096 1097template <class _CharT> 1098template <class _ForwardIterator> 1099typename regex_traits<_CharT>::string_type 1100regex_traits<_CharT>::transform(_ForwardIterator __f, _ForwardIterator __l) const 1101{ 1102 string_type __s(__f, __l); 1103 return __col_->transform(__s.data(), __s.data() + __s.size()); 1104} 1105 1106template <class _CharT> 1107void 1108regex_traits<_CharT>::__init() 1109{ 1110 __ct_ = &use_facet<ctype<char_type> >(__loc_); 1111 __col_ = &use_facet<collate<char_type> >(__loc_); 1112} 1113 1114template <class _CharT> 1115typename regex_traits<_CharT>::locale_type 1116regex_traits<_CharT>::imbue(locale_type __l) 1117{ 1118 locale __r = __loc_; 1119 __loc_ = __l; 1120 __init(); 1121 return __r; 1122} 1123 1124// transform_primary is very FreeBSD-specific 1125 1126template <class _CharT> 1127template <class _ForwardIterator> 1128typename regex_traits<_CharT>::string_type 1129regex_traits<_CharT>::__transform_primary(_ForwardIterator __f, 1130 _ForwardIterator __l, char) const 1131{ 1132 const string_type __s(__f, __l); 1133 string_type __d = __col_->transform(__s.data(), __s.data() + __s.size()); 1134 switch (__d.size()) 1135 { 1136 case 1: 1137 break; 1138 case 12: 1139 __d[11] = __d[3]; 1140 break; 1141 default: 1142 __d.clear(); 1143 break; 1144 } 1145 return __d; 1146} 1147 1148template <class _CharT> 1149template <class _ForwardIterator> 1150typename regex_traits<_CharT>::string_type 1151regex_traits<_CharT>::__transform_primary(_ForwardIterator __f, 1152 _ForwardIterator __l, wchar_t) const 1153{ 1154 const string_type __s(__f, __l); 1155 string_type __d = __col_->transform(__s.data(), __s.data() + __s.size()); 1156 switch (__d.size()) 1157 { 1158 case 1: 1159 break; 1160 case 3: 1161 __d[2] = __d[0]; 1162 break; 1163 default: 1164 __d.clear(); 1165 break; 1166 } 1167 return __d; 1168} 1169 1170// lookup_collatename is very FreeBSD-specific 1171 1172_LIBCPP_FUNC_VIS string __get_collation_name(const char* __s); 1173 1174template <class _CharT> 1175template <class _ForwardIterator> 1176typename regex_traits<_CharT>::string_type 1177regex_traits<_CharT>::__lookup_collatename(_ForwardIterator __f, 1178 _ForwardIterator __l, char) const 1179{ 1180 string_type __s(__f, __l); 1181 string_type __r; 1182 if (!__s.empty()) 1183 { 1184 __r = __get_collation_name(__s.c_str()); 1185 if (__r.empty() && __s.size() <= 2) 1186 { 1187 __r = __col_->transform(__s.data(), __s.data() + __s.size()); 1188 if (__r.size() == 1 || __r.size() == 12) 1189 __r = __s; 1190 else 1191 __r.clear(); 1192 } 1193 } 1194 return __r; 1195} 1196 1197template <class _CharT> 1198template <class _ForwardIterator> 1199typename regex_traits<_CharT>::string_type 1200regex_traits<_CharT>::__lookup_collatename(_ForwardIterator __f, 1201 _ForwardIterator __l, wchar_t) const 1202{ 1203 string_type __s(__f, __l); 1204 string __n; 1205 __n.reserve(__s.size()); 1206 for (typename string_type::const_iterator __i = __s.begin(), __e = __s.end(); 1207 __i != __e; ++__i) 1208 { 1209 if (static_cast<unsigned>(*__i) >= 127) 1210 return string_type(); 1211 __n.push_back(char(*__i)); 1212 } 1213 string_type __r; 1214 if (!__s.empty()) 1215 { 1216 __n = __get_collation_name(__n.c_str()); 1217 if (!__n.empty()) 1218 __r.assign(__n.begin(), __n.end()); 1219 else if (__s.size() <= 2) 1220 { 1221 __r = __col_->transform(__s.data(), __s.data() + __s.size()); 1222 if (__r.size() == 1 || __r.size() == 3) 1223 __r = __s; 1224 else 1225 __r.clear(); 1226 } 1227 } 1228 return __r; 1229} 1230 1231// lookup_classname 1232 1233regex_traits<char>::char_class_type _LIBCPP_FUNC_VIS 1234__get_classname(const char* __s, bool __icase); 1235 1236template <class _CharT> 1237template <class _ForwardIterator> 1238typename regex_traits<_CharT>::char_class_type 1239regex_traits<_CharT>::__lookup_classname(_ForwardIterator __f, 1240 _ForwardIterator __l, 1241 bool __icase, char) const 1242{ 1243 string_type __s(__f, __l); 1244 __ct_->tolower(&__s[0], &__s[0] + __s.size()); 1245 return __get_classname(__s.c_str(), __icase); 1246} 1247 1248template <class _CharT> 1249template <class _ForwardIterator> 1250typename regex_traits<_CharT>::char_class_type 1251regex_traits<_CharT>::__lookup_classname(_ForwardIterator __f, 1252 _ForwardIterator __l, 1253 bool __icase, wchar_t) const 1254{ 1255 string_type __s(__f, __l); 1256 __ct_->tolower(&__s[0], &__s[0] + __s.size()); 1257 string __n; 1258 __n.reserve(__s.size()); 1259 for (typename string_type::const_iterator __i = __s.begin(), __e = __s.end(); 1260 __i != __e; ++__i) 1261 { 1262 if (static_cast<unsigned>(*__i) >= 127) 1263 return char_class_type(); 1264 __n.push_back(char(*__i)); 1265 } 1266 return __get_classname(__n.c_str(), __icase); 1267} 1268 1269template <class _CharT> 1270bool 1271regex_traits<_CharT>::isctype(char_type __c, char_class_type __m) const 1272{ 1273 if (__ct_->is(__m, __c)) 1274 return true; 1275 return (__c == '_' && (__m & __regex_word)); 1276} 1277 1278template <class _CharT> 1279int 1280regex_traits<_CharT>::__regex_traits_value(unsigned char __ch, int __radix) 1281{ 1282 if ((__ch & 0xF8u) == 0x30) // '0' <= __ch && __ch <= '7' 1283 return __ch - '0'; 1284 if (__radix != 8) 1285 { 1286 if ((__ch & 0xFEu) == 0x38) // '8' <= __ch && __ch <= '9' 1287 return __ch - '0'; 1288 if (__radix == 16) 1289 { 1290 __ch |= 0x20; // tolower 1291 if ('a' <= __ch && __ch <= 'f') 1292 return __ch - ('a' - 10); 1293 } 1294 } 1295 return -1; 1296} 1297 1298template <class _CharT> 1299inline 1300int 1301regex_traits<_CharT>::__regex_traits_value(wchar_t __ch, int __radix) const 1302{ 1303 return __regex_traits_value(static_cast<unsigned char>(__ct_->narrow(__ch, char_type())), __radix); 1304} 1305 1306template <class _CharT> class __node; 1307 1308template <class _BidirectionalIterator> class _LIBCPP_TEMPLATE_VIS sub_match; 1309 1310template <class _BidirectionalIterator, 1311 class _Allocator = allocator<sub_match<_BidirectionalIterator> > > 1312class _LIBCPP_TEMPLATE_VIS match_results; 1313 1314template <class _CharT> 1315struct __state 1316{ 1317 enum 1318 { 1319 __end_state = -1000, 1320 __consume_input, // -999 1321 __begin_marked_expr, // -998 1322 __end_marked_expr, // -997 1323 __pop_state, // -996 1324 __accept_and_consume, // -995 1325 __accept_but_not_consume, // -994 1326 __reject, // -993 1327 __split, 1328 __repeat 1329 }; 1330 1331 int __do_; 1332 const _CharT* __first_; 1333 const _CharT* __current_; 1334 const _CharT* __last_; 1335 vector<sub_match<const _CharT*> > __sub_matches_; 1336 vector<pair<size_t, const _CharT*> > __loop_data_; 1337 const __node<_CharT>* __node_; 1338 regex_constants::match_flag_type __flags_; 1339 bool __at_first_; 1340 1341 _LIBCPP_INLINE_VISIBILITY 1342 __state() 1343 : __do_(0), __first_(nullptr), __current_(nullptr), __last_(nullptr), 1344 __node_(nullptr), __flags_() {} 1345}; 1346 1347// __node 1348 1349template <class _CharT> 1350class __node 1351{ 1352 __node(const __node&); 1353 __node& operator=(const __node&); 1354public: 1355 typedef _VSTD::__state<_CharT> __state; 1356 1357 _LIBCPP_INLINE_VISIBILITY 1358 __node() {} 1359 _LIBCPP_INLINE_VISIBILITY 1360 virtual ~__node() {} 1361 1362 _LIBCPP_INLINE_VISIBILITY 1363 virtual void __exec(__state&) const {} 1364 _LIBCPP_INLINE_VISIBILITY 1365 virtual void __exec_split(bool, __state&) const {} 1366}; 1367 1368// __end_state 1369 1370template <class _CharT> 1371class __end_state 1372 : public __node<_CharT> 1373{ 1374public: 1375 typedef _VSTD::__state<_CharT> __state; 1376 1377 _LIBCPP_INLINE_VISIBILITY 1378 __end_state() {} 1379 1380 virtual void __exec(__state&) const; 1381}; 1382 1383template <class _CharT> 1384void 1385__end_state<_CharT>::__exec(__state& __s) const 1386{ 1387 __s.__do_ = __state::__end_state; 1388} 1389 1390// __has_one_state 1391 1392template <class _CharT> 1393class __has_one_state 1394 : public __node<_CharT> 1395{ 1396 __node<_CharT>* __first_; 1397 1398public: 1399 _LIBCPP_INLINE_VISIBILITY 1400 explicit __has_one_state(__node<_CharT>* __s) 1401 : __first_(__s) {} 1402 1403 _LIBCPP_INLINE_VISIBILITY 1404 __node<_CharT>* first() const {return __first_;} 1405 _LIBCPP_INLINE_VISIBILITY 1406 __node<_CharT>*& first() {return __first_;} 1407}; 1408 1409// __owns_one_state 1410 1411template <class _CharT> 1412class __owns_one_state 1413 : public __has_one_state<_CharT> 1414{ 1415 typedef __has_one_state<_CharT> base; 1416 1417public: 1418 _LIBCPP_INLINE_VISIBILITY 1419 explicit __owns_one_state(__node<_CharT>* __s) 1420 : base(__s) {} 1421 1422 virtual ~__owns_one_state(); 1423}; 1424 1425template <class _CharT> 1426__owns_one_state<_CharT>::~__owns_one_state() 1427{ 1428 delete this->first(); 1429} 1430 1431// __empty_state 1432 1433template <class _CharT> 1434class __empty_state 1435 : public __owns_one_state<_CharT> 1436{ 1437 typedef __owns_one_state<_CharT> base; 1438 1439public: 1440 typedef _VSTD::__state<_CharT> __state; 1441 1442 _LIBCPP_INLINE_VISIBILITY 1443 explicit __empty_state(__node<_CharT>* __s) 1444 : base(__s) {} 1445 1446 virtual void __exec(__state&) const; 1447}; 1448 1449template <class _CharT> 1450void 1451__empty_state<_CharT>::__exec(__state& __s) const 1452{ 1453 __s.__do_ = __state::__accept_but_not_consume; 1454 __s.__node_ = this->first(); 1455} 1456 1457// __empty_non_own_state 1458 1459template <class _CharT> 1460class __empty_non_own_state 1461 : public __has_one_state<_CharT> 1462{ 1463 typedef __has_one_state<_CharT> base; 1464 1465public: 1466 typedef _VSTD::__state<_CharT> __state; 1467 1468 _LIBCPP_INLINE_VISIBILITY 1469 explicit __empty_non_own_state(__node<_CharT>* __s) 1470 : base(__s) {} 1471 1472 virtual void __exec(__state&) const; 1473}; 1474 1475template <class _CharT> 1476void 1477__empty_non_own_state<_CharT>::__exec(__state& __s) const 1478{ 1479 __s.__do_ = __state::__accept_but_not_consume; 1480 __s.__node_ = this->first(); 1481} 1482 1483// __repeat_one_loop 1484 1485template <class _CharT> 1486class __repeat_one_loop 1487 : public __has_one_state<_CharT> 1488{ 1489 typedef __has_one_state<_CharT> base; 1490 1491public: 1492 typedef _VSTD::__state<_CharT> __state; 1493 1494 _LIBCPP_INLINE_VISIBILITY 1495 explicit __repeat_one_loop(__node<_CharT>* __s) 1496 : base(__s) {} 1497 1498 virtual void __exec(__state&) const; 1499}; 1500 1501template <class _CharT> 1502void 1503__repeat_one_loop<_CharT>::__exec(__state& __s) const 1504{ 1505 __s.__do_ = __state::__repeat; 1506 __s.__node_ = this->first(); 1507} 1508 1509// __owns_two_states 1510 1511template <class _CharT> 1512class __owns_two_states 1513 : public __owns_one_state<_CharT> 1514{ 1515 typedef __owns_one_state<_CharT> base; 1516 1517 base* __second_; 1518 1519public: 1520 _LIBCPP_INLINE_VISIBILITY 1521 explicit __owns_two_states(__node<_CharT>* __s1, base* __s2) 1522 : base(__s1), __second_(__s2) {} 1523 1524 virtual ~__owns_two_states(); 1525 1526 _LIBCPP_INLINE_VISIBILITY 1527 base* second() const {return __second_;} 1528 _LIBCPP_INLINE_VISIBILITY 1529 base*& second() {return __second_;} 1530}; 1531 1532template <class _CharT> 1533__owns_two_states<_CharT>::~__owns_two_states() 1534{ 1535 delete __second_; 1536} 1537 1538// __loop 1539 1540template <class _CharT> 1541class __loop 1542 : public __owns_two_states<_CharT> 1543{ 1544 typedef __owns_two_states<_CharT> base; 1545 1546 size_t __min_; 1547 size_t __max_; 1548 unsigned __loop_id_; 1549 unsigned __mexp_begin_; 1550 unsigned __mexp_end_; 1551 bool __greedy_; 1552 1553public: 1554 typedef _VSTD::__state<_CharT> __state; 1555 1556 _LIBCPP_INLINE_VISIBILITY 1557 explicit __loop(unsigned __loop_id, 1558 __node<_CharT>* __s1, __owns_one_state<_CharT>* __s2, 1559 unsigned __mexp_begin, unsigned __mexp_end, 1560 bool __greedy = true, 1561 size_t __min = 0, 1562 size_t __max = numeric_limits<size_t>::max()) 1563 : base(__s1, __s2), __min_(__min), __max_(__max), __loop_id_(__loop_id), 1564 __mexp_begin_(__mexp_begin), __mexp_end_(__mexp_end), 1565 __greedy_(__greedy) {} 1566 1567 virtual void __exec(__state& __s) const; 1568 virtual void __exec_split(bool __second, __state& __s) const; 1569 1570private: 1571 _LIBCPP_INLINE_VISIBILITY 1572 void __init_repeat(__state& __s) const 1573 { 1574 __s.__loop_data_[__loop_id_].second = __s.__current_; 1575 for (size_t __i = __mexp_begin_-1; __i != __mexp_end_-1; ++__i) 1576 { 1577 __s.__sub_matches_[__i].first = __s.__last_; 1578 __s.__sub_matches_[__i].second = __s.__last_; 1579 __s.__sub_matches_[__i].matched = false; 1580 } 1581 } 1582}; 1583 1584template <class _CharT> 1585void 1586__loop<_CharT>::__exec(__state& __s) const 1587{ 1588 if (__s.__do_ == __state::__repeat) 1589 { 1590 bool __do_repeat = ++__s.__loop_data_[__loop_id_].first < __max_; 1591 bool __do_alt = __s.__loop_data_[__loop_id_].first >= __min_; 1592 if (__do_repeat && __do_alt && 1593 __s.__loop_data_[__loop_id_].second == __s.__current_) 1594 __do_repeat = false; 1595 if (__do_repeat && __do_alt) 1596 __s.__do_ = __state::__split; 1597 else if (__do_repeat) 1598 { 1599 __s.__do_ = __state::__accept_but_not_consume; 1600 __s.__node_ = this->first(); 1601 __init_repeat(__s); 1602 } 1603 else 1604 { 1605 __s.__do_ = __state::__accept_but_not_consume; 1606 __s.__node_ = this->second(); 1607 } 1608 } 1609 else 1610 { 1611 __s.__loop_data_[__loop_id_].first = 0; 1612 bool __do_repeat = 0 < __max_; 1613 bool __do_alt = 0 >= __min_; 1614 if (__do_repeat && __do_alt) 1615 __s.__do_ = __state::__split; 1616 else if (__do_repeat) 1617 { 1618 __s.__do_ = __state::__accept_but_not_consume; 1619 __s.__node_ = this->first(); 1620 __init_repeat(__s); 1621 } 1622 else 1623 { 1624 __s.__do_ = __state::__accept_but_not_consume; 1625 __s.__node_ = this->second(); 1626 } 1627 } 1628} 1629 1630template <class _CharT> 1631void 1632__loop<_CharT>::__exec_split(bool __second, __state& __s) const 1633{ 1634 __s.__do_ = __state::__accept_but_not_consume; 1635 if (__greedy_ != __second) 1636 { 1637 __s.__node_ = this->first(); 1638 __init_repeat(__s); 1639 } 1640 else 1641 __s.__node_ = this->second(); 1642} 1643 1644// __alternate 1645 1646template <class _CharT> 1647class __alternate 1648 : public __owns_two_states<_CharT> 1649{ 1650 typedef __owns_two_states<_CharT> base; 1651 1652public: 1653 typedef _VSTD::__state<_CharT> __state; 1654 1655 _LIBCPP_INLINE_VISIBILITY 1656 explicit __alternate(__owns_one_state<_CharT>* __s1, 1657 __owns_one_state<_CharT>* __s2) 1658 : base(__s1, __s2) {} 1659 1660 virtual void __exec(__state& __s) const; 1661 virtual void __exec_split(bool __second, __state& __s) const; 1662}; 1663 1664template <class _CharT> 1665void 1666__alternate<_CharT>::__exec(__state& __s) const 1667{ 1668 __s.__do_ = __state::__split; 1669} 1670 1671template <class _CharT> 1672void 1673__alternate<_CharT>::__exec_split(bool __second, __state& __s) const 1674{ 1675 __s.__do_ = __state::__accept_but_not_consume; 1676 if (__second) 1677 __s.__node_ = this->second(); 1678 else 1679 __s.__node_ = this->first(); 1680} 1681 1682// __begin_marked_subexpression 1683 1684template <class _CharT> 1685class __begin_marked_subexpression 1686 : public __owns_one_state<_CharT> 1687{ 1688 typedef __owns_one_state<_CharT> base; 1689 1690 unsigned __mexp_; 1691public: 1692 typedef _VSTD::__state<_CharT> __state; 1693 1694 _LIBCPP_INLINE_VISIBILITY 1695 explicit __begin_marked_subexpression(unsigned __mexp, __node<_CharT>* __s) 1696 : base(__s), __mexp_(__mexp) {} 1697 1698 virtual void __exec(__state&) const; 1699}; 1700 1701template <class _CharT> 1702void 1703__begin_marked_subexpression<_CharT>::__exec(__state& __s) const 1704{ 1705 __s.__do_ = __state::__accept_but_not_consume; 1706 __s.__sub_matches_[__mexp_-1].first = __s.__current_; 1707 __s.__node_ = this->first(); 1708} 1709 1710// __end_marked_subexpression 1711 1712template <class _CharT> 1713class __end_marked_subexpression 1714 : public __owns_one_state<_CharT> 1715{ 1716 typedef __owns_one_state<_CharT> base; 1717 1718 unsigned __mexp_; 1719public: 1720 typedef _VSTD::__state<_CharT> __state; 1721 1722 _LIBCPP_INLINE_VISIBILITY 1723 explicit __end_marked_subexpression(unsigned __mexp, __node<_CharT>* __s) 1724 : base(__s), __mexp_(__mexp) {} 1725 1726 virtual void __exec(__state&) const; 1727}; 1728 1729template <class _CharT> 1730void 1731__end_marked_subexpression<_CharT>::__exec(__state& __s) const 1732{ 1733 __s.__do_ = __state::__accept_but_not_consume; 1734 __s.__sub_matches_[__mexp_-1].second = __s.__current_; 1735 __s.__sub_matches_[__mexp_-1].matched = true; 1736 __s.__node_ = this->first(); 1737} 1738 1739// __back_ref 1740 1741template <class _CharT> 1742class __back_ref 1743 : public __owns_one_state<_CharT> 1744{ 1745 typedef __owns_one_state<_CharT> base; 1746 1747 unsigned __mexp_; 1748public: 1749 typedef _VSTD::__state<_CharT> __state; 1750 1751 _LIBCPP_INLINE_VISIBILITY 1752 explicit __back_ref(unsigned __mexp, __node<_CharT>* __s) 1753 : base(__s), __mexp_(__mexp) {} 1754 1755 virtual void __exec(__state&) const; 1756}; 1757 1758template <class _CharT> 1759void 1760__back_ref<_CharT>::__exec(__state& __s) const 1761{ 1762 if (__mexp_ > __s.__sub_matches_.size()) 1763 __throw_regex_error<regex_constants::error_backref>(); 1764 sub_match<const _CharT*>& __sm = __s.__sub_matches_[__mexp_-1]; 1765 if (__sm.matched) 1766 { 1767 ptrdiff_t __len = __sm.second - __sm.first; 1768 if (__s.__last_ - __s.__current_ >= __len && 1769 _VSTD::equal(__sm.first, __sm.second, __s.__current_)) 1770 { 1771 __s.__do_ = __state::__accept_but_not_consume; 1772 __s.__current_ += __len; 1773 __s.__node_ = this->first(); 1774 } 1775 else 1776 { 1777 __s.__do_ = __state::__reject; 1778 __s.__node_ = nullptr; 1779 } 1780 } 1781 else 1782 { 1783 __s.__do_ = __state::__reject; 1784 __s.__node_ = nullptr; 1785 } 1786} 1787 1788// __back_ref_icase 1789 1790template <class _CharT, class _Traits> 1791class __back_ref_icase 1792 : public __owns_one_state<_CharT> 1793{ 1794 typedef __owns_one_state<_CharT> base; 1795 1796 _Traits __traits_; 1797 unsigned __mexp_; 1798public: 1799 typedef _VSTD::__state<_CharT> __state; 1800 1801 _LIBCPP_INLINE_VISIBILITY 1802 explicit __back_ref_icase(const _Traits& __traits, unsigned __mexp, 1803 __node<_CharT>* __s) 1804 : base(__s), __traits_(__traits), __mexp_(__mexp) {} 1805 1806 virtual void __exec(__state&) const; 1807}; 1808 1809template <class _CharT, class _Traits> 1810void 1811__back_ref_icase<_CharT, _Traits>::__exec(__state& __s) const 1812{ 1813 sub_match<const _CharT*>& __sm = __s.__sub_matches_[__mexp_-1]; 1814 if (__sm.matched) 1815 { 1816 ptrdiff_t __len = __sm.second - __sm.first; 1817 if (__s.__last_ - __s.__current_ >= __len) 1818 { 1819 for (ptrdiff_t __i = 0; __i < __len; ++__i) 1820 { 1821 if (__traits_.translate_nocase(__sm.first[__i]) != 1822 __traits_.translate_nocase(__s.__current_[__i])) 1823 goto __not_equal; 1824 } 1825 __s.__do_ = __state::__accept_but_not_consume; 1826 __s.__current_ += __len; 1827 __s.__node_ = this->first(); 1828 } 1829 else 1830 { 1831 __s.__do_ = __state::__reject; 1832 __s.__node_ = nullptr; 1833 } 1834 } 1835 else 1836 { 1837__not_equal: 1838 __s.__do_ = __state::__reject; 1839 __s.__node_ = nullptr; 1840 } 1841} 1842 1843// __back_ref_collate 1844 1845template <class _CharT, class _Traits> 1846class __back_ref_collate 1847 : public __owns_one_state<_CharT> 1848{ 1849 typedef __owns_one_state<_CharT> base; 1850 1851 _Traits __traits_; 1852 unsigned __mexp_; 1853public: 1854 typedef _VSTD::__state<_CharT> __state; 1855 1856 _LIBCPP_INLINE_VISIBILITY 1857 explicit __back_ref_collate(const _Traits& __traits, unsigned __mexp, 1858 __node<_CharT>* __s) 1859 : base(__s), __traits_(__traits), __mexp_(__mexp) {} 1860 1861 virtual void __exec(__state&) const; 1862}; 1863 1864template <class _CharT, class _Traits> 1865void 1866__back_ref_collate<_CharT, _Traits>::__exec(__state& __s) const 1867{ 1868 sub_match<const _CharT*>& __sm = __s.__sub_matches_[__mexp_-1]; 1869 if (__sm.matched) 1870 { 1871 ptrdiff_t __len = __sm.second - __sm.first; 1872 if (__s.__last_ - __s.__current_ >= __len) 1873 { 1874 for (ptrdiff_t __i = 0; __i < __len; ++__i) 1875 { 1876 if (__traits_.translate(__sm.first[__i]) != 1877 __traits_.translate(__s.__current_[__i])) 1878 goto __not_equal; 1879 } 1880 __s.__do_ = __state::__accept_but_not_consume; 1881 __s.__current_ += __len; 1882 __s.__node_ = this->first(); 1883 } 1884 else 1885 { 1886 __s.__do_ = __state::__reject; 1887 __s.__node_ = nullptr; 1888 } 1889 } 1890 else 1891 { 1892__not_equal: 1893 __s.__do_ = __state::__reject; 1894 __s.__node_ = nullptr; 1895 } 1896} 1897 1898// __word_boundary 1899 1900template <class _CharT, class _Traits> 1901class __word_boundary 1902 : public __owns_one_state<_CharT> 1903{ 1904 typedef __owns_one_state<_CharT> base; 1905 1906 _Traits __traits_; 1907 bool __invert_; 1908public: 1909 typedef _VSTD::__state<_CharT> __state; 1910 1911 _LIBCPP_INLINE_VISIBILITY 1912 explicit __word_boundary(const _Traits& __traits, bool __invert, 1913 __node<_CharT>* __s) 1914 : base(__s), __traits_(__traits), __invert_(__invert) {} 1915 1916 virtual void __exec(__state&) const; 1917}; 1918 1919template <class _CharT, class _Traits> 1920void 1921__word_boundary<_CharT, _Traits>::__exec(__state& __s) const 1922{ 1923 bool __is_word_b = false; 1924 if (__s.__first_ != __s.__last_) 1925 { 1926 if (__s.__current_ == __s.__last_) 1927 { 1928 if (!(__s.__flags_ & regex_constants::match_not_eow)) 1929 { 1930 _CharT __c = __s.__current_[-1]; 1931 __is_word_b = __c == '_' || 1932 __traits_.isctype(__c, ctype_base::alnum); 1933 } 1934 } 1935 else if (__s.__current_ == __s.__first_ && 1936 !(__s.__flags_ & regex_constants::match_prev_avail)) 1937 { 1938 if (!(__s.__flags_ & regex_constants::match_not_bow)) 1939 { 1940 _CharT __c = *__s.__current_; 1941 __is_word_b = __c == '_' || 1942 __traits_.isctype(__c, ctype_base::alnum); 1943 } 1944 } 1945 else 1946 { 1947 _CharT __c1 = __s.__current_[-1]; 1948 _CharT __c2 = *__s.__current_; 1949 bool __is_c1_b = __c1 == '_' || 1950 __traits_.isctype(__c1, ctype_base::alnum); 1951 bool __is_c2_b = __c2 == '_' || 1952 __traits_.isctype(__c2, ctype_base::alnum); 1953 __is_word_b = __is_c1_b != __is_c2_b; 1954 } 1955 } 1956 if (__is_word_b != __invert_) 1957 { 1958 __s.__do_ = __state::__accept_but_not_consume; 1959 __s.__node_ = this->first(); 1960 } 1961 else 1962 { 1963 __s.__do_ = __state::__reject; 1964 __s.__node_ = nullptr; 1965 } 1966} 1967 1968// __l_anchor 1969 1970template <class _CharT> 1971class __l_anchor 1972 : public __owns_one_state<_CharT> 1973{ 1974 typedef __owns_one_state<_CharT> base; 1975 1976public: 1977 typedef _VSTD::__state<_CharT> __state; 1978 1979 _LIBCPP_INLINE_VISIBILITY 1980 __l_anchor(__node<_CharT>* __s) 1981 : base(__s) {} 1982 1983 virtual void __exec(__state&) const; 1984}; 1985 1986template <class _CharT> 1987void 1988__l_anchor<_CharT>::__exec(__state& __s) const 1989{ 1990 if (__s.__at_first_ && __s.__current_ == __s.__first_ && 1991 !(__s.__flags_ & regex_constants::match_not_bol)) 1992 { 1993 __s.__do_ = __state::__accept_but_not_consume; 1994 __s.__node_ = this->first(); 1995 } 1996 else 1997 { 1998 __s.__do_ = __state::__reject; 1999 __s.__node_ = nullptr; 2000 } 2001} 2002 2003// __r_anchor 2004 2005template <class _CharT> 2006class __r_anchor 2007 : public __owns_one_state<_CharT> 2008{ 2009 typedef __owns_one_state<_CharT> base; 2010 2011public: 2012 typedef _VSTD::__state<_CharT> __state; 2013 2014 _LIBCPP_INLINE_VISIBILITY 2015 __r_anchor(__node<_CharT>* __s) 2016 : base(__s) {} 2017 2018 virtual void __exec(__state&) const; 2019}; 2020 2021template <class _CharT> 2022void 2023__r_anchor<_CharT>::__exec(__state& __s) const 2024{ 2025 if (__s.__current_ == __s.__last_ && 2026 !(__s.__flags_ & regex_constants::match_not_eol)) 2027 { 2028 __s.__do_ = __state::__accept_but_not_consume; 2029 __s.__node_ = this->first(); 2030 } 2031 else 2032 { 2033 __s.__do_ = __state::__reject; 2034 __s.__node_ = nullptr; 2035 } 2036} 2037 2038// __match_any 2039 2040template <class _CharT> 2041class __match_any 2042 : public __owns_one_state<_CharT> 2043{ 2044 typedef __owns_one_state<_CharT> base; 2045 2046public: 2047 typedef _VSTD::__state<_CharT> __state; 2048 2049 _LIBCPP_INLINE_VISIBILITY 2050 __match_any(__node<_CharT>* __s) 2051 : base(__s) {} 2052 2053 virtual void __exec(__state&) const; 2054}; 2055 2056template <class _CharT> 2057void 2058__match_any<_CharT>::__exec(__state& __s) const 2059{ 2060 if (__s.__current_ != __s.__last_ && *__s.__current_ != 0) 2061 { 2062 __s.__do_ = __state::__accept_and_consume; 2063 ++__s.__current_; 2064 __s.__node_ = this->first(); 2065 } 2066 else 2067 { 2068 __s.__do_ = __state::__reject; 2069 __s.__node_ = nullptr; 2070 } 2071} 2072 2073// __match_any_but_newline 2074 2075template <class _CharT> 2076class __match_any_but_newline 2077 : public __owns_one_state<_CharT> 2078{ 2079 typedef __owns_one_state<_CharT> base; 2080 2081public: 2082 typedef _VSTD::__state<_CharT> __state; 2083 2084 _LIBCPP_INLINE_VISIBILITY 2085 __match_any_but_newline(__node<_CharT>* __s) 2086 : base(__s) {} 2087 2088 virtual void __exec(__state&) const; 2089}; 2090 2091template <> _LIBCPP_FUNC_VIS void __match_any_but_newline<char>::__exec(__state&) const; 2092template <> _LIBCPP_FUNC_VIS void __match_any_but_newline<wchar_t>::__exec(__state&) const; 2093 2094// __match_char 2095 2096template <class _CharT> 2097class __match_char 2098 : public __owns_one_state<_CharT> 2099{ 2100 typedef __owns_one_state<_CharT> base; 2101 2102 _CharT __c_; 2103 2104 __match_char(const __match_char&); 2105 __match_char& operator=(const __match_char&); 2106public: 2107 typedef _VSTD::__state<_CharT> __state; 2108 2109 _LIBCPP_INLINE_VISIBILITY 2110 __match_char(_CharT __c, __node<_CharT>* __s) 2111 : base(__s), __c_(__c) {} 2112 2113 virtual void __exec(__state&) const; 2114}; 2115 2116template <class _CharT> 2117void 2118__match_char<_CharT>::__exec(__state& __s) const 2119{ 2120 if (__s.__current_ != __s.__last_ && *__s.__current_ == __c_) 2121 { 2122 __s.__do_ = __state::__accept_and_consume; 2123 ++__s.__current_; 2124 __s.__node_ = this->first(); 2125 } 2126 else 2127 { 2128 __s.__do_ = __state::__reject; 2129 __s.__node_ = nullptr; 2130 } 2131} 2132 2133// __match_char_icase 2134 2135template <class _CharT, class _Traits> 2136class __match_char_icase 2137 : public __owns_one_state<_CharT> 2138{ 2139 typedef __owns_one_state<_CharT> base; 2140 2141 _Traits __traits_; 2142 _CharT __c_; 2143 2144 __match_char_icase(const __match_char_icase&); 2145 __match_char_icase& operator=(const __match_char_icase&); 2146public: 2147 typedef _VSTD::__state<_CharT> __state; 2148 2149 _LIBCPP_INLINE_VISIBILITY 2150 __match_char_icase(const _Traits& __traits, _CharT __c, __node<_CharT>* __s) 2151 : base(__s), __traits_(__traits), __c_(__traits.translate_nocase(__c)) {} 2152 2153 virtual void __exec(__state&) const; 2154}; 2155 2156template <class _CharT, class _Traits> 2157void 2158__match_char_icase<_CharT, _Traits>::__exec(__state& __s) const 2159{ 2160 if (__s.__current_ != __s.__last_ && 2161 __traits_.translate_nocase(*__s.__current_) == __c_) 2162 { 2163 __s.__do_ = __state::__accept_and_consume; 2164 ++__s.__current_; 2165 __s.__node_ = this->first(); 2166 } 2167 else 2168 { 2169 __s.__do_ = __state::__reject; 2170 __s.__node_ = nullptr; 2171 } 2172} 2173 2174// __match_char_collate 2175 2176template <class _CharT, class _Traits> 2177class __match_char_collate 2178 : public __owns_one_state<_CharT> 2179{ 2180 typedef __owns_one_state<_CharT> base; 2181 2182 _Traits __traits_; 2183 _CharT __c_; 2184 2185 __match_char_collate(const __match_char_collate&); 2186 __match_char_collate& operator=(const __match_char_collate&); 2187public: 2188 typedef _VSTD::__state<_CharT> __state; 2189 2190 _LIBCPP_INLINE_VISIBILITY 2191 __match_char_collate(const _Traits& __traits, _CharT __c, __node<_CharT>* __s) 2192 : base(__s), __traits_(__traits), __c_(__traits.translate(__c)) {} 2193 2194 virtual void __exec(__state&) const; 2195}; 2196 2197template <class _CharT, class _Traits> 2198void 2199__match_char_collate<_CharT, _Traits>::__exec(__state& __s) const 2200{ 2201 if (__s.__current_ != __s.__last_ && 2202 __traits_.translate(*__s.__current_) == __c_) 2203 { 2204 __s.__do_ = __state::__accept_and_consume; 2205 ++__s.__current_; 2206 __s.__node_ = this->first(); 2207 } 2208 else 2209 { 2210 __s.__do_ = __state::__reject; 2211 __s.__node_ = nullptr; 2212 } 2213} 2214 2215// __bracket_expression 2216 2217template <class _CharT, class _Traits> 2218class __bracket_expression 2219 : public __owns_one_state<_CharT> 2220{ 2221 typedef __owns_one_state<_CharT> base; 2222 typedef typename _Traits::string_type string_type; 2223 2224 _Traits __traits_; 2225 vector<_CharT> __chars_; 2226 vector<_CharT> __neg_chars_; 2227 vector<pair<string_type, string_type> > __ranges_; 2228 vector<pair<_CharT, _CharT> > __digraphs_; 2229 vector<string_type> __equivalences_; 2230 typename regex_traits<_CharT>::char_class_type __mask_; 2231 typename regex_traits<_CharT>::char_class_type __neg_mask_; 2232 bool __negate_; 2233 bool __icase_; 2234 bool __collate_; 2235 bool __might_have_digraph_; 2236 2237 __bracket_expression(const __bracket_expression&); 2238 __bracket_expression& operator=(const __bracket_expression&); 2239public: 2240 typedef _VSTD::__state<_CharT> __state; 2241 2242 _LIBCPP_INLINE_VISIBILITY 2243 __bracket_expression(const _Traits& __traits, __node<_CharT>* __s, 2244 bool __negate, bool __icase, bool __collate) 2245 : base(__s), __traits_(__traits), __mask_(), __neg_mask_(), 2246 __negate_(__negate), __icase_(__icase), __collate_(__collate), 2247 __might_have_digraph_(__traits_.getloc().name() != "C") {} 2248 2249 virtual void __exec(__state&) const; 2250 2251 _LIBCPP_INLINE_VISIBILITY 2252 bool __negated() const {return __negate_;} 2253 2254 _LIBCPP_INLINE_VISIBILITY 2255 void __add_char(_CharT __c) 2256 { 2257 if (__icase_) 2258 __chars_.push_back(__traits_.translate_nocase(__c)); 2259 else if (__collate_) 2260 __chars_.push_back(__traits_.translate(__c)); 2261 else 2262 __chars_.push_back(__c); 2263 } 2264 _LIBCPP_INLINE_VISIBILITY 2265 void __add_neg_char(_CharT __c) 2266 { 2267 if (__icase_) 2268 __neg_chars_.push_back(__traits_.translate_nocase(__c)); 2269 else if (__collate_) 2270 __neg_chars_.push_back(__traits_.translate(__c)); 2271 else 2272 __neg_chars_.push_back(__c); 2273 } 2274 _LIBCPP_INLINE_VISIBILITY 2275 void __add_range(string_type __b, string_type __e) 2276 { 2277 if (__collate_) 2278 { 2279 if (__icase_) 2280 { 2281 for (size_t __i = 0; __i < __b.size(); ++__i) 2282 __b[__i] = __traits_.translate_nocase(__b[__i]); 2283 for (size_t __i = 0; __i < __e.size(); ++__i) 2284 __e[__i] = __traits_.translate_nocase(__e[__i]); 2285 } 2286 else 2287 { 2288 for (size_t __i = 0; __i < __b.size(); ++__i) 2289 __b[__i] = __traits_.translate(__b[__i]); 2290 for (size_t __i = 0; __i < __e.size(); ++__i) 2291 __e[__i] = __traits_.translate(__e[__i]); 2292 } 2293 __ranges_.push_back(make_pair( 2294 __traits_.transform(__b.begin(), __b.end()), 2295 __traits_.transform(__e.begin(), __e.end()))); 2296 } 2297 else 2298 { 2299 if (__b.size() != 1 || __e.size() != 1) 2300 __throw_regex_error<regex_constants::error_range>(); 2301 if (__icase_) 2302 { 2303 __b[0] = __traits_.translate_nocase(__b[0]); 2304 __e[0] = __traits_.translate_nocase(__e[0]); 2305 } 2306 __ranges_.push_back(make_pair(_VSTD::move(__b), _VSTD::move(__e))); 2307 } 2308 } 2309 _LIBCPP_INLINE_VISIBILITY 2310 void __add_digraph(_CharT __c1, _CharT __c2) 2311 { 2312 if (__icase_) 2313 __digraphs_.push_back(make_pair(__traits_.translate_nocase(__c1), 2314 __traits_.translate_nocase(__c2))); 2315 else if (__collate_) 2316 __digraphs_.push_back(make_pair(__traits_.translate(__c1), 2317 __traits_.translate(__c2))); 2318 else 2319 __digraphs_.push_back(make_pair(__c1, __c2)); 2320 } 2321 _LIBCPP_INLINE_VISIBILITY 2322 void __add_equivalence(const string_type& __s) 2323 {__equivalences_.push_back(__s);} 2324 _LIBCPP_INLINE_VISIBILITY 2325 void __add_class(typename regex_traits<_CharT>::char_class_type __mask) 2326 {__mask_ |= __mask;} 2327 _LIBCPP_INLINE_VISIBILITY 2328 void __add_neg_class(typename regex_traits<_CharT>::char_class_type __mask) 2329 {__neg_mask_ |= __mask;} 2330}; 2331 2332template <class _CharT, class _Traits> 2333void 2334__bracket_expression<_CharT, _Traits>::__exec(__state& __s) const 2335{ 2336 bool __found = false; 2337 unsigned __consumed = 0; 2338 if (__s.__current_ != __s.__last_) 2339 { 2340 ++__consumed; 2341 if (__might_have_digraph_) 2342 { 2343 const _CharT* __next = _VSTD::next(__s.__current_); 2344 if (__next != __s.__last_) 2345 { 2346 pair<_CharT, _CharT> __ch2(*__s.__current_, *__next); 2347 if (__icase_) 2348 { 2349 __ch2.first = __traits_.translate_nocase(__ch2.first); 2350 __ch2.second = __traits_.translate_nocase(__ch2.second); 2351 } 2352 else if (__collate_) 2353 { 2354 __ch2.first = __traits_.translate(__ch2.first); 2355 __ch2.second = __traits_.translate(__ch2.second); 2356 } 2357 if (!__traits_.lookup_collatename(&__ch2.first, &__ch2.first+2).empty()) 2358 { 2359 // __ch2 is a digraph in this locale 2360 ++__consumed; 2361 for (size_t __i = 0; __i < __digraphs_.size(); ++__i) 2362 { 2363 if (__ch2 == __digraphs_[__i]) 2364 { 2365 __found = true; 2366 goto __exit; 2367 } 2368 } 2369 if (__collate_ && !__ranges_.empty()) 2370 { 2371 string_type __s2 = __traits_.transform(&__ch2.first, 2372 &__ch2.first + 2); 2373 for (size_t __i = 0; __i < __ranges_.size(); ++__i) 2374 { 2375 if (__ranges_[__i].first <= __s2 && 2376 __s2 <= __ranges_[__i].second) 2377 { 2378 __found = true; 2379 goto __exit; 2380 } 2381 } 2382 } 2383 if (!__equivalences_.empty()) 2384 { 2385 string_type __s2 = __traits_.transform_primary(&__ch2.first, 2386 &__ch2.first + 2); 2387 for (size_t __i = 0; __i < __equivalences_.size(); ++__i) 2388 { 2389 if (__s2 == __equivalences_[__i]) 2390 { 2391 __found = true; 2392 goto __exit; 2393 } 2394 } 2395 } 2396 if (__traits_.isctype(__ch2.first, __mask_) && 2397 __traits_.isctype(__ch2.second, __mask_)) 2398 { 2399 __found = true; 2400 goto __exit; 2401 } 2402 if (!__traits_.isctype(__ch2.first, __neg_mask_) && 2403 !__traits_.isctype(__ch2.second, __neg_mask_)) 2404 { 2405 __found = true; 2406 goto __exit; 2407 } 2408 goto __exit; 2409 } 2410 } 2411 } 2412 // test *__s.__current_ as not a digraph 2413 _CharT __ch = *__s.__current_; 2414 if (__icase_) 2415 __ch = __traits_.translate_nocase(__ch); 2416 else if (__collate_) 2417 __ch = __traits_.translate(__ch); 2418 for (size_t __i = 0; __i < __chars_.size(); ++__i) 2419 { 2420 if (__ch == __chars_[__i]) 2421 { 2422 __found = true; 2423 goto __exit; 2424 } 2425 } 2426 // When there's at least one of __neg_chars_ and __neg_mask_, the set 2427 // of "__found" chars is 2428 // union(complement(union(__neg_chars_, __neg_mask_)), 2429 // other cases...) 2430 // 2431 // It doesn't make sense to check this when there are no __neg_chars_ 2432 // and no __neg_mask_. 2433 if (!(__neg_mask_ == 0 && __neg_chars_.empty())) 2434 { 2435 const bool __in_neg_mask = __traits_.isctype(__ch, __neg_mask_); 2436 const bool __in_neg_chars = 2437 std::find(__neg_chars_.begin(), __neg_chars_.end(), __ch) != 2438 __neg_chars_.end(); 2439 if (!(__in_neg_mask || __in_neg_chars)) 2440 { 2441 __found = true; 2442 goto __exit; 2443 } 2444 } 2445 if (!__ranges_.empty()) 2446 { 2447 string_type __s2 = __collate_ ? 2448 __traits_.transform(&__ch, &__ch + 1) : 2449 string_type(1, __ch); 2450 for (size_t __i = 0; __i < __ranges_.size(); ++__i) 2451 { 2452 if (__ranges_[__i].first <= __s2 && __s2 <= __ranges_[__i].second) 2453 { 2454 __found = true; 2455 goto __exit; 2456 } 2457 } 2458 } 2459 if (!__equivalences_.empty()) 2460 { 2461 string_type __s2 = __traits_.transform_primary(&__ch, &__ch + 1); 2462 for (size_t __i = 0; __i < __equivalences_.size(); ++__i) 2463 { 2464 if (__s2 == __equivalences_[__i]) 2465 { 2466 __found = true; 2467 goto __exit; 2468 } 2469 } 2470 } 2471 if (__traits_.isctype(__ch, __mask_)) 2472 { 2473 __found = true; 2474 goto __exit; 2475 } 2476 } 2477 else 2478 __found = __negate_; // force reject 2479__exit: 2480 if (__found != __negate_) 2481 { 2482 __s.__do_ = __state::__accept_and_consume; 2483 __s.__current_ += __consumed; 2484 __s.__node_ = this->first(); 2485 } 2486 else 2487 { 2488 __s.__do_ = __state::__reject; 2489 __s.__node_ = nullptr; 2490 } 2491} 2492 2493template <class _CharT, class _Traits> class __lookahead; 2494 2495template <class _CharT, class _Traits = regex_traits<_CharT> > 2496class _LIBCPP_TEMPLATE_VIS basic_regex 2497{ 2498public: 2499 // types: 2500 typedef _CharT value_type; 2501 typedef _Traits traits_type; 2502 typedef typename _Traits::string_type string_type; 2503 typedef regex_constants::syntax_option_type flag_type; 2504 typedef typename _Traits::locale_type locale_type; 2505 2506private: 2507 _Traits __traits_; 2508 flag_type __flags_; 2509 unsigned __marked_count_; 2510 unsigned __loop_count_; 2511 int __open_count_; 2512 shared_ptr<__empty_state<_CharT> > __start_; 2513 __owns_one_state<_CharT>* __end_; 2514 2515 typedef _VSTD::__state<_CharT> __state; 2516 typedef _VSTD::__node<_CharT> __node; 2517 2518public: 2519 // constants: 2520 static const regex_constants::syntax_option_type icase = regex_constants::icase; 2521 static const regex_constants::syntax_option_type nosubs = regex_constants::nosubs; 2522 static const regex_constants::syntax_option_type optimize = regex_constants::optimize; 2523 static const regex_constants::syntax_option_type collate = regex_constants::collate; 2524 static const regex_constants::syntax_option_type ECMAScript = regex_constants::ECMAScript; 2525 static const regex_constants::syntax_option_type basic = regex_constants::basic; 2526 static const regex_constants::syntax_option_type extended = regex_constants::extended; 2527 static const regex_constants::syntax_option_type awk = regex_constants::awk; 2528 static const regex_constants::syntax_option_type grep = regex_constants::grep; 2529 static const regex_constants::syntax_option_type egrep = regex_constants::egrep; 2530 2531 // construct/copy/destroy: 2532 _LIBCPP_INLINE_VISIBILITY 2533 basic_regex() 2534 : __flags_(regex_constants::ECMAScript), __marked_count_(0), __loop_count_(0), __open_count_(0), 2535 __end_(0) 2536 {} 2537 _LIBCPP_INLINE_VISIBILITY 2538 explicit basic_regex(const value_type* __p, flag_type __f = regex_constants::ECMAScript) 2539 : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0), 2540 __end_(0) 2541 { 2542 if (__get_grammar(__flags_) == 0) __flags_ |= regex_constants::ECMAScript; 2543 __parse(__p, __p + __traits_.length(__p)); 2544 } 2545 2546 _LIBCPP_INLINE_VISIBILITY 2547 basic_regex(const value_type* __p, size_t __len, flag_type __f = regex_constants::ECMAScript) 2548 : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0), 2549 __end_(0) 2550 { 2551 if (__get_grammar(__flags_) == 0) __flags_ |= regex_constants::ECMAScript; 2552 __parse(__p, __p + __len); 2553 } 2554 2555// basic_regex(const basic_regex&) = default; 2556// basic_regex(basic_regex&&) = default; 2557 template <class _ST, class _SA> 2558 _LIBCPP_INLINE_VISIBILITY 2559 explicit basic_regex(const basic_string<value_type, _ST, _SA>& __p, 2560 flag_type __f = regex_constants::ECMAScript) 2561 : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0), 2562 __end_(0) 2563 { 2564 if (__get_grammar(__flags_) == 0) __flags_ |= regex_constants::ECMAScript; 2565 __parse(__p.begin(), __p.end()); 2566 } 2567 2568 template <class _ForwardIterator> 2569 _LIBCPP_INLINE_VISIBILITY 2570 basic_regex(_ForwardIterator __first, _ForwardIterator __last, 2571 flag_type __f = regex_constants::ECMAScript) 2572 : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0), 2573 __end_(0) 2574 { 2575 if (__get_grammar(__flags_) == 0) __flags_ |= regex_constants::ECMAScript; 2576 __parse(__first, __last); 2577 } 2578#ifndef _LIBCPP_CXX03_LANG 2579 _LIBCPP_INLINE_VISIBILITY 2580 basic_regex(initializer_list<value_type> __il, 2581 flag_type __f = regex_constants::ECMAScript) 2582 : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0), 2583 __end_(0) 2584 { 2585 if (__get_grammar(__flags_) == 0) __flags_ |= regex_constants::ECMAScript; 2586 __parse(__il.begin(), __il.end()); 2587 } 2588#endif // _LIBCPP_CXX03_LANG 2589 2590// ~basic_regex() = default; 2591 2592// basic_regex& operator=(const basic_regex&) = default; 2593// basic_regex& operator=(basic_regex&&) = default; 2594 _LIBCPP_INLINE_VISIBILITY 2595 basic_regex& operator=(const value_type* __p) 2596 {return assign(__p);} 2597#ifndef _LIBCPP_CXX03_LANG 2598 _LIBCPP_INLINE_VISIBILITY 2599 basic_regex& operator=(initializer_list<value_type> __il) 2600 {return assign(__il);} 2601#endif // _LIBCPP_CXX03_LANG 2602 template <class _ST, class _SA> 2603 _LIBCPP_INLINE_VISIBILITY 2604 basic_regex& operator=(const basic_string<value_type, _ST, _SA>& __p) 2605 {return assign(__p);} 2606 2607 // assign: 2608 _LIBCPP_INLINE_VISIBILITY 2609 basic_regex& assign(const basic_regex& __that) 2610 {return *this = __that;} 2611#ifndef _LIBCPP_CXX03_LANG 2612 _LIBCPP_INLINE_VISIBILITY 2613 basic_regex& assign(basic_regex&& __that) _NOEXCEPT 2614 {return *this = _VSTD::move(__that);} 2615#endif 2616 _LIBCPP_INLINE_VISIBILITY 2617 basic_regex& assign(const value_type* __p, flag_type __f = regex_constants::ECMAScript) 2618 {return assign(__p, __p + __traits_.length(__p), __f);} 2619 _LIBCPP_INLINE_VISIBILITY 2620 basic_regex& assign(const value_type* __p, size_t __len, flag_type __f = regex_constants::ECMAScript) 2621 {return assign(__p, __p + __len, __f);} 2622 template <class _ST, class _SA> 2623 _LIBCPP_INLINE_VISIBILITY 2624 basic_regex& assign(const basic_string<value_type, _ST, _SA>& __s, 2625 flag_type __f = regex_constants::ECMAScript) 2626 {return assign(__s.begin(), __s.end(), __f);} 2627 2628 template <class _InputIterator> 2629 _LIBCPP_INLINE_VISIBILITY 2630 typename enable_if 2631 < 2632 __is_input_iterator <_InputIterator>::value && 2633 !__is_forward_iterator<_InputIterator>::value, 2634 basic_regex& 2635 >::type 2636 assign(_InputIterator __first, _InputIterator __last, 2637 flag_type __f = regex_constants::ECMAScript) 2638 { 2639 basic_string<_CharT> __t(__first, __last); 2640 return assign(__t.begin(), __t.end(), __f); 2641 } 2642 2643private: 2644 _LIBCPP_INLINE_VISIBILITY 2645 void __member_init(flag_type __f) 2646 { 2647 __flags_ = __f; 2648 __marked_count_ = 0; 2649 __loop_count_ = 0; 2650 __open_count_ = 0; 2651 __end_ = nullptr; 2652 } 2653public: 2654 2655 template <class _ForwardIterator> 2656 _LIBCPP_INLINE_VISIBILITY 2657 typename enable_if 2658 < 2659 __is_forward_iterator<_ForwardIterator>::value, 2660 basic_regex& 2661 >::type 2662 assign(_ForwardIterator __first, _ForwardIterator __last, 2663 flag_type __f = regex_constants::ECMAScript) 2664 { 2665 return assign(basic_regex(__first, __last, __f)); 2666 } 2667 2668#ifndef _LIBCPP_CXX03_LANG 2669 2670 _LIBCPP_INLINE_VISIBILITY 2671 basic_regex& assign(initializer_list<value_type> __il, 2672 flag_type __f = regex_constants::ECMAScript) 2673 {return assign(__il.begin(), __il.end(), __f);} 2674 2675#endif // _LIBCPP_CXX03_LANG 2676 2677 // const operations: 2678 _LIBCPP_INLINE_VISIBILITY 2679 unsigned mark_count() const {return __marked_count_;} 2680 _LIBCPP_INLINE_VISIBILITY 2681 flag_type flags() const {return __flags_;} 2682 2683 // locale: 2684 _LIBCPP_INLINE_VISIBILITY 2685 locale_type imbue(locale_type __loc) 2686 { 2687 __member_init(ECMAScript); 2688 __start_.reset(); 2689 return __traits_.imbue(__loc); 2690 } 2691 _LIBCPP_INLINE_VISIBILITY 2692 locale_type getloc() const {return __traits_.getloc();} 2693 2694 // swap: 2695 void swap(basic_regex& __r); 2696 2697private: 2698 _LIBCPP_INLINE_VISIBILITY 2699 unsigned __loop_count() const {return __loop_count_;} 2700 2701 template <class _ForwardIterator> 2702 _ForwardIterator 2703 __parse(_ForwardIterator __first, _ForwardIterator __last); 2704 template <class _ForwardIterator> 2705 _ForwardIterator 2706 __parse_basic_reg_exp(_ForwardIterator __first, _ForwardIterator __last); 2707 template <class _ForwardIterator> 2708 _ForwardIterator 2709 __parse_RE_expression(_ForwardIterator __first, _ForwardIterator __last); 2710 template <class _ForwardIterator> 2711 _ForwardIterator 2712 __parse_simple_RE(_ForwardIterator __first, _ForwardIterator __last); 2713 template <class _ForwardIterator> 2714 _ForwardIterator 2715 __parse_nondupl_RE(_ForwardIterator __first, _ForwardIterator __last); 2716 template <class _ForwardIterator> 2717 _ForwardIterator 2718 __parse_one_char_or_coll_elem_RE(_ForwardIterator __first, _ForwardIterator __last); 2719 template <class _ForwardIterator> 2720 _ForwardIterator 2721 __parse_Back_open_paren(_ForwardIterator __first, _ForwardIterator __last); 2722 template <class _ForwardIterator> 2723 _ForwardIterator 2724 __parse_Back_close_paren(_ForwardIterator __first, _ForwardIterator __last); 2725 template <class _ForwardIterator> 2726 _ForwardIterator 2727 __parse_Back_open_brace(_ForwardIterator __first, _ForwardIterator __last); 2728 template <class _ForwardIterator> 2729 _ForwardIterator 2730 __parse_Back_close_brace(_ForwardIterator __first, _ForwardIterator __last); 2731 template <class _ForwardIterator> 2732 _ForwardIterator 2733 __parse_BACKREF(_ForwardIterator __first, _ForwardIterator __last); 2734 template <class _ForwardIterator> 2735 _ForwardIterator 2736 __parse_ORD_CHAR(_ForwardIterator __first, _ForwardIterator __last); 2737 template <class _ForwardIterator> 2738 _ForwardIterator 2739 __parse_QUOTED_CHAR(_ForwardIterator __first, _ForwardIterator __last); 2740 template <class _ForwardIterator> 2741 _ForwardIterator 2742 __parse_RE_dupl_symbol(_ForwardIterator __first, _ForwardIterator __last, 2743 __owns_one_state<_CharT>* __s, 2744 unsigned __mexp_begin, unsigned __mexp_end); 2745 template <class _ForwardIterator> 2746 _ForwardIterator 2747 __parse_ERE_dupl_symbol(_ForwardIterator __first, _ForwardIterator __last, 2748 __owns_one_state<_CharT>* __s, 2749 unsigned __mexp_begin, unsigned __mexp_end); 2750 template <class _ForwardIterator> 2751 _ForwardIterator 2752 __parse_bracket_expression(_ForwardIterator __first, _ForwardIterator __last); 2753 template <class _ForwardIterator> 2754 _ForwardIterator 2755 __parse_follow_list(_ForwardIterator __first, _ForwardIterator __last, 2756 __bracket_expression<_CharT, _Traits>* __ml); 2757 template <class _ForwardIterator> 2758 _ForwardIterator 2759 __parse_expression_term(_ForwardIterator __first, _ForwardIterator __last, 2760 __bracket_expression<_CharT, _Traits>* __ml); 2761 template <class _ForwardIterator> 2762 _ForwardIterator 2763 __parse_equivalence_class(_ForwardIterator __first, _ForwardIterator __last, 2764 __bracket_expression<_CharT, _Traits>* __ml); 2765 template <class _ForwardIterator> 2766 _ForwardIterator 2767 __parse_character_class(_ForwardIterator __first, _ForwardIterator __last, 2768 __bracket_expression<_CharT, _Traits>* __ml); 2769 template <class _ForwardIterator> 2770 _ForwardIterator 2771 __parse_collating_symbol(_ForwardIterator __first, _ForwardIterator __last, 2772 basic_string<_CharT>& __col_sym); 2773 template <class _ForwardIterator> 2774 _ForwardIterator 2775 __parse_DUP_COUNT(_ForwardIterator __first, _ForwardIterator __last, int& __c); 2776 template <class _ForwardIterator> 2777 _ForwardIterator 2778 __parse_extended_reg_exp(_ForwardIterator __first, _ForwardIterator __last); 2779 template <class _ForwardIterator> 2780 _ForwardIterator 2781 __parse_ERE_branch(_ForwardIterator __first, _ForwardIterator __last); 2782 template <class _ForwardIterator> 2783 _ForwardIterator 2784 __parse_ERE_expression(_ForwardIterator __first, _ForwardIterator __last); 2785 template <class _ForwardIterator> 2786 _ForwardIterator 2787 __parse_one_char_or_coll_elem_ERE(_ForwardIterator __first, _ForwardIterator __last); 2788 template <class _ForwardIterator> 2789 _ForwardIterator 2790 __parse_ORD_CHAR_ERE(_ForwardIterator __first, _ForwardIterator __last); 2791 template <class _ForwardIterator> 2792 _ForwardIterator 2793 __parse_QUOTED_CHAR_ERE(_ForwardIterator __first, _ForwardIterator __last); 2794 template <class _ForwardIterator> 2795 _ForwardIterator 2796 __parse_ecma_exp(_ForwardIterator __first, _ForwardIterator __last); 2797 template <class _ForwardIterator> 2798 _ForwardIterator 2799 __parse_alternative(_ForwardIterator __first, _ForwardIterator __last); 2800 template <class _ForwardIterator> 2801 _ForwardIterator 2802 __parse_term(_ForwardIterator __first, _ForwardIterator __last); 2803 template <class _ForwardIterator> 2804 _ForwardIterator 2805 __parse_assertion(_ForwardIterator __first, _ForwardIterator __last); 2806 template <class _ForwardIterator> 2807 _ForwardIterator 2808 __parse_atom(_ForwardIterator __first, _ForwardIterator __last); 2809 template <class _ForwardIterator> 2810 _ForwardIterator 2811 __parse_atom_escape(_ForwardIterator __first, _ForwardIterator __last); 2812 template <class _ForwardIterator> 2813 _ForwardIterator 2814 __parse_decimal_escape(_ForwardIterator __first, _ForwardIterator __last); 2815 template <class _ForwardIterator> 2816 _ForwardIterator 2817 __parse_character_class_escape(_ForwardIterator __first, _ForwardIterator __last); 2818 template <class _ForwardIterator> 2819 _ForwardIterator 2820 __parse_character_escape(_ForwardIterator __first, _ForwardIterator __last, 2821 basic_string<_CharT>* __str = nullptr); 2822 template <class _ForwardIterator> 2823 _ForwardIterator 2824 __parse_pattern_character(_ForwardIterator __first, _ForwardIterator __last); 2825 template <class _ForwardIterator> 2826 _ForwardIterator 2827 __parse_grep(_ForwardIterator __first, _ForwardIterator __last); 2828 template <class _ForwardIterator> 2829 _ForwardIterator 2830 __parse_egrep(_ForwardIterator __first, _ForwardIterator __last); 2831 template <class _ForwardIterator> 2832 _ForwardIterator 2833 __parse_class_escape(_ForwardIterator __first, _ForwardIterator __last, 2834 basic_string<_CharT>& __str, 2835 __bracket_expression<_CharT, _Traits>* __ml); 2836 template <class _ForwardIterator> 2837 _ForwardIterator 2838 __parse_awk_escape(_ForwardIterator __first, _ForwardIterator __last, 2839 basic_string<_CharT>* __str = nullptr); 2840 2841 _LIBCPP_INLINE_VISIBILITY 2842 void __push_l_anchor(); 2843 void __push_r_anchor(); 2844 void __push_match_any(); 2845 void __push_match_any_but_newline(); 2846 _LIBCPP_INLINE_VISIBILITY 2847 void __push_greedy_inf_repeat(size_t __min, __owns_one_state<_CharT>* __s, 2848 unsigned __mexp_begin = 0, unsigned __mexp_end = 0) 2849 {__push_loop(__min, numeric_limits<size_t>::max(), __s, 2850 __mexp_begin, __mexp_end);} 2851 _LIBCPP_INLINE_VISIBILITY 2852 void __push_nongreedy_inf_repeat(size_t __min, __owns_one_state<_CharT>* __s, 2853 unsigned __mexp_begin = 0, unsigned __mexp_end = 0) 2854 {__push_loop(__min, numeric_limits<size_t>::max(), __s, 2855 __mexp_begin, __mexp_end, false);} 2856 void __push_loop(size_t __min, size_t __max, __owns_one_state<_CharT>* __s, 2857 size_t __mexp_begin = 0, size_t __mexp_end = 0, 2858 bool __greedy = true); 2859 __bracket_expression<_CharT, _Traits>* __start_matching_list(bool __negate); 2860 void __push_char(value_type __c); 2861 void __push_back_ref(int __i); 2862 void __push_alternation(__owns_one_state<_CharT>* __sa, 2863 __owns_one_state<_CharT>* __sb); 2864 void __push_begin_marked_subexpression(); 2865 void __push_end_marked_subexpression(unsigned); 2866 void __push_empty(); 2867 void __push_word_boundary(bool); 2868 void __push_lookahead(const basic_regex&, bool, unsigned); 2869 2870 template <class _Allocator> 2871 bool 2872 __search(const _CharT* __first, const _CharT* __last, 2873 match_results<const _CharT*, _Allocator>& __m, 2874 regex_constants::match_flag_type __flags) const; 2875 2876 template <class _Allocator> 2877 bool 2878 __match_at_start(const _CharT* __first, const _CharT* __last, 2879 match_results<const _CharT*, _Allocator>& __m, 2880 regex_constants::match_flag_type __flags, bool) const; 2881 template <class _Allocator> 2882 bool 2883 __match_at_start_ecma(const _CharT* __first, const _CharT* __last, 2884 match_results<const _CharT*, _Allocator>& __m, 2885 regex_constants::match_flag_type __flags, bool) const; 2886 template <class _Allocator> 2887 bool 2888 __match_at_start_posix_nosubs(const _CharT* __first, const _CharT* __last, 2889 match_results<const _CharT*, _Allocator>& __m, 2890 regex_constants::match_flag_type __flags, bool) const; 2891 template <class _Allocator> 2892 bool 2893 __match_at_start_posix_subs(const _CharT* __first, const _CharT* __last, 2894 match_results<const _CharT*, _Allocator>& __m, 2895 regex_constants::match_flag_type __flags, bool) const; 2896 2897 template <class _Bp, class _Ap, class _Cp, class _Tp> 2898 friend 2899 bool 2900 regex_search(_Bp, _Bp, match_results<_Bp, _Ap>&, const basic_regex<_Cp, _Tp>&, 2901 regex_constants::match_flag_type); 2902 2903 template <class _Ap, class _Cp, class _Tp> 2904 friend 2905 bool 2906 regex_search(const _Cp*, const _Cp*, match_results<const _Cp*, _Ap>&, 2907 const basic_regex<_Cp, _Tp>&, regex_constants::match_flag_type); 2908 2909 template <class _Bp, class _Cp, class _Tp> 2910 friend 2911 bool 2912 regex_search(_Bp, _Bp, const basic_regex<_Cp, _Tp>&, 2913 regex_constants::match_flag_type); 2914 2915 template <class _Cp, class _Tp> 2916 friend 2917 bool 2918 regex_search(const _Cp*, const _Cp*, 2919 const basic_regex<_Cp, _Tp>&, regex_constants::match_flag_type); 2920 2921 template <class _Cp, class _Ap, class _Tp> 2922 friend 2923 bool 2924 regex_search(const _Cp*, match_results<const _Cp*, _Ap>&, const basic_regex<_Cp, _Tp>&, 2925 regex_constants::match_flag_type); 2926 2927 template <class _ST, class _SA, class _Cp, class _Tp> 2928 friend 2929 bool 2930 regex_search(const basic_string<_Cp, _ST, _SA>& __s, 2931 const basic_regex<_Cp, _Tp>& __e, 2932 regex_constants::match_flag_type __flags); 2933 2934 template <class _ST, class _SA, class _Ap, class _Cp, class _Tp> 2935 friend 2936 bool 2937 regex_search(const basic_string<_Cp, _ST, _SA>& __s, 2938 match_results<typename basic_string<_Cp, _ST, _SA>::const_iterator, _Ap>&, 2939 const basic_regex<_Cp, _Tp>& __e, 2940 regex_constants::match_flag_type __flags); 2941 2942 template <class _Iter, class _Ap, class _Cp, class _Tp> 2943 friend 2944 bool 2945 regex_search(__wrap_iter<_Iter> __first, 2946 __wrap_iter<_Iter> __last, 2947 match_results<__wrap_iter<_Iter>, _Ap>& __m, 2948 const basic_regex<_Cp, _Tp>& __e, 2949 regex_constants::match_flag_type __flags); 2950 2951 template <class, class> friend class __lookahead; 2952}; 2953 2954#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES 2955template <class _ForwardIterator, 2956 class = typename enable_if<__is_forward_iterator<_ForwardIterator>::value, nullptr_t>::type 2957> 2958basic_regex(_ForwardIterator, _ForwardIterator, 2959 regex_constants::syntax_option_type = regex_constants::ECMAScript) 2960 -> basic_regex<typename iterator_traits<_ForwardIterator>::value_type>; 2961#endif 2962 2963template <class _CharT, class _Traits> 2964 const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::icase; 2965template <class _CharT, class _Traits> 2966 const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::nosubs; 2967template <class _CharT, class _Traits> 2968 const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::optimize; 2969template <class _CharT, class _Traits> 2970 const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::collate; 2971template <class _CharT, class _Traits> 2972 const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::ECMAScript; 2973template <class _CharT, class _Traits> 2974 const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::basic; 2975template <class _CharT, class _Traits> 2976 const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::extended; 2977template <class _CharT, class _Traits> 2978 const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::awk; 2979template <class _CharT, class _Traits> 2980 const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::grep; 2981template <class _CharT, class _Traits> 2982 const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::egrep; 2983 2984template <class _CharT, class _Traits> 2985void 2986basic_regex<_CharT, _Traits>::swap(basic_regex& __r) 2987{ 2988 using _VSTD::swap; 2989 swap(__traits_, __r.__traits_); 2990 swap(__flags_, __r.__flags_); 2991 swap(__marked_count_, __r.__marked_count_); 2992 swap(__loop_count_, __r.__loop_count_); 2993 swap(__open_count_, __r.__open_count_); 2994 swap(__start_, __r.__start_); 2995 swap(__end_, __r.__end_); 2996} 2997 2998template <class _CharT, class _Traits> 2999inline _LIBCPP_INLINE_VISIBILITY 3000void 3001swap(basic_regex<_CharT, _Traits>& __x, basic_regex<_CharT, _Traits>& __y) 3002{ 3003 return __x.swap(__y); 3004} 3005 3006// __lookahead 3007 3008template <class _CharT, class _Traits> 3009class __lookahead 3010 : public __owns_one_state<_CharT> 3011{ 3012 typedef __owns_one_state<_CharT> base; 3013 3014 basic_regex<_CharT, _Traits> __exp_; 3015 unsigned __mexp_; 3016 bool __invert_; 3017 3018 __lookahead(const __lookahead&); 3019 __lookahead& operator=(const __lookahead&); 3020public: 3021 typedef _VSTD::__state<_CharT> __state; 3022 3023 _LIBCPP_INLINE_VISIBILITY 3024 __lookahead(const basic_regex<_CharT, _Traits>& __exp, bool __invert, __node<_CharT>* __s, unsigned __mexp) 3025 : base(__s), __exp_(__exp), __mexp_(__mexp), __invert_(__invert) {} 3026 3027 virtual void __exec(__state&) const; 3028}; 3029 3030template <class _CharT, class _Traits> 3031void 3032__lookahead<_CharT, _Traits>::__exec(__state& __s) const 3033{ 3034 match_results<const _CharT*> __m; 3035 __m.__init(1 + __exp_.mark_count(), __s.__current_, __s.__last_); 3036 bool __matched = __exp_.__match_at_start_ecma( 3037 __s.__current_, __s.__last_, 3038 __m, 3039 (__s.__flags_ | regex_constants::match_continuous) & 3040 ~regex_constants::__full_match, 3041 __s.__at_first_ && __s.__current_ == __s.__first_); 3042 if (__matched != __invert_) 3043 { 3044 __s.__do_ = __state::__accept_but_not_consume; 3045 __s.__node_ = this->first(); 3046 for (unsigned __i = 1; __i < __m.size(); ++__i) { 3047 __s.__sub_matches_[__mexp_ + __i - 1] = __m.__matches_[__i]; 3048 } 3049 } 3050 else 3051 { 3052 __s.__do_ = __state::__reject; 3053 __s.__node_ = nullptr; 3054 } 3055} 3056 3057template <class _CharT, class _Traits> 3058template <class _ForwardIterator> 3059_ForwardIterator 3060basic_regex<_CharT, _Traits>::__parse(_ForwardIterator __first, 3061 _ForwardIterator __last) 3062{ 3063 { 3064 unique_ptr<__node> __h(new __end_state<_CharT>); 3065 __start_.reset(new __empty_state<_CharT>(__h.get())); 3066 __h.release(); 3067 __end_ = __start_.get(); 3068 } 3069 switch (__get_grammar(__flags_)) 3070 { 3071 case ECMAScript: 3072 __first = __parse_ecma_exp(__first, __last); 3073 break; 3074 case basic: 3075 __first = __parse_basic_reg_exp(__first, __last); 3076 break; 3077 case extended: 3078 case awk: 3079 __first = __parse_extended_reg_exp(__first, __last); 3080 break; 3081 case grep: 3082 __first = __parse_grep(__first, __last); 3083 break; 3084 case egrep: 3085 __first = __parse_egrep(__first, __last); 3086 break; 3087 default: 3088 __throw_regex_error<regex_constants::__re_err_grammar>(); 3089 } 3090 return __first; 3091} 3092 3093template <class _CharT, class _Traits> 3094template <class _ForwardIterator> 3095_ForwardIterator 3096basic_regex<_CharT, _Traits>::__parse_basic_reg_exp(_ForwardIterator __first, 3097 _ForwardIterator __last) 3098{ 3099 if (__first != __last) 3100 { 3101 if (*__first == '^') 3102 { 3103 __push_l_anchor(); 3104 ++__first; 3105 } 3106 if (__first != __last) 3107 { 3108 __first = __parse_RE_expression(__first, __last); 3109 if (__first != __last) 3110 { 3111 _ForwardIterator __temp = _VSTD::next(__first); 3112 if (__temp == __last && *__first == '$') 3113 { 3114 __push_r_anchor(); 3115 ++__first; 3116 } 3117 } 3118 } 3119 if (__first != __last) 3120 __throw_regex_error<regex_constants::__re_err_empty>(); 3121 } 3122 return __first; 3123} 3124 3125template <class _CharT, class _Traits> 3126template <class _ForwardIterator> 3127_ForwardIterator 3128basic_regex<_CharT, _Traits>::__parse_extended_reg_exp(_ForwardIterator __first, 3129 _ForwardIterator __last) 3130{ 3131 __owns_one_state<_CharT>* __sa = __end_; 3132 _ForwardIterator __temp = __parse_ERE_branch(__first, __last); 3133 if (__temp == __first) 3134 __throw_regex_error<regex_constants::__re_err_empty>(); 3135 __first = __temp; 3136 while (__first != __last && *__first == '|') 3137 { 3138 __owns_one_state<_CharT>* __sb = __end_; 3139 __temp = __parse_ERE_branch(++__first, __last); 3140 if (__temp == __first) 3141 __throw_regex_error<regex_constants::__re_err_empty>(); 3142 __push_alternation(__sa, __sb); 3143 __first = __temp; 3144 } 3145 return __first; 3146} 3147 3148template <class _CharT, class _Traits> 3149template <class _ForwardIterator> 3150_ForwardIterator 3151basic_regex<_CharT, _Traits>::__parse_ERE_branch(_ForwardIterator __first, 3152 _ForwardIterator __last) 3153{ 3154 _ForwardIterator __temp = __parse_ERE_expression(__first, __last); 3155 if (__temp == __first) 3156 __throw_regex_error<regex_constants::__re_err_empty>(); 3157 do 3158 { 3159 __first = __temp; 3160 __temp = __parse_ERE_expression(__first, __last); 3161 } while (__temp != __first); 3162 return __first; 3163} 3164 3165template <class _CharT, class _Traits> 3166template <class _ForwardIterator> 3167_ForwardIterator 3168basic_regex<_CharT, _Traits>::__parse_ERE_expression(_ForwardIterator __first, 3169 _ForwardIterator __last) 3170{ 3171 __owns_one_state<_CharT>* __e = __end_; 3172 unsigned __mexp_begin = __marked_count_; 3173 _ForwardIterator __temp = __parse_one_char_or_coll_elem_ERE(__first, __last); 3174 if (__temp == __first && __temp != __last) 3175 { 3176 switch (*__temp) 3177 { 3178 case '^': 3179 __push_l_anchor(); 3180 ++__temp; 3181 break; 3182 case '$': 3183 __push_r_anchor(); 3184 ++__temp; 3185 break; 3186 case '(': 3187 __push_begin_marked_subexpression(); 3188 unsigned __temp_count = __marked_count_; 3189 ++__open_count_; 3190 __temp = __parse_extended_reg_exp(++__temp, __last); 3191 if (__temp == __last || *__temp != ')') 3192 __throw_regex_error<regex_constants::error_paren>(); 3193 __push_end_marked_subexpression(__temp_count); 3194 --__open_count_; 3195 ++__temp; 3196 break; 3197 } 3198 } 3199 if (__temp != __first) 3200 __temp = __parse_ERE_dupl_symbol(__temp, __last, __e, __mexp_begin+1, 3201 __marked_count_+1); 3202 __first = __temp; 3203 return __first; 3204} 3205 3206template <class _CharT, class _Traits> 3207template <class _ForwardIterator> 3208_ForwardIterator 3209basic_regex<_CharT, _Traits>::__parse_RE_expression(_ForwardIterator __first, 3210 _ForwardIterator __last) 3211{ 3212 while (true) 3213 { 3214 _ForwardIterator __temp = __parse_simple_RE(__first, __last); 3215 if (__temp == __first) 3216 break; 3217 __first = __temp; 3218 } 3219 return __first; 3220} 3221 3222template <class _CharT, class _Traits> 3223template <class _ForwardIterator> 3224_ForwardIterator 3225basic_regex<_CharT, _Traits>::__parse_simple_RE(_ForwardIterator __first, 3226 _ForwardIterator __last) 3227{ 3228 if (__first != __last) 3229 { 3230 __owns_one_state<_CharT>* __e = __end_; 3231 unsigned __mexp_begin = __marked_count_; 3232 _ForwardIterator __temp = __parse_nondupl_RE(__first, __last); 3233 if (__temp != __first) 3234 __first = __parse_RE_dupl_symbol(__temp, __last, __e, 3235 __mexp_begin+1, __marked_count_+1); 3236 } 3237 return __first; 3238} 3239 3240template <class _CharT, class _Traits> 3241template <class _ForwardIterator> 3242_ForwardIterator 3243basic_regex<_CharT, _Traits>::__parse_nondupl_RE(_ForwardIterator __first, 3244 _ForwardIterator __last) 3245{ 3246 _ForwardIterator __temp = __first; 3247 __first = __parse_one_char_or_coll_elem_RE(__first, __last); 3248 if (__temp == __first) 3249 { 3250 __temp = __parse_Back_open_paren(__first, __last); 3251 if (__temp != __first) 3252 { 3253 __push_begin_marked_subexpression(); 3254 unsigned __temp_count = __marked_count_; 3255 __first = __parse_RE_expression(__temp, __last); 3256 __temp = __parse_Back_close_paren(__first, __last); 3257 if (__temp == __first) 3258 __throw_regex_error<regex_constants::error_paren>(); 3259 __push_end_marked_subexpression(__temp_count); 3260 __first = __temp; 3261 } 3262 else 3263 __first = __parse_BACKREF(__first, __last); 3264 } 3265 return __first; 3266} 3267 3268template <class _CharT, class _Traits> 3269template <class _ForwardIterator> 3270_ForwardIterator 3271basic_regex<_CharT, _Traits>::__parse_one_char_or_coll_elem_RE( 3272 _ForwardIterator __first, 3273 _ForwardIterator __last) 3274{ 3275 _ForwardIterator __temp = __parse_ORD_CHAR(__first, __last); 3276 if (__temp == __first) 3277 { 3278 __temp = __parse_QUOTED_CHAR(__first, __last); 3279 if (__temp == __first) 3280 { 3281 if (__temp != __last && *__temp == '.') 3282 { 3283 __push_match_any(); 3284 ++__temp; 3285 } 3286 else 3287 __temp = __parse_bracket_expression(__first, __last); 3288 } 3289 } 3290 __first = __temp; 3291 return __first; 3292} 3293 3294template <class _CharT, class _Traits> 3295template <class _ForwardIterator> 3296_ForwardIterator 3297basic_regex<_CharT, _Traits>::__parse_one_char_or_coll_elem_ERE( 3298 _ForwardIterator __first, 3299 _ForwardIterator __last) 3300{ 3301 _ForwardIterator __temp = __parse_ORD_CHAR_ERE(__first, __last); 3302 if (__temp == __first) 3303 { 3304 __temp = __parse_QUOTED_CHAR_ERE(__first, __last); 3305 if (__temp == __first) 3306 { 3307 if (__temp != __last && *__temp == '.') 3308 { 3309 __push_match_any(); 3310 ++__temp; 3311 } 3312 else 3313 __temp = __parse_bracket_expression(__first, __last); 3314 } 3315 } 3316 __first = __temp; 3317 return __first; 3318} 3319 3320template <class _CharT, class _Traits> 3321template <class _ForwardIterator> 3322_ForwardIterator 3323basic_regex<_CharT, _Traits>::__parse_Back_open_paren(_ForwardIterator __first, 3324 _ForwardIterator __last) 3325{ 3326 if (__first != __last) 3327 { 3328 _ForwardIterator __temp = _VSTD::next(__first); 3329 if (__temp != __last) 3330 { 3331 if (*__first == '\\' && *__temp == '(') 3332 __first = ++__temp; 3333 } 3334 } 3335 return __first; 3336} 3337 3338template <class _CharT, class _Traits> 3339template <class _ForwardIterator> 3340_ForwardIterator 3341basic_regex<_CharT, _Traits>::__parse_Back_close_paren(_ForwardIterator __first, 3342 _ForwardIterator __last) 3343{ 3344 if (__first != __last) 3345 { 3346 _ForwardIterator __temp = _VSTD::next(__first); 3347 if (__temp != __last) 3348 { 3349 if (*__first == '\\' && *__temp == ')') 3350 __first = ++__temp; 3351 } 3352 } 3353 return __first; 3354} 3355 3356template <class _CharT, class _Traits> 3357template <class _ForwardIterator> 3358_ForwardIterator 3359basic_regex<_CharT, _Traits>::__parse_Back_open_brace(_ForwardIterator __first, 3360 _ForwardIterator __last) 3361{ 3362 if (__first != __last) 3363 { 3364 _ForwardIterator __temp = _VSTD::next(__first); 3365 if (__temp != __last) 3366 { 3367 if (*__first == '\\' && *__temp == '{') 3368 __first = ++__temp; 3369 } 3370 } 3371 return __first; 3372} 3373 3374template <class _CharT, class _Traits> 3375template <class _ForwardIterator> 3376_ForwardIterator 3377basic_regex<_CharT, _Traits>::__parse_Back_close_brace(_ForwardIterator __first, 3378 _ForwardIterator __last) 3379{ 3380 if (__first != __last) 3381 { 3382 _ForwardIterator __temp = _VSTD::next(__first); 3383 if (__temp != __last) 3384 { 3385 if (*__first == '\\' && *__temp == '}') 3386 __first = ++__temp; 3387 } 3388 } 3389 return __first; 3390} 3391 3392template <class _CharT, class _Traits> 3393template <class _ForwardIterator> 3394_ForwardIterator 3395basic_regex<_CharT, _Traits>::__parse_BACKREF(_ForwardIterator __first, 3396 _ForwardIterator __last) 3397{ 3398 if (__first != __last) 3399 { 3400 _ForwardIterator __temp = _VSTD::next(__first); 3401 if (__temp != __last) 3402 { 3403 if (*__first == '\\') 3404 { 3405 int __val = __traits_.value(*__temp, 10); 3406 if (__val >= 1 && __val <= 9) 3407 { 3408 __push_back_ref(__val); 3409 __first = ++__temp; 3410 } 3411 } 3412 } 3413 } 3414 return __first; 3415} 3416 3417template <class _CharT, class _Traits> 3418template <class _ForwardIterator> 3419_ForwardIterator 3420basic_regex<_CharT, _Traits>::__parse_ORD_CHAR(_ForwardIterator __first, 3421 _ForwardIterator __last) 3422{ 3423 if (__first != __last) 3424 { 3425 _ForwardIterator __temp = _VSTD::next(__first); 3426 if (__temp == __last && *__first == '$') 3427 return __first; 3428 // Not called inside a bracket 3429 if (*__first == '.' || *__first == '\\' || *__first == '[') 3430 return __first; 3431 __push_char(*__first); 3432 ++__first; 3433 } 3434 return __first; 3435} 3436 3437template <class _CharT, class _Traits> 3438template <class _ForwardIterator> 3439_ForwardIterator 3440basic_regex<_CharT, _Traits>::__parse_ORD_CHAR_ERE(_ForwardIterator __first, 3441 _ForwardIterator __last) 3442{ 3443 if (__first != __last) 3444 { 3445 switch (*__first) 3446 { 3447 case '^': 3448 case '.': 3449 case '[': 3450 case '$': 3451 case '(': 3452 case '|': 3453 case '*': 3454 case '+': 3455 case '?': 3456 case '{': 3457 case '\\': 3458 break; 3459 case ')': 3460 if (__open_count_ == 0) 3461 { 3462 __push_char(*__first); 3463 ++__first; 3464 } 3465 break; 3466 default: 3467 __push_char(*__first); 3468 ++__first; 3469 break; 3470 } 3471 } 3472 return __first; 3473} 3474 3475template <class _CharT, class _Traits> 3476template <class _ForwardIterator> 3477_ForwardIterator 3478basic_regex<_CharT, _Traits>::__parse_QUOTED_CHAR(_ForwardIterator __first, 3479 _ForwardIterator __last) 3480{ 3481 if (__first != __last) 3482 { 3483 _ForwardIterator __temp = _VSTD::next(__first); 3484 if (__temp != __last) 3485 { 3486 if (*__first == '\\') 3487 { 3488 switch (*__temp) 3489 { 3490 case '^': 3491 case '.': 3492 case '*': 3493 case '[': 3494 case '$': 3495 case '\\': 3496 __push_char(*__temp); 3497 __first = ++__temp; 3498 break; 3499 } 3500 } 3501 } 3502 } 3503 return __first; 3504} 3505 3506template <class _CharT, class _Traits> 3507template <class _ForwardIterator> 3508_ForwardIterator 3509basic_regex<_CharT, _Traits>::__parse_QUOTED_CHAR_ERE(_ForwardIterator __first, 3510 _ForwardIterator __last) 3511{ 3512 if (__first != __last) 3513 { 3514 _ForwardIterator __temp = _VSTD::next(__first); 3515 if (__temp != __last) 3516 { 3517 if (*__first == '\\') 3518 { 3519 switch (*__temp) 3520 { 3521 case '^': 3522 case '.': 3523 case '*': 3524 case '[': 3525 case '$': 3526 case '\\': 3527 case '(': 3528 case ')': 3529 case '|': 3530 case '+': 3531 case '?': 3532 case '{': 3533 case '}': 3534 __push_char(*__temp); 3535 __first = ++__temp; 3536 break; 3537 default: 3538 if (__get_grammar(__flags_) == awk) 3539 __first = __parse_awk_escape(++__first, __last); 3540 break; 3541 } 3542 } 3543 } 3544 } 3545 return __first; 3546} 3547 3548template <class _CharT, class _Traits> 3549template <class _ForwardIterator> 3550_ForwardIterator 3551basic_regex<_CharT, _Traits>::__parse_RE_dupl_symbol(_ForwardIterator __first, 3552 _ForwardIterator __last, 3553 __owns_one_state<_CharT>* __s, 3554 unsigned __mexp_begin, 3555 unsigned __mexp_end) 3556{ 3557 if (__first != __last) 3558 { 3559 if (*__first == '*') 3560 { 3561 __push_greedy_inf_repeat(0, __s, __mexp_begin, __mexp_end); 3562 ++__first; 3563 } 3564 else 3565 { 3566 _ForwardIterator __temp = __parse_Back_open_brace(__first, __last); 3567 if (__temp != __first) 3568 { 3569 int __min = 0; 3570 __first = __temp; 3571 __temp = __parse_DUP_COUNT(__first, __last, __min); 3572 if (__temp == __first) 3573 __throw_regex_error<regex_constants::error_badbrace>(); 3574 __first = __temp; 3575 if (__first == __last) 3576 __throw_regex_error<regex_constants::error_brace>(); 3577 if (*__first != ',') 3578 { 3579 __temp = __parse_Back_close_brace(__first, __last); 3580 if (__temp == __first) 3581 __throw_regex_error<regex_constants::error_brace>(); 3582 __push_loop(__min, __min, __s, __mexp_begin, __mexp_end, 3583 true); 3584 __first = __temp; 3585 } 3586 else 3587 { 3588 ++__first; // consume ',' 3589 int __max = -1; 3590 __first = __parse_DUP_COUNT(__first, __last, __max); 3591 __temp = __parse_Back_close_brace(__first, __last); 3592 if (__temp == __first) 3593 __throw_regex_error<regex_constants::error_brace>(); 3594 if (__max == -1) 3595 __push_greedy_inf_repeat(__min, __s, __mexp_begin, __mexp_end); 3596 else 3597 { 3598 if (__max < __min) 3599 __throw_regex_error<regex_constants::error_badbrace>(); 3600 __push_loop(__min, __max, __s, __mexp_begin, __mexp_end, 3601 true); 3602 } 3603 __first = __temp; 3604 } 3605 } 3606 } 3607 } 3608 return __first; 3609} 3610 3611template <class _CharT, class _Traits> 3612template <class _ForwardIterator> 3613_ForwardIterator 3614basic_regex<_CharT, _Traits>::__parse_ERE_dupl_symbol(_ForwardIterator __first, 3615 _ForwardIterator __last, 3616 __owns_one_state<_CharT>* __s, 3617 unsigned __mexp_begin, 3618 unsigned __mexp_end) 3619{ 3620 if (__first != __last) 3621 { 3622 unsigned __grammar = __get_grammar(__flags_); 3623 switch (*__first) 3624 { 3625 case '*': 3626 ++__first; 3627 if (__grammar == ECMAScript && __first != __last && *__first == '?') 3628 { 3629 ++__first; 3630 __push_nongreedy_inf_repeat(0, __s, __mexp_begin, __mexp_end); 3631 } 3632 else 3633 __push_greedy_inf_repeat(0, __s, __mexp_begin, __mexp_end); 3634 break; 3635 case '+': 3636 ++__first; 3637 if (__grammar == ECMAScript && __first != __last && *__first == '?') 3638 { 3639 ++__first; 3640 __push_nongreedy_inf_repeat(1, __s, __mexp_begin, __mexp_end); 3641 } 3642 else 3643 __push_greedy_inf_repeat(1, __s, __mexp_begin, __mexp_end); 3644 break; 3645 case '?': 3646 ++__first; 3647 if (__grammar == ECMAScript && __first != __last && *__first == '?') 3648 { 3649 ++__first; 3650 __push_loop(0, 1, __s, __mexp_begin, __mexp_end, false); 3651 } 3652 else 3653 __push_loop(0, 1, __s, __mexp_begin, __mexp_end); 3654 break; 3655 case '{': 3656 { 3657 int __min; 3658 _ForwardIterator __temp = __parse_DUP_COUNT(++__first, __last, __min); 3659 if (__temp == __first) 3660 __throw_regex_error<regex_constants::error_badbrace>(); 3661 __first = __temp; 3662 if (__first == __last) 3663 __throw_regex_error<regex_constants::error_brace>(); 3664 switch (*__first) 3665 { 3666 case '}': 3667 ++__first; 3668 if (__grammar == ECMAScript && __first != __last && *__first == '?') 3669 { 3670 ++__first; 3671 __push_loop(__min, __min, __s, __mexp_begin, __mexp_end, false); 3672 } 3673 else 3674 __push_loop(__min, __min, __s, __mexp_begin, __mexp_end); 3675 break; 3676 case ',': 3677 ++__first; 3678 if (__first == __last) 3679 __throw_regex_error<regex_constants::error_badbrace>(); 3680 if (*__first == '}') 3681 { 3682 ++__first; 3683 if (__grammar == ECMAScript && __first != __last && *__first == '?') 3684 { 3685 ++__first; 3686 __push_nongreedy_inf_repeat(__min, __s, __mexp_begin, __mexp_end); 3687 } 3688 else 3689 __push_greedy_inf_repeat(__min, __s, __mexp_begin, __mexp_end); 3690 } 3691 else 3692 { 3693 int __max = -1; 3694 __temp = __parse_DUP_COUNT(__first, __last, __max); 3695 if (__temp == __first) 3696 __throw_regex_error<regex_constants::error_brace>(); 3697 __first = __temp; 3698 if (__first == __last || *__first != '}') 3699 __throw_regex_error<regex_constants::error_brace>(); 3700 ++__first; 3701 if (__max < __min) 3702 __throw_regex_error<regex_constants::error_badbrace>(); 3703 if (__grammar == ECMAScript && __first != __last && *__first == '?') 3704 { 3705 ++__first; 3706 __push_loop(__min, __max, __s, __mexp_begin, __mexp_end, false); 3707 } 3708 else 3709 __push_loop(__min, __max, __s, __mexp_begin, __mexp_end); 3710 } 3711 break; 3712 default: 3713 __throw_regex_error<regex_constants::error_badbrace>(); 3714 } 3715 } 3716 break; 3717 } 3718 } 3719 return __first; 3720} 3721 3722template <class _CharT, class _Traits> 3723template <class _ForwardIterator> 3724_ForwardIterator 3725basic_regex<_CharT, _Traits>::__parse_bracket_expression(_ForwardIterator __first, 3726 _ForwardIterator __last) 3727{ 3728 if (__first != __last && *__first == '[') 3729 { 3730 ++__first; 3731 if (__first == __last) 3732 __throw_regex_error<regex_constants::error_brack>(); 3733 bool __negate = false; 3734 if (*__first == '^') 3735 { 3736 ++__first; 3737 __negate = true; 3738 } 3739 __bracket_expression<_CharT, _Traits>* __ml = __start_matching_list(__negate); 3740 // __ml owned by *this 3741 if (__first == __last) 3742 __throw_regex_error<regex_constants::error_brack>(); 3743 if (__get_grammar(__flags_) != ECMAScript && *__first == ']') 3744 { 3745 __ml->__add_char(']'); 3746 ++__first; 3747 } 3748 __first = __parse_follow_list(__first, __last, __ml); 3749 if (__first == __last) 3750 __throw_regex_error<regex_constants::error_brack>(); 3751 if (*__first == '-') 3752 { 3753 __ml->__add_char('-'); 3754 ++__first; 3755 } 3756 if (__first == __last || *__first != ']') 3757 __throw_regex_error<regex_constants::error_brack>(); 3758 ++__first; 3759 } 3760 return __first; 3761} 3762 3763template <class _CharT, class _Traits> 3764template <class _ForwardIterator> 3765_ForwardIterator 3766basic_regex<_CharT, _Traits>::__parse_follow_list(_ForwardIterator __first, 3767 _ForwardIterator __last, 3768 __bracket_expression<_CharT, _Traits>* __ml) 3769{ 3770 if (__first != __last) 3771 { 3772 while (true) 3773 { 3774 _ForwardIterator __temp = __parse_expression_term(__first, __last, 3775 __ml); 3776 if (__temp == __first) 3777 break; 3778 __first = __temp; 3779 } 3780 } 3781 return __first; 3782} 3783 3784template <class _CharT, class _Traits> 3785template <class _ForwardIterator> 3786_ForwardIterator 3787basic_regex<_CharT, _Traits>::__parse_expression_term(_ForwardIterator __first, 3788 _ForwardIterator __last, 3789 __bracket_expression<_CharT, _Traits>* __ml) 3790{ 3791 if (__first != __last && *__first != ']') 3792 { 3793 _ForwardIterator __temp = _VSTD::next(__first); 3794 basic_string<_CharT> __start_range; 3795 if (__temp != __last && *__first == '[') 3796 { 3797 if (*__temp == '=') 3798 return __parse_equivalence_class(++__temp, __last, __ml); 3799 else if (*__temp == ':') 3800 return __parse_character_class(++__temp, __last, __ml); 3801 else if (*__temp == '.') 3802 __first = __parse_collating_symbol(++__temp, __last, __start_range); 3803 } 3804 unsigned __grammar = __get_grammar(__flags_); 3805 if (__start_range.empty()) 3806 { 3807 if ((__grammar == ECMAScript || __grammar == awk) && *__first == '\\') 3808 { 3809 if (__grammar == ECMAScript) 3810 __first = __parse_class_escape(++__first, __last, __start_range, __ml); 3811 else 3812 __first = __parse_awk_escape(++__first, __last, &__start_range); 3813 } 3814 else 3815 { 3816 __start_range = *__first; 3817 ++__first; 3818 } 3819 } 3820 if (__first != __last && *__first != ']') 3821 { 3822 __temp = _VSTD::next(__first); 3823 if (__temp != __last && *__first == '-' && *__temp != ']') 3824 { 3825 // parse a range 3826 basic_string<_CharT> __end_range; 3827 __first = __temp; 3828 ++__temp; 3829 if (__temp != __last && *__first == '[' && *__temp == '.') 3830 __first = __parse_collating_symbol(++__temp, __last, __end_range); 3831 else 3832 { 3833 if ((__grammar == ECMAScript || __grammar == awk) && *__first == '\\') 3834 { 3835 if (__grammar == ECMAScript) 3836 __first = __parse_class_escape(++__first, __last, 3837 __end_range, __ml); 3838 else 3839 __first = __parse_awk_escape(++__first, __last, 3840 &__end_range); 3841 } 3842 else 3843 { 3844 __end_range = *__first; 3845 ++__first; 3846 } 3847 } 3848 __ml->__add_range(_VSTD::move(__start_range), _VSTD::move(__end_range)); 3849 } 3850 else if (!__start_range.empty()) 3851 { 3852 if (__start_range.size() == 1) 3853 __ml->__add_char(__start_range[0]); 3854 else 3855 __ml->__add_digraph(__start_range[0], __start_range[1]); 3856 } 3857 } 3858 else if (!__start_range.empty()) 3859 { 3860 if (__start_range.size() == 1) 3861 __ml->__add_char(__start_range[0]); 3862 else 3863 __ml->__add_digraph(__start_range[0], __start_range[1]); 3864 } 3865 } 3866 return __first; 3867} 3868 3869template <class _CharT, class _Traits> 3870template <class _ForwardIterator> 3871_ForwardIterator 3872basic_regex<_CharT, _Traits>::__parse_class_escape(_ForwardIterator __first, 3873 _ForwardIterator __last, 3874 basic_string<_CharT>& __str, 3875 __bracket_expression<_CharT, _Traits>* __ml) 3876{ 3877 if (__first == __last) 3878 __throw_regex_error<regex_constants::error_escape>(); 3879 switch (*__first) 3880 { 3881 case 0: 3882 __str = *__first; 3883 return ++__first; 3884 case 'b': 3885 __str = _CharT(8); 3886 return ++__first; 3887 case 'd': 3888 __ml->__add_class(ctype_base::digit); 3889 return ++__first; 3890 case 'D': 3891 __ml->__add_neg_class(ctype_base::digit); 3892 return ++__first; 3893 case 's': 3894 __ml->__add_class(ctype_base::space); 3895 return ++__first; 3896 case 'S': 3897 __ml->__add_neg_class(ctype_base::space); 3898 return ++__first; 3899 case 'w': 3900 __ml->__add_class(ctype_base::alnum); 3901 __ml->__add_char('_'); 3902 return ++__first; 3903 case 'W': 3904 __ml->__add_neg_class(ctype_base::alnum); 3905 __ml->__add_neg_char('_'); 3906 return ++__first; 3907 } 3908 __first = __parse_character_escape(__first, __last, &__str); 3909 return __first; 3910} 3911 3912template <class _CharT, class _Traits> 3913template <class _ForwardIterator> 3914_ForwardIterator 3915basic_regex<_CharT, _Traits>::__parse_awk_escape(_ForwardIterator __first, 3916 _ForwardIterator __last, 3917 basic_string<_CharT>* __str) 3918{ 3919 if (__first == __last) 3920 __throw_regex_error<regex_constants::error_escape>(); 3921 switch (*__first) 3922 { 3923 case '\\': 3924 case '"': 3925 case '/': 3926 if (__str) 3927 *__str = *__first; 3928 else 3929 __push_char(*__first); 3930 return ++__first; 3931 case 'a': 3932 if (__str) 3933 *__str = _CharT(7); 3934 else 3935 __push_char(_CharT(7)); 3936 return ++__first; 3937 case 'b': 3938 if (__str) 3939 *__str = _CharT(8); 3940 else 3941 __push_char(_CharT(8)); 3942 return ++__first; 3943 case 'f': 3944 if (__str) 3945 *__str = _CharT(0xC); 3946 else 3947 __push_char(_CharT(0xC)); 3948 return ++__first; 3949 case 'n': 3950 if (__str) 3951 *__str = _CharT(0xA); 3952 else 3953 __push_char(_CharT(0xA)); 3954 return ++__first; 3955 case 'r': 3956 if (__str) 3957 *__str = _CharT(0xD); 3958 else 3959 __push_char(_CharT(0xD)); 3960 return ++__first; 3961 case 't': 3962 if (__str) 3963 *__str = _CharT(0x9); 3964 else 3965 __push_char(_CharT(0x9)); 3966 return ++__first; 3967 case 'v': 3968 if (__str) 3969 *__str = _CharT(0xB); 3970 else 3971 __push_char(_CharT(0xB)); 3972 return ++__first; 3973 } 3974 if ('0' <= *__first && *__first <= '7') 3975 { 3976 unsigned __val = *__first - '0'; 3977 if (++__first != __last && ('0' <= *__first && *__first <= '7')) 3978 { 3979 __val = 8 * __val + *__first - '0'; 3980 if (++__first != __last && ('0' <= *__first && *__first <= '7')) 3981 __val = 8 * __val + *__first++ - '0'; 3982 } 3983 if (__str) 3984 *__str = _CharT(__val); 3985 else 3986 __push_char(_CharT(__val)); 3987 } 3988 else 3989 __throw_regex_error<regex_constants::error_escape>(); 3990 return __first; 3991} 3992 3993template <class _CharT, class _Traits> 3994template <class _ForwardIterator> 3995_ForwardIterator 3996basic_regex<_CharT, _Traits>::__parse_equivalence_class(_ForwardIterator __first, 3997 _ForwardIterator __last, 3998 __bracket_expression<_CharT, _Traits>* __ml) 3999{ 4000 // Found [= 4001 // This means =] must exist 4002 value_type _Equal_close[2] = {'=', ']'}; 4003 _ForwardIterator __temp = _VSTD::search(__first, __last, _Equal_close, 4004 _Equal_close+2); 4005 if (__temp == __last) 4006 __throw_regex_error<regex_constants::error_brack>(); 4007 // [__first, __temp) contains all text in [= ... =] 4008 string_type __collate_name = 4009 __traits_.lookup_collatename(__first, __temp); 4010 if (__collate_name.empty()) 4011 __throw_regex_error<regex_constants::error_collate>(); 4012 string_type __equiv_name = 4013 __traits_.transform_primary(__collate_name.begin(), 4014 __collate_name.end()); 4015 if (!__equiv_name.empty()) 4016 __ml->__add_equivalence(__equiv_name); 4017 else 4018 { 4019 switch (__collate_name.size()) 4020 { 4021 case 1: 4022 __ml->__add_char(__collate_name[0]); 4023 break; 4024 case 2: 4025 __ml->__add_digraph(__collate_name[0], __collate_name[1]); 4026 break; 4027 default: 4028 __throw_regex_error<regex_constants::error_collate>(); 4029 } 4030 } 4031 __first = _VSTD::next(__temp, 2); 4032 return __first; 4033} 4034 4035template <class _CharT, class _Traits> 4036template <class _ForwardIterator> 4037_ForwardIterator 4038basic_regex<_CharT, _Traits>::__parse_character_class(_ForwardIterator __first, 4039 _ForwardIterator __last, 4040 __bracket_expression<_CharT, _Traits>* __ml) 4041{ 4042 // Found [: 4043 // This means :] must exist 4044 value_type _Colon_close[2] = {':', ']'}; 4045 _ForwardIterator __temp = _VSTD::search(__first, __last, _Colon_close, 4046 _Colon_close+2); 4047 if (__temp == __last) 4048 __throw_regex_error<regex_constants::error_brack>(); 4049 // [__first, __temp) contains all text in [: ... :] 4050 typedef typename _Traits::char_class_type char_class_type; 4051 char_class_type __class_type = 4052 __traits_.lookup_classname(__first, __temp, __flags_ & icase); 4053 if (__class_type == 0) 4054 __throw_regex_error<regex_constants::error_ctype>(); 4055 __ml->__add_class(__class_type); 4056 __first = _VSTD::next(__temp, 2); 4057 return __first; 4058} 4059 4060template <class _CharT, class _Traits> 4061template <class _ForwardIterator> 4062_ForwardIterator 4063basic_regex<_CharT, _Traits>::__parse_collating_symbol(_ForwardIterator __first, 4064 _ForwardIterator __last, 4065 basic_string<_CharT>& __col_sym) 4066{ 4067 // Found [. 4068 // This means .] must exist 4069 value_type _Dot_close[2] = {'.', ']'}; 4070 _ForwardIterator __temp = _VSTD::search(__first, __last, _Dot_close, 4071 _Dot_close+2); 4072 if (__temp == __last) 4073 __throw_regex_error<regex_constants::error_brack>(); 4074 // [__first, __temp) contains all text in [. ... .] 4075 __col_sym = __traits_.lookup_collatename(__first, __temp); 4076 switch (__col_sym.size()) 4077 { 4078 case 1: 4079 case 2: 4080 break; 4081 default: 4082 __throw_regex_error<regex_constants::error_collate>(); 4083 } 4084 __first = _VSTD::next(__temp, 2); 4085 return __first; 4086} 4087 4088template <class _CharT, class _Traits> 4089template <class _ForwardIterator> 4090_ForwardIterator 4091basic_regex<_CharT, _Traits>::__parse_DUP_COUNT(_ForwardIterator __first, 4092 _ForwardIterator __last, 4093 int& __c) 4094{ 4095 if (__first != __last ) 4096 { 4097 int __val = __traits_.value(*__first, 10); 4098 if ( __val != -1 ) 4099 { 4100 __c = __val; 4101 for (++__first; 4102 __first != __last && ( __val = __traits_.value(*__first, 10)) != -1; 4103 ++__first) 4104 { 4105 if (__c >= std::numeric_limits<int>::max() / 10) 4106 __throw_regex_error<regex_constants::error_badbrace>(); 4107 __c *= 10; 4108 __c += __val; 4109 } 4110 } 4111 } 4112 return __first; 4113} 4114 4115template <class _CharT, class _Traits> 4116template <class _ForwardIterator> 4117_ForwardIterator 4118basic_regex<_CharT, _Traits>::__parse_ecma_exp(_ForwardIterator __first, 4119 _ForwardIterator __last) 4120{ 4121 __owns_one_state<_CharT>* __sa = __end_; 4122 _ForwardIterator __temp = __parse_alternative(__first, __last); 4123 if (__temp == __first) 4124 __push_empty(); 4125 __first = __temp; 4126 while (__first != __last && *__first == '|') 4127 { 4128 __owns_one_state<_CharT>* __sb = __end_; 4129 __temp = __parse_alternative(++__first, __last); 4130 if (__temp == __first) 4131 __push_empty(); 4132 __push_alternation(__sa, __sb); 4133 __first = __temp; 4134 } 4135 return __first; 4136} 4137 4138template <class _CharT, class _Traits> 4139template <class _ForwardIterator> 4140_ForwardIterator 4141basic_regex<_CharT, _Traits>::__parse_alternative(_ForwardIterator __first, 4142 _ForwardIterator __last) 4143{ 4144 while (true) 4145 { 4146 _ForwardIterator __temp = __parse_term(__first, __last); 4147 if (__temp == __first) 4148 break; 4149 __first = __temp; 4150 } 4151 return __first; 4152} 4153 4154template <class _CharT, class _Traits> 4155template <class _ForwardIterator> 4156_ForwardIterator 4157basic_regex<_CharT, _Traits>::__parse_term(_ForwardIterator __first, 4158 _ForwardIterator __last) 4159{ 4160 _ForwardIterator __temp = __parse_assertion(__first, __last); 4161 if (__temp == __first) 4162 { 4163 __owns_one_state<_CharT>* __e = __end_; 4164 unsigned __mexp_begin = __marked_count_; 4165 __temp = __parse_atom(__first, __last); 4166 if (__temp != __first) 4167 __first = __parse_ERE_dupl_symbol(__temp, __last, __e, 4168 __mexp_begin+1, __marked_count_+1); 4169 } 4170 else 4171 __first = __temp; 4172 return __first; 4173} 4174 4175template <class _CharT, class _Traits> 4176template <class _ForwardIterator> 4177_ForwardIterator 4178basic_regex<_CharT, _Traits>::__parse_assertion(_ForwardIterator __first, 4179 _ForwardIterator __last) 4180{ 4181 if (__first != __last) 4182 { 4183 switch (*__first) 4184 { 4185 case '^': 4186 __push_l_anchor(); 4187 ++__first; 4188 break; 4189 case '$': 4190 __push_r_anchor(); 4191 ++__first; 4192 break; 4193 case '\\': 4194 { 4195 _ForwardIterator __temp = _VSTD::next(__first); 4196 if (__temp != __last) 4197 { 4198 if (*__temp == 'b') 4199 { 4200 __push_word_boundary(false); 4201 __first = ++__temp; 4202 } 4203 else if (*__temp == 'B') 4204 { 4205 __push_word_boundary(true); 4206 __first = ++__temp; 4207 } 4208 } 4209 } 4210 break; 4211 case '(': 4212 { 4213 _ForwardIterator __temp = _VSTD::next(__first); 4214 if (__temp != __last && *__temp == '?') 4215 { 4216 if (++__temp != __last) 4217 { 4218 switch (*__temp) 4219 { 4220 case '=': 4221 { 4222 basic_regex __exp; 4223 __exp.__flags_ = __flags_; 4224 __temp = __exp.__parse(++__temp, __last); 4225 unsigned __mexp = __exp.__marked_count_; 4226 __push_lookahead(_VSTD::move(__exp), false, __marked_count_); 4227 __marked_count_ += __mexp; 4228 if (__temp == __last || *__temp != ')') 4229 __throw_regex_error<regex_constants::error_paren>(); 4230 __first = ++__temp; 4231 } 4232 break; 4233 case '!': 4234 { 4235 basic_regex __exp; 4236 __exp.__flags_ = __flags_; 4237 __temp = __exp.__parse(++__temp, __last); 4238 unsigned __mexp = __exp.__marked_count_; 4239 __push_lookahead(_VSTD::move(__exp), true, __marked_count_); 4240 __marked_count_ += __mexp; 4241 if (__temp == __last || *__temp != ')') 4242 __throw_regex_error<regex_constants::error_paren>(); 4243 __first = ++__temp; 4244 } 4245 break; 4246 } 4247 } 4248 } 4249 } 4250 break; 4251 } 4252 } 4253 return __first; 4254} 4255 4256template <class _CharT, class _Traits> 4257template <class _ForwardIterator> 4258_ForwardIterator 4259basic_regex<_CharT, _Traits>::__parse_atom(_ForwardIterator __first, 4260 _ForwardIterator __last) 4261{ 4262 if (__first != __last) 4263 { 4264 switch (*__first) 4265 { 4266 case '.': 4267 __push_match_any_but_newline(); 4268 ++__first; 4269 break; 4270 case '\\': 4271 __first = __parse_atom_escape(__first, __last); 4272 break; 4273 case '[': 4274 __first = __parse_bracket_expression(__first, __last); 4275 break; 4276 case '(': 4277 { 4278 ++__first; 4279 if (__first == __last) 4280 __throw_regex_error<regex_constants::error_paren>(); 4281 _ForwardIterator __temp = _VSTD::next(__first); 4282 if (__temp != __last && *__first == '?' && *__temp == ':') 4283 { 4284 ++__open_count_; 4285 __first = __parse_ecma_exp(++__temp, __last); 4286 if (__first == __last || *__first != ')') 4287 __throw_regex_error<regex_constants::error_paren>(); 4288 --__open_count_; 4289 ++__first; 4290 } 4291 else 4292 { 4293 __push_begin_marked_subexpression(); 4294 unsigned __temp_count = __marked_count_; 4295 ++__open_count_; 4296 __first = __parse_ecma_exp(__first, __last); 4297 if (__first == __last || *__first != ')') 4298 __throw_regex_error<regex_constants::error_paren>(); 4299 __push_end_marked_subexpression(__temp_count); 4300 --__open_count_; 4301 ++__first; 4302 } 4303 } 4304 break; 4305 case '*': 4306 case '+': 4307 case '?': 4308 case '{': 4309 __throw_regex_error<regex_constants::error_badrepeat>(); 4310 break; 4311 default: 4312 __first = __parse_pattern_character(__first, __last); 4313 break; 4314 } 4315 } 4316 return __first; 4317} 4318 4319template <class _CharT, class _Traits> 4320template <class _ForwardIterator> 4321_ForwardIterator 4322basic_regex<_CharT, _Traits>::__parse_atom_escape(_ForwardIterator __first, 4323 _ForwardIterator __last) 4324{ 4325 if (__first != __last && *__first == '\\') 4326 { 4327 _ForwardIterator __t1 = _VSTD::next(__first); 4328 if (__t1 == __last) 4329 __throw_regex_error<regex_constants::error_escape>(); 4330 4331 _ForwardIterator __t2 = __parse_decimal_escape(__t1, __last); 4332 if (__t2 != __t1) 4333 __first = __t2; 4334 else 4335 { 4336 __t2 = __parse_character_class_escape(__t1, __last); 4337 if (__t2 != __t1) 4338 __first = __t2; 4339 else 4340 { 4341 __t2 = __parse_character_escape(__t1, __last); 4342 if (__t2 != __t1) 4343 __first = __t2; 4344 } 4345 } 4346 } 4347 return __first; 4348} 4349 4350template <class _CharT, class _Traits> 4351template <class _ForwardIterator> 4352_ForwardIterator 4353basic_regex<_CharT, _Traits>::__parse_decimal_escape(_ForwardIterator __first, 4354 _ForwardIterator __last) 4355{ 4356 if (__first != __last) 4357 { 4358 if (*__first == '0') 4359 { 4360 __push_char(_CharT()); 4361 ++__first; 4362 } 4363 else if ('1' <= *__first && *__first <= '9') 4364 { 4365 unsigned __v = *__first - '0'; 4366 for (++__first; 4367 __first != __last && '0' <= *__first && *__first <= '9'; ++__first) 4368 { 4369 if (__v >= std::numeric_limits<unsigned>::max() / 10) 4370 __throw_regex_error<regex_constants::error_backref>(); 4371 __v = 10 * __v + *__first - '0'; 4372 } 4373 if (__v == 0 || __v > mark_count()) 4374 __throw_regex_error<regex_constants::error_backref>(); 4375 __push_back_ref(__v); 4376 } 4377 } 4378 return __first; 4379} 4380 4381template <class _CharT, class _Traits> 4382template <class _ForwardIterator> 4383_ForwardIterator 4384basic_regex<_CharT, _Traits>::__parse_character_class_escape(_ForwardIterator __first, 4385 _ForwardIterator __last) 4386{ 4387 if (__first != __last) 4388 { 4389 __bracket_expression<_CharT, _Traits>* __ml; 4390 switch (*__first) 4391 { 4392 case 'd': 4393 __ml = __start_matching_list(false); 4394 __ml->__add_class(ctype_base::digit); 4395 ++__first; 4396 break; 4397 case 'D': 4398 __ml = __start_matching_list(true); 4399 __ml->__add_class(ctype_base::digit); 4400 ++__first; 4401 break; 4402 case 's': 4403 __ml = __start_matching_list(false); 4404 __ml->__add_class(ctype_base::space); 4405 ++__first; 4406 break; 4407 case 'S': 4408 __ml = __start_matching_list(true); 4409 __ml->__add_class(ctype_base::space); 4410 ++__first; 4411 break; 4412 case 'w': 4413 __ml = __start_matching_list(false); 4414 __ml->__add_class(ctype_base::alnum); 4415 __ml->__add_char('_'); 4416 ++__first; 4417 break; 4418 case 'W': 4419 __ml = __start_matching_list(true); 4420 __ml->__add_class(ctype_base::alnum); 4421 __ml->__add_char('_'); 4422 ++__first; 4423 break; 4424 } 4425 } 4426 return __first; 4427} 4428 4429template <class _CharT, class _Traits> 4430template <class _ForwardIterator> 4431_ForwardIterator 4432basic_regex<_CharT, _Traits>::__parse_character_escape(_ForwardIterator __first, 4433 _ForwardIterator __last, 4434 basic_string<_CharT>* __str) 4435{ 4436 if (__first != __last) 4437 { 4438 _ForwardIterator __t; 4439 unsigned __sum = 0; 4440 int __hd; 4441 switch (*__first) 4442 { 4443 case 'f': 4444 if (__str) 4445 *__str = _CharT(0xC); 4446 else 4447 __push_char(_CharT(0xC)); 4448 ++__first; 4449 break; 4450 case 'n': 4451 if (__str) 4452 *__str = _CharT(0xA); 4453 else 4454 __push_char(_CharT(0xA)); 4455 ++__first; 4456 break; 4457 case 'r': 4458 if (__str) 4459 *__str = _CharT(0xD); 4460 else 4461 __push_char(_CharT(0xD)); 4462 ++__first; 4463 break; 4464 case 't': 4465 if (__str) 4466 *__str = _CharT(0x9); 4467 else 4468 __push_char(_CharT(0x9)); 4469 ++__first; 4470 break; 4471 case 'v': 4472 if (__str) 4473 *__str = _CharT(0xB); 4474 else 4475 __push_char(_CharT(0xB)); 4476 ++__first; 4477 break; 4478 case 'c': 4479 if ((__t = _VSTD::next(__first)) != __last) 4480 { 4481 if (('A' <= *__t && *__t <= 'Z') || 4482 ('a' <= *__t && *__t <= 'z')) 4483 { 4484 if (__str) 4485 *__str = _CharT(*__t % 32); 4486 else 4487 __push_char(_CharT(*__t % 32)); 4488 __first = ++__t; 4489 } 4490 else 4491 __throw_regex_error<regex_constants::error_escape>(); 4492 } 4493 else 4494 __throw_regex_error<regex_constants::error_escape>(); 4495 break; 4496 case 'u': 4497 ++__first; 4498 if (__first == __last) 4499 __throw_regex_error<regex_constants::error_escape>(); 4500 __hd = __traits_.value(*__first, 16); 4501 if (__hd == -1) 4502 __throw_regex_error<regex_constants::error_escape>(); 4503 __sum = 16 * __sum + static_cast<unsigned>(__hd); 4504 ++__first; 4505 if (__first == __last) 4506 __throw_regex_error<regex_constants::error_escape>(); 4507 __hd = __traits_.value(*__first, 16); 4508 if (__hd == -1) 4509 __throw_regex_error<regex_constants::error_escape>(); 4510 __sum = 16 * __sum + static_cast<unsigned>(__hd); 4511 // drop through 4512 case 'x': 4513 ++__first; 4514 if (__first == __last) 4515 __throw_regex_error<regex_constants::error_escape>(); 4516 __hd = __traits_.value(*__first, 16); 4517 if (__hd == -1) 4518 __throw_regex_error<regex_constants::error_escape>(); 4519 __sum = 16 * __sum + static_cast<unsigned>(__hd); 4520 ++__first; 4521 if (__first == __last) 4522 __throw_regex_error<regex_constants::error_escape>(); 4523 __hd = __traits_.value(*__first, 16); 4524 if (__hd == -1) 4525 __throw_regex_error<regex_constants::error_escape>(); 4526 __sum = 16 * __sum + static_cast<unsigned>(__hd); 4527 if (__str) 4528 *__str = _CharT(__sum); 4529 else 4530 __push_char(_CharT(__sum)); 4531 ++__first; 4532 break; 4533 case '0': 4534 if (__str) 4535 *__str = _CharT(0); 4536 else 4537 __push_char(_CharT(0)); 4538 ++__first; 4539 break; 4540 default: 4541 if (*__first != '_' && !__traits_.isctype(*__first, ctype_base::alnum)) 4542 { 4543 if (__str) 4544 *__str = *__first; 4545 else 4546 __push_char(*__first); 4547 ++__first; 4548 } 4549 else 4550 __throw_regex_error<regex_constants::error_escape>(); 4551 break; 4552 } 4553 } 4554 return __first; 4555} 4556 4557template <class _CharT, class _Traits> 4558template <class _ForwardIterator> 4559_ForwardIterator 4560basic_regex<_CharT, _Traits>::__parse_pattern_character(_ForwardIterator __first, 4561 _ForwardIterator __last) 4562{ 4563 if (__first != __last) 4564 { 4565 switch (*__first) 4566 { 4567 case '^': 4568 case '$': 4569 case '\\': 4570 case '.': 4571 case '*': 4572 case '+': 4573 case '?': 4574 case '(': 4575 case ')': 4576 case '[': 4577 case ']': 4578 case '{': 4579 case '}': 4580 case '|': 4581 break; 4582 default: 4583 __push_char(*__first); 4584 ++__first; 4585 break; 4586 } 4587 } 4588 return __first; 4589} 4590 4591template <class _CharT, class _Traits> 4592template <class _ForwardIterator> 4593_ForwardIterator 4594basic_regex<_CharT, _Traits>::__parse_grep(_ForwardIterator __first, 4595 _ForwardIterator __last) 4596{ 4597 __owns_one_state<_CharT>* __sa = __end_; 4598 _ForwardIterator __t1 = _VSTD::find(__first, __last, _CharT('\n')); 4599 if (__t1 != __first) 4600 __parse_basic_reg_exp(__first, __t1); 4601 else 4602 __push_empty(); 4603 __first = __t1; 4604 if (__first != __last) 4605 ++__first; 4606 while (__first != __last) 4607 { 4608 __t1 = _VSTD::find(__first, __last, _CharT('\n')); 4609 __owns_one_state<_CharT>* __sb = __end_; 4610 if (__t1 != __first) 4611 __parse_basic_reg_exp(__first, __t1); 4612 else 4613 __push_empty(); 4614 __push_alternation(__sa, __sb); 4615 __first = __t1; 4616 if (__first != __last) 4617 ++__first; 4618 } 4619 return __first; 4620} 4621 4622template <class _CharT, class _Traits> 4623template <class _ForwardIterator> 4624_ForwardIterator 4625basic_regex<_CharT, _Traits>::__parse_egrep(_ForwardIterator __first, 4626 _ForwardIterator __last) 4627{ 4628 __owns_one_state<_CharT>* __sa = __end_; 4629 _ForwardIterator __t1 = _VSTD::find(__first, __last, _CharT('\n')); 4630 if (__t1 != __first) 4631 __parse_extended_reg_exp(__first, __t1); 4632 else 4633 __push_empty(); 4634 __first = __t1; 4635 if (__first != __last) 4636 ++__first; 4637 while (__first != __last) 4638 { 4639 __t1 = _VSTD::find(__first, __last, _CharT('\n')); 4640 __owns_one_state<_CharT>* __sb = __end_; 4641 if (__t1 != __first) 4642 __parse_extended_reg_exp(__first, __t1); 4643 else 4644 __push_empty(); 4645 __push_alternation(__sa, __sb); 4646 __first = __t1; 4647 if (__first != __last) 4648 ++__first; 4649 } 4650 return __first; 4651} 4652 4653template <class _CharT, class _Traits> 4654void 4655basic_regex<_CharT, _Traits>::__push_loop(size_t __min, size_t __max, 4656 __owns_one_state<_CharT>* __s, size_t __mexp_begin, size_t __mexp_end, 4657 bool __greedy) 4658{ 4659 unique_ptr<__empty_state<_CharT> > __e1(new __empty_state<_CharT>(__end_->first())); 4660 __end_->first() = nullptr; 4661 unique_ptr<__loop<_CharT> > __e2(new __loop<_CharT>(__loop_count_, 4662 __s->first(), __e1.get(), __mexp_begin, __mexp_end, __greedy, 4663 __min, __max)); 4664 __s->first() = nullptr; 4665 __e1.release(); 4666 __end_->first() = new __repeat_one_loop<_CharT>(__e2.get()); 4667 __end_ = __e2->second(); 4668 __s->first() = __e2.release(); 4669 ++__loop_count_; 4670} 4671 4672template <class _CharT, class _Traits> 4673void 4674basic_regex<_CharT, _Traits>::__push_char(value_type __c) 4675{ 4676 if (flags() & icase) 4677 __end_->first() = new __match_char_icase<_CharT, _Traits> 4678 (__traits_, __c, __end_->first()); 4679 else if (flags() & collate) 4680 __end_->first() = new __match_char_collate<_CharT, _Traits> 4681 (__traits_, __c, __end_->first()); 4682 else 4683 __end_->first() = new __match_char<_CharT>(__c, __end_->first()); 4684 __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first()); 4685} 4686 4687template <class _CharT, class _Traits> 4688void 4689basic_regex<_CharT, _Traits>::__push_begin_marked_subexpression() 4690{ 4691 if (!(__flags_ & nosubs)) 4692 { 4693 __end_->first() = 4694 new __begin_marked_subexpression<_CharT>(++__marked_count_, 4695 __end_->first()); 4696 __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first()); 4697 } 4698} 4699 4700template <class _CharT, class _Traits> 4701void 4702basic_regex<_CharT, _Traits>::__push_end_marked_subexpression(unsigned __sub) 4703{ 4704 if (!(__flags_ & nosubs)) 4705 { 4706 __end_->first() = 4707 new __end_marked_subexpression<_CharT>(__sub, __end_->first()); 4708 __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first()); 4709 } 4710} 4711 4712template <class _CharT, class _Traits> 4713void 4714basic_regex<_CharT, _Traits>::__push_l_anchor() 4715{ 4716 __end_->first() = new __l_anchor<_CharT>(__end_->first()); 4717 __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first()); 4718} 4719 4720template <class _CharT, class _Traits> 4721void 4722basic_regex<_CharT, _Traits>::__push_r_anchor() 4723{ 4724 __end_->first() = new __r_anchor<_CharT>(__end_->first()); 4725 __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first()); 4726} 4727 4728template <class _CharT, class _Traits> 4729void 4730basic_regex<_CharT, _Traits>::__push_match_any() 4731{ 4732 __end_->first() = new __match_any<_CharT>(__end_->first()); 4733 __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first()); 4734} 4735 4736template <class _CharT, class _Traits> 4737void 4738basic_regex<_CharT, _Traits>::__push_match_any_but_newline() 4739{ 4740 __end_->first() = new __match_any_but_newline<_CharT>(__end_->first()); 4741 __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first()); 4742} 4743 4744template <class _CharT, class _Traits> 4745void 4746basic_regex<_CharT, _Traits>::__push_empty() 4747{ 4748 __end_->first() = new __empty_state<_CharT>(__end_->first()); 4749 __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first()); 4750} 4751 4752template <class _CharT, class _Traits> 4753void 4754basic_regex<_CharT, _Traits>::__push_word_boundary(bool __invert) 4755{ 4756 __end_->first() = new __word_boundary<_CharT, _Traits>(__traits_, __invert, 4757 __end_->first()); 4758 __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first()); 4759} 4760 4761template <class _CharT, class _Traits> 4762void 4763basic_regex<_CharT, _Traits>::__push_back_ref(int __i) 4764{ 4765 if (flags() & icase) 4766 __end_->first() = new __back_ref_icase<_CharT, _Traits> 4767 (__traits_, __i, __end_->first()); 4768 else if (flags() & collate) 4769 __end_->first() = new __back_ref_collate<_CharT, _Traits> 4770 (__traits_, __i, __end_->first()); 4771 else 4772 __end_->first() = new __back_ref<_CharT>(__i, __end_->first()); 4773 __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first()); 4774} 4775 4776template <class _CharT, class _Traits> 4777void 4778basic_regex<_CharT, _Traits>::__push_alternation(__owns_one_state<_CharT>* __sa, 4779 __owns_one_state<_CharT>* __ea) 4780{ 4781 __sa->first() = new __alternate<_CharT>( 4782 static_cast<__owns_one_state<_CharT>*>(__sa->first()), 4783 static_cast<__owns_one_state<_CharT>*>(__ea->first())); 4784 __ea->first() = nullptr; 4785 __ea->first() = new __empty_state<_CharT>(__end_->first()); 4786 __end_->first() = nullptr; 4787 __end_->first() = new __empty_non_own_state<_CharT>(__ea->first()); 4788 __end_ = static_cast<__owns_one_state<_CharT>*>(__ea->first()); 4789} 4790 4791template <class _CharT, class _Traits> 4792__bracket_expression<_CharT, _Traits>* 4793basic_regex<_CharT, _Traits>::__start_matching_list(bool __negate) 4794{ 4795 __bracket_expression<_CharT, _Traits>* __r = 4796 new __bracket_expression<_CharT, _Traits>(__traits_, __end_->first(), 4797 __negate, __flags_ & icase, 4798 __flags_ & collate); 4799 __end_->first() = __r; 4800 __end_ = __r; 4801 return __r; 4802} 4803 4804template <class _CharT, class _Traits> 4805void 4806basic_regex<_CharT, _Traits>::__push_lookahead(const basic_regex& __exp, 4807 bool __invert, 4808 unsigned __mexp) 4809{ 4810 __end_->first() = new __lookahead<_CharT, _Traits>(__exp, __invert, 4811 __end_->first(), __mexp); 4812 __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first()); 4813} 4814 4815typedef basic_regex<char> regex; 4816typedef basic_regex<wchar_t> wregex; 4817 4818// sub_match 4819 4820template <class _BidirectionalIterator> 4821class _LIBCPP_TEMPLATE_VIS sub_match 4822 : public pair<_BidirectionalIterator, _BidirectionalIterator> 4823{ 4824public: 4825 typedef _BidirectionalIterator iterator; 4826 typedef typename iterator_traits<iterator>::value_type value_type; 4827 typedef typename iterator_traits<iterator>::difference_type difference_type; 4828 typedef basic_string<value_type> string_type; 4829 4830 bool matched; 4831 4832 _LIBCPP_INLINE_VISIBILITY 4833 _LIBCPP_CONSTEXPR sub_match() : matched() {} 4834 4835 _LIBCPP_INLINE_VISIBILITY 4836 difference_type length() const 4837 {return matched ? _VSTD::distance(this->first, this->second) : 0;} 4838 _LIBCPP_INLINE_VISIBILITY 4839 string_type str() const 4840 {return matched ? string_type(this->first, this->second) : string_type();} 4841 _LIBCPP_INLINE_VISIBILITY 4842 operator string_type() const 4843 {return str();} 4844 4845 _LIBCPP_INLINE_VISIBILITY 4846 int compare(const sub_match& __s) const 4847 {return str().compare(__s.str());} 4848 _LIBCPP_INLINE_VISIBILITY 4849 int compare(const string_type& __s) const 4850 {return str().compare(__s);} 4851 _LIBCPP_INLINE_VISIBILITY 4852 int compare(const value_type* __s) const 4853 {return str().compare(__s);} 4854}; 4855 4856typedef sub_match<const char*> csub_match; 4857typedef sub_match<const wchar_t*> wcsub_match; 4858typedef sub_match<string::const_iterator> ssub_match; 4859typedef sub_match<wstring::const_iterator> wssub_match; 4860 4861template <class _BiIter> 4862inline _LIBCPP_INLINE_VISIBILITY 4863bool 4864operator==(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y) 4865{ 4866 return __x.compare(__y) == 0; 4867} 4868 4869template <class _BiIter> 4870inline _LIBCPP_INLINE_VISIBILITY 4871bool 4872operator!=(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y) 4873{ 4874 return !(__x == __y); 4875} 4876 4877template <class _BiIter> 4878inline _LIBCPP_INLINE_VISIBILITY 4879bool 4880operator<(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y) 4881{ 4882 return __x.compare(__y) < 0; 4883} 4884 4885template <class _BiIter> 4886inline _LIBCPP_INLINE_VISIBILITY 4887bool 4888operator<=(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y) 4889{ 4890 return !(__y < __x); 4891} 4892 4893template <class _BiIter> 4894inline _LIBCPP_INLINE_VISIBILITY 4895bool 4896operator>=(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y) 4897{ 4898 return !(__x < __y); 4899} 4900 4901template <class _BiIter> 4902inline _LIBCPP_INLINE_VISIBILITY 4903bool 4904operator>(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y) 4905{ 4906 return __y < __x; 4907} 4908 4909template <class _BiIter, class _ST, class _SA> 4910inline _LIBCPP_INLINE_VISIBILITY 4911bool 4912operator==(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x, 4913 const sub_match<_BiIter>& __y) 4914{ 4915 return __y.compare(typename sub_match<_BiIter>::string_type(__x.data(), __x.size())) == 0; 4916} 4917 4918template <class _BiIter, class _ST, class _SA> 4919inline _LIBCPP_INLINE_VISIBILITY 4920bool 4921operator!=(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x, 4922 const sub_match<_BiIter>& __y) 4923{ 4924 return !(__x == __y); 4925} 4926 4927template <class _BiIter, class _ST, class _SA> 4928inline _LIBCPP_INLINE_VISIBILITY 4929bool 4930operator<(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x, 4931 const sub_match<_BiIter>& __y) 4932{ 4933 return __y.compare(typename sub_match<_BiIter>::string_type(__x.data(), __x.size())) > 0; 4934} 4935 4936template <class _BiIter, class _ST, class _SA> 4937inline _LIBCPP_INLINE_VISIBILITY 4938bool 4939operator>(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x, 4940 const sub_match<_BiIter>& __y) 4941{ 4942 return __y < __x; 4943} 4944 4945template <class _BiIter, class _ST, class _SA> 4946inline _LIBCPP_INLINE_VISIBILITY 4947bool operator>=(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x, 4948 const sub_match<_BiIter>& __y) 4949{ 4950 return !(__x < __y); 4951} 4952 4953template <class _BiIter, class _ST, class _SA> 4954inline _LIBCPP_INLINE_VISIBILITY 4955bool 4956operator<=(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x, 4957 const sub_match<_BiIter>& __y) 4958{ 4959 return !(__y < __x); 4960} 4961 4962template <class _BiIter, class _ST, class _SA> 4963inline _LIBCPP_INLINE_VISIBILITY 4964bool 4965operator==(const sub_match<_BiIter>& __x, 4966 const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y) 4967{ 4968 return __x.compare(typename sub_match<_BiIter>::string_type(__y.data(), __y.size())) == 0; 4969} 4970 4971template <class _BiIter, class _ST, class _SA> 4972inline _LIBCPP_INLINE_VISIBILITY 4973bool 4974operator!=(const sub_match<_BiIter>& __x, 4975 const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y) 4976{ 4977 return !(__x == __y); 4978} 4979 4980template <class _BiIter, class _ST, class _SA> 4981inline _LIBCPP_INLINE_VISIBILITY 4982bool 4983operator<(const sub_match<_BiIter>& __x, 4984 const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y) 4985{ 4986 return __x.compare(typename sub_match<_BiIter>::string_type(__y.data(), __y.size())) < 0; 4987} 4988 4989template <class _BiIter, class _ST, class _SA> 4990inline _LIBCPP_INLINE_VISIBILITY 4991bool operator>(const sub_match<_BiIter>& __x, 4992 const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y) 4993{ 4994 return __y < __x; 4995} 4996 4997template <class _BiIter, class _ST, class _SA> 4998inline _LIBCPP_INLINE_VISIBILITY 4999bool 5000operator>=(const sub_match<_BiIter>& __x, 5001 const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y) 5002{ 5003 return !(__x < __y); 5004} 5005 5006template <class _BiIter, class _ST, class _SA> 5007inline _LIBCPP_INLINE_VISIBILITY 5008bool 5009operator<=(const sub_match<_BiIter>& __x, 5010 const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y) 5011{ 5012 return !(__y < __x); 5013} 5014 5015template <class _BiIter> 5016inline _LIBCPP_INLINE_VISIBILITY 5017bool 5018operator==(typename iterator_traits<_BiIter>::value_type const* __x, 5019 const sub_match<_BiIter>& __y) 5020{ 5021 return __y.compare(__x) == 0; 5022} 5023 5024template <class _BiIter> 5025inline _LIBCPP_INLINE_VISIBILITY 5026bool 5027operator!=(typename iterator_traits<_BiIter>::value_type const* __x, 5028 const sub_match<_BiIter>& __y) 5029{ 5030 return !(__x == __y); 5031} 5032 5033template <class _BiIter> 5034inline _LIBCPP_INLINE_VISIBILITY 5035bool 5036operator<(typename iterator_traits<_BiIter>::value_type const* __x, 5037 const sub_match<_BiIter>& __y) 5038{ 5039 return __y.compare(__x) > 0; 5040} 5041 5042template <class _BiIter> 5043inline _LIBCPP_INLINE_VISIBILITY 5044bool 5045operator>(typename iterator_traits<_BiIter>::value_type const* __x, 5046 const sub_match<_BiIter>& __y) 5047{ 5048 return __y < __x; 5049} 5050 5051template <class _BiIter> 5052inline _LIBCPP_INLINE_VISIBILITY 5053bool 5054operator>=(typename iterator_traits<_BiIter>::value_type const* __x, 5055 const sub_match<_BiIter>& __y) 5056{ 5057 return !(__x < __y); 5058} 5059 5060template <class _BiIter> 5061inline _LIBCPP_INLINE_VISIBILITY 5062bool 5063operator<=(typename iterator_traits<_BiIter>::value_type const* __x, 5064 const sub_match<_BiIter>& __y) 5065{ 5066 return !(__y < __x); 5067} 5068 5069template <class _BiIter> 5070inline _LIBCPP_INLINE_VISIBILITY 5071bool 5072operator==(const sub_match<_BiIter>& __x, 5073 typename iterator_traits<_BiIter>::value_type const* __y) 5074{ 5075 return __x.compare(__y) == 0; 5076} 5077 5078template <class _BiIter> 5079inline _LIBCPP_INLINE_VISIBILITY 5080bool 5081operator!=(const sub_match<_BiIter>& __x, 5082 typename iterator_traits<_BiIter>::value_type const* __y) 5083{ 5084 return !(__x == __y); 5085} 5086 5087template <class _BiIter> 5088inline _LIBCPP_INLINE_VISIBILITY 5089bool 5090operator<(const sub_match<_BiIter>& __x, 5091 typename iterator_traits<_BiIter>::value_type const* __y) 5092{ 5093 return __x.compare(__y) < 0; 5094} 5095 5096template <class _BiIter> 5097inline _LIBCPP_INLINE_VISIBILITY 5098bool 5099operator>(const sub_match<_BiIter>& __x, 5100 typename iterator_traits<_BiIter>::value_type const* __y) 5101{ 5102 return __y < __x; 5103} 5104 5105template <class _BiIter> 5106inline _LIBCPP_INLINE_VISIBILITY 5107bool 5108operator>=(const sub_match<_BiIter>& __x, 5109 typename iterator_traits<_BiIter>::value_type const* __y) 5110{ 5111 return !(__x < __y); 5112} 5113 5114template <class _BiIter> 5115inline _LIBCPP_INLINE_VISIBILITY 5116bool 5117operator<=(const sub_match<_BiIter>& __x, 5118 typename iterator_traits<_BiIter>::value_type const* __y) 5119{ 5120 return !(__y < __x); 5121} 5122 5123template <class _BiIter> 5124inline _LIBCPP_INLINE_VISIBILITY 5125bool 5126operator==(typename iterator_traits<_BiIter>::value_type const& __x, 5127 const sub_match<_BiIter>& __y) 5128{ 5129 typedef basic_string<typename iterator_traits<_BiIter>::value_type> string_type; 5130 return __y.compare(string_type(1, __x)) == 0; 5131} 5132 5133template <class _BiIter> 5134inline _LIBCPP_INLINE_VISIBILITY 5135bool 5136operator!=(typename iterator_traits<_BiIter>::value_type const& __x, 5137 const sub_match<_BiIter>& __y) 5138{ 5139 return !(__x == __y); 5140} 5141 5142template <class _BiIter> 5143inline _LIBCPP_INLINE_VISIBILITY 5144bool 5145operator<(typename iterator_traits<_BiIter>::value_type const& __x, 5146 const sub_match<_BiIter>& __y) 5147{ 5148 typedef basic_string<typename iterator_traits<_BiIter>::value_type> string_type; 5149 return __y.compare(string_type(1, __x)) > 0; 5150} 5151 5152template <class _BiIter> 5153inline _LIBCPP_INLINE_VISIBILITY 5154bool 5155operator>(typename iterator_traits<_BiIter>::value_type const& __x, 5156 const sub_match<_BiIter>& __y) 5157{ 5158 return __y < __x; 5159} 5160 5161template <class _BiIter> 5162inline _LIBCPP_INLINE_VISIBILITY 5163bool 5164operator>=(typename iterator_traits<_BiIter>::value_type const& __x, 5165 const sub_match<_BiIter>& __y) 5166{ 5167 return !(__x < __y); 5168} 5169 5170template <class _BiIter> 5171inline _LIBCPP_INLINE_VISIBILITY 5172bool 5173operator<=(typename iterator_traits<_BiIter>::value_type const& __x, 5174 const sub_match<_BiIter>& __y) 5175{ 5176 return !(__y < __x); 5177} 5178 5179template <class _BiIter> 5180inline _LIBCPP_INLINE_VISIBILITY 5181bool 5182operator==(const sub_match<_BiIter>& __x, 5183 typename iterator_traits<_BiIter>::value_type const& __y) 5184{ 5185 typedef basic_string<typename iterator_traits<_BiIter>::value_type> string_type; 5186 return __x.compare(string_type(1, __y)) == 0; 5187} 5188 5189template <class _BiIter> 5190inline _LIBCPP_INLINE_VISIBILITY 5191bool 5192operator!=(const sub_match<_BiIter>& __x, 5193 typename iterator_traits<_BiIter>::value_type const& __y) 5194{ 5195 return !(__x == __y); 5196} 5197 5198template <class _BiIter> 5199inline _LIBCPP_INLINE_VISIBILITY 5200bool 5201operator<(const sub_match<_BiIter>& __x, 5202 typename iterator_traits<_BiIter>::value_type const& __y) 5203{ 5204 typedef basic_string<typename iterator_traits<_BiIter>::value_type> string_type; 5205 return __x.compare(string_type(1, __y)) < 0; 5206} 5207 5208template <class _BiIter> 5209inline _LIBCPP_INLINE_VISIBILITY 5210bool 5211operator>(const sub_match<_BiIter>& __x, 5212 typename iterator_traits<_BiIter>::value_type const& __y) 5213{ 5214 return __y < __x; 5215} 5216 5217template <class _BiIter> 5218inline _LIBCPP_INLINE_VISIBILITY 5219bool 5220operator>=(const sub_match<_BiIter>& __x, 5221 typename iterator_traits<_BiIter>::value_type const& __y) 5222{ 5223 return !(__x < __y); 5224} 5225 5226template <class _BiIter> 5227inline _LIBCPP_INLINE_VISIBILITY 5228bool 5229operator<=(const sub_match<_BiIter>& __x, 5230 typename iterator_traits<_BiIter>::value_type const& __y) 5231{ 5232 return !(__y < __x); 5233} 5234 5235template <class _CharT, class _ST, class _BiIter> 5236inline _LIBCPP_INLINE_VISIBILITY 5237basic_ostream<_CharT, _ST>& 5238operator<<(basic_ostream<_CharT, _ST>& __os, const sub_match<_BiIter>& __m) 5239{ 5240 return __os << __m.str(); 5241} 5242 5243template <class _BidirectionalIterator, class _Allocator> 5244class _LIBCPP_TEMPLATE_VIS match_results 5245{ 5246public: 5247 typedef _Allocator allocator_type; 5248 typedef sub_match<_BidirectionalIterator> value_type; 5249private: 5250 typedef vector<value_type, allocator_type> __container_type; 5251 5252 __container_type __matches_; 5253 value_type __unmatched_; 5254 value_type __prefix_; 5255 value_type __suffix_; 5256 bool __ready_; 5257public: 5258 _BidirectionalIterator __position_start_; 5259 typedef const value_type& const_reference; 5260 typedef value_type& reference; 5261 typedef typename __container_type::const_iterator const_iterator; 5262 typedef const_iterator iterator; 5263 typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type; 5264 typedef typename allocator_traits<allocator_type>::size_type size_type; 5265 typedef typename iterator_traits<_BidirectionalIterator>::value_type char_type; 5266 typedef basic_string<char_type> string_type; 5267 5268 // construct/copy/destroy: 5269 explicit match_results(const allocator_type& __a = allocator_type()); 5270// match_results(const match_results&) = default; 5271// match_results& operator=(const match_results&) = default; 5272// match_results(match_results&& __m) = default; 5273// match_results& operator=(match_results&& __m) = default; 5274// ~match_results() = default; 5275 5276 _LIBCPP_INLINE_VISIBILITY 5277 bool ready() const {return __ready_;} 5278 5279 // size: 5280 _LIBCPP_INLINE_VISIBILITY 5281 size_type size() const _NOEXCEPT {return __matches_.size();} 5282 _LIBCPP_INLINE_VISIBILITY 5283 size_type max_size() const _NOEXCEPT {return __matches_.max_size();} 5284 _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY 5285 bool empty() const _NOEXCEPT {return size() == 0;} 5286 5287 // element access: 5288 _LIBCPP_INLINE_VISIBILITY 5289 difference_type length(size_type __sub = 0) const 5290 { 5291 _LIBCPP_ASSERT(ready(), "match_results::length() called when not ready"); 5292 return (*this)[__sub].length(); 5293 } 5294 _LIBCPP_INLINE_VISIBILITY 5295 difference_type position(size_type __sub = 0) const 5296 { 5297 _LIBCPP_ASSERT(ready(), "match_results::position() called when not ready"); 5298 return _VSTD::distance(__position_start_, (*this)[__sub].first); 5299 } 5300 _LIBCPP_INLINE_VISIBILITY 5301 string_type str(size_type __sub = 0) const 5302 { 5303 _LIBCPP_ASSERT(ready(), "match_results::str() called when not ready"); 5304 return (*this)[__sub].str(); 5305 } 5306 _LIBCPP_INLINE_VISIBILITY 5307 const_reference operator[](size_type __n) const 5308 { 5309 _LIBCPP_ASSERT(ready(), "match_results::operator[]() called when not ready"); 5310 return __n < __matches_.size() ? __matches_[__n] : __unmatched_; 5311 } 5312 5313 _LIBCPP_INLINE_VISIBILITY 5314 const_reference prefix() const 5315 { 5316 _LIBCPP_ASSERT(ready(), "match_results::prefix() called when not ready"); 5317 return __prefix_; 5318 } 5319 _LIBCPP_INLINE_VISIBILITY 5320 const_reference suffix() const 5321 { 5322 _LIBCPP_ASSERT(ready(), "match_results::suffix() called when not ready"); 5323 return __suffix_; 5324 } 5325 5326 _LIBCPP_INLINE_VISIBILITY 5327 const_iterator begin() const {return empty() ? __matches_.end() : __matches_.begin();} 5328 _LIBCPP_INLINE_VISIBILITY 5329 const_iterator end() const {return __matches_.end();} 5330 _LIBCPP_INLINE_VISIBILITY 5331 const_iterator cbegin() const {return empty() ? __matches_.end() : __matches_.begin();} 5332 _LIBCPP_INLINE_VISIBILITY 5333 const_iterator cend() const {return __matches_.end();} 5334 5335 // format: 5336 template <class _OutputIter> 5337 _OutputIter 5338 format(_OutputIter __output_iter, const char_type* __fmt_first, 5339 const char_type* __fmt_last, 5340 regex_constants::match_flag_type __flags = regex_constants::format_default) const; 5341 template <class _OutputIter, class _ST, class _SA> 5342 _LIBCPP_INLINE_VISIBILITY 5343 _OutputIter 5344 format(_OutputIter __output_iter, const basic_string<char_type, _ST, _SA>& __fmt, 5345 regex_constants::match_flag_type __flags = regex_constants::format_default) const 5346 {return format(__output_iter, __fmt.data(), __fmt.data() + __fmt.size(), __flags);} 5347 template <class _ST, class _SA> 5348 _LIBCPP_INLINE_VISIBILITY 5349 basic_string<char_type, _ST, _SA> 5350 format(const basic_string<char_type, _ST, _SA>& __fmt, 5351 regex_constants::match_flag_type __flags = regex_constants::format_default) const 5352 { 5353 basic_string<char_type, _ST, _SA> __r; 5354 format(back_inserter(__r), __fmt.data(), __fmt.data() + __fmt.size(), 5355 __flags); 5356 return __r; 5357 } 5358 _LIBCPP_INLINE_VISIBILITY 5359 string_type 5360 format(const char_type* __fmt, 5361 regex_constants::match_flag_type __flags = regex_constants::format_default) const 5362 { 5363 string_type __r; 5364 format(back_inserter(__r), __fmt, 5365 __fmt + char_traits<char_type>::length(__fmt), __flags); 5366 return __r; 5367 } 5368 5369 // allocator: 5370 _LIBCPP_INLINE_VISIBILITY 5371 allocator_type get_allocator() const {return __matches_.get_allocator();} 5372 5373 // swap: 5374 void swap(match_results& __m); 5375 5376 template <class _Bp, class _Ap> 5377 _LIBCPP_INLINE_VISIBILITY 5378 void __assign(_BidirectionalIterator __f, _BidirectionalIterator __l, 5379 const match_results<_Bp, _Ap>& __m, bool __no_update_pos) 5380 { 5381 _Bp __mf = __m.prefix().first; 5382 __matches_.resize(__m.size()); 5383 for (size_type __i = 0; __i < __matches_.size(); ++__i) 5384 { 5385 __matches_[__i].first = _VSTD::next(__f, _VSTD::distance(__mf, __m[__i].first)); 5386 __matches_[__i].second = _VSTD::next(__f, _VSTD::distance(__mf, __m[__i].second)); 5387 __matches_[__i].matched = __m[__i].matched; 5388 } 5389 __unmatched_.first = __l; 5390 __unmatched_.second = __l; 5391 __unmatched_.matched = false; 5392 __prefix_.first = _VSTD::next(__f, _VSTD::distance(__mf, __m.prefix().first)); 5393 __prefix_.second = _VSTD::next(__f, _VSTD::distance(__mf, __m.prefix().second)); 5394 __prefix_.matched = __m.prefix().matched; 5395 __suffix_.first = _VSTD::next(__f, _VSTD::distance(__mf, __m.suffix().first)); 5396 __suffix_.second = _VSTD::next(__f, _VSTD::distance(__mf, __m.suffix().second)); 5397 __suffix_.matched = __m.suffix().matched; 5398 if (!__no_update_pos) 5399 __position_start_ = __prefix_.first; 5400 __ready_ = __m.ready(); 5401 } 5402 5403private: 5404 void __init(unsigned __s, 5405 _BidirectionalIterator __f, _BidirectionalIterator __l, 5406 bool __no_update_pos = false); 5407 5408 template <class, class> friend class basic_regex; 5409 5410 template <class _Bp, class _Ap, class _Cp, class _Tp> 5411 friend 5412 bool 5413 regex_match(_Bp, _Bp, match_results<_Bp, _Ap>&, const basic_regex<_Cp, _Tp>&, 5414 regex_constants::match_flag_type); 5415 5416 template <class _Bp, class _Ap> 5417 friend 5418 bool 5419 operator==(const match_results<_Bp, _Ap>&, const match_results<_Bp, _Ap>&); 5420 5421 template <class, class> friend class __lookahead; 5422}; 5423 5424template <class _BidirectionalIterator, class _Allocator> 5425match_results<_BidirectionalIterator, _Allocator>::match_results( 5426 const allocator_type& __a) 5427 : __matches_(__a), 5428 __unmatched_(), 5429 __prefix_(), 5430 __suffix_(), 5431 __ready_(false), 5432 __position_start_() 5433{ 5434} 5435 5436template <class _BidirectionalIterator, class _Allocator> 5437void 5438match_results<_BidirectionalIterator, _Allocator>::__init(unsigned __s, 5439 _BidirectionalIterator __f, _BidirectionalIterator __l, 5440 bool __no_update_pos) 5441{ 5442 __unmatched_.first = __l; 5443 __unmatched_.second = __l; 5444 __unmatched_.matched = false; 5445 __matches_.assign(__s, __unmatched_); 5446 __prefix_.first = __f; 5447 __prefix_.second = __f; 5448 __prefix_.matched = false; 5449 __suffix_ = __unmatched_; 5450 if (!__no_update_pos) 5451 __position_start_ = __prefix_.first; 5452 __ready_ = true; 5453} 5454 5455template <class _BidirectionalIterator, class _Allocator> 5456template <class _OutputIter> 5457_OutputIter 5458match_results<_BidirectionalIterator, _Allocator>::format(_OutputIter __output_iter, 5459 const char_type* __fmt_first, const char_type* __fmt_last, 5460 regex_constants::match_flag_type __flags) const 5461{ 5462 _LIBCPP_ASSERT(ready(), "match_results::format() called when not ready"); 5463 if (__flags & regex_constants::format_sed) 5464 { 5465 for (; __fmt_first != __fmt_last; ++__fmt_first) 5466 { 5467 if (*__fmt_first == '&') 5468 __output_iter = _VSTD::copy(__matches_[0].first, __matches_[0].second, 5469 __output_iter); 5470 else if (*__fmt_first == '\\' && __fmt_first + 1 != __fmt_last) 5471 { 5472 ++__fmt_first; 5473 if ('0' <= *__fmt_first && *__fmt_first <= '9') 5474 { 5475 size_t __i = *__fmt_first - '0'; 5476 __output_iter = _VSTD::copy((*this)[__i].first, 5477 (*this)[__i].second, __output_iter); 5478 } 5479 else 5480 { 5481 *__output_iter = *__fmt_first; 5482 ++__output_iter; 5483 } 5484 } 5485 else 5486 { 5487 *__output_iter = *__fmt_first; 5488 ++__output_iter; 5489 } 5490 } 5491 } 5492 else 5493 { 5494 for (; __fmt_first != __fmt_last; ++__fmt_first) 5495 { 5496 if (*__fmt_first == '$' && __fmt_first + 1 != __fmt_last) 5497 { 5498 switch (__fmt_first[1]) 5499 { 5500 case '$': 5501 *__output_iter = *++__fmt_first; 5502 ++__output_iter; 5503 break; 5504 case '&': 5505 ++__fmt_first; 5506 __output_iter = _VSTD::copy(__matches_[0].first, __matches_[0].second, 5507 __output_iter); 5508 break; 5509 case '`': 5510 ++__fmt_first; 5511 __output_iter = _VSTD::copy(__prefix_.first, __prefix_.second, __output_iter); 5512 break; 5513 case '\'': 5514 ++__fmt_first; 5515 __output_iter = _VSTD::copy(__suffix_.first, __suffix_.second, __output_iter); 5516 break; 5517 default: 5518 if ('0' <= __fmt_first[1] && __fmt_first[1] <= '9') 5519 { 5520 ++__fmt_first; 5521 size_t __idx = *__fmt_first - '0'; 5522 if (__fmt_first + 1 != __fmt_last && 5523 '0' <= __fmt_first[1] && __fmt_first[1] <= '9') 5524 { 5525 ++__fmt_first; 5526 if (__idx >= std::numeric_limits<size_t>::max() / 10) 5527 __throw_regex_error<regex_constants::error_escape>(); 5528 __idx = 10 * __idx + *__fmt_first - '0'; 5529 } 5530 __output_iter = _VSTD::copy((*this)[__idx].first, 5531 (*this)[__idx].second, __output_iter); 5532 } 5533 else 5534 { 5535 *__output_iter = *__fmt_first; 5536 ++__output_iter; 5537 } 5538 break; 5539 } 5540 } 5541 else 5542 { 5543 *__output_iter = *__fmt_first; 5544 ++__output_iter; 5545 } 5546 } 5547 } 5548 return __output_iter; 5549} 5550 5551template <class _BidirectionalIterator, class _Allocator> 5552void 5553match_results<_BidirectionalIterator, _Allocator>::swap(match_results& __m) 5554{ 5555 using _VSTD::swap; 5556 swap(__matches_, __m.__matches_); 5557 swap(__unmatched_, __m.__unmatched_); 5558 swap(__prefix_, __m.__prefix_); 5559 swap(__suffix_, __m.__suffix_); 5560 swap(__position_start_, __m.__position_start_); 5561 swap(__ready_, __m.__ready_); 5562} 5563 5564typedef match_results<const char*> cmatch; 5565typedef match_results<const wchar_t*> wcmatch; 5566typedef match_results<string::const_iterator> smatch; 5567typedef match_results<wstring::const_iterator> wsmatch; 5568 5569template <class _BidirectionalIterator, class _Allocator> 5570bool 5571operator==(const match_results<_BidirectionalIterator, _Allocator>& __x, 5572 const match_results<_BidirectionalIterator, _Allocator>& __y) 5573{ 5574 if (__x.__ready_ != __y.__ready_) 5575 return false; 5576 if (!__x.__ready_) 5577 return true; 5578 return __x.__matches_ == __y.__matches_ && 5579 __x.__prefix_ == __y.__prefix_ && 5580 __x.__suffix_ == __y.__suffix_; 5581} 5582 5583template <class _BidirectionalIterator, class _Allocator> 5584inline _LIBCPP_INLINE_VISIBILITY 5585bool 5586operator!=(const match_results<_BidirectionalIterator, _Allocator>& __x, 5587 const match_results<_BidirectionalIterator, _Allocator>& __y) 5588{ 5589 return !(__x == __y); 5590} 5591 5592template <class _BidirectionalIterator, class _Allocator> 5593inline _LIBCPP_INLINE_VISIBILITY 5594void 5595swap(match_results<_BidirectionalIterator, _Allocator>& __x, 5596 match_results<_BidirectionalIterator, _Allocator>& __y) 5597{ 5598 __x.swap(__y); 5599} 5600 5601// regex_search 5602 5603template <class _CharT, class _Traits> 5604template <class _Allocator> 5605bool 5606basic_regex<_CharT, _Traits>::__match_at_start_ecma( 5607 const _CharT* __first, const _CharT* __last, 5608 match_results<const _CharT*, _Allocator>& __m, 5609 regex_constants::match_flag_type __flags, bool __at_first) const 5610{ 5611 vector<__state> __states; 5612 __node* __st = __start_.get(); 5613 if (__st) 5614 { 5615 sub_match<const _CharT*> __unmatched; 5616 __unmatched.first = __last; 5617 __unmatched.second = __last; 5618 __unmatched.matched = false; 5619 5620 __states.push_back(__state()); 5621 __states.back().__do_ = 0; 5622 __states.back().__first_ = __first; 5623 __states.back().__current_ = __first; 5624 __states.back().__last_ = __last; 5625 __states.back().__sub_matches_.resize(mark_count(), __unmatched); 5626 __states.back().__loop_data_.resize(__loop_count()); 5627 __states.back().__node_ = __st; 5628 __states.back().__flags_ = __flags; 5629 __states.back().__at_first_ = __at_first; 5630 int __counter = 0; 5631 int __length = __last - __first; 5632 do 5633 { 5634 ++__counter; 5635 if (__counter % _LIBCPP_REGEX_COMPLEXITY_FACTOR == 0 && 5636 __counter / _LIBCPP_REGEX_COMPLEXITY_FACTOR >= __length) 5637 __throw_regex_error<regex_constants::error_complexity>(); 5638 __state& __s = __states.back(); 5639 if (__s.__node_) 5640 __s.__node_->__exec(__s); 5641 switch (__s.__do_) 5642 { 5643 case __state::__end_state: 5644 if ((__flags & regex_constants::match_not_null) && 5645 __s.__current_ == __first) 5646 { 5647 __states.pop_back(); 5648 break; 5649 } 5650 if ((__flags & regex_constants::__full_match) && 5651 __s.__current_ != __last) 5652 { 5653 __states.pop_back(); 5654 break; 5655 } 5656 __m.__matches_[0].first = __first; 5657 __m.__matches_[0].second = _VSTD::next(__first, __s.__current_ - __first); 5658 __m.__matches_[0].matched = true; 5659 for (unsigned __i = 0; __i < __s.__sub_matches_.size(); ++__i) 5660 __m.__matches_[__i+1] = __s.__sub_matches_[__i]; 5661 return true; 5662 case __state::__accept_and_consume: 5663 case __state::__repeat: 5664 case __state::__accept_but_not_consume: 5665 break; 5666 case __state::__split: 5667 { 5668 __state __snext = __s; 5669 __s.__node_->__exec_split(true, __s); 5670 __snext.__node_->__exec_split(false, __snext); 5671 __states.push_back(_VSTD::move(__snext)); 5672 } 5673 break; 5674 case __state::__reject: 5675 __states.pop_back(); 5676 break; 5677 default: 5678 __throw_regex_error<regex_constants::__re_err_unknown>(); 5679 break; 5680 5681 } 5682 } while (!__states.empty()); 5683 } 5684 return false; 5685} 5686 5687template <class _CharT, class _Traits> 5688template <class _Allocator> 5689bool 5690basic_regex<_CharT, _Traits>::__match_at_start_posix_nosubs( 5691 const _CharT* __first, const _CharT* __last, 5692 match_results<const _CharT*, _Allocator>& __m, 5693 regex_constants::match_flag_type __flags, bool __at_first) const 5694{ 5695 deque<__state> __states; 5696 ptrdiff_t __highest_j = 0; 5697 ptrdiff_t _Np = _VSTD::distance(__first, __last); 5698 __node* __st = __start_.get(); 5699 if (__st) 5700 { 5701 __states.push_back(__state()); 5702 __states.back().__do_ = 0; 5703 __states.back().__first_ = __first; 5704 __states.back().__current_ = __first; 5705 __states.back().__last_ = __last; 5706 __states.back().__loop_data_.resize(__loop_count()); 5707 __states.back().__node_ = __st; 5708 __states.back().__flags_ = __flags; 5709 __states.back().__at_first_ = __at_first; 5710 bool __matched = false; 5711 int __counter = 0; 5712 int __length = __last - __first; 5713 do 5714 { 5715 ++__counter; 5716 if (__counter % _LIBCPP_REGEX_COMPLEXITY_FACTOR == 0 && 5717 __counter / _LIBCPP_REGEX_COMPLEXITY_FACTOR >= __length) 5718 __throw_regex_error<regex_constants::error_complexity>(); 5719 __state& __s = __states.back(); 5720 if (__s.__node_) 5721 __s.__node_->__exec(__s); 5722 switch (__s.__do_) 5723 { 5724 case __state::__end_state: 5725 if ((__flags & regex_constants::match_not_null) && 5726 __s.__current_ == __first) 5727 { 5728 __states.pop_back(); 5729 break; 5730 } 5731 if ((__flags & regex_constants::__full_match) && 5732 __s.__current_ != __last) 5733 { 5734 __states.pop_back(); 5735 break; 5736 } 5737 if (!__matched || __highest_j < __s.__current_ - __s.__first_) 5738 __highest_j = __s.__current_ - __s.__first_; 5739 __matched = true; 5740 if (__highest_j == _Np) 5741 __states.clear(); 5742 else 5743 __states.pop_back(); 5744 break; 5745 case __state::__consume_input: 5746 break; 5747 case __state::__accept_and_consume: 5748 __states.push_front(_VSTD::move(__s)); 5749 __states.pop_back(); 5750 break; 5751 case __state::__repeat: 5752 case __state::__accept_but_not_consume: 5753 break; 5754 case __state::__split: 5755 { 5756 __state __snext = __s; 5757 __s.__node_->__exec_split(true, __s); 5758 __snext.__node_->__exec_split(false, __snext); 5759 __states.push_back(_VSTD::move(__snext)); 5760 } 5761 break; 5762 case __state::__reject: 5763 __states.pop_back(); 5764 break; 5765 default: 5766 __throw_regex_error<regex_constants::__re_err_unknown>(); 5767 break; 5768 } 5769 } while (!__states.empty()); 5770 if (__matched) 5771 { 5772 __m.__matches_[0].first = __first; 5773 __m.__matches_[0].second = _VSTD::next(__first, __highest_j); 5774 __m.__matches_[0].matched = true; 5775 return true; 5776 } 5777 } 5778 return false; 5779} 5780 5781template <class _CharT, class _Traits> 5782template <class _Allocator> 5783bool 5784basic_regex<_CharT, _Traits>::__match_at_start_posix_subs( 5785 const _CharT* __first, const _CharT* __last, 5786 match_results<const _CharT*, _Allocator>& __m, 5787 regex_constants::match_flag_type __flags, bool __at_first) const 5788{ 5789 vector<__state> __states; 5790 __state __best_state; 5791 ptrdiff_t __j = 0; 5792 ptrdiff_t __highest_j = 0; 5793 ptrdiff_t _Np = _VSTD::distance(__first, __last); 5794 __node* __st = __start_.get(); 5795 if (__st) 5796 { 5797 sub_match<const _CharT*> __unmatched; 5798 __unmatched.first = __last; 5799 __unmatched.second = __last; 5800 __unmatched.matched = false; 5801 5802 __states.push_back(__state()); 5803 __states.back().__do_ = 0; 5804 __states.back().__first_ = __first; 5805 __states.back().__current_ = __first; 5806 __states.back().__last_ = __last; 5807 __states.back().__sub_matches_.resize(mark_count(), __unmatched); 5808 __states.back().__loop_data_.resize(__loop_count()); 5809 __states.back().__node_ = __st; 5810 __states.back().__flags_ = __flags; 5811 __states.back().__at_first_ = __at_first; 5812 const _CharT* __current = __first; 5813 bool __matched = false; 5814 int __counter = 0; 5815 int __length = __last - __first; 5816 do 5817 { 5818 ++__counter; 5819 if (__counter % _LIBCPP_REGEX_COMPLEXITY_FACTOR == 0 && 5820 __counter / _LIBCPP_REGEX_COMPLEXITY_FACTOR >= __length) 5821 __throw_regex_error<regex_constants::error_complexity>(); 5822 __state& __s = __states.back(); 5823 if (__s.__node_) 5824 __s.__node_->__exec(__s); 5825 switch (__s.__do_) 5826 { 5827 case __state::__end_state: 5828 if ((__flags & regex_constants::match_not_null) && 5829 __s.__current_ == __first) 5830 { 5831 __states.pop_back(); 5832 break; 5833 } 5834 if ((__flags & regex_constants::__full_match) && 5835 __s.__current_ != __last) 5836 { 5837 __states.pop_back(); 5838 break; 5839 } 5840 if (!__matched || __highest_j < __s.__current_ - __s.__first_) 5841 { 5842 __highest_j = __s.__current_ - __s.__first_; 5843 __best_state = __s; 5844 } 5845 __matched = true; 5846 if (__highest_j == _Np) 5847 __states.clear(); 5848 else 5849 __states.pop_back(); 5850 break; 5851 case __state::__accept_and_consume: 5852 __j += __s.__current_ - __current; 5853 __current = __s.__current_; 5854 break; 5855 case __state::__repeat: 5856 case __state::__accept_but_not_consume: 5857 break; 5858 case __state::__split: 5859 { 5860 __state __snext = __s; 5861 __s.__node_->__exec_split(true, __s); 5862 __snext.__node_->__exec_split(false, __snext); 5863 __states.push_back(_VSTD::move(__snext)); 5864 } 5865 break; 5866 case __state::__reject: 5867 __states.pop_back(); 5868 break; 5869 default: 5870 __throw_regex_error<regex_constants::__re_err_unknown>(); 5871 break; 5872 } 5873 } while (!__states.empty()); 5874 if (__matched) 5875 { 5876 __m.__matches_[0].first = __first; 5877 __m.__matches_[0].second = _VSTD::next(__first, __highest_j); 5878 __m.__matches_[0].matched = true; 5879 for (unsigned __i = 0; __i < __best_state.__sub_matches_.size(); ++__i) 5880 __m.__matches_[__i+1] = __best_state.__sub_matches_[__i]; 5881 return true; 5882 } 5883 } 5884 return false; 5885} 5886 5887template <class _CharT, class _Traits> 5888template <class _Allocator> 5889bool 5890basic_regex<_CharT, _Traits>::__match_at_start( 5891 const _CharT* __first, const _CharT* __last, 5892 match_results<const _CharT*, _Allocator>& __m, 5893 regex_constants::match_flag_type __flags, bool __at_first) const 5894{ 5895 if (__get_grammar(__flags_) == ECMAScript) 5896 return __match_at_start_ecma(__first, __last, __m, __flags, __at_first); 5897 if (mark_count() == 0) 5898 return __match_at_start_posix_nosubs(__first, __last, __m, __flags, __at_first); 5899 return __match_at_start_posix_subs(__first, __last, __m, __flags, __at_first); 5900} 5901 5902template <class _CharT, class _Traits> 5903template <class _Allocator> 5904bool 5905basic_regex<_CharT, _Traits>::__search( 5906 const _CharT* __first, const _CharT* __last, 5907 match_results<const _CharT*, _Allocator>& __m, 5908 regex_constants::match_flag_type __flags) const 5909{ 5910 __m.__init(1 + mark_count(), __first, __last, 5911 __flags & regex_constants::__no_update_pos); 5912 if (__match_at_start(__first, __last, __m, __flags, 5913 !(__flags & regex_constants::__no_update_pos))) 5914 { 5915 __m.__prefix_.second = __m[0].first; 5916 __m.__prefix_.matched = __m.__prefix_.first != __m.__prefix_.second; 5917 __m.__suffix_.first = __m[0].second; 5918 __m.__suffix_.matched = __m.__suffix_.first != __m.__suffix_.second; 5919 return true; 5920 } 5921 if (__first != __last && !(__flags & regex_constants::match_continuous)) 5922 { 5923 __flags |= regex_constants::match_prev_avail; 5924 for (++__first; __first != __last; ++__first) 5925 { 5926 __m.__matches_.assign(__m.size(), __m.__unmatched_); 5927 if (__match_at_start(__first, __last, __m, __flags, false)) 5928 { 5929 __m.__prefix_.second = __m[0].first; 5930 __m.__prefix_.matched = __m.__prefix_.first != __m.__prefix_.second; 5931 __m.__suffix_.first = __m[0].second; 5932 __m.__suffix_.matched = __m.__suffix_.first != __m.__suffix_.second; 5933 return true; 5934 } 5935 __m.__matches_.assign(__m.size(), __m.__unmatched_); 5936 } 5937 } 5938 __m.__matches_.clear(); 5939 return false; 5940} 5941 5942template <class _BidirectionalIterator, class _Allocator, class _CharT, class _Traits> 5943inline _LIBCPP_INLINE_VISIBILITY 5944bool 5945regex_search(_BidirectionalIterator __first, _BidirectionalIterator __last, 5946 match_results<_BidirectionalIterator, _Allocator>& __m, 5947 const basic_regex<_CharT, _Traits>& __e, 5948 regex_constants::match_flag_type __flags = regex_constants::match_default) 5949{ 5950 int __offset = (__flags & regex_constants::match_prev_avail) ? 1 : 0; 5951 basic_string<_CharT> __s(_VSTD::prev(__first, __offset), __last); 5952 match_results<const _CharT*> __mc; 5953 bool __r = __e.__search(__s.data() + __offset, __s.data() + __s.size(), __mc, __flags); 5954 __m.__assign(__first, __last, __mc, __flags & regex_constants::__no_update_pos); 5955 return __r; 5956} 5957 5958template <class _Iter, class _Allocator, class _CharT, class _Traits> 5959inline _LIBCPP_INLINE_VISIBILITY 5960bool 5961regex_search(__wrap_iter<_Iter> __first, 5962 __wrap_iter<_Iter> __last, 5963 match_results<__wrap_iter<_Iter>, _Allocator>& __m, 5964 const basic_regex<_CharT, _Traits>& __e, 5965 regex_constants::match_flag_type __flags = regex_constants::match_default) 5966{ 5967 match_results<const _CharT*> __mc; 5968 bool __r = __e.__search(__first.base(), __last.base(), __mc, __flags); 5969 __m.__assign(__first, __last, __mc, __flags & regex_constants::__no_update_pos); 5970 return __r; 5971} 5972 5973template <class _Allocator, class _CharT, class _Traits> 5974inline _LIBCPP_INLINE_VISIBILITY 5975bool 5976regex_search(const _CharT* __first, const _CharT* __last, 5977 match_results<const _CharT*, _Allocator>& __m, 5978 const basic_regex<_CharT, _Traits>& __e, 5979 regex_constants::match_flag_type __flags = regex_constants::match_default) 5980{ 5981 return __e.__search(__first, __last, __m, __flags); 5982} 5983 5984template <class _BidirectionalIterator, class _CharT, class _Traits> 5985inline _LIBCPP_INLINE_VISIBILITY 5986bool 5987regex_search(_BidirectionalIterator __first, _BidirectionalIterator __last, 5988 const basic_regex<_CharT, _Traits>& __e, 5989 regex_constants::match_flag_type __flags = regex_constants::match_default) 5990{ 5991 basic_string<_CharT> __s(__first, __last); 5992 match_results<const _CharT*> __mc; 5993 return __e.__search(__s.data(), __s.data() + __s.size(), __mc, __flags); 5994} 5995 5996template <class _CharT, class _Traits> 5997inline _LIBCPP_INLINE_VISIBILITY 5998bool 5999regex_search(const _CharT* __first, const _CharT* __last, 6000 const basic_regex<_CharT, _Traits>& __e, 6001 regex_constants::match_flag_type __flags = regex_constants::match_default) 6002{ 6003 match_results<const _CharT*> __mc; 6004 return __e.__search(__first, __last, __mc, __flags); 6005} 6006 6007template <class _CharT, class _Allocator, class _Traits> 6008inline _LIBCPP_INLINE_VISIBILITY 6009bool 6010regex_search(const _CharT* __str, match_results<const _CharT*, _Allocator>& __m, 6011 const basic_regex<_CharT, _Traits>& __e, 6012 regex_constants::match_flag_type __flags = regex_constants::match_default) 6013{ 6014 return __e.__search(__str, __str + _Traits::length(__str), __m, __flags); 6015} 6016 6017template <class _CharT, class _Traits> 6018inline _LIBCPP_INLINE_VISIBILITY 6019bool 6020regex_search(const _CharT* __str, const basic_regex<_CharT, _Traits>& __e, 6021 regex_constants::match_flag_type __flags = regex_constants::match_default) 6022{ 6023 match_results<const _CharT*> __m; 6024 return _VSTD::regex_search(__str, __m, __e, __flags); 6025} 6026 6027template <class _ST, class _SA, class _CharT, class _Traits> 6028inline _LIBCPP_INLINE_VISIBILITY 6029bool 6030regex_search(const basic_string<_CharT, _ST, _SA>& __s, 6031 const basic_regex<_CharT, _Traits>& __e, 6032 regex_constants::match_flag_type __flags = regex_constants::match_default) 6033{ 6034 match_results<const _CharT*> __mc; 6035 return __e.__search(__s.data(), __s.data() + __s.size(), __mc, __flags); 6036} 6037 6038template <class _ST, class _SA, class _Allocator, class _CharT, class _Traits> 6039inline _LIBCPP_INLINE_VISIBILITY 6040bool 6041regex_search(const basic_string<_CharT, _ST, _SA>& __s, 6042 match_results<typename basic_string<_CharT, _ST, _SA>::const_iterator, _Allocator>& __m, 6043 const basic_regex<_CharT, _Traits>& __e, 6044 regex_constants::match_flag_type __flags = regex_constants::match_default) 6045{ 6046 match_results<const _CharT*> __mc; 6047 bool __r = __e.__search(__s.data(), __s.data() + __s.size(), __mc, __flags); 6048 __m.__assign(__s.begin(), __s.end(), __mc, __flags & regex_constants::__no_update_pos); 6049 return __r; 6050} 6051 6052#if _LIBCPP_STD_VER > 11 6053template <class _ST, class _SA, class _Ap, class _Cp, class _Tp> 6054bool 6055regex_search(const basic_string<_Cp, _ST, _SA>&& __s, 6056 match_results<typename basic_string<_Cp, _ST, _SA>::const_iterator, _Ap>&, 6057 const basic_regex<_Cp, _Tp>& __e, 6058 regex_constants::match_flag_type __flags = regex_constants::match_default) = delete; 6059#endif 6060 6061// regex_match 6062 6063template <class _BidirectionalIterator, class _Allocator, class _CharT, class _Traits> 6064bool 6065regex_match(_BidirectionalIterator __first, _BidirectionalIterator __last, 6066 match_results<_BidirectionalIterator, _Allocator>& __m, 6067 const basic_regex<_CharT, _Traits>& __e, 6068 regex_constants::match_flag_type __flags = regex_constants::match_default) 6069{ 6070 bool __r = _VSTD::regex_search( 6071 __first, __last, __m, __e, 6072 __flags | regex_constants::match_continuous | 6073 regex_constants::__full_match); 6074 if (__r) 6075 { 6076 __r = !__m.suffix().matched; 6077 if (!__r) 6078 __m.__matches_.clear(); 6079 } 6080 return __r; 6081} 6082 6083template <class _BidirectionalIterator, class _CharT, class _Traits> 6084inline _LIBCPP_INLINE_VISIBILITY 6085bool 6086regex_match(_BidirectionalIterator __first, _BidirectionalIterator __last, 6087 const basic_regex<_CharT, _Traits>& __e, 6088 regex_constants::match_flag_type __flags = regex_constants::match_default) 6089{ 6090 match_results<_BidirectionalIterator> __m; 6091 return _VSTD::regex_match(__first, __last, __m, __e, __flags); 6092} 6093 6094template <class _CharT, class _Allocator, class _Traits> 6095inline _LIBCPP_INLINE_VISIBILITY 6096bool 6097regex_match(const _CharT* __str, match_results<const _CharT*, _Allocator>& __m, 6098 const basic_regex<_CharT, _Traits>& __e, 6099 regex_constants::match_flag_type __flags = regex_constants::match_default) 6100{ 6101 return _VSTD::regex_match(__str, __str + _Traits::length(__str), __m, __e, __flags); 6102} 6103 6104template <class _ST, class _SA, class _Allocator, class _CharT, class _Traits> 6105inline _LIBCPP_INLINE_VISIBILITY 6106bool 6107regex_match(const basic_string<_CharT, _ST, _SA>& __s, 6108 match_results<typename basic_string<_CharT, _ST, _SA>::const_iterator, _Allocator>& __m, 6109 const basic_regex<_CharT, _Traits>& __e, 6110 regex_constants::match_flag_type __flags = regex_constants::match_default) 6111{ 6112 return _VSTD::regex_match(__s.begin(), __s.end(), __m, __e, __flags); 6113} 6114 6115#if _LIBCPP_STD_VER > 11 6116template <class _ST, class _SA, class _Allocator, class _CharT, class _Traits> 6117inline _LIBCPP_INLINE_VISIBILITY 6118bool 6119regex_match(const basic_string<_CharT, _ST, _SA>&& __s, 6120 match_results<typename basic_string<_CharT, _ST, _SA>::const_iterator, _Allocator>& __m, 6121 const basic_regex<_CharT, _Traits>& __e, 6122 regex_constants::match_flag_type __flags = regex_constants::match_default) = delete; 6123#endif 6124 6125template <class _CharT, class _Traits> 6126inline _LIBCPP_INLINE_VISIBILITY 6127bool 6128regex_match(const _CharT* __str, const basic_regex<_CharT, _Traits>& __e, 6129 regex_constants::match_flag_type __flags = regex_constants::match_default) 6130{ 6131 return _VSTD::regex_match(__str, __str + _Traits::length(__str), __e, __flags); 6132} 6133 6134template <class _ST, class _SA, class _CharT, class _Traits> 6135inline _LIBCPP_INLINE_VISIBILITY 6136bool 6137regex_match(const basic_string<_CharT, _ST, _SA>& __s, 6138 const basic_regex<_CharT, _Traits>& __e, 6139 regex_constants::match_flag_type __flags = regex_constants::match_default) 6140{ 6141 return _VSTD::regex_match(__s.begin(), __s.end(), __e, __flags); 6142} 6143 6144// regex_iterator 6145 6146template <class _BidirectionalIterator, 6147 class _CharT = typename iterator_traits<_BidirectionalIterator>::value_type, 6148 class _Traits = regex_traits<_CharT> > 6149class _LIBCPP_TEMPLATE_VIS regex_iterator 6150{ 6151public: 6152 typedef basic_regex<_CharT, _Traits> regex_type; 6153 typedef match_results<_BidirectionalIterator> value_type; 6154 typedef ptrdiff_t difference_type; 6155 typedef const value_type* pointer; 6156 typedef const value_type& reference; 6157 typedef forward_iterator_tag iterator_category; 6158 6159private: 6160 _BidirectionalIterator __begin_; 6161 _BidirectionalIterator __end_; 6162 const regex_type* __pregex_; 6163 regex_constants::match_flag_type __flags_; 6164 value_type __match_; 6165 6166public: 6167 regex_iterator(); 6168 regex_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b, 6169 const regex_type& __re, 6170 regex_constants::match_flag_type __m 6171 = regex_constants::match_default); 6172#if _LIBCPP_STD_VER > 11 6173 regex_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b, 6174 const regex_type&& __re, 6175 regex_constants::match_flag_type __m 6176 = regex_constants::match_default) = delete; 6177#endif 6178 6179 bool operator==(const regex_iterator& __x) const; 6180 _LIBCPP_INLINE_VISIBILITY 6181 bool operator!=(const regex_iterator& __x) const {return !(*this == __x);} 6182 6183 _LIBCPP_INLINE_VISIBILITY 6184 reference operator*() const {return __match_;} 6185 _LIBCPP_INLINE_VISIBILITY 6186 pointer operator->() const {return _VSTD::addressof(__match_);} 6187 6188 regex_iterator& operator++(); 6189 _LIBCPP_INLINE_VISIBILITY 6190 regex_iterator operator++(int) 6191 { 6192 regex_iterator __t(*this); 6193 ++(*this); 6194 return __t; 6195 } 6196}; 6197 6198template <class _BidirectionalIterator, class _CharT, class _Traits> 6199regex_iterator<_BidirectionalIterator, _CharT, _Traits>::regex_iterator() 6200 : __begin_(), __end_(), __pregex_(nullptr), __flags_(), __match_() 6201{ 6202} 6203 6204template <class _BidirectionalIterator, class _CharT, class _Traits> 6205regex_iterator<_BidirectionalIterator, _CharT, _Traits>:: 6206 regex_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b, 6207 const regex_type& __re, regex_constants::match_flag_type __m) 6208 : __begin_(__a), 6209 __end_(__b), 6210 __pregex_(_VSTD::addressof(__re)), 6211 __flags_(__m) 6212{ 6213 _VSTD::regex_search(__begin_, __end_, __match_, *__pregex_, __flags_); 6214} 6215 6216template <class _BidirectionalIterator, class _CharT, class _Traits> 6217bool 6218regex_iterator<_BidirectionalIterator, _CharT, _Traits>:: 6219 operator==(const regex_iterator& __x) const 6220{ 6221 if (__match_.empty() && __x.__match_.empty()) 6222 return true; 6223 if (__match_.empty() || __x.__match_.empty()) 6224 return false; 6225 return __begin_ == __x.__begin_ && 6226 __end_ == __x.__end_ && 6227 __pregex_ == __x.__pregex_ && 6228 __flags_ == __x.__flags_ && 6229 __match_[0] == __x.__match_[0]; 6230} 6231 6232template <class _BidirectionalIterator, class _CharT, class _Traits> 6233regex_iterator<_BidirectionalIterator, _CharT, _Traits>& 6234regex_iterator<_BidirectionalIterator, _CharT, _Traits>::operator++() 6235{ 6236 __flags_ |= regex_constants::__no_update_pos; 6237 _BidirectionalIterator __start = __match_[0].second; 6238 if (__match_[0].first == __match_[0].second) 6239 { 6240 if (__start == __end_) 6241 { 6242 __match_ = value_type(); 6243 return *this; 6244 } 6245 else if (_VSTD::regex_search(__start, __end_, __match_, *__pregex_, 6246 __flags_ | regex_constants::match_not_null | 6247 regex_constants::match_continuous)) 6248 return *this; 6249 else 6250 ++__start; 6251 } 6252 __flags_ |= regex_constants::match_prev_avail; 6253 if (!_VSTD::regex_search(__start, __end_, __match_, *__pregex_, __flags_)) 6254 __match_ = value_type(); 6255 return *this; 6256} 6257 6258typedef regex_iterator<const char*> cregex_iterator; 6259typedef regex_iterator<const wchar_t*> wcregex_iterator; 6260typedef regex_iterator<string::const_iterator> sregex_iterator; 6261typedef regex_iterator<wstring::const_iterator> wsregex_iterator; 6262 6263// regex_token_iterator 6264 6265template <class _BidirectionalIterator, 6266 class _CharT = typename iterator_traits<_BidirectionalIterator>::value_type, 6267 class _Traits = regex_traits<_CharT> > 6268class _LIBCPP_TEMPLATE_VIS regex_token_iterator 6269{ 6270public: 6271 typedef basic_regex<_CharT, _Traits> regex_type; 6272 typedef sub_match<_BidirectionalIterator> value_type; 6273 typedef ptrdiff_t difference_type; 6274 typedef const value_type* pointer; 6275 typedef const value_type& reference; 6276 typedef forward_iterator_tag iterator_category; 6277 6278private: 6279 typedef regex_iterator<_BidirectionalIterator, _CharT, _Traits> _Position; 6280 6281 _Position __position_; 6282 const value_type* __result_; 6283 value_type __suffix_; 6284 ptrdiff_t __n_; 6285 vector<int> __subs_; 6286 6287public: 6288 regex_token_iterator(); 6289 regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b, 6290 const regex_type& __re, int __submatch = 0, 6291 regex_constants::match_flag_type __m = 6292 regex_constants::match_default); 6293#if _LIBCPP_STD_VER > 11 6294 regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b, 6295 const regex_type&& __re, int __submatch = 0, 6296 regex_constants::match_flag_type __m = 6297 regex_constants::match_default) = delete; 6298#endif 6299 6300 regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b, 6301 const regex_type& __re, const vector<int>& __submatches, 6302 regex_constants::match_flag_type __m = 6303 regex_constants::match_default); 6304#if _LIBCPP_STD_VER > 11 6305 regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b, 6306 const regex_type&& __re, const vector<int>& __submatches, 6307 regex_constants::match_flag_type __m = 6308 regex_constants::match_default) = delete; 6309#endif 6310 6311#ifndef _LIBCPP_CXX03_LANG 6312 regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b, 6313 const regex_type& __re, 6314 initializer_list<int> __submatches, 6315 regex_constants::match_flag_type __m = 6316 regex_constants::match_default); 6317 6318#if _LIBCPP_STD_VER > 11 6319 regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b, 6320 const regex_type&& __re, 6321 initializer_list<int> __submatches, 6322 regex_constants::match_flag_type __m = 6323 regex_constants::match_default) = delete; 6324#endif 6325#endif // _LIBCPP_CXX03_LANG 6326 template <size_t _Np> 6327 regex_token_iterator(_BidirectionalIterator __a, 6328 _BidirectionalIterator __b, 6329 const regex_type& __re, 6330 const int (&__submatches)[_Np], 6331 regex_constants::match_flag_type __m = 6332 regex_constants::match_default); 6333#if _LIBCPP_STD_VER > 11 6334 template <std::size_t _Np> 6335 regex_token_iterator(_BidirectionalIterator __a, 6336 _BidirectionalIterator __b, 6337 const regex_type&& __re, 6338 const int (&__submatches)[_Np], 6339 regex_constants::match_flag_type __m = 6340 regex_constants::match_default) = delete; 6341#endif 6342 6343 regex_token_iterator(const regex_token_iterator&); 6344 regex_token_iterator& operator=(const regex_token_iterator&); 6345 6346 bool operator==(const regex_token_iterator& __x) const; 6347 _LIBCPP_INLINE_VISIBILITY 6348 bool operator!=(const regex_token_iterator& __x) const {return !(*this == __x);} 6349 6350 _LIBCPP_INLINE_VISIBILITY 6351 const value_type& operator*() const {return *__result_;} 6352 _LIBCPP_INLINE_VISIBILITY 6353 const value_type* operator->() const {return __result_;} 6354 6355 regex_token_iterator& operator++(); 6356 _LIBCPP_INLINE_VISIBILITY 6357 regex_token_iterator operator++(int) 6358 { 6359 regex_token_iterator __t(*this); 6360 ++(*this); 6361 return __t; 6362 } 6363 6364private: 6365 void __init(_BidirectionalIterator __a, _BidirectionalIterator __b); 6366 void __establish_result () { 6367 if (__subs_[__n_] == -1) 6368 __result_ = &__position_->prefix(); 6369 else 6370 __result_ = &(*__position_)[__subs_[__n_]]; 6371 } 6372}; 6373 6374template <class _BidirectionalIterator, class _CharT, class _Traits> 6375regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>:: 6376 regex_token_iterator() 6377 : __result_(nullptr), 6378 __suffix_(), 6379 __n_(0) 6380{ 6381} 6382 6383template <class _BidirectionalIterator, class _CharT, class _Traits> 6384void 6385regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>:: 6386 __init(_BidirectionalIterator __a, _BidirectionalIterator __b) 6387{ 6388 if (__position_ != _Position()) 6389 __establish_result (); 6390 else if (__subs_[__n_] == -1) 6391 { 6392 __suffix_.matched = true; 6393 __suffix_.first = __a; 6394 __suffix_.second = __b; 6395 __result_ = &__suffix_; 6396 } 6397 else 6398 __result_ = nullptr; 6399} 6400 6401template <class _BidirectionalIterator, class _CharT, class _Traits> 6402regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>:: 6403 regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b, 6404 const regex_type& __re, int __submatch, 6405 regex_constants::match_flag_type __m) 6406 : __position_(__a, __b, __re, __m), 6407 __n_(0), 6408 __subs_(1, __submatch) 6409{ 6410 __init(__a, __b); 6411} 6412 6413template <class _BidirectionalIterator, class _CharT, class _Traits> 6414regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>:: 6415 regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b, 6416 const regex_type& __re, const vector<int>& __submatches, 6417 regex_constants::match_flag_type __m) 6418 : __position_(__a, __b, __re, __m), 6419 __n_(0), 6420 __subs_(__submatches) 6421{ 6422 __init(__a, __b); 6423} 6424 6425#ifndef _LIBCPP_CXX03_LANG 6426 6427template <class _BidirectionalIterator, class _CharT, class _Traits> 6428regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>:: 6429 regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b, 6430 const regex_type& __re, 6431 initializer_list<int> __submatches, 6432 regex_constants::match_flag_type __m) 6433 : __position_(__a, __b, __re, __m), 6434 __n_(0), 6435 __subs_(__submatches) 6436{ 6437 __init(__a, __b); 6438} 6439 6440#endif // _LIBCPP_CXX03_LANG 6441 6442template <class _BidirectionalIterator, class _CharT, class _Traits> 6443template <size_t _Np> 6444regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>:: 6445 regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b, 6446 const regex_type& __re, 6447 const int (&__submatches)[_Np], 6448 regex_constants::match_flag_type __m) 6449 : __position_(__a, __b, __re, __m), 6450 __n_(0), 6451 __subs_(begin(__submatches), end(__submatches)) 6452{ 6453 __init(__a, __b); 6454} 6455 6456template <class _BidirectionalIterator, class _CharT, class _Traits> 6457regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>:: 6458 regex_token_iterator(const regex_token_iterator& __x) 6459 : __position_(__x.__position_), 6460 __result_(__x.__result_), 6461 __suffix_(__x.__suffix_), 6462 __n_(__x.__n_), 6463 __subs_(__x.__subs_) 6464{ 6465 if (__x.__result_ == &__x.__suffix_) 6466 __result_ = &__suffix_; 6467 else if ( __result_ != nullptr ) 6468 __establish_result (); 6469} 6470 6471template <class _BidirectionalIterator, class _CharT, class _Traits> 6472regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>& 6473regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>:: 6474 operator=(const regex_token_iterator& __x) 6475{ 6476 if (this != &__x) 6477 { 6478 __position_ = __x.__position_; 6479 if (__x.__result_ == &__x.__suffix_) 6480 __result_ = &__suffix_; 6481 else 6482 __result_ = __x.__result_; 6483 __suffix_ = __x.__suffix_; 6484 __n_ = __x.__n_; 6485 __subs_ = __x.__subs_; 6486 6487 if ( __result_ != nullptr && __result_ != &__suffix_ ) 6488 __establish_result(); 6489 } 6490 return *this; 6491} 6492 6493template <class _BidirectionalIterator, class _CharT, class _Traits> 6494bool 6495regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>:: 6496 operator==(const regex_token_iterator& __x) const 6497{ 6498 if (__result_ == nullptr && __x.__result_ == nullptr) 6499 return true; 6500 if (__result_ == &__suffix_ && __x.__result_ == &__x.__suffix_ && 6501 __suffix_ == __x.__suffix_) 6502 return true; 6503 if (__result_ == nullptr || __x.__result_ == nullptr) 6504 return false; 6505 if (__result_ == &__suffix_ || __x.__result_ == &__x.__suffix_) 6506 return false; 6507 return __position_ == __x.__position_ && __n_ == __x.__n_ && 6508 __subs_ == __x.__subs_; 6509} 6510 6511template <class _BidirectionalIterator, class _CharT, class _Traits> 6512regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>& 6513regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::operator++() 6514{ 6515 _Position __prev = __position_; 6516 if (__result_ == &__suffix_) 6517 __result_ = nullptr; 6518 else if (static_cast<size_t>(__n_ + 1) < __subs_.size()) 6519 { 6520 ++__n_; 6521 __establish_result(); 6522 } 6523 else 6524 { 6525 __n_ = 0; 6526 ++__position_; 6527 if (__position_ != _Position()) 6528 __establish_result(); 6529 else 6530 { 6531 if (_VSTD::find(__subs_.begin(), __subs_.end(), -1) != __subs_.end() 6532 && __prev->suffix().length() != 0) 6533 { 6534 __suffix_.matched = true; 6535 __suffix_.first = __prev->suffix().first; 6536 __suffix_.second = __prev->suffix().second; 6537 __result_ = &__suffix_; 6538 } 6539 else 6540 __result_ = nullptr; 6541 } 6542 } 6543 return *this; 6544} 6545 6546typedef regex_token_iterator<const char*> cregex_token_iterator; 6547typedef regex_token_iterator<const wchar_t*> wcregex_token_iterator; 6548typedef regex_token_iterator<string::const_iterator> sregex_token_iterator; 6549typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator; 6550 6551// regex_replace 6552 6553template <class _OutputIterator, class _BidirectionalIterator, 6554 class _Traits, class _CharT> 6555_OutputIterator 6556regex_replace(_OutputIterator __output_iter, 6557 _BidirectionalIterator __first, _BidirectionalIterator __last, 6558 const basic_regex<_CharT, _Traits>& __e, const _CharT* __fmt, 6559 regex_constants::match_flag_type __flags = regex_constants::match_default) 6560{ 6561 typedef regex_iterator<_BidirectionalIterator, _CharT, _Traits> _Iter; 6562 _Iter __i(__first, __last, __e, __flags); 6563 _Iter __eof; 6564 if (__i == __eof) 6565 { 6566 if (!(__flags & regex_constants::format_no_copy)) 6567 __output_iter = _VSTD::copy(__first, __last, __output_iter); 6568 } 6569 else 6570 { 6571 sub_match<_BidirectionalIterator> __lm; 6572 for (size_t __len = char_traits<_CharT>::length(__fmt); __i != __eof; ++__i) 6573 { 6574 if (!(__flags & regex_constants::format_no_copy)) 6575 __output_iter = _VSTD::copy(__i->prefix().first, __i->prefix().second, __output_iter); 6576 __output_iter = __i->format(__output_iter, __fmt, __fmt + __len, __flags); 6577 __lm = __i->suffix(); 6578 if (__flags & regex_constants::format_first_only) 6579 break; 6580 } 6581 if (!(__flags & regex_constants::format_no_copy)) 6582 __output_iter = _VSTD::copy(__lm.first, __lm.second, __output_iter); 6583 } 6584 return __output_iter; 6585} 6586 6587template <class _OutputIterator, class _BidirectionalIterator, 6588 class _Traits, class _CharT, class _ST, class _SA> 6589inline _LIBCPP_INLINE_VISIBILITY 6590_OutputIterator 6591regex_replace(_OutputIterator __output_iter, 6592 _BidirectionalIterator __first, _BidirectionalIterator __last, 6593 const basic_regex<_CharT, _Traits>& __e, 6594 const basic_string<_CharT, _ST, _SA>& __fmt, 6595 regex_constants::match_flag_type __flags = regex_constants::match_default) 6596{ 6597 return _VSTD::regex_replace(__output_iter, __first, __last, __e, __fmt.c_str(), __flags); 6598} 6599 6600template <class _Traits, class _CharT, class _ST, class _SA, class _FST, 6601 class _FSA> 6602inline _LIBCPP_INLINE_VISIBILITY 6603basic_string<_CharT, _ST, _SA> 6604regex_replace(const basic_string<_CharT, _ST, _SA>& __s, 6605 const basic_regex<_CharT, _Traits>& __e, 6606 const basic_string<_CharT, _FST, _FSA>& __fmt, 6607 regex_constants::match_flag_type __flags = regex_constants::match_default) 6608{ 6609 basic_string<_CharT, _ST, _SA> __r; 6610 _VSTD::regex_replace(back_inserter(__r), __s.begin(), __s.end(), __e, 6611 __fmt.c_str(), __flags); 6612 return __r; 6613} 6614 6615template <class _Traits, class _CharT, class _ST, class _SA> 6616inline _LIBCPP_INLINE_VISIBILITY 6617basic_string<_CharT, _ST, _SA> 6618regex_replace(const basic_string<_CharT, _ST, _SA>& __s, 6619 const basic_regex<_CharT, _Traits>& __e, const _CharT* __fmt, 6620 regex_constants::match_flag_type __flags = regex_constants::match_default) 6621{ 6622 basic_string<_CharT, _ST, _SA> __r; 6623 _VSTD::regex_replace(back_inserter(__r), __s.begin(), __s.end(), __e, 6624 __fmt, __flags); 6625 return __r; 6626} 6627 6628template <class _Traits, class _CharT, class _ST, class _SA> 6629inline _LIBCPP_INLINE_VISIBILITY 6630basic_string<_CharT> 6631regex_replace(const _CharT* __s, 6632 const basic_regex<_CharT, _Traits>& __e, 6633 const basic_string<_CharT, _ST, _SA>& __fmt, 6634 regex_constants::match_flag_type __flags = regex_constants::match_default) 6635{ 6636 basic_string<_CharT> __r; 6637 _VSTD::regex_replace(back_inserter(__r), __s, 6638 __s + char_traits<_CharT>::length(__s), __e, 6639 __fmt.c_str(), __flags); 6640 return __r; 6641} 6642 6643template <class _Traits, class _CharT> 6644inline _LIBCPP_INLINE_VISIBILITY 6645basic_string<_CharT> 6646regex_replace(const _CharT* __s, 6647 const basic_regex<_CharT, _Traits>& __e, 6648 const _CharT* __fmt, 6649 regex_constants::match_flag_type __flags = regex_constants::match_default) 6650{ 6651 basic_string<_CharT> __r; 6652 _VSTD::regex_replace(back_inserter(__r), __s, 6653 __s + char_traits<_CharT>::length(__s), __e, 6654 __fmt, __flags); 6655 return __r; 6656} 6657 6658_LIBCPP_END_NAMESPACE_STD 6659 6660_LIBCPP_POP_MACROS 6661 6662#endif // _LIBCPP_REGEX 6663