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