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