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