// -*- C++ -*- //===--------------------------- regex ------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef _LIBCPP_REGEX #define _LIBCPP_REGEX /* regex synopsis #include namespace std { namespace regex_constants { enum syntax_option_type { icase = unspecified, nosubs = unspecified, optimize = unspecified, collate = unspecified, ECMAScript = unspecified, basic = unspecified, extended = unspecified, awk = unspecified, grep = unspecified, egrep = unspecified, multiline = unspecified }; constexpr syntax_option_type operator~(syntax_option_type f); constexpr syntax_option_type operator&(syntax_option_type lhs, syntax_option_type rhs); constexpr syntax_option_type operator|(syntax_option_type lhs, syntax_option_type rhs); enum match_flag_type { match_default = 0, match_not_bol = unspecified, match_not_eol = unspecified, match_not_bow = unspecified, match_not_eow = unspecified, match_any = unspecified, match_not_null = unspecified, match_continuous = unspecified, match_prev_avail = unspecified, format_default = 0, format_sed = unspecified, format_no_copy = unspecified, format_first_only = unspecified }; constexpr match_flag_type operator~(match_flag_type f); constexpr match_flag_type operator&(match_flag_type lhs, match_flag_type rhs); constexpr match_flag_type operator|(match_flag_type lhs, match_flag_type rhs); enum error_type { error_collate = unspecified, error_ctype = unspecified, error_escape = unspecified, error_backref = unspecified, error_brack = unspecified, error_paren = unspecified, error_brace = unspecified, error_badbrace = unspecified, error_range = unspecified, error_space = unspecified, error_badrepeat = unspecified, error_complexity = unspecified, error_stack = unspecified }; } // regex_constants class regex_error : public runtime_error { public: explicit regex_error(regex_constants::error_type ecode); regex_constants::error_type code() const; }; template struct regex_traits { public: typedef charT char_type; typedef basic_string string_type; typedef locale locale_type; typedef /bitmask_type/ char_class_type; regex_traits(); static size_t length(const char_type* p); charT translate(charT c) const; charT translate_nocase(charT c) const; template string_type transform(ForwardIterator first, ForwardIterator last) const; template string_type transform_primary( ForwardIterator first, ForwardIterator last) const; template string_type lookup_collatename(ForwardIterator first, ForwardIterator last) const; template char_class_type lookup_classname(ForwardIterator first, ForwardIterator last, bool icase = false) const; bool isctype(charT c, char_class_type f) const; int value(charT ch, int radix) const; locale_type imbue(locale_type l); locale_type getloc()const; }; template > class basic_regex { public: // types: typedef charT value_type; typedef traits traits_type; typedef typename traits::string_type string_type; typedef regex_constants::syntax_option_type flag_type; typedef typename traits::locale_type locale_type; // constants: static constexpr regex_constants::syntax_option_type icase = regex_constants::icase; static constexpr regex_constants::syntax_option_type nosubs = regex_constants::nosubs; static constexpr regex_constants::syntax_option_type optimize = regex_constants::optimize; static constexpr regex_constants::syntax_option_type collate = regex_constants::collate; static constexpr regex_constants::syntax_option_type ECMAScript = regex_constants::ECMAScript; static constexpr regex_constants::syntax_option_type basic = regex_constants::basic; static constexpr regex_constants::syntax_option_type extended = regex_constants::extended; static constexpr regex_constants::syntax_option_type awk = regex_constants::awk; static constexpr regex_constants::syntax_option_type grep = regex_constants::grep; static constexpr regex_constants::syntax_option_type egrep = regex_constants::egrep; static constexpr regex_constants::syntax_option_type multiline = regex_constants::multiline; // construct/copy/destroy: basic_regex(); explicit basic_regex(const charT* p, flag_type f = regex_constants::ECMAScript); basic_regex(const charT* p, size_t len, flag_type f = regex_constants::ECMAScript); basic_regex(const basic_regex&); basic_regex(basic_regex&&) noexcept; template explicit basic_regex(const basic_string& p, flag_type f = regex_constants::ECMAScript); template basic_regex(ForwardIterator first, ForwardIterator last, flag_type f = regex_constants::ECMAScript); basic_regex(initializer_list, flag_type = regex_constants::ECMAScript); ~basic_regex(); basic_regex& operator=(const basic_regex&); basic_regex& operator=(basic_regex&&) noexcept; basic_regex& operator=(const charT* ptr); basic_regex& operator=(initializer_list il); template basic_regex& operator=(const basic_string& p); // assign: basic_regex& assign(const basic_regex& that); basic_regex& assign(basic_regex&& that) noexcept; basic_regex& assign(const charT* ptr, flag_type f = regex_constants::ECMAScript); basic_regex& assign(const charT* p, size_t len, flag_type f = regex_constants::ECMAScript); template basic_regex& assign(const basic_string& s, flag_type f = regex_constants::ECMAScript); template basic_regex& assign(InputIterator first, InputIterator last, flag_type f = regex_constants::ECMAScript); basic_regex& assign(initializer_list, flag_type f = regex_constants::ECMAScript); // const operations: unsigned mark_count() const; flag_type flags() const; // locale: locale_type imbue(locale_type loc); locale_type getloc() const; // swap: void swap(basic_regex&); }; template basic_regex(ForwardIterator, ForwardIterator, regex_constants::syntax_option_type = regex_constants::ECMAScript) -> basic_regex::value_type>; // C++17 typedef basic_regex regex; typedef basic_regex wregex; template void swap(basic_regex& e1, basic_regex& e2); template class sub_match : public pair { public: typedef typename iterator_traits::value_type value_type; typedef typename iterator_traits::difference_type difference_type; typedef BidirectionalIterator iterator; typedef basic_string string_type; bool matched; constexpr sub_match(); difference_type length() const; operator string_type() const; string_type str() const; int compare(const sub_match& s) const; int compare(const string_type& s) const; int compare(const value_type* s) const; }; typedef sub_match csub_match; typedef sub_match wcsub_match; typedef sub_match ssub_match; typedef sub_match wssub_match; template bool operator==(const sub_match& lhs, const sub_match& rhs); template bool operator!=(const sub_match& lhs, const sub_match& rhs); template bool operator<(const sub_match& lhs, const sub_match& rhs); template bool operator<=(const sub_match& lhs, const sub_match& rhs); template bool operator>=(const sub_match& lhs, const sub_match& rhs); template bool operator>(const sub_match& lhs, const sub_match& rhs); template bool operator==(const basic_string::value_type, ST, SA>& lhs, const sub_match& rhs); template bool operator!=(const basic_string::value_type, ST, SA>& lhs, const sub_match& rhs); template bool operator<(const basic_string::value_type, ST, SA>& lhs, const sub_match& rhs); template bool operator>(const basic_string::value_type, ST, SA>& lhs, const sub_match& rhs); template bool operator>=(const basic_string::value_type, ST, SA>& lhs, const sub_match& rhs); template bool operator<=(const basic_string::value_type, ST, SA>& lhs, const sub_match& rhs); template bool operator==(const sub_match& lhs, const basic_string::value_type, ST, SA>& rhs); template bool operator!=(const sub_match& lhs, const basic_string::value_type, ST, SA>& rhs); template bool operator<(const sub_match& lhs, const basic_string::value_type, ST, SA>& rhs); template bool operator>(const sub_match& lhs, const basic_string::value_type, ST, SA>& rhs); template bool operator>=(const sub_match& lhs, const basic_string::value_type, ST, SA>& rhs); template bool operator<=(const sub_match& lhs, const basic_string::value_type, ST, SA>& rhs); template bool operator==(typename iterator_traits::value_type const* lhs, const sub_match& rhs); template bool operator!=(typename iterator_traits::value_type const* lhs, const sub_match& rhs); template bool operator<(typename iterator_traits::value_type const* lhs, const sub_match& rhs); template bool operator>(typename iterator_traits::value_type const* lhs, const sub_match& rhs); template bool operator>=(typename iterator_traits::value_type const* lhs, const sub_match& rhs); template bool operator<=(typename iterator_traits::value_type const* lhs, const sub_match& rhs); template bool operator==(const sub_match& lhs, typename iterator_traits::value_type const* rhs); template bool operator!=(const sub_match& lhs, typename iterator_traits::value_type const* rhs); template bool operator<(const sub_match& lhs, typename iterator_traits::value_type const* rhs); template bool operator>(const sub_match& lhs, typename iterator_traits::value_type const* rhs); template bool operator>=(const sub_match& lhs, typename iterator_traits::value_type const* rhs); template bool operator<=(const sub_match& lhs, typename iterator_traits::value_type const* rhs); template bool operator==(typename iterator_traits::value_type const& lhs, const sub_match& rhs); template bool operator!=(typename iterator_traits::value_type const& lhs, const sub_match& rhs); template bool operator<(typename iterator_traits::value_type const& lhs, const sub_match& rhs); template bool operator>(typename iterator_traits::value_type const& lhs, const sub_match& rhs); template bool operator>=(typename iterator_traits::value_type const& lhs, const sub_match& rhs); template bool operator<=(typename iterator_traits::value_type const& lhs, const sub_match& rhs); template bool operator==(const sub_match& lhs, typename iterator_traits::value_type const& rhs); template bool operator!=(const sub_match& lhs, typename iterator_traits::value_type const& rhs); template bool operator<(const sub_match& lhs, typename iterator_traits::value_type const& rhs); template bool operator>(const sub_match& lhs, typename iterator_traits::value_type const& rhs); template bool operator>=(const sub_match& lhs, typename iterator_traits::value_type const& rhs); template bool operator<=(const sub_match& lhs, typename iterator_traits::value_type const& rhs); template basic_ostream& operator<<(basic_ostream& os, const sub_match& m); template >> class match_results { public: typedef sub_match value_type; typedef const value_type& const_reference; typedef value_type& reference; typedef /implementation-defined/ const_iterator; typedef const_iterator iterator; typedef typename iterator_traits::difference_type difference_type; typedef typename allocator_traits::size_type size_type; typedef Allocator allocator_type; typedef typename iterator_traits::value_type char_type; typedef basic_string string_type; // construct/copy/destroy: explicit match_results(const Allocator& a = Allocator()); // before C++20 match_results() : match_results(Allocator()) {} // C++20 explicit match_results(const Allocator& a); // C++20 match_results(const match_results& m); match_results(match_results&& m) noexcept; match_results& operator=(const match_results& m); match_results& operator=(match_results&& m); ~match_results(); bool ready() const; // size: size_type size() const; size_type max_size() const; bool empty() const; // element access: difference_type length(size_type sub = 0) const; difference_type position(size_type sub = 0) const; string_type str(size_type sub = 0) const; const_reference operator[](size_type n) const; const_reference prefix() const; const_reference suffix() const; const_iterator begin() const; const_iterator end() const; const_iterator cbegin() const; const_iterator cend() const; // format: template OutputIter format(OutputIter out, const char_type* fmt_first, const char_type* fmt_last, regex_constants::match_flag_type flags = regex_constants::format_default) const; template OutputIter format(OutputIter out, const basic_string& fmt, regex_constants::match_flag_type flags = regex_constants::format_default) const; template basic_string format(const basic_string& fmt, regex_constants::match_flag_type flags = regex_constants::format_default) const; string_type format(const char_type* fmt, regex_constants::match_flag_type flags = regex_constants::format_default) const; // allocator: allocator_type get_allocator() const; // swap: void swap(match_results& that); }; typedef match_results cmatch; typedef match_results wcmatch; typedef match_results smatch; typedef match_results wsmatch; template bool operator==(const match_results& m1, const match_results& m2); template bool operator!=(const match_results& m1, const match_results& m2); template void swap(match_results& m1, match_results& m2); template bool regex_match(BidirectionalIterator first, BidirectionalIterator last, match_results& m, const basic_regex& e, regex_constants::match_flag_type flags = regex_constants::match_default); template bool regex_match(BidirectionalIterator first, BidirectionalIterator last, const basic_regex& e, regex_constants::match_flag_type flags = regex_constants::match_default); template bool regex_match(const charT* str, match_results& m, const basic_regex& e, regex_constants::match_flag_type flags = regex_constants::match_default); template bool regex_match(const basic_string& s, match_results::const_iterator, Allocator>& m, const basic_regex& e, regex_constants::match_flag_type flags = regex_constants::match_default); template bool regex_match(const basic_string&& s, match_results::const_iterator, Allocator>& m, const basic_regex& e, regex_constants::match_flag_type flags = regex_constants::match_default) = delete; // C++14 template bool regex_match(const charT* str, const basic_regex& e, regex_constants::match_flag_type flags = regex_constants::match_default); template bool regex_match(const basic_string& s, const basic_regex& e, regex_constants::match_flag_type flags = regex_constants::match_default); template bool regex_search(BidirectionalIterator first, BidirectionalIterator last, match_results& m, const basic_regex& e, regex_constants::match_flag_type flags = regex_constants::match_default); template bool regex_search(BidirectionalIterator first, BidirectionalIterator last, const basic_regex& e, regex_constants::match_flag_type flags = regex_constants::match_default); template bool regex_search(const charT* str, match_results& m, const basic_regex& e, regex_constants::match_flag_type flags = regex_constants::match_default); template bool regex_search(const charT* str, const basic_regex& e, regex_constants::match_flag_type flags = regex_constants::match_default); template bool regex_search(const basic_string& s, const basic_regex& e, regex_constants::match_flag_type flags = regex_constants::match_default); template bool regex_search(const basic_string& s, match_results::const_iterator, Allocator>& m, const basic_regex& e, regex_constants::match_flag_type flags = regex_constants::match_default); template bool regex_search(const basic_string&& s, match_results::const_iterator, Allocator>& m, const basic_regex& e, regex_constants::match_flag_type flags = regex_constants::match_default) = delete; // C++14 template OutputIterator regex_replace(OutputIterator out, BidirectionalIterator first, BidirectionalIterator last, const basic_regex& e, const basic_string& fmt, regex_constants::match_flag_type flags = regex_constants::match_default); template OutputIterator regex_replace(OutputIterator out, BidirectionalIterator first, BidirectionalIterator last, const basic_regex& e, const charT* fmt, regex_constants::match_flag_type flags = regex_constants::match_default); template basic_string regex_replace(const basic_string& s, const basic_regex& e, const basic_string& fmt, regex_constants::match_flag_type flags = regex_constants::match_default); template basic_string regex_replace(const basic_string& s, const basic_regex& e, const charT* fmt, regex_constants::match_flag_type flags = regex_constants::match_default); template basic_string regex_replace(const charT* s, const basic_regex& e, const basic_string& fmt, regex_constants::match_flag_type flags = regex_constants::match_default); template basic_string regex_replace(const charT* s, const basic_regex& e, const charT* fmt, regex_constants::match_flag_type flags = regex_constants::match_default); template ::value_type, class traits = regex_traits> class regex_iterator { public: typedef basic_regex regex_type; typedef match_results value_type; typedef ptrdiff_t difference_type; typedef const value_type* pointer; typedef const value_type& reference; typedef forward_iterator_tag iterator_category; regex_iterator(); regex_iterator(BidirectionalIterator a, BidirectionalIterator b, const regex_type& re, regex_constants::match_flag_type m = regex_constants::match_default); regex_iterator(BidirectionalIterator a, BidirectionalIterator b, const regex_type&& re, regex_constants::match_flag_type m = regex_constants::match_default) = delete; // C++14 regex_iterator(const regex_iterator&); regex_iterator& operator=(const regex_iterator&); bool operator==(const regex_iterator&) const; bool operator!=(const regex_iterator&) const; const value_type& operator*() const; const value_type* operator->() const; regex_iterator& operator++(); regex_iterator operator++(int); }; typedef regex_iterator cregex_iterator; typedef regex_iterator wcregex_iterator; typedef regex_iterator sregex_iterator; typedef regex_iterator wsregex_iterator; template ::value_type, class traits = regex_traits> class regex_token_iterator { public: typedef basic_regex regex_type; typedef sub_match value_type; typedef ptrdiff_t difference_type; typedef const value_type* pointer; typedef const value_type& reference; typedef forward_iterator_tag iterator_category; regex_token_iterator(); regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, const regex_type& re, int submatch = 0, regex_constants::match_flag_type m = regex_constants::match_default); regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, const regex_type&& re, int submatch = 0, regex_constants::match_flag_type m = regex_constants::match_default) = delete; // C++14 regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, const regex_type& re, const vector& submatches, regex_constants::match_flag_type m = regex_constants::match_default); regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, const regex_type&& re, const vector& submatches, regex_constants::match_flag_type m = regex_constants::match_default) = delete; // C++14 regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, const regex_type& re, initializer_list submatches, regex_constants::match_flag_type m = regex_constants::match_default); regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, const regex_type&& re, initializer_list submatches, regex_constants::match_flag_type m = regex_constants::match_default) = delete; // C++14 template regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, const regex_type& re, const int (&submatches)[N], regex_constants::match_flag_type m = regex_constants::match_default); template regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, const regex_type&& re, const int (&submatches)[N], regex_constants::match_flag_type m = regex_constants::match_default) = delete; // C++14 regex_token_iterator(const regex_token_iterator&); regex_token_iterator& operator=(const regex_token_iterator&); bool operator==(const regex_token_iterator&) const; bool operator!=(const regex_token_iterator&) const; const value_type& operator*() const; const value_type* operator->() const; regex_token_iterator& operator++(); regex_token_iterator operator++(int); }; typedef regex_token_iterator cregex_token_iterator; typedef regex_token_iterator wcregex_token_iterator; typedef regex_token_iterator sregex_token_iterator; typedef regex_token_iterator wsregex_token_iterator; } // std */ #include <__config> #include <__debug> #include <__iterator/wrap_iter.h> #include <__locale> #include #include #include #include #include #include #include #include #include #include #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #pragma GCC system_header #endif _LIBCPP_PUSH_MACROS #include <__undef_macros> #define _LIBCPP_REGEX_COMPLEXITY_FACTOR 4096 _LIBCPP_BEGIN_NAMESPACE_STD namespace regex_constants { // syntax_option_type enum syntax_option_type { icase = 1 << 0, nosubs = 1 << 1, optimize = 1 << 2, collate = 1 << 3, #ifdef _LIBCPP_ABI_REGEX_CONSTANTS_NONZERO ECMAScript = 1 << 9, #else ECMAScript = 0, #endif basic = 1 << 4, extended = 1 << 5, awk = 1 << 6, grep = 1 << 7, egrep = 1 << 8, // 1 << 9 may be used by ECMAScript multiline = 1 << 10 }; inline _LIBCPP_CONSTEXPR syntax_option_type __get_grammar(syntax_option_type __g) { #ifdef _LIBCPP_ABI_REGEX_CONSTANTS_NONZERO return static_cast(__g & 0x3F0); #else return static_cast(__g & 0x1F0); #endif } inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR syntax_option_type operator~(syntax_option_type __x) { return syntax_option_type(~int(__x) & 0x1FF); } inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR syntax_option_type operator&(syntax_option_type __x, syntax_option_type __y) { return syntax_option_type(int(__x) & int(__y)); } inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR syntax_option_type operator|(syntax_option_type __x, syntax_option_type __y) { return syntax_option_type(int(__x) | int(__y)); } inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR syntax_option_type operator^(syntax_option_type __x, syntax_option_type __y) { return syntax_option_type(int(__x) ^ int(__y)); } inline _LIBCPP_INLINE_VISIBILITY syntax_option_type& operator&=(syntax_option_type& __x, syntax_option_type __y) { __x = __x & __y; return __x; } inline _LIBCPP_INLINE_VISIBILITY syntax_option_type& operator|=(syntax_option_type& __x, syntax_option_type __y) { __x = __x | __y; return __x; } inline _LIBCPP_INLINE_VISIBILITY syntax_option_type& operator^=(syntax_option_type& __x, syntax_option_type __y) { __x = __x ^ __y; return __x; } // match_flag_type enum match_flag_type { match_default = 0, match_not_bol = 1 << 0, match_not_eol = 1 << 1, match_not_bow = 1 << 2, match_not_eow = 1 << 3, match_any = 1 << 4, match_not_null = 1 << 5, match_continuous = 1 << 6, match_prev_avail = 1 << 7, format_default = 0, format_sed = 1 << 8, format_no_copy = 1 << 9, format_first_only = 1 << 10, __no_update_pos = 1 << 11, __full_match = 1 << 12 }; inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR match_flag_type operator~(match_flag_type __x) { return match_flag_type(~int(__x) & 0x0FFF); } inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR match_flag_type operator&(match_flag_type __x, match_flag_type __y) { return match_flag_type(int(__x) & int(__y)); } inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR match_flag_type operator|(match_flag_type __x, match_flag_type __y) { return match_flag_type(int(__x) | int(__y)); } inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR match_flag_type operator^(match_flag_type __x, match_flag_type __y) { return match_flag_type(int(__x) ^ int(__y)); } inline _LIBCPP_INLINE_VISIBILITY match_flag_type& operator&=(match_flag_type& __x, match_flag_type __y) { __x = __x & __y; return __x; } inline _LIBCPP_INLINE_VISIBILITY match_flag_type& operator|=(match_flag_type& __x, match_flag_type __y) { __x = __x | __y; return __x; } inline _LIBCPP_INLINE_VISIBILITY match_flag_type& operator^=(match_flag_type& __x, match_flag_type __y) { __x = __x ^ __y; return __x; } enum error_type { error_collate = 1, error_ctype, error_escape, error_backref, error_brack, error_paren, error_brace, error_badbrace, error_range, error_space, error_badrepeat, error_complexity, error_stack, __re_err_grammar, __re_err_empty, __re_err_unknown, __re_err_parse }; } // regex_constants class _LIBCPP_EXCEPTION_ABI regex_error : public runtime_error { regex_constants::error_type __code_; public: explicit regex_error(regex_constants::error_type __ecode); regex_error(const regex_error&) _NOEXCEPT = default; virtual ~regex_error() _NOEXCEPT; _LIBCPP_INLINE_VISIBILITY regex_constants::error_type code() const {return __code_;} }; template _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY void __throw_regex_error() { #ifndef _LIBCPP_NO_EXCEPTIONS throw regex_error(_Ev); #else _VSTD::abort(); #endif } template struct _LIBCPP_TEMPLATE_VIS regex_traits { public: typedef _CharT char_type; typedef basic_string string_type; typedef locale locale_type; #ifdef __BIONIC__ // Originally bionic's ctype_base used its own ctype masks because the // builtin ctype implementation wasn't in libc++ yet. Bionic's ctype mask // was only 8 bits wide and already saturated, so it used a wider type here // to make room for __regex_word (then a part of this class rather than // ctype_base). Bionic has since moved to the builtin ctype_base // implementation, but this was not updated to match. Since then Android has // needed to maintain a stable libc++ ABI, and this can't be changed without // an ABI break. typedef uint16_t char_class_type; #else typedef ctype_base::mask char_class_type; #endif static const char_class_type __regex_word = ctype_base::__regex_word; private: locale __loc_; const ctype* __ct_; const collate* __col_; public: regex_traits(); _LIBCPP_INLINE_VISIBILITY static size_t length(const char_type* __p) {return char_traits::length(__p);} _LIBCPP_INLINE_VISIBILITY char_type translate(char_type __c) const {return __c;} char_type translate_nocase(char_type __c) const; template string_type transform(_ForwardIterator __f, _ForwardIterator __l) const; template _LIBCPP_INLINE_VISIBILITY string_type transform_primary( _ForwardIterator __f, _ForwardIterator __l) const {return __transform_primary(__f, __l, char_type());} template _LIBCPP_INLINE_VISIBILITY string_type lookup_collatename(_ForwardIterator __f, _ForwardIterator __l) const {return __lookup_collatename(__f, __l, char_type());} template _LIBCPP_INLINE_VISIBILITY char_class_type lookup_classname(_ForwardIterator __f, _ForwardIterator __l, bool __icase = false) const {return __lookup_classname(__f, __l, __icase, char_type());} bool isctype(char_type __c, char_class_type __m) const; _LIBCPP_INLINE_VISIBILITY int value(char_type __ch, int __radix) const {return __regex_traits_value(__ch, __radix);} locale_type imbue(locale_type __l); _LIBCPP_INLINE_VISIBILITY locale_type getloc()const {return __loc_;} private: void __init(); template string_type __transform_primary(_ForwardIterator __f, _ForwardIterator __l, char) const; template string_type __transform_primary(_ForwardIterator __f, _ForwardIterator __l, wchar_t) const; template string_type __lookup_collatename(_ForwardIterator __f, _ForwardIterator __l, char) const; template string_type __lookup_collatename(_ForwardIterator __f, _ForwardIterator __l, wchar_t) const; template char_class_type __lookup_classname(_ForwardIterator __f, _ForwardIterator __l, bool __icase, char) const; template char_class_type __lookup_classname(_ForwardIterator __f, _ForwardIterator __l, bool __icase, wchar_t) const; static int __regex_traits_value(unsigned char __ch, int __radix); _LIBCPP_INLINE_VISIBILITY int __regex_traits_value(char __ch, int __radix) const {return __regex_traits_value(static_cast(__ch), __radix);} _LIBCPP_INLINE_VISIBILITY int __regex_traits_value(wchar_t __ch, int __radix) const; }; template const typename regex_traits<_CharT>::char_class_type regex_traits<_CharT>::__regex_word; template regex_traits<_CharT>::regex_traits() { __init(); } template typename regex_traits<_CharT>::char_type regex_traits<_CharT>::translate_nocase(char_type __c) const { return __ct_->tolower(__c); } template template typename regex_traits<_CharT>::string_type regex_traits<_CharT>::transform(_ForwardIterator __f, _ForwardIterator __l) const { string_type __s(__f, __l); return __col_->transform(__s.data(), __s.data() + __s.size()); } template void regex_traits<_CharT>::__init() { __ct_ = &use_facet >(__loc_); __col_ = &use_facet >(__loc_); } template typename regex_traits<_CharT>::locale_type regex_traits<_CharT>::imbue(locale_type __l) { locale __r = __loc_; __loc_ = __l; __init(); return __r; } // transform_primary is very FreeBSD-specific template template typename regex_traits<_CharT>::string_type regex_traits<_CharT>::__transform_primary(_ForwardIterator __f, _ForwardIterator __l, char) const { const string_type __s(__f, __l); string_type __d = __col_->transform(__s.data(), __s.data() + __s.size()); switch (__d.size()) { case 1: break; case 12: __d[11] = __d[3]; break; default: __d.clear(); break; } return __d; } template template typename regex_traits<_CharT>::string_type regex_traits<_CharT>::__transform_primary(_ForwardIterator __f, _ForwardIterator __l, wchar_t) const { const string_type __s(__f, __l); string_type __d = __col_->transform(__s.data(), __s.data() + __s.size()); switch (__d.size()) { case 1: break; case 3: __d[2] = __d[0]; break; default: __d.clear(); break; } return __d; } // lookup_collatename is very FreeBSD-specific _LIBCPP_FUNC_VIS string __get_collation_name(const char* __s); template template typename regex_traits<_CharT>::string_type regex_traits<_CharT>::__lookup_collatename(_ForwardIterator __f, _ForwardIterator __l, char) const { string_type __s(__f, __l); string_type __r; if (!__s.empty()) { __r = __get_collation_name(__s.c_str()); if (__r.empty() && __s.size() <= 2) { __r = __col_->transform(__s.data(), __s.data() + __s.size()); if (__r.size() == 1 || __r.size() == 12) __r = __s; else __r.clear(); } } return __r; } template template typename regex_traits<_CharT>::string_type regex_traits<_CharT>::__lookup_collatename(_ForwardIterator __f, _ForwardIterator __l, wchar_t) const { string_type __s(__f, __l); string __n; __n.reserve(__s.size()); for (typename string_type::const_iterator __i = __s.begin(), __e = __s.end(); __i != __e; ++__i) { if (static_cast(*__i) >= 127) return string_type(); __n.push_back(char(*__i)); } string_type __r; if (!__s.empty()) { __n = __get_collation_name(__n.c_str()); if (!__n.empty()) __r.assign(__n.begin(), __n.end()); else if (__s.size() <= 2) { __r = __col_->transform(__s.data(), __s.data() + __s.size()); if (__r.size() == 1 || __r.size() == 3) __r = __s; else __r.clear(); } } return __r; } // lookup_classname regex_traits::char_class_type _LIBCPP_FUNC_VIS __get_classname(const char* __s, bool __icase); template template typename regex_traits<_CharT>::char_class_type regex_traits<_CharT>::__lookup_classname(_ForwardIterator __f, _ForwardIterator __l, bool __icase, char) const { string_type __s(__f, __l); __ct_->tolower(&__s[0], &__s[0] + __s.size()); return __get_classname(__s.c_str(), __icase); } template template typename regex_traits<_CharT>::char_class_type regex_traits<_CharT>::__lookup_classname(_ForwardIterator __f, _ForwardIterator __l, bool __icase, wchar_t) const { string_type __s(__f, __l); __ct_->tolower(&__s[0], &__s[0] + __s.size()); string __n; __n.reserve(__s.size()); for (typename string_type::const_iterator __i = __s.begin(), __e = __s.end(); __i != __e; ++__i) { if (static_cast(*__i) >= 127) return char_class_type(); __n.push_back(char(*__i)); } return __get_classname(__n.c_str(), __icase); } template bool regex_traits<_CharT>::isctype(char_type __c, char_class_type __m) const { if (__ct_->is(__m, __c)) return true; return (__c == '_' && (__m & __regex_word)); } template int regex_traits<_CharT>::__regex_traits_value(unsigned char __ch, int __radix) { if ((__ch & 0xF8u) == 0x30) // '0' <= __ch && __ch <= '7' return __ch - '0'; if (__radix != 8) { if ((__ch & 0xFEu) == 0x38) // '8' <= __ch && __ch <= '9' return __ch - '0'; if (__radix == 16) { __ch |= 0x20; // tolower if ('a' <= __ch && __ch <= 'f') return __ch - ('a' - 10); } } return -1; } template inline int regex_traits<_CharT>::__regex_traits_value(wchar_t __ch, int __radix) const { return __regex_traits_value(static_cast(__ct_->narrow(__ch, char_type())), __radix); } template class __node; template class _LIBCPP_TEMPLATE_VIS sub_match; template > > class _LIBCPP_TEMPLATE_VIS match_results; template struct __state { enum { __end_state = -1000, __consume_input, // -999 __begin_marked_expr, // -998 __end_marked_expr, // -997 __pop_state, // -996 __accept_and_consume, // -995 __accept_but_not_consume, // -994 __reject, // -993 __split, __repeat }; int __do_; const _CharT* __first_; const _CharT* __current_; const _CharT* __last_; vector > __sub_matches_; vector > __loop_data_; const __node<_CharT>* __node_; regex_constants::match_flag_type __flags_; bool __at_first_; _LIBCPP_INLINE_VISIBILITY __state() : __do_(0), __first_(nullptr), __current_(nullptr), __last_(nullptr), __node_(nullptr), __flags_() {} }; // __node template class __node { __node(const __node&); __node& operator=(const __node&); public: typedef _VSTD::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY __node() {} _LIBCPP_INLINE_VISIBILITY virtual ~__node() {} _LIBCPP_INLINE_VISIBILITY virtual void __exec(__state&) const {} _LIBCPP_INLINE_VISIBILITY virtual void __exec_split(bool, __state&) const {} }; // __end_state template class __end_state : public __node<_CharT> { public: typedef _VSTD::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY __end_state() {} virtual void __exec(__state&) const; }; template void __end_state<_CharT>::__exec(__state& __s) const { __s.__do_ = __state::__end_state; } // __has_one_state template class __has_one_state : public __node<_CharT> { __node<_CharT>* __first_; public: _LIBCPP_INLINE_VISIBILITY explicit __has_one_state(__node<_CharT>* __s) : __first_(__s) {} _LIBCPP_INLINE_VISIBILITY __node<_CharT>* first() const {return __first_;} _LIBCPP_INLINE_VISIBILITY __node<_CharT>*& first() {return __first_;} }; // __owns_one_state template class __owns_one_state : public __has_one_state<_CharT> { typedef __has_one_state<_CharT> base; public: _LIBCPP_INLINE_VISIBILITY explicit __owns_one_state(__node<_CharT>* __s) : base(__s) {} virtual ~__owns_one_state(); }; template __owns_one_state<_CharT>::~__owns_one_state() { delete this->first(); } // __empty_state template class __empty_state : public __owns_one_state<_CharT> { typedef __owns_one_state<_CharT> base; public: typedef _VSTD::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY explicit __empty_state(__node<_CharT>* __s) : base(__s) {} virtual void __exec(__state&) const; }; template void __empty_state<_CharT>::__exec(__state& __s) const { __s.__do_ = __state::__accept_but_not_consume; __s.__node_ = this->first(); } // __empty_non_own_state template class __empty_non_own_state : public __has_one_state<_CharT> { typedef __has_one_state<_CharT> base; public: typedef _VSTD::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY explicit __empty_non_own_state(__node<_CharT>* __s) : base(__s) {} virtual void __exec(__state&) const; }; template void __empty_non_own_state<_CharT>::__exec(__state& __s) const { __s.__do_ = __state::__accept_but_not_consume; __s.__node_ = this->first(); } // __repeat_one_loop template class __repeat_one_loop : public __has_one_state<_CharT> { typedef __has_one_state<_CharT> base; public: typedef _VSTD::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY explicit __repeat_one_loop(__node<_CharT>* __s) : base(__s) {} virtual void __exec(__state&) const; }; template void __repeat_one_loop<_CharT>::__exec(__state& __s) const { __s.__do_ = __state::__repeat; __s.__node_ = this->first(); } // __owns_two_states template class __owns_two_states : public __owns_one_state<_CharT> { typedef __owns_one_state<_CharT> base; base* __second_; public: _LIBCPP_INLINE_VISIBILITY explicit __owns_two_states(__node<_CharT>* __s1, base* __s2) : base(__s1), __second_(__s2) {} virtual ~__owns_two_states(); _LIBCPP_INLINE_VISIBILITY base* second() const {return __second_;} _LIBCPP_INLINE_VISIBILITY base*& second() {return __second_;} }; template __owns_two_states<_CharT>::~__owns_two_states() { delete __second_; } // __loop template class __loop : public __owns_two_states<_CharT> { typedef __owns_two_states<_CharT> base; size_t __min_; size_t __max_; unsigned __loop_id_; unsigned __mexp_begin_; unsigned __mexp_end_; bool __greedy_; public: typedef _VSTD::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY explicit __loop(unsigned __loop_id, __node<_CharT>* __s1, __owns_one_state<_CharT>* __s2, unsigned __mexp_begin, unsigned __mexp_end, bool __greedy = true, size_t __min = 0, size_t __max = numeric_limits::max()) : base(__s1, __s2), __min_(__min), __max_(__max), __loop_id_(__loop_id), __mexp_begin_(__mexp_begin), __mexp_end_(__mexp_end), __greedy_(__greedy) {} virtual void __exec(__state& __s) const; virtual void __exec_split(bool __second, __state& __s) const; private: _LIBCPP_INLINE_VISIBILITY void __init_repeat(__state& __s) const { __s.__loop_data_[__loop_id_].second = __s.__current_; for (size_t __i = __mexp_begin_-1; __i != __mexp_end_-1; ++__i) { __s.__sub_matches_[__i].first = __s.__last_; __s.__sub_matches_[__i].second = __s.__last_; __s.__sub_matches_[__i].matched = false; } } }; template void __loop<_CharT>::__exec(__state& __s) const { if (__s.__do_ == __state::__repeat) { bool __do_repeat = ++__s.__loop_data_[__loop_id_].first < __max_; bool __do_alt = __s.__loop_data_[__loop_id_].first >= __min_; if (__do_repeat && __do_alt && __s.__loop_data_[__loop_id_].second == __s.__current_) __do_repeat = false; if (__do_repeat && __do_alt) __s.__do_ = __state::__split; else if (__do_repeat) { __s.__do_ = __state::__accept_but_not_consume; __s.__node_ = this->first(); __init_repeat(__s); } else { __s.__do_ = __state::__accept_but_not_consume; __s.__node_ = this->second(); } } else { __s.__loop_data_[__loop_id_].first = 0; bool __do_repeat = 0 < __max_; bool __do_alt = 0 >= __min_; if (__do_repeat && __do_alt) __s.__do_ = __state::__split; else if (__do_repeat) { __s.__do_ = __state::__accept_but_not_consume; __s.__node_ = this->first(); __init_repeat(__s); } else { __s.__do_ = __state::__accept_but_not_consume; __s.__node_ = this->second(); } } } template void __loop<_CharT>::__exec_split(bool __second, __state& __s) const { __s.__do_ = __state::__accept_but_not_consume; if (__greedy_ != __second) { __s.__node_ = this->first(); __init_repeat(__s); } else __s.__node_ = this->second(); } // __alternate template class __alternate : public __owns_two_states<_CharT> { typedef __owns_two_states<_CharT> base; public: typedef _VSTD::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY explicit __alternate(__owns_one_state<_CharT>* __s1, __owns_one_state<_CharT>* __s2) : base(__s1, __s2) {} virtual void __exec(__state& __s) const; virtual void __exec_split(bool __second, __state& __s) const; }; template void __alternate<_CharT>::__exec(__state& __s) const { __s.__do_ = __state::__split; } template void __alternate<_CharT>::__exec_split(bool __second, __state& __s) const { __s.__do_ = __state::__accept_but_not_consume; if (__second) __s.__node_ = this->second(); else __s.__node_ = this->first(); } // __begin_marked_subexpression template class __begin_marked_subexpression : public __owns_one_state<_CharT> { typedef __owns_one_state<_CharT> base; unsigned __mexp_; public: typedef _VSTD::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY explicit __begin_marked_subexpression(unsigned __mexp, __node<_CharT>* __s) : base(__s), __mexp_(__mexp) {} virtual void __exec(__state&) const; }; template void __begin_marked_subexpression<_CharT>::__exec(__state& __s) const { __s.__do_ = __state::__accept_but_not_consume; __s.__sub_matches_[__mexp_-1].first = __s.__current_; __s.__node_ = this->first(); } // __end_marked_subexpression template class __end_marked_subexpression : public __owns_one_state<_CharT> { typedef __owns_one_state<_CharT> base; unsigned __mexp_; public: typedef _VSTD::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY explicit __end_marked_subexpression(unsigned __mexp, __node<_CharT>* __s) : base(__s), __mexp_(__mexp) {} virtual void __exec(__state&) const; }; template void __end_marked_subexpression<_CharT>::__exec(__state& __s) const { __s.__do_ = __state::__accept_but_not_consume; __s.__sub_matches_[__mexp_-1].second = __s.__current_; __s.__sub_matches_[__mexp_-1].matched = true; __s.__node_ = this->first(); } // __back_ref template class __back_ref : public __owns_one_state<_CharT> { typedef __owns_one_state<_CharT> base; unsigned __mexp_; public: typedef _VSTD::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY explicit __back_ref(unsigned __mexp, __node<_CharT>* __s) : base(__s), __mexp_(__mexp) {} virtual void __exec(__state&) const; }; template void __back_ref<_CharT>::__exec(__state& __s) const { if (__mexp_ > __s.__sub_matches_.size()) __throw_regex_error(); sub_match& __sm = __s.__sub_matches_[__mexp_-1]; if (__sm.matched) { ptrdiff_t __len = __sm.second - __sm.first; if (__s.__last_ - __s.__current_ >= __len && _VSTD::equal(__sm.first, __sm.second, __s.__current_)) { __s.__do_ = __state::__accept_but_not_consume; __s.__current_ += __len; __s.__node_ = this->first(); } else { __s.__do_ = __state::__reject; __s.__node_ = nullptr; } } else { __s.__do_ = __state::__reject; __s.__node_ = nullptr; } } // __back_ref_icase template class __back_ref_icase : public __owns_one_state<_CharT> { typedef __owns_one_state<_CharT> base; _Traits __traits_; unsigned __mexp_; public: typedef _VSTD::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY explicit __back_ref_icase(const _Traits& __traits, unsigned __mexp, __node<_CharT>* __s) : base(__s), __traits_(__traits), __mexp_(__mexp) {} virtual void __exec(__state&) const; }; template void __back_ref_icase<_CharT, _Traits>::__exec(__state& __s) const { sub_match& __sm = __s.__sub_matches_[__mexp_-1]; if (__sm.matched) { ptrdiff_t __len = __sm.second - __sm.first; if (__s.__last_ - __s.__current_ >= __len) { for (ptrdiff_t __i = 0; __i < __len; ++__i) { if (__traits_.translate_nocase(__sm.first[__i]) != __traits_.translate_nocase(__s.__current_[__i])) goto __not_equal; } __s.__do_ = __state::__accept_but_not_consume; __s.__current_ += __len; __s.__node_ = this->first(); } else { __s.__do_ = __state::__reject; __s.__node_ = nullptr; } } else { __not_equal: __s.__do_ = __state::__reject; __s.__node_ = nullptr; } } // __back_ref_collate template class __back_ref_collate : public __owns_one_state<_CharT> { typedef __owns_one_state<_CharT> base; _Traits __traits_; unsigned __mexp_; public: typedef _VSTD::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY explicit __back_ref_collate(const _Traits& __traits, unsigned __mexp, __node<_CharT>* __s) : base(__s), __traits_(__traits), __mexp_(__mexp) {} virtual void __exec(__state&) const; }; template void __back_ref_collate<_CharT, _Traits>::__exec(__state& __s) const { sub_match& __sm = __s.__sub_matches_[__mexp_-1]; if (__sm.matched) { ptrdiff_t __len = __sm.second - __sm.first; if (__s.__last_ - __s.__current_ >= __len) { for (ptrdiff_t __i = 0; __i < __len; ++__i) { if (__traits_.translate(__sm.first[__i]) != __traits_.translate(__s.__current_[__i])) goto __not_equal; } __s.__do_ = __state::__accept_but_not_consume; __s.__current_ += __len; __s.__node_ = this->first(); } else { __s.__do_ = __state::__reject; __s.__node_ = nullptr; } } else { __not_equal: __s.__do_ = __state::__reject; __s.__node_ = nullptr; } } // __word_boundary template class __word_boundary : public __owns_one_state<_CharT> { typedef __owns_one_state<_CharT> base; _Traits __traits_; bool __invert_; public: typedef _VSTD::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY explicit __word_boundary(const _Traits& __traits, bool __invert, __node<_CharT>* __s) : base(__s), __traits_(__traits), __invert_(__invert) {} virtual void __exec(__state&) const; }; template void __word_boundary<_CharT, _Traits>::__exec(__state& __s) const { bool __is_word_b = false; if (__s.__first_ != __s.__last_) { if (__s.__current_ == __s.__last_) { if (!(__s.__flags_ & regex_constants::match_not_eow)) { _CharT __c = __s.__current_[-1]; __is_word_b = __c == '_' || __traits_.isctype(__c, ctype_base::alnum); } } else if (__s.__current_ == __s.__first_ && !(__s.__flags_ & regex_constants::match_prev_avail)) { if (!(__s.__flags_ & regex_constants::match_not_bow)) { _CharT __c = *__s.__current_; __is_word_b = __c == '_' || __traits_.isctype(__c, ctype_base::alnum); } } else { _CharT __c1 = __s.__current_[-1]; _CharT __c2 = *__s.__current_; bool __is_c1_b = __c1 == '_' || __traits_.isctype(__c1, ctype_base::alnum); bool __is_c2_b = __c2 == '_' || __traits_.isctype(__c2, ctype_base::alnum); __is_word_b = __is_c1_b != __is_c2_b; } } if (__is_word_b != __invert_) { __s.__do_ = __state::__accept_but_not_consume; __s.__node_ = this->first(); } else { __s.__do_ = __state::__reject; __s.__node_ = nullptr; } } // __l_anchor template _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR bool __is_eol(_CharT c) { return c == '\r' || c == '\n'; } template class __l_anchor_multiline : public __owns_one_state<_CharT> { typedef __owns_one_state<_CharT> base; bool __multiline_; public: typedef _VSTD::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY __l_anchor_multiline(bool __multiline, __node<_CharT>* __s) : base(__s), __multiline_(__multiline) {} virtual void __exec(__state&) const; }; template void __l_anchor_multiline<_CharT>::__exec(__state& __s) const { if (__s.__at_first_ && __s.__current_ == __s.__first_ && !(__s.__flags_ & regex_constants::match_not_bol)) { __s.__do_ = __state::__accept_but_not_consume; __s.__node_ = this->first(); } else if (__multiline_ && !__s.__at_first_ && __is_eol(*_VSTD::prev(__s.__current_))) { __s.__do_ = __state::__accept_but_not_consume; __s.__node_ = this->first(); } else { __s.__do_ = __state::__reject; __s.__node_ = nullptr; } } // __r_anchor template class __r_anchor_multiline : public __owns_one_state<_CharT> { typedef __owns_one_state<_CharT> base; bool __multiline; public: typedef _VSTD::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY __r_anchor_multiline(bool __multiline, __node<_CharT>* __s) : base(__s), __multiline(__multiline) {} virtual void __exec(__state&) const; }; template void __r_anchor_multiline<_CharT>::__exec(__state& __s) const { if (__s.__current_ == __s.__last_ && !(__s.__flags_ & regex_constants::match_not_eol)) { __s.__do_ = __state::__accept_but_not_consume; __s.__node_ = this->first(); } else if (__multiline && __is_eol(*__s.__current_)) { __s.__do_ = __state::__accept_but_not_consume; __s.__node_ = this->first(); } else { __s.__do_ = __state::__reject; __s.__node_ = nullptr; } } // __match_any template class __match_any : public __owns_one_state<_CharT> { typedef __owns_one_state<_CharT> base; public: typedef _VSTD::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY __match_any(__node<_CharT>* __s) : base(__s) {} virtual void __exec(__state&) const; }; template void __match_any<_CharT>::__exec(__state& __s) const { if (__s.__current_ != __s.__last_ && *__s.__current_ != 0) { __s.__do_ = __state::__accept_and_consume; ++__s.__current_; __s.__node_ = this->first(); } else { __s.__do_ = __state::__reject; __s.__node_ = nullptr; } } // __match_any_but_newline template class __match_any_but_newline : public __owns_one_state<_CharT> { typedef __owns_one_state<_CharT> base; public: typedef _VSTD::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY __match_any_but_newline(__node<_CharT>* __s) : base(__s) {} virtual void __exec(__state&) const; }; template <> _LIBCPP_FUNC_VIS void __match_any_but_newline::__exec(__state&) const; template <> _LIBCPP_FUNC_VIS void __match_any_but_newline::__exec(__state&) const; // __match_char template class __match_char : public __owns_one_state<_CharT> { typedef __owns_one_state<_CharT> base; _CharT __c_; __match_char(const __match_char&); __match_char& operator=(const __match_char&); public: typedef _VSTD::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY __match_char(_CharT __c, __node<_CharT>* __s) : base(__s), __c_(__c) {} virtual void __exec(__state&) const; }; template void __match_char<_CharT>::__exec(__state& __s) const { if (__s.__current_ != __s.__last_ && *__s.__current_ == __c_) { __s.__do_ = __state::__accept_and_consume; ++__s.__current_; __s.__node_ = this->first(); } else { __s.__do_ = __state::__reject; __s.__node_ = nullptr; } } // __match_char_icase template class __match_char_icase : public __owns_one_state<_CharT> { typedef __owns_one_state<_CharT> base; _Traits __traits_; _CharT __c_; __match_char_icase(const __match_char_icase&); __match_char_icase& operator=(const __match_char_icase&); public: typedef _VSTD::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY __match_char_icase(const _Traits& __traits, _CharT __c, __node<_CharT>* __s) : base(__s), __traits_(__traits), __c_(__traits.translate_nocase(__c)) {} virtual void __exec(__state&) const; }; template void __match_char_icase<_CharT, _Traits>::__exec(__state& __s) const { if (__s.__current_ != __s.__last_ && __traits_.translate_nocase(*__s.__current_) == __c_) { __s.__do_ = __state::__accept_and_consume; ++__s.__current_; __s.__node_ = this->first(); } else { __s.__do_ = __state::__reject; __s.__node_ = nullptr; } } // __match_char_collate template class __match_char_collate : public __owns_one_state<_CharT> { typedef __owns_one_state<_CharT> base; _Traits __traits_; _CharT __c_; __match_char_collate(const __match_char_collate&); __match_char_collate& operator=(const __match_char_collate&); public: typedef _VSTD::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY __match_char_collate(const _Traits& __traits, _CharT __c, __node<_CharT>* __s) : base(__s), __traits_(__traits), __c_(__traits.translate(__c)) {} virtual void __exec(__state&) const; }; template void __match_char_collate<_CharT, _Traits>::__exec(__state& __s) const { if (__s.__current_ != __s.__last_ && __traits_.translate(*__s.__current_) == __c_) { __s.__do_ = __state::__accept_and_consume; ++__s.__current_; __s.__node_ = this->first(); } else { __s.__do_ = __state::__reject; __s.__node_ = nullptr; } } // __bracket_expression template class __bracket_expression : public __owns_one_state<_CharT> { typedef __owns_one_state<_CharT> base; typedef typename _Traits::string_type string_type; _Traits __traits_; vector<_CharT> __chars_; vector<_CharT> __neg_chars_; vector > __ranges_; vector > __digraphs_; vector __equivalences_; typename regex_traits<_CharT>::char_class_type __mask_; typename regex_traits<_CharT>::char_class_type __neg_mask_; bool __negate_; bool __icase_; bool __collate_; bool __might_have_digraph_; __bracket_expression(const __bracket_expression&); __bracket_expression& operator=(const __bracket_expression&); public: typedef _VSTD::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY __bracket_expression(const _Traits& __traits, __node<_CharT>* __s, bool __negate, bool __icase, bool __collate) : base(__s), __traits_(__traits), __mask_(), __neg_mask_(), __negate_(__negate), __icase_(__icase), __collate_(__collate), __might_have_digraph_(__traits_.getloc().name() != "C") {} virtual void __exec(__state&) const; _LIBCPP_INLINE_VISIBILITY bool __negated() const {return __negate_;} _LIBCPP_INLINE_VISIBILITY void __add_char(_CharT __c) { if (__icase_) __chars_.push_back(__traits_.translate_nocase(__c)); else if (__collate_) __chars_.push_back(__traits_.translate(__c)); else __chars_.push_back(__c); } _LIBCPP_INLINE_VISIBILITY void __add_neg_char(_CharT __c) { if (__icase_) __neg_chars_.push_back(__traits_.translate_nocase(__c)); else if (__collate_) __neg_chars_.push_back(__traits_.translate(__c)); else __neg_chars_.push_back(__c); } _LIBCPP_INLINE_VISIBILITY void __add_range(string_type __b, string_type __e) { if (__collate_) { if (__icase_) { for (size_t __i = 0; __i < __b.size(); ++__i) __b[__i] = __traits_.translate_nocase(__b[__i]); for (size_t __i = 0; __i < __e.size(); ++__i) __e[__i] = __traits_.translate_nocase(__e[__i]); } else { for (size_t __i = 0; __i < __b.size(); ++__i) __b[__i] = __traits_.translate(__b[__i]); for (size_t __i = 0; __i < __e.size(); ++__i) __e[__i] = __traits_.translate(__e[__i]); } __ranges_.push_back(make_pair( __traits_.transform(__b.begin(), __b.end()), __traits_.transform(__e.begin(), __e.end()))); } else { if (__b.size() != 1 || __e.size() != 1) __throw_regex_error(); if (__icase_) { __b[0] = __traits_.translate_nocase(__b[0]); __e[0] = __traits_.translate_nocase(__e[0]); } __ranges_.push_back(make_pair(_VSTD::move(__b), _VSTD::move(__e))); } } _LIBCPP_INLINE_VISIBILITY void __add_digraph(_CharT __c1, _CharT __c2) { if (__icase_) __digraphs_.push_back(make_pair(__traits_.translate_nocase(__c1), __traits_.translate_nocase(__c2))); else if (__collate_) __digraphs_.push_back(make_pair(__traits_.translate(__c1), __traits_.translate(__c2))); else __digraphs_.push_back(make_pair(__c1, __c2)); } _LIBCPP_INLINE_VISIBILITY void __add_equivalence(const string_type& __s) {__equivalences_.push_back(__s);} _LIBCPP_INLINE_VISIBILITY void __add_class(typename regex_traits<_CharT>::char_class_type __mask) {__mask_ |= __mask;} _LIBCPP_INLINE_VISIBILITY void __add_neg_class(typename regex_traits<_CharT>::char_class_type __mask) {__neg_mask_ |= __mask;} }; template void __bracket_expression<_CharT, _Traits>::__exec(__state& __s) const { bool __found = false; unsigned __consumed = 0; if (__s.__current_ != __s.__last_) { ++__consumed; if (__might_have_digraph_) { const _CharT* __next = _VSTD::next(__s.__current_); if (__next != __s.__last_) { pair<_CharT, _CharT> __ch2(*__s.__current_, *__next); if (__icase_) { __ch2.first = __traits_.translate_nocase(__ch2.first); __ch2.second = __traits_.translate_nocase(__ch2.second); } else if (__collate_) { __ch2.first = __traits_.translate(__ch2.first); __ch2.second = __traits_.translate(__ch2.second); } if (!__traits_.lookup_collatename(&__ch2.first, &__ch2.first+2).empty()) { // __ch2 is a digraph in this locale ++__consumed; for (size_t __i = 0; __i < __digraphs_.size(); ++__i) { if (__ch2 == __digraphs_[__i]) { __found = true; goto __exit; } } if (__collate_ && !__ranges_.empty()) { string_type __s2 = __traits_.transform(&__ch2.first, &__ch2.first + 2); for (size_t __i = 0; __i < __ranges_.size(); ++__i) { if (__ranges_[__i].first <= __s2 && __s2 <= __ranges_[__i].second) { __found = true; goto __exit; } } } if (!__equivalences_.empty()) { string_type __s2 = __traits_.transform_primary(&__ch2.first, &__ch2.first + 2); for (size_t __i = 0; __i < __equivalences_.size(); ++__i) { if (__s2 == __equivalences_[__i]) { __found = true; goto __exit; } } } if (__traits_.isctype(__ch2.first, __mask_) && __traits_.isctype(__ch2.second, __mask_)) { __found = true; goto __exit; } if (!__traits_.isctype(__ch2.first, __neg_mask_) && !__traits_.isctype(__ch2.second, __neg_mask_)) { __found = true; goto __exit; } goto __exit; } } } // test *__s.__current_ as not a digraph _CharT __ch = *__s.__current_; if (__icase_) __ch = __traits_.translate_nocase(__ch); else if (__collate_) __ch = __traits_.translate(__ch); for (size_t __i = 0; __i < __chars_.size(); ++__i) { if (__ch == __chars_[__i]) { __found = true; goto __exit; } } // When there's at least one of __neg_chars_ and __neg_mask_, the set // of "__found" chars is // union(complement(union(__neg_chars_, __neg_mask_)), // other cases...) // // It doesn't make sense to check this when there are no __neg_chars_ // and no __neg_mask_. if (!(__neg_mask_ == 0 && __neg_chars_.empty())) { const bool __in_neg_mask = __traits_.isctype(__ch, __neg_mask_); const bool __in_neg_chars = _VSTD::find(__neg_chars_.begin(), __neg_chars_.end(), __ch) != __neg_chars_.end(); if (!(__in_neg_mask || __in_neg_chars)) { __found = true; goto __exit; } } if (!__ranges_.empty()) { string_type __s2 = __collate_ ? __traits_.transform(&__ch, &__ch + 1) : string_type(1, __ch); for (size_t __i = 0; __i < __ranges_.size(); ++__i) { if (__ranges_[__i].first <= __s2 && __s2 <= __ranges_[__i].second) { __found = true; goto __exit; } } } if (!__equivalences_.empty()) { string_type __s2 = __traits_.transform_primary(&__ch, &__ch + 1); for (size_t __i = 0; __i < __equivalences_.size(); ++__i) { if (__s2 == __equivalences_[__i]) { __found = true; goto __exit; } } } if (__traits_.isctype(__ch, __mask_)) { __found = true; goto __exit; } } else __found = __negate_; // force reject __exit: if (__found != __negate_) { __s.__do_ = __state::__accept_and_consume; __s.__current_ += __consumed; __s.__node_ = this->first(); } else { __s.__do_ = __state::__reject; __s.__node_ = nullptr; } } template class __lookahead; template > class _LIBCPP_TEMPLATE_VIS basic_regex; typedef basic_regex regex; typedef basic_regex