10b57cec5SDimitry Andric// -*- C++ -*- 2349cc55cSDimitry Andric//===----------------------------------------------------------------------===// 30b57cec5SDimitry Andric// 40b57cec5SDimitry Andric// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 50b57cec5SDimitry Andric// See https://llvm.org/LICENSE.txt for license information. 60b57cec5SDimitry Andric// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 70b57cec5SDimitry Andric// 80b57cec5SDimitry Andric//===----------------------------------------------------------------------===// 90b57cec5SDimitry Andric 100b57cec5SDimitry Andric#ifndef _LIBCPP_REGEX 110b57cec5SDimitry Andric#define _LIBCPP_REGEX 120b57cec5SDimitry Andric 130b57cec5SDimitry Andric/* 140b57cec5SDimitry Andric regex synopsis 150b57cec5SDimitry Andric 1606c3fb27SDimitry Andric#include <compare> 170b57cec5SDimitry Andric#include <initializer_list> 180b57cec5SDimitry Andric 190b57cec5SDimitry Andricnamespace std 200b57cec5SDimitry Andric{ 210b57cec5SDimitry Andric 220b57cec5SDimitry Andricnamespace regex_constants 230b57cec5SDimitry Andric{ 240b57cec5SDimitry Andric 255ffd83dbSDimitry Andricenum syntax_option_type 260b57cec5SDimitry Andric{ 270b57cec5SDimitry Andric icase = unspecified, 280b57cec5SDimitry Andric nosubs = unspecified, 290b57cec5SDimitry Andric optimize = unspecified, 300b57cec5SDimitry Andric collate = unspecified, 310b57cec5SDimitry Andric ECMAScript = unspecified, 320b57cec5SDimitry Andric basic = unspecified, 330b57cec5SDimitry Andric extended = unspecified, 340b57cec5SDimitry Andric awk = unspecified, 350b57cec5SDimitry Andric grep = unspecified, 36e8d8bef9SDimitry Andric egrep = unspecified, 37e8d8bef9SDimitry Andric multiline = unspecified 380b57cec5SDimitry Andric}; 390b57cec5SDimitry Andric 400b57cec5SDimitry Andricconstexpr syntax_option_type operator~(syntax_option_type f); 410b57cec5SDimitry Andricconstexpr syntax_option_type operator&(syntax_option_type lhs, syntax_option_type rhs); 420b57cec5SDimitry Andricconstexpr syntax_option_type operator|(syntax_option_type lhs, syntax_option_type rhs); 430b57cec5SDimitry Andric 440b57cec5SDimitry Andricenum match_flag_type 450b57cec5SDimitry Andric{ 460b57cec5SDimitry Andric match_default = 0, 470b57cec5SDimitry Andric match_not_bol = unspecified, 480b57cec5SDimitry Andric match_not_eol = unspecified, 490b57cec5SDimitry Andric match_not_bow = unspecified, 500b57cec5SDimitry Andric match_not_eow = unspecified, 510b57cec5SDimitry Andric match_any = unspecified, 520b57cec5SDimitry Andric match_not_null = unspecified, 530b57cec5SDimitry Andric match_continuous = unspecified, 540b57cec5SDimitry Andric match_prev_avail = unspecified, 550b57cec5SDimitry Andric format_default = 0, 560b57cec5SDimitry Andric format_sed = unspecified, 570b57cec5SDimitry Andric format_no_copy = unspecified, 580b57cec5SDimitry Andric format_first_only = unspecified 590b57cec5SDimitry Andric}; 600b57cec5SDimitry Andric 610b57cec5SDimitry Andricconstexpr match_flag_type operator~(match_flag_type f); 620b57cec5SDimitry Andricconstexpr match_flag_type operator&(match_flag_type lhs, match_flag_type rhs); 630b57cec5SDimitry Andricconstexpr match_flag_type operator|(match_flag_type lhs, match_flag_type rhs); 640b57cec5SDimitry Andric 650b57cec5SDimitry Andricenum error_type 660b57cec5SDimitry Andric{ 670b57cec5SDimitry Andric error_collate = unspecified, 680b57cec5SDimitry Andric error_ctype = unspecified, 690b57cec5SDimitry Andric error_escape = unspecified, 700b57cec5SDimitry Andric error_backref = unspecified, 710b57cec5SDimitry Andric error_brack = unspecified, 720b57cec5SDimitry Andric error_paren = unspecified, 730b57cec5SDimitry Andric error_brace = unspecified, 740b57cec5SDimitry Andric error_badbrace = unspecified, 750b57cec5SDimitry Andric error_range = unspecified, 760b57cec5SDimitry Andric error_space = unspecified, 770b57cec5SDimitry Andric error_badrepeat = unspecified, 780b57cec5SDimitry Andric error_complexity = unspecified, 790b57cec5SDimitry Andric error_stack = unspecified 800b57cec5SDimitry Andric}; 810b57cec5SDimitry Andric 820b57cec5SDimitry Andric} // regex_constants 830b57cec5SDimitry Andric 840b57cec5SDimitry Andricclass regex_error 850b57cec5SDimitry Andric : public runtime_error 860b57cec5SDimitry Andric{ 870b57cec5SDimitry Andricpublic: 880b57cec5SDimitry Andric explicit regex_error(regex_constants::error_type ecode); 890b57cec5SDimitry Andric regex_constants::error_type code() const; 900b57cec5SDimitry Andric}; 910b57cec5SDimitry Andric 920b57cec5SDimitry Andrictemplate <class charT> 930b57cec5SDimitry Andricstruct regex_traits 940b57cec5SDimitry Andric{ 950b57cec5SDimitry Andricpublic: 960b57cec5SDimitry Andric typedef charT char_type; 970b57cec5SDimitry Andric typedef basic_string<char_type> string_type; 980b57cec5SDimitry Andric typedef locale locale_type; 990b57cec5SDimitry Andric typedef /bitmask_type/ char_class_type; 1000b57cec5SDimitry Andric 1010b57cec5SDimitry Andric regex_traits(); 1020b57cec5SDimitry Andric 1030b57cec5SDimitry Andric static size_t length(const char_type* p); 1040b57cec5SDimitry Andric charT translate(charT c) const; 1050b57cec5SDimitry Andric charT translate_nocase(charT c) const; 1060b57cec5SDimitry Andric template <class ForwardIterator> 1070b57cec5SDimitry Andric string_type 1080b57cec5SDimitry Andric transform(ForwardIterator first, ForwardIterator last) const; 1090b57cec5SDimitry Andric template <class ForwardIterator> 1100b57cec5SDimitry Andric string_type 1110b57cec5SDimitry Andric transform_primary( ForwardIterator first, ForwardIterator last) const; 1120b57cec5SDimitry Andric template <class ForwardIterator> 1130b57cec5SDimitry Andric string_type 1140b57cec5SDimitry Andric lookup_collatename(ForwardIterator first, ForwardIterator last) const; 1150b57cec5SDimitry Andric template <class ForwardIterator> 1160b57cec5SDimitry Andric char_class_type 1170b57cec5SDimitry Andric lookup_classname(ForwardIterator first, ForwardIterator last, 1180b57cec5SDimitry Andric bool icase = false) const; 1190b57cec5SDimitry Andric bool isctype(charT c, char_class_type f) const; 1200b57cec5SDimitry Andric int value(charT ch, int radix) const; 1210b57cec5SDimitry Andric locale_type imbue(locale_type l); 1220b57cec5SDimitry Andric locale_type getloc()const; 1230b57cec5SDimitry Andric}; 1240b57cec5SDimitry Andric 1250b57cec5SDimitry Andrictemplate <class charT, class traits = regex_traits<charT>> 1260b57cec5SDimitry Andricclass basic_regex 1270b57cec5SDimitry Andric{ 1280b57cec5SDimitry Andricpublic: 1290b57cec5SDimitry Andric // types: 1300b57cec5SDimitry Andric typedef charT value_type; 1310b57cec5SDimitry Andric typedef traits traits_type; 1320b57cec5SDimitry Andric typedef typename traits::string_type string_type; 1330b57cec5SDimitry Andric typedef regex_constants::syntax_option_type flag_type; 1340b57cec5SDimitry Andric typedef typename traits::locale_type locale_type; 1350b57cec5SDimitry Andric 1360b57cec5SDimitry Andric // constants: 1370b57cec5SDimitry Andric static constexpr regex_constants::syntax_option_type icase = regex_constants::icase; 1380b57cec5SDimitry Andric static constexpr regex_constants::syntax_option_type nosubs = regex_constants::nosubs; 1390b57cec5SDimitry Andric static constexpr regex_constants::syntax_option_type optimize = regex_constants::optimize; 1400b57cec5SDimitry Andric static constexpr regex_constants::syntax_option_type collate = regex_constants::collate; 1410b57cec5SDimitry Andric static constexpr regex_constants::syntax_option_type ECMAScript = regex_constants::ECMAScript; 1420b57cec5SDimitry Andric static constexpr regex_constants::syntax_option_type basic = regex_constants::basic; 1430b57cec5SDimitry Andric static constexpr regex_constants::syntax_option_type extended = regex_constants::extended; 1440b57cec5SDimitry Andric static constexpr regex_constants::syntax_option_type awk = regex_constants::awk; 1450b57cec5SDimitry Andric static constexpr regex_constants::syntax_option_type grep = regex_constants::grep; 1460b57cec5SDimitry Andric static constexpr regex_constants::syntax_option_type egrep = regex_constants::egrep; 147e8d8bef9SDimitry Andric static constexpr regex_constants::syntax_option_type multiline = regex_constants::multiline; 1480b57cec5SDimitry Andric 1490b57cec5SDimitry Andric // construct/copy/destroy: 1500b57cec5SDimitry Andric basic_regex(); 1510b57cec5SDimitry Andric explicit basic_regex(const charT* p, flag_type f = regex_constants::ECMAScript); 1520b57cec5SDimitry Andric basic_regex(const charT* p, size_t len, flag_type f = regex_constants::ECMAScript); 1530b57cec5SDimitry Andric basic_regex(const basic_regex&); 1540b57cec5SDimitry Andric basic_regex(basic_regex&&) noexcept; 1550b57cec5SDimitry Andric template <class ST, class SA> 1560b57cec5SDimitry Andric explicit basic_regex(const basic_string<charT, ST, SA>& p, 1570b57cec5SDimitry Andric flag_type f = regex_constants::ECMAScript); 1580b57cec5SDimitry Andric template <class ForwardIterator> 1590b57cec5SDimitry Andric basic_regex(ForwardIterator first, ForwardIterator last, 1600b57cec5SDimitry Andric flag_type f = regex_constants::ECMAScript); 1610b57cec5SDimitry Andric basic_regex(initializer_list<charT>, flag_type = regex_constants::ECMAScript); 1620b57cec5SDimitry Andric 1630b57cec5SDimitry Andric ~basic_regex(); 1640b57cec5SDimitry Andric 1650b57cec5SDimitry Andric basic_regex& operator=(const basic_regex&); 1660b57cec5SDimitry Andric basic_regex& operator=(basic_regex&&) noexcept; 1670b57cec5SDimitry Andric basic_regex& operator=(const charT* ptr); 1680b57cec5SDimitry Andric basic_regex& operator=(initializer_list<charT> il); 1690b57cec5SDimitry Andric template <class ST, class SA> 1700b57cec5SDimitry Andric basic_regex& operator=(const basic_string<charT, ST, SA>& p); 1710b57cec5SDimitry Andric 1720b57cec5SDimitry Andric // assign: 1730b57cec5SDimitry Andric basic_regex& assign(const basic_regex& that); 1740b57cec5SDimitry Andric basic_regex& assign(basic_regex&& that) noexcept; 1750b57cec5SDimitry Andric basic_regex& assign(const charT* ptr, flag_type f = regex_constants::ECMAScript); 176e40139ffSDimitry Andric basic_regex& assign(const charT* p, size_t len, flag_type f = regex_constants::ECMAScript); 1770b57cec5SDimitry Andric template <class string_traits, class A> 1780b57cec5SDimitry Andric basic_regex& assign(const basic_string<charT, string_traits, A>& s, 1790b57cec5SDimitry Andric flag_type f = regex_constants::ECMAScript); 1800b57cec5SDimitry Andric template <class InputIterator> 1810b57cec5SDimitry Andric basic_regex& assign(InputIterator first, InputIterator last, 1820b57cec5SDimitry Andric flag_type f = regex_constants::ECMAScript); 183e40139ffSDimitry Andric basic_regex& assign(initializer_list<charT>, flag_type f = regex_constants::ECMAScript); 1840b57cec5SDimitry Andric 1850b57cec5SDimitry Andric // const operations: 1860b57cec5SDimitry Andric unsigned mark_count() const; 1870b57cec5SDimitry Andric flag_type flags() const; 1880b57cec5SDimitry Andric 1890b57cec5SDimitry Andric // locale: 1900b57cec5SDimitry Andric locale_type imbue(locale_type loc); 1910b57cec5SDimitry Andric locale_type getloc() const; 1920b57cec5SDimitry Andric 1930b57cec5SDimitry Andric // swap: 1940b57cec5SDimitry Andric void swap(basic_regex&); 1950b57cec5SDimitry Andric}; 1960b57cec5SDimitry Andric 1970b57cec5SDimitry Andrictemplate<class ForwardIterator> 1980b57cec5SDimitry Andricbasic_regex(ForwardIterator, ForwardIterator, 1990b57cec5SDimitry Andric regex_constants::syntax_option_type = regex_constants::ECMAScript) 2000b57cec5SDimitry Andric -> basic_regex<typename iterator_traits<ForwardIterator>::value_type>; // C++17 2010b57cec5SDimitry Andric 2020b57cec5SDimitry Andrictypedef basic_regex<char> regex; 2030b57cec5SDimitry Andrictypedef basic_regex<wchar_t> wregex; 2040b57cec5SDimitry Andric 2050b57cec5SDimitry Andrictemplate <class charT, class traits> 2060b57cec5SDimitry Andric void swap(basic_regex<charT, traits>& e1, basic_regex<charT, traits>& e2); 2070b57cec5SDimitry Andric 2080b57cec5SDimitry Andrictemplate <class BidirectionalIterator> 2090b57cec5SDimitry Andricclass sub_match 2100b57cec5SDimitry Andric : public pair<BidirectionalIterator, BidirectionalIterator> 2110b57cec5SDimitry Andric{ 2120b57cec5SDimitry Andricpublic: 2130b57cec5SDimitry Andric typedef typename iterator_traits<BidirectionalIterator>::value_type value_type; 2140b57cec5SDimitry Andric typedef typename iterator_traits<BidirectionalIterator>::difference_type difference_type; 2150b57cec5SDimitry Andric typedef BidirectionalIterator iterator; 2160b57cec5SDimitry Andric typedef basic_string<value_type> string_type; 2170b57cec5SDimitry Andric 2180b57cec5SDimitry Andric bool matched; 2190b57cec5SDimitry Andric 2200b57cec5SDimitry Andric constexpr sub_match(); 2210b57cec5SDimitry Andric 2220b57cec5SDimitry Andric difference_type length() const; 2230b57cec5SDimitry Andric operator string_type() const; 2240b57cec5SDimitry Andric string_type str() const; 2250b57cec5SDimitry Andric 2260b57cec5SDimitry Andric int compare(const sub_match& s) const; 2270b57cec5SDimitry Andric int compare(const string_type& s) const; 2280b57cec5SDimitry Andric int compare(const value_type* s) const; 22906c3fb27SDimitry Andric 23006c3fb27SDimitry Andric void swap(sub_match& s) noexcept(see below); 2310b57cec5SDimitry Andric}; 2320b57cec5SDimitry Andric 2330b57cec5SDimitry Andrictypedef sub_match<const char*> csub_match; 2340b57cec5SDimitry Andrictypedef sub_match<const wchar_t*> wcsub_match; 2350b57cec5SDimitry Andrictypedef sub_match<string::const_iterator> ssub_match; 2360b57cec5SDimitry Andrictypedef sub_match<wstring::const_iterator> wssub_match; 2370b57cec5SDimitry Andric 2380b57cec5SDimitry Andrictemplate <class BiIter> 2390b57cec5SDimitry Andric bool 2400b57cec5SDimitry Andric operator==(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs); 2410b57cec5SDimitry Andric 2420b57cec5SDimitry Andrictemplate <class BiIter> 24306c3fb27SDimitry Andric auto 24406c3fb27SDimitry Andric operator<=>(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs); // Since C++20 24506c3fb27SDimitry Andric 24606c3fb27SDimitry Andric template <class BiIter> // Removed in C++20 2470b57cec5SDimitry Andric bool 2480b57cec5SDimitry Andric operator!=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs); 2490b57cec5SDimitry Andric 25006c3fb27SDimitry Andrictemplate <class BiIter> // Removed in C++20 2510b57cec5SDimitry Andric bool 2520b57cec5SDimitry Andric operator<(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs); 2530b57cec5SDimitry Andric 25406c3fb27SDimitry Andrictemplate <class BiIter> // Removed in C++20 2550b57cec5SDimitry Andric bool 2560b57cec5SDimitry Andric operator<=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs); 2570b57cec5SDimitry Andric 25806c3fb27SDimitry Andrictemplate <class BiIter> // Removed in C++20 2590b57cec5SDimitry Andric bool 2600b57cec5SDimitry Andric operator>=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs); 2610b57cec5SDimitry Andric 26206c3fb27SDimitry Andrictemplate <class BiIter> // Removed in C++20 2630b57cec5SDimitry Andric bool 2640b57cec5SDimitry Andric operator>(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs); 2650b57cec5SDimitry Andric 26606c3fb27SDimitry Andrictemplate <class BiIter, class ST, class SA> // Removed in C++20 2670b57cec5SDimitry Andric bool 2680b57cec5SDimitry Andric operator==(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs, 2690b57cec5SDimitry Andric const sub_match<BiIter>& rhs); 2700b57cec5SDimitry Andric 27106c3fb27SDimitry Andrictemplate <class BiIter, class ST, class SA> // Removed in C++20 2720b57cec5SDimitry Andric bool 2730b57cec5SDimitry Andric operator!=(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs, 2740b57cec5SDimitry Andric const sub_match<BiIter>& rhs); 2750b57cec5SDimitry Andric 27606c3fb27SDimitry Andrictemplate <class BiIter, class ST, class SA> // Removed in C++20 2770b57cec5SDimitry Andric bool 2780b57cec5SDimitry Andric operator<(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs, 2790b57cec5SDimitry Andric const sub_match<BiIter>& rhs); 2800b57cec5SDimitry Andric 28106c3fb27SDimitry Andrictemplate <class BiIter, class ST, class SA> // Removed in C++20 2820b57cec5SDimitry Andric bool 2830b57cec5SDimitry Andric operator>(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs, 2840b57cec5SDimitry Andric const sub_match<BiIter>& rhs); 2850b57cec5SDimitry Andric 28606c3fb27SDimitry Andrictemplate <class BiIter, class ST, class SA> // Removed in C++20 2870b57cec5SDimitry Andric bool operator>=(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs, 2880b57cec5SDimitry Andric const sub_match<BiIter>& rhs); 2890b57cec5SDimitry Andric 29006c3fb27SDimitry Andrictemplate <class BiIter, class ST, class SA> // Removed in C++20 2910b57cec5SDimitry Andric bool 2920b57cec5SDimitry Andric operator<=(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs, 2930b57cec5SDimitry Andric const sub_match<BiIter>& rhs); 2940b57cec5SDimitry Andric 2950b57cec5SDimitry Andrictemplate <class BiIter, class ST, class SA> 2960b57cec5SDimitry Andric bool 2970b57cec5SDimitry Andric operator==(const sub_match<BiIter>& lhs, 2980b57cec5SDimitry Andric const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs); 2990b57cec5SDimitry Andric 30006c3fb27SDimitry Andrictemplate <class BiIter, class ST, class SA> // Since C++20 30106c3fb27SDimitry Andric auto 30206c3fb27SDimitry Andric operator<=>(const sub_match<BiIter>& lhs, 30306c3fb27SDimitry Andric const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs); 30406c3fb27SDimitry Andric 30506c3fb27SDimitry Andrictemplate <class BiIter, class ST, class SA> // Removed in C++20 3060b57cec5SDimitry Andric bool 3070b57cec5SDimitry Andric operator!=(const sub_match<BiIter>& lhs, 3080b57cec5SDimitry Andric const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs); 3090b57cec5SDimitry Andric 31006c3fb27SDimitry Andrictemplate <class BiIter, class ST, class SA> // Removed in C++20 3110b57cec5SDimitry Andric bool 3120b57cec5SDimitry Andric operator<(const sub_match<BiIter>& lhs, 3130b57cec5SDimitry Andric const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs); 3140b57cec5SDimitry Andric 31506c3fb27SDimitry Andrictemplate <class BiIter, class ST, class SA> // Removed in C++20 31606c3fb27SDimitry Andric bool 31706c3fb27SDimitry Andric operator>(const sub_match<BiIter>& lhs, 3180b57cec5SDimitry Andric const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs); 3190b57cec5SDimitry Andric 32006c3fb27SDimitry Andrictemplate <class BiIter, class ST, class SA> // Removed in C++20 3210b57cec5SDimitry Andric bool 3220b57cec5SDimitry Andric operator>=(const sub_match<BiIter>& lhs, 3230b57cec5SDimitry Andric const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs); 3240b57cec5SDimitry Andric 32506c3fb27SDimitry Andrictemplate <class BiIter, class ST, class SA> // Removed in C++20 3260b57cec5SDimitry Andric bool 3270b57cec5SDimitry Andric operator<=(const sub_match<BiIter>& lhs, 3280b57cec5SDimitry Andric const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs); 3290b57cec5SDimitry Andric 33006c3fb27SDimitry Andrictemplate <class BiIter> // Removed in C++20 3310b57cec5SDimitry Andric bool 3320b57cec5SDimitry Andric operator==(typename iterator_traits<BiIter>::value_type const* lhs, 3330b57cec5SDimitry Andric const sub_match<BiIter>& rhs); 3340b57cec5SDimitry Andric 33506c3fb27SDimitry Andrictemplate <class BiIter> // Removed in C++20 3360b57cec5SDimitry Andric bool 3370b57cec5SDimitry Andric operator!=(typename iterator_traits<BiIter>::value_type const* lhs, 3380b57cec5SDimitry Andric const sub_match<BiIter>& rhs); 3390b57cec5SDimitry Andric 34006c3fb27SDimitry Andrictemplate <class BiIter> // Removed in C++20 3410b57cec5SDimitry Andric bool 3420b57cec5SDimitry Andric operator<(typename iterator_traits<BiIter>::value_type const* lhs, 3430b57cec5SDimitry Andric const sub_match<BiIter>& rhs); 3440b57cec5SDimitry Andric 34506c3fb27SDimitry Andrictemplate <class BiIter> // Removed in C++20 3460b57cec5SDimitry Andric bool 3470b57cec5SDimitry Andric operator>(typename iterator_traits<BiIter>::value_type const* lhs, 3480b57cec5SDimitry Andric const sub_match<BiIter>& rhs); 3490b57cec5SDimitry Andric 35006c3fb27SDimitry Andrictemplate <class BiIter> // Removed in C++20 3510b57cec5SDimitry Andric bool 3520b57cec5SDimitry Andric operator>=(typename iterator_traits<BiIter>::value_type const* lhs, 3530b57cec5SDimitry Andric const sub_match<BiIter>& rhs); 3540b57cec5SDimitry Andric 35506c3fb27SDimitry Andrictemplate <class BiIter> // Removed in C++20 3560b57cec5SDimitry Andric bool 3570b57cec5SDimitry Andric operator<=(typename iterator_traits<BiIter>::value_type const* lhs, 3580b57cec5SDimitry Andric const sub_match<BiIter>& rhs); 3590b57cec5SDimitry Andric 3600b57cec5SDimitry Andrictemplate <class BiIter> 3610b57cec5SDimitry Andric bool 3620b57cec5SDimitry Andric operator==(const sub_match<BiIter>& lhs, 3630b57cec5SDimitry Andric typename iterator_traits<BiIter>::value_type const* rhs); 3640b57cec5SDimitry Andric 36506c3fb27SDimitry Andrictemplate <class BiIter> // Since C++20 36606c3fb27SDimitry Andric auto 36706c3fb27SDimitry Andric operator<=>(const sub_match<BiIter>& lhs, 36806c3fb27SDimitry Andric typename iterator_traits<BiIter>::value_type const* rhs); 36906c3fb27SDimitry Andric 37006c3fb27SDimitry Andrictemplate <class BiIter, class ST, class SA> // Removed in C++20 3710b57cec5SDimitry Andric bool 3720b57cec5SDimitry Andric operator!=(const sub_match<BiIter>& lhs, 3730b57cec5SDimitry Andric typename iterator_traits<BiIter>::value_type const* rhs); 3740b57cec5SDimitry Andric 37506c3fb27SDimitry Andrictemplate <class BiIter> // Removed in C++20 3760b57cec5SDimitry Andric bool 3770b57cec5SDimitry Andric operator<(const sub_match<BiIter>& lhs, 3780b57cec5SDimitry Andric typename iterator_traits<BiIter>::value_type const* rhs); 3790b57cec5SDimitry Andric 38006c3fb27SDimitry Andrictemplate <class BiIter> // Removed in C++20 3810b57cec5SDimitry Andric bool 3820b57cec5SDimitry Andric operator>(const sub_match<BiIter>& lhs, 3830b57cec5SDimitry Andric typename iterator_traits<BiIter>::value_type const* rhs); 3840b57cec5SDimitry Andric 38506c3fb27SDimitry Andrictemplate <class BiIter> // Removed in C++20 3860b57cec5SDimitry Andric bool 3870b57cec5SDimitry Andric operator>=(const sub_match<BiIter>& lhs, 3880b57cec5SDimitry Andric typename iterator_traits<BiIter>::value_type const* rhs); 3890b57cec5SDimitry Andric 39006c3fb27SDimitry Andrictemplate <class BiIter> // Removed in C++20 3910b57cec5SDimitry Andric bool 3920b57cec5SDimitry Andric operator<=(const sub_match<BiIter>& lhs, 3930b57cec5SDimitry Andric typename iterator_traits<BiIter>::value_type const* rhs); 3940b57cec5SDimitry Andric 39506c3fb27SDimitry Andrictemplate <class BiIter> // Removed in C++20 3960b57cec5SDimitry Andric bool 3970b57cec5SDimitry Andric operator==(typename iterator_traits<BiIter>::value_type const& lhs, 3980b57cec5SDimitry Andric const sub_match<BiIter>& rhs); 3990b57cec5SDimitry Andric 40006c3fb27SDimitry Andrictemplate <class BiIter> // Removed in C++20 4010b57cec5SDimitry Andric bool 4020b57cec5SDimitry Andric operator!=(typename iterator_traits<BiIter>::value_type const& lhs, 4030b57cec5SDimitry Andric const sub_match<BiIter>& rhs); 4040b57cec5SDimitry Andric 40506c3fb27SDimitry Andrictemplate <class BiIter> // Removed in C++20 4060b57cec5SDimitry Andric bool 4070b57cec5SDimitry Andric operator<(typename iterator_traits<BiIter>::value_type const& lhs, 4080b57cec5SDimitry Andric const sub_match<BiIter>& rhs); 4090b57cec5SDimitry Andric 41006c3fb27SDimitry Andrictemplate <class BiIter> // Removed in C++20 4110b57cec5SDimitry Andric bool 4120b57cec5SDimitry Andric operator>(typename iterator_traits<BiIter>::value_type const& lhs, 4130b57cec5SDimitry Andric const sub_match<BiIter>& rhs); 4140b57cec5SDimitry Andric 41506c3fb27SDimitry Andrictemplate <class BiIter> // Removed in C++20 4160b57cec5SDimitry Andric bool 4170b57cec5SDimitry Andric operator>=(typename iterator_traits<BiIter>::value_type const& lhs, 4180b57cec5SDimitry Andric const sub_match<BiIter>& rhs); 4190b57cec5SDimitry Andric 42006c3fb27SDimitry Andrictemplate <class BiIter> // Removed in C++20 4210b57cec5SDimitry Andric bool 4220b57cec5SDimitry Andric operator<=(typename iterator_traits<BiIter>::value_type const& lhs, 4230b57cec5SDimitry Andric const sub_match<BiIter>& rhs); 4240b57cec5SDimitry Andric 4250b57cec5SDimitry Andrictemplate <class BiIter> 4260b57cec5SDimitry Andric bool 4270b57cec5SDimitry Andric operator==(const sub_match<BiIter>& lhs, 4280b57cec5SDimitry Andric typename iterator_traits<BiIter>::value_type const& rhs); 4290b57cec5SDimitry Andric 43006c3fb27SDimitry Andrictemplate <class BiIter> // Since C++20 43106c3fb27SDimitry Andric auto 43206c3fb27SDimitry Andric operator<=>(const sub_match<BiIter>& lhs, 43306c3fb27SDimitry Andric typename iterator_traits<BiIter>::value_type const& rhs); 43406c3fb27SDimitry Andric 43506c3fb27SDimitry Andrictemplate <class BiIter> // Removed in C++20 4360b57cec5SDimitry Andric bool 4370b57cec5SDimitry Andric operator!=(const sub_match<BiIter>& lhs, 4380b57cec5SDimitry Andric typename iterator_traits<BiIter>::value_type const& rhs); 4390b57cec5SDimitry Andric 44006c3fb27SDimitry Andrictemplate <class BiIter> // Removed in C++20 4410b57cec5SDimitry Andric bool 4420b57cec5SDimitry Andric operator<(const sub_match<BiIter>& lhs, 4430b57cec5SDimitry Andric typename iterator_traits<BiIter>::value_type const& rhs); 4440b57cec5SDimitry Andric 44506c3fb27SDimitry Andrictemplate <class BiIter> // Removed in C++20 4460b57cec5SDimitry Andric bool 4470b57cec5SDimitry Andric operator>(const sub_match<BiIter>& lhs, 4480b57cec5SDimitry Andric typename iterator_traits<BiIter>::value_type const& rhs); 4490b57cec5SDimitry Andric 45006c3fb27SDimitry Andrictemplate <class BiIter> // Removed in C++20 4510b57cec5SDimitry Andric bool 4520b57cec5SDimitry Andric operator>=(const sub_match<BiIter>& lhs, 4530b57cec5SDimitry Andric typename iterator_traits<BiIter>::value_type const& rhs); 4540b57cec5SDimitry Andric 45506c3fb27SDimitry Andrictemplate <class BiIter> // Removed in C++20 4560b57cec5SDimitry Andric bool 4570b57cec5SDimitry Andric operator<=(const sub_match<BiIter>& lhs, 4580b57cec5SDimitry Andric typename iterator_traits<BiIter>::value_type const& rhs); 4590b57cec5SDimitry Andric 4600b57cec5SDimitry Andrictemplate <class charT, class ST, class BiIter> 4610b57cec5SDimitry Andric basic_ostream<charT, ST>& 4620b57cec5SDimitry Andric operator<<(basic_ostream<charT, ST>& os, const sub_match<BiIter>& m); 4630b57cec5SDimitry Andric 4640b57cec5SDimitry Andrictemplate <class BidirectionalIterator, 4650b57cec5SDimitry Andric class Allocator = allocator<sub_match<BidirectionalIterator>>> 4660b57cec5SDimitry Andricclass match_results 4670b57cec5SDimitry Andric{ 4680b57cec5SDimitry Andricpublic: 4690b57cec5SDimitry Andric typedef sub_match<BidirectionalIterator> value_type; 4700b57cec5SDimitry Andric typedef const value_type& const_reference; 4710b57cec5SDimitry Andric typedef value_type& reference; 4720b57cec5SDimitry Andric typedef /implementation-defined/ const_iterator; 4730b57cec5SDimitry Andric typedef const_iterator iterator; 4740b57cec5SDimitry Andric typedef typename iterator_traits<BidirectionalIterator>::difference_type difference_type; 4750b57cec5SDimitry Andric typedef typename allocator_traits<Allocator>::size_type size_type; 4760b57cec5SDimitry Andric typedef Allocator allocator_type; 4770b57cec5SDimitry Andric typedef typename iterator_traits<BidirectionalIterator>::value_type char_type; 4780b57cec5SDimitry Andric typedef basic_string<char_type> string_type; 4790b57cec5SDimitry Andric 4800b57cec5SDimitry Andric // construct/copy/destroy: 481e8d8bef9SDimitry Andric explicit match_results(const Allocator& a = Allocator()); // before C++20 482e8d8bef9SDimitry Andric match_results() : match_results(Allocator()) {} // C++20 483e8d8bef9SDimitry Andric explicit match_results(const Allocator& a); // C++20 4840b57cec5SDimitry Andric match_results(const match_results& m); 4850b57cec5SDimitry Andric match_results(match_results&& m) noexcept; 4860b57cec5SDimitry Andric match_results& operator=(const match_results& m); 4870b57cec5SDimitry Andric match_results& operator=(match_results&& m); 4880b57cec5SDimitry Andric ~match_results(); 4890b57cec5SDimitry Andric 4900b57cec5SDimitry Andric bool ready() const; 4910b57cec5SDimitry Andric 4920b57cec5SDimitry Andric // size: 4930b57cec5SDimitry Andric size_type size() const; 4940b57cec5SDimitry Andric size_type max_size() const; 4950b57cec5SDimitry Andric bool empty() const; 4960b57cec5SDimitry Andric 4970b57cec5SDimitry Andric // element access: 4980b57cec5SDimitry Andric difference_type length(size_type sub = 0) const; 4990b57cec5SDimitry Andric difference_type position(size_type sub = 0) const; 5000b57cec5SDimitry Andric string_type str(size_type sub = 0) const; 5010b57cec5SDimitry Andric const_reference operator[](size_type n) const; 5020b57cec5SDimitry Andric 5030b57cec5SDimitry Andric const_reference prefix() const; 5040b57cec5SDimitry Andric const_reference suffix() const; 5050b57cec5SDimitry Andric 5060b57cec5SDimitry Andric const_iterator begin() const; 5070b57cec5SDimitry Andric const_iterator end() const; 5080b57cec5SDimitry Andric const_iterator cbegin() const; 5090b57cec5SDimitry Andric const_iterator cend() const; 5100b57cec5SDimitry Andric 5110b57cec5SDimitry Andric // format: 5120b57cec5SDimitry Andric template <class OutputIter> 5130b57cec5SDimitry Andric OutputIter 5140b57cec5SDimitry Andric format(OutputIter out, const char_type* fmt_first, 5150b57cec5SDimitry Andric const char_type* fmt_last, 5160b57cec5SDimitry Andric regex_constants::match_flag_type flags = regex_constants::format_default) const; 5170b57cec5SDimitry Andric template <class OutputIter, class ST, class SA> 5180b57cec5SDimitry Andric OutputIter 5190b57cec5SDimitry Andric format(OutputIter out, const basic_string<char_type, ST, SA>& fmt, 5200b57cec5SDimitry Andric regex_constants::match_flag_type flags = regex_constants::format_default) const; 5210b57cec5SDimitry Andric template <class ST, class SA> 5220b57cec5SDimitry Andric basic_string<char_type, ST, SA> 5230b57cec5SDimitry Andric format(const basic_string<char_type, ST, SA>& fmt, 5240b57cec5SDimitry Andric regex_constants::match_flag_type flags = regex_constants::format_default) const; 5250b57cec5SDimitry Andric string_type 5260b57cec5SDimitry Andric format(const char_type* fmt, 5270b57cec5SDimitry Andric regex_constants::match_flag_type flags = regex_constants::format_default) const; 5280b57cec5SDimitry Andric 5290b57cec5SDimitry Andric // allocator: 5300b57cec5SDimitry Andric allocator_type get_allocator() const; 5310b57cec5SDimitry Andric 5320b57cec5SDimitry Andric // swap: 5330b57cec5SDimitry Andric void swap(match_results& that); 5340b57cec5SDimitry Andric}; 5350b57cec5SDimitry Andric 5360b57cec5SDimitry Andrictypedef match_results<const char*> cmatch; 5370b57cec5SDimitry Andrictypedef match_results<const wchar_t*> wcmatch; 5380b57cec5SDimitry Andrictypedef match_results<string::const_iterator> smatch; 5390b57cec5SDimitry Andrictypedef match_results<wstring::const_iterator> wsmatch; 5400b57cec5SDimitry Andric 5410b57cec5SDimitry Andrictemplate <class BidirectionalIterator, class Allocator> 5420b57cec5SDimitry Andric bool 5430b57cec5SDimitry Andric operator==(const match_results<BidirectionalIterator, Allocator>& m1, 5440b57cec5SDimitry Andric const match_results<BidirectionalIterator, Allocator>& m2); 5450b57cec5SDimitry Andric 54606c3fb27SDimitry Andrictemplate <class BidirectionalIterator, class Allocator> // Removed in C++20 5470b57cec5SDimitry Andric bool 5480b57cec5SDimitry Andric operator!=(const match_results<BidirectionalIterator, Allocator>& m1, 5490b57cec5SDimitry Andric const match_results<BidirectionalIterator, Allocator>& m2); 5500b57cec5SDimitry Andric 5510b57cec5SDimitry Andrictemplate <class BidirectionalIterator, class Allocator> 5520b57cec5SDimitry Andric void 5530b57cec5SDimitry Andric swap(match_results<BidirectionalIterator, Allocator>& m1, 5540b57cec5SDimitry Andric match_results<BidirectionalIterator, Allocator>& m2); 5550b57cec5SDimitry Andric 5560b57cec5SDimitry Andrictemplate <class BidirectionalIterator, class Allocator, class charT, class traits> 5570b57cec5SDimitry Andric bool 5580b57cec5SDimitry Andric regex_match(BidirectionalIterator first, BidirectionalIterator last, 5590b57cec5SDimitry Andric match_results<BidirectionalIterator, Allocator>& m, 5600b57cec5SDimitry Andric const basic_regex<charT, traits>& e, 5610b57cec5SDimitry Andric regex_constants::match_flag_type flags = regex_constants::match_default); 5620b57cec5SDimitry Andric 5630b57cec5SDimitry Andrictemplate <class BidirectionalIterator, class charT, class traits> 5640b57cec5SDimitry Andric bool 5650b57cec5SDimitry Andric regex_match(BidirectionalIterator first, BidirectionalIterator last, 5660b57cec5SDimitry Andric const basic_regex<charT, traits>& e, 5670b57cec5SDimitry Andric regex_constants::match_flag_type flags = regex_constants::match_default); 5680b57cec5SDimitry Andric 5690b57cec5SDimitry Andrictemplate <class charT, class Allocator, class traits> 5700b57cec5SDimitry Andric bool 5710b57cec5SDimitry Andric regex_match(const charT* str, match_results<const charT*, Allocator>& m, 5720b57cec5SDimitry Andric const basic_regex<charT, traits>& e, 5730b57cec5SDimitry Andric regex_constants::match_flag_type flags = regex_constants::match_default); 5740b57cec5SDimitry Andric 5750b57cec5SDimitry Andrictemplate <class ST, class SA, class Allocator, class charT, class traits> 5760b57cec5SDimitry Andric bool 5770b57cec5SDimitry Andric regex_match(const basic_string<charT, ST, SA>& s, 5780b57cec5SDimitry Andric match_results<typename basic_string<charT, ST, SA>::const_iterator, Allocator>& m, 5790b57cec5SDimitry Andric const basic_regex<charT, traits>& e, 5800b57cec5SDimitry Andric regex_constants::match_flag_type flags = regex_constants::match_default); 5810b57cec5SDimitry Andric 5820b57cec5SDimitry Andrictemplate <class ST, class SA, class Allocator, class charT, class traits> 5830b57cec5SDimitry Andric bool 5840b57cec5SDimitry Andric regex_match(const basic_string<charT, ST, SA>&& s, 5850b57cec5SDimitry Andric match_results<typename basic_string<charT, ST, SA>::const_iterator, Allocator>& m, 5860b57cec5SDimitry Andric const basic_regex<charT, traits>& e, 5870b57cec5SDimitry Andric regex_constants::match_flag_type flags = regex_constants::match_default) = delete; // C++14 5880b57cec5SDimitry Andric 5890b57cec5SDimitry Andrictemplate <class charT, class traits> 5900b57cec5SDimitry Andric bool 5910b57cec5SDimitry Andric regex_match(const charT* str, const basic_regex<charT, traits>& e, 5920b57cec5SDimitry Andric regex_constants::match_flag_type flags = regex_constants::match_default); 5930b57cec5SDimitry Andric 5940b57cec5SDimitry Andrictemplate <class ST, class SA, class charT, class traits> 5950b57cec5SDimitry Andric bool 5960b57cec5SDimitry Andric regex_match(const basic_string<charT, ST, SA>& s, 5970b57cec5SDimitry Andric const basic_regex<charT, traits>& e, 5980b57cec5SDimitry Andric regex_constants::match_flag_type flags = regex_constants::match_default); 5990b57cec5SDimitry Andric 6000b57cec5SDimitry Andrictemplate <class BidirectionalIterator, class Allocator, class charT, class traits> 6010b57cec5SDimitry Andric bool 6020b57cec5SDimitry Andric regex_search(BidirectionalIterator first, BidirectionalIterator last, 6030b57cec5SDimitry Andric match_results<BidirectionalIterator, Allocator>& m, 6040b57cec5SDimitry Andric const basic_regex<charT, traits>& e, 6050b57cec5SDimitry Andric regex_constants::match_flag_type flags = regex_constants::match_default); 6060b57cec5SDimitry Andric 6070b57cec5SDimitry Andrictemplate <class BidirectionalIterator, class charT, class traits> 6080b57cec5SDimitry Andric bool 6090b57cec5SDimitry Andric regex_search(BidirectionalIterator first, BidirectionalIterator last, 6100b57cec5SDimitry Andric const basic_regex<charT, traits>& e, 6110b57cec5SDimitry Andric regex_constants::match_flag_type flags = regex_constants::match_default); 6120b57cec5SDimitry Andric 6130b57cec5SDimitry Andrictemplate <class charT, class Allocator, class traits> 6140b57cec5SDimitry Andric bool 6150b57cec5SDimitry Andric regex_search(const charT* str, match_results<const charT*, Allocator>& m, 6160b57cec5SDimitry Andric const basic_regex<charT, traits>& e, 6170b57cec5SDimitry Andric regex_constants::match_flag_type flags = regex_constants::match_default); 6180b57cec5SDimitry Andric 6190b57cec5SDimitry Andrictemplate <class charT, class traits> 6200b57cec5SDimitry Andric bool 6210b57cec5SDimitry Andric regex_search(const charT* str, const basic_regex<charT, traits>& e, 6220b57cec5SDimitry Andric regex_constants::match_flag_type flags = regex_constants::match_default); 6230b57cec5SDimitry Andric 6240b57cec5SDimitry Andrictemplate <class ST, class SA, class charT, class traits> 6250b57cec5SDimitry Andric bool 6260b57cec5SDimitry Andric regex_search(const basic_string<charT, ST, SA>& s, 6270b57cec5SDimitry Andric const basic_regex<charT, traits>& e, 6280b57cec5SDimitry Andric regex_constants::match_flag_type flags = regex_constants::match_default); 6290b57cec5SDimitry Andric 6300b57cec5SDimitry Andrictemplate <class ST, class SA, class Allocator, class charT, class traits> 6310b57cec5SDimitry Andric bool 6320b57cec5SDimitry Andric regex_search(const basic_string<charT, ST, SA>& s, 6330b57cec5SDimitry Andric match_results<typename basic_string<charT, ST, SA>::const_iterator, Allocator>& m, 6340b57cec5SDimitry Andric const basic_regex<charT, traits>& e, 6350b57cec5SDimitry Andric regex_constants::match_flag_type flags = regex_constants::match_default); 6360b57cec5SDimitry Andric 6370b57cec5SDimitry Andrictemplate <class ST, class SA, class Allocator, class charT, class traits> 6380b57cec5SDimitry Andric bool 6390b57cec5SDimitry Andric regex_search(const basic_string<charT, ST, SA>&& s, 6400b57cec5SDimitry Andric match_results<typename basic_string<charT, ST, SA>::const_iterator, Allocator>& m, 6410b57cec5SDimitry Andric const basic_regex<charT, traits>& e, 6420b57cec5SDimitry Andric regex_constants::match_flag_type flags = regex_constants::match_default) = delete; // C++14 6430b57cec5SDimitry Andric 6440b57cec5SDimitry Andrictemplate <class OutputIterator, class BidirectionalIterator, 6450b57cec5SDimitry Andric class traits, class charT, class ST, class SA> 6460b57cec5SDimitry Andric OutputIterator 6470b57cec5SDimitry Andric regex_replace(OutputIterator out, 6480b57cec5SDimitry Andric BidirectionalIterator first, BidirectionalIterator last, 6490b57cec5SDimitry Andric const basic_regex<charT, traits>& e, 6500b57cec5SDimitry Andric const basic_string<charT, ST, SA>& fmt, 6510b57cec5SDimitry Andric regex_constants::match_flag_type flags = regex_constants::match_default); 6520b57cec5SDimitry Andric 6530b57cec5SDimitry Andrictemplate <class OutputIterator, class BidirectionalIterator, 6540b57cec5SDimitry Andric class traits, class charT> 6550b57cec5SDimitry Andric OutputIterator 6560b57cec5SDimitry Andric regex_replace(OutputIterator out, 6570b57cec5SDimitry Andric BidirectionalIterator first, BidirectionalIterator last, 6580b57cec5SDimitry Andric const basic_regex<charT, traits>& e, const charT* fmt, 6590b57cec5SDimitry Andric regex_constants::match_flag_type flags = regex_constants::match_default); 6600b57cec5SDimitry Andric 6615ffd83dbSDimitry Andrictemplate <class traits, class charT, class ST, class SA, class FST, class FSA> 6620b57cec5SDimitry Andric basic_string<charT, ST, SA> 6630b57cec5SDimitry Andric regex_replace(const basic_string<charT, ST, SA>& s, 6640b57cec5SDimitry Andric const basic_regex<charT, traits>& e, 6650b57cec5SDimitry Andric const basic_string<charT, FST, FSA>& fmt, 6660b57cec5SDimitry Andric regex_constants::match_flag_type flags = regex_constants::match_default); 6670b57cec5SDimitry Andric 6680b57cec5SDimitry Andrictemplate <class traits, class charT, class ST, class SA> 6690b57cec5SDimitry Andric basic_string<charT, ST, SA> 6700b57cec5SDimitry Andric regex_replace(const basic_string<charT, ST, SA>& s, 6710b57cec5SDimitry Andric const basic_regex<charT, traits>& e, const charT* fmt, 6720b57cec5SDimitry Andric regex_constants::match_flag_type flags = regex_constants::match_default); 6730b57cec5SDimitry Andric 6740b57cec5SDimitry Andrictemplate <class traits, class charT, class ST, class SA> 6750b57cec5SDimitry Andric basic_string<charT> 6760b57cec5SDimitry Andric regex_replace(const charT* s, 6770b57cec5SDimitry Andric const basic_regex<charT, traits>& e, 6780b57cec5SDimitry Andric const basic_string<charT, ST, SA>& fmt, 6790b57cec5SDimitry Andric regex_constants::match_flag_type flags = regex_constants::match_default); 6800b57cec5SDimitry Andric 6810b57cec5SDimitry Andrictemplate <class traits, class charT> 6820b57cec5SDimitry Andric basic_string<charT> 6830b57cec5SDimitry Andric regex_replace(const charT* s, 6840b57cec5SDimitry Andric const basic_regex<charT, traits>& e, 6850b57cec5SDimitry Andric const charT* fmt, 6860b57cec5SDimitry Andric regex_constants::match_flag_type flags = regex_constants::match_default); 6870b57cec5SDimitry Andric 6880b57cec5SDimitry Andrictemplate <class BidirectionalIterator, 6890b57cec5SDimitry Andric class charT = typename iterator_traits< BidirectionalIterator>::value_type, 6900b57cec5SDimitry Andric class traits = regex_traits<charT>> 6910b57cec5SDimitry Andricclass regex_iterator 6920b57cec5SDimitry Andric{ 6930b57cec5SDimitry Andricpublic: 6940b57cec5SDimitry Andric typedef basic_regex<charT, traits> regex_type; 6950b57cec5SDimitry Andric typedef match_results<BidirectionalIterator> value_type; 6960b57cec5SDimitry Andric typedef ptrdiff_t difference_type; 6970b57cec5SDimitry Andric typedef const value_type* pointer; 6980b57cec5SDimitry Andric typedef const value_type& reference; 6990b57cec5SDimitry Andric typedef forward_iterator_tag iterator_category; 700*5f757f3fSDimitry Andric typedef input_iterator_tag iterator_concept; // since C++20 7010b57cec5SDimitry Andric 7020b57cec5SDimitry Andric regex_iterator(); 7030b57cec5SDimitry Andric regex_iterator(BidirectionalIterator a, BidirectionalIterator b, 7040b57cec5SDimitry Andric const regex_type& re, 7050b57cec5SDimitry Andric regex_constants::match_flag_type m = regex_constants::match_default); 7065ffd83dbSDimitry Andric regex_iterator(BidirectionalIterator a, BidirectionalIterator b, 7075ffd83dbSDimitry Andric const regex_type&& re, 7085ffd83dbSDimitry Andric regex_constants::match_flag_type m 7090b57cec5SDimitry Andric = regex_constants::match_default) = delete; // C++14 7100b57cec5SDimitry Andric regex_iterator(const regex_iterator&); 7110b57cec5SDimitry Andric regex_iterator& operator=(const regex_iterator&); 7120b57cec5SDimitry Andric 7130b57cec5SDimitry Andric bool operator==(const regex_iterator&) const; 71406c3fb27SDimitry Andric bool operator==(default_sentinel_t) const { return *this == regex_iterator(); } // since C++20 71506c3fb27SDimitry Andric bool operator!=(const regex_iterator&) const; // Removed in C++20 7160b57cec5SDimitry Andric 7170b57cec5SDimitry Andric const value_type& operator*() const; 7180b57cec5SDimitry Andric const value_type* operator->() const; 7190b57cec5SDimitry Andric 7200b57cec5SDimitry Andric regex_iterator& operator++(); 7210b57cec5SDimitry Andric regex_iterator operator++(int); 7220b57cec5SDimitry Andric}; 7230b57cec5SDimitry Andric 7240b57cec5SDimitry Andrictypedef regex_iterator<const char*> cregex_iterator; 7250b57cec5SDimitry Andrictypedef regex_iterator<const wchar_t*> wcregex_iterator; 7260b57cec5SDimitry Andrictypedef regex_iterator<string::const_iterator> sregex_iterator; 7270b57cec5SDimitry Andrictypedef regex_iterator<wstring::const_iterator> wsregex_iterator; 7280b57cec5SDimitry Andric 7290b57cec5SDimitry Andrictemplate <class BidirectionalIterator, 7300b57cec5SDimitry Andric class charT = typename iterator_traits<BidirectionalIterator>::value_type, 7310b57cec5SDimitry Andric class traits = regex_traits<charT>> 7320b57cec5SDimitry Andricclass regex_token_iterator 7330b57cec5SDimitry Andric{ 7340b57cec5SDimitry Andricpublic: 7350b57cec5SDimitry Andric typedef basic_regex<charT, traits> regex_type; 7360b57cec5SDimitry Andric typedef sub_match<BidirectionalIterator> value_type; 7370b57cec5SDimitry Andric typedef ptrdiff_t difference_type; 7380b57cec5SDimitry Andric typedef const value_type* pointer; 7390b57cec5SDimitry Andric typedef const value_type& reference; 7400b57cec5SDimitry Andric typedef forward_iterator_tag iterator_category; 741*5f757f3fSDimitry Andric typedef input_iterator_tag iterator_concept; // since C++20 7420b57cec5SDimitry Andric 7430b57cec5SDimitry Andric regex_token_iterator(); 7440b57cec5SDimitry Andric regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, 7450b57cec5SDimitry Andric const regex_type& re, int submatch = 0, 7460b57cec5SDimitry Andric regex_constants::match_flag_type m = regex_constants::match_default); 7470b57cec5SDimitry Andric regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, 7480b57cec5SDimitry Andric const regex_type&& re, int submatch = 0, 7490b57cec5SDimitry Andric regex_constants::match_flag_type m = regex_constants::match_default) = delete; // C++14 7500b57cec5SDimitry Andric regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, 7510b57cec5SDimitry Andric const regex_type& re, const vector<int>& submatches, 7520b57cec5SDimitry Andric regex_constants::match_flag_type m = regex_constants::match_default); 7530b57cec5SDimitry Andric regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, 7540b57cec5SDimitry Andric const regex_type&& re, const vector<int>& submatches, 7550b57cec5SDimitry Andric regex_constants::match_flag_type m = regex_constants::match_default) = delete; // C++14 7560b57cec5SDimitry Andric regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, 7570b57cec5SDimitry Andric const regex_type& re, initializer_list<int> submatches, 7580b57cec5SDimitry Andric regex_constants::match_flag_type m = regex_constants::match_default); 7590b57cec5SDimitry Andric regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, 7600b57cec5SDimitry Andric const regex_type&& re, initializer_list<int> submatches, 7610b57cec5SDimitry Andric regex_constants::match_flag_type m = regex_constants::match_default) = delete; // C++14 7620b57cec5SDimitry Andric template <size_t N> 7630b57cec5SDimitry Andric regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, 7640b57cec5SDimitry Andric const regex_type& re, const int (&submatches)[N], 7650b57cec5SDimitry Andric regex_constants::match_flag_type m = regex_constants::match_default); 7660b57cec5SDimitry Andric template <size_t N> 7670b57cec5SDimitry Andric regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, 7685ffd83dbSDimitry Andric const regex_type&& re, const int (&submatches)[N], 7695ffd83dbSDimitry Andric regex_constants::match_flag_type m = regex_constants::match_default) = delete; // C++14 7700b57cec5SDimitry Andric regex_token_iterator(const regex_token_iterator&); 7710b57cec5SDimitry Andric regex_token_iterator& operator=(const regex_token_iterator&); 7720b57cec5SDimitry Andric 7730b57cec5SDimitry Andric bool operator==(const regex_token_iterator&) const; 77406c3fb27SDimitry Andric bool operator==(default_sentinel_t) const { return *this == regex_token_iterator(); } // since C++20 77506c3fb27SDimitry Andric bool operator!=(const regex_token_iterator&) const; // Removed in C++20 7760b57cec5SDimitry Andric 7770b57cec5SDimitry Andric const value_type& operator*() const; 7780b57cec5SDimitry Andric const value_type* operator->() const; 7790b57cec5SDimitry Andric 7800b57cec5SDimitry Andric regex_token_iterator& operator++(); 7810b57cec5SDimitry Andric regex_token_iterator operator++(int); 7820b57cec5SDimitry Andric}; 7830b57cec5SDimitry Andric 7840b57cec5SDimitry Andrictypedef regex_token_iterator<const char*> cregex_token_iterator; 7850b57cec5SDimitry Andrictypedef regex_token_iterator<const wchar_t*> wcregex_token_iterator; 7860b57cec5SDimitry Andrictypedef regex_token_iterator<string::const_iterator> sregex_token_iterator; 7870b57cec5SDimitry Andrictypedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator; 7880b57cec5SDimitry Andric 7890b57cec5SDimitry Andric} // std 7900b57cec5SDimitry Andric*/ 7910b57cec5SDimitry Andric 79281ad6265SDimitry Andric#include <__algorithm/find.h> 79381ad6265SDimitry Andric#include <__algorithm/search.h> 79481ad6265SDimitry Andric#include <__assert> // all public C++ headers provide the assertion handler 79506c3fb27SDimitry Andric#include <__availability> 7960b57cec5SDimitry Andric#include <__config> 79781ad6265SDimitry Andric#include <__iterator/back_insert_iterator.h> 79806c3fb27SDimitry Andric#include <__iterator/default_sentinel.h> 799fe6060f1SDimitry Andric#include <__iterator/wrap_iter.h> 8000b57cec5SDimitry Andric#include <__locale> 80106c3fb27SDimitry Andric#include <__memory/shared_ptr.h> 802bdd1243dSDimitry Andric#include <__memory_resource/polymorphic_allocator.h> 80306c3fb27SDimitry Andric#include <__type_traits/is_swappable.h> 80481ad6265SDimitry Andric#include <__utility/move.h> 805bdd1243dSDimitry Andric#include <__utility/pair.h> 80681ad6265SDimitry Andric#include <__utility/swap.h> 80706c3fb27SDimitry Andric#include <__verbose_abort> 8080b57cec5SDimitry Andric#include <deque> 809fe6060f1SDimitry Andric#include <stdexcept> 810fe6060f1SDimitry Andric#include <string> 811fe6060f1SDimitry Andric#include <vector> 8120b57cec5SDimitry Andric#include <version> 8130b57cec5SDimitry Andric 81481ad6265SDimitry Andric// standard-mandated includes 81581ad6265SDimitry Andric 81681ad6265SDimitry Andric// [iterator.range] 81781ad6265SDimitry Andric#include <__iterator/access.h> 81881ad6265SDimitry Andric#include <__iterator/data.h> 81981ad6265SDimitry Andric#include <__iterator/empty.h> 82081ad6265SDimitry Andric#include <__iterator/reverse_access.h> 82181ad6265SDimitry Andric#include <__iterator/size.h> 82281ad6265SDimitry Andric 82381ad6265SDimitry Andric// [re.syn] 82481ad6265SDimitry Andric#include <compare> 82581ad6265SDimitry Andric#include <initializer_list> 82681ad6265SDimitry Andric 8270b57cec5SDimitry Andric#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 8280b57cec5SDimitry Andric# pragma GCC system_header 8290b57cec5SDimitry Andric#endif 8300b57cec5SDimitry Andric 8310b57cec5SDimitry Andric_LIBCPP_PUSH_MACROS 8320b57cec5SDimitry Andric#include <__undef_macros> 8330b57cec5SDimitry Andric 8340b57cec5SDimitry Andric 8350b57cec5SDimitry Andric#define _LIBCPP_REGEX_COMPLEXITY_FACTOR 4096 8360b57cec5SDimitry Andric 8370b57cec5SDimitry Andric_LIBCPP_BEGIN_NAMESPACE_STD 8380b57cec5SDimitry Andric 8390b57cec5SDimitry Andricnamespace regex_constants 8400b57cec5SDimitry Andric{ 8410b57cec5SDimitry Andric 8420b57cec5SDimitry Andric// syntax_option_type 8430b57cec5SDimitry Andric 8440b57cec5SDimitry Andricenum syntax_option_type 8450b57cec5SDimitry Andric{ 8460b57cec5SDimitry Andric icase = 1 << 0, 8470b57cec5SDimitry Andric nosubs = 1 << 1, 8480b57cec5SDimitry Andric optimize = 1 << 2, 8490b57cec5SDimitry Andric collate = 1 << 3, 8500b57cec5SDimitry Andric#ifdef _LIBCPP_ABI_REGEX_CONSTANTS_NONZERO 8510b57cec5SDimitry Andric ECMAScript = 1 << 9, 8520b57cec5SDimitry Andric#else 8530b57cec5SDimitry Andric ECMAScript = 0, 8540b57cec5SDimitry Andric#endif 8550b57cec5SDimitry Andric basic = 1 << 4, 8560b57cec5SDimitry Andric extended = 1 << 5, 8570b57cec5SDimitry Andric awk = 1 << 6, 8580b57cec5SDimitry Andric grep = 1 << 7, 859e8d8bef9SDimitry Andric egrep = 1 << 8, 860e8d8bef9SDimitry Andric // 1 << 9 may be used by ECMAScript 861e8d8bef9SDimitry Andric multiline = 1 << 10 8620b57cec5SDimitry Andric}; 8630b57cec5SDimitry Andric 864bdd1243dSDimitry Andric_LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR 8650b57cec5SDimitry Andricsyntax_option_type __get_grammar(syntax_option_type __g) 8660b57cec5SDimitry Andric{ 8670b57cec5SDimitry Andric#ifdef _LIBCPP_ABI_REGEX_CONSTANTS_NONZERO 8680b57cec5SDimitry Andric return static_cast<syntax_option_type>(__g & 0x3F0); 8690b57cec5SDimitry Andric#else 8700b57cec5SDimitry Andric return static_cast<syntax_option_type>(__g & 0x1F0); 8710b57cec5SDimitry Andric#endif 8720b57cec5SDimitry Andric} 8730b57cec5SDimitry Andric 874*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 8750b57cec5SDimitry Andric_LIBCPP_CONSTEXPR 8760b57cec5SDimitry Andricsyntax_option_type 8770b57cec5SDimitry Andricoperator~(syntax_option_type __x) 8780b57cec5SDimitry Andric{ 8790b57cec5SDimitry Andric return syntax_option_type(~int(__x) & 0x1FF); 8800b57cec5SDimitry Andric} 8810b57cec5SDimitry Andric 882*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 8830b57cec5SDimitry Andric_LIBCPP_CONSTEXPR 8840b57cec5SDimitry Andricsyntax_option_type 8850b57cec5SDimitry Andricoperator&(syntax_option_type __x, syntax_option_type __y) 8860b57cec5SDimitry Andric{ 8870b57cec5SDimitry Andric return syntax_option_type(int(__x) & int(__y)); 8880b57cec5SDimitry Andric} 8890b57cec5SDimitry Andric 890*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 8910b57cec5SDimitry Andric_LIBCPP_CONSTEXPR 8920b57cec5SDimitry Andricsyntax_option_type 8930b57cec5SDimitry Andricoperator|(syntax_option_type __x, syntax_option_type __y) 8940b57cec5SDimitry Andric{ 8950b57cec5SDimitry Andric return syntax_option_type(int(__x) | int(__y)); 8960b57cec5SDimitry Andric} 8970b57cec5SDimitry Andric 898*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 8990b57cec5SDimitry Andric_LIBCPP_CONSTEXPR 9000b57cec5SDimitry Andricsyntax_option_type 9010b57cec5SDimitry Andricoperator^(syntax_option_type __x, syntax_option_type __y) 9020b57cec5SDimitry Andric{ 9030b57cec5SDimitry Andric return syntax_option_type(int(__x) ^ int(__y)); 9040b57cec5SDimitry Andric} 9050b57cec5SDimitry Andric 906*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 9070b57cec5SDimitry Andricsyntax_option_type& 9080b57cec5SDimitry Andricoperator&=(syntax_option_type& __x, syntax_option_type __y) 9090b57cec5SDimitry Andric{ 9100b57cec5SDimitry Andric __x = __x & __y; 9110b57cec5SDimitry Andric return __x; 9120b57cec5SDimitry Andric} 9130b57cec5SDimitry Andric 914*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 9150b57cec5SDimitry Andricsyntax_option_type& 9160b57cec5SDimitry Andricoperator|=(syntax_option_type& __x, syntax_option_type __y) 9170b57cec5SDimitry Andric{ 9180b57cec5SDimitry Andric __x = __x | __y; 9190b57cec5SDimitry Andric return __x; 9200b57cec5SDimitry Andric} 9210b57cec5SDimitry Andric 922*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 9230b57cec5SDimitry Andricsyntax_option_type& 9240b57cec5SDimitry Andricoperator^=(syntax_option_type& __x, syntax_option_type __y) 9250b57cec5SDimitry Andric{ 9260b57cec5SDimitry Andric __x = __x ^ __y; 9270b57cec5SDimitry Andric return __x; 9280b57cec5SDimitry Andric} 9290b57cec5SDimitry Andric 9300b57cec5SDimitry Andric// match_flag_type 9310b57cec5SDimitry Andric 9320b57cec5SDimitry Andricenum match_flag_type 9330b57cec5SDimitry Andric{ 9340b57cec5SDimitry Andric match_default = 0, 9350b57cec5SDimitry Andric match_not_bol = 1 << 0, 9360b57cec5SDimitry Andric match_not_eol = 1 << 1, 9370b57cec5SDimitry Andric match_not_bow = 1 << 2, 9380b57cec5SDimitry Andric match_not_eow = 1 << 3, 9390b57cec5SDimitry Andric match_any = 1 << 4, 9400b57cec5SDimitry Andric match_not_null = 1 << 5, 9410b57cec5SDimitry Andric match_continuous = 1 << 6, 9420b57cec5SDimitry Andric match_prev_avail = 1 << 7, 9430b57cec5SDimitry Andric format_default = 0, 9440b57cec5SDimitry Andric format_sed = 1 << 8, 9450b57cec5SDimitry Andric format_no_copy = 1 << 9, 9460b57cec5SDimitry Andric format_first_only = 1 << 10, 9470b57cec5SDimitry Andric __no_update_pos = 1 << 11, 9480b57cec5SDimitry Andric __full_match = 1 << 12 9490b57cec5SDimitry Andric}; 9500b57cec5SDimitry Andric 951*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 9520b57cec5SDimitry Andric_LIBCPP_CONSTEXPR 9530b57cec5SDimitry Andricmatch_flag_type 9540b57cec5SDimitry Andricoperator~(match_flag_type __x) 9550b57cec5SDimitry Andric{ 9560b57cec5SDimitry Andric return match_flag_type(~int(__x) & 0x0FFF); 9570b57cec5SDimitry Andric} 9580b57cec5SDimitry Andric 959*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 9600b57cec5SDimitry Andric_LIBCPP_CONSTEXPR 9610b57cec5SDimitry Andricmatch_flag_type 9620b57cec5SDimitry Andricoperator&(match_flag_type __x, match_flag_type __y) 9630b57cec5SDimitry Andric{ 9640b57cec5SDimitry Andric return match_flag_type(int(__x) & int(__y)); 9650b57cec5SDimitry Andric} 9660b57cec5SDimitry Andric 967*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 9680b57cec5SDimitry Andric_LIBCPP_CONSTEXPR 9690b57cec5SDimitry Andricmatch_flag_type 9700b57cec5SDimitry Andricoperator|(match_flag_type __x, match_flag_type __y) 9710b57cec5SDimitry Andric{ 9720b57cec5SDimitry Andric return match_flag_type(int(__x) | int(__y)); 9730b57cec5SDimitry Andric} 9740b57cec5SDimitry Andric 975*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 9760b57cec5SDimitry Andric_LIBCPP_CONSTEXPR 9770b57cec5SDimitry Andricmatch_flag_type 9780b57cec5SDimitry Andricoperator^(match_flag_type __x, match_flag_type __y) 9790b57cec5SDimitry Andric{ 9800b57cec5SDimitry Andric return match_flag_type(int(__x) ^ int(__y)); 9810b57cec5SDimitry Andric} 9820b57cec5SDimitry Andric 983*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 9840b57cec5SDimitry Andricmatch_flag_type& 9850b57cec5SDimitry Andricoperator&=(match_flag_type& __x, match_flag_type __y) 9860b57cec5SDimitry Andric{ 9870b57cec5SDimitry Andric __x = __x & __y; 9880b57cec5SDimitry Andric return __x; 9890b57cec5SDimitry Andric} 9900b57cec5SDimitry Andric 991*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 9920b57cec5SDimitry Andricmatch_flag_type& 9930b57cec5SDimitry Andricoperator|=(match_flag_type& __x, match_flag_type __y) 9940b57cec5SDimitry Andric{ 9950b57cec5SDimitry Andric __x = __x | __y; 9960b57cec5SDimitry Andric return __x; 9970b57cec5SDimitry Andric} 9980b57cec5SDimitry Andric 999*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 10000b57cec5SDimitry Andricmatch_flag_type& 10010b57cec5SDimitry Andricoperator^=(match_flag_type& __x, match_flag_type __y) 10020b57cec5SDimitry Andric{ 10030b57cec5SDimitry Andric __x = __x ^ __y; 10040b57cec5SDimitry Andric return __x; 10050b57cec5SDimitry Andric} 10060b57cec5SDimitry Andric 10070b57cec5SDimitry Andricenum error_type 10080b57cec5SDimitry Andric{ 10090b57cec5SDimitry Andric error_collate = 1, 10100b57cec5SDimitry Andric error_ctype, 10110b57cec5SDimitry Andric error_escape, 10120b57cec5SDimitry Andric error_backref, 10130b57cec5SDimitry Andric error_brack, 10140b57cec5SDimitry Andric error_paren, 10150b57cec5SDimitry Andric error_brace, 10160b57cec5SDimitry Andric error_badbrace, 10170b57cec5SDimitry Andric error_range, 10180b57cec5SDimitry Andric error_space, 10190b57cec5SDimitry Andric error_badrepeat, 10200b57cec5SDimitry Andric error_complexity, 10210b57cec5SDimitry Andric error_stack, 10220b57cec5SDimitry Andric __re_err_grammar, 10230b57cec5SDimitry Andric __re_err_empty, 1024480093f4SDimitry Andric __re_err_unknown, 1025480093f4SDimitry Andric __re_err_parse 10260b57cec5SDimitry Andric}; 10270b57cec5SDimitry Andric 10280eae32dcSDimitry Andric} // namespace regex_constants 10290b57cec5SDimitry Andric 103006c3fb27SDimitry Andricclass _LIBCPP_EXPORTED_FROM_ABI regex_error 10310b57cec5SDimitry Andric : public runtime_error 10320b57cec5SDimitry Andric{ 10330b57cec5SDimitry Andric regex_constants::error_type __code_; 10340b57cec5SDimitry Andricpublic: 10350b57cec5SDimitry Andric explicit regex_error(regex_constants::error_type __ecode); 103606c3fb27SDimitry Andric _LIBCPP_HIDE_FROM_ABI regex_error(const regex_error&) _NOEXCEPT = default; 1037bdd1243dSDimitry Andric ~regex_error() _NOEXCEPT override; 1038*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 10390b57cec5SDimitry Andric regex_constants::error_type code() const {return __code_;} 10400b57cec5SDimitry Andric}; 10410b57cec5SDimitry Andric 10420b57cec5SDimitry Andrictemplate <regex_constants::error_type _Ev> 1043*5f757f3fSDimitry Andric_LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI 10440b57cec5SDimitry Andricvoid __throw_regex_error() 10450b57cec5SDimitry Andric{ 104606c3fb27SDimitry Andric#ifndef _LIBCPP_HAS_NO_EXCEPTIONS 10470b57cec5SDimitry Andric throw regex_error(_Ev); 10480b57cec5SDimitry Andric#else 104906c3fb27SDimitry Andric _LIBCPP_VERBOSE_ABORT("regex_error was thrown in -fno-exceptions mode"); 10500b57cec5SDimitry Andric#endif 10510b57cec5SDimitry Andric} 10520b57cec5SDimitry Andric 10530b57cec5SDimitry Andrictemplate <class _CharT> 10540b57cec5SDimitry Andricstruct _LIBCPP_TEMPLATE_VIS regex_traits 10550b57cec5SDimitry Andric{ 10560b57cec5SDimitry Andricpublic: 10570b57cec5SDimitry Andric typedef _CharT char_type; 10580b57cec5SDimitry Andric typedef basic_string<char_type> string_type; 10590b57cec5SDimitry Andric typedef locale locale_type; 1060bdd1243dSDimitry Andric#if defined(__BIONIC__) || defined(_NEWLIB_VERSION) 10615ffd83dbSDimitry Andric // Originally bionic's ctype_base used its own ctype masks because the 10625ffd83dbSDimitry Andric // builtin ctype implementation wasn't in libc++ yet. Bionic's ctype mask 10635ffd83dbSDimitry Andric // was only 8 bits wide and already saturated, so it used a wider type here 10645ffd83dbSDimitry Andric // to make room for __regex_word (then a part of this class rather than 10655ffd83dbSDimitry Andric // ctype_base). Bionic has since moved to the builtin ctype_base 10665ffd83dbSDimitry Andric // implementation, but this was not updated to match. Since then Android has 10675ffd83dbSDimitry Andric // needed to maintain a stable libc++ ABI, and this can't be changed without 10685ffd83dbSDimitry Andric // an ABI break. 1069bdd1243dSDimitry Andric // We also need this workaround for newlib since _NEWLIB_VERSION is not 1070bdd1243dSDimitry Andric // defined yet inside __config, so we can't set the 1071bdd1243dSDimitry Andric // _LIBCPP_PROVIDES_DEFAULT_RUNE_TABLE macro. Additionally, newlib is 1072bdd1243dSDimitry Andric // often used for space constrained environments, so it makes sense not to 1073bdd1243dSDimitry Andric // duplicate the ctype table. 10745ffd83dbSDimitry Andric typedef uint16_t char_class_type; 10755ffd83dbSDimitry Andric#else 10760b57cec5SDimitry Andric typedef ctype_base::mask char_class_type; 10775ffd83dbSDimitry Andric#endif 10780b57cec5SDimitry Andric 10790b57cec5SDimitry Andric static const char_class_type __regex_word = ctype_base::__regex_word; 10800b57cec5SDimitry Andricprivate: 10810b57cec5SDimitry Andric locale __loc_; 10820b57cec5SDimitry Andric const ctype<char_type>* __ct_; 10830b57cec5SDimitry Andric const collate<char_type>* __col_; 10840b57cec5SDimitry Andric 10850b57cec5SDimitry Andricpublic: 10860b57cec5SDimitry Andric regex_traits(); 10870b57cec5SDimitry Andric 1088*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 10890b57cec5SDimitry Andric static size_t length(const char_type* __p) 10900b57cec5SDimitry Andric {return char_traits<char_type>::length(__p);} 1091*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 10920b57cec5SDimitry Andric char_type translate(char_type __c) const {return __c;} 10930b57cec5SDimitry Andric char_type translate_nocase(char_type __c) const; 10940b57cec5SDimitry Andric template <class _ForwardIterator> 10950b57cec5SDimitry Andric string_type 10960b57cec5SDimitry Andric transform(_ForwardIterator __f, _ForwardIterator __l) const; 10970b57cec5SDimitry Andric template <class _ForwardIterator> 1098*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 10990b57cec5SDimitry Andric string_type 11000b57cec5SDimitry Andric transform_primary( _ForwardIterator __f, _ForwardIterator __l) const 11010b57cec5SDimitry Andric {return __transform_primary(__f, __l, char_type());} 11020b57cec5SDimitry Andric template <class _ForwardIterator> 1103*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 11040b57cec5SDimitry Andric string_type 11050b57cec5SDimitry Andric lookup_collatename(_ForwardIterator __f, _ForwardIterator __l) const 11060b57cec5SDimitry Andric {return __lookup_collatename(__f, __l, char_type());} 11070b57cec5SDimitry Andric template <class _ForwardIterator> 1108*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 11090b57cec5SDimitry Andric char_class_type 11100b57cec5SDimitry Andric lookup_classname(_ForwardIterator __f, _ForwardIterator __l, 11110b57cec5SDimitry Andric bool __icase = false) const 11120b57cec5SDimitry Andric {return __lookup_classname(__f, __l, __icase, char_type());} 11130b57cec5SDimitry Andric bool isctype(char_type __c, char_class_type __m) const; 1114*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 11150b57cec5SDimitry Andric int value(char_type __ch, int __radix) const 11160b57cec5SDimitry Andric {return __regex_traits_value(__ch, __radix);} 11170b57cec5SDimitry Andric locale_type imbue(locale_type __l); 1118*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 11190b57cec5SDimitry Andric locale_type getloc()const {return __loc_;} 11200b57cec5SDimitry Andric 11210b57cec5SDimitry Andricprivate: 11220b57cec5SDimitry Andric void __init(); 11230b57cec5SDimitry Andric 11240b57cec5SDimitry Andric template <class _ForwardIterator> 11250b57cec5SDimitry Andric string_type 11260b57cec5SDimitry Andric __transform_primary(_ForwardIterator __f, _ForwardIterator __l, char) const; 1127349cc55cSDimitry Andric#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 11280b57cec5SDimitry Andric template <class _ForwardIterator> 11290b57cec5SDimitry Andric string_type 11300b57cec5SDimitry Andric __transform_primary(_ForwardIterator __f, _ForwardIterator __l, wchar_t) const; 1131349cc55cSDimitry Andric#endif 11320b57cec5SDimitry Andric template <class _ForwardIterator> 11330b57cec5SDimitry Andric string_type 11340b57cec5SDimitry Andric __lookup_collatename(_ForwardIterator __f, _ForwardIterator __l, char) const; 1135349cc55cSDimitry Andric#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 11360b57cec5SDimitry Andric template <class _ForwardIterator> 11370b57cec5SDimitry Andric string_type 11380b57cec5SDimitry Andric __lookup_collatename(_ForwardIterator __f, _ForwardIterator __l, wchar_t) const; 1139349cc55cSDimitry Andric#endif 11400b57cec5SDimitry Andric template <class _ForwardIterator> 11410b57cec5SDimitry Andric char_class_type 11420b57cec5SDimitry Andric __lookup_classname(_ForwardIterator __f, _ForwardIterator __l, 11430b57cec5SDimitry Andric bool __icase, char) const; 1144349cc55cSDimitry Andric#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 11450b57cec5SDimitry Andric template <class _ForwardIterator> 11460b57cec5SDimitry Andric char_class_type 11470b57cec5SDimitry Andric __lookup_classname(_ForwardIterator __f, _ForwardIterator __l, 11480b57cec5SDimitry Andric bool __icase, wchar_t) const; 1149349cc55cSDimitry Andric#endif 11500b57cec5SDimitry Andric 11510b57cec5SDimitry Andric static int __regex_traits_value(unsigned char __ch, int __radix); 1152*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 11530b57cec5SDimitry Andric int __regex_traits_value(char __ch, int __radix) const 11540b57cec5SDimitry Andric {return __regex_traits_value(static_cast<unsigned char>(__ch), __radix);} 1155349cc55cSDimitry Andric#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 1156*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 11570b57cec5SDimitry Andric int __regex_traits_value(wchar_t __ch, int __radix) const; 1158349cc55cSDimitry Andric#endif 11590b57cec5SDimitry Andric}; 11600b57cec5SDimitry Andric 11610b57cec5SDimitry Andrictemplate <class _CharT> 11620b57cec5SDimitry Andricconst typename regex_traits<_CharT>::char_class_type 11630b57cec5SDimitry Andricregex_traits<_CharT>::__regex_word; 11640b57cec5SDimitry Andric 11650b57cec5SDimitry Andrictemplate <class _CharT> 11660b57cec5SDimitry Andricregex_traits<_CharT>::regex_traits() 11670b57cec5SDimitry Andric{ 11680b57cec5SDimitry Andric __init(); 11690b57cec5SDimitry Andric} 11700b57cec5SDimitry Andric 11710b57cec5SDimitry Andrictemplate <class _CharT> 11720b57cec5SDimitry Andrictypename regex_traits<_CharT>::char_type 11730b57cec5SDimitry Andricregex_traits<_CharT>::translate_nocase(char_type __c) const 11740b57cec5SDimitry Andric{ 11750b57cec5SDimitry Andric return __ct_->tolower(__c); 11760b57cec5SDimitry Andric} 11770b57cec5SDimitry Andric 11780b57cec5SDimitry Andrictemplate <class _CharT> 11790b57cec5SDimitry Andrictemplate <class _ForwardIterator> 11800b57cec5SDimitry Andrictypename regex_traits<_CharT>::string_type 11810b57cec5SDimitry Andricregex_traits<_CharT>::transform(_ForwardIterator __f, _ForwardIterator __l) const 11820b57cec5SDimitry Andric{ 11830b57cec5SDimitry Andric string_type __s(__f, __l); 11840b57cec5SDimitry Andric return __col_->transform(__s.data(), __s.data() + __s.size()); 11850b57cec5SDimitry Andric} 11860b57cec5SDimitry Andric 11870b57cec5SDimitry Andrictemplate <class _CharT> 11880b57cec5SDimitry Andricvoid 11890b57cec5SDimitry Andricregex_traits<_CharT>::__init() 11900b57cec5SDimitry Andric{ 1191bdd1243dSDimitry Andric __ct_ = &std::use_facet<ctype<char_type> >(__loc_); 1192bdd1243dSDimitry Andric __col_ = &std::use_facet<collate<char_type> >(__loc_); 11930b57cec5SDimitry Andric} 11940b57cec5SDimitry Andric 11950b57cec5SDimitry Andrictemplate <class _CharT> 11960b57cec5SDimitry Andrictypename regex_traits<_CharT>::locale_type 11970b57cec5SDimitry Andricregex_traits<_CharT>::imbue(locale_type __l) 11980b57cec5SDimitry Andric{ 11990b57cec5SDimitry Andric locale __r = __loc_; 12000b57cec5SDimitry Andric __loc_ = __l; 12010b57cec5SDimitry Andric __init(); 12020b57cec5SDimitry Andric return __r; 12030b57cec5SDimitry Andric} 12040b57cec5SDimitry Andric 12050b57cec5SDimitry Andric// transform_primary is very FreeBSD-specific 12060b57cec5SDimitry Andric 12070b57cec5SDimitry Andrictemplate <class _CharT> 12080b57cec5SDimitry Andrictemplate <class _ForwardIterator> 12090b57cec5SDimitry Andrictypename regex_traits<_CharT>::string_type 12100b57cec5SDimitry Andricregex_traits<_CharT>::__transform_primary(_ForwardIterator __f, 12110b57cec5SDimitry Andric _ForwardIterator __l, char) const 12120b57cec5SDimitry Andric{ 12130b57cec5SDimitry Andric const string_type __s(__f, __l); 12140b57cec5SDimitry Andric string_type __d = __col_->transform(__s.data(), __s.data() + __s.size()); 12150b57cec5SDimitry Andric switch (__d.size()) 12160b57cec5SDimitry Andric { 12170b57cec5SDimitry Andric case 1: 12180b57cec5SDimitry Andric break; 12190b57cec5SDimitry Andric case 12: 12200b57cec5SDimitry Andric __d[11] = __d[3]; 12210b57cec5SDimitry Andric break; 12220b57cec5SDimitry Andric default: 12230b57cec5SDimitry Andric __d.clear(); 12240b57cec5SDimitry Andric break; 12250b57cec5SDimitry Andric } 12260b57cec5SDimitry Andric return __d; 12270b57cec5SDimitry Andric} 12280b57cec5SDimitry Andric 1229349cc55cSDimitry Andric#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 12300b57cec5SDimitry Andrictemplate <class _CharT> 12310b57cec5SDimitry Andrictemplate <class _ForwardIterator> 12320b57cec5SDimitry Andrictypename regex_traits<_CharT>::string_type 12330b57cec5SDimitry Andricregex_traits<_CharT>::__transform_primary(_ForwardIterator __f, 12340b57cec5SDimitry Andric _ForwardIterator __l, wchar_t) const 12350b57cec5SDimitry Andric{ 12360b57cec5SDimitry Andric const string_type __s(__f, __l); 12370b57cec5SDimitry Andric string_type __d = __col_->transform(__s.data(), __s.data() + __s.size()); 12380b57cec5SDimitry Andric switch (__d.size()) 12390b57cec5SDimitry Andric { 12400b57cec5SDimitry Andric case 1: 12410b57cec5SDimitry Andric break; 12420b57cec5SDimitry Andric case 3: 12430b57cec5SDimitry Andric __d[2] = __d[0]; 12440b57cec5SDimitry Andric break; 12450b57cec5SDimitry Andric default: 12460b57cec5SDimitry Andric __d.clear(); 12470b57cec5SDimitry Andric break; 12480b57cec5SDimitry Andric } 12490b57cec5SDimitry Andric return __d; 12500b57cec5SDimitry Andric} 1251349cc55cSDimitry Andric#endif 12520b57cec5SDimitry Andric 12530b57cec5SDimitry Andric// lookup_collatename is very FreeBSD-specific 12540b57cec5SDimitry Andric 125506c3fb27SDimitry Andric_LIBCPP_EXPORTED_FROM_ABI string __get_collation_name(const char* __s); 12560b57cec5SDimitry Andric 12570b57cec5SDimitry Andrictemplate <class _CharT> 12580b57cec5SDimitry Andrictemplate <class _ForwardIterator> 12590b57cec5SDimitry Andrictypename regex_traits<_CharT>::string_type 12600b57cec5SDimitry Andricregex_traits<_CharT>::__lookup_collatename(_ForwardIterator __f, 12610b57cec5SDimitry Andric _ForwardIterator __l, char) const 12620b57cec5SDimitry Andric{ 12630b57cec5SDimitry Andric string_type __s(__f, __l); 12640b57cec5SDimitry Andric string_type __r; 12650b57cec5SDimitry Andric if (!__s.empty()) 12660b57cec5SDimitry Andric { 1267bdd1243dSDimitry Andric __r = std::__get_collation_name(__s.c_str()); 12680b57cec5SDimitry Andric if (__r.empty() && __s.size() <= 2) 12690b57cec5SDimitry Andric { 12700b57cec5SDimitry Andric __r = __col_->transform(__s.data(), __s.data() + __s.size()); 12710b57cec5SDimitry Andric if (__r.size() == 1 || __r.size() == 12) 12720b57cec5SDimitry Andric __r = __s; 12730b57cec5SDimitry Andric else 12740b57cec5SDimitry Andric __r.clear(); 12750b57cec5SDimitry Andric } 12760b57cec5SDimitry Andric } 12770b57cec5SDimitry Andric return __r; 12780b57cec5SDimitry Andric} 12790b57cec5SDimitry Andric 1280349cc55cSDimitry Andric#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 12810b57cec5SDimitry Andrictemplate <class _CharT> 12820b57cec5SDimitry Andrictemplate <class _ForwardIterator> 12830b57cec5SDimitry Andrictypename regex_traits<_CharT>::string_type 12840b57cec5SDimitry Andricregex_traits<_CharT>::__lookup_collatename(_ForwardIterator __f, 12850b57cec5SDimitry Andric _ForwardIterator __l, wchar_t) const 12860b57cec5SDimitry Andric{ 12870b57cec5SDimitry Andric string_type __s(__f, __l); 12880b57cec5SDimitry Andric string __n; 12890b57cec5SDimitry Andric __n.reserve(__s.size()); 12900b57cec5SDimitry Andric for (typename string_type::const_iterator __i = __s.begin(), __e = __s.end(); 12910b57cec5SDimitry Andric __i != __e; ++__i) 12920b57cec5SDimitry Andric { 12930b57cec5SDimitry Andric if (static_cast<unsigned>(*__i) >= 127) 12940b57cec5SDimitry Andric return string_type(); 12950b57cec5SDimitry Andric __n.push_back(char(*__i)); 12960b57cec5SDimitry Andric } 12970b57cec5SDimitry Andric string_type __r; 12980b57cec5SDimitry Andric if (!__s.empty()) 12990b57cec5SDimitry Andric { 13000b57cec5SDimitry Andric __n = __get_collation_name(__n.c_str()); 13010b57cec5SDimitry Andric if (!__n.empty()) 13020b57cec5SDimitry Andric __r.assign(__n.begin(), __n.end()); 13030b57cec5SDimitry Andric else if (__s.size() <= 2) 13040b57cec5SDimitry Andric { 13050b57cec5SDimitry Andric __r = __col_->transform(__s.data(), __s.data() + __s.size()); 13060b57cec5SDimitry Andric if (__r.size() == 1 || __r.size() == 3) 13070b57cec5SDimitry Andric __r = __s; 13080b57cec5SDimitry Andric else 13090b57cec5SDimitry Andric __r.clear(); 13100b57cec5SDimitry Andric } 13110b57cec5SDimitry Andric } 13120b57cec5SDimitry Andric return __r; 13130b57cec5SDimitry Andric} 1314349cc55cSDimitry Andric#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS 13150b57cec5SDimitry Andric 13160b57cec5SDimitry Andric// lookup_classname 13170b57cec5SDimitry Andric 131806c3fb27SDimitry Andricregex_traits<char>::char_class_type _LIBCPP_EXPORTED_FROM_ABI __get_classname(const char* __s, bool __icase); 13190b57cec5SDimitry Andric 13200b57cec5SDimitry Andrictemplate <class _CharT> 13210b57cec5SDimitry Andrictemplate <class _ForwardIterator> 13220b57cec5SDimitry Andrictypename regex_traits<_CharT>::char_class_type 13230b57cec5SDimitry Andricregex_traits<_CharT>::__lookup_classname(_ForwardIterator __f, 13240b57cec5SDimitry Andric _ForwardIterator __l, 13250b57cec5SDimitry Andric bool __icase, char) const 13260b57cec5SDimitry Andric{ 13270b57cec5SDimitry Andric string_type __s(__f, __l); 13280b57cec5SDimitry Andric __ct_->tolower(&__s[0], &__s[0] + __s.size()); 1329bdd1243dSDimitry Andric return std::__get_classname(__s.c_str(), __icase); 13300b57cec5SDimitry Andric} 13310b57cec5SDimitry Andric 1332349cc55cSDimitry Andric#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 13330b57cec5SDimitry Andrictemplate <class _CharT> 13340b57cec5SDimitry Andrictemplate <class _ForwardIterator> 13350b57cec5SDimitry Andrictypename regex_traits<_CharT>::char_class_type 13360b57cec5SDimitry Andricregex_traits<_CharT>::__lookup_classname(_ForwardIterator __f, 13370b57cec5SDimitry Andric _ForwardIterator __l, 13380b57cec5SDimitry Andric bool __icase, wchar_t) const 13390b57cec5SDimitry Andric{ 13400b57cec5SDimitry Andric string_type __s(__f, __l); 13410b57cec5SDimitry Andric __ct_->tolower(&__s[0], &__s[0] + __s.size()); 13420b57cec5SDimitry Andric string __n; 13430b57cec5SDimitry Andric __n.reserve(__s.size()); 13440b57cec5SDimitry Andric for (typename string_type::const_iterator __i = __s.begin(), __e = __s.end(); 13450b57cec5SDimitry Andric __i != __e; ++__i) 13460b57cec5SDimitry Andric { 13470b57cec5SDimitry Andric if (static_cast<unsigned>(*__i) >= 127) 13480b57cec5SDimitry Andric return char_class_type(); 13490b57cec5SDimitry Andric __n.push_back(char(*__i)); 13500b57cec5SDimitry Andric } 13510b57cec5SDimitry Andric return __get_classname(__n.c_str(), __icase); 13520b57cec5SDimitry Andric} 1353349cc55cSDimitry Andric#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS 13540b57cec5SDimitry Andric 13550b57cec5SDimitry Andrictemplate <class _CharT> 13560b57cec5SDimitry Andricbool 13570b57cec5SDimitry Andricregex_traits<_CharT>::isctype(char_type __c, char_class_type __m) const 13580b57cec5SDimitry Andric{ 13590b57cec5SDimitry Andric if (__ct_->is(__m, __c)) 13600b57cec5SDimitry Andric return true; 13610b57cec5SDimitry Andric return (__c == '_' && (__m & __regex_word)); 13620b57cec5SDimitry Andric} 13630b57cec5SDimitry Andric 1364*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 1365753f127fSDimitry Andricbool __is_07(unsigned char __c) 136604eeddc0SDimitry Andric{ 1367753f127fSDimitry Andric return (__c & 0xF8u) == 136804eeddc0SDimitry Andric#if defined(__MVS__) && !defined(__NATIVE_ASCII_F) 136904eeddc0SDimitry Andric 0xF0; 137004eeddc0SDimitry Andric#else 137104eeddc0SDimitry Andric 0x30; 137204eeddc0SDimitry Andric#endif 137304eeddc0SDimitry Andric} 137404eeddc0SDimitry Andric 1375*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 1376753f127fSDimitry Andricbool __is_89(unsigned char __c) 137704eeddc0SDimitry Andric{ 1378753f127fSDimitry Andric return (__c & 0xFEu) == 137904eeddc0SDimitry Andric#if defined(__MVS__) && !defined(__NATIVE_ASCII_F) 138004eeddc0SDimitry Andric 0xF8; 138104eeddc0SDimitry Andric#else 138204eeddc0SDimitry Andric 0x38; 138304eeddc0SDimitry Andric#endif 138404eeddc0SDimitry Andric} 138504eeddc0SDimitry Andric 1386*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 1387753f127fSDimitry Andricunsigned char __to_lower(unsigned char __c) 138804eeddc0SDimitry Andric{ 138904eeddc0SDimitry Andric#if defined(__MVS__) && !defined(__NATIVE_ASCII_F) 1390a4a491e2SDimitry Andric return __c & 0xBF; 139104eeddc0SDimitry Andric#else 1392753f127fSDimitry Andric return __c | 0x20; 139304eeddc0SDimitry Andric#endif 139404eeddc0SDimitry Andric} 139504eeddc0SDimitry Andric 13960b57cec5SDimitry Andrictemplate <class _CharT> 13970b57cec5SDimitry Andricint 13980b57cec5SDimitry Andricregex_traits<_CharT>::__regex_traits_value(unsigned char __ch, int __radix) 13990b57cec5SDimitry Andric{ 140004eeddc0SDimitry Andric if (__is_07(__ch)) // '0' <= __ch && __ch <= '7' 14010b57cec5SDimitry Andric return __ch - '0'; 14020b57cec5SDimitry Andric if (__radix != 8) 14030b57cec5SDimitry Andric { 140404eeddc0SDimitry Andric if (__is_89(__ch)) // '8' <= __ch && __ch <= '9' 14050b57cec5SDimitry Andric return __ch - '0'; 14060b57cec5SDimitry Andric if (__radix == 16) 14070b57cec5SDimitry Andric { 140804eeddc0SDimitry Andric __ch = __to_lower(__ch); // tolower 14090b57cec5SDimitry Andric if ('a' <= __ch && __ch <= 'f') 14100b57cec5SDimitry Andric return __ch - ('a' - 10); 14110b57cec5SDimitry Andric } 14120b57cec5SDimitry Andric } 14130b57cec5SDimitry Andric return -1; 14140b57cec5SDimitry Andric} 14150b57cec5SDimitry Andric 1416349cc55cSDimitry Andric#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 14170b57cec5SDimitry Andrictemplate <class _CharT> 14180b57cec5SDimitry Andricinline 14190b57cec5SDimitry Andricint 14200b57cec5SDimitry Andricregex_traits<_CharT>::__regex_traits_value(wchar_t __ch, int __radix) const 14210b57cec5SDimitry Andric{ 14220b57cec5SDimitry Andric return __regex_traits_value(static_cast<unsigned char>(__ct_->narrow(__ch, char_type())), __radix); 14230b57cec5SDimitry Andric} 1424349cc55cSDimitry Andric#endif 14250b57cec5SDimitry Andric 14260b57cec5SDimitry Andrictemplate <class _CharT> class __node; 14270b57cec5SDimitry Andric 14280b57cec5SDimitry Andrictemplate <class _BidirectionalIterator> class _LIBCPP_TEMPLATE_VIS sub_match; 14290b57cec5SDimitry Andric 14300b57cec5SDimitry Andrictemplate <class _BidirectionalIterator, 14310b57cec5SDimitry Andric class _Allocator = allocator<sub_match<_BidirectionalIterator> > > 14320b57cec5SDimitry Andricclass _LIBCPP_TEMPLATE_VIS match_results; 14330b57cec5SDimitry Andric 14340b57cec5SDimitry Andrictemplate <class _CharT> 14350b57cec5SDimitry Andricstruct __state 14360b57cec5SDimitry Andric{ 14370b57cec5SDimitry Andric enum 14380b57cec5SDimitry Andric { 14390b57cec5SDimitry Andric __end_state = -1000, 14400b57cec5SDimitry Andric __consume_input, // -999 14410b57cec5SDimitry Andric __begin_marked_expr, // -998 14420b57cec5SDimitry Andric __end_marked_expr, // -997 14430b57cec5SDimitry Andric __pop_state, // -996 14440b57cec5SDimitry Andric __accept_and_consume, // -995 14450b57cec5SDimitry Andric __accept_but_not_consume, // -994 14460b57cec5SDimitry Andric __reject, // -993 14470b57cec5SDimitry Andric __split, 14480b57cec5SDimitry Andric __repeat 14490b57cec5SDimitry Andric }; 14500b57cec5SDimitry Andric 14510b57cec5SDimitry Andric int __do_; 14520b57cec5SDimitry Andric const _CharT* __first_; 14530b57cec5SDimitry Andric const _CharT* __current_; 14540b57cec5SDimitry Andric const _CharT* __last_; 14550b57cec5SDimitry Andric vector<sub_match<const _CharT*> > __sub_matches_; 14560b57cec5SDimitry Andric vector<pair<size_t, const _CharT*> > __loop_data_; 14570b57cec5SDimitry Andric const __node<_CharT>* __node_; 14580b57cec5SDimitry Andric regex_constants::match_flag_type __flags_; 14590b57cec5SDimitry Andric bool __at_first_; 14600b57cec5SDimitry Andric 1461*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 14620b57cec5SDimitry Andric __state() 14630b57cec5SDimitry Andric : __do_(0), __first_(nullptr), __current_(nullptr), __last_(nullptr), 1464*5f757f3fSDimitry Andric __node_(nullptr), __flags_(), __at_first_(false) {} 14650b57cec5SDimitry Andric}; 14660b57cec5SDimitry Andric 14670b57cec5SDimitry Andric// __node 14680b57cec5SDimitry Andric 14690b57cec5SDimitry Andrictemplate <class _CharT> 14700b57cec5SDimitry Andricclass __node 14710b57cec5SDimitry Andric{ 14720b57cec5SDimitry Andric __node(const __node&); 14730b57cec5SDimitry Andric __node& operator=(const __node&); 14740b57cec5SDimitry Andricpublic: 1475*5f757f3fSDimitry Andric typedef std::__state<_CharT> __state; 14760b57cec5SDimitry Andric 1477*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 14780b57cec5SDimitry Andric __node() {} 1479bdd1243dSDimitry Andric _LIBCPP_HIDE_FROM_ABI_VIRTUAL 14800b57cec5SDimitry Andric virtual ~__node() {} 14810b57cec5SDimitry Andric 1482bdd1243dSDimitry Andric _LIBCPP_HIDE_FROM_ABI_VIRTUAL 14830b57cec5SDimitry Andric virtual void __exec(__state&) const {} 1484bdd1243dSDimitry Andric _LIBCPP_HIDE_FROM_ABI_VIRTUAL 14850b57cec5SDimitry Andric virtual void __exec_split(bool, __state&) const {} 14860b57cec5SDimitry Andric}; 14870b57cec5SDimitry Andric 14880b57cec5SDimitry Andric// __end_state 14890b57cec5SDimitry Andric 14900b57cec5SDimitry Andrictemplate <class _CharT> 14910b57cec5SDimitry Andricclass __end_state 14920b57cec5SDimitry Andric : public __node<_CharT> 14930b57cec5SDimitry Andric{ 14940b57cec5SDimitry Andricpublic: 1495*5f757f3fSDimitry Andric typedef std::__state<_CharT> __state; 14960b57cec5SDimitry Andric 1497*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 14980b57cec5SDimitry Andric __end_state() {} 14990b57cec5SDimitry Andric 150006c3fb27SDimitry Andric _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const; 15010b57cec5SDimitry Andric}; 15020b57cec5SDimitry Andric 15030b57cec5SDimitry Andrictemplate <class _CharT> 15040b57cec5SDimitry Andricvoid 15050b57cec5SDimitry Andric__end_state<_CharT>::__exec(__state& __s) const 15060b57cec5SDimitry Andric{ 15070b57cec5SDimitry Andric __s.__do_ = __state::__end_state; 15080b57cec5SDimitry Andric} 15090b57cec5SDimitry Andric 15100b57cec5SDimitry Andric// __has_one_state 15110b57cec5SDimitry Andric 15120b57cec5SDimitry Andrictemplate <class _CharT> 15130b57cec5SDimitry Andricclass __has_one_state 15140b57cec5SDimitry Andric : public __node<_CharT> 15150b57cec5SDimitry Andric{ 15160b57cec5SDimitry Andric __node<_CharT>* __first_; 15170b57cec5SDimitry Andric 15180b57cec5SDimitry Andricpublic: 1519*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 15200b57cec5SDimitry Andric explicit __has_one_state(__node<_CharT>* __s) 15210b57cec5SDimitry Andric : __first_(__s) {} 15220b57cec5SDimitry Andric 1523*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 15240b57cec5SDimitry Andric __node<_CharT>* first() const {return __first_;} 1525*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 15260b57cec5SDimitry Andric __node<_CharT>*& first() {return __first_;} 15270b57cec5SDimitry Andric}; 15280b57cec5SDimitry Andric 15290b57cec5SDimitry Andric// __owns_one_state 15300b57cec5SDimitry Andric 15310b57cec5SDimitry Andrictemplate <class _CharT> 15320b57cec5SDimitry Andricclass __owns_one_state 15330b57cec5SDimitry Andric : public __has_one_state<_CharT> 15340b57cec5SDimitry Andric{ 15350b57cec5SDimitry Andric typedef __has_one_state<_CharT> base; 15360b57cec5SDimitry Andric 15370b57cec5SDimitry Andricpublic: 1538*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 15390b57cec5SDimitry Andric explicit __owns_one_state(__node<_CharT>* __s) 15400b57cec5SDimitry Andric : base(__s) {} 15410b57cec5SDimitry Andric 1542bdd1243dSDimitry Andric ~__owns_one_state() override; 15430b57cec5SDimitry Andric}; 15440b57cec5SDimitry Andric 15450b57cec5SDimitry Andrictemplate <class _CharT> 15460b57cec5SDimitry Andric__owns_one_state<_CharT>::~__owns_one_state() 15470b57cec5SDimitry Andric{ 15480b57cec5SDimitry Andric delete this->first(); 15490b57cec5SDimitry Andric} 15500b57cec5SDimitry Andric 15510b57cec5SDimitry Andric// __empty_state 15520b57cec5SDimitry Andric 15530b57cec5SDimitry Andrictemplate <class _CharT> 15540b57cec5SDimitry Andricclass __empty_state 15550b57cec5SDimitry Andric : public __owns_one_state<_CharT> 15560b57cec5SDimitry Andric{ 15570b57cec5SDimitry Andric typedef __owns_one_state<_CharT> base; 15580b57cec5SDimitry Andric 15590b57cec5SDimitry Andricpublic: 1560*5f757f3fSDimitry Andric typedef std::__state<_CharT> __state; 15610b57cec5SDimitry Andric 1562*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 15630b57cec5SDimitry Andric explicit __empty_state(__node<_CharT>* __s) 15640b57cec5SDimitry Andric : base(__s) {} 15650b57cec5SDimitry Andric 156606c3fb27SDimitry Andric _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const; 15670b57cec5SDimitry Andric}; 15680b57cec5SDimitry Andric 15690b57cec5SDimitry Andrictemplate <class _CharT> 15700b57cec5SDimitry Andricvoid 15710b57cec5SDimitry Andric__empty_state<_CharT>::__exec(__state& __s) const 15720b57cec5SDimitry Andric{ 15730b57cec5SDimitry Andric __s.__do_ = __state::__accept_but_not_consume; 15740b57cec5SDimitry Andric __s.__node_ = this->first(); 15750b57cec5SDimitry Andric} 15760b57cec5SDimitry Andric 15770b57cec5SDimitry Andric// __empty_non_own_state 15780b57cec5SDimitry Andric 15790b57cec5SDimitry Andrictemplate <class _CharT> 15800b57cec5SDimitry Andricclass __empty_non_own_state 15810b57cec5SDimitry Andric : public __has_one_state<_CharT> 15820b57cec5SDimitry Andric{ 15830b57cec5SDimitry Andric typedef __has_one_state<_CharT> base; 15840b57cec5SDimitry Andric 15850b57cec5SDimitry Andricpublic: 1586*5f757f3fSDimitry Andric typedef std::__state<_CharT> __state; 15870b57cec5SDimitry Andric 1588*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 15890b57cec5SDimitry Andric explicit __empty_non_own_state(__node<_CharT>* __s) 15900b57cec5SDimitry Andric : base(__s) {} 15910b57cec5SDimitry Andric 159206c3fb27SDimitry Andric _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const; 15930b57cec5SDimitry Andric}; 15940b57cec5SDimitry Andric 15950b57cec5SDimitry Andrictemplate <class _CharT> 15960b57cec5SDimitry Andricvoid 15970b57cec5SDimitry Andric__empty_non_own_state<_CharT>::__exec(__state& __s) const 15980b57cec5SDimitry Andric{ 15990b57cec5SDimitry Andric __s.__do_ = __state::__accept_but_not_consume; 16000b57cec5SDimitry Andric __s.__node_ = this->first(); 16010b57cec5SDimitry Andric} 16020b57cec5SDimitry Andric 16030b57cec5SDimitry Andric// __repeat_one_loop 16040b57cec5SDimitry Andric 16050b57cec5SDimitry Andrictemplate <class _CharT> 16060b57cec5SDimitry Andricclass __repeat_one_loop 16070b57cec5SDimitry Andric : public __has_one_state<_CharT> 16080b57cec5SDimitry Andric{ 16090b57cec5SDimitry Andric typedef __has_one_state<_CharT> base; 16100b57cec5SDimitry Andric 16110b57cec5SDimitry Andricpublic: 1612*5f757f3fSDimitry Andric typedef std::__state<_CharT> __state; 16130b57cec5SDimitry Andric 1614*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 16150b57cec5SDimitry Andric explicit __repeat_one_loop(__node<_CharT>* __s) 16160b57cec5SDimitry Andric : base(__s) {} 16170b57cec5SDimitry Andric 161806c3fb27SDimitry Andric _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const; 16190b57cec5SDimitry Andric}; 16200b57cec5SDimitry Andric 16210b57cec5SDimitry Andrictemplate <class _CharT> 16220b57cec5SDimitry Andricvoid 16230b57cec5SDimitry Andric__repeat_one_loop<_CharT>::__exec(__state& __s) const 16240b57cec5SDimitry Andric{ 16250b57cec5SDimitry Andric __s.__do_ = __state::__repeat; 16260b57cec5SDimitry Andric __s.__node_ = this->first(); 16270b57cec5SDimitry Andric} 16280b57cec5SDimitry Andric 16290b57cec5SDimitry Andric// __owns_two_states 16300b57cec5SDimitry Andric 16310b57cec5SDimitry Andrictemplate <class _CharT> 16320b57cec5SDimitry Andricclass __owns_two_states 16330b57cec5SDimitry Andric : public __owns_one_state<_CharT> 16340b57cec5SDimitry Andric{ 16350b57cec5SDimitry Andric typedef __owns_one_state<_CharT> base; 16360b57cec5SDimitry Andric 16370b57cec5SDimitry Andric base* __second_; 16380b57cec5SDimitry Andric 16390b57cec5SDimitry Andricpublic: 1640*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 16410b57cec5SDimitry Andric explicit __owns_two_states(__node<_CharT>* __s1, base* __s2) 16420b57cec5SDimitry Andric : base(__s1), __second_(__s2) {} 16430b57cec5SDimitry Andric 164406c3fb27SDimitry Andric _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual ~__owns_two_states(); 16450b57cec5SDimitry Andric 1646*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 16470b57cec5SDimitry Andric base* second() const {return __second_;} 1648*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 16490b57cec5SDimitry Andric base*& second() {return __second_;} 16500b57cec5SDimitry Andric}; 16510b57cec5SDimitry Andric 16520b57cec5SDimitry Andrictemplate <class _CharT> 16530b57cec5SDimitry Andric__owns_two_states<_CharT>::~__owns_two_states() 16540b57cec5SDimitry Andric{ 16550b57cec5SDimitry Andric delete __second_; 16560b57cec5SDimitry Andric} 16570b57cec5SDimitry Andric 16580b57cec5SDimitry Andric// __loop 16590b57cec5SDimitry Andric 16600b57cec5SDimitry Andrictemplate <class _CharT> 16610b57cec5SDimitry Andricclass __loop 16620b57cec5SDimitry Andric : public __owns_two_states<_CharT> 16630b57cec5SDimitry Andric{ 16640b57cec5SDimitry Andric typedef __owns_two_states<_CharT> base; 16650b57cec5SDimitry Andric 16660b57cec5SDimitry Andric size_t __min_; 16670b57cec5SDimitry Andric size_t __max_; 16680b57cec5SDimitry Andric unsigned __loop_id_; 16690b57cec5SDimitry Andric unsigned __mexp_begin_; 16700b57cec5SDimitry Andric unsigned __mexp_end_; 16710b57cec5SDimitry Andric bool __greedy_; 16720b57cec5SDimitry Andric 16730b57cec5SDimitry Andricpublic: 1674*5f757f3fSDimitry Andric typedef std::__state<_CharT> __state; 16750b57cec5SDimitry Andric 1676*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 16770b57cec5SDimitry Andric explicit __loop(unsigned __loop_id, 16780b57cec5SDimitry Andric __node<_CharT>* __s1, __owns_one_state<_CharT>* __s2, 16790b57cec5SDimitry Andric unsigned __mexp_begin, unsigned __mexp_end, 16800b57cec5SDimitry Andric bool __greedy = true, 16810b57cec5SDimitry Andric size_t __min = 0, 16820b57cec5SDimitry Andric size_t __max = numeric_limits<size_t>::max()) 16830b57cec5SDimitry Andric : base(__s1, __s2), __min_(__min), __max_(__max), __loop_id_(__loop_id), 16840b57cec5SDimitry Andric __mexp_begin_(__mexp_begin), __mexp_end_(__mexp_end), 16850b57cec5SDimitry Andric __greedy_(__greedy) {} 16860b57cec5SDimitry Andric 168706c3fb27SDimitry Andric _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state& __s) const; 168806c3fb27SDimitry Andric _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec_split(bool __second, __state& __s) const; 16890b57cec5SDimitry Andric 16900b57cec5SDimitry Andricprivate: 1691*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 16920b57cec5SDimitry Andric void __init_repeat(__state& __s) const 16930b57cec5SDimitry Andric { 16940b57cec5SDimitry Andric __s.__loop_data_[__loop_id_].second = __s.__current_; 16950b57cec5SDimitry Andric for (size_t __i = __mexp_begin_-1; __i != __mexp_end_-1; ++__i) 16960b57cec5SDimitry Andric { 16970b57cec5SDimitry Andric __s.__sub_matches_[__i].first = __s.__last_; 16980b57cec5SDimitry Andric __s.__sub_matches_[__i].second = __s.__last_; 16990b57cec5SDimitry Andric __s.__sub_matches_[__i].matched = false; 17000b57cec5SDimitry Andric } 17010b57cec5SDimitry Andric } 17020b57cec5SDimitry Andric}; 17030b57cec5SDimitry Andric 17040b57cec5SDimitry Andrictemplate <class _CharT> 17050b57cec5SDimitry Andricvoid 17060b57cec5SDimitry Andric__loop<_CharT>::__exec(__state& __s) const 17070b57cec5SDimitry Andric{ 17080b57cec5SDimitry Andric if (__s.__do_ == __state::__repeat) 17090b57cec5SDimitry Andric { 17100b57cec5SDimitry Andric bool __do_repeat = ++__s.__loop_data_[__loop_id_].first < __max_; 17110b57cec5SDimitry Andric bool __do_alt = __s.__loop_data_[__loop_id_].first >= __min_; 17120b57cec5SDimitry Andric if (__do_repeat && __do_alt && 17130b57cec5SDimitry Andric __s.__loop_data_[__loop_id_].second == __s.__current_) 17140b57cec5SDimitry Andric __do_repeat = false; 17150b57cec5SDimitry Andric if (__do_repeat && __do_alt) 17160b57cec5SDimitry Andric __s.__do_ = __state::__split; 17170b57cec5SDimitry Andric else if (__do_repeat) 17180b57cec5SDimitry Andric { 17190b57cec5SDimitry Andric __s.__do_ = __state::__accept_but_not_consume; 17200b57cec5SDimitry Andric __s.__node_ = this->first(); 17210b57cec5SDimitry Andric __init_repeat(__s); 17220b57cec5SDimitry Andric } 17230b57cec5SDimitry Andric else 17240b57cec5SDimitry Andric { 17250b57cec5SDimitry Andric __s.__do_ = __state::__accept_but_not_consume; 17260b57cec5SDimitry Andric __s.__node_ = this->second(); 17270b57cec5SDimitry Andric } 17280b57cec5SDimitry Andric } 17290b57cec5SDimitry Andric else 17300b57cec5SDimitry Andric { 17310b57cec5SDimitry Andric __s.__loop_data_[__loop_id_].first = 0; 17320b57cec5SDimitry Andric bool __do_repeat = 0 < __max_; 17330b57cec5SDimitry Andric bool __do_alt = 0 >= __min_; 17340b57cec5SDimitry Andric if (__do_repeat && __do_alt) 17350b57cec5SDimitry Andric __s.__do_ = __state::__split; 17360b57cec5SDimitry Andric else if (__do_repeat) 17370b57cec5SDimitry Andric { 17380b57cec5SDimitry Andric __s.__do_ = __state::__accept_but_not_consume; 17390b57cec5SDimitry Andric __s.__node_ = this->first(); 17400b57cec5SDimitry Andric __init_repeat(__s); 17410b57cec5SDimitry Andric } 17420b57cec5SDimitry Andric else 17430b57cec5SDimitry Andric { 17440b57cec5SDimitry Andric __s.__do_ = __state::__accept_but_not_consume; 17450b57cec5SDimitry Andric __s.__node_ = this->second(); 17460b57cec5SDimitry Andric } 17470b57cec5SDimitry Andric } 17480b57cec5SDimitry Andric} 17490b57cec5SDimitry Andric 17500b57cec5SDimitry Andrictemplate <class _CharT> 17510b57cec5SDimitry Andricvoid 17520b57cec5SDimitry Andric__loop<_CharT>::__exec_split(bool __second, __state& __s) const 17530b57cec5SDimitry Andric{ 17540b57cec5SDimitry Andric __s.__do_ = __state::__accept_but_not_consume; 17550b57cec5SDimitry Andric if (__greedy_ != __second) 17560b57cec5SDimitry Andric { 17570b57cec5SDimitry Andric __s.__node_ = this->first(); 17580b57cec5SDimitry Andric __init_repeat(__s); 17590b57cec5SDimitry Andric } 17600b57cec5SDimitry Andric else 17610b57cec5SDimitry Andric __s.__node_ = this->second(); 17620b57cec5SDimitry Andric} 17630b57cec5SDimitry Andric 17640b57cec5SDimitry Andric// __alternate 17650b57cec5SDimitry Andric 17660b57cec5SDimitry Andrictemplate <class _CharT> 17670b57cec5SDimitry Andricclass __alternate 17680b57cec5SDimitry Andric : public __owns_two_states<_CharT> 17690b57cec5SDimitry Andric{ 17700b57cec5SDimitry Andric typedef __owns_two_states<_CharT> base; 17710b57cec5SDimitry Andric 17720b57cec5SDimitry Andricpublic: 1773*5f757f3fSDimitry Andric typedef std::__state<_CharT> __state; 17740b57cec5SDimitry Andric 1775*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 17760b57cec5SDimitry Andric explicit __alternate(__owns_one_state<_CharT>* __s1, 17770b57cec5SDimitry Andric __owns_one_state<_CharT>* __s2) 17780b57cec5SDimitry Andric : base(__s1, __s2) {} 17790b57cec5SDimitry Andric 178006c3fb27SDimitry Andric _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state& __s) const; 178106c3fb27SDimitry Andric _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec_split(bool __second, __state& __s) const; 17820b57cec5SDimitry Andric}; 17830b57cec5SDimitry Andric 17840b57cec5SDimitry Andrictemplate <class _CharT> 17850b57cec5SDimitry Andricvoid 17860b57cec5SDimitry Andric__alternate<_CharT>::__exec(__state& __s) const 17870b57cec5SDimitry Andric{ 17880b57cec5SDimitry Andric __s.__do_ = __state::__split; 17890b57cec5SDimitry Andric} 17900b57cec5SDimitry Andric 17910b57cec5SDimitry Andrictemplate <class _CharT> 17920b57cec5SDimitry Andricvoid 17930b57cec5SDimitry Andric__alternate<_CharT>::__exec_split(bool __second, __state& __s) const 17940b57cec5SDimitry Andric{ 17950b57cec5SDimitry Andric __s.__do_ = __state::__accept_but_not_consume; 17960b57cec5SDimitry Andric if (__second) 17970b57cec5SDimitry Andric __s.__node_ = this->second(); 17980b57cec5SDimitry Andric else 17990b57cec5SDimitry Andric __s.__node_ = this->first(); 18000b57cec5SDimitry Andric} 18010b57cec5SDimitry Andric 18020b57cec5SDimitry Andric// __begin_marked_subexpression 18030b57cec5SDimitry Andric 18040b57cec5SDimitry Andrictemplate <class _CharT> 18050b57cec5SDimitry Andricclass __begin_marked_subexpression 18060b57cec5SDimitry Andric : public __owns_one_state<_CharT> 18070b57cec5SDimitry Andric{ 18080b57cec5SDimitry Andric typedef __owns_one_state<_CharT> base; 18090b57cec5SDimitry Andric 18100b57cec5SDimitry Andric unsigned __mexp_; 18110b57cec5SDimitry Andricpublic: 1812*5f757f3fSDimitry Andric typedef std::__state<_CharT> __state; 18130b57cec5SDimitry Andric 1814*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 18150b57cec5SDimitry Andric explicit __begin_marked_subexpression(unsigned __mexp, __node<_CharT>* __s) 18160b57cec5SDimitry Andric : base(__s), __mexp_(__mexp) {} 18170b57cec5SDimitry Andric 181806c3fb27SDimitry Andric _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const; 18190b57cec5SDimitry Andric}; 18200b57cec5SDimitry Andric 18210b57cec5SDimitry Andrictemplate <class _CharT> 18220b57cec5SDimitry Andricvoid 18230b57cec5SDimitry Andric__begin_marked_subexpression<_CharT>::__exec(__state& __s) const 18240b57cec5SDimitry Andric{ 18250b57cec5SDimitry Andric __s.__do_ = __state::__accept_but_not_consume; 18260b57cec5SDimitry Andric __s.__sub_matches_[__mexp_-1].first = __s.__current_; 18270b57cec5SDimitry Andric __s.__node_ = this->first(); 18280b57cec5SDimitry Andric} 18290b57cec5SDimitry Andric 18300b57cec5SDimitry Andric// __end_marked_subexpression 18310b57cec5SDimitry Andric 18320b57cec5SDimitry Andrictemplate <class _CharT> 18330b57cec5SDimitry Andricclass __end_marked_subexpression 18340b57cec5SDimitry Andric : public __owns_one_state<_CharT> 18350b57cec5SDimitry Andric{ 18360b57cec5SDimitry Andric typedef __owns_one_state<_CharT> base; 18370b57cec5SDimitry Andric 18380b57cec5SDimitry Andric unsigned __mexp_; 18390b57cec5SDimitry Andricpublic: 1840*5f757f3fSDimitry Andric typedef std::__state<_CharT> __state; 18410b57cec5SDimitry Andric 1842*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 18430b57cec5SDimitry Andric explicit __end_marked_subexpression(unsigned __mexp, __node<_CharT>* __s) 18440b57cec5SDimitry Andric : base(__s), __mexp_(__mexp) {} 18450b57cec5SDimitry Andric 184606c3fb27SDimitry Andric _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const; 18470b57cec5SDimitry Andric}; 18480b57cec5SDimitry Andric 18490b57cec5SDimitry Andrictemplate <class _CharT> 18500b57cec5SDimitry Andricvoid 18510b57cec5SDimitry Andric__end_marked_subexpression<_CharT>::__exec(__state& __s) const 18520b57cec5SDimitry Andric{ 18530b57cec5SDimitry Andric __s.__do_ = __state::__accept_but_not_consume; 18540b57cec5SDimitry Andric __s.__sub_matches_[__mexp_-1].second = __s.__current_; 18550b57cec5SDimitry Andric __s.__sub_matches_[__mexp_-1].matched = true; 18560b57cec5SDimitry Andric __s.__node_ = this->first(); 18570b57cec5SDimitry Andric} 18580b57cec5SDimitry Andric 18590b57cec5SDimitry Andric// __back_ref 18600b57cec5SDimitry Andric 18610b57cec5SDimitry Andrictemplate <class _CharT> 18620b57cec5SDimitry Andricclass __back_ref 18630b57cec5SDimitry Andric : public __owns_one_state<_CharT> 18640b57cec5SDimitry Andric{ 18650b57cec5SDimitry Andric typedef __owns_one_state<_CharT> base; 18660b57cec5SDimitry Andric 18670b57cec5SDimitry Andric unsigned __mexp_; 18680b57cec5SDimitry Andricpublic: 1869*5f757f3fSDimitry Andric typedef std::__state<_CharT> __state; 18700b57cec5SDimitry Andric 1871*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 18720b57cec5SDimitry Andric explicit __back_ref(unsigned __mexp, __node<_CharT>* __s) 18730b57cec5SDimitry Andric : base(__s), __mexp_(__mexp) {} 18740b57cec5SDimitry Andric 187506c3fb27SDimitry Andric _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const; 18760b57cec5SDimitry Andric}; 18770b57cec5SDimitry Andric 18780b57cec5SDimitry Andrictemplate <class _CharT> 18790b57cec5SDimitry Andricvoid 18800b57cec5SDimitry Andric__back_ref<_CharT>::__exec(__state& __s) const 18810b57cec5SDimitry Andric{ 18820b57cec5SDimitry Andric if (__mexp_ > __s.__sub_matches_.size()) 18830b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_backref>(); 18840b57cec5SDimitry Andric sub_match<const _CharT*>& __sm = __s.__sub_matches_[__mexp_-1]; 18850b57cec5SDimitry Andric if (__sm.matched) 18860b57cec5SDimitry Andric { 18870b57cec5SDimitry Andric ptrdiff_t __len = __sm.second - __sm.first; 18880b57cec5SDimitry Andric if (__s.__last_ - __s.__current_ >= __len && 1889*5f757f3fSDimitry Andric std::equal(__sm.first, __sm.second, __s.__current_)) 18900b57cec5SDimitry Andric { 18910b57cec5SDimitry Andric __s.__do_ = __state::__accept_but_not_consume; 18920b57cec5SDimitry Andric __s.__current_ += __len; 18930b57cec5SDimitry Andric __s.__node_ = this->first(); 18940b57cec5SDimitry Andric } 18950b57cec5SDimitry Andric else 18960b57cec5SDimitry Andric { 18970b57cec5SDimitry Andric __s.__do_ = __state::__reject; 18980b57cec5SDimitry Andric __s.__node_ = nullptr; 18990b57cec5SDimitry Andric } 19000b57cec5SDimitry Andric } 19010b57cec5SDimitry Andric else 19020b57cec5SDimitry Andric { 19030b57cec5SDimitry Andric __s.__do_ = __state::__reject; 19040b57cec5SDimitry Andric __s.__node_ = nullptr; 19050b57cec5SDimitry Andric } 19060b57cec5SDimitry Andric} 19070b57cec5SDimitry Andric 19080b57cec5SDimitry Andric// __back_ref_icase 19090b57cec5SDimitry Andric 19100b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 19110b57cec5SDimitry Andricclass __back_ref_icase 19120b57cec5SDimitry Andric : public __owns_one_state<_CharT> 19130b57cec5SDimitry Andric{ 19140b57cec5SDimitry Andric typedef __owns_one_state<_CharT> base; 19150b57cec5SDimitry Andric 19160b57cec5SDimitry Andric _Traits __traits_; 19170b57cec5SDimitry Andric unsigned __mexp_; 19180b57cec5SDimitry Andricpublic: 1919*5f757f3fSDimitry Andric typedef std::__state<_CharT> __state; 19200b57cec5SDimitry Andric 1921*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 19220b57cec5SDimitry Andric explicit __back_ref_icase(const _Traits& __traits, unsigned __mexp, 19230b57cec5SDimitry Andric __node<_CharT>* __s) 19240b57cec5SDimitry Andric : base(__s), __traits_(__traits), __mexp_(__mexp) {} 19250b57cec5SDimitry Andric 192606c3fb27SDimitry Andric _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const; 19270b57cec5SDimitry Andric}; 19280b57cec5SDimitry Andric 19290b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 19300b57cec5SDimitry Andricvoid 19310b57cec5SDimitry Andric__back_ref_icase<_CharT, _Traits>::__exec(__state& __s) const 19320b57cec5SDimitry Andric{ 19330b57cec5SDimitry Andric sub_match<const _CharT*>& __sm = __s.__sub_matches_[__mexp_-1]; 19340b57cec5SDimitry Andric if (__sm.matched) 19350b57cec5SDimitry Andric { 19360b57cec5SDimitry Andric ptrdiff_t __len = __sm.second - __sm.first; 19370b57cec5SDimitry Andric if (__s.__last_ - __s.__current_ >= __len) 19380b57cec5SDimitry Andric { 19390b57cec5SDimitry Andric for (ptrdiff_t __i = 0; __i < __len; ++__i) 19400b57cec5SDimitry Andric { 19410b57cec5SDimitry Andric if (__traits_.translate_nocase(__sm.first[__i]) != 19420b57cec5SDimitry Andric __traits_.translate_nocase(__s.__current_[__i])) 19430b57cec5SDimitry Andric goto __not_equal; 19440b57cec5SDimitry Andric } 19450b57cec5SDimitry Andric __s.__do_ = __state::__accept_but_not_consume; 19460b57cec5SDimitry Andric __s.__current_ += __len; 19470b57cec5SDimitry Andric __s.__node_ = this->first(); 19480b57cec5SDimitry Andric } 19490b57cec5SDimitry Andric else 19500b57cec5SDimitry Andric { 19510b57cec5SDimitry Andric __s.__do_ = __state::__reject; 19520b57cec5SDimitry Andric __s.__node_ = nullptr; 19530b57cec5SDimitry Andric } 19540b57cec5SDimitry Andric } 19550b57cec5SDimitry Andric else 19560b57cec5SDimitry Andric { 19570b57cec5SDimitry Andric__not_equal: 19580b57cec5SDimitry Andric __s.__do_ = __state::__reject; 19590b57cec5SDimitry Andric __s.__node_ = nullptr; 19600b57cec5SDimitry Andric } 19610b57cec5SDimitry Andric} 19620b57cec5SDimitry Andric 19630b57cec5SDimitry Andric// __back_ref_collate 19640b57cec5SDimitry Andric 19650b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 19660b57cec5SDimitry Andricclass __back_ref_collate 19670b57cec5SDimitry Andric : public __owns_one_state<_CharT> 19680b57cec5SDimitry Andric{ 19690b57cec5SDimitry Andric typedef __owns_one_state<_CharT> base; 19700b57cec5SDimitry Andric 19710b57cec5SDimitry Andric _Traits __traits_; 19720b57cec5SDimitry Andric unsigned __mexp_; 19730b57cec5SDimitry Andricpublic: 1974*5f757f3fSDimitry Andric typedef std::__state<_CharT> __state; 19750b57cec5SDimitry Andric 1976*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 19770b57cec5SDimitry Andric explicit __back_ref_collate(const _Traits& __traits, unsigned __mexp, 19780b57cec5SDimitry Andric __node<_CharT>* __s) 19790b57cec5SDimitry Andric : base(__s), __traits_(__traits), __mexp_(__mexp) {} 19800b57cec5SDimitry Andric 198106c3fb27SDimitry Andric _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const; 19820b57cec5SDimitry Andric}; 19830b57cec5SDimitry Andric 19840b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 19850b57cec5SDimitry Andricvoid 19860b57cec5SDimitry Andric__back_ref_collate<_CharT, _Traits>::__exec(__state& __s) const 19870b57cec5SDimitry Andric{ 19880b57cec5SDimitry Andric sub_match<const _CharT*>& __sm = __s.__sub_matches_[__mexp_-1]; 19890b57cec5SDimitry Andric if (__sm.matched) 19900b57cec5SDimitry Andric { 19910b57cec5SDimitry Andric ptrdiff_t __len = __sm.second - __sm.first; 19920b57cec5SDimitry Andric if (__s.__last_ - __s.__current_ >= __len) 19930b57cec5SDimitry Andric { 19940b57cec5SDimitry Andric for (ptrdiff_t __i = 0; __i < __len; ++__i) 19950b57cec5SDimitry Andric { 19960b57cec5SDimitry Andric if (__traits_.translate(__sm.first[__i]) != 19970b57cec5SDimitry Andric __traits_.translate(__s.__current_[__i])) 19980b57cec5SDimitry Andric goto __not_equal; 19990b57cec5SDimitry Andric } 20000b57cec5SDimitry Andric __s.__do_ = __state::__accept_but_not_consume; 20010b57cec5SDimitry Andric __s.__current_ += __len; 20020b57cec5SDimitry Andric __s.__node_ = this->first(); 20030b57cec5SDimitry Andric } 20040b57cec5SDimitry Andric else 20050b57cec5SDimitry Andric { 20060b57cec5SDimitry Andric __s.__do_ = __state::__reject; 20070b57cec5SDimitry Andric __s.__node_ = nullptr; 20080b57cec5SDimitry Andric } 20090b57cec5SDimitry Andric } 20100b57cec5SDimitry Andric else 20110b57cec5SDimitry Andric { 20120b57cec5SDimitry Andric__not_equal: 20130b57cec5SDimitry Andric __s.__do_ = __state::__reject; 20140b57cec5SDimitry Andric __s.__node_ = nullptr; 20150b57cec5SDimitry Andric } 20160b57cec5SDimitry Andric} 20170b57cec5SDimitry Andric 20180b57cec5SDimitry Andric// __word_boundary 20190b57cec5SDimitry Andric 20200b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 20210b57cec5SDimitry Andricclass __word_boundary 20220b57cec5SDimitry Andric : public __owns_one_state<_CharT> 20230b57cec5SDimitry Andric{ 20240b57cec5SDimitry Andric typedef __owns_one_state<_CharT> base; 20250b57cec5SDimitry Andric 20260b57cec5SDimitry Andric _Traits __traits_; 20270b57cec5SDimitry Andric bool __invert_; 20280b57cec5SDimitry Andricpublic: 2029*5f757f3fSDimitry Andric typedef std::__state<_CharT> __state; 20300b57cec5SDimitry Andric 2031*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 20320b57cec5SDimitry Andric explicit __word_boundary(const _Traits& __traits, bool __invert, 20330b57cec5SDimitry Andric __node<_CharT>* __s) 20340b57cec5SDimitry Andric : base(__s), __traits_(__traits), __invert_(__invert) {} 20350b57cec5SDimitry Andric 203606c3fb27SDimitry Andric _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const; 20370b57cec5SDimitry Andric}; 20380b57cec5SDimitry Andric 20390b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 20400b57cec5SDimitry Andricvoid 20410b57cec5SDimitry Andric__word_boundary<_CharT, _Traits>::__exec(__state& __s) const 20420b57cec5SDimitry Andric{ 20430b57cec5SDimitry Andric bool __is_word_b = false; 20440b57cec5SDimitry Andric if (__s.__first_ != __s.__last_) 20450b57cec5SDimitry Andric { 20460b57cec5SDimitry Andric if (__s.__current_ == __s.__last_) 20470b57cec5SDimitry Andric { 20480b57cec5SDimitry Andric if (!(__s.__flags_ & regex_constants::match_not_eow)) 20490b57cec5SDimitry Andric { 20500b57cec5SDimitry Andric _CharT __c = __s.__current_[-1]; 20510b57cec5SDimitry Andric __is_word_b = __c == '_' || 20520b57cec5SDimitry Andric __traits_.isctype(__c, ctype_base::alnum); 20530b57cec5SDimitry Andric } 20540b57cec5SDimitry Andric } 20550b57cec5SDimitry Andric else if (__s.__current_ == __s.__first_ && 20560b57cec5SDimitry Andric !(__s.__flags_ & regex_constants::match_prev_avail)) 20570b57cec5SDimitry Andric { 20580b57cec5SDimitry Andric if (!(__s.__flags_ & regex_constants::match_not_bow)) 20590b57cec5SDimitry Andric { 20600b57cec5SDimitry Andric _CharT __c = *__s.__current_; 20610b57cec5SDimitry Andric __is_word_b = __c == '_' || 20620b57cec5SDimitry Andric __traits_.isctype(__c, ctype_base::alnum); 20630b57cec5SDimitry Andric } 20640b57cec5SDimitry Andric } 20650b57cec5SDimitry Andric else 20660b57cec5SDimitry Andric { 20670b57cec5SDimitry Andric _CharT __c1 = __s.__current_[-1]; 20680b57cec5SDimitry Andric _CharT __c2 = *__s.__current_; 20690b57cec5SDimitry Andric bool __is_c1_b = __c1 == '_' || 20700b57cec5SDimitry Andric __traits_.isctype(__c1, ctype_base::alnum); 20710b57cec5SDimitry Andric bool __is_c2_b = __c2 == '_' || 20720b57cec5SDimitry Andric __traits_.isctype(__c2, ctype_base::alnum); 20730b57cec5SDimitry Andric __is_word_b = __is_c1_b != __is_c2_b; 20740b57cec5SDimitry Andric } 20750b57cec5SDimitry Andric } 20760b57cec5SDimitry Andric if (__is_word_b != __invert_) 20770b57cec5SDimitry Andric { 20780b57cec5SDimitry Andric __s.__do_ = __state::__accept_but_not_consume; 20790b57cec5SDimitry Andric __s.__node_ = this->first(); 20800b57cec5SDimitry Andric } 20810b57cec5SDimitry Andric else 20820b57cec5SDimitry Andric { 20830b57cec5SDimitry Andric __s.__do_ = __state::__reject; 20840b57cec5SDimitry Andric __s.__node_ = nullptr; 20850b57cec5SDimitry Andric } 20860b57cec5SDimitry Andric} 20870b57cec5SDimitry Andric 20880b57cec5SDimitry Andric// __l_anchor 20890b57cec5SDimitry Andric 20900b57cec5SDimitry Andrictemplate <class _CharT> 2091*5f757f3fSDimitry Andric_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR 2092753f127fSDimitry Andricbool __is_eol(_CharT __c) 2093e8d8bef9SDimitry Andric{ 2094753f127fSDimitry Andric return __c == '\r' || __c == '\n'; 2095e8d8bef9SDimitry Andric} 2096e8d8bef9SDimitry Andric 2097e8d8bef9SDimitry Andrictemplate <class _CharT> 2098e8d8bef9SDimitry Andricclass __l_anchor_multiline 20990b57cec5SDimitry Andric : public __owns_one_state<_CharT> 21000b57cec5SDimitry Andric{ 21010b57cec5SDimitry Andric typedef __owns_one_state<_CharT> base; 21020b57cec5SDimitry Andric 2103fe6060f1SDimitry Andric bool __multiline_; 2104e8d8bef9SDimitry Andric 21050b57cec5SDimitry Andricpublic: 2106*5f757f3fSDimitry Andric typedef std::__state<_CharT> __state; 21070b57cec5SDimitry Andric 2108*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 2109e8d8bef9SDimitry Andric __l_anchor_multiline(bool __multiline, __node<_CharT>* __s) 2110fe6060f1SDimitry Andric : base(__s), __multiline_(__multiline) {} 21110b57cec5SDimitry Andric 211206c3fb27SDimitry Andric _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const; 21130b57cec5SDimitry Andric}; 21140b57cec5SDimitry Andric 21150b57cec5SDimitry Andrictemplate <class _CharT> 21160b57cec5SDimitry Andricvoid 2117e8d8bef9SDimitry Andric__l_anchor_multiline<_CharT>::__exec(__state& __s) const 21180b57cec5SDimitry Andric{ 21190b57cec5SDimitry Andric if (__s.__at_first_ && __s.__current_ == __s.__first_ && 21200b57cec5SDimitry Andric !(__s.__flags_ & regex_constants::match_not_bol)) 21210b57cec5SDimitry Andric { 21220b57cec5SDimitry Andric __s.__do_ = __state::__accept_but_not_consume; 21230b57cec5SDimitry Andric __s.__node_ = this->first(); 21240b57cec5SDimitry Andric } 2125fe6060f1SDimitry Andric else if (__multiline_ && 2126e8d8bef9SDimitry Andric !__s.__at_first_ && 2127*5f757f3fSDimitry Andric std::__is_eol(*std::prev(__s.__current_))) 2128e8d8bef9SDimitry Andric { 2129e8d8bef9SDimitry Andric __s.__do_ = __state::__accept_but_not_consume; 2130e8d8bef9SDimitry Andric __s.__node_ = this->first(); 2131e8d8bef9SDimitry Andric } 21320b57cec5SDimitry Andric else 21330b57cec5SDimitry Andric { 21340b57cec5SDimitry Andric __s.__do_ = __state::__reject; 21350b57cec5SDimitry Andric __s.__node_ = nullptr; 21360b57cec5SDimitry Andric } 21370b57cec5SDimitry Andric} 21380b57cec5SDimitry Andric 21390b57cec5SDimitry Andric// __r_anchor 21400b57cec5SDimitry Andric 21410b57cec5SDimitry Andrictemplate <class _CharT> 2142e8d8bef9SDimitry Andricclass __r_anchor_multiline 21430b57cec5SDimitry Andric : public __owns_one_state<_CharT> 21440b57cec5SDimitry Andric{ 21450b57cec5SDimitry Andric typedef __owns_one_state<_CharT> base; 21460b57cec5SDimitry Andric 214781ad6265SDimitry Andric bool __multiline_; 2148e8d8bef9SDimitry Andric 21490b57cec5SDimitry Andricpublic: 2150*5f757f3fSDimitry Andric typedef std::__state<_CharT> __state; 21510b57cec5SDimitry Andric 2152*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 2153e8d8bef9SDimitry Andric __r_anchor_multiline(bool __multiline, __node<_CharT>* __s) 215481ad6265SDimitry Andric : base(__s), __multiline_(__multiline) {} 21550b57cec5SDimitry Andric 215606c3fb27SDimitry Andric _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const; 21570b57cec5SDimitry Andric}; 21580b57cec5SDimitry Andric 21590b57cec5SDimitry Andrictemplate <class _CharT> 21600b57cec5SDimitry Andricvoid 2161e8d8bef9SDimitry Andric__r_anchor_multiline<_CharT>::__exec(__state& __s) const 21620b57cec5SDimitry Andric{ 21630b57cec5SDimitry Andric if (__s.__current_ == __s.__last_ && 21640b57cec5SDimitry Andric !(__s.__flags_ & regex_constants::match_not_eol)) 21650b57cec5SDimitry Andric { 21660b57cec5SDimitry Andric __s.__do_ = __state::__accept_but_not_consume; 21670b57cec5SDimitry Andric __s.__node_ = this->first(); 21680b57cec5SDimitry Andric } 2169bdd1243dSDimitry Andric else if (__multiline_ && std::__is_eol(*__s.__current_)) 2170e8d8bef9SDimitry Andric { 2171e8d8bef9SDimitry Andric __s.__do_ = __state::__accept_but_not_consume; 2172e8d8bef9SDimitry Andric __s.__node_ = this->first(); 2173e8d8bef9SDimitry Andric } 21740b57cec5SDimitry Andric else 21750b57cec5SDimitry Andric { 21760b57cec5SDimitry Andric __s.__do_ = __state::__reject; 21770b57cec5SDimitry Andric __s.__node_ = nullptr; 21780b57cec5SDimitry Andric } 21790b57cec5SDimitry Andric} 21800b57cec5SDimitry Andric 21810b57cec5SDimitry Andric// __match_any 21820b57cec5SDimitry Andric 21830b57cec5SDimitry Andrictemplate <class _CharT> 21840b57cec5SDimitry Andricclass __match_any 21850b57cec5SDimitry Andric : public __owns_one_state<_CharT> 21860b57cec5SDimitry Andric{ 21870b57cec5SDimitry Andric typedef __owns_one_state<_CharT> base; 21880b57cec5SDimitry Andric 21890b57cec5SDimitry Andricpublic: 2190*5f757f3fSDimitry Andric typedef std::__state<_CharT> __state; 21910b57cec5SDimitry Andric 2192*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 21930b57cec5SDimitry Andric __match_any(__node<_CharT>* __s) 21940b57cec5SDimitry Andric : base(__s) {} 21950b57cec5SDimitry Andric 219606c3fb27SDimitry Andric _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const; 21970b57cec5SDimitry Andric}; 21980b57cec5SDimitry Andric 21990b57cec5SDimitry Andrictemplate <class _CharT> 22000b57cec5SDimitry Andricvoid 22010b57cec5SDimitry Andric__match_any<_CharT>::__exec(__state& __s) const 22020b57cec5SDimitry Andric{ 22030b57cec5SDimitry Andric if (__s.__current_ != __s.__last_ && *__s.__current_ != 0) 22040b57cec5SDimitry Andric { 22050b57cec5SDimitry Andric __s.__do_ = __state::__accept_and_consume; 22060b57cec5SDimitry Andric ++__s.__current_; 22070b57cec5SDimitry Andric __s.__node_ = this->first(); 22080b57cec5SDimitry Andric } 22090b57cec5SDimitry Andric else 22100b57cec5SDimitry Andric { 22110b57cec5SDimitry Andric __s.__do_ = __state::__reject; 22120b57cec5SDimitry Andric __s.__node_ = nullptr; 22130b57cec5SDimitry Andric } 22140b57cec5SDimitry Andric} 22150b57cec5SDimitry Andric 22160b57cec5SDimitry Andric// __match_any_but_newline 22170b57cec5SDimitry Andric 22180b57cec5SDimitry Andrictemplate <class _CharT> 22190b57cec5SDimitry Andricclass __match_any_but_newline 22200b57cec5SDimitry Andric : public __owns_one_state<_CharT> 22210b57cec5SDimitry Andric{ 22220b57cec5SDimitry Andric typedef __owns_one_state<_CharT> base; 22230b57cec5SDimitry Andric 22240b57cec5SDimitry Andricpublic: 2225*5f757f3fSDimitry Andric typedef std::__state<_CharT> __state; 22260b57cec5SDimitry Andric 2227*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 22280b57cec5SDimitry Andric __match_any_but_newline(__node<_CharT>* __s) 22290b57cec5SDimitry Andric : base(__s) {} 22300b57cec5SDimitry Andric 2231bdd1243dSDimitry Andric void __exec(__state&) const override; 22320b57cec5SDimitry Andric}; 22330b57cec5SDimitry Andric 223406c3fb27SDimitry Andrictemplate <> _LIBCPP_EXPORTED_FROM_ABI void __match_any_but_newline<char>::__exec(__state&) const; 2235349cc55cSDimitry Andric#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 223606c3fb27SDimitry Andrictemplate <> _LIBCPP_EXPORTED_FROM_ABI void __match_any_but_newline<wchar_t>::__exec(__state&) const; 2237349cc55cSDimitry Andric#endif 22380b57cec5SDimitry Andric 22390b57cec5SDimitry Andric// __match_char 22400b57cec5SDimitry Andric 22410b57cec5SDimitry Andrictemplate <class _CharT> 22420b57cec5SDimitry Andricclass __match_char 22430b57cec5SDimitry Andric : public __owns_one_state<_CharT> 22440b57cec5SDimitry Andric{ 22450b57cec5SDimitry Andric typedef __owns_one_state<_CharT> base; 22460b57cec5SDimitry Andric 22470b57cec5SDimitry Andric _CharT __c_; 22480b57cec5SDimitry Andric 22490b57cec5SDimitry Andric __match_char(const __match_char&); 22500b57cec5SDimitry Andric __match_char& operator=(const __match_char&); 22510b57cec5SDimitry Andricpublic: 2252*5f757f3fSDimitry Andric typedef std::__state<_CharT> __state; 22530b57cec5SDimitry Andric 2254*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 22550b57cec5SDimitry Andric __match_char(_CharT __c, __node<_CharT>* __s) 22560b57cec5SDimitry Andric : base(__s), __c_(__c) {} 22570b57cec5SDimitry Andric 225806c3fb27SDimitry Andric _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const; 22590b57cec5SDimitry Andric}; 22600b57cec5SDimitry Andric 22610b57cec5SDimitry Andrictemplate <class _CharT> 22620b57cec5SDimitry Andricvoid 22630b57cec5SDimitry Andric__match_char<_CharT>::__exec(__state& __s) const 22640b57cec5SDimitry Andric{ 22650b57cec5SDimitry Andric if (__s.__current_ != __s.__last_ && *__s.__current_ == __c_) 22660b57cec5SDimitry Andric { 22670b57cec5SDimitry Andric __s.__do_ = __state::__accept_and_consume; 22680b57cec5SDimitry Andric ++__s.__current_; 22690b57cec5SDimitry Andric __s.__node_ = this->first(); 22700b57cec5SDimitry Andric } 22710b57cec5SDimitry Andric else 22720b57cec5SDimitry Andric { 22730b57cec5SDimitry Andric __s.__do_ = __state::__reject; 22740b57cec5SDimitry Andric __s.__node_ = nullptr; 22750b57cec5SDimitry Andric } 22760b57cec5SDimitry Andric} 22770b57cec5SDimitry Andric 22780b57cec5SDimitry Andric// __match_char_icase 22790b57cec5SDimitry Andric 22800b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 22810b57cec5SDimitry Andricclass __match_char_icase 22820b57cec5SDimitry Andric : public __owns_one_state<_CharT> 22830b57cec5SDimitry Andric{ 22840b57cec5SDimitry Andric typedef __owns_one_state<_CharT> base; 22850b57cec5SDimitry Andric 22860b57cec5SDimitry Andric _Traits __traits_; 22870b57cec5SDimitry Andric _CharT __c_; 22880b57cec5SDimitry Andric 22890b57cec5SDimitry Andric __match_char_icase(const __match_char_icase&); 22900b57cec5SDimitry Andric __match_char_icase& operator=(const __match_char_icase&); 22910b57cec5SDimitry Andricpublic: 2292*5f757f3fSDimitry Andric typedef std::__state<_CharT> __state; 22930b57cec5SDimitry Andric 2294*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 22950b57cec5SDimitry Andric __match_char_icase(const _Traits& __traits, _CharT __c, __node<_CharT>* __s) 22960b57cec5SDimitry Andric : base(__s), __traits_(__traits), __c_(__traits.translate_nocase(__c)) {} 22970b57cec5SDimitry Andric 229806c3fb27SDimitry Andric _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const; 22990b57cec5SDimitry Andric}; 23000b57cec5SDimitry Andric 23010b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 23020b57cec5SDimitry Andricvoid 23030b57cec5SDimitry Andric__match_char_icase<_CharT, _Traits>::__exec(__state& __s) const 23040b57cec5SDimitry Andric{ 23050b57cec5SDimitry Andric if (__s.__current_ != __s.__last_ && 23060b57cec5SDimitry Andric __traits_.translate_nocase(*__s.__current_) == __c_) 23070b57cec5SDimitry Andric { 23080b57cec5SDimitry Andric __s.__do_ = __state::__accept_and_consume; 23090b57cec5SDimitry Andric ++__s.__current_; 23100b57cec5SDimitry Andric __s.__node_ = this->first(); 23110b57cec5SDimitry Andric } 23120b57cec5SDimitry Andric else 23130b57cec5SDimitry Andric { 23140b57cec5SDimitry Andric __s.__do_ = __state::__reject; 23150b57cec5SDimitry Andric __s.__node_ = nullptr; 23160b57cec5SDimitry Andric } 23170b57cec5SDimitry Andric} 23180b57cec5SDimitry Andric 23190b57cec5SDimitry Andric// __match_char_collate 23200b57cec5SDimitry Andric 23210b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 23220b57cec5SDimitry Andricclass __match_char_collate 23230b57cec5SDimitry Andric : public __owns_one_state<_CharT> 23240b57cec5SDimitry Andric{ 23250b57cec5SDimitry Andric typedef __owns_one_state<_CharT> base; 23260b57cec5SDimitry Andric 23270b57cec5SDimitry Andric _Traits __traits_; 23280b57cec5SDimitry Andric _CharT __c_; 23290b57cec5SDimitry Andric 23300b57cec5SDimitry Andric __match_char_collate(const __match_char_collate&); 23310b57cec5SDimitry Andric __match_char_collate& operator=(const __match_char_collate&); 23320b57cec5SDimitry Andricpublic: 2333*5f757f3fSDimitry Andric typedef std::__state<_CharT> __state; 23340b57cec5SDimitry Andric 2335*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 23360b57cec5SDimitry Andric __match_char_collate(const _Traits& __traits, _CharT __c, __node<_CharT>* __s) 23370b57cec5SDimitry Andric : base(__s), __traits_(__traits), __c_(__traits.translate(__c)) {} 23380b57cec5SDimitry Andric 233906c3fb27SDimitry Andric _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const; 23400b57cec5SDimitry Andric}; 23410b57cec5SDimitry Andric 23420b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 23430b57cec5SDimitry Andricvoid 23440b57cec5SDimitry Andric__match_char_collate<_CharT, _Traits>::__exec(__state& __s) const 23450b57cec5SDimitry Andric{ 23460b57cec5SDimitry Andric if (__s.__current_ != __s.__last_ && 23470b57cec5SDimitry Andric __traits_.translate(*__s.__current_) == __c_) 23480b57cec5SDimitry Andric { 23490b57cec5SDimitry Andric __s.__do_ = __state::__accept_and_consume; 23500b57cec5SDimitry Andric ++__s.__current_; 23510b57cec5SDimitry Andric __s.__node_ = this->first(); 23520b57cec5SDimitry Andric } 23530b57cec5SDimitry Andric else 23540b57cec5SDimitry Andric { 23550b57cec5SDimitry Andric __s.__do_ = __state::__reject; 23560b57cec5SDimitry Andric __s.__node_ = nullptr; 23570b57cec5SDimitry Andric } 23580b57cec5SDimitry Andric} 23590b57cec5SDimitry Andric 23600b57cec5SDimitry Andric// __bracket_expression 23610b57cec5SDimitry Andric 23620b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 23630b57cec5SDimitry Andricclass __bracket_expression 23640b57cec5SDimitry Andric : public __owns_one_state<_CharT> 23650b57cec5SDimitry Andric{ 23660b57cec5SDimitry Andric typedef __owns_one_state<_CharT> base; 23670b57cec5SDimitry Andric typedef typename _Traits::string_type string_type; 23680b57cec5SDimitry Andric 23690b57cec5SDimitry Andric _Traits __traits_; 23700b57cec5SDimitry Andric vector<_CharT> __chars_; 23710b57cec5SDimitry Andric vector<_CharT> __neg_chars_; 23720b57cec5SDimitry Andric vector<pair<string_type, string_type> > __ranges_; 23730b57cec5SDimitry Andric vector<pair<_CharT, _CharT> > __digraphs_; 23740b57cec5SDimitry Andric vector<string_type> __equivalences_; 23750b57cec5SDimitry Andric typename regex_traits<_CharT>::char_class_type __mask_; 23760b57cec5SDimitry Andric typename regex_traits<_CharT>::char_class_type __neg_mask_; 23770b57cec5SDimitry Andric bool __negate_; 23780b57cec5SDimitry Andric bool __icase_; 23790b57cec5SDimitry Andric bool __collate_; 23800b57cec5SDimitry Andric bool __might_have_digraph_; 23810b57cec5SDimitry Andric 23820b57cec5SDimitry Andric __bracket_expression(const __bracket_expression&); 23830b57cec5SDimitry Andric __bracket_expression& operator=(const __bracket_expression&); 23840b57cec5SDimitry Andricpublic: 2385*5f757f3fSDimitry Andric typedef std::__state<_CharT> __state; 23860b57cec5SDimitry Andric 2387*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 23880b57cec5SDimitry Andric __bracket_expression(const _Traits& __traits, __node<_CharT>* __s, 23890b57cec5SDimitry Andric bool __negate, bool __icase, bool __collate) 23900b57cec5SDimitry Andric : base(__s), __traits_(__traits), __mask_(), __neg_mask_(), 23910b57cec5SDimitry Andric __negate_(__negate), __icase_(__icase), __collate_(__collate), 23920b57cec5SDimitry Andric __might_have_digraph_(__traits_.getloc().name() != "C") {} 23930b57cec5SDimitry Andric 239406c3fb27SDimitry Andric _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const; 23950b57cec5SDimitry Andric 2396*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 23970b57cec5SDimitry Andric bool __negated() const {return __negate_;} 23980b57cec5SDimitry Andric 2399*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 24000b57cec5SDimitry Andric void __add_char(_CharT __c) 24010b57cec5SDimitry Andric { 24020b57cec5SDimitry Andric if (__icase_) 24030b57cec5SDimitry Andric __chars_.push_back(__traits_.translate_nocase(__c)); 24040b57cec5SDimitry Andric else if (__collate_) 24050b57cec5SDimitry Andric __chars_.push_back(__traits_.translate(__c)); 24060b57cec5SDimitry Andric else 24070b57cec5SDimitry Andric __chars_.push_back(__c); 24080b57cec5SDimitry Andric } 2409*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 24100b57cec5SDimitry Andric void __add_neg_char(_CharT __c) 24110b57cec5SDimitry Andric { 24120b57cec5SDimitry Andric if (__icase_) 24130b57cec5SDimitry Andric __neg_chars_.push_back(__traits_.translate_nocase(__c)); 24140b57cec5SDimitry Andric else if (__collate_) 24150b57cec5SDimitry Andric __neg_chars_.push_back(__traits_.translate(__c)); 24160b57cec5SDimitry Andric else 24170b57cec5SDimitry Andric __neg_chars_.push_back(__c); 24180b57cec5SDimitry Andric } 2419*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 24200b57cec5SDimitry Andric void __add_range(string_type __b, string_type __e) 24210b57cec5SDimitry Andric { 24220b57cec5SDimitry Andric if (__collate_) 24230b57cec5SDimitry Andric { 24240b57cec5SDimitry Andric if (__icase_) 24250b57cec5SDimitry Andric { 24260b57cec5SDimitry Andric for (size_t __i = 0; __i < __b.size(); ++__i) 24270b57cec5SDimitry Andric __b[__i] = __traits_.translate_nocase(__b[__i]); 24280b57cec5SDimitry Andric for (size_t __i = 0; __i < __e.size(); ++__i) 24290b57cec5SDimitry Andric __e[__i] = __traits_.translate_nocase(__e[__i]); 24300b57cec5SDimitry Andric } 24310b57cec5SDimitry Andric else 24320b57cec5SDimitry Andric { 24330b57cec5SDimitry Andric for (size_t __i = 0; __i < __b.size(); ++__i) 24340b57cec5SDimitry Andric __b[__i] = __traits_.translate(__b[__i]); 24350b57cec5SDimitry Andric for (size_t __i = 0; __i < __e.size(); ++__i) 24360b57cec5SDimitry Andric __e[__i] = __traits_.translate(__e[__i]); 24370b57cec5SDimitry Andric } 2438bdd1243dSDimitry Andric __ranges_.push_back(std::make_pair( 24390b57cec5SDimitry Andric __traits_.transform(__b.begin(), __b.end()), 24400b57cec5SDimitry Andric __traits_.transform(__e.begin(), __e.end()))); 24410b57cec5SDimitry Andric } 24420b57cec5SDimitry Andric else 24430b57cec5SDimitry Andric { 24440b57cec5SDimitry Andric if (__b.size() != 1 || __e.size() != 1) 24450b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_range>(); 24460b57cec5SDimitry Andric if (__icase_) 24470b57cec5SDimitry Andric { 24480b57cec5SDimitry Andric __b[0] = __traits_.translate_nocase(__b[0]); 24490b57cec5SDimitry Andric __e[0] = __traits_.translate_nocase(__e[0]); 24500b57cec5SDimitry Andric } 2451*5f757f3fSDimitry Andric __ranges_.push_back(std::make_pair(std::move(__b), std::move(__e))); 24520b57cec5SDimitry Andric } 24530b57cec5SDimitry Andric } 2454*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 24550b57cec5SDimitry Andric void __add_digraph(_CharT __c1, _CharT __c2) 24560b57cec5SDimitry Andric { 24570b57cec5SDimitry Andric if (__icase_) 2458bdd1243dSDimitry Andric __digraphs_.push_back(std::make_pair(__traits_.translate_nocase(__c1), 24590b57cec5SDimitry Andric __traits_.translate_nocase(__c2))); 24600b57cec5SDimitry Andric else if (__collate_) 2461bdd1243dSDimitry Andric __digraphs_.push_back(std::make_pair(__traits_.translate(__c1), 24620b57cec5SDimitry Andric __traits_.translate(__c2))); 24630b57cec5SDimitry Andric else 2464bdd1243dSDimitry Andric __digraphs_.push_back(std::make_pair(__c1, __c2)); 24650b57cec5SDimitry Andric } 2466*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 24670b57cec5SDimitry Andric void __add_equivalence(const string_type& __s) 24680b57cec5SDimitry Andric {__equivalences_.push_back(__s);} 2469*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 24700b57cec5SDimitry Andric void __add_class(typename regex_traits<_CharT>::char_class_type __mask) 24710b57cec5SDimitry Andric {__mask_ |= __mask;} 2472*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 24730b57cec5SDimitry Andric void __add_neg_class(typename regex_traits<_CharT>::char_class_type __mask) 24740b57cec5SDimitry Andric {__neg_mask_ |= __mask;} 24750b57cec5SDimitry Andric}; 24760b57cec5SDimitry Andric 24770b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 24780b57cec5SDimitry Andricvoid 24790b57cec5SDimitry Andric__bracket_expression<_CharT, _Traits>::__exec(__state& __s) const 24800b57cec5SDimitry Andric{ 24810b57cec5SDimitry Andric bool __found = false; 24820b57cec5SDimitry Andric unsigned __consumed = 0; 24830b57cec5SDimitry Andric if (__s.__current_ != __s.__last_) 24840b57cec5SDimitry Andric { 24850b57cec5SDimitry Andric ++__consumed; 24860b57cec5SDimitry Andric if (__might_have_digraph_) 24870b57cec5SDimitry Andric { 2488*5f757f3fSDimitry Andric const _CharT* __next = std::next(__s.__current_); 24890b57cec5SDimitry Andric if (__next != __s.__last_) 24900b57cec5SDimitry Andric { 24910b57cec5SDimitry Andric pair<_CharT, _CharT> __ch2(*__s.__current_, *__next); 24920b57cec5SDimitry Andric if (__icase_) 24930b57cec5SDimitry Andric { 24940b57cec5SDimitry Andric __ch2.first = __traits_.translate_nocase(__ch2.first); 24950b57cec5SDimitry Andric __ch2.second = __traits_.translate_nocase(__ch2.second); 24960b57cec5SDimitry Andric } 24970b57cec5SDimitry Andric else if (__collate_) 24980b57cec5SDimitry Andric { 24990b57cec5SDimitry Andric __ch2.first = __traits_.translate(__ch2.first); 25000b57cec5SDimitry Andric __ch2.second = __traits_.translate(__ch2.second); 25010b57cec5SDimitry Andric } 25020b57cec5SDimitry Andric if (!__traits_.lookup_collatename(&__ch2.first, &__ch2.first+2).empty()) 25030b57cec5SDimitry Andric { 25040b57cec5SDimitry Andric // __ch2 is a digraph in this locale 25050b57cec5SDimitry Andric ++__consumed; 25060b57cec5SDimitry Andric for (size_t __i = 0; __i < __digraphs_.size(); ++__i) 25070b57cec5SDimitry Andric { 25080b57cec5SDimitry Andric if (__ch2 == __digraphs_[__i]) 25090b57cec5SDimitry Andric { 25100b57cec5SDimitry Andric __found = true; 25110b57cec5SDimitry Andric goto __exit; 25120b57cec5SDimitry Andric } 25130b57cec5SDimitry Andric } 25140b57cec5SDimitry Andric if (__collate_ && !__ranges_.empty()) 25150b57cec5SDimitry Andric { 25160b57cec5SDimitry Andric string_type __s2 = __traits_.transform(&__ch2.first, 25170b57cec5SDimitry Andric &__ch2.first + 2); 25180b57cec5SDimitry Andric for (size_t __i = 0; __i < __ranges_.size(); ++__i) 25190b57cec5SDimitry Andric { 25200b57cec5SDimitry Andric if (__ranges_[__i].first <= __s2 && 25210b57cec5SDimitry Andric __s2 <= __ranges_[__i].second) 25220b57cec5SDimitry Andric { 25230b57cec5SDimitry Andric __found = true; 25240b57cec5SDimitry Andric goto __exit; 25250b57cec5SDimitry Andric } 25260b57cec5SDimitry Andric } 25270b57cec5SDimitry Andric } 25280b57cec5SDimitry Andric if (!__equivalences_.empty()) 25290b57cec5SDimitry Andric { 25300b57cec5SDimitry Andric string_type __s2 = __traits_.transform_primary(&__ch2.first, 25310b57cec5SDimitry Andric &__ch2.first + 2); 25320b57cec5SDimitry Andric for (size_t __i = 0; __i < __equivalences_.size(); ++__i) 25330b57cec5SDimitry Andric { 25340b57cec5SDimitry Andric if (__s2 == __equivalences_[__i]) 25350b57cec5SDimitry Andric { 25360b57cec5SDimitry Andric __found = true; 25370b57cec5SDimitry Andric goto __exit; 25380b57cec5SDimitry Andric } 25390b57cec5SDimitry Andric } 25400b57cec5SDimitry Andric } 25410b57cec5SDimitry Andric if (__traits_.isctype(__ch2.first, __mask_) && 25420b57cec5SDimitry Andric __traits_.isctype(__ch2.second, __mask_)) 25430b57cec5SDimitry Andric { 25440b57cec5SDimitry Andric __found = true; 25450b57cec5SDimitry Andric goto __exit; 25460b57cec5SDimitry Andric } 25470b57cec5SDimitry Andric if (!__traits_.isctype(__ch2.first, __neg_mask_) && 25480b57cec5SDimitry Andric !__traits_.isctype(__ch2.second, __neg_mask_)) 25490b57cec5SDimitry Andric { 25500b57cec5SDimitry Andric __found = true; 25510b57cec5SDimitry Andric goto __exit; 25520b57cec5SDimitry Andric } 25530b57cec5SDimitry Andric goto __exit; 25540b57cec5SDimitry Andric } 25550b57cec5SDimitry Andric } 25560b57cec5SDimitry Andric } 25570b57cec5SDimitry Andric // test *__s.__current_ as not a digraph 25580b57cec5SDimitry Andric _CharT __ch = *__s.__current_; 25590b57cec5SDimitry Andric if (__icase_) 25600b57cec5SDimitry Andric __ch = __traits_.translate_nocase(__ch); 25610b57cec5SDimitry Andric else if (__collate_) 25620b57cec5SDimitry Andric __ch = __traits_.translate(__ch); 25630b57cec5SDimitry Andric for (size_t __i = 0; __i < __chars_.size(); ++__i) 25640b57cec5SDimitry Andric { 25650b57cec5SDimitry Andric if (__ch == __chars_[__i]) 25660b57cec5SDimitry Andric { 25670b57cec5SDimitry Andric __found = true; 25680b57cec5SDimitry Andric goto __exit; 25690b57cec5SDimitry Andric } 25700b57cec5SDimitry Andric } 25710b57cec5SDimitry Andric // When there's at least one of __neg_chars_ and __neg_mask_, the set 25720b57cec5SDimitry Andric // of "__found" chars is 25730b57cec5SDimitry Andric // union(complement(union(__neg_chars_, __neg_mask_)), 25740b57cec5SDimitry Andric // other cases...) 25750b57cec5SDimitry Andric // 25760b57cec5SDimitry Andric // It doesn't make sense to check this when there are no __neg_chars_ 25770b57cec5SDimitry Andric // and no __neg_mask_. 25780b57cec5SDimitry Andric if (!(__neg_mask_ == 0 && __neg_chars_.empty())) 25790b57cec5SDimitry Andric { 25800b57cec5SDimitry Andric const bool __in_neg_mask = __traits_.isctype(__ch, __neg_mask_); 25810b57cec5SDimitry Andric const bool __in_neg_chars = 2582*5f757f3fSDimitry Andric std::find(__neg_chars_.begin(), __neg_chars_.end(), __ch) != 25830b57cec5SDimitry Andric __neg_chars_.end(); 25840b57cec5SDimitry Andric if (!(__in_neg_mask || __in_neg_chars)) 25850b57cec5SDimitry Andric { 25860b57cec5SDimitry Andric __found = true; 25870b57cec5SDimitry Andric goto __exit; 25880b57cec5SDimitry Andric } 25890b57cec5SDimitry Andric } 25900b57cec5SDimitry Andric if (!__ranges_.empty()) 25910b57cec5SDimitry Andric { 25920b57cec5SDimitry Andric string_type __s2 = __collate_ ? 25930b57cec5SDimitry Andric __traits_.transform(&__ch, &__ch + 1) : 25940b57cec5SDimitry Andric string_type(1, __ch); 25950b57cec5SDimitry Andric for (size_t __i = 0; __i < __ranges_.size(); ++__i) 25960b57cec5SDimitry Andric { 25970b57cec5SDimitry Andric if (__ranges_[__i].first <= __s2 && __s2 <= __ranges_[__i].second) 25980b57cec5SDimitry Andric { 25990b57cec5SDimitry Andric __found = true; 26000b57cec5SDimitry Andric goto __exit; 26010b57cec5SDimitry Andric } 26020b57cec5SDimitry Andric } 26030b57cec5SDimitry Andric } 26040b57cec5SDimitry Andric if (!__equivalences_.empty()) 26050b57cec5SDimitry Andric { 26060b57cec5SDimitry Andric string_type __s2 = __traits_.transform_primary(&__ch, &__ch + 1); 26070b57cec5SDimitry Andric for (size_t __i = 0; __i < __equivalences_.size(); ++__i) 26080b57cec5SDimitry Andric { 26090b57cec5SDimitry Andric if (__s2 == __equivalences_[__i]) 26100b57cec5SDimitry Andric { 26110b57cec5SDimitry Andric __found = true; 26120b57cec5SDimitry Andric goto __exit; 26130b57cec5SDimitry Andric } 26140b57cec5SDimitry Andric } 26150b57cec5SDimitry Andric } 26160b57cec5SDimitry Andric if (__traits_.isctype(__ch, __mask_)) 26170b57cec5SDimitry Andric { 26180b57cec5SDimitry Andric __found = true; 26190b57cec5SDimitry Andric goto __exit; 26200b57cec5SDimitry Andric } 26210b57cec5SDimitry Andric } 26220b57cec5SDimitry Andric else 26230b57cec5SDimitry Andric __found = __negate_; // force reject 26240b57cec5SDimitry Andric__exit: 26250b57cec5SDimitry Andric if (__found != __negate_) 26260b57cec5SDimitry Andric { 26270b57cec5SDimitry Andric __s.__do_ = __state::__accept_and_consume; 26280b57cec5SDimitry Andric __s.__current_ += __consumed; 26290b57cec5SDimitry Andric __s.__node_ = this->first(); 26300b57cec5SDimitry Andric } 26310b57cec5SDimitry Andric else 26320b57cec5SDimitry Andric { 26330b57cec5SDimitry Andric __s.__do_ = __state::__reject; 26340b57cec5SDimitry Andric __s.__node_ = nullptr; 26350b57cec5SDimitry Andric } 26360b57cec5SDimitry Andric} 26370b57cec5SDimitry Andric 26380b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> class __lookahead; 26390b57cec5SDimitry Andric 26400b57cec5SDimitry Andrictemplate <class _CharT, class _Traits = regex_traits<_CharT> > 2641e8d8bef9SDimitry Andric class _LIBCPP_TEMPLATE_VIS basic_regex; 2642e8d8bef9SDimitry Andric 2643e8d8bef9SDimitry Andrictypedef basic_regex<char> regex; 2644349cc55cSDimitry Andric#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 2645e8d8bef9SDimitry Andrictypedef basic_regex<wchar_t> wregex; 2646349cc55cSDimitry Andric#endif 2647e8d8bef9SDimitry Andric 2648e8d8bef9SDimitry Andrictemplate <class _CharT, class _Traits> 2649e8d8bef9SDimitry Andricclass 2650e8d8bef9SDimitry Andric _LIBCPP_TEMPLATE_VIS 2651e8d8bef9SDimitry Andric _LIBCPP_PREFERRED_NAME(regex) 2652349cc55cSDimitry Andric _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wregex)) 2653e8d8bef9SDimitry Andric basic_regex 26540b57cec5SDimitry Andric{ 26550b57cec5SDimitry Andricpublic: 26560b57cec5SDimitry Andric // types: 26570b57cec5SDimitry Andric typedef _CharT value_type; 26580b57cec5SDimitry Andric typedef _Traits traits_type; 26590b57cec5SDimitry Andric typedef typename _Traits::string_type string_type; 26600b57cec5SDimitry Andric typedef regex_constants::syntax_option_type flag_type; 26610b57cec5SDimitry Andric typedef typename _Traits::locale_type locale_type; 26620b57cec5SDimitry Andric 26630b57cec5SDimitry Andricprivate: 26640b57cec5SDimitry Andric _Traits __traits_; 26650b57cec5SDimitry Andric flag_type __flags_; 26660b57cec5SDimitry Andric unsigned __marked_count_; 26670b57cec5SDimitry Andric unsigned __loop_count_; 26680b57cec5SDimitry Andric int __open_count_; 26690b57cec5SDimitry Andric shared_ptr<__empty_state<_CharT> > __start_; 26700b57cec5SDimitry Andric __owns_one_state<_CharT>* __end_; 26710b57cec5SDimitry Andric 2672*5f757f3fSDimitry Andric typedef std::__state<_CharT> __state; 2673*5f757f3fSDimitry Andric typedef std::__node<_CharT> __node; 26740b57cec5SDimitry Andric 26750b57cec5SDimitry Andricpublic: 26760b57cec5SDimitry Andric // constants: 26770b57cec5SDimitry Andric static const regex_constants::syntax_option_type icase = regex_constants::icase; 26780b57cec5SDimitry Andric static const regex_constants::syntax_option_type nosubs = regex_constants::nosubs; 26790b57cec5SDimitry Andric static const regex_constants::syntax_option_type optimize = regex_constants::optimize; 26800b57cec5SDimitry Andric static const regex_constants::syntax_option_type collate = regex_constants::collate; 26810b57cec5SDimitry Andric static const regex_constants::syntax_option_type ECMAScript = regex_constants::ECMAScript; 26820b57cec5SDimitry Andric static const regex_constants::syntax_option_type basic = regex_constants::basic; 26830b57cec5SDimitry Andric static const regex_constants::syntax_option_type extended = regex_constants::extended; 26840b57cec5SDimitry Andric static const regex_constants::syntax_option_type awk = regex_constants::awk; 26850b57cec5SDimitry Andric static const regex_constants::syntax_option_type grep = regex_constants::grep; 26860b57cec5SDimitry Andric static const regex_constants::syntax_option_type egrep = regex_constants::egrep; 2687e8d8bef9SDimitry Andric static const regex_constants::syntax_option_type multiline = regex_constants::multiline; 26880b57cec5SDimitry Andric 26890b57cec5SDimitry Andric // construct/copy/destroy: 2690*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 26910b57cec5SDimitry Andric basic_regex() 26920b57cec5SDimitry Andric : __flags_(regex_constants::ECMAScript), __marked_count_(0), __loop_count_(0), __open_count_(0), 2693e8d8bef9SDimitry Andric __end_(nullptr) 26940b57cec5SDimitry Andric {} 2695*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 26960b57cec5SDimitry Andric explicit basic_regex(const value_type* __p, flag_type __f = regex_constants::ECMAScript) 26970b57cec5SDimitry Andric : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0), 2698e8d8bef9SDimitry Andric __end_(nullptr) 26990b57cec5SDimitry Andric { 2700480093f4SDimitry Andric __init(__p, __p + __traits_.length(__p)); 27010b57cec5SDimitry Andric } 27020b57cec5SDimitry Andric 2703*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 27040b57cec5SDimitry Andric basic_regex(const value_type* __p, size_t __len, flag_type __f = regex_constants::ECMAScript) 27050b57cec5SDimitry Andric : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0), 2706e8d8bef9SDimitry Andric __end_(nullptr) 27070b57cec5SDimitry Andric { 2708480093f4SDimitry Andric __init(__p, __p + __len); 27090b57cec5SDimitry Andric } 27100b57cec5SDimitry Andric 27110b57cec5SDimitry Andric// basic_regex(const basic_regex&) = default; 27120b57cec5SDimitry Andric// basic_regex(basic_regex&&) = default; 27130b57cec5SDimitry Andric template <class _ST, class _SA> 2714*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 27150b57cec5SDimitry Andric explicit basic_regex(const basic_string<value_type, _ST, _SA>& __p, 27160b57cec5SDimitry Andric flag_type __f = regex_constants::ECMAScript) 27170b57cec5SDimitry Andric : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0), 2718e8d8bef9SDimitry Andric __end_(nullptr) 27190b57cec5SDimitry Andric { 2720480093f4SDimitry Andric __init(__p.begin(), __p.end()); 27210b57cec5SDimitry Andric } 27220b57cec5SDimitry Andric 27230b57cec5SDimitry Andric template <class _ForwardIterator> 2724*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 27250b57cec5SDimitry Andric basic_regex(_ForwardIterator __first, _ForwardIterator __last, 27260b57cec5SDimitry Andric flag_type __f = regex_constants::ECMAScript) 27270b57cec5SDimitry Andric : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0), 2728e8d8bef9SDimitry Andric __end_(nullptr) 27290b57cec5SDimitry Andric { 2730480093f4SDimitry Andric __init(__first, __last); 27310b57cec5SDimitry Andric } 27320b57cec5SDimitry Andric#ifndef _LIBCPP_CXX03_LANG 2733*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 27340b57cec5SDimitry Andric basic_regex(initializer_list<value_type> __il, 27350b57cec5SDimitry Andric flag_type __f = regex_constants::ECMAScript) 27360b57cec5SDimitry Andric : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0), 2737e8d8bef9SDimitry Andric __end_(nullptr) 27380b57cec5SDimitry Andric { 2739480093f4SDimitry Andric __init(__il.begin(), __il.end()); 27400b57cec5SDimitry Andric } 27410b57cec5SDimitry Andric#endif // _LIBCPP_CXX03_LANG 27420b57cec5SDimitry Andric 27430b57cec5SDimitry Andric// ~basic_regex() = default; 27440b57cec5SDimitry Andric 27450b57cec5SDimitry Andric// basic_regex& operator=(const basic_regex&) = default; 27460b57cec5SDimitry Andric// basic_regex& operator=(basic_regex&&) = default; 2747*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 27480b57cec5SDimitry Andric basic_regex& operator=(const value_type* __p) 27490b57cec5SDimitry Andric {return assign(__p);} 27500b57cec5SDimitry Andric#ifndef _LIBCPP_CXX03_LANG 2751*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 27520b57cec5SDimitry Andric basic_regex& operator=(initializer_list<value_type> __il) 27530b57cec5SDimitry Andric {return assign(__il);} 27540b57cec5SDimitry Andric#endif // _LIBCPP_CXX03_LANG 27550b57cec5SDimitry Andric template <class _ST, class _SA> 2756*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 27570b57cec5SDimitry Andric basic_regex& operator=(const basic_string<value_type, _ST, _SA>& __p) 27580b57cec5SDimitry Andric {return assign(__p);} 27590b57cec5SDimitry Andric 27600b57cec5SDimitry Andric // assign: 2761*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 27620b57cec5SDimitry Andric basic_regex& assign(const basic_regex& __that) 27630b57cec5SDimitry Andric {return *this = __that;} 27640b57cec5SDimitry Andric#ifndef _LIBCPP_CXX03_LANG 2765*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 27660b57cec5SDimitry Andric basic_regex& assign(basic_regex&& __that) _NOEXCEPT 2767*5f757f3fSDimitry Andric {return *this = std::move(__that);} 27680b57cec5SDimitry Andric#endif 2769*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 27700b57cec5SDimitry Andric basic_regex& assign(const value_type* __p, flag_type __f = regex_constants::ECMAScript) 27710b57cec5SDimitry Andric {return assign(__p, __p + __traits_.length(__p), __f);} 2772*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 2773e40139ffSDimitry Andric basic_regex& assign(const value_type* __p, size_t __len, flag_type __f = regex_constants::ECMAScript) 27740b57cec5SDimitry Andric {return assign(__p, __p + __len, __f);} 27750b57cec5SDimitry Andric template <class _ST, class _SA> 2776*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 27770b57cec5SDimitry Andric basic_regex& assign(const basic_string<value_type, _ST, _SA>& __s, 27780b57cec5SDimitry Andric flag_type __f = regex_constants::ECMAScript) 27790b57cec5SDimitry Andric {return assign(__s.begin(), __s.end(), __f);} 27800b57cec5SDimitry Andric 2781*5f757f3fSDimitry Andric template <class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value, int> = 0> 2782*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 2783*5f757f3fSDimitry Andric basic_regex& 27840b57cec5SDimitry Andric assign(_InputIterator __first, _InputIterator __last, 27850b57cec5SDimitry Andric flag_type __f = regex_constants::ECMAScript) 27860b57cec5SDimitry Andric { 27870b57cec5SDimitry Andric basic_string<_CharT> __t(__first, __last); 27880b57cec5SDimitry Andric return assign(__t.begin(), __t.end(), __f); 27890b57cec5SDimitry Andric } 27900b57cec5SDimitry Andric 27910b57cec5SDimitry Andricprivate: 2792*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 27930b57cec5SDimitry Andric void __member_init(flag_type __f) 27940b57cec5SDimitry Andric { 27950b57cec5SDimitry Andric __flags_ = __f; 27960b57cec5SDimitry Andric __marked_count_ = 0; 27970b57cec5SDimitry Andric __loop_count_ = 0; 27980b57cec5SDimitry Andric __open_count_ = 0; 27990b57cec5SDimitry Andric __end_ = nullptr; 28000b57cec5SDimitry Andric } 28010b57cec5SDimitry Andricpublic: 28020b57cec5SDimitry Andric 2803*5f757f3fSDimitry Andric template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> = 0> 2804*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 28050b57cec5SDimitry Andric basic_regex& 28060b57cec5SDimitry Andric assign(_ForwardIterator __first, _ForwardIterator __last, 28070b57cec5SDimitry Andric flag_type __f = regex_constants::ECMAScript) 28080b57cec5SDimitry Andric { 28090b57cec5SDimitry Andric return assign(basic_regex(__first, __last, __f)); 28100b57cec5SDimitry Andric } 28110b57cec5SDimitry Andric 28120b57cec5SDimitry Andric#ifndef _LIBCPP_CXX03_LANG 28130b57cec5SDimitry Andric 2814*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 28150b57cec5SDimitry Andric basic_regex& assign(initializer_list<value_type> __il, 28160b57cec5SDimitry Andric flag_type __f = regex_constants::ECMAScript) 28170b57cec5SDimitry Andric {return assign(__il.begin(), __il.end(), __f);} 28180b57cec5SDimitry Andric 28190b57cec5SDimitry Andric#endif // _LIBCPP_CXX03_LANG 28200b57cec5SDimitry Andric 28210b57cec5SDimitry Andric // const operations: 2822*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 28230b57cec5SDimitry Andric unsigned mark_count() const {return __marked_count_;} 2824*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 28250b57cec5SDimitry Andric flag_type flags() const {return __flags_;} 28260b57cec5SDimitry Andric 28270b57cec5SDimitry Andric // locale: 2828*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 28290b57cec5SDimitry Andric locale_type imbue(locale_type __loc) 28300b57cec5SDimitry Andric { 28310b57cec5SDimitry Andric __member_init(ECMAScript); 28320b57cec5SDimitry Andric __start_.reset(); 28330b57cec5SDimitry Andric return __traits_.imbue(__loc); 28340b57cec5SDimitry Andric } 2835*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 28360b57cec5SDimitry Andric locale_type getloc() const {return __traits_.getloc();} 28370b57cec5SDimitry Andric 28380b57cec5SDimitry Andric // swap: 28390b57cec5SDimitry Andric void swap(basic_regex& __r); 28400b57cec5SDimitry Andric 28410b57cec5SDimitry Andricprivate: 2842*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 28430b57cec5SDimitry Andric unsigned __loop_count() const {return __loop_count_;} 28440b57cec5SDimitry Andric 2845*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 2846e8d8bef9SDimitry Andric bool __use_multiline() const 2847e8d8bef9SDimitry Andric { 2848e8d8bef9SDimitry Andric return __get_grammar(__flags_) == ECMAScript && (__flags_ & multiline); 2849e8d8bef9SDimitry Andric } 2850e8d8bef9SDimitry Andric 28510b57cec5SDimitry Andric template <class _ForwardIterator> 2852480093f4SDimitry Andric void 2853480093f4SDimitry Andric __init(_ForwardIterator __first, _ForwardIterator __last); 2854480093f4SDimitry Andric template <class _ForwardIterator> 28550b57cec5SDimitry Andric _ForwardIterator 28560b57cec5SDimitry Andric __parse(_ForwardIterator __first, _ForwardIterator __last); 28570b57cec5SDimitry Andric template <class _ForwardIterator> 28580b57cec5SDimitry Andric _ForwardIterator 28590b57cec5SDimitry Andric __parse_basic_reg_exp(_ForwardIterator __first, _ForwardIterator __last); 28600b57cec5SDimitry Andric template <class _ForwardIterator> 28610b57cec5SDimitry Andric _ForwardIterator 28620b57cec5SDimitry Andric __parse_RE_expression(_ForwardIterator __first, _ForwardIterator __last); 28630b57cec5SDimitry Andric template <class _ForwardIterator> 28640b57cec5SDimitry Andric _ForwardIterator 28650b57cec5SDimitry Andric __parse_simple_RE(_ForwardIterator __first, _ForwardIterator __last); 28660b57cec5SDimitry Andric template <class _ForwardIterator> 28670b57cec5SDimitry Andric _ForwardIterator 28680b57cec5SDimitry Andric __parse_nondupl_RE(_ForwardIterator __first, _ForwardIterator __last); 28690b57cec5SDimitry Andric template <class _ForwardIterator> 28700b57cec5SDimitry Andric _ForwardIterator 28710b57cec5SDimitry Andric __parse_one_char_or_coll_elem_RE(_ForwardIterator __first, _ForwardIterator __last); 28720b57cec5SDimitry Andric template <class _ForwardIterator> 28730b57cec5SDimitry Andric _ForwardIterator 28740b57cec5SDimitry Andric __parse_Back_open_paren(_ForwardIterator __first, _ForwardIterator __last); 28750b57cec5SDimitry Andric template <class _ForwardIterator> 28760b57cec5SDimitry Andric _ForwardIterator 28770b57cec5SDimitry Andric __parse_Back_close_paren(_ForwardIterator __first, _ForwardIterator __last); 28780b57cec5SDimitry Andric template <class _ForwardIterator> 28790b57cec5SDimitry Andric _ForwardIterator 28800b57cec5SDimitry Andric __parse_Back_open_brace(_ForwardIterator __first, _ForwardIterator __last); 28810b57cec5SDimitry Andric template <class _ForwardIterator> 28820b57cec5SDimitry Andric _ForwardIterator 28830b57cec5SDimitry Andric __parse_Back_close_brace(_ForwardIterator __first, _ForwardIterator __last); 28840b57cec5SDimitry Andric template <class _ForwardIterator> 28850b57cec5SDimitry Andric _ForwardIterator 28860b57cec5SDimitry Andric __parse_BACKREF(_ForwardIterator __first, _ForwardIterator __last); 28870b57cec5SDimitry Andric template <class _ForwardIterator> 28880b57cec5SDimitry Andric _ForwardIterator 28890b57cec5SDimitry Andric __parse_ORD_CHAR(_ForwardIterator __first, _ForwardIterator __last); 28900b57cec5SDimitry Andric template <class _ForwardIterator> 28910b57cec5SDimitry Andric _ForwardIterator 28920b57cec5SDimitry Andric __parse_QUOTED_CHAR(_ForwardIterator __first, _ForwardIterator __last); 28930b57cec5SDimitry Andric template <class _ForwardIterator> 28940b57cec5SDimitry Andric _ForwardIterator 28950b57cec5SDimitry Andric __parse_RE_dupl_symbol(_ForwardIterator __first, _ForwardIterator __last, 28960b57cec5SDimitry Andric __owns_one_state<_CharT>* __s, 28970b57cec5SDimitry Andric unsigned __mexp_begin, unsigned __mexp_end); 28980b57cec5SDimitry Andric template <class _ForwardIterator> 28990b57cec5SDimitry Andric _ForwardIterator 29000b57cec5SDimitry Andric __parse_ERE_dupl_symbol(_ForwardIterator __first, _ForwardIterator __last, 29010b57cec5SDimitry Andric __owns_one_state<_CharT>* __s, 29020b57cec5SDimitry Andric unsigned __mexp_begin, unsigned __mexp_end); 29030b57cec5SDimitry Andric template <class _ForwardIterator> 29040b57cec5SDimitry Andric _ForwardIterator 29050b57cec5SDimitry Andric __parse_bracket_expression(_ForwardIterator __first, _ForwardIterator __last); 29060b57cec5SDimitry Andric template <class _ForwardIterator> 29070b57cec5SDimitry Andric _ForwardIterator 29080b57cec5SDimitry Andric __parse_follow_list(_ForwardIterator __first, _ForwardIterator __last, 29090b57cec5SDimitry Andric __bracket_expression<_CharT, _Traits>* __ml); 29100b57cec5SDimitry Andric template <class _ForwardIterator> 29110b57cec5SDimitry Andric _ForwardIterator 29120b57cec5SDimitry Andric __parse_expression_term(_ForwardIterator __first, _ForwardIterator __last, 29130b57cec5SDimitry Andric __bracket_expression<_CharT, _Traits>* __ml); 29140b57cec5SDimitry Andric template <class _ForwardIterator> 29150b57cec5SDimitry Andric _ForwardIterator 29160b57cec5SDimitry Andric __parse_equivalence_class(_ForwardIterator __first, _ForwardIterator __last, 29170b57cec5SDimitry Andric __bracket_expression<_CharT, _Traits>* __ml); 29180b57cec5SDimitry Andric template <class _ForwardIterator> 29190b57cec5SDimitry Andric _ForwardIterator 29200b57cec5SDimitry Andric __parse_character_class(_ForwardIterator __first, _ForwardIterator __last, 29210b57cec5SDimitry Andric __bracket_expression<_CharT, _Traits>* __ml); 29220b57cec5SDimitry Andric template <class _ForwardIterator> 29230b57cec5SDimitry Andric _ForwardIterator 29240b57cec5SDimitry Andric __parse_collating_symbol(_ForwardIterator __first, _ForwardIterator __last, 29250b57cec5SDimitry Andric basic_string<_CharT>& __col_sym); 29260b57cec5SDimitry Andric template <class _ForwardIterator> 29270b57cec5SDimitry Andric _ForwardIterator 29280b57cec5SDimitry Andric __parse_DUP_COUNT(_ForwardIterator __first, _ForwardIterator __last, int& __c); 29290b57cec5SDimitry Andric template <class _ForwardIterator> 29300b57cec5SDimitry Andric _ForwardIterator 29310b57cec5SDimitry Andric __parse_extended_reg_exp(_ForwardIterator __first, _ForwardIterator __last); 29320b57cec5SDimitry Andric template <class _ForwardIterator> 29330b57cec5SDimitry Andric _ForwardIterator 29340b57cec5SDimitry Andric __parse_ERE_branch(_ForwardIterator __first, _ForwardIterator __last); 29350b57cec5SDimitry Andric template <class _ForwardIterator> 29360b57cec5SDimitry Andric _ForwardIterator 29370b57cec5SDimitry Andric __parse_ERE_expression(_ForwardIterator __first, _ForwardIterator __last); 29380b57cec5SDimitry Andric template <class _ForwardIterator> 29390b57cec5SDimitry Andric _ForwardIterator 29400b57cec5SDimitry Andric __parse_one_char_or_coll_elem_ERE(_ForwardIterator __first, _ForwardIterator __last); 29410b57cec5SDimitry Andric template <class _ForwardIterator> 29420b57cec5SDimitry Andric _ForwardIterator 29430b57cec5SDimitry Andric __parse_ORD_CHAR_ERE(_ForwardIterator __first, _ForwardIterator __last); 29440b57cec5SDimitry Andric template <class _ForwardIterator> 29450b57cec5SDimitry Andric _ForwardIterator 29460b57cec5SDimitry Andric __parse_QUOTED_CHAR_ERE(_ForwardIterator __first, _ForwardIterator __last); 29470b57cec5SDimitry Andric template <class _ForwardIterator> 29480b57cec5SDimitry Andric _ForwardIterator 29490b57cec5SDimitry Andric __parse_ecma_exp(_ForwardIterator __first, _ForwardIterator __last); 29500b57cec5SDimitry Andric template <class _ForwardIterator> 29510b57cec5SDimitry Andric _ForwardIterator 29520b57cec5SDimitry Andric __parse_alternative(_ForwardIterator __first, _ForwardIterator __last); 29530b57cec5SDimitry Andric template <class _ForwardIterator> 29540b57cec5SDimitry Andric _ForwardIterator 29550b57cec5SDimitry Andric __parse_term(_ForwardIterator __first, _ForwardIterator __last); 29560b57cec5SDimitry Andric template <class _ForwardIterator> 29570b57cec5SDimitry Andric _ForwardIterator 29580b57cec5SDimitry Andric __parse_assertion(_ForwardIterator __first, _ForwardIterator __last); 29590b57cec5SDimitry Andric template <class _ForwardIterator> 29600b57cec5SDimitry Andric _ForwardIterator 29610b57cec5SDimitry Andric __parse_atom(_ForwardIterator __first, _ForwardIterator __last); 29620b57cec5SDimitry Andric template <class _ForwardIterator> 29630b57cec5SDimitry Andric _ForwardIterator 29640b57cec5SDimitry Andric __parse_atom_escape(_ForwardIterator __first, _ForwardIterator __last); 29650b57cec5SDimitry Andric template <class _ForwardIterator> 29660b57cec5SDimitry Andric _ForwardIterator 29670b57cec5SDimitry Andric __parse_decimal_escape(_ForwardIterator __first, _ForwardIterator __last); 29680b57cec5SDimitry Andric template <class _ForwardIterator> 29690b57cec5SDimitry Andric _ForwardIterator 29700b57cec5SDimitry Andric __parse_character_class_escape(_ForwardIterator __first, _ForwardIterator __last); 29710b57cec5SDimitry Andric template <class _ForwardIterator> 29720b57cec5SDimitry Andric _ForwardIterator 29730b57cec5SDimitry Andric __parse_character_escape(_ForwardIterator __first, _ForwardIterator __last, 29740b57cec5SDimitry Andric basic_string<_CharT>* __str = nullptr); 29750b57cec5SDimitry Andric template <class _ForwardIterator> 29760b57cec5SDimitry Andric _ForwardIterator 29770b57cec5SDimitry Andric __parse_pattern_character(_ForwardIterator __first, _ForwardIterator __last); 29780b57cec5SDimitry Andric template <class _ForwardIterator> 29790b57cec5SDimitry Andric _ForwardIterator 29800b57cec5SDimitry Andric __parse_grep(_ForwardIterator __first, _ForwardIterator __last); 29810b57cec5SDimitry Andric template <class _ForwardIterator> 29820b57cec5SDimitry Andric _ForwardIterator 29830b57cec5SDimitry Andric __parse_egrep(_ForwardIterator __first, _ForwardIterator __last); 29840b57cec5SDimitry Andric template <class _ForwardIterator> 29850b57cec5SDimitry Andric _ForwardIterator 29860b57cec5SDimitry Andric __parse_class_escape(_ForwardIterator __first, _ForwardIterator __last, 29870b57cec5SDimitry Andric basic_string<_CharT>& __str, 29880b57cec5SDimitry Andric __bracket_expression<_CharT, _Traits>* __ml); 29890b57cec5SDimitry Andric template <class _ForwardIterator> 29900b57cec5SDimitry Andric _ForwardIterator 29910b57cec5SDimitry Andric __parse_awk_escape(_ForwardIterator __first, _ForwardIterator __last, 29920b57cec5SDimitry Andric basic_string<_CharT>* __str = nullptr); 29930b57cec5SDimitry Andric 2994753f127fSDimitry Andric bool __test_back_ref(_CharT); 29955ffd83dbSDimitry Andric 2996*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 29970b57cec5SDimitry Andric void __push_l_anchor(); 29980b57cec5SDimitry Andric void __push_r_anchor(); 29990b57cec5SDimitry Andric void __push_match_any(); 30000b57cec5SDimitry Andric void __push_match_any_but_newline(); 3001*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 30020b57cec5SDimitry Andric void __push_greedy_inf_repeat(size_t __min, __owns_one_state<_CharT>* __s, 30030b57cec5SDimitry Andric unsigned __mexp_begin = 0, unsigned __mexp_end = 0) 30040b57cec5SDimitry Andric {__push_loop(__min, numeric_limits<size_t>::max(), __s, 30050b57cec5SDimitry Andric __mexp_begin, __mexp_end);} 3006*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 30070b57cec5SDimitry Andric void __push_nongreedy_inf_repeat(size_t __min, __owns_one_state<_CharT>* __s, 30080b57cec5SDimitry Andric unsigned __mexp_begin = 0, unsigned __mexp_end = 0) 30090b57cec5SDimitry Andric {__push_loop(__min, numeric_limits<size_t>::max(), __s, 30100b57cec5SDimitry Andric __mexp_begin, __mexp_end, false);} 30110b57cec5SDimitry Andric void __push_loop(size_t __min, size_t __max, __owns_one_state<_CharT>* __s, 30120b57cec5SDimitry Andric size_t __mexp_begin = 0, size_t __mexp_end = 0, 30130b57cec5SDimitry Andric bool __greedy = true); 30140b57cec5SDimitry Andric __bracket_expression<_CharT, _Traits>* __start_matching_list(bool __negate); 30150b57cec5SDimitry Andric void __push_char(value_type __c); 30160b57cec5SDimitry Andric void __push_back_ref(int __i); 30170b57cec5SDimitry Andric void __push_alternation(__owns_one_state<_CharT>* __sa, 30180b57cec5SDimitry Andric __owns_one_state<_CharT>* __sb); 30190b57cec5SDimitry Andric void __push_begin_marked_subexpression(); 30200b57cec5SDimitry Andric void __push_end_marked_subexpression(unsigned); 30210b57cec5SDimitry Andric void __push_empty(); 30220b57cec5SDimitry Andric void __push_word_boundary(bool); 30230b57cec5SDimitry Andric void __push_lookahead(const basic_regex&, bool, unsigned); 30240b57cec5SDimitry Andric 30250b57cec5SDimitry Andric template <class _Allocator> 30260b57cec5SDimitry Andric bool 30270b57cec5SDimitry Andric __search(const _CharT* __first, const _CharT* __last, 30280b57cec5SDimitry Andric match_results<const _CharT*, _Allocator>& __m, 30290b57cec5SDimitry Andric regex_constants::match_flag_type __flags) const; 30300b57cec5SDimitry Andric 30310b57cec5SDimitry Andric template <class _Allocator> 30320b57cec5SDimitry Andric bool 30330b57cec5SDimitry Andric __match_at_start(const _CharT* __first, const _CharT* __last, 30340b57cec5SDimitry Andric match_results<const _CharT*, _Allocator>& __m, 30350b57cec5SDimitry Andric regex_constants::match_flag_type __flags, bool) const; 30360b57cec5SDimitry Andric template <class _Allocator> 30370b57cec5SDimitry Andric bool 30380b57cec5SDimitry Andric __match_at_start_ecma(const _CharT* __first, const _CharT* __last, 30390b57cec5SDimitry Andric match_results<const _CharT*, _Allocator>& __m, 30400b57cec5SDimitry Andric regex_constants::match_flag_type __flags, bool) const; 30410b57cec5SDimitry Andric template <class _Allocator> 30420b57cec5SDimitry Andric bool 30430b57cec5SDimitry Andric __match_at_start_posix_nosubs(const _CharT* __first, const _CharT* __last, 30440b57cec5SDimitry Andric match_results<const _CharT*, _Allocator>& __m, 30450b57cec5SDimitry Andric regex_constants::match_flag_type __flags, bool) const; 30460b57cec5SDimitry Andric template <class _Allocator> 30470b57cec5SDimitry Andric bool 30480b57cec5SDimitry Andric __match_at_start_posix_subs(const _CharT* __first, const _CharT* __last, 30490b57cec5SDimitry Andric match_results<const _CharT*, _Allocator>& __m, 30500b57cec5SDimitry Andric regex_constants::match_flag_type __flags, bool) const; 30510b57cec5SDimitry Andric 30520b57cec5SDimitry Andric template <class _Bp, class _Ap, class _Cp, class _Tp> 30530b57cec5SDimitry Andric friend 30540b57cec5SDimitry Andric bool 30550b57cec5SDimitry Andric regex_search(_Bp, _Bp, match_results<_Bp, _Ap>&, const basic_regex<_Cp, _Tp>&, 30560b57cec5SDimitry Andric regex_constants::match_flag_type); 30570b57cec5SDimitry Andric 30580b57cec5SDimitry Andric template <class _Ap, class _Cp, class _Tp> 30590b57cec5SDimitry Andric friend 30600b57cec5SDimitry Andric bool 30610b57cec5SDimitry Andric regex_search(const _Cp*, const _Cp*, match_results<const _Cp*, _Ap>&, 30620b57cec5SDimitry Andric const basic_regex<_Cp, _Tp>&, regex_constants::match_flag_type); 30630b57cec5SDimitry Andric 30640b57cec5SDimitry Andric template <class _Bp, class _Cp, class _Tp> 30650b57cec5SDimitry Andric friend 30660b57cec5SDimitry Andric bool 30670b57cec5SDimitry Andric regex_search(_Bp, _Bp, const basic_regex<_Cp, _Tp>&, 30680b57cec5SDimitry Andric regex_constants::match_flag_type); 30690b57cec5SDimitry Andric 30700b57cec5SDimitry Andric template <class _Cp, class _Tp> 30710b57cec5SDimitry Andric friend 30720b57cec5SDimitry Andric bool 30730b57cec5SDimitry Andric regex_search(const _Cp*, const _Cp*, 30740b57cec5SDimitry Andric const basic_regex<_Cp, _Tp>&, regex_constants::match_flag_type); 30750b57cec5SDimitry Andric 30760b57cec5SDimitry Andric template <class _Cp, class _Ap, class _Tp> 30770b57cec5SDimitry Andric friend 30780b57cec5SDimitry Andric bool 30790b57cec5SDimitry Andric regex_search(const _Cp*, match_results<const _Cp*, _Ap>&, const basic_regex<_Cp, _Tp>&, 30800b57cec5SDimitry Andric regex_constants::match_flag_type); 30810b57cec5SDimitry Andric 30820b57cec5SDimitry Andric template <class _ST, class _SA, class _Cp, class _Tp> 30830b57cec5SDimitry Andric friend 30840b57cec5SDimitry Andric bool 30850b57cec5SDimitry Andric regex_search(const basic_string<_Cp, _ST, _SA>& __s, 30860b57cec5SDimitry Andric const basic_regex<_Cp, _Tp>& __e, 30870b57cec5SDimitry Andric regex_constants::match_flag_type __flags); 30880b57cec5SDimitry Andric 30890b57cec5SDimitry Andric template <class _ST, class _SA, class _Ap, class _Cp, class _Tp> 30900b57cec5SDimitry Andric friend 30910b57cec5SDimitry Andric bool 30920b57cec5SDimitry Andric regex_search(const basic_string<_Cp, _ST, _SA>& __s, 30930b57cec5SDimitry Andric match_results<typename basic_string<_Cp, _ST, _SA>::const_iterator, _Ap>&, 30940b57cec5SDimitry Andric const basic_regex<_Cp, _Tp>& __e, 30950b57cec5SDimitry Andric regex_constants::match_flag_type __flags); 30960b57cec5SDimitry Andric 30970b57cec5SDimitry Andric template <class _Iter, class _Ap, class _Cp, class _Tp> 30980b57cec5SDimitry Andric friend 30990b57cec5SDimitry Andric bool 31000b57cec5SDimitry Andric regex_search(__wrap_iter<_Iter> __first, 31010b57cec5SDimitry Andric __wrap_iter<_Iter> __last, 31020b57cec5SDimitry Andric match_results<__wrap_iter<_Iter>, _Ap>& __m, 31030b57cec5SDimitry Andric const basic_regex<_Cp, _Tp>& __e, 31040b57cec5SDimitry Andric regex_constants::match_flag_type __flags); 31050b57cec5SDimitry Andric 31060b57cec5SDimitry Andric template <class, class> friend class __lookahead; 31070b57cec5SDimitry Andric}; 31080b57cec5SDimitry Andric 3109349cc55cSDimitry Andric#if _LIBCPP_STD_VER >= 17 31100b57cec5SDimitry Andrictemplate <class _ForwardIterator, 3111*5f757f3fSDimitry Andric __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> = 0> 31120b57cec5SDimitry Andricbasic_regex(_ForwardIterator, _ForwardIterator, 31130b57cec5SDimitry Andric regex_constants::syntax_option_type = regex_constants::ECMAScript) 31140b57cec5SDimitry Andric -> basic_regex<typename iterator_traits<_ForwardIterator>::value_type>; 31150b57cec5SDimitry Andric#endif 31160b57cec5SDimitry Andric 31170b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 31180b57cec5SDimitry Andric const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::icase; 31190b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 31200b57cec5SDimitry Andric const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::nosubs; 31210b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 31220b57cec5SDimitry Andric const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::optimize; 31230b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 31240b57cec5SDimitry Andric const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::collate; 31250b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 31260b57cec5SDimitry Andric const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::ECMAScript; 31270b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 31280b57cec5SDimitry Andric const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::basic; 31290b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 31300b57cec5SDimitry Andric const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::extended; 31310b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 31320b57cec5SDimitry Andric const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::awk; 31330b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 31340b57cec5SDimitry Andric const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::grep; 31350b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 31360b57cec5SDimitry Andric const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::egrep; 31370b57cec5SDimitry Andric 31380b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 31390b57cec5SDimitry Andricvoid 31400b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::swap(basic_regex& __r) 31410b57cec5SDimitry Andric{ 3142*5f757f3fSDimitry Andric using std::swap; 31430b57cec5SDimitry Andric swap(__traits_, __r.__traits_); 31440b57cec5SDimitry Andric swap(__flags_, __r.__flags_); 31450b57cec5SDimitry Andric swap(__marked_count_, __r.__marked_count_); 31460b57cec5SDimitry Andric swap(__loop_count_, __r.__loop_count_); 31470b57cec5SDimitry Andric swap(__open_count_, __r.__open_count_); 31480b57cec5SDimitry Andric swap(__start_, __r.__start_); 31490b57cec5SDimitry Andric swap(__end_, __r.__end_); 31500b57cec5SDimitry Andric} 31510b57cec5SDimitry Andric 31520b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 3153*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 31540b57cec5SDimitry Andricvoid 31550b57cec5SDimitry Andricswap(basic_regex<_CharT, _Traits>& __x, basic_regex<_CharT, _Traits>& __y) 31560b57cec5SDimitry Andric{ 31570b57cec5SDimitry Andric return __x.swap(__y); 31580b57cec5SDimitry Andric} 31590b57cec5SDimitry Andric 31600b57cec5SDimitry Andric// __lookahead 31610b57cec5SDimitry Andric 31620b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 31630b57cec5SDimitry Andricclass __lookahead 31640b57cec5SDimitry Andric : public __owns_one_state<_CharT> 31650b57cec5SDimitry Andric{ 31660b57cec5SDimitry Andric typedef __owns_one_state<_CharT> base; 31670b57cec5SDimitry Andric 31680b57cec5SDimitry Andric basic_regex<_CharT, _Traits> __exp_; 31690b57cec5SDimitry Andric unsigned __mexp_; 31700b57cec5SDimitry Andric bool __invert_; 31710b57cec5SDimitry Andric 31720b57cec5SDimitry Andric __lookahead(const __lookahead&); 31730b57cec5SDimitry Andric __lookahead& operator=(const __lookahead&); 31740b57cec5SDimitry Andricpublic: 3175*5f757f3fSDimitry Andric typedef std::__state<_CharT> __state; 31760b57cec5SDimitry Andric 3177*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 31780b57cec5SDimitry Andric __lookahead(const basic_regex<_CharT, _Traits>& __exp, bool __invert, __node<_CharT>* __s, unsigned __mexp) 31790b57cec5SDimitry Andric : base(__s), __exp_(__exp), __mexp_(__mexp), __invert_(__invert) {} 31800b57cec5SDimitry Andric 318106c3fb27SDimitry Andric _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const; 31820b57cec5SDimitry Andric}; 31830b57cec5SDimitry Andric 31840b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 31850b57cec5SDimitry Andricvoid 31860b57cec5SDimitry Andric__lookahead<_CharT, _Traits>::__exec(__state& __s) const 31870b57cec5SDimitry Andric{ 31880b57cec5SDimitry Andric match_results<const _CharT*> __m; 31890b57cec5SDimitry Andric __m.__init(1 + __exp_.mark_count(), __s.__current_, __s.__last_); 31900b57cec5SDimitry Andric bool __matched = __exp_.__match_at_start_ecma( 31910b57cec5SDimitry Andric __s.__current_, __s.__last_, 31920b57cec5SDimitry Andric __m, 31930b57cec5SDimitry Andric (__s.__flags_ | regex_constants::match_continuous) & 31940b57cec5SDimitry Andric ~regex_constants::__full_match, 31950b57cec5SDimitry Andric __s.__at_first_ && __s.__current_ == __s.__first_); 31960b57cec5SDimitry Andric if (__matched != __invert_) 31970b57cec5SDimitry Andric { 31980b57cec5SDimitry Andric __s.__do_ = __state::__accept_but_not_consume; 31990b57cec5SDimitry Andric __s.__node_ = this->first(); 32000b57cec5SDimitry Andric for (unsigned __i = 1; __i < __m.size(); ++__i) { 32010b57cec5SDimitry Andric __s.__sub_matches_[__mexp_ + __i - 1] = __m.__matches_[__i]; 32020b57cec5SDimitry Andric } 32030b57cec5SDimitry Andric } 32040b57cec5SDimitry Andric else 32050b57cec5SDimitry Andric { 32060b57cec5SDimitry Andric __s.__do_ = __state::__reject; 32070b57cec5SDimitry Andric __s.__node_ = nullptr; 32080b57cec5SDimitry Andric } 32090b57cec5SDimitry Andric} 32100b57cec5SDimitry Andric 32110b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 32120b57cec5SDimitry Andrictemplate <class _ForwardIterator> 3213480093f4SDimitry Andricvoid 3214480093f4SDimitry Andricbasic_regex<_CharT, _Traits>::__init(_ForwardIterator __first, _ForwardIterator __last) 3215480093f4SDimitry Andric{ 3216480093f4SDimitry Andric if (__get_grammar(__flags_) == 0) __flags_ |= regex_constants::ECMAScript; 3217480093f4SDimitry Andric _ForwardIterator __temp = __parse(__first, __last); 3218480093f4SDimitry Andric if ( __temp != __last) 3219480093f4SDimitry Andric __throw_regex_error<regex_constants::__re_err_parse>(); 3220480093f4SDimitry Andric} 3221480093f4SDimitry Andric 3222480093f4SDimitry Andrictemplate <class _CharT, class _Traits> 3223480093f4SDimitry Andrictemplate <class _ForwardIterator> 32240b57cec5SDimitry Andric_ForwardIterator 32250b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse(_ForwardIterator __first, 32260b57cec5SDimitry Andric _ForwardIterator __last) 32270b57cec5SDimitry Andric{ 32280b57cec5SDimitry Andric { 32290b57cec5SDimitry Andric unique_ptr<__node> __h(new __end_state<_CharT>); 32300b57cec5SDimitry Andric __start_.reset(new __empty_state<_CharT>(__h.get())); 32310b57cec5SDimitry Andric __h.release(); 32320b57cec5SDimitry Andric __end_ = __start_.get(); 32330b57cec5SDimitry Andric } 32340b57cec5SDimitry Andric switch (__get_grammar(__flags_)) 32350b57cec5SDimitry Andric { 32360b57cec5SDimitry Andric case ECMAScript: 32370b57cec5SDimitry Andric __first = __parse_ecma_exp(__first, __last); 32380b57cec5SDimitry Andric break; 32390b57cec5SDimitry Andric case basic: 32400b57cec5SDimitry Andric __first = __parse_basic_reg_exp(__first, __last); 32410b57cec5SDimitry Andric break; 32420b57cec5SDimitry Andric case extended: 32430b57cec5SDimitry Andric case awk: 32440b57cec5SDimitry Andric __first = __parse_extended_reg_exp(__first, __last); 32450b57cec5SDimitry Andric break; 32460b57cec5SDimitry Andric case grep: 32470b57cec5SDimitry Andric __first = __parse_grep(__first, __last); 32480b57cec5SDimitry Andric break; 32490b57cec5SDimitry Andric case egrep: 32500b57cec5SDimitry Andric __first = __parse_egrep(__first, __last); 32510b57cec5SDimitry Andric break; 32520b57cec5SDimitry Andric default: 32530b57cec5SDimitry Andric __throw_regex_error<regex_constants::__re_err_grammar>(); 32540b57cec5SDimitry Andric } 32550b57cec5SDimitry Andric return __first; 32560b57cec5SDimitry Andric} 32570b57cec5SDimitry Andric 32580b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 32590b57cec5SDimitry Andrictemplate <class _ForwardIterator> 32600b57cec5SDimitry Andric_ForwardIterator 32610b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_basic_reg_exp(_ForwardIterator __first, 32620b57cec5SDimitry Andric _ForwardIterator __last) 32630b57cec5SDimitry Andric{ 32640b57cec5SDimitry Andric if (__first != __last) 32650b57cec5SDimitry Andric { 32660b57cec5SDimitry Andric if (*__first == '^') 32670b57cec5SDimitry Andric { 32680b57cec5SDimitry Andric __push_l_anchor(); 32690b57cec5SDimitry Andric ++__first; 32700b57cec5SDimitry Andric } 32710b57cec5SDimitry Andric if (__first != __last) 32720b57cec5SDimitry Andric { 32730b57cec5SDimitry Andric __first = __parse_RE_expression(__first, __last); 32740b57cec5SDimitry Andric if (__first != __last) 32750b57cec5SDimitry Andric { 3276*5f757f3fSDimitry Andric _ForwardIterator __temp = std::next(__first); 32770b57cec5SDimitry Andric if (__temp == __last && *__first == '$') 32780b57cec5SDimitry Andric { 32790b57cec5SDimitry Andric __push_r_anchor(); 32800b57cec5SDimitry Andric ++__first; 32810b57cec5SDimitry Andric } 32820b57cec5SDimitry Andric } 32830b57cec5SDimitry Andric } 32840b57cec5SDimitry Andric if (__first != __last) 32850b57cec5SDimitry Andric __throw_regex_error<regex_constants::__re_err_empty>(); 32860b57cec5SDimitry Andric } 32870b57cec5SDimitry Andric return __first; 32880b57cec5SDimitry Andric} 32890b57cec5SDimitry Andric 32900b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 32910b57cec5SDimitry Andrictemplate <class _ForwardIterator> 32920b57cec5SDimitry Andric_ForwardIterator 32930b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_extended_reg_exp(_ForwardIterator __first, 32940b57cec5SDimitry Andric _ForwardIterator __last) 32950b57cec5SDimitry Andric{ 32960b57cec5SDimitry Andric __owns_one_state<_CharT>* __sa = __end_; 32970b57cec5SDimitry Andric _ForwardIterator __temp = __parse_ERE_branch(__first, __last); 32980b57cec5SDimitry Andric if (__temp == __first) 32990b57cec5SDimitry Andric __throw_regex_error<regex_constants::__re_err_empty>(); 33000b57cec5SDimitry Andric __first = __temp; 33010b57cec5SDimitry Andric while (__first != __last && *__first == '|') 33020b57cec5SDimitry Andric { 33030b57cec5SDimitry Andric __owns_one_state<_CharT>* __sb = __end_; 33040b57cec5SDimitry Andric __temp = __parse_ERE_branch(++__first, __last); 33050b57cec5SDimitry Andric if (__temp == __first) 33060b57cec5SDimitry Andric __throw_regex_error<regex_constants::__re_err_empty>(); 33070b57cec5SDimitry Andric __push_alternation(__sa, __sb); 33080b57cec5SDimitry Andric __first = __temp; 33090b57cec5SDimitry Andric } 33100b57cec5SDimitry Andric return __first; 33110b57cec5SDimitry Andric} 33120b57cec5SDimitry Andric 33130b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 33140b57cec5SDimitry Andrictemplate <class _ForwardIterator> 33150b57cec5SDimitry Andric_ForwardIterator 33160b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_ERE_branch(_ForwardIterator __first, 33170b57cec5SDimitry Andric _ForwardIterator __last) 33180b57cec5SDimitry Andric{ 33190b57cec5SDimitry Andric _ForwardIterator __temp = __parse_ERE_expression(__first, __last); 33200b57cec5SDimitry Andric if (__temp == __first) 33210b57cec5SDimitry Andric __throw_regex_error<regex_constants::__re_err_empty>(); 33220b57cec5SDimitry Andric do 33230b57cec5SDimitry Andric { 33240b57cec5SDimitry Andric __first = __temp; 33250b57cec5SDimitry Andric __temp = __parse_ERE_expression(__first, __last); 33260b57cec5SDimitry Andric } while (__temp != __first); 33270b57cec5SDimitry Andric return __first; 33280b57cec5SDimitry Andric} 33290b57cec5SDimitry Andric 33300b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 33310b57cec5SDimitry Andrictemplate <class _ForwardIterator> 33320b57cec5SDimitry Andric_ForwardIterator 33330b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_ERE_expression(_ForwardIterator __first, 33340b57cec5SDimitry Andric _ForwardIterator __last) 33350b57cec5SDimitry Andric{ 33360b57cec5SDimitry Andric __owns_one_state<_CharT>* __e = __end_; 33370b57cec5SDimitry Andric unsigned __mexp_begin = __marked_count_; 33380b57cec5SDimitry Andric _ForwardIterator __temp = __parse_one_char_or_coll_elem_ERE(__first, __last); 33390b57cec5SDimitry Andric if (__temp == __first && __temp != __last) 33400b57cec5SDimitry Andric { 33410b57cec5SDimitry Andric switch (*__temp) 33420b57cec5SDimitry Andric { 33430b57cec5SDimitry Andric case '^': 33440b57cec5SDimitry Andric __push_l_anchor(); 33450b57cec5SDimitry Andric ++__temp; 33460b57cec5SDimitry Andric break; 33470b57cec5SDimitry Andric case '$': 33480b57cec5SDimitry Andric __push_r_anchor(); 33490b57cec5SDimitry Andric ++__temp; 33500b57cec5SDimitry Andric break; 33510b57cec5SDimitry Andric case '(': 33520b57cec5SDimitry Andric __push_begin_marked_subexpression(); 33530b57cec5SDimitry Andric unsigned __temp_count = __marked_count_; 33540b57cec5SDimitry Andric ++__open_count_; 33550b57cec5SDimitry Andric __temp = __parse_extended_reg_exp(++__temp, __last); 33560b57cec5SDimitry Andric if (__temp == __last || *__temp != ')') 33570b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_paren>(); 33580b57cec5SDimitry Andric __push_end_marked_subexpression(__temp_count); 33590b57cec5SDimitry Andric --__open_count_; 33600b57cec5SDimitry Andric ++__temp; 33610b57cec5SDimitry Andric break; 33620b57cec5SDimitry Andric } 33630b57cec5SDimitry Andric } 33640b57cec5SDimitry Andric if (__temp != __first) 33650b57cec5SDimitry Andric __temp = __parse_ERE_dupl_symbol(__temp, __last, __e, __mexp_begin+1, 33660b57cec5SDimitry Andric __marked_count_+1); 33670b57cec5SDimitry Andric __first = __temp; 33680b57cec5SDimitry Andric return __first; 33690b57cec5SDimitry Andric} 33700b57cec5SDimitry Andric 33710b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 33720b57cec5SDimitry Andrictemplate <class _ForwardIterator> 33730b57cec5SDimitry Andric_ForwardIterator 33740b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_RE_expression(_ForwardIterator __first, 33750b57cec5SDimitry Andric _ForwardIterator __last) 33760b57cec5SDimitry Andric{ 33770b57cec5SDimitry Andric while (true) 33780b57cec5SDimitry Andric { 33790b57cec5SDimitry Andric _ForwardIterator __temp = __parse_simple_RE(__first, __last); 33800b57cec5SDimitry Andric if (__temp == __first) 33810b57cec5SDimitry Andric break; 33820b57cec5SDimitry Andric __first = __temp; 33830b57cec5SDimitry Andric } 33840b57cec5SDimitry Andric return __first; 33850b57cec5SDimitry Andric} 33860b57cec5SDimitry Andric 33870b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 33880b57cec5SDimitry Andrictemplate <class _ForwardIterator> 33890b57cec5SDimitry Andric_ForwardIterator 33900b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_simple_RE(_ForwardIterator __first, 33910b57cec5SDimitry Andric _ForwardIterator __last) 33920b57cec5SDimitry Andric{ 33930b57cec5SDimitry Andric if (__first != __last) 33940b57cec5SDimitry Andric { 33950b57cec5SDimitry Andric __owns_one_state<_CharT>* __e = __end_; 33960b57cec5SDimitry Andric unsigned __mexp_begin = __marked_count_; 33970b57cec5SDimitry Andric _ForwardIterator __temp = __parse_nondupl_RE(__first, __last); 33980b57cec5SDimitry Andric if (__temp != __first) 33990b57cec5SDimitry Andric __first = __parse_RE_dupl_symbol(__temp, __last, __e, 34000b57cec5SDimitry Andric __mexp_begin+1, __marked_count_+1); 34010b57cec5SDimitry Andric } 34020b57cec5SDimitry Andric return __first; 34030b57cec5SDimitry Andric} 34040b57cec5SDimitry Andric 34050b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 34060b57cec5SDimitry Andrictemplate <class _ForwardIterator> 34070b57cec5SDimitry Andric_ForwardIterator 34080b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_nondupl_RE(_ForwardIterator __first, 34090b57cec5SDimitry Andric _ForwardIterator __last) 34100b57cec5SDimitry Andric{ 34110b57cec5SDimitry Andric _ForwardIterator __temp = __first; 34120b57cec5SDimitry Andric __first = __parse_one_char_or_coll_elem_RE(__first, __last); 34130b57cec5SDimitry Andric if (__temp == __first) 34140b57cec5SDimitry Andric { 34150b57cec5SDimitry Andric __temp = __parse_Back_open_paren(__first, __last); 34160b57cec5SDimitry Andric if (__temp != __first) 34170b57cec5SDimitry Andric { 34180b57cec5SDimitry Andric __push_begin_marked_subexpression(); 34190b57cec5SDimitry Andric unsigned __temp_count = __marked_count_; 34200b57cec5SDimitry Andric __first = __parse_RE_expression(__temp, __last); 34210b57cec5SDimitry Andric __temp = __parse_Back_close_paren(__first, __last); 34220b57cec5SDimitry Andric if (__temp == __first) 34230b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_paren>(); 34240b57cec5SDimitry Andric __push_end_marked_subexpression(__temp_count); 34250b57cec5SDimitry Andric __first = __temp; 34260b57cec5SDimitry Andric } 34270b57cec5SDimitry Andric else 34280b57cec5SDimitry Andric __first = __parse_BACKREF(__first, __last); 34290b57cec5SDimitry Andric } 34300b57cec5SDimitry Andric return __first; 34310b57cec5SDimitry Andric} 34320b57cec5SDimitry Andric 34330b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 34340b57cec5SDimitry Andrictemplate <class _ForwardIterator> 34350b57cec5SDimitry Andric_ForwardIterator 34360b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_one_char_or_coll_elem_RE( 34370b57cec5SDimitry Andric _ForwardIterator __first, 34380b57cec5SDimitry Andric _ForwardIterator __last) 34390b57cec5SDimitry Andric{ 34400b57cec5SDimitry Andric _ForwardIterator __temp = __parse_ORD_CHAR(__first, __last); 34410b57cec5SDimitry Andric if (__temp == __first) 34420b57cec5SDimitry Andric { 34430b57cec5SDimitry Andric __temp = __parse_QUOTED_CHAR(__first, __last); 34440b57cec5SDimitry Andric if (__temp == __first) 34450b57cec5SDimitry Andric { 34460b57cec5SDimitry Andric if (__temp != __last && *__temp == '.') 34470b57cec5SDimitry Andric { 34480b57cec5SDimitry Andric __push_match_any(); 34490b57cec5SDimitry Andric ++__temp; 34500b57cec5SDimitry Andric } 34510b57cec5SDimitry Andric else 34520b57cec5SDimitry Andric __temp = __parse_bracket_expression(__first, __last); 34530b57cec5SDimitry Andric } 34540b57cec5SDimitry Andric } 34550b57cec5SDimitry Andric __first = __temp; 34560b57cec5SDimitry Andric return __first; 34570b57cec5SDimitry Andric} 34580b57cec5SDimitry Andric 34590b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 34600b57cec5SDimitry Andrictemplate <class _ForwardIterator> 34610b57cec5SDimitry Andric_ForwardIterator 34620b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_one_char_or_coll_elem_ERE( 34630b57cec5SDimitry Andric _ForwardIterator __first, 34640b57cec5SDimitry Andric _ForwardIterator __last) 34650b57cec5SDimitry Andric{ 34660b57cec5SDimitry Andric _ForwardIterator __temp = __parse_ORD_CHAR_ERE(__first, __last); 34670b57cec5SDimitry Andric if (__temp == __first) 34680b57cec5SDimitry Andric { 34690b57cec5SDimitry Andric __temp = __parse_QUOTED_CHAR_ERE(__first, __last); 34700b57cec5SDimitry Andric if (__temp == __first) 34710b57cec5SDimitry Andric { 34720b57cec5SDimitry Andric if (__temp != __last && *__temp == '.') 34730b57cec5SDimitry Andric { 34740b57cec5SDimitry Andric __push_match_any(); 34750b57cec5SDimitry Andric ++__temp; 34760b57cec5SDimitry Andric } 34770b57cec5SDimitry Andric else 34780b57cec5SDimitry Andric __temp = __parse_bracket_expression(__first, __last); 34790b57cec5SDimitry Andric } 34800b57cec5SDimitry Andric } 34810b57cec5SDimitry Andric __first = __temp; 34820b57cec5SDimitry Andric return __first; 34830b57cec5SDimitry Andric} 34840b57cec5SDimitry Andric 34850b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 34860b57cec5SDimitry Andrictemplate <class _ForwardIterator> 34870b57cec5SDimitry Andric_ForwardIterator 34880b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_Back_open_paren(_ForwardIterator __first, 34890b57cec5SDimitry Andric _ForwardIterator __last) 34900b57cec5SDimitry Andric{ 34910b57cec5SDimitry Andric if (__first != __last) 34920b57cec5SDimitry Andric { 3493*5f757f3fSDimitry Andric _ForwardIterator __temp = std::next(__first); 34940b57cec5SDimitry Andric if (__temp != __last) 34950b57cec5SDimitry Andric { 34960b57cec5SDimitry Andric if (*__first == '\\' && *__temp == '(') 34970b57cec5SDimitry Andric __first = ++__temp; 34980b57cec5SDimitry Andric } 34990b57cec5SDimitry Andric } 35000b57cec5SDimitry Andric return __first; 35010b57cec5SDimitry Andric} 35020b57cec5SDimitry Andric 35030b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 35040b57cec5SDimitry Andrictemplate <class _ForwardIterator> 35050b57cec5SDimitry Andric_ForwardIterator 35060b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_Back_close_paren(_ForwardIterator __first, 35070b57cec5SDimitry Andric _ForwardIterator __last) 35080b57cec5SDimitry Andric{ 35090b57cec5SDimitry Andric if (__first != __last) 35100b57cec5SDimitry Andric { 3511*5f757f3fSDimitry Andric _ForwardIterator __temp = std::next(__first); 35120b57cec5SDimitry Andric if (__temp != __last) 35130b57cec5SDimitry Andric { 35140b57cec5SDimitry Andric if (*__first == '\\' && *__temp == ')') 35150b57cec5SDimitry Andric __first = ++__temp; 35160b57cec5SDimitry Andric } 35170b57cec5SDimitry Andric } 35180b57cec5SDimitry Andric return __first; 35190b57cec5SDimitry Andric} 35200b57cec5SDimitry Andric 35210b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 35220b57cec5SDimitry Andrictemplate <class _ForwardIterator> 35230b57cec5SDimitry Andric_ForwardIterator 35240b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_Back_open_brace(_ForwardIterator __first, 35250b57cec5SDimitry Andric _ForwardIterator __last) 35260b57cec5SDimitry Andric{ 35270b57cec5SDimitry Andric if (__first != __last) 35280b57cec5SDimitry Andric { 3529*5f757f3fSDimitry Andric _ForwardIterator __temp = std::next(__first); 35300b57cec5SDimitry Andric if (__temp != __last) 35310b57cec5SDimitry Andric { 35320b57cec5SDimitry Andric if (*__first == '\\' && *__temp == '{') 35330b57cec5SDimitry Andric __first = ++__temp; 35340b57cec5SDimitry Andric } 35350b57cec5SDimitry Andric } 35360b57cec5SDimitry Andric return __first; 35370b57cec5SDimitry Andric} 35380b57cec5SDimitry Andric 35390b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 35400b57cec5SDimitry Andrictemplate <class _ForwardIterator> 35410b57cec5SDimitry Andric_ForwardIterator 35420b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_Back_close_brace(_ForwardIterator __first, 35430b57cec5SDimitry Andric _ForwardIterator __last) 35440b57cec5SDimitry Andric{ 35450b57cec5SDimitry Andric if (__first != __last) 35460b57cec5SDimitry Andric { 3547*5f757f3fSDimitry Andric _ForwardIterator __temp = std::next(__first); 35480b57cec5SDimitry Andric if (__temp != __last) 35490b57cec5SDimitry Andric { 35500b57cec5SDimitry Andric if (*__first == '\\' && *__temp == '}') 35510b57cec5SDimitry Andric __first = ++__temp; 35520b57cec5SDimitry Andric } 35530b57cec5SDimitry Andric } 35540b57cec5SDimitry Andric return __first; 35550b57cec5SDimitry Andric} 35560b57cec5SDimitry Andric 35570b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 35580b57cec5SDimitry Andrictemplate <class _ForwardIterator> 35590b57cec5SDimitry Andric_ForwardIterator 35600b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_BACKREF(_ForwardIterator __first, 35610b57cec5SDimitry Andric _ForwardIterator __last) 35620b57cec5SDimitry Andric{ 35630b57cec5SDimitry Andric if (__first != __last) 35640b57cec5SDimitry Andric { 3565*5f757f3fSDimitry Andric _ForwardIterator __temp = std::next(__first); 35665ffd83dbSDimitry Andric if (__temp != __last && *__first == '\\' && __test_back_ref(*__temp)) 35670b57cec5SDimitry Andric __first = ++__temp; 35680b57cec5SDimitry Andric } 35690b57cec5SDimitry Andric return __first; 35700b57cec5SDimitry Andric} 35710b57cec5SDimitry Andric 35720b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 35730b57cec5SDimitry Andrictemplate <class _ForwardIterator> 35740b57cec5SDimitry Andric_ForwardIterator 35750b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_ORD_CHAR(_ForwardIterator __first, 35760b57cec5SDimitry Andric _ForwardIterator __last) 35770b57cec5SDimitry Andric{ 35780b57cec5SDimitry Andric if (__first != __last) 35790b57cec5SDimitry Andric { 3580*5f757f3fSDimitry Andric _ForwardIterator __temp = std::next(__first); 35810b57cec5SDimitry Andric if (__temp == __last && *__first == '$') 35820b57cec5SDimitry Andric return __first; 35830b57cec5SDimitry Andric // Not called inside a bracket 35840b57cec5SDimitry Andric if (*__first == '.' || *__first == '\\' || *__first == '[') 35850b57cec5SDimitry Andric return __first; 35860b57cec5SDimitry Andric __push_char(*__first); 35870b57cec5SDimitry Andric ++__first; 35880b57cec5SDimitry Andric } 35890b57cec5SDimitry Andric return __first; 35900b57cec5SDimitry Andric} 35910b57cec5SDimitry Andric 35920b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 35930b57cec5SDimitry Andrictemplate <class _ForwardIterator> 35940b57cec5SDimitry Andric_ForwardIterator 35950b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_ORD_CHAR_ERE(_ForwardIterator __first, 35960b57cec5SDimitry Andric _ForwardIterator __last) 35970b57cec5SDimitry Andric{ 35980b57cec5SDimitry Andric if (__first != __last) 35990b57cec5SDimitry Andric { 36000b57cec5SDimitry Andric switch (*__first) 36010b57cec5SDimitry Andric { 36020b57cec5SDimitry Andric case '^': 36030b57cec5SDimitry Andric case '.': 36040b57cec5SDimitry Andric case '[': 36050b57cec5SDimitry Andric case '$': 36060b57cec5SDimitry Andric case '(': 36070b57cec5SDimitry Andric case '|': 36080b57cec5SDimitry Andric case '*': 36090b57cec5SDimitry Andric case '+': 36100b57cec5SDimitry Andric case '?': 36110b57cec5SDimitry Andric case '{': 36120b57cec5SDimitry Andric case '\\': 36130b57cec5SDimitry Andric break; 36140b57cec5SDimitry Andric case ')': 36150b57cec5SDimitry Andric if (__open_count_ == 0) 36160b57cec5SDimitry Andric { 36170b57cec5SDimitry Andric __push_char(*__first); 36180b57cec5SDimitry Andric ++__first; 36190b57cec5SDimitry Andric } 36200b57cec5SDimitry Andric break; 36210b57cec5SDimitry Andric default: 36220b57cec5SDimitry Andric __push_char(*__first); 36230b57cec5SDimitry Andric ++__first; 36240b57cec5SDimitry Andric break; 36250b57cec5SDimitry Andric } 36260b57cec5SDimitry Andric } 36270b57cec5SDimitry Andric return __first; 36280b57cec5SDimitry Andric} 36290b57cec5SDimitry Andric 36300b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 36310b57cec5SDimitry Andrictemplate <class _ForwardIterator> 36320b57cec5SDimitry Andric_ForwardIterator 36330b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_QUOTED_CHAR(_ForwardIterator __first, 36340b57cec5SDimitry Andric _ForwardIterator __last) 36350b57cec5SDimitry Andric{ 36360b57cec5SDimitry Andric if (__first != __last) 36370b57cec5SDimitry Andric { 3638*5f757f3fSDimitry Andric _ForwardIterator __temp = std::next(__first); 36390b57cec5SDimitry Andric if (__temp != __last) 36400b57cec5SDimitry Andric { 36410b57cec5SDimitry Andric if (*__first == '\\') 36420b57cec5SDimitry Andric { 36430b57cec5SDimitry Andric switch (*__temp) 36440b57cec5SDimitry Andric { 36450b57cec5SDimitry Andric case '^': 36460b57cec5SDimitry Andric case '.': 36470b57cec5SDimitry Andric case '*': 36480b57cec5SDimitry Andric case '[': 36490b57cec5SDimitry Andric case '$': 36500b57cec5SDimitry Andric case '\\': 36510b57cec5SDimitry Andric __push_char(*__temp); 36520b57cec5SDimitry Andric __first = ++__temp; 36530b57cec5SDimitry Andric break; 36540b57cec5SDimitry Andric } 36550b57cec5SDimitry Andric } 36560b57cec5SDimitry Andric } 36570b57cec5SDimitry Andric } 36580b57cec5SDimitry Andric return __first; 36590b57cec5SDimitry Andric} 36600b57cec5SDimitry Andric 36610b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 36620b57cec5SDimitry Andrictemplate <class _ForwardIterator> 36630b57cec5SDimitry Andric_ForwardIterator 36640b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_QUOTED_CHAR_ERE(_ForwardIterator __first, 36650b57cec5SDimitry Andric _ForwardIterator __last) 36660b57cec5SDimitry Andric{ 36670b57cec5SDimitry Andric if (__first != __last) 36680b57cec5SDimitry Andric { 3669*5f757f3fSDimitry Andric _ForwardIterator __temp = std::next(__first); 36700b57cec5SDimitry Andric if (__temp != __last) 36710b57cec5SDimitry Andric { 36720b57cec5SDimitry Andric if (*__first == '\\') 36730b57cec5SDimitry Andric { 36740b57cec5SDimitry Andric switch (*__temp) 36750b57cec5SDimitry Andric { 36760b57cec5SDimitry Andric case '^': 36770b57cec5SDimitry Andric case '.': 36780b57cec5SDimitry Andric case '*': 36790b57cec5SDimitry Andric case '[': 36800b57cec5SDimitry Andric case '$': 36810b57cec5SDimitry Andric case '\\': 36820b57cec5SDimitry Andric case '(': 36830b57cec5SDimitry Andric case ')': 36840b57cec5SDimitry Andric case '|': 36850b57cec5SDimitry Andric case '+': 36860b57cec5SDimitry Andric case '?': 36870b57cec5SDimitry Andric case '{': 36880b57cec5SDimitry Andric case '}': 36890b57cec5SDimitry Andric __push_char(*__temp); 36900b57cec5SDimitry Andric __first = ++__temp; 36910b57cec5SDimitry Andric break; 36920b57cec5SDimitry Andric default: 36930b57cec5SDimitry Andric if (__get_grammar(__flags_) == awk) 36940b57cec5SDimitry Andric __first = __parse_awk_escape(++__first, __last); 36955ffd83dbSDimitry Andric else if(__test_back_ref(*__temp)) 36965ffd83dbSDimitry Andric __first = ++__temp; 36970b57cec5SDimitry Andric break; 36980b57cec5SDimitry Andric } 36990b57cec5SDimitry Andric } 37000b57cec5SDimitry Andric } 37010b57cec5SDimitry Andric } 37020b57cec5SDimitry Andric return __first; 37030b57cec5SDimitry Andric} 37040b57cec5SDimitry Andric 37050b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 37060b57cec5SDimitry Andrictemplate <class _ForwardIterator> 37070b57cec5SDimitry Andric_ForwardIterator 37080b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_RE_dupl_symbol(_ForwardIterator __first, 37090b57cec5SDimitry Andric _ForwardIterator __last, 37100b57cec5SDimitry Andric __owns_one_state<_CharT>* __s, 37110b57cec5SDimitry Andric unsigned __mexp_begin, 37120b57cec5SDimitry Andric unsigned __mexp_end) 37130b57cec5SDimitry Andric{ 37140b57cec5SDimitry Andric if (__first != __last) 37150b57cec5SDimitry Andric { 37160b57cec5SDimitry Andric if (*__first == '*') 37170b57cec5SDimitry Andric { 37180b57cec5SDimitry Andric __push_greedy_inf_repeat(0, __s, __mexp_begin, __mexp_end); 37190b57cec5SDimitry Andric ++__first; 37200b57cec5SDimitry Andric } 37210b57cec5SDimitry Andric else 37220b57cec5SDimitry Andric { 37230b57cec5SDimitry Andric _ForwardIterator __temp = __parse_Back_open_brace(__first, __last); 37240b57cec5SDimitry Andric if (__temp != __first) 37250b57cec5SDimitry Andric { 37260b57cec5SDimitry Andric int __min = 0; 37270b57cec5SDimitry Andric __first = __temp; 37280b57cec5SDimitry Andric __temp = __parse_DUP_COUNT(__first, __last, __min); 37290b57cec5SDimitry Andric if (__temp == __first) 37300b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_badbrace>(); 37310b57cec5SDimitry Andric __first = __temp; 37320b57cec5SDimitry Andric if (__first == __last) 37330b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_brace>(); 37340b57cec5SDimitry Andric if (*__first != ',') 37350b57cec5SDimitry Andric { 37360b57cec5SDimitry Andric __temp = __parse_Back_close_brace(__first, __last); 37370b57cec5SDimitry Andric if (__temp == __first) 37380b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_brace>(); 37390b57cec5SDimitry Andric __push_loop(__min, __min, __s, __mexp_begin, __mexp_end, 37400b57cec5SDimitry Andric true); 37410b57cec5SDimitry Andric __first = __temp; 37420b57cec5SDimitry Andric } 37430b57cec5SDimitry Andric else 37440b57cec5SDimitry Andric { 37450b57cec5SDimitry Andric ++__first; // consume ',' 37460b57cec5SDimitry Andric int __max = -1; 37470b57cec5SDimitry Andric __first = __parse_DUP_COUNT(__first, __last, __max); 37480b57cec5SDimitry Andric __temp = __parse_Back_close_brace(__first, __last); 37490b57cec5SDimitry Andric if (__temp == __first) 37500b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_brace>(); 37510b57cec5SDimitry Andric if (__max == -1) 37520b57cec5SDimitry Andric __push_greedy_inf_repeat(__min, __s, __mexp_begin, __mexp_end); 37530b57cec5SDimitry Andric else 37540b57cec5SDimitry Andric { 37550b57cec5SDimitry Andric if (__max < __min) 37560b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_badbrace>(); 37570b57cec5SDimitry Andric __push_loop(__min, __max, __s, __mexp_begin, __mexp_end, 37580b57cec5SDimitry Andric true); 37590b57cec5SDimitry Andric } 37600b57cec5SDimitry Andric __first = __temp; 37610b57cec5SDimitry Andric } 37620b57cec5SDimitry Andric } 37630b57cec5SDimitry Andric } 37640b57cec5SDimitry Andric } 37650b57cec5SDimitry Andric return __first; 37660b57cec5SDimitry Andric} 37670b57cec5SDimitry Andric 37680b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 37690b57cec5SDimitry Andrictemplate <class _ForwardIterator> 37700b57cec5SDimitry Andric_ForwardIterator 37710b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_ERE_dupl_symbol(_ForwardIterator __first, 37720b57cec5SDimitry Andric _ForwardIterator __last, 37730b57cec5SDimitry Andric __owns_one_state<_CharT>* __s, 37740b57cec5SDimitry Andric unsigned __mexp_begin, 37750b57cec5SDimitry Andric unsigned __mexp_end) 37760b57cec5SDimitry Andric{ 37770b57cec5SDimitry Andric if (__first != __last) 37780b57cec5SDimitry Andric { 37790b57cec5SDimitry Andric unsigned __grammar = __get_grammar(__flags_); 37800b57cec5SDimitry Andric switch (*__first) 37810b57cec5SDimitry Andric { 37820b57cec5SDimitry Andric case '*': 37830b57cec5SDimitry Andric ++__first; 37840b57cec5SDimitry Andric if (__grammar == ECMAScript && __first != __last && *__first == '?') 37850b57cec5SDimitry Andric { 37860b57cec5SDimitry Andric ++__first; 37870b57cec5SDimitry Andric __push_nongreedy_inf_repeat(0, __s, __mexp_begin, __mexp_end); 37880b57cec5SDimitry Andric } 37890b57cec5SDimitry Andric else 37900b57cec5SDimitry Andric __push_greedy_inf_repeat(0, __s, __mexp_begin, __mexp_end); 37910b57cec5SDimitry Andric break; 37920b57cec5SDimitry Andric case '+': 37930b57cec5SDimitry Andric ++__first; 37940b57cec5SDimitry Andric if (__grammar == ECMAScript && __first != __last && *__first == '?') 37950b57cec5SDimitry Andric { 37960b57cec5SDimitry Andric ++__first; 37970b57cec5SDimitry Andric __push_nongreedy_inf_repeat(1, __s, __mexp_begin, __mexp_end); 37980b57cec5SDimitry Andric } 37990b57cec5SDimitry Andric else 38000b57cec5SDimitry Andric __push_greedy_inf_repeat(1, __s, __mexp_begin, __mexp_end); 38010b57cec5SDimitry Andric break; 38020b57cec5SDimitry Andric case '?': 38030b57cec5SDimitry Andric ++__first; 38040b57cec5SDimitry Andric if (__grammar == ECMAScript && __first != __last && *__first == '?') 38050b57cec5SDimitry Andric { 38060b57cec5SDimitry Andric ++__first; 38070b57cec5SDimitry Andric __push_loop(0, 1, __s, __mexp_begin, __mexp_end, false); 38080b57cec5SDimitry Andric } 38090b57cec5SDimitry Andric else 38100b57cec5SDimitry Andric __push_loop(0, 1, __s, __mexp_begin, __mexp_end); 38110b57cec5SDimitry Andric break; 38120b57cec5SDimitry Andric case '{': 38130b57cec5SDimitry Andric { 38140b57cec5SDimitry Andric int __min; 38150b57cec5SDimitry Andric _ForwardIterator __temp = __parse_DUP_COUNT(++__first, __last, __min); 38160b57cec5SDimitry Andric if (__temp == __first) 38170b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_badbrace>(); 38180b57cec5SDimitry Andric __first = __temp; 38190b57cec5SDimitry Andric if (__first == __last) 38200b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_brace>(); 38210b57cec5SDimitry Andric switch (*__first) 38220b57cec5SDimitry Andric { 38230b57cec5SDimitry Andric case '}': 38240b57cec5SDimitry Andric ++__first; 38250b57cec5SDimitry Andric if (__grammar == ECMAScript && __first != __last && *__first == '?') 38260b57cec5SDimitry Andric { 38270b57cec5SDimitry Andric ++__first; 38280b57cec5SDimitry Andric __push_loop(__min, __min, __s, __mexp_begin, __mexp_end, false); 38290b57cec5SDimitry Andric } 38300b57cec5SDimitry Andric else 38310b57cec5SDimitry Andric __push_loop(__min, __min, __s, __mexp_begin, __mexp_end); 38320b57cec5SDimitry Andric break; 38330b57cec5SDimitry Andric case ',': 38340b57cec5SDimitry Andric ++__first; 38350b57cec5SDimitry Andric if (__first == __last) 38360b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_badbrace>(); 38370b57cec5SDimitry Andric if (*__first == '}') 38380b57cec5SDimitry Andric { 38390b57cec5SDimitry Andric ++__first; 38400b57cec5SDimitry Andric if (__grammar == ECMAScript && __first != __last && *__first == '?') 38410b57cec5SDimitry Andric { 38420b57cec5SDimitry Andric ++__first; 38430b57cec5SDimitry Andric __push_nongreedy_inf_repeat(__min, __s, __mexp_begin, __mexp_end); 38440b57cec5SDimitry Andric } 38450b57cec5SDimitry Andric else 38460b57cec5SDimitry Andric __push_greedy_inf_repeat(__min, __s, __mexp_begin, __mexp_end); 38470b57cec5SDimitry Andric } 38480b57cec5SDimitry Andric else 38490b57cec5SDimitry Andric { 38500b57cec5SDimitry Andric int __max = -1; 38510b57cec5SDimitry Andric __temp = __parse_DUP_COUNT(__first, __last, __max); 38520b57cec5SDimitry Andric if (__temp == __first) 38530b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_brace>(); 38540b57cec5SDimitry Andric __first = __temp; 38550b57cec5SDimitry Andric if (__first == __last || *__first != '}') 38560b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_brace>(); 38570b57cec5SDimitry Andric ++__first; 38580b57cec5SDimitry Andric if (__max < __min) 38590b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_badbrace>(); 38600b57cec5SDimitry Andric if (__grammar == ECMAScript && __first != __last && *__first == '?') 38610b57cec5SDimitry Andric { 38620b57cec5SDimitry Andric ++__first; 38630b57cec5SDimitry Andric __push_loop(__min, __max, __s, __mexp_begin, __mexp_end, false); 38640b57cec5SDimitry Andric } 38650b57cec5SDimitry Andric else 38660b57cec5SDimitry Andric __push_loop(__min, __max, __s, __mexp_begin, __mexp_end); 38670b57cec5SDimitry Andric } 38680b57cec5SDimitry Andric break; 38690b57cec5SDimitry Andric default: 38700b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_badbrace>(); 38710b57cec5SDimitry Andric } 38720b57cec5SDimitry Andric } 38730b57cec5SDimitry Andric break; 38740b57cec5SDimitry Andric } 38750b57cec5SDimitry Andric } 38760b57cec5SDimitry Andric return __first; 38770b57cec5SDimitry Andric} 38780b57cec5SDimitry Andric 38790b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 38800b57cec5SDimitry Andrictemplate <class _ForwardIterator> 38810b57cec5SDimitry Andric_ForwardIterator 38820b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_bracket_expression(_ForwardIterator __first, 38830b57cec5SDimitry Andric _ForwardIterator __last) 38840b57cec5SDimitry Andric{ 38850b57cec5SDimitry Andric if (__first != __last && *__first == '[') 38860b57cec5SDimitry Andric { 38870b57cec5SDimitry Andric ++__first; 38880b57cec5SDimitry Andric if (__first == __last) 38890b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_brack>(); 38900b57cec5SDimitry Andric bool __negate = false; 38910b57cec5SDimitry Andric if (*__first == '^') 38920b57cec5SDimitry Andric { 38930b57cec5SDimitry Andric ++__first; 38940b57cec5SDimitry Andric __negate = true; 38950b57cec5SDimitry Andric } 38960b57cec5SDimitry Andric __bracket_expression<_CharT, _Traits>* __ml = __start_matching_list(__negate); 38970b57cec5SDimitry Andric // __ml owned by *this 38980b57cec5SDimitry Andric if (__first == __last) 38990b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_brack>(); 39000b57cec5SDimitry Andric if (__get_grammar(__flags_) != ECMAScript && *__first == ']') 39010b57cec5SDimitry Andric { 39020b57cec5SDimitry Andric __ml->__add_char(']'); 39030b57cec5SDimitry Andric ++__first; 39040b57cec5SDimitry Andric } 39050b57cec5SDimitry Andric __first = __parse_follow_list(__first, __last, __ml); 39060b57cec5SDimitry Andric if (__first == __last) 39070b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_brack>(); 39080b57cec5SDimitry Andric if (*__first == '-') 39090b57cec5SDimitry Andric { 39100b57cec5SDimitry Andric __ml->__add_char('-'); 39110b57cec5SDimitry Andric ++__first; 39120b57cec5SDimitry Andric } 39130b57cec5SDimitry Andric if (__first == __last || *__first != ']') 39140b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_brack>(); 39150b57cec5SDimitry Andric ++__first; 39160b57cec5SDimitry Andric } 39170b57cec5SDimitry Andric return __first; 39180b57cec5SDimitry Andric} 39190b57cec5SDimitry Andric 39200b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 39210b57cec5SDimitry Andrictemplate <class _ForwardIterator> 39220b57cec5SDimitry Andric_ForwardIterator 39230b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_follow_list(_ForwardIterator __first, 39240b57cec5SDimitry Andric _ForwardIterator __last, 39250b57cec5SDimitry Andric __bracket_expression<_CharT, _Traits>* __ml) 39260b57cec5SDimitry Andric{ 39270b57cec5SDimitry Andric if (__first != __last) 39280b57cec5SDimitry Andric { 39290b57cec5SDimitry Andric while (true) 39300b57cec5SDimitry Andric { 39310b57cec5SDimitry Andric _ForwardIterator __temp = __parse_expression_term(__first, __last, 39320b57cec5SDimitry Andric __ml); 39330b57cec5SDimitry Andric if (__temp == __first) 39340b57cec5SDimitry Andric break; 39350b57cec5SDimitry Andric __first = __temp; 39360b57cec5SDimitry Andric } 39370b57cec5SDimitry Andric } 39380b57cec5SDimitry Andric return __first; 39390b57cec5SDimitry Andric} 39400b57cec5SDimitry Andric 39410b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 39420b57cec5SDimitry Andrictemplate <class _ForwardIterator> 39430b57cec5SDimitry Andric_ForwardIterator 39440b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_expression_term(_ForwardIterator __first, 39450b57cec5SDimitry Andric _ForwardIterator __last, 39460b57cec5SDimitry Andric __bracket_expression<_CharT, _Traits>* __ml) 39470b57cec5SDimitry Andric{ 39480b57cec5SDimitry Andric if (__first != __last && *__first != ']') 39490b57cec5SDimitry Andric { 3950*5f757f3fSDimitry Andric _ForwardIterator __temp = std::next(__first); 39510b57cec5SDimitry Andric basic_string<_CharT> __start_range; 39520b57cec5SDimitry Andric if (__temp != __last && *__first == '[') 39530b57cec5SDimitry Andric { 39540b57cec5SDimitry Andric if (*__temp == '=') 39550b57cec5SDimitry Andric return __parse_equivalence_class(++__temp, __last, __ml); 39560b57cec5SDimitry Andric else if (*__temp == ':') 39570b57cec5SDimitry Andric return __parse_character_class(++__temp, __last, __ml); 39580b57cec5SDimitry Andric else if (*__temp == '.') 39590b57cec5SDimitry Andric __first = __parse_collating_symbol(++__temp, __last, __start_range); 39600b57cec5SDimitry Andric } 39610b57cec5SDimitry Andric unsigned __grammar = __get_grammar(__flags_); 39620b57cec5SDimitry Andric if (__start_range.empty()) 39630b57cec5SDimitry Andric { 39640b57cec5SDimitry Andric if ((__grammar == ECMAScript || __grammar == awk) && *__first == '\\') 39650b57cec5SDimitry Andric { 39660b57cec5SDimitry Andric if (__grammar == ECMAScript) 39670b57cec5SDimitry Andric __first = __parse_class_escape(++__first, __last, __start_range, __ml); 39680b57cec5SDimitry Andric else 39690b57cec5SDimitry Andric __first = __parse_awk_escape(++__first, __last, &__start_range); 39700b57cec5SDimitry Andric } 39710b57cec5SDimitry Andric else 39720b57cec5SDimitry Andric { 39730b57cec5SDimitry Andric __start_range = *__first; 39740b57cec5SDimitry Andric ++__first; 39750b57cec5SDimitry Andric } 39760b57cec5SDimitry Andric } 39770b57cec5SDimitry Andric if (__first != __last && *__first != ']') 39780b57cec5SDimitry Andric { 3979*5f757f3fSDimitry Andric __temp = std::next(__first); 39800b57cec5SDimitry Andric if (__temp != __last && *__first == '-' && *__temp != ']') 39810b57cec5SDimitry Andric { 39820b57cec5SDimitry Andric // parse a range 39830b57cec5SDimitry Andric basic_string<_CharT> __end_range; 39840b57cec5SDimitry Andric __first = __temp; 39850b57cec5SDimitry Andric ++__temp; 39860b57cec5SDimitry Andric if (__temp != __last && *__first == '[' && *__temp == '.') 39870b57cec5SDimitry Andric __first = __parse_collating_symbol(++__temp, __last, __end_range); 39880b57cec5SDimitry Andric else 39890b57cec5SDimitry Andric { 39900b57cec5SDimitry Andric if ((__grammar == ECMAScript || __grammar == awk) && *__first == '\\') 39910b57cec5SDimitry Andric { 39920b57cec5SDimitry Andric if (__grammar == ECMAScript) 39930b57cec5SDimitry Andric __first = __parse_class_escape(++__first, __last, 39940b57cec5SDimitry Andric __end_range, __ml); 39950b57cec5SDimitry Andric else 39960b57cec5SDimitry Andric __first = __parse_awk_escape(++__first, __last, 39970b57cec5SDimitry Andric &__end_range); 39980b57cec5SDimitry Andric } 39990b57cec5SDimitry Andric else 40000b57cec5SDimitry Andric { 40010b57cec5SDimitry Andric __end_range = *__first; 40020b57cec5SDimitry Andric ++__first; 40030b57cec5SDimitry Andric } 40040b57cec5SDimitry Andric } 4005*5f757f3fSDimitry Andric __ml->__add_range(std::move(__start_range), std::move(__end_range)); 40060b57cec5SDimitry Andric } 40070b57cec5SDimitry Andric else if (!__start_range.empty()) 40080b57cec5SDimitry Andric { 40090b57cec5SDimitry Andric if (__start_range.size() == 1) 40100b57cec5SDimitry Andric __ml->__add_char(__start_range[0]); 40110b57cec5SDimitry Andric else 40120b57cec5SDimitry Andric __ml->__add_digraph(__start_range[0], __start_range[1]); 40130b57cec5SDimitry Andric } 40140b57cec5SDimitry Andric } 40150b57cec5SDimitry Andric else if (!__start_range.empty()) 40160b57cec5SDimitry Andric { 40170b57cec5SDimitry Andric if (__start_range.size() == 1) 40180b57cec5SDimitry Andric __ml->__add_char(__start_range[0]); 40190b57cec5SDimitry Andric else 40200b57cec5SDimitry Andric __ml->__add_digraph(__start_range[0], __start_range[1]); 40210b57cec5SDimitry Andric } 40220b57cec5SDimitry Andric } 40230b57cec5SDimitry Andric return __first; 40240b57cec5SDimitry Andric} 40250b57cec5SDimitry Andric 40260b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 40270b57cec5SDimitry Andrictemplate <class _ForwardIterator> 40280b57cec5SDimitry Andric_ForwardIterator 40290b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_class_escape(_ForwardIterator __first, 40300b57cec5SDimitry Andric _ForwardIterator __last, 40310b57cec5SDimitry Andric basic_string<_CharT>& __str, 40320b57cec5SDimitry Andric __bracket_expression<_CharT, _Traits>* __ml) 40330b57cec5SDimitry Andric{ 40340b57cec5SDimitry Andric if (__first == __last) 40350b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_escape>(); 40360b57cec5SDimitry Andric switch (*__first) 40370b57cec5SDimitry Andric { 40380b57cec5SDimitry Andric case 0: 40390b57cec5SDimitry Andric __str = *__first; 40400b57cec5SDimitry Andric return ++__first; 40410b57cec5SDimitry Andric case 'b': 40420b57cec5SDimitry Andric __str = _CharT(8); 40430b57cec5SDimitry Andric return ++__first; 40440b57cec5SDimitry Andric case 'd': 40450b57cec5SDimitry Andric __ml->__add_class(ctype_base::digit); 40460b57cec5SDimitry Andric return ++__first; 40470b57cec5SDimitry Andric case 'D': 40480b57cec5SDimitry Andric __ml->__add_neg_class(ctype_base::digit); 40490b57cec5SDimitry Andric return ++__first; 40500b57cec5SDimitry Andric case 's': 40510b57cec5SDimitry Andric __ml->__add_class(ctype_base::space); 40520b57cec5SDimitry Andric return ++__first; 40530b57cec5SDimitry Andric case 'S': 40540b57cec5SDimitry Andric __ml->__add_neg_class(ctype_base::space); 40550b57cec5SDimitry Andric return ++__first; 40560b57cec5SDimitry Andric case 'w': 40570b57cec5SDimitry Andric __ml->__add_class(ctype_base::alnum); 40580b57cec5SDimitry Andric __ml->__add_char('_'); 40590b57cec5SDimitry Andric return ++__first; 40600b57cec5SDimitry Andric case 'W': 40610b57cec5SDimitry Andric __ml->__add_neg_class(ctype_base::alnum); 40620b57cec5SDimitry Andric __ml->__add_neg_char('_'); 40630b57cec5SDimitry Andric return ++__first; 40640b57cec5SDimitry Andric } 40650b57cec5SDimitry Andric __first = __parse_character_escape(__first, __last, &__str); 40660b57cec5SDimitry Andric return __first; 40670b57cec5SDimitry Andric} 40680b57cec5SDimitry Andric 40690b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 40700b57cec5SDimitry Andrictemplate <class _ForwardIterator> 40710b57cec5SDimitry Andric_ForwardIterator 40720b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_awk_escape(_ForwardIterator __first, 40730b57cec5SDimitry Andric _ForwardIterator __last, 40740b57cec5SDimitry Andric basic_string<_CharT>* __str) 40750b57cec5SDimitry Andric{ 40760b57cec5SDimitry Andric if (__first == __last) 40770b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_escape>(); 40780b57cec5SDimitry Andric switch (*__first) 40790b57cec5SDimitry Andric { 40800b57cec5SDimitry Andric case '\\': 40810b57cec5SDimitry Andric case '"': 40820b57cec5SDimitry Andric case '/': 40830b57cec5SDimitry Andric if (__str) 40840b57cec5SDimitry Andric *__str = *__first; 40850b57cec5SDimitry Andric else 40860b57cec5SDimitry Andric __push_char(*__first); 40870b57cec5SDimitry Andric return ++__first; 40880b57cec5SDimitry Andric case 'a': 40890b57cec5SDimitry Andric if (__str) 40900b57cec5SDimitry Andric *__str = _CharT(7); 40910b57cec5SDimitry Andric else 40920b57cec5SDimitry Andric __push_char(_CharT(7)); 40930b57cec5SDimitry Andric return ++__first; 40940b57cec5SDimitry Andric case 'b': 40950b57cec5SDimitry Andric if (__str) 40960b57cec5SDimitry Andric *__str = _CharT(8); 40970b57cec5SDimitry Andric else 40980b57cec5SDimitry Andric __push_char(_CharT(8)); 40990b57cec5SDimitry Andric return ++__first; 41000b57cec5SDimitry Andric case 'f': 41010b57cec5SDimitry Andric if (__str) 41020b57cec5SDimitry Andric *__str = _CharT(0xC); 41030b57cec5SDimitry Andric else 41040b57cec5SDimitry Andric __push_char(_CharT(0xC)); 41050b57cec5SDimitry Andric return ++__first; 41060b57cec5SDimitry Andric case 'n': 41070b57cec5SDimitry Andric if (__str) 41080b57cec5SDimitry Andric *__str = _CharT(0xA); 41090b57cec5SDimitry Andric else 41100b57cec5SDimitry Andric __push_char(_CharT(0xA)); 41110b57cec5SDimitry Andric return ++__first; 41120b57cec5SDimitry Andric case 'r': 41130b57cec5SDimitry Andric if (__str) 41140b57cec5SDimitry Andric *__str = _CharT(0xD); 41150b57cec5SDimitry Andric else 41160b57cec5SDimitry Andric __push_char(_CharT(0xD)); 41170b57cec5SDimitry Andric return ++__first; 41180b57cec5SDimitry Andric case 't': 41190b57cec5SDimitry Andric if (__str) 41200b57cec5SDimitry Andric *__str = _CharT(0x9); 41210b57cec5SDimitry Andric else 41220b57cec5SDimitry Andric __push_char(_CharT(0x9)); 41230b57cec5SDimitry Andric return ++__first; 41240b57cec5SDimitry Andric case 'v': 41250b57cec5SDimitry Andric if (__str) 41260b57cec5SDimitry Andric *__str = _CharT(0xB); 41270b57cec5SDimitry Andric else 41280b57cec5SDimitry Andric __push_char(_CharT(0xB)); 41290b57cec5SDimitry Andric return ++__first; 41300b57cec5SDimitry Andric } 41310b57cec5SDimitry Andric if ('0' <= *__first && *__first <= '7') 41320b57cec5SDimitry Andric { 41330b57cec5SDimitry Andric unsigned __val = *__first - '0'; 41340b57cec5SDimitry Andric if (++__first != __last && ('0' <= *__first && *__first <= '7')) 41350b57cec5SDimitry Andric { 41360b57cec5SDimitry Andric __val = 8 * __val + *__first - '0'; 41370b57cec5SDimitry Andric if (++__first != __last && ('0' <= *__first && *__first <= '7')) 41380b57cec5SDimitry Andric __val = 8 * __val + *__first++ - '0'; 41390b57cec5SDimitry Andric } 41400b57cec5SDimitry Andric if (__str) 41410b57cec5SDimitry Andric *__str = _CharT(__val); 41420b57cec5SDimitry Andric else 41430b57cec5SDimitry Andric __push_char(_CharT(__val)); 41440b57cec5SDimitry Andric } 41450b57cec5SDimitry Andric else 41460b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_escape>(); 41470b57cec5SDimitry Andric return __first; 41480b57cec5SDimitry Andric} 41490b57cec5SDimitry Andric 41500b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 41510b57cec5SDimitry Andrictemplate <class _ForwardIterator> 41520b57cec5SDimitry Andric_ForwardIterator 41530b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_equivalence_class(_ForwardIterator __first, 41540b57cec5SDimitry Andric _ForwardIterator __last, 41550b57cec5SDimitry Andric __bracket_expression<_CharT, _Traits>* __ml) 41560b57cec5SDimitry Andric{ 41570b57cec5SDimitry Andric // Found [= 41580b57cec5SDimitry Andric // This means =] must exist 415906c3fb27SDimitry Andric value_type __equal_close[2] = {'=', ']'}; 4160*5f757f3fSDimitry Andric _ForwardIterator __temp = std::search(__first, __last, __equal_close, 416106c3fb27SDimitry Andric __equal_close+2); 41620b57cec5SDimitry Andric if (__temp == __last) 41630b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_brack>(); 41640b57cec5SDimitry Andric // [__first, __temp) contains all text in [= ... =] 41650b57cec5SDimitry Andric string_type __collate_name = 41660b57cec5SDimitry Andric __traits_.lookup_collatename(__first, __temp); 41670b57cec5SDimitry Andric if (__collate_name.empty()) 41680b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_collate>(); 41690b57cec5SDimitry Andric string_type __equiv_name = 41700b57cec5SDimitry Andric __traits_.transform_primary(__collate_name.begin(), 41710b57cec5SDimitry Andric __collate_name.end()); 41720b57cec5SDimitry Andric if (!__equiv_name.empty()) 41730b57cec5SDimitry Andric __ml->__add_equivalence(__equiv_name); 41740b57cec5SDimitry Andric else 41750b57cec5SDimitry Andric { 41760b57cec5SDimitry Andric switch (__collate_name.size()) 41770b57cec5SDimitry Andric { 41780b57cec5SDimitry Andric case 1: 41790b57cec5SDimitry Andric __ml->__add_char(__collate_name[0]); 41800b57cec5SDimitry Andric break; 41810b57cec5SDimitry Andric case 2: 41820b57cec5SDimitry Andric __ml->__add_digraph(__collate_name[0], __collate_name[1]); 41830b57cec5SDimitry Andric break; 41840b57cec5SDimitry Andric default: 41850b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_collate>(); 41860b57cec5SDimitry Andric } 41870b57cec5SDimitry Andric } 4188*5f757f3fSDimitry Andric __first = std::next(__temp, 2); 41890b57cec5SDimitry Andric return __first; 41900b57cec5SDimitry Andric} 41910b57cec5SDimitry Andric 41920b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 41930b57cec5SDimitry Andrictemplate <class _ForwardIterator> 41940b57cec5SDimitry Andric_ForwardIterator 41950b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_character_class(_ForwardIterator __first, 41960b57cec5SDimitry Andric _ForwardIterator __last, 41970b57cec5SDimitry Andric __bracket_expression<_CharT, _Traits>* __ml) 41980b57cec5SDimitry Andric{ 41990b57cec5SDimitry Andric // Found [: 42000b57cec5SDimitry Andric // This means :] must exist 420106c3fb27SDimitry Andric value_type __colon_close[2] = {':', ']'}; 4202*5f757f3fSDimitry Andric _ForwardIterator __temp = std::search(__first, __last, __colon_close, 420306c3fb27SDimitry Andric __colon_close+2); 42040b57cec5SDimitry Andric if (__temp == __last) 42050b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_brack>(); 42060b57cec5SDimitry Andric // [__first, __temp) contains all text in [: ... :] 42070b57cec5SDimitry Andric typedef typename _Traits::char_class_type char_class_type; 42080b57cec5SDimitry Andric char_class_type __class_type = 42090b57cec5SDimitry Andric __traits_.lookup_classname(__first, __temp, __flags_ & icase); 42100b57cec5SDimitry Andric if (__class_type == 0) 42110b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_ctype>(); 42120b57cec5SDimitry Andric __ml->__add_class(__class_type); 4213*5f757f3fSDimitry Andric __first = std::next(__temp, 2); 42140b57cec5SDimitry Andric return __first; 42150b57cec5SDimitry Andric} 42160b57cec5SDimitry Andric 42170b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 42180b57cec5SDimitry Andrictemplate <class _ForwardIterator> 42190b57cec5SDimitry Andric_ForwardIterator 42200b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_collating_symbol(_ForwardIterator __first, 42210b57cec5SDimitry Andric _ForwardIterator __last, 42220b57cec5SDimitry Andric basic_string<_CharT>& __col_sym) 42230b57cec5SDimitry Andric{ 42240b57cec5SDimitry Andric // Found [. 42250b57cec5SDimitry Andric // This means .] must exist 422606c3fb27SDimitry Andric value_type __dot_close[2] = {'.', ']'}; 4227*5f757f3fSDimitry Andric _ForwardIterator __temp = std::search(__first, __last, __dot_close, 422806c3fb27SDimitry Andric __dot_close+2); 42290b57cec5SDimitry Andric if (__temp == __last) 42300b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_brack>(); 42310b57cec5SDimitry Andric // [__first, __temp) contains all text in [. ... .] 42320b57cec5SDimitry Andric __col_sym = __traits_.lookup_collatename(__first, __temp); 42330b57cec5SDimitry Andric switch (__col_sym.size()) 42340b57cec5SDimitry Andric { 42350b57cec5SDimitry Andric case 1: 42360b57cec5SDimitry Andric case 2: 42370b57cec5SDimitry Andric break; 42380b57cec5SDimitry Andric default: 42390b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_collate>(); 42400b57cec5SDimitry Andric } 4241*5f757f3fSDimitry Andric __first = std::next(__temp, 2); 42420b57cec5SDimitry Andric return __first; 42430b57cec5SDimitry Andric} 42440b57cec5SDimitry Andric 42450b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 42460b57cec5SDimitry Andrictemplate <class _ForwardIterator> 42470b57cec5SDimitry Andric_ForwardIterator 42480b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_DUP_COUNT(_ForwardIterator __first, 42490b57cec5SDimitry Andric _ForwardIterator __last, 42500b57cec5SDimitry Andric int& __c) 42510b57cec5SDimitry Andric{ 42520b57cec5SDimitry Andric if (__first != __last ) 42530b57cec5SDimitry Andric { 42540b57cec5SDimitry Andric int __val = __traits_.value(*__first, 10); 42550b57cec5SDimitry Andric if ( __val != -1 ) 42560b57cec5SDimitry Andric { 42570b57cec5SDimitry Andric __c = __val; 42580b57cec5SDimitry Andric for (++__first; 42590b57cec5SDimitry Andric __first != __last && ( __val = __traits_.value(*__first, 10)) != -1; 42600b57cec5SDimitry Andric ++__first) 42610b57cec5SDimitry Andric { 4262e8d8bef9SDimitry Andric if (__c >= numeric_limits<int>::max() / 10) 42630b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_badbrace>(); 42640b57cec5SDimitry Andric __c *= 10; 42650b57cec5SDimitry Andric __c += __val; 42660b57cec5SDimitry Andric } 42670b57cec5SDimitry Andric } 42680b57cec5SDimitry Andric } 42690b57cec5SDimitry Andric return __first; 42700b57cec5SDimitry Andric} 42710b57cec5SDimitry Andric 42720b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 42730b57cec5SDimitry Andrictemplate <class _ForwardIterator> 42740b57cec5SDimitry Andric_ForwardIterator 42750b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_ecma_exp(_ForwardIterator __first, 42760b57cec5SDimitry Andric _ForwardIterator __last) 42770b57cec5SDimitry Andric{ 42780b57cec5SDimitry Andric __owns_one_state<_CharT>* __sa = __end_; 42790b57cec5SDimitry Andric _ForwardIterator __temp = __parse_alternative(__first, __last); 42800b57cec5SDimitry Andric if (__temp == __first) 42810b57cec5SDimitry Andric __push_empty(); 42820b57cec5SDimitry Andric __first = __temp; 42830b57cec5SDimitry Andric while (__first != __last && *__first == '|') 42840b57cec5SDimitry Andric { 42850b57cec5SDimitry Andric __owns_one_state<_CharT>* __sb = __end_; 42860b57cec5SDimitry Andric __temp = __parse_alternative(++__first, __last); 42870b57cec5SDimitry Andric if (__temp == __first) 42880b57cec5SDimitry Andric __push_empty(); 42890b57cec5SDimitry Andric __push_alternation(__sa, __sb); 42900b57cec5SDimitry Andric __first = __temp; 42910b57cec5SDimitry Andric } 42920b57cec5SDimitry Andric return __first; 42930b57cec5SDimitry Andric} 42940b57cec5SDimitry Andric 42950b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 42960b57cec5SDimitry Andrictemplate <class _ForwardIterator> 42970b57cec5SDimitry Andric_ForwardIterator 42980b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_alternative(_ForwardIterator __first, 42990b57cec5SDimitry Andric _ForwardIterator __last) 43000b57cec5SDimitry Andric{ 43010b57cec5SDimitry Andric while (true) 43020b57cec5SDimitry Andric { 43030b57cec5SDimitry Andric _ForwardIterator __temp = __parse_term(__first, __last); 43040b57cec5SDimitry Andric if (__temp == __first) 43050b57cec5SDimitry Andric break; 43060b57cec5SDimitry Andric __first = __temp; 43070b57cec5SDimitry Andric } 43080b57cec5SDimitry Andric return __first; 43090b57cec5SDimitry Andric} 43100b57cec5SDimitry Andric 43110b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 43120b57cec5SDimitry Andrictemplate <class _ForwardIterator> 43130b57cec5SDimitry Andric_ForwardIterator 43140b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_term(_ForwardIterator __first, 43150b57cec5SDimitry Andric _ForwardIterator __last) 43160b57cec5SDimitry Andric{ 43170b57cec5SDimitry Andric _ForwardIterator __temp = __parse_assertion(__first, __last); 43180b57cec5SDimitry Andric if (__temp == __first) 43190b57cec5SDimitry Andric { 43200b57cec5SDimitry Andric __owns_one_state<_CharT>* __e = __end_; 43210b57cec5SDimitry Andric unsigned __mexp_begin = __marked_count_; 43220b57cec5SDimitry Andric __temp = __parse_atom(__first, __last); 43230b57cec5SDimitry Andric if (__temp != __first) 43240b57cec5SDimitry Andric __first = __parse_ERE_dupl_symbol(__temp, __last, __e, 43250b57cec5SDimitry Andric __mexp_begin+1, __marked_count_+1); 43260b57cec5SDimitry Andric } 43270b57cec5SDimitry Andric else 43280b57cec5SDimitry Andric __first = __temp; 43290b57cec5SDimitry Andric return __first; 43300b57cec5SDimitry Andric} 43310b57cec5SDimitry Andric 43320b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 43330b57cec5SDimitry Andrictemplate <class _ForwardIterator> 43340b57cec5SDimitry Andric_ForwardIterator 43350b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_assertion(_ForwardIterator __first, 43360b57cec5SDimitry Andric _ForwardIterator __last) 43370b57cec5SDimitry Andric{ 43380b57cec5SDimitry Andric if (__first != __last) 43390b57cec5SDimitry Andric { 43400b57cec5SDimitry Andric switch (*__first) 43410b57cec5SDimitry Andric { 43420b57cec5SDimitry Andric case '^': 43430b57cec5SDimitry Andric __push_l_anchor(); 43440b57cec5SDimitry Andric ++__first; 43450b57cec5SDimitry Andric break; 43460b57cec5SDimitry Andric case '$': 43470b57cec5SDimitry Andric __push_r_anchor(); 43480b57cec5SDimitry Andric ++__first; 43490b57cec5SDimitry Andric break; 43500b57cec5SDimitry Andric case '\\': 43510b57cec5SDimitry Andric { 4352*5f757f3fSDimitry Andric _ForwardIterator __temp = std::next(__first); 43530b57cec5SDimitry Andric if (__temp != __last) 43540b57cec5SDimitry Andric { 43550b57cec5SDimitry Andric if (*__temp == 'b') 43560b57cec5SDimitry Andric { 43570b57cec5SDimitry Andric __push_word_boundary(false); 43580b57cec5SDimitry Andric __first = ++__temp; 43590b57cec5SDimitry Andric } 43600b57cec5SDimitry Andric else if (*__temp == 'B') 43610b57cec5SDimitry Andric { 43620b57cec5SDimitry Andric __push_word_boundary(true); 43630b57cec5SDimitry Andric __first = ++__temp; 43640b57cec5SDimitry Andric } 43650b57cec5SDimitry Andric } 43660b57cec5SDimitry Andric } 43670b57cec5SDimitry Andric break; 43680b57cec5SDimitry Andric case '(': 43690b57cec5SDimitry Andric { 4370*5f757f3fSDimitry Andric _ForwardIterator __temp = std::next(__first); 43710b57cec5SDimitry Andric if (__temp != __last && *__temp == '?') 43720b57cec5SDimitry Andric { 43730b57cec5SDimitry Andric if (++__temp != __last) 43740b57cec5SDimitry Andric { 43750b57cec5SDimitry Andric switch (*__temp) 43760b57cec5SDimitry Andric { 43770b57cec5SDimitry Andric case '=': 43780b57cec5SDimitry Andric { 43790b57cec5SDimitry Andric basic_regex __exp; 43800b57cec5SDimitry Andric __exp.__flags_ = __flags_; 43810b57cec5SDimitry Andric __temp = __exp.__parse(++__temp, __last); 43820b57cec5SDimitry Andric unsigned __mexp = __exp.__marked_count_; 4383*5f757f3fSDimitry Andric __push_lookahead(std::move(__exp), false, __marked_count_); 43840b57cec5SDimitry Andric __marked_count_ += __mexp; 43850b57cec5SDimitry Andric if (__temp == __last || *__temp != ')') 43860b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_paren>(); 43870b57cec5SDimitry Andric __first = ++__temp; 43880b57cec5SDimitry Andric } 43890b57cec5SDimitry Andric break; 43900b57cec5SDimitry Andric case '!': 43910b57cec5SDimitry Andric { 43920b57cec5SDimitry Andric basic_regex __exp; 43930b57cec5SDimitry Andric __exp.__flags_ = __flags_; 43940b57cec5SDimitry Andric __temp = __exp.__parse(++__temp, __last); 43950b57cec5SDimitry Andric unsigned __mexp = __exp.__marked_count_; 4396*5f757f3fSDimitry Andric __push_lookahead(std::move(__exp), true, __marked_count_); 43970b57cec5SDimitry Andric __marked_count_ += __mexp; 43980b57cec5SDimitry Andric if (__temp == __last || *__temp != ')') 43990b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_paren>(); 44000b57cec5SDimitry Andric __first = ++__temp; 44010b57cec5SDimitry Andric } 44020b57cec5SDimitry Andric break; 44030b57cec5SDimitry Andric } 44040b57cec5SDimitry Andric } 44050b57cec5SDimitry Andric } 44060b57cec5SDimitry Andric } 44070b57cec5SDimitry Andric break; 44080b57cec5SDimitry Andric } 44090b57cec5SDimitry Andric } 44100b57cec5SDimitry Andric return __first; 44110b57cec5SDimitry Andric} 44120b57cec5SDimitry Andric 44130b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 44140b57cec5SDimitry Andrictemplate <class _ForwardIterator> 44150b57cec5SDimitry Andric_ForwardIterator 44160b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_atom(_ForwardIterator __first, 44170b57cec5SDimitry Andric _ForwardIterator __last) 44180b57cec5SDimitry Andric{ 44190b57cec5SDimitry Andric if (__first != __last) 44200b57cec5SDimitry Andric { 44210b57cec5SDimitry Andric switch (*__first) 44220b57cec5SDimitry Andric { 44230b57cec5SDimitry Andric case '.': 44240b57cec5SDimitry Andric __push_match_any_but_newline(); 44250b57cec5SDimitry Andric ++__first; 44260b57cec5SDimitry Andric break; 44270b57cec5SDimitry Andric case '\\': 44280b57cec5SDimitry Andric __first = __parse_atom_escape(__first, __last); 44290b57cec5SDimitry Andric break; 44300b57cec5SDimitry Andric case '[': 44310b57cec5SDimitry Andric __first = __parse_bracket_expression(__first, __last); 44320b57cec5SDimitry Andric break; 44330b57cec5SDimitry Andric case '(': 44340b57cec5SDimitry Andric { 44350b57cec5SDimitry Andric ++__first; 44360b57cec5SDimitry Andric if (__first == __last) 44370b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_paren>(); 4438*5f757f3fSDimitry Andric _ForwardIterator __temp = std::next(__first); 44390b57cec5SDimitry Andric if (__temp != __last && *__first == '?' && *__temp == ':') 44400b57cec5SDimitry Andric { 44410b57cec5SDimitry Andric ++__open_count_; 44420b57cec5SDimitry Andric __first = __parse_ecma_exp(++__temp, __last); 44430b57cec5SDimitry Andric if (__first == __last || *__first != ')') 44440b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_paren>(); 44450b57cec5SDimitry Andric --__open_count_; 44460b57cec5SDimitry Andric ++__first; 44470b57cec5SDimitry Andric } 44480b57cec5SDimitry Andric else 44490b57cec5SDimitry Andric { 44500b57cec5SDimitry Andric __push_begin_marked_subexpression(); 44510b57cec5SDimitry Andric unsigned __temp_count = __marked_count_; 44520b57cec5SDimitry Andric ++__open_count_; 44530b57cec5SDimitry Andric __first = __parse_ecma_exp(__first, __last); 44540b57cec5SDimitry Andric if (__first == __last || *__first != ')') 44550b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_paren>(); 44560b57cec5SDimitry Andric __push_end_marked_subexpression(__temp_count); 44570b57cec5SDimitry Andric --__open_count_; 44580b57cec5SDimitry Andric ++__first; 44590b57cec5SDimitry Andric } 44600b57cec5SDimitry Andric } 44610b57cec5SDimitry Andric break; 44620b57cec5SDimitry Andric case '*': 44630b57cec5SDimitry Andric case '+': 44640b57cec5SDimitry Andric case '?': 44650b57cec5SDimitry Andric case '{': 44660b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_badrepeat>(); 44670b57cec5SDimitry Andric break; 44680b57cec5SDimitry Andric default: 44690b57cec5SDimitry Andric __first = __parse_pattern_character(__first, __last); 44700b57cec5SDimitry Andric break; 44710b57cec5SDimitry Andric } 44720b57cec5SDimitry Andric } 44730b57cec5SDimitry Andric return __first; 44740b57cec5SDimitry Andric} 44750b57cec5SDimitry Andric 44760b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 44770b57cec5SDimitry Andrictemplate <class _ForwardIterator> 44780b57cec5SDimitry Andric_ForwardIterator 44790b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_atom_escape(_ForwardIterator __first, 44800b57cec5SDimitry Andric _ForwardIterator __last) 44810b57cec5SDimitry Andric{ 44820b57cec5SDimitry Andric if (__first != __last && *__first == '\\') 44830b57cec5SDimitry Andric { 4484*5f757f3fSDimitry Andric _ForwardIterator __t1 = std::next(__first); 44850b57cec5SDimitry Andric if (__t1 == __last) 44860b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_escape>(); 44870b57cec5SDimitry Andric 44880b57cec5SDimitry Andric _ForwardIterator __t2 = __parse_decimal_escape(__t1, __last); 44890b57cec5SDimitry Andric if (__t2 != __t1) 44900b57cec5SDimitry Andric __first = __t2; 44910b57cec5SDimitry Andric else 44920b57cec5SDimitry Andric { 44930b57cec5SDimitry Andric __t2 = __parse_character_class_escape(__t1, __last); 44940b57cec5SDimitry Andric if (__t2 != __t1) 44950b57cec5SDimitry Andric __first = __t2; 44960b57cec5SDimitry Andric else 44970b57cec5SDimitry Andric { 44980b57cec5SDimitry Andric __t2 = __parse_character_escape(__t1, __last); 44990b57cec5SDimitry Andric if (__t2 != __t1) 45000b57cec5SDimitry Andric __first = __t2; 45010b57cec5SDimitry Andric } 45020b57cec5SDimitry Andric } 45030b57cec5SDimitry Andric } 45040b57cec5SDimitry Andric return __first; 45050b57cec5SDimitry Andric} 45060b57cec5SDimitry Andric 45070b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 45080b57cec5SDimitry Andrictemplate <class _ForwardIterator> 45090b57cec5SDimitry Andric_ForwardIterator 45100b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_decimal_escape(_ForwardIterator __first, 45110b57cec5SDimitry Andric _ForwardIterator __last) 45120b57cec5SDimitry Andric{ 45130b57cec5SDimitry Andric if (__first != __last) 45140b57cec5SDimitry Andric { 45150b57cec5SDimitry Andric if (*__first == '0') 45160b57cec5SDimitry Andric { 45170b57cec5SDimitry Andric __push_char(_CharT()); 45180b57cec5SDimitry Andric ++__first; 45190b57cec5SDimitry Andric } 45200b57cec5SDimitry Andric else if ('1' <= *__first && *__first <= '9') 45210b57cec5SDimitry Andric { 45220b57cec5SDimitry Andric unsigned __v = *__first - '0'; 45230b57cec5SDimitry Andric for (++__first; 45240b57cec5SDimitry Andric __first != __last && '0' <= *__first && *__first <= '9'; ++__first) 45250b57cec5SDimitry Andric { 4526e8d8bef9SDimitry Andric if (__v >= numeric_limits<unsigned>::max() / 10) 45270b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_backref>(); 45280b57cec5SDimitry Andric __v = 10 * __v + *__first - '0'; 45290b57cec5SDimitry Andric } 45300b57cec5SDimitry Andric if (__v == 0 || __v > mark_count()) 45310b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_backref>(); 45320b57cec5SDimitry Andric __push_back_ref(__v); 45330b57cec5SDimitry Andric } 45340b57cec5SDimitry Andric } 45350b57cec5SDimitry Andric return __first; 45360b57cec5SDimitry Andric} 45370b57cec5SDimitry Andric 45380b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 45390b57cec5SDimitry Andrictemplate <class _ForwardIterator> 45400b57cec5SDimitry Andric_ForwardIterator 45410b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_character_class_escape(_ForwardIterator __first, 45420b57cec5SDimitry Andric _ForwardIterator __last) 45430b57cec5SDimitry Andric{ 45440b57cec5SDimitry Andric if (__first != __last) 45450b57cec5SDimitry Andric { 45460b57cec5SDimitry Andric __bracket_expression<_CharT, _Traits>* __ml; 45470b57cec5SDimitry Andric switch (*__first) 45480b57cec5SDimitry Andric { 45490b57cec5SDimitry Andric case 'd': 45500b57cec5SDimitry Andric __ml = __start_matching_list(false); 45510b57cec5SDimitry Andric __ml->__add_class(ctype_base::digit); 45520b57cec5SDimitry Andric ++__first; 45530b57cec5SDimitry Andric break; 45540b57cec5SDimitry Andric case 'D': 45550b57cec5SDimitry Andric __ml = __start_matching_list(true); 45560b57cec5SDimitry Andric __ml->__add_class(ctype_base::digit); 45570b57cec5SDimitry Andric ++__first; 45580b57cec5SDimitry Andric break; 45590b57cec5SDimitry Andric case 's': 45600b57cec5SDimitry Andric __ml = __start_matching_list(false); 45610b57cec5SDimitry Andric __ml->__add_class(ctype_base::space); 45620b57cec5SDimitry Andric ++__first; 45630b57cec5SDimitry Andric break; 45640b57cec5SDimitry Andric case 'S': 45650b57cec5SDimitry Andric __ml = __start_matching_list(true); 45660b57cec5SDimitry Andric __ml->__add_class(ctype_base::space); 45670b57cec5SDimitry Andric ++__first; 45680b57cec5SDimitry Andric break; 45690b57cec5SDimitry Andric case 'w': 45700b57cec5SDimitry Andric __ml = __start_matching_list(false); 45710b57cec5SDimitry Andric __ml->__add_class(ctype_base::alnum); 45720b57cec5SDimitry Andric __ml->__add_char('_'); 45730b57cec5SDimitry Andric ++__first; 45740b57cec5SDimitry Andric break; 45750b57cec5SDimitry Andric case 'W': 45760b57cec5SDimitry Andric __ml = __start_matching_list(true); 45770b57cec5SDimitry Andric __ml->__add_class(ctype_base::alnum); 45780b57cec5SDimitry Andric __ml->__add_char('_'); 45790b57cec5SDimitry Andric ++__first; 45800b57cec5SDimitry Andric break; 45810b57cec5SDimitry Andric } 45820b57cec5SDimitry Andric } 45830b57cec5SDimitry Andric return __first; 45840b57cec5SDimitry Andric} 45850b57cec5SDimitry Andric 45860b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 45870b57cec5SDimitry Andrictemplate <class _ForwardIterator> 45880b57cec5SDimitry Andric_ForwardIterator 45890b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_character_escape(_ForwardIterator __first, 45900b57cec5SDimitry Andric _ForwardIterator __last, 45910b57cec5SDimitry Andric basic_string<_CharT>* __str) 45920b57cec5SDimitry Andric{ 45930b57cec5SDimitry Andric if (__first != __last) 45940b57cec5SDimitry Andric { 45950b57cec5SDimitry Andric _ForwardIterator __t; 45960b57cec5SDimitry Andric unsigned __sum = 0; 45970b57cec5SDimitry Andric int __hd; 45980b57cec5SDimitry Andric switch (*__first) 45990b57cec5SDimitry Andric { 46000b57cec5SDimitry Andric case 'f': 46010b57cec5SDimitry Andric if (__str) 46020b57cec5SDimitry Andric *__str = _CharT(0xC); 46030b57cec5SDimitry Andric else 46040b57cec5SDimitry Andric __push_char(_CharT(0xC)); 46050b57cec5SDimitry Andric ++__first; 46060b57cec5SDimitry Andric break; 46070b57cec5SDimitry Andric case 'n': 46080b57cec5SDimitry Andric if (__str) 46090b57cec5SDimitry Andric *__str = _CharT(0xA); 46100b57cec5SDimitry Andric else 46110b57cec5SDimitry Andric __push_char(_CharT(0xA)); 46120b57cec5SDimitry Andric ++__first; 46130b57cec5SDimitry Andric break; 46140b57cec5SDimitry Andric case 'r': 46150b57cec5SDimitry Andric if (__str) 46160b57cec5SDimitry Andric *__str = _CharT(0xD); 46170b57cec5SDimitry Andric else 46180b57cec5SDimitry Andric __push_char(_CharT(0xD)); 46190b57cec5SDimitry Andric ++__first; 46200b57cec5SDimitry Andric break; 46210b57cec5SDimitry Andric case 't': 46220b57cec5SDimitry Andric if (__str) 46230b57cec5SDimitry Andric *__str = _CharT(0x9); 46240b57cec5SDimitry Andric else 46250b57cec5SDimitry Andric __push_char(_CharT(0x9)); 46260b57cec5SDimitry Andric ++__first; 46270b57cec5SDimitry Andric break; 46280b57cec5SDimitry Andric case 'v': 46290b57cec5SDimitry Andric if (__str) 46300b57cec5SDimitry Andric *__str = _CharT(0xB); 46310b57cec5SDimitry Andric else 46320b57cec5SDimitry Andric __push_char(_CharT(0xB)); 46330b57cec5SDimitry Andric ++__first; 46340b57cec5SDimitry Andric break; 46350b57cec5SDimitry Andric case 'c': 4636*5f757f3fSDimitry Andric if ((__t = std::next(__first)) != __last) 46370b57cec5SDimitry Andric { 46380b57cec5SDimitry Andric if (('A' <= *__t && *__t <= 'Z') || 46390b57cec5SDimitry Andric ('a' <= *__t && *__t <= 'z')) 46400b57cec5SDimitry Andric { 46410b57cec5SDimitry Andric if (__str) 46420b57cec5SDimitry Andric *__str = _CharT(*__t % 32); 46430b57cec5SDimitry Andric else 46440b57cec5SDimitry Andric __push_char(_CharT(*__t % 32)); 46450b57cec5SDimitry Andric __first = ++__t; 46460b57cec5SDimitry Andric } 46470b57cec5SDimitry Andric else 46480b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_escape>(); 46490b57cec5SDimitry Andric } 46500b57cec5SDimitry Andric else 46510b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_escape>(); 46520b57cec5SDimitry Andric break; 46530b57cec5SDimitry Andric case 'u': 46540b57cec5SDimitry Andric ++__first; 46550b57cec5SDimitry Andric if (__first == __last) 46560b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_escape>(); 46570b57cec5SDimitry Andric __hd = __traits_.value(*__first, 16); 46580b57cec5SDimitry Andric if (__hd == -1) 46590b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_escape>(); 46600b57cec5SDimitry Andric __sum = 16 * __sum + static_cast<unsigned>(__hd); 46610b57cec5SDimitry Andric ++__first; 46620b57cec5SDimitry Andric if (__first == __last) 46630b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_escape>(); 46640b57cec5SDimitry Andric __hd = __traits_.value(*__first, 16); 46650b57cec5SDimitry Andric if (__hd == -1) 46660b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_escape>(); 46670b57cec5SDimitry Andric __sum = 16 * __sum + static_cast<unsigned>(__hd); 4668fe6060f1SDimitry Andric // fallthrough 46690b57cec5SDimitry Andric case 'x': 46700b57cec5SDimitry Andric ++__first; 46710b57cec5SDimitry Andric if (__first == __last) 46720b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_escape>(); 46730b57cec5SDimitry Andric __hd = __traits_.value(*__first, 16); 46740b57cec5SDimitry Andric if (__hd == -1) 46750b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_escape>(); 46760b57cec5SDimitry Andric __sum = 16 * __sum + static_cast<unsigned>(__hd); 46770b57cec5SDimitry Andric ++__first; 46780b57cec5SDimitry Andric if (__first == __last) 46790b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_escape>(); 46800b57cec5SDimitry Andric __hd = __traits_.value(*__first, 16); 46810b57cec5SDimitry Andric if (__hd == -1) 46820b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_escape>(); 46830b57cec5SDimitry Andric __sum = 16 * __sum + static_cast<unsigned>(__hd); 46840b57cec5SDimitry Andric if (__str) 46850b57cec5SDimitry Andric *__str = _CharT(__sum); 46860b57cec5SDimitry Andric else 46870b57cec5SDimitry Andric __push_char(_CharT(__sum)); 46880b57cec5SDimitry Andric ++__first; 46890b57cec5SDimitry Andric break; 46900b57cec5SDimitry Andric case '0': 46910b57cec5SDimitry Andric if (__str) 46920b57cec5SDimitry Andric *__str = _CharT(0); 46930b57cec5SDimitry Andric else 46940b57cec5SDimitry Andric __push_char(_CharT(0)); 46950b57cec5SDimitry Andric ++__first; 46960b57cec5SDimitry Andric break; 46970b57cec5SDimitry Andric default: 46980b57cec5SDimitry Andric if (*__first != '_' && !__traits_.isctype(*__first, ctype_base::alnum)) 46990b57cec5SDimitry Andric { 47000b57cec5SDimitry Andric if (__str) 47010b57cec5SDimitry Andric *__str = *__first; 47020b57cec5SDimitry Andric else 47030b57cec5SDimitry Andric __push_char(*__first); 47040b57cec5SDimitry Andric ++__first; 47050b57cec5SDimitry Andric } 47060b57cec5SDimitry Andric else 47070b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_escape>(); 47080b57cec5SDimitry Andric break; 47090b57cec5SDimitry Andric } 47100b57cec5SDimitry Andric } 47110b57cec5SDimitry Andric return __first; 47120b57cec5SDimitry Andric} 47130b57cec5SDimitry Andric 47140b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 47150b57cec5SDimitry Andrictemplate <class _ForwardIterator> 47160b57cec5SDimitry Andric_ForwardIterator 47170b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_pattern_character(_ForwardIterator __first, 47180b57cec5SDimitry Andric _ForwardIterator __last) 47190b57cec5SDimitry Andric{ 47200b57cec5SDimitry Andric if (__first != __last) 47210b57cec5SDimitry Andric { 47220b57cec5SDimitry Andric switch (*__first) 47230b57cec5SDimitry Andric { 47240b57cec5SDimitry Andric case '^': 47250b57cec5SDimitry Andric case '$': 47260b57cec5SDimitry Andric case '\\': 47270b57cec5SDimitry Andric case '.': 47280b57cec5SDimitry Andric case '*': 47290b57cec5SDimitry Andric case '+': 47300b57cec5SDimitry Andric case '?': 47310b57cec5SDimitry Andric case '(': 47320b57cec5SDimitry Andric case ')': 47330b57cec5SDimitry Andric case '[': 47340b57cec5SDimitry Andric case ']': 47350b57cec5SDimitry Andric case '{': 47360b57cec5SDimitry Andric case '}': 47370b57cec5SDimitry Andric case '|': 47380b57cec5SDimitry Andric break; 47390b57cec5SDimitry Andric default: 47400b57cec5SDimitry Andric __push_char(*__first); 47410b57cec5SDimitry Andric ++__first; 47420b57cec5SDimitry Andric break; 47430b57cec5SDimitry Andric } 47440b57cec5SDimitry Andric } 47450b57cec5SDimitry Andric return __first; 47460b57cec5SDimitry Andric} 47470b57cec5SDimitry Andric 47480b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 47490b57cec5SDimitry Andrictemplate <class _ForwardIterator> 47500b57cec5SDimitry Andric_ForwardIterator 47510b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_grep(_ForwardIterator __first, 47520b57cec5SDimitry Andric _ForwardIterator __last) 47530b57cec5SDimitry Andric{ 47540b57cec5SDimitry Andric __owns_one_state<_CharT>* __sa = __end_; 4755*5f757f3fSDimitry Andric _ForwardIterator __t1 = std::find(__first, __last, _CharT('\n')); 47560b57cec5SDimitry Andric if (__t1 != __first) 47570b57cec5SDimitry Andric __parse_basic_reg_exp(__first, __t1); 47580b57cec5SDimitry Andric else 47590b57cec5SDimitry Andric __push_empty(); 47600b57cec5SDimitry Andric __first = __t1; 47610b57cec5SDimitry Andric if (__first != __last) 47620b57cec5SDimitry Andric ++__first; 47630b57cec5SDimitry Andric while (__first != __last) 47640b57cec5SDimitry Andric { 4765*5f757f3fSDimitry Andric __t1 = std::find(__first, __last, _CharT('\n')); 47660b57cec5SDimitry Andric __owns_one_state<_CharT>* __sb = __end_; 47670b57cec5SDimitry Andric if (__t1 != __first) 47680b57cec5SDimitry Andric __parse_basic_reg_exp(__first, __t1); 47690b57cec5SDimitry Andric else 47700b57cec5SDimitry Andric __push_empty(); 47710b57cec5SDimitry Andric __push_alternation(__sa, __sb); 47720b57cec5SDimitry Andric __first = __t1; 47730b57cec5SDimitry Andric if (__first != __last) 47740b57cec5SDimitry Andric ++__first; 47750b57cec5SDimitry Andric } 47760b57cec5SDimitry Andric return __first; 47770b57cec5SDimitry Andric} 47780b57cec5SDimitry Andric 47790b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 47800b57cec5SDimitry Andrictemplate <class _ForwardIterator> 47810b57cec5SDimitry Andric_ForwardIterator 47820b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__parse_egrep(_ForwardIterator __first, 47830b57cec5SDimitry Andric _ForwardIterator __last) 47840b57cec5SDimitry Andric{ 47850b57cec5SDimitry Andric __owns_one_state<_CharT>* __sa = __end_; 4786*5f757f3fSDimitry Andric _ForwardIterator __t1 = std::find(__first, __last, _CharT('\n')); 47870b57cec5SDimitry Andric if (__t1 != __first) 47880b57cec5SDimitry Andric __parse_extended_reg_exp(__first, __t1); 47890b57cec5SDimitry Andric else 47900b57cec5SDimitry Andric __push_empty(); 47910b57cec5SDimitry Andric __first = __t1; 47920b57cec5SDimitry Andric if (__first != __last) 47930b57cec5SDimitry Andric ++__first; 47940b57cec5SDimitry Andric while (__first != __last) 47950b57cec5SDimitry Andric { 4796*5f757f3fSDimitry Andric __t1 = std::find(__first, __last, _CharT('\n')); 47970b57cec5SDimitry Andric __owns_one_state<_CharT>* __sb = __end_; 47980b57cec5SDimitry Andric if (__t1 != __first) 47990b57cec5SDimitry Andric __parse_extended_reg_exp(__first, __t1); 48000b57cec5SDimitry Andric else 48010b57cec5SDimitry Andric __push_empty(); 48020b57cec5SDimitry Andric __push_alternation(__sa, __sb); 48030b57cec5SDimitry Andric __first = __t1; 48040b57cec5SDimitry Andric if (__first != __last) 48050b57cec5SDimitry Andric ++__first; 48060b57cec5SDimitry Andric } 48070b57cec5SDimitry Andric return __first; 48080b57cec5SDimitry Andric} 48090b57cec5SDimitry Andric 48100b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 48115ffd83dbSDimitry Andricbool 4812753f127fSDimitry Andricbasic_regex<_CharT, _Traits>::__test_back_ref(_CharT __c) 48135ffd83dbSDimitry Andric{ 4814753f127fSDimitry Andric unsigned __val = __traits_.value(__c, 10); 48155ffd83dbSDimitry Andric if (__val >= 1 && __val <= 9) 48165ffd83dbSDimitry Andric { 48175ffd83dbSDimitry Andric if (__val > mark_count()) 48185ffd83dbSDimitry Andric __throw_regex_error<regex_constants::error_backref>(); 48195ffd83dbSDimitry Andric __push_back_ref(__val); 48205ffd83dbSDimitry Andric return true; 48215ffd83dbSDimitry Andric } 48225ffd83dbSDimitry Andric 48235ffd83dbSDimitry Andric return false; 48245ffd83dbSDimitry Andric} 48255ffd83dbSDimitry Andric 48265ffd83dbSDimitry Andrictemplate <class _CharT, class _Traits> 48270b57cec5SDimitry Andricvoid 48280b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__push_loop(size_t __min, size_t __max, 48290b57cec5SDimitry Andric __owns_one_state<_CharT>* __s, size_t __mexp_begin, size_t __mexp_end, 48300b57cec5SDimitry Andric bool __greedy) 48310b57cec5SDimitry Andric{ 48320b57cec5SDimitry Andric unique_ptr<__empty_state<_CharT> > __e1(new __empty_state<_CharT>(__end_->first())); 48330b57cec5SDimitry Andric __end_->first() = nullptr; 48340b57cec5SDimitry Andric unique_ptr<__loop<_CharT> > __e2(new __loop<_CharT>(__loop_count_, 48350b57cec5SDimitry Andric __s->first(), __e1.get(), __mexp_begin, __mexp_end, __greedy, 48360b57cec5SDimitry Andric __min, __max)); 48370b57cec5SDimitry Andric __s->first() = nullptr; 48380b57cec5SDimitry Andric __e1.release(); 48390b57cec5SDimitry Andric __end_->first() = new __repeat_one_loop<_CharT>(__e2.get()); 48400b57cec5SDimitry Andric __end_ = __e2->second(); 48410b57cec5SDimitry Andric __s->first() = __e2.release(); 48420b57cec5SDimitry Andric ++__loop_count_; 48430b57cec5SDimitry Andric} 48440b57cec5SDimitry Andric 48450b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 48460b57cec5SDimitry Andricvoid 48470b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__push_char(value_type __c) 48480b57cec5SDimitry Andric{ 48490b57cec5SDimitry Andric if (flags() & icase) 48500b57cec5SDimitry Andric __end_->first() = new __match_char_icase<_CharT, _Traits> 48510b57cec5SDimitry Andric (__traits_, __c, __end_->first()); 48520b57cec5SDimitry Andric else if (flags() & collate) 48530b57cec5SDimitry Andric __end_->first() = new __match_char_collate<_CharT, _Traits> 48540b57cec5SDimitry Andric (__traits_, __c, __end_->first()); 48550b57cec5SDimitry Andric else 48560b57cec5SDimitry Andric __end_->first() = new __match_char<_CharT>(__c, __end_->first()); 48570b57cec5SDimitry Andric __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first()); 48580b57cec5SDimitry Andric} 48590b57cec5SDimitry Andric 48600b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 48610b57cec5SDimitry Andricvoid 48620b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__push_begin_marked_subexpression() 48630b57cec5SDimitry Andric{ 48640b57cec5SDimitry Andric if (!(__flags_ & nosubs)) 48650b57cec5SDimitry Andric { 48660b57cec5SDimitry Andric __end_->first() = 48670b57cec5SDimitry Andric new __begin_marked_subexpression<_CharT>(++__marked_count_, 48680b57cec5SDimitry Andric __end_->first()); 48690b57cec5SDimitry Andric __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first()); 48700b57cec5SDimitry Andric } 48710b57cec5SDimitry Andric} 48720b57cec5SDimitry Andric 48730b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 48740b57cec5SDimitry Andricvoid 48750b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__push_end_marked_subexpression(unsigned __sub) 48760b57cec5SDimitry Andric{ 48770b57cec5SDimitry Andric if (!(__flags_ & nosubs)) 48780b57cec5SDimitry Andric { 48790b57cec5SDimitry Andric __end_->first() = 48800b57cec5SDimitry Andric new __end_marked_subexpression<_CharT>(__sub, __end_->first()); 48810b57cec5SDimitry Andric __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first()); 48820b57cec5SDimitry Andric } 48830b57cec5SDimitry Andric} 48840b57cec5SDimitry Andric 48850b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 48860b57cec5SDimitry Andricvoid 48870b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__push_l_anchor() 48880b57cec5SDimitry Andric{ 4889e8d8bef9SDimitry Andric __end_->first() = new __l_anchor_multiline<_CharT>(__use_multiline(), __end_->first()); 48900b57cec5SDimitry Andric __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first()); 48910b57cec5SDimitry Andric} 48920b57cec5SDimitry Andric 48930b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 48940b57cec5SDimitry Andricvoid 48950b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__push_r_anchor() 48960b57cec5SDimitry Andric{ 4897e8d8bef9SDimitry Andric __end_->first() = new __r_anchor_multiline<_CharT>(__use_multiline(), __end_->first()); 48980b57cec5SDimitry Andric __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first()); 48990b57cec5SDimitry Andric} 49000b57cec5SDimitry Andric 49010b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 49020b57cec5SDimitry Andricvoid 49030b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__push_match_any() 49040b57cec5SDimitry Andric{ 49050b57cec5SDimitry Andric __end_->first() = new __match_any<_CharT>(__end_->first()); 49060b57cec5SDimitry Andric __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first()); 49070b57cec5SDimitry Andric} 49080b57cec5SDimitry Andric 49090b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 49100b57cec5SDimitry Andricvoid 49110b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__push_match_any_but_newline() 49120b57cec5SDimitry Andric{ 49130b57cec5SDimitry Andric __end_->first() = new __match_any_but_newline<_CharT>(__end_->first()); 49140b57cec5SDimitry Andric __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first()); 49150b57cec5SDimitry Andric} 49160b57cec5SDimitry Andric 49170b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 49180b57cec5SDimitry Andricvoid 49190b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__push_empty() 49200b57cec5SDimitry Andric{ 49210b57cec5SDimitry Andric __end_->first() = new __empty_state<_CharT>(__end_->first()); 49220b57cec5SDimitry Andric __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first()); 49230b57cec5SDimitry Andric} 49240b57cec5SDimitry Andric 49250b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 49260b57cec5SDimitry Andricvoid 49270b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__push_word_boundary(bool __invert) 49280b57cec5SDimitry Andric{ 49290b57cec5SDimitry Andric __end_->first() = new __word_boundary<_CharT, _Traits>(__traits_, __invert, 49300b57cec5SDimitry Andric __end_->first()); 49310b57cec5SDimitry Andric __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first()); 49320b57cec5SDimitry Andric} 49330b57cec5SDimitry Andric 49340b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 49350b57cec5SDimitry Andricvoid 49360b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__push_back_ref(int __i) 49370b57cec5SDimitry Andric{ 49380b57cec5SDimitry Andric if (flags() & icase) 49390b57cec5SDimitry Andric __end_->first() = new __back_ref_icase<_CharT, _Traits> 49400b57cec5SDimitry Andric (__traits_, __i, __end_->first()); 49410b57cec5SDimitry Andric else if (flags() & collate) 49420b57cec5SDimitry Andric __end_->first() = new __back_ref_collate<_CharT, _Traits> 49430b57cec5SDimitry Andric (__traits_, __i, __end_->first()); 49440b57cec5SDimitry Andric else 49450b57cec5SDimitry Andric __end_->first() = new __back_ref<_CharT>(__i, __end_->first()); 49460b57cec5SDimitry Andric __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first()); 49470b57cec5SDimitry Andric} 49480b57cec5SDimitry Andric 49490b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 49500b57cec5SDimitry Andricvoid 49510b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__push_alternation(__owns_one_state<_CharT>* __sa, 49520b57cec5SDimitry Andric __owns_one_state<_CharT>* __ea) 49530b57cec5SDimitry Andric{ 49540b57cec5SDimitry Andric __sa->first() = new __alternate<_CharT>( 49550b57cec5SDimitry Andric static_cast<__owns_one_state<_CharT>*>(__sa->first()), 49560b57cec5SDimitry Andric static_cast<__owns_one_state<_CharT>*>(__ea->first())); 49570b57cec5SDimitry Andric __ea->first() = nullptr; 49580b57cec5SDimitry Andric __ea->first() = new __empty_state<_CharT>(__end_->first()); 49590b57cec5SDimitry Andric __end_->first() = nullptr; 49600b57cec5SDimitry Andric __end_->first() = new __empty_non_own_state<_CharT>(__ea->first()); 49610b57cec5SDimitry Andric __end_ = static_cast<__owns_one_state<_CharT>*>(__ea->first()); 49620b57cec5SDimitry Andric} 49630b57cec5SDimitry Andric 49640b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 49650b57cec5SDimitry Andric__bracket_expression<_CharT, _Traits>* 49660b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__start_matching_list(bool __negate) 49670b57cec5SDimitry Andric{ 49680b57cec5SDimitry Andric __bracket_expression<_CharT, _Traits>* __r = 49690b57cec5SDimitry Andric new __bracket_expression<_CharT, _Traits>(__traits_, __end_->first(), 49700b57cec5SDimitry Andric __negate, __flags_ & icase, 49710b57cec5SDimitry Andric __flags_ & collate); 49720b57cec5SDimitry Andric __end_->first() = __r; 49730b57cec5SDimitry Andric __end_ = __r; 49740b57cec5SDimitry Andric return __r; 49750b57cec5SDimitry Andric} 49760b57cec5SDimitry Andric 49770b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 49780b57cec5SDimitry Andricvoid 49790b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__push_lookahead(const basic_regex& __exp, 49800b57cec5SDimitry Andric bool __invert, 49810b57cec5SDimitry Andric unsigned __mexp) 49820b57cec5SDimitry Andric{ 49830b57cec5SDimitry Andric __end_->first() = new __lookahead<_CharT, _Traits>(__exp, __invert, 49840b57cec5SDimitry Andric __end_->first(), __mexp); 49850b57cec5SDimitry Andric __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first()); 49860b57cec5SDimitry Andric} 49870b57cec5SDimitry Andric 49880b57cec5SDimitry Andric// sub_match 49890b57cec5SDimitry Andric 4990e8d8bef9SDimitry Andrictypedef sub_match<const char*> csub_match; 4991e8d8bef9SDimitry Andrictypedef sub_match<string::const_iterator> ssub_match; 4992349cc55cSDimitry Andric#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 4993349cc55cSDimitry Andrictypedef sub_match<const wchar_t*> wcsub_match; 4994e8d8bef9SDimitry Andrictypedef sub_match<wstring::const_iterator> wssub_match; 4995349cc55cSDimitry Andric#endif 4996e8d8bef9SDimitry Andric 49970b57cec5SDimitry Andrictemplate <class _BidirectionalIterator> 4998e8d8bef9SDimitry Andricclass 4999e8d8bef9SDimitry Andric _LIBCPP_TEMPLATE_VIS 5000e8d8bef9SDimitry Andric _LIBCPP_PREFERRED_NAME(csub_match) 5001349cc55cSDimitry Andric _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wcsub_match)) 5002e8d8bef9SDimitry Andric _LIBCPP_PREFERRED_NAME(ssub_match) 5003349cc55cSDimitry Andric _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wssub_match)) 5004e8d8bef9SDimitry Andric sub_match 50050b57cec5SDimitry Andric : public pair<_BidirectionalIterator, _BidirectionalIterator> 50060b57cec5SDimitry Andric{ 50070b57cec5SDimitry Andricpublic: 50080b57cec5SDimitry Andric typedef _BidirectionalIterator iterator; 50090b57cec5SDimitry Andric typedef typename iterator_traits<iterator>::value_type value_type; 50100b57cec5SDimitry Andric typedef typename iterator_traits<iterator>::difference_type difference_type; 50110b57cec5SDimitry Andric typedef basic_string<value_type> string_type; 50120b57cec5SDimitry Andric 50130b57cec5SDimitry Andric bool matched; 50140b57cec5SDimitry Andric 5015*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 50160b57cec5SDimitry Andric _LIBCPP_CONSTEXPR sub_match() : matched() {} 50170b57cec5SDimitry Andric 5018*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 50190b57cec5SDimitry Andric difference_type length() const 5020*5f757f3fSDimitry Andric {return matched ? std::distance(this->first, this->second) : 0;} 5021*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 50220b57cec5SDimitry Andric string_type str() const 50230b57cec5SDimitry Andric {return matched ? string_type(this->first, this->second) : string_type();} 5024*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 50250b57cec5SDimitry Andric operator string_type() const 50260b57cec5SDimitry Andric {return str();} 50270b57cec5SDimitry Andric 5028*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 50290b57cec5SDimitry Andric int compare(const sub_match& __s) const 50300b57cec5SDimitry Andric {return str().compare(__s.str());} 5031*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 50320b57cec5SDimitry Andric int compare(const string_type& __s) const 50330b57cec5SDimitry Andric {return str().compare(__s);} 5034*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 50350b57cec5SDimitry Andric int compare(const value_type* __s) const 50360b57cec5SDimitry Andric {return str().compare(__s);} 503706c3fb27SDimitry Andric 503806c3fb27SDimitry Andric _LIBCPP_HIDE_FROM_ABI 503906c3fb27SDimitry Andric void swap(sub_match& __s) 504006c3fb27SDimitry Andric#ifndef _LIBCPP_CXX03_LANG 504106c3fb27SDimitry Andric _NOEXCEPT(__is_nothrow_swappable<_BidirectionalIterator>::value) 504206c3fb27SDimitry Andric#endif // _LIBCPP_CXX03_LANG 504306c3fb27SDimitry Andric { 504406c3fb27SDimitry Andric this->pair<_BidirectionalIterator, _BidirectionalIterator>::swap(__s); 504506c3fb27SDimitry Andric std::swap(matched, __s.matched); 504606c3fb27SDimitry Andric } 50470b57cec5SDimitry Andric}; 50480b57cec5SDimitry Andric 50490b57cec5SDimitry Andrictemplate <class _BiIter> 5050*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 50510b57cec5SDimitry Andricbool 50520b57cec5SDimitry Andricoperator==(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y) 50530b57cec5SDimitry Andric{ 50540b57cec5SDimitry Andric return __x.compare(__y) == 0; 50550b57cec5SDimitry Andric} 50560b57cec5SDimitry Andric 505706c3fb27SDimitry Andric#if _LIBCPP_STD_VER >= 20 505806c3fb27SDimitry Andrictemplate<class _BiIter> 505906c3fb27SDimitry Andricusing __sub_match_cat = compare_three_way_result_t<basic_string<typename iterator_traits<_BiIter>::value_type>>; 506006c3fb27SDimitry Andric 506106c3fb27SDimitry Andrictemplate <class _BiIter> 506206c3fb27SDimitry Andric_LIBCPP_HIDE_FROM_ABI auto operator<=>(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y) { 506306c3fb27SDimitry Andric return static_cast<__sub_match_cat<_BiIter>>(__x.compare(__y) <=> 0); 506406c3fb27SDimitry Andric} 506506c3fb27SDimitry Andric#else // _LIBCPP_STD_VER >= 20 50660b57cec5SDimitry Andrictemplate <class _BiIter> 5067*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 50680b57cec5SDimitry Andricbool 50690b57cec5SDimitry Andricoperator!=(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y) 50700b57cec5SDimitry Andric{ 50710b57cec5SDimitry Andric return !(__x == __y); 50720b57cec5SDimitry Andric} 50730b57cec5SDimitry Andric 50740b57cec5SDimitry Andrictemplate <class _BiIter> 5075*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 50760b57cec5SDimitry Andricbool 50770b57cec5SDimitry Andricoperator<(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y) 50780b57cec5SDimitry Andric{ 50790b57cec5SDimitry Andric return __x.compare(__y) < 0; 50800b57cec5SDimitry Andric} 50810b57cec5SDimitry Andric 50820b57cec5SDimitry Andrictemplate <class _BiIter> 5083*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 50840b57cec5SDimitry Andricbool 50850b57cec5SDimitry Andricoperator<=(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y) 50860b57cec5SDimitry Andric{ 50870b57cec5SDimitry Andric return !(__y < __x); 50880b57cec5SDimitry Andric} 50890b57cec5SDimitry Andric 50900b57cec5SDimitry Andrictemplate <class _BiIter> 5091*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 50920b57cec5SDimitry Andricbool 50930b57cec5SDimitry Andricoperator>=(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y) 50940b57cec5SDimitry Andric{ 50950b57cec5SDimitry Andric return !(__x < __y); 50960b57cec5SDimitry Andric} 50970b57cec5SDimitry Andric 50980b57cec5SDimitry Andrictemplate <class _BiIter> 5099*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 51000b57cec5SDimitry Andricbool 51010b57cec5SDimitry Andricoperator>(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y) 51020b57cec5SDimitry Andric{ 51030b57cec5SDimitry Andric return __y < __x; 51040b57cec5SDimitry Andric} 51050b57cec5SDimitry Andric 51060b57cec5SDimitry Andrictemplate <class _BiIter, class _ST, class _SA> 5107*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 51080b57cec5SDimitry Andricbool 51090b57cec5SDimitry Andricoperator==(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x, 51100b57cec5SDimitry Andric const sub_match<_BiIter>& __y) 51110b57cec5SDimitry Andric{ 51120b57cec5SDimitry Andric return __y.compare(typename sub_match<_BiIter>::string_type(__x.data(), __x.size())) == 0; 51130b57cec5SDimitry Andric} 51140b57cec5SDimitry Andric 51150b57cec5SDimitry Andrictemplate <class _BiIter, class _ST, class _SA> 5116*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 51170b57cec5SDimitry Andricbool 51180b57cec5SDimitry Andricoperator!=(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x, 51190b57cec5SDimitry Andric const sub_match<_BiIter>& __y) 51200b57cec5SDimitry Andric{ 51210b57cec5SDimitry Andric return !(__x == __y); 51220b57cec5SDimitry Andric} 51230b57cec5SDimitry Andric 51240b57cec5SDimitry Andrictemplate <class _BiIter, class _ST, class _SA> 5125*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 51260b57cec5SDimitry Andricbool 51270b57cec5SDimitry Andricoperator<(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x, 51280b57cec5SDimitry Andric const sub_match<_BiIter>& __y) 51290b57cec5SDimitry Andric{ 51300b57cec5SDimitry Andric return __y.compare(typename sub_match<_BiIter>::string_type(__x.data(), __x.size())) > 0; 51310b57cec5SDimitry Andric} 51320b57cec5SDimitry Andric 51330b57cec5SDimitry Andrictemplate <class _BiIter, class _ST, class _SA> 5134*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 51350b57cec5SDimitry Andricbool 51360b57cec5SDimitry Andricoperator>(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x, 51370b57cec5SDimitry Andric const sub_match<_BiIter>& __y) 51380b57cec5SDimitry Andric{ 51390b57cec5SDimitry Andric return __y < __x; 51400b57cec5SDimitry Andric} 51410b57cec5SDimitry Andric 51420b57cec5SDimitry Andrictemplate <class _BiIter, class _ST, class _SA> 5143*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 51440b57cec5SDimitry Andricbool operator>=(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x, 51450b57cec5SDimitry Andric const sub_match<_BiIter>& __y) 51460b57cec5SDimitry Andric{ 51470b57cec5SDimitry Andric return !(__x < __y); 51480b57cec5SDimitry Andric} 51490b57cec5SDimitry Andric 51500b57cec5SDimitry Andrictemplate <class _BiIter, class _ST, class _SA> 5151*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 51520b57cec5SDimitry Andricbool 51530b57cec5SDimitry Andricoperator<=(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x, 51540b57cec5SDimitry Andric const sub_match<_BiIter>& __y) 51550b57cec5SDimitry Andric{ 51560b57cec5SDimitry Andric return !(__y < __x); 51570b57cec5SDimitry Andric} 515806c3fb27SDimitry Andric#endif // _LIBCPP_STD_VER >= 20 51590b57cec5SDimitry Andric 51600b57cec5SDimitry Andrictemplate <class _BiIter, class _ST, class _SA> 5161*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 51620b57cec5SDimitry Andricbool 51630b57cec5SDimitry Andricoperator==(const sub_match<_BiIter>& __x, 51640b57cec5SDimitry Andric const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y) 51650b57cec5SDimitry Andric{ 51660b57cec5SDimitry Andric return __x.compare(typename sub_match<_BiIter>::string_type(__y.data(), __y.size())) == 0; 51670b57cec5SDimitry Andric} 51680b57cec5SDimitry Andric 516906c3fb27SDimitry Andric#if _LIBCPP_STD_VER >= 20 517006c3fb27SDimitry Andrictemplate <class _BiIter, class _ST, class _SA> 517106c3fb27SDimitry Andric_LIBCPP_HIDE_FROM_ABI auto operator<=>( 517206c3fb27SDimitry Andric const sub_match<_BiIter>& __x, const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y) { 517306c3fb27SDimitry Andric return static_cast<__sub_match_cat<_BiIter>>( 517406c3fb27SDimitry Andric __x.compare(typename sub_match<_BiIter>::string_type(__y.data(), __y.size())) <=> 0); 517506c3fb27SDimitry Andric} 517606c3fb27SDimitry Andric#else // _LIBCPP_STD_VER >= 20 51770b57cec5SDimitry Andrictemplate <class _BiIter, class _ST, class _SA> 5178*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 51790b57cec5SDimitry Andricbool 51800b57cec5SDimitry Andricoperator!=(const sub_match<_BiIter>& __x, 51810b57cec5SDimitry Andric const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y) 51820b57cec5SDimitry Andric{ 51830b57cec5SDimitry Andric return !(__x == __y); 51840b57cec5SDimitry Andric} 51850b57cec5SDimitry Andric 51860b57cec5SDimitry Andrictemplate <class _BiIter, class _ST, class _SA> 5187*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 51880b57cec5SDimitry Andricbool 51890b57cec5SDimitry Andricoperator<(const sub_match<_BiIter>& __x, 51900b57cec5SDimitry Andric const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y) 51910b57cec5SDimitry Andric{ 51920b57cec5SDimitry Andric return __x.compare(typename sub_match<_BiIter>::string_type(__y.data(), __y.size())) < 0; 51930b57cec5SDimitry Andric} 51940b57cec5SDimitry Andric 51950b57cec5SDimitry Andrictemplate <class _BiIter, class _ST, class _SA> 5196*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 51970b57cec5SDimitry Andricbool operator>(const sub_match<_BiIter>& __x, 51980b57cec5SDimitry Andric const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y) 51990b57cec5SDimitry Andric{ 52000b57cec5SDimitry Andric return __y < __x; 52010b57cec5SDimitry Andric} 52020b57cec5SDimitry Andric 52030b57cec5SDimitry Andrictemplate <class _BiIter, class _ST, class _SA> 5204*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 52050b57cec5SDimitry Andricbool 52060b57cec5SDimitry Andricoperator>=(const sub_match<_BiIter>& __x, 52070b57cec5SDimitry Andric const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y) 52080b57cec5SDimitry Andric{ 52090b57cec5SDimitry Andric return !(__x < __y); 52100b57cec5SDimitry Andric} 52110b57cec5SDimitry Andric 52120b57cec5SDimitry Andrictemplate <class _BiIter, class _ST, class _SA> 5213*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 52140b57cec5SDimitry Andricbool 52150b57cec5SDimitry Andricoperator<=(const sub_match<_BiIter>& __x, 52160b57cec5SDimitry Andric const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y) 52170b57cec5SDimitry Andric{ 52180b57cec5SDimitry Andric return !(__y < __x); 52190b57cec5SDimitry Andric} 52200b57cec5SDimitry Andric 52210b57cec5SDimitry Andrictemplate <class _BiIter> 5222*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 52230b57cec5SDimitry Andricbool 52240b57cec5SDimitry Andricoperator==(typename iterator_traits<_BiIter>::value_type const* __x, 52250b57cec5SDimitry Andric const sub_match<_BiIter>& __y) 52260b57cec5SDimitry Andric{ 52270b57cec5SDimitry Andric return __y.compare(__x) == 0; 52280b57cec5SDimitry Andric} 52290b57cec5SDimitry Andric 52300b57cec5SDimitry Andrictemplate <class _BiIter> 5231*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 52320b57cec5SDimitry Andricbool 52330b57cec5SDimitry Andricoperator!=(typename iterator_traits<_BiIter>::value_type const* __x, 52340b57cec5SDimitry Andric const sub_match<_BiIter>& __y) 52350b57cec5SDimitry Andric{ 52360b57cec5SDimitry Andric return !(__x == __y); 52370b57cec5SDimitry Andric} 52380b57cec5SDimitry Andric 52390b57cec5SDimitry Andrictemplate <class _BiIter> 5240*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 52410b57cec5SDimitry Andricbool 52420b57cec5SDimitry Andricoperator<(typename iterator_traits<_BiIter>::value_type const* __x, 52430b57cec5SDimitry Andric const sub_match<_BiIter>& __y) 52440b57cec5SDimitry Andric{ 52450b57cec5SDimitry Andric return __y.compare(__x) > 0; 52460b57cec5SDimitry Andric} 52470b57cec5SDimitry Andric 52480b57cec5SDimitry Andrictemplate <class _BiIter> 5249*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 52500b57cec5SDimitry Andricbool 52510b57cec5SDimitry Andricoperator>(typename iterator_traits<_BiIter>::value_type const* __x, 52520b57cec5SDimitry Andric const sub_match<_BiIter>& __y) 52530b57cec5SDimitry Andric{ 52540b57cec5SDimitry Andric return __y < __x; 52550b57cec5SDimitry Andric} 52560b57cec5SDimitry Andric 52570b57cec5SDimitry Andrictemplate <class _BiIter> 5258*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 52590b57cec5SDimitry Andricbool 52600b57cec5SDimitry Andricoperator>=(typename iterator_traits<_BiIter>::value_type const* __x, 52610b57cec5SDimitry Andric const sub_match<_BiIter>& __y) 52620b57cec5SDimitry Andric{ 52630b57cec5SDimitry Andric return !(__x < __y); 52640b57cec5SDimitry Andric} 52650b57cec5SDimitry Andric 52660b57cec5SDimitry Andrictemplate <class _BiIter> 5267*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 52680b57cec5SDimitry Andricbool 52690b57cec5SDimitry Andricoperator<=(typename iterator_traits<_BiIter>::value_type const* __x, 52700b57cec5SDimitry Andric const sub_match<_BiIter>& __y) 52710b57cec5SDimitry Andric{ 52720b57cec5SDimitry Andric return !(__y < __x); 52730b57cec5SDimitry Andric} 527406c3fb27SDimitry Andric#endif // _LIBCPP_STD_VER >= 20 52750b57cec5SDimitry Andric 52760b57cec5SDimitry Andrictemplate <class _BiIter> 5277*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 52780b57cec5SDimitry Andricbool 52790b57cec5SDimitry Andricoperator==(const sub_match<_BiIter>& __x, 52800b57cec5SDimitry Andric typename iterator_traits<_BiIter>::value_type const* __y) 52810b57cec5SDimitry Andric{ 52820b57cec5SDimitry Andric return __x.compare(__y) == 0; 52830b57cec5SDimitry Andric} 52840b57cec5SDimitry Andric 528506c3fb27SDimitry Andric#if _LIBCPP_STD_VER >= 20 528606c3fb27SDimitry Andrictemplate <class _BiIter> 528706c3fb27SDimitry Andric_LIBCPP_HIDE_FROM_ABI auto 528806c3fb27SDimitry Andricoperator<=>(const sub_match<_BiIter>& __x, typename iterator_traits<_BiIter>::value_type const* __y) { 528906c3fb27SDimitry Andric return static_cast<__sub_match_cat<_BiIter>>(__x.compare(__y) <=> 0); 529006c3fb27SDimitry Andric} 529106c3fb27SDimitry Andric#else // _LIBCPP_STD_VER >= 20 52920b57cec5SDimitry Andrictemplate <class _BiIter> 5293*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 52940b57cec5SDimitry Andricbool 52950b57cec5SDimitry Andricoperator!=(const sub_match<_BiIter>& __x, 52960b57cec5SDimitry Andric typename iterator_traits<_BiIter>::value_type const* __y) 52970b57cec5SDimitry Andric{ 52980b57cec5SDimitry Andric return !(__x == __y); 52990b57cec5SDimitry Andric} 53000b57cec5SDimitry Andric 53010b57cec5SDimitry Andrictemplate <class _BiIter> 5302*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 53030b57cec5SDimitry Andricbool 53040b57cec5SDimitry Andricoperator<(const sub_match<_BiIter>& __x, 53050b57cec5SDimitry Andric typename iterator_traits<_BiIter>::value_type const* __y) 53060b57cec5SDimitry Andric{ 53070b57cec5SDimitry Andric return __x.compare(__y) < 0; 53080b57cec5SDimitry Andric} 53090b57cec5SDimitry Andric 53100b57cec5SDimitry Andrictemplate <class _BiIter> 5311*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 53120b57cec5SDimitry Andricbool 53130b57cec5SDimitry Andricoperator>(const sub_match<_BiIter>& __x, 53140b57cec5SDimitry Andric typename iterator_traits<_BiIter>::value_type const* __y) 53150b57cec5SDimitry Andric{ 53160b57cec5SDimitry Andric return __y < __x; 53170b57cec5SDimitry Andric} 53180b57cec5SDimitry Andric 53190b57cec5SDimitry Andrictemplate <class _BiIter> 5320*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 53210b57cec5SDimitry Andricbool 53220b57cec5SDimitry Andricoperator>=(const sub_match<_BiIter>& __x, 53230b57cec5SDimitry Andric typename iterator_traits<_BiIter>::value_type const* __y) 53240b57cec5SDimitry Andric{ 53250b57cec5SDimitry Andric return !(__x < __y); 53260b57cec5SDimitry Andric} 53270b57cec5SDimitry Andric 53280b57cec5SDimitry Andrictemplate <class _BiIter> 5329*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 53300b57cec5SDimitry Andricbool 53310b57cec5SDimitry Andricoperator<=(const sub_match<_BiIter>& __x, 53320b57cec5SDimitry Andric typename iterator_traits<_BiIter>::value_type const* __y) 53330b57cec5SDimitry Andric{ 53340b57cec5SDimitry Andric return !(__y < __x); 53350b57cec5SDimitry Andric} 53360b57cec5SDimitry Andric 53370b57cec5SDimitry Andrictemplate <class _BiIter> 5338*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 53390b57cec5SDimitry Andricbool 53400b57cec5SDimitry Andricoperator==(typename iterator_traits<_BiIter>::value_type const& __x, 53410b57cec5SDimitry Andric const sub_match<_BiIter>& __y) 53420b57cec5SDimitry Andric{ 53430b57cec5SDimitry Andric typedef basic_string<typename iterator_traits<_BiIter>::value_type> string_type; 53440b57cec5SDimitry Andric return __y.compare(string_type(1, __x)) == 0; 53450b57cec5SDimitry Andric} 53460b57cec5SDimitry Andric 53470b57cec5SDimitry Andrictemplate <class _BiIter> 5348*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 53490b57cec5SDimitry Andricbool 53500b57cec5SDimitry Andricoperator!=(typename iterator_traits<_BiIter>::value_type const& __x, 53510b57cec5SDimitry Andric const sub_match<_BiIter>& __y) 53520b57cec5SDimitry Andric{ 53530b57cec5SDimitry Andric return !(__x == __y); 53540b57cec5SDimitry Andric} 53550b57cec5SDimitry Andric 53560b57cec5SDimitry Andrictemplate <class _BiIter> 5357*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 53580b57cec5SDimitry Andricbool 53590b57cec5SDimitry Andricoperator<(typename iterator_traits<_BiIter>::value_type const& __x, 53600b57cec5SDimitry Andric const sub_match<_BiIter>& __y) 53610b57cec5SDimitry Andric{ 53620b57cec5SDimitry Andric typedef basic_string<typename iterator_traits<_BiIter>::value_type> string_type; 53630b57cec5SDimitry Andric return __y.compare(string_type(1, __x)) > 0; 53640b57cec5SDimitry Andric} 53650b57cec5SDimitry Andric 53660b57cec5SDimitry Andrictemplate <class _BiIter> 5367*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 53680b57cec5SDimitry Andricbool 53690b57cec5SDimitry Andricoperator>(typename iterator_traits<_BiIter>::value_type const& __x, 53700b57cec5SDimitry Andric const sub_match<_BiIter>& __y) 53710b57cec5SDimitry Andric{ 53720b57cec5SDimitry Andric return __y < __x; 53730b57cec5SDimitry Andric} 53740b57cec5SDimitry Andric 53750b57cec5SDimitry Andrictemplate <class _BiIter> 5376*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 53770b57cec5SDimitry Andricbool 53780b57cec5SDimitry Andricoperator>=(typename iterator_traits<_BiIter>::value_type const& __x, 53790b57cec5SDimitry Andric const sub_match<_BiIter>& __y) 53800b57cec5SDimitry Andric{ 53810b57cec5SDimitry Andric return !(__x < __y); 53820b57cec5SDimitry Andric} 53830b57cec5SDimitry Andric 53840b57cec5SDimitry Andrictemplate <class _BiIter> 5385*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 53860b57cec5SDimitry Andricbool 53870b57cec5SDimitry Andricoperator<=(typename iterator_traits<_BiIter>::value_type const& __x, 53880b57cec5SDimitry Andric const sub_match<_BiIter>& __y) 53890b57cec5SDimitry Andric{ 53900b57cec5SDimitry Andric return !(__y < __x); 53910b57cec5SDimitry Andric} 539206c3fb27SDimitry Andric#endif // _LIBCPP_STD_VER >= 20 53930b57cec5SDimitry Andric 53940b57cec5SDimitry Andrictemplate <class _BiIter> 5395*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 53960b57cec5SDimitry Andricbool 53970b57cec5SDimitry Andricoperator==(const sub_match<_BiIter>& __x, 53980b57cec5SDimitry Andric typename iterator_traits<_BiIter>::value_type const& __y) 53990b57cec5SDimitry Andric{ 54000b57cec5SDimitry Andric typedef basic_string<typename iterator_traits<_BiIter>::value_type> string_type; 54010b57cec5SDimitry Andric return __x.compare(string_type(1, __y)) == 0; 54020b57cec5SDimitry Andric} 54030b57cec5SDimitry Andric 540406c3fb27SDimitry Andric#if _LIBCPP_STD_VER >= 20 540506c3fb27SDimitry Andrictemplate <class _BiIter> 540606c3fb27SDimitry Andric_LIBCPP_HIDE_FROM_ABI auto 540706c3fb27SDimitry Andricoperator<=>(const sub_match<_BiIter>& __x, typename iterator_traits<_BiIter>::value_type const& __y) { 540806c3fb27SDimitry Andric using string_type = basic_string<typename iterator_traits<_BiIter>::value_type>; 540906c3fb27SDimitry Andric return static_cast<__sub_match_cat<_BiIter>>(__x.compare(string_type(1, __y)) <=> 0); 541006c3fb27SDimitry Andric} 541106c3fb27SDimitry Andric#else // _LIBCPP_STD_VER >= 20 54120b57cec5SDimitry Andrictemplate <class _BiIter> 5413*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 54140b57cec5SDimitry Andricbool 54150b57cec5SDimitry Andricoperator!=(const sub_match<_BiIter>& __x, 54160b57cec5SDimitry Andric typename iterator_traits<_BiIter>::value_type const& __y) 54170b57cec5SDimitry Andric{ 54180b57cec5SDimitry Andric return !(__x == __y); 54190b57cec5SDimitry Andric} 54200b57cec5SDimitry Andric 54210b57cec5SDimitry Andrictemplate <class _BiIter> 5422*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 54230b57cec5SDimitry Andricbool 54240b57cec5SDimitry Andricoperator<(const sub_match<_BiIter>& __x, 54250b57cec5SDimitry Andric typename iterator_traits<_BiIter>::value_type const& __y) 54260b57cec5SDimitry Andric{ 54270b57cec5SDimitry Andric typedef basic_string<typename iterator_traits<_BiIter>::value_type> string_type; 54280b57cec5SDimitry Andric return __x.compare(string_type(1, __y)) < 0; 54290b57cec5SDimitry Andric} 54300b57cec5SDimitry Andric 54310b57cec5SDimitry Andrictemplate <class _BiIter> 5432*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 54330b57cec5SDimitry Andricbool 54340b57cec5SDimitry Andricoperator>(const sub_match<_BiIter>& __x, 54350b57cec5SDimitry Andric typename iterator_traits<_BiIter>::value_type const& __y) 54360b57cec5SDimitry Andric{ 54370b57cec5SDimitry Andric return __y < __x; 54380b57cec5SDimitry Andric} 54390b57cec5SDimitry Andric 54400b57cec5SDimitry Andrictemplate <class _BiIter> 5441*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 54420b57cec5SDimitry Andricbool 54430b57cec5SDimitry Andricoperator>=(const sub_match<_BiIter>& __x, 54440b57cec5SDimitry Andric typename iterator_traits<_BiIter>::value_type const& __y) 54450b57cec5SDimitry Andric{ 54460b57cec5SDimitry Andric return !(__x < __y); 54470b57cec5SDimitry Andric} 54480b57cec5SDimitry Andric 54490b57cec5SDimitry Andrictemplate <class _BiIter> 5450*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 54510b57cec5SDimitry Andricbool 54520b57cec5SDimitry Andricoperator<=(const sub_match<_BiIter>& __x, 54530b57cec5SDimitry Andric typename iterator_traits<_BiIter>::value_type const& __y) 54540b57cec5SDimitry Andric{ 54550b57cec5SDimitry Andric return !(__y < __x); 54560b57cec5SDimitry Andric} 545706c3fb27SDimitry Andric#endif // _LIBCPP_STD_VER >= 20 54580b57cec5SDimitry Andric 54590b57cec5SDimitry Andrictemplate <class _CharT, class _ST, class _BiIter> 5460*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 54610b57cec5SDimitry Andricbasic_ostream<_CharT, _ST>& 54620b57cec5SDimitry Andricoperator<<(basic_ostream<_CharT, _ST>& __os, const sub_match<_BiIter>& __m) 54630b57cec5SDimitry Andric{ 54640b57cec5SDimitry Andric return __os << __m.str(); 54650b57cec5SDimitry Andric} 54660b57cec5SDimitry Andric 5467e8d8bef9SDimitry Andrictypedef match_results<const char*> cmatch; 5468e8d8bef9SDimitry Andrictypedef match_results<string::const_iterator> smatch; 5469349cc55cSDimitry Andric#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 5470349cc55cSDimitry Andrictypedef match_results<const wchar_t*> wcmatch; 5471e8d8bef9SDimitry Andrictypedef match_results<wstring::const_iterator> wsmatch; 5472349cc55cSDimitry Andric#endif 5473e8d8bef9SDimitry Andric 54740b57cec5SDimitry Andrictemplate <class _BidirectionalIterator, class _Allocator> 5475e8d8bef9SDimitry Andricclass 5476e8d8bef9SDimitry Andric _LIBCPP_TEMPLATE_VIS 5477e8d8bef9SDimitry Andric _LIBCPP_PREFERRED_NAME(cmatch) 5478349cc55cSDimitry Andric _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wcmatch)) 5479e8d8bef9SDimitry Andric _LIBCPP_PREFERRED_NAME(smatch) 5480349cc55cSDimitry Andric _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wsmatch)) 5481e8d8bef9SDimitry Andric match_results 54820b57cec5SDimitry Andric{ 54830b57cec5SDimitry Andricpublic: 54840b57cec5SDimitry Andric typedef _Allocator allocator_type; 54850b57cec5SDimitry Andric typedef sub_match<_BidirectionalIterator> value_type; 54860b57cec5SDimitry Andricprivate: 54870b57cec5SDimitry Andric typedef vector<value_type, allocator_type> __container_type; 54880b57cec5SDimitry Andric 54890b57cec5SDimitry Andric __container_type __matches_; 54900b57cec5SDimitry Andric value_type __unmatched_; 54910b57cec5SDimitry Andric value_type __prefix_; 54920b57cec5SDimitry Andric value_type __suffix_; 54930b57cec5SDimitry Andric bool __ready_; 54940b57cec5SDimitry Andricpublic: 54950b57cec5SDimitry Andric _BidirectionalIterator __position_start_; 54960b57cec5SDimitry Andric typedef const value_type& const_reference; 54970b57cec5SDimitry Andric typedef value_type& reference; 54980b57cec5SDimitry Andric typedef typename __container_type::const_iterator const_iterator; 54990b57cec5SDimitry Andric typedef const_iterator iterator; 55000b57cec5SDimitry Andric typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type; 55010b57cec5SDimitry Andric typedef typename allocator_traits<allocator_type>::size_type size_type; 55020b57cec5SDimitry Andric typedef typename iterator_traits<_BidirectionalIterator>::value_type char_type; 55030b57cec5SDimitry Andric typedef basic_string<char_type> string_type; 55040b57cec5SDimitry Andric 55050b57cec5SDimitry Andric // construct/copy/destroy: 5506e8d8bef9SDimitry Andric#ifndef _LIBCPP_CXX03_LANG 5507e8d8bef9SDimitry Andric match_results() : match_results(allocator_type()) {} 5508e8d8bef9SDimitry Andric explicit match_results(const allocator_type& __a); 5509e8d8bef9SDimitry Andric#else 55100b57cec5SDimitry Andric explicit match_results(const allocator_type& __a = allocator_type()); 5511e8d8bef9SDimitry Andric#endif 5512e8d8bef9SDimitry Andric 55130b57cec5SDimitry Andric// match_results(const match_results&) = default; 55140b57cec5SDimitry Andric// match_results& operator=(const match_results&) = default; 55150b57cec5SDimitry Andric// match_results(match_results&& __m) = default; 55160b57cec5SDimitry Andric// match_results& operator=(match_results&& __m) = default; 55170b57cec5SDimitry Andric// ~match_results() = default; 55180b57cec5SDimitry Andric 5519*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 55200b57cec5SDimitry Andric bool ready() const {return __ready_;} 55210b57cec5SDimitry Andric 55220b57cec5SDimitry Andric // size: 5523*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 55240b57cec5SDimitry Andric size_type size() const _NOEXCEPT {return __matches_.size();} 5525*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 55260b57cec5SDimitry Andric size_type max_size() const _NOEXCEPT {return __matches_.max_size();} 5527*5f757f3fSDimitry Andric _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI 55280b57cec5SDimitry Andric bool empty() const _NOEXCEPT {return size() == 0;} 55290b57cec5SDimitry Andric 55300b57cec5SDimitry Andric // element access: 5531*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 55320b57cec5SDimitry Andric difference_type length(size_type __sub = 0) const 55330b57cec5SDimitry Andric { 553406c3fb27SDimitry Andric _LIBCPP_ASSERT_UNCATEGORIZED(ready(), "match_results::length() called when not ready"); 55350b57cec5SDimitry Andric return (*this)[__sub].length(); 55360b57cec5SDimitry Andric } 5537*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 55380b57cec5SDimitry Andric difference_type position(size_type __sub = 0) const 55390b57cec5SDimitry Andric { 554006c3fb27SDimitry Andric _LIBCPP_ASSERT_UNCATEGORIZED(ready(), "match_results::position() called when not ready"); 5541*5f757f3fSDimitry Andric return std::distance(__position_start_, (*this)[__sub].first); 55420b57cec5SDimitry Andric } 5543*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 55440b57cec5SDimitry Andric string_type str(size_type __sub = 0) const 55450b57cec5SDimitry Andric { 554606c3fb27SDimitry Andric _LIBCPP_ASSERT_UNCATEGORIZED(ready(), "match_results::str() called when not ready"); 55470b57cec5SDimitry Andric return (*this)[__sub].str(); 55480b57cec5SDimitry Andric } 5549*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 55500b57cec5SDimitry Andric const_reference operator[](size_type __n) const 55510b57cec5SDimitry Andric { 555206c3fb27SDimitry Andric _LIBCPP_ASSERT_UNCATEGORIZED(ready(), "match_results::operator[]() called when not ready"); 55530b57cec5SDimitry Andric return __n < __matches_.size() ? __matches_[__n] : __unmatched_; 55540b57cec5SDimitry Andric } 55550b57cec5SDimitry Andric 5556*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 55570b57cec5SDimitry Andric const_reference prefix() const 55580b57cec5SDimitry Andric { 555906c3fb27SDimitry Andric _LIBCPP_ASSERT_UNCATEGORIZED(ready(), "match_results::prefix() called when not ready"); 55600b57cec5SDimitry Andric return __prefix_; 55610b57cec5SDimitry Andric } 5562*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 55630b57cec5SDimitry Andric const_reference suffix() const 55640b57cec5SDimitry Andric { 556506c3fb27SDimitry Andric _LIBCPP_ASSERT_UNCATEGORIZED(ready(), "match_results::suffix() called when not ready"); 55660b57cec5SDimitry Andric return __suffix_; 55670b57cec5SDimitry Andric } 55680b57cec5SDimitry Andric 5569*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 55700b57cec5SDimitry Andric const_iterator begin() const {return empty() ? __matches_.end() : __matches_.begin();} 5571*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 55720b57cec5SDimitry Andric const_iterator end() const {return __matches_.end();} 5573*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 55740b57cec5SDimitry Andric const_iterator cbegin() const {return empty() ? __matches_.end() : __matches_.begin();} 5575*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 55760b57cec5SDimitry Andric const_iterator cend() const {return __matches_.end();} 55770b57cec5SDimitry Andric 55780b57cec5SDimitry Andric // format: 55790b57cec5SDimitry Andric template <class _OutputIter> 55800b57cec5SDimitry Andric _OutputIter 55810b57cec5SDimitry Andric format(_OutputIter __output_iter, const char_type* __fmt_first, 55820b57cec5SDimitry Andric const char_type* __fmt_last, 55830b57cec5SDimitry Andric regex_constants::match_flag_type __flags = regex_constants::format_default) const; 55840b57cec5SDimitry Andric template <class _OutputIter, class _ST, class _SA> 5585*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 55860b57cec5SDimitry Andric _OutputIter 55870b57cec5SDimitry Andric format(_OutputIter __output_iter, const basic_string<char_type, _ST, _SA>& __fmt, 55880b57cec5SDimitry Andric regex_constants::match_flag_type __flags = regex_constants::format_default) const 55890b57cec5SDimitry Andric {return format(__output_iter, __fmt.data(), __fmt.data() + __fmt.size(), __flags);} 55900b57cec5SDimitry Andric template <class _ST, class _SA> 5591*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 55920b57cec5SDimitry Andric basic_string<char_type, _ST, _SA> 55930b57cec5SDimitry Andric format(const basic_string<char_type, _ST, _SA>& __fmt, 55940b57cec5SDimitry Andric regex_constants::match_flag_type __flags = regex_constants::format_default) const 55950b57cec5SDimitry Andric { 55960b57cec5SDimitry Andric basic_string<char_type, _ST, _SA> __r; 5597bdd1243dSDimitry Andric format(std::back_inserter(__r), __fmt.data(), __fmt.data() + __fmt.size(), 55980b57cec5SDimitry Andric __flags); 55990b57cec5SDimitry Andric return __r; 56000b57cec5SDimitry Andric } 5601*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 56020b57cec5SDimitry Andric string_type 56030b57cec5SDimitry Andric format(const char_type* __fmt, 56040b57cec5SDimitry Andric regex_constants::match_flag_type __flags = regex_constants::format_default) const 56050b57cec5SDimitry Andric { 56060b57cec5SDimitry Andric string_type __r; 5607bdd1243dSDimitry Andric format(std::back_inserter(__r), __fmt, 56080b57cec5SDimitry Andric __fmt + char_traits<char_type>::length(__fmt), __flags); 56090b57cec5SDimitry Andric return __r; 56100b57cec5SDimitry Andric } 56110b57cec5SDimitry Andric 56120b57cec5SDimitry Andric // allocator: 5613*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 56140b57cec5SDimitry Andric allocator_type get_allocator() const {return __matches_.get_allocator();} 56150b57cec5SDimitry Andric 56160b57cec5SDimitry Andric // swap: 56170b57cec5SDimitry Andric void swap(match_results& __m); 56180b57cec5SDimitry Andric 56190b57cec5SDimitry Andric template <class _Bp, class _Ap> 5620*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 56210b57cec5SDimitry Andric void __assign(_BidirectionalIterator __f, _BidirectionalIterator __l, 56220b57cec5SDimitry Andric const match_results<_Bp, _Ap>& __m, bool __no_update_pos) 56230b57cec5SDimitry Andric { 56240b57cec5SDimitry Andric _Bp __mf = __m.prefix().first; 56250b57cec5SDimitry Andric __matches_.resize(__m.size()); 56260b57cec5SDimitry Andric for (size_type __i = 0; __i < __matches_.size(); ++__i) 56270b57cec5SDimitry Andric { 5628*5f757f3fSDimitry Andric __matches_[__i].first = std::next(__f, std::distance(__mf, __m[__i].first)); 5629*5f757f3fSDimitry Andric __matches_[__i].second = std::next(__f, std::distance(__mf, __m[__i].second)); 56300b57cec5SDimitry Andric __matches_[__i].matched = __m[__i].matched; 56310b57cec5SDimitry Andric } 56320b57cec5SDimitry Andric __unmatched_.first = __l; 56330b57cec5SDimitry Andric __unmatched_.second = __l; 56340b57cec5SDimitry Andric __unmatched_.matched = false; 5635*5f757f3fSDimitry Andric __prefix_.first = std::next(__f, std::distance(__mf, __m.prefix().first)); 5636*5f757f3fSDimitry Andric __prefix_.second = std::next(__f, std::distance(__mf, __m.prefix().second)); 56370b57cec5SDimitry Andric __prefix_.matched = __m.prefix().matched; 5638*5f757f3fSDimitry Andric __suffix_.first = std::next(__f, std::distance(__mf, __m.suffix().first)); 5639*5f757f3fSDimitry Andric __suffix_.second = std::next(__f, std::distance(__mf, __m.suffix().second)); 56400b57cec5SDimitry Andric __suffix_.matched = __m.suffix().matched; 56410b57cec5SDimitry Andric if (!__no_update_pos) 56420b57cec5SDimitry Andric __position_start_ = __prefix_.first; 56430b57cec5SDimitry Andric __ready_ = __m.ready(); 56440b57cec5SDimitry Andric } 56450b57cec5SDimitry Andric 56460b57cec5SDimitry Andricprivate: 56470b57cec5SDimitry Andric void __init(unsigned __s, 56480b57cec5SDimitry Andric _BidirectionalIterator __f, _BidirectionalIterator __l, 56490b57cec5SDimitry Andric bool __no_update_pos = false); 56500b57cec5SDimitry Andric 56510b57cec5SDimitry Andric template <class, class> friend class basic_regex; 56520b57cec5SDimitry Andric 56530b57cec5SDimitry Andric template <class _Bp, class _Ap, class _Cp, class _Tp> 56540b57cec5SDimitry Andric friend 56550b57cec5SDimitry Andric bool 56560b57cec5SDimitry Andric regex_match(_Bp, _Bp, match_results<_Bp, _Ap>&, const basic_regex<_Cp, _Tp>&, 56570b57cec5SDimitry Andric regex_constants::match_flag_type); 56580b57cec5SDimitry Andric 56590b57cec5SDimitry Andric template <class _Bp, class _Ap> 56600b57cec5SDimitry Andric friend 56610b57cec5SDimitry Andric bool 56620b57cec5SDimitry Andric operator==(const match_results<_Bp, _Ap>&, const match_results<_Bp, _Ap>&); 56630b57cec5SDimitry Andric 56640b57cec5SDimitry Andric template <class, class> friend class __lookahead; 56650b57cec5SDimitry Andric}; 56660b57cec5SDimitry Andric 56670b57cec5SDimitry Andrictemplate <class _BidirectionalIterator, class _Allocator> 56680b57cec5SDimitry Andricmatch_results<_BidirectionalIterator, _Allocator>::match_results( 56690b57cec5SDimitry Andric const allocator_type& __a) 56700b57cec5SDimitry Andric : __matches_(__a), 56710b57cec5SDimitry Andric __unmatched_(), 56720b57cec5SDimitry Andric __prefix_(), 56730b57cec5SDimitry Andric __suffix_(), 56740b57cec5SDimitry Andric __ready_(false), 56750b57cec5SDimitry Andric __position_start_() 56760b57cec5SDimitry Andric{ 56770b57cec5SDimitry Andric} 56780b57cec5SDimitry Andric 56790b57cec5SDimitry Andrictemplate <class _BidirectionalIterator, class _Allocator> 56800b57cec5SDimitry Andricvoid 56810b57cec5SDimitry Andricmatch_results<_BidirectionalIterator, _Allocator>::__init(unsigned __s, 56820b57cec5SDimitry Andric _BidirectionalIterator __f, _BidirectionalIterator __l, 56830b57cec5SDimitry Andric bool __no_update_pos) 56840b57cec5SDimitry Andric{ 56850b57cec5SDimitry Andric __unmatched_.first = __l; 56860b57cec5SDimitry Andric __unmatched_.second = __l; 56870b57cec5SDimitry Andric __unmatched_.matched = false; 56880b57cec5SDimitry Andric __matches_.assign(__s, __unmatched_); 56890b57cec5SDimitry Andric __prefix_.first = __f; 56900b57cec5SDimitry Andric __prefix_.second = __f; 56910b57cec5SDimitry Andric __prefix_.matched = false; 56920b57cec5SDimitry Andric __suffix_ = __unmatched_; 56930b57cec5SDimitry Andric if (!__no_update_pos) 56940b57cec5SDimitry Andric __position_start_ = __prefix_.first; 56950b57cec5SDimitry Andric __ready_ = true; 56960b57cec5SDimitry Andric} 56970b57cec5SDimitry Andric 56980b57cec5SDimitry Andrictemplate <class _BidirectionalIterator, class _Allocator> 56990b57cec5SDimitry Andrictemplate <class _OutputIter> 57000b57cec5SDimitry Andric_OutputIter 57010b57cec5SDimitry Andricmatch_results<_BidirectionalIterator, _Allocator>::format(_OutputIter __output_iter, 57020b57cec5SDimitry Andric const char_type* __fmt_first, const char_type* __fmt_last, 57030b57cec5SDimitry Andric regex_constants::match_flag_type __flags) const 57040b57cec5SDimitry Andric{ 570506c3fb27SDimitry Andric _LIBCPP_ASSERT_UNCATEGORIZED(ready(), "match_results::format() called when not ready"); 57060b57cec5SDimitry Andric if (__flags & regex_constants::format_sed) 57070b57cec5SDimitry Andric { 57080b57cec5SDimitry Andric for (; __fmt_first != __fmt_last; ++__fmt_first) 57090b57cec5SDimitry Andric { 57100b57cec5SDimitry Andric if (*__fmt_first == '&') 5711*5f757f3fSDimitry Andric __output_iter = std::copy(__matches_[0].first, __matches_[0].second, 57120b57cec5SDimitry Andric __output_iter); 57130b57cec5SDimitry Andric else if (*__fmt_first == '\\' && __fmt_first + 1 != __fmt_last) 57140b57cec5SDimitry Andric { 57150b57cec5SDimitry Andric ++__fmt_first; 57160b57cec5SDimitry Andric if ('0' <= *__fmt_first && *__fmt_first <= '9') 57170b57cec5SDimitry Andric { 57180b57cec5SDimitry Andric size_t __i = *__fmt_first - '0'; 5719*5f757f3fSDimitry Andric __output_iter = std::copy((*this)[__i].first, 57200b57cec5SDimitry Andric (*this)[__i].second, __output_iter); 57210b57cec5SDimitry Andric } 57220b57cec5SDimitry Andric else 57230b57cec5SDimitry Andric { 57240b57cec5SDimitry Andric *__output_iter = *__fmt_first; 57250b57cec5SDimitry Andric ++__output_iter; 57260b57cec5SDimitry Andric } 57270b57cec5SDimitry Andric } 57280b57cec5SDimitry Andric else 57290b57cec5SDimitry Andric { 57300b57cec5SDimitry Andric *__output_iter = *__fmt_first; 57310b57cec5SDimitry Andric ++__output_iter; 57320b57cec5SDimitry Andric } 57330b57cec5SDimitry Andric } 57340b57cec5SDimitry Andric } 57350b57cec5SDimitry Andric else 57360b57cec5SDimitry Andric { 57370b57cec5SDimitry Andric for (; __fmt_first != __fmt_last; ++__fmt_first) 57380b57cec5SDimitry Andric { 57390b57cec5SDimitry Andric if (*__fmt_first == '$' && __fmt_first + 1 != __fmt_last) 57400b57cec5SDimitry Andric { 57410b57cec5SDimitry Andric switch (__fmt_first[1]) 57420b57cec5SDimitry Andric { 57430b57cec5SDimitry Andric case '$': 57440b57cec5SDimitry Andric *__output_iter = *++__fmt_first; 57450b57cec5SDimitry Andric ++__output_iter; 57460b57cec5SDimitry Andric break; 57470b57cec5SDimitry Andric case '&': 57480b57cec5SDimitry Andric ++__fmt_first; 5749*5f757f3fSDimitry Andric __output_iter = std::copy(__matches_[0].first, __matches_[0].second, 57500b57cec5SDimitry Andric __output_iter); 57510b57cec5SDimitry Andric break; 57520b57cec5SDimitry Andric case '`': 57530b57cec5SDimitry Andric ++__fmt_first; 5754*5f757f3fSDimitry Andric __output_iter = std::copy(__prefix_.first, __prefix_.second, __output_iter); 57550b57cec5SDimitry Andric break; 57560b57cec5SDimitry Andric case '\'': 57570b57cec5SDimitry Andric ++__fmt_first; 5758*5f757f3fSDimitry Andric __output_iter = std::copy(__suffix_.first, __suffix_.second, __output_iter); 57590b57cec5SDimitry Andric break; 57600b57cec5SDimitry Andric default: 57610b57cec5SDimitry Andric if ('0' <= __fmt_first[1] && __fmt_first[1] <= '9') 57620b57cec5SDimitry Andric { 57630b57cec5SDimitry Andric ++__fmt_first; 57640b57cec5SDimitry Andric size_t __idx = *__fmt_first - '0'; 57650b57cec5SDimitry Andric if (__fmt_first + 1 != __fmt_last && 57660b57cec5SDimitry Andric '0' <= __fmt_first[1] && __fmt_first[1] <= '9') 57670b57cec5SDimitry Andric { 57680b57cec5SDimitry Andric ++__fmt_first; 5769e8d8bef9SDimitry Andric if (__idx >= numeric_limits<size_t>::max() / 10) 57700b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_escape>(); 57710b57cec5SDimitry Andric __idx = 10 * __idx + *__fmt_first - '0'; 57720b57cec5SDimitry Andric } 5773*5f757f3fSDimitry Andric __output_iter = std::copy((*this)[__idx].first, 57740b57cec5SDimitry Andric (*this)[__idx].second, __output_iter); 57750b57cec5SDimitry Andric } 57760b57cec5SDimitry Andric else 57770b57cec5SDimitry Andric { 57780b57cec5SDimitry Andric *__output_iter = *__fmt_first; 57790b57cec5SDimitry Andric ++__output_iter; 57800b57cec5SDimitry Andric } 57810b57cec5SDimitry Andric break; 57820b57cec5SDimitry Andric } 57830b57cec5SDimitry Andric } 57840b57cec5SDimitry Andric else 57850b57cec5SDimitry Andric { 57860b57cec5SDimitry Andric *__output_iter = *__fmt_first; 57870b57cec5SDimitry Andric ++__output_iter; 57880b57cec5SDimitry Andric } 57890b57cec5SDimitry Andric } 57900b57cec5SDimitry Andric } 57910b57cec5SDimitry Andric return __output_iter; 57920b57cec5SDimitry Andric} 57930b57cec5SDimitry Andric 57940b57cec5SDimitry Andrictemplate <class _BidirectionalIterator, class _Allocator> 57950b57cec5SDimitry Andricvoid 57960b57cec5SDimitry Andricmatch_results<_BidirectionalIterator, _Allocator>::swap(match_results& __m) 57970b57cec5SDimitry Andric{ 5798*5f757f3fSDimitry Andric using std::swap; 57990b57cec5SDimitry Andric swap(__matches_, __m.__matches_); 58000b57cec5SDimitry Andric swap(__unmatched_, __m.__unmatched_); 58010b57cec5SDimitry Andric swap(__prefix_, __m.__prefix_); 58020b57cec5SDimitry Andric swap(__suffix_, __m.__suffix_); 58030b57cec5SDimitry Andric swap(__position_start_, __m.__position_start_); 58040b57cec5SDimitry Andric swap(__ready_, __m.__ready_); 58050b57cec5SDimitry Andric} 58060b57cec5SDimitry Andric 58070b57cec5SDimitry Andrictemplate <class _BidirectionalIterator, class _Allocator> 5808bdd1243dSDimitry Andric_LIBCPP_HIDE_FROM_ABI bool 58090b57cec5SDimitry Andricoperator==(const match_results<_BidirectionalIterator, _Allocator>& __x, 58100b57cec5SDimitry Andric const match_results<_BidirectionalIterator, _Allocator>& __y) 58110b57cec5SDimitry Andric{ 58120b57cec5SDimitry Andric if (__x.__ready_ != __y.__ready_) 58130b57cec5SDimitry Andric return false; 58140b57cec5SDimitry Andric if (!__x.__ready_) 58150b57cec5SDimitry Andric return true; 58160b57cec5SDimitry Andric return __x.__matches_ == __y.__matches_ && 58170b57cec5SDimitry Andric __x.__prefix_ == __y.__prefix_ && 58180b57cec5SDimitry Andric __x.__suffix_ == __y.__suffix_; 58190b57cec5SDimitry Andric} 58200b57cec5SDimitry Andric 582106c3fb27SDimitry Andric#if _LIBCPP_STD_VER < 20 58220b57cec5SDimitry Andrictemplate <class _BidirectionalIterator, class _Allocator> 5823*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 58240b57cec5SDimitry Andricbool 58250b57cec5SDimitry Andricoperator!=(const match_results<_BidirectionalIterator, _Allocator>& __x, 58260b57cec5SDimitry Andric const match_results<_BidirectionalIterator, _Allocator>& __y) 58270b57cec5SDimitry Andric{ 58280b57cec5SDimitry Andric return !(__x == __y); 58290b57cec5SDimitry Andric} 583006c3fb27SDimitry Andric#endif 58310b57cec5SDimitry Andric 58320b57cec5SDimitry Andrictemplate <class _BidirectionalIterator, class _Allocator> 5833*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 58340b57cec5SDimitry Andricvoid 58350b57cec5SDimitry Andricswap(match_results<_BidirectionalIterator, _Allocator>& __x, 58360b57cec5SDimitry Andric match_results<_BidirectionalIterator, _Allocator>& __y) 58370b57cec5SDimitry Andric{ 58380b57cec5SDimitry Andric __x.swap(__y); 58390b57cec5SDimitry Andric} 58400b57cec5SDimitry Andric 58410b57cec5SDimitry Andric// regex_search 58420b57cec5SDimitry Andric 58430b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 58440b57cec5SDimitry Andrictemplate <class _Allocator> 58450b57cec5SDimitry Andricbool 58460b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__match_at_start_ecma( 58470b57cec5SDimitry Andric const _CharT* __first, const _CharT* __last, 58480b57cec5SDimitry Andric match_results<const _CharT*, _Allocator>& __m, 58490b57cec5SDimitry Andric regex_constants::match_flag_type __flags, bool __at_first) const 58500b57cec5SDimitry Andric{ 58510b57cec5SDimitry Andric vector<__state> __states; 58520b57cec5SDimitry Andric __node* __st = __start_.get(); 58530b57cec5SDimitry Andric if (__st) 58540b57cec5SDimitry Andric { 58550b57cec5SDimitry Andric sub_match<const _CharT*> __unmatched; 58560b57cec5SDimitry Andric __unmatched.first = __last; 58570b57cec5SDimitry Andric __unmatched.second = __last; 58580b57cec5SDimitry Andric __unmatched.matched = false; 58590b57cec5SDimitry Andric 58600b57cec5SDimitry Andric __states.push_back(__state()); 58610b57cec5SDimitry Andric __states.back().__do_ = 0; 58620b57cec5SDimitry Andric __states.back().__first_ = __first; 58630b57cec5SDimitry Andric __states.back().__current_ = __first; 58640b57cec5SDimitry Andric __states.back().__last_ = __last; 58650b57cec5SDimitry Andric __states.back().__sub_matches_.resize(mark_count(), __unmatched); 58660b57cec5SDimitry Andric __states.back().__loop_data_.resize(__loop_count()); 58670b57cec5SDimitry Andric __states.back().__node_ = __st; 58680b57cec5SDimitry Andric __states.back().__flags_ = __flags; 58690b57cec5SDimitry Andric __states.back().__at_first_ = __at_first; 58700b57cec5SDimitry Andric int __counter = 0; 58710b57cec5SDimitry Andric int __length = __last - __first; 58720b57cec5SDimitry Andric do 58730b57cec5SDimitry Andric { 58740b57cec5SDimitry Andric ++__counter; 58750b57cec5SDimitry Andric if (__counter % _LIBCPP_REGEX_COMPLEXITY_FACTOR == 0 && 58760b57cec5SDimitry Andric __counter / _LIBCPP_REGEX_COMPLEXITY_FACTOR >= __length) 58770b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_complexity>(); 58780b57cec5SDimitry Andric __state& __s = __states.back(); 58790b57cec5SDimitry Andric if (__s.__node_) 58800b57cec5SDimitry Andric __s.__node_->__exec(__s); 58810b57cec5SDimitry Andric switch (__s.__do_) 58820b57cec5SDimitry Andric { 58830b57cec5SDimitry Andric case __state::__end_state: 58840b57cec5SDimitry Andric if ((__flags & regex_constants::match_not_null) && 58850b57cec5SDimitry Andric __s.__current_ == __first) 58860b57cec5SDimitry Andric { 58870b57cec5SDimitry Andric __states.pop_back(); 58880b57cec5SDimitry Andric break; 58890b57cec5SDimitry Andric } 58900b57cec5SDimitry Andric if ((__flags & regex_constants::__full_match) && 58910b57cec5SDimitry Andric __s.__current_ != __last) 58920b57cec5SDimitry Andric { 58930b57cec5SDimitry Andric __states.pop_back(); 58940b57cec5SDimitry Andric break; 58950b57cec5SDimitry Andric } 58960b57cec5SDimitry Andric __m.__matches_[0].first = __first; 5897*5f757f3fSDimitry Andric __m.__matches_[0].second = std::next(__first, __s.__current_ - __first); 58980b57cec5SDimitry Andric __m.__matches_[0].matched = true; 58990b57cec5SDimitry Andric for (unsigned __i = 0; __i < __s.__sub_matches_.size(); ++__i) 59000b57cec5SDimitry Andric __m.__matches_[__i+1] = __s.__sub_matches_[__i]; 59010b57cec5SDimitry Andric return true; 59020b57cec5SDimitry Andric case __state::__accept_and_consume: 59030b57cec5SDimitry Andric case __state::__repeat: 59040b57cec5SDimitry Andric case __state::__accept_but_not_consume: 59050b57cec5SDimitry Andric break; 59060b57cec5SDimitry Andric case __state::__split: 59070b57cec5SDimitry Andric { 59080b57cec5SDimitry Andric __state __snext = __s; 59090b57cec5SDimitry Andric __s.__node_->__exec_split(true, __s); 59100b57cec5SDimitry Andric __snext.__node_->__exec_split(false, __snext); 5911*5f757f3fSDimitry Andric __states.push_back(std::move(__snext)); 59120b57cec5SDimitry Andric } 59130b57cec5SDimitry Andric break; 59140b57cec5SDimitry Andric case __state::__reject: 59150b57cec5SDimitry Andric __states.pop_back(); 59160b57cec5SDimitry Andric break; 59170b57cec5SDimitry Andric default: 59180b57cec5SDimitry Andric __throw_regex_error<regex_constants::__re_err_unknown>(); 59190b57cec5SDimitry Andric break; 59200b57cec5SDimitry Andric 59210b57cec5SDimitry Andric } 59220b57cec5SDimitry Andric } while (!__states.empty()); 59230b57cec5SDimitry Andric } 59240b57cec5SDimitry Andric return false; 59250b57cec5SDimitry Andric} 59260b57cec5SDimitry Andric 59270b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 59280b57cec5SDimitry Andrictemplate <class _Allocator> 59290b57cec5SDimitry Andricbool 59300b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__match_at_start_posix_nosubs( 59310b57cec5SDimitry Andric const _CharT* __first, const _CharT* __last, 59320b57cec5SDimitry Andric match_results<const _CharT*, _Allocator>& __m, 59330b57cec5SDimitry Andric regex_constants::match_flag_type __flags, bool __at_first) const 59340b57cec5SDimitry Andric{ 59350b57cec5SDimitry Andric deque<__state> __states; 59360b57cec5SDimitry Andric ptrdiff_t __highest_j = 0; 5937*5f757f3fSDimitry Andric ptrdiff_t __np = std::distance(__first, __last); 59380b57cec5SDimitry Andric __node* __st = __start_.get(); 59390b57cec5SDimitry Andric if (__st) 59400b57cec5SDimitry Andric { 59410b57cec5SDimitry Andric __states.push_back(__state()); 59420b57cec5SDimitry Andric __states.back().__do_ = 0; 59430b57cec5SDimitry Andric __states.back().__first_ = __first; 59440b57cec5SDimitry Andric __states.back().__current_ = __first; 59450b57cec5SDimitry Andric __states.back().__last_ = __last; 59460b57cec5SDimitry Andric __states.back().__loop_data_.resize(__loop_count()); 59470b57cec5SDimitry Andric __states.back().__node_ = __st; 59480b57cec5SDimitry Andric __states.back().__flags_ = __flags; 59490b57cec5SDimitry Andric __states.back().__at_first_ = __at_first; 59500b57cec5SDimitry Andric bool __matched = false; 59510b57cec5SDimitry Andric int __counter = 0; 59520b57cec5SDimitry Andric int __length = __last - __first; 59530b57cec5SDimitry Andric do 59540b57cec5SDimitry Andric { 59550b57cec5SDimitry Andric ++__counter; 59560b57cec5SDimitry Andric if (__counter % _LIBCPP_REGEX_COMPLEXITY_FACTOR == 0 && 59570b57cec5SDimitry Andric __counter / _LIBCPP_REGEX_COMPLEXITY_FACTOR >= __length) 59580b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_complexity>(); 59590b57cec5SDimitry Andric __state& __s = __states.back(); 59600b57cec5SDimitry Andric if (__s.__node_) 59610b57cec5SDimitry Andric __s.__node_->__exec(__s); 59620b57cec5SDimitry Andric switch (__s.__do_) 59630b57cec5SDimitry Andric { 59640b57cec5SDimitry Andric case __state::__end_state: 59650b57cec5SDimitry Andric if ((__flags & regex_constants::match_not_null) && 59660b57cec5SDimitry Andric __s.__current_ == __first) 59670b57cec5SDimitry Andric { 59680b57cec5SDimitry Andric __states.pop_back(); 59690b57cec5SDimitry Andric break; 59700b57cec5SDimitry Andric } 59710b57cec5SDimitry Andric if ((__flags & regex_constants::__full_match) && 59720b57cec5SDimitry Andric __s.__current_ != __last) 59730b57cec5SDimitry Andric { 59740b57cec5SDimitry Andric __states.pop_back(); 59750b57cec5SDimitry Andric break; 59760b57cec5SDimitry Andric } 59770b57cec5SDimitry Andric if (!__matched || __highest_j < __s.__current_ - __s.__first_) 59780b57cec5SDimitry Andric __highest_j = __s.__current_ - __s.__first_; 59790b57cec5SDimitry Andric __matched = true; 598006c3fb27SDimitry Andric if (__highest_j == __np) 59810b57cec5SDimitry Andric __states.clear(); 59820b57cec5SDimitry Andric else 59830b57cec5SDimitry Andric __states.pop_back(); 59840b57cec5SDimitry Andric break; 59850b57cec5SDimitry Andric case __state::__consume_input: 59860b57cec5SDimitry Andric break; 59870b57cec5SDimitry Andric case __state::__accept_and_consume: 5988*5f757f3fSDimitry Andric __states.push_front(std::move(__s)); 59890b57cec5SDimitry Andric __states.pop_back(); 59900b57cec5SDimitry Andric break; 59910b57cec5SDimitry Andric case __state::__repeat: 59920b57cec5SDimitry Andric case __state::__accept_but_not_consume: 59930b57cec5SDimitry Andric break; 59940b57cec5SDimitry Andric case __state::__split: 59950b57cec5SDimitry Andric { 59960b57cec5SDimitry Andric __state __snext = __s; 59970b57cec5SDimitry Andric __s.__node_->__exec_split(true, __s); 59980b57cec5SDimitry Andric __snext.__node_->__exec_split(false, __snext); 5999*5f757f3fSDimitry Andric __states.push_back(std::move(__snext)); 60000b57cec5SDimitry Andric } 60010b57cec5SDimitry Andric break; 60020b57cec5SDimitry Andric case __state::__reject: 60030b57cec5SDimitry Andric __states.pop_back(); 60040b57cec5SDimitry Andric break; 60050b57cec5SDimitry Andric default: 60060b57cec5SDimitry Andric __throw_regex_error<regex_constants::__re_err_unknown>(); 60070b57cec5SDimitry Andric break; 60080b57cec5SDimitry Andric } 60090b57cec5SDimitry Andric } while (!__states.empty()); 60100b57cec5SDimitry Andric if (__matched) 60110b57cec5SDimitry Andric { 60120b57cec5SDimitry Andric __m.__matches_[0].first = __first; 6013*5f757f3fSDimitry Andric __m.__matches_[0].second = std::next(__first, __highest_j); 60140b57cec5SDimitry Andric __m.__matches_[0].matched = true; 60150b57cec5SDimitry Andric return true; 60160b57cec5SDimitry Andric } 60170b57cec5SDimitry Andric } 60180b57cec5SDimitry Andric return false; 60190b57cec5SDimitry Andric} 60200b57cec5SDimitry Andric 60210b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 60220b57cec5SDimitry Andrictemplate <class _Allocator> 60230b57cec5SDimitry Andricbool 60240b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__match_at_start_posix_subs( 60250b57cec5SDimitry Andric const _CharT* __first, const _CharT* __last, 60260b57cec5SDimitry Andric match_results<const _CharT*, _Allocator>& __m, 60270b57cec5SDimitry Andric regex_constants::match_flag_type __flags, bool __at_first) const 60280b57cec5SDimitry Andric{ 60290b57cec5SDimitry Andric vector<__state> __states; 60300b57cec5SDimitry Andric __state __best_state; 60310b57cec5SDimitry Andric ptrdiff_t __highest_j = 0; 6032*5f757f3fSDimitry Andric ptrdiff_t __np = std::distance(__first, __last); 60330b57cec5SDimitry Andric __node* __st = __start_.get(); 60340b57cec5SDimitry Andric if (__st) 60350b57cec5SDimitry Andric { 60360b57cec5SDimitry Andric sub_match<const _CharT*> __unmatched; 60370b57cec5SDimitry Andric __unmatched.first = __last; 60380b57cec5SDimitry Andric __unmatched.second = __last; 60390b57cec5SDimitry Andric __unmatched.matched = false; 60400b57cec5SDimitry Andric 60410b57cec5SDimitry Andric __states.push_back(__state()); 60420b57cec5SDimitry Andric __states.back().__do_ = 0; 60430b57cec5SDimitry Andric __states.back().__first_ = __first; 60440b57cec5SDimitry Andric __states.back().__current_ = __first; 60450b57cec5SDimitry Andric __states.back().__last_ = __last; 60460b57cec5SDimitry Andric __states.back().__sub_matches_.resize(mark_count(), __unmatched); 60470b57cec5SDimitry Andric __states.back().__loop_data_.resize(__loop_count()); 60480b57cec5SDimitry Andric __states.back().__node_ = __st; 60490b57cec5SDimitry Andric __states.back().__flags_ = __flags; 60500b57cec5SDimitry Andric __states.back().__at_first_ = __at_first; 60510b57cec5SDimitry Andric bool __matched = false; 60520b57cec5SDimitry Andric int __counter = 0; 60530b57cec5SDimitry Andric int __length = __last - __first; 60540b57cec5SDimitry Andric do 60550b57cec5SDimitry Andric { 60560b57cec5SDimitry Andric ++__counter; 60570b57cec5SDimitry Andric if (__counter % _LIBCPP_REGEX_COMPLEXITY_FACTOR == 0 && 60580b57cec5SDimitry Andric __counter / _LIBCPP_REGEX_COMPLEXITY_FACTOR >= __length) 60590b57cec5SDimitry Andric __throw_regex_error<regex_constants::error_complexity>(); 60600b57cec5SDimitry Andric __state& __s = __states.back(); 60610b57cec5SDimitry Andric if (__s.__node_) 60620b57cec5SDimitry Andric __s.__node_->__exec(__s); 60630b57cec5SDimitry Andric switch (__s.__do_) 60640b57cec5SDimitry Andric { 60650b57cec5SDimitry Andric case __state::__end_state: 60660b57cec5SDimitry Andric if ((__flags & regex_constants::match_not_null) && 60670b57cec5SDimitry Andric __s.__current_ == __first) 60680b57cec5SDimitry Andric { 60690b57cec5SDimitry Andric __states.pop_back(); 60700b57cec5SDimitry Andric break; 60710b57cec5SDimitry Andric } 60720b57cec5SDimitry Andric if ((__flags & regex_constants::__full_match) && 60730b57cec5SDimitry Andric __s.__current_ != __last) 60740b57cec5SDimitry Andric { 60750b57cec5SDimitry Andric __states.pop_back(); 60760b57cec5SDimitry Andric break; 60770b57cec5SDimitry Andric } 60780b57cec5SDimitry Andric if (!__matched || __highest_j < __s.__current_ - __s.__first_) 60790b57cec5SDimitry Andric { 60800b57cec5SDimitry Andric __highest_j = __s.__current_ - __s.__first_; 60810b57cec5SDimitry Andric __best_state = __s; 60820b57cec5SDimitry Andric } 60830b57cec5SDimitry Andric __matched = true; 608406c3fb27SDimitry Andric if (__highest_j == __np) 60850b57cec5SDimitry Andric __states.clear(); 60860b57cec5SDimitry Andric else 60870b57cec5SDimitry Andric __states.pop_back(); 60880b57cec5SDimitry Andric break; 60890b57cec5SDimitry Andric case __state::__accept_and_consume: 60900b57cec5SDimitry Andric case __state::__repeat: 60910b57cec5SDimitry Andric case __state::__accept_but_not_consume: 60920b57cec5SDimitry Andric break; 60930b57cec5SDimitry Andric case __state::__split: 60940b57cec5SDimitry Andric { 60950b57cec5SDimitry Andric __state __snext = __s; 60960b57cec5SDimitry Andric __s.__node_->__exec_split(true, __s); 60970b57cec5SDimitry Andric __snext.__node_->__exec_split(false, __snext); 6098*5f757f3fSDimitry Andric __states.push_back(std::move(__snext)); 60990b57cec5SDimitry Andric } 61000b57cec5SDimitry Andric break; 61010b57cec5SDimitry Andric case __state::__reject: 61020b57cec5SDimitry Andric __states.pop_back(); 61030b57cec5SDimitry Andric break; 61040b57cec5SDimitry Andric default: 61050b57cec5SDimitry Andric __throw_regex_error<regex_constants::__re_err_unknown>(); 61060b57cec5SDimitry Andric break; 61070b57cec5SDimitry Andric } 61080b57cec5SDimitry Andric } while (!__states.empty()); 61090b57cec5SDimitry Andric if (__matched) 61100b57cec5SDimitry Andric { 61110b57cec5SDimitry Andric __m.__matches_[0].first = __first; 6112*5f757f3fSDimitry Andric __m.__matches_[0].second = std::next(__first, __highest_j); 61130b57cec5SDimitry Andric __m.__matches_[0].matched = true; 61140b57cec5SDimitry Andric for (unsigned __i = 0; __i < __best_state.__sub_matches_.size(); ++__i) 61150b57cec5SDimitry Andric __m.__matches_[__i+1] = __best_state.__sub_matches_[__i]; 61160b57cec5SDimitry Andric return true; 61170b57cec5SDimitry Andric } 61180b57cec5SDimitry Andric } 61190b57cec5SDimitry Andric return false; 61200b57cec5SDimitry Andric} 61210b57cec5SDimitry Andric 61220b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 61230b57cec5SDimitry Andrictemplate <class _Allocator> 61240b57cec5SDimitry Andricbool 61250b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__match_at_start( 61260b57cec5SDimitry Andric const _CharT* __first, const _CharT* __last, 61270b57cec5SDimitry Andric match_results<const _CharT*, _Allocator>& __m, 61280b57cec5SDimitry Andric regex_constants::match_flag_type __flags, bool __at_first) const 61290b57cec5SDimitry Andric{ 61300b57cec5SDimitry Andric if (__get_grammar(__flags_) == ECMAScript) 61310b57cec5SDimitry Andric return __match_at_start_ecma(__first, __last, __m, __flags, __at_first); 61320b57cec5SDimitry Andric if (mark_count() == 0) 61330b57cec5SDimitry Andric return __match_at_start_posix_nosubs(__first, __last, __m, __flags, __at_first); 61340b57cec5SDimitry Andric return __match_at_start_posix_subs(__first, __last, __m, __flags, __at_first); 61350b57cec5SDimitry Andric} 61360b57cec5SDimitry Andric 61370b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 61380b57cec5SDimitry Andrictemplate <class _Allocator> 61390b57cec5SDimitry Andricbool 61400b57cec5SDimitry Andricbasic_regex<_CharT, _Traits>::__search( 61410b57cec5SDimitry Andric const _CharT* __first, const _CharT* __last, 61420b57cec5SDimitry Andric match_results<const _CharT*, _Allocator>& __m, 61430b57cec5SDimitry Andric regex_constants::match_flag_type __flags) const 61440b57cec5SDimitry Andric{ 61455ffd83dbSDimitry Andric if (__flags & regex_constants::match_prev_avail) 61465ffd83dbSDimitry Andric __flags &= ~(regex_constants::match_not_bol | regex_constants::match_not_bow); 61475ffd83dbSDimitry Andric 61480b57cec5SDimitry Andric __m.__init(1 + mark_count(), __first, __last, 61490b57cec5SDimitry Andric __flags & regex_constants::__no_update_pos); 61500b57cec5SDimitry Andric if (__match_at_start(__first, __last, __m, __flags, 61510b57cec5SDimitry Andric !(__flags & regex_constants::__no_update_pos))) 61520b57cec5SDimitry Andric { 61530b57cec5SDimitry Andric __m.__prefix_.second = __m[0].first; 61540b57cec5SDimitry Andric __m.__prefix_.matched = __m.__prefix_.first != __m.__prefix_.second; 61550b57cec5SDimitry Andric __m.__suffix_.first = __m[0].second; 61560b57cec5SDimitry Andric __m.__suffix_.matched = __m.__suffix_.first != __m.__suffix_.second; 61570b57cec5SDimitry Andric return true; 61580b57cec5SDimitry Andric } 61590b57cec5SDimitry Andric if (__first != __last && !(__flags & regex_constants::match_continuous)) 61600b57cec5SDimitry Andric { 61610b57cec5SDimitry Andric __flags |= regex_constants::match_prev_avail; 61620b57cec5SDimitry Andric for (++__first; __first != __last; ++__first) 61630b57cec5SDimitry Andric { 61640b57cec5SDimitry Andric __m.__matches_.assign(__m.size(), __m.__unmatched_); 61650b57cec5SDimitry Andric if (__match_at_start(__first, __last, __m, __flags, false)) 61660b57cec5SDimitry Andric { 61670b57cec5SDimitry Andric __m.__prefix_.second = __m[0].first; 61680b57cec5SDimitry Andric __m.__prefix_.matched = __m.__prefix_.first != __m.__prefix_.second; 61690b57cec5SDimitry Andric __m.__suffix_.first = __m[0].second; 61700b57cec5SDimitry Andric __m.__suffix_.matched = __m.__suffix_.first != __m.__suffix_.second; 61710b57cec5SDimitry Andric return true; 61720b57cec5SDimitry Andric } 61730b57cec5SDimitry Andric __m.__matches_.assign(__m.size(), __m.__unmatched_); 61740b57cec5SDimitry Andric } 61750b57cec5SDimitry Andric } 61760b57cec5SDimitry Andric __m.__matches_.clear(); 61770b57cec5SDimitry Andric return false; 61780b57cec5SDimitry Andric} 61790b57cec5SDimitry Andric 61800b57cec5SDimitry Andrictemplate <class _BidirectionalIterator, class _Allocator, class _CharT, class _Traits> 6181*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 61820b57cec5SDimitry Andricbool 61830b57cec5SDimitry Andricregex_search(_BidirectionalIterator __first, _BidirectionalIterator __last, 61840b57cec5SDimitry Andric match_results<_BidirectionalIterator, _Allocator>& __m, 61850b57cec5SDimitry Andric const basic_regex<_CharT, _Traits>& __e, 61860b57cec5SDimitry Andric regex_constants::match_flag_type __flags = regex_constants::match_default) 61870b57cec5SDimitry Andric{ 61880b57cec5SDimitry Andric int __offset = (__flags & regex_constants::match_prev_avail) ? 1 : 0; 6189*5f757f3fSDimitry Andric basic_string<_CharT> __s(std::prev(__first, __offset), __last); 61900b57cec5SDimitry Andric match_results<const _CharT*> __mc; 61910b57cec5SDimitry Andric bool __r = __e.__search(__s.data() + __offset, __s.data() + __s.size(), __mc, __flags); 61920b57cec5SDimitry Andric __m.__assign(__first, __last, __mc, __flags & regex_constants::__no_update_pos); 61930b57cec5SDimitry Andric return __r; 61940b57cec5SDimitry Andric} 61950b57cec5SDimitry Andric 61960b57cec5SDimitry Andrictemplate <class _Iter, class _Allocator, class _CharT, class _Traits> 6197*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 61980b57cec5SDimitry Andricbool 61990b57cec5SDimitry Andricregex_search(__wrap_iter<_Iter> __first, 62000b57cec5SDimitry Andric __wrap_iter<_Iter> __last, 62010b57cec5SDimitry Andric match_results<__wrap_iter<_Iter>, _Allocator>& __m, 62020b57cec5SDimitry Andric const basic_regex<_CharT, _Traits>& __e, 62030b57cec5SDimitry Andric regex_constants::match_flag_type __flags = regex_constants::match_default) 62040b57cec5SDimitry Andric{ 62050b57cec5SDimitry Andric match_results<const _CharT*> __mc; 62060b57cec5SDimitry Andric bool __r = __e.__search(__first.base(), __last.base(), __mc, __flags); 62070b57cec5SDimitry Andric __m.__assign(__first, __last, __mc, __flags & regex_constants::__no_update_pos); 62080b57cec5SDimitry Andric return __r; 62090b57cec5SDimitry Andric} 62100b57cec5SDimitry Andric 62110b57cec5SDimitry Andrictemplate <class _Allocator, class _CharT, class _Traits> 6212*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 62130b57cec5SDimitry Andricbool 62140b57cec5SDimitry Andricregex_search(const _CharT* __first, const _CharT* __last, 62150b57cec5SDimitry Andric match_results<const _CharT*, _Allocator>& __m, 62160b57cec5SDimitry Andric const basic_regex<_CharT, _Traits>& __e, 62170b57cec5SDimitry Andric regex_constants::match_flag_type __flags = regex_constants::match_default) 62180b57cec5SDimitry Andric{ 62190b57cec5SDimitry Andric return __e.__search(__first, __last, __m, __flags); 62200b57cec5SDimitry Andric} 62210b57cec5SDimitry Andric 62220b57cec5SDimitry Andrictemplate <class _BidirectionalIterator, class _CharT, class _Traits> 6223*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 62240b57cec5SDimitry Andricbool 62250b57cec5SDimitry Andricregex_search(_BidirectionalIterator __first, _BidirectionalIterator __last, 62260b57cec5SDimitry Andric const basic_regex<_CharT, _Traits>& __e, 62270b57cec5SDimitry Andric regex_constants::match_flag_type __flags = regex_constants::match_default) 62280b57cec5SDimitry Andric{ 62290b57cec5SDimitry Andric basic_string<_CharT> __s(__first, __last); 62300b57cec5SDimitry Andric match_results<const _CharT*> __mc; 62310b57cec5SDimitry Andric return __e.__search(__s.data(), __s.data() + __s.size(), __mc, __flags); 62320b57cec5SDimitry Andric} 62330b57cec5SDimitry Andric 62340b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 6235*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 62360b57cec5SDimitry Andricbool 62370b57cec5SDimitry Andricregex_search(const _CharT* __first, const _CharT* __last, 62380b57cec5SDimitry Andric const basic_regex<_CharT, _Traits>& __e, 62390b57cec5SDimitry Andric regex_constants::match_flag_type __flags = regex_constants::match_default) 62400b57cec5SDimitry Andric{ 62410b57cec5SDimitry Andric match_results<const _CharT*> __mc; 62420b57cec5SDimitry Andric return __e.__search(__first, __last, __mc, __flags); 62430b57cec5SDimitry Andric} 62440b57cec5SDimitry Andric 62450b57cec5SDimitry Andrictemplate <class _CharT, class _Allocator, class _Traits> 6246*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 62470b57cec5SDimitry Andricbool 62480b57cec5SDimitry Andricregex_search(const _CharT* __str, match_results<const _CharT*, _Allocator>& __m, 62490b57cec5SDimitry Andric const basic_regex<_CharT, _Traits>& __e, 62500b57cec5SDimitry Andric regex_constants::match_flag_type __flags = regex_constants::match_default) 62510b57cec5SDimitry Andric{ 62520b57cec5SDimitry Andric return __e.__search(__str, __str + _Traits::length(__str), __m, __flags); 62530b57cec5SDimitry Andric} 62540b57cec5SDimitry Andric 62550b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 6256*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 62570b57cec5SDimitry Andricbool 62580b57cec5SDimitry Andricregex_search(const _CharT* __str, const basic_regex<_CharT, _Traits>& __e, 62590b57cec5SDimitry Andric regex_constants::match_flag_type __flags = regex_constants::match_default) 62600b57cec5SDimitry Andric{ 62610b57cec5SDimitry Andric match_results<const _CharT*> __m; 6262*5f757f3fSDimitry Andric return std::regex_search(__str, __m, __e, __flags); 62630b57cec5SDimitry Andric} 62640b57cec5SDimitry Andric 62650b57cec5SDimitry Andrictemplate <class _ST, class _SA, class _CharT, class _Traits> 6266*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 62670b57cec5SDimitry Andricbool 62680b57cec5SDimitry Andricregex_search(const basic_string<_CharT, _ST, _SA>& __s, 62690b57cec5SDimitry Andric const basic_regex<_CharT, _Traits>& __e, 62700b57cec5SDimitry Andric regex_constants::match_flag_type __flags = regex_constants::match_default) 62710b57cec5SDimitry Andric{ 62720b57cec5SDimitry Andric match_results<const _CharT*> __mc; 62730b57cec5SDimitry Andric return __e.__search(__s.data(), __s.data() + __s.size(), __mc, __flags); 62740b57cec5SDimitry Andric} 62750b57cec5SDimitry Andric 62760b57cec5SDimitry Andrictemplate <class _ST, class _SA, class _Allocator, class _CharT, class _Traits> 6277*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 62780b57cec5SDimitry Andricbool 62790b57cec5SDimitry Andricregex_search(const basic_string<_CharT, _ST, _SA>& __s, 62800b57cec5SDimitry Andric match_results<typename basic_string<_CharT, _ST, _SA>::const_iterator, _Allocator>& __m, 62810b57cec5SDimitry Andric const basic_regex<_CharT, _Traits>& __e, 62820b57cec5SDimitry Andric regex_constants::match_flag_type __flags = regex_constants::match_default) 62830b57cec5SDimitry Andric{ 62840b57cec5SDimitry Andric match_results<const _CharT*> __mc; 62850b57cec5SDimitry Andric bool __r = __e.__search(__s.data(), __s.data() + __s.size(), __mc, __flags); 62860b57cec5SDimitry Andric __m.__assign(__s.begin(), __s.end(), __mc, __flags & regex_constants::__no_update_pos); 62870b57cec5SDimitry Andric return __r; 62880b57cec5SDimitry Andric} 62890b57cec5SDimitry Andric 629006c3fb27SDimitry Andric#if _LIBCPP_STD_VER >= 14 62910b57cec5SDimitry Andrictemplate <class _ST, class _SA, class _Ap, class _Cp, class _Tp> 62920b57cec5SDimitry Andricbool 62930b57cec5SDimitry Andricregex_search(const basic_string<_Cp, _ST, _SA>&& __s, 62940b57cec5SDimitry Andric match_results<typename basic_string<_Cp, _ST, _SA>::const_iterator, _Ap>&, 62950b57cec5SDimitry Andric const basic_regex<_Cp, _Tp>& __e, 62960b57cec5SDimitry Andric regex_constants::match_flag_type __flags = regex_constants::match_default) = delete; 62970b57cec5SDimitry Andric#endif 62980b57cec5SDimitry Andric 62990b57cec5SDimitry Andric// regex_match 63000b57cec5SDimitry Andric 63010b57cec5SDimitry Andrictemplate <class _BidirectionalIterator, class _Allocator, class _CharT, class _Traits> 6302bdd1243dSDimitry Andric_LIBCPP_HIDE_FROM_ABI bool 63030b57cec5SDimitry Andricregex_match(_BidirectionalIterator __first, _BidirectionalIterator __last, 63040b57cec5SDimitry Andric match_results<_BidirectionalIterator, _Allocator>& __m, 63050b57cec5SDimitry Andric const basic_regex<_CharT, _Traits>& __e, 63060b57cec5SDimitry Andric regex_constants::match_flag_type __flags = regex_constants::match_default) 63070b57cec5SDimitry Andric{ 6308*5f757f3fSDimitry Andric bool __r = std::regex_search( 63090b57cec5SDimitry Andric __first, __last, __m, __e, 63100b57cec5SDimitry Andric __flags | regex_constants::match_continuous | 63110b57cec5SDimitry Andric regex_constants::__full_match); 63120b57cec5SDimitry Andric if (__r) 63130b57cec5SDimitry Andric { 63140b57cec5SDimitry Andric __r = !__m.suffix().matched; 63150b57cec5SDimitry Andric if (!__r) 63160b57cec5SDimitry Andric __m.__matches_.clear(); 63170b57cec5SDimitry Andric } 63180b57cec5SDimitry Andric return __r; 63190b57cec5SDimitry Andric} 63200b57cec5SDimitry Andric 63210b57cec5SDimitry Andrictemplate <class _BidirectionalIterator, class _CharT, class _Traits> 6322*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 63230b57cec5SDimitry Andricbool 63240b57cec5SDimitry Andricregex_match(_BidirectionalIterator __first, _BidirectionalIterator __last, 63250b57cec5SDimitry Andric const basic_regex<_CharT, _Traits>& __e, 63260b57cec5SDimitry Andric regex_constants::match_flag_type __flags = regex_constants::match_default) 63270b57cec5SDimitry Andric{ 63280b57cec5SDimitry Andric match_results<_BidirectionalIterator> __m; 6329*5f757f3fSDimitry Andric return std::regex_match(__first, __last, __m, __e, __flags); 63300b57cec5SDimitry Andric} 63310b57cec5SDimitry Andric 63320b57cec5SDimitry Andrictemplate <class _CharT, class _Allocator, class _Traits> 6333*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 63340b57cec5SDimitry Andricbool 63350b57cec5SDimitry Andricregex_match(const _CharT* __str, match_results<const _CharT*, _Allocator>& __m, 63360b57cec5SDimitry Andric const basic_regex<_CharT, _Traits>& __e, 63370b57cec5SDimitry Andric regex_constants::match_flag_type __flags = regex_constants::match_default) 63380b57cec5SDimitry Andric{ 6339*5f757f3fSDimitry Andric return std::regex_match(__str, __str + _Traits::length(__str), __m, __e, __flags); 63400b57cec5SDimitry Andric} 63410b57cec5SDimitry Andric 63420b57cec5SDimitry Andrictemplate <class _ST, class _SA, class _Allocator, class _CharT, class _Traits> 6343*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 63440b57cec5SDimitry Andricbool 63450b57cec5SDimitry Andricregex_match(const basic_string<_CharT, _ST, _SA>& __s, 63460b57cec5SDimitry Andric match_results<typename basic_string<_CharT, _ST, _SA>::const_iterator, _Allocator>& __m, 63470b57cec5SDimitry Andric const basic_regex<_CharT, _Traits>& __e, 63480b57cec5SDimitry Andric regex_constants::match_flag_type __flags = regex_constants::match_default) 63490b57cec5SDimitry Andric{ 6350*5f757f3fSDimitry Andric return std::regex_match(__s.begin(), __s.end(), __m, __e, __flags); 63510b57cec5SDimitry Andric} 63520b57cec5SDimitry Andric 635306c3fb27SDimitry Andric#if _LIBCPP_STD_VER >= 14 63540b57cec5SDimitry Andrictemplate <class _ST, class _SA, class _Allocator, class _CharT, class _Traits> 6355*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 63560b57cec5SDimitry Andricbool 63570b57cec5SDimitry Andricregex_match(const basic_string<_CharT, _ST, _SA>&& __s, 63580b57cec5SDimitry Andric match_results<typename basic_string<_CharT, _ST, _SA>::const_iterator, _Allocator>& __m, 63590b57cec5SDimitry Andric const basic_regex<_CharT, _Traits>& __e, 63600b57cec5SDimitry Andric regex_constants::match_flag_type __flags = regex_constants::match_default) = delete; 63610b57cec5SDimitry Andric#endif 63620b57cec5SDimitry Andric 63630b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 6364*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 63650b57cec5SDimitry Andricbool 63660b57cec5SDimitry Andricregex_match(const _CharT* __str, const basic_regex<_CharT, _Traits>& __e, 63670b57cec5SDimitry Andric regex_constants::match_flag_type __flags = regex_constants::match_default) 63680b57cec5SDimitry Andric{ 6369*5f757f3fSDimitry Andric return std::regex_match(__str, __str + _Traits::length(__str), __e, __flags); 63700b57cec5SDimitry Andric} 63710b57cec5SDimitry Andric 63720b57cec5SDimitry Andrictemplate <class _ST, class _SA, class _CharT, class _Traits> 6373*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 63740b57cec5SDimitry Andricbool 63750b57cec5SDimitry Andricregex_match(const basic_string<_CharT, _ST, _SA>& __s, 63760b57cec5SDimitry Andric const basic_regex<_CharT, _Traits>& __e, 63770b57cec5SDimitry Andric regex_constants::match_flag_type __flags = regex_constants::match_default) 63780b57cec5SDimitry Andric{ 6379*5f757f3fSDimitry Andric return std::regex_match(__s.begin(), __s.end(), __e, __flags); 63800b57cec5SDimitry Andric} 63810b57cec5SDimitry Andric 63820b57cec5SDimitry Andric// regex_iterator 63830b57cec5SDimitry Andric 63840b57cec5SDimitry Andrictemplate <class _BidirectionalIterator, 63850b57cec5SDimitry Andric class _CharT = typename iterator_traits<_BidirectionalIterator>::value_type, 63860b57cec5SDimitry Andric class _Traits = regex_traits<_CharT> > 6387e8d8bef9SDimitry Andric class _LIBCPP_TEMPLATE_VIS regex_iterator; 6388e8d8bef9SDimitry Andric 6389e8d8bef9SDimitry Andrictypedef regex_iterator<const char*> cregex_iterator; 6390e8d8bef9SDimitry Andrictypedef regex_iterator<string::const_iterator> sregex_iterator; 6391349cc55cSDimitry Andric#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 6392349cc55cSDimitry Andrictypedef regex_iterator<const wchar_t*> wcregex_iterator; 6393e8d8bef9SDimitry Andrictypedef regex_iterator<wstring::const_iterator> wsregex_iterator; 6394349cc55cSDimitry Andric#endif 6395e8d8bef9SDimitry Andric 6396e8d8bef9SDimitry Andrictemplate <class _BidirectionalIterator, class _CharT, class _Traits> 6397e8d8bef9SDimitry Andricclass 6398e8d8bef9SDimitry Andric _LIBCPP_TEMPLATE_VIS 6399e8d8bef9SDimitry Andric _LIBCPP_PREFERRED_NAME(cregex_iterator) 6400349cc55cSDimitry Andric _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wcregex_iterator)) 6401e8d8bef9SDimitry Andric _LIBCPP_PREFERRED_NAME(sregex_iterator) 6402349cc55cSDimitry Andric _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wsregex_iterator)) 6403e8d8bef9SDimitry Andric regex_iterator 64040b57cec5SDimitry Andric{ 64050b57cec5SDimitry Andricpublic: 64060b57cec5SDimitry Andric typedef basic_regex<_CharT, _Traits> regex_type; 64070b57cec5SDimitry Andric typedef match_results<_BidirectionalIterator> value_type; 64080b57cec5SDimitry Andric typedef ptrdiff_t difference_type; 64090b57cec5SDimitry Andric typedef const value_type* pointer; 64100b57cec5SDimitry Andric typedef const value_type& reference; 64110b57cec5SDimitry Andric typedef forward_iterator_tag iterator_category; 6412*5f757f3fSDimitry Andric#if _LIBCPP_STD_VER >= 20 6413*5f757f3fSDimitry Andric typedef input_iterator_tag iterator_concept; 6414*5f757f3fSDimitry Andric#endif 64150b57cec5SDimitry Andric 64160b57cec5SDimitry Andricprivate: 64170b57cec5SDimitry Andric _BidirectionalIterator __begin_; 64180b57cec5SDimitry Andric _BidirectionalIterator __end_; 64190b57cec5SDimitry Andric const regex_type* __pregex_; 64200b57cec5SDimitry Andric regex_constants::match_flag_type __flags_; 64210b57cec5SDimitry Andric value_type __match_; 64220b57cec5SDimitry Andric 64230b57cec5SDimitry Andricpublic: 64240b57cec5SDimitry Andric regex_iterator(); 64250b57cec5SDimitry Andric regex_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b, 64260b57cec5SDimitry Andric const regex_type& __re, 64270b57cec5SDimitry Andric regex_constants::match_flag_type __m 64280b57cec5SDimitry Andric = regex_constants::match_default); 642906c3fb27SDimitry Andric#if _LIBCPP_STD_VER >= 14 64300b57cec5SDimitry Andric regex_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b, 64310b57cec5SDimitry Andric const regex_type&& __re, 64320b57cec5SDimitry Andric regex_constants::match_flag_type __m 64330b57cec5SDimitry Andric = regex_constants::match_default) = delete; 64340b57cec5SDimitry Andric#endif 64350b57cec5SDimitry Andric 643606c3fb27SDimitry Andric _LIBCPP_HIDE_FROM_ABI bool operator==(const regex_iterator& __x) const; 643706c3fb27SDimitry Andric#if _LIBCPP_STD_VER >= 20 643806c3fb27SDimitry Andric _LIBCPP_HIDE_FROM_ABI bool operator==(default_sentinel_t) const { return *this == regex_iterator(); } 643906c3fb27SDimitry Andric#endif 644006c3fb27SDimitry Andric#if _LIBCPP_STD_VER < 20 6441*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 64420b57cec5SDimitry Andric bool operator!=(const regex_iterator& __x) const {return !(*this == __x);} 644306c3fb27SDimitry Andric#endif 64440b57cec5SDimitry Andric 6445*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 64460b57cec5SDimitry Andric reference operator*() const {return __match_;} 6447*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 6448*5f757f3fSDimitry Andric pointer operator->() const {return std::addressof(__match_);} 64490b57cec5SDimitry Andric 64500b57cec5SDimitry Andric regex_iterator& operator++(); 6451*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 64520b57cec5SDimitry Andric regex_iterator operator++(int) 64530b57cec5SDimitry Andric { 64540b57cec5SDimitry Andric regex_iterator __t(*this); 64550b57cec5SDimitry Andric ++(*this); 64560b57cec5SDimitry Andric return __t; 64570b57cec5SDimitry Andric } 64580b57cec5SDimitry Andric}; 64590b57cec5SDimitry Andric 64600b57cec5SDimitry Andrictemplate <class _BidirectionalIterator, class _CharT, class _Traits> 64610b57cec5SDimitry Andricregex_iterator<_BidirectionalIterator, _CharT, _Traits>::regex_iterator() 64620b57cec5SDimitry Andric : __begin_(), __end_(), __pregex_(nullptr), __flags_(), __match_() 64630b57cec5SDimitry Andric{ 64640b57cec5SDimitry Andric} 64650b57cec5SDimitry Andric 64660b57cec5SDimitry Andrictemplate <class _BidirectionalIterator, class _CharT, class _Traits> 64670b57cec5SDimitry Andricregex_iterator<_BidirectionalIterator, _CharT, _Traits>:: 64680b57cec5SDimitry Andric regex_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b, 64690b57cec5SDimitry Andric const regex_type& __re, regex_constants::match_flag_type __m) 64700b57cec5SDimitry Andric : __begin_(__a), 64710b57cec5SDimitry Andric __end_(__b), 6472*5f757f3fSDimitry Andric __pregex_(std::addressof(__re)), 64730b57cec5SDimitry Andric __flags_(__m) 64740b57cec5SDimitry Andric{ 6475*5f757f3fSDimitry Andric std::regex_search(__begin_, __end_, __match_, *__pregex_, __flags_); 64760b57cec5SDimitry Andric} 64770b57cec5SDimitry Andric 64780b57cec5SDimitry Andrictemplate <class _BidirectionalIterator, class _CharT, class _Traits> 64790b57cec5SDimitry Andricbool 64800b57cec5SDimitry Andricregex_iterator<_BidirectionalIterator, _CharT, _Traits>:: 64810b57cec5SDimitry Andric operator==(const regex_iterator& __x) const 64820b57cec5SDimitry Andric{ 64830b57cec5SDimitry Andric if (__match_.empty() && __x.__match_.empty()) 64840b57cec5SDimitry Andric return true; 64850b57cec5SDimitry Andric if (__match_.empty() || __x.__match_.empty()) 64860b57cec5SDimitry Andric return false; 64870b57cec5SDimitry Andric return __begin_ == __x.__begin_ && 64880b57cec5SDimitry Andric __end_ == __x.__end_ && 64890b57cec5SDimitry Andric __pregex_ == __x.__pregex_ && 64900b57cec5SDimitry Andric __flags_ == __x.__flags_ && 64910b57cec5SDimitry Andric __match_[0] == __x.__match_[0]; 64920b57cec5SDimitry Andric} 64930b57cec5SDimitry Andric 64940b57cec5SDimitry Andrictemplate <class _BidirectionalIterator, class _CharT, class _Traits> 64950b57cec5SDimitry Andricregex_iterator<_BidirectionalIterator, _CharT, _Traits>& 64960b57cec5SDimitry Andricregex_iterator<_BidirectionalIterator, _CharT, _Traits>::operator++() 64970b57cec5SDimitry Andric{ 64980b57cec5SDimitry Andric __flags_ |= regex_constants::__no_update_pos; 64990b57cec5SDimitry Andric _BidirectionalIterator __start = __match_[0].second; 65000b57cec5SDimitry Andric if (__match_[0].first == __match_[0].second) 65010b57cec5SDimitry Andric { 65020b57cec5SDimitry Andric if (__start == __end_) 65030b57cec5SDimitry Andric { 65040b57cec5SDimitry Andric __match_ = value_type(); 65050b57cec5SDimitry Andric return *this; 65060b57cec5SDimitry Andric } 6507*5f757f3fSDimitry Andric else if (std::regex_search(__start, __end_, __match_, *__pregex_, 65080b57cec5SDimitry Andric __flags_ | regex_constants::match_not_null | 65090b57cec5SDimitry Andric regex_constants::match_continuous)) 65100b57cec5SDimitry Andric return *this; 65110b57cec5SDimitry Andric else 65120b57cec5SDimitry Andric ++__start; 65130b57cec5SDimitry Andric } 65140b57cec5SDimitry Andric __flags_ |= regex_constants::match_prev_avail; 6515*5f757f3fSDimitry Andric if (!std::regex_search(__start, __end_, __match_, *__pregex_, __flags_)) 65160b57cec5SDimitry Andric __match_ = value_type(); 65170b57cec5SDimitry Andric return *this; 65180b57cec5SDimitry Andric} 65190b57cec5SDimitry Andric 65200b57cec5SDimitry Andric// regex_token_iterator 65210b57cec5SDimitry Andric 65220b57cec5SDimitry Andrictemplate <class _BidirectionalIterator, 65230b57cec5SDimitry Andric class _CharT = typename iterator_traits<_BidirectionalIterator>::value_type, 65240b57cec5SDimitry Andric class _Traits = regex_traits<_CharT> > 6525e8d8bef9SDimitry Andric class _LIBCPP_TEMPLATE_VIS regex_token_iterator; 6526e8d8bef9SDimitry Andric 6527e8d8bef9SDimitry Andrictypedef regex_token_iterator<const char*> cregex_token_iterator; 6528e8d8bef9SDimitry Andrictypedef regex_token_iterator<string::const_iterator> sregex_token_iterator; 6529349cc55cSDimitry Andric#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 6530349cc55cSDimitry Andrictypedef regex_token_iterator<const wchar_t*> wcregex_token_iterator; 6531e8d8bef9SDimitry Andrictypedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator; 6532349cc55cSDimitry Andric#endif 6533e8d8bef9SDimitry Andric 6534e8d8bef9SDimitry Andrictemplate <class _BidirectionalIterator, class _CharT, class _Traits> 6535e8d8bef9SDimitry Andricclass 6536e8d8bef9SDimitry Andric _LIBCPP_TEMPLATE_VIS 6537e8d8bef9SDimitry Andric _LIBCPP_PREFERRED_NAME(cregex_token_iterator) 6538349cc55cSDimitry Andric _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wcregex_token_iterator)) 6539e8d8bef9SDimitry Andric _LIBCPP_PREFERRED_NAME(sregex_token_iterator) 6540349cc55cSDimitry Andric _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wsregex_token_iterator)) 6541e8d8bef9SDimitry Andric regex_token_iterator 65420b57cec5SDimitry Andric{ 65430b57cec5SDimitry Andricpublic: 65440b57cec5SDimitry Andric typedef basic_regex<_CharT, _Traits> regex_type; 65450b57cec5SDimitry Andric typedef sub_match<_BidirectionalIterator> value_type; 65460b57cec5SDimitry Andric typedef ptrdiff_t difference_type; 65470b57cec5SDimitry Andric typedef const value_type* pointer; 65480b57cec5SDimitry Andric typedef const value_type& reference; 65490b57cec5SDimitry Andric typedef forward_iterator_tag iterator_category; 6550*5f757f3fSDimitry Andric#if _LIBCPP_STD_VER >= 20 6551*5f757f3fSDimitry Andric typedef input_iterator_tag iterator_concept; 6552*5f757f3fSDimitry Andric#endif 65530b57cec5SDimitry Andric 65540b57cec5SDimitry Andricprivate: 65550b57cec5SDimitry Andric typedef regex_iterator<_BidirectionalIterator, _CharT, _Traits> _Position; 65560b57cec5SDimitry Andric 65570b57cec5SDimitry Andric _Position __position_; 65580b57cec5SDimitry Andric const value_type* __result_; 65590b57cec5SDimitry Andric value_type __suffix_; 65600b57cec5SDimitry Andric ptrdiff_t __n_; 65610b57cec5SDimitry Andric vector<int> __subs_; 65620b57cec5SDimitry Andric 65630b57cec5SDimitry Andricpublic: 65640b57cec5SDimitry Andric regex_token_iterator(); 65650b57cec5SDimitry Andric regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b, 65660b57cec5SDimitry Andric const regex_type& __re, int __submatch = 0, 65670b57cec5SDimitry Andric regex_constants::match_flag_type __m = 65680b57cec5SDimitry Andric regex_constants::match_default); 656906c3fb27SDimitry Andric#if _LIBCPP_STD_VER >= 14 65700b57cec5SDimitry Andric regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b, 65710b57cec5SDimitry Andric const regex_type&& __re, int __submatch = 0, 65720b57cec5SDimitry Andric regex_constants::match_flag_type __m = 65730b57cec5SDimitry Andric regex_constants::match_default) = delete; 65740b57cec5SDimitry Andric#endif 65750b57cec5SDimitry Andric 65760b57cec5SDimitry Andric regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b, 65770b57cec5SDimitry Andric const regex_type& __re, const vector<int>& __submatches, 65780b57cec5SDimitry Andric regex_constants::match_flag_type __m = 65790b57cec5SDimitry Andric regex_constants::match_default); 658006c3fb27SDimitry Andric#if _LIBCPP_STD_VER >= 14 65810b57cec5SDimitry Andric regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b, 65820b57cec5SDimitry Andric const regex_type&& __re, const vector<int>& __submatches, 65830b57cec5SDimitry Andric regex_constants::match_flag_type __m = 65840b57cec5SDimitry Andric regex_constants::match_default) = delete; 65850b57cec5SDimitry Andric#endif 65860b57cec5SDimitry Andric 65870b57cec5SDimitry Andric#ifndef _LIBCPP_CXX03_LANG 65880b57cec5SDimitry Andric regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b, 65890b57cec5SDimitry Andric const regex_type& __re, 65900b57cec5SDimitry Andric initializer_list<int> __submatches, 65910b57cec5SDimitry Andric regex_constants::match_flag_type __m = 65920b57cec5SDimitry Andric regex_constants::match_default); 65930b57cec5SDimitry Andric 659406c3fb27SDimitry Andric#if _LIBCPP_STD_VER >= 14 65950b57cec5SDimitry Andric regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b, 65960b57cec5SDimitry Andric const regex_type&& __re, 65970b57cec5SDimitry Andric initializer_list<int> __submatches, 65980b57cec5SDimitry Andric regex_constants::match_flag_type __m = 65990b57cec5SDimitry Andric regex_constants::match_default) = delete; 66000b57cec5SDimitry Andric#endif 66010b57cec5SDimitry Andric#endif // _LIBCPP_CXX03_LANG 66020b57cec5SDimitry Andric template <size_t _Np> 66030b57cec5SDimitry Andric regex_token_iterator(_BidirectionalIterator __a, 66040b57cec5SDimitry Andric _BidirectionalIterator __b, 66050b57cec5SDimitry Andric const regex_type& __re, 66060b57cec5SDimitry Andric const int (&__submatches)[_Np], 66070b57cec5SDimitry Andric regex_constants::match_flag_type __m = 66080b57cec5SDimitry Andric regex_constants::match_default); 660906c3fb27SDimitry Andric#if _LIBCPP_STD_VER >= 14 6610e8d8bef9SDimitry Andric template <size_t _Np> 66110b57cec5SDimitry Andric regex_token_iterator(_BidirectionalIterator __a, 66120b57cec5SDimitry Andric _BidirectionalIterator __b, 66130b57cec5SDimitry Andric const regex_type&& __re, 66140b57cec5SDimitry Andric const int (&__submatches)[_Np], 66150b57cec5SDimitry Andric regex_constants::match_flag_type __m = 66160b57cec5SDimitry Andric regex_constants::match_default) = delete; 66170b57cec5SDimitry Andric#endif 66180b57cec5SDimitry Andric 66190b57cec5SDimitry Andric regex_token_iterator(const regex_token_iterator&); 66200b57cec5SDimitry Andric regex_token_iterator& operator=(const regex_token_iterator&); 66210b57cec5SDimitry Andric 662206c3fb27SDimitry Andric _LIBCPP_HIDE_FROM_ABI bool operator==(const regex_token_iterator& __x) const; 662306c3fb27SDimitry Andric#if _LIBCPP_STD_VER >= 20 662406c3fb27SDimitry Andric _LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI bool operator==(default_sentinel_t) const { 662506c3fb27SDimitry Andric return *this == regex_token_iterator(); 662606c3fb27SDimitry Andric } 662706c3fb27SDimitry Andric#endif 662806c3fb27SDimitry Andric#if _LIBCPP_STD_VER < 20 6629*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 66300b57cec5SDimitry Andric bool operator!=(const regex_token_iterator& __x) const {return !(*this == __x);} 663106c3fb27SDimitry Andric#endif 66320b57cec5SDimitry Andric 6633*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 66340b57cec5SDimitry Andric const value_type& operator*() const {return *__result_;} 6635*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 66360b57cec5SDimitry Andric const value_type* operator->() const {return __result_;} 66370b57cec5SDimitry Andric 66380b57cec5SDimitry Andric regex_token_iterator& operator++(); 6639*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 66400b57cec5SDimitry Andric regex_token_iterator operator++(int) 66410b57cec5SDimitry Andric { 66420b57cec5SDimitry Andric regex_token_iterator __t(*this); 66430b57cec5SDimitry Andric ++(*this); 66440b57cec5SDimitry Andric return __t; 66450b57cec5SDimitry Andric } 66460b57cec5SDimitry Andric 66470b57cec5SDimitry Andricprivate: 66480b57cec5SDimitry Andric void __init(_BidirectionalIterator __a, _BidirectionalIterator __b); 66490b57cec5SDimitry Andric void __establish_result () { 66500b57cec5SDimitry Andric if (__subs_[__n_] == -1) 66510b57cec5SDimitry Andric __result_ = &__position_->prefix(); 66520b57cec5SDimitry Andric else 66530b57cec5SDimitry Andric __result_ = &(*__position_)[__subs_[__n_]]; 66540b57cec5SDimitry Andric } 66550b57cec5SDimitry Andric}; 66560b57cec5SDimitry Andric 66570b57cec5SDimitry Andrictemplate <class _BidirectionalIterator, class _CharT, class _Traits> 66580b57cec5SDimitry Andricregex_token_iterator<_BidirectionalIterator, _CharT, _Traits>:: 66590b57cec5SDimitry Andric regex_token_iterator() 66600b57cec5SDimitry Andric : __result_(nullptr), 66610b57cec5SDimitry Andric __suffix_(), 66620b57cec5SDimitry Andric __n_(0) 66630b57cec5SDimitry Andric{ 66640b57cec5SDimitry Andric} 66650b57cec5SDimitry Andric 66660b57cec5SDimitry Andrictemplate <class _BidirectionalIterator, class _CharT, class _Traits> 66670b57cec5SDimitry Andricvoid 66680b57cec5SDimitry Andricregex_token_iterator<_BidirectionalIterator, _CharT, _Traits>:: 66690b57cec5SDimitry Andric __init(_BidirectionalIterator __a, _BidirectionalIterator __b) 66700b57cec5SDimitry Andric{ 66710b57cec5SDimitry Andric if (__position_ != _Position()) 66720b57cec5SDimitry Andric __establish_result (); 66730b57cec5SDimitry Andric else if (__subs_[__n_] == -1) 66740b57cec5SDimitry Andric { 66750b57cec5SDimitry Andric __suffix_.matched = true; 66760b57cec5SDimitry Andric __suffix_.first = __a; 66770b57cec5SDimitry Andric __suffix_.second = __b; 66780b57cec5SDimitry Andric __result_ = &__suffix_; 66790b57cec5SDimitry Andric } 66800b57cec5SDimitry Andric else 66810b57cec5SDimitry Andric __result_ = nullptr; 66820b57cec5SDimitry Andric} 66830b57cec5SDimitry Andric 66840b57cec5SDimitry Andrictemplate <class _BidirectionalIterator, class _CharT, class _Traits> 66850b57cec5SDimitry Andricregex_token_iterator<_BidirectionalIterator, _CharT, _Traits>:: 66860b57cec5SDimitry Andric regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b, 66870b57cec5SDimitry Andric const regex_type& __re, int __submatch, 66880b57cec5SDimitry Andric regex_constants::match_flag_type __m) 66890b57cec5SDimitry Andric : __position_(__a, __b, __re, __m), 66900b57cec5SDimitry Andric __n_(0), 66910b57cec5SDimitry Andric __subs_(1, __submatch) 66920b57cec5SDimitry Andric{ 66930b57cec5SDimitry Andric __init(__a, __b); 66940b57cec5SDimitry Andric} 66950b57cec5SDimitry Andric 66960b57cec5SDimitry Andrictemplate <class _BidirectionalIterator, class _CharT, class _Traits> 66970b57cec5SDimitry Andricregex_token_iterator<_BidirectionalIterator, _CharT, _Traits>:: 66980b57cec5SDimitry Andric regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b, 66990b57cec5SDimitry Andric const regex_type& __re, const vector<int>& __submatches, 67000b57cec5SDimitry Andric regex_constants::match_flag_type __m) 67010b57cec5SDimitry Andric : __position_(__a, __b, __re, __m), 67020b57cec5SDimitry Andric __n_(0), 67030b57cec5SDimitry Andric __subs_(__submatches) 67040b57cec5SDimitry Andric{ 67050b57cec5SDimitry Andric __init(__a, __b); 67060b57cec5SDimitry Andric} 67070b57cec5SDimitry Andric 67080b57cec5SDimitry Andric#ifndef _LIBCPP_CXX03_LANG 67090b57cec5SDimitry Andric 67100b57cec5SDimitry Andrictemplate <class _BidirectionalIterator, class _CharT, class _Traits> 67110b57cec5SDimitry Andricregex_token_iterator<_BidirectionalIterator, _CharT, _Traits>:: 67120b57cec5SDimitry Andric regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b, 67130b57cec5SDimitry Andric const regex_type& __re, 67140b57cec5SDimitry Andric initializer_list<int> __submatches, 67150b57cec5SDimitry Andric regex_constants::match_flag_type __m) 67160b57cec5SDimitry Andric : __position_(__a, __b, __re, __m), 67170b57cec5SDimitry Andric __n_(0), 67180b57cec5SDimitry Andric __subs_(__submatches) 67190b57cec5SDimitry Andric{ 67200b57cec5SDimitry Andric __init(__a, __b); 67210b57cec5SDimitry Andric} 67220b57cec5SDimitry Andric 67230b57cec5SDimitry Andric#endif // _LIBCPP_CXX03_LANG 67240b57cec5SDimitry Andric 67250b57cec5SDimitry Andrictemplate <class _BidirectionalIterator, class _CharT, class _Traits> 67260b57cec5SDimitry Andrictemplate <size_t _Np> 67270b57cec5SDimitry Andricregex_token_iterator<_BidirectionalIterator, _CharT, _Traits>:: 67280b57cec5SDimitry Andric regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b, 67290b57cec5SDimitry Andric const regex_type& __re, 67300b57cec5SDimitry Andric const int (&__submatches)[_Np], 67310b57cec5SDimitry Andric regex_constants::match_flag_type __m) 67320b57cec5SDimitry Andric : __position_(__a, __b, __re, __m), 67330b57cec5SDimitry Andric __n_(0), 67340b57cec5SDimitry Andric __subs_(begin(__submatches), end(__submatches)) 67350b57cec5SDimitry Andric{ 67360b57cec5SDimitry Andric __init(__a, __b); 67370b57cec5SDimitry Andric} 67380b57cec5SDimitry Andric 67390b57cec5SDimitry Andrictemplate <class _BidirectionalIterator, class _CharT, class _Traits> 67400b57cec5SDimitry Andricregex_token_iterator<_BidirectionalIterator, _CharT, _Traits>:: 67410b57cec5SDimitry Andric regex_token_iterator(const regex_token_iterator& __x) 67420b57cec5SDimitry Andric : __position_(__x.__position_), 67430b57cec5SDimitry Andric __result_(__x.__result_), 67440b57cec5SDimitry Andric __suffix_(__x.__suffix_), 67450b57cec5SDimitry Andric __n_(__x.__n_), 67460b57cec5SDimitry Andric __subs_(__x.__subs_) 67470b57cec5SDimitry Andric{ 67480b57cec5SDimitry Andric if (__x.__result_ == &__x.__suffix_) 67490b57cec5SDimitry Andric __result_ = &__suffix_; 67500b57cec5SDimitry Andric else if ( __result_ != nullptr ) 67510b57cec5SDimitry Andric __establish_result (); 67520b57cec5SDimitry Andric} 67530b57cec5SDimitry Andric 67540b57cec5SDimitry Andrictemplate <class _BidirectionalIterator, class _CharT, class _Traits> 67550b57cec5SDimitry Andricregex_token_iterator<_BidirectionalIterator, _CharT, _Traits>& 67560b57cec5SDimitry Andricregex_token_iterator<_BidirectionalIterator, _CharT, _Traits>:: 67570b57cec5SDimitry Andric operator=(const regex_token_iterator& __x) 67580b57cec5SDimitry Andric{ 67590b57cec5SDimitry Andric if (this != &__x) 67600b57cec5SDimitry Andric { 67610b57cec5SDimitry Andric __position_ = __x.__position_; 67620b57cec5SDimitry Andric if (__x.__result_ == &__x.__suffix_) 67630b57cec5SDimitry Andric __result_ = &__suffix_; 67640b57cec5SDimitry Andric else 67650b57cec5SDimitry Andric __result_ = __x.__result_; 67660b57cec5SDimitry Andric __suffix_ = __x.__suffix_; 67670b57cec5SDimitry Andric __n_ = __x.__n_; 67680b57cec5SDimitry Andric __subs_ = __x.__subs_; 67690b57cec5SDimitry Andric 67700b57cec5SDimitry Andric if ( __result_ != nullptr && __result_ != &__suffix_ ) 67710b57cec5SDimitry Andric __establish_result(); 67720b57cec5SDimitry Andric } 67730b57cec5SDimitry Andric return *this; 67740b57cec5SDimitry Andric} 67750b57cec5SDimitry Andric 67760b57cec5SDimitry Andrictemplate <class _BidirectionalIterator, class _CharT, class _Traits> 67770b57cec5SDimitry Andricbool 67780b57cec5SDimitry Andricregex_token_iterator<_BidirectionalIterator, _CharT, _Traits>:: 67790b57cec5SDimitry Andric operator==(const regex_token_iterator& __x) const 67800b57cec5SDimitry Andric{ 67810b57cec5SDimitry Andric if (__result_ == nullptr && __x.__result_ == nullptr) 67820b57cec5SDimitry Andric return true; 67830b57cec5SDimitry Andric if (__result_ == &__suffix_ && __x.__result_ == &__x.__suffix_ && 67840b57cec5SDimitry Andric __suffix_ == __x.__suffix_) 67850b57cec5SDimitry Andric return true; 67860b57cec5SDimitry Andric if (__result_ == nullptr || __x.__result_ == nullptr) 67870b57cec5SDimitry Andric return false; 67880b57cec5SDimitry Andric if (__result_ == &__suffix_ || __x.__result_ == &__x.__suffix_) 67890b57cec5SDimitry Andric return false; 67900b57cec5SDimitry Andric return __position_ == __x.__position_ && __n_ == __x.__n_ && 67910b57cec5SDimitry Andric __subs_ == __x.__subs_; 67920b57cec5SDimitry Andric} 67930b57cec5SDimitry Andric 67940b57cec5SDimitry Andrictemplate <class _BidirectionalIterator, class _CharT, class _Traits> 67950b57cec5SDimitry Andricregex_token_iterator<_BidirectionalIterator, _CharT, _Traits>& 67960b57cec5SDimitry Andricregex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::operator++() 67970b57cec5SDimitry Andric{ 67980b57cec5SDimitry Andric _Position __prev = __position_; 67990b57cec5SDimitry Andric if (__result_ == &__suffix_) 68000b57cec5SDimitry Andric __result_ = nullptr; 68010b57cec5SDimitry Andric else if (static_cast<size_t>(__n_ + 1) < __subs_.size()) 68020b57cec5SDimitry Andric { 68030b57cec5SDimitry Andric ++__n_; 68040b57cec5SDimitry Andric __establish_result(); 68050b57cec5SDimitry Andric } 68060b57cec5SDimitry Andric else 68070b57cec5SDimitry Andric { 68080b57cec5SDimitry Andric __n_ = 0; 68090b57cec5SDimitry Andric ++__position_; 68100b57cec5SDimitry Andric if (__position_ != _Position()) 68110b57cec5SDimitry Andric __establish_result(); 68120b57cec5SDimitry Andric else 68130b57cec5SDimitry Andric { 6814*5f757f3fSDimitry Andric if (std::find(__subs_.begin(), __subs_.end(), -1) != __subs_.end() 68150b57cec5SDimitry Andric && __prev->suffix().length() != 0) 68160b57cec5SDimitry Andric { 68170b57cec5SDimitry Andric __suffix_.matched = true; 68180b57cec5SDimitry Andric __suffix_.first = __prev->suffix().first; 68190b57cec5SDimitry Andric __suffix_.second = __prev->suffix().second; 68200b57cec5SDimitry Andric __result_ = &__suffix_; 68210b57cec5SDimitry Andric } 68220b57cec5SDimitry Andric else 68230b57cec5SDimitry Andric __result_ = nullptr; 68240b57cec5SDimitry Andric } 68250b57cec5SDimitry Andric } 68260b57cec5SDimitry Andric return *this; 68270b57cec5SDimitry Andric} 68280b57cec5SDimitry Andric 68290b57cec5SDimitry Andric// regex_replace 68300b57cec5SDimitry Andric 68310b57cec5SDimitry Andrictemplate <class _OutputIterator, class _BidirectionalIterator, 68320b57cec5SDimitry Andric class _Traits, class _CharT> 6833bdd1243dSDimitry Andric_LIBCPP_HIDE_FROM_ABI _OutputIterator 68340b57cec5SDimitry Andricregex_replace(_OutputIterator __output_iter, 68350b57cec5SDimitry Andric _BidirectionalIterator __first, _BidirectionalIterator __last, 68360b57cec5SDimitry Andric const basic_regex<_CharT, _Traits>& __e, const _CharT* __fmt, 68370b57cec5SDimitry Andric regex_constants::match_flag_type __flags = regex_constants::match_default) 68380b57cec5SDimitry Andric{ 68390b57cec5SDimitry Andric typedef regex_iterator<_BidirectionalIterator, _CharT, _Traits> _Iter; 68400b57cec5SDimitry Andric _Iter __i(__first, __last, __e, __flags); 68410b57cec5SDimitry Andric _Iter __eof; 68420b57cec5SDimitry Andric if (__i == __eof) 68430b57cec5SDimitry Andric { 68440b57cec5SDimitry Andric if (!(__flags & regex_constants::format_no_copy)) 6845*5f757f3fSDimitry Andric __output_iter = std::copy(__first, __last, __output_iter); 68460b57cec5SDimitry Andric } 68470b57cec5SDimitry Andric else 68480b57cec5SDimitry Andric { 68490b57cec5SDimitry Andric sub_match<_BidirectionalIterator> __lm; 68500b57cec5SDimitry Andric for (size_t __len = char_traits<_CharT>::length(__fmt); __i != __eof; ++__i) 68510b57cec5SDimitry Andric { 68520b57cec5SDimitry Andric if (!(__flags & regex_constants::format_no_copy)) 6853*5f757f3fSDimitry Andric __output_iter = std::copy(__i->prefix().first, __i->prefix().second, __output_iter); 68540b57cec5SDimitry Andric __output_iter = __i->format(__output_iter, __fmt, __fmt + __len, __flags); 68550b57cec5SDimitry Andric __lm = __i->suffix(); 68560b57cec5SDimitry Andric if (__flags & regex_constants::format_first_only) 68570b57cec5SDimitry Andric break; 68580b57cec5SDimitry Andric } 68590b57cec5SDimitry Andric if (!(__flags & regex_constants::format_no_copy)) 6860*5f757f3fSDimitry Andric __output_iter = std::copy(__lm.first, __lm.second, __output_iter); 68610b57cec5SDimitry Andric } 68620b57cec5SDimitry Andric return __output_iter; 68630b57cec5SDimitry Andric} 68640b57cec5SDimitry Andric 68650b57cec5SDimitry Andrictemplate <class _OutputIterator, class _BidirectionalIterator, 68660b57cec5SDimitry Andric class _Traits, class _CharT, class _ST, class _SA> 6867*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 68680b57cec5SDimitry Andric_OutputIterator 68690b57cec5SDimitry Andricregex_replace(_OutputIterator __output_iter, 68700b57cec5SDimitry Andric _BidirectionalIterator __first, _BidirectionalIterator __last, 68710b57cec5SDimitry Andric const basic_regex<_CharT, _Traits>& __e, 68720b57cec5SDimitry Andric const basic_string<_CharT, _ST, _SA>& __fmt, 68730b57cec5SDimitry Andric regex_constants::match_flag_type __flags = regex_constants::match_default) 68740b57cec5SDimitry Andric{ 6875*5f757f3fSDimitry Andric return std::regex_replace(__output_iter, __first, __last, __e, __fmt.c_str(), __flags); 68760b57cec5SDimitry Andric} 68770b57cec5SDimitry Andric 68780b57cec5SDimitry Andrictemplate <class _Traits, class _CharT, class _ST, class _SA, class _FST, 68790b57cec5SDimitry Andric class _FSA> 6880*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 68810b57cec5SDimitry Andricbasic_string<_CharT, _ST, _SA> 68820b57cec5SDimitry Andricregex_replace(const basic_string<_CharT, _ST, _SA>& __s, 68830b57cec5SDimitry Andric const basic_regex<_CharT, _Traits>& __e, 68840b57cec5SDimitry Andric const basic_string<_CharT, _FST, _FSA>& __fmt, 68850b57cec5SDimitry Andric regex_constants::match_flag_type __flags = regex_constants::match_default) 68860b57cec5SDimitry Andric{ 68870b57cec5SDimitry Andric basic_string<_CharT, _ST, _SA> __r; 6888*5f757f3fSDimitry Andric std::regex_replace(std::back_inserter(__r), __s.begin(), __s.end(), __e, 68890b57cec5SDimitry Andric __fmt.c_str(), __flags); 68900b57cec5SDimitry Andric return __r; 68910b57cec5SDimitry Andric} 68920b57cec5SDimitry Andric 68930b57cec5SDimitry Andrictemplate <class _Traits, class _CharT, class _ST, class _SA> 6894*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 68950b57cec5SDimitry Andricbasic_string<_CharT, _ST, _SA> 68960b57cec5SDimitry Andricregex_replace(const basic_string<_CharT, _ST, _SA>& __s, 68970b57cec5SDimitry Andric const basic_regex<_CharT, _Traits>& __e, const _CharT* __fmt, 68980b57cec5SDimitry Andric regex_constants::match_flag_type __flags = regex_constants::match_default) 68990b57cec5SDimitry Andric{ 69000b57cec5SDimitry Andric basic_string<_CharT, _ST, _SA> __r; 6901*5f757f3fSDimitry Andric std::regex_replace(std::back_inserter(__r), __s.begin(), __s.end(), __e, 69020b57cec5SDimitry Andric __fmt, __flags); 69030b57cec5SDimitry Andric return __r; 69040b57cec5SDimitry Andric} 69050b57cec5SDimitry Andric 69060b57cec5SDimitry Andrictemplate <class _Traits, class _CharT, class _ST, class _SA> 6907*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 69080b57cec5SDimitry Andricbasic_string<_CharT> 69090b57cec5SDimitry Andricregex_replace(const _CharT* __s, 69100b57cec5SDimitry Andric const basic_regex<_CharT, _Traits>& __e, 69110b57cec5SDimitry Andric const basic_string<_CharT, _ST, _SA>& __fmt, 69120b57cec5SDimitry Andric regex_constants::match_flag_type __flags = regex_constants::match_default) 69130b57cec5SDimitry Andric{ 69140b57cec5SDimitry Andric basic_string<_CharT> __r; 6915*5f757f3fSDimitry Andric std::regex_replace(std::back_inserter(__r), __s, 69160b57cec5SDimitry Andric __s + char_traits<_CharT>::length(__s), __e, 69170b57cec5SDimitry Andric __fmt.c_str(), __flags); 69180b57cec5SDimitry Andric return __r; 69190b57cec5SDimitry Andric} 69200b57cec5SDimitry Andric 69210b57cec5SDimitry Andrictemplate <class _Traits, class _CharT> 6922*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 69230b57cec5SDimitry Andricbasic_string<_CharT> 69240b57cec5SDimitry Andricregex_replace(const _CharT* __s, 69250b57cec5SDimitry Andric const basic_regex<_CharT, _Traits>& __e, 69260b57cec5SDimitry Andric const _CharT* __fmt, 69270b57cec5SDimitry Andric regex_constants::match_flag_type __flags = regex_constants::match_default) 69280b57cec5SDimitry Andric{ 69290b57cec5SDimitry Andric basic_string<_CharT> __r; 6930*5f757f3fSDimitry Andric std::regex_replace(std::back_inserter(__r), __s, 69310b57cec5SDimitry Andric __s + char_traits<_CharT>::length(__s), __e, 69320b57cec5SDimitry Andric __fmt, __flags); 69330b57cec5SDimitry Andric return __r; 69340b57cec5SDimitry Andric} 69350b57cec5SDimitry Andric 69360b57cec5SDimitry Andric_LIBCPP_END_NAMESPACE_STD 69370b57cec5SDimitry Andric 693806c3fb27SDimitry Andric#if _LIBCPP_STD_VER >= 17 6939bdd1243dSDimitry Andric_LIBCPP_BEGIN_NAMESPACE_STD 6940bdd1243dSDimitry Andricnamespace pmr { 6941bdd1243dSDimitry Andrictemplate <class _BidirT> 694206c3fb27SDimitry Andricusing match_results _LIBCPP_AVAILABILITY_PMR = std::match_results<_BidirT, polymorphic_allocator<std::sub_match<_BidirT>>>; 6943bdd1243dSDimitry Andric 694406c3fb27SDimitry Andricusing cmatch _LIBCPP_AVAILABILITY_PMR = match_results<const char*>; 694506c3fb27SDimitry Andricusing smatch _LIBCPP_AVAILABILITY_PMR = match_results<std::pmr::string::const_iterator>; 6946bdd1243dSDimitry Andric 6947bdd1243dSDimitry Andric#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 694806c3fb27SDimitry Andricusing wcmatch _LIBCPP_AVAILABILITY_PMR = match_results<const wchar_t*>; 694906c3fb27SDimitry Andricusing wsmatch _LIBCPP_AVAILABILITY_PMR = match_results<std::pmr::wstring::const_iterator>; 6950bdd1243dSDimitry Andric#endif 6951bdd1243dSDimitry Andric} // namespace pmr 6952bdd1243dSDimitry Andric_LIBCPP_END_NAMESPACE_STD 6953bdd1243dSDimitry Andric#endif 6954bdd1243dSDimitry Andric 69550b57cec5SDimitry Andric_LIBCPP_POP_MACROS 69560b57cec5SDimitry Andric 6957bdd1243dSDimitry Andric#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 6958bdd1243dSDimitry Andric# include <atomic> 6959bdd1243dSDimitry Andric# include <concepts> 696006c3fb27SDimitry Andric# include <cstdlib> 6961bdd1243dSDimitry Andric# include <iosfwd> 6962bdd1243dSDimitry Andric# include <iterator> 6963*5f757f3fSDimitry Andric# include <mutex> 6964bdd1243dSDimitry Andric# include <new> 696506c3fb27SDimitry Andric# include <type_traits> 6966bdd1243dSDimitry Andric# include <typeinfo> 6967bdd1243dSDimitry Andric# include <utility> 6968bdd1243dSDimitry Andric#endif 6969bdd1243dSDimitry Andric 69700b57cec5SDimitry Andric#endif // _LIBCPP_REGEX 6971