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